C++ FUSE (Filesystem in Userspace)：用 C++ 实现自定义文件系统

哈喽，各位好！今天咱们来聊聊一个挺酷的东西：C++ FUSE，也就是用 C++ 实现自定义文件系统。想象一下，你可以像搭积木一样，定义文件怎么存储，怎么读取，甚至可以把网络上的数据变成一个文件系统！听起来是不是有点小激动？

什么是 FUSE？

FUSE (Filesystem in Userspace) 顾名思义，就是在用户空间实现的文件系统。 传统的内核文件系统需要修改内核代码，这风险很大，而且需要很高的权限。 FUSE 厉害的地方在于，它提供了一个桥梁，让用户空间的程序也能参与到文件系统的运作中来。

你可以把 FUSE 看成一个中间人，它负责接收来自内核的文件系统请求（比如打开文件、读取文件、写入文件），然后把这些请求转发给你的用户空间程序。 你的程序处理完这些请求后，再把结果返回给 FUSE， FUSE 最终把结果返回给内核。

为什么要用 C++？

当然，你可以用任何你喜欢的语言来写 FUSE 文件系统。但是 C++ 有一些优势：

• 性能: C++ 性能高，尤其是在处理大量文件 I/O 操作的时候，这很重要。
• 控制力: C++ 给你更多的底层控制权，可以更好地管理内存和资源。
• 库支持: 有很多优秀的 C++ 库可以帮助你开发文件系统，比如 Boost。

FUSE 的基本原理

FUSE 的核心在于它的 API。 你需要实现一些关键的函数，这些函数会在文件系统操作发生时被调用。 比如：

• getattr: 获取文件或目录的属性（大小、权限、修改时间等等）。
• readdir: 读取目录下的文件列表。
• open: 打开文件。
• read: 读取文件内容。
• write: 写入文件内容。
• create: 创建文件。
• mkdir: 创建目录。
• unlink: 删除文件。
• rmdir: 删除目录。

等等…

这些函数就像文件系统的“接口”，你的程序需要按照 FUSE 的规范来实现它们。

一个简单的例子：Hello World 文件系统

咱们先从一个最简单的例子开始，创建一个 "Hello World" 文件系统。 这个文件系统只有一个文件，名叫 "hello.txt"，里面的内容是 "Hello, FUSE!"。

#define FUSE_USE_VERSION 31

#include <fuse.h>
#include <iostream>
#include <string>
#include <cstring>
#include <errno.h>

static const char *hello_str = "Hello, FUSE!n";
static const char *hello_path = "/hello.txt";

static int getattr_callback(const char *path, struct stat *stbuf) {
    memset(stbuf, 0, sizeof(struct stat));
    if (strcmp(path, "/") == 0) {
        stbuf->st_mode = S_IFDIR | 0755;
        stbuf->st_nlink = 2;
        return 0;
    } else if (strcmp(path, hello_path) == 0) {
        stbuf->st_mode = S_IFREG | 0444;
        stbuf->st_nlink = 1;
        stbuf->st_size = strlen(hello_str);
        return 0;
    }
    return -ENOENT;
}

static int readdir_callback(const char *path, void *buf, fuse_fill_dir_t filler,
                             off_t offset, struct fuse_file_info *fi) {
    (void) offset;
    (void) fi;

    if (strcmp(path, "/") != 0)
        return -ENOENT;

    filler(buf, ".", NULL, 0);
    filler(buf, "..", NULL, 0);
    filler(buf, hello_path + 1, NULL, 0); // Remove leading slash

    return 0;
}

