Linux内核设计与实现(14)--虚拟文件系统

梦里梦外; 2022-06-18 03:47 235阅读 0赞

虚拟文件系统，简称VFS。系统中所有文件系统不但依赖VFS共存，而且也依靠VFS系统协同工作。程序可以利用标准的Unix系统调用对不同的文件系统，甚至不同介质上的文件系统进行读写操作。

# 1.通用文件系统接口 #

VFS使得用户可以直接使用open(),read()和write()这样的系统调用而无需考虑具体文件系统和实际物理介质，这点DOS是不具备的，DOS中任何对非本地文件系统的访问都要依靠特殊工具才能完成。

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

# 2.文件系统抽象层 #

VFS可以为应用提供通用接口操作各类文件系统，是因为内核在底层文件系统接口上建立了一个抽象层。这个抽象系统模型，包括了任何文件系统的常用功能集和行为。当然，该模型偏重于Unix风格的文件系统。

内核通过抽象层能够方便、简单地支持各种类型的文件系统，实际文件系统通过编程提供VFS所期望的抽象接口和数据结构。比如用户空间的一个写操作：

ret = write(fd, buf, len);

write系统调用将buf指针指向的长度为len字节的数据写入文件描述符fd对应的文件的当前位置。这个系统调用首先调用sys\_write()处理，sys\_write()函数要找到fd所在的文件系统实际给出的是哪个写操作，然后再执行该操作。具体文件系统的写方法是文件系统实现的一部分，数据最终写入介质。  
![Image 1][]

# 3.Unix文件系统 #

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

从本质上讲文件系统是特殊的数据分层存储结构，包含文件、目录和相关控制信息。

文件系统通用操作包含创建、删除和安装等。在Unix中，文件系统采用全局命名空间，挂载到系统根目录下的一个子节点。

Unix文件概念和面向记录的文件系统形（比如OpenVMS的File-11）成鲜明对比，面向记录的文件系统提供更丰富、更结构化的表示，而简单的面向字节流抽象的Unix文件则以简单性和相当的灵活性为代价。

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

Unix系统将文件的信息和文件本身这两个概念加以区分，例如访问控制权限、大小、拥有者、创建时间等。文件相关信息称作文件的元数据，被存储在一个单独的数据结构中，叫做索引节点（inode）。索引节点存储在超级块中。超级块是一种包含文件系统信息的数据结构。

Linux的VFS设计目标就是要保证能与支持或实现了这些概念的文件系统协同工作。

非Unixf风格的文件系统（比如FAT或NTFS），要在Linux上工作，必须经过封装，提供一个符合这些概念的界面。这个封装转换需要在使用现场引入一些特殊处理，这样文件系统仍然能工作，但其带来的开销是很大的。

# 4.VFS对象及其数据结构 #

VFS其实采用的是面向对象的设计，内核是纯C开发，用结构体来实现对象，结构体包含数据和操作这些数据的函数指针。

VFS有四个主要对象类型，分别是：

超级块对象：代表一个具体已安装文件系统

索引节点对象：代表一个具体文件

目录项对象：代表一个目录项，是路径的一个组成部分

文件对象：它代表由进程打开的文件

注意，这里的目录项代表的是路径的一个组成部分，可能包含一个普通文件。这不同于目录。Unix中，目录仅是一个普通文件。

每个主要对象中，都包含一个操作对象，这些操作对象描述了内核针对主要对象可以使用的方法：

super\_operations对象，包含针对特定文件系统调用方法，比如write\_inode(),sync\_fs等

inode\_operations对象，包含create()，link()等;

dentry\_operations对象，包含d\_compare(),d\_delete()等

file\_operations对象，包含进程针对已打开文件所能调用的方法，比如read()和write()等

操作对象作为一个结构体指针来实现，此结构体中包含指向操作其父对象的函数指针。通常来说，可以继承使用VFS通用函数，如果通用函数提供的基本功能无法满足需要，那就必须使用实际文件系统独有方法填充这些函数指针，使其指向文件系统实例。

VFS使用了大量结构体对象，还包括file\_system\_type描述文件系统及其性能，vfsmount包含安装点相关信息等。

# 5.超级块对象 #

各种文件系统都必须实现超级块对象，该对象用于存储特定文件系统信息，通常对应于存放在磁盘特定扇区中的文件系统超级块或者文件系统控制块(超级块对象)。对于非基于磁盘的文件系统（比如基于内存的文件系统sysfs），它们会在使用现场创建超级块并将其保存到内存中。

超级块对象由super\_block结构体表示，定义在 中：

点击(此处)折叠或打开

