深入内核表明白Android Binder【三】

媒介

深入内核表明白Android Binder【一】实现了Binder跨进程通信的客户端和服务端的C语言Demo，并对服务端向service_manager注册服务，客户端向service_manager获取服务的源码举行了详细分析，但分析仅止步于用户态，深入内核表明白Android Binder【二】，详细分析了服务注册过程Binder驱动内核源码，本篇文章继续分析服务获取过程及利用过程的Binder驱动内核源码。相信有了对上一篇文章的基础，这篇文章读起来应该轻松很多，那么我们就开始吧~
一、服务的获取过程内核源码剖析

1. 客户端获取服务的用户态源码回顾

深入内核表明白Android Binder【一】详细分析了客户端获取服务的用户态源码，这里简单回顾一下客户端通过svcmgr_lookup函数获取服务的用户态源码。

1. int main(int argc, char **argv)
2. {
3.     int fd;
4.     struct binder_state *bs;
5.     uint32_t svcmgr = BINDER_SERVICE_MANAGER;
6.     uint32_t handle;
7.         int ret;
9.         if (argc < 2){
10.         fprintf(stderr, "Usage:\n");
11.         fprintf(stderr, "%s <hello|goodbye>\n", argv[0]);
12.         fprintf(stderr, "%s <hello|goodbye> <name>\n", argv[0]);
13.         return -1;
14.         }
15.    
16.     //打开驱动
17.     bs = binder_open(128*1024);
18.     if (!bs) {
19.         fprintf(stderr, "failed to open binder driver\n");
20.         return -1;
21.     }
22.         g_bs = bs;
23.    
24.     //向service_manager发送数据，获得hello服务句柄
25.         handle = svcmgr_lookup(bs, svcmgr, "hello");
26.         if (!handle) {
27.         fprintf(stderr, "failed to get hello service\n");
28.         return -1;
29.         }
30.         g_hello_handle = handle;
31.         fprintf(stderr, "Handle for hello service = %d\n", g_hello_handle);
33.         /* 向服务端发送数据 */
34.         if (!strcmp(argv[1], "hello"))
35.         {
36.                 if (argc == 2) {
37.                         sayhello();
38.                 } else if (argc == 3) {
39.                         ret = sayhello_to(argv[2]);
40.                 fprintf(stderr, "get ret of sayhello_to = %d\n", ret);               
41.                 }
42.         }
44.         binder_release(bs, handle);
46.     return 0;
47. }
50. uint32_t svcmgr_lookup(struct binder_state *bs, uint32_t target, const char *name)
51. {
52.     uint32_t handle;
53.     unsigned iodata[512/4];
54.     struct binder_io msg, reply;
56.     bio_init(&msg, iodata, sizeof(iodata), 4); // 为msg划分iodata的空间
57.     bio_put_uint32(&msg, 0);  // strict mode header
58.     bio_put_string16_x(&msg, SVC_MGR_NAME); // 写入android.os.IServiceManager
59.     bio_put_string16_x(&msg, name); // 写入服务名 hello
61.     // target = 0，代表service_manager，SVC_MGR_CHECK_SERVICE代表需要调用service_manager的查找服务的函数
62.     if (binder_call(bs, &msg, &reply, target, SVC_MGR_CHECK_SERVICE))
63.         return 0;
65.     // 获取hello服务的句柄
66.     handle = bio_get_ref(&reply);
68.     if (handle)
69.         binder_acquire(bs, handle);
71.     binder_done(bs, &msg, &reply);
73.     return handle;
74. }
76. int binder_call(struct binder_state *bs,
77.                 struct binder_io *msg, struct binder_io *reply,
78.                 uint32_t target, uint32_t code)
79. {
80.     int res;
81.     struct binder_write_read bwr;
82.     struct {
83.         uint32_t cmd;
84.         struct binder_transaction_data txn;
85.     } __attribute__((packed)) writebuf;
86.     unsigned readbuf[32];
88.     if (msg->flags & BIO_F_OVERFLOW) {
89.         fprintf(stderr,"binder: txn buffer overflow\n");
90.         goto fail;
91.     }
92.     // 构造binder_transaction_data
93.     writebuf.cmd = BC_TRANSACTION;//ioclt类型
94.     writebuf.txn.target.handle = target;//数据发送给哪个进程
95.     writebuf.txn.code = code;//调用进程的哪个函数
96.     writebuf.txn.flags = 0;
97.     writebuf.txn.data_size = msg->data - msg->data0;//数据本身大小
98.     writebuf.txn.offsets_size = ((char*) msg->offs) - ((char*) msg->offs0);//数据头大小，指向binder_node实体（发送端提供服务函数的地址），bio_put_obj(&msg, ptr);
99.     writebuf.txn.data.ptr.buffer = (uintptr_t)msg->data0;//指向数据本身内存起点
100.     writebuf.txn.data.ptr.offsets = (uintptr_t)msg->offs0;//指向数据头内存起点
101.    
102.     // 构造binder_write_read
103.     bwr.write_size = sizeof(writebuf);
104.     bwr.write_consumed = 0;
105.     bwr.write_buffer = (uintptr_t) &writebuf;
107.     hexdump(msg->data0, msg->data - msg->data0);
108.     for (;;) {
109.         bwr.read_size = sizeof(readbuf);
110.         bwr.read_consumed = 0;
111.         bwr.read_buffer = (uintptr_t) readbuf;
113.         res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);//调用ioctl发送数据给驱动程序
115.         if (res < 0) {
116.             fprintf(stderr,"binder: ioctl failed (%s)\n", strerror(errno));
117.             goto fail;
118.         }
119.         // 解析数据，将readbuf中的数据解析给reply
120.         res = binder_parse(bs, reply, (uintptr_t) readbuf, bwr.read_consumed, 0);
121.         if (res == 0) return 0;
122.         if (res < 0) goto fail;
123.     }
125. fail:
126.     memset(reply, 0, sizeof(*reply));
127.     reply->flags |= BIO_F_IOERROR;
128.     return -1;
129. }

复制代码

可以看到svcmgr_lookup函数也是构造好binder_io数据，然后调用binder_call函数，把binder_io数据封装为binder_write_read数据，最后通过ioctl发送给service_manager。
这个过程和深入内核表明白Android Binder【二】中分析的服务端向service_manager注册服务的过程类似，都是构造数据，然后通过ioctl把数据发给service_manager。
那么下面我们就进入linux内核源码，分析数据发给service_manager后，到底干了什么。
2. 客户端获取服务的内核源码分析

服务端调用ioctl，对应会调用到内核Binder驱动程序中的binder_ioctl函数，点击检察源码
2.1 客户端向service_manager发送数据

1. binder_ioctl

1. // 客户端调用ioctl发送数据给驱动程序
2. res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
4. // 对应Binder内核驱动程序调用binder_ioctl函数处理数据
5. static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
6. {
7.         int ret;
8.         // 获取服务的binder_proc，它是在服务打开binder驱动的时候创建的，后面我们会分析
9.         struct binder_proc *proc = filp->private_data;
10.         struct binder_thread *thread;
11.         void __user *ubuf = (void __user *)arg;
13.         /*pr_info("binder_ioctl: %d:%d %x %lx\n",
14.                         proc->pid, current->pid, cmd, arg);*/
16.         binder_selftest_alloc(&proc->alloc);
18.         trace_binder_ioctl(cmd, arg);
20.         ret = wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2);
21.         if (ret)
22.                 goto err_unlocked;
24.         //为服务进程proc创建binder_thread
25.         thread = binder_get_thread(proc);
26.         if (thread == NULL) {
27.                 ret = -ENOMEM;
28.                 goto err;
29.         }
30.    
31.     // 从上面的分析可知此时cmd=BINDER_WRITE_READ
32.         switch (cmd) {
33.         case BINDER_WRITE_READ:
34.             // 处理服客户端数据
35.                 ret = binder_ioctl_write_read(filp, arg, thread);
36.                 if (ret)
37.                         goto err;
38.                 break;
39.                
40.         ......
41. }

复制代码

2. binder_ioctl_write_read

1. static int binder_ioctl_write_read(struct file *filp, unsigned long arg,
2.                                 struct binder_thread *thread)
3. {
4.         int ret = 0;
5.         struct binder_proc *proc = filp->private_data;
6.         void __user *ubuf = (void __user *)arg; // 用户空间的数据
7.         // 从用户空间获取客户端发送的数据binder_write_read
8.         struct binder_write_read bwr;
10.         //从用户空间发送的数据头拷贝到内核空间（这部分内核空间被mmap映射到了目标进程）
11.         if (copy_from_user(&bwr, ubuf, sizeof(bwr))) {
12.                 ret = -EFAULT;
13.                 goto out;
14.         }
15.         binder_debug(BINDER_DEBUG_READ_WRITE,
16.                      "%d:%d write %lld at %016llx, read %lld at %016llx\n",
17.                      proc->pid, thread->pid,
18.                      (u64)bwr.write_size, (u64)bwr.write_buffer,
19.                      (u64)bwr.read_size, (u64)bwr.read_buffer);
20.         
21.         // 上面已经分析过客户端发送的数据保存在binder_write_read，此时它的write_size是大于0的
22.         if (bwr.write_size > 0) { // 向驱动程序写数据
23.                 ret = binder_thread_write(proc, thread,
24.                                           bwr.write_buffer,
25.                                           bwr.write_size,
26.                                           &bwr.write_consumed);
27.                 trace_binder_write_done(ret);
28.                 if (ret < 0) {
29.                         bwr.read_consumed = 0;
30.                         if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
31.                                 ret = -EFAULT;
32.                         goto out;
33.                 }
34.         }
35.         if (bwr.read_size > 0) { // 从驱动程序读数据
36.                 ret = binder_thread_read(proc, thread, bwr.read_buffer,
37.                                          bwr.read_size,
38.                                          &bwr.read_consumed,
39.                                          filp->f_flags & O_NONBLOCK);
40.                 trace_binder_read_done(ret);
41.                 binder_inner_proc_lock(proc);
42.                 if (!binder_worklist_empty_ilocked(&proc->todo))
43.                         binder_wakeup_proc_ilocked(proc);
44.                 binder_inner_proc_unlock(proc);
45.                 if (ret < 0) {
46.                         if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
47.                                 ret = -EFAULT;
48.                         goto out;
49.                 }
50.         }
51.         binder_debug(BINDER_DEBUG_READ_WRITE,
52.                      "%d:%d wrote %lld of %lld, read return %lld of %lld\n",
53.                      proc->pid, thread->pid,
54.                      (u64)bwr.write_consumed, (u64)bwr.write_size,
55.                      (u64)bwr.read_consumed, (u64)bwr.read_size);
56.         // 复制数据给到用户空间
57.         if (copy_to_user(ubuf, &bwr, sizeof(bwr))) {
58.                 ret = -EFAULT;
59.                 goto out;
60.         }
61. out:
62.         return ret;
63. }
65. static inline int copy_from_user(void *to, const void __user volatile *from,
66.                                  unsigned long n)
67. {
68.         volatile_memcpy(to, from, n);
69.         return 0;
70. }
72. static inline int copy_to_user(void __user volatile *to, const void *from,
73.                                unsigned long n)
74. {
75.         volatile_memcpy(to, from, n);
76.         return 0;
77. }

复制代码

3. binder_thread_write

此时cmd是BC_TRANSACTION

1. static int binder_thread_write(struct binder_proc *proc,
2.                         struct binder_thread *thread,
3.                         binder_uintptr_t binder_buffer, size_t size,
4.                         binder_size_t *consumed)
5. {
6.         uint32_t cmd;
7.         struct binder_context *context = proc->context;
8.         // 获取数据buffer，根据上面总结的发送数据可知，这个buffer由cmd和binder_transcation_data两部分数据组成
9.         void __user *buffer = (void __user *)(uintptr_t)binder_buffer;
10.         // 发送来的数据consumed=0，因此ptr指向用户空间数据buffer的起点
11.         void __user *ptr = buffer + *consumed;
12.         // 指向数据buffer的末尾
13.         void __user *end = buffer + size;
14.         // 逐个读取客户端发送来的数据(cmd+binder_transcation_data)
15.         while (ptr < end && thread->return_error.cmd == BR_OK) {
16.                 int ret;
17.                
18.                 // 获取用户空间中buffer的cmd值
19.                 if (get_user(cmd, (uint32_t __user *)ptr))
20.                         return -EFAULT;
21.                 // 移动指针到cmd的位置之后,指向binder_transcation_data数据的内存起点
22.                 ptr += sizeof(uint32_t);
23.                 trace_binder_command(cmd);
24.                 if (_IOC_NR(cmd) < ARRAY_SIZE(binder_stats.bc)) {
25.                         atomic_inc(&binder_stats.bc[_IOC_NR(cmd)]);
26.                         atomic_inc(&proc->stats.bc[_IOC_NR(cmd)]);
27.                         atomic_inc(&thread->stats.bc[_IOC_NR(cmd)]);
28.                 }
29.                 // 根据上面总结的发送数据可知，cmd是BC_TRANSACTION
30.                 switch (cmd) {
31.                    ......
32.                    /*
33.                 BC_TRANSACTION：进程发送信息的cmd
34.                 BR_TRANSACTION:进程接收BC_TRANSACTION发送信息的cmd
35.                
36.                 BC_REPLY:进程回复信息的cmd
37.                 BR_REPLY：进程接收BC_REPLY回复信息的cmd
38.                 */
39.                     case BC_TRANSACTION:
40.                     case BC_REPLY: {
41.                             struct binder_transaction_data tr;
42.                            
43.                             // 从用户空间拷贝binder_transaction_data到内核空间
44.                             if (copy_from_user(&tr, ptr, sizeof(tr)))
45.                                     return -EFAULT;
46.                             // 移动指针到binder_transaction_data的位置之后,指向下一个cmd数据的内存起点
47.                             ptr += sizeof(tr);
48.                             // 处理binder_transaction_data数据
49.                             binder_transaction(proc, thread, &tr,
50.                                                cmd == BC_REPLY, 0);
51.                             break;
52.                     }
53.                 }
54.         }
55.         ......
56. }
58. int get_user(int *val, const int __user *ptr) {
59.     if (copy_from_user(val, ptr, sizeof(int))) {
60.         return -EFAULT; // 返回错误码
61.     }
62.     return 0; // 成功
63. }

复制代码

4. binder_transaction

4.1 找到目的进程service_manager

1. static void binder_transaction(struct binder_proc *proc,
2.                                struct binder_thread *thread,
3.                                struct binder_transaction_data *tr, int reply,
4.                                binder_size_t extra_buffers_size)
5. {
6.         ......
7.         // 此时是客户端向内核发送数据，reply为false
8.         if (reply) { // Binder内核驱动程序向用户空间回复数据的处理逻辑
9.                 ......
10.         } else { // 用户空间数据发送给内核空间的处理逻辑
11.                 //1. 找到目的进程，本次分析的是向service_manager获取服务，因此目的进程就是tr->target.handle=0的service_manager
12.                 if (tr->target.handle) { // tr->target.handle == 0 代表是service_manager进程，否则是其它进程
13.                         .......
14.                 } else { //处理service_manager进程
15.                         mutex_lock(&context->context_mgr_node_lock);
16.                         //这个node是在创建service_manager时通过BINDER_SET_CONTEXT_MGR的cmd创建的
17.                         target_node = context->binder_context_mgr_node;
18.                         if (target_node)
19.                                 target_node = binder_get_node_refs_for_txn(
20.                                                 target_node, &target_proc,
21.                                                 &return_error);
22.                         else
23.                                 return_error = BR_DEAD_REPLY;
24.                         mutex_unlock(&context->context_mgr_node_lock);
25.                         if (target_node && target_proc->pid == proc->pid) {
26.                                 binder_user_error("%d:%d got transaction to context manager from process owning it\n",
27.                                                   proc->pid, thread->pid);
28.                                 return_error = BR_FAILED_REPLY;
29.                                 return_error_param = -EINVAL;
30.                                 return_error_line = __LINE__;
31.                                 goto err_invalid_target_handle;
32.                         }
33.                 }
34.                 ......
35.         }
36. }

复制代码

4.2 拷贝客户端binder_transaction_data数据中的data.ptr.offsets到service_manager的mmap内核空间

