浅谈Service Manager成为Android进程间通信（IPC）机制Binder守护进程之路(1)

上一篇文章Android进程间通信（IPC）机制Binder简要介绍和学习计划简要介绍了Android系统进程间通信机制Binder的总体架构，它由Client、Server、Service Manager和驱动程序Binder四个组件构成。本文着重介绍组件Service Manager，它是整个Binder机制的守护进程，用来管理开发者创建的各种Server，并且向Client提供查询Server远程接口的功能。

        既然Service Manager组件是用来管理Server并且向Client提供查询Server远程接口的功能，那么，Service Manager就必然要和Server以及Client进行通信了。我们知道，Service Manger、Client和Server三者分别是运行在独立的进程当中，这样它们之间的通信也属于进程间通信了，而且也是采用Binder机制进行进程间通信，因此，Service Manager在充当Binder机制的守护进程的角色的同时，也在充当Server的角色，然而，它是一种特殊的Server，下面我们将会看到它的特殊之处。

       与Service Manager相关的源代码较多，这里不会完整去分析每一行代码，主要是带着Service Manager是如何成为整个Binder机制中的守护进程这条主线来一步一步地深入分析相关源代码，包括从用户空间到内核空间的相关源代码。希望读者在阅读下面的内容之前，先阅读一下前一篇文章提到的两个参考资料Android深入浅出之Binder机制和Android Binder设计与实现，熟悉相关概念和数据结构，这有助于理解下面要分析的源代码。

       Service Manager在用户空间的源代码位于frameworks/base/cmds/servicemanager目录下，主要是由binder.h、binder.c和service_manager.c三个文件组成。Service Manager的入口位于service_manager.c文件中的main函数：

1. int main(int argc, char **argv)  
2. {  
3.     struct binder_state *bs;  
4.     void *svcmgr = BINDER_SERVICE_MANAGER;  
5.  
6.     bs = binder_open(128*1024);  
7.  
8.     if (binder_become_context_manager(bs)) {  
9.         LOGE("cannot become context manager (%s)\n", strerror(errno));  
10.         return -1;  
11.     }  
12.  
13.     svcmgr_handle = svcmgr;  
14.     binder_loop(bs, svcmgr_handler);  
15.     return 0;  
16. } 

   main函数主要有三个功能：一是打开Binder设备文件；二是告诉Binder驱动程序自己是Binder上下文管理者，即我们前面所说的守护进程；三是进入一个无穷循环，充当Server的角色，等待Client的请求。进入这三个功能之间，先来看一下这里用到的结构体binder_state、宏BINDER_SERVICE_MANAGER的定义：

        struct binder_state定义在frameworks/base/cmds/servicemanager/binder.c文件中：

1. struct binder_state  
2. {  
3.     int fd;  
4.     void *mapped;  
5.     unsigned mapsize;  
6. }; 

   fd是文件描述符，即表示打开的/dev/binder设备文件描述符；mapped是把设备文件/dev/binder映射到进程空间的起始地址；mapsize是上述内存映射空间的大小。

        宏BINDER_SERVICE_MANAGER定义frameworks/base/cmds/servicemanager/binder.h文件中：

1. /* the one magic object */  
2. #define BINDER_SERVICE_MANAGER ((void*) 0) 

   它表示Service Manager的句柄为0。Binder通信机制使用句柄来代表远程接口，这个句柄的意义和Windows编程中用到的句柄是差不多的概念。前面说到，Service Manager在充当守护进程的同时，它充当Server的角色，当它作为远程接口使用时，它的句柄值便为0，这就是它的特殊之处，其余的Server的远程接口句柄值都是一个大于0 而且由Binder驱动程序自动进行分配的。

        函数首先是执行打开Binder设备文件的操作binder_open，这个函数位于frameworks/base/cmds/servicemanager/binder.c文件中：

