虚拟文件系统（虚拟文件交换/VFS）作为内核子系统，为用户空间程序提供了文件和文件系统相关的接口。

1. 通用文件系统接口

VFS使得用户可以直接使用open()、read()和write()这样的系统调用而无须考虑具体文件系统和实际物理介质。

新的文件系统和新类型的存储介质都能找到进入Linux之路，程序无需重写，甚至无须重新编译。

VFS把各种不同的文件系统抽象后采用统一的方式进行操作。

VFS与块I/O相结合，提供抽象、接口以及交融，使得用户空间的程序调用用统一的系统调用访问各种文件，不管文件系统是什么，也不管文件系统位于何种介质，采用的命名策略是统一的。

2.文件系统抽象层

内核在底层文件系统接口上建立了一个抽象层，所以可以使用这种通用接口对所有类型的文件系统进行操作。

VFS抽象层之所以能够衔接各种各样的文件系统，是因为定义了所有文件系统都支持的、基本的、概念上的接口和数据结构等抽象性行为。（抽象）

在VFS层和内核的其他部分看来，所有文件系统都是相同的，它们都支持像文件和目录这样的概念，同时也支持像创建文件和删除文件这样的操作。

ps:在内核中，除了文件系统本身外，其他部分并不需要了解文件系统的内部细节。（因为其他相关部分都是抽象性的行为）

3.Unix文件系统

Unix文件系统使用了四种和文件系统相关的传统抽象概念：文件、目录项、索引节点和安装点(mount point)。

从本质上将文件系统就是特殊的数据分层存储结构，它包含文件、目录和相关的控制信息。文件系统的通用操作包含创建、删除和安装等。

在Unix系统中，文件系统被安装在一个特定的安装点上，该安装点在全局层次结构中被称作命名空间，所有的已安装文件系统都作为根文件系统树的枝叶出现在系统中。

文件其实可以做一个有序字节串，字节串中第一个字节是文件的头，最后一个字节是文件的尾。

文件通过目录组织起来。
在Unix系统中，目录属于普通文件，它列出包含在其中的所有文件，由于VFS把目录当做文件对待，所以可以对目录执行和文件相同的操作。

Unix系统将文件的相关信息和文件本身这两个概念加以区分。
文件相关信息被称作文件的元数据（文件的相关数据），被存储在一个单独的数据结构中，该结构被称为索引节点(inode)。

4.VFS对象及其数据结构

VFS采用的是面向对象的设计思路，使用一组数据结构来代表通用文件对象。

VFS中有四个主要的对象类型（结构体类型），如：

1. 超级块对象，它代表一个具体的已安装文件系统；
2. 索引节点对象，它代表一个具体文件；
3. 目录项对象，它代表一个目录项，是路径的一个组成部分；
4. 文件对象，它代表由进程打开的文件。

每个主要对象都包含一个操作对象，如下所示：

1. super_oprations对象，其中包括内核针对特定文件系统所能调用的方法，如wirte_inode()和sync_fs()等方法；
2. inode_operations对象，其中包括内核针对特定文件所能调用的方法，比如create()和link()等方法；
3. dentry_operations对象，其中包括内核针对特定目录所能调用的方法，比如d_compare()和d_delete()等方法；
4. file_operations对象，其中包括进程针对已打开文件所能调用的方法，比如read()和write()等方法。

操作对象作为一个结构体指针来实现，此结构体中包含指向操作其父对象的函数指针。

VFS使用了大量结构体对象，它所包括的对象远远多于上面提到的这几种主要对象。

fs_struct结构体和file结构体描述了文件系统以及和进程相关的文件。

5.超级块对象

各种文件系统都必须实现超级块对象，该对象用于存储特定文件系统的信息，通常对应于存放在磁盘特定扇区中的文件系统超级块或文件系统控制块。

对于并非基于磁盘的文件系统（如基于内存的文件系统–sysfs），它们会在使用现场创建超级块并将其保存到内存中。

超级块对象由super_block结构体表示，定义在文件<linux/fs.h>中，如下（选自kernel版本3.10）：

