话说文件系统——aufs源码分析

Posted 请给我倒杯茶

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了话说文件系统——aufs源码分析相关的知识，希望对你有一定的参考价值。

本文转载自：http://www.cnblogs.com/xie0812/p/8848185.html

1. linux中设备驱动的入口都是：module_init(xxx_init);里面注册的函数，对于文件系统来说也是一样的，对于aufs来说，就是aufs_init，具体如下

1
2
3
4
5
//用于描述aufs文件系统的特性和功能static struct file_system_type aufs_type = {
    .name = "aufs",
    .mount = aufs_get_sb,
    .kill_sb = kill_litter_super,
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
static int __init aufs_init(void)
{
    int ret;
 
    struct dentry *pslot;
     
    ret = register_filesystem(&aufs_type); //把注册具体的文件系统
    if (ret) {
        printk(KERN_ERR "aufs: cannot register file system\\n");
        return ret;
    }
 
    aufs_mount = kern_mount(&aufs_type); //创建aufs对于的super_block和根目录dentry
    if (IS_ERR(aufs_mount)) {
        printk(KERN_ERR "aufs: cannot mount file system\\n");
        unregister_filesystem(&aufs_type);
        return ret;
    }
 
　　　　　......
 
    return 0;
}

2. struct file_system_type结构体在(kernel)/include/linux/fs.h中。每个注册到内核中的文件系统都有一个这样的结构体来表示，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct file_system_type {
    const char *name; //文件系统的名字，比如我们的名字为“aufs”
    int fs_flags;
　　　　 .....
    //用于从磁盘文件系统中读取到super_block，或者对于一些特殊文件系统来说，直接在kernel内存
    //中构造对于的super_block结构体。我们的aufs不是磁盘文件系统，所以是直接在内存中构造的
        struct dentry *(*mount) (struct file_system_type *, int,
               const char *, void *);
    void (*kill_sb) (struct super_block *);//用于结束访问对应文件系统的super_block
    struct module *owner;
    struct file_system_type * next;//注册文件系统时，会把file_system_type添加到全局的file_systems中
    struct hlist_head fs_supers;
    ......
};

3. (kernel)/fs/filesystems.c register_filesystem函数主要的作用就是通过在在内核中搜索是否要注册的文件系统是否已经注册过了，如果没有

就注册到系统中，其实所谓注册，就是把对应的file_system_type结构体添加到全局的file_systems变量组成的链表中。每个file_system_type不是

