打开文件的内核源码分析

一、概要
   用户进程在能够读/写一个文件之前必须要先打开这个文件，从概念上说是一个进程与文件系统之间的一种有链接的通信，对于打开文件实质就是在进程和文件之间建立起连接，而“打开文件号”就是唯一的标识这个连接。在文件系统的处理当中，每当一个进程重复打开同一个文件时就建立起一个由file数据结构代表的独立的上下文。通常，一个file数据结构，即一个读/写文件的上下文，都是由一个“打开文件号”加以标识的。从上面可以看出，一个文件的打开与进程是有着紧密联系的。接下来就首先介绍进程中与文件有关的相关结构。
二、与进程有关的文件
（1）进程中与文件相关的结构
      1、首先是task_struct结构，每个进程都有一个task_struct结构的对象，该对象包含了进程处理的上下文。在这里只贴出与文件有关的部分如下：

点击(此处)折叠或打开

1. struct task_struct{
   
2.  ...........
   
3.     struct fs_struct *fs;
   
4.     struct file_struct *files;
   
5.  ...........
   
6. }

从上面进程中与文件有关的代码可以看出，在一个task_struct结构中与文件操作有关的结构之后两个即struct fs_struct结构对象和file_struct结构对象。下面分别讲解这两个对象的相关信息。
    2、fs_struct结构。

点击(此处)折叠或打开

1. struct fs_struct {
   
2.         int users;  
   
3.         rwlock_t lock;
   
4.         int umask;
   
5.         int in_exec;
   
6.         struct path root, pwd;  //其中的root对象是用来存放根目录的相关信息，比如根目录的目录项等而pwd存放的是当前目录的相关信息。主要是当前目录的目录项对象。这两个对象主要是在文件路径名解析的时候用于查找文件开始的目录项。如果路径名查找是绝对路径查找，那么就会根据root->dentry来开始查找。而如果是相对路径查找就会根据pwd->dentry来进行查找。
   
7. };

其中涉及到的path结构如下：

点击(此处)折叠或打开

1. struct path {
   
2.         struct vfsmount *mnt;//只有当相应的目录为挂载目录的时候这个变量才存放一些有关挂载的信息
   
3.         struct dentry *dentry;//表示目录的目录项对象结构。
   
4. }

    3、file_struct对象

点击(此处)折叠或打开

1. struct files_struct { 
   
2.     atomic_t count; //自动增量 
   
3.     struct fdtable *fdt; 
   
4.     struct fdtable fdtab; 
   
5.     fd_set close_on_exec_init; //执行exec时
   
6. 需要关闭的文件描述符初值集合 
   
7.     fd_set open_fds_init; //当前打开文件
   
8. 的文件描述符屏蔽字 
   
9.     struct file * fd_array[NR_OPEN_DEFAULT]; 
   
10.     spinlock_t file_lock; 
11. };

这个数据结构中最主要的就是一个file结构指针数组fd_array[]，该数组的大小事固定的，即32，其下标为打开文件号即为文件描述符。
这个结构中两个重要的结构即为文件描述符管理结构fdtable与file对象。其中fdtable对象的代码如下：

点击(此处)折叠或打开

1. struct fdtable {
   
2.  unsigned int max_fds; //可以代开的最大文件数
   
3.  int max_fdset; //位图的最大长度
   
4.  int next_fd; //下一个可用的fd
   
5.  struct file ** fd; /* current fd array 指向files_struct的fd_array */
   
6.  fd_set *close_on_exec;
   
7.  fd_set *open_fds; //打开的文件标记，比如第2位为1，则打开了2号文件.这个字段和close_on_exec字段都是一个位图的形式来进行表示的
   
8.  struct rcu_head rcu;
   
9.  struct files_struct *free_files;
   
10.  struct fdtable *next;
    
11. }