struct super_block {
	struct list_head	s_list;		/* Keep this first 指向所有超级块的链表 */
	dev_t			s_dev;		/* search index; _not_ kdev_t 设备标识符 */
	unsigned char		s_blocksize_bits;	/* 以字节为单位的块大小 */
	unsigned long		s_blocksize;		/* 以位为单位的块大小 */
	loff_t			s_maxbytes;	/* Max file size 文件大小上限*/
	struct file_system_type	*s_type;	/* 文件系统类型 */
	const struct super_operations	*s_op;	/* 超级块方法 -- 重点域 */
	const struct dquot_operations	*dq_op;	/* 磁盘限额方法 */
	const struct quotactl_ops	*s_qcop;	/* 限额控制方法 */
	const struct export_operations *s_export_op;	/* 导出方法 */
	unsigned long		s_flags;				/* 挂载标志 */
	unsigned long		s_magic;				/* 文件系统的幻数 */
	struct dentry		*s_root;				/* 目录挂载点 */
	struct rw_semaphore	s_umount;				/* 卸载信号量 */
	int			s_count;						/* 超级块引用计数 */
	atomic_t		s_active;					/* 活动引用计数 */
#ifdef CONFIG_SECURITY
	void                    *s_security;		/* 安全模块 */
#endif
	const struct xattr_handler **s_xattr;		/* 扩展的属性操作 */

	struct list_head	s_inodes;	/* all inodes inodes 链表 */
	struct hlist_bl_head	s_anon;		/* anonymous dentries for (nfs) exporting 匿名目录项 */
#ifdef CONFIG_SMP
	struct list_head __percpu *s_files;		
#else
	struct list_head	s_files;		/* 被分配文件链表 */
#endif
	struct list_head	s_mounts;	/* list of mounts; _not_ for fs use */
	/* s_dentry_lru, s_nr_dentry_unused protected by dcache.c lru locks */
	struct list_head	s_dentry_lru;	/* unused dentry lru  未被使用目录项链表 */
	int			s_nr_dentry_unused;	/* # of dentry on lru  链表中目录项的数目 */

	/* s_inode_lru_lock protects s_inode_lru and s_nr_inodes_unused */
	spinlock_t		s_inode_lru_lock ____cacheline_aligned_in_smp;
	struct list_head	s_inode_lru;		/* unused inode lru */
	int			s_nr_inodes_unused;	/* # of inodes on lru */

	struct block_device	*s_bdev;		/* 相关的块设备 */
	struct backing_dev_info *s_bdi;	
	struct mtd_info		*s_mtd;			/* 存储磁盘信息 */
	struct hlist_node	s_instances;	/* 该类型文件系统 */
	struct quota_info	s_dquot;	/* Diskquota specific options  限额相关选项 */

	struct sb_writers	s_writers;

	char s_id[32];				/* Informational name  文本名字 */
	u8 s_uuid[16];				/* UUID */

	void 			*s_fs_info;	/* Filesystem private info  文件系统特殊信息 */
	unsigned int		s_max_links;
	fmode_t			s_mode;		/* 安装权限 */

	/* Granularity of c/m/atime in ns.
	   Cannot be worse than a second */
	u32		   s_time_gran;		/* 时间戳粒度 */

	/*
	 * The next field is for VFS *only*. No filesystems have any business
	 * even looking at it. You had been warned.
	 */
	struct mutex s_vfs_rename_mutex;	/* Kludge */

	/*
	 * Filesystem subtype.  If non-empty the filesystem type field
	 * in /proc/mounts will be "type.subtype"
	 */
	char *s_subtype;				/* 子类型名称 */

	/*
	 * Saved mount options for lazy filesystems using
	 * generic_show_options()
	 */
	char __rcu *s_options;			/* 已存安装选项 */
	const struct dentry_operations *s_d_op; /* default d_op for dentries */

	/*
	 * Saved pool identifier for cleancache (-1 means none)
	 */
	int cleancache_poolid;

	struct shrinker s_shrink;	/* per-sb shrinker handle */

