Android Binder 系统学习笔记Binder系统的基本使用方法

Posted CrazyDiode

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Android Binder 系统学习笔记Binder系统的基本使用方法相关的知识,希望对你有一定的参考价值。

1.什么是RPC(远程过程调用)

Binder系统的目的是实现远程过程调用(RPC),即进程A去调用进程B的某个函数,它是在进程间通信(IPC)的基础上实现的。RPC的一个应用场景如下:

A进程想去打开LED,它会去调用led_open,然后调用led_ctl,但是如果A进程并没有权限去打开驱动程序呢?

假设此时有一个进程B由权限去操作LED驱动程序,那么进程A可以通过如下方式来操作LED驱动:

①封装数据,即A进程首先把想要调用的B进程的某个函数的(事先约定好的)代号等信息封装成数据包

②A进程把封装好了的数据包通过IPC(进程间通信)发送给B进程

③B取出数据之后,通过从数据包里解析出来的函数的代号来调用它自己相应的led_open或led_ctl函数

整个过程的结果好像A程序直接来操纵LED一样,这就是所谓的RPC。整个过程涉及到了IPC(进程间通信)的三大要素,源、目的和数据。在这个例子里面,源就是进程A,目的是进程B,数据实际上就是一个双方约定好了数据格式的buffer。

2.Binder系统实现的RPC

Binder系统采用的是CS架构,提供服务的进程称为server进程,访问服务的进程称为client进程,server进程和client进程的通信需要依靠内核中的Binder驱动来进行。同时Binder系统提供了一个上下文的管理者servicemanager, server进程可以向servicemanager注册服务,然后client进程可以通过向servicemanager查询服务来获取server进程注册的服务。

回到上面的例子,A进程想操作LED,它可以通过将B进程的某个函数的(事先约定好的)代号通过IPC发给B进程,通过B进程来间接的操作LED,但是如果A进程不知道可以通过哪个进程来间接的操作LED呢,它应该将封装好了的数据包发送给哪个进程呢?这就引入了Binder系统的大管家servicemanager。首先B进程向servicemanager注册LED服务,然后我们的A进程就可以通过向servicemanager查询LED服务,就会得到一个handle,这个handle就是指向进程B的,这样进程A就知道把数据包(约定好数据格式的buffer)发送给哪个进程就可以间接的操作LED了。在这个例子中进程B就是server进程,进程A是client进程。

小小的总结一下,在 Binder系统中主要涉及到4个东西,一个是我们的A进程也就是client进程,一个是B进程也就是我们的server进程。client进程怎么知道要向哪一个server进程发送数据呢,中间就引入了Binder系统的大管家servicemanager。client进程、server进程和servicemanager之间的通信是建立在内核binder驱动的基础上的,它们四个的关系如下图所示

 

3.Binder系统的简单应用(基于android内核,抛开Android系统框架)

在Android源码里面有一些C语言写的binder应用程序

frameworks/native/cmds/servicemanager/bctest.c
frameworks/native/cmds/servicemanager/binder.c
frameworks/native/cmds/servicemanager/binder.h
frameworks/native/cmds/servicemanager/service_manager.c

我们可以参照这些程序,基于Android内核,在Linux上实现一个Binder RPC的程序来理解使用Binder实现进程间通信的整个函数调用过程。

我们首先把android源码frameworks/native/cmds/servicemanager目录下的内容拷贝到我们自己的工程中,然后基于bctest.c来实现我们的server和client程序,因为我们是脱离Android系统来实现的,所以还需要将依赖的头文件拷贝到工程中,然后对service_manager.c和binder.c做一些修改,去掉一些不必要的内容。最后我们还需要写一个Makefile文件来构建整个工程,工程结构如下图所示。

3.1.Server进程

首先实现Server程序,它实现两个函数,sayhello和sayhello_to,并通过binder系统将向ServiceManager注册服务,然后循环的从binder驱动读取client进程发过来请求数据,并且通过这些请求数据调用自己相应的sayhello和sayhello_to函数。整个过程如下图所示。

接着我们就来分析以下具体的代码

/*test_server.h*/

#ifndef _TEST_SERVER_H
#define _TEST_SERVER_H
/*事先约定好的Server进程的相应函数的代号*/
#define HELLO_SVR_CMD_SAYHELLO     0
#define HELLO_SVR_CMD_SAYHELLO_TO  1
#endif // _TEST_SERVER_H

 

/*test_server.c*/

