Android源码第十章:ContentProvider 与文件存储——从 URI 与 fd 追到存储后端

8 阅读1小时+

打开一个 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 的固定中转站
VFSKernel 文件接口抽象与分派根据实际文件系统选择 file_operations
页缓存文件数据在内存中的缓存与回写基础命中时可以不产生本次块设备读取
块层与 Driver将需要的块 I/O 调度到设备后端本章沿历史 Emulator 基线读 VirtIO block;真实设备可能用 UFS、eMMC 等

先区分三条路径 再看它们怎样汇合

Android 分层中的客户端、Provider、系统服务、Native 守护进程、Binder、文件系统和存储后端

先看左侧的文件数据线,再看蓝色的 Provider 请求和回复。右侧是卷与密钥控制。

三个入口有不同的完成条件。对照流程图看路径打开、URI 打开和查询分别取得什么,再沿着文件或窗口读到结果。

直接文件、URI 打开和 Cursor 查询从发起、返回到资源归还的整体流程

全章时序沿用同一套生命线。上半部按示例工作线程的顺序排直接读写、打开 URI 和查询。末两段是独立的卷挂载与用户解锁。手机上可先看阶段标题,再放大查看方法和箭头。

同一组生命线上的直接 I/O、普通文件 URI、Cursor 查询、FUSE 会话与 CE 密钥时序

直接文件访问通常在应用进程内经 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。

源码 FileOutputStream

        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 文件接口:

源码 Linux_writeBytes

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);
}

源码 Linux_readBytes

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 各有职责。

源码 do_sys_openat2

	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:

源码 ext4_file_read_iter

	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 的对齐、缓存或并发语义。

读缓存命中、未命中提交请求以及写入和 fsync 的不同完成出口

先沿读路径看“缓存是否满足”,再看写路径如何先标脏、后回写。图是控制与完成关系的概括,实际 bio 可分裂、合并、重映射;它不是一个 read 对应一个设备请求的保证。

观察缓存读取的分步示意:已有缓存必须数据就绪才直接复制;缺数据时,工作线程可以等待补页;本示意选择成功补齐数据的分支,条件满足后线程仍须等调度才能继续。错误或中断另走返回路径。 缓存命中与缺失是备选,示意中选择一次缺失过程不表示每个 read 都发设备请求。

页缓存命中时 可以直接把数据复制给用户

filemap_get_pages 查找文件映射中的缓存页;没有取得缓存批次时,进入预读与补页逻辑:

源码 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 的缓冲写入主分支先通过写检查,再执行页缓存写入:

源码 ext4_buffered_write_iter

	inode_lock(inode);
	ret = ext4_write_checks(iocb, from);
	if (ret <= 0)
		goto out;

	ret = generic_perform_write(iocb, from);

这个片段省略锁释放与返回后的同步判断;普通写会更新页缓存与脏状态,后续回写与文件系统日志参与持久化。它不保证每次 write 返回前已经完成底层设备写入。

ext4_sync_file 的有日志文件系统路径先等待数据,再等待相关日志事务:

源码 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:

源码 virtio_queue_rq

	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 列表的关键交接在下一个函数:

源码 virtblk_add_req

	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 系统接口请求:

源码 acquireProvider

                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:

源码 openFileDescriptor

        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 接口:

源码 openAssetFileDescriptor

            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,并读取包含文件信息的回复:

源码 openTypedAssetFile

            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 实现会选择不同分支,本文不把它们串成一条固定链。

客户端按只读 typed asset 路径调用 Provider 并取得 AFD

Transport 先检查 再委托真正的 Provider

Transport.openTypedAssetFile 接收的是 MIME 类型、opts 与取消信号,在处理 URI/userId 后,以固定的 "r" 执行读权限检查,并使用 openTypedAssetFile 的 Trace 名称:

源码 openTypedAssetFile

            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:

