Linux vfs流程分析 阶段一：安装 rootfs 文件系统
1 vfs整体流程
Linux版本：linux4.14
vfs函数调用流程
start_kernel()
|----vfs_caches_init_early()
|----vfs_caches_init()
|----dcache_init()
|----inode_init()
|----files_init()
|----files_maxfiles_init()
|----mnt_init()
|----init_rootfs()
|----register_filesystem(&rootfs_fs_type)
|----init_mount_tree()
|----bdev_cache_init()
|----chrdev_init()
2 vfs_cache_init()
void __init vfs_caches_init(void)
{
names_cachep = kmem_cache_create("names_cache", PATH_MAX, 0,
SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
dcache_init();
inode_init();
files_init();
files_maxfiles_init();
mnt_init();
bdev_cache_init();
chrdev_init();
}
此函数的主要作用就是初始化一些 vfs 会用到的 cache。关于 cache 的内容可参考深入理解LINUX内核第八章内存管理。
以下几个加粗的变量都是全局变量。很关键。
- dcache_init() 初始化 dentry_cache 与 dentry_hashtable。
- inode_init() 初始化 inode_cache 与 inode_hashtable。
- files_init() 初始化 filp_cache 。
- files_maxfiles_init() 初始化内存中可以打开的最大的文件数。
- mnt_init() 初始化 mount_cache 与 mount_hashtable 与 mountpoint_hashtable。还会调用其它的函数，放到下一节具体介绍。
- bdev_cache_init() 初始化 bdev_cachep ，注册 bdev 文件系统，挂载 bdev 文件系统。
- chrdev_init() 初始化 cdev_map。
3 mnt_init()
void __init mnt_init(void)
{
int err;
mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct mount),
0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
mount_hashtable = alloc_large_system_hash("Mount-cache",
sizeof(struct hlist_head),
mhash_entries, 19,
HASH_ZERO,
&m_hash_shift, &m_hash_mask, 0, 0);
mountpoint_hashtable = alloc_large_system_hash("Mountpoint-cache",
sizeof(struct hlist_head),
mphash_entries, 19,
HASH_ZERO,
&mp_hash_shift, &mp_hash_mask, 0, 0);
if (!mount_hashtable || !mountpoint_hashtable)
panic("Failed to allocate mount hash table\n");
kernfs_init();
err = sysfs_init();
if (err)
printk(KERN_WARNING "%s: sysfs_init error: %d\n",
__func__, err);
fs_kobj = kobject_create_and_add("fs", NULL);
if (!fs_kobj)
printk(KERN_WARNING "%s: kobj create error\n", __func__);
init_rootfs();
init_mount_tree();
}
- 调用 kmem_cache_create 分配 mnt_cache。
- 调用 alloc_large_system_hash 分别分配 mount_hashtable 与 mountpoint_hashtable。
- 初始化 sysfs 文件系统。
- 初始化 rootfs 文件系统。
- 初始化 mount tree，最终要的就是初始化根目录，然后挂载一个空的 rootfs 上去。
4 init_rootfs()
int __init init_rootfs(void)
{
int err = register_filesystem(&rootfs_fs_type);
if (err)
return err;
if (IS_ENABLED(CONFIG_TMPFS) && !saved_root_name[0] &&
(!root_fs_names || strstr(root_fs_names, "tmpfs"))) {
err = shmem_init();
is_tmpfs = true;
} else {
err = init_ramfs_fs();
}
if (err)
unregister_filesystem(&rootfs_fs_type);
return err;
}
- 注册 rootfs_fs_type 。
5 init_mount_tree()
static void __init init_mount_tree(void)
{
struct vfsmount *mnt;
struct mnt_namespace *ns;
struct path root;
struct file_system_type *type;
type = get_fs_type("rootfs");
if (!type)
panic("Can't find rootfs type");
mnt = vfs_kern_mount(type, 0, "rootfs", NULL);
put_filesystem(type);
if (IS_ERR(mnt))
panic("Can't create rootfs");
ns = create_mnt_ns(mnt);
if (IS_ERR(ns))
panic("Can't allocate initial namespace");
init_task.nsproxy->mnt_ns = ns;
get_mnt_ns(ns);
root.mnt = mnt;
root.dentry = mnt->mnt_root;
mnt->mnt_flags |= MNT_LOCKED;
set_fs_pwd(current->fs, &root);
set_fs_root(current->fs, &root);
}
- 调用 get_fs_type(“rootfs”) 获取文件系统类型 (file_system_type)。
- 调用 vfs_kern_mount() 挂载 rootfs 到根目录（ “/” ），同时返回 vfsmount 结构体。
- 调用 create_mnt_ns() 创建 mnt namespace。
- 将mnt namespace 赋给 0 号进程的 task_struct init_task.nsproxy->mnt_ns。
- 将 0 号进程的根目录与当前目录都切换到根目录（ “/” ）。
6 vfs_kern_mount()
struct vfsmount *
vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
{
struct mount *mnt;
struct dentry *root;
if (!type)
return ERR_PTR(-ENODEV);
mnt = alloc_vfsmnt(name);
if (!mnt)
return ERR_PTR(-ENOMEM);
if (flags & SB_KERNMOUNT)
mnt->mnt.mnt_flags = MNT_INTERNAL;
root = mount_fs(type, flags, name, data);
if (IS_ERR(root)) {
mnt_free_id(mnt);
free_vfsmnt(mnt);
return ERR_CAST(root);
}
mnt->mnt.mnt_root = root;
mnt->mnt.mnt_sb = root->d_sb;
mnt->mnt_mountpoint = mnt->mnt.mnt_root;
mnt->mnt_parent = mnt;
lock_mount_hash();
list_add_tail(&mnt->mnt_instance, &root->d_sb->s_mounts);
unlock_mount_hash();
return &mnt->mnt;
}
- 调用 alloc_vfsmnt() 分配一个 mount 结构体。
- 调用 mount_fs() ，挂载 rootfs，返回挂载的 dentry，也就是根目录，根目录会在里面创建的。
- 将根目录 dentry root 赋值给 mount->vfsmount.dentry mnt_root 。
- 将 super_block root->d_sb 赋值给 mount->vfsmount.super_block mnt_sb 。
- 将 mount->vfsmount.dentry mnt_root 赋值给 mount->dentry mnt_mountpoint 。
- 将 mount mnt 赋值给 mount->mount mnt_parent 。
- 将 mount mnt 通过 mnt->mnt_instance 加入到 dentry->super_block->list_head root->d_sb->s_mounts 。
7 mount_fs()
struct dentry *
mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
{
struct dentry *root;
struct super_block *sb;
char *secdata = NULL;
int error = -ENOMEM;
if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
secdata = alloc_secdata();
if (!secdata)
goto out;
error = security_sb_copy_data(data, secdata);
if (error)
goto out_free_secdata;
}
root = type->mount(type, flags, name, data);
if (IS_ERR(root)) {
error = PTR_ERR(root);
goto out_free_secdata;
}
sb = root->d_sb;
BUG_ON(!sb);
WARN_ON(!sb->s_bdi);
/*
* Write barrier is for super_cache_count(). We place it before setting
* SB_BORN as the data dependency between the two functions is the
* superblock structure contents that we just set up, not the SB_BORN
* flag.
*/
smp_wmb();
sb->s_flags |= SB_BORN;
error = security_sb_kern_mount(sb, flags, secdata);
if (error)
goto out_sb;
/*
* filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE
* but s_maxbytes was an unsigned long long for many releases. Throw
* this warning for a little while to try and catch filesystems that
* violate this rule.
*/
WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
"negative value (%lld)\n", type->name, sb->s_maxbytes);
up_write(&sb->s_umount);
free_secdata(secdata);
return root;
out_sb:
dput(root);
deactivate_locked_super(sb);
out_free_secdata:
free_secdata(secdata);
out:
return ERR_PTR(error);
}
此函数调用实际的文件系统类型中的 mount 操作，返回 mount 的目录，也就是 mountpoint 。对于 rootfs_fs_type 返回的 dentry root 也就是根目录（“/”）。下载挂载着虚 rootfs 文件系统（ramfs的一种）。后面会根据启动项中的参数，再挂载具体的根文件系统。
8 rootfs_mount()
static struct dentry *rootfs_mount(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data)
{
static unsigned long once;
void *fill = ramfs_fill_super;
if (test_and_set_bit(0, &once))
return ERR_PTR(-ENODEV);
if (IS_ENABLED(CONFIG_TMPFS) && is_tmpfs)
fill = shmem_fill_super;
return mount_nodev(fs_type, flags, data, fill);
}
- ramfs_fill_super 是根据 ramfs 文件系统填充虚拟文件系统的 super block 。
- 调用 mount_nodev() 挂载虚 rootfs 。nodev 说明了此文件系统没有具体的 block 载体，是存在于 ram 中的。
9 mount_nodev()
struct dentry *mount_nodev(struct file_system_type *fs_type,
int flags, void *data,
int (*fill_super)(struct super_block *, void *, int))
{
int error;
struct super_block *s = sget(fs_type, NULL, set_anon_super, flags, NULL);
if (IS_ERR(s))
return ERR_CAST(s);
error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
if (error) {
deactivate_locked_super(s);
return ERR_PTR(error);
}
s->s_flags |= SB_ACTIVE;
return dget(s->s_root);
}
- sget 现在现存 fs_type->fs_supers 链表中查找已经存在的对应的超级块实例（因为一个设备可能已经被挂载过了），fs_supers 是 file_system_type 的成员，它指向一个特定文件系统下的所有超级块实例的链表表头。如果没能找到已经存在的超级块实例，那就只能创建一个新的了。并把这个新的 sb 加入到全局 super_blocks 链表，以及此 file_system_type 的 fs_supers 链表中。到此就得到了一个已知的或新的 super_block 实例，后面的工作都是为了填充这个 super_block 的内容，并把它加入到各种链表中。
- fill_super 填充上面获取到的 super block 。fill_super 就是 mount_nodev(fs_type, flags, data, fill) 传进来的 fill，也就是 fill_ramfs_super 函数。
10 fill_ramfs_super()
int ramfs_fill_super(struct super_block *sb, void *data, int silent)
{
struct ramfs_fs_info *fsi;
struct inode *inode;
int err;
fsi = kzalloc(sizeof(struct ramfs_fs_info), GFP_KERNEL);
sb->s_fs_info = fsi;
if (!fsi)
return -ENOMEM;
err = ramfs_parse_options(data, &fsi->mount_opts);
if (err)
return err;
sb->s_maxbytes = MAX_LFS_FILESIZE;
sb->s_blocksize = PAGE_SIZE;
sb->s_blocksize_bits = PAGE_SHIFT;
sb->s_magic = RAMFS_MAGIC;
sb->s_op = &ramfs_ops;
sb->s_time_gran = 1;
inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0);
sb->s_root = d_make_root(inode);
if (!sb->s_root)
return -ENOMEM;
return 0;
}
- 此函数主要是 获取 ramfs 文件系统的根目录 inode，一般是根目录 inode 号为2。
- 根据根 inode make root dentry 。将 dentry root 赋值到 super_block->dentry sb->s_root 。
11 d_make_root()
struct dentry *d_make_root(struct inode *root_inode)
{
struct dentry *res = NULL;
if (root_inode) {
res = __d_alloc(root_inode->i_sb, NULL);
if (res) {
res->d_flags |= DCACHE_RCUACCESS;
d_instantiate(res, root_inode);
} else {
iput(root_inode);
}
}
return res;
}
- 调用 __d_alloc() 分配一个目录结构。
- 调用 d_instantiate，使用 root_inode 初始化分配的目录。
12 __d_alloc()
struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
{
struct external_name *ext = NULL;
struct dentry *dentry;
char *dname;
int err;
dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL);
if (!dentry)
return NULL;
/*
* We guarantee that the inline name is always NUL-terminated.
* This way the memcpy() done by the name switching in rename
* will still always have a NUL at the end, even if we might
* be overwriting an internal NUL character
*/
dentry->d_iname[DNAME_INLINE_LEN-1] = 0;
if (unlikely(!name)) {
name = &slash_name;
dname = dentry->d_iname;
} else if (name->len > DNAME_INLINE_LEN-1) {
size_t size = offsetof(struct external_name, name[1]);
ext = kmalloc(size + name->len, GFP_KERNEL_ACCOUNT);
if (!ext) {
kmem_cache_free(dentry_cache, dentry);
return NULL;
}
atomic_set(&ext->u.count, 1);
dname = ext->name;
if (IS_ENABLED(CONFIG_DCACHE_WORD_ACCESS))
kasan_unpoison_shadow(dname,
round_up(name->len + 1, sizeof(unsigned long)));
} else {
dname = dentry->d_iname;
}
dentry->d_name.len = name->len;
dentry->d_name.hash = name->hash;
memcpy(dname, name->name, name->len);
dname[name->len] = 0;
/* Make sure we always see the terminating NUL character */
smp_wmb();
dentry->d_name.name = dname;
dentry->d_lockref.count = 1;
dentry->d_flags = 0;
spin_lock_init(&dentry->d_lock);
seqcount_init(&dentry->d_seq);
dentry->d_inode = NULL;
dentry->d_parent = dentry;
dentry->d_sb = sb;
dentry->d_op = NULL;
dentry->d_fsdata = NULL;
INIT_HLIST_BL_NODE(&dentry->d_hash);
INIT_LIST_HEAD(&dentry->d_lru);
INIT_LIST_HEAD(&dentry->d_subdirs);
INIT_HLIST_NODE(&dentry->d_u.d_alias);
INIT_LIST_HEAD(&dentry->d_child);
d_set_d_op(dentry, dentry->d_sb->s_d_op);
if (dentry->d_op && dentry->d_op->d_init) {
err = dentry->d_op->d_init(dentry);
if (err) {
if (dname_external(dentry))
kfree(external_name(dentry));
kmem_cache_free(dentry_cache, dentry);
return NULL;
}
}
if (unlikely(ext)) {
pg_data_t *pgdat = page_pgdat(virt_to_page(ext));
mod_node_page_state(pgdat, NR_INDIRECTLY_RECLAIMABLE_BYTES,
ksize(ext));
}
this_cpu_inc(nr_dentry);
return dentry;
}
- 调用此函数的时候，第二个参数为 NULL，当第二个参数为 NULL 时，目录的名字就为 slash_name 。
- const struct qstr slash_name = QSTR_INIT("/", 1); slash_name 就是根目录的名字（“/”）。
- 其他的就不具体分析了。
至此虚 rootfs 就挂载在根目录下了，此文件系统的目的就是提供一个空的目录结构，等待后面再挂载具体的文件系统。这个我们下一篇文章在分析。
此时的文件系统如下图所示。此文件系统是存在于 ram 中的。
