linux中mmap系统调用原理分析与实现

墨蓝 2022-07-17 03:52 181阅读 0赞

1、mmap系统调用（功能）  
      void\* mmap ( void \* addr , size\_t len , int prot , int flags ,int fd , off\_t offset )  
      内存映射函数mmap, 负责把文件内容映射到进程的虚拟内存空间, 通过对这段内存的读取和修改，来实现对文件的读取和修改,而不需要再调用read，write等操作。

![1337264541_6409.png][]

2、mmap系统调用（参数）  
      1）addr： 指定映射的起始地址, 通常设为NULL, 由系统指定。  
      2）length: 映射到内存的文件长度。  
      3） prot：   映射区的保护方式, 可以是:  
             PROT\_EXEC: 映射区可被执行  
             PROT\_READ: 映射区可被读取  
             PROT\_WRITE: 映射区可被写入

4）flags: 映射区的特性, 可以是:  
            MAP\_SHARED:写入映射区的数据会复制回文件, 且允许其他映射该文件的进程共享。  
            MAP\_PRIVATE:对映射区的写入操作会产生一个映射区的复制(copy-on-write), 对此区域所做的修改不会写回原文件。

5）fd: 由open返回的文件描述符, 代表要映射的文件。  
      6）offset: 以文件开始处的偏移量, 必须是分页大小的整数倍, 通常为0, 表示从文件头开始映射。

3、解除映射  
      int munmap(void \*start,size\_t length)  
     功能：取消参数start所指向的映射内存，参数length表示欲取消的内存大小。  
    返回值：解除成功返回0，否则返回－1，错误原因存于errno中。

实例分析  
mmap系统调用

4、虚拟内存区域  
      虚拟内存区域是进程的虚拟地址空间中的一个同质区间，即具有同样特性的连续地址范围。一个进程的内存映象由下面几部分组成：程序代码、数据、BSS  
和栈区域，以及内存映射的区域。

>  一个进程的内存区域可以通过查看：/proc/pid/maps  
> 08048000-0804f000 r-xp 00000000 08:01 573748 /sbin/rpc.statd \#text  
> 0804f000-08050000 rw-p 00007000 08:01 573748 /sbin/rpc.statd \#data  
> 08050000-08055000 rwxp 00000000 00:00 0 \#bss  
> 040000000-40015000 r-xp 00000000 08:01 933965 /lib/ld2.3.2.so \#text  
> 40015000-40016000 rw-p 00014000 08:01 933965 /lib/ld-2.3.2.so \#data

每一行的域为：start\_end perm offset major:minor inode  
       1） Start: 该区域起始虚拟地址  
       2） End: 该区域结束虚拟地址  
       3） Perm: 读、写和执行权限；表示对这个区域，允许进程做什么。这个域的最后一个字符要么是p表示私有的，要么是s表示共享的。  
       4） Offset: 被映射部分在文件中的起始地址  
       5） Major、minor：主次设备号  
       6） Inode：索引结点

5、vm\_area\_struct  
      Linux内核使用结构vm\_area\_struct（<linux/mm\_types.h>）来描述虚拟内存区域，其中几个主要成员如下：  
     1）unsigned long vm\_start   虚拟内存区域起始地址  
     2）unsigned long vm\_end    虚拟内存区域结束地址

3）unsigned long vm\_flags  该区域的标记。如:VM\_IO和VM\_RESERVED。VM\_IO将该VMA标记为内存映射的IO区域，VM\_IO会阻止系统将该区域包含在进程的存放转  
存(core dump )中，VM\_RESERVED标志内存区域不能被换出。

6、mmap设备操作  
      映射一个设备是指把用户空间的一段地址关联到设备内存上。当程序读写这段用户空间的地址时，它实际上是在访问设备。

mmap设备方法需要完成什么功能？  
      mmap方法是file\_oprations结构的成员，在mmap系统调用发出时被调用。在此之前，内核已经完成了很多工作。mmap设备方法所需要做的就是建立  
虚拟地址到物理地址的页表。  
      int (\*mmap) (struct file \*, struct vm\_area\_struct \*)

mmap如何完成页表的建立？  
     方法有二：  
     1）使用remap\_pfn\_range一次建立所有页表;  
     2）使用nopage VMA方法每次建立一个页表。