1. struct binder_state *binder_open(unsigned mapsize)  
2. {  
3.     struct binder_state *bs;  
4.  
5.     bs = malloc(sizeof(*bs));  
6.     if (!bs) {  
7.         errno = ENOMEM;  
8.         return 0;  
9.     }  
10.  
11.     bs->fd = open("/dev/binder", O_RDWR);  
12.     if (bs->fd < 0) {  
13.         fprintf(stderr,"binder: cannot open device (%s)\n",  
14.                 strerror(errno));  
15.         goto fail_open;  
16.     }  
17.  
18.     bs->mapsize = mapsize;  
19.     bs->mapped = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, bs->fd, 0);  
20.     if (bs->mapped == MAP_FAILED) {  
21.         fprintf(stderr,"binder: cannot map device (%s)\n",  
22.                 strerror(errno));  
23.         goto fail_map;  
24.     }  
25.  
26.         /* TODO: check version */  
27.  
28.     return bs;  
29.  
30. fail_map:  
31.     close(bs->fd);  
32. fail_open:  
33.     free(bs);  
34.     return 0;  
35. } 

通过文件操作函数open来打开/dev/binder设备文件。设备文件/dev/binder是在Binder驱动程序模块初始化的时候创建的，我们先看一下这个设备文件的创建过程。进入到kernel/common/drivers/staging/android目录中，打开binder.c文件，可以看到模块初始化入口binder_init：

1. static struct file_operations binder_fops = {  
2.     .owner = THIS_MODULE,  
3.     .poll = binder_poll,  
4.     .unlocked_ioctl = binder_ioctl,  
5.     .mmap = binder_mmap,  
6.     .open = binder_open,  
7.     .flush = binder_flush,  
8.     .release = binder_release,  
9. };  
10.  
11. static struct miscdevice binder_miscdev = {  
12.     .minor = MISC_DYNAMIC_MINOR,  
13.     .name = "binder",  
14.     .fops = &binder_fops  
15. };  
16.  
17. static int __init binder_init(void)  
18. {  
19.     int ret;  
20.  
21.     binder_proc_dir_entry_root = proc_mkdir("binder", NULL);  
22.     if (binder_proc_dir_entry_root)  
23.         binder_proc_dir_entry_proc = proc_mkdir("proc", binder_proc_dir_entry_root);  
24.     ret = misc_register(&binder_miscdev);  
25.     if (binder_proc_dir_entry_root) {  
26.         create_proc_read_entry("state", S_IRUGO, binder_proc_dir_entry_root, binder_read_proc_state, NULL);  
27.         create_proc_read_entry("stats", S_IRUGO, binder_proc_dir_entry_root, binder_read_proc_stats, NULL);  
28.         create_proc_read_entry("transactions", S_IRUGO, binder_proc_dir_entry_root, binder_read_proc_transactions, NULL);  
29.         create_proc_read_entry("transaction_log", S_IRUGO, binder_proc_dir_entry_root, binder_read_proc_transaction_log, &binder_transaction_log);  
30.         create_proc_read_entry("failed_transaction_log", S_IRUGO, binder_proc_dir_entry_root, binder_read_proc_transaction_log, &binder_transaction_log_failed);  
31.     }  
32.     return ret;  
33. }  
34.  
35. device_initcall(binder_init); 

   创建设备文件的地方在misc_register函数里面，关于misc设备的注册，我们在Android日志系统驱动程序Logger源代码分析一文中有提到，有兴趣的读取不访去了解一下。其余的逻辑主要是在/proc目录创建各种Binder相关的文件，供用户访问。从设备文件的操作方法binder_fops可以看出，前面的binder_open函数执行语句：

1. bs->fd = open("/dev/binder", O_RDWR); 

  就进入到Binder驱动程序的binder_open函数了：

