（转）rootfs_initialize.c

/*
** arm、linux2.6.29
** 该文件不是内核中的文件，只是为了方便分析单独从 linux2.6 ramfs机制解析 中提取出来
** 主要分析的是start_kernel()函数中的vfs_caches_init_early()和vfs_caches_init(num_physpages)
** 他们实现了rootfs的初始化
*/
asmlinkage void __init start_kernel(void)
{
    ...
    vfs_caches_init_early();                    // note 1
    ...
    vfs_caches_init(num_physpages);        // note 2
    ...
}

/** note 1 **/
void __init vfs_caches_init_early(void)
{
    dcache_init_early();                            // 对目录项哈希表进行早期的初始化 note 1-1
    inode_init_early();                                // 对文件节点哈希表进行早期初始化 note 1-2
}

/**** note 1-1 ****/
// fs/dcache.c
static void __init dcache_init_early(void)
{
    int loop;

    /* If hashes are distributed across NUMA nodes, defer
     * hash allocation until vmalloc space is available.
     * 如果hashes需要布局(NUMA),那么就需要在vmalloc空间有效之后再分配hash
     */
    if (hashdist)        // note 1-1-1
        return;
    /* 返回hash表头地址
     * hash table 名字是Dentry cache
     * 哈希表入口项数目numentries值2的对数，保存到d_hash_shif变量。
   * d_hash_mask保存入口项的掩码。
    */
    dentry_hashtable =    // dentry_hashtable是fs/dcache.c中的全局变量  // note 1-1-2
        alloc_large_system_hash("Dentry cache",
                    sizeof(struct hlist_head),
                    dhash_entries,    // note 1-1-3
                    13,
                    HASH_EARLY,
                    &d_hash_shift,
                    &d_hash_mask,
                    0);
    // 对哈希表的每项的链表头进行初始化，->NULL
    for (loop = 0; loop < (1 << d_hash_shift); loop++)
        INIT_HLIST_HEAD(&dentry_hashtable[loop]);
}

/****** note 1-1-1 ******/
// hashdist的历史
// include/linux/bootmem.h
...
/* Only NUMA needs hash distribution.
     只有NUMA才需要hash布局
 * IA64 and x86_64 have sufficient vmalloc space.
      IA64和x86_64拥有充足的vamalloc空间
 */
#if defined(CONFIG_NUMA) && (defined(CONFIG_IA64) || defined(CONFIG_X86_64))
#define HASHDIST_DEFAULT 1
#else
#define HASHDIST_DEFAULT 0
#endif
...
// mm/page_allloc.c定义了hashdist
int hashdist = HASHDIST_DEFAULT;
/*
该值可以采用默认值HASHDIST_DEFAULT，也可以通过cmdline来传递，hashdist=
*/
// page_alloc.c
#ifdef CONFIG_NUMA
static int __init set_hashdist(char *str)
{
    if (!str)
        return 0;
    hashdist = simple_strtoul(str, &str, 0);
    return 1;
}
__setup("hashdist=", set_hashdist);
#endif
/****** note 1-1-1 ******/

/****** note 1-1-2 ******/
// fs/dcache.c z中的静态变量
static struct hlist_head *dentry_hashtable __read_mostly;
// include/liunx/list.h
struct hlist_head {
    struct hlist_node *first;
};
struct hlist_node {
    struct hlist_node *next, **pprev;
};
/****** note 1-1-2 ******/

/****** note 1-1-3 ******/
static __initdata unsigned long dhash_entries;
static int __init set_dhash_entries(char *str)
{
    if (!str)
        return 0;
    dhash_entries = simple_strtoul(str, &str, 0);
    return 1;
}
__setup("dhash_entries=", set_dhash_entries);
/*
这个dhash_entries变量表示目录项哈希表入口数目，默认为0。
可以通过命令行传递参数dhash_entries= 0xxx来指定。
*/
/****** note 1-1-3 ******/
/**** note 1-1 ****/