构造页表的工作可由remap\_pfn\_range函数完成，原型如下：  
     int remap\_pfn\_range(struct vm\_area\_struct \*vma, unsigned long addr,unsigned long pfn, unsigned long size, pgprot\_t prot)

vma:           虚拟内存区域指针  
     virt\_addr:   虚拟地址的起始值

pfn:             要映射的物理地址所在的物理页帧号，可将物理地址>>PAGE\_SHIFT得到。  
     size:           要映射的区域的大小。  
     prot:            VMA的保护属性。

>   
> int memdev\_mmap(struct file\*filp, struct vm\_area\_struct \*vma)  
> \{  
> Vma->vm\_flags |= VM\_IO;  
> Vma->vm\_flags |= VM\_RESERVED;  
> if (remap\_pfn\_range(vma, vma->vm\_start,  
> virt\_to\_phys(dev- >data)>> PAGE\_SHIFT,  
> size,  
> vma->vm\_page\_prot))  
> return -EAGAIN;  
> return 0;  
> \}

7、mmap设备方法实例  
       1）memdev.源码

> > \#ifndef \_MEMDEV\_H\_  
> > \#define \_MEMDEV\_H\_
> > 
> > \#ifndef MEMDEV\_MAJOR  
> > \#define MEMDEV\_MAJOR 0   /\*预设的mem的主设备号\*/  
> > \#endif
> > 
> > \#ifndef MEMDEV\_NR\_DEVS  
> > \#define MEMDEV\_NR\_DEVS 2    /\*设备数\*/  
> > \#endif
> > 
> > \#ifndef MEMDEV\_SIZE  
> > \#define MEMDEV\_SIZE 4096  
> > \#endif
> > 
> > /\*mem设备描述结构体\*/  
> > struct mem\_dev                                       
> > \{                                                          
> >   char \*data;                        
> >   unsigned long size;         
> > \};
> > 
> > \#endif /\* \_MEMDEV\_H\_ \*/

2）memdev.c源码

