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结构所形成链表的头指针。

我们来看个图：