1. static void binder_transaction(struct binder_proc *proc,
2.                                struct binder_thread *thread,
3.                                struct binder_transaction_data *tr, int reply,
4.                                binder_size_t extra_buffers_size)
5. {
6.         int ret;
7.         struct binder_transaction *t;
8.         struct binder_work *w;
9.         struct binder_work *tcomplete;
10.         binder_size_t buffer_offset = 0;
11.         binder_size_t off_start_offset, off_end_offset;
12.         binder_size_t off_min;
13.         binder_size_t sg_buf_offset, sg_buf_end_offset;
14.         binder_size_t user_offset = 0;
15.         struct binder_proc *target_proc = NULL;
16.         struct binder_thread *target_thread = NULL;
17.         struct binder_node *target_node = NULL;
18.         struct binder_transaction *in_reply_to = NULL;
19.         struct binder_transaction_log_entry *e;
20.         uint32_t return_error = 0;
21.         uint32_t return_error_param = 0;
22.         uint32_t return_error_line = 0;
23.         binder_size_t last_fixup_obj_off = 0;
24.         binder_size_t last_fixup_min_off = 0;
25.         struct binder_context *context = proc->context;
26.         int t_debug_id = atomic_inc_return(&binder_last_id);
27.         ktime_t t_start_time = ktime_get();
28.         char *secctx = NULL;
29.         u32 secctx_sz = 0;
30.         struct list_head sgc_head;
31.         struct list_head pf_head;
32.         const void __user *user_buffer = (const void __user *)
33.                                 (uintptr_t)tr->data.ptr.buffer;
34.         INIT_LIST_HEAD(&sgc_head);
35.         INIT_LIST_HEAD(&pf_head);
37.         e = binder_transaction_log_add(&binder_transaction_log);
38.         e->debug_id = t_debug_id;
39.         e->call_type = reply ? 2 : !!(tr->flags & TF_ONE_WAY);
40.         e->from_proc = proc->pid;
41.         e->from_thread = thread->pid;
42.         e->target_handle = tr->target.handle;
43.         e->data_size = tr->data_size;
44.         e->offsets_size = tr->offsets_size;
45.         strscpy(e->context_name, proc->context->name, BINDERFS_MAX_NAME);
47.         binder_inner_proc_lock(proc);
48.         binder_set_extended_error(&thread->ee, t_debug_id, BR_OK, 0);
49.         binder_inner_proc_unlock(proc);
51.         if (reply) {// 找到要回复的进程
52.                 ......
53.         } else {// 1. 找到要发送的目的进程
54.                 if (tr->target.handle) { // 目的进程非service_manager进程
55.                        .....
56.                 } else { //目的进程是service_manager进程
57.                         // 找到service_manager的binder_node节点
58.                         .....
59.                 }
60.                 ......
61.         }
62.         if (target_thread)
63.                 e->to_thread = target_thread->pid;
64.         e->to_proc = target_proc->pid;
66.         /* TODO: reuse incoming transaction for reply */
67.         // 为binder_transcation分配内存
68.         t = kzalloc(sizeof(*t), GFP_KERNEL);
69.         
70.         .....
72.         if (!reply && !(tr->flags & TF_ONE_WAY))
73.                 t->from = thread;
74.         else
75.                 t->from = NULL;
76.         // 存储发送双方的基本信息
77.         t->from_pid = proc->pid;
78.         t->from_tid = thread->pid;
79.         t->sender_euid = task_euid(proc->tsk);
80.         t->to_proc = target_proc;
81.         t->to_thread = target_thread;
82.         t->code = tr->code;
83.         t->flags = tr->flags;
84.         t->priority = task_nice(current);
86.         ......
88.         t->buffer = binder_alloc_new_buf(&target_proc->alloc, tr->data_size,
89.                 tr->offsets_size, extra_buffers_size,
90.                 !reply && (t->flags & TF_ONE_WAY));
91.         ......
92.         
93.         t->buffer->debug_id = t->debug_id;
94.         t->buffer->transaction = t;
95.         t->buffer->target_node = target_node;
96.         t->buffer->clear_on_free = !!(t->flags & TF_CLEAR_BUF);
97.         trace_binder_transaction_alloc_buf(t->buffer);
98.         
99.         // 把客户端的数据拷贝到目的进程service_manager mmap的内存空间,即t->buffer指向的内存空间
100.         if (binder_alloc_copy_user_to_buffer(
101.                                 &target_proc->alloc,
102.                                 t->buffer,
103.                                 ALIGN(tr->data_size, sizeof(void *)),
104.                                 (const void __user *)
105.                                         (uintptr_t)tr->data.ptr.offsets,
106.                                 tr->offsets_size)) {
107.                 binder_user_error("%d:%d got transaction with invalid offsets ptr\n",
108.                                 proc->pid, thread->pid);
109.                 return_error = BR_FAILED_REPLY;
110.                 return_error_param = -EFAULT;
111.                 return_error_line = __LINE__;
112.                 goto err_copy_data_failed;
113.         }
114.         ......
115. }
117. /**
118. * binder_alloc_copy_user_to_buffer() - copy src user to tgt user
119. * @alloc: binder_alloc for this proc
120. * @buffer: binder buffer to be accessed
121. * @buffer_offset: offset into @buffer data
122. * @from: userspace pointer to source buffer
123. * @bytes: bytes to copy
124. *
125. * Copy bytes from source userspace to target buffer.
126. *
127. * Return: bytes remaining to be copied
128. */
129. unsigned long
130. binder_alloc_copy_user_to_buffer(struct binder_alloc *alloc,
131.                                  struct binder_buffer *buffer,
132.                                  binder_size_t buffer_offset,
133.                                  const void __user *from,
134.                                  size_t bytes)
135. {
136.         if (!check_buffer(alloc, buffer, buffer_offset, bytes))
137.                 return bytes;
139.         while (bytes) {
140.                 unsigned long size;
141.                 unsigned long ret;
142.                 struct page *page;
143.                 pgoff_t pgoff;
144.                 void *kptr;
146.                 page = binder_alloc_get_page(alloc, buffer,
147.                                              buffer_offset, &pgoff);
148.                 size = min_t(size_t, bytes, PAGE_SIZE - pgoff);
149.                 kptr = kmap_local_page(page) + pgoff;
150.                 // 拷贝服务端数据到service_manager mmap的内核内存空间
151.                 ret = copy_from_user(kptr, from, size);
152.                 kunmap_local(kptr);
153.                 if (ret)
154.                         return bytes - size + ret;
155.                 bytes -= size;
156.                 from += size;
157.                 buffer_offset += size;
158.         }
159.         return 0;
160. }

复制代码

4.3 拷贝客户端binder_transaction_data数据中的data.ptr.buffer到service_manager的mmap内核空间

1. static void binder_transaction(struct binder_proc *proc,
2.                                struct binder_thread *thread,
3.                                struct binder_transaction_data *tr, int reply,
4.                                binder_size_t extra_buffers_size)
5. {
6.         int ret;
7.         struct binder_transaction *t;
8.         struct binder_work *w;
9.         struct binder_work *tcomplete;
10.         binder_size_t buffer_offset = 0;
11.         binder_size_t off_start_offset, off_end_offset;
12.         binder_size_t off_min;
13.         binder_size_t sg_buf_offset, sg_buf_end_offset;
14.         binder_size_t user_offset = 0;
15.         struct binder_proc *target_proc = NULL;
16.         struct binder_thread *target_thread = NULL;
17.         struct binder_node *target_node = NULL;
18.         struct binder_transaction *in_reply_to = NULL;
19.         struct binder_transaction_log_entry *e;
20.         uint32_t return_error = 0;
21.         uint32_t return_error_param = 0;
22.         uint32_t return_error_line = 0;
23.         binder_size_t last_fixup_obj_off = 0;
24.         binder_size_t last_fixup_min_off = 0;
25.         struct binder_context *context = proc->context;
26.         int t_debug_id = atomic_inc_return(&binder_last_id);
27.         ktime_t t_start_time = ktime_get();
28.         char *secctx = NULL;
29.         u32 secctx_sz = 0;
30.         struct list_head sgc_head;
31.         struct list_head pf_head;
32.         const void __user *user_buffer = (const void __user *)
33.                                 (uintptr_t)tr->data.ptr.buffer;
34.         INIT_LIST_HEAD(&sgc_head);
35.         INIT_LIST_HEAD(&pf_head);
37.         e = binder_transaction_log_add(&binder_transaction_log);
38.         e->debug_id = t_debug_id;
39.         e->call_type = reply ? 2 : !!(tr->flags & TF_ONE_WAY);
40.         e->from_proc = proc->pid;
41.         e->from_thread = thread->pid;
42.         e->target_handle = tr->target.handle;
43.         e->data_size = tr->data_size;
44.         e->offsets_size = tr->offsets_size;
45.         strscpy(e->context_name, proc->context->name, BINDERFS_MAX_NAME);
47.         binder_inner_proc_lock(proc);
48.         binder_set_extended_error(&thread->ee, t_debug_id, BR_OK, 0);
49.         binder_inner_proc_unlock(proc);
51.         if (reply) {// 找到要回复的进程
52.                 ......
53.         } else {// 1. 找到要发送的目的进程
54.                 if (tr->target.handle) { // 目的进程非service_manager进程
55.                        .....
56.                 } else { //目的进程是service_manager进程
57.                         // 找到service_manager的binder_node节点
58.                         .....
59.                 }
60.                 ......
61.         }
62.         if (target_thread)
63.                 e->to_thread = target_thread->pid;
64.         e->to_proc = target_proc->pid;
66.         /* TODO: reuse incoming transaction for reply */
67.         // 为binder_transcation分配内存
68.         t = kzalloc(sizeof(*t), GFP_KERNEL);
69.         
70.         .....
72.         if (!reply && !(tr->flags & TF_ONE_WAY))
73.                 t->from = thread;
74.         else
75.                 t->from = NULL;
76.         // 存储发送双方的基本信息
77.         t->from_pid = proc->pid;
78.         t->from_tid = thread->pid;
79.         t->sender_euid = task_euid(proc->tsk);
80.         t->to_proc = target_proc;
81.         t->to_thread = target_thread;
82.         t->code = tr->code;
83.         t->flags = tr->flags;
84.         t->priority = task_nice(current);
86.         ......
88.         t->buffer = binder_alloc_new_buf(&target_proc->alloc, tr->data_size,
89.                 tr->offsets_size, extra_buffers_size,
90.                 !reply && (t->flags & TF_ONE_WAY));
91.         ......
92.         
93.         t->buffer->debug_id = t->debug_id;
94.         t->buffer->transaction = t;
95.         t->buffer->target_node = target_node;
96.         t->buffer->clear_on_free = !!(t->flags & TF_CLEAR_BUF);
97.         trace_binder_transaction_alloc_buf(t->buffer);
98.         
99.         // 把客户端的数据拷贝到目的进程service_manager mmap的内存空间,即t->buffer指向的内存空间
100.         if (binder_alloc_copy_user_to_buffer(
101.                                 &target_proc->alloc,
102.                                 t->buffer,
103.                                 ALIGN(tr->data_size, sizeof(void *)),
104.                                 (const void __user *)
105.                                         (uintptr_t)tr->data.ptr.offsets,
106.                                 tr->offsets_size)) {
107.                 binder_user_error("%d:%d got transaction with invalid offsets ptr\n",
108.                                 proc->pid, thread->pid);
109.                 return_error = BR_FAILED_REPLY;
110.                 return_error_param = -EFAULT;
111.                 return_error_line = __LINE__;
112.                 goto err_copy_data_failed;
113.         }
114.         
115.         ......
117.                 /* Done processing objects, copy the rest of the buffer */
118.                 if (binder_alloc_copy_user_to_buffer(
119.                                         &target_proc->alloc,
120.                                         t->buffer, user_offset,
121.                                         user_buffer + user_offset,
122.                                         tr->data_size - user_offset)) {
123.                         binder_user_error("%d:%d got transaction with invalid data ptr\n",
124.                                         proc->pid, thread->pid);
125.                         return_error = BR_FAILED_REPLY;
126.                         return_error_param = -EFAULT;
127.                         return_error_line = __LINE__;
128.                         goto err_copy_data_failed;
129.                 }
130.                
131.                 ......
132. }

复制代码

4.4 把待处理的数据放到目的进程service_manager的binder_proc或binder_thread的todo链表

1. static void binder_transaction(struct binder_proc *proc,
2.                                struct binder_thread *thread,
3.                                struct binder_transaction_data *tr, int reply,
4.                                binder_size_t extra_buffers_size)
5. {
6.         int ret;
7.         struct binder_transaction *t;
8.         struct binder_work *w;
9.         struct binder_work *tcomplete;
10.         binder_size_t buffer_offset = 0;
11.         binder_size_t off_start_offset, off_end_offset;
12.         binder_size_t off_min;
13.         binder_size_t sg_buf_offset, sg_buf_end_offset;
14.         binder_size_t user_offset = 0;
15.         struct binder_proc *target_proc = NULL;
16.         struct binder_thread *target_thread = NULL;
17.         struct binder_node *target_node = NULL;
18.         struct binder_transaction *in_reply_to = NULL;
19.         struct binder_transaction_log_entry *e;
20.         uint32_t return_error = 0;
21.         uint32_t return_error_param = 0;
22.         uint32_t return_error_line = 0;
23.         binder_size_t last_fixup_obj_off = 0;
24.         binder_size_t last_fixup_min_off = 0;
25.         struct binder_context *context = proc->context;
26.         int t_debug_id = atomic_inc_return(&binder_last_id);
27.         ktime_t t_start_time = ktime_get();
28.         char *secctx = NULL;
29.         u32 secctx_sz = 0;
30.         struct list_head sgc_head;
31.         struct list_head pf_head;
32.         const void __user *user_buffer = (const void __user *)
33.                                 (uintptr_t)tr->data.ptr.buffer;
34.         INIT_LIST_HEAD(&sgc_head);
35.         INIT_LIST_HEAD(&pf_head);
37.         e = binder_transaction_log_add(&binder_transaction_log);
38.         e->debug_id = t_debug_id;
39.         e->call_type = reply ? 2 : !!(tr->flags & TF_ONE_WAY);
40.         e->from_proc = proc->pid;
41.         e->from_thread = thread->pid;
42.         e->target_handle = tr->target.handle;
43.         e->data_size = tr->data_size;
44.         e->offsets_size = tr->offsets_size;
45.         strscpy(e->context_name, proc->context->name, BINDERFS_MAX_NAME);
47.         binder_inner_proc_lock(proc);
48.         binder_set_extended_error(&thread->ee, t_debug_id, BR_OK, 0);
49.         binder_inner_proc_unlock(proc);
51.         if (reply) {// 找到要回复的进程
52.                 ......
53.         } else {// 1. 找到要发送的目的进程
54.                 if (tr->target.handle) { // 目的进程非service_manager进程
55.                        .....
56.                 } else { //目的进程是service_manager进程
57.                         // 找到service_manager的binder_node节点
58.                         .....
59.                 }
60.                 ......
61.         }
62.         if (target_thread)
63.                 e->to_thread = target_thread->pid;
64.         e->to_proc = target_proc->pid;
66.         /* TODO: reuse incoming transaction for reply */
67.         // 为binder_transcation分配内存
68.         t = kzalloc(sizeof(*t), GFP_KERNEL);
69.         
70.         .....
72.         if (!reply && !(tr->flags & TF_ONE_WAY))
73.                 t->from = thread;
74.         else
75.                 t->from = NULL;
76.         // 存储发送双方的基本信息
77.         t->from_pid = proc->pid;
78.         t->from_tid = thread->pid;
79.         t->sender_euid = task_euid(proc->tsk);
80.         t->to_proc = target_proc;
81.         t->to_thread = target_thread;
82.         t->code = tr->code;
83.         t->flags = tr->flags;
84.         t->priority = task_nice(current);
86.         ......
88.         t->buffer = binder_alloc_new_buf(&target_proc->alloc, tr->data_size,
89.                 tr->offsets_size, extra_buffers_size,
90.                 !reply && (t->flags & TF_ONE_WAY));
91.         ......
92.         
93.         t->buffer->debug_id = t->debug_id;
94.         t->buffer->transaction = t;
95.         t->buffer->target_node = target_node;
96.         t->buffer->clear_on_free = !!(t->flags & TF_CLEAR_BUF);
97.         trace_binder_transaction_alloc_buf(t->buffer);
98.         
99.         // 把客户端的数据拷贝到目的进程service_manager mmap的内存空间,即t->buffer指向的内存空间
100.         if (binder_alloc_copy_user_to_buffer(
101.                                 &target_proc->alloc,
102.                                 t->buffer,
103.                                 ALIGN(tr->data_size, sizeof(void *)),
104.                                 (const void __user *)
105.                                         (uintptr_t)tr->data.ptr.offsets,
106.                                 tr->offsets_size)) {
107.                 binder_user_error("%d:%d got transaction with invalid offsets ptr\n",
108.                                 proc->pid, thread->pid);
109.                 return_error = BR_FAILED_REPLY;
110.                 return_error_param = -EFAULT;
111.                 return_error_line = __LINE__;
112.                 goto err_copy_data_failed;
113.         }
114.         
115.         ......
117.                 /* Done processing objects, copy the rest of the buffer */
118.                 if (binder_alloc_copy_user_to_buffer(
119.                                         &target_proc->alloc,
120.                                         t->buffer, user_offset,
121.                                         user_buffer + user_offset,
122.                                         tr->data_size - user_offset)) {
123.                         binder_user_error("%d:%d got transaction with invalid data ptr\n",
124.                                         proc->pid, thread->pid);
125.                         return_error = BR_FAILED_REPLY;
126.                         return_error_param = -EFAULT;
127.                         return_error_line = __LINE__;
128.                         goto err_copy_data_failed;
129.                 }
130.                
131.                 ......
132.                
133.                 t->work.type = BINDER_WORK_TRANSACTION;
135.                 if (reply) {
136.                         ......
137.                 } else if (!(t->flags & TF_ONE_WAY)) {
138.                         BUG_ON(t->buffer->async_transaction != 0);
139.                         binder_inner_proc_lock(proc);
140.                         /*
141.                          * Defer the TRANSACTION_COMPLETE, so we don't return to
142.                          * userspace immediately; this allows the target process to
143.                          * immediately start processing this transaction, reducing
144.                          * latency. We will then return the TRANSACTION_COMPLETE when
145.                          * the target replies (or there is an error).
146.                          */
147.                         binder_enqueue_deferred_thread_work_ilocked(thread, tcomplete);
148.                         t->need_reply = 1;
149.                         t->from_parent = thread->transaction_stack;
150.                         //入栈
151.                         thread->transaction_stack = t;
152.                         binder_inner_proc_unlock(proc);
153.                         //将数据放入目的进程的binder_proc或binder_thread的todo链表
154.                         return_error = binder_proc_transaction(t,
155.                                         target_proc, target_thread);
156.                         if (return_error) {
157.                                 binder_inner_proc_lock(proc);
158.                                 binder_pop_transaction_ilocked(thread, t);
159.                                 binder_inner_proc_unlock(proc);
160.                                 goto err_dead_proc_or_thread;
161.                         }
162.                 } else {
163.                         ......
164.                 }
165. }