1. static int binder_open(struct inode *nodp, struct file *filp)  
2. {  
3.     struct binder_proc *proc;  
4.  
5.     if (binder_debug_mask & BINDER_DEBUG_OPEN_CLOSE)  
6.         printk(KERN_INFO "binder_open: %d:%d\n", current->group_leader->pid, current->pid);  
7.  
8.     proc = kzalloc(sizeof(*proc), GFP_KERNEL);  
9.     if (proc == NULL)  
10.         return -ENOMEM;  
11.     get_task_struct(current);  
12.     proc->tsk = current;  
13.     INIT_LIST_HEAD(&proc->todo);  
14.     init_waitqueue_head(&proc->wait);  
15.     proc->default_priority = task_nice(current);  
16.     mutex_lock(&binder_lock);  
17.     binder_stats.obj_created[BINDER_STAT_PROC]++;  
18.     hlist_add_head(&proc->proc_node, &binder_procs);  
19.     proc->pid = current->group_leader->pid;  
20.     INIT_LIST_HEAD(&proc->delivered_death);  
21.     filp->private_data = proc;  
22.     mutex_unlock(&binder_lock);  
23.  
24.     if (binder_proc_dir_entry_proc) {  
25.         char strbuf[11];  
26.         snprintf(strbuf, sizeof(strbuf), "%u", proc->pid);  
27.         remove_proc_entry(strbuf, binder_proc_dir_entry_proc);  
28.         create_proc_read_entry(strbuf, S_IRUGO, binder_proc_dir_entry_proc, binder_read_proc_proc, proc);  
29.     }  
30.  
31.     return 0;  
32. } 

     这个函数的主要作用是创建一个struct binder_proc数据结构来保存打开设备文件/dev/binder的进程的上下文信息，并且将这个进程上下文信息保存在打开文件结构struct file的私有数据成员变量private_data中，这样，在执行其它文件操作时，就通过打开文件结构struct file来取回这个进程上下文信息了。这个进程上下文信息同时还会保存在一个全局哈希表binder_procs中，驱动程序内部使用。binder_procs定义在文件的开头：
 

1. static HLIST_HEAD(binder_procs); 

  结构体struct binder_proc也是定义在kernel/common/drivers/staging/android/binder.c文件中：
 

1. struct binder_proc {  
2.     struct hlist_node proc_node;  
3.     struct rb_root threads;  
4.     struct rb_root nodes;  
5.     struct rb_root refs_by_desc;  
6.     struct rb_root refs_by_node;  
7.     int pid;  
8.     struct vm_area_struct *vma;  
9.     struct task_struct *tsk;  
10.     struct files_struct *files;  
11.     struct hlist_node deferred_work_node;  
12.     int deferred_work;  
13.     void *buffer;  
14.     ptrdiff_t user_buffer_offset;  
15.  
16.     struct list_head buffers;  
17.     struct rb_root free_buffers;  
18.     struct rb_root allocated_buffers;  
19.     size_t free_async_space;  
20.  
21.     struct page **pages;  
22.     size_t buffer_size;  
23.     uint32_t buffer_free;  
24.     struct list_head todo;  
25.     wait_queue_head_t wait;  
26.     struct binder_stats stats;  
27.     struct list_head delivered_death;  
28.     int max_threads;  
29.     int requested_threads;  
30.     int requested_threads_started;  
31.     int ready_threads;  
32.     long default_priority;  
33. }; 

 这个结构体的成员比较多，这里就不一一说明了，简单解释一下四个成员变量threads、nodes、 refs_by_desc和refs_by_node，其它的我们在遇到的时候再详细解释。这四个成员变量都是表示红黑树的节点，也就是说，binder_proc分别挂会四个红黑树下。threads树用来保存binder_proc进程内用于处理用户请求的线程，它的最大数量由max_threads来决定；node树成用来保存binder_proc进程内的Binder实体；refs_by_desc树和refs_by_node树用来保存binder_proc进程内的Binder引用，即引用的其它进程的Binder实体，它分别用两种方式来组织红黑树，一种是以句柄作来key值来组织，一种是以引用的实体节点的地址值作来key值来组织，它们都是表示同一样东西，只不过是为了内部查找方便而用两个红黑树来表示。

         这样，打开设备文件/dev/binder的操作就完成了，接着是对打开的设备文件进行内存映射操作mmap：

