Binder 示例程序之 C 语言篇-六虎

本文依据 Android 10 源码环境。

ServiceManager 从 Android11 开始运用 C++ 重构了，这不利于咱们现在的学习，这儿咱们先运用 Android10 的代码剖析，在整个 Binder 框架讲解完以后咱们再来看看 Android13 是怎么重构的。

1. 引子

Binder 是一个 RPC（Remote Procedure Call）框架，翻译成中文便是长途过程调用。也便是说经过 Binder，咱们能够在 A 进程中访问 B 进程中界说的函数。进程 B 中的这些等候着被长途调用的函数的调集，咱们称其为Binder 服务（Binder Service），进程 A 称之为 Binder 客户端（Binder Client），进程 B 称之为 Binder 服务端（Binder Server）

一般，服务（Service） 需求事前注册到服务管家（ServiceManager），才干被其他进程访问到。服务管家（ServiceManager） 是 Android 体系发动时，发动的一个用于办理 Binder 服务（Binder Service） 的进程。

以上的 Binder 长途过程调用的才能是经过Binder 驱动来完结的，现在咱们关注的重点是应用程序的流程，能够将 Binder 驱动作为一个黑盒来看待，只关心 Binder 驱动对外供给的接口。

一般一个完整的 Binder 程序会涉及到 4 个目标和 4 个流程

4 个目标：

Binder 驱动
Binder Server
Binder Client
ServiceManager

4 个流程：

在 Binder Server 端界说好服务
然后向 ServiceManager 注册服务
在 Binder Client 中向 ServiceManager 获取到服务
建议长途调用，调用 Binder Server 中界说好的服务

整个流程都是建立在 Binder 驱动供给的跨进程调用才能之上：

2. Binder 驱动对外供给的接口

现在阶段，咱们的重点是 Binder 应用程序的作业流程和相关数据结构，Binder 驱动应该作为一个黑盒来看待，只关心 Binder 驱动对外供给了哪些函数供应用程序运用。

Binder 是一个 Linux 字符驱动，对外供给了以下函数供应用程序运用：

open()，用于打开 binder 驱动，回来 Binder 驱动的文件描述符
mmap()，用于在内核中申请一块内存，并完结应用层与内核层的虚拟地址映射
ioctl，在应用层调用 ioctl 向内核层发送数据或者读取内核层发送到应用层的数据：

ioctl(文件描述符,ioctl命令,数据)

文件描述符是在调用 open 时的回来值，ioctl 命令和第三个参数”数据”的类型是相关联的，具体如下：

ioctl命令	数据类型	函数动作
BINDER_WRITE_READ	struct binder_write_read	应用层向内核层收发数据
BINDER_SET_MAX_THREADS	size_t	设置最大线程数
BINDER_SET_CONTEXT_MGR	int or flat_binder_object	设置当时进程为ServiceManager
BINDER_THREAD_EXIT	int	删去 binder 线程
BINDER_VERSION	struct binder_version	获取 binder 协议版本

3. 应用程序编写

能够在这儿下载好示例代码再接着往下看。

在 frameworks/native/cmds/servicemanager 目录下的 binder.c 和 bctest.c 针对应用编写的需求，对open mmap ioctl 等基本操作做了封装，供给了以下几个函数：

binder_open：用于初始化 binder 驱动
binder_become_context_manager：设置当时进程为 ServiceManager
svcmgr_lookup：用于向 ServiceManager 查找服务
svcmgr_publish：用于向 ServiceManager 注册服务
binder_call：用于建议长途过程调用
binder_loop：进入循环，在循环中，获取和解析收到的 binder 数据

3.1 Server 端的完结

接下来，咱们就开始写 Server 端的代码,相关的代码在 binder_server.c 中，首要过程如下：

界说服务
界说服务回调函数
完结 main 函数流程
- Binder 初始化
- 注册服务
- 进入 loop，等候 client 恳求服务

3.1.1 界说服务

这儿咱们界说一个服务：

//服务供给的函数1
void sayhello(void)
{
	static int cnt = 0;
	//fprintf(stderr, "say hello : %d\n", ++cnt);
    	ALOGW("say hello : %d\n", ++cnt);
}
//服务供给的函数2
int sayhello_to(char *name)
{
	static int cnt = 0;
	//fprintf(stderr, "say hello to %s : %d\n", name, ++cnt);
    	ALOGW("say hello to %s : %d\n", name, ++cnt);
	return cnt;
}

能够看出，服务便是若干函数的调集。

3.1.2 界说服务回调函数

