Android IPC 通讯机制源码分析

Client A与Binder kernel通信:

kernel\drivers\android\Binder.c）

staticintbinder_open(structinode*nodp,structfile*filp)

{

struct binder_proc *proc;

if (binder_debug_mask & BINDER_DEBUG_OPEN_CLOSE)   printk(KERN_INFO "binder_open: %d:%d\n", current->group_leader->pid, current->pid);

proc = kzalloc(sizeof(*proc), GFP_KERNEL);

if(proc==NULL)

return-ENOMEM;

get_task_struct(current);

proc->tsk=current;//保存打开/dev/binder驱动的当前进程任务数据结构

INIT_LIST_HEAD(&proc->todo);

init_waitqueue_head(&proc->wait);

proc->default_priority=task_nice(current);

mutex_lock(&binder_lock);

binder_stats.obj_created[BINDER_STAT_PROC]++;

hlist_add_head(&proc->proc_node,&binder_procs);

proc->pid=current->group_leader->pid;

INIT_LIST_HEAD(&proc->delivered_death);

filp->private_data=proc;

mutex_unlock(&binder_lock);

if (binder_proc_dir_entry_proc) {

charstrbuf[11];

snprintf(strbuf,sizeof(strbuf),"%u",proc->pid);

create_proc_read_entry(strbuf,S_IRUGO,binder_proc_dir_entry_proc,binder_read_proc_proc,proc);//为当前进程创建一个process入口结构信息

}

return0;

}

从这里可以知道每一个打开/dev/binder的进程的信息都保存在binderkernel中，因而当一个进程调用ioctl与kernelbinder通信时，binderkernel就能查询到调用进程的信息。BINDER_WRITE_READ是调用ioctl进程与Binderkernel通信一个非常重要的command。大家可以看到在IPCThreadState中的transact函数这个函数中calltalkWithDriver发送的command就是BINDER_WRITE_READ。

staticlongbinder_ioctl(structfile*filp,unsignedintcmd,unsignedlongarg)