files_struct结构：该结构保存了该进程中打开的所有的文件得信息。比如文件描述符管理表、打开的文件数组等等都是表示的是该进程打开的文件的详细信息。
files_struct结构与fdtable结构的结构体如下

对于文件结构体，其代表的是一个打开的文件，系统中的每个打开的文件在内核空间都有一个关联的struct file。它有内核在打开文件时创建。同时在文件关闭之后，内核释放这个数据结构。
file对象的代码如下：

点击(此处)折叠或打开

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;
   
9.         } f_u;
   
10.         struct path f_path;//该文件所对应的path结构，主要是存放的是该文件的目录项对象结构。
    
11. #define f_dentry f_path.dentry
    
12. #define f_vfsmnt f_path.mnt
    
13.         const struct file_operations *f_op;//文件操作的指针，如果打开的文件存在那么这个指针是通过dentry里的对象来设置。而如果打开的文件不存在需要新建立，那么这个指针是通过父目录的dentry中的对象来设置。
    
14. //以下的信息主要是通过文件的inode节点中的信息进行设置的     
15.    atomic_t f_count;
    
16.         unsigned int f_flags;
    
17.         mode_t f_mode;
    
18.         loff_t f_pos; //这个字段是很重要的，表示的是文件中的当前读写位置，当使用系统调用lseek的时候就是改变的这个字段的值
    
19.         struct fown_struct f_owner;
    
20.         unsigned int f_uid, f_gid;
    
21.         struct file_ra_state f_ra;
    
22.         unsigned long f_version;
    
23. #ifdef CONFIG_SECURITY
    
24.         void *f_security;
    
25. #endif
    
26.         /* needed for tty driver, and maybe others */
    
27.         void *private_data;
    
28. #ifdef CONFIG_EPOLL
    
29.         /* Used by fs/eventpoll.c to link all the hooks to this file */
    
30.         struct list_head f_ep_links;
    
31.         spinlock_t f_ep_lock;
    
32. #endif /* #ifdef CONFIG_EPOLL */
    
33.         struct address_space *f_mapping;//这个指针是想的是地址空间的对象的指针，主要是用于在page cache中进行查找操作。
    
34. };

   （2）进程中与文件相关的各个结构的联系
以上就是进程环境中与文件操作有关的所有的结构了，为了更好的理解结构之间的联系，下面给出各个结构之间的结构图。


三、open函数的内核追踪过程
   打开文件的系统调用是open（），这个系统调用在物理文件系统层是通过do_sys_open()函数来实现的，其代码在/fs/open.c这个文件中。其具体的代码如下：

点击(此处)折叠或打开

1. long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
   
2.  {
   
3.          struct open_flags op;
   
4.          int lookup = build_open_flags(flags, mode, &op);
   
5.          struct filename *tmp = getname(filename);//将从用户空间传入的路径名复制到内核空间
   
6.          int fd = PTR_ERR(tmp);
   
7.  
   
8.          if (!IS_ERR(tmp)) {
   
9.                  fd = get_unused_fd_flags(flags);//获取一个没有使用的文件描述符fd
   
10.                  if (fd >= 0) {
    
11.                          struct file *f = do_filp_open(dfd, tmp, &op, lookup);//建立file对象
    
12.                         if (IS_ERR(f)) {
    
13.                                  put_unused_fd(fd);
    
14.                                  fd = PTR_ERR(f);
    
15.                          } else {
    
16.                                  fsnotify_open(f);
    
17.                                  fd_install(fd, f);//将current->files_struct和文件对象进行关联
    
18.                          }
    
19.                  }
    
20.                  putname(tmp);
    
21.          }
    
22.          return fd;
    
23.  }

