• 全面详细介绍Linux 虚拟文件系统（VFS）原理

    一. 通用文件模型

    Linux内核支持装载不同的文件系统类型，不同的文件系统有各自管理文件的方式。Linux中标准的文件系统为Ext文件系统族，当然，开发者不能为他们使用的每种文件系统采用不同的文件存取方式，这与操作系统作为一种抽象机制背道而驰。

    为支持各种文件系统，Linux内核在用户进程（或C标准库）和具体的文件系统之间引入了一个抽象层，该抽象层称之为“虚拟文件系统（VFS）”。

    VFS一方面提供一种操作文件、目录及其他对象的统一方法，使用户进程不必知道文件系统的细节。另一方面，VFS提供的各种方法必须和具体文件系统的实现达成一种妥协，毕竟对几十种文件系统类型进行统一管理并不是件容易的事。

    为此，VFS中定义了一个通用文件模型，以支持文件系统中对象（或文件）的统一视图。

    Linux对Ext文件系统族的支持是最好的，因为VFS抽象层的组织与Ext文件系统类似，这样在处理Ext文件系统时可以提高性能，因为在Ext和VFS之间转换几乎不会损失时间。

    内核处理文件的关键是inode，每个文件（和目录）都有且只有一个对应的inode（struct inode实例），其中包含元数据和指向文件数据的指针，但inode并不包含文件名。系统中所有的inode都有一个特定的编号，用于唯一的标识各个inode。文件名可以随时更改，但是索引节点对文件是唯一的，并且随文件的存在而存在。

    对于每个已经挂载的文件系统，VFS在内核中都生成一个超级块结构（struct super_block实例），超级块代表一个已经安装的文件系统，用于存储文件系统的控制信息，例如文件系统类型、大小、所有inode对象、脏的inode链表等。

    inode和super block在存储介质中都是有实际映射的，即存储介质中也存在超级块和inode。但是由于不同类型的文件系统差异，超级块和inode的结构不尽相同。而VFS的作用就是通过具体的设备驱动获得某个文件系统中的超级块和inode节点，然后将其中的信息填充到内核中的struct super_block和struct inode中，以此来试图对不同文件系统进行统一管理。

    由于块设备速度较慢（于内存而言），可能需要很长时间才能找到与一个文件名关联的inode。Linux使用目录项（dentry）缓存来快速访问此前的查找操作结果。在VFS读取了一个目录或文件的数据之后，则创建一个dentry实例（struct dentry），以缓存找到的数据。

    dentry结构的主要用途就是建立文件名和相关的inode之间的联系。一个文件系统中的dentry对象都被放在一个散列表中，同时不再使用的dentry对象被放到超级块指向的一个LRU链表中，在某个时间点会删除比较老的对象以释放内存。

     【文章福利】小编推荐自己的Linux内核技术交流群： 【977878001】整理一些个人觉得比较好得学习书籍、视频资料共享在群文件里面，有需要的可以自行添加哦！！！前100进群领取，额外赠送一份 价值699的内核资料包（含视频教程、电子书、实战项目及代码）

    内核资料直通车：Linux内核源码技术学习路线+视频教程代码资料

    学习直通车：Linux内核源码/内存调优/文件系统/进程管理/设备驱动/网络协议栈

    另外简单提一下两个数据结构：

    每种注册到内核的文件系统类型以struct file_system_type结构表示，每种文件系统类型中都有一个链表，指向所有属于该类型的文件系统的超级块。

    当一个文件系统挂载到内核文件系统的目录树上，会生成一个挂载点，用来管理所挂载的文件系统的信息。该挂载点用一个struct vfsmount结构表示，这个结构后面会提到。

    上面的这些结构的关系大致如下：

    其中红色字体的链表为内核中的全局链表。

    二. 挂载文件系统

    在用户程序中，使用mount系统调用来挂载文件系统，相应的使用umount卸载文件系统。当然，内核必须支持将要挂载的文件系统类型，在内核启动时或者在安装内核模块时，可以注册特定的文件系统类型到内核，注册的函数为register_filesystem()。

    mount命令最常用的方式是mount [-t fstype] something somewhere

    其中something是将要被挂载的设备或目录，somewhere指明要挂载到何处。-t选项指明挂载的文件系统类型。由于something指向的设备是一个已知设备，即其上的文件系统类型是确定的，所以-t选项必须设置正确才能挂载成功。

    每个装载的文件系统都对应一个vfsmount结构的实例。

    由于装载过程是向内核文件系统目录树中添加装载点，这些装载点就存在一种父子关系，这和父目录与子目录的关系类似。例如，我的根文件系统类型是squashfs，装载到根目录“/”，生成一个挂载点，之后我又在/tmp目录挂载了ramfs文件系统，在根文件系统中的tmp目录生成了一个挂载点，这两个挂载点就是父子关系。这种关系存储在struct vfsmount结构中。

    在下图中，根文件系统为squashfs，根目录为“/”，然后创建/tmp目录，并挂载为ramfs，之后又创建了/tmp/usbdisk/volume9和/tmp/usbdisk/volume1两个目录，并将/tmp/dev/sda1和/tmp/dev/sdb1两个分区挂载到这两个目录上。其中/tmp/dev/sda1设备上有如下文件：

    gccbacktrace/

    ----> gcc_backtrace.c

    ---->man_page.log

    ---->readme.txt

    notes-fs.txt

    smb.conf

    挂载完成后，VFS中相关的数据结构的关系如图所示。

    mount系统调用在内核中的入口点是sys_mount函数，该函数将装载的选项从用户态复制一份，然后调用do_mount()函数进行挂载，这个函数做的事情就是通过特定文件系统读取超级块和inode信息，然后建立VFS的数据结构并建立上图中的关系。

    在父文件系统中的某个目录上挂载另一个文件系统后，该目录原来的内容就被隐藏了。例如，/tmp/samba/是非空的，然后，我将/tmp/dev/sda1挂载到/tmp/samba上，那这时/tmp/samba/目录下就只能看到/tmp/dev/sda1设备上的文件，直到将该设备卸载，原来目录中的文件才会显示出来。这是通过struct vfsmount中的mnt_mountpoint和mnt_root两个成员来实现的，这两个成员分别保存了在父文件系统中挂载点的dentry和在当前文件系统中挂载点的dentry，在卸载当前挂载点之后，可以找回挂载目录在父文件系统中的dentry对象。

    三. 一个进程中与文件系统相关的信息

    1. struct task_struct {
    2. 	……
    3. 	/* filesystem information */
    4. 	struct fs_struct *fs;
    5. 	/* open file information */
    6. 	struct files_struct *files;
    7. 	/* namespaces */
    8. 	struct nsproxy *nsproxy;
    9. 	……
    10. }

    其中fs成员指向进程当前工作目录的文件系统信息。files成员指向了进程打开的文件的信息。nsproxy指向了进程所在的命名空间，其中包含了虚拟文件系统命名空间。

    从上图可以看到，fs中包含了文件系统的挂载点和挂载点的dentry信息。而files指向了一系列的struct file结构，其中struct path结构用于将struct file和vfsmount以及dentry联系起来。struct file保存了内核所看到的文件的特征信息，进程打开的文件列表就存放在task_struct->files->fd_array[]数组以及fdtable中。

    task_struct结构还存放了其打开文件的文件描述符fd的信息，这是用户进程需要用到的，用户进程在通过文件名打开一个文件后，文件名就没有用处了，之后的操作都是对文件描述符fd的，在内核中，fget_light()函数用于通过整数fd来查找对应的struct file对象。由于每个进程都维护了自己的fd列表，所以不同进程维护的fd的值可以重复，例如标准输入、标准输出和标准错误对应的fd分别为0、1、2。

    struct file的mapping成员指向属于文件相关的inode实例的地址空间映射，通常它设置为inode->i_mapping。在读写一个文件时，每次都从物理设备上获取文件的话，速度会很慢，在内核中对每个文件分配一个地址空间，实际上是这个文件的数据缓存区域，在读写文件时只是操作这块缓存，通过内核有相应的同步机制将脏的页写回物理设备。super_block中维护了一个脏的inode的链表。

    struct file的f_op成员指向一个struct file_operations实例（图中画错了，不是f_pos），该结构保存了指向所有可能文件操作的指针，如read/write/open等。

    1. struct file_operations {
    2. 	struct module *owner;
    3. 	loff_t (*llseek) (struct file *, loff_t, int);
    4. 	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    5. 	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    6. 	ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    7. 	ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    8. 	int (*readdir) (struct file *, void *, filldir_t);
    9. 	unsigned int (*poll) (struct file *, struct poll_table_struct *);
    10. 	int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
    11. 	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    12. 	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    13. 	int (*mmap) (struct file *, struct vm_area_struct *);
    14. 	int (*open) (struct inode *, struct file *);
    15. 	int (*flush) (struct file *, fl_owner_t id);
    16. 	int (*release) (struct inode *, struct file *);
    17. 	int (*fsync) (struct file *, struct dentry *, int datasync);
    18. 	……
    19. };

    四. 打包文件系统

    在制作好了文件系统的目录之后，可通过特定于文件系统类型的工具对目录进行打包，即制作文件系统。例如squashfs文件系统的打包工具为mksquashfs。除了打包之外，打包工具还针对特定文件系统生成超级块和inode节点信息，最终生成的文件系统镜像可以被内核解释并挂载。

    附录 VFS相关数据结构

    inode：

    1. struct inode {
    2. 	/* 全局的散列表 */
    3. 	struct hlist_node	i_hash;
    4. 	/* 根据inode的状态可能处理不同的链表中（inode_unused/inode_in_use/super_block->dirty） */
    5. 	struct list_head	i_list;
    6. 	/* super_block->s_inodes链表的节点 */
    7. 	struct list_head	i_sb_list;
    8. 	/* inode对应的dentry链表，可能多个dentry指向同一个文件 */
    9. 	struct list_head	i_dentry;
    10. 	/* inode编号 */
    11. 	unsigned long		i_ino;
    12. 	/* 访问该inode的进程数目 */
    13. 	atomic_t		i_count;
    14. 	/* inode的硬链接数 */
    15. 	unsigned int		i_nlink;
    16. 	uid_t			i_uid;
    17. 	gid_t			i_gid;
    18. 	/* inode表示设备文件时的设备号 */
    19. 	dev_t			i_rdev;
    20. 	u64			i_version;
    21. 	/* 文件的大小，以字节为单位 */
    22. 	loff_t			i_size;
    23. #ifdef __NEED_I_SIZE_ORDERED
    24. 	seqcount_t		i_size_seqcount;
    25. #endif
    26. 	/* 最后访问时间 */
    27. 	struct timespec		i_atime;
    28. 	/* 最后修改inode数据的时间 */
    29. 	struct timespec		i_mtime;
    30. 	/* 最后修改inode自身的时间 */
    31. 	struct timespec		i_ctime;
    32. 	/* 以block为单位的inode的大小 */
    33. 	blkcnt_t		i_blocks;
    34. 	unsigned int		i_blkbits;
    35. 	unsigned short          i_bytes;
    36. 	/* 文件属性，低12位为文件访问权限，同chmod参数含义，其余位为文件类型，如普通文件、目录、socket、设备文件等 */
    37. 	umode_t			i_mode;
    38. 	spinlock_t		i_lock;	/* i_blocks, i_bytes, maybe i_size */
    39. 	struct mutex		i_mutex;
    40. 	struct rw_semaphore	i_alloc_sem;
    41. 	/* inode操作 */
    42. 	const struct inode_operations	*i_op;
    43. 	/* file操作 */
    44. 	const struct file_operations	*i_fop;
    45. 	/* inode所属的super_block */
    46. 	struct super_block	*i_sb;
    47. 	struct file_lock	*i_flock;
    48. 	/* inode的地址空间映射 */
    49. 	struct address_space	*i_mapping;
    50. 	struct address_space	i_data;
    51. #ifdef CONFIG_QUOTA
    52. 	struct dquot		*i_dquot[MAXQUOTAS];
    53. #endif
    54. 	struct list_head	i_devices; /* 若为设备文件的inode，则为设备的打开文件列表节点 */
    55. 	union {
    56. 		struct pipe_inode_info	*i_pipe;
    57. 		struct block_device	*i_bdev; /* 若为块设备的inode，则指向该设备实例 */
    58. 		struct cdev		*i_cdev; /* 若为字符设备的inode，则指向该设备实例 */
    59. 	};
    60.  
    61. 	__u32			i_generation;
    62.  
    63. #ifdef CONFIG_FSNOTIFY
    64. 	__u32			i_fsnotify_mask; /* all events this inode cares about */
    65. 	struct hlist_head	i_fsnotify_mark_entries; /* fsnotify mark entries */
    66. #endif
    67.  
    68. #ifdef CONFIG_INOTIFY
    69. 	struct list_head	inotify_watches; /* watches on this inode */
    70. 	struct mutex		inotify_mutex;	/* protects the watches list */
    71. #endif
    72.  
    73. 	unsigned long		i_state;
    74. 	unsigned long		dirtied_when;	/* jiffies of first dirtying */
    75.  
    76. 	unsigned int		i_flags; /* 文件打开标记，如noatime */
    77.  
    78. 	atomic_t		i_writecount;
    79. #ifdef CONFIG_SECURITY
    80. 	void			*i_security;
    81. #endif
    82. #ifdef CONFIG_FS_POSIX_ACL
    83. 	struct posix_acl	*i_acl;
    84. 	struct posix_acl	*i_default_acl;
    85. #endif
    86. 	void			*i_private; /* fs or device private pointer */
    87. };

    super_block：

    1. struct super_block {
    2. 	/* 全局链表元素 */
    3. 	struct list_head	s_list;
    4. 	/* 底层文件系统所在的设备 */
    5. 	dev_t			s_dev;
    6. 	/* 文件系统中每一块的长度 */
    7. 	unsigned long		s_blocksize;
    8. 	/* 文件系统中每一块的长度（以2为底的对数） */
    9. 	unsigned char		s_blocksize_bits;
    10. 	/* 是否需要向磁盘回写 */
    11. 	unsigned char		s_dirt;
    12. 	unsigned long long	s_maxbytes;	/* Max file size */
    13. 	/* 文件系统类型 */
    14. 	struct file_system_type	*s_type;
    15. 	/* 超级块操作方法 */
    16. 	const struct super_operations	*s_op;
    17. 	struct dquot_operations	*dq_op;
    18.  	struct quotactl_ops	*s_qcop;
    19. 	const struct export_operations *s_export_op;
    20. 	unsigned long		s_flags;
    21. 	unsigned long		s_magic;
    22. 	/* 全局根目录的dentry */
    23. 	struct dentry		*s_root;
    24. 	struct rw_semaphore	s_umount;
    25. 	struct mutex		s_lock;
    26. 	int			s_count;
    27. 	int			s_need_sync;
    28. 	atomic_t		s_active;
    29. #ifdef CONFIG_SECURITY
    30. 	void                    *s_security;
    31. #endif
    32. 	struct xattr_handler	**s_xattr;
    33. 	/* 超级块管理的所有inode的链表 */
    34. 	struct list_head	s_inodes;	/* all inodes */
    35. 	/* 脏的inode的链表 */
    36. 	struct list_head	s_dirty;	/* dirty inodes */
    37. 	struct list_head	s_io;		/* parked for writeback */
    38. 	struct list_head	s_more_io;	/* parked for more writeback */
    39. 	struct hlist_head	s_anon;		/* anonymous dentries for (nfs) exporting */
    40. 	/* file结构的链表，该超级块上所有打开的文件 */
    41. 	struct list_head	s_files;
    42. 	/* s_dentry_lru and s_nr_dentry_unused are protected by dcache_lock */
    43. 	/* 不再使用的dentry的LRU链表 */
    44. 	struct list_head	s_dentry_lru;	/* unused dentry lru */
    45. 	int			s_nr_dentry_unused;	/* # of dentry on lru */
    46.  
    47. 	struct block_device	*s_bdev;
    48. 	struct mtd_info		*s_mtd;
    49. 	/* 相同文件系统类型的超级块链表的节点 */
    50. 	struct list_head	s_instances;
    51. 	struct quota_info	s_dquot;	/* Diskquota specific options */
    52.  
    53. 	int			s_frozen;
    54. 	wait_queue_head_t	s_wait_unfrozen;
    55.  
    56. 	char s_id[32];				/* Informational name */
    57.  
    58. 	void 			*s_fs_info;	/* Filesystem private info */
    59. 	fmode_t			s_mode;
    60.  
    61. 	/*
    62. 	 * The next field is for VFS *only*. No filesystems have any business
    63. 	 * even looking at it. You had been warned.
    64. 	 */
    65. 	struct mutex s_vfs_rename_mutex;	/* Kludge */
    66.  
    67. 	/* Granularity of c/m/atime in ns.
    68. 	   Cannot be worse than a second */
    69. 	u32		   s_time_gran;
    70.  
    71. 	/*
    72. 	 * Filesystem subtype.  If non-empty the filesystem type field
    73. 	 * in /proc/mounts will be "type.subtype"
    74. 	 */
    75. 	char *s_subtype;
    76.  
    77. 	/*
    78. 	 * Saved mount options for lazy filesystems using
    79. 	 * generic_show_options()
    80. 	 */
    81. 	char *s_options;
    82. };

    dentry：

    1. struct dentry {
    2. 	atomic_t d_count;
    3. 	unsigned int d_flags;		/* protected by d_lock */
    4. 	spinlock_t d_lock;		/* per dentry lock */
    5. 	/* 该dentry是否是一个装载点 */
    6. 	int d_mounted;
    7. 	/* 文件所属的inode */
    8. 	struct inode *d_inode;
    9. 	/*
    10. 	 * The next three fields are touched by __d_lookup.  Place them here so they all fit in a cache line.
    11. 	 */
    12. 	/* 全局的dentry散列表 */
    13. 	struct hlist_node d_hash;	/* lookup hash list */
    14. 	/* 父目录的dentry */
    15. 	struct dentry *d_parent;	/* parent directory */
    16. 	/* 文件的名称，例如对/tmp/a.sh，文件名即为a.sh */
    17. 	struct qstr d_name;
    18. 	/* 脏的dentry链表的节点 */
    19. 	struct list_head d_lru;		/* LRU list */
    20. 	/*
    21. 	 * d_child and d_rcu can share memory
    22. 	 */
    23. 	union {
    24. 		struct list_head d_child;	/* child of parent list */
    25. 	 	struct rcu_head d_rcu;
    26. 	} d_u;
    27. 	/* 该dentry子目录中的dentry的节点链表 */
    28. 	struct list_head d_subdirs;	/* our children */
    29. 	/* 硬链接使用几个不同名称表示同一个文件时，用于连接各个dentry */
    30. 	struct list_head d_alias;	/* inode alias list */
    31. 	unsigned long d_time;		/* used by d_revalidate */
    32. 	const struct dentry_operations *d_op;
    33. 	/* 所属的super_block */
    34. 	struct super_block *d_sb;	/* The root of the dentry tree */
    35. 	void *d_fsdata;			/* fs-specific data */
    36. 	/* 如果文件名由少量字符组成，在保存在这里，加速访问 */
    37. 	unsigned char d_iname[DNAME_INLINE_LEN_MIN];	/* small names */
    38. };

    vfsmount：

    1. struct vfsmount {
    2. 	/* 全局散列表 */
    3. 	struct list_head mnt_hash;
    4. 	/* 父文件系统的挂载点 */
    5. 	struct vfsmount *mnt_parent;	/* fs we are mounted on */
    6. 	/* 父文件系统中该挂载点的dentry */
    7. 	struct dentry *mnt_mountpoint;	/* dentry of mountpoint */
    8. 	/* 当前文件系统中该挂载点的dentry */
    9. 	struct dentry *mnt_root;	/* root of the mounted tree */
    10. 	/* 指向super_block */
    11. 	struct super_block *mnt_sb;	/* pointer to superblock */
    12. 	/* 该挂载点下面的子挂载点列表 */
    13. 	struct list_head mnt_mounts;	/* list of children, anchored here */
    14. 	/* 父文件系统的子挂载点的列表节点 */
    15. 	struct list_head mnt_child;	/* and going through their mnt_child */
    16. 	int mnt_flags;
    17. 	/* 4 bytes hole on 64bits arches */
    18. 	/* 挂载的设备，如/dev/dsk/hda1 */
    19. 	const char *mnt_devname;
    20. 	/* 虚拟文件系统命名空间中的链表节点 */
    21. 	struct list_head mnt_list;
    22. 	struct list_head mnt_expire;	/* link in fs-specific expiry list */
    23. 	struct list_head mnt_share;	/* circular list of shared mounts */
    24. 	struct list_head mnt_slave_list;/* list of slave mounts */
    25. 	struct list_head mnt_slave;	/* slave list entry */
    26. 	struct vfsmount *mnt_master;	/* slave is on master->mnt_slave_list */
    27. 	/* 所在的虚拟文件系统命名空间*/
    28. 	struct mnt_namespace *mnt_ns;	/* containing namespace */
    29. 	int mnt_id;			/* mount identifier */
    30. 	int mnt_group_id;		/* peer group identifier */
    31. 	/*
    32. 	 * We put mnt_count & mnt_expiry_mark at the end of struct vfsmount
    33. 	 * to let these frequently modified fields in a separate cache line
    34. 	 * (so that reads of mnt_flags wont ping-pong on SMP machines)
    35. 	 */
    36. 	atomic_t mnt_count;
    37. 	int mnt_expiry_mark;		/* true if marked for expiry */
    38. 	int mnt_pinned;
    39. 	int mnt_ghosts;
    40. #ifdef CONFIG_SMP
    41. 	int *mnt_writers;
    42. #else
    43. 	int mnt_writers;
    44. #endif
    45. };
  • 相关阅读:
    已解决TypeError: __init__() missing 1 required positional argument: ‘scheme‘
    分布式锁的3种实现！附代码
    springboot项目讲解
    第十九章 Kali Linux桌面概览
    Docker实践笔记04：Tomcat环境DockerFile制作
    洛谷P2345 MooFest G
    【LeetCode热题100】--74.搜索二维矩阵
    世界前沿技术发展报告2023《世界航空技术发展报告》（四）无人机技术
    Leetcode—53.最大子数组和【中等】
    【CVPR2020】DEF：Seeing Through Fog Without Seeing Fog论文阅读分析与总结
  • 原文地址：https://blog.csdn.net/m0_74282605/article/details/127848570