/* Copyright 2008 The Android Open Source Project
 */
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <linux/types.h>
#include<stdbool.h>
#include <string.h>
#include <private/android_filesystem_config.h>
#include "binder.h"
#include "test_server.h"
int svcmgr_publish(struct binder_state *bs, uint32_t target, const char *name, void *ptr)
{
    int status;
    unsigned iodata[512/4];
    struct binder_io msg, reply;
    bio_init(&msg, iodata, sizeof(iodata), 4);
    bio_put_uint32(&msg, 0);  // strict mode header
    bio_put_string16_x(&msg, SVC_MGR_NAME);
    bio_put_string16_x(&msg, name);
    bio_put_obj(&msg, ptr);
    /*远程调用ServiceManager的do_add_service函数*/
    if (binder_call(bs, &msg, &reply, target, SVC_MGR_ADD_SERVICE))
        return -1;
    status = bio_get_uint32(&reply);
    binder_done(bs, &msg, &reply);
    return status;
}
void sayhello(void)
{
    static int cnt = 0;
    fprintf(stderr, "say hello : %d\\n", cnt++);
}
int sayhello_to(char *name)
{
    static int cnt = 0;
    fprintf(stderr, "say hello to %s : %d\\n", name, cnt++);
    return cnt;
}
int hello_service_handler(struct binder_state *bs,
                   struct binder_transaction_data *txn,
                   struct binder_io *msg,
                   struct binder_io *reply)
{
    /* 根据txn->code知道要调用哪一个函数
     * 如果需要参数, 可以从msg取出
     * 如果要返回结果, 可以把结果放入reply
     */
    /* sayhello
     * sayhello_to
     */
    
    uint16_t *s;
    char name[512];
    size_t len;
    uint32_t handle;
    uint32_t strict_policy;
    int i;
    // Equivalent to Parcel::enforceInterface(), reading the RPC
    // header with the strict mode policy mask and the interface name.
    // Note that we ignore the strict_policy and don\'t propagate it
    // further (since we do no outbound RPCs anyway).
    strict_policy = bio_get_uint32(msg);
    switch(txn->code) {
    case HELLO_SVR_CMD_SAYHELLO:
        sayhello();
        return 0;
    case HELLO_SVR_CMD_SAYHELLO_TO:
        /* 从msg里取出字符串 */
        s = bio_get_string16(msg, &len);
        if (s == NULL) {
            return -1;
        }
        for (i = 0; i < len; i++)
            name[i] = s[i];
        name[i] = \'\\0\';
        /* 处理 */
        i = sayhello_to(name);
        /* 把结果放入reply */
        bio_put_uint32(reply, i);
        
        break;
    default:
        fprintf(stderr, "unknown code %d\\n", txn->code);
        return -1;
    }
    return 0;
}
int main(int argc, char **argv)
{
    int fd;
    struct binder_state *bs;
    uint32_t svcmgr = BINDER_SERVICE_MANAGER;
    uint32_t handle;
    int ret;
    /*打开并映射binder驱动*/
    bs = binder_open(128*1024);
    if (!bs) {
        fprintf(stderr, "failed to open binder driver\\n");
        return -1;
    }
    /* 向ServiceManager注册服务 */
    ret = svcmgr_publish(bs, svcmgr, "hello", (void *)123);
    if (ret) {
        fprintf(stderr, "failed to publish hello service\\n");
        return -1;
    }
    ret = svcmgr_publish(bs, svcmgr, "goodbye", (void *)124);
    if (ret) {
        fprintf(stderr, "failed to publish goodbye service\\n");
    }
#if 0
    while (1)
    {
        /* read data */
        /* parse data, and process */
        /* reply */
    }
#endif
    /*通过我们传入的hello_service_handler循环处理从binder驱动读出的数据*/
    binder_loop(bs, hello_service_handler);
    return 0;
}

接着我们来分析一下这个binder_loop函数,它主要实现了3个功能

1.读数据

2.解析并处理数据

3.回复

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 表明下面的ioctl不会发起写操作,只不过发起读操作
    bwr.write_size = 0;
    bwr.write_consumed = 0;
    bwr.write_buffer = 0;
    readbuf[0] = BC_ENTER_LOOPER;
    binder_write(bs, readbuf, sizeof(uint32_t));
    for (;;) {
        bwr.read_size = sizeof(readbuf);
        bwr.read_consumed = 0;
        bwr.read_buffer = (uintptr_t) readbuf;
        /*通过ioctl从binder驱动中读数据*/
        res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
        if (res < 0) {
            ALOGE("binder_loop: ioctl failed (%s)\\n", strerror(errno));
            break;
        }
        //读到数据之后调用binder_parse解析数据,如果传入func参数还会处理数据
        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;
        }
    }
}

