linux内核装载vfs过程,linux内核装载vfs过程

linux虚拟文件系统是设备驱动程序的之上的一个抽象层，致力于提供给应用程序一个统一的操作文件的接口。虚拟文件系统的各个数据结构之间的关系比较复杂，画了一张各个数据结构之间的关系图在 http://download.csdn.net/detail/lonewolfxw/4588935，这个清晰的给出了各结构的关系。

1. 目录查找

linux的虚拟文件系统最核心的结构就是dentry缓存，每次查找一个路径时，先在dentry缓存中查找是否有对应的项，例如cd /home/lonewolf则先解析目录结构，查找对应于home的dentry是否在缓存中，若不在则从底层设备中读取，然后查找lonewolf对应的dentry，依次进行，找到了dentry就找到文件对应的inode。因此，dentry缓存和文件目录树相同，按照树的方式组织，并且将已经得到的dentry项加入到dentry_hashtable缓存起来，避免每次都从低速的底层设备中读取，哈希表用来快速的查找。这当然只是一个查找的简略的过程，实际的过程相当复杂，需要处理很多情况，包括：

检测符号链接，是否要跟踪符号链接

检测挂载点，并且重定向到新的文件系统查找

检查路径上每个目录的权限

解析各种复杂的用户输入的路径，如/./home///..//.

linux中的路径查找工作由namei.c中的kern_path操作完成，完成这个函数的主要操作又集中在link_path_walk中：

/*

* Name resolution.

* This is the basic name resolution function, turning a pathname into

* the final dentry. We expect 'base' to be positive and a directory.

*

* Returns 0 and nd will have valid dentry and mnt on success.

* Returns error and drops reference to input namei data on failure.

*/

static int link_path_walk(const char *name, struct nameidata *nd) /*struct nameidata只是一个查找结果的传送定义的一个结构体，查找成功则nd->path就是找到的结果，在执行这个函数之前，先对@nd进行初始化，表示路径查找的起点，若@name是以'/'开始，怎@nd->path就初始化fs_struct->root表示从跟目录开始查找，若@name不是以'/'开始，则初始化fs_struct->pwd表示从进程的当前目录开始查找*/

{

struct path next;

int err;

while (*name=='/') //若name是以/开始，则跳过，然后解析真正的路径的各个部分

name++;

if (!*name)

return 0;

/* At this point we know we have a real path component. */

for(;;) {

unsigned long hash;

struct qstr this;

unsigned int c;

int type;

err = may_lookup(nd); //检查权限，检查@nd对应inode的目录是否有执行权限，访问目录需要目录的执行权限

if (err)

break;

/*下面就是解析目录的各个部分, this表示解析的当前部分的结果*/

this.name = name;

c = *(const unsigned char *)name;

hash = init_name_hash();

do {

name++;

hash = partial_name_hash(c, hash);//一个一个字符累加的哈希值，计算遍历到的部分的哈希值

c = *(const unsigned char *)name;

} while (c && (c != '/')); //字符串结束或者碰到下个部分的开始'/',则停止

this.len = name - (const char *) this.name;

this.hash = end_name_hash(hash);

/*type表示当前部分的类型，用来处理特殊目录'.'和'..'*/

type = LAST_NORM;

if (this.name[0] == '.') switch (this.len) {

case 2:

if (this.name[1] == '.') {

type = LAST_DOTDOT;

nd->flags |= LOOKUP_JUMPED;

}

break;

case 1:

type = LAST_DOT;

}

if (likely(type == LAST_NORM)) {

struct dentry *parent = nd->path.dentry;

nd->flags &= ~LOOKUP_JUMPED;

if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {

err = parent->d_op->d_hash(parent, nd->inode,

&this);

if (err < 0)

break;

}

}

/*如果字符串已经结束，或者当前解析之后全是'/'，则当前部分是路径的最后一部分，没有进过walk_component处理，因为有可能最后一个部分不是目录，从而跳到last_component处理，由调用link_path_walk出来最后一个部分*/

if (!c)

goto last_component;

while (*++name == '/');

if (!*name)

goto last_component;

err = walk_component(nd, &next, &this, type, LOOKUP_FOLLOW);/*这个函数执行真正的dentry缓存的查找，在dentry_hashtable中查找@this的名字，找不到则使用inode的inode_operations->lookup中的操作从底层设备载入进来，这个哈希表用父目录的dentry和当前目录名字的hash值也就是this->hash作为键值。而且这个函数还处理目录的权限以及目录是装载点的情况，由于一个目录下可以装载多个文件系统，最新装载的文件系统隐藏以前的装载，若是装载点，则顺着装载点一直查找，直到最上层的装载点也就是当前可以看到的文件系统，当这个函数返回1，则表示这个目录是符号链接，下面进行特殊处理。函数调用成功则 @nd->path 表示this.name这个名字所表示的目录，也是就当前解析成功的目录，然后下一次循环解析下一个部分时候，这个目录就当做父目录在dentry缓存中查找，直至所有的部分全部完成*/

if (err < 0)

return err;

if (err) {

err = nested_symlink(&next, nd);//如果err是1，则处理符号链接

if (err)

return err;

}

if (can_lookup(nd->inode)) /*检查这个部分是否可以查找，也就是说检查这个部分是否是目录，由于除了最后一部分之外，中间的部分必须是目录，不是目录则出错。是最后一项会跳过此处的检查，直接跳到last_component*/

continue;

err = -ENOTDIR;

break;

/* here ends the main loop */

last_component:

nd->last = this;

nd->last_type = type;

return 0;

}

terminate_walk(nd);

return err;

}

