mmap共享内存

mmap

存储映射I/O（Memory-mapped I/O）使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据，就相当于读文件中的相应字节。与此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可以在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。

使用这种方法，首先应该通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。

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

参数

addr： 指定映射区的首地址。通常传NULL，表示让系统自动分配。

length： 共享内存映射区的大小

prot：共享内存映射区的读写属性.PROT_READ， PROT_WRITE

flags：MAP_SHARED（内存修改可以直接修改磁盘）, MAP_PRIVATE，标注共享内存的共享属性。

fd： 用于创建共享内存映射区的那个文件的文件描述符。

offset： 偏移位置。必须是4K的整数倍。

返回值

成功： 返回指向映射区的首地址

失败： MAP_FAILED（事实上是(void *)-1）。errno

int munmap(void *addr, size_t length) 释放映射区

参数

addr：mmap的返回值

返回值

成功：0

失败： -1

	#include<stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>
	#include <errno.h>
	#include <pthread.h>
	#include <sys/mman.h>
	#include <fcntl.h>

	void sys_err(const char *str){
		perror(str);
		exit(1);
	}
	
	int main(int argc, char *argv[]){
		char *p = NULL;
		int fd, len;
	
		fd = open("testmap", O_RDWR|O_CREAT|O_TRUNC, 0644);
		if(fd == -1){
			sys_err("open error");
		}
	
		//lseek 扩展文件大小
		//lseek(fd, 10, SEEK_END);
		//write(fd, "\0", 1);
		//ftruncate()
		
		ftruncate(fd, 40);
		len = lseek(fd, 0, SEEK_END);
		p = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
		if(p == MAP_FAILED){
			sys_err("mmap error");
		}
		//使用p对文件进行读写操作
		strcpy(p, "hello mmap");//write
		printf("---------%s\n", p);
	
	    int	ret = munmap(p, len);
		if(ret == -1){
			sys_err("munmap error");
		}
	
		return 0;
	}

结果为：`hello mmap`

注意事项

1、用 0 大小的文件去创建一个 20 大小的映射区，会发生“总线错误”。所有的错误都是信号错误。

2、用 0 大小的文件去创建一个 0 大小的映射区，发生创建失败，无效参数len。

3、用于创建映射区的文件读写属性为读写，ftruncate需要写权限才能扩展文件大小。

4、用于创建映射区的文件读写属性为只读，映射区属性为读写，出“无效参数”。

5、创建映射区需要read权限，mmap的读写权限，需要小于等于文件的open权限。只写是不行的。

6、文件描述符先关闭，即在mmap创建映射区完成即可关闭。后续访问文件，用地址访问。

7、offset必须是4096的整数倍，MMU映射的最小单位是4K。

8、对申请的映射区内存，不能越界访问。

9、munmap用于释放的地址必须是mmap申请返回的地址。

10、映射区访问权限为“私有” MAP_PRIVATE，对内存所作的所有修改，只在内存有限，不体现在磁盘上。

11、映射区访问权限为“私有” MAP_PRIVATE，只需要open文件时，有读权限，用于创建映射区即可。

mmap父子进程通信

父子等有血缘关系的进程之间也可以通过mmap建立的映射区来完成数据通信。但相应的要在创建映射区的时候指定对应的标志位参数flags

MAP_PRIVATE:私有映射，父子进程各独占映射区。

MAP_SHARED:共享映射，父子进程共享映射区。

练习：父进程创建映射区，然后fork子进程，子进程修改映射区内容，而后，父进程读取映射区内容，查验是否共享。

#include<stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <unistd.h>

int var = 100;

int main(void){
	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(pid == 0){
		*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(ret == -1){
			perror("munmap error");
			exit(1);
		}
	}

	return 0;
}

运行结果为：
	
	ymyy@ymyy-virtual-machine:~/systemcode$ ./fork_mmap 
	child, *p = 2000, var = 1000
	parent, *p = 2000, var = 100

实际上，进程之间在共享内存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建立共享内存区域。而是保持共享区域，直到通信完毕为止，这样，数据内容一直保存在共享内存中，并没有写回文件。共享内存中的内容往往是在解除映射时才写回文件的。 int ret = munmap(p, 4); //释放共享内存。因此，采用共享内存的通信方式效率是非常高的。

非血缘关系进程间通信

两个进程打开同一文件，创建映射区。一个进程写入，另一个进程读出。

和fifo的区别：fifo数据只能一次读取，mmap可以重复读取。
下面展示一些 内联代码片。

写端：
	
#include<stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/mman.h>

struct student{
	int id;
	char name[256];
	int age;
};

void sys_err(const char *str){
	perror(str);
	exit(1);
}

int main(){
	int fd;
	pid_t pid;
	struct student *p;
	struct student stu = {
		1, "xiaoming", 18
	};

	fd = open("test_map", O_RDWR|O_CREAT|O_TRUNC, 0644);
	if(fd < 0){
		sys_err("open error");
	}

	ftruncate(fd, sizeof(stu));
	p = mmap(NULL, sizeof(stu), PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
	if(p == MAP_FAILED)
		sys_err("mmap error");
	close(fd);
	
	while(1){
	    memcpy(p, &stu, sizeof(stu));
		stu.id++;
		sleep(1);
	}
	munmap(p, sizeof(stu));

	return 0;
}

读端：

#include<stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/mman.h>

struct student{
	int id;
	char name[256];
	int age;
};

void sys_err(const char *str){
	perror(str);
	exit(1);
}

int main(){
	int fd;
	struct student *p;
	struct student stu; 
	

	fd = open("test_map", O_RDONLY);
	if(fd == -1){
		sys_err("open error");
	}

	p = mmap(NULL, sizeof(stu), PROT_READ, MAP_SHARED, fd, 0);
	if(p == MAP_FAILED)
		sys_err("mmap error");
	close(fd);
	
	while(1){
		printf("---id = %d, name = %s, age = %d\n", p->id, p->name, p->age);
		sleep(1);
	}
	munmap(p, sizeof(stu));

	return 0;
}

运行结果：

ymyy@ymyy-virtual-machine:~/systemcode$ ./mmap_w

ymyy@ymyy-virtual-machine:~/systemcode$ ./mmap_r
---id = 11, name = xiaoming, age = 18
---id = 12, name = xiaoming, age = 18
---id = 13, name = xiaoming, age = 18
---id = 14, name = xiaoming, age = 18
---id = 15, name = xiaoming, age = 18
---id = 16, name = xiaoming, age = 18

mmap匿名映射

利用宏 MAP_ANONYMOUS ，fd处传-1占位。 匿名映射只能用于血缘关系映射，不能用于非血缘关系映射。

p = mmap(NULL, sizeof(stu), PROT_READ, MAP_SHARED|MAP_ANONYMOUS, fd, 0);