FUSE魔法：从用户态文件系统到云存储网关的全栈深度实战指南

引言：为什么需要用户态文件系统

在操作系统的经典架构中，文件系统一直运行在内核态——这意味着任何文件系统Bug都可能导致内核崩溃（Kernel Panic），开发调试极其困难。直到FUSE（Filesystem in Userspace）的出现，彻底打破了这一限制。FUSE让开发者可以在用户态实现完整的文件系统逻辑，享受用户进程的安全隔离和丰富的开发工具链，同时向用户提供标准的POSIX文件访问接口。

如今，FUSE已成为现代存储基础设施的基石：从SSHFS到GlusterFS，从S3FS到IPFS，从加密文件系统到日志审计层，几乎所有非传统存储方案都依赖FUE作为连接用户空间和内核VFS的桥梁。本文将从架构原理出发，深入剖析FUSE的核心机制，并通过大量实战代码带你掌握用户态文件系统的开发精髓。

一、FUSE架构全景解析

1.1 架构总览

FUSE本质上是一个"代理"角色，在内核中注册一个虚拟文件系统，将VFS层的文件操作请求通过字符设备（/dev/fuse）转发到用户态守护进程处理。完整的请求路径如下：

应用程序
    ↓ read()
VFS 层 (kernel)
    ↓
FUSE Kernel Module (fuse.ko)
    ↓ /dev/fuse (字符设备通信)
FUSE Daemon (用户态进程)
    ↓ 业务逻辑处理
底层存储 / 网络 / 内存

1.2 内核模块的工作机制

FUSE内核模块（fuse.ko）运行时会在/dev/fuse创建一个特殊字符设备，用户态的文件系统守护进程通过此设备与内核交换数据。通信协议基于FUSE协议，每个请求包含：

• header：包含opcode（操作类型）、unique（请求ID）、uid/gid/pid（调用者身份）、length（数据长度）
• payload：操作相关的参数（文件路径、读写缓冲区、属性结构体等）

这种设计保证了内核模块的极度精简——它只负责协议编解码和请求转发，完全不涉及文件系统逻辑，因此极少引入安全隐患。

1.3 libfuse 提供的两种API模式

libfuse为用户态开发者提供了两套API：

• High-level API：以文件路径（pathname）为参数，简单易用，适合大多数场景。例如 int fuse_fs_getattr(const char *path, struct stat *stbuf)
• Low-level API：以inode为参数，提供细粒度控制，适合需要管理硬链接、控制缓存、实现特殊文件系统语义的场景。例如 int fuse_lowlevel_ops.getattr(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)

二、30行代码实现首个FUSE文件系统

让我们从一个最简单的"Hello World"文件系统开始——一个始终返回"Hello World!"的只读伪文件：

#include <fuse3.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>

static const char *hello_content = "Hello FUSE World!\n";
static const char *hello_path = "/hello";

static int hello_getattr(const char *path, struct stat *stbuf,
                         struct fuse_file_info *fi) {
    (void) fi;
    memset(stbuf, 0, sizeof(struct stat));

    if (strcmp(path, "/") == 0) {
        stbuf->st_mode = S_IFDIR | 0755;
        stbuf->st_nlink = 2;
        return 0;
    }
    if (strcmp(path, hello_path) == 0) {
        stbuf->st_mode = S_IFREG | 0444;
        stbuf->st_nlink = 1;
        stbuf->st_size = strlen(hello_content);
        return 0;
    }
    return -ENOENT;
}

static int hello_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;
    if (strcmp(path, "/") != 0) return -ENOENT;

    filler(buf, ".", NULL, 0, 0);
    filler(buf, "..", NULL, 0, 0);
    filler(buf, hello_path + 1, NULL, 0, 0);
    return 0;
}

static int hello_open(const char *path, struct fuse_file_info *fi) {
    if (strcmp(path, hello_path) != 0) return -ENOENT;
    if ((fi->flags & O_ACCMODE) != O_RDONLY) return -EACCES;
    return 0;
}

