虚拟文件系统：为什么这个抽象层统治了Linux文件访问三十年

struct super_block {
    struct list_head    s_list;         // 所有superblock的链表
    dev_t               s_dev;          // 设备标识符
    unsigned char       s_blocksize_bits; // 块大小（位数）
    unsigned long       s_blocksize;    // 块大小（字节）
    loff_t              s_maxbytes;     // 文件最大大小
    struct file_system_type *s_type;    // 文件系统类型
    const struct super_operations *s_op; // 操作函数向量
    
    unsigned long       s_flags;        // 挂载标志
    unsigned long       s_magic;        // 魔数（用于识别文件系统类型）
    struct dentry       *s_root;        // 文件系统根目录的dentry
    struct rw_semaphore s_umount;       // 卸载信号量
    int                 s_count;        // 引用计数
    // ... 更多字段
};

struct super_operations {
    struct inode *(*alloc_inode)(struct super_block *sb);
    void (*destroy_inode)(struct inode *);
    void (*dirty_inode)(struct inode *, int flags);
    int (*write_inode)(struct inode *, struct writeback_control *wbc);
    int (*drop_inode)(struct inode *);
    void (*put_super)(struct super_block *);
    int (*sync_fs)(struct super_block *sb, int wait);
    int (*statfs)(struct dentry *, struct kstatfs *);
    int (*remount_fs)(struct super_block *, int *, char *);
    // ... 更多操作
};

struct inode {
    umode_t             i_mode;     // 文件类型和权限
    unsigned short      i_opflags;  // 操作标志
    kuid_t              i_uid;      // 所有者用户ID
    kgid_t              i_gid;      // 所有者组ID
    unsigned int        i_flags;    // 文件系统标志
    
    const struct inode_operations *i_op;  // inode操作向量
    struct super_block  *i_sb;      // 所属superblock
    
    union {
        const unsigned int i_nlink; // 硬链接计数
        unsigned int __i_nlink;
    };
    
    loff_t              i_size;     // 文件大小（字节）
    struct timespec64   i_atime;    // 最后访问时间
    struct timespec64   i_mtime;    // 最后修改时间
    struct timespec64   i_ctime;    // inode最后变更时间
    
    spinlock_t          i_lock;     // 保护inode的自旋锁
    unsigned short      i_bytes;    // 已使用的字节数（不足一个块）
    u8                  i_blkbits;  // 块大小位数
    blkcnt_t            i_blocks;   // 分配的块数
    
    union {
        struct hlist_head   i_dentry;   // 指向此inode的dentry链表
        struct rcu_head     i_rcu;
    };
    
    const struct file_operations *i_fop; // 默认文件操作
    
    void                *i_private; // 文件系统私有数据
    // ... 更多字段
};

struct inode_operations {
    struct dentry * (*lookup)(struct inode *, struct dentry *, unsigned int);
    int (*create)(struct mnt_idmap *, struct inode *, struct dentry *, umode_t, bool);
    int (*link)(struct dentry *, struct inode *, struct dentry *);
    int (*unlink)(struct inode *, struct dentry *);
    int (*symlink)(struct mnt_idmap *, struct inode *, struct dentry *, const char *);
    int (*mkdir)(struct mnt_idmap *, struct inode *, struct dentry *, umode_t);
    int (*rmdir)(struct inode *, struct dentry *);
    int (*rename)(struct mnt_idmap *, struct inode *, struct dentry *,
                  struct inode *, struct dentry *, unsigned int);
    int (*permission)(struct mnt_idmap *, struct inode *, int);
    int (*getattr)(struct mnt_idmap *, const struct path *, struct kstat *, u32, unsigned int);
    int (*setattr)(struct mnt_idmap *, struct dentry *, struct iattr *);
    // ... 更多操作
};

struct dentry {
    unsigned int d_flags;           // dentry标志
    seqcount_spinlock_t d_seq;      // 序列计数（用于RCU路径查找）
    struct hlist_bl_node d_hash;    // 哈希表节点
    struct dentry *d_parent;        // 父目录dentry
    struct qstr d_name;             // 文件名（包含哈希值）
    
    struct inode *d_inode;          // 关联的inode
    unsigned char d_iname[DNAME_INLINE_LEN]; // 短文件名内联存储
    