/**** note 1-2 ****/
// fs/inode.c
static __initdata unsigned long ihash_entries;
static int __init set_ihash_entries(char *str)
{
    if (!str)
        return 0;
    ihash_entries = simple_strtoul(str, &str, 0);
    return 1;
}
__setup("ihash_entries=", set_ihash_entries);

void __init inode_init_early(void)
{
    int loop;

    /* If hashes are distributed across NUMA nodes, defer
     * hash allocation until vmalloc space is available.
     */
    if (hashdist)
        return;
    // alloc_large_system_hash()  // note 1-2-1
    inode_hashtable =
        alloc_large_system_hash("Inode-cache",
                    sizeof(struct hlist_head),
                    ihash_entries,
                    14,
                    HASH_EARLY,
                    &i_hash_shift,
                    &i_hash_mask,
                    0);

    for (loop = 0; loop < (1 << i_hash_shift); loop++)
        INIT_HLIST_HEAD(&inode_hashtable[loop]);
    // #define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
}
// 与对目录项哈希表早期初始化类似，只不过这里是对文件节点inode哈希表初始化
// 该hash的入口项可以通过cmdline参数传递进来，ihash_entries=

/****** note 1-2-1 ******/
/*
参数含义：
tablename         哈希表名字
bucketsize        这个是每个元素的大小
numentries        哈希表入口数，可以取0，或者由cmdline中传入。这时可能即使你给了值，系统也会把它变为最接
                                    近的2的幂
scale                取值有 13、14、15、17 之类的，如果numentries不为0，这个参数没有作用。
lags              可取HASH_EARLY或0，分配内存的地方根据这个有不同
_hash_shift            用于返回元素个数的以2为底的对数，也就是表示元素个数这个数值所用的比特数
_hash_mask        用于返回*_hash_shift个比特所能表示的最大数-1
limit                哈希表表元数上限，不是分配内存的总尺寸，不要弄混了。
                  如果给个0值，那么系统使用1/16内存所能容纳的元素数作为哈希表表元数。    

参数numentries和limit有关系的，参数numentries的值不能超出limit的值
*/
// 下面函数注释中的所有数据均代表创建Inode-cache时所用的数据，所传参数如下：
// ("Inode-cache", 4, 0, 14, HASH_EARLY, &i_hash_shift, &i_hash_mask, 0)
void *__init alloc_large_system_hash(const char *tablename,
                     unsigned long bucketsize,
                     unsigned long numentries,
                     int scale,
                     int flags,
                     unsigned int *_hash_shift,
                     unsigned int *_hash_mask,
                     unsigned long limit)
{
    unsigned long long max = limit;
    unsigned long log2qty, size;
    void *table = NULL;

    /* allow the kernel cmdline to have a say */
    // 如果传递进来的参数numentries==0，进入if体内执行
    if (!numentries) {
        /* round applicable memory size up to nearest megabyte */
        /*
         这个nr_kernel_pages 变量在free_area_init_core（） 函数中赋值，
         表示不包含高端内存的系统内存共有的内存页面数。
         PAGE_SHIFT=12
         计算不包含高端内存的系统内存共有多少MB（不足1MB，以1MB 计算）。
        */
        numentries = nr_kernel_pages;
        numentries += (1UL << (20 - PAGE_SHIFT)) - 1;   // +上1MB中包含的页数
        numentries >>= 20 - PAGE_SHIFT;                                    // 向上对1MB取整
        //取得不足1MB，以1MB计算后的页面数目
        numentries <<= 20 - PAGE_SHIFT;

        /* limit to 1 bucket per 2^scale bytes of low memory */
        // scale = 14 对numentries进行缩放
        if (scale > PAGE_SHIFT)
            numentries >>= (scale - PAGE_SHIFT);                    // numentries >> 2
        else
            numentries <<= (PAGE_SHIFT - scale);

        /* Make sure we've got at least a 0-order allocation.. */
        // 如果numentries个hash入口所占空间不足一个页面的空间，以一个页面的空间来计算出numentries
        if (unlikely((numentries * bucketsize) < PAGE_SIZE))
            numentries = PAGE_SIZE / bucketsize;
    }
    // 向上取最接近目前numentries的2的幂次方的值给numentries
    numentries = roundup_pow_of_two(numentries);

    /* limit allocation size to 1/16 total memory by default */
    //这个max等于limit,如果等于0,就计算numentries的最大值max 
    if (max == 0) {
        /*
        这个nr_all_pages 变量表示所有内存的页面,即哈希表的内存最大为整个内存的1/16的空间。
        */
        max = ((unsigned long long)nr_all_pages << PAGE_SHIFT) >> 4;
        //do_div()宏, 使max除以bucketsize，并把结果赋值给max变量
        do_div(max, bucketsize);
    }
    // 变量numentries不能够大于max变量，即哈希表的入口不能够大于max变量
    if (numentries > max)
        numentries = max;

    log2qty = ilog2(numentries);  //对numentries取2的对数

    do {
        size = bucketsize << log2qty;    /*取得要分配空间的大小*/
        if (flags & HASH_EARLY)
            // 当flags为HASH_EARLY标志时，表示内核没有启动完毕，使用启动内存分配器来分配空间
            table = alloc_bootmem_nopanic(size);
        else if (hashdist)
            // 如果hashdist不等于0 ，从vmalloc空间分配内存
            table = __vmalloc(size, GFP_ATOMIC, PAGE_KERNEL);
        else {
            // 下面的在系统启动完毕后，从buddy内存管理器上分配页面
            unsigned long order = get_order(size);
            table = (void*) __get_free_pages(GFP_ATOMIC, order);
            /*
             * If bucketsize is not a power-of-two, we may free
             * some pages at the end of hash table.
             */
            if (table) {
                unsigned long alloc_end = (unsigned long)table +
                        (PAGE_SIZE << order);
                unsigned long used = (unsigned long)table +
                        PAGE_ALIGN(size);
                split_page(virt_to_page(table), order);
                while (used < alloc_end) {
                    free_page(used);
                    used += PAGE_SIZE;
                }
            }
        }
    } while (!table && size > PAGE_SIZE && --log2qty);

    if (!table)    /* 如果table等于NULL,表示没有足够的空间来进行分配 */
        panic("Failed to allocate %s hash table/n", tablename);

    printk(KERN_INFO "%s hash table entries: %d (order: %d, %lu bytes)/n",
           tablename,
           (1U << log2qty),
           ilog2(size) - PAGE_SHIFT,
           size);
// 返回哈希表入口项数目numentries值2的对数
    if (_hash_shift)
        *_hash_shift = log2qty;
    if (_hash_mask)
        *_hash_mask = (1 << log2qty) - 1;

    return table;            // 返回哈希表入口地址
}