static int hello_read(const char *path, char *buf, size_t size, off_t offset,
                      struct fuse_file_info *fi) {
    (void) fi;
    size_t len = strlen(hello_content);
    if (offset >= (off_t)len) return 0;
    if (offset + size > len) size = len - offset;
    memcpy(buf, hello_content + offset, size);
    return size;
}

static const struct fuse_operations hello_ops = {
    .getattr = hello_getattr,
    .readdir  = hello_readdir,
    .open    = hello_open,
    .read    = hello_read,
};

int main(int argc, char *argv[]) {
    return fuse_main(argc, argv, &hello_ops, NULL);
}

编译运行：gcc -Wall hello_fuse.c $(pkg-config fuse3 --cflags --libs) -o hello_fuse && ./hello_fuse /mnt/fuse -f

现在执行 cat /mnt/fuse/hello 就能看到 "Hello FUSE World!"。短短几十行代码，就实现了一个完整可用的文件系统。

三、核心操作全解析

一个生产级FUSE文件系统需要实现以下核心操作，下面我们逐一深入：

3.1 元数据操作

// getattr: 获取文件/目录属性
static int my_getattr(const char *path, struct stat *stbuf, struct fuse_file_info *fi) {
    memset(stbuf, 0, sizeof(struct stat));

    if (strcmp(path, "/") == 0) {
        stbuf->st_mode  = S_IFDIR | 0755;   // 目录权限
        stbuf->st_nlink = 2;                 // 硬链接数
        stbuf->st_uid   = getuid();           // owner uid
        stbuf->st_gid   = getgid();           // owner gid
        stbuf->st_atime = time(NULL);        // access time
        stbuf->st_mtime = time(NULL);        // modify time
        stbuf->st_ctime = time(NULL);        // change time
        return 0;
    }

    // 查数据库判断文件存在与否
    if (meta_db_lookup(path, stbuf) == 0) {
        return stbuf->st_size;
    }
    return -ENOENT;
}

// chmod/chown 操作
static int my_chmod(const char *path, mode_t mode, struct fuse_file_info *fi) {
    return meta_db_update_mode(path, mode);
}

static int my_chown(const char *path, uid_t uid, gid_t gid, struct fuse_file_info *fi) {
    return meta_db_update_owner(path, uid, gid);
}

3.2 目录操作

// readdir: 列出目录内容
static int my_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
                      off_t offset, struct fuse_file_info *fi,
                      enum fuse_readdir_flags flags) {
    filler(buf, ".",  NULL, 0, FUSE_FILL_DIR_PLUS);  // FUSE_FILL_DIR_PLUS 同时获取属性
    filler(buf, "..", NULL, 0, FUSE_FILL_DIR_PLUS);

    DirEntry *entries;
    int count = storage_list_dir(path, &entries);
    for (int i = 0; i < count; i++) {
        struct stat st;
        stat_from_entry(&entries[i], &st);
        filler(buf, entries[i].name, &st, 0, 0);
    }
    free(entries);
    return 0;
}

// mkdir/rmdir
static int my_mkdir(const char *path, mode_t mode) {
    return storage_create_dir(path, mode | S_IFDIR);
}

static int my_rmdir(const char *path) {
    return storage_remove_dir(path);  // 目录非空返回 -ENOTEMPTY
}

3.3 文件IO操作

// create/open/release
static int my_create(const char *path, mode_t mode, struct fuse_file_info *fi) {
    int fd = storage_open(path, O_CREAT | fi->flags, mode);
    if (fd < 0) return -errno;
    fi->fh = fd;  // 将文件句柄存入 fuse_file_info，后续读写直接使用
    return 0;
}

static int my_open(const char *path, struct fuse_file_info *fi) {
    int fd = storage_open(path, fi->flags, 0);
    if (fd < 0) return -errno;
    fi->fh = fd;
    return 0;
}

static int my_read(const char *path, char *buf, size_t size, off_t offset,
                   struct fuse_file_info *fi) {
    int fd = fi->fh;
    ssize_t n = pread(fd, buf, size, offset);
    return (n < 0) ? -errno : n;
}

