// include/linux/fs.h 结构体已删减
struct file_system_type {
    // 文件系统的名称（如 "ext4"、"vfat"），用于标识文件系统类型
    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      // 允许用户命名空间中的 root 挂载此文件系统
#define FS_USERNS_DEV_MOUNT 16
#define FS_RENAME_DOES_D_MOVE 32768

    // 函数指针，挂载文件系统，返回根目录的 dentry 结构指针，表示挂载点
    // 参数：文件系统类型、挂载标志、设备路径、挂载数据
    struct dentry* (*mount)(struct file_system_type*, int, const char*, void*);

    // 函数指针，卸载文件系统，释放挂载点的超级块结构
    void (*kill_sb)(struct super_block*);

    // 指向文件系统模块的指针，一般都是设置为 THIS_MODULE
    struct module* owner;

    // 指向链表中下一个文件系统类型结构，用于组织多个文件系统类型
    // 在注册的时候会找到最后一个文件系统，并将其 next 指向新注册的文件系统
    // 链表头：static struct file_system_type *file_systems;
    // 保护锁：static DEFINE_RWLOCK(file_systems_lock);
    struct file_system_type* next;

    // 哈希表头，用于记录该文件系统的所有 super_block 实例，
    // 由于同一文件系统可能会被多次挂载，因此每个挂载点都会有一个单独的超级块
    // 链表头：LIST_HEAD(super_blocks); -> struct list_head super_blocks
    // 保护锁：DEFINE_SPINLOCK(sb_lock);
    struct hlist_head fs_supers;  // 与 list_head 结构完全相同，只是名称不同而已
};

// fs/filesystems.c

/* 全局变量 */
static struct file_system_type *file_systems;
static DEFINE_RWLOCK(file_systems_lock);

/**
 *	register_filesystem - register a new filesystem
 *	@fs: the file system structure
 *
 *	Adds the file system passed to the list of file systems the kernel
 *	is aware of for mount and other syscalls. Returns 0 on success,
 *	or a negative errno code on an error.
 *
 *	The &struct file_system_type that is passed is linked into the kernel
 *	structures and must not be freed until the file system has been
 *	unregistered.
 */

int register_filesystem(struct file_system_type* fs) {
    int res = 0;
    struct file_system_type** p;

    BUG_ON(strchr(fs->name, '.'));  // 文件系统的名称不能出现 '.'
    if (fs->next)
        return -EBUSY;

    write_lock(&file_systems_lock);
    // 找到同名字的文件系统就说明已经注册，否则将其（入参 fs）挂到 ->next 链表最后
    p = find_filesystem(fs->name, strlen(fs->name));
    if (*p)
        res = -EBUSY;
    else
        *p = fs;
    write_unlock(&file_systems_lock);

    return res;
}

EXPORT_SYMBOL(register_filesystem);

static struct file_system_type** find_filesystem(const char* name, unsigned len) {
    struct file_system_type** p;
    for (p = &file_systems; *p; p = &(*p)->next)
        if (strlen((*p)->name) == len && strncmp((*p)->name, name, len) == 0)
            break;
    return p;
}

/**
 *	unregister_filesystem - unregister a file system
 *	@fs: filesystem to unregister
 *
 *	Remove a file system that was previously successfully registered
 *	with the kernel. An error is returned if the file system is not found.
 *	Zero is returned on a success.
 *
 *	Once this function has returned the &struct file_system_type structure
 *	may be freed or reused.
 */

int unregister_filesystem(struct file_system_type* fs) {
    struct file_system_type** tmp;

    write_lock(&file_systems_lock);
    tmp = &file_systems;
    while (*tmp) {
        if (fs == *tmp) {     // 地址比较相等
            *tmp = fs->next;  // 跳过将要移除的节点（上一个节点的 next 指向 fs 的下一个节点）
            fs->next = NULL;  // 将要移除的节点的 next 指向空
            write_unlock(&file_systems_lock);
            synchronize_rcu();
            return 0;
        }
        // 更新 tmp，使之指向下一个 file_system_type* 的地址，
        // 换句话说，现在 tmp 指向了上一个节点的 next 地址
        tmp = &(*tmp)->next;
    }
    write_unlock(&file_systems_lock);

    return -EINVAL;
}