/****** note 1-2-1 ******/

/**** note 1-2 ****/

/*
struct hlist_head {
    struct hlist_node *first;
};

struct hlist_node {
    struct hlist_node *next, **pprev;
};
总结：
    inode_hashtable就是一数组，每个数组元素都是一个struct hlist_head结构体，该结构体实际上就只有一个
指向struct hlist_node对象的指针first，所有指针在arm体系上都是4字节，所以这个函数实际上只是为数组
inode_hashtable分配了一段内存空间，该数组是实际上就是一个指针数组，每个元素都是指向struct hlist_node
对象的指针。然后最后将这些指针全部置成NULL。至于后续怎么使用还没涉及到。
    同样对于Dentry cache哈希表(dentry_hashtable)也是一样的，只是创建了一个指针数组而已。
    参考：http://qgjie456.blog.163.com/blog/static/3545136720081126102615685/
*/
/** note 1 **/

++++++++++++++++++++++++++++++++  vfs_caches_init(num_physpages)  +++++++++++++++++++++
/** note 2 **/
// fs/dcache.c
// 注意：该版本代码是2.6.29 ，和2.6.14的代码该处关于内存分配器有一些差别，就像前文说的，2.6.29引入了
// slub分配器，而2.6.14还是使用的slab，但是接口被保留，实现的功能一样。以下还是以slab称呼
void __init vfs_caches_init(unsigned long mempages)
{
    unsigned long reserve;

    /* Base hash sizes on available memory, with a reserve equal to
           150% of current kernel size */

    reserve = min((mempages - nr_free_pages()) * 3/2, mempages - 1);
    mempages -= reserve;
    
    names_cachep = kmem_cache_create("names_cache", PATH_MAX, 0,
            SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
    // 创建slab高速缓存组names_cache，其中缓存的结构体对象大小是PATH_MAX = 4096
    // 这里与2.6.14版本不同的是，filp高速缓存组没有被创建。
    // 返回描述该高速缓存的一个结构体指针names_cachep

    dcache_init();        // slab高速缓存组创建，注册dcache页面回收函数 note 2-1
    inode_init();            // slab高速缓存组创建，注册icache页面回收函数 note 2-2
    files_init(mempages); // note 2-3
    mnt_init();                        /* 重要函数，挂载rootfs文件系统 */ // note 2-4
    bdev_cache_init();
    chrdev_init();
}

/**** note 2-1 ****/
static void __init dcache_init(void)
{
    int loop;

    /* 
     * A constructor could be added for stable state like the lists,
     * but it is probably not worth it because of the cache nature
     * of the dcache. 
     */
    dentry_cache = KMEM_CACHE(dentry,
        SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD);
    /*
        static struct kmem_cache *dentry_cache __read_mostly;
        #define KMEM_CACHE(__struct, __flags) kmem_cache_create(#__struct,/
                sizeof(struct __struct), __alignof__(struct __struct),/
                (__flags), NULL)
                
        可以看出，这里是创建了一个名字为dentry的slab高速缓存组，由指针dentry_cache指向的结构体描述
    */
    
    register_shrinker(&dcache_shrinker);
    // 注册dcache页面回收函数shrink_dcache_memory，由页面回收算法(PFRA)来执行

    /* Hash may have been set up in dcache_init_early */
    if (!hashdist)
        return;

...    // 该部分的工作在dcache_init_early中完成
}
/**** note 2-1 ****/

/**** note 2-2 ****/
void __init inode_init(void)
{
    int loop;

    /* inode slab cache */
    inode_cachep = kmem_cache_create("inode_cache",
                     sizeof(struct inode),
                     0,
                     (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|
                     SLAB_MEM_SPREAD),
                     init_once);
    // 创建了一个名字为inode_cache的slab高速缓存组，由指针inode_cachep指向的结构体描述
    register_shrinker(&icache_shrinker);
    // 注册icache页面回收函数shrink_icache_memory，由页面回收算法(PFRA)来执行

    /* Hash may have been set up in inode_init_early */
    if (!hashdist)
        return;
...    // 该部分的工作在icache_init_early中完成
}
/**** note 2-2 ****/

/**** note 2-3 ****/
void __init files_init(unsigned long mempages)
{ 
    int n; 

    filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
            SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
            // 创建名为filp的slab高速缓存组，格式化成struct file，由指针filp_cachep指向的结构体描述该高缓

    /*
     * One file with associated inode and dcache is very roughly 1K.
     * Per default don't use more than 10% of our memory for files. 
     */ 

    n = (mempages * (PAGE_SIZE / 1024)) / 10;
    files_stat.max_files = n; 
    if (files_stat.max_files < NR_FILE)
        files_stat.max_files = NR_FILE;
    files_defer_init();                                        // 这两个函数做什么用的，暂时不管
    percpu_counter_init(&nr_files, 0);
} 
/**** note 2-3 ****/

/**** note 2-4 ****/
void __init mnt_init(void)
{
    unsigned u;
    int err;

    init_rwsem(&namespace_sem);

    mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct vfsmount),
            0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
    // 创建名为mnt_cache的slab高速缓存，格式化成struct vfsmount，由指针mnt_cache指向的结构体描述

    mount_hashtable = (struct list_head *)__get_free_page(GFP_ATOMIC);
    // 必须分配到一页物理内存

    if (!mount_hashtable)
        panic("Failed to allocate mount hash table/n");

    printk("Mount-cache hash table entries: %lu/n", HASH_SIZE);
    // HASH_SIZE = 512
    for (u = 0; u < HASH_SIZE; u++)
        INIT_LIST_HEAD(&mount_hashtable[u]);
    // 初始化next和prev均指向其自身
    
    err = sysfs_init();    /* sysfs文件系统注册 in fs/sysfs/mount.c*/
    if (err)
        printk(KERN_WARNING "%s: sysfs_init error: %d/n",
            __func__, err);
    fs_kobj = kobject_create_and_add("fs", NULL);
    // 在sysfs目录下创建fs目录，主要是创建名为fs的kobject及相关初始化
    if (!fs_kobj)
        printk(KERN_WARNING "%s: kobj create error/n", __func__);
    init_rootfs();    /* rootfs文件系统注册 in fs/ramfs/inode.c*/
    init_mount_tree();/* 为VFS建立根目录 "/" */   // note 2-4-1
    /* 挂载rootfs文件系统。它的挂载点默认为"/",最后切换进程的根目录和当前目录为"/" */
}