    struct lockref d_lockref;       // 锁和引用计数
    const struct dentry_operations *d_op; // dentry操作向量
    struct super_block *d_sb;       // 所属superblock
    unsigned long d_time;           // 重新验证时间
    void *d_fsdata;                 // 文件系统私有数据
    
    union {
        struct list_head d_lru;     // LRU链表
        wait_queue_head_t *d_wait;  // 等待队列
    };
    struct list_head d_child;       // 在父目录的子项链表中
    struct list_head d_subdirs;     // 子目录链表
    // ... 更多字段
};

struct dentry_operations {
    int (*d_revalidate)(struct dentry *, unsigned int);
    int (*d_weak_revalidate)(struct dentry *, unsigned int);
    int (*d_hash)(const struct dentry *, struct qstr *);
    int (*d_compare)(const struct dentry *, unsigned int, const char *, const struct qstr *);
    int (*d_delete)(const struct dentry *);
    int (*d_init)(struct dentry *);
    void (*d_release)(struct dentry *);
    void (*d_iput)(struct dentry *, struct inode *);
    char *(*d_dname)(struct dentry *, char *, int);
    // ... 更多操作
};

struct file {
    union {
        struct llist_node   fu_llist;
        struct rcu_head     fu_rcuhead;
    } f_u;
    struct path             f_path;     // 文件路径（包含dentry和挂载点）
    struct inode            *f_inode;   // 关联的inode
    const struct file_operations *f_op; // 文件操作向量
    
    spinlock_t              f_lock;     // 保护file的自旋锁
    atomic_long_t           f_count;    // 引用计数
    unsigned int            f_flags;    // 打开标志（O_RDONLY, O_WRONLY等）
    fmode_t                 f_mode;     // 访问模式
    struct mutex            f_pos_lock; // 保护文件偏移量
    loff_t                  f_pos;      // 当前文件偏移量
    struct fown_struct      f_owner;    // 异步I/O所有者
    
    // 预读状态
    struct file_ra_state    f_ra;
    
    void                    *private_data; // 私有数据（如TTY、管道等使用）
    // ... 更多字段
};

struct file_operations {
    struct module *owner;
    loff_t (*llseek)(struct file *, loff_t, int);
    ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
    ssize_t (*read_iter)(struct kiocb *, struct iov_iter *);
    ssize_t (*write_iter)(struct kiocb *, struct iov_iter *);
    int (*iterate)(struct file *, struct dir_context *);
    int (*iterate_shared)(struct file *, struct dir_context *);
    __poll_t (*poll)(struct file *, struct poll_table_struct *);
    long (*unlocked_ioctl)(struct file *, unsigned int, unsigned long);
    long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
    int (*mmap)(struct file *, struct vm_area_struct *);
    int (*open)(struct inode *, struct file *);
    int (*flush)(struct file *, fl_owner_t id);
    int (*release)(struct inode *, struct file *);
    int (*fsync)(struct file *, loff_t, loff_t, int datasync);
    int (*fasync)(int, struct file *, int);
    int (*lock)(struct file *, int, struct file_lock *);
    // ... 更多操作
};

struct file_system_type {
    const char *name;               // 文件系统名称
    int fs_flags;                   // 标志位
#define FS_REQUIRES_DEV     1       // 需要块设备
#define FS_BINARY_MOUNTDATA 2       // 二进制挂载数据
#define FS_HAS_SUBTYPE      4       // 支持子类型
#define FS_USERNS_MOUNT     8       // 可在用户命名空间挂载
    
    // 初始化文件系统上下文
    int (*init_fs_context)(struct fs_context *);
    
    // 参数规范
    const struct fs_parameter_spec *parameters;
    
    // 销毁superblock
    void (*kill_sb)(struct super_block *);
    
    struct module *owner;           // 所属模块
    struct file_system_type *next;  // 链表下一项
    struct hlist_head fs_supers;    // 该类型的所有superblock
    
    // ... 其他字段
};

struct mount {
    struct hlist_node m_hash;       // 哈希表节点
    struct mount *m_parent;         // 父挂载点
    struct dentry *m_mountpoint;    // 挂载点dentry
    struct vfsmount mnt;            // 嵌入的vfsmount
    union {
        struct rcu_head mnt_rcu;
        struct llist_node mnt_llist;
    };
    // ... 更多字段
};

