Android系统RPC与Binder

一、RPC与IPC关系

    Binder机制对于Android系统学习就犹如根文件系统挂载部分对于Linux内核学习；是一座不得不翻越的大山（指其复杂程度与重要性）。

1.RPC基本流程

    RPC在调用一个远程过程后，自己进入等待状态，传往远程过程的参数包括过程参数，返回参数包括执行结果；当收到包括执行结果的消息后，本地进程从消息中取得结果，调用进程重新开始执行。在服务器一方，有一个程序在等待调用，当有一个调用到达时，服务器进程取得进程参数，计算结果，然后返回结果。

    调用可以同步的也可以是异步的；服务器可以创建一个线程来接收用户请求，也可以自己来接收用户请求。

2.二者关系

相同点：二者都可以用于进程间；

不同点：RPC强调的是调用、即一个进程直接调用另外一个进程中的方法，而IPC仅仅完成进程间的互通信、没有函数调用功能。

总结：RPC其实就是添加了进程间函数调用功能的IPC。

二、Android系统RPC与Binder的关系

    Android系统中的Binder为IPC的一种实现方式，为Android系统RPC机制提供底层支持；其他常见的RPC还有COM组件、CORBA架构等。不同之处在于Android的RPC并不需要实现不同主机或不同操作系统间的远程调用，所以、它属于一个轻量级的RPC。

总结：Android系统的RPC = Binder进程间通信 + 在Binder基础上建立起来的进程间函数调用机制。

三、Android系统RPC实现

1.基本原理

a）服务端调用Binder驱动；并开启线程，反复调用Binder驱动的读接口、服务端继承Bnxxx进而继承BBinder的处理函数和Binder驱动的写接口，其中读接口会阻塞。

b）客户端通过Bpxxx继承Bpbinder调用Binder驱动；并开启线程，首先调用Binder驱动写接口、唤醒服务端，然后客户端调用Binder驱动读接口、并阻塞，服务器端处理完后调用写接口、唤醒阻塞中的客户端；如此，完成调用逻辑。

JAVA层AIDL——AIDL对Binder的使用进行了封装，可以让开发者方便的进行方法的远程调用。

2.具体实现

Binder负责IPC，主要就是Binder驱动；

RPC机制的的实现由如下组件完成：Client、Server、Service Manager。

下边着重分析上处组件。

3.Server服务组件

创建一个线程来接收、处理用户请求，发送执行结果：

sp<ProcessState> proc(ProcessState::self()); //打开Binder设备

ProcessState::self()->startThreadPool(); //开启监听线程

IPCThreadState::self()->joinThreadPool(); //将线程加入，loop等待客户端命令

talkWithDriver();  //接收/发送数据

executeCommand();  //指令处理

关键代码流程：

frameworks/native/libs/binder/IPCThreadState.cpp

