此文档由AI生成
本文基于 Android 16(API 36)AOSP 源码,结合本仓库(
f:/Android16/Project/AndroidSourceCode)中的framework_base_core、framework_base_services_core、framework_native源码展开。 内核层(drivers/android/binder.c)不在本仓库内,按 AOSP 内核源码描述。 本文为上半部(第一、二章)。三大调用流程与源码清单见下半部《Binder跨进程通信详解(下)》。
目录
- 一、开篇:Binder 的由来、设计思路与架构
- 二、核心概念:binder_proc、binder_node、binder_ref、handle、flat_binder_object
一、开篇:Binder 的由来、设计思路与架构
1.1 为什么 Linux 原生 IPC 不够用
Android 需要一种面向对象的、有安全身份的、可复用对象引用的进程间通信机制,而 Linux 原生手段各有硬伤:
| 机制 | 问题 |
|---|---|
| 管道 / 消息队列 / 信号量 | 面向字节流/无类型,无对象概念;没有身份认证(任何进程可读) |
| Socket | 通用但开销大(两次拷贝 + 协议栈),无 UID/PID 安全模型 |
| 共享内存 | 最快但完全无同步、无安全,需要额外机制配合 |
| 传统 RPC(CORBA/D-Bus) | 依赖用户态守护进程中转,多一跳;且非内核原生 |
Android 的需求本质是:
- 性能:IPC 是全系统最高频操作(AMS、WMS、PMS……),必须接近函数调用级别的开销;
- 安全:Android 是沙箱模型,每次 IPC 都要校验调用者 UID/PID,内核必须能提供可信的调用者身份;
- 对象语义:希望像调用本地对象一样调用远端对象(引用传递、引用计数、生命周期、死亡通知);
- 稳定性:避免一层用户态守护进程成为单点故障。
1.2 Binder 的由来
Binder 并非 Google 从零发明。它源自 OpenBinder 项目:
- 最初由 Be Inc. 开发(BeOS 系统),后随 PalmSource(Palm OS)继续演进;
- Android 之父 Andy Rubin 的团队加入 Google 前在 Palm 工作,Android 吸收了 OpenBinder 的核心设计;
- 后来长期维护者 Dianne Hackborn(frameworks 团队)正是 OpenBinder 的作者之一。
OpenBinder 的核心遗产被完整继承进 Android:
IBinder/BBinder/BpBinder的命名与对象模型(Bp= Binder proxy,BB= Binder "本端"对象);- 内核态驱动 + 用户态代理/桩的三层结构;
- Parcell 序列化、引用计数、死亡通知。
Android 对其做了大量改造:重写为 C++/Java 双运行时(libbinder + framework Binder JNI)、加入 SELinux/UID 安全模型、加入 servicemanager 命名服务、引入匿名共享内存的一次拷贝传输、以及后来的 Binder RPC(socket 传输)。
1.3 Binder 的设计思路
核心思想:用内核维护"跨进程对象引用"的语义。
-
对象身份由内核担保 每个可被远端访问的对象对应内核里的一个
binder_node(宿主进程 + 本地指针)。跨进程传递对象时,内核为接收方进程分配一个本地编号handle(binder_ref),并保证:同一对象在同一进程内永远对应同一个 handle,对象销毁时引用计数与死亡通知由内核驱动。 -
一次拷贝(zero-copy 的变体) —— 详见下方 1.3.1 的完整展开。
-
内核提供可信身份 事务由内核投递,
callingPid / callingUid由内核填写,用户态无法伪造——这是 Android 权限模型的基石。 -
代理/桩(Proxy/Stub)自动生成 AIDL 编译器生成
Stub(服务端基类)和Proxy(客户端代理),开发者只面向接口编程。 -
按需线程池 + 同步/异步两种语义 每个进程默认启动若干 binder 线程处理入站事务;同步调用等待 reply,
oneway(FLAG_ONEWAY)投递后立即返回。 -
命名服务解耦
servicemanager是唯一的全局权威(handle 0),负责"名字 → 引用"的注册与查找,其余一切对象引用都通过已有引用逐级传递获得(能力传递模型)。
1.3.1 深入理解"一次拷贝"(binder_mmap 机制)
先精确化你的理解:"客户端的数据被拷进服务端的 binder buffer"这个方向是对的,但有两个关键点要修正——
- 这个"服务端的 buffer"不是驱动里的普通内核缓冲,而是服务端进程自己 mmap 出来的那块内存;
- 完成这次拷贝的执行者是内核驱动(
copy_from_user),而发送方和接收方的用户态全程都不动手。精确的说法是:驱动把"发送方用户态内存"里的数据,直接拷进"接收方 mmap 区域中切出来的一块 buffer"里——这一次拷贝就是数据的唯一一次搬运,接收方之后直接从自己地址空间里读,不再有第二次拷贝。
(1)对比:为什么常规 IPC 是两次拷贝
常规管道/Socket(两次拷贝):
发送方用户内存 ──copy_from_user──► 内核缓冲区 ──copy_to_user──► 接收方用户内存
① ②
binder(一次拷贝):
发送方用户内存 ──copy_from_user──► 接收方 mmap 区域内的一块 binder_buffer
①(唯一一次) └─ 接收方地址空间里,直接读,零拷贝
省掉第二次拷贝的诀窍在于:接收方的 mmap 区域本来就是"内核可见 + 用户态可见"的同一块物理内存。内核写进去的数据,接收方立刻能在自己的虚拟地址上读到,根本不需要"内核缓冲区"这个中转站。
注意:"一次拷贝"的度量单位是"单次事务(单方向数据搬运)",不是"一次 IPC 调用"。 一次同步调用 = 请求事务 + 回复事务两个事务,总共 2 次拷贝:
传统 pipe/socket(同步一来一回 = 4 次拷贝):
请求:发送方用户 → 内核缓冲 → 接收方用户 (2 次)
回复:服务方用户 → 内核缓冲 → 客户方用户 (2 次)
binder(同步一来一回 = 2 次拷贝):
请求:client 用户 → service 的 mmap buffer (1 次,copy_from_user)
回复:service 用户 → client 的 mmap buffer (1 次,copy_from_user)
即 binder 把"每方向搬运"从 2 次压到 1 次,省掉的是内核缓冲区中转站;总拷贝数 = 事务数 × 1:
- oneway 调用(如流程二 register):1 个事务 → 1 次拷贝
- 同步带返回值(如流程三 setStudentInfo):2 个事务 → 2 次拷贝
- 请求和回复分别占用接收方的 mmap 配额(大返回值消耗的是 client 的 1MB 配额)
(2)mmap 阶段:区域是怎么建立的
每个进程在使用 binder 前都会执行(ProcessState 构造函数里,每进程仅一次):
// framework/native/libs/binder/ProcessState.cpp
#define BINDER_VM_SIZE ((1 * 1024 * 1024) - sysconf(_SC_PAGE_SIZE) * 2) // ≈1MB
mVMStart = mmap(nullptr, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE,
opened.get(), 0);
内核侧 binder_mmap() 做了三件重要的事:
- 只允许 PROT_READ:用户态对这块区域的权限被强制降为只读(驱动会清掉
VM_MAYWRITE,显式传 PROT_WRITE 会直接失败)。这是刻意的安全设计——用户态只能"读"送来的事务数据,不能"写",防止进程伪造/篡改属于其他事务的数据; - 内核保留自己的映射:这块物理内存同时被映射进内核地址空间,驱动可以任意读写它;
- 登记到
binder_alloc:把区域信息(起始地址、总大小、页表)记入binder_proc->alloc,此后驱动从这个区域里按需"切"buffer 分配给事务。
也就是说:一块 ≈1MB 的区域,用户态只读视角,内核读写视角,两端指向同一份物理页。
(3)binder_buffer 的申请流程:不是启动时申请,而是"按需切分"
这是最容易误解的一点。进程启动(准确说是进程首次使用 binder 时)只做"圈地",不申请任何事务缓冲;真正的 binder_buffer 是每来一个入站事务时,由驱动从那块区域里现切出来的;物理页也是按需分配的。
① 时间线:什么时候发生了什么
| 时机 | 动作 | 实际内存占用 |
|---|---|---|
| 进程首次用 binder(open + mmap) | open("/dev/binder") 建 binder_proc;mmap(1MB, PROT_READ, MAP_NORESERVE) 建立虚拟地址区域;binder_mmap 初始化 binder_alloc(记录 vma、起止地址、大小、页表数组) | 只占虚拟地址空间。MAP_NORESERVE + 页未被访问 → 物理页为 0 |
| 第一个入站事务到达 | binder_alloc_new_buf():空闲池为空 → kzalloc 出一个 binder_buffer 元数据 → 从区域头部划一块 → binder_update_page_range() 逐页 alloc_page | 按该事务大小分配物理页(首次) |
| 后续每个入站事务 | best-fit 从空闲 buffer 链表里挑可用的搬运;不够则切新块/补物理页 | 复用为主,按需追加 |
接收方处理完,发 BC_FREE_BUFFER | binder_alloc_free_buf():删掉 buffer 元数据,与前后空闲块合并(coalesce) | 物理页保留在内核,不归还系统 |
| 进程退出 / fd 关闭 | binder_deferred_release() → binder_alloc_free_page_range() | 全部物理页归还 |
①′ 谁触发了 open("/dev/binder")?
结论:不是"进程一启动就自动 open",而是"进程内第一次真正需要 binder 的调用"触发的;而且在 Android 11+ 上,这个调用必然发生在 fork() 之后——因为 fork 出的子进程会主动关掉从父进程继承的 binder fd。
(a)触发链:所有路径最终都收敛到 ProcessState::self()
某处第一次使用 binder
↓
ProcessState::self() // ProcessState.cpp
↓
ProcessState::init(driver = "/dev/binder", requireDefault = true)
↓
std::call_once(gProcessOnce) { ... } // 全进程仅执行一次
├─ pthread_atfork(onFork, parentPostFork, childPostFork) // 注册 fork 保护
└─ gProcess = sp<ProcessState>::make(driver)
↓
ProcessState 构造函数
├─ open_driver("/dev/binder") // ★ open() 在这里发生
└─ mmap(BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE|MAP_NORESERVE, fd, 0)
IPCThreadState::self()(每线程事务状态)内部同样会调 ProcessState::self(),所以任何一次 transact 都足以触发初始化。
(b)具体是哪些场景在触发
| 场景 | 触发点 | 时机 |
|---|---|---|
| 普通 App 进程 | ZygoteInit.nativeZygoteInit() → JNI com_android_internal_os_ZygoteInit_nativeZygoteInit → AppRuntime::onZygoteInit() → ProcessState::self()->startThreadPool() | zygote fork 之后、Java main 之前 |
| App 进程(第二条) | RuntimeInit.nativeFinishInit() → AppRuntime::onStarted() → ProcessState::self() | RuntimeInit 收尾时(幂等,返回已有单例) |
| system_server | 由 zygote fork 后走 RuntimeInit → onStarted() → ProcessState::self() | 系统服务启动前 |
| servicemanager | 自己的 main() 中 open /dev/binder 并 BINDER_SET_CONTEXT_MGR 声明自己为 handle 0 | 系统启动最早(早于 zygote) |
| native 系统服务(audioserver/cameraserver/…) | main() 里 ProcessState::self() 或 defaultServiceManager() | 进程启动即用 |
| vendor 进程 | ProcessState::initWithDriver("/dev/vndbinder") | 使用独立的 vndbinder 域 |
| HIDL/HWBinder | hwbinder 库(android::hardware)自行 open /dev/hwbinder | 与 libbinder 不同库 |
对应的 JNI 映射在本仓库可查:
// framework/base/core/jni/AndroidRuntime.cpp
static void com_android_internal_os_RuntimeInit_nativeFinishInit(JNIEnv* env, jobject clazz)
{
gCurRuntime->onStarted(); // ← AppRuntime::onStarted() → ProcessState::self()
}
static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
gCurRuntime->onZygoteInit(); // ← AppRuntime::onZygoteInit() → ProcessState::self()
}
①″ 精确回答:Zygote fork 出来的进程,是立刻 open 还是等第一次 IPC 才 open?
答案:App 进程在 fork 完成后、执行 Java main 之前就已经 open 了,不等第一次 IPC;只有纯 native 进程才是"首次用到才 open"。
判断依据不是"何时发起 IPC",而是"何时执行到 ProcessState::self()"——这一步是唯一的触发条件。而 Zygote 子进程的启动路径里无条件调用了它。
(1)App 进程:fork 后立即 open(eager)
// framework/base/core/java/com/android/internal/os/ZygoteConnection.java:504
private Runnable handleChildProc(ZygoteArguments parsedArgs,
FileDescriptor pipeFd, boolean isZygote) {
closeSocket();
Zygote.setAppProcessName(parsedArgs, TAG);
...
if (!isZygote) {
return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,
parsedArgs.mDisabledCompatChanges,
parsedArgs.mRemainingArgs, null /* classLoader */);
// framework/base/core/java/com/android/internal/os/ZygoteInit.java:976
public static Runnable zygoteInit(int targetSdkVersion, long[] disabledCompatChanges,
String[] argv, ClassLoader classLoader) {
...
RuntimeInit.commonInit();
ZygoteInit.nativeZygoteInit(); // ★ 无条件调用,与"是否要 IPC"完全无关
return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv,
classLoader);
}
再往下就是本仓库能看到的 JNI 映射:
ZygoteInit.nativeZygoteInit() (Java)
→ com_android_internal_os_ZygoteInit_nativeZygoteInit (framework/base/core/jni/AndroidRuntime.cpp:275)
→ AppRuntime::onZygoteInit() (frameworks/base/cmds/app_process/app_main.cpp)
sp<ProcessState> proc = ProcessState::self(); // ★ open("/dev/binder") + mmap
proc->startThreadPool(); // ★ 顺便把 binder 线程池拉起来
所以 App 进程的时间线是:
fork() 返回 → handleChildProc → zygoteInit() → nativeZygoteInit()
→ ProcessState::self() ← 此刻 open("/dev/binder"),可能一次 IPC 都还没发生
→ startThreadPool() ← 此刻已经能接收别的进程发来的 binder 调用
→ RuntimeInit.applicationInit() → 加载 App 类 → main()
一个强有力的旁证:同一文件里专供"子 zygote"使用的另一条路径故意跳过这一步,注释写得很直白——
// framework/base/core/java/com/android/internal/os/ZygoteInit.java:991
/**
* The main function called when starting a child zygote process. This is used as an alternative
* to zygoteInit(), which skips calling into initialization routines that start the Binder
* threadpool.
*/
static Runnable childZygoteInit(String[] argv) { ... } // 不含 nativeZygoteInit()
(2)对照:谁才是"懒加载"
| 进程类型 | 何时 open("/dev/binder") | 属于 | 备注 |
|---|---|---|---|
| 普通 App 进程(含 USAP 池里的进程) | fork 后立即(zygoteInit() → nativeZygoteInit()) | eager | 早于 App 的 main(),也早于任何 IPC |
| system_server | fork 后立即(走同一 zygoteInit() 路径) | eager | 之后才 startBootstrapServices |
子 zygote(--start-child-zygote) | 不主动 open | lazy | childZygoteInit() 显式跳过 |
| 纯 native 进程(audioserver 等) | main() 里首次 ProcessState::self() / defaultServiceManager() | lazy | 通常也在 main 早段完成 |
| servicemanager | 自己 main 里 open(最早) | eager | 并 BINDER_SET_CONTEXT_MGR |
(3)为什么 App 进程不能"懒"到第一次 IPC
因为 App 随时可能被别人先调用:AMS 要回调 ApplicationThread、Service.onBind 结果要 publish、BroadcastReceiver 要投递——这些入站事务要求进程的 binder 线程池已经就绪。如果等到 App 自己第一次主动 IPC 才初始化,就会出现"别人调不进来"的死循环式问题(尤其在冷启动阶段),所以 Zygote 在子进程一落地就把它准备好。
(4)一句话记忆
open("/dev/binder")的触发点是ProcessState::self();App 进程的启动路径在 fork 后无条件执行它,所以是"进程起来就 open";native 进程没人替它调用,所以表现为"首次用到才 open"。"是否要通信"不是触发条件,"是否执行到这个单例初始化"才是。
(c)为什么必须"fork 之后"才 open:libbinder 的 fork 保护
这一条非常关键,直接解释了"进程首次用 binder"的真实含义。ProcessState::init() 里注册了 pthread_atfork 回调,fork 的子进程会主动废掉继承来的 binder 会话:
// framework/native/libs/binder/ProcessState.cpp
static void verifyNotForked(bool forked) {
LOG_ALWAYS_FATAL_IF(forked, "libbinder ProcessState can not be used after fork");
}
void ProcessState::childPostFork() {
if (gProcess) {
gProcess->mForked = true;
// "O_CLOFORK"
close(gProcess->mDriverFD); // ★ 子进程关闭继承的 fd
gProcess->mDriverFD = -1;
}
gProcessMutex.unlock();
}
由此推出三条事实:
- fd 不继承:子进程即使继承了
fd数字也拿不到同一个 binder 会话(已被显式close,语义等同O_CLOFORK),因为内核的binder_proc与struct file绑定,父子共享一个binder_proc在语义上是错的(handle 表、线程池、mmap 缓冲都是进程私有的); - 在 fork 前初始化过 binder 的进程,子进程用它就会 fatal:
verifyNotForked(gProcess->mForked)直接LOG_ALWAYS_FATAL。这就是为什么 Zygote 父进程不使用 binder——它只用 socket(/dev/socket/zygote)接收请求,保证gProcess == nullptr,子进程才能干净地重新初始化; - 每个进程的
open()恰好一次:std::call_once(gProcessOnce)保证;若进程需要多个 binder 域(binder + vndbinder),则用ProcessState::initWithDriver("/dev/vndbinder")(selfOrNull()/独立实例),仍是一域一 open。
(d)Java 层的"看起来是第一次用 binder"其实是间接的
Java 代码里第一次跨进程调用形如 ActivityManager.getService().xxx(),其底层是 BinderProxy.transactNative → JNI → BpBinder::transact → IPCThreadState::self() → ProcessState::self()。也就是说:
- Java 侧没有"打开驱动"的 API,只有 C++ 侧的单例初始化;
- 但实践中 App 进程在跑 Java 代码之前(
onZygoteInit)就已经把驱动打开了,所以 Java 层的第一次调用只是"复用已初始化的会话"; - 反过来,如果一个纯 native 进程从未调用
ProcessState::self()/defaultServiceManager(),那它永远不会有 binder fd,也就收不到任何 binder 事务。
(e)失败表现
// ProcessState.cpp: open_driver()
if (access(driver, R_OK) == -1) {
ALOGE("Binder driver %s is unavailable. Using /dev/binder instead.", driver);
- 设备节点不存在 / SELinux 禁止 →
open失败 →mDriverFD = -1,后续getContextObject()返回 null(日志Not able to get context object on /dev/binder.); - 内核未编 binder 驱动 → 同上;
- 编译期
!kEnableKernelIpc(非 Linux 平台/RPC-only 构建)→ 相关路径直接LOG_ALWAYS_FATAL,只能用 Binder RPC。
② 两个不同的"申请"要分清
| 虚拟地址空间 | 物理页 / buffer | |
|---|---|---|
| 何时 | mmap 那一刻(进程首次用 binder) | 每个入站事务到达时 |
| 大小 | 固定 ≈1MB(BINDER_VM_SIZE) | 按事务 data_size + offsets_size 对齐后切分,最少一页 |
| 谁分配 | mmap + binder_alloc 记元数据 | binder_alloc_new_buf → alloc_page |
| 释放 | munmap(进程退出) | 物理页保留到进程退出;buffer 元数据在 BC_FREE_BUFFER 时销毁 |
③ binder_alloc(每进程一份的区域管理员)
// drivers/android/binder_alloc.h(简化)
struct binder_alloc {
struct mutex mutex;
struct vm_area_struct *vma; // mmap 出的用户态区域
struct mm_struct *mm;
void __user *buffer; // 用户态起始地址(接收方视角)
size_t buffer_size; // ≈1MB(减去 2 页)
struct list_head buffers; // 所有 buffer(空闲+占用),按地址升序,便于合并
size_t free_async_space; // 异步配额,初始 = buffer_size / 2
struct page **pages; // 页描述符数组(按需填充)
size_t page_count; // 当前已分配的物理页数(懒增长)
...
};
它挂在 binder_proc->alloc 上,所以**"1MB 配额"是每进程独立计算的**,不是全系统共享。
④ binder_buffer(单笔事务的容器,元数据在堆上,数据在 mmap 区)
// drivers/android/binder_alloc.h(简化)
struct binder_buffer {
struct list_head entry; // 挂 binder_alloc.buffers(按地址排序 → 便于前后合并)
unsigned free:1; // 空闲标
unsigned allow_user_free:1;
unsigned async_transaction:1; // 是否 oneway(影响异步配额归还)
struct binder_transaction *transaction;
struct binder_node *target_node;
size_t data_size; // 有效数据长度
size_t offsets_size; // binder 对象偏移表长度
size_t extra_buffers_size; // BINDER_TYPE_FDA/PTR 等附加缓冲
struct binder_alloc *alloc;
uint8_t data[]; // ★ 数据本体,落在 mmap 区域里(不是这块结构体内存)
};
注意区分:struct binder_buffer 本身是内核堆上的一小块元数据;data[] 指向的是 mmap 区域内的地址。用户态完全看不到 binder_buffer 结构,只看到 data 部分的地址。
⑤ 切分流程(binder_alloc_new_buf_locked 逻辑)
输入:data_size、offsets_size、extra_buffers_size、is_async
1. need = ALIGN(data_size) + ALIGN(offsets_size) + extra_buffers_size
2. 遍历 alloc->buffers,找 free && size >= need 的最小块(best-fit)
├─ 命中:
│ · 若块比 need 大很多 → split:尾部剩余重新变成空闲 binder_buffer
│ · binder_update_page_range():确保 [起始, 起始+need) 的物理页已就绪 │ (没有就 alloc_page 补上;MAP_NORESERVE 的懒分配发生在这里) │ · buffer->free = 0,返回 └─ 未命中: · 剩余空间够 → 在空闲区尾部切一个全新 buffer(kzalloc 元数据),补页 · 剩余空间不够 → 返回 ERR_PTR(-ENOSPC)3. is_async(oneway): free_async_space -= (data_size + offsets_size) 不足则 ENOSPC(异步事务额外受"总量一半"约束)4. 返回 buffer → binder_transaction 调用 copy_from_user 把发送方数据拷进来(唯一一次拷贝)
失败时驱动回 BR_FAILED_REPLY,用户态 IPCThreadState 得到 FAILED_TRANSACTION,Java 层最终抛 TransactionTooLargeException。
⑥ 三个常见误解
| 误解 | 事实 |
|---|---|
| "进程启动就申请 1MB 物理内存" | 只 mmap 虚拟地址(MAP_NORESERVE),物理页在事务到达时才 alloc_page,alloc->page_count 懒增长 |
| "每个事务单独 malloc 一块内存" | 全部从同一块 mmap 区域切分,binder_buffer 只是切分账本;BC_FREE_BUFFER 后可被任意后续事务复用 |
| "1MB 是单个事务的上限" | 1MB 是该进程所有在途事务的总量;单个大事务受它约束,但真正的失败常来自"旧 buffer 没释放导致累积占满" |
⑦ 相关源码
| 层 | 文件 | 关键函数 |
|---|---|---|
| 用户态 | framework/native/libs/binder/ProcessState.cpp | mmap 建立区域(BINDER_VM_SIZE) |
| 用户态 | framework/native/libs/binder/IPCThreadState.cpp | freeBuffer(发 BC_FREE_BUFFER)、executeCommand |
| 内核 | drivers/android/binder.c | binder_mmap、binder_transaction(调用 binder_alloc_new_buf)、binder_deferred_release |
| 内核 | drivers/android/binder_alloc.c / binder_alloc.h | binder_alloc_new_buf_locked、binder_alloc_free_buf、binder_update_page_range、binder_alloc_new_buf(异步配额) |
(4)发送阶段:唯一的那次拷贝发生在哪
当 client 发起 BC_TRANSACTION 时,binder_write_read.write_buffer 里携带的是小事务头 + 发送方 Parcel 数据在自己用户态的地址(binder_transaction_data 的 data.ptr.buffer / data_size)。驱动在 binder_transaction() 中:
1. binder_alloc_new_buf(target_proc->alloc, size)
→ 从【接收方】进程的 mmap 区域里切出一块空闲 buffer
(注意:buffer 属于接收方的区域,不是发送方的,也不是独立的内核堆)
2. binder_alloc_copy_data_to_buffer / copy_from_user
→ 把发送方用户内存中的 Parcel 数据,拷进这块 buffer ★ 全程唯一的一次数据搬运
3. 对 buffer 内的 flat_binder_object 原地改写(对象翻译,见第二章 2.6)
4. 组装 binder_transaction_data,data.ptr.buffer 填成【接收方地址空间里的虚拟地址】
→ 放入接收方线程的 todo,唤醒
(5)接收阶段:为什么第二次拷贝消失了
接收方 binder 线程被 BR_TRANSACTION 唤醒后,拿到的 data.ptr.buffer 是自己地址空间里的地址(就在它 mmap 的那 1MB 内):
// IPCThreadState::executeCommand 中
reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer) // ← 直接当普通内存读
数据已经躺在它的用户虚拟地址上了,JavaBBinder::onTransact 直接把这块内存包装成 Parcel 读——没有任何内核/用户态之间的第二次搬运。
用完后接收方必须发 BC_FREE_BUFFER 把 buffer 还给驱动的空闲池(否则这块区域被占满,进程的 binder 通道整体堵死)。
(6)由此产生的几个著名现象
| 现象 | 根源 |
|---|---|
TransactionTooLargeException | 事务数据超过 mmap 区域剩余空间(单进程总量 ≈1MB)时驱动分配失败,回 BR_FAILED_REPLY,Java 层抛出。所以官方建议单笔事务 ≤ 500KB |
| 异步(oneway)事务单笔上限 ≈ 512KB | 驱动为异步事务预留一半配额(binder_alloc 的 async free space 检查),防止 oneway 大包把同步事务饿死 |
| oneway 大量发送会堵死整个进程 | 异步事务只有等接收方 BC_FREE_BUFFER 后才释放,积压会把 1MB 区域占满,之后连别人的同步事务也进不来(对应 Android 11+ 的 oneway spam 检测,DEFAULT_ENABLE_ONEWAY_SPAM_DETECTION) |
| 大文件/位图不用 binder 直传 | 1MB 硬上限 → 大数据走共享内存(ashmem / IMemory / Parcelable blob),binder 只传 fd 或引用 |
(7)为什么不做"真·零拷贝"
理论上可以让发送方直接写进接收方的 mmap 页(零次拷贝),但没这么做,原因:
- 安全:数据必须先经过内核校验(对象翻译、UID/PID 注入、SELinux、buffer 边界检查),"发送方直接写接收方内存"会绕开全部检查点;
- 同步复杂度:发送方写一半接收方就读、页共享的引用管理、跨进程页错误处理,复杂度远超省下的一次拷贝;
- 收益有限:一次
copy_from_user本身很快(memcpy 级),binder 调用的主要开销在 ioctl/上下文切换/线程唤醒上。
一句话总结:mmap 的区域是"接收方的地盘、内核的后厨"——驱动从接收方地盘里切一块 buffer,把发送方用户内存里的数据直接端进去,这是唯一一次拷贝;接收方在自己家直接吃,不再搬运。
(8)相关源码
| 层 | 文件 | 关键函数/代码 |
|---|---|---|
| 用户态 | framework/native/libs/binder/ProcessState.cpp | BINDER_VM_SIZE、mmap(...)、open_driver |
| 用户态 | framework/native/libs/binder/IPCThreadState.cpp | talkWithDriver(组装 binder_write_read)、executeCommand(BR_TRANSACTION 直接读 mmap 地址)、freeBuffer |
| 内核 | drivers/android/binder.c | binder_mmap(清 VM_MAYWRITE、登记 alloc) |
| 内核 | drivers/android/binder_alloc.c / .h | binder_alloc_new_buf(切 buffer)、async 配额检查、binder_alloc_free_buf |
1.4 Binder 整体架构(四层)
┌─────────────────────────────────────────────────────────────────────┐
│ ① 应用/框架层 (Java) │
│ AIDL 接口、Stub/Proxy、Binder/BinderProxy/Parcel │
│ frameworks/base/core/java/android/os/* │
├─────────────────────────────────────────────────────────────────────┤
│ ② JNI 层 │
│ Java↔C++ 桥:android_util_Binder.cpp、android_os_Parcel.cpp │
│ frameworks/base/core/jni/* │
├─────────────────────────────────────────────────────────────────────┤
│ ③ libbinder (C++ 用户态) │
│ ProcessState / IPCThreadState / BpBinder / BBinder / Parcel │
│ frameworks/native/libs/binder/* │
├─────────────────────────────────────────────────────────────────────┤
│ ④ 内核 binder 驱动 │
│ /dev/binder,binder_proc/binder_node/binder_ref │
│ kernel drivers/android/binder.c │
└─────────────────────────────────────────────────────────────────────┘
│
└── 全局单例:servicemanager(frameworks/native/cmds/servicemanager)
用户态守护进程,占用 handle 0,提供"服务名 → 引用"的注册与查询
一次典型调用的穿透路径:
Java Proxy.transact()
→ BinderProxy.transactNative() [Java → JNI]
→ android_os_BinderProxy_transact() [JNI]
→ BpBinder::transact() [libbinder]
→ IPCThreadState::transact()
→ writeTransactionData + talkWithDriver
→ ioctl(fd, BINDER_WRITE_READ) [用户态 → 内核]
→ binder_ioctl → binder_transaction [内核]
→ 目标进程 binder 线程被唤醒
→ BBinder::onTransact → JavaBBinder::onTransact → Java Stub.onTransact()
1.5 binder 驱动:概念与作用
binder 驱动是一个字符设备驱动,位于内核 drivers/android/,设备节点传统上是 /dev/binder(Android 11+ 使用 binderfs 挂载,如 /dev/binderfs/binder,另有 hwbinder、vndbinder 分域)。
它承担六大职责:
-
打开即建会话(binder_proc) 进程
open("/dev/binder")时,驱动创建binder_proc,记录该进程的 handle 表(nodes、refs_by_node、refs_by_desc三棵红黑树)、线程列表、内存映射信息。每个进程只 open 一次,fd 存于ProcessState::mDriverFD。 -
全局对象登记簿(binder_node / binder_ref)
binder_node:远端可访问对象的唯一实体,归属于宿主进程,key 是(proc, 用户态指针);binder_ref:某进程对某 node 的引用,含编号desc(即 handle),每进程各有一套编号空间;- 这正是"跨进程对象引用计数"的实现处。
-
事务路由(binder_transaction) 解析
BC_TRANSACTION:按 target.handle 查 ref → node → 宿主进程 → 选一条空闲 binder 线程投递;同时翻译事务数据里的所有 binder 对象(binder_translate_binder/binder_translate_handle,详见下文流程)。 -
一次拷贝内存(binder_mmap / binder_alloc) 进程 mmap 一块虚拟内存(默认约 1MB,异步事务各限 200KB 的一半配额),驱动把发送方数据
copy_from_user进这块缓冲,接收方直接从映射区读——两次拷贝变一次。 -
身份注入
binder_transaction里携带调用者pid/uid/euid,内核填、内核核验,配合 SELinux(binder类)做逐次调用的授权检查。 -
生命周期与死亡通知 BC_INCREFS/ACQUIRE/RELEASE/DECREFS 维护强/弱引用;强引用归零触发
BR_DEAD_BINDER回调linkToDeath注册的接收者;BR_DEAD_REPLY/BR_FAILED_REPLY报告远端已死。
通信协议:用户态→驱动是 BC_* 命令(BC_TRANSACTION、BC_ACQUIRE…),驱动→用户态是 BR_* 命令(BR_TRANSACTION、BR_REPLY、BR_SPAWN_LOOPER…),二者在 BINDER_WRITE_READ 的 read/write buffer 中成对搬运。
1.6 文件描述符:概念与作用
文件描述符(fd) 是 Unix 的基本抽象:进程通过 open() 获得一个非负整数,作为"进程 → 内核对象"的引用编号;后续 read/write/ioctl/close 都以它为句柄。每个进程有自己的 fd 表,同一个 fd 数字在不同进程可以指向不同内核对象——这与 binder handle 的思想完全同构:
| 文件描述符 | Binder handle | |
|---|---|---|
| 内核对象 | struct file / 设备实例 | binder_node |
| 进程私有编号 | fd 表下标 | binder_ref.desc |
| 获得方式 | open()/dup()/recvmsg 传递 | 内核翻译 binder 对象时分配 |
| 归还 | close() | ref 计数归零后回收复用 |
| 作用域 | 单进程内唯一有效 | 单进程内唯一有效 |
在 Binder 中,fd 的具体作用:
open("/dev/binder")得到 fd → 每个 binder 操作(ioctl(fd, BINDER_WRITE_READ, ...))都通过它进行;ProcessState持有这个 fd(mDriverFD),整个进程共享一个 binder 会话;- fd 本身也可以跨进程传递——驱动支持
BINDER_TYPE_FD对象,把一个进程的 fd 转换成另一个进程指向同一内核struct file的新 fd(binder 事务数据中的文件对象自动完成 dup),这是 ParcelFileDescriptor 的实现基础; - 通过 fd,用户态永远无法绕过驱动直接操作 binder 状态——所有状态变更都经过内核校验,这是安全模型的一部分。
二、核心概念:binder_proc、binder_node、binder_ref、handle、flat_binder_object
Binder 驱动是一段有状态的内核代码——它要在内核里替所有进程记住"谁拥有哪个对象、谁引用了哪个对象、每个引用编号是多少"。这句话里的"谁拥有""谁引用""编号",分别就是 binder_node、binder_ref、binder_proc 要干的事。
先给一张全景关系图,后面逐个展开:
┌─────────────────────────────────────────────┐
│ binder 驱动(内核) │
│ │
进程A │ binder_proc(A) binder_proc(B) │ 进程B
┌───────┐ │ ┌─────────────┐ ┌─────────────┐ │ ┌───────┐
│ fd=5 ─┼─open─────┼─►│ nodes: │ │ refs_by_desc│◄─┼─┤ fd=7 │
└───────┘ │ │ node1 │◄─owner───┤ desc=3→n1 │ │ └───────┘
│ └─────────────┘ └─────────────┘ │
│ ▲ │ │
│ └───── binder_ref ──────┘ │
│ (B 对 A 的 node1 的引用) │
└─────────────────────────────────────────────┘
用户态对应:
ProcessState(mDriverFD=5) ProcessState(mDriverFD=7)
BBinder(本地对象) ←→ node1 BpBinder(handle=3) ←→ binder_ref
一句话分工:
- binder_proc = 驱动视角下的"进程档案"(fd 的幕后实体);
- binder_node = "这个远端对象本体是什么、归谁所有";
- binder_ref = "B 进程手里那张引用票据";
- handle(desc) = 票据上的编号;
- flat_binder_object = 票据在 Parcel 里的书写格式。
2.1 binder_proc:驱动视角下的进程档案
为什么需要它? binder 是有状态 IPC:handle 只在本进程有意义、mmap 缓冲是进程私有的、线程池要逐进程管理。驱动必须能从 fd 一路查到"这是哪个进程、它有哪些对象、哪些引用、哪些线程"——这个档案就是 binder_proc。
何时创建/销毁:
open("/dev/binder")→ 驱动binder_open()创建binder_proc,与该次打开产生的struct file私有数据绑定;- 每个 binder 命令
ioctl(fd, BINDER_WRITE_READ, ...)都由 fd 找到 file → 找到binder_proc; - fd 关闭 →
binder_deferred_release():清理该进程的 node/ref/线程/缓冲。所以 Zygote fork 出的进程共享?不——fork 后子进程会各自重新 open(ProcessState 有 fork 保护verifyNotForked),每个进程一个 proc。
结构成员(简化自 drivers/android/binder_internal.h,保留关键注释):
struct binder_proc {
/* —— 链入全局 —— */
struct hlist_node proc_node; // 挂到全局 proc 链表(binder_procs)
struct mutex proc_lock;
/* —— 三棵红黑树:本进程的对象与引用 —— */
struct rb_root nodes; // 本进程【拥有】的 binder_node,key = 本地对象指针
struct rb_root refs_by_desc; // 本进程【持有】的 binder_ref,key = desc(handle)
struct rb_root refs_by_node; // 同一批 ref,key = node 指针(用于"我是否已引用过它"的查询)
/* —— 线程管理 —— */
struct list_head todo; // 尚无归属线程的待处理事务
struct rb_root threads; // 本进程的全部 binder_thread,key = pid
int requested_threads; // 驱动要求进程 spawn 的线程数(BR_SPAWN_LOOPER)
int requested_threads_started;
int tmp_ref;
/* —— 一次拷贝内存 —— */
struct binder_alloc alloc; // mmap 缓冲区管理(默认约 1MB,异步各占一半配额)
/* —— 身份与状态 —— */
kuid_t default_priority; // 调度优先级信息
struct pid *pid; // 所属进程(安全模型用)
kuid_t uid;
char *comm; // 进程名(日志用)
bool is_dead; // 进程已退出,node 待清理
struct binder_context *context; // 所属 binder context(binder/hwbinder/vndbinder 分域)
...
};
三个红黑树的分工务必分清:
| 红黑树 | 存什么 | key | 什么时候查 |
|---|---|---|---|
nodes | 自己拥有的对象 | 用户态对象指针 | 本地对象第一次跨进程传出时(binder_get_node/binder_new_node) |
refs_by_desc | 自己持有的引用 | handle(desc) | 每次按 handle 发事务(BC_TRANSACTION 的 target) |
refs_by_node | 同一批引用 | node 指针 | 收到对方的对象时,判断"我是不是已经引用过它了"(避免重复建 ref) |
类比:
nodes是"我的房产证",refs_by_desc是"我租的房子的门牌号索引",refs_by_node是"我租的房子地址索引"。
与用户态的对应:一个 binder_proc ↔ 一个 ProcessState(单例,持有 mDriverFD)。进程里所有线程共用这一个 proc,但各有各的 binder_thread。
2.2 binder_node:远端对象的唯一实体
语义:一个进程里的某个本地对象(BBinder/JavaBBinder)第一次被写进 Parcel 发往别的进程时,驱动才为它建立 binder_node。node 记录三件事:本体归谁、本体是谁、现在有哪些进程引用我。
何时创建:binder_translate_binder() 中,先 binder_get_node(proc, fp->binder) 按"对象指针"查 proc->nodes 红黑树;查不到才 binder_new_node() 创建。所以同一对象无论被传出多少次,proc 里只有一个 node。
结构成员(简化自 binder_internal.h):
struct binder_node {
int debug_id; // 调试用递增编号
spinlock_t lock;
struct binder_work work; // node 死亡时需要处理的清理工作项
/* —— 链入 proc->nodes 的节点;proc 死后转挂全局 dead_node 链表 —— */
union {
struct rb_node rb_node; // 生存期:挂在宿主 proc->nodes,key = 对象指针
struct hlist_node dead_node; // 宿主进程退出后:仍被其他进程引用时挂全局链
};
/* —— 身份 —— */
struct binder_proc *proc; // ★ 宿主进程。proc == NULL 表示宿主已死,node 变成"僵尸"
kuid_t uid; // 宿主的 UID(安全检查用)
/* —— 引用我的所有 binder_ref(内核侧引用计数的核心) —— */
struct hlist_head refs; // 链接所有指向本 node 的 binder_ref(node_entry)
int internal_strong_refs; // 内核管理的强引用数 = 各 ref 的 strong 计数总和
int tmp_refs; // 临时引用(遍历/清理期间防释放)
/* —— 本地(宿主进程内部)引用计数 —— */
int local_weak_refs; // 宿主进程内弱引用数(obj.binder 指向的 wp 表)
int local_strong_refs; // 宿主进程内强引用数(sp<IBinder> 的个数)
bool has_strong_ref; // 是否有人在内核侧持有强引用
bool has_weak_ref;
bool pending_strong_ref; // 计数变更事务(BC_ACQUIRE等)在途标志
bool pending_weak_ref;
bool has_async_transaction; // 异步(oneway)事务串行化用
bool accept_fds; // 是否允许传 fd(FLAT_BINDER_FLAG_ACCEPTS_FDS)
bool inherit_rt; // 实时优先级继承
/* —— 优先级继承(服务端按 min_priority 被提升) —— */
uint8_t min_priority; // 处理本 node 事务时线程的最低优先级
uint8_t max_sched_policy;
uint8_t sched_policy;
/* —— oneway 事务的串行队列 —— */
struct list_head async_todo; // 同一 node 的 oneway 事务必须逐个投递,排队在此
};
几个字段为什么存在:
proc + 指针 key:node 的本质是"宿主进程里的一个地址"。事务到达宿主进程时,驱动从BR_TRANSACTION的 target(node)取出ptr/cookie,找到要调用的那个BBinder*。refs链表 +internal_strong_refs:node 的生死由所有进程的强引用总和决定。每个持有它的进程在自己的 ref 上记 strong 计数(对应BC_ACQUIRE/BC_RELEASE),node 侧汇总。全部归零 → 通知宿主进程释放本地对象。local_weak_refs / local_strong_refs:这是宿主进程内部的引用计数(用户态wp<IBinder>/sp<IBinder>),与跨进程计数分开记——对象何时能析构,取决于"本地还有没有人用 + 远端还有没有人强引用我"。dead_node分支:宿主进程退出了,但别的进程还握着它的 ref——node 暂不销毁,转挂全局binder_dead_nodes链,等待所有引用方释放(或触发BR_DEAD_BINDER死亡通知)。async_todo:oneway 事务不能并发打向同一个 node(会乱序),所以同一 node 的 oneway 一次只投一个,其余排队。
与用户态的对应(宿主进程内):
| 内核 | 宿主进程用户态 |
|---|---|
| node 的 key(对象指针) | BBinder*,Java 场景即 JavaBBinder*(持 Java Binder 全局引用) |
local_strong_refs | JavaBBinder 上的 sp 引用计数 |
node->proc | ProcessState 所在进程 |
2.3 binder_ref:别的进程手里那张"引用票据"
语义:进程 B 想调用进程 A 的对象时,内核在 B 的 proc 里为该 node 建一个 binder_ref,并分配一个编号 desc——这就是 handle。ref 永远挂在引用方进程名下,A 进程自己看不到它。
何时创建:binder_translate_binder() / binder_translate_handle() 投递事务时,对目标进程调用 binder_get_ref_for_node(target_proc, node):
- 先按 node 查
target_proc->refs_by_node——命中说明以前引用过,直接复用(这保证了"同一 node 在同一进程只有一个 handle"); - 未命中才创建新 ref 并分配 desc。
结构成员(简化自 binder_internal.h):
struct binder_ref_data {
int debug_id;
uint32_t desc; // ★ handle 本尊:分配给引用方进程的编号
int strong; // 引用方在内核侧的强引用计数(BC_ACQUIRE/RELEASE 增减)
int weak; // 弱引用计数(BC_INCREFS/DECREFS 增减)
};
struct binder_ref {
struct binder_ref_data data;
/* —— 同时链入两棵树 + node 的链表 —— */
struct rb_node rb_node_desc; // 挂 proc->refs_by_desc,key = desc
struct rb_node rb_node_node; // 挂 proc->refs_by_node,key = node
struct hlist_node node_entry; // 挂 node->refs(node 汇总引用它的人)
struct binder_proc *proc; // 引用方进程(不是宿主!)
struct binder_node *node; // ★ 我引用的是哪个 node(handle→node 的解析结果缓存)
struct binder_ref_death death; // linkToDeath 注册的死亡通知 cookie(用户态传的地址)
};
death 字段:linkToDeath(recipient) 时,用户态把一个 cookie 随 BINDER_TYPE.../BC_REQUEST_DEATH_NOTIFICATION 交给内核存在 ref 里;宿主进程死掉(node 变僵尸)时驱动据此回投 BR_DEAD_BINDER, JNI 层再回调 Java 的 BinderProxy 死亡通知逻辑。
强/弱引用与远端对象保活:
BpBinder构造 →BC_INCREFS(ref->weak +1);首次sp强持有 →BC_ACQUIRE(ref->strong +1)→ node 的internal_strong_refs+1;BpBinder销毁 → 逐级BC_DECREFS/BC_RELEASE;- 全部归零 → ref 从 proc 两棵树删除、从 node->refs 摘除,desc 编号回收。
与用户态的对应(引用方进程内):一个 binder_ref ↔ 一个 BpBinder(Java 场景再包一层 BinderProxy),缓存在 ProcessState::mHandleToObject[desc]。
2.4 binder_thread:事务的执行单位
每个调用过 binder ioctl 的线程在驱动里都有一个 binder_thread:
struct binder_thread {
struct binder_proc *proc; // 属于哪个进程
struct rb_node rb_node; // 挂 proc->threads,key = pid
struct list_head todo; // 派给本线程的事务队列
int return_error; // 本线程最近一次错误码
struct list_head waiting_thread_node;
bool is_extended_error;
struct {
bool looper; // 已调用 BC_REGISTER_LOOPER/BC_ENTER_LOOPER
bool looper_need_return;
};
pid_t pid;
loff_t return_error_line;
};
- binder 线程池:
ProcessState::startThreadPool()→ 子线程 ioctlBINDER_SET_MAX_THREADS注册上限;驱动事务到达时优先派给空闲 looper 线程,没有就回投BR_SPAWN_LOOPER让用户态再拉一个线程(受上限约束)。 - 每线程一份
IPCThreadState(TLS)↔ 每线程一个binder_thread。
2.5 handle:编号的完整生命周期
分配(内核 binder_get_ref_for_node)
desc = 0 仅给 context manager(servicemanager)
其余从 1 开始:按 refs_by_desc 中序遍历,取最小空闲值
↓
使用(本进程内)
BpBinder.transact → BC_TRANSACTION.target.handle
Parcel 里的 BINDER_TYPE_HANDLE.obj.handle
↓
翻译(跨进程投递时)
发送方 desc → ref → node → 接收方 desc(接收方无 ref 则现场分配)
↓
回收(binder_cleanup_ref,强/弱计数全归零时)
ref 删除,desc 回到编号池 → 可能被分配给下一个 node
由此得出的四条铁律(前文流程全部依赖):
- handle 是 (pid, desc) 对——离开所属进程,数字毫无意义;
- 同一 node 在同一进程永远一个 desc(refs_by_node 去重),不同进程的 desc 数值通常不同且互不相关;
- desc 会被回收复用——用户态必须持有
BpBinder/BinderProxy让引用计数保活,缓存裸 int 是典型 use-after-free; - handle 0 全局特指 servicemanager,也是唯一不经翻译、所有进程含义一致的编号。
2.6 flat_binder_object:binder 对象在 Parcel 里的线上格式
前文反复出现的"对象编码",其线上格式就是 include/uapi/linux/android/binder.h 里的:
struct flat_binder_object {
struct binder_object_header hdr; // hdr.type:下面 BINDER_TYPE_* 之一
__u32 flags; // 优先级信息、是否接受 fd、是否要 SecurityContext 等
union {
binder_uintptr_t binder; // 本地对象(BINDER_TYPE_*_BINDER):本地弱引用表(wp)的地址
__u32 handle; // 代理对象(BINDER_TYPE_*_HANDLE):发送方进程的 handle
};
binder_uintptr_t cookie; // 本地对象:本地 BBinder 指针;代理对象:恒为 0
};
各 type 与内核翻译动作的对照:
| hdr.type | 谁在发、发什么 | obj 字段含义 | 内核翻译动作 |
|---|---|---|---|
BINDER_TYPE_BINDER | 宿主进程发自己的对象 | binder=弱引用表地址,cookie=BBinder* | binder_translate_binder:建/查 node → 给接收方分配 desc → 改写为 HANDLE |
BINDER_TYPE_WEAK_BINDER | 同上,弱引用语义 | 同上 | 同上,弱引用版本 |
BINDER_TYPE_HANDLE | 任何进程转发自己持有的代理 | handle=发送方的 desc,cookie=0 | binder_translate_handle:按发送方 desc 查 ref→node→给接收方建/复用 ref,改写 handle;若接收方就是宿主,还原为 BINDERS+cookie |
BINDER_TYPE_WEAK_HANDLE | 同上,弱引用语义 | 同上 | 同上 |
BINDER_TYPE_FD | 传文件描述符 | handle=发送方的 fd | 驱动在接收方 dup 出新 fd(ParcelFileDescriptor 的实现基础) |
BINDER_TYPE_PTR / BINDER_TYPE_FDA | 共享内存指针 / fd 数组 | 大小+地址 | 配合 parent 偏移换算(MMAP 一次拷贝缓冲内的相对寻址) |
关键理解:BINDER_TYPE_BINDER 和 BINDER_TYPE_HANDLE 是同一对象在旅程两端的两种写法。发送方写哪个类型取决于"这对象对我来说是本地还是远端"(Parcel::flattenBinder 用 binder->localBinder() 判断);接收方读到的类型永远是内核改写后的(本地对象→HANDLE,代理→仍 HANDLE 或还原成 BINDER)。cookie 字段尤其重要:对象回到宿主进程时,驱动就是靠 cookie 把用户态指针原样还回去的。
2.7 内核结构 ↔ 用户态结构对应总表
| 内核结构 | 宿主方用户态 | 引用方用户态 | 生命周期 |
|---|---|---|---|
binder_proc | ProcessState(单例,mDriverFD) | 同左 | open → close |
binder_thread | 每线程一个 IPCThreadState(TLS) | 同左 | 首次 ioctl → fd 关闭 |
binder_node | BBinder/JavaBBinder(本地对象) | —(引用方不接触 node) | 首次被传出 → 强引用全归零且宿主释放 |
binder_ref | —(宿主不给自己发 ref) | BpBinder → BinderProxy | 首次收到对象 → BC_RELEASE/DECREFS 归零 |
handle(desc) | — | BpBinder 缓存的编号 | 分配 → 回收复用 |
以及贯穿全文的三条不变式:
(pid, handle) → binder_ref → binder_node → (宿主pid, 用户态 BBinder*)
同一 node 在同一进程只有一个 handle;不同进程 handle 数值互不相关。
对象回到宿主进程时永远是本地指针(cookie),绝不绕代理。