Linux Kernel 及 binder mmap实现

1. 简介

对于mmap在用户态通过函数以下函数进行调用:

1. void*mmap(void*addr,size_tsize,intprot,intflags,intfd,longoffset)

然后进入系统调用。

2. Kernel mmap实现

1）然后进入系统调用，其系统调用号为:

kernel/arch/arm/include/asm/unistd.h

#define __NR_mmap2(__NR_SYSCALL_BASE+192)

2）触发软中断

其ISR 代码位于kernel/arch/arm/kernel/entry-common.S的ENTRY(vector_swi), __NR_mmap2对应的函数为:sys_mmap2(位于linux/arch/arm/kernel/calls.S)

3）sys_mmap2的实现

位于kernel/arch/arm/kernel/entry-common.S,实现代码如下：

1. /*
2. *Note:off_4k(r5)isalwaysunitsof4K.Ifwecan'tdotherequested
3. *offset,wereturnEINVAL.
4. */
5. sys_mmap2:
6. #ifPAGE_SHIFT>12
7. tstr5,#PGOFF_MASK
8. moveqr5,r5,lsr#PAGE_SHIFT-12
9. streqr5,[sp,#4]
10. beqsys_mmap_pgoff
11. movr0,#-EINVAL
12. movpc,lr
13. #else
14. strr5,[sp,#4]
15. bsys_mmap_pgoff
16. #endif

4） 调用sys_mmap_pgoff

在kernel/include/linux/syscalls.h中定义如下：

1. asmlinkagelongsys_mmap_pgoff(unsignedlongaddr,unsignedlonglen,
2. unsignedlongprot,unsignedlongflags,
3. unsignedlongfd,unsignedlongpgoff);

6）sys_mmap_pgoff实现
在kernel/mm/mmap.c中实现如下：

1. SYSCALL_DEFINE6(mmap_pgoff,unsignedlong,addr,unsignedlong,len,
2. unsignedlong,prot,unsignedlong,flags,
3. unsignedlong,fd,unsignedlong,pgoff)
4. {
5. structfile*file=NULL;
6. unsignedlongretval=-EBADF;
8. if(!(flags&MAP_ANONYMOUS)){
9. audit_mmap_fd(fd,flags);
10. if(unlikely(flags&MAP_HUGETLB))
11. return-EINVAL;
12. file=fget(fd);
13. if(!file)
14. gotoout;
15. }elseif(flags&MAP_HUGETLB){
16. structuser_struct*user=NULL;
17. /*
18. *VM_NORESERVEisusedbecausethereservationswillbe
19. *takenwhenvm_ops->mmap()iscalled
20. *Adummyuservalueisusedbecausewearenotlocking
21. *memorysonoaccountingisnecessary
22. */
23. len=ALIGN(len,huge_page_size(&default_hstate));
24. file=hugetlb_file_setup(HUGETLB_ANON_FILE,len,VM_NORESERVE,
25. &user,HUGETLB_ANONHUGE_INODE);
26. if(IS_ERR(file))
27. returnPTR_ERR(file);
28. }
30. flags&=~(MAP_EXECUTABLE|MAP_DENYWRITE);
32. down_write(¤t->mm->mmap_sem);
33. retval=do_mmap_pgoff(file,addr,len,prot,flags,pgoff);
34. up_write(¤t->mm->mmap_sem);
36. if(file)
37. fput(file);
38. out:
39. returnretval;
40. }

其功能为：从当前进程中获取用户态可用的虚拟地址空间（vm_area_struct *vma），在mmap_region中真正获取vma，然后调用file->f_op->mmap(file, vma)，调用具体的支持mmap的驱动来处理。

下面以binder驱动为例。

3. binder mmap实现

binder驱动的mmap函数为：binder_mmap，其实现代码如下：

1. staticintbinder_mmap(structfile*filp,structvm_area_struct*vma)
2. {
3. intret;
4. structvm_struct*area;
5. structbinder_proc*proc=filp->private_data;
6. constchar*failure_string;
7. structbinder_buffer*buffer;
9. if((vma->vm_end-vma->vm_start)>SZ_4M)
10. vma->vm_end=vma->vm_start+SZ_4M;
12. binder_debug(BINDER_DEBUG_OPEN_CLOSE,
13. "binder_mmap:%d%lx-%lx(%ldK)vma%lxpagep%lx\n",
14. proc->pid,vma->vm_start,vma->vm_end,
15. (vma->vm_end-vma->vm_start)/SZ_1K,vma->vm_flags,
16. (unsignedlong)pgprot_val(vma->vm_page_prot));
18. if(vma->vm_flags&FORBIDDEN_MMAP_FLAGS){
19. ret=-EPERM;
20. failure_string="badvm_flags";
21. gotoerr_bad_arg;
22. }
23. vma->vm_flags=(vma->vm_flags|VM_DONTCOPY)&~VM_MAYWRITE;
25. if(proc->buffer){
26. ret=-EBUSY;
27. failure_string="alreadymapped";
28. gotoerr_already_mapped;
29. }
31. area=get_vm_area(vma->vm_end-vma->vm_start,VM_IOREMAP);
32. if(area==NULL){
33. ret=-ENOMEM;
34. failure_string="get_vm_area";
35. gotoerr_get_vm_area_failed;
36. }
37. proc->buffer=area->addr;
38. proc->user_buffer_offset=vma->vm_start-(uintptr_t)proc->buffer;
40. #ifdefCONFIG_CPU_CACHE_VIPT
41. if(cache_is_vipt_aliasing()){
42. while(CACHE_COLOUR((vma->vm_start^(uint32_t)proc->buffer))){
43. printk(KERN_INFO"binder_mmap:%d%lx-%lxmaps%pbadalignment\n",proc->pid,vma->vm_start,vma->vm_end,proc->buffer);
44. vma->vm_start+=PAGE_SIZE;
45. }
46. }
47. #endif
48. proc->pages=kzalloc(sizeof(proc->pages[0])*((vma->vm_end-vma->vm_start)/PAGE_SIZE),GFP_KERNEL);
49. if(proc->pages==NULL){
50. ret=-ENOMEM;
51. failure_string="allocpagearray";
52. gotoerr_alloc_pages_failed;
53. }
54. proc->buffer_size=vma->vm_end-vma->vm_start;
56. vma->vm_ops=&binder_vm_ops;
57. vma->vm_private_data=proc;
59. if(binder_update_page_range(proc,1,proc->buffer,proc->buffer+PAGE_SIZE,vma)){
60. ret=-ENOMEM;
61. failure_string="allocsmallbuf";
62. gotoerr_alloc_small_buf_failed;
63. }
64. buffer=proc->buffer;
65. INIT_LIST_HEAD(&proc->buffers);
66. list_add(&buffer->entry,&proc->buffers);
67. buffer->free=1;
68. binder_insert_free_buffer(proc,buffer);
69. proc->free_async_space=proc->buffer_size/2;
70. barrier();
71. proc->files=get_files_struct(current);
72. proc->vma=vma;
74. /*printk(KERN_INFO"binder_mmap:%d%lx-%lxmaps%p\n",
75. proc->pid,vma->vm_start,vma->vm_end,proc->buffer);*/
76. return0;
78. err_alloc_small_buf_failed:
79. kfree(proc->pages);
80. proc->pages=NULL;
81. err_alloc_pages_failed:
82. vfree(proc->buffer);
83. proc->buffer=NULL;
84. err_get_vm_area_failed:
85. err_already_mapped:
86. err_bad_arg:
87. printk(KERN_ERR"binder_mmap:%d%lx-%lx%sfailed%d\n",
88. proc->pid,vma->vm_start,vma->vm_end,failure_string,ret);
89. returnret;
90. }

1）获取kernel态虚拟地址空间：
struct vm_struct *area;
area = get_vm_area(vma->vm_end - vma->vm_start, VM_IOREMAP);

根据传过来的vma（数据结构为vm_area_struct,属于进程的一段空间，用于与内核空间映射用的），调用get_vm_area在内核的vmalloc区域获得一个相同大小的连续空间，数据结构为vm_struct,同时将该结构加入到vm_list统一管理

2）保存kernel态虚拟地址空间的起始地址，以便后面使用：

proc->buffer = area->addr;

3) 计算并保存进程用户态虚拟地址空间起始地址与kernel态虚拟地址空间的起始地址的差值，以便后面使用。

proc->user_buffer_offset = vma->vm_start - (uintptr_t)proc->buffer;

4）分配物理页表项(struct page)

proc->pages = kzalloc(sizeof(proc->pages[0]) * ((vma->vm_end - vma->vm_start) / PAGE_SIZE), GFP_KERNEL);

5）binder_update_page_range

它的工作为：

a）分配物理页

b）分别对vma用户空间建立页表、对vmalloc区域建立页表映射关系。

前面有了用户态和Kernel态的虚拟地址空间，但是还不能访问，因为还没有对应的物理内存。

补充知识：

a）struct page用于跟踪描述一个物理页面是否正在被使用。所有的page结构将都被存入一个叫做mem_map的全局数组中.

b）在每个进程的task_struct中包含一个指向mm_struct结构的指针.进程的mm_struct中则包含了进程可执行影像的页目录指针pgd.还包含了指向vm_area_struct的几个指针,每个vm_area_struct包含一个进程的虚拟地址区域.

binder_update_page_range(proc, 1, proc->buffer, proc->buffer + PAGE_SIZE, vma)

proc->buffer指向内核的vmalloc区域的起始地址，前面已经有了vma(vm_area_struct)和area(vm_struct)。binder_update_page_range实现代码如下：

1. staticintbinder_update_page_range(structbinder_proc*proc,intallocate,
2. void*start,void*end,
3. structvm_area_struct*vma)
4. {
5. void*page_addr;
6. unsignedlonguser_page_addr;
7. structvm_structtmp_area;
8. structpage**page;
9. structmm_struct*mm;
11. binder_debug(BINDER_DEBUG_BUFFER_ALLOC,
12. "binder:%d:%spages%p-%p\n",proc->pid,
13. allocate?"allocate":"free",start,end);
15. if(end<=start)
16. return0;
18. if(vma)
19. mm=NULL;
20. else
21. mm=get_task_mm(proc->tsk);
23. if(mm){
24. down_write(&mm->mmap_sem);
25. vma=proc->vma;
26. }
28. if(allocate==0)
29. gotofree_range;
31. if(vma==NULL){
32. printk(KERN_ERR"binder:%d:binder_alloc_buffailedto"
33. "mappagesinuserspace,novma\n",proc->pid);
34. gotoerr_no_vma;
35. }
37. for(page_addr=start;page_addr<end;page_addr+=PAGE_SIZE){
38. intret;
39. structpage**page_array_ptr;
40. page=&proc->pages[(page_addr-proc->buffer)/PAGE_SIZE];
42. BUG_ON(*page);
43. //分配一个物理页
44. *page=alloc_page(GFP_KERNEL|__GFP_ZERO);
45. if(*page==NULL){
46. printk(KERN_ERR"binder:%d:binder_alloc_buffailed"
47. "forpageat%p\n",proc->pid,page_addr);
48. gotoerr_alloc_page_failed;
49. }
50. tmp_area.addr=page_addr;
51. tmp_area.size=PAGE_SIZE+PAGE_SIZE/*guardpage?*/;
52. page_array_ptr=page;
53. //根据kernel态的虚拟地址，分配对应的pud,pmd和pte并填充对应的值
54. //以使根据虚拟地址，可以通过pgd,pud,pmd和pte寻址到对应的物理存储单元
55. ret=map_vm_area(&tmp_area,PAGE_KERNEL,&page_array_ptr);
56. if(ret){
57. printk(KERN_ERR"binder:%d:binder_alloc_buffailed"
58. "tomappageat%pinkernel\n",
59. proc->pid,page_addr);
60. gotoerr_map_kernel_failed;
61. }
62. user_page_addr=
63. (uintptr_t)page_addr+proc->user_buffer_offset;
64. //根据用户态的虚拟地址，插入一页到用户空间的vma，
65. //从而用户空间访问从user_page_addr开始的一页内存时，
66. //从而可以访问到与page对应的物理页中对应的存储单元
67. ret=vm_insert_page(vma,user_page_addr,page[0]);
68. if(ret){
69. printk(KERN_ERR"binder:%d:binder_alloc_buffailed"
70. "tomappageat%lxinuserspace\n",
71. proc->pid,user_page_addr);
72. gotoerr_vm_insert_page_failed;
73. }
74. /*vm_insert_pagedoesnotseemtoincrementtherefcount*/
75. }
76. if(mm){
77. up_write(&mm->mmap_sem);
78. mmput(mm);
79. }
80. return0;
82. free_range:
83. for(page_addr=end-PAGE_SIZE;page_addr>=start;
84. page_addr-=PAGE_SIZE){
85. page=&proc->pages[(page_addr-proc->buffer)/PAGE_SIZE];
86. if(vma)
87. zap_page_range(vma,(uintptr_t)page_addr+
88. proc->user_buffer_offset,PAGE_SIZE,NULL);
89. err_vm_insert_page_failed:
90. unmap_kernel_range((unsignedlong)page_addr,PAGE_SIZE);
91. err_map_kernel_failed:
92. __free_page(*page);
93. *page=NULL;
94. err_alloc_page_failed:
95. ;
96. }
97. err_no_vma:
98. if(mm){
99. up_write(&mm->mmap_sem);
100. mmput(mm);
101. }
102. return-ENOMEM;
103. }

a）map_vm_area:映射Kernel虚拟地址到物理内存，为vmalloc区域的连续地址空间进行页表映射，当然需要vm_struct（提供虚拟地址）参数和page参数（用来makepte的），这就完成了内核区的映射

b） vm_insert_page:更新vma对应的页表，这样就是实现了mmap功能

c）binder_update_page_range(proc, 1, proc->buffer, proc->buffer + PAGE_SIZE, vma)调用的时候只分配了1页，这个是为了节约空间，按需分配。而进程虚拟空间和vmalloc内核空间按需要分配，反正它不占用实际物理内存，所以开始就占用了所需的全部空间，而实际的物理页按需获取；

proc->vma为调用进程的一段用户空间；

proc->files为调用进程的files_struct结构；

proc->buffer_size为需要映射的长度（小于4m）-sizeof（structbinder_buffer）;

proc->pages为分配的物理页page的指针数组，开始只有一项，即1页，但是长度还是预留好了；

proc->buffer为内核连续映射区首地址；

proc->user_buffer_offset为用户空间映射区首地址-内核空间连续映射的首地址。

http://www.linuxidc.com/Linux/2012-03/55897p3.htm