1. bs->mapped = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, bs->fd, 0); 

  对应Binder驱动程序的binder_mmap函数：

1. static int binder_mmap(struct file *filp, struct vm_area_struct *vma)  
2. {  
3.     int ret;  
4.     struct vm_struct *area;  
5.     struct binder_proc *proc = filp->private_data;  
6.     const char *failure_string;  
7.     struct binder_buffer *buffer;  
8.  
9.     if ((vma->vm_end - vma->vm_start) > SZ_4M)  
10.         vma->vm_end = vma->vm_start + SZ_4M;  
11.  
12.     if (binder_debug_mask & BINDER_DEBUG_OPEN_CLOSE)  
13.         printk(KERN_INFO  
14.             "binder_mmap: %d %lx-%lx (%ld K) vma %lx pagep %lx\n",  
15.             proc->pid, vma->vm_start, vma->vm_end,  
16.             (vma->vm_end - vma->vm_start) / SZ_1K, vma->vm_flags,  
17.             (unsigned long)pgprot_val(vma->vm_page_prot));  
18.  
19.     if (vma->vm_flags & FORBIDDEN_MMAP_FLAGS) {  
20.         ret = -EPERM;  
21.         failure_string = "bad vm_flags";  
22.         goto err_bad_arg;  
23.     }  
24.     vma->vm_flags = (vma->vm_flags | VM_DONTCOPY) & ~VM_MAYWRITE;  
25.  
26.     if (proc->buffer) {  
27.         ret = -EBUSY;  
28.         failure_string = "already mapped";  
29.         goto err_already_mapped;  
30.     }  
31.  
32.     area = get_vm_area(vma->vm_end - vma->vm_start, VM_IOREMAP);  
33.     if (area == NULL) {  
34.         ret = -ENOMEM;  
35.         failure_string = "get_vm_area";  
36.         goto err_get_vm_area_failed;  
37.     }  
38.     proc->buffer = area->addr;  
39.     proc->user_buffer_offset = vma->vm_start - (uintptr_t)proc->buffer;  
40.  
41. #ifdef CONFIG_CPU_CACHE_VIPT  
42.     if (cache_is_vipt_aliasing()) {  
43.         while (CACHE_COLOUR((vma->vm_start ^ (uint32_t)proc->buffer))) {  
44.             printk(KERN_INFO "binder_mmap: %d %lx-%lx maps %p bad alignment\n", proc->pid, vma->vm_start, vma->vm_end, proc->buffer);  
45.             vma->vm_start += PAGE_SIZE;  
46.         }  
47.     }  
48. #endif  
49.     proc->pages = kzalloc(sizeof(proc->pages[0]) * ((vma->vm_end - vma->vm_start) / PAGE_SIZE), GFP_KERNEL);  
50.     if (proc->pages == NULL) {  
51.         ret = -ENOMEM;  
52.         failure_string = "alloc page array";  
53.         goto err_alloc_pages_failed;  
54.     }  
55.     proc->buffer_size = vma->vm_end - vma->vm_start;  
56.  
57.     vma->vm_ops = &binder_vm_ops;  
58.     vma->vm_private_data = proc;  
59.  
60.     if (binder_update_page_range(proc, 1, proc->buffer, proc->buffer + PAGE_SIZE, vma)) {  
61.         ret = -ENOMEM;  
62.         failure_string = "alloc small buf";  
63.         goto err_alloc_small_buf_failed;  
64.     }  
65.     buffer = proc->buffer;  
66.     INIT_LIST_HEAD(&proc->buffers);  
67.     list_add(&buffer->entry, &proc->buffers);  
68.     buffer->free = 1;  
69.     binder_insert_free_buffer(proc, buffer);  
70.     proc->free_async_space = proc->buffer_size / 2;  
71.     barrier();  
72.     proc->files = get_files_struct(current);  
73.     proc->vma = vma;  
74.  
75.     /*printk(KERN_INFO "binder_mmap: %d %lx-%lx maps %p\n", proc->pid, vma->vm_start, vma->vm_end, proc->buffer);*/  
76.     return 0;  
77.  
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 %s failed %d\n", proc->pid, vma->vm_start, vma->vm_end, failure_string, ret);  
88.     return ret;  
89. } 

    函数首先通过filp->private_data得到在打开设备文件/dev/binder时创建的struct binder_proc结构。内存映射信息放在vma参数中，注意，这里的vma的数据类型是struct vm_area_struct，它表示的是一块连续的虚拟地址空间区域，在函数变量声明的地方，我们还看到有一个类似的结构体struct vm_struct，这个数据结构也是表示一块连续的虚拟地址空间区域，那么，这两者的区别是什么呢？在Linux中，struct vm_area_struct表示的虚拟地址是给进程使用的，而struct vm_struct表示的虚拟地址是给内核使用的，它们对应的物理页面都可以是不连续的。struct vm_area_struct表示的地址空间范围是0~3G，而struct vm_struct表示的地址空间范围是(3G + 896M + 8M) ~ 4G。struct vm_struct表示的地址空间范围为什么不是3G~4G呢？原来，3G ~ (3G + 896M)范围的地址是用来映射连续的物理页面的，这个范围的虚拟地址和对应的实际物理地址有着简单的对应关系，即对应0~896M的物理地址空间，而(3G + 896M) ~ (3G + 896M + 8M)是安全保护区域（例如，所有指向这8M地址空间的指针都是非法的），因此struct vm_struct使用(3G + 896M + 8M) ~ 4G地址空间来映射非连续的物理页面。有关Linux的内存管理知识，可以参考Android学习启动篇一文提到的《Understanding the Linux Kernel》一书中的第8章。

        这里为什么会同时使用进程虚拟地址空间和内核虚拟地址空间来映射同一个物理页面呢？这就是Binder进程间通信机制的精髓所在了，同一个物理页面，一方映射到进程虚拟地址空间，一方面映射到内核虚拟地址空间，这样，进程和内核之间就可以减少一次内存拷贝了，提到了进程间通信效率。举个例子如，Client要将一块内存数据传递给Server，一般的做法是，Client将这块数据从它的进程空间拷贝到内核空间中，然后内核再将这个数据从内核空间拷贝到Server的进程空间，这样，Server就可以访问这个数据了。但是在这种方法中，执行了两次内存拷贝操作，而采用我们上面提到的方法，只需要把Client进程空间的数据拷贝一次到内核空间，然后Server与内核共享这个数据就可以了，整个过程只需要执行一次内存拷贝，提高了效率。

        binder_mmap的原理讲完了，这个函数的逻辑就好理解了。不过，这里还是先要解释一下struct binder_proc结构体的几个成员变量。buffer成员变量是一个void*指针，它表示要映射的物理内存在内核空间中的起始位置；buffer_size成员变量是一个size_t类型的变量，表示要映射的内存的大小；pages成员变量是一个struct page*类型的数组，struct page是用来描述物理页面的数据结构；user_buffer_offset成员变量是一个ptrdiff_t类型的变量，它表示的是内核使用的虚拟地址与进程使用的虚拟地址之间的差值，即如果某个物理页面在内核空间中对应的虚拟地址是addr的话，那么这个物理页面在进程空间对应的虚拟地址就为addr + user_buffer_offset。

        再解释一下Binder驱动程序管理这个内存映射地址空间的方法，即是如何管理buffer ~ (buffer + buffer_size)这段地址空间的，这个地址空间被划分为一段一段来管理，每一段是结构体struct binder_buffer来描述：