> > \#include <linux/module.h>  
> > \#include <linux/types.h>  
> > \#include <linux/fs.h>  
> > \#include <linux/errno.h>  
> > \#include <linux/mm.h>  
> > \#include <linux/sched.h>  
> > \#include <linux/init.h>  
> > \#include <linux/cdev.h>  
> > \#include <asm/io.h>  
> > \#include <asm/system.h>  
> > \#include <asm/uaccess.h>
> > 
> > \#include <linux/kernel.h>  
> > \#include "memdev.h"
> > 
> > static int mem\_major = MEMDEV\_MAJOR;
> > 
> > module\_param(mem\_major, int, S\_IRUGO);
> > 
> > struct mem\_dev \*mem\_devp; /\*设备结构体指针\*/
> > 
> > struct cdev cdev;
> > 
> > /\*文件打开函数\*/  
> > int mem\_open(struct inode \*inode, struct file \*filp)  
> > \{  
> >     struct mem\_dev \*dev;  
> >       
> >     /\*获取次设备号\*/  
> >     int num = MINOR(inode->i\_rdev);
> > 
> >     if (num >= MEMDEV\_NR\_DEVS)   
> >             return -ENODEV;  
> >     dev = &mem\_devp\[num\];  
> >       
> >     /\*将设备描述结构指针赋值给文件私有数据指针\*/  
> >     filp->private\_data = dev;  
> >       
> >     return 0;   
> > \}
> > 
> > /\*文件释放函数\*/  
> > int mem\_release(struct inode \*inode, struct file \*filp)  
> > \{  
> >   return 0;  
> > \}  
> > static int memdev\_mmap(struct file\*filp, struct vm\_area\_struct \*vma)  
> > \{  
> >       struct mem\_dev \*dev = filp->private\_data; /\*获得设备结构体指针\*/  
> >         
> >       vma->vm\_flags |= VM\_IO;  
> >       vma->vm\_flags |= VM\_RESERVED;
> > 
> >        
> >       if (remap\_pfn\_range(vma,vma->vm\_start,virt\_to\_phys(dev->data)>>PAGE\_SHIFT, vma->vm\_end - vma->vm\_start, vma->vm\_page\_prot))  
> >           return  -EAGAIN;  
> >                   
> >       return 0;  
> > \}
> > 
> > /\*文件操作结构体\*/  
> > static const struct file\_operations mem\_fops =  
> > \{  
> >   .owner = THIS\_MODULE,  
> >   .open = mem\_open,  
> >   .release = mem\_release,  
> >   .mmap = memdev\_mmap,  
> > \};
> > 
> > /\*设备驱动模块加载函数\*/  
> > static int memdev\_init(void)  
> > \{  
> >   int result;  
> >   int i;
> > 
> >   dev\_t devno = MKDEV(mem\_major, 0);
> > 
> >   /\* 静态申请设备号\*/  
> >   if (mem\_major)  
> >     result = register\_chrdev\_region(devno, 2, "memdev");  
> >   else  /\* 动态分配设备号 \*/  
> >   \{  
> >     result = alloc\_chrdev\_region(&devno, 0, 2, "memdev");  
> >     mem\_major = MAJOR(devno);  
> >   \}    
> >     
> >   if (result < 0)  
> >     return result;
> > 
> >   /\*初始化cdev结构\*/  
> >   cdev\_init(&cdev, &mem\_fops);  
> >   cdev.owner = THIS\_MODULE;  
> >   cdev.ops = &mem\_fops;  
> >     
> >   /\* 注册字符设备 \*/  
> >   cdev\_add(&cdev, MKDEV(mem\_major, 0), MEMDEV\_NR\_DEVS);  
> >      
> >   /\* 为设备描述结构分配内存\*/  
> >   mem\_devp = kmalloc(MEMDEV\_NR\_DEVS \* sizeof(struct mem\_dev), GFP\_KERNEL);  
> >   if (!mem\_devp)    /\*申请失败\*/  
> >   \{  
> >     result =  - ENOMEM;  
> >     goto fail\_malloc;  
> >   \}  
> >   memset(mem\_devp, 0, sizeof(struct mem\_dev));  
> >     
> >   /\*为设备分配内存\*/  
> >   for (i=0; i < MEMDEV\_NR\_DEVS; i++)   
> >   \{  
> >         mem\_devp\[i\].size = MEMDEV\_SIZE;  
> >         mem\_devp\[i\].data = kmalloc(MEMDEV\_SIZE, GFP\_KERNEL);  
> >         memset(mem\_devp\[i\].data, 0, MEMDEV\_SIZE);  
> >   \}  
> >       
> >   return 0;
> > 
> >   fail\_malloc:   
> >   unregister\_chrdev\_region(devno, 1);  
> >     
> >   return result;  
> > \}
> > 
> > /\*模块卸载函数\*/  
> > static void memdev\_exit(void)  
> > \{  
> >   cdev\_del(&cdev);   /\*注销设备\*/  
> >   kfree(mem\_devp);     /\*释放设备结构体内存\*/  
> >   unregister\_chrdev\_region(MKDEV(mem\_major, 0), 2); /\*释放设备号\*/  
> > \}
> > 
> > MODULE\_AUTHOR("yinjiabin);  
> > MODULE\_LICENSE("GPL");
> > 
> > module\_init(memdev\_init);  
> > module\_exit(memdev\_exit);
> > 
> >  
> > 
> > 3）测试程序源码
> > 
> > \#include <stdio.h>  
> > \#include<sys/types.h>  
> > \#include<sys/stat.h>  
> > \#include<fcntl.h>  
> > \#include<unistd.h>  
> > \#include<sys/mman.h>
> > 
> > int main()  
> > \{  
> >  int fd;  
> >  char \*start;  
> >  //char buf\[100\];  
> >  char \*buf;  
> >    
> >  /\*打开文件\*/  
> >  fd = open("/dev/memdev0",O\_RDWR);  
> >           
> >  buf = (char \*)malloc(100);  
> >  memset(buf, 0, 100);  
> >  start=mmap(NULL,100,PROT\_READ|PROT\_WRITE,MAP\_SHARED,fd,0);  
> >    
> >  /\* 读出数据 \*/  
> >  strcpy(buf,start);  
> >  sleep (1);  
> >  printf("buf 1 = %s\\n",buf); 
> > 
> >  /\* 写入数据 \*/  
> >  strcpy(start,"Buf Is Not Null!");  
> >    
> >  memset(buf, 0, 100);  
> >  strcpy(buf,start);  
> >  sleep (1);  
> >  printf("buf 2 = %s\\n",buf);
> > 
> >          
> >  munmap(start,100); /\*解除映射\*/  
> >  free(buf);  
> >  close(fd);    
> >  return 0;   
> > \}

[1337264541_6409.png]: https://img-my.csdn.net/uploads/201205/17/1337264541_6409.png