static int my_write(const char *path, const char *buf, size_t size, off_t offset,
                    struct fuse_file_info *fi) {
    int fd = fi->fh;
    ssize_t n = pwrite(fd, buf, size, offset);
    return (n < 0) ? -errno : n;
}

// flush: 用户态fsync() 被调用时触发，确保数据持久化
static int my_flush(const char *path, struct fuse_file_info *fi) {
    return (fsync(fi->fh) == 0) ? 0 : -errno;
}

// release: 最后一个文件描述符关闭时调用
static int my_release(const char *path, struct fuse_file_info *fi) {
    return (close(fi->fh) == 0) ? 0 : -errno;
}

3.4 高级文件操作

// truncate/ftruncate
static int my_truncate(const char *path, off_t size, struct fuse_file_info *fi) {
    return (truncate(path, size) == 0) ? 0 : -errno;
}

// rename: 同一文件系统内的原子移动
static int my_rename(const char *oldpath, const char *newpath, unsigned int flags) {
    // flags 可能包含 RENAME_EXCHANGE(原子交换) 或 RENAME_NOREPLACE(目标不存在)
    return (renameat2(AT_FDCWD, oldpath, AT_FDCWD, newpath, flags) == 0) ? 0 : -errno;
}

// link/unlink (硬链接与删除)
static int my_link(const char *oldpath, const char *newpath) {
    return (link(oldpath, newpath) == 0) ? 0 : -errno;
}

static int my_unlink(const char *path) {
    return (unlink(path) == 0) ? 0 : -errno;
}

// symlink/readlink
static int my_symlink(const char *target, const char *linkpath) {
    return (symlink(target, linkpath) == 0) ? 0 : -errno;
}

// 扩展属性 (xattr) - 用于保存ACL、加密元数据等
static int my_setxattr(const char *path, const char *name, const char *value,
                       size_t size, int flags) {
    return (setxattr(path, name, value, size, flags) == 0) ? 0 : -errno;
}

四、性能优化：从零延迟到高吞吐

默认配置下，FUSE因为用户态-内核态的上下文切换和数据拷贝，吞吐量远不如内核文件系统。但通过合理的参数调优，可以达到接近原生文件系统的性能。

4.1 写回缓存（writeback_cache）

启用 -o writeback_cache 后，FUSE会缓存写操作，将小写入合并为大写入，减少用户态-内核切换次数。对于顺序写场景，吞吐量可以提升5-10倍。

// 在 mount 时通过参数启用
static struct options {
    int writeback_cache;
    int cache_timeout;
} options;

#define OPTION(t, p) { t, offsetof(struct options, p), 1 }
static const struct fuse_opt option_spec[] = {
    OPTION("--writeback_cache", writeback_cache),
    OPTION("--cache_timeout=%d", cache_timeout),
    FUSE_OPT_END
};

int main(int argc, char *argv[]) {
    struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
    fuse_opt_parse(&args, &options, option_spec, NULL);

    // 启用 writeback_cache: 内核缓存写入，延迟回写用户态
    // 副作用：断电可能丢失缓存中的数据
    if (options.writeback_cache) {
        // libfuse 自动处理写回逻辑
    }
    return fuse_main(args.argc, args.argv, &my_ops, NULL);
}

4.2 异步I/O与direct_io

libfuse 3.x版本引入了 .async_read 操作，同时支持单线程下的并发请求处理。对于需要并发读取数据库/网络的文件系统，这是关键优化：

// libfuse3 支持并发请求，只要不要在回调中修改共享状态
static int my_read(const char *path, char *buf, size_t size, off_t offset,
                   struct fuse_file_info *fi) {
    // 每个 read 调用在 libfuse 内部是独立的请求
    // 可以通过返回 FUSE_REQ_ASYNC + fuse_req_async_xxxx 实现异步完成
    return storage_read_async(fi->fh, buf, size, offset);
}

// 对于网络文件系统，推荐启用 direct_io 避免内核页缓存
static int my_open(const char *path, struct fuse_file_info *fi) {
    fi->direct_io = 1;  // 不经过内核缓存，直接写入用户态
    fi->keep_cache = 0;
    fi->auto_cache = 0;
    return 0;
}