1. struct binder_buffer {  
2.     struct list_head entry; /* free and allocated entries by addesss */  
3.     struct rb_node rb_node; /* free entry by size or allocated entry */  
4.                 /* by address */  
5.     unsigned free : 1;  
6.     unsigned allow_user_free : 1;  
7.     unsigned async_transaction : 1;  
8.     unsigned debug_id : 29;  
9.  
10.     struct binder_transaction *transaction;  
11.  
12.     struct binder_node *target_node;  
13.     size_t data_size;  
14.     size_t offsets_size;  
15.     uint8_t data[0];  
16. }; 

 每一个binder_buffer通过其成员entry按从低址到高地址连入到struct binder_proc中的buffers表示的链表中去，同时，每一个binder_buffer又分为正在使用的和空闲的，通过free成员变量来区分，空闲的binder_buffer通过成员变量rb_node连入到struct binder_proc中的free_buffers表示的红黑树中去，正在使用的binder_buffer通过成员变量rb_node连入到struct binder_proc中的allocated_buffers表示的红黑树中去。这样做当然是为了方便查询和维护这块地址空间了，这一点我们可以从其它的代码中看到，等遇到的时候我们再分析。

        终于可以回到binder_mmap这个函数来了，首先是对参数作一些健康体检（sanity check），例如，要映射的内存大小不能超过SIZE_4M，即4M，回到service_manager.c中的main 函数，这里传进来的值是128 * 1024个字节，即128K，这个检查没有问题。通过健康体检后，调用get_vm_area函数获得一个空闲的vm_struct区间，并初始化proc结构体的buffer、user_buffer_offset、pages和buffer_size和成员变量，接着调用binder_update_page_range来为虚拟地址空间proc->buffer ~ proc->buffer + PAGE_SIZE分配一个空闲的物理页面，同时这段地址空间使用一个binder_buffer来描述，分别插入到proc->buffers链表和proc->free_buffers红黑树中去，最后，还初始化了proc结构体的free_async_space、files和vma三个成员变量。

        这里，我们继续进入到binder_update_page_range函数中去看一下Binder驱动程序是如何实现把一个物理页面同时映射到内核空间和进程空间去的：