从上面的代码可以看出open（）系统调用的主要是由以下的函数来实现的：
（1）getname（）函数： 将从用户空间传入的路径名复制到内核空间。
（2） get_unused_fd_flags ( )函数： 获取一个没有使用的文件描述符fd ，这个函数主要是操作fdtable结构中的相关字段
（3） do_filp_open ( )函数： 建立file对象,并把file对象插入到文件系统超级块的s_files字段所指向的打开文件的链表。
（4）fd_install()函数： 将current->files_struct和文件对象进行关联。
下面就分别来讲解这些函数的具体操作
（1）getname（）函数：这个函数在这里就不追踪了。比较麻烦。
（2）get_unused_fd_flags()函数：这个函数主要是通过内核函数__alloc_fd()函数来实现的该函数的代码如下：

点击(此处)折叠或打开

1. /*
   
2.   * allocate a file descriptor, mark it busy.
   
3.   *功能：分配一个文件描述符，并把它标记为忙的状态
4.   *其中的files参数为：当前进程中的current->files变量
5.   */
   
6. int __alloc_fd(struct files_struct *files,
   
7.                unsigned start, unsigned end, unsigned flags)
   
8.  {
   
9.          unsigned int fd;
   
10.          int error;
    
11.          struct fdtable *fdt;//文件描述符管理结构
    
12.  
    
13.          spin_lock(&files->file_lock);
    
14.  repeat:
    
15.          fdt = files_fdtable(files);//指向files_struct结构中的fdtable指针
    
16.         fd = start;
    
17.          if (fd < files->next_fd)//首先判断fd是不是小于进程中下一个可用的fd，如果是则直接赋值下一个可用的fd给fd
    
18.                 fd = files->next_fd;
    
19.  
    
20.          if (fd < fdt->max_fds)
    
21.                  fd = find_next_zero_bit(fdt->open_fds, fdt->max_fds, fd);//将open_fds所指向的位图中的相应的为设置成1，表示这个打开的文件号已经不再空闲了。这个位图表示的是已经在使用中的打开文件号。同时还将指针close_on_exec所指向的位图中的相应的为清0，表示如果当前进程通过exec（）系统调用执行一个可执行程序的话无需将这个文件进行关闭。
    
22.  
    
23.          /*
    
24.           * N.B. For clone tasks sharing a files structure, this test
    
25.           * will limit the total number of files that can be opened.
    
26.           */
    
27.          error = -EMFILE;
    
28.   if (fd >= end)
    
29.                  goto out;
    
30.  
    
31.          error = expand_files(files, fd);//如果所指向的fd超出了file结构指针数组的容量就通过该函数来扩充该数组的容量，并让指针fd指向新的数组。同时会使用expand_fdset来扩充位图的容量，并使open_fds指针也指向新的位图。
    
32.          if (error < 0)
    
33.                  goto out;
    
34.  
    
35.          /*
    
36.           * If we needed to expand the fs array we
    
37.   * might have blocked - try again.
    
38.           */
    
39.          if (error)
    
40.   goto repeat;
    
41.  
    
42.          if (start <= files->next_fd)
    
43.                  files->next_fd = fd + 1;
    
44.  
    
45.         __set_open_fd(fd, fdt);
    
46.          if (flags & O_CLOEXEC)
    
47.                  __set_close_on_exec(fd, fdt);
    
48.          else
    
49.                  __clear_close_on_exec(fd, fdt);
    
50.          error = fd;
    
51.  #if 1
    
52.          /* Sanity check */
    
53.          if (rcu_dereference_raw(fdt->fd[fd]) != NULL) {
    
54.   printk(KERN_WARNING "alloc_fd: slot %d not NULL!n", fd);
    
55.                  rcu_assign_pointer(fdt->fd[fd], NULL);
    
56.          }
    
57.  #endif
    
58. 
    
59.  out:
    
60.         spin_unlock(&files->file_lock);
    
61.          return error;
    
62.  }

这个函数主要是在文件描述符管理结构中把相应的下一个可用的fd所在的位置1，表示这个文件打开号是处于忙的状态，同时如果要打开的文件号大于文件数组的文件打开号的最大值，那么就进行扩容处理。主要涉及到的就是对open_fds位图中相应的位进行置1的处理和返回fd的位置。
（3） do_filp_open ( )函数，这个函数才是open系统调用中最主要的函数即主体函数，该函数的代码如下