复制代码

4.5 binder_proc_transaction将待处理的数据放到service_manager的todo链表，并叫醒service_manager

1. static int binder_proc_transaction(struct binder_transaction *t,
2.                                     struct binder_proc *proc,
3.                                     struct binder_thread *thread)
4. {
5.         struct binder_node *node = t->buffer->target_node;
6.         bool oneway = !!(t->flags & TF_ONE_WAY);
7.         bool pending_async = false;
8.         struct binder_transaction *t_outdated = NULL;
9.         bool frozen = false;
11.         BUG_ON(!node);
12.         binder_node_lock(node);
13.         if (oneway) {
14.                 BUG_ON(thread);
15.                 if (node->has_async_transaction)
16.                         pending_async = true;
17.                 else
18.                         node->has_async_transaction = true;
19.         }
21.         binder_inner_proc_lock(proc);
22.         if (proc->is_frozen) {
23.                 frozen = true;
24.                 proc->sync_recv |= !oneway;
25.                 proc->async_recv |= oneway;
26.         }
28.         if ((frozen && !oneway) || proc->is_dead ||
29.                         (thread && thread->is_dead)) {
30.                 binder_inner_proc_unlock(proc);
31.                 binder_node_unlock(node);
32.                 return frozen ? BR_FROZEN_REPLY : BR_DEAD_REPLY;
33.         }
35.         if (!thread && !pending_async)
36.                 thread = binder_select_thread_ilocked(proc);
38.         if (thread) {
39.                 binder_enqueue_thread_work_ilocked(thread, &t->work);//将数据放入目的进程的binder_thread
40.         } else if (!pending_async) {
41.                 binder_enqueue_work_ilocked(&t->work, &proc->todo);//将数据放入目的进程的binder_proc
42.         } else {
43.                 if ((t->flags & TF_UPDATE_TXN) && frozen) {
44.                         t_outdated = binder_find_outdated_transaction_ilocked(t,
45.                                                                               &node->async_todo);
46.                         if (t_outdated) {
47.                                 binder_debug(BINDER_DEBUG_TRANSACTION,
48.                                              "txn %d supersedes %d\n",
49.                                              t->debug_id, t_outdated->debug_id);
50.                                 list_del_init(&t_outdated->work.entry);
51.                                 proc->outstanding_txns--;
52.                         }
53.                 }
54.                 binder_enqueue_work_ilocked(&t->work, &node->async_todo);
55.         }
57.         if (!pending_async)
58.                 binder_wakeup_thread_ilocked(proc, thread, !oneway /* sync */);
60.         proc->outstanding_txns++;
61.         binder_inner_proc_unlock(proc);
62.         binder_node_unlock(node);
64.         /*
65.          * To reduce potential contention, free the outdated transaction and
66.          * buffer after releasing the locks.
67.          */
68.         if (t_outdated) {
69.                 struct binder_buffer *buffer = t_outdated->buffer;
71.                 t_outdated->buffer = NULL;
72.                 buffer->transaction = NULL;
73.                 trace_binder_transaction_update_buffer_release(buffer);
74.                 binder_release_entire_buffer(proc, NULL, buffer, false);
75.                 binder_alloc_free_buf(&proc->alloc, buffer);
76.                 kfree(t_outdated);
77.                 binder_stats_deleted(BINDER_STAT_TRANSACTION);
78.         }
80.         if (oneway && frozen)
81.                 return BR_TRANSACTION_PENDING_FROZEN;
83.         return 0;
84. }
86. static void
87. binder_enqueue_thread_work_ilocked(struct binder_thread *thread,
88.                                    struct binder_work *work)
89. {
90.         WARN_ON(!list_empty(&thread->waiting_thread_node));
91.         binder_enqueue_work_ilocked(work, &thread->todo); // 将待处理的数据放到thread的todo链表
93.         /* (e)poll-based threads require an explicit wakeup signal when
94.          * queuing their own work; they rely on these events to consume
95.          * messages without I/O block. Without it, threads risk waiting
96.          * indefinitely without handling the work.
97.          */
98.         if (thread->looper & BINDER_LOOPER_STATE_POLL &&
99.             thread->pid == current->pid && !thread->process_todo)
100.             // 唤醒service_manager
101.                 wake_up_interruptible_sync(&thread->wait);
103.         thread->process_todo = true;
104. }
106. static void
107. binder_enqueue_work_ilocked(struct binder_work *work,
108.                            struct list_head *target_list)
109. {
110.         BUG_ON(target_list == NULL);
111.         BUG_ON(work->entry.next && !list_empty(&work->entry));
112.         list_add_tail(&work->entry, target_list);
113. }

复制代码

2.2. service_manager被叫醒

1. service_manager发送ioctl读取内核中的数据

1. int main(int argc, char **argv)
2. {
3.     struct binder_state *bs;
5.     bs = binder_open(128*1024);
6.     if (!bs) {
7.         ALOGE("failed to open binder driver\n");
8.         return -1;
9.     }
11.     if (binder_become_context_manager(bs)) {
12.         ALOGE("cannot become context manager (%s)\n", strerror(errno));
13.         return -1;
14.     }
17.     svcmgr_handle = BINDER_SERVICE_MANAGER;
18.     binder_loop(bs, svcmgr_handler);
20.     return 0;
21. }
23. void binder_loop(struct binder_state *bs, binder_handler func)
24. {
25.     int res;
26.     struct binder_write_read bwr;
27.     uint32_t readbuf[32];
29.     bwr.write_size = 0;
30.     bwr.write_consumed = 0;
31.     bwr.write_buffer = 0;
33.     readbuf[0] = BC_ENTER_LOOPER;
34.     binder_write(bs, readbuf, sizeof(uint32_t));
36.     for (;;) {
37.         bwr.read_size = sizeof(readbuf);
38.         bwr.read_consumed = 0;
39.         bwr.read_buffer = (uintptr_t) readbuf;
40.         
41.         // 发起读操作
42.         res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
44.         if (res < 0) {
45.             ALOGE("binder_loop: ioctl failed (%s)\n", strerror(errno));
46.             break;
47.         }
49.         res = binder_parse(bs, 0, (uintptr_t) readbuf, bwr.read_consumed, func);
50.         if (res == 0) {
51.             ALOGE("binder_loop: unexpected reply?!\n");
52.             break;
53.         }
54.         if (res < 0) {
55.             ALOGE("binder_loop: io error %d %s\n", res, strerror(errno));
56.             break;
57.         }
58.     }
59. }

复制代码

2. binder_ioctl

1. // res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);进入binder驱动程序
2. static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
3. {
4.         int ret;
5.         struct binder_proc *proc = filp->private_data;
6.         struct binder_thread *thread;
7.         void __user *ubuf = (void __user *)arg;
9.         /*pr_info("binder_ioctl: %d:%d %x %lx\n",
10.                         proc->pid, current->pid, cmd, arg);*/
12.         binder_selftest_alloc(&proc->alloc);
14.         trace_binder_ioctl(cmd, arg);
16.         ret = wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2);
17.         if (ret)
18.                 goto err_unlocked;
20.         //为进程proc创建binder_thread
21.         thread = binder_get_thread(proc);
22.         if (thread == NULL) {
23.                 ret = -ENOMEM;
24.                 goto err;
25.         }
27.         switch (cmd) {
28.         case BINDER_WRITE_READ:
29.                 ret = binder_ioctl_write_read(filp, arg, thread);
30.                 if (ret)
31.                         goto err;
32.                 break;
33.                 ......
34.         }
35.         ......
36. }

复制代码

3. binder_ioctl_write_read

1. static int binder_ioctl_write_read(struct file *filp, unsigned long arg,
2.                                 struct binder_thread *thread)
3. {
4.         int ret = 0;
5.         struct binder_proc *proc = filp->private_data;
6.         void __user *ubuf = (void __user *)arg;
7.         struct binder_write_read bwr;
9.     //从用户空间拷贝数据到内核空间（这部分内核空间被mmap映射到了目标进程）
10.         if (copy_from_user(&bwr, ubuf, sizeof(bwr))) {
11.                 ret = -EFAULT;
12.                 goto out;
13.         }
14.         binder_debug(BINDER_DEBUG_READ_WRITE,
15.                      "%d:%d write %lld at %016llx, read %lld at %016llx\n",
16.                      proc->pid, thread->pid,
17.                      (u64)bwr.write_size, (u64)bwr.write_buffer,
18.                      (u64)bwr.read_size, (u64)bwr.read_buffer);
20.         if (bwr.write_size > 0) {
21.                 ......
22.         }
23.         if (bwr.read_size > 0) {
24.                 ret = binder_thread_read(proc, thread, bwr.read_buffer,
25.                                          bwr.read_size,
26.                                          &bwr.read_consumed,
27.                                          filp->f_flags & O_NONBLOCK);
28.                 trace_binder_read_done(ret);
29.                 binder_inner_proc_lock(proc);
30.                 if (!binder_worklist_empty_ilocked(&proc->todo))
31.                         binder_wakeup_proc_ilocked(proc);
32.                 binder_inner_proc_unlock(proc);
33.                 if (ret < 0) {
34.                         if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
35.                                 ret = -EFAULT;
36.                         goto out;
37.                 }
38.         }
39.         binder_debug(BINDER_DEBUG_READ_WRITE,
40.                      "%d:%d wrote %lld of %lld, read return %lld of %lld\n",
41.                      proc->pid, thread->pid,
42.                      (u64)bwr.write_consumed, (u64)bwr.write_size,
43.                      (u64)bwr.read_consumed, (u64)bwr.read_size);
44.         if (copy_to_user(ubuf, &bwr, sizeof(bwr))) {
45.                 ret = -EFAULT;
46.                 goto out;
47.         }
48. out:
49.         return ret;
50. }

复制代码

4. binder_thread_read

读取service_manager内核空间的数据，写入service_manager用户空间