	/* Number of inodes with nlink == 0 but still referenced */
	atomic_long_t s_remove_count;

	/* Being remounted read-only */
	int s_readonly_remount;
};

创建、管理和撤销超级块对象的代码位于文件fs/super.c中。
超级块对象通过alloc_super()函数创建并初始化。
在文件系统安装时，文件系统会调用该函数以便从磁盘读取文件系统超级块，并将其信息填充到内存中的超级块对象中。

6.超级块操作

超级块对象中最重要的一个域就是s_op，它指向超级块的操作函数表。
超级块操作函数表由super_oprations结构体表示，定义在文件<linux/fs.h>中，如下（选自kernel版本3.10）：
当文件系统需要对其超级块执行操作时，首先要在超级块对象中寻找需要的操作方法。

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);
};

下表解释super_oprations中超级块操作函数的用法：

以上所有函数都是由VFS再进程上下文中调用。除了dirty_inode()其他函数在必要时都可以阻塞。

这其中一些函数是可选的。在超级块操作表中，文件系统可以将不需要的函数指针设置成NULL。

如果VFS发现操作函数指针是NULL，那它要么就会调用通用函数执行相应操作，要么什么也不做，如果选择取决于具体操作。

7.索引节点对象

索引节点对象包含了内核在操作文件或目录时需要的全部信息。
索引节点对象必须在内存中创建，以便于文件系统使用。
索引节点对象由inode结构体表示，定义在文件<linux/fs.h>中，如下（选自kernel版本3.10）：

struct inode {
	umode_t			i_mode;
	unsigned short		i_opflags;
	kuid_t			i_uid;				/* 使用者的id */
	kgid_t			i_gid;				/* 使用组的id */
	unsigned int		i_flags;

#ifdef CONFIG_FS_POSIX_ACL
	struct posix_acl	*i_acl;
	struct posix_acl	*i_default_acl;
#endif

	const struct inode_operations	*i_op;		/* 索引节点操作表 -- 重要域 */
	struct super_block	*i_sb;					/* 相关的超级块 */
	struct address_space	*i_mapping;			/* 相关的地址映射 */

#ifdef CONFIG_SECURITY
	void			*i_security;				/* 安全模块 */
#endif

	/* Stat data, not accessed from path walking */
	unsigned long		i_ino;			/* 节点号 */
	/*
	 * Filesystems may only read i_nlink directly.  They shall use the
	 * following functions for modification:
	 *
	 *    (set|clear|inc|drop)_nlink
	 *    inode_(inc|dec)_link_count
	 */
	union {								/* 硬连接数 */
		const unsigned int i_nlink;
		unsigned int __i_nlink;
	};
	dev_t			i_rdev;				/* 实际设备标识符 */
	loff_t			i_size;				/* 以字节为单位的文件大小 */
	struct timespec		i_atime;		/* 最后访问时间 */
	struct timespec		i_mtime;		/* 最后修改时间 */
	struct timespec		i_ctime;		/* 最后改变时间 */
	spinlock_t		i_lock;	/* i_blocks, i_bytes, maybe i_size */
	unsigned short          i_bytes;	/* 使用的字节数 */
	unsigned int		i_blkbits;		/* 以位为单位的块大小 */
	blkcnt_t		i_blocks;			/* 文件的块数 */

#ifdef __NEED_I_SIZE_ORDERED
	seqcount_t		i_size_seqcount;	/* 对 i_size 进行串行计数 */
#endif

	/* Misc */
	unsigned long		i_state;		/* 状态标志 */
	struct mutex		i_mutex;		

	unsigned long		dirtied_when;	/* jiffies of first dirtying 第一次弄脏数据的时间 */

