Android的Binder机制浅析

1. 引言

一般实际的软件系统中进程间通信（IPC）的实现方法有命名管道（named pipe），共享内存(shared memory)，消息队列（message queue），Socket等方法。在Android的框架（Framework）中，以Binder作为框架内进程间（通常如服务和客户间）通信的主要实现手段。这可能是出于效率和软件架构考虑。Binder通信的底层基础是Binder设备，本文通过一些实例简要介绍基于Binder通信的流程，由于整个机制，尤其是驱动和一些数据封装部分相当复杂，本文也仅仅关注了其主体的流程，难免有疏漏和错误。

2. Binder相关模块及其流程

Binder通信主要涉及以下文件：
进程状态对象：
include/utils/ProcessState.h, lib/utils/ProcessState.cpp
IPC通信机制和状态：
include/utils/IPCThreadState.h, lib/utils/ProcessState.cpp
Binder基础类：
include/utils/Binder.h，（以及一些派生类等）
（本文不加说明，相对目录均从/frameworks/base出发）

设备驱动模块：
Binder驱动模块位于Android根目录下/kernel/drivers/misc/binder.c中。

2.1 主要模块概览

图1显示了Framework中模块。其中XXX表示某具体应用。例如对Surface，其接口就是ISurface，本地调用端就是BpSurface，实现端就是BnSurface；对ServiceManager其接口就是IServiceManager，本地调用端就是BpServiceManager，实现端就是BnServiceManager。





图1 IPC-Binder相关对象继承关系
接口IXXX规定了这个应用需要实现的一些方法，例如ISurface中就定义了以下方法：

方法名	说明
registerBuffers	注册Buffer
postBuffer	输送Buffer
unregisterBuffers	注销Buffer
createOverlay	创建叠层

以Surface应用为例，远端实现侧（进程）是一个Surface操作的具体实现。而在另一个具体的进程中只要通过创建和使用BpSurface，就能够调用这个远端进程的功能。
于是BpXXX，在这里即BpSurface，由于继承了ISurface，必须也实现这些方法。而通常BpXXX是本地调用远端具体实现的入口，因此在这其中通常是启动IPC，传入和传出数据和参数的过程，这其中mRemote（BpBinder对象）是媒介，详见后续讨论。
而BnXXX，即BnSurface，同样也继承了IServiceManager，也实现这些方法。而BnXXX（或其派生类），必须真正实现这些方法的具体工作，因为它是被BpXXX调用的。

又如SurfaceFlingerClient，其接口ISurfaceFlingerClient定义如下方法：

方法名	说明
getControlBlocks	获得控制块
createSurface	创建一个Surface对象（Bp, Bn侧）
destroySurface	销毁一个Surface对象
setState	设置状态

而媒体播放器服务MediaPlayerService，其接口IMediaPlayerService定义如下方法：

方法名	说明
createMediaRecorer	创建一个媒体录制器(MediaRecorder)
createMetadataRetriever	创建一个元数据读取器(MetadataRetriever)
create	创建一个媒体播放器(MediaPlayer)
decode	解码一个流

同样服务管理模块ServiceManager也是一个基于Binder的应用，接口IServiceManager定义了如下方法：

方法名	说明
getService	获得一个服务
checkService	查询服务
addService	添加一个服务
listServices	列举服务

2.2 Binder初始化

由于Binder的基础是Binder设备，因此设备的启动和配置是首要操作。
首先一个是Binder处理进程，它是android启动后第一个运行的binder相关程序。以下代码主要在cmds/serviceManager/binder.c中。以下是代码分析片段：

1: int main(int argc, char **argv)

