Linux虚拟文件系统之文件打开（sys

在文件读写之前，我们必须先打开文件。从应用程序的角度来看，这是通过标准库的open函数完成的，该函数返回一个文件描述符。内核中是由系统调用sys_open()函数完成。

[cpp] view plain copy print?

/*sys_open*/
SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode)
{
long ret;
/*检查是否应该不考虑用户层传递的标志、总是强行设置
O_LARGEFILE标志。如果底层处理器的字长不是32位，就是这种
情况*/
if (force_o_largefile())
flags |= O_LARGEFILE;
/*实际工作*/
ret = do_sys_open(AT_FDCWD, filename, flags, mode);
/* avoid REGPARM breakage on x86: */
asmlinkage_protect(3, ret, filename, flags, mode);
return ret;
}

实际实现工作

[cpp] view plain copy print?

<pre class="cpp" name="code">long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
{
/*从进程地址空间读取该文件的路径名*/
char *tmp = getname(filename);
int fd = PTR_ERR(tmp);
if (!IS_ERR(tmp)) {
/*在内核中，每个打开的文件由一个文件描述符表示
该描述符在特定于进程的数组中充当位置索引(数组是
task_struct->files->fd_arry)，该数组的元素包含了file结构，其中
包括每个打开文件的所有必要信息。因此，调用下面
函数查找一个未使用的文件描述符,返回的是上面
说的数组的下标*/
fd = get_unused_fd_flags(flags);
if (fd >= 0) {
/*fd获取成功则开始打开文件，此函数是主要完成打开功能的函数*/
struct file *f = do_filp_open(dfd, tmp, flags, mode, 0);
if (IS_ERR(f)) {
put_unused_fd(fd);
fd = PTR_ERR(f);
} else {
fsnotify_open(f->f_path.dentry);
fd_install(fd, f);
}
}
putname(tmp);
}
return fd;
}</pre>
<pre></pre>
打开文件主体实现
<pre class="cpp" name="code">/*
* Note that the low bits of the passed in "open_flag"
* are not the same as in the local variable "flag". See
* open_to_namei_flags() for more details.
*/
struct file *do_filp_open(int dfd, const char *pathname,
int open_flag, int mode, int acc_mode)
{
struct file *filp;
struct nameidata nd;
int error;
struct path path;
struct dentry *dir;
int count = 0;
int will_write;
/*改变参数flag的值，具体做法是flag+1*/
int flag = open_to_namei_flags(open_flag);
/*设置访问权限*/
if (!acc_mode)
acc_mode = MAY_OPEN | ACC_MODE(flag);
/* O_TRUNC implies we need access checks for write permissions */
/*根据 O_TRUNC标志设置写权限 */
if (flag & O_TRUNC)
acc_mode |= MAY_WRITE;
/* Allow the LSM permission hook to distinguish append
access from general write access. */
/* 设置O_APPEND 标志*/
if (flag & O_APPEND)
acc_mode |= MAY_APPEND;
/*
* The simplest case - just a plain lookup.
*/
/*如果不是创建文件*/
if (!(flag & O_CREAT)) {
/*当内核要访问一个文件的时候，第一步要做的是找到这个文件，
而查找文件的过程在vfs里面是由path_lookup或者path_lookup_open函数来完成的。
这两个函数将用户传进来的字符串表示的文件路径转换成一个dentry结构，
并建立好相应的inode和file结构，将指向file的描述符返回用户。用户随后
通过文件描述符，来访问这些数据结构*/
error = path_lookup_open(dfd, pathname, lookup_flags(flag),
&nd, flag);
if (error)
return ERR_PTR(error);
goto ok;/*跳过下面的创建部分*/
}
/*
* Create - we need to know the parent.
*/
/*到此则是要创建文件*/
/* path-init为查找作准备工作，path_walk真正上路查找，
这两个函数联合起来根据一段路径名找到对应的dentry */
error = path_init(dfd, pathname, LOOKUP_PARENT, &nd);
if (error)
return ERR_PTR(error);
error = path_walk(pathname, &nd);
if (error) {
if (nd.root.mnt)
path_put(&nd.root);
return ERR_PTR(error);
}
if (unlikely(!audit_dummy_context()))
/*保存inode节点信息*/
audit_inode(pathname, nd.path.dentry);
/*
* We have the parent and last component. First of all, check
* that we are not asked to creat(2) an obvious directory - that
* will not do.
*/
error = -EISDIR;
/*父节点信息*/
if (nd.last_type != LAST_NORM || nd.last.name[nd.last.len])
goto exit_parent;
error = -ENFILE;
/*获取文件指针*/
filp = get_empty_filp();
if (filp == NULL)
goto exit_parent;
/*填充nameidata 结构*/
nd.intent.open.file = filp;
nd.intent.open.flags = flag;
nd.intent.open.create_mode = mode;
dir = nd.path.dentry;
nd.flags &= ~LOOKUP_PARENT;
nd.flags |= LOOKUP_CREATE | LOOKUP_OPEN;
if (flag & O_EXCL)
nd.flags |= LOOKUP_EXCL;
mutex_lock(&dir->d_inode->i_mutex);
/*从哈希表中查找目的文件对应的dentry,上面路径搜索的是父节点
也就是目的文件的上一层目录，为了得到目的文件的
path结构，我们用nd中的last结构和上一层目录的dentry结构
可以找到*/
path.dentry = lookup_hash(&nd);
path.mnt = nd.path.mnt;
/*到此目标节点的path结构已经找到*/
do_last:
error = PTR_ERR(path.dentry);
if (IS_ERR(path.dentry)) {
mutex_unlock(&dir->d_inode->i_mutex);
goto exit;
}
if (IS_ERR(nd.intent.open.file)) {
error = PTR_ERR(nd.intent.open.file);
goto exit_mutex_unlock;
}
/* Negative dentry, just create the file */
/*如果此dentry结构没有对应的inode节点，说明是无效的，应该创建文件节点 */
if (!path.dentry->d_inode) {
/*
* This write is needed to ensure that a
* ro->rw transition does not occur between
* the time when the file is created and when
* a permanent write count is taken through
* the 'struct file' in nameidata_to_filp().
*/
/*write权限是必需的*/
error = mnt_want_write(nd.path.mnt);
if (error)
goto exit_mutex_unlock;
/*按照namei格式的flag open*,主要是创建inode*/
error = __open_namei_create(&nd, &path, flag, mode);
if (error) {
mnt_drop_write(nd.path.mnt);
goto exit;
}
/*根据nameidata 得到相应的file结构*/
filp = nameidata_to_filp(&nd, open_flag);
if (IS_ERR(filp))
ima_counts_put(&nd.path,
acc_mode & (MAY_READ | MAY_WRITE |
MAY_EXEC));
/*放弃写权限*/
mnt_drop_write(nd.path.mnt);
if (nd.root.mnt)
path_put(&nd.root);
return filp;
}
/*
* It already exists.
*/
/*要打开的文件已经存在*/
mutex_unlock(&dir->d_inode->i_mutex);
/*保存inode节点*/
audit_inode(pathname, path.dentry);
error = -EEXIST;
if (flag & O_EXCL)
goto exit_dput;
/*如果path上安装了文件系统，则依次往下找，直到找到
的文件系统没有安装别的文件系统，更新path结构为
此文件系统的根目录信息*/
if (__follow_mount(&path)) {
error = -ELOOP;
if (flag & O_NOFOLLOW)
goto exit_dput;
}
error = -ENOENT;
if (!path.dentry->d_inode)
goto exit_dput;
if (path.dentry->d_inode->i_op->follow_link)
goto do_link;/*顺次遍历符号链接*/
/*路径转化为相应的nameidata 结构*/
path_to_nameidata(&path, &nd);
error = -EISDIR;
/*如果是文件夹*/
if (path.dentry->d_inode && S_ISDIR(path.dentry->d_inode->i_mode))
goto exit;
/*到这里，nd结构中存放的信息已经是最后的目的文件信息*/
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;
}
/*may_open执行权限检测、文件打开和truncate的操作*/
error = may_open(&nd.path, acc_mode, flag);
if (error) {
if (will_write)
mnt_drop_write(nd.path.mnt);
goto exit;
}
/*将nameidata转化为file*/
filp = nameidata_to_filp(&nd, open_flag);
if (IS_ERR(filp))
ima_counts_put(&nd.path,
acc_mode & (MAY_READ | MAY_WRITE | MAY_EXEC));
/*
* 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);
if (nd.root.mnt)
/*释放引用计数*/
path_put(&nd.root);
return filp;
exit_mutex_unlock:
mutex_unlock(&dir->d_inode->i_mutex);
exit_dput:
path_put_conditional(&path, &nd);
exit:
if (!IS_ERR(nd.intent.open.file))
release_open_intent(&nd);
exit_parent:
if (nd.root.mnt)
path_put(&nd.root);
path_put(&nd.path);
return ERR_PTR(error);
/*允许遍历连接文件，则手工找到连接文件对应的文件*/
do_link:
error = -ELOOP;
if (flag & O_NOFOLLOW)
goto exit_dput;/*不允许遍历连接文件，返回错误*/
/*
* This is subtle. Instead of calling do_follow_link() we do the
* thing by hands. The reason is that this way we have zero link_count
* and path_walk() (called from ->follow_link) honoring LOOKUP_PARENT.
* After that we have the parent and last component, i.e.
* we are in the same situation as after the first path_walk().
* Well, almost - if the last component is normal we get its copy
* stored in nd->last.name and we will have to putname() it when we
* are done. Procfs-like symlinks just set LAST_BIND.
*/
/*以下是手工找到链接文件对应的文件dentry结构代码
*/
/*设置查找LOOKUP_PARENT标志*/
nd.flags |= LOOKUP_PARENT;
/*判断操作是否安全*/
error = security_inode_follow_link(path.dentry, &nd);
if (error)
goto exit_dput;
/*处理符号链接,即路径搜索，结果放入nd中*/
error = __do_follow_link(&path, &nd);
if (error) {
/* Does someone understand code flow here? Or it is only
* me so stupid? Anathema to whoever designed this non-sense
* with "intent.open".
*/
release_open_intent(&nd);
if (nd.root.mnt)
path_put(&nd.root);
return ERR_PTR(error);
}
nd.flags &= ~LOOKUP_PARENT;
/*检查最后一段文件或目录名的属性情况*/
if (nd.last_type == LAST_BIND)
goto ok;
error = -EISDIR;
if (nd.last_type != LAST_NORM)
goto exit;
if (nd.last.name[nd.last.len]) {
__putname(nd.last.name);
goto exit;
}
error = -ELOOP;
/*出现回环标志: 循环超过32次*/
if (count++==32) {
__putname(nd.last.name);
goto exit;
}
dir = nd.path.dentry;
mutex_lock(&dir->d_inode->i_mutex);
/*更新路径的挂接点和dentry*/
path.dentry = lookup_hash(&nd);
path.mnt = nd.path.mnt;
__putname(nd.last.name);
goto do_last;
}
在内核中要打开一个文件，首先应该找到这个文件，而查找文件的过程在vfs里面是由do_path_lookup或者path_lookup_open函数来完成的，关于文件路径查找在前面已经分析过相关的代码了。这两个函数将用户传进来的字符串表示的文件路径转换成一个dentry结构，并建立好相应的inode和file结构，将指向file的描述符返回用户。用户随后通过文件描述符，来访问这些数据结构。