	struct hlist_node	i_hash;		/* 散列表 */
	struct list_head	i_wb_list;	/* backing dev IO list */
	struct list_head	i_lru;		/* inode LRU list */
	struct list_head	i_sb_list;	/* 超级块链表 */
	union {
		struct hlist_head	i_dentry;	/* 目录项链表 */
		struct rcu_head		i_rcu;
	};
	u64			i_version;				/* 版本号 */
	atomic_t		i_count;			/* 引用计数 */
	atomic_t		i_dio_count;
	atomic_t		i_writecount;		/* 写者计数 */
	const struct file_operations	*i_fop;	/* former ->i_op->default_file_ops 缺省的索引节点操作 */
	struct file_lock	*i_flock;		/* 文件锁链表 */
	struct address_space	i_data;		/* 设备地址映射 */
#ifdef CONFIG_QUOTA
	struct dquot		*i_dquot[MAXQUOTAS];	/* 索引节点的磁盘限额 */
#endif
	struct list_head	i_devices;				/* 块设备链表 */
	union {
		struct pipe_inode_info	*i_pipe;		/* 管道信息 */
		struct block_device	*i_bdev;			/* 块设备驱动 */
		struct cdev		*i_cdev;				/* 字符设备驱动 */
	};

	__u32			i_generation;

#ifdef CONFIG_FSNOTIFY
	__u32			i_fsnotify_mask; /* all events this inode cares about */
	struct hlist_head	i_fsnotify_marks;
#endif

#ifdef CONFIG_IMA
	atomic_t		i_readcount; /* struct files open RO */
#endif
	void			*i_private; /* fs or device private pointer fs私有指针 */
};

一个索引节点代表文件系统中（索引节点仅当文件被访问时，才在内存中创建）的一个文件，
也可以是设备或者管道这样的特殊文件。因此索引节点结构体中有一些和特殊文件相关的项。
如上述的i_pipe、i_bdev和i_cdev三个指针代表三个不同的特殊文件，它们被存放在一个联合体（union）中，因为一个给定的索引节点每次只能表示三者之一或者三者均不。

8.索引节点操作

索引节点对象中的inode_operations项非常重要，描述了VFS用以操作索引节点对象的所有方法，这些方法由文件系统实现。

inode_operations结构体定义在文件<linux/fs.h>中，如下（选自kernel版本3.10）：

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;

上述这些接口由各种函数组成，在给定的节点上，可能由VFS执行这些函数，也可能由具体的文件系统执行。
下表解释inode_operations 中索引节点操作函数的用法：

9.目录项对象

VFS把目录当作文件对待，路径中的每个组成部分都由一个索引节点对象表示。

目录项对象由dentry结构体表示，定义在文件<linux/dcache.h>中，如下（选自kernel版本3.10）：

struct dentry {
	/* RCU lookup touched fields */
	unsigned int d_flags;		/* protected by d_lock 目录项标识 */
	seqcount_t d_seq;		/* per dentry seqlock */
	struct hlist_bl_node d_hash;	/* lookup hash list */
	struct dentry *d_parent;	/* parent directory 父目录的目录项对象 */
	struct qstr d_name;			/* 目录项名称 */
	struct inode *d_inode;		/* 相关联的索引节点 Where the name belongs to - NULL is
					 * negative */
	unsigned char d_iname[DNAME_INLINE_LEN];	/* small names */

	/* Ref lookup also touches following */
	unsigned int d_count;		/* protected by d_lock 使用记数 */
	spinlock_t d_lock;		/* per dentry lock  单目录项锁 */
	const struct dentry_operations *d_op;	/* 目录项操作指针 -- 重点域 */
	struct super_block *d_sb;	/* The root of the dentry tree 文件的超级块 */
	unsigned long d_time;		/* used by d_revalidate 重置时间 */
	void *d_fsdata;			/* fs-specific data 文件系统特有数据 */

	struct list_head d_lru;		/* LRU list 未使用的链表 */
	/*
	 * d_child and d_rcu can share memory
	 */
	union {
		struct list_head d_child;	/* child of parent list  目录项内部形成的链表 */
	 	struct rcu_head d_rcu;		/* RCU 加锁 */
	} d_u;
	struct list_head d_subdirs;	/* our children 子目录链表 */
	struct hlist_node d_alias;	/* inode alias list 索引节点别名链表 */
};