1.  struct super\_block \{   
    
2.      struct list\_head    s\_list;        /\* Keep this first \*///指向所有超级快的链表  
    
3.      dev\_t            s\_dev;        /\* search index; \_not\_ kdev\_t \*///设备标识符  
    
4.      unsigned char        s\_dirt; //修改(脏)标志  
    
5.      unsigned char        s\_blocksize\_bits; //块大小，单位bit  
    
6.      unsigned long        s\_blocksize; //块大小，单位字节  
    
7.      loff\_t            s\_maxbytes;    /\* Max file size \*///文件大小上限  
    
8.      struct file\_system\_type    \*s\_type; //文件系统类型  
    
9.      const struct super\_operations    \*s\_op; //超级块方法  
    
10.     const struct dquot\_operations    \*dq\_op; //磁盘限额方法  
    
11.     const struct quotactl\_ops    \*s\_qcop; //限额控制方法  
    
12.     const struct export\_operations \*s\_export\_op;//导出方法  
    
13.     unsigned long        s\_flags; //挂载标志  
    
14.     unsigned long        s\_magic; //文件系统幻数  
    
15.     struct dentry        \*s\_root; //目录挂载点  
    
16.     struct rw\_semaphore    s\_umount; //卸载信号量  
    
17.     struct mutex        s\_lock; //超级块信号量  
    
18.     int            s\_count; //超级块引用计数  
    
19.     int            s\_need\_sync; //尚未同步标志  
    
20.     atomic\_t        s\_active; //活动引用计数  
    
21. \#ifdef CONFIG\_SECURITY  
    
22.     void \*s\_security; //活动模块  
    
23. \#endif  
    
24.     struct xattr\_handler    \*\*s\_xattr; //扩展属性操作  
    
25.   
    
26.     struct list\_head    s\_inodes;    /\* all inodes \*///inodes链表  
    
27.     struct hlist\_head    s\_anon;        /\* anonymous dentries for (nfs) exporting \*///匿名目录项  
    
28.     struct list\_head    s\_files; //被分配文件链表  
    
29.     /\* s\_dentry\_lru and s\_nr\_dentry\_unused are protected by dcache\_lock \*/  
    
30.     struct list\_head    s\_dentry\_lru;    /\* unused dentry lru \*///未被使用目录项链表  
    
31.     int            s\_nr\_dentry\_unused;    /\* \# of dentry on lru \*///链表中目录项的数目  
    
32.   
    
33.     struct block\_device    \*s\_bdev; //相关块设备  
    
34.     struct backing\_dev\_info \*s\_bdi;  
    
35.     struct mtd\_info        \*s\_mtd; //存储磁盘信息  
    
36.     struct list\_head    s\_instances; //该类型文件系统  
    
37.     struct quota\_info    s\_dquot;    /\* Diskquota specific options \*///限额相关选项  
    
38.   
    
39.     int            s\_frozen; //frozen标志位  
    
40.     wait\_queue\_head\_t    s\_wait\_unfrozen; //冻结的等待队列  
    
41.   
    
42.     char s\_id\[32\];                /\* Informational name \*///文本名字  
    
43.   
    
44.     void             \*s\_fs\_info;    /\* Filesystem private info \*///文件系统特殊信息  
    
45.     fmode\_t            s\_mode; //安装权限  
    
46.   
    
47.     /\* Granularity of c/m/atime in ns.  
    
48.      Cannot be worse than a second \*/  
    
49.     u32         s\_time\_gran; //时间戳粒度  
    
50.   
    
51.     /\*  
    
52.      \* The next field is for VFS \*only\*. No filesystems have any business  
    
53.      \* even looking at it. You had been warned.  
    
54.      \*/  
    
55.     struct mutex s\_vfs\_rename\_mutex;    /\* Kludge \*///重命名信号量  
    
56.   
    
57.     /\*  
    
58.      \* Filesystem subtype. If non\-empty the filesystem type field  
    
59.      \* in /proc/mounts will be "type.subtype"  
    
60.      \*/  
    
61.     char \*s\_subtype;//子类型名称  
    
62.   
    
63.     /\*  
    
64.      \* Saved mount options for lazy filesystems using  
    
65.      \* generic\_show\_options()  
    
66.      \*/  
    
67.     char \*s\_options; //已存安装选项  
    
68. \};

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

# 6.超级块操作 #

超级块对象中最重要的一个域是s\_op, 它指向超级块的操作函数表，操作函数表在 定义

该结构体每一项都是一个指向超级块操作函数的指针，超级块操作函数执行文件系统和索引节点的底层操作。

当文件系统需要对其超级块执行操作时，首先要在超级块对象中找到合适的方法，比如一个文件系要写自己的超级块，需要调用

sb->s\_op->write\_super(sb);

由于C语言无法直接得到操作函数的父对象，所以必须将父对象以参数显示传给操作函数。

点击(此处)折叠或打开

1.  struct super\_operations \{   
    
2.      //在给定的超级块下创建和初始化一个新的索引节点对象  
    
3.         struct inode \*(\*alloc\_inode)(struct super\_block \*sb);  
    
4.      //释放给定的索引节点  
    
5.      void (\*destroy\_inode)(struct inode \*);  
    
6.      //VFS在索引节点脏(被修改)时会调用此函数  
    
7.      //日志文件系统，(比如ext3/etx4)执行该函数进行日志更新  
    
8.         void (\*dirty\_inode) (struct inode \*);  
    
9.      //用于将给定的索引节点写入磁盘，wait参数指明写操作是否需同步  
    
10.     int (\*write\_inode) (struct inode \*, struct writeback\_control \*wbc);  
    
11.     //在最后一个指向索引节点的引用被释放后，VFS会调用该函数，VFS只需要简单地删除这个索引节点后,Unix文件系统就不会定义这个函数了  
    
12.     void (\*drop\_inode) (struct inode \*);  
    
13.     void (\*delete\_inode) (struct inode \*);//从磁盘删除给定的索引节点  
    
14.     void (\*put\_super) (struct super\_block \*);//卸载文件系统时被VFS调用，用来释放超级块，调用者必须持有s\_lock锁  
    
15.     //用给定的超级块更新磁盘上的超级块，VFS通过该函数对内存中的超级块和磁盘中的超级块进行同步，调用者必须持有s\_lock锁  
    
16.     void (\*write\_super) (struct super\_block \*);  
    
17. //使文件系统的数据元与磁盘上的文件系统同步，wait参数指定操作是否同步  
    
18.     int (\*sync\_fs)(struct super\_block \*sb, int wait);  
    
19.     int (\*freeze\_fs) (struct super\_block \*);  
    
20.     int (\*unfreeze\_fs) (struct super\_block \*);  
    
21.     int (\*statfs) (struct dentry \*, struct kstatfs \*);//获取文件系统状态  
    
22. //当执行新的安装选项重新安装文件系统时，VFS会调用，必须持有s\_lock锁  
    
23.     int (\*remount\_fs) (struct super\_block \*, int \*, char \*);  
    
24. //VFS调用，释放索引节点，并清空包含相关数据所有页面  
    
25.     void (\*clear\_inode) (struct inode \*);  
    
26. //VFS调用中断安装操作，该函数被网络文件系统使用，如NFS。  
    
27.     void (\*umount\_begin) (struct super\_block \*);  
    
28.   
    
29.     int (\*show\_options)(struct seq\_file \*, struct vfsmount \*);  
    
30.     int (\*show\_stats)(struct seq\_file \*, struct vfsmount \*);  
    
31. \#ifdef CONFIG\_QUOTA  
    
32.     ssize\_t (\*quota\_read)(struct super\_block \*, int, char \*, size\_t, loff\_t);  
    
33.     ssize\_t (\*quota\_write)(struct super\_block \*, int, const char \*, size\_t, loff\_t);  
    
34. \#endif  
    
35.     int (\*bdev\_try\_to\_free\_page)(struct super\_block\*, struct page\*, gfp\_t);  
    
36. \};

