红茶一杯话Binder(传输机制篇_中)

干了5Android开发还没掌握-binder-机制、驱动核心源码?我劝你早点改行吧 bwr.read_consumed = 0; if (copy_to_user(ubuf, &bwr, sizeof(bwr))) ret = -EFAULT; goto out; } } if (bwr.read_size > 0) {//读数据 ret = binder_thread_read(proc, thread, bwr.read_buffer, bwr.read_size, &bwr.read_consumed, filp->f_flags & O_NONB 阅读详情

红茶一杯话Binder

(传输机制篇_中)

 

侯 亮

 

1 谈谈底层IPC机制吧

        在上一篇文章的最后,我们说到BpBinder将数据发到了Binder驱动。然而在驱动层,这部分数据又是如何传递到BBinder一侧的呢?这里面到底藏着什么猫腻?另外,上一篇文章虽然阐述了4棵红黑树,但是并未说明红黑树的节点到底是怎么产生的。现在,我们试着回答这些问题。

1.1 概述

        在Binder驱动层,和ioctl()相对的动作是binder_ioctl()函数。在这个函数里,会先调用类似copy_from_user()这样的函数,来读取用户态的数据。然后,再调用binder_thread_write()和binder_thread_read()进行进一步的处理。我们先画一张调用关系图:


         binder_ioctl()调用binder_thread_write()的代码是这样的:

if (bwr.write_size > 0) 
{
    ret = binder_thread_write(proc, thread, (void __user *)bwr.write_buffer,
                              bwr.write_size, &bwr.write_consumed);
    if (ret < 0) 
    {
        bwr.read_consumed = 0;
        if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
            ret = -EFAULT;
        goto err;
    }
}

注意binder_thread_write()的前两个参数,一个是binder_proc指针,另一个是binder_thread指针,表示发起传输动作的进程和线程。binder_proc不必多说了,那个binder_thread是怎么回事?大家应该还记得前文提到的binder_proc里的4棵树吧,此处的binder_thread就是从threads树中查到的节点。

thread = binder_get_thread(proc);

binder_get_thread()的代码如下:

static struct binder_thread *binder_get_thread(struct binder_proc *proc)
{
    struct binder_thread *thread = NULL;
    struct rb_node *parent = NULL;
    struct rb_node **p = &proc->threads.rb_node;
 
    // 尽量从threads树中查找和current线程匹配的binder_thread节点
    while (*p)
    {
        parent = *p;
        thread = rb_entry(parent, struct binder_thread, rb_node);
        if (current->pid < thread->pid)
            p = &(*p)->rb_left;
        else if (current->pid > thread->pid)
            p = &(*p)->rb_right;
        else
            break;
    }
   
    // “找不到就创建”一个binder_thread节点
    if (*p == NULL)
    {
        thread = kzalloc(sizeof(*thread), GFP_KERNEL);
        if (thread == NULL)
            return NULL;
        binder_stats_created(BINDER_STAT_THREAD);
        thread->proc = proc;
        thread->pid = current->pid;
        init_waitqueue_head(&thread->wait);
        INIT_LIST_HEAD(&thread->todo);
       
         // 新binder_thread节点插入红黑树
        rb_link_node(&thread->rb_node, parent, p);
        rb_insert_color(&thread->rb_node, &proc->threads);
        thread->looper |= BINDER_LOOPER_STATE_NEED_RETURN;
        thread->return_error = BR_OK;
        thread->return_error2 = BR_OK;
    }
    return thread;
}

binder_get_thread()会尽量从threads树中查找和current线程匹配的binder_thread节点,如果找不到,就会创建一个新的节点并插入树中。这种“找不到就创建”的做法,在后文还会看到,我们暂时先不多说。

        在调用binder_thread_write()之后,binder_ioctl()接着调用到binder_thread_read(),此时往往需要等待远端的回复,所以binder_thread_read()会让线程睡眠,把控制权让出来。在未来的某个时刻,远端处理完此处发去的语义,就会着手发回回复。当回复到达后,线程会从以前binder_thread_read()睡眠的地方醒来,并进一步解析收到的回复。

        以上所说,都只是概要性的阐述,下面我们要深入一些细节了。

 

1.2 要进行跨进程调用,需要考虑什么?

        我们可以先考虑一下,要设计跨进程调用机制,大概需要考虑什么东西呢?我们列一下:

1) 发起端:肯定包括发起端所从属的进程,以及实际执行传输动作的线程。当然,发起端的BpBinder更是重中之重。

2) 接收端:包括与发起端对应的BBinder,以及目标进程、线程。

