内核与用户空间共享内存之mmap

一、用到的API与数据结构
先看用户空间使用的API

1. #include <sys/mman.h>
   
2. void *mmap(void *start, //映射的范围首地址，通常设NULL，让系统自动选地址，映射成功后返回该地址
3.          size_t length, //映射的范围的大小
   
4.          int prot,      //映射区的保护属性 PROT_EXEC PROT_READ PROT_WRITE PROT_NONE
5.          int flags,     //映射区的属性，注意MAP_SHARED、MAP_PRIVATE必选其一
6.          int fd,        //文件描述符
   
7.          off_t offsize);//偏移量，后面讲
8. 返回值：若映射成功则返回映射区的内存起始地址，否则返回MAP_FAILED(－1)，错误原因存于errno 中。
9. 
   
10. 另外注意： offsize参数是有限制的。。。（以下摘自man手册） 
    
11. EINVAL  We don’t like start or length or offset. 
    
12.         (E.g., they are too large, or not aligned on a PAGESIZE boundary.)
    

在字符设备驱动模块里，有一个stuct file_operations结构
其中的fop->mmap() 指向你自己的mmap钩子函数。
用户空间里对一个字符设备文件进行mmap()系统调用后，最终会调用驱动模块里的mmap钩子函数
在mmap钩子函数里，需要调用下面这个API

1. int remap_pfn_range(struct vm_area_struct *vma, //这个结构很重要！！后面讲
   
2.                     unsigned long virt_addr,    //要映射的范围的首地址
   
3.                     unsigned long pfn,          //要映射的范围对应的物理内存的页帧号！！重要
   
4.                     unsigned long size,         //要映射的范围的大小
5.                     pgprot_t prot);             //PROTECT属性，mmap()中来的
   

内核维护VMA的链表和树形结构(即vm_area_struct),我们没事别建新的VMA，否则会打破这种组织结构。
用户空间每次调用mmap(),内核都会新建一个vm_area_struct数据结构,我们只关注几个重要的成员

1. struct vm_area_struct{
   
2.    unsigned long vm_start; //要映射的范围的首地址
   
3.    unsigned long vm_end;   //要映射的范围的尾地址
   
4. 
   
5.    pgprot_t vm_page_prot； //来自mmap()的形参prot
   
6.    sturct file *vm_file;   //字符设备文件所对应的file数据结构
   
7.    unsigned long vm_pgoff; //来自mmap()的形参offsize,注意它是以PAGE为单位的，不是字节
   
8.    unsigned long vm_flags; //来自mmap()的形参flags
   
9. }

在你的mmap钩子函数里，象下面这样就可以了

1. int my_mmap(struct file *filp, struct vm_area_struct *vma){
   
2.    //......省略，page很重要,其他的参数一般照下面就可以了
   
3.    remap_pfn_range(vma, vma->vm_start, page,
4.         (vma->vm_end - vma->vm_start), vma->vm_page_prot);
   
5.    //......省略
   
6. }

二、代码示例
内核模块里分配内存，通过proc把此内存的EA地址、大小告诉用户空间。
用户空间通过proc获取内存相关信息后，调用mmap，往内存里写字符串。

内核模块代码：

1. #include <linux/module.h>
   
2. #include <linux/types.h>
   
3. #include <linux/fs.h>
   
4. #include <asm/io.h>
   
5. #include <asm/system.h>
   
6. #include <linux/cdev.h>
   
7. #include <linux/proc_fs.h>
   
8. #include <linux/mm.h>
   
9. #define PROC_SHM_MAP_DIR "shm_dir"
   
10. #define PROC_SHM_MAP_INFO "shm_info"
    
11. #define PAGE_ORDER   0
    
12. #define PAGES_NUMBER 1
    
13. 
    
14. static int dbg_major = 215;
    
15. struct cdev dgb_dev;
    
16. struct proc_dir_entry *proc_shm_map_dir;
    
17. unsigned long kernel_memaddr = 0;
    
18. unsigned long kernel_memsize = 0;
    