1. static int binder_thread_read(struct binder_proc *proc,
2.                               struct binder_thread *thread,
3.                               binder_uintptr_t binder_buffer, size_t size,
4.                               binder_size_t *consumed, int non_block)
5. {
6.         void __user *buffer = (void __user *)(uintptr_t)binder_buffer;
7.         void __user *ptr = buffer + *consumed;
8.         void __user *end = buffer + size;
10.         int ret = 0;
11.         int wait_for_proc_work;
13.         if (*consumed == 0) {
14.                 if (put_user(BR_NOOP, (uint32_t __user *)ptr))//对于所有的读操作，数据头部都是BR_NOOP
15.                         return -EFAULT;
16.                 ptr += sizeof(uint32_t);
17.         }
19. retry:
20.         binder_inner_proc_lock(proc);
21.         wait_for_proc_work = binder_available_for_proc_work_ilocked(thread);
22.         binder_inner_proc_unlock(proc);
24.         thread->looper |= BINDER_LOOPER_STATE_WAITING;
26.         trace_binder_wait_for_work(wait_for_proc_work,
27.                                    !!thread->transaction_stack,
28.                                    !binder_worklist_empty(proc, &thread->todo));
29.         if (wait_for_proc_work) {
30.                 if (!(thread->looper & (BINDER_LOOPER_STATE_REGISTERED |
31.                                         BINDER_LOOPER_STATE_ENTERED))) {
32.                         binder_user_error("%d:%d ERROR: Thread waiting for process work before calling BC_REGISTER_LOOPER or BC_ENTER_LOOPER (state %x)\n",
33.                                 proc->pid, thread->pid, thread->looper);
34.                         wait_event_interruptible(binder_user_error_wait,
35.                                                  binder_stop_on_user_error < 2);
36.                 }
37.                 binder_set_nice(proc->default_priority);
38.         }
40.     //没有数据就休眠
41.         if (non_block) {
42.                 if (!binder_has_work(thread, wait_for_proc_work))
43.                         ret = -EAGAIN;
44.         } else {
45.                 ret = binder_wait_for_work(thread, wait_for_proc_work);
46.         }
48.         thread->looper &= ~BINDER_LOOPER_STATE_WAITING;
49.        
50.         if (ret)
51.                 return ret;
53.         while (1) {
54.                 uint32_t cmd;
55.                 struct binder_transaction_data_secctx tr;
56.                 struct binder_transaction_data *trd = &tr.transaction_data;
57.                 struct binder_work *w = NULL;
58.                 struct list_head *list = NULL;
59.                 struct binder_transaction *t = NULL;
60.                 struct binder_thread *t_from;
61.                 size_t trsize = sizeof(*trd);
63.                 binder_inner_proc_lock(proc);
64.                 //如果proc的thread->todo链表有数据，拿到链表数据
65.                 if (!binder_worklist_empty_ilocked(&thread->todo))
66.                         list = &thread->todo;
67.                 //如果proc->todo链表有数据，拿到链表数据
68.                 else if (!binder_worklist_empty_ilocked(&proc->todo) &&
69.                            wait_for_proc_work)
70.                         list = &proc->todo;
71.                 else {
72.                         binder_inner_proc_unlock(proc);
74.                         /* no data added */
75.                         if (ptr - buffer == 4 && !thread->looper_need_return)
76.                                 goto retry;
77.                         break;
78.                 }
80.                 if (end - ptr < sizeof(tr) + 4) {
81.                         binder_inner_proc_unlock(proc);
82.                         break;
83.                 }
84.                 w = binder_dequeue_work_head_ilocked(list);
85.                 if (binder_worklist_empty_ilocked(&thread->todo))
86.                         thread->process_todo = false;
88.                 //逐个处理相关类型的数据,server唤醒service_manager，将数据添加到链表时，binder_work.type是BINDER_WORK_TRANSACTION
89.                 switch (w->type) {
90.                 case BINDER_WORK_TRANSACTION: {
91.                         binder_inner_proc_unlock(proc);
92.                          t= container_of(w, struct binder_transaction, work);//构造出发送方发来的binder_transaction
93.                 } break;
94.                
95.                 ......
96.                
97.                 }
99.                 if (!t)
100.                         continue;
102.                 BUG_ON(t->buffer == NULL);
103.                 if (t->buffer->target_node) {
104.                         struct binder_node *target_node = t->buffer->target_node;
106.                         trd->target.ptr = target_node->ptr;
107.                         trd->cookie =  target_node->cookie;
108.                         t->saved_priority = task_nice(current);
109.                         if (t->priority < target_node->min_priority &&
110.                             !(t->flags & TF_ONE_WAY))
111.                                 binder_set_nice(t->priority);
112.                         else if (!(t->flags & TF_ONE_WAY) ||
113.                                  t->saved_priority > target_node->min_priority)
114.                                 binder_set_nice(target_node->min_priority);
115.             //从server发送数据给service_manager，cmd是BC_TRANSACTION
116.             //从service_manager返回数据给server,将cmd设为BR_TRANSACTION，
117.                         cmd = BR_TRANSACTION;
118.                 } else {
119.                         trd->target.ptr = 0;
120.                         trd->cookie = 0;
121.                         cmd = BR_REPLY;
122.                 }
123.                 trd->code = t->code;
124.                 trd->flags = t->flags;
125.                 trd->sender_euid = from_kuid(current_user_ns(), t->sender_euid);
127.                 ......
128.                
129.                 trd->data_size = t->buffer->data_size;
130.                 trd->offsets_size = t->buffer->offsets_size;
131.                 trd->data.ptr.buffer = t->buffer->user_data;
132.                 trd->data.ptr.offsets = trd->data.ptr.buffer +
133.                                         ALIGN(t->buffer->data_size,
134.                                             sizeof(void *));
136.                 tr.secctx = t->security_ctx;
137.                 if (t->security_ctx) {
138.                         cmd = BR_TRANSACTION_SEC_CTX;
139.                         trsize = sizeof(tr);
140.                 }
141.                 // 把cmd写入service_manager的用户空间
142.                 if (put_user(cmd, (uint32_t __user *)ptr)) {
143.                         if (t_from)
144.                                 binder_thread_dec_tmpref(t_from);
146.                         binder_cleanup_transaction(t, "put_user failed",
147.                                                    BR_FAILED_REPLY);
149.                         return -EFAULT;
150.                 }
151.                 ptr += sizeof(uint32_t);
152.                 // 把tr写入service_manager的用户空间，tr.transaction_data中包括了客户端发送来的数据
153.                 if (copy_to_user(ptr, &tr, trsize)) {
154.                         if (t_from)
155.                                 binder_thread_dec_tmpref(t_from);
157.                         binder_cleanup_transaction(t, "copy_to_user failed",
158.                                                    BR_FAILED_REPLY);
160.                         return -EFAULT;
161.                 }
162.                 ptr += trsize;
164.                 ......
166. done:
168.         ......
169.        
170.         return 0;
171. }

复制代码

5. 从service_manager内核空间读取到的数据构造形式

6. binder_parse剖析客户端发送给service_manager的数据

此时cmd是BR_TRANSACTION

1. void binder_loop(struct binder_state *bs, binder_handler func)
2. {
3.     int res;
4.     struct binder_write_read bwr;
5.     uint32_t readbuf[32];
7.     bwr.write_size = 0;
8.     bwr.write_consumed = 0;
9.     bwr.write_buffer = 0;
11.     readbuf[0] = BC_ENTER_LOOPER;
12.     binder_write(bs, readbuf, sizeof(uint32_t));
14.     for (;;) {
15.         bwr.read_size = sizeof(readbuf);
16.         bwr.read_consumed = 0;
17.         bwr.read_buffer = (uintptr_t) readbuf;
19.         res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);//读到数据
21.         if (res < 0) {
22.             ALOGE("binder_loop: ioctl failed (%s)\n", strerror(errno));
23.             break;
24.         }
25.         
26.         //解析读到的数据
27.         res = binder_parse(bs, 0, (uintptr_t) readbuf, bwr.read_consumed, func);
28.         if (res == 0) {
29.             ALOGE("binder_loop: unexpected reply?!\n");
30.             break;
31.         }
32.         if (res < 0) {
33.             ALOGE("binder_loop: io error %d %s\n", res, strerror(errno));
34.             break;
35.         }
36.     }
37. }
39. int binder_parse(struct binder_state *bs, struct binder_io *bio,
40.                  uintptr_t ptr, size_t size, binder_handler func)
41. {
42.     int r = 1;
43.     uintptr_t end = ptr + (uintptr_t) size;
45.     while (ptr < end) {
46.         uint32_t cmd = *(uint32_t *) ptr;
47.         ptr += sizeof(uint32_t);
48. #if TRACE
49.         fprintf(stderr,"%s:\n", cmd_name(cmd));
50. #endif
51.         switch(cmd) {
52.         case BR_NOOP:
53.             break;
54.         ......
55.         //收到数据的处理情况，（收到的数据中有服务名称，服务的handle）
56.         case BR_TRANSACTION: {
57.             struct binder_transaction_data *txn = (struct binder_transaction_data *) ptr;
58.             if ((end - ptr) < sizeof(*txn)) {
59.                 ALOGE("parse: txn too small!\n");
60.                 return -1;
61.             }
62.             binder_dump_txn(txn);
63.             if (func) {
64.                 unsigned rdata[256/4];
65.                 struct binder_io msg;
66.                 struct binder_io reply;
67.                 int res;
68.                 //构造binder_io
69.                 bio_init(&reply, rdata, sizeof(rdata), 4);
70.                 bio_init_from_txn(&msg, txn);
71.                 //处理binde_io
72.                 res = func(bs, txn, &msg, &reply); // func = svcmgr_handler,用于添加/获取服务
73.                 //将处理完的数据，发送给server
74.                 binder_send_reply(bs, &reply, txn->data.ptr.buffer, res);
75.             }
76.             ptr += sizeof(*txn);
77.             break;
78.         }
79.         ......
80.         default:
81.             ALOGE("parse: OOPS %d\n", cmd);
82.             return -1;
83.         }
84.     }
86.     return r;
87. }

复制代码

7. svcmgr_handler处理客户端发送给service_manager的数据，获取客户端请求的服务handle

1. int svcmgr_handler(struct binder_state *bs,
2.                    struct binder_transaction_data *txn,
3.                    struct binder_io *msg,
4.                    struct binder_io *reply)
5. {
6.     struct svcinfo *si;
7.     uint16_t *s;
8.     size_t len;
9.     uint32_t handle;
10.     uint32_t strict_policy;
11.     int allow_isolated;
13.     //ALOGI("target=%x code=%d pid=%d uid=%d\n",
14.     //  txn->target.handle, txn->code, txn->sender_pid, txn->sender_euid);
16.     if (txn->target.handle != svcmgr_handle)
17.         return -1;
19.     if (txn->code == PING_TRANSACTION)
20.         return 0;
22.     // Equivalent to Parcel::enforceInterface(), reading the RPC
23.     // header with the strict mode policy mask and the interface name.
24.     // Note that we ignore the strict_policy and don't propagate it
25.     // further (since we do no outbound RPCs anyway).
26.     strict_policy = bio_get_uint32(msg);
27.     s = bio_get_string16(msg, &len); //传入的是android.os.IServiceManager
28.     if (s == NULL) {
29.         return -1;
30.     }
32.     if ((len != (sizeof(svcmgr_id) / 2)) ||
33.         memcmp(svcmgr_id, s, sizeof(svcmgr_id))) {//传入的必须是android.os.IServiceManager
34.         fprintf(stderr,"invalid id %s\n", str8(s, len));
35.         return -1;
36.     }
39.     switch(txn->code) {
40.     case SVC_MGR_GET_SERVICE:
41.     case SVC_MGR_CHECK_SERVICE:
42.         s = bio_get_string16(msg, &len); // 获取客户端要获取的服务的名字"hello"
43.         if (s == NULL) {
44.             return -1;
45.         }
46.         // 在service_manager的服务列表中寻找服务名为hello的服务的handle
47.         handle = do_find_service(bs, s, len, txn->sender_euid, txn->sender_pid);
48.         if (!handle)
49.             break;
50.             
51.         // 将服务handle写入reply
52.         bio_put_ref(reply, handle);
53.         return 0;
55.     ......
57.     bio_put_uint32(reply, 0);//处理完后，最后要构造一个reply，并放入0
58.     return 0;
59. }
61. uint32_t do_find_service(struct binder_state *bs, const uint16_t *s, size_t len, uid_t uid, pid_t spid)
62. {
63.     struct svcinfo *si;
65.     if (!svc_can_find(s, len, spid)) {
66.         ALOGE("find_service('%s') uid=%d - PERMISSION DENIED\n",
67.              str8(s, len), uid);
68.         return 0;
69.     }
70.     si = find_svc(s, len);
71.     //ALOGI("check_service('%s') handle = %x\n", str8(s, len), si ? si->handle : 0);
72.     if (si && si->handle) {
73.         if (!si->allow_isolated) {
74.             // If this service doesn't allow access from isolated processes,
75.             // then check the uid to see if it is isolated.
76.             uid_t appid = uid % AID_USER;
77.             if (appid >= AID_ISOLATED_START && appid <= AID_ISOLATED_END) {
78.                 return 0;
79.             }
80.         }
81.         return si->handle;
82.     } else {
83.         return 0;
84.     }
85. }
87. struct svcinfo *find_svc(const uint16_t *s16, size_t len)
88. {
89.     struct svcinfo *si;
91.     for (si = svclist; si; si = si->next) {
92.         if ((len == si->len) &&
93.             !memcmp(s16, si->name, len * sizeof(uint16_t))) {
94.             return si;
95.         }
96.     }
97.     return NULL;
98. }
100. void bio_put_ref(struct binder_io *bio, uint32_t handle)
101. {
102.     struct flat_binder_object *obj;
104.     if (handle)
105.         obj = bio_alloc_obj(bio);
106.     else
107.         obj = bio_alloc(bio, sizeof(*obj));
109.     if (!obj)
110.         return;
112.     obj->flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
113.     obj->type = BINDER_TYPE_HANDLE;
114.     obj->handle = handle;
115.     obj->cookie = 0;
116. }

复制代码

8. binder_send_reply将获取到的服务handle数据复兴给驱动程序

1. int binder_parse(struct binder_state *bs, struct binder_io *bio,
2.                  uintptr_t ptr, size_t size, binder_handler func)
3. {
4.     int r = 1;
5.     uintptr_t end = ptr + (uintptr_t) size;
7.     while (ptr < end) {
8.         uint32_t cmd = *(uint32_t *) ptr;
9.         ptr += sizeof(uint32_t);
10. #if TRACE
11.         fprintf(stderr,"%s:\n", cmd_name(cmd));
12. #endif
13.         switch(cmd) {
14.         case BR_NOOP:
15.             break;
16.         ......
17.         //收到数据的处理情况，（收到的数据中有服务名称，服务的handle）
18.         case BR_TRANSACTION: {
19.             struct binder_transaction_data *txn = (struct binder_transaction_data *) ptr;
20.             if ((end - ptr) < sizeof(*txn)) {
21.                 ALOGE("parse: txn too small!\n");
22.                 return -1;
23.             }
24.             binder_dump_txn(txn);
25.             if (func) {
26.                 unsigned rdata[256/4];
27.                 struct binder_io msg;
28.                 struct binder_io reply;
29.                 int res;
30.                 //构造binder_io
31.                 bio_init(&reply, rdata, sizeof(rdata), 4);
32.                 bio_init_from_txn(&msg, txn);
33.                 //处理binde_io
34.                 res = func(bs, txn, &msg, &reply); // func = svcmgr_handler,用于添加/获取服务
35.                 //将处理完的数据，发送给server
36.                 binder_send_reply(bs, &reply, txn->data.ptr.buffer, res);
37.             }
38.             ptr += sizeof(*txn);
39.             break;
40.         }
41.         ......
42.         default:
43.             ALOGE("parse: OOPS %d\n", cmd);
44.             return -1;
45.         }
46.     }
48.     return r;
49. }
51. void binder_send_reply(struct binder_state *bs,
52.                        struct binder_io *reply,
53.                        binder_uintptr_t buffer_to_free,
54.                        int status)
55. {
56.     struct {
57.         uint32_t cmd_free;
58.         binder_uintptr_t buffer;
59.         uint32_t cmd_reply;
60.         struct binder_transaction_data txn;
61.     } __attribute__((packed)) data;
63.     data.cmd_free = BC_FREE_BUFFER;//server拷贝到service_manager映射的内核态缓冲区的数据，用完后，就可以释放了
64.     data.buffer = buffer_to_free;
65.     data.cmd_reply = BC_REPLY; // service_manager处理完数据后，将结果回复回去，cmd = BC_REPLY
66.     data.txn.target.ptr = 0;
67.     data.txn.cookie = 0;
68.     data.txn.code = 0;
69.     if (status) {
70.         data.txn.flags = TF_STATUS_CODE;
71.         data.txn.data_size = sizeof(int);
72.         data.txn.offsets_size = 0;
73.         data.txn.data.ptr.buffer = (uintptr_t)&status;
74.         data.txn.data.ptr.offsets = 0;
75.     } else {
76.         data.txn.flags = 0;
77.         data.txn.data_size = reply->data - reply->data0;
78.         data.txn.offsets_size = ((char*) reply->offs) - ((char*) reply->offs0);
79.         data.txn.data.ptr.buffer = (uintptr_t)reply->data0;
80.         data.txn.data.ptr.offsets = (uintptr_t)reply->offs0;
81.     }
82.     binder_write(bs, &data, sizeof(data));
83. }
85. int binder_write(struct binder_state *bs, void *data, size_t len)
86. {
87.     struct binder_write_read bwr;
88.     int res;
90.     bwr.write_size = len;
91.     bwr.write_consumed = 0;
92.     bwr.write_buffer = (uintptr_t) data;
93.     bwr.read_size = 0;
94.     bwr.read_consumed = 0;
95.     bwr.read_buffer = 0;
96.     res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
97.     if (res < 0) {
98.         fprintf(stderr,"binder_write: ioctl failed (%s)\n",
99.                 strerror(errno));
100.     }
101.     return res;
102. }

复制代码

2.3 binder驱动接收到service_manager剖析完客户端发送的数据的数据

1. binder_ioctl

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.         void __user *ubuf = (void __user *)arg;
8.         /*pr_info("binder_ioctl: %d:%d %x %lx\n",
9.                         proc->pid, current->pid, cmd, arg);*/
11.         binder_selftest_alloc(&proc->alloc);
13.         trace_binder_ioctl(cmd, arg);
15.         ret = wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2);
16.         if (ret)
17.                 goto err_unlocked;
19.         //为进程proc创建binder_thread
20.         thread = binder_get_thread(proc);
21.         if (thread == NULL) {
22.                 ret = -ENOMEM;
23.                 goto err;
24.         }
26.         switch (cmd) {
27.         case BINDER_WRITE_READ:
28.                 ret = binder_ioctl_write_read(filp, arg, thread);
29.                 if (ret)
30.                         goto err;
31.                 break;
32.                 ......
33.         }
34.         ......
35. }

复制代码

2. binder_ioctl_write_read

1. static int binder_ioctl_write_read(struct file *filp, unsigned long arg,
2.                                 struct binder_thread *thread)
3. {
4.         int ret = 0;
5.         struct binder_proc *proc = filp->private_data;
6.         void __user *ubuf = (void __user *)arg;
7.         struct binder_write_read bwr;
9.     //从用户空间拷贝数据到内核空间（这部分内核空间被mmap映射到了目标进程）
10.         if (copy_from_user(&bwr, ubuf, sizeof(bwr))) {
11.                 ret = -EFAULT;
12.                 goto out;
13.         }
14.         binder_debug(BINDER_DEBUG_READ_WRITE,
15.                      "%d:%d write %lld at %016llx, read %lld at %016llx\n",
16.                      proc->pid, thread->pid,
17.                      (u64)bwr.write_size, (u64)bwr.write_buffer,
18.                      (u64)bwr.read_size, (u64)bwr.read_buffer);
20.         if (bwr.write_size > 0) {
21.                 ret = binder_thread_write(proc, thread,
22.                                           bwr.write_buffer,
23.                                           bwr.write_size,
24.                                           &bwr.write_consumed);
25.                 trace_binder_write_done(ret);
26.                 if (ret < 0) {
27.                         bwr.read_consumed = 0;
28.                         if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
29.                                 ret = -EFAULT;
30.                         goto out;
31.                 }
32.         }
33.         if (bwr.read_size > 0) {
34.                 ......
35.         }
36.         ......
37. out:
38.         return ret;
39. }

复制代码

3. binder_thread_write

此时cmd是BC_REPLY