static inline int walk_component(struct nameidata *nd, struct path *path,

struct qstr *name, int type, int follow)

{

struct inode *inode;

int err;

/*

* "." and ".." are special - ".." especially so because it has

* to be able to know about the current root directory and

* parent relationships.

*/

if (unlikely(type != LAST_NORM))

return handle_dots(nd, type); /*处理目录是'.'和'..’的情况，'.'很好处理，直接跳过就可以了，'..'稍微麻烦，因为当前目录有可能是一个装载点，跳到上一级目录就要切换文件系统*/

err = do_lookup(nd, name, path, &inode);/*这个从dentry缓存中查找，找不到就从底层设备中找，并且会处理装载点的情况*/

if (unlikely(err)) {

terminate_walk(nd);

return err;

}

if (!inode) {//没有找到dentry，则表示文件不存在

path_to_nameidata(path, nd);

terminate_walk(nd);

return -ENOENT;

}

if (should_follow_link(inode, follow)) {//检查是否要跟踪符号链接，若是返回1，有nested_symlink处理

if (nd->flags & LOOKUP_RCU) {

if (unlikely(unlazy_walk(nd, path->dentry))) {

terminate_walk(nd);

return -ECHILD;

}

}

BUG_ON(inode != path->dentry->d_inode);

return 1;

}

path_to_nameidata(path, nd);//将找到的path放到nd中返回

nd->inode = inode;

return 0;

}

static inline int handle_dots(struct nameidata *nd, int type)

{

if (type == LAST_DOTDOT) {

if (nd->flags & LOOKUP_RCU) {

if (follow_dotdot_rcu(nd))

return -ECHILD;

} else

follow_dotdot(nd);

}

return 0;

}

static int follow_dotdot_rcu(struct nameidata *nd)

{

set_root_rcu(nd); //获得当前进程的根文件系统的path

while (1) {

if (nd->path.dentry == nd->root.dentry &&

nd->path.mnt == nd->root.mnt) { /*如果在根路径上执行"..",没有意义直接跳过就可以了*/

break;

}

if (nd->path.dentry != nd->path.mnt->mnt_root) { /*不是装载点的根目录，就直接获得dentry的parent就可以了*/

struct dentry *old = nd->path.dentry;

struct dentry *parent = old->d_parent;

unsigned seq;

seq = read_seqcount_begin(&parent->d_seq);

if (read_seqcount_retry(&old->d_seq, nd->seq))

goto failed;

nd->path.dentry = parent;

nd->seq = seq;

break;

}

if (!follow_up_rcu(&nd->path))

break;

nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);

}

follow_mount_rcu(nd);

nd->inode = nd->path.dentry->d_inode;

return 0;

failed:

nd->flags &= ~LOOKUP_RCU;

if (!(nd->flags & LOOKUP_ROOT))

nd->root.mnt = NULL;

rcu_read_unlock();

br_read_unlock(vfsmount_lock);

return -ECHILD;

}

查找操作比较麻烦，处理的情况很多，沿着目录一步一步一直找到最后一个目录，然后dentry缓存起到很好的加速作用，不用每次都从设备中读取，在解析目录各个部分考虑符号链接和装载点就可以了。

2. 文件系统装载

文件系统装载大概的过程就是先查找文件系统要装载的目录的dentry和vfsmount，然后新建一个vfsmount表示新的装载点，调用文件系统的mount操作，将其装载，并且将新的vfsmount加入vfsmount树中，相应的dentry项设置相关的flag。文件系统的装载由do_mount完成

/*

* Flags is a 32-bit value that allows up to 31 non-fs dependent flags to

* be given to the mount() call (ie: read-only, no-dev, no-suid etc).

*

* data is a (void *) that can point to any structure up to

* PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent

* information (or be NULL).

*

* Pre-0.97 versions of mount() didn't have a flags word.

* When the flags word was introduced its top half was required

* to have the magic value 0xC0ED, and this remained so until 2.4.0-test9.

* Therefore, if this magic number is present, it carries no information

* and must be discarded.

*/

long do_mount(char *dev_name, char *dir_name, char *type_page,

unsigned long flags, void *data_page)