以上函数都是由VFS在进程上下文调用，除了dirty\_inode()，其他函数可以阻塞。

其中一些函数是可选的，不需要的函数设为NULL，如果VFS发现操作函数指针是NULL，它调用通用函数指向相应操作，或者什么都不做。

# 7.索引节点对象 #

索引节点对象，包含了内核在操作文件或目录时需要的全部信息。

对于Unix风格的文件系统来说，这些信息可以从磁盘索引节点直接读入。有的文件系统没有索引节点，没有将数据和控制信息分开存放。不管哪种情况、采用哪种方式，索引节点对象必须在内存中创建，以便于文件系统调用。

索引节点对象inode结构，在 中定义

点击(此处)折叠或打开

1.  struct inode \{   
    
2.      struct hlist\_node    i\_hash; //散列表  
    
3.      /\* backing dev IO list \*/  
    
4.      struct list\_head    i\_list;         //索引节点链表  
    
5.      struct list\_head    i\_sb\_list; //超级块链表  
    
6.      struct list\_head    i\_dentry; //目录项链表  
    
7.      unsigned long        i\_ino; //节点号  
    
8.      atomic\_t        i\_count; //引用计数  
    
9.      unsigned int        i\_nlink; //硬链接数  
    
10.     uid\_t            i\_uid; //使用者id  
    
11.     gid\_t            i\_gid; //使用组id  
    
12.     dev\_t            i\_rdev; //实际设备标志符  
    
13.     unsigned int        i\_blkbits; //以位单位文件大小  
    
14.     u64            i\_version; //版本号  
    
15.     loff\_t            i\_size; //以字节单位文件大小  
    
16. \#ifdef \_\_NEED\_I\_SIZE\_ORDERED  
    
17.     seqcount\_t        i\_size\_seqcount; //以i\_size进行串行计数  
    
18. \#endif  
    
19.     struct timespec        i\_atime; //最后访问时间  
    
20.     struct timespec        i\_mtime; //最后修改时间  
    
21.     struct timespec        i\_ctime; //最后改变时间  
    
22.     blkcnt\_t        i\_blocks; //文件的块数  
    
23.     unsigned short i\_bytes; //使用的字节数  
    
24.     umode\_t            i\_mode; //访问权限  
    
25.     /\* i\_blocks, i\_bytes, maybe i\_size \*/  
    
26.     spinlock\_t        i\_lock;     //自旋锁  
    
27.     struct mutex        i\_mutex; //互斥锁  
    
28.     struct rw\_semaphore    i\_alloc\_sem; //嵌入i\_sem内部  
    
29.     const struct inode\_operations    \*i\_op;//索引节点操作表  
    
30.     /\* former \->i\_op\->default\_file\_ops \*/  
    
31.     const struct file\_operations    \*i\_fop;//缺省的索引节点操作表  
    
32.     struct super\_block    \*i\_sb; //相关的超级块  
    
33.     struct file\_lock    \*i\_flock;  
    
34.     struct address\_space    \*i\_mapping;//相关的地址映射  
    
35.     struct address\_space    i\_data; //设备地址映射  
    
36. \#ifdef CONFIG\_QUOTA  
    
37.     struct dquot        \*i\_dquot\[MAXQUOTAS\];  
    
38. \#endif  
    
39.     struct list\_head    i\_devices;  
    
40.     union \{   
    
41.         struct pipe\_inode\_info    \*i\_pipe; //管道信息  
    
42.         struct block\_device    \*i\_bdev; //块设备驱动  
    
43.         struct cdev        \*i\_cdev; //字符设备驱动  
    
44.     \};  
    
45.   
    
46.     \_\_u32            i\_generation;  
    
47.   
    
48. \#ifdef CONFIG\_FSNOTIFY  
    
49.     \_\_u32            i\_fsnotify\_mask; /\* all events this inode cares about \*/  
    
50.     struct hlist\_head    i\_fsnotify\_mark\_entries; /\* fsnotify mark entries \*/  
    
51. \#endif  
    
52.   
    
53. \#ifdef CONFIG\_INOTIFY  
    
54.     struct list\_head    inotify\_watches; /\* watches on this inode \*/  
    
55.     struct mutex        inotify\_mutex;    /\* protects the watches list \*/  
    
56. \#endif  
    
57.   
    
58.     unsigned long        i\_state;  
    
59.     unsigned long        dirtied\_when;    /\* jiffies of first dirtying \*/  
    
60.   
    
61.     unsigned int        i\_flags; //文件系统标志  
    
62.   
    
63.     atomic\_t        i\_writecount; //写者技数  
    
64. \#ifdef CONFIG\_SECURITY  
    
65.     void            \*i\_security; //安全模块  
    
66. \#endif  
    
67. \#ifdef CONFIG\_FS\_POSIX\_ACL  
    
68.     struct posix\_acl    \*i\_acl;  
    
69.     struct posix\_acl    \*i\_default\_acl;  
    
70. \#endif  
    
71.     /\* fs or device private pointer \*/  
    
72.   
    
73.     void            \*i\_private;//fs私有指针  
    
74. \};

