Linux 操作系统 - 内存映射函数-mmap函数

本文主要是介绍Linux 操作系统 - 内存映射函数-mmap函数，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Linux提供了内存映射函数mmap, 它把文件内容映射到一段内存上(准确说是虚拟内存上), 通过对这段内存的读取和修改, 实现对文件的读取和修改, 先来看一下mmap的函数声明:

头文件:
- <unistd.h>
- <sys/mman.h>
原型: void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offsize);
返回值: 成功则返回映射区起始地址, 失败则返回MAP_FAILED(-1).
参数:
- addr: 指定映射的起始地址, 通常设为NULL, 由系统指定.
- length: 将文件的多大长度映射到内存.
- prot: 映射区的保护方式, 可以是:
  - PROT_EXEC: 映射区可被执行.
  - PROT_READ: 映射区可被读取.
  - PROT_WRITE: 映射区可被写入.
  - PROT_NONE: 映射区不能存取.
- flags: 映射区的特性, 可以是:
  - MAP_SHARED: 对映射区域的写入数据会复制回文件, 且允许其他映射该文件的进程共享.
  - MAP_PRIVATE: 对映射区域的写入操作会产生一个映射的复制(copy-on-write), 对此区域所做的修改不会写回原文件.
  - 此外还有其他几个flags不很常用, 具体查看linux C函数说明.
- fd: 由open返回的文件描述符, 代表要映射的文件.
- offset: 以文件开始处的偏移量, 必须是分页大小的整数倍, 通常为0, 表示从文件头开始映射.

下面说一下内存映射的步骤:

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

注意事项:

在修改映射的文件时, 只能在原长度上修改, 不能增加文件长度, 因为内存是已经分配好的.

内存映射，简而言之就是将用户空间的一段内存区域映射到内核空间，映射成功后，用户对这段内存区域的修改可以直接反映到内核空间，相反，内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<---->用户空间两者之间需要大量数据传输等操作的话效率是非常高的。

[cpp]  view plain copy  
 print ? 
 #include <sys/types.h>  
 #include <sys/stat.h>  
 #include <fcntl.h>  
 #include <stdio.h>  
 #include <sys/mman.h>  
 #include <string.h>  
 #include <errno.h>  
 #include <unistd.h>  
   
 /* 
    void *mmap(void *start, size_t length, int prot, int flags,int fd, off_t offset); 
 //该函数把一个文件或一个posix共享内存区对象映射到调用进程的进程。 
 1.start:一般可以为NULL; 
 2.length:映射的字节大小; 
 3.prot:对映射存储的权限访问(PROT_NONE:不可访问;PROT_READ:可读; 
 PROT_WRITE:可写;PROT_EXEC:可执行); 
 4.flags:MAP_FIXED、MAP_SHARED(对内存的操作同样影响文件)、MAP_PRIVATE 
 5.文件描述附 
 6.要偏移的位置(SEEK_SET、SEEK_CUR、SEEK_END) 
  
 int munmap(void *start, size_t length); 
 //该函数用于取消映射 
  */  
   
 #define FILENAME1 "./lhw1"  
 #define FILENAME2 "./lhw2"  
 #define OPEN_FLAG O_RDWR|O_CREAT  
 #define OPEN_MODE 00777  
 #define FILE_SIZE 4096*4  
   
 static int my_mmap(int dst, int src)  
 {  
     int ret = -1;  
     void* add_src = NULL;  
     void* add_dst = NULL;  
     struct stat buf = {0};  
   
     //获取打开文件的详细信息（主要要取得读文件的大小）  
     ret = fstat(src, &buf);  
     if(-1 == ret)  
     {  
         perror("fstat failed: ");  
         goto _OUT;  
     }  
     //映射源文件的存储区  
     add_src = mmap(NULL, buf.st_size, PROT_READ, MAP_SHARED, src, SEEK_SET);  
     if(NULL == add_src)  
     {  
         perror("mmap src failed: ");  
         goto _OUT;  
     }  
   
     //lseek dst（制造文件空洞，使其有一定大小，没有大小会出错)  
     ret = lseek(dst, buf.st_size, SEEK_SET);  
     if(-1 == ret)  
     {  
         perror("lseek dst faile: ");  
         goto _OUT;  
     }  
     //write dst  
     ret = write(dst, "w", 1);  
     if(-1 == ret)  
     {  
         perror("write dst faile: ");  
         goto _OUT;  
     }  
   
     //映射目标文件的存储区  
     add_dst = mmap(NULL, buf.st_size, PROT_WRITE, MAP_SHARED, dst, SEEK_SET);  
     if(NULL == add_dst)  
     {  
         perror("mmap src failed: ");  
         goto _OUT;  
     }  
   
     //memcpy 将源文件内存add_src的内容拷贝到目标文件add_dst，通过内存共享  
     memcpy(add_dst, add_src, buf.st_size);  
       
     //取消映射  
     ret = munmap(add_src, buf.st_size);  
     if(-1 == ret)  
     {  
         perror("munmap src faile: ");  
         goto _OUT;  
     }  
     ret = munmap(add_dst, buf.st_size);  
     if(-1 == ret)  
     {  
         perror("munmap dst faile: ");  
         goto _OUT;  
     }  
   
 _OUT:  
     return ret;  
 }  
   
 int main(void)  
 {  
     int ret = -1;  
     int fd1 = -1;  
     int fd2 = -1;  
   
     //open fd1  
     fd1 = open(FILENAME1, OPEN_FLAG, OPEN_MODE);  
     if(-1 == (ret = fd1))  
     {  
         perror("open fd1 failed: ");  
         goto _OUT;  
     }  
     //write fd1  
     ret = write(fd1, "howaylee", sizeof("howaylee"));  
     if(-1 == ret)  
     {  
         perror("write failed: ");  
         goto _OUT;  
     }  
     //open fd2  
     fd2 = open(FILENAME2, OPEN_FLAG, OPEN_MODE);  
     if(-1 == (ret = fd2))  
     {  
         perror("open fd2 failed: ");  
         goto _OUT;  
     }  
     //mmap  
     my_mmap(fd2, fd1);  
   
 _OUT:     
     return ret;  
 }  

