struct super_block {
    struct list_head    s_list;              // 所有超级块的链表
    dev_t               s_dev;               // 设备标识符
    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;             // 根目录项
    int                 s_count;             // 引用计数
    atomic_t            s_active;            // 活跃计数
    void                *s_fs_info;          // 文件系统私有信息
    // ... 更多字段
};

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);
    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;              // 访问权限
    kuid_t              i_uid;               // 所有者ID
    kgid_t              i_gid;               // 组ID
    unsigned long       i_ino;               // inode编号
    loff_t              i_size;              // 文件大小
    struct timespec64   i_atime;             // 访问时间
    struct timespec64   i_mtime;             // 修改时间
    struct timespec64   i_ctime;             // 状态改变时间
    blkcnt_t            i_blocks;            // 块数
    
    const struct inode_operations *i_op;     // inode操作函数表
    const struct file_operations *i_fop;     // 文件操作函数表
    struct super_block  *i_sb;               // 所属超级块
    struct address_space *i_mapping;         // 页缓存映射
    
    union {
        struct pipe_inode_info *i_pipe;      // 管道信息
        struct block_device *i_bdev;         // 块设备
        struct cdev *i_cdev;                 // 字符设备
    };
    // ... 更多字段
};

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

struct dentry {
    unsigned int        d_flags;             // 目录项标志
    struct dentry       *d_parent;           // 父目录项
    struct qstr         d_name;              // 目录项名称
    struct inode        *d_inode;            // 关联的inode
    
    const struct dentry_operations *d_op;    // 目录项操作
    struct super_block  *d_sb;               // 所属超级块
    void                *d_fsdata;           // 文件系统私有数据
    
    struct list_head    d_child;             // 父目录的子目录项链表
    struct list_head    d_subdirs;           // 当前目录的子目录项链表
    struct hlist_node   d_alias;             // inode的别名链表
    // ... 更多字段
};

struct file {
    struct path         f_path;              // 文件路径(包含dentry和vfsmount)
    struct inode        *f_inode;            // 关联的inode
    const struct file_operations *f_op;      // 文件操作函数表
    
    atomic_long_t       f_count;             // 引用计数
    unsigned int        f_flags;             // 打开标志(O_RDONLY, O_WRONLY等)
    fmode_t             f_mode;              // 访问模式
    loff_t              f_pos;               // 文件位置指针
    struct fown_struct  f_owner;             // 文件所有者
    
    void                *private_data;       // 私有数据(驱动使用)
    struct address_space *f_mapping;         // 页缓存映射
    // ... 更多字段
};

struct file_operations {
    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 (*open)(struct inode *, struct file *);
    int (*release)(struct inode *, struct file *);
    int (*fsync)(struct file *, loff_t, loff_t, int datasync);
    int (*mmap)(struct file *, struct vm_area_struct *);
    // ... 更多操作
};

struct file_system_type {
    const char          *name;               // 文件系统名称
    int                 fs_flags;            // 文件系统标志
    
    // 挂载文件系统的回调函数
    struct dentry *(*mount)(struct file_system_type *, int,
                           const char *, void *);
    
    void (*kill_sb)(struct super_block *);   // 卸载文件系统
    struct module       *owner;              // 所属模块
    struct file_system_type *next;           // 链表指针
    struct hlist_head   fs_supers;           // 该类型的所有超级块
};

#include <linux/fs.h>
#include <linux/module.h>

// 1. 定义超级块操作
static const struct super_operations myfs_super_ops = {
    .alloc_inode    = myfs_alloc_inode,
    .destroy_inode  = myfs_destroy_inode,
    .write_inode    = myfs_write_inode,
    .put_super      = myfs_put_super,
    .statfs         = myfs_statfs,
    .sync_fs        = myfs_sync_fs,
};

// 2. 定义inode操作
static const struct inode_operations myfs_inode_ops = {
    .lookup         = myfs_lookup,
    .create         = myfs_create,
    .mkdir          = myfs_mkdir,
    .rmdir          = myfs_rmdir,
    .unlink         = myfs_unlink,
};

// 3. 定义文件操作
static const struct file_operations myfs_file_ops = {
    .read_iter      = myfs_read_iter,
    .write_iter     = myfs_write_iter,
    .open           = myfs_open,
    .release        = myfs_release,
    .fsync          = myfs_fsync,
    .llseek         = generic_file_llseek,
};

// 4. 填充超级块
static int myfs_fill_super(struct super_block *sb, void *data, int silent)
{
    struct inode *root_inode;
    struct dentry *root_dentry;
    
    // 设置超级块基本信息
    sb->s_blocksize = PAGE_SIZE;
    sb->s_blocksize_bits = PAGE_SHIFT;
    sb->s_magic = MYFS_MAGIC;
    sb->s_op = &myfs_super_ops;
    sb->s_maxbytes = MAX_LFS_FILESIZE;
    
    // 创建根inode
    root_inode = new_inode(sb);
    if (!root_inode)
        return -ENOMEM;
    
    root_inode->i_ino = 1;
    root_inode->i_mode = S_IFDIR | 0755;
    root_inode->i_op = &myfs_inode_ops;
    root_inode->i_fop = &simple_dir_operations;
    set_nlink(root_inode, 2);
    
    // 创建根dentry
    root_dentry = d_make_root(root_inode);
    if (!root_dentry) {
        iput(root_inode);
        return -ENOMEM;
    }
    
    sb->s_root = root_dentry;
    return 0;
}