/**** note 2-4 ****/
/****** note 2-4-1 init_mount_tree()******/
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);    // note 2-4-1-1
    /* 重要函数 挂载前面已经注册进内核的rootfs文件系统*/
    if (IS_ERR(mnt))
        panic("Can't create rootfs");
    ns = kmalloc(sizeof(*ns), GFP_KERNEL);
    if (!ns)
        panic("Can't allocate initial namespace");
    atomic_set(&ns->count, 1);
    // 设置引用计数
    INIT_LIST_HEAD(&ns->list);
    init_waitqueue_head(&ns->poll);
    ns->event = 0;
    list_add(&mnt->mnt_list, &ns->list);
    // 将该vfsmount结构体挂接到namespace结构体的链表中
    ns->root = mnt;
    // 该命名空间的root目录为刚刚建立的vfsmount结构体
    mnt->mnt_ns = ns;
    // 该vfsmount结构体的命名空间为ns

    init_task.nsproxy->mnt_ns = ns;
    get_mnt_ns(ns);
    /* 
        init_mount_tree() 函数会为系统最开始的进程(即 init_task 进程)
        准备它的进程数据块中的namespace 域，主要目的是将 do_kern_mount()
        函数中建立的 mnt 和 dentry 信息记录在了 init_task 进程的进程数据块中，
        这样所有以后从 init_task 进程 fork 出来的进程也都先天地继承了这一信息
    */

    root.mnt = ns->root;
    root.dentry = ns->root->mnt_root;

    set_fs_pwd(current->fs, &root);
    set_fs_root(current->fs, &root);
    /*
    最后两行便是将 do_kern_mount() 函数中建立的 mnt 和 dentry 信息记录在了当前进程的 fs结构中
    */
}
/******** note 2-4-1-1 do_kern_mount() ********/
struct vfsmount *
do_kern_mount(const char *fstype, int flags, const char *name, void *data)
{
    struct file_system_type *type = get_fs_type(fstype);    // 获取全局链表file_system中名为fstype的文件系统
                                                                                                                // 结构体指针
    struct vfsmount *mnt;
    
    if (!type)
        return ERR_PTR(-ENODEV);
    mnt = vfs_kern_mount(type, flags, name, data);                // note 2-4-1-1-1
            // 重要函数
    if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
        !mnt->mnt_sb->s_subtype)
        mnt = fs_set_subtype(mnt, fstype);
    put_filesystem(type);        // wake_up_process()
    return mnt;
}

