虚拟文件系统 (VFS)-基于linux3.10

图0.1中的文件系统信息结构体如下：

struct fs_struct {
	int users;
	spinlock_t lock;
	seqcount_t seq;
	int umask;
	int in_exec;
	struct path root, pwd;
};

Users反映的是用户数，umask是设置文件权限的掩码，path是路径名，放映的是文件系统的挂载路径和目录项。早先这两个成员直接存在于fs_strcut中。

struct path {
	struct vfsmount *mnt;
	struct dentry *dentry;
};

在mount一个文件系统时，再回到这里查看该文件系统。

1.1.5 目录项

在真实的文件系统（ext2、ext3）中并没有目录项的概念，其目的是加速访问先前查找操作的结果，在读取一个目录或者文件数据之后，就会创建一个dentry实例，以缓存查找到的实例。

include/linux/dcache.h
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;
	} d_u;
	struct list_head d_subdirs;	/* our children */
	struct hlist_node d_alias;	/* inode alias list */
};

d_flags定义了目录项的相关的一些标志，这些标志和dentry定义于同一个文件中，这些标志用于表明目录项的状态。

d_seq的序列锁，保护之用。

d_hash用于散列溢出。

d_parent是一个指针，指向当前节点父目录的目录项实例，当前的dentry实例位于父目录的d_subdirs链表中。

d_name是文件/目录的名称，qstr封装了文件名字符串的长度和散列值。

d_inode指向该目录项管关联的索引节点。

d_iname用于存储短文件名。

d_count是该目录项的引用计数。

d_sb指向目录项所属的超级块实例。

d_alias连接表示相同文件的各个目录项。

d_lru，最近最少使用链表，其中不再使用的对象将授予一个最后宽限期，过了宽限期后才从内存移除。

d_op是目录项的操作函数集。

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;

d_revalidate、d_weak_revalidate网络文件系统使用，检查目录项是否能够反映文件系统中的情况。

d_hash计算目录项的哈希值，该值用于散列目录项

d_compare用于比较两个目录对象的文件名。

d_release用于递减目录项的引用计数值（d_count），当计数值达到零时，调用d_delete函数删除目录项。

d_iput从不在使用的目录项中释放inode。

1.1.6 超级块

超级块定义于include/linux/fs.h，在装载一个文件系统时，很重要的一步是调用read_super读取存储介质上的超级块信息，并重构到如下的super_block结构体中。

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;
	const struct xattr_handler **s_xattr;//扩展属性处理函数指针。

	struct list_head	s_inodes;	/* all inodes */
	struct hlist_bl_head	s_anon;		/* anonymous dentries for (nfs) exporting */
	struct list_head	s_files;
	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; //分区信息，MTD（Memory Technology Device）系统使用。
	struct hlist_node	s_instances;
	struct quota_info	s_dquot;	/* Diskquota specific options */

	struct sb_writers	s_writers;//对超级块操作的管理结构，会使用wait queue的方式管理超级块写者。

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

s_blocksize和s_blocksize_bits分别指定了文件系统的块长度，前一个是按字节计算的长度，而后一个是前一个取以2为底的对数。

s_op是超级块操作函数，这些函数由特定的文件系统实现。

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 *);//仅用于NFS、CIFS和9fs网络文件系统和用户空间文件系统（FUSE），它允许在卸载操作系统之前，于远程的文件系统提供者进行通信。

	int (*show_options)(struct seq_file *, struct dentry *);//用于proc文件系统，用以显示文件系统装载的选项。
	int (*show_devname)(struct seq_file *, struct dentry *);
	int (*show_path)(struct seq_file *, struct dentry *);
	int (*show_stats)(struct seq_file *, struct dentry *);//统计信息，也是用于proc文件系统。
	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);
};

alloc_inode和destroy_inode分别是创建和销毁一个索引节点，dirty_inode和write_inode分别是将索引节点标记为“脏”和将更新存储介质上的索引节点。drop_inode删除索引节点。sysfs这类比较特殊的文件系统会实现evict_inode方法，这是因为对于sysfs而言，sysfs_dirent既做为索引节点又做为目录项，为了防止sysfs的索引节点号被永久的删除，采用了在索引节点里有一项指向sysfs_dirent，而这里的evict_inode()正是用于在索引节点销毁时解除上述索引节点对的sysfs_dirent引用。对于pur_super释放超级块，在卸载文件系统时会调用该方法。

freeze_fs和unfreeze_fs是在linux3.9才引入的，用于文件的快照功能。

1.2 文件系统挂载

1.2.1 注册文件系统

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

	if (fs->next)
		return -EBUSY;
	write_lock(&file_systems_lock);
	p = find_filesystem(fs->name, strlen(fs->name));
	if (*p)
		res = -EBUSY;
	else
		*p = fs;
	write_unlock(&file_systems_lock);
	return res;
}

该函数的参数定义如下：

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