void IPCThreadState::joinThreadPool(bool isMain){  do {    result = talkWithDriver();  //接收/发送数据    result = executeCommand(cmd); //指令处理  }while (result != -ECONNREFUSED && result != -EBADF);}//接收/发送数据status_t IPCThreadState::talkWithDriver(bool doReceive){  binder_write_read bwr;  bwr.write_size = outAvail;  bwr.write_buffer = (long unsigned int)mOut.data();  if (doReceive && needRead) {    bwr.read_size = mIn.dataCapacity();    bwr.read_buffer = (long unsigned int)mIn.data();  } else {    bwr.read_size = 0;    bwr.read_buffer = 0;  }  bwr.write_consumed = 0;  bwr.read_consumed = 0;  do {    if (ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0) //重要；下边会分析      err = NO_ERROR;  }while (err == -EINTR);}//指令处理status_t IPCThreadState::executeCommand(int32_t cmd){  switch (cmd) {    case BR_TRANSACTION:{      sp<BBinder> b((BBinder*)tr.cookie);      const status_t error = b->transact(tr.code, buffer, &reply, tr.flags);      /*      frameworks/native/libs/binder/Binder.cpp      status_t BBinder::transact(          uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags){        err = onTransact(code, data, reply, flags);      }      以下为Service继承Bnxxx进而继承BBinder实现的该接口，也就是实际调用的服务端的接口      */    }  }}

4.Client客户端组件

创建一个线程来发送请求，接收执行结果：

ProcessState::self()->getContextObject(NULL)；//获得ServiceManager接口

GetService();  //获得代理接口Bpxxx

remote()->transact();  //发送请求并等待结果返回

这部分先不做讨论，后边《四》中将会看到Client/Server组件调用Service Manager的例子

5.主要使用地方就是服务创建部分：

SystemServer服务——frameworks/base/cmds/system_server/library/System_init.cpp

MediaService服务——frameworks/av/media/mediaserver/Main_mediaserver.cpp

供JAVA调用——frameworks/base/core/jni/android_util_Binder.cpp

供Native调用——frameworks/native/include/binder/BinderService.cpp

四、Binder远程同步调用的实现——ServiceManager

Binder驱动在读函数中：wait_event_interruptible(thread->wait, binder_has_thread_work(thread));阻塞睡眠。

Binder驱动在写函数中：wake_up_interruptible(target_wait);唤醒另外一个进程。

该过程是实现不同进程间同步调用的关键。

1.Client和Server组件调用ServiceManager的远程接口BpServiceManager

Server端：BpServiceManager::addService

Client端：BpServiceManager::getService

BpServiceManager::addService中如下：

frameworks/native/libs/binder/IServiceManager.cpp

class BpServiceManager : public BpInterface<IServiceManager>{  virtual status_t addService(const String16& name, const sp<IBinder>& service,            bool allowIsolated){    status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);    /*    模板类    frameworks/native/include/binder/IInterface.h    template<typename INTERFACE>    class BpInterface : public INTERFACE, public BpRefBase{      public:      BpInterface(const sp<IBinder>& remote);    }        */  }}

实际调用如下：

frameworks/native/libs/binder/Binder.cpp

status_t BpBinder::transact(    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags){  // Once a binder has died, it will never come back to life.  if (mAlive) {    status_t status = IPCThreadState::self()->transact(    mHandle, code, data, reply, flags);  //mHandle就是目标，这里是0    if (status == DEAD_OBJECT) mAlive = 0;      return status;  }  return DEAD_OBJECT;}

frameworks/native/libs/binder/IPCThreadState.cpp

status_t IPCThreadState::transact(int32_t handle,                                  uint32_t code, const Parcel& data,                                  Parcel* reply, uint32_t flags){  err = writeTransactionData(BC_TRANSACTION, flags, handle, code, data, NULL);  /*  binder_transaction_data tr;  tr.target.handle = handle;  tr.code = code;  tr.flags = binderFlags;  tr.cookie = 0;  tr.sender_pid = 0;  tr.sender_euid = 0;  */  err = waitForResponse(reply);}status_t IPCThreadState::waitForResponse(Parcel *reply, status_t *acquireResult){  if ((err=talkWithDriver()) < NO_ERROR) break;  //阻塞}status_t IPCThreadState::talkWithDriver(bool doReceive){  bwr.write_consumed = 0;  if (ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0)}

drivers/staging/android/binder.c

static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg){  switch (cmd) {    case BINDER_WRITE_READ: {      ret = binder_thread_write(proc, thread, (void __user *)bwr.write_buffer, bwr.write_size, &bwr.write_consumed);      ret = binder_thread_read(proc, thread, (void __user *)bwr.read_buffer, bwr.read_size, &bwr.read_consumed, filp->f_flags & O_NONBLOCK); //阻塞    }  }}int binder_thread_write(struct binder_proc *proc, struct binder_thread *thread,    void __user *buffer, int size, signed long *consumed){  switch (cmd) {    case BC_TRANSACTION: //一般都是这个    case BC_REPLY: {      struct binder_transaction_data tr;      if (copy_from_user(&tr, ptr, sizeof(tr))) return -EFAULT;      ptr += sizeof(tr);      binder_transaction(proc, thread, &tr, cmd == BC_REPLY);      break;    }  }}static void binder_transaction(struct binder_proc *proc, struct binder_thread *thread,struct binder_transaction_data *tr, int reply){  struct binder_proc *target_proc;  struct binder_thread *target_thread = NULL;  struct binder_node *target_node = NULL;  struct list_head *target_list;  wait_queue_head_t *target_wait;  if (tr->target.handle) {  }esle{    target_node = binder_context_mgr_node; //重要  }  target_proc = target_node->proc; //重要  if (target_thread) {  } else {     target_list = &target_proc->todo;  //重要     target_wait = &target_proc->wait;  //重要  }  //唤醒ServiceManager线程  list_add_tail(&t->work.entry, target_list);  list_add_tail(&tcomplete->entry, &thread->todo);  if (target_wait)    wake_up_interruptible(target_wait);  //唤醒ServiceManager}

唤醒ServiceManager并将说明需要调用的接口以及入参。

2.ServiceManager组件如何响应Client和Server组件调用过程

先补充下Service Manager进程启动过程：

frameworks/base/cmds/servicemanager/service_manager.c

int main(int argc, char **argv){  binder_loop(bs, svcmgr_handler);}

frameworks/base/cmds/servicemanager/binder.c

void binder_loop(struct binder_state *bs, binder_handler func){  for(;;){    res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);    res = binder_parse(bs, 0, readbuf, bwr.read_consumed, func);  }}

drivers/staging/android/binder.c

static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg){  if (bwr.read_size > 0) {    ret = binder_thread_write(proc, thread, (void __user *)bwr.write_buffer, bwr.write_size, &bwr.write_consumed);    ret = binder_thread_read(proc, thread, (void __user *)bwr.read_buffer, bwr.read_size, &bwr.read_consumed, filp->f_flags & O_NONBLOCK);  }}static int binder_thread_read(struct binder_proc *proc, struct binder_thread *thread,void  __user *buffer, int size, signed long *consumed, int non_block){  ret = wait_event_interruptible(thread->wait, binder_has_thread_work(thread)); //等待被唤醒}

=========================================

//被唤醒后

frameworks/base/cmds/servicemanager/service_manager.c

int binder_parse(struct binder_state *bs, struct binder_io *bio,                 uint32_t *ptr, uint32_t size, binder_handler func){  switch(cmd) {    case BR_TRANSACTION: {      binder_send_reply(bs, &reply, txn->data, res);    }  }}void binder_send_reply(struct binder_state *bs,                       struct binder_io *reply,                       void *buffer_to_free,                       int status){  binder_write(bs, &data, sizeof(data));}int binder_write(struct binder_state *bs, void *data, unsigned len){  struct binder_write_read bwr;  int res;  bwr.write_size = len;  bwr.write_consumed = 0;  bwr.write_buffer = (unsigned) data;  bwr.read_size = 0;  bwr.read_consumed = 0;  bwr.read_buffer = 0;  res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);}

唤醒Client或Server组件并将执行结果返回。

六、Binder驱动部分

drivers/staging/android/binder.c

static struct file_operations binder_fops = {  .owner = THIS_MODULE,  .poll = binder_poll,  .unlocked_ioctl = binder_ioctl,  //控制操作接口  .mmap = binder_mmap, //mmap系统调用  .open = binder_open,  //打开接口  .flush = binder_flush,  .release = binder_release,  //关闭接口};static struct miscdevice binder_miscdev = {  .minor = MISC_DYNAMIC_MINOR,  .name = "binder",  .fops = &binder_fops};static int __init binder_init(void){  int ret;  binder_proc_dir_entry_root = proc_mkdir("binder", NULL);  if (binder_proc_dir_entry_root)    binder_proc_dir_entry_proc = proc_mkdir("proc", binder_proc_dir_entry_root);  ret = misc_register(&binder_miscdev);  //注册设备并创建设备节点  if (binder_proc_dir_entry_root) {    create_proc_read_entry("state", S_IRUGO, binder_proc_dir_entry_root, binder_read_proc_state, NULL);    create_proc_read_entry("stats", S_IRUGO, binder_proc_dir_entry_root, binder_read_proc_stats, NULL);    create_proc_read_entry("transactions", S_IRUGO, binder_proc_dir_entry_root, binder_read_proc_transactions, NULL);    create_proc_read_entry("transaction_log", S_IRUGO, binder_proc_dir_entry_root, binder_read_proc_transaction_log, &binder_transaction_log);    create_proc_read_entry("failed_transaction_log", S_IRUGO, binder_proc_dir_entry_root, binder_read_proc_transaction_log, &binder_transaction_log_failed);  }  return ret;}device_initcall(binder_init);

七、一些dome

1.Native层的binder应用：Android Binder机制的Native应用

2.Native层的binder双向调用：Android Binder机制的Native应用—双向通信

3.JAVA层的binder实例：Android Service学习之AIDL, Parcelable和远程服务