mmap内存映射操作

概述：

1.对于mmap的内存映射，是将物理内存映射到进程的虚拟地址空间中去，那么进程对文件的访问就相当于直接对内存的访问，从而加快了读写操作的效率。在这里，remap_pfn_range函数是一次性的建立页表，而nopage函数是根据page fault产生的进程虚拟地址去找到内核相对应的逻辑地址，再通过这个逻辑地址去找到page。完成映射过程。remap_pfn_range不能对常规内存映射，只能对保留的内存与物理内存之外的进行映射。

2.在这里，要分清几个地址，一个是物理地址，这个很简单，就是物理内存的实际地址。第二个是内核虚拟地址，即内核可以直接访问的地址，如kmalloc,vmalloc等内核函数返回的地址，kmalloc返回的地址也称为内核逻辑地址。内核虚拟地址与实际的物理地址只有一个偏移量。第三个是进程虚拟地址，这个地址处于用户空间。而对于mmap函数映射的是物理地址到进程虚拟地址，而不是把物理地址映射到内核虚拟地址。而ioremap函数是将物理地址映射为内核虚拟地址。

3.用户空间的进程调用mmap函数，首先进行必要的处理，生成vma结构体，然后调用remap_pfn_range函数建立页表。而用户空间的mmap函数返回的是映射到进程地址空间的首地址。所以mmap函数与remap_pfn_range函数是不同的，前者只是生成mmap，而建立页表通过remap_pfn_range函数来完成。

在应用层：

#include <sys/mman.h>

prototype : void *mmap(void *start, size_t length, int prot, int flags,  int fd, off_t offset);

                 int munmap(void *start, size_t length);

parameter :

start : 映射区的开始地址。(一般建议为null，让内核帮我们自动寻找一个合适的地址)

length : 映射区的长度。

prot：期望的内存保护标志，不能与文件的打开模式冲突。是以下的某个值，可以通过or运算合理的组合在一起：
                         PROT_EXEC //页内容可以被执行
                         PROT_READ  //页内容可以被读取
                         PROT_WRITE //页可以被写入
                         PROT_NONE  //页不可访问

flags：指定映射对象的类型，映射选项和映射页是否可以共享。它的值可以是一个或者多

                           个以下位的组合体。

                           MAP_SHARED //与其它所有映射这个对象的进程共享映射空间。对共享区的写

                                                 入，相当于输出到文件。直到msync()或者munmap()被调

                                                 用，文件实际上不会被更新。
                           MAP_PRIVATE //建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原

                                                 文件。这个标志和以上标志是互斥的，只能使用其中一个。

                           （还有更多可选参数，具体网上易得）

fd：有效的文件描述词。

offset：被映射对象内容的起点。

return : 返回所映射的虚拟内存首地址。

成功执行时，mmap()返回被映射区的指针，munmap()返回0。失败时，mmap()返回MAP_FAILED[其值为(void *)-1]，munmap返回-1。errno被设为以下的某个值   
EACCES：访问出错
EAGAIN：文件已被锁定，或者太多的内存已被锁定
EBADF：fd不是有效的文件描述词
EINVAL：一个或者多个参数无效
ENFILE：已达到系统对打开文件的限制
ENODEV：指定文件所在的文件系统不支持内存映射
ENOMEM：内存不足，或者进程已超出最大内存映射数量
EPERM：权能不足，操作不允许
ETXTBSY：已写的方式打开文件，同时指定MAP_DENYWRITE标志
SIGSEGV：试着向只读区写入
SIGBUS：试着访问不属于进程的内存区

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include<sys/types.h>  
3. #include<sys/stat.h>  
4. #include<fcntl.h>  
5. #include<unistd.h>  
6. #include<sys/mman.h>  
7.   
8. int main()  
9. {  
10.     int fd;  
11.     char *start;  
12.     char buf[100];  
13.   
14.     /* open the device */  
15.     fd = open("testfile",O_RDWR);  
16.           
17.     start=mmap(NULL,100,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);  
18.       
19.     /* read the data */  
20.     strcpy(buf,start);  
21.     printf("buf = %s/n",buf);      
22.   
23.     /* write data */  
24.     strcpy(start,"Buf Is Not Null!");  
25.       
26.     munmap(start,100); /* unmap */  
27.     close(fd);    
28.       
29.     return 0;      
30. }  

在我测试时，strcpy总是会跑飞，后在网上找到程序：

[cpp] view plaincopy