mmap将一个文件或者其它对象映射进内存。文件被映射到多个页上，如果文件的大小不是所有页的大小之和，最后一个页不被使用的空间将会清零。mmap在用户空间映射调用系统中作用很大。
头文件 <sys/mman.h>
函数原型
void* mmap(void* start,size_t length,int prot,int flags,int fd,off_t offset);

int munmap(void* start,size_t length);

mmap()[1] 必须以PAGE_SIZE为单位进行映射，而内存也只能以页为单位进行映射，若要映射非PAGE_SIZE整数倍的地址范围，要先进行内存对齐，强行以PAGE_SIZE的倍数大小进行映射。

用法:

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

UNIX网络编程第二卷进程间通信对mmap函数进行了说明。该函数主要用途有三个：
1、将一个普通文件映射到内存中，通常在需要对文件进行频繁读写时使用，这样用内存读写取代I/O读写，以获得较高的性能；
2、将特殊文件进行匿名内存映射，可以为关联进程提供共享内存空间；
3、为无关联的进程提供共享内存空间，一般也是将一个普通文件映射到内存中。

函数：void *mmap(void *start,size_t length,int prot,int flags,int fd,off_t offsize);
参数start：指向欲映射的内存起始地址，通常设为 NULL，代表让系统自动选定地址，映射成功后返回该地址。

参数length：代表将文件中多大的部分映射到内存。

参数prot：映射区域的保护方式。可以为以下几种方式的组合：
PROT_EXEC 映射区域可被执行
PROT_READ 映射区域可被读取
PROT_WRITE 映射区域可被写入
PROT_NONE 映射区域不能存取

