第二章(下):Binder 与 AIDL——从 AIDL 到内核的完整调用链

21 阅读59分钟

上篇已走通 AIDL 调用、bindService 与反向 callback。本篇继续追踪对象关联、资源生命周期和死亡通知,并展开对照实验。执行命令前,先按上篇 2.1 准备 Host 终端与实验设备,按 2.3、2.9 准备基础示例与 callback 示例。

2.10 深入理解 Java 与 Native 对象怎样建立关联

前面的调用主线使用了已经存在的 Parcel 和 Binder 包装。现在沿对象创建的时间线回看:先建立关联,发送时读取关联,接收新引用时再按缓存规则创建或复用代理。 这一节可在首次读通 2.4~2.9 后深入,也可以通过字段名随时查阅。

先认识引用与指针的四个层次

名称含义阅读时怎样判断
Java 引用当前运行时管理的对象引用不能当作其他进程可访问的地址
Native 指针当前进程地址空间中的 C++ 对象位置Java long 字段可以保存它,但所属进程仍不变
sp 与 wpNative 强引用与弱引用包装强引用参与保活;弱引用需要尝试提升后再使用
handle 与 binder_ref本进程用于访问远端实体的描述值与 Kernel 引用记录与 Native 指针、JNI 字段标识分开理解

JNI 的 jfieldID 标识“某个类中的哪个字段”,不是字段里保存的对象地址。NativeAllocationRegistry 将 Java 对象的回收与对应 Native 清理动作关联;它并不让所有引用立即消失。

进程先打开 Binder 设备 并建立接收映射

来源:ProcessState.cpp,ProcessState 构造函数。进程首次建立对应 Binder 通信状态时,打开设备并预留接收事务的映射区:

unique_fd opened = open_driver(driver, &error);

if (opened.ok()) {
    // 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,
                    opened.get(), 0);

ioctl 是向打开的设备提交控制请求的系统调用,mmap 将相应内存映射进本进程地址空间;二者用途不同。这里的映射使接收者可以读取 Driver 准备的载荷页,2.6 的 copy_from_user 仍需把发送数据写到接收缓冲区。映射建立不表示每次调用都重新创建相同地址区,更不授予应用访问其他应用任意内存的能力。

mNativePtr 在进入 transact 之前就已建立

为什么读取一个字段就能拿到 Parcel?Proxy 中的 Parcel.obtain() 已准备好 Java 与 Native 的对应关系。文件:Parcel.java。obtain 可以复用池中对象;没有可复用对象时创建 new Parcel(0),构造函数再调用下面的 init:

private void init(long nativePtr) {
    if (nativePtr != 0) {
        mNativePtr = nativePtr;
        mOwnsNativeParcelObject = false;
    } else {
        mNativePtr = nativeCreate();
        mOwnsNativeParcelObject = true;
    }
}

新建路径的关键是 mNativePtr = nativeCreate()。 nativeCreate 在 android_os_Parcel.cpp 的 gParcelMethods 中绑定到 Native 创建函数:

{"nativeCreate",              "()J", (void*)android_os_Parcel_create},

对应 android_os_Parcel_create 完成分配,并把地址以 jlong 返回 Java:

static jlong android_os_Parcel_create(JNIEnv* env, jclass clazz)
{
    Parcel* parcel = new Parcel();
    return reinterpret_cast<jlong>(parcel);
}

创建时建立关联,transact 时读取关联,所以无需在 transact 入口重新创建或编码这份 Parcel。 注意另一个分支可包装已有 Native Parcel,并用 mOwnsNativeParcelObject 区分所有权;不能把所有 Java Parcel 都说成自己分配 Native 对象。

Proxy 调用的 writeInt 也已经用到这个关联。Parcel.java 的 writeInt 内部调用:

int err = nativeWriteInt(mNativePtr, val);

它把同一个 mNativePtr 传给 Native 写入函数。该方法注册到 android_os_Parcel_writeInt,在 android_os_Parcel.cpp 中实现如下:

static int android_os_Parcel_writeInt(CRITICAL_JNI_PARAMS_COMMA jlong nativePtr, jint val) {
    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
    return (parcel != NULL) ? parcel->writeInt32(val) : OK;
}

从保存的地址取得 Native Parcel,再调用 writeInt32 写入 val。 因此 parcelForJavaObject 取回的是前面已经写过参数的 Native Parcel,不是把 Java 对象变成 BinderProxy,也不是在这里才把 7、8 跨进程发送出去。

mNativeData 来自先前收到 Binder 引用时的包装

2.8 已说明业务引用怎样送达客户端。这里回看收到引用时的包装过程,obj 是最终用于发送业务事务的 Java BinderProxy。

读取 Binder 引用有一个可追踪的入口:android_os_Parcel.cpp 的 android_os_Parcel_readStrongBinder,在 Native Parcel 有效时执行:

return javaObjectForIBinder(env, parcel->readStrongBinder());

readStrongBinder() 取得 Native IBinder,javaObjectForIBinder 为 Java 返回对应的 Binder 对象。 本例远端引用对应的 Native 代理是 BpBinder;它从 handle 取得或复用代理的实现,可沿 Parcel.cpp 的 unflattenBinder 与 ProcessState.cpp 的 getStrongProxyForHandle 继续读。

先明确位置:本例的 BpBinder 是客户端的 C++ 对象。指向它的指针属于客户端进程虚拟地址空间,不是服务端对象的地址。 服务端本地 Binder 与 Java Stub 是另一组对象。

BpBinder 在哪里创建?在接收远端引用、需要为 handle 建立本地代理时,ProcessState.cpp 的 getStrongProxyForHandle 检查代理缓存。需要新建的分支执行:

sp<BpBinder> bp = BpBinder::PrivateAccessor::create(handle, &postTask);
e->binder = bp.get();
if (bp) e->refs = bp->getWeakRefs();
result = bp;

这是在客户端进程内为 handle 建立或保存代理。 已有可复用代理时走其他分支,不是每次取得引用都必定新分配。

再向下一层:BpBinder.h 的 PrivateAccessor::create 只转交给真正的工厂:

return BpBinder::create(handle, postTask);

最终 BpBinder.cpp 的 BpBinder::create(int32_t handle, ...) 在检查通过后创建对象:

return sp<BpBinder>::make(BinderHandle{handle}, trackedUid);

sp<BpBinder>::make(...) 创建客户端 Native 堆中的 BpBinder,BinderHandle{handle} 记录用于访问远端实体的 handle。 之后 javaObjectForIBinder 才把得到的 Native IBinder 放进下面的 BinderProxyNativeData。两种对象的创建位置不同,不能把包装结构的 new 当成 BpBinder 的创建。

切回 android_util_Binder.cpp,符号 javaObjectForIBinder。在非本地 Java Binder 的包装路径上:

BinderProxyNativeData* nativeData = new BinderProxyNativeData;
nativeData->mOrgue = sp<DeathRecipientList>::make();
nativeData->mFrozenStateChangeCallbackList = sp<FrozenStateChangeCallbackList>::make();
nativeData->mObject = val;

nativeData->mObject = val 将 Native IBinder 保存在包装结构里。 mObject 的声明位于同文件 BinderProxyNativeData,类型是强引用:

sp<IBinder> mObject;

同一包装函数随后调用 Java 的 BinderProxy.getInstance,把包装结构地址传过去:

jobject object = env->CallStaticObjectMethod(gBinderProxyOffsets.mClass,
        gBinderProxyOffsets.mGetInstance, (jlong) nativeData, (jlong) val.get());

getInstance 会检查已有代理缓存;需要新建时,进入 BinderProxy.java 的构造函数:

private BinderProxy(long nativeData) {
    mNativeData = nativeData;
}

至此,Java BinderProxy.mNativeData → BinderProxyNativeData → mObject → Native IBinder 的关系已经建立。 这些步骤发生在取得或包装引用时,不是每次 add 都重新执行。已有 BinderProxy 可被复用;完整实现还负责多余包装结构与 NativeAllocationRegistry 的生命周期管理。

这里的 mNativeData 保存的是客户端 Native 包装结构地址,mObject 保存的是客户端代理;它们都不是服务端 Java 对象地址,也不等于 Driver 使用的整数 handle。

mNativeData 来自先前收到 Binder 引用时的包装(过程或对象关系)

客户端 → Binder Driver → 服务端的箭头是事务传递,不是客户端拿着服务端指针直接解引用。 服务端对象地址只在服务端自己的地址空间中有意义。

服务端 Stub 怎样关联 Native Binder 实体

在本章 DemoService 中,Stub 是字段初始化时创建的,并不是每次执行 onBind 都 new 一次。对象实例化发生在 Service 创建期间;它的 Binder 父类构造函数位于 Binder.java:

mObject = getNativeBBinderHolder();
NoImagePreloadHolder.sRegistry.registerNativeAllocation(this, mObject);

Java Binder.mObject 是保存 Native Holder 地址的 long 字段。 它不同于 BinderProxyNativeData 中类型为 sp<IBinder> 的同名 mObject,不能因为名字一样就认为保存的是同一种内容。

getNativeBBinderHolder 在 android_util_Binder.cpp 中创建 Holder:

JavaBBinderHolder* jbh = new JavaBBinderHolder();
return (jlong) jbh;
对象分配位置本例的创建或关联时机
DemoService、ICalculator.Stub 实例服务端 Java 堆创建组件、执行示例字段初始化时
JavaBBinderHolder服务端 Native 堆Binder 父类构造时,地址保存到 Java mObject
JavaBBinderExt服务端 Native 堆需要取得 Native IBinder 时按需创建或复用
binder_nodeKernelBinder 实体被导出、Driver 需要记录它时创建或复用

为什么还需要 JavaBBinderExt?publishService 生成的传输代码写入 Binder 参数时,Parcel 的 JNI 写入入口会做以下交接。文件:android_os_Parcel.cpp,符号 android_os_Parcel_writeStrongBinder:

const status_t err = parcel->writeStrongBinder(ibinderForJavaObject(env, object));

对本例这个本地 Java Binder,ibinderForJavaObject 先从其 mObject 取得 Holder,再执行:

return jbh->get(env, obj);

Holder.get 先尝试从弱引用取得已有桥接对象;需要创建时才执行:

b = sp<JavaBBinderExt>::make(env, obj);

JavaBBinderExt 使 Native Binder 事务能够回到原来的 Java Stub。 它在构造时通过 NewGlobalRef 关联 Java 对象;Holder 对桥接对象使用弱引用,Native 强引用与 JNI 全局引用共同参与生命周期管理。服务端实体不会因为传输而被克隆成另一个进程中的 DemoService。

这些对象共同解释了 2.5 的两个读取动作:parcelForJavaObject 找当前数据,getBPNativeData 找当前目标。下面再按所有权区分它们的释放,避免把“同一次绑定中创建”误认为“同一次解绑时一起销毁”。

2.11 区分事务缓冲区 对象引用与组件生命周期

一次 add 返回以后,请求与响应已经完成业务作用;ICalculator 代理仍要留给下一次调用。事务结束只归还本次传输所用的资源,长期对象引用与 Android Service 生命周期另行管理。

请求接收数据与响应接收数据分别由谁归还

数据接收缓冲区属于谁谁持有读取包装本例的归还触发
add 的请求服务端进程服务端 Native 请求 Parcel;Java 包装不拥有该 Native 对象分发结束后 Native 请求 Parcel 释放所关联的数据
add 的响应客户端进程Proxy 的 reply Java Parcel 及其 Native ParcelProxy finally 中 recycle,Native 释放已关联响应数据
Proxy 写出的请求参数客户端用户空间自己构造的 Native Parcel 参数区recycle 清理自己的参数和对象引用;不能将它等同于服务端接收区