1. //read.c 读取共享内存中的内容，读取了，内容也存在，跟普通文件一样。  
2. #include <stdio.h>  
3. #include <stdlib.h>  
4. #include <unistd.h>  
5. #include <sys/types.h>  
6. #include <sys/stat.h>  
7. #include <fcntl.h>  
8. #include <sys/mman.h>  
9. #include <string.h>  
10. #include <errno.h>  
11.   
12. #define MAPPED_FILENAME "/tmp/test.mmap.1"  
13. #define BUFFER_SIZE 1024  
14.   
15. int main(int argc, char **argv)  
16. {  
17.  int fd;  
18.    
19.  if (argc < 2)  
20.  {  
21.   fprintf(stdout, "Usage:%s <filename>\n", argv[0]);  
22.   exit(-1);  
23.  }  
24.    
25.  //step 1, open a file and get a fd  
26.  //int open(const char *pathname, int flags, mode_t mode);  
27.  if ((fd = open(argv[1], O_RDWR | O_CREAT, 0644)) <0 )  
28.  {  
29.   if (errno == EEXIST)  
30.   {  
31.    fprintf(stderr, "Fatal error: The target mapped file existed, exit.\n");  
32.   }  
33.   else  
34.   {  
35.    fprintf(stderr, "Error: open file failed: (errno = %d) %s\n", errno, strerror(errno));  
36.   }  
37.   exit(-2);  
38.  }  
39.  off_t offset;  
40.  offset = 1024;  
41.  //step2, create a hole file  
42.  //off_t lseek(int fildes, off_t offset, int whence);  
43.  if (lseek(fd, offset, SEEK_SET) == (off_t) - 1)  
44.  {  
45.   fprintf(stderr, "lseek() failed:%s\n", strerror(errno));  
46.   //FIXME:unlink the file  
47.   close(fd);  
48.   exit(-3);  
49.  }  
50.    
51.  size_t n;  
52.    
53.  //size_t write(int fd, const void *buf, size_t count);  
54.  if ((n = write(fd, "", 1)) < 0)  
55.  {  
56.   fprintf(stderr, "write() failed:%s\n", strerror(errno));  
57.   exit(-4);  
58.  }  
59.    
60.  void *p;  
61.  //step 3, mmap(), get a pointer  
62.  //void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);  
63.  if ((p = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED)  
64.  {  
65.   fprintf(stderr, "mmap() failed:%s\n", strerror(errno));  
66.   close(fd);  
67.   exit(-4);   
68.  }  
69.    
70.  close (fd);  
71.  fprintf(stdout, "mapped file to memory, size=%d\n", 1024);  
72.  char buffer[BUFFER_SIZE];  
73.    
74.  //step 4, read/write on shared memory  
75.  //void *memcpy(void *dest, const void *src, size_t n);  
76.  memcpy(buffer, p+256, 32);    //与read.c不同的地方，反向拷贝  
77.  fprintf(stdout, "%s\n", buffer);  
78.    
79.  //step 5, munmap();  
80.  //int munmap(void *stat, size_t length);  
81.  munmap(p, 1024);  
82.    
83.    
84.  //close(fd);  
85.    
86.  return 0;  
87. }  
88.   
89.    
90.   
91. //write.c 创建共享内存，并写入数据。然后退出程序。  
92. #include <stdio.h>  
93. #include <stdlib.h>  
94. #include <unistd.h>  
95. #include <sys/types.h>  
96. #include <sys/stat.h>  
97. #include <fcntl.h>  
98. #include <sys/mman.h>  
99. #include <string.h>  
100. #include <errno.h>  
101.   
102. #define MAPPED_FILENAME "/tmp/test.mmap.1"  
103.   
104. int main(int argc, char **argv)  
105. {  
106.  int fd;  
107.    
108.  if (argc < 2)  
109.  {  
110.   fprintf(stdout, "Usage:%s <filename>\n", argv[0]);  
111.   exit(-1);  
112.  }  
113.    
114.  //step 1, open a file and get a fd  
115.  //int open(const char *pathname, int flags, mode_t mode);  
116.  if ((fd = open(argv[1], O_RDWR | O_CREAT | O_EXCL, 0644)) <0 )  
117.  {  
118.   if (errno == EEXIST)  
119.   {  
120.    fprintf(stderr, "Fatal error: The target mapped file existed, exit.\n");  
121.   }  
122.   else  
123.   {  
124.    fprintf(stderr, "Error: open file failed: (errno = %d) %s\n", errno, strerror(errno));  
125.   }  
126.   exit(-2);  
127.  }  
128.  off_t offset;  
129.  offset = 1024;  
130.  //step2, create a hole file  
131.  //off_t lseek(int fildes, off_t offset, int whence);  
132.  if (lseek(fd, offset, SEEK_SET) == (off_t) - 1)  
133.  {  
134.   fprintf(stderr, "lseek() failed:%s\n", strerror(errno));  
135.   //FIXME:unlink the file  
136.   close(fd);  
137.   exit(-3);  
138.  }  
139.    
140.  size_t n;  
141.    
142.  //size_t write(int fd, const void *buf, size_t count);  
143.  if ((n = write(fd, "", 1)) < 0)  
144.  {  
145.   fprintf(stderr, "write() failed:%s\n", strerror(errno));  
146.   exit(-4);  
147.  }  
148.    
149.  void *p;  
150.  //step 3, mmap(), get a pointer  
151.  //void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);  
152.  if ((p = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED)  
153.  {  
154.   fprintf(stderr, "mmap() failed:%s\n", strerror(errno));  
155.   close(fd);  
156.   exit(-4);   
157.  }  
158.   
159.  close (fd);  
160.  fprintf(stdout, "mapped file to memory, size=%d\n", 1024);  
161.    
162.    
163.  //step 4, read/write on shared memory  
164.  char *banner = "hello world.";  
165.    
166.  //void *memcpy(void *dest, const void *src, size_t n);  
167.  memset(p, '\0', 1024);  
168.  memcpy(p+256, banner, strlen(banner));  
169.    
170.  //step 5, munmap();  
171.  //int munmap(void *stat, size_t length);  
172.    
173.  return 0;  
174. }  

虽然取出数据，但全是零。

表头文件: #include <string.h>
定义函数: void *memcpy(void *dest, const void *src, size_t n)
函数说明: memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是,memcpy()会完整的复制n个字节,不会因为遇到字符串结束'\0'而结束
返回值:   返回指向dest的指针
附加说明: 指针src和dest所指的内存区域不可重叠。

在内核中：

mmap设备方法是file_operations结构的成员，在Mmap系统调用发出时被调用。在此之前，内核已经完成了很多工作。mmap设备方法所需要做的就是建立虚拟地址到物理地址的页表。

prototype : int (*mmap)(struct file *, struct vm_area_struct *);

parameter: struct file * : 需要操作的文件

                struct vm_area_struct * : 内核自动帮我们找到的一个虚拟内存区域。

return : 虚拟内存区域起始地址

Linux内核使用结构vm_area_struct 来描述虚拟虚拟内存区域，其中几个主要成员如下：

unsigned long vm_start : 虚拟内存区域起始地址

unsinged long vm_end  : 虚拟内存区域结束地址

unsigned long vm_flags : 该区域的标记（能否直接把信息通过虚拟地址存入物理地址等）

 

通过上面的介绍，其实mmap是如何完成页表的建立呢？

方法有两种：

1.使用remap_pfn_range一次建立所有页表

2.使用nopage VMA方法每次建立一个页表

 

我们这里详细介绍方法一。

prototype : int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr,

                                              unsigned long pfn, unsigned long size, pgprot_t prot)

parameter: vma : 虚拟内存区域指针

                addr : 虚拟地址的起始值

                pfn  : 要映射的物理地址的页帧号，即将物理地址右移PAGE_SHIFT（12位），至于为什

                         么是12位，敬请查看《深入理解LINUX内核》内存管理部分

                size : 要映射的区域的大小。

                prot : VMA的保护属性。

return : 返回虚拟内存起始地址。

[cpp] view plaincopy

1. int memdev_mmap(struct file * filp, struct vm_area_struct * vma)  
2. {  
3.     vma -> vm_flags |= VM_IO;  
4.     vma -> vm_flags |= VM_RESERVED;  //设置保护属性  
5.   
6.     if (remap_pfn_range(vma, vma -> vm_start, virt_to_phys(dev -> data) >> PAGE_SHIFT, size, vma -> vm_page_prot))  
7.     {  
8.         return -EAGAIN;  
9.     }  
10.   
11.     return 0;  
12. }  

注意这里的remap_pfn_range函数里的virt_to_phys(dev -> data)，因为例子采用的“设备”其实就是内存，所以需要先转化成物理地址再移位。如果以后我们操作实际的硬件，这里就不用转化了，直接填入物理地址即可。

mmap执行的顺序
a.在用户进程创建一个vma区域
b.驱动程序获得页
c.将获得的页分配给vma区域

内存映射的步骤:
* 用open系统调用打开文件, 并返回描述符fd.
* 用mmap建立内存映射, 并返回映射首地址指针start.
* 对映射(文件)进行各种操作, 显示(printf), 修改(sprintf).
* 用munmap(void *start, size_t lenght)关闭内存映射.
* 用close系统调用关闭文件fd.