19. 
    
20. int get_shm_proc_info(char *page, char **start, off_t off, int count)
    
21. {
    
22.     return sprintf(page, "lx %lu\n", __pa(kernel_memaddr), kernel_memsize);
    
23. }
    
24. 
    
25. void create_shm_proc(void)
    
26. {
    
27.     if(NULL == (proc_shm_map_dir = proc_mkdir(PROC_SHM_MAP_DIR, NULL)) ){
    
28.         printk("proc create error!\n");
    
29.         return ;
    
30.     }
    
31.     create_proc_info_entry(PROC_SHM_MAP_INFO, 0, proc_shm_map_dir, get_shm_proc_info);
    
32. }
    
33. 
    
34. void destroy_shm_proc(void)
    
35. {
    
36.     remove_proc_entry(PROC_SHM_MAP_INFO, proc_shm_map_dir);
    
37.     remove_proc_entry(PROC_SHM_MAP_DIR, NULL);
    
38. }
    
39. 
    
40. int shm_mmap(struct file *filp, struct vm_area_struct *vma)
    
41. {
    
42.     unsigned long page;
    
43.     page = virt_to_phys((void *)kernel_memaddr) >> PAGE_SHIFT;
    
44. 
    
45.     if( remap_pfn_range(vma, vma->vm_start, page, (vma->vm_end - vma->vm_start),
    
46.          vma->vm_page_prot) )
    
47.         return -1;
    
48.     vma->vm_flags |= VM_RESERVED;
49.     printk("remap_pfn_rang page:[%lu] ok.\n", page);
    
50.     return 0;
    
51. }
    
52. 
    
53. int create_shm_mem(void)
    
54. {
55.     if( NULL == (kernel_memaddr =__get_free_pages(GFP_KERNEL, PAGE_ORDER) )) {
    
56.         printk("alloc kernel memory failed!\n");
    
57.         return -1;
    
58.     }
    
59.     SetPageReserved(virt_to_page(kernel_memaddr)); // important !! only 1 page
    
60.     kernel_memsize = PAGES_NUMBER * PAGE_SIZE;
    
61.     printk("The kernel mem addr=lx, size=%lu\n",__pa(kernel_memaddr), kernel_memsize);
    
62.     return 0;
    
63. }
64. 
    
65. void destroy_shm_mem(void)
    
66. {
    
67.     printk("The string written by user is: %s\n", (unsigned char *)kernel_memaddr);
    
68.     ClearPageReserved(virt_to_page(kernel_memaddr));// important !!
    
69.     free_pages(kernel_memaddr, PAGE_ORDER);
    
70.     return;
    
71. }
    
72. 
    
73. static const struct file_operations dbg_fops ={
    
74.     .owner = THIS_MODULE,
    
75.     .mmap = shm_mmap,
    
76. };
    
77. 
    
78. static void dbg_exit(void)
    
79. {
    
80.     cdev_del(&dgb_dev);
    
81.     unregister_chrdev_region(MKDEV(dbg_major, 0), 1);
    
82.     destroy_shm_proc();
    
83.     destroy_shm_mem();
    
84. }
    
85. 
    
86. int dbg_init(void)
    
87. {
    
88.     int result;
    
89.     dev_t devno ;
    
90.     struct cdev *p_cdev = &dgb_dev;
    
91. 
    
92.     if (dbg_major){
    
93.         devno =MKDEV(dbg_major,0);
    
94.         result = register_chrdev_region(devno,1, "leon");
    
95.     }
    
96.     else{
    
97.         result=alloc_chrdev_region(&devno, 0, 1,"leon");
    
98.         dbg_major = MAJOR(devno);
    
99.     }
    
100. 
     
101.     if (result < 0)
     
102.         return result;
     
103.     printk("the major device No. is %d\n", dbg_major );
     
104. 
     
105.     cdev_init(p_cdev,&dbg_fops);
     
106.     p_cdev->owner = THIS_MODULE;
     
107.     result = cdev_add(p_cdev,devno,1);
     
108. 
     
109.     if(result){
     
110.         printk(KERN_NOTICE "Error %d while adding dbg",result);
     
111.         return result;
     
112.     }
     
113. 
     
114.     create_shm_mem();
     
115.     create_shm_proc();
     
116.     return 0;
     
117. }
     
