上篇已走通 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 与 wp | Native 强引用与弱引用包装 | 强引用参与保活;弱引用需要尝试提升后再使用 |
| 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。
客户端 → 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_node | Kernel | Binder 实体被导出、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 Parcel | Proxy 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_death | Kernel | 关联监听方 binder_ref,保存死亡工作和回传 cookie |
| 被监听的 binder_node | Kernel | 远端实体的节点,宿主退出时触发关联引用的死亡处理 |
本节仍沿 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 场景中则可以是服务端:
Driver 怎样感知宿主进程退出
入口是 Binder 设备文件的 release 回调。 宿主进程打开 Binder 设备后,内核保存一份文件对象与 Binder 进程状态的关联;进程退出时,Linux 回收文件引用,最终由 VFS 调用该设备的 release。Driver 从这里开始释放连接、清理节点,随后才产生我们前面讨论的死亡通知。因此 SIGKILL 不要求应用先执行 onDestroy,也不要求死亡进程再给 Driver 发一条告别消息。
先认识三个不同对象:fd 是进程文件表里的编号,struct file 是内核中的打开文件对象,binder_proc 则是这次 Binder 打开连接的驱动状态。退出清理沿文件引用找到 binder_proc,不靠 Java Service 的生命周期回调找到它。 下面是本章固定 Kernel 基线的退出主路径,图中方框写明引用条件;共享文件表或其他文件引用仍在时,不能直接跨过这些条件:
先看打开时怎样保存关联。 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 怎样把消息送回监听方
承接前面的 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 行识别任意业务对象;此处结合已知测试进程、线程与对应日志作对照。完整提取见协议复核记录。
把释放与死亡分成四个问题
- 本次请求和响应是否归还了接收缓冲区?看 Parcel 的所有权与 BC_FREE_BUFFER。
- 对象引用是否还被应用、框架、订阅或在途事务持有?看代理引用和 Driver 计数。
- Service 是否还需要存活?看绑定关系、启动状态与宿主进程。
- 远端宿主已经退出时,监听方如何获知?看 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 仍需处理提交和协议结果,可能有背压、调度、等待或失败。
图中单向调用的两条路径不规定全局先后:客户端可能在业务完成前返回,但不保证服务端一定在客户端返回后才开始。区别是是否等待业务 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 中按以下顺序观察,不把所有轨道同时展开:
- 搜索 BinderDemo.sync,找到服务端 Binder 线程上的约 1200 ms 区间;对照客户端工作线程,观察它在这次同步事务中的等待。该区间包含示例主动休眠,不代表线程连续占用 CPU。
- 查看紧接着的 BinderDemo.oneway。客户端 BinderDemo.runCalls 已可结束,服务端还在完成约 1200 ms 的业务。利用 Binder 事务和线程事件关联两端,不能只按时间接近判断。
- 搜索 CallbackDemo.request,定位客户端提交注册和计算请求的线程;再定位服务端工作线程上的 CallbackDemo.compute。业务方法只是排队,因此这两个区间的结束时刻没有“计算必须先结束”的约束。
- 找到客户端 Binder 线程上的 CallbackDemo.onResult,再找到主线程的 CallbackDemo.mainResult。两者通过 Handler 交接;这正是 2.9 的回调实现,不能把它误读成 Binder 自动回调主线程。
- 查看事务的 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。
| 实测区间 | PID / TID | 持续时间与含义 |
|---|---|---|
| CallbackDemo.request | 2527 / 2577 | 约 6.65 ms,客户端完成注册与排队请求 |
| CallbackDemo.compute | 2550 / 2578 | 约 122.94 ms,服务端工作线程计算并通知,包含主动休眠 |
| CallbackDemo.onResult | 2527 / 2538 | 约 0.093 ms,客户端 Binder 线程接收业务 callback |
| CallbackDemo.mainResult | 2527 / 2527 | 约 0.544 ms,Handler 投递后在客户端主线程更新结果 |
本轮客户端 onResult 开始时,服务端 compute 区间尚未结束;这个区间包含通知和收尾,并不只是加法计算。这说明发送 oneway 通知以后,两端可以并发推进。
这轮收到的数值为 15。客户端 callback 与主线程处理相邻,但 TID 不同;结合 MainActivity 中明确的 Handler.post,才能把时间线对应到线程交接。单凭两个时间点接近,不能推断任意两段代码具有因果关系。
本轮 Binder 事件还记录了两个不同的目标节点:
| 调用方向 | 事务与目标 | 本轮 destination node |
|---|---|---|
| 客户端注册 callback | registerCallback 的目标是服务端业务实体,事务 ID 61765 | 59455 |
| 服务端通知客户端 | onResult 的目标是客户端 callback,事务 ID 65250 | 61766 |
这为 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,:server | echo、独立 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 客户端 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 返回 false | Manifest、组件名、安装状态与绑定错误 | 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.c | process.rs 及相关分配模块 | 每进程状态与映射怎样建立? |
| 命令与接收 | binder_thread_write/read | thread.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 回到业务 Stub | 2.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。
自测题
-
一个 APK 怎样产生真实跨进程 Binder 调用?同 UID 是否表示同进程?
-
AIDL Proxy 与 BinderProxy 有什么区别?
-
为什么同进程的 oneway 方法可能阻塞调用者?
-
BC_TRANSACTION、BINDER_WRITE_READ、BR_TRANSACTION 分别是什么?
-
Driver 为什么不能直接根据 Java 方法名执行 add?
-
BR_TRANSACTION_COMPLETE 为什么不能当作业务完成?
-
/dev/binder 的 mmap 是否表示两个应用可任意读写对方内存?
-
onServiceConnected 与服务端 add 是否必然在主线程?
-
为什么 DemoService 不出现在 service list 中仍可以工作?
-
怎样把 Cuttlefish 的 Rust 配置与当前设备实际实现区分开?
-
linkToDeath 成功能否保证下一次 add 成功?
-
若要业务完成通知,oneway 是否足够?
-
服务端业务 Stub 与客户端独立创建的 callback Stub 是否对应同一个 binder_node?
-
registerCallback 的事务目标,与它的 callback 参数,分别指向哪里?
-
为什么要分别配对请求与回复的 alloc/release,而不是只看 recycle 日志?
-
callback 客户端突然死亡,怎样证明是服务端自动清理而非主动注销?
-
在途同步调用失败后,收到 binderDied 就能继续使用旧代理吗?
-
DeathRecipient 的注册需要新建业务 callback 节点吗?cookie 是哪一方的地址?
-
BR_SPAWN_LOOPER 是谁创建线程?默认配置 15 是否等于进程总共 15 条接收线程?
-
死亡通知是否自动切主线程?Binder 池是否像普通 Executor 一样闲置超时缩容?
-
进程被 SIGKILL、没有执行 onDestroy,Driver 怎样开始清理?为什么单次 close 或单线程退出还不足以判断节点死亡?
-
ServiceManager 找到业务 Binder 后,每次调用还要再按名字查询吗?
-
exported=true 能否代替方法权限检查?
-
为什么在 worker 中读取 getCallingUid 不能辨认之前的远程调用者?
-
256 KiB echo 成功,能否推导同进程两笔并发请求也一定成功?
-
改成 oneway 能否消除业务队列与接收空间压力?
-
存在 Rust 模块、独立 APK 已能运行,分别还缺什么证据?
参考答案:
-
为 Service 设置私有 remote 进程,分别核对 PID;同 UID 是身份关系,不等于同一进程。见 2.3。
-
前者负责具体接口的方法、参数与事务编号,后者是通用 Java 远端 Binder 对象并连接 Native。见 2.4、2.5。
-
asInterface 直接返回本地实现,调用不经过远程单向事务调度。见 2.4、2.12。
-
分别是用户向 Driver 的事务命令、承载读写协议的 ioctl 请求、Driver 向接收线程交付事务的协议命令。见 2.5、2.6。
-
Driver 处理引用、编号与缓冲区;Java Stub 才按编号调用具体接口实现。见 2.6、2.7。
-
它是协议阶段通知;同步业务结果由 reply 返回,单向业务也可能尚未完成。见 2.7、2.12。
-
不是。映射服务于本进程 Binder 缓冲区,发送、接收和引用都有 Driver 管理。见 2.6。
-
本例普通连接通知在客户端主线程回调,跨进程业务在服务端 Binder 分发线程,同进程又有不同路径。见 2.3、2.12。
-
应用绑定流程交付 Binder,不等于把该组件按名称注册进系统 ServiceManager。见 2.8。
-
分别记录产品配置、启动参数、运行状态、模块与源码提交,必要时检查回退和加载记录。见 2.6。
-
不能;死亡与调用之间存在竞态,仍需处理失败与重新获取引用。见 2.12。
-
不够;需显式回调、状态查询或其他业务完成协议。见 2.9、2.12。
-
不是。它们是两个进程中的独立实体,各有自己的节点;引用持续存活时,反复调用同一份 callback 不等于反复创建节点。见 2.9。
-
事务目标指向服务端业务节点;参数描述客户端回调实体,服务端收到相应代理后才能反向调用。见 2.9。
-
请求与回复分别占各自接收方的缓冲区;同一 transaction ID 的分配/释放事件证明选定缓冲区归还,不能据此推出对象也已释放。见 2.12 实验五。
-
单独终止 callback 进程,保持服务端存活,确认没有主动注销路径,并观察死亡通知、订阅数归零与后续通知结束。见实验六。
-
不能;原等待由错误返回结束,新连接交付新 Binder 后应用更新代理,再验证业务调用。见实验七。
-
不需要;复用原代理引用登记死亡事件。Driver 回传的 cookie 是监听方自己的 BpBinder 地址,由监听方 libbinder 解释。见 2.11。
-
Driver 只是请求,ProcessState 创建 PoolThread;默认配置限制按请求补充的数量,总容量还要计入初始线程和手工加入者。见 2.7。
-
不会自动切主线程;回调在处理死亡命令的接收线程执行。当前固定 Driver 正常等待没有空闲计时缩容机制,不能仅凭 Native 的 TIMED_OUT 分支推断自动回收。见 2.7、2.11。
-
Linux 退出路径回收资源,最后文件引用回收时由 VFS 调用 binder_release,再由工作队列清理节点并安排死亡通知;文件表和 struct file 各有引用计数,所以单线程退出或单次 close 不一定触发最终释放。见 2.11 的宿主退出感知。
-
不需要;使用业务引用发起事务。缓存与查询行为另看具体 API,见 2.13。
-
不能;组件可访问、协议匹配与业务授权分别判断,见 2.14。
-
Binder 身份保存在接收线程上下文中,切线程不会自动携带,见 2.14。
-
不能;并发占用、回复和释放时机均影响剩余接收空间,见 2.15。
-
不能;它不等待业务 reply,仍有提交、排队和资源约束,见 2.15。
-
前者缺运行实现选择与实际行为证明;后者缺 Soong 成功构建和该产物的安装运行记录,见 2.16~2.17。
阅读与操作速查
| 目的 | 入口 |
|---|---|
| 看生成代码 | 记录目录 generated/.../ICalculator.java |
| 看本地接口判定 | Binder.queryLocalInterface、BinderProxy.queryLocalInterface |
| 跟踪客户端 Java 到 Native | BinderProxy.transactNative、android_os_BinderProxy_transact |
| 跟踪 Native 事务 | BpBinder::transact、IPCThreadState::transact/talkWithDriver |
| 跟踪服务端与 Reply | executeCommand、JavaBBinderExt::onTransact、Stub.onTransact、sendReply |
| 看 C Driver | binder_ioctl_write_read、binder_transaction、binder_thread_read |
| 看 Rust Driver | process.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/base | 94b4c163b7dfe5ce3607f7bb8456f9573f7de57d |
| frameworks/native | ae266dcb706d083868578cfedce381ef44488a07 |
| 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。
后续实验顺序与验收目标
| 建议顺序 | 要回答的问题 | 需要的实验条件 | 完成判据 |
|---|---|---|---|
| 1 | ServiceManager 怎样登记、查找、清理服务? | 先查询现有服务;自定义注册需专用系统组件及对应策略 | 找到登记与查找对象,证明拿到引用后的业务调用不再查表;补服务死亡后的处理 |
| 2 | 跨 UID 调用在哪里被拒绝? | 两个独立包名,签名允许/不允许两种安装组合 | 拒绝发生在哪层、合法调用的 UID、业务方法是否进入都有证据 |
| 3 | 大 Parcel、并发与 oneway 积压如何区分? | 独立实验设备,尺寸与并发均有上界 | 将参数大小、接收分配、业务排队和失败关联;保留恢复结果 |
| 4 | C/Rust Binder 怎样做同条件对照? | 两套匹配镜像、配置、模块与启动选择 | 每次先证明运行实现,再比较相同接口与失败语义 |
| 5 | 独立 APK 怎样纳入 Soong? | 已选定的 AOSP 产品、完整构建依赖 | Soong 成功退出、目标 APK 存在、安装后复跑同一组实验 |
建议先做 1 的只读观察,再准备 2 与 3 的工程;5 可提前用于构建实验模块。4 需要额外镜像材料,放到最后。每项单独记录来源和证据,完成其中一项不代表全部扩展实验完成。