1
// include/linux/fs.h（简化）
2
struct super_block {
3
    dev_t                   s_dev;          // 设备号
4
    unsigned long           s_blocksize;    // 块大小（字节）
5
    loff_t                  s_maxbytes;     // 文件最大尺寸
6
    struct file_system_type *s_type;        // 文件系统类型
7
    const struct super_operations *s_op;    // 超级块操作表
8
    struct dentry           *s_root;        // 根目录项
9
    struct list_head        s_inodes;       // 该文件系统所有 inode 链表
10
    void                    *s_fs_info;     // 具体文件系统的私有数据
11
    // ... 更多字段
12
};

1
struct super_operations {
2
    struct inode *(*alloc_inode)(struct super_block *sb);   // 分配 inode
3
    void         (*destroy_inode)(struct inode *);          // 销毁 inode
4
    void         (*dirty_inode)(struct inode *, int flags); // 标记脏 inode
5
    int          (*write_inode)(struct inode *, int wait);  // 写回 inode
6
    void         (*drop_inode)(struct inode *);             // 释放 inode 引用
7
    void         (*evict_inode)(struct inode *);            // 驱逐 inode
8
    void         (*put_super)(struct super_block *);        // 卸载时释放超级块
9
    int          (*sync_fs)(struct super_block *, int);     // 同步文件系统
10
    int          (*statfs)(struct dentry *, struct kstatfs *); // 文件系统统计
11
    int          (*remount_fs)(struct super_block *, int *, char *); // 重新挂载
12
    // ...
13
};

1
// include/linux/fs.h（简化）
2
struct inode {
3
    umode_t                 i_mode;         // 文件类型与权限
4
    uid_t                   i_uid;          // 所有者 UID
5
    gid_t                   i_gid;          // 所有者 GID
6
    loff_t                  i_size;         // 文件大小（字节）
7
    struct timespec         i_atime;        // 最后访问时间
8
    struct timespec         i_mtime;        // 最后修改时间
9
    struct timespec         i_ctime;        // 最后状态变更时间
10
    const struct inode_operations *i_op;    // inode 操作表
11
    const struct file_operations  *i_fop;   // 文件操作表
12
    struct super_block      *i_sb;          // 所属超级块
13
    struct address_space    *i_data;        // 页缓存映射
14
    void                    *i_private;     // 具体文件系统私有数据
15
    // ... 更多字段
16
};

1
struct inode_operations {
2
    struct dentry *(*lookup)(struct inode *, struct dentry *, unsigned int);  // 目录查找
3
    int           (*create)(struct inode *, struct dentry *, umode_t, bool);  // 创建文件
4
    int           (*link)(struct dentry *, struct inode *, struct dentry *);  // 硬链接
5
    int           (*unlink)(struct inode *, struct dentry *);                // 删除目录项
6
    int           (*symlink)(struct inode *, struct dentry *, const char *); // 符号链接
7
    int           (*mkdir)(struct inode *, struct dentry *, umode_t);        // 创建目录
8
    int           (*rmdir)(struct inode *, struct dentry *);                 // 删除目录
9
    int           (*rename)(struct inode *, struct dentry *,
10
                           struct inode *, struct dentry *, unsigned int);   // 重命名
11
    int           (*getattr)(const struct path *, struct kstat *, ...);      // 获取属性
12
    int           (*setattr)(struct dentry *, struct iattr *);               // 设置属性
13
    // ...
14
};

1
struct file_operations {
2
    loff_t (*llseek)(struct file *, loff_t, int);               // 定位
3
    ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);   // 读
4
    ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *); // 写
5
    int    (*mmap)(struct file *, struct vm_area_struct *);      // 内存映射
6
    int    (*open)(struct inode *, struct file *);               // 打开
7
    int    (*flush)(struct file *, fl_owner_t);                  // 刷新
8
    int    (*release)(struct inode *, struct file *);            // 关闭
9
    int    (*fsync)(struct file *, loff_t, loff_t, int);        // 同步
10
    // ...
11
};

1
// include/linux/dcache.h（简化）
2
struct dentry {
3
    atomic_t                d_lockref;      // 引用计数 + 自旋锁
4
    unsigned int            d_flags;        // 标志位
5
    struct qstr             d_name;         // 名字（哈希字符串）
6
    struct inode            *d_inode;       // 关联的 inode
7
    struct dentry           *d_parent;      // 父目录项
8
    struct list_head        d_child;        // 父目录的子目录项链表
9
    struct list_head        d_subdirs;      // 子目录项链表
10
    const struct dentry_operations *d_op;   // dentry 操作表
11
    struct super_block      *d_sb;          // 所属超级块
12
    void                    *d_fsdata;      // 具体文件系统私有数据
13
    // ...
14
};

1
struct dentry_operations {
2
    int     (*d_revalidate)(struct dentry *, unsigned int);  // 重新验证（网络文件系统）
3
    int     (*d_hash)(const struct dentry *, struct qstr *); // 自定义哈希
4
    int     (*d_compare)(const struct dentry *,              // 名字比较
5
                         unsigned int, const char *, const struct qstr *);
6
    int     (*d_delete)(const struct dentry *);              // 删除通知
7
    void    (*d_release)(struct dentry *);                   // 释放
8
    // ...
9
};

1
// include/linux/fs.h（简化）
2
struct file {
3
    struct path             f_path;         // 关联的 dentry + vfsmount
4
    const struct file_operations *f_op;     // 文件操作表
5
    atomic_long_t           f_count;        // 引用计数
6
    unsigned int            f_flags;        // 打开标志（O_RDONLY 等）
7
    fmode_t                 f_mode;         // 模式（FMODE_READ/FMODE_WRITE）
8
    loff_t                  f_pos;          // 当前读写偏移量
9
    void                    *private_data;  // 私有数据
10
    struct address_space    *f_mapping;     // 页缓存映射
11
    // ...
12
};