3) 待传输的数据:其实就是前文IPCThreadState::writeTransactionData()代码中的binder_transaction_data了,需要注意的是,这份数据中除了包含简单数据,还可能包含其他binder对象噢,这些对象或许对应binder代理对象,或许对应binder实体对象,视具体情况而定。

4) 如果我们的IPC动作需要接收应答(reply),该如何保证应答能准确无误地传回来?

5) 如何让系统中的多个传输动作有条不紊地进行。

        我们可以先画一张示意图:


然而这张图似乎还是串接不起整个传输过程,图中的“传输的数据”到底是怎么发到目标端的呢?要回答这个问题,我们还得继续研究Binder IPC机制的实现机理。

 

1.3 传输机制的大体运作

         Binder IPC机制的大体思路是这样的,它将每次“传输并执行特定语义的”工作理解为一个小事务,既然所传输的数据是binder_transaction_data类型的,那么这种事务的类名可以相应地定为binder_transaction。系统中当然会有很多事务啦,那么发向同一个进程或线程的若干事务就必须串行化起来,因此binder驱动为进程节点(binder_proc)和线程节点(binder_thread)都设计了个todo队列。todo队列的职责就是“串行化地组织待处理的事务”。

        下图绘制了一个进程节点,以及一个从属于该进程的线程节点,它们各带了两个待处理的事务(binder_transaction):


        这样看来,传输动作的基本目标就很明确了,就是想办法把发起端的一个binder_transaction节点,插入到目标端进程或其合适子线程的todo队列去。

        可是,该怎么找目标进程和目标线程呢?基本做法是先从发起端的BpBinder开始,找到与其对应的binder_node节点,这个在前文阐述binder_proc的4棵红黑树时已经说过了,这里不再赘述。总之拿到目标binder_node之后,我们就可以通过其proc域,拿到目标进程对应的binder_proc了。如果偷懒的话,我们直接把binder_transaction节点插到这个binder_proc的todo链表去,就算完成传输动作了。当然,binder驱动做了一些更精细的调整。

        binder驱动希望能把binder_transaction节点尽量放到目标进程里的某个线程去,这样可以充分利用这个进程中的binder工作线程。比如一个binder线程目前正睡着,它在等待其他某个线程做完某个事情后才会醒来,而那个工作又偏偏需要在当前这个binder_transaction事务处理结束后才能完成,那么我们就可以让那个睡着的线程先去做当前的binder_transaction事务,这就达到充分利用线程的目的了。反正不管怎么说,如果binder驱动可以找到一个合适的线程,它就会把binder_transaction节点插到它的todo队列去。而如果找不到合适的线程,还可以把节点插入目标binder_proc的todo队列。

 

1.4 红黑树节点的产生过程

        另一个要考虑的东西就是binder_proc里的那4棵树啦。前文在阐述binder_get_thread()时,已经看到过向threads树中添加节点的动作。那么其他3棵树的节点该如何添加呢?其实,秘密都在传输动作中。要知道,binder驱动在传输数据的时候,可不是仅仅简单地递送数据噢,它会分析被传输的数据,找出其中记录的binder对象,并生成相应的树节点。如果传输的是个binder实体对象,它不仅会在发起端对应的nodes树中添加一个binder_node节点,还会在目标端对应的refs_by_desc树、refs_by_node树中添加一个binder_ref节点,而且让binder_ref节点的node域指向binder_node节点。我们把前一篇文章的示意图加以修改,得到下图:


图中用红色线条来表示传输binder实体时在驱动层会添加的红黑树节点以及节点之间的关系。

        可是,驱动层又是怎么知道所传的数据中有多少binder对象,以及这些对象的确切位置呢?答案很简单,是你告诉它的。大家还记得在向binder驱动传递数据之前,都是要把数据打成parcel包的吧。比如:

virtual status_t addService(const String16& name, const sp<IBinder>& service)
{
    Parcel data, reply;
       
    data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
    data.writeString16(name);
    data.writeStrongBinder(service);  // 把一个binder实体“打扁”并写入parcel
    status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);
    return err == NO_ERROR ? reply.readExceptionCode() : err;
}

请大家注意上面data.writeStrongBinder()一句,它专门负责把一个binder实体“打扁”并写入parcel。其代码如下:

status_t Parcel::writeStrongBinder(const sp<IBinder>& val)
{
    return flatten_binder(ProcessState::self(), val, this);
}

 