EXPORT_SYMBOL(unregister_filesystem);

static struct file_system_type rootfs_fs_type = {
	.name		= "rootfs",
	.mount		= rootfs_mount,  // 挂载和卸载操作
	.kill_sb	= kill_litter_super,
};

int __init init_rootfs(void)
{
	int err;
	// ...
	err = register_filesystem(&rootfs_fs_type);
	// ...
	return err;
}

static struct file_system_type ramfs_fs_type = {
	.name		= "ramfs",
	.mount		= ramfs_mount,
	.kill_sb	= ramfs_kill_sb,
	.fs_flags	= FS_USERNS_MOUNT,
};

static int __init init_ramfs_fs(void)
{
	return register_filesystem(&ramfs_fs_type);
}
module_init(init_ramfs_fs)

// include/linux/fs.h 结构体已删减
struct super_block {
    struct list_head s_list;              // Keep this first，链接所有超级块的链表头，便于管理多个挂载的文件系统

    dev_t s_dev;                          // 标识文件系统的设备编号
    unsigned char s_blocksize_bits;       // block 大小的幂数
    unsigned long s_blocksize;            // block 的实际字节，s_blocksize=2^s_blocksize_bits
    loff_t s_maxbytes;                    // 支持的单个文件的最大字节大小 MAX_LFS_FILESIZE
    struct file_system_type* s_type;      // 此超级块所属的文件系统类型

    const struct super_operations* s_op;  // 指向超级块操作函数，如 alloc_inode/write_inode/destroy_inode 等

    struct dentry* s_root;                // 根目录项，表示文件系统的挂载点
    int s_count;                          // 超级块的引用次数，决定何时可以销毁超级块
    atomic_t s_active;                    // 超级块是否处于活跃状态
    struct list_head s_inodes;            // 文件系统中 inode 链表头，记录文件系统的所有 inode
    struct list_head s_mounts;            // list of mounts; _not_ for fs use，记录当前挂载该文件系统的所有挂载点
    struct hlist_node s_instances;        // 链接所有 super_block 实例
    fmode_t s_mode;                       // 文件系统的访问模式（读 / 写等）
};

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 (*evict_inode) (struct inode *);
	void (*put_super) (struct super_block *);
	int (*sync_fs)(struct super_block *sb, int wait);
	int (*freeze_fs) (struct super_block *);
	int (*unfreeze_fs) (struct super_block *);
	int (*statfs) (struct dentry *, struct kstatfs *);
	int (*remount_fs) (struct super_block *, int *, char *);
	void (*umount_begin) (struct super_block *);

	int (*show_options)(struct seq_file *, struct dentry *);
	int (*show_devname)(struct seq_file *, struct dentry *);
	int (*show_path)(struct seq_file *, struct dentry *);
	int (*show_stats)(struct seq_file *, struct dentry *);
#ifdef CONFIG_QUOTA
	ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
	ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
#endif
	int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
	int (*nr_cached_objects)(struct super_block *);
	void (*free_cached_objects)(struct super_block *, int);
};

// include/linux/fs.h 结构体已删减
struct inode {
    umode_t i_mode;                       // 文件权限及类型
    kuid_t i_uid;                         // user id
    kgid_t i_gid;                         // group id
    const struct inode_operations* i_op;  // inode 操作函数，如 create，mkdir，lookup，rename 等
    struct super_block* i_sb;             // 所属的 SuperBlock
    struct address_space* i_mapping;      // 地址空间（用于处理文件的“内存”映射）
    struct address_space i_data;          // inode 的数据地址空间
    loff_t i_size;                        // 文件大小
    struct timespec i_atime;              // 文件最后访问时间
    struct timespec i_mtime;              // 文件最后修改时间
    struct timespec i_ctime;              // 文件元数据最后修改时间（包括文件名称）
    const struct file_operations* i_fop;  // 文件操作函数，open、write 等
    void* i_private;                      // 文件系统的私有数据
};

