Linux 内核编程之文件系统（二）

VFS中的目录项对象和文件对象

一 .VFS 中的目录项对象

1.为了方便查找，VFS引入了 目录 项，每个dentry代表路径中的一个特定部分。目录项也可包括安装点。
2.目录项对象由dentry结构体表示 ，定义在文件linux/dcache.h 头文件中。
89struct dentry {
90 atomic_t d_count; //使用计数
91 unsigned int d_flags; //目录项标时
92 spinlock_t d_lock; //单目录锁
93 int d_mounted; //目录项的安装点
94 struct inode *d_inode; //与该目录项相关联的索引节点
95
96 /*
97 * The next three fields are touched by __d_lookup. Place them here
98 * so they all fit in a cache line.
99 */
100 struct hlist_node d_hash; //散列表
101 struct dentry *d_parent; //父目录项
102 struct qstr d_name; //目录项名可快速查找
103
104 struct list_head d_lru; // 未使用目录以LRU 算法链接的链表
105 /*
106 * d_child and d_rcu can share memory
107 */
108 union {
109 struct list_head d_child; /* child of parent list */
110 struct rcu_head d_rcu;
111 } d_u;
112 struct list_head d_subdirs; //该目录项子目录项所形成的链表
113 struct list_head d_alias; //索引节点别名链表
114 unsigned long d_time; //重新生效时间
115 const struct dentry_operations *d_op; // 操作目录项的函数
116 struct super_block *d_sb; //目录项树的根
117 void *d_fsdata; //具体文件系统的数据
118
119 unsigned char d_iname[DNAME_INLINE_LEN_MIN]; //短文件名
120};
1>索引节点中的i_dentry指向了它目录项，目录项中的d_alias，d_inode又指会了索引节点对象，目录项中的d_sb又指回了超级块对象。
2>我们可以看到不同于VFS 中的索引节点对象和超级块对象，目录项对象中没有对应磁盘的数据结构，所以说明目录项对象并没有真正标存在磁盘上，那么它也就没有脏标志位。
3>目录项的状态(被使用，未被使用和负状态）
a.它们是靠d_count的值来进行区分的，当d_count为正值说明目录项处于被使用状态。当d_count=0时表示该目录项是一个未被使用的目录项， 但其d_inode指针仍然指向相关的的索引节点。该目录项仍然包含有效的信息，只是当前没有人引用他。d_count=NULL表示负（negative）状态，与目录项相关的inode对象不复存在（相应的磁盘索引节点可能已经被删除），dentry对象的d_inode 指针为NULL。但这种dentry对象仍然保存在dcache中，以便后续对同一文件名的查找能够快速完成。这种dentry对象在回收内存时将首先被释放。
4> d_subdirs：如果当前目录项是一个目录，那么该目录下所有的子目录形成一个链表。该字段是这个链表的表头；
d_child：如果当前目录项是一个目录，那么该目录项通过这个字段加入到父目录的d_subdirs链表当中。这个字段中的next和prev指针分别 指向父目录中的另外两个子目录；
d_alias：一个inode可能对应多个目录项，所有的目录项形成一个链表。inode结构中的i_dentry即为这个链表的头结点。当前目录项以这个字段处于i_dentry链表中。该字段中的prev和next指针分别指向与该目录项同inode的其他两个（如果有的话）目录项
3.dentry和inode的区别：
　inode（可理解为ext2 inode）对应于物理磁盘上的具体对象，dentry是一个内存实体，其中的d_inode成员指向对应的inode。也就是说，一个inode可以在运行的时候链接多个dentry，而d_count记录了这个链接的数量。
4.dentry与dentry_cache
dentry_cache简称dcache，中文名称是目录项高速缓存，是Linux为了提高目录项对象的处理效率而设计的。它主要由两个数据结构组成：
1>哈希链表dentry_hashtable：dcache中的所有dentry对象都通过d_hash指针域链到相应的dentry哈希链表中。
2>未使用的dentry对象链表dentry_unused：dcache中所有处于unused状态和negative状态的dentry对象都通过其d_lru指针域链入dentry_unused链表中。该链表也称为LRU链表。
目录项高速缓存dcache是索引节点缓存icache的主控器（master），也即 dcache中的dentry对象控制着icache中的inode对象的生命期转换。无论何时，只要一个目录项对象存在于dcache中（非 negative状态），则相应的inode就将总是存在，因为 inode的引用计数i_count总是大于0。当dcache中的一个dentry被释放时，针对相应inode对象的iput()方法就会被调用。
5对目录项进行操作的一组函数叫目录项操作表,由dentry_operation结构描述。它可以在 include/linux/dcache.h 中查到
134struct dentry_operations {
135 int (*d_revalidate)(struct dentry *, struct nameidata *);
136 int (*d_hash) (struct dentry *, struct qstr *);
137 int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
138 int (*d_delete)(struct dentry *);
139 void (*d_release)(struct dentry *);
140 void (*d_iput)(struct dentry *, struct inode *);
141 char *(*d_dname)(struct dentry *, char *, int);
142}；
a.int d_reavlidate(struct dentry *dentry ,int flags) 该函数判断目录对象是否有效。VFS准备从dcache中使用一个目录项时，会调用该函数.
b.int d_hash(struct dentry *dentry ,struct qstr *name)：该目录生成散列值，当目录项要加入到散列表时，VFS要调用此函数。
c.int d_compare( struct dentry *dentry, struct qstr *name1, struct qstr *name2) 该函数来比较name1和name2这两个文件名。使用该函数要加dcache_lock锁。
d.int d_delete(struct dentry *dentry):当d_count=0时，VFS调用次函数。使用该函数要叫 dcache_lock锁。
e.void d_release(struct dentry *dentry):当该目录对象将要被释放时，VFS调用该函数。
f.void d_iput(struct dentry *dentry,struct inode *inode)当一个目录项丢失了其索引节点时，VFS就掉用该函数。
二．VFS中的文件对象
1.文件对象表示进程已经打开的文件 在内存中的表示，该对象不是物理上的文件。它是由相应的open()系统调用创建，由close()系统调用销毁。多个进程可以打开和操作同一个文件，所以同一个文件也可能存在多个对应的文件对象。
2一个文件对应的文件对象不是唯一的，但对应的索引节点和超级块对象是唯一的。
3.file结构中保存了文件位置，此外，还把指向该文件索引节点的指针也放在其中。file结构形成一个双链表，称为系统打开文件表 。它的定义在 include/linux/fs.h 中可以看到
909struct file {
910 /*
911 * fu_list becomes invalid after file_free is called and queued via
912 * fu_rcuhead for RCU freeing
913 */
914 union {
915 struct list_head fu_list; //每个文件系统中被打开的文件都会形成一个双链表
916 struct rcu_head fu_rcuhead;
917 } f_u;
918 struct path f_path;
919#define f_dentry f_path.dentry // 与该文件对应的dentry
920#define f_vfsmnt f_path.mnt
921 const struct file_operations *f_op; //指向文件操作表的指针
922 spinlock_t f_lock; /* f_ep_links, f_flags, no IRQ */
923#ifdef CONFIG_SMP
924 int f_sb_list_cpu;
925#endif
926 atomic_long_t f_count; //文件对象的使用计数
927 unsigned int f_flags; //打开文件时所指定的标志
928 fmode_t f_mode; //文件的访问模式
929 loff_t f_pos; //文件当前的位移量
930 struct fown_struct f_owner
931 const struct cred *f_cred;
932 struct file_ra_state f_ra; //预读状态
933
934 u64 f_version; //版本号
935#ifdef CONFIG_SECURITY
936 void *f_security; //安全模块
937#endif
938 /* needed for tty driver, and maybe others */
939 void *private_data; //tty设备hook
940
941#ifdef CONFIG_EPOLL
942 /* Used by fs/eventpoll.c to link all the hooks to this file */
943 struct list_head f_ep_links;
944#endif /* #ifdef CONFIG_EPOLL */
945 struct address_space *f_mapping; //页缓存映射
946#ifdef CONFIG_DEBUG_WRITECOUNT
947 unsigned long f_mnt_write_state;
948#endif
949};
1>文件对象实际上没有对应的磁盘数据，所以在结构体中没有代表其对象是否为脏，是否需要写回磁盘的标志。文件对象 通过f_path.dentry指针指向相关的目录项对象。目录项会指向相关的索引节点，索引节点会记录文件是否是脏的。
2>fu_list：每个文件系统中以被打开的文件都会形成一个双联表，这个双联表的头结点存放在超级块的s_files字段中。该字段的prev和next指针分别指向在链表中与当前文件结构体相邻的前后两个元素.

Tiger-John说明：

file结构中主要保存了文件位置，此外还把指向该文件索引节点的指针也放在其中。---》有人就问了，问什么不直接把文件位置存放在索引节点中呢？

因为：Linux中的文件是能够共享的，假如把文件位置存放在索引节点中，当有两个或更多个进程同时打开一个文件时，它们将去访问同一个索引节点，那么一个进程的lseek操作将影响到另一个进程的读操作，这显然是致命的错误。

4>对文件进行操作的一组函数叫文件操作表，由file_operations结构定义：可以在include/linux/fs.h 中查看
1488struct file_operations {
1489 struct module *owner;
1490 loff_t (*llseek) (struct file *, loff_t, int);
1491 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
1492 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
1493 ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
1494 ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
1495 int (*readdir) (struct file *, void *, filldir_t);
1496 unsigned int (*poll) (struct file *, struct poll_table_struct *);
1497 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
1498 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
1499 int (*mmap) (struct file *, struct vm_area_struct *);
1500 int (*open) (struct inode *, struct file *);
1501 int (*flush) (struct file *, fl_owner_t id);
1502 int (*release) (struct inode *, struct file *);
1503 int (*fsync) (struct file *, int datasync);
1504 int (*aio_fsync) (struct kiocb *, int datasync);
1505 int (*fasync) (int, struct file *, int);
1506 int (*lock) (struct file *, int, struct file_lock *);
1507 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
1508 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
1509 int (*check_flags)(int);
1510 int (*flock) (struct file *, int, struct file_lock *);
1511 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
1512 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
1513 int (*setlease)(struct file *, long, struct file_lock **);
1514};
owner：用于指定拥有这个文件操作结构体的模块，通常取THIS_MODULE；
llseek：用于设置文件的偏移量。第一个参数指明要操作的文件，第二个参数为偏移量，第三个参数为开始偏移的位置（可取SEEK_SET,SEEK_CUR和SEEK_END之一）。
read：从文件中读数据。第一个参数为源文件，第二个参数为目的字符串，第三个参数指明欲读数据的总字节数，第四个参数指明从源文件的某个偏移量处开始读数据。由系统调用read()调用；
write：往文件里写数据。第一个参数为目的文件，第二个参数源字符串，第三个参数指明欲写数据的总字节数，第四个参数指明从目的文件的某个偏移量出开始写数据。由系统调用write()调用；
mmap：将指定文件映射到指定的地址空间上。由系统调用mmap()调用；
open：打开指定文件，并且将这个文件和指定的索引结点关联起来。由系统调用open()调用；
release：释放以打开的文件，当打开文件的引用计数（f_count）为0时，该函数被调用；
fsync()：文件在缓冲的数据写回磁盘
3.用户打开文件表
系统中的每一个进程都有自己的一组打开的文件 ，像根文件系统，当前目工作目录，安装点等。有四个数据结构将VFS层和系统的进程紧密联系在一起，它们分别是：files_struct,fs_struct， file_system_type 和namespace结构体。

我们先看两个图：

此图来自陈莉君老师 博客，版权归属于陈莉君老师。
1.>文 件描述符是用来描述打开的文件的。每个进程用一个files_struct结构来记录文件描述符的使用情况，这个结构称为用户打开文件表。它是进程的私有数据。
a.files_struct 结构体定义在文件 include/linux/fdtable.h该结构体由进程描述符中的files 域指向。所有与每个进程(per-process)相关的信息如打开的文件及文件描述符都包含在其中。
44struct files_struct {
45 /*
46 * read mostly part
47 */
48 atomic_t count; //共享该表的进程数
49 struct fdtable *fdt;
50 struct fdtable fdtab; //定义了文件的一些属性
51 /*
52 * written part on a separate cache line in SMP
53 */
54 spinlock_t file_lock ____cacheline_aligned_in_smp;
55 int next_fd; //下一个文件描述符
56 struct embedded_fd_set close_on_exec_init; //*exec()关闭的文件描述符
57 struct embedded_fd_set open_fds_init; //文件描述符的初始集合
58 struct file * fd_array[NR_OPEN_DEFAULT]; //默认的文件对象数组
59};
a.看看 struct fdtable结构：
32struct fdtable {
33 unsigned int max_fds; //文件对象的上限
34 struct file ** fd; //全部文件对象数组
35 fd_set *close_on_exec; //*exec（）关闭的文件描述符
36 fd_set *open_fds; //指向打开文件的描述符
37 struct rcu_head rcu;
38 struct fdtable *next; //指向该链表的下一个对象
39};
40
b.fd数组指针指向已打开的文件对象链表，默认情况下，指向fd_arry数组。因为NR_OPEN_DEFAULT等于32，所以该数组可以容纳32个文件对象。如果一个进程所打开的文件对象超过32个。内核将分配一个新数组，并且将fd指向它。

c.对于在fd数组中有入口地址的每个文件来说，数组的索引就是文件描述符。通常，数组的第一个元素（索引为0）表示进程的标准输入文件，数组的第二个元素（索引为1）是进程的标准输出文件，数组的第三个元素(索引为2)是进程的标准错误文件）
2.>fs_struct 结构
a.fs_struct 结构描述进程与文件系统的关系
b.我们来深入分析其代码，它的定义在 include/linux/fs_struct.h,
6struct fs_struct {
7 int users;
8 spinlock_t lock; //保护该结构体的锁
9 int umask; //默认的文件访问权限
10 int in_exec;
11 struct path root, pwd;
12};
看一下struct path 结构的定义 ：
7struct path {
8 struct vfsmount *mnt;
9 struct dentry *dentry;
10}
可以看到struct path 封装了vfsmount 和dentry;，所以struct path root,pwd包含了当前进程的当前工作目录和根目录以及根目录安装点对象和pwd安装点对象。

3>file_system_type结构体

在Linux中，用file_system_type来描述各种特定文件系统类型，比如ext3。也就是说Linux支持的所有文件系统类型都分别唯一的对应一个file_system_type结构

a.它的定义在 include/linux/fs.h中。

1736struct file_system_type {
1737 const char *name; //文件系统的类型名
1738 int fs_flags; //文件系统类型标志
1739 int (*get_sb) (struct file_system_type *, int, //文件系统读入其超级块的函数指针
1740 const char *, void *, struct vfsmount *);
1741 void (*kill_sb) (struct super_block *); //该函数用来终止访问超级块
1742 struct module *owner; //通常设置为宏THIS_MODLUE,用以确定是否把文件系统作为模块安装
1743 struct file_system_type * next;
1744 struct list_head fs_supers;
1745
1746 struct lock_class_key s_lock_key;
1747 struct lock_class_key s_umount_key;
1748 struct lock_class_key s_vfs_rename_key;
1749
1750 struct lock_class_key i_lock_key;
1751 struct lock_class_key i_mutex_key;
1752 struct lock_class_key i_mutex_dir_key;
1753 struct lock_class_key i_alloc_sem_key;
1754};

tiger-john说明：

1>name：文件系统的名字，不能为空；
2>get_sb：在安装文件系统时，调用此指针所指函数以在磁盘中获取超级块；
3>kill_sb：卸载文件文件系统时候，调用此指针所指函数以进行一些清理工作；
4>owner：如果一个文件系统以模块的形式加载到内核，则该字段用来说明哪个模块拥有这个结构。一般为THIS_MODULE；
5>next：所有的文件系统类型结构形成一个链表，该链表的头指针为全局变量file_systems（struct file_system_type *file_systems）。这个字段指向链表中下一个文件系统类型结构；
6>fs_supers：同一个文件系统类型下的所有超级块形成一个双联表，这个字段是这个双联表的头结点。超级块之间通过s_instances字段相互链接.

4>vfsmount结构体

a.当文件系统被实际安装时，将有一个vfsmount 结构体在安装点被创建。该结构体用来代表文件系统的实例即代表一个安装点。

b.vfsmount结构体被定义在 include/linux/mount.h中

36/*
37 * MNT_SHARED_MASK is the set of flags that should be cleared when a
38 * mount becomes shared. Currently, this is only the flag that says a

39 * mount cannot be bind mounted, since this is how we create a mount
40 * that shares events with another mount. If you add a new MNT_*
41 * flag, consider how it interacts with shared mounts.
42 */
43#define MNT_SHARED_MASK (MNT_UNBINDABLE)
44#define MNT_PROPAGATION_MASK (MNT_SHARED | MNT_UNBINDABLE)
45
46
47#define MNT_INTERNAL 0x4000
48
49struct vfsmount {
50 struct list_head mnt_hash; //散列表
51 struct vfsmount *mnt_parent; //指向上一层安转点的指针
52 struct dentry *mnt_mountpoint; //安装点的目录项
53 struct dentry *mnt_root; //安装树的根
54 struct super_block *mnt_sb; //指向超级块的指针
55 struct list_head mnt_mounts; //子链表
56 struct list_head mnt_child; / /通过mnt_child进行遍历
57 int mnt_flags; //安装标志
58 /* 4 bytes hole on 64bits arches without fsnotify */
59#ifdef CONFIG_FSNOTIFY
60 __u32 mnt_fsnotify_mask;
61 struct hlist_head mnt_fsnotify_marks;
62#endif
63 const char *mnt_devname; /* Name of device e.g. /dev/dsk/hda1 */
64 struct list_head mnt_list;
65 struct list_head mnt_expire ; /* link in fs-specific expiry list */
66 struct list_head mnt_share; /* circular list of shared mounts */
67 struct list_head mnt_slave_list;/* list of slave mounts */
68 struct list_head mnt_slave; /* slave list entry */
69 struct vfsmount *mnt_master; /* slave is on master->mnt_slave_list */
70 struct mnt_namespace *mnt_ns; /* containing namespace */
71 int mnt_id; /* mount identifier */
72 int mnt_group_id; /* peer group identifier */
73 /*
74 * We put mnt_count & mnt_expiry_mark at the end of struct vfsmount
75 * to let these frequently modified fields in a separate cache line
76 * (so that reads of mnt_flags wont ping-pong on SMP machines)
77 */
78 atomic_t mnt_count; //使用计数
79 int mnt_expiry_mark; /* true if marked for expiry */
80 int mnt_pinned;
81 int mnt_ghosts;
82#ifdef CONFIG_SMP
83 int __percpu *mnt_writers;
84#else
85 int mnt_writers;
86#endif
87};

a.vfsmount 结构还保存了在安装时指定的标志信息，该信息存储在mmt_flags中。

MNT_NOSUID:禁止该文件系统的可执行文件设置setuid和setgid标志

MNT_NODEV：禁止访问该文件系统上的设备文件

MNT_NOEXEC：禁止执行该文件系统上的可执行文件

Tiger-John说明：

在管理员安装一些不是很安全的移动设备时，这些标志很有用。

b.为了对系统中的所有安装点进行快速查找，内核把它们按哈希表来组织，mnt_hash就是形成哈希表的队列指针。
c.mnt_mountpoint是指向安装点dentry结构的指针。而dentry指针指向安装点所在目录树中根目录的dentry结构。
d.mnt_parent是指向上一层安装点的指针。如果当前的安装点没有上一层安装点（如根设备），则这个指针为NULL。同时，vfsmount结构中还有mnt_mounts和mnt_child两个队列头，只要上一层vfsmount结构存在，就把当前vfsmount结构中mnt_child链入上一层vfsmount结构的mnt_mounts队列中。这样就形成一颗设备安装的树结构，从一个vfsmount结构的mnt_mounts队列开始，可以找到所有直接或间接安装在这个安装点上的其他设备。如图8.2。
e.mnt_sb指向所安装设备的超级块结构super_block。
f.mnt_list是指向vfsmount结构所形成链表的头指针。

我们来看个图：