status_t flatten_binder(const sp<ProcessState>& proc, const sp<IBinder>& binder, Parcel* out)
{
    flat_binder_object obj;
    . . . . . .
    if (binder != NULL) {
        IBinder *local = binder->localBinder();
        if (!local) {
            BpBinder *proxy = binder->remoteBinder();
            . . . . . .
            obj.type = BINDER_TYPE_HANDLE;
            obj.handle = handle;
            obj.cookie = NULL;
        } else {
            obj.type = BINDER_TYPE_BINDER;
            obj.binder = local->getWeakRefs();
            obj.cookie = local;
        }
    }
    . . . . . .
    return finish_flatten_binder(binder, obj, out);
}

看到了吗?“打扁”的意思就是把binder对象整理成flat_binder_object变量,如果打扁的是binder实体,那么flat_binder_object用cookie域记录binder实体的指针,即BBinder指针,而如果打扁的是binder代理,那么flat_binder_object用handle域记录的binder代理的句柄值。

        然后flatten_binder()调用了一个关键的finish_flatten_binder()函数。这个函数内部会记录下刚刚被扁平化的flat_binder_object在parcel中的位置。说得更详细点儿就是,parcel对象内部会有一个buffer,记录着parcel中所有扁平化的数据,有些扁平数据是普通数据,而另一些扁平数据则记录着binder对象。所以parcel中会构造另一个mObjects数组,专门记录那些binder扁平数据所在的位置,示意图如下:


        一旦到了向驱动层传递数据的时候,IPCThreadState::writeTransactionData()会先把Parcel数据整理成一个binder_transaction_data数据,这个在上一篇文章已有阐述,但是当时我们并没有太关心里面的关键句子,现在我们把关键句子再列一下:

status_t IPCThreadState::writeTransactionData(int32_t cmd, uint32_t binderFlags,
                                              int32_t handle, uint32_t code,
                                              const Parcel& data, status_t* statusBuffer)
{
    binder_transaction_data tr;
    . . . . . .
        // 这部分是待传递数据
        tr.data_size = data.ipcDataSize();
        tr.data.ptr.buffer = data.ipcData();
        // 这部分是扁平化的binder对象在数据中的具体位置
        tr.offsets_size = data.ipcObjectsCount()*sizeof(size_t);
        tr.data.ptr.offsets = data.ipcObjects();
    . . . . . .
    mOut.write(&tr, sizeof(tr));
    . . . . . .
}

其中给tr.data.ptr.offsets赋值的那句,所做的就是记录下“待传数据”中所有binder对象的具体位置,示意图如下:


因此,当binder_transaction_data传递到binder驱动层后,驱动层可以准确地分析出数据中到底有多少binder对象,并分别进行处理,从而产生出合适的红黑树节点。此时,如果产生的红黑树节点是binder_node的话,binder_node的cookie域会被赋值成flat_binder_object所携带的cookie值,也就是用户态的BBinder地址值啦。这个新生成的binder_node节点被插入红黑树后,会一直严阵以待,以后当它成为另外某次传输动作的目标节点时,它的cookie域就派上用场了,此时cookie值会被反映到用户态,于是用户态就拿到了BBinder对象。

        我们再具体看一下IPCThreadState::waitForResponse()函数,当它辗转从睡眠态跳出来时,会进一步解析刚收到的命令,此时会调用executeCommand(cmd)一句。

status_t IPCThreadState::waitForResponse(Parcel *reply, status_t *acquireResult)
{
    int32_t cmd;
    int32_t err;
 
    while (1)
    {
        if ((err = talkWithDriver()) < NO_ERROR) break;
        . . . . . .
        switch (cmd)
        {
            . . . . . .
            . . . . . .
        default:
            err = executeCommand(cmd);
            . . . . . .
            break;
        }
    }
    . . . . . .
   
    return err;
}

executeCommand()的代码截选如下:

status_t IPCThreadState::executeCommand(int32_t cmd)
{
    BBinder* obj;
    . . . . . .
    switch (cmd)
    {
        . . . . . .
        . . . . . .
    case BR_TRANSACTION:
        {
            binder_transaction_data tr;
            result = mIn.read(&tr, sizeof(tr));
            . . . . . .
            . . . . . .
            if (tr.target.ptr)
            {
                sp<BBinder> b((BBinder*)tr.cookie);
                const status_t error = b->transact(tr.code, buffer, &reply, tr.flags);
                if (error < NO_ERROR) reply.setError(error);
 
            }
            . . . . . .
           
            if ((tr.flags & TF_ONE_WAY) == 0)
            {
                LOG_ONEWAY("Sending reply to %d!", mCallingPid);
                sendReply(reply, 0);
            }
            else
            {
                LOG_ONEWAY("NOT sending reply to %d!", mCallingPid);
            }
            . . . . . .
        }
        break;
    . . . . . .
    . . . . . .
    default:
        printf("*** BAD COMMAND %d received from Binder driver\n", cmd);
        result = UNKNOWN_ERROR;
        break;
    }
    . . . . . .
    return result;
}