struct inode_operations {
	struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
	void * (*follow_link) (struct dentry *, struct nameidata *);
	int (*permission) (struct inode *, int);
	struct posix_acl * (*get_acl)(struct inode *, int);

	int (*readlink) (struct dentry *, char __user *,int);
	void (*put_link) (struct dentry *, struct nameidata *, void *);

	int (*create) (struct inode *,struct dentry *, umode_t, bool);
	int (*link) (struct dentry *,struct inode *,struct dentry *);
	int (*unlink) (struct inode *,struct dentry *);
	int (*symlink) (struct inode *,struct dentry *,const char *);
	int (*mkdir) (struct inode *,struct dentry *,umode_t);
	int (*rmdir) (struct inode *,struct dentry *);
	int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
	int (*rename) (struct inode *, struct dentry *,
			struct inode *, struct dentry *);
	int (*setattr) (struct dentry *, struct iattr *);
	int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
	int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
	ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
	ssize_t (*listxattr) (struct dentry *, char *, size_t);
	int (*removexattr) (struct dentry *, const char *);
	int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
		      u64 len);
	int (*update_time)(struct inode *, struct timespec *, int);
	int (*atomic_open)(struct inode *, struct dentry *,
			   struct file *, unsigned open_flag,
			   umode_t create_mode, int *opened);
} ____cacheline_aligned;

// include/linux/fs.h 结构体已删减
struct file {
    struct path f_path;                  // 包含的目录项
    struct inode* f_inode;               // 缓存值
    const struct file_operations* f_op;  // 文件操作函数
    atomic_long_t f_count;               // 文件对象引用计数
    unsigned int f_flags;
    fmode_t f_mode;
    loff_t f_pos;
    struct fown_struct f_owner;
    void* private_data;
    struct address_space *f_mapping;
};

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 (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
	ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
	int (*readdir) (struct file *, void *, filldir_t);
	unsigned int (*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 (*aio_fsync) (struct kiocb *, int datasync);
	int (*fasync) (int, struct file *, int);
	int (*lock) (struct file *, int, struct file_lock *);
	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
	int (*check_flags)(int);
	int (*flock) (struct file *, int, struct file_lock *);
	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
	int (*setlease)(struct file *, long, struct file_lock **);
	long (*fallocate)(struct file *file, int mode, loff_t offset,
			  loff_t len);
	int (*show_fdinfo)(struct seq_file *m, struct file *f);
};

// include/linux/sched.h 结构体已删减
struct task_struct {
    struct fs_struct* fs;        // filesystem information
    struct files_struct* files;  // open file information
};

// include/linux/path.h
struct path {
    struct vfsmount* mnt;
    struct dentry* dentry;
};

// include/linux/fs_struct.h 结构体已删减 
struct fs_struct {
    int users;         // 当前有多少个用户（线程或进程）共享这个 fs_struct 资源
    int umask;         // 文件权限的掩码
    struct path root;  // 根目录(/) 路径 
    struct path pwd;   // 当前工作目录(.) 路径
};

// include/linux/fdtable.h 结构体已删减
struct files_struct {  // Open file table structure
    atomic_t count;    // 引用计数
    struct fdtable __rcu* fdt;
    struct fdtable fdtab;
    spinlock_t file_lock ____cacheline_aligned_in_smp;
    int next_fd;  // 下一个可用的 fd 索引：当前 fd+1
    unsigned long close_on_exec_init[1];
    unsigned long open_fds_init[1];          // 记录当前已打开的 fd 的 bitmap，用数组是便于以后扩展
    struct file* fd_array[NR_OPEN_DEFAULT];  // 默认数量内，fd 索引对应的 file 对象
};

// include/linux/fdtable.h
struct fdtable {
    unsigned int max_fds;          // 最大可打开文件数，即 fd 数组长度
    struct file __rcu** fd;        // 当前的 fd 数组
    unsigned long* close_on_exec;  // 位图：带 O_CLOEXEC 打开标志的 fd
    unsigned long* open_fds;       // 位图：已经打开的 fd
    struct rcu_head rcu;
};

// include/linux/dcache.h 结构体已删减
struct dentry {
    struct dentry* d_parent;               // 父目录
    struct qstr d_name;                    // 文件名称及哈希值
    struct inode* d_inode;                 // 关联的 inode，NULL 表示 negative
    const struct dentry_operations* d_op;  // 目录项操作相关函数
    void* d_fsdata;                        // 文件系统特定的数据
    struct super_block* d_sb;              // 指向超级块
    union {
        struct list_head d_child;  // 父目录中的子目录和文件
        struct rcu_head d_rcu;
    } d_u;
    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 *, const struct inode *,
			struct qstr *);
	int (*d_compare)(const struct dentry *, const struct inode *,
			const struct dentry *, const struct inode *,
			unsigned int, const char *, const struct qstr *);
	int (*d_delete)(const struct dentry *);
	void (*d_release)(struct dentry *);
	void (*d_prune)(struct dentry *);
	void (*d_iput)(struct dentry *, struct inode *);
	char *(*d_dname)(struct dentry *, char *, int);
	struct vfsmount *(*d_automount)(struct path *);
	int (*d_manage)(struct dentry *, bool);
} ____cacheline_aligned;

