Binder 跨进程通信详解(上):由来、架构与核心概念

1 阅读34分钟

此文档由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 的需求本质是:

  1. 性能:IPC 是全系统最高频操作(AMS、WMS、PMS……),必须接近函数调用级别的开销;
  2. 安全:Android 是沙箱模型,每次 IPC 都要校验调用者 UID/PID,内核必须能提供可信的调用者身份;
  3. 对象语义:希望像调用本地对象一样调用远端对象(引用传递、引用计数、生命周期、死亡通知);
  4. 稳定性:避免一层用户态守护进程成为单点故障。

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 的设计思路

核心思想:用内核维护"跨进程对象引用"的语义。

  1. 对象身份由内核担保 每个可被远端访问的对象对应内核里的一个 binder_node(宿主进程 + 本地指针)。跨进程传递对象时,内核为接收方进程分配一个本地编号 handle(binder_ref),并保证:同一对象在同一进程内永远对应同一个 handle,对象销毁时引用计数与死亡通知由内核驱动。

  2. 一次拷贝(zero-copy 的变体) —— 详见下方 1.3.1 的完整展开。

  3. 内核提供可信身份 事务由内核投递,callingPid / callingUid 由内核填写,用户态无法伪造——这是 Android 权限模型的基石。

  4. 代理/桩(Proxy/Stub)自动生成 AIDL 编译器生成 Stub(服务端基类)和 Proxy(客户端代理),开发者只面向接口编程。

  5. 按需线程池 + 同步/异步两种语义 每个进程默认启动若干 binder 线程处理入站事务;同步调用等待 reply,oneway(FLAG_ONEWAY)投递后立即返回。

  6. 命名服务解耦 servicemanager 是唯一的全局权威(handle 0),负责"名字 → 引用"的注册与查找,其余一切对象引用都通过已有引用逐级传递获得(能力传递模型)。

1.3.1 深入理解"一次拷贝"(binder_mmap 机制)

先精确化你的理解:"客户端的数据被拷进服务端的 binder buffer"这个方向是对的,但有两个关键点要修正——

  1. 这个"服务端的 buffer"不是驱动里的普通内核缓冲,而是服务端进程自己 mmap 出来的那块内存;
  2. 完成这次拷贝的执行者是内核驱动(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() 做了三件重要的事:

  1. 只允许 PROT_READ:用户态对这块区域的权限被强制降为只读(驱动会清掉 VM_MAYWRITE,显式传 PROT_WRITE 会直接失败)。这是刻意的安全设计——用户态只能"读"送来的事务数据,不能"写",防止进程伪造/篡改属于其他事务的数据;
  2. 内核保留自己的映射:这块物理内存同时被映射进内核地址空间,驱动可以任意读写它;
  3. 登记到 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_BUFFERbinder_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/HWBinderhwbinder 库(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_serverfork 后立即(走同一 zygoteInit() 路径)eager之后才 startBootstrapServices
子 zygote(--start-child-zygote)不主动 openlazychildZygoteInit() 显式跳过
纯 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();
}

由此推出三条事实:

  1. fd 不继承:子进程即使继承了 fd 数字也拿不到同一个 binder 会话(已被显式 close,语义等同 O_CLOFORK),因为内核的 binder_proc 与 struct file 绑定,父子共享一个 binder_proc 在语义上是错的(handle 表、线程池、mmap 缓冲都是进程私有的);
  2. 在 fork 前初始化过 binder 的进程,子进程用它就会 fatal:verifyNotForked(gProcess->mForked) 直接 LOG_ALWAYS_FATAL。这就是为什么 Zygote 父进程不使用 binder——它只用 socket(/dev/socket/zygote)接收请求,保证 gProcess == nullptr,子进程才能干净地重新初始化;
  3. 每个进程的 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.cppmmap 建立区域(BINDER_VM_SIZE)
用户态framework/native/libs/binder/IPCThreadState.cppfreeBuffer(发 BC_FREE_BUFFER)、executeCommand
内核drivers/android/binder.cbinder_mmap、binder_transaction(调用 binder_alloc_new_buf)、binder_deferred_release
内核drivers/android/binder_alloc.c / binder_alloc.hbinder_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 页(零次拷贝),但没这么做,原因:

  1. 安全:数据必须先经过内核校验(对象翻译、UID/PID 注入、SELinux、buffer 边界检查),"发送方直接写接收方内存"会绕开全部检查点;
  2. 同步复杂度:发送方写一半接收方就读、页共享的引用管理、跨进程页错误处理,复杂度远超省下的一次拷贝;
  3. 收益有限:一次 copy_from_user 本身很快(memcpy 级),binder 调用的主要开销在 ioctl/上下文切换/线程唤醒上。

一句话总结:mmap 的区域是"接收方的地盘、内核的后厨"——驱动从接收方地盘里切一块 buffer,把发送方用户内存里的数据直接端进去,这是唯一一次拷贝;接收方在自己家直接吃,不再搬运。

(8)相关源码
层文件关键函数/代码
用户态framework/native/libs/binder/ProcessState.cppBINDER_VM_SIZE、mmap(...)、open_driver
用户态framework/native/libs/binder/IPCThreadState.cpptalkWithDriver(组装 binder_write_read)、executeCommand(BR_TRANSACTION 直接读 mmap 地址)、freeBuffer
内核drivers/android/binder.cbinder_mmap(清 VM_MAYWRITE、登记 alloc)
内核drivers/android/binder_alloc.c / .hbinder_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 分域)。