点击(此处)折叠或打开

1. struct file *do_filp_open(int dfd, struct filename *pathname,
   
2.                 const struct open_flags *op, int flags)
   
3. {
   
4.         struct nameidata nd;
   
5.         struct file *filp;
   
6. 
   
7.         filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_RCU);
   
8.         if (unlikely(filp == ERR_PTR(-ECHILD)))
   
9.                 filp = path_openat(dfd, pathname, &nd, op, flags);
   
10.         if (unlikely(filp == ERR_PTR(-ESTALE)))
    
11.                 filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_REVAL);
    
12.         return filp;
    
13. }

其主要的函数为 path_openat（）函数，该函数的功能是：根据路径名找到相应的文件对应的dentry对象和inode对象，然后通过这两个对象来对file对象进行赋值。最终返回赋值好的file对象。其中用到了路径名解析中的知识，这块知识在后面会进一步详细的讲解，所以在这里就不着重讲了。
该函数的内核代码如下：

点击(此处)折叠或打开

1. static struct file *path_openat(int dfd, struct filename *pathname,
   
2.                 struct nameidata *nd, const struct open_flags *op, int flags)
   
3. {
   
4.         struct file *base = NULL;
   
5.         struct file *file;
   
6.         struct path path;
   
7.         int opened = 0;
   
8.         int error;
   
9. 
   
10.         file = get_empty_filp();//从内存中的空闲的file对象队列中，分配一个空闲的file对象出来
    
11.         if (IS_ERR(file))
    
12.                 return file;
    
13. 
    
14.         file->f_flags = op->open_flag;
    
15. 
    
16.         error = path_init(dfd, pathname->name, flags | LOOKUP_PARENT, nd, &base);//进行路劲查找，查找到路劲的开始目录的dentry对象。主要是通过current->fs中的值对nd进行一些赋值处理
    
17.         if (unlikely(error))
    
18.                 goto out;
    
19. 
    
20.  current->total_link_count = 0;
    
21.  error = link_path_walk(pathname->name, nd);//这个函数主要是完成路径名查找的后半段从开始目录到最终的文件父目录的查找过程。主要是通过路径分量名在内存中查找路径分量名对应的目录项对象。直到找到最终文件对应的父目录的目录项对象即dentry结构。（找到最终文件的父目录的目录项对象和inode节点对象）
    
22.         if (unlikely(error))
    
23.                goto out;
    
24. 
    
25.  error = do_last(nd, &path, file, op, &opened, pathname);//这个函数主要通过检查最终的文件是不是存在，如果存在直接找到该文件的dentry对象和inode对象。并对file对象进行赋值操作。如果要查找的文件不存在的时候，就会创建这个文件，创建文件的操作是通过vfs_create函数来实现的，在这里就不详细讲解这里面的知识了，这部分知识将留在后面进行讲解。（主要是判断文件是不是存在，然后进行一些列的处理）
26.         while (unlikely(error > 0)) { /* trailing symlink */
    
27.  struct path link = path;
    
28.                 void *cookie;
    
29.  if (!(nd->flags & LOOKUP_FOLLOW)) {
    
30.  path_put_conditional(&path, nd);
    
31.                         path_put(&nd->path);
    
32.  error = -ELOOP;
    
33.                        break;
    
34.  }
    
35.  error = may_follow_link(&link, nd);
    
36.                 if (unlikely(error))
    
37.  break;
    
38.                 nd->flags |= LOOKUP_PARENT;
    
39.  nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL);
    
40.  error = follow_link(&link, nd, &cookie);
    
41.  if (unlikely(error))
    
42.  break;
    
43.                 error = do_last(nd, &path, file, op, &opened, pathname);
    
44.                 put_link(nd, &link, cookie);
    
45.  }
    