2: {

3:     struct binder_state *bs;

4:     void *svcmgr = BINDER_SERVICE_MANAGER;    //一个NULL指针

5:

6:     bs = binder_open(mapsize = 128*1024)

7:     {

8:         …

9:         bs->fd = open("/dev/binder", O_RDWR);

10:         …

11:         bs->mapsize = mapsize;

12:         bs->mapped = mmap(NULL, mpasize, PROT_READ, MAP_PRIVATE, bs->fd, 0);

13:         …

14:     }

15:

16:     binder_become_context_manager(bs)

17:     {

18:         // 将本进程在内核中注册为context manager

19:         ioctl(bs->fd, BINDER_SET_CONTEXT_MGR, 0);

20:     }

21:

22:     svcmgr_handle = svcmgr;

23:     binder_loop(bs, svcmgr_handler)    // binder消息分发的关键循环

24:     {

25:         …

26:         for(;;) {

27:             …

28:             // 一般阻塞再此，直到有消息送达（阻塞点1），详见激活点1

29:             ioctl(bs->fd, BINDER_WRITE_READ, &bwr)

30:             {

31:                 …

32:                 binder_thread_write(…) { …}

33:                 binder_thread_read(…)

34:                 {

35:                     …激活后，相应处理中会在ptr所指buffer中将cmd设置为

36:                     BR_TRANSACTION

37:                 }

38:                 …

39:             }

40:

41:             // 解析消息

42:             binder_parse(bs, bio = 0, ptr=readbuf, size = bwr.read_consumed,

43:                         func = svcmgr_handler)

44:             {

45:                 while (解析readbuf未完)

46:                 {

47:                     cmd = *ptr++;

48:                     switch(cmd)

49:                     {

50:                     …

51:                     case BR_TRANSACTION:

52:                         func {=svcmgr_handler}(bs, txn, &msg, &reply)

53:                         {

54:                             …

55:                             switch(txn->code)

56:                             {

57:                             case SVC_MGR_GET_SERVICE: …

58:                             case SVC_MGR_CHECK_SERVICE: …

59:                             …

60:                             }

61:                             …

62:                         }

63:                         binder_send_reply(bs, &reply, txn->data, res)

64:                         {

65:                             data= …

66:                             binder_write(bs, &data, sizeof(data))

67:                             {

68:                                 ioctl(bs->fd, BINDER_WRITE_READ, &bwr)

69:                             }

70:                         }

71:                     }

72:                 }

73:             }

74:         }

75:     }

76:     return 0;

77: }

2.3 Runtime初始化

以下的服务进程和2.2介绍的类似，也是实现了ServiceManager的接口功能，只是它是用C++实现的，并且其本身也做成了Binder类型。
因此，它可能是在上述2.2初始化之后最先加入的服务，而此后它将服务于维护其他服务。同样它也注册成Context Manager，这样在客户侧调用时无需制定具体的对象句柄。
以下程序位于cmds/runtime/main_runtime.cpp。

1: int main(…)

2: {

3:     …

4:     boot_init()

5:   {

6:         proc = ProcessState::self();

7:         proc->becomeContextManager(contextChecker, NULL)

8:         {

9:             …

10:             // 本进程变为Context Manager，接受后续的Binder处理

11:             ioctl(mDriverFD, BINDER_SET_CONTEXT_MGR, &dummy);

12:             …

13:         }

14:

15:       sm = new BServiceManager;

16:

17:         proc->setContextObject(IBinder object = sm)

18:         {

19:             setContextObject(sm, "default")

20:             {

21:               mContexts.add("default", sm)

22:                 {

23:                     装入映射表mContexts中…

24:                 }

25:             }

26:         }

27:         …

28:         run(…)

29:         {

30:             …

31:             IPCThreadState::self()->joinThreadPool()

32:             {

33:                 等待消息，过程类似2.7中的讨论

34:             }

35:         }

36:     }

37:     …

38: }

BServiceManager实现BnServiceManager，由于ServiceManager服务程序作为ContextManager，因此后续在defaultServiceManager()上进行IServiceManager调用（如调用getService()）都将定向到这个对象，而BServiceManager则维护了系统中的所有服务。

2.4 Bp对象的创建

Bp相关类型在framework中通过宏定义实现。这个宏定义在include/utils/IInterface.h中以DECLARE_META_INTERFACE和IMPLEMENT_META_INTERFACE命名。在相关的类定义中加入，例如在BpSurface这个例子中，它在ISurface.cpp中出现。

1: sp BpSurfaceFlingerClient::createSurface(..)