请注意上面代码中的sp<BBinder> b((BBinder*)tr.cookie)一句,看到了吧,驱动层的binder_node节点的cookie值终于发挥它的作用了,我们拿到了一个合法的sp<BBinder>。

        接下来,程序走到b->transact()一句。transact()函数的代码截选如下:

status_t BBinder::transact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    . . . . . .
    switch (code)
    {
        . . . . . .
        default:
            err = onTransact(code, data, reply, flags);
            break;
    }
    . . . . . .
}

其中最关键的一句是调用onTransaction()。因为我们的binder实体在本质上都是继承于BBinder的,而且我们一般都会重载onTransact()函数,所以上面这句onTransact()实际上调用的是具体binder实体的onTransact()成员函数。

        Ok,说了这么多,我们大概明白了binder驱动层的红黑树节点是怎么产生的,以及binder_node节点的cookie值是怎么派上用场的。限于篇幅,我们先在这里打住。下一篇文章我们再来阐述binder事务的传递和处理方面的细节。

 

如需转载本文内容,请注明出处。

谢谢。

(本文也发布在我的oschina博客上)

细读《深入理解 Android 内核设计思想》(五)Binder 机制 [下] 对冗余挑拣重点,对重点深入补充,输出结构清晰的精简版 深入 binder 驱动内部 binder_ioctl binder_get_thread binder_ioctl_write_read binder_thread_write binder_transaction binder_thread_read 小结 binder Q&A 如何找到目标进程 Binder 实体 如何实现 Binder 线程的睡眠与唤醒 最后 深入 binder 驱动内部 前两篇文章都有提到 binder_ioc 阅读详情

相关推荐

命名管道和匿名管道

