VFS的任务并不简单。一方面，它用来提供了一种操作文件、目录及其他对象的统一方法。另一方面，它必须能够与各种方法给出的具体文件系统的实现达成妥协，这些实现在具体细节、总体设计方面都有一些不同之处。
文件系统类型
- 基于磁盘的文件系统
- 虚拟文件系统
- 网络文件系统
通用文件模型
在处理文件时，内核空间和用户空间使用的主要对象是不同的。对用户程序来说，一个文件由一个文件描述符标识。内核处理文件的关键是inode。
inode
目录只是一个特殊的文件。
inode的成员可能分为下面两类。
- 描述文件状态的元数据。
- 保存实际文件内容的数据段。
为阐明如何用inodes来构造文件系统的目录层次结构，我们来考察内核查找对应于/usr/bin/emacs的inode过程。
查找起始于inode,它表示根目录/，对系统来说必须总是已知的。该目录由一个inode表示，其数据段并不包含普通数据，而是根目录下的各个目录项。这些目录项可能代表文件或其他目录。每个项由两个成员组成。
- 该目录项的数据所在inode的编号
- 文件或目录的名称
链接
对每个符号链接都使用了一个独立的inode。相应inode的数据段包含一个字符串，给出了链接目标的路径。
对于硬链接建立时，创建的目录项使用了给定文件的inode编号。
VFS结构
结构概观
VFS由两个部分组成，文件和文件系统，这些都需要管理和抽象。
文件表示
在抽象对底层文件系统的访问时，并未使用固定的函数，而是使用了函数指针。这些函数指针保存在两个结构中，包括了所有相关的函数。
- inode操作：创建链接、文件重命名、在目录中生成新文件、删除文件。
- 文件操作：作用于文件的数据内容。它们包含一些显然的操作（如读和写），还包括如设置文件指针和创建内存映射之类的操作。
每个inode还包含了一个指向底层文件系统的超级块对象的指针，用于执行inode本身的操作。
文件系统和超级块信息
超级块还包含了读、写、操作inode的函数指针。也包含了文件系统的关键信息（块长度、最大文件长度，等等）。
超级块结构的一个重要成员是一个列表，包括相关文件系统中所有修改过的inode（内核相当不敬地称之为脏inode？？？miao miao miao?）。根据该列表很容易标识已经修改过的文件和目录，以便将其写回到存储介质。
inode
<fs.h>
struct inode {
struct hlist_node i_hash;
struct list_head i_list;
struct list_head i_sb_list;
struct list_head i_dentry;
unsigned long i_ino;//inode编号标识
atomic_t i_count;//访问该inode结构的进程数目
unsigned int i_nlink;//硬链接总数
uid_t i_uid;
gid_t i_gid;
dev_t i_rdev;//在inode表示设备文件时，使用
unsigned long i_version;
loff_t i_size;//文件长度，字节计算
#ifdef __NEED_I_SIZE_ORDERED
seqcount_t i_size_seqcount;
#endif
struct timespec i_atime;//最后访问的时间，
struct timespec i_mtime;//最后修改的时间（数据内容）
struct timespec i_ctime;//最后修改inode的时间（inode内容）
unsigned int i_blkbits;
blkcnt_t i_blocks;//文件按块计算的长度
unsigned short i_bytes;
umode_t i_mode;//文件访问权限
spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
struct mutex i_mutex;
struct rw_semaphore i_alloc_sem;
const struct inode_operations *i_op;
const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
struct super_block *i_sb;
struct file_lock *i_flock;
struct address_space *i_mapping;
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;
};
int i_cindex;
__u32 i_generation;
#ifdef CONFIG_DNOTIFY
unsigned long i_dnotify_mask; /* Directory notify events */
struct dnotify_struct *i_dnotify; /* for directory notifications */
#endif
#ifdef CONFIG_INOTIFY
struct list_head inotify_watches; /* watches on this inode */
struct mutex inotify_mutex; /* protects the watches list */
#endif
unsigned long i_state;
unsigned long dirtied_when; /* jiffies of first dirtying */
unsigned int i_flags;
atomic_t i_writecount;
#ifdef CONFIG_SECURITY
void *i_security;
#endif
void *i_private; /* fs or device private pointer */
};inode操作
file_operations用于操作文件中包含的数据，而inode_operations负责管理结构性的操作（例如删除一个文件）和文件相关的元数据（例如，属性）。
struct inode_operations {
int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);//根据文件系统对象的名称。查找其inode实例
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 *,int);
int (*rmdir) (struct inode *,struct dentry *);
int (*mknod) (struct inode *,struct dentry *,int,dev_t);
int (*rename) (struct inode *, struct dentry *,
struct inode *, struct dentry *);
int (*readlink) (struct dentry *, char __user *,int);
void * (*follow_link) (struct dentry *, struct nameidata *);//根据符号链接查找目录的inode
void (*put_link) (struct dentry *, struct nameidata *, void *);
void (*truncate) (struct inode *);
int (*permission) (struct inode *, int, struct nameidata *);
int (*setattr) (struct dentry *, struct iattr *);//xattr函数，用于建立、读取、删除文件的扩展属性
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 *);
void (*truncate_range)(struct inode *, loff_t, loff_t);//截断一个范围内的块
long (*fallocate)(struct inode *inode, int mode, loff_t offset,
loff_t len);//用于对文件预先分配空间
};inode链表
每个inode都有一个i_list成员，可以将inode存储在一个链表中。根据inode的状态，它可能有3种主要的情况。
- inode处于内存中，未关联到任何文件，也不处于活动使用状态
- inode结构在内存中，正在由一个或多个进程使用，通常表示一个文件。两个计数器(i_count和i_nlink)的值都必须大于0。文件内容和inode元数据都与底层块设备上的信息相同。也就是说，与上一次与存储介质同步以来，该inode没有改变过
- inode处于活动使用状态。其数据内容已经改变，与存储介质上的内容不同。这种状态的inode被称作脏的。
在fs/inode.c中内核定义了两个全局变量用作表头，inode_unsued用于有效但非活动的inode。inode_in_use用于所有使用但未改变的inode。脏的inode保存在一个特定于超级块的链表中（super_block->s_dirty）。
每个inode不仅出现在特定于状态的链表中，还在一个散列表中出现（inode_hashtable，也定义在fs/inode.c中），以根据inode编号和超级快快速访问inode。
inode还通过一个特定于超级块的链表维护，表头是super_block->s_inodes。i_sb_list用作链表元素。
表头为super_block->s_io和super_block->s_more_io使用同样的链表元素i_list。这两个链表包含的是已经选中向磁盘回写的inode，但正在等待回写进行。
特定于进程的信息
<sched.h>
struct task_struct {
...
/* 文件系统信息 */
int link_count, total_link_count;
...
/* 文件系统信息 */
struct fs_struct *fs;
/* 打开文件信息 */
struct files_struct *files;
/* 命名空间 */
struct nsproxy *nsproxy;
...
} <file.h>
struct files_struct {
/*
* read mostly part
*/
atomic_t count;
//fdtable在打开超过NR_OPEN_DEFAULT个文件时，使用
struct fdtable *fdt;
struct fdtable fdtab;
/*
* written part on a separate cache line in SMP
*/
spinlock_t file_lock ____cacheline_aligned_in_smp;
int next_fd;//表示下一次打开新文件时使用的文件描述符
struct embedded_fd_set close_on_exec_init;//位图，对执行exec时将关闭的所有文件描述符，都置位。
struct embedded_fd_set open_fds_init;//最初文件描述符集合
struct file * fd_array[NR_OPEN_DEFAULT];//指向每个打开文件的struct file实例（默认情况下，内核允许每个进程打开NR_OPEN_DEFAULT个文件）
};如果进程试图打开更多的文件(大于NR_OPEN_DEFAULT)，则内核需要分配更多的内核空间。fdtable用于该目的。
struct fdtable {
unsigned int max_fds;//max_fds指定了进程当前可以处理的文件对象和文件描述符的大数目
struct file ** fd; /* current fd array */
fd_set *close_on_exec;//是一个指向位域的指针，该位域保存了所有在exec系统调用时将要关闭的文件描述符的信息
fd_set *open_fds;//是一个指向位域的指针，该位域管理着当前所有打开文件的描述符
struct rcu_head rcu;
struct fdtable *next;
};开始，fdt指向fdtab，fdtab中的成员fd、open_fds和 close_on_exec都初始化为指向前者对应的3个成员。
struct file。该结构保存了内核所看到的文件的特征信息。
<fs.h>
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;
} f_u;
struct path f_path;//封装了两部分信息：1.文件名和inode之间的关联；2.文件所在文件系统的有关信息。
#define f_dentry f_path.dentry
#define f_vfsmnt f_path.mnt
const struct file_operations *f_op;//文件操作函数
atomic_t f_count;
unsigned int f_flags;
mode_t f_mode;//文件操作模式
loff_t f_pos;//文件指针
struct fown_struct f_owner;//包含了处理该文件的进程有关的信息
unsigned int f_uid, f_gid;
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;
#ifdef CONFIG_EPOLL
/* Used by fs/eventpoll.c to link all the hooks to this file */
struct list_head f_ep_links;
spinlock_t f_ep_lock;
#endif /* #ifdef CONFIG_EPOLL */
struct address_space *f_mapping;//指向属于文件相关的inode实例的地址空间映射
};
每个超级块都提供了一个s_list成员用作表头，以建立file对象的链表，链表元素是 file->f_list。该链表包含该超级块表示的文件系统的所有打开文件。
file实例可以用get_emtpy_filep分配，该函数利用了自身的缓存并将实例用基本数据预先初始化。
每当内核打开一个文件或做其他的操作时，如果需要file_struct提供比初始值更多的项，则调用expand_files函数。
文件操作
各个file实例都包含一个指向struct file_operations实例的指针，该结构保存了指向所有可能文件操作的函数指针。
<fs.h>
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 *);
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
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 *);//打开一个文件，相当于将file对象关联到inode
int (*flush) (struct file *, fl_owner_t id);//在文件描述符关闭时调用，同时将file对象计数减1
int (*release) (struct inode *, struct file *);//file对象为0时调用
int (*fsync) (struct file *, struct dentry *, 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 (*dir_notify)(struct file *filp, unsigned long arg);
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 **);
};目录信息
每个task_struct实例都包含一个指针，指向另一个结构，类型为fs_struct.
<fs_struct.h>
struct fs_struct {
atomic_t count;
rwlock_t lock;
int umask;//用于设置新文件的权限
struct dentry * root, * pwd, * altroot;
struct vfsmount * rootmnt, * pwdmnt, * altrootmnt;
};- root和rootmnt指定了相关进程的根目录和文件系统
- pwd和pwdmnt指定了当前工作目录和文件系统。pwdmnt只有进入了一个新的装载点时，才会改变
- altroot和altrootmnt成员用于实现个性（personality）。这种特性允许为二进制程序建立一个仿真环境，使得程序认为是在不同于Linux的某个操作系统下运行。例如，在Sparc系统上仿真SunOS时就使用了该方法。仿真所需的特殊文件和库安置在一个目录中（通常是/usr/gnemul/）。有关该路径的信息保存在alt成员中。在搜索文件时总是优先扫描上述目录，因此首先会找到仿真的库或系统文件，而不是Linux系 统的文件（这些之后才搜索）。这支持对不同的二进制格式同时使用不同的库
VFS命名空间
VFS命名空间是所有已经装载、构成某个容器目录树的文件系统的集合。
内核使用以下结构管理命名空间。在各种命名空间中，其中之一是VFS命名空间。
<nsproxy.h>
struct nsproxy{
...
struct mnt_namespace *mnt_ns;
...
}<mnt_namespace.h>
struct mnt_namespace{
atomic_t count;//使用该命名空间的进程数目
struct vfsmount *root;
struct list_head list;//VFS命名空间中所有文件系统的vfsmount实例
...
}目录项缓存
dentry结构的主要用途是建立文件名和相关的inode之间的关联。
在VFS连同文件系统实现读取的一个目录项的数据之后，则创建一个dentry实例，以缓存找到的数据。
<dcache.h>
struct dentry {
atomic_t d_count;
unsigned int d_flags; /* protected by d_lock *///DCACHE_DISCONNECTED指定一个dentry当前没有连接到超级块的dentry树。DCACHE_UNHASHED表明该dentry实例没有包含在任何inode的散列表中。
spinlock_t d_lock; /* per dentry lock */
struct inode *d_inode; /* Where the name belongs to - NULL is
* negative *///文件名所属的inode，如果为NULL，则表示不存在的文件名
/*
* The next three fields are touched by __d_lookup. Place them here
* so they all fit in a cache line.
*/
struct hlist_node d_hash; /* lookup hash list */
struct dentry *d_parent; /* parent directory *///指向当前节点父目录的dentry实例（对于根目录指向自身）
struct qstr d_name; //指定了文件的名称，qstr是一个内核字符串的包装器，它存储了实际的char（只存储最后一个分量,如/usr/src,则存储src） *字符串以及字符串长度和散列值，这使得更容易处理查找工作。
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 *///用于将当前dentry链接到父目录dentry的d_subdirs链表中。
struct rcu_head d_rcu;
} d_u;
struct list_head d_subdirs; /* our children *///子目录/文件的目录项链表
struct list_head d_alias; /* inode alias list *///用于将dentry链接到inode的i_dentry链表中，以链接表示相同文件的各个dentry对象
unsigned long d_time; /* used by d_revalidate *///
struct dentry_operations *d_op;
struct super_block *d_sb; /* The root of the dentry tree */
void *d_fsdata; /* fs-specific data */
#ifdef CONFIG_PROFILING
struct dcookie_struct *d_cookie; /* cookie, if any */
#endif
int d_mounted;//当前dentry对象表示一个装载点，那么d_mounted设置为1，否则其值为0
unsigned char d_iname[DNAME_INLINE_LEN_MIN]; /* small names *///短文件名（文件名只由少量字符组成时，才保存在d_iname中）
};
内存中所有活动的dentry实例都保存在一个散列表中，该散列表使用fs/dcache.c中的全局变量dentry_hashtable实现。用d_hash实现的溢出链，用于解决散列碰撞。在下文中，我将该散列表称 为全局dentry散列表。
内核中还有另一个dentry的链表，表头是全局变量dentry_unused（也在fs/dcache.c中初始化）。所有使用计数器（d_count）到达0（因而任何进程都不再使用）的 dentry实例都自动地放置到该链表上。
缓存组织
dentry对象在内存中的组织，涉及下面两个部分。
- 一个散列表，包含了所有dentry对象。
- 一个LRU链表，其中不再使用的对象将授予一个最后宽期限，宽期限过后才从内存移除。
在dentry对象的使用计数器（d_count）到达0时，会被置于LRU链表上，这表明没有什么应用程序正在使用该对象。新项总是置于该链表的起始处。换句话说，一项在链表中越靠后，它就越老，这是经典的LRU原理。prune_dcache会时常调用，例如在卸载文件系统或内核需要更多内存时。其中会删除比较老的对象，以释放内存。要注意，有时候dentry对象可能临时处于该链表上，尽管这些对象仍然处于活动使用状态，而且其使用计数大于0。这是因为内核进行了一些优化：在LRU链表上的dentry对象恢复使用时，不会立即将其从LRU链表移除，这可以省去一些锁操作，从而提高了性能。有些操作如prune_dcache，无论如何代价都比较高，我们可以对这种情况作出补救。具体地，如果遇到使用计数为正值的对象，只是将其从链表移除，而不释放该对象。
dentry操作
dentry_operations结构保存了一些指向各种特定于文件系统可以对dentry对象执行的操作的函数指针。
struct dentry_operations {
int (*d_revalidate)(struct dentry *, struct nameidata *);//检查内存中，各个dentry对象构成的结构是否仍然能够反映当前文件系统中的情况
int (*d_hash) (struct dentry *, struct qstr *);//计算散列值，该值用于将对象放置到dentry散列表中。
int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);//比较两个dentry对象的文件名。
int (*d_delete)(struct dentry *);//再d_count到达0时，调用
void (*d_release)(struct dentry *);//再d_count到达0时，先于d_delete调用
void (*d_iput)(struct dentry *, struct inode *);//从一个不再使用的dentry对象中释放inode（默认情况下，将inode的使用计数减1，计数器到达0后，将inode从各种链表中移除）
char *(*d_dname)(struct dentry *, char *, int);
};由于大多数文件系统都没有实现前述的这些函数，内核的惯例是这样：如果文件系统对每个函数 提供的实现为NULL指针，则将其替换为VFS的默认实现。
标准函数
以下辅助函数需要一个指向struct dentry的指针作为参数。
- 每当内核的某个部分需要使用一个dentry实例时，都需要调用dget。调用dget将对象的引用 计数加1，即获取对象的一个引用。
- dput是dget的对应物。如果内核中的某个使用者不再需要一个dentry实例时，就必须调用dput。该函数将dentry对象的使用计数减1。如果计数下降到0，则调用dentry_operations->d_delete方法（如果可用）。此外，还需要使用d_drop从全局dentry散列表移除该实例，并将其置于LRU链表上。
- d_drop将一个dentry实例从全局dentry散列表移除。
- d_delete在确认dentry对象仍然包含在全局dentry散列表中之后，使用__d_drop将其移除。如果该对象此时只剩余一个使用者，还会调用dentry_iput将相关inode的使用计数减1。
- d_instantiate将一个dentry实例与一个inode关联起来。这意味着设置d_inode字段并将该 dentry增加到inode->i_dentry链表。
- d_add调用了d_instantiate。此外，该对象还添加到全局dentry散列表dentry_hashtable 中。
- d_alloc为一个新的struct dentry实例分配内存。初始化各个字段，如果给出了一个表示父结点的dentry，则新dentry对象的超级块指针从父结点获取。
- d_alloc_anon为一个struct dentry实例分配内存，但并不设置与父结点dentry的任何关联， 因此该函数与d_alloc相比去掉了相关参数。
- d_splice_alias将一个断开连接的dentry对象连接到dentry树中。该功能的inode参数表示 与dentry关联的inode。
- d_lookup根据目录对应的dentry实例，搜索名称为name的文件对应的dentry对象。
处理VFS对象
文件系统操作
每个文件系统在使用以前必须注册到内核，这样内核都能够了解可用的文件系统，并按需调用装载功能。
注册文件系统
文件系统的表示：
<fs.h>
struct file_system_type {
const char *name;//文件系统的名称
int fs_flags;//使用的标志，例如标明只读装载、禁止setuid/setgid操作或进行其他的微调
int (*get_sb) (struct file_system_type *, int,
const char *, void *, struct vfsmount *);//从底层存储介质读取超级块
void (*kill_sb) (struct super_block *);//在不需要某个文件系统类型时执行清理工作。
struct module *owner;
struct file_system_type * next;//链接到下一个文件系统
struct list_head fs_supers;//由于可以装载几个同一类型的文件系统，同一文件系统类型可能对应了多个超级块结构，这些超级块结构，聚集在一个链表中
struct lock_class_key s_lock_key;
struct lock_class_key s_umount_key;
struct lock_class_key i_lock_key;
struct lock_class_key i_mutex_key;
struct lock_class_key i_mutex_dir_key;
struct lock_class_key i_alloc_sem_key;
};文件系统的注册函数，register_filesystem。
<fs/filesystems.c>
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;
INIT_LIST_HEAD(&fs->fs_supers);
write_lock(&file_systems_lock);
p = find_filesystem(fs->name, strlen(fs->name));//查看准备注册的文件系统是否已经存在
if (*p)
res = -EBUSY;
else
*p = fs;//不存在，将其添加到file_systems文件系统链表上
write_unlock(&file_systems_lock);
return res;
}装载和卸载
每个装载的文件系统都有一个本地根目录，其中包含了系统目录。在将文件系统装载到一个目录时，装载点的内容被替换为即将装载的文件系统的相对根目录的内容。前一个目录数据消失，直至新文件系统卸载才重新出现。
每个装载的文件系统都对应于一个vfsmount结构的实例，其定义如下：
<mount.h>
struct vfsmount {
struct list_head mnt_hash; //vfsmount实例的地址和相关的dentry对象的地址用来计算散列和。散列表，称作mount_hashtable，定义在fs/namespace.c中。
struct vfsmount *mnt_parent; /* fs we are mounted on *///装载点所在的父文件系统
struct dentry *mnt_mountpoint; /* dentry of mountpoint *///装载点在父文件系统中的dentry
struct dentry *mnt_root; /* root of the mounted tree *///当前文件系统根目录的dentry
struct super_block *mnt_sb; /* pointer to superblock *///指向超级块的指针
struct list_head mnt_mounts; /* list of children, anchored here *///子文件系统链表
struct list_head mnt_child; /* and going through their mnt_child *///用于连接到父文件系统中的mnt_mounts
int mnt_flags;
/* 4 bytes hole on 64bits arches */
char *mnt_devname; /* Name of device e.g. /dev/dsk/hda1 */
struct list_head mnt_list; //一个命名空间的所有装载的文件系统都保存在namespace->list链表中。使用vfsmount的mnt_list成员作为链表元素
struct list_head mnt_expire; /* link in fs-specific expiry list */ /* 链表元素，用于特定于文件系统的到期链表中 */
struct list_head mnt_share; /* circular list of shared mounts */ /* 链表元素，用于共享装载的循环链表 */
struct list_head mnt_slave_list;/* list of slave mounts */ /* 从属装载的链表 */
struct list_head mnt_slave; /* slave list entry */ /* 链表元素，用于从属装载的链表 */
struct vfsmount *mnt_master; /* slave is on master->mnt_slave_list */
struct mnt_namespace *mnt_ns; /* containing namespace *///所属的命名空间
/*
* We put mnt_count & mnt_expiry_mark at the end of struct vfsmount
* to let these frequently modified fields in a separate cache line
* (so that reads of mnt_flags wont ping-pong on SMP machines)
*/
atomic_t mnt_count; //mnt_count实现了一个使用计数器。每当一个vfsmount实例不再需要时，都必须用mntput将计数器减1。mntget与mntput相对，在获取vfsmount实例使用时，必须调用mntget。
int mnt_expiry_mark; /* true if marked for expiry */ /* 如果标记为到期，则其值为true */
int mnt_pinned;
};超级块的定义非常冗长，因此我们给出一个简化的版本
<fs.h>
struct super_block {
struct list_head s_list; //将系统中所有的超级块聚集到一个链表中。该链表的表头是全局变量super_blocks
dev_t s_dev; /* 搜索索引，不是kdev_t */
unsigned long s_blocksize; //指定文件系统的块长度（单位字节）
unsigned char s_blocksize_bits; //指定文件系统的块长度（2^s_blocksize_bits字节）
unsigned char s_dirt; //如果以任何方式改变了超级块，需要向磁盘回写，都会将s_dirt设置为1.否则，其值为0.
unsigned long long s_maxbytes; /* 最大的文件长度 */
struct file_system_type *s_type; //指向文件系统
struct super_operations *s_op;
unsigned long s_flags;
unsigned long s_magic;
struct dentry *s_root; //将超级块与全局根目录的dentry项关联起来（为NULL，则该文件系统是一个伪文件系统，只在内核内部可见）
struct xattr_handler **s_xattr; //该结构包含了一些用于处理扩展属性的函数指针
struct list_head s_inodes; /* 所有inode的链表 */
struct list_head s_dirty; /* 脏inode的链表 */
struct list_head s_io; /* 等待回写 */
struct list_head s_more_io; /* 等待回写，另一个链表 */
struct list_head s_files; //包含了一系列file结构，列出了该超级块表示的文件系统上所有打开的文件
struct block_device *s_bdev; // s_dev和s_bdev指定了底层文件系统的数据所在的块设备
struct list_head s_instances; //各个超级块都连接到另一个链表中，表示同一类型文件系统的所有超级块实例。表头是file_system_type结构的fs_supers成员。
char s_id[32]; /* 有意义的名字 */
void *s_fs_info; /* 文件系统私有信息 */
/* 创建/修改/访问时间的粒度，单位为ns（纳秒）。 粒度不能大于1秒 */
u32 s_time_gran;
}; <fs.h>
struct super_operations {
struct inode *(*alloc_inode)(struct super_block *sb);
void (*destroy_inode)(struct inode *);
void (*read_inode) (struct inode *);//读取inode数据，参数为inode的编号，通过参数传递
void (*dirty_inode) (struct inode *);//将传递的inode结构标记为脏的，因为其数据已经修改
int (*write_inode) (struct inode *, int);
void (*put_inode) (struct inode *);//将inode使用计数器减1
void (*drop_inode) (struct inode *);
void (*delete_inode) (struct inode *);//将inode从内存和底层存储介质删除
void (*put_super) (struct super_block *);//将超级块的私有信息从内存移除，这发生在文件系统卸载、该数据不再需要时
void (*write_super) (struct super_block *);//将超级块写入存储介质
int (*sync_fs)(struct super_block *sb, int wait);//将文件系统数据与底层块设备上的数据同步。
void (*write_super_lockfs) (struct super_block *);
void (*unlockfs) (struct super_block *);
int (*statfs) (struct dentry *, struct kstatfs *);//给出有关文件系统的统计信息
int (*remount_fs) (struct super_block *, int *, char *);//重新装载一个已经装载的文件系统
void (*clear_inode) (struct inode *);//当某个inode不再使用时，由VFS在内部调用clear_inode。它释放仍然包含数据的所有相关的内存页面
void (*umount_begin) (struct vfsmount *, int);//仅用于网络文件系统（NFS、CIFS和9fs）和用户空间文件系统（FUSE）。
int (*show_options)(struct seq_file *, struct vfsmount *);//用于proc文件系统，用于显示文件系统装载的选项
int (*show_stats)(struct seq_file *, struct vfsmount *);//用于proc文件系统，提供了文件系统的统计信息。
#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
};
mount系统调用
mount->sys_mount->do_new_mount
static int do_new_mount(struct nameidata *nd, char *type, int flags,
int mnt_flags, char *name, void *data)
{
struct vfsmount *mnt;
if (!type || !memchr(type, 0, PAGE_SIZE))
return -EINVAL;
/* we need capabilities... */
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
mnt = do_kern_mount(type, flags, name, data);//使用get_fs_type找到匹配的file_system_type实例，然后分配并初始化vfsmount结构，
if (IS_ERR(mnt))
return PTR_ERR(mnt);
return do_add_mount(mnt, nd, mnt_flags, NULL);//处理一些必需的锁定操作，并确保一个文件系统不会重复装载到同一位置。主要工作委托给graft_tree。
}nameidata结构用于将一个vfsmount实例和一个dentry实例聚集起来。在这里，该结构保存了装载点的dentry实例和该目录此前（即新的装载操作执行之前）所在文件系统的vfsmount实例。
graft_tree -> attach_recursive_mount:将新装载的文件系统添加到父文件系统的命名空间。
attach_recursive_mount -> mnt_set_mountpoint:确保新的vfsmount实例的mnt_parent成员指向父文件系统的vfsmount实例，而mnt_mountpoint成员指向装载点所在文件系统中的dentry实例。
attach_recursive_mount -> commit_tree：将新的vfsmount实例添加到全局散列表( list_add_tail(&mnt->mnt_hash, mount_hashtable +hash(parent,mnt->mnt_mountpoint)); )以及父文件系统vfsmount实例中的子文件系统链表.(hash(父挂在vfsmount,父dentry))
mount系统调用分析：https://www.cnblogs.com/cslunatic/p/3683117.html
umount实现：使用保存在mnt_mountpoint和mnt_parent中的数据，将环境恢复到所述文件系统装载之前的原始状态。
伪文件系统
伪文件系统是不能装载的文件系统，因而不可能从用户层直接看到，内核可以用kern_mount或kern_mount_data装载一个伪文件系统。
文件操作
查找inode
nameidata结构用来向查找函数传递参数，并保存查找结果。
<namei.h>
struct nameidata {
struct dentry *dentry;// 查找完成之后，dentry和mnt包含了找到的文件系统项的数据
struct vfsmount *mnt;
struct qstr last;//包含了需要查找的名称
unsigned int flags;
int last_type;
unsigned depth;
char *saved_names[MAX_NESTED_LINKS + 1];
/* Intent data */
union {
struct open_intent open;
} intent;
};内核使用path_lookup函数查找路径或文件名
<fs/namei.c>
int fastcall path_lookup(const char *name, unsigned int flags,
struct nameidata *nd);//name:所需的名称，flags标志，nd:临时结果的“暂存器”path_lookup->do_path_lookup
<fs/namei.c>
static int fastcall do_path_lookup(int dfd, const char *name,
unsigned int flags, struct nameidata *nd)
{
int retval = 0;
int fput_needed;
struct file *file;
struct fs_struct *fs = current->fs;
nd->last_type = LAST_ROOT; /* if there are only slashes... */
nd->flags = flags;
nd->depth = 0;
if (*name=='/') {//使用当前根目录的dentry和vfsmount实例作为起点
read_lock(&fs->lock);
if (fs->altroot && !(nd->flags & LOOKUP_NOALT)) {
nd->mnt = mntget(fs->altrootmnt);
nd->dentry = dget(fs->altroot);
read_unlock(&fs->lock);
if (__emul_lookup_dentry(name,nd))
goto out; /* found in altroot */
read_lock(&fs->lock);
}
nd->mnt = mntget(fs->rootmnt);
nd->dentry = dget(fs->root);
read_unlock(&fs->lock);
} else if (dfd == AT_FDCWD) {//或者使用当前工作目录作为起点
read_lock(&fs->lock);
nd->mnt = mntget(fs->pwdmnt);
nd->dentry = dget(fs->pwd);
read_unlock(&fs->lock);
} else {
struct dentry *dentry;
file = fget_light(dfd, &fput_needed);
retval = -EBADF;
if (!file)
goto out_fail;
dentry = file->f_path.dentry;
retval = -ENOTDIR;
if (!S_ISDIR(dentry->d_inode->i_mode))
goto fput_fail;
retval = file_permission(file, MAY_EXEC);
if (retval)
goto fput_fail;
nd->mnt = mntget(file->f_path.mnt);
nd->dentry = dget(dentry);
fput_light(file, fput_needed);
}
retval = path_walk(name, nd);
out:
if (unlikely(!retval && !audit_dummy_context() && nd->dentry &&
nd->dentry->d_inode))
audit_inode(name, nd->dentry);
out_fail:
return retval;
fput_fail:
fput_light(file, fput_needed);
goto out_fail;
}path_walk --> link_path_walk --> __link_path_walk
<fs/namei.c>
static fastcall int __link_path_walk(const char * name, struct nameidata *nd)
{
struct path next;
struct inode *inode;
int err;
unsigned int lookup_flags = nd->flags;
while (*name=='/')
name++;
if (!*name)
goto return_reval;
inode = nd->dentry->d_inode;
if (nd->depth)
lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);
/* At this point we know we have a real path component. */
for(;;) {
unsigned long hash;
struct qstr this;
unsigned int c;
nd->flags |= LOOKUP_CONTINUE;
err = exec_permission_lite(inode, nd);//权限检查
if (err == -EAGAIN)
err = vfs_permission(nd, MAY_EXEC);//调用inode_operations的permission方法进行权限检查
if (err)
break;//权限错误
this.name = name;
c = *(const unsigned char *)name;
hash = init_name_hash();
do {
name++;
hash = partial_name_hash(c, hash);
c = *(const unsigned char *)name;
} while (c && (c != '/'));
this.len = name - (const char *) this.name;//提取路径中分量
this.hash = end_name_hash(hash);//计算散列值
/* remove trailing slashes? */
if (!c)//
goto last_component;//当前分量为最后一个分量
while (*++name == '/');//为下一次循环做准备，跳过‘/’
if (!*name)
goto last_with_slashes;
/*
* "." and ".." are special - ".." especially so because it has
* to be able to know about the current root directory and
* parent relationships.
*/
if (this.name[0] == '.') switch (this.len) {
default:
break;
case 2: //两个点的情况，需要回退
if (this.name[1] != '.')
break;
follow_dotdot(nd);
/*follow_dotdot函数。当查找操作处理进程的根目录时，..是没有效果的，因为无法切换到根目录的父目录。否则，有两个可用的选项。如果当前目录不是一个装载点的根目录，则将当前dentry对象的d_parent成员用作新的目录，因为它总是表示父目录。但如果当前目录是一个已装载文件系统的根目录，保存在mnt_mountpoint和mnt_parent中的信息用于定义新的dentry和vfsmount对象。follow_mount和lookup_mnt用于取得所需的信息(follow_mount,找到最后的挂载点)*/
inode = nd->dentry->d_inode;
/* fallthrough */
case 1://一个点（.），表示当前目录，内核将直接跳过查找循环的下一个周期，因为在目录层次结构中的位置没有改变
continue;
}
/*
* See if the low-level filesystem might want
* to use its own hash..
*/
if (nd->dentry->d_op && nd->dentry->d_op->d_hash) {
err = nd->dentry->d_op->d_hash(nd->dentry, &this);
if (err < 0)
break;
}
/* This does the actual lookups.. */
err = do_lookup(nd, &this, &next);//查找分量对应的dentry实例
if (err)
break;
err = -ENOENT;
inode = next.dentry->d_inode;
if (!inode)
goto out_dput;
err = -ENOTDIR;
if (!inode->i_op)
goto out_dput;
if (inode->i_op->follow_link) {//下面进行符号连接的处理
err = do_follow_link(&next, nd);
if (err)
goto return_err;
err = -ENOENT;
inode = nd->dentry->d_inode;
if (!inode)
break;
err = -ENOTDIR;
if (!inode->i_op)
break;
} else
path_to_nameidata(&next, nd);
err = -ENOTDIR;
if (!inode->i_op->lookup)
break;
continue;
/* here ends the main loop */
last_with_slashes:
lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
last_component:
/* Clear LOOKUP_CONTINUE iff it was previously unset */
nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;
if (lookup_flags & LOOKUP_PARENT)
goto lookup_parent;
if (this.name[0] == '.') switch (this.len) {
default:
break;
case 2:
if (this.name[1] != '.')
break;
follow_dotdot(nd);
inode = nd->dentry->d_inode;
/* fallthrough */
case 1:
goto return_reval;
}
if (nd->dentry->d_op && nd->dentry->d_op->d_hash) {
err = nd->dentry->d_op->d_hash(nd->dentry, &this);
if (err < 0)
break;
}
err = do_lookup(nd, &this, &next);
if (err)
break;
inode = next.dentry->d_inode;
if ((lookup_flags & LOOKUP_FOLLOW)
&& inode && inode->i_op && inode->i_op->follow_link) {
err = do_follow_link(&next, nd);
if (err)
goto return_err;
inode = nd->dentry->d_inode;
} else
path_to_nameidata(&next, nd);
err = -ENOENT;
if (!inode)
break;
if (lookup_flags & LOOKUP_DIRECTORY) {
err = -ENOTDIR;
if (!inode->i_op || !inode->i_op->lookup)
break;
}
goto return_base;
lookup_parent:
nd->last = this;
nd->last_type = LAST_NORM;
if (this.name[0] != '.')
goto return_base;
if (this.len == 1)
nd->last_type = LAST_DOT;
else if (this.len == 2 && this.name[1] == '.')
nd->last_type = LAST_DOTDOT;
else
goto return_base;
return_reval:
/*
* We bypassed the ordinary revalidation routines.
* We may need to check the cached dentry for staleness.
*/
if (nd->dentry && nd->dentry->d_sb &&
(nd->dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) {
err = -ESTALE;
/* Note: we do not d_invalidate() */
if (!nd->dentry->d_op->d_revalidate(nd->dentry, nd))
break;
}
return_base:
return 0;
out_dput:
dput_path(&next, nd);
break;
}
path_release(nd);
return_err:
return err;
}do_lookup的实现
<fs/namei.c>
static int do_lookup(struct nameidata *nd, struct qstr *name,
struct path *path)
{
struct vfsmount *mnt = nd->mnt;
struct dentry *dentry = __d_lookup(nd->dentry, name);//试图在dentry缓存中查找inode
if (!dentry)
goto need_lookup;
if (dentry->d_op && dentry->d_op->d_revalidate)
goto need_revalidate;
done:
path->mnt = mnt;
path->dentry = dentry;
__follow_mount(path);//确保已装载文件系统的根目录用作装载点（可能有几个文件系统相继装载到前一个文件系统中，，除了后一个文件系统，所有其他文件系统都被相邻的后一个文件系统隐藏）
return 0;
need_lookup:
dentry = real_lookup(nd->dentry, name, nd);//缓存无效，必须从底层文件系统中发起一个查找操作
if (IS_ERR(dentry))
goto fail;
goto done;
need_revalidate:
dentry = do_revalidate(dentry, nd);
if (!dentry)
goto need_lookup;
if (IS_ERR(dentry))
goto fail;
goto done;
fail:
return PTR_ERR(dentry);
}do_follow_link的实现：
在内核跟踪符号链接时，它必须要注意用户可能构造出的环状结构，如:a->b,b->c,c->a。如果内核不采取适当的防护措施，这可能被利用，导致系统变得不可用。
打开文件
sys_open->do_sys_open->do_filp_open
do_filp_open->open_namei:调用path_lookup函数查找inode并执行几个额外的检查。
do_filp_open->nameidata_to_filp:初始化预读结构，将新创建的file实例放置到超级块的s_files链表上，并调用底层文件系统的file_operations结构的open函数
标准函数
通用读取例程
ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
{
struct iovec iov = { .iov_base = buf, .iov_len = len };
struct kiocb kiocb;
ssize_t ret;
init_sync_kiocb(&kiocb, filp);
kiocb.ki_pos = *ppos;
kiocb.ki_left = len;
for (;;) {
ret = filp->f_op->aio_read(&kiocb, &iov, 1, kiocb.ki_pos);//通常为generic_file_aio_read(异步)
if (ret != -EIOCBRETRY)
break;
wait_on_retry_sync_kiocb(&kiocb);//等待异步读取完成
}
if (-EIOCBQUEUED == ret)
ret = wait_on_sync_kiocb(&kiocb);
*ppos = kiocb.ki_pos;
return ret;
}<mm/filemap.c>
ssize_t
generic_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
unsigned long nr_segs, loff_t pos)
{
struct file *filp = iocb->ki_filp;
ssize_t retval;
unsigned long seg;
size_t count;
loff_t *ppos = &iocb->ki_pos;
count = 0;
retval = generic_segment_checks(iov, &nr_segs, &count, VERIFY_WRITE);//确认读请求包含的参数是否有效
if (retval)
return retval;
/* coalesce the iovecs and go direct-to-BIO for O_DIRECT */
if (filp->f_flags & O_DIRECT) {//直接读取，不使用页缓存
loff_t size;
struct address_space *mapping;
struct inode *inode;
mapping = filp->f_mapping;
inode = mapping->host;
retval = 0;
if (!count)
goto out; /* skip atime */
size = i_size_read(inode);
if (pos < size) {
retval = generic_file_direct_IO(READ, iocb,
iov, pos, nr_segs);
if (retval > 0)
*ppos = pos + retval;
}
if (likely(retval != 0)) {
file_accessed(filp);
goto out;
}
}
retval = 0;
if (count) {
for (seg = 0; seg < nr_segs; seg++) {
read_descriptor_t desc;
desc.written = 0;
desc.arg.buf = iov[seg].iov_base;
desc.count = iov[seg].iov_len;
if (desc.count == 0)
continue;
desc.error = 0;
do_generic_file_read(filp,ppos,&desc,file_read_actor);//该函数将对文件的读操作转换为对映射的读操作
retval += desc.written;
if (desc.error) {
retval = retval ?: desc.error;
break;
}
if (desc.count > 0)
break;
}
}
out:
return retval;
}do_generic_file_read->do_generic_mapping_read
void do_generic_mapping_read(struct address_space *mapping,
struct file_ra_state *ra,
struct file *filp,
loff_t *ppos,
read_descriptor_t *desc,
read_actor_t actor)
{
struct inode *inode = mapping->host;
pgoff_t index;
pgoff_t last_index;
pgoff_t prev_index;
unsigned long offset; /* offset into pagecache page */
unsigned int prev_offset;
int error;
index = *ppos >> PAGE_CACHE_SHIFT;
prev_index = ra->prev_pos >> PAGE_CACHE_SHIFT;
prev_offset = ra->prev_pos & (PAGE_CACHE_SIZE-1);
last_index = (*ppos + desc->count + PAGE_CACHE_SIZE-1) >> PAGE_CACHE_SHIFT;
offset = *ppos & ~PAGE_CACHE_MASK;
for (;;) {
struct page *page;
pgoff_t end_index;
loff_t isize;
unsigned long nr, ret;
cond_resched();
find_page:
page = find_get_page(mapping, index);
if (!page) {//页没有在页缓存中
page_cache_sync_readahead(mapping,
ra, filp,
index, last_index - index);
page = find_get_page(mapping, index);//发出一个同步预读请求
if (unlikely(page == NULL))
goto no_cached_page;
}
if (PageReadahead(page)) {//检查是否需要进行异步预读操作
page_cache_async_readahead(mapping,
ra, filp, page,
index, last_index - index);
}
if (!PageUptodate(page))//检查页缓存中的数据是否是最新的
goto page_not_up_to_date;
page_ok:
/*
* i_size must be checked after we know the page is Uptodate.
*
* Checking i_size after the check allows us to calculate
* the correct value for "nr", which means the zero-filled
* part of the page is not copied back to userspace (unless
* another truncate extends the file - this is desired though).
*/
isize = i_size_read(inode);
end_index = (isize - 1) >> PAGE_CACHE_SHIFT;
if (unlikely(!isize || index > end_index)) {
page_cache_release(page);
goto out;
}
/* nr is the maximum number of bytes to copy from this page */
nr = PAGE_CACHE_SIZE;
if (index == end_index) {
nr = ((isize - 1) & ~PAGE_CACHE_MASK) + 1;
if (nr <= offset) {
page_cache_release(page);
goto out;
}
}
nr = nr - offset;
/* If users can be writing to this page using arbitrary
* virtual addresses, take care about potential aliasing
* before reading the page on the kernel side.
*/
if (mapping_writably_mapped(mapping))
flush_dcache_page(page);
/*
* When a sequential read accesses a page several times,
* only mark it as accessed the first time.
*/
if (prev_index != index || offset != prev_offset)
mark_page_accessed(page);
prev_index = index;
/*
* Ok, we have the page, and it's up-to-date, so
* now we can copy it to user space...
*
* The actor routine returns how many bytes were actually used..
* NOTE! This may not be the same as how much of a user buffer
* we filled up (we may be padding etc), so we can only update
* "pos" here (the actor routine has to update the user buffer
* pointers and the remaining count).
*/
ret = actor(desc, page, offset, nr);
offset += ret;
index += offset >> PAGE_CACHE_SHIFT;
offset &= ~PAGE_CACHE_MASK;
prev_offset = offset;
page_cache_release(page);
if (ret == nr && desc->count)
continue;
goto out;
page_not_up_to_date:
/* Get exclusive access to the page ... */
lock_page(page);
/* Did it get truncated before we got the lock? */
if (!page->mapping) {
unlock_page(page);
page_cache_release(page);
continue;
}
/* Did somebody else fill it already? */
if (PageUptodate(page)) {
unlock_page(page);
goto page_ok;
}
readpage:
/* Start the actual read. The read will unlock the page. */
error = mapping->a_ops->readpage(filp, page);
if (unlikely(error)) {
if (error == AOP_TRUNCATED_PAGE) {
page_cache_release(page);
goto find_page;
}
goto readpage_error;
}
if (!PageUptodate(page)) {
lock_page(page);
if (!PageUptodate(page)) {
if (page->mapping == NULL) {
/*
* invalidate_inode_pages got it
*/
unlock_page(page);
page_cache_release(page);
goto find_page;
}
unlock_page(page);
error = -EIO;
shrink_readahead_size_eio(filp, ra);
goto readpage_error;
}
unlock_page(page);
}
goto page_ok;
readpage_error:
/* UHHUH! A synchronous read error occurred. Report it */
desc->error = error;
page_cache_release(page);
goto out;
no_cached_page:
/*
* Ok, it wasn't cached, so we need to create a new
* page..
*/
page = page_cache_alloc_cold(mapping);
if (!page) {
desc->error = -ENOMEM;
goto out;
}
error = add_to_page_cache_lru(page, mapping,
index, GFP_KERNEL);
if (error) {
page_cache_release(page);
if (error == -EEXIST)
goto find_page;
desc->error = error;
goto out;
}
goto readpage;
}
out:
ra->prev_pos = prev_index;
ra->prev_pos <<= PAGE_CACHE_SHIFT;
ra->prev_pos |= prev_offset;
*ppos = ((loff_t)index << PAGE_CACHE_SHIFT) + offset;
if (filp)
file_accessed(filp);
}