From f5b3a991818306e2c687b523722b65ad734807e6 Mon Sep 17 00:00:00 2001 From: longjin Date: Thu, 5 Feb 2026 03:44:56 +0800 Subject: [PATCH 01/16] feat:fuse-support-phase-a-and-b --- ROADMAP_FUSE.md | 304 ++++++++++++++++++ TODO_FUSE_PHASE_AB.md | 49 +++ config/app-blocklist.toml | 2 + kernel/src/filesystem/devfs/mod.rs | 4 + kernel/src/filesystem/fuse/conn.rs | 278 ++++++++++++++++ kernel/src/filesystem/fuse/dev.rs | 247 ++++++++++++++ kernel/src/filesystem/fuse/fs.rs | 284 ++++++++++++++++ kernel/src/filesystem/fuse/mod.rs | 4 + kernel/src/filesystem/fuse/protocol.rs | 80 +++++ kernel/src/filesystem/mod.rs | 1 + kernel/src/filesystem/vfs/file.rs | 14 + kernel/src/filesystem/vfs/mod.rs | 1 + .../src/filesystem/vfs/syscall/sys_mount.rs | 2 +- user/apps/c_unitest/test_fuse_dev.c | 52 +++ user/apps/c_unitest/test_fuse_mount_init.c | 226 +++++++++++++ 15 files changed, 1547 insertions(+), 1 deletion(-) create mode 100644 ROADMAP_FUSE.md create mode 100644 TODO_FUSE_PHASE_AB.md create mode 100644 kernel/src/filesystem/fuse/conn.rs create mode 100644 kernel/src/filesystem/fuse/dev.rs create mode 100644 kernel/src/filesystem/fuse/fs.rs create mode 100644 kernel/src/filesystem/fuse/mod.rs create mode 100644 kernel/src/filesystem/fuse/protocol.rs create mode 100644 user/apps/c_unitest/test_fuse_dev.c create mode 100644 user/apps/c_unitest/test_fuse_mount_init.c diff --git a/ROADMAP_FUSE.md b/ROADMAP_FUSE.md new file mode 100644 index 0000000000..6490bf1506 --- /dev/null +++ b/ROADMAP_FUSE.md @@ -0,0 +1,304 @@ +# DragonOS FUSE 支持路线图（对齐 Linux 6.6 语义，分 PR/可测/可演示） + +> 目标：让 DragonOS 具备**可用、可演示**的 FUSE（Filesystem in Userspace）能力，并逐步对齐 Linux 6.6 的行为语义与用户态生态（libfuse/fusermount/sshfs 等）。 +> +> 说明：本文是“路线图”，不是最终设计文档；但每个阶段都给出**必须实现的东西**、**可独立 PR 的拆分**、**可单独测试的点**、以及**最终演示方式**。 + +--- + +## 0. 现状对齐：DragonOS 与 Linux 6.6 的关键实现接口 + +### 0.1 DragonOS 现有能力（与 FUSE 最相关的落点） + +- **挂载框架已具备**：`sys_mount` → `do_mount()` → `produce_fs()` 通过 `FSMAKER` 分发创建文件系统实例（见 `kernel/src/filesystem/vfs/syscall/sys_mount.rs`、`kernel/src/filesystem/vfs/mod.rs`）。 +- **VFS 操作面清晰**：文件系统通过实现 `FileSystem` + `IndexNode` 接入（`kernel/src/filesystem/vfs/mod.rs`）。 +- **devfs 设备节点框架可复用**：/dev 由 devfs 统一管理，内置字符设备在 `DevFS::register_bultinin_device()` 中注册（`kernel/src/filesystem/devfs/mod.rs`）。 +- **阻塞/唤醒与 poll/epoll 已具备基础设施**： + - `WaitQueue` 可用于“读阻塞 / 写唤醒 / 信号打断”（`kernel/src/libs/wait_queue.rs`）。 + - VFS 有 `PollableInode` 抽象与 epoll 集成；`eventfd` 是一个可参考的“伪文件描述符 + wait_queue + epoll item 链表”范例（`kernel/src/filesystem/eventfd.rs`、`kernel/src/filesystem/vfs/mod.rs`）。 +- **权限检查在路径遍历阶段发生**：`IndexNode::do_lookup_follow_symlink()` 会对目录执行权限（search/execute）做校验（`kernel/src/filesystem/vfs/mod.rs`）。这对 FUSE 的 `default_permissions` 语义很关键（后文详述）。 +- **目录读取当前依赖 `IndexNode::list()+find()`**：`File::read_dir()` 首次会缓存 `inode.list()` 的全量目录项名，然后逐个 `inode.find(name)`（`kernel/src/filesystem/vfs/file.rs`）。这与 Linux 的“readdir 流式 + offset”模型有差异，是一个需要在路线图里显式处理的点。 + +### 0.2 Linux 6.6 FUSE 的“最小闭环”关键路径（需要对齐的行为） + +以下为 Linux 6.6 的参考实现位置： + +- 协议与 uapi：`include/uapi/linux/fuse.h`（当前内核版本号 `7.39`，定义了 `FUSE_INIT`、各 opcode、结构体与 feature flags）。 +- /dev/fuse 设备（请求队列、read/write、poll、ioctl clone）：`fs/fuse/dev.c` +- 挂载参数解析与 superblock 建立：`fs/fuse/inode.c` +- 行为语义概述与 mount 选项：`Documentation/filesystems/fuse.rst` + +Linux 的基本闭环如下： + +1. 用户态 daemon `open("/dev/fuse")` 得到 fd； +2. `mount("fuse", target, "fuse", flags, "fd=N,rootmode=...,user_id=...,group_id=...")`； +3. 内核在连接建立后，**向 daemon 发送 `FUSE_INIT` 请求**（daemon read /dev/fuse 得到请求）； +4. daemon write 回 `FUSE_INIT` reply，完成版本/feature 协商； +5. 后续每个 VFS 操作（lookup/getattr/readdir/open/read/write…）转换成一条 FUSE request，daemon 处理后写回 reply，内核把结果映射回 VFS。 + +> 结论：DragonOS 要“有可用东西出来”，必须先做出上述闭环：**/dev/fuse + mount(fd=) + INIT 协商 + 若干核心 opcode**。 + +--- + +## 1. 必须实现的东西（按“能跑起来”到“能用起来”分层） + +为了便于拆 PR/验收，这里把“必须实现”分成三层：MVP（可演示）、可用版（能跑常见 FUSE FS）、生产版（安全/语义/性能接近 Linux）。 + +### 1.1 MVP（可演示、可交付）的“最低必需集” + +目标：实现一个**只依赖 DragonOS 自己的用户态 demo daemon**就能挂载并访问的 FUSE 文件系统（至少能 `ls`/`stat`/`cat`）。 + +MVP 必须具备： + +1) **/dev/fuse 字符设备** +- devfs 中提供 `/dev/fuse`（最好保证路径一致；若 DragonOS 把大多数字符设备放在 `/dev/char/*`，也要给出 `/dev/fuse` 兼容入口：直接节点或符号链接）。 +- 支持： + - `read()`：从内核请求队列取下一条 request（无请求时可阻塞；支持 nonblock 返回 `EAGAIN`）。 + - `write()`：写入 userspace reply，按 `unique` 匹配并唤醒等待该 reply 的内核线程。 + - `poll()/epoll()`：队列非空 → 可读；通常永远可写；断连 → `POLLERR`。 + - `close()`：daemon 退出时触发断连/abort，避免内核永久阻塞。 + +2) **FUSE 连接对象（connection）与请求生命周期** +- 统一的 `FuseConn`：维护 `connected/aborted`、request id（unique）、请求队列、等待队列、以及与挂载点的关联。 +- 请求：`(header + payload)` → 入队 → wake daemon → 内核线程 wait → reply 到达 → 唤醒返回。 +- 信号语义（MVP 允许简化）：至少保证被信号打断时内核不死锁；可以先不实现完整 `FUSE_INTERRUPT`，但要规划后续补齐。 + +3) **挂载：`-t fuse -o fd=...`** +- 新增 `FuseFS` 作为 `FSMAKER` 的一个条目（如 `"fuse"`/`"fuse3"` 选其一或都支持）。 +- `make_mount_data(raw_data)` 解析 `fd=,rootmode=,user_id=,group_id=`，并从当前进程 `fd_table` 获取对应 `File`，校验它确实来自 `/dev/fuse`。 +- mount 成功后：触发或保证 daemon 读 /dev/fuse 时**能收到 `FUSE_INIT` 请求**（建议 mount 时把 INIT request 放入队列）。 + +4) **核心 opcode（覆盖 `ls/stat/cat` 的最小集合）** +- `FUSE_INIT`：版本协商 + feature flags（MVP 可只支持一个较小子集）。 +- `FUSE_LOOKUP`：路径遍历（`IndexNode::find()`）必需。 +- `FUSE_GETATTR`：`stat()`/权限判断/类型判断必需。 +- `FUSE_OPENDIR + FUSE_READDIR + FUSE_RELEASEDIR`：目录 `list()` 必需。 +- `FUSE_OPEN + FUSE_READ + FUSE_RELEASE`：读取文件内容必需。 +- 建议同时包含： + - `FUSE_FORGET`（可先“弱化实现”，至少能减少内核对象泄漏风险）。 + - `FUSE_STATFS`（可先返回固定值，后续再对齐）。 + +5) **权限与路径遍历的最小策略** +- DragonOS 当前在路径遍历时做 `MAY_EXEC` 检查；MVP 为了不被权限卡死，建议： + - demo daemon 返回的目录权限至少 `0555`（或更宽）。 + - 先以 root 演示，降低权限语义复杂度。 +- 但路线图里必须明确：后续要支持 Linux 的 `default_permissions` / `allow_other` / “仅 mount owner 可访问”语义（见 1.2/1.3）。 + +### 1.2 可用版（能跑更多现成 FUSE FS）的必需补齐 + +目标：能跑“更真实”的 FUSE FS（例如更完整的 hello/passthrough 示例，或未来接入 libfuse）。 + +需要补齐： + +- **写路径与创建类操作** + - `FUSE_CREATE`/`MKNOD`/`MKDIR`/`UNLINK`/`RMDIR`/`RENAME`（至少覆盖基础文件增删改名） + - `FUSE_WRITE`/`SETATTR`（truncate/chmod/chown/utimens 等） + - `FUSE_FLUSH`/`FSYNC`/`RELEASE` 的行为对齐（可分阶段） +- **更完整的目录语义** + - `.`/`..`、`nlink`、inode id 稳定性、重名/硬链接等 + - 解决 DragonOS 当前 `list()` 模式与 FUSE `readdir+offset` 的差异：要么在 FUSE inode 内部做“全量拉取+缓存”，要么推动 VFS 抽象升级为“流式 readdir 回调”（推荐长期方向） +- **超时与缓存（attr/dentry cache）** + - Linux FUSE 有属性缓存与超时（由 daemon 返回）；可先实现最小缓存策略，否则会导致性能与语义不稳（例如频繁 getattr）。 +- **基础 xattr（可选但对生态有帮助）** + - `GETXATTR/SETXATTR/LISTXATTR/REMOVEXATTR`（可后置，但要规划） + +### 1.3 生产版（安全/语义/性能接近 Linux）的必需补齐 + +目标：支持非特权挂载（fusermount 模型）、更完善的信号/中断语义、可控的连接管理、以及性能可接受。 + +需要补齐： + +- **非特权挂载安全模型** + - “默认仅 mount owner 可访问”，`allow_other` 的限制（Linux fuse.rst 有详细动机） + - 与 DragonOS `Cred`/capability 的对齐（哪些能力允许 `allow_other`、哪些 mount flags 允许普通用户） + - 若要兼容 Linux 生态：最终需要用户态 `fusermount`（setuid root）或等价机制 +- **请求中断与连接 abort** + - `FUSE_INTERRUPT` 以及被信号打断时的竞态处理 + - 断连（daemon 死亡/close fd）时：所有 pending/processing 请求应快速失败并唤醒 +- **并发与多线程** + - `FUSE_DEV_IOC_CLONE`（libfuse 多线程常用） + - 背景队列/最大并发（Linux 有 max_background 等控制） +- **性能与 IO 能力** + - page cache / readahead / writeback cache（与 DragonOS `FileSystem::support_readahead()`、mm/page_cache 机制协同） + - 大 IO、零拷贝（splice/pipe）、mmap（`FOPEN_DIRECT_IO` 等） + +--- + +## 2. 推荐路线图（阶段 → 可独立 PR → 可独立测试） + +下面按“每个 PR 可单测/可集成测”为原则拆分。实际合并粒度可根据人力调整，但建议保持“每步都能验收”。 + +### Phase A：协议与内核基础设施（不引入 mount 行为变更或只做最小变更） + +**PR A1：引入 FUSE uapi 与协议编码/解码层（纯内核库）** +- 内容： + - 在 `kernel/src/filesystem/` 下新增 `fuse/` 模块：定义 `fuse_in_header/fuse_out_header`、opcode 常量、init/lookup/getattr/readdir/open/read/write 等结构体（参考 Linux `include/uapi/linux/fuse.h`）。 + - 提供安全的序列化/反序列化工具（对齐 64-bit 对齐要求，避免未对齐访问）。 +- 单测建议： + - 内核侧（或 host-side）结构体布局/大小断言； + - round-trip 编解码测试（给定样例字节流解析为结构体再编码一致）。 + +**PR A2：/dev/fuse 设备节点（devfs 注册 + 最小 file op）** +- 内容： + - 在 devfs 内注册字符设备 `fuse`，并保证 `/dev/fuse` 路径可用（必要时增加 symlink）。 + - `open()` 为每个 fd 初始化私有状态（建议新增 `FilePrivateData::FuseDev(...)`，内部持有 `Arc` 或 `Arc`）。 + - `read_at/write_at/poll/ioctl(close)` 的骨架先跑通（先不实现完整协议，只做队列读写框架）。 +- 单测/集成测建议： + - 用户态 smoke：`open("/dev/fuse")`，`poll()` 超时，向内核注入一条假 request（可通过调试接口或内核测试 hook），验证 poll 变为可读，read 能取到数据。 + - nonblock 行为：`O_NONBLOCK` 下 read 无数据返回 `EAGAIN`。 + +### Phase B：挂载闭环 + INIT 协商（做到“可演示”的里程碑） + +**PR B1：FuseFS 注册到 `FSMAKER`，实现 `mount -t fuse -o fd=...`** +- 内容： + - 新增 `FuseFS: MountableFileSystem`，注册 `"fuse"`（可选额外支持 `"fuse3"`，但建议从 `"fuse"` 起步）。 + - 解析 mount data（至少 `fd/rootmode/user_id/group_id`，参考 Linux `fs/fuse/inode.c` 与 `Documentation/filesystems/fuse.rst`）。 + - 通过 fd 取到 `/dev/fuse` 对应的 file/private_data，建立 `FuseConn` 与该挂载点绑定。 + - `SuperBlock.magic` 增加 `FUSE_SUPER_MAGIC`（Linux 常用值为 `0x65735546`，建议对齐），并为 `Magic` 增补该枚举项（`kernel/src/filesystem/vfs/mod.rs`）。 +- 集成测建议： + - 用户态：用最小 demo 程序完成 `open("/dev/fuse")` + `mount()`（即使 daemon 还没实现协议，也应能 mount 成功或在 INIT 未完成时明确返回错误）。 + +**PR B2：实现 INIT 请求生成与 init reply 处理（连接初始化状态机）** +- 内容： + - mount 后将 `FUSE_INIT` request 入队，daemon `read("/dev/fuse")` 能拿到 INIT。 + - 处理 init reply：记录 negotiated version、max_write/max_read、flags 等（先实现最小必要集合）。 + - INIT 前禁止其它请求或让其它请求阻塞，避免未初始化就访问。 +- 集成测建议（最重要的 MVP 里程碑测试）： + - 用户态 demo daemon：只实现 INIT（收到 INIT → 回 INIT reply → sleep），验证 mount 后内核 `fc.initialized==true`，并且 `/proc/mounts`（若已有）或 `statfs` 能正常返回。 + +### Phase C：最小可用 opcode（做到 `ls/stat/cat`） + +**PR C1：目录与路径遍历（LOOKUP/GETATTR/OPENDIR/READDIR/RELEASEDIR）** +- 内容： + - `IndexNode::find(name)` → `FUSE_LOOKUP(parent, name)` → 返回子 inode（nodeid/attr）。 + - `IndexNode::metadata()` → 触发或使用缓存的 `FUSE_GETATTR`。 + - `IndexNode::list()`：通过 `FUSE_OPENDIR + FUSE_READDIR` 拉取目录项并返回 `Vec`（MVP 允许“全量拉取+缓存”，但需写清楚局限）。 +- 集成测建议： + - 用户态 demo daemon 实现一个固定目录树（例如 `/hello.txt`、`/dir/a.txt`），在 DragonOS 内执行：`ls -l mountpoint`、`stat mountpoint/dir`。 + +**PR C2：文件读（OPEN/READ/RELEASE）** +- 内容： + - `open()` 返回 file handle（fh）写入 `FilePrivateData::FuseFile`； + - `read_at()` 生成 `FUSE_READ(nodeid, fh, offset, size)`，把 reply 数据拷回用户缓冲区。 +- 集成测建议： + - `cat mountpoint/hello.txt` 输出正确内容； + - `dd if=... bs=... count=...` 验证分块 read 与 offset 正确。 + +> 至此应达到“可演示”标准：一个用户态 daemon 在 DragonOS 内运行，完成 mount 并提供可访问文件。 + +### Phase D：写与创建（更接近可用） + +**PR D1：创建/删除/重命名（CREATE/MKDIR/UNLINK/RMDIR/RENAME）** +- 集成测建议： + - `mkdir`, `touch`, `rm`, `mv` 在挂载点上工作（可以只支持最小集合，逐步扩展）。 + +**PR D2：写与属性修改（WRITE/SETATTR/FSYNC/FLUSH）** +- 集成测建议： + - `echo hi > file`、`truncate -s`、`chmod/chown`（视 DragonOS 用户态工具链而定）。 + +### Phase E：Linux 语义与生态兼容（逐步接入 libfuse/fusermount） + +**PR E1：权限语义对齐（default_permissions / allow_other / mount owner 限制）** +- 关键点： + - DragonOS 的权限检查发生在 VFS 路径遍历与 open 等处；需要一个“按文件系统/挂载选项控制”的开关： + - `default_permissions`：按 mode 做内核侧权限裁决； + - 未开启时：尽量让访问透传给 daemon（更接近 Linux FUSE 默认行为）。 + - “默认仅 mount owner 可访问”与 `allow_other` 的安全限制，需要与 `Cred`/capability 结合设计。 +- 测试建议： + - 不同 uid/gid 下访问同一挂载点，行为符合预期。 + +**PR E2：`FUSE_DEV_IOC_CLONE` 与多线程（libfuse 常用路径）** +- 测试建议： + - 单线程模式 `-s`（不依赖 clone）先跑通，再开多线程。 + +**PR E3：提供用户态最小工具链** +- 方向 1：先把 DragonOS 的 demo daemon 做成“低层协议实现”，作为持续回归测试。 +- 方向 2：移植/引入 `libfuse3 + fusermount3`，逐步跑通现成 FUSE 文件系统（如 `sshfs`）。 +- 测试建议： + - `libfuse` 官方 example（hello/passthrough）的分步跑通清单。 + +--- + +## 3. 每个阶段“可以单独测试”的建议清单 + +为了避免“大工程最后才发现不通”，建议把测试分三层： + +### 3.1 设备层（/dev/fuse）测试 +- open/close：多次 open 是否产生独立连接或独立 dev state（按设计决定，但要可预测）。 +- poll/epoll：队列空/非空/断连时返回事件是否正确。 +- 阻塞 read：可被信号打断（返回 `ERESTARTSYS` 或 DragonOS 约定的等价错误）。 +- write reply：unique 不存在/重复 reply 的错误处理。 + +### 3.2 协议层测试 +- INIT：版本协商、feature flags 记录、max_read/max_write 限制是否生效。 +- LOOKUP/GETATTR：inode 类型（dir/file/symlink）与 mode 位语义。 +- READDIR：目录项编码解析（`fuse_dirent`）与 offset 行为（即使 MVP 做全量拉取也要保证不会重复/漏项）。 + +### 3.3 VFS 集成测试 +- `ls -l`/`stat`/`cat`（MVP） +- `mkdir/touch/rm/mv`（写路径阶段） +- `umount`：daemon 存活/daemon 已死两种情况下都不会卡住；挂载点清理正确。 + +--- + +## 4. 最终成品如何演示（建议的“可复制演示脚本”） + +建议把演示分成两档：**最小可演示**与**生态兼容演示**。 + +### 4.1 最小可演示（强烈建议优先做） + +**演示目标**：在 DragonOS 里运行一个 `fuse_demo`（用户态 daemon），挂载到 `/mnt/fuse`，展示目录与文件读写。 + +建议的演示流程（单终端也能完成）： + +1. 创建挂载点：`mkdir -p /mnt/fuse` +2. 启动 daemon（前台或后台）：`/bin/fuse_demo /mnt/fuse &` +3. 展示读路径： + - `ls -l /mnt/fuse` + - `cat /mnt/fuse/hello.txt` +4. 若已支持写路径，再展示： + - `echo hi > /mnt/fuse/new.txt` + - `cat /mnt/fuse/new.txt` +5. 卸载：`umount /mnt/fuse`（或 `umount2` 对应的用户态命令） + +**验收标准（建议写入 CI/回归脚本）**： +- `mount()` 成功并完成 INIT； +- `ls/stat/cat` 全部成功； +- daemon 被 kill 后，内核访问不会永久阻塞（应快速失败并可 umount）。 + +### 4.2 生态兼容演示（后续阶段） + +当 `libfuse3 + fusermount3` 跑通后，可以用更“直观”的演示： + +- 跑 `libfuse` 官方 hello/passthrough 示例； +- 跑 `sshfs`（如果 DragonOS 网络栈与 openssh/ dropbear 可用）； +- 或跑 `rclone mount` 等典型 FUSE 应用（取决于用户态生态与依赖）。 + +--- + +## 5. 风险点与关键决策（需要在实施前明确） + +1) **DragonOS 的 `IndexNode::list()` 是“全量目录项列表”接口** +FUSE 原生是流式 `READDIR`（带 offset），大目录会导致内存/性能问题。 +路线建议： +- MVP：先在 FUSE inode 内部做“分页拉取→拼成 Vec→缓存”跑通； +- 可用版/生产版：推动 VFS 增加“流式 readdir”接口，减少一次性全量拉取。 + +2) **权限语义：DragonOS 当前在路径遍历阶段就检查目录执行权限** +Linux FUSE 在 `default_permissions` 关闭时倾向把访问控制交给 daemon。 +要对齐语义，可能需要在 VFS 权限检查处引入“按文件系统/挂载选项”的可配置策略（这可能是跨模块的改动，应单独 PR、单独评审）。 + +3) **用户态生态的分阶段策略** +建议先用自研 `fuse_demo` 打通内核闭环并做回归，再考虑移植 libfuse/fusermount；否则调试成本会很高且难以定位问题在内核还是用户库。 + +--- + +## 6. 建议的 Roadmap 里程碑（便于汇报/追踪） + +- M0：PR A1+A2 合并（有 /dev/fuse 与协议骨架） +- M1：PR B1+B2 合并（mount(fd=) + INIT 协商跑通） +- M2：PR C1+C2 合并（`ls/stat/cat` 可演示） +- M3：PR D1+D2 合并（基础写路径可用） +- M4：PR E1 合并（权限语义对齐，安全模型清晰） +- M5：PR E2+E3 合并（libfuse/fusermount/生态演示） + diff --git a/TODO_FUSE_PHASE_AB.md b/TODO_FUSE_PHASE_AB.md new file mode 100644 index 0000000000..2dc7b286be --- /dev/null +++ b/TODO_FUSE_PHASE_AB.md @@ -0,0 +1,49 @@ +# TODO：实现 Phase A + Phase B（FUSE 基础设施 + mount/INIT 闭环） + +> 范围：仅覆盖 `ROADMAP_FUSE.md` 中 Phase A、Phase B（协议层 /dev/fuse / mount(fd=) / INIT 协商），并配套 `user/apps/c_unitest` 的单元测试与集成测试。 + +## Phase A（协议 + /dev/fuse） + +- [x] A1：引入 FUSE uapi 子集（结构体/常量/安全解析） + - 位置：`kernel/src/filesystem/fuse/protocol.rs` +- [x] A2：实现 `FuseConn`（请求队列 + unique + abort + INIT request 入队） + - 位置：`kernel/src/filesystem/fuse/conn.rs` +- [x] A3：实现 `/dev/fuse` 字符设备 + - [x] devfs 注册 `/dev/fuse` + - [x] open：初始化连接对象并写入 fd private data + - [x] read：从 pending 队列取 request（支持 nonblock 返回 `EAGAIN`） + - [x] write：写入 reply，匹配 unique，并驱动 INIT 完成 + - [x] poll/epoll：队列非空可读；断连返回 `POLLERR` + - 位置：`kernel/src/filesystem/fuse/dev.rs`、`kernel/src/filesystem/devfs/mod.rs` + +## Phase B（挂载闭环 + INIT 协商） + +- [x] B1：注册 `FuseFS` 到 `FSMAKER`（`-t fuse`） + - [x] 解析 mount data：`fd=,rootmode=,user_id=,group_id=` + - [x] 校验 fd 对应 `/dev/fuse` + - [x] 一个连接仅允许 mount 一次（重复 mount 返回 `EBUSY`） + - 位置：`kernel/src/filesystem/fuse/fs.rs` +- [x] B2：mount 成功后自动投递 `FUSE_INIT` request +- [x] B3：处理 `FUSE_INIT` reply 并将连接标记为 initialized + +## 测试（`user/apps/c_unitest`） + +- [x] 单元测试：`/dev/fuse` nonblock read + poll 空队列语义 + - `user/apps/c_unitest/test_fuse_dev.c` +- [x] 集成测试：`mount -t fuse -o fd=...` 触发 INIT，并能接受 INIT reply + - `user/apps/c_unitest/test_fuse_mount_init.c` + +## 反思/回归（执行到“完全确认正确”为止） + +- [x] 运行 `make user`，确认以上两个测试程序能编译进 rootfs +- [x ] 运行内核并执行： + - `/bin/test_fuse_dev` + - `/bin/test_fuse_mount_init` +- [x] 若失败：记录 errno/输出 → 回到对应模块修复 → 重复直到稳定通过 + +## 后续（不在 Phase A+B 范围内，仅记录） + +- [ ] `FUSE_DEV_IOC_CLONE`（libfuse 多线程路径） +- [ ] fusectl（`/sys/fs/fuse/connections`）与 abort 控制接口 +- [ ] 目录/文件 opcode（Phase C 起） + diff --git a/config/app-blocklist.toml b/config/app-blocklist.toml index 2de01e5e4e..a797182d7d 100644 --- a/config/app-blocklist.toml +++ b/config/app-blocklist.toml @@ -67,5 +67,7 @@ blocked_apps = [ { name = "NovaShell", reason = "工具链版本有问题，应为nightly-2025-8-10" }, { name = "test_ebpf_new", reason = "2025.11.17,aya上游发版有问题，导致ci过不了，暂时禁用" }, { name = "test_ebpf_tp", reason = "2025.11.17,aya上游发版有问题，导致ci过不了，暂时禁用" }, + { name = "runcell", reason = "依赖项依赖github，可能网络问题导致编不过" }, + ] diff --git a/kernel/src/filesystem/devfs/mod.rs b/kernel/src/filesystem/devfs/mod.rs index 0406420867..3d8c293e09 100644 --- a/kernel/src/filesystem/devfs/mod.rs +++ b/kernel/src/filesystem/devfs/mod.rs @@ -148,6 +148,7 @@ impl DevFS { /// @brief 注册系统内部自带的设备 fn register_bultinin_device(&self) { + use crate::filesystem::fuse::dev::LockedFuseDevInode; use null_dev::LockedNullInode; use random_dev::LockedRandomInode; use zero_dev::LockedZeroInode; @@ -161,6 +162,9 @@ impl DevFS { dev_root .add_dev("random", LockedRandomInode::new()) .expect("DevFS: Failed to register /dev/random"); + dev_root + .add_dev("fuse", LockedFuseDevInode::new()) + .expect("DevFS: Failed to register /dev/fuse"); } /// @brief 在devfs内注册设备 diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs new file mode 100644 index 0000000000..c62ae3e46f --- /dev/null +++ b/kernel/src/filesystem/fuse/conn.rs @@ -0,0 +1,278 @@ +use alloc::{ + collections::{BTreeMap, VecDeque}, + sync::Arc, + vec::Vec, +}; +use core::sync::atomic::{AtomicU64, Ordering}; + +use system_error::SystemError; + +use crate::{ + filesystem::epoll::{ + event_poll::EventPoll, event_poll::LockedEPItemLinkedList, EPollEventType, EPollItem, + }, + libs::{mutex::Mutex, wait_queue::WaitQueue}, +}; + +use super::protocol::{ + fuse_pack_struct, fuse_read_struct, FuseInHeader, FuseInitIn, FuseInitOut, FuseOutHeader, + FUSE_INIT, FUSE_KERNEL_MINOR_VERSION, FUSE_KERNEL_VERSION, +}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum FuseReqKind { + Init, +} + +#[derive(Debug)] +pub struct FuseRequest { + pub unique: u64, + pub kind: FuseReqKind, + pub bytes: Vec, +} + +#[derive(Debug)] +struct FuseConnInner { + connected: bool, + mounted: bool, + initialized: bool, + pending: VecDeque>, + processing: BTreeMap, +} + +/// FUSE connection object (roughly equivalent to Linux `struct fuse_conn`). +#[derive(Debug)] +pub struct FuseConn { + inner: Mutex, + next_unique: AtomicU64, + read_wait: WaitQueue, + epitems: LockedEPItemLinkedList, +} + +impl FuseConn { + pub fn new() -> Arc { + Arc::new(Self { + inner: Mutex::new(FuseConnInner { + connected: true, + mounted: false, + initialized: false, + pending: VecDeque::new(), + processing: BTreeMap::new(), + }), + // Use non-zero unique, keep even IDs for "ordinary" requests as Linux does. + next_unique: AtomicU64::new(2), + read_wait: WaitQueue::default(), + epitems: LockedEPItemLinkedList::default(), + }) + } + + pub fn is_mounted(&self) -> bool { + self.inner.lock().mounted + } + + pub fn mark_mounted(&self) -> Result<(), SystemError> { + let mut g = self.inner.lock(); + if !g.connected { + return Err(SystemError::ENOTCONN); + } + if g.mounted { + // Linux 6.6: mounting with an already-used /dev/fuse fd fails (-EINVAL). + return Err(SystemError::EINVAL); + } + g.mounted = true; + Ok(()) + } + + pub fn is_initialized(&self) -> bool { + self.inner.lock().initialized + } + + fn alloc_unique(&self) -> u64 { + self.next_unique.fetch_add(2, Ordering::Relaxed) + } + + pub fn enqueue_init(&self) -> Result<(), SystemError> { + let unique = self.alloc_unique(); + + let hdr = FuseInHeader { + len: (core::mem::size_of::() + core::mem::size_of::()) as u32, + opcode: FUSE_INIT, + unique, + nodeid: 0, + uid: 0, + gid: 0, + pid: 0, + total_extlen: 0, + padding: 0, + }; + + let init_in = FuseInitIn { + major: FUSE_KERNEL_VERSION, + minor: FUSE_KERNEL_MINOR_VERSION, + max_readahead: 0, + flags: 0, + flags2: 0, + unused: [0; 11], + }; + + let mut bytes = Vec::with_capacity(hdr.len as usize); + bytes.extend_from_slice(fuse_pack_struct(&hdr)); + bytes.extend_from_slice(fuse_pack_struct(&init_in)); + + let req = Arc::new(FuseRequest { + unique, + kind: FuseReqKind::Init, + bytes, + }); + + { + let mut g = self.inner.lock(); + if !g.connected { + return Err(SystemError::ENOTCONN); + } + g.pending.push_back(req.clone()); + g.processing.insert(unique, FuseReqKind::Init); + } + + self.read_wait.wakeup(None); + let _ = EventPoll::wakeup_epoll( + &self.epitems, + EPollEventType::EPOLLIN | EPollEventType::EPOLLRDNORM, + ); + Ok(()) + } + + pub fn abort(&self) { + { + let mut g = self.inner.lock(); + g.connected = false; + } + self.read_wait.wakeup(None); + let _ = EventPoll::wakeup_epoll( + &self.epitems, + EPollEventType::EPOLLERR | EPollEventType::EPOLLHUP, + ); + } + + pub fn poll_mask(&self, have_pending: bool) -> EPollEventType { + let mut events = EPollEventType::EPOLLOUT | EPollEventType::EPOLLWRNORM; + let g = self.inner.lock(); + if !g.connected { + return EPollEventType::EPOLLERR; + } + if have_pending { + events |= EPollEventType::EPOLLIN | EPollEventType::EPOLLRDNORM; + } + events + } + + pub fn poll(&self) -> EPollEventType { + let g = self.inner.lock(); + let have_pending = !g.pending.is_empty(); + drop(g); + self.poll_mask(have_pending) + } + + pub fn add_epitem(&self, epitem: Arc) -> Result<(), SystemError> { + self.epitems.lock().push_back(epitem); + Ok(()) + } + + pub fn remove_epitem(&self, epitem: &Arc) -> Result<(), SystemError> { + let mut guard = self.epitems.lock(); + let len = guard.len(); + guard.retain(|x| !Arc::ptr_eq(x, epitem)); + if len != guard.len() { + return Ok(()); + } + Err(SystemError::ENOENT) + } + + pub fn read_request(&self, nonblock: bool, out: &mut [u8]) -> Result { + // Linux: if O_NONBLOCK, return EAGAIN. + + let req = if nonblock { + let mut g = self.inner.lock(); + if !g.connected { + return Err(SystemError::ENOTCONN); + } + g.pending + .pop_front() + .ok_or(SystemError::EAGAIN_OR_EWOULDBLOCK)? + } else { + self.read_wait.wait_until_interruptible(|| { + let mut g = self.inner.lock(); + if !g.connected { + return Some(Err(SystemError::ENOTCONN)); + } + g.pending.pop_front().map(Ok) + })?? + }; + + if out.len() < req.bytes.len() { + // Put it back and report EINVAL: user must provide a sufficiently large buffer. + let mut g = self.inner.lock(); + if g.connected { + g.pending.push_front(req); + } + return Err(SystemError::EINVAL); + } + + out[..req.bytes.len()].copy_from_slice(&req.bytes); + Ok(req.bytes.len()) + } + + pub fn write_reply(&self, data: &[u8]) -> Result { + if data.len() < core::mem::size_of::() { + return Err(SystemError::EINVAL); + } + + let out_hdr: FuseOutHeader = fuse_read_struct(data)?; + if out_hdr.len as usize != data.len() { + return Err(SystemError::EINVAL); + } + + let kind = { + let mut g = self.inner.lock(); + if !g.connected { + return Err(SystemError::ENOTCONN); + } + match g.processing.remove(&out_hdr.unique) { + Some(k) => k, + None => return Err(SystemError::EINVAL), + } + }; + + if out_hdr.error != 0 { + // Any init-stage error aborts the connection. + self.abort(); + return Err(SystemError::EINVAL); + } + + match kind { + FuseReqKind::Init => { + let payload = &data[core::mem::size_of::()..]; + let init_out: FuseInitOut = fuse_read_struct(payload)?; + if init_out.major != FUSE_KERNEL_VERSION { + self.abort(); + return Err(SystemError::EINVAL); + } + + // Negotiate minor version: use the smaller one. + let negotiated_minor = core::cmp::min(init_out.minor, FUSE_KERNEL_MINOR_VERSION); + + let mut g = self.inner.lock(); + if !g.connected { + return Err(SystemError::ENOTCONN); + } + g.initialized = true; + drop(g); + + // For now we only record "initialized"; other negotiated values can be added later. + let _ = negotiated_minor; + } + } + + Ok(data.len()) + } +} diff --git a/kernel/src/filesystem/fuse/dev.rs b/kernel/src/filesystem/fuse/dev.rs new file mode 100644 index 0000000000..aedd3a1aa3 --- /dev/null +++ b/kernel/src/filesystem/fuse/dev.rs @@ -0,0 +1,247 @@ +use alloc::{ + string::String, + sync::{Arc, Weak}, + vec::Vec, +}; + +use system_error::SystemError; + +use crate::{ + driver::base::device::device_number::DeviceNumber, + filesystem::{ + devfs::{DevFS, DeviceINode, LockedDevFSInode}, + epoll::EPollItem, + vfs::{ + file::FileFlags, file::FuseDevPrivateData, vcore::generate_inode_id, FilePrivateData, + FileSystem, FileType, IndexNode, InodeFlags, InodeMode, Metadata, PollableInode, + }, + }, + libs::mutex::{Mutex, MutexGuard}, + time::PosixTimeSpec, +}; + +use super::conn::FuseConn; + +#[derive(Debug)] +pub struct FuseDevInode { + self_ref: Weak, + fs: Weak, + parent: Weak, + metadata: Metadata, +} + +#[derive(Debug)] +pub struct LockedFuseDevInode(Mutex); + +impl LockedFuseDevInode { + pub fn new() -> Arc { + let inode = FuseDevInode { + self_ref: Weak::default(), + fs: Weak::default(), + parent: Weak::default(), + metadata: Metadata { + dev_id: 1, + inode_id: generate_inode_id(), + size: 0, + blk_size: 0, + blocks: 0, + atime: PosixTimeSpec::default(), + mtime: PosixTimeSpec::default(), + ctime: PosixTimeSpec::default(), + btime: PosixTimeSpec::default(), + file_type: FileType::CharDevice, + mode: InodeMode::from_bits_truncate(0o666), + flags: InodeFlags::empty(), + nlinks: 1, + uid: 0, + gid: 0, + raw_dev: DeviceNumber::default(), + }, + }; + let result = Arc::new(LockedFuseDevInode(Mutex::new(inode))); + result.0.lock().self_ref = Arc::downgrade(&result); + result + } +} + +impl DeviceINode for LockedFuseDevInode { + fn set_fs(&self, fs: Weak) { + self.0.lock().fs = fs; + } + + fn set_parent(&self, parent: Weak) { + self.0.lock().parent = parent; + } +} + +impl PollableInode for LockedFuseDevInode { + fn poll(&self, private_data: &FilePrivateData) -> Result { + let FilePrivateData::FuseDev(p) = private_data else { + return Err(SystemError::EINVAL); + }; + let conn = p + .conn + .clone() + .downcast::() + .map_err(|_| SystemError::EINVAL)?; + Ok(conn.poll().bits() as usize) + } + + fn add_epitem( + &self, + epitem: Arc, + private_data: &FilePrivateData, + ) -> Result<(), SystemError> { + let FilePrivateData::FuseDev(p) = private_data else { + return Err(SystemError::EINVAL); + }; + let conn = p + .conn + .clone() + .downcast::() + .map_err(|_| SystemError::EINVAL)?; + conn.add_epitem(epitem) + } + + fn remove_epitem( + &self, + epitem: &Arc, + private_data: &FilePrivateData, + ) -> Result<(), SystemError> { + let FilePrivateData::FuseDev(p) = private_data else { + return Err(SystemError::EINVAL); + }; + let conn = p + .conn + .clone() + .downcast::() + .map_err(|_| SystemError::EINVAL)?; + conn.remove_epitem(epitem) + } +} + +impl IndexNode for LockedFuseDevInode { + fn is_stream(&self) -> bool { + true + } + + fn open( + &self, + mut data: MutexGuard, + flags: &FileFlags, + ) -> Result<(), SystemError> { + let nonblock = flags.contains(FileFlags::O_NONBLOCK); + let conn = FuseConn::new(); + let conn_any: Arc = conn; + *data = FilePrivateData::FuseDev(FuseDevPrivateData { + conn: conn_any, + nonblock, + }); + Ok(()) + } + + fn close(&self, data: MutexGuard) -> Result<(), SystemError> { + if let FilePrivateData::FuseDev(p) = &*data { + if let Ok(conn) = p.conn.clone().downcast::() { + conn.abort(); + } + } + Ok(()) + } + + fn read_at( + &self, + _offset: usize, + len: usize, + buf: &mut [u8], + data: MutexGuard, + ) -> Result { + if buf.len() < len { + return Err(SystemError::EINVAL); + } + let FilePrivateData::FuseDev(p) = &*data else { + return Err(SystemError::EINVAL); + }; + let conn = p + .conn + .clone() + .downcast::() + .map_err(|_| SystemError::EINVAL)?; + conn.read_request(p.nonblock, &mut buf[..len]) + } + + fn write_at( + &self, + _offset: usize, + len: usize, + buf: &[u8], + data: MutexGuard, + ) -> Result { + if buf.len() < len { + return Err(SystemError::EINVAL); + } + let FilePrivateData::FuseDev(p) = &*data else { + return Err(SystemError::EINVAL); + }; + let conn = p + .conn + .clone() + .downcast::() + .map_err(|_| SystemError::EINVAL)?; + conn.write_reply(&buf[..len]) + } + + fn metadata(&self) -> Result { + Ok(self.0.lock().metadata.clone()) + } + + fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> { + let mut inode = self.0.lock(); + inode.metadata.atime = metadata.atime; + inode.metadata.mtime = metadata.mtime; + inode.metadata.ctime = metadata.ctime; + inode.metadata.btime = metadata.btime; + inode.metadata.mode = metadata.mode; + inode.metadata.uid = metadata.uid; + inode.metadata.gid = metadata.gid; + Ok(()) + } + + fn fs(&self) -> Arc { + self.0.lock().fs.upgrade().unwrap() + } + + fn as_any_ref(&self) -> &dyn core::any::Any { + self + } + + fn list(&self) -> Result, SystemError> { + Err(SystemError::EINVAL) + } + + fn parent(&self) -> Result, SystemError> { + self.0 + .lock() + .parent + .upgrade() + .map(|p| p as Arc) + .ok_or(SystemError::ENOENT) + } + + fn as_pollable_inode(&self) -> Result<&dyn PollableInode, SystemError> { + Ok(self) + } + + fn ioctl( + &self, + _cmd: u32, + _data: usize, + _private_data: &FilePrivateData, + ) -> Result { + Err(SystemError::ENOTTY) + } + + fn absolute_path(&self) -> Result { + Ok(String::from("/dev/fuse")) + } +} diff --git a/kernel/src/filesystem/fuse/fs.rs b/kernel/src/filesystem/fuse/fs.rs new file mode 100644 index 0000000000..2e58a05628 --- /dev/null +++ b/kernel/src/filesystem/fuse/fs.rs @@ -0,0 +1,284 @@ +use alloc::{string::String, sync::Arc, vec::Vec}; + +use system_error::SystemError; + +use crate::{ + filesystem::vfs::{ + vcore::generate_inode_id, FileSystem, FileSystemMakerData, FileType, FsInfo, IndexNode, + InodeFlags, InodeMode, Magic, Metadata, MountableFileSystem, SuperBlock, FSMAKER, + }, + libs::mutex::{Mutex, MutexGuard}, + process::ProcessManager, + register_mountable_fs, + time::PosixTimeSpec, +}; + +use linkme::distributed_slice; + +use super::conn::FuseConn; + +#[derive(Debug)] +pub struct FuseMountData { + pub fd: i32, + pub rootmode: u32, + pub user_id: u32, + pub group_id: u32, + pub conn: Arc, +} + +impl FileSystemMakerData for FuseMountData { + fn as_any(&self) -> &dyn core::any::Any { + self + } +} + +#[derive(Debug)] +pub struct FuseFS { + root: Arc, + super_block: SuperBlock, + conn: Arc, + #[allow(dead_code)] + owner_uid: u32, + #[allow(dead_code)] + owner_gid: u32, +} + +impl FuseFS { + fn parse_mount_options(raw: Option<&str>) -> Result<(i32, u32, u32, u32), SystemError> { + let mut fd: Option = None; + let mut rootmode: Option = None; + let mut user_id: Option = None; + let mut group_id: Option = None; + + let s = raw.unwrap_or(""); + for part in s.split(',') { + let part = part.trim(); + if part.is_empty() { + continue; + } + let (k, v) = match part.split_once('=') { + Some((k, v)) => (k.trim(), v.trim()), + None => (part, ""), + }; + match k { + "fd" => { + fd = Some(v.parse::().map_err(|_| SystemError::EINVAL)?); + } + "rootmode" => { + // Linux expects octal representation. + rootmode = Some(u32::from_str_radix(v, 8).map_err(|_| SystemError::EINVAL)?); + } + "user_id" => { + user_id = Some(v.parse::().map_err(|_| SystemError::EINVAL)?); + } + "group_id" => { + group_id = Some(v.parse::().map_err(|_| SystemError::EINVAL)?); + } + _ => {} + } + } + + let fd = fd.ok_or(SystemError::EINVAL)?; + let pcb = ProcessManager::current_pcb(); + let cred = pcb.cred(); + let user_id = user_id.unwrap_or(cred.fsuid.data() as u32); + let group_id = group_id.unwrap_or(cred.fsgid.data() as u32); + // Default root mode: directory 0755 (with type bit). + let rootmode = rootmode.unwrap_or(0o040755); + + Ok((fd, rootmode, user_id, group_id)) + } +} + +impl MountableFileSystem for FuseFS { + fn make_mount_data( + raw_data: Option<&str>, + _source: &str, + ) -> Result>, SystemError> { + let (fd, rootmode, user_id, group_id) = Self::parse_mount_options(raw_data)?; + + let file = ProcessManager::current_pcb() + .fd_table() + .read() + .get_file_by_fd(fd) + .ok_or(SystemError::EBADF)?; + + let conn = { + let pdata = file.private_data.lock(); + match &*pdata { + crate::filesystem::vfs::FilePrivateData::FuseDev(p) => p + .conn + .clone() + .downcast::() + .map_err(|_| SystemError::EINVAL)?, + _ => return Err(SystemError::EINVAL), + } + }; + + conn.mark_mounted()?; + + Ok(Some(Arc::new(FuseMountData { + fd, + rootmode, + user_id, + group_id, + conn, + }))) + } + + fn make_fs( + data: Option<&dyn FileSystemMakerData>, + ) -> Result, SystemError> { + let mount_data = data + .and_then(|d| d.as_any().downcast_ref::()) + .ok_or(SystemError::EINVAL)?; + + let super_block = SuperBlock::new(Magic::FUSE_MAGIC, 4096, 255); + + let root_md = Metadata { + dev_id: 0, + inode_id: generate_inode_id(), + size: 0, + blk_size: 0, + blocks: 0, + atime: PosixTimeSpec::default(), + mtime: PosixTimeSpec::default(), + ctime: PosixTimeSpec::default(), + btime: PosixTimeSpec::default(), + file_type: FileType::Dir, + mode: InodeMode::from_bits_truncate(mount_data.rootmode), + flags: InodeFlags::empty(), + nlinks: 2, + uid: mount_data.user_id as usize, + gid: mount_data.group_id as usize, + raw_dev: crate::driver::base::device::device_number::DeviceNumber::default(), + }; + + let conn = mount_data.conn.clone(); + + let fs = Arc::new_cyclic(|weak_fs| { + let root = Arc::new_cyclic(|weak_root| FuseRootInode { + self_ref: weak_root.clone(), + fs: weak_fs.clone(), + metadata: Mutex::new(root_md), + }); + FuseFS { + root, + super_block, + conn: conn.clone(), + owner_uid: mount_data.user_id, + owner_gid: mount_data.group_id, + } + }); + + conn.enqueue_init()?; + Ok(fs) + } +} + +register_mountable_fs!(FuseFS, FUSEFSMAKER, "fuse"); + +impl FileSystem for FuseFS { + fn root_inode(&self) -> Arc { + self.root.clone() + } + + fn info(&self) -> FsInfo { + FsInfo { + blk_dev_id: 0, + max_name_len: 255, + } + } + + fn as_any_ref(&self) -> &dyn core::any::Any { + self + } + + fn name(&self) -> &str { + "fuse" + } + + fn super_block(&self) -> SuperBlock { + self.super_block.clone() + } +} + +#[derive(Debug)] +pub struct FuseRootInode { + self_ref: alloc::sync::Weak, + fs: alloc::sync::Weak, + metadata: Mutex, +} + +impl IndexNode for FuseRootInode { + fn as_any_ref(&self) -> &dyn core::any::Any { + self + } + + fn open( + &self, + _data: MutexGuard, + _flags: &crate::filesystem::vfs::file::FileFlags, + ) -> Result<(), SystemError> { + Ok(()) + } + + fn close( + &self, + _data: MutexGuard, + ) -> Result<(), SystemError> { + Ok(()) + } + + fn read_at( + &self, + _offset: usize, + _len: usize, + _buf: &mut [u8], + _data: MutexGuard, + ) -> Result { + Err(SystemError::EISDIR) + } + + fn write_at( + &self, + _offset: usize, + _len: usize, + _buf: &[u8], + _data: MutexGuard, + ) -> Result { + Err(SystemError::EISDIR) + } + + fn metadata(&self) -> Result { + Ok(self.metadata.lock().clone()) + } + + fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> { + *self.metadata.lock() = metadata.clone(); + Ok(()) + } + + fn fs(&self) -> Arc { + self.fs.upgrade().unwrap() + } + + fn list(&self) -> Result, SystemError> { + Ok(Vec::new()) + } + + fn find(&self, name: &str) -> Result, SystemError> { + match name { + "." | ".." => Ok(self.self_ref.upgrade().ok_or(SystemError::ENOENT)?), + _ => Err(SystemError::ENOENT), + } + } + + fn parent(&self) -> Result, SystemError> { + Ok(self.self_ref.upgrade().ok_or(SystemError::ENOENT)?) + } + + fn absolute_path(&self) -> Result { + Ok(String::from("/")) + } +} diff --git a/kernel/src/filesystem/fuse/mod.rs b/kernel/src/filesystem/fuse/mod.rs new file mode 100644 index 0000000000..75e3d23537 --- /dev/null +++ b/kernel/src/filesystem/fuse/mod.rs @@ -0,0 +1,4 @@ +pub mod conn; +pub mod dev; +pub mod fs; +pub mod protocol; diff --git a/kernel/src/filesystem/fuse/protocol.rs b/kernel/src/filesystem/fuse/protocol.rs new file mode 100644 index 0000000000..5c108e5e3e --- /dev/null +++ b/kernel/src/filesystem/fuse/protocol.rs @@ -0,0 +1,80 @@ +//! FUSE protocol structures (Linux 6.6 uapi compatible subset). +//! +//! Reference: linux-6.6.21 `include/uapi/linux/fuse.h`. + +use core::mem::size_of; + +use system_error::SystemError; + +pub const FUSE_KERNEL_VERSION: u32 = 7; +pub const FUSE_KERNEL_MINOR_VERSION: u32 = 39; + +/// The read buffer is required to be at least 8k on Linux. +pub const FUSE_MIN_READ_BUFFER: usize = 8192; + +pub const FUSE_ROOT_ID: u64 = 1; + +pub const FUSE_INIT: u32 = 26; + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseInHeader { + pub len: u32, + pub opcode: u32, + pub unique: u64, + pub nodeid: u64, + pub uid: u32, + pub gid: u32, + pub pid: u32, + pub total_extlen: u16, + pub padding: u16, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseOutHeader { + pub len: u32, + pub error: i32, + pub unique: u64, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseInitIn { + pub major: u32, + pub minor: u32, + pub max_readahead: u32, + pub flags: u32, + pub flags2: u32, + pub unused: [u32; 11], +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseInitOut { + pub major: u32, + pub minor: u32, + pub max_readahead: u32, + pub flags: u32, + pub max_background: u16, + pub congestion_threshold: u16, + pub max_write: u32, + pub time_gran: u32, + pub max_pages: u16, + pub map_alignment: u16, + pub flags2: u32, + pub unused: [u32; 7], +} + +pub fn fuse_pack_struct(v: &T) -> &[u8] { + unsafe { core::slice::from_raw_parts((v as *const T).cast::(), size_of::()) } +} + +pub fn fuse_read_struct(buf: &[u8]) -> Result { + if buf.len() < size_of::() { + return Err(SystemError::EINVAL); + } + // FUSE messages are packed and 64-bit aligned, but userspace may still + // pass unaligned buffers; use unaligned reads for robustness. + Ok(unsafe { core::ptr::read_unaligned(buf.as_ptr().cast::()) }) +} diff --git a/kernel/src/filesystem/mod.rs b/kernel/src/filesystem/mod.rs index 8170cf3e1c..6b42846690 100644 --- a/kernel/src/filesystem/mod.rs +++ b/kernel/src/filesystem/mod.rs @@ -5,6 +5,7 @@ pub mod eventfd; pub mod ext4; pub mod fat; pub mod fs; +pub mod fuse; pub mod kernfs; pub mod mbr; pub mod overlayfs; diff --git a/kernel/src/filesystem/vfs/file.rs b/kernel/src/filesystem/vfs/file.rs index 70060f6c94..efbd8289a0 100644 --- a/kernel/src/filesystem/vfs/file.rs +++ b/kernel/src/filesystem/vfs/file.rs @@ -1,4 +1,5 @@ use core::{ + any::Any, fmt, sync::atomic::{AtomicBool, AtomicUsize, Ordering}, }; @@ -126,10 +127,23 @@ pub enum FilePrivateData { Namespace(NamespaceFilePrivateData), /// Socket file created by socket syscalls (not by VFS open(2)). SocketCreate, + /// /dev/fuse file private data (stores an opaque connection object). + FuseDev(FuseDevPrivateData), /// 不需要文件私有信息 Unused, } +/// Private data for `/dev/fuse`. +/// +/// Note: to avoid cyclic dependencies between `vfs` and `filesystem::fuse`, +/// the connection object is stored as an opaque `Arc`, +/// and is downcasted by the FUSE implementation as needed. +#[derive(Debug, Clone)] +pub struct FuseDevPrivateData { + pub conn: Arc, + pub nonblock: bool, +} + impl Default for FilePrivateData { fn default() -> Self { return Self::Unused; diff --git a/kernel/src/filesystem/vfs/mod.rs b/kernel/src/filesystem/vfs/mod.rs index 7fd79e2516..5ec5a93b43 100644 --- a/kernel/src/filesystem/vfs/mod.rs +++ b/kernel/src/filesystem/vfs/mod.rs @@ -1274,6 +1274,7 @@ bitflags! { const DEVFS_MAGIC = 0x1373; const FAT_MAGIC = 0xf2f52011; const EXT4_MAGIC = 0xef53; + const FUSE_MAGIC = 0x65735546; const TMPFS_MAGIC = 0x01021994; const KER_MAGIC = 0x3153464b; const PROC_MAGIC = 0x9fa0; diff --git a/kernel/src/filesystem/vfs/syscall/sys_mount.rs b/kernel/src/filesystem/vfs/syscall/sys_mount.rs index abfda513be..d23021489d 100644 --- a/kernel/src/filesystem/vfs/syscall/sys_mount.rs +++ b/kernel/src/filesystem/vfs/syscall/sys_mount.rs @@ -268,7 +268,7 @@ fn do_new_mount( let fs_type_str = filesystemtype.ok_or(SystemError::EINVAL)?; let source = source.ok_or(SystemError::EINVAL)?; let fs = produce_fs(&fs_type_str, data.as_deref(), &source).inspect_err(|e| { - log::error!("Failed to produce filesystem: {:?}", e); + log::warn!("Failed to produce filesystem: {:?}", e); })?; // 若目标是挂载点根，则尝试在其父目录挂载，避免 EBUSY 并与 Linux 叠加语义接近 diff --git a/user/apps/c_unitest/test_fuse_dev.c b/user/apps/c_unitest/test_fuse_dev.c new file mode 100644 index 0000000000..5d8229acef --- /dev/null +++ b/user/apps/c_unitest/test_fuse_dev.c @@ -0,0 +1,52 @@ +/** + * @file test_fuse_dev.c + * @brief Phase A unit test: /dev/fuse basic semantics (open/read nonblock) + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include + +static int test_nonblock_read_empty(void) { + int fd = open("/dev/fuse", O_RDWR | O_NONBLOCK); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + return -1; + } + + unsigned char buf[256]; + ssize_t n = read(fd, buf, sizeof(buf)); + if (n != -1 || (errno != EAGAIN && errno != EWOULDBLOCK)) { + printf("[FAIL] nonblock read empty: n=%zd errno=%d (%s)\n", n, errno, strerror(errno)); + close(fd); + return -1; + } + + struct pollfd pfd; + pfd.fd = fd; + pfd.events = POLLIN; + int pr = poll(&pfd, 1, 100 /*ms*/); + if (pr != 0) { + printf("[FAIL] poll empty expected timeout: pr=%d revents=%x errno=%d (%s)\n", + pr, pfd.revents, errno, strerror(errno)); + close(fd); + return -1; + } + + close(fd); + printf("[PASS] nonblock_read_empty\n"); + return 0; +} + +int main(void) { + if (test_nonblock_read_empty() != 0) { + return 1; + } + return 0; +} + diff --git a/user/apps/c_unitest/test_fuse_mount_init.c b/user/apps/c_unitest/test_fuse_mount_init.c new file mode 100644 index 0000000000..060422db58 --- /dev/null +++ b/user/apps/c_unitest/test_fuse_mount_init.c @@ -0,0 +1,226 @@ +/** + * @file test_fuse_mount_init.c + * @brief Phase B integration test: mount -t fuse -o fd=... triggers INIT and accepts init reply. + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef FUSE_INIT +#define FUSE_INIT 26 +#endif + +struct fuse_in_header { + uint32_t len; + uint32_t opcode; + uint64_t unique; + uint64_t nodeid; + uint32_t uid; + uint32_t gid; + uint32_t pid; + uint16_t total_extlen; + uint16_t padding; +}; + +struct fuse_out_header { + uint32_t len; + int32_t error; + uint64_t unique; +}; + +struct fuse_init_in { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; + uint32_t flags2; + uint32_t unused[11]; +}; + +struct fuse_init_out { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; + uint16_t max_background; + uint16_t congestion_threshold; + uint32_t max_write; + uint32_t time_gran; + uint16_t max_pages; + uint16_t map_alignment; + uint32_t flags2; + uint32_t unused[7]; +}; + +static int ensure_dir(const char *path) { + struct stat st; + if (stat(path, &st) == 0) { + if (S_ISDIR(st.st_mode)) { + return 0; + } + errno = ENOTDIR; + return -1; + } + return mkdir(path, 0755); +} + +static int wait_readable(int fd, int timeout_ms) { + struct pollfd pfd; + memset(&pfd, 0, sizeof(pfd)); + pfd.fd = fd; + pfd.events = POLLIN; + int pr = poll(&pfd, 1, timeout_ms); + if (pr < 0) { + return -1; + } + if (pr == 0) { + errno = ETIMEDOUT; + return -1; + } + if ((pfd.revents & POLLIN) == 0) { + errno = EIO; + return -1; + } + return 0; +} + +static int do_init_handshake(int fd) { + if (wait_readable(fd, 1000) != 0) { + printf("[FAIL] poll for INIT: %s (errno=%d)\n", strerror(errno), errno); + return -1; + } + + unsigned char buf[4096]; + ssize_t n = read(fd, buf, sizeof(buf)); + if (n < (ssize_t)(sizeof(struct fuse_in_header) + sizeof(struct fuse_init_in))) { + printf("[FAIL] read INIT too short: n=%zd errno=%d (%s)\n", n, errno, strerror(errno)); + return -1; + } + + struct fuse_in_header in_hdr; + memcpy(&in_hdr, buf, sizeof(in_hdr)); + if (in_hdr.opcode != FUSE_INIT) { + printf("[FAIL] expected FUSE_INIT opcode=%d got=%u\n", FUSE_INIT, in_hdr.opcode); + return -1; + } + if (in_hdr.len != (uint32_t)n) { + printf("[FAIL] header.len mismatch: hdr=%u read=%zd\n", in_hdr.len, n); + return -1; + } + + struct fuse_init_in init_in; + memcpy(&init_in, buf + sizeof(struct fuse_in_header), sizeof(init_in)); + if (init_in.major != 7) { + printf("[FAIL] init_in.major expected 7 got %u\n", init_in.major); + return -1; + } + + struct fuse_out_header out_hdr; + memset(&out_hdr, 0, sizeof(out_hdr)); + out_hdr.len = sizeof(struct fuse_out_header) + sizeof(struct fuse_init_out); + out_hdr.error = 0; + out_hdr.unique = in_hdr.unique; + + struct fuse_init_out init_out; + memset(&init_out, 0, sizeof(init_out)); + init_out.major = 7; + init_out.minor = 39; + init_out.max_readahead = 0; + init_out.flags = 0; + init_out.max_write = 4096; + + unsigned char reply[sizeof(out_hdr) + sizeof(init_out)]; + memcpy(reply, &out_hdr, sizeof(out_hdr)); + memcpy(reply + sizeof(out_hdr), &init_out, sizeof(init_out)); + + ssize_t wn = write(fd, reply, sizeof(reply)); + if (wn != (ssize_t)sizeof(reply)) { + printf("[FAIL] write INIT reply: wn=%zd errno=%d (%s)\n", wn, errno, strerror(errno)); + return -1; + } + + return 0; +} + +int main(void) { + const char *mp = "/tmp/test_fuse_mp"; + const char *mp2 = "/tmp/test_fuse_mp2"; + + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return 1; + } + if (ensure_dir(mp2) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp2, strerror(errno), errno); + return 1; + } + + int fd = open("/dev/fuse", O_RDWR | O_NONBLOCK); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + return 1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + close(fd); + return 1; + } + + if (do_init_handshake(fd) != 0) { + umount(mp); + close(fd); + return 1; + } + + /* After INIT reply, queue should be empty. Nonblock read should return EAGAIN. */ + unsigned char tmp[64]; + ssize_t rn = read(fd, tmp, sizeof(tmp)); + if (rn != -1 || (errno != EAGAIN && errno != EWOULDBLOCK)) { + printf("[FAIL] expected EAGAIN after init: rn=%zd errno=%d (%s)\n", rn, errno, strerror(errno)); + umount(mp); + close(fd); + return 1; + } + + /* + * Second mount with same fd should fail (connection already mounted). + * Use a different mountpoint to avoid any "mount-on-mountpoint-root" corner + * behavior from interfering with the check. + */ + if (mount("none", mp2, "fuse", 0, opts) == 0) { + printf("[FAIL] second mount with same fd unexpectedly succeeded\n"); + umount(mp); + umount(mp2); + close(fd); + return 1; + } + if (errno != EINVAL) { + printf("[FAIL] second mount expected EINVAL got errno=%d (%s)\n", errno, strerror(errno)); + umount(mp); + close(fd); + return 1; + } + printf("[INFO] second mount failed as expected: errno=%d (%s)\n", errno, strerror(errno)); + + umount(mp); + rmdir(mp); + rmdir(mp2); + close(fd); + printf("[PASS] fuse_mount_init\n"); + return 0; +} From 7445191ab70c587682ccac75c23a62a5b6661c28 Mon Sep 17 00:00:00 2001 From: longjin Date: Thu, 5 Feb 2026 14:35:37 +0800 Subject: [PATCH 02/16] phasec+d untest --- TODO_FUSE_PHASE_CD.md | 52 ++ kernel/src/filesystem/fuse/conn.rs | 252 +++++--- kernel/src/filesystem/fuse/dev.rs | 8 +- kernel/src/filesystem/fuse/fs.rs | 162 ++--- kernel/src/filesystem/fuse/inode.rs | 557 ++++++++++++++++ kernel/src/filesystem/fuse/mod.rs | 1 + kernel/src/filesystem/fuse/protocol.rs | 187 ++++++ kernel/src/filesystem/vfs/file.rs | 18 + user/apps/c_unitest/fuse_test_simplefs.h | 784 +++++++++++++++++++++++ user/apps/c_unitest/test_fuse_phase_c.c | 151 +++++ user/apps/c_unitest/test_fuse_phase_d.c | 159 +++++ 11 files changed, 2138 insertions(+), 193 deletions(-) create mode 100644 TODO_FUSE_PHASE_CD.md create mode 100644 kernel/src/filesystem/fuse/inode.rs create mode 100644 user/apps/c_unitest/fuse_test_simplefs.h create mode 100644 user/apps/c_unitest/test_fuse_phase_c.c create mode 100644 user/apps/c_unitest/test_fuse_phase_d.c diff --git a/TODO_FUSE_PHASE_CD.md b/TODO_FUSE_PHASE_CD.md new file mode 100644 index 0000000000..40606f3903 --- /dev/null +++ b/TODO_FUSE_PHASE_CD.md @@ -0,0 +1,52 @@ +# TODO：实现 Phase C + Phase D（FUSE VFS 核心操作 + 写路径/创建操作） + +> 范围：继续完成 `ROADMAP_FUSE.md` 的 Phase C、Phase D，并在 `user/apps/c_unitest` 下补齐对应单元/集成测试。 +> +> 注意：本 TODO 覆盖“可演示/可用”的核心路径，不涵盖 Phase E（权限安全模型、fusermount/libfuse、clone、多线程等）。 + +## Phase C：读路径（`ls/stat/cat`） + +- [x] C0：`FuseConn` 支持通用 request/reply（阻塞等待 + errno 透传） + - `kernel/src/filesystem/fuse/conn.rs` +- [x] C1：实现 FUSE inode（VFS → FUSE opcode 映射） + - `LOOKUP`：`IndexNode::find()` + - `GETATTR`：`IndexNode::metadata()` + - `OPENDIR/READDIR/RELEASEDIR`：`IndexNode::list()` + - `OPEN/READ/RELEASE`：`IndexNode::open/read_at/close` + - `kernel/src/filesystem/fuse/inode.rs` +- [x] C2：FuseFS 提供 node cache + root nodeid=1 + - `kernel/src/filesystem/fuse/fs.rs` +- [x] C3：扩展 FUSE 协议结构体/常量（最小子集） + - `kernel/src/filesystem/fuse/protocol.rs` + +## Phase D：写与创建（`touch/echo/mkdir/rm/mv/truncate`） + +- [x] D1：`MKNOD/MKDIR`：`IndexNode::create_with_data()` +- [x] D2：`UNLINK/RMDIR`：`IndexNode::unlink()/rmdir()` +- [x] D3：`RENAME`：`IndexNode::move_to()` +- [x] D4：`WRITE`：`IndexNode::write_at()`（依赖 `open()` 得到 fh） +- [x] D5：`SETATTR(size)`：`IndexNode::resize()`（覆盖 `ftruncate`） +- [x] D6：`SETATTR(mode/uid/gid/size)`：`IndexNode::set_metadata()`（最小实现，后续可按 valid 精化） + +## 测试（`user/apps/c_unitest`） + +### 单元测试（偏接口/行为） + +- [x] `test_fuse_phase_c`：daemon 提供只读树，验证 `readdir/stat/open/read` + - 文件：`user/apps/c_unitest/test_fuse_phase_c.c` +- [x] `test_fuse_phase_d`：daemon 提供可写树，验证 `create/write/ftruncate/rename/unlink/mkdir/rmdir` + - 文件：`user/apps/c_unitest/test_fuse_phase_d.c` + +### 集成回归（与 Phase A+B 组合） + +- [ ] 组合运行： + - `/bin/test_fuse_dev` + - `/bin/test_fuse_mount_init` + - `/bin/test_fuse_phase_c` + - `/bin/test_fuse_phase_d` + +## 反思/迭代（直到“完全确认正确”） + +- [ ] 每次失败都必须记录：触发的 opcode、返回 errno、以及用户态 daemon 收到的请求序列 +- [ ] 优先修根因：协议字段/长度/对齐、offset 语义、inode type/mode 映射、fd private data 生命周期 +- [ ] 对齐 Linux 6.6：错误码（如重复 mount 应返回 `EINVAL`）、阻塞语义（`EAGAIN`/poll）、release 行为 diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs index c62ae3e46f..533d4dbbfd 100644 --- a/kernel/src/filesystem/fuse/conn.rs +++ b/kernel/src/filesystem/fuse/conn.rs @@ -1,10 +1,7 @@ -use alloc::{ - collections::{BTreeMap, VecDeque}, - sync::Arc, - vec::Vec, -}; +use alloc::{collections::BTreeMap, collections::VecDeque, sync::Arc, vec::Vec}; use core::sync::atomic::{AtomicU64, Ordering}; +use num_traits::FromPrimitive; use system_error::SystemError; use crate::{ @@ -12,6 +9,7 @@ use crate::{ event_poll::EventPoll, event_poll::LockedEPItemLinkedList, EPollEventType, EPollItem, }, libs::{mutex::Mutex, wait_queue::WaitQueue}, + process::ProcessManager, }; use super::protocol::{ @@ -19,25 +17,56 @@ use super::protocol::{ FUSE_INIT, FUSE_KERNEL_MINOR_VERSION, FUSE_KERNEL_VERSION, }; -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum FuseReqKind { - Init, -} - #[derive(Debug)] pub struct FuseRequest { - pub unique: u64, - pub kind: FuseReqKind, pub bytes: Vec, } +#[derive(Debug)] +pub struct FusePendingState { + opcode: u32, + response: Mutex, SystemError>>>, + wait: WaitQueue, +} + +impl FusePendingState { + pub fn new(opcode: u32) -> Self { + Self { + opcode, + response: Mutex::new(None), + wait: WaitQueue::default(), + } + } + + pub fn complete(&self, v: Result, SystemError>) { + let mut guard = self.response.lock(); + if guard.is_some() { + // Duplicate replies are ignored (Linux does similarly). + return; + } + *guard = Some(v); + drop(guard); + self.wait.wakeup(None); + } + + pub fn wait_complete(&self) -> Result, SystemError> { + match self + .wait + .wait_until_interruptible(|| self.response.lock().take())? + { + Some(v) => v, + None => Err(SystemError::EIO), + } + } +} + #[derive(Debug)] struct FuseConnInner { connected: bool, mounted: bool, initialized: bool, pending: VecDeque>, - processing: BTreeMap, + processing: BTreeMap>, } /// FUSE connection object (roughly equivalent to Linux `struct fuse_conn`). @@ -46,6 +75,7 @@ pub struct FuseConn { inner: Mutex, next_unique: AtomicU64, read_wait: WaitQueue, + init_wait: WaitQueue, epitems: LockedEPItemLinkedList, } @@ -62,6 +92,7 @@ impl FuseConn { // Use non-zero unique, keep even IDs for "ordinary" requests as Linux does. next_unique: AtomicU64::new(2), read_wait: WaitQueue::default(), + init_wait: WaitQueue::default(), epitems: LockedEPItemLinkedList::default(), }) } @@ -91,63 +122,36 @@ impl FuseConn { self.next_unique.fetch_add(2, Ordering::Relaxed) } - pub fn enqueue_init(&self) -> Result<(), SystemError> { - let unique = self.alloc_unique(); - - let hdr = FuseInHeader { - len: (core::mem::size_of::() + core::mem::size_of::()) as u32, - opcode: FUSE_INIT, - unique, - nodeid: 0, - uid: 0, - gid: 0, - pid: 0, - total_extlen: 0, - padding: 0, - }; - - let init_in = FuseInitIn { - major: FUSE_KERNEL_VERSION, - minor: FUSE_KERNEL_MINOR_VERSION, - max_readahead: 0, - flags: 0, - flags2: 0, - unused: [0; 11], - }; - - let mut bytes = Vec::with_capacity(hdr.len as usize); - bytes.extend_from_slice(fuse_pack_struct(&hdr)); - bytes.extend_from_slice(fuse_pack_struct(&init_in)); - - let req = Arc::new(FuseRequest { - unique, - kind: FuseReqKind::Init, - bytes, - }); - - { - let mut g = self.inner.lock(); + fn wait_initialized(&self) -> Result<(), SystemError> { + if self.is_initialized() { + return Ok(()); + } + self.init_wait.wait_until_interruptible(|| { + let g = self.inner.lock(); if !g.connected { - return Err(SystemError::ENOTCONN); + return Some(Err(SystemError::ENOTCONN)); } - g.pending.push_back(req.clone()); - g.processing.insert(unique, FuseReqKind::Init); - } - - self.read_wait.wakeup(None); - let _ = EventPoll::wakeup_epoll( - &self.epitems, - EPollEventType::EPOLLIN | EPollEventType::EPOLLRDNORM, - ); - Ok(()) + if g.initialized { + return Some(Ok(())); + } + None + })? } pub fn abort(&self) { - { + let processing: Vec> = { let mut g = self.inner.lock(); g.connected = false; + g.pending.clear(); + let processing = g.processing.values().cloned().collect(); + g.processing.clear(); + processing + }; + for p in processing { + p.complete(Err(SystemError::ENOTCONN)); } self.read_wait.wakeup(None); + self.init_wait.wakeup(None); let _ = EventPoll::wakeup_epoll( &self.epitems, EPollEventType::EPOLLERR | EPollEventType::EPOLLHUP, @@ -222,6 +226,77 @@ impl FuseConn { Ok(req.bytes.len()) } + pub fn enqueue_init(&self) -> Result<(), SystemError> { + let init_in = FuseInitIn { + major: FUSE_KERNEL_VERSION, + minor: FUSE_KERNEL_MINOR_VERSION, + max_readahead: 0, + flags: 0, + flags2: 0, + unused: [0; 11], + }; + self.enqueue_request(FUSE_INIT, 0, fuse_pack_struct(&init_in)) + .map(|_| ()) + } + + pub fn request(&self, opcode: u32, nodeid: u64, payload: &[u8]) -> Result, SystemError> { + if opcode != FUSE_INIT { + self.wait_initialized()?; + } + self.enqueue_request(opcode, nodeid, payload)?.wait_complete() + } + + fn enqueue_request( + &self, + opcode: u32, + nodeid: u64, + payload: &[u8], + ) -> Result, SystemError> { + let unique = self.alloc_unique(); + + let pcb = ProcessManager::current_pcb(); + let cred = pcb.cred(); + let pid = pcb + .task_tgid_vnr() + .map(|p| p.data() as u32) + .unwrap_or(0); + + let hdr = FuseInHeader { + len: (core::mem::size_of::() + payload.len()) as u32, + opcode, + unique, + nodeid, + uid: cred.fsuid.data() as u32, + gid: cred.fsgid.data() as u32, + pid, + total_extlen: 0, + padding: 0, + }; + + let mut bytes = Vec::with_capacity(hdr.len as usize); + bytes.extend_from_slice(fuse_pack_struct(&hdr)); + bytes.extend_from_slice(payload); + + let req = Arc::new(FuseRequest { bytes }); + let pending_state = Arc::new(FusePendingState::new(opcode)); + + { + let mut g = self.inner.lock(); + if !g.connected { + return Err(SystemError::ENOTCONN); + } + g.pending.push_back(req); + g.processing.insert(unique, pending_state.clone()); + } + + self.read_wait.wakeup(None); + let _ = EventPoll::wakeup_epoll( + &self.epitems, + EPollEventType::EPOLLIN | EPollEventType::EPOLLRDNORM, + ); + Ok(pending_state) + } + pub fn write_reply(&self, data: &[u8]) -> Result { if data.len() < core::mem::size_of::() { return Err(SystemError::EINVAL); @@ -232,47 +307,50 @@ impl FuseConn { return Err(SystemError::EINVAL); } - let kind = { + let pending = { let mut g = self.inner.lock(); if !g.connected { return Err(SystemError::ENOTCONN); } - match g.processing.remove(&out_hdr.unique) { - Some(k) => k, - None => return Err(SystemError::EINVAL), - } + g.processing.remove(&out_hdr.unique) + .ok_or(SystemError::EINVAL)? }; - if out_hdr.error != 0 { - // Any init-stage error aborts the connection. - self.abort(); - return Err(SystemError::EINVAL); + let payload = &data[core::mem::size_of::()..]; + let error = out_hdr.error; + + if error != 0 { + // Negative errno from userspace. + let errno = -error; + let e = SystemError::from_i32(errno).unwrap_or(SystemError::EIO); + pending.complete(Err(e)); + if pending.opcode == FUSE_INIT { + self.abort(); + } + return Ok(data.len()); } - match kind { - FuseReqKind::Init => { - let payload = &data[core::mem::size_of::()..]; - let init_out: FuseInitOut = fuse_read_struct(payload)?; - if init_out.major != FUSE_KERNEL_VERSION { - self.abort(); - return Err(SystemError::EINVAL); - } + if pending.opcode == FUSE_INIT { + let init_out: FuseInitOut = fuse_read_struct(payload)?; + if init_out.major != FUSE_KERNEL_VERSION { + pending.complete(Err(SystemError::EINVAL)); + self.abort(); + return Ok(data.len()); + } - // Negotiate minor version: use the smaller one. - let negotiated_minor = core::cmp::min(init_out.minor, FUSE_KERNEL_MINOR_VERSION); + // Negotiate minor version: use the smaller one. + let _negotiated_minor = core::cmp::min(init_out.minor, FUSE_KERNEL_MINOR_VERSION); + { let mut g = self.inner.lock(); - if !g.connected { - return Err(SystemError::ENOTCONN); + if g.connected { + g.initialized = true; } - g.initialized = true; - drop(g); - - // For now we only record "initialized"; other negotiated values can be added later. - let _ = negotiated_minor; } + self.init_wait.wakeup(None); } + pending.complete(Ok(payload.to_vec())); Ok(data.len()) } } diff --git a/kernel/src/filesystem/fuse/dev.rs b/kernel/src/filesystem/fuse/dev.rs index aedd3a1aa3..aafacef313 100644 --- a/kernel/src/filesystem/fuse/dev.rs +++ b/kernel/src/filesystem/fuse/dev.rs @@ -220,12 +220,8 @@ impl IndexNode for LockedFuseDevInode { } fn parent(&self) -> Result, SystemError> { - self.0 - .lock() - .parent - .upgrade() - .map(|p| p as Arc) - .ok_or(SystemError::ENOENT) + let parent = self.0.lock().parent.upgrade().ok_or(SystemError::ENOENT)?; + Ok(parent) } fn as_pollable_inode(&self) -> Result<&dyn PollableInode, SystemError> { diff --git a/kernel/src/filesystem/fuse/fs.rs b/kernel/src/filesystem/fuse/fs.rs index 2e58a05628..391621c39f 100644 --- a/kernel/src/filesystem/fuse/fs.rs +++ b/kernel/src/filesystem/fuse/fs.rs @@ -1,13 +1,18 @@ -use alloc::{string::String, sync::Arc, vec::Vec}; +use alloc::{ + collections::BTreeMap, + string::String, + sync::{Arc, Weak}, + vec::Vec, +}; use system_error::SystemError; use crate::{ filesystem::vfs::{ - vcore::generate_inode_id, FileSystem, FileSystemMakerData, FileType, FsInfo, IndexNode, - InodeFlags, InodeMode, Magic, Metadata, MountableFileSystem, SuperBlock, FSMAKER, + FileSystem, FileSystemMakerData, FileType, FsInfo, IndexNode, InodeFlags, InodeId, + InodeMode, Magic, Metadata, MountableFileSystem, SuperBlock, FSMAKER, }, - libs::mutex::{Mutex, MutexGuard}, + libs::mutex::Mutex, process::ProcessManager, register_mountable_fs, time::PosixTimeSpec, @@ -15,7 +20,7 @@ use crate::{ use linkme::distributed_slice; -use super::conn::FuseConn; +use super::{conn::FuseConn, inode::FuseNode, protocol::FUSE_ROOT_ID}; #[derive(Debug)] pub struct FuseMountData { @@ -34,9 +39,10 @@ impl FileSystemMakerData for FuseMountData { #[derive(Debug)] pub struct FuseFS { - root: Arc, + root: Arc, super_block: SuperBlock, conn: Arc, + nodes: Mutex>>, #[allow(dead_code)] owner_uid: u32, #[allow(dead_code)] @@ -88,6 +94,42 @@ impl FuseFS { Ok((fd, rootmode, user_id, group_id)) } + + pub fn root_node(&self) -> Arc { + self.root.clone() + } + + pub fn get_or_create_node( + self: &Arc, + nodeid: u64, + parent_nodeid: u64, + cached: Option, + ) -> Arc { + if nodeid == FUSE_ROOT_ID { + return self.root.clone(); + } + + let mut nodes = self.nodes.lock(); + if let Some(w) = nodes.get(&nodeid) { + if let Some(n) = w.upgrade() { + n.set_parent_nodeid(parent_nodeid); + if let Some(md) = cached { + n.set_cached_metadata(md); + } + return n; + } + } + + let n = FuseNode::new( + Arc::downgrade(self), + self.conn.clone(), + nodeid, + parent_nodeid, + cached, + ); + nodes.insert(nodeid, Arc::downgrade(&n)); + n + } } impl MountableFileSystem for FuseFS { @@ -137,7 +179,7 @@ impl MountableFileSystem for FuseFS { let root_md = Metadata { dev_id: 0, - inode_id: generate_inode_id(), + inode_id: InodeId::new(FUSE_ROOT_ID as usize), size: 0, blk_size: 0, blocks: 0, @@ -156,19 +198,19 @@ impl MountableFileSystem for FuseFS { let conn = mount_data.conn.clone(); - let fs = Arc::new_cyclic(|weak_fs| { - let root = Arc::new_cyclic(|weak_root| FuseRootInode { - self_ref: weak_root.clone(), - fs: weak_fs.clone(), - metadata: Mutex::new(root_md), - }); - FuseFS { - root, - super_block, - conn: conn.clone(), - owner_uid: mount_data.user_id, - owner_gid: mount_data.group_id, - } + let fs = Arc::new_cyclic(|weak_fs| FuseFS { + root: FuseNode::new( + weak_fs.clone(), + conn.clone(), + FUSE_ROOT_ID, + FUSE_ROOT_ID, + Some(root_md), + ), + super_block, + conn: conn.clone(), + nodes: Mutex::new(BTreeMap::new()), + owner_uid: mount_data.user_id, + owner_gid: mount_data.group_id, }); conn.enqueue_init()?; @@ -202,83 +244,3 @@ impl FileSystem for FuseFS { self.super_block.clone() } } - -#[derive(Debug)] -pub struct FuseRootInode { - self_ref: alloc::sync::Weak, - fs: alloc::sync::Weak, - metadata: Mutex, -} - -impl IndexNode for FuseRootInode { - fn as_any_ref(&self) -> &dyn core::any::Any { - self - } - - fn open( - &self, - _data: MutexGuard, - _flags: &crate::filesystem::vfs::file::FileFlags, - ) -> Result<(), SystemError> { - Ok(()) - } - - fn close( - &self, - _data: MutexGuard, - ) -> Result<(), SystemError> { - Ok(()) - } - - fn read_at( - &self, - _offset: usize, - _len: usize, - _buf: &mut [u8], - _data: MutexGuard, - ) -> Result { - Err(SystemError::EISDIR) - } - - fn write_at( - &self, - _offset: usize, - _len: usize, - _buf: &[u8], - _data: MutexGuard, - ) -> Result { - Err(SystemError::EISDIR) - } - - fn metadata(&self) -> Result { - Ok(self.metadata.lock().clone()) - } - - fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> { - *self.metadata.lock() = metadata.clone(); - Ok(()) - } - - fn fs(&self) -> Arc { - self.fs.upgrade().unwrap() - } - - fn list(&self) -> Result, SystemError> { - Ok(Vec::new()) - } - - fn find(&self, name: &str) -> Result, SystemError> { - match name { - "." | ".." => Ok(self.self_ref.upgrade().ok_or(SystemError::ENOENT)?), - _ => Err(SystemError::ENOENT), - } - } - - fn parent(&self) -> Result, SystemError> { - Ok(self.self_ref.upgrade().ok_or(SystemError::ENOENT)?) - } - - fn absolute_path(&self) -> Result { - Ok(String::from("/")) - } -} diff --git a/kernel/src/filesystem/fuse/inode.rs b/kernel/src/filesystem/fuse/inode.rs new file mode 100644 index 0000000000..982adf7a5b --- /dev/null +++ b/kernel/src/filesystem/fuse/inode.rs @@ -0,0 +1,557 @@ +use alloc::{ + string::{String, ToString}, + sync::{Arc, Weak}, + vec::Vec, +}; +use core::mem::size_of; + +use system_error::SystemError; + +use crate::{ + driver::base::device::device_number::DeviceNumber, + filesystem::vfs::{ + file::{FuseDirPrivateData, FuseFilePrivateData, FileFlags}, + syscall::RenameFlags, + FilePrivateData, FileSystem, FileType, InodeFlags, InodeId, InodeMode, IndexNode, Metadata, + }, + libs::mutex::{Mutex, MutexGuard}, + time::PosixTimeSpec, +}; + +use super::{ + conn::FuseConn, + fs::FuseFS, + protocol::{ + fuse_pack_struct, fuse_read_struct, FuseAttr, FuseAttrOut, FuseDirent, FuseEntryOut, + FuseGetattrIn, FuseMkdirIn, FuseMknodIn, FuseOpenIn, FuseOpenOut, FuseReadIn, FuseReleaseIn, + FuseRenameIn, FuseSetattrIn, FuseWriteIn, FuseWriteOut, FATTR_GID, FATTR_MODE, FATTR_SIZE, + FATTR_UID, FUSE_GETATTR, FUSE_LOOKUP, FUSE_MKDIR, FUSE_MKNOD, FUSE_OPEN, FUSE_OPENDIR, + FUSE_READ, FUSE_READDIR, FUSE_RELEASE, FUSE_RELEASEDIR, FUSE_RENAME, FUSE_RMDIR, + FUSE_SETATTR, FUSE_UNLINK, FUSE_WRITE, + }, +}; + +#[derive(Debug)] +pub struct FuseNode { + fs: Weak, + conn: Arc, + nodeid: u64, + parent_nodeid: Mutex, + cached_metadata: Mutex>, +} + +impl FuseNode { + pub fn new( + fs: Weak, + conn: Arc, + nodeid: u64, + parent_nodeid: u64, + cached: Option, + ) -> Arc { + Arc::new(Self { + fs, + conn, + nodeid, + parent_nodeid: Mutex::new(parent_nodeid), + cached_metadata: Mutex::new(cached), + }) + } + + pub fn nodeid(&self) -> u64 { + self.nodeid + } + + pub fn set_parent_nodeid(&self, parent: u64) { + *self.parent_nodeid.lock() = parent; + } + + pub fn set_cached_metadata(&self, md: Metadata) { + *self.cached_metadata.lock() = Some(md); + } + + fn conn(&self) -> &Arc { + &self.conn + } + + fn request_name(&self, opcode: u32, nodeid: u64, name: &str) -> Result, SystemError> { + let mut payload = Vec::with_capacity(name.len() + 1); + payload.extend_from_slice(name.as_bytes()); + payload.push(0); + self.conn().request(opcode, nodeid, &payload) + } + + fn attr_to_metadata(attr: &FuseAttr) -> Metadata { + let mode = InodeMode::from_bits_truncate(attr.mode); + let file_type = if mode.contains(InodeMode::S_IFDIR) { + FileType::Dir + } else if mode.contains(InodeMode::S_IFREG) { + FileType::File + } else if mode.contains(InodeMode::S_IFLNK) { + FileType::SymLink + } else if mode.contains(InodeMode::S_IFCHR) { + FileType::CharDevice + } else if mode.contains(InodeMode::S_IFBLK) { + FileType::BlockDevice + } else if mode.contains(InodeMode::S_IFSOCK) { + FileType::Socket + } else if mode.contains(InodeMode::S_IFIFO) { + FileType::Pipe + } else { + FileType::File + }; + + let inode_id = InodeId::new(attr.ino as usize); + + Metadata { + dev_id: 0, + inode_id, + size: attr.size as usize, + blk_size: attr.blksize as usize, + blocks: attr.blocks as usize, + atime: PosixTimeSpec::new(attr.atime as i64, attr.atimensec as i64), + mtime: PosixTimeSpec::new(attr.mtime as i64, attr.mtimensec as i64), + ctime: PosixTimeSpec::new(attr.ctime as i64, attr.ctimensec as i64), + btime: PosixTimeSpec::default(), + file_type, + mode, + flags: InodeFlags::empty(), + nlinks: attr.nlink as usize, + uid: attr.uid as usize, + gid: attr.gid as usize, + raw_dev: DeviceNumber::default(), + } + } + + fn fetch_attr(&self) -> Result { + let getattr_in = FuseGetattrIn { + getattr_flags: 0, + dummy: 0, + fh: 0, + }; + let payload = self + .conn() + .request(FUSE_GETATTR, self.nodeid, fuse_pack_struct(&getattr_in))?; + let out: FuseAttrOut = fuse_read_struct(&payload)?; + let md = Self::attr_to_metadata(&out.attr); + *self.cached_metadata.lock() = Some(md.clone()); + Ok(md) + } + + fn cached_or_fetch_metadata(&self) -> Result { + if let Some(m) = self.cached_metadata.lock().clone() { + return Ok(m); + } + self.fetch_attr() + } + + fn open_common( + &self, + opcode: u32, + data: &mut FilePrivateData, + flags: &FileFlags, + ) -> Result<(), SystemError> { + let open_in = FuseOpenIn { + flags: flags.bits(), + open_flags: 0, + }; + let payload = self + .conn() + .request(opcode, self.nodeid, fuse_pack_struct(&open_in))?; + let out: FuseOpenOut = fuse_read_struct(&payload)?; + + let conn_any: Arc = self.conn.clone(); + match opcode { + FUSE_OPEN => { + *data = FilePrivateData::FuseFile(FuseFilePrivateData { + conn: conn_any, + fh: out.fh, + open_flags: open_in.flags, + }); + } + FUSE_OPENDIR => { + *data = FilePrivateData::FuseDir(FuseDirPrivateData { + conn: conn_any, + fh: out.fh, + open_flags: open_in.flags, + }); + } + _ => return Err(SystemError::EINVAL), + } + Ok(()) + } + + fn release_common(&self, opcode: u32, fh: u64, open_flags: u32) -> Result<(), SystemError> { + let inarg = FuseReleaseIn { + fh, + flags: open_flags, + release_flags: 0, + lock_owner: 0, + }; + let _ = self + .conn() + .request(opcode, self.nodeid, fuse_pack_struct(&inarg))?; + Ok(()) + } + + fn ensure_dir(&self) -> Result<(), SystemError> { + let md = self.cached_or_fetch_metadata()?; + if md.file_type != FileType::Dir { + return Err(SystemError::ENOTDIR); + } + Ok(()) + } + + fn ensure_regular(&self) -> Result<(), SystemError> { + let md = self.cached_or_fetch_metadata()?; + if md.file_type != FileType::File { + return Err(SystemError::EINVAL); + } + Ok(()) + } +} + +impl IndexNode for FuseNode { + fn as_any_ref(&self) -> &dyn core::any::Any { + self + } + + fn open(&self, mut data: MutexGuard, flags: &FileFlags) -> Result<(), SystemError> { + let md = self.cached_or_fetch_metadata()?; + match md.file_type { + FileType::Dir => self.open_common(FUSE_OPENDIR, &mut *data, flags), + FileType::File => self.open_common(FUSE_OPEN, &mut *data, flags), + _ => Err(SystemError::EINVAL), + } + } + + fn close(&self, data: MutexGuard) -> Result<(), SystemError> { + match &*data { + FilePrivateData::FuseFile(p) => self.release_common(FUSE_RELEASE, p.fh, p.open_flags), + FilePrivateData::FuseDir(p) => self.release_common(FUSE_RELEASEDIR, p.fh, p.open_flags), + _ => Ok(()), + } + } + + fn read_at( + &self, + offset: usize, + len: usize, + buf: &mut [u8], + data: MutexGuard, + ) -> Result { + self.ensure_regular()?; + if buf.len() < len { + return Err(SystemError::EINVAL); + } + let FilePrivateData::FuseFile(p) = &*data else { + return Err(SystemError::EBADF); + }; + let read_in = FuseReadIn { + fh: p.fh, + offset: offset as u64, + size: len as u32, + read_flags: 0, + lock_owner: 0, + flags: 0, + padding: 0, + }; + let payload = self + .conn() + .request(FUSE_READ, self.nodeid, fuse_pack_struct(&read_in))?; + let n = core::cmp::min(payload.len(), len); + buf[..n].copy_from_slice(&payload[..n]); + Ok(n) + } + + fn write_at( + &self, + offset: usize, + len: usize, + buf: &[u8], + data: MutexGuard, + ) -> Result { + self.ensure_regular()?; + if buf.len() < len { + return Err(SystemError::EINVAL); + } + let FilePrivateData::FuseFile(p) = &*data else { + return Err(SystemError::EBADF); + }; + let write_in = FuseWriteIn { + fh: p.fh, + offset: offset as u64, + size: len as u32, + write_flags: 0, + lock_owner: 0, + flags: 0, + padding: 0, + }; + let mut payload_in = Vec::with_capacity(size_of::() + len); + payload_in.extend_from_slice(fuse_pack_struct(&write_in)); + payload_in.extend_from_slice(&buf[..len]); + let payload = self.conn().request(FUSE_WRITE, self.nodeid, &payload_in)?; + let out: FuseWriteOut = fuse_read_struct(&payload)?; + Ok(out.size as usize) + } + + fn metadata(&self) -> Result { + self.cached_or_fetch_metadata() + } + + fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> { + // Minimal setattr: mode/uid/gid/size + let mut valid = 0u32; + valid |= FATTR_MODE; + valid |= FATTR_UID; + valid |= FATTR_GID; + valid |= FATTR_SIZE; + + let inarg = FuseSetattrIn { + valid, + padding: 0, + fh: 0, + size: metadata.size as u64, + lock_owner: 0, + atime: 0, + mtime: 0, + ctime: 0, + atimensec: 0, + mtimensec: 0, + ctimensec: 0, + mode: metadata.mode.bits(), + unused4: 0, + uid: metadata.uid as u32, + gid: metadata.gid as u32, + unused5: 0, + }; + let payload = self + .conn() + .request(FUSE_SETATTR, self.nodeid, fuse_pack_struct(&inarg))?; + let out: FuseAttrOut = fuse_read_struct(&payload)?; + let md = Self::attr_to_metadata(&out.attr); + *self.cached_metadata.lock() = Some(md); + Ok(()) + } + + fn resize(&self, len: usize) -> Result<(), SystemError> { + let inarg = FuseSetattrIn { + valid: FATTR_SIZE, + padding: 0, + fh: 0, + size: len as u64, + lock_owner: 0, + atime: 0, + mtime: 0, + ctime: 0, + atimensec: 0, + mtimensec: 0, + ctimensec: 0, + mode: 0, + unused4: 0, + uid: 0, + gid: 0, + unused5: 0, + }; + let payload = self + .conn() + .request(FUSE_SETATTR, self.nodeid, fuse_pack_struct(&inarg))?; + let out: FuseAttrOut = fuse_read_struct(&payload)?; + let md = Self::attr_to_metadata(&out.attr); + *self.cached_metadata.lock() = Some(md); + Ok(()) + } + + fn fs(&self) -> Arc { + self.fs.upgrade().unwrap() + } + + fn list(&self) -> Result, SystemError> { + self.ensure_dir()?; + + // OPENDIR + let mut pdata = FilePrivateData::Unused; + let flags = FileFlags::O_RDONLY; + self.open_common(FUSE_OPENDIR, &mut pdata, &flags)?; + let FilePrivateData::FuseDir(dir_p) = &pdata else { + return Err(SystemError::EINVAL); + }; + let fh = dir_p.fh; + let open_flags = dir_p.open_flags; + + let mut names: Vec = Vec::new(); + let mut offset: u64 = 0; + + loop { + let read_in = FuseReadIn { + fh, + offset, + size: 64 * 1024, + read_flags: 0, + lock_owner: 0, + flags: 0, + padding: 0, + }; + let payload = self + .conn() + .request(FUSE_READDIR, self.nodeid, fuse_pack_struct(&read_in))?; + if payload.is_empty() { + break; + } + + let mut pos: usize = 0; + let mut last_off: u64 = offset; + while pos + size_of::() <= payload.len() { + let dirent: FuseDirent = fuse_read_struct(&payload[pos..])?; + let name_start = pos + size_of::(); + let name_end = name_start + dirent.namelen as usize; + if name_end > payload.len() { + break; + } + let name_bytes = &payload[name_start..name_end]; + if let Ok(name) = core::str::from_utf8(name_bytes) { + if !name.is_empty() && name != "." && name != ".." { + names.push(name.to_string()); + } + } + + last_off = dirent.off; + let rec_len_unaligned = size_of::() + dirent.namelen as usize; + let rec_len = (rec_len_unaligned + 8 - 1) & !(8 - 1); + if rec_len == 0 { + break; + } + pos = pos.saturating_add(rec_len); + } + + if last_off == offset { + // Avoid infinite loop if userspace doesn't advance offsets. + break; + } + offset = last_off; + } + + // RELEASEDIR (best-effort) + let _ = self.release_common(FUSE_RELEASEDIR, fh, open_flags); + Ok(names) + } + + fn find(&self, name: &str) -> Result, SystemError> { + self.ensure_dir()?; + if name == "." { + let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; + return Ok(fs.get_or_create_node(self.nodeid, *self.parent_nodeid.lock(), None)); + } + if name == ".." { + return self.parent(); + } + + let payload = self.request_name(FUSE_LOOKUP, self.nodeid, name)?; + let entry: FuseEntryOut = fuse_read_struct(&payload)?; + let md = Self::attr_to_metadata(&entry.attr); + + let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; + let child = fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md)); + Ok(child) + } + + fn parent(&self) -> Result, SystemError> { + let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; + let parent_nodeid = *self.parent_nodeid.lock(); + if parent_nodeid == self.nodeid { + return Ok(fs.root_node()); + } + Ok(fs.get_or_create_node(parent_nodeid, parent_nodeid, None)) + } + + fn create_with_data( + &self, + name: &str, + file_type: FileType, + mode: InodeMode, + _data: usize, + ) -> Result, SystemError> { + self.ensure_dir()?; + + match file_type { + FileType::Dir => { + let inarg = FuseMkdirIn { + mode: (InodeMode::S_IFDIR | mode).bits(), + umask: 0, + }; + let mut payload_in = Vec::with_capacity(size_of::() + name.len() + 1); + payload_in.extend_from_slice(fuse_pack_struct(&inarg)); + payload_in.extend_from_slice(name.as_bytes()); + payload_in.push(0); + let payload = self + .conn() + .request(FUSE_MKDIR, self.nodeid, &payload_in)?; + let entry: FuseEntryOut = fuse_read_struct(&payload)?; + let md = Self::attr_to_metadata(&entry.attr); + let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; + Ok(fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md))) + } + FileType::File => { + let inarg = FuseMknodIn { + mode: (InodeMode::S_IFREG | mode).bits(), + rdev: 0, + umask: 0, + padding: 0, + }; + let mut payload_in = Vec::with_capacity(size_of::() + name.len() + 1); + payload_in.extend_from_slice(fuse_pack_struct(&inarg)); + payload_in.extend_from_slice(name.as_bytes()); + payload_in.push(0); + let payload = self + .conn() + .request(FUSE_MKNOD, self.nodeid, &payload_in)?; + let entry: FuseEntryOut = fuse_read_struct(&payload)?; + let md = Self::attr_to_metadata(&entry.attr); + let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; + Ok(fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md))) + } + _ => Err(SystemError::ENOSYS), + } + } + + fn unlink(&self, name: &str) -> Result<(), SystemError> { + self.ensure_dir()?; + let _ = self.request_name(FUSE_UNLINK, self.nodeid, name)?; + Ok(()) + } + + fn rmdir(&self, name: &str) -> Result<(), SystemError> { + self.ensure_dir()?; + let _ = self.request_name(FUSE_RMDIR, self.nodeid, name)?; + Ok(()) + } + + fn move_to( + &self, + old_name: &str, + target: &Arc, + new_name: &str, + _flag: RenameFlags, + ) -> Result<(), SystemError> { + self.ensure_dir()?; + let target_any = target + .as_any_ref() + .downcast_ref::() + .ok_or(SystemError::EXDEV)?; + + let inarg = FuseRenameIn { + newdir: target_any.nodeid, + }; + let mut payload_in = Vec::new(); + payload_in.extend_from_slice(fuse_pack_struct(&inarg)); + payload_in.extend_from_slice(old_name.as_bytes()); + payload_in.push(0); + payload_in.extend_from_slice(new_name.as_bytes()); + payload_in.push(0); + let _ = self.conn().request(FUSE_RENAME, self.nodeid, &payload_in)?; + Ok(()) + } + + fn absolute_path(&self) -> Result { + Ok(format!("fuse:{}", self.nodeid)) + } +} diff --git a/kernel/src/filesystem/fuse/mod.rs b/kernel/src/filesystem/fuse/mod.rs index 75e3d23537..9d87679c80 100644 --- a/kernel/src/filesystem/fuse/mod.rs +++ b/kernel/src/filesystem/fuse/mod.rs @@ -1,4 +1,5 @@ pub mod conn; pub mod dev; pub mod fs; +pub mod inode; pub mod protocol; diff --git a/kernel/src/filesystem/fuse/protocol.rs b/kernel/src/filesystem/fuse/protocol.rs index 5c108e5e3e..a7d7308a6d 100644 --- a/kernel/src/filesystem/fuse/protocol.rs +++ b/kernel/src/filesystem/fuse/protocol.rs @@ -14,7 +14,36 @@ pub const FUSE_MIN_READ_BUFFER: usize = 8192; pub const FUSE_ROOT_ID: u64 = 1; +// Opcodes (subset) +pub const FUSE_LOOKUP: u32 = 1; +pub const FUSE_FORGET: u32 = 2; // no reply +pub const FUSE_GETATTR: u32 = 3; +pub const FUSE_SETATTR: u32 = 4; +pub const FUSE_MKNOD: u32 = 8; +pub const FUSE_MKDIR: u32 = 9; +pub const FUSE_UNLINK: u32 = 10; +pub const FUSE_RMDIR: u32 = 11; +pub const FUSE_RENAME: u32 = 12; +pub const FUSE_OPEN: u32 = 14; +pub const FUSE_READ: u32 = 15; +pub const FUSE_WRITE: u32 = 16; +pub const FUSE_RELEASE: u32 = 18; pub const FUSE_INIT: u32 = 26; +pub const FUSE_OPENDIR: u32 = 27; +pub const FUSE_READDIR: u32 = 28; +pub const FUSE_RELEASEDIR: u32 = 29; + +// getattr/setattr valid bits (subset) +pub const FATTR_MODE: u32 = 1 << 0; +pub const FATTR_UID: u32 = 1 << 1; +pub const FATTR_GID: u32 = 1 << 2; +pub const FATTR_SIZE: u32 = 1 << 3; +pub const FATTR_ATIME: u32 = 1 << 4; +pub const FATTR_MTIME: u32 = 1 << 5; +pub const FATTR_FH: u32 = 1 << 6; +pub const FATTR_ATIME_NOW: u32 = 1 << 7; +pub const FATTR_MTIME_NOW: u32 = 1 << 8; +pub const FATTR_CTIME: u32 = 1 << 10; #[repr(C)] #[derive(Debug, Clone, Copy)] @@ -66,6 +95,164 @@ pub struct FuseInitOut { pub unused: [u32; 7], } +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseAttr { + pub ino: u64, + pub size: u64, + pub blocks: u64, + pub atime: u64, + pub mtime: u64, + pub ctime: u64, + pub atimensec: u32, + pub mtimensec: u32, + pub ctimensec: u32, + pub mode: u32, + pub nlink: u32, + pub uid: u32, + pub gid: u32, + pub rdev: u32, + pub blksize: u32, + pub flags: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseEntryOut { + pub nodeid: u64, + pub generation: u64, + pub entry_valid: u64, + pub attr_valid: u64, + pub entry_valid_nsec: u32, + pub attr_valid_nsec: u32, + pub attr: FuseAttr, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseGetattrIn { + pub getattr_flags: u32, + pub dummy: u32, + pub fh: u64, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseAttrOut { + pub attr_valid: u64, + pub attr_valid_nsec: u32, + pub dummy: u32, + pub attr: FuseAttr, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseOpenIn { + pub flags: u32, + pub open_flags: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseOpenOut { + pub fh: u64, + pub open_flags: u32, + pub padding: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseReadIn { + pub fh: u64, + pub offset: u64, + pub size: u32, + pub read_flags: u32, + pub lock_owner: u64, + pub flags: u32, + pub padding: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseWriteIn { + pub fh: u64, + pub offset: u64, + pub size: u32, + pub write_flags: u32, + pub lock_owner: u64, + pub flags: u32, + pub padding: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseWriteOut { + pub size: u32, + pub padding: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseReleaseIn { + pub fh: u64, + pub flags: u32, + pub release_flags: u32, + pub lock_owner: u64, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseMknodIn { + pub mode: u32, + pub rdev: u32, + pub umask: u32, + pub padding: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseMkdirIn { + pub mode: u32, + pub umask: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseRenameIn { + pub newdir: u64, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseSetattrIn { + pub valid: u32, + pub padding: u32, + pub fh: u64, + pub size: u64, + pub lock_owner: u64, + pub atime: u64, + pub mtime: u64, + pub ctime: u64, + pub atimensec: u32, + pub mtimensec: u32, + pub ctimensec: u32, + pub mode: u32, + pub unused4: u32, + pub uid: u32, + pub gid: u32, + pub unused5: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseDirent { + pub ino: u64, + pub off: u64, + pub namelen: u32, + pub typ: u32, + // name follows +} + pub fn fuse_pack_struct(v: &T) -> &[u8] { unsafe { core::slice::from_raw_parts((v as *const T).cast::(), size_of::()) } } diff --git a/kernel/src/filesystem/vfs/file.rs b/kernel/src/filesystem/vfs/file.rs index efbd8289a0..d131064f33 100644 --- a/kernel/src/filesystem/vfs/file.rs +++ b/kernel/src/filesystem/vfs/file.rs @@ -129,6 +129,10 @@ pub enum FilePrivateData { SocketCreate, /// /dev/fuse file private data (stores an opaque connection object). FuseDev(FuseDevPrivateData), + /// FUSE regular file private data (stores fh/open flags). + FuseFile(FuseFilePrivateData), + /// FUSE directory private data (stores fh/open flags). + FuseDir(FuseDirPrivateData), /// 不需要文件私有信息 Unused, } @@ -144,6 +148,20 @@ pub struct FuseDevPrivateData { pub nonblock: bool, } +#[derive(Debug, Clone)] +pub struct FuseFilePrivateData { + pub conn: Arc, + pub fh: u64, + pub open_flags: u32, +} + +#[derive(Debug, Clone)] +pub struct FuseDirPrivateData { + pub conn: Arc, + pub fh: u64, + pub open_flags: u32, +} + impl Default for FilePrivateData { fn default() -> Self { return Self::Unused; diff --git a/user/apps/c_unitest/fuse_test_simplefs.h b/user/apps/c_unitest/fuse_test_simplefs.h new file mode 100644 index 0000000000..60a7392019 --- /dev/null +++ b/user/apps/c_unitest/fuse_test_simplefs.h @@ -0,0 +1,784 @@ +/* + * Minimal FUSE userspace daemon for DragonOS kernel tests (no libfuse). + * + * This header provides a tiny in-memory filesystem and request handlers for + * a subset of FUSE opcodes used by Phase C/D tests. + */ + +#pragma once + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef DT_DIR +#define DT_DIR 4 +#endif +#ifndef DT_REG +#define DT_REG 8 +#endif + +/* Opcodes (subset) */ +#ifndef FUSE_LOOKUP +#define FUSE_LOOKUP 1 +#endif +#ifndef FUSE_GETATTR +#define FUSE_GETATTR 3 +#endif +#ifndef FUSE_SETATTR +#define FUSE_SETATTR 4 +#endif +#ifndef FUSE_MKNOD +#define FUSE_MKNOD 8 +#endif +#ifndef FUSE_MKDIR +#define FUSE_MKDIR 9 +#endif +#ifndef FUSE_UNLINK +#define FUSE_UNLINK 10 +#endif +#ifndef FUSE_RMDIR +#define FUSE_RMDIR 11 +#endif +#ifndef FUSE_RENAME +#define FUSE_RENAME 12 +#endif +#ifndef FUSE_OPEN +#define FUSE_OPEN 14 +#endif +#ifndef FUSE_READ +#define FUSE_READ 15 +#endif +#ifndef FUSE_WRITE +#define FUSE_WRITE 16 +#endif +#ifndef FUSE_RELEASE +#define FUSE_RELEASE 18 +#endif +#ifndef FUSE_INIT +#define FUSE_INIT 26 +#endif +#ifndef FUSE_OPENDIR +#define FUSE_OPENDIR 27 +#endif +#ifndef FUSE_READDIR +#define FUSE_READDIR 28 +#endif +#ifndef FUSE_RELEASEDIR +#define FUSE_RELEASEDIR 29 +#endif + +/* setattr valid bits (subset) */ +#ifndef FATTR_MODE +#define FATTR_MODE (1u << 0) +#endif +#ifndef FATTR_UID +#define FATTR_UID (1u << 1) +#endif +#ifndef FATTR_GID +#define FATTR_GID (1u << 2) +#endif +#ifndef FATTR_SIZE +#define FATTR_SIZE (1u << 3) +#endif + +struct fuse_in_header { + uint32_t len; + uint32_t opcode; + uint64_t unique; + uint64_t nodeid; + uint32_t uid; + uint32_t gid; + uint32_t pid; + uint16_t total_extlen; + uint16_t padding; +}; + +struct fuse_out_header { + uint32_t len; + int32_t error; /* -errno */ + uint64_t unique; +}; + +struct fuse_init_in { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; + uint32_t flags2; + uint32_t unused[11]; +}; + +struct fuse_init_out { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; + uint16_t max_background; + uint16_t congestion_threshold; + uint32_t max_write; + uint32_t time_gran; + uint16_t max_pages; + uint16_t map_alignment; + uint32_t flags2; + uint32_t unused[7]; +}; + +struct fuse_attr { + uint64_t ino; + uint64_t size; + uint64_t blocks; + uint64_t atime; + uint64_t mtime; + uint64_t ctime; + uint32_t atimensec; + uint32_t mtimensec; + uint32_t ctimensec; + uint32_t mode; + uint32_t nlink; + uint32_t uid; + uint32_t gid; + uint32_t rdev; + uint32_t blksize; + uint32_t flags; +}; + +struct fuse_entry_out { + uint64_t nodeid; + uint64_t generation; + uint64_t entry_valid; + uint64_t attr_valid; + uint32_t entry_valid_nsec; + uint32_t attr_valid_nsec; + struct fuse_attr attr; +}; + +struct fuse_getattr_in { + uint32_t getattr_flags; + uint32_t dummy; + uint64_t fh; +}; + +struct fuse_attr_out { + uint64_t attr_valid; + uint32_t attr_valid_nsec; + uint32_t dummy; + struct fuse_attr attr; +}; + +struct fuse_open_in { + uint32_t flags; + uint32_t open_flags; +}; + +struct fuse_open_out { + uint64_t fh; + uint32_t open_flags; + uint32_t padding; +}; + +struct fuse_read_in { + uint64_t fh; + uint64_t offset; + uint32_t size; + uint32_t read_flags; + uint64_t lock_owner; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_write_in { + uint64_t fh; + uint64_t offset; + uint32_t size; + uint32_t write_flags; + uint64_t lock_owner; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_write_out { + uint32_t size; + uint32_t padding; +}; + +struct fuse_release_in { + uint64_t fh; + uint32_t flags; + uint32_t release_flags; + uint64_t lock_owner; +}; + +struct fuse_mknod_in { + uint32_t mode; + uint32_t rdev; + uint32_t umask; + uint32_t padding; +}; + +struct fuse_mkdir_in { + uint32_t mode; + uint32_t umask; +}; + +struct fuse_rename_in { + uint64_t newdir; +}; + +struct fuse_setattr_in { + uint32_t valid; + uint32_t padding; + uint64_t fh; + uint64_t size; + uint64_t lock_owner; + uint64_t atime; + uint64_t mtime; + uint64_t ctime; + uint32_t atimensec; + uint32_t mtimensec; + uint32_t ctimensec; + uint32_t mode; + uint32_t unused4; + uint32_t uid; + uint32_t gid; + uint32_t unused5; +}; + +struct fuse_dirent { + uint64_t ino; + uint64_t off; + uint32_t namelen; + uint32_t type; + /* char name[]; */ +}; + +static inline size_t fuse_dirent_rec_len(size_t namelen) { + size_t unaligned = sizeof(struct fuse_dirent) + namelen; + return (unaligned + 8 - 1) & ~(size_t)(8 - 1); +} + +/* ===== in-memory FS ===== */ + +#define SIMPLEFS_MAX_NODES 64 +#define SIMPLEFS_NAME_MAX 64 +#define SIMPLEFS_DATA_MAX 8192 + +struct simplefs_node { + int used; + uint64_t nodeid; + uint64_t ino; + uint64_t parent; + int is_dir; + uint32_t mode; /* includes type bits */ + char name[SIMPLEFS_NAME_MAX]; + unsigned char data[SIMPLEFS_DATA_MAX]; + size_t size; +}; + +struct simplefs { + struct simplefs_node nodes[SIMPLEFS_MAX_NODES]; + uint64_t next_nodeid; + uint64_t next_ino; +}; + +static inline void simplefs_init(struct simplefs *fs) { + memset(fs, 0, sizeof(*fs)); + fs->next_nodeid = 2; + fs->next_ino = 2; + + /* root nodeid=1 */ + fs->nodes[0].used = 1; + fs->nodes[0].nodeid = 1; + fs->nodes[0].ino = 1; + fs->nodes[0].parent = 1; + fs->nodes[0].is_dir = 1; + fs->nodes[0].mode = 0040755; + strcpy(fs->nodes[0].name, ""); + fs->nodes[0].size = 0; + + /* hello.txt under root */ + fs->nodes[1].used = 1; + fs->nodes[1].nodeid = 2; + fs->nodes[1].ino = 2; + fs->nodes[1].parent = 1; + fs->nodes[1].is_dir = 0; + fs->nodes[1].mode = 0100644; + strcpy(fs->nodes[1].name, "hello.txt"); + const char *msg = "hello from fuse\n"; + fs->nodes[1].size = strlen(msg); + memcpy(fs->nodes[1].data, msg, fs->nodes[1].size); + + fs->next_nodeid = 3; + fs->next_ino = 3; +} + +static inline struct simplefs_node *simplefs_find_node(struct simplefs *fs, uint64_t nodeid) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (fs->nodes[i].used && fs->nodes[i].nodeid == nodeid) { + return &fs->nodes[i]; + } + } + return NULL; +} + +static inline struct simplefs_node *simplefs_find_child(struct simplefs *fs, uint64_t parent, + const char *name) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (!fs->nodes[i].used) + continue; + if (fs->nodes[i].parent != parent) + continue; + if (strcmp(fs->nodes[i].name, name) == 0) { + return &fs->nodes[i]; + } + } + return NULL; +} + +static inline int simplefs_has_children(struct simplefs *fs, uint64_t parent) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (fs->nodes[i].used && fs->nodes[i].parent == parent) { + return 1; + } + } + return 0; +} + +static inline struct simplefs_node *simplefs_alloc(struct simplefs *fs) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (!fs->nodes[i].used) { + memset(&fs->nodes[i], 0, sizeof(fs->nodes[i])); + fs->nodes[i].used = 1; + fs->nodes[i].nodeid = fs->next_nodeid++; + fs->nodes[i].ino = fs->next_ino++; + return &fs->nodes[i]; + } + } + return NULL; +} + +static inline void simplefs_fill_attr(const struct simplefs_node *n, struct fuse_attr *a) { + memset(a, 0, sizeof(*a)); + a->ino = n->ino; + a->size = n->size; + a->blocks = 0; + a->mode = n->mode; + a->nlink = n->is_dir ? 2 : 1; + a->uid = 0; + a->gid = 0; + a->blksize = 4096; +} + +static inline int fuse_write_reply(int fd, uint64_t unique, int32_t err_neg, + const void *payload, size_t payload_len) { + struct fuse_out_header out; + out.len = sizeof(out) + payload_len; + out.error = err_neg; + out.unique = unique; + + unsigned char buf[65536]; + if (sizeof(out) + payload_len > sizeof(buf)) { + errno = E2BIG; + return -1; + } + memcpy(buf, &out, sizeof(out)); + if (payload_len) { + memcpy(buf + sizeof(out), payload, payload_len); + } + ssize_t wn = write(fd, buf, sizeof(out) + payload_len); + if (wn != (ssize_t)(sizeof(out) + payload_len)) { + return -1; + } + return 0; +} + +struct fuse_daemon_args { + int fd; + volatile int *stop; + volatile int *init_done; + int enable_write_ops; + struct simplefs fs; +}; + +static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned char *req, size_t n) { + if (n < sizeof(struct fuse_in_header)) { + return -1; + } + const struct fuse_in_header *h = (const struct fuse_in_header *)req; + const unsigned char *payload = req + sizeof(*h); + size_t payload_len = n - sizeof(*h); + + switch (h->opcode) { + case FUSE_INIT: { + if (payload_len < sizeof(struct fuse_init_in)) { + return -1; + } + struct fuse_init_out out; + memset(&out, 0, sizeof(out)); + out.major = 7; + out.minor = 39; + out.max_write = 4096; + if (fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)) != 0) { + return -1; + } + *a->init_done = 1; + return 0; + } + case FUSE_LOOKUP: { + const char *name = (const char *)payload; + if (payload_len == 0 || name[payload_len - 1] != '\0') { + return -1; + } + struct simplefs_node *parent = simplefs_find_node(&a->fs, h->nodeid); + if (!parent || !parent->is_dir) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + struct simplefs_node *child = simplefs_find_child(&a->fs, h->nodeid, name); + if (!child) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + struct fuse_entry_out out; + memset(&out, 0, sizeof(out)); + out.nodeid = child->nodeid; + simplefs_fill_attr(child, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_GETATTR: { + (void)payload; + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + struct fuse_attr_out out; + memset(&out, 0, sizeof(out)); + simplefs_fill_attr(node, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_OPENDIR: + case FUSE_OPEN: { + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (h->opcode == FUSE_OPENDIR && !node->is_dir) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (h->opcode == FUSE_OPEN && node->is_dir) { + return fuse_write_reply(a->fd, h->unique, -EISDIR, NULL, 0); + } + struct fuse_open_out out; + memset(&out, 0, sizeof(out)); + out.fh = node->nodeid; + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_READ: { + if (payload_len < sizeof(struct fuse_read_in)) { + return -1; + } + const struct fuse_read_in *in = (const struct fuse_read_in *)payload; + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node || node->is_dir) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } + if (in->offset >= node->size) { + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } + size_t remain = node->size - (size_t)in->offset; + size_t to_copy = in->size; + if (to_copy > remain) { + to_copy = remain; + } + return fuse_write_reply(a->fd, h->unique, 0, node->data + in->offset, to_copy); + } + case FUSE_READDIR: { + if (payload_len < sizeof(struct fuse_read_in)) { + return -1; + } + const struct fuse_read_in *in = (const struct fuse_read_in *)payload; + (void)in; + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node || !node->is_dir) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + + /* offset is an entry index: 0=".", 1="..", then children */ + uint64_t idx = in->offset; + unsigned char outbuf[65536]; + size_t outlen = 0; + + const char *fixed_names[2] = {".", ".."}; + for (; idx < 2; idx++) { + const char *nm = fixed_names[idx]; + size_t nmlen = strlen(nm); + size_t reclen = fuse_dirent_rec_len(nmlen); + if (outlen + reclen > sizeof(outbuf)) + break; + struct fuse_dirent de; + memset(&de, 0, sizeof(de)); + de.ino = 1; + de.off = idx + 1; + de.namelen = (uint32_t)nmlen; + de.type = DT_DIR; + memcpy(outbuf + outlen, &de, sizeof(de)); + memcpy(outbuf + outlen + sizeof(de), nm, nmlen); + outlen += reclen; + } + + /* children in insertion order */ + uint64_t child_base = 2; + uint64_t cur = idx; + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + struct simplefs_node *c = &a->fs.nodes[i]; + if (!c->used || c->parent != h->nodeid) + continue; + if (cur < child_base) { + cur = child_base; + } + if (cur > child_base) { + /* skip until we reach this entry index */ + child_base++; + continue; + } + + size_t nmlen = strlen(c->name); + size_t reclen = fuse_dirent_rec_len(nmlen); + if (outlen + reclen > sizeof(outbuf)) + break; + struct fuse_dirent de; + memset(&de, 0, sizeof(de)); + de.ino = c->ino; + de.off = child_base + 1; + de.namelen = (uint32_t)nmlen; + de.type = c->is_dir ? DT_DIR : DT_REG; + memcpy(outbuf + outlen, &de, sizeof(de)); + memcpy(outbuf + outlen + sizeof(de), c->name, nmlen); + outlen += reclen; + + child_base++; + cur++; + } + + return fuse_write_reply(a->fd, h->unique, 0, outbuf, outlen); + } + case FUSE_RELEASE: + case FUSE_RELEASEDIR: + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_WRITE: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_write_in)) { + return -1; + } + const struct fuse_write_in *in = (const struct fuse_write_in *)payload; + const unsigned char *data = payload + sizeof(*in); + size_t data_len = payload_len - sizeof(*in); + if (data_len < in->size) { + return -1; + } + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node || node->is_dir) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } + if (in->offset >= SIMPLEFS_DATA_MAX) { + return fuse_write_reply(a->fd, h->unique, -EFBIG, NULL, 0); + } + size_t to_copy = in->size; + if (in->offset + to_copy > SIMPLEFS_DATA_MAX) { + to_copy = SIMPLEFS_DATA_MAX - (size_t)in->offset; + } + memcpy(node->data + in->offset, data, to_copy); + if (node->size < in->offset + to_copy) { + node->size = (size_t)in->offset + to_copy; + } + struct fuse_write_out out; + memset(&out, 0, sizeof(out)); + out.size = (uint32_t)to_copy; + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_MKDIR: + case FUSE_MKNOD: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + const char *name = NULL; + size_t name_off = 0; + int is_dir = (h->opcode == FUSE_MKDIR); + uint32_t mode = 0; + if (is_dir) { + if (payload_len < sizeof(struct fuse_mkdir_in) + 1) + return -1; + const struct fuse_mkdir_in *in = (const struct fuse_mkdir_in *)payload; + mode = in->mode; + name_off = sizeof(*in); + } else { + if (payload_len < sizeof(struct fuse_mknod_in) + 1) + return -1; + const struct fuse_mknod_in *in = (const struct fuse_mknod_in *)payload; + mode = in->mode; + name_off = sizeof(*in); + } + name = (const char *)(payload + name_off); + if (name[payload_len - name_off - 1] != '\0') + return -1; + if (simplefs_find_child(&a->fs, h->nodeid, name)) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + struct simplefs_node *p = simplefs_find_node(&a->fs, h->nodeid); + if (!p || !p->is_dir) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + struct simplefs_node *nnode = simplefs_alloc(&a->fs); + if (!nnode) { + return fuse_write_reply(a->fd, h->unique, -ENOSPC, NULL, 0); + } + nnode->parent = h->nodeid; + nnode->is_dir = is_dir; + nnode->mode = mode; + strncpy(nnode->name, name, sizeof(nnode->name) - 1); + nnode->size = 0; + + struct fuse_entry_out out; + memset(&out, 0, sizeof(out)); + out.nodeid = nnode->nodeid; + simplefs_fill_attr(nnode, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_UNLINK: + case FUSE_RMDIR: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + const char *name = (const char *)payload; + if (payload_len == 0 || name[payload_len - 1] != '\0') { + return -1; + } + struct simplefs_node *child = simplefs_find_child(&a->fs, h->nodeid, name); + if (!child) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (h->opcode == FUSE_RMDIR) { + if (!child->is_dir) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (simplefs_has_children(&a->fs, child->nodeid)) { + return fuse_write_reply(a->fd, h->unique, -ENOTEMPTY, NULL, 0); + } + } else { + if (child->is_dir) { + return fuse_write_reply(a->fd, h->unique, -EISDIR, NULL, 0); + } + } + child->used = 0; + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } + case FUSE_RENAME: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_rename_in) + 3) { + return -1; + } + const struct fuse_rename_in *in = (const struct fuse_rename_in *)payload; + const char *names = (const char *)(payload + sizeof(*in)); + size_t names_len = payload_len - sizeof(*in); + if (names[names_len - 1] != '\0') { + return -1; + } + const char *oldname = names; + const char *newname = oldname + strlen(oldname) + 1; + if (newname >= names + names_len) { + return -1; + } + struct simplefs_node *src = simplefs_find_child(&a->fs, h->nodeid, oldname); + if (!src) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (simplefs_find_child(&a->fs, in->newdir, newname)) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + src->parent = in->newdir; + strncpy(src->name, newname, sizeof(src->name) - 1); + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } + case FUSE_SETATTR: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_setattr_in)) { + return -1; + } + const struct fuse_setattr_in *in = (const struct fuse_setattr_in *)payload; + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (in->valid & FATTR_SIZE) { + if (in->size > SIMPLEFS_DATA_MAX) { + return fuse_write_reply(a->fd, h->unique, -EFBIG, NULL, 0); + } + node->size = (size_t)in->size; + } + if (in->valid & FATTR_MODE) { + node->mode = in->mode; + } + struct fuse_attr_out out; + memset(&out, 0, sizeof(out)); + simplefs_fill_attr(node, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + default: + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } +} + +static inline void *fuse_daemon_thread(void *arg) { + struct fuse_daemon_args *a = (struct fuse_daemon_args *)arg; + unsigned char buf[65536]; + + simplefs_init(&a->fs); + + while (!*a->stop) { + ssize_t n = read(a->fd, buf, sizeof(buf)); + if (n < 0) { + if (errno == EINTR) + continue; + if (errno == ENOTCONN) + break; + continue; + } + if (n == 0) { + break; + } + struct fuse_in_header *h = (struct fuse_in_header *)buf; + if ((size_t)n != h->len) { + continue; + } + (void)fuse_handle_one(a, buf, (size_t)n); + } + return NULL; +} + +static inline int ensure_dir(const char *path) { + struct stat st; + if (stat(path, &st) == 0) { + if (S_ISDIR(st.st_mode)) + return 0; + errno = ENOTDIR; + return -1; + } + return mkdir(path, 0755); +} + diff --git a/user/apps/c_unitest/test_fuse_phase_c.c b/user/apps/c_unitest/test_fuse_phase_c.c new file mode 100644 index 0000000000..412e048988 --- /dev/null +++ b/user/apps/c_unitest/test_fuse_phase_c.c @@ -0,0 +1,151 @@ +/** + * @file test_fuse_phase_c.c + * @brief Phase C integration test: LOOKUP/GETATTR/READDIR/OPEN/READ path. + */ + +#include "fuse_test_simplefs.h" + +static int read_all(const char *path, char *buf, size_t cap) { + int fd = open(path, O_RDONLY); + if (fd < 0) + return -1; + ssize_t n = read(fd, buf, cap); + close(fd); + if (n < 0) + return -1; + return (int)n; +} + +int main(void) { + const char *mp = "/tmp/test_fuse_c"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return 1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + return 1; + } + + volatile int stop = 0; + volatile int init_done = 0; + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + return 1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + /* wait init */ + for (int i = 0; i < 100; i++) { + if (init_done) + break; + usleep(10 * 1000); + } + if (!init_done) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + /* readdir */ + DIR *d = opendir(mp); + if (!d) { + printf("[FAIL] opendir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + int found = 0; + struct dirent *de; + while ((de = readdir(d)) != NULL) { + if (strcmp(de->d_name, "hello.txt") == 0) { + found = 1; + break; + } + } + closedir(d); + if (!found) { + printf("[FAIL] readdir: hello.txt not found\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + /* stat + cat */ + char p[256]; + snprintf(p, sizeof(p), "%s/hello.txt", mp); + + struct stat st; + if (stat(p, &st) != 0) { + printf("[FAIL] stat(%s): %s (errno=%d)\n", p, strerror(errno), errno); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + if (!S_ISREG(st.st_mode)) { + printf("[FAIL] stat: expected regular file\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + char buf[128]; + int n = read_all(p, buf, sizeof(buf) - 1); + if (n < 0) { + printf("[FAIL] read(%s): %s (errno=%d)\n", p, strerror(errno), errno); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + buf[n] = '\0'; + if (strcmp(buf, "hello from fuse\n") != 0) { + printf("[FAIL] content mismatch: got='%s'\n", buf); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + umount(mp); + rmdir(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + printf("[PASS] fuse_phase_c\n"); + return 0; +} + diff --git a/user/apps/c_unitest/test_fuse_phase_d.c b/user/apps/c_unitest/test_fuse_phase_d.c new file mode 100644 index 0000000000..6077108dc2 --- /dev/null +++ b/user/apps/c_unitest/test_fuse_phase_d.c @@ -0,0 +1,159 @@ +/** + * @file test_fuse_phase_d.c + * @brief Phase D integration test: create/write/ftruncate/rename/unlink/mkdir/rmdir. + */ + +#include "fuse_test_simplefs.h" + +static int write_all(const char *path, const char *s) { + int fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644); + if (fd < 0) + return -1; + size_t len = strlen(s); + ssize_t wn = write(fd, s, len); + if (wn != (ssize_t)len) { + close(fd); + return -1; + } + close(fd); + return 0; +} + +static int read_all(const char *path, char *buf, size_t cap) { + int fd = open(path, O_RDONLY); + if (fd < 0) + return -1; + ssize_t n = read(fd, buf, cap); + close(fd); + if (n < 0) + return -1; + return (int)n; +} + +int main(void) { + const char *mp = "/tmp/test_fuse_d"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return 1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + return 1; + } + + volatile int stop = 0; + volatile int init_done = 0; + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 1; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + return 1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + for (int i = 0; i < 100; i++) { + if (init_done) + break; + usleep(10 * 1000); + } + if (!init_done) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + char p1[256]; + snprintf(p1, sizeof(p1), "%s/new.txt", mp); + if (write_all(p1, "abcdef") != 0) { + printf("[FAIL] write_all(%s): %s (errno=%d)\n", p1, strerror(errno), errno); + goto fail; + } + + /* ftruncate to 3 */ + int f = open(p1, O_RDWR); + if (f < 0) { + printf("[FAIL] open for truncate: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (ftruncate(f, 3) != 0) { + printf("[FAIL] ftruncate: %s (errno=%d)\n", strerror(errno), errno); + close(f); + goto fail; + } + close(f); + + char buf[64]; + int n = read_all(p1, buf, sizeof(buf) - 1); + if (n < 0) { + printf("[FAIL] read_all after truncate: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + buf[n] = '\0'; + if (strcmp(buf, "abc") != 0) { + printf("[FAIL] truncate content mismatch got='%s'\n", buf); + goto fail; + } + + /* rename */ + char p2[256]; + snprintf(p2, sizeof(p2), "%s/renamed.txt", mp); + if (rename(p1, p2) != 0) { + printf("[FAIL] rename: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + + /* unlink */ + if (unlink(p2) != 0) { + printf("[FAIL] unlink: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + + /* mkdir + rmdir */ + char d1[256]; + snprintf(d1, sizeof(d1), "%s/dir", mp); + if (mkdir(d1, 0755) != 0) { + printf("[FAIL] mkdir: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (rmdir(d1) != 0) { + printf("[FAIL] rmdir: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + + umount(mp); + rmdir(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + printf("[PASS] fuse_phase_d\n"); + return 0; + +fail: + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; +} + From 5e5421635898666ad1ce080f2d4c8293827b29ba Mon Sep 17 00:00:00 2001 From: longjin Date: Thu, 5 Feb 2026 19:44:03 +0800 Subject: [PATCH 03/16] 1 --- kernel/src/filesystem/fuse/conn.rs | 93 +++++++++++++++++++----- kernel/src/filesystem/fuse/dev.rs | 28 ++++--- kernel/src/filesystem/fuse/fs.rs | 7 +- kernel/src/filesystem/fuse/inode.rs | 2 +- kernel/src/filesystem/vfs/mod.rs | 4 + kernel/src/filesystem/vfs/mount.rs | 3 + user/apps/c_unitest/Makefile | 13 +--- user/apps/c_unitest/fuse_test_simplefs.h | 71 +++++++++++++++--- user/apps/c_unitest/test_fuse_phase_c.c | 14 +++- user/apps/c_unitest/test_fuse_phase_d.c | 23 +++++- 10 files changed, 204 insertions(+), 54 deletions(-) diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs index 533d4dbbfd..b5939e4867 100644 --- a/kernel/src/filesystem/fuse/conn.rs +++ b/kernel/src/filesystem/fuse/conn.rs @@ -8,7 +8,10 @@ use crate::{ filesystem::epoll::{ event_poll::EventPoll, event_poll::LockedEPItemLinkedList, EPollEventType, EPollItem, }, - libs::{mutex::Mutex, wait_queue::WaitQueue}, + libs::{ + mutex::Mutex, + wait_queue::{WaitQueue, Waiter}, + }, process::ProcessManager, }; @@ -50,12 +53,30 @@ impl FusePendingState { } pub fn wait_complete(&self) -> Result, SystemError> { - match self - .wait - .wait_until_interruptible(|| self.response.lock().take())? - { - Some(v) => v, - None => Err(SystemError::EIO), + // Avoid TOCTOU between response update and wait queue registration. + if let Some(res) = self.response.lock().take() { + return res; + } + loop { + let mut guard = self.response.lock(); + if let Some(res) = guard.take() { + return res; + } + + let (waiter, waker) = Waiter::new_pair(); + self.wait.register_waker(waker.clone())?; + + // Re-check under the same lock after registering. + if let Some(res) = guard.take() { + self.wait.remove_waker(&waker); + return res; + } + drop(guard); + + if let Err(e) = waiter.wait(true) { + self.wait.remove_waker(&waker); + return Err(e); + } } } } @@ -126,16 +147,34 @@ impl FuseConn { if self.is_initialized() { return Ok(()); } - self.init_wait.wait_until_interruptible(|| { - let g = self.inner.lock(); + // Bind condition checks to inner lock and register waker before releasing it. + loop { + let mut g = self.inner.lock(); + if !g.connected { + return Err(SystemError::ENOTCONN); + } + if g.initialized { + return Ok(()); + } + + let (waiter, waker) = Waiter::new_pair(); + self.init_wait.register_waker(waker.clone())?; + if !g.connected { - return Some(Err(SystemError::ENOTCONN)); + self.init_wait.remove_waker(&waker); + return Err(SystemError::ENOTCONN); } if g.initialized { - return Some(Ok(())); + self.init_wait.remove_waker(&waker); + return Ok(()); + } + drop(g); + + if let Err(e) = waiter.wait(true) { + self.init_wait.remove_waker(&waker); + return Err(e); } - None - })? + } } pub fn abort(&self) { @@ -204,13 +243,33 @@ impl FuseConn { .pop_front() .ok_or(SystemError::EAGAIN_OR_EWOULDBLOCK)? } else { - self.read_wait.wait_until_interruptible(|| { + loop { let mut g = self.inner.lock(); if !g.connected { - return Some(Err(SystemError::ENOTCONN)); + return Err(SystemError::ENOTCONN); } - g.pending.pop_front().map(Ok) - })?? + if let Some(req) = g.pending.pop_front() { + break req; + } + + let (waiter, waker) = Waiter::new_pair(); + self.read_wait.register_waker(waker.clone())?; + + if !g.connected { + self.read_wait.remove_waker(&waker); + return Err(SystemError::ENOTCONN); + } + if let Some(req) = g.pending.pop_front() { + self.read_wait.remove_waker(&waker); + break req; + } + drop(g); + + if let Err(e) = waiter.wait(true) { + self.read_wait.remove_waker(&waker); + return Err(e); + } + } }; if out.len() < req.bytes.len() { diff --git a/kernel/src/filesystem/fuse/dev.rs b/kernel/src/filesystem/fuse/dev.rs index aafacef313..43e3d23a5b 100644 --- a/kernel/src/filesystem/fuse/dev.rs +++ b/kernel/src/filesystem/fuse/dev.rs @@ -159,15 +159,18 @@ impl IndexNode for LockedFuseDevInode { if buf.len() < len { return Err(SystemError::EINVAL); } - let FilePrivateData::FuseDev(p) = &*data else { - return Err(SystemError::EINVAL); + let (conn_any, nonblock) = { + let FilePrivateData::FuseDev(p) = &*data else { + return Err(SystemError::EINVAL); + }; + (p.conn.clone(), p.nonblock) }; - let conn = p - .conn - .clone() + // Drop private_data lock before potentially blocking in read_request(). + drop(data); + let conn = conn_any .downcast::() .map_err(|_| SystemError::EINVAL)?; - conn.read_request(p.nonblock, &mut buf[..len]) + conn.read_request(nonblock, &mut buf[..len]) } fn write_at( @@ -180,12 +183,15 @@ impl IndexNode for LockedFuseDevInode { if buf.len() < len { return Err(SystemError::EINVAL); } - let FilePrivateData::FuseDev(p) = &*data else { - return Err(SystemError::EINVAL); + let conn_any = { + let FilePrivateData::FuseDev(p) = &*data else { + return Err(SystemError::EINVAL); + }; + p.conn.clone() }; - let conn = p - .conn - .clone() + // Drop private_data lock before potentially blocking in write_reply(). + drop(data); + let conn = conn_any .downcast::() .map_err(|_| SystemError::EINVAL)?; conn.write_reply(&buf[..len]) diff --git a/kernel/src/filesystem/fuse/fs.rs b/kernel/src/filesystem/fuse/fs.rs index 391621c39f..8430a62f9e 100644 --- a/kernel/src/filesystem/fuse/fs.rs +++ b/kernel/src/filesystem/fuse/fs.rs @@ -1,8 +1,6 @@ use alloc::{ collections::BTreeMap, - string::String, sync::{Arc, Weak}, - vec::Vec, }; use system_error::SystemError; @@ -243,4 +241,9 @@ impl FileSystem for FuseFS { fn super_block(&self) -> SuperBlock { self.super_block.clone() } + + fn on_umount(&self) { + // Abort pending/blocked requests to wake daemon thread on unmount. + self.conn.abort(); + } } diff --git a/kernel/src/filesystem/fuse/inode.rs b/kernel/src/filesystem/fuse/inode.rs index 982adf7a5b..bb11e43ba7 100644 --- a/kernel/src/filesystem/fuse/inode.rs +++ b/kernel/src/filesystem/fuse/inode.rs @@ -105,7 +105,7 @@ impl FuseNode { Metadata { dev_id: 0, inode_id, - size: attr.size as usize, + size: attr.size as i64, blk_size: attr.blksize as usize, blocks: attr.blocks as usize, atime: PosixTimeSpec::new(attr.atime as i64, attr.atimensec as i64), diff --git a/kernel/src/filesystem/vfs/mod.rs b/kernel/src/filesystem/vfs/mod.rs index 5ec5a93b43..83a3b23079 100644 --- a/kernel/src/filesystem/vfs/mod.rs +++ b/kernel/src/filesystem/vfs/mod.rs @@ -1310,6 +1310,10 @@ pub trait FileSystem: Any + Sync + Send + Debug { fn super_block(&self) -> SuperBlock; + /// Called after a filesystem is successfully unmounted. + /// Default is no-op. + fn on_umount(&self) {} + unsafe fn fault(&self, _pfm: &mut PageFaultMessage) -> VmFaultReason { VmFaultReason::VM_FAULT_SIGBUS } diff --git a/kernel/src/filesystem/vfs/mount.rs b/kernel/src/filesystem/vfs/mount.rs index 39eeee7480..191edb9ebc 100644 --- a/kernel/src/filesystem/vfs/mount.rs +++ b/kernel/src/filesystem/vfs/mount.rs @@ -414,6 +414,9 @@ impl MountFS { self.self_mountpoint.write().take(); + // Notify the filesystem that it has been unmounted. + self.inner_filesystem.on_umount(); + return r; } } diff --git a/user/apps/c_unitest/Makefile b/user/apps/c_unitest/Makefile index b78106934c..909d977488 100644 --- a/user/apps/c_unitest/Makefile +++ b/user/apps/c_unitest/Makefile @@ -11,26 +11,19 @@ CFLAGS := -Wall -O2 -static -lpthread SRCS := $(wildcard *.c) BINS := $(SRCS:.c=) - - -$(C_TARGETS): %.o: %.c - $(CC) -c $< -o $@ - all: $(BINS) # @echo "src: $(SRCS)" @echo "bins: $(BINS)" -%: %.c - $(CC) $(CFLAGS) $< -o $@ - +# 依赖同目录下所有 .h，任意头文件变更都会触发重编 +%: %.c $(wildcard *.h) + $(CC) $(CFLAGS) $< -o $@ install: all @echo "Installing binaries to $(DADK_CURRENT_BUILD_DIR)/" mv $(BINS) $(DADK_CURRENT_BUILD_DIR)/ - clean: rm -f $(BINS) - .PHONY: all install clean diff --git a/user/apps/c_unitest/fuse_test_simplefs.h b/user/apps/c_unitest/fuse_test_simplefs.h index 60a7392019..aba665f88b 100644 --- a/user/apps/c_unitest/fuse_test_simplefs.h +++ b/user/apps/c_unitest/fuse_test_simplefs.h @@ -23,6 +23,26 @@ #include #include +#define FUSE_TEST_LOG_PREFIX "[fuse-test] " + +static inline int fuse_test_log_enabled(void) { + static int inited = 0; + static int enabled = 0; + if (!inited) { + const char *v = getenv("FUSE_TEST_LOG"); + enabled = (v && v[0] && strcmp(v, "0") != 0); + inited = 1; + } + return enabled; +} + +#define FUSE_TEST_LOG(fmt, ...) \ + do { \ + if (fuse_test_log_enabled()) { \ + fprintf(stderr, FUSE_TEST_LOG_PREFIX fmt "\n", ##__VA_ARGS__); \ + } \ + } while (0) + #ifndef DT_DIR #define DT_DIR 4 #endif @@ -30,6 +50,9 @@ #define DT_REG 8 #endif +/* Keep test buffers off small thread stacks. */ +#define FUSE_TEST_BUF_SIZE (64 * 1024) + /* Opcodes (subset) */ #ifndef FUSE_LOOKUP #define FUSE_LOOKUP 1 @@ -388,17 +411,27 @@ static inline int fuse_write_reply(int fd, uint64_t unique, int32_t err_neg, out.error = err_neg; out.unique = unique; - unsigned char buf[65536]; - if (sizeof(out) + payload_len > sizeof(buf)) { + size_t total = sizeof(out) + payload_len; + if (total > FUSE_TEST_BUF_SIZE) { errno = E2BIG; return -1; } + unsigned char *buf = malloc(total); + if (!buf) { + errno = ENOMEM; + return -1; + } memcpy(buf, &out, sizeof(out)); if (payload_len) { memcpy(buf + sizeof(out), payload, payload_len); } - ssize_t wn = write(fd, buf, sizeof(out) + payload_len); - if (wn != (ssize_t)(sizeof(out) + payload_len)) { + ssize_t wn = write(fd, buf, total); + free(buf); + if (wn == (ssize_t)total) { + FUSE_TEST_LOG("reply unique=%llu err=%d len=%zu", + (unsigned long long)unique, (int)err_neg, total); + } + if (wn != (ssize_t)total) { return -1; } return 0; @@ -419,6 +452,9 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha const struct fuse_in_header *h = (const struct fuse_in_header *)req; const unsigned char *payload = req + sizeof(*h); size_t payload_len = n - sizeof(*h); + FUSE_TEST_LOG("handle opcode=%u unique=%llu nodeid=%llu len=%u payload=%zu", + h->opcode, (unsigned long long)h->unique, (unsigned long long)h->nodeid, + h->len, payload_len); switch (h->opcode) { case FUSE_INIT: { @@ -515,7 +551,10 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha /* offset is an entry index: 0=".", 1="..", then children */ uint64_t idx = in->offset; - unsigned char outbuf[65536]; + unsigned char *outbuf = malloc(FUSE_TEST_BUF_SIZE); + if (!outbuf) { + return fuse_write_reply(a->fd, h->unique, -ENOMEM, NULL, 0); + } size_t outlen = 0; const char *fixed_names[2] = {".", ".."}; @@ -523,7 +562,7 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha const char *nm = fixed_names[idx]; size_t nmlen = strlen(nm); size_t reclen = fuse_dirent_rec_len(nmlen); - if (outlen + reclen > sizeof(outbuf)) + if (outlen + reclen > FUSE_TEST_BUF_SIZE) break; struct fuse_dirent de; memset(&de, 0, sizeof(de)); @@ -554,7 +593,7 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha size_t nmlen = strlen(c->name); size_t reclen = fuse_dirent_rec_len(nmlen); - if (outlen + reclen > sizeof(outbuf)) + if (outlen + reclen > FUSE_TEST_BUF_SIZE) break; struct fuse_dirent de; memset(&de, 0, sizeof(de)); @@ -570,7 +609,9 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha cur++; } - return fuse_write_reply(a->fd, h->unique, 0, outbuf, outlen); + int ret = fuse_write_reply(a->fd, h->unique, 0, outbuf, outlen); + free(outbuf); + return ret; } case FUSE_RELEASE: case FUSE_RELEASEDIR: @@ -746,13 +787,18 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha static inline void *fuse_daemon_thread(void *arg) { struct fuse_daemon_args *a = (struct fuse_daemon_args *)arg; - unsigned char buf[65536]; + unsigned char *buf = malloc(FUSE_TEST_BUF_SIZE); + if (!buf) { + return NULL; + } simplefs_init(&a->fs); while (!*a->stop) { - ssize_t n = read(a->fd, buf, sizeof(buf)); + FUSE_TEST_LOG("daemon read start"); + ssize_t n = read(a->fd, buf, FUSE_TEST_BUF_SIZE); if (n < 0) { + FUSE_TEST_LOG("daemon read error n=%zd errno=%d", n, errno); if (errno == EINTR) continue; if (errno == ENOTCONN) @@ -760,14 +806,18 @@ static inline void *fuse_daemon_thread(void *arg) { continue; } if (n == 0) { + FUSE_TEST_LOG("daemon read EOF"); break; } + FUSE_TEST_LOG("daemon read n=%zd", n); struct fuse_in_header *h = (struct fuse_in_header *)buf; if ((size_t)n != h->len) { + FUSE_TEST_LOG("daemon short read n=%zd hdr.len=%u", n, h->len); continue; } (void)fuse_handle_one(a, buf, (size_t)n); } + free(buf); return NULL; } @@ -781,4 +831,3 @@ static inline int ensure_dir(const char *path) { } return mkdir(path, 0755); } - diff --git a/user/apps/c_unitest/test_fuse_phase_c.c b/user/apps/c_unitest/test_fuse_phase_c.c index 412e048988..4a4df77588 100644 --- a/user/apps/c_unitest/test_fuse_phase_c.c +++ b/user/apps/c_unitest/test_fuse_phase_c.c @@ -47,6 +47,7 @@ int main(void) { char opts[256]; snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + FUSE_TEST_LOG("step: mount start"); if (mount("none", mp, "fuse", 0, opts) != 0) { printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); stop = 1; @@ -54,6 +55,7 @@ int main(void) { pthread_join(th, NULL); return 1; } + FUSE_TEST_LOG("step: mount ok"); /* wait init */ for (int i = 0; i < 100; i++) { @@ -69,8 +71,10 @@ int main(void) { pthread_join(th, NULL); return 1; } + FUSE_TEST_LOG("step: init ok"); /* readdir */ + FUSE_TEST_LOG("step: opendir start"); DIR *d = opendir(mp); if (!d) { printf("[FAIL] opendir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); @@ -80,6 +84,7 @@ int main(void) { pthread_join(th, NULL); return 1; } + FUSE_TEST_LOG("step: readdir loop start"); int found = 0; struct dirent *de; while ((de = readdir(d)) != NULL) { @@ -88,6 +93,7 @@ int main(void) { break; } } + FUSE_TEST_LOG("step: readdir loop end"); closedir(d); if (!found) { printf("[FAIL] readdir: hello.txt not found\n"); @@ -103,6 +109,7 @@ int main(void) { snprintf(p, sizeof(p), "%s/hello.txt", mp); struct stat st; + FUSE_TEST_LOG("step: stat start"); if (stat(p, &st) != 0) { printf("[FAIL] stat(%s): %s (errno=%d)\n", p, strerror(errno), errno); umount(mp); @@ -111,6 +118,7 @@ int main(void) { pthread_join(th, NULL); return 1; } + FUSE_TEST_LOG("step: stat ok"); if (!S_ISREG(st.st_mode)) { printf("[FAIL] stat: expected regular file\n"); umount(mp); @@ -121,6 +129,7 @@ int main(void) { } char buf[128]; + FUSE_TEST_LOG("step: read start"); int n = read_all(p, buf, sizeof(buf) - 1); if (n < 0) { printf("[FAIL] read(%s): %s (errno=%d)\n", p, strerror(errno), errno); @@ -130,6 +139,7 @@ int main(void) { pthread_join(th, NULL); return 1; } + FUSE_TEST_LOG("step: read ok"); buf[n] = '\0'; if (strcmp(buf, "hello from fuse\n") != 0) { printf("[FAIL] content mismatch: got='%s'\n", buf); @@ -140,12 +150,14 @@ int main(void) { return 1; } + FUSE_TEST_LOG("step: umount start"); umount(mp); + FUSE_TEST_LOG("step: umount ok"); rmdir(mp); + FUSE_TEST_LOG("step: rmdir ok"); stop = 1; close(fd); pthread_join(th, NULL); printf("[PASS] fuse_phase_c\n"); return 0; } - diff --git a/user/apps/c_unitest/test_fuse_phase_d.c b/user/apps/c_unitest/test_fuse_phase_d.c index 6077108dc2..602a9f141e 100644 --- a/user/apps/c_unitest/test_fuse_phase_d.c +++ b/user/apps/c_unitest/test_fuse_phase_d.c @@ -61,6 +61,7 @@ int main(void) { char opts[256]; snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + FUSE_TEST_LOG("step: mount start"); if (mount("none", mp, "fuse", 0, opts) != 0) { printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); stop = 1; @@ -68,6 +69,7 @@ int main(void) { pthread_join(th, NULL); return 1; } + FUSE_TEST_LOG("step: mount ok"); for (int i = 0; i < 100; i++) { if (init_done) @@ -82,33 +84,42 @@ int main(void) { pthread_join(th, NULL); return 1; } + FUSE_TEST_LOG("step: init ok"); char p1[256]; snprintf(p1, sizeof(p1), "%s/new.txt", mp); + FUSE_TEST_LOG("step: write_all start"); if (write_all(p1, "abcdef") != 0) { printf("[FAIL] write_all(%s): %s (errno=%d)\n", p1, strerror(errno), errno); goto fail; } + FUSE_TEST_LOG("step: write_all ok"); /* ftruncate to 3 */ + FUSE_TEST_LOG("step: ftruncate open start"); int f = open(p1, O_RDWR); if (f < 0) { printf("[FAIL] open for truncate: %s (errno=%d)\n", strerror(errno), errno); goto fail; } + FUSE_TEST_LOG("step: ftruncate call start"); if (ftruncate(f, 3) != 0) { printf("[FAIL] ftruncate: %s (errno=%d)\n", strerror(errno), errno); close(f); goto fail; } + FUSE_TEST_LOG("step: ftruncate call ok"); close(f); + FUSE_TEST_LOG("step: ftruncate close ok"); char buf[64]; + FUSE_TEST_LOG("step: read_all start"); int n = read_all(p1, buf, sizeof(buf) - 1); if (n < 0) { printf("[FAIL] read_all after truncate: %s (errno=%d)\n", strerror(errno), errno); goto fail; } + FUSE_TEST_LOG("step: read_all ok"); buf[n] = '\0'; if (strcmp(buf, "abc") != 0) { printf("[FAIL] truncate content mismatch got='%s'\n", buf); @@ -118,31 +129,42 @@ int main(void) { /* rename */ char p2[256]; snprintf(p2, sizeof(p2), "%s/renamed.txt", mp); + FUSE_TEST_LOG("step: rename start"); if (rename(p1, p2) != 0) { printf("[FAIL] rename: %s (errno=%d)\n", strerror(errno), errno); goto fail; } + FUSE_TEST_LOG("step: rename ok"); /* unlink */ + FUSE_TEST_LOG("step: unlink start"); if (unlink(p2) != 0) { printf("[FAIL] unlink: %s (errno=%d)\n", strerror(errno), errno); goto fail; } + FUSE_TEST_LOG("step: unlink ok"); /* mkdir + rmdir */ char d1[256]; snprintf(d1, sizeof(d1), "%s/dir", mp); + FUSE_TEST_LOG("step: mkdir start"); if (mkdir(d1, 0755) != 0) { printf("[FAIL] mkdir: %s (errno=%d)\n", strerror(errno), errno); goto fail; } + FUSE_TEST_LOG("step: mkdir ok"); + FUSE_TEST_LOG("step: rmdir start"); if (rmdir(d1) != 0) { printf("[FAIL] rmdir: %s (errno=%d)\n", strerror(errno), errno); goto fail; } + FUSE_TEST_LOG("step: rmdir ok"); + FUSE_TEST_LOG("step: umount start"); umount(mp); + FUSE_TEST_LOG("step: umount ok"); rmdir(mp); + FUSE_TEST_LOG("step: rmdir mp ok"); stop = 1; close(fd); pthread_join(th, NULL); @@ -156,4 +178,3 @@ int main(void) { pthread_join(th, NULL); return 1; } - From ec841de4a99705d1281df404e5b0ed5335412c39 Mon Sep 17 00:00:00 2001 From: longjin Date: Sat, 7 Feb 2026 21:51:02 +0800 Subject: [PATCH 04/16] =?UTF-8?q?feat(fuse):=20=E5=AE=9E=E7=8E=B0FUSE?= =?UTF-8?q?=E6=9D=83=E9=99=90=E6=8E=A7=E5=88=B6=E3=80=81=E8=AE=BE=E5=A4=87?= =?UTF-8?q?=E5=85=8B=E9=9A=86=E5=92=8C=E6=96=87=E4=BB=B6=E7=B3=BB=E7=BB=9F?= =?UTF-8?q?=E7=BB=9F=E8=AE=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 新增FUSE权限控制机制，支持allow_other和default_permissions挂载选项 - 实现FUSE_DEV_IOC_CLONE设备克隆功能，支持多线程FUSE守护进程 - 添加FUSE_STATFS协议支持，完善文件系统统计信息 - 重构VFS权限检查，支持基于文件系统的权限策略（DAC/Remote） - 新增用户态测试程序，验证权限控制、设备克隆和统计功能 - 清理未使用的日志导入，优化代码结构 Signed-off-by: longjin --- kernel/src/arch/x86_64/init/mod.rs | 2 +- kernel/src/driver/clocksource/tsc.rs | 3 +- kernel/src/filesystem/fuse/conn.rs | 94 +- kernel/src/filesystem/fuse/dev.rs | 59 +- kernel/src/filesystem/fuse/fs.rs | 82 +- kernel/src/filesystem/fuse/inode.rs | 45 +- kernel/src/filesystem/fuse/protocol.rs | 22 + kernel/src/filesystem/vfs/mod.rs | 33 +- kernel/src/filesystem/vfs/mount.rs | 15 + kernel/src/filesystem/vfs/open.rs | 15 +- kernel/src/filesystem/vfs/permission.rs | 33 + .../src/filesystem/vfs/syscall/link_utils.rs | 22 +- .../filesystem/vfs/syscall/rename_utils.rs | 14 +- .../src/filesystem/vfs/syscall/sys_chdir.rs | 71 +- .../src/filesystem/vfs/syscall/sys_chroot.rs | 7 +- .../src/filesystem/vfs/syscall/sys_fchdir.rs | 11 +- .../src/filesystem/vfs/syscall/sys_fstatfs.rs | 4 +- .../src/filesystem/vfs/syscall/sys_statfs.rs | 3 +- .../filesystem/vfs/syscall/sys_truncate.rs | 8 +- kernel/src/filesystem/vfs/vcore.rs | 33 +- user/apps/c_unitest/fuse_test_simplefs.h | 60 +- user/apps/c_unitest/test_fuse_clone.c | 185 ++++ user/apps/c_unitest/test_fuse_permissions.c | 172 ++++ user/apps/fuse_demo/Makefile | 27 + user/apps/fuse_demo/README.md | 74 ++ user/apps/fuse_demo/fuse_demo.c | 189 ++++ user/apps/fuse_demo/fuse_test_simplefs.h | 899 ++++++++++++++++++ user/apps/tests/syscall/gvisor/whitelist.txt | 1 + user/dadk/config/fuse_demo.toml | 36 + 29 files changed, 2088 insertions(+), 131 deletions(-) create mode 100644 user/apps/c_unitest/test_fuse_clone.c create mode 100644 user/apps/c_unitest/test_fuse_permissions.c create mode 100644 user/apps/fuse_demo/Makefile create mode 100644 user/apps/fuse_demo/README.md create mode 100644 user/apps/fuse_demo/fuse_demo.c create mode 100644 user/apps/fuse_demo/fuse_test_simplefs.h create mode 100644 user/dadk/config/fuse_demo.toml diff --git a/kernel/src/arch/x86_64/init/mod.rs b/kernel/src/arch/x86_64/init/mod.rs index 3bcf0ebb35..be1c994dbd 100644 --- a/kernel/src/arch/x86_64/init/mod.rs +++ b/kernel/src/arch/x86_64/init/mod.rs @@ -3,7 +3,7 @@ use core::{ sync::atomic::{compiler_fence, Ordering}, }; -use log::{debug, info}; +use log::debug; use system_error::SystemError; use x86::dtables::DescriptorTablePointer; diff --git a/kernel/src/driver/clocksource/tsc.rs b/kernel/src/driver/clocksource/tsc.rs index d19fc44e4d..0fdfcfd418 100644 --- a/kernel/src/driver/clocksource/tsc.rs +++ b/kernel/src/driver/clocksource/tsc.rs @@ -2,7 +2,7 @@ use alloc::{ string::ToString, sync::{Arc, Weak}, }; -use log::{info, warn}; +use log::warn; use system_error::SystemError; use crate::{ @@ -16,6 +16,7 @@ use crate::{ pub static mut CLOCKSOURCE_TSC: Option> = None; +#[allow(dead_code)] pub fn clocksource_tsc() -> Arc { unsafe { CLOCKSOURCE_TSC.as_ref().unwrap().clone() } } diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs index b5939e4867..fd58f676be 100644 --- a/kernel/src/filesystem/fuse/conn.rs +++ b/kernel/src/filesystem/fuse/conn.rs @@ -1,5 +1,5 @@ use alloc::{collections::BTreeMap, collections::VecDeque, sync::Arc, vec::Vec}; -use core::sync::atomic::{AtomicU64, Ordering}; +use core::sync::atomic::{AtomicU64, AtomicUsize, Ordering}; use num_traits::FromPrimitive; use system_error::SystemError; @@ -15,6 +15,8 @@ use crate::{ process::ProcessManager, }; +use crate::process::cred::CAPFlags; + use super::protocol::{ fuse_pack_struct, fuse_read_struct, FuseInHeader, FuseInitIn, FuseInitOut, FuseOutHeader, FUSE_INIT, FUSE_KERNEL_MINOR_VERSION, FUSE_KERNEL_VERSION, @@ -86,6 +88,9 @@ struct FuseConnInner { connected: bool, mounted: bool, initialized: bool, + owner_uid: u32, + owner_gid: u32, + allow_other: bool, pending: VecDeque>, processing: BTreeMap>, } @@ -95,6 +100,7 @@ struct FuseConnInner { pub struct FuseConn { inner: Mutex, next_unique: AtomicU64, + dev_count: AtomicUsize, read_wait: WaitQueue, init_wait: WaitQueue, epitems: LockedEPItemLinkedList, @@ -107,17 +113,22 @@ impl FuseConn { connected: true, mounted: false, initialized: false, + owner_uid: 0, + owner_gid: 0, + allow_other: false, pending: VecDeque::new(), processing: BTreeMap::new(), }), // Use non-zero unique, keep even IDs for "ordinary" requests as Linux does. next_unique: AtomicU64::new(2), + dev_count: AtomicUsize::new(1), read_wait: WaitQueue::default(), init_wait: WaitQueue::default(), epitems: LockedEPItemLinkedList::default(), }) } + #[allow(dead_code)] pub fn is_mounted(&self) -> bool { self.inner.lock().mounted } @@ -139,17 +150,58 @@ impl FuseConn { self.inner.lock().initialized } + pub fn configure_mount(&self, owner_uid: u32, owner_gid: u32, allow_other: bool) { + let mut g = self.inner.lock(); + g.owner_uid = owner_uid; + g.owner_gid = owner_gid; + g.allow_other = allow_other; + } + fn alloc_unique(&self) -> u64 { self.next_unique.fetch_add(2, Ordering::Relaxed) } + fn allow_current_process(&self, cred: &crate::process::cred::Cred) -> bool { + let g = self.inner.lock(); + + if !g.mounted { + return true; + } + + if g.allow_other { + return true; + } + + // Linux: allow sysadmin to bypass allow_other restrictions (configurable). + if cred.has_capability(CAPFlags::CAP_SYS_ADMIN) { + return true; + } + + let owner_uid = g.owner_uid as usize; + let owner_gid = g.owner_gid as usize; + cred.uid.data() == owner_uid + && cred.euid.data() == owner_uid + && cred.suid.data() == owner_uid + && cred.gid.data() == owner_gid + && cred.egid.data() == owner_gid + && cred.sgid.data() == owner_gid + } + + pub fn check_allow_current_process(&self) -> Result<(), SystemError> { + let cred = ProcessManager::current_pcb().cred(); + if !self.allow_current_process(&cred) { + return Err(SystemError::EACCES); + } + Ok(()) + } + fn wait_initialized(&self) -> Result<(), SystemError> { if self.is_initialized() { return Ok(()); } // Bind condition checks to inner lock and register waker before releasing it. loop { - let mut g = self.inner.lock(); + let g = self.inner.lock(); if !g.connected { return Err(SystemError::ENOTCONN); } @@ -197,6 +249,19 @@ impl FuseConn { ); } + /// Acquire a new `/dev/fuse` file handle reference to this connection. + pub fn dev_acquire(&self) { + self.dev_count.fetch_add(1, Ordering::Relaxed); + } + + /// Release a `/dev/fuse` file handle reference. When the last handle is closed, + /// abort the connection (Linux: daemon exits). + pub fn dev_release(&self) { + if self.dev_count.fetch_sub(1, Ordering::AcqRel) == 1 { + self.abort(); + } + } + pub fn poll_mask(&self, have_pending: bool) -> EPollEventType { let mut events = EPollEventType::EPOLLOUT | EPollEventType::EPOLLWRNORM; let g = self.inner.lock(); @@ -298,11 +363,21 @@ impl FuseConn { .map(|_| ()) } - pub fn request(&self, opcode: u32, nodeid: u64, payload: &[u8]) -> Result, SystemError> { + pub fn request( + &self, + opcode: u32, + nodeid: u64, + payload: &[u8], + ) -> Result, SystemError> { if opcode != FUSE_INIT { + let cred = ProcessManager::current_pcb().cred(); + if !self.allow_current_process(&cred) { + return Err(SystemError::EACCES); + } self.wait_initialized()?; } - self.enqueue_request(opcode, nodeid, payload)?.wait_complete() + self.enqueue_request(opcode, nodeid, payload)? + .wait_complete() } fn enqueue_request( @@ -315,10 +390,10 @@ impl FuseConn { let pcb = ProcessManager::current_pcb(); let cred = pcb.cred(); - let pid = pcb - .task_tgid_vnr() - .map(|p| p.data() as u32) - .unwrap_or(0); + if !self.allow_current_process(&cred) { + return Err(SystemError::EACCES); + } + let pid = pcb.task_tgid_vnr().map(|p| p.data() as u32).unwrap_or(0); let hdr = FuseInHeader { len: (core::mem::size_of::() + payload.len()) as u32, @@ -371,7 +446,8 @@ impl FuseConn { if !g.connected { return Err(SystemError::ENOTCONN); } - g.processing.remove(&out_hdr.unique) + g.processing + .remove(&out_hdr.unique) .ok_or(SystemError::EINVAL)? }; diff --git a/kernel/src/filesystem/fuse/dev.rs b/kernel/src/filesystem/fuse/dev.rs index 43e3d23a5b..ff11ff617b 100644 --- a/kernel/src/filesystem/fuse/dev.rs +++ b/kernel/src/filesystem/fuse/dev.rs @@ -17,10 +17,13 @@ use crate::{ }, }, libs::mutex::{Mutex, MutexGuard}, + process::ProcessManager, + syscall::user_access::UserBufferReader, time::PosixTimeSpec, }; use super::conn::FuseConn; +const FUSE_DEV_IOC_CLONE: u32 = 0x8004_4600; // _IOR('F', 0, uint32_t) #[derive(Debug)] pub struct FuseDevInode { @@ -143,7 +146,7 @@ impl IndexNode for LockedFuseDevInode { fn close(&self, data: MutexGuard) -> Result<(), SystemError> { if let FilePrivateData::FuseDev(p) = &*data { if let Ok(conn) = p.conn.clone().downcast::() { - conn.abort(); + conn.dev_release(); } } Ok(()) @@ -236,11 +239,57 @@ impl IndexNode for LockedFuseDevInode { fn ioctl( &self, - _cmd: u32, - _data: usize, - _private_data: &FilePrivateData, + cmd: u32, + data: usize, + mut private_data: MutexGuard, ) -> Result { - Err(SystemError::ENOTTY) + match cmd { + FUSE_DEV_IOC_CLONE => { + if data == 0 { + return Err(SystemError::EFAULT); + } + + let reader = + UserBufferReader::new(data as *const u32, core::mem::size_of::(), true)?; + let oldfd = reader.buffer_protected(0)?.read_one::(0)? as i32; + + let old_file = ProcessManager::current_pcb() + .fd_table() + .read() + .get_file_by_fd(oldfd) + .ok_or(SystemError::EINVAL)?; + + let old_conn = { + let guard = old_file.private_data.lock(); + let FilePrivateData::FuseDev(p) = &*guard else { + return Err(SystemError::EINVAL); + }; + p.conn.clone() + }; + + let FilePrivateData::FuseDev(p) = &mut *private_data else { + return Err(SystemError::EINVAL); + }; + let old_fc = old_conn + .clone() + .downcast::() + .map_err(|_| SystemError::EINVAL)?; + + // If this fd already points to the same connection, this is a no-op. + if let Ok(cur_fc) = p.conn.clone().downcast::() { + if Arc::ptr_eq(&cur_fc, &old_fc) { + return Ok(0); + } + cur_fc.dev_release(); + } + + old_fc.dev_acquire(); + p.conn = old_conn; + + Ok(0) + } + _ => Err(SystemError::ENOTTY), + } } fn absolute_path(&self) -> Result { diff --git a/kernel/src/filesystem/fuse/fs.rs b/kernel/src/filesystem/fuse/fs.rs index 8430a62f9e..8e72960072 100644 --- a/kernel/src/filesystem/fuse/fs.rs +++ b/kernel/src/filesystem/fuse/fs.rs @@ -18,7 +18,11 @@ use crate::{ use linkme::distributed_slice; -use super::{conn::FuseConn, inode::FuseNode, protocol::FUSE_ROOT_ID}; +use super::{ + conn::FuseConn, + inode::FuseNode, + protocol::{fuse_read_struct, FuseStatfsOut, FUSE_ROOT_ID, FUSE_STATFS}, +}; #[derive(Debug)] pub struct FuseMountData { @@ -26,6 +30,8 @@ pub struct FuseMountData { pub rootmode: u32, pub user_id: u32, pub group_id: u32, + pub default_permissions: bool, + pub allow_other: bool, pub conn: Arc, } @@ -41,18 +47,22 @@ pub struct FuseFS { super_block: SuperBlock, conn: Arc, nodes: Mutex>>, - #[allow(dead_code)] owner_uid: u32, - #[allow(dead_code)] owner_gid: u32, + default_permissions: bool, + allow_other: bool, } impl FuseFS { - fn parse_mount_options(raw: Option<&str>) -> Result<(i32, u32, u32, u32), SystemError> { + fn parse_mount_options( + raw: Option<&str>, + ) -> Result<(i32, u32, u32, u32, bool, bool), SystemError> { let mut fd: Option = None; let mut rootmode: Option = None; let mut user_id: Option = None; let mut group_id: Option = None; + let mut default_permissions = false; + let mut allow_other = false; let s = raw.unwrap_or(""); for part in s.split(',') { @@ -78,6 +88,12 @@ impl FuseFS { "group_id" => { group_id = Some(v.parse::().map_err(|_| SystemError::EINVAL)?); } + "default_permissions" => { + default_permissions = v.is_empty() || v != "0"; + } + "allow_other" => { + allow_other = v.is_empty() || v != "0"; + } _ => {} } } @@ -90,7 +106,14 @@ impl FuseFS { // Default root mode: directory 0755 (with type bit). let rootmode = rootmode.unwrap_or(0o040755); - Ok((fd, rootmode, user_id, group_id)) + Ok(( + fd, + rootmode, + user_id, + group_id, + default_permissions, + allow_other, + )) } pub fn root_node(&self) -> Arc { @@ -135,7 +158,8 @@ impl MountableFileSystem for FuseFS { raw_data: Option<&str>, _source: &str, ) -> Result>, SystemError> { - let (fd, rootmode, user_id, group_id) = Self::parse_mount_options(raw_data)?; + let (fd, rootmode, user_id, group_id, default_permissions, allow_other) = + Self::parse_mount_options(raw_data)?; let file = ProcessManager::current_pcb() .fd_table() @@ -155,6 +179,7 @@ impl MountableFileSystem for FuseFS { } }; + conn.configure_mount(user_id, group_id, allow_other); conn.mark_mounted()?; Ok(Some(Arc::new(FuseMountData { @@ -162,6 +187,8 @@ impl MountableFileSystem for FuseFS { rootmode, user_id, group_id, + default_permissions, + allow_other, conn, }))) } @@ -209,6 +236,8 @@ impl MountableFileSystem for FuseFS { nodes: Mutex::new(BTreeMap::new()), owner_uid: mount_data.user_id, owner_gid: mount_data.group_id, + default_permissions: mount_data.default_permissions, + allow_other: mount_data.allow_other, }); conn.enqueue_init()?; @@ -242,6 +271,47 @@ impl FileSystem for FuseFS { self.super_block.clone() } + fn statfs(&self, inode: &Arc) -> Result { + match self.conn.check_allow_current_process() { + Ok(()) => {} + Err(SystemError::EACCES) => { + let mut sb = self.super_block.clone(); + sb.magic = Magic::FUSE_MAGIC; + return Ok(sb); + } + Err(e) => return Err(e), + } + + let nodeid = inode + .as_any_ref() + .downcast_ref::() + .map(|n| n.nodeid()) + .unwrap_or(FUSE_ROOT_ID); + + let payload = self.conn.request(FUSE_STATFS, nodeid, &[])?; + let out: FuseStatfsOut = fuse_read_struct(&payload)?; + + let mut sb = self.super_block.clone(); + sb.magic = Magic::FUSE_MAGIC; + sb.blocks = out.st.blocks; + sb.bfree = out.st.bfree; + sb.bavail = out.st.bavail; + sb.files = out.st.files; + sb.ffree = out.st.ffree; + sb.bsize = out.st.bsize as u64; + sb.namelen = out.st.namelen as u64; + sb.frsize = out.st.frsize as u64; + Ok(sb) + } + + fn permission_policy(&self) -> crate::filesystem::vfs::FsPermissionPolicy { + if self.default_permissions { + crate::filesystem::vfs::FsPermissionPolicy::Dac + } else { + crate::filesystem::vfs::FsPermissionPolicy::Remote + } + } + fn on_umount(&self) { // Abort pending/blocked requests to wake daemon thread on unmount. self.conn.abort(); diff --git a/kernel/src/filesystem/fuse/inode.rs b/kernel/src/filesystem/fuse/inode.rs index bb11e43ba7..3217693f27 100644 --- a/kernel/src/filesystem/fuse/inode.rs +++ b/kernel/src/filesystem/fuse/inode.rs @@ -10,9 +10,9 @@ use system_error::SystemError; use crate::{ driver::base::device::device_number::DeviceNumber, filesystem::vfs::{ - file::{FuseDirPrivateData, FuseFilePrivateData, FileFlags}, + file::{FileFlags, FuseDirPrivateData, FuseFilePrivateData}, syscall::RenameFlags, - FilePrivateData, FileSystem, FileType, InodeFlags, InodeId, InodeMode, IndexNode, Metadata, + FilePrivateData, FileSystem, FileType, IndexNode, InodeFlags, InodeId, InodeMode, Metadata, }, libs::mutex::{Mutex, MutexGuard}, time::PosixTimeSpec, @@ -23,11 +23,11 @@ use super::{ fs::FuseFS, protocol::{ fuse_pack_struct, fuse_read_struct, FuseAttr, FuseAttrOut, FuseDirent, FuseEntryOut, - FuseGetattrIn, FuseMkdirIn, FuseMknodIn, FuseOpenIn, FuseOpenOut, FuseReadIn, FuseReleaseIn, - FuseRenameIn, FuseSetattrIn, FuseWriteIn, FuseWriteOut, FATTR_GID, FATTR_MODE, FATTR_SIZE, - FATTR_UID, FUSE_GETATTR, FUSE_LOOKUP, FUSE_MKDIR, FUSE_MKNOD, FUSE_OPEN, FUSE_OPENDIR, - FUSE_READ, FUSE_READDIR, FUSE_RELEASE, FUSE_RELEASEDIR, FUSE_RENAME, FUSE_RMDIR, - FUSE_SETATTR, FUSE_UNLINK, FUSE_WRITE, + FuseGetattrIn, FuseMkdirIn, FuseMknodIn, FuseOpenIn, FuseOpenOut, FuseReadIn, + FuseReleaseIn, FuseRenameIn, FuseSetattrIn, FuseWriteIn, FuseWriteOut, FATTR_GID, + FATTR_MODE, FATTR_SIZE, FATTR_UID, FUSE_GETATTR, FUSE_LOOKUP, FUSE_MKDIR, FUSE_MKNOD, + FUSE_OPEN, FUSE_OPENDIR, FUSE_READ, FUSE_READDIR, FUSE_RELEASE, FUSE_RELEASEDIR, + FUSE_RENAME, FUSE_RMDIR, FUSE_SETATTR, FUSE_UNLINK, FUSE_WRITE, }, }; @@ -128,9 +128,9 @@ impl FuseNode { dummy: 0, fh: 0, }; - let payload = self - .conn() - .request(FUSE_GETATTR, self.nodeid, fuse_pack_struct(&getattr_in))?; + let payload = + self.conn() + .request(FUSE_GETATTR, self.nodeid, fuse_pack_struct(&getattr_in))?; let out: FuseAttrOut = fuse_read_struct(&payload)?; let md = Self::attr_to_metadata(&out.attr); *self.cached_metadata.lock() = Some(md.clone()); @@ -138,6 +138,7 @@ impl FuseNode { } fn cached_or_fetch_metadata(&self) -> Result { + self.conn.check_allow_current_process()?; if let Some(m) = self.cached_metadata.lock().clone() { return Ok(m); } @@ -215,11 +216,15 @@ impl IndexNode for FuseNode { self } - fn open(&self, mut data: MutexGuard, flags: &FileFlags) -> Result<(), SystemError> { + fn open( + &self, + mut data: MutexGuard, + flags: &FileFlags, + ) -> Result<(), SystemError> { let md = self.cached_or_fetch_metadata()?; match md.file_type { - FileType::Dir => self.open_common(FUSE_OPENDIR, &mut *data, flags), - FileType::File => self.open_common(FUSE_OPEN, &mut *data, flags), + FileType::Dir => self.open_common(FUSE_OPENDIR, &mut data, flags), + FileType::File => self.open_common(FUSE_OPEN, &mut data, flags), _ => Err(SystemError::EINVAL), } } @@ -391,9 +396,9 @@ impl IndexNode for FuseNode { flags: 0, padding: 0, }; - let payload = self - .conn() - .request(FUSE_READDIR, self.nodeid, fuse_pack_struct(&read_in))?; + let payload = + self.conn() + .request(FUSE_READDIR, self.nodeid, fuse_pack_struct(&read_in))?; if payload.is_empty() { break; } @@ -482,9 +487,7 @@ impl IndexNode for FuseNode { payload_in.extend_from_slice(fuse_pack_struct(&inarg)); payload_in.extend_from_slice(name.as_bytes()); payload_in.push(0); - let payload = self - .conn() - .request(FUSE_MKDIR, self.nodeid, &payload_in)?; + let payload = self.conn().request(FUSE_MKDIR, self.nodeid, &payload_in)?; let entry: FuseEntryOut = fuse_read_struct(&payload)?; let md = Self::attr_to_metadata(&entry.attr); let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; @@ -501,9 +504,7 @@ impl IndexNode for FuseNode { payload_in.extend_from_slice(fuse_pack_struct(&inarg)); payload_in.extend_from_slice(name.as_bytes()); payload_in.push(0); - let payload = self - .conn() - .request(FUSE_MKNOD, self.nodeid, &payload_in)?; + let payload = self.conn().request(FUSE_MKNOD, self.nodeid, &payload_in)?; let entry: FuseEntryOut = fuse_read_struct(&payload)?; let md = Self::attr_to_metadata(&entry.attr); let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; diff --git a/kernel/src/filesystem/fuse/protocol.rs b/kernel/src/filesystem/fuse/protocol.rs index a7d7308a6d..318617c96a 100644 --- a/kernel/src/filesystem/fuse/protocol.rs +++ b/kernel/src/filesystem/fuse/protocol.rs @@ -27,6 +27,7 @@ pub const FUSE_RENAME: u32 = 12; pub const FUSE_OPEN: u32 = 14; pub const FUSE_READ: u32 = 15; pub const FUSE_WRITE: u32 = 16; +pub const FUSE_STATFS: u32 = 17; pub const FUSE_RELEASE: u32 = 18; pub const FUSE_INIT: u32 = 26; pub const FUSE_OPENDIR: u32 = 27; @@ -191,6 +192,27 @@ pub struct FuseWriteOut { pub padding: u32, } +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseKstatfs { + pub blocks: u64, + pub bfree: u64, + pub bavail: u64, + pub files: u64, + pub ffree: u64, + pub bsize: u32, + pub namelen: u32, + pub frsize: u32, + pub padding: u32, + pub spare: [u32; 6], +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseStatfsOut { + pub st: FuseKstatfs, +} + #[repr(C)] #[derive(Debug, Clone, Copy)] pub struct FuseReleaseIn { diff --git a/kernel/src/filesystem/vfs/mod.rs b/kernel/src/filesystem/vfs/mod.rs index 4d10e68689..07960cd226 100644 --- a/kernel/src/filesystem/vfs/mod.rs +++ b/kernel/src/filesystem/vfs/mod.rs @@ -992,9 +992,6 @@ impl dyn IndexNode { let process_root_inode = ProcessManager::current_pcb().fs_struct().root(); let trailing_slash = path.ends_with('/'); - // 获取当前进程的凭证（用于路径遍历的权限检查） - let cred = ProcessManager::current_pcb().cred(); - // 处理绝对路径 // result: 上一个被找到的inode // rest_path: 还没有查找的路径 @@ -1013,9 +1010,9 @@ impl dyn IndexNode { } // 检查当前目录的执行权限（搜索权限） - // 这确保了进程有权限遍历到此目录 + // 这确保了进程有权限遍历到此目录（对 Remote 权限模型的 FS，该检查会被绕过） let metadata = result.metadata()?; - cred.inode_permission(&metadata, PermissionMask::MAY_EXEC.bits())?; + permission::check_inode_permission(&result, &metadata, PermissionMask::MAY_EXEC)?; let name; // 寻找“/” @@ -1286,6 +1283,18 @@ bitflags! { } } +/// Filesystem-level permission checking policy used by VFS. +/// +/// - `Dac`: VFS performs Unix DAC permission checks (mode/uid/gid) locally. +/// - `Remote`: VFS bypasses local DAC checks and lets the filesystem/server decide. +/// For Linux FUSE remote model, execute permission is still checked locally for +/// regular files; see `vfs::permission::check_inode_permission()`. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum FsPermissionPolicy { + Dac, + Remote, +} + /// @brief 所有文件系统都应该实现的trait pub trait FileSystem: Any + Sync + Send + Debug { /// @brief 获取当前文件系统的root inode的指针 @@ -1310,6 +1319,20 @@ pub trait FileSystem: Any + Sync + Send + Debug { fn super_block(&self) -> SuperBlock; + /// @brief 获取文件系统统计信息（statfs） + /// + /// 默认实现直接返回 super_block。需要自定义 statfs 行为的文件系统可覆写此方法。 + fn statfs(&self, _inode: &Arc) -> Result { + Ok(self.super_block()) + } + + /// VFS permission checking policy for this filesystem instance. + /// + /// Default is `Dac` (local Unix DAC checks). + fn permission_policy(&self) -> FsPermissionPolicy { + FsPermissionPolicy::Dac + } + /// Called after a filesystem is successfully unmounted. /// Default is no-op. fn on_umount(&self) {} diff --git a/kernel/src/filesystem/vfs/mount.rs b/kernel/src/filesystem/vfs/mount.rs index f6493287dd..a661afcfcc 100644 --- a/kernel/src/filesystem/vfs/mount.rs +++ b/kernel/src/filesystem/vfs/mount.rs @@ -1097,6 +1097,21 @@ impl FileSystem for MountFS { sb } + fn statfs(&self, inode: &Arc) -> Result { + let inner_inode = inode + .as_any_ref() + .downcast_ref::() + .map(|mnt| mnt.inner_inode.clone()) + .unwrap_or_else(|| inode.clone()); + let mut sb = self.inner_filesystem.statfs(&inner_inode)?; + sb.flags = self.mount_flags.bits() as u64; + Ok(sb) + } + + fn permission_policy(&self) -> crate::filesystem::vfs::FsPermissionPolicy { + self.inner_filesystem.permission_policy() + } + unsafe fn fault(&self, pfm: &mut PageFaultMessage) -> VmFaultReason { self.inner_filesystem.fault(pfm) } diff --git a/kernel/src/filesystem/vfs/open.rs b/kernel/src/filesystem/vfs/open.rs index aff0981939..925cacf7f7 100644 --- a/kernel/src/filesystem/vfs/open.rs +++ b/kernel/src/filesystem/vfs/open.rs @@ -7,7 +7,7 @@ use super::{ permission::PermissionMask, syscall::{OpenHow, OpenHowResolve}, utils::{rsplit_path, should_remove_sgid_on_chown, user_path_at}, - vcore::{check_parent_dir_permission, resolve_parent_inode}, + vcore::{check_parent_dir_permission_inode, resolve_parent_inode}, FileType, IndexNode, InodeMode, MAX_PATHLEN, VFS_MAX_FOLLOW_SYMLINK_TIMES, }; use crate::{filesystem::vfs::syscall::UtimensFlags, process::cred::Kgid}; @@ -265,7 +265,7 @@ fn do_sys_openat2(dirfd: i32, path: &str, how: OpenHow) -> Result Result Result, SystemError> return Err(SystemError::EACCES); } - // 检查执行权限 - let cred = ProcessManager::current_pcb().cred(); - cred.inode_permission(&metadata, PermissionMask::MAY_EXEC.bits())?; - - // 同时需要读权限（用于读取ELF内容） - cred.inode_permission(&metadata, PermissionMask::MAY_READ.bits())?; + super::permission::check_inode_permission(&inode, &metadata, PermissionMask::MAY_EXEC)?; + super::permission::check_inode_permission(&inode, &metadata, PermissionMask::MAY_READ)?; // 创建File对象，使用O_RDONLY | O_CLOEXEC let file = File::new(inode, FileFlags::O_RDONLY | FileFlags::O_CLOEXEC)?; diff --git a/kernel/src/filesystem/vfs/permission.rs b/kernel/src/filesystem/vfs/permission.rs index d393f9ba1c..5c13ca8abd 100644 --- a/kernel/src/filesystem/vfs/permission.rs +++ b/kernel/src/filesystem/vfs/permission.rs @@ -7,9 +7,13 @@ use super::Metadata; use crate::{ filesystem::vfs::{FileType, InodeMode}, process::cred::{CAPFlags, Cred}, + process::ProcessManager, }; +use alloc::sync::Arc; use system_error::SystemError; +use super::{FsPermissionPolicy, IndexNode}; + bitflags! { pub struct PermissionMask: u32 { /// 测试执行权限 @@ -31,6 +35,35 @@ bitflags! { } } +/// VFS permission check wrapper that respects per-filesystem policy. +/// +/// This is the single entry point that should be used by VFS/pathwalk/syscalls +/// when deciding whether to apply local Unix DAC checks. +/// +/// Linux FUSE remote permission model: +/// - Without `default_permissions`, the kernel bypasses most DAC checks and +/// lets the userspace daemon decide. +/// - Execute permission is still checked locally for regular files. +pub fn check_inode_permission( + inode: &Arc, + metadata: &Metadata, + mask: PermissionMask, +) -> Result<(), SystemError> { + let cred = ProcessManager::current_pcb().cred(); + match inode.fs().permission_policy() { + FsPermissionPolicy::Dac => cred.inode_permission(metadata, mask.bits()), + FsPermissionPolicy::Remote => { + if mask.contains(PermissionMask::MAY_EXEC) + && metadata.file_type == FileType::File + && (metadata.mode.bits() & InodeMode::S_IXUGO.bits()) == 0 + { + return Err(SystemError::EACCES); + } + Ok(()) + } + } +} + impl Cred { /// 检查具有给定凭证的进程是否有权限访问 inode。 /// diff --git a/kernel/src/filesystem/vfs/syscall/link_utils.rs b/kernel/src/filesystem/vfs/syscall/link_utils.rs index 613dad9360..5fe257b002 100644 --- a/kernel/src/filesystem/vfs/syscall/link_utils.rs +++ b/kernel/src/filesystem/vfs/syscall/link_utils.rs @@ -1,3 +1,4 @@ +use crate::filesystem::vfs::permission::PermissionMask; use crate::filesystem::vfs::syscall::AtFlags; use crate::filesystem::vfs::utils::rsplit_path; use crate::filesystem::vfs::utils::user_path_at; @@ -8,9 +9,9 @@ use crate::filesystem::vfs::Metadata; use crate::filesystem::vfs::SystemError; use crate::filesystem::vfs::VFS_MAX_FOLLOW_SYMLINK_TIMES; use crate::process::cred::CAPFlags; -use crate::process::cred::Cred; use crate::process::ProcessManager; use alloc::sync::Arc; + /// **创建硬连接的系统调用** /// /// ## 参数 @@ -129,7 +130,7 @@ fn may_linkat(old_inode: &Arc) -> Result<(), SystemError> { } // 检查是否是"安全的"硬链接源 - if !safe_hardlink_source(&metadata, &cred)? { + if !safe_hardlink_source(old_inode, &metadata)? { return Err(SystemError::EPERM); } @@ -159,7 +160,10 @@ fn may_linkat(old_inode: &Arc) -> Result<(), SystemError> { /// - `Ok(true)`: 硬链接源安全，允许创建硬链接 /// - `Ok(false)`: 硬链接源不安全，不允许创建硬链接 /// - `Err(SystemError::EACCES)`: 权限检查失败 -fn safe_hardlink_source(metadata: &Metadata, cred: &Arc) -> Result { +fn safe_hardlink_source( + old_inode: &Arc, + metadata: &Metadata, +) -> Result { let mode = metadata.mode; let file_type = metadata.file_type; @@ -178,10 +182,14 @@ fn safe_hardlink_source(metadata: &Metadata, cred: &Arc) -> Result String::from("/"), - _ => proc.basic().cwd(), - }; - let mut cwd_vec: Vec<_> = cwd.split('/').filter(|&x| !x.is_empty()).collect(); - let path_split = path.split('/').filter(|&x| !x.is_empty()); - for seg in path_split { - if seg == ".." { - cwd_vec.pop(); - } else if seg == "." { - // 当前目录 - } else { - cwd_vec.push(seg); - } - } - for seg in cwd_vec { - new_path.push('/'); - new_path.push_str(seg); + crate::filesystem::vfs::permission::check_inode_permission( + &inode, + &metadata, + PermissionMask::MAY_EXEC | PermissionMask::MAY_CHDIR, + )?; + + // 维护一个“用户可见”的 cwd 字符串（用于 getcwd 的快速路径） + // 注意：路径解析不再依赖该字符串，避免 chroot 后出现语义偏差。 + let mut new_path = String::from(""); + let cwd = match path.as_bytes()[0] { + b'/' => String::from("/"), + _ => proc.basic().cwd(), + }; + let mut cwd_vec: Vec<_> = cwd.split('/').filter(|&x| !x.is_empty()).collect(); + let path_split = path.split('/').filter(|&x| !x.is_empty()); + for seg in path_split { + if seg == ".." { + cwd_vec.pop(); + } else if seg == "." { + // 当前目录 + } else { + cwd_vec.push(seg); } - if new_path.is_empty() { - new_path = String::from("/"); - } - - proc.basic_mut().set_cwd(new_path); - proc.fs_struct_mut().set_pwd(inode); - return Ok(0); - } else { - return Err(SystemError::ENOTDIR); } + for seg in cwd_vec { + new_path.push('/'); + new_path.push_str(seg); + } + if new_path.is_empty() { + new_path = String::from("/"); + } + + proc.basic_mut().set_cwd(new_path); + proc.fs_struct_mut().set_pwd(inode); + Ok(0) } /// Formats the syscall parameters for display/debug purposes diff --git a/kernel/src/filesystem/vfs/syscall/sys_chroot.rs b/kernel/src/filesystem/vfs/syscall/sys_chroot.rs index 283bc8c0dc..13d094569b 100644 --- a/kernel/src/filesystem/vfs/syscall/sys_chroot.rs +++ b/kernel/src/filesystem/vfs/syscall/sys_chroot.rs @@ -63,8 +63,11 @@ impl Syscall for SysChrootHandle { return Err(SystemError::ENOTDIR); } - // 目录搜索权限（execute） - cred.inode_permission(&meta, PermissionMask::MAY_EXEC.bits())?; + crate::filesystem::vfs::permission::check_inode_permission( + &target, + &meta, + PermissionMask::MAY_EXEC, + )?; // 更新进程 fs root；不改变 cwd（Linux 行为） pcb.fs_struct_mut().set_root(target); diff --git a/kernel/src/filesystem/vfs/syscall/sys_fchdir.rs b/kernel/src/filesystem/vfs/syscall/sys_fchdir.rs index ecfe462ada..c8e7fcad21 100644 --- a/kernel/src/filesystem/vfs/syscall/sys_fchdir.rs +++ b/kernel/src/filesystem/vfs/syscall/sys_fchdir.rs @@ -4,6 +4,7 @@ use system_error::SystemError; use crate::arch::interrupt::TrapFrame; use crate::arch::syscall::nr::SYS_FCHDIR; +use crate::filesystem::vfs::permission::PermissionMask; use crate::process::ProcessManager; use crate::syscall::table::FormattedSyscallParam; use crate::syscall::table::Syscall; @@ -41,8 +42,14 @@ impl Syscall for SysFchdirHandle { let inode = file.inode(); let metadata = inode.metadata()?; - let cred = pcb.cred(); - cred.check_chdir_permission(&metadata)?; + if metadata.file_type != crate::filesystem::vfs::FileType::Dir { + return Err(SystemError::ENOTDIR); + } + crate::filesystem::vfs::permission::check_inode_permission( + &inode, + &metadata, + PermissionMask::MAY_EXEC | PermissionMask::MAY_CHDIR, + )?; let path = inode.absolute_path()?; pcb.basic_mut().set_cwd(path); diff --git a/kernel/src/filesystem/vfs/syscall/sys_fstatfs.rs b/kernel/src/filesystem/vfs/syscall/sys_fstatfs.rs index 73f465d7af..ee85a03d63 100644 --- a/kernel/src/filesystem/vfs/syscall/sys_fstatfs.rs +++ b/kernel/src/filesystem/vfs/syscall/sys_fstatfs.rs @@ -25,7 +25,9 @@ impl Syscall for SysFstatfsHandle { .get_file_by_fd(fd) .ok_or(SystemError::EBADF)?; drop(fd_table_guard); - let statfs = PosixStatfs::from(file.inode().fs().super_block()); + let inode = file.inode(); + let sb = inode.fs().statfs(&inode)?; + let statfs = PosixStatfs::from(sb); writer.copy_one_to_user(&statfs, 0)?; return Ok(0); } diff --git a/kernel/src/filesystem/vfs/syscall/sys_statfs.rs b/kernel/src/filesystem/vfs/syscall/sys_statfs.rs index 7ce3e194a5..28d80a1f1b 100644 --- a/kernel/src/filesystem/vfs/syscall/sys_statfs.rs +++ b/kernel/src/filesystem/vfs/syscall/sys_statfs.rs @@ -33,7 +33,8 @@ impl Syscall for SysStatfsHandle { let pcb = ProcessManager::current_pcb(); let (inode_begin, remain_path) = user_path_at(&pcb, fd as i32, &path)?; let inode = inode_begin.lookup_follow_symlink(&remain_path, MAX_PATHLEN)?; - let statfs = PosixStatfs::from(inode.fs().super_block()); + let sb = inode.fs().statfs(&inode)?; + let statfs = PosixStatfs::from(sb); writer.copy_one_to_user(&statfs, 0)?; return Ok(0); } diff --git a/kernel/src/filesystem/vfs/syscall/sys_truncate.rs b/kernel/src/filesystem/vfs/syscall/sys_truncate.rs index 8b1ef5f4b1..a205a68688 100644 --- a/kernel/src/filesystem/vfs/syscall/sys_truncate.rs +++ b/kernel/src/filesystem/vfs/syscall/sys_truncate.rs @@ -52,9 +52,11 @@ impl Syscall for SysTruncateHandle { .lookup_follow_symlink(remain_path.as_str(), VFS_MAX_FOLLOW_SYMLINK_TIMES)?; let md = target.metadata()?; - // DAC write permission check - let cred = ProcessManager::current_pcb().cred(); - cred.inode_permission(&md, PermissionMask::MAY_WRITE.bits())?; + crate::filesystem::vfs::permission::check_inode_permission( + &target, + &md, + PermissionMask::MAY_WRITE, + )?; // RLIMIT_FSIZE enforcement for regular files if md.file_type == FileType::File { diff --git a/kernel/src/filesystem/vfs/vcore.rs b/kernel/src/filesystem/vfs/vcore.rs index 76da2b7227..159a0ee3cc 100644 --- a/kernel/src/filesystem/vfs/vcore.rs +++ b/kernel/src/filesystem/vfs/vcore.rs @@ -295,12 +295,15 @@ pub fn do_mkdir_at( return Err(SystemError::ENOTDIR); } let pcb = ProcessManager::current_pcb(); - let cred = pcb.cred(); // Linux 语义：目录执行权限控制能否遍历（查找子项） // 先检查执行权限，再检查文件是否存在，最后检查写权限 // 顺序很重要：无执行权限 → EACCES；有执行权限且已存在 → EEXIST；有执行权限无写权限 → EACCES - cred.inode_permission(&parent_md, PermissionMask::MAY_EXEC.bits())?; + crate::filesystem::vfs::permission::check_inode_permission( + ¤t_inode, + &parent_md, + PermissionMask::MAY_EXEC, + )?; // 已确认有执行权限，可以查找子项 if current_inode.find(name).is_ok() { @@ -308,7 +311,11 @@ pub fn do_mkdir_at( } // 创建目录还需要对父目录拥有写权限 - cred.inode_permission(&parent_md, PermissionMask::MAY_WRITE.bits())?; + crate::filesystem::vfs::permission::check_inode_permission( + ¤t_inode, + &parent_md, + PermissionMask::MAY_WRITE, + )?; let mut final_mode_bits = mode.bits() & InodeMode::S_IRWXUGO.bits(); if (parent_md.mode.bits() & InodeMode::S_ISGID.bits()) != 0 { @@ -344,15 +351,15 @@ pub(super) fn resolve_parent_inode( } } -/// 检查父目录权限（写+执行权限） -/// -/// Linux 语义：删除/创建文件/目录需要对父目录拥有 W+X（写+执行）权限 -/// 注意：权限检查必须在 find 之前进行，否则当文件不存在时会返回 ENOENT 而不是 EACCES -pub(super) fn check_parent_dir_permission(parent_md: &super::Metadata) -> Result<(), SystemError> { - let cred = ProcessManager::current_pcb().cred(); - cred.inode_permission( +/// 检查父目录权限（写+执行权限），并尊重文件系统权限策略（如 FUSE remote 模型）。 +pub(super) fn check_parent_dir_permission_inode( + parent_inode: &Arc, + parent_md: &super::Metadata, +) -> Result<(), SystemError> { + crate::filesystem::vfs::permission::check_inode_permission( + parent_inode, parent_md, - (PermissionMask::MAY_WRITE | PermissionMask::MAY_EXEC).bits(), + PermissionMask::MAY_WRITE | PermissionMask::MAY_EXEC, ) } @@ -385,7 +392,7 @@ pub fn do_remove_dir(dirfd: i32, path: &str) -> Result { // Linux 语义：删除目录需要对父目录拥有 W+X（写+搜索）权限 // 注意：权限检查必须在 find 之前进行，否则当目录不存在时会返回 ENOENT 而不是 EACCES - check_parent_dir_permission(&parent_md)?; + check_parent_dir_permission_inode(&parent_inode, &parent_md)?; // 在目标点为symlink时也返回ENOTDIR let target_inode = parent_inode.find(filename)?; @@ -423,7 +430,7 @@ pub fn do_unlink_at(dirfd: i32, path: &str) -> Result { // Linux 语义：删除文件需要对父目录拥有 W+X（写+搜索）权限 // 注意：权限检查必须在 find 之前进行，否则当文件不存在时会返回 ENOENT 而不是 EACCES - check_parent_dir_permission(&parent_md)?; + check_parent_dir_permission_inode(&parent_inode, &parent_md)?; // Linux 语义：unlink(2)/unlinkat(2) 删除目录项本身，不跟随最后一个符号链接。 // 我们已解析到父目录，因此这里必须用 find() 直接取目录项对应 inode， diff --git a/user/apps/c_unitest/fuse_test_simplefs.h b/user/apps/c_unitest/fuse_test_simplefs.h index aba665f88b..89d88c1b5d 100644 --- a/user/apps/c_unitest/fuse_test_simplefs.h +++ b/user/apps/c_unitest/fuse_test_simplefs.h @@ -24,6 +24,7 @@ #include #define FUSE_TEST_LOG_PREFIX "[fuse-test] " +#define FUSE_SIMPLEFS_REV "statfs-v1" static inline int fuse_test_log_enabled(void) { static int inited = 0; @@ -87,6 +88,9 @@ static inline int fuse_test_log_enabled(void) { #ifndef FUSE_WRITE #define FUSE_WRITE 16 #endif +#ifndef FUSE_STATFS +#define FUSE_STATFS 17 +#endif #ifndef FUSE_RELEASE #define FUSE_RELEASE 18 #endif @@ -237,6 +241,23 @@ struct fuse_write_out { uint32_t padding; }; +struct fuse_kstatfs { + uint64_t blocks; + uint64_t bfree; + uint64_t bavail; + uint64_t files; + uint64_t ffree; + uint32_t bsize; + uint32_t namelen; + uint32_t frsize; + uint32_t padding; + uint32_t spare[6]; +}; + +struct fuse_statfs_out { + struct fuse_kstatfs st; +}; + struct fuse_release_in { uint64_t fh; uint32_t flags; @@ -344,7 +365,7 @@ static inline void simplefs_init(struct simplefs *fs) { memcpy(fs->nodes[1].data, msg, fs->nodes[1].size); fs->next_nodeid = 3; - fs->next_ino = 3; + fs->next_ino = 3; } static inline struct simplefs_node *simplefs_find_node(struct simplefs *fs, uint64_t nodeid) { @@ -442,6 +463,9 @@ struct fuse_daemon_args { volatile int *stop; volatile int *init_done; int enable_write_ops; + int exit_after_init; + uint32_t root_mode_override; + uint32_t hello_mode_override; struct simplefs fs; }; @@ -613,6 +637,31 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha free(outbuf); return ret; } + case FUSE_STATFS: { + struct fuse_statfs_out out; + memset(&out, 0, sizeof(out)); + + unsigned used = 0; + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (a->fs.nodes[i].used) { + used++; + } + } + + out.st.blocks = 1024; + out.st.bfree = 512; + out.st.bavail = 512; + out.st.files = SIMPLEFS_MAX_NODES; + out.st.ffree = (used > SIMPLEFS_MAX_NODES) ? 0 : (SIMPLEFS_MAX_NODES - used); + out.st.bsize = 4096; + out.st.frsize = 4096; + out.st.namelen = SIMPLEFS_NAME_MAX - 1; + FUSE_TEST_LOG("statfs reply ok blocks=%llu bfree=%llu bavail=%llu", + (unsigned long long)out.st.blocks, + (unsigned long long)out.st.bfree, + (unsigned long long)out.st.bavail); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } case FUSE_RELEASE: case FUSE_RELEASEDIR: return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); @@ -793,6 +842,12 @@ static inline void *fuse_daemon_thread(void *arg) { } simplefs_init(&a->fs); + if (a->root_mode_override) { + a->fs.nodes[0].mode = a->root_mode_override; + } + if (a->hello_mode_override) { + a->fs.nodes[1].mode = a->hello_mode_override; + } while (!*a->stop) { FUSE_TEST_LOG("daemon read start"); @@ -816,6 +871,9 @@ static inline void *fuse_daemon_thread(void *arg) { continue; } (void)fuse_handle_one(a, buf, (size_t)n); + if (a->exit_after_init && a->init_done && *a->init_done) { + break; + } } free(buf); return NULL; diff --git a/user/apps/c_unitest/test_fuse_clone.c b/user/apps/c_unitest/test_fuse_clone.c new file mode 100644 index 0000000000..8e9660da40 --- /dev/null +++ b/user/apps/c_unitest/test_fuse_clone.c @@ -0,0 +1,185 @@ +/** + * @file test_fuse_clone.c + * @brief Phase E test: FUSE_DEV_IOC_CLONE basic behavior. + * + * This test mounts a simple FUSE filesystem using a master /dev/fuse fd, + * then opens a second /dev/fuse fd and uses FUSE_DEV_IOC_CLONE to attach it + * to the existing connection. After INIT is done, all requests are served + * via the cloned fd. + */ + +#include "fuse_test_simplefs.h" + +#include + +#ifndef FUSE_DEV_IOC_CLONE +#define FUSE_DEV_IOC_CLONE 0x80044600 /* _IOR('F', 0, uint32_t) */ +#endif + +static int read_all(const char *path, char *buf, size_t cap) { + int fd = open(path, O_RDONLY); + if (fd < 0) + return -1; + ssize_t n = read(fd, buf, cap); + close(fd); + if (n < 0) + return -1; + return (int)n; +} + +int main(void) { + const char *mp = "/tmp/test_fuse_clone"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return 1; + } + + int master_fd = open("/dev/fuse", O_RDWR); + if (master_fd < 0) { + printf("[FAIL] open(/dev/fuse master): %s (errno=%d)\n", strerror(errno), errno); + return 1; + } + + volatile int stop = 0; + volatile int init_done = 0; + + /* INIT responder on master fd, then exit */ + struct fuse_daemon_args master_args; + memset(&master_args, 0, sizeof(master_args)); + master_args.fd = master_fd; + master_args.stop = &stop; + master_args.init_done = &init_done; + master_args.enable_write_ops = 0; + master_args.exit_after_init = 1; + + pthread_t master_th; + if (pthread_create(&master_th, NULL, fuse_daemon_thread, &master_args) != 0) { + printf("[FAIL] pthread_create(master)\n"); + close(master_fd); + return 1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", master_fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(master_fd); + pthread_join(master_th, NULL); + return 1; + } + + for (int i = 0; i < 100; i++) { + if (init_done) + break; + usleep(10 * 1000); + } + if (!init_done) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(master_fd); + pthread_join(master_th, NULL); + return 1; + } + + pthread_join(master_th, NULL); + + /* Open a new fd and clone it to the master connection */ + int clone_fd = open("/dev/fuse", O_RDWR); + if (clone_fd < 0) { + printf("[FAIL] open(/dev/fuse clone): %s (errno=%d)\n", strerror(errno), errno); + umount(mp); + close(master_fd); + return 1; + } + + uint32_t oldfd_u32 = (uint32_t)master_fd; + if (ioctl(clone_fd, FUSE_DEV_IOC_CLONE, &oldfd_u32) != 0) { + printf("[FAIL] ioctl(FUSE_DEV_IOC_CLONE): %s (errno=%d)\n", strerror(errno), errno); + umount(mp); + close(clone_fd); + close(master_fd); + return 1; + } + + /* Serve all subsequent requests via the cloned fd */ + struct fuse_daemon_args clone_args; + memset(&clone_args, 0, sizeof(clone_args)); + clone_args.fd = clone_fd; + clone_args.stop = &stop; + clone_args.init_done = &init_done; + clone_args.enable_write_ops = 0; + clone_args.exit_after_init = 0; + + pthread_t clone_th; + if (pthread_create(&clone_th, NULL, fuse_daemon_thread, &clone_args) != 0) { + printf("[FAIL] pthread_create(clone)\n"); + umount(mp); + close(clone_fd); + close(master_fd); + return 1; + } + + /* readdir + stat + read */ + DIR *d = opendir(mp); + if (!d) { + printf("[FAIL] opendir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + goto fail; + } + int found = 0; + struct dirent *de; + while ((de = readdir(d)) != NULL) { + if (strcmp(de->d_name, "hello.txt") == 0) { + found = 1; + break; + } + } + closedir(d); + if (!found) { + printf("[FAIL] readdir: hello.txt not found\n"); + goto fail; + } + + char p[256]; + snprintf(p, sizeof(p), "%s/hello.txt", mp); + struct stat st; + if (stat(p, &st) != 0) { + printf("[FAIL] stat(%s): %s (errno=%d)\n", p, strerror(errno), errno); + goto fail; + } + if (!S_ISREG(st.st_mode)) { + printf("[FAIL] stat: expected regular file\n"); + goto fail; + } + + char buf[128]; + int n = read_all(p, buf, sizeof(buf) - 1); + if (n < 0) { + printf("[FAIL] read(%s): %s (errno=%d)\n", p, strerror(errno), errno); + goto fail; + } + buf[n] = '\0'; + if (strcmp(buf, "hello from fuse\n") != 0) { + printf("[FAIL] content mismatch: got='%s'\n", buf); + goto fail; + } + + umount(mp); + rmdir(mp); + stop = 1; + close(clone_fd); + close(master_fd); + pthread_join(clone_th, NULL); + printf("[PASS] fuse_clone\n"); + return 0; + +fail: + umount(mp); + stop = 1; + close(clone_fd); + close(master_fd); + pthread_join(clone_th, NULL); + return 1; +} + diff --git a/user/apps/c_unitest/test_fuse_permissions.c b/user/apps/c_unitest/test_fuse_permissions.c new file mode 100644 index 0000000000..5ed4892c3f --- /dev/null +++ b/user/apps/c_unitest/test_fuse_permissions.c @@ -0,0 +1,172 @@ +/** + * @file test_fuse_permissions.c + * @brief Phase E test: allow_other/default_permissions + mount owner restriction. + */ + +#include "fuse_test_simplefs.h" + +#include + +static int wait_init(volatile int *init_done) { + for (int i = 0; i < 200; i++) { + if (*init_done) + return 0; + usleep(10 * 1000); + } + errno = ETIMEDOUT; + return -1; +} + +static int run_child_drop_priv_and_stat(const char *mp, int expect_errno, int expect_success) { + pid_t pid = fork(); + if (pid < 0) { + return -1; + } + if (pid == 0) { + /* child */ + (void)setgid(1000); + (void)setuid(1000); + + struct stat st; + int r = stat(mp, &st); + if (expect_success) { + if (r != 0) + _exit(10); + /* Also check file read works */ + char p[256]; + snprintf(p, sizeof(p), "%s/hello.txt", mp); + int fd = open(p, O_RDONLY); + if (fd < 0) + _exit(11); + char buf[64]; + ssize_t n = read(fd, buf, sizeof(buf) - 1); + close(fd); + if (n < 0) + _exit(12); + buf[n] = '\0'; + if (strcmp(buf, "hello from fuse\n") != 0) + _exit(13); + _exit(0); + } + + if (r == 0) + _exit(20); + if (errno != expect_errno) + _exit(21); + _exit(0); + } + + int status = 0; + if (waitpid(pid, &status, 0) < 0) { + return -1; + } + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { + errno = ECHILD; + return -1; + } + return 0; +} + +static int run_one(const char *mp, const char *opts, uint32_t root_mode_override, + uint32_t hello_mode_override, int expect_errno, int expect_success) { + if (ensure_dir(mp) != 0) { + return -1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + return -1; + } + + volatile int stop = 0; + volatile int init_done = 0; + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + args.exit_after_init = 0; + args.root_mode_override = root_mode_override; + args.hello_mode_override = hello_mode_override; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + close(fd); + return -1; + } + + char full_opts[512]; + snprintf(full_opts, sizeof(full_opts), "fd=%d,%s", fd, opts); + if (mount("none", mp, "fuse", 0, full_opts) != 0) { + stop = 1; + close(fd); + pthread_join(th, NULL); + return -1; + } + + if (wait_init(&init_done) != 0) { + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return -1; + } + + if (run_child_drop_priv_and_stat(mp, expect_errno, expect_success) != 0) { + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return -1; + } + + umount(mp); + rmdir(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 0; +} + +int main(void) { + /* Build opts strings with the real fd inside run_one() */ + /* - For deny cases, use a root dir with no permissions to exercise default_permissions. */ + const uint32_t DIR_NO_PERM = 0040000; + const uint32_t REG_NO_PERM = 0100000; + + /* Case A: mount owner restriction (no allow_other) */ + { + const char *mp = "/tmp/test_fuse_perm_owner"; + if (run_one(mp, "rootmode=040755,user_id=0,group_id=0", 0, 0, EACCES, 0) != 0) { + printf("[FAIL] mount owner restriction\n"); + return 1; + } + } + + /* Case B: allow_other + default_permissions: DAC should deny with no-perm root */ + { + const char *mp = "/tmp/test_fuse_perm_default"; + if (run_one(mp, + "rootmode=040000,user_id=0,group_id=0,allow_other,default_permissions", + DIR_NO_PERM, REG_NO_PERM, EACCES, 0) + != 0) { + printf("[FAIL] default_permissions deny\n"); + return 1; + } + } + + /* Case C: allow_other without default_permissions: bypass DAC, should succeed */ + { + const char *mp = "/tmp/test_fuse_perm_remote"; + if (run_one(mp, "rootmode=040000,user_id=0,group_id=0,allow_other", DIR_NO_PERM, + REG_NO_PERM, 0, 1) + != 0) { + printf("[FAIL] remote permission model allow\n"); + return 1; + } + } + + printf("[PASS] fuse_permissions\n"); + return 0; +} diff --git a/user/apps/fuse_demo/Makefile b/user/apps/fuse_demo/Makefile new file mode 100644 index 0000000000..2d3db9878a --- /dev/null +++ b/user/apps/fuse_demo/Makefile @@ -0,0 +1,27 @@ +ARCH ?= x86_64 +ifeq ($(ARCH), x86_64) + CROSS_COMPILE=x86_64-linux-musl- +else ifeq ($(ARCH), riscv64) + CROSS_COMPILE=riscv64-linux-musl- +endif + +CC=$(CROSS_COMPILE)gcc +CFLAGS := -Wall -O2 -static -lpthread + +SRCS := fuse_demo.c +BINS := $(SRCS:.c=) + +all: $(BINS) + @echo "bins: $(BINS)" + +%: %.c fuse_test_simplefs.h + $(CC) $(CFLAGS) $< -o $@ + +install: all + @echo "Installing binaries to $(DADK_CURRENT_BUILD_DIR)/" + mv $(BINS) $(DADK_CURRENT_BUILD_DIR)/ + +clean: + rm -f $(BINS) + +.PHONY: all install clean diff --git a/user/apps/fuse_demo/README.md b/user/apps/fuse_demo/README.md new file mode 100644 index 0000000000..ea70817681 --- /dev/null +++ b/user/apps/fuse_demo/README.md @@ -0,0 +1,74 @@ +# fuse_demo（DragonOS 最小 FUSE daemon，无 libfuse） + +`fuse_demo` 是 DragonOS 内核 FUSE 功能的**用户态回归/演示程序**，直接读写 `/dev/fuse` 协议，不依赖 `libfuse`。 + +它提供一个极简的内存文件系统： + +- `/hello.txt`：内容为 `hello from fuse\n` + +## 用法 + +``` +fuse_demo [--rw] [--allow-other] [--default-permissions] [--threads N] +``` + +参数说明： + +- ``：挂载点目录（需已存在，或可被创建） +- `--rw`：启用写相关 opcode（create/write/truncate/rename/unlink/mkdir/rmdir） +- `--allow-other`：允许非挂载者/非同 uid 进程访问（对齐 Linux FUSE 的 `allow_other` 行为） +- `--default-permissions`：启用内核侧 DAC 权限检查（对齐 Linux FUSE 的 `default_permissions`） +- `--threads N`：启动 N 个 worker 线程（`N>=1`）。当 `N>1` 时会使用 `FUSE_DEV_IOC_CLONE` 复制连接到新的 `/dev/fuse` fd。 + +调试： + +- `FUSE_TEST_LOG=1`：输出更详细的 request/reply 日志到 stderr + +## 典型示例 + +### 只读演示（ls/stat/cat） + +``` +mkdir -p /mnt/fuse +FUSE_TEST_LOG=1 fuse_demo /mnt/fuse +``` + +另一个终端（或后台运行后）： + +``` +ls -l /mnt/fuse +cat /mnt/fuse/hello.txt +``` + +停止： + +- 前台运行时按 `Ctrl-C`，程序会 best-effort `umount` 并退出 +- 若仍残留挂载：`umount /mnt/fuse` + +### 读写演示（创建/写入/重命名/删除） + +``` +mkdir -p /mnt/fuse +fuse_demo /mnt/fuse --rw + +echo hi > /mnt/fuse/new.txt +cat /mnt/fuse/new.txt +mv /mnt/fuse/new.txt /mnt/fuse/renamed.txt +rm /mnt/fuse/renamed.txt +``` + +### 多线程 / clone 演示 + +``` +mkdir -p /mnt/fuse +fuse_demo /mnt/fuse --threads 4 +``` + +如果内核尚未支持 `FUSE_DEV_IOC_CLONE`，`--threads > 1` 会在 clone 阶段失败并提前退出（或只跑单线程，取决于当时实现）。 + +## 权限语义备注（对应 Phase E） + +- 未指定 `--allow-other`：内核会限制“非挂载者允许的进程”调用到该 FUSE 挂载（更安全，类似 Linux 默认行为）。 +- 未指定 `--default-permissions`：内核会绕过大部分本地 DAC 权限检查（remote model），把权限决策交给用户态 daemon。 + - 本 demo daemon **不做权限拒绝**，因此 remote model 下通常会更“宽松”。 + diff --git a/user/apps/fuse_demo/fuse_demo.c b/user/apps/fuse_demo/fuse_demo.c new file mode 100644 index 0000000000..27ebed912e --- /dev/null +++ b/user/apps/fuse_demo/fuse_demo.c @@ -0,0 +1,189 @@ +/** + * @file fuse_demo.c + * @brief Minimal FUSE demo daemon for DragonOS (no libfuse). + * + * Usage: + * fuse_demo [--rw] [--allow-other] [--default-permissions] [--threads N] + * + * This demo serves a tiny in-memory filesystem: + * /hello.txt (contains "hello from fuse\n") + */ + +#include "fuse_test_simplefs.h" + +#include +#include + +#ifndef FUSE_DEV_IOC_CLONE +#define FUSE_DEV_IOC_CLONE 0x80044600 /* _IOR('F', 0, uint32_t) */ +#endif + +static volatile int g_stop = 0; + +static void on_sigint(int signo) { + (void)signo; + g_stop = 1; +} + +static int parse_int(const char *s, int *out) { + char *end = NULL; + long v = strtol(s, &end, 10); + if (!s[0] || !end || *end != '\0') + return -1; + if (v < 0 || v > 1024) + return -1; + *out = (int)v; + return 0; +} + +int main(int argc, char **argv) { + if (argc < 2) { + fprintf(stderr, + "usage: %s [--rw] [--allow-other] [--default-permissions] [--threads N]\n", + argv[0]); + return 1; + } + + fprintf(stderr, "fuse_demo simplefs rev: %s\n", FUSE_SIMPLEFS_REV); + + const char *mp = argv[1]; + int enable_write_ops = 0; + int allow_other = 0; + int default_permissions = 0; + int threads = 1; + + for (int i = 2; i < argc; i++) { + if (strcmp(argv[i], "--rw") == 0) { + enable_write_ops = 1; + } else if (strcmp(argv[i], "--allow-other") == 0) { + allow_other = 1; + } else if (strcmp(argv[i], "--default-permissions") == 0) { + default_permissions = 1; + } else if (strcmp(argv[i], "--threads") == 0) { + if (i + 1 >= argc || parse_int(argv[i + 1], &threads) != 0 || threads < 1) { + fprintf(stderr, "invalid --threads\n"); + return 1; + } + i++; + } else { + fprintf(stderr, "unknown arg: %s\n", argv[i]); + return 1; + } + } + + if (ensure_dir(mp) != 0) { + perror("ensure_dir"); + return 1; + } + + signal(SIGINT, on_sigint); + signal(SIGTERM, on_sigint); + + int master_fd = open("/dev/fuse", O_RDWR); + if (master_fd < 0) { + perror("open(/dev/fuse)"); + return 1; + } + + volatile int init_done = 0; + volatile int stop = 0; + + struct fuse_daemon_args master_args; + memset(&master_args, 0, sizeof(master_args)); + master_args.fd = master_fd; + master_args.stop = &stop; + master_args.init_done = &init_done; + master_args.enable_write_ops = enable_write_ops; + + pthread_t *ths = calloc((size_t)threads, sizeof(pthread_t)); + struct fuse_daemon_args *args = calloc((size_t)threads, sizeof(struct fuse_daemon_args)); + int *fds = calloc((size_t)threads, sizeof(int)); + if (!ths || !args || !fds) { + fprintf(stderr, "oom\n"); + close(master_fd); + return 1; + } + + fds[0] = master_fd; + args[0] = master_args; + if (pthread_create(&ths[0], NULL, fuse_daemon_thread, &args[0]) != 0) { + fprintf(stderr, "pthread_create(master) failed\n"); + close(master_fd); + return 1; + } + + char opts[512]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=%u,group_id=%u%s%s", master_fd, + (unsigned)getuid(), (unsigned)getgid(), allow_other ? ",allow_other" : "", + default_permissions ? ",default_permissions" : ""); + + if (mount("none", mp, "fuse", 0, opts) != 0) { + perror("mount(fuse)"); + stop = 1; + close(master_fd); + pthread_join(ths[0], NULL); + return 1; + } + + for (int i = 0; i < 200; i++) { + if (init_done) + break; + usleep(10 * 1000); + } + if (!init_done) { + fprintf(stderr, "init handshake timeout\n"); + umount(mp); + stop = 1; + close(master_fd); + pthread_join(ths[0], NULL); + return 1; + } + + /* Optional extra threads via clone */ + for (int i = 1; i < threads; i++) { + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + perror("open(/dev/fuse) for clone"); + break; + } + uint32_t oldfd_u32 = (uint32_t)master_fd; + if (ioctl(fd, FUSE_DEV_IOC_CLONE, &oldfd_u32) != 0) { + perror("ioctl(FUSE_DEV_IOC_CLONE)"); + close(fd); + break; + } + fds[i] = fd; + memset(&args[i], 0, sizeof(args[i])); + args[i].fd = fd; + args[i].stop = &stop; + args[i].init_done = &init_done; + args[i].enable_write_ops = enable_write_ops; + if (pthread_create(&ths[i], NULL, fuse_daemon_thread, &args[i]) != 0) { + perror("pthread_create(clone)"); + close(fd); + break; + } + } + + fprintf(stderr, "fuse_demo mounted at %s (threads=%d). Ctrl-C to stop.\n", mp, threads); + + while (!g_stop) { + sleep(1); + } + + /* Best-effort cleanup */ + umount(mp); + stop = 1; + for (int i = 0; i < threads; i++) { + if (fds[i] > 0) + close(fds[i]); + } + for (int i = 0; i < threads; i++) { + if (ths[i]) + pthread_join(ths[i], NULL); + } + free(fds); + free(args); + free(ths); + return 0; +} diff --git a/user/apps/fuse_demo/fuse_test_simplefs.h b/user/apps/fuse_demo/fuse_test_simplefs.h new file mode 100644 index 0000000000..8be6f9a67c --- /dev/null +++ b/user/apps/fuse_demo/fuse_test_simplefs.h @@ -0,0 +1,899 @@ +/* + * Minimal FUSE userspace daemon for DragonOS kernel tests (no libfuse). + * + * This header provides a tiny in-memory filesystem and request handlers for + * a subset of FUSE opcodes used by Phase C/D tests. + */ + +#pragma once + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define FUSE_TEST_LOG_PREFIX "[fuse-test] " +#define FUSE_SIMPLEFS_REV "statfs-v1" + +static inline int fuse_test_log_enabled(void) { + static int inited = 0; + static int enabled = 0; + if (!inited) { + const char *v = getenv("FUSE_TEST_LOG"); + enabled = (v && v[0] && strcmp(v, "0") != 0); + inited = 1; + } + return enabled; +} + +#define FUSE_TEST_LOG(fmt, ...) \ + do { \ + if (fuse_test_log_enabled()) { \ + fprintf(stderr, FUSE_TEST_LOG_PREFIX fmt "\n", ##__VA_ARGS__); \ + } \ + } while (0) + +#ifndef DT_DIR +#define DT_DIR 4 +#endif +#ifndef DT_REG +#define DT_REG 8 +#endif + +/* Keep test buffers off small thread stacks. */ +#define FUSE_TEST_BUF_SIZE (64 * 1024) + +/* Opcodes (subset) */ +#ifndef FUSE_LOOKUP +#define FUSE_LOOKUP 1 +#endif +#ifndef FUSE_GETATTR +#define FUSE_GETATTR 3 +#endif +#ifndef FUSE_SETATTR +#define FUSE_SETATTR 4 +#endif +#ifndef FUSE_MKNOD +#define FUSE_MKNOD 8 +#endif +#ifndef FUSE_MKDIR +#define FUSE_MKDIR 9 +#endif +#ifndef FUSE_UNLINK +#define FUSE_UNLINK 10 +#endif +#ifndef FUSE_RMDIR +#define FUSE_RMDIR 11 +#endif +#ifndef FUSE_RENAME +#define FUSE_RENAME 12 +#endif +#ifndef FUSE_OPEN +#define FUSE_OPEN 14 +#endif +#ifndef FUSE_READ +#define FUSE_READ 15 +#endif +#ifndef FUSE_WRITE +#define FUSE_WRITE 16 +#endif +#ifndef FUSE_STATFS +#define FUSE_STATFS 17 +#endif +#ifndef FUSE_RELEASE +#define FUSE_RELEASE 18 +#endif +#ifndef FUSE_INIT +#define FUSE_INIT 26 +#endif +#ifndef FUSE_OPENDIR +#define FUSE_OPENDIR 27 +#endif +#ifndef FUSE_READDIR +#define FUSE_READDIR 28 +#endif +#ifndef FUSE_RELEASEDIR +#define FUSE_RELEASEDIR 29 +#endif + +/* setattr valid bits (subset) */ +#ifndef FATTR_MODE +#define FATTR_MODE (1u << 0) +#endif +#ifndef FATTR_UID +#define FATTR_UID (1u << 1) +#endif +#ifndef FATTR_GID +#define FATTR_GID (1u << 2) +#endif +#ifndef FATTR_SIZE +#define FATTR_SIZE (1u << 3) +#endif + +struct fuse_in_header { + uint32_t len; + uint32_t opcode; + uint64_t unique; + uint64_t nodeid; + uint32_t uid; + uint32_t gid; + uint32_t pid; + uint16_t total_extlen; + uint16_t padding; +}; + +struct fuse_out_header { + uint32_t len; + int32_t error; /* -errno */ + uint64_t unique; +}; + +struct fuse_init_in { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; + uint32_t flags2; + uint32_t unused[11]; +}; + +struct fuse_init_out { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; + uint16_t max_background; + uint16_t congestion_threshold; + uint32_t max_write; + uint32_t time_gran; + uint16_t max_pages; + uint16_t map_alignment; + uint32_t flags2; + uint32_t unused[7]; +}; + +struct fuse_attr { + uint64_t ino; + uint64_t size; + uint64_t blocks; + uint64_t atime; + uint64_t mtime; + uint64_t ctime; + uint32_t atimensec; + uint32_t mtimensec; + uint32_t ctimensec; + uint32_t mode; + uint32_t nlink; + uint32_t uid; + uint32_t gid; + uint32_t rdev; + uint32_t blksize; + uint32_t flags; +}; + +struct fuse_entry_out { + uint64_t nodeid; + uint64_t generation; + uint64_t entry_valid; + uint64_t attr_valid; + uint32_t entry_valid_nsec; + uint32_t attr_valid_nsec; + struct fuse_attr attr; +}; + +struct fuse_getattr_in { + uint32_t getattr_flags; + uint32_t dummy; + uint64_t fh; +}; + +struct fuse_attr_out { + uint64_t attr_valid; + uint32_t attr_valid_nsec; + uint32_t dummy; + struct fuse_attr attr; +}; + +struct fuse_open_in { + uint32_t flags; + uint32_t open_flags; +}; + +struct fuse_open_out { + uint64_t fh; + uint32_t open_flags; + uint32_t padding; +}; + +struct fuse_read_in { + uint64_t fh; + uint64_t offset; + uint32_t size; + uint32_t read_flags; + uint64_t lock_owner; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_write_in { + uint64_t fh; + uint64_t offset; + uint32_t size; + uint32_t write_flags; + uint64_t lock_owner; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_write_out { + uint32_t size; + uint32_t padding; +}; + +struct fuse_kstatfs { + uint64_t blocks; + uint64_t bfree; + uint64_t bavail; + uint64_t files; + uint64_t ffree; + uint32_t bsize; + uint32_t namelen; + uint32_t frsize; + uint32_t padding; + uint32_t spare[6]; +}; + +struct fuse_statfs_out { + struct fuse_kstatfs st; +}; + +struct fuse_release_in { + uint64_t fh; + uint32_t flags; + uint32_t release_flags; + uint64_t lock_owner; +}; + +struct fuse_mknod_in { + uint32_t mode; + uint32_t rdev; + uint32_t umask; + uint32_t padding; +}; + +struct fuse_mkdir_in { + uint32_t mode; + uint32_t umask; +}; + +struct fuse_rename_in { + uint64_t newdir; +}; + +struct fuse_setattr_in { + uint32_t valid; + uint32_t padding; + uint64_t fh; + uint64_t size; + uint64_t lock_owner; + uint64_t atime; + uint64_t mtime; + uint64_t ctime; + uint32_t atimensec; + uint32_t mtimensec; + uint32_t ctimensec; + uint32_t mode; + uint32_t unused4; + uint32_t uid; + uint32_t gid; + uint32_t unused5; +}; + +struct fuse_dirent { + uint64_t ino; + uint64_t off; + uint32_t namelen; + uint32_t type; + /* char name[]; */ +}; + +static inline size_t fuse_dirent_rec_len(size_t namelen) { + size_t unaligned = sizeof(struct fuse_dirent) + namelen; + return (unaligned + 8 - 1) & ~(size_t)(8 - 1); +} + +/* ===== in-memory FS ===== */ + +#define SIMPLEFS_MAX_NODES 64 +#define SIMPLEFS_NAME_MAX 64 +#define SIMPLEFS_DATA_MAX 8192 + +struct simplefs_node { + int used; + uint64_t nodeid; + uint64_t ino; + uint64_t parent; + int is_dir; + uint32_t mode; /* includes type bits */ + char name[SIMPLEFS_NAME_MAX]; + unsigned char data[SIMPLEFS_DATA_MAX]; + size_t size; +}; + +struct simplefs { + struct simplefs_node nodes[SIMPLEFS_MAX_NODES]; + uint64_t next_nodeid; + uint64_t next_ino; +}; + +static inline void simplefs_init(struct simplefs *fs) { + memset(fs, 0, sizeof(*fs)); + fs->next_nodeid = 2; + fs->next_ino = 2; + + /* root nodeid=1 */ + fs->nodes[0].used = 1; + fs->nodes[0].nodeid = 1; + fs->nodes[0].ino = 1; + fs->nodes[0].parent = 1; + fs->nodes[0].is_dir = 1; + fs->nodes[0].mode = 0040755; + strcpy(fs->nodes[0].name, ""); + fs->nodes[0].size = 0; + + /* hello.txt under root */ + fs->nodes[1].used = 1; + fs->nodes[1].nodeid = 2; + fs->nodes[1].ino = 2; + fs->nodes[1].parent = 1; + fs->nodes[1].is_dir = 0; + fs->nodes[1].mode = 0100644; + strcpy(fs->nodes[1].name, "hello.txt"); + const char *msg = "hello from fuse\n"; + fs->nodes[1].size = strlen(msg); + memcpy(fs->nodes[1].data, msg, fs->nodes[1].size); + + fs->next_nodeid = 3; + fs->next_ino = 3; +} + +static inline struct simplefs_node *simplefs_find_node(struct simplefs *fs, uint64_t nodeid) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (fs->nodes[i].used && fs->nodes[i].nodeid == nodeid) { + return &fs->nodes[i]; + } + } + return NULL; +} + +static inline struct simplefs_node *simplefs_find_child(struct simplefs *fs, uint64_t parent, + const char *name) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (!fs->nodes[i].used) + continue; + if (fs->nodes[i].parent != parent) + continue; + if (strcmp(fs->nodes[i].name, name) == 0) + return &fs->nodes[i]; + } + return NULL; +} + +static inline int simplefs_has_children(struct simplefs *fs, uint64_t parent) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (!fs->nodes[i].used) + continue; + if (fs->nodes[i].parent == parent) + return 1; + } + return 0; +} + +static inline struct simplefs_node *simplefs_alloc(struct simplefs *fs) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (!fs->nodes[i].used) { + struct simplefs_node *n = &fs->nodes[i]; + memset(n, 0, sizeof(*n)); + n->used = 1; + n->nodeid = fs->next_nodeid++; + n->ino = fs->next_ino++; + return n; + } + } + return NULL; +} + +static inline void simplefs_fill_attr(const struct simplefs_node *n, struct fuse_attr *a) { + memset(a, 0, sizeof(*a)); + a->ino = n->ino; + a->size = n->size; + a->blocks = (n->size + 511) / 512; + a->mode = n->mode; + a->nlink = n->is_dir ? 2 : 1; + a->uid = getuid(); + a->gid = getgid(); + a->blksize = 4096; +} + +static inline int fuse_write_reply(int fd, uint64_t unique, int err_neg, const void *payload, + size_t payload_len) { + struct fuse_out_header out; + memset(&out, 0, sizeof(out)); + out.len = sizeof(out) + (uint32_t)payload_len; + out.error = err_neg; + out.unique = unique; + + size_t total = sizeof(out) + payload_len; + unsigned char *buf = malloc(total); + if (!buf) { + errno = ENOMEM; + return -1; + } + memcpy(buf, &out, sizeof(out)); + if (payload_len) { + memcpy(buf + sizeof(out), payload, payload_len); + } + ssize_t wn = write(fd, buf, total); + free(buf); + if (wn == (ssize_t)total) { + FUSE_TEST_LOG("reply unique=%llu err=%d len=%zu", + (unsigned long long)unique, (int)err_neg, total); + } + if (wn != (ssize_t)total) { + return -1; + } + return 0; +} + +struct fuse_daemon_args { + int fd; + volatile int *stop; + volatile int *init_done; + int enable_write_ops; + int exit_after_init; + uint32_t root_mode_override; + uint32_t hello_mode_override; + struct simplefs fs; +}; + +static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned char *req, size_t n) { + if (n < sizeof(struct fuse_in_header)) { + return -1; + } + const struct fuse_in_header *h = (const struct fuse_in_header *)req; + const unsigned char *payload = req + sizeof(*h); + size_t payload_len = n - sizeof(*h); + FUSE_TEST_LOG("handle opcode=%u unique=%llu nodeid=%llu len=%u payload=%zu", + h->opcode, (unsigned long long)h->unique, (unsigned long long)h->nodeid, + h->len, payload_len); + + switch (h->opcode) { + case FUSE_INIT: { + if (payload_len < sizeof(struct fuse_init_in)) { + return -1; + } + struct fuse_init_out out; + memset(&out, 0, sizeof(out)); + out.major = 7; + out.minor = 39; + out.max_write = 4096; + if (fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)) != 0) { + return -1; + } + *a->init_done = 1; + return 0; + } + case FUSE_LOOKUP: { + const char *name = (const char *)payload; + if (payload_len == 0 || name[payload_len - 1] != '\0') { + return -1; + } + struct simplefs_node *parent = simplefs_find_node(&a->fs, h->nodeid); + if (!parent || !parent->is_dir) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + struct simplefs_node *child = simplefs_find_child(&a->fs, h->nodeid, name); + if (!child) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + struct fuse_entry_out out; + memset(&out, 0, sizeof(out)); + out.nodeid = child->nodeid; + simplefs_fill_attr(child, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_GETATTR: { + (void)payload; + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + struct fuse_attr_out out; + memset(&out, 0, sizeof(out)); + simplefs_fill_attr(node, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_OPENDIR: + case FUSE_OPEN: { + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (h->opcode == FUSE_OPENDIR && !node->is_dir) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (h->opcode == FUSE_OPEN && node->is_dir) { + return fuse_write_reply(a->fd, h->unique, -EISDIR, NULL, 0); + } + struct fuse_open_out out; + memset(&out, 0, sizeof(out)); + out.fh = node->nodeid; + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_READ: { + if (payload_len < sizeof(struct fuse_read_in)) { + return -1; + } + const struct fuse_read_in *in = (const struct fuse_read_in *)payload; + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node || node->is_dir) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } + if (in->offset >= node->size) { + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } + size_t remain = node->size - (size_t)in->offset; + size_t to_copy = in->size; + if (to_copy > remain) { + to_copy = remain; + } + return fuse_write_reply(a->fd, h->unique, 0, node->data + in->offset, to_copy); + } + case FUSE_READDIR: { + if (payload_len < sizeof(struct fuse_read_in)) { + return -1; + } + const struct fuse_read_in *in = (const struct fuse_read_in *)payload; + (void)in; + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node || !node->is_dir) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + + /* offset is an entry index: 0=".", 1="..", then children */ + uint64_t idx = in->offset; + unsigned char *outbuf = malloc(FUSE_TEST_BUF_SIZE); + if (!outbuf) { + return fuse_write_reply(a->fd, h->unique, -ENOMEM, NULL, 0); + } + size_t outlen = 0; + + const char *fixed_names[2] = {".", ".."}; + for (; idx < 2; idx++) { + const char *nm = fixed_names[idx]; + size_t nmlen = strlen(nm); + size_t reclen = fuse_dirent_rec_len(nmlen); + if (outlen + reclen > FUSE_TEST_BUF_SIZE) + break; + struct fuse_dirent de; + memset(&de, 0, sizeof(de)); + de.ino = 1; + de.off = idx + 1; + de.namelen = (uint32_t)nmlen; + de.type = DT_DIR; + memcpy(outbuf + outlen, &de, sizeof(de)); + memcpy(outbuf + outlen + sizeof(de), nm, nmlen); + outlen += reclen; + } + + /* children in insertion order */ + uint64_t child_base = 2; + uint64_t cur = idx; + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + struct simplefs_node *c = &a->fs.nodes[i]; + if (!c->used || c->parent != h->nodeid) + continue; + if (cur < child_base) { + cur = child_base; + } + if (cur > child_base) { + /* skip until we reach this entry index */ + child_base++; + continue; + } + + size_t nmlen = strlen(c->name); + size_t reclen = fuse_dirent_rec_len(nmlen); + if (outlen + reclen > FUSE_TEST_BUF_SIZE) + break; + struct fuse_dirent de; + memset(&de, 0, sizeof(de)); + de.ino = c->ino; + de.off = child_base + 1; + de.namelen = (uint32_t)nmlen; + de.type = c->is_dir ? DT_DIR : DT_REG; + memcpy(outbuf + outlen, &de, sizeof(de)); + memcpy(outbuf + outlen + sizeof(de), c->name, nmlen); + outlen += reclen; + + child_base++; + cur++; + } + + int ret = fuse_write_reply(a->fd, h->unique, 0, outbuf, outlen); + free(outbuf); + return ret; + } + case FUSE_STATFS: { + struct fuse_statfs_out out; + memset(&out, 0, sizeof(out)); + + unsigned used = 0; + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (a->fs.nodes[i].used) { + used++; + } + } + + out.st.blocks = 1024; + out.st.bfree = 512; + out.st.bavail = 512; + out.st.files = SIMPLEFS_MAX_NODES; + out.st.ffree = (used > SIMPLEFS_MAX_NODES) ? 0 : (SIMPLEFS_MAX_NODES - used); + out.st.bsize = 4096; + out.st.frsize = 4096; + out.st.namelen = SIMPLEFS_NAME_MAX - 1; + FUSE_TEST_LOG("statfs reply ok blocks=%llu bfree=%llu bavail=%llu", + (unsigned long long)out.st.blocks, + (unsigned long long)out.st.bfree, + (unsigned long long)out.st.bavail); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_RELEASE: + case FUSE_RELEASEDIR: + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_WRITE: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_write_in)) { + return -1; + } + const struct fuse_write_in *in = (const struct fuse_write_in *)payload; + const unsigned char *data = payload + sizeof(*in); + size_t data_len = payload_len - sizeof(*in); + if (data_len < in->size) { + return -1; + } + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node || node->is_dir) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } + if (in->offset >= SIMPLEFS_DATA_MAX) { + return fuse_write_reply(a->fd, h->unique, -EFBIG, NULL, 0); + } + size_t to_copy = in->size; + if (in->offset + to_copy > SIMPLEFS_DATA_MAX) { + to_copy = SIMPLEFS_DATA_MAX - (size_t)in->offset; + } + memcpy(node->data + in->offset, data, to_copy); + if (node->size < in->offset + to_copy) { + node->size = (size_t)in->offset + to_copy; + } + struct fuse_write_out out; + memset(&out, 0, sizeof(out)); + out.size = (uint32_t)to_copy; + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_MKDIR: + case FUSE_MKNOD: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + const char *name = NULL; + size_t name_off = 0; + int is_dir = (h->opcode == FUSE_MKDIR); + uint32_t mode = 0; + if (is_dir) { + if (payload_len < sizeof(struct fuse_mkdir_in) + 1) + return -1; + const struct fuse_mkdir_in *in = (const struct fuse_mkdir_in *)payload; + mode = in->mode; + name_off = sizeof(*in); + } else { + if (payload_len < sizeof(struct fuse_mknod_in) + 1) + return -1; + const struct fuse_mknod_in *in = (const struct fuse_mknod_in *)payload; + mode = in->mode; + name_off = sizeof(*in); + } + name = (const char *)(payload + name_off); + if (name[payload_len - name_off - 1] != '\0') + return -1; + if (simplefs_find_child(&a->fs, h->nodeid, name)) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + struct simplefs_node *p = simplefs_find_node(&a->fs, h->nodeid); + if (!p || !p->is_dir) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + struct simplefs_node *nnode = simplefs_alloc(&a->fs); + if (!nnode) { + return fuse_write_reply(a->fd, h->unique, -ENOSPC, NULL, 0); + } + nnode->parent = h->nodeid; + nnode->is_dir = is_dir; + nnode->mode = mode; + strncpy(nnode->name, name, sizeof(nnode->name) - 1); + nnode->size = 0; + + struct fuse_entry_out out; + memset(&out, 0, sizeof(out)); + out.nodeid = nnode->nodeid; + simplefs_fill_attr(nnode, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_UNLINK: + case FUSE_RMDIR: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + const char *name = (const char *)payload; + if (payload_len == 0 || name[payload_len - 1] != '\0') { + return -1; + } + struct simplefs_node *child = simplefs_find_child(&a->fs, h->nodeid, name); + if (!child) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (h->opcode == FUSE_RMDIR) { + if (!child->is_dir) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (simplefs_has_children(&a->fs, child->nodeid)) { + return fuse_write_reply(a->fd, h->unique, -ENOTEMPTY, NULL, 0); + } + } else { + if (child->is_dir) { + return fuse_write_reply(a->fd, h->unique, -EISDIR, NULL, 0); + } + } + child->used = 0; + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } + case FUSE_RENAME: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_rename_in) + 3) { + return -1; + } + const struct fuse_rename_in *in = (const struct fuse_rename_in *)payload; + const char *names = (const char *)(payload + sizeof(*in)); + size_t names_len = payload_len - sizeof(*in); + + /* oldname\0newname\0 */ + const char *oldname = names; + size_t oldlen = strnlen(oldname, names_len); + if (oldlen == names_len) + return -1; + const char *newname = names + oldlen + 1; + size_t remain = names_len - oldlen - 1; + if (remain == 0) + return -1; + size_t newlen = strnlen(newname, remain); + if (newlen == remain) + return -1; + + struct simplefs_node *src = simplefs_find_child(&a->fs, h->nodeid, oldname); + if (!src) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (simplefs_find_child(&a->fs, in->newdir, newname)) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + struct simplefs_node *dst_parent = simplefs_find_node(&a->fs, in->newdir); + if (!dst_parent || !dst_parent->is_dir) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + src->parent = in->newdir; + strncpy(src->name, newname, sizeof(src->name) - 1); + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } + case FUSE_SETATTR: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_setattr_in)) { + return -1; + } + const struct fuse_setattr_in *in = (const struct fuse_setattr_in *)payload; + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (in->valid & FATTR_SIZE) { + if (in->size > SIMPLEFS_DATA_MAX) { + return fuse_write_reply(a->fd, h->unique, -EFBIG, NULL, 0); + } + node->size = (size_t)in->size; + } + if (in->valid & FATTR_MODE) { + node->mode = in->mode; + } + struct fuse_attr_out out; + memset(&out, 0, sizeof(out)); + simplefs_fill_attr(node, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + default: + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } +} + +static inline void *fuse_daemon_thread(void *arg) { + struct fuse_daemon_args *a = (struct fuse_daemon_args *)arg; + unsigned char *buf = malloc(FUSE_TEST_BUF_SIZE); + if (!buf) { + return NULL; + } + + simplefs_init(&a->fs); + if (a->root_mode_override) { + a->fs.nodes[0].mode = a->root_mode_override; + } + if (a->hello_mode_override) { + a->fs.nodes[1].mode = a->hello_mode_override; + } + + while (!*a->stop) { + FUSE_TEST_LOG("daemon read start"); + ssize_t n = read(a->fd, buf, FUSE_TEST_BUF_SIZE); + if (n < 0) { + FUSE_TEST_LOG("daemon read error n=%zd errno=%d", n, errno); + if (errno == EINTR) + continue; + if (errno == ENOTCONN) + break; + continue; + } + if (n == 0) { + FUSE_TEST_LOG("daemon read EOF"); + break; + } + FUSE_TEST_LOG("daemon read n=%zd", n); + struct fuse_in_header *h = (struct fuse_in_header *)buf; + if ((size_t)n != h->len) { + FUSE_TEST_LOG("daemon short read n=%zd hdr.len=%u", n, h->len); + continue; + } + (void)fuse_handle_one(a, buf, (size_t)n); + if (a->exit_after_init && a->init_done && *a->init_done) { + break; + } + } + free(buf); + return NULL; +} + +static inline int ensure_dir(const char *path) { + struct stat st; + if (stat(path, &st) == 0) { + if (S_ISDIR(st.st_mode)) + return 0; + errno = ENOTDIR; + return -1; + } + return mkdir(path, 0755); +} diff --git a/user/apps/tests/syscall/gvisor/whitelist.txt b/user/apps/tests/syscall/gvisor/whitelist.txt index c4b5bc8641..41a840da64 100644 --- a/user/apps/tests/syscall/gvisor/whitelist.txt +++ b/user/apps/tests/syscall/gvisor/whitelist.txt @@ -16,6 +16,7 @@ pause_test chroot_test creat_test dup_test +fuse_test write_test mkdir_test mknod_test diff --git a/user/dadk/config/fuse_demo.toml b/user/dadk/config/fuse_demo.toml new file mode 100644 index 0000000000..e305bab846 --- /dev/null +++ b/user/dadk/config/fuse_demo.toml @@ -0,0 +1,36 @@ +# 用户程序名称 +name = "fuse_demo" +# 版本号 +version = "0.1.0" +# 用户程序描述信息 +description = "" +# （可选）是否只构建一次，如果为true，DADK会在构建成功后，将构建结果缓存起来，下次构建时，直接使用缓存的构建结果 +build-once = false +# (可选) 是否只安装一次，如果为true，DADK会在安装成功后，不再重复安装 +install-once = false +# 目标架构 +# 可选值："x86_64", "aarch64", "riscv64" +target-arch = ["x86_64"] +# 任务源 +[task-source] +# 构建类型 +# 可选值："build-from_source", "install-from-prebuilt" +type = "build-from-source" +# 构建来源 +# "build_from_source" 可选值："git", "local", "archive" +# "install_from_prebuilt" 可选值："local", "archive" +source = "local" +# 路径或URL +source-path = "user/apps/fuse_demo" +# 构建相关信息 +[build] +# （可选）构建命令 +build-command = "make install -j8" +# 安装相关信息 +[install] +# （可选）安装到DragonOS的路径 +in-dragonos-path = "/bin" +# 清除相关信息 +[clean] +# （可选）清除命令 +clean-command = "make clean" From c50ae45ccc0b26323f2a2bf78199e1da0461f97f Mon Sep 17 00:00:00 2001 From: longjin Date: Sun, 8 Feb 2026 11:14:49 +0800 Subject: [PATCH 05/16] feat(fuse): enhance FUSE connection management and request handling - Introduced `FuseInitNegotiated` structure to manage negotiated parameters during FUSE initialization. - Implemented `on_umount` method to handle unmounting, ensuring in-flight requests are properly failed and queued for destruction. - Added `queue_forget` method to send FORGET messages for node lookups. - Enhanced read request handling to enforce minimum buffer size requirements. - Updated protocol definitions to include new FUSE opcodes and flags. - Removed obsolete `fuse_test_simplefs.h` header file. Signed-off-by: longjin --- kernel/src/filesystem/fuse/conn.rs | 222 ++++- kernel/src/filesystem/fuse/fs.rs | 21 +- kernel/src/filesystem/fuse/inode.rs | 139 ++- kernel/src/filesystem/fuse/protocol.rs | 30 + user/apps/c_unitest/fuse_test_simplefs.h | 891 ------------------ user/apps/fuse_demo/Makefile | 4 +- user/apps/fuse_demo/README.md | 13 +- user/apps/fuse_demo/fuse_demo.c | 2 + user/apps/fuse_demo/fuse_test_simplefs.h | 56 ++ .../test_fuse_clone.c | 0 .../{c_unitest => fuse_demo}/test_fuse_dev.c | 35 +- .../test_fuse_mount_init.c | 124 +-- user/apps/fuse_demo/test_fuse_p1_lifecycle.c | 124 +++ .../test_fuse_permissions.c | 0 .../test_fuse_phase_c.c | 0 .../test_fuse_phase_d.c | 0 16 files changed, 628 insertions(+), 1033 deletions(-) delete mode 100644 user/apps/c_unitest/fuse_test_simplefs.h rename user/apps/{c_unitest => fuse_demo}/test_fuse_clone.c (100%) rename user/apps/{c_unitest => fuse_demo}/test_fuse_dev.c (57%) rename user/apps/{c_unitest => fuse_demo}/test_fuse_mount_init.c (67%) create mode 100644 user/apps/fuse_demo/test_fuse_p1_lifecycle.c rename user/apps/{c_unitest => fuse_demo}/test_fuse_permissions.c (100%) rename user/apps/{c_unitest => fuse_demo}/test_fuse_phase_c.c (100%) rename user/apps/{c_unitest => fuse_demo}/test_fuse_phase_d.c (100%) diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs index fd58f676be..7e7dcdf592 100644 --- a/kernel/src/filesystem/fuse/conn.rs +++ b/kernel/src/filesystem/fuse/conn.rs @@ -18,8 +18,13 @@ use crate::{ use crate::process::cred::CAPFlags; use super::protocol::{ - fuse_pack_struct, fuse_read_struct, FuseInHeader, FuseInitIn, FuseInitOut, FuseOutHeader, - FUSE_INIT, FUSE_KERNEL_MINOR_VERSION, FUSE_KERNEL_VERSION, + fuse_pack_struct, fuse_read_struct, FuseForgetIn, FuseInHeader, FuseInitIn, FuseInitOut, + FuseOutHeader, FuseWriteIn, FUSE_ABORT_ERROR, FUSE_ASYNC_DIO, FUSE_ASYNC_READ, + FUSE_ATOMIC_O_TRUNC, FUSE_AUTO_INVAL_DATA, FUSE_BIG_WRITES, FUSE_DESTROY, FUSE_DONT_MASK, + FUSE_EXPLICIT_INVAL_DATA, FUSE_EXPORT_SUPPORT, FUSE_FORGET, FUSE_HANDLE_KILLPRIV, FUSE_INIT, + FUSE_INIT_EXT, FUSE_KERNEL_MINOR_VERSION, FUSE_KERNEL_VERSION, FUSE_MAX_PAGES, + FUSE_MIN_READ_BUFFER, FUSE_NO_OPENDIR_SUPPORT, FUSE_NO_OPEN_SUPPORT, FUSE_PARALLEL_DIROPS, + FUSE_POSIX_ACL, FUSE_POSIX_LOCKS, FUSE_WRITEBACK_CACHE, }; #[derive(Debug)] @@ -83,6 +88,30 @@ impl FusePendingState { } } +#[derive(Debug, Clone, Copy)] +struct FuseInitNegotiated { + minor: u32, + max_readahead: u32, + max_write: u32, + time_gran: u32, + max_pages: u16, + flags: u64, +} + +impl Default for FuseInitNegotiated { + fn default() -> Self { + Self { + minor: 0, + max_readahead: 0, + // Linux guarantees max_write >= 4096 after init; before init keep sane default. + max_write: 4096, + time_gran: 0, + max_pages: 1, + flags: 0, + } + } +} + #[derive(Debug)] struct FuseConnInner { connected: bool, @@ -91,6 +120,7 @@ struct FuseConnInner { owner_uid: u32, owner_gid: u32, allow_other: bool, + init: FuseInitNegotiated, pending: VecDeque>, processing: BTreeMap>, } @@ -116,6 +146,7 @@ impl FuseConn { owner_uid: 0, owner_gid: 0, allow_other: false, + init: FuseInitNegotiated::default(), pending: VecDeque::new(), processing: BTreeMap::new(), }), @@ -233,6 +264,7 @@ impl FuseConn { let processing: Vec> = { let mut g = self.inner.lock(); g.connected = false; + g.mounted = false; g.pending.clear(); let processing = g.processing.values().cloned().collect(); g.processing.clear(); @@ -249,6 +281,54 @@ impl FuseConn { ); } + /// Unmount path: fail in-flight requests and best-effort queue DESTROY. + /// + /// Keep the connection readable for daemon-side teardown; actual disconnect + /// happens when /dev/fuse is closed or explicit abort path is triggered. + pub fn on_umount(&self) { + let processing: Vec>; + let should_destroy: bool; + { + let mut g = self.inner.lock(); + should_destroy = g.connected && g.initialized; + g.mounted = false; + g.pending.clear(); + processing = g.processing.values().cloned().collect(); + g.processing.clear(); + } + + for p in processing { + p.complete(Err(SystemError::ENOTCONN)); + } + self.init_wait.wakeup(None); + + if !should_destroy { + self.abort(); + return; + } + + if self.enqueue_noreply(FUSE_DESTROY, 0, &[]).is_err() { + self.abort(); + return; + } + } + + /// Queue a FORGET message (no reply expected). + pub fn queue_forget(&self, nodeid: u64, nlookup: u64) -> Result<(), SystemError> { + if nodeid == 0 || nlookup == 0 { + return Ok(()); + } + let can_send = { + let g = self.inner.lock(); + g.connected && g.mounted && g.initialized + }; + if !can_send { + return Ok(()); + } + let inarg = FuseForgetIn { nlookup }; + self.enqueue_noreply(FUSE_FORGET, nodeid, fuse_pack_struct(&inarg)) + } + /// Acquire a new `/dev/fuse` file handle reference to this connection. pub fn dev_acquire(&self) { self.dev_count.fetch_add(1, Ordering::Relaxed); @@ -296,9 +376,32 @@ impl FuseConn { Err(SystemError::ENOENT) } + fn calc_min_read_buffer(max_write: usize) -> usize { + core::cmp::max( + FUSE_MIN_READ_BUFFER, + core::mem::size_of::() + core::mem::size_of::() + max_write, + ) + } + + fn min_read_buffer(&self) -> usize { + let g = self.inner.lock(); + Self::calc_min_read_buffer(g.init.max_write as usize) + } + pub fn read_request(&self, nonblock: bool, out: &mut [u8]) -> Result { - // Linux: if O_NONBLOCK, return EAGAIN. + // Linux: require a sane minimum read buffer for all reads. + let min_read = self.min_read_buffer(); + if out.len() < min_read { + log::warn!( + "fuse: read buffer too small: got={} min={} nonblock={}", + out.len(), + min_read, + nonblock + ); + return Err(SystemError::EINVAL); + } + // Linux: if O_NONBLOCK and no pending request, return EAGAIN. let req = if nonblock { let mut g = self.inner.lock(); if !g.connected { @@ -338,11 +441,17 @@ impl FuseConn { }; if out.len() < req.bytes.len() { - // Put it back and report EINVAL: user must provide a sufficiently large buffer. + // Put it back and report EINVAL: userspace must provide a sufficiently large buffer. + let req_len = req.bytes.len(); let mut g = self.inner.lock(); if g.connected { g.pending.push_front(req); } + log::warn!( + "fuse: read buffer smaller than queued request: got={} need={}", + out.len(), + req_len + ); return Err(SystemError::EINVAL); } @@ -350,13 +459,35 @@ impl FuseConn { Ok(req.bytes.len()) } + fn kernel_init_flags() -> u64 { + FUSE_ASYNC_READ + | FUSE_POSIX_LOCKS + | FUSE_ATOMIC_O_TRUNC + | FUSE_EXPORT_SUPPORT + | FUSE_BIG_WRITES + | FUSE_DONT_MASK + | FUSE_AUTO_INVAL_DATA + | FUSE_ASYNC_DIO + | FUSE_WRITEBACK_CACHE + | FUSE_NO_OPEN_SUPPORT + | FUSE_PARALLEL_DIROPS + | FUSE_HANDLE_KILLPRIV + | FUSE_POSIX_ACL + | FUSE_ABORT_ERROR + | FUSE_MAX_PAGES + | FUSE_NO_OPENDIR_SUPPORT + | FUSE_EXPLICIT_INVAL_DATA + | FUSE_INIT_EXT + } + pub fn enqueue_init(&self) -> Result<(), SystemError> { + let flags = Self::kernel_init_flags(); let init_in = FuseInitIn { major: FUSE_KERNEL_VERSION, minor: FUSE_KERNEL_MINOR_VERSION, max_readahead: 0, - flags: 0, - flags2: 0, + flags: flags as u32, + flags2: (flags >> 32) as u32, unused: [0; 11], }; self.enqueue_request(FUSE_INIT, 0, fuse_pack_struct(&init_in)) @@ -380,6 +511,41 @@ impl FuseConn { .wait_complete() } + fn enqueue_noreply(&self, opcode: u32, nodeid: u64, payload: &[u8]) -> Result<(), SystemError> { + let unique = self.alloc_unique(); + let hdr = FuseInHeader { + len: (core::mem::size_of::() + payload.len()) as u32, + opcode, + unique, + nodeid, + uid: 0, + gid: 0, + pid: 0, + total_extlen: 0, + padding: 0, + }; + + let mut bytes = Vec::with_capacity(hdr.len as usize); + bytes.extend_from_slice(fuse_pack_struct(&hdr)); + bytes.extend_from_slice(payload); + let req = Arc::new(FuseRequest { bytes }); + + { + let mut g = self.inner.lock(); + if !g.connected { + return Err(SystemError::ENOTCONN); + } + g.pending.push_back(req); + } + + self.read_wait.wakeup(None); + let _ = EventPoll::wakeup_epoll( + &self.epitems, + EPollEventType::EPOLLIN | EPollEventType::EPOLLRDNORM, + ); + Ok(()) + } + fn enqueue_request( &self, opcode: u32, @@ -466,20 +632,45 @@ impl FuseConn { } if pending.opcode == FUSE_INIT { - let init_out: FuseInitOut = fuse_read_struct(payload)?; + let init_out: FuseInitOut = match fuse_read_struct(payload) { + Ok(v) => v, + Err(e) => { + pending.complete(Err(e)); + self.abort(); + return Ok(data.len()); + } + }; + if init_out.major != FUSE_KERNEL_VERSION { pending.complete(Err(SystemError::EINVAL)); self.abort(); return Ok(data.len()); } - // Negotiate minor version: use the smaller one. - let _negotiated_minor = core::cmp::min(init_out.minor, FUSE_KERNEL_MINOR_VERSION); + let mut negotiated_flags = init_out.flags as u64; + if (negotiated_flags & FUSE_INIT_EXT) != 0 { + negotiated_flags |= (init_out.flags2 as u64) << 32; + } + let negotiated_minor = core::cmp::min(init_out.minor, FUSE_KERNEL_MINOR_VERSION); + let negotiated_max_pages = + if (negotiated_flags & FUSE_MAX_PAGES) != 0 && init_out.max_pages != 0 { + init_out.max_pages + } else { + 1 + }; { let mut g = self.inner.lock(); if g.connected { g.initialized = true; + g.init = FuseInitNegotiated { + minor: negotiated_minor, + max_readahead: init_out.max_readahead, + max_write: core::cmp::max(4096, init_out.max_write), + time_gran: init_out.time_gran, + max_pages: negotiated_max_pages, + flags: negotiated_flags, + }; } } self.init_wait.wakeup(None); @@ -488,4 +679,17 @@ impl FuseConn { pending.complete(Ok(payload.to_vec())); Ok(data.len()) } + + #[allow(dead_code)] + pub fn negotiated_state(&self) -> (u32, u32, u32, u32, u16, u64) { + let g = self.inner.lock(); + ( + g.init.minor, + g.init.max_readahead, + g.init.max_write, + g.init.time_gran, + g.init.max_pages, + g.init.flags, + ) + } } diff --git a/kernel/src/filesystem/fuse/fs.rs b/kernel/src/filesystem/fuse/fs.rs index 8e72960072..5d519c7e70 100644 --- a/kernel/src/filesystem/fuse/fs.rs +++ b/kernel/src/filesystem/fuse/fs.rs @@ -1,6 +1,7 @@ use alloc::{ collections::BTreeMap, sync::{Arc, Weak}, + vec::Vec, }; use system_error::SystemError; @@ -26,12 +27,10 @@ use super::{ #[derive(Debug)] pub struct FuseMountData { - pub fd: i32, pub rootmode: u32, pub user_id: u32, pub group_id: u32, pub default_permissions: bool, - pub allow_other: bool, pub conn: Arc, } @@ -47,10 +46,7 @@ pub struct FuseFS { super_block: SuperBlock, conn: Arc, nodes: Mutex>>, - owner_uid: u32, - owner_gid: u32, default_permissions: bool, - allow_other: bool, } impl FuseFS { @@ -183,12 +179,10 @@ impl MountableFileSystem for FuseFS { conn.mark_mounted()?; Ok(Some(Arc::new(FuseMountData { - fd, rootmode, user_id, group_id, default_permissions, - allow_other, conn, }))) } @@ -234,10 +228,7 @@ impl MountableFileSystem for FuseFS { super_block, conn: conn.clone(), nodes: Mutex::new(BTreeMap::new()), - owner_uid: mount_data.user_id, - owner_gid: mount_data.group_id, default_permissions: mount_data.default_permissions, - allow_other: mount_data.allow_other, }); conn.enqueue_init()?; @@ -313,7 +304,13 @@ impl FileSystem for FuseFS { } fn on_umount(&self) { - // Abort pending/blocked requests to wake daemon thread on unmount. - self.conn.abort(); + let live_nodes: Vec> = { + let nodes = self.nodes.lock(); + nodes.values().filter_map(|w| w.upgrade()).collect() + }; + for node in live_nodes { + node.flush_forget(); + } + self.conn.on_umount(); } } diff --git a/kernel/src/filesystem/fuse/inode.rs b/kernel/src/filesystem/fuse/inode.rs index 3217693f27..827c4ef372 100644 --- a/kernel/src/filesystem/fuse/inode.rs +++ b/kernel/src/filesystem/fuse/inode.rs @@ -4,9 +4,11 @@ use alloc::{ vec::Vec, }; use core::mem::size_of; +use core::sync::atomic::{AtomicU64, Ordering}; use system_error::SystemError; +use crate::time::timekeep::ktime_get_real_ns; use crate::{ driver::base::device::device_number::DeviceNumber, filesystem::vfs::{ @@ -24,10 +26,11 @@ use super::{ protocol::{ fuse_pack_struct, fuse_read_struct, FuseAttr, FuseAttrOut, FuseDirent, FuseEntryOut, FuseGetattrIn, FuseMkdirIn, FuseMknodIn, FuseOpenIn, FuseOpenOut, FuseReadIn, - FuseReleaseIn, FuseRenameIn, FuseSetattrIn, FuseWriteIn, FuseWriteOut, FATTR_GID, - FATTR_MODE, FATTR_SIZE, FATTR_UID, FUSE_GETATTR, FUSE_LOOKUP, FUSE_MKDIR, FUSE_MKNOD, - FUSE_OPEN, FUSE_OPENDIR, FUSE_READ, FUSE_READDIR, FUSE_RELEASE, FUSE_RELEASEDIR, - FUSE_RENAME, FUSE_RMDIR, FUSE_SETATTR, FUSE_UNLINK, FUSE_WRITE, + FuseReleaseIn, FuseRenameIn, FuseSetattrIn, FuseWriteIn, FuseWriteOut, FATTR_ATIME, + FATTR_CTIME, FATTR_GID, FATTR_MODE, FATTR_MTIME, FATTR_SIZE, FATTR_UID, FUSE_GETATTR, + FUSE_LOOKUP, FUSE_MKDIR, FUSE_MKNOD, FUSE_OPEN, FUSE_OPENDIR, FUSE_READ, FUSE_READDIR, + FUSE_RELEASE, FUSE_RELEASEDIR, FUSE_RENAME, FUSE_RMDIR, FUSE_ROOT_ID, FUSE_SETATTR, + FUSE_UNLINK, FUSE_WRITE, }, }; @@ -38,6 +41,8 @@ pub struct FuseNode { nodeid: u64, parent_nodeid: Mutex, cached_metadata: Mutex>, + cached_metadata_deadline_ns: AtomicU64, + lookup_count: AtomicU64, } impl FuseNode { @@ -48,12 +53,15 @@ impl FuseNode { parent_nodeid: u64, cached: Option, ) -> Arc { + let has_cached = cached.is_some(); Arc::new(Self { fs, conn, nodeid, parent_nodeid: Mutex::new(parent_nodeid), cached_metadata: Mutex::new(cached), + cached_metadata_deadline_ns: AtomicU64::new(if has_cached { u64::MAX } else { 0 }), + lookup_count: AtomicU64::new(0), }) } @@ -67,6 +75,46 @@ impl FuseNode { pub fn set_cached_metadata(&self, md: Metadata) { *self.cached_metadata.lock() = Some(md); + self.cached_metadata_deadline_ns + .store(u64::MAX, Ordering::Relaxed); + } + + pub fn set_cached_metadata_with_valid(&self, md: Metadata, valid: u64, valid_nsec: u32) { + *self.cached_metadata.lock() = Some(md); + self.cached_metadata_deadline_ns + .store(Self::cache_deadline(valid, valid_nsec), Ordering::Relaxed); + } + + pub fn inc_lookup(&self, count: u64) { + if self.nodeid == FUSE_ROOT_ID || count == 0 { + return; + } + self.lookup_count.fetch_add(count, Ordering::Relaxed); + } + + pub fn flush_forget(&self) { + if self.nodeid == FUSE_ROOT_ID { + return; + } + let nlookup = self.lookup_count.swap(0, Ordering::Relaxed); + if nlookup == 0 { + return; + } + let _ = self.conn.queue_forget(self.nodeid, nlookup); + } + + fn now_ns() -> u64 { + ktime_get_real_ns().max(0) as u64 + } + + fn cache_deadline(valid: u64, valid_nsec: u32) -> u64 { + if valid == 0 && valid_nsec == 0 { + return 0; + } + let delta_ns = valid + .saturating_mul(1_000_000_000) + .saturating_add(valid_nsec as u64); + Self::now_ns().saturating_add(delta_ns) } fn conn(&self) -> &Arc { @@ -133,14 +181,17 @@ impl FuseNode { .request(FUSE_GETATTR, self.nodeid, fuse_pack_struct(&getattr_in))?; let out: FuseAttrOut = fuse_read_struct(&payload)?; let md = Self::attr_to_metadata(&out.attr); - *self.cached_metadata.lock() = Some(md.clone()); + self.set_cached_metadata_with_valid(md.clone(), out.attr_valid, out.attr_valid_nsec); Ok(md) } fn cached_or_fetch_metadata(&self) -> Result { self.conn.check_allow_current_process()?; if let Some(m) = self.cached_metadata.lock().clone() { - return Ok(m); + let deadline = self.cached_metadata_deadline_ns.load(Ordering::Relaxed); + if deadline == u64::MAX || (deadline != 0 && Self::now_ns() < deadline) { + return Ok(m); + } } self.fetch_attr() } @@ -304,12 +355,32 @@ impl IndexNode for FuseNode { } fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> { - // Minimal setattr: mode/uid/gid/size + let old = self.cached_or_fetch_metadata()?; let mut valid = 0u32; - valid |= FATTR_MODE; - valid |= FATTR_UID; - valid |= FATTR_GID; - valid |= FATTR_SIZE; + if metadata.mode != old.mode { + valid |= FATTR_MODE; + } + if metadata.uid != old.uid { + valid |= FATTR_UID; + } + if metadata.gid != old.gid { + valid |= FATTR_GID; + } + if metadata.size != old.size { + valid |= FATTR_SIZE; + } + if metadata.atime != old.atime { + valid |= FATTR_ATIME; + } + if metadata.mtime != old.mtime { + valid |= FATTR_MTIME; + } + if metadata.ctime != old.ctime { + valid |= FATTR_CTIME; + } + if valid == 0 { + return Ok(()); + } let inarg = FuseSetattrIn { valid, @@ -317,12 +388,12 @@ impl IndexNode for FuseNode { fh: 0, size: metadata.size as u64, lock_owner: 0, - atime: 0, - mtime: 0, - ctime: 0, - atimensec: 0, - mtimensec: 0, - ctimensec: 0, + atime: metadata.atime.tv_sec as u64, + mtime: metadata.mtime.tv_sec as u64, + ctime: metadata.ctime.tv_sec as u64, + atimensec: metadata.atime.tv_nsec as u32, + mtimensec: metadata.mtime.tv_nsec as u32, + ctimensec: metadata.ctime.tv_nsec as u32, mode: metadata.mode.bits(), unused4: 0, uid: metadata.uid as u32, @@ -334,7 +405,7 @@ impl IndexNode for FuseNode { .request(FUSE_SETATTR, self.nodeid, fuse_pack_struct(&inarg))?; let out: FuseAttrOut = fuse_read_struct(&payload)?; let md = Self::attr_to_metadata(&out.attr); - *self.cached_metadata.lock() = Some(md); + self.set_cached_metadata_with_valid(md, out.attr_valid, out.attr_valid_nsec); Ok(()) } @@ -362,7 +433,7 @@ impl IndexNode for FuseNode { .request(FUSE_SETATTR, self.nodeid, fuse_pack_struct(&inarg))?; let out: FuseAttrOut = fuse_read_struct(&payload)?; let md = Self::attr_to_metadata(&out.attr); - *self.cached_metadata.lock() = Some(md); + self.set_cached_metadata_with_valid(md, out.attr_valid, out.attr_valid_nsec); Ok(()) } @@ -456,6 +527,12 @@ impl IndexNode for FuseNode { let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; let child = fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md)); + child.inc_lookup(1); + child.set_cached_metadata_with_valid( + Self::attr_to_metadata(&entry.attr), + entry.attr_valid, + entry.attr_valid_nsec, + ); Ok(child) } @@ -491,7 +568,14 @@ impl IndexNode for FuseNode { let entry: FuseEntryOut = fuse_read_struct(&payload)?; let md = Self::attr_to_metadata(&entry.attr); let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; - Ok(fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md))) + let child = fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md)); + child.inc_lookup(1); + child.set_cached_metadata_with_valid( + Self::attr_to_metadata(&entry.attr), + entry.attr_valid, + entry.attr_valid_nsec, + ); + Ok(child) } FileType::File => { let inarg = FuseMknodIn { @@ -508,7 +592,14 @@ impl IndexNode for FuseNode { let entry: FuseEntryOut = fuse_read_struct(&payload)?; let md = Self::attr_to_metadata(&entry.attr); let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; - Ok(fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md))) + let child = fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md)); + child.inc_lookup(1); + child.set_cached_metadata_with_valid( + Self::attr_to_metadata(&entry.attr), + entry.attr_valid, + entry.attr_valid_nsec, + ); + Ok(child) } _ => Err(SystemError::ENOSYS), } @@ -556,3 +647,9 @@ impl IndexNode for FuseNode { Ok(format!("fuse:{}", self.nodeid)) } } + +impl Drop for FuseNode { + fn drop(&mut self) { + self.flush_forget(); + } +} diff --git a/kernel/src/filesystem/fuse/protocol.rs b/kernel/src/filesystem/fuse/protocol.rs index 318617c96a..7afeae77ad 100644 --- a/kernel/src/filesystem/fuse/protocol.rs +++ b/kernel/src/filesystem/fuse/protocol.rs @@ -33,6 +33,27 @@ pub const FUSE_INIT: u32 = 26; pub const FUSE_OPENDIR: u32 = 27; pub const FUSE_READDIR: u32 = 28; pub const FUSE_RELEASEDIR: u32 = 29; +pub const FUSE_DESTROY: u32 = 38; // no reply + +// INIT flags (subset) +pub const FUSE_ASYNC_READ: u64 = 1 << 0; +pub const FUSE_POSIX_LOCKS: u64 = 1 << 1; +pub const FUSE_ATOMIC_O_TRUNC: u64 = 1 << 3; +pub const FUSE_EXPORT_SUPPORT: u64 = 1 << 4; +pub const FUSE_BIG_WRITES: u64 = 1 << 5; +pub const FUSE_DONT_MASK: u64 = 1 << 6; +pub const FUSE_AUTO_INVAL_DATA: u64 = 1 << 12; +pub const FUSE_ASYNC_DIO: u64 = 1 << 15; +pub const FUSE_WRITEBACK_CACHE: u64 = 1 << 16; +pub const FUSE_NO_OPEN_SUPPORT: u64 = 1 << 17; +pub const FUSE_PARALLEL_DIROPS: u64 = 1 << 18; +pub const FUSE_HANDLE_KILLPRIV: u64 = 1 << 19; +pub const FUSE_POSIX_ACL: u64 = 1 << 20; +pub const FUSE_ABORT_ERROR: u64 = 1 << 21; +pub const FUSE_MAX_PAGES: u64 = 1 << 22; +pub const FUSE_NO_OPENDIR_SUPPORT: u64 = 1 << 24; +pub const FUSE_EXPLICIT_INVAL_DATA: u64 = 1 << 25; +pub const FUSE_INIT_EXT: u64 = 1 << 30; // getattr/setattr valid bits (subset) pub const FATTR_MODE: u32 = 1 << 0; @@ -41,8 +62,11 @@ pub const FATTR_GID: u32 = 1 << 2; pub const FATTR_SIZE: u32 = 1 << 3; pub const FATTR_ATIME: u32 = 1 << 4; pub const FATTR_MTIME: u32 = 1 << 5; +#[allow(dead_code)] pub const FATTR_FH: u32 = 1 << 6; +#[allow(dead_code)] pub const FATTR_ATIME_NOW: u32 = 1 << 7; +#[allow(dead_code)] pub const FATTR_MTIME_NOW: u32 = 1 << 8; pub const FATTR_CTIME: u32 = 1 << 10; @@ -129,6 +153,12 @@ pub struct FuseEntryOut { pub attr: FuseAttr, } +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseForgetIn { + pub nlookup: u64, +} + #[repr(C)] #[derive(Debug, Clone, Copy)] pub struct FuseGetattrIn { diff --git a/user/apps/c_unitest/fuse_test_simplefs.h b/user/apps/c_unitest/fuse_test_simplefs.h deleted file mode 100644 index 89d88c1b5d..0000000000 --- a/user/apps/c_unitest/fuse_test_simplefs.h +++ /dev/null @@ -1,891 +0,0 @@ -/* - * Minimal FUSE userspace daemon for DragonOS kernel tests (no libfuse). - * - * This header provides a tiny in-memory filesystem and request handlers for - * a subset of FUSE opcodes used by Phase C/D tests. - */ - -#pragma once - -#define _GNU_SOURCE - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define FUSE_TEST_LOG_PREFIX "[fuse-test] " -#define FUSE_SIMPLEFS_REV "statfs-v1" - -static inline int fuse_test_log_enabled(void) { - static int inited = 0; - static int enabled = 0; - if (!inited) { - const char *v = getenv("FUSE_TEST_LOG"); - enabled = (v && v[0] && strcmp(v, "0") != 0); - inited = 1; - } - return enabled; -} - -#define FUSE_TEST_LOG(fmt, ...) \ - do { \ - if (fuse_test_log_enabled()) { \ - fprintf(stderr, FUSE_TEST_LOG_PREFIX fmt "\n", ##__VA_ARGS__); \ - } \ - } while (0) - -#ifndef DT_DIR -#define DT_DIR 4 -#endif -#ifndef DT_REG -#define DT_REG 8 -#endif - -/* Keep test buffers off small thread stacks. */ -#define FUSE_TEST_BUF_SIZE (64 * 1024) - -/* Opcodes (subset) */ -#ifndef FUSE_LOOKUP -#define FUSE_LOOKUP 1 -#endif -#ifndef FUSE_GETATTR -#define FUSE_GETATTR 3 -#endif -#ifndef FUSE_SETATTR -#define FUSE_SETATTR 4 -#endif -#ifndef FUSE_MKNOD -#define FUSE_MKNOD 8 -#endif -#ifndef FUSE_MKDIR -#define FUSE_MKDIR 9 -#endif -#ifndef FUSE_UNLINK -#define FUSE_UNLINK 10 -#endif -#ifndef FUSE_RMDIR -#define FUSE_RMDIR 11 -#endif -#ifndef FUSE_RENAME -#define FUSE_RENAME 12 -#endif -#ifndef FUSE_OPEN -#define FUSE_OPEN 14 -#endif -#ifndef FUSE_READ -#define FUSE_READ 15 -#endif -#ifndef FUSE_WRITE -#define FUSE_WRITE 16 -#endif -#ifndef FUSE_STATFS -#define FUSE_STATFS 17 -#endif -#ifndef FUSE_RELEASE -#define FUSE_RELEASE 18 -#endif -#ifndef FUSE_INIT -#define FUSE_INIT 26 -#endif -#ifndef FUSE_OPENDIR -#define FUSE_OPENDIR 27 -#endif -#ifndef FUSE_READDIR -#define FUSE_READDIR 28 -#endif -#ifndef FUSE_RELEASEDIR -#define FUSE_RELEASEDIR 29 -#endif - -/* setattr valid bits (subset) */ -#ifndef FATTR_MODE -#define FATTR_MODE (1u << 0) -#endif -#ifndef FATTR_UID -#define FATTR_UID (1u << 1) -#endif -#ifndef FATTR_GID -#define FATTR_GID (1u << 2) -#endif -#ifndef FATTR_SIZE -#define FATTR_SIZE (1u << 3) -#endif - -struct fuse_in_header { - uint32_t len; - uint32_t opcode; - uint64_t unique; - uint64_t nodeid; - uint32_t uid; - uint32_t gid; - uint32_t pid; - uint16_t total_extlen; - uint16_t padding; -}; - -struct fuse_out_header { - uint32_t len; - int32_t error; /* -errno */ - uint64_t unique; -}; - -struct fuse_init_in { - uint32_t major; - uint32_t minor; - uint32_t max_readahead; - uint32_t flags; - uint32_t flags2; - uint32_t unused[11]; -}; - -struct fuse_init_out { - uint32_t major; - uint32_t minor; - uint32_t max_readahead; - uint32_t flags; - uint16_t max_background; - uint16_t congestion_threshold; - uint32_t max_write; - uint32_t time_gran; - uint16_t max_pages; - uint16_t map_alignment; - uint32_t flags2; - uint32_t unused[7]; -}; - -struct fuse_attr { - uint64_t ino; - uint64_t size; - uint64_t blocks; - uint64_t atime; - uint64_t mtime; - uint64_t ctime; - uint32_t atimensec; - uint32_t mtimensec; - uint32_t ctimensec; - uint32_t mode; - uint32_t nlink; - uint32_t uid; - uint32_t gid; - uint32_t rdev; - uint32_t blksize; - uint32_t flags; -}; - -struct fuse_entry_out { - uint64_t nodeid; - uint64_t generation; - uint64_t entry_valid; - uint64_t attr_valid; - uint32_t entry_valid_nsec; - uint32_t attr_valid_nsec; - struct fuse_attr attr; -}; - -struct fuse_getattr_in { - uint32_t getattr_flags; - uint32_t dummy; - uint64_t fh; -}; - -struct fuse_attr_out { - uint64_t attr_valid; - uint32_t attr_valid_nsec; - uint32_t dummy; - struct fuse_attr attr; -}; - -struct fuse_open_in { - uint32_t flags; - uint32_t open_flags; -}; - -struct fuse_open_out { - uint64_t fh; - uint32_t open_flags; - uint32_t padding; -}; - -struct fuse_read_in { - uint64_t fh; - uint64_t offset; - uint32_t size; - uint32_t read_flags; - uint64_t lock_owner; - uint32_t flags; - uint32_t padding; -}; - -struct fuse_write_in { - uint64_t fh; - uint64_t offset; - uint32_t size; - uint32_t write_flags; - uint64_t lock_owner; - uint32_t flags; - uint32_t padding; -}; - -struct fuse_write_out { - uint32_t size; - uint32_t padding; -}; - -struct fuse_kstatfs { - uint64_t blocks; - uint64_t bfree; - uint64_t bavail; - uint64_t files; - uint64_t ffree; - uint32_t bsize; - uint32_t namelen; - uint32_t frsize; - uint32_t padding; - uint32_t spare[6]; -}; - -struct fuse_statfs_out { - struct fuse_kstatfs st; -}; - -struct fuse_release_in { - uint64_t fh; - uint32_t flags; - uint32_t release_flags; - uint64_t lock_owner; -}; - -struct fuse_mknod_in { - uint32_t mode; - uint32_t rdev; - uint32_t umask; - uint32_t padding; -}; - -struct fuse_mkdir_in { - uint32_t mode; - uint32_t umask; -}; - -struct fuse_rename_in { - uint64_t newdir; -}; - -struct fuse_setattr_in { - uint32_t valid; - uint32_t padding; - uint64_t fh; - uint64_t size; - uint64_t lock_owner; - uint64_t atime; - uint64_t mtime; - uint64_t ctime; - uint32_t atimensec; - uint32_t mtimensec; - uint32_t ctimensec; - uint32_t mode; - uint32_t unused4; - uint32_t uid; - uint32_t gid; - uint32_t unused5; -}; - -struct fuse_dirent { - uint64_t ino; - uint64_t off; - uint32_t namelen; - uint32_t type; - /* char name[]; */ -}; - -static inline size_t fuse_dirent_rec_len(size_t namelen) { - size_t unaligned = sizeof(struct fuse_dirent) + namelen; - return (unaligned + 8 - 1) & ~(size_t)(8 - 1); -} - -/* ===== in-memory FS ===== */ - -#define SIMPLEFS_MAX_NODES 64 -#define SIMPLEFS_NAME_MAX 64 -#define SIMPLEFS_DATA_MAX 8192 - -struct simplefs_node { - int used; - uint64_t nodeid; - uint64_t ino; - uint64_t parent; - int is_dir; - uint32_t mode; /* includes type bits */ - char name[SIMPLEFS_NAME_MAX]; - unsigned char data[SIMPLEFS_DATA_MAX]; - size_t size; -}; - -struct simplefs { - struct simplefs_node nodes[SIMPLEFS_MAX_NODES]; - uint64_t next_nodeid; - uint64_t next_ino; -}; - -static inline void simplefs_init(struct simplefs *fs) { - memset(fs, 0, sizeof(*fs)); - fs->next_nodeid = 2; - fs->next_ino = 2; - - /* root nodeid=1 */ - fs->nodes[0].used = 1; - fs->nodes[0].nodeid = 1; - fs->nodes[0].ino = 1; - fs->nodes[0].parent = 1; - fs->nodes[0].is_dir = 1; - fs->nodes[0].mode = 0040755; - strcpy(fs->nodes[0].name, ""); - fs->nodes[0].size = 0; - - /* hello.txt under root */ - fs->nodes[1].used = 1; - fs->nodes[1].nodeid = 2; - fs->nodes[1].ino = 2; - fs->nodes[1].parent = 1; - fs->nodes[1].is_dir = 0; - fs->nodes[1].mode = 0100644; - strcpy(fs->nodes[1].name, "hello.txt"); - const char *msg = "hello from fuse\n"; - fs->nodes[1].size = strlen(msg); - memcpy(fs->nodes[1].data, msg, fs->nodes[1].size); - - fs->next_nodeid = 3; - fs->next_ino = 3; -} - -static inline struct simplefs_node *simplefs_find_node(struct simplefs *fs, uint64_t nodeid) { - for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { - if (fs->nodes[i].used && fs->nodes[i].nodeid == nodeid) { - return &fs->nodes[i]; - } - } - return NULL; -} - -static inline struct simplefs_node *simplefs_find_child(struct simplefs *fs, uint64_t parent, - const char *name) { - for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { - if (!fs->nodes[i].used) - continue; - if (fs->nodes[i].parent != parent) - continue; - if (strcmp(fs->nodes[i].name, name) == 0) { - return &fs->nodes[i]; - } - } - return NULL; -} - -static inline int simplefs_has_children(struct simplefs *fs, uint64_t parent) { - for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { - if (fs->nodes[i].used && fs->nodes[i].parent == parent) { - return 1; - } - } - return 0; -} - -static inline struct simplefs_node *simplefs_alloc(struct simplefs *fs) { - for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { - if (!fs->nodes[i].used) { - memset(&fs->nodes[i], 0, sizeof(fs->nodes[i])); - fs->nodes[i].used = 1; - fs->nodes[i].nodeid = fs->next_nodeid++; - fs->nodes[i].ino = fs->next_ino++; - return &fs->nodes[i]; - } - } - return NULL; -} - -static inline void simplefs_fill_attr(const struct simplefs_node *n, struct fuse_attr *a) { - memset(a, 0, sizeof(*a)); - a->ino = n->ino; - a->size = n->size; - a->blocks = 0; - a->mode = n->mode; - a->nlink = n->is_dir ? 2 : 1; - a->uid = 0; - a->gid = 0; - a->blksize = 4096; -} - -static inline int fuse_write_reply(int fd, uint64_t unique, int32_t err_neg, - const void *payload, size_t payload_len) { - struct fuse_out_header out; - out.len = sizeof(out) + payload_len; - out.error = err_neg; - out.unique = unique; - - size_t total = sizeof(out) + payload_len; - if (total > FUSE_TEST_BUF_SIZE) { - errno = E2BIG; - return -1; - } - unsigned char *buf = malloc(total); - if (!buf) { - errno = ENOMEM; - return -1; - } - memcpy(buf, &out, sizeof(out)); - if (payload_len) { - memcpy(buf + sizeof(out), payload, payload_len); - } - ssize_t wn = write(fd, buf, total); - free(buf); - if (wn == (ssize_t)total) { - FUSE_TEST_LOG("reply unique=%llu err=%d len=%zu", - (unsigned long long)unique, (int)err_neg, total); - } - if (wn != (ssize_t)total) { - return -1; - } - return 0; -} - -struct fuse_daemon_args { - int fd; - volatile int *stop; - volatile int *init_done; - int enable_write_ops; - int exit_after_init; - uint32_t root_mode_override; - uint32_t hello_mode_override; - struct simplefs fs; -}; - -static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned char *req, size_t n) { - if (n < sizeof(struct fuse_in_header)) { - return -1; - } - const struct fuse_in_header *h = (const struct fuse_in_header *)req; - const unsigned char *payload = req + sizeof(*h); - size_t payload_len = n - sizeof(*h); - FUSE_TEST_LOG("handle opcode=%u unique=%llu nodeid=%llu len=%u payload=%zu", - h->opcode, (unsigned long long)h->unique, (unsigned long long)h->nodeid, - h->len, payload_len); - - switch (h->opcode) { - case FUSE_INIT: { - if (payload_len < sizeof(struct fuse_init_in)) { - return -1; - } - struct fuse_init_out out; - memset(&out, 0, sizeof(out)); - out.major = 7; - out.minor = 39; - out.max_write = 4096; - if (fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)) != 0) { - return -1; - } - *a->init_done = 1; - return 0; - } - case FUSE_LOOKUP: { - const char *name = (const char *)payload; - if (payload_len == 0 || name[payload_len - 1] != '\0') { - return -1; - } - struct simplefs_node *parent = simplefs_find_node(&a->fs, h->nodeid); - if (!parent || !parent->is_dir) { - return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); - } - struct simplefs_node *child = simplefs_find_child(&a->fs, h->nodeid, name); - if (!child) { - return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); - } - struct fuse_entry_out out; - memset(&out, 0, sizeof(out)); - out.nodeid = child->nodeid; - simplefs_fill_attr(child, &out.attr); - return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); - } - case FUSE_GETATTR: { - (void)payload; - struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); - if (!node) { - return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); - } - struct fuse_attr_out out; - memset(&out, 0, sizeof(out)); - simplefs_fill_attr(node, &out.attr); - return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); - } - case FUSE_OPENDIR: - case FUSE_OPEN: { - struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); - if (!node) { - return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); - } - if (h->opcode == FUSE_OPENDIR && !node->is_dir) { - return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); - } - if (h->opcode == FUSE_OPEN && node->is_dir) { - return fuse_write_reply(a->fd, h->unique, -EISDIR, NULL, 0); - } - struct fuse_open_out out; - memset(&out, 0, sizeof(out)); - out.fh = node->nodeid; - return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); - } - case FUSE_READ: { - if (payload_len < sizeof(struct fuse_read_in)) { - return -1; - } - const struct fuse_read_in *in = (const struct fuse_read_in *)payload; - struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); - if (!node || node->is_dir) { - return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); - } - if (in->offset >= node->size) { - return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); - } - size_t remain = node->size - (size_t)in->offset; - size_t to_copy = in->size; - if (to_copy > remain) { - to_copy = remain; - } - return fuse_write_reply(a->fd, h->unique, 0, node->data + in->offset, to_copy); - } - case FUSE_READDIR: { - if (payload_len < sizeof(struct fuse_read_in)) { - return -1; - } - const struct fuse_read_in *in = (const struct fuse_read_in *)payload; - (void)in; - struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); - if (!node || !node->is_dir) { - return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); - } - - /* offset is an entry index: 0=".", 1="..", then children */ - uint64_t idx = in->offset; - unsigned char *outbuf = malloc(FUSE_TEST_BUF_SIZE); - if (!outbuf) { - return fuse_write_reply(a->fd, h->unique, -ENOMEM, NULL, 0); - } - size_t outlen = 0; - - const char *fixed_names[2] = {".", ".."}; - for (; idx < 2; idx++) { - const char *nm = fixed_names[idx]; - size_t nmlen = strlen(nm); - size_t reclen = fuse_dirent_rec_len(nmlen); - if (outlen + reclen > FUSE_TEST_BUF_SIZE) - break; - struct fuse_dirent de; - memset(&de, 0, sizeof(de)); - de.ino = 1; - de.off = idx + 1; - de.namelen = (uint32_t)nmlen; - de.type = DT_DIR; - memcpy(outbuf + outlen, &de, sizeof(de)); - memcpy(outbuf + outlen + sizeof(de), nm, nmlen); - outlen += reclen; - } - - /* children in insertion order */ - uint64_t child_base = 2; - uint64_t cur = idx; - for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { - struct simplefs_node *c = &a->fs.nodes[i]; - if (!c->used || c->parent != h->nodeid) - continue; - if (cur < child_base) { - cur = child_base; - } - if (cur > child_base) { - /* skip until we reach this entry index */ - child_base++; - continue; - } - - size_t nmlen = strlen(c->name); - size_t reclen = fuse_dirent_rec_len(nmlen); - if (outlen + reclen > FUSE_TEST_BUF_SIZE) - break; - struct fuse_dirent de; - memset(&de, 0, sizeof(de)); - de.ino = c->ino; - de.off = child_base + 1; - de.namelen = (uint32_t)nmlen; - de.type = c->is_dir ? DT_DIR : DT_REG; - memcpy(outbuf + outlen, &de, sizeof(de)); - memcpy(outbuf + outlen + sizeof(de), c->name, nmlen); - outlen += reclen; - - child_base++; - cur++; - } - - int ret = fuse_write_reply(a->fd, h->unique, 0, outbuf, outlen); - free(outbuf); - return ret; - } - case FUSE_STATFS: { - struct fuse_statfs_out out; - memset(&out, 0, sizeof(out)); - - unsigned used = 0; - for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { - if (a->fs.nodes[i].used) { - used++; - } - } - - out.st.blocks = 1024; - out.st.bfree = 512; - out.st.bavail = 512; - out.st.files = SIMPLEFS_MAX_NODES; - out.st.ffree = (used > SIMPLEFS_MAX_NODES) ? 0 : (SIMPLEFS_MAX_NODES - used); - out.st.bsize = 4096; - out.st.frsize = 4096; - out.st.namelen = SIMPLEFS_NAME_MAX - 1; - FUSE_TEST_LOG("statfs reply ok blocks=%llu bfree=%llu bavail=%llu", - (unsigned long long)out.st.blocks, - (unsigned long long)out.st.bfree, - (unsigned long long)out.st.bavail); - return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); - } - case FUSE_RELEASE: - case FUSE_RELEASEDIR: - return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); - case FUSE_WRITE: { - if (!a->enable_write_ops) { - return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); - } - if (payload_len < sizeof(struct fuse_write_in)) { - return -1; - } - const struct fuse_write_in *in = (const struct fuse_write_in *)payload; - const unsigned char *data = payload + sizeof(*in); - size_t data_len = payload_len - sizeof(*in); - if (data_len < in->size) { - return -1; - } - struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); - if (!node || node->is_dir) { - return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); - } - if (in->offset >= SIMPLEFS_DATA_MAX) { - return fuse_write_reply(a->fd, h->unique, -EFBIG, NULL, 0); - } - size_t to_copy = in->size; - if (in->offset + to_copy > SIMPLEFS_DATA_MAX) { - to_copy = SIMPLEFS_DATA_MAX - (size_t)in->offset; - } - memcpy(node->data + in->offset, data, to_copy); - if (node->size < in->offset + to_copy) { - node->size = (size_t)in->offset + to_copy; - } - struct fuse_write_out out; - memset(&out, 0, sizeof(out)); - out.size = (uint32_t)to_copy; - return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); - } - case FUSE_MKDIR: - case FUSE_MKNOD: { - if (!a->enable_write_ops) { - return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); - } - const char *name = NULL; - size_t name_off = 0; - int is_dir = (h->opcode == FUSE_MKDIR); - uint32_t mode = 0; - if (is_dir) { - if (payload_len < sizeof(struct fuse_mkdir_in) + 1) - return -1; - const struct fuse_mkdir_in *in = (const struct fuse_mkdir_in *)payload; - mode = in->mode; - name_off = sizeof(*in); - } else { - if (payload_len < sizeof(struct fuse_mknod_in) + 1) - return -1; - const struct fuse_mknod_in *in = (const struct fuse_mknod_in *)payload; - mode = in->mode; - name_off = sizeof(*in); - } - name = (const char *)(payload + name_off); - if (name[payload_len - name_off - 1] != '\0') - return -1; - if (simplefs_find_child(&a->fs, h->nodeid, name)) { - return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); - } - struct simplefs_node *p = simplefs_find_node(&a->fs, h->nodeid); - if (!p || !p->is_dir) { - return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); - } - struct simplefs_node *nnode = simplefs_alloc(&a->fs); - if (!nnode) { - return fuse_write_reply(a->fd, h->unique, -ENOSPC, NULL, 0); - } - nnode->parent = h->nodeid; - nnode->is_dir = is_dir; - nnode->mode = mode; - strncpy(nnode->name, name, sizeof(nnode->name) - 1); - nnode->size = 0; - - struct fuse_entry_out out; - memset(&out, 0, sizeof(out)); - out.nodeid = nnode->nodeid; - simplefs_fill_attr(nnode, &out.attr); - return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); - } - case FUSE_UNLINK: - case FUSE_RMDIR: { - if (!a->enable_write_ops) { - return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); - } - const char *name = (const char *)payload; - if (payload_len == 0 || name[payload_len - 1] != '\0') { - return -1; - } - struct simplefs_node *child = simplefs_find_child(&a->fs, h->nodeid, name); - if (!child) { - return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); - } - if (h->opcode == FUSE_RMDIR) { - if (!child->is_dir) { - return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); - } - if (simplefs_has_children(&a->fs, child->nodeid)) { - return fuse_write_reply(a->fd, h->unique, -ENOTEMPTY, NULL, 0); - } - } else { - if (child->is_dir) { - return fuse_write_reply(a->fd, h->unique, -EISDIR, NULL, 0); - } - } - child->used = 0; - return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); - } - case FUSE_RENAME: { - if (!a->enable_write_ops) { - return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); - } - if (payload_len < sizeof(struct fuse_rename_in) + 3) { - return -1; - } - const struct fuse_rename_in *in = (const struct fuse_rename_in *)payload; - const char *names = (const char *)(payload + sizeof(*in)); - size_t names_len = payload_len - sizeof(*in); - if (names[names_len - 1] != '\0') { - return -1; - } - const char *oldname = names; - const char *newname = oldname + strlen(oldname) + 1; - if (newname >= names + names_len) { - return -1; - } - struct simplefs_node *src = simplefs_find_child(&a->fs, h->nodeid, oldname); - if (!src) { - return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); - } - if (simplefs_find_child(&a->fs, in->newdir, newname)) { - return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); - } - src->parent = in->newdir; - strncpy(src->name, newname, sizeof(src->name) - 1); - return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); - } - case FUSE_SETATTR: { - if (!a->enable_write_ops) { - return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); - } - if (payload_len < sizeof(struct fuse_setattr_in)) { - return -1; - } - const struct fuse_setattr_in *in = (const struct fuse_setattr_in *)payload; - struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); - if (!node) { - return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); - } - if (in->valid & FATTR_SIZE) { - if (in->size > SIMPLEFS_DATA_MAX) { - return fuse_write_reply(a->fd, h->unique, -EFBIG, NULL, 0); - } - node->size = (size_t)in->size; - } - if (in->valid & FATTR_MODE) { - node->mode = in->mode; - } - struct fuse_attr_out out; - memset(&out, 0, sizeof(out)); - simplefs_fill_attr(node, &out.attr); - return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); - } - default: - return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); - } -} - -static inline void *fuse_daemon_thread(void *arg) { - struct fuse_daemon_args *a = (struct fuse_daemon_args *)arg; - unsigned char *buf = malloc(FUSE_TEST_BUF_SIZE); - if (!buf) { - return NULL; - } - - simplefs_init(&a->fs); - if (a->root_mode_override) { - a->fs.nodes[0].mode = a->root_mode_override; - } - if (a->hello_mode_override) { - a->fs.nodes[1].mode = a->hello_mode_override; - } - - while (!*a->stop) { - FUSE_TEST_LOG("daemon read start"); - ssize_t n = read(a->fd, buf, FUSE_TEST_BUF_SIZE); - if (n < 0) { - FUSE_TEST_LOG("daemon read error n=%zd errno=%d", n, errno); - if (errno == EINTR) - continue; - if (errno == ENOTCONN) - break; - continue; - } - if (n == 0) { - FUSE_TEST_LOG("daemon read EOF"); - break; - } - FUSE_TEST_LOG("daemon read n=%zd", n); - struct fuse_in_header *h = (struct fuse_in_header *)buf; - if ((size_t)n != h->len) { - FUSE_TEST_LOG("daemon short read n=%zd hdr.len=%u", n, h->len); - continue; - } - (void)fuse_handle_one(a, buf, (size_t)n); - if (a->exit_after_init && a->init_done && *a->init_done) { - break; - } - } - free(buf); - return NULL; -} - -static inline int ensure_dir(const char *path) { - struct stat st; - if (stat(path, &st) == 0) { - if (S_ISDIR(st.st_mode)) - return 0; - errno = ENOTDIR; - return -1; - } - return mkdir(path, 0755); -} diff --git a/user/apps/fuse_demo/Makefile b/user/apps/fuse_demo/Makefile index 2d3db9878a..cef89a59af 100644 --- a/user/apps/fuse_demo/Makefile +++ b/user/apps/fuse_demo/Makefile @@ -8,13 +8,13 @@ endif CC=$(CROSS_COMPILE)gcc CFLAGS := -Wall -O2 -static -lpthread -SRCS := fuse_demo.c +SRCS := $(wildcard *.c) BINS := $(SRCS:.c=) all: $(BINS) @echo "bins: $(BINS)" -%: %.c fuse_test_simplefs.h +%: %.c $(wildcard *.h) $(CC) $(CFLAGS) $< -o $@ install: all diff --git a/user/apps/fuse_demo/README.md b/user/apps/fuse_demo/README.md index ea70817681..98d2303eaf 100644 --- a/user/apps/fuse_demo/README.md +++ b/user/apps/fuse_demo/README.md @@ -66,9 +66,20 @@ fuse_demo /mnt/fuse --threads 4 如果内核尚未支持 `FUSE_DEV_IOC_CLONE`，`--threads > 1` 会在 clone 阶段失败并提前退出（或只跑单线程，取决于当时实现）。 +## 内置测试程序 + +`user/apps/fuse_demo` 目录下同时提供了 FUSE 相关回归测试二进制： + +- `test_fuse_dev`：`/dev/fuse` 缓冲区与 nonblock 语义 +- `test_fuse_mount_init`：`mount + INIT` 协商与同 fd 重复挂载拒绝 +- `test_fuse_phase_c`：`ls/stat/cat` 读路径 +- `test_fuse_phase_d`：创建/写入/重命名/删除路径 +- `test_fuse_clone`：`FUSE_DEV_IOC_CLONE` 基础路径 +- `test_fuse_permissions`：`allow_other/default_permissions` 语义 +- `test_fuse_p1_lifecycle`：`FORGET/DESTROY` 生命周期语义 + ## 权限语义备注（对应 Phase E） - 未指定 `--allow-other`：内核会限制“非挂载者允许的进程”调用到该 FUSE 挂载（更安全，类似 Linux 默认行为）。 - 未指定 `--default-permissions`：内核会绕过大部分本地 DAC 权限检查（remote model），把权限决策交给用户态 daemon。 - 本 demo daemon **不做权限拒绝**，因此 remote model 下通常会更“宽松”。 - diff --git a/user/apps/fuse_demo/fuse_demo.c b/user/apps/fuse_demo/fuse_demo.c index 27ebed912e..3657f782b7 100644 --- a/user/apps/fuse_demo/fuse_demo.c +++ b/user/apps/fuse_demo/fuse_demo.c @@ -94,6 +94,7 @@ int main(int argc, char **argv) { master_args.stop = &stop; master_args.init_done = &init_done; master_args.enable_write_ops = enable_write_ops; + master_args.stop_on_destroy = 1; pthread_t *ths = calloc((size_t)threads, sizeof(pthread_t)); struct fuse_daemon_args *args = calloc((size_t)threads, sizeof(struct fuse_daemon_args)); @@ -158,6 +159,7 @@ int main(int argc, char **argv) { args[i].stop = &stop; args[i].init_done = &init_done; args[i].enable_write_ops = enable_write_ops; + args[i].stop_on_destroy = 1; if (pthread_create(&ths[i], NULL, fuse_daemon_thread, &args[i]) != 0) { perror("pthread_create(clone)"); close(fd); diff --git a/user/apps/fuse_demo/fuse_test_simplefs.h b/user/apps/fuse_demo/fuse_test_simplefs.h index 8be6f9a67c..4e55089ebf 100644 --- a/user/apps/fuse_demo/fuse_test_simplefs.h +++ b/user/apps/fuse_demo/fuse_test_simplefs.h @@ -58,6 +58,9 @@ static inline int fuse_test_log_enabled(void) { #ifndef FUSE_LOOKUP #define FUSE_LOOKUP 1 #endif +#ifndef FUSE_FORGET +#define FUSE_FORGET 2 +#endif #ifndef FUSE_GETATTR #define FUSE_GETATTR 3 #endif @@ -106,6 +109,21 @@ static inline int fuse_test_log_enabled(void) { #ifndef FUSE_RELEASEDIR #define FUSE_RELEASEDIR 29 #endif +#ifndef FUSE_DESTROY +#define FUSE_DESTROY 38 +#endif + +#ifndef FUSE_MIN_READ_BUFFER +#define FUSE_MIN_READ_BUFFER 8192 +#endif + +/* INIT flags (subset) */ +#ifndef FUSE_INIT_EXT +#define FUSE_INIT_EXT (1u << 30) +#endif +#ifndef FUSE_MAX_PAGES +#define FUSE_MAX_PAGES (1u << 22) +#endif /* setattr valid bits (subset) */ #ifndef FATTR_MODE @@ -192,6 +210,10 @@ struct fuse_entry_out { struct fuse_attr attr; }; +struct fuse_forget_in { + uint64_t nlookup; +}; + struct fuse_getattr_in { uint32_t getattr_flags; uint32_t dummy; @@ -462,8 +484,15 @@ struct fuse_daemon_args { volatile int *init_done; int enable_write_ops; int exit_after_init; + int stop_on_destroy; uint32_t root_mode_override; uint32_t hello_mode_override; + volatile uint32_t *forget_count; + volatile uint64_t *forget_nlookup_sum; + volatile uint32_t *destroy_count; + volatile uint32_t *init_in_flags; + volatile uint32_t *init_in_flags2; + volatile uint32_t *init_in_max_readahead; struct simplefs fs; }; @@ -483,17 +512,38 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha if (payload_len < sizeof(struct fuse_init_in)) { return -1; } + const struct fuse_init_in *in = (const struct fuse_init_in *)payload; + if (a->init_in_flags) + *a->init_in_flags = in->flags; + if (a->init_in_flags2) + *a->init_in_flags2 = in->flags2; + if (a->init_in_max_readahead) + *a->init_in_max_readahead = in->max_readahead; + struct fuse_init_out out; memset(&out, 0, sizeof(out)); out.major = 7; out.minor = 39; + out.flags = FUSE_INIT_EXT | FUSE_MAX_PAGES; + out.flags2 = 0; out.max_write = 4096; + out.max_pages = 32; if (fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)) != 0) { return -1; } *a->init_done = 1; return 0; } + case FUSE_FORGET: { + if (payload_len < sizeof(struct fuse_forget_in)) + return -1; + const struct fuse_forget_in *in = (const struct fuse_forget_in *)payload; + if (a->forget_count) + (*a->forget_count)++; + if (a->forget_nlookup_sum) + (*a->forget_nlookup_sum) += in->nlookup; + return 0; + } case FUSE_LOOKUP: { const char *name = (const char *)payload; if (payload_len == 0 || name[payload_len - 1] != '\0') { @@ -663,6 +713,12 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha case FUSE_RELEASE: case FUSE_RELEASEDIR: return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_DESTROY: + if (a->destroy_count) + (*a->destroy_count)++; + if (a->stop_on_destroy && a->stop) + *a->stop = 1; + return 0; case FUSE_WRITE: { if (!a->enable_write_ops) { return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); diff --git a/user/apps/c_unitest/test_fuse_clone.c b/user/apps/fuse_demo/test_fuse_clone.c similarity index 100% rename from user/apps/c_unitest/test_fuse_clone.c rename to user/apps/fuse_demo/test_fuse_clone.c diff --git a/user/apps/c_unitest/test_fuse_dev.c b/user/apps/fuse_demo/test_fuse_dev.c similarity index 57% rename from user/apps/c_unitest/test_fuse_dev.c rename to user/apps/fuse_demo/test_fuse_dev.c index 5d8229acef..43917e27a5 100644 --- a/user/apps/c_unitest/test_fuse_dev.c +++ b/user/apps/fuse_demo/test_fuse_dev.c @@ -1,16 +1,9 @@ /** * @file test_fuse_dev.c - * @brief Phase A unit test: /dev/fuse basic semantics (open/read nonblock) + * @brief Phase P0 unit test: /dev/fuse read buffer and nonblock semantics. */ -#define _GNU_SOURCE - -#include -#include -#include -#include -#include -#include +#include "fuse_test_simplefs.h" static int test_nonblock_read_empty(void) { int fd = open("/dev/fuse", O_RDWR | O_NONBLOCK); @@ -19,10 +12,27 @@ static int test_nonblock_read_empty(void) { return -1; } - unsigned char buf[256]; - ssize_t n = read(fd, buf, sizeof(buf)); + unsigned char small[FUSE_MIN_READ_BUFFER / 2]; + ssize_t n = read(fd, small, sizeof(small)); + if (n != -1 || errno != EINVAL) { + printf("[FAIL] nonblock read with small buffer: n=%zd errno=%d (%s)\n", n, errno, + strerror(errno)); + close(fd); + return -1; + } + + unsigned char *big = malloc(FUSE_TEST_BUF_SIZE); + if (!big) { + printf("[FAIL] malloc big buffer failed\n"); + close(fd); + return -1; + } + memset(big, 0, FUSE_TEST_BUF_SIZE); + + n = read(fd, big, FUSE_TEST_BUF_SIZE); if (n != -1 || (errno != EAGAIN && errno != EWOULDBLOCK)) { printf("[FAIL] nonblock read empty: n=%zd errno=%d (%s)\n", n, errno, strerror(errno)); + free(big); close(fd); return -1; } @@ -34,10 +44,12 @@ static int test_nonblock_read_empty(void) { if (pr != 0) { printf("[FAIL] poll empty expected timeout: pr=%d revents=%x errno=%d (%s)\n", pr, pfd.revents, errno, strerror(errno)); + free(big); close(fd); return -1; } + free(big); close(fd); printf("[PASS] nonblock_read_empty\n"); return 0; @@ -49,4 +61,3 @@ int main(void) { } return 0; } - diff --git a/user/apps/c_unitest/test_fuse_mount_init.c b/user/apps/fuse_demo/test_fuse_mount_init.c similarity index 67% rename from user/apps/c_unitest/test_fuse_mount_init.c rename to user/apps/fuse_demo/test_fuse_mount_init.c index 060422db58..a8d24648db 100644 --- a/user/apps/c_unitest/test_fuse_mount_init.c +++ b/user/apps/fuse_demo/test_fuse_mount_init.c @@ -1,79 +1,9 @@ /** * @file test_fuse_mount_init.c - * @brief Phase B integration test: mount -t fuse -o fd=... triggers INIT and accepts init reply. + * @brief Phase P0 integration test: mount/INIT handshake and single-use fd. */ -#define _GNU_SOURCE - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifndef FUSE_INIT -#define FUSE_INIT 26 -#endif - -struct fuse_in_header { - uint32_t len; - uint32_t opcode; - uint64_t unique; - uint64_t nodeid; - uint32_t uid; - uint32_t gid; - uint32_t pid; - uint16_t total_extlen; - uint16_t padding; -}; - -struct fuse_out_header { - uint32_t len; - int32_t error; - uint64_t unique; -}; - -struct fuse_init_in { - uint32_t major; - uint32_t minor; - uint32_t max_readahead; - uint32_t flags; - uint32_t flags2; - uint32_t unused[11]; -}; - -struct fuse_init_out { - uint32_t major; - uint32_t minor; - uint32_t max_readahead; - uint32_t flags; - uint16_t max_background; - uint16_t congestion_threshold; - uint32_t max_write; - uint32_t time_gran; - uint16_t max_pages; - uint16_t map_alignment; - uint32_t flags2; - uint32_t unused[7]; -}; - -static int ensure_dir(const char *path) { - struct stat st; - if (stat(path, &st) == 0) { - if (S_ISDIR(st.st_mode)) { - return 0; - } - errno = ENOTDIR; - return -1; - } - return mkdir(path, 0755); -} +#include "fuse_test_simplefs.h" static int wait_readable(int fd, int timeout_ms) { struct pollfd pfd; @@ -81,9 +11,8 @@ static int wait_readable(int fd, int timeout_ms) { pfd.fd = fd; pfd.events = POLLIN; int pr = poll(&pfd, 1, timeout_ms); - if (pr < 0) { + if (pr < 0) return -1; - } if (pr == 0) { errno = ETIMEDOUT; return -1; @@ -101,10 +30,18 @@ static int do_init_handshake(int fd) { return -1; } - unsigned char buf[4096]; - ssize_t n = read(fd, buf, sizeof(buf)); + unsigned char *buf = malloc(FUSE_TEST_BUF_SIZE); + if (!buf) { + errno = ENOMEM; + printf("[FAIL] malloc init buffer failed\n"); + return -1; + } + memset(buf, 0, FUSE_TEST_BUF_SIZE); + + ssize_t n = read(fd, buf, FUSE_TEST_BUF_SIZE); if (n < (ssize_t)(sizeof(struct fuse_in_header) + sizeof(struct fuse_init_in))) { printf("[FAIL] read INIT too short: n=%zd errno=%d (%s)\n", n, errno, strerror(errno)); + free(buf); return -1; } @@ -112,19 +49,28 @@ static int do_init_handshake(int fd) { memcpy(&in_hdr, buf, sizeof(in_hdr)); if (in_hdr.opcode != FUSE_INIT) { printf("[FAIL] expected FUSE_INIT opcode=%d got=%u\n", FUSE_INIT, in_hdr.opcode); + free(buf); return -1; } if (in_hdr.len != (uint32_t)n) { printf("[FAIL] header.len mismatch: hdr=%u read=%zd\n", in_hdr.len, n); + free(buf); return -1; } struct fuse_init_in init_in; memcpy(&init_in, buf + sizeof(struct fuse_in_header), sizeof(init_in)); - if (init_in.major != 7) { - printf("[FAIL] init_in.major expected 7 got %u\n", init_in.major); + if (init_in.major != 7 || init_in.minor == 0) { + printf("[FAIL] invalid init_in version major=%u minor=%u\n", init_in.major, init_in.minor); + free(buf); return -1; } + if (init_in.flags == 0 && init_in.flags2 == 0) { + printf("[FAIL] expected non-zero init flags\n"); + free(buf); + return -1; + } + free(buf); struct fuse_out_header out_hdr; memset(&out_hdr, 0, sizeof(out_hdr)); @@ -136,9 +82,10 @@ static int do_init_handshake(int fd) { memset(&init_out, 0, sizeof(init_out)); init_out.major = 7; init_out.minor = 39; - init_out.max_readahead = 0; - init_out.flags = 0; + init_out.flags = FUSE_INIT_EXT | FUSE_MAX_PAGES; + init_out.flags2 = 0; init_out.max_write = 4096; + init_out.max_pages = 32; unsigned char reply[sizeof(out_hdr) + sizeof(init_out)]; memcpy(reply, &out_hdr, sizeof(out_hdr)); @@ -187,20 +134,27 @@ int main(void) { return 1; } - /* After INIT reply, queue should be empty. Nonblock read should return EAGAIN. */ - unsigned char tmp[64]; - ssize_t rn = read(fd, tmp, sizeof(tmp)); + unsigned char *tmp = malloc(FUSE_TEST_BUF_SIZE); + if (!tmp) { + printf("[FAIL] malloc tmp buffer failed\n"); + umount(mp); + close(fd); + return 1; + } + memset(tmp, 0, FUSE_TEST_BUF_SIZE); + + ssize_t rn = read(fd, tmp, FUSE_TEST_BUF_SIZE); if (rn != -1 || (errno != EAGAIN && errno != EWOULDBLOCK)) { printf("[FAIL] expected EAGAIN after init: rn=%zd errno=%d (%s)\n", rn, errno, strerror(errno)); + free(tmp); umount(mp); close(fd); return 1; } + free(tmp); /* * Second mount with same fd should fail (connection already mounted). - * Use a different mountpoint to avoid any "mount-on-mountpoint-root" corner - * behavior from interfering with the check. */ if (mount("none", mp2, "fuse", 0, opts) == 0) { printf("[FAIL] second mount with same fd unexpectedly succeeded\n"); diff --git a/user/apps/fuse_demo/test_fuse_p1_lifecycle.c b/user/apps/fuse_demo/test_fuse_p1_lifecycle.c new file mode 100644 index 0000000000..49b6944f4b --- /dev/null +++ b/user/apps/fuse_demo/test_fuse_p1_lifecycle.c @@ -0,0 +1,124 @@ +/** + * @file test_fuse_p1_lifecycle.c + * @brief Phase P1 test: FORGET request lifecycle + DESTROY on umount. + */ + +#include "fuse_test_simplefs.h" + +static int wait_init(volatile int *init_done) { + for (int i = 0; i < 200; i++) { + if (*init_done) + return 0; + usleep(10 * 1000); + } + errno = ETIMEDOUT; + return -1; +} + +int main(void) { + const char *mp = "/tmp/test_fuse_p1_lifecycle"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return 1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + return 1; + } + + volatile int stop = 0; + volatile int init_done = 0; + volatile uint32_t forget_count = 0; + volatile uint64_t forget_nlookup_sum = 0; + volatile uint32_t destroy_count = 0; + + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + args.stop_on_destroy = 1; + args.forget_count = &forget_count; + args.forget_nlookup_sum = &forget_nlookup_sum; + args.destroy_count = &destroy_count; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + return 1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + if (wait_init(&init_done) != 0) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + char p[256]; + snprintf(p, sizeof(p), "%s/hello.txt", mp); + for (int i = 0; i < 8; i++) { + struct stat st; + if (stat(p, &st) != 0) { + printf("[FAIL] stat(%s): %s (errno=%d)\n", p, strerror(errno), errno); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + } + + /* Give daemon time to consume queued FORGETs before unmount path. */ + usleep(100 * 1000); + + if (umount(mp) != 0) { + printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + for (int i = 0; i < 100; i++) { + if (destroy_count > 0) + break; + usleep(10 * 1000); + } + + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + + if (forget_count == 0 || forget_nlookup_sum == 0) { + printf("[FAIL] expected FORGET requests, got count=%u nlookup_sum=%llu\n", forget_count, + (unsigned long long)forget_nlookup_sum); + return 1; + } + + if (destroy_count == 0) { + printf("[FAIL] expected DESTROY request on umount\n"); + return 1; + } + + printf("[PASS] fuse_p1_lifecycle (forget_count=%u, forget_nlookup_sum=%llu, destroy_count=%u)\n", + forget_count, (unsigned long long)forget_nlookup_sum, destroy_count); + return 0; +} diff --git a/user/apps/c_unitest/test_fuse_permissions.c b/user/apps/fuse_demo/test_fuse_permissions.c similarity index 100% rename from user/apps/c_unitest/test_fuse_permissions.c rename to user/apps/fuse_demo/test_fuse_permissions.c diff --git a/user/apps/c_unitest/test_fuse_phase_c.c b/user/apps/fuse_demo/test_fuse_phase_c.c similarity index 100% rename from user/apps/c_unitest/test_fuse_phase_c.c rename to user/apps/fuse_demo/test_fuse_phase_c.c diff --git a/user/apps/c_unitest/test_fuse_phase_d.c b/user/apps/fuse_demo/test_fuse_phase_d.c similarity index 100% rename from user/apps/c_unitest/test_fuse_phase_d.c rename to user/apps/fuse_demo/test_fuse_phase_d.c From fc61e482026bb917cadab2ecc858c4c7fe73325d Mon Sep 17 00:00:00 2001 From: longjin Date: Mon, 9 Feb 2026 03:25:51 +0800 Subject: [PATCH 06/16] feat(fuse): implement comprehensive FUSE plan and demo application - Added a detailed phased implementation plan for DragonOS FUSE, outlining key objectives and milestones from protocol enhancements to ecosystem compatibility. - Introduced a demo application (`fuse3_demo`) based on `libfuse3`, including automatic library download and build processes. - Implemented a test application (`test_fuse3_demo`) for regression testing of the FUSE functionality. - Enhanced FUSE connection management with new opcodes and improved request handling. - Updated protocol definitions to support additional FUSE operations and flags. Signed-off-by: longjin --- TODO_FUSE_FULL_PLAN_CN.md | 118 ++++ kernel/src/filesystem/fuse/conn.rs | 189 +++++- kernel/src/filesystem/fuse/dev.rs | 10 +- kernel/src/filesystem/fuse/inode.rs | 498 +++++++++++--- kernel/src/filesystem/fuse/protocol.rs | 82 +++ kernel/src/filesystem/vfs/file.rs | 6 +- kernel/src/filesystem/vfs/mod.rs | 37 +- kernel/src/filesystem/vfs/mount.rs | 24 + kernel/src/filesystem/vfs/open.rs | 31 +- .../src/filesystem/vfs/syscall/readlink_at.rs | 14 +- .../filesystem/vfs/syscall/symlink_utils.rs | 12 +- .../src/filesystem/vfs/syscall/sys_fsync.rs | 3 +- user/apps/fuse3_demo/.gitignore | 3 + user/apps/fuse3_demo/Makefile | 104 +++ user/apps/fuse3_demo/README.md | 55 ++ user/apps/fuse3_demo/fuse3_demo.c | 613 ++++++++++++++++++ user/apps/fuse3_demo/test_fuse3_demo.c | 214 ++++++ user/apps/fuse_demo/README.md | 4 + user/apps/fuse_demo/fuse_test_simplefs.h | 586 +++++++++++++++-- user/apps/fuse_demo/test_fuse_mount_init.c | 4 +- user/apps/fuse_demo/test_fuse_p2_ops.c | 239 +++++++ user/apps/fuse_demo/test_fuse_p3_interrupt.c | 191 ++++++ .../test_fuse_p3_noopen_readdirplus_notify.c | 160 +++++ .../fuse_demo/test_fuse_p4_subtype_mount.c | 119 ++++ user/dadk/config/fuse3_demo.toml | 36 + 25 files changed, 3166 insertions(+), 186 deletions(-) create mode 100644 TODO_FUSE_FULL_PLAN_CN.md create mode 100644 user/apps/fuse3_demo/.gitignore create mode 100644 user/apps/fuse3_demo/Makefile create mode 100644 user/apps/fuse3_demo/README.md create mode 100644 user/apps/fuse3_demo/fuse3_demo.c create mode 100644 user/apps/fuse3_demo/test_fuse3_demo.c create mode 100644 user/apps/fuse_demo/test_fuse_p2_ops.c create mode 100644 user/apps/fuse_demo/test_fuse_p3_interrupt.c create mode 100644 user/apps/fuse_demo/test_fuse_p3_noopen_readdirplus_notify.c create mode 100644 user/apps/fuse_demo/test_fuse_p4_subtype_mount.c create mode 100644 user/dadk/config/fuse3_demo.toml diff --git a/TODO_FUSE_FULL_PLAN_CN.md b/TODO_FUSE_FULL_PLAN_CN.md new file mode 100644 index 0000000000..f500cad386 --- /dev/null +++ b/TODO_FUSE_FULL_PLAN_CN.md @@ -0,0 +1,118 @@ +# DragonOS FUSE 完整实现分阶段计划（中文） + +> 目标：在现有 Phase A~D 基础上，补齐 Linux 6.6 关键语义与生态兼容能力，最终达到可用、可维护、可回归测试的完整 FUSE 实现。 + +## 1. 现状与核心缺口 + +- 当前已具备 `/dev/fuse`、`mount(fd=...)`、`INIT`、基础读写与目录操作闭环。 +- 主要缺口集中在：协议协商完整性、请求生命周期（尤其 FORGET）、权限语义细节、卸载销毁语义、以及 libfuse/fusermount 兼容路径。 +- 当前 dead code（如 `FUSE_MIN_READ_BUFFER`、`FUSE_FORGET`、`FATTR_ATIME/MTIME/...`）对应的是“功能未落地”，不建议简单删除。 + +## 2. dead code 与缺失功能映射 + +- `FUSE_MIN_READ_BUFFER`：应接入 `/dev/fuse` 读缓冲校验逻辑。 +- `FUSE_FORGET`：应接入 inode nlookup 生命周期与 forget 队列。 +- `FATTR_ATIME/MTIME/FH/ATIME_NOW/MTIME_NOW/CTIME`：应接入 `SETATTR(valid)` 精确编码与 `utimens/futimens` 语义。 +- `FuseFS` 中未消费字段（如 `owner_uid/owner_gid/allow_other/fd`）：要么用于语义与导出路径，要么移除避免误导。 + +## 3. 分阶段实现计划 + +### P0：协议与初始化补强（先把基础打牢） + +**目标**：修正 INIT 协商和设备层基础语义，清零当前 warning 的“伪完成”状态。 +**范围**： + +- 完整实现 `FUSE_INIT` 协商状态：记录并使用 negotiated `minor/flags/max_write/max_readahead/time_gran/max_pages`。 +- 在 `/dev/fuse` 读取路径加入 Linux 语义的最小缓冲校验（使用 `FUSE_MIN_READ_BUFFER`）。 +- 清理或落地当前未使用字段与常量，确保 dead code 反映真实功能状态。 + +**验收**： + +- `mount + INIT` 协商字段在连接对象中可观测。 +- `/dev/fuse` 小缓冲读取返回符合预期错误。 +- FUSE 相关 dead code warning 显著下降且不靠“静默忽略”。 + +--- + +### P1：请求生命周期与缓存一致性 + +**目标**：补齐 inode 生命周期核心语义，避免长期运行下的资源与一致性问题。 +**范围**： + +- 实现 `FUSE_FORGET`（可扩展到 `FUSE_BATCH_FORGET`）。 +- 建立 `lookup -> nlookup++ -> forget` 的闭环。 +- 接入 `entry_valid/attr_valid` 超时逻辑，完善 attr/dentry 缓存失效策略。 +- 卸载时在已初始化连接发送 `FUSE_DESTROY`（再进行 abort/清理）。 + +**验收**： + +- 压测反复 `lookup/readdir/umount` 不出现引用泄漏或僵死请求。 +- daemon 侧可观测到 forget/destroy 请求序列，且时序稳定。 + +--- + +### P2：Linux 关键语义 opcode 补齐 + +**目标**：补齐“常用但目前缺失”的协议能力，使通用用户态程序更易跑通。 +**范围**： + +- 权限相关：`FUSE_ACCESS`（尤其 Remote 权限模型下 `access/chdir` 语义）。 +- 同步相关：`FUSE_FLUSH`、`FUSE_FSYNC`、`FUSE_FSYNCDIR`。 +- 创建/链接族增强：`FUSE_CREATE`、`FUSE_LINK`、`FUSE_SYMLINK`、`FUSE_READLINK`、`FUSE_RENAME2`。 +- 属性扩展：`SETATTR` 完整 valid 位处理；接入 xattr 族（`GETXATTR/SETXATTR/LISTXATTR/REMOVEXATTR`）。 + +**验收**： + +- `chmod/chown/truncate/utimens`、`readlink/symlink/link/renameat2`、`fsync/fdatasync` 语义可回归。 +- xattr 相关 syscall 测例可跑通基本路径。 + +--- + +### P3：高级协议与并发/中断语义 + +**目标**：提升复杂场景可靠性，向 Linux 6.6 行为进一步收敛。 +**范围**： + +- `FUSE_INTERRUPT`：请求可中断、重入与竞态处理（含 `EAGAIN` 语义）。 +- 支持 notification（`unique=0`）基础框架与关键 notify 类型。 +- 目录增强：`READDIRPLUS`（可先按能力协商后开关）。 +- 协商优化：`FUSE_NO_OPEN_SUPPORT`、`FUSE_NO_OPENDIR_SUPPORT` 等能力位处理。 + +**验收**： + +- 信号打断下不死锁，错误码与请求完成路径可预测。 +- 大目录与并发 readdir/open 场景行为稳定。 + +--- + +### P4：生态兼容与工程化收口 + +**目标**：形成“可演示 + 可回归 + 可迁移”的完整交付。 +**范围**： + +- 跑通 `libfuse3 + fusermount3`（先单线程，再多线程 clone 路径）。 +- 完善 `FUSE_DEV_IOC_CLONE` 与多 daemon worker 协作语义。 +- 建立分层测试矩阵：`c_unitest`（设备/协议/VFS）+ gVisor syscall 回归 + demo 演示脚本。 +- 形成故障注入用例：daemon 崩溃、超时、中断、umount 竞争。 + +**验收**： + +- libfuse hello/passthrough 可稳定挂载与读写。 +- CI/回归中包含关键 FUSE 测试集并可长期运行。 + +## 4. 推荐 PR 拆分策略 + +- 每阶段拆 2~4 个小 PR，先“接口与状态机”，后“opcode 实现”，最后“测试补齐”。 +- 每个 PR 必须携带最小可复现实验（至少 1 个 c_unitest）。 +- 禁止以临时 workaround 通过测试，必须按 Linux 6.6 语义修根因。 + +## 5. 实施顺序建议 + +1. 先做 P0（基础正确性） +2. 再做 P1（生命周期） +3. 之后并行推进 P2（功能）与 P3（复杂语义） +4. 最后 P4（生态与工程化）收口 + +--- + +如需，我可以基于本计划继续输出：**第一批 P0 的具体代码任务清单（文件级别 + 函数级别 + 测试用例）**。 diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs index 7e7dcdf592..559f1ecc44 100644 --- a/kernel/src/filesystem/fuse/conn.rs +++ b/kernel/src/filesystem/fuse/conn.rs @@ -5,6 +5,7 @@ use num_traits::FromPrimitive; use system_error::SystemError; use crate::{ + arch::MMArch, filesystem::epoll::{ event_poll::EventPoll, event_poll::LockedEPItemLinkedList, EPollEventType, EPollItem, }, @@ -12,6 +13,7 @@ use crate::{ mutex::Mutex, wait_queue::{WaitQueue, Waiter}, }, + mm::MemoryManagementArch, process::ProcessManager, }; @@ -19,12 +21,14 @@ use crate::process::cred::CAPFlags; use super::protocol::{ fuse_pack_struct, fuse_read_struct, FuseForgetIn, FuseInHeader, FuseInitIn, FuseInitOut, - FuseOutHeader, FuseWriteIn, FUSE_ABORT_ERROR, FUSE_ASYNC_DIO, FUSE_ASYNC_READ, + FuseInterruptIn, FuseOutHeader, FuseWriteIn, FUSE_ABORT_ERROR, FUSE_ASYNC_DIO, FUSE_ASYNC_READ, FUSE_ATOMIC_O_TRUNC, FUSE_AUTO_INVAL_DATA, FUSE_BIG_WRITES, FUSE_DESTROY, FUSE_DONT_MASK, - FUSE_EXPLICIT_INVAL_DATA, FUSE_EXPORT_SUPPORT, FUSE_FORGET, FUSE_HANDLE_KILLPRIV, FUSE_INIT, - FUSE_INIT_EXT, FUSE_KERNEL_MINOR_VERSION, FUSE_KERNEL_VERSION, FUSE_MAX_PAGES, - FUSE_MIN_READ_BUFFER, FUSE_NO_OPENDIR_SUPPORT, FUSE_NO_OPEN_SUPPORT, FUSE_PARALLEL_DIROPS, - FUSE_POSIX_ACL, FUSE_POSIX_LOCKS, FUSE_WRITEBACK_CACHE, + FUSE_DO_READDIRPLUS, FUSE_EXPLICIT_INVAL_DATA, FUSE_EXPORT_SUPPORT, FUSE_FLUSH, FUSE_FORGET, + FUSE_HANDLE_KILLPRIV, FUSE_INIT, FUSE_INIT_EXT, FUSE_INTERRUPT, FUSE_KERNEL_MINOR_VERSION, + FUSE_KERNEL_VERSION, FUSE_LOOKUP, FUSE_MAX_PAGES, FUSE_MIN_READ_BUFFER, FUSE_NOTIFY_DELETE, + FUSE_NOTIFY_INVAL_ENTRY, FUSE_NOTIFY_INVAL_INODE, FUSE_NOTIFY_POLL, FUSE_NOTIFY_RETRIEVE, + FUSE_NOTIFY_STORE, FUSE_NO_OPENDIR_SUPPORT, FUSE_NO_OPEN_SUPPORT, FUSE_PARALLEL_DIROPS, + FUSE_POSIX_ACL, FUSE_POSIX_LOCKS, FUSE_READDIRPLUS_AUTO, FUSE_WRITEBACK_CACHE, }; #[derive(Debug)] @@ -34,20 +38,26 @@ pub struct FuseRequest { #[derive(Debug)] pub struct FusePendingState { + unique: u64, opcode: u32, response: Mutex, SystemError>>>, wait: WaitQueue, } impl FusePendingState { - pub fn new(opcode: u32) -> Self { + pub fn new(unique: u64, opcode: u32) -> Self { Self { + unique, opcode, response: Mutex::new(None), wait: WaitQueue::default(), } } + pub fn unique(&self) -> u64 { + self.unique + } + pub fn complete(&self, v: Result, SystemError>) { let mut guard = self.response.lock(); if guard.is_some() { @@ -121,6 +131,9 @@ struct FuseConnInner { owner_gid: u32, allow_other: bool, init: FuseInitNegotiated, + no_open: bool, + no_opendir: bool, + no_readdirplus: bool, pending: VecDeque>, processing: BTreeMap>, } @@ -137,6 +150,9 @@ pub struct FuseConn { } impl FuseConn { + // Keep this in sync with `sys_read.rs` userspace chunking size. + const USER_READ_CHUNK: usize = 64 * 1024; + pub fn new() -> Arc { Arc::new(Self { inner: Mutex::new(FuseConnInner { @@ -147,6 +163,9 @@ impl FuseConn { owner_gid: 0, allow_other: false, init: FuseInitNegotiated::default(), + no_open: false, + no_opendir: false, + no_readdirplus: false, pending: VecDeque::new(), processing: BTreeMap::new(), }), @@ -188,6 +207,47 @@ impl FuseConn { g.allow_other = allow_other; } + fn has_init_flag(&self, flag: u64) -> bool { + let g = self.inner.lock(); + (g.init.flags & flag) != 0 + } + + pub fn should_skip_open(&self, opcode: u32) -> bool { + let g = self.inner.lock(); + match opcode { + super::protocol::FUSE_OPEN => g.no_open, + super::protocol::FUSE_OPENDIR => g.no_opendir, + _ => false, + } + } + + pub fn open_enosys_is_supported(&self, opcode: u32) -> bool { + match opcode { + super::protocol::FUSE_OPEN => self.has_init_flag(FUSE_NO_OPEN_SUPPORT), + super::protocol::FUSE_OPENDIR => self.has_init_flag(FUSE_NO_OPENDIR_SUPPORT), + _ => false, + } + } + + pub fn mark_no_open(&self, opcode: u32) { + let mut g = self.inner.lock(); + match opcode { + super::protocol::FUSE_OPEN => g.no_open = true, + super::protocol::FUSE_OPENDIR => g.no_opendir = true, + _ => {} + } + } + + pub fn use_readdirplus(&self) -> bool { + let g = self.inner.lock(); + !g.no_readdirplus && (g.init.flags & FUSE_DO_READDIRPLUS) != 0 + } + + pub fn disable_readdirplus(&self) { + let mut g = self.inner.lock(); + g.no_readdirplus = true; + } + fn alloc_unique(&self) -> u64 { self.next_unique.fetch_add(2, Ordering::Relaxed) } @@ -329,6 +389,22 @@ impl FuseConn { self.enqueue_noreply(FUSE_FORGET, nodeid, fuse_pack_struct(&inarg)) } + fn queue_interrupt(&self, unique: u64) -> Result<(), SystemError> { + if unique == 0 { + return Ok(()); + } + let can_send = { + let g = self.inner.lock(); + g.connected && g.mounted && g.initialized + }; + if !can_send { + return Ok(()); + } + let inarg = FuseInterruptIn { unique }; + let _ = self.enqueue_request(FUSE_INTERRUPT, 0, fuse_pack_struct(&inarg))?; + Ok(()) + } + /// Acquire a new `/dev/fuse` file handle reference to this connection. pub fn dev_acquire(&self) { self.dev_count.fetch_add(1, Ordering::Relaxed); @@ -383,6 +459,15 @@ impl FuseConn { ) } + fn max_write_cap_for_user_read_chunk() -> usize { + let overhead = core::mem::size_of::() + core::mem::size_of::(); + if Self::USER_READ_CHUNK <= overhead { + 4096 + } else { + Self::USER_READ_CHUNK - overhead + } + } + fn min_read_buffer(&self) -> usize { let g = self.inner.lock(); Self::calc_min_read_buffer(g.init.max_write as usize) @@ -467,6 +552,8 @@ impl FuseConn { | FUSE_BIG_WRITES | FUSE_DONT_MASK | FUSE_AUTO_INVAL_DATA + | FUSE_DO_READDIRPLUS + | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO | FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT @@ -507,8 +594,16 @@ impl FuseConn { } self.wait_initialized()?; } - self.enqueue_request(opcode, nodeid, payload)? - .wait_complete() + let pending = self.enqueue_request(opcode, nodeid, payload)?; + match pending.wait_complete() { + Err(SystemError::EINTR) | Err(SystemError::ERESTARTSYS) => { + if opcode != FUSE_INTERRUPT { + let _ = self.queue_interrupt(pending.unique()); + } + Err(SystemError::EINTR) + } + x => x, + } } fn enqueue_noreply(&self, opcode: u32, nodeid: u64, payload: &[u8]) -> Result<(), SystemError> { @@ -578,7 +673,7 @@ impl FuseConn { bytes.extend_from_slice(payload); let req = Arc::new(FuseRequest { bytes }); - let pending_state = Arc::new(FusePendingState::new(opcode)); + let pending_state = Arc::new(FusePendingState::new(unique, opcode)); { let mut g = self.inner.lock(); @@ -607,14 +702,20 @@ impl FuseConn { return Err(SystemError::EINVAL); } + if out_hdr.unique == 0 { + let payload = &data[core::mem::size_of::()..]; + self.handle_notify(out_hdr.error, payload)?; + return Ok(data.len()); + } + let pending = { let mut g = self.inner.lock(); if !g.connected { - return Err(SystemError::ENOTCONN); + return Err(SystemError::ENOENT); } g.processing .remove(&out_hdr.unique) - .ok_or(SystemError::EINVAL)? + .ok_or(SystemError::ENOENT)? }; let payload = &data[core::mem::size_of::()..]; @@ -624,6 +725,21 @@ impl FuseConn { // Negative errno from userspace. let errno = -error; let e = SystemError::from_i32(errno).unwrap_or(SystemError::EIO); + if Self::is_expected_reply_error(pending.opcode, errno) { + log::trace!( + "fuse: reply error opcode={} unique={} errno={}", + pending.opcode, + out_hdr.unique, + errno + ); + } else { + log::warn!( + "fuse: reply error opcode={} unique={} errno={}", + pending.opcode, + out_hdr.unique, + errno + ); + } pending.complete(Err(e)); if pending.opcode == FUSE_INIT { self.abort(); @@ -652,12 +768,27 @@ impl FuseConn { negotiated_flags |= (init_out.flags2 as u64) << 32; } let negotiated_minor = core::cmp::min(init_out.minor, FUSE_KERNEL_MINOR_VERSION); - let negotiated_max_pages = + let negotiated_max_pages_raw = if (negotiated_flags & FUSE_MAX_PAGES) != 0 && init_out.max_pages != 0 { init_out.max_pages } else { 1 }; + let negotiated_max_write = core::cmp::max(4096usize, init_out.max_write as usize); + let max_write_cap = Self::max_write_cap_for_user_read_chunk(); + let capped_max_write = core::cmp::min(negotiated_max_write, max_write_cap); + if capped_max_write < negotiated_max_write { + log::trace!( + "fuse: cap negotiated max_write from {} to {} due user read chunk limit", + negotiated_max_write, + capped_max_write + ); + } + let pages_from_write = core::cmp::max( + 1usize, + capped_max_write.div_ceil(MMArch::PAGE_SIZE), + ) as u16; + let negotiated_max_pages = core::cmp::min(negotiated_max_pages_raw, pages_from_write); { let mut g = self.inner.lock(); @@ -666,7 +797,7 @@ impl FuseConn { g.init = FuseInitNegotiated { minor: negotiated_minor, max_readahead: init_out.max_readahead, - max_write: core::cmp::max(4096, init_out.max_write), + max_write: capped_max_write as u32, time_gran: init_out.time_gran, max_pages: negotiated_max_pages, flags: negotiated_flags, @@ -680,6 +811,33 @@ impl FuseConn { Ok(data.len()) } + fn handle_notify(&self, code: i32, payload: &[u8]) -> Result<(), SystemError> { + if code <= 0 { + return Err(SystemError::EINVAL); + } + match code { + FUSE_NOTIFY_POLL + | FUSE_NOTIFY_INVAL_INODE + | FUSE_NOTIFY_INVAL_ENTRY + | FUSE_NOTIFY_STORE + | FUSE_NOTIFY_RETRIEVE + | FUSE_NOTIFY_DELETE => { + log::debug!("fuse: notify code={} len={}", code, payload.len()); + Ok(()) + } + _ => Err(SystemError::EINVAL), + } + } + + fn is_expected_reply_error(opcode: u32, errno: i32) -> bool { + matches!( + (opcode, SystemError::from_i32(errno)), + (FUSE_LOOKUP, Some(SystemError::ENOENT)) + | (FUSE_FLUSH, Some(SystemError::ENOSYS)) + | (FUSE_INTERRUPT, Some(SystemError::EAGAIN_OR_EWOULDBLOCK)) + ) + } + #[allow(dead_code)] pub fn negotiated_state(&self) -> (u32, u32, u32, u32, u16, u64) { let g = self.inner.lock(); @@ -692,4 +850,9 @@ impl FuseConn { g.init.flags, ) } + + pub fn max_write(&self) -> usize { + let g = self.inner.lock(); + core::cmp::max(4096usize, g.init.max_write as usize) + } } diff --git a/kernel/src/filesystem/fuse/dev.rs b/kernel/src/filesystem/fuse/dev.rs index ff11ff617b..42d2c7e8ac 100644 --- a/kernel/src/filesystem/fuse/dev.rs +++ b/kernel/src/filesystem/fuse/dev.rs @@ -173,7 +173,10 @@ impl IndexNode for LockedFuseDevInode { let conn = conn_any .downcast::() .map_err(|_| SystemError::EINVAL)?; - conn.read_request(nonblock, &mut buf[..len]) + match conn.read_request(nonblock, &mut buf[..len]) { + Err(SystemError::ENOTCONN) => Err(SystemError::ENODEV), + x => x, + } } fn write_at( @@ -197,7 +200,10 @@ impl IndexNode for LockedFuseDevInode { let conn = conn_any .downcast::() .map_err(|_| SystemError::EINVAL)?; - conn.write_reply(&buf[..len]) + match conn.write_reply(&buf[..len]) { + Err(SystemError::ENOTCONN) => Err(SystemError::ENOENT), + x => x, + } } fn metadata(&self) -> Result { diff --git a/kernel/src/filesystem/fuse/inode.rs b/kernel/src/filesystem/fuse/inode.rs index 827c4ef372..d466b4754d 100644 --- a/kernel/src/filesystem/fuse/inode.rs +++ b/kernel/src/filesystem/fuse/inode.rs @@ -13,6 +13,7 @@ use crate::{ driver::base::device::device_number::DeviceNumber, filesystem::vfs::{ file::{FileFlags, FuseDirPrivateData, FuseFilePrivateData}, + permission::PermissionMask, syscall::RenameFlags, FilePrivateData, FileSystem, FileType, IndexNode, InodeFlags, InodeId, InodeMode, Metadata, }, @@ -24,13 +25,16 @@ use super::{ conn::FuseConn, fs::FuseFS, protocol::{ - fuse_pack_struct, fuse_read_struct, FuseAttr, FuseAttrOut, FuseDirent, FuseEntryOut, - FuseGetattrIn, FuseMkdirIn, FuseMknodIn, FuseOpenIn, FuseOpenOut, FuseReadIn, - FuseReleaseIn, FuseRenameIn, FuseSetattrIn, FuseWriteIn, FuseWriteOut, FATTR_ATIME, - FATTR_CTIME, FATTR_GID, FATTR_MODE, FATTR_MTIME, FATTR_SIZE, FATTR_UID, FUSE_GETATTR, - FUSE_LOOKUP, FUSE_MKDIR, FUSE_MKNOD, FUSE_OPEN, FUSE_OPENDIR, FUSE_READ, FUSE_READDIR, - FUSE_RELEASE, FUSE_RELEASEDIR, FUSE_RENAME, FUSE_RMDIR, FUSE_ROOT_ID, FUSE_SETATTR, - FUSE_UNLINK, FUSE_WRITE, + fuse_pack_struct, fuse_read_struct, FuseAccessIn, FuseAttr, FuseAttrOut, FuseCreateIn, + FuseDirent, FuseDirentPlus, FuseEntryOut, FuseFlushIn, FuseFsyncIn, FuseGetattrIn, + FuseLinkIn, FuseMkdirIn, FuseMknodIn, FuseOpenIn, FuseOpenOut, FuseReadIn, FuseReleaseIn, + FuseRename2In, FuseRenameIn, FuseSetattrIn, FuseWriteIn, FuseWriteOut, FATTR_ATIME, + FATTR_CTIME, FATTR_GID, FATTR_MODE, FATTR_MTIME, FATTR_SIZE, FATTR_UID, FUSE_ACCESS, + FUSE_CREATE, FUSE_FLUSH, FUSE_FSYNC, FUSE_FSYNCDIR, FUSE_FSYNC_FDATASYNC, FUSE_GETATTR, + FUSE_LINK, FUSE_LOOKUP, FUSE_MKDIR, FUSE_MKNOD, FUSE_OPEN, FUSE_OPENDIR, FUSE_READ, + FUSE_READDIR, FUSE_READDIRPLUS, FUSE_READLINK, FUSE_RELEASE, FUSE_RELEASEDIR, FUSE_RENAME, + FUSE_RENAME2, FUSE_RMDIR, FUSE_ROOT_ID, FUSE_SETATTR, FUSE_SYMLINK, FUSE_UNLINK, + FUSE_WRITE, }, }; @@ -130,19 +134,20 @@ impl FuseNode { fn attr_to_metadata(attr: &FuseAttr) -> Metadata { let mode = InodeMode::from_bits_truncate(attr.mode); - let file_type = if mode.contains(InodeMode::S_IFDIR) { + let ifmt = mode.bits() & InodeMode::S_IFMT.bits(); + let file_type = if ifmt == InodeMode::S_IFDIR.bits() { FileType::Dir - } else if mode.contains(InodeMode::S_IFREG) { + } else if ifmt == InodeMode::S_IFREG.bits() { FileType::File - } else if mode.contains(InodeMode::S_IFLNK) { + } else if ifmt == InodeMode::S_IFLNK.bits() { FileType::SymLink - } else if mode.contains(InodeMode::S_IFCHR) { + } else if ifmt == InodeMode::S_IFCHR.bits() { FileType::CharDevice - } else if mode.contains(InodeMode::S_IFBLK) { + } else if ifmt == InodeMode::S_IFBLK.bits() { FileType::BlockDevice - } else if mode.contains(InodeMode::S_IFSOCK) { + } else if ifmt == InodeMode::S_IFSOCK.bits() { FileType::Socket - } else if mode.contains(InodeMode::S_IFIFO) { + } else if ifmt == InodeMode::S_IFIFO.bits() { FileType::Pipe } else { FileType::File @@ -202,13 +207,67 @@ impl FuseNode { data: &mut FilePrivateData, flags: &FileFlags, ) -> Result<(), SystemError> { + if self.conn.should_skip_open(opcode) { + let conn_any: Arc = self.conn.clone(); + match opcode { + FUSE_OPEN => { + *data = FilePrivateData::FuseFile(FuseFilePrivateData { + conn: conn_any, + fh: 0, + open_flags: flags.bits(), + no_open: true, + }); + return Ok(()); + } + FUSE_OPENDIR => { + *data = FilePrivateData::FuseDir(FuseDirPrivateData { + conn: conn_any, + fh: 0, + open_flags: flags.bits(), + no_open: true, + }); + return Ok(()); + } + _ => return Err(SystemError::EINVAL), + } + } + let open_in = FuseOpenIn { flags: flags.bits(), open_flags: 0, }; - let payload = self + let payload = match self .conn() - .request(opcode, self.nodeid, fuse_pack_struct(&open_in))?; + .request(opcode, self.nodeid, fuse_pack_struct(&open_in)) + { + Ok(v) => v, + Err(SystemError::ENOSYS) if self.conn.open_enosys_is_supported(opcode) => { + self.conn.mark_no_open(opcode); + let conn_any: Arc = self.conn.clone(); + match opcode { + FUSE_OPEN => { + *data = FilePrivateData::FuseFile(FuseFilePrivateData { + conn: conn_any, + fh: 0, + open_flags: open_in.flags, + no_open: true, + }); + return Ok(()); + } + FUSE_OPENDIR => { + *data = FilePrivateData::FuseDir(FuseDirPrivateData { + conn: conn_any, + fh: 0, + open_flags: open_in.flags, + no_open: true, + }); + return Ok(()); + } + _ => return Err(SystemError::EINVAL), + } + } + Err(e) => return Err(e), + }; let out: FuseOpenOut = fuse_read_struct(&payload)?; let conn_any: Arc = self.conn.clone(); @@ -218,6 +277,7 @@ impl FuseNode { conn: conn_any, fh: out.fh, open_flags: open_in.flags, + no_open: false, }); } FUSE_OPENDIR => { @@ -225,6 +285,7 @@ impl FuseNode { conn: conn_any, fh: out.fh, open_flags: open_in.flags, + no_open: false, }); } _ => return Err(SystemError::EINVAL), @@ -260,6 +321,78 @@ impl FuseNode { } Ok(()) } + + fn fsync_common(&self, datasync: bool) -> Result<(), SystemError> { + let md = self.cached_or_fetch_metadata()?; + let opcode = match md.file_type { + FileType::File => FUSE_FSYNC, + FileType::Dir => FUSE_FSYNCDIR, + _ => return Ok(()), + }; + let inarg = FuseFsyncIn { + fh: 0, + fsync_flags: if datasync { FUSE_FSYNC_FDATASYNC } else { 0 }, + padding: 0, + }; + let _ = self + .conn() + .request(opcode, self.nodeid, fuse_pack_struct(&inarg))?; + Ok(()) + } + + fn fsync_with_file_data( + &self, + datasync: bool, + data: &FilePrivateData, + ) -> Result<(), SystemError> { + let (opcode, fh, no_open) = match data { + FilePrivateData::FuseFile(p) => (FUSE_FSYNC, p.fh, p.no_open), + FilePrivateData::FuseDir(p) => (FUSE_FSYNCDIR, p.fh, p.no_open), + _ => return self.fsync_common(datasync), + }; + + // Linux 对 no_open/no_opendir 语义允许缺省 open，fh 不可靠，直接成功返回。 + if no_open { + return Ok(()); + } + + let inarg = FuseFsyncIn { + fh, + fsync_flags: if datasync { FUSE_FSYNC_FDATASYNC } else { 0 }, + padding: 0, + }; + let _ = self + .conn() + .request(opcode, self.nodeid, fuse_pack_struct(&inarg))?; + Ok(()) + } + + fn parse_create_reply(payload: &[u8]) -> Result<(FuseEntryOut, FuseOpenOut), SystemError> { + let entry_size = size_of::(); + let open_size = size_of::(); + if payload.len() < entry_size + open_size { + return Err(SystemError::EINVAL); + } + let entry: FuseEntryOut = fuse_read_struct(&payload[..entry_size])?; + let open_out: FuseOpenOut = fuse_read_struct(&payload[entry_size..entry_size + open_size])?; + Ok((entry, open_out)) + } + + fn create_node_from_entry( + &self, + entry: &FuseEntryOut, + ) -> Result, SystemError> { + let md = Self::attr_to_metadata(&entry.attr); + let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; + let child = fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md)); + child.inc_lookup(1); + child.set_cached_metadata_with_valid( + Self::attr_to_metadata(&entry.attr), + entry.attr_valid, + entry.attr_valid_nsec, + ); + Ok(child) + } } impl IndexNode for FuseNode { @@ -282,8 +415,28 @@ impl IndexNode for FuseNode { fn close(&self, data: MutexGuard) -> Result<(), SystemError> { match &*data { - FilePrivateData::FuseFile(p) => self.release_common(FUSE_RELEASE, p.fh, p.open_flags), - FilePrivateData::FuseDir(p) => self.release_common(FUSE_RELEASEDIR, p.fh, p.open_flags), + FilePrivateData::FuseFile(p) => { + if p.no_open { + return Ok(()); + } + let flush_in = FuseFlushIn { + fh: p.fh, + unused: 0, + padding: 0, + lock_owner: 0, + }; + let _ = self + .conn() + .request(FUSE_FLUSH, self.nodeid, fuse_pack_struct(&flush_in)); + self.release_common(FUSE_RELEASE, p.fh, p.open_flags) + } + FilePrivateData::FuseDir(p) => { + if p.no_open { + Ok(()) + } else { + self.release_common(FUSE_RELEASEDIR, p.fh, p.open_flags) + } + } _ => Ok(()), } } @@ -295,10 +448,20 @@ impl IndexNode for FuseNode { buf: &mut [u8], data: MutexGuard, ) -> Result { - self.ensure_regular()?; if buf.len() < len { return Err(SystemError::EINVAL); } + let md = self.cached_or_fetch_metadata()?; + if md.file_type == FileType::SymLink { + if offset != 0 { + return Ok(0); + } + let payload = self.conn().request(FUSE_READLINK, self.nodeid, &[])?; + let n = core::cmp::min(payload.len(), len); + buf[..n].copy_from_slice(&payload[..n]); + return Ok(n); + } + self.ensure_regular()?; let FilePrivateData::FuseFile(p) = &*data else { return Err(SystemError::EBADF); }; @@ -333,27 +496,54 @@ impl IndexNode for FuseNode { let FilePrivateData::FuseFile(p) = &*data else { return Err(SystemError::EBADF); }; - let write_in = FuseWriteIn { - fh: p.fh, - offset: offset as u64, - size: len as u32, - write_flags: 0, - lock_owner: 0, - flags: 0, - padding: 0, - }; - let mut payload_in = Vec::with_capacity(size_of::() + len); - payload_in.extend_from_slice(fuse_pack_struct(&write_in)); - payload_in.extend_from_slice(&buf[..len]); - let payload = self.conn().request(FUSE_WRITE, self.nodeid, &payload_in)?; - let out: FuseWriteOut = fuse_read_struct(&payload)?; - Ok(out.size as usize) + let max_write = self.conn().max_write(); + let mut total_written = 0usize; + + while total_written < len { + let chunk = core::cmp::min(max_write, len - total_written); + let chunk_offset = offset + .checked_add(total_written) + .ok_or(SystemError::EOVERFLOW)?; + + let write_in = FuseWriteIn { + fh: p.fh, + offset: chunk_offset as u64, + size: chunk as u32, + write_flags: 0, + lock_owner: 0, + flags: 0, + padding: 0, + }; + let mut payload_in = Vec::with_capacity(size_of::() + chunk); + payload_in.extend_from_slice(fuse_pack_struct(&write_in)); + payload_in.extend_from_slice(&buf[total_written..total_written + chunk]); + let payload = self.conn().request(FUSE_WRITE, self.nodeid, &payload_in)?; + let out: FuseWriteOut = fuse_read_struct(&payload)?; + let wrote = core::cmp::min(out.size as usize, chunk); + total_written += wrote; + if wrote < chunk { + break; + } + } + + Ok(total_written) } fn metadata(&self) -> Result { self.cached_or_fetch_metadata() } + fn check_access(&self, mask: PermissionMask) -> Result<(), SystemError> { + let inarg = FuseAccessIn { + mask: mask.bits() & PermissionMask::MAY_RWX.bits(), + padding: 0, + }; + let _ = self + .conn() + .request(FUSE_ACCESS, self.nodeid, fuse_pack_struct(&inarg))?; + Ok(()) + } + fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> { let old = self.cached_or_fetch_metadata()?; let mut valid = 0u32; @@ -437,6 +627,22 @@ impl IndexNode for FuseNode { Ok(()) } + fn sync(&self) -> Result<(), SystemError> { + self.fsync_common(false) + } + + fn datasync(&self) -> Result<(), SystemError> { + self.fsync_common(true) + } + + fn sync_file( + &self, + datasync: bool, + data: MutexGuard, + ) -> Result<(), SystemError> { + self.fsync_with_file_data(datasync, &data) + } + fn fs(&self) -> Arc { self.fs.upgrade().unwrap() } @@ -453,6 +659,7 @@ impl IndexNode for FuseNode { }; let fh = dir_p.fh; let open_flags = dir_p.open_flags; + let mut use_readdirplus = self.conn.use_readdirplus(); let mut names: Vec = Vec::new(); let mut offset: u64 = 0; @@ -467,36 +674,92 @@ impl IndexNode for FuseNode { flags: 0, padding: 0, }; - let payload = - self.conn() - .request(FUSE_READDIR, self.nodeid, fuse_pack_struct(&read_in))?; + let opcode = if use_readdirplus { + FUSE_READDIRPLUS + } else { + FUSE_READDIR + }; + let payload = match self + .conn() + .request(opcode, self.nodeid, fuse_pack_struct(&read_in)) + { + Ok(v) => v, + Err(SystemError::ENOSYS) if use_readdirplus => { + self.conn.disable_readdirplus(); + use_readdirplus = false; + continue; + } + Err(e) => return Err(e), + }; if payload.is_empty() { break; } let mut pos: usize = 0; let mut last_off: u64 = offset; - while pos + size_of::() <= payload.len() { - let dirent: FuseDirent = fuse_read_struct(&payload[pos..])?; - let name_start = pos + size_of::(); - let name_end = name_start + dirent.namelen as usize; - if name_end > payload.len() { - break; - } - let name_bytes = &payload[name_start..name_end]; - if let Ok(name) = core::str::from_utf8(name_bytes) { - if !name.is_empty() && name != "." && name != ".." { - names.push(name.to_string()); + if use_readdirplus { + while pos + size_of::() <= payload.len() { + let plus: FuseDirentPlus = fuse_read_struct(&payload[pos..])?; + let dirent = plus.dirent; + let name_start = pos + size_of::(); + let name_end = name_start + dirent.namelen as usize; + if name_end > payload.len() { + break; + } + let name_bytes = &payload[name_start..name_end]; + if let Ok(name) = core::str::from_utf8(name_bytes) { + if !name.is_empty() && name != "." && name != ".." { + names.push(name.to_string()); + if plus.entry_out.nodeid != 0 { + if let Some(fs) = self.fs.upgrade() { + let md = Self::attr_to_metadata(&plus.entry_out.attr); + let child = fs.get_or_create_node( + plus.entry_out.nodeid, + self.nodeid, + Some(md), + ); + child.inc_lookup(1); + child.set_cached_metadata_with_valid( + Self::attr_to_metadata(&plus.entry_out.attr), + plus.entry_out.attr_valid, + plus.entry_out.attr_valid_nsec, + ); + } + } + } + } + + last_off = dirent.off; + let rec_len_unaligned = size_of::() + dirent.namelen as usize; + let rec_len = (rec_len_unaligned + 8 - 1) & !(8 - 1); + if rec_len == 0 { + break; } + pos = pos.saturating_add(rec_len); } + } else { + while pos + size_of::() <= payload.len() { + let dirent: FuseDirent = fuse_read_struct(&payload[pos..])?; + let name_start = pos + size_of::(); + let name_end = name_start + dirent.namelen as usize; + if name_end > payload.len() { + break; + } + let name_bytes = &payload[name_start..name_end]; + if let Ok(name) = core::str::from_utf8(name_bytes) { + if !name.is_empty() && name != "." && name != ".." { + names.push(name.to_string()); + } + } - last_off = dirent.off; - let rec_len_unaligned = size_of::() + dirent.namelen as usize; - let rec_len = (rec_len_unaligned + 8 - 1) & !(8 - 1); - if rec_len == 0 { - break; + last_off = dirent.off; + let rec_len_unaligned = size_of::() + dirent.namelen as usize; + let rec_len = (rec_len_unaligned + 8 - 1) & !(8 - 1); + if rec_len == 0 { + break; + } + pos = pos.saturating_add(rec_len); } - pos = pos.saturating_add(rec_len); } if last_off == offset { @@ -507,7 +770,9 @@ impl IndexNode for FuseNode { } // RELEASEDIR (best-effort) - let _ = self.release_common(FUSE_RELEASEDIR, fh, open_flags); + if !dir_p.no_open { + let _ = self.release_common(FUSE_RELEASEDIR, fh, open_flags); + } Ok(names) } @@ -545,6 +810,37 @@ impl IndexNode for FuseNode { Ok(fs.get_or_create_node(parent_nodeid, parent_nodeid, None)) } + fn create( + &self, + name: &str, + file_type: FileType, + mode: InodeMode, + ) -> Result, SystemError> { + self.ensure_dir()?; + if file_type != FileType::File { + return self.create_with_data(name, file_type, mode, 0); + } + + let inarg = FuseCreateIn { + flags: FileFlags::O_RDONLY.bits(), + mode: (InodeMode::S_IFREG | mode).bits(), + umask: 0, + open_flags: 0, + }; + let mut payload_in = Vec::with_capacity(size_of::() + name.len() + 1); + payload_in.extend_from_slice(fuse_pack_struct(&inarg)); + payload_in.extend_from_slice(name.as_bytes()); + payload_in.push(0); + + let payload = match self.conn().request(FUSE_CREATE, self.nodeid, &payload_in) { + Ok(v) => v, + Err(SystemError::ENOSYS) => return self.create_with_data(name, file_type, mode, 0), + Err(e) => return Err(e), + }; + let (entry, _) = Self::parse_create_reply(&payload)?; + self.create_node_from_entry(&entry) + } + fn create_with_data( &self, name: &str, @@ -566,16 +862,7 @@ impl IndexNode for FuseNode { payload_in.push(0); let payload = self.conn().request(FUSE_MKDIR, self.nodeid, &payload_in)?; let entry: FuseEntryOut = fuse_read_struct(&payload)?; - let md = Self::attr_to_metadata(&entry.attr); - let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; - let child = fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md)); - child.inc_lookup(1); - child.set_cached_metadata_with_valid( - Self::attr_to_metadata(&entry.attr), - entry.attr_valid, - entry.attr_valid_nsec, - ); - Ok(child) + self.create_node_from_entry(&entry) } FileType::File => { let inarg = FuseMknodIn { @@ -590,21 +877,55 @@ impl IndexNode for FuseNode { payload_in.push(0); let payload = self.conn().request(FUSE_MKNOD, self.nodeid, &payload_in)?; let entry: FuseEntryOut = fuse_read_struct(&payload)?; - let md = Self::attr_to_metadata(&entry.attr); - let fs = self.fs.upgrade().ok_or(SystemError::ENOENT)?; - let child = fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md)); - child.inc_lookup(1); - child.set_cached_metadata_with_valid( - Self::attr_to_metadata(&entry.attr), - entry.attr_valid, - entry.attr_valid_nsec, - ); - Ok(child) + self.create_node_from_entry(&entry) + } + FileType::SymLink => { + let mut payload_in = Vec::with_capacity(name.len() + 2); + payload_in.push(0); + payload_in.extend_from_slice(name.as_bytes()); + payload_in.push(0); + let payload = self + .conn() + .request(FUSE_SYMLINK, self.nodeid, &payload_in)?; + let entry: FuseEntryOut = fuse_read_struct(&payload)?; + self.create_node_from_entry(&entry) } _ => Err(SystemError::ENOSYS), } } + fn symlink(&self, name: &str, target: &str) -> Result, SystemError> { + self.ensure_dir()?; + let mut payload_in = Vec::with_capacity(target.len() + name.len() + 2); + payload_in.extend_from_slice(target.as_bytes()); + payload_in.push(0); + payload_in.extend_from_slice(name.as_bytes()); + payload_in.push(0); + let payload = self + .conn() + .request(FUSE_SYMLINK, self.nodeid, &payload_in)?; + let entry: FuseEntryOut = fuse_read_struct(&payload)?; + self.create_node_from_entry(&entry) + } + + fn link(&self, name: &str, other: &Arc) -> Result<(), SystemError> { + self.ensure_dir()?; + let target = other + .as_any_ref() + .downcast_ref::() + .ok_or(SystemError::EXDEV)?; + let inarg = FuseLinkIn { + oldnodeid: target.nodeid, + }; + let mut payload_in = Vec::with_capacity(size_of::() + name.len() + 1); + payload_in.extend_from_slice(fuse_pack_struct(&inarg)); + payload_in.extend_from_slice(name.as_bytes()); + payload_in.push(0); + let payload = self.conn().request(FUSE_LINK, self.nodeid, &payload_in)?; + let _entry: FuseEntryOut = fuse_read_struct(&payload)?; + Ok(()) + } + fn unlink(&self, name: &str) -> Result<(), SystemError> { self.ensure_dir()?; let _ = self.request_name(FUSE_UNLINK, self.nodeid, name)?; @@ -622,7 +943,7 @@ impl IndexNode for FuseNode { old_name: &str, target: &Arc, new_name: &str, - _flag: RenameFlags, + flag: RenameFlags, ) -> Result<(), SystemError> { self.ensure_dir()?; let target_any = target @@ -630,16 +951,31 @@ impl IndexNode for FuseNode { .downcast_ref::() .ok_or(SystemError::EXDEV)?; - let inarg = FuseRenameIn { - newdir: target_any.nodeid, - }; let mut payload_in = Vec::new(); - payload_in.extend_from_slice(fuse_pack_struct(&inarg)); + let opcode = if flag.is_empty() { + let inarg = FuseRenameIn { + newdir: target_any.nodeid, + }; + payload_in.extend_from_slice(fuse_pack_struct(&inarg)); + FUSE_RENAME + } else { + let inarg = FuseRename2In { + newdir: target_any.nodeid, + flags: flag.bits(), + padding: 0, + }; + payload_in.extend_from_slice(fuse_pack_struct(&inarg)); + FUSE_RENAME2 + }; payload_in.extend_from_slice(old_name.as_bytes()); payload_in.push(0); payload_in.extend_from_slice(new_name.as_bytes()); payload_in.push(0); - let _ = self.conn().request(FUSE_RENAME, self.nodeid, &payload_in)?; + let r = self.conn().request(opcode, self.nodeid, &payload_in); + if opcode == FUSE_RENAME2 && matches!(r, Err(SystemError::ENOSYS)) { + return Err(SystemError::EINVAL); + } + let _ = r?; Ok(()) } diff --git a/kernel/src/filesystem/fuse/protocol.rs b/kernel/src/filesystem/fuse/protocol.rs index 7afeae77ad..1f37d8fb0b 100644 --- a/kernel/src/filesystem/fuse/protocol.rs +++ b/kernel/src/filesystem/fuse/protocol.rs @@ -19,21 +19,32 @@ pub const FUSE_LOOKUP: u32 = 1; pub const FUSE_FORGET: u32 = 2; // no reply pub const FUSE_GETATTR: u32 = 3; pub const FUSE_SETATTR: u32 = 4; +pub const FUSE_READLINK: u32 = 5; +pub const FUSE_SYMLINK: u32 = 6; pub const FUSE_MKNOD: u32 = 8; pub const FUSE_MKDIR: u32 = 9; pub const FUSE_UNLINK: u32 = 10; pub const FUSE_RMDIR: u32 = 11; pub const FUSE_RENAME: u32 = 12; +pub const FUSE_LINK: u32 = 13; pub const FUSE_OPEN: u32 = 14; pub const FUSE_READ: u32 = 15; pub const FUSE_WRITE: u32 = 16; pub const FUSE_STATFS: u32 = 17; pub const FUSE_RELEASE: u32 = 18; +pub const FUSE_FSYNC: u32 = 20; +pub const FUSE_FLUSH: u32 = 25; pub const FUSE_INIT: u32 = 26; pub const FUSE_OPENDIR: u32 = 27; pub const FUSE_READDIR: u32 = 28; pub const FUSE_RELEASEDIR: u32 = 29; +pub const FUSE_FSYNCDIR: u32 = 30; +pub const FUSE_ACCESS: u32 = 34; +pub const FUSE_CREATE: u32 = 35; +pub const FUSE_INTERRUPT: u32 = 36; pub const FUSE_DESTROY: u32 = 38; // no reply +pub const FUSE_READDIRPLUS: u32 = 44; +pub const FUSE_RENAME2: u32 = 45; // INIT flags (subset) pub const FUSE_ASYNC_READ: u64 = 1 << 0; @@ -43,6 +54,8 @@ pub const FUSE_EXPORT_SUPPORT: u64 = 1 << 4; pub const FUSE_BIG_WRITES: u64 = 1 << 5; pub const FUSE_DONT_MASK: u64 = 1 << 6; pub const FUSE_AUTO_INVAL_DATA: u64 = 1 << 12; +pub const FUSE_DO_READDIRPLUS: u64 = 1 << 13; +pub const FUSE_READDIRPLUS_AUTO: u64 = 1 << 14; pub const FUSE_ASYNC_DIO: u64 = 1 << 15; pub const FUSE_WRITEBACK_CACHE: u64 = 1 << 16; pub const FUSE_NO_OPEN_SUPPORT: u64 = 1 << 17; @@ -70,6 +83,14 @@ pub const FATTR_ATIME_NOW: u32 = 1 << 7; pub const FATTR_MTIME_NOW: u32 = 1 << 8; pub const FATTR_CTIME: u32 = 1 << 10; +pub const FUSE_FSYNC_FDATASYNC: u32 = 1 << 0; +pub const FUSE_NOTIFY_POLL: i32 = 1; +pub const FUSE_NOTIFY_INVAL_INODE: i32 = 2; +pub const FUSE_NOTIFY_INVAL_ENTRY: i32 = 3; +pub const FUSE_NOTIFY_STORE: i32 = 4; +pub const FUSE_NOTIFY_RETRIEVE: i32 = 5; +pub const FUSE_NOTIFY_DELETE: i32 = 6; + #[repr(C)] #[derive(Debug, Clone, Copy)] pub struct FuseInHeader { @@ -159,6 +180,12 @@ pub struct FuseForgetIn { pub nlookup: u64, } +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseInterruptIn { + pub unique: u64, +} + #[repr(C)] #[derive(Debug, Clone, Copy)] pub struct FuseGetattrIn { @@ -274,6 +301,20 @@ pub struct FuseRenameIn { pub newdir: u64, } +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseRename2In { + pub newdir: u64, + pub flags: u32, + pub padding: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseLinkIn { + pub oldnodeid: u64, +} + #[repr(C)] #[derive(Debug, Clone, Copy)] pub struct FuseSetattrIn { @@ -305,6 +346,47 @@ pub struct FuseDirent { // name follows } +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseDirentPlus { + pub entry_out: FuseEntryOut, + pub dirent: FuseDirent, + // name follows +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseCreateIn { + pub flags: u32, + pub mode: u32, + pub umask: u32, + pub open_flags: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseFlushIn { + pub fh: u64, + pub unused: u32, + pub padding: u32, + pub lock_owner: u64, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseFsyncIn { + pub fh: u64, + pub fsync_flags: u32, + pub padding: u32, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub struct FuseAccessIn { + pub mask: u32, + pub padding: u32, +} + pub fn fuse_pack_struct(v: &T) -> &[u8] { unsafe { core::slice::from_raw_parts((v as *const T).cast::(), size_of::()) } } diff --git a/kernel/src/filesystem/vfs/file.rs b/kernel/src/filesystem/vfs/file.rs index d131064f33..6743faee15 100644 --- a/kernel/src/filesystem/vfs/file.rs +++ b/kernel/src/filesystem/vfs/file.rs @@ -153,6 +153,7 @@ pub struct FuseFilePrivateData { pub conn: Arc, pub fh: u64, pub open_flags: u32, + pub no_open: bool, } #[derive(Debug, Clone)] @@ -160,6 +161,7 @@ pub struct FuseDirPrivateData { pub conn: Arc, pub fh: u64, pub open_flags: u32, + pub no_open: bool, } impl Default for FilePrivateData { @@ -512,10 +514,10 @@ impl File { if need_data_sync || inode_sync { if need_metadata_sync || inode_sync { // O_SYNC 或 S_SYNC: 完整同步（数据 + 元数据） - self.inode.sync()?; + self.inode.sync_file(false, self.private_data.lock())?; } else { // O_DSYNC: 仅数据同步 - self.inode.datasync()?; + self.inode.sync_file(true, self.private_data.lock())?; } } Ok(()) diff --git a/kernel/src/filesystem/vfs/mod.rs b/kernel/src/filesystem/vfs/mod.rs index 07960cd226..87899f01ba 100644 --- a/kernel/src/filesystem/vfs/mod.rs +++ b/kernel/src/filesystem/vfs/mod.rs @@ -543,6 +543,15 @@ pub trait IndexNode: Any + Sync + Send + Debug + CastFromSync { return Err(SystemError::ENOSYS); } + /// @brief 在当前目录下创建符号链接（name -> target） + fn symlink(&self, name: &str, target: &str) -> Result, SystemError> { + let inode = self.create_with_data(name, FileType::SymLink, InodeMode::S_IRWXUGO, 0)?; + let bytes = target.as_bytes(); + let len = bytes.len(); + inode.write_at(0, len, bytes, Mutex::new(FilePrivateData::Unused).lock())?; + Ok(inode) + } + /// @brief 在当前目录下，创建一个名为Name的硬链接，指向另一个IndexNode /// /// @param name 硬链接的名称 @@ -591,6 +600,11 @@ pub trait IndexNode: Any + Sync + Send + Debug + CastFromSync { return Err(SystemError::ENOSYS); } + /// @brief 专用于 remote 权限模型下 access(2) 的检查 + fn check_access(&self, _mask: PermissionMask) -> Result<(), SystemError> { + Err(SystemError::ENOSYS) + } + /// @brief 寻找一个名为Name的inode /// /// @param name 要寻找的inode的名称 @@ -764,6 +778,21 @@ pub trait IndexNode: Any + Sync + Send + Debug + CastFromSync { self.datasync() } + /// @brief 基于打开文件上下文执行同步（可使用文件句柄等私有信息） + /// + /// 默认实现回退到 inode 级 `sync/datasync`。 + fn sync_file( + &self, + datasync: bool, + _data: MutexGuard, + ) -> Result<(), SystemError> { + if datasync { + self.datasync() + } else { + self.sync() + } + } + /// @brief 仅同步数据到磁盘（不包括元数据） /// /// O_DSYNC 语义：确保数据写入完成，但不保证元数据（如 mtime）更新 @@ -1522,7 +1551,13 @@ pub fn produce_fs( data: Option<&str>, source: &str, ) -> Result, SystemError> { - match FSMAKER.iter().find(|&m| m.name == filesystem) { + let canonical_filesystem = if filesystem.starts_with("fuse.") { + "fuse" + } else { + filesystem + }; + + match FSMAKER.iter().find(|&m| m.name == canonical_filesystem) { Some(maker) => { let mount_data = (maker.builder)(data, source)?; let mount_data_ref = mount_data.as_ref().map(|arc| arc.as_ref()); diff --git a/kernel/src/filesystem/vfs/mount.rs b/kernel/src/filesystem/vfs/mount.rs index a661afcfcc..ec02ebda27 100644 --- a/kernel/src/filesystem/vfs/mount.rs +++ b/kernel/src/filesystem/vfs/mount.rs @@ -657,6 +657,14 @@ impl IndexNode for MountFSInode { return self.inner_inode.sync(); } + fn sync_file( + &self, + datasync: bool, + data: MutexGuard, + ) -> Result<(), SystemError> { + self.inner_inode.sync_file(datasync, data) + } + fn fadvise( &self, file: &Arc, @@ -796,6 +804,15 @@ impl IndexNode for MountFSInode { return self.inner_inode.link(name, &other_inner); } + fn symlink(&self, name: &str, target: &str) -> Result, SystemError> { + let inner_inode = self.inner_inode.symlink(name, target)?; + Ok(Arc::new_cyclic(|self_ref| MountFSInode { + inner_inode, + mount_fs: self.mount_fs.clone(), + self_ref: self_ref.clone(), + })) + } + /// @brief 在挂载文件系统中删除文件/文件夹 #[inline] fn unlink(&self, name: &str) -> Result<(), SystemError> { @@ -848,6 +865,13 @@ impl IndexNode for MountFSInode { .move_to(old_name, &target_inner, new_name, flags); } + fn check_access( + &self, + mask: crate::filesystem::vfs::permission::PermissionMask, + ) -> Result<(), SystemError> { + self.inner_inode.check_access(mask) + } + fn find(&self, name: &str) -> Result, SystemError> { match name { // 查找的是当前目录 diff --git a/kernel/src/filesystem/vfs/open.rs b/kernel/src/filesystem/vfs/open.rs index 925cacf7f7..176193235b 100644 --- a/kernel/src/filesystem/vfs/open.rs +++ b/kernel/src/filesystem/vfs/open.rs @@ -8,7 +8,7 @@ use super::{ syscall::{OpenHow, OpenHowResolve}, utils::{rsplit_path, should_remove_sgid_on_chown, user_path_at}, vcore::{check_parent_dir_permission_inode, resolve_parent_inode}, - FileType, IndexNode, InodeMode, MAX_PATHLEN, VFS_MAX_FOLLOW_SYMLINK_TIMES, + FileType, FsPermissionPolicy, IndexNode, InodeMode, MAX_PATHLEN, VFS_MAX_FOLLOW_SYMLINK_TIMES, }; use crate::{filesystem::vfs::syscall::UtimensFlags, process::cred::Kgid}; use crate::{ @@ -67,9 +67,34 @@ pub(super) fn do_faccessat( let (inode, path) = user_path_at(&ProcessManager::current_pcb(), dirfd, path)?; // 如果找不到文件，则返回错误码ENOENT - let _inode = inode.lookup_follow_symlink(path.as_str(), VFS_MAX_FOLLOW_SYMLINK_TIMES)?; + let inode = inode.lookup_follow_symlink(path.as_str(), VFS_MAX_FOLLOW_SYMLINK_TIMES)?; + if mode.bits() == 0 { + return Ok(0); + } + + let mut mask = PermissionMask::empty(); + if mode.contains(InodeMode::S_IROTH) { + mask |= PermissionMask::MAY_READ; + } + if mode.contains(InodeMode::S_IWOTH) { + mask |= PermissionMask::MAY_WRITE; + } + if mode.contains(InodeMode::S_IXOTH) { + mask |= PermissionMask::MAY_EXEC; + } + + let metadata = inode.metadata()?; + match inode.fs().permission_policy() { + FsPermissionPolicy::Dac => { + super::permission::check_inode_permission(&inode, &metadata, mask)?; + } + FsPermissionPolicy::Remote => match inode.check_access(mask) { + Ok(()) => {} + Err(SystemError::ENOSYS) => {} + Err(e) => return Err(e), + }, + } - // todo: 接着完善（可以借鉴linux 6.1.9的do_faccessat） return Ok(0); } diff --git a/kernel/src/filesystem/vfs/syscall/readlink_at.rs b/kernel/src/filesystem/vfs/syscall/readlink_at.rs index cb0f7270f4..b9b55ab14d 100644 --- a/kernel/src/filesystem/vfs/syscall/readlink_at.rs +++ b/kernel/src/filesystem/vfs/syscall/readlink_at.rs @@ -2,10 +2,9 @@ use system_error::SystemError; use crate::{ filesystem::vfs::{ - file::{File, FileFlags}, - utils::user_path_at, - FileType, MAX_PATHLEN, VFS_MAX_FOLLOW_SYMLINK_TIMES, + utils::user_path_at, FilePrivateData, FileType, MAX_PATHLEN, VFS_MAX_FOLLOW_SYMLINK_TIMES, }, + libs::mutex::Mutex, process::ProcessManager, syscall::user_access::{check_and_clone_cstr, UserBufferWriter}, }; @@ -31,9 +30,12 @@ pub fn do_readlink_at( let ubuf = user_buf.buffer::(0).unwrap(); - let file = File::new(inode, FileFlags::O_RDONLY)?; - - let len = file.read(buf_size, ubuf)?; + let len = inode.read_at( + 0, + buf_size, + ubuf, + Mutex::new(FilePrivateData::Unused).lock(), + )?; return Ok(len); } diff --git a/kernel/src/filesystem/vfs/syscall/symlink_utils.rs b/kernel/src/filesystem/vfs/syscall/symlink_utils.rs index 89e2b9da9c..de12f5987e 100644 --- a/kernel/src/filesystem/vfs/syscall/symlink_utils.rs +++ b/kernel/src/filesystem/vfs/syscall/symlink_utils.rs @@ -4,14 +4,11 @@ use crate::{ filesystem::vfs::{ fcntl::AtFlags, utils::{rsplit_path, user_path_at}, - FilePrivateData, FileType, NAME_MAX, VFS_MAX_FOLLOW_SYMLINK_TIMES, + FileType, NAME_MAX, VFS_MAX_FOLLOW_SYMLINK_TIMES, }, - libs::mutex::Mutex, process::ProcessManager, }; -use super::InodeMode; - pub fn do_symlinkat(from: &str, newdfd: Option, to: &str) -> Result { let newdfd = match newdfd { Some(fd) => fd, @@ -52,12 +49,7 @@ pub fn do_symlinkat(from: &str, newdfd: Option, to: &str) -> Result/dev/null 2>&1; then \ + curl -fL --retry 3 --retry-delay 1 -o "$@.tmp" "$(LIBFUSE_URL_PRIMARY)" || \ + curl -fL --retry 3 --retry-delay 1 -o "$@.tmp" "$(LIBFUSE_URL_MIRROR)"; \ + elif command -v wget >/dev/null 2>&1; then \ + wget -O "$@.tmp" "$(LIBFUSE_URL_PRIMARY)" || \ + wget -O "$@.tmp" "$(LIBFUSE_URL_MIRROR)"; \ + else \ + echo "error: neither curl nor wget found"; \ + exit 1; \ + fi + @mv "$@.tmp" "$@" + +$(LIBFUSE_SRC_DIR): $(LIBFUSE_ARCHIVE) + @mkdir -p $(LIBFUSE_SRC_ROOT) + @rm -rf "$(LIBFUSE_SRC_DIR)" + @tar -xzf "$(LIBFUSE_ARCHIVE)" -C "$(LIBFUSE_SRC_ROOT)" + +$(LIBFUSE_STAMP): $(LIBFUSE_SRC_DIR) + @command -v "$(MESON)" >/dev/null 2>&1 || (echo "error: meson not found" && exit 1) + @command -v ninja >/dev/null 2>&1 || (echo "error: ninja not found" && exit 1) + @command -v "$(PKG_CONFIG)" >/dev/null 2>&1 || (echo "error: pkg-config not found" && exit 1) + @rm -rf "$(LIBFUSE_BUILD_DIR)" "$(LIBFUSE_PREFIX)" + @mkdir -p "$(LIBFUSE_BUILD_DIR)" "$(LIBFUSE_PREFIX)" + @CC="$(CC)" AR="$(AR)" RANLIB="$(RANLIB)" STRIP="$(STRIP)" \ + CFLAGS="$(LIBFUSE_MESON_CFLAGS)" LDFLAGS="$(LIBFUSE_MESON_LDFLAGS)" \ + $(MESON) setup "$(LIBFUSE_BUILD_DIR)" "$(LIBFUSE_SRC_DIR)" \ + --buildtype=release \ + --default-library=static \ + --prefix="$(LIBFUSE_PREFIX)" \ + --libdir=lib \ + -Dexamples=false \ + -Dutils=false \ + -Ddisable-mtab=true \ + -Duseroot=false + @env -u MAKEFLAGS $(MESON) compile -C "$(LIBFUSE_BUILD_DIR)" -j "$(LIBFUSE_MESON_JOBS)" + @env -u MAKEFLAGS $(MESON) install -C "$(LIBFUSE_BUILD_DIR)" + @touch "$@" + +fuse3_demo: fuse3_demo.c $(LIBFUSE_STAMP) + @FUSE_CFLAGS="$$(PKG_CONFIG_PATH="$(LIBFUSE_PC_DIR)" $(PKG_CONFIG) --cflags fuse3)"; \ + FUSE_LIBS="$$(PKG_CONFIG_PATH="$(LIBFUSE_PC_DIR)" $(PKG_CONFIG) --static --libs fuse3)"; \ + $(CC) $(CFLAGS_COMMON) $$FUSE_CFLAGS $< -o $@ $$FUSE_LIBS + +test_fuse3_demo: test_fuse3_demo.c + $(CC) $(CFLAGS_COMMON) $< -o $@ + +install: all + @echo "Installing binaries to $(DADK_CURRENT_BUILD_DIR)/" + mv $(BINS) $(DADK_CURRENT_BUILD_DIR)/ + +clean: + rm -f $(BINS) + rm -rf "$(LIBFUSE_BUILD_DIR)" "$(LIBFUSE_PREFIX)" + +distclean: clean + rm -rf "$(LIBFUSE_SRC_ROOT)" "$(LIBFUSE_CACHE_DIR)" + +.PHONY: all install clean distclean diff --git a/user/apps/fuse3_demo/README.md b/user/apps/fuse3_demo/README.md new file mode 100644 index 0000000000..5317a866e8 --- /dev/null +++ b/user/apps/fuse3_demo/README.md @@ -0,0 +1,55 @@ +# fuse3_demo（基于 libfuse3 的 DragonOS FUSE 演示） + +`fuse3_demo` 是基于 `libfuse3` 的最小可运行 demo，用于推进 `TODO_FUSE_FULL_PLAN_CN.md` 的 P4（生态兼容）目标。 + +## 设计目标 + +- 自动下载 `libfuse3` 源码并本地构建静态库 +- `fuse3_demo` 二进制静态链接 `libfuse3` +- 提供一个可回归的集成测试 `test_fuse3_demo` + +## 构建 + +在项目根目录下： + +```bash +make -C user/apps/fuse3_demo -j8 +``` + +默认行为： + +1. 自动下载 `fuse-3.18.1.tar.gz` +2. 使用 meson/ninja 构建 `libfuse3.a` +3. 静态链接生成： + - `fuse3_demo` + - `test_fuse3_demo` + +可选变量： + +- `LIBFUSE_VERSION`：指定 libfuse 版本（默认 `3.18.1`） +- `LIBFUSE_URL_PRIMARY`：主下载地址 +- `LIBFUSE_URL_MIRROR`：镜像下载地址 +- `LIBFUSE_ARCHIVE`：指定本地 tarball（离线构建时可用） +- `LIBFUSE_MESON_JOBS`：libfuse 编译并行度（默认 `1`，避免 jobserver 兼容问题） + +## 运行 demo + +```bash +mkdir -p /tmp/fuse3_mnt +fuse3_demo /tmp/fuse3_mnt --single +``` + +默认会创建临时 backing 目录，并在挂载点导出 `hello.txt`。 + +## 运行测试 + +```bash +test_fuse3_demo +``` + +测试会： + +1. 启动 `fuse3_demo` +2. 校验 `hello.txt` 读取 +3. 校验创建/写入/重命名/删除文件 +4. 发送信号停止 daemon 并清理挂载点 diff --git a/user/apps/fuse3_demo/fuse3_demo.c b/user/apps/fuse3_demo/fuse3_demo.c new file mode 100644 index 0000000000..5f5b61e500 --- /dev/null +++ b/user/apps/fuse3_demo/fuse3_demo.c @@ -0,0 +1,613 @@ +#define FUSE_USE_VERSION 31 +#define _GNU_SOURCE + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static char g_backing_dir[PATH_MAX]; +static int g_cleanup_backing = 0; +static int g_verbose_log = -1; + +static int demo_verbose_enabled(void) { + if (g_verbose_log < 0) { + const char *v = getenv("FUSE3_TEST_LOG"); + g_verbose_log = (v && v[0] && strcmp(v, "0") != 0) ? 1 : 0; + } + return g_verbose_log; +} + +static void demo_logf(const char *fmt, ...) { + if (!demo_verbose_enabled()) { + return; + } + va_list ap; + va_start(ap, fmt); + fprintf(stderr, "[fuse3-demo] "); + vfprintf(stderr, fmt, ap); + fprintf(stderr, "\n"); + va_end(ap); +} + +static int demo_sanitize_open_flags(int flags, int for_create) { + int keep = O_ACCMODE | O_APPEND | O_NONBLOCK | O_DSYNC | O_DIRECT | O_LARGEFILE | + O_DIRECTORY | O_NOFOLLOW | O_NOATIME | O_CLOEXEC; +#ifdef O_PATH + keep |= O_PATH; +#endif +#ifdef O_SYNC + keep |= O_SYNC; +#endif +#ifdef O_TRUNC + keep |= O_TRUNC; +#endif + if (for_create) { + keep |= O_CREAT; +#ifdef O_EXCL + keep |= O_EXCL; +#endif + } + return flags & keep; +} + +static int demo_realpath(const char *path, char *buf, size_t buflen) { + if (!path || path[0] != '/') { + return -EINVAL; + } + int n = snprintf(buf, buflen, "%s%s", g_backing_dir, path); + if (n < 0 || (size_t)n >= buflen) { + return -ENAMETOOLONG; + } + return 0; +} + +static void remove_tree(const char *root) { + DIR *dir = opendir(root); + if (!dir) { + return; + } + + struct dirent *ent; + while ((ent = readdir(dir)) != NULL) { + if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0) { + continue; + } + char full[PATH_MAX]; + int n = snprintf(full, sizeof(full), "%s/%s", root, ent->d_name); + if (n < 0 || (size_t)n >= sizeof(full)) { + continue; + } + + struct stat st; + if (lstat(full, &st) != 0) { + continue; + } + + if (S_ISDIR(st.st_mode)) { + remove_tree(full); + rmdir(full); + } else { + unlink(full); + } + } + closedir(dir); +} + +static int prepare_backing_dir(const char *custom) { + const char *base = custom; + char tmp[] = "/tmp/fuse3_demo_backing_XXXXXX"; + + if (!base) { + base = mkdtemp(tmp); + if (!base) { + return -errno; + } + g_cleanup_backing = 1; + } else { + struct stat st; + if (stat(base, &st) != 0) { + if (mkdir(base, 0755) != 0) { + return -errno; + } + } else if (!S_ISDIR(st.st_mode)) { + return -ENOTDIR; + } + } + + if (strlen(base) >= sizeof(g_backing_dir)) { + return -ENAMETOOLONG; + } + strcpy(g_backing_dir, base); + + char hello_path[PATH_MAX]; + int err = demo_realpath("/hello.txt", hello_path, sizeof(hello_path)); + if (err) { + return err; + } + + int fd = open(hello_path, O_CREAT | O_WRONLY | O_TRUNC, 0644); + if (fd < 0) { + return -errno; + } + + const char *msg = "hello from libfuse3\n"; + ssize_t wn = write(fd, msg, strlen(msg)); + close(fd); + if (wn != (ssize_t)strlen(msg)) { + return -EIO; + } + return 0; +} + +static int demo_getattr(const char *path, struct stat *stbuf, struct fuse_file_info *fi) { + (void)fi; + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + if (lstat(full, stbuf) != 0) { + return -errno; + } + return 0; +} + +static int demo_access(const char *path, int mask) { + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + if (access(full, mask) != 0) { + return -errno; + } + return 0; +} + +static int demo_readlink(const char *path, char *buf, size_t size) { + if (size == 0) { + return -EINVAL; + } + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + ssize_t len = readlink(full, buf, size - 1); + if (len < 0) { + return -errno; + } + buf[len] = '\0'; + return 0; +} + +static int demo_readdir(const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, + struct fuse_file_info *fi, enum fuse_readdir_flags flags) { + (void)offset; + (void)fi; + (void)flags; + + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + + DIR *dir = opendir(full); + if (!dir) { + return -errno; + } + + struct dirent *ent; + while ((ent = readdir(dir)) != NULL) { + struct stat st; + memset(&st, 0, sizeof(st)); + st.st_ino = ent->d_ino; + st.st_mode = (mode_t)(ent->d_type << 12); + if (filler(buf, ent->d_name, &st, 0, 0) != 0) { + break; + } + } + closedir(dir); + return 0; +} + +static int demo_mknod(const char *path, mode_t mode, dev_t rdev) { + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + + int ret; + if (S_ISREG(mode)) { + ret = open(full, O_CREAT | O_EXCL | O_WRONLY, mode); + if (ret >= 0) { + close(ret); + ret = 0; + } + } else if (S_ISFIFO(mode)) { + ret = mkfifo(full, mode); + } else { + ret = mknod(full, mode, rdev); + } + if (ret != 0) { + return -errno; + } + return 0; +} + +static int demo_mkdir(const char *path, mode_t mode) { + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + if (mkdir(full, mode) != 0) { + return -errno; + } + return 0; +} + +static int demo_unlink(const char *path) { + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + if (unlink(full) != 0) { + return -errno; + } + return 0; +} + +static int demo_rmdir(const char *path) { + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + if (rmdir(full) != 0) { + return -errno; + } + return 0; +} + +static int demo_symlink(const char *from, const char *to) { + char full_to[PATH_MAX]; + int err = demo_realpath(to, full_to, sizeof(full_to)); + if (err) { + return err; + } + if (symlink(from, full_to) != 0) { + return -errno; + } + return 0; +} + +static int demo_rename(const char *from, const char *to, unsigned int flags) { + if (flags != 0) { + return -EINVAL; + } + + char full_from[PATH_MAX]; + char full_to[PATH_MAX]; + int err = demo_realpath(from, full_from, sizeof(full_from)); + if (err) { + return err; + } + err = demo_realpath(to, full_to, sizeof(full_to)); + if (err) { + return err; + } + + if (rename(full_from, full_to) != 0) { + return -errno; + } + return 0; +} + +static int demo_link(const char *from, const char *to) { + char full_from[PATH_MAX]; + char full_to[PATH_MAX]; + int err = demo_realpath(from, full_from, sizeof(full_from)); + if (err) { + return err; + } + err = demo_realpath(to, full_to, sizeof(full_to)); + if (err) { + return err; + } + if (link(full_from, full_to) != 0) { + return -errno; + } + return 0; +} + +static int demo_chmod(const char *path, mode_t mode, struct fuse_file_info *fi) { + (void)fi; + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + if (chmod(full, mode) != 0) { + return -errno; + } + return 0; +} + +static int demo_chown(const char *path, uid_t uid, gid_t gid, struct fuse_file_info *fi) { + (void)fi; + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + if (lchown(full, uid, gid) != 0) { + return -errno; + } + return 0; +} + +static int demo_truncate(const char *path, off_t size, struct fuse_file_info *fi) { + if (fi != NULL) { + if (ftruncate((int)fi->fh, size) != 0) { + demo_logf("truncate fh=%llu size=%lld errno=%d", (unsigned long long)fi->fh, + (long long)size, errno); + return -errno; + } + demo_logf("truncate fh=%llu size=%lld ok", (unsigned long long)fi->fh, (long long)size); + return 0; + } + + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + if (truncate(full, size) != 0) { + demo_logf("truncate path=%s size=%lld errno=%d", path, (long long)size, errno); + return -errno; + } + demo_logf("truncate path=%s size=%lld ok", path, (long long)size); + return 0; +} + +static int demo_open(const char *path, struct fuse_file_info *fi) { + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + int open_flags = demo_sanitize_open_flags(fi->flags, 0); + int fd = open(full, open_flags); + if (fd < 0) { + demo_logf("open path=%s flags=0x%x sanitized=0x%x errno=%d", path, fi->flags, open_flags, + errno); + return -errno; + } + demo_logf("open path=%s flags=0x%x sanitized=0x%x fd=%d", path, fi->flags, open_flags, fd); + fi->fh = (uint64_t)fd; + return 0; +} + +static int demo_create(const char *path, mode_t mode, struct fuse_file_info *fi) { + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + int create_flags = demo_sanitize_open_flags(fi->flags | O_CREAT, 1); + int fd = open(full, create_flags, mode); + if (fd < 0) { + demo_logf("create path=%s flags=0x%x sanitized=0x%x mode=0%o errno=%d", path, fi->flags, + create_flags, (unsigned)mode, errno); + return -errno; + } + demo_logf("create path=%s flags=0x%x sanitized=0x%x mode=0%o fd=%d", path, fi->flags, + create_flags, (unsigned)mode, fd); + fi->fh = (uint64_t)fd; + return 0; +} + +static int demo_read(const char *path, char *buf, size_t size, off_t offset, + struct fuse_file_info *fi) { + (void)path; + int fd = (int)fi->fh; + ssize_t n = pread(fd, buf, size, offset); + if (n < 0) { + return -errno; + } + return (int)n; +} + +static int demo_write(const char *path, const char *buf, size_t size, off_t offset, + struct fuse_file_info *fi) { + (void)path; + int fd = (int)fi->fh; + ssize_t n = pwrite(fd, buf, size, offset); + if (n < 0) { + return -errno; + } + return (int)n; +} + +static int demo_statfs(const char *path, struct statvfs *stbuf) { + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + if (statvfs(full, stbuf) != 0) { + return -errno; + } + return 0; +} + +static int demo_flush(const char *path, struct fuse_file_info *fi) { + (void)path; + if (fi == NULL) { + return 0; + } + + int dupfd = dup((int)fi->fh); + if (dupfd < 0) { + return -errno; + } + if (close(dupfd) != 0) { + return -errno; + } + return 0; +} + +static int demo_release(const char *path, struct fuse_file_info *fi) { + (void)path; + if (close((int)fi->fh) != 0) { + return -errno; + } + return 0; +} + +static int demo_fsync(const char *path, int isdatasync, struct fuse_file_info *fi) { + (void)path; + int ret = isdatasync ? fdatasync((int)fi->fh) : fsync((int)fi->fh); + if (ret != 0) { + return -errno; + } + return 0; +} + +static int demo_fsyncdir(const char *path, int isdatasync, struct fuse_file_info *fi) { + (void)path; + (void)isdatasync; + (void)fi; + return 0; +} + +static int demo_utimens(const char *path, const struct timespec tv[2], struct fuse_file_info *fi) { + (void)fi; + char full[PATH_MAX]; + int err = demo_realpath(path, full, sizeof(full)); + if (err) { + return err; + } + if (utimensat(AT_FDCWD, full, tv, AT_SYMLINK_NOFOLLOW) != 0) { + return -errno; + } + return 0; +} + +static void *demo_init(struct fuse_conn_info *conn, struct fuse_config *cfg) { + (void)cfg; + fprintf(stderr, "fuse3_demo: INIT proto=%u.%u capable=0x%llx want=0x%llx\n", conn->proto_major, + conn->proto_minor, (unsigned long long)conn->capable, + (unsigned long long)conn->want); + return NULL; +} + +static struct fuse_operations g_ops = { + .init = demo_init, + .getattr = demo_getattr, + .readlink = demo_readlink, + .mknod = demo_mknod, + .mkdir = demo_mkdir, + .unlink = demo_unlink, + .rmdir = demo_rmdir, + .symlink = demo_symlink, + .rename = demo_rename, + .link = demo_link, + .chmod = demo_chmod, + .chown = demo_chown, + .truncate = demo_truncate, + .open = demo_open, + .read = demo_read, + .write = demo_write, + .statfs = demo_statfs, + .flush = demo_flush, + .release = demo_release, + .fsync = demo_fsync, + .fsyncdir = demo_fsyncdir, + .readdir = demo_readdir, + .create = demo_create, + .utimens = demo_utimens, + .access = demo_access, +}; + +static void usage(const char *prog) { + fprintf(stderr, + "Usage: %s [--backing-dir DIR] [--single] [--debug] [libfuse opts...]\n", + prog); +} + +int main(int argc, char **argv) { + if (argc < 2) { + usage(argv[0]); + return 1; + } + + const char *mountpoint = argv[1]; + const char *backing_dir = NULL; + + char **fuse_argv = calloc((size_t)argc + 4, sizeof(char *)); + if (!fuse_argv) { + perror("calloc"); + return 1; + } + + int fuse_argc = 0; + fuse_argv[fuse_argc++] = argv[0]; + fuse_argv[fuse_argc++] = "-f"; + + for (int i = 2; i < argc; i++) { + if (strcmp(argv[i], "--backing-dir") == 0) { + if (i + 1 >= argc) { + usage(argv[0]); + free(fuse_argv); + return 1; + } + backing_dir = argv[++i]; + continue; + } + if (strcmp(argv[i], "--single") == 0) { + fuse_argv[fuse_argc++] = "-s"; + continue; + } + if (strcmp(argv[i], "--debug") == 0) { + fuse_argv[fuse_argc++] = "-d"; + continue; + } + fuse_argv[fuse_argc++] = argv[i]; + } + + fuse_argv[fuse_argc++] = (char *)mountpoint; + + int err = prepare_backing_dir(backing_dir); + if (err != 0) { + fprintf(stderr, "fuse3_demo: prepare backing dir failed: %s (%d)\n", strerror(-err), -err); + free(fuse_argv); + return 1; + } + + fprintf(stderr, "fuse3_demo: mount=%s backing=%s\n", mountpoint, g_backing_dir); + int ret = fuse_main(fuse_argc, fuse_argv, &g_ops, NULL); + + if (g_cleanup_backing) { + remove_tree(g_backing_dir); + rmdir(g_backing_dir); + } + free(fuse_argv); + return ret; +} diff --git a/user/apps/fuse3_demo/test_fuse3_demo.c b/user/apps/fuse3_demo/test_fuse3_demo.c new file mode 100644 index 0000000000..fb6174c227 --- /dev/null +++ b/user/apps/fuse3_demo/test_fuse3_demo.c @@ -0,0 +1,214 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void log_fail(const char *fmt, ...) { + va_list ap; + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); +} + +static int read_all(const char *path, char *buf, size_t cap) { + int fd = open(path, O_RDONLY); + if (fd < 0) { + return -1; + } + ssize_t n = read(fd, buf, cap - 1); + int saved = errno; + close(fd); + if (n < 0) { + errno = saved; + return -1; + } + buf[n] = '\0'; + return (int)n; +} + +static int wait_hello_ready(const char *mountpoint, int timeout_ms) { + char path[256]; + snprintf(path, sizeof(path), "%s/hello.txt", mountpoint); + + int rounds = timeout_ms / 20; + if (rounds < 1) { + rounds = 1; + } + + for (int i = 0; i < rounds; i++) { + char buf[128]; + if (read_all(path, buf, sizeof(buf)) >= 0) { + if (strncmp(buf, "hello from libfuse3\n", 20) == 0) { + return 0; + } + } + usleep(20 * 1000); + } + errno = ETIMEDOUT; + return -1; +} + +static int stop_daemon(pid_t pid, int *status) { + for (int i = 0; i < 100; i++) { + pid_t w = waitpid(pid, status, WNOHANG); + if (w == pid) { + return 0; + } + usleep(20 * 1000); + } + + kill(pid, SIGINT); + for (int i = 0; i < 100; i++) { + pid_t w = waitpid(pid, status, WNOHANG); + if (w == pid) { + return 0; + } + usleep(20 * 1000); + } + + kill(pid, SIGTERM); + for (int i = 0; i < 100; i++) { + pid_t w = waitpid(pid, status, WNOHANG); + if (w == pid) { + return 0; + } + usleep(20 * 1000); + } + + kill(pid, SIGKILL); + return waitpid(pid, status, 0) == pid ? 0 : -1; +} + +int main(void) { + char mnt_template[] = "/tmp/test_fuse3_demo_XXXXXX"; + char *mountpoint = mkdtemp(mnt_template); + if (!mountpoint) { + log_fail("[FAIL] mkdtemp mountpoint: %s (errno=%d)\n", strerror(errno), errno); + return 1; + } + + const char *daemon_path = "/bin/fuse3_demo"; + if (access(daemon_path, X_OK) != 0) { + daemon_path = "./fuse3_demo"; + } + + pid_t pid = fork(); + if (pid < 0) { + log_fail("[FAIL] fork: %s (errno=%d)\n", strerror(errno), errno); + rmdir(mountpoint); + return 1; + } + + if (pid == 0) { + execl(daemon_path, daemon_path, mountpoint, "--single", NULL); + _exit(127); + } + + if (wait_hello_ready(mountpoint, 5000) != 0) { + log_fail("[FAIL] wait hello ready: %s (errno=%d)\n", strerror(errno), errno); + int st = 0; + stop_daemon(pid, &st); + umount(mountpoint); + rmdir(mountpoint); + return 1; + } + + char note[256]; + snprintf(note, sizeof(note), "%s/note.txt", mountpoint); + int fd = open(note, O_CREAT | O_RDWR | O_TRUNC, 0644); + if (fd < 0) { + log_fail("[FAIL] create note: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + + const char *content = "dragonos fuse3 test\n"; + ssize_t wn = write(fd, content, strlen(content)); + close(fd); + if (wn != (ssize_t)strlen(content)) { + log_fail("[FAIL] write note: wn=%zd errno=%d (%s)\n", wn, errno, strerror(errno)); + goto fail; + } + + char read_buf[256]; + if (read_all(note, read_buf, sizeof(read_buf)) < 0) { + log_fail("[FAIL] read note: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (strcmp(read_buf, content) != 0) { + log_fail("[FAIL] content mismatch: got='%s' expect='%s'\n", read_buf, content); + goto fail; + } + + char renamed[256]; + snprintf(renamed, sizeof(renamed), "%s/note2.txt", mountpoint); + if (rename(note, renamed) != 0) { + log_fail("[FAIL] rename note: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + + if (unlink(renamed) != 0) { + log_fail("[FAIL] unlink note2: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + + int dirfd = open(mountpoint, O_RDONLY | O_DIRECTORY); + if (dirfd < 0) { + log_fail("[FAIL] open mountpoint dir: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (fsync(dirfd) != 0) { + log_fail("[FAIL] fsyncdir mountpoint: %s (errno=%d)\n", strerror(errno), errno); + close(dirfd); + goto fail; + } + close(dirfd); + + if (umount(mountpoint) != 0) { + log_fail("[FAIL] umount(%s): %s (errno=%d)\n", mountpoint, strerror(errno), errno); + int status = 0; + stop_daemon(pid, &status); + rmdir(mountpoint); + return 1; + } + + { + int status = 0; + if (stop_daemon(pid, &status) != 0) { + log_fail("[FAIL] stop daemon failed\n"); + rmdir(mountpoint); + return 1; + } + if (!WIFEXITED(status)) { + log_fail("[FAIL] daemon not exited normally, status=%d\n", status); + rmdir(mountpoint); + return 1; + } + int code = WEXITSTATUS(status); + if (code != 0 && code != 8) { + log_fail("[FAIL] daemon exit code=%d (raw=%d)\n", code, status); + rmdir(mountpoint); + return 1; + } + } + + rmdir(mountpoint); + printf("[PASS] fuse3_demo\n"); + return 0; + +fail: + { + int status = 0; + stop_daemon(pid, &status); + } + umount(mountpoint); + rmdir(mountpoint); + return 1; +} diff --git a/user/apps/fuse_demo/README.md b/user/apps/fuse_demo/README.md index 98d2303eaf..2ac819cd78 100644 --- a/user/apps/fuse_demo/README.md +++ b/user/apps/fuse_demo/README.md @@ -77,6 +77,10 @@ fuse_demo /mnt/fuse --threads 4 - `test_fuse_clone`：`FUSE_DEV_IOC_CLONE` 基础路径 - `test_fuse_permissions`：`allow_other/default_permissions` 语义 - `test_fuse_p1_lifecycle`：`FORGET/DESTROY` 生命周期语义 +- `test_fuse_p2_ops`：`ACCESS/CREATE/SYMLINK/READLINK/LINK/RENAME2/FLUSH/FSYNC/FSYNCDIR` +- `test_fuse_p3_interrupt`：信号中断触发 `FUSE_INTERRUPT` 语义 +- `test_fuse_p3_noopen_readdirplus_notify`：`NO_OPEN/NO_OPENDIR/READDIRPLUS/notify(unique=0)` +- `test_fuse_p4_subtype_mount`：`mount(..., "fuse.", ...)` 兼容路径 ## 权限语义备注（对应 Phase E） diff --git a/user/apps/fuse_demo/fuse_test_simplefs.h b/user/apps/fuse_demo/fuse_test_simplefs.h index 4e55089ebf..6c1636d2d1 100644 --- a/user/apps/fuse_demo/fuse_test_simplefs.h +++ b/user/apps/fuse_demo/fuse_test_simplefs.h @@ -50,6 +50,9 @@ static inline int fuse_test_log_enabled(void) { #ifndef DT_REG #define DT_REG 8 #endif +#ifndef DT_LNK +#define DT_LNK 10 +#endif /* Keep test buffers off small thread stacks. */ #define FUSE_TEST_BUF_SIZE (64 * 1024) @@ -67,6 +70,12 @@ static inline int fuse_test_log_enabled(void) { #ifndef FUSE_SETATTR #define FUSE_SETATTR 4 #endif +#ifndef FUSE_READLINK +#define FUSE_READLINK 5 +#endif +#ifndef FUSE_SYMLINK +#define FUSE_SYMLINK 6 +#endif #ifndef FUSE_MKNOD #define FUSE_MKNOD 8 #endif @@ -82,6 +91,9 @@ static inline int fuse_test_log_enabled(void) { #ifndef FUSE_RENAME #define FUSE_RENAME 12 #endif +#ifndef FUSE_LINK +#define FUSE_LINK 13 +#endif #ifndef FUSE_OPEN #define FUSE_OPEN 14 #endif @@ -97,6 +109,12 @@ static inline int fuse_test_log_enabled(void) { #ifndef FUSE_RELEASE #define FUSE_RELEASE 18 #endif +#ifndef FUSE_FSYNC +#define FUSE_FSYNC 20 +#endif +#ifndef FUSE_FLUSH +#define FUSE_FLUSH 25 +#endif #ifndef FUSE_INIT #define FUSE_INIT 26 #endif @@ -109,9 +127,27 @@ static inline int fuse_test_log_enabled(void) { #ifndef FUSE_RELEASEDIR #define FUSE_RELEASEDIR 29 #endif +#ifndef FUSE_FSYNCDIR +#define FUSE_FSYNCDIR 30 +#endif +#ifndef FUSE_ACCESS +#define FUSE_ACCESS 34 +#endif +#ifndef FUSE_CREATE +#define FUSE_CREATE 35 +#endif +#ifndef FUSE_INTERRUPT +#define FUSE_INTERRUPT 36 +#endif #ifndef FUSE_DESTROY #define FUSE_DESTROY 38 #endif +#ifndef FUSE_READDIRPLUS +#define FUSE_READDIRPLUS 44 +#endif +#ifndef FUSE_RENAME2 +#define FUSE_RENAME2 45 +#endif #ifndef FUSE_MIN_READ_BUFFER #define FUSE_MIN_READ_BUFFER 8192 @@ -124,6 +160,35 @@ static inline int fuse_test_log_enabled(void) { #ifndef FUSE_MAX_PAGES #define FUSE_MAX_PAGES (1u << 22) #endif +#ifndef FUSE_DO_READDIRPLUS +#define FUSE_DO_READDIRPLUS (1u << 13) +#endif +#ifndef FUSE_READDIRPLUS_AUTO +#define FUSE_READDIRPLUS_AUTO (1u << 14) +#endif +#ifndef FUSE_NO_OPEN_SUPPORT +#define FUSE_NO_OPEN_SUPPORT (1u << 17) +#endif +#ifndef FUSE_NO_OPENDIR_SUPPORT +#define FUSE_NO_OPENDIR_SUPPORT (1u << 24) +#endif +#ifndef FUSE_FSYNC_FDATASYNC +#define FUSE_FSYNC_FDATASYNC (1u << 0) +#endif + +#ifndef FUSE_NOTIFY_INVAL_INODE +#define FUSE_NOTIFY_INVAL_INODE 2 +#endif + +#ifndef RENAME_NOREPLACE +#define RENAME_NOREPLACE (1u << 0) +#endif +#ifndef RENAME_EXCHANGE +#define RENAME_EXCHANGE (1u << 1) +#endif +#ifndef RENAME_WHITEOUT +#define RENAME_WHITEOUT (1u << 2) +#endif /* setattr valid bits (subset) */ #ifndef FATTR_MODE @@ -214,6 +279,10 @@ struct fuse_forget_in { uint64_t nlookup; }; +struct fuse_interrupt_in { + uint64_t unique; +}; + struct fuse_getattr_in { uint32_t getattr_flags; uint32_t dummy; @@ -232,6 +301,13 @@ struct fuse_open_in { uint32_t open_flags; }; +struct fuse_create_in { + uint32_t flags; + uint32_t mode; + uint32_t umask; + uint32_t open_flags; +}; + struct fuse_open_out { uint64_t fh; uint32_t open_flags; @@ -287,6 +363,24 @@ struct fuse_release_in { uint64_t lock_owner; }; +struct fuse_flush_in { + uint64_t fh; + uint32_t unused; + uint32_t padding; + uint64_t lock_owner; +}; + +struct fuse_fsync_in { + uint64_t fh; + uint32_t fsync_flags; + uint32_t padding; +}; + +struct fuse_access_in { + uint32_t mask; + uint32_t padding; +}; + struct fuse_mknod_in { uint32_t mode; uint32_t rdev; @@ -303,6 +397,16 @@ struct fuse_rename_in { uint64_t newdir; }; +struct fuse_rename2_in { + uint64_t newdir; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_link_in { + uint64_t oldnodeid; +}; + struct fuse_setattr_in { uint32_t valid; uint32_t padding; @@ -330,11 +434,28 @@ struct fuse_dirent { /* char name[]; */ }; +struct fuse_direntplus { + struct fuse_entry_out entry_out; + struct fuse_dirent dirent; + /* char name[]; */ +}; + +struct fuse_notify_inval_inode_out { + uint64_t ino; + int64_t off; + int64_t len; +}; + static inline size_t fuse_dirent_rec_len(size_t namelen) { size_t unaligned = sizeof(struct fuse_dirent) + namelen; return (unaligned + 8 - 1) & ~(size_t)(8 - 1); } +static inline size_t fuse_direntplus_rec_len(size_t namelen) { + size_t unaligned = sizeof(struct fuse_direntplus) + namelen; + return (unaligned + 8 - 1) & ~(size_t)(8 - 1); +} + /* ===== in-memory FS ===== */ #define SIMPLEFS_MAX_NODES 64 @@ -347,6 +468,7 @@ struct simplefs_node { uint64_t ino; uint64_t parent; int is_dir; + int is_symlink; uint32_t mode; /* includes type bits */ char name[SIMPLEFS_NAME_MAX]; unsigned char data[SIMPLEFS_DATA_MAX]; @@ -370,6 +492,7 @@ static inline void simplefs_init(struct simplefs *fs) { fs->nodes[0].ino = 1; fs->nodes[0].parent = 1; fs->nodes[0].is_dir = 1; + fs->nodes[0].is_symlink = 0; fs->nodes[0].mode = 0040755; strcpy(fs->nodes[0].name, ""); fs->nodes[0].size = 0; @@ -380,6 +503,7 @@ static inline void simplefs_init(struct simplefs *fs) { fs->nodes[1].ino = 2; fs->nodes[1].parent = 1; fs->nodes[1].is_dir = 0; + fs->nodes[1].is_symlink = 0; fs->nodes[1].mode = 0100644; strcpy(fs->nodes[1].name, "hello.txt"); const char *msg = "hello from fuse\n"; @@ -390,6 +514,14 @@ static inline void simplefs_init(struct simplefs *fs) { fs->next_ino = 3; } +static inline int simplefs_mode_is_dir(uint32_t mode) { + return (mode & 0170000u) == 0040000u; +} + +static inline int simplefs_mode_is_symlink(uint32_t mode) { + return (mode & 0170000u) == 0120000u; +} + static inline struct simplefs_node *simplefs_find_node(struct simplefs *fs, uint64_t nodeid) { for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { if (fs->nodes[i].used && fs->nodes[i].nodeid == nodeid) { @@ -442,7 +574,7 @@ static inline void simplefs_fill_attr(const struct simplefs_node *n, struct fuse a->size = n->size; a->blocks = (n->size + 511) / 512; a->mode = n->mode; - a->nlink = n->is_dir ? 2 : 1; + a->nlink = simplefs_mode_is_dir(n->mode) ? 2 : 1; a->uid = getuid(); a->gid = getgid(); a->blksize = 4096; @@ -493,9 +625,109 @@ struct fuse_daemon_args { volatile uint32_t *init_in_flags; volatile uint32_t *init_in_flags2; volatile uint32_t *init_in_max_readahead; + volatile uint32_t *access_count; + volatile uint32_t *flush_count; + volatile uint32_t *fsync_count; + volatile uint32_t *fsyncdir_count; + volatile uint32_t *create_count; + volatile uint32_t *rename2_count; + volatile uint32_t *open_count; + volatile uint32_t *opendir_count; + volatile uint32_t *release_count; + volatile uint32_t *releasedir_count; + volatile uint32_t *readdirplus_count; + volatile uint32_t *interrupt_count; + volatile uint64_t *blocked_read_unique; + volatile uint64_t *last_interrupt_target; + uint32_t access_deny_mask; + uint32_t init_out_flags_override; + int force_open_enosys; + int force_opendir_enosys; + int block_read_until_interrupt; struct simplefs fs; }; +static inline int simplefs_node_is_dir(const struct simplefs_node *n) { + return n && (n->is_dir || simplefs_mode_is_dir(n->mode)); +} + +static inline int simplefs_node_is_symlink(const struct simplefs_node *n) { + return n && (n->is_symlink || simplefs_mode_is_symlink(n->mode)); +} + +static inline uint32_t simplefs_dirent_type(const struct simplefs_node *n) { + if (simplefs_node_is_dir(n)) { + return DT_DIR; + } + if (simplefs_node_is_symlink(n)) { + return DT_LNK; + } + return DT_REG; +} + +static inline int simplefs_fill_entry_reply(struct fuse_daemon_args *a, const struct fuse_in_header *h, + const struct simplefs_node *node) { + struct fuse_entry_out out; + memset(&out, 0, sizeof(out)); + out.nodeid = node->nodeid; + simplefs_fill_attr(node, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); +} + +static inline int simplefs_parse_two_names(const unsigned char *payload, size_t payload_len, + size_t fixed_len, const char **oldname_out, + const char **newname_out) { + if (payload_len < fixed_len + 3) { + return -1; + } + const char *names = (const char *)(payload + fixed_len); + size_t names_len = payload_len - fixed_len; + const char *oldname = names; + size_t oldlen = strnlen(oldname, names_len); + if (oldlen == names_len) { + return -1; + } + const char *newname = names + oldlen + 1; + size_t remain = names_len - oldlen - 1; + if (remain == 0) { + return -1; + } + size_t newlen = strnlen(newname, remain); + if (newlen == remain) { + return -1; + } + *oldname_out = oldname; + *newname_out = newname; + return 0; +} + +static inline int simplefs_do_rename(struct fuse_daemon_args *a, const struct fuse_in_header *h, + uint64_t newdir, uint32_t flags, const char *oldname, + const char *newname) { + if ((flags & (RENAME_EXCHANGE | RENAME_WHITEOUT)) != 0) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } + struct simplefs_node *src = simplefs_find_child(&a->fs, h->nodeid, oldname); + if (!src) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + struct simplefs_node *dst_parent = simplefs_find_node(&a->fs, newdir); + if (!dst_parent || !simplefs_node_is_dir(dst_parent)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + struct simplefs_node *dst = simplefs_find_child(&a->fs, newdir, newname); + if (dst) { + if (flags & RENAME_NOREPLACE) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + src->parent = newdir; + strncpy(src->name, newname, sizeof(src->name) - 1); + src->name[sizeof(src->name) - 1] = '\0'; + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); +} + static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned char *req, size_t n) { if (n < sizeof(struct fuse_in_header)) { return -1; @@ -524,7 +756,11 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha memset(&out, 0, sizeof(out)); out.major = 7; out.minor = 39; - out.flags = FUSE_INIT_EXT | FUSE_MAX_PAGES; + uint32_t init_flags = a->init_out_flags_override; + if (init_flags == 0) { + init_flags = FUSE_INIT_EXT | FUSE_MAX_PAGES; + } + out.flags = init_flags; out.flags2 = 0; out.max_write = 4096; out.max_pages = 32; @@ -550,7 +786,7 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha return -1; } struct simplefs_node *parent = simplefs_find_node(&a->fs, h->nodeid); - if (!parent || !parent->is_dir) { + if (!parent || !simplefs_node_is_dir(parent)) { return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); } struct simplefs_node *child = simplefs_find_child(&a->fs, h->nodeid, name); @@ -580,10 +816,22 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha if (!node) { return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); } - if (h->opcode == FUSE_OPENDIR && !node->is_dir) { + if (h->opcode == FUSE_OPEN && a->open_count) { + (*a->open_count)++; + } + if (h->opcode == FUSE_OPENDIR && a->opendir_count) { + (*a->opendir_count)++; + } + if (h->opcode == FUSE_OPEN && a->force_open_enosys) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (h->opcode == FUSE_OPENDIR && a->force_opendir_enosys) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (h->opcode == FUSE_OPENDIR && !simplefs_node_is_dir(node)) { return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); } - if (h->opcode == FUSE_OPEN && node->is_dir) { + if (h->opcode == FUSE_OPEN && simplefs_node_is_dir(node)) { return fuse_write_reply(a->fd, h->unique, -EISDIR, NULL, 0); } struct fuse_open_out out; @@ -591,15 +839,31 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha out.fh = node->nodeid; return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); } + case FUSE_READLINK: { + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (!simplefs_node_is_symlink(node)) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } + return fuse_write_reply(a->fd, h->unique, 0, node->data, node->size); + } case FUSE_READ: { if (payload_len < sizeof(struct fuse_read_in)) { return -1; } const struct fuse_read_in *in = (const struct fuse_read_in *)payload; struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); - if (!node || node->is_dir) { + if (!node || simplefs_node_is_dir(node) || simplefs_node_is_symlink(node)) { return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); } + if (a->block_read_until_interrupt > 0) { + if (a->blocked_read_unique && *a->blocked_read_unique == 0) { + *a->blocked_read_unique = h->unique; + } + usleep((useconds_t)a->block_read_until_interrupt * 1000); + } if (in->offset >= node->size) { return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); } @@ -610,14 +874,19 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha } return fuse_write_reply(a->fd, h->unique, 0, node->data + in->offset, to_copy); } - case FUSE_READDIR: { + case FUSE_READDIR: + case FUSE_READDIRPLUS: { if (payload_len < sizeof(struct fuse_read_in)) { return -1; } const struct fuse_read_in *in = (const struct fuse_read_in *)payload; (void)in; + int is_plus = (h->opcode == FUSE_READDIRPLUS); + if (is_plus && a->readdirplus_count) { + (*a->readdirplus_count)++; + } struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); - if (!node || !node->is_dir) { + if (!node || !simplefs_node_is_dir(node)) { return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); } @@ -633,17 +902,30 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha for (; idx < 2; idx++) { const char *nm = fixed_names[idx]; size_t nmlen = strlen(nm); - size_t reclen = fuse_dirent_rec_len(nmlen); + size_t reclen = is_plus ? fuse_direntplus_rec_len(nmlen) : fuse_dirent_rec_len(nmlen); if (outlen + reclen > FUSE_TEST_BUF_SIZE) break; - struct fuse_dirent de; - memset(&de, 0, sizeof(de)); - de.ino = 1; - de.off = idx + 1; - de.namelen = (uint32_t)nmlen; - de.type = DT_DIR; - memcpy(outbuf + outlen, &de, sizeof(de)); - memcpy(outbuf + outlen + sizeof(de), nm, nmlen); + if (is_plus) { + struct fuse_direntplus dp; + memset(&dp, 0, sizeof(dp)); + dp.entry_out.nodeid = 1; + simplefs_fill_attr(&a->fs.nodes[0], &dp.entry_out.attr); + dp.dirent.ino = 1; + dp.dirent.off = idx + 1; + dp.dirent.namelen = (uint32_t)nmlen; + dp.dirent.type = DT_DIR; + memcpy(outbuf + outlen, &dp, sizeof(dp)); + memcpy(outbuf + outlen + sizeof(dp), nm, nmlen); + } else { + struct fuse_dirent de; + memset(&de, 0, sizeof(de)); + de.ino = 1; + de.off = idx + 1; + de.namelen = (uint32_t)nmlen; + de.type = DT_DIR; + memcpy(outbuf + outlen, &de, sizeof(de)); + memcpy(outbuf + outlen + sizeof(de), nm, nmlen); + } outlen += reclen; } @@ -664,17 +946,30 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha } size_t nmlen = strlen(c->name); - size_t reclen = fuse_dirent_rec_len(nmlen); + size_t reclen = is_plus ? fuse_direntplus_rec_len(nmlen) : fuse_dirent_rec_len(nmlen); if (outlen + reclen > FUSE_TEST_BUF_SIZE) break; - struct fuse_dirent de; - memset(&de, 0, sizeof(de)); - de.ino = c->ino; - de.off = child_base + 1; - de.namelen = (uint32_t)nmlen; - de.type = c->is_dir ? DT_DIR : DT_REG; - memcpy(outbuf + outlen, &de, sizeof(de)); - memcpy(outbuf + outlen + sizeof(de), c->name, nmlen); + if (is_plus) { + struct fuse_direntplus dp; + memset(&dp, 0, sizeof(dp)); + dp.entry_out.nodeid = c->nodeid; + simplefs_fill_attr(c, &dp.entry_out.attr); + dp.dirent.ino = c->ino; + dp.dirent.off = child_base + 1; + dp.dirent.namelen = (uint32_t)nmlen; + dp.dirent.type = simplefs_dirent_type(c); + memcpy(outbuf + outlen, &dp, sizeof(dp)); + memcpy(outbuf + outlen + sizeof(dp), c->name, nmlen); + } else { + struct fuse_dirent de; + memset(&de, 0, sizeof(de)); + de.ino = c->ino; + de.off = child_base + 1; + de.namelen = (uint32_t)nmlen; + de.type = simplefs_dirent_type(c); + memcpy(outbuf + outlen, &de, sizeof(de)); + memcpy(outbuf + outlen + sizeof(de), c->name, nmlen); + } outlen += reclen; child_base++; @@ -711,8 +1006,56 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); } case FUSE_RELEASE: + if (a->release_count) { + (*a->release_count)++; + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); case FUSE_RELEASEDIR: + if (a->releasedir_count) { + (*a->releasedir_count)++; + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_INTERRUPT: { + if (payload_len < sizeof(struct fuse_interrupt_in)) { + return -1; + } + const struct fuse_interrupt_in *in = (const struct fuse_interrupt_in *)payload; + if (a->interrupt_count) { + (*a->interrupt_count)++; + } + if (a->last_interrupt_target) { + *a->last_interrupt_target = in->unique; + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } + case FUSE_FLUSH: + if (a->flush_count) { + (*a->flush_count)++; + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_FSYNC: + if (a->fsync_count) { + (*a->fsync_count)++; + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_FSYNCDIR: + if (a->fsyncdir_count) { + (*a->fsyncdir_count)++; + } return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_ACCESS: { + if (payload_len < sizeof(struct fuse_access_in)) { + return -1; + } + const struct fuse_access_in *in = (const struct fuse_access_in *)payload; + if (a->access_count) { + (*a->access_count)++; + } + if ((in->mask & a->access_deny_mask) != 0) { + return fuse_write_reply(a->fd, h->unique, -EACCES, NULL, 0); + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } case FUSE_DESTROY: if (a->destroy_count) (*a->destroy_count)++; @@ -733,7 +1076,7 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha return -1; } struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); - if (!node || node->is_dir) { + if (!node || simplefs_node_is_dir(node) || simplefs_node_is_symlink(node)) { return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); } if (in->offset >= SIMPLEFS_DATA_MAX) { @@ -752,6 +1095,132 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha out.size = (uint32_t)to_copy; return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); } + case FUSE_CREATE: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_create_in) + 1) { + return -1; + } + const struct fuse_create_in *in = (const struct fuse_create_in *)payload; + const char *name = (const char *)(payload + sizeof(*in)); + if (name[payload_len - sizeof(*in) - 1] != '\0') { + return -1; + } + if (a->create_count) { + (*a->create_count)++; + } + struct simplefs_node *p = simplefs_find_node(&a->fs, h->nodeid); + if (!p || !simplefs_node_is_dir(p)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (simplefs_find_child(&a->fs, h->nodeid, name)) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + struct simplefs_node *nnode = simplefs_alloc(&a->fs); + if (!nnode) { + return fuse_write_reply(a->fd, h->unique, -ENOSPC, NULL, 0); + } + nnode->parent = h->nodeid; + nnode->is_dir = 0; + nnode->is_symlink = 0; + nnode->mode = in->mode; + strncpy(nnode->name, name, sizeof(nnode->name) - 1); + nnode->name[sizeof(nnode->name) - 1] = '\0'; + nnode->size = 0; + + struct { + struct fuse_entry_out entry; + struct fuse_open_out open_out; + } out; + memset(&out, 0, sizeof(out)); + out.entry.nodeid = nnode->nodeid; + simplefs_fill_attr(nnode, &out.entry.attr); + out.open_out.fh = nnode->nodeid; + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_SYMLINK: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + const char *target = (const char *)payload; + size_t target_len = strnlen(target, payload_len); + if (target_len == payload_len) { + return -1; + } + const char *name = target + target_len + 1; + size_t remain = payload_len - target_len - 1; + if (remain == 0) { + return -1; + } + size_t name_len = strnlen(name, remain); + if (name_len == remain) { + return -1; + } + struct simplefs_node *p = simplefs_find_node(&a->fs, h->nodeid); + if (!p || !simplefs_node_is_dir(p)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (simplefs_find_child(&a->fs, h->nodeid, name)) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + struct simplefs_node *nnode = simplefs_alloc(&a->fs); + if (!nnode) { + return fuse_write_reply(a->fd, h->unique, -ENOSPC, NULL, 0); + } + nnode->parent = h->nodeid; + nnode->is_dir = 0; + nnode->is_symlink = 1; + nnode->mode = 0120777; + strncpy(nnode->name, name, sizeof(nnode->name) - 1); + nnode->name[sizeof(nnode->name) - 1] = '\0'; + nnode->size = (target_len < SIMPLEFS_DATA_MAX) ? target_len : SIMPLEFS_DATA_MAX; + memcpy(nnode->data, target, nnode->size); + return simplefs_fill_entry_reply(a, h, nnode); + } + case FUSE_LINK: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_link_in) + 1) { + return -1; + } + const struct fuse_link_in *in = (const struct fuse_link_in *)payload; + const char *name = (const char *)(payload + sizeof(*in)); + if (name[payload_len - sizeof(*in) - 1] != '\0') { + return -1; + } + struct simplefs_node *src = simplefs_find_node(&a->fs, in->oldnodeid); + if (!src) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (simplefs_node_is_dir(src)) { + return fuse_write_reply(a->fd, h->unique, -EPERM, NULL, 0); + } + struct simplefs_node *dst_parent = simplefs_find_node(&a->fs, h->nodeid); + if (!dst_parent || !simplefs_node_is_dir(dst_parent)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (simplefs_find_child(&a->fs, h->nodeid, name)) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + struct simplefs_node *nnode = simplefs_alloc(&a->fs); + if (!nnode) { + return fuse_write_reply(a->fd, h->unique, -ENOSPC, NULL, 0); + } + nnode->parent = h->nodeid; + nnode->is_dir = 0; + nnode->is_symlink = src->is_symlink; + nnode->mode = src->mode; + strncpy(nnode->name, name, sizeof(nnode->name) - 1); + nnode->name[sizeof(nnode->name) - 1] = '\0'; + nnode->size = src->size; + if (nnode->size > SIMPLEFS_DATA_MAX) { + nnode->size = SIMPLEFS_DATA_MAX; + } + memcpy(nnode->data, src->data, nnode->size); + return simplefs_fill_entry_reply(a, h, nnode); + } case FUSE_MKDIR: case FUSE_MKNOD: { if (!a->enable_write_ops) { @@ -781,7 +1250,7 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); } struct simplefs_node *p = simplefs_find_node(&a->fs, h->nodeid); - if (!p || !p->is_dir) { + if (!p || !simplefs_node_is_dir(p)) { return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); } struct simplefs_node *nnode = simplefs_alloc(&a->fs); @@ -790,15 +1259,13 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha } nnode->parent = h->nodeid; nnode->is_dir = is_dir; + nnode->is_symlink = 0; nnode->mode = mode; strncpy(nnode->name, name, sizeof(nnode->name) - 1); + nnode->name[sizeof(nnode->name) - 1] = '\0'; nnode->size = 0; - struct fuse_entry_out out; - memset(&out, 0, sizeof(out)); - out.nodeid = nnode->nodeid; - simplefs_fill_attr(nnode, &out.attr); - return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + return simplefs_fill_entry_reply(a, h, nnode); } case FUSE_UNLINK: case FUSE_RMDIR: { @@ -814,14 +1281,14 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); } if (h->opcode == FUSE_RMDIR) { - if (!child->is_dir) { + if (!simplefs_node_is_dir(child)) { return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); } if (simplefs_has_children(&a->fs, child->nodeid)) { return fuse_write_reply(a->fd, h->unique, -ENOTEMPTY, NULL, 0); } } else { - if (child->is_dir) { + if (simplefs_node_is_dir(child)) { return fuse_write_reply(a->fd, h->unique, -EISDIR, NULL, 0); } } @@ -832,40 +1299,28 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha if (!a->enable_write_ops) { return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); } - if (payload_len < sizeof(struct fuse_rename_in) + 3) { - return -1; - } const struct fuse_rename_in *in = (const struct fuse_rename_in *)payload; - const char *names = (const char *)(payload + sizeof(*in)); - size_t names_len = payload_len - sizeof(*in); - - /* oldname\0newname\0 */ - const char *oldname = names; - size_t oldlen = strnlen(oldname, names_len); - if (oldlen == names_len) - return -1; - const char *newname = names + oldlen + 1; - size_t remain = names_len - oldlen - 1; - if (remain == 0) + const char *oldname = NULL; + const char *newname = NULL; + if (simplefs_parse_two_names(payload, payload_len, sizeof(*in), &oldname, &newname) != 0) { return -1; - size_t newlen = strnlen(newname, remain); - if (newlen == remain) - return -1; - - struct simplefs_node *src = simplefs_find_child(&a->fs, h->nodeid, oldname); - if (!src) { - return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); } - if (simplefs_find_child(&a->fs, in->newdir, newname)) { - return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + return simplefs_do_rename(a, h, in->newdir, 0, oldname, newname); + } + case FUSE_RENAME2: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); } - struct simplefs_node *dst_parent = simplefs_find_node(&a->fs, in->newdir); - if (!dst_parent || !dst_parent->is_dir) { - return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + const struct fuse_rename2_in *in = (const struct fuse_rename2_in *)payload; + const char *oldname = NULL; + const char *newname = NULL; + if (simplefs_parse_two_names(payload, payload_len, sizeof(*in), &oldname, &newname) != 0) { + return -1; } - src->parent = in->newdir; - strncpy(src->name, newname, sizeof(src->name) - 1); - return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + if (a->rename2_count) { + (*a->rename2_count)++; + } + return simplefs_do_rename(a, h, in->newdir, in->flags, oldname, newname); } case FUSE_SETATTR: { if (!a->enable_write_ops) { @@ -879,6 +1334,9 @@ static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned cha if (!node) { return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); } + if (simplefs_node_is_dir(node) || simplefs_node_is_symlink(node)) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } if (in->valid & FATTR_SIZE) { if (in->size > SIMPLEFS_DATA_MAX) { return fuse_write_reply(a->fd, h->unique, -EFBIG, NULL, 0); diff --git a/user/apps/fuse_demo/test_fuse_mount_init.c b/user/apps/fuse_demo/test_fuse_mount_init.c index a8d24648db..f535c4b97d 100644 --- a/user/apps/fuse_demo/test_fuse_mount_init.c +++ b/user/apps/fuse_demo/test_fuse_mount_init.c @@ -84,8 +84,8 @@ static int do_init_handshake(int fd) { init_out.minor = 39; init_out.flags = FUSE_INIT_EXT | FUSE_MAX_PAGES; init_out.flags2 = 0; - init_out.max_write = 4096; - init_out.max_pages = 32; + init_out.max_write = 1024 * 1024; + init_out.max_pages = 256; unsigned char reply[sizeof(out_hdr) + sizeof(init_out)]; memcpy(reply, &out_hdr, sizeof(out_hdr)); diff --git a/user/apps/fuse_demo/test_fuse_p2_ops.c b/user/apps/fuse_demo/test_fuse_p2_ops.c new file mode 100644 index 0000000000..a5dcc882e3 --- /dev/null +++ b/user/apps/fuse_demo/test_fuse_p2_ops.c @@ -0,0 +1,239 @@ +/** + * @file test_fuse_p2_ops.c + * @brief Phase P2 test: ACCESS/CREATE/SYMLINK/READLINK/LINK/RENAME2/FLUSH/FSYNC/FSYNCDIR. + */ + +#include "fuse_test_simplefs.h" + +#include + +static int wait_init(volatile int *init_done) { + for (int i = 0; i < 200; i++) { + if (*init_done) + return 0; + usleep(10 * 1000); + } + errno = ETIMEDOUT; + return -1; +} + +static int write_all(int fd, const char *s) { + size_t left = strlen(s); + const char *p = s; + while (left > 0) { + ssize_t n = write(fd, p, left); + if (n <= 0) { + return -1; + } + p += n; + left -= (size_t)n; + } + return 0; +} + +int main(void) { + const char *mp = "/tmp/test_fuse_p2_ops"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return 1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + return 1; + } + + volatile int stop = 0; + volatile int init_done = 0; + volatile uint32_t access_count = 0; + volatile uint32_t flush_count = 0; + volatile uint32_t fsync_count = 0; + volatile uint32_t fsyncdir_count = 0; + volatile uint32_t create_count = 0; + volatile uint32_t rename2_count = 0; + + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 1; + args.stop_on_destroy = 1; + args.access_count = &access_count; + args.flush_count = &flush_count; + args.fsync_count = &fsync_count; + args.fsyncdir_count = &fsyncdir_count; + args.create_count = &create_count; + args.rename2_count = &rename2_count; + args.access_deny_mask = 2; /* MAY_WRITE */ + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + return 1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0,allow_other", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + if (wait_init(&init_done) != 0) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + + char hello[256]; + snprintf(hello, sizeof(hello), "%s/hello.txt", mp); + if (access(hello, R_OK) != 0) { + printf("[FAIL] access(R_OK): %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (access(hello, W_OK) == 0 || errno != EACCES) { + printf("[FAIL] access(W_OK) expected EACCES, errno=%d (%s)\n", errno, strerror(errno)); + goto fail; + } + + char created[256]; + snprintf(created, sizeof(created), "%s/p2_create.txt", mp); + int f = open(created, O_CREAT | O_RDWR, 0644); + if (f < 0) { + printf("[FAIL] open(O_CREAT): %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (write_all(f, "p2-data") != 0) { + printf("[FAIL] write created file: %s (errno=%d)\n", strerror(errno), errno); + close(f); + goto fail; + } + if (fsync(f) != 0) { + printf("[FAIL] fsync(file): %s (errno=%d)\n", strerror(errno), errno); + close(f); + goto fail; + } + close(f); + + char symlink_path[256]; + snprintf(symlink_path, sizeof(symlink_path), "%s/p2_symlink.txt", mp); + if (symlink("p2_create.txt", symlink_path) != 0) { + printf("[FAIL] symlink: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + char target_buf[256]; + ssize_t tn = readlink(symlink_path, target_buf, sizeof(target_buf) - 1); + if (tn <= 0) { + printf("[FAIL] readlink: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + target_buf[tn] = '\0'; + if (strcmp(target_buf, "p2_create.txt") != 0) { + printf("[FAIL] readlink target mismatch: got=%s\n", target_buf); + goto fail; + } + + char hard_path[256]; + snprintf(hard_path, sizeof(hard_path), "%s/p2_hard.txt", mp); + if (link(created, hard_path) != 0) { + printf("[FAIL] link: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (unlink(created) != 0) { + printf("[FAIL] unlink original: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + f = open(hard_path, O_RDONLY); + if (f < 0) { + printf("[FAIL] open hard link: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + char rbuf[64]; + ssize_t rn = read(f, rbuf, sizeof(rbuf) - 1); + close(f); + if (rn <= 0) { + printf("[FAIL] read hard link: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + rbuf[rn] = '\0'; + if (strcmp(rbuf, "p2-data") != 0) { + printf("[FAIL] hard link content mismatch: got=%s\n", rbuf); + goto fail; + } + + char dst_exist[256]; + snprintf(dst_exist, sizeof(dst_exist), "%s/p2_dst_exist.txt", mp); + f = open(dst_exist, O_CREAT | O_RDWR, 0644); + if (f < 0) { + printf("[FAIL] create dst_exist: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + close(f); + + if (syscall(SYS_renameat2, AT_FDCWD, hard_path, AT_FDCWD, dst_exist, RENAME_NOREPLACE) == 0 + || errno != EEXIST) { + printf("[FAIL] renameat2 NOREPLACE expected EEXIST, errno=%d (%s)\n", errno, + strerror(errno)); + goto fail; + } + + char renamed[256]; + snprintf(renamed, sizeof(renamed), "%s/p2_renamed.txt", mp); + if (syscall(SYS_renameat2, AT_FDCWD, hard_path, AT_FDCWD, renamed, RENAME_NOREPLACE) != 0) { + printf("[FAIL] renameat2 NOREPLACE success path: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + + int dfd = open(mp, O_RDONLY | O_DIRECTORY); + if (dfd < 0) { + printf("[FAIL] open mountpoint dirfd: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (fsync(dfd) != 0) { + printf("[FAIL] fsync(dirfd): %s (errno=%d)\n", strerror(errno), errno); + close(dfd); + goto fail; + } + close(dfd); + + usleep(100 * 1000); + + if (access_count < 2 || flush_count == 0 || fsync_count == 0 || fsyncdir_count == 0 + || create_count == 0 || rename2_count < 2) { + printf("[FAIL] counters access=%u flush=%u fsync=%u fsyncdir=%u create=%u rename2=%u\n", + access_count, flush_count, fsync_count, fsyncdir_count, create_count, + rename2_count); + goto fail; + } + + if (umount(mp) != 0) { + printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + goto fail_noum; + } + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + + printf("[PASS] fuse_p2_ops (access=%u flush=%u fsync=%u fsyncdir=%u create=%u rename2=%u)\n", + access_count, flush_count, fsync_count, fsyncdir_count, create_count, rename2_count); + return 0; + +fail: + umount(mp); +fail_noum: + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return 1; +} diff --git a/user/apps/fuse_demo/test_fuse_p3_interrupt.c b/user/apps/fuse_demo/test_fuse_p3_interrupt.c new file mode 100644 index 0000000000..4a8bfcaeb3 --- /dev/null +++ b/user/apps/fuse_demo/test_fuse_p3_interrupt.c @@ -0,0 +1,191 @@ +/** + * @file test_fuse_p3_interrupt.c + * @brief Phase P3 test: blocked request interrupted by signal -> FUSE_INTERRUPT. + */ + +#include "fuse_test_simplefs.h" + +#include + +static void sigusr1_handler(int signo) { + (void)signo; +} + +static int wait_init(volatile int *init_done) { + for (int i = 0; i < 200; i++) { + if (*init_done) { + return 0; + } + usleep(10 * 1000); + } + errno = ETIMEDOUT; + return -1; +} + +struct reader_ctx { + char path[256]; + volatile int done; + ssize_t nread; + int err; +}; + +static void *reader_thread(void *arg) { + struct reader_ctx *ctx = (struct reader_ctx *)arg; + int fd = open(ctx->path, O_RDONLY); + if (fd < 0) { + ctx->nread = -1; + ctx->err = errno; + ctx->done = 1; + return NULL; + } + + char buf[64]; + ssize_t n = read(fd, buf, sizeof(buf)); + if (n < 0) { + ctx->nread = -1; + ctx->err = errno; + } else { + ctx->nread = n; + ctx->err = 0; + } + close(fd); + ctx->done = 1; + return NULL; +} + +int main(void) { + struct sigaction sa; + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = sigusr1_handler; + sigemptyset(&sa.sa_mask); + sa.sa_flags = 0; /* no SA_RESTART */ + if (sigaction(SIGUSR1, &sa, NULL) != 0) { + printf("[FAIL] sigaction(SIGUSR1): %s (errno=%d)\n", strerror(errno), errno); + return 1; + } + + const char *mp = "/tmp/test_fuse_p3_interrupt"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return 1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + return 1; + } + + volatile int stop = 0; + volatile int init_done = 0; + volatile uint32_t interrupt_count = 0; + volatile uint64_t blocked_read_unique = 0; + volatile uint64_t last_interrupt_target = 0; + + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + args.stop_on_destroy = 1; + args.block_read_until_interrupt = 1000; /* delay read reply 1s */ + args.interrupt_count = &interrupt_count; + args.blocked_read_unique = &blocked_read_unique; + args.last_interrupt_target = &last_interrupt_target; + + pthread_t daemon_th; + if (pthread_create(&daemon_th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create(daemon)\n"); + close(fd); + return 1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(daemon_th, NULL); + return 1; + } + if (wait_init(&init_done) != 0) { + printf("[FAIL] init handshake timeout\n"); + goto fail; + } + + struct reader_ctx rctx; + memset(&rctx, 0, sizeof(rctx)); + snprintf(rctx.path, sizeof(rctx.path), "%s/hello.txt", mp); + + pthread_t reader_th; + if (pthread_create(&reader_th, NULL, reader_thread, &rctx) != 0) { + printf("[FAIL] pthread_create(reader)\n"); + goto fail; + } + + for (int i = 0; i < 200; i++) { + if (blocked_read_unique != 0) { + break; + } + usleep(5 * 1000); + } + if (blocked_read_unique == 0) { + printf("[FAIL] timed out waiting for blocked read request\n"); + stop = 1; + pthread_join(reader_th, NULL); + goto fail; + } + + if (pthread_kill(reader_th, SIGUSR1) != 0) { + printf("[FAIL] pthread_kill(SIGUSR1)\n"); + stop = 1; + pthread_join(reader_th, NULL); + goto fail; + } + pthread_join(reader_th, NULL); + + if (rctx.nread != -1 || rctx.err != EINTR) { + printf("[FAIL] reader expected EINTR, nread=%zd err=%d (%s)\n", rctx.nread, rctx.err, + strerror(rctx.err)); + goto fail; + } + + for (int i = 0; i < 500; i++) { + if (interrupt_count > 0) { + break; + } + usleep(5 * 1000); + } + + if (interrupt_count == 0) { + printf("[FAIL] expected FUSE_INTERRUPT request\n"); + goto fail; + } + if (last_interrupt_target == 0 || last_interrupt_target != blocked_read_unique) { + printf("[FAIL] interrupt target mismatch: blocked=%llu interrupt_target=%llu\n", + (unsigned long long)blocked_read_unique, (unsigned long long)last_interrupt_target); + goto fail; + } + + if (umount(mp) != 0) { + printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + goto fail_no_umount; + } + stop = 1; + close(fd); + pthread_join(daemon_th, NULL); + rmdir(mp); + printf("[PASS] fuse_p3_interrupt (interrupt_count=%u)\n", interrupt_count); + return 0; + +fail: + umount(mp); +fail_no_umount: + stop = 1; + close(fd); + pthread_join(daemon_th, NULL); + rmdir(mp); + return 1; +} diff --git a/user/apps/fuse_demo/test_fuse_p3_noopen_readdirplus_notify.c b/user/apps/fuse_demo/test_fuse_p3_noopen_readdirplus_notify.c new file mode 100644 index 0000000000..c0b410bd12 --- /dev/null +++ b/user/apps/fuse_demo/test_fuse_p3_noopen_readdirplus_notify.c @@ -0,0 +1,160 @@ +/** + * @file test_fuse_p3_noopen_readdirplus_notify.c + * @brief Phase P3 test: NO_OPEN/NO_OPENDIR + READDIRPLUS + notify(unique=0). + */ + +#include "fuse_test_simplefs.h" + +static int wait_init(volatile int *init_done) { + for (int i = 0; i < 200; i++) { + if (*init_done) { + return 0; + } + usleep(10 * 1000); + } + errno = ETIMEDOUT; + return -1; +} + +int main(void) { + const char *mp = "/tmp/test_fuse_p3_noopen"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return 1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + return 1; + } + + volatile int stop = 0; + volatile int init_done = 0; + volatile uint32_t open_count = 0; + volatile uint32_t opendir_count = 0; + volatile uint32_t release_count = 0; + volatile uint32_t releasedir_count = 0; + volatile uint32_t readdirplus_count = 0; + + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + args.stop_on_destroy = 1; + args.open_count = &open_count; + args.opendir_count = &opendir_count; + args.release_count = &release_count; + args.releasedir_count = &releasedir_count; + args.readdirplus_count = &readdirplus_count; + args.force_open_enosys = 1; + args.force_opendir_enosys = 1; + args.init_out_flags_override = FUSE_INIT_EXT | FUSE_MAX_PAGES | FUSE_NO_OPEN_SUPPORT | + FUSE_NO_OPENDIR_SUPPORT | FUSE_DO_READDIRPLUS; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + return 1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 1; + } + if (wait_init(&init_done) != 0) { + printf("[FAIL] init handshake timeout\n"); + goto fail; + } + + char file_path[256]; + snprintf(file_path, sizeof(file_path), "%s/hello.txt", mp); + for (int i = 0; i < 2; i++) { + int f = open(file_path, O_RDONLY); + if (f < 0) { + printf("[FAIL] open(%s): %s (errno=%d)\n", file_path, strerror(errno), errno); + goto fail; + } + char buf[64]; + ssize_t n = read(f, buf, sizeof(buf) - 1); + close(f); + if (n <= 0) { + printf("[FAIL] read(%s): %s (errno=%d)\n", file_path, strerror(errno), errno); + goto fail; + } + } + + for (int i = 0; i < 2; i++) { + DIR *dir = opendir(mp); + if (!dir) { + printf("[FAIL] opendir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + goto fail; + } + int saw = 0; + struct dirent *de; + while ((de = readdir(dir)) != NULL) { + if (strcmp(de->d_name, "hello.txt") == 0) { + saw = 1; + } + } + closedir(dir); + if (!saw) { + printf("[FAIL] readdir didn't see hello.txt\n"); + goto fail; + } + } + + struct { + struct fuse_out_header out; + struct fuse_notify_inval_inode_out inval; + } notify_msg; + memset(¬ify_msg, 0, sizeof(notify_msg)); + notify_msg.out.len = sizeof(notify_msg); + notify_msg.out.error = FUSE_NOTIFY_INVAL_INODE; + notify_msg.out.unique = 0; + notify_msg.inval.ino = 2; + notify_msg.inval.off = 0; + notify_msg.inval.len = -1; + ssize_t wn = write(fd, ¬ify_msg, sizeof(notify_msg)); + if (wn != (ssize_t)sizeof(notify_msg)) { + printf("[FAIL] write notify: wn=%zd errno=%d (%s)\n", wn, errno, strerror(errno)); + goto fail; + } + + usleep(100 * 1000); + + if (open_count != 1 || opendir_count != 1 || release_count != 0 || releasedir_count != 0 || + readdirplus_count == 0) { + printf("[FAIL] counters open=%u opendir=%u release=%u releasedir=%u readdirplus=%u\n", + open_count, opendir_count, release_count, releasedir_count, readdirplus_count); + goto fail; + } + + if (umount(mp) != 0) { + printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + goto fail_no_umount; + } + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + printf("[PASS] fuse_p3_noopen_readdirplus_notify\n"); + return 0; + +fail: + umount(mp); +fail_no_umount: + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return 1; +} diff --git a/user/apps/fuse_demo/test_fuse_p4_subtype_mount.c b/user/apps/fuse_demo/test_fuse_p4_subtype_mount.c new file mode 100644 index 0000000000..325b0df981 --- /dev/null +++ b/user/apps/fuse_demo/test_fuse_p4_subtype_mount.c @@ -0,0 +1,119 @@ +/** + * @file test_fuse_p4_subtype_mount.c + * @brief Phase P4 regression: mount with filesystem type "fuse.". + */ + +#include "fuse_test_simplefs.h" + +static int read_all(const char *path, char *buf, size_t cap) { + int fd = open(path, O_RDONLY); + if (fd < 0) { + return -1; + } + ssize_t n = read(fd, buf, cap - 1); + int saved_errno = errno; + close(fd); + if (n < 0) { + errno = saved_errno; + return -1; + } + buf[n] = '\0'; + return (int)n; +} + +int main(void) { + const char *mp = "/tmp/test_fuse_p4_subtype"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return 1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + return 1; + } + + volatile int stop = 0; + volatile int init_done = 0; + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + args.stop_on_destroy = 1; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + return 1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse.fuse3_demo", 0, opts) != 0) { + printf("[FAIL] mount(fuse.fuse3_demo): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return 1; + } + + for (int i = 0; i < 200; i++) { + if (init_done) { + break; + } + usleep(10 * 1000); + } + if (!init_done) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return 1; + } + + char file_path[256]; + snprintf(file_path, sizeof(file_path), "%s/hello.txt", mp); + + char buf[128]; + if (read_all(file_path, buf, sizeof(buf)) < 0) { + printf("[FAIL] read(%s): %s (errno=%d)\n", file_path, strerror(errno), errno); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return 1; + } + if (strcmp(buf, "hello from fuse\n") != 0) { + printf("[FAIL] content mismatch: got='%s'\n", buf); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return 1; + } + + if (umount(mp) != 0) { + printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return 1; + } + + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + printf("[PASS] fuse_p4_subtype_mount\n"); + return 0; +} diff --git a/user/dadk/config/fuse3_demo.toml b/user/dadk/config/fuse3_demo.toml new file mode 100644 index 0000000000..16b855128d --- /dev/null +++ b/user/dadk/config/fuse3_demo.toml @@ -0,0 +1,36 @@ +# 用户程序名称 +name = "fuse3_demo" +# 版本号 +version = "0.1.0" +# 用户程序描述信息 +description = "libfuse3 static demo and regression test" +# （可选）是否只构建一次，如果为true，DADK会在构建成功后，将构建结果缓存起来，下次构建时，直接使用缓存的构建结果 +build-once = false +# (可选) 是否只安装一次，如果为true，DADK会在安装成功后，不再重复安装 +install-once = false +# 目标架构 +# 可选值："x86_64", "aarch64", "riscv64" +target-arch = ["x86_64"] +# 任务源 +[task-source] +# 构建类型 +# 可选值："build-from_source", "install-from-prebuilt" +type = "build-from-source" +# 构建来源 +# "build_from_source" 可选值："git", "local", "archive" +# "install_from_prebuilt" 可选值："local", "archive" +source = "local" +# 路径或URL +source-path = "user/apps/fuse3_demo" +# 构建相关信息 +[build] +# （可选）构建命令 +build-command = "make install -j8" +# 安装相关信息 +[install] +# （可选）安装到DragonOS的路径 +in-dragonos-path = "/bin" +# 清除相关信息 +[clean] +# （可选）清除命令 +clean-command = "make clean" From c8e240e43d0e43c25322074fad5595f470266c35 Mon Sep 17 00:00:00 2001 From: longjin Date: Mon, 9 Feb 2026 15:57:20 +0800 Subject: [PATCH 07/16] =?UTF-8?q?refactor(fuse):=20=E9=87=8D=E6=9E=84FUSE?= =?UTF-8?q?=E7=A7=81=E6=9C=89=E6=95=B0=E6=8D=AE=E7=BB=93=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 将FUSE私有数据相关结构体移至独立模块 - 统一使用枚举类型FuseFilePrivateData表示所有FUSE文件类型 - 简化代码结构，提高可维护性 Signed-off-by: longjin --- kernel/src/filesystem/fuse/conn.rs | 6 +-- kernel/src/filesystem/fuse/dev.rs | 29 +++++----- kernel/src/filesystem/fuse/fs.rs | 3 +- kernel/src/filesystem/fuse/inode.rs | 63 +++++++++++----------- kernel/src/filesystem/fuse/mod.rs | 1 + kernel/src/filesystem/fuse/private_data.rs | 23 ++++++++ kernel/src/filesystem/vfs/file.rs | 37 ++----------- 7 files changed, 79 insertions(+), 83 deletions(-) create mode 100644 kernel/src/filesystem/fuse/private_data.rs diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs index 559f1ecc44..40ca8bc25b 100644 --- a/kernel/src/filesystem/fuse/conn.rs +++ b/kernel/src/filesystem/fuse/conn.rs @@ -784,10 +784,8 @@ impl FuseConn { capped_max_write ); } - let pages_from_write = core::cmp::max( - 1usize, - capped_max_write.div_ceil(MMArch::PAGE_SIZE), - ) as u16; + let pages_from_write = + core::cmp::max(1usize, capped_max_write.div_ceil(MMArch::PAGE_SIZE)) as u16; let negotiated_max_pages = core::cmp::min(negotiated_max_pages_raw, pages_from_write); { diff --git a/kernel/src/filesystem/fuse/dev.rs b/kernel/src/filesystem/fuse/dev.rs index 42d2c7e8ac..1f8a4b628a 100644 --- a/kernel/src/filesystem/fuse/dev.rs +++ b/kernel/src/filesystem/fuse/dev.rs @@ -12,8 +12,8 @@ use crate::{ devfs::{DevFS, DeviceINode, LockedDevFSInode}, epoll::EPollItem, vfs::{ - file::FileFlags, file::FuseDevPrivateData, vcore::generate_inode_id, FilePrivateData, - FileSystem, FileType, IndexNode, InodeFlags, InodeMode, Metadata, PollableInode, + file::FileFlags, vcore::generate_inode_id, FilePrivateData, FileSystem, FileType, + IndexNode, InodeFlags, InodeMode, Metadata, PollableInode, }, }, libs::mutex::{Mutex, MutexGuard}, @@ -22,7 +22,10 @@ use crate::{ time::PosixTimeSpec, }; -use super::conn::FuseConn; +use super::{ + conn::FuseConn, + private_data::{FuseDevPrivateData, FuseFilePrivateData}, +}; const FUSE_DEV_IOC_CLONE: u32 = 0x8004_4600; // _IOR('F', 0, uint32_t) #[derive(Debug)] @@ -79,7 +82,7 @@ impl DeviceINode for LockedFuseDevInode { impl PollableInode for LockedFuseDevInode { fn poll(&self, private_data: &FilePrivateData) -> Result { - let FilePrivateData::FuseDev(p) = private_data else { + let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = private_data else { return Err(SystemError::EINVAL); }; let conn = p @@ -95,7 +98,7 @@ impl PollableInode for LockedFuseDevInode { epitem: Arc, private_data: &FilePrivateData, ) -> Result<(), SystemError> { - let FilePrivateData::FuseDev(p) = private_data else { + let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = private_data else { return Err(SystemError::EINVAL); }; let conn = p @@ -111,7 +114,7 @@ impl PollableInode for LockedFuseDevInode { epitem: &Arc, private_data: &FilePrivateData, ) -> Result<(), SystemError> { - let FilePrivateData::FuseDev(p) = private_data else { + let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = private_data else { return Err(SystemError::EINVAL); }; let conn = p @@ -136,15 +139,15 @@ impl IndexNode for LockedFuseDevInode { let nonblock = flags.contains(FileFlags::O_NONBLOCK); let conn = FuseConn::new(); let conn_any: Arc = conn; - *data = FilePrivateData::FuseDev(FuseDevPrivateData { + *data = FilePrivateData::Fuse(FuseFilePrivateData::Dev(FuseDevPrivateData { conn: conn_any, nonblock, - }); + })); Ok(()) } fn close(&self, data: MutexGuard) -> Result<(), SystemError> { - if let FilePrivateData::FuseDev(p) = &*data { + if let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = &*data { if let Ok(conn) = p.conn.clone().downcast::() { conn.dev_release(); } @@ -163,7 +166,7 @@ impl IndexNode for LockedFuseDevInode { return Err(SystemError::EINVAL); } let (conn_any, nonblock) = { - let FilePrivateData::FuseDev(p) = &*data else { + let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = &*data else { return Err(SystemError::EINVAL); }; (p.conn.clone(), p.nonblock) @@ -190,7 +193,7 @@ impl IndexNode for LockedFuseDevInode { return Err(SystemError::EINVAL); } let conn_any = { - let FilePrivateData::FuseDev(p) = &*data else { + let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = &*data else { return Err(SystemError::EINVAL); }; p.conn.clone() @@ -267,13 +270,13 @@ impl IndexNode for LockedFuseDevInode { let old_conn = { let guard = old_file.private_data.lock(); - let FilePrivateData::FuseDev(p) = &*guard else { + let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = &*guard else { return Err(SystemError::EINVAL); }; p.conn.clone() }; - let FilePrivateData::FuseDev(p) = &mut *private_data else { + let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = &mut *private_data else { return Err(SystemError::EINVAL); }; let old_fc = old_conn diff --git a/kernel/src/filesystem/fuse/fs.rs b/kernel/src/filesystem/fuse/fs.rs index 5d519c7e70..0c7cf0b542 100644 --- a/kernel/src/filesystem/fuse/fs.rs +++ b/kernel/src/filesystem/fuse/fs.rs @@ -22,6 +22,7 @@ use linkme::distributed_slice; use super::{ conn::FuseConn, inode::FuseNode, + private_data::FuseFilePrivateData, protocol::{fuse_read_struct, FuseStatfsOut, FUSE_ROOT_ID, FUSE_STATFS}, }; @@ -166,7 +167,7 @@ impl MountableFileSystem for FuseFS { let conn = { let pdata = file.private_data.lock(); match &*pdata { - crate::filesystem::vfs::FilePrivateData::FuseDev(p) => p + crate::filesystem::vfs::FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) => p .conn .clone() .downcast::() diff --git a/kernel/src/filesystem/fuse/inode.rs b/kernel/src/filesystem/fuse/inode.rs index d466b4754d..46188455a8 100644 --- a/kernel/src/filesystem/fuse/inode.rs +++ b/kernel/src/filesystem/fuse/inode.rs @@ -12,10 +12,8 @@ use crate::time::timekeep::ktime_get_real_ns; use crate::{ driver::base::device::device_number::DeviceNumber, filesystem::vfs::{ - file::{FileFlags, FuseDirPrivateData, FuseFilePrivateData}, - permission::PermissionMask, - syscall::RenameFlags, - FilePrivateData, FileSystem, FileType, IndexNode, InodeFlags, InodeId, InodeMode, Metadata, + file::FileFlags, permission::PermissionMask, syscall::RenameFlags, FilePrivateData, + FileSystem, FileType, IndexNode, InodeFlags, InodeId, InodeMode, Metadata, }, libs::mutex::{Mutex, MutexGuard}, time::PosixTimeSpec, @@ -24,6 +22,7 @@ use crate::{ use super::{ conn::FuseConn, fs::FuseFS, + private_data::{FuseFilePrivateData, FuseOpenPrivateData}, protocol::{ fuse_pack_struct, fuse_read_struct, FuseAccessIn, FuseAttr, FuseAttrOut, FuseCreateIn, FuseDirent, FuseDirentPlus, FuseEntryOut, FuseFlushIn, FuseFsyncIn, FuseGetattrIn, @@ -211,21 +210,21 @@ impl FuseNode { let conn_any: Arc = self.conn.clone(); match opcode { FUSE_OPEN => { - *data = FilePrivateData::FuseFile(FuseFilePrivateData { + *data = FilePrivateData::Fuse(FuseFilePrivateData::File(FuseOpenPrivateData { conn: conn_any, fh: 0, open_flags: flags.bits(), no_open: true, - }); + })); return Ok(()); } FUSE_OPENDIR => { - *data = FilePrivateData::FuseDir(FuseDirPrivateData { + *data = FilePrivateData::Fuse(FuseFilePrivateData::Dir(FuseOpenPrivateData { conn: conn_any, fh: 0, open_flags: flags.bits(), no_open: true, - }); + })); return Ok(()); } _ => return Err(SystemError::EINVAL), @@ -246,21 +245,23 @@ impl FuseNode { let conn_any: Arc = self.conn.clone(); match opcode { FUSE_OPEN => { - *data = FilePrivateData::FuseFile(FuseFilePrivateData { - conn: conn_any, - fh: 0, - open_flags: open_in.flags, - no_open: true, - }); + *data = + FilePrivateData::Fuse(FuseFilePrivateData::File(FuseOpenPrivateData { + conn: conn_any, + fh: 0, + open_flags: open_in.flags, + no_open: true, + })); return Ok(()); } FUSE_OPENDIR => { - *data = FilePrivateData::FuseDir(FuseDirPrivateData { - conn: conn_any, - fh: 0, - open_flags: open_in.flags, - no_open: true, - }); + *data = + FilePrivateData::Fuse(FuseFilePrivateData::Dir(FuseOpenPrivateData { + conn: conn_any, + fh: 0, + open_flags: open_in.flags, + no_open: true, + })); return Ok(()); } _ => return Err(SystemError::EINVAL), @@ -273,20 +274,20 @@ impl FuseNode { let conn_any: Arc = self.conn.clone(); match opcode { FUSE_OPEN => { - *data = FilePrivateData::FuseFile(FuseFilePrivateData { + *data = FilePrivateData::Fuse(FuseFilePrivateData::File(FuseOpenPrivateData { conn: conn_any, fh: out.fh, open_flags: open_in.flags, no_open: false, - }); + })); } FUSE_OPENDIR => { - *data = FilePrivateData::FuseDir(FuseDirPrivateData { + *data = FilePrivateData::Fuse(FuseFilePrivateData::Dir(FuseOpenPrivateData { conn: conn_any, fh: out.fh, open_flags: open_in.flags, no_open: false, - }); + })); } _ => return Err(SystemError::EINVAL), } @@ -346,8 +347,8 @@ impl FuseNode { data: &FilePrivateData, ) -> Result<(), SystemError> { let (opcode, fh, no_open) = match data { - FilePrivateData::FuseFile(p) => (FUSE_FSYNC, p.fh, p.no_open), - FilePrivateData::FuseDir(p) => (FUSE_FSYNCDIR, p.fh, p.no_open), + FilePrivateData::Fuse(FuseFilePrivateData::File(p)) => (FUSE_FSYNC, p.fh, p.no_open), + FilePrivateData::Fuse(FuseFilePrivateData::Dir(p)) => (FUSE_FSYNCDIR, p.fh, p.no_open), _ => return self.fsync_common(datasync), }; @@ -415,7 +416,7 @@ impl IndexNode for FuseNode { fn close(&self, data: MutexGuard) -> Result<(), SystemError> { match &*data { - FilePrivateData::FuseFile(p) => { + FilePrivateData::Fuse(FuseFilePrivateData::File(p)) => { if p.no_open { return Ok(()); } @@ -430,7 +431,7 @@ impl IndexNode for FuseNode { .request(FUSE_FLUSH, self.nodeid, fuse_pack_struct(&flush_in)); self.release_common(FUSE_RELEASE, p.fh, p.open_flags) } - FilePrivateData::FuseDir(p) => { + FilePrivateData::Fuse(FuseFilePrivateData::Dir(p)) => { if p.no_open { Ok(()) } else { @@ -462,7 +463,7 @@ impl IndexNode for FuseNode { return Ok(n); } self.ensure_regular()?; - let FilePrivateData::FuseFile(p) = &*data else { + let FilePrivateData::Fuse(FuseFilePrivateData::File(p)) = &*data else { return Err(SystemError::EBADF); }; let read_in = FuseReadIn { @@ -493,7 +494,7 @@ impl IndexNode for FuseNode { if buf.len() < len { return Err(SystemError::EINVAL); } - let FilePrivateData::FuseFile(p) = &*data else { + let FilePrivateData::Fuse(FuseFilePrivateData::File(p)) = &*data else { return Err(SystemError::EBADF); }; let max_write = self.conn().max_write(); @@ -654,7 +655,7 @@ impl IndexNode for FuseNode { let mut pdata = FilePrivateData::Unused; let flags = FileFlags::O_RDONLY; self.open_common(FUSE_OPENDIR, &mut pdata, &flags)?; - let FilePrivateData::FuseDir(dir_p) = &pdata else { + let FilePrivateData::Fuse(FuseFilePrivateData::Dir(dir_p)) = &pdata else { return Err(SystemError::EINVAL); }; let fh = dir_p.fh; diff --git a/kernel/src/filesystem/fuse/mod.rs b/kernel/src/filesystem/fuse/mod.rs index 9d87679c80..26e7dc3589 100644 --- a/kernel/src/filesystem/fuse/mod.rs +++ b/kernel/src/filesystem/fuse/mod.rs @@ -2,4 +2,5 @@ pub mod conn; pub mod dev; pub mod fs; pub mod inode; +pub mod private_data; pub mod protocol; diff --git a/kernel/src/filesystem/fuse/private_data.rs b/kernel/src/filesystem/fuse/private_data.rs new file mode 100644 index 0000000000..35ebcfea04 --- /dev/null +++ b/kernel/src/filesystem/fuse/private_data.rs @@ -0,0 +1,23 @@ +use alloc::sync::Arc; +use core::any::Any; + +#[derive(Debug, Clone)] +pub struct FuseDevPrivateData { + pub conn: Arc, + pub nonblock: bool, +} + +#[derive(Debug, Clone)] +pub struct FuseOpenPrivateData { + pub conn: Arc, + pub fh: u64, + pub open_flags: u32, + pub no_open: bool, +} + +#[derive(Debug, Clone)] +pub enum FuseFilePrivateData { + Dev(FuseDevPrivateData), + File(FuseOpenPrivateData), + Dir(FuseOpenPrivateData), +} diff --git a/kernel/src/filesystem/vfs/file.rs b/kernel/src/filesystem/vfs/file.rs index 6743faee15..7825471e43 100644 --- a/kernel/src/filesystem/vfs/file.rs +++ b/kernel/src/filesystem/vfs/file.rs @@ -1,5 +1,4 @@ use core::{ - any::Any, fmt, sync::atomic::{AtomicBool, AtomicUsize, Ordering}, }; @@ -22,6 +21,7 @@ use crate::{ }, filesystem::{ epoll::{event_poll::EPollPrivateData, EPollItem}, + fuse::private_data::FuseFilePrivateData, procfs::ProcfsFilePrivateData, vfs::FilldirContext, }, @@ -127,43 +127,12 @@ pub enum FilePrivateData { Namespace(NamespaceFilePrivateData), /// Socket file created by socket syscalls (not by VFS open(2)). SocketCreate, - /// /dev/fuse file private data (stores an opaque connection object). - FuseDev(FuseDevPrivateData), - /// FUSE regular file private data (stores fh/open flags). - FuseFile(FuseFilePrivateData), - /// FUSE directory private data (stores fh/open flags). - FuseDir(FuseDirPrivateData), + /// FUSE file private data. + Fuse(FuseFilePrivateData), /// 不需要文件私有信息 Unused, } -/// Private data for `/dev/fuse`. -/// -/// Note: to avoid cyclic dependencies between `vfs` and `filesystem::fuse`, -/// the connection object is stored as an opaque `Arc`, -/// and is downcasted by the FUSE implementation as needed. -#[derive(Debug, Clone)] -pub struct FuseDevPrivateData { - pub conn: Arc, - pub nonblock: bool, -} - -#[derive(Debug, Clone)] -pub struct FuseFilePrivateData { - pub conn: Arc, - pub fh: u64, - pub open_flags: u32, - pub no_open: bool, -} - -#[derive(Debug, Clone)] -pub struct FuseDirPrivateData { - pub conn: Arc, - pub fh: u64, - pub open_flags: u32, - pub no_open: bool, -} - impl Default for FilePrivateData { fn default() -> Self { return Self::Unused; From 366931d69f7ee8936bb4599d7071408ec0bdc814 Mon Sep 17 00:00:00 2001 From: longjin Date: Mon, 9 Feb 2026 18:03:22 +0800 Subject: [PATCH 08/16] refactor(fuse): streamline request handling and connection management - Introduced `FuseRequestCred` struct to encapsulate user credentials for FUSE requests. - Refactored request building and handling methods to improve code clarity and reduce redundancy. - Updated `FuseDevPrivateData` to provide a safer way to obtain a reference to `FuseConn`. - Simplified connection reference retrieval in `LockedFuseDevInode` implementations. Signed-off-by: longjin --- kernel/src/filesystem/fuse/conn.rs | 89 ++++++++----- kernel/src/filesystem/fuse/dev.rs | 25 ++-- kernel/src/filesystem/fuse/inode.rs | 148 ++++++++------------- kernel/src/filesystem/fuse/private_data.rs | 17 +++ 4 files changed, 137 insertions(+), 142 deletions(-) diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs index 40ca8bc25b..9ddef17f90 100644 --- a/kernel/src/filesystem/fuse/conn.rs +++ b/kernel/src/filesystem/fuse/conn.rs @@ -36,6 +36,13 @@ pub struct FuseRequest { pub bytes: Vec, } +#[derive(Debug, Clone, Copy)] +struct FuseRequestCred { + uid: u32, + gid: u32, + pid: u32, +} + #[derive(Debug)] pub struct FusePendingState { unique: u64, @@ -608,36 +615,18 @@ impl FuseConn { fn enqueue_noreply(&self, opcode: u32, nodeid: u64, payload: &[u8]) -> Result<(), SystemError> { let unique = self.alloc_unique(); - let hdr = FuseInHeader { - len: (core::mem::size_of::() + payload.len()) as u32, - opcode, + let req = self.build_request( unique, + opcode, nodeid, - uid: 0, - gid: 0, - pid: 0, - total_extlen: 0, - padding: 0, - }; - - let mut bytes = Vec::with_capacity(hdr.len as usize); - bytes.extend_from_slice(fuse_pack_struct(&hdr)); - bytes.extend_from_slice(payload); - let req = Arc::new(FuseRequest { bytes }); - - { - let mut g = self.inner.lock(); - if !g.connected { - return Err(SystemError::ENOTCONN); - } - g.pending.push_back(req); - } - - self.read_wait.wakeup(None); - let _ = EventPoll::wakeup_epoll( - &self.epitems, - EPollEventType::EPOLLIN | EPollEventType::EPOLLRDNORM, + payload, + FuseRequestCred { + uid: 0, + gid: 0, + pid: 0, + }, ); + self.push_request(req, None, unique)?; Ok(()) } @@ -655,15 +644,38 @@ impl FuseConn { return Err(SystemError::EACCES); } let pid = pcb.task_tgid_vnr().map(|p| p.data() as u32).unwrap_or(0); + let pending_state = Arc::new(FusePendingState::new(unique, opcode)); + let req = self.build_request( + unique, + opcode, + nodeid, + payload, + FuseRequestCred { + uid: cred.fsuid.data() as u32, + gid: cred.fsgid.data() as u32, + pid, + }, + ); + self.push_request(req, Some(pending_state.clone()), unique)?; + Ok(pending_state) + } + fn build_request( + &self, + unique: u64, + opcode: u32, + nodeid: u64, + payload: &[u8], + req_cred: FuseRequestCred, + ) -> Arc { let hdr = FuseInHeader { len: (core::mem::size_of::() + payload.len()) as u32, opcode, unique, nodeid, - uid: cred.fsuid.data() as u32, - gid: cred.fsgid.data() as u32, - pid, + uid: req_cred.uid, + gid: req_cred.gid, + pid: req_cred.pid, total_extlen: 0, padding: 0, }; @@ -671,17 +683,24 @@ impl FuseConn { let mut bytes = Vec::with_capacity(hdr.len as usize); bytes.extend_from_slice(fuse_pack_struct(&hdr)); bytes.extend_from_slice(payload); + Arc::new(FuseRequest { bytes }) + } - let req = Arc::new(FuseRequest { bytes }); - let pending_state = Arc::new(FusePendingState::new(unique, opcode)); - + fn push_request( + &self, + req: Arc, + pending_state: Option>, + unique: u64, + ) -> Result<(), SystemError> { { let mut g = self.inner.lock(); if !g.connected { return Err(SystemError::ENOTCONN); } g.pending.push_back(req); - g.processing.insert(unique, pending_state.clone()); + if let Some(pending) = pending_state { + g.processing.insert(unique, pending); + } } self.read_wait.wakeup(None); @@ -689,7 +708,7 @@ impl FuseConn { &self.epitems, EPollEventType::EPOLLIN | EPollEventType::EPOLLRDNORM, ); - Ok(pending_state) + Ok(()) } pub fn write_reply(&self, data: &[u8]) -> Result { diff --git a/kernel/src/filesystem/fuse/dev.rs b/kernel/src/filesystem/fuse/dev.rs index 1f8a4b628a..988e5ea491 100644 --- a/kernel/src/filesystem/fuse/dev.rs +++ b/kernel/src/filesystem/fuse/dev.rs @@ -85,11 +85,7 @@ impl PollableInode for LockedFuseDevInode { let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = private_data else { return Err(SystemError::EINVAL); }; - let conn = p - .conn - .clone() - .downcast::() - .map_err(|_| SystemError::EINVAL)?; + let conn = p.conn_ref()?; Ok(conn.poll().bits() as usize) } @@ -101,11 +97,7 @@ impl PollableInode for LockedFuseDevInode { let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = private_data else { return Err(SystemError::EINVAL); }; - let conn = p - .conn - .clone() - .downcast::() - .map_err(|_| SystemError::EINVAL)?; + let conn = p.conn_ref()?; conn.add_epitem(epitem) } @@ -117,11 +109,7 @@ impl PollableInode for LockedFuseDevInode { let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = private_data else { return Err(SystemError::EINVAL); }; - let conn = p - .conn - .clone() - .downcast::() - .map_err(|_| SystemError::EINVAL)?; + let conn = p.conn_ref()?; conn.remove_epitem(epitem) } } @@ -148,7 +136,7 @@ impl IndexNode for LockedFuseDevInode { fn close(&self, data: MutexGuard) -> Result<(), SystemError> { if let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = &*data { - if let Ok(conn) = p.conn.clone().downcast::() { + if let Ok(conn) = p.conn_ref() { conn.dev_release(); } } @@ -270,7 +258,10 @@ impl IndexNode for LockedFuseDevInode { let old_conn = { let guard = old_file.private_data.lock(); - let FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) = &*guard else { + let FilePrivateData::Fuse(fuse_data) = &*guard else { + return Err(SystemError::EINVAL); + }; + let FuseFilePrivateData::Dev(p) = fuse_data else { return Err(SystemError::EINVAL); }; p.conn.clone() diff --git a/kernel/src/filesystem/fuse/inode.rs b/kernel/src/filesystem/fuse/inode.rs index 46188455a8..cc5f2c54fd 100644 --- a/kernel/src/filesystem/fuse/inode.rs +++ b/kernel/src/filesystem/fuse/inode.rs @@ -125,10 +125,59 @@ impl FuseNode { } fn request_name(&self, opcode: u32, nodeid: u64, name: &str) -> Result, SystemError> { + let payload = Self::pack_name_payload(name); + self.conn().request(opcode, nodeid, &payload) + } + + fn pack_name_payload(name: &str) -> Vec { let mut payload = Vec::with_capacity(name.len() + 1); payload.extend_from_slice(name.as_bytes()); payload.push(0); - self.conn().request(opcode, nodeid, &payload) + payload + } + + fn pack_struct_and_name_payload(inarg: &T, name: &str) -> Vec { + let mut payload = Vec::with_capacity(size_of::() + name.len() + 1); + payload.extend_from_slice(fuse_pack_struct(inarg)); + payload.extend_from_slice(name.as_bytes()); + payload.push(0); + payload + } + + fn pack_two_names_payload(first: &str, second: &str) -> Vec { + let mut payload = Vec::with_capacity(first.len() + second.len() + 2); + payload.extend_from_slice(first.as_bytes()); + payload.push(0); + payload.extend_from_slice(second.as_bytes()); + payload.push(0); + payload + } + + fn set_open_private_data( + &self, + data: &mut FilePrivateData, + opcode: u32, + fh: u64, + open_flags: u32, + no_open: bool, + ) -> Result<(), SystemError> { + let conn_any: Arc = self.conn.clone(); + *data = match opcode { + FUSE_OPEN => FilePrivateData::Fuse(FuseFilePrivateData::File(FuseOpenPrivateData { + conn: conn_any, + fh, + open_flags, + no_open, + })), + FUSE_OPENDIR => FilePrivateData::Fuse(FuseFilePrivateData::Dir(FuseOpenPrivateData { + conn: conn_any, + fh, + open_flags, + no_open, + })), + _ => return Err(SystemError::EINVAL), + }; + Ok(()) } fn attr_to_metadata(attr: &FuseAttr) -> Metadata { @@ -207,28 +256,7 @@ impl FuseNode { flags: &FileFlags, ) -> Result<(), SystemError> { if self.conn.should_skip_open(opcode) { - let conn_any: Arc = self.conn.clone(); - match opcode { - FUSE_OPEN => { - *data = FilePrivateData::Fuse(FuseFilePrivateData::File(FuseOpenPrivateData { - conn: conn_any, - fh: 0, - open_flags: flags.bits(), - no_open: true, - })); - return Ok(()); - } - FUSE_OPENDIR => { - *data = FilePrivateData::Fuse(FuseFilePrivateData::Dir(FuseOpenPrivateData { - conn: conn_any, - fh: 0, - open_flags: flags.bits(), - no_open: true, - })); - return Ok(()); - } - _ => return Err(SystemError::EINVAL), - } + return self.set_open_private_data(data, opcode, 0, flags.bits(), true); } let open_in = FuseOpenIn { @@ -242,56 +270,12 @@ impl FuseNode { Ok(v) => v, Err(SystemError::ENOSYS) if self.conn.open_enosys_is_supported(opcode) => { self.conn.mark_no_open(opcode); - let conn_any: Arc = self.conn.clone(); - match opcode { - FUSE_OPEN => { - *data = - FilePrivateData::Fuse(FuseFilePrivateData::File(FuseOpenPrivateData { - conn: conn_any, - fh: 0, - open_flags: open_in.flags, - no_open: true, - })); - return Ok(()); - } - FUSE_OPENDIR => { - *data = - FilePrivateData::Fuse(FuseFilePrivateData::Dir(FuseOpenPrivateData { - conn: conn_any, - fh: 0, - open_flags: open_in.flags, - no_open: true, - })); - return Ok(()); - } - _ => return Err(SystemError::EINVAL), - } + return self.set_open_private_data(data, opcode, 0, open_in.flags, true); } Err(e) => return Err(e), }; let out: FuseOpenOut = fuse_read_struct(&payload)?; - - let conn_any: Arc = self.conn.clone(); - match opcode { - FUSE_OPEN => { - *data = FilePrivateData::Fuse(FuseFilePrivateData::File(FuseOpenPrivateData { - conn: conn_any, - fh: out.fh, - open_flags: open_in.flags, - no_open: false, - })); - } - FUSE_OPENDIR => { - *data = FilePrivateData::Fuse(FuseFilePrivateData::Dir(FuseOpenPrivateData { - conn: conn_any, - fh: out.fh, - open_flags: open_in.flags, - no_open: false, - })); - } - _ => return Err(SystemError::EINVAL), - } - Ok(()) + self.set_open_private_data(data, opcode, out.fh, open_in.flags, false) } fn release_common(&self, opcode: u32, fh: u64, open_flags: u32) -> Result<(), SystemError> { @@ -828,10 +812,7 @@ impl IndexNode for FuseNode { umask: 0, open_flags: 0, }; - let mut payload_in = Vec::with_capacity(size_of::() + name.len() + 1); - payload_in.extend_from_slice(fuse_pack_struct(&inarg)); - payload_in.extend_from_slice(name.as_bytes()); - payload_in.push(0); + let payload_in = Self::pack_struct_and_name_payload(&inarg, name); let payload = match self.conn().request(FUSE_CREATE, self.nodeid, &payload_in) { Ok(v) => v, @@ -857,10 +838,7 @@ impl IndexNode for FuseNode { mode: (InodeMode::S_IFDIR | mode).bits(), umask: 0, }; - let mut payload_in = Vec::with_capacity(size_of::() + name.len() + 1); - payload_in.extend_from_slice(fuse_pack_struct(&inarg)); - payload_in.extend_from_slice(name.as_bytes()); - payload_in.push(0); + let payload_in = Self::pack_struct_and_name_payload(&inarg, name); let payload = self.conn().request(FUSE_MKDIR, self.nodeid, &payload_in)?; let entry: FuseEntryOut = fuse_read_struct(&payload)?; self.create_node_from_entry(&entry) @@ -872,10 +850,7 @@ impl IndexNode for FuseNode { umask: 0, padding: 0, }; - let mut payload_in = Vec::with_capacity(size_of::() + name.len() + 1); - payload_in.extend_from_slice(fuse_pack_struct(&inarg)); - payload_in.extend_from_slice(name.as_bytes()); - payload_in.push(0); + let payload_in = Self::pack_struct_and_name_payload(&inarg, name); let payload = self.conn().request(FUSE_MKNOD, self.nodeid, &payload_in)?; let entry: FuseEntryOut = fuse_read_struct(&payload)?; self.create_node_from_entry(&entry) @@ -897,11 +872,7 @@ impl IndexNode for FuseNode { fn symlink(&self, name: &str, target: &str) -> Result, SystemError> { self.ensure_dir()?; - let mut payload_in = Vec::with_capacity(target.len() + name.len() + 2); - payload_in.extend_from_slice(target.as_bytes()); - payload_in.push(0); - payload_in.extend_from_slice(name.as_bytes()); - payload_in.push(0); + let payload_in = Self::pack_two_names_payload(target, name); let payload = self .conn() .request(FUSE_SYMLINK, self.nodeid, &payload_in)?; @@ -918,10 +889,7 @@ impl IndexNode for FuseNode { let inarg = FuseLinkIn { oldnodeid: target.nodeid, }; - let mut payload_in = Vec::with_capacity(size_of::() + name.len() + 1); - payload_in.extend_from_slice(fuse_pack_struct(&inarg)); - payload_in.extend_from_slice(name.as_bytes()); - payload_in.push(0); + let payload_in = Self::pack_struct_and_name_payload(&inarg, name); let payload = self.conn().request(FUSE_LINK, self.nodeid, &payload_in)?; let _entry: FuseEntryOut = fuse_read_struct(&payload)?; Ok(()) diff --git a/kernel/src/filesystem/fuse/private_data.rs b/kernel/src/filesystem/fuse/private_data.rs index 35ebcfea04..b43fd3001a 100644 --- a/kernel/src/filesystem/fuse/private_data.rs +++ b/kernel/src/filesystem/fuse/private_data.rs @@ -1,5 +1,8 @@ use alloc::sync::Arc; use core::any::Any; +use system_error::SystemError; + +use super::conn::FuseConn; #[derive(Debug, Clone)] pub struct FuseDevPrivateData { @@ -7,6 +10,12 @@ pub struct FuseDevPrivateData { pub nonblock: bool, } +impl FuseDevPrivateData { + pub fn conn_ref(&self) -> Result, SystemError> { + downcast_conn(&self.conn) + } +} + #[derive(Debug, Clone)] pub struct FuseOpenPrivateData { pub conn: Arc, @@ -21,3 +30,11 @@ pub enum FuseFilePrivateData { File(FuseOpenPrivateData), Dir(FuseOpenPrivateData), } + +#[inline] +fn downcast_conn(conn_any: &Arc) -> Result, SystemError> { + conn_any + .clone() + .downcast::() + .map_err(|_| SystemError::EINVAL) +} From 607e0b7b83370ef3fc0ce80f9f926291ee8f3fea Mon Sep 17 00:00:00 2001 From: longjin Date: Mon, 9 Feb 2026 18:35:52 +0800 Subject: [PATCH 09/16] feat(fuse): enhance request handling and directory entry parsing - Added non-blocking and blocking methods for popping pending requests in `FuseConn`. - Introduced alignment for directory entry records in `FuseNode` to ensure proper memory alignment. - Implemented methods for parsing directory entries in `FuseNode`, improving the handling of readdir and readdirplus payloads. - Added a new script `run_all_test_fuse.sh` for executing and summarizing test results for FUSE applications. Signed-off-by: longjin --- kernel/src/filesystem/fuse/conn.rs | 76 +++++++----- kernel/src/filesystem/fuse/inode.rs | 150 +++++++++++++---------- user/apps/fuse_demo/Makefile | 1 + user/apps/fuse_demo/run_all_test_fuse.sh | 59 +++++++++ 4 files changed, 190 insertions(+), 96 deletions(-) create mode 100755 user/apps/fuse_demo/run_all_test_fuse.sh diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs index 9ddef17f90..7ccb55f92d 100644 --- a/kernel/src/filesystem/fuse/conn.rs +++ b/kernel/src/filesystem/fuse/conn.rs @@ -480,6 +480,46 @@ impl FuseConn { Self::calc_min_read_buffer(g.init.max_write as usize) } + fn pop_pending_nonblock(&self) -> Result, SystemError> { + let mut g = self.inner.lock(); + if !g.connected { + return Err(SystemError::ENOTCONN); + } + g.pending + .pop_front() + .ok_or(SystemError::EAGAIN_OR_EWOULDBLOCK) + } + + fn pop_pending_blocking(&self) -> Result, SystemError> { + loop { + let mut g = self.inner.lock(); + if !g.connected { + return Err(SystemError::ENOTCONN); + } + if let Some(req) = g.pending.pop_front() { + return Ok(req); + } + + let (waiter, waker) = Waiter::new_pair(); + self.read_wait.register_waker(waker.clone())?; + + if !g.connected { + self.read_wait.remove_waker(&waker); + return Err(SystemError::ENOTCONN); + } + if let Some(req) = g.pending.pop_front() { + self.read_wait.remove_waker(&waker); + return Ok(req); + } + drop(g); + + if let Err(e) = waiter.wait(true) { + self.read_wait.remove_waker(&waker); + return Err(e); + } + } + } + pub fn read_request(&self, nonblock: bool, out: &mut [u8]) -> Result { // Linux: require a sane minimum read buffer for all reads. let min_read = self.min_read_buffer(); @@ -495,41 +535,9 @@ impl FuseConn { // Linux: if O_NONBLOCK and no pending request, return EAGAIN. let req = if nonblock { - let mut g = self.inner.lock(); - if !g.connected { - return Err(SystemError::ENOTCONN); - } - g.pending - .pop_front() - .ok_or(SystemError::EAGAIN_OR_EWOULDBLOCK)? + self.pop_pending_nonblock()? } else { - loop { - let mut g = self.inner.lock(); - if !g.connected { - return Err(SystemError::ENOTCONN); - } - if let Some(req) = g.pending.pop_front() { - break req; - } - - let (waiter, waker) = Waiter::new_pair(); - self.read_wait.register_waker(waker.clone())?; - - if !g.connected { - self.read_wait.remove_waker(&waker); - return Err(SystemError::ENOTCONN); - } - if let Some(req) = g.pending.pop_front() { - self.read_wait.remove_waker(&waker); - break req; - } - drop(g); - - if let Err(e) = waiter.wait(true) { - self.read_wait.remove_waker(&waker); - return Err(e); - } - } + self.pop_pending_blocking()? }; if out.len() < req.bytes.len() { diff --git a/kernel/src/filesystem/fuse/inode.rs b/kernel/src/filesystem/fuse/inode.rs index cc5f2c54fd..19b1513e1e 100644 --- a/kernel/src/filesystem/fuse/inode.rs +++ b/kernel/src/filesystem/fuse/inode.rs @@ -49,6 +49,8 @@ pub struct FuseNode { } impl FuseNode { + const FUSE_DIRENT_ALIGN: usize = 8; + pub fn new( fs: Weak, conn: Arc, @@ -180,6 +182,90 @@ impl FuseNode { Ok(()) } + fn align_dirent_record_len(base_len: usize) -> usize { + (base_len + Self::FUSE_DIRENT_ALIGN - 1) & !(Self::FUSE_DIRENT_ALIGN - 1) + } + + fn cache_child_from_entry(&self, entry: &FuseEntryOut) { + if entry.nodeid == 0 { + return; + } + if let Some(fs) = self.fs.upgrade() { + let md = Self::attr_to_metadata(&entry.attr); + let child = fs.get_or_create_node(entry.nodeid, self.nodeid, Some(md.clone())); + child.inc_lookup(1); + child.set_cached_metadata_with_valid(md, entry.attr_valid, entry.attr_valid_nsec); + } + } + + fn parse_readdirplus_payload( + &self, + payload: &[u8], + names: &mut Vec, + mut last_off: u64, + ) -> Result { + let mut pos: usize = 0; + while pos + size_of::() <= payload.len() { + let plus: FuseDirentPlus = fuse_read_struct(&payload[pos..])?; + let dirent = plus.dirent; + let name_start = pos + size_of::(); + let name_end = name_start + dirent.namelen as usize; + if name_end > payload.len() { + break; + } + + let name_bytes = &payload[name_start..name_end]; + if let Ok(name) = core::str::from_utf8(name_bytes) { + if !name.is_empty() && name != "." && name != ".." { + names.push(name.to_string()); + self.cache_child_from_entry(&plus.entry_out); + } + } + + last_off = dirent.off; + let rec_len = Self::align_dirent_record_len( + size_of::() + dirent.namelen as usize, + ); + if rec_len == 0 { + break; + } + pos = pos.saturating_add(rec_len); + } + Ok(last_off) + } + + fn parse_readdir_payload( + payload: &[u8], + names: &mut Vec, + mut last_off: u64, + ) -> Result { + let mut pos: usize = 0; + while pos + size_of::() <= payload.len() { + let dirent: FuseDirent = fuse_read_struct(&payload[pos..])?; + let name_start = pos + size_of::(); + let name_end = name_start + dirent.namelen as usize; + if name_end > payload.len() { + break; + } + + let name_bytes = &payload[name_start..name_end]; + if let Ok(name) = core::str::from_utf8(name_bytes) { + if !name.is_empty() && name != "." && name != ".." { + names.push(name.to_string()); + } + } + + last_off = dirent.off; + let rec_len = + Self::align_dirent_record_len(size_of::() + dirent.namelen as usize); + if rec_len == 0 { + break; + } + pos = pos.saturating_add(rec_len); + } + Ok(last_off) + } + fn attr_to_metadata(attr: &FuseAttr) -> Metadata { let mode = InodeMode::from_bits_truncate(attr.mode); let ifmt = mode.bits() & InodeMode::S_IFMT.bits(); @@ -680,71 +766,11 @@ impl IndexNode for FuseNode { break; } - let mut pos: usize = 0; let mut last_off: u64 = offset; if use_readdirplus { - while pos + size_of::() <= payload.len() { - let plus: FuseDirentPlus = fuse_read_struct(&payload[pos..])?; - let dirent = plus.dirent; - let name_start = pos + size_of::(); - let name_end = name_start + dirent.namelen as usize; - if name_end > payload.len() { - break; - } - let name_bytes = &payload[name_start..name_end]; - if let Ok(name) = core::str::from_utf8(name_bytes) { - if !name.is_empty() && name != "." && name != ".." { - names.push(name.to_string()); - if plus.entry_out.nodeid != 0 { - if let Some(fs) = self.fs.upgrade() { - let md = Self::attr_to_metadata(&plus.entry_out.attr); - let child = fs.get_or_create_node( - plus.entry_out.nodeid, - self.nodeid, - Some(md), - ); - child.inc_lookup(1); - child.set_cached_metadata_with_valid( - Self::attr_to_metadata(&plus.entry_out.attr), - plus.entry_out.attr_valid, - plus.entry_out.attr_valid_nsec, - ); - } - } - } - } - - last_off = dirent.off; - let rec_len_unaligned = size_of::() + dirent.namelen as usize; - let rec_len = (rec_len_unaligned + 8 - 1) & !(8 - 1); - if rec_len == 0 { - break; - } - pos = pos.saturating_add(rec_len); - } + last_off = self.parse_readdirplus_payload(&payload, &mut names, last_off)?; } else { - while pos + size_of::() <= payload.len() { - let dirent: FuseDirent = fuse_read_struct(&payload[pos..])?; - let name_start = pos + size_of::(); - let name_end = name_start + dirent.namelen as usize; - if name_end > payload.len() { - break; - } - let name_bytes = &payload[name_start..name_end]; - if let Ok(name) = core::str::from_utf8(name_bytes) { - if !name.is_empty() && name != "." && name != ".." { - names.push(name.to_string()); - } - } - - last_off = dirent.off; - let rec_len_unaligned = size_of::() + dirent.namelen as usize; - let rec_len = (rec_len_unaligned + 8 - 1) & !(8 - 1); - if rec_len == 0 { - break; - } - pos = pos.saturating_add(rec_len); - } + last_off = Self::parse_readdir_payload(&payload, &mut names, last_off)?; } if last_off == offset { diff --git a/user/apps/fuse_demo/Makefile b/user/apps/fuse_demo/Makefile index cef89a59af..2133f86aa8 100644 --- a/user/apps/fuse_demo/Makefile +++ b/user/apps/fuse_demo/Makefile @@ -20,6 +20,7 @@ all: $(BINS) install: all @echo "Installing binaries to $(DADK_CURRENT_BUILD_DIR)/" mv $(BINS) $(DADK_CURRENT_BUILD_DIR)/ + cp run_all_test_fuse.sh $(DADK_CURRENT_BUILD_DIR)/ clean: rm -f $(BINS) diff --git a/user/apps/fuse_demo/run_all_test_fuse.sh b/user/apps/fuse_demo/run_all_test_fuse.sh new file mode 100755 index 0000000000..974e08da1d --- /dev/null +++ b/user/apps/fuse_demo/run_all_test_fuse.sh @@ -0,0 +1,59 @@ +#!/bin/busybox sh +set -u + +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd) +cd "$SCRIPT_DIR" || exit 1 + +if [ ! -e /dev/fuse ]; then + echo "[WARN] /dev/fuse 不存在，测试大概率会失败。" +fi + +pass=0 +fail=0 +total=0 +failed_tests="" +found_any=0 + +for t in ./test_fuse_*; do + if [ ! -e "$t" ]; then + continue + fi + if [ ! -x "$t" ]; then + continue + fi + + found_any=1 + total=$((total + 1)) + name=$(basename "$t") + + echo "===== RUN ${name} =====" + "$t" + rc=$? + if [ "$rc" -eq 0 ]; then + echo "===== PASS ${name} =====" + pass=$((pass + 1)) + else + echo "===== FAIL ${name} (rc=${rc}) =====" + fail=$((fail + 1)) + failed_tests="${failed_tests}\n - ${name}(rc=${rc})" + fi + echo +done + +if [ "$found_any" -eq 0 ]; then + echo "[ERROR] 当前目录未找到可执行的 test_fuse_*" + exit 1 +fi + +echo "===== SUMMARY =====" +echo "TOTAL: ${total}" +echo "PASS: ${pass}" +echo "FAIL: ${fail}" + +if [ "$fail" -ne 0 ]; then + echo "FAILED TESTS:" + printf "%b\n" "$failed_tests" + exit 1 +fi + +echo "ALL test_fuse_* PASSED" From 5414b5375f5426bd4cf75121e54300181b76100d Mon Sep 17 00:00:00 2001 From: longjin Date: Mon, 9 Feb 2026 18:37:50 +0800 Subject: [PATCH 10/16] refactor(fuse): simplify request waiting logic and enhance option parsing - Introduced a new `wait_with_recheck` function to streamline the waiting mechanism for requests in `FuseConn`, reducing code duplication. - Refactored the `wait_complete`, `wait_initialized`, and `pop_pending_blocking` methods to utilize the new waiting function. - Added utility methods in `FuseFS` for parsing optional integer and boolean values from strings, improving the clarity of mount option handling. Signed-off-by: longjin --- kernel/src/filesystem/fuse/conn.rs | 104 ++++++++++------------------- kernel/src/filesystem/fuse/fs.rs | 36 +++++++--- 2 files changed, 61 insertions(+), 79 deletions(-) diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs index 7ccb55f92d..35c53dd2c8 100644 --- a/kernel/src/filesystem/fuse/conn.rs +++ b/kernel/src/filesystem/fuse/conn.rs @@ -31,6 +31,30 @@ use super::protocol::{ FUSE_POSIX_ACL, FUSE_POSIX_LOCKS, FUSE_READDIRPLUS_AUTO, FUSE_WRITEBACK_CACHE, }; +fn wait_with_recheck(waitq: &WaitQueue, mut check: F) -> Result +where + F: FnMut() -> Result, SystemError>, +{ + if let Some(v) = check()? { + return Ok(v); + } + + loop { + let (waiter, waker) = Waiter::new_pair(); + waitq.register_waker(waker.clone())?; + + if let Some(v) = check()? { + waitq.remove_waker(&waker); + return Ok(v); + } + + if let Err(e) = waiter.wait(true) { + waitq.remove_waker(&waker); + return Err(e); + } + } +} + #[derive(Debug)] pub struct FuseRequest { pub bytes: Vec, @@ -77,31 +101,13 @@ impl FusePendingState { } pub fn wait_complete(&self) -> Result, SystemError> { - // Avoid TOCTOU between response update and wait queue registration. - if let Some(res) = self.response.lock().take() { - return res; - } - loop { + wait_with_recheck(&self.wait, || { let mut guard = self.response.lock(); if let Some(res) = guard.take() { - return res; + return Ok(Some(res)); } - - let (waiter, waker) = Waiter::new_pair(); - self.wait.register_waker(waker.clone())?; - - // Re-check under the same lock after registering. - if let Some(res) = guard.take() { - self.wait.remove_waker(&waker); - return res; - } - drop(guard); - - if let Err(e) = waiter.wait(true) { - self.wait.remove_waker(&waker); - return Err(e); - } - } + Ok(None) + })? } } @@ -294,37 +300,16 @@ impl FuseConn { } fn wait_initialized(&self) -> Result<(), SystemError> { - if self.is_initialized() { - return Ok(()); - } - // Bind condition checks to inner lock and register waker before releasing it. - loop { + wait_with_recheck(&self.init_wait, || { let g = self.inner.lock(); if !g.connected { return Err(SystemError::ENOTCONN); } if g.initialized { - return Ok(()); + return Ok(Some(())); } - - let (waiter, waker) = Waiter::new_pair(); - self.init_wait.register_waker(waker.clone())?; - - if !g.connected { - self.init_wait.remove_waker(&waker); - return Err(SystemError::ENOTCONN); - } - if g.initialized { - self.init_wait.remove_waker(&waker); - return Ok(()); - } - drop(g); - - if let Err(e) = waiter.wait(true) { - self.init_wait.remove_waker(&waker); - return Err(e); - } - } + Ok(None) + }) } pub fn abort(&self) { @@ -491,33 +476,16 @@ impl FuseConn { } fn pop_pending_blocking(&self) -> Result, SystemError> { - loop { + wait_with_recheck(&self.read_wait, || { let mut g = self.inner.lock(); if !g.connected { return Err(SystemError::ENOTCONN); } if let Some(req) = g.pending.pop_front() { - return Ok(req); - } - - let (waiter, waker) = Waiter::new_pair(); - self.read_wait.register_waker(waker.clone())?; - - if !g.connected { - self.read_wait.remove_waker(&waker); - return Err(SystemError::ENOTCONN); - } - if let Some(req) = g.pending.pop_front() { - self.read_wait.remove_waker(&waker); - return Ok(req); - } - drop(g); - - if let Err(e) = waiter.wait(true) { - self.read_wait.remove_waker(&waker); - return Err(e); + return Ok(Some(req)); } - } + Ok(None) + }) } pub fn read_request(&self, nonblock: bool, out: &mut [u8]) -> Result { diff --git a/kernel/src/filesystem/fuse/fs.rs b/kernel/src/filesystem/fuse/fs.rs index 0c7cf0b542..aaa63c5e49 100644 --- a/kernel/src/filesystem/fuse/fs.rs +++ b/kernel/src/filesystem/fuse/fs.rs @@ -51,6 +51,22 @@ pub struct FuseFS { } impl FuseFS { + fn parse_opt_u32_decimal(v: &str) -> Result { + v.parse::().map_err(|_| SystemError::EINVAL) + } + + fn parse_opt_i32_decimal(v: &str) -> Result { + v.parse::().map_err(|_| SystemError::EINVAL) + } + + fn parse_opt_u32_octal(v: &str) -> Result { + u32::from_str_radix(v, 8).map_err(|_| SystemError::EINVAL) + } + + fn parse_opt_bool_switch(v: &str) -> bool { + v.is_empty() || v != "0" + } + fn parse_mount_options( raw: Option<&str>, ) -> Result<(i32, u32, u32, u32, bool, bool), SystemError> { @@ -73,23 +89,23 @@ impl FuseFS { }; match k { "fd" => { - fd = Some(v.parse::().map_err(|_| SystemError::EINVAL)?); + fd = Some(Self::parse_opt_i32_decimal(v)?); } "rootmode" => { // Linux expects octal representation. - rootmode = Some(u32::from_str_radix(v, 8).map_err(|_| SystemError::EINVAL)?); + rootmode = Some(Self::parse_opt_u32_octal(v)?); } "user_id" => { - user_id = Some(v.parse::().map_err(|_| SystemError::EINVAL)?); + user_id = Some(Self::parse_opt_u32_decimal(v)?); } "group_id" => { - group_id = Some(v.parse::().map_err(|_| SystemError::EINVAL)?); + group_id = Some(Self::parse_opt_u32_decimal(v)?); } "default_permissions" => { - default_permissions = v.is_empty() || v != "0"; + default_permissions = Self::parse_opt_bool_switch(v); } "allow_other" => { - allow_other = v.is_empty() || v != "0"; + allow_other = Self::parse_opt_bool_switch(v); } _ => {} } @@ -167,11 +183,9 @@ impl MountableFileSystem for FuseFS { let conn = { let pdata = file.private_data.lock(); match &*pdata { - crate::filesystem::vfs::FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) => p - .conn - .clone() - .downcast::() - .map_err(|_| SystemError::EINVAL)?, + crate::filesystem::vfs::FilePrivateData::Fuse(FuseFilePrivateData::Dev(p)) => { + p.conn_ref()? + } _ => return Err(SystemError::EINVAL), } }; From 266a4dea7dcea0f48136a93f5ec97d2bcf66a501 Mon Sep 17 00:00:00 2001 From: longjin Date: Wed, 11 Feb 2026 15:33:33 +0800 Subject: [PATCH 11/16] 1 --- user/dadk/config/{ => all}/fuse3_demo.toml | 0 user/dadk/config/{ => all}/fuse_demo.toml | 0 user/dadk/config/sets/default/fuse3_demo.toml | 1 + user/dadk/config/sets/default/fuse_demo.toml | 1 + 4 files changed, 2 insertions(+) rename user/dadk/config/{ => all}/fuse3_demo.toml (100%) rename user/dadk/config/{ => all}/fuse_demo.toml (100%) create mode 120000 user/dadk/config/sets/default/fuse3_demo.toml create mode 120000 user/dadk/config/sets/default/fuse_demo.toml diff --git a/user/dadk/config/fuse3_demo.toml b/user/dadk/config/all/fuse3_demo.toml similarity index 100% rename from user/dadk/config/fuse3_demo.toml rename to user/dadk/config/all/fuse3_demo.toml diff --git a/user/dadk/config/fuse_demo.toml b/user/dadk/config/all/fuse_demo.toml similarity index 100% rename from user/dadk/config/fuse_demo.toml rename to user/dadk/config/all/fuse_demo.toml diff --git a/user/dadk/config/sets/default/fuse3_demo.toml b/user/dadk/config/sets/default/fuse3_demo.toml new file mode 120000 index 0000000000..41167e83ce --- /dev/null +++ b/user/dadk/config/sets/default/fuse3_demo.toml @@ -0,0 +1 @@ +../../all/fuse3_demo.toml \ No newline at end of file diff --git a/user/dadk/config/sets/default/fuse_demo.toml b/user/dadk/config/sets/default/fuse_demo.toml new file mode 120000 index 0000000000..88df73dd60 --- /dev/null +++ b/user/dadk/config/sets/default/fuse_demo.toml @@ -0,0 +1 @@ +../../all/fuse_demo.toml \ No newline at end of file From 2a32185af351a8280da6df3cd40fa94b5eaf58d1 Mon Sep 17 00:00:00 2001 From: longjin Date: Sun, 15 Feb 2026 00:27:27 +0800 Subject: [PATCH 12/16] =?UTF-8?q?=E5=88=A0=E9=99=A4=E8=BF=87=E7=A8=8B?= =?UTF-8?q?=E6=96=87=E6=A1=A3=EF=BC=8C=E6=9B=B4=E6=94=B9=E4=B8=8B=E8=BD=BD?= =?UTF-8?q?=E6=BA=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ROADMAP_FUSE.md | 304 ---------------------------------- TODO_FUSE_FULL_PLAN_CN.md | 118 ------------- TODO_FUSE_PHASE_AB.md | 49 ------ TODO_FUSE_PHASE_CD.md | 52 ------ user/apps/fuse3_demo/Makefile | 2 +- 5 files changed, 1 insertion(+), 524 deletions(-) delete mode 100644 ROADMAP_FUSE.md delete mode 100644 TODO_FUSE_FULL_PLAN_CN.md delete mode 100644 TODO_FUSE_PHASE_AB.md delete mode 100644 TODO_FUSE_PHASE_CD.md diff --git a/ROADMAP_FUSE.md b/ROADMAP_FUSE.md deleted file mode 100644 index 6490bf1506..0000000000 --- a/ROADMAP_FUSE.md +++ /dev/null @@ -1,304 +0,0 @@ -# DragonOS FUSE 支持路线图（对齐 Linux 6.6 语义，分 PR/可测/可演示） - -> 目标：让 DragonOS 具备**可用、可演示**的 FUSE（Filesystem in Userspace）能力，并逐步对齐 Linux 6.6 的行为语义与用户态生态（libfuse/fusermount/sshfs 等）。 -> -> 说明：本文是“路线图”，不是最终设计文档；但每个阶段都给出**必须实现的东西**、**可独立 PR 的拆分**、**可单独测试的点**、以及**最终演示方式**。 - ---- - -## 0. 现状对齐：DragonOS 与 Linux 6.6 的关键实现接口 - -### 0.1 DragonOS 现有能力（与 FUSE 最相关的落点） - -- **挂载框架已具备**：`sys_mount` → `do_mount()` → `produce_fs()` 通过 `FSMAKER` 分发创建文件系统实例（见 `kernel/src/filesystem/vfs/syscall/sys_mount.rs`、`kernel/src/filesystem/vfs/mod.rs`）。 -- **VFS 操作面清晰**：文件系统通过实现 `FileSystem` + `IndexNode` 接入（`kernel/src/filesystem/vfs/mod.rs`）。 -- **devfs 设备节点框架可复用**：/dev 由 devfs 统一管理，内置字符设备在 `DevFS::register_bultinin_device()` 中注册（`kernel/src/filesystem/devfs/mod.rs`）。 -- **阻塞/唤醒与 poll/epoll 已具备基础设施**： - - `WaitQueue` 可用于“读阻塞 / 写唤醒 / 信号打断”（`kernel/src/libs/wait_queue.rs`）。 - - VFS 有 `PollableInode` 抽象与 epoll 集成；`eventfd` 是一个可参考的“伪文件描述符 + wait_queue + epoll item 链表”范例（`kernel/src/filesystem/eventfd.rs`、`kernel/src/filesystem/vfs/mod.rs`）。 -- **权限检查在路径遍历阶段发生**：`IndexNode::do_lookup_follow_symlink()` 会对目录执行权限（search/execute）做校验（`kernel/src/filesystem/vfs/mod.rs`）。这对 FUSE 的 `default_permissions` 语义很关键（后文详述）。 -- **目录读取当前依赖 `IndexNode::list()+find()`**：`File::read_dir()` 首次会缓存 `inode.list()` 的全量目录项名，然后逐个 `inode.find(name)`（`kernel/src/filesystem/vfs/file.rs`）。这与 Linux 的“readdir 流式 + offset”模型有差异，是一个需要在路线图里显式处理的点。 - -### 0.2 Linux 6.6 FUSE 的“最小闭环”关键路径（需要对齐的行为） - -以下为 Linux 6.6 的参考实现位置： - -- 协议与 uapi：`include/uapi/linux/fuse.h`（当前内核版本号 `7.39`，定义了 `FUSE_INIT`、各 opcode、结构体与 feature flags）。 -- /dev/fuse 设备（请求队列、read/write、poll、ioctl clone）：`fs/fuse/dev.c` -- 挂载参数解析与 superblock 建立：`fs/fuse/inode.c` -- 行为语义概述与 mount 选项：`Documentation/filesystems/fuse.rst` - -Linux 的基本闭环如下： - -1. 用户态 daemon `open("/dev/fuse")` 得到 fd； -2. `mount("fuse", target, "fuse", flags, "fd=N,rootmode=...,user_id=...,group_id=...")`； -3. 内核在连接建立后，**向 daemon 发送 `FUSE_INIT` 请求**（daemon read /dev/fuse 得到请求）； -4. daemon write 回 `FUSE_INIT` reply，完成版本/feature 协商； -5. 后续每个 VFS 操作（lookup/getattr/readdir/open/read/write…）转换成一条 FUSE request，daemon 处理后写回 reply，内核把结果映射回 VFS。 - -> 结论：DragonOS 要“有可用东西出来”，必须先做出上述闭环：**/dev/fuse + mount(fd=) + INIT 协商 + 若干核心 opcode**。 - ---- - -## 1. 必须实现的东西（按“能跑起来”到“能用起来”分层） - -为了便于拆 PR/验收，这里把“必须实现”分成三层：MVP（可演示）、可用版（能跑常见 FUSE FS）、生产版（安全/语义/性能接近 Linux）。 - -### 1.1 MVP（可演示、可交付）的“最低必需集” - -目标：实现一个**只依赖 DragonOS 自己的用户态 demo daemon**就能挂载并访问的 FUSE 文件系统（至少能 `ls`/`stat`/`cat`）。 - -MVP 必须具备： - -1) **/dev/fuse 字符设备** -- devfs 中提供 `/dev/fuse`（最好保证路径一致；若 DragonOS 把大多数字符设备放在 `/dev/char/*`，也要给出 `/dev/fuse` 兼容入口：直接节点或符号链接）。 -- 支持： - - `read()`：从内核请求队列取下一条 request（无请求时可阻塞；支持 nonblock 返回 `EAGAIN`）。 - - `write()`：写入 userspace reply，按 `unique` 匹配并唤醒等待该 reply 的内核线程。 - - `poll()/epoll()`：队列非空 → 可读；通常永远可写；断连 → `POLLERR`。 - - `close()`：daemon 退出时触发断连/abort，避免内核永久阻塞。 - -2) **FUSE 连接对象（connection）与请求生命周期** -- 统一的 `FuseConn`：维护 `connected/aborted`、request id（unique）、请求队列、等待队列、以及与挂载点的关联。 -- 请求：`(header + payload)` → 入队 → wake daemon → 内核线程 wait → reply 到达 → 唤醒返回。 -- 信号语义（MVP 允许简化）：至少保证被信号打断时内核不死锁；可以先不实现完整 `FUSE_INTERRUPT`，但要规划后续补齐。 - -3) **挂载：`-t fuse -o fd=...`** -- 新增 `FuseFS` 作为 `FSMAKER` 的一个条目（如 `"fuse"`/`"fuse3"` 选其一或都支持）。 -- `make_mount_data(raw_data)` 解析 `fd=,rootmode=,user_id=,group_id=`，并从当前进程 `fd_table` 获取对应 `File`，校验它确实来自 `/dev/fuse`。 -- mount 成功后：触发或保证 daemon 读 /dev/fuse 时**能收到 `FUSE_INIT` 请求**（建议 mount 时把 INIT request 放入队列）。 - -4) **核心 opcode（覆盖 `ls/stat/cat` 的最小集合）** -- `FUSE_INIT`：版本协商 + feature flags（MVP 可只支持一个较小子集）。 -- `FUSE_LOOKUP`：路径遍历（`IndexNode::find()`）必需。 -- `FUSE_GETATTR`：`stat()`/权限判断/类型判断必需。 -- `FUSE_OPENDIR + FUSE_READDIR + FUSE_RELEASEDIR`：目录 `list()` 必需。 -- `FUSE_OPEN + FUSE_READ + FUSE_RELEASE`：读取文件内容必需。 -- 建议同时包含： - - `FUSE_FORGET`（可先“弱化实现”，至少能减少内核对象泄漏风险）。 - - `FUSE_STATFS`（可先返回固定值，后续再对齐）。 - -5) **权限与路径遍历的最小策略** -- DragonOS 当前在路径遍历时做 `MAY_EXEC` 检查；MVP 为了不被权限卡死，建议： - - demo daemon 返回的目录权限至少 `0555`（或更宽）。 - - 先以 root 演示，降低权限语义复杂度。 -- 但路线图里必须明确：后续要支持 Linux 的 `default_permissions` / `allow_other` / “仅 mount owner 可访问”语义（见 1.2/1.3）。 - -### 1.2 可用版（能跑更多现成 FUSE FS）的必需补齐 - -目标：能跑“更真实”的 FUSE FS（例如更完整的 hello/passthrough 示例，或未来接入 libfuse）。 - -需要补齐： - -- **写路径与创建类操作** - - `FUSE_CREATE`/`MKNOD`/`MKDIR`/`UNLINK`/`RMDIR`/`RENAME`（至少覆盖基础文件增删改名） - - `FUSE_WRITE`/`SETATTR`（truncate/chmod/chown/utimens 等） - - `FUSE_FLUSH`/`FSYNC`/`RELEASE` 的行为对齐（可分阶段） -- **更完整的目录语义** - - `.`/`..`、`nlink`、inode id 稳定性、重名/硬链接等 - - 解决 DragonOS 当前 `list()` 模式与 FUSE `readdir+offset` 的差异：要么在 FUSE inode 内部做“全量拉取+缓存”，要么推动 VFS 抽象升级为“流式 readdir 回调”（推荐长期方向） -- **超时与缓存（attr/dentry cache）** - - Linux FUSE 有属性缓存与超时（由 daemon 返回）；可先实现最小缓存策略，否则会导致性能与语义不稳（例如频繁 getattr）。 -- **基础 xattr（可选但对生态有帮助）** - - `GETXATTR/SETXATTR/LISTXATTR/REMOVEXATTR`（可后置，但要规划） - -### 1.3 生产版（安全/语义/性能接近 Linux）的必需补齐 - -目标：支持非特权挂载（fusermount 模型）、更完善的信号/中断语义、可控的连接管理、以及性能可接受。 - -需要补齐： - -- **非特权挂载安全模型** - - “默认仅 mount owner 可访问”，`allow_other` 的限制（Linux fuse.rst 有详细动机） - - 与 DragonOS `Cred`/capability 的对齐（哪些能力允许 `allow_other`、哪些 mount flags 允许普通用户） - - 若要兼容 Linux 生态：最终需要用户态 `fusermount`（setuid root）或等价机制 -- **请求中断与连接 abort** - - `FUSE_INTERRUPT` 以及被信号打断时的竞态处理 - - 断连（daemon 死亡/close fd）时：所有 pending/processing 请求应快速失败并唤醒 -- **并发与多线程** - - `FUSE_DEV_IOC_CLONE`（libfuse 多线程常用） - - 背景队列/最大并发（Linux 有 max_background 等控制） -- **性能与 IO 能力** - - page cache / readahead / writeback cache（与 DragonOS `FileSystem::support_readahead()`、mm/page_cache 机制协同） - - 大 IO、零拷贝（splice/pipe）、mmap（`FOPEN_DIRECT_IO` 等） - ---- - -## 2. 推荐路线图（阶段 → 可独立 PR → 可独立测试） - -下面按“每个 PR 可单测/可集成测”为原则拆分。实际合并粒度可根据人力调整，但建议保持“每步都能验收”。 - -### Phase A：协议与内核基础设施（不引入 mount 行为变更或只做最小变更） - -**PR A1：引入 FUSE uapi 与协议编码/解码层（纯内核库）** -- 内容： - - 在 `kernel/src/filesystem/` 下新增 `fuse/` 模块：定义 `fuse_in_header/fuse_out_header`、opcode 常量、init/lookup/getattr/readdir/open/read/write 等结构体（参考 Linux `include/uapi/linux/fuse.h`）。 - - 提供安全的序列化/反序列化工具（对齐 64-bit 对齐要求，避免未对齐访问）。 -- 单测建议： - - 内核侧（或 host-side）结构体布局/大小断言； - - round-trip 编解码测试（给定样例字节流解析为结构体再编码一致）。 - -**PR A2：/dev/fuse 设备节点（devfs 注册 + 最小 file op）** -- 内容： - - 在 devfs 内注册字符设备 `fuse`，并保证 `/dev/fuse` 路径可用（必要时增加 symlink）。 - - `open()` 为每个 fd 初始化私有状态（建议新增 `FilePrivateData::FuseDev(...)`，内部持有 `Arc` 或 `Arc`）。 - - `read_at/write_at/poll/ioctl(close)` 的骨架先跑通（先不实现完整协议，只做队列读写框架）。 -- 单测/集成测建议： - - 用户态 smoke：`open("/dev/fuse")`，`poll()` 超时，向内核注入一条假 request（可通过调试接口或内核测试 hook），验证 poll 变为可读，read 能取到数据。 - - nonblock 行为：`O_NONBLOCK` 下 read 无数据返回 `EAGAIN`。 - -### Phase B：挂载闭环 + INIT 协商（做到“可演示”的里程碑） - -**PR B1：FuseFS 注册到 `FSMAKER`，实现 `mount -t fuse -o fd=...`** -- 内容： - - 新增 `FuseFS: MountableFileSystem`，注册 `"fuse"`（可选额外支持 `"fuse3"`，但建议从 `"fuse"` 起步）。 - - 解析 mount data（至少 `fd/rootmode/user_id/group_id`，参考 Linux `fs/fuse/inode.c` 与 `Documentation/filesystems/fuse.rst`）。 - - 通过 fd 取到 `/dev/fuse` 对应的 file/private_data，建立 `FuseConn` 与该挂载点绑定。 - - `SuperBlock.magic` 增加 `FUSE_SUPER_MAGIC`（Linux 常用值为 `0x65735546`，建议对齐），并为 `Magic` 增补该枚举项（`kernel/src/filesystem/vfs/mod.rs`）。 -- 集成测建议： - - 用户态：用最小 demo 程序完成 `open("/dev/fuse")` + `mount()`（即使 daemon 还没实现协议，也应能 mount 成功或在 INIT 未完成时明确返回错误）。 - -**PR B2：实现 INIT 请求生成与 init reply 处理（连接初始化状态机）** -- 内容： - - mount 后将 `FUSE_INIT` request 入队，daemon `read("/dev/fuse")` 能拿到 INIT。 - - 处理 init reply：记录 negotiated version、max_write/max_read、flags 等（先实现最小必要集合）。 - - INIT 前禁止其它请求或让其它请求阻塞，避免未初始化就访问。 -- 集成测建议（最重要的 MVP 里程碑测试）： - - 用户态 demo daemon：只实现 INIT（收到 INIT → 回 INIT reply → sleep），验证 mount 后内核 `fc.initialized==true`，并且 `/proc/mounts`（若已有）或 `statfs` 能正常返回。 - -### Phase C：最小可用 opcode（做到 `ls/stat/cat`） - -**PR C1：目录与路径遍历（LOOKUP/GETATTR/OPENDIR/READDIR/RELEASEDIR）** -- 内容： - - `IndexNode::find(name)` → `FUSE_LOOKUP(parent, name)` → 返回子 inode（nodeid/attr）。 - - `IndexNode::metadata()` → 触发或使用缓存的 `FUSE_GETATTR`。 - - `IndexNode::list()`：通过 `FUSE_OPENDIR + FUSE_READDIR` 拉取目录项并返回 `Vec`（MVP 允许“全量拉取+缓存”，但需写清楚局限）。 -- 集成测建议： - - 用户态 demo daemon 实现一个固定目录树（例如 `/hello.txt`、`/dir/a.txt`），在 DragonOS 内执行：`ls -l mountpoint`、`stat mountpoint/dir`。 - -**PR C2：文件读（OPEN/READ/RELEASE）** -- 内容： - - `open()` 返回 file handle（fh）写入 `FilePrivateData::FuseFile`； - - `read_at()` 生成 `FUSE_READ(nodeid, fh, offset, size)`，把 reply 数据拷回用户缓冲区。 -- 集成测建议： - - `cat mountpoint/hello.txt` 输出正确内容； - - `dd if=... bs=... count=...` 验证分块 read 与 offset 正确。 - -> 至此应达到“可演示”标准：一个用户态 daemon 在 DragonOS 内运行，完成 mount 并提供可访问文件。 - -### Phase D：写与创建（更接近可用） - -**PR D1：创建/删除/重命名（CREATE/MKDIR/UNLINK/RMDIR/RENAME）** -- 集成测建议： - - `mkdir`, `touch`, `rm`, `mv` 在挂载点上工作（可以只支持最小集合，逐步扩展）。 - -**PR D2：写与属性修改（WRITE/SETATTR/FSYNC/FLUSH）** -- 集成测建议： - - `echo hi > file`、`truncate -s`、`chmod/chown`（视 DragonOS 用户态工具链而定）。 - -### Phase E：Linux 语义与生态兼容（逐步接入 libfuse/fusermount） - -**PR E1：权限语义对齐（default_permissions / allow_other / mount owner 限制）** -- 关键点： - - DragonOS 的权限检查发生在 VFS 路径遍历与 open 等处；需要一个“按文件系统/挂载选项控制”的开关： - - `default_permissions`：按 mode 做内核侧权限裁决； - - 未开启时：尽量让访问透传给 daemon（更接近 Linux FUSE 默认行为）。 - - “默认仅 mount owner 可访问”与 `allow_other` 的安全限制，需要与 `Cred`/capability 结合设计。 -- 测试建议： - - 不同 uid/gid 下访问同一挂载点，行为符合预期。 - -**PR E2：`FUSE_DEV_IOC_CLONE` 与多线程（libfuse 常用路径）** -- 测试建议： - - 单线程模式 `-s`（不依赖 clone）先跑通，再开多线程。 - -**PR E3：提供用户态最小工具链** -- 方向 1：先把 DragonOS 的 demo daemon 做成“低层协议实现”，作为持续回归测试。 -- 方向 2：移植/引入 `libfuse3 + fusermount3`，逐步跑通现成 FUSE 文件系统（如 `sshfs`）。 -- 测试建议： - - `libfuse` 官方 example（hello/passthrough）的分步跑通清单。 - ---- - -## 3. 每个阶段“可以单独测试”的建议清单 - -为了避免“大工程最后才发现不通”，建议把测试分三层： - -### 3.1 设备层（/dev/fuse）测试 -- open/close：多次 open 是否产生独立连接或独立 dev state（按设计决定，但要可预测）。 -- poll/epoll：队列空/非空/断连时返回事件是否正确。 -- 阻塞 read：可被信号打断（返回 `ERESTARTSYS` 或 DragonOS 约定的等价错误）。 -- write reply：unique 不存在/重复 reply 的错误处理。 - -### 3.2 协议层测试 -- INIT：版本协商、feature flags 记录、max_read/max_write 限制是否生效。 -- LOOKUP/GETATTR：inode 类型（dir/file/symlink）与 mode 位语义。 -- READDIR：目录项编码解析（`fuse_dirent`）与 offset 行为（即使 MVP 做全量拉取也要保证不会重复/漏项）。 - -### 3.3 VFS 集成测试 -- `ls -l`/`stat`/`cat`（MVP） -- `mkdir/touch/rm/mv`（写路径阶段） -- `umount`：daemon 存活/daemon 已死两种情况下都不会卡住；挂载点清理正确。 - ---- - -## 4. 最终成品如何演示（建议的“可复制演示脚本”） - -建议把演示分成两档：**最小可演示**与**生态兼容演示**。 - -### 4.1 最小可演示（强烈建议优先做） - -**演示目标**：在 DragonOS 里运行一个 `fuse_demo`（用户态 daemon），挂载到 `/mnt/fuse`，展示目录与文件读写。 - -建议的演示流程（单终端也能完成）： - -1. 创建挂载点：`mkdir -p /mnt/fuse` -2. 启动 daemon（前台或后台）：`/bin/fuse_demo /mnt/fuse &` -3. 展示读路径： - - `ls -l /mnt/fuse` - - `cat /mnt/fuse/hello.txt` -4. 若已支持写路径，再展示： - - `echo hi > /mnt/fuse/new.txt` - - `cat /mnt/fuse/new.txt` -5. 卸载：`umount /mnt/fuse`（或 `umount2` 对应的用户态命令） - -**验收标准（建议写入 CI/回归脚本）**： -- `mount()` 成功并完成 INIT； -- `ls/stat/cat` 全部成功； -- daemon 被 kill 后，内核访问不会永久阻塞（应快速失败并可 umount）。 - -### 4.2 生态兼容演示（后续阶段） - -当 `libfuse3 + fusermount3` 跑通后，可以用更“直观”的演示： - -- 跑 `libfuse` 官方 hello/passthrough 示例； -- 跑 `sshfs`（如果 DragonOS 网络栈与 openssh/ dropbear 可用）； -- 或跑 `rclone mount` 等典型 FUSE 应用（取决于用户态生态与依赖）。 - ---- - -## 5. 风险点与关键决策（需要在实施前明确） - -1) **DragonOS 的 `IndexNode::list()` 是“全量目录项列表”接口** -FUSE 原生是流式 `READDIR`（带 offset），大目录会导致内存/性能问题。 -路线建议： -- MVP：先在 FUSE inode 内部做“分页拉取→拼成 Vec→缓存”跑通； -- 可用版/生产版：推动 VFS 增加“流式 readdir”接口，减少一次性全量拉取。 - -2) **权限语义：DragonOS 当前在路径遍历阶段就检查目录执行权限** -Linux FUSE 在 `default_permissions` 关闭时倾向把访问控制交给 daemon。 -要对齐语义，可能需要在 VFS 权限检查处引入“按文件系统/挂载选项”的可配置策略（这可能是跨模块的改动，应单独 PR、单独评审）。 - -3) **用户态生态的分阶段策略** -建议先用自研 `fuse_demo` 打通内核闭环并做回归，再考虑移植 libfuse/fusermount；否则调试成本会很高且难以定位问题在内核还是用户库。 - ---- - -## 6. 建议的 Roadmap 里程碑（便于汇报/追踪） - -- M0：PR A1+A2 合并（有 /dev/fuse 与协议骨架） -- M1：PR B1+B2 合并（mount(fd=) + INIT 协商跑通） -- M2：PR C1+C2 合并（`ls/stat/cat` 可演示） -- M3：PR D1+D2 合并（基础写路径可用） -- M4：PR E1 合并（权限语义对齐，安全模型清晰） -- M5：PR E2+E3 合并（libfuse/fusermount/生态演示） - diff --git a/TODO_FUSE_FULL_PLAN_CN.md b/TODO_FUSE_FULL_PLAN_CN.md deleted file mode 100644 index f500cad386..0000000000 --- a/TODO_FUSE_FULL_PLAN_CN.md +++ /dev/null @@ -1,118 +0,0 @@ -# DragonOS FUSE 完整实现分阶段计划（中文） - -> 目标：在现有 Phase A~D 基础上，补齐 Linux 6.6 关键语义与生态兼容能力，最终达到可用、可维护、可回归测试的完整 FUSE 实现。 - -## 1. 现状与核心缺口 - -- 当前已具备 `/dev/fuse`、`mount(fd=...)`、`INIT`、基础读写与目录操作闭环。 -- 主要缺口集中在：协议协商完整性、请求生命周期（尤其 FORGET）、权限语义细节、卸载销毁语义、以及 libfuse/fusermount 兼容路径。 -- 当前 dead code（如 `FUSE_MIN_READ_BUFFER`、`FUSE_FORGET`、`FATTR_ATIME/MTIME/...`）对应的是“功能未落地”，不建议简单删除。 - -## 2. dead code 与缺失功能映射 - -- `FUSE_MIN_READ_BUFFER`：应接入 `/dev/fuse` 读缓冲校验逻辑。 -- `FUSE_FORGET`：应接入 inode nlookup 生命周期与 forget 队列。 -- `FATTR_ATIME/MTIME/FH/ATIME_NOW/MTIME_NOW/CTIME`：应接入 `SETATTR(valid)` 精确编码与 `utimens/futimens` 语义。 -- `FuseFS` 中未消费字段（如 `owner_uid/owner_gid/allow_other/fd`）：要么用于语义与导出路径，要么移除避免误导。 - -## 3. 分阶段实现计划 - -### P0：协议与初始化补强（先把基础打牢） - -**目标**：修正 INIT 协商和设备层基础语义，清零当前 warning 的“伪完成”状态。 -**范围**： - -- 完整实现 `FUSE_INIT` 协商状态：记录并使用 negotiated `minor/flags/max_write/max_readahead/time_gran/max_pages`。 -- 在 `/dev/fuse` 读取路径加入 Linux 语义的最小缓冲校验（使用 `FUSE_MIN_READ_BUFFER`）。 -- 清理或落地当前未使用字段与常量，确保 dead code 反映真实功能状态。 - -**验收**： - -- `mount + INIT` 协商字段在连接对象中可观测。 -- `/dev/fuse` 小缓冲读取返回符合预期错误。 -- FUSE 相关 dead code warning 显著下降且不靠“静默忽略”。 - ---- - -### P1：请求生命周期与缓存一致性 - -**目标**：补齐 inode 生命周期核心语义，避免长期运行下的资源与一致性问题。 -**范围**： - -- 实现 `FUSE_FORGET`（可扩展到 `FUSE_BATCH_FORGET`）。 -- 建立 `lookup -> nlookup++ -> forget` 的闭环。 -- 接入 `entry_valid/attr_valid` 超时逻辑，完善 attr/dentry 缓存失效策略。 -- 卸载时在已初始化连接发送 `FUSE_DESTROY`（再进行 abort/清理）。 - -**验收**： - -- 压测反复 `lookup/readdir/umount` 不出现引用泄漏或僵死请求。 -- daemon 侧可观测到 forget/destroy 请求序列，且时序稳定。 - ---- - -### P2：Linux 关键语义 opcode 补齐 - -**目标**：补齐“常用但目前缺失”的协议能力，使通用用户态程序更易跑通。 -**范围**： - -- 权限相关：`FUSE_ACCESS`（尤其 Remote 权限模型下 `access/chdir` 语义）。 -- 同步相关：`FUSE_FLUSH`、`FUSE_FSYNC`、`FUSE_FSYNCDIR`。 -- 创建/链接族增强：`FUSE_CREATE`、`FUSE_LINK`、`FUSE_SYMLINK`、`FUSE_READLINK`、`FUSE_RENAME2`。 -- 属性扩展：`SETATTR` 完整 valid 位处理；接入 xattr 族（`GETXATTR/SETXATTR/LISTXATTR/REMOVEXATTR`）。 - -**验收**： - -- `chmod/chown/truncate/utimens`、`readlink/symlink/link/renameat2`、`fsync/fdatasync` 语义可回归。 -- xattr 相关 syscall 测例可跑通基本路径。 - ---- - -### P3：高级协议与并发/中断语义 - -**目标**：提升复杂场景可靠性，向 Linux 6.6 行为进一步收敛。 -**范围**： - -- `FUSE_INTERRUPT`：请求可中断、重入与竞态处理（含 `EAGAIN` 语义）。 -- 支持 notification（`unique=0`）基础框架与关键 notify 类型。 -- 目录增强：`READDIRPLUS`（可先按能力协商后开关）。 -- 协商优化：`FUSE_NO_OPEN_SUPPORT`、`FUSE_NO_OPENDIR_SUPPORT` 等能力位处理。 - -**验收**： - -- 信号打断下不死锁，错误码与请求完成路径可预测。 -- 大目录与并发 readdir/open 场景行为稳定。 - ---- - -### P4：生态兼容与工程化收口 - -**目标**：形成“可演示 + 可回归 + 可迁移”的完整交付。 -**范围**： - -- 跑通 `libfuse3 + fusermount3`（先单线程，再多线程 clone 路径）。 -- 完善 `FUSE_DEV_IOC_CLONE` 与多 daemon worker 协作语义。 -- 建立分层测试矩阵：`c_unitest`（设备/协议/VFS）+ gVisor syscall 回归 + demo 演示脚本。 -- 形成故障注入用例：daemon 崩溃、超时、中断、umount 竞争。 - -**验收**： - -- libfuse hello/passthrough 可稳定挂载与读写。 -- CI/回归中包含关键 FUSE 测试集并可长期运行。 - -## 4. 推荐 PR 拆分策略 - -- 每阶段拆 2~4 个小 PR，先“接口与状态机”，后“opcode 实现”，最后“测试补齐”。 -- 每个 PR 必须携带最小可复现实验（至少 1 个 c_unitest）。 -- 禁止以临时 workaround 通过测试，必须按 Linux 6.6 语义修根因。 - -## 5. 实施顺序建议 - -1. 先做 P0（基础正确性） -2. 再做 P1（生命周期） -3. 之后并行推进 P2（功能）与 P3（复杂语义） -4. 最后 P4（生态与工程化）收口 - ---- - -如需，我可以基于本计划继续输出：**第一批 P0 的具体代码任务清单（文件级别 + 函数级别 + 测试用例）**。 diff --git a/TODO_FUSE_PHASE_AB.md b/TODO_FUSE_PHASE_AB.md deleted file mode 100644 index 2dc7b286be..0000000000 --- a/TODO_FUSE_PHASE_AB.md +++ /dev/null @@ -1,49 +0,0 @@ -# TODO：实现 Phase A + Phase B（FUSE 基础设施 + mount/INIT 闭环） - -> 范围：仅覆盖 `ROADMAP_FUSE.md` 中 Phase A、Phase B（协议层 /dev/fuse / mount(fd=) / INIT 协商），并配套 `user/apps/c_unitest` 的单元测试与集成测试。 - -## Phase A（协议 + /dev/fuse） - -- [x] A1：引入 FUSE uapi 子集（结构体/常量/安全解析） - - 位置：`kernel/src/filesystem/fuse/protocol.rs` -- [x] A2：实现 `FuseConn`（请求队列 + unique + abort + INIT request 入队） - - 位置：`kernel/src/filesystem/fuse/conn.rs` -- [x] A3：实现 `/dev/fuse` 字符设备 - - [x] devfs 注册 `/dev/fuse` - - [x] open：初始化连接对象并写入 fd private data - - [x] read：从 pending 队列取 request（支持 nonblock 返回 `EAGAIN`） - - [x] write：写入 reply，匹配 unique，并驱动 INIT 完成 - - [x] poll/epoll：队列非空可读；断连返回 `POLLERR` - - 位置：`kernel/src/filesystem/fuse/dev.rs`、`kernel/src/filesystem/devfs/mod.rs` - -## Phase B（挂载闭环 + INIT 协商） - -- [x] B1：注册 `FuseFS` 到 `FSMAKER`（`-t fuse`） - - [x] 解析 mount data：`fd=,rootmode=,user_id=,group_id=` - - [x] 校验 fd 对应 `/dev/fuse` - - [x] 一个连接仅允许 mount 一次（重复 mount 返回 `EBUSY`） - - 位置：`kernel/src/filesystem/fuse/fs.rs` -- [x] B2：mount 成功后自动投递 `FUSE_INIT` request -- [x] B3：处理 `FUSE_INIT` reply 并将连接标记为 initialized - -## 测试（`user/apps/c_unitest`） - -- [x] 单元测试：`/dev/fuse` nonblock read + poll 空队列语义 - - `user/apps/c_unitest/test_fuse_dev.c` -- [x] 集成测试：`mount -t fuse -o fd=...` 触发 INIT，并能接受 INIT reply - - `user/apps/c_unitest/test_fuse_mount_init.c` - -## 反思/回归（执行到“完全确认正确”为止） - -- [x] 运行 `make user`，确认以上两个测试程序能编译进 rootfs -- [x ] 运行内核并执行： - - `/bin/test_fuse_dev` - - `/bin/test_fuse_mount_init` -- [x] 若失败：记录 errno/输出 → 回到对应模块修复 → 重复直到稳定通过 - -## 后续（不在 Phase A+B 范围内，仅记录） - -- [ ] `FUSE_DEV_IOC_CLONE`（libfuse 多线程路径） -- [ ] fusectl（`/sys/fs/fuse/connections`）与 abort 控制接口 -- [ ] 目录/文件 opcode（Phase C 起） - diff --git a/TODO_FUSE_PHASE_CD.md b/TODO_FUSE_PHASE_CD.md deleted file mode 100644 index 40606f3903..0000000000 --- a/TODO_FUSE_PHASE_CD.md +++ /dev/null @@ -1,52 +0,0 @@ -# TODO：实现 Phase C + Phase D（FUSE VFS 核心操作 + 写路径/创建操作） - -> 范围：继续完成 `ROADMAP_FUSE.md` 的 Phase C、Phase D，并在 `user/apps/c_unitest` 下补齐对应单元/集成测试。 -> -> 注意：本 TODO 覆盖“可演示/可用”的核心路径，不涵盖 Phase E（权限安全模型、fusermount/libfuse、clone、多线程等）。 - -## Phase C：读路径（`ls/stat/cat`） - -- [x] C0：`FuseConn` 支持通用 request/reply（阻塞等待 + errno 透传） - - `kernel/src/filesystem/fuse/conn.rs` -- [x] C1：实现 FUSE inode（VFS → FUSE opcode 映射） - - `LOOKUP`：`IndexNode::find()` - - `GETATTR`：`IndexNode::metadata()` - - `OPENDIR/READDIR/RELEASEDIR`：`IndexNode::list()` - - `OPEN/READ/RELEASE`：`IndexNode::open/read_at/close` - - `kernel/src/filesystem/fuse/inode.rs` -- [x] C2：FuseFS 提供 node cache + root nodeid=1 - - `kernel/src/filesystem/fuse/fs.rs` -- [x] C3：扩展 FUSE 协议结构体/常量（最小子集） - - `kernel/src/filesystem/fuse/protocol.rs` - -## Phase D：写与创建（`touch/echo/mkdir/rm/mv/truncate`） - -- [x] D1：`MKNOD/MKDIR`：`IndexNode::create_with_data()` -- [x] D2：`UNLINK/RMDIR`：`IndexNode::unlink()/rmdir()` -- [x] D3：`RENAME`：`IndexNode::move_to()` -- [x] D4：`WRITE`：`IndexNode::write_at()`（依赖 `open()` 得到 fh） -- [x] D5：`SETATTR(size)`：`IndexNode::resize()`（覆盖 `ftruncate`） -- [x] D6：`SETATTR(mode/uid/gid/size)`：`IndexNode::set_metadata()`（最小实现，后续可按 valid 精化） - -## 测试（`user/apps/c_unitest`） - -### 单元测试（偏接口/行为） - -- [x] `test_fuse_phase_c`：daemon 提供只读树，验证 `readdir/stat/open/read` - - 文件：`user/apps/c_unitest/test_fuse_phase_c.c` -- [x] `test_fuse_phase_d`：daemon 提供可写树，验证 `create/write/ftruncate/rename/unlink/mkdir/rmdir` - - 文件：`user/apps/c_unitest/test_fuse_phase_d.c` - -### 集成回归（与 Phase A+B 组合） - -- [ ] 组合运行： - - `/bin/test_fuse_dev` - - `/bin/test_fuse_mount_init` - - `/bin/test_fuse_phase_c` - - `/bin/test_fuse_phase_d` - -## 反思/迭代（直到“完全确认正确”） - -- [ ] 每次失败都必须记录：触发的 opcode、返回 errno、以及用户态 daemon 收到的请求序列 -- [ ] 优先修根因：协议字段/长度/对齐、offset 语义、inode type/mode 映射、fd private data 生命周期 -- [ ] 对齐 Linux 6.6：错误码（如重复 mount 应返回 `EINVAL`）、阻塞语义（`EAGAIN`/poll）、release 行为 diff --git a/user/apps/fuse3_demo/Makefile b/user/apps/fuse3_demo/Makefile index 9b99e8c024..1ee3c7dbbf 100644 --- a/user/apps/fuse3_demo/Makefile +++ b/user/apps/fuse3_demo/Makefile @@ -16,7 +16,7 @@ MESON ?= meson LIBFUSE_VERSION ?= 3.18.1 LIBFUSE_NAME := fuse-$(LIBFUSE_VERSION) LIBFUSE_URL_PRIMARY ?= https://github.com/libfuse/libfuse/releases/download/fuse-$(LIBFUSE_VERSION)/$(LIBFUSE_NAME).tar.gz -LIBFUSE_URL_MIRROR ?= https://mirrors.edge.kernel.org/pub/linux/kernel/people/mszeredi/fuse/$(LIBFUSE_NAME).tar.gz +LIBFUSE_URL_MIRROR ?= https://git.mirrors.dragonos.org.cn/DragonOS-Community/libfuse/archive/fuse-$(LIBFUSE_VERSION).tar.gz LIBFUSE_CACHE_DIR := $(CURDIR)/.cache LIBFUSE_ARCHIVE ?= $(LIBFUSE_CACHE_DIR)/$(LIBFUSE_NAME).tar.gz From 7dd8a697e25eb2a7f29e834a3306b50e2338af73 Mon Sep 17 00:00:00 2001 From: longjin Date: Sun, 15 Feb 2026 16:03:10 +0800 Subject: [PATCH 13/16] =?UTF-8?q?refactor(fuse):=20=E8=BF=81=E7=A7=BBFUSE?= =?UTF-8?q?=E5=9B=9E=E5=BD=92=E6=B5=8B=E8=AF=95=E8=87=B3dunitest=E6=A1=86?= =?UTF-8?q?=E6=9E=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: longjin --- user/apps/fuse_demo/Makefile | 1 - user/apps/fuse_demo/README.md | 21 +- user/apps/fuse_demo/run_all_test_fuse.sh | 59 - user/apps/fuse_demo/test_fuse_clone.c | 185 --- user/apps/fuse_demo/test_fuse_dev.c | 63 - user/apps/fuse_demo/test_fuse_mount_init.c | 180 --- user/apps/fuse_demo/test_fuse_p1_lifecycle.c | 124 -- user/apps/fuse_demo/test_fuse_p2_ops.c | 239 --- user/apps/fuse_demo/test_fuse_p3_interrupt.c | 191 --- .../test_fuse_p3_noopen_readdirplus_notify.c | 160 -- .../fuse_demo/test_fuse_p4_subtype_mount.c | 119 -- user/apps/fuse_demo/test_fuse_permissions.c | 172 -- user/apps/fuse_demo/test_fuse_phase_c.c | 163 -- user/apps/fuse_demo/test_fuse_phase_d.c | 180 --- user/apps/tests/dunitest/Makefile | 2 +- .../tests/dunitest/suites/fuse/fuse_core.cc | 548 +++++++ .../dunitest/suites/fuse/fuse_extended.cc | 1015 ++++++++++++ .../dunitest/suites/fuse/fuse_gtest_common.h | 154 ++ .../suites/fuse/fuse_test_simplefs_local.h | 1415 +++++++++++++++++ user/apps/tests/dunitest/whitelist.txt | 2 + 20 files changed, 3141 insertions(+), 1852 deletions(-) delete mode 100755 user/apps/fuse_demo/run_all_test_fuse.sh delete mode 100644 user/apps/fuse_demo/test_fuse_clone.c delete mode 100644 user/apps/fuse_demo/test_fuse_dev.c delete mode 100644 user/apps/fuse_demo/test_fuse_mount_init.c delete mode 100644 user/apps/fuse_demo/test_fuse_p1_lifecycle.c delete mode 100644 user/apps/fuse_demo/test_fuse_p2_ops.c delete mode 100644 user/apps/fuse_demo/test_fuse_p3_interrupt.c delete mode 100644 user/apps/fuse_demo/test_fuse_p3_noopen_readdirplus_notify.c delete mode 100644 user/apps/fuse_demo/test_fuse_p4_subtype_mount.c delete mode 100644 user/apps/fuse_demo/test_fuse_permissions.c delete mode 100644 user/apps/fuse_demo/test_fuse_phase_c.c delete mode 100644 user/apps/fuse_demo/test_fuse_phase_d.c create mode 100644 user/apps/tests/dunitest/suites/fuse/fuse_core.cc create mode 100644 user/apps/tests/dunitest/suites/fuse/fuse_extended.cc create mode 100644 user/apps/tests/dunitest/suites/fuse/fuse_gtest_common.h create mode 100644 user/apps/tests/dunitest/suites/fuse/fuse_test_simplefs_local.h diff --git a/user/apps/fuse_demo/Makefile b/user/apps/fuse_demo/Makefile index 2133f86aa8..cef89a59af 100644 --- a/user/apps/fuse_demo/Makefile +++ b/user/apps/fuse_demo/Makefile @@ -20,7 +20,6 @@ all: $(BINS) install: all @echo "Installing binaries to $(DADK_CURRENT_BUILD_DIR)/" mv $(BINS) $(DADK_CURRENT_BUILD_DIR)/ - cp run_all_test_fuse.sh $(DADK_CURRENT_BUILD_DIR)/ clean: rm -f $(BINS) diff --git a/user/apps/fuse_demo/README.md b/user/apps/fuse_demo/README.md index 2ac819cd78..c53d61a984 100644 --- a/user/apps/fuse_demo/README.md +++ b/user/apps/fuse_demo/README.md @@ -66,21 +66,12 @@ fuse_demo /mnt/fuse --threads 4 如果内核尚未支持 `FUSE_DEV_IOC_CLONE`，`--threads > 1` 会在 clone 阶段失败并提前退出（或只跑单线程，取决于当时实现）。 -## 内置测试程序 - -`user/apps/fuse_demo` 目录下同时提供了 FUSE 相关回归测试二进制： - -- `test_fuse_dev`：`/dev/fuse` 缓冲区与 nonblock 语义 -- `test_fuse_mount_init`：`mount + INIT` 协商与同 fd 重复挂载拒绝 -- `test_fuse_phase_c`：`ls/stat/cat` 读路径 -- `test_fuse_phase_d`：创建/写入/重命名/删除路径 -- `test_fuse_clone`：`FUSE_DEV_IOC_CLONE` 基础路径 -- `test_fuse_permissions`：`allow_other/default_permissions` 语义 -- `test_fuse_p1_lifecycle`：`FORGET/DESTROY` 生命周期语义 -- `test_fuse_p2_ops`：`ACCESS/CREATE/SYMLINK/READLINK/LINK/RENAME2/FLUSH/FSYNC/FSYNCDIR` -- `test_fuse_p3_interrupt`：信号中断触发 `FUSE_INTERRUPT` 语义 -- `test_fuse_p3_noopen_readdirplus_notify`：`NO_OPEN/NO_OPENDIR/READDIRPLUS/notify(unique=0)` -- `test_fuse_p4_subtype_mount`：`mount(..., "fuse.", ...)` 兼容路径 +## 测试入口迁移说明 + +FUSE 回归测试已统一迁移到 `dunitest` 的 `suites/fuse/` 下，按以下两个 gtest 二进制维护： + +- `fuse/fuse_core` +- `fuse/fuse_extended` ## 权限语义备注（对应 Phase E） diff --git a/user/apps/fuse_demo/run_all_test_fuse.sh b/user/apps/fuse_demo/run_all_test_fuse.sh deleted file mode 100755 index 974e08da1d..0000000000 --- a/user/apps/fuse_demo/run_all_test_fuse.sh +++ /dev/null @@ -1,59 +0,0 @@ -#!/bin/busybox sh -set -u - -SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd) -cd "$SCRIPT_DIR" || exit 1 - -if [ ! -e /dev/fuse ]; then - echo "[WARN] /dev/fuse 不存在，测试大概率会失败。" -fi - -pass=0 -fail=0 -total=0 -failed_tests="" -found_any=0 - -for t in ./test_fuse_*; do - if [ ! -e "$t" ]; then - continue - fi - if [ ! -x "$t" ]; then - continue - fi - - found_any=1 - total=$((total + 1)) - name=$(basename "$t") - - echo "===== RUN ${name} =====" - "$t" - rc=$? - if [ "$rc" -eq 0 ]; then - echo "===== PASS ${name} =====" - pass=$((pass + 1)) - else - echo "===== FAIL ${name} (rc=${rc}) =====" - fail=$((fail + 1)) - failed_tests="${failed_tests}\n - ${name}(rc=${rc})" - fi - echo -done - -if [ "$found_any" -eq 0 ]; then - echo "[ERROR] 当前目录未找到可执行的 test_fuse_*" - exit 1 -fi - -echo "===== SUMMARY =====" -echo "TOTAL: ${total}" -echo "PASS: ${pass}" -echo "FAIL: ${fail}" - -if [ "$fail" -ne 0 ]; then - echo "FAILED TESTS:" - printf "%b\n" "$failed_tests" - exit 1 -fi - -echo "ALL test_fuse_* PASSED" diff --git a/user/apps/fuse_demo/test_fuse_clone.c b/user/apps/fuse_demo/test_fuse_clone.c deleted file mode 100644 index 8e9660da40..0000000000 --- a/user/apps/fuse_demo/test_fuse_clone.c +++ /dev/null @@ -1,185 +0,0 @@ -/** - * @file test_fuse_clone.c - * @brief Phase E test: FUSE_DEV_IOC_CLONE basic behavior. - * - * This test mounts a simple FUSE filesystem using a master /dev/fuse fd, - * then opens a second /dev/fuse fd and uses FUSE_DEV_IOC_CLONE to attach it - * to the existing connection. After INIT is done, all requests are served - * via the cloned fd. - */ - -#include "fuse_test_simplefs.h" - -#include - -#ifndef FUSE_DEV_IOC_CLONE -#define FUSE_DEV_IOC_CLONE 0x80044600 /* _IOR('F', 0, uint32_t) */ -#endif - -static int read_all(const char *path, char *buf, size_t cap) { - int fd = open(path, O_RDONLY); - if (fd < 0) - return -1; - ssize_t n = read(fd, buf, cap); - close(fd); - if (n < 0) - return -1; - return (int)n; -} - -int main(void) { - const char *mp = "/tmp/test_fuse_clone"; - if (ensure_dir(mp) != 0) { - printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - return 1; - } - - int master_fd = open("/dev/fuse", O_RDWR); - if (master_fd < 0) { - printf("[FAIL] open(/dev/fuse master): %s (errno=%d)\n", strerror(errno), errno); - return 1; - } - - volatile int stop = 0; - volatile int init_done = 0; - - /* INIT responder on master fd, then exit */ - struct fuse_daemon_args master_args; - memset(&master_args, 0, sizeof(master_args)); - master_args.fd = master_fd; - master_args.stop = &stop; - master_args.init_done = &init_done; - master_args.enable_write_ops = 0; - master_args.exit_after_init = 1; - - pthread_t master_th; - if (pthread_create(&master_th, NULL, fuse_daemon_thread, &master_args) != 0) { - printf("[FAIL] pthread_create(master)\n"); - close(master_fd); - return 1; - } - - char opts[256]; - snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", master_fd); - if (mount("none", mp, "fuse", 0, opts) != 0) { - printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); - stop = 1; - close(master_fd); - pthread_join(master_th, NULL); - return 1; - } - - for (int i = 0; i < 100; i++) { - if (init_done) - break; - usleep(10 * 1000); - } - if (!init_done) { - printf("[FAIL] init handshake timeout\n"); - umount(mp); - stop = 1; - close(master_fd); - pthread_join(master_th, NULL); - return 1; - } - - pthread_join(master_th, NULL); - - /* Open a new fd and clone it to the master connection */ - int clone_fd = open("/dev/fuse", O_RDWR); - if (clone_fd < 0) { - printf("[FAIL] open(/dev/fuse clone): %s (errno=%d)\n", strerror(errno), errno); - umount(mp); - close(master_fd); - return 1; - } - - uint32_t oldfd_u32 = (uint32_t)master_fd; - if (ioctl(clone_fd, FUSE_DEV_IOC_CLONE, &oldfd_u32) != 0) { - printf("[FAIL] ioctl(FUSE_DEV_IOC_CLONE): %s (errno=%d)\n", strerror(errno), errno); - umount(mp); - close(clone_fd); - close(master_fd); - return 1; - } - - /* Serve all subsequent requests via the cloned fd */ - struct fuse_daemon_args clone_args; - memset(&clone_args, 0, sizeof(clone_args)); - clone_args.fd = clone_fd; - clone_args.stop = &stop; - clone_args.init_done = &init_done; - clone_args.enable_write_ops = 0; - clone_args.exit_after_init = 0; - - pthread_t clone_th; - if (pthread_create(&clone_th, NULL, fuse_daemon_thread, &clone_args) != 0) { - printf("[FAIL] pthread_create(clone)\n"); - umount(mp); - close(clone_fd); - close(master_fd); - return 1; - } - - /* readdir + stat + read */ - DIR *d = opendir(mp); - if (!d) { - printf("[FAIL] opendir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - goto fail; - } - int found = 0; - struct dirent *de; - while ((de = readdir(d)) != NULL) { - if (strcmp(de->d_name, "hello.txt") == 0) { - found = 1; - break; - } - } - closedir(d); - if (!found) { - printf("[FAIL] readdir: hello.txt not found\n"); - goto fail; - } - - char p[256]; - snprintf(p, sizeof(p), "%s/hello.txt", mp); - struct stat st; - if (stat(p, &st) != 0) { - printf("[FAIL] stat(%s): %s (errno=%d)\n", p, strerror(errno), errno); - goto fail; - } - if (!S_ISREG(st.st_mode)) { - printf("[FAIL] stat: expected regular file\n"); - goto fail; - } - - char buf[128]; - int n = read_all(p, buf, sizeof(buf) - 1); - if (n < 0) { - printf("[FAIL] read(%s): %s (errno=%d)\n", p, strerror(errno), errno); - goto fail; - } - buf[n] = '\0'; - if (strcmp(buf, "hello from fuse\n") != 0) { - printf("[FAIL] content mismatch: got='%s'\n", buf); - goto fail; - } - - umount(mp); - rmdir(mp); - stop = 1; - close(clone_fd); - close(master_fd); - pthread_join(clone_th, NULL); - printf("[PASS] fuse_clone\n"); - return 0; - -fail: - umount(mp); - stop = 1; - close(clone_fd); - close(master_fd); - pthread_join(clone_th, NULL); - return 1; -} - diff --git a/user/apps/fuse_demo/test_fuse_dev.c b/user/apps/fuse_demo/test_fuse_dev.c deleted file mode 100644 index 43917e27a5..0000000000 --- a/user/apps/fuse_demo/test_fuse_dev.c +++ /dev/null @@ -1,63 +0,0 @@ -/** - * @file test_fuse_dev.c - * @brief Phase P0 unit test: /dev/fuse read buffer and nonblock semantics. - */ - -#include "fuse_test_simplefs.h" - -static int test_nonblock_read_empty(void) { - int fd = open("/dev/fuse", O_RDWR | O_NONBLOCK); - if (fd < 0) { - printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); - return -1; - } - - unsigned char small[FUSE_MIN_READ_BUFFER / 2]; - ssize_t n = read(fd, small, sizeof(small)); - if (n != -1 || errno != EINVAL) { - printf("[FAIL] nonblock read with small buffer: n=%zd errno=%d (%s)\n", n, errno, - strerror(errno)); - close(fd); - return -1; - } - - unsigned char *big = malloc(FUSE_TEST_BUF_SIZE); - if (!big) { - printf("[FAIL] malloc big buffer failed\n"); - close(fd); - return -1; - } - memset(big, 0, FUSE_TEST_BUF_SIZE); - - n = read(fd, big, FUSE_TEST_BUF_SIZE); - if (n != -1 || (errno != EAGAIN && errno != EWOULDBLOCK)) { - printf("[FAIL] nonblock read empty: n=%zd errno=%d (%s)\n", n, errno, strerror(errno)); - free(big); - close(fd); - return -1; - } - - struct pollfd pfd; - pfd.fd = fd; - pfd.events = POLLIN; - int pr = poll(&pfd, 1, 100 /*ms*/); - if (pr != 0) { - printf("[FAIL] poll empty expected timeout: pr=%d revents=%x errno=%d (%s)\n", - pr, pfd.revents, errno, strerror(errno)); - free(big); - close(fd); - return -1; - } - - free(big); - close(fd); - printf("[PASS] nonblock_read_empty\n"); - return 0; -} - -int main(void) { - if (test_nonblock_read_empty() != 0) { - return 1; - } - return 0; -} diff --git a/user/apps/fuse_demo/test_fuse_mount_init.c b/user/apps/fuse_demo/test_fuse_mount_init.c deleted file mode 100644 index f535c4b97d..0000000000 --- a/user/apps/fuse_demo/test_fuse_mount_init.c +++ /dev/null @@ -1,180 +0,0 @@ -/** - * @file test_fuse_mount_init.c - * @brief Phase P0 integration test: mount/INIT handshake and single-use fd. - */ - -#include "fuse_test_simplefs.h" - -static int wait_readable(int fd, int timeout_ms) { - struct pollfd pfd; - memset(&pfd, 0, sizeof(pfd)); - pfd.fd = fd; - pfd.events = POLLIN; - int pr = poll(&pfd, 1, timeout_ms); - if (pr < 0) - return -1; - if (pr == 0) { - errno = ETIMEDOUT; - return -1; - } - if ((pfd.revents & POLLIN) == 0) { - errno = EIO; - return -1; - } - return 0; -} - -static int do_init_handshake(int fd) { - if (wait_readable(fd, 1000) != 0) { - printf("[FAIL] poll for INIT: %s (errno=%d)\n", strerror(errno), errno); - return -1; - } - - unsigned char *buf = malloc(FUSE_TEST_BUF_SIZE); - if (!buf) { - errno = ENOMEM; - printf("[FAIL] malloc init buffer failed\n"); - return -1; - } - memset(buf, 0, FUSE_TEST_BUF_SIZE); - - ssize_t n = read(fd, buf, FUSE_TEST_BUF_SIZE); - if (n < (ssize_t)(sizeof(struct fuse_in_header) + sizeof(struct fuse_init_in))) { - printf("[FAIL] read INIT too short: n=%zd errno=%d (%s)\n", n, errno, strerror(errno)); - free(buf); - return -1; - } - - struct fuse_in_header in_hdr; - memcpy(&in_hdr, buf, sizeof(in_hdr)); - if (in_hdr.opcode != FUSE_INIT) { - printf("[FAIL] expected FUSE_INIT opcode=%d got=%u\n", FUSE_INIT, in_hdr.opcode); - free(buf); - return -1; - } - if (in_hdr.len != (uint32_t)n) { - printf("[FAIL] header.len mismatch: hdr=%u read=%zd\n", in_hdr.len, n); - free(buf); - return -1; - } - - struct fuse_init_in init_in; - memcpy(&init_in, buf + sizeof(struct fuse_in_header), sizeof(init_in)); - if (init_in.major != 7 || init_in.minor == 0) { - printf("[FAIL] invalid init_in version major=%u minor=%u\n", init_in.major, init_in.minor); - free(buf); - return -1; - } - if (init_in.flags == 0 && init_in.flags2 == 0) { - printf("[FAIL] expected non-zero init flags\n"); - free(buf); - return -1; - } - free(buf); - - struct fuse_out_header out_hdr; - memset(&out_hdr, 0, sizeof(out_hdr)); - out_hdr.len = sizeof(struct fuse_out_header) + sizeof(struct fuse_init_out); - out_hdr.error = 0; - out_hdr.unique = in_hdr.unique; - - struct fuse_init_out init_out; - memset(&init_out, 0, sizeof(init_out)); - init_out.major = 7; - init_out.minor = 39; - init_out.flags = FUSE_INIT_EXT | FUSE_MAX_PAGES; - init_out.flags2 = 0; - init_out.max_write = 1024 * 1024; - init_out.max_pages = 256; - - unsigned char reply[sizeof(out_hdr) + sizeof(init_out)]; - memcpy(reply, &out_hdr, sizeof(out_hdr)); - memcpy(reply + sizeof(out_hdr), &init_out, sizeof(init_out)); - - ssize_t wn = write(fd, reply, sizeof(reply)); - if (wn != (ssize_t)sizeof(reply)) { - printf("[FAIL] write INIT reply: wn=%zd errno=%d (%s)\n", wn, errno, strerror(errno)); - return -1; - } - - return 0; -} - -int main(void) { - const char *mp = "/tmp/test_fuse_mp"; - const char *mp2 = "/tmp/test_fuse_mp2"; - - if (ensure_dir(mp) != 0) { - printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - return 1; - } - if (ensure_dir(mp2) != 0) { - printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp2, strerror(errno), errno); - return 1; - } - - int fd = open("/dev/fuse", O_RDWR | O_NONBLOCK); - if (fd < 0) { - printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); - return 1; - } - - char opts[256]; - snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); - - if (mount("none", mp, "fuse", 0, opts) != 0) { - printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); - close(fd); - return 1; - } - - if (do_init_handshake(fd) != 0) { - umount(mp); - close(fd); - return 1; - } - - unsigned char *tmp = malloc(FUSE_TEST_BUF_SIZE); - if (!tmp) { - printf("[FAIL] malloc tmp buffer failed\n"); - umount(mp); - close(fd); - return 1; - } - memset(tmp, 0, FUSE_TEST_BUF_SIZE); - - ssize_t rn = read(fd, tmp, FUSE_TEST_BUF_SIZE); - if (rn != -1 || (errno != EAGAIN && errno != EWOULDBLOCK)) { - printf("[FAIL] expected EAGAIN after init: rn=%zd errno=%d (%s)\n", rn, errno, strerror(errno)); - free(tmp); - umount(mp); - close(fd); - return 1; - } - free(tmp); - - /* - * Second mount with same fd should fail (connection already mounted). - */ - if (mount("none", mp2, "fuse", 0, opts) == 0) { - printf("[FAIL] second mount with same fd unexpectedly succeeded\n"); - umount(mp); - umount(mp2); - close(fd); - return 1; - } - if (errno != EINVAL) { - printf("[FAIL] second mount expected EINVAL got errno=%d (%s)\n", errno, strerror(errno)); - umount(mp); - close(fd); - return 1; - } - printf("[INFO] second mount failed as expected: errno=%d (%s)\n", errno, strerror(errno)); - - umount(mp); - rmdir(mp); - rmdir(mp2); - close(fd); - printf("[PASS] fuse_mount_init\n"); - return 0; -} diff --git a/user/apps/fuse_demo/test_fuse_p1_lifecycle.c b/user/apps/fuse_demo/test_fuse_p1_lifecycle.c deleted file mode 100644 index 49b6944f4b..0000000000 --- a/user/apps/fuse_demo/test_fuse_p1_lifecycle.c +++ /dev/null @@ -1,124 +0,0 @@ -/** - * @file test_fuse_p1_lifecycle.c - * @brief Phase P1 test: FORGET request lifecycle + DESTROY on umount. - */ - -#include "fuse_test_simplefs.h" - -static int wait_init(volatile int *init_done) { - for (int i = 0; i < 200; i++) { - if (*init_done) - return 0; - usleep(10 * 1000); - } - errno = ETIMEDOUT; - return -1; -} - -int main(void) { - const char *mp = "/tmp/test_fuse_p1_lifecycle"; - if (ensure_dir(mp) != 0) { - printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - return 1; - } - - int fd = open("/dev/fuse", O_RDWR); - if (fd < 0) { - printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); - return 1; - } - - volatile int stop = 0; - volatile int init_done = 0; - volatile uint32_t forget_count = 0; - volatile uint64_t forget_nlookup_sum = 0; - volatile uint32_t destroy_count = 0; - - struct fuse_daemon_args args; - memset(&args, 0, sizeof(args)); - args.fd = fd; - args.stop = &stop; - args.init_done = &init_done; - args.enable_write_ops = 0; - args.stop_on_destroy = 1; - args.forget_count = &forget_count; - args.forget_nlookup_sum = &forget_nlookup_sum; - args.destroy_count = &destroy_count; - - pthread_t th; - if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { - printf("[FAIL] pthread_create\n"); - close(fd); - return 1; - } - - char opts[256]; - snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); - if (mount("none", mp, "fuse", 0, opts) != 0) { - printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - - if (wait_init(&init_done) != 0) { - printf("[FAIL] init handshake timeout\n"); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - - char p[256]; - snprintf(p, sizeof(p), "%s/hello.txt", mp); - for (int i = 0; i < 8; i++) { - struct stat st; - if (stat(p, &st) != 0) { - printf("[FAIL] stat(%s): %s (errno=%d)\n", p, strerror(errno), errno); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - } - - /* Give daemon time to consume queued FORGETs before unmount path. */ - usleep(100 * 1000); - - if (umount(mp) != 0) { - printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - - for (int i = 0; i < 100; i++) { - if (destroy_count > 0) - break; - usleep(10 * 1000); - } - - stop = 1; - close(fd); - pthread_join(th, NULL); - rmdir(mp); - - if (forget_count == 0 || forget_nlookup_sum == 0) { - printf("[FAIL] expected FORGET requests, got count=%u nlookup_sum=%llu\n", forget_count, - (unsigned long long)forget_nlookup_sum); - return 1; - } - - if (destroy_count == 0) { - printf("[FAIL] expected DESTROY request on umount\n"); - return 1; - } - - printf("[PASS] fuse_p1_lifecycle (forget_count=%u, forget_nlookup_sum=%llu, destroy_count=%u)\n", - forget_count, (unsigned long long)forget_nlookup_sum, destroy_count); - return 0; -} diff --git a/user/apps/fuse_demo/test_fuse_p2_ops.c b/user/apps/fuse_demo/test_fuse_p2_ops.c deleted file mode 100644 index a5dcc882e3..0000000000 --- a/user/apps/fuse_demo/test_fuse_p2_ops.c +++ /dev/null @@ -1,239 +0,0 @@ -/** - * @file test_fuse_p2_ops.c - * @brief Phase P2 test: ACCESS/CREATE/SYMLINK/READLINK/LINK/RENAME2/FLUSH/FSYNC/FSYNCDIR. - */ - -#include "fuse_test_simplefs.h" - -#include - -static int wait_init(volatile int *init_done) { - for (int i = 0; i < 200; i++) { - if (*init_done) - return 0; - usleep(10 * 1000); - } - errno = ETIMEDOUT; - return -1; -} - -static int write_all(int fd, const char *s) { - size_t left = strlen(s); - const char *p = s; - while (left > 0) { - ssize_t n = write(fd, p, left); - if (n <= 0) { - return -1; - } - p += n; - left -= (size_t)n; - } - return 0; -} - -int main(void) { - const char *mp = "/tmp/test_fuse_p2_ops"; - if (ensure_dir(mp) != 0) { - printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - return 1; - } - - int fd = open("/dev/fuse", O_RDWR); - if (fd < 0) { - printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); - return 1; - } - - volatile int stop = 0; - volatile int init_done = 0; - volatile uint32_t access_count = 0; - volatile uint32_t flush_count = 0; - volatile uint32_t fsync_count = 0; - volatile uint32_t fsyncdir_count = 0; - volatile uint32_t create_count = 0; - volatile uint32_t rename2_count = 0; - - struct fuse_daemon_args args; - memset(&args, 0, sizeof(args)); - args.fd = fd; - args.stop = &stop; - args.init_done = &init_done; - args.enable_write_ops = 1; - args.stop_on_destroy = 1; - args.access_count = &access_count; - args.flush_count = &flush_count; - args.fsync_count = &fsync_count; - args.fsyncdir_count = &fsyncdir_count; - args.create_count = &create_count; - args.rename2_count = &rename2_count; - args.access_deny_mask = 2; /* MAY_WRITE */ - - pthread_t th; - if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { - printf("[FAIL] pthread_create\n"); - close(fd); - return 1; - } - - char opts[256]; - snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0,allow_other", fd); - if (mount("none", mp, "fuse", 0, opts) != 0) { - printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - - if (wait_init(&init_done) != 0) { - printf("[FAIL] init handshake timeout\n"); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - - char hello[256]; - snprintf(hello, sizeof(hello), "%s/hello.txt", mp); - if (access(hello, R_OK) != 0) { - printf("[FAIL] access(R_OK): %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - if (access(hello, W_OK) == 0 || errno != EACCES) { - printf("[FAIL] access(W_OK) expected EACCES, errno=%d (%s)\n", errno, strerror(errno)); - goto fail; - } - - char created[256]; - snprintf(created, sizeof(created), "%s/p2_create.txt", mp); - int f = open(created, O_CREAT | O_RDWR, 0644); - if (f < 0) { - printf("[FAIL] open(O_CREAT): %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - if (write_all(f, "p2-data") != 0) { - printf("[FAIL] write created file: %s (errno=%d)\n", strerror(errno), errno); - close(f); - goto fail; - } - if (fsync(f) != 0) { - printf("[FAIL] fsync(file): %s (errno=%d)\n", strerror(errno), errno); - close(f); - goto fail; - } - close(f); - - char symlink_path[256]; - snprintf(symlink_path, sizeof(symlink_path), "%s/p2_symlink.txt", mp); - if (symlink("p2_create.txt", symlink_path) != 0) { - printf("[FAIL] symlink: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - char target_buf[256]; - ssize_t tn = readlink(symlink_path, target_buf, sizeof(target_buf) - 1); - if (tn <= 0) { - printf("[FAIL] readlink: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - target_buf[tn] = '\0'; - if (strcmp(target_buf, "p2_create.txt") != 0) { - printf("[FAIL] readlink target mismatch: got=%s\n", target_buf); - goto fail; - } - - char hard_path[256]; - snprintf(hard_path, sizeof(hard_path), "%s/p2_hard.txt", mp); - if (link(created, hard_path) != 0) { - printf("[FAIL] link: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - if (unlink(created) != 0) { - printf("[FAIL] unlink original: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - f = open(hard_path, O_RDONLY); - if (f < 0) { - printf("[FAIL] open hard link: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - char rbuf[64]; - ssize_t rn = read(f, rbuf, sizeof(rbuf) - 1); - close(f); - if (rn <= 0) { - printf("[FAIL] read hard link: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - rbuf[rn] = '\0'; - if (strcmp(rbuf, "p2-data") != 0) { - printf("[FAIL] hard link content mismatch: got=%s\n", rbuf); - goto fail; - } - - char dst_exist[256]; - snprintf(dst_exist, sizeof(dst_exist), "%s/p2_dst_exist.txt", mp); - f = open(dst_exist, O_CREAT | O_RDWR, 0644); - if (f < 0) { - printf("[FAIL] create dst_exist: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - close(f); - - if (syscall(SYS_renameat2, AT_FDCWD, hard_path, AT_FDCWD, dst_exist, RENAME_NOREPLACE) == 0 - || errno != EEXIST) { - printf("[FAIL] renameat2 NOREPLACE expected EEXIST, errno=%d (%s)\n", errno, - strerror(errno)); - goto fail; - } - - char renamed[256]; - snprintf(renamed, sizeof(renamed), "%s/p2_renamed.txt", mp); - if (syscall(SYS_renameat2, AT_FDCWD, hard_path, AT_FDCWD, renamed, RENAME_NOREPLACE) != 0) { - printf("[FAIL] renameat2 NOREPLACE success path: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - - int dfd = open(mp, O_RDONLY | O_DIRECTORY); - if (dfd < 0) { - printf("[FAIL] open mountpoint dirfd: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - if (fsync(dfd) != 0) { - printf("[FAIL] fsync(dirfd): %s (errno=%d)\n", strerror(errno), errno); - close(dfd); - goto fail; - } - close(dfd); - - usleep(100 * 1000); - - if (access_count < 2 || flush_count == 0 || fsync_count == 0 || fsyncdir_count == 0 - || create_count == 0 || rename2_count < 2) { - printf("[FAIL] counters access=%u flush=%u fsync=%u fsyncdir=%u create=%u rename2=%u\n", - access_count, flush_count, fsync_count, fsyncdir_count, create_count, - rename2_count); - goto fail; - } - - if (umount(mp) != 0) { - printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - goto fail_noum; - } - stop = 1; - close(fd); - pthread_join(th, NULL); - rmdir(mp); - - printf("[PASS] fuse_p2_ops (access=%u flush=%u fsync=%u fsyncdir=%u create=%u rename2=%u)\n", - access_count, flush_count, fsync_count, fsyncdir_count, create_count, rename2_count); - return 0; - -fail: - umount(mp); -fail_noum: - stop = 1; - close(fd); - pthread_join(th, NULL); - rmdir(mp); - return 1; -} diff --git a/user/apps/fuse_demo/test_fuse_p3_interrupt.c b/user/apps/fuse_demo/test_fuse_p3_interrupt.c deleted file mode 100644 index 4a8bfcaeb3..0000000000 --- a/user/apps/fuse_demo/test_fuse_p3_interrupt.c +++ /dev/null @@ -1,191 +0,0 @@ -/** - * @file test_fuse_p3_interrupt.c - * @brief Phase P3 test: blocked request interrupted by signal -> FUSE_INTERRUPT. - */ - -#include "fuse_test_simplefs.h" - -#include - -static void sigusr1_handler(int signo) { - (void)signo; -} - -static int wait_init(volatile int *init_done) { - for (int i = 0; i < 200; i++) { - if (*init_done) { - return 0; - } - usleep(10 * 1000); - } - errno = ETIMEDOUT; - return -1; -} - -struct reader_ctx { - char path[256]; - volatile int done; - ssize_t nread; - int err; -}; - -static void *reader_thread(void *arg) { - struct reader_ctx *ctx = (struct reader_ctx *)arg; - int fd = open(ctx->path, O_RDONLY); - if (fd < 0) { - ctx->nread = -1; - ctx->err = errno; - ctx->done = 1; - return NULL; - } - - char buf[64]; - ssize_t n = read(fd, buf, sizeof(buf)); - if (n < 0) { - ctx->nread = -1; - ctx->err = errno; - } else { - ctx->nread = n; - ctx->err = 0; - } - close(fd); - ctx->done = 1; - return NULL; -} - -int main(void) { - struct sigaction sa; - memset(&sa, 0, sizeof(sa)); - sa.sa_handler = sigusr1_handler; - sigemptyset(&sa.sa_mask); - sa.sa_flags = 0; /* no SA_RESTART */ - if (sigaction(SIGUSR1, &sa, NULL) != 0) { - printf("[FAIL] sigaction(SIGUSR1): %s (errno=%d)\n", strerror(errno), errno); - return 1; - } - - const char *mp = "/tmp/test_fuse_p3_interrupt"; - if (ensure_dir(mp) != 0) { - printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - return 1; - } - - int fd = open("/dev/fuse", O_RDWR); - if (fd < 0) { - printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); - return 1; - } - - volatile int stop = 0; - volatile int init_done = 0; - volatile uint32_t interrupt_count = 0; - volatile uint64_t blocked_read_unique = 0; - volatile uint64_t last_interrupt_target = 0; - - struct fuse_daemon_args args; - memset(&args, 0, sizeof(args)); - args.fd = fd; - args.stop = &stop; - args.init_done = &init_done; - args.enable_write_ops = 0; - args.stop_on_destroy = 1; - args.block_read_until_interrupt = 1000; /* delay read reply 1s */ - args.interrupt_count = &interrupt_count; - args.blocked_read_unique = &blocked_read_unique; - args.last_interrupt_target = &last_interrupt_target; - - pthread_t daemon_th; - if (pthread_create(&daemon_th, NULL, fuse_daemon_thread, &args) != 0) { - printf("[FAIL] pthread_create(daemon)\n"); - close(fd); - return 1; - } - - char opts[256]; - snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); - if (mount("none", mp, "fuse", 0, opts) != 0) { - printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); - stop = 1; - close(fd); - pthread_join(daemon_th, NULL); - return 1; - } - if (wait_init(&init_done) != 0) { - printf("[FAIL] init handshake timeout\n"); - goto fail; - } - - struct reader_ctx rctx; - memset(&rctx, 0, sizeof(rctx)); - snprintf(rctx.path, sizeof(rctx.path), "%s/hello.txt", mp); - - pthread_t reader_th; - if (pthread_create(&reader_th, NULL, reader_thread, &rctx) != 0) { - printf("[FAIL] pthread_create(reader)\n"); - goto fail; - } - - for (int i = 0; i < 200; i++) { - if (blocked_read_unique != 0) { - break; - } - usleep(5 * 1000); - } - if (blocked_read_unique == 0) { - printf("[FAIL] timed out waiting for blocked read request\n"); - stop = 1; - pthread_join(reader_th, NULL); - goto fail; - } - - if (pthread_kill(reader_th, SIGUSR1) != 0) { - printf("[FAIL] pthread_kill(SIGUSR1)\n"); - stop = 1; - pthread_join(reader_th, NULL); - goto fail; - } - pthread_join(reader_th, NULL); - - if (rctx.nread != -1 || rctx.err != EINTR) { - printf("[FAIL] reader expected EINTR, nread=%zd err=%d (%s)\n", rctx.nread, rctx.err, - strerror(rctx.err)); - goto fail; - } - - for (int i = 0; i < 500; i++) { - if (interrupt_count > 0) { - break; - } - usleep(5 * 1000); - } - - if (interrupt_count == 0) { - printf("[FAIL] expected FUSE_INTERRUPT request\n"); - goto fail; - } - if (last_interrupt_target == 0 || last_interrupt_target != blocked_read_unique) { - printf("[FAIL] interrupt target mismatch: blocked=%llu interrupt_target=%llu\n", - (unsigned long long)blocked_read_unique, (unsigned long long)last_interrupt_target); - goto fail; - } - - if (umount(mp) != 0) { - printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - goto fail_no_umount; - } - stop = 1; - close(fd); - pthread_join(daemon_th, NULL); - rmdir(mp); - printf("[PASS] fuse_p3_interrupt (interrupt_count=%u)\n", interrupt_count); - return 0; - -fail: - umount(mp); -fail_no_umount: - stop = 1; - close(fd); - pthread_join(daemon_th, NULL); - rmdir(mp); - return 1; -} diff --git a/user/apps/fuse_demo/test_fuse_p3_noopen_readdirplus_notify.c b/user/apps/fuse_demo/test_fuse_p3_noopen_readdirplus_notify.c deleted file mode 100644 index c0b410bd12..0000000000 --- a/user/apps/fuse_demo/test_fuse_p3_noopen_readdirplus_notify.c +++ /dev/null @@ -1,160 +0,0 @@ -/** - * @file test_fuse_p3_noopen_readdirplus_notify.c - * @brief Phase P3 test: NO_OPEN/NO_OPENDIR + READDIRPLUS + notify(unique=0). - */ - -#include "fuse_test_simplefs.h" - -static int wait_init(volatile int *init_done) { - for (int i = 0; i < 200; i++) { - if (*init_done) { - return 0; - } - usleep(10 * 1000); - } - errno = ETIMEDOUT; - return -1; -} - -int main(void) { - const char *mp = "/tmp/test_fuse_p3_noopen"; - if (ensure_dir(mp) != 0) { - printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - return 1; - } - - int fd = open("/dev/fuse", O_RDWR); - if (fd < 0) { - printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); - return 1; - } - - volatile int stop = 0; - volatile int init_done = 0; - volatile uint32_t open_count = 0; - volatile uint32_t opendir_count = 0; - volatile uint32_t release_count = 0; - volatile uint32_t releasedir_count = 0; - volatile uint32_t readdirplus_count = 0; - - struct fuse_daemon_args args; - memset(&args, 0, sizeof(args)); - args.fd = fd; - args.stop = &stop; - args.init_done = &init_done; - args.enable_write_ops = 0; - args.stop_on_destroy = 1; - args.open_count = &open_count; - args.opendir_count = &opendir_count; - args.release_count = &release_count; - args.releasedir_count = &releasedir_count; - args.readdirplus_count = &readdirplus_count; - args.force_open_enosys = 1; - args.force_opendir_enosys = 1; - args.init_out_flags_override = FUSE_INIT_EXT | FUSE_MAX_PAGES | FUSE_NO_OPEN_SUPPORT | - FUSE_NO_OPENDIR_SUPPORT | FUSE_DO_READDIRPLUS; - - pthread_t th; - if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { - printf("[FAIL] pthread_create\n"); - close(fd); - return 1; - } - - char opts[256]; - snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); - if (mount("none", mp, "fuse", 0, opts) != 0) { - printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - if (wait_init(&init_done) != 0) { - printf("[FAIL] init handshake timeout\n"); - goto fail; - } - - char file_path[256]; - snprintf(file_path, sizeof(file_path), "%s/hello.txt", mp); - for (int i = 0; i < 2; i++) { - int f = open(file_path, O_RDONLY); - if (f < 0) { - printf("[FAIL] open(%s): %s (errno=%d)\n", file_path, strerror(errno), errno); - goto fail; - } - char buf[64]; - ssize_t n = read(f, buf, sizeof(buf) - 1); - close(f); - if (n <= 0) { - printf("[FAIL] read(%s): %s (errno=%d)\n", file_path, strerror(errno), errno); - goto fail; - } - } - - for (int i = 0; i < 2; i++) { - DIR *dir = opendir(mp); - if (!dir) { - printf("[FAIL] opendir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - goto fail; - } - int saw = 0; - struct dirent *de; - while ((de = readdir(dir)) != NULL) { - if (strcmp(de->d_name, "hello.txt") == 0) { - saw = 1; - } - } - closedir(dir); - if (!saw) { - printf("[FAIL] readdir didn't see hello.txt\n"); - goto fail; - } - } - - struct { - struct fuse_out_header out; - struct fuse_notify_inval_inode_out inval; - } notify_msg; - memset(¬ify_msg, 0, sizeof(notify_msg)); - notify_msg.out.len = sizeof(notify_msg); - notify_msg.out.error = FUSE_NOTIFY_INVAL_INODE; - notify_msg.out.unique = 0; - notify_msg.inval.ino = 2; - notify_msg.inval.off = 0; - notify_msg.inval.len = -1; - ssize_t wn = write(fd, ¬ify_msg, sizeof(notify_msg)); - if (wn != (ssize_t)sizeof(notify_msg)) { - printf("[FAIL] write notify: wn=%zd errno=%d (%s)\n", wn, errno, strerror(errno)); - goto fail; - } - - usleep(100 * 1000); - - if (open_count != 1 || opendir_count != 1 || release_count != 0 || releasedir_count != 0 || - readdirplus_count == 0) { - printf("[FAIL] counters open=%u opendir=%u release=%u releasedir=%u readdirplus=%u\n", - open_count, opendir_count, release_count, releasedir_count, readdirplus_count); - goto fail; - } - - if (umount(mp) != 0) { - printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - goto fail_no_umount; - } - stop = 1; - close(fd); - pthread_join(th, NULL); - rmdir(mp); - printf("[PASS] fuse_p3_noopen_readdirplus_notify\n"); - return 0; - -fail: - umount(mp); -fail_no_umount: - stop = 1; - close(fd); - pthread_join(th, NULL); - rmdir(mp); - return 1; -} diff --git a/user/apps/fuse_demo/test_fuse_p4_subtype_mount.c b/user/apps/fuse_demo/test_fuse_p4_subtype_mount.c deleted file mode 100644 index 325b0df981..0000000000 --- a/user/apps/fuse_demo/test_fuse_p4_subtype_mount.c +++ /dev/null @@ -1,119 +0,0 @@ -/** - * @file test_fuse_p4_subtype_mount.c - * @brief Phase P4 regression: mount with filesystem type "fuse.". - */ - -#include "fuse_test_simplefs.h" - -static int read_all(const char *path, char *buf, size_t cap) { - int fd = open(path, O_RDONLY); - if (fd < 0) { - return -1; - } - ssize_t n = read(fd, buf, cap - 1); - int saved_errno = errno; - close(fd); - if (n < 0) { - errno = saved_errno; - return -1; - } - buf[n] = '\0'; - return (int)n; -} - -int main(void) { - const char *mp = "/tmp/test_fuse_p4_subtype"; - if (ensure_dir(mp) != 0) { - printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - return 1; - } - - int fd = open("/dev/fuse", O_RDWR); - if (fd < 0) { - printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); - return 1; - } - - volatile int stop = 0; - volatile int init_done = 0; - struct fuse_daemon_args args; - memset(&args, 0, sizeof(args)); - args.fd = fd; - args.stop = &stop; - args.init_done = &init_done; - args.enable_write_ops = 0; - args.stop_on_destroy = 1; - - pthread_t th; - if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { - printf("[FAIL] pthread_create\n"); - close(fd); - return 1; - } - - char opts[256]; - snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); - if (mount("none", mp, "fuse.fuse3_demo", 0, opts) != 0) { - printf("[FAIL] mount(fuse.fuse3_demo): %s (errno=%d)\n", strerror(errno), errno); - stop = 1; - close(fd); - pthread_join(th, NULL); - rmdir(mp); - return 1; - } - - for (int i = 0; i < 200; i++) { - if (init_done) { - break; - } - usleep(10 * 1000); - } - if (!init_done) { - printf("[FAIL] init handshake timeout\n"); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - rmdir(mp); - return 1; - } - - char file_path[256]; - snprintf(file_path, sizeof(file_path), "%s/hello.txt", mp); - - char buf[128]; - if (read_all(file_path, buf, sizeof(buf)) < 0) { - printf("[FAIL] read(%s): %s (errno=%d)\n", file_path, strerror(errno), errno); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - rmdir(mp); - return 1; - } - if (strcmp(buf, "hello from fuse\n") != 0) { - printf("[FAIL] content mismatch: got='%s'\n", buf); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - rmdir(mp); - return 1; - } - - if (umount(mp) != 0) { - printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - stop = 1; - close(fd); - pthread_join(th, NULL); - rmdir(mp); - return 1; - } - - stop = 1; - close(fd); - pthread_join(th, NULL); - rmdir(mp); - printf("[PASS] fuse_p4_subtype_mount\n"); - return 0; -} diff --git a/user/apps/fuse_demo/test_fuse_permissions.c b/user/apps/fuse_demo/test_fuse_permissions.c deleted file mode 100644 index 5ed4892c3f..0000000000 --- a/user/apps/fuse_demo/test_fuse_permissions.c +++ /dev/null @@ -1,172 +0,0 @@ -/** - * @file test_fuse_permissions.c - * @brief Phase E test: allow_other/default_permissions + mount owner restriction. - */ - -#include "fuse_test_simplefs.h" - -#include - -static int wait_init(volatile int *init_done) { - for (int i = 0; i < 200; i++) { - if (*init_done) - return 0; - usleep(10 * 1000); - } - errno = ETIMEDOUT; - return -1; -} - -static int run_child_drop_priv_and_stat(const char *mp, int expect_errno, int expect_success) { - pid_t pid = fork(); - if (pid < 0) { - return -1; - } - if (pid == 0) { - /* child */ - (void)setgid(1000); - (void)setuid(1000); - - struct stat st; - int r = stat(mp, &st); - if (expect_success) { - if (r != 0) - _exit(10); - /* Also check file read works */ - char p[256]; - snprintf(p, sizeof(p), "%s/hello.txt", mp); - int fd = open(p, O_RDONLY); - if (fd < 0) - _exit(11); - char buf[64]; - ssize_t n = read(fd, buf, sizeof(buf) - 1); - close(fd); - if (n < 0) - _exit(12); - buf[n] = '\0'; - if (strcmp(buf, "hello from fuse\n") != 0) - _exit(13); - _exit(0); - } - - if (r == 0) - _exit(20); - if (errno != expect_errno) - _exit(21); - _exit(0); - } - - int status = 0; - if (waitpid(pid, &status, 0) < 0) { - return -1; - } - if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { - errno = ECHILD; - return -1; - } - return 0; -} - -static int run_one(const char *mp, const char *opts, uint32_t root_mode_override, - uint32_t hello_mode_override, int expect_errno, int expect_success) { - if (ensure_dir(mp) != 0) { - return -1; - } - - int fd = open("/dev/fuse", O_RDWR); - if (fd < 0) { - return -1; - } - - volatile int stop = 0; - volatile int init_done = 0; - struct fuse_daemon_args args; - memset(&args, 0, sizeof(args)); - args.fd = fd; - args.stop = &stop; - args.init_done = &init_done; - args.enable_write_ops = 0; - args.exit_after_init = 0; - args.root_mode_override = root_mode_override; - args.hello_mode_override = hello_mode_override; - - pthread_t th; - if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { - close(fd); - return -1; - } - - char full_opts[512]; - snprintf(full_opts, sizeof(full_opts), "fd=%d,%s", fd, opts); - if (mount("none", mp, "fuse", 0, full_opts) != 0) { - stop = 1; - close(fd); - pthread_join(th, NULL); - return -1; - } - - if (wait_init(&init_done) != 0) { - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return -1; - } - - if (run_child_drop_priv_and_stat(mp, expect_errno, expect_success) != 0) { - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return -1; - } - - umount(mp); - rmdir(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 0; -} - -int main(void) { - /* Build opts strings with the real fd inside run_one() */ - /* - For deny cases, use a root dir with no permissions to exercise default_permissions. */ - const uint32_t DIR_NO_PERM = 0040000; - const uint32_t REG_NO_PERM = 0100000; - - /* Case A: mount owner restriction (no allow_other) */ - { - const char *mp = "/tmp/test_fuse_perm_owner"; - if (run_one(mp, "rootmode=040755,user_id=0,group_id=0", 0, 0, EACCES, 0) != 0) { - printf("[FAIL] mount owner restriction\n"); - return 1; - } - } - - /* Case B: allow_other + default_permissions: DAC should deny with no-perm root */ - { - const char *mp = "/tmp/test_fuse_perm_default"; - if (run_one(mp, - "rootmode=040000,user_id=0,group_id=0,allow_other,default_permissions", - DIR_NO_PERM, REG_NO_PERM, EACCES, 0) - != 0) { - printf("[FAIL] default_permissions deny\n"); - return 1; - } - } - - /* Case C: allow_other without default_permissions: bypass DAC, should succeed */ - { - const char *mp = "/tmp/test_fuse_perm_remote"; - if (run_one(mp, "rootmode=040000,user_id=0,group_id=0,allow_other", DIR_NO_PERM, - REG_NO_PERM, 0, 1) - != 0) { - printf("[FAIL] remote permission model allow\n"); - return 1; - } - } - - printf("[PASS] fuse_permissions\n"); - return 0; -} diff --git a/user/apps/fuse_demo/test_fuse_phase_c.c b/user/apps/fuse_demo/test_fuse_phase_c.c deleted file mode 100644 index 4a4df77588..0000000000 --- a/user/apps/fuse_demo/test_fuse_phase_c.c +++ /dev/null @@ -1,163 +0,0 @@ -/** - * @file test_fuse_phase_c.c - * @brief Phase C integration test: LOOKUP/GETATTR/READDIR/OPEN/READ path. - */ - -#include "fuse_test_simplefs.h" - -static int read_all(const char *path, char *buf, size_t cap) { - int fd = open(path, O_RDONLY); - if (fd < 0) - return -1; - ssize_t n = read(fd, buf, cap); - close(fd); - if (n < 0) - return -1; - return (int)n; -} - -int main(void) { - const char *mp = "/tmp/test_fuse_c"; - if (ensure_dir(mp) != 0) { - printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - return 1; - } - - int fd = open("/dev/fuse", O_RDWR); - if (fd < 0) { - printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); - return 1; - } - - volatile int stop = 0; - volatile int init_done = 0; - struct fuse_daemon_args args; - memset(&args, 0, sizeof(args)); - args.fd = fd; - args.stop = &stop; - args.init_done = &init_done; - args.enable_write_ops = 0; - - pthread_t th; - if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { - printf("[FAIL] pthread_create\n"); - close(fd); - return 1; - } - - char opts[256]; - snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); - FUSE_TEST_LOG("step: mount start"); - if (mount("none", mp, "fuse", 0, opts) != 0) { - printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - FUSE_TEST_LOG("step: mount ok"); - - /* wait init */ - for (int i = 0; i < 100; i++) { - if (init_done) - break; - usleep(10 * 1000); - } - if (!init_done) { - printf("[FAIL] init handshake timeout\n"); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - FUSE_TEST_LOG("step: init ok"); - - /* readdir */ - FUSE_TEST_LOG("step: opendir start"); - DIR *d = opendir(mp); - if (!d) { - printf("[FAIL] opendir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - FUSE_TEST_LOG("step: readdir loop start"); - int found = 0; - struct dirent *de; - while ((de = readdir(d)) != NULL) { - if (strcmp(de->d_name, "hello.txt") == 0) { - found = 1; - break; - } - } - FUSE_TEST_LOG("step: readdir loop end"); - closedir(d); - if (!found) { - printf("[FAIL] readdir: hello.txt not found\n"); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - - /* stat + cat */ - char p[256]; - snprintf(p, sizeof(p), "%s/hello.txt", mp); - - struct stat st; - FUSE_TEST_LOG("step: stat start"); - if (stat(p, &st) != 0) { - printf("[FAIL] stat(%s): %s (errno=%d)\n", p, strerror(errno), errno); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - FUSE_TEST_LOG("step: stat ok"); - if (!S_ISREG(st.st_mode)) { - printf("[FAIL] stat: expected regular file\n"); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - - char buf[128]; - FUSE_TEST_LOG("step: read start"); - int n = read_all(p, buf, sizeof(buf) - 1); - if (n < 0) { - printf("[FAIL] read(%s): %s (errno=%d)\n", p, strerror(errno), errno); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - FUSE_TEST_LOG("step: read ok"); - buf[n] = '\0'; - if (strcmp(buf, "hello from fuse\n") != 0) { - printf("[FAIL] content mismatch: got='%s'\n", buf); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - - FUSE_TEST_LOG("step: umount start"); - umount(mp); - FUSE_TEST_LOG("step: umount ok"); - rmdir(mp); - FUSE_TEST_LOG("step: rmdir ok"); - stop = 1; - close(fd); - pthread_join(th, NULL); - printf("[PASS] fuse_phase_c\n"); - return 0; -} diff --git a/user/apps/fuse_demo/test_fuse_phase_d.c b/user/apps/fuse_demo/test_fuse_phase_d.c deleted file mode 100644 index 602a9f141e..0000000000 --- a/user/apps/fuse_demo/test_fuse_phase_d.c +++ /dev/null @@ -1,180 +0,0 @@ -/** - * @file test_fuse_phase_d.c - * @brief Phase D integration test: create/write/ftruncate/rename/unlink/mkdir/rmdir. - */ - -#include "fuse_test_simplefs.h" - -static int write_all(const char *path, const char *s) { - int fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644); - if (fd < 0) - return -1; - size_t len = strlen(s); - ssize_t wn = write(fd, s, len); - if (wn != (ssize_t)len) { - close(fd); - return -1; - } - close(fd); - return 0; -} - -static int read_all(const char *path, char *buf, size_t cap) { - int fd = open(path, O_RDONLY); - if (fd < 0) - return -1; - ssize_t n = read(fd, buf, cap); - close(fd); - if (n < 0) - return -1; - return (int)n; -} - -int main(void) { - const char *mp = "/tmp/test_fuse_d"; - if (ensure_dir(mp) != 0) { - printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); - return 1; - } - - int fd = open("/dev/fuse", O_RDWR); - if (fd < 0) { - printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); - return 1; - } - - volatile int stop = 0; - volatile int init_done = 0; - struct fuse_daemon_args args; - memset(&args, 0, sizeof(args)); - args.fd = fd; - args.stop = &stop; - args.init_done = &init_done; - args.enable_write_ops = 1; - - pthread_t th; - if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { - printf("[FAIL] pthread_create\n"); - close(fd); - return 1; - } - - char opts[256]; - snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); - FUSE_TEST_LOG("step: mount start"); - if (mount("none", mp, "fuse", 0, opts) != 0) { - printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - FUSE_TEST_LOG("step: mount ok"); - - for (int i = 0; i < 100; i++) { - if (init_done) - break; - usleep(10 * 1000); - } - if (!init_done) { - printf("[FAIL] init handshake timeout\n"); - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; - } - FUSE_TEST_LOG("step: init ok"); - - char p1[256]; - snprintf(p1, sizeof(p1), "%s/new.txt", mp); - FUSE_TEST_LOG("step: write_all start"); - if (write_all(p1, "abcdef") != 0) { - printf("[FAIL] write_all(%s): %s (errno=%d)\n", p1, strerror(errno), errno); - goto fail; - } - FUSE_TEST_LOG("step: write_all ok"); - - /* ftruncate to 3 */ - FUSE_TEST_LOG("step: ftruncate open start"); - int f = open(p1, O_RDWR); - if (f < 0) { - printf("[FAIL] open for truncate: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - FUSE_TEST_LOG("step: ftruncate call start"); - if (ftruncate(f, 3) != 0) { - printf("[FAIL] ftruncate: %s (errno=%d)\n", strerror(errno), errno); - close(f); - goto fail; - } - FUSE_TEST_LOG("step: ftruncate call ok"); - close(f); - FUSE_TEST_LOG("step: ftruncate close ok"); - - char buf[64]; - FUSE_TEST_LOG("step: read_all start"); - int n = read_all(p1, buf, sizeof(buf) - 1); - if (n < 0) { - printf("[FAIL] read_all after truncate: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - FUSE_TEST_LOG("step: read_all ok"); - buf[n] = '\0'; - if (strcmp(buf, "abc") != 0) { - printf("[FAIL] truncate content mismatch got='%s'\n", buf); - goto fail; - } - - /* rename */ - char p2[256]; - snprintf(p2, sizeof(p2), "%s/renamed.txt", mp); - FUSE_TEST_LOG("step: rename start"); - if (rename(p1, p2) != 0) { - printf("[FAIL] rename: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - FUSE_TEST_LOG("step: rename ok"); - - /* unlink */ - FUSE_TEST_LOG("step: unlink start"); - if (unlink(p2) != 0) { - printf("[FAIL] unlink: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - FUSE_TEST_LOG("step: unlink ok"); - - /* mkdir + rmdir */ - char d1[256]; - snprintf(d1, sizeof(d1), "%s/dir", mp); - FUSE_TEST_LOG("step: mkdir start"); - if (mkdir(d1, 0755) != 0) { - printf("[FAIL] mkdir: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - FUSE_TEST_LOG("step: mkdir ok"); - FUSE_TEST_LOG("step: rmdir start"); - if (rmdir(d1) != 0) { - printf("[FAIL] rmdir: %s (errno=%d)\n", strerror(errno), errno); - goto fail; - } - FUSE_TEST_LOG("step: rmdir ok"); - - FUSE_TEST_LOG("step: umount start"); - umount(mp); - FUSE_TEST_LOG("step: umount ok"); - rmdir(mp); - FUSE_TEST_LOG("step: rmdir mp ok"); - stop = 1; - close(fd); - pthread_join(th, NULL); - printf("[PASS] fuse_phase_d\n"); - return 0; - -fail: - umount(mp); - stop = 1; - close(fd); - pthread_join(th, NULL); - return 1; -} diff --git a/user/apps/tests/dunitest/Makefile b/user/apps/tests/dunitest/Makefile index 732e930886..a2d564b9e0 100644 --- a/user/apps/tests/dunitest/Makefile +++ b/user/apps/tests/dunitest/Makefile @@ -20,7 +20,7 @@ RESULTS_DIR = results BIN_DIR = bin # 要编译的测试套件目录列表（suites/ 下的子目录名） -SUITES = demo normal +SUITES = demo normal fuse GTEST_ROOT = third_party/googletest GTEST_REPO = https://git.mirrors.dragonos.org.cn/DragonOS-Community/googletest diff --git a/user/apps/tests/dunitest/suites/fuse/fuse_core.cc b/user/apps/tests/dunitest/suites/fuse/fuse_core.cc new file mode 100644 index 0000000000..250dd76059 --- /dev/null +++ b/user/apps/tests/dunitest/suites/fuse/fuse_core.cc @@ -0,0 +1,548 @@ +#include + +#include "fuse_gtest_common.h" + +static int core_test_nonblock_read_empty() { + int fd = open("/dev/fuse", O_RDWR | O_NONBLOCK); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + return -1; + } + + unsigned char small[FUSE_MIN_READ_BUFFER / 2]; + ssize_t n = read(fd, small, sizeof(small)); + if (n != -1 || errno != EINVAL) { + printf("[FAIL] nonblock read with small buffer: n=%zd errno=%d (%s)\n", n, errno, + strerror(errno)); + close(fd); + return -1; + } + + unsigned char *big = (unsigned char *)malloc(FUSE_TEST_BUF_SIZE); + if (!big) { + printf("[FAIL] malloc big buffer failed\n"); + close(fd); + return -1; + } + memset(big, 0, FUSE_TEST_BUF_SIZE); + + n = read(fd, big, FUSE_TEST_BUF_SIZE); + if (n != -1 || (errno != EAGAIN && errno != EWOULDBLOCK)) { + printf("[FAIL] nonblock read empty: n=%zd errno=%d (%s)\n", n, errno, strerror(errno)); + free(big); + close(fd); + return -1; + } + + struct pollfd pfd; + pfd.fd = fd; + pfd.events = POLLIN; + int pr = poll(&pfd, 1, 100); + if (pr != 0) { + printf("[FAIL] poll empty expected timeout: pr=%d revents=%x errno=%d (%s)\n", pr, + pfd.revents, errno, strerror(errno)); + free(big); + close(fd); + return -1; + } + + free(big); + close(fd); + return 0; +} + +static int core_test_mount_init_single_use_fd() { + const char *mp = "/tmp/test_fuse_mp"; + const char *mp2 = "/tmp/test_fuse_mp2"; + + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return -1; + } + if (ensure_dir(mp2) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp2, strerror(errno), errno); + rmdir(mp); + return -1; + } + + int fd = open("/dev/fuse", O_RDWR | O_NONBLOCK); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + rmdir(mp); + rmdir(mp2); + return -1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + close(fd); + rmdir(mp); + rmdir(mp2); + return -1; + } + + if (fuseg_do_init_handshake_basic(fd) != 0) { + printf("[FAIL] init handshake: %s (errno=%d)\n", strerror(errno), errno); + umount(mp); + close(fd); + rmdir(mp); + rmdir(mp2); + return -1; + } + + unsigned char *tmp = (unsigned char *)malloc(FUSE_TEST_BUF_SIZE); + if (!tmp) { + printf("[FAIL] malloc tmp buffer failed\n"); + umount(mp); + close(fd); + rmdir(mp); + rmdir(mp2); + return -1; + } + memset(tmp, 0, FUSE_TEST_BUF_SIZE); + + ssize_t rn = read(fd, tmp, FUSE_TEST_BUF_SIZE); + if (rn != -1 || (errno != EAGAIN && errno != EWOULDBLOCK)) { + printf("[FAIL] expected EAGAIN after init: rn=%zd errno=%d (%s)\n", rn, errno, + strerror(errno)); + free(tmp); + umount(mp); + close(fd); + rmdir(mp); + rmdir(mp2); + return -1; + } + free(tmp); + + if (mount("none", mp2, "fuse", 0, opts) == 0) { + printf("[FAIL] second mount with same fd unexpectedly succeeded\n"); + umount(mp); + umount(mp2); + close(fd); + rmdir(mp); + rmdir(mp2); + return -1; + } + if (errno != EINVAL) { + printf("[FAIL] second mount expected EINVAL got errno=%d (%s)\n", errno, strerror(errno)); + umount(mp); + close(fd); + rmdir(mp); + rmdir(mp2); + return -1; + } + + umount(mp); + rmdir(mp); + rmdir(mp2); + close(fd); + return 0; +} + +static int core_test_phase_c_read_path() { + const char *mp = "/tmp/test_fuse_c"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return -1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + rmdir(mp); + return -1; + } + + volatile int stop = 0; + volatile int init_done = 0; + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + rmdir(mp); + return -1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + for (int i = 0; i < 100; i++) { + if (init_done) + break; + usleep(10 * 1000); + } + if (!init_done) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + DIR *d = opendir(mp); + if (!d) { + printf("[FAIL] opendir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + int found = 0; + struct dirent *de; + while ((de = readdir(d)) != NULL) { + if (strcmp(de->d_name, "hello.txt") == 0) { + found = 1; + break; + } + } + closedir(d); + if (!found) { + printf("[FAIL] readdir: hello.txt not found\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + char p[256]; + snprintf(p, sizeof(p), "%s/hello.txt", mp); + + struct stat st; + if (stat(p, &st) != 0) { + printf("[FAIL] stat(%s): %s (errno=%d)\n", p, strerror(errno), errno); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + if (!S_ISREG(st.st_mode)) { + printf("[FAIL] stat: expected regular file\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + char buf[128]; + int n = fuseg_read_file(p, buf, sizeof(buf) - 1); + if (n < 0) { + printf("[FAIL] read(%s): %s (errno=%d)\n", p, strerror(errno), errno); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + buf[n] = '\0'; + if (strcmp(buf, "hello from fuse\n") != 0) { + printf("[FAIL] content mismatch: got='%s'\n", buf); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + umount(mp); + rmdir(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 0; +} + +static int core_test_phase_d_write_path() { + const char *mp = "/tmp/test_fuse_d"; + int f = -1; + int n = -1; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return -1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + rmdir(mp); + return -1; + } + + volatile int stop = 0; + volatile int init_done = 0; + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 1; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + rmdir(mp); + return -1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + for (int i = 0; i < 100; i++) { + if (init_done) + break; + usleep(10 * 1000); + } + if (!init_done) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + char p1[256]; + snprintf(p1, sizeof(p1), "%s/new.txt", mp); + if (fuseg_write_file(p1, "abcdef") != 0) { + printf("[FAIL] write_all(%s): %s (errno=%d)\n", p1, strerror(errno), errno); + goto fail; + } + + f = open(p1, O_RDWR); + if (f < 0) { + printf("[FAIL] open for truncate: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (ftruncate(f, 3) != 0) { + printf("[FAIL] ftruncate: %s (errno=%d)\n", strerror(errno), errno); + close(f); + goto fail; + } + close(f); + + char buf[64]; + n = fuseg_read_file(p1, buf, sizeof(buf) - 1); + if (n < 0) { + printf("[FAIL] read_all after truncate: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + buf[n] = '\0'; + if (strcmp(buf, "abc") != 0) { + printf("[FAIL] truncate content mismatch got='%s'\n", buf); + goto fail; + } + + char p2[256]; + snprintf(p2, sizeof(p2), "%s/renamed.txt", mp); + if (rename(p1, p2) != 0) { + printf("[FAIL] rename: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + + if (unlink(p2) != 0) { + printf("[FAIL] unlink: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + + char d1[256]; + snprintf(d1, sizeof(d1), "%s/dir", mp); + if (mkdir(d1, 0755) != 0) { + printf("[FAIL] mkdir: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (rmdir(d1) != 0) { + printf("[FAIL] rmdir: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + + umount(mp); + rmdir(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 0; + +fail: + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; +} + +static int core_test_lifecycle_forget_destroy() { + const char *mp = "/tmp/test_fuse_p1_lifecycle"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return -1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + rmdir(mp); + return -1; + } + + volatile int stop = 0; + volatile int init_done = 0; + volatile uint32_t forget_count = 0; + volatile uint64_t forget_nlookup_sum = 0; + volatile uint32_t destroy_count = 0; + + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + args.stop_on_destroy = 1; + args.forget_count = &forget_count; + args.forget_nlookup_sum = &forget_nlookup_sum; + args.destroy_count = &destroy_count; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + rmdir(mp); + return -1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + if (fuseg_wait_init(&init_done) != 0) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + char p[256]; + snprintf(p, sizeof(p), "%s/hello.txt", mp); + for (int i = 0; i < 8; i++) { + struct stat st; + if (stat(p, &st) != 0) { + printf("[FAIL] stat(%s): %s (errno=%d)\n", p, strerror(errno), errno); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + } + + usleep(100 * 1000); + + if (umount(mp) != 0) { + printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + for (int i = 0; i < 100; i++) { + if (destroy_count > 0) + break; + usleep(10 * 1000); + } + + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + + if (forget_count == 0 || forget_nlookup_sum == 0) { + printf("[FAIL] expected FORGET requests, got count=%u nlookup_sum=%llu\n", forget_count, + (unsigned long long)forget_nlookup_sum); + return -1; + } + + if (destroy_count == 0) { + printf("[FAIL] expected DESTROY request on umount\n"); + return -1; + } + + return 0; +} + +TEST(FuseCore, DevNonblockReadEmpty) { + ASSERT_EQ(0, core_test_nonblock_read_empty()); +} + +TEST(FuseCore, MountInitAndSingleUseFd) { + ASSERT_EQ(0, core_test_mount_init_single_use_fd()); +} + +TEST(FuseCore, ReadPathLookupGetattrReaddirOpenRead) { + ASSERT_EQ(0, core_test_phase_c_read_path()); +} + +TEST(FuseCore, WritePathCreateTruncateRenameUnlinkMkdirRmdir) { + ASSERT_EQ(0, core_test_phase_d_write_path()); +} + +TEST(FuseCore, LifecycleForgetAndDestroy) { + ASSERT_EQ(0, core_test_lifecycle_forget_destroy()); +} + +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/user/apps/tests/dunitest/suites/fuse/fuse_extended.cc b/user/apps/tests/dunitest/suites/fuse/fuse_extended.cc new file mode 100644 index 0000000000..cd674f30c5 --- /dev/null +++ b/user/apps/tests/dunitest/suites/fuse/fuse_extended.cc @@ -0,0 +1,1015 @@ +#include + +#include +#include +#include +#include + +#include "fuse_gtest_common.h" + +#ifndef FUSE_DEV_IOC_CLONE +#define FUSE_DEV_IOC_CLONE 0x80044600 +#endif + +static int ext_test_p2_ops() { + const char *mp = "/tmp/test_fuse_p2_ops"; + int f = -1; + int dfd = -1; + ssize_t tn = -1; + ssize_t rn = -1; + char hello[256]; + char created[256]; + char symlink_path[256]; + char target_buf[256]; + char hard_path[256]; + char rbuf[64]; + char dst_exist[256]; + char renamed[256]; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return -1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + rmdir(mp); + return -1; + } + + volatile int stop = 0; + volatile int init_done = 0; + volatile uint32_t access_count = 0; + volatile uint32_t flush_count = 0; + volatile uint32_t fsync_count = 0; + volatile uint32_t fsyncdir_count = 0; + volatile uint32_t create_count = 0; + volatile uint32_t rename2_count = 0; + + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 1; + args.stop_on_destroy = 1; + args.access_count = &access_count; + args.flush_count = &flush_count; + args.fsync_count = &fsync_count; + args.fsyncdir_count = &fsyncdir_count; + args.create_count = &create_count; + args.rename2_count = &rename2_count; + args.access_deny_mask = 2; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + rmdir(mp); + return -1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0,allow_other", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + if (fuseg_wait_init(&init_done) != 0) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + snprintf(hello, sizeof(hello), "%s/hello.txt", mp); + if (access(hello, R_OK) != 0) { + printf("[FAIL] access(R_OK): %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (access(hello, W_OK) == 0 || errno != EACCES) { + printf("[FAIL] access(W_OK) expected EACCES, errno=%d (%s)\n", errno, strerror(errno)); + goto fail; + } + + snprintf(created, sizeof(created), "%s/p2_create.txt", mp); + f = open(created, O_CREAT | O_RDWR, 0644); + if (f < 0) { + printf("[FAIL] open(O_CREAT): %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (fuseg_write_all_fd(f, "p2-data") != 0) { + printf("[FAIL] write created file: %s (errno=%d)\n", strerror(errno), errno); + close(f); + goto fail; + } + if (fsync(f) != 0) { + printf("[FAIL] fsync(file): %s (errno=%d)\n", strerror(errno), errno); + close(f); + goto fail; + } + close(f); + + snprintf(symlink_path, sizeof(symlink_path), "%s/p2_symlink.txt", mp); + if (symlink("p2_create.txt", symlink_path) != 0) { + printf("[FAIL] symlink: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + tn = readlink(symlink_path, target_buf, sizeof(target_buf) - 1); + if (tn <= 0) { + printf("[FAIL] readlink: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + target_buf[tn] = '\0'; + if (strcmp(target_buf, "p2_create.txt") != 0) { + printf("[FAIL] readlink target mismatch: got=%s\n", target_buf); + goto fail; + } + + snprintf(hard_path, sizeof(hard_path), "%s/p2_hard.txt", mp); + if (link(created, hard_path) != 0) { + printf("[FAIL] link: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (unlink(created) != 0) { + printf("[FAIL] unlink original: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + f = open(hard_path, O_RDONLY); + if (f < 0) { + printf("[FAIL] open hard link: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + rn = read(f, rbuf, sizeof(rbuf) - 1); + close(f); + if (rn <= 0) { + printf("[FAIL] read hard link: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + rbuf[rn] = '\0'; + if (strcmp(rbuf, "p2-data") != 0) { + printf("[FAIL] hard link content mismatch: got=%s\n", rbuf); + goto fail; + } + + snprintf(dst_exist, sizeof(dst_exist), "%s/p2_dst_exist.txt", mp); + f = open(dst_exist, O_CREAT | O_RDWR, 0644); + if (f < 0) { + printf("[FAIL] create dst_exist: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + close(f); + + if (syscall(SYS_renameat2, AT_FDCWD, hard_path, AT_FDCWD, dst_exist, RENAME_NOREPLACE) == 0 || + errno != EEXIST) { + printf("[FAIL] renameat2 NOREPLACE expected EEXIST, errno=%d (%s)\n", errno, + strerror(errno)); + goto fail; + } + + snprintf(renamed, sizeof(renamed), "%s/p2_renamed.txt", mp); + if (syscall(SYS_renameat2, AT_FDCWD, hard_path, AT_FDCWD, renamed, RENAME_NOREPLACE) != 0) { + printf("[FAIL] renameat2 NOREPLACE success path: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + + dfd = open(mp, O_RDONLY | O_DIRECTORY); + if (dfd < 0) { + printf("[FAIL] open mountpoint dirfd: %s (errno=%d)\n", strerror(errno), errno); + goto fail; + } + if (fsync(dfd) != 0) { + printf("[FAIL] fsync(dirfd): %s (errno=%d)\n", strerror(errno), errno); + close(dfd); + goto fail; + } + close(dfd); + + usleep(100 * 1000); + + if (access_count < 2 || flush_count == 0 || fsync_count == 0 || fsyncdir_count == 0 || + create_count == 0 || rename2_count < 2) { + printf("[FAIL] counters access=%u flush=%u fsync=%u fsyncdir=%u create=%u rename2=%u\n", + access_count, flush_count, fsync_count, fsyncdir_count, create_count, + rename2_count); + goto fail; + } + + if (umount(mp) != 0) { + printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + goto fail_no_umount; + } + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return 0; + +fail: + umount(mp); +fail_no_umount: + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; +} + +static void ext_sigusr1_handler(int signo) { + (void)signo; +} + +struct ext_reader_ctx { + char path[256]; + volatile int done; + ssize_t nread; + int err; +}; + +static void *ext_reader_thread(void *arg) { + struct ext_reader_ctx *ctx = (struct ext_reader_ctx *)arg; + int fd = open(ctx->path, O_RDONLY); + if (fd < 0) { + ctx->nread = -1; + ctx->err = errno; + ctx->done = 1; + return NULL; + } + + char buf[64]; + ssize_t n = read(fd, buf, sizeof(buf)); + if (n < 0) { + ctx->nread = -1; + ctx->err = errno; + } else { + ctx->nread = n; + ctx->err = 0; + } + close(fd); + ctx->done = 1; + return NULL; +} + +static int ext_test_p3_interrupt() { + struct sigaction sa; + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = ext_sigusr1_handler; + sigemptyset(&sa.sa_mask); + sa.sa_flags = 0; + + struct sigaction old_sa; + if (sigaction(SIGUSR1, &sa, &old_sa) != 0) { + printf("[FAIL] sigaction(SIGUSR1): %s (errno=%d)\n", strerror(errno), errno); + return -1; + } + + const char *mp = "/tmp/test_fuse_p3_interrupt"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + sigaction(SIGUSR1, &old_sa, NULL); + return -1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + rmdir(mp); + sigaction(SIGUSR1, &old_sa, NULL); + return -1; + } + + volatile int stop = 0; + volatile int init_done = 0; + volatile uint32_t interrupt_count = 0; + volatile uint64_t blocked_read_unique = 0; + volatile uint64_t last_interrupt_target = 0; + + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + args.stop_on_destroy = 1; + args.block_read_until_interrupt = 1000; + args.interrupt_count = &interrupt_count; + args.blocked_read_unique = &blocked_read_unique; + args.last_interrupt_target = &last_interrupt_target; + + pthread_t daemon_th; + if (pthread_create(&daemon_th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create(daemon)\n"); + close(fd); + rmdir(mp); + sigaction(SIGUSR1, &old_sa, NULL); + return -1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(daemon_th, NULL); + rmdir(mp); + sigaction(SIGUSR1, &old_sa, NULL); + return -1; + } + if (fuseg_wait_init(&init_done) != 0) { + printf("[FAIL] init handshake timeout\n"); + goto fail; + } + + struct ext_reader_ctx rctx; + memset(&rctx, 0, sizeof(rctx)); + snprintf(rctx.path, sizeof(rctx.path), "%s/hello.txt", mp); + + pthread_t reader_th; + if (pthread_create(&reader_th, NULL, ext_reader_thread, &rctx) != 0) { + printf("[FAIL] pthread_create(reader)\n"); + goto fail; + } + + for (int i = 0; i < 200; i++) { + if (blocked_read_unique != 0) { + break; + } + usleep(5 * 1000); + } + if (blocked_read_unique == 0) { + printf("[FAIL] timed out waiting for blocked read request\n"); + stop = 1; + pthread_join(reader_th, NULL); + goto fail; + } + + if (pthread_kill(reader_th, SIGUSR1) != 0) { + printf("[FAIL] pthread_kill(SIGUSR1)\n"); + stop = 1; + pthread_join(reader_th, NULL); + goto fail; + } + pthread_join(reader_th, NULL); + + if (rctx.nread != -1 || rctx.err != EINTR) { + printf("[FAIL] reader expected EINTR, nread=%zd err=%d (%s)\n", rctx.nread, rctx.err, + strerror(rctx.err)); + goto fail; + } + + for (int i = 0; i < 500; i++) { + if (interrupt_count > 0) { + break; + } + usleep(5 * 1000); + } + + if (interrupt_count == 0) { + printf("[FAIL] expected FUSE_INTERRUPT request\n"); + goto fail; + } + if (last_interrupt_target == 0 || last_interrupt_target != blocked_read_unique) { + printf("[FAIL] interrupt target mismatch: blocked=%llu interrupt_target=%llu\n", + (unsigned long long)blocked_read_unique, (unsigned long long)last_interrupt_target); + goto fail; + } + + if (umount(mp) != 0) { + printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + goto fail_no_umount; + } + stop = 1; + close(fd); + pthread_join(daemon_th, NULL); + rmdir(mp); + sigaction(SIGUSR1, &old_sa, NULL); + return 0; + +fail: + umount(mp); +fail_no_umount: + stop = 1; + close(fd); + pthread_join(daemon_th, NULL); + rmdir(mp); + sigaction(SIGUSR1, &old_sa, NULL); + return -1; +} + +static int ext_test_p3_noopen_readdirplus_notify() { + const char *mp = "/tmp/test_fuse_p3_noopen"; + ssize_t wn = -1; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return -1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + rmdir(mp); + return -1; + } + + volatile int stop = 0; + volatile int init_done = 0; + volatile uint32_t open_count = 0; + volatile uint32_t opendir_count = 0; + volatile uint32_t release_count = 0; + volatile uint32_t releasedir_count = 0; + volatile uint32_t readdirplus_count = 0; + + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + args.stop_on_destroy = 1; + args.open_count = &open_count; + args.opendir_count = &opendir_count; + args.release_count = &release_count; + args.releasedir_count = &releasedir_count; + args.readdirplus_count = &readdirplus_count; + args.force_open_enosys = 1; + args.force_opendir_enosys = 1; + args.init_out_flags_override = FUSE_INIT_EXT | FUSE_MAX_PAGES | FUSE_NO_OPEN_SUPPORT | + FUSE_NO_OPENDIR_SUPPORT | FUSE_DO_READDIRPLUS; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + rmdir(mp); + return -1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + if (fuseg_wait_init(&init_done) != 0) { + printf("[FAIL] init handshake timeout\n"); + goto fail; + } + + char file_path[256]; + snprintf(file_path, sizeof(file_path), "%s/hello.txt", mp); + for (int i = 0; i < 2; i++) { + int f = open(file_path, O_RDONLY); + if (f < 0) { + printf("[FAIL] open(%s): %s (errno=%d)\n", file_path, strerror(errno), errno); + goto fail; + } + char buf[64]; + ssize_t n = read(f, buf, sizeof(buf) - 1); + close(f); + if (n <= 0) { + printf("[FAIL] read(%s): %s (errno=%d)\n", file_path, strerror(errno), errno); + goto fail; + } + } + + for (int i = 0; i < 2; i++) { + DIR *dir = opendir(mp); + if (!dir) { + printf("[FAIL] opendir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + goto fail; + } + int saw = 0; + struct dirent *de; + while ((de = readdir(dir)) != NULL) { + if (strcmp(de->d_name, "hello.txt") == 0) { + saw = 1; + } + } + closedir(dir); + if (!saw) { + printf("[FAIL] readdir didn't see hello.txt\n"); + goto fail; + } + } + + struct { + struct fuse_out_header out; + struct fuse_notify_inval_inode_out inval; + } notify_msg; + memset(¬ify_msg, 0, sizeof(notify_msg)); + notify_msg.out.len = sizeof(notify_msg); + notify_msg.out.error = FUSE_NOTIFY_INVAL_INODE; + notify_msg.out.unique = 0; + notify_msg.inval.ino = 2; + notify_msg.inval.off = 0; + notify_msg.inval.len = -1; + wn = write(fd, ¬ify_msg, sizeof(notify_msg)); + if (wn != (ssize_t)sizeof(notify_msg)) { + printf("[FAIL] write notify: wn=%zd errno=%d (%s)\n", wn, errno, strerror(errno)); + goto fail; + } + + usleep(100 * 1000); + + if (open_count != 1 || opendir_count != 1 || release_count != 0 || releasedir_count != 0 || + readdirplus_count == 0) { + printf("[FAIL] counters open=%u opendir=%u release=%u releasedir=%u readdirplus=%u\n", + open_count, opendir_count, release_count, releasedir_count, readdirplus_count); + goto fail; + } + + if (umount(mp) != 0) { + printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + goto fail_no_umount; + } + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return 0; + +fail: + umount(mp); +fail_no_umount: + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; +} + +static int ext_test_p4_subtype_mount() { + const char *mp = "/tmp/test_fuse_p4_subtype"; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return -1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + printf("[FAIL] open(/dev/fuse): %s (errno=%d)\n", strerror(errno), errno); + rmdir(mp); + return -1; + } + + volatile int stop = 0; + volatile int init_done = 0; + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + args.stop_on_destroy = 1; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + printf("[FAIL] pthread_create\n"); + close(fd); + rmdir(mp); + return -1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", fd); + if (mount("none", mp, "fuse.fuse3_demo", 0, opts) != 0) { + printf("[FAIL] mount(fuse.fuse3_demo): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + for (int i = 0; i < 200; i++) { + if (init_done) { + break; + } + usleep(10 * 1000); + } + if (!init_done) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + char file_path[256]; + snprintf(file_path, sizeof(file_path), "%s/hello.txt", mp); + + char buf[128]; + if (fuseg_read_file_cstr(file_path, buf, sizeof(buf)) < 0) { + printf("[FAIL] read(%s): %s (errno=%d)\n", file_path, strerror(errno), errno); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + if (strcmp(buf, "hello from fuse\n") != 0) { + printf("[FAIL] content mismatch: got='%s'\n", buf); + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + if (umount(mp) != 0) { + printf("[FAIL] umount(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return 0; +} + +static int ext_run_child_drop_priv_and_stat(const char *mp, int expect_errno, int expect_success) { + pid_t pid = fork(); + if (pid < 0) { + return -1; + } + if (pid == 0) { + if (setgid(1000) != 0) { + _exit(30); + } + if (setuid(1000) != 0) { + _exit(31); + } + + struct stat st; + int r = stat(mp, &st); + if (expect_success) { + if (r != 0) + _exit(10); + char p[256]; + snprintf(p, sizeof(p), "%s/hello.txt", mp); + int fd = open(p, O_RDONLY); + if (fd < 0) + _exit(11); + char buf[64]; + ssize_t n = read(fd, buf, sizeof(buf) - 1); + close(fd); + if (n < 0) + _exit(12); + buf[n] = '\0'; + if (strcmp(buf, "hello from fuse\n") != 0) + _exit(13); + _exit(0); + } + + if (r != 0 && errno == expect_errno) { + _exit(0); + } + if (r != 0) { + _exit(21); + } + + /* + * Linux 语义下，目录本身的 stat 可能成功；真正的拒绝点通常体现在 + * 访问目录内对象（例如 open/stat 子路径）。 + */ + char p[256]; + snprintf(p, sizeof(p), "%s/hello.txt", mp); + int fd = open(p, O_RDONLY); + if (fd >= 0) { + close(fd); + _exit(22); + } + if (errno != expect_errno) { + _exit(23); + } + _exit(0); + } + + int status = 0; + if (waitpid(pid, &status, 0) < 0) { + return -1; + } + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { + errno = ECHILD; + return -1; + } + return 0; +} + +static int ext_run_permission_case(const char *mp, const char *opts, uint32_t root_mode_override, + uint32_t hello_mode_override, int expect_errno, + int expect_success) { + if (ensure_dir(mp) != 0) { + return -1; + } + + int fd = open("/dev/fuse", O_RDWR); + if (fd < 0) { + rmdir(mp); + return -1; + } + + volatile int stop = 0; + volatile int init_done = 0; + struct fuse_daemon_args args; + memset(&args, 0, sizeof(args)); + args.fd = fd; + args.stop = &stop; + args.init_done = &init_done; + args.enable_write_ops = 0; + args.exit_after_init = 0; + args.root_mode_override = root_mode_override; + args.hello_mode_override = hello_mode_override; + + pthread_t th; + if (pthread_create(&th, NULL, fuse_daemon_thread, &args) != 0) { + close(fd); + rmdir(mp); + return -1; + } + + char full_opts[512]; + snprintf(full_opts, sizeof(full_opts), "fd=%d,%s", fd, opts); + if (mount("none", mp, "fuse", 0, full_opts) != 0) { + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + if (fuseg_wait_init(&init_done) != 0) { + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + if (ext_run_child_drop_priv_and_stat(mp, expect_errno, expect_success) != 0) { + umount(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + rmdir(mp); + return -1; + } + + umount(mp); + rmdir(mp); + stop = 1; + close(fd); + pthread_join(th, NULL); + return 0; +} + +static int ext_test_permissions() { + const uint32_t DIR_NO_PERM = 0040000; + const uint32_t REG_NO_PERM = 0100000; + + { + const char *mp = "/tmp/test_fuse_perm_owner"; + if (ext_run_permission_case(mp, "rootmode=040755,user_id=0,group_id=0", 0, 0, EACCES, 0) != + 0) { + printf("[FAIL] mount owner restriction\n"); + return -1; + } + } + + { + const char *mp = "/tmp/test_fuse_perm_default"; + if (ext_run_permission_case( + mp, "rootmode=040000,user_id=0,group_id=0,allow_other,default_permissions", + DIR_NO_PERM, REG_NO_PERM, EACCES, 0) != 0) { + printf("[FAIL] default_permissions deny\n"); + return -1; + } + } + + { + const char *mp = "/tmp/test_fuse_perm_remote"; + if (ext_run_permission_case(mp, "rootmode=040000,user_id=0,group_id=0,allow_other", + DIR_NO_PERM, REG_NO_PERM, 0, 1) != 0) { + printf("[FAIL] remote permission model allow\n"); + return -1; + } + } + + return 0; +} + +static int ext_test_clone() { + const char *mp = "/tmp/test_fuse_clone"; + DIR *d = NULL; + int found = 0; + struct dirent *de = NULL; + char p[256]; + struct stat st; + char buf[128]; + int n = -1; + if (ensure_dir(mp) != 0) { + printf("[FAIL] ensure_dir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + return -1; + } + + int master_fd = open("/dev/fuse", O_RDWR); + if (master_fd < 0) { + printf("[FAIL] open(/dev/fuse master): %s (errno=%d)\n", strerror(errno), errno); + rmdir(mp); + return -1; + } + + volatile int stop = 0; + volatile int init_done = 0; + + struct fuse_daemon_args master_args; + memset(&master_args, 0, sizeof(master_args)); + master_args.fd = master_fd; + master_args.stop = &stop; + master_args.init_done = &init_done; + master_args.enable_write_ops = 0; + master_args.exit_after_init = 1; + + pthread_t master_th; + if (pthread_create(&master_th, NULL, fuse_daemon_thread, &master_args) != 0) { + printf("[FAIL] pthread_create(master)\n"); + close(master_fd); + rmdir(mp); + return -1; + } + + char opts[256]; + snprintf(opts, sizeof(opts), "fd=%d,rootmode=040755,user_id=0,group_id=0", master_fd); + if (mount("none", mp, "fuse", 0, opts) != 0) { + printf("[FAIL] mount(fuse): %s (errno=%d)\n", strerror(errno), errno); + stop = 1; + close(master_fd); + pthread_join(master_th, NULL); + rmdir(mp); + return -1; + } + + for (int i = 0; i < 100; i++) { + if (init_done) + break; + usleep(10 * 1000); + } + if (!init_done) { + printf("[FAIL] init handshake timeout\n"); + umount(mp); + stop = 1; + close(master_fd); + pthread_join(master_th, NULL); + rmdir(mp); + return -1; + } + + pthread_join(master_th, NULL); + + int clone_fd = open("/dev/fuse", O_RDWR); + if (clone_fd < 0) { + printf("[FAIL] open(/dev/fuse clone): %s (errno=%d)\n", strerror(errno), errno); + umount(mp); + close(master_fd); + rmdir(mp); + return -1; + } + + uint32_t oldfd_u32 = (uint32_t)master_fd; + if (ioctl(clone_fd, FUSE_DEV_IOC_CLONE, &oldfd_u32) != 0) { + printf("[FAIL] ioctl(FUSE_DEV_IOC_CLONE): %s (errno=%d)\n", strerror(errno), errno); + umount(mp); + close(clone_fd); + close(master_fd); + rmdir(mp); + return -1; + } + + struct fuse_daemon_args clone_args; + memset(&clone_args, 0, sizeof(clone_args)); + clone_args.fd = clone_fd; + clone_args.stop = &stop; + clone_args.init_done = &init_done; + clone_args.enable_write_ops = 0; + clone_args.exit_after_init = 0; + + pthread_t clone_th; + if (pthread_create(&clone_th, NULL, fuse_daemon_thread, &clone_args) != 0) { + printf("[FAIL] pthread_create(clone)\n"); + umount(mp); + close(clone_fd); + close(master_fd); + rmdir(mp); + return -1; + } + + d = opendir(mp); + if (!d) { + printf("[FAIL] opendir(%s): %s (errno=%d)\n", mp, strerror(errno), errno); + goto fail; + } + found = 0; + while ((de = readdir(d)) != NULL) { + if (strcmp(de->d_name, "hello.txt") == 0) { + found = 1; + break; + } + } + closedir(d); + if (!found) { + printf("[FAIL] readdir: hello.txt not found\n"); + goto fail; + } + + snprintf(p, sizeof(p), "%s/hello.txt", mp); + if (stat(p, &st) != 0) { + printf("[FAIL] stat(%s): %s (errno=%d)\n", p, strerror(errno), errno); + goto fail; + } + if (!S_ISREG(st.st_mode)) { + printf("[FAIL] stat: expected regular file\n"); + goto fail; + } + + n = fuseg_read_file_cstr(p, buf, sizeof(buf)); + if (n < 0) { + printf("[FAIL] read(%s): %s (errno=%d)\n", p, strerror(errno), errno); + goto fail; + } + if (strcmp(buf, "hello from fuse\n") != 0) { + printf("[FAIL] content mismatch: got='%s'\n", buf); + goto fail; + } + + umount(mp); + rmdir(mp); + stop = 1; + close(clone_fd); + close(master_fd); + pthread_join(clone_th, NULL); + return 0; + +fail: + umount(mp); + stop = 1; + close(clone_fd); + close(master_fd); + pthread_join(clone_th, NULL); + rmdir(mp); + return -1; +} + +TEST(FuseExtended, OpsAccessCreateSymlinkLinkRename2FlushFsync) { + ASSERT_EQ(0, ext_test_p2_ops()); +} + +TEST(FuseExtended, InterruptDeliversFuseInterrupt) { + ASSERT_EQ(0, ext_test_p3_interrupt()); +} + +TEST(FuseExtended, NoOpenNoOpendirReaddirplusNotify) { + ASSERT_EQ(0, ext_test_p3_noopen_readdirplus_notify()); +} + +TEST(FuseExtended, SubtypeMountFuseDotSubtype) { + ASSERT_EQ(0, ext_test_p4_subtype_mount()); +} + +TEST(FuseExtended, PermissionModelAllowOtherDefaultPermissions) { + if (geteuid() != 0) { + GTEST_SKIP() << "requires root to execute setuid/setgid permission cases"; + } + ASSERT_EQ(0, ext_test_permissions()); +} + +TEST(FuseExtended, DevCloneAttachAndServe) { + ASSERT_EQ(0, ext_test_clone()); +} + +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/user/apps/tests/dunitest/suites/fuse/fuse_gtest_common.h b/user/apps/tests/dunitest/suites/fuse/fuse_gtest_common.h new file mode 100644 index 0000000000..684b5acba8 --- /dev/null +++ b/user/apps/tests/dunitest/suites/fuse/fuse_gtest_common.h @@ -0,0 +1,154 @@ +#pragma once + +#include + +#include "fuse_test_simplefs_local.h" + +static inline int fuseg_wait_flag(volatile int *flag, int retries, int sleep_us) { + for (int i = 0; i < retries; i++) { + if (*flag) { + return 0; + } + usleep(sleep_us); + } + errno = ETIMEDOUT; + return -1; +} + +static inline int fuseg_wait_init(volatile int *init_done) { + return fuseg_wait_flag(init_done, 200, 10 * 1000); +} + +static inline int fuseg_wait_readable(int fd, int timeout_ms) { + struct pollfd pfd; + memset(&pfd, 0, sizeof(pfd)); + pfd.fd = fd; + pfd.events = POLLIN; + int pr = poll(&pfd, 1, timeout_ms); + if (pr < 0) { + return -1; + } + if (pr == 0) { + errno = ETIMEDOUT; + return -1; + } + if ((pfd.revents & POLLIN) == 0) { + errno = EIO; + return -1; + } + return 0; +} + +static inline int fuseg_write_all_fd(int fd, const char *s) { + size_t left = strlen(s); + const char *p = s; + while (left > 0) { + ssize_t n = write(fd, p, left); + if (n <= 0) { + return -1; + } + p += n; + left -= (size_t)n; + } + return 0; +} + +static inline int fuseg_write_file(const char *path, const char *s) { + int fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644); + if (fd < 0) { + return -1; + } + int rc = fuseg_write_all_fd(fd, s); + close(fd); + return rc; +} + +static inline int fuseg_read_file(const char *path, char *buf, size_t cap) { + int fd = open(path, O_RDONLY); + if (fd < 0) { + return -1; + } + ssize_t n = read(fd, buf, cap); + close(fd); + if (n < 0) { + return -1; + } + return (int)n; +} + +static inline int fuseg_read_file_cstr(const char *path, char *buf, size_t cap) { + int fd = open(path, O_RDONLY); + if (fd < 0) { + return -1; + } + ssize_t n = read(fd, buf, cap - 1); + int saved_errno = errno; + close(fd); + if (n < 0) { + errno = saved_errno; + return -1; + } + buf[n] = '\0'; + return (int)n; +} + +static inline int fuseg_do_init_handshake_basic(int fd) { + if (fuseg_wait_readable(fd, 1000) != 0) { + return -1; + } + + unsigned char *buf = (unsigned char *)malloc(FUSE_TEST_BUF_SIZE); + if (!buf) { + errno = ENOMEM; + return -1; + } + memset(buf, 0, FUSE_TEST_BUF_SIZE); + + ssize_t n = read(fd, buf, FUSE_TEST_BUF_SIZE); + if (n < (ssize_t)(sizeof(struct fuse_in_header) + sizeof(struct fuse_init_in))) { + free(buf); + return -1; + } + + struct fuse_in_header in_hdr; + memcpy(&in_hdr, buf, sizeof(in_hdr)); + if (in_hdr.opcode != FUSE_INIT || in_hdr.len != (uint32_t)n) { + free(buf); + errno = EPROTO; + return -1; + } + + struct fuse_init_in init_in; + memcpy(&init_in, buf + sizeof(struct fuse_in_header), sizeof(init_in)); + free(buf); + if (init_in.major != 7 || init_in.minor == 0 || (init_in.flags == 0 && init_in.flags2 == 0)) { + errno = EPROTO; + return -1; + } + + struct fuse_out_header out_hdr; + memset(&out_hdr, 0, sizeof(out_hdr)); + out_hdr.len = sizeof(struct fuse_out_header) + sizeof(struct fuse_init_out); + out_hdr.error = 0; + out_hdr.unique = in_hdr.unique; + + struct fuse_init_out init_out; + memset(&init_out, 0, sizeof(init_out)); + init_out.major = 7; + init_out.minor = 39; + init_out.flags = FUSE_INIT_EXT | FUSE_MAX_PAGES; + init_out.flags2 = 0; + init_out.max_write = 1024 * 1024; + init_out.max_pages = 256; + + unsigned char reply[sizeof(out_hdr) + sizeof(init_out)]; + memcpy(reply, &out_hdr, sizeof(out_hdr)); + memcpy(reply + sizeof(out_hdr), &init_out, sizeof(init_out)); + + ssize_t wn = write(fd, reply, sizeof(reply)); + if (wn != (ssize_t)sizeof(reply)) { + return -1; + } + + return 0; +} diff --git a/user/apps/tests/dunitest/suites/fuse/fuse_test_simplefs_local.h b/user/apps/tests/dunitest/suites/fuse/fuse_test_simplefs_local.h new file mode 100644 index 0000000000..f85dcb4c8e --- /dev/null +++ b/user/apps/tests/dunitest/suites/fuse/fuse_test_simplefs_local.h @@ -0,0 +1,1415 @@ +/* + * Minimal FUSE userspace daemon for DragonOS kernel tests (no libfuse). + * + * This header provides a tiny in-memory filesystem and request handlers for + * a subset of FUSE opcodes used by Phase C/D tests. + */ + +#pragma once + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define FUSE_TEST_LOG_PREFIX "[fuse-test] " +#define FUSE_SIMPLEFS_REV "statfs-v1" + +static inline int fuse_test_log_enabled(void) { + static int inited = 0; + static int enabled = 0; + if (!inited) { + const char *v = getenv("FUSE_TEST_LOG"); + enabled = (v && v[0] && strcmp(v, "0") != 0); + inited = 1; + } + return enabled; +} + +#define FUSE_TEST_LOG(fmt, ...) \ + do { \ + if (fuse_test_log_enabled()) { \ + fprintf(stderr, FUSE_TEST_LOG_PREFIX fmt "\n", ##__VA_ARGS__); \ + } \ + } while (0) + +#ifndef DT_DIR +#define DT_DIR 4 +#endif +#ifndef DT_REG +#define DT_REG 8 +#endif +#ifndef DT_LNK +#define DT_LNK 10 +#endif + +/* Keep test buffers off small thread stacks. */ +#define FUSE_TEST_BUF_SIZE (64 * 1024) + +/* Opcodes (subset) */ +#ifndef FUSE_LOOKUP +#define FUSE_LOOKUP 1 +#endif +#ifndef FUSE_FORGET +#define FUSE_FORGET 2 +#endif +#ifndef FUSE_GETATTR +#define FUSE_GETATTR 3 +#endif +#ifndef FUSE_SETATTR +#define FUSE_SETATTR 4 +#endif +#ifndef FUSE_READLINK +#define FUSE_READLINK 5 +#endif +#ifndef FUSE_SYMLINK +#define FUSE_SYMLINK 6 +#endif +#ifndef FUSE_MKNOD +#define FUSE_MKNOD 8 +#endif +#ifndef FUSE_MKDIR +#define FUSE_MKDIR 9 +#endif +#ifndef FUSE_UNLINK +#define FUSE_UNLINK 10 +#endif +#ifndef FUSE_RMDIR +#define FUSE_RMDIR 11 +#endif +#ifndef FUSE_RENAME +#define FUSE_RENAME 12 +#endif +#ifndef FUSE_LINK +#define FUSE_LINK 13 +#endif +#ifndef FUSE_OPEN +#define FUSE_OPEN 14 +#endif +#ifndef FUSE_READ +#define FUSE_READ 15 +#endif +#ifndef FUSE_WRITE +#define FUSE_WRITE 16 +#endif +#ifndef FUSE_STATFS +#define FUSE_STATFS 17 +#endif +#ifndef FUSE_RELEASE +#define FUSE_RELEASE 18 +#endif +#ifndef FUSE_FSYNC +#define FUSE_FSYNC 20 +#endif +#ifndef FUSE_FLUSH +#define FUSE_FLUSH 25 +#endif +#ifndef FUSE_INIT +#define FUSE_INIT 26 +#endif +#ifndef FUSE_OPENDIR +#define FUSE_OPENDIR 27 +#endif +#ifndef FUSE_READDIR +#define FUSE_READDIR 28 +#endif +#ifndef FUSE_RELEASEDIR +#define FUSE_RELEASEDIR 29 +#endif +#ifndef FUSE_FSYNCDIR +#define FUSE_FSYNCDIR 30 +#endif +#ifndef FUSE_ACCESS +#define FUSE_ACCESS 34 +#endif +#ifndef FUSE_CREATE +#define FUSE_CREATE 35 +#endif +#ifndef FUSE_INTERRUPT +#define FUSE_INTERRUPT 36 +#endif +#ifndef FUSE_DESTROY +#define FUSE_DESTROY 38 +#endif +#ifndef FUSE_READDIRPLUS +#define FUSE_READDIRPLUS 44 +#endif +#ifndef FUSE_RENAME2 +#define FUSE_RENAME2 45 +#endif + +#ifndef FUSE_MIN_READ_BUFFER +#define FUSE_MIN_READ_BUFFER 8192 +#endif + +/* INIT flags (subset) */ +#ifndef FUSE_INIT_EXT +#define FUSE_INIT_EXT (1u << 30) +#endif +#ifndef FUSE_MAX_PAGES +#define FUSE_MAX_PAGES (1u << 22) +#endif +#ifndef FUSE_DO_READDIRPLUS +#define FUSE_DO_READDIRPLUS (1u << 13) +#endif +#ifndef FUSE_READDIRPLUS_AUTO +#define FUSE_READDIRPLUS_AUTO (1u << 14) +#endif +#ifndef FUSE_NO_OPEN_SUPPORT +#define FUSE_NO_OPEN_SUPPORT (1u << 17) +#endif +#ifndef FUSE_NO_OPENDIR_SUPPORT +#define FUSE_NO_OPENDIR_SUPPORT (1u << 24) +#endif +#ifndef FUSE_FSYNC_FDATASYNC +#define FUSE_FSYNC_FDATASYNC (1u << 0) +#endif + +#ifndef FUSE_NOTIFY_INVAL_INODE +#define FUSE_NOTIFY_INVAL_INODE 2 +#endif + +#ifndef RENAME_NOREPLACE +#define RENAME_NOREPLACE (1u << 0) +#endif +#ifndef RENAME_EXCHANGE +#define RENAME_EXCHANGE (1u << 1) +#endif +#ifndef RENAME_WHITEOUT +#define RENAME_WHITEOUT (1u << 2) +#endif + +/* setattr valid bits (subset) */ +#ifndef FATTR_MODE +#define FATTR_MODE (1u << 0) +#endif +#ifndef FATTR_UID +#define FATTR_UID (1u << 1) +#endif +#ifndef FATTR_GID +#define FATTR_GID (1u << 2) +#endif +#ifndef FATTR_SIZE +#define FATTR_SIZE (1u << 3) +#endif + +struct fuse_in_header { + uint32_t len; + uint32_t opcode; + uint64_t unique; + uint64_t nodeid; + uint32_t uid; + uint32_t gid; + uint32_t pid; + uint16_t total_extlen; + uint16_t padding; +}; + +struct fuse_out_header { + uint32_t len; + int32_t error; /* -errno */ + uint64_t unique; +}; + +struct fuse_init_in { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; + uint32_t flags2; + uint32_t unused[11]; +}; + +struct fuse_init_out { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; + uint16_t max_background; + uint16_t congestion_threshold; + uint32_t max_write; + uint32_t time_gran; + uint16_t max_pages; + uint16_t map_alignment; + uint32_t flags2; + uint32_t unused[7]; +}; + +struct fuse_attr { + uint64_t ino; + uint64_t size; + uint64_t blocks; + uint64_t atime; + uint64_t mtime; + uint64_t ctime; + uint32_t atimensec; + uint32_t mtimensec; + uint32_t ctimensec; + uint32_t mode; + uint32_t nlink; + uint32_t uid; + uint32_t gid; + uint32_t rdev; + uint32_t blksize; + uint32_t flags; +}; + +struct fuse_entry_out { + uint64_t nodeid; + uint64_t generation; + uint64_t entry_valid; + uint64_t attr_valid; + uint32_t entry_valid_nsec; + uint32_t attr_valid_nsec; + struct fuse_attr attr; +}; + +struct fuse_forget_in { + uint64_t nlookup; +}; + +struct fuse_interrupt_in { + uint64_t unique; +}; + +struct fuse_getattr_in { + uint32_t getattr_flags; + uint32_t dummy; + uint64_t fh; +}; + +struct fuse_attr_out { + uint64_t attr_valid; + uint32_t attr_valid_nsec; + uint32_t dummy; + struct fuse_attr attr; +}; + +struct fuse_open_in { + uint32_t flags; + uint32_t open_flags; +}; + +struct fuse_create_in { + uint32_t flags; + uint32_t mode; + uint32_t umask; + uint32_t open_flags; +}; + +struct fuse_open_out { + uint64_t fh; + uint32_t open_flags; + uint32_t padding; +}; + +struct fuse_read_in { + uint64_t fh; + uint64_t offset; + uint32_t size; + uint32_t read_flags; + uint64_t lock_owner; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_write_in { + uint64_t fh; + uint64_t offset; + uint32_t size; + uint32_t write_flags; + uint64_t lock_owner; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_write_out { + uint32_t size; + uint32_t padding; +}; + +struct fuse_kstatfs { + uint64_t blocks; + uint64_t bfree; + uint64_t bavail; + uint64_t files; + uint64_t ffree; + uint32_t bsize; + uint32_t namelen; + uint32_t frsize; + uint32_t padding; + uint32_t spare[6]; +}; + +struct fuse_statfs_out { + struct fuse_kstatfs st; +}; + +struct fuse_release_in { + uint64_t fh; + uint32_t flags; + uint32_t release_flags; + uint64_t lock_owner; +}; + +struct fuse_flush_in { + uint64_t fh; + uint32_t unused; + uint32_t padding; + uint64_t lock_owner; +}; + +struct fuse_fsync_in { + uint64_t fh; + uint32_t fsync_flags; + uint32_t padding; +}; + +struct fuse_access_in { + uint32_t mask; + uint32_t padding; +}; + +struct fuse_mknod_in { + uint32_t mode; + uint32_t rdev; + uint32_t umask; + uint32_t padding; +}; + +struct fuse_mkdir_in { + uint32_t mode; + uint32_t umask; +}; + +struct fuse_rename_in { + uint64_t newdir; +}; + +struct fuse_rename2_in { + uint64_t newdir; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_link_in { + uint64_t oldnodeid; +}; + +struct fuse_setattr_in { + uint32_t valid; + uint32_t padding; + uint64_t fh; + uint64_t size; + uint64_t lock_owner; + uint64_t atime; + uint64_t mtime; + uint64_t ctime; + uint32_t atimensec; + uint32_t mtimensec; + uint32_t ctimensec; + uint32_t mode; + uint32_t unused4; + uint32_t uid; + uint32_t gid; + uint32_t unused5; +}; + +struct fuse_dirent { + uint64_t ino; + uint64_t off; + uint32_t namelen; + uint32_t type; + /* char name[]; */ +}; + +struct fuse_direntplus { + struct fuse_entry_out entry_out; + struct fuse_dirent dirent; + /* char name[]; */ +}; + +struct fuse_notify_inval_inode_out { + uint64_t ino; + int64_t off; + int64_t len; +}; + +static inline size_t fuse_dirent_rec_len(size_t namelen) { + size_t unaligned = sizeof(struct fuse_dirent) + namelen; + return (unaligned + 8 - 1) & ~(size_t)(8 - 1); +} + +static inline size_t fuse_direntplus_rec_len(size_t namelen) { + size_t unaligned = sizeof(struct fuse_direntplus) + namelen; + return (unaligned + 8 - 1) & ~(size_t)(8 - 1); +} + +/* ===== in-memory FS ===== */ + +#define SIMPLEFS_MAX_NODES 64 +#define SIMPLEFS_NAME_MAX 64 +#define SIMPLEFS_DATA_MAX 8192 + +struct simplefs_node { + int used; + uint64_t nodeid; + uint64_t ino; + uint64_t parent; + int is_dir; + int is_symlink; + uint32_t mode; /* includes type bits */ + char name[SIMPLEFS_NAME_MAX]; + unsigned char data[SIMPLEFS_DATA_MAX]; + size_t size; +}; + +struct simplefs { + struct simplefs_node nodes[SIMPLEFS_MAX_NODES]; + uint64_t next_nodeid; + uint64_t next_ino; +}; + +static inline void simplefs_init(struct simplefs *fs) { + memset(fs, 0, sizeof(*fs)); + fs->next_nodeid = 2; + fs->next_ino = 2; + + /* root nodeid=1 */ + fs->nodes[0].used = 1; + fs->nodes[0].nodeid = 1; + fs->nodes[0].ino = 1; + fs->nodes[0].parent = 1; + fs->nodes[0].is_dir = 1; + fs->nodes[0].is_symlink = 0; + fs->nodes[0].mode = 0040755; + strcpy(fs->nodes[0].name, ""); + fs->nodes[0].size = 0; + + /* hello.txt under root */ + fs->nodes[1].used = 1; + fs->nodes[1].nodeid = 2; + fs->nodes[1].ino = 2; + fs->nodes[1].parent = 1; + fs->nodes[1].is_dir = 0; + fs->nodes[1].is_symlink = 0; + fs->nodes[1].mode = 0100644; + strcpy(fs->nodes[1].name, "hello.txt"); + const char *msg = "hello from fuse\n"; + fs->nodes[1].size = strlen(msg); + memcpy(fs->nodes[1].data, msg, fs->nodes[1].size); + + fs->next_nodeid = 3; + fs->next_ino = 3; +} + +static inline int simplefs_mode_is_dir(uint32_t mode) { + return (mode & 0170000u) == 0040000u; +} + +static inline int simplefs_mode_is_symlink(uint32_t mode) { + return (mode & 0170000u) == 0120000u; +} + +static inline struct simplefs_node *simplefs_find_node(struct simplefs *fs, uint64_t nodeid) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (fs->nodes[i].used && fs->nodes[i].nodeid == nodeid) { + return &fs->nodes[i]; + } + } + return NULL; +} + +static inline struct simplefs_node *simplefs_find_child(struct simplefs *fs, uint64_t parent, + const char *name) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (!fs->nodes[i].used) + continue; + if (fs->nodes[i].parent != parent) + continue; + if (strcmp(fs->nodes[i].name, name) == 0) + return &fs->nodes[i]; + } + return NULL; +} + +static inline int simplefs_has_children(struct simplefs *fs, uint64_t parent) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (!fs->nodes[i].used) + continue; + if (fs->nodes[i].parent == parent) + return 1; + } + return 0; +} + +static inline struct simplefs_node *simplefs_alloc(struct simplefs *fs) { + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (!fs->nodes[i].used) { + struct simplefs_node *n = &fs->nodes[i]; + memset(n, 0, sizeof(*n)); + n->used = 1; + n->nodeid = fs->next_nodeid++; + n->ino = fs->next_ino++; + return n; + } + } + return NULL; +} + +static inline void simplefs_fill_attr(const struct simplefs_node *n, struct fuse_attr *a) { + memset(a, 0, sizeof(*a)); + a->ino = n->ino; + a->size = n->size; + a->blocks = (n->size + 511) / 512; + a->mode = n->mode; + a->nlink = simplefs_mode_is_dir(n->mode) ? 2 : 1; + a->uid = getuid(); + a->gid = getgid(); + a->blksize = 4096; +} + +static inline int fuse_write_reply(int fd, uint64_t unique, int err_neg, const void *payload, + size_t payload_len) { + struct fuse_out_header out; + memset(&out, 0, sizeof(out)); + out.len = sizeof(out) + (uint32_t)payload_len; + out.error = err_neg; + out.unique = unique; + + size_t total = sizeof(out) + payload_len; + unsigned char *buf = (unsigned char *)malloc(total); + if (!buf) { + errno = ENOMEM; + return -1; + } + memcpy(buf, &out, sizeof(out)); + if (payload_len) { + memcpy(buf + sizeof(out), payload, payload_len); + } + ssize_t wn = write(fd, buf, total); + free(buf); + if (wn == (ssize_t)total) { + FUSE_TEST_LOG("reply unique=%llu err=%d len=%zu", + (unsigned long long)unique, (int)err_neg, total); + } + if (wn != (ssize_t)total) { + return -1; + } + return 0; +} + +struct fuse_daemon_args { + int fd; + volatile int *stop; + volatile int *init_done; + int enable_write_ops; + int exit_after_init; + int stop_on_destroy; + uint32_t root_mode_override; + uint32_t hello_mode_override; + volatile uint32_t *forget_count; + volatile uint64_t *forget_nlookup_sum; + volatile uint32_t *destroy_count; + volatile uint32_t *init_in_flags; + volatile uint32_t *init_in_flags2; + volatile uint32_t *init_in_max_readahead; + volatile uint32_t *access_count; + volatile uint32_t *flush_count; + volatile uint32_t *fsync_count; + volatile uint32_t *fsyncdir_count; + volatile uint32_t *create_count; + volatile uint32_t *rename2_count; + volatile uint32_t *open_count; + volatile uint32_t *opendir_count; + volatile uint32_t *release_count; + volatile uint32_t *releasedir_count; + volatile uint32_t *readdirplus_count; + volatile uint32_t *interrupt_count; + volatile uint64_t *blocked_read_unique; + volatile uint64_t *last_interrupt_target; + uint32_t access_deny_mask; + uint32_t init_out_flags_override; + int force_open_enosys; + int force_opendir_enosys; + int block_read_until_interrupt; + struct simplefs fs; +}; + +static inline int simplefs_node_is_dir(const struct simplefs_node *n) { + return n && (n->is_dir || simplefs_mode_is_dir(n->mode)); +} + +static inline int simplefs_node_is_symlink(const struct simplefs_node *n) { + return n && (n->is_symlink || simplefs_mode_is_symlink(n->mode)); +} + +static inline uint32_t simplefs_dirent_type(const struct simplefs_node *n) { + if (simplefs_node_is_dir(n)) { + return DT_DIR; + } + if (simplefs_node_is_symlink(n)) { + return DT_LNK; + } + return DT_REG; +} + +static inline int simplefs_fill_entry_reply(struct fuse_daemon_args *a, const struct fuse_in_header *h, + const struct simplefs_node *node) { + struct fuse_entry_out out; + memset(&out, 0, sizeof(out)); + out.nodeid = node->nodeid; + simplefs_fill_attr(node, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); +} + +static inline int simplefs_parse_two_names(const unsigned char *payload, size_t payload_len, + size_t fixed_len, const char **oldname_out, + const char **newname_out) { + if (payload_len < fixed_len + 3) { + return -1; + } + const char *names = (const char *)(payload + fixed_len); + size_t names_len = payload_len - fixed_len; + const char *oldname = names; + size_t oldlen = strnlen(oldname, names_len); + if (oldlen == names_len) { + return -1; + } + const char *newname = names + oldlen + 1; + size_t remain = names_len - oldlen - 1; + if (remain == 0) { + return -1; + } + size_t newlen = strnlen(newname, remain); + if (newlen == remain) { + return -1; + } + *oldname_out = oldname; + *newname_out = newname; + return 0; +} + +static inline int simplefs_do_rename(struct fuse_daemon_args *a, const struct fuse_in_header *h, + uint64_t newdir, uint32_t flags, const char *oldname, + const char *newname) { + if ((flags & (RENAME_EXCHANGE | RENAME_WHITEOUT)) != 0) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } + struct simplefs_node *src = simplefs_find_child(&a->fs, h->nodeid, oldname); + if (!src) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + struct simplefs_node *dst_parent = simplefs_find_node(&a->fs, newdir); + if (!dst_parent || !simplefs_node_is_dir(dst_parent)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + struct simplefs_node *dst = simplefs_find_child(&a->fs, newdir, newname); + if (dst) { + if (flags & RENAME_NOREPLACE) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + src->parent = newdir; + strncpy(src->name, newname, sizeof(src->name) - 1); + src->name[sizeof(src->name) - 1] = '\0'; + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); +} + +static inline int fuse_handle_one(struct fuse_daemon_args *a, const unsigned char *req, size_t n) { + if (n < sizeof(struct fuse_in_header)) { + return -1; + } + const struct fuse_in_header *h = (const struct fuse_in_header *)req; + const unsigned char *payload = req + sizeof(*h); + size_t payload_len = n - sizeof(*h); + FUSE_TEST_LOG("handle opcode=%u unique=%llu nodeid=%llu len=%u payload=%zu", + h->opcode, (unsigned long long)h->unique, (unsigned long long)h->nodeid, + h->len, payload_len); + + switch (h->opcode) { + case FUSE_INIT: { + if (payload_len < sizeof(struct fuse_init_in)) { + return -1; + } + const struct fuse_init_in *in = (const struct fuse_init_in *)payload; + if (a->init_in_flags) + *a->init_in_flags = in->flags; + if (a->init_in_flags2) + *a->init_in_flags2 = in->flags2; + if (a->init_in_max_readahead) + *a->init_in_max_readahead = in->max_readahead; + + struct fuse_init_out out; + memset(&out, 0, sizeof(out)); + out.major = 7; + out.minor = 39; + uint32_t init_flags = a->init_out_flags_override; + if (init_flags == 0) { + init_flags = FUSE_INIT_EXT | FUSE_MAX_PAGES; + } + out.flags = init_flags; + out.flags2 = 0; + out.max_write = 4096; + out.max_pages = 32; + if (fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)) != 0) { + return -1; + } + *a->init_done = 1; + return 0; + } + case FUSE_FORGET: { + if (payload_len < sizeof(struct fuse_forget_in)) + return -1; + const struct fuse_forget_in *in = (const struct fuse_forget_in *)payload; + if (a->forget_count) + (*a->forget_count)++; + if (a->forget_nlookup_sum) + (*a->forget_nlookup_sum) += in->nlookup; + return 0; + } + case FUSE_LOOKUP: { + const char *name = (const char *)payload; + if (payload_len == 0 || name[payload_len - 1] != '\0') { + return -1; + } + struct simplefs_node *parent = simplefs_find_node(&a->fs, h->nodeid); + if (!parent || !simplefs_node_is_dir(parent)) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + struct simplefs_node *child = simplefs_find_child(&a->fs, h->nodeid, name); + if (!child) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + struct fuse_entry_out out; + memset(&out, 0, sizeof(out)); + out.nodeid = child->nodeid; + simplefs_fill_attr(child, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_GETATTR: { + (void)payload; + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + struct fuse_attr_out out; + memset(&out, 0, sizeof(out)); + simplefs_fill_attr(node, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_OPENDIR: + case FUSE_OPEN: { + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (h->opcode == FUSE_OPEN && a->open_count) { + (*a->open_count)++; + } + if (h->opcode == FUSE_OPENDIR && a->opendir_count) { + (*a->opendir_count)++; + } + if (h->opcode == FUSE_OPEN && a->force_open_enosys) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (h->opcode == FUSE_OPENDIR && a->force_opendir_enosys) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (h->opcode == FUSE_OPENDIR && !simplefs_node_is_dir(node)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (h->opcode == FUSE_OPEN && simplefs_node_is_dir(node)) { + return fuse_write_reply(a->fd, h->unique, -EISDIR, NULL, 0); + } + struct fuse_open_out out; + memset(&out, 0, sizeof(out)); + out.fh = node->nodeid; + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_READLINK: { + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (!simplefs_node_is_symlink(node)) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } + return fuse_write_reply(a->fd, h->unique, 0, node->data, node->size); + } + case FUSE_READ: { + if (payload_len < sizeof(struct fuse_read_in)) { + return -1; + } + const struct fuse_read_in *in = (const struct fuse_read_in *)payload; + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node || simplefs_node_is_dir(node) || simplefs_node_is_symlink(node)) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } + if (a->block_read_until_interrupt > 0) { + if (a->blocked_read_unique && *a->blocked_read_unique == 0) { + *a->blocked_read_unique = h->unique; + } + usleep((useconds_t)a->block_read_until_interrupt * 1000); + } + if (in->offset >= node->size) { + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } + size_t remain = node->size - (size_t)in->offset; + size_t to_copy = in->size; + if (to_copy > remain) { + to_copy = remain; + } + return fuse_write_reply(a->fd, h->unique, 0, node->data + in->offset, to_copy); + } + case FUSE_READDIR: + case FUSE_READDIRPLUS: { + if (payload_len < sizeof(struct fuse_read_in)) { + return -1; + } + const struct fuse_read_in *in = (const struct fuse_read_in *)payload; + (void)in; + int is_plus = (h->opcode == FUSE_READDIRPLUS); + if (is_plus && a->readdirplus_count) { + (*a->readdirplus_count)++; + } + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node || !simplefs_node_is_dir(node)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + + /* offset is an entry index: 0=".", 1="..", then children */ + uint64_t idx = in->offset; + unsigned char *outbuf = (unsigned char *)malloc(FUSE_TEST_BUF_SIZE); + if (!outbuf) { + return fuse_write_reply(a->fd, h->unique, -ENOMEM, NULL, 0); + } + size_t outlen = 0; + + const char *fixed_names[2] = {".", ".."}; + for (; idx < 2; idx++) { + const char *nm = fixed_names[idx]; + size_t nmlen = strlen(nm); + size_t reclen = is_plus ? fuse_direntplus_rec_len(nmlen) : fuse_dirent_rec_len(nmlen); + if (outlen + reclen > FUSE_TEST_BUF_SIZE) + break; + if (is_plus) { + struct fuse_direntplus dp; + memset(&dp, 0, sizeof(dp)); + dp.entry_out.nodeid = 1; + simplefs_fill_attr(&a->fs.nodes[0], &dp.entry_out.attr); + dp.dirent.ino = 1; + dp.dirent.off = idx + 1; + dp.dirent.namelen = (uint32_t)nmlen; + dp.dirent.type = DT_DIR; + memcpy(outbuf + outlen, &dp, sizeof(dp)); + memcpy(outbuf + outlen + sizeof(dp), nm, nmlen); + } else { + struct fuse_dirent de; + memset(&de, 0, sizeof(de)); + de.ino = 1; + de.off = idx + 1; + de.namelen = (uint32_t)nmlen; + de.type = DT_DIR; + memcpy(outbuf + outlen, &de, sizeof(de)); + memcpy(outbuf + outlen + sizeof(de), nm, nmlen); + } + outlen += reclen; + } + + /* children in insertion order */ + uint64_t child_base = 2; + uint64_t cur = idx; + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + struct simplefs_node *c = &a->fs.nodes[i]; + if (!c->used || c->parent != h->nodeid) + continue; + if (cur < child_base) { + cur = child_base; + } + if (cur > child_base) { + /* skip until we reach this entry index */ + child_base++; + continue; + } + + size_t nmlen = strlen(c->name); + size_t reclen = is_plus ? fuse_direntplus_rec_len(nmlen) : fuse_dirent_rec_len(nmlen); + if (outlen + reclen > FUSE_TEST_BUF_SIZE) + break; + if (is_plus) { + struct fuse_direntplus dp; + memset(&dp, 0, sizeof(dp)); + dp.entry_out.nodeid = c->nodeid; + simplefs_fill_attr(c, &dp.entry_out.attr); + dp.dirent.ino = c->ino; + dp.dirent.off = child_base + 1; + dp.dirent.namelen = (uint32_t)nmlen; + dp.dirent.type = simplefs_dirent_type(c); + memcpy(outbuf + outlen, &dp, sizeof(dp)); + memcpy(outbuf + outlen + sizeof(dp), c->name, nmlen); + } else { + struct fuse_dirent de; + memset(&de, 0, sizeof(de)); + de.ino = c->ino; + de.off = child_base + 1; + de.namelen = (uint32_t)nmlen; + de.type = simplefs_dirent_type(c); + memcpy(outbuf + outlen, &de, sizeof(de)); + memcpy(outbuf + outlen + sizeof(de), c->name, nmlen); + } + outlen += reclen; + + child_base++; + cur++; + } + + int ret = fuse_write_reply(a->fd, h->unique, 0, outbuf, outlen); + free(outbuf); + return ret; + } + case FUSE_STATFS: { + struct fuse_statfs_out out; + memset(&out, 0, sizeof(out)); + + unsigned used = 0; + for (int i = 0; i < SIMPLEFS_MAX_NODES; i++) { + if (a->fs.nodes[i].used) { + used++; + } + } + + out.st.blocks = 1024; + out.st.bfree = 512; + out.st.bavail = 512; + out.st.files = SIMPLEFS_MAX_NODES; + out.st.ffree = (used > SIMPLEFS_MAX_NODES) ? 0 : (SIMPLEFS_MAX_NODES - used); + out.st.bsize = 4096; + out.st.frsize = 4096; + out.st.namelen = SIMPLEFS_NAME_MAX - 1; + FUSE_TEST_LOG("statfs reply ok blocks=%llu bfree=%llu bavail=%llu", + (unsigned long long)out.st.blocks, + (unsigned long long)out.st.bfree, + (unsigned long long)out.st.bavail); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_RELEASE: + if (a->release_count) { + (*a->release_count)++; + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_RELEASEDIR: + if (a->releasedir_count) { + (*a->releasedir_count)++; + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_INTERRUPT: { + if (payload_len < sizeof(struct fuse_interrupt_in)) { + return -1; + } + const struct fuse_interrupt_in *in = (const struct fuse_interrupt_in *)payload; + if (a->interrupt_count) { + (*a->interrupt_count)++; + } + if (a->last_interrupt_target) { + *a->last_interrupt_target = in->unique; + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } + case FUSE_FLUSH: + if (a->flush_count) { + (*a->flush_count)++; + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_FSYNC: + if (a->fsync_count) { + (*a->fsync_count)++; + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_FSYNCDIR: + if (a->fsyncdir_count) { + (*a->fsyncdir_count)++; + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + case FUSE_ACCESS: { + if (payload_len < sizeof(struct fuse_access_in)) { + return -1; + } + const struct fuse_access_in *in = (const struct fuse_access_in *)payload; + if (a->access_count) { + (*a->access_count)++; + } + if ((in->mask & a->access_deny_mask) != 0) { + return fuse_write_reply(a->fd, h->unique, -EACCES, NULL, 0); + } + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } + case FUSE_DESTROY: + if (a->destroy_count) + (*a->destroy_count)++; + if (a->stop_on_destroy && a->stop) + *a->stop = 1; + return 0; + case FUSE_WRITE: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_write_in)) { + return -1; + } + const struct fuse_write_in *in = (const struct fuse_write_in *)payload; + const unsigned char *data = payload + sizeof(*in); + size_t data_len = payload_len - sizeof(*in); + if (data_len < in->size) { + return -1; + } + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node || simplefs_node_is_dir(node) || simplefs_node_is_symlink(node)) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } + if (in->offset >= SIMPLEFS_DATA_MAX) { + return fuse_write_reply(a->fd, h->unique, -EFBIG, NULL, 0); + } + size_t to_copy = in->size; + if (in->offset + to_copy > SIMPLEFS_DATA_MAX) { + to_copy = SIMPLEFS_DATA_MAX - (size_t)in->offset; + } + memcpy(node->data + in->offset, data, to_copy); + if (node->size < in->offset + to_copy) { + node->size = (size_t)in->offset + to_copy; + } + struct fuse_write_out out; + memset(&out, 0, sizeof(out)); + out.size = (uint32_t)to_copy; + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_CREATE: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_create_in) + 1) { + return -1; + } + const struct fuse_create_in *in = (const struct fuse_create_in *)payload; + const char *name = (const char *)(payload + sizeof(*in)); + if (name[payload_len - sizeof(*in) - 1] != '\0') { + return -1; + } + if (a->create_count) { + (*a->create_count)++; + } + struct simplefs_node *p = simplefs_find_node(&a->fs, h->nodeid); + if (!p || !simplefs_node_is_dir(p)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (simplefs_find_child(&a->fs, h->nodeid, name)) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + struct simplefs_node *nnode = simplefs_alloc(&a->fs); + if (!nnode) { + return fuse_write_reply(a->fd, h->unique, -ENOSPC, NULL, 0); + } + nnode->parent = h->nodeid; + nnode->is_dir = 0; + nnode->is_symlink = 0; + nnode->mode = in->mode; + strncpy(nnode->name, name, sizeof(nnode->name) - 1); + nnode->name[sizeof(nnode->name) - 1] = '\0'; + nnode->size = 0; + + struct { + struct fuse_entry_out entry; + struct fuse_open_out open_out; + } out; + memset(&out, 0, sizeof(out)); + out.entry.nodeid = nnode->nodeid; + simplefs_fill_attr(nnode, &out.entry.attr); + out.open_out.fh = nnode->nodeid; + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + case FUSE_SYMLINK: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + const char *target = (const char *)payload; + size_t target_len = strnlen(target, payload_len); + if (target_len == payload_len) { + return -1; + } + const char *name = target + target_len + 1; + size_t remain = payload_len - target_len - 1; + if (remain == 0) { + return -1; + } + size_t name_len = strnlen(name, remain); + if (name_len == remain) { + return -1; + } + struct simplefs_node *p = simplefs_find_node(&a->fs, h->nodeid); + if (!p || !simplefs_node_is_dir(p)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (simplefs_find_child(&a->fs, h->nodeid, name)) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + struct simplefs_node *nnode = simplefs_alloc(&a->fs); + if (!nnode) { + return fuse_write_reply(a->fd, h->unique, -ENOSPC, NULL, 0); + } + nnode->parent = h->nodeid; + nnode->is_dir = 0; + nnode->is_symlink = 1; + nnode->mode = 0120777; + strncpy(nnode->name, name, sizeof(nnode->name) - 1); + nnode->name[sizeof(nnode->name) - 1] = '\0'; + nnode->size = (target_len < SIMPLEFS_DATA_MAX) ? target_len : SIMPLEFS_DATA_MAX; + memcpy(nnode->data, target, nnode->size); + return simplefs_fill_entry_reply(a, h, nnode); + } + case FUSE_LINK: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_link_in) + 1) { + return -1; + } + const struct fuse_link_in *in = (const struct fuse_link_in *)payload; + const char *name = (const char *)(payload + sizeof(*in)); + if (name[payload_len - sizeof(*in) - 1] != '\0') { + return -1; + } + struct simplefs_node *src = simplefs_find_node(&a->fs, in->oldnodeid); + if (!src) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (simplefs_node_is_dir(src)) { + return fuse_write_reply(a->fd, h->unique, -EPERM, NULL, 0); + } + struct simplefs_node *dst_parent = simplefs_find_node(&a->fs, h->nodeid); + if (!dst_parent || !simplefs_node_is_dir(dst_parent)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (simplefs_find_child(&a->fs, h->nodeid, name)) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + struct simplefs_node *nnode = simplefs_alloc(&a->fs); + if (!nnode) { + return fuse_write_reply(a->fd, h->unique, -ENOSPC, NULL, 0); + } + nnode->parent = h->nodeid; + nnode->is_dir = 0; + nnode->is_symlink = src->is_symlink; + nnode->mode = src->mode; + strncpy(nnode->name, name, sizeof(nnode->name) - 1); + nnode->name[sizeof(nnode->name) - 1] = '\0'; + nnode->size = src->size; + if (nnode->size > SIMPLEFS_DATA_MAX) { + nnode->size = SIMPLEFS_DATA_MAX; + } + memcpy(nnode->data, src->data, nnode->size); + return simplefs_fill_entry_reply(a, h, nnode); + } + case FUSE_MKDIR: + case FUSE_MKNOD: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + const char *name = NULL; + size_t name_off = 0; + int is_dir = (h->opcode == FUSE_MKDIR); + uint32_t mode = 0; + if (is_dir) { + if (payload_len < sizeof(struct fuse_mkdir_in) + 1) + return -1; + const struct fuse_mkdir_in *in = (const struct fuse_mkdir_in *)payload; + mode = in->mode; + name_off = sizeof(*in); + } else { + if (payload_len < sizeof(struct fuse_mknod_in) + 1) + return -1; + const struct fuse_mknod_in *in = (const struct fuse_mknod_in *)payload; + mode = in->mode; + name_off = sizeof(*in); + } + name = (const char *)(payload + name_off); + if (name[payload_len - name_off - 1] != '\0') + return -1; + if (simplefs_find_child(&a->fs, h->nodeid, name)) { + return fuse_write_reply(a->fd, h->unique, -EEXIST, NULL, 0); + } + struct simplefs_node *p = simplefs_find_node(&a->fs, h->nodeid); + if (!p || !simplefs_node_is_dir(p)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + struct simplefs_node *nnode = simplefs_alloc(&a->fs); + if (!nnode) { + return fuse_write_reply(a->fd, h->unique, -ENOSPC, NULL, 0); + } + nnode->parent = h->nodeid; + nnode->is_dir = is_dir; + nnode->is_symlink = 0; + nnode->mode = mode; + strncpy(nnode->name, name, sizeof(nnode->name) - 1); + nnode->name[sizeof(nnode->name) - 1] = '\0'; + nnode->size = 0; + + return simplefs_fill_entry_reply(a, h, nnode); + } + case FUSE_UNLINK: + case FUSE_RMDIR: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + const char *name = (const char *)payload; + if (payload_len == 0 || name[payload_len - 1] != '\0') { + return -1; + } + struct simplefs_node *child = simplefs_find_child(&a->fs, h->nodeid, name); + if (!child) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (h->opcode == FUSE_RMDIR) { + if (!simplefs_node_is_dir(child)) { + return fuse_write_reply(a->fd, h->unique, -ENOTDIR, NULL, 0); + } + if (simplefs_has_children(&a->fs, child->nodeid)) { + return fuse_write_reply(a->fd, h->unique, -ENOTEMPTY, NULL, 0); + } + } else { + if (simplefs_node_is_dir(child)) { + return fuse_write_reply(a->fd, h->unique, -EISDIR, NULL, 0); + } + } + child->used = 0; + return fuse_write_reply(a->fd, h->unique, 0, NULL, 0); + } + case FUSE_RENAME: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + const struct fuse_rename_in *in = (const struct fuse_rename_in *)payload; + const char *oldname = NULL; + const char *newname = NULL; + if (simplefs_parse_two_names(payload, payload_len, sizeof(*in), &oldname, &newname) != 0) { + return -1; + } + return simplefs_do_rename(a, h, in->newdir, 0, oldname, newname); + } + case FUSE_RENAME2: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + const struct fuse_rename2_in *in = (const struct fuse_rename2_in *)payload; + const char *oldname = NULL; + const char *newname = NULL; + if (simplefs_parse_two_names(payload, payload_len, sizeof(*in), &oldname, &newname) != 0) { + return -1; + } + if (a->rename2_count) { + (*a->rename2_count)++; + } + return simplefs_do_rename(a, h, in->newdir, in->flags, oldname, newname); + } + case FUSE_SETATTR: { + if (!a->enable_write_ops) { + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } + if (payload_len < sizeof(struct fuse_setattr_in)) { + return -1; + } + const struct fuse_setattr_in *in = (const struct fuse_setattr_in *)payload; + struct simplefs_node *node = simplefs_find_node(&a->fs, h->nodeid); + if (!node) { + return fuse_write_reply(a->fd, h->unique, -ENOENT, NULL, 0); + } + if (simplefs_node_is_dir(node) || simplefs_node_is_symlink(node)) { + return fuse_write_reply(a->fd, h->unique, -EINVAL, NULL, 0); + } + if (in->valid & FATTR_SIZE) { + if (in->size > SIMPLEFS_DATA_MAX) { + return fuse_write_reply(a->fd, h->unique, -EFBIG, NULL, 0); + } + node->size = (size_t)in->size; + } + if (in->valid & FATTR_MODE) { + node->mode = in->mode; + } + struct fuse_attr_out out; + memset(&out, 0, sizeof(out)); + simplefs_fill_attr(node, &out.attr); + return fuse_write_reply(a->fd, h->unique, 0, &out, sizeof(out)); + } + default: + return fuse_write_reply(a->fd, h->unique, -ENOSYS, NULL, 0); + } +} + +static inline void *fuse_daemon_thread(void *arg) { + struct fuse_daemon_args *a = (struct fuse_daemon_args *)arg; + unsigned char *buf = (unsigned char *)malloc(FUSE_TEST_BUF_SIZE); + if (!buf) { + return NULL; + } + + simplefs_init(&a->fs); + if (a->root_mode_override) { + a->fs.nodes[0].mode = a->root_mode_override; + } + if (a->hello_mode_override) { + a->fs.nodes[1].mode = a->hello_mode_override; + } + + while (!*a->stop) { + FUSE_TEST_LOG("daemon read start"); + ssize_t n = read(a->fd, buf, FUSE_TEST_BUF_SIZE); + if (n < 0) { + FUSE_TEST_LOG("daemon read error n=%zd errno=%d", n, errno); + if (errno == EINTR) + continue; + if (errno == ENOTCONN) + break; + continue; + } + if (n == 0) { + FUSE_TEST_LOG("daemon read EOF"); + break; + } + FUSE_TEST_LOG("daemon read n=%zd", n); + struct fuse_in_header *h = (struct fuse_in_header *)buf; + if ((size_t)n != h->len) { + FUSE_TEST_LOG("daemon short read n=%zd hdr.len=%u", n, h->len); + continue; + } + (void)fuse_handle_one(a, buf, (size_t)n); + if (a->exit_after_init && a->init_done && *a->init_done) { + break; + } + } + free(buf); + return NULL; +} + +static inline int ensure_dir(const char *path) { + struct stat st; + if (stat(path, &st) == 0) { + if (S_ISDIR(st.st_mode)) + return 0; + errno = ENOTDIR; + return -1; + } + return mkdir(path, 0755); +} diff --git a/user/apps/tests/dunitest/whitelist.txt b/user/apps/tests/dunitest/whitelist.txt index 1dd8a54292..22c2e88a3b 100644 --- a/user/apps/tests/dunitest/whitelist.txt +++ b/user/apps/tests/dunitest/whitelist.txt @@ -2,3 +2,5 @@ # 格式: 相对于 bin/ 的用例名（去除可执行文件的 _test 后缀） demo/gtest_demo normal/capability +fuse/fuse_core +fuse/fuse_extended From 38f41c287003e60899dd4d439706f2ab62958fd1 Mon Sep 17 00:00:00 2001 From: longjin Date: Sun, 15 Feb 2026 23:30:37 +0800 Subject: [PATCH 14/16] fix(fuse): correct FUSE_DEV_IOC_CLONE constant value Signed-off-by: longjin --- kernel/src/filesystem/fuse/dev.rs | 2 +- user/apps/fuse_demo/fuse_demo.c | 2 +- user/apps/tests/dunitest/suites/fuse/fuse_extended.cc | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/kernel/src/filesystem/fuse/dev.rs b/kernel/src/filesystem/fuse/dev.rs index 988e5ea491..db10aba78d 100644 --- a/kernel/src/filesystem/fuse/dev.rs +++ b/kernel/src/filesystem/fuse/dev.rs @@ -26,7 +26,7 @@ use super::{ conn::FuseConn, private_data::{FuseDevPrivateData, FuseFilePrivateData}, }; -const FUSE_DEV_IOC_CLONE: u32 = 0x8004_4600; // _IOR('F', 0, uint32_t) +const FUSE_DEV_IOC_CLONE: u32 = 0x8004_e500; // _IOR(229, 0, uint32_t) #[derive(Debug)] pub struct FuseDevInode { diff --git a/user/apps/fuse_demo/fuse_demo.c b/user/apps/fuse_demo/fuse_demo.c index 3657f782b7..dee5a9b010 100644 --- a/user/apps/fuse_demo/fuse_demo.c +++ b/user/apps/fuse_demo/fuse_demo.c @@ -15,7 +15,7 @@ #include #ifndef FUSE_DEV_IOC_CLONE -#define FUSE_DEV_IOC_CLONE 0x80044600 /* _IOR('F', 0, uint32_t) */ +#define FUSE_DEV_IOC_CLONE 0x8004e500 /* _IOR(229, 0, uint32_t) */ #endif static volatile int g_stop = 0; diff --git a/user/apps/tests/dunitest/suites/fuse/fuse_extended.cc b/user/apps/tests/dunitest/suites/fuse/fuse_extended.cc index cd674f30c5..1a899699c4 100644 --- a/user/apps/tests/dunitest/suites/fuse/fuse_extended.cc +++ b/user/apps/tests/dunitest/suites/fuse/fuse_extended.cc @@ -8,7 +8,7 @@ #include "fuse_gtest_common.h" #ifndef FUSE_DEV_IOC_CLONE -#define FUSE_DEV_IOC_CLONE 0x80044600 +#define FUSE_DEV_IOC_CLONE 0x8004e500 #endif static int ext_test_p2_ops() { From 981f78396c54df2abf2a56e98fcfdbf9fe9701dd Mon Sep 17 00:00:00 2001 From: longjin Date: Mon, 16 Feb 2026 00:52:41 +0800 Subject: [PATCH 15/16] refactor(vfs): reorder umount operations to ensure atomicity - Move peer group unregistration after successful mountpoint detachment - Ensure filesystem notifications only occur after successful umount - Simplify mountpoint removal logic in propagation functions Signed-off-by: longjin --- kernel/src/filesystem/vfs/mount.rs | 49 ++++++++------------- kernel/src/process/namespace/propagation.rs | 10 +---- 2 files changed, 19 insertions(+), 40 deletions(-) diff --git a/kernel/src/filesystem/vfs/mount.rs b/kernel/src/filesystem/vfs/mount.rs index 94d070249d..9945a7d9fc 100644 --- a/kernel/src/filesystem/vfs/mount.rs +++ b/kernel/src/filesystem/vfs/mount.rs @@ -400,24 +400,18 @@ impl MountFS { /// # Errors /// 如果当前文件系统是根文件系统，那么将会返回`EINVAL` pub fn umount(&self) -> Result, SystemError> { - // Unregister from peer group before unmounting - let propagation = self.propagation(); - if propagation.is_shared() { - let group_id = propagation.peer_group_id(); - unregister_peer(group_id, &self.self_ref()); - } - - let r = self + let result = self .self_mountpoint() .ok_or(SystemError::EINVAL)? .do_umount(); - self.self_mountpoint.write().take(); - - // Notify the filesystem that it has been unmounted. - self.inner_filesystem.on_umount(); + // Only clear mountpoint state and notify filesystem after successful detach. + if result.is_ok() { + self.self_mountpoint.write().take(); + self.inner_filesystem.on_umount(); + } - return r; + return result; } } @@ -539,21 +533,14 @@ impl MountFSInode { let mountpoint_id = self.inner_inode.metadata()?.inode_id; - // Get the child mount that will be unmounted + // Detach first. Follow-up bookkeeping (peer registry and propagation) + // must not run if detach itself failed. let child_mount = self .mount_fs .mountpoints .lock() - .get(&mountpoint_id) - .cloned(); - - if let Some(ref child) = child_mount { - // Unregister from peer group if shared - let child_prop = child.propagation(); - if child_prop.is_shared() { - unregister_peer(child_prop.peer_group_id(), child); - } - } + .remove(&mountpoint_id) + .ok_or(SystemError::ENOENT)?; // Propagate umount to peers and slaves of the parent mount let parent_prop = self.mount_fs.propagation(); @@ -563,13 +550,13 @@ impl MountFSInode { } } - // Remove the mount - return self - .mount_fs - .mountpoints - .lock() - .remove(&mountpoint_id) - .ok_or(SystemError::ENOENT); + // Remove detached mount from peer registry if needed. + let child_prop = child_mount.propagation(); + if child_prop.is_shared() { + unregister_peer(child_prop.peer_group_id(), &child_mount); + } + + return Ok(child_mount); } #[inline(never)] diff --git a/kernel/src/process/namespace/propagation.rs b/kernel/src/process/namespace/propagation.rs index b39c62e218..55c7413d60 100644 --- a/kernel/src/process/namespace/propagation.rs +++ b/kernel/src/process/namespace/propagation.rs @@ -920,20 +920,12 @@ pub fn propagate_umount( /// Umount at a specific peer mount. fn umount_at_peer(peer_mnt: &Arc, mountpoint_id: InodeId) -> Result<(), SystemError> { - let mountpoints = peer_mnt.mountpoints(); - if let Some(child_mount) = mountpoints.get(&mountpoint_id) { - let child = child_mount.clone(); - drop(mountpoints); - + if let Some(child) = peer_mnt.mountpoints().remove(&mountpoint_id) { // Unregister the child from its peer group if shared let child_prop = child.propagation(); if child_prop.is_shared() { unregister_peer(child_prop.peer_group_id(), &child); } - - // Remove from parent's mountpoints - peer_mnt.mountpoints().remove(&mountpoint_id); - // log::debug!("umount_at_peer: removed mount at {:?}", mountpoint_id); } Ok(()) From 7d47787f105452b213edd885d6d2f62e21115985 Mon Sep 17 00:00:00 2001 From: longjin Date: Mon, 16 Feb 2026 01:27:13 +0800 Subject: [PATCH 16/16] feat(fuse): add mount setup rollback and reorder initialization - Add`rollback_mount_setup`method to revert mount state on failure - Move`mark_mounted`and`configure_mount`calls to`mount`method - Propagate`allow_other`flag via`FuseMountData` - Handle`enqueue_init`errors by rolling back mount setup Signed-off-by: longjin --- kernel/src/filesystem/fuse/conn.rs | 7 +++++++ kernel/src/filesystem/fuse/fs.rs | 16 ++++++++++++---- 2 files changed, 19 insertions(+), 4 deletions(-) diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs index 35c53dd2c8..ed7046c8d3 100644 --- a/kernel/src/filesystem/fuse/conn.rs +++ b/kernel/src/filesystem/fuse/conn.rs @@ -209,6 +209,13 @@ impl FuseConn { Ok(()) } + /// Roll back a mount reservation when mount setup fails before + /// the filesystem is actually attached to the mount tree. + pub fn rollback_mount_setup(&self) { + let mut g = self.inner.lock(); + g.mounted = false; + } + pub fn is_initialized(&self) -> bool { self.inner.lock().initialized } diff --git a/kernel/src/filesystem/fuse/fs.rs b/kernel/src/filesystem/fuse/fs.rs index aaa63c5e49..2cf7750b65 100644 --- a/kernel/src/filesystem/fuse/fs.rs +++ b/kernel/src/filesystem/fuse/fs.rs @@ -31,6 +31,7 @@ pub struct FuseMountData { pub rootmode: u32, pub user_id: u32, pub group_id: u32, + pub allow_other: bool, pub default_permissions: bool, pub conn: Arc, } @@ -190,13 +191,11 @@ impl MountableFileSystem for FuseFS { } }; - conn.configure_mount(user_id, group_id, allow_other); - conn.mark_mounted()?; - Ok(Some(Arc::new(FuseMountData { rootmode, user_id, group_id, + allow_other, default_permissions, conn, }))) @@ -231,6 +230,12 @@ impl MountableFileSystem for FuseFS { }; let conn = mount_data.conn.clone(); + conn.mark_mounted()?; + conn.configure_mount( + mount_data.user_id, + mount_data.group_id, + mount_data.allow_other, + ); let fs = Arc::new_cyclic(|weak_fs| FuseFS { root: FuseNode::new( @@ -246,7 +251,10 @@ impl MountableFileSystem for FuseFS { default_permissions: mount_data.default_permissions, }); - conn.enqueue_init()?; + if let Err(e) = conn.enqueue_init() { + conn.rollback_mount_setup(); + return Err(e); + } Ok(fs) } }