2: {

3:     …

4:     data上设置参数

5:   mRemote->transact(CREATE_SURFACE, data, &reply)

6:     {

7:         … IPC调用到Bn侧功能并返回

8:     }

9:     …

10:     sp binder = reply.readStrongBinder()

11:     {

12:         unflatten_binder(proc=ProcessState::self(), *this, sp* out = &val)

13:         {

14:           // 从in中取出flat_binder_object

15:           flat_binder_object *flat = in.readObject(false);

16:           if (flat)

17:             {

18:                 switch(flat->type)

19:                 {

20:                 …

21:               case BINDER_TYPE_HANDLE:    // 本节注释1

22:                     *out = proc->getStrongProxyForHandle(flat->handle)

23:                     /* ProcessState:: getStrongProxyForHandle() */

24:                     {

25:                         // 查表获得一个表项，若首次则创建一个表项

26:                         e = lookupHandleLocked(handle);

27:                         if (e != NULL) {

28:                             IBinder * b = e->binder;

29:                             if (b == NULL || …)

30:                             {    // 初次e->binder为空

31:                                 e->binder = b = new BpBinder(handle)

32:                                 { mHandle = handle; }

33:                                 …

34:                                 result = b;

35:                             }

36:                         }

37:                         return result;

38:                     }

39:                     return finish_unflatten_binder(NULL, *flat, in);

40:    }

41:             }

42:         }

43:         return val;

44:     }

45:     return interface_cast(binder)        // 上述宏定义的展开

46:     {

47:         return sp ISurface::asInterface(binder)

48:         {

49:             sp intr;

50:             if (binder != NULL)

51:             {

52:                 …

53:                 intr = new BpSurface(binder)

54:                 {

55:                     基类创建：BpRefBase(binder)

56:                     {

57:                         mRemote = binder.get();    // 即刚创建的BpBinder

58:                     }

59:                 }

60:             }

61:         }

62:     }

63: }

可见BpSurfaceFlingerClient的作用之一是创建BpSurface对象。两者都在客户端（同一进程中）。

-----
【注释1】 在binder_transaction传递（ioctl在BINDER_WRITE_READ的BC_REPLY返回时，详见后续章节）中会将扁平处理的binder信息flat_binder_object中的类型从BINDER_TYPE_BINDER转换为BINDER_TYPE_HANDLE，而具体的handle是从底层对象注册用的红黑树上取出的唯一handle号，这样Bp侧用这个handle号和Bn侧的具体对象对应。

2.5 Bn对象的创建

而在Bn侧BnSurfaceFlingerClient::onTransact处理上述mRemote->transact的过程：

1: BnSurfaceFlingerClient::onTransact(…)

2: {

3:     …

4:     switch(code) {

5:   case CREATE_SURFACE:

6:         从data上获取参数

7:         sp s = BClient::createSurface(…)

8:         {

9:             …

10:             创建一个Bn侧的ISurface实体对象s

11:             （BnSurface类型，具体如LayerBuffer::SurfaceBuffer）

12:             …

13:             sBinder = s->IInterface::asBinder()

14:           {

15:               BnInterface::onAsBinder()

16:               {

17:                     return this;

18:                 }

19:             }

20:             reply->writeStrongBinder(sBinder)

21:           {

22:                 flatten_binder(ProcessState::self(), binder= sBinder, out = this = reply)

23:                 {

24:                     flat_binder_object obj;

25:                     obj.flags = …

26:                     if (sBinder!= NULL)

27:                     {

28:                         local = binder->localBinder() { return this; }

29:                         if (!local)…

30:                         else

31:                         {

32:                             obj.type = BINDER_TYPE_BINDER;

33:                             obj.binder = local->getWeakRefs();

34:                             obj.cookie = local;    // 这个在后续访问操作使用

35:                         }

36:                     }

37:                     … 其他分支略

38:

39:                     return finish_flatten_binder(sBinder, obj, out)

40:        {

41:                         out->writeObject(obj, nullMetaData = false)

42:                         {

43:                             …将obj数据写到out这个Parcel对象中

44:                         }

45:                     }

46:                 }

47:             }

48:             // 此后reply这个Parcel将通过IPC传回客户端

49:         }

50:         …

51:     }

52: }

上述客户端和远端代码基本展示了Surface的创建过程。Bp和Bn侧的Surface创建完成后才有后续Surface的具体运作。

2.6 BpSurface运作