{

intret;

structbinder_proc*proc=filp->private_data;

structbinder_thread*thread;

unsignedintsize=_IOC_SIZE(cmd);

void __user *ubuf = (void __user *)arg;

/*printk(KERN_INFO "binder_ioctl: %d:%d %x %lx\n", proc->pid, current->pid, cmd, arg);*/

//将调用ioctl的进程挂起caller将挂起直到service返回

ret=wait_event_interruptible(binder_user_error_wait,binder_stop_on_user_error<2);

if(ret)

   return ret;

mutex_lock(&binder_lock);

thread=binder_get_thread(proc);//根据当caller进程消息获取该进程线程池数据结构

if(thread==NULL){

ret=-ENOMEM;

gotoerr;

}

switch (cmd) {

caseBINDER_WRITE_READ:{//IPcThreadState中talkWithDriver设置ioctl的CMD

structbinder_write_readbwr;

if(size!=sizeof(structbinder_write_read)){

ret=-EINVAL;

gotoerr;

}

if(copy_from_user(&bwr,ubuf,sizeof(bwr))){

ret=-EFAULT;

gotoerr;

}

if(binder_debug_mask&BINDER_DEBUG_READ_WRITE)

printk(KERN_INFO"binder:%d:%dwrite%ldat%08lx,read%ldat%08lx\n",

proc->pid,thread->pid,bwr.write_size,bwr.write_buffer,bwr.read_size,bwr.read_buffer);

if(bwr.write_size>0){

ret=binder_thread_write(proc,thread,(void__user*)bwr.write_buffer,bwr.write_size,&bwr.write_consumed);

if(ret<0){

bwr.read_consumed=0;

if(copy_to_user(ubuf,&bwr,sizeof(bwr)))

ret=-EFAULT;

gotoerr;

}

}

if(bwr.read_size>0){//数据写入到callerprocess。

ret=binder_thread_read(proc,thread,(void__user*)bwr.read_buffer,bwr.read_size,&bwr.read_consumed,filp->f_flags&O_NONBLOCK);

if(!list_empty(&proc->todo))

wake_up_interruptible(&proc->wait);//恢复挂起的caller进程

if(ret<0){

if(copy_to_user(ubuf,&bwr,sizeof(bwr)))

ret=-EFAULT;

gotoerr;

}

}

.........................................

}

Int binder_thread_write(struct binder_proc *proc, struct binder_thread *thread,void __user *buffer, int size, signed long *consumed)

{

uint32_tcmd;

void__user*ptr=buffer+*consumed;

void __user *end = buffer + size;

while (ptr < end && thread->return_error == BR_OK) {

if(get_user(cmd,(uint32_t__user*)ptr))//从user空间获取cmd数据到内核空间

return-EFAULT;

ptr+=sizeof(uint32_t);

if(_IOC_NR(cmd)<ARRAY_SIZE(binder_stats.bc)){

binder_stats.bc[_IOC_NR(cmd)]++;

proc->stats.bc[_IOC_NR(cmd)]++;

thread->stats.bc[_IOC_NR(cmd)]++;

}

switch(cmd){

caseBC_INCREFS:

.........................................

caseBC_TRANSACTION://IPCThreadState通过writeTransactionData设置该cmd

caseBC_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(structbinder_proc*proc,structbinder_thread*thread,

structbinder_transaction_data*tr,intreply)

{

..............................................

if(reply)//cmd!=BC_REPLY不走这个case

{

......................................

}

else

{

if(tr->target.handle){//对于service_manager来说这个条件不满足(handle==0)

.......................................

}

}else{//这一段我们获取到了service_manangerprocess注册在binderkernle的进程信息

target_node=binder_context_mgr_node;//BINDER_SET_CONTEXT_MGR注册了service

if(target_node==NULL){//manager

return_error=BR_DEAD_REPLY;

gotoerr_no_context_mgr_node;

}

}

e->to_node=target_node->debug_id;

target_proc=target_node->proc;//得到目标进程service_mananger的结构

if(target_proc==NULL){

return_error=BR_DEAD_REPLY;

gotoerr_dead_binder;

}

....................

}

if(target_thread){

e->to_thread=target_thread->pid;

target_list=&target_thread->todo;

target_wait=&target_thread->wait;//得到servicemanager挂起的线程

}else{

target_list=&target_proc->todo;

target_wait=&target_proc->wait;

}

............................................

caseBINDER_TYPE_BINDER:

caseBINDER_TYPE_WEAK_BINDER:{

..........................

ref=binder_get_ref_for_node(target_proc,node);//在Binderkernel中创建

..........................//查找到的service参考

   } break;

............................................

if(target_wait)

wake_up_interruptible(target_wait);//唤醒挂起的线程处理callerprocess请求

............................................//处理命令可以看svcmgr_handler

}

到这里我们已经通过getService连接到servicemanager进程了，servicemanager进程得到请求后，如果他的状态是挂起的话，将被唤醒。现在我们来看一下servicemanager中的binder_loop函数。

Service_manager.c

voidbinder_loop(structbinder_state*bs,binder_handlerfunc)

{

.................................

    binder_write(bs, readbuf, sizeof(unsigned));

    for (;;) {

bwr.read_size=sizeof(readbuf);

bwr.read_consumed=0;

bwr.read_buffer=(unsigned)readbuf;

res=ioctl(bs->fd,BINDER_WRITE_READ,&bwr);//如果没有要处理的请求进程将挂起

if(res<0){

LOGE("binder_loop:ioctlfailed(%s)\n",strerror(errno));

break;

}

res=binder_parse(bs,0,readbuf,bwr.read_consumed,func);//这里func就是

...................................//svcmgr_handler

}

}

接收到数据处理的请求，这里进行解析并调用前面注册的回调函数查找caller请求的service

intbinder_parse(structbinder_state*bs,structbinder_io*bio,

uint32_t*ptr,uint32_tsize,binder_handlerfunc)

{

....................................

switch(cmd){

......

caseBR_TRANSACTION:{

structbinder_txn*txn=(void*)ptr;

if((end-ptr)*sizeof(uint32_t)<sizeof(structbinder_txn)){

LOGE("parse:txntoosmall!\n");

return-1;

}

binder_dump_txn(txn);

if(func){

unsignedrdata[256/4];

structbinder_iomsg;

structbinder_ioreply;

                int res;

                bio_init(&reply, rdata, sizeof(rdata), 4);

bio_init_from_txn(&msg,txn);

res=func(bs,txn,&msg,&reply);//找到caller请求的service

binder_send_reply(bs,&reply,txn->data,res);//将找到的service返回给caller

}

ptr+=sizeof(*txn)/sizeof(uint32_t);

break;

........

        }

}

voidbinder_send_reply(structbinder_state*bs,

structbinder_io*reply,

void*buffer_to_free,

intstatus)

{

struct{

uint32_tcmd_free;

void*buffer;

uint32_tcmd_reply;

structbinder_txntxn;

    } __attribute__((packed)) data;

    data.cmd_free = BC_FREE_BUFFER;

data.buffer=buffer_to_free;

data.cmd_reply=BC_REPLY;//将我们前面binder_thread_write中cmd替换为BC_REPLY就可以知

data.txn.target=0;//道servicemanager如何将找到的service返回给caller了

..........................

binder_write(bs,&data,sizeof(data));//调用ioctl与binderkernel通信

}

从这里走出去后，caller该被唤醒了，client进程就得到了所请求的service的IBinder对象在Binder kernel中的参考，这是一个远程BBinder对象。

连接建立后的client连接Service的通信过程：

virtualsp<ICamera>connect(constsp<ICameraClient>&cameraClient)

{

Parceldata,reply;

data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());

data.writeStrongBinder(cameraClient->asBinder());

remote()->transact(BnCameraService::CONNECT,data,&reply);

returninterface_cast<ICamera>(reply.readStrongBinder());

}

向前面分析的这里remote是我们得到的CameraService的对象，caller进程会切入到CameraService。android的每一个进程都会创建一个线程池，这个线程池用处理其他进程的请求。当没有数据的时候线程是挂起的，这时binderkernel唤醒了这个线程：

IPCThreadState::joinThreadPool(boolisMain)

{

    LOG_THREADPOOL("**** THREAD %p (PID %d) IS JOINING THE THREAD POOL\n", (void*)pthread_self(), getpid());

    mOut.writeInt32(isMain ? BC_ENTER_LOOPER : BC_REGISTER_LOOPER);

status_tresult;

do{

int32_tcmd;

result=talkWithDriver();

if(result>=NO_ERROR){

size_tIN=mIn.dataAvail();//binderkernel传递数据到service

if(IN<sizeof(int32_t))continue;

cmd=mIn.readInt32();

IF_LOG_COMMANDS(){

alog<<"Processingtop-levelCommand:"

<<getReturnString(cmd)<<endl;

}

result=executeCommand(cmd);//service执行binderkernel请求的命令

}

//Letthisthreadexitthethreadpoolifitisnolonger

//neededanditisnotthemainprocessthread.

if(result==TIMED_OUT&&!isMain){

break;

}

}while(result!=-ECONNREFUSED&&result!=-EBADF);

.......................

}

status_t IPCThreadState::executeCommand(int32_t cmd)

{

BBinder*obj;

RefBase::weakref_type*refs;

status_tresult=NO_ERROR;

switch(cmd){

.........................

caseBR_TRANSACTION:

{

binder_transaction_datatr;

result=mIn.read(&tr,sizeof(tr));

LOG_ASSERT(result==NO_ERROR,

"NotenoughcommanddataforbrTRANSACTION");

if(result!=NO_ERROR)break;

Parcelbuffer;

buffer.ipcSetDataReference(

reinterpret_cast<constuint8_t*>(tr.data.ptr.buffer),

tr.data_size,

reinterpret_cast<constsize_t*>(tr.data.ptr.offsets),

tr.offsets_size/sizeof(size_t),freeBuffer,this);

constpid_torigPid=mCallingPid;

constuid_torigUid=mCallingUid;

mCallingPid=tr.sender_pid;

mCallingUid=tr.sender_euid;

//LOGI(">>>>TRANSACTfrompid%duid%d\n",mCallingPid,mCallingUid);

Parcelreply;

.........................

if(tr.target.ptr){

sp<BBinder>b((BBinder*)tr.cookie);//service中Binder对象即CameraService

conststatus_terror=b->transact(tr.code,buffer,&reply,0);//将调用

if(error<NO_ERROR)reply.setError(error);//CameraService的onTransact函数

}else{

conststatus_terror=the_context_object->transact(tr.code,buffer,&reply,0);

if(error<NO_ERROR)reply.setError(error);

}

//LOGI("<<<<TRANSACTfrompid%drestorepid%duid%d\n",

//mCallingPid,origPid,origUid);

if((tr.flags&TF_ONE_WAY)==0){

LOG_ONEWAY("Sendingreplyto%d!",mCallingPid);

sendReply(reply,0);

}else{

LOG_ONEWAY("NOTsendingreplyto%d!",mCallingPid);

}

mCallingPid=origPid;

mCallingUid=origUid;

IF_LOG_TRANSACTIONS(){

TextOutput::Bundle_b(alog);

alog<<"BC_REPLYthr"<<(void*)pthread_self()<<"/obj"

<<tr.target.ptr<<":"<<indent<<reply<<dedent<<endl;

}

..................................

}

break;

}

..................................

if((tr.flags&TF_ONE_WAY)==0){

LOG_ONEWAY("Sendingreplyto%d!",mCallingPid);

sendReply(reply,0);//通过binderkernel返回数据到caller进程这个过程大家

}else{//参照前面的叙述自己分析一下

LOG_ONEWAY("NOTsendingreplyto%d!",mCallingPid);

}

if(result!=NO_ERROR){

mLastError=result;

}

returnresult;

}

调用CameraServiceBBinder对象中的transact函数：

status_tBBinder::transact(

uint32_tcode,constParcel&data,Parcel*reply,uint32_tflags)

{

.....................

switch(code){

casePING_TRANSACTION:

reply->writeInt32(pingBinder());

break;

default:

err=onTransact(code,data,reply,flags);

break;

}

...................

returnerr;

}

将调用CameraService的onTransact函数，CameraService继承了BBinder。

status_tBnCameraService::onTransact(

uint32_tcode,constParcel&data,Parcel*reply,uint32_tflags)

{

switch(code){

caseCONNECT:{

CHECK_INTERFACE(ICameraService,data,reply);

sp<ICameraClient>cameraClient=interface_cast<ICameraClient>(data.readStrongBinder());

sp<ICamera>camera=connect(cameraClient);//真正的处理函数

reply->writeStrongBinder(camera->asBinder());

returnNO_ERROR;

}break;

default:

returnBBinder::onTransact(code,data,reply,flags);

}

}

至此完成了一次从client到service的通信。

设计一个多客户端的Service

Service可以连接不同的Client,这里说的多客户端是指在Service中为不同的client创建不同的IClient接口，如果看过AIDL编程的话，应该清楚，Service需要开放一个IService接口给客户端，我们通过defaultServiceManager->getService就可以得到相应的service一个BpBinder接口，通过这个接口调用transact函数就可以与service通信了，这样也就完成了一个简单的service与client程序了，但这里有个缺点就是，这个IService是对所有的client开放的，如果我们要对不同的client做区分的话，在建立连接的时候所有的client需要给Service一个特性，这样做也未尝不可，但会很麻烦。比如对Camera来说可能不止一个摄像头，摄像头的功能也不一样，这样做就比较麻烦了。其实我们完全可以参照QT中多客户端的设计方式，在Service中为每一个Client都创建一个IClient接口，IService接口只用于Serivce与Client建立连接用。对于Camera，如果存在多摄像头我们就可以在Service中为不同的Client打开不同的设备。

importandroid.os.IBinder;

importandroid.os.RemoteException;

publicclassTestServerServerextendsandroid.app.testServer.ITestServer.Stub

{

intmClientCount=0;

testServerClientmClient[];

@Override

publicandroid.app.testServer.ITestClient.Stubconnect(ITestClientclient)throwsRemoteException

{

//TODOAuto-generatedmethodstub

testServerClienttClient=newtestServerClient(this,client);//为Client创建

mClient[mClientCount]=tClient;//不同的IClient

mClientCount++;

System.out.printf("***Serverconnectclientis%d",client.asBinder());

returntClient;

}

@Override

publicvoidreceivedData(intcount)throwsRemoteException

{

//TODOAuto-generatedmethodstub

}

PublicstaticclasstestServerClientextendsandroid.app.testServer.ITestClient.Stub

{

publicandroid.app.testServer.ITestClientmClient;

publicTestServerServermServer;

publictestServerClient(TestServerServertServer,android.app.testServer.ITestClienttClient)

{

mServer=tServer;

mClient=tClient;

}

publicIBinderasBinder()

{

//TODOAuto-generatedmethodstub

returnthis;

}

}

}

这仅仅是个Service的demo而已，如果添加这个作为system Service还得改一下android代码avoid permission check!

总结：

假定一个ClientA进程与ServiceB进程要建立IPC通信，通过前面的分析我们知道他的流程如下：

1：ServiceB打开Binderdriver，将自己的进程信息注册到kernel并为Service创建一个binder_ref。

2：ServiceB通过Add_Service将Service信息添加到service_manager进程

3：ServiceB的Threadpool挂起等待client的请求

4：ClientA调用open_driver打开Binderdriver将自己的进程信息注册到kernel并为Service创建一个binder_ref

5:ClientA调用defaultManagerService.getService得到ServiceB在kernel中的IBinder对象

6：通过transact与Binderkernel通信，BinderKernel将ClientA挂起。

7：BinderKernel恢复ServiceBthreadpool线程，并在joinThreadPool中处理Client的请求

8:BinderKernel挂起ServiceB并将ServiceB返回的数据写到ClientA

9：BinderKernle恢复ClientA

Binderkerneldriver在ClientA与ServiceB之间扮演着中间代理的角色。任何通过transact传递的IBinder对象都会在Binderkernel中创建一个与此相关联的独一无二的BInder对象，用于区分不同的Client。