struct vfsmount {
    struct dentry *mnt_root;        // 文件系统根目录
    struct super_block *mnt_sb;     // 关联的superblock
    int mnt_flags;                  // 挂载标志
    // ... 其他字段
};

// dentry哈希表
static struct hlist_bl_head *dentry_hashtable;

// dentry哈希函数
static inline struct hlist_bl_head *d_hash(unsigned int hash)
{
    return dentry_hashtable + (hash & d_hash_mask);
}

// 简化的路径解析逻辑
static int link_path_walk(const char *name, struct nameidata *nd)
{
    while (*name) {
        // 1. 提取下一个路径分量
        const char *this = name;
        name = getname_component(name);
        
        // 2. 快速路径：dcache查找
        dentry = d_lookup(nd->path.dentry, &this);
        if (dentry) {
            // 检查有效性
            if (d_revalidate(dentry, nd->flags))
                goto found;
        }
        
        // 3. 慢速路径：调用文件系统lookup
        dentry = d_alloc(nd->path.dentry, &this);
        err = inode->i_op->lookup(inode, dentry, nd->flags);
        
found:
        // 4. 处理符号链接
        if (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode)) {
            // 跟随符号链接
        }
        
        // 5. 移动到下一级
        nd->path.dentry = dentry;
    }
    return 0;
}

// 简化的open实现
long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
{
    // 1. 从用户空间复制文件名
    struct open_flags op;
    tmp = getname(filename);
    
    // 2. 解析路径，获取dentry和inode
    path = do_filp_open(dfd, tmp, &op);
    
    // 3. 创建file结构体
    struct file *f = alloc_file(&path, flags, fop);
    
    // 4. 调用文件系统的open方法
    if (f->f_op->open)
        f->f_op->open(inode, f);
    
    // 5. 分配文件描述符
    fd = get_unused_fd_flags(flags);
    fd_install(fd, f);
    
    return fd;
}

// 简化的read实现
ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
    ssize_t ret;
    
    // 1. 权限检查
    if (!(file->f_mode & FMODE_READ))
        return -EBADF;
    
    // 2. 调用文件系统的read或read_iter
    if (file->f_op->read)
        ret = file->f_op->read(file, buf, count, pos);
    else if (file->f_op->read_iter)
        ret = new_sync_read(file, buf, count, pos);
    else
        ret = -EINVAL;
    
    // 3. 更新访问时间
    if (ret > 0)
        add_rchar(current, ret);
    
    return ret;
}

struct address_space {
    struct inode *host;              // 所属inode
    struct xarray i_pages;           // 页缓存XArray
    // 按页面索引组织的页缓存
    // 支持高效的范围查找和迭代
    
    unsigned long nrpages;           // 缓存页面数
    unsigned long nrexceptional;     // 特殊条目数（如DAX、hole）
    const struct address_space_operations *a_ops; // 操作向量
    
    unsigned long flags;             // 标志位
    errseq_t wb_err;                 // 回写错误
    spinlock_t private_lock;         // 私有数据锁
    struct list_head private_list;   // 私有数据链表
    // ... 更多字段
};

struct address_space_operations {
    // 读取页面
    int (*readpage)(struct file *, struct page *);
    int (*readpages)(struct file *filp, struct address_space *mapping,
                     struct list_head *pages, unsigned nr_pages);
    
    // 写入页面
    int (*writepage)(struct page *page, struct writeback_control *wbc);
    int (*writepages)(struct address_space *, struct writeback_control *);
    
    // 脏页标记
    int (*set_page_dirty)(struct page *page);
    
    // 直接I/O
    ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter);
    
    // 空洞处理
    int (*migratepage)(struct address_space *, struct page *, struct page *, enum migrate_mode);
    // ... 更多操作
};

struct file_ra_state {
    pgoff_t start;              // 当前窗口起始
    unsigned int size;          // 当前窗口大小
    unsigned int async_size;    // 异步预读阈值
    unsigned int ra_pages;      // 最大预读页面数
    unsigned int mmap_miss;     // mmap未命中计数
    loff_t prev_pos;            // 前一次读取位置
};

static const struct file_operations proc_pid_cmdline_ops = {
    .read       = proc_pid_cmdline_read,
    .llseek     = generic_file_llseek,
    .read_iter  = generic_file_read_iter,
};

