Linux进程通信之mmap

mmap()函数：

void *mmap(void* addr,size_t length,int port,int flags,int fd,off_t offset);

返回：成功：返回创建的映射区首地址；失败：MAP_FAILED 宏

参数：

       addr:      建立映射区的首地址，由linux内核决定。使用时直接传递NULL；

       length:   欲创建映射区的大小

       port：    映射区权限PROT _READ、PROT_WRITE 、PROT _READ|PROTWRITE

       flags：   标志位参数（常用于设定更新物理区域、设置共享、创建匿名映射区）

                     MAP_SHARED:     会将映射区所做的操作反射到物理设备上

                     MAP_PRIVATE:     映射区所作的修改不会反映到物理设备。

       fd：       用来建立映射区的文件描述符

       offset：  映射文件的偏移（4K的整数倍）

/***
mmap.c
***/
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/mman.h>int main()
{int len,ret;char *p = NULL;int fd = open("mytest.txt",O_CREAT|O_RDWR,0644);if(fd < 0 ){perror("open error:");exit(1);}len = ftruncate(fd,4);if(-1 == len){perror("ftruncate  error:");exit(1);}p = mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);if(p == MAP_FAILED){perror("mmap error:");exit(1);}strcpy(p,"abc");ret = munmap(p,4);if(-1 == ret){perror("mmap error:");exit(1);} close(fd);return 0;
}

运行结果：

ubuntu1604@ubuntu:~/wangqinghe/linux/20190807$ gcc mmap.c -o mmap

ubuntu1604@ubuntu:~/wangqinghe/linux/20190807$ ./mmap

ubuntu1604@ubuntu:~/wangqinghe/linux/20190807$ cat mytest.txt

abc

mmap在使用过程中注意以下事项：

  1. 创建映射区的过程中，隐含着一次对映射文件的读操作。
  2. 当MAP_SHARED时，要求：映射区的权限  <= 文件打开的权限（出于对映射区的保护）。而MAP_PRIVATE则无所谓，因为mmap中的权限时对内存的限制。
  3. 映射区的释放和文件关闭无关。只要映射成功，文件可以立刻关闭。
  4. 特别注意：当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须有实际大小。mmap使用时常常会出现总线错误，通常是因为共享文件存储空间大小所引起的。
  5. munmap传入的地址一定是mmap的返回地址，坚决杜绝指针++操作
  6. 如果使用文件偏移，则值必须是4K的整数倍
  7. mmap创建映射区出错概率极高，一定要检查返回值，确保映射区建立成功再进行后续操作。

 

mmap父子进程间通信：

文件inode属性

struct stat

{

       存储指针地址；

       大小；

       权限；

       类型；

       所以者；

}

/***
mmap_fork.c
***/
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<sys/wait.h>int var = 100;int main()
{int *p;pid_t pid;int fd;fd = open("temp",O_RDWR|O_CREAT|O_TRUNC,0644);if(fd < 0){perror("open error");exit(1);}unlink("temp");ftruncate(fd,4);p = (int*)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);if(p == MAP_FAILED){perror("mmap error");exit(1);}close(fd);pid = fork();if(0 == pid){*p = 2000;var = 1000;printf("child, *p = %d, var = %d\n",*p,var);}else{sleep(1);printf("parent, *p = %d, var = %d\n",*p,var);wait(NULL);int ret = munmap(p,4);if(-1 == ret){perror("munmap error");exit(1);}}return 0;
}

运行结果：

ubuntu1604@ubuntu:~/wangqinghe/linux/20190807$ gcc mmap_fork.c -o mmap_fork

ubuntu1604@ubuntu:~/wangqinghe/linux/20190807$ ./mmap_fork

child, *p = 2000, var = 1000

parent, *p = 2000, var = 100

 

mmap创建匿名映射区

/***
fork_mmap_linux.c
***/
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<sys/wait.h>int var = 100;int main()
{int *p;pid_t pid;p = (int*)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED | MAP_ANON,-1,0);if(p == MAP_FAILED){perror("mmap error");exit(1);}pid = fork();if(0 == pid){var = 1000;*p = 2000;printf("child, *p = %d,var = %d\n",*p,var);}else{sleep(1);//    printf("parent,*p = %d\n",*p);printf("child, *p = %d,var = %d\n",*p,var);wait(NULL);int ret = munmap(p,4);if(-1 == ret){perror("munmap error");exit(1);}}return 0;
}

运行结果：

ubuntu1604@ubuntu:~/wangqinghe/linux/20190807$ gcc fork_map_linux.c -o fork_map_linux

ubuntu1604@ubuntu:~/wangqinghe/linux/20190807$ ./fork_map_linux

child, *p = 2000,var = 1000

child, *p = 2000,var = 100

 

注意：MAP_ANONYMOUS和MAP_ANON 这两个宏是linux操作系统特有的宏，再类Unix系统中如无该宏的定义，可以使用以下步骤来完成匿名映射区的建立。

  1. fd = open(“/dev/zero”,O_RDWR);
  2. p = mmap(NULL,size,PROT_READ|PROT_WRITE,MMAP_SHARED,fd,0);