1. static int binder_thread_write(struct binder_proc *proc,
2.                         struct binder_thread *thread,
3.                         binder_uintptr_t binder_buffer, size_t size,
4.                         binder_size_t *consumed)
5. {
6.         uint32_t cmd;
7.         struct binder_context *context = proc->context;
8.         // 获取数据buffer，根据上面总结的发送数据可知，这个buffer由cmd和binder_transcation_data两部分数据组成
9.         void __user *buffer = (void __user *)(uintptr_t)binder_buffer;
10.         // 发送来的数据consumed=0，因此ptr指向用户空间数据buffer的起点
11.         void __user *ptr = buffer + *consumed;
12.         // 指向数据buffer的末尾
13.         void __user *end = buffer + size;
14.         // 逐个读取客户端发送来的数据(cmd+binder_transcation_data)
15.         while (ptr < end && thread->return_error.cmd == BR_OK) {
16.                 int ret;
17.                
18.                 // 获取用户空间中buffer的cmd值
19.                 if (get_user(cmd, (uint32_t __user *)ptr))
20.                         return -EFAULT;
21.                 // 移动指针到cmd的位置之后,指向binder_transcation_data数据的内存起点
22.                 ptr += sizeof(uint32_t);
23.                 trace_binder_command(cmd);
24.                 if (_IOC_NR(cmd) < ARRAY_SIZE(binder_stats.bc)) {
25.                         atomic_inc(&binder_stats.bc[_IOC_NR(cmd)]);
26.                         atomic_inc(&proc->stats.bc[_IOC_NR(cmd)]);
27.                         atomic_inc(&thread->stats.bc[_IOC_NR(cmd)]);
28.                 }
29.                 // 根据上面总结的发送数据可知，cmd是BC_TRANSACTION
30.                 switch (cmd) {
31.                    ......
32.                    /*
33.                 BC_TRANSACTION：进程发送信息的cmd
34.                 BR_TRANSACTION:进程接收BC_TRANSACTION发送信息的cmd
35.                
36.                 BC_REPLY:进程回复信息的cmd
37.                 BR_REPLY：进程接收BC_REPLY回复信息的cmd
38.                 */
39.                     case BC_TRANSACTION:
40.                     case BC_REPLY: {
41.                             struct binder_transaction_data tr;
42.                            
43.                             // 从用户空间拷贝binder_transaction_data到内核空间
44.                             if (copy_from_user(&tr, ptr, sizeof(tr)))
45.                                     return -EFAULT;
46.                             // 移动指针到binder_transaction_data的位置之后,指向下一个cmd数据的内存起点
47.                             ptr += sizeof(tr);
48.                             // 处理binder_transaction_data数据
49.                             binder_transaction(proc, thread, &tr,
50.                                                cmd == BC_REPLY, 0);
51.                             break;
52.                     }
53.                 }
54.         }
55.         ......
56. }
58. int get_user(int *val, const int __user *ptr) {
59.     if (copy_from_user(val, ptr, sizeof(int))) {
60.         return -EFAULT; // 返回错误码
61.     }
62.     return 0; // 成功
63. }

复制代码

4. binder_transaction

4.1. 找到要复兴的进程

1. static void binder_transaction(struct binder_proc *proc,
2.                                struct binder_thread *thread,
3.                                struct binder_transaction_data *tr, int reply,
4.                                binder_size_t extra_buffers_size)
5. {
6.         ......
8.         if (reply) {// 找到要回复的进程
9.                 binder_inner_proc_lock(proc);
10.                                 in_reply_to = thread->transaction_stack;//从栈中取出binder_transaction，获得要回复给谁
11.                                 if (in_reply_to == NULL) {
12.                                         binder_inner_proc_unlock(proc);
13.                                         binder_user_error("%d:%d got reply transaction with no transaction stack\n",
14.                                                           proc->pid, thread->pid);
15.                                         return_error = BR_FAILED_REPLY;
16.                                         return_error_param = -EPROTO;
17.                                         return_error_line = __LINE__;
18.                                         goto err_empty_call_stack;
19.                                 }
20.                                 if (in_reply_to->to_thread != thread) {
21.                                         spin_lock(&in_reply_to->lock);
22.                                         binder_user_error("%d:%d got reply transaction with bad transaction stack, transaction %d has target %d:%d\n",
23.                                                 proc->pid, thread->pid, in_reply_to->debug_id,
24.                                                 in_reply_to->to_proc ?
25.                                                 in_reply_to->to_proc->pid : 0,
26.                                                 in_reply_to->to_thread ?
27.                                                 in_reply_to->to_thread->pid : 0);
28.                                         spin_unlock(&in_reply_to->lock);
29.                                         binder_inner_proc_unlock(proc);
30.                                         return_error = BR_FAILED_REPLY;
31.                                         return_error_param = -EPROTO;
32.                                         return_error_line = __LINE__;
33.                                         in_reply_to = NULL;
34.                                         goto err_bad_call_stack;
35.                                 }
36.                                 thread->transaction_stack = in_reply_to->to_parent;//出栈
37.                                 binder_inner_proc_unlock(proc);
38.                                 binder_set_nice(in_reply_to->saved_priority);
39.                                 target_thread = binder_get_txn_from_and_acq_inner(in_reply_to);
40.                                 if (target_thread == NULL) {
41.                                         /* annotation for sparse */
42.                                         __release(&target_thread->proc->inner_lock);
43.                                         binder_txn_error("%d:%d reply target not found\n",
44.                                                 thread->pid, proc->pid);
45.                                         return_error = BR_DEAD_REPLY;
46.                                         return_error_line = __LINE__;
47.                                         goto err_dead_binder;
48.                                 }
49.                                 if (target_thread->transaction_stack != in_reply_to) {
50.                                         binder_user_error("%d:%d got reply transaction with bad target transaction stack %d, expected %d\n",
51.                                                 proc->pid, thread->pid,
52.                                                 target_thread->transaction_stack ?
53.                                                 target_thread->transaction_stack->debug_id : 0,
54.                                                 in_reply_to->debug_id);
55.                                         binder_inner_proc_unlock(target_thread->proc);
56.                                         return_error = BR_FAILED_REPLY;
57.                                         return_error_param = -EPROTO;
58.                                         return_error_line = __LINE__;
59.                                         in_reply_to = NULL;
60.                                         target_thread = NULL;
61.                                         goto err_dead_binder;
62.                                 }
63.                                 // 找到要回复的进程
64.                                 target_proc = target_thread->proc;
65.                                 target_proc->tmp_ref++;
66.                                 binder_inner_proc_unlock(target_thread->proc);
67.         } else {// 1. 找到要发送的目的进程
68.                 ......
69.         }
70. ......
71. }

复制代码

4.2 处理flat_binder_object