4.3 max_readahead调优

FUSE支持预读（readahead）机制，通过 -o max_readahead=1048576（1MB）增大预读窗口，可以显著降低随机读取延迟。对于顺序读取为主的场景，推荐设置为磁盘块大小的整数倍。

4.4 多线程模式

libfuse 默认单线程处理请求（串行执行），对于多核CPU是严重浪费。启用 --mt 参数可以启用多线程模式：

gcc -DUSE_THREADS fuse_fs.c $(pkg-config fuse3 --cflags --libs) -lpthread -o fuse_fs
./fuse_fs /mnt/fuse -o allow_other -o max_threads=12

多线程模式下需要注意线程安全问题：每个操作回调函数可能在任意线程被调用，需要保护共享数据结构。

五、实战项目：加密文件系统

现在让我们综合运用上述知识，构建一个完整的透明加密文件系统。它挂载后透明地对文件进行AES-256-GCM加密，所有写入自动加密、读取自动解密，用户完全无感知。

#include <fuse3.h>
#include <openssl/evp.h>
#include <openssl/rand.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>

#define KEY_LEN  32   // AES-256
#define IV_LEN   12   // GCM IV
#define TAG_LEN  16   // GCM Auth Tag
#define HEADER_LEN (IV_LEN + 8)  // IV + 原始大小(8字节)

static unsigned char master_key[KEY_LEN];

// 从环境变量或配置文件加载密钥
static void load_master_key() {
    const char *hex_key = getenv("FUSE_ENCRYPT_KEY");
    if (!hex_key || strlen(hex_key) != KEY_LEN * 2) {
        fprintf(stderr, "请设置 FUSE_ENCRYPT_KEY 为 %d 字节的十六进制字符串\n", KEY_LEN);
        exit(1);
    }
    for (int i = 0; i < KEY_LEN; i++) {
        sscanf(hex_key + 2*i, "%2hhx", &master_key[i]);
    }
}

// 加密一个数据块
// 输入: plaintext, plaintext_len, key
// 输出: output = IV + ciphertext + TAG
// 返回: 总输出长度
static int encrypt_block(const unsigned char *plaintext, unsigned int pt_len,
                         unsigned char *output) {
    unsigned char iv[IV_LEN];
    RAND_bytes(iv, IV_LEN);

    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
    EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
    EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, IV_LEN, NULL);
    EVP_EncryptInit_ex(ctx, NULL, NULL, master_key, iv);

    // 写入IV到输出头部
    memcpy(output, iv, IV_LEN);

    int len;
    unsigned char *ct = output + IV_LEN;
    EVP_EncryptUpdate(ctx, ct, &len, plaintext, pt_len);

    int final_len;
    EVP_EncryptFinal_ex(ctx, ct + len, &final_len);

    unsigned char tag[TAG_LEN];
    EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, TAG_LEN, tag);
    memcpy(ct + len + final_len, tag, TAG_LEN);

    EVP_CIPHER_CTX_free(ctx);
    return IV_LEN + len + final_len + TAG_LEN;  // IV + ciphertext + TAG
}

// 解密一个数据块
static int decrypt_block(const unsigned char *input, unsigned int in_len,
                         unsigned char *plaintext) {
    if (in_len < IV_LEN + TAG_LEN) return -1;

    unsigned char iv[IV_LEN];
    memcpy(iv, input, IV_LEN);

    const unsigned char *ct = input + IV_LEN;
    unsigned int ct_len = in_len - IV_LEN - TAG_LEN;

    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
    EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
    EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, IV_LEN, NULL);
    EVP_DecryptInit_ex(ctx, NULL, NULL, master_key, iv);

    int len;
    EVP_DecryptUpdate(ctx, plaintext, &len, ct, ct_len);

    unsigned char tag[TAG_LEN];
    memcpy(tag, input + in_len - TAG_LEN, TAG_LEN);
    EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, TAG_LEN, tag);

    int ret = EVP_DecryptFinal_ex(ctx, plaintext + len, &len);
    EVP_CIPHER_CTX_free(ctx);

    return (ret > 0) ? (len) : -1;  // GCM 验证失败返回 -1
}