一个索引节点代表文件系统中的一个文件（索引节点仅当文件被访问时，才在内存中创建），也可以是设备文件或管道文件这样的特殊文件。

# 8.索引节点操作 #

索引节点对象的inode\_operations项非常重要，因为它描述了操作索引节点的所有方法，这些方法由文件系统实现。在 定义

点击(此处)折叠或打开

1.  struct inode\_operations \{   
    
2.  //VFS通过系统调用create()和open()来调用该函数，从而为dentry对象创建  
    
3.  //一个新的索引节点  
    
4.      int (\*create) (struct inode \*,struct dentry \*,int, struct nameidata \*);  
    
5.  //在特定的目录中寻找索引节点，该索引节点要对应于denrty中给定的文件名  
    
6.      struct dentry \* (\*lookup) (struct inode \*,struct dentry \*, struct nameidata \*);  
    
7.  //被系统调用link()调用，用来创建硬链接  
    
8.  //硬链接名称由dentry参数指定，链接对象是dir目录中old\_dentry目录项所代表的文件  
    
9.      int (\*link) (struct dentry \*,struct inode \*,struct dentry \*);  
    
10. //被系统调用ulink()调用，从目录dir中删除由目录项dentry指定的索引节点对象  
    
11.     int (\*unlink) (struct inode \*,struct dentry \*);  
    
12. //被symlik()调用，创建符号链接  
    
13.     int (\*symlink) (struct inode \*,struct dentry \*,const char \*);  
    
14. //被mknod()调用，创建新目录  
    
15.     int (\*mkdir) (struct inode \*,struct dentry \*,int);  
    
16. //被rmdir()调用，删除dir目录中的dentry目录项代表的文件  
    
17.     int (\*rmdir) (struct inode \*,struct dentry \*);  
    
18. //被mknod()调用，船舰特殊文件(设备文件，管道，套接字等)  
    
19.     int (\*mknod) (struct inode \*,struct dentry \*,int,dev\_t);  
    
20. //移动文件  
    
21.     int (\*rename) (struct inode \*, struct dentry \*,  
    
22.             struct inode \*, struct dentry \*);  
    
23. //readlink()调用，拷贝数据到特定的缓冲buffer中?  
    
24. //拷贝的数据来自dentry指定的符号链接，拷贝大小最大可达buflen字节  
    
25.     int (\*readlink) (struct dentry \*, char \_\_user \*,int);  
    
26.     void \* (\*follow\_link) (struct dentry \*, struct nameidata \*);  
    
27.     void (\*put\_link) (struct dentry \*, struct nameidata \*, void \*);  
    
28.     void (\*truncate) (struct inode \*);//修改文件大小  
    
29.     int (\*permission) (struct inode \*, int);//检查访问权限  
    
30.     int (\*check\_acl)(struct inode \*, int);  
    
31. //被notify\_change()调用，在修改索引节点后，通知发送了"改变事件"  
    
32.     int (\*setattr) (struct dentry \*, struct iattr \*);  
    
33. //在通知索引节点需要从磁盘中更新时，VFS会调用  
    
34.     int (\*getattr) (struct vfsmount \*mnt, struct dentry \*, struct kstat \*);  
    
35. //VFS调用，给dentry指定的文件设置扩展属性  
    
36.     int (\*setxattr) (struct dentry \*, const char \*,const void \*,size\_t,int);  
    
37. //VFS调用，向value中拷贝给定文件的扩展属性name对应的数值  
    
38.     ssize\_t (\*getxattr) (struct dentry \*, const char \*, void \*, size\_t);  
    
39. //将特定文件的所有属性列表拷贝到一个缓冲列表中  
    
40.     ssize\_t (\*listxattr) (struct dentry \*, char \*, size\_t);  
    
41. //从文件中删除指定的属性  
    
42.     int (\*removexattr) (struct dentry \*, const char \*);  
    
43.     void (\*truncate\_range)(struct inode \*, loff\_t, loff\_t);  
    
44.     long (\*fallocate)(struct inode \*inode, int mode, loff\_t offset,  
    
45.              loff\_t len);  
    
46.     int (\*fiemap)(struct inode \*, struct fiemap\_extent\_info \*, u64 start,  
    
47.          u64 len);  
    
48. \};

# 9.目录项对象 #