118. 
     
119. MODULE_AUTHOR("leonwang202");
     
120. MODULE_LICENSE("Dual BSD/GPL");
     
121. module_init(dbg_init);
     
122. module_exit(dbg_exit);

用户空间代码：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <string.h>
   
5. #include <fcntl.h>
   
6. #include <sys/stat.h>
   
7. #include <sys/types.h>
   
8. #include <sys/mman.h>
   
9. #include <errno.h>
   
10. 
    
11. int main(int argc, char* argv[])
    
12. {
    
13.     if(argc != 2) {
    
14.         printf("Usage: %s string\n", argv[0]);
    
15.         return 0;
    
16.     }
    
17.     unsigned long phymem_addr, phymem_size;
    
18.     char *map_addr;
    
19.     char s[256];
    
20.     int fd;
    
21. 
    
22.     if( (fd = open("/proc/shm_dir/shm_info", O_RDONLY)) < 0) {
    
23.         printf("cannot open file /proc/shm_dir/shm_info\n");
    
24.         return 0;
    
25.     }
    
26. 
    
27.     read(fd, s, sizeof(s));
    
28.     if(2 != sscanf(s, "lx %lu", &phymem_addr, &phymem_size)){
    
29.         printf("data format from /proc/shm_dir/shm_info error!\n");
    
30.         close(fd);
    
31.         return -1;
    
32.     };
    
33.     close(fd);
    
34.     printf("phymem_addr=%lx, phymem_size=%lu\n", phymem_addr, phymem_size);
    
35. 
    
36.     if( (fd = open("/dev/enetdbg", O_RDWR|O_NONBLOCK)) < 0){
    
37.         printf("open /dev/enetdbg error!\n");
    
38.         return -1;
    
39.     }
    
40. 
    
41.     map_addr = mmap(NULL,
    
42.                     phymem_size,
    
43.                     PROT_READ|PROT_WRITE,
    
44.                     MAP_SHARED,
    
45.                     fd,
    
46.                     0); // ignored, because we don't use "vm->pgoff" in driver.
    
47. 
    
48.     if( MAP_FAILED == map_addr){
    
49.         printf("mmap() error:[%d]\n", errno);
    
50.         return -1;
    
51.     }
    
52. 
    
53.     strcpy(map_addr, argv[1]);
    
54.     munmap(map_addr, phymem_size);
    
55. 
    
56.     close(fd);
    
57.     return 0;
    
58. }

注意：我们在shm_mmap里没使用vm->pgoff，所以mmap()的形参offsize可以无视。

三、使用/dev/mem
想偷懒的，可以使/dev/mem，就不用费劲写内核模块里的mmap钩子函数了
（此用法在帖子http://bbs.chinaunix.net/thread-2017863-1-1.html中有写）

内核代码不用改，图干净的话只要把mmap钩子函数相关的东东全删掉就ok了
用户空间代码得改：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <string.h>
   
5. #include <fcntl.h>
   
6. #include <sys/stat.h>
   
7. #include <sys/types.h>
   
8. #include <sys/mman.h>
   
9. #include <errno.h>
   
10. 
    
11. int main(int argc, char* argv[])
    
