Linux文件系统(七)---系统调用之open操作(一)

水深无声 2022-08-13 00:45 358阅读 0赞

(内核2.4.37)

一、

当我们打开一个文件的时候，需要获得文件的文件描述符(前面已经说过其实就是文件数组下标)，一般是通过函数open来完成，这个系统调用在<unistd.h>头文件中声明定义，我们看一下源码：

530 static inline long open(const char * name, int mode, int flags)
    531 {
    532         return sys_open(name, mode, flags);
    533 }

Ps：对于这些参数一般我们都很熟悉，经常使用，这里顺便提出记忆一下：

**mode**：参数可选：

32 #define S_IRWXU 00700     文件所有者可读可写可执行
     33 #define S_IRUSR 00400     文件所有者可读
     34 #define S_IWUSR 00200     文件所有者可写
     35 #define S_IXUSR 00100     文件所有者可执行
     36 
     37 #define S_IRWXG 00070     文件用户组可写可读可执行
     38 #define S_IRGRP 00040     文件用户组可读
     39 #define S_IWGRP 00020     文件用户组可写
     40 #define S_IXGRP 00010     文件用户组可执行
     41 
     42 #define S_IRWXO 00007     其他用户可写可读可执行
     43 #define S_IROTH 00004     其他用户可读
     44 #define S_IWOTH 00002     其他用户可写
     45 #define S_IXOTH 00001     其他用户可执行

**flags**：在fcntl.h中定义

7 #define O_RDONLY             00
      8 #define O_WRONLY             01
      9 #define O_RDWR               02
     10 #define O_CREAT            0100 /* not fcntl */
     11 #define O_EXCL             0200 /* not fcntl */
     12 #define O_NOCTTY           0400 /* not fcntl */
     13 #define O_TRUNC           01000 /* not fcntl */
     14 #define O_APPEND          02000
     15 #define O_NONBLOCK        04000
     16 #define O_NDELAY        O_NONBLOCK
     17 #define O_SYNC           010000
     18 #define FASYNC           020000 /* fcntl, for BSD compatibility */
     19 #define O_DIRECT         040000 /* direct disk access hint */
     20 #define O_LARGEFILE     0100000
     21 #define O_DIRECTORY     0200000 /* must be a directory */
     22 #define O_NOFOLLOW      0400000 /* don't follow links */

O\_RDONLY          以只读方式打开文件  
O\_WRONLY         以只写方式打开文件  
O\_RDWR              以读和写的方式打开文件  
上面三个只能选择一个，下面的可以合理的任意组合：  
O\_CREAT             打开文件，如果文件不存在则建立文件  
O\_EXCL                如果已经置O\_CREAT且文件存在，则强制open()失败  
O\_TRUNC             将文件的长度截为0  
O\_APPEND           强制write()从文件尾开始  
对于终端文件，上面四个是无效，提供了两个新的标志：  
O\_NOCTTY           停止这个终端作为控制终端  
O\_NONBLOCK      使open()、read()、write()不被阻塞。

我们可以看到，里面实际调用的是sys\_open这个系统调用，其实想想也很正常，对于我的一个系统而言，可以存在很多组不同的文件系统，对于不同的文件系统，打开文件的方式肯定是不一样的，所有内核需要根据具体的文件系统的类型去调用不同的函数进行执行。现在看看sys\_open函数(fs/open.c中)：

800 asmlinkage long sys_open(const char * filename, int flags, int mode)
    801 {
    802         char * tmp;
    803         int fd, error;
    804 
    805 #if BITS_PER_LONG != 32
    806         flags |= O_LARGEFILE;
    807 #endif
    808         tmp = getname(filename);   /* 1 */
    809         fd = PTR_ERR(tmp);
    810         if (!IS_ERR(tmp)) {
    811                 fd = get_unused_fd();  /* 2 */
    812                 if (fd >= 0) {
    813                         struct file *f = filp_open(tmp, flags, mode); /* 3 */
    814                         error = PTR_ERR(f);
    815                         if (IS_ERR(f))
    816                                 goto out_error;
    817                         fd_install(fd, f);    /* 4 */
    818                 }
    819 out:
    820                 putname(tmp);
    821         }
    822         return fd;
    823 
    824 out_error:
    825         put_unused_fd(fd);
    826         fd = error;
    827         goto out;
    828 }

主要看上面注释表示的四大步骤/\* 1 \*/  /\* 2 \*/  /\* 3 \*/  /\* 4 \*/

**/\* 1 \*/**：这步是一个辅助步骤，将filename从用户态拷贝到内核态变量中。基本步骤涉及一下几个函数：

125 char * getname(const char * filename)
 126 {
 127 char *tmp, *result;
 128 
 129 result = ERR_PTR(-ENOMEM);
 130 tmp = __getname(); /* 这玩意吧其实是分配内核中空间用户装name */
 131 if (tmp) {
 132 int retval = do_getname(filename, tmp); /* 其实就是将filename拷贝到tmp中 */
 133 
 134 result = tmp;
 135 if (retval < 0) {
 136 putname(tmp);
 137 result = ERR_PTR(retval);
 138 }
 139 }
 140 return result;
 141 }