我们知道进程间是可以通信的。可以达到数据传输、资源共享、事件通知、进程控制等目的。进程间通信主要包括管道、系统IPC,套接字等。 管道分为三种: 普通管道:一是单工,只能单向传输 ,二是仅能在父子进程或者兄弟进程中使用。 流管道:去除了第一种限制,为半双工,可以双向传递, 命名管道:去除了第二种限制 ,可以在很多并不相关的进程 中进行通信。 1、普通管道 int pipe(int f...

ffsiwei的博客 1万+

红茶一杯话Binder(合集五篇)

红茶一杯话Binder(初始篇) https://blog.csdn.net/codefly/article/details/17058607 红茶一杯话Binder (初始篇) 侯 亮 1 什么是Binder?        简单地说,Binder是Android平台上的一种跨进程交互技术。该技术最早并不是由Google公司提出的,它的前身是Be Inc公司开发的OpenBinder,而且在Pa...

青岛海珊瑚IT学习中心 1037

如何实现MCGS与S7-200SMART PLC以太网多台通信控制?

第九步:(设备工具箱—设备管理—鼠标依次点击通用TCP/IP父设备—西门子_ Smart200到设备窗口里面去)数据类型:第0位(指PLC地址变量小数点后面的位数,例如我地址是M0.0,那么在数据类型应填写通道的第00位)第十步:(鼠标双击打开通用TCPIP父设备0--[通用TCP/IP父设备]进入通信配置)通道地址:0(指小数点前面起始字节的地址,例如我地址是M0.0,那么应在通道地填写0)。第七步:(选择通用TCP/IP父设备,点击新增,右侧选定设备就会自动添加进去。

u010670857的博客 6720

【物联网 · 嵌入式】使用 ESP8266 接入 Blinker 物联网平台

搭建开发环境 1. 安装Arduino IDE ① 进入 Arduino 官网 https://www.arduino.cc/en/software ② 选择适合电脑的版本(这里选择的是windows版本) ③ 点击 “Just Download” ④ 下载完成后,安装即可 2. 安装esp8266支持包 ① 点击下载支持包 ② 下载完成后,解压并点击安装即可 3. 安装blinker库 ① 点击下载blinker库 ② 将下载好的文件解压到 我的电脑>文档>Arduino>libra

不定时分享与嵌入式有关的知识 2万+

手把手教你用分立元件搭建自举电路:解决高端MOS驱动难题

本文详细介绍了如何用分立元件搭建自举电路,解决高端MOS驱动中的栅源极电压不足问题。通过面包板实验,逐步讲解二极管、电容等关键元件的选型与电路搭建,提供波形调试和常见问题排查方法,帮助工程师提升开关电源和电机驱动等应用的效率与可靠性。

weixin_30555125的博客 156

ansys workbench生成simpack使用的柔性体文件(.sub和.cdb文件)

由于需要做齿轮箱的刚柔耦合仿真,所以需要使用ansys生成.sub和.cdb文件,通过simpack内置的插件完成柔性体的建立。但是网络的教程相当有限。bilibili用户分享,apdl生成.sub和.cdb文件(apdl)子结构处理超大型模型问题ansys子结构分析时如何选取主自由度但是apdl学习成本比较高,所以我还是希望使用workbench实现这些功能,所以在此,我总结一下操作方法。

chbl6的博客 9714

红茶一杯话Binder(传输机制篇_上)

红茶一杯话Binder (传输机制篇_上)   侯 亮   1 Binder是如何做到精确打击的?         我们先问一个问题,binder机制到底是如何从代理对象找到其对应的binder实体呢?难道它有某种制导装置吗?要回答这个问题,我们只能静下心来研究binder驱动的代码。在本系列文档的初始篇中,我们曾经介绍过ProcessState,这个结构是属于

夜静水寒鱼不食 满船空载月明归 4435

手把手教你用ROS2控制PX4无人机画个圆:从C++代码到Gazebo仿真全流程解析

本文详细解析了如何使用ROS2控制PX4无人机实现圆形轨迹飞行,涵盖从C++代码编写到Gazebo仿真的全流程。重点介绍了Offboard模式下的控制算法实现、圆形轨迹生成的数学原理,以及解决通信延迟和坐标系转换等常见问题的实用技巧。通过实战案例,帮助开发者快速掌握无人机轨迹跟踪仿真的核心技术。

weixin_30839881的博客 99

红茶一杯话Binder(传输机制篇_下)

红茶一杯话Binder (传输机制篇_下)   侯 亮   1 事务的传递和处理         从IPCThreadState的角度看,它的transact()函数是通过向binder驱动发出BC_TRANSACTION语义,来表达其传输意图的,而后如有必要,它会等待从binder发回的回馈,这些回馈语义常常以“BR_”开头。另一方面,当IPCThreadSt

夜静水寒鱼不食 满船空载月明归 3929

整理笔记——二极管

二极管是一种由半导体材料制成的一种具有单向导电性能的电子元器件,二极管的核心是PN结。加在二极管两端的电压和通关的电流被成为,二极管的伏安特性曲线​​​二极管的正向特性:起初正向电压较小时,正向电流几乎没有,称之为死区,此时二极管处于截止状态。当电压差超过截止电压(0.5V或者0.7V),电流随着电压上升,开始增加缓慢,随后急剧增大,二极管的电阻变小进入导通状态,此时电压变化较小。二极管的反向特性:起初反向电流很小,不随电压二变化,此时成为反向饱和电流;当方向电压达到二极管的反向击穿电压。

#include 811

从零开始学习CANoe(三)—— 系统变量的创建和使用

从零开始学习CANoe(三)—— 系统变量的创建和使用

蚂蚁小兵 1万+

Binder学习资料整理

Android深入浅出之Binder机制 Android进程间通信(IPC)机制Binder简要介绍和学习计划 浅谈Service Manager成为Android进程间通信(IPC)机制Binder守护进程之路 浅谈Android系统进程间通信(IPC)机制Binder中的Server和Client获得Service Manager接口之路 Android系统进程间通

Vincent的专栏 732

超级详细的GNS3最新版3-2.2.50安装配置教程,网工速度收藏!

你好,这里是网络技术联盟站,我是瑞哥。上周给大家分享了GNS3安装包。周末的时候有小伙伴在安装的时候遇到了一些问题,瑞哥周末特地从头安装了一下GNS3,今天给大家出个安装的教程,每一步的步骤我都截图了下来,希望对大家有所帮助!

网络技术联盟站 1111

binder学习笔记

学习资料 1.Android Bander设计与实现 - 设计篇 :强烈推荐此文,对binder整体设计讲得比较清楚,十分容易读懂。 2.红茶一杯话Binder:强烈推荐此文,这是一个系列,对binder驱动的具体实现做了详细分析。全文读下来基本对binder就了解得差不多了。 3.《深入理解Android:卷1》中的binder章节:以MediaPlayerService为例分析利用bind

sgwhp的专栏 1226

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

上一篇: 红茶一杯话Binder(传输机制篇_上)
下一篇: 红茶一杯话Binder(传输机制篇_下)
悠然红茶
博客等级 码龄26年 270粉丝 27原创
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悠然红茶

原来还有打赏功能,试一下呦。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值