源码 openTypedAssetFile

        if ("*/*".equals(mimeTypeFilter)) {
            // If they can take anything, the untyped open call is good enough.
            return openAssetFile(uri, "r");

源码 openAssetFile

        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 后关闭相应原始所有权:

源码 writeToParcel

            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 引用,并检查转移权限:

源码 binder_translate_fd

	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 在接收方上下文分配可用槽位、把接收方的描述值写进事务数据,成功后安装文件:

源码 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 当成重新打开独立文件。

Provider 将普通文件引用交给 Parcel,Binder 再把引用安装到客户端

动图先看发送 Parcel 怎样保住同一个打开文件状态,再看 Driver 给接收方安装新的 fd。文件字节到下一步客户端 read 时才进入读缓冲区。

取得打开引用之后才开始阅读档案内容

接收的 fd 怎样变成客户端 Java 对象

Driver 安装好的 fd 先属于接收事务携带的资源。ContentProviderProxy 读取回复中的 AFD,其构造方法继续创建 PFD:

源码 AssetFileDescriptor

        mFd = ParcelFileDescriptor.CREATOR.createFromParcel(src);
        mStartOffset = src.readLong();
        mLength = src.readLong();

PFD 的 CREATOR 从 Parcel 取得 Java FileDescriptor,再创建包装对象:

源码 createFromParcel

            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:

源码 releaseResources

            if (mProviderReleased.compareAndSet(false, true)) {
                ContentResolver.this.releaseProvider(mContentProvider);
            }

AutoCloseInputStream 的 close 最终覆盖这层责任:

源码 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 接口继续取得。

query 跨进程后执行 SQLite 并通过远端 Cursor 协议回复窗口

getCount 本身就可能促使查询执行

服务端生成 BulkCursorDescriptor 时,会读取行数与当前窗口:

源码 getBulkCursorDescriptor

            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 根据连接与事务状态获取连接,继续委托:

源码 executeForCursorWindow

            return mConnection.executeForCursorWindow(sql, bindArgs,
                    window, startPos, requiredPos, countAllRows,

SQLiteConnection 绑定参数、附加取消信号后,调用 JNI:

源码 executeForCursorWindow

                        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 先写远端控制接口,再按是否有初始窗口写入窗口:

源码 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:

源码 writeToParcel

        acquireReference();
        try {
            dest.writeInt(mStartPos);
            nativeWriteToParcel(mWindowPtr, dest);
        } finally {

JNI 在 Provider 进程内还原两个本地对象,继续调用 Native 序列化:

源码 nativeWriteToParcel

    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:

源码 CursorWindow::create

    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,由当前窗口状态决定。 本例只有一行短文本与整数,所需内容很小,依据源码可推测通常能由内联窗口承载;本章没有运行采样,不把这个推测记成已观测到的分支。

CursorWindow 的空窗、内联字节和可映射共享区 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 和窗口:

源码 readFromParcel

        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 窗口:

源码 nativeCreateFromParcel

    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:

源码 nativeCreateFromParcel

    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 对象:

源码 nativeDispose

    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 引用:

源码 CursorWrapperInner.close

        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:

源码 VoldNativeService::mount

    vol->setMountCallback(callback);
    int res = vol->mount();
    vol->setMountCallback(nullptr);

    if (res != OK) {
        return translate(res);
    }

VolumeBase 对状态变更与 doMount 的关系很明确:

源码 VolumeBase::mount

    setState(State::kChecking);
    status_t res = doMount();
    setState(res == OK ? State::kMounted : State::kUnmountable);

    if (res == OK) {
        doPostMount();
    }

卷先进入 Checking,具体挂载成功后才成为 Mounted;失败转为 Unmountable。 “发出了挂载请求”和“应用已可访问”之间还包含回调、会话建立与状态通知。

system_server 调用 vold 挂载并将 FUSE 会话交给存储服务

EmulatedVolume 建立 FUSE 会话

本章选择 EmulatedVolume 的普通 FUSE 路径,不把可移动 PublicVolume 或早期根文件系统挂载强行塞进它。EmulatedVolume.doMount 先准备目录,再调用 MountUserFuse:

源码 EmulatedVolume::doMount

        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 系统调用建立挂载:

源码 MountUserFuse

    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 并启动:

源码 onStartSession

                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 才根据打开方式选择路径。打开阶段的固定源码

FUSE 打开选择与后续读取的直接、passthrough 和缓存分支

固定 Kernel 的 fuse_file_read_iter 有明确分支:

源码 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。

源码 fscrypt_unlock_ce_storage

    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 是否已安装;重复解锁不要求每次重新创建同一用户的所有状态。

用户解锁时恢复和安装内部 CE 密钥,之后根据文件策略访问

密钥材料的保护方式由当前 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:

源码 fscrypt_file_open

	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 encryptionfs_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。

谁负责关闭 要沿着所有权找

普通流、PFD、Provider 引用、Cursor 和窗口的关闭责任

资源本例创建或取得的位置正常结束异常与宿主退出
直接文件流Activity 工作线程try-with-resources close异常也进入 close;进程退出时 Kernel 关闭其 fd,不保证 Java finally 已运行
Provider 原始打开 fdDemoProvider.openFile返回序列化按返回值契约交给 Parcel 后关闭原所有权Binder 失败路径负责已取得引用的清理,不能在传输前手动提前关闭返回对象
接收方 PFD / 流Resolver 包装后由 Activity 持有AutoCloseInputStream.close → PFD.close → 内部引用归还不以 GC 作为主要关闭机制;读取中途失败仍按相同所有权关闭
查询 Cursor / 窗口Provider 创建,客户端持有适配器客户端 Cursor.close 带动远端与窗口释放服务端/客户端死亡还有 Binder 与框架清理,不能保证业务 onClose 日志总能出现
Provider 数据库 helper / poolProvider 实例持有多次查询可复用;测试的 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 CursorAPI 契约、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 回顾、自测与源码速查

把主线重新连起来

  1. 文件 API 在本进程内把路径转成 fd,读写经 libcore、JNI、Bionic 进入 Kernel。
  2. Provider 先把 authority 变成组件引用,再按接口提供 fd 或 Cursor;只读整文件还有 typed/asset 默认委托的桥梁。
  3. Binder 传 fd 时,Driver 转移打开文件引用并给接收方安装描述符,不要求 fd 数字一致,不复制整份文件内容。
  4. 普通文件数据进入实际文件系统与页缓存,需要时才生成块 I/O;Guest VirtIO 完成与 Host 持久性仍有明确边界。
  5. Cursor 返回涉及远端适配器、窗口、SQL 执行与清理;不把数据库连接指针或数据库文件 fd 暴露成普通查询结果。
  6. 卷挂载、FUSE 和密钥状态改变路径可见性、策略与可访问条件,属于与数据 I/O 相连但不同的管理链。
  7. 返回、关闭、同步、组件引用和宿主退出分别结束不同责任,不能用一个成功日志证明全部闭环。

自测 先预测再核对

问题参考答案与定位
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 / writeFileOutputStream → 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 Driverbio → device-mapper / blk-mq → virtio_queue_rq → virtqueue
Provider 引用来自哪里ApplicationContentResolver → ActivityThread.acquireProvider → ContentProviderHelper / 发布
只读 open 怎样到手写方法ContentResolver.openTypedAssetFileDescriptor → Transport → typed / asset 默认委托 → openFile
fd 怎样跨 BinderParcel.writeFileDescriptor → writeDupFileDescriptor → binder_translate_fd / binder_apply_fd_fixups
客户端关闭怎样归还 ProviderParcelFileDescriptorInner.releaseResources → ContentResolver.releaseProvider
query 何时执行和填窗ContentProviderNative → CursorToBulkCursorAdaptor → SQLiteCursor / SQLiteQuery / SQLiteSession / SQLiteConnection
外部存储挂载怎样建立 FUSEStorageManagerService → IVold / EmulatedVolume → MountUserFuse → ExternalStorageServiceImpl / FuseDaemon
key 怎样影响文件打开FsCrypt / KeyStorage / KeyUtil → FS_IOC_ADD_ENCRYPTION_KEY → fscrypt_file_open

固定版本与源码范围

项目本文固定提交
bionic06356e41c5ed7b12220b24c05ba4fdb873b126a7
external/sqlite7961228217942c86f2b0bd2ae4115d00e157fc0b
frameworks/base94b4c163b7dfe5ce3607f7bb8456f9573f7de57d
frameworks/nativeae266dcb706d083868578cfedce381ef44488a07
kernelccafb60de224d35a8bc14de33e1cd47caaaa786b
libcore4ebfb391ee0109d16abe6e2bc965724b940928c5
packages/providers/MediaProvider773ea53100eeb1e97c223826ca59054a58cd74ff
system/vold6d20a0078c2bcaa2499dc5d032f337bfe1182d9e

摘录先锁定函数范围,再从该范围抽取连续原文,适用条件在正文就近解释。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;

参考资料