Linux VFS文件系统之打开(Open)文件 2010-02-28 23:16:53

 

分类： LINUX

------------------------------------------------

#纯属个人理解,如有问题敬请谅解!

#kernel version: 2.6.26

#Author: andy wang

-------------------------------------------------

一 : 概述

文件的打开读写操作是一项复杂的工作 , 本文只讨论 VFS层系统调用打开文件的实现 , 文件的打开操作流程大致是这样的 : 首先在当前进程的文件描述表 fdtale中分配一个空的文件描述符 fd , 然后在 filp_cachep中创建一个 file struct , 调用 do_path_lookup()找的文件的 inode ,取出 inode的文件操作方法 file_operations赋给 file struct ,并调用 f->f_op->open()执行打开的操作 . 最后根据根据文件描述符 fd将 file安装在当前进程文件描述表 fdtable对应的位置 .欧了 ,整个打开文件的流程大致就是这个样子的了 . 这样在以后读写文件操作时 , 只需要根据文件描述符 fd,就可以在当前进程的描述表中找到该文件的 file对象 ,然后调用 f->f_op操作方法对文件进行操作 .

二 : open的实现流程

先来看看我画的一个 VFS文件操作的 流程图吧 ,有了这个图再来看下面的 代码就要清晰的多了哦 ~~~~~~~ ..

从上面的图中我们可以看到,其实 VFS操作一个文件就是要找到该文件索引节点关联的文件操作方法.

下面就正式开始进入Open系统调用:

系统调用Open打开一个文件, kernel VFS层调用sys_open()->do_sys_open()执行打开文件.

下面看看 代码片段:

long do_sys_open(int dfd, const char __user *filename, int flags, int mode)

{

char *tmp = getname(filename); //文件路径名filename拷贝到内核空间

int fd = PTR_ERR(tmp);

if (!IS_ERR(tmp)) {

fd = get_unused_fd_flags(flags); //获取空的文件描述符fd

if (fd >= 0) { //文件描述符为非负数

struct file *f = do_filp_open(dfd, tmp, flags, mode); //分配并初始化file结构

if (IS_ERR(f)) {

put_unused_fd(fd); //释放fd

fd = PTR_ERR(f);

} else {

s fsnotify_open(f->f_path.dentry);

fd_install(fd, f); //安装file到当前进程描述表中

}

}

putname(tmp);

}

return fd; //返回文件描述符fd到用户空间.

}

首先拷贝文件路径名字到内核空间, 我们需要这个路径在 VFS中找到文件的dentry,然后取到inode指向的该文件的操作方法。接下来就是调用get_unused_fd_flags()在当前进程的文件描述表中取到未使用的文件描述符fd , 对于用户空间来说,文件描述符fd就像打开文件的一把钥匙;只要有了文件文件描述符fd ,我们就可以取出文件中的内容了.

接下来我们要看看打开的文件信息是如何与进程联系在一起的.

如下是do_filp_open() 代码片段:

struct file *do_filp_open(int dfd, const char *pathname,

int open_flag, int mode)

{

struct file *filp;

struct nameidata nd;

int acc_mode, error;

struct path path;

struct dentry *dir;

int count = 0;

int will_write;

int flag = open_to_namei_flags(open_flag);

acc_mode = ACC_MODE(flag);

/* O_TRUNC implies we need access checks for write permissions */

if (flag & O_TRUNC)

acc_mode |= MAY_WRITE;

/* Allow the LSM permission hook to distinguish append

access from general write access. */

if (flag & O_APPEND)

acc_mode |= MAY_APPEND;

if (!(flag & O_CREAT)) { //这是打开文件最简单的一种情况

error = path_lookup_open(dfd, pathname, lookup_flags(flag),

&nd, flag); //创建file,并查找文件,保存在nd中

if (error)

return ERR_PTR(error);

goto ok;

}

/*

* Create - we need to know the parent.

*/

error = path_lookup_create(dfd, pathname, LOOKUP_PARENT,

&nd, flag, mode); //文件不存在,首先需要创建文件

if (error)

return ERR_PTR(error);

…………….

ok:

/*

* Consider:

* 1. may_open() truncates a file

* 2. a rw->ro mount transition occurs

* 3. nameidata_to_filp() fails due to

* the ro mount.

* That would be inconsistent, and should

* be avoided. Taking this mnt write here

* ensures that (2) can not occur.

*/

will_write = open_will_write_to_fs(flag, nd.path.dentry->d_inode); //返回是否需要判断写权限

if (will_write) { //如果是普通文件或者目录文件

error = mnt_want_write(nd.path.mnt); //判断写权限

if (error)

goto exit;

}

error = may_open(&nd, acc_mode, flag);

if (error) {

if (will_write)

mnt_drop_write(nd.path.mnt);

goto exit;

}

filp = nameidata_to_filp(&nd, open_flag); //初始化file ,执行f-> f_op->open()

/*

* It is now safe to drop the mnt write

* because the filp has had a write taken

* on its behalf.

*/

if (will_write)

mnt_drop_write(nd.path.mnt);

return filp;

}

这个函数比较长,所以只是列出了部分 代码, 只讨论文件打开的一般情况.

我们首先来跟踪一下path_lookup_open()函数;