46. out:
    
47.         if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT))
    
48.                 path_put(&nd->root);//这个函数的功能是释放dentry结构和mnt结构
    
49.        if (base)
    
50.  fput(base);
    
51.         if (!(opened & FILE_OPENED)) {
    
52.  BUG_ON(!error);
    
53.  put_filp(file);
    
54.  }
    
55.  if (unlikely(error)) {
    
56.  if (error == -EOPENSTALE) {
    
57.  if (flags & LOOKUP_RCU)
    
58.  error = -ECHILD;
    
59.  else
    
60.  error = -ESTALE;
    
61.  }
    
62.  file = ERR_PTR(error);
    
63.         }
    
64.  return file;
    
65. }
66. 当找到了目标文件的dentry结构和inode结构之后就对file对象进行相应的赋值，最后就可以进行返回了。

这里将看看当O_CREAT标志位为1的情况下，即当如果要找的目标文件不存在的时候不返回错误，而是创建一个新的文件。创建新的文件主要是通过函数vfs_create（）函数来实现，该函数主要是实现创建一个文件的功能。该函数的内核代码如下：

点击(此处)折叠或打开

1. int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
   
2.                 bool want_excl)
   
3. {
   
4.        int error = may_create(dir, dentry);
   
5.         if (error)
   
6.                 return error;
   
7. 
   
8.         if (!dir->i_op->create)
   
9.                 return -EACCES; /* shouldn't it be ENOSYS? */
   
10.         mode &= S_IALLUGO;
    
11.         mode |= S_IFREG;
    
12.         error = security_inode_create(dir, dentry, mode);
    
13.         if (error)
    
14.                 return error;
    
15.         error = dir->i_op->create(dir, dentry, mode, want_excl);
    
16.  if (!error)
    
17.                 fsnotify_create(dir, dentry);
    
18.         return error;
    
19. }

建立新文件的函数vfs_create()函数的详细细节在之后的博客中在进行跟踪，在这里只要知道这个函数是创建一个新文件就可以了。
（4）在回到 do_sys_open（）函数中来讲解fd_install()函数。通过上面的三个函数已经创建了file对象并且通过找到文件的dentry对象和inode对象对file对象进行了赋值操作。接下来的工作就是把刚创建的file对象与current->files_struct进行关联。其实就是把返回的文件对象file对象地址赋值给current->files->fd[fd].
fd_install（）函数主要是通过__fd_install()函数来实现的，所以下面贴出__fd_install()函数的代码如下：

点击(此处)折叠或打开

1. void __fd_install(struct files_struct *files, unsigned int fd,
   
2.                  struct file *file)
   
3.  {
   
4.          struct fdtable *fdt;
   
5.          spin_lock(&files->file_lock);
   
6.          fdt = files_fdtable(files);
   
7.          BUG_ON(fdt->fd[fd] != NULL);
   
8.         rcu_assign_pointer(fdt->fd[fd], file);//把file对象的地址赋值给current->files->fd[fd].这里在文件描述符管理表中的fd指针指向的就是current->files->fd[]数组
   
9.          spin_unlock(&files->file_lock);
   
10. }

四、总结

    打开文件做的工作总结：
   (1)把路径名从用户空间读取到内核空间。
  （2）在fdtable中找到一个没有使用的文件描述符，然后修改fdtable结构中的相应字段。
  （3）创建一个文件对象（file对象），然后通过路径名解析查找到目标文件的dentry结构和inode结构（如果要查        找的文件不存在则建立新的文件并创建该文件的dentry结构和inode结构），通过文件的dentry结构和inode结        构来对file对象进行赋值操作，并最终返回file对象的地址。
  （4）把建立的file对象的地址赋值给current->files->fd[fd]中。
  （5）返回fd即这个打开文件对应的文件描述符。