12. {
    
13.     if(argc != 2) {
    
14.         printf("Usage: %s string\n", argv[0]);
    
15.         return 0;
    
16.     }
    
17.     unsigned long phymem_addr, phymem_size;
    
18.     char *map_addr;
    
19.     char s[256];
    
20.     int fd;
    
21. 
    
22.     if( (fd = open("/proc/shm_dir/shm_info", O_RDONLY)) < 0) {
    
23.         printf("cannot open file /proc/shm_dir/shm_info\n");
    
24.         return 0;
    
25.     }
    
26.     read(fd, s, sizeof(s));
    
27.     if(2 != sscanf(s, "lx %lu", &phymem_addr, &phymem_size)){
    
28.         printf("data format from /proc/shm_dir/shm_info error!\n");
    
29.         close(fd);
    
30.         return -1;
    
31.     };
    
32.     close(fd);
    
33.     printf("phymem_addr=%lx, phymem_size=%lu\n", phymem_addr, phymem_size);
    
34. 
    
35.     if( (fd = open("/dev/mem", O_RDWR|O_NONBLOCK)) < 0){
    
36.         printf("open /dev/mem error!\n");
    
37.         exit(0);
    
38.     }
    
39.     map_addr = mmap(NULL,
    
40.                     phymem_size,
    
41.                     PROT_READ|PROT_WRITE,
    
42.                     MAP_SHARED,
    
43.                     fd,
    
44.                     phymem_addr);
    
45. 
    
46.     strcpy(map_addr, argv[1]);
    
47.     munmap(map_addr, phymem_size);
    
48.     close(fd);
    
49.     return 0;
    
50. }

注意：
1.你的linux环境下没有/dev/mem的话，敲命令 mknod /dev/mem c 1 1       原因后面讲
2.这次mmap()形参offsize不能无视，因为创建/dev/mem的内核模块的mmap钩子函数里用到了vm->pgoff

看到底是哪个模块创建了/dev/mem

1. start_kernel --> kernel_init --> do_basic_setup --> do_initcalls --> chr_dev_init

文件 linux_2_6_24/drivers/char/mem.c 中 chr_dev_init() 函数

1. static int __init chr_dev_init(void)
   
2. {
   
3.    if (register_chrdev(MEM_MAJOR,"mem",&memory_fops)) //cat /proc/devices 时显示 1 mem
   
4.       printk("unable to get major %d for memory devs\n", MEM_MAJOR);
   
5. 
   
6.    for (i = 0; i < ARRAY_SIZE(devlist); i )
   
7.       device_create(mem_class, NULL,        //据数组新建N多设备，主设备号为1，从设备号来自数组
   
8.                   MKDEV(MEM_MAJOR, devlist[i].minor),devlist[i].name);
   
9. }
   
10. 
    
11. static const struct {
    
12.     unsigned int minor;
    
13.     char *name;
    
14.     umode_t mode;
    
15.     const struct file_operations *fops;
    
16. } devlist[] = { /* list of minor devices */             //我擦，major为1的字符设备这么多....
    
17.     {1, "mem", S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops}, //mknod /dev/mem c 1 1 原因知道了吧
18.     {2, "kmem", S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops},
    
19.     {3, "null", S_IRUGO | S_IWUGO, &null_fops},
    
20. #ifdef CONFIG_DEVPORT
    
21.     {4, "port", S_IRUSR | S_IWUSR | S_IRGRP, &port_fops},
    
22. #endif
    
23.     {5, "zero", S_IRUGO | S_IWUGO, &zero_fops},
    
24.     {7, "full", S_IRUGO | S_IWUGO, &full_fops},
    
25.     {8, "random", S_IRUGO | S_IWUSR, &random_fops},
    
26.     {9, "urandom", S_IRUGO | S_IWUSR, &urandom_fops},
    
27.     {11,"kmsg", S_IRUGO | S_IWUSR, &kmsg_fops},
    
28. #ifdef CONFIG_CRASH_DUMP
    
29.     {12,"oldmem", S_IRUSR | S_IWUSR | S_IRGRP, &oldmem_fops},
    
30. #endif
    
31. };

---------------------------------- 华丽的分割线 -------------------------------------------

若共享小块连续内存，上面例子用get_free_pages可以分配多达几M的连续空间（MAX_ORDER目前是11）。
若共享大块连续内存，就得靠uboot帮忙了，给linux kernel传参数的时候，用mem=大小

《ldd3》中的分配内存那章有专门一节讲解，通过API

1. void *alloc_bootmem(unsigned long size);
   
2. void free_bootmem(unsigned long addr, unsigned long size);