其调用关系为path_lookup_open()-> __path_lookup_intent_open() ,下面是__path_lookup_intent_open() 代码片段:

static int __path_lookup_intent_open(int dfd, const char *name,

unsigned int lookup_flags, struct nameidata *nd,

int open_flags, int create_mode)

{

struct file *filp = get_empty_filp(); //在filp_cachep中分配file

int err;

if (filp == NULL)

return -ENFILE;

nd->intent.open.file = filp;

nd->intent.open.flags = open_flags;

nd->intent.open.create_mode = create_mode;

err = do_path_lookup(dfd, name, lookup_flags|LOOKUP_OPEN, nd); //查找文件

if (IS_ERR(nd->intent.open.file)) {

if (err == 0) {

err = PTR_ERR(nd->intent.open.file);

path_put(&nd->path);

}

} else if (err != 0)

release_open_intent(nd);

return err;

}

这个函数比较简单, 它就是将分配的file和查找文件的信息都保存在nd中, do_path_lookup()查找路径已经在上篇文章中介绍过了。

现在我们再回到do_filp_ope()函数中, 在执行完path_lookup_open()函数后 , 信息都保存在了nd中了.然后执行goto ok; 调用函数open_will_write_to_fs()判断该文件所在文件系统是否需要进行写权限的判断, 特殊文件是不需要进行写权限判断的, 而目录和普通文件是需要判断所在文件系统写权限的.

下面这个函数nameidata_to_filp()是一个很重要的函数,因为这个函数将我们要操作目标文件的操作方法初始化给了filep ,这样文件索引节点inode的使命就完成了.

下面是这个函数的 代码片段:

struct file *nameidata_to_filp(struct nameidata *nd, int flags)

{

struct file *filp;

/* Pick up the filp from the open intent */

filp = nd->intent.open.file; //取得刚才建立的file结构

if (filp->f_path.dentry == NULL) //断断是否初始化该文件

filp = __dentry_open(nd->path.dentry, nd->path.mnt, flags, filp,

NULL);

else

path_put(&nd->path);

return filp;

}

继续跟踪__dentry_open()函数:

static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,

int flags, struct file *f,

int (*open)(struct inode *, struct file *))

{

struct inode *inode;

int error;

f->f_flags = flags;

f->f_mode = ((flags+1) & O_ACCMODE) | FMODE_LSEEK |

FMODE_PREAD | FMODE_PWRITE; //文件模式

inode = dentry->d_inode; //获取该文件的索引节点inode

if (f->f_mode & FMODE_WRITE) { //如果是可写模式 需要判断文件所在的文件系统可写？

error = __get_file_write_access(inode, mnt); // 特殊文件不需要判断哦

if (error)

goto cleanup_file;

if (!special_file(inode->i_mode))

file_take_write(f);

}

f->f_mapping = inode->i_mapping;

f->f_path.dentry = dentry; //初始化f_path指向的dentry

f->f_path.mnt = mnt; //初始化f_path指向的mnt

f->f_pos = 0; //读写位置指针

f->f_op = fops_get(inode->i_fop); //在inode中获取文件的操作方法

file_move(f, &inode->i_sb->s_files);

error = security_dentry_open(f);

if (error)

goto cleanup_all;

if (!open && f->f_op)

open = f->f_op->open;

if (open) {

error = open(inode, f); //就是在这里执行文件open操作了

if (error)

goto cleanup_all;

}

f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);

file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);

/* NB: we're sure to have correct a_ops only after f_op->open */

if (f->f_flags & O_DIRECT) {

if (!f->f_mapping->a_ops ||

((!f->f_mapping->a_ops->direct_IO) &&

(!f->f_mapping->a_ops->get_xip_mem))) {

fput(f);

f = ERR_PTR(-EINVAL);

}

}

return f;

……………..

}

将inode的信息初始化给file后,调用f->f_op->open 执行文件的open操作 ,我们就拿字符设备为例子:如果在注册字符设备时定义了文件的open函数的话,这个时候就会调用定义的open函数了. 到这里文件就已经打开了. 不过我们还需要把这个file struct保存在当前进程中,以便可以由fd在这个进程中找到这个file,然后才能执行文件的其它操作哦~~~~~~~~~~.

那么这个file是咋个安装在当前进程中的呢？这时我们就需要回到函数do_sys_open()中看看了, 其中有一个函数fd_install();它的作用就是将file安装在当前进程对应的文件描述表中.

代码如下:

void fd_install(unsigned int fd, struct file *file)

{

struct files_struct *files = current->files;

struct fdtable *fdt;

spin_lock(&files->file_lock);

fdt = files_fdtable(files);

BUG_ON(fdt->fd[fd] != NULL);

rcu_assign_pointer(fdt->fd[fd], file);

spin_unlock(&files->file_lock);

}

可见上面的 代码就是取出当前进程的文件描述表fstable,然后根据文件描述符fd的值把file对象安装在对应的当前进程的文件描述表中. 欧拉, VFS的Open工作就完了哦.

三: 小结

本文讨论了 VFS如何去打开一个文件,这些都只是第一步; 在后面的文章将继续分析 VFS读写文件是如何实现的. 当然了解完open的流程后, VFS的read,write操作的分析就会是水到渠成了