static int open_callback(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 read_callback(const char *path, char *buf, size_t size, off_t offset,
                            struct fuse_file_info *fi) {
    size_t len;
    (void) fi;
    if(strcmp(path, hello_path) != 0)
        return -ENOENT;

    len = strlen(hello_str);
    if (offset < len) {
        if (offset + size > len)
            size = len - offset;
        memcpy(buf, hello_str + offset, size);
    } else
        size = 0;

    return size;
}

static struct fuse_operations hello_oper = {
    .getattr = getattr_callback,
    .readdir = readdir_callback,
    .open    = open_callback,
    .read    = read_callback,
};

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

代码解释:

• #define FUSE_USE_VERSION 31: 指定 FUSE API 的版本。
• #include <fuse.h>: 包含 FUSE 头文件，里面定义了 FUSE API。
• hello_str 和 hello_path: 定义了文件内容和文件路径。
• getattr_callback: 获取文件属性。 如果请求的是根目录 /，返回目录属性； 如果请求的是 /hello.txt，返回文件属性； 否则返回 ENOENT (文件不存在)。
• readdir_callback: 读取目录内容。 如果请求的是根目录 /，返回 . (当前目录), .. (父目录), 和 hello.txt。
• open_callback: 打开文件。 检查文件路径是否正确，以及是否以只读方式打开。
• read_callback: 读取文件内容。 把 hello_str 的内容复制到 buf 中。
• hello_oper: 一个 fuse_operations 结构体，把上面定义的函数指针关联起来。
• fuse_main: FUSE 的主函数，负责初始化 FUSE，处理请求，并调用你定义的函数。

编译和运行:

1. 安装 FUSE: 在 Linux 上，通常可以使用 apt-get install libfuse3-dev 或 yum install fuse3-devel 来安装 FUSE 开发包。 在 macOS 上，可以使用 Homebrew 安装： brew install osxfuse。
2. 编译: 使用 g++ -o hello hello.cpp -Wall -Wextra -std=c++11 -lfuse3 命令编译代码。
3. 创建挂载点: 创建一个目录，用来挂载文件系统，比如 mkdir mnt。
4. 运行: 使用 ./hello mnt 命令运行程序，把文件系统挂载到 mnt 目录。

现在，你可以进入 mnt 目录，看到一个 hello.txt 文件。 你可以用 cat mnt/hello.txt 命令查看文件内容，会显示 "Hello, FUSE!"。

更复杂的例子：内存文件系统

上面的例子只是一个静态的文件系统，文件内容是固定的。 让我们做一个更高级的例子：一个内存文件系统。 这个文件系统把所有文件都存储在内存中，你可以动态地创建、删除和修改文件。

#define FUSE_USE_VERSION 31

#include <fuse.h>
#include <iostream>
#include <string>
#include <cstring>
#include <errno.h>
#include <unordered_map>
#include <sstream>

struct FileData {
    std::string content;
    time_t last_modified;
};

static std::unordered_map<std::string, FileData> files;
static std::unordered_map<std::string, std::unordered_map<std::string, bool>> directories; // dir -> {filename -> exists}

static time_t current_time() {
    return time(nullptr);
}

static int getattr_callback(const char *path, struct stat *stbuf) {
    memset(stbuf, 0, sizeof(struct stat));

    std::string path_str(path);

    if (path_str == "/") {
        stbuf->st_mode = S_IFDIR | 0755;
        stbuf->st_nlink = 2;
        stbuf->st_atime = current_time();
        stbuf->st_mtime = current_time();
        stbuf->st_ctime = current_time();
        return 0;
    }

    if (files.count(path_str)) {
        stbuf->st_mode = S_IFREG | 0644;
        stbuf->st_nlink = 1;
        stbuf->st_size = files[path_str].content.size();
        stbuf->st_atime = current_time();
        stbuf->st_mtime = files[path_str].last_modified;
        stbuf->st_ctime = files[path_str].last_modified;
        return 0;
    }

    if (directories.count(path_str)) {
        stbuf->st_mode = S_IFDIR | 0755;
        stbuf->st_nlink = 2;  // For "." and ".."
        stbuf->st_atime = current_time();
        stbuf->st_mtime = current_time();
        stbuf->st_ctime = current_time();
        return 0;
    }

    return -ENOENT;
}

static int readdir_callback(const char *path, void *buf, fuse_fill_dir_t filler,
                             off_t offset, struct fuse_file_info *fi) {
    (void) offset;
    (void) fi;

    std::string path_str(path);

    filler(buf, ".", NULL, 0);
    filler(buf, "..", NULL, 0);

    if (path_str == "/") {
        for (const auto& [filepath, filedata] : files) {
            if (filepath.find("/", 1) == std::string::npos) { // Only list files directly under root
                filler(buf, filepath.substr(1).c_str(), NULL, 0);
            }
        }

        for (const auto& [dirpath, contents] : directories) {
            if (dirpath.find("/", 1) == std::string::npos) {
                filler(buf, dirpath.substr(1).c_str(), NULL, 0);
            }
        }
        return 0;
    }

    if (directories.count(path_str)) {
        for (const auto& [filename, exists] : directories[path_str]) {
            if (exists) {
                filler(buf, filename.c_str(), NULL, 0);
            }
        }
        return 0;
    }

    return -ENOENT;
}

static int open_callback(const char *path, struct fuse_file_info *fi) {
    std::string path_str(path);

    if (!files.count(path_str) && (fi->flags & O_CREAT) == 0)
        return -ENOENT;

    return 0;
}

static int read_callback(const char *path, char *buf, size_t size, off_t offset,
                            struct fuse_file_info *fi) {
    std::string path_str(path);

    if (!files.count(path_str))
        return -ENOENT;

    size_t len = files[path_str].content.size();
    if (offset < len) {
        if (offset + size > len)
            size = len - offset;
        memcpy(buf, files[path_str].content.c_str() + offset, size);
    } else
        size = 0;

    return size;
}

static int write_callback(const char *path, const char *buf, size_t size, off_t offset,
                             struct fuse_file_info *fi) {
    std::string path_str(path);

    if (!files.count(path_str))
        return -ENOENT;

    files[path_str].content.replace(offset, size, buf, size);
    files[path_str].last_modified = current_time();

    return size;
}

static int create_callback(const char *path, mode_t mode, struct fuse_file_info *fi) {
    std::string path_str(path);

    if (files.count(path_str))
        return -EEXIST;

    FileData newFile;
    newFile.content = "";
    newFile.last_modified = current_time();
    files[path_str] = newFile;

    std::string dirpath = path_str.substr(0, path_str.find_last_of("/"));
    std::string filename = path_str.substr(path_str.find_last_of("/") + 1);

    if (!directories.count(dirpath)) {
        directories[dirpath] = {};
    }
    directories[dirpath][filename] = true;

    return 0;
}

static int unlink_callback(const char *path) {
    std::string path_str(path);

    if (!files.count(path_str))
        return -ENOENT;

    files.erase(path_str);

     std::string dirpath = path_str.substr(0, path_str.find_last_of("/"));
    std::string filename = path_str.substr(path_str.find_last_of("/") + 1);
        if(directories.count(dirpath) )
           directories[dirpath].erase(filename);

    return 0;
}

static int mkdir_callback(const char *path, mode_t mode) {
    std::string path_str(path);

    if (directories.count(path_str))
        return -EEXIST;

    directories[path_str] = {};

    std::string parent_dir = path_str.substr(0, path_str.find_last_of("/"));
    std::string dirname = path_str.substr(path_str.find_last_of("/") + 1);
    if(directories.count(parent_dir))
        directories[parent_dir][dirname] = true;

    return 0;
}

static int rmdir_callback(const char *path) {
    std::string path_str(path);

    if (!directories.count(path_str))
        return -ENOENT;

    if (!directories[path_str].empty())
        return -ENOTEMPTY;

    directories.erase(path_str);
    std::string parent_dir = path_str.substr(0, path_str.find_last_of("/"));
    std::string dirname = path_str.substr(path_str.find_last_of("/") + 1);
    if(directories.count(parent_dir))
        directories[parent_dir].erase(dirname);

    return 0;
}

static struct fuse_operations memfs_oper = {
    .getattr = getattr_callback,
    .readdir = readdir_callback,
    .open    = open_callback,
    .read    = read_callback,
    .write   = write_callback,
    .create  = create_callback,
    .unlink  = unlink_callback,
    .mkdir   = mkdir_callback,
    .rmdir   = rmdir_callback,
};

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

代码解释:

• files: 一个 unordered_map，用于存储文件数据。 Key 是文件路径，Value 是 FileData 结构体，包含文件内容和最后修改时间。
• directories: 一个嵌套的 unordered_map，存储目录结构。 第一层key是目录路径，第二层key是文件名，value 是是否存在。
• current_time: 一个简单的函数，返回当前时间。
• getattr_callback: 除了根目录和 /hello.txt，现在还要检查 files 中是否存在请求的文件，如果存在，返回文件属性。
• readdir_callback: 除了 . 和 ..，现在要遍历 files，把所有文件和目录添加到目录列表中。
• open_callback: 如果文件不存在，返回 ENOENT。
• read_callback: 从 files 中读取文件内容。
• write_callback: 把数据写入 files 中。
• create_callback: 创建新文件，在 files 中添加一个新条目。
• unlink_callback: 删除文件，从 files 中删除对应的条目。
• mkdir_callback: 创建目录，在 directories 中添加一个条目。
• rmdir_callback: 删除目录，从 directories 中删除对应的条目。

编译和运行:

和之前的例子一样，编译和运行这个程序。 然后，你就可以像操作普通文件系统一样，在这个内存文件系统中创建、删除和修改文件。

一些更高级的技巧

• 缓存: 为了提高性能，可以使用缓存来存储文件数据和目录列表。 可以使用 LRU (Least Recently Used) 算法来管理缓存。
• 并发: FUSE 文件系统是多线程的，所以需要考虑并发问题。 可以使用互斥锁 (mutex) 来保护共享数据。
• 错误处理: 一定要仔细处理错误，并返回正确的错误码。 FUSE API 定义了很多错误码，可以参考 errno.h。
• 日志: 添加日志可以帮助你调试文件系统。 可以使用 syslog 或自定义的日志系统。
• 异步 I/O: 可以使用异步 I/O 来提高性能。 FUSE 提供了 async_read 和 async_write 函数。

FUSE 的应用场景

FUSE 的应用场景非常广泛，以下是一些常见的例子：

应用场景	描述
网络文件系统	可以把网络上的数据（比如 FTP, SSH, WebDAV）变成一个文件系统。
压缩文件系统	可以把压缩文件（比如 ZIP, GZIP）变成一个文件系统，可以直接访问压缩文件中的内容，而不需要解压缩。
加密文件系统	可以对文件进行加密和解密，保护数据的安全性。
版本控制文件系统	可以记录文件的历史版本，方便回溯和恢复。
数据库文件系统	可以把数据库的数据变成一个文件系统，方便访问和管理。
特殊设备文件系统	可以把一些特殊设备（比如摄像头、传感器）的数据变成一个文件系统，方便应用程序访问。
云存储文件系统	将云存储服务（如Amazon S3、Google Cloud Storage）挂载为本地文件系统，方便本地程序访问云端数据。
归档系统	将旧数据归档到一个FUSE文件系统，可以压缩、加密或者存储在低速存储介质上，但在需要时仍能方便地访问。
镜像文件挂载	将ISO、IMG等镜像文件挂载为可读文件系统，可以直接访问镜像文件中的内容。
用户态RAID实现	在用户态实现RAID功能，将多个磁盘组合成一个逻辑卷，提供冗余和性能提升。
虚拟文件系统（Overlay）	将多个目录合并成一个虚拟目录，实现文件的覆盖和合并。例如，用于Docker镜像分层存储。
文件系统快照	创建文件系统的快照，允许用户访问文件系统在某个时间点的状态。

总结

FUSE 是一个非常强大的工具，可以让你自由地定制文件系统。 虽然 FUSE API 有点复杂，但是只要你理解了它的基本原理，就可以创建出各种各样的文件系统。

希望今天的讲解对你有所帮助。 祝大家编程愉快！