该函数稍微有些长，其name参数是该文件系统的名称，fs_flags是装载标志，如只读、禁止设置setuid/setgid操作等，其字段的下面由#define定义的哪些宏就是用于fs_flags的。mount函数指针是在挂载该文件系统时会调用的方法。Kill_sb 用于删除一个超级块对象，owner在该文件系统使用模块形式加载到内核时会用到。Next用于串接各个文件系统以便与管理。Fs_super是将同一个文件系统多个超级块聚集在一起的链表头。最后是一些用于保护的锁。

添加一个文件系统的逻辑还是很简单的，由于所有的文件系统都连接在file_systems这个链表上，将内核链表上的文件系统的名称和要注册的文件系统的名称（name）进行比较，如果找到了，则if (*p)就会成立，即res = -EBUSY;否则简单的将新添加的文件系统放在链表的末尾*p = fs。

1.2.2 文件系统装载和卸载

文件系统的装载和卸载比仅仅注册一个文件系统要复杂许多。文件系统的装载由mount系统调用发起，对于根文件系统则是由mount_root（init/do_mounts.c）完成。文件系统的注销则由umount完成。查看当前挂载的文件系统可以使用mount命令。

/dev/sda1 on / type ext4 (rw,errors=remount-ro)
proc on /proc type proc (rw,noexec,nosuid,nodev)
sysfs on /sys type sysfs (rw,noexec,nosuid,nodev)
none on /sys/fs/fuse/connections type fusectl (rw)
none on /sys/kernel/debug type debugfs (rw)
none on /sys/kernel/security type securityfs (rw)
udev on /dev type devtmpfs (rw,mode=0755)
devpts on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=0620)
tmpfs on /run type tmpfs (rw,noexec,nosuid,size=10%,mode=0755)
none on /run/lock type tmpfs (rw,noexec,nosuid,nodev,size=5242880)
none on /run/shm type tmpfs (rw,nosuid,nodev)
/dev/sdb1 on /data1 type ext4 (rw,usrquota,grpquota)
rpc_pipefs on /run/rpc_pipefs type rpc_pipefs (rw)
/dev/sdc1 on /data2 type ext4 (rw,usrquota,grpquota)
nfsd on /proc/fs/nfsd type nfsd (rw)

<include/linux/mount.h>
struct vfsmount {
	struct dentry *mnt_root;	/* root of the mounted tree */
	struct super_block *mnt_sb;	/* pointer to superblock */
	int mnt_flags;
};

挂载一个文件系统的flag有如下可选标志：

#define MNT_NOSUID	0x01 //禁止setuid
#define MNT_NODEV	0x02//挂载虚拟文件系统，无物理设备
#define MNT_NOEXEC	0x04//不允许程序执行
#define MNT_NOATIME	0x08//不更新access时间
#define MNT_NODIRATIME	0x10//不更新目录access时间
#define MNT_RELATIME	0x20//
#define MNT_READONLY	0x40	/* does the user want this to be r/o? */

#define MNT_SHRINKABLE	0x100
#define MNT_WRITE_HOLD	0x200

#define MNT_SHARED	0x1000	/* if the vfsmount is a shared mount */
#define MNT_UNBINDABLE	0x2000	/* if the vfsmount is a unbindable mount */
/*
 * MNT_SHARED_MASK is the set of flags that should be cleared when a
 * mount becomes shared.  Currently, this is only the flag that says a
 * mount cannot be bind mounted, since this is how we create a mount
 * that shares events with another mount.  If you add a new MNT_*
 * flag, consider how it interacts with shared mounts.
 */
#define MNT_SHARED_MASK	(MNT_UNBINDABLE)
#define MNT_PROPAGATION_MASK	(MNT_SHARED | MNT_UNBINDABLE)

#define MNT_INTERNAL	0x4000
#define MNT_LOCK_READONLY	0x400000

1.2.3 mount系统调用

要想对文件系统有所了解，就必须知道mount系统调用流程，并且在有了前面的相关数据结构以及数据结构体之间的关系，来看mount系统调用目标也会变的明确，也就是那些数据结构如何实例化。通常能够看到如下mount的常用用法：

mount      [OPTIONS]  [-o OPTS]    DEVICE                            NODE
mount   -t     proc                proc                               /proc
mount   -t     sysfs                sysfs                               /sys
mount   -t     ramfs               ramfs                              /home
mount   –t     ubifs               /dev/ubi4_0                         /config
mount   -t     nfs   -o   nolock    10.1.14.104:/workteam/shichaog/nfs     /mnt

这里有必要对上面进行适当的说明，前面提到的三种类型的文件系统，伪文件系统、存储介质文件系统、网络文件系统在上面均有示例，第一行是mount的常用用法，-t指定了挂载的文件系统类型，DEVICE是挂载的设备，这是必须存在的，而最后的NODE那一列是设备挂载点。

         mount系统调用的入口函数定义于fs/namespace.c文件中，其定义原型如下：