1
fd (int) → fdtable.fd_array[fd] → struct file → dentry → inode

1
// fs/open.c（简化）
2
long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
3
{
4
    struct open_flags op;
5
    int fd = build_open_flags(flags, mode, &op);  // 解析并验证标志
6
    if (fd)
7
        return fd;
8

9
    fd = get_unused_fd_flags(flags);  // 分配一个未使用的文件描述符
10
    if (fd >= 0) {
11
        struct file *f = do_filp_open(dfd, filename, &op);  // 执行路径解析和文件打开
12
        if (IS_ERR(f)) {
13
            put_unused_fd(fd);
14
            fd = PTR_ERR(f);
15
        } else {
16
            fsnotify_open(f);
17
            fd_install(fd, f);  // 将 file 指针安装到 fdtable
18
        }
19
    }
20
    return fd;
21
}

1
// fs/read_write.c（简化流程）
2
SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
3
    → ksys_read(fd, buf, count)
4
        → vfs_read(file, buf, count, &pos)
5
            → file->f_op->read(file, buf, count, &pos)    // 方式一：直接调用
6
            或
7
            → new_sync_read(file, buf, count, &pos)        // 方式二：通用读
8
                → file->f_op->read_iter(&iocb, &iter)      // 调用 read_iter

1
// fs/read_write.c（简化流程）
2
SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf, size_t, count)
3
    → ksys_write(fd, buf, count)
4
        → vfs_write(file, buf, count, &pos)
5
            → file->f_op->write_iter(&iocb, &iter)
6
                → generic_file_write_iter()
7
                    → generic_perform_write()  // 逐页写入页缓存
8
                        → 标记脏页
9
                        → 唤醒 writeback 守护进程（如果脏页过多）

1
| 块组0                | 块组1                | 块组2      | ...
2
| SB | BGDT | BB | IB | IT | Data... | SB | BGDT | ... | SB | ...

1
// ext4 的 extent 结构（简化）
2
struct ext4_extent {
3
    __le32  ee_block;     // 逻辑块号（文件内偏移）
4
    __le16  ee_len;       // 长度（块数）
5
    __le16  ee_start_hi;  // 物理块号高 16 位
6
    __le32  ee_start_lo;  // 物理块号低 32 位
7
};

1
// fs/mount.h（简化）
2
struct mount {
3
    struct list_head mnt_hash;      // 全局哈希链表
4
    struct mount *mnt_parent;       // 父挂载
5
    struct dentry *mnt_mountpoint;  // 挂载点 dentry
6
    struct vfsmount mnt;            // 嵌入的 vfsmount
7
};
8

9
struct vfsmount {
10
    struct dentry *mnt_root;        // 挂载文件系统的根 dentry
11
    struct super_block *mnt_sb;     // 挂载文件系统的超级块
12
    int mnt_flags;                  // 挂载标志
13
};

1
# 创建新的挂载命名空间
2
unshare --mount /bin/bash
3

4
# 在新命名空间中挂载，不影响宿主
5
mount -t tmpfs tmpfs /mnt/test

1
# 查看文件系统类型
2
df -T
3

4
# 查看文件的 inode 信息
5
stat /etc/passwd
6

7
# 查看目录项缓存状态
8
cat /proc/sys/fs/dentry-state
9

10
# 查看系统支持的文件系统类型
11
cat /proc/filesystems
12

13
# 查看当前挂载信息
14
cat /proc/mounts
15
# 或
16
mount -l

1
# 查看 ext4 超级块信息
2
sudo dumpe2fs /dev/sda1 | head -50
3

4
# 查看 ext4 块组描述符
5
sudo dumpe2fs /dev/sda1 -bg
6

7
# 使用 debugfs 探索 ext4 内部结构
8
sudo debugfs /dev/sda1
9
# 在 debugfs 中：
10
#   stat <inode号>     查看 inode 详情
11
#   ls -l /            列出根目录
12
#   blocks <inode号>   查看文件的块分配
13
#   dump <文件> /tmp/out  提取文件内容
14

15
# 查看文件的 inode 号和磁盘块
16
ls -lai /etc/passwd
17
sudo hdparm --fibmap /etc/passwd

1
# procfs：查看进程信息
2
cat /proc/self/status
3
ls /proc/self/fd/       # 查看当前进程的文件描述符
4
cat /proc/self/maps     # 查看内存映射
5

6
# procfs：查看内核参数
7
cat /proc/sys/vm/dirty_ratio
8
sudo sysctl vm.dirty_ratio=20   # 修改内核参数
9

10
# sysfs：查看设备模型
11
ls /sys/class/net/
12
cat /sys/class/net/eth0/mtu
13
echo 9000 | sudo tee /sys/class/net/eth0/mtu  # 修改 MTU
14

15
# tmpfs：创建和使用
16
mount -t tmpfs -o size=100M tmpfs /mnt/tmpfs
17
df -h /mnt/tmpfs
18
dd if=/dev/zero of=/mnt/tmpfs/test bs=1M count=50

1
# 使用 strace 追踪 open 系统调用
2
strace -e openat cat /etc/hostname
3

4
# 使用 bpftrace 追踪内核路径解析
5
sudo bpftrace -e 'kprobe:do_filp_open { printf("path: %s\n", str(arg1)); }'
6

7
# 使用 perf 追踪 VFS 操作
8
sudo perf record -e 'vfs:*' -a sleep 5
9
sudo perf script