看一下\_\_getname()函数：

1099 #define __getname()     kmem_cache_alloc(names_cachep, SLAB_KERNEL)

就是在内核的slab空间中分配能够容纳name的空间~~~

看一下do\_getname()函数：

104 static inline int do_getname(const char *filename, char *page)
 105 {
 106 int retval;
 107 unsigned long len = PATH_MAX;
 108 
 109 if ((unsigned long) filename >= TASK_SIZE) {
 110 if (!segment_eq(get_fs(), KERNEL_DS))
 111 return -EFAULT;
 112 } else if (TASK_SIZE - (unsigned long) filename < PATH_MAX)
 113 len = TASK_SIZE - (unsigned long) filename;
 114 
 115 retval = strncpy_from_user((char *)page, filename, len);/* 核心的一个步骤，其实就是将filename拷贝到刚刚在内核中分配的空间中 */
 116 if (retval > 0) {
 117 if (retval < len)
 118 return 0;
 119 return -ENAMETOOLONG;
 120 } else if (!retval)
 121 retval = -ENOENT;
 122 return retval;
 123 }

**/\* 2 \*/**：这一步是需要找到一个没有使用的文件描述符fd

看一下这个函数get\_unused\_fd：看这个链接：[get\_unused\_fd][get_unused_fd]

**/\* 3 \*/**：再回到上面看/\* 3 \*/步骤，到现在为止，我们已经找到了一个可用的文件描述符fd了，然后我们要做的就是打开指定文件，然后将这个fd和打开的文件关联即可，/\* 3 \*/步骤就是打开我们指定的文件！

下面会涉及到名字结构nameidata，所以先看看这个结构体：

700 struct nameidata {
    701         struct dentry *dentry;   /* 当前目录项对象 */
    702         struct vfsmount *mnt;    /* 已安装的文件系统挂载点 */
    703         struct qstr last;        /* 路径名称最后一部分 */
    704         unsigned int flags;      /* 查询标识 */
    705         int last_type;           /* 路径名称最后一部分类型 */
    706 };

看这个函数filp\_open：

644 /*
    645  * Note that while the flag value (low two bits) for sys_open means:
    646  *      00 - read-only
    647  *      01 - write-only
    648  *      10 - read-write
    649  *      11 - special
    650  * it is changed into
    651  *      00 - no permissions needed
    652  *      01 - read-permission
    653  *      10 - write-permission
    654  *      11 - read-write
    655  * for the internal routines (ie open_namei()/follow_link() etc). 00 is
    656  * used by symlinks.
    657  */
    658 struct file *filp_open(const char * filename, int flags, int mode)
    659 {
    660         int namei_flags, error;
    661         struct nameidata nd;
    662 
    663         namei_flags = flags;
    664         if ((namei_flags+1) & O_ACCMODE)
    665                 namei_flags++;
    666         if (namei_flags & O_TRUNC)
    667                 namei_flags |= 2;
    668         /* 根据文件名打开文件 */
    669         error = open_namei(filename, namei_flags, mode, &nd);
    670         if (!error)   /* 下面打开这个文件，这个函数返回的是file结构体指针！！！ */
    671                 return dentry_open(nd.dentry, nd.mnt, flags);
    672 
    673         return ERR_PTR(error);
    674 }

这个函数比较复杂，请看这个链接：[open\_namei][open_namei]

回头再看这个函数，dentry\_open：这个函数返回的file结构体指针：

676 struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags)
 677 {
 678 struct file * f;
 679 struct inode *inode;
 680 static LIST_HEAD(kill_list);
 681 int error;
 682 
 683 error = -ENFILE;
 684 f = get_empty_filp(); /* 得到一个空的file结构体，如果出错或者内存不足，返回1error */
 685 if (!f)
 686 goto cleanup_dentry;
 687 f->f_flags = flags; /* 一些赋值操作 */
 688 f->f_mode = (flags+1) & O_ACCMODE;
 689 inode = dentry->d_inode; /* 获得文件inode */
 690 if (f->f_mode & FMODE_WRITE) {
 691 error = get_write_access(inode);
 692 if (error)
 693 goto cleanup_file;
 694 }
 695 /* 一些赋值操作 */
 696 f->f_dentry = dentry; /* 目录项 */
 697 f->f_vfsmnt = mnt; /* 挂载点 */
 698 f->f_pos = 0; /* 文件相对开头偏移 */
 699 f->f_reada = 0; /* 预读标志 */
 700 f->f_op = fops_get(inode->i_fop); /* 文件操作函数 */
 701 file_move(f, &inode->i_sb->s_files);/* 将新建的file链接进入inode对应的超级块的file链表中 */
 702 
 703 /* preallocate kiobuf for O_DIRECT */
 704 f->f_iobuf = NULL;
 705 f->f_iobuf_lock = 0;
 706 if (f->f_flags & O_DIRECT) {
 707 error = alloc_kiovec(1, &f->f_iobuf); /* 分配io buffer */
 708 if (error)
 709 goto cleanup_all;
 710 }
 711 	 /* 下面尝试打开文件，保证能够正常打开这个文件 */
 712 if (f->f_op && f->f_op->open) { 
 713 error = f->f_op->open(inode,f);
 714 if (error)
 715 goto cleanup_all;
 716 }
 717 f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
 718 
 719 return f; /* 返回创建好的file */
 720 /* 下面都是出错处理 */
 721 cleanup_all:
 722 if (f->f_iobuf)
 723 free_kiovec(1, &f->f_iobuf);
 724 fops_put(f->f_op);
 725 if (f->f_mode & FMODE_WRITE)
 726 put_write_access(inode);
 727 file_move(f, &kill_list); /* out of the way.. */
 728 f->f_dentry = NULL;
 729 f->f_vfsmnt = NULL;
 730 cleanup_file:
 731 put_filp(f);
 732 cleanup_dentry:
 733 dput(dentry);
 734 mntput(mnt);
 735 return ERR_PTR(error);
 736 }
 737

