社区首页 >专栏 >[051]Binder线程优先级继承

[051]Binder线程优先级继承

王小二

发布于 2020-06-08 04:11:08

2.9K00

代码可运行

文章被收录于专栏：王小二的Android站王小二的Android站

运行总次数：0

代码可运行

前言

Binder通信需要两个线程，这两个线程的优先级是不同，也就意味着，他们能获取到的cpu的优先级不同。

假如线程A通过非oneway的Binder调用到线程B，如果线程A的优先级大于线程B，这里就会有一个问题出现，线程A会因为线程B的优先级较低而block更多的时间。显然这是不合理的，Binder设计理念就是让你感觉不到IPC的存在，如同在同一线程中调用一个方法那么容易。

一、非oneway的Binder的流程

假设线程A通过Binder接口int add(a, b)将a和b发送给线程B，然后线程B计算c=a+b，将c返回给线程A。简化一下步骤就是如图1.1

图1.1

二、如何将线程A优先级传递给线程B

我们先不看代码，自己想想如何实现这个需求。我们可以考虑在a，b的数据包中带上线程A的优先级参数，唤醒线程B的时候设置成A线程优先级，然后处理c=a+b，处理完成之后然后发送c的数据给线程A，发完之后，将线程B恢复成原来的线程优先级。其实Binder驱动也就是这样子实现。简化一下步骤就是如图2.1

图2.1

三、代码分析

看了图2.1中的红色字体，你会发现整个实现很简单，有种将大象装进冰箱总共需要三步一样简单，我们就来分析每一步是如何实现的。

3.1 将线程A的优先级打包进a，b的数据包

对于非oneway的方法，会将client端线程A也就是current的policy和normal_prio值打包进binder_transaction t->priority

    struct binder_transaction *t;

    if (!(t->flags & TF_ONE_WAY) &&
        binder_supported_policy(current->policy)) {
        /* Inherit supported policies for synchronous transactions */
                //将client端线程也就是current的policy和normal_prio值打包进binder_transaction
        t->priority.sched_policy = current->policy;
        t->priority.prio = current->normal_prio;
    } else {
        /* Otherwise, fall back to the default priority */
        t->priority = target_proc->default_priority;
    }

3.2 唤醒线程B之后，保存线程B的优先级参数，并设置成线程A的优先级

从binder_transaction中获取线程A的优先级参数desired_prio 保存线程B的优先级参数到t->saved_priority 设置线程B的优先级参数为desired_prio。注意：对于线程B返回给线程A的时候，不需要改变线程A的优先级

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)
{
....
        if (t->buffer->target_node) {
            struct binder_node *target_node = t->buffer->target_node;
            struct binder_priority node_prio;

            trd->target.ptr = target_node->ptr;
            trd->cookie =  target_node->cookie;
            node_prio.sched_policy = target_node->sched_policy;
            node_prio.prio = target_node->min_priority;
            //开始设置线程B的优先级
            binder_transaction_priority(current, t, node_prio,
                            target_node->inherit_rt);//跳转到3.2.1
            cmd = BR_TRANSACTION;
        } else { //对于server段返回给client端，不需要改变client端的线程优先级
            trd->target.ptr = 0;
            trd->cookie = 0;
            cmd = BR_REPLY;
        }
...
}

//3.2.1
static void binder_transaction_priority(struct task_struct *task,
                    struct binder_transaction *t,
                    struct binder_priority node_prio,
                    bool inherit_rt)
{
    //提取3.1保存的线程A的优先级，作为desired_prio
    struct binder_priority desired_prio = t->priority;
    //保存线程B的优先级到binder_transaction的saved_priority
    t->saved_priority.sched_policy = task->policy;
    t->saved_priority.prio = task->normal_prio;
        ...
    //设置线程B的优先级为desired_prio
    binder_set_priority(task, desired_prio);
}

3.3 恢复线程B的优先级

线程B返回结果的时候会调用这个代码唤醒线程A 将线程B的优先级恢复

    if (reply) {
        ...
        //唤醒线程A
        wake_up_interruptible_sync(&target_thread->wait);
        //将线程B的优先级恢复
        binder_restore_priority(current, in_reply_to->saved_priority);
                ...
    }