Linux虚拟文件系统之文件打开（sys_open()）相关推荐

网络与IO知识扫盲（一）：Linux虚拟文件系统，文件描述符，IO重定向
系统IO原理在 Linux 中: VFS(Virtual Filesystem Switch):虚拟文件系统,是一个目录树.树上不同的节点可以映射到物理的文件地址,可以挂载. 相当于一个解耦层,在具 ...
Linux虚拟文件系统、文件描述符、管道
在Linux中,所有内容都是以文件的形式保存和管理的,即一切皆文件,普通文件是文件,目录(Windows下称为文件夹)是文件,硬件设备(键盘.监视器.硬盘.打印机等)都是文件,就连套接字(socket ...
linux 目录防篡改,一种基于Linux虚拟文件系统的防篡改方法及系统的制作方法
一种基于Linux虚拟文件系统的防篡改方法及系统的制作方法 [技术领域] [0001]本发明涉及文件防护技术领域,特别涉及一种基于Linux虚拟文件系统的防篡改方法及系统. [背景技术] [0002] ...
Linux虚拟文件系统：数据结构与文件系统注册、文件打开读写
数据结构超级块 - super_block 索引节点 - inode 目录项 - dentry 文件结构 - file 虚拟文件系统实现注册文件系统 - register_filesystem 打 ...
Linux虚拟文件系统
从文件 I/O 看 Linux 的虚拟文件系统 1 引言 Linux 中允许众多不同的文件系统共存,如 ext2, ext3, vfat 等.通过使用同一套文件 I/O 系统调用即可对 Linux ...
linux虚拟文件系统浅析
linux虚拟文件系统浅析虚拟文件系统(VFS) 在我看来, "虚拟"二字主要有两层含义: 1, 在同一个目录结构中, 可以挂载着若干种不同的文件系统. VFS隐藏了它们的实现细 ...
linux 文件系统 vfs,linux虚拟文件系统vfs
<操作系统>课程设计报告课程设计题目:操作系统课程设计设计时间:2016/1/10一. 课程设计目的与要求需要完成的内容:(1) 安装虚拟机:Vmware.Vmware palyer ( ...
Linux 虚拟文件系统(一)概述
Linux 虚拟文件系统(一)概述 tags: Linux源码 Linux 虚拟文件系统一概述文章梗概正文文件系统虚拟文件系统架构虚拟文件系统如何知道可用的文件系统有哪些的不太喜欢的环节 ...
Linux 虚拟文件系统四大对象：超级块、inode、dentry、file之间关系
一:文件系统 1. 什么是文件系统? 操作系统中负责管理和存储文件信息的软件机构称为文件管理系统,简称文件系统. 通常文件系统是用于存储和组织文件的一种机制,便于对文件进行方便的查找与访问. 文件系统 ...
linux虚拟文件系统-文件的打开
本质上,一个文件打开的过程就是建立fd,file,dentry,inode,address_space的关联过程.关联过程中关键的一个过程是如何根据路径名寻找到对应的dentry,对于用户程序来说路径 ...

Linux虚拟文件系统之文件打开（sys_open()）

Linux虚拟文件系统之文件打开（sys_open()）相关推荐

最新文章

热门文章