/***
fork_map_anon.c
***/
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<sys/wait.h>int var = 100;int main()
{int *p;pid_t pid;int fd = open("/dev/zero",O_RDWR);p = (int*)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);if(p == MAP_FAILED){perror("mmap error");exit(1);}pid = fork();if(0 == pid){var = 1000;*p = 2000;printf("child, *p = %d,var = %d\n",*p,var);}else{sleep(1);//    printf("parent,*p = %d\n",*p);printf("child, *p = %d,var = %d\n",*p,var);wait(NULL);int ret = munmap(p,4);if(-1 == ret){perror("munmap error");exit(1);}}return 0;
}

运行结果：

buntu1604@ubuntu:~/wangqinghe/linux/20190807$ gcc fork_map.c -o fork_map

ubuntu1604@ubuntu:~/wangqinghe/linux/20190807$ ./fork_map

child, *p = 2000,var = 1000

child, *p = 2000,var = 100

 

mmap无血缘关系进程间通信：

/***
mmap_w.c
***/
#include<stdio.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/mman.h>
#include<string.h>struct STU
{int id;char name[20];char sex;
};void sys_err(char *str)
{perror(str);exit(1);
}int main(int argc,char ** argv)
{int fd;struct STU student = {10,"xiaoming",'m'};char *mm;if(argc < 2){printf("./a.out file_shared\n");exit(-1);}fd = open(argv[1],O_RDWR | O_CREAT,0664);ftruncate(fd,sizeof(student));mm = mmap(NULL,sizeof(student),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);if(mm == MAP_FAILED){sys_err("mmap error");}close(fd);while(1){memcpy(mm,&student,sizeof(student));student.id++;sleep(2);}munmap(mm,sizeof(student));return 0;
}
/***
mmap_r.c
***/
#include<stdio.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/mman.h>
#include<string.h>struct STU
{int id;char name[20];char sex;
};void sys_err(char *str)
{perror(str);exit(1);
}int main(int argc,char ** argv)
{int fd;struct STU student;struct STU *mm;if(argc < 2){printf("./a.out file_shared\n");exit(-1);}fd = open(argv[1],O_RDONLY);if(-1 == fd)sys_err("open error");mm = mmap(NULL,sizeof(student),PROT_READ,MAP_SHARED,fd,0);if(mm == MAP_FAILED){sys_err("mmap error");}close(fd);while(1){printf("id=%d,name = %s,%c\n",mm->id,mm->name,mm->sex);sleep(2);}munmap(mm,sizeof(student));return 0;
}

 

转载于:https://www.cnblogs.com/wanghao-boke/p/11317614.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/384891.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Linux之文件通信

Linux之文件通信

/** 后执行,尝试读取另外一个进程写入文件的内容*/ #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <fcntl.h> #include <string.h>int main(void) {char buf[1024];char *str "----------test2 write secesuss---…
阅读更多...
重载函数和重载运算符

重载函数和重载运算符

C允许在同一个作用域中的某个函数和运算符指定多个定义&#xff0c;分别称为函数重载和运算符重载。 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明&#xff0c;但他们的参数列表和定义&#xff08;实现&#xff09;不相同。 当调用一个重载函数…
阅读更多...
二元运算符重载

二元运算符重载

以非成员函数方式重载运算符 /*** overtwo.cpp ***/ #include<iostream> using namespace std;class Box {public:Box(double l 2.0,double b 2.0,double h 2.0){length l;breadth b;height h;}double getVolume(){return length*breadth*height;}private:double l…
阅读更多...
一元运算符重载

一元运算符重载

一元运算符只对一个操作数进行操作&#xff0c;下面是一元运算符实例&#xff1a; 递增运算符&#xff08;&#xff09; 和递减运算符&#xff08;--&#xff09;一元减运算符&#xff0c;即符号&#xff08;-&#xff09;逻辑非运算符&#xff08;!&#xff09;/*** overone.c…
阅读更多...
关系运算符重载

关系运算符重载

C语言支持各种关系运算符重载(<,>,>,<,)&#xff0c;他们可用于比较C内置的数据类型。 支持重载任意一个关系运算符&#xff0c;重载后的关系运算符可以用于比较类的对象。 /*** overrealate.cpp ***/ #include<iostream> using namespace std;class Distanc…
阅读更多...
kill函数

kill函数

kill函数/命令产生信号 kill命令产生信号&#xff1a;kill -SIGKILL pid kill函数&#xff1a;给指定进程发送指定信号(不一定杀死) int kill(pid_t pid, int sig); 成功&#xff1a;0&#xff1b;失败&#xff1a;-1 (ID非法&#xff0c;信号非法&#xff0c;普通用户杀i…
阅读更多...
下标运算符重载

下标运算符重载

重载该运算符用于增强操作C数组的功能。 /*** subscript.cpp ***/ #include<iostream> using namespace std; const int SIZE 10;class safearay {private:int arr[SIZE];public:safearay(){register int i;for(i 0; i < SIZE ;i){arr[i] i;} }int& operator…
阅读更多...
赋值运算符重载