struct file* fget(unsigned int fd) {
    struct file* file;
    struct files_struct* files = current->files;  // 1. current -> files_struct ⭐

    rcu_read_lock();
    file = fcheck_files(files, fd);  // 2. files_struct -> fdtable -> file ⭐
    if (file) {
        /* File object ref couldn't be taken 要求文件不是目录、可以引用 */
        if (file->f_mode & FMODE_PATH || !atomic_long_inc_not_zero(&file->f_count))
            file = NULL;
    }
    rcu_read_unlock();

    return file;
}

static inline struct file* fcheck_files(struct files_struct* files, unsigned int fd) {
    struct file* file = NULL;
    struct fdtable* fdt = files_fdtable(files);  // 2.1 files_struct -> fdtable ⭐

    /* 2.2 fdtable -> file ⭐ */
    if (fd < fdt->max_fds)
        // 如果 fd 小于 NR_OPEN_DEFAULT，这里 fdt->fd[fd] 便是 files->fd_array[fd] 
        file = rcu_dereference_check_fdtable(files, fdt->fd[fd]);
    return file;
}

#define rcu_dereference_check_fdtable(files, fdtfd) \
    (rcu_dereference_check((fdtfd), \
                   lockdep_is_held(&(files)->file_lock) || \
                   atomic_read(&(files)->count) == 1 || \
                   rcu_my_thread_group_empty()))

#define files_fdtable(files) \
        (rcu_dereference_check_fdtable((files), (files)->fdt))

#include <linux/fs.h>

#define MY_BLOCK_MAJOR 240
#define MY_BLKDEV_NAME "mybdev"

static int my_block_init(void) {
    int status;

    status = register_blkdev(MY_BLOCK_MAJOR, MY_BLKDEV_NAME);
    if (status < 0) {
        printk(KERN_ERR "unable to register mybdev block device\n");
        return -EBUSY;
    }
    //...
}

static void my_block_exit(void) {
    //...
    unregister_blkdev(MY_BLOCK_MAJOR, MY_BLKDEV_NAME);
}

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

#define MY_BLOCK_MINORS 1

static struct my_block_dev {
    struct gendisk* gd;
    //...
} dev;

static int create_block_device(struct my_block_dev* dev) {
    dev->gd = alloc_disk(MY_BLOCK_MINORS);
    //...
    add_disk(dev->gd);
}

static int my_block_init(void) {
    //...
    create_block_device(&dev);
}

static void delete_block_device(struct my_block_dev* dev) {
    if (dev->gd)
        del_gendisk(dev->gd);
    //...
}

static void my_block_exit(void) {
    delete_block_device(&dev);
    //...
}

// include/linux/genhd.h 结构体已删减
struct gendisk {
    /* 描述磁盘使用的标识符；磁盘必须至少有一个次设备号；
       如果磁盘允许分区操作，则必须为每个可能的分区分配一个次设备号 */
    int major;       /* 磁盘设备的主设备号 */
    int first_minor; /* 磁盘的第一个次设备号 */
    int minors;      /* 磁盘的次设备号数量，即磁盘的分区数量 */