// ===== FUSE 操作实现 =====

typedef struct {
    char realpath[PATH_MAX];  // 底层真实路径
    int   real_fd;            // 底层文件描述符
} FileHandle;

static int encfs_getattr(const char *path, struct stat *st,
                         struct fuse_file_info *fi) {
    FileHandle *fh = (FileHandle *)(uintptr_t)fi->fh;
    int fd = (fi->flags & O_PATH) ? AT_FDCWD : fh->real_fd;

    if (fstatat(fd, path, st, AT_SYMLINK_NOFOLLOW) == -1)
        return -errno;

    // 文件大小需要减去加密头开销（IV + TAG）
    if (S_ISREG(st->st_mode) && st->st_size > 0) {
        unsigned char hdr[HEADER_LEN];
        preat(fd, hdr, HEADER_LEN, 0);
        unsigned long long orig_size;
        memcpy(&orig_size, hdr + IV_LEN, 8);
        st->st_size = orig_size;  // 报告原始大小给上层
    }
    return 0;
}

static int encfs_read(const char *path, char *buf, size_t size, off_t offset,
                      struct fuse_file_info *fi) {
    FileHandle *fh = (FileHandle *)(uintptr_t)fi->fh;

    // 1. 读取加密文件中的密文块
    unsigned char *ciphertext = malloc(size + TAG_LEN);
    ssize_t encrypted_bytes = preat(fh->real_fd, ciphertext, size + TAG_LEN, offset);

    // 2. 解密
    int orig_size = decrypt_block(ciphertext, encrypted_bytes, (unsigned char *)buf);
    free(ciphertext);

    return (orig_size > 0) ? orig_size : 0;
}

static int encfs_write(const char *path, const char *buf, size_t size,
                       off_t offset, struct fuse_file_info *fi) {
    FileHandle *fh = (FileHandle *)(uintptr_t)fi->fh;

    // 加密数据
    unsigned char *output = malloc(size + HEADER_LEN);
    int encrypted_len = encrypt_block((unsigned char *)buf, size, output);

    // 写入密文
    ssize_t written = pwrite(fh->real_fd, output, encrypted_len, offset);
    free(output);

    return (written > 0) ? size : -errno;
}

// 完整实现省略其他操作 (mkdir, unlink, truncate 等)

int main(int argc, char *argv[]) {
    load_master_key();
    // 将剩余参数传给底层存储作为 data_dir
    return fuse_main(argc, argv, &encfs_ops, NULL);
}

使用方式：

export FUSE_ENCRYPT_KEY=$(openssl rand -hex 32)
./encfs /mnt/encrypted ~/.encrypted_storage/

挂载后，任何写入 /mnt/encrypted 的文件都会被AES-256-GCM加密存储到 ~/.encrypted_storage，即使磁盘被拆走，没有密钥也无法解密任何内容。

六、FUSE在云原生时代的应用

6.1 S3FS：将对象存储POSIX化

s3fs-fuse 是最广泛使用的云存储FUSE网关。它将AWS S3 / MinIO / Ceph RGW 等对象存储的桶映射为本地目录。实现要点包括：将对象路径映射为本地文件路径、利用FUSE缓存减少对S3 API的调用、支持大文件分块上传下载。

aws s3 mb s3://my-bucket
s3fs my-bucket /mnt/s3 -o url=https://s3.amazonaws.com -o use_cache=/tmp/s3cache

# 挂载后像普通磁盘一样操作对象存储
dd if=/dev/urandom of=/mnt/s3/large-file.bin bs=1M count=512
ls -la /mnt/s3/

6.2 JuiceFS：分布式POSIX文件系统

JuiceFS 是一个为云环境设计的分布式文件系统，它使用Redis/数据库管理元数据，S3/对象存储管理数据，通过FUSE挂载为本地POSIX文件系统。关键创新：数据和元数据分离存储、利用本地RocksDB缓存元数据、支持S3兼容对象存储后端。

6.3 MergerFS：联合文件系统方案