1. static int binder_update_page_range(struct binder_proc *proc, int allocate,  
2.     void *start, void *end, struct vm_area_struct *vma)  
3. {  
4.     void *page_addr;  
5.     unsigned long user_page_addr;  
6.     struct vm_struct tmp_area;  
7.     struct page **page;  
8.     struct mm_struct *mm;  
9.  
10.     if (binder_debug_mask & BINDER_DEBUG_BUFFER_ALLOC)  
11.         printk(KERN_INFO "binder: %d: %s pages %p-%p\n",  
12.                proc->pid, allocate ? "allocate" : "free", start, end);  
13.  
14.     if (end <= start)  
15.         return 0;  
16.  
17.     if (vma)  
18.         mm = NULL;  
19.     else 
20.         mm = get_task_mm(proc->tsk);  
21.  
22.     if (mm) {  
23.         down_write(&mm->mmap_sem);  
24.         vma = proc->vma;  
25.     }  
26.  
27.     if (allocate == 0)  
28.         goto free_range;  
29.  
30.     if (vma == NULL) {  
31.         printk(KERN_ERR "binder: %d: binder_alloc_buf failed to " 
32.                "map pages in userspace, no vma\n", proc->pid);  
33.         goto err_no_vma;  
34.     }  
35.  
36.     for (page_addr = start; page_addr < end; page_addr += PAGE_SIZE) {  
37.         int ret;  
38.         struct page **page_array_ptr;  
39.         page = &proc->pages[(page_addr - proc->buffer) / PAGE_SIZE];  
40.  
41.         BUG_ON(*page);  
42.         *page = alloc_page(GFP_KERNEL | __GFP_ZERO);  
43.         if (*page == NULL) {  
44.             printk(KERN_ERR "binder: %d: binder_alloc_buf failed " 
45.                    "for page at %p\n", proc->pid, page_addr);  
46.             goto err_alloc_page_failed;  
47.         }  
48.         tmp_area.addr = page_addr;  
49.         tmp_area.size = PAGE_SIZE + PAGE_SIZE /* guard page? */;  
50.         page_array_ptr = page;  
51.         ret = map_vm_area(&tmp_area, PAGE_KERNEL, &page_array_ptr);  
52.         if (ret) {  
53.             printk(KERN_ERR "binder: %d: binder_alloc_buf failed " 
54.                    "to map page at %p in kernel\n",  
55.                    proc->pid, page_addr);  
56.             goto err_map_kernel_failed;  
57.         }  
58.         user_page_addr =  
59.             (uintptr_t)page_addr + proc->user_buffer_offset;  
60.         ret = vm_insert_page(vma, user_page_addr, page[0]);  
61.         if (ret) {  
62.             printk(KERN_ERR "binder: %d: binder_alloc_buf failed " 
63.                    "to map page at %lx in userspace\n",  
64.                    proc->pid, user_page_addr);  
65.             goto err_vm_insert_page_failed;  
66.         }  
67.         /* vm_insert_page does not seem to increment the refcount */  
68.     }  
69.     if (mm) {  
70.         up_write(&mm->mmap_sem);  
71.         mmput(mm);  
72.     }  
73.     return 0;  
74.  
75. free_range:  
76.     for (page_addr = end - PAGE_SIZE; page_addr >= start;  
77.          page_addr -= PAGE_SIZE) {  
78.         page = &proc->pages[(page_addr - proc->buffer) / PAGE_SIZE];  
79.         if (vma)  
80.             zap_page_range(vma, (uintptr_t)page_addr +  
81.                 proc->user_buffer_offset, PAGE_SIZE, NULL);  
82. err_vm_insert_page_failed:  
83.         unmap_kernel_range((unsigned long)page_addr, PAGE_SIZE);  
84. err_map_kernel_failed:  
85.         __free_page(*page);  
86.         *page = NULL;  
87. err_alloc_page_failed:  
88.         ;  
89.     }  
90. err_no_vma:  
91.     if (mm) {  
92.         up_write(&mm->mmap_sem);  
93.         mmput(mm);  
94.     }  
95.     return -ENOMEM;  
96. } 

    这个函数既可以分配物理页面，也可以用来释放物理页面，通过allocate参数来区别，这里我们只关注分配物理页面的情况。要分配物理页面的虚拟地址空间范围为(start ~ end)，函数前面的一些检查逻辑就不看了，直接看中间的for循环：