以前面提到的ISurface上的postBuffer接口的工作为例。这部分将深一些到IPC 事务（transaction）作业内部。其实前一节的Surface的创建过程已经调用了ISurfaceFlingerClient::createSurface接口，已经走了一遍类似的transaction事务流程，而前一节主要以BpSurface和BnSurface为例介绍在IPC流程的前提——两侧的建立为目的，在这里再对此后的事务操作进行详细介绍。
从BpSurface出发：

1: void BpSurface::postBuffer(offset)

2: {

3:     data.writeInterfacetoken(ISurface::getInterfaceDescriptor());    // ISurface接口描述符

4:     data.writeInt32(offset);

5:   mRemote->transact(code =POST_BUFFER, data, reply = &reply, 

6:                       flags = IBinder::FLAG_ONEWAY)    // FLAG_ONEWAY=1

7:     （mRemote即刚才建立的BpBinder对象，即BpBinder::transact(..)）

8:     {

9:         …

10:         IPCThreadState::self()->transact(handle = mHandle, code, data, reply, flags)

11:         {    // handle是对应Bn侧Surface对象的有效值

12:             …

13:             writeTransactionData(cmd = BC_TRANSACTION, flags, handle,

14:                                code, data, NULL)

15:           {

16:               binder_transaction_data tr;

17:                 tr.target.handle = handle;

18:                 tr.code = code; tr.flags = flags;

19:                 ...

20:                 mOut.writeInt32(cmd)

21:               mOut.write(&tr, sizeof(tr));

22:                 …

23:             }

24:             …

25:             waitForResponse(reply = NULL, acquireResult = NULL)    // 不需要返回值

26:             {

27:                 while(1)

28:                 {

29:                     talkWithDriver()

30:                     {

31:                         …

32:                         ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr)

33:                         …

34:                     }

35:                     … 处理返回值

36:                 }

37:             }

38:       }

39:         …

40:     }

41: }

上述ioctl将调用请求做成通过Binder发送到远端。其过程在后续章节介绍。

2.7 Binder驱动概要

在/kernel/drivers/misc/binder.c的Binder设备驱动中，定义了以下函数，它在内核中处理上述ioctl调用，完成Binder的功能。

1: static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

2: {

3:     …

4:     // 以下将本函数调用者进程挂起（如上述BpSurface所在进程），直到处理完返回

5:   wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2);

6:

7:     // 进程私有数据

8:     binder_proc proc = filp->private_data;

9:     // 获得调用者进程的线程池数据结构

10:     binder_thread *thread = binder_get_thread(proc);

11:     …

12:     switch(cmd)