赋值运算符重载

重载赋值运算符&#xff08;&#xff09;&#xff0c;用于创建一个对象&#xff0c;比如拷贝构造函数。 /*** evaluate.cpp ***/ #include<iostream> using namespace std;class Distance {private:int feet;int inches;public:Distance(){feet 0;inches 0;}Distance(i…
阅读更多...
运算符小括号重载

运算符小括号重载

函数调用运算符()可以被重用于类的对象。当重载()时&#xff0c;没有创造一个新的调用函数的方式&#xff0c;相反地&#xff0c;这是创建一个可以传递任意数目参数的运算符函数。 /*** bracke.cpp ***/ #include<iostream> using namespace std;class Distance {private…
阅读更多...
自增自减运算符重载

自增自减运算符重载

递增运算符&#xff08;&#xff09;和递减运算符&#xff08;--&#xff09;是C语言中两个重要的一元运算符。 /*** addMyself.cpp ***/ #include<iostream> using namespace std;class Time {private:int hours;int minutes;public:Time(){hours 0;minutes 0;}Time(i…
阅读更多...
输入输出运算符重载

输入输出运算符重载

C能够使用流提取运算符>>和流插入运算符<< 来输入输出内置数据类型&#xff0c;也可以重载流提取运算符和流插入运算符来操作对象等用户自定义的数据类型。 我们有时需要把运算符重载函数声明为类的友元函数&#xff0c;这样我们就能不用构造对象而直接调用函数。 …
阅读更多...
alarm函数

alarm函数

alarm函数 设置定时器(闹钟)。在指定seconds后&#xff0c;内核会给当前进程发送14&#xff09;SIGALRM信号。进程收到该信号&#xff0c;默认动作终止。 每个进程都有且只有唯一个定时器。 unsigned int alarm(unsigned int seconds); 返回0或剩余的秒数&#xff0c;无失败…
阅读更多...
信号捕捉

信号捕捉

signal函数 注册一个信号捕捉函数&#xff1a; typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t handler); 该函数由ANSI定义&#xff0c;由于历史原因在不同版本的Unix和不同版本的Linux中可能有不同的行为。因此应该尽量避免使用它&#x…
阅读更多...
打印未决信号集

打印未决信号集

信号集操作函数 内核通过读取未决信号集来判断信号是否应被处理。信号屏蔽字mask可以影响未决信号集。而我们可以在应用程序中自定义set来改变mask。已达到屏蔽指定信号的目的。 信号集设定 sigset_t set; // typedef unsigned long sigset_t; int sigemptyset(sigset_…
阅读更多...
sigaction（）函数

sigaction（）函数

sigaction函数 修改信号处理动作&#xff08;通常在Linux用其来注册一个信号的捕捉函数&#xff09; int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); 成功&#xff1a;0&#xff1b;失败&#xff1a;-1&#xff0c;设置errno 参数&a…
阅读更多...
内核实现信号捕捉原理

内核实现信号捕捉原理

信号捕捉特性 进程正常运行时&#xff0c;默认PCB中有一个信号屏蔽字&#xff0c;假定为☆&#xff0c;它决定了进程自动屏蔽哪些信号。当注册了某个信号捕捉函数&#xff0c;捕捉到该信号以后&#xff0c;要调用该函数。而该函数有可能执行很长时间&#xff0c;在这期间所屏蔽…
阅读更多...
pause函数

pause函数

pause函数 调用该函数可以造成进程主动挂起&#xff0c;等待信号唤醒。调用该系统调用的进程将处于阻塞状态(主动放弃cpu) 直到有信号递达将其唤醒。 int pause(void); 返回值&#xff1a;-1 并设置errno为EINTR 返回值&#xff1a; ① 如果信号的默认处理动作是终止进程&a…
阅读更多...
SIGCHLD函数

SIGCHLD函数

SIGCHLD的产生条件 子进程终止时 子进程接收到SIGSTOP信号停止时 子进程处在停止态&#xff0c;接受到SIGCONT后唤醒时 借助SIGCHLD信号回收子进程 子进程结束运行&#xff0c;其父进程会收到SIGCHLD信号。该信号的默认处理动作是忽略。可以捕捉该信号&#xff0c;在捕捉函数中…
阅读更多...
成员访问控制符重载

成员访问控制符重载

类成员访问运算符&#xff08;->&#xff09;可以被重载&#xff0c;但它比较麻烦它被定义用于为一个类赋予“指针”行为。运算符->必须是一个成员函数。如果使用了->运算符&#xff0c;返回类型必须是指针或者是类的对象。 运算符->通常与指针引用运算符 * 结合使…
阅读更多...
C++动态内存

C++动态内存

C程序中内存分为两个部分 栈&#xff1a;在函数内部声明的所有变量都将占用栈内存。 堆&#xff1a;这是程序中未使用的内存&#xff0c;在程序中可用于动态分配内存。 在很多时候&#xff0c;我们无法提前预知需要多少内存来存储某个变量的特定信息&#xff0c;所需内存的大小…
阅读更多...
最新文章

Copyright @ 2022~2023