1. for (page_addr = start; page_addr < end; page_addr += PAGE_SIZE) {  
2.     int ret;  
3.     struct page **page_array_ptr;  
4.     page = &proc->pages[(page_addr - proc->buffer) / PAGE_SIZE];  
5.  
6.     BUG_ON(*page);  
7.     *page = alloc_page(GFP_KERNEL | __GFP_ZERO);  
8.     if (*page == NULL) {  
9.         printk(KERN_ERR "binder: %d: binder_alloc_buf failed " 
10.                "for page at %p\n", proc->pid, page_addr);  
11.         goto err_alloc_page_failed;  
12.     }  
13.     tmp_area.addr = page_addr;  
14.     tmp_area.size = PAGE_SIZE + PAGE_SIZE /* guard page? */;  
15.     page_array_ptr = page;  
16.     ret = map_vm_area(&tmp_area, PAGE_KERNEL, &page_array_ptr);  
17.     if (ret) {  
18.         printk(KERN_ERR "binder: %d: binder_alloc_buf failed " 
19.                "to map page at %p in kernel\n",  
20.                proc->pid, page_addr);  
21.         goto err_map_kernel_failed;  
22.     }  
23.     user_page_addr =  
24.         (uintptr_t)page_addr + proc->user_buffer_offset;  
25.     ret = vm_insert_page(vma, user_page_addr, page[0]);  
26.     if (ret) {  
27.         printk(KERN_ERR "binder: %d: binder_alloc_buf failed " 
28.                "to map page at %lx in userspace\n",  
29.                proc->pid, user_page_addr);  
30.         goto err_vm_insert_page_failed;  
31.     }  
32.     /* vm_insert_page does not seem to increment the refcount */  
33. } 

  首先是调用alloc_page来分配一个物理页面，这个函数返回一个struct page物理页面描述符，根据这个描述的内容初始化好struct vm_struct tmp_area结构体，然后通过map_vm_area将这个物理页面插入到tmp_area描述的内核空间去，接着通过page_addr + proc->user_buffer_offset获得进程虚拟空间地址，并通过vm_insert_page函数将这个物理页面插入到进程地址空间去，参数vma代表了要插入的进程的地址空间。
       这样，frameworks/base/cmds/servicemanager/binder.c文件中的binder_open函数就描述完了，回到frameworks/base/cmds/servicemanager/service_manager.c文件中的main函数，下一步就是调用binder_become_context_manager来通知Binder驱动程序自己是Binder机制的上下文管理者，即守护进程。binder_become_context_manager函数位于frameworks/base/cmds/servicemanager/binder.c文件中：