1. static void binder_transaction(struct binder_proc *proc,
2.                                struct binder_thread *thread,
3.                                struct binder_transaction_data *tr, int reply,
4.                                binder_size_t extra_buffers_size)
5. {
6.         ......
8.         if (reply) {// 找到要回复的进程
9.                 binder_inner_proc_lock(proc);
10.                                 in_reply_to = thread->transaction_stack;//从栈中取出binder_transaction，获得要回复给谁
11.                                 if (in_reply_to == NULL) {
12.                                         binder_inner_proc_unlock(proc);
13.                                         binder_user_error("%d:%d got reply transaction with no transaction stack\n",
14.                                                           proc->pid, thread->pid);
15.                                         return_error = BR_FAILED_REPLY;
16.                                         return_error_param = -EPROTO;
17.                                         return_error_line = __LINE__;
18.                                         goto err_empty_call_stack;
19.                                 }
20.                                 if (in_reply_to->to_thread != thread) {
21.                                         spin_lock(&in_reply_to->lock);
22.                                         binder_user_error("%d:%d got reply transaction with bad transaction stack, transaction %d has target %d:%d\n",
23.                                                 proc->pid, thread->pid, in_reply_to->debug_id,
24.                                                 in_reply_to->to_proc ?
25.                                                 in_reply_to->to_proc->pid : 0,
26.                                                 in_reply_to->to_thread ?
27.                                                 in_reply_to->to_thread->pid : 0);
28.                                         spin_unlock(&in_reply_to->lock);
29.                                         binder_inner_proc_unlock(proc);
30.                                         return_error = BR_FAILED_REPLY;
31.                                         return_error_param = -EPROTO;
32.                                         return_error_line = __LINE__;
33.                                         in_reply_to = NULL;
34.                                         goto err_bad_call_stack;
35.                                 }
36.                                 thread->transaction_stack = in_reply_to->to_parent;//出栈
37.                                 binder_inner_proc_unlock(proc);
38.                                 binder_set_nice(in_reply_to->saved_priority);
39.                                 target_thread = binder_get_txn_from_and_acq_inner(in_reply_to);
40.                                 if (target_thread == NULL) {
41.                                         /* annotation for sparse */
42.                                         __release(&target_thread->proc->inner_lock);
43.                                         binder_txn_error("%d:%d reply target not found\n",
44.                                                 thread->pid, proc->pid);
45.                                         return_error = BR_DEAD_REPLY;
46.                                         return_error_line = __LINE__;
47.                                         goto err_dead_binder;
48.                                 }
49.                                 if (target_thread->transaction_stack != in_reply_to) {
50.                                         binder_user_error("%d:%d got reply transaction with bad target transaction stack %d, expected %d\n",
51.                                                 proc->pid, thread->pid,
52.                                                 target_thread->transaction_stack ?
53.                                                 target_thread->transaction_stack->debug_id : 0,
54.                                                 in_reply_to->debug_id);
55.                                         binder_inner_proc_unlock(target_thread->proc);
56.                                         return_error = BR_FAILED_REPLY;
57.                                         return_error_param = -EPROTO;
58.                                         return_error_line = __LINE__;
59.                                         in_reply_to = NULL;
60.                                         target_thread = NULL;
61.                                         goto err_dead_binder;
62.                                 }
63.                                 // 找到要回复的进程
64.                                 target_proc = target_thread->proc;
65.                                 target_proc->tmp_ref++;
66.                                 binder_inner_proc_unlock(target_thread->proc);
67.         } else {// 1. 找到要发送的目的进程
68.                 ......
69.         }
70.         if (target_thread)
71.                 e->to_thread = target_thread->pid;
72.         e->to_proc = target_proc->pid;
74.         /* TODO: reuse incoming transaction for reply */
75.         // 为binder_transcation分配内存
76.         t = kzalloc(sizeof(*t), GFP_KERNEL);
77.         
78.         .....
80.         if (!reply && !(tr->flags & TF_ONE_WAY))
81.                 t->from = thread;
82.         else
83.                 t->from = NULL;
84.         // 存储发送双方的基本信息
85.         t->from_pid = proc->pid;
86.         t->from_tid = thread->pid;
87.         t->sender_euid = task_euid(proc->tsk);
88.         t->to_proc = target_proc;
89.         t->to_thread = target_thread;
90.         t->code = tr->code;
91.         t->flags = tr->flags;
92.         t->priority = task_nice(current);
94.         ......
96.         t->buffer = binder_alloc_new_buf(&target_proc->alloc, tr->data_size,
97.                 tr->offsets_size, extra_buffers_size,
98.                 !reply && (t->flags & TF_ONE_WAY));
99.         ......
100.         
101.         t->buffer->debug_id = t->debug_id;
102.         t->buffer->transaction = t;
103.         t->buffer->target_node = target_node;
104.         t->buffer->clear_on_free = !!(t->flags & TF_CLEAR_BUF);
105.         trace_binder_transaction_alloc_buf(t->buffer);
106.         
107.         // 把客户端的数据拷贝到目的进程test_client mmap的内存空间
108.         if (binder_alloc_copy_user_to_buffer(
109.                                 &target_proc->alloc,
110.                                 t->buffer,
111.                                 ALIGN(tr->data_size, sizeof(void *)),
112.                                 (const void __user *)
113.                                         (uintptr_t)tr->data.ptr.offsets,
114.                                 tr->offsets_size)) {
115.                 binder_user_error("%d:%d got transaction with invalid offsets ptr\n",
116.                                 proc->pid, thread->pid);
117.                 return_error = BR_FAILED_REPLY;
118.                 return_error_param = -EFAULT;
119.                 return_error_line = __LINE__;
120.                 goto err_copy_data_failed;
121.         }
122.         ......
123.                
124.                 //处理server传入的binder_io.offs数据，这个数据指向用于构建binder_node实体的                flat_binder_object
125.                 for (buffer_offset = off_start_offset; buffer_offset < off_end_offset;
126.                      buffer_offset += sizeof(binder_size_t)) {
127.                         struct binder_object_header *hdr;
128.                         size_t object_size;
129.                         struct binder_object object;
130.                         binder_size_t object_offset;
131.                         binder_size_t copy_size;
132.        
133.                         if (binder_alloc_copy_from_buffer(&target_proc->alloc,
134.                                                           &object_offset,
135.                                                           t->buffer,
136.                                                           buffer_offset,
137.                                                           sizeof(object_offset))) {
138.                                 binder_txn_error("%d:%d copy offset from buffer failed\n",
139.                                         thread->pid, proc->pid);
140.                                 return_error = BR_FAILED_REPLY;
141.                                 return_error_param = -EINVAL;
142.                                 return_error_line = __LINE__;
143.                                 goto err_bad_offset;
144.                         }
145.        
146.                         /*
147.                          * Copy the source user buffer up to the next object
148.                          * that will be processed.
149.                          */
150.                         copy_size = object_offset - user_offset;
151.                         if (copy_size && (user_offset > object_offset ||
152.                                         binder_alloc_copy_user_to_buffer(
153.                                                 &target_proc->alloc,
154.                                                 t->buffer, user_offset,
155.                                                 user_buffer + user_offset,
156.                                                 copy_size))) {
157.                                 binder_user_error("%d:%d got transaction with invalid data ptr\n",
158.                                                 proc->pid, thread->pid);
159.                                 return_error = BR_FAILED_REPLY;
160.                                 return_error_param = -EFAULT;
161.                                 return_error_line = __LINE__;
162.                                 goto err_copy_data_failed;
163.                         }
164.                         // 将指向flat_binder_object的指针拷贝给object
165.                         object_size = binder_get_object(target_proc, user_buffer,
166.                                         t->buffer, object_offset, &object);
167.                         if (object_size == 0 || object_offset < off_min) {
168.                                 binder_user_error("%d:%d got transaction with invalid offset (%lld, min %lld max %lld) or object.\n",
169.                                                   proc->pid, thread->pid,
170.                                                   (u64)object_offset,
171.                                                   (u64)off_min,
172.                                                   (u64)t->buffer->data_size);
173.                                 return_error = BR_FAILED_REPLY;
174.                                 return_error_param = -EINVAL;
175.                                 return_error_line = __LINE__;
176.                                 goto err_bad_offset;
177.                         }
178.                         /*
179.                          * Set offset to the next buffer fragment to be
180.                          * copied
181.                          */
182.                         user_offset = object_offset + object_size;
183.        
184.                         hdr = &object.hdr;
185.                         off_min = object_offset + object_size;
186.                         // 此处 binder类型的是BINDER_TYPE_HANDLE，通过handle在service_manager的binder-ref中找到hello服务的binder_node
187.                         switch (hdr->type) {
188.                         //处理binder实体
189.                         case BINDER_TYPE_BINDER:
190.                         case BINDER_TYPE_WEAK_BINDER: {
191.                                 ......
192.                                
193.                         } break;
194.                         //处理binder引用
195.                         case BINDER_TYPE_HANDLE:
196.                         case BINDER_TYPE_WEAK_HANDLE: {
197.                                 struct flat_binder_object *fp;
198.        
199.                                 fp = to_flat_binder_object(hdr);
200.                                 ret = binder_translate_handle(fp, t, thread);
201.                                 if (ret < 0 ||
202.                                     binder_alloc_copy_to_buffer(&target_proc->alloc,
203.                                                                 t->buffer,
204.                                                                 object_offset,
205.                                                                 fp, sizeof(*fp))) {
206.                                         binder_txn_error("%d:%d translate handle failed\n",
207.                                                 thread->pid, proc->pid);
208.                                         return_error = BR_FAILED_REPLY;
209.                                         return_error_param = ret;
210.                                         return_error_line = __LINE__;
211.                                         goto err_translate_failed;
212.                                 }
213.                         } break;
214.                         ......
215.          }
216. ......
217. }

复制代码

4.3 根据handle找到服务的binder_node，

1. static int binder_translate_handle(struct flat_binder_object *fp,
2.                                    struct binder_transaction *t,
3.                                    struct binder_thread *thread)
4. {
5.         struct binder_proc *proc = thread->proc;
6.         struct binder_proc *target_proc = t->to_proc;
7.         struct binder_node *node;
8.         struct binder_ref_data src_rdata;
9.         int ret = 0;
10.    
11.     // 根据handle从service_manager中找到服务的binder_node
12.         node = binder_get_node_from_ref(proc, fp->handle,
13.                         fp->hdr.type == BINDER_TYPE_HANDLE, &src_rdata);
14.         if (!node) {
15.                 binder_user_error("%d:%d got transaction with invalid handle, %d\n",
16.                                   proc->pid, thread->pid, fp->handle);
17.                 return -EINVAL;
18.         }
19.         if (security_binder_transfer_binder(proc->cred, target_proc->cred)) {
20.                 ret = -EPERM;
21.                 goto done;
22.         }
24.         binder_node_lock(node);
25.         if (node->proc == target_proc) {
26.                 if (fp->hdr.type == BINDER_TYPE_HANDLE)
27.                         fp->hdr.type = BINDER_TYPE_BINDER;
28.                 else
29.                         fp->hdr.type = BINDER_TYPE_WEAK_BINDER;
30.                 fp->binder = node->ptr;
31.                 fp->cookie = node->cookie;
32.                 if (node->proc)
33.                         binder_inner_proc_lock(node->proc);
34.                 else
35.                         __acquire(&node->proc->inner_lock);
36.                 binder_inc_node_nilocked(node,
37.                                          fp->hdr.type == BINDER_TYPE_BINDER,
38.                                          0, NULL);
39.                 if (node->proc)
40.                         binder_inner_proc_unlock(node->proc);
41.                 else
42.                         __release(&node->proc->inner_lock);
43.                 trace_binder_transaction_ref_to_node(t, node, &src_rdata);
44.                 binder_debug(BINDER_DEBUG_TRANSACTION,
45.                              "        ref %d desc %d -> node %d u%016llx\n",
46.                              src_rdata.debug_id, src_rdata.desc, node->debug_id,
47.                              (u64)node->ptr);
48.                 binder_node_unlock(node);
49.         } else {
50.                 struct binder_ref_data dest_rdata;
52.                 binder_node_unlock(node);
53.                 // 为客户端创建binder_ref指向服务的binder_node
54.                 ret = binder_inc_ref_for_node(target_proc, node,
55.                                 fp->hdr.type == BINDER_TYPE_HANDLE,
56.                                 NULL, &dest_rdata);
57.                 if (ret)
58.                         goto done;
60.                 fp->binder = 0;
61.                 fp->handle = dest_rdata.desc;
62.                 fp->cookie = 0;
63.                 trace_binder_transaction_ref_to_ref(t, node, &src_rdata,
64.                                                     &dest_rdata);
65.                 binder_debug(BINDER_DEBUG_TRANSACTION,
66.                              "        ref %d desc %d -> ref %d desc %d (node %d)\n",
67.                              src_rdata.debug_id, src_rdata.desc,
68.                              dest_rdata.debug_id, dest_rdata.desc,
69.                              node->debug_id);
70.         }
71. done:
72.         binder_put_node(node);
73.         return ret;
74. }
76. static struct binder_node *binder_get_node_from_ref(
77.                 struct binder_proc *proc,
78.                 u32 desc, bool need_strong_ref,
79.                 struct binder_ref_data *rdata)
80. {
81.         struct binder_node *node;
82.         struct binder_ref *ref;
84.         binder_proc_lock(proc);
85.         // 根据handle找到binder_ref
86.         ref = binder_get_ref_olocked(proc, desc, need_strong_ref);
87.         if (!ref)
88.                 goto err_no_ref;
89.                
90.         // 根据binder_ref找到binder_node
91.         node = ref->node;
92.         /*
93.          * Take an implicit reference on the node to ensure
94.          * it stays alive until the call to binder_put_node()
95.          */
96.         binder_inc_node_tmpref(node);
97.         if (rdata)
98.                 *rdata = ref->data;
99.         binder_proc_unlock(proc);
101.         return node;
103. err_no_ref:
104.         binder_proc_unlock(proc);
105.         return NULL;
106. }
108. static struct binder_ref *binder_get_ref_olocked(struct binder_proc *proc,
109.                                                  u32 desc, bool need_strong_ref)
110. {
111.         struct rb_node *n = proc->refs_by_desc.rb_node;
112.         struct binder_ref *ref;
114.         while (n) {
115.                 ref = rb_entry(n, struct binder_ref, rb_node_desc);
117.                 if (desc < ref->data.desc) {
118.                         n = n->rb_left;
119.                 } else if (desc > ref->data.desc) {
120.                         n = n->rb_right;
121.                 } else if (need_strong_ref && !ref->data.strong) {
122.                         binder_user_error("tried to use weak ref as strong ref\n");
123.                         return NULL;
124.                 } else {
125.                         return ref;
126.                 }
127.         }
128.         return NULL;
129. }

复制代码

4.4 为客户端创建binder_ref，指向服务的binder_node

1. static int binder_inc_ref_for_node(struct binder_proc *proc,
2.                         struct binder_node *node,
3.                         bool strong,
4.                         struct list_head *target_list,
5.                         struct binder_ref_data *rdata)
6. {
7.         struct binder_ref *ref;
8.         struct binder_ref *new_ref = NULL;
9.         int ret = 0;
11.         binder_proc_lock(proc);
12.         // 先查找客户端是否已经有对应的binder_ref，若没有则新建binder_ref
13.         ref = binder_get_ref_for_node_olocked(proc, node, NULL);
14.         if (!ref) {
15.                 binder_proc_unlock(proc);
16.                 new_ref = kzalloc(sizeof(*ref), GFP_KERNEL);
17.                 if (!new_ref)
18.                         return -ENOMEM;
19.                 binder_proc_lock(proc);
20.                 ref = binder_get_ref_for_node_olocked(proc, node, new_ref);
21.         }
22.         //增加引用计数
23.         ret = binder_inc_ref_olocked(ref, strong, target_list);
24.         *rdata = ref->data;
25.         if (ret && ref == new_ref) {
26.                 /*
27.                  * Cleanup the failed reference here as the target
28.                  * could now be dead and have already released its
29.                  * references by now. Calling on the new reference
30.                  * with strong=0 and a tmp_refs will not decrement
31.                  * the node. The new_ref gets kfree'd below.
32.                  */
33.                 binder_cleanup_ref_olocked(new_ref);
34.                 ref = NULL;
35.         }
37.         binder_proc_unlock(proc);
38.         if (new_ref && ref != new_ref)
39.                 /*
40.                  * Another thread created the ref first so
41.                  * free the one we allocated
42.                  */
43.                 kfree(new_ref);
44.         return ret;
45. }
47. static struct binder_ref *binder_get_ref_for_node_olocked(
48.                                         struct binder_proc *proc,
49.                                         struct binder_node *node,
50.                                         struct binder_ref *new_ref)
51. {
52.         struct binder_context *context = proc->context;
53.         struct rb_node **p = &proc->refs_by_node.rb_node;
54.         struct rb_node *parent = NULL;
55.         struct binder_ref *ref;
56.         struct rb_node *n;
58.         while (*p) {
59.                 parent = *p;
60.                 ref = rb_entry(parent, struct binder_ref, rb_node_node);
62.                 if (node < ref->node)
63.                         p = &(*p)->rb_left;
64.                 else if (node > ref->node)
65.                         p = &(*p)->rb_right;
66.                 else
67.                         return ref;
68.         }
69.         if (!new_ref)
70.                 return NULL;
72.         binder_stats_created(BINDER_STAT_REF);
73.         new_ref->data.debug_id = atomic_inc_return(&binder_last_id);
74.         new_ref->proc = proc;
75.         new_ref->node = node;
76.         rb_link_node(&new_ref->rb_node_node, parent, p);
77.         rb_insert_color(&new_ref->rb_node_node, &proc->refs_by_node);
78.    
79.     // 更新binder_ref的handle值，后续客户端通过handle值找到这个binder_ref，进而找到binder_node
80.         new_ref->data.desc = (node == context->binder_context_mgr_node) ? 0 : 1;
81.         for (n = rb_first(&proc->refs_by_desc); n != NULL; n = rb_next(n)) {
82.                 ref = rb_entry(n, struct binder_ref, rb_node_desc);
83.                 if (ref->data.desc > new_ref->data.desc)
84.                         break;
85.                 // 客户端引用服务的handle加1
86.                 new_ref->data.desc = ref->data.desc + 1;
87.         }
89.         p = &proc->refs_by_desc.rb_node;
90.         while (*p) {
91.                 parent = *p;
92.                 ref = rb_entry(parent, struct binder_ref, rb_node_desc);
94.                 if (new_ref->data.desc < ref->data.desc)
95.                         p = &(*p)->rb_left;
96.                 else if (new_ref->data.desc > ref->data.desc)
97.                         p = &(*p)->rb_right;
98.                 else
99.                         BUG();
100.         }
101.         rb_link_node(&new_ref->rb_node_desc, parent, p);
102.         rb_insert_color(&new_ref->rb_node_desc, &proc->refs_by_desc);
104.         binder_node_lock(node);
105.         hlist_add_head(&new_ref->node_entry, &node->refs);
107.         binder_debug(BINDER_DEBUG_INTERNAL_REFS,
108.                      "%d new ref %d desc %d for node %d\n",
109.                       proc->pid, new_ref->data.debug_id, new_ref->data.desc,
110.                       node->debug_id);
111.         binder_node_unlock(node);
112.         return new_ref;
113. }

复制代码

4.5 把数据放到客户端的todo链表，叫醒客户端

1. static void binder_transaction(struct binder_proc *proc,
2.                                struct binder_thread *thread,
3.                                struct binder_transaction_data *tr, int reply,
4.                                binder_size_t extra_buffers_size)
5. {
6.         ......
8.         if (reply) {// 找到要回复的进程
9.                 binder_inner_proc_lock(proc);
10.                                 in_reply_to = thread->transaction_stack;//从栈中取出binder_transaction，获得要回复给谁
11.                                 if (in_reply_to == NULL) {
12.                                         binder_inner_proc_unlock(proc);
13.                                         binder_user_error("%d:%d got reply transaction with no transaction stack\n",
14.                                                           proc->pid, thread->pid);
15.                                         return_error = BR_FAILED_REPLY;
16.                                         return_error_param = -EPROTO;
17.                                         return_error_line = __LINE__;
18.                                         goto err_empty_call_stack;
19.                                 }
20.                                 if (in_reply_to->to_thread != thread) {
21.                                         spin_lock(&in_reply_to->lock);
22.                                         binder_user_error("%d:%d got reply transaction with bad transaction stack, transaction %d has target %d:%d\n",
23.                                                 proc->pid, thread->pid, in_reply_to->debug_id,
24.                                                 in_reply_to->to_proc ?
25.                                                 in_reply_to->to_proc->pid : 0,
26.                                                 in_reply_to->to_thread ?
27.                                                 in_reply_to->to_thread->pid : 0);
28.                                         spin_unlock(&in_reply_to->lock);
29.                                         binder_inner_proc_unlock(proc);
30.                                         return_error = BR_FAILED_REPLY;
31.                                         return_error_param = -EPROTO;
32.                                         return_error_line = __LINE__;
33.                                         in_reply_to = NULL;
34.                                         goto err_bad_call_stack;
35.                                 }
36.                                 thread->transaction_stack = in_reply_to->to_parent;//出栈
37.                                 binder_inner_proc_unlock(proc);
38.                                 binder_set_nice(in_reply_to->saved_priority);
39.                                 target_thread = binder_get_txn_from_and_acq_inner(in_reply_to);
40.                                 if (target_thread == NULL) {
41.                                         /* annotation for sparse */
42.                                         __release(&target_thread->proc->inner_lock);
43.                                         binder_txn_error("%d:%d reply target not found\n",
44.                                                 thread->pid, proc->pid);
45.                                         return_error = BR_DEAD_REPLY;
46.                                         return_error_line = __LINE__;
47.                                         goto err_dead_binder;
48.                                 }
49.                                 if (target_thread->transaction_stack != in_reply_to) {
50.                                         binder_user_error("%d:%d got reply transaction with bad target transaction stack %d, expected %d\n",
51.                                                 proc->pid, thread->pid,
52.                                                 target_thread->transaction_stack ?
53.                                                 target_thread->transaction_stack->debug_id : 0,
54.                                                 in_reply_to->debug_id);
55.                                         binder_inner_proc_unlock(target_thread->proc);
56.                                         return_error = BR_FAILED_REPLY;
57.                                         return_error_param = -EPROTO;
58.                                         return_error_line = __LINE__;
59.                                         in_reply_to = NULL;
60.                                         target_thread = NULL;
61.                                         goto err_dead_binder;
62.                                 }
63.                                 // 找到要回复的进程
64.                                 target_proc = target_thread->proc;
65.                                 target_proc->tmp_ref++;
66.                                 binder_inner_proc_unlock(target_thread->proc);
67.         } else {// 1. 找到要发送的目的进程
68.                 ......
69.         }
70.         if (target_thread)
71.                 e->to_thread = target_thread->pid;
72.         e->to_proc = target_proc->pid;
74.         /* TODO: reuse incoming transaction for reply */
75.         // 为binder_transcation分配内存
76.         t = kzalloc(sizeof(*t), GFP_KERNEL);
77.         
78.         .....
80.         if (!reply && !(tr->flags & TF_ONE_WAY))
81.                 t->from = thread;
82.         else
83.                 t->from = NULL;
84.         // 存储发送双方的基本信息
85.         t->from_pid = proc->pid;
86.         t->from_tid = thread->pid;
87.         t->sender_euid = task_euid(proc->tsk);
88.         t->to_proc = target_proc;
89.         t->to_thread = target_thread;
90.         t->code = tr->code;
91.         t->flags = tr->flags;
92.         t->priority = task_nice(current);
94.         ......
96.         t->buffer = binder_alloc_new_buf(&target_proc->alloc, tr->data_size,
97.                 tr->offsets_size, extra_buffers_size,
98.                 !reply && (t->flags & TF_ONE_WAY));
99.         ......
100.         
101.         t->buffer->debug_id = t->debug_id;
102.         t->buffer->transaction = t;
103.         t->buffer->target_node = target_node;
104.         t->buffer->clear_on_free = !!(t->flags & TF_CLEAR_BUF);
105.         trace_binder_transaction_alloc_buf(t->buffer);
106.         
107.         // 把客户端的数据拷贝到目的进程test_client mmap的内存空间
108.         if (binder_alloc_copy_user_to_buffer(
109.                                 &target_proc->alloc,
110.                                 t->buffer,
111.                                 ALIGN(tr->data_size, sizeof(void *)),
112.                                 (const void __user *)
113.                                         (uintptr_t)tr->data.ptr.offsets,
114.                                 tr->offsets_size)) {
115.                 binder_user_error("%d:%d got transaction with invalid offsets ptr\n",
116.                                 proc->pid, thread->pid);
117.                 return_error = BR_FAILED_REPLY;
118.                 return_error_param = -EFAULT;
119.                 return_error_line = __LINE__;
120.                 goto err_copy_data_failed;
121.         }
122.         ......
123.                
124.                 //处理server传入的binder_io.offs数据，这个数据指向用于构建binder_node实体的                flat_binder_object
125.                 for (buffer_offset = off_start_offset; buffer_offset < off_end_offset;
126.                      buffer_offset += sizeof(binder_size_t)) {
127.                         struct binder_object_header *hdr;
128.                         size_t object_size;
129.                         struct binder_object object;
130.                         binder_size_t object_offset;
131.                         binder_size_t copy_size;
132.        
133.                         if (binder_alloc_copy_from_buffer(&target_proc->alloc,
134.                                                           &object_offset,
135.                                                           t->buffer,
136.                                                           buffer_offset,
137.                                                           sizeof(object_offset))) {
138.                                 binder_txn_error("%d:%d copy offset from buffer failed\n",
139.                                         thread->pid, proc->pid);
140.                                 return_error = BR_FAILED_REPLY;
141.                                 return_error_param = -EINVAL;
142.                                 return_error_line = __LINE__;
143.                                 goto err_bad_offset;
144.                         }
145.        
146.                         /*
147.                          * Copy the source user buffer up to the next object
148.                          * that will be processed.
149.                          */
150.                         copy_size = object_offset - user_offset;
151.                         if (copy_size && (user_offset > object_offset ||
152.                                         binder_alloc_copy_user_to_buffer(
153.                                                 &target_proc->alloc,
154.                                                 t->buffer, user_offset,
155.                                                 user_buffer + user_offset,
156.                                                 copy_size))) {
157.                                 binder_user_error("%d:%d got transaction with invalid data ptr\n",
158.                                                 proc->pid, thread->pid);
159.                                 return_error = BR_FAILED_REPLY;
160.                                 return_error_param = -EFAULT;
161.                                 return_error_line = __LINE__;
162.                                 goto err_copy_data_failed;
163.                         }
164.                         // 将指向flat_binder_object的指针拷贝给object
165.                         object_size = binder_get_object(target_proc, user_buffer,
166.                                         t->buffer, object_offset, &object);
167.                         if (object_size == 0 || object_offset < off_min) {
168.                                 binder_user_error("%d:%d got transaction with invalid offset (%lld, min %lld max %lld) or object.\n",
169.                                                   proc->pid, thread->pid,
170.                                                   (u64)object_offset,
171.                                                   (u64)off_min,
172.                                                   (u64)t->buffer->data_size);
173.                                 return_error = BR_FAILED_REPLY;
174.                                 return_error_param = -EINVAL;
175.                                 return_error_line = __LINE__;
176.                                 goto err_bad_offset;
177.                         }
178.                         /*
179.                          * Set offset to the next buffer fragment to be
180.                          * copied
181.                          */
182.                         user_offset = object_offset + object_size;
183.        
184.                         hdr = &object.hdr;
185.                         off_min = object_offset + object_size;
186.                         // 此处 binder类型的是BINDER_TYPE_HANDLE，通过handle在service_manager的binder-ref中找到hello服务的binder_node
187.                         switch (hdr->type) {
188.                         //处理binder实体
189.                         case BINDER_TYPE_BINDER:
190.                         case BINDER_TYPE_WEAK_BINDER: {
191.                                 ......
192.                                
193.                         } break;
194.                         //处理binder引用
195.                         case BINDER_TYPE_HANDLE:
196.                         case BINDER_TYPE_WEAK_HANDLE: {
197.                                 struct flat_binder_object *fp;
198.        
199.                                 fp = to_flat_binder_object(hdr);
200.                                 ret = binder_translate_handle(fp, t, thread);
201.                                 if (ret < 0 ||
202.                                     binder_alloc_copy_to_buffer(&target_proc->alloc,
203.                                                                 t->buffer,
204.                                                                 object_offset,
205.                                                                 fp, sizeof(*fp))) {
206.                                         binder_txn_error("%d:%d translate handle failed\n",
207.                                                 thread->pid, proc->pid);
208.                                         return_error = BR_FAILED_REPLY;
209.                                         return_error_param = ret;
210.                                         return_error_line = __LINE__;
211.                                         goto err_translate_failed;
212.                                 }
213.                         } break;
214.                         ......
215.          }
216.         ......
217.         t->work.type = BINDER_WORK_TRANSACTION;
219.         if (reply) {
220.                 binder_enqueue_thread_work(thread, tcomplete);
221.                 binder_inner_proc_lock(target_proc);
222.                 if (target_thread->is_dead) {
223.                         return_error = BR_DEAD_REPLY;
224.                         binder_inner_proc_unlock(target_proc);
225.                         goto err_dead_proc_or_thread;
226.                 }
227.                 BUG_ON(t->buffer->async_transaction != 0);
228.                 binder_pop_transaction_ilocked(target_thread, in_reply_to);//再次出栈
229.                 // 将数据放到客户端target_thread的todo链表
230.                 binder_enqueue_thread_work_ilocked(target_thread, &t->work);
231.                 target_proc->outstanding_txns++;
232.                 binder_inner_proc_unlock(target_proc);
233.                 // 唤醒客户端
234.                 wake_up_interruptible_sync(&target_thread->wait);
235.                 binder_free_transaction(in_reply_to);
236.         } else if (!(t->flags & TF_ONE_WAY)) {
237.                 ......
238.         } else {
239.                 ......
240.         }
241.         if (target_thread)
242.                 binder_thread_dec_tmpref(target_thread);
243.         binder_proc_dec_tmpref(target_proc);
244.         if (target_node)
245.                 binder_dec_node_tmpref(target_node);
246.         /*
247.          * write barrier to synchronize with initialization
248.          * of log entry
249.          */
250.         smp_wmb();
251.         WRITE_ONCE(e->debug_id_done, t_debug_id);
252.         return;
253.         ......
254. }
256. static void
257. binder_enqueue_thread_work_ilocked(struct binder_thread *thread,
258.                                    struct binder_work *work)
259. {
260.         WARN_ON(!list_empty(&thread->waiting_thread_node));
261.         binder_enqueue_work_ilocked(work, &thread->todo);
263.         /* (e)poll-based threads require an explicit wakeup signal when
264.          * queuing their own work; they rely on these events to consume
265.          * messages without I/O block. Without it, threads risk waiting
266.          * indefinitely without handling the work.
267.          */
268.         if (thread->looper & BINDER_LOOPER_STATE_POLL &&
269.             thread->pid == current->pid && !thread->process_todo)
270.                 wake_up_interruptible_sync(&thread->wait);
272.         thread->process_todo = true;
273. }
275. static void
276. binder_enqueue_work_ilocked(struct binder_work *work,
277.                            struct list_head *target_list)
278. {
279.         BUG_ON(target_list == NULL);
280.         BUG_ON(work->entry.next && !list_empty(&work->entry));
281.         list_add_tail(&work->entry, target_list);
282. }

复制代码

2.4 客户端被叫醒，获取客户端binder_ref对应的handle

1. handle = svcmgr_lookup(bs, svcmgr, "hello");
3. uint32_t svcmgr_lookup(struct binder_state *bs, uint32_t target, const char *name)
4. {
5.     uint32_t handle;
6.     unsigned iodata[512/4];
7.     struct binder_io msg, reply;
9.     bio_init(&msg, iodata, sizeof(iodata), 4);
10.     bio_put_uint32(&msg, 0);  // strict mode header
11.     bio_put_string16_x(&msg, SVC_MGR_NAME);
12.     bio_put_string16_x(&msg, name);
13.    
14.     // ioctl到内核处理
15.     if (binder_call(bs, &msg, &reply, target, SVC_MGR_CHECK_SERVICE))
16.         return 0;
17.    
18.     // 获取引用服务binder_node的客户端binder_ref的handle
19.     handle = bio_get_ref(&reply);
21.     if (handle)
22.         binder_acquire(bs, handle);
24.     binder_done(bs, &msg, &reply);
26.     return handle;
27. }
29. uint32_t bio_get_ref(struct binder_io *bio)
30. {
31.     struct flat_binder_object *obj;
33.     obj = _bio_get_obj(bio);
34.     if (!obj)
35.         return 0;
37.     if (obj->type == BINDER_TYPE_HANDLE)
38.         return obj->handle;
40.     return 0;
41. }

复制代码

3 服务注册和获取过程的简要总结图

二、服务的利用过程内核源码剖析

上面我们通过源码分析，获得了客户端想要利用的服务的handle，下面我们接着分析，如何利用该服务。
1. 服务利用过程思路

有了之前Binder源码阅读的经验，我们直接看服务利用的思路，应该很轻易可以或许明白，我们基于这个思路举行分析源码，也更轻易明白源码。

2. 客户端利用服务内核源码剖析

2.1 向服务端发送数据

1. int main(int argc, char **argv)
2. {
3.     int fd;
4.     struct binder_state *bs;
5.     uint32_t svcmgr = BINDER_SERVICE_MANAGER;
6.     uint32_t handle;
7.         int ret;
9.         if (argc < 2){
10.         fprintf(stderr, "Usage:\n");
11.         fprintf(stderr, "%s <hello|goodbye>\n", argv[0]);
12.         fprintf(stderr, "%s <hello|goodbye> <name>\n", argv[0]);
13.         return -1;
14.         }
15.    
16.     //打开驱动
17.     bs = binder_open(128*1024);
18.     if (!bs) {
19.         fprintf(stderr, "failed to open binder driver\n");
20.         return -1;
21.     }
22.         g_bs = bs;
23.    
24.     //向service_manager发送数据，获得hello服务句柄
25.         handle = svcmgr_lookup(bs, svcmgr, "hello");
26.         if (!handle) {
27.         fprintf(stderr, "failed to get hello service\n");
28.         return -1;
29.         }
30.         g_hello_handle = handle;
31.         fprintf(stderr, "Handle for hello service = %d\n", g_hello_handle);
33.         /* 向服务端发送数据 */
34.         if (!strcmp(argv[1], "hello"))
35.         {
36.                 if (argc == 2) {
37.                         sayhello();
38.                 } else if (argc == 3) {
39.                         ret = sayhello_to(argv[2]);
40.                 fprintf(stderr, "get ret of sayhello_to = %d\n", ret);               
41.                 }
42.         }
44.         binder_release(bs, handle);
46.     return 0;
47. }

复制代码

1. sayhello_to

以调用服务端的sayhello_to函数为例，分析客户端利用服务的过程

1. int sayhello_to(char *name)
2. {
3.         unsigned iodata[512/4];
4.         struct binder_io msg, reply;
5.         int ret;
6.         int exception;
8.         /* 构造binder_io */
9.         bio_init(&msg, iodata, sizeof(iodata), 4);
10.         bio_put_uint32(&msg, 0);  // strict mode header
11.     bio_put_string16_x(&msg, "IHelloService");
13.         /* 放入参数 */
14.     bio_put_string16_x(&msg, name);
16.         /* 调用binder_call
17.         msg：客户端的数据
18.         reply：携带服务端返回的数据
19.         g_hello_handle：服务端进程的handle
20.         HELLO_SVR_CMD_SAYHELLO_TO：要调用的服务端提供的服务
21.          */
22.         if (binder_call(g_bs, &msg, &reply, g_hello_handle, HELLO_SVR_CMD_SAYHELLO_TO))
23.                 return 0;
24.        
25.         /* 从reply中解析出返回值 */
26.         exception = bio_get_uint32(&reply);
27.         if (exception)
28.                 ret = -1;
29.         else
30.                 ret = bio_get_uint32(&reply);
32.         binder_done(g_bs, &msg, &reply);
34.         return ret;
35.        
36. }

复制代码

2. binder_call

binder_call函数，已经分析很多遍了，这里不再详细分析，贴下代码

1. int binder_call(struct binder_state *bs,
2.                 struct binder_io *msg, struct binder_io *reply,
3.                 uint32_t target, uint32_t code)
4. {
5.     int res;
6.     struct binder_write_read bwr;
7.     struct {
8.         uint32_t cmd;
9.         struct binder_transaction_data txn;
10.     } __attribute__((packed)) writebuf;
11.     unsigned readbuf[32];
13.     if (msg->flags & BIO_F_OVERFLOW) {
14.         fprintf(stderr,"binder: txn buffer overflow\n");
15.         goto fail;
16.     }
18.     writebuf.cmd = BC_TRANSACTION;//ioclt类型
19.     writebuf.txn.target.handle = target;//数据发送给哪个进程
20.     writebuf.txn.code = code;//调用进程的哪个函数
21.     writebuf.txn.flags = 0;
22.     writebuf.txn.data_size = msg->data - msg->data0;//数据本身大小
23.     writebuf.txn.offsets_size = ((char*) msg->offs) - ((char*) msg->offs0);//数据头大小，指向binder_node实体（发送端提供服务函数的地址），bio_put_obj(&msg, ptr);
24.     writebuf.txn.data.ptr.buffer = (uintptr_t)msg->data0;//指向数据本身内存起点
25.     writebuf.txn.data.ptr.offsets = (uintptr_t)msg->offs0;//指向数据头内存起点
27.     bwr.write_size = sizeof(writebuf);
28.     bwr.write_consumed = 0;
29.     bwr.write_buffer = (uintptr_t) &writebuf;
31.     hexdump(msg->data0, msg->data - msg->data0);
32.     for (;;) {
33.         bwr.read_size = sizeof(readbuf);
34.         bwr.read_consumed = 0;
35.         bwr.read_buffer = (uintptr_t) readbuf;
37.         res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);//调用ioctl发送数据给驱动程序
39.         if (res < 0) {
40.             fprintf(stderr,"binder: ioctl failed (%s)\n", strerror(errno));
41.             goto fail;
42.         }
44.         res = binder_parse(bs, reply, (uintptr_t) readbuf, bwr.read_consumed, 0);
45.         if (res == 0) return 0;
46.         if (res < 0) goto fail;
47.     }
49. fail:
50.     memset(reply, 0, sizeof(*reply));
51.     reply->flags |= BIO_F_IOERROR;
52.     return -1;
53. }

复制代码

3. binder_ioctl

用户态的ioctl调用到内核Binder驱动程序binder_ioctl函数，这个函数也分析很多遍了，相信看到这儿的博友，对这些函数已经很熟悉了。

1. // res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);进入binder驱动程序
2. static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
3. {
4.         int ret;
5.         struct binder_proc *proc = filp->private_data;
6.         struct binder_thread *thread;
7.         void __user *ubuf = (void __user *)arg;
9.         /*pr_info("binder_ioctl: %d:%d %x %lx\n",
10.                         proc->pid, current->pid, cmd, arg);*/
12.         binder_selftest_alloc(&proc->alloc);
14.         trace_binder_ioctl(cmd, arg);
16.         ret = wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2);
17.         if (ret)
18.                 goto err_unlocked;
20.         //为进程proc创建binder_thread
21.         thread = binder_get_thread(proc);
22.         if (thread == NULL) {
23.                 ret = -ENOMEM;
24.                 goto err;
25.         }
27.         switch (cmd) {
28.         case BINDER_WRITE_READ:
29.                 ret = binder_ioctl_write_read(filp, arg, thread);
30.                 if (ret)
31.                         goto err;
32.                 break;
33.                 ......
34.         }
35.         ......
36. }