VFS把目录当作文件对待，一个完整路径中的每个组成部分都由一个索引节点对象标志。虽然可以用索引节点表示，但为了实际操作方便，引入目录项对象。完整路径的每一部分都是一个目录项对象，比如/bin/vi中/,bin,vi是三个目录项对象。

VFS在执行目录操作时(需要的话)会现场创建目录项对象。

目录项对象dentry结构体在 定义

点击(此处)折叠或打开

1.  struct dentry \{   
    
2.      atomic\_t d\_count; //使用计数  
    
3.      /\* protected by d\_lock \*/  
    
4.      unsigned int d\_flags;         //目录项标识  
    
5.      /\* per dentry lock \*/  
    
6.      spinlock\_t d\_lock; //但目录项锁          
    
7.      int d\_mounted;  
    
8.      /\* Where the name belongs to \- NULL is  
    
9.                       \* negative \*/  
    
10.     struct inode \*d\_inode;         //相关联的索引节点  
    
11.     /\*  
    
12.      \* The next three fields are touched by \_\_d\_lookup. Place them here  
    
13.      \* so they all fit in a cache line.  
    
14.      \*/  
    
15.     struct hlist\_node d\_hash;    /\* lookup hash list \*/  
    
16.     struct dentry \*d\_parent;    /\* parent directory \*/  
    
17.     struct qstr d\_name; //目录项名字  
    
18.   
    
19.     struct list\_head d\_lru;        /\* LRU list \*///未使用的链表  
    
20.     /\*  
    
21.      \* d\_child and d\_rcu can share memory  
    
22.      \*/  
    
23.     union \{   
    
24.     /\* child of parent list \*/  
    
25.         struct list\_head d\_child;//目录项内部形成的链表  
    
26.          struct rcu\_head d\_rcu; //RCU加锁  
    
27.     \} d\_u;  
    
28.     struct list\_head d\_subdirs;    /\* our children \*///子目录链表  
    
29.     struct list\_head d\_alias;    /\* inode alias list \*///索引节点别名链表  
    
30.     unsigned long d\_time;        /\* used by d\_revalidate \*///重置时间  
    
31.     const struct dentry\_operations \*d\_op;//目录项操作时间  
    
32.     struct super\_block \*d\_sb;    /\* The root of the dentry tree \*///文件的超级块  
    
33.     void \*d\_fsdata;            /\* fs\-specific data \*///文件系统特有数据  
    
34.   
    
35.     unsigned char d\_iname\[DNAME\_INLINE\_LEN\_MIN\];    /\* small names \*/  
    
36. \};

与超级块和索引节点不同，目录项对象没有对应的磁盘数据结构，VFS根据字符串形式的路径名现场创建它，而且由于目录项对象并非真正保存在磁盘上，所以目录项结构体没有是否被修改的标志。

## 9.1 目录项状态 ##

目录项对象有三种有效状态：被使用、未被使用和负状态。

(1)一个被使用的目录项对应一个有效的索引节点(d\_inode指针)，并且表明该对象存在一个或多个使用者(d\_count为正值)，一个目录项处于被使用状态，意味着它正被VFS使用并且指向有效数据，因此不能丢弃。

(2)一个未被使用的目录项对应一个有效的索引节点(d\_inode指向索引节点)，但VFS当前并未使用(d\_count为0)，该目录项对象仍然指向一个有效对象，而且被保留在缓存中以便需要时使用。这样当需要它时，不必重新创建，这样路径查找更快。

(3)负状态的目录项没有对应的有效索引节点，节点以及被删除或路径已经不正确了。但目录项仍然保留，以便快速解析以后的路径查询。

目录项对象释放后也可以保存到slab对象缓存中。

## 9.2 目录项缓存 ##

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

dcache主要包括三个部分：

(1)“被使用的”目录项链表，i\_dentry项链接相关索引节点。因为一个索引节点可能有多个链接，所以就可能有多个目录项对象，因此用链表链接他们。

(2)“最近被使用的”双向链表。该链表含有未被使用的或负状态的目录项对象。

由于该链表总是在头部插入目录项，所以头节点目录项是最新的，内核通过删除节点回收内存时，会从链尾删除。

(3)散列表和相应的散列函数，用来快速地将给定路径解析为相关目录项对象。

散列表由数组dentry\_hashtable表示，其中每一个元素都是一个指向相同键值的目录项对象链表的指针。

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

dcache在一定意义上也提供了对索引节点的缓存，即icache。和目录项对象相关的索引节点不会被释放。因为目录项让相关索引节点的使用计数为正，这样确保相应索引节点保留在内存中。所以，只要路径名在缓存中找到，那么相应的索引节点肯定也在内存中缓存着。

因为文件访问呈现空间和时间的局部性，所以对目录项和索引节点进程缓存非常有益。

时间的局部性，是指程序可能会一次又一次地访问相同的文件，当同一个文件被访问时，所缓存的相关目录项和索引节点命中率高。

空间局部性，是指程序可能在同一个目录下访问多个文件，因此一个文件对应的目录项缓存后命中率高，因为相关的文件可能在下次又被使用。

# 10.目录项操作 #

dentry\_operation结构体指向VFS操作目录项的所有方法，在 定义

点击(此处)折叠或打开

1.  struct dentry\_operations \{   
    
2.      int (\*d\_revalidate)(struct dentry \*, struct nameidata \*);  
    
3.      int (\*d\_hash) (struct dentry \*, struct qstr \*);  
    
4.      int (\*d\_compare) (struct dentry \*, struct qstr \*, struct qstr \*);  
    
5.      int (\*d\_delete)(struct dentry \*);  
    
6.      void (\*d\_release)(struct dentry \*);  
    
7.      void (\*d\_iput)(struct dentry \*, struct inode \*);  
    
8.      char \*(\*d\_dname)(struct dentry \*, char \*, int);  
    
9.  \};