    /* 在 /proc/partitions 和 sysfs (/sys/block) 中显示 */
    char disk_name[DISK_NAME_LEN]; /* name of major driver */

    char* (*devnode)(struct gendisk* gd, umode_t* mode);

    unsigned int events; /* supported events */

    struct hd_struct part0;  /* 分区描述 */

    const struct block_device_operations* fops; /* 块设备操作集 */
    struct request_queue* queue;                /* 磁盘对应的请求队列 */
    void* private_data;                         /* 指向私有数据的指针 */
};

// include/linux/genhd.h 结构体已删减
struct hd_struct {
    /* 定义了该分区在块设备上的起始扇区和长度，唯一地描述了该分区 */
    sector_t start_sect;
    sector_t nr_sects;

    sector_t alignment_offset;
    unsigned int discard_alignment;

    struct partition_meta_info* info;
};

#include <linux/blkdev.h>
#include <linux/fs.h>
#include <linux/genhd.h>

#define NR_SECTORS 1024

#define KERNEL_SECTOR_SIZE 512

static struct my_block_dev {
    //...
    spinlock_t lock;             /* 互斥锁 */
    struct request_queue* queue; /* 设备请求队列 */
    struct gendisk* gd;          /* gendisk 结构体 */
    //...
} dev;

static int create_block_device(struct my_block_dev* dev) {
    // ...
    /* 初始化 gendisk 结构体 */
    dev->gd = alloc_disk(MY_BLOCK_MINORS);
    if (!dev->gd) {
        printk(KERN_NOTICE "alloc_disk failure\n");
        return -ENOMEM;
    }

    dev->gd->major = MY_BLOCK_MAJOR;
    dev->gd->first_minor = 0;
    dev->gd->fops = &my_block_ops;
    dev->gd->queue = dev->queue;
    dev->gd->private_data = dev;
    snprintf(dev->gd->disk_name, 32, "myblock");
    set_capacity(dev->gd, NR_SECTORS);  // dev-gd->part0.nr_sects = NR_SECTORS

    add_disk(dev->gd);

    return 0;
}

struct block_device_operations {
    int (*open)(struct block_device*, fmode_t);
    int (*release)(struct gendisk*, fmode_t);
    int (*locked_ioctl)(struct block_device*, fmode_t, unsigned, unsigned long);
    int (*ioctl)(struct block_device*, fmode_t, unsigned, unsigned long);
    int (*compat_ioctl)(struct block_device*, fmode_t, unsigned, unsigned long);
    int (*direct_access)(struct block_device*, sector_t, void**, unsigned long*);
    int (*media_changed)(struct gendisk*);
    int (*revalidate_disk)(struct gendisk*);
    // 获取磁盘信息，包括磁头、柱面和扇区等信息
    int (*getgeo)(struct block_device*, struct hd_geometry*);
    blk_qc_t (*submit_bio)(struct bio* bio);
    struct module* owner;
}

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

static struct my_block_dev {
    //...
    struct gendisk* gd;
    //...
} dev;

static int my_block_open(struct block_device* bdev, fmode_t mode) {
    //...

    return 0;
}

static int my_block_release(struct gendisk* gd, fmode_t mode) {
    //...

    return 0;
}

struct block_device_operations my_block_ops = {.owner = THIS_MODULE, .open = my_block_open, .release = my_block_release};

static int create_block_device(struct my_block_dev* dev) {
    //....
    dev->gd->fops = &my_block_ops;
    dev->gd->private_data = dev;
    //...
}

// include/linux/blkdev.h 结构体已删减
struct request_queue {
    struct list_head queue_head;
    struct request* last_merge;
    struct elevator_queue* elevator;
    request_fn_proc* request_fn;
    make_request_fn* make_request_fn;
    void* queuedata;
    struct list_head icq_list;
    struct queue_limits limits;
    struct blk_flush_queue* fq;
    struct list_head requeue_list;
    spinlock_t requeue_lock;
    struct delayed_work requeue_work;
};