参数flags：影响映射区域的各种特性。在调用mmap()时必须要指定MAP_SHARED 或MAP_PRIVATE。
MAP_FIXED 如果参数start所指的地址无法成功建立映射时，则放弃映射，不对地址做修正。通常不鼓励用此旗标。
MAP_SHARED对映射区域的写入数据会复制回文件内，而且允许其他映射该文件的进程共享。
MAP_PRIVATE 对映射区域的写入操作会产生一个映射文件的复制，即私人的“写入时复制”（copy on write）对此区域作的任何修改都不会写回原来的文件内容。
MAP_ANONYMOUS建立匿名映射。此时会忽略参数fd，不涉及文件，而且映射区域无法和其他进程共享。
MAP_DENYWRITE只允许对映射区域的写入操作，其他对文件直接写入的操作将会被拒绝。
MAP_LOCKED 将映射区域锁定住，这表示该区域不会被置换（swap）。

参数fd：要映射到内存中的文件描述符。如果使用匿名内存映射时，即flags中设置了MAP_ANONYMOUS，fd设为-1。有些系统不支持匿名内存映射，则可以使用fopen打开/dev/zero文件，然后对该文件进行映射，可以同样达到匿名内存映射的效果。

参数offset：文件映射的偏移量，通常设置为0，代表从文件最前方开始对应，offset必须是分页大小的整数倍。

返回值：

若映射成功则返回映射区的内存起始地址，否则返回MAP_FAILED(－1)，错误原因存于errno 中。

错误代码：

EBADF 参数fd 不是有效的文件描述词
EACCES 存取权限有误。如果是MAP_PRIVATE 情况下文件必须可读，使用MAP_SHARED则要有PROT_WRITE以及该文件要能写入。
EINVAL 参数start、length 或offset有一个不合法。
EAGAIN 文件被锁住，或是有太多内存被锁住。
ENOMEM 内存不足。

系统调用mmap()用于共享内存的两种方式：
（1）使用普通文件提供的内存映射：

适用于任何进程之间。此时，需要打开或创建一个文件，然后再调用mmap()

典型调用代码如下：

fd=open(name, flag, mode); if(fd<0) ...

ptr=mmap(NULL, len , PROT_READ|PROT_WRITE, MAP_SHARED , fd , 0);

通过mmap()实现共享内存的通信方式有许多特点和要注意的地方，可以参看UNIX网络编程第二卷。

（2）使用特殊文件提供匿名内存映射：

适用于具有亲缘关系的进程之间。由于父子进程特殊的亲缘关系，在父进程中先调用mmap()，然后调用 fork()。那么在调用fork()之后，子进程继承父进程匿名映射后的地址空间，同样也继承mmap()返回的地址，这样，父子进程就可以通过映射区域进行通信了。注意，这里不是一般的继承关系。一般来说，子进程单独维护从父进程继承下来的一些变量。而mmap()返回的地址，却由父子进程共同维护。对于具有亲缘关系的进程实现共享内存最好的方式应该是采用匿名内存映射的方式。此时，不必指定具体的文件，只要设置相应的标志即可。

一、概述
内存映射，简而言之就是将用户空间的一段内存区域映射到内核空间，映射成功后，用户对这段内存区域的修改可以直接反映到内核空间，同样，内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<---->用户空间两者之间需要大量数据传输等操作的话效率是非常高的。
以下是一个把普遍文件映射到用户空间的内存区域的示意图。
图一：

二、基本函数
mmap函数是unix/Linux下的系统调用，详细内容可参考《Unix Netword programming》卷二12.2节。
mmap系统调用并不是完全为了用于共享内存而设计的。它本身提供了不同于一般对普通文件的访问方式，进程可以像读写内存一样对普通文件的操作。而Posix或系统V的共享内存IPC则纯粹用于共享目的，当然mmap()实现共享内存也是其主要应用之一。
mmap系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以像访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。mmap并不分配空间, 只是将文件映射到调用进程的地址空间里（但是会占掉你的 virutal memory）, 然后你就可以用memcpy等操作写文件, 而不用write()了.写完后，内存中的内容并不会立即更新到文件中，而是有一段时间的延迟，你可以调用msync()来显式同步一下, 这样你所写的内容就能立即保存到文件里了.这点应该和驱动相关。不过通过mmap来写文件这种方式没办法增加文件的长度, 因为要映射的长度在调用mmap()的时候就决定了.如果想取消内存映射，可以调用munmap()来取消内存映射

[cpp]  view plain copy  
 void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset)  

