引言：在linux系統中，一直對根檔案系統理解得模稜兩可，是時候徹底梳理一下了，包括根檔案系統是什麼 、如何初始化、如何應用及Android系統中的根檔案系統等問題。

首先要弄清楚根檔案系統是什麼？以下英文部分摘自
Kernel_2.3.6\Documentation\filesystemsramfs-rootfs-initramfs.txt

What is rootfs?
Rootfs is a special instance of ramfs (or tmpfs, if that’s enabled), which is always present in 2.6 systems. You can’t unmount rootfs for approximately the same reason you can’t kill the init process; rather than having special code to check for and handle an empty list, it’s smaller and simpler for the kernel to just make sure certain lists can’t become empty.
Most systems just mount another filesystem over rootfs and ignore it. The amount of space an empty instance of ramfs takes up is tiny.

What is ramfs?
Ramfs is a very simple filesystem that exports Linux’s disk caching mechanisms (the page cache and dentry cache) as a dynamically resizable RAM-based filesystem.

根據linux文件可以看出，rootfs是ramfs或tmpfs的一種例項，它不能被umount，對於核心而言，rootfs體積小且簡單，主要用於確保某些lists不能為空。大部分系統將在rootfs掛載另一種檔案系統，ramfs一個空例項的佔用空間的總量花銷很少。
其中，lists 不好翻譯，我的理解為目錄。這裡提到了ramfs和tmpfs，ramfs是一種非常簡單的RAM系統，它基於linux系統硬碟緩衝機制，可以動態改變大小。

這裡可以看出根檔案系統的一些簡單特性，首先它也是一種檔案系統，即提供讀、寫、掛載等常規操作。其作用主要管理一些目錄（目錄也是一種檔案），而Linux系統正常執行嚴重依賴這些目錄。如核心0.11對rootfs至少需要/etc,/bin,/dev,/home等。

1.根檔案系統初始化

對rootfs有了基本的瞭解後，需要進一步知道rootfs執行起來的流程。從核心init程序出發開始探索：

asmlinkage void __init start_kernel(void)
    vfs_caches_init_early();
        dcache_init_early();
        inode_init_early();
    --> vfs_caches_init(num_physpages);
        dcache_init();
        inode_init();
        files_init(mempages);
        --> mnt_init();
            --> init_rootfs();
            --> init_mount_tree();
 

以上程式碼中，從start_kernel開始，初始化虛擬檔案系統，包括dcache、inode初始，建立核心物件fs，然後開始初始化rootfs。

Inode.c (fs\ramfs):int __init init_rootfs(void)
int __init init_rootfs(void)
{
    int err;
    err = bdi_init(&ramfs_backing_dev_info);
    err = register_filesystem(&rootfs_fs_type);
    return err;
}

在init_rootfs()中，註冊rootfs檔案型別，主要作用是把rootfs加入核心維護的一個檔案系統型別的連結串列中，同時供其它模組進行系統呼叫。接著再看函式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);
    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);
    ns->root = mnt;
    mnt->mnt_ns = ns;

    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);
    --> set_fs_root(current->fs, &root);
}

關鍵函式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);
    struct vfsmount *mnt;
    if (!type)
        return ERR_PTR(-ENODEV);
    --> mnt = vfs_kern_mount(type, flags, name, data);
    if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
        !mnt->mnt_sb->s_subtype)
        mnt = fs_set_subtype(mnt, fstype);
    put_filesystem(type);
    return mnt;
}

do_kern_mount這個過程，呼叫vfs_kern_mount得到一個vfsmount結構，其中type為rootfs_fs_type

struct vfsmount *
vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
{
    struct vfsmount *mnt;
    --> error = type->get_sb(type, flags, name, data, mnt);

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

這裡會呼叫Inode.c (fs\ramfs):static int rootfs_get_sb(struct file_system_type *fs_type)，進而呼叫到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);
    s->s_flags = flags;
    --> error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
    if (error) {
        up_write(&s->s_umount);
        deactivate_super(s);
        return error;
    }
    s->s_flags |= MS_ACTIVE;
    return simple_set_mnt(mnt, s);

在get_sb_nodev中，用sget獲得一個超級塊s，並初始化超級塊s的flags，然後呼叫fill_super

static int fill_super(struct super_block *sb, void *data, int silent)
{
    static struct tree_descr files[] = {{""}};
    --> return simple_fill_super(sb, SECURITYFS_MAGIC, files);
}
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);
        }
    }
    return res;
}

程式碼路徑：Inode.c (security):static int fill_super()
在對超級塊填充過程中，首先會分配一個inode對像，然後分配根目錄 /， 這就是我們看到的根目錄符號。後邊的目錄項分配會以根目錄開始，呈樹狀延伸。再次回到這兩個函式：
set_fs_pwd(current->fs, &root);
set_fs_root(current->fs, &root);
作用是把init程序的當前目錄和root目錄設為檔案系統的根目錄，即根檔案系統。至此rootfs流程完畢，但此時的rootfs是ramfs，這些資料掉電丟失，在根檔案系統下要永久儲存一些檔案，就需要把根檔案系統安裝到實際硬碟或flash中。

2.虛擬根檔案系統與真實根檔案系統