{

struct path path;

int retval = 0;

int mnt_flags = 0;

/* Discard magic */

if ((flags & MS_MGC_MSK) == MS_MGC_VAL)

flags &= ~MS_MGC_MSK;

/* Basic sanity checks */

if (!dir_name || !*dir_name || !memchr(dir_name, 0, PAGE_SIZE)) //验证目录的名字

return -EINVAL;

if (data_page) //特定文件系统的私有项，大小为一页

((char *)data_page)[PAGE_SIZE - 1] = 0;

/* ... and get the mountpoint */

retval = kern_path(dir_name, LOOKUP_FOLLOW, &path); //上文讲的查找装载点的路径

if (retval)

return retval;

retval = security_sb_mount(dev_name, &path,

type_page, flags, data_page); //直接调用security_ops->sb_mount,若成功直接返回

if (retval)

goto dput_out;

/*通过flag配置装载选项，下面是一个多路选择器，根据不同的装载选项调用不同的函数*/

/* Default to relatime unless overriden */

if (!(flags & MS_NOATIME))

mnt_flags |= MNT_RELATIME;

/* Separate the per-mountpoint flags */

if (flags & MS_NOSUID)

mnt_flags |= MNT_NOSUID;

if (flags & MS_NODEV)

mnt_flags |= MNT_NODEV;

if (flags & MS_NOEXEC)

mnt_flags |= MNT_NOEXEC;

if (flags & MS_NOATIME)

mnt_flags |= MNT_NOATIME;

if (flags & MS_NODIRATIME)

mnt_flags |= MNT_NODIRATIME;

if (flags & MS_STRICTATIME)

mnt_flags &= ~(MNT_RELATIME | MNT_NOATIME);

if (flags & MS_RDONLY)

mnt_flags |= MNT_READONLY;

flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE | MS_BORN |

MS_NOATIME | MS_NODIRATIME | MS_RELATIME| MS_KERNMOUNT |

MS_STRICTATIME);

if (flags & MS_REMOUNT)

retval = do_remount(&path, flags & ~MS_REMOUNT, mnt_flags,

data_page);

else if (flags & MS_BIND)

retval = do_loopback(&path, dev_name, flags & MS_REC);

else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))

retval = do_change_type(&path, flags);

else if (flags & MS_MOVE)

retval = do_move_mount(&path, dev_name);

else

retval = do_new_mount(&path, type_page, flags, mnt_flags,

dev_name, data_page);

dput_out:

path_put(&path);

return retval;

}装载新的文件系统通过do_new_mount来处理：

/*

* create a new mount for userspace and request it to be added into the

* namespace's tree

*/

static int do_new_mount(struct path *path, char *type, int flags,

int mnt_flags, char *name, void *data)

{

struct vfsmount *mnt;

int err;

if (!type)

return -EINVAL;

/* we need capabilities... */

if (!capable(CAP_SYS_ADMIN)) //权限检查

return -EPERM;

mnt = do_kern_mount(type, flags, name, data); /*新建一个vfsmount实例，并通过特定文件系统的操作装载到系统系统中，返回装载点的根目录*/

if (IS_ERR(mnt))

return PTR_ERR(mnt);

err = do_add_mount(mnt, path, mnt_flags); /*将vfsmount加入到vfsmount树中, 设置相关的数据结构的选项*/

if (err)

mntput(mnt);

return err;

}do_add_mount通过各种检查，例如一个挂载点不能重复挂载其自身在相同的挂载点、挂载点必须是目录等，最后执行namespace.c中的attach_recursive_mnt处理各种数据结构：

static int attach_recursive_mnt(struct vfsmount *source_mnt,

struct path *path, struct path *parent_path)

{

LIST_HEAD(tree_list);

struct vfsmount *dest_mnt = path->mnt;

struct dentry *dest_dentry = path->dentry;

struct vfsmount *child, *p;

int err;

if (IS_MNT_SHARED(dest_mnt)) {

err = invent_group_ids(source_mnt, true);

if (err)

goto out;

}

err = propagate_mnt(dest_mnt, dest_dentry, source_mnt, &tree_list); /*处理从属装载和共享装载，将相关的vfsmount通过tree_list返回*/

if (err)

goto out_cleanup_ids;

br_write_lock(vfsmount_lock);

if (IS_MNT_SHARED(dest_mnt)) {

for (p = source_mnt; p; p = next_mnt(p, source_mnt))

set_mnt_shared(p);

}

if (parent_path) { /*如果source_mnt之前装载在@parent_path，要迁移到@path上，则先从parent_path中移除，然后增加到@path路径上,移除包括从parent_path的vfsmount的子装载点中移除和从mount_hashtable中移除，因为mount_hashtable是通过父装载点的vfsmount和子装载的dentry来计算哈希值的*/

detach_mnt(source_mnt, parent_path);

attach_mnt(source_mnt, path);

touch_mnt_namespace(parent_path->mnt->mnt_ns);

} else { /*parent_path为空表示新挂载项，则设置source_mnt的mnt_parent、mnt_root、mnt_mountpoint，然后将其增加到父装载点的子装载点链表中，并将其加入哈希表*/

mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt);

commit_tree(source_mnt);

}

/*处理所有的从属装载和共享装载*/

list_for_each_entry_safe(child, p, &tree_list, mnt_hash) {

list_del_init(&child->mnt_hash);

commit_tree(child);

}

br_write_unlock(vfsmount_lock);

return 0;

out_cleanup_ids:

if (IS_MNT_SHARED(dest_mnt))

cleanup_group_ids(source_mnt, NULL);

out:

return err;

}至此，装载文件系统基本完成了。