打开一个 content URI,Provider 已经返回 ParcelFileDescriptor,应用为什么还要自己 read?本例经 Binder 拿到的是普通文件的打开引用,随后 read 才把字节放进客户端缓冲区。query 交回可读的一批行,以及按需取得下一批的远端接口。直接写文件时,write 接受字节,fsync 再报告同步结果。
在资料室查档案时,地址说明该找谁。工作人员核对后给出入口,翻到内容还要下一步。本章的一个 APK 有两个进程。我们在客户端依次比较直接文件读写、Provider 打开文件和 SQLite 查询,沿途核对谁打开文件、谁读取字节、谁关闭资源。卷挂载、FUSE 和文件加密放在访问条件变化时讲。
10.1 先把文件、Provider 与存储管理放回整体架构
路径、URI 与 fd 分别回答不同问题
/data/user/0/com.example.storagedemo/files/direct.txt 是文件系统路径。内核结合当前进程的挂载视图、目录遍历与访问检查解析它。content://com.example.storagedemo.files/file/payload.txt 是 Provider 接口地址:authority 定位组件,后半段由组件解释;它并不要求在磁盘上存在同名目录。
fd 是进程文件描述符表中的一个整数槽位。成功打开文件后,read(fd, ...) 使用这个槽位对应的打开文件状态,通常不需要重新解析原路径。Java 的 FileDescriptor 包装该进程中的描述符;ParcelFileDescriptor 在此基础上提供跨进程传递与关闭责任的封装。路径描述“去哪找”,URI 描述“找谁提供什么”,fd 描述“本进程已取得的打开资源”。
| 概念 | 主要职责 | 例子与边界 |
|---|---|---|
| ContentResolver | 应用访问 Provider 的统一入口,获取组件引用并发起请求 | query、openFileDescriptor;不要求所有结果都是文件 |
| ContentProvider | 执行接口、检查 URI 和权限,决定怎样提供数据 | 可返回数据库 Cursor、普通文件、pipe、代理文件等 |
| StorageManager / StorageManagerService | 存储卷信息、挂载与用户存储管理 | 控制卷状态,不逐次代理每一个文件 read |
| vold | 系统 Native 存储管理进程 | 挂载、用户密钥与相关配置;不是 Java 文件 I/O 的固定中转站 |
| VFS | Kernel 文件接口抽象与分派 | 根据实际文件系统选择 file_operations |
| 页缓存 | 文件数据在内存中的缓存与回写基础 | 命中时可以不产生本次块设备读取 |
| 块层与 Driver | 将需要的块 I/O 调度到设备后端 | 本章沿历史 Emulator 基线读 VirtIO block;真实设备可能用 UFS、eMMC 等 |
先区分三条路径 再看它们怎样汇合
先看左侧的文件数据线,再看蓝色的 Provider 请求和回复。右侧是卷与密钥控制。
三个入口有不同的完成条件。对照流程图看路径打开、URI 打开和查询分别取得什么,再沿着文件或窗口读到结果。
全章时序沿用同一套生命线。上半部按示例工作线程的顺序排直接读写、打开 URI 和查询。末两段是独立的卷挂载与用户解锁。手机上可先看阶段标题,再放大查看方法和箭头。
直接文件访问通常在应用进程内经 libcore、JNI、Bionic 进入 openat/read/write。Provider 访问先通过 Binder 发出控制请求;若返回普通文件 fd,客户端后续用自己的 fd 读文件,内容不需要逐块再次打包成 Binder 参数。若返回 Cursor,则要看 CursorWindow 与远端 Cursor 的协议,不能画成同一种数据返回。
卷管理改变路径所指的挂载和应用看到的视图。外部模拟存储路径可能进入 Kernel FUSE,再由 MediaProvider 的 FUSE daemon 执行策略或访问下层文件;应用私有 /data/user/... 文件不应无条件画成先走 MediaProvider/FUSE。
这几条主线没有一个统一的“Storage HAL”。文件加密的密钥保护可能连接 keystore2/KeyMint,见 10.8;它是条件分支,不是每次文件读写都经过的层。
先确认阅读基线 再决定走哪个后端
本文用户空间采用本工程 Android 17 源码,Kernel 阅读基线为第一章已定位的 ccafb60de224。源码树、运行镜像和设备状态分别核对。本文涉及的项目提交列于 10.11;各摘录都附固定提交链接。第一章底层来源清单与第五章历史存储观察表明,那一轮 Emulator 的 /data 使用 ext4,设备关系最终落到 virtio_blk。第五章的 /data → ext4 → dm → VirtIO block 记录仅作为历史后端线索,不充当本章实测。
这些材料可以用来建立阅读主线,但不能据此认定当前设备号仍是 dm-6 或 vdc。不同镜像、挂载配置和存储形态须重新定位;没有取得的硬件、Host 精确实现或加密配置,保留待核验,不能用相近产品的代码补成“本机实际链路”。
10.2 准备一个可对照的双进程示例
示例要回答哪三个问题
同一应用的 Activity 在默认进程,DemoProvider 在 :provider 进程。Activity 的工作线程依次直接写读 direct.txt、打开 Provider 的 payload.txt、查询 Provider 的 metadata。Provider 用自己的普通文件提供内容,用 SQLite 保存一行描述信息。
| 操作 | API 与产物 | 要观察的区别 |
|---|---|---|
| 直接文件 | FileOutputStream / FileInputStream;应用 files 下的 direct.txt | 不需要为这次文件内容主动调用 Provider Binder |
| Provider 文件 | ContentResolver → 返回 ParcelFileDescriptor → InputStream | 先有跨进程打开,随后客户端自己读 fd |
| Provider 查询 | Provider 用 SQLiteCursor 填窗,客户端通过 Cursor 适配器读当前窗口 | 行数据和补窗接口按协议返回,数据库仍在 Provider 一侧 |
Provider 不导出,同一个 APK 内双方通常同 UID、不同 PID。这个布局用来观察跨进程,不用来证明跨 UID 权限隔离。 同 UID 仍可直接访问同一私有目录;我们选择 URI 路径,是为比较访问方式。Provider 接口只有固定只读 URI,客户端不能把任意路径拼给它打开。
先准备 Host 与示例目录
下面所有命令都在 Host 的 Bash 终端 A 执行。源码根路径不同则修改第一行。Host 工具需由第一章准备好;本章脚本不替你下载 SDK 或完整编译系统。
chapter10_top=/absolute/path/to/aosp
cd "$chapter10_top" || exit 1
chapter10_run=$(mktemp -d "$HOME/aosp-chapter10.XXXXXX") || exit 1
chapter10_notes="$chapter10_run"
chapter10_module="$chapter10_notes/示例/Chapter10StorageDemo"
chapter10_adb="$chapter10_top/out/host/linux-x86/bin/adb"
mkdir -p "$chapter10_module/src/com/example/storagedemo" \
"$chapter10_notes/示例/追踪配置" || exit 1
test -x "$chapter10_adb" || exit 1
"$chapter10_adb" devices -l || exit 1
read -r -p '输入本次设备 serial:' chapter10_serial
test -n "$chapter10_serial" || exit 1
chapter10_boot=$("$chapter10_adb" -s "$chapter10_serial" shell getprop sys.boot_completed) || exit 1
test "${chapter10_boot//$'\r'/}" = 1 || exit 1
"$chapter10_adb" -s "$chapter10_serial" shell getprop ro.build.fingerprint || exit 1
"$chapter10_adb" -s "$chapter10_serial" shell uname -a || exit 1
预期 boot_completed 为 1,serial 与设备列表一致。空列表或 offline 时先回第一章排查运行器与连接;不要将其当作 Provider 问题。本章写作时没有执行上述设备命令。
把文末“附录 A 示例完整输入文件”的四个文件保存到 $chapter10_run/示例/Chapter10StorageDemo/;再把附录 B 的两个追踪文件保存到 $chapter10_run/示例/ 下对应路径。先保存文件,再执行构建。 目录如下:
Chapter10StorageDemo/
Android.bp.example
AndroidManifest.xml
src/com/example/storagedemo/MainActivity.java
src/com/example/storagedemo/DemoProvider.java
源码包见Chapter10StorageDemo.zip,展开版本在示例目录。仓库里保留 Android.bp.example,防止 Soong 自动扫描知识库形成重复模块;ZIP 内使用真正的 Android.bp。
先读三个核心动作
以下均为本章手写示例摘要,不是 AOSP 原文;完整生命周期和错误处理在附录。
直接写文件时,工作线程创建流、写入、请求同步,再让 try-with-resources 关闭流:
try (FileOutputStream out = new FileOutputStream(file)) {
out.write(bytes);
Os.fsync(out.getFD());
}
Os.fsync 和 close 有不同职责。 前者报告该同步请求的结果,后者结束描述符所有权;新建文件的目录项持久化还涉及父目录,不能把这段示例称为通用的掉电原子更新方案。
Provider 返回的是一个打开资源,客户端把它交给会关闭 PFD 的流:
ParcelFileDescriptor pfd = resolver.openFileDescriptor(uri, "r");
if (pfd == null) throw new IOException("Provider returned null");
try (InputStream in = new ParcelFileDescriptor.AutoCloseInputStream(pfd)) {
// 笔记摘要:循环读取至 EOF。
}
只创建 new FileInputStream(pfd.getFileDescriptor()) 并不清楚表达 PFD 的完整清理责任。 此处用 AutoCloseInputStream,把普通 fd 关闭与 Resolver 包装的引用释放一起带到明确的结束点。
查询则是另一种资源:
try (Cursor cursor = resolver.query(metadataUri,
new String[]{"_id", "label", "bytes"}, null, null, null)) {
if (cursor == null || !cursor.moveToFirst()) {
throw new IllegalStateException("Missing metadata row");
}
// 笔记摘要:按列名读取当前行。
}
这里的 Cursor.close() 要关闭查询与远端适配器关系,不能用“应用最终会 GC”替代。
用 Soong 生成本轮 APK
沿用第一章已经选好产品配置的 AOSP 终端,并在源码根目录执行。把附录 A 的文件复制到新建的实验模块后再编译。已有同名目录时,先对照本篇输入,在确认内容一致后单独执行 m 和后面的 APK 核对。
unset chapter10_apk
chapter10_soong_dir="$chapter10_top/packages/apps/Chapter10StorageDemo"
if mkdir "$chapter10_soong_dir" &&
cp -R "$chapter10_module/." "$chapter10_soong_dir/" &&
mv "$chapter10_soong_dir/Android.bp.example" "$chapter10_soong_dir/Android.bp" &&
m Chapter10StorageDemo &&
chapter10_product_out=$(get_build_var PRODUCT_OUT); then
chapter10_candidate="$chapter10_product_out/system/app/Chapter10StorageDemo/Chapter10StorageDemo.apk"
if test -s "$chapter10_candidate" && sha256sum "$chapter10_candidate"; then
chapter10_apk="$chapter10_candidate"
else
find "$chapter10_product_out" -name Chapter10StorageDemo.apk -type f
fi
fi
遇到其他安装目录时,核对本轮构建输出和文件摘要后,再把确认的实际文件设置为 chapter10_apk。
10.3 从 Java 文件 API 进入系统调用
创建 File 对象不等于打开文件
new File(parent, "direct.txt") 主要表示路径。示例进入 new FileOutputStream(file) 后,才按标志打开或创建文件。下面摘录的是 Android 当前实现,不能直接用桌面 OpenJDK 的 writeBytes Native 路径替代。
10.1 的全章时序第一段中,Java、JNI、Native 的动作都由当前应用工作线程继续执行。进入系统调用表示该线程进入内核态;当 I/O 要等待时才可能睡眠、由调度器安排其他线程,不是“JNI 自动创建一个 I/O 线程”。
FileOutputStream 先确定打开语义
执行者:应用工作线程。输入:路径和 append。输出:存入 Java 流对象的 FileDescriptor。
int flags = O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC);
this.fd = IoBridge.open(name, flags);
非 append 分支带 O_TRUNC,会截断已有文件;O_CREAT 允许创建。 因而本示例每次直接写入都覆盖 direct.txt。它不是原子替换旧版本,也没有替业务实现并发写入协议。
IoBridge 再进入系统调用包装,成功后还检查目标不是目录:
源码 open
fd = Libcore.os.open(path, flags, 0666);
// Posix open(2) fails with EISDIR only if you ask for write permission.
// Java disallows reading directories too.f
if (S_ISDIR(Libcore.os.fstat(fd).st_mode)) {
throw new ErrnoException("open", EISDIR);
}
return fd;
FileDescriptor 包装的是本进程的 fd。 发生 ErrnoException 时,IoBridge 的错误分支会关闭已经打开的资源,并把原因转换为 FileNotFoundException;不能只按异常类名推断“一定不存在”,权限拒绝、目录等问题也可能表现为打开失败。
Linux JNI 把 Java 参数转换为 C 参数
Libcore.os 可经 BlockGuardOs 等策略包装委托给 Linux 实现,负责线程磁盘策略等检查;它们不自动把文件内容交给 vold。当前 Native 文件名为 libcore_io_Linux.cpp。
源码 Linux_open
int fd = throwIfMinusOne(env, "open", TEMP_FAILURE_RETRY(open(path.c_str(), flags, mode)));
return createFileDescriptorIfOpen(env, fd);
JNI 从 Java 路径得到 C 字符串,调用 C open 后,为有效 fd 创建 Java FileDescriptor。C 返回 -1 时包装 errno,沿 Java 异常路径回传;不是给 Java 返回一个可以继续读写的负数 fd。
Bionic 对普通 open 的实现继续转到 __openat:
源码 open
return FDTRACK_CREATE(__openat(AT_FDCWD, pathname, force_O_LARGEFILE(flags), mode));
AT_FDCWD 表示相对路径以当前工作目录为基准;绝对路径则按其根解析。 因此 Java 代码调用 open,系统调用跟踪看到 openat 并不矛盾。不同架构的 syscall 入口汇编不同,本章主场景是 x86_64。
write 完成的是向下游交付 不等于全部设备工作结束
FileOutputStream 的数组写入进入 IoBridge:
源码 write
IoBridge.write(fd, b, off, len);
IoBridge 需要处理一次底层 write 只接受了部分字节的情况:
源码 write
while (byteCount > 0) {
int bytesWritten = Libcore.os.write(fd, bytes, byteOffset, byteCount);
byteCount -= bytesWritten;
byteOffset += bytesWritten;
}
byteOffset 和 byteCount 随已写入数量更新,Java 的这次数组写入才形成完整语义。 错误转换为 IOException;不能在重试时从头重复整块,从而重复写入已被接受的前缀。
Native 层分别取得可读或可写的 Java 数组区域,再调用对应的 C 文件接口:
static jint Linux_writeBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount) {
ScopedBytesRO bytes(env, javaBytes);
if (bytes.get() == NULL) {
return -1;
}
return IO_FAILURE_RETRY(env, ssize_t, write, javaFd, bytes.get() + byteOffset, byteCount);
}
static jint Linux_readBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount) {
ScopedBytesRW bytes(env, javaBytes);
if (bytes.get() == NULL) {
return -1;
}
return IO_FAILURE_RETRY(env, ssize_t, read, javaFd, bytes.get() + byteOffset, byteCount);
}
读路径由 FileInputStream → IoBridge.read 汇入这里。普通文件 read 的 0 在 IoBridge 中转换成 Java 流的 EOF -1;零长度请求的处理另有分支。应用的 byte[]、Kernel 页缓存与文件偏移是三种不同对象,不能把 JNI 取得数组地址叫作“磁盘地址”。
示例使用的 Os.fsync 也有明确 Native 入口:
源码 Linux_fsync
static void Linux_fsync(JNIEnv* env, jobject, jobject javaFd) {
int fd = jniGetFDFromFileDescriptor(env, javaFd);
throwIfMinusOne(env, "fsync", TEMP_FAILURE_RETRY(fsync(fd)));
}
下一站进入文件系统同步实现。是否真的有待写数据、是否需要缓存刷新以及错误何时报告,继续看 10.4。
10.4 从 VFS、页缓存追到 VirtIO block
打开时分配 fd 再把它连接到打开文件状态
执行者仍是发起 openat 的应用线程,但处于 Kernel。VFS 解析路径、选择挂载与文件系统,检查打开条件后得到 struct file。这个结构保存打开状态与操作表等信息;它与磁盘 inode、目录名和 Java FileDescriptor 各有职责。
fd = get_unused_fd_flags(how->flags);
if (fd >= 0) {
struct file *f = do_filp_open(dfd, tmp, &op);
if (IS_ERR(f)) {
put_unused_fd(fd);
fd = PTR_ERR(f);
} else {
fd_install(fd, f);
}
}
get_unused_fd_flags 预留当前进程的描述符槽位;fd_install(fd, f) 把打开文件装进去。 失败分支归还预留槽位。成功返回 Java 的整数描述值,只在这个进程的文件表中解释。
VFS 根据真实文件系统选择 read 实现
源码 vfs_read
if (file->f_op->read)
ret = file->f_op->read(file, buf, count, pos);
else if (file->f_op->read_iter)
ret = new_sync_read(file, buf, count, pos);
else
ret = -EINVAL;
对本文 ext4 普通文件阅读分支,操作表中的 read_iter 连接到 ext4:
if (iocb->ki_flags & IOCB_DIRECT)
return ext4_dio_read_iter(iocb, to);
return generic_file_read_iter(iocb, to);
普通 buffered read 走 generic_file_read_iter;Direct I/O 是另一个条件分支。 本示例没有使用 O_DIRECT,不能拿普通 FileInputStream 的行为证明 Direct I/O 的对齐、缓存或并发语义。
先沿读路径看“缓存是否满足”,再看写路径如何先标脏、后回写。图是控制与完成关系的概括,实际 bio 可分裂、合并、重映射;它不是一个 read 对应一个设备请求的保证。
观察缓存读取的分步示意:已有缓存必须数据就绪才直接复制;缺数据时,工作线程可以等待补页;本示意选择成功补齐数据的分支,条件满足后线程仍须等调度才能继续。错误或中断另走返回路径。 缓存命中与缺失是备选,示意中选择一次缺失过程不表示每个 read 都发设备请求。
页缓存命中时 可以直接把数据复制给用户
filemap_get_pages 查找文件映射中的缓存页;没有取得缓存批次时,进入预读与补页逻辑:
filemap_get_read_batch(mapping, index, last_index - 1, fbatch);
if (!folio_batch_count(fbatch)) {
DEFINE_READAHEAD(ractl, filp, &filp->f_ra, mapping, index);
if (iocb->ki_flags & IOCB_NOIO)
return -EAGAIN;
if (iocb->ki_flags & IOCB_NOWAIT)
flags = memalloc_noio_save();
if (iocb->ki_flags & IOCB_DONTCACHE)
这里先认两个动作:filemap_get_read_batch 查缓存批次,!folio_batch_count(fbatch) 进入没有取到批次的分支。短摘录未展示完整补页实现。后续还检查 folio 是否 Uptodate、是否在预读、是否需要等待更新;“查到 folio”不等于数据已可用。 folio 是 Kernel 页管理的聚合抽象,不应把它与应用一次 read 的 byte[] 大小绑定。
数据准备好后,filemap_read 才复制到用户提供的缓冲区并推进偏移:
源码 filemap_read
copied = copy_folio_to_iter(folio, offset, bytes, iter);
already_read += copied;
iocb->ki_pos += copied;
因此刚刚写完又读取的小文本,很可能直接由页缓存满足。快不是“没有 Kernel”,也不能从快推断“没发生任何元数据或后台 I/O”。
buffered write 与 fsync 的完成边界不同
ext4 的缓冲写入主分支先通过写检查,再执行页缓存写入:
inode_lock(inode);
ret = ext4_write_checks(iocb, from);
if (ret <= 0)
goto out;
ret = generic_perform_write(iocb, from);
这个片段省略锁释放与返回后的同步判断;普通写会更新页缓存与脏状态,后续回写与文件系统日志参与持久化。它不保证每次 write 返回前已经完成底层设备写入。
ext4_sync_file 的有日志文件系统路径先等待数据,再等待相关日志事务:
ret = file_write_and_wait_range(file, start, end);
if (ret)
goto out;
/*
* The caller's filemap_fdatawrite()/wait will sync the data.
* Metadata is in the journal, we wait for proper transaction to
* commit here.
*/
ret = ext4_fsync_journal(inode, datasync, &needs_barrier);
其后按 needs_barrier 判断是否发设备 flush,并检查延迟回写错误。检查 fsync 的返回结果,才能知道这次同步请求是否成功;close 的成功不能替代它。 对虚拟机来说,guest 的完成还依赖 Emulator 与 Host 存储栈遵守相应契约,本章没有做 Host 掉电测试。
| 操作完成 | 能说明什么 | 仍不能直接说明什么 |
|---|---|---|
| 应用 buffer flush | 用户空间缓冲被送到下游流 | 设备持久化完成 |
| 普通 write 成功返回 | 该调用报告的字节被内核路径接受 | 后续回写不会报错、掉电仍保留全部内容 |
| 文件 fsync 成功 | 文件系统针对该文件完成所要求的同步并报告成功 | 新建/重命名的父目录项已经另行同步、跨多个文件的业务原子性 |
| close 完成 | 本次描述符所有权结束 | 隐式完成 fsync、自动提交数据库事务 |
从文件系统的 bio 找到实际队列
缓存不足时,ext4 的 read_folio/readahead 进入 ext4_mpage_readpages,在映射文件块后提交 bio。bio 表示块 I/O,携带目标块设备、方向、扇区与内存片段等信息;多个 Java 读取可能因预读、合并或缓存而对应完全不同数量的 bio。
固定来源:ext4 readpage.c · ext4_mpage_readpages、blk-mq.c。块层的 __submit_bio 区分普通 multi-queue 设备与实现了自身 submit_bio 的设备:
源码 __submit_bio
if (!bdev_test_flag(bio->bi_bdev, BD_HAS_SUBMIT_BIO)) {
blk_mq_submit_bio(bio);
} else if (likely(bio_queue_enter(bio) == 0)) {
struct gendisk *disk = bio->bi_bdev->bd_disk;
device-mapper 等堆叠设备可先处理或重映射 bio,再把工作交给下层设备。 所以历史 /data 在 dm 设备上时,不能从 ext4 画一根没有说明的箭头直接跳到 virtio_blk;先用 10.10 的 mountinfo 与 sysfs 设备关系确认中间映射,再看实际 target。加密 target 的条件见 10.8。
底层 request 由 blk-mq 的调度、合并、资源与驱动队列处理;在 VirtIO block 的 virtio_mq_ops 中,queue_rq 对应 virtio_queue_rq。它准备请求并尝试投进 virtqueue:
err = virtblk_add_req(vblk->vqs[qid].vq, vbr);
if (err) {
virtqueue_kick(vblk->vqs[qid].vq);
/* Don't stop the queue if -ENOMEM: we may have failed to
* bounce the buffer due to global resource outage.
*/
if (err == -ENOSPC)
blk_mq_stop_hw_queue(hctx);
spin_unlock_irqrestore(&vblk->vqs[qid].lock, flags);
提交 scatter-gather 列表的关键交接在下一个函数:
return virtqueue_add_sgs(vq, sgs, num_out, num_in, vbr, GFP_ATOMIC);
virtqueue 描述的是与虚拟设备交接的内存队列,不是把 guest fd 直接交给 Host Java。 之后按通知条件唤醒后端处理。本章只定位 guest 驱动接口与历史 Emulator 身份,没有取得当前 Host 存储后端构建源码的完整对应关系,也不套用物理 UFS 控制器的 DMA/IRQ 实现。
请求完成怎样回到等待者
当 VirtIO 后端完成相应描述符,guest 回调从 used buffer 取回请求并交给块层完成逻辑:
源码 virtblk_done
while ((vbr = virtqueue_get_buf(vblk->vqs[qid].vq, &len)) != NULL) {
struct request *req = blk_mq_rq_from_pdu(vbr);
if (likely(!blk_should_fake_timeout(req->q)))
blk_mq_complete_request(req);
req_done = true;
}
块层完成继续关联 bio、文件系统与 folio 状态,需要数据的读线程在条件满足后继续。唤醒只代表可以争取 CPU,不代表已经立刻运行;一次 read 的总时长也不等于驱动耗时。 这条返回路径需要与 read 返回的字节数、错误及应用 Trace 一起观察。
10.5 Provider 怎样把可读文件交给客户端
先把 URI 变成组件引用
客户端拿到 content://... 后,ContentResolver 通过 ContextImpl 的 ApplicationContentResolver 委托 ActivityThread 获取 Provider。先查本地已安装的 Provider 引用;没有合适缓存时,才向 ActivityManager 系统接口请求:
holder = ActivityManager.getService().getContentProvider(
getApplicationThread(), c.getOpPackageName(), auth, userId, stable);
输入包括 authority、userId 与 stable 属性。system_server 的 ContentProviderHelper 负责权限、现有记录、按需启动及等待发布;Provider 进程由 ActivityThread 安装并发布自己的 Transport,客户端获得 IContentProvider 引用后缓存并计数。URI 本身不是 Binder handle;authority 查询与后续业务请求也不是同一笔事务。
按需启动复用第四章的 Zygote 与应用进程机制,组件层面的发布可接第六章。本节的关键终点是客户端已有一个有效 IContentProvider;它不要求每次 open 都重新创建 Provider 进程。
只读模式实际先走 typed asset 分支
ContentResolver.openFileDescriptor 的普通实现先取得 AssetFileDescriptor:
AssetFileDescriptor afd = openAssetFileDescriptor(uri, mode, cancellationSignal);
if (afd == null) {
return null;
}
if (afd.getDeclaredLength() < 0) {
// This is a full file!
return afd.getParcelFileDescriptor();
}
只有声明为整文件的结果才能直接拿出 PFD。 如果 AFD 表示某个文件的子区间,openFileDescriptor 会关闭不适用结果并报错;此时应用应考虑 AFD 自己提供的区间读取语义,而不是忽略 offset 和 length。
本章使用 content scheme、"r" 模式。openAssetFileDescriptor 在这个条件下转向 typed 接口:
if ("r".equals(mode)) {
return openTypedAssetFileDescriptor(uri, "*/*", null, cancellationSignal);
} else {
所以不能把实际调用写成 ContentResolver → IContentProvider.openFile 一步结束。openTypedAssetFileDescriptor 先取得 unstable 引用,然后调用远端:
源码 openTypedAssetFileDescriptor
fd = unstableProvider.openTypedAssetFile(
mContext.getAttributionSource(), uri, mimeType, opts,
remoteCancellationSignal);
if (fd == null) {
// The provider will be released by the finally{} clause
return null;
}
ContentProviderProxy 编码后发出 OPEN_TYPED_ASSET_FILE_TRANSACTION,并读取包含文件信息的回复:
mRemote.transact(IContentProvider.OPEN_TYPED_ASSET_FILE_TRANSACTION, data, reply, 0);
DatabaseUtils.readExceptionWithFileNotFoundExceptionFromParcel(reply);
int has = reply.readInt();
AssetFileDescriptor fd = has != 0
? AssetFileDescriptor.CREATOR.createFromParcel(reply) : null;
return fd;
Binder 的参数、线程与错误回传机制复用第二章。这里是应用工作线程等待;服务端 Binder 接收线程进入 Provider Transport。不同模式、file scheme、mWrapped 本地包装与自定义 typed 实现会选择不同分支,本文不把它们串成一条固定链。
Transport 先检查 再委托真正的 Provider
Transport.openTypedAssetFile 接收的是 MIME 类型、opts 与取消信号,在处理 URI/userId 后,以固定的 "r" 执行读权限检查,并使用 openTypedAssetFile 的 Trace 名称:
Bundle.setDefusable(opts, true);
uri = validateIncomingUri(uri);
uri = maybeGetUriWithoutUserId(uri);
enforceFilePermission(attributionSource, uri, "r");
traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "openTypedAssetFile: ", uri.getAuthority());
final AttributionSource original = setCallingAttributionSource(
attributionSource);
try {
return mInterface.openTypedAssetFile(
uri, mimeType, opts, CancellationSignal.fromTransport(cancellationSignal));
下一站是 mInterface.openTypedAssetFile(...):Transport 把请求交给 Provider 对象的 typed 方法。 示例没有重写 typed 或 asset 入口,因此 Provider 自己的默认实现继续委托到手写 openFile:
if ("*/*".equals(mimeTypeFilter)) {
// If they can take anything, the untyped open call is good enough.
return openAssetFile(uri, "r");
ParcelFileDescriptor fd = openFile(uri, mode);
return fd != null ? new AssetFileDescriptor(fd, 0, -1) : null;
这里的 ContentProvider.openTypedAssetFile → openAssetFile → openFile 是 Provider 对象内部的普通方法调用,不会倒回 Transport.openAssetFile 再执行一轮 mode 校验或同名 Trace。 这条默认委托链解释了为什么只重写 openFile 的示例仍能响应只读请求。它不表示系统要求任意 Provider 都返回同一种普通文件;转换、脱敏、子区间、pipe 或代理 fd 都可改变数据路径。
示例 openFile 只接受固定 authority、固定 path 和 "r";准备文件后调用 ParcelFileDescriptor.open。Framework 把 PFD 模式转换为 POSIX 标志,再经 Os.open 得到服务端 fd:
源码 openInternal
final int flags = FileUtils.translateModePfdToPosix(mode) | ifAtLeastQ(O_CLOEXEC);
int realMode = S_IRWXU | S_IRWXG;
if ((mode & MODE_WORLD_READABLE) != 0) realMode |= S_IROTH;
if ((mode & MODE_WORLD_WRITEABLE) != 0) realMode |= S_IWOTH;
final String path = file.getPath();
try {
return Os.open(path, flags, realMode);
} catch (ErrnoException e) {
throw new FileNotFoundException(e.getMessage());
此时 fd 存在 Provider 进程,还不能把它的整数直接拿到客户端使用。
先看 fd 交接的分步示意:留意两个进程的 fd 槽位各自存在,Kernel 打开文件状态由引用连接;交付完成后,客户端普通文件 read 从文件系统取得字节,最后关闭各自持有的资源。 这是机制示意,播放时长不代表实际耗时,也不要求两个进程得到相同 fd 数字。
Binder 传 fd 传的是打开资源的引用
Provider 方法返回 AFD 后,ContentProviderNative.onTransact 在 OPEN_TYPED_ASSET_FILE_TRANSACTION 分支写成功状态和对象存在标记,再用 PARCELABLE_WRITE_RETURN_VALUE 序列化 AFD。AssetFileDescriptor.writeToParcel 把同一 flags 交给内部 PFD,继续写 offset 和 length。返回标记决定后面原 PFD 的关闭责任。服务端写回复 · AFD 转发 flags
接着 Java Parcel 通过 JNI 写 fd。
源码 android_os_Parcel_writeFileDescriptor
const status_t err =
parcel->writeDupFileDescriptor(jniGetFDFromFileDescriptor(env, object));
if (err != NO_ERROR) {
signalExceptionForError(env, clazz, err);
}
Native Parcel 的对应实现先复制 fd,再声明由 Parcel 持有:
源码 Parcel::writeDupFileDescriptor
int dupFd;
if (status_t err = binder::os::dupFileDescriptor(fd, &dupFd); err != OK) {
return err;
}
status_t err = writeFileDescriptor(dupFd, true /*takeOwnership*/);
if (err != OK) {
close(dupFd);
}
return err;
writeDupFileDescriptor 为 Parcel 保持自己的描述符副本与清理责任。 返回值序列化带 PARCELABLE_WRITE_RETURN_VALUE,PFD 把内容交给 Parcel 后关闭相应原始所有权:
if ((flags & PARCELABLE_WRITE_RETURN_VALUE) != 0 && !mClosed) {
// Not a real close, so emit no status
closeWithStatus(Status.SILENCE, null);
}
这个关闭发生在“已有可传递副本”之后,不能把示例写成“先把返回的 PFD close,再把已关闭对象交给 Binder”。Native Parcel 的具体 fd 对象标记与第二章的对象元数据处理相接。
Driver 在 binder_translate_fd 先从发送进程 fd 表取得 struct file 引用,并检查转移权限:
file = fget(fd);
if (!file) {
binder_user_error("%d:%d got transaction with invalid fd, %d\n",
proc->pid, thread->pid, fd);
ret = -EBADF;
goto err_fget;
}
ret = security_binder_transfer_file(proc->cred, target_proc->cred, file);
if (ret < 0) {
ret = -EPERM;
goto err_security;
它把需要交付的 file 和偏移记入事务 fixup。交付前,binder_apply_fd_fixups 在接收方上下文分配可用槽位、把接收方的描述值写进事务数据,成功后安装文件:
list_for_each_entry_safe(fixup, tmp, &t->fd_fixups, fixup_entry) {
fd_install(fixup->target_fd, fixup->file);
list_del(&fixup->fixup_entry);
kfree(fixup);
}
两边 fd 的数字不要求相等,但对应同一个打开文件状态的引用。 这也意味着共享文件偏移是需要考虑的语义;要独立偏移应设计独立 open 或使用明确偏移的 I/O,而不是把 dup 当成重新打开独立文件。
动图先看发送 Parcel 怎样保住同一个打开文件状态,再看 Driver 给接收方安装新的 fd。文件字节到下一步客户端 read 时才进入读缓冲区。
接收的 fd 怎样变成客户端 Java 对象
Driver 安装好的 fd 先属于接收事务携带的资源。ContentProviderProxy 读取回复中的 AFD,其构造方法继续创建 PFD:
mFd = ParcelFileDescriptor.CREATOR.createFromParcel(src);
mStartOffset = src.readLong();
mLength = src.readLong();
PFD 的 CREATOR 从 Parcel 取得 Java FileDescriptor,再创建包装对象:
int hasCommChannel = in.readInt();
final FileDescriptor fd = in.readRawFileDescriptor();
FileDescriptor commChannel = null;
if (hasCommChannel != 0) {
commChannel = in.readRawFileDescriptor();
}
return new ParcelFileDescriptor(fd, commChannel);
readRawFileDescriptor 对应的 Native 方法并不是直接把 Parcel 中的整数交给 Java;它先复制描述符:
源码 android_os_Parcel_readFileDescriptor
int fd = parcel->readFileDescriptor();
if (fd < 0) return NULL;
fd = fcntl(fd, F_DUPFD_CLOEXEC, 0);
if (fd < 0) return NULL;
jobject jifd = jniCreateFileDescriptor(env, fd);
if (jifd == NULL) {
close(fd);
}
return jifd;
F_DUPFD_CLOEXEC 让 Java 一侧拥有独立的 fd 关闭责任,仍指向同一个打开文件状态。 jniCreateFileDescriptor 创建客户端 Java FileDescriptor,PFD 构造方法保存它并设置所有者。临时 reply Parcel 回收不应提前关闭 Java 持有的这个副本。
因此,Driver 安装的接收 fd 与日志中 pfd.getFd() 也不要求是同一个数字。之后 AFD 带着 offset/length 返回 Resolver,才形成下面的引用包装;不能跳过这次 dup,把整个过程理解成“一个 fd 整数从内核直接变成了 Java PFD 对象”。
返回的 PFD 还带着 Provider 引用责任
成功拿到 AFD 后,Resolver 取得 stable Provider 引用,归还 unstable 引用,并建立内部 PFD 包装:
源码 openTypedAssetFileDescriptor
if (stableProvider == null) {
stableProvider = acquireProvider(uri);
}
releaseUnstableProvider(unstableProvider);
unstableProvider = null;
ParcelFileDescriptor pfd = new ParcelFileDescriptorInner(
fd.getParcelFileDescriptor(), stableProvider);
// Success! Don't release the provider when exiting, let
// ParcelFileDescriptorInner do that when it is closed.
stableProvider = null;
清空局部变量 stableProvider,是为了让 finally 不提前归还已经转交包装对象的引用。这里的 stable 是 Provider 进程依赖关系的计数属性,不表示 fd 的数字“稳定”,也不表示磁盘数据已经持久化。
这个内部包装在释放资源时调用 releaseProvider:
if (mProviderReleased.compareAndSet(false, true)) {
ContentResolver.this.releaseProvider(mContentProvider);
}
AutoCloseInputStream 的 close 最终覆盖这层责任:
public void close() throws IOException {
try {
super.close();
} finally {
mPfd.close();
}
}
至此控制请求、fd 交付、客户端 read 与关闭各有位置。取得引用失败、服务死亡和 null 返回的处理,集中放在 10.9。
10.6 query 怎样经过 SQLite 返回 Cursor
query 的结果怎样进入客户端 Cursor
读完 payload.txt 后,同一个工作线程查询 metadata URI。上一段的文件已关闭。这次客户端要读 label 和 bytes 两个字段,Provider 的 SQLiteCursor 在服务端组织行,客户端经适配器读取自己的窗口。
示例的 /metadata 端点由 DemoProvider.query 执行 SQLiteDatabase.query,返回 SQLiteCursor。数据库连接、SQL statement 与查询游标由 Provider 进程持有;客户端 ContentResolver 不因此获得可直接改写数据库的 fd。
先抓住适配器的职责:客户端把跨进程按批取行的协议接成应用熟悉的 Cursor 接口;服务端则把本地 Cursor 接到这个协议。再看两端具体由哪些类接手。
远端 query 使用 ContentProviderProxy、ContentProviderNative 与 BulkCursor 适配器连接两边。服务端先得到业务 Cursor,再包装为 CursorToBulkCursorAdaptor;客户端收到 BulkCursorDescriptor 后初始化 BulkCursorToCursorAdaptor。CursorWindow 用于承载一批行,窗口不够时可通过远端 Cursor 接口继续取得。
getCount 本身就可能促使查询执行
服务端生成 BulkCursorDescriptor 时,会读取行数与当前窗口:
d.count = mCursor.getCount();
d.window = mCursor.getWindow();
if (d.window != null) {
// Acquire a reference to the window because its reference count will be
// decremented when it is returned as part of the binder call reply parcel.
d.window.acquireReference();
SQLiteCursor 的行数尚未得到时会填充窗口:
源码 getCount
if (mCount == NO_COUNT) {
fillWindow(0);
}
return mCount;
不要把 SQL 执行时间一律算在客户端 moveToFirst 之后。 query 的 Binder 回复构造阶段就可能因为 getCount 开始填窗;客户端开始遍历时,初始窗口可能已经可用。反过来,大结果集也未必在首次 query 时全部复制到客户端。
SQLiteQuery 把窗口与参数交给 Session
源码 fillWindow
int numRows = getSession().executeForCursorWindow(getSql(), getBindArgs(),
window, startPos, requiredPos, countAllRows, getConnectionFlags(),
mCancellationSignal);
return numRows;
SQLiteSession 根据连接与事务状态获取连接,继续委托:
return mConnection.executeForCursorWindow(sql, bindArgs,
window, startPos, requiredPos, countAllRows,
SQLiteConnection 绑定参数、附加取消信号后,调用 JNI:
final long result = nativeExecuteForCursorWindow(
mConnectionPtr, statement.mStatementPtr, window.mWindowPtr,
startPos, requiredPos, countAllRows);
actualPos = (int)(result >> 32);
countedRows = (int)result;
filledRows = window.getNumRows();
window.setStartPosition(actualPos);
这里的 mConnectionPtr、statement 指针和 window 指针属于 Provider 进程。 SQLiteConnection 打开连接时通过 Native sqlite3_open_v2 建立数据库连接;prepare 阶段产生 statement,CursorWindow 创建时形成 Native 窗口。后面读取的是这些已存在对象,不是每次读取指针字段都新建一次数据库。
sqlite3_step 推进语句并返回当前行。JNI 的 copyRow 再读取这些字段,将行写入 CursorWindow。
源码 nativeExecuteForCursorWindow
while (!gotException && (!windowFull || countAllRows)) {
int err = sqlite3_step(statement);
if (err == SQLITE_ROW) {
LOG_WINDOW("Stepped statement %p to row %d", statement, totalRows);
retryCount = 0;
totalRows += 1;
SQLite 的页缓存和事务机制在用户空间。这里的 SQLite VFS 是它自己的文件操作适配接口;需要实际文件 I/O 时,再经 Native 文件接口进入 Kernel 的文件系统路径,与前文 Kernel VFS 分清归属。当前源码默认目录指向 sqlite-autoconf-3500600,Unix VFS 的 seekAndRead 按编译条件选择 pread 或 pread64 等方式:
源码 seekAndRead
got = osPread(id->h, pBuf, cnt, offset);
SimulateIOError( got = -1 );
#elif defined(USE_PREAD64)
got = osPread64(id->h, pBuf, cnt, offset);
SimulateIOError( got = -1 );
上面是文件读取分支的摘录;若启用了 mmap 且所需范围已映射,也可能先由映射满足。它用于解释下游接口,未据此认定设备上安装的 SQLite 一定由这个目录构建。SQL 一次取行不等于必有一次设备读;SQLite 缓存命中、Kernel 页缓存命中和块设备完成是三个不同观察层次。 SQLite 发行目录存在多个版本时,应根据产品选择核对运行库,不能仅选一个源码目录就称它是当前设备实现。
填好的窗口怎样进入 Binder 回复
到这里,SQL 行还在 Provider 进程的 CursorWindow 中。要让客户端读到这些行,接下来要同时传递两样东西:用于后续控制的 IBulkCursor 引用,以及当前窗口的行数据。它们由 BulkCursorDescriptor 一起组织,但采用不同的编码方式。
ContentProviderNative 的 QUERY_TRANSACTION 分支取得描述符后,把它写进本次 reply:
源码 onTransact
reply.writeNoException();
reply.writeInt(1);
d.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
BulkCursorDescriptor.writeToParcel 先写远端控制接口,再按是否有初始窗口写入窗口:
out.writeStrongBinder(cursor.asBinder());
out.writeStringArray(columnNames);
out.writeInt(wantsAllOnMoveCalls ? 1 : 0);
out.writeInt(count);
if (window != null) {
out.writeInt(1);
window.writeToParcel(out, flags);
} else {
out.writeInt(0);
cursor.asBinder() 是以后补窗、关闭等操作的控制入口;window.writeToParcel 才负责交付当前批次的行数据。 数据库文件 fd、远端 Cursor 的 Binder 和窗口数据不能混为同一个“返回对象”。描述符还带有列名、行数和 wantsAllOnMoveCalls,供客户端初始化适配器。
Java CursorWindow 写下起始行号,再把本进程 Native 窗口与当前 Parcel 交给 JNI:
acquireReference();
try {
dest.writeInt(mStartPos);
nativeWriteToParcel(mWindowPtr, dest);
} finally {
JNI 在 Provider 进程内还原两个本地对象,继续调用 Native 序列化:
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
Parcel* parcel = parcelForJavaObject(env, parcelObj);
status_t status = window->writeToParcel(parcel);
这里读取 mWindowPtr 是为了找到服务端本地窗口并编码其内容,没有把这个地址作为窗口本体写入 Binder。下一步要看的就是 CursorWindow::writeToParcel 选择了哪一种数据载体。
接着观察窗口数据的分步示意:控制 Binder 始终与窗口载体分开;有行时分别看内联复制与 ashmem fd 两个备选分支,再看客户端本地 getter 与归还。 两个分支不是同一次请求先后都执行,空窗另按零大小协议处理;本例的运行分支需用采集结果确认。
小窗口内联复制 扩容窗口按条件传 fd
本版本 kInlineSize 为 16384,即 16 KiB。CursorWindow::create 初次分配的是不超过该值的轻量内存,而不是一创建就必定建立 ashmem:
window->mSize = std::min(kInlineSize, inflatedSize);
window->mInflatedSize = inflatedSize;
window->mData = calloc(window->mSize, 1);
if (!window->mData) goto fail;
window->mReadOnly = false;
这里的 16 KiB 约束窗口最初的轻量内存阶段,不是数据库或整次查询结果量的上限;行数据与字段 slot 都占空间,装不下时再看扩容和补窗条件。
容量不足且允许扩容时,maybeInflate 调用 ashmem_create_region,建立可映射共享区并迁移已有数据。mAshmemFd 和 isAshmem 是字段与协议名称。固定 libcutils 实现会按 use_memfd() 选择 memfd 或 ashmem,单凭这两个名称无法认定实际使用 /dev/ashmem。发送时再按当前窗口状态判断。libcutils 的共享区选择
源码 CursorWindow::writeToParcel
if (mNumRows == 0) {
if (parcel->writeUint32(/*size=*/0)) goto fail;
if (parcel->writeBool(/*isAshmem=*/false)) goto fail;
} else if (mAshmemFd != -1) {
if (parcel->writeUint32(mSize)) goto fail;
if (parcel->writeBool(/*isAshmem=*/true)) goto fail;
if (parcel->writeDupFileDescriptor(mAshmemFd)) goto fail;
这个片段展示了空窗和有行的 ashmem 分支;后面还有未扩容窗口的分支。空窗编码为零大小;有行且 mAshmemFd != -1 时写入区域大小、类型标记和复制的 fd;有行但没有 ashmem fd 时,把实际使用的内容压紧写进 Parcel。
内联分支复制数据区和 slot 区,slot 保存字段类型,以及定长值或可变长数据的位置等信息:
源码 CursorWindow::writeToParcel
size_t slotsSize = sizeOfSlots();
size_t compactedSize = sizeInUse();
if (parcel->writeUint32(compactedSize)) goto fail;
if (parcel->writeBool(/*isAshmem=*/false)) goto fail;
void* dest = parcel->writeInplace(compactedSize);
if (!dest) goto fail;
memcpy(static_cast<uint8_t*>(dest),
static_cast<uint8_t*>(mData), mAllocOffset);
memcpy(static_cast<uint8_t*>(dest) + compactedSize - slotsSize,
static_cast<uint8_t*>(mData) + mSlotsOffset, slotsSize);
所以这里既不能一概说“CursorWindow 总是共享内存”,也不能说“整个窗口都通过 Binder 逐字节复制”。是复制行数据,还是传递可映射区域的 fd,由当前窗口状态决定。 本例只有一行短文本与整数,所需内容很小,依据源码可推测通常能由内联窗口承载;本章没有运行采样,不把这个推测记成已观测到的分支。
这张图把控制 Binder 与窗口数据分开。内联分支在客户端获得本地数据副本;ashmem 分支在客户端建立只读映射。两边都有各自的 Java 和 Native 窗口对象,不共享同一个对象地址。
客户端重新创建本进程的窗口
ContentProviderProxy.query 读到 reply 中“有描述符”的标记后,先重建 BulkCursorDescriptor,再初始化先前创建的适配器:
源码 query
if (reply.readInt() != 0) {
BulkCursorDescriptor d = BulkCursorDescriptor.CREATOR.createFromParcel(reply);
Binder.copyAllowBlocking(mRemote, (d.cursor != null) ? d.cursor.asBinder() : null);
adaptor.initialize(d);
} else {
描述符的接收方法分别读取控制 Binder 和窗口:
cursor = BulkCursorNative.asInterface(in.readStrongBinder());
columnNames = in.readStringArray();
wantsAllOnMoveCalls = in.readInt() != 0;
count = in.readInt();
if (in.readInt() != 0) {
window = CursorWindow.CREATOR.createFromParcel(in);
}
BulkCursorNative.asInterface 得到控制接口代理;CursorWindow.CREATOR 则调用私有构造方法。后者读取起始行号,并在客户端调用 Native 工厂:
源码 CursorWindow
mStartPos = source.readInt();
mWindowPtr = nativeCreateFromParcel(source);
if (mWindowPtr == 0) {
throw new AssertionError(); // Not possible, the native code won't return it.
}
JNI 取得的是客户端接收 Parcel 对应的 Native Parcel,随后请求创建新的 Native 窗口:
Parcel* parcel = parcelForJavaObject(env, parcelObj);
CursorWindow* window;
status_t status = CursorWindow::createFromParcel(parcel, &window);
CursorWindow::createFromParcel 在客户端执行 new CursorWindow(),然后读取名称、行列数和大小等元数据:
源码 CursorWindow::createFromParcel
CursorWindow* window = new CursorWindow();
if (!window) goto fail;
if (parcel->readString8(&window->mName)) goto fail;
if (parcel->readUint32(&window->mNumRows)) goto fail;
if (parcel->readUint32(&window->mNumColumns)) goto fail;
if (parcel->readUint32(&window->mSize)) goto fail;
接着校验尺寸与类型标记,再进入对应分支。
在 ashmem 分支,先从 Parcel 取得已转移到本进程的 fd,再复制为窗口自己负责关闭的 fd,建立 PROT_READ 映射:
源码 CursorWindow::createFromParcel
tempFd = ::fcntl(tempFd, F_DUPFD_CLOEXEC, 0);
if (tempFd < 0) {
PLOG(ERROR) << "Failed F_DUPFD_CLOEXEC";
goto fail_silent;
}
window->mMappedFile = MappedFile::Create(tempFd, 0, window->mSize, PROT_READ);
映射失败会关闭刚复制的 fd 并沿失败路径清理窗口。成功后,窗口的 mData 指向该映射的本地虚拟地址,mAshmemFd 保存自己的 fd;它与 Provider 进程的映射地址不要求相等。
在内联分支,先限制接收大小不能超过 kInlineSize,再分配客户端本地内存并从 Parcel 复制:
源码 CursorWindow::createFromParcel
window->mData = malloc(window->mSize);
if (!window->mData) goto fail;
if (window->mSize > 0) {
if (parcel->read(window->mData, window->mSize)) goto fail;
}
无论哪个分支,成功接收的窗口都被标记为只读且不能继续扩容。JNI 最后只把新建的客户端 Native 窗口地址返回给本进程 Java,保存在前面构造方法的 mWindowPtr:
return reinterpret_cast<jlong>(window);
指针值是客户端创建后的本地结果,跨进程传来的是协议元数据和数据字节或 fd。 临时 reply Parcel 结束后,客户端窗口依靠自己的数据副本或独立 fd/映射继续提供读取。
getter 读取当前窗口 越界移动才按需补窗
适配器初始化时分别保存远端控制接口、列名、行数和初始窗口:
源码 initialize
mBulkCursor = d.cursor;
mColumns = d.columnNames;
mWantsAllOnMoveCalls = d.wantsAllOnMoveCalls;
mCount = d.count;
if (d.window != null) {
setWindow(d.window);
}
随后 ContentResolver 可再包装 CursorWrapperInner,保留 Provider 引用。应用拿到的 Cursor 沿这些包装层,最终由 AbstractWindowedCursor 的 getter 读取当前窗口,例如:
源码 getString
checkPosition();
return mWindow.getString(mPos, columnIndex);
CursorWindow.getString 通过本进程 JNI 读取当前行列的 slot 并构造 Java 字符串;getLong 也在本地窗口中读取。这条 getter 数据路径不会为了每一列再发一次 Provider query。 行号需减去窗口起始位置,列名到列号的映射来自描述符中的列名。
当移动到新位置时,BulkCursorToCursorAdaptor.onMove 检查该行是否仍在当前窗口内;没有窗口或越界时才请求远端 getWindow:
源码 onMove
if (mWindow == null
|| newPosition < mWindow.getStartPosition()
|| newPosition >= mWindow.getStartPosition() + mWindow.getNumRows()) {
setWindow(mBulkCursor.getWindow(newPosition));
} else if (mWantsAllOnMoveCalls) {
mBulkCursor.onMove(newPosition);
}
服务端 CursorToBulkCursorAdaptor.getWindow 让底层 Cursor 移到对应位置,取得或填充窗口,再按相同的窗口序列化协议返回。若窗口仍覆盖该行,getter 可继续用本地数据;不过 mWantsAllOnMoveCalls 为真时,仍会另发远端 onMove 通知,不能把它说成“窗口内移动绝不通信”。
替换窗口时,setWindow 会先关闭旧窗口,再接管新窗口:
源码 setWindow
if (window != mWindow) {
closeWindow();
mWindow = window;
}
窗口数据与控制接口怎样归还
发送端 CursorToBulkCursorAdaptor 为返回窗口额外取得的引用,由 CursorWindow.writeToParcel 的返回值标志处理平衡;它不表示发完回复就必须销毁 Provider 自己仍在使用的窗口。写入 Parcel 的临时 fd 也有 Parcel 自己的所有权,接收端映射使用的是其独立复制的 fd。
客户端替换窗口或关闭 Cursor 后,窗口引用最终归零会经 CursorWindow.onAllReferencesReleased → dispose → nativeDispose,删除本进程的 Native 对象:
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
if (window) {
LOG_WINDOW("Closing window %p", window);
delete window;
Native 析构按数据载体分别归还映射/fd 或分配的内存:
源码 CursorWindow::~CursorWindow
if (mAshmemFd >= 0) {
mMappedFile.reset();
::close(mAshmemFd);
} else {
free(mData);
}
关闭远端控制 Cursor 与归还 Resolver 的 Provider 引用则继续沿下一小节的链路。由此才能把“SQL 行填窗”接到“应用 getter 读到值”,再接到数据窗口和进程依赖各自的结束。
查询怎样正常结束与失败
Resolver 交给客户端的 CursorWrapperInner 在关闭内部 Cursor 后,归还它保留的 Provider 引用:
public void close() {
mCloseGuard.close();
super.close();
if (mProviderReleased.compareAndSet(false, true)) {
ContentResolver.this.releaseProvider(mContentProvider);
}
客户端 Cursor.close 归还远端游标、窗口与 Resolver 的 Provider 引用。服务端关闭某次 Cursor 不表示关闭整个 SQLiteOpenHelper 的连接池:连接池可被同一 Provider 后续请求复用。应用长期持有 Cursor,既可能保留窗口等 Native 内存,也延长组件依赖关系。
SQL 错误、取消、数据库损坏、权限拒绝和远端进程死亡不是同一种“空表”。示例同时检查 null Cursor 与无行,并统一作为缺少元数据行报告;其他异常另行记录。数据库写事务是否提交,应以 SQLite 事务边界、同步配置和实际返回为依据;读到了新行不能替代崩溃恢复或掉电持久性验证。
示例只使用单行元数据与固定查询,未演示大窗口换页、WAL 并发与事务恢复。不能把本次教材的静态核对当作完整数据库验证。
10.7 StorageManager、vold 与 FUSE 怎样改变可见性
同一块数据可以有不同挂载视图
前面沿着已经取得的入口看字节怎样交付;现在把视线移回路径,看看同一批文件为何会有不同的可见范围。挂载把文件系统接入命名空间;bind mount 可让已有目录出现在另一个位置。/storage/emulated/<userId> 和下层 /data/media/<userId> 可以关联同一批文件,但访问策略、观察到的挂载点和进程权限不必相同。
应用在独立挂载视图下运行;多用户、应用数据隔离和运行时权限会影响可见性。看到 Shell 能列出路径,不等于目标应用能从它自己的命名空间访问。 run-as 改变执行身份,也不能自动证明其进程的挂载视图与已经启动的目标应用完全相同;需要记录实际观察进程。
普通应用能查询存储卷与自己的外部目录,但不能任意调用受保护的卷挂载管理接口。本节读系统实现,不给读者执行格式化、卸载真实卷或破坏用户数据的步骤。
StorageManagerService 把卷控制交给 vold
StorageManager 的系统接口进入 system_server,StorageManagerService 查找卷并检查策略。在 mount 的实现里,系统把卷标志、目标用户和回调交给 vold:
源码 mount
mVold.mount(vol.getId(), vol.getMountFlags(), vol.getMountUserId(),
new IVoldMountCallback.Stub() {
@Override
public boolean onVolumeChecking(FileDescriptor fd, String path,
String internalPath) {
vol.setFsPath(path);
vol.setInternalPath(internalPath);
ParcelFileDescriptor pfd = new ParcelFileDescriptor(fd);
try {
回调拿到 FUSE 设备 fd 与路径后,StorageSessionController 请求 ExternalStorageService 建立会话。回调 finally 关闭它自己的 PFD 包装;被转交的另一进程副本有独立责任,这又一次体现了 fd 传递与单一 Java 对象的区别。
vold 收到 IVold.mount,找到具体 VolumeBase 子类,临时保存 callback 并调用 mount:
vol->setMountCallback(callback);
int res = vol->mount();
vol->setMountCallback(nullptr);
if (res != OK) {
return translate(res);
}
VolumeBase 对状态变更与 doMount 的关系很明确:
setState(State::kChecking);
status_t res = doMount();
setState(res == OK ? State::kMounted : State::kUnmountable);
if (res == OK) {
doPostMount();
}
卷先进入 Checking,具体挂载成功后才成为 Mounted;失败转为 Unmountable。 “发出了挂载请求”和“应用已可访问”之间还包含回调、会话建立与状态通知。
EmulatedVolume 建立 FUSE 会话
本章选择 EmulatedVolume 的普通 FUSE 路径,不把可移动 PublicVolume 或早期根文件系统挂载强行塞进它。EmulatedVolume.doMount 先准备目录,再调用 MountUserFuse:
res = MountUserFuse(user_id, getInternalPath(), label, &fd);
if (res != 0) {
PLOG(ERROR) << "Failed to mount emulated fuse volume";
return res;
}
mFuseMounted = true;
auto fuse_unmounter = [&]() {
MountUserFuse 打开 /dev/fuse,构造含会话 fd 的选项,通过 mount 系统调用建立挂载:
result = TEMP_FAILURE_RETRY(mount("/dev/fuse", fuse_path.c_str(), "fuse",
MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME | MS_LAZYTIME,
opts.c_str()));
if (result != 0) {
PLOG(ERROR) << "Failed to mount " << fuse_path;
return -errno;
}
/dev/fuse 的 fd 是用户空间 daemon 与 Kernel FUSE 交换请求的会话,不是应用最终打开的某个照片 fd。 mount 成功还不够;回调把会话交给合适的服务。MediaProvider 的 ExternalStorageServiceImpl 创建 FuseDaemon 并启动:
FuseDaemon daemon = new FuseDaemon(mediaProvider, this, deviceFd, sessionId,
upperFileSystemPath.getPath(), uncachedMode,
supportedTranscodingRelativePaths, supportedUncachedRelativePaths);
daemon.start();
sFuseDaemons.put(sessionId, daemon);
这解释了为什么普通文件 read 不需要每次先发 Binder 到 vold,仍可能在 FUSE 缓存缺失或策略检查时进入 MediaProvider 用户空间。挂载控制的 Binder 通信与 FUSE 请求通道各有用途。
FUSE 数据路径要看文件打开的实际模式
MediaProvider 在打开阶段校验权限并判断脱敏、转码和下层 fd。当前实现还要满足全局 passthrough、该 fd 允许 passthrough、无需脱敏且转换完成。Java 层提供的 fd 在这里没有 passthrough 资格。所选 passthrough 的注册失败会回复错误。之后 read 才根据打开方式选择路径。打开阶段的固定源码
固定 Kernel 的 fuse_file_read_iter 有明确分支:
if (ff->open_flags & FOPEN_DIRECT_IO)
return fuse_direct_read_iter(iocb, to);
else if (fuse_file_passthrough(ff))
return fuse_passthrough_read_iter(iocb, to);
else
return fuse_cache_read_iter(iocb, to);
这是前面的 DAX、错误检查与可选 FUSE_BPF 分支之后的摘录。FOPEN_DIRECT_IO、passthrough 和普通缓存路径互为条件选择;不能把它们串成每次读取都会依次经过的三层。
在普通 daemon 参与的路径,FuseDaemon 的 do_read 为下层文件 fd 与偏移准备回复数据:
源码 do_read
buf.buf[0].fd = h->fd;
buf.buf[0].pos = off;
buf.buf[0].flags =
(enum fuse_buf_flags) (FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK);
后续 fuse_reply_data 的读取、splice 或复制选择由实现处理。涉及位置脱敏、转码与额外权限时,会选其他路径或拒绝;不能断言“所有 MediaStore fd 都已绕过 FUSE”。当前文件的打开标志、Kernel 配置与 MediaProvider 功能选择都要核实。
官方Scoped storage 说明解释了 FUSE 在策略中的位置;FUSE passthrough 说明可帮助理解为什么部分文件数据能走下层路径。具体设备是否启用,以配置、属性、挂载、服务与执行证据为准。本章的自定义 Provider 普通私有文件示例没有验证这条外部存储路径。
10.8 文件加密怎样把解锁状态接入访问路径
DE、CE 与屏幕锁不是同一个维度
文件级加密 FBE 按目录或文件策略使用密钥。Device Encrypted(DE)存储在设备启动后的规定阶段可用;Credential Encrypted(CE)存储需相应用户解锁。普通应用默认 files 目录通常位于 CE;Direct Boot 场景可用 device-protected Context 访问 DE,但组件能否在该阶段运行,还取决于声明与系统策略。
屏幕熄灭或重新出现锁屏,不等同于所有 CE key 立即被移出 Kernel。 用户停止、锁定凭据存储和运行中的文件引用是另外的状态转换。不要把“锁屏后还能读”误判成“FBE 失效”,也不要用普通应用的一个 read 代替密钥生命周期测试。
系统解锁请求怎样安装用户密钥
StorageManagerService 经 IVold.unlockCeStorage 请求 vold。这里的 fscrypt_unlock_ce_storage 解锁内部 /data 的 CE 存储。可采纳卷的准备另有 fscrypt_prepare_user_storage。下面的函数恢复密钥并记录对应用户的内部 policy。
auto auth = authentication_from_secret(secret);
KeyBuffer ce_key;
if (!read_and_fixate_user_ce_key(user_id, auth, &ce_key)) return false;
EncryptionPolicy ce_policy;
if (!install_userdata_key(ce_key, &ce_policy)) return false;
s_ce_policies[user_id].internal = ce_policy;
LOG(DEBUG) << "Installed CE key for user " << user_id;
return true;
输入的 secret 用于保护与恢复流程,不应把应用传给普通 Provider 的 URI 与这个系统密钥输入混为一谈。该函数还检查是否启用 FBE、用户 key 是否已安装;重复解锁不要求每次重新创建同一用户的所有状态。
密钥材料的保护方式由当前 KeyAuthentication 决定。retrieveKey 区分使用 Keystore 的路径与其他支持分支:
源码 retrieveKey
if (auth.usesKeystore()) {
Keystore keystore;
if (!keystore) return false;
km::AuthorizationSet keyParams = beginParams(appId);
if (!decryptWithKeystoreKey(keystore, dir, keyParams, encryptedMessage, key)) {
LOG(ERROR) << "decryptWithKeystoreKey failed";
return false;
}
} else {
if (!decryptWithoutKeystore(appId, encryptedMessage, key)) {
LOG(ERROR) << "decryptWithoutKeystore failed";
return false;
Keystore 路径连接 android.system.keystore2.IKeystoreService/default,通过相应安全级别接口完成操作。实际 KeyMint 服务及可信执行后端需结合设备核验;Emulator 有同名接口,不等于具有真实硬件 TEE。KeyMint 后端内部和认证整条链路继续归第十九章,本章保留调用边界与其对存储访问的影响。
安装密钥使用的是文件系统 ioctl
install_userdata_key 最终进入 KeyUtil.installKey。它构造 fscrypt_add_key_arg,打开挂载点目录,将 key 材料与策略交给 Kernel:
源码 installKey
if (ioctl(fd, FS_IOC_ADD_ENCRYPTION_KEY, arg) != 0) {
PLOG(ERROR) << "Failed to install fscrypt key to " << mountpoint;
return false;
}
FS_IOC_ADD_ENCRYPTION_KEY 改变文件系统的密钥状态;它不是把每一次业务 read 都送进 KeyMint。 Kernel 的 fscrypt_ioctl_add_key 负责校验并管理挂载文件系统的 key 记录。普通打开则根据 inode 的加密策略检查 key:
err = fscrypt_require_key(inode);
if (err)
return err;
ext4_file_open 调用 fscrypt_file_open 后才能继续该分支的文件访问;实际数据加解密可由 Kernel crypto 或设备 inline encryption 等配置承接。缺少 key、策略不兼容和普通文件权限失败分别追踪 errno,不能全部解释成“用户没授权存储权限”。
文件级加密与元数据加密怎样分工
fscrypt 处理相应策略下的文件内容与文件名保护;文件系统其他元数据的保护还可能依赖 metadata encryption。vold 的 MetadataCrypt 与 Kernel dm-default-key 是另一条需要核对 fstab 和设备映射的路径,不能仅看到 dm 设备就宣称它一定是 dm-default-key。
| 需要确认的问题 | 看什么 | 本章边界 |
|---|---|---|
| CE / DE 路径与当前用户 | Context 路径、userId、用户解锁状态 | 有教学检查方法,无本章解锁实测 |
| 文件加密策略与 key 安装 | vold FsCrypt / KeyUtil、Kernel fscrypt、目标 fstab | 固定源码分支已读,不记录或导出真实 key |
| 是否经过 KeyMint 保护 | KeyStorage 分支、keystore2 与设备服务配置 | 已定位接口,具体可信后端待设备对应 |
| 是否使用 metadata encryption | fs_mgr/vold 配置、dm target 与相关 Kernel 实现 | 不从历史 dm 编号推断其类型 |
锁定、移除 key 时,已打开 inode、进行中的 I/O 与 key 引用可能影响何时完全停止访问。不要给出“一个 ioctl 就让所有已有 fd 立即失效”的保证。写教材也不需要执行会影响正在使用数据的锁钥、删钥或格式化命令。
10.9 权限、异常、fd 与 Cursor 怎样结束
文件权限与 Provider 权限分别检查
直接文件访问受 UID/GID、目录遍历、模式位、SELinux、挂载视图、文件系统与 key 状态等约束。Provider 访问先受 exported、读写权限、URI grants、用户和 AppOps 等规则影响,服务端仍要把 URI 正确映射为允许提供的资源。
拿到一个合法 URI 不代表任意路径可读;拿到有权转移的 fd,也不意味着客户端需要再次用路径重新通过相同的打开检查。 因此自定义 Provider 必须约束 URI、访问模式和所提供的资源。本示例只提供固定路径,只读、不导出,既不申请宽泛存储权限,也不演示跨应用授予权限。
匿名 pipe、proxy fd 与普通文件的错误、seek、阻塞与关闭行为不同。示例用的是普通文件;不能把读至 EOF、Provider 退出后的行为或 fsync 语义无条件推广到所有 PFD。
谁负责关闭 要沿着所有权找
| 资源 | 本例创建或取得的位置 | 正常结束 | 异常与宿主退出 |
|---|---|---|---|
| 直接文件流 | Activity 工作线程 | try-with-resources close | 异常也进入 close;进程退出时 Kernel 关闭其 fd,不保证 Java finally 已运行 |
| Provider 原始打开 fd | DemoProvider.openFile | 返回序列化按返回值契约交给 Parcel 后关闭原所有权 | Binder 失败路径负责已取得引用的清理,不能在传输前手动提前关闭返回对象 |
| 接收方 PFD / 流 | Resolver 包装后由 Activity 持有 | AutoCloseInputStream.close → PFD.close → 内部引用归还 | 不以 GC 作为主要关闭机制;读取中途失败仍按相同所有权关闭 |
| 查询 Cursor / 窗口 | Provider 创建,客户端持有适配器 | 客户端 Cursor.close 带动远端与窗口释放 | 服务端/客户端死亡还有 Binder 与框架清理,不能保证业务 onClose 日志总能出现 |
| Provider 数据库 helper / pool | Provider 实例持有 | 多次查询可复用;测试的 shutdown 与宿主生命周期另行处理 | 普通应用不存在可靠的“所有进程退出前都会执行 onDestroy”承诺 |
关闭 PFD 会归还一个 stable Provider 引用,但 Provider 是否马上退出取决于其他引用、组件与系统进程策略。fd 引用计数、Provider 引用计数、SQLite 连接池和卷挂载状态各自独立,不能画成一个统一计数器。
Kernel 中已安装的普通文件 fd 不需要原打开进程一直活着才能表示打开文件;但 Android 的 stable Provider 依赖可能导致客户端在 Provider 死亡时受到框架处置。因此不把“文件引用在 Kernel 里仍有效”扩写成“客户端必定能无感继续运行”。
失败要按阶段定位
| 现象 | 先检查哪一站 | 不宜直接作的结论 |
|---|---|---|
| 找不到 Provider / 取得引用超时 | authority、Manifest、目标用户、发布与进程日志 | 不一定是文件不存在 |
| FileNotFoundException | 是否整文件、URI/模式、Provider 的错误映射、底层 errno | 不一定只表示 ENOENT |
| SecurityException / AppOp 拒绝 | exported、权限、URI grant、AttributionSource 与 AppOps | 不是加 chmod 就一定可解决 |
| null PFD / null Cursor | API 契约、Provider 进程崩溃/返回、调用上下文 | 不能继续把 null 当空文件 |
| read 中途失败 | fd 类型、设备状态、取消、底层 I/O;保留已读字节数 | 不证明 Provider 从未执行过 open |
| write 或 fsync 失败 | 已接受字节、剩余空间、只读状态、延迟回写错误 | 异常不保证此前没有副作用 |
| SQLite 错误 / 锁竞争 | SQL、事务、取消、连接与数据库状态 | 不是“查不到行” |
Resolver 使用 unstable 引用时,在特定 DeadObjectException 分支会重新获取 stable 引用并重试打开。它是当前源码的恢复策略;带写入或其他副作用的自定义 Provider 不因此自动具有安全重试语义。示例的只读文件端点把失败原样记录,不做无限循环重试。
Activity.onDestroy 请求停止 worker 并移除界面回调;运行中的 I/O 是否立刻被中断取决于具体操作。示例的 try-with-resources 承担资源收尾,界面更新先检查 Activity 状态。停止一个 Executor 的排队任务,不等于为任意文件或数据库操作提供可保证的取消期限。
10.10 运行、观察与对照实验
以下是待执行的教学操作,本章未安装 APK、未启动或停止设备、未采集本章 Trace。所有判据都需要读者执行后记录。不要把上一章同一设备上的成功直接填为本章结果。
实验一 对照两个进程和三种访问
先在终端 A 按 10.2 构建本轮 APK,再打开 Host Bash 终端 B,选择同一设备并实时监听。B 有独立的环境变量。
chapter10_top=/absolute/path/to/aosp
chapter10_adb="$chapter10_top/out/host/linux-x86/bin/adb"
test -x "$chapter10_adb" || exit 1
"$chapter10_adb" devices -l || exit 1
read -r -p '输入与终端 A 相同的设备 serial:' chapter10_serial
test -n "$chapter10_serial" || exit 1
"$chapter10_adb" -s "$chapter10_serial" logcat -v threadtime -s Chapter10:I '*:S'
回到 A。安装只处理本章测试包。-S 会先停止旧进程,因此这段命令要在观察 fd 之前执行。
chapter10_launch=""
if [[ -n "${chapter10_apk:-}" ]] && test -s "$chapter10_apk" &&
"$chapter10_adb" -s "$chapter10_serial" install -r "$chapter10_apk" &&
chapter10_launch=$(mktemp -d "$chapter10_run/launch.XXXXXX") &&
"$chapter10_adb" -s "$chapter10_serial" shell 'date "+%m-%d %H:%M:%S.000"' \
> "$chapter10_launch/trigger-time.txt" &&
"$chapter10_adb" -s "$chapter10_serial" shell am start -S -W \
-n com.example.storagedemo/.MainActivity --es action all \
> "$chapter10_launch/start.txt" 2>&1 &&
grep -q '^Status: ok' "$chapter10_launch/start.txt"; then
cat "$chapter10_launch/start.txt"
else
printf '%s\n' '本轮安装或启动失败。先检查构建、设备连接和启动结果。' >&2
if [[ -n "$chapter10_launch" && -f "$chapter10_launch/start.txt" ]]; then
cat "$chapter10_launch/start.txt" >&2
fi
chapter10_launch=""
fi
am start -W 的退出状态与输出中的 Status: ok 一起核对。启动通过后,在 B 等待这轮 direct、provider 和 query 三项结果。按当前客户端和 Provider 的不同 PID、时间与线程对照。静态预期是 direct 为 23 bytes、provider 为 25 bytes、query 为 label=provider-payload bytes=25,且没有异常。看到同轮业务结果后,再回 A 保存日志和进程身份。
if [[ -n "${chapter10_launch:-}" ]] &&
chapter10_since=$(tr -d '\r\n' < "$chapter10_launch/trigger-time.txt") &&
[[ -n "$chapter10_since" ]]; then
"$chapter10_adb" -s "$chapter10_serial" logcat -d -v threadtime \
-T "$chapter10_since" -s Chapter10:I '*:S' > "$chapter10_launch/all-logcat.txt" &&
"$chapter10_adb" -s "$chapter10_serial" shell pidof com.example.storagedemo &&
"$chapter10_adb" -s "$chapter10_serial" shell pidof com.example.storagedemo:provider
fi
日志快照仍可能包含同一秒或其他触发的记录。用终端 B 观察到的 PID、时间与三项结果检查快照。缺任一项时先查 B 和启动记录。
如果测试中由你执行 adb root、重启 adbd 或重启设备,原监听可能结束,必须重开终端 B 后再触发下一次操作。本文不要求为普通示例获取 root。
实验二 在 fd 尚未关闭时观察它
hold 动作要等工作线程完成 openFileDescriptor、建立 AutoCloseInputStream 后,才打印 received fd=... inode=... hold=true 并等待十秒。am start -W 等的是 Activity 启动/显示阶段,不会替我们等待这个异步业务事件。观察窗口以本轮 received 日志开始,以十秒到期、providerRead 开始或进程退出等较早发生的边界结束。
先保持终端 B 按上一实验实时监听日志;如果监听已退出,先重开,再触发下一轮。在终端 A 启动 hold 之前预先定义下面的只读核对函数,减少拿到日志后临时准备命令的时间。函数参数依次是本轮日志中的 PID、fd 和 inode,不使用历史编号,也不通过列出整个 fd 目录猜目标。
chapter10_observe_fd() {
local observed_pid="$1" observed_fd="$2" expected_inode="$3"
local current_pid actual_inode fd_path status
if [[ ! "$observed_pid" =~ ^[0-9]+$ || ! "$observed_fd" =~ ^[0-9]+$ \
|| ! "$expected_inode" =~ ^[0-9]+$ ]]; then
echo 'PID、fd、inode 必须来自本轮 received 日志。'
return 2
fi
current_pid=$("$chapter10_adb" -s "$chapter10_serial" shell pidof com.example.storagedemo)
status=$?
current_pid="${current_pid//$'\r'/}"
if (( status != 0 )) || [[ "$current_pid" != "$observed_pid" ]]; then
echo '进程已改变或无法确认,本次观察无效。'
return 2
fi
fd_path="/proc/$observed_pid/fd/$observed_fd"
actual_inode=$("$chapter10_adb" -s "$chapter10_serial" shell stat -L -c %i "$fd_path")
status=$?
actual_inode="${actual_inode//$'\r'/}"
if (( status != 0 )); then
echo '未取得目标 fd:区分权限受限与窗口过期,不能据此判定传递失败。'
return 2
fi
if [[ "$actual_inode" != "$expected_inode" ]]; then
echo 'fd 对应的 inode 已不匹配,本次观察无效。'
return 2
fi
"$chapter10_adb" -s "$chapter10_serial" shell readlink "$fd_path"
status=$?
if (( status != 0 )); then
echo '读取链接失败,本次观察未完成。'
return 2
fi
actual_inode=$("$chapter10_adb" -s "$chapter10_serial" shell stat -L -c %i "$fd_path")
status=$?
actual_inode="${actual_inode//$'\r'/}"
if (( status != 0 )) || [[ "$actual_inode" != "$expected_inode" ]]; then
echo '采样期间 fd 消失或改变,本次观察无效。'
return 2
fi
echo '目标 fd 与 inode 前后匹配;还需用同轮日志/Trace 确认采样未跨过持有窗口。'
}
接着在终端 A 触发新的一轮 hold,终端 B 已在监听。先记录设备时间作为本轮触发的时间下界,再启动应用:
"$chapter10_adb" -s "$chapter10_serial" shell 'date "+%m-%d %H:%M:%S"'
"$chapter10_adb" -s "$chapter10_serial" shell am start -S -W \
-n com.example.storagedemo/.MainActivity --es action hold
"$chapter10_adb" -s "$chapter10_serial" shell pidof com.example.storagedemo
启动命令返回后,先在终端 B 等待这次触发产生的日志,不能立刻把 pidof 成功当成 fd 已就绪。日志的形状如下,这里没有提供可复用的实际编号:
pid=本轮客户端PID tid=本轮工作线程TID received fd=本轮fd inode=本轮inode hold=true
核对日志时间在本次触发之后、PID 与本轮客户端一致、hold=true,再立刻在终端 A 输入同一行的三个数并采样:
read -r -p '输入刚收到的本轮 PID fd inode(三个整数):' \
chapter10_observed_pid chapter10_observed_fd chapter10_observed_inode
chapter10_observe_fd "$chapter10_observed_pid" \
"$chapter10_observed_fd" "$chapter10_observed_inode"
有效观察必须同时满足:received 事件已发生、仍处在其后的持有窗口、进程未换、明确 fd 的 inode 前后匹配。 日志里进入 Chapter10/providerRead 的 Trace 区间、出现本轮 provider bytes=...、十秒已到或进程退出时,就不再把采样算作“持有窗口内”。read 结束后流才按 try-with-resources 关闭;Trace 读取区间的开始是本实验采用的保守采样截止点,不冒称它就是精确 close 时刻。
若人工输入或命令执行太慢、fd 已消失、同一槽位被复用,记为窗口无效,重新触发 hold 并等待新的 received 日志;不能把一次空列表或 ENOENT 写成“Binder 没传 fd”。如果是 Permission denied,则记为观察受限,不是窗口成功或传递失败。函数的前后 inode 检查能排除部分复用,但不能替代日志/Trace 对时间窗口的界定,也不能保证任意慢设备都能在十秒内完成这些命令。
Provider 已经返回后,它的临时返回 fd 可能早已被序列化清理,不能要求两个进程同时打印同一个数字。同轮客户端 fd、inode 与 read 结果,结合 fd 转移源码解释所有权;若要证明某笔事务的 fixup,仍需额外驱动事件证据。 本章没有实际运行这组命令,不把上述判据写成已经观测到的成功。
实验三 对照包重启后的首请求与同进程再次请求
默认 all 先写后读。DemoProvider.onCreate 建立路径和数据库 helper,首次 openFile 或 query 进入 ensureData 时才同步小文件并插入一行。两项都成功后,本进程才将准备状态标为完成。应用重启会重建进程内状态,Kernel 页缓存可能保留。
下面这条命令比较的是包重启后的首请求;Provider 重启后,首次业务请求会重新进入数据准备。若要观察同一 Provider 进程的后续请求,可在同一轮 Activity 中再次点击按钮,并用本轮 PID 和请求日志确认进程是否保持;按钮会重复 all 的完整序列,也不能把它当成只改变 Provider 缓存的单变量实验。
"$chapter10_adb" -s "$chapter10_serial" shell am start -S -W \
-n com.example.storagedemo/.MainActivity --es action provider
对照维度包括:Provider 是否需启动、初始化是否执行、SQL 缓存是否已热、Kernel 缓存是否满足、是否出现块请求。一次只主改一个条件;不要为了制造冷读去默认清全机缓存、格式化或改挂载。 大文件、内存压力和 Direct I/O 可以另做受控实验,并记录其与本例的差别。
实验四 用实际挂载与设备关系选择源码
先保存系统卷视图和挂载信息,之后再把目标路径关联到具体文件系统:
"$chapter10_adb" -s "$chapter10_serial" shell dumpsys mount > "$chapter10_run/mount-service.txt"
"$chapter10_adb" -s "$chapter10_serial" shell cat /proc/mounts > "$chapter10_run/shell-mounts.txt"
"$chapter10_adb" -s "$chapter10_serial" shell getprop ro.crypto.type
"$chapter10_adb" -s "$chapter10_serial" shell getprop ro.crypto.state
chapter10_pid=$("$chapter10_adb" -s "$chapter10_serial" shell pidof com.example.storagedemo | tr -d '\r')
if [[ "$chapter10_pid" =~ ^[0-9]+$ ]]; then
chapter10_mount=$(mktemp -d "$chapter10_run/mount.XXXXXX") || exit 1
"$chapter10_adb" -s "$chapter10_serial" shell cat "/proc/$chapter10_pid/mountinfo" \
> "$chapter10_mount/client-mountinfo.txt" 2> "$chapter10_mount/client-mountinfo.err"
chapter10_mount_status=$?
printf '%s\n' "$chapter10_mount_status" > "$chapter10_mount/exit-status.txt"
if (( chapter10_mount_status == 0 )) &&
grep -qE '^[0-9]+ [0-9]+ [0-9]+:[0-9]+ ' "$chapter10_mount/client-mountinfo.txt"; then
printf '%s\n' "$chapter10_mount/client-mountinfo.txt"
else
printf '%s\n' '没有取得可用的目标进程 mountinfo。' >&2
fi
fi
最后一条可能受权限限制;文件非空不等于命令成功,要记录退出码与是否含错误。Shell 的 mount 表用于导航,目标进程的 mountinfo 才直接描述它的挂载视图。读取不到目标信息时,记录缺口,不拿 Shell 输出冒充应用视图。
从目标 mountinfo 或可信设备证据取设备名,不要照抄历史 dm-6。例如手动确认 /data 的来源为某个 dm 设备后,继续只读检查:
read -r -p '输入本轮确认的块设备名,例如 dm-6(不要带路径):' chapter10_block
if [[ "$chapter10_block" =~ ^[a-zA-Z0-9_-]+$ ]]; then
"$chapter10_adb" -s "$chapter10_serial" shell ls -l "/sys/class/block/$chapter10_block/slaves"
"$chapter10_adb" -s "$chapter10_serial" shell readlink -f "/sys/class/block/$chapter10_block/device/driver"
fi
device-mapper 本身不一定有对应的物理 driver 链接,需要沿 slaves 继续取下层设备。多个 slaves 可能表示更复杂的映射关系。看到 virtio_blk 说明设备绑定;要证明某次 read 产生了哪个块请求,还要结合 Trace 与时间、设备号、请求方向等证据。
FUSE 继续检查目标外部路径是否真的位于 FUSE mount、MediaProvider 的服务与会话、相关属性/配置;crypto 属性只能描述概况,不能替代 fscrypt policy 或 dm target 的核验。不要读取或导出真实用户密钥。
实验五 采集分阶段 Trace 而不是只看总耗时
配套Perfetto 配置包含应用与 Provider 的自定义区间、Binder、调度和候选块 I/O 事件。目标需可运行 Perfetto,tracefs 事件的支持与权限由设备决定;缺事件时根据本机可用事件调整,并保留调整后的配置。
采集前先打开 Host Bash 终端 C,终端 B 继续监听日志。C 不继承 A 的变量,先独立准备:
chapter10_top=/absolute/path/to/aosp
chapter10_adb="$chapter10_top/out/host/linux-x86/bin/adb"
"$chapter10_adb" devices -l
read -r -p '输入与终端 A 相同的设备 serial:' chapter10_serial
在 A 创建本轮独立目录,从标准输入把配置交给 Perfetto。A 正在采集时,在 C 触发下一段 all 命令,B 继续监听。下面只有在采集命令成功、拉取成功且文件非空时才输出 Trace 路径。
chapter10_trace=""
chapter10_capture=$(mktemp -d "$chapter10_run/capture.XXXXXX") || exit 1
chapter10_config="$chapter10_notes/示例/追踪配置/第十章Storage.pbtxt"
chapter10_remote="/data/misc/perfetto-traces/chapter10-${chapter10_capture##*/}.perfetto-trace"
chapter10_result="$chapter10_capture/chapter10-storage.perfetto-trace"
chapter10_trace_log="$chapter10_capture/perfetto.log"
if test -s "$chapter10_config" &&
"$chapter10_adb" -s "$chapter10_serial" shell -T perfetto --txt \
-c - -o "$chapter10_remote" < "$chapter10_config" 2> "$chapter10_trace_log" &&
! grep -qiE 'failed to (start tracing|connect|enable)|service unavailable' "$chapter10_trace_log" &&
"$chapter10_adb" -s "$chapter10_serial" pull "$chapter10_remote" "$chapter10_result" &&
test -s "$chapter10_result"; then
chapter10_trace="$chapter10_result"
printf '%s\n' "$chapter10_trace"
else
printf '%s\n' '本轮采集或拉取失败。检查日志后换新目录重采。' >&2
if test -s "$chapter10_trace_log"; then
cat "$chapter10_trace_log" >&2
fi
fi
在终端 C,确认 A 已进入采集后立即执行:
"$chapter10_adb" -s "$chapter10_serial" shell am start -S -W \
-n com.example.storagedemo/.MainActivity --es action all
all让同一轮包含直接文件、Provider文件和query区间。若实际Trace没有覆盖触发时刻,记本轮未完成,核对时间和采集覆盖后再重做;启动命令返回不证明采集或业务成功。
先看 Chapter10/providerOpen 与 Chapter10/providerRead,再看 Provider 进程的 providerOpenFile 和 providerQuery。跨进程区间存在因果关系,但两边耗时可能嵌套,不能简单相加;query 方法的 Trace 结束以后,返回适配器构造仍可能触发 Cursor 填窗。
把 A 打印出的本轮 Trace 路径导入 Perfetto 查看器,在该文件的 SQL 查询界面执行文末“示例/追踪配置/提取Storage区间.sql”。不要把配置 pbtxt 或旧一轮 Trace 当作查询对象。用业务区间 SQL可按进程与线程查询区间。再把 Kernel block 事件放到相同时间轴:没有对应请求可能来自缓存,也可能是权限、配置或事件未采集。只有确认采集覆盖,才可以把“没有看见”作为这个观察窗口的证据。 本章未生成任何声称实测的时间线图。
失败对照与结束
missing 动作只改变固定 URI 的末段,预期 Provider 拒绝,客户端记录 FileNotFoundException;应用仍使用同一包和同一权限配置。DemoProvider 在 providerOpenFile 区间开始前先检查 URI,因此没有该业务区间也可能是请求已经到达后被拒绝。
"$chapter10_adb" -s "$chapter10_serial" shell am start -S -W \
-n com.example.storagedemo/.MainActivity --es action missing
随后改回 all,应恢复正常访问。退出 Activity 后检查其界面不再更新,观察资源关闭;Provider 进程仍保留并不直接证明泄漏。若不再需要测试应用,可手动卸载,这会删除本章测试包及其私有数据:
"$chapter10_adb" -s "$chapter10_serial" uninstall com.example.storagedemo
实验完成后按实验记录模板保存本轮版本、命令、退出码、原始日志与边界,另行更新覆盖状态。
10.11 回顾、自测与源码速查
把主线重新连起来
- 文件 API 在本进程内把路径转成 fd,读写经 libcore、JNI、Bionic 进入 Kernel。
- Provider 先把 authority 变成组件引用,再按接口提供 fd 或 Cursor;只读整文件还有 typed/asset 默认委托的桥梁。
- Binder 传 fd 时,Driver 转移打开文件引用并给接收方安装描述符,不要求 fd 数字一致,不复制整份文件内容。
- 普通文件数据进入实际文件系统与页缓存,需要时才生成块 I/O;Guest VirtIO 完成与 Host 持久性仍有明确边界。
- Cursor 返回涉及远端适配器、窗口、SQL 执行与清理;不把数据库连接指针或数据库文件 fd 暴露成普通查询结果。
- 卷挂载、FUSE 和密钥状态改变路径可见性、策略与可访问条件,属于与数据 I/O 相连但不同的管理链。
- 返回、关闭、同步、组件引用和宿主退出分别结束不同责任,不能用一个成功日志证明全部闭环。
自测 先预测再核对
| 问题 | 参考答案与定位 |
|---|---|
new File 成功,是否证明目标文件存在且可读? | 不证明;它主要表示路径,实际 open 才走打开与权限路径,见 10.3 |
| FileOutputStream 调 open,为什么跟踪看到 openat? | Bionic 的 open 包装使用 __openat,见 10.3 |
| Provider 返回的 fd=71,客户端是不是也必须用 71? | 不必;接收方文件表分配自己的有效槽位,见 10.5 |
| 只重写 openFile,为什么只读请求还能成功? | 默认 typed */* → openAssetFile → openFile,见 10.5;自定义实现可能改变它 |
| Provider 已返回 PFD 后,普通文件内容是否每块都走 Binder? | 不必;本例客户端用自己的普通文件 fd 直接 read,其他 fd 类型另判,见 10.5 |
| 关闭流和关闭 Resolver 的 Provider 引用是不是同一件事? | 是不同责任,本例通过 AutoCloseInputStream 与内部 PFD 包装串起来,见 10.5、10.9 |
| stable Provider 是不是保证服务绝不死? | 不是;它描述进程依赖引用属性,见 10.5、10.9 |
| query 返回后才开始 SQLite 第一次取行吗? | 不一定;服务端 getBulkCursorDescriptor 的 getCount 可先填窗,见 10.6 |
| CursorWindow 总共享内存吗,Native 指针会传到客户端吗? | 不总是;本版有空窗、内联复制、ashmem fd 分支,客户端重建本地窗口,见 10.6 |
| am start -W 返回后就能观察 hold 的 fd 吗? | 还要等同轮 received fd/inode/hold=true,并在窗口结束前核对明确目标;过期记无效,见 10.10 |
| read 很快、没有 block 事件,能证明数据没经过 Kernel 吗? | 不能;可由页缓存满足,也要排除采集缺失,见 10.4、10.10 |
| write 返回、fsync 返回、close 返回分别意味着什么? | 接受字节、同步请求的结果、结束描述符所有权,持久性和目录项另有边界,见 10.4 |
| 应用私有文件是否都先经过 FUSE? | 不是;按实际路径和 mount 选择文件系统,见 10.7 |
| 看到一个 dm 设备,能断言它是加密层吗? | 不能;必须核对 dm target、配置与 slaves,见 10.4、10.8 |
| 屏幕锁定后还能读 CE 文件,是否说明 FBE 失效? | 不能;锁屏与用户 CE key 的移除不同,见 10.8 |
| 每次 read 是否都向 KeyMint 请求解密? | 不能这样理解;密钥保护与 Kernel 文件加解密路径分开,见 10.8 |
| Provider 进程还活着是否证明 Cursor 泄漏? | 不能;还可能有其他组件、引用与进程缓存策略,见 10.9 |
| all 模式通过后,本章哪些仍未验证? | 外部存储 FUSE、跨 UID、加密解锁、并发/容量、恢复与 Host 持久性等都需独立证据 |
按问题定位源码
| 要解决的问题 | 入口与下一站 |
|---|---|
| Java 文件何时真正 open / write | FileOutputStream → IoBridge → Linux JNI → Bionic open/write |
| fd 在哪里安装 | Kernel do_sys_openat2 → do_filp_open → fd_install |
| 普通读取怎样命中缓存 | vfs_read → ext4_file_read_iter → generic_file_read_iter / filemap_read |
| 同步写入怎样等待 | Linux_fsync → ext4_sync_file → 数据回写 / 日志 / 条件 flush |
| 块请求怎样交给 guest Driver | bio → device-mapper / blk-mq → virtio_queue_rq → virtqueue |
| Provider 引用来自哪里 | ApplicationContentResolver → ActivityThread.acquireProvider → ContentProviderHelper / 发布 |
| 只读 open 怎样到手写方法 | ContentResolver.openTypedAssetFileDescriptor → Transport → typed / asset 默认委托 → openFile |
| fd 怎样跨 Binder | Parcel.writeFileDescriptor → writeDupFileDescriptor → binder_translate_fd / binder_apply_fd_fixups |
| 客户端关闭怎样归还 Provider | ParcelFileDescriptorInner.releaseResources → ContentResolver.releaseProvider |
| query 何时执行和填窗 | ContentProviderNative → CursorToBulkCursorAdaptor → SQLiteCursor / SQLiteQuery / SQLiteSession / SQLiteConnection |
| 外部存储挂载怎样建立 FUSE | StorageManagerService → IVold / EmulatedVolume → MountUserFuse → ExternalStorageServiceImpl / FuseDaemon |
| key 怎样影响文件打开 | FsCrypt / KeyStorage / KeyUtil → FS_IOC_ADD_ENCRYPTION_KEY → fscrypt_file_open |
固定版本与源码范围
| 项目 | 本文固定提交 |
|---|---|
| bionic | 06356e41c5ed7b12220b24c05ba4fdb873b126a7 |
| external/sqlite | 7961228217942c86f2b0bd2ae4115d00e157fc0b |
| frameworks/base | 94b4c163b7dfe5ce3607f7bb8456f9573f7de57d |
| frameworks/native | ae266dcb706d083868578cfedce381ef44488a07 |
| kernel | ccafb60de224d35a8bc14de33e1cd47caaaa786b |
| libcore | 4ebfb391ee0109d16abe6e2bc965724b940928c5 |
| packages/providers/MediaProvider | 773ea53100eeb1e97c223826ca59054a58cd74ff |
| system/vold | 6d20a0078c2bcaa2499dc5d032f337bfe1182d9e |
摘录先锁定函数范围,再从该范围抽取连续原文,适用条件在正文就近解释。Kernel 文件按固定 Gitiles 提交读取,当前工程并没有被当作完整 Kernel checkout。
附录 A 示例完整输入文件
前文已经解释了三个动作与各自实现,以下四个完整文件用于自行创建同一工程。它们是本章手写示例,不是 AOSP 自带程序;初次运行需要经过 10.2 的构建与 10.10 的安装,不能仅因下列源码存在就认定程序已运行成功。
Android.bp
知识库展开文件名是 Android.bp.example,解压到构建树或手动创建模块时改为 Android.bp。
android_app {
name: "Chapter10StorageDemo",
manifest: "AndroidManifest.xml",
srcs: ["src/**/*.java"],
sdk_version: "current",
min_sdk_version: "28",
certificate: "testkey",
optimize: { enabled: false },
}
AndroidManifest.xml
Provider 使用 :provider 进程;不导出、不申请跨应用访问权限。files 与数据库都是本章包的私有数据,卸载会删除。
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.storagedemo">
<uses-sdk android:minSdkVersion="28" />
<application android:label="Storage Demo" android:debuggable="true"
android:theme="@android:style/Theme.Material.Light.NoActionBar">
<activity android:name=".MainActivity" android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<provider android:name=".DemoProvider"
android:authorities="com.example.storagedemo.files"
android:process=":provider" android:exported="false" />
</application>
</manifest>
MainActivity.java
工作放在单线程 Executor 中,Trace 区分 Provider 打开和真正读取。hold 是观察 fd 的十秒窗口;退出时 shutdownNow 不是任意阻塞 I/O 的期限保证。
package com.example.storagedemo;
import android.app.Activity;
import android.content.ContentResolver;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.ParcelFileDescriptor;
import android.os.Process;
import android.os.Trace;
import android.system.Os;
import android.util.Log;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public final class MainActivity extends Activity {
private static final String TAG = "Chapter10";
private static final String AUTHORITY = "content://com.example.storagedemo.files/";
private final ExecutorService worker = Executors.newSingleThreadExecutor();
private final Handler main = new Handler(Looper.getMainLooper());
private TextView result;
@Override public void onCreate(Bundle state) {
super.onCreate(state);
LinearLayout layout = new LinearLayout(this);
layout.setOrientation(LinearLayout.VERTICAL);
result = new TextView(this);
Button button = new Button(this);
button.setText("运行文件与 Provider 对照");
button.setOnClickListener(v -> run("all"));
layout.addView(button);
layout.addView(result);
setContentView(layout);
String action = getIntent().getStringExtra("action");
run(action == null ? "all" : action);
}
private void run(String action) {
worker.execute(() -> {
try {
if ("all".equals(action)) {
directFile();
providerFile(Uri.parse(AUTHORITY + "file/payload.txt"), false);
providerQuery();
} else if ("provider".equals(action)) {
providerFile(Uri.parse(AUTHORITY + "file/payload.txt"), false);
} else if ("hold".equals(action)) {
providerFile(Uri.parse(AUTHORITY + "file/payload.txt"), true);
} else if ("missing".equals(action)) {
providerFile(Uri.parse(AUTHORITY + "file/missing.txt"), false);
} else {
throw new IllegalArgumentException("Unknown action: " + action);
}
show("完成:" + action);
} catch (Exception error) {
Log.e(TAG, "action=" + action + " failed", error);
show(error.getClass().getSimpleName() + ": " + error.getMessage());
}
});
}
private void directFile() throws Exception {
Trace.beginSection("Chapter10/direct");
try {
File file = new File(getFilesDir(), "direct.txt");
byte[] bytes = "chapter10: direct file\n".getBytes(StandardCharsets.UTF_8);
try (FileOutputStream out = new FileOutputStream(file)) {
out.write(bytes);
Os.fsync(out.getFD());
}
try (FileInputStream in = new FileInputStream(file)) {
log("direct bytes=" + count(in) + " path=" + file);
}
} finally {
Trace.endSection();
}
}
private void providerFile(Uri uri, boolean hold) throws Exception {
Trace.beginSection("Chapter10/providerOpen");
ParcelFileDescriptor descriptor;
try {
descriptor = getContentResolver().openFileDescriptor(uri, "r");
if (descriptor == null) {
throw new java.io.IOException("Provider returned null: " + uri);
}
} finally {
Trace.endSection();
}
// AutoCloseInputStream closes both its stream and the ParcelFileDescriptor.
try (InputStream in = new ParcelFileDescriptor.AutoCloseInputStream(descriptor)) {
log("received fd=" + descriptor.getFd() + " inode="
+ Os.fstat(descriptor.getFileDescriptor()).st_ino + " hold=" + hold);
if (hold) Thread.sleep(10000);
Trace.beginSection("Chapter10/providerRead");
try {
log("provider bytes=" + count(in) + " uri=" + uri);
} finally {
Trace.endSection();
}
}
}
private void providerQuery() {
Trace.beginSection("Chapter10/query");
try {
ContentResolver resolver = getContentResolver();
try (Cursor cursor = resolver.query(Uri.parse(AUTHORITY + "metadata"),
new String[]{"_id", "label", "bytes"}, null, null, null)) {
if (cursor == null || !cursor.moveToFirst()) {
throw new IllegalStateException("Missing metadata row");
}
log("query label=" + cursor.getString(cursor.getColumnIndexOrThrow("label"))
+ " bytes=" + cursor.getLong(cursor.getColumnIndexOrThrow("bytes")));
}
} finally {
Trace.endSection();
}
}
private static long count(InputStream in) throws java.io.IOException {
byte[] buffer = new byte[4096];
long total = 0;
int n;
while ((n = in.read(buffer)) != -1) total += n;
return total;
}
private static void log(String message) {
Log.i(TAG, "pid=" + Process.myPid() + " tid=" + Process.myTid() + " " + message);
}
private void show(String message) {
main.post(() -> {
if (!isFinishing() && !isDestroyed()) result.setText(message);
});
}
@Override protected void onDestroy() {
worker.shutdownNow();
main.removeCallbacksAndMessages(null);
super.onDestroy();
}
}
DemoProvider.java
Provider 构造数据库 helper,但延迟到首次请求执行文件与数据库准备。初始化受锁保护;一次 query 的 Cursor 可继续使用 Provider 持有的连接池,不能在刚返回 Cursor 时把 helper 关闭。
package com.example.storagedemo;
import android.content.ContentProvider;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.net.Uri;
import android.os.ParcelFileDescriptor;
import android.os.Process;
import android.os.Trace;
import android.system.ErrnoException;
import android.system.Os;
import android.util.Log;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public final class DemoProvider extends ContentProvider {
private static final String AUTHORITY = "com.example.storagedemo.files";
private static final byte[] PAYLOAD =
"chapter10: provider file\n".getBytes(StandardCharsets.UTF_8);
private final Object initLock = new Object();
private Database helper;
private File payload;
private boolean ready;
@Override public boolean onCreate() {
Context context = getContext();
if (context == null) return false;
// The helper constructor does not open the database. I/O is deferred to a request.
helper = new Database(context);
payload = new File(context.getFilesDir(), "provider-payload.txt");
return true;
}
private void ensureData() throws IOException {
synchronized (initLock) {
if (ready) return;
try (FileOutputStream out = new FileOutputStream(payload)) {
out.write(PAYLOAD);
try {
Os.fsync(out.getFD());
} catch (ErrnoException error) {
throw error.rethrowAsIOException();
}
}
ContentValues row = new ContentValues();
row.put("_id", 1);
row.put("label", "provider-payload");
row.put("bytes", PAYLOAD.length);
long inserted = helper.getWritableDatabase().insertWithOnConflict(
"metadata", null, row, SQLiteDatabase.CONFLICT_REPLACE);
if (inserted == -1) throw new IOException("Cannot write metadata row");
ready = true;
}
}
private static void check(Uri uri, String path) throws FileNotFoundException {
if (!"content".equals(uri.getScheme()) || !AUTHORITY.equals(uri.getAuthority())
|| !path.equals(uri.getPath())) {
throw new FileNotFoundException("Unsupported URI: " + uri);
}
}
@Override public ParcelFileDescriptor openFile(Uri uri, String mode)
throws FileNotFoundException {
check(uri, "/file/payload.txt");
if (!"r".equals(mode)) throw new FileNotFoundException("Read-only endpoint");
Trace.beginSection("Chapter10/providerOpenFile");
try {
ensureData();
Log.i("Chapter10", "openFile pid=" + Process.myPid()
+ " tid=" + Process.myTid() + " mode=" + mode);
return ParcelFileDescriptor.open(payload, ParcelFileDescriptor.MODE_READ_ONLY);
} catch (IOException error) {
FileNotFoundException failure = new FileNotFoundException(error.getMessage());
failure.initCause(error);
throw failure;
} finally {
Trace.endSection();
}
}
@Override public Cursor query(Uri uri, String[] projection, String selection,
String[] selectionArgs, String sortOrder) {
Trace.beginSection("Chapter10/providerQuery");
try {
check(uri, "/metadata");
if (selection != null || selectionArgs != null || sortOrder != null) {
throw new IllegalArgumentException("This endpoint uses a fixed query");
}
if (projection != null) {
for (String column : projection) {
if (!"_id".equals(column) && !"label".equals(column)
&& !"bytes".equals(column)) {
throw new IllegalArgumentException("Unknown column: " + column);
}
}
}
ensureData();
Log.i("Chapter10", "query pid=" + Process.myPid() + " tid=" + Process.myTid());
return helper.getReadableDatabase().query("metadata", projection,
"_id = ?", new String[]{"1"}, null, null, null);
} catch (IOException error) {
throw new IllegalStateException("Cannot prepare metadata", error);
} finally {
Trace.endSection();
}
}
@Override public String getType(Uri uri) {
return "/file/payload.txt".equals(uri.getPath())
? "text/plain" : "vnd.android.cursor.item/vnd.storagedemo.metadata";
}
@Override public Uri insert(Uri uri, ContentValues values) {
throw new UnsupportedOperationException("Read-only endpoint");
}
@Override public int update(Uri uri, ContentValues values, String where, String[] args) {
throw new UnsupportedOperationException("Read-only endpoint");
}
@Override public int delete(Uri uri, String where, String[] args) {
throw new UnsupportedOperationException("Read-only endpoint");
}
private static final class Database extends SQLiteOpenHelper {
Database(Context context) { super(context, "metadata.db", null, 1); }
@Override public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE metadata (_id INTEGER PRIMARY KEY, label TEXT, bytes INTEGER)");
}
@Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
throw new IllegalStateException("No upgrade path in this example");
}
}
}
附录 B Perfetto 配置与查询
本附录对应 10.10 的 Trace 实验。按标题所示路径保存到本轮工作目录;源文件存在不代表构建或设备实验成功。
示例/追踪配置/第十章Storage.pbtxt
设备缺事件时保留修改副本,并将实验五的 chapter10_config 指向实际选用的 pbtxt。
buffers { size_kb: 32768 fill_policy: RING_BUFFER }
duration_ms: 20000
data_sources {
config {
name: "linux.ftrace"
ftrace_config {
buffer_size_kb: 4096
drain_period_ms: 250
atrace_categories: "am"
atrace_categories: "binder_driver"
atrace_categories: "disk"
atrace_apps: "com.example.storagedemo"
atrace_apps: "com.example.storagedemo:provider"
ftrace_events: "sched/sched_switch"
ftrace_events: "sched/sched_waking"
ftrace_events: "binder/binder_transaction"
ftrace_events: "binder/binder_transaction_received"
ftrace_events: "block/block_rq_issue"
ftrace_events: "block/block_rq_complete"
}
}
}
data_sources {
config {
name: "linux.process_stats"
process_stats_config { scan_all_processes_on_start: true }
}
}
示例/追踪配置/提取Storage区间.sql
在本轮实际Trace的SQL查询界面执行,结果为空先核对采集覆盖。
-- 对实际采集的 Trace 执行。没有行不等于相关业务从未发生。
SELECT
process.name AS process_name,
process.pid,
thread.tid,
slice.name,
ROUND(slice.ts / 1e6, 3) AS start_ms,
ROUND(slice.dur / 1e6, 3) AS duration_ms
FROM slice
JOIN thread_track ON slice.track_id = thread_track.id
JOIN thread ON thread_track.utid = thread.utid
LEFT JOIN process ON thread.upid = process.upid
WHERE slice.name GLOB 'Chapter10/*' AND slice.dur >= 0
ORDER BY slice.ts;