服务端 Java Binder.execTransact 的 Parcel.obtain(dataObj) 包装已有 Native Parcel,回收 Java 包装不会替代 Native 宿主的释放。Native Parcel 析构会进入 freeDataNoInit;响应数据则可以由客户端 Java recycle 经 JNI 触发。下面沿客户端 reply 的实际路径读到 Driver。

从 reply.recycle 追到 BC_FREE_BUFFER

来源:Parcel.java,recycle 调用 freeBuffer,拥有 Native Parcel 的分支继续执行:

if (mOwnsNativeParcelObject) {
    nativeFreeBuffer(mNativePtr);
}

JNI 注册将 nativeFreeBuffer 绑定到 android_os_Parcel.cpp 的 android_os_Parcel_freeBuffer:

Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
if (parcel != NULL) {
    parcel->freeData();
}

Native Parcel::freeData 调用 freeDataNoInit。对于 2.7 中 ipcSetDataReference 设置了 owner 回调的数据,Parcel.cpp 执行:

mOwner(mData, mDataSize, kernelFields ? kernelFields->mObjects : nullptr,
       kernelFields ? kernelFields->mObjectsSize : 0);

mOwner 是归还这份外部接收数据的函数,不是服务端 Java 对象。 本例关联的函数是 IPCThreadState::freeBuffer,其末尾将释放命令写入当前线程的 mOut:

state->mOut.writeInt32(BC_FREE_BUFFER);
state->mOut.writePointer((uintptr_t)data);
state->flushIfNeeded();

flushIfNeeded 与后续收发共同决定命令何时真正提交;不能把写入 mOut 当成 Driver 已经处理完。服务端 Native 请求 Parcel 对接收数据的释放也汇入同一个命令路径。

Driver 查找本进程的缓冲区 再归还空间

来源:binder.c,binder_thread_write 的 BC_FREE_BUFFER 分支。读取命令里的接收数据地址以后,按当前进程分配器查找可归还缓冲区:

buffer = binder_alloc_prepare_to_free(&proc->alloc,
				      data_ptr);

它校验地址、状态与重复释放等条件,通过后才调用:

binder_free_buf(proc, thread, buffer, false);

binder_free_buf 处理事务与异步队列关联,末尾分别释放载荷携带的对象资源和缓冲区空间:

binder_release_entire_buffer(proc, thread, buffer, is_failure);
binder_alloc_free_buf(&proc->alloc, buffer);

缓冲区归还后可以供后续事务复用;这不等于 Kernel 同时删除所有 binder_node。 载荷中的临时引用与另外保存的长期强引用也不能合并计算。

callback 注销与代理释放是另一个闭环

在 2.9 的示例中,客户端通过同一个 callback 对象调用 unregisterCallback;服务端 RemoteCallbackList 移除注册和相应死亡监听。客户端仍持有自己的 callback 字段,其他进程也可能持有引用,所以注销只是解除这项业务订阅。

再看远端 Java BinderProxy 的 Native 生命周期。BinderProxy.getInstance 把 nativeData 登记到 NativeAllocationRegistry;Java 对象满足回收条件时,对应 android_util_Binder.cpp 的 BinderProxy_destroy 负责清理:

delete nativeData;
IPCThreadState::self()->flushCommands();

删除包装结构会释放其中 sp<IBinder>。如果这正好使 BpBinder 的最后一个 Native 强引用结束,BpBinder::onLastStrongRef 经 IPCThreadState::decStrongHandle 通知 Driver:

mOut.writeInt32(BC_RELEASE);
mOut.writeInt32(handle);
flushIfNeeded();

这一串包含条件判断和异步回收,不是设置某个 Java 字段为 null 后立即执行的固定时序。 弱引用还通过 BC_DECREFS 管理。Driver 的 BC_ACQUIRE/BC_RELEASE 等分支调用 binder_update_ref_for_handle,在增减引用时分别执行:

if (increment)
	ret = binder_inc_ref_olocked(ref, strong, NULL);
else
	delete_ref = binder_dec_ref_olocked(ref, strong);

binder_dec_ref_olocked 只有在强、弱计数都归零等条件满足时,才清理这份 binder_ref:

if (ref->data.strong == 0 && ref->data.weak == 0) {
	binder_cleanup_ref_olocked(ref);
	return true;
}

binder_node 的宿主、其他进程引用及在途工作还要另行判断。JavaBBinderExt 的 JNI 全局引用与 Holder 的弱引用关系见 2.10;Kernel 不直接对 Java 对象执行垃圾回收。

unbindService 解除绑定 不等于全部内存立即释放

文件:ContextImpl.java,符号 unbindService:

IServiceConnection sd = mPackageInfo.forgetServiceDispatcher(
        getOuterContext(), conn);
try {
    ActivityManager.getService().unbindService(sd);
} catch (RemoteException e) {
    throw e.rethrowFromSystemServer();
}

客户端移除相应 ServiceDispatcher 记录并通知系统解除绑定。框架、应用字段、Java 垃圾回收、Native 引用计数和 Driver 协议共同决定后续对象何时回收,不能把这四种生命周期合在一起:

被管理的内容释放或结束的含义
本次事务接收缓冲区libbinder 经 BC_FREE_BUFFER 等路径归还空间,不等于删除服务实体
绑定关系与连接记录Framework 解除这组组件连接,并按组件规则决定后续状态
Java/Native 代理及桥接对象在相应引用不再持有后,由各自的回收机制处理
Kernel 的 binder_ref 与 binder_node按引用状态与宿主进程状态维护,不因一次 Parcel 回收就全部删除

只要应用或其他框架记录还持有引用,相关对象就可能继续存在。Service 组件是否销毁还与其他绑定、是否被 startService 启动等条件有关;组件生命周期也不能代替对 Binder 对象引用的检查。服务端进程退出时,旧代理对象仍可能留在客户端内存中,但原实体已不可用,后续需按死亡与调用失败处理。

描述符检查与身份检查分别解决什么

本例 Service 不对外导出,客户端与服务端通常同 UID;记录 callingUid 用来观察调用身份。真实跨应用或系统接口仍需按业务检查调用者权限、UID 与对象访问规则,Driver 检查不能替代全部业务授权。

enforceInterface 检查接口协议;Binder.getCallingUid 用于理解当前 Binder 调用者身份。把工作丢给另一线程后,不能假设仍读到原调用者身份。clearCallingIdentity 改变当前线程后续操作的身份上下文,需要按职责使用并在 finally 中恢复,不能把它当成通用的权限检查开关。

2026-10-20 的资源释放与异常死亡实验分别观察请求/回复缓冲区和独立 token 引用,并验证 callback 客户端与服务端的异常退出。先理解本节各自的生命周期,再用实验确认具体对象的状态。

死亡代理 DeathRecipient 怎样从注册走到通知

前面讨论的是“引用何时释放”;远端进程突然消失时,本地还需要知道代理指向的实体已经不可用了。这正是 linkToDeath 的用途。常说的“死亡代理”在这里应拆成应用实现的 IBinder.DeathRecipient 死亡接收者、JNI 的 JavaDeathRecipient 桥接对象,以及 Driver 保存的死亡登记;它不是又创建了一份业务 AIDL Proxy。

对象所在位置保存或处理什么
BinderProxy / BpBinder监听方进程原有远端代理;BpBinder 的 mObituaries 管理接收者记录
IBinder.DeathRecipient监听方 Java 层应用实现 binderDied,更新连接状态、清理业务等
JavaDeathRecipient监听方 Native 层实现 Native IBinder::DeathRecipient,把通知带回 Java
binder_ref_deathKernel关联监听方 binder_ref,保存死亡工作和回传 cookie
被监听的 binder_nodeKernel远端实体的节点,宿主退出时触发关联引用的死亡处理

本节仍沿 Java AIDL + Kernel Binder。如果同进程直接拿到本地 Binder,Binder.java 的 linkToDeath 是空实现;与监听本进程里普通 Java 对象的 GC 不同。

注册入口仍使用原来的业务代理

在客户端拿到远端 IBinder 后调用 binder.linkToDeath(death, 0),death 是自己的 Java 接收者。下面是 BinderProxy.java 的 linkToDeath 方法体:

linkToDeathNative(recipient, flags);
mDeathRecipients.add(recipient);

先进入 Native 登记,成功后 Java 列表保留接收者。 如果远端已经死亡,注册也可能抛 RemoteException,不能默认“注册完再开始考虑竞态”。保存接收者也不等于保活远端进程。

进入 android_util_Binder.cpp 的 android_os_BinderProxy_linkToDeath。它先沿 2.10 的 mNativeData 关联取得已有 Native 代理:

BinderProxyNativeData *nd = getBPNativeData(env, obj);
IBinder* target = nd->mObject.get();

接着在非本地 Binder 分支创建桥接对象,并交给同一个 target:

sp<DeathRecipientList> list = nd->mOrgue;
sp<JavaDeathRecipient> jdr = sp<JavaDeathRecipient>::make(env, recipient, list);
status_t err = target->linkToDeath(jdr, NULL, flags);

JavaDeathRecipient 是在监听方创建的 Native 对象;被监听目标仍是原 BpBinder 对应的远端实体。 它不继承业务 Stub,不需要额外导出一个 callback binder_node。后面的 Driver 管理命令也不是一次 AIDL 业务方法调用。

BpBinder 聚合接收者 由 Driver 记录一份死亡登记

BpBinder.cpp 的 linkToDeath 用 mObituaries 保存 Obituary 记录。首次建立列表、且走 Kernel Binder 分支时,执行以下连续代码:

getWeakRefs()->incWeak(this);
IPCThreadState* self = IPCThreadState::self();
self->requestDeathNotification(binderHandle(), this);
self->flushCommands();

同一 BpBinder 可以登记多个本地接收者,但不会为每一个接收者都重复向 Driver 增加一份独立登记。列表管理在用户空间聚合,Kernel 登记关联这份 handle 的 binder_ref。 Obituary.recipient 是 Native 的 wp<DeathRecipient>,此例指向 JavaDeathRecipient;JNI 的 mOrgue 列表则持有这份 Native 桥接对象的强引用。它们与 Java 接收者的 JNI 强弱引用是不同关系,后者的版本条件在本节末尾说明。

IPCThreadState.cpp 的 requestDeathNotification 将这三个值写进当前线程的命令流:

mOut.writeInt32(BC_REQUEST_DEATH_NOTIFICATION);
mOut.writeInt32((int32_t)handle);
mOut.writePointer((uintptr_t)proxy);

handle 用来定位监听方的引用;这里的 proxy 指针作为 cookie 原样回传。 它是监听方进程中 BpBinder 的地址,不是远端地址,也不是 Kernel 为 Java 对象分配的地址。Driver 不通过这个指针调用 BpBinder;收到通知后,监听方自己的 libbinder 才把 cookie 解释回本地指针。它与 Native linkToDeath 参数里供调用者使用的 cookie 也要分开看,此处传下去的是 this。

匹配 Kernel binder.c 的 binder_thread_write 分配并检查 binder_ref_death 后,把登记关联到 ref;相应连续摘录为:

binder_stats_created(BINDER_STAT_DEATH);
INIT_LIST_HEAD(&death->work.entry);
death->cookie = cookie;
ref->death = death;

若此时该节点宿主已经不存在,后续分支会直接安排死亡工作。因此“我注册之前查过 isBinderAlive 为真”不能保证登记、通知和下一次调用之间没有死亡竞态。

