一、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和远程服务