看一下我们是怎么处理数据的,注意我们传入的binder_handler这个参数,它是一个函数指针

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:
            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;
        //我们收到的命令是BR_TRANSACTION
        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;
                //接收到数据之后,构造一个binder_io
                bio_init(&reply, rdata, sizeof(rdata), 4);
                bio_init_from_txn(&msg, txn);
                //调用我们的处理函数
                res = func(bs, txn, &msg, &reply);
                //处理完之后发送一个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);
            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;
}

3.2.Client进程

Client进程和Server进程的大致流程差不多,它首先打开和映射binder驱动,然后向ServiceManager查询服务,最后通过查询服务时ServiceManager返回的handle远程调用Server进程的函数,主要流程如下所示。

下面我们就分析一下具体的源码

/*test_client.c*/

/* Copyright 2008 The Android Open Source Project
 */
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <linux/types.h>
#include<stdbool.h>
#include <string.h>
#include <private/android_filesystem_config.h>
#include "binder.h"
#include "test_server.h"
uint32_t svcmgr_lookup(struct binder_state *bs, uint32_t target, const char *name)
{
    uint32_t handle;
    unsigned iodata[512/4];
    struct binder_io msg, reply;
    bio_init(&msg, iodata, sizeof(iodata), 4);
    bio_put_uint32(&msg, 0);  // strict mode header
    bio_put_string16_x(&msg, SVC_MGR_NAME);
    bio_put_string16_x(&msg, name);
    /*远程调用ServiceManager的do_find_service函数*/
    if (binder_call(bs, &msg, &reply, target, SVC_MGR_CHECK_SERVICE))
        return 0;
    handle = bio_get_ref(&reply);
    if (handle)
        binder_acquire(bs, handle);
    binder_done(bs, &msg, &reply);
    return handle;
}
struct binder_state *g_bs;
uint32_t g_handle;
void sayhello(void)
{
    unsigned iodata[512/4];
    struct binder_io msg, reply;
    /* 构造binder_io */
    bio_init(&msg, iodata, sizeof(iodata), 4);
    bio_put_uint32(&msg, 0);  // strict mode header
    /* 放入参数 */
    /* 调用binder_call远程调用Server的sayhello函数*/
    if (binder_call(g_bs, &msg, &reply, g_handle, HELLO_SVR_CMD_SAYHELLO))
        return ;
    
    /* 从reply中解析出返回值 */
    binder_done(g_bs, &msg, &reply);
    
}
int sayhello_to(char *name)
{
    unsigned iodata[512/4];
    struct binder_io msg, reply;
    int ret;
    /* 构造binder_io */
    bio_init(&msg, iodata, sizeof(iodata), 4);
    bio_put_uint32(&msg, 0);  // strict mode header
    /* 放入参数 */
    bio_put_string16_x(&msg, name);
    /* 调用binder_call远程调用Server的sayhello_to函数 */
    if (binder_call(g_bs, &msg, &reply, g_handle, HELLO_SVR_CMD_SAYHELLO_TO))
        return 0;
    
    /* 从reply中解析出返回值 */
    ret = bio_get_uint32(&reply);
    binder_done(g_bs, &msg, &reply);
    return ret;
    
}
/* ./test_client hello
 * ./test_client hello <name>
 */
int main(int argc, char **argv)
{
    int fd;
    struct binder_state *bs;
    uint32_t svcmgr = BINDER_SERVICE_MANAGER;
    uint32_t handle;
    int ret;
    if (argc < 2){
        fprintf(stderr, "Usage:\\n");
        fprintf(stderr, "%s hello\\n", argv[0]);
        fprintf(stderr, "%s hello <name>\\n", argv[0]);
        return -1;
    }
    /*打开binder驱动*/
    bs = binder_open(128*1024);
    if (!bs) {
        fprintf(stderr, "failed to open binder driver\\n");
        return -1;
    }
    g_bs = bs;
    /* 向ServiceManager查询hello服务 */
    handle = svcmgr_lookup(bs, svcmgr, "hello");
    if (!handle) {
        fprintf(stderr, "failed to get hello service\\n");
        return -1;
    }
    g_handle = handle;
    /* send data to server */
    if (argc == 2) {
        sayhello();
    } else if (argc == 3) {
        ret = sayhello_to(argv[2]);
        fprintf(stderr, "get ret of sayhello_to = %d\\n", ret);        
    }
    binder_release(bs, handle);
    return 0;
}

这里需要注意的一点是,不管我们的Server进程还是Client进程,他们在远程调用其他进程的函数的时候,都是通过binder_call这个函数来实现的,下面我们就来分析一下这个函数。