// 5. 挂载函数
static struct dentry *myfs_mount(struct file_system_type *fs_type,
                                  int flags, const char *dev_name,
                                  void *data)
{
    // 对于基于块设备的文件系统,使用mount_bdev
    return mount_bdev(fs_type, flags, dev_name, data, myfs_fill_super);
    
    // 对于伪文件系统(如procfs),使用mount_nodev
    // return mount_nodev(fs_type, flags, data, myfs_fill_super);
}

// 6. 定义file_system_type
static struct file_system_type myfs_type = {
    .owner          = THIS_MODULE,
    .name           = "myfs",
    .mount          = myfs_mount,
    .kill_sb        = kill_block_super,  // 或kill_litter_super
    .fs_flags       = FS_REQUIRES_DEV,
};

// 7. 模块初始化和清理
static int __init myfs_init(void)
{
    int ret;
    
    // 注册文件系统
    ret = register_filesystem(&myfs_type);
    if (ret) {
        pr_err("Failed to register myfs\n");
        return ret;
    }
    
    pr_info("myfs registered successfully\n");
    return 0;
}

static void __exit myfs_exit(void)
{
    // 注销文件系统
    unregister_filesystem(&myfs_type);
    pr_info("myfs unregistered\n");
}

module_init(myfs_init);
module_exit(myfs_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("My Custom File System");

ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
    ssize_t ret;
    
    // 检查文件是否可读
    if (!(file->f_mode & FMODE_READ))
        return -EBADF;
    
    // 检查file_operations是否存在
    if (!file->f_op->read && !file->f_op->read_iter)
        return -EINVAL;
    
    // 检查缓冲区是否可写
    if (!access_ok(buf, count))
        return -EFAULT;
    
    // 调用具体文件系统的read操作
    if (file->f_op->read_iter)
        ret = new_sync_read(file, buf, count, pos);
    else
        ret = file->f_op->read(file, buf, count, pos);
    
    // 更新访问时间
    if (ret > 0) {
        fsnotify_access(file);
        add_rchar(current, ret);
    }
    
    inc_syscr(current);
    return ret;
}

static ssize_t ext4_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
    struct inode *inode = file_inode(iocb->ki_filp);
    
    // 处理加密文件
    if (!ext4_inode_readable(inode))
        return -EACCES;
    
    // 对于直接I/O
    if (iocb->ki_flags & IOCB_DIRECT) {
        // 处理Direct I/O
        return ext4_dio_read_iter(iocb, to);
    }
    
    // 标准的buffered I/O,使用通用页缓存
    return generic_file_read_iter(iocb, to);
}

ssize_t generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
{
    // 如果是Direct I/O
    if (iocb->ki_flags & IOCB_DIRECT) {
        struct address_space *mapping = iocb->ki_filp->f_mapping;
        
        // 刷新该范围的脏页
        filemap_write_and_wait_range(mapping, iocb->ki_pos, end);
        
        // 执行Direct I/O读取
        return mapping->a_ops->direct_IO(iocb, iter);
    }
    
    // 标准的页缓存读取
    return filemap_read(iocb, iter, 0);
}

const struct file_operations ext4_file_operations = {
    .llseek         = ext4_llseek,
    .read_iter      = ext4_file_read_iter,
    .write_iter     = ext4_file_write_iter,
    .unlocked_ioctl = ext4_ioctl,
    .open           = ext4_file_open,
    .release        = ext4_release_file,
    .mmap           = ext4_file_mmap,
    .fsync          = ext4_sync_file,
    .splice_read    = generic_file_splice_read,
    .splice_write   = iter_file_splice_write,
    .fallocate      = ext4_fallocate,
};

static const struct address_space_operations ext4_aops = {
    .readpage       = ext4_readpage,
    .readpages      = ext4_readpages,
    .writepage      = ext4_writepage,
    .writepages     = ext4_writepages,
    .write_begin    = ext4_write_begin,
    .write_end      = ext4_write_end,
    .bmap           = ext4_bmap,
    .invalidatepage = ext4_invalidatepage,
    .releasepage    = ext4_releasepage,
    .direct_IO      = ext4_direct_IO,
    .migratepage    = buffer_migrate_page,
    .is_partially_uptodate = block_is_partially_uptodate,
    .error_remove_page = generic_error_remove_page,
};

// 逻辑块号 -> 物理块号
int ext4_map_blocks(handle_t *handle, struct inode *inode,
                    struct ext4_map_blocks *map, int flags)
{
    struct ext4_extent_header *eh;
    struct ext4_extent *ex;
    
    // 1. 在extent tree中查找逻辑块对应的extent
    ex = ext4_find_extent(inode, map->m_lblk);
    
    // 2. 如果找到extent,直接返回物理块号
    if (ex) {
        map->m_pblk = ext4_ext_pblock(ex) + (map->m_lblk - le32_to_cpu(ex->ee_block));
        return 0;
    }
    
    // 3. 如果是写操作且没找到,需要分配新块
    if (flags & EXT4_GET_BLOCKS_CREATE) {
        return ext4_ext_map_blocks(handle, inode, map, flags);
    }
    
    return -ENOENT;
}