它承担六大职责:

  1. 打开即建会话(binder_proc) 进程 open("/dev/binder") 时,驱动创建 binder_proc,记录该进程的 handle 表(nodes、refs_by_node、refs_by_desc 三棵红黑树)、线程列表、内存映射信息。每个进程只 open 一次,fd 存于 ProcessState::mDriverFD。

  2. 全局对象登记簿(binder_node / binder_ref)

    • binder_node:远端可访问对象的唯一实体,归属于宿主进程,key 是 (proc, 用户态指针);
    • binder_ref:某进程对某 node 的引用,含编号 desc(即 handle),每进程各有一套编号空间;
    • 这正是"跨进程对象引用计数"的实现处。
  3. 事务路由(binder_transaction) 解析 BC_TRANSACTION:按 target.handle 查 ref → node → 宿主进程 → 选一条空闲 binder 线程投递;同时翻译事务数据里的所有 binder 对象(binder_translate_binder / binder_translate_handle,详见下文流程)。

  4. 一次拷贝内存(binder_mmap / binder_alloc) 进程 mmap 一块虚拟内存(默认约 1MB,异步事务各限 200KB 的一半配额),驱动把发送方数据 copy_from_user 进这块缓冲,接收方直接从映射区读——两次拷贝变一次。

  5. 身份注入 binder_transaction 里携带调用者 pid/uid/euid,内核填、内核核验,配合 SELinux(binder 类)做逐次调用的授权检查。

  6. 生命周期与死亡通知 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 的具体作用:

  1. open("/dev/binder") 得到 fd → 每个 binder 操作(ioctl(fd, BINDER_WRITE_READ, ...))都通过它进行;
  2. ProcessState 持有这个 fd(mDriverFD),整个进程共享一个 binder 会话;
  3. fd 本身也可以跨进程传递——驱动支持 BINDER_TYPE_FD 对象,把一个进程的 fd 转换成另一个进程指向同一内核 struct file 的新 fd(binder 事务数据中的文件对象自动完成 dup),这是 ParcelFileDescriptor 的实现基础;
  4. 通过 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_refsJavaBBinder 上的 sp 引用计数
node->procProcessState 所在进程

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):

  1. 先按 node 查 target_proc->refs_by_node——命中说明以前引用过,直接复用(这保证了"同一 node 在同一进程只有一个 handle");
  2. 未命中才创建新 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() → 子线程 ioctl BINDER_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

由此得出的四条铁律(前文流程全部依赖):

  1. handle 是 (pid, desc) 对——离开所属进程,数字毫无意义;
  2. 同一 node 在同一进程永远一个 desc(refs_by_node 去重),不同进程的 desc 数值通常不同且互不相关;
  3. desc 会被回收复用——用户态必须持有 BpBinder/BinderProxy 让引用计数保活,缓存裸 int 是典型 use-after-free;
  4. 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=0binder_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_procProcessState(单例,mDriverFD)同左open → close
binder_thread每线程一个 IPCThreadState(TLS)同左首次 ioctl → fd 关闭
binder_nodeBBinder/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),绝不绕代理。