复制代码

4. binder_ioctl_write_read

1. static int binder_ioctl_write_read(struct file *filp, unsigned long arg,
2.                                 struct binder_thread *thread)
3. {
4.         int ret = 0;
5.         struct binder_proc *proc = filp->private_data;
6.         void __user *ubuf = (void __user *)arg;
7.         struct binder_write_read bwr;
9.     //从用户空间拷贝数据到内核空间（这部分内核空间被mmap映射到了目标进程）
10.         if (copy_from_user(&bwr, ubuf, sizeof(bwr))) {
11.                 ret = -EFAULT;
12.                 goto out;
13.         }
14.         binder_debug(BINDER_DEBUG_READ_WRITE,
15.                      "%d:%d write %lld at %016llx, read %lld at %016llx\n",
16.                      proc->pid, thread->pid,
17.                      (u64)bwr.write_size, (u64)bwr.write_buffer,
18.                      (u64)bwr.read_size, (u64)bwr.read_buffer);
20.         if (bwr.write_size > 0) {
21.                 ret = binder_thread_write(proc, thread,
22.                                           bwr.write_buffer,
23.                                           bwr.write_size,
24.                                           &bwr.write_consumed);
25.                 trace_binder_write_done(ret);
26.                 if (ret < 0) {
27.                         bwr.read_consumed = 0;
28.                         if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
29.                                 ret = -EFAULT;
30.                         goto out;
31.                 }
32.         }
33.         if (bwr.read_size > 0) {
34.                 ......
35.         }
36.         binder_debug(BINDER_DEBUG_READ_WRITE,
37.                      "%d:%d wrote %lld of %lld, read return %lld of %lld\n",
38.                      proc->pid, thread->pid,
39.                      (u64)bwr.write_consumed, (u64)bwr.write_size,
40.                      (u64)bwr.read_consumed, (u64)bwr.read_size);
41.         if (copy_to_user(ubuf, &bwr, sizeof(bwr))) {
42.                 ret = -EFAULT;
43.                 goto out;
44.         }
45. out:
46.         return ret;
47. }

复制代码

5. binder_thread_write