int d\_ revalidate(struct dentry \*dentry, struct nameidata\*name);

判断目录对象是否有效,VFS准备从dcache中使用一个目录项时，会调用该函数，大部分时候设为NULL,因为dcache中的目录项总是有效的。

int (\*d\_hash) (struct dentry \* dentry, struct qstr \* name);

该函数为目录生成散列值，当目录项需要加入到散列表中时，VFS调用该函数。

int (\*d\_compare) (struct dentry \* dentry, struct qstr \*name1, struct qstr \*name2);

多数文件系统使用VFS默认的操作，仅比较字符串。但有些系统，比如FAT，不区分大小写的，所以需要实现不区分大小写的字符串比较函数。

int (\*d\_delete)(struct dentry \*dentry);

当目录项对象的d\_count计数值等于0，VFS调用该函数

void (\*d\_release)(struct dentry \*);

当目录项对象将要被释放时，VFS调用该函数

void (\*d\_iput)(struct dentry \*, struct inode \*);

当目录项丢失了索引节点时（索引节点被删除了），VFS调用，默认调用input()函数释放所有节点。

# 11.文件对象 #

文件对象，表示进程已打开的文件，进程直接处理的是文件，而不是超级块，索引节点或目录项。文件对象与我们熟悉的系统调用read()和write()对应。

多个进程可以同时打开和操作同一个文件，所以同一个文件也可能存在多个对应的文件对象。文件对象仅仅是进程观点上已打开的实际文件，只有索引节点和目录项对象才是唯一的。

文件对象在 定义

点击(此处)折叠或打开

1.  struct file \{   
    
2.      /\*  
    
3.       \* fu\_list becomes invalid after file\_free is called and queued via  
    
4.       \* fu\_rcuhead for RCU freeing  
    
5.       \*/  
    
6.      union \{   
    
7.          struct list\_head    fu\_list; //文件对象链表  
    
8.          struct rcu\_head     fu\_rcuhead; //释放之后的RCU链表  
    
9.      \} f\_u;  
    
10.     struct path        f\_path; //包含目录项  
    
11. \#define f\_dentry    f\_path.dentry  
    
12. \#define f\_vfsmnt    f\_path.mnt  
    
13.     const struct file\_operations    \*f\_op;//文件操作表  
    
14.     spinlock\_t        f\_lock; /\* f\_ep\_links, f\_flags, no IRQ \*///单个文件结构锁  
    
15.     atomic\_long\_t        f\_count; //文件对象的使用计数  
    
16.     unsigned int         f\_flags; //打开文件时所指定的标志  
    
17.     fmode\_t            f\_mode; //文件的访问模式  
    
18.     loff\_t            f\_pos; //文件当前的位移量(文件指针)  
    
19.     struct fown\_struct    f\_owner; //拥有者通过信号进行异步I/O数据传送  
    
20.     const struct cred    \*f\_cred; //文件的信任状  
    
21.     struct file\_ra\_state    f\_ra; //预读状态  
    
22.   
    
23.     u64            f\_version; //版本号  
    
24. \#ifdef CONFIG\_SECURITY  
    
25.     void            \*f\_security; //安全模块  
    
26. \#endif  
    
27.     /\* needed for tty driver, and maybe others \*/  
    
28.     void            \*private\_data; //tty设备驱动的钩子  
    
29.   
    
30. \#ifdef CONFIG\_EPOLL  
    
31.     /\* Used by fs/eventpoll.c to link all the hooks to this file \*/  
    
32.     struct list\_head    f\_ep\_links; //事件池链表  
    
33. \#endif /\* \#ifdef CONFIG\_EPOLL \*/  
    
34.     struct address\_space    \*f\_mapping; //页缓存映射  
    
35. \#ifdef CONFIG\_DEBUG\_WRITECOUNT  
    
36.     unsigned long f\_mnt\_write\_state; //调试状态  
    
37. \#endif  
    
38. \};

文件对象实际上没有对应的磁盘数据，通过f\_dentry指针指向相关的目录项对象，目录项会指向相关的索引节点，索引节点会记录文件是否为脏的。

# 12.文件操作 #

点击(此处)折叠或打开

1.  /\*  
    
2.   \* NOTE:  
    
3.   \* read, write, poll, fsync, readv, writev, unlocked\_ioctl and compat\_ioctl  
    
4.   \* can be called without the big kernel lock held in all filesystems.  
    
5.   \*/  
    