与前面的两个对象不同，目录项对象没有对应的磁盘数据结构，VFS根据字符串形式的路径名现场创建它。
而且由于目录项对象并发真正保存在磁盘上，所以目录项结构体没有是否被修改的标志（也就是是否为脏、是否需要写回磁盘的标志）

9.1 目录项状态–被使用、未被使用和负使用（无效目录项）

被使用：一个被使用的目录项对应一个有效的索引节点（即d_inode指向相应的索引节点）并且表明该对象存在一个或多个使用者（即d_count为正值）。一个目录项处于被使用状态，则意味着它正被VFS使用并且指向有效的数据，因此不能被丢弃。

未被使用：一个未被使用的目录项对应一个有效的索引节点（即d_inode指向一个索引节点），但是应指明VFS当前并未使用它（d_count为0）。可以撤销未使用的目录项。

负使用：一个负状态的目录项没有对应的有效索引节点（即d_inode为NULL），因为索引节点已被删除，或路径不再正确，但是目录项仍然保留，以便快速解析以后的路经查询。可以撤销。

9.2 目录项缓存

如果VFS层遍历路径名中的所有的元素并将它们逐个的解析成目录项对象，还要到达最深层目录，将是一件非常费力的工作，会浪费大量的时间，因此内核将目录项对象缓存在目录项缓存（dcache）中。

目录项缓冲包括如下三个主要部分：

1. “被使用的”目录项链表。该链表荣光索引节点对象中的i_dentry项连接相关的索引节点，因为一个给定的索引节点可能有多个链接，所以就可能有多个目录项对象，因为用一个链表来连接它们。
2. “最近被使用的”双向链表。该链表含有未被使用的和负状态的目录项对象（该链总是在头部插入目录项）。
3. 散列表和相应的散列函数用来快速地将给定路径解析为相关目录项对象。

散列表由数组dentry_hashtable表示，其中每一个元素都是一个指向具有相同键值的目录项对象链表的指针。数组的大小取决于系统中物理内存的大小。

实际的散列值由d_hash()函数计算，它是内核提供给文件系统的唯一的一个散列函数。

查找散列表要通过d_lookup()函数，如果该函数在dcache中发现了与其相匹配的目录项对象，则匹配的对象被返回，否则返回NULL指针。

10.目录项操作

dentry_operation结构体指明了VFS操作目录项的所有方法。
该结构定义在文件<linux/dcache.h>中，如下（选自kernel版本3.10）：

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;

下表解释inode_operations 中索引节点操作函数的用法：

11.文件对象

文件对象表示进程已打开的文件。

文件对象是已打开的文件在内存中的表示。

文件对象仅仅在进程观点上表示已打开的实际文件，反过来指向目录项对象（反过来指向索引节点），其实只有目录项对象才表示已打开的实际文件。

虽然一个文件对应的文件对象不是唯一的（因为多个进程可以同时打开和操作同一个文件），但对应的索引节点和目录项对象无疑是唯一的。

文件对象由file结构体表示，定义在文件<linux/fs.h>中，如下（选自kernel版本3.10）：

struct file {
	/*
	 * fu_list becomes invalid after file_free is called and queued via
	 * fu_rcuhead for RCU freeing
	 */
	union {
		struct list_head	fu_list;		/* 文件对象链表 */
		struct rcu_head 	fu_rcuhead;		/* 释放之后的 RCU 链表 */
	} f_u;
	struct path		f_path;					/* 包含目录项 */
#define f_dentry	f_path.dentry
	struct inode		*f_inode;	/* cached value */
	const struct file_operations	*f_op;	/* 文件操作表 -- 重要域 */

	/*
	 * Protects f_ep_links, f_flags, f_pos vs i_size in lseek SEEK_CUR.
	 * Must not be taken from IRQ context.
	 */
	spinlock_t		f_lock;					/* 单个文件结果锁 */
#ifdef CONFIG_SMP
	int			f_sb_list_cpu;
#endif
	atomic_long_t		f_count;			/* 文件对象的使用计数 */
	unsigned int 		f_flags;			/* 当打开文件时所指定的标志 */
	fmode_t			f_mode;					/* 文件的访问模式 */
	loff_t			f_pos;					/* 文件当前的位移量(文件指针) */
	struct fown_struct	f_owner;			/* 拥有者通过信号量进行异步 I/O 数据的传送 */
	const struct cred	*f_cred;			/* 文件的信任状 */
	struct file_ra_state	f_ra;			/* 预读状态 */