SYSCALL_DEFINE5(mount, char __user *, dev_name, char__user *, dir_name,
char __user *,type, unsigned long, flags, void __user *, data)

上述mount命令的常用用法的type字段对应系统调用的字段

         上面的type参数是挂载时指定的文件系统类型，如proc、sysfs、ubifs、ramfs、tmpfs、ubifs、yaffs2等，dev_name是要挂载的设备对应mount用法的DEVICE那一列。Flag是挂载挂载的标志，还是有必要来看一看，其调用流程。

图1.2.1 mount代码流程图

在上述流程图中，关键的工作由do_mount来完成，首先调用kern_path找到挂载点，然后根据挂载的标志，调用相应的挂载函数执行挂载，比如如果设置了MS_REMOUNT标志，则会调用do_remount来重新挂载文件系统，如果没有设置特殊的标志，则调用do_new_mount完成挂载工作，上面的挂载实例执行的都是这个函数。

查找挂载点的函数调用如下：

retval =kern_path(dir_name, LOOKUP_FOLLOW, &path);

其第一个参数是挂载点，第二个参数指定了如何查找，正确找到的情况下，会将查找的路径放在最后一个参数path里。

int kern_path(const char *name, unsigned int flags, struct path *path)
{
	struct nameidata nd;
	int res = do_path_lookup(AT_FDCWD, name, flags, &nd);
	if (!res)
		*path = nd.path;
	return res;
}

nameidata临时用于查找路径之用，

struct nameidata {
	struct path	path; //
	struct qstr	last; 
	struct path	root;
	struct inode	*inode; /* path.dentry.d_inode */
	unsigned int	flags; //搜索标志
	unsigned	seq;
	int		last_type;
	unsigned	depth;
	char *saved_names[MAX_NESTED_LINKS + 1];
};

其path和last成员的定义原型如下：

struct path {
	struct vfsmount *mnt;
	struct dentry *dentry;
};

qstr是“quickstring”缩写，存储了字符串长度值，而name存储了字符串名。

struct qstr {
	union {
		struct {
			HASH_LEN_DECLARE;
		};
		u64 hash_len;
	};
	const unsigned char *name;
};

路径查找的过程很繁琐，这一过程也不是最感兴趣的部分，在1.3.1有所涉及文件路径的相关操作，这里只需要知道查找到的路径信息将会存放在struct nameidata结构体里供后续使用。

1.3.1 文件打开

应用程序在读写文件或者设备时需要先使用open打开一个设备，对应调用的是fs/open.c文件中的open系统调用，其原型如下：

SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
{
	if (force_o_largefile())
		flags |= O_LARGEFILE;

	return do_sys_open(AT_FDCWD, filename, flags, mode);
}

如果是64位系统而不是32位系统则会执行flags |= O_LARGEFILE;语句，这是因为64位系统默认选择了大文件配置选项。

fs/manei.c
struct file *do_filp_open(int dfd, struct filename *pathname,
		const struct open_flags *op, int flags)
{
	struct nameidata nd;
	struct file *filp;

	filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_RCU);
	return filp;
}

static int do_last(struct nameidata *nd, struct path *path,
		   struct file *file, const struct open_flags *op,
		   int *opened, struct filename *name)
{
//此处是找文件的信息而非找到文件查找其实目录的信息，所以该标志需要清除掉
	nd->flags &= ~LOOKUP_PARENT;
	nd->flags |= op->intent;
…
//判断是否是创建文件，如果创建文件则没有必要查找file内容，否则查找文件的struct file
if (!(open_flag & O_CREAT)) {
		…
//0,成功找到， 1:内存中没有，需要调用lookup_real，<0则容rcu-walk方式转到ref-walk方式。
		error = lookup_fast(nd, path, &inode);
		if (likely(!error))
			goto finish_lookup; 

retry_lookup:
	error = lookup_open(nd, path, file, op, got_write, opened);
error = follow_managed(path, nd->flags);
inode = path->dentry->d_inode;

if ((nd->flags & LOOKUP_RCU) || nd->path.mnt != path->mnt) {
		path_to_nameidata(path, nd);
	} else {
		save_parent.dentry = nd->path.dentry;
		save_parent.mnt = mntget(path->mnt);
		nd->path.dentry = path->dentry;
	}
	nd->inode = inode;

finish_open_created:
	error = may_open(&nd->path, acc_mode, open_flag);

int finish_open(struct file *file, struct dentry *dentry,
		int (*open)(struct inode *, struct file *),
		int *opened)

file->f_path.mnt = nd->path.mnt;
	error = finish_open(file, nd->path.dentry, NULL, opened);
opened:
	error = open_check_o_direct(file);
	error = ima_file_check(file, op->acc_mode);
out:
	if (got_write)
		mnt_drop_write(nd->path.mnt);
	path_put(&save_parent);
	terminate_walk(nd);
	return error;

if (file->f_op->read)
			ret = file->f_op->read(file, buf, count, pos);
		else
			ret = do_sync_read(file, buf, count, pos);