6.  struct file\_operations \{   
    
7.      struct module \*owner;  
    
8.  //该函数用于更新偏移量指针，  
    
9.  //由系统调用lleek()调用  
    
10.     loff\_t (\*llseek) (struct file \*, loff\_t, int);  
    
11. //从给定文件的offset偏移处读取count字节到buf中  
    
12. //由系统调用read()调用  
    
13.     ssize\_t (\*read) (struct file \*, char \_\_user \*, size\_t, loff\_t \*);  
    
14. //从给定buf中取出count字节数据，写入给定文件的offset偏移处，更新文件指针  
    
15. //由系统调用write()调用  
    
16.     ssize\_t (\*write) (struct file \*, const char \_\_user \*, size\_t, loff\_t \*);  
    
17. //从给定文件，以同步方式读取count字节的数据到buf中，  
    
18. //由系统调用aio\_read()调用  
    
19.     ssize\_t (\*aio\_read) (struct kiocb \*, const struct iovec \*, unsigned long, loff\_t);  
    
20. //以同步方式从给定buf中取出count字节数据，写入由iocb描述的文件中  
    
21. //由系统调用aio\_write()调用  
    
22.     ssize\_t (\*aio\_write) (struct kiocb \*, const struct iovec \*, unsigned long, loff\_t);  
    
23. //返回目录列表的下一个目录  
    
24. //由系统调用readdir()调用  
    
25.     int (\*readdir) (struct file \*, void \*, filldir\_t);  
    
26. //该函数睡眠等待给定的文件活动  
    
27. //由系统调用poll()调用  
    
28.     unsigned int (\*poll) (struct file \*, struct poll\_table\_struct \*);  
    
29. //给设备发送命令参数对，进行设置操作  
    
30. //由系统调用ioctl调用，调用者必须持有BKL  
    
31.     int (\*ioctl) (struct inode \*, struct file \*, unsigned int, unsigned long);  
    
32. //功能与ioctl()类似，但不需要调用者持有BKL，如果用户空间调用ioctl()系统调用，  
    
33. //VFS可以调用unlocked\_ioctl(),它与ioctl()实现一个即可，一般有限实现unlocked\_ioctl()  
    
34.     long (\*unlocked\_ioctl) (struct file \*, unsigned int, unsigned long);  
    
35. //是ioctl()函数的可移植变种，被32位应用程序用在64位系统上  
    
36.     long (\*compat\_ioctl) (struct file \*, unsigned int, unsigned long);  
    
37. //将给定的文件映射到指定的地址空间上，  
    
38. //由系统调用mmap()调用  
    
39.     int (\*mmap) (struct file \*, struct vm\_area\_struct \*);  
    
40. //创建一个新的文件对象，并将它与相应索引节点对象关联  
    
41. //由系统调用open()调用  
    
42.     int (\*open) (struct inode \*, struct file \*);  
    
43. //当已打开文件的引用计数减少时，该函数被VFS调用，作用根据具体文件系统而定  
    
44.     int (\*flush) (struct file \*, fl\_owner\_t id);  
    
45. //当文件最后一个引用被注销时，该函数被VFS调用  
    
46.     int (\*release) (struct inode \*, struct file \*);  
    
47. //将给定文件的所有缓存数据写回磁盘  
    
48. //由系统调用fsync()调用  
    
49.     int (\*fsync) (struct file \*, struct dentry \*, int datasync);  
    
50. //将iocb描述的文件所有缓存数据写回磁盘，  
    
51. //由系统调用aio\_fsync()调用  
    
52.     int (\*aio\_fsync) (struct kiocb \*, int datasync);  
    
53. //用于打开或关闭异步I/O的通告信号  
    
54.     int (\*fasync) (int, struct file \*, int);  
    
55. //给指定文件上锁  
    
56.     int (\*lock) (struct file \*, int, struct file\_lock \*);  
    
57.     ssize\_t (\*sendpage) (struct file \*, struct page \*, int, size\_t, loff\_t \*, int);  
    
58.     unsigned long (\*get\_unmapped\_area)(struct file \*, unsigned long, unsigned long, unsigned long, unsigned long);  
    
59.     int (\*check\_flags)(int);  
    
60.     int (\*flock) (struct file \*, int, struct file\_lock \*);  
    
61.     ssize\_t (\*splice\_write)(struct pipe\_inode\_info \*, struct file \*, loff\_t \*, size\_t, unsigned int);  
    
62.     ssize\_t (\*splice\_read)(struct file \*, loff\_t \*, struct pipe\_inode\_info \*, size\_t, unsigned int);  
    
63.     int (\*setlease)(struct file \*, long, struct file\_lock \*\*);  
    
64. \};

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

除了上面几种VFS基础对象外，内核还使用了另外一些标注数据结构来管理文件系统的其他相关数据。

第一个是file\_system\_type，用来描述各种特定文件系统类型，比如ext3/4，UDF。

在 定义

点击(此处)折叠或打开

1.  struct file\_system\_type \{   
    
2.      const char \*name; //文件系统名字  
    
3.      int fs\_flags; //文件系统类型标志  
    
4.  //从磁盘中读取超级块  
    
5.      int (\*get\_sb) (struct file\_system\_type \*, int,  
    
6.           const char \*, void \*, struct vfsmount \*);  
    
7.      void (\*kill\_sb) (struct super\_block \*);//终止访问超级块  
    
8.      struct module \*owner; //文件系统模块  
    
9.      struct file\_system\_type \* next; //链表中下一个文件系统类型  
    
10.     struct list\_head fs\_supers; //超级块对象链表  
    
11. //以下字段运行时使锁生效  
    
12.     struct lock\_class\_key s\_lock\_key;  
    
13.     struct lock\_class\_key s\_umount\_key;  
    
14.   
    
15.     struct lock\_class\_key i\_lock\_key;  
    
16.     struct lock\_class\_key i\_mutex\_key;  
    
17.     struct lock\_class\_key i\_mutex\_dir\_key;  
    
18.     struct lock\_class\_key i\_alloc\_sem\_key;  
    
19. \};

get\_sb()函数从磁盘读取超级块，并且在文件系统被安装时，在内存中组装超级块对象，剩余的函数描述文件系统属性。

每种文件系统不管被安装多少个实例到系统中，都只有一个file\_system\_type结构。当文件系统被实际安装时，有一个vfsmount结构体在安装点被创建。该结构体用来代表文件系统的实例，即一个安装点