MergerFS将多个磁盘/网络存储合并为一个逻辑卷，自动处理磁盘扩容、负载均衡和数据冗余，是家庭NAS/小型存储集群的首选方案。

七、调试与排错技巧

7.1 使用 -f (前台) + -d (debug) 模式

./myfs /mnt/myfs -f -d

libfuse会在stderr打印每个FUSE调用的详细信息，包括请求参数和返回值，是最有效的调试方式。

7.2 fusermount 相关工具

# 查看当前挂载的 FUSE 文件系统
mount | grep fuse

# 强制卸载（当守护进程死掉时）
fusermount -u -z /mnt/myfs

# 查看/proc信息
cat /proc/$PID/fd  # 查看FUSE文件描述符
cat /proc/$PID/maps  # 查看共享内存映射

7.3 常见故障排查

• Too many open files：增加 ulimit -n 65536 或在代码中调整 rlimit
• fuse: bad mount point：确保挂载点存在且为空目录
• Stale file handle：FUSE daemon重启后inode失效，需要在daemon重启时通过 --hard_remove 和 entry_timeout=0 强制清除缓存
• 间歇性 IO Error：检查是否正确处理了 fuse_file_info 的生命周期，fi->fh必须在 release 中释放

7.4 性能诊断

# 使用 fio 测试 FUSE 文件系统性能
fio --name=randread --ioengine=libaio --iodepth=32 \
    --rw=randread --bs=4k --size=1G --numjobs=4 \
    --directory=/mnt/myfs --time_based --runtime=30

# 使用 strace 跟踪 FUSE daemon 系统调用
strace -f -e trace=read,write,pread64,pwrite64 -p $DAEMON_PID

# 使用 perf 分析热点
perf record -g -p $DAEMON_PID sleep 10
perf report --stdio

八、FUSE 3.x 最新特性

libfuse 3.x版本相比2.x带来了诸多改进：

• io_uring 支持：利用 Linux 5.1+ 的 io_uring 高效异步I/O，大幅降低上下文切换开销
• 更丰富的协议操作：新增 ioctl、poll、notify_writeback、copy_file_range 等高层操作
• bfl 锁机制改进：更高效的锁管理，减少了不必要的内存拷贝
• LPD 缓存锁定：支持在缓存失效时回调通知，而不只是依赖超时
• 更安全的默认值：默认启用 splice（零拷贝转发），禁用不安全的扩展属性

九、超越FUSE：新兴用户态存储方案

虽然FUSE统治了用户态文件系统多年，但新方案也在涌现：

• io_uring + SPDK：直接操作NVMe设备，绕过内核块层延迟
• VFIO 直通：将NVMe设备直接映射到用户态，实现接近原生的存储性能
• DAX (Direct Access)：对于PMEM/持久内存，可以通过DAX模式直接mmap到用户空间
• EROFS：增强型只读文件系统，某些场景可以替代FUSE实现透明压缩/加密

十、总结：何时选择FUSE

FUSE适合以下场景：

• 快速原型：功能需求变化频繁，不希望频繁修改内核模块
• 特殊语义：实现非标准文件系统语义（如加密、压缩、内容寻址）
• 云网存储网关：将S3/对象存储/数据库映射为本地文件系统
• 开发维护便利：使用熟悉的语言（C/Rust/Python/Go）开发，享受丰富的调试工具

FUSE不适合以下场景：

• 极致性能要求：延迟敏感型数据库（建议内核文件系统或SPDK）
• 高并发小文件：每次操作都涉及内核-用户态切换
• 底层块设备操作：FUSE工作在文件系统层而非块设备层

总的来说，FUSE是Linux生态系统中最强大的"造轮子"工具——它让你用写用户进程的方式构建文件系统，用写文件操作的方式重塑存储架构。掌握了FUSE，就掌握了在存储领域自由创新的钥匙。

本文的全部示例代码可在 GitHub 仓库 github.com/example/fuse-deep-dive 获取。推荐延伸阅读：libfuse 官方文档、Linux 内核 fs/fuse/ 源码、以及 Google FUSE-Based File Systems 技术报告。