static ssize_t proc_pid_cmdline_read(struct file *file, char __user *buf,
                                      size_t count, loff_t *pos)
{
    // 从进程的内存布局中读取命令行参数
    struct task_struct *task = get_proc_task(file_inode(file));
    struct mm_struct *mm = get_task_mm(task);
    
    // 访问进程内存，复制到用户缓冲区
    // ...
}

// sysfs文件创建
int sysfs_create_file(struct kobject *kobj, const struct attribute *attr)
{
    // 创建表示内核对象属性的文件
    // 读写操作会调用attribute的show/store方法
}

// 属性操作示例
static ssize_t cpu_show(struct device *dev, 
                        struct device_attribute *attr, char *buf)
{
    return sprintf(buf, "%u\n", cpumask_weight(cpu_online_mask));
}

static DEVICE_ATTR(online, 0444, cpu_show, NULL);

static struct file_system_type tmpfs_fs_type = {
    .name       = "tmpfs",
    .init_fs_context = shmem_init_fs_context,
    .parameters = shmem_fs_parameters,
    .kill_sb    = kill_litter_super,
    .fs_flags   = FS_USERNS_MOUNT,
};

// RCU查找示例
struct dentry *d_lookup(const struct dentry *parent, const struct qstr *name)
{
    unsigned int hash = name->hash;
    struct hlist_bl_head *b = d_hash(hash);
    
    // RCU临界区
    rcu_read_lock();
    hlist_bl_for_each_entry_rcu(dentry, node, b, d_hash) {
        if (dentry->d_parent == parent &&
            dentry->d_name.hash == hash &&
            d_unhashed(dentry) == 0) {
            // 名称比较
            if (!dentry->d_op || !dentry->d_op->d_compare ||
                dentry->d_op->d_compare(dentry, dentry->d_name.len,
                                       name->name, name) == 0)
                goto found;
        }
    }
    rcu_read_unlock();
    return NULL;
found:
    // 增加引用计数
    if (!lockref_get_not_dead(&dentry->d_lockref))
        dentry = NULL;
    rcu_read_unlock();
    return dentry;
}

// 回写相关参数（/proc/sys/vm/）
dirty_ratio              = 20    // 脏页占比上限（%）
dirty_background_ratio   = 10    // 后台回写触发阈值（%）
dirty_writeback_centisecs = 500  // 回写线程唤醒间隔（厘秒）
dirty_expire_centisecs   = 3000  // 脏页过期时间（厘秒）

// 目录锁规则（简化版）
// 1. 获取父目录的i_rwsem
// 2. 获取目标文件/目录的i_rwsem（如果适用）
// 3. 对于跨目录重命名，需要获取s_vfs_rename_mutex

// 锁获取顺序（避免死锁）：
// - 父目录 -> 子目录
// - 对于同层inode，按地址顺序锁定
// - 全局s_vfs_rename_mutex在最后

// 安全钩子示例
int vfs_permission(struct mnt_idmap *idmap, struct inode *inode, int mask)
{
    // 1. 传统权限检查
    int ret = inode_permission(idmap, inode, mask);
    if (ret)
        return ret;
    
    // 2. LSM钩子
    return security_inode_permission(inode, mask);
}

// 文件capability检查
int cap_inode_need_killpriv(struct dentry *dentry)
{
    struct inode *inode = d_backing_inode(dentry);
    
    // 检查文件是否设置了setuid/setgid位
    if (inode->i_mode & (S_ISUID | S_ISGID))
        return 1;
    
    // 检查扩展属性中的capabilities
    if (!cap_inode_getsecurity(dentry, XATTR_NAME_CAPS, NULL, 0, true))
        return 0;
    
    return 1;
}

// fcntl锁
struct flock fl = {
    .l_type = F_WRLCK,    // 写锁
    .l_whence = SEEK_SET,
    .l_start = 0,
    .l_len = 0,           // 锁定整个文件
};

fcntl(fd, F_SETLK, &fl);

# 在挂载时启用
mount -o mand /dev/sda1 /mnt

# 设置强制锁标志（关闭组执行位 + 设置setgid位）
chmod g-s,g+x file.txt

// DAX相关的address_space_operations
static const struct address_space_operations ext4_dax_aops = {
    .direct_IO         = ext4_dax_direct_IO,
    .set_page_dirty    = __set_page_dirty_no_writeback,
    // DAX不需要传统的回写
};