第二个结构体vfsmount，在 定义

点击(此处)折叠或打开

1.  struct vfsmount \{   
    
2.      struct list\_head mnt\_hash;  
    
3.      struct vfsmount \*mnt\_parent;    /\* fs we are mounted on \*/  
    
4.      struct dentry \*mnt\_mountpoint;    /\* dentry of mountpoint \*/  
    
5.      struct dentry \*mnt\_root;    /\* root of the mounted tree \*/  
    
6.      struct super\_block \*mnt\_sb;    /\* pointer to superblock \*/  
    
7.      struct list\_head mnt\_mounts;    /\* list of children, anchored here \*/  
    
8.      struct list\_head mnt\_child;    /\* and going through their mnt\_child \*/  
    
9.      int mnt\_flags;  
    
10.     /\* 4 bytes hole on 64bits arches \*/  
    
11.     const char \*mnt\_devname;    /\* Name of device e.g. /dev/dsk/hda1 \*/  
    
12.     struct list\_head mnt\_list;  
    
13.     struct list\_head mnt\_expire;    /\* link in fs\-specific expiry list \*/  
    
14.     struct list\_head mnt\_share;    /\* circular list of shared mounts \*/  
    
15.     struct list\_head mnt\_slave\_list;/\* list of slave mounts \*/  
    
16.     struct list\_head mnt\_slave;    /\* slave list entry \*/  
    
17.     struct vfsmount \*mnt\_master;    /\* slave is on master\->mnt\_slave\_list \*/  
    
18.     struct mnt\_namespace \*mnt\_ns;    /\* containing namespace \*/  
    
19.     int mnt\_id;            /\* mount identifier \*/  
    
20.     int mnt\_group\_id;        /\* peer group identifier \*/  
    
21.     /\*  
    
22.      \* We put mnt\_count & mnt\_expiry\_mark at the end of struct vfsmount  
    
23.      \* to let these frequently modified fields in a separate cache line  
    
24.      \* (so that reads of mnt\_flags wont ping\-pong on SMP machines)  
    
25.      \*/  
    
26.     atomic\_t mnt\_count;  
    
27.     int mnt\_expiry\_mark;        /\* true if marked for expiry \*/  
    
28.     int mnt\_pinned;  
    
29.     int mnt\_ghosts;  
    
30. \#ifdef CONFIG\_SMP  
    
31.     int \_\_percpu \*mnt\_writers;  
    
32. \#else  
    
33.     int mnt\_writers;  
    
34. \#endif  
    
35. \};

vfsmount结构还保存了在安装时指定的标志信息，该信息存储在mnt\_flags域中

![Image 1][]

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

每个进程多有自己的一组打开的文件，像跟文件系统，当前工作目录，安装点等。有三个将VFS层和系统的进程紧密联系在一起，它们分别是file\_struct, fs\_struct, namespace结构体。

file\_struct 结构体定义在 中，该结构体由进程描述符的files目录项指向，所有与单个进程相关的信息(如打开的文件及文件描述符)都包含在其中

点击(此处)折叠或打开

1.  /\*  
    
2.   \* Open file table structure  
    
3.   \*/  
    
4.  struct files\_struct \{   
    
5.    /\*  
    
6.     \* read mostly part  
    
7.     \*/  
    
8.      atomic\_t count; //结构的使用计数  
    
9.      struct fdtable \*fdt; //指向其他fd表的指针  
    
10.     struct fdtable fdtab; //基fd表  
    
11.   /\*  
    
12.    \* written part on a separate cache line in SMP  
    
13.    \*/  
    
14.     spinlock\_t file\_lock \_\_\_\_cacheline\_aligned\_in\_smp;  
    
15.     int next\_fd; //缓存下一个可用的fd  
    
16.     struct embedded\_fd\_set close\_on\_exec\_init;//exec()时关闭的文件描述符表  
    
17.     struct embedded\_fd\_set open\_fds\_init;//打开的文件描述符链表  
    
18.     struct file \* fd\_array\[NR\_OPEN\_DEFAULT\];//缺省的文件对象数组  
    
19. \};

第二个和进程相关的结构体是fs\_struct，该结构由进程描述符的fs域指向，它包含文件系统和进程的相关信息，定义在 中

点击(此处)折叠或打开

1.  struct fs\_struct \{   
    
2.      int users; //用户数目  
    
3.      rwlock\_t lock; //保护该结构体的锁  
    
4.      int umask; //掩码  
    
5.      int in\_exec; //当前正执行的文件  
    
6.      struct path root, pwd;//根目录路径和当前工作目录路径  
    
7.  \};

第三个相关进程相关结构体是namespace，由进程描述符的mmt\_namespace域指向，在 定义，大多数系统上只有一个命名空间，但CLONE\_NEWS标志可以使这一功能失效。

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

小结：

Linux支持了相当多种类的文件系统，从本地文件系统(ext3和ext4)到网络文件系统(NFS和Coda)，Linux在标准内核中已支持的文件系统超过60种。VFS层提供给这些不同文件系统一个统一的实现框架，而且也提供了能和标准系统调用交互工作的统一接口。由于VFS层的存在，使得在Linux上实现新文件系统的工作变得简单起来，它可以轻松地使这些文件系统通过标准Unix系统调用而协同工作。

阅读(3287) | 评论(3) | 转发(12) |

上一篇：Linux内核设计与实现(13)--进程地址空间

下一篇： Linux内核设计与实现(15)--块I/O层