Binder“一次拷贝“你真懂吗，2024年最新15个经典面试问题和答案技巧大公开

2401_83944297

已于 2024-04-09 16:21:06 修改

阅读量1k

点赞数 17

分类专栏： 2024年程序员学习文章标签： binder 面试 linux

于 2024-04-09 16:21:04 首次发布

本文链接：https://blog.csdn.net/2401_83944297/article/details/137557211

版权

2024年程序员学习专栏收录该内容

279 篇文章 0 订阅

订阅专栏

Binder驱动源码中有很多地方都会出现这两个函数的调用。我们需要搞清楚每次调用都是在拷贝些什么东西，拷贝到哪里去了。
为了抓住本文的“一次拷贝”这个点，下面源码引用会尽量集中在和内存操作相关的代码而暂时略过其他代码。

下面我们就先从内存映射说起

Binder内存映射

ProcessState构造函数

ProcessState::ProcessState(const char *driver)
{
if (mDriverFD >= 0) {
// mmap the binder, providing a chunk of virtual address space to receive transactions.
mVMStart = mmap(nullptr, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);
}
}

注意mmap上方的注释，已经说的很清楚了，这块内存映射只是作为接收transactions来使用的，也就是说往驱动写数据的时候是与内存映射无关的。记住这一点。
下面我们看一下内核空间相应的调用：
binder_mmap

static int binder_mmap(struct file *filp, struct vm_area_struct *vma)
{
…
ret = binder_alloc_mmap_handler(&proc->alloc, vma);
…
}

真正的映射操作由函数binder_alloc_mmap_handler()完成。这里我们只需要记住这个函数的第一个入参&proc->alloc。通过这个结构体我们就能找到映射好的内存块。
内存映射完成之后，就让我们看一下Binder的传输过程中哪里使用到了这块特殊的内存。

Binder传输过程

传输过程我们只关注内存和数据。

发起方用户空间
发起方用户空间做的事情其实就像发快递一样不停的打包，注意一下都包了些啥。

IPCThreadState::writeTransactionData

// 我们要传输的数据在data这个入参中
status_t IPCThreadState::writeTransactionData(… const Parcel& data…)
{
binder_transaction_data tr;

…
//tr.data.ptr.buffer保存了指向data的指针
tr.data_size = data.ipcDataSize();
tr.data.ptr.buffer = data.ipcData();
tr.offsets_size = data.ipcObjectsCount()*sizeof(binder_size_t);
tr.data.ptr.offsets = data.ipcObjects();
…
// 将tr写入mOut。
mOut.writeInt32(cmd);
mOut.write(&tr, sizeof(tr));

return NO_ERROR;
}

这里tr只保存了指向数据的指针。然后tr被写入mOut这个Parcel。
IPCThreadState::talkWithDriver

status_t IPCThreadState::talkWithDriver(bool doReceive)
{
…

binder_write_read bwr;
…
bwr.write_size = outAvail;
bwr.write_buffer = (uintptr_t)mOut.data();
…
bwr.write_consumed = 0;
…
ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0
…
}

这里又包了一层，bwr。其中bwr.write_buffer保存了指向mOut.data()的指针。在这里也就是指向了tr。
所以在发起方：

bwr含有指向tr的指针。
tr含有指向data的指针。

记住上面两点，接下来我们看一下内核空间是怎么取包的：

发起方内核空间
binder_ioctl_write_read

static int binder_ioctl_write_read(struct file *filp,
unsigned int cmd, unsigned long arg,
struct binder_thread **threadp)
{ …
void __user *ubuf = (void __user *)arg;
struct binder_write_read bwr;
…
if (copy_from_user(&bwr, ubuf, sizeof(bwr))) {
ret = -EFAULT;
goto out;
}
…
ret = binder_thread_write(proc, *threadp,
bwr.write_buffer,
bwr.write_size,
&bwr.write_consumed);
}

这里我们遇到了第一个copy_from_user()调用。这个调用会把用户空间的bwr给拷贝到内核空间。但是要注意，copy_from_user()的第一个入参是拷贝的目标地址，这里给的是&bwr，函数内部的一个结构体。显然此处和内存映射没有关系。接下来就进入binder_thread_write。入参有bwr.write_buffer,回头看用户空间最底层那里，指向的是不是tr?

binder_thread_write

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)
{
void __user *buffer = (void __user *)(uintptr_t)binder_buffer;
void __user *ptr = buffer + *consumed;
…
case BC_TRANSACTION:
case BC_REPLY: {
struct binder_transaction_data tr;

if (copy_from_user(&tr, ptr, sizeof(tr)))
return -EFAULT;
ptr += sizeof(tr);
binder_transaction(proc, thread, &tr,
cmd == BC_REPLY, 0);
break;
}
…
}

这里我们遇到了第二个copy_from_user()。这回会把用户空间的那个tr,也就是IPCThreadState.mOut，给拷贝到内核中来，看它的第一个入参，还是和内存映射没有关系。接下来就进入关键的binder_transaction()了。

binder_transaction

static void binder_transaction(struct binder_proc *proc,
struct binder_thread *thread,
struct binder_transaction_data *tr, int reply,
binder_size_t extra_buffers_size)
{
…
struct binder_transaction *t;
…
t->buffer = binder_alloc_new_buf(&target_proc->alloc, tr->data_size,
tr->offsets_size, extra_buffers_size,
!reply && (t->flags & TF_ONE_WAY));
…
copy_from_user(t->buffer->data, (const void __user *)(uintptr_t)
tr->data.ptr.buffer, tr->data_size)
…
off_start = (binder_size_t *)(t->buffer->data +
ALIGN(tr->data_size, sizeof(void *)));
offp = off_start;
…
copy_from_user(offp, (const void __user *)(uintptr_t)
tr->data.ptr.offsets, tr->offsets_size);

}

首先看一下t->buffer，函数binder_alloc_new_buf()的返回值会赋值给它，这里是我们第一次见到这个函数，从名字看是分配内存，看它的第一个入参&target_proc->alloc。现在回想前面说mmap的时候提到内存映射的信息会保存到proc->alloc这个结构体中。所以这里我们就可以确定现在是在接收方进程的内存映射中分配了一块内存出来。t->buffer就指向这块有映射的内存。

接下来就是我们遇到的第三次copy_from_user()调用了。回想在用户空间的时候tr.data.ptr.buffer是指向我们要传输的数据的。所以这里可以看到这个copy_from_user()的操作就是把发起方用户空间的数据直接拷贝到了接收方内核的内存映射中。 这就是所谓“一次拷贝”的关键点。

紧接着还有一个copy_from_user()调用，这里拷贝的是和数据相关的一些跨境程对象的偏移量，和前面拷贝bwr和tr在体量上来讲与数据的体量相比不是主要矛盾，所以说“一次拷贝”指的就是上面对数据的拷贝。

至此关于“一次拷贝”这个问题我们应该是已经有了初步的答案了，但为了让整个过程形成个闭环，接下来我们再来看一下Binder传输过程的后半段。

接收方内核空间

binder_thread_read

static int binder_thread_read(struct binder_proc *proc,
struct binder_thread **threadp,
binder_uintptr_t binder_buffer, size_t size,
binder_size_t *consumed, int non_block)
{
…
void __user *buffer = (void __user *)(uintptr_t)binder_buffer;
void __user *ptr = buffer + *consumed;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数HarmonyOS鸿蒙开发工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年HarmonyOS鸿蒙开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。