有next成员吗，就是通过next把系统中的所有文件系统链接到一起的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int register_filesystem(struct file_system_type * fs)
{
    int res = 0;
    struct file_system_type ** p;
 
    BUG_ON(strchr(fs->name, \'.\'));
    if (fs->next) //如果要注册的fs的next不是NULL，证明此fs已经注册过了
        return -EBUSY;
    write_lock(&file_systems_lock);
    p = find_filesystem(fs->name, strlen(fs->name));//通过要注册的fs的名字在kernel中搜索
    if (*p)//如果搜索到了，证明已经注册过了
        res = -EBUSY;
    else //如果没有找到，就把具体的fs注册到系统中
        *p = fs;
    write_unlock(&file_systems_lock);
    return res;
}

4. find_filesystem((kernel)/fs/filesystems.c)函数在系统中通过所注册文件系统的名字，通过简单的字符串比对的方式找是否在系统中已经注册了。

这也可以说，文件系统的名字必须得唯一，这里需要注意的是：这个函数的返回值是指针的指针，正是由于这样，在register_filesystem函数中

可以改变find_filesystem函数返回的值，也是把要注册的文件系统添加到链表中了

1
2
3
4
5
6
7
8
9
static struct file_system_type **find_filesystem(const char *name, unsigned len)
{
    struct file_system_type **p;
    for (p=&file_systems; *p; p=&(*p)->next)
        if (strlen((*p)->name) == len &&
            strncmp((*p)->name, name, len) == 0)
            break;
    return p;
}

5. 把文件系统中注册到链表中后，register_filesystem函数的使命就结束了。注册就这么简单？没错，没有花眼，其实重头戏在kern_mount函数中，

这个函数位于：(kernel)/include/linux中，是一个宏定义(#define kern_mount(type) kern_mount_data(type, NULL))，好吧，看来kern_mount只是

kern_mount_data函数穿了一件外套，那就看看我们的真大神吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//（kernel）/fs/namespace.c
struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
{
    struct vfsmount *mnt;//文件系统的挂载点，这个结构代表一种文件系统的一个特定的实例，也就是说一种文件系统可以
                         //在父文件系统的多个地方挂载，只有文件系统挂载到具体的某个目录下了，才能使用
    mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);//注意我们传入的data为NULL
    if (!IS_ERR(mnt)) {
        /*
         * it is a longterm mount, don\'t release mnt until
         * we unmount before file sys is unregistered
        */
        real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL;
    }
    return mnt;
}

6. vfs_kern_mount这个函数主要的目的就是分配struct mount、aufs文件系统的根目录dentry、aufs的super_block，同时对其初始化，且把它们相互

联系起来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//(kernel)/fs/namespace.c
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);//根据name创建mount，对我们来说就是创建名为aufs的mount
    if (!mnt)
        return ERR_PTR(-ENOMEM);
 
    if (flags & MS_KERNMOUNT)
        mnt->mnt.mnt_flags = MNT_INTERNAL;
 
    root = mount_fs(type, flags, name, data);//创建aufs的根目录dentry，同时创建aufs对应的super_block
    if (IS_ERR(root)) {
        mnt_free_id(mnt);
        free_vfsmnt(mnt);
        return ERR_CAST(root);
    }
 
    mnt->mnt.mnt_root = root;//把aufs的根目录dentry赋值给vfsmount的mnt_root，这样就可以通过挂载点找到根目录dentry
    mnt->mnt.mnt_sb = root->d_sb;//把aufs的super_block赋值给vfsmount的mnt_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);//把mount实例添加到super_block中的s_mounts链表中，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //跟代码发现在文件系统重新时会遍历这个链表
    unlock_mount_hash();
    return &mnt->mnt;//返回aufs根目录的dentry
}

7. mount_fs函数中根据条件创建和初始化了aufs文件系统的super_block和根目录的dentry，其实真真是通过执行aufs_get_sb这个函数

创建的，这个函数中更多的是把aufs_get_sb函数返回的dentry和super_block进行处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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;
　　//注意：因为我们传入的data为NULL，所以这里直接跳过去
    if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
　　　　......
    }
    //其实真正创建aufs文件系统的super_block和根目录dentry是在这个函数中，还记得吗，我们的aufs_type的mount指针指向的是
　　//aufs_get_sb这个函数
    root = type->mount(type, flags, name, data);
    if (IS_ERR(root)) {
        error = PTR_ERR(root);
        goto out_free_secdata;
    }
    sb = root->d_sb;//从root的dentry的得到super_block
    BUG_ON(!sb);
    WARN_ON(!sb->s_bdi);
    sb->s_flags |= MS_BORN;
 
    .....
    return root;
        .....
}

8. 视线转移到aufs_get_sb吧，这个函数只是调用了mount_single函数，不过注意，aufs_fill_super函数作为参数传递给了mount_single。

1
2
3
4
5
static struct dentry *aufs_get_sb(struct file_system_type *fs_type,
        int flags, const char *dev_name, void *data)
{
    return mount_single(fs_type, flags, data, aufs_fill_super);
}