看一下这个函数get\_empty\_filp，得到一个空的file结构体：

26 /* Find an unused file structure and return a pointer to it.
 27 * Returns NULL, if there are no more free file structures or
 28 * we run out of memory.
 29 *
 30 * SMP-safe.
 31 */
 32 struct file * get_empty_filp(void)
 33 {
 34 static int old_max = 0;
 35 struct file * f;
 36 
 37 file_list_lock();
 38 if (files_stat.nr_free_files > NR_RESERVED_FILES) { /* 如果允许打开的数量已经超过系统允许的 */
 39 used_one:
 40 f = list_entry(free_list.next, struct file, f_list); /* 在free_list中删除一个，留下了给新的file使用 */
 41 list_del(&f->f_list);
 42 files_stat.nr_free_files--;
 43 new_one: /* 下面创建一个新的file结构体 */
 44 memset(f, 0, sizeof(*f));
 45 atomic_set(&f->f_count,1);
 46 f->f_version = ++event;
 47 f->f_uid = current->fsuid;
 48 f->f_gid = current->fsgid;
 49 f->f_maxcount = INT_MAX;
 50 list_add(&f->f_list, &anon_list);
 51 file_list_unlock();
 52 return f; /* 返回file */
 53 }
 54 /*
 55 * Use a reserved one if we're the superuser
 56 */
 57 if (files_stat.nr_free_files && !current->euid)
 58 goto used_one;
 59 /*
 60 * Allocate a new one if we're below the limit. 如果还可以创建file结构体，那么创建一个新的就OK
 61 */
 62 if (files_stat.nr_files < files_stat.max_files) {
 63 file_list_unlock();
 64 f = kmem_cache_alloc(filp_cachep, SLAB_KERNEL); /* 在slab中分配一个新的file缓存 */
 65 file_list_lock();
 66 if (f) {
 67 files_stat.nr_files++; /* 数量++ */
 68 goto new_one; /* 初始化这个新的值 */
 69 }
 70 /* Big problems... */
 71 printk(KERN_WARNING "VFS: filp allocation failed\n");
 72 
 73 } else if (files_stat.max_files > old_max) {
 74 printk(KERN_INFO "VFS: file-max limit %d reached\n", files_stat.max_files);
 75 old_max = files_stat.max_files;
 76 }
 77 file_list_unlock();
 78 return NULL;
 79 }

/\* 4 \*/：最后看一下fd\_install函数，这个函数比较简单，就是将之前申请的文件描述符fd和打开的文件file结构体关联起来：

74 /*
 75 * Install a file pointer in the fd array. 
 76 *
 77 * The VFS is full of places where we drop the files lock between
 78 * setting the open_fds bitmap and installing the file in the file
 79 * array. At any such point, we are vulnerable to a dup2() race
 80 * installing a file in the array before us. We need to detect this and
 81 * fput() the struct file we are about to overwrite in this case.
 82 *
 83 * It should never happen - if we allow dup2() do it, _really_ bad things
 84 * will follow.
 85 */
 86 
 87 void fd_install(unsigned int fd, struct file * file)
 88 {
 89 struct files_struct *files = current->files; /* 获得当前进程文件打开表 */
 90 
 91 write_lock(&files->file_lock);
 92 if (files->fd[fd]) /* 如果这个fd下已经存在文件了，那么error！ */
 93 BUG(); 
 94 files->fd[fd] = file;/* 关联这个fd和新打开的文件 */
 95 write_unlock(&files->file_lock);
 96 }

至此，文件open操作完成了~~~

[get_unused_fd]: http://blog.csdn.net/shanshanpt/article/details/39927301
[open_namei]: http://blog.csdn.net/shanshanpt/article/details/39927553