linux vfs open函数,Linux VFS 之 open系统调用(kernel 3.4)

linux version: 3.4.67

kernel 代码

fs/open.c

fs/namei.c

open命令调用关系

mount- > /fs/open.c/SYSCALL_DEFINE3(open, ....); -> do_sys_open->get_unused_fd_flags->

->do_filp_open->fd_install

根据调用关系对各函数注解

１、do_sys_open

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

{

struct open_flags op;

int lookup = build_open_flags(flags, mode, &op);

char *tmp = getname(filename);

int fd = PTR_ERR(tmp);

if (!IS_ERR(tmp)) {

fd = get_unused_fd_flags(flags);　　　//获取一个未使用的文件描述符，参考fs/file.c文件alloc_fd() ，后续仔细研究file.c文件。

if (fd >= 0) {

struct file *f = do_filp_open(dfd, tmp, &op, lookup);　 //直接调用path_openat打开文件，返回file文件对象。

if (IS_ERR(f)) {

put_unused_fd(fd);

fd = PTR_ERR(f);

} else {

fsnotify_open(f);

fd_install(fd, f);　　//file文件对象与当前进程current关联。fd作为file对象的索引，这样file与fd也一一对应。

}

}

putname(tmp);

}

return fd;  //返回文件描述符

}

２、path_openat

static struct file *path_openat(int dfd, const char *pathname,

struct nameidata *nd, const struct open_flags *op, int flags)

{

struct file *base = NULL;

struct file *filp;

struct path path;

int error;

//申请文件对象file结构体内存批针

filp = get_empty_filp();

if (!filp)

return ERR_PTR(-ENFILE);

filp->f_flags = op->open_flag;     //保存open flag

nd->intent.open.file = filp;       //将文件对象到nd->intent.open.file，后面就直接从这儿拿文件对象指针

nd->intent.open.flags = open_to_namei_flags(op->open_flag);

nd->intent.open.create_mode = op->mode;

error = path_init(dfd, pathname, flags | LOOKUP_PARENT, nd, &base);　　　//初始化nd

if (unlikely(error))

goto out_filp;

current->total_link_count = 0;

error = link_path_walk(pathname, nd)

;//查找到打开文件所在目录的目录项对象dentry和vfsmount,保存到nd。

后面仔细研研path lookup的方法namei.c

filp = do_last(nd, &path, op, pathname);   //  调用do_last继续做其它工作

........

return filp;

}

３、do_last

static struct file *do_last(struct nameidata *nd, struct path *path,

const struct open_flags *op, const char *pathname)

{

struct dentry *dir = nd->path.dentry;　　//所在目录的目录项对象dentry

struct dentry *dentry;

int open_flag = op->open_flag;

int will_truncate = open_flag & O_TRUNC;

int want_write = 0;

int acc_mode = op->acc_mode;

struct file *filp;

int error;

nd->flags &= ~LOOKUP_PARENT;

nd->flags |= op->intent;

..........

dentry = lookup_hash(nd);　//基于文件所在目录的nd，从目录项缓存中查找要打开文件的目录项对象dentry。

//如果缓存查找不到，放心会新创建一个新的目录项对项

path->dentry = dentry;

path->mnt = nd->path.mnt;

/* Negative dentry, just create the file */

if (!dentry->d_inode) {　　//如果文件dentry对应的inode为空，则需要为它创建inode

umode_t mode = op->mode;

。。。。。。。

error = vfs_create(dir->d_inode, dentry, mode, nd);  //利用所在目录的目录项对象的inode operation为相关文件创建新inode。注：这里dentry与inode就关联起来了。

nd->path.dentry = dentry;　　//建文件的目录项对象保存到nd->path->dentry

goto common;  // 跑到common 继续～～

}

common:

filp = nameidata_to_filp(nd);  //将nameidata相关项赋值给struct file对象。

return filp;

｝

4、nameidata_to_filp

struct file *nameidata_to_filp(struct nameidata *nd)

{

const struct cred *cred = current_cred();

struct file *filp;

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

filp = nd->intent.open.file;     //获取函数path_openat申请并保存到nameidata的file对象

nd->intent.open.file = NULL;

// 文件对象是在path_openat函数申请及一些简单初始化，这儿先判断filp->f_path.dentry是否为空

//注：虽然前面do_last函数将file对象相关的dentry和inode已经创建好了，但并未与file对象关联起来。

//file对象的很多其它重要成员也都没有初始化！

//接下来__dentry_open就要做这些事情了！

/* Has the filesystem initialised the file for us? */

if (filp->f_path.dentry == NULL) {

path_get(&nd->path);

filp = __dentry_open(nd->path.dentry, nd->path.mnt, filp,  // file对象初始化，包括file与dentry关联工作

NULL, cred);

}

return filp;

}

6、

__dentry_open

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

struct file *f,

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

const struct cred *cred)

{

static const struct file_operations empty_fops = {};

struct inode *inode;

int error;

f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |        //初始化打开mode

FMODE_PREAD | FMODE_PWRITE;

if (unlikely(f->f_flags & O_PATH))

f->f_mode = FMODE_PATH;    //打开的是目录

。。。。。。。

inode = dentry->d_inode;      //从dentry中获取inode。 dentry和inode在前面的do_last函数已经关联过的。

f->f_mapping = inode->i_mapping;   //地址空间map

f->f_path.dentry = dentry;             // 注： 就在这儿file对象与目录象对象关联起来啦！！

f->f_path.mnt = mnt;                   // file对象与挂载点对象关联起来啦。

f->f_pos = 0;                                //初始文件批针位置为0.

file_sb_list_add(f, inode->i_sb);             // add a file to the sb's file list

if (unlikely(f->f_mode & FMODE_PATH)) {

f->f_op = &empty_fops;          //打开目录的话，file operation为空了，直接返回了。

return f;

}

//注： 在这儿file对象的file_operations初始化好了。

f->f_op = fops_get(inode->i_fop);  //inode节点在初始化的时候已经赋值了i_fop,现在将文件操作赋值给f_op

// 通过file对象的file_operations->open指针，调用到特定文件系统的open函数，打开特定的设备或文件啦！

if (!open && f->f_op)

open = f->f_op->open;

if (open) {

error = open(inode, f);

if (error)

goto cleanup_all;

}

。。。。。。。。

/* 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;     //至此file对象已经初始化完成、并且调用特定文件系统的open方法

}

7、fd_install

将进程的current->files对象与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);　　　　//将fdt->fd[fd]指向file对象，这样文件对象与进程关联上了。 fd作为file对象的索引。这样file与fd也一一对应

spin_unlock(&files->file_lock);

}

fs/open.c 提供的内核常用方法

//面向kernel的文件open相关操作接口。注：返回值都是file对象，而非fd文件描述符。

filp_open

file_open_root

filp_close

dentry_open

参考:

http://blog.csdn.net/chenjin_zhong/article/details/8452453

http://blog.csdn.net/chenjin_zhong/article/details/8452487