9. 在我们实现的aufs文件系统的super_block和根目录dentry都是从这个函数中得到

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
(kernel)/fs/super.cstruct dentry *mount_single(struct file_system_type *fs_type,
    int flags, void *data,
    int (*fill_super)(struct super_block *, void *, int))
{
    struct super_block *s;
    int error;
    //搜索或者创建aufs对应的super_block，其中compare_single函数返回一直是1；
    //set_anon_super这个函数把创建的super_block的dev设置为none，比如如果是
    //一个磁盘文件系统的话，对应的设备就是一个磁盘，或者U盘等
    s = sget(fs_type, compare_single, set_anon_super, flags, NULL);
    if (IS_ERR(s))
        return ERR_CAST(s);
    if (!s->s_root) {
        //如果执行到这里，证明根目录的dentry还没有创建，那我们推断这个还是中就会创建
        //根目录对应的dentry和inode，同时把开始时创建的super_block联系起来，这个函数通过参数
        //传递进来的，其实对应为aufs_fill_super
        error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
        if (error) {
            deactivate_locked_super(s);
            return ERR_PTR(error);
        }
        s->s_flags |= MS_ACTIVE;
    } else {
        do_remount_sb(s, flags, data, 0);
    }
    return dget(s->s_root);
}

10. 到这个地方已经是胜利在望了，我们继续跟踪一下sget这个函数，它是怎么创建aufs的super_block的。其实file_system_type中

维护着一个以fs_supers的super_block链表，对应我们的aufs_type，当然我们的aufs_type中此成员设置为NULL，那么也就会创建一个

super_block，同时把aufs_type的对应创建的super_block添加到aufs_type中fs_supers链表中，同时把分配的super_block添加到内核维

护的一个全局super_block链表中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
struct super_block *sget(struct file_system_type *type,
            int (*test)(struct super_block *,void *),
            int (*set)(struct super_block *,void *),
            int flags,
            void *data)
{
    struct super_block *s = NULL;
    struct super_block *old;
    int err;
 
retry:
    spin_lock(&sb_lock);
    if (test) {//这里test为compare_single,这个函数什么都没做，就返回1
        //在对应的file_system_type（aufs_type）结构中维护的fs_supers的super_block链表查找
        hlist_for_each_entry(old, &type->fs_supers, s_instances) {
            if (!test(old, data))
                continue;
            if (!grab_super(old))
                goto retry;
            if (s) {
                up_write(&s->s_umount);
                destroy_super(s);
                s = NULL;
            }
            return old;
        }
    }
    //如果没有找到，就分配一个super_block结构体，这里需要注意，分配完之后又goto retry，
    //这是因为allo_super有可能导致进程休眠，所以当分配成功时，有可能在进程休眠的时候已经
    //分配了对应的super_block，所以要goto回去
    if (!s) {
        spin_unlock(&sb_lock);
        s = alloc_super(type, flags);
        if (!s)
            return ERR_PTR(-ENOMEM);
        goto retry;
    }
         
    err = set(s, data);//这里的set对应：set_anon_super
    if (err) {
        spin_unlock(&sb_lock);
        up_write(&s->s_umount);
        destroy_super(s);
        return ERR_PTR(err);
    }
    s->s_type = type;//把创建的super_block的s_type设置为我们传递进来的aufs_type
    strlcpy(s->s_id, type->name, sizeof(s->s_id));//把创建的super_block的名字设置为aufs
    list_add_tail(&s->s_list, &super_blocks);//内核维护着一个super_block的链表，所有注册到内核中的文件系统都会注册到
                                            //这个链表上，这个链表的头就是super_blocks
    hlist_add_head(&s->s_instances, &type->fs_supers);//把aufs的super_block添加到aufs_type的fs_supers中
    spin_unlock(&sb_lock);
    get_filesystem(type);
    register_shrinker(&s->s_shrink);
    return s;
}

11. sget函数执行完之后，我们就得到了aufs_type对应的super_block，但是aufs对应的根目录的dentry还没有着落了，我们回到第9步，还记得吗，

我们在第9步说fill_super这个函数，对应aufs的aufs_fill_super函数

1
2
3
4
5
6
7
static int aufs_fill_super(struct super_block *sb, void *data, int silent)
{
    //在根目录下创建对应的文件，这里我们什么都没有创建
    static struct tree_descr debug_files[] = {{""}};

(c)2006-2024 SYSTEM All Rights Reserved IT常识