/********** note 2-4-1-1-1 vfs_kern_mount() **********/
struct vfsmount *
vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
{
    struct vfsmount *mnt;
    char *secdata = NULL;
    int error;

    if (!type)
        return ERR_PTR(-ENODEV);        // 参数验证

    error = -ENOMEM;
    mnt = alloc_vfsmnt(name);
    /*在slab高速缓存组mnt_cache中分配一个vfsmount对象,并对其进行初始化*/
    if (!mnt)
        goto out;

    if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
        secdata = alloc_secdata();
        if (!secdata)
            goto out_mnt;

        error = security_sb_copy_data(data, secdata);
        if (error)
            goto out_free_secdata;
    }

    error = type->get_sb(type, flags, name, data, mnt);    // note 2-4-1-1-1-1 ，以rootfs为例
    /* 文件系统超级块的回调函数 */
    /* rootfs_get_sb
    一般的伪文件系统或叫内存文件系统分配超级块都是调用get_sb_nodev()或者
    get_sb_single(); 而实际文件系统如磁盘文件系统,在分配超级块的时候则调
    用get_sb_bdev()需要在具体块设备上建立超级块。
    因为rootfs是内存文件系统所以调用get_sb_nodev();
    */
    if (error < 0)
        goto out_free_secdata;
    BUG_ON(!mnt->mnt_sb);

     error = security_sb_kern_mount(mnt->mnt_sb, flags, secdata);    
     if (error)
         goto out_sb;

    mnt->mnt_mountpoint = mnt->mnt_root;    //指明挂载点，其实就是刚才建立的”/”目录
    mnt->mnt_parent = mnt;                                //父对象是自己
    up_write(&mnt->mnt_sb->s_umount);
    free_secdata(secdata);
    return mnt;