1. int binder_become_context_manager(struct binder_state *bs)  
2. {  
3.     return ioctl(bs->fd, BINDER_SET_CONTEXT_MGR, 0);  
4. } 

这里通过调用ioctl文件操作函数来通知Binder驱动程序自己是守护进程，命令号是BINDER_SET_CONTEXT_MGR，没有参数。BINDER_SET_CONTEXT_MGR定义为：

1. #define BINDER_SET_CONTEXT_MGR      _IOW('b', 7, int) 

    这样就进入到Binder驱动程序的binder_ioctl函数，我们只关注BINDER_SET_CONTEXT_MGR命令：

1. static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)  
2. {  
3.     int ret;  
4.     struct binder_proc *proc = filp->private_data;  
5.     struct binder_thread *thread;  
6.     unsigned int size = _IOC_SIZE(cmd);  
7.     void __user *ubuf = (void __user *)arg;  
8.  
9.     /*printk(KERN_INFO "binder_ioctl: %d:%d %x %lx\n", proc->pid, current->pid, cmd, arg);*/  
10.  
11.     ret = wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2);  
12.     if (ret)  
13.         return ret;  
14.  
15.     mutex_lock(&binder_lock);  
16.     thread = binder_get_thread(proc);  
17.     if (thread == NULL) {  
18.         ret = -ENOMEM;  
19.         goto err;  
20.     }  
21.  
22.     switch (cmd) {  
23.         ......  
24.     case BINDER_SET_CONTEXT_MGR:  
25.         if (binder_context_mgr_node != NULL) {  
26.             printk(KERN_ERR "binder: BINDER_SET_CONTEXT_MGR already set\n");  
27.             ret = -EBUSY;  
28.             goto err;  
29.         }  
30.         if (binder_context_mgr_uid != -1) {  
31.             if (binder_context_mgr_uid != current->cred->euid) {  
32.                 printk(KERN_ERR "binder: BINDER_SET_" 
33.                     "CONTEXT_MGR bad uid %d != %d\n",  
34.                     current->cred->euid,  
35.                     binder_context_mgr_uid);  
36.                 ret = -EPERM;  
37.                 goto err;  
38.             }  
39.         } else 
40.             binder_context_mgr_uid = current->cred->euid;  
41.         binder_context_mgr_node = binder_new_node(proc, NULL, NULL);  
42.         if (binder_context_mgr_node == NULL) {  
43.             ret = -ENOMEM;  
44.             goto err;  
45.         }  
46.         binder_context_mgr_node->local_weak_refs++;  
47.         binder_context_mgr_node->local_strong_refs++;  
48.         binder_context_mgr_node->has_strong_ref = 1;  
49.         binder_context_mgr_node->has_weak_ref = 1;  
50.         break;  
51.         ......  
52.     default:  
53.         ret = -EINVAL;  
54.         goto err;  
55.     }  
56.     ret = 0;  
57. err:  
58.     if (thread)  
59.         thread->looper &= ~BINDER_LOOPER_STATE_NEED_RETURN;  
60.     mutex_unlock(&binder_lock);  
61.     wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2);  
62.     if (ret && ret != -ERESTARTSYS)  
63.         printk(KERN_INFO "binder: %d:%d ioctl %x %lx returned %d\n", proc->pid, current->pid, cmd, arg, ret);  
64.     return ret;  
65. }