13:     {

14:   case BINDER_WRITE_READ:

15:       …

16:       // 从用户空间将bind_write_read参数复制到bwr

17:         copy_from_user(&bwr, ubuf, sizeof(bwr);

18:         …

19:         binder_thread_write(proc, thread, bwr.write_buffer, bwr.write_size,

20:                             bwr.write_consumed)

21:       {

22:             while (处理bwr.write_buffer未完成)

23:             {

24:                 // 从用户空间获取cmd数据到内核空间

25:                 get_user(cmd, (uint32_t __user *)ptr);

26:                 …

27:                 switch(cmd)

28:                 {

29:                 …

30:                 case BC_TRANSACTION: case BC_REPLY:

31:                     // 从用户空间得到binder_transaction_data数据

32:                     copy_from_user(&tr, ptr, sizeof(tr));

33:                     …

34:                     binder_transaction(proc, thread, tr=&tr,

35:                         reply=(cmd==BC_REPLY)=false)

36:                     {

37:                         …

38:                       if (reply) 

39:                         {    // 是回复

40:                …

41:                         }

42:                         else

43:                         {    // 是正向请求

44:                             if (tr->target.handle)

45:                             {    // 从红黑树中获得对应的节点

46:                                 ref = binder_get_ref(proc, tr->target.handle);

47:                                 …

48:                                 target_node = ref->node;

49:                             }

50:                             else…

51:                             // 找到节点对应的服务进程

52:                             target_proc = target_node->proc;

53:                             …

54:                         }

55:                         if (target_thread) …

56:                         else

57:                         {

58:                             target_list = &target_proc->todo;

59:                             target_wait = &target_proc->wait;

60:                         }

61:                         …

62:                         for(遍历其中的flat objects)

63:                         {

64:                             …在postBuffer这个例子中忽略

65:                             …在createSurface中它将消息内含flat object进行处理

66:                             … 以实现两侧物件BINDER和HANDLE类型转换，

67:                             … 即完成2.4的注释1中的过程：

68:                             switch(fp->type)

69:                             {

70:                             …

71:                             case BINDER_TYPE_BINDER:

72:                                 …

73:                                 node=binder_new_node(proc,

74:                                 ptr = fp->binder, cookie = fp->cookie)

75:                                 {

76:                                     …

77:                                     node->proc = proc;

78:                                     // 这个进程就是BnSurfaceFlingerClient和

79:                                     // BnSurface所在进程

80:                                     node->ptr = ptr;

81:                                     node->cookie = cookie;

82:                                     …

83:                                 }

84:

85:                                 …

86:                                 binder_get_ref_for_node(target_proc, node);

87:                                 …

88:                                 fp->type = BINDER_TYPE_HANDLE;

89:                                 …

90:                             }

91:                         }

92:                         …

93:                         // 激活点1：

94:                         // 唤醒进程（见“阻塞点2”）

95:                         // (对于在ServiceManager阶段会激活service_manager的“阻塞点1”)

96:                         wake_up_interruptible (target_wait);

97:                     }    // binder_transaction

98:                 }

99:             }    // binder_thread_write

100:             …

101:             binder_thread_read(…)

102:             {

103:                 … 读取数据

104:                 … 处理

105:                 if (t->buffer->target_node) {

106:

107:                     tr.target.ptr = target_node->ptr;

108:                     tr.cookie = target_node->cookie;    //本地对象指针

109:                     … 相应处理中会在ptr所指buffer中将cmd设置为

110:                     BR_TRANSACTION

111:                 }

112:             }

113:             if (读得数据)

114:                 wake_up_interruptible(&proc->wait); //激活等数据的用户进程

115:         }

116:         …

117:         // 反馈给用户空间

118:         copy_to_usr(ubuf, &bwr, sizeof(bwr));

119:     }

120: }

2.8 IPC处理和监听线程

以下Surface相关服务的进程入口（cmds/surfaceflinger/main_surfaceflinger.cpp）：

1: int main(…)