当 client 建议长途调用时，server 端会收到数据，并将这些数据传递给服务回调函数，这个回调函数需求咱们自己来界说：

// server 收到 client 长途函数调用后的回调函数，用于处理收到的信息
// bs 表明 binder 状况
// binder_io 是 c 层界说的数据结构，能够简略理解为一个数据调集
// txn_secctx 和 msg 是收到的数据
// reply 是需求回来给 client 的数据
int hello_service_handler(struct binder_state *bs,
                   struct binder_transaction_data_secctx *txn_secctx,
                   struct binder_io *msg,
                   struct binder_io *reply)
{
    struct binder_transaction_data *txn = &txn_secctx->transaction_data;
    uint16_t *s;
    char name[512];
    size_t len;
    //uint32_t handle;
    uint32_t strict_policy;
    int i;
    //bio_get_uint32 用于从 binder_io 中取出一个 32 为整型数据
    strict_policy = bio_get_uint32(msg);
/* 依据txn->code知道要调用哪一个函数
 * 假如需求参数, 能够从msg取出
 * 假如要回来成果, 能够把成果放入reply
 */
    switch(txn->code) {
        //调用函数1
        case HELLO_SVR_CMD_SAYHELLO:
            sayhello();
            bio_put_uint32(reply, 0); /* no exception */
            return 0;
        //调用函数2
        case HELLO_SVR_CMD_SAYHELLO_TO:
        /* 从msg里取出字符串 */
            s = bio_get_string16(msg, &len);  //"IHelloService"
            s = bio_get_string16(msg, &len);  // name
            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, 0); /* no exception */
            bio_put_uint32(reply, i);
            break;
        default:
            fprintf(stderr, "unknown code %d\n", txn->code);
            return -1;
    }
        return 0;
}

回调函数的流程结构仍是比较清晰明的：

取出 code 值
依据 code 值调用对应的函数
函数假如有参数，从 msg 中取出
函数的回来值写入到 reply 中

3.1.3 Server 主函数

主函数首要完结以下几件工作：

Binder 初始化
注册服务
进入 loop，等候 client 恳求服务

int main(int argc, char **argv)
{
    struct binder_state *bs;
    uint32_t svcmgr = BINDER_SERVICE_MANAGER;
    uint32_t handle;
	int ret;
    //Binder 初始化
    bs = binder_open("/dev/binder", 128*1024);
    if (!bs) {
        fprintf(stderr, "failed to open binder driver\n");
        return -1;
    }
	//svcmgr 的值是 0，表明发送信息给 servicemanager
	//注册服务
	ret = svcmgr_publish(bs, svcmgr, "hello", hello_service_handler);
    if (ret) {
        fprintf(stderr, "failed to publish hello service\n");
        return -1;
    }
    //进入 loop， 等候 client 恳求服务
    binder_loop(bs, test_server_handler);
    return 0;
}

main 函数首要调用了 binder_open、svcmgr_publish 和 binder_loop 三个函数来完结了 binder 的初始化，服务注册，进入 looper 三个阶段的功能。

3.2 ServiceManager 的完结

ServiceManager 由体系完结，并在体系发动时发动。

其源码在 frameworks/native/cmds/servicemanager/service_manager.c：

主函数的内容如下

int main(int argc, char** argv)
{
    struct binder_state *bs;
    char *driver;
    if (argc > 1) {
        driver = argv[1];
    } else {
        driver = "/dev/binder";
    }
    //binder 驱动初始化
    bs = binder_open(driver, 128*1024);
    //删减了 VENDORSERVICEMANAGER 相关内容
    if (!bs) {
        ALOGE("failed to open binder driver %s\n", driver);
        return -1;
    }
    //告知驱动，当时进程是
    if (binder_become_context_manager(bs)) {
        ALOGE("cannot become context manager (%s)\n", strerror(errno));
        return -1;
    }
    //删减了 selinux 相关内容
    binder_loop(bs, svcmgr_handler);
    return 0;
}

main 函数首要流程如下：

调用 binder_open 函数完结 binder 驱动的初始化
调用 binder_become_context_manager 函数告知 binder 驱动当时进程是 context_manager
调用 binder_loop 函数，进入 looper ，比及长途调用，其收到数据后的回调函数是 svcmgr_handler

3.3 Client

编写 Client 程序的首要流程如下：

完结长途调用函数
open 初始化 binder 驱动
查询服务，获取到服务的句柄 handle
经过 handle 调用长途调用函数

首先界说好长途调用函数：