out_sb:
    dput(mnt->mnt_root);
    up_write(&mnt->mnt_sb->s_umount);
    deactivate_super(mnt->mnt_sb);
out_free_secdata:
    free_secdata(secdata);
out_mnt:
    free_vfsmnt(mnt);
out:
    return ERR_PTR(error);
}
/************ note 2-4-1-1-1-1 超级块回调函数 ************/
// rootfs文件系统的超级块回调函数是rootfs_get_sb()
static int rootfs_get_sb(struct file_system_type *fs_type,
    int flags, const char *dev_name, void *data, struct vfsmount *mnt)
{
    return get_sb_nodev(fs_type, flags|MS_NOUSER, data, ramfs_fill_super,
                mnt);    // note 2-4-1-1-1-1-1
}
// ramfs_fill_super()是超级块填充函数
/************** note 2-4-1-1-1-1-1 get_sb_nodev() **************/
int get_sb_nodev(struct file_system_type *fs_type,
    int flags, void *data,
    int (*fill_super)(struct super_block *, void *, int),
    struct vfsmount *mnt)
{
    int error;
    struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
    /* 在内存中分配一个超级块，并做相应初始化*/
    // set_anon_super为回调函数
    if (IS_ERR(s))
        return PTR_ERR(s);

    s->s_flags = flags;      // flags = MS_NOUSER

    error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);    // note 2-4-1-1-1-1-1-1
    // 执行填充超级块的回调函数 ramfs_fill_super
    if (error) {
        up_write(&s->s_umount);
        deactivate_super(s);
        return error;
    }
    s->s_flags |= MS_ACTIVE;
    return simple_set_mnt(mnt, s);    /* 超级块和文件系统挂载结构体简单关联 */
                                                                    // mnt->mnt_sb = sb;
                                                                    // mnt->mnt_root = dget(sb->s_root);
}
/**************** note 2-4-1-1-1-1-1-1 fill_super = ramfs_fill_super() ****************/
static int ramfs_fill_super(struct super_block * sb, void * data, int silent)
{
    struct inode * inode;
    struct dentry * root;

    sb->s_maxbytes = MAX_LFS_FILESIZE;    /* 文件的最大值 */
    sb->s_blocksize = PAGE_CACHE_SIZE;    /* 以字节为单位的块的大小 */
    sb->s_blocksize_bits = PAGE_CACHE_SHIFT;    /* 以位为单位的块的大小 */
    sb->s_magic = RAMFS_MAGIC;    /* 文件系统的魔数 0x858458f6 */
    sb->s_op = &ramfs_ops;            /* 超级块的方法 ,在处理inode的时候会有用 */
    sb->s_time_gran = 1;
    inode = ramfs_get_inode(sb, S_IFDIR | 0755, 0);/* 建立根目录索引节点 */ // note 2-4-1-1-1-1-1-1-1
    if (!inode)
        return -ENOMEM;

    root = d_alloc_root(inode);/* 建立根目录目录对象，并关联上inode */ // note 2-4-1-1-1-1-1-1-2
    if (!root) {
        iput(inode);
        return -ENOMEM;
    }
    sb->s_root = root;                /* 超级块的s_root指向刚建立的根目录对象 */
    return 0;
}
/****************** note 2-4-1-1-1-1-1-1-1 ramfs_get_inode() ******************/
struct inode *ramfs_get_inode(struct super_block *sb, int mode, dev_t dev)
{
    struct inode * inode = new_inode(sb);
    /* 在索引节点高速缓存inode_cachep中创建一个inode, 并初始化话相应的域*/