mmap用于把文件映射到内存空间中，简单说mmap就是把一个文件的内容在内存里面做一个映像。映射成功后，用户对这段内存区域的修改可以直接反映到内核空间，同样，内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<---->用户空间两者之间需要大量数据传输等操作的话效率是非常高的。
start：要映射到的内存区域的起始地址，通常都是用NULL（NULL即为0）。NULL表示由内核来指定该内存地址

length：要映射的内存区域的大小
prot：期望的内存保护标志，不能与文件的打开模式冲突。是以下的某个值，可以通过or运算合理地组合在一起
PROT_EXEC //页内容可以被执行
PROT_READ //页内容可以被读取
PROT_WRITE //页可以被写入
PROT_NONE //页不可访问
flags：指定映射对象的类型，映射选项和映射页是否可以共享。它的值可以是一个或者多个以下位的组合体
MAP_FIXED ：使用指定的映射起始地址，如果由start和len参数指定的内存区重叠于现存的映射空间，重叠部分将会被丢弃。如果指定的起始地址不可用，操作将会失败。并且起始地址必须落在页的边界上。
MAP_SHARED ：对映射区域的写入数据会复制回文件内, 而且允许其他映射该文件的进程共享。
MAP_PRIVATE ：建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件。这个标志和以上标志是互斥的，只能使用其中一个。
MAP_DENYWRITE ：这个标志被忽略。
MAP_EXECUTABLE ：同上
MAP_NORESERVE ：不要为这个映射保留交换空间。当交换空间被保留，对映射区修改的可能会得到保证。当交换空间不被保留，同时内存不足，对映射区的修改会引起段违例信号。
MAP_LOCKED ：锁定映射区的页面，从而防止页面被交换出内存。
MAP_GROWSDOWN ：用于堆栈，告诉内核VM系统，映射区可以向下扩展。
MAP_ANONYMOUS ：匿名映射，映射区不与任何文件关联。
MAP_ANON ：MAP_ANONYMOUS的别称，不再被使用。
MAP_FILE ：兼容标志，被忽略。
MAP_32BIT ：将映射区放在进程地址空间的低2GB，MAP_FIXED指定时会被忽略。当前这个标志只在x86-64平台上得到支持。
MAP_POPULATE ：为文件映射通过预读的方式准备好页表。随后对映射区的访问不会被页违例阻塞。
MAP_NONBLOCK ：仅和MAP_POPULATE一起使用时才有意义。不执行预读，只为已存在于内存中的页面建立页表入口。

fd：文件描述符（由open函数返回）

offset：表示被映射对象（即文件）从那里开始对映，通常都是用0。该值应该为大小为PAGE_SIZE的整数倍

返回说明
成功执行时，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 plain copy  
 int munmap(void *start, size_t length)   

start：要取消映射的内存区域的起始地址
length：要取消映射的内存区域的大小。
返回说明
成功执行时munmap()返回0。失败时munmap返回-1.
int msync(const void *start, size_t length, int flags);

对映射内存的内容的更改并不会立即更新到文件中，而是有一段时间的延迟，你可以调用msync()来显式同步一下, 这样你内存的更新就能立即保存到文件里
start：要进行同步的映射的内存区域的起始地址。
length：要同步的内存区域的大小
flag:flags可以为以下三个值之一：
MS_ASYNC : 请Kernel快将资料写入。
MS_SYNC : 在msync结束返回前，将资料写入。
MS_INVALIDATE : 让核心自行决定是否写入，仅在特殊状况下使用

三、用户空间和驱动程序的内存映射
3.1、基本过程
首先，驱动程序先分配好一段内存，接着用户进程通过库函数mmap()来告诉内核要将多大的内存映射到内核空间，内核经过一系列函数调用后调用对应的驱动程序的file_operation中指定的mmap函数，在该函数中调用remap_pfn_range()来建立映射关系。
3.2、映射的实现
首先在驱动程序分配一页大小的内存，然后用户进程通过mmap()将用户空间中大小也为一页的内存映射到内核空间这页内存上。映射完成后，驱动程序往这段内存写10个字节数据，用户进程将这些数据显示出来。
驱动程序：