void sayhello(void)
{
    unsigned iodata[512/4];
    //binder_io 能够理解为一个数据调集，用于存取数据
    struct binder_io msg, reply;
	/* 结构binder_io */
    bio_init(&msg, iodata, sizeof(iodata), 4);
    bio_put_uint32(&msg, 0);  // strict mode header
    bio_put_string16_x(&msg, "IHelloService");
	/* 放入参数 */
	/* 调用 binder_call 建议长途调用 */
    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;
	int exception;
	/* 结构binder_io */
	bio_init(&msg, iodata, sizeof(iodata), 4);
	bio_put_uint32(&msg, 0);  // strict mode header
    bio_put_string16_x(&msg, "IHelloService");
	/* 放入参数 */
    bio_put_string16_x(&msg, name);
	/* 调用binder_call  建议长途调用*/
	if (binder_call(g_bs, &msg, &reply, g_handle, HELLO_SVR_CMD_SAYHELLO_TO))
		return 0;
	/* 从reply中解分出回来值 */
	exception = bio_get_uint32(&reply);
	if (exception)
		ret = -1;
	else
		ret = bio_get_uint32(&reply);
	binder_done(g_bs, &msg, &reply);
	return ret;
}

接下来，完结 main 函数：

int g_handle = 0;
struct binder_state *g_bs;
int main(int argc, char **argv)
{
    int fd;
    struct binder_state *bs;
    uint32_t svcmgr = BINDER_SERVICE_MANAGER;
	int ret;
    //初始化 binder 驱动
    bs = binder_open("/dev/binder", 128*1024);
    if (!bs) {
        fprintf(stderr, "failed to open binder driver\n");
        return -1;
    }
    g_bs = bs;
	//查找服务，获取到服务的句柄 handle，用于找到 Server 进程
    g_handle = svcmgr_lookup(bs, svcmgr, "hello");
    if (!g_handle) {
        ALOGW("binder client 查找服务 hello 失利");
        return -1;
    } else {
        ALOGW("binder client 查找服务成功 handle = %d", g_handle);
    }
    //经过 handle 调用服务
    sayhello();
    sayhelloto("hello binder");

3.4 编译运转程序

项目目录下增加 Android.bp ：

cc_defaults {
    name: "bindertestflags",
    cflags: [
        "-Wall",
        "-Wextra",
        "-Werror",
        "-Wno-unused-parameter",
        "-Wno-missing-field-initializers",
        "-Wno-unused-parameter",
        "-Wno-unused-variable",
        "-Wno-incompatible-pointer-types",
        "-Wno-sign-compare",
    ],
    product_variables: {
        binder32bit: {
            cflags: ["-DBINDER_IPC_32BIT=1"],
        },
    },
    shared_libs: ["liblog"],
}
cc_binary {
    name: "binderclient",
    defaults: ["bindertestflags"],
    srcs: [
        "client.cpp",
        "binder.c",
    ],
}
cc_binary {
    name: "binderserver",
    defaults: ["bindertestflags"],
    srcs: [
        "server.cpp",
        "binder.c",
    ],
}

终端进入体系源码，然后履行：

source build/envsetup.sh
lunch aosp_x86_64-eng
emulator

将源码移动到aosp源码下恣意目录，进入 BinderCDemo，编译模块：

mm

编译完结后，将程序上传到模拟器并履行。

传输可履行文件到模拟器：

adb push aosp/out/target/product/generic_x86_64/vendor/bin/binderserver /data/local/tmp
adb push aosp/out/target/product/generic_x86_64/vendor/bin/binderclient /data/local/tmp

接下来 adb shell 进入模拟器 shell 环境：

adb shell
cd /data/local/tmp
./binderserver
# 重新开一个终端进入 adb shell
cd /data/local/tmp
./binderclient

最终经过 logcat 检查履行成果：

logcat | grep "BinderServer"
11-22 17:08:39.133  6594  6594 W BinderServer: say hello : 1

Binder 示例程序之 C 语言篇

1. 引子

2. Binder 驱动对外供给的接口

3. 应用程序编写

3.1 Server 端的完结

3.1.1 界说服务

3.1.2 界说服务回调函数

3.1.3 Server 主函数

3.2 ServiceManager 的完结

3.3 Client

3.4 编译运转程序

相关文章

等等党的胜利？秋招岗位还能投？

Chat GPT 说自己会报哪些错误以及错误收集？

SpringBoot3整合MyBatis报错：Property sqlSessionFactory or sqlSessionTemplate required

【Codeium】使用体验：一款免费的Copilot平替

作者信息