簡單的說，一個檔案系統對應著一塊儲存區域，虛擬根檔案系統對應的儲存區域為記憶體ram，而直根檔案系統對應的儲存區域為 硬碟或flash，根據前面介紹，在系統初始化期間，先掛載的是虛擬根檔案系統。那麼這裡有兩個疑問，為什麼不直接掛載真實根檔案系統？真實根檔案系統又是什麼時機掛載上去的？

對根檔案系統和整個核心的啟動，這兩個問題都顯得相當重要。對於第一個問題，先舉個例子，假如直接將硬碟的一個ext4格式的分割槽（/dev/sda1）掛載為根檔案系統，可以這樣示意：mount -t ext4 /dev/sda1 /
但是在系統初始化時，/dev這個目錄從何而來？sda1這個分割槽是否就緒了？這樣就從反面說明了核心初始化時只能先掛載虛擬根檔案系統，然後在一個合適的時機掛載真實的根檔案系統。這個時機至少是當/dev/sda1準備就緒。

繼續檢視kernel_init程式碼：

static int __init kernel_init(void * unused)
{
    --> do_basic_setup();

    /*
     * check if there is an early userspace init.  If yes, let it do all
     * the work
     */

    if (!ramdisk_execute_command)
        --> ramdisk_execute_command = "/init";

    if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
        ramdisk_execute_command = NULL;
        --> prepare_namespace();
    }

    /*
     * Ok, we have completed the initial bootup, and
     * we're essentially up and running. Get rid of the
     * initmem segments and start the user-mode stuff..
     */

    init_post();
    return 0;
}

上邊說到至少實際儲存區域要準備好，這裡就稍微有點複雜，先看下do_basic_setup這個函式：

static void __init do_basic_setup(void)
{
    rcu_init_sched(); /* needed by module_init stage. */
    init_workqueues();
    usermodehelper_init();
    --> river_init();
    init_irq_proc();
    do_initcalls();
}
void __init driver_init(void)
{
    /* These are the core pieces */
    --> devices_init();
    buses_init();
    classes_init();
}
int __init devices_init(void)
{
    devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
    if (!devices_kset)
        return -ENOMEM;
    --> dev_kobj = kobject_create_and_add("dev", NULL);
    if (!dev_kobj)
        goto dev_kobj_err;
    sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
    if (!sysfs_dev_block_kobj)
        goto block_kobj_err;
    sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
    if (!sysfs_dev_char_kobj)
        goto char_kobj_err;

    return 0;
}

根據函式呼叫來到devices_init中，可以看到devices、dev、block、char等核心物件的建立，但這些物件是建立在/sys目錄下，而根目錄下的/dev仍沒出現。關鍵在於這個函式do_initcalls，

static void __init do_initcalls(void)
{
    initcall_t *call;

    for (call = __early_initcall_end; call < __initcall_end; call++)
        --> do_one_initcall(*call);
}

define rootfs_initcall(fn) __define_initcall("rootfs",fn,rootfs)

可以看到，從t__early_initcall_end到__initcall_end段的函式會被呼叫。經過一些處理rootfs_initcall(populate_rootfs)這類函式會被呼叫。在程式碼init路徑下有兩個檔案initramfs.c和noinitramfs.c，對於noinitramfs.c有：

static int __init default_rootfs(void)
{
    int err;

    --> err = sys_mkdir("/dev", 0755);
    if (err < 0)
        goto out;

    err = sys_mknod((const char __user *) "/dev/console",
            S_IFCHR | S_IRUSR | S_IWUSR,
            new_encode_dev(MKDEV(5, 1)));
    if (err < 0)
        goto out;

    err = sys_mkdir("/root", 0700);
    if (err < 0)
        goto out;

    return 0;
}
rootfs_initcall(default_rootfs);

對於initramfs.c有：

static int __init populate_rootfs(void)
{
    char *err = unpack_to_rootfs(__initramfs_start,
             __initramfs_end - __initramfs_start, 0);
    if (err)
        panic(err);
    if (initrd_start) {
#ifdef CONFIG_BLK_DEV_RAM
        int fd;
        printk(KERN_INFO "checking if image is initramfs...");
        err = unpack_to_rootfs((char *)initrd_start,
            initrd_end - initrd_start, 1);
        if (!err) {
            printk(" it is\n");
            unpack_to_rootfs((char *)initrd_start,
                initrd_end - initrd_start, 0);
            free_initrd();
            return 0;
        }
        printk("it isn't (%s); looks like an initrd\n", err);
        fd = sys_open("/initrd.image", O_WRONLY|O_CREAT, 0700);
        if (fd >= 0) {
            sys_write(fd, (char *)initrd_start,
                    initrd_end - initrd_start);
            sys_close(fd);
            free_initrd();
        }
#else
        printk(KERN_INFO "Unpacking initramfs...");
        err = unpack_to_rootfs((char *)initrd_start,
            initrd_end - initrd_start, 0);
        if (err)
            panic(err);
        printk(" done\n");
        free_initrd();
#endif
    }
    return 0;
}
rootfs_initcall(populate_rootfs);</span>

這兩個函式會根據CONFIG_BLK_DEV_INITRD配置，決定是否被呼叫。對於noinitramfs，可以清楚的看到/dev目錄的建立。由於時間關係，對於initramfs、真實根檔案系統掛載和Android根檔案系統相關內容留著下次再寫。—2016.04.30 00：40