[cpp]  view plain copy  
 #include <linux/miscdevice.h>   
 #include <linux/delay.h>   
 #include <linux/kernel.h>   
 #include <linux/module.h>   
 #include <linux/init.h>   
 #include <linux/mm.h>   
 #include <linux/fs.h>   
 #include <linux/types.h>   
 #include <linux/delay.h>   
 #include <linux/moduleparam.h>   
 #include <linux/slab.h>   
 #include <linux/errno.h>   
 #include <linux/ioctl.h>   
 #include <linux/cdev.h>   
 #include <linux/string.h>   
 #include <linux/list.h>   
 #include <linux/pci.h>   
 #include <linux/gpio.h>   
   
   
 #define DEVICE_NAME "mymap"   
   
   
 static unsigned char array[10]={0,1,2,3,4,5,6,7,8,9};   
 static unsigned char *buffer;   
   
   
 static int my_open(struct inode *inode, struct file *file)   
 {   
 return 0;   
 }   
   
   
 static int my_map(struct file *filp, struct vm_area_struct *vma)   
 {   
 unsigned long page;   
 unsigned char i;   
 unsigned long start = (unsigned long)vma->vm_start;   
 //unsigned long end = (unsigned long)vma->vm_end;   
 unsigned long size = (unsigned long)(vma->vm_end - vma->vm_start);   
   
 //得到物理地址   
 page = virt_to_phys(buffer);   
 //将用户空间的一个vma虚拟内存区映射到以page开始的一段连续物理页面上   
 if(remap_pfn_range(vma,start,page>>PAGE_SHIFT,size,PAGE_SHARED))//第三个参数是页帧号，由物理地址右移PAGE_SHIFT得到   
 return -1;   
   
 //往该内存写10字节数据   
 for(i=0;i<10;i++)   
 buffer[i] = array[i];   
   
 return 0;   
 }   
   
   
 static struct file_operations dev_fops = {   
 .owner = THIS_MODULE,   
 .open = my_open,   
 .mmap = my_map,   
 };   
   
 static struct miscdevice misc = {   
 .minor = MISC_DYNAMIC_MINOR,   
 .name = DEVICE_NAME,   
 .fops = &dev_fops,   
 };   
   
   
 static int __init dev_init(void)   
 {   
 int ret;   
   
 //注册混杂设备   
 ret = misc_register(&misc);   
 //内存分配   
 buffer = (unsigned char *)kmalloc(PAGE_SIZE,GFP_KERNEL);   
 //将该段内存设置为保留   
 SetPageReserved(virt_to_page(buffer));   
   
 return ret;   
 }   
   
   
 static void __exit dev_exit(void)   
 {   
 //注销设备   
 misc_deregister(&misc);   
 //清除保留   
 ClearPageReserved(virt_to_page(buffer));   
 //释放内存   
 kfree(buffer);   
 }   
   
   
 module_init(dev_init);   
 module_exit(dev_exit);   
 MODULE_LICENSE("GPL");   
 MODULE_AUTHOR("LKN@SCUT");   

应用程序：

[cpp]  view plain copy  
 #include <unistd.h>   
 #include <stdio.h>   
 #include <stdlib.h>   
 #include <string.h>   
 #include <fcntl.h>   
 #include <linux/fb.h>   
 #include <sys/mman.h>   
 #include <sys/ioctl.h>   
   
 #define PAGE_SIZE 4096   
   
   
 int main(int argc , char *argv[])   
 {   
 int fd;   
 int i;   
 unsigned char *p_map;   
   
 //打开设备   
 fd = open("/dev/mymap",O_RDWR);   
 if(fd < 0)   
 {   
 printf("open fail\n");   
 exit(1);   
 }   
   
 //内存映射   
 p_map = (unsigned char *)mmap(0, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED,fd, 0);   
 if(p_map == MAP_FAILED)   
 {   
 printf("mmap fail\n");   
 goto here;   
 }   
   
 //打印映射后的内存中的前10个字节内容   
 for(i=0;i<10;i++)   
 printf("%d\n",p_map[i]);   
   
   
 here:   
 munmap(p_map, PAGE_SIZE);   
 return 0;   
 }   