1. static int binder_thread_write(struct binder_proc *proc,
2.                         struct binder_thread *thread,
3.                         binder_uintptr_t binder_buffer, size_t size,
4.                         binder_size_t *consumed)
5. {
6.         uint32_t cmd;
7.         struct binder_context *context = proc->context;
8.         // 获取数据buffer，根据上面总结的发送数据可知，这个buffer由cmd和binder_transcation_data两部分数据组成
9.         void __user *buffer = (void __user *)(uintptr_t)binder_buffer;
10.         // 发送来的数据consumed=0，因此ptr指向用户空间数据buffer的起点
11.         void __user *ptr = buffer + *consumed;
12.         // 指向数据buffer的末尾
13.         void __user *end = buffer + size;
14.         // 逐个读取客户端发送来的数据(cmd+binder_transcation_data)
15.         while (ptr < end && thread->return_error.cmd == BR_OK) {
16.                 int ret;
17.                
18.                 // 获取用户空间中buffer的cmd值
19.                 if (get_user(cmd, (uint32_t __user *)ptr))
20.                         return -EFAULT;
21.                 // 移动指针到cmd的位置之后,指向binder_transcation_data数据的内存起点
22.                 ptr += sizeof(uint32_t);
23.                 trace_binder_command(cmd);
24.                 if (_IOC_NR(cmd) < ARRAY_SIZE(binder_stats.bc)) {
25.                         atomic_inc(&binder_stats.bc[_IOC_NR(cmd)]);
26.                         atomic_inc(&proc->stats.bc[_IOC_NR(cmd)]);
27.                         atomic_inc(&thread->stats.bc[_IOC_NR(cmd)]);
28.                 }
29.                 // 根据上面总结的发送数据可知，cmd是BC_TRANSACTION
30.                 switch (cmd) {
31.                    ......
32.                    /*
33.                 BC_TRANSACTION：进程发送信息的cmd
34.                 BR_TRANSACTION:进程接收BC_TRANSACTION发送信息的cmd
35.                
36.                 BC_REPLY:进程回复信息的cmd
37.                 BR_REPLY：进程接收BC_REPLY回复信息的cmd
38.                 */
39.                     case BC_TRANSACTION:
40.                     case BC_REPLY: {
41.                             struct binder_transaction_data tr;
42.                            
43.                             // 从用户空间拷贝binder_transaction_data到内核空间
44.                             if (copy_from_user(&tr, ptr, sizeof(tr)))
45.                                     return -EFAULT;
46.                             // 移动指针到binder_transaction_data的位置之后,指向下一个cmd数据的内存起点
47.                             ptr += sizeof(tr);
48.                             // 处理binder_transaction_data数据
49.                             binder_transaction(proc, thread, &tr,
50.                                                cmd == BC_REPLY, 0);
51.                             break;
52.                     }
53.                 }
54.         }
55.         ......
56. }
58. int get_user(int *val, const int __user *ptr) {
59.     if (copy_from_user(val, ptr, sizeof(int))) {
60.         return -EFAULT; // 返回错误码
61.     }
62.     return 0; // 成功
63. }

复制代码

6. binder_transaction

这个函数也分析了很多很多遍了，这里简要分析下

1. static void binder_transaction(struct binder_proc *proc,
2.                                struct binder_thread *thread,
3.                                struct binder_transaction_data *tr, int reply,
4.                                binder_size_t extra_buffers_size)
5. {
6.         int ret;
7.         struct binder_transaction *t;
8.         struct binder_work *w;
9.         struct binder_work *tcomplete;
10.         binder_size_t buffer_offset = 0;
11.         binder_size_t off_start_offset, off_end_offset;
12.         binder_size_t off_min;
13.         binder_size_t sg_buf_offset, sg_buf_end_offset;
14.         binder_size_t user_offset = 0;
15.         struct binder_proc *target_proc = NULL;
16.         struct binder_thread *target_thread = NULL;
17.         struct binder_node *target_node = NULL;
18.         struct binder_transaction *in_reply_to = NULL;
19.         struct binder_transaction_log_entry *e;
20.         uint32_t return_error = 0;
21.         uint32_t return_error_param = 0;
22.         uint32_t return_error_line = 0;
23.         binder_size_t last_fixup_obj_off = 0;
24.         binder_size_t last_fixup_min_off = 0;
25.         struct binder_context *context = proc->context;
26.         int t_debug_id = atomic_inc_return(&binder_last_id);
27.         ktime_t t_start_time = ktime_get();
28.         char *secctx = NULL;
29.         u32 secctx_sz = 0;
30.         struct list_head sgc_head;
31.         struct list_head pf_head;
32.         // 客户端发送来的数据buffer
33.         const void __user *user_buffer = (const void __user *)
34.                                 (uintptr_t)tr->data.ptr.buffer;
35.         INIT_LIST_HEAD(&sgc_head);
36.         INIT_LIST_HEAD(&pf_head);
38.         e = binder_transaction_log_add(&binder_transaction_log);
39.         e->debug_id = t_debug_id;
40.         e->call_type = reply ? 2 : !!(tr->flags & TF_ONE_WAY);
41.         e->from_proc = proc->pid;
42.         e->from_thread = thread->pid;
43.         e->target_handle = tr->target.handle;
44.         e->data_size = tr->data_size;
45.         e->offsets_size = tr->offsets_size;
46.         strscpy(e->context_name, proc->context->name, BINDERFS_MAX_NAME);
48.         binder_inner_proc_lock(proc);
49.         binder_set_extended_error(&thread->ee, t_debug_id, BR_OK, 0);
50.         binder_inner_proc_unlock(proc);
52.         if (reply) {//找到要回复的进程
53.                 ......
54.         } else {
55.             //1. 找到要发送的目的进程
56.                 if (tr->target.handle) {// tr->target.handle == 0 代表是service_manager进程，否则是其它进程
57.                         struct binder_ref *ref;
59.                         /*
60.                          * There must already be a strong ref
61.                          * on this node. If so, do a strong
62.                          * increment on the node to ensure it
63.                          * stays alive until the transaction is
64.                          * done.
65.                          */
66.                         binder_proc_lock(proc);
67.                         //根据客户端发送来的handle找到获取binder_ref
68.                         ref = binder_get_ref_olocked(proc, tr->target.handle,
69.                                                      true);
70.                         if (ref) {
71.                             // 根据binder_ref拿到目的进程的binder_node和binder_proc
72.                                 target_node = binder_get_node_refs_for_txn(
73.                                                 ref->node, &target_proc,
74.                                                 &return_error);
75.                         } else {
76.                                 binder_user_error("%d:%d got transaction to invalid handle, %u\n",
77.                                                   proc->pid, thread->pid, tr->target.handle);
78.                                 return_error = BR_FAILED_REPLY;
79.                         }
80.                         binder_proc_unlock(proc);
81.                 } else {
82.                     //处理service_manager进程
83.                         ......
84.                 }
85.                
86.                 ......
87.                
88.                 binder_inner_proc_unlock(proc);
89.         }
90.        
91.         ......
92.        
93.         t->work.type = BINDER_WORK_TRANSACTION;
94.     if (reply) {
95.                 ......
96.         } else if (!(t->flags & TF_ONE_WAY)) {
97.                 BUG_ON(t->buffer->async_transaction != 0);
98.                 binder_inner_proc_lock(proc);
99.                 /*
100.                  * Defer the TRANSACTION_COMPLETE, so we don't return to
101.                  * userspace immediately; this allows the target process to
102.                  * immediately start processing this transaction, reducing
103.                  * latency. We will then return the TRANSACTION_COMPLETE when
104.                  * the target replies (or there is an error).
105.                  */
106.                 binder_enqueue_deferred_thread_work_ilocked(thread, tcomplete);
107.                 t->need_reply = 1;
108.                 t->from_parent = thread->transaction_stack;
109.                 //入栈
110.                 thread->transaction_stack = t;
111.                 binder_inner_proc_unlock(proc);
112.                 //将数据放入目的进程的binder_proc或binder_thread，并唤醒目的进程
113.                 return_error = binder_proc_transaction(t,
114.                                 target_proc, target_thread);
115.                 if (return_error) {
116.                         binder_inner_proc_lock(proc);
117.                         binder_pop_transaction_ilocked(thread, t);
118.                         binder_inner_proc_unlock(proc);
119.                         goto err_dead_proc_or_thread;
120.                 }
121.         } else {
122.                 ......
123.         }

复制代码

2.2 服务端被被叫醒，处理客户端发送的数据

服务端的binder_loop函数中有一个死循环，一直在等待数据，如今数据来了，可以开始读取和处理数据了

1. int main(int argc, char **argv)
2. {
3.     int fd;
4.     struct binder_state *bs;
5.     uint32_t svcmgr = BINDER_SERVICE_MANAGER;
6.     uint32_t handle;
7.         int ret;
9.     bs = binder_open(128*1024);
10.     if (!bs) {
11.         fprintf(stderr, "failed to open binder driver\n");
12.         return -1;
13.     }
15.         /* add service */
16.         ret = svcmgr_publish(bs, svcmgr, "hello", hello_service_handler);
17.     if (ret) {
18.         fprintf(stderr, "failed to publish hello service\n");
19.         return -1;
20.     }
21.         ret = svcmgr_publish(bs, svcmgr, "goodbye", goodbye_service_handler);
22.     if (ret) {
23.         fprintf(stderr, "failed to publish goodbye service\n");
24.     }
26. #if 0
27.         while (1)
28.         {
29.                 /* read data */
30.                 /* parse data, and process */
31.                 /* reply */
32.         }
33. #endif
35.         binder_set_maxthreads(bs, 10);
36.    
37.     // 死循环等待读取客户端发送来的数据
38.     binder_loop(bs, test_server_handler);
40.     return 0;
41. }
43. void binder_loop(struct binder_state *bs, binder_handler func)
44. {
45.     int res;
46.     struct binder_write_read bwr;
47.     uint32_t readbuf[32];
49.     bwr.write_size = 0;
50.     bwr.write_consumed = 0;
51.     bwr.write_buffer = 0;
53.     readbuf[0] = BC_ENTER_LOOPER;
54.     binder_write(bs, readbuf, sizeof(uint32_t));
55.      
56.     // 死循环等待读取客户端的数据
57.     for (;;) {
58.         bwr.read_size = sizeof(readbuf);
59.         bwr.read_consumed = 0;
60.         bwr.read_buffer = (uintptr_t) readbuf;
61.         // 读取客户端发送来的数据（这个内核源码过程和上面service_manager被唤醒后的过程一样，不再赘述）
62.         res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
64.         if (res < 0) {
65.             ALOGE("binder_loop: ioctl failed (%s)\n", strerror(errno));
66.             break;
67.         }
68.         // 解析客户端发送来的数据
69.         res = binder_parse(bs, 0, (uintptr_t) readbuf, bwr.read_consumed, func);
70.         if (res == 0) {
71.             ALOGE("binder_loop: unexpected reply?!\n");
72.             break;
73.         }
74.         if (res < 0) {
75.             ALOGE("binder_loop: io error %d %s\n", res, strerror(errno));
76.             break;
77.         }
78.     }
79. }
81. int binder_parse(struct binder_state *bs, struct binder_io *bio,
82.                  uintptr_t ptr, size_t size, binder_handler func)
83. {
84.     int r = 1;
85.     uintptr_t end = ptr + (uintptr_t) size;
87.     while (ptr < end) {
88.         uint32_t cmd = *(uint32_t *) ptr;
89.         ptr += sizeof(uint32_t);
90. #if TRACE
91.         fprintf(stderr,"%s:\n", cmd_name(cmd));
92. #endif
93.         switch(cmd) {
94.         ......
95.         case BR_TRANSACTION: {
96.             struct binder_transaction_data *txn = (struct binder_transaction_data *) ptr;
97.             if ((end - ptr) < sizeof(*txn)) {
98.                 ALOGE("parse: txn too small!\n");
99.                 return -1;
100.             }
101.             binder_dump_txn(txn);
102.             if (func) {
103.                 unsigned rdata[256/4];
104.                 struct binder_io msg;
105.                 struct binder_io reply;
106.                 int res;
108.                 bio_init(&reply, rdata, sizeof(rdata), 4);
109.                 bio_init_from_txn(&msg, txn);
110.                 // 这里的msg就是客户端发送来的数据，func是服务端的函数test_server_handler
111.                 res = func(bs, txn, &msg, &reply);
112.                 binder_send_reply(bs, &reply, txn->data.ptr.buffer, res);
113.             }
114.             ptr += sizeof(*txn);
115.             break;
116.         }
117.         ......
118.         }
119.     }
121.     return r;
122. }
124. int test_server_handler(struct binder_state *bs,
125.                    struct binder_transaction_data *txn,
126.                    struct binder_io *msg,
127.                    struct binder_io *reply)
128. {
129.         int (*handler)(struct binder_state *bs,
130.                    struct binder_transaction_data *txn,
131.                    struct binder_io *msg,
132.                    struct binder_io *reply);
134.         handler = (int (*)(struct binder_state *bs,
135.                    struct binder_transaction_data *txn,
136.                    struct binder_io *msg,
137.                    struct binder_io *reply))txn->target.ptr; // 服务端的函数指针，在向service_manager注册服务的时候写入的，此处是hello_service_handler
138.        
139.         return handler(bs, txn, msg, reply);
140. }
142. int hello_service_handler(struct binder_state *bs,
143.                    struct binder_transaction_data *txn,
144.                    struct binder_io *msg,
145.                    struct binder_io *reply)
146. {
147.         /* 根据txn->code知道要调用哪一个函数
148.          * 如果需要参数, 可以从msg取出
149.          * 如果要返回结果, 可以把结果放入reply
150.          */
152.         /* sayhello
153.          * sayhello_to
154.          */
155.        
156.     uint16_t *s;
157.         char name[512];
158.     size_t len;
159.     uint32_t handle;
160.     uint32_t strict_policy;
161.         int i;
164.     // Equivalent to Parcel::enforceInterface(), reading the RPC
165.     // header with the strict mode policy mask and the interface name.
166.     // Note that we ignore the strict_policy and don't propagate it
167.     // further (since we do no outbound RPCs anyway).
168.     strict_policy = bio_get_uint32(msg);
171.     switch(txn->code) {
172.     case HELLO_SVR_CMD_SAYHELLO:
173.                 sayhello();
174.                 bio_put_uint32(reply, 0); /* no exception */
175.         return 0;
177.     case HELLO_SVR_CMD_SAYHELLO_TO:
178.                 /* 从msg里取出字符串 */
179.                 s = bio_get_string16(msg, &len);  //"IHelloService"
180.                 s = bio_get_string16(msg, &len);  // name
181.                 if (s == NULL) {
182.                         return -1;
183.                 }
184.                 for (i = 0; i < len; i++)
185.                         name[i] = s[i];
186.                 name[i] = '\0';
188.                 /* 调用服务函数处理客户端的数据 */
189.                 i = sayhello_to(name);
191.                 /* 把结果放入reply */
192.                 bio_put_uint32(reply, 0); /* no exception */
193.                 bio_put_uint32(reply, i);
194.                
195.         break;
197.     default:
198.         fprintf(stderr, "unknown code %d\n", txn->code);
199.         return -1;
200.     }
202.     return 0;
203. }

复制代码

2.3 客户端收到服务端处理的数据

从reply中获取服务端处理后的数据

1. int sayhello_to(char *name)
2. {
3.         unsigned iodata[512/4];
4.         struct binder_io msg, reply;
5.         int ret;
6.         int exception;
8.         /* 构造binder_io */
9.         bio_init(&msg, iodata, sizeof(iodata), 4);
10.         bio_put_uint32(&msg, 0);  // strict mode header
11.     bio_put_string16_x(&msg, "IHelloService");
13.         /* 放入参数 */
14.     bio_put_string16_x(&msg, name);
16.         /* 调用binder_call */
17.         if (binder_call(g_bs, &msg, &reply, g_hello_handle, HELLO_SVR_CMD_SAYHELLO_TO))
18.                 return 0;
19.        
20.         /* 从reply中解析出返回值 */
21.         exception = bio_get_uint32(&reply);
22.         if (exception)
23.                 ret = -1;
24.         else
25.                 ret = bio_get_uint32(&reply);
27.         binder_done(g_bs, &msg, &reply);
29.         return ret;
30.        
31. }

复制代码

三、后记

自此，我们通过三篇文章完成了Binder跨进程通信的源码分析，我们深入内核去分析Binder跨进程通信实现的源码，相信通过这三篇文章，我们已经非常深入地明白了Binder跨进程通信的实现方案。其实内核的源码我们只是分析了大概，更加细节的源码没有深入分析，但我相信有了如今的基础，我们再独立去更深入的分析内核源码，应该会轻松不少，至少不会像无头苍蝇一下，无从动手。
说实话，Android Binder的内核源码分析，我自以为写的不是很好，另有很多改善空间，另有很多没有讲清楚的地方，背面我也会不停加强自己的技术本领，希望未来有一天，我会再重新写一篇更加普通易懂的Binder驱动内核源码分析。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告