2: {

3:     …

4:     SurfaceFlinger::instantiate()

5:   {    /* 实例化SurfaceFlinger服务 */

6:       sm = defaultServiceManager()

7:         {

8:             if (gDefaultServiceManager != NULL) return gDefaultServiceManager;

9:             …

10:             // 在当前进程中首次调用

11:

12:             co = ProcessState::self()->getContextObject(NULL)

13:             {

14:               if (supportsProcess()) {    /* Android支持此分支 */

15:                   return getStrongProxyForHandle(0)

16:                   {

17:                         具体流程类似2.4节介绍，生成一个新的BpBinder对象

18:                         （ServiceManager的实际对象作为Context，功能实体在启

19:                         动时已经产生，即2.3介绍的BServiceManager，所以此

20:                         处不在需要生成Bn对象）

21:                   }

22:                 } else …

23:             }

24:             gDefaultServiceManager = interaface_cast(co)

25:             {

26:                 …具体流程类似2.4节介绍，新建一个BpServiceManager对象

27:                   上述BpBinder对象作为其mRemote

28:             }

29:             return gDefaultServiceManager;

30:         }

31:         sm->addService()

32:         {

33:             远程调用，完成服务（SurfaceFlinger）的加载

34:         }

35:     }

36:

37:     …    其他服务创建 …

38:   ProcessState::self()->startThreadPool()

39:     {

40:         …

41:         spawnPoolThread(true)

42:         {

43:             创建线程运行IPCThreadState::self()->joinThreadPool(true)

44:         }

45:     }

46:

47:     IPCThreadState::self()->joinThreadPool()

48:     {

49:         …

50:         do {

51:             …处理输入信息

52:             talkWithDriver()

53:             {

54:                 通过ioctl和binder设备交换信息（见前几节介绍），

55:                 数据未到时挂起（阻塞点2）

56:             }

57:             …

58:             cmd = mIn.readInt32();

59:             executeCommand(cmd)

60:             {

61:                 switch(cmd)

62:                 {

63:                 …

64:                 case BR_TRANSACTION:

65:                     binder_transaction_data tr;

66:                     mIn.Read(&tr, sizeof(tr));

67:                     …

68:                     if (tr.target.ptr)

69:                     {

70:                         sp b = ((BBinder*)tr.cookie;    // 本地对象指针

71:                         b->transact(tr.code, buffer, &reply, 0)

72:                         {

73:                             BnSurface:: onTransact(…)

74:                             {

75:                                 switch(code)

76:                                 {

77:                                     …

78:                                     case POST_BUFFER:

79:                                         …

80:                                         offset = data.readInt32();

81:                                         postBuffer(offset);

82:                                     …

83:                                 }

84:                               …

85:                             }

86:                         }

87:                     }

88:                     …

89:                 }

90:             }

91:         } while (未完结);

92:          …

93:     }

94: }

以下是媒体相关服务进程入口：

1: int main(…)

2: {

3:     …

4:     MediaPlayerService::instantiate()    { 见上一段代码 }

5:   …    其他服务创建 …

6:   ProcessState::self()->startThreadPool() { 见上一段代码 }

7:     IPCThreadState::self()->joinThreadPool() { 见上一段代码 }

8: }

2.9 Surface总体流程

根据上述的Bp和Bn两侧生成过程原理分析SurfaceFlinger相关代码，可以发现：
通过ISurfaceFlinger::createConnection，两侧生成ISurfaceFlingerClient；
通过ISurfaceFlingerClient:: createSurface，两侧生成ISurface。
而服务SurfaceFlinger的Bp端最初通过获取服务取得，如下：

1: _get_surface_manager()

2: {

3:     if (gSurfaceManager != 0) return gSurfaceManager;

4:

5:   sm = defaultServiceManager() { 详见2.8节 }

6:

7:     …

8:     // 获得SurfaceFlinger服务（Bp侧句柄），其原理前面章节（如2.3节）

9:     binder = sm->getService(String16("SurfaceFlinger"));

10:     …

11:

12:     // 实际产生

13:     sp sc = interface_cast (binder)

14:   { 详见2.4节，sc实为BpSurfaceComposer }

15:

16:   if (gSurfaceManager == 0) gSurfaceManager = sc;

17:

18:     return gSurfaceManager;

19: }

加上前述Surface的分析，Surface的总体服务流程如图2所示，这些操作使得最终在客户应用中得到BpSurfaceComposer, BpSurfaceFlingerClient和BpSurface三个对象。而发起这些创建的是客户就是SurfaceFlingerClient，它在SurfaceSession（Java对象）中维护，可见SurfaceSession是创建Surface的关键对象。






2.10 MediaPlayerService服务总流程

1: android_media_MediaPlayer_setDataSource(…)    /* JNI */

2: {

3:     sp mp = getMediaPlayer(…)

4:   {

5:       获得Java对象中引用的MediaPlayer对象，

6:       它曾在android_media_MediaPlayer_native_setup中设置

7:         即一个新建的MediaPlayer对象。

8:         虽然它是BnMediaPlayer，但是接下来调用setDataSource将它绑定到一个远端

9:         的MediaPlayer上

10:     }

11:   MediaPlayer::setDataSource(url)

12:     {

13:         …

14:       sp &service = MediaPlayer::getMediaPlayerService()

15:       {

16:           sp sm = defaultServiceManager() {…}

17:           …

18:             binder = sm->getService("media.player") {…}

19:             …

20:             sMediaPlayerService = interface_cast(binder)

21:           { … 得到一个BpMediaPlayerService }

22:                     …

23:             return sMediaPlayerService;

24:         }

25:         …

26:             // 通过BpMediaPlayerService远程调用创建一个播放器

27:         sp player = service->create(…) {…}

28:         setDataSource(player)

29:         {

30:             … 

31:             mPlayer = player;    //  远端的实际功能播放器

32:             …

33:         }

34:         …

35:     }

36: }

参考资料：
http://hi.baidu.com/albertchen521/blog/item/30c32d3f4bee993a71cf6ca0.html
http://www.limodev.cn/blog/archives/777