    if (inode) {
        inode->i_mode = mode;/* 文件的类型 */
        inode->i_uid = current->fsuid;
        inode->i_gid = current->fsgid;
        inode->i_blksize = PAGE_CACHE_SIZE;
        inode->i_blocks = 0;//文件的块数
        inode->i_mapping->a_ops = &ramfs_aops;
        inode->i_mapping->backing_dev_info = &ramfs_backing_dev_info;
        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
        switch (mode & S_IFMT) {//判断文件类型
        default:
            init_special_inode(inode, mode, dev);
            //特殊文件;如:字符~块设备文件,FIFO,SOCKET文件
            break;
        case S_IFREG://普通文件
            inode->i_op = &ramfs_file_inode_operations;//索引节点的操作方法
            inode->i_fop = &ramfs_file_operations;// 缺省普通文件的操作方法
            break;
        case S_IFDIR:// 目录文件
            inode->i_op = &ramfs_dir_inode_operations;
            inode->i_fop = &simple_dir_operations; // 目录文件的操作方法

            /* directory inodes start off with i_nlink == 2 (for "." entry) */
            inode->i_nlink++;
            break;
        case S_IFLNK: //符号链接
            inode->i_op = &page_symlink_inode_operations;
            break;
        }
    }
    return inode;             //返回创建的inode与对应的目录项对象关联
}
/****************** note 2-4-1-1-1-1-1-1-1 ramfs_get_inode() ******************/
/****************** note 2-4-1-1-1-1-1-1-2 d_alloc_root() ******************/
struct dentry * d_alloc_root(struct inode * root_inode)
{
    struct dentry *res = NULL;

    if (root_inode) {
        static const struct qstr name = { .name = "/", .len = 1 };
        /* 看到根目录的符号了吧 */
        res = d_alloc(NULL, &name);
        if (res) {
            res->d_sb = root_inode->i_sb;    //指向该文件系统的超级块
            res->d_parent = res;                    //根目录的父亲当然是它自己了
            d_instantiate(res, root_inode); // note 2-4-1-1-1-1-1-1-2-1
            //将dentry 和 inode关联上
        }
    }
    return res;
}

/******************** note 2-4-1-1-1-1-1-1-2-1 d_instantiate() ********************/
void d_instantiate(struct dentry *entry, struct inode * inode)
{
    if (!list_empty(&entry->d_alias)) BUG();
    //一个目录项对象只能关联一个索引节点
    spin_lock(&dcache_lock);
    if (inode)
        list_add(&entry->d_alias, &inode->i_dentry);
        //一个索引节点可以关联多个目录项对象
    entry->d_inode = inode;
    spin_unlock(&dcache_lock);
    security_d_instantiate(entry, inode);
}
/******************** note 2-4-1-1-1-1-1-1-2-1 d_instantiate() ********************/

/****************** note 2-4-1-1-1-1-1-1-2 d_alloc_root() ******************/

/**************** note 2-4-1-1-1-1-1-1 fill_super = ramfs_fill_super() ****************/



/************** note 2-4-1-1-1-1-1 get_sb_nodev() **************/

/************ note 2-4-1-1-1-1 超级块回调函数 ************/

/********** note 2-4-1-1-1 vfs_kern_mount() **********/


/******** note 2-4-1-1 do_kern_mount() ********/
/****** note 2-4-1 init_mount_tree()******/

/** note 2 **/