Android跨進(jìn)程通信IPC整體內(nèi)容如下
- 1、Android跨進(jìn)程通信IPC之1——Linux基礎(chǔ)
- 2、Android跨進(jìn)程通信IPC之2——Bionic
- 3、Android跨進(jìn)程通信IPC之3——關(guān)于"JNI"的那些事
- 4、Android跨進(jìn)程通信IPC之4——AndroidIPC基礎(chǔ)1
- 4、Android跨進(jìn)程通信IPC之4——AndroidIPC基礎(chǔ)2
- 5、Android跨進(jìn)程通信IPC之5——Binder的三大接口
- 6、Android跨進(jìn)程通信IPC之6——Binder框架
- 7、Android跨進(jìn)程通信IPC之7——Binder相關(guān)結(jié)構(gòu)體簡(jiǎn)介
- 8、Android跨進(jìn)程通信IPC之8——Binder驅(qū)動(dòng)
- 9、Android跨進(jìn)程通信IPC之9——Binder之Framework層C++篇1
- 9、Android跨進(jìn)程通信IPC之9——Binder之Framework層C++篇2
- 10、Android跨進(jìn)程通信IPC之10——Binder之Framework層Java篇
- 11、Android跨進(jìn)程通信IPC之11——AIDL
- 12、Android跨進(jìn)程通信IPC之12——Binder補(bǔ)充
- 13、Android跨進(jìn)程通信IPC之13——Binder總結(jié)
- 14、Android跨進(jìn)程通信IPC之14——其他IPC方式
- 15、Android跨進(jìn)程通信IPC之15——感謝
Framework是一個(gè)中間層，它對(duì)接了底層的實(shí)現(xiàn)，封裝了復(fù)雜的內(nèi)部邏輯，并提供外部使用接口。Framework層是應(yīng)用程序開(kāi)發(fā)的基礎(chǔ)。Binder Framework層為了C++和Java兩個(gè)部分，為了達(dá)到功能的復(fù)用，中間通過(guò)JNI進(jìn)行銜接。Binder Framework的C++部分，頭文件位于這個(gè)路徑：/frameworks/native/include/binder/。實(shí)現(xiàn)位于這個(gè)路徑：/frameworks/native/libs/binder/。binder庫(kù)最終會(huì)編譯成一個(gè)動(dòng)態(tài)鏈接庫(kù)：/libbinder.so，供其他進(jìn)程連接使用。今天按照android Binder的流程來(lái)源碼分析Binder，本篇主要是Framwork層里面C++的內(nèi)容，里面涉及到的驅(qū)動(dòng)層的調(diào)用，請(qǐng)看上一篇文章。我們知道要要想號(hào)獲取相應(yīng)的服務(wù)，服務(wù)必須現(xiàn)在ServiceManager中注冊(cè)，那么問(wèn)題來(lái)了，ServiceMamanger是什么時(shí)候啟動(dòng)的？所以本篇的主要內(nèi)容如下：
- 1、ServiceManager的啟動(dòng)
- 2、ServiceManager的核心服務(wù)
- 3、ServiceManager的獲得
- 4、注冊(cè)服務(wù)
- 5、獲得服務(wù)
一、ServiceManager的啟動(dòng)
(一) ServiceManager啟動(dòng)簡(jiǎn)述
ServiceManager(后邊簡(jiǎn)稱 SM) 是 Binder的守護(hù)進(jìn)程。就像前面說(shuō)的，它本身也是一個(gè)Binder的服務(wù)。是通過(guò)編寫(xiě)binder.c直接和Binder驅(qū)動(dòng)來(lái)通信，里面含量一個(gè)循環(huán)binder_looper來(lái)進(jìn)行讀取和處理事務(wù)。因?yàn)楫吘故鞘謾C(jī)，只有這樣才能達(dá)到簡(jiǎn)單高效。
經(jīng)過(guò)前面幾篇文章，大家也知道SM的工作也很簡(jiǎn)單，就是兩個(gè)：
- 1、注冊(cè)服務(wù)
- 2、查詢
因?yàn)锽inder里面的通信一般都是由BpBinder和BBinder來(lái)實(shí)現(xiàn)的，就像ActivityManagerProxy與ActivityManagerService之間的通信。
(二)源碼的位置
由于Binder中大部分的代碼都是在C層，所以我特意把源碼的地址發(fā)上來(lái)。里面涉及幾個(gè)類，代碼路徑如下：
framework/native/cmds/servicemanager/
- service_manager.c
- binder.c
system/core/rootdir
-/init.rc
kernel/drivers/ (不同Linux分支路徑略有不同)
- android/binder.c
大家如果想看源碼請(qǐng)點(diǎn)擊下面的對(duì)應(yīng)的類即可
kernel下binder.c這個(gè)文件已經(jīng)不在android的源碼里面了，在Linux源碼里面
強(qiáng)調(diào)一下這里面有兩個(gè)binder.c文件，一個(gè)是framework/native/cmds/servicemanager/binder.c，另外一個(gè)是kernel/drivers/android/binder.c ，絕對(duì)不是同一個(gè)東西，千萬(wàn)不要弄混了。
(三) 啟動(dòng)過(guò)程
在前面文章講解Binder驅(qū)動(dòng)的時(shí)候，我們就說(shuō)到了：任何使用Binder機(jī)制的進(jìn)程都必須要對(duì)/dev/binder設(shè)備進(jìn)行open以及mmap之后才能使用，這部分邏輯是所有使用Binder機(jī)制進(jìn)程通用的，SM也不例外。那我們就來(lái)看看
啟動(dòng)流程圖下：
啟動(dòng)整體流程圖.png
ServiceManager是由init進(jìn)程通過(guò)解析init.rc文件而創(chuàng)建的，其所對(duì)應(yīng)的可執(zhí)行程序是/system/bin/servicemanager，所對(duì)應(yīng)的源文件是service_manager.c，進(jìn)程名為/system/bin/servicemanager。
代碼如下：
// init.rc 602行
service servicemanager /system/bin/servicemanager
class core
user system
group system
critical
onrestart restart healthd
onrestart restart zygote
onrestart restart media
onrestart restart surfaceflinger
onrestart restart drm
1、service_manager.c
啟動(dòng)Service Manager的入口函數(shù)是service_manager.c的main()方法如下：
//service_manager.c 347行
int main(int argc, char **argv)
{
struct binder_state *bs;
//打開(kāi)binder驅(qū)動(dòng)，申請(qǐng)128k字節(jié)大小的內(nèi)存空間
bs = binder_open(128*1024);
...
//省略部分代碼
...
//成為上下文管理者
if (binder_become_context_manager(bs)) {
return -1;
}
selinux_enabled = is_selinux_enabled(); //selinux權(quán)限是否使能
sehandle = selinux_android_service_context_handle();
selinux_status_open(true);
if (selinux_enabled > 0) {
if (sehandle == NULL) {
abort(); //無(wú)法獲取sehandle
}
if (getcon(&service_manager_context) != 0) {
abort(); //無(wú)法獲取service_manager上下文
}
}
union selinux_callback cb;
cb.func_audit = audit_callback;
selinux_set_callback(SELINUX_CB_AUDIT, cb);
cb.func_log = selinux_log_callback;
selinux_set_callback(SELINUX_CB_LOG, cb);
//進(jìn)入無(wú)限循環(huán)，充當(dāng)Server角色，處理client端發(fā)來(lái)的請(qǐng)求
binder_loop(bs, svcmgr_handler);
return 0;
}
PS:svcmgr_handler是一個(gè)方向指針，相當(dāng)于binder_loop的每一次循環(huán)調(diào)用到svcmgr_handler()函數(shù)。
這部分代碼 主要分為3塊
- bs = binder_open(128*1024)：打開(kāi)binder驅(qū)動(dòng)，申請(qǐng)128k字節(jié)大小的內(nèi)存空間
- binder_become_context_manager(bs)：變成上下文的管理者
- binder_loop(bs, svcmgr_handler)：進(jìn)入輪詢，處理來(lái)自client端發(fā)來(lái)的請(qǐng)求
下面我們就詳細(xì)的來(lái)看下這三塊的代碼
1.1、 binder_open(128*1024)
這塊代碼在framework/native/cmds/servicemanager/binder.c中
// framework/native/cmds/servicemanager/binder.c 96行
struct binder_state *binder_open(size_t mapsize)
{
struct binder_state *bs;
struct binder_version vers;
bs = malloc(sizeof(*bs));
if (!bs) {
errno = ENOMEM;
return NULL;
}
//通過(guò)系統(tǒng)調(diào)用進(jìn)入內(nèi)核，打開(kāi)Binder的驅(qū)動(dòng)設(shè)備
bs->fd = open("/dev/binder", O_RDWR);
if (bs->fd < 0) {
//無(wú)法打開(kāi)binder設(shè)備
goto fail_open;
}
//通過(guò)系統(tǒng)調(diào)用，ioctl獲取binder版本信息
if ((ioctl(bs->fd, BINDER_VERSION, &vers) == -1) ||
(vers.protocol_version != BINDER_CURRENT_PROTOCOL_VERSION)) {
//如果內(nèi)核空間與用戶空間的binder不是同一版本
goto fail_open;
}
bs->mapsize = mapsize;
//通過(guò)系統(tǒng)調(diào)用，mmap內(nèi)存映射，mmap必須是page的整數(shù)倍
bs->mapped = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, bs->fd, 0);
if (bs->mapped == MAP_FAILED) {
//binder設(shè)備內(nèi)存映射失敗
goto fail_map; // binder
}
return bs;
fail_map:
close(bs->fd);
fail_open:
free(bs);
return NULL;
}
- 1、打開(kāi)binder相關(guān)操作，先調(diào)用open()打開(kāi)binder設(shè)備，open()方法經(jīng)過(guò)系統(tǒng)調(diào)用，進(jìn)入Binder驅(qū)動(dòng)，然后調(diào)用方法binder_open()，該方法會(huì)在Binder驅(qū)動(dòng)層創(chuàng)建一個(gè)binder_proc對(duì)象，再將 binder_proc 對(duì)象賦值給fd->private_data，同時(shí)放入全局鏈表binder_proc。
- 2、再通過(guò)ioctl檢驗(yàn)當(dāng)前binder版本與Binder驅(qū)動(dòng)層的版本是否一致。
- 3、調(diào)用mmap()進(jìn)行內(nèi)存映射，同理mmap()方法經(jīng)過(guò)系統(tǒng)調(diào)用，對(duì)應(yīng)Binder驅(qū)動(dòng)層binde_mmap()方法，該方法會(huì)在Binder驅(qū)動(dòng)層創(chuàng)建Binder_buffer對(duì)象，并放入當(dāng)前binder_proc的** proc->buffers ** 鏈表
PS:這里重點(diǎn)說(shuō)下binder_state
//framework/native/cmds/servicemanager/binder.c 89行
struct binder_state
{
int fd; //dev/binder的文件描述
void *mapped; //指向mmap的內(nèi)存地址
size_t mapsize; //分配內(nèi)存的大小，默認(rèn)是128K
};
至此，整個(gè)binder_open就已經(jīng)結(jié)束了。
1.2、binder_become_context_manager()函數(shù)解析
代碼很簡(jiǎn)單，如下：
//framework/native/cmds/servicemanager/binder.c 146行
int binder_become_context_manager(struct binder_state *bs)
{
//通過(guò)ioctl，傳遞BINDER_SET_CONTEXT_MGR執(zhí)行
return ioctl(bs->fd, BINDER_SET_CONTEXT_MGR, 0);
}
變成上下文的管理者，整個(gè)系統(tǒng)中只有一個(gè)這樣的管理者。通過(guò)ioctl()方法經(jīng)過(guò)系統(tǒng)調(diào)用，對(duì)應(yīng)的是Binder驅(qū)動(dòng)的binder_ioctl()方法。
1.2.1 binder_ioctl解析
Binder驅(qū)動(dòng)在Linux 內(nèi)核中，代碼在kernel中
如下：
//kernel/drivers/android/binder.c 3134行
static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
...
//省略部分代碼
...
switch (cmd) {
...
//省略部分代碼
...
//3279行
case BINDER_SET_CONTEXT_MGR:
ret = binder_ioctl_set_ctx_mgr(filp);
if (ret)
goto err;
break;
}
...
//省略部分代碼
...
}
...
//省略部分代碼
...
}
根據(jù)參數(shù)BINDER_SET_CONTEXT_MGR,最終調(diào)用binder_ioctl_set_ctx_mgr()方法，這個(gè)過(guò)程會(huì)持有binder_main_lock。
1.2.2、binder_ioctl_set_ctx_mgr() 是屬于Linux kernel的部分，代碼
//kernel/drivers/android/binder.c 3198行
static int binder_ioctl_set_ctx_mgr(struct file *filp)
{
int ret = 0;
struct binder_proc *proc = filp->private_data;
struct binder_context *context = proc->context;
kuid_t curr_euid = current_euid();
//保證binder_context_mgr_node對(duì)象只創(chuàng)建一次
if (context->binder_context_mgr_node) {
pr_err("BINDER_SET_CONTEXT_MGR already set\n");
ret = -EBUSY;
goto out;
}
ret = security_binder_set_context_mgr(proc->tsk);
if (ret < 0)
goto out;
if (uid_valid(context->binder_context_mgr_uid)) {
if (!uid_eq(context->binder_context_mgr_uid, curr_euid)) {
pr_err("BINDER_SET_CONTEXT_MGR bad uid %d != %d\n",
from_kuid(&init_user_ns, curr_euid),
from_kuid(&init_user_ns,
context->binder_context_mgr_uid));
ret = -EPERM;
goto out;
}
} else {
//設(shè)置當(dāng)前線程euid作為Service Manager的uid
context->binder_context_mgr_uid = curr_euid;
}
//創(chuàng)建ServiceManager的實(shí)體。
context->binder_context_mgr_node = binder_new_node(proc, 0, 0);
if (!context->binder_context_mgr_node) {
ret = -ENOMEM;
goto out;
}
context->binder_context_mgr_node->local_weak_refs++;
context->binder_context_mgr_node->local_strong_refs++;
context->binder_context_mgr_node->has_strong_ref = 1;
context->binder_context_mgr_node->has_weak_ref = 1;
out:
return ret;
}
進(jìn)入Binder驅(qū)動(dòng)，在Binder驅(qū)動(dòng)中定義的靜態(tài)變量
1.2.3 binder_context 結(jié)構(gòu)體
//kernel/drivers/android/binder.c 228行
struct binder_context {
//service manager所對(duì)應(yīng)的binder_node
struct binder_node *binder_context_mgr_node;
//運(yùn)行service manager的線程uid
kuid_t binder_context_mgr_uid;
const char *name;
};
創(chuàng)建了全局的binder_node對(duì)象binder_context_mgr_node，并將binder_context_mgr_node的強(qiáng)弱引用各加1
這時(shí)候我們?cè)賮?lái)看下binder_new_node()方法里面
1.2.4、binder_new_node()函數(shù)解析
//kernel/drivers/android/binder.c
static struct binder_node *binder_new_node(struct binder_proc *proc,
binder_uintptr_t ptr,
binder_uintptr_t cookie)
{
struct rb_node **p = &proc->nodes.rb_node;
struct rb_node *parent = NULL;
struct binder_node *node;
//第一次進(jìn)來(lái)是空
while (*p) {
parent = *p;
node = rb_entry(parent, struct binder_node, rb_node);
if (ptr < node->ptr)
p = &(*p)->rb_left;
else if (ptr > node->ptr)
p = &(*p)->rb_right;
else
return NULL;
}
//給創(chuàng)建的binder_node 分配內(nèi)存空間
node = kzalloc(sizeof(*node), GFP_KERNEL);
if (node == NULL)
return NULL;
binder_stats_created(BINDER_STAT_NODE);
//將創(chuàng)建的node對(duì)象添加到proc紅黑樹(shù)
rb_link_node(&node->rb_node, parent, p);
rb_insert_color(&node->rb_node, &proc->nodes);
node->debug_id = ++binder_last_id;
node->proc = proc;
node->ptr = ptr;
node->cookie = cookie;
//設(shè)置binder_work的type
node->work.type = BINDER_WORK_NODE;
INIT_LIST_HEAD(&node->work.entry);
INIT_LIST_HEAD(&node->async_todo);
binder_debug(BINDER_DEBUG_INTERNAL_REFS,
"%d:%d node %d u%016llx c%016llx created\n",
proc->pid, current->pid, node->debug_id,
(u64)node->ptr, (u64)node->cookie);
return node;
}
在Binder驅(qū)動(dòng)層創(chuàng)建了binder_node結(jié)構(gòu)體對(duì)象，并將當(dāng)前的binder_pro加入到binder_node的node->proc。并創(chuàng)建binder_node的async_todo和binder_work兩個(gè)隊(duì)列
1.3、binder_loop()詳解
// framework/native/cmds/servicemanager/binder.c 372行
void binder_loop(struct binder_state *bs, binder_handler func) {
int res;
struct binder_write_read bwr;
uint32_t readbuf[ 32];
bwr.write_size = 0;
bwr.write_consumed = 0;
bwr.write_buffer = 0;
readbuf[0] = BC_ENTER_LOOPER;
//將BC_ENTER_LOOPER命令發(fā)送給Binder驅(qū)動(dòng)，讓ServiceManager進(jìn)行循環(huán)
binder_write(bs, readbuf, sizeof(uint32_t));
for (; ; ) {
bwr.read_size = sizeof(readbuf);
bwr.read_consumed = 0;
bwr.read_buffer = (uintptr_t) readbuf;
//進(jìn)入循環(huán)，不斷地binder讀寫(xiě)過(guò)程
res = ioctl(bs -> fd, BINDER_WRITE_READ, & bwr);
if (res < 0) {
ALOGE("binder_loop: ioctl failed (%s)\n", strerror(errno));
break;
}
//解析binder信息
res = binder_parse(bs, 0, (uintptr_t) readbuf, bwr.read_consumed, func);
if (res == 0) {
ALOGE("binder_loop: unexpected reply?!\n");
break;
}
if (res < 0) {
ALOGE("binder_loop: io error %d %s\n", res, strerror(errno));
break;
}
}
}
進(jìn)入循環(huán)讀寫(xiě)操作，由main()方法傳遞過(guò)來(lái)的參數(shù)func指向svcmgr_handler。binder_write通過(guò)ioctl()將BC_ENTER_LOOPER命令發(fā)送給binder驅(qū)動(dòng)，此時(shí)bwr只有write_buffer有數(shù)據(jù)，進(jìn)入binder_thread_write()方法。 接下來(lái)進(jìn)入for循環(huán)，執(zhí)行ioctl()，此時(shí)bwr只有read_buffer有數(shù)據(jù)，那么進(jìn)入binder_thread_read()方法。
主要是循環(huán)讀寫(xiě)操作，這里有3個(gè)重點(diǎn)是
- binder_thread_write結(jié)構(gòu)體
- binder_write函數(shù)
- binder_parse函數(shù)
1.3.1 binder_thread_write
//kernel/drivers/android/binder.c 2248行
static int binder_thread_write(struct binder_proc *proc,
struct binder_thread *thread,
binder_uintptr_t binder_buffer, size_t size,
binder_size_t *consumed)
{
uint32_t cmd;
struct binder_context *context = proc->context;
void __user *buffer = (void __user *)(uintptr_t)binder_buffer;
void __user *ptr = buffer + *consumed;
void __user *end = buffer + size;
while (ptr < end && thread->return_error == BR_OK) {
//獲取命令
get_user(cmd, (uint32_t __user *)ptr);
switch (cmd) {
//**** 省略部分代碼 ****
case BC_ENTER_LOOPER:
//設(shè)置該線程的looper狀態(tài)
thread->looper |= BINDER_LOOPER_STATE_ENTERED;
break;
//**** 省略部分代碼 ****
}
//**** 省略部分代碼 ****
return 0;
}
主要是從bwr.write_buffer中拿出數(shù)據(jù)，此處為BC_ENTER_LOOPER，可見(jiàn)上層調(diào)用binder_write()方法主要是完成當(dāng)前線程的looper狀態(tài)為BINDER_LOOPER_STATE_ENABLE。
1.3.2、 binder_write函數(shù)
這塊的函數(shù)在
// framework/native/cmds/servicemanager/binder.c 151行
int binder_write(struct binder_state *bs, void *data, size_t len) {
struct binder_write_read bwr;
int res;
bwr.write_size = len;
bwr.write_consumed = 0;
//此處data為BC_ENTER_LOOPER
bwr.write_buffer = (uintptr_t) data;
bwr.read_size = 0;
bwr.read_consumed = 0;
bwr.read_buffer = 0;
res = ioctl(bs -> fd, BINDER_WRITE_READ, & bwr);
if (res < 0) {
fprintf(stderr, "binder_write: ioctl failed (%s)\n",
strerror(errno));
}
return res;
}
根據(jù)傳遞進(jìn)來(lái)的參數(shù)，初始化bwr，其中write_size大小為4,write_buffer指向緩沖區(qū)的起始地址，其內(nèi)容為BC_ENTER_LOOPER請(qǐng)求協(xié)議號(hào)。通過(guò)ioctl將bwr數(shù)據(jù)發(fā)送給Binder驅(qū)動(dòng)，則調(diào)用binder_ioctl函數(shù)
1.3.3讓我們來(lái)看下binder_ioctl函數(shù)
//kernel/drivers/android/binder.c 3239行
static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
//**** 省略部分代碼 ****
//獲取binder_thread
thread = binder_get_thread(proc);
switch (cmd) {
case BINDER_WRITE_READ:
//進(jìn)行binder的讀寫(xiě)操作
ret = binder_ioctl_write_read(filp, cmd, arg, thread);
if (ret)
goto err;
break;
//**** 省略部分代碼 ****
}
}
主要就是根據(jù)參數(shù) BINDER_SET_CONTEXT_MGR，最終調(diào)用binder_ioctl_set_ctx_mgr()方法，這個(gè)過(guò)程會(huì)持有binder_main_lock。
binder_ioctl_write_read()函數(shù)解析
//kernel/drivers/android/binder.c 3134
static int binder_ioctl_write_read(struct file *filp,
unsigned int cmd, unsigned long arg,
struct binder_thread *thread)
{
int ret = 0;
struct binder_proc *proc = filp->private_data;
unsigned int size = _IOC_SIZE(cmd);
void __user *ubuf = (void __user *)arg;
struct binder_write_read bwr;
if (size != sizeof(struct binder_write_read)) {
ret = -EINVAL;
goto out;
}
//把用戶空間數(shù)據(jù)ubuf拷貝到bwr中
if (copy_from_user(&bwr, ubuf, sizeof(bwr))) {
ret = -EFAULT;
goto out;
}
binder_debug(BINDER_DEBUG_READ_WRITE,
"%d:%d write %lld at %016llx, read %lld at %016llx\n",
proc->pid, thread->pid,
(u64)bwr.write_size, (u64)bwr.write_buffer,
(u64)bwr.read_size, (u64)bwr.read_buffer);
// “寫(xiě)緩存” 有數(shù)據(jù)
if (bwr.write_size > 0) {
ret = binder_thread_write(proc, thread,
bwr.write_buffer,
bwr.write_size,
&bwr.write_consumed);
trace_binder_write_done(ret);
if (ret < 0) {
bwr.read_consumed = 0;
if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
ret = -EFAULT;
goto out;
}
}
// "讀緩存" 有數(shù)據(jù)
if (bwr.read_size > 0) {
ret = binder_thread_read(proc, thread, bwr.read_buffer,
bwr.read_size,
&bwr.read_consumed,
filp->f_flags & O_NONBLOCK);
trace_binder_read_done(ret);
if (!list_empty(&proc->todo))
wake_up_interruptible(&proc->wait);
if (ret < 0) {
if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
ret = -EFAULT;
goto out;
}
}
binder_debug(BINDER_DEBUG_READ_WRITE,
"%d:%d wrote %lld of %lld, read return %lld of %lld\n",
proc->pid, thread->pid,
(u64)bwr.write_consumed, (u64)bwr.write_size,
(u64)bwr.read_consumed, (u64)bwr.read_size);
//將內(nèi)核數(shù)據(jù)bwr拷貝到用戶控件bufd
if (copy_to_user(ubuf, &bwr, sizeof(bwr))) {
ret = -EFAULT;
goto out;
}
out:
return ret;
}
此處代碼就一個(gè)作用：就是講用戶空間的binder_write_read結(jié)構(gòu)體 拷貝到內(nèi)核空間。
1.3.3、 binder_parse函數(shù)解析
binder_parse在// framework/native/cmds/servicemanager/binder.c中
// framework/native/cmds/servicemanager/binder.c 204行
int binder_parse(struct binder_state *bs, struct binder_io *bio,
uintptr_t ptr, size_t size, binder_handler func) {
int r = 1;
uintptr_t end = ptr + (uintptr_t) size;
while (ptr < end) {
uint32_t cmd = *(uint32_t *) ptr;
ptr += sizeof(uint32_t);
#if TRACE
fprintf(stderr, "%s:\n", cmd_name(cmd));
#endif
switch (cmd) {
case BR_NOOP:
//誤操作，退出循環(huán)
break;
case BR_TRANSACTION_COMPLETE:
break;
case BR_INCREFS:
case BR_ACQUIRE:
case BR_RELEASE:
case BR_DECREFS:
#if TRACE
fprintf(stderr, " %p, %p\n", (void *)ptr, (void *)(ptr + sizeof(void *)));
#endif
ptr += sizeof(struct binder_ptr_cookie);
break;
case BR_TRANSACTION: {
struct binder_transaction_data *txn = (struct binder_transaction_data *)ptr;
if ((end - ptr) < sizeof( * txn)){
ALOGE("parse: txn too small!\n");
return -1;
}
binder_dump_txn(txn);
if (func) {
unsigned rdata[ 256 / 4];
struct binder_io msg;
struct binder_io reply;
int res;
bio_init( & reply, rdata, sizeof(rdata), 4);
bio_init_from_txn( & msg, txn);
res = func(bs, txn, & msg, &reply);
binder_send_reply(bs, & reply, txn -> data.ptr.buffer, res);
}
ptr += sizeof( * txn);
break;
}
case BR_REPLY: {
struct binder_transaction_data *txn = (struct binder_transaction_data *)ptr;
if ((end - ptr) < sizeof( * txn)){
ALOGE("parse: reply too small!\n");
return -1;
}
binder_dump_txn(txn);
if (bio) {
bio_init_from_txn(bio, txn);
bio = 0;
} else {
/* todo FREE BUFFER */
}
ptr += sizeof( * txn);
r = 0;
break;
}
case BR_DEAD_BINDER: {
struct binder_death *death = (struct binder_death *)
(uintptr_t) * (binder_uintptr_t *) ptr;
ptr += sizeof(binder_uintptr_t);
//binder死亡消息
death -> func(bs, death -> ptr);
break;
}
case BR_FAILED_REPLY:
r = -1;
break;
case BR_DEAD_REPLY:
r = -1;
break;
default:
ALOGE("parse: OOPS %d\n", cmd);
return -1;
}
}
return r;
}
主要是解析binder消息，此處參數(shù)ptr指向BC_ENTER_LOOPER，func指向svcmgr_handler，所以有請(qǐng)求來(lái)，則調(diào)用svcmgr
這里面我們重點(diǎn)分析BR_TRANSACTION里面的幾個(gè)函數(shù)
- bio_init()函數(shù)
- bio_init_from_txn()函數(shù)
1.3.3.1 bio_init()函數(shù)
// framework/native/cmds/servicemanager/binder.c 409行
void bio_init_from_txn(struct binder_io *bio, struct binder_transaction_data *txn)
{
bio->data = bio->data0 = (char *)(intptr_t)txn->data.ptr.buffer;
bio->offs = bio->offs0 = (binder_size_t *)(intptr_t)txn->data.ptr.offsets;
bio->data_avail = txn->data_size;
bio->offs_avail = txn->offsets_size / sizeof(size_t);
bio->flags = BIO_F_SHARED;
}
其中binder_io的結(jié)構(gòu)體在 /frameworks/native/cmds/servicemanager/binder.h 里面
binder.h
//frameworks/native/cmds/servicemanager/binder.h 12行
struct binder_io
{
char *data; /* pointer to read/write from */
binder_size_t *offs; /* array of offsets */
size_t data_avail; /* bytes available in data buffer */
size_t offs_avail; /* entries available in offsets array */
char *data0; //data buffer起點(diǎn)位置
binder_size_t *offs0; //buffer偏移量的起點(diǎn)位置
uint32_t flags;
uint32_t unused;
};
1.3.3.2 bio_init_from_txn()函數(shù)
// framework/native/cmds/servicemanager/binder.c 409行
void bio_init_from_txn(struct binder_io *bio, struct binder_transaction_data *txn)
{
bio->data = bio->data0 = (char *)(intptr_t)txn->data.ptr.buffer;
bio->offs = bio->offs0 = (binder_size_t *)(intptr_t)txn->data.ptr.offsets;
bio->data_avail = txn->data_size;
bio->offs_avail = txn->offsets_size / sizeof(size_t);
bio->flags = BIO_F_SHARED;
}
其實(shí)很簡(jiǎn)單，就是將readbuf的數(shù)據(jù)賦給bio對(duì)象的data
將readbuf的數(shù)據(jù)賦給bio對(duì)象的data
####### 1.3.4 svcmgr_handler
//service_manager.c 244行
int svcmgr_handler(struct binder_state*bs,
struct binder_transaction_data*txn,
struct binder_io*msg,
struct binder_io*reply) {
struct svcinfo*si;
uint16_t * s;
size_t len;
uint32_t handle;
uint32_t strict_policy;
int allow_isolated;
if (txn -> target.ptr != BINDER_SERVICE_MANAGER)
return -1;
if (txn -> code == PING_TRANSACTION)
return 0;
strict_policy = bio_get_uint32(msg);
s = bio_get_string16(msg, & len);
if (s == NULL) {
return -1;
}
if ((len != (sizeof(svcmgr_id) / 2)) ||
memcmp(svcmgr_id, s, sizeof(svcmgr_id))) {
fprintf(stderr, "invalid id %s\n", str8(s, len));
return -1;
}
if (sehandle && selinux_status_updated() > 0) {
struct selabel_handle*tmp_sehandle = selinux_android_service_context_handle();
if (tmp_sehandle) {
selabel_close(sehandle);
sehandle = tmp_sehandle;
}
}
switch (txn -> code) {
case SVC_MGR_GET_SERVICE:
case SVC_MGR_CHECK_SERVICE:
//獲取服務(wù)名
s = bio_get_string16(msg, & len);
if (s == NULL) {
return -1;
}
//根據(jù)名稱查找相應(yīng)服務(wù)
handle = do_find_service(bs, s, len, txn -> sender_euid, txn -> sender_pid);
if (!handle)
break;
bio_put_ref(reply, handle);
return 0;
case SVC_MGR_ADD_SERVICE:
//獲取服務(wù)名
s = bio_get_string16(msg, & len);
if (s == NULL) {
return -1;
}
handle = bio_get_ref(msg);
allow_isolated = bio_get_uint32(msg) ? 1 : 0;
//注冊(cè)服務(wù)
if (do_add_service(bs, s, len, handle, txn -> sender_euid,
allow_isolated, txn -> sender_pid))
return -1;
break;
case SVC_MGR_LIST_SERVICES: {
uint32_t n = bio_get_uint32(msg);
if (!svc_can_list(txn -> sender_pid)) {
ALOGE("list_service() uid=%d - PERMISSION DENIED\n",
txn -> sender_euid);
return -1;
}
si = svclist;
while ((n-- > 0) && si)
si = si -> next;
if (si) {
bio_put_string16(reply, si -> name);
return 0;
}
return -1;
}
default:
ALOGE("unknown code %d\n", txn -> code);
return -1;
}
bio_put_uint32(reply, 0);
return 0;
}
代碼看著很多，其實(shí)主要就是servicemanger提供查詢服務(wù)和注冊(cè)服務(wù)以及列舉所有服務(wù)。
這里提一下svcinfo
//service_manager.c 128行
struct svcinfo
{
struct svcinfo*next;
uint32_t handle;
struct binder_death death;
int allow_isolated;
size_t len;
uint16_t name[ 0];
};
每一個(gè)服務(wù)用svcinfo結(jié)構(gòu)體來(lái)表示，該handle值是注冊(cè)服務(wù)的過(guò)程中，又服務(wù)所在進(jìn)程那一端所確定。
1.3.4 總結(jié)
ServiceManager集中管理系統(tǒng)內(nèi)的所有服務(wù)，通過(guò)權(quán)限控制進(jìn)程是否有權(quán)注冊(cè)服務(wù)，通過(guò)字符串名稱來(lái)查找對(duì)應(yīng)的Service；由于ServiceManager進(jìn)程建立跟所有向其注冊(cè)服務(wù)的死亡通知，那么當(dāng)前服務(wù)所在進(jìn)程死亡后，會(huì)只需要告知ServiceManager。每個(gè)Client通過(guò)查詢ServiceManager可獲取Service進(jìn)程的情況，降低所有Client進(jìn)程直接檢測(cè)導(dǎo)致負(fù)載過(guò)重。
讓我們?cè)俅慰催@張圖
啟動(dòng)整體流程圖.png
ServiceManager 啟動(dòng)流程：
- 打開(kāi)binder驅(qū)動(dòng)，并調(diào)用mmap()方法分配128k內(nèi)存映射空間：binder_open()
- 通知binder驅(qū)動(dòng)使其成為守護(hù)進(jìn)程：binder_become_context_manager()；
- 驗(yàn)證selinux權(quán)限，判斷進(jìn)程是否有權(quán)注冊(cè)或查看指定服務(wù);
- 進(jìn)入循環(huán)狀態(tài)，等待Client端的請(qǐng)求
- 注冊(cè)服務(wù)的過(guò)程，根據(jù)服務(wù)的名稱，但同一個(gè)服務(wù)已注冊(cè)，然后調(diào)用binder_node_release。這個(gè)過(guò)程便會(huì)發(fā)出死亡通知的回調(diào)。
二、ServiceManager的核心服務(wù)
通過(guò)上面的代碼我們知道service manager的核心服務(wù)主要有4個(gè)
- do_add_service()函數(shù)：注冊(cè)服務(wù)
- do_find_service()函數(shù)：查找服務(wù)
- binder_link_to_death()函數(shù)：結(jié)束服務(wù)
- binder_send_reply()函數(shù)：將注冊(cè)結(jié)果返回給Binder驅(qū)動(dòng)
下面我們就挨個(gè)講解一下
(一)、do_add_service()函數(shù)
//service_manager.c 194行
int do_add_service(struct binder_state *bs,
const uint16_t *s, size_t len,
uint32_t handle, uid_t uid, int allow_isolated,
pid_t spid)
{
struct svcinfo *si;
if (!handle || (len == 0) || (len > 127))
return -1;
//權(quán)限檢查
if (!svc_can_register(s, len, spid)) {
return -1;
}
//服務(wù)檢索
si = find_svc(s, len);
if (si) {
if (si->handle) {
svcinfo_death(bs, si); //服務(wù)已注冊(cè)時(shí)，釋放相應(yīng)的服務(wù)
}
si->handle = handle;
} else {
si = malloc(sizeof(*si) + (len + 1) * sizeof(uint16_t));
if (!si) {
//內(nèi)存不足，無(wú)法分配足夠內(nèi)存
return -1;
}
si->handle = handle;
si->len = len;
//內(nèi)存拷貝服務(wù)信息
memcpy(si->name, s, (len + 1) * sizeof(uint16_t));
si->name[len] = '\0';
si->death.func = (void*) svcinfo_death;
si->death.ptr = si;
si->allow_isolated = allow_isolated;
// svclist保存所有已注冊(cè)的服務(wù)
si->next = svclist;
svclist = si;
}
//以BC_ACQUIRE命令，handle為目標(biāo)的信息，通過(guò)ioctl發(fā)送給binder驅(qū)動(dòng)
binder_acquire(bs, handle);
//以BC_REQUEST_DEATH_NOTIFICATION命令的信息，通過(guò)ioctl發(fā)送給binder驅(qū)動(dòng)，主要用于清理內(nèi)存等收尾工作。
binder_link_to_death(bs, handle, &si->death);
return 0;
}
注冊(cè)服務(wù)部分主要分塊內(nèi)容：
- svc_can_register：檢查權(quán)限：檢查selinux權(quán)限是否滿足
- find_svc：服務(wù)檢索，根據(jù)服務(wù)名來(lái)查詢匹配的服務(wù)；
- svcinfo_death：釋放服務(wù)，當(dāng)查詢到已存在的同名的服務(wù)，則先清理該服務(wù)信息，再講當(dāng)前的服務(wù)加入到服務(wù)列表svclist;
svc_can_register：檢查權(quán)限，檢查selinux權(quán)限是否滿足；
find_svc：服務(wù)檢索，根據(jù)服務(wù)名來(lái)查詢匹配的服務(wù)；
svcinfo_death：釋放服務(wù)，當(dāng)查詢到已存在同名的服務(wù)，則先清理該服務(wù)信息，再將當(dāng)前的服務(wù)加入到服務(wù)列表svclist；
1、svc_can_register()函數(shù)
//service_manager.c 110行
static int svc_can_register(const uint16_t *name, size_t name_len, pid_t spid)
{
const char *perm = "add";
//檢查selinux權(quán)限是否滿足
return check_mac_perms_from_lookup(spid, perm, str8(name, name_len)) ? 1 : 0;
}
2、svcinfo_death()函數(shù)
//service_manager.c 153行
void svcinfo_death(struct binder_state *bs, void *ptr)
{
struct svcinfo *si = (struct svcinfo* ) ptr;
if (si->handle) {
binder_release(bs, si->handle);
si->handle = 0;
}
}
3、bio_get_ref()函數(shù)
// framework/native/cmds/servicemanager/binder.c 627行
uint32_t bio_get_ref(struct binder_io *bio)
{
struct flat_binder_object *obj;
obj = _bio_get_obj(bio);
if (!obj)
return 0;
if (obj->type == BINDER_TYPE_HANDLE)
return obj->handle;
return 0;
}
(二)、do_find_service()
//service_manager.c 170行
uint32_t do_find_service(struct binder_state *bs, const uint16_t *s, size_t len, uid_t uid, pid_t spid)
{
//具體查詢相應(yīng)的服務(wù)
struct svcinfo *si = find_svc(s, len);
if (!si || !si->handle) {
return 0;
}
if (!si->allow_isolated) {
uid_t appid = uid % AID_USER;
//檢查該服務(wù)是否允許孤立于進(jìn)程而單獨(dú)存在
if (appid >= AID_ISOLATED_START && appid <= AID_ISOLATED_END) {
return 0;
}
}
//服務(wù)是否滿足于查詢條件
if (!svc_can_find(s, len, spid)) {
return 0;
}
/返回結(jié)點(diǎn)中的ptr，這個(gè)ptr是binder中對(duì)應(yīng)的binder_ref.des
return si->handle;
}
主要就是查詢目標(biāo)服務(wù)，并返回該服務(wù)所對(duì)應(yīng)的handle
1、find_svc()函數(shù)
//service_manager.c 140行
struct svcinfo *find_svc(const uint16_t *s16, size_t len)
{
struct svcinfo *si;
for (si = svclist; si; si = si->next) {
//當(dāng)名字完全一致，則返回查詢到的結(jié)果
if ((len == si->len) &&
!memcmp(s16, si->name, len * sizeof(uint16_t))) {
return si;
}
}
return NULL;
}
在svclist服務(wù)列表中，根據(jù)服務(wù)名遍歷查找是否已經(jīng)注冊(cè)。當(dāng)服務(wù)已經(jīng)存在svclist，則返回相應(yīng)的服務(wù)名，否則返回null。
當(dāng)找到服務(wù)的handle，則調(diào)用bio_put_ref(reply,handle)，將handle封裝到reply。
在svcmgr_handler中當(dāng)執(zhí)行完do_find_service()函數(shù)后，會(huì)調(diào)用bio_put_ref()函數(shù)，讓我們來(lái)一起研究下這個(gè)函數(shù)
2、bio_put_ref()函數(shù)
// framework/native/cmds/servicemanager/binder.c 505行
void bio_put_ref(struct binder_io *bio, uint32_t handle)
{
//構(gòu)造了一個(gè)flat_binder_object
struct flat_binder_object *obj;
if (handle)
obj = bio_alloc_obj(bio);
else
obj = bio_alloc(bio, sizeof(*obj));
if (!obj)
return;
obj->flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
obj->type = BINDER_TYPE_HANDLE; //返回的是HANDLE類型
//以service manager的身份回應(yīng)給kernel driver，ptr就是handler對(duì)應(yīng)的ref索引值 1，2，3，4，5，6等
obj->handle = handle;
obj->cookie = 0;
}
這個(gè)段代碼也不復(fù)雜，就是根據(jù)handle來(lái)判斷分別執(zhí)行bio_alloc_obj()函數(shù)和bio_alloc()函數(shù)
那我們就來(lái)好好研究和兩個(gè)函數(shù)
3、bio_alloc_obj()函數(shù)
// framework/native/cmds/servicemanager/binder.c 468 行
static struct flat_binder_object *bio_alloc_obj(struct binder_io *bio)
{
struct flat_binder_object *obj;
obj = bio_alloc(bio, sizeof(*obj));//[見(jiàn)小節(jié)3.1.4]
if (obj && bio->offs_avail) {
bio->offs_avail--;
*bio->offs++ = ((char*) obj) - ((char*) bio->data0);
return obj;
}
bio->flags |= BIO_F_OVERFLOW;
return NULL;
}
4、bio_alloc()函數(shù)
// framework/native/cmds/servicemanager/binder.c 437 行
static void *bio_alloc(struct binder_io *bio, size_t size)
{
size = (size + 3) & (~3);
if (size > bio->data_avail) {
bio->flags |= BIO_F_OVERFLOW;
return NULL;
} else {
void *ptr = bio->data;
bio->data += size;
bio->data_avail -= size;
return ptr;
}
}
(三) 、 binder_link_to_death() 函數(shù)
// framework/native/cmds/servicemanager/binder.c 305行
void binder_link_to_death(struct binder_state *bs, uint32_t target, struct binder_death *death)
{
struct {
uint32_t cmd;
struct binder_handle_cookie payload;
} __attribute__((packed)) data;
data.cmd = BC_REQUEST_DEATH_NOTIFICATION;
data.payload.handle = target;
data.payload.cookie = (uintptr_t) death;
binder_write(bs, &data, sizeof(data)); //[見(jiàn)小節(jié)3.3.1]
}
binder_write和前面的binder_write一樣，進(jìn)入Binder driver后，直接調(diào)用binder_thread_write，處理BC_REQUEST_DEATH_NOTIFICATION命令。其中binder_ioctl_write_read()函數(shù)，上面已經(jīng)講解過(guò)了。這里就不詳細(xì)講解了
1、 binder_thread_write() 函數(shù)
//kernel/drivers/android/binder.c 2248行
static int binder_thread_write(struct binder_proc *proc,
struct binder_thread *thread,
binder_uintptr_t binder_buffer, size_t size,
binder_size_t *consumed)
{
uint32_t cmd;
struct binder_context *context = proc->context;
void __user *buffer = (void __user *)(uintptr_t)binder_buffer;
void __user *ptr = buffer + *consumed;
void __user *end = buffer + size;
while (ptr < end && thread->return_error == BR_OK) {
//獲取命令
get_user(cmd, (uint32_t __user *)ptr);
switch (cmd) {
//**** 省略部分代碼 ****
// 注冊(cè)死亡通知
case BC_REQUEST_DEATH_NOTIFICATION:
case BC_CLEAR_DEATH_NOTIFICATION: {
uint32_t target;
void __user *cookie;
struct binder_ref *ref;
struct binder_ref_death *death;
//獲取taget
get_user(target, (uint32_t __user *)ptr);
ptr += sizeof(uint32_t);
/獲取death
get_user(cookie, (void __user * __user *)ptr); /
ptr += sizeof(void *);
//拿到目標(biāo)服務(wù)的binder_ref
ref = binder_get_ref(proc, target);
if (cmd == BC_REQUEST_DEATH_NOTIFICATION) {
//已設(shè)死亡通知
if (ref->death) {
break;
}
death = kzalloc(sizeof(*death), GFP_KERNEL);
INIT_LIST_HEAD(&death->work.entry);
death->cookie = cookie;
ref->death = death;
//當(dāng)目標(biāo)服務(wù)所在進(jìn)程已死，則發(fā)送死亡通知
if (ref->node->proc == NULL) {
//當(dāng)前線程為binder線程，則直接添加到當(dāng)前線程的TODO隊(duì)列
ref->death->work.type = BINDER_WORK_DEAD_BINDER;
if (thread->looper & (BINDER_LOOPER_STATE_REGISTERED | BINDER_LOOPER_STATE_ENTERED)) {
list_add_tail(&ref->death->work.entry, &thread->todo);
} else {
list_add_tail(&ref->death->work.entry, &proc->todo);
wake_up_interruptible(&proc->wait);
}
}
} else {
...
}
} break;
//**** 省略部分代碼 ****
}
//**** 省略部分代碼 ****
return 0;
}
此方法中的proc，thread都是指當(dāng)前的servicemanager進(jìn)程信息，此時(shí)TODO隊(duì)列有數(shù)據(jù)，則進(jìn)入binder_thread_read。
那么問(wèn)題來(lái)了，哪些場(chǎng)景會(huì)向隊(duì)列增加BINDER_WORK_READ_BINDER事物？那邊是當(dāng)binder所在進(jìn)程死亡后，會(huì)調(diào)用binder_realse方法，然后調(diào)用binder_node_release這個(gè)過(guò)程便會(huì)發(fā)出死亡通知的回調(diào)。
2、binder_thread_read() 函數(shù)
static int binder_thread_read(struct binder_proc *proc,
struct binder_thread *thread,
binder_uintptr_t binder_buffer, size_t size,
binder_size_t *consumed, int non_block)
...
//只有當(dāng)前線程todo隊(duì)列為空，并且transaction_stack也為空，才會(huì)開(kāi)始處于當(dāng)前進(jìn)程的事務(wù)
if (wait_for_proc_work) {
...
ret = wait_event_freezable_exclusive(proc->wait, binder_has_proc_work(proc, thread));
} else {
...
ret = wait_event_freezable(thread->wait, binder_has_thread_work(thread));
}
//加鎖
binder_lock(__func__);
if (wait_for_proc_work)
//空閑的binder線程減1
proc->ready_threads--;
thread->looper &= ~BINDER_LOOPER_STATE_WAITING;
while (1) {
uint32_t cmd;
struct binder_transaction_data tr;
struct binder_work *w;
struct binder_transaction *t = NULL;
//從todo隊(duì)列拿出前面放入的binder_work, 此時(shí)type為BINDER_WORK_DEAD_BINDER
if (!list_empty(&thread->todo)) {
w = list_first_entry(&thread->todo, struct binder_work,
entry);
} else if (!list_empty(&proc->todo) && wait_for_proc_work) {
w = list_first_entry(&proc->todo, struct binder_work,
entry);
}
switch (w->type) {
case BINDER_WORK_DEAD_BINDER: {
struct binder_ref_death *death;
uint32_t cmd;
death = container_of(w, struct binder_ref_death, work);
if (w->type == BINDER_WORK_CLEAR_DEATH_NOTIFICATION)
...
else
//進(jìn)入此分支
cmd = BR_DEAD_BINDER;
//拷貝用戶空間
put_user(cmd, (uint32_t __user *)ptr);
ptr += sizeof(uint32_t);
//此處的cookie是前面?zhèn)鬟f的svcinfo_death
put_user(death->cookie, (binder_uintptr_t __user *)ptr);
ptr += sizeof(binder_uintptr_t);
if (w->type == BINDER_WORK_CLEAR_DEATH_NOTIFICATION) {
...
} else
list_move(&w->entry, &proc->delivered_death);
if (cmd == BR_DEAD_BINDER)
goto done;
} break;
}
}
...
return 0;
}
將命令BR_DEAD_BINDER寫(xiě)到用戶空間，此處的cookie是前面?zhèn)鬟f的svcinfo_death。當(dāng)binder_loop下一次執(zhí)行binder_parse的過(guò)程便會(huì)處理該消息。 binder_parse()函數(shù)和svcinfo_death()函數(shù)上面已經(jīng)說(shuō)明了，這里就不詳細(xì)說(shuō)明了。
3、 binder_release() 函數(shù)
//frameworks/native/cmds/servicemanager/binder.c 297行
void binder_release(struct binder_state *bs, uint32_t target)
{
uint32_t cmd[2];
cmd[0] = BC_RELEASE;
cmd[1] = target;
binder_write(bs, cmd, sizeof(cmd));
}
向Binder Driver寫(xiě)入BC_RELEASE命令，最終進(jìn)入Binder Driver后執(zhí)行binder_dec_ref(ref，1) 來(lái)減少binder node的引用。
(四)、 binder_send_reply() 函數(shù)
//frameworks/native/cmds/servicemanager/binder.c 170行
void binder_send_reply(struct binder_state *bs,
struct binder_io *reply,
binder_uintptr_t buffer_to_free,
int status) {
struct {
uint32_t cmd_free;
binder_uintptr_t buffer;
uint32_t cmd_reply;
struct binder_transaction_data txn;
} __attribute__((packed)) data;
//free buffer命令
data.cmd_free = BC_FREE_BUFFER;
data.buffer = buffer_to_free;
//replay命令
data.cmd_reply = BC_REPLY;
data.txn.target.ptr = 0;
data.txn.cookie = 0;
data.txn.code = 0;
if (status) {
data.txn.flags = TF_STATUS_CODE;
data.txn.data_size = sizeof(int);
data.txn.offsets_size = 0;
data.txn.data.ptr.buffer = (uintptr_t) & status;
data.txn.data.ptr.offsets = 0;
} else {
data.txn.flags = 0;
data.txn.data_size = reply -> data - reply -> data0;
data.txn.offsets_size = ((char*)reply -> offs)-((char*)reply -> offs0);
data.txn.data.ptr.buffer = (uintptr_t) reply -> data0;
data.txn.data.ptr.offsets = (uintptr_t) reply -> offs0;
}
//向Binder驅(qū)動(dòng)通信
binder_write(bs, & data, sizeof(data));
}
執(zhí)行binder_parse方法，先調(diào)用svcmgr_handler()函數(shù)，然后再執(zhí)行binder_send_reply過(guò)程，該過(guò)程會(huì)調(diào)用binder_write進(jìn)入binder驅(qū)動(dòng)后，將BC_FREE_BUFFER和BC_REPLY命令協(xié)議發(fā)送給Binder驅(qū)動(dòng)，向Client端發(fā)送reply，其中data數(shù)據(jù)區(qū)中保存的是TYPE為HANDLE。
現(xiàn)在我們對(duì)ServiceManager有個(gè)初步的了解，那么我們?cè)趺床拍艿玫絊erviceManager那？下面就讓我們來(lái)看下如何獲得ServiceManager。
三、ServiceManager的獲得
(一)、源碼信息
代碼位于
framework/native/libs/binder/
- ProcessState.cpp
- BpBinder.cpp
- Binder.cpp
- IServiceManager.cpp
framework/native/include/binder/
- IServiceManager.h
- IInterface.h
鏈接為
這里重點(diǎn)提醒下framework/native/libs/binder/IServiceManager.cpp和 framework/native/include/binder/IServiceManager.h大家千萬(wàn)不要弄混了。
(二)、獲取Service Manager簡(jiǎn)述
獲取Service Manager是通過(guò)defaultServiceManager()方法來(lái)完成的。當(dāng)進(jìn)程 注冊(cè)服務(wù) 與 獲取服務(wù)之前，都需要調(diào)用defaultServiceManager()方法來(lái)獲取gDefaultServiceManager對(duì)象。對(duì)于gDefaultServiceManager對(duì)象，如果存在直接返回。如果不存在直接創(chuàng)建該對(duì)象，創(chuàng)建過(guò)程包括調(diào)用open()打開(kāi)binder驅(qū)動(dòng)設(shè)備，利用mmap()映射內(nèi)核的地址空間。
(三)、流程圖
獲取ServiceManager流程圖.png
(四)、獲取defaultServiceManager
代碼如下
//frameworks/native/libs/binder/IServiceManager.cpp 33行
sp<IServiceManager> defaultServiceManager()
{
if (gDefaultServiceManager != NULL) return gDefaultServiceManager;
{
//加鎖
AutoMutex _l(gDefaultServiceManagerLock);
while (gDefaultServiceManager == NULL) {
gDefaultServiceManager = interface_cast<IServiceManager>(
//這里才是關(guān)鍵和重點(diǎn)
ProcessState::self()->getContextObject(NULL));
if (gDefaultServiceManager == NULL)
sleep(1);
}
}
return gDefaultServiceManager;
}
獲取ServiceManager 對(duì)象采用單例模式，當(dāng)gDefaultServiceManager存在，則直接返回，否則創(chuàng)建一個(gè)新對(duì)象。這里的創(chuàng)建單利模式和咱們之前的java里面的單例不一樣。它里面多了一層while循環(huán)，這是谷歌在2013年1月Todd Poynor提交的修改。因?yàn)楫?dāng)?shù)谝淮螄L試創(chuàng)建獲取ServiceManager時(shí)，ServiceManager可能還未準(zhǔn)備就緒，所以通過(guò)sleep1秒，實(shí)現(xiàn)延遲1秒，然后嘗試去獲取直到成功。
而gDefualtServiceManager的創(chuàng)建過(guò)程又可以分解為3個(gè)步驟
- ProcessState：：self() ：用于獲取ProcessState對(duì)象(也是單例模式)，每個(gè)進(jìn)程有且只有一個(gè)ProcessState對(duì)象，存在則直接返回，不存在則創(chuàng)建。
- getContextObject()： 用于獲取BpBinder對(duì)象，對(duì)于hanle=0的BpBinder對(duì)象，存在則直接返回，不存在則創(chuàng)建。
- interface_cast<IServiceManager>()：用于獲取BpServiceManager對(duì)象。
所以下面的 (五)(六)(七) 依次講解ProcessState、BpBinder對(duì)象和BpServiceManager對(duì)象
(五)、獲取ProcessState對(duì)象
1、ProcessState::self
我們先來(lái)看下這塊代碼
//frameworks/native/libs/binder/ProcessState.cpp 70行
// 這又是一個(gè)進(jìn)程單體
sp<ProcessState> ProcessState::self()
{
Mutex::Autolock _l(gProcessMutex);
if (gProcess != NULL) {
return gProcess;
}
//實(shí)例化 ProcessState，首次創(chuàng)建
gProcess = new ProcessState;
return gProcess;
}
獲取ProcessState對(duì)象：這也是一個(gè)單利模式，從而保證每一個(gè)進(jìn)程只有一個(gè)ProcessState對(duì)象，其中g(shù)Proccess和gProccessMutex是保持在Static.cpp的類全局變量。
那我們來(lái)一起看下ProccessState的構(gòu)造函數(shù)
2、ProccessState的構(gòu)造函數(shù)
//frameworks/native/libs/binder/ProcessState.cpp 339行
ProcessState::ProcessState()
//這里打開(kāi)了打開(kāi)了Binder驅(qū)動(dòng)，也就是/dev/binder文件，返回文件描述符
: mDriverFD(open_driver())
, mVMStart(MAP_FAILED)
, mThreadCountLock(PTHREAD_MUTEX_INITIALIZER)
, mThreadCountDecrement(PTHREAD_COND_INITIALIZER)
, mExecutingThreadsCount(0)
, mMaxThreads(DEFAULT_MAX_BINDER_THREADS)
, mManagesContexts(false)
, mBinderContextCheckFunc(NULL)
, mBinderContextUserData(NULL)
, mThreadPoolStarted(false)
, mThreadPoolSeq(1)
{
if (mDriverFD >= 0) {
//采用內(nèi)存映射函數(shù)mmap，給binder分配一塊虛擬地址空間，涌來(lái)了接收事物
mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);
if (mVMStart == MAP_FAILED) {
//沒(méi)有足夠空間分配給/dev/binder，則關(guān)閉驅(qū)動(dòng)。
close(mDriverFD);
mDriverFD = -1;
}
}
}
通過(guò)上面的構(gòu)造函數(shù)我們知道
- ProcessState的單利模式的唯一性，因此一個(gè)進(jìn)程只打開(kāi)binder設(shè)備一次，其中ProcessState的成員變量mDriverFD記錄binder驅(qū)動(dòng)的fd，用于訪問(wèn)binder設(shè)備。
- BINDER_VM_SIZE=(110241024- (40962))，所以binder分配的默認(rèn)內(nèi)存大小是10241016也就是1M-8K(1M減去8k)
- DEFAULT_MAX_BINDER_THREAD=15，binder默認(rèn)的最大可并發(fā)的線程數(shù)為16。
這里面調(diào)用了open_driver()方法，那么讓我們研究下這個(gè)方法
3、open_driver()方法
//frameworks/native/libs/binder/ProcessState.cpp 311行
static int open_driver()
{
// 打開(kāi)/dev/binder設(shè)備，建立與內(nèi)核的Binder驅(qū)動(dòng)的交互通道
int fd = open("/dev/binder", O_RDWR);
if (fd >= 0) {
fcntl(fd, F_SETFD, FD_CLOEXEC);
int vers = 0;
status_t result = ioctl(fd, BINDER_VERSION, &vers);
if (result == -1) {
close(fd);
fd = -1;
}
if (result != 0 || vers != BINDER_CURRENT_PROTOCOL_VERSION) {
close(fd);
fd = -1;
}
size_t maxThreads = DEFAULT_MAX_BINDER_THREADS;
// 通過(guò)ioctl設(shè)置binder驅(qū)動(dòng)，能支持的最大線程數(shù)
result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);
if (result == -1) {
ALOGE("Binder ioctl to set max threads failed: %s", strerror(errno));
}
} else {
ALOGW("Opening '/dev/binder' failed: %s\n", strerror(errno));
}
return fd;
}
open_driver的作用就是打開(kāi)/dev/binder設(shè)備，設(shè)定binder支持的最大線程數(shù)。binder驅(qū)動(dòng)相應(yīng)的內(nèi)容請(qǐng)看上一篇文章。
(六)、獲取BpBiner對(duì)象
1、getContextObject()方法
//frameworks/native/libs/binder/ProcessState.cpp 85行
sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& /*caller*/)
{
return getStrongProxyForHandle(0);
}
我們發(fā)現(xiàn)這里面什么都沒(méi)做，就是調(diào)用getStrongProxyForHandle()方法，大家注意它的入?yún)?xiě)死為0，然后我們繼續(xù)深入
2、getStrongProxyForHandle()方法
注釋有點(diǎn)長(zhǎng)，我把注釋刪除了
//frameworks/native/libs/binder/ProcessState.cpp 179行
sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle)
{
sp<IBinder> result;
AutoMutex _l(mLock);
//查找handle對(duì)應(yīng)的資源項(xiàng)
handle_entry* e = lookupHandleLocked(handle);
if (e != NULL) {
IBinder* b = e->binder;
if (b == NULL || !e->refs->attemptIncWeak(this)) {
if (handle == 0) {
Parcel data;
//通過(guò)ping操作測(cè)試binder是否已經(jīng)準(zhǔn)備就緒
status_t status = IPCThreadState::self()->transact(
0, IBinder::PING_TRANSACTION, data, NULL, 0);
if (status == DEAD_OBJECT)
return NULL;
}
//當(dāng)handle值所對(duì)應(yīng)的IBinder不存在或弱引用無(wú)效時(shí)，則創(chuàng)建BpBinder對(duì)象
b = new BpBinder(handle);
e->binder = b;
if (b) e->refs = b->getWeakRefs();
result = b;
} else {
result.force_set(b);
e->refs->decWeak(this);
}
}
return result;
}
大家注意上面函數(shù)的入?yún)andle=0
當(dāng)handle值所對(duì)應(yīng)的IBinder不存在或弱引用無(wú)效時(shí)會(huì)創(chuàng)建BpBinder，否則直接獲取。針對(duì)hande==0的特殊情況，通過(guò)PING_TRANSACTION來(lái)判斷是否準(zhǔn)備就緒。如果在context manager還未生效前，一個(gè)BpBinder的本地引用就已經(jīng)被創(chuàng)建，那么驅(qū)動(dòng)將無(wú)法提供context manager的引用。
在getStrongProxyForHandle()方法里面先后調(diào)用了lookupHandleLocked()方法和創(chuàng)建BpBinder對(duì)象，那我們就來(lái)詳細(xì)研究下
3、lookupHandleLocked()方法
//frameworks/native/libs/binder/ProcessState.cpp 166行
ProcessState::handle_entry* ProcessState::lookupHandleLocked(int32_t handle)
{
const size_t N=mHandleToObject.size();
//當(dāng)handle大于mHandleToObject的長(zhǎng)度時(shí)，進(jìn)入該分支
if (N <= (size_t)handle) {
handle_entry e;
e.binder = NULL;
e.refs = NULL;
//從mHandleToObject的第N個(gè)位置開(kāi)始，插入(handle+1-N)個(gè)e到隊(duì)列中
status_t err = mHandleToObject.insertAt(e, N, handle+1-N);
if (err < NO_ERROR) return NULL;
}
return &mHandleToObject.editItemAt(handle);
}
根據(jù)handle值來(lái)查找對(duì)應(yīng)的handle_entry,handle_entry是一個(gè)結(jié)構(gòu)體，里面記錄了IBinder和weakref_type兩個(gè)指針。當(dāng)handle大于mHandleToObject的Vector長(zhǎng)度時(shí)，則向Vector中添加(handle+1-N)個(gè)handle_entry結(jié)構(gòu)體，然后再返回handle向?qū)?yīng)位置的handle_entry結(jié)構(gòu)體指針。
4、創(chuàng)建BpBinder
//frameworks/native/libs/binder/BpBinder.cpp 89行
BpBinder::BpBinder(int32_t handle)
: mHandle(handle)
, mAlive(1)
, mObitsSent(0)
, mObituaries(NULL)
{
//延長(zhǎng)對(duì)象的生命時(shí)間
extendObjectLifetime(OBJECT_LIFETIME_WEAK);
// handle所對(duì)應(yīng)的bindle弱引用+1
IPCThreadState::self()->incWeakHandle(handle);
}
創(chuàng)建BpBinder對(duì)象中將handle相對(duì)應(yīng)的弱引用+1
(七)、獲取BpServiceManager對(duì)象
1、interface_cast()函數(shù)
//frameworks/native/include/binder/IInterface.h 42行
template<typename INTERFACE>
inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)
{
return INTERFACE::asInterface(obj);
}
這是一個(gè)模板函數(shù)，可得出，interface_cast<IServiceManager>()等價(jià)于IServiceManager::asInterface()。接下來(lái)，再說(shuō)說(shuō)asInterface()函數(shù)的具體功能。
2、IServiceManager::asInterface()函數(shù)
對(duì)于asInterface()函數(shù)，通過(guò)搜索代碼，你會(huì)發(fā)現(xiàn)根本找不到這個(gè)方法是在哪里定義這個(gè)函數(shù)的，其實(shí)是通過(guò)模板函數(shù)來(lái)定義的，通過(guò)下面兩個(gè)代碼完成的
// 位于IServiceManager.h 33行
DECLARE_META_INTERFACE(ServiceManager)
//位于IServiceManager.cpp 108行
IMPLEMENT_META_INTERFACE(ServiceManager,"android.os.IServiceManager")
那我們就來(lái)重點(diǎn)說(shuō)下這兩塊代碼的功能
3、DECLARE_META_INTERFACE
//framework/native/include/binder/IInterface.h 74行
#define DECLARE_META_INTERFACE(INTERFACE)
static const android::String16 descriptor;
static android::sp<I##INTERFACE> asInterface(
const android::sp<android::IBinder>& obj);
virtual const android::String16& getInterfaceDescriptor() const;
I##INTERFACE();
virtual ~I##INTERFACE();
位于IServiceManager.h文件中,INTERFACE=ServiceManager展開(kāi)即可得：
static const android::String16 descriptor;
static android::sp< IServiceManager > asInterface(const android::sp<android::IBinder>& obj)
virtual const android::String16& getInterfaceDescriptor() const;
IServiceManager ();
virtual ~IServiceManager();
該過(guò)程主要是聲明asInterface()、getInterfaceDescriptor()方法。
4、 IMPLEMENT_META_INTERFACE
//framework/native/include/binder/IInterface.h 83行
#define IMPLEMENT_META_INTERFACE(INTERFACE, NAME) \
const android::String16 I##INTERFACE::descriptor(NAME); \
const android::String16& \
I##INTERFACE::getInterfaceDescriptor() const { \
return I##INTERFACE::descriptor; \
} \
android::sp<I##INTERFACE> I##INTERFACE::asInterface( \
const android::sp<android::IBinder>& obj) \
{ \
android::sp<I##INTERFACE> intr; \
if (obj != NULL) { \
intr = static_cast<I##INTERFACE*>( \
obj->queryLocalInterface( \
I##INTERFACE::descriptor).get()); \
if (intr == NULL) { \
intr = new Bp##INTERFACE(obj); \
} \
} \
return intr; \
} \
I##INTERFACE::I##INTERFACE() { } \
I##INTERFACE::~I##INTERFACE() { } \
位于IServiceManager.cpp文件中，INTERFACE=ServiceManager，NAME="android.os.IServiceManager" 開(kāi)展即可得：
const
android::String16
IServiceManager::descriptor(“android.os.IServiceManager”);
const android::String16& IServiceManager::getInterfaceDescriptor() const
{
return IServiceManager::descriptor;
}
android::sp<IServiceManager> IServiceManager::asInterface(const android::sp<android::IBinder>& obj)
{
android::sp<IServiceManager> intr;
if(obj != NULL) {
intr = static_cast<IServiceManager *>(
obj->queryLocalInterface(IServiceManager::descriptor).get());
if (intr == NULL) {
intr = new BpServiceManager(obj); //【見(jiàn)小節(jié)4.5】
}
}
return intr;
}
IServiceManager::IServiceManager () { }
IServiceManager::~ IServiceManager() { }
不難發(fā)現(xiàn)，上面說(shuō)的IServiceManager::asInterface() 等價(jià)于new BpServiceManager()。在這里，更確切地說(shuō)應(yīng)該是new BpServiceManager(BpBinder)。
4.1、 BpServiceManager實(shí)例化
//frameworks/native/libs/binder/IServiceManager.cpp 126行
class BpServiceManager : public BpInterface<IServiceManager>
{
public:
BpServiceManager(const sp<IBinder>& impl)
: BpInterface<IServiceManager>(impl)
{
}
virtual sp<IBinder> getService(const String16& name) const
{
unsigned n;
for (n = 0; n < 5; n++){
sp<IBinder> svc = checkService(name);
if (svc != NULL) return svc;
ALOGI("Waiting for service %s...\n", String8(name).string());
sleep(1);
}
return NULL;
}
virtual sp<IBinder> checkService( const String16& name) const
{
Parcel data, reply;
data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
data.writeString16(name);
remote()->transact(CHECK_SERVICE_TRANSACTION, data, &reply);
return reply.readStrongBinder();
}
virtual status_t addService(const String16& name, const sp<IBinder>& service,
bool allowIsolated)
{
Parcel data, reply;
data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
data.writeString16(name);
data.writeStrongBinder(service);
data.writeInt32(allowIsolated ? 1 : 0);
status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);
return err == NO_ERROR ? reply.readExceptionCode() : err;
}
virtual Vector<String16> listServices()
{
Vector<String16> res;
int n = 0;
for (;;) {
Parcel data, reply;
data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
data.writeInt32(n++);
status_t err = remote()->transact(LIST_SERVICES_TRANSACTION, data, &reply);
if (err != NO_ERROR)
break;
res.add(reply.readString16());
}
return res;
}
};
創(chuàng)建BpServiceManager對(duì)象的過(guò)程，會(huì)先初始化父類對(duì)象：
4.2、 BpServiceManager實(shí)例化
//frameworks/native/include/binder/IInterface.h 135行
template<typename INTERFACE>
class BpInterface : public INTERFACE, public BpRefBase
{
public: BpInterface(const sp<IBinder>& remote);
protected: virtual IBinder* onAsBinder();
};
4.3、BpRefBase初始化
BpRefBase::BpRefBase(const sp<IBinder>& o)
: mRemote(o.get()), mRefs(NULL), mState(0)
{
extendObjectLifetime(OBJECT_LIFETIME_WEAK);
if (mRemote) {
mRemote->incStrong(this);
mRefs = mRemote->createWeak(this);
}
}
new BpServiceManager()，在初始化過(guò)程中，比較重要的類BpRefBase的mRemote指向new BpBinder(0)，從而B(niǎo)pServiceManager能夠利用Binder進(jìn)行通信。
(八) 模板函數(shù)
C層的Binder架構(gòu)，通過(guò)下面的兩個(gè)宏，非常方便地創(chuàng)建了new Bp##INTERFACE(obj)
代碼如下：
// 用于申明asInterface()，getInterfaceDescriptor()
#define DECLARE_META_INTERFACE(INTERFACE)
// 用于實(shí)現(xiàn)上述兩個(gè)方法
#define IMPLEMENT_META_INTERFACE(INTERFACE, NAME)
例如:
// 實(shí)現(xiàn)BpServiceManager對(duì)象
IMPLEMENT_META_INTERFACE(ServiceManager,"android.os.IServiceManager")
等價(jià)于:
const android::String16 IServiceManager::descriptor(“android.os.IServiceManager”);
const android::String16& IServiceManager::getInterfaceDescriptor() const
{
return IServiceManager::descriptor;
}
android::sp<IServiceManager> IServiceManager::asInterface(const android::sp<android::IBinder>& obj)
{
android::sp<IServiceManager> intr;
if(obj != NULL) {
intr = static_cast<IServiceManager *>(
obj->queryLocalInterface(IServiceManager::descriptor).get());
if (intr == NULL) {
intr = new BpServiceManager(obj);
}
}
return intr;
}
IServiceManager::IServiceManager () { }
IServiceManager::~ IServiceManager() { }
(九) 總結(jié)
- defaultServiceManager 等價(jià)于new BpServiceManager(new BpBinder(0));
- ProcessState:: self() 主要工作：
- 調(diào)用open，打/dev/binder驅(qū)動(dòng)設(shè)備
- 調(diào)用mmap(),創(chuàng)建大小為 1016K的內(nèi)存地址空間
- 設(shè)定當(dāng)前進(jìn)程最大的并發(fā)Binder線程個(gè)數(shù)為16
- BpServiceManager巧妙將通信層與業(yè)務(wù)層邏輯合為一體，通過(guò)繼承接口IServiceManager實(shí)現(xiàn)接口中的業(yè)務(wù)邏輯函數(shù);通過(guò)成員變量mRemote=new BpBinder(0) 進(jìn)行Binder通信工作。BpBinder通過(guò)handle來(lái)指向所對(duì)應(yīng)的BBinder，在整個(gè)Binder系統(tǒng)總handle=0代表ServiceManager所對(duì)應(yīng)的BBinder。