int binder_call(struct binder_state *bs,
                struct binder_io *msg, struct binder_io *reply,
                uint32_t target, uint32_t code)
{
    int res;
    /*构造参数*/
    struct binder_write_read bwr;
    struct {
        uint32_t cmd;
        struct binder_transaction_data txn;
    } __attribute__((packed)) writebuf;
    unsigned readbuf[32];
    if (msg->flags & BIO_F_OVERFLOW) {
        fprintf(stderr,"binder: txn buffer overflow\\n");
        goto fail;
    }
    
    writebuf.cmd = BC_TRANSACTION;
    writebuf.txn.target.handle = target;
    writebuf.txn.code = code;
    writebuf.txn.flags = 0;
    writebuf.txn.data_size = msg->data - msg->data0;
    writebuf.txn.offsets_size = ((char*) msg->offs) - ((char*) msg->offs0);
    writebuf.txn.data.ptr.buffer = (uintptr_t)msg->data0;
    writebuf.txn.data.ptr.offsets = (uintptr_t)msg->offs0;
    bwr.write_size = sizeof(writebuf);
    bwr.write_consumed = 0;
    bwr.write_buffer = (uintptr_t) &writebuf;
    hexdump(msg->data0, msg->data - msg->data0);
    for (;;) {
        bwr.read_size = sizeof(readbuf);
        bwr.read_consumed = 0;
        bwr.read_buffer = (uintptr_t) readbuf;
        /*调用ioctl发送数据*/
        res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
        if (res < 0) {
            fprintf(stderr,"binder: ioctl failed (%s)\\n", strerror(errno));
            goto fail;
        }
        /*解析返回的数据*/
        res = binder_parse(bs, reply, (uintptr_t) readbuf, bwr.read_consumed, 0);
        if (res == 0) return 0;
        if (res < 0) goto fail;
    }
fail:
    memset(reply, 0, sizeof(*reply));
    reply->flags |= BIO_F_IOERROR;
    return -1;
}

其中第一个参数用来描述当前binder的状态,是调用binder_open时返回的,第二个参数是要发送的数据,第三个参数用来保存返回的数据,第四非参数是数据发送的目的地,即向谁发送数据,第五个参数是要调用的远程的函数的约定好的代号。

3.3.ServiceManager进程

分析完了Server进程和Client进程,紧接着就要来分析我们的大管家ServiceManager进程了,我们的Client进程想使用sayhello函数的时候,是不知道sayhello函数是属于哪一个进程的,有了我们的大管家之后,Client进程才能通过它来查找到Server进程。在Server进程向ServiceManager注册服务和Client进程向ServiceManager查询服务的时候,ServiceManager相对而言都是Server进程。下面就来分析一下这个大管家。
它首先也是打开和映射binder驱动,然后告诉binder驱动,我就是大管家,最后循环接收Server进程和Client进程的请求,它的主要流程如下图所示。

 

紧接着我们就来分析一下它的main函数,和其他一些主要的函数

int main(int argc, char **argv)
{
    struct binder_state *bs;
    /*打开binder驱动*/
    bs = binder_open(128*1024);
    if (!bs) {
        ALOGE("failed to open binder driver\\n");
        return -1;
    }
    /*告诉驱动,我是大管家*/
    if (binder_become_context_manager(bs)) {
        ALOGE("cannot become context manager (%s)\\n", strerror(errno));
        return -1;
    }
    svcmgr_handle = BINDER_SERVICE_MANAGER;
    /*进入无限循环,处理client端发来的请求*/
    binder_loop(bs, svcmgr_handler);
    return 0;
}

分析一下binder_become_context_manager这个函数,看一下是怎样向驱动注册为大管家的

int binder_become_context_manager(struct binder_state *bs)
{
      /*通过ioctl,传递BINDER_SET_CONTEXT_MGR指令*/
    return ioctl(bs->fd, BINDER_SET_CONTEXT_MGR, 0);
}

整个流程的时序如下图所示

总结一下,整个binder远程过程调用,就是首先大管家ServiceManager告诉binder驱动,我现在是大管家了,然后Server进程和Client进程通过这个大管家互相了解了之后,Client进程就可以远程调用Server进程的函数了。

 

 

参考文章:
韦东山老师的binder系统分析的视频:www.100ask.org
Gityuan的博客:http://gityuan.com/

 

 

以上是关于Android Binder 系统学习笔记Binder系统的基本使用方法的主要内容,如果未能解决你的问题,请参考以下文章

Android:安卓学习笔记之Binder 机制的简单理解和使用

转 理解Android系统Binder机制

Android笔记 - Binder之基本概念

binder学习笔记—— 穿越到驱动层

binder学习笔记—— 穿越到驱动层

啃完这份Android Binder原理一系列笔记,完虐大厂面试官