下面是注册与通知的完整机制时序图;“监听方”在普通服务调用中通常是客户端,在反向 callback 场景中则可以是服务端:

BpBinder 聚合接收者 由 Driver 记录一份死亡登记(过程或对象关系)

宿主退出后通知仍存活一方

Driver 怎样感知宿主进程退出

入口是 Binder 设备文件的 release 回调。 宿主进程打开 Binder 设备后,内核保存一份文件对象与 Binder 进程状态的关联;进程退出时,Linux 回收文件引用,最终由 VFS 调用该设备的 release。Driver 从这里开始释放连接、清理节点,随后才产生我们前面讨论的死亡通知。因此 SIGKILL 不要求应用先执行 onDestroy,也不要求死亡进程再给 Driver 发一条告别消息。

先认识三个不同对象:fd 是进程文件表里的编号,struct file 是内核中的打开文件对象,binder_proc 则是这次 Binder 打开连接的驱动状态。退出清理沿文件引用找到 binder_proc,不靠 Java Service 的生命周期回调找到它。 下面是本章固定 Kernel 基线的退出主路径,图中方框写明引用条件;共享文件表或其他文件引用仍在时,不能直接跨过这些条件:

Driver 怎样感知宿主进程退出(过程或对象关系)

先看打开时怎样保存关联。 drivers/android/binder.c 的 binder_open 分配并初始化 binder_proc,然后执行:

filp->private_data = proc;

同文件的 binder_fops 为该设备登记了以下连续操作项:

.open = binder_open,
.flush = binder_flush,
.release = binder_release,

private_data 把打开的文件与 Driver 状态连起来;release 指针告诉 VFS,文件最终回收时调用哪个驱动函数。 这也解释了为什么下面的文件回收流程能够进入 Binder,而不需要额外查询这个 PID 是否还活着。

再看任务退出怎样归还文件表。 kernel/exit.c 的 do_exit 先后执行 exit_mm、exit_files 和后面的 exit_task_work,分别参与地址空间、文件表和任务延后工作的收尾。与文件表交接的一行是:

exit_files(tsk);

fs/file.c 的 exit_files 取出 tsk->files、解除当前任务对它的关联,再调用 put_files_struct。后者只有在共享文件表的引用减到零时,才执行以下连续片段:

