linux_3.0.1分析4--文件系统的挂载

一. 临时文件系统的挂载过程
系统开始时先挂载了一个临时的文件系统,通过这个临时的文件系统

init/main.c
start_kernel
{
    vfs_caches_init(totalram_pages);  ;在fs/dcache.c:创建一个虚拟的文件系统
        --> mnt_init                  ;在fs/namespace.c中
            --> init_rootfs           ;1.在fs/ramfs/inode.c中
            --> init_mount_tree();     ;2.在fs/namespace.c中
}

1.在fs/ramfs/inode.c中

int __init init_rootfs(void)
{
    bdi_init(&ramfs_backing_dev_info);       //初始化ramfs_backing_dev_info结构体
    register_filesystem(&rootfs_fs_type);    //1.1注册rootfs_fs_type,
}                                               即把rootfs_fs_type添加到全局变量中

static struct backing_dev_info ramfs_backing_dev_info = {
    .name        = "ramfs",
    .ra_pages    = 0,    /* No readahead */
    .capabilities    = BDI_CAP_NO_ACCT_AND_WRITEBACK |
              BDI_CAP_MAP_DIRECT | BDI_CAP_MAP_COPY |
              BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP,
};

static struct file_system_type rootfs_fs_type = {
    .name        = "rootfs",
    .mount        = rootfs_mount,
    .kill_sb    = kill_litter_super,
};

1.1全局变量file_systems链表中将参数fs添加进来

int register_filesystem(struct file_system_type * fs)
{

    struct file_system_type ** p;
    INIT_LIST_HEAD(&fs->fs_supers);
    write_lock(&file_systems_lock);
    p = find_filesystem(fs->name, strlen(fs->name)); //1.1.1在全局变量file_system中查找
    if (*p)              //如果在全局变量中能够找到,*p!=NULL说明这个文件系统己经注册过了
        res = -EBUSY;
    else                 //如果在全局变量中不能找到,*p==NULL,说明这个文件系统没有注册可以使用
        *p = fs;         //使得file_systems.next=fs,链表中增加一项
    write_unlock(&file_systems_lock);
    return res;
}

1.1.1在全局变量文件系统类型的链表中查找有没有名字等于参数name的文件系统类型

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;
}

2.在fs/namespace.c中

static void __init init_mount_tree(void)
{
    struct vfsmount *mnt;
    struct mnt_namespace *ns;
    struct path root;

    mnt = do_kern_mount("rootfs", 0, "rootfs", NULL);   //2.1
    ns = create_mnt_ns(mnt);                            //为新的文件系统创建namespace
    init_task.nsproxy->mnt_ns = ns;
    get_mnt_ns(ns);
    root.mnt = ns->root;
    root.dentry = ns->root->mnt_root;
    set_fs_pwd(current->fs, &root);                   //将进程0的当前路径设为rootfs的root
    set_fs_root(current->fs, &root);                  //将进程0的fs设为rootfs的root
}

2.1在fs/namespace.c中

struct vfsmount * do_kern_mount(const char *fstype, int flags, const char *name, void *data)
{
    //从全局变量file_systems中找出刚刚注册的"rootfs"的地址
    struct file_system_type *type = get_fs_type(fstype);
    struct vfsmount *mnt;
    if (!type)
        return ERR_PTR(-ENODEV);
    mnt = vfs_kern_mount(type, flags, name, data);   //2.1.1
    put_filesystem(type);                  //空函数
    return mnt;
}

2.1.1 rootfs的mount过程
在fs/namespace.c中

struct vfsmount * vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
{
    struct vfsmount *mnt;
    struct dentry *root;

    if (!type)
        return ERR_PTR(-ENODEV);
    mnt = alloc_vfsmnt(name);                  //申请并初始化vfsmount结构体
    //这儿flags==0
    if (flags & MS_KERNMOUNT)
        mnt->mnt_flags = MNT_INTERNAL;
    root = mount_fs(type, flags, name, data);  //2.1.2
    mnt->mnt_root = root;
    mnt->mnt_sb = root->d_sb;
    mnt->mnt_mountpoint = mnt->mnt_root;
    mnt->mnt_parent = mnt;
    return mnt;
}

2.1.2调用具体文件系统的mount
在fs/super.c中

struct dentry * mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
{
    struct dentry *root;
    struct super_block *sb;
    //file_system_type rootfs_fs_type 中定义.mount = rootfs_mount,
    root = type->mount(type, flags, name, data);    //调用具体文件系统的mount
    sb = root->d_sb;
    sb->s_flags |= MS_BORN;
    up_write(&sb->s_umount);
    return root;
}

2.1.3在fs/ramfs/inode.c中

static struct dentry *rootfs_mount(struct file_system_type *fs_type,
    int flags, const char *dev_name, void *data)
{
    return mount_nodev(fs_type, flags|MS_NOUSER, data, ramfs_fill_super);
}

2.1.4 在fs/super.c中

struct dentry *mount_nodev(struct file_system_type *fs_type, int flags, void *data,
    int (*fill_super)(struct super_block *, void *, int))
{
    struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);   //2.1.5
    s->s_flags = flags;
    error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);   //2.1.6调用ramfs_fill_super,初始化super_block和root
    s->s_flags |= MS_ACTIVE;
    return dget(s->s_root);         //获取在fill_super中初始化好的root
}

2.1.5 分配一个super_block并做初初化

struct super_block *sget(struct file_system_type *type,
            int (*test)(struct super_block *,void *),
            int (*set)(struct super_block *,void *),
            void *data)
{
    struct super_block *s = NULL;
    struct super_block *old;
    int err;
retry:
    if (!s) {
        s = alloc_super(type);        //s是空的就需要分配一个super_block结构体
        if (!s)
            return ERR_PTR(-ENOMEM);
        goto retry;
    }

    err = set(s, data);
    s->s_type = type;
    strlcpy(s->s_id, type->name, sizeof(s->s_id));
    list_add_tail(&s->s_list, &super_blocks);
    list_add(&s->s_instances, &type->fs_supers);
    spin_unlock(&sb_lock);
    get_filesystem(type);
    return s;
}

2.1.6 初始化super_block并初始化root

int ramfs_fill_super(struct super_block *sb, void *data, int silent)
{
    struct ramfs_fs_info *fsi;
    struct inode *inode = NULL;
    struct dentry *root;
    int err;

    save_mount_options(sb, data);

    fsi = kzalloc(sizeof(struct ramfs_fs_info), GFP_KERNEL);
    sb->s_fs_info = fsi;

    err = ramfs_parse_options(data, &fsi->mount_opts);

    sb->s_maxbytes        = MAX_LFS_FILESIZE;
    sb->s_blocksize        = PAGE_CACHE_SIZE;
    sb->s_blocksize_bits    = PAGE_CACHE_SHIFT;
    sb->s_magic        = RAMFS_MAGIC;
    sb->s_op        = &ramfs_ops;
    sb->s_time_gran        = 1;
    //分配inode结构体并初始化inode->i_ino=1
    inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0);
    //初始化root的dentry结构体
    root = d_alloc_root(inode);
    sb->s_root = root;
    return 0;
}

---

二. 真正的文件系统的挂载过程