	u64			f_version;					/* 版本号 */
#ifdef CONFIG_SECURITY
	void			*f_security;			/* 安全模块 */
#endif
	/* needed for tty driver, and maybe others */
	void			*private_data;			/* tty 设备驱动的钩子 */

#ifdef CONFIG_EPOLL
	/* Used by fs/eventpoll.c to link all the hooks to this file */
	struct list_head	f_ep_links;			/* 事件池链表 */
	struct list_head	f_tfile_llink;		
#endif /* #ifdef CONFIG_EPOLL */
	struct address_space	*f_mapping;		/* 页缓存映射 */
#ifdef CONFIG_DEBUG_WRITECOUNT
	unsigned long f_mnt_write_state;		/* 调试状态 */
#endif
};

类似于目录项对象，文件对象实际上没有对于的磁盘数据。
所以在结构体中没有代表其对象是否为脏，是否需要写回磁盘的标志。

文件对象通过f_dentry指针指向相关的目录项对象。
目录项会指向相关的索引节点，索引节点会记录文件是否是脏的。

12.文件操作

文件对象的操作由file_operations结构体表示，定义在文件<linux/fs.h>中，如下（选自kernel版本3.10）：

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);
};

上述操作与系统调用很累死，这些操作是标准Unix系统调用的基础。

具体的文件系统可以为每一种操作做专门的实现，或者如果存在通用操作，也可以直接使用通用操作。

下表解释file_operations 中文件对象操作函数的用法：

ps:
BKL:大内核锁

13.和文件系统相关的数据结构

file_system_type 用来描述各种特定文件系统类型，如ext3,ext4或UDF；
vfsmount 用来描述一个安装文件系统的实例。

因为Linux支持众多不同的文件系统，所以内核必须由一个特殊的结构来描述每种文件系统的功能和行为。

file_system_type结构体被定义在<linux/fs.h>中，如下（选自kernel版本3.10）：

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	/* Can be mounted by userns root */
#define FS_USERNS_DEV_MOUNT	16 /* A userns mount does not imply MNT_NODEV */
#define FS_RENAME_DOES_D_MOVE	32768	/* FS will handle d_move() during rename() internally. */
	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;					/* 超级块对象链表 */

	/* 这些字段 运行时使锁生效 */
	struct lock_class_key s_lock_key;
	struct lock_class_key s_umount_key;
	struct lock_class_key s_vfs_rename_key;
	struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];

	struct lock_class_key i_lock_key;
	struct lock_class_key i_mutex_key;
	struct lock_class_key i_mutex_dir_key;
};

每种文件系统，不管有多少个实例安装到系统，还是根本就没有安装到系统中，都只有一个file_system_type结构。

注意：当文件系统被实际安装时，将有一个vfsmount结构体在安装点被创建。该结构体用来代表文件系统的实例，也就是代表要给安装点。

vfsmount结构体被定义在<linux/mount.h>中，如下（选自kernel版本3.10）：

struct vfsmount {
	struct dentry *mnt_root;	/* root of the mounted tree  该文件系统的根目录项 */
	struct super_block *mnt_sb;	/* pointer to superblock  该文件系统的超级块 */
	int mnt_flags;				/* 安装标志 */
};

mnt_flags存储了文件系统在安装时指定的标志信息，如下：

14.和进程相关的数据结构

有三个数据结构将VFS层和系统的进程紧密联系在一起，它们分别是：files_struct 、fs_struct和namespace结构体。

files_struct 结构体定义在文件<linux/fdtable.h>中，该结构体由进程描述符中的files目录项指向，所有与单个进程（per-process）相关的信息都包含在其中，如下（选自kernel版本3.10）：