if (atomic_dec_and_test(&files->count)) {
    struct fdtable *fdt = close_files(files);

close_files 遍历打开的 fd,对对应 struct file 调用 filp_close。fs/open.c 的 filp_close 中有以下连续语句:

retval = filp_flush(filp, id);
fput(filp);

文件表的引用计数和文件对象的引用计数是两层条件。 同一进程的线程可以共享文件表,单独一条线程退出时,其他线程仍在使用它,便不会因此清空整个表。即使某个 fd 被关闭,dup 等形成的其他引用、尚未回收的映射等也可能继续持有 struct file;死亡通知不能按“出现一次 close”来推断。

最后一份文件引用结束后,VFS 才进入设备回调。 fs/file_table.c 的 fput 首先检查:

if (atomic_long_dec_and_test(&file->f_count)) {
    struct task_struct *task = current;

本版本普通任务的最终回收可登记为 task_work,经 ____fput 调用 __fput;do_exit 后面的 exit_task_work 会处理退出任务的这些工作。另有 delayed_fput 等延后路径,所以不应把 fput 简化成总是立即、直接调用 Driver。__fput 中真正跨入设备实现的连续片段为:

if (file->f_op->release)
    file->f_op->release(inode, file);

这里的 file->f_op 就能找到前面的 binder_fops,因此调用的是 binder_release。 Binder 的 flush 与 release 也要分开:前面的 filp_flush 可以调用 binder_flush,后者安排 BINDER_DEFERRED_FLUSH;释放整份 Binder 连接的入口则是 release 安排的 BINDER_DEFERRED_RELEASE。

Driver 收到 release 后,再把清理交给工作队列。 binder_release 从 filp->private_data 取回 binder_proc;移除相应调试条目后,执行:

binder_defer_work(proc, BINDER_DEFERRED_RELEASE);

binder_defer_work 在 binder_deferred_lock 锁内合并待处理标记,并在首次将该 proc 加入待处理列表时调度工作,连续摘录如下:

proc->deferred_work |= defer;
if (hlist_unhashed(&proc->deferred_work_node)) {
    hlist_add_head(&proc->deferred_work_node,
                  &binder_deferred_list);
    schedule_work(&binder_deferred_work);
}

binder_deferred_work 的处理函数是 binder_deferred_func。它从列表取出 proc 和待处理标记后,检查释放标记:

if (defer & BINDER_DEFERRED_RELEASE)
    binder_deferred_release(proc); /* frees proc */

从这里才进入原来文章直接写出的 binder_deferred_release。 该函数将 proc->is_dead 置为 true,清理这份连接的线程、节点与引用;遍历其 binder_node 时调用 binder_node_release,后者给已登记的监听方排入死亡工作。VFS 的文件回收和 Binder 的工作队列都是内核管理的收尾,已经退出的 Java 进程无需参与。

这里的“宿主死亡”以常见的进程退出场景来理解;从 Driver 的准确触发点看,是对应 Binder 打开连接最终被释放。普通线程退出、某个 Service 执行 onDestroy、关闭一份仍有其他引用的 fd,都不能单独等同于整份连接释放。相反,若一个仍存活的 Native 进程主动彻底释放了相应 Binder 文件及映射,也可能让这份连接中的节点失去宿主。

以上为固定源码的链路说明;本章已有死亡 Trace 验证了后面的协议交付,没有逐函数跟踪这些 VFS 收尾步骤。源码范围与衔接校验保留本节摘录及来源。

资源回收进入Driver并交付死亡通知

宿主退出后 Driver 怎样把消息送回监听方

承接前面的 VFS release 与工作队列,binder_deferred_release 会逐个处理宿主节点,进入 binder_node_release。节点会失去原来的宿主关联;对于仍持有引用、且已登记死亡通知的监听方,函数在相应锁内执行:

ref->death->work.type = BINDER_WORK_DEAD_BINDER;
binder_enqueue_work_ilocked(&ref->death->work,
                            &ref->proc->todo);
binder_wakeup_proc_ilocked(ref->proc);

入队的是监听方进程的工作,不是让已经退出的服务再主动调用一次 callback。 监听方从自己的 Driver 接收循环取得这项工作;binder_thread_read 将其编码为 BR_DEAD_BINDER 并携带先前保存的 cookie。

IPCThreadState::executeCommand 的分支如下:

case BR_DEAD_BINDER:
    {
        BpBinder *proxy = (BpBinder*)mIn.readPointer();
        proxy->sendObituary();
        mOut.writeInt32(BC_DEAD_BINDER_DONE);
        mOut.writePointer((uintptr_t)proxy);
    }
    break;

回传 cookie 找回的是原 BpBinder,BC_DEAD_BINDER_DONE 是处理确认。 BpBinder::sendObituary 会令 mAlive 为 0,取出接收者列表并设置 mObitsSent;通知接收者前会释放自己的 mLock。随后 reportOneDeath 提升接收者弱引用,仍存在时调用其 binderDied。这样,Driver 只需交付一项死亡事件,用户空间再分发给这份代理登记的接收者。

Native 回到 Java 之后运行在哪个线程

JavaDeathRecipient::binderDied 取得 Java 接收者与代理的局部引用后,通过 JNI 执行以下调用:

env->CallStaticVoidMethod(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mSendDeathNotice,
                          jRecipient.get(), jBinderProxy.get());

BinderProxy.sendDeathNotice 在 try 中再调用:

recipient.binderDied(binderProxy);

IBinder.DeathRecipient 带 IBinder 参数的默认方法,会转给传统的无参数 binderDied(),所以前面示例的 lambda 也能收到通知。这段 JNI 调用不会自动 post 到主线程;Java 代码在处理死亡命令的那条接收线程上执行。 普通应用通常是自己的 Binder 接收线程,实际 TID 仍需结合日志;不要在里面执行长耗时操作或直接更新 UI。它也不与 onServiceDisconnected、另一个工作线程收到 DeadObjectException 建立固定先后。

2.7 的线程管理解释了这里为什么需要接收循环。反向 callback 的服务端也一样:RemoteCallbackList 监听的是客户端导出的 callback Binder;客户端宿主退出后,服务端收到这条链路的死亡通知,再移除自己的订阅记录,见 2.12 实验六。

主动解除监听 与远端已经死亡分别怎样清理

目标仍存活、业务已经不关心它时,使用同一个 recipient 调用 unlinkToDeath。Java BinderProxy 移除自己的接收者;JNI 查找对应 JavaDeathRecipient,再调用 BpBinder::unlinkToDeath。Native 列表中最后一项移除时,才通过 clearDeathNotification 提交 BC_CLEAR_DEATH_NOTIFICATION。Driver 的 BR_CLEAR_DEATH_NOTIFICATION_DONE 回来后,libbinder 对先前登记期间增加的 BpBinder 弱引用执行 decWeak。

取消登记、死亡事件交付和处理确认可能交错。 Driver 具有 DEAD_BINDER_AND_CLEAR 等工作状态来衔接这两类操作,不能把方法返回理解成 Kernel 的登记结构已经同步释放,或已经开始执行的业务清理被撤回。按 IBinder 的接口约定,binderDied 回调内不必再调用 unlinkToDeath;通常应使业务清理能承受调用失败与死亡通知的并发;更新连接状态时识别触发通知的旧 Binder,避免晚到通知清掉新连接,重连后对新代理重新登记。

本版本还有一处与旧博客不同的生命周期细节:Java BinderProxy.mDeathRecipients 持有 Java 接收者;JNI 是否使用弱引用由编译宏 BINDER_DEATH_RECIPIENT_WEAK_FROM_JNI 与 target SDK 判断共同决定,启用该分支且目标为 Android V/SDK 35 及以上时只保留 JNI 弱引用。不能沿用“JNI 永远强持有接收者”的结论。 放弃代理及相关引用后,不应指望一项死亡登记永久维持业务对象;需要独立接收通知时要自己管理接收者的可达性,也要及时清理不再需要的订阅。

对照已保存的死亡实验

2026-10-20 的实测中,主控客户端 PID 4795 的 TID 4807 依次记录:

827.271762  BR_DEAD_BINDER
827.271766  BC_CLEAR_DEATH_NOTIFICATION
827.271865  BC_DEAD_BINDER_DONE

同一轮 Java 日志的 client binderDied 也运行在 TID 4807;发起 slowCall 的却是 TID 4831,它通过 BR_DEAD_REPLY → DeadObjectException 退出同步等待。死亡通知和在途调用失败是两条相互关联、但各自返回的路径。 这些协议 tracepoint 不显示 cookie,不能仅凭一条 BR_DEAD_BINDER 行识别任意业务对象;此处结合已知测试进程、线程与对应日志作对照。完整提取见协议复核记录。

把释放与死亡分成四个问题

  1. 本次请求和响应是否归还了接收缓冲区?看 Parcel 的所有权与 BC_FREE_BUFFER。
  2. 对象引用是否还被应用、框架、订阅或在途事务持有?看代理引用和 Driver 计数。
  3. Service 是否还需要存活?看绑定关系、启动状态与宿主进程。
  4. 远端宿主已经退出时,监听方如何获知?看 DeathRecipient、Driver 死亡登记与接收循环。

服务端进程死亡会使原实体不可用,客户端旧代理仍可能占有本地内存;死亡通知是状态变化,不是立即清空所有对象。2.12 的死亡实验用于观察这一点。

2.12 用对照实验理解线程 单向调用与死亡

知道完整链路后,再用改变条件的方式检验理解。每组都记录源码、APK、设备版本、PID/TID 和日志,不能只写“测试通过”。

同步与单向历史实测

实验一 同步调用和 oneway 到底差在哪里

重新启动示例,观察客户端的工作线程、服务端线程以及两种 sleep 的耗时。预期同步 sleep 的客户端返回包含服务端业务等待;oneway 通常先结束客户端提交阶段,服务端随后完成业务。

生成的 Stub.Proxy.sleepOneway 中,只摘录与同步 add 调用对照的提交语句:

boolean _status = mRemote.transact(Stub.TRANSACTION_sleepOneway, _data, null, android.os.IBinder.FLAG_ONEWAY);

与同步 add 对照:reply 变为 null,flags 变为 FLAG_ONEWAY。 它没有业务响应 Parcel,也不会等待服务端业务方法完成后的 reply。Driver 与 libbinder 仍需处理提交和协议结果,可能有背压、调度、等待或失败。

实验一 同步调用和 oneway 到底差在哪里(过程或对象关系)

图中单向调用的两条路径不规定全局先后:客户端可能在业务完成前返回,但不保证服务端一定在客户端返回后才开始。区别是是否等待业务 reply,不是凭这张图给两台时钟排先后。

它不会自动创建客户端 Java 工作线程。同进程优化若直接返回实现对象,sleepOneway 仍是普通 Java 调用,会等该方法执行结束;实验三可以验证这一点。

对同一远端 Binder 对象,oneway 调用有串行交付执行的规则;不要把它泛化为全进程所有对象的全局顺序。可以把客户端 one-way 调用增加为连续两次,观察服务端 begin/end 是否交错;同步调用则要考虑并发线程、线程池和可重入性。官方线程与异步事务说明

服务端并发读写共享数据必须自行同步。同步调用期间可能出现嵌套或反向调用,持锁跨进程调用可能造成死锁或重入问题,不能只靠“有 Binder 线程池”保证安全。

实验二 关闭远端进程并观察死亡通知

先确认当前仍使用 remote 进程配置,等待这轮业务执行结束。从日志读出 serverPid,再与两个进程列表核对。仅对本实验应用使用 run-as:

"$chapter2_adb" -s "$chapter2_serial" shell pidof com.example.binderdemo
"$chapter2_adb" -s "$chapter2_serial" shell pidof com.example.binderdemo:remote
read -r -p '输入核实后的 remote 服务端 PID:' chapter2_server_pid
"$chapter2_adb" -s "$chapter2_serial" shell \
  run-as com.example.binderdemo kill -9 "$chapter2_server_pid"
timeout 6 "$chapter2_adb" -s "$chapter2_serial" logcat -v threadtime \
  -s BinderDemoClient:I BinderDemoServer:I '*:S' \
  | tee "$chapter2_run/death.log"

预期旧 Binder 的 DeathRecipient 收到 binderDied,连接状态还可能触发 onServiceDisconnected。二者路径与线程不同,不要求日志顺序固定。BIND_AUTO_CREATE 也可能促使服务重建并重新连接,新 PID 与新 Binder 不能当作旧 Binder 复活。

run-as 要求应用可调试且包名正确;失败时先核实安装的 Manifest 与应用状态,不需要为此全局关闭设备安全机制。

2.11 的死亡通知链已把 Java 接收者、Native 代理列表和 Driver 登记接起来;2.7 的线程管理解释负责读取通知的线程从哪里来。它不提供下一次调用必定成功的保证:即使刚查询 isBinderAlive 为真,下一次仍可能失败。

实验三 改成同进程 对照 asInterface

先保存示例 Manifest:

cp "$chapter2_demo/AndroidManifest.xml" "$chapter2_run/AndroidManifest.remote.xml"

仅去掉 Service 的 android:process=":remote" 属性,保留其他内容。重新执行 2.3 的模块构建、APK 安装、force-stop 和启动,另存本轮日志。

观察项remote 配置去掉 process 属性
客户端与服务端 PID不同相同
asInterface 结果生成的 Proxy通常直接返回本地 Stub 实现
业务执行线程服务端 Binder 分发线程本例客户端 Executor 调用线程
oneway 的 sleep客户端不等业务 reply直接调用仍等待方法返回

同进程结果不能证明 Binder 跨进程传输有问题,它说明 asInterface 走了本地接口路径。该模式下不要执行上一组“杀 remote PID”的命令,因为已经没有独立 remote 进程。

对照结束后恢复 Manifest,再重新构建、安装和启动,确保后续仍是双进程版本:

cp "$chapter2_run/AndroidManifest.remote.xml" "$chapter2_demo/AndroidManifest.xml"

实验四 把真实 Trace 对应到源码与线程

本章示例已在关键位置加入 Trace.beginSection/endSection。基础版客户端区间叫 BinderDemo.runCalls,服务端有 BinderDemo.add、BinderDemo.sync、BinderDemo.oneway;callback 版有 CallbackDemo.request、CallbackDemo.compute、CallbackDemo.onResult 和 CallbackDemo.mainResult。

准备好两个应用,先确认设备支持调度和 Binder 跟踪。在 Host 终端 A 开始一个 14 秒窗口,配置文件为 第二章Binder.pbtxt:

"$chapter2_adb" -s "$chapter2_serial" shell atrace --list_categories
"$chapter2_adb" -s "$chapter2_serial" shell perfetto --txt -c - \
  -o /data/misc/perfetto-traces/chapter2.perfetto-trace \
  < "$chapter2_notes/示例/追踪配置/第二章Binder.pbtxt"

配置同时记录 Binder 事务、线程调度、进程名称和示例自己的 Trace 区间。atrace_apps 包含主进程名与 :remote 进程名,否则可能只能看到客户端自定义区间,看不到服务端的业务区间。它不自动开启所有应用或全部系统事件。

在设置了相同 adb 路径与 serial 的 Host 终端 B 中,在采集窗口内依次重启两个示例。基础版自动执行约 2.4 秒,等它的服务端 oneway end 后再启动 callback 版:

"$chapter2_adb" -s "$chapter2_serial" shell am force-stop com.example.binderdemo
"$chapter2_adb" -s "$chapter2_serial" shell am start -W \
  -n com.example.binderdemo/.MainActivity

继续启动 callback 版:

"$chapter2_adb" -s "$chapter2_serial" shell am force-stop com.example.bindercallback
"$chapter2_adb" -s "$chapter2_serial" shell am start -W \
  -n com.example.bindercallback/.MainActivity

窗口结束后,在 Host 拉取并打开自己的文件:

"$chapter2_adb" -s "$chapter2_serial" pull \
  /data/misc/perfetto-traces/chapter2.perfetto-trace "$chapter2_run/"

在 Perfetto UI 中按以下顺序观察,不把所有轨道同时展开:

  1. 搜索 BinderDemo.sync,找到服务端 Binder 线程上的约 1200 ms 区间;对照客户端工作线程,观察它在这次同步事务中的等待。该区间包含示例主动休眠,不代表线程连续占用 CPU。
  2. 查看紧接着的 BinderDemo.oneway。客户端 BinderDemo.runCalls 已可结束,服务端还在完成约 1200 ms 的业务。利用 Binder 事务和线程事件关联两端,不能只按时间接近判断。
  3. 搜索 CallbackDemo.request,定位客户端提交注册和计算请求的线程;再定位服务端工作线程上的 CallbackDemo.compute。业务方法只是排队,因此这两个区间的结束时刻没有“计算必须先结束”的约束。
  4. 找到客户端 Binder 线程上的 CallbackDemo.onResult,再找到主线程的 CallbackDemo.mainResult。两者通过 Handler 交接;这正是 2.9 的回调实现,不能把它误读成 Binder 自动回调主线程。
  5. 查看事务的 Flow 或关联事件与双方 TID;同一个进程可有多条 Binder 接收线程。某一轮使用了同一 TID,不足以推出所有调用都固定分发到它。

本文的实测时间线与对应日志见本节后面的记录。调度状态用于区分 Running、Runnable 与等待;只有业务 Trace 区间而没有调度事件时,不能直接把整个区间当成 CPU 时间。缺少 Binder 或示例区间时,先核实配置、进程名与采集窗口,再判断机制。Perfetto 官方采集说明

本轮实测与图的读法

以下是 2026-10-16 的设备实测,与前面的预期判据分开记录。使用独立 data 冷启动的 Emulator,serial 为 emulator-5560,系统为 Android 17 userdebug,Kernel 为 6.12.58-android16-6-gccafb60de224-ab14828483。两个 APK 均由文中的 Host 工具链生成后安装;完整 fingerprint、关键日志、查询结果与检查项见 本轮运行证据。

先看同步与 oneway。 下图从实际 Trace 的业务区间提取重绘,保留真实起止时间与 TID,属于测量时间线,不是 Perfetto UI 截图。横轴以客户端 BinderDemo.runCalls 开始为 0 ms;红色虚线表示这个客户端调用序列结束。

同步调用等待业务结果,单向调用提交后服务端继续执行

客户端 PID 2458、工作线程 TID 2493;服务端 PID 2475、Binder 线程 TID 2489。客户端序列包含 getServerPid、add、sleepSync 和 sleepOneway,持续约 1208.86 ms;服务端的 sync 与 oneway 业务区间分别约 1201.46 ms、1200.31 ms。客户端退出调用序列时,服务端 oneway 仍在继续。

sync 业务区间内,调度数据记录了约 1200.423 ms 的 Sleeping 与 0.227 ms 的 Running,其余为可运行状态等时间。因此长条主要来自示例休眠,不能读成服务端消耗了 1200 ms CPU。对应日志中同步调用耗时为 1205 ms,单向提交耗时为 0 ms;后者是毫秒取整结果,不表示整个传输没有成本。

再看 callback 的两个方向。 图的上半部分以客户端 CallbackDemo.request 开始为 0 ms;下半部分单独放大客户端收到回调后的线程交接,并重新以 onResult 开始为 0 ms。

业务请求排队后反向通知客户端,再由 Handler 切到主线程

实测区间PID / TID持续时间与含义
CallbackDemo.request2527 / 2577约 6.65 ms,客户端完成注册与排队请求
CallbackDemo.compute2550 / 2578约 122.94 ms,服务端工作线程计算并通知,包含主动休眠
CallbackDemo.onResult2527 / 2538约 0.093 ms,客户端 Binder 线程接收业务 callback
CallbackDemo.mainResult2527 / 2527约 0.544 ms,Handler 投递后在客户端主线程更新结果

本轮客户端 onResult 开始时,服务端 compute 区间尚未结束;这个区间包含通知和收尾,并不只是加法计算。这说明发送 oneway 通知以后,两端可以并发推进。

这轮收到的数值为 15。客户端 callback 与主线程处理相邻,但 TID 不同;结合 MainActivity 中明确的 Handler.post,才能把时间线对应到线程交接。单凭两个时间点接近,不能推断任意两段代码具有因果关系。

本轮 Binder 事件还记录了两个不同的目标节点:

调用方向事务与目标本轮 destination node
客户端注册 callbackregisterCallback 的目标是服务端业务实体,事务 ID 6176559455
服务端通知客户端onResult 的目标是客户端 callback,事务 ID 6525061766

这为 2.9 的“两份独立实体”提供了运行对照。destination node 是本轮 Kernel 跟踪中的节点标识,不是 handle 或用户空间地址,也不能在下一轮直接复用。反向事务发送与接收事件都记录事务 ID 65250,可结合它与线程映射关联两端。

本轮还完成了:注销后再计算不新增结果通知、重新注册恢复通知、关闭基础版服务端后收到 binderDied;点击“结束绑定并退出”后客户端与服务端完成退出/解绑,日志中未出现 ServiceConnectionLeaked。另一次同进程对照中,客户端与服务端业务日志的 PID、TID 相同,oneway 方法耗时 1201 ms,验证了直接 Java 调用仍等待方法结束。组件连接通知与业务 callback 的节点仍需各自识别;上述表只选择业务调用和业务回调,不表示设备中只有两个 Binder 节点。

用自己的 Trace 查询同样的区间

可在 Perfetto UI 的 SQL 查询面板运行 提取业务区间.sql,按 name 找到示例区间,再按 PID/TID 定位线程。需要核对引用方向时,运行 提取Binder目标.sql,对照目标节点和事务 ID。

本工程还带有 trace_processor_shell。若原文件没有执行位,先复制到本轮记录目录,再执行查询;下列 -q 参数接收 SQL 文件:

cp "$chapter2_top/prebuilts/tools/linux-x86_64/perfetto/trace_processor_shell" \
  "$chapter2_run/trace_processor_shell"
chmod u+x "$chapter2_run/trace_processor_shell"
"$chapter2_run/trace_processor_shell" \
  "$chapter2_run/chapter2.perfetto-trace" \
  -q "$chapter2_notes/示例/追踪配置/提取业务区间.sql" \
  > "$chapter2_run/trace-sections.csv"

本轮使用的解析器版本为 Perfetto v54.0。不同版本对事件名称与参数展示可能有差异;先查看自己的表和字段,不把本文的 slice ID、事务 ID 或节点编号写进通用判断逻辑。

实验五 分开验证缓冲区归还与 Binder 引用释放

前面的加法与 callback 已证明“能通信”。还剩一个问题:一次调用结束后,到底释放了什么? 2.11 的源码给出了两条不同路径,现在分别取运行证据,避免只凭一条 recycle() 日志宣称内存全部回收。

这三组补充实验使用独立的 Chapter2LifecycleDemo 源码包,不修改前面的基础版与 callback 版。完整文件也在展开的源码目录。它有三个进程:

进程职责为什么需要它
主控客户端 MainActivity工作线程发起调用,并持续绑定服务callback 客户端死亡后仍有人维持服务,才能观察服务端清理
服务端 ProbeService,:serverecho、独立 token、callback 列表与耗时方法把数据、对象和失败场景分开控制
callback 客户端 CallbackActivity,:callback创建并注册自己的 callback Stub可以单独终止它,模拟未主动注销的订阅者死亡

先构建、安装,再采集。 以下在 Host 的 AOSP 根目录运行,沿用 2.1 的 chapter2_top、chapter2_adb 和实际选定的 chapter2_serial。设备需为专用的 userdebug 实验实例,允许 adb root,并具有 Binder 调试快照与 ftrace 事件。脚本会清空 logcat、配置全局 ftrace、单独终止本示例的两个子进程,因此使用独立实例;它不会修改 AOSP 核心源码。

chapter2_notes="$chapter2_top/Android源码学习笔记/章节学习/第二章-Binder与AIDL"
chapter2_lifecycle=$(mktemp -d "$HOME/aosp-binder-lifecycle.XXXXXX")
python3 "$chapter2_notes/示例/构建示例APK.py" \
  --aosp-top "$chapter2_top" \
  --module "$chapter2_notes/示例/Chapter2LifecycleDemo" \
  --name Chapter2LifecycleDemo --out "$chapter2_lifecycle/build"
"$chapter2_adb" -s "$chapter2_serial" root
"$chapter2_adb" -s "$chapter2_serial" wait-for-device
"$chapter2_adb" -s "$chapter2_serial" install -r \
  "$chapter2_lifecycle/build/Chapter2LifecycleDemo.apk"
"$chapter2_adb" -s "$chapter2_serial" shell am force-stop com.example.binderclosure
"$chapter2_adb" -s "$chapter2_serial" shell am start -W \
  -n com.example.binderclosure/.MainActivity --es op ping

预期启动成功,日志出现 client connected 与 ping serverPid=。如果还没有连接,先核对 Service 创建与 Manifest,不继续按不存在的 PID 采集。然后执行采集脚本与分析脚本:

python3 "$chapter2_notes/示例/执行生命周期实验.py" \
  --aosp-top "$chapter2_top" --serial "$chapter2_serial" \
  --out "$chapter2_lifecycle/run"
python3 "$chapter2_notes/示例/分析生命周期证据.py" \
  --run "$chapter2_lifecycle/run"

采集脚本按顺序完成实验五、六、七,保存实际命令、退出码、日志、快照和原始 ftrace;分析脚本检查请求与回复的分配/释放配对、特定引用消失和异常恢复。成功时输出 analysis.json、echo-buffers.csv 和 trace-selected.txt。metadata.json 中三个 phase 均为 true 是采集阶段的检查结果,仍需结合分析与原始证据判断。若等待 GC 超时,只能记为本轮未观察到释放;System.gc() 是请求,不能将固定等待几秒当作保证。事件缺失时先核对 Kernel 配置和调试接口,不能把“没采到”当作“没发生”。

先只传数据,看两个接收缓冲区。 客户端发送 256 KiB 的 byte[],服务端返回 clone;数组数据为 262144 字节,序列化后的请求和回复还包含各自的协议内容,所以 Driver 的 data_size 不等于数组长度。这是固定尺寸的观察实验,不是容量上限测试。

下面是 2026-10-20 在独立 SDK Emulator 上的实测,当前 Binder impl=c。主控 PID 4795、工作线程 TID 4831;服务端 PID 4812、接收线程 TID 4825:

方向transaction ID接收方Driver data_size分配 → 释放(启动后秒)
echo 请求186369服务端262244 字节825.239519 → 825.243830
echo 回复186393主控客户端262152 字节825.243982 → 825.245172

同一个 transaction ID 的 alloc 与 buffer_release 配对,才是这块接收缓冲区已经归还的直接证据。 本轮两个释放事件前,同一接收线程也提交了 BC_FREE_BUFFER,对应 2.11 的 Parcel → freeBuffer → Driver 路径。请求与回复各自分配、各自释放,不能拿请求的分配去配回复的释放。原始 Trace 的时间是启动后的单调时间,不能直接与 logcat 的墙上时间相减。

再只观察一个独立 Binder 对象。 服务端创建普通 Binder token 并保留 Java 字段,将它作为返回值交给客户端;客户端暂存代理。这里不用业务 Service 的 Binder,因为它还被绑定机制和其他对象持有,难以隔离实验条件。ProbeService.createToken 与 MainActivity 的 token/release 操作是教学示例,关键语句如下,两段分属不同进程:

// 服务端示例:创建实体并保留 Java 字段。
token = new Binder();
return token;
// 客户端示例:移除自己的代理字段,然后请求回收。
token = null;
System.gc();
System.runFinalization();

本轮客户端快照出现 ref 186474: desc 55 node 186473 s 1 w 1,服务端快照出现 node 186473。handle 55 属于客户端,node 186473 是本轮 Kernel 节点编号,二者都不是服务端的内存地址。 释放客户端字段并请求 GC 后,脚本最多观察 8 秒,本轮匹配的客户端 ref 和服务端 owner 快照中的 node 均已消失;这时还没有调用 dropServerToken()。

为什么服务端 Java 字段还在,Kernel 节点就能消失?2.10 中的 Java Binder、JavaBBinderHolder、Native 桥接实体与 Kernel 节点具有不同的引用关系。保留 Java Binder 对象不代表永远持有一份强 Native 实体,也不保证 Kernel 节点一直驻留。 当对应 Native 实体及 Driver 引用满足释放条件,节点可以先离开 owner 树;Java 对象仍可能存活。若将来再次导出它,不能拿旧节点编号继续识别。这个现象验证的是选定对象在本轮快照中的状态,不证明所有对象、在途工作或每个分配字节都已回收。

本轮客户端回收阶段还记录了 BC_RELEASE 与 BC_DECREFS。这些 binder_command 事件没有 handle 字段,所以它们只支持“这一阶段发生过引用协议处理”;特定 token 已释放的判断依靠 node/ref 快照,不能把相邻的一条命令擅自归到 handle 55。 对照证据见内存日志、汇总分析与配对事件。

实验六 callback 客户端突然死亡 服务端怎样清理订阅

2.9 的主动注销是业务代码主动配合。现在反过来:客户端来不及注销就退出,服务端能否继续运行? 主控客户端持续绑定服务端,独立 callback 客户端注册一次并收到 15,然后脚本只向 callback 进程的实际 PID 发送 SIGKILL。不能用整个包的 force-stop 代替这一步,否则同包的服务端也会退出,无法验证服务端存活时的订阅清理。

下面是机制时序图,重点是死亡通知与列表变化,省略组件绑定细节。直接画在客户端与服务端之间的业务箭头也经过 Driver;图中只展开死亡通知的 Driver 交接:

实验六 callback 客户端突然死亡 服务端怎样清理订阅(过程或对象关系)

本轮 callback 客户端 PID 4941,服务端对它的引用为 ref 187468 / handle 26 / node 187467。终止 callback 进程后,服务端 PID 4812 和主控 PID 4795 均保持存活。关键实测日志按阶段摘录,完整 PID/TID 见原记录:

server register ok=true count=1
callback-client onResult=15
server callbackDied remaining=0
client callbackCount=0
server broadcast count=0
server broadcast finished count=0
client notify returned

这组结果需要一起看:收到死亡通知、订阅已经移除、后续通知仍能正常结束,才构成服务端处理异常订阅者的闭环。客户端日志没有 onDestroy,SIGKILL 路径也不会执行主动注销;因此不能把本次清理解释为客户端善后。

为什么 onCallbackDied 里已经看到 0?RemoteCallbackList.java 的内部 Callback 实现了 DeathRecipient,下面是 binderDied() 的完整方法,固定提交为 frameworks/base 94b4c163b7dfe5ce3607f7bb8456f9573f7de57d:公开源码。

public void binderDied() {
    synchronized (mInterfaces) {
        mInterfaces.remove(mBinder);
        maybeUnsubscribeFromFrozenCallback();
    }
    onCallbackDied(mInterface, mCookie);
}

先从 mInterfaces 删除,再调用 onCallbackDied。 它清理的是服务端登记的 callback 代理记录,不会替服务端回滚业务,也不会让死亡客户端恢复。注册检查、通知时捕获 RemoteException、业务任务取消等仍各有职责;本例只验证一条订阅及随后的空列表广播,不宣称覆盖“广播恰好进行到一半时死亡”的所有竞态。

实验七 同步调用尚未返回 服务端突然死亡会怎样

前面的“服务端退出后收到 binderDied”还不能证明等待中的调用会结束。这次让主控工作线程调用 slowCall(8000),等日志确认服务端已经进入 slow begin,再终止服务端 PID。客户端工作线程要么拿到业务响应,要么收到失败;死亡回调自身不是那次方法调用的返回值。

下面是机制示意图,死亡通知、组件断连与工作线程抛异常之间不承诺固定先后:

实验七 同步调用尚未返回 服务端突然死亡会怎样(过程或对象关系)

本轮仍由工作线程 TID 4831 发起事务 188923,服务端 TID 4825 记录 slow begin 后被终止。ftrace 在同一客户端 TID 记录 BR_DEAD_REPLY;Java 调用抛出 android.os.DeadObjectException,最终结束日志耗时 26 ms,没有等满设置的 8000 ms,也没有 slow returned normally。这个 26 ms 包含测试脚本很快注入终止的影响,是本次结果,不是 Binder 保证的故障发现延迟。

从哪里结束等待?IPCThreadState.cpp 的 waitForResponse() 中,BR_DEAD_REPLY 分支为以下连续摘录,固定提交见文末:

case BR_DEAD_REPLY:
    err = DEAD_OBJECT;
    goto finish;

错误状态让原等待循环结束。 随后沿 Native 返回值进入 android_util_Binder.cpp 的 signalExceptionForError(),在允许抛 RemoteException 的调用路径中转换为 Java 异常。其 DEAD_OBJECT 分支如下:

case DEAD_OBJECT:
    // DeadObjectException is a checked exception, only throw from certain methods.
    jniThrowException(env, canThrowRemoteException
            ? "android/os/DeadObjectException"
                    : "java/lang/RuntimeException", NULL);
    break;

这就把 Driver 失败 → libbinder 错误状态 → JNI 异常 → Java catch/finally 串起来了。它不依靠主线程先收到 onServiceDisconnected,也不依靠应用的 DeathRecipient 主动去唤醒那条工作线程。

恢复阶段,本例保留的 BIND_AUTO_CREATE 连接再次收到 onServiceConnected,新服务端 PID 为 5085。MainActivity 替换接口代理,同一个工作线程 TID 4831 的 ping 返回 5085,证明它已经退出旧等待,并能使用新引用继续工作。旧代理不会因为服务重建就自动变成新对象;本例更新的是 remote 字段。绑定恢复还受系统和组件状态影响,不能推断任何异常退出都必然在一秒后重启。

失败不等于业务一定没执行。 其他接口可能在回复前已经提交部分结果;重连后是否重试要由业务的幂等性、请求编号或状态查询决定。本实验只在显式 sleep 阶段注入死亡,验证通信失败与重连,不自动重放原调用。完整日志、命令与采集边界见三组实验记录。实验结束可卸载 com.example.binderclosure;采集脚本在退出时停止本轮 ftrace 并关闭事件,独立 Emulator 由启动者关闭。

常见问题与本次结果怎样记录

现象第一检查项不能直接得出的结论
bindService 返回 falseManifest、组件名、安装状态与绑定错误Driver 已经故障
客户端与服务端 PID 相同process 属性与是否安装了新 APK已完成真实跨进程实验
oneway 也等了约一段业务耗时asInterface 是否返回本地对象oneway 标记无效
一直没有连接回调生命周期、服务创建、Framework 错误日志客户端一定已拿到 Binder
客户端卡住是否主线程调用、服务端状态、线程池与锁所有延迟都发生在 Driver
出现 DeadObjectException服务端是否退出、旧引用是否失效应原样无限重试
大参数调用失败单次与并发占用、对象与接收缓冲区每个接口都拥有独占固定容量
Driver 目录只有预编译文件Kernel 来源、提交与构建信息已经有完整底层实现可读

实验结束后可通过 adb -s serial uninstall com.example.binderdemo 卸载本例,它会删除该应用及其数据;源码可保留供后续练习。记录实际成功与失败,不把本文预期输出替代自己的证据。

2.13 ServiceManager 如何把名称变成 Binder 引用

前面的示例解释了引用、调用、回调与释放。接下来把这套机制用于服务发现、权限、容量、Driver 对照与构建集成。2.13~2.17 提供概念、源码与后续实验方案;其中独立服务注册、跨 UID、容量压力、Rust 切换和 Soong 成功构建仍需逐项验证,不能沿用 2.12 的通过结果。

先区分发现服务与调用服务

应用的 bindService 找的是 Android Service 组件,由系统安排创建与连接;ServiceManager 则维护系统 Binder 服务的名称与对象关系。二者都能交付 Binder,但入口、权限和生命周期契约不同。

以系统中的一个已注册服务为例:服务端把自己的 Binder 登记到 ServiceManager;客户端提交名字,得到指向该实体的引用;之后每次业务事务直接以业务 handle 为目标,不再按名称经过 ServiceManager 转发。 ServiceManager 不是所有业务数据的中转站。

下面是经典服务登记/查询路径的机制示意,省略本版本支持的 accessor 等扩展:

先区分发现服务与调用服务(过程或对象关系)

Java 查询先看缓存 再访问远端管理器

ServiceManager.java 的 checkService() 中,try 内的连续摘录如下:固定提交源码。

IBinder service = sCache.get(name);
if (service != null) {
    return service;
} else {
    return Binder.allowBlocking(
            getIServiceManager().checkService2(name).getServiceWithMetadata().service);
}

缓存命中与远端查询是两个分支。 sCache 不是所有应用随时共享的一份全局 Java Map;它在当前进程中。未命中时,接口调用本身又是一笔 Binder 事务。外层还捕获 RemoteException 并返回 null,不能只看到方法返回 null 就断定“系统没有这个服务”。

这也是 checkService 与 waitForService 要分开理解的原因:前者不等待服务将来注册,后者是等待型接口。checkService 的“不等待”不等于内部绝不会因一次同步 IPC 与调度而耗时。普通公共 SDK 应用也不能直接把隐藏的 ServiceManager API 当成受支持的应用开发入口。

Native 注册先检查身份 再建立名称记录

ServiceManager.cpp 的 addService() 先取得调用上下文,接着有这一段:固定提交源码。

if (multiuser_get_app_id(ctx.uid) >= AID_APP) {
    return Status::fromExceptionCode(Status::EX_SECURITY, "App UIDs cannot add services.");
}

应用 UID 会在这一分支被拒绝。 因而把前文 APK 的包名改掉、调用 addService,并不是有效的独立注册教程。后面 canAddService() 还要检查服务名对应的 SELinux add 权限;查找也有 canFindService 等判断。root shell、测试密钥、system UID 和合适的 SELinux 域分别解决不同条件,不能互相替代。

通过名称、对象和声明等检查后,addService() 中保存记录的连续摘录为:

mNameToService[name] = Service{
        .binder = binder,
        .allowIsolated = allowIsolated,
        .dumpPriority = dumpPriority,
        .hasClients = prevClients, // see b/279898063, matters if existing callbacks
        .guaranteeClient = false,
        .ctx = ctx,
};

记录保存的是 Binder 与调用上下文,不是把服务端 Java 对象拷贝进管理器。 同函数还会为远端 Binder 注册死亡通知。后续阅读 binderDied(),对照服务登记项、通知订阅及重注册处理,不能将“服务死亡”简单等同为“客户端手里的旧代理已经更新”。

先做只读观察 再做自定义注册

在 Host 设置实际 serial,以下操作仅查询现有系统服务,不调用任意 transaction code:

chapter2_top="$HOME/aosp"
chapter2_adb="$chapter2_top/out/host/linux-x86/bin/adb"
"$chapter2_adb" devices -l
read -r -p '输入实验设备 serial:' chapter2_serial
"$chapter2_adb" -s "$chapter2_serial" shell service list
"$chapter2_adb" -s "$chapter2_serial" shell service check activity
"$chapter2_adb" -s "$chapter2_serial" shell dumpsys -l

预期 service list 显示名称及接口描述符,check activity 能找到相应 Binder。若未找到,先查产品服务是否存在、服务名和查询权限。dumpsys -l 是可 dump 服务视角,不能直接当作每个应用绑定 Service 的清单。查询结果也不证明调用者拥有该服务每个业务方法的权限。

自定义注册的后续实验选择专用 Native 系统服务:定义最小 ping AIDL;用对应后端生成 Stub/Proxy;配置模块、init 启动与专用 SELinux 域;为新名字登记 service_contexts,并给生产者 add、消费者 find 和必要的 Binder 调用权限。注册端记录 addService 的实际 Status;查询端分别记录未启动、启动成功、服务退出后的结果,然后用新引用再次 ping。测试只操作新服务,不终止 activity 等系统核心服务。

验收时至少保存“名称、接口描述符、宿主 PID、客户端目标 node、注册结果、查询结果、死亡后行为”。涉及 lazy service 或 accessor 时另列变体,不用经典图替代当前配置的实际链路。本节的注册实验尚未执行,系统策略的具体新增文件要随选定产品确定。

2.14 拿到 Binder 为什么仍需权限检查

组件权限与方法权限解决不同边界

前文三个进程属于同一包、同一 UID;这能验证通信与生命周期,不能证明跨 UID 安全。换成两个 APK 后,至少有三层需要分开看:

边界常见检查它能说明什么
能否绑定组件exported、组件 permission、Framework 的访问检查能否从这个入口取得引用
能否跨域传递或调用SELinux Binder、service_manager 等策略当前安全域是否允许相应交互
能否执行方法服务端的权限、UID、用户与业务状态检查当前调用者是否有权完成具体操作

接口描述符校验只检查协议入口,不代表业务授权。 即使某个 Binder 通过另一条获准通道传给了调用者,服务端仍应按契约保护敏感方法,不能只依赖最初的 bindService 入口。

在接收线程读取身份 再切到工作线程

Binder 调用身份属于正在接收事务的线程上下文。服务端通过 Binder.getCallingUid() 取得 Driver 提供的调用者身份;客户端在 Parcel 中自报的 uid 字段只是参数,不能当成授权依据。

在接收线程读取身份 再切到工作线程(过程或对象关系)

先读真实框架入口:ContextImpl.java 的 enforceCallingPermission() 方法如下,注解省略:固定提交源码。

public void enforceCallingPermission(String permission, String message) {
    enforce(permission,
            checkCallingPermission(permission),
            false,
            Binder.getCallingUid(),
            message);
}

检查对象是当前调用者,不是参数里声明的用户。 接下来是教学片段,演示跨进程业务入口怎样先检查、再派发;不是从 AOSP 某个系统服务逐字摘取:

@Override public void request(int requestId) {
    final int callerUid = Binder.getCallingUid();
    enforceCallingPermission("com.example.permission.USE_PROBE", "USE_PROBE required");
    worker.execute(() -> handleAuthorizedRequest(requestId, callerUid));
}

在 worker 中重新调用 getCallingUid,通常得到当前服务自身的身份,不能复原之前那笔远程事务。应传入已经校验过、为业务所必需的上下文,并继续处理用户切换、撤销或资源所有权等契约。这个片段限定为远程入口;enforceCallingPermission 对同进程直接调用有不同语义,需要同时支持本地调用时应明确设计,而不是换一个 API 猜测。

clearCallingIdentity 不会给远程调用者增加权限

有些服务校验完调用者后,需要以服务自身身份执行内部操作。下面是教学结构,必须先完成外部授权,并在 finally 中恢复;runInternalOperation() 是示意方法:

final long identity = Binder.clearCallingIdentity();
try {
    runInternalOperation();
} finally {
    Binder.restoreCallingIdentity(identity);
}

它清除的是当前线程的入站调用身份,不是授权 API。 若在校验前清除,后续逻辑可能错误地以服务自身身份通过检查;若切到另一个线程才调用,它也不会清除原线程的那份上下文。源码入口见 Binder.java 的 getCallingUid、clearCallingIdentity 与 restoreCallingIdentity 声明,Native 实现在前文 JNI/libbinder 基线上继续追踪。

用两个包和两套签名设计实验

后续建立独立的 provider、consumer 模块,两者不要使用 sharedUserId。provider 声明 signature 级 com.example.permission.USE_PROBE,将 ProbeService 的 exported 设为 true,并在 service permission 和业务入口按上面的边界保护。consumer 通过显式组件绑定并请求该权限;先用不同签名构建,再用相同实验签名重建 consumer。签名不一致的 APK 不能直接覆盖安装,切换前卸载实验 consumer 包,不要误删系统包。

Manifest 的教学片段如下,省略 application 等外层,permission 与 service 均属于 provider:

<permission android:name="com.example.permission.USE_PROBE"
    android:protectionLevel="signature" />
<!-- 下列 service 放在 application 内 -->
<service android:name=".ProbeService" android:exported="true"
    android:process=":server" android:permission="com.example.permission.USE_PROBE" />

第一次预期在绑定入口拒绝,不应出现业务进入日志;第二次预期绑定与调用成功,服务端记录 consumer 的真实 UID。用 adb shell pm list packages -U 核对两包 UID,用日志关联 PID/TID。若要单独检验方法权限,在另一个实验变体中开放非敏感的取引用入口,保留敏感方法校验,再比较结果;不要把“根本没有拿到 Binder”误记为“方法内部已经拒绝”。两种变体分别记录,不在同一结果中混写。

2.15 大 Parcel、并发与 oneway 为什么会积压

先区分推荐尺寸与真实分配条件

IBinder.java 中的常量为以下摘录:固定提交源码。

public static final int MAX_IPC_SIZE = 64 * 1024;

它上方注释明确这是推荐值,而非真实事务缓冲区硬上限;getSuggestedMaxIpcSizeBytes() 返回该值。“建议小于某尺寸”和“每次调用拥有某个固定容量”是两回事。 前文 256 KiB echo 已成功,也只代表那次条件允许,不代表长期或并发下都安全。

发送请求会占目标进程的接收空间,响应又占客户端空间;序列化额外字段、在途事务、异步队列与释放时机共同影响剩余容量。失败还可能发生在序列化、Driver 分配、回复等不同阶段。不能只凭 TransactionTooLargeException 或一次 FAILED_TRANSACTION 就推导所有版本的统一阈值。

并发数要在真正发起调用的位置改变

2.7 的线程管理解释了创建、扩容、队列选择和正常常驻行为;本节在此基础上观察容量与负载。前文诊断版使用 newSingleThreadExecutor(),连续点击两次仍会先在客户端 Java 队列串行。要研究 Binder 并发,先把实验副本改成两个工作线程,让请求携带不同 requestId,再观察服务端实际 TID 和重叠区间。

并发数要在真正发起调用的位置改变(过程或对象关系)

图中分发后的两条箭头用于区分生命周期,不规定业务工作与归还缓冲区的全局先后。业务若另行投递,原事务结束时,应用队列可能仍未处理它;不能把缓冲区已归还当作业务已完成。

线程池、节点异步队列、业务锁和应用 Executor 是不同的排队位置。 同一节点的远程 oneway 调用存在异步串行处理规则;它不保证永远由同一个 TID 执行,也不能推广为所有 Binder 对象全局串行。oneway 返回说明提交路径结束,不说明队列已经排空,持续生产仍可能受到空间、冻结状态、调度或限流等影响。

源码按前文固定 C Driver 的 binder_transaction()、binder_proc_transaction()、binder_thread_read() 定位缓冲区分配、目标队列和 async 分支;Native 对照 IPCThreadState::transact() 的 TF_ONE_WAY 分支。先按条件选择一条路径,再读入队与归还,不能将同步、异步队列合并成一条逐函数链。

每次只改变一个变量

使用 Chapter2LifecycleDemo 的独立实验副本和新包名,保留前文已验证源码。为 echo 的 payloadBytes 加入显式参数并在客户端、服务端同时设置上界;建议按 32、64、128、256、512 KiB 逐级测试,若需更大再单独加到最多 2 MiB,不持续循环到设备失去响应。下面是尺寸控制的教学片段,尚未并入前文 APK:

int payloadBytes = intent.getIntExtra("payloadBytes", 32 * 1024);
if (payloadBytes < 0 || payloadBytes > 2 * 1024 * 1024) {
    throw new IllegalArgumentException("payloadBytes outside experiment range");
}
byte[] data = new byte[payloadBytes];

先做单线程、逐笔等待完成的尺寸对照;再固定一个已成功的小尺寸,将客户端并发从 1 改为 2;最后使用单向方法测试有限批次,例如 20 次,每次都带 requestId,服务端明确记录开始和结束。每轮等待业务完成再读取队列现象,遇到失败就停止该轮并保存日志,不自动重试放大流量。

每轮记录 payloadBytes、Parcel data_size、发起/接收 PID 与 TID、开始/结束、异常类型、buffer alloc/release 和业务排队位置。以分配事件关联接收空间,不用发送端数组内存大小代替 Driver 占用。恢复步骤是停止新请求、待已排队业务结束,必要时只重启实验应用,并用一次小尺寸 ping/echo 验证。大量数据的工程方案通常应考虑文件描述符、共享内存或分块协议,Binder 负责控制;选择方案时还要设计所有权、同步和清理契约。

2.16 怎样比较 C Binder 与 Rust Binder

先证明当前运行哪一套

Rust AIDL 后端与 Rust Binder Driver 是两个维度:前者决定生成的用户空间代码,后者是 Kernel 中的实现。Java AIDL 也可以与 Rust Driver 通信;用了 Rust 服务并不说明 Kernel 已切换。

在本章设备上,前文已核实 C 实现内建、Rust 配置为模块但未加载、运行参数 impl=c。下列只读命令在自己的设备上重新核对,不能直接照抄本轮结果:

"$chapter2_adb" -s "$chapter2_serial" shell cat /sys/module/binder/parameters/impl
"$chapter2_adb" -s "$chapter2_serial" shell cat /proc/modules
"$chapter2_adb" -s "$chapter2_serial" shell uname -a
"$chapter2_adb" -s "$chapter2_serial" shell getprop ro.build.fingerprint

若没有 impl 参数,先查对应版本的选择机制与启动配置,不用“文件不存在”反推实现。完整配置、模块摘要和底层来源见第一章来源清单。目录里存在 Rust 源码或 binder_rust.ko,不等于已实际使用它。

按职责对照 不按函数名强行一一对应

要比较的行为C 实现阅读位置Rust 实现阅读位置对照问题
进程与设备连接binder.c 的 open/mmap、binder_alloc.cprocess.rs 及相关分配模块每进程状态与映射怎样建立?
命令与接收binder_thread_write/readthread.rs哪个循环解释协议、等待和交付工作?
事务与对象引用binder_transaction 及 node/ref 路径transaction.rs、node.rs 等模块目标对象、在途状态和失败怎样维护?
退出与回收release、ref/node 清理路径对应对象的释放与工作清理路径进程退出如何影响等待者和死亡订阅?

这些路径是阅读入口,不保证相同职责都在同名文件。使用匹配提交源码核对具体符号;先比较可观察的协议与结果,再深入锁、所有权和生命周期实现。编程语言的内存安全机制不自动代替跨进程协议与业务正确性证明。

实际切换需要单独的冷启动实验

为两个后端各准备匹配的 Kernel、配置、模块和启动选择,启动前保存来源摘要,启动后验证运行选择及模块状态,再安装同一份诊断 APK,复跑前文三组实验。记录不能只比较成功返回值,还要比较缓冲区释放、callback 死亡清理、在途同步失败与重连。

本节不提供在活跃设备上盲目写 impl 或直接加载未知模块的切换命令;具体流程由匹配版本的 Kconfig、参数及产品启动配置确定。这里欠缺的是另一套可运行镜像与对应证据,不能用纯源码对照填成“Rust 实测通过”。两套实现的性能比较还需控制镜像、编译选项、CPU、负载与采集开销,本阶段先验证语义。

2.17 从独立 Host 构建走向 Soong 模块

两条构建路径分别证明什么

前文的构建脚本显式调用 AIDL、javac、D8、aapt2 与签名工具,适合快速形成 APK 并观察机制。Soong 则将源码、依赖、SDK、变体、签名等模块声明接入产品的构建图。独立脚本成功不代表 Android.bp 已被当前产品成功解析和构建。 反过来,Soong 成功也仍需安装运行验证。

本章每个源码包都带 Android.bp;知识库展开目录里使用 Android.bp.example,避免同名模块被整棵源码树重复扫描。不要把 AIDL 手写声明与已生成 Java 同时塞入 src,否则可能重复定义接口。

在独立模块目录构建诊断示例

以下为后续 Soong 验证步骤,当前尚无本模块的成功构建记录。在 AOSP 根目录运行;首次目录必须不存在,避免覆盖自己已有模块。示例包已经将模板改名为 Android.bp:

cd "$chapter2_top"
test ! -e packages/apps/Chapter2LifecycleDemo || {
  echo '目标模块目录已存在,请先检查已有内容'; exit 1;
}
unzip "$chapter2_top/Android源码学习笔记/章节学习/第二章-Binder与AIDL/示例/Chapter2LifecycleDemo.zip" \
  -d packages/apps
source build/envsetup.sh
lunch sdk_phone64_x86_64 aosp_current userdebug
set -o pipefail
m Chapter2LifecycleDemo -j2 2>&1 | tee "$HOME/chapter2-soong-build.log"

lunch 的产品与 release 必须对应自己的设备和当前树;上面沿用本知识库的 SDK Emulator 产品。pipefail 防止 tee 成功掩盖真正构建失败。Soong 可能先构建工具与依赖,不能以“开始出现编译输出”判断完成。

成功后先定位实际模块产物,再安装,不能拿独立脚本上次生成的同名 APK 冒充:

rg --files --no-ignore out/target/product/emu64x out/soong/.intermediates/packages/apps/Chapter2LifecycleDemo \
  -g 'Chapter2LifecycleDemo.apk'

预期找到当前构建生成的 APK;查清候选路径、时间和签名后再设置 chapter2_soong_apk 为实际选择的文件。安装到独立设备,按前文执行三组生命周期实验,保留构建日志、退出码、APK SHA-256 与运行结果。此处安装与运行复用前文命令,只替换输入 APK 的来源。

若报重复模块,优先检查是否多解压了一份;若提示找不到目标,检查 module name、Android.bp 文件名、源码路径及构建上下文。验证完成后可将本次新增模块移到 AOSP 树外保存,避免后续全树构建继续扫描;知识库原始示例仍保留。不要删除自己在实验前已有的目录。

2.18 回顾 自测与源码速查

把一次 add 完整说一遍

客户端从绑定回调拿到 Binder,asInterface 为远端对象创建具体 AIDL Proxy。Proxy 按约定写 Parcel 并提交事务,经 BinderProxy、JNI、BpBinder、IPCThreadState 和 ioctl 到达 Driver。Driver 根据引用找到目标并安排线程接收,服务端 libbinder 与 JNI 回到 Java Stub,再执行 add。

结果沿 BC_REPLY、Driver、BR_REPLY 返回客户端,Proxy 读出异常状态与整数结果。对象引用、线程、缓冲区和权限检查共同支撑这个过程,不能只把它压缩成一句“跨进程调了一个方法”。

把获取 调用 回调与结束连成同一个模型

阶段目标对象与关键交接阅读定位
获取系统管理绑定,连接通知携带业务引用,客户端包装成接口代理2.8
正向请求业务 Proxy 写参数;当前线程进入等待循环与 ioctl;Driver 根据业务 handle 定位实体2.4~2.6
接收与执行服务端自己的 Binder 接收循环读到工作,Native/JNI 回到业务 Stub2.7
同步回复原事务记录发起线程,reply 返回该线程,Proxy 读取结果2.7
主动通知注册参数导出客户端 callback,服务端通过另一份代理发起反向事务2.9
结束事务缓冲区归还、对象引用下降、组件解绑分别管理;分别取运行证据2.11、2.12 实验五~七
服务发现按名称登记和取得引用,后续业务直接访问目标对象2.13
权限与身份在正确的线程上下文校验调用者,再按契约执行业务2.14
容量与并发区分接收空间、节点队列、线程池和应用队列2.15
Driver 对照先确认运行实现,再比较相同协议与失败场景2.16
构建集成将示例接入 Soong,区分独立 Host 产物与产品构建产物2.17

第一次读懂的标志,是能指出每次事务的目标节点、当前执行线程、数据容器和结束条件。字段与地址的创建细节可回到 2.10 查阅;实验现象和代码之间的对应见 2.12。

自测题

  1. 一个 APK 怎样产生真实跨进程 Binder 调用?同 UID 是否表示同进程?

  2. AIDL Proxy 与 BinderProxy 有什么区别?

  3. 为什么同进程的 oneway 方法可能阻塞调用者?

  4. BC_TRANSACTION、BINDER_WRITE_READ、BR_TRANSACTION 分别是什么?

  5. Driver 为什么不能直接根据 Java 方法名执行 add?

  6. BR_TRANSACTION_COMPLETE 为什么不能当作业务完成?

  7. /dev/binder 的 mmap 是否表示两个应用可任意读写对方内存?

  8. onServiceConnected 与服务端 add 是否必然在主线程?

  9. 为什么 DemoService 不出现在 service list 中仍可以工作?

  10. 怎样把 Cuttlefish 的 Rust 配置与当前设备实际实现区分开?

  11. linkToDeath 成功能否保证下一次 add 成功?

  12. 若要业务完成通知,oneway 是否足够?

  13. 服务端业务 Stub 与客户端独立创建的 callback Stub 是否对应同一个 binder_node?

  14. registerCallback 的事务目标,与它的 callback 参数,分别指向哪里?

  15. 为什么要分别配对请求与回复的 alloc/release,而不是只看 recycle 日志?

  16. callback 客户端突然死亡,怎样证明是服务端自动清理而非主动注销?

  17. 在途同步调用失败后,收到 binderDied 就能继续使用旧代理吗?

  18. DeathRecipient 的注册需要新建业务 callback 节点吗?cookie 是哪一方的地址?

  19. BR_SPAWN_LOOPER 是谁创建线程?默认配置 15 是否等于进程总共 15 条接收线程?

  20. 死亡通知是否自动切主线程?Binder 池是否像普通 Executor 一样闲置超时缩容?

  21. 进程被 SIGKILL、没有执行 onDestroy,Driver 怎样开始清理?为什么单次 close 或单线程退出还不足以判断节点死亡?

  22. ServiceManager 找到业务 Binder 后,每次调用还要再按名字查询吗?

  23. exported=true 能否代替方法权限检查?

  24. 为什么在 worker 中读取 getCallingUid 不能辨认之前的远程调用者?

  25. 256 KiB echo 成功,能否推导同进程两笔并发请求也一定成功?

  26. 改成 oneway 能否消除业务队列与接收空间压力?

  27. 存在 Rust 模块、独立 APK 已能运行,分别还缺什么证据?

参考答案:

  1. 为 Service 设置私有 remote 进程,分别核对 PID;同 UID 是身份关系,不等于同一进程。见 2.3。

  2. 前者负责具体接口的方法、参数与事务编号,后者是通用 Java 远端 Binder 对象并连接 Native。见 2.4、2.5。

  3. asInterface 直接返回本地实现,调用不经过远程单向事务调度。见 2.4、2.12。

  4. 分别是用户向 Driver 的事务命令、承载读写协议的 ioctl 请求、Driver 向接收线程交付事务的协议命令。见 2.5、2.6。

  5. Driver 处理引用、编号与缓冲区;Java Stub 才按编号调用具体接口实现。见 2.6、2.7。

  6. 它是协议阶段通知;同步业务结果由 reply 返回,单向业务也可能尚未完成。见 2.7、2.12。

  7. 不是。映射服务于本进程 Binder 缓冲区,发送、接收和引用都有 Driver 管理。见 2.6。

  8. 本例普通连接通知在客户端主线程回调,跨进程业务在服务端 Binder 分发线程,同进程又有不同路径。见 2.3、2.12。

  9. 应用绑定流程交付 Binder,不等于把该组件按名称注册进系统 ServiceManager。见 2.8。

  10. 分别记录产品配置、启动参数、运行状态、模块与源码提交,必要时检查回退和加载记录。见 2.6。

  11. 不能;死亡与调用之间存在竞态,仍需处理失败与重新获取引用。见 2.12。

  12. 不够;需显式回调、状态查询或其他业务完成协议。见 2.9、2.12。

  13. 不是。它们是两个进程中的独立实体,各有自己的节点;引用持续存活时,反复调用同一份 callback 不等于反复创建节点。见 2.9。

  14. 事务目标指向服务端业务节点;参数描述客户端回调实体,服务端收到相应代理后才能反向调用。见 2.9。

  15. 请求与回复分别占各自接收方的缓冲区;同一 transaction ID 的分配/释放事件证明选定缓冲区归还,不能据此推出对象也已释放。见 2.12 实验五。

  16. 单独终止 callback 进程,保持服务端存活,确认没有主动注销路径,并观察死亡通知、订阅数归零与后续通知结束。见实验六。

  17. 不能;原等待由错误返回结束,新连接交付新 Binder 后应用更新代理,再验证业务调用。见实验七。

  18. 不需要;复用原代理引用登记死亡事件。Driver 回传的 cookie 是监听方自己的 BpBinder 地址,由监听方 libbinder 解释。见 2.11。

  19. Driver 只是请求,ProcessState 创建 PoolThread;默认配置限制按请求补充的数量,总容量还要计入初始线程和手工加入者。见 2.7。

  20. 不会自动切主线程;回调在处理死亡命令的接收线程执行。当前固定 Driver 正常等待没有空闲计时缩容机制,不能仅凭 Native 的 TIMED_OUT 分支推断自动回收。见 2.7、2.11。

  21. Linux 退出路径回收资源,最后文件引用回收时由 VFS 调用 binder_release,再由工作队列清理节点并安排死亡通知;文件表和 struct file 各有引用计数,所以单线程退出或单次 close 不一定触发最终释放。见 2.11 的宿主退出感知。

  22. 不需要;使用业务引用发起事务。缓存与查询行为另看具体 API,见 2.13。

  23. 不能;组件可访问、协议匹配与业务授权分别判断,见 2.14。

  24. Binder 身份保存在接收线程上下文中,切线程不会自动携带,见 2.14。

  25. 不能;并发占用、回复和释放时机均影响剩余接收空间,见 2.15。

  26. 不能;它不等待业务 reply,仍有提交、排队和资源约束,见 2.15。

  27. 前者缺运行实现选择与实际行为证明;后者缺 Soong 成功构建和该产物的安装运行记录,见 2.16~2.17。

阅读与操作速查

目的入口
看生成代码记录目录 generated/.../ICalculator.java
看本地接口判定Binder.queryLocalInterface、BinderProxy.queryLocalInterface
跟踪客户端 Java 到 NativeBinderProxy.transactNative、android_os_BinderProxy_transact
跟踪 Native 事务BpBinder::transact、IPCThreadState::transact/talkWithDriver
跟踪服务端与 ReplyexecuteCommand、JavaBBinderExt::onTransact、Stub.onTransact、sendReply
看 C Driverbinder_ioctl_write_read、binder_transaction、binder_thread_read
看 Rust Driverprocess.rs、thread.rs、transaction.rs
看系统服务查询2.13:Java ServiceManager、Native ServiceManager.cpp
看权限与调用身份2.14:组件访问、方法授权、getCallingUid 与身份恢复
看容量与并发2.15:接收空间、线程池与业务队列
看 C/Rust 对照2.16:运行选择、相同协议与失败场景
看 Soong 集成2.17:模块声明、构建产物和安装验证
看应用绑定ActivityThread.handleBindService、ActiveServices、LoadedApk.ServiceDispatcher
看业务回调registerCallback 写入 Binder 参数、服务端保存回调代理、客户端 callback Stub.onTransact
看线程池管理2.7:startThreadPool、BR_SPAWN_LOOPER、joinThreadPool、线程与进程 todo
看死亡代理与通知2.11:JavaDeathRecipient、mObituaries、binder_ref_death、BR_DEAD_BINDER、sendObituary

本文源码基线与验证范围

材料固定提交或来源
frameworks/base94b4c163b7dfe5ce3607f7bb8456f9573f7de57d
frameworks/nativeae266dcb706d083868578cfedce381ef44488a07
system/tools/aidl 源码入口9a94664f74536bf28010207fd1804b04c6435e2c
Goldfish 预编译 Kernel 仓库prebuilts/qemu-kernel,7fe7e19e1bdb1850d637ce32b206db0b61fc937e
本文 Kernel 阅读基线kernel/common,ccafb60de224d35a8bc14de33e1cd47caaaa786b

基础版与 callback 完整版已通过 Host AIDL、JDK 21、current 公共 android.jar、D8、aapt2 与测试密钥签名生成 APK,并在上述 Emulator 安装运行。已验证加法、同步与 oneway、业务回调与主线程交接、注销与重新注册、服务端死亡通知及同进程对照,并保留真实 Perfetto 数据与解读。现有 Host 二进制未宣称已经重建到生成器源码提交,生成结果以实际工具为准。

此前的 Soong 模块构建尝试未取得成功退出记录,因此不计入已验证范围;前面的独立 Host 构建提供可复现的设备实验路径。后续 2026-10-19 的独立来源核对已确认当前镜像使用 C Binder,证据见 2.6;2026-10-20 的独立诊断示例进一步验证了请求/回复缓冲区释放、选定 token 的 ref/node 消失、callback 客户端异常死亡后的订阅清理,以及同步在途调用失败后重连。证据只针对这些场景,不等于所有引用分支或竞态都已验证;ServiceManager 独立注册、跨 UID 安全、容量与并发、Rust 实际切换及 Soong 成功构建的后续验证分别见 2.13~2.17。

后续实验顺序与验收目标

建议顺序要回答的问题需要的实验条件完成判据
1ServiceManager 怎样登记、查找、清理服务?先查询现有服务;自定义注册需专用系统组件及对应策略找到登记与查找对象,证明拿到引用后的业务调用不再查表;补服务死亡后的处理
2跨 UID 调用在哪里被拒绝?两个独立包名,签名允许/不允许两种安装组合拒绝发生在哪层、合法调用的 UID、业务方法是否进入都有证据
3大 Parcel、并发与 oneway 积压如何区分?独立实验设备,尺寸与并发均有上界将参数大小、接收分配、业务排队和失败关联;保留恢复结果
4C/Rust Binder 怎样做同条件对照?两套匹配镜像、配置、模块与启动选择每次先证明运行实现,再比较相同接口与失败语义
5独立 APK 怎样纳入 Soong?已选定的 AOSP 产品、完整构建依赖Soong 成功退出、目标 APK 存在、安装后复跑同一组实验

建议先做 1 的只读观察,再准备 2 与 3 的工程;5 可提前用于构建实验模块。4 需要额外镜像材料,放到最后。每项单独记录来源和证据,完成其中一项不代表全部扩展实验完成。

参考资料