/*
 * Open file table structure
 */
struct files_struct {
  /*
   * read mostly part
   */
	atomic_t count;						/* 结构的使用计数 */
	struct fdtable __rcu *fdt;			/* 指向其他fd表的指针 */
	struct fdtable fdtab;				/* 基fd表 */
  /*
   * written part on a separate cache line in SMP
   */
	spinlock_t file_lock ____cacheline_aligned_in_smp;
	int next_fd;											/* 缓存下一个可用的fd */
	unsigned long close_on_exec_init[1];					/* exec()时关闭的文件描述符链表 */
	unsigned long open_fds_init[1];							/* 打开的文件描述符链表 */
	struct file __rcu * fd_array[NR_OPEN_DEFAULT];			/* 缺省的文件对象数组，指向已经打开的文件对象 */
};

fs_struct 由进程描述符的fs域指向，它包含系统文件和进程相关的信息，如下：

struct fs_struct {
	int users;					/* 用户数目 */
	spinlock_t lock;			/* 保护该结构体的锁 */
	seqcount_t seq;				
	int umask;					/* 掩码 */
	int in_exec;				/* 当前正在执行的文件 */
	struct path root, pwd;		/* 根目录路径和当前工作目录的路径 */
};

namespace结构体由进程描述符中mmt_namespace域指向，2.4内核版本后，单进程命名空间被加入内核中，它使得每个进程在系统中都能看到唯一的安装文件系统–不仅是唯一的根目录，而是唯一的文件系统层次结构。
书中记录的是<linux/mmt_namespace.h>中，在kernel3.10版本中没有找到，是另外一种形式，这里笔者不确定是不是对应的如下：
kernel/fs/mount.h

struct mnt_namespace {
	atomic_t		count;					/* 结构的使用计数 */
	unsigned int		proc_inum;
	struct mount *	root;					/* 根目录的安装点对象 */
	struct list_head	list;				/* 安装点链表：连接已安装文件系统的双向链表，包含的元素组成了全体命名空间 */
	struct user_namespace	*user_ns;
	u64			seq;	/* Sequence number to prevent loops */
	wait_queue_head_t poll;					/* 轮询的等待队列 */
	int event;								/* 事件计数 */
};

上述这些数据结构都是通过进程描述符连接起来的。
对多数进程来说，它们的描述符都指向唯一的files_struct 和 fs_struct 结构体。
但是，对于那些使用克隆标志 CLONE_FILES 或 CLONE_FS 创建的进程，会共享这两个结构体。所以多个进程描述符可能指向同一个files_struct 或 fs_struct 结构体。
每个结构体都维护一个 count 域作为引用计数，它防止进程正使用该结构时，该结构体被撤销。

namespace 结构体的使用方法和前两种结构体完全不同。
默认情况下，所有的进程共享同样的命名空间（它们都从相同的挂载表中看到同一个文件系统层次结构）。
只有在进行clone()操作时使用 CLONE_NEWS 标志，才会给进程一个唯一的命名空间结构体的拷贝。
因为大多数进程都不提供这个标志，所有进程都继承其父进程的命名空间。
因此在大多数系统上只有一个命名空间，不过，CLONE_NEWS 标志可以使这一功能失效。

最后

以上就是真实过客为你收集整理的【读书笔记】Linux内核设计与实现--虚拟文件系统1. 通用文件系统接口2.文件系统抽象层3.Unix文件系统4.VFS对象及其数据结构5.超级块对象6.超级块操作7.索引节点对象8.索引节点操作9.目录项对象10.目录项操作11.文件对象12.文件操作13.和文件系统相关的数据结构14.和进程相关的数据结构的全部内容，希望文章能够帮你解决【读书笔记】Linux内核设计与实现--虚拟文件系统1. 通用文件系统接口2.文件系统抽象层3.Unix文件系统4.VFS对象及其数据结构5.超级块对象6.超级块操作7.索引节点对象8.索引节点操作9.目录项对象10.目录项操作11.文件对象12.文件操作13.和文件系统相关的数据结构14.和进程相关的数据结构所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。