ARM Linux启动流程-根文件系统的加载

前言

　　在Kernel启动的初始阶段，首先去创建虚拟的根文件系统(rootfs)，接下来再去调用do_mount来加载真正的文件系统，并将根文件系统切换到真正的文件系统，也即真实的文件系统。
　　接下来结核内核代码(内核版本：linux-3.14.28)，讲解整个流程。

1、文件系统的分类

　　文件系统大体可以分为基于内存的文件系统(initrd)和非基于内存的文件系统(noinitrd)，想要了解根文件系统的挂载流程，首先要了解各种文件的特性及使用方法。
　　rootfs: 一个基于内存的文件系统，是linux在初始化时加载的第一个文件系统。
　　realfs: 用户最终使用的真正的文件系统。
　　initramfs: 在内核镜像中附加一个cpio包，这个cpio包中包含了一个小型的文件系统，当内核启动时，内核将这个cpio包解开，并且将其中包含的文件系统释放到rootfs中，内核中的一部分初始化代码会放到这个文件系统中，作为用户层进程来执行。这样带来的明显的好处是精简了内核的初始化代码，而且使得内核的初始化过程更容易定制。Linux 2.6.12内核的initramfs还没有什么实质性的东西，一个包含完整功能的initramfs的实现可能还需要一个缓慢的过程。
　　cpio-initrd: cpio格式的initrd。一般作为最终的根文件系统。
　　image-initrd: 专指传统的文件镜像格式的initrd，如ext2格式。可以作为最终的根文件系统，也可以作为过渡，由Image-initrd里的init来加载最终的根文件系统。
　　noinitrd: 如jffs2，yaffs2等格式的根文件系统，作为最终的根文件系统。

2、initrd的处理流程

　　initrd有CPIO-initrd和Image-initrd两种格式，取决于制作initrd文件系统映像的工具和方法。initramfs是内核自动生成的一个简单的CPIO-initrd。
　　initramfs的处理流程:
　　1.如果内核支持initrd，但是并没有配置CONFIG_INITRAMFS_SOURCE选项的话，内核在编译的时候会自动生成一个最小的cpio包附在内核中(这个cpio包的内容与由default_rootfs生成的一样)，除非你使用了ramdisk作为文件系统，否则内核按initramfs文件系统启动。
　　2.将initramfs的内容释放到rootfs中。
　　3.挂载真实的文件系统。
　　cpio-initrd 的处理流程：
　　1.bootloader 把内核以及 initrd 文件系统分别加载到内存的特定位置。然后启动内核，并告诉内核initrd在内存的位置。
　　2.内核判断initrd的文件格式，如果是cpio格式。
　　3.将initrd的内容释放到rootfs中。即这时候rootfs就是真正的根文件系统。
　　4.执行initrd中的/init文件，执行到这一点，内核的工作全部结束，完全交给/init文件处理。
　　image-initrd的处理流程：
　　1.bootloader 把内核以及 initrd 文件系统分别加载到内存的特定位置。然后启动内核，并告诉内核initrd在内存的位置
　　2.内核判断initrd的文件格式，如果不是cpio格式，将其作为image-initrd处理。
　　3.内核将initrd的内容保存在rootfs下的/initrd.image文件中。
　　4.内核将/initrd.image的内容读入/dev/ram0设备中，也就是读入了一个内存盘中。
　　5.接着内核以可读写的方式把/dev/ram0设备挂载为原始的根文件系统。
　　6.执行initrd上的/linuxrc文件，linuxrc通常是一个脚本文件，负责加载内核访问根文件系统必须的驱动， 以及加载根文件系统。
　　7.如果/dev/ram0被指定为真正的根文件系统，那么内核跳至最后一步（即第9步）正常启动。
　　8.否则, 将真实根文件系统（如/dev/mtdblock3或nfs）挂载到rootfs下。
　　9.在常规根文件系统上进行正常启动过程 ，执行/sbin/init。
　　二者比较：
　　１、cpio-initrd的处理流程更加简单，并没有使用额外的ramdisk，而是将其内容直接输入到rootfs中，其实rootfs本身也是一个基于内存的文件系统。这样就省掉了ramdisk的挂载、卸载等步骤。cpio-initrd不再象image-initrd那样作为linux内核启动的一个中间步骤，而是作为内核启动的终点，内核将控制权交给cpio-initrd的/init文件后，内核的任务就结束了，所以在/init文件中，我们可以做更多的工作，而不比担心同内核后续处理的衔接问题。
　　２、而对于image-initrd，如果最终的真实根文件系统不在Root_RAM0（比如在/dev/mtdblock3或nfs），则内核在执行完image-initrd 里的/linuxrc进程后，还要进行一些收尾工作。并挂载最终执行真正的根文件系统和执行最终真正根文件系统里的init。如果最终的真实根文件系统在Root_RAM0，则挂载最终执行真正的根文件系统和执行最终真正根文件系统里的init。

3、整体流程解读

　3.1 根文件系统的注册

　　首先不得不从老掉牙的Linux系统的函数start_kernel()说起。函数start_kernel()中会去调用vfs_caches_init()来初始化VFS。

void __init vfs_caches_init(unsigned long mempages) 
{ 
      …
      //创建一个rootfs，这是个虚拟的rootfs，即内存文件系统，后面还会指向真实的文件系统 
      mnt_init(); 
}

void __init mnt_init(void) 
{
       …
       //创建虚拟根文件系统（调用register_filesystem(&rootfs_fs_type)注册rootfs，即根文件系统）； 
       init_rootfs(); 

       /*******************************************************************************
       *挂载根文件系统（”/”其实这只是个空目录，是后面挂载实际根文件系统的根节点）。 
       *init_mount_tree会调用 vfs_kern_mount(“rootfs”, 0, “rootfs”, NULL)为 VFS 建立根目
       *录“/”，而一旦有了根，那么这棵数就可以发展壮大。同时挂载前面已经注册了的 rootfs 文件系统到
       *根目录“/”下。最后调用set_fs_pwd和set_fs_root切换进程的根目录和当前目录为”/”.这也就是根
       *目录的由来 
       ********************************************************************************/
       init_mount_tree(); 
} 

　　这个流程如下图所示：

　3.２ 根文件系统的初始化

　3.2.1 noinitrd初始化流程

　　针对noinitrd的情况，初始化一个简单的rootfs。主要往里面创建两个目录/dev和/root，还有一个结点/dev/console。

/*
 * Create a simple rootfs that is similar to the default initramfs
 */
static int __init default_rootfs(void)
{
    int err;

    err = sys_mkdir((const char __user __force *) "/dev", 0755);
    if (err < 0)
        goto out;

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

    err = sys_mkdir((const char __user __force *) "/root", 0700);
    if (err < 0)
        goto out;

    return 0;

out:
    printk(KERN_WARNING "Failed to create a rootfs\n");
    return err;
}
rootfs_initcall(default_rootfs);

　3.2.2initrd初始化流程

　　（１）当内核支持initrd时，rootfs_initcall调用initramfs.c中的populate_rootfs()函数。
　　针对initrd的情况，在kernel启动之前，uboot会把initrd映像(即真实根文件系统)拷贝到外部sram的指定位置。
　　如果是cpio-initrd，则直接填充到rootfs根目录下，这时rootfs即从vfs变成真实的根文件系统。
　　如果是Image-initrd，则Image-initrd里面的内容保存到/initrd.image里面。
　　unpack_to_rootfs顾名思义，就是解压包到rootfs文件系统中。

static int __init populate_rootfs(void)
{
    char *err = unpack_to_rootfs(__initramfs_start, __initramfs_size);
    if (err)
        panic("%s", err); /* Failed to decompress INTERNAL initramfs */
        /**********************************
        *如果内核支持initrd，但是并没有配置CONFIG_INITRAMFS_SOURCE选项的话,
        *initrd_start为０。
        ***********************************/
    if (initrd_start) {
/************************
*支持ramdisk的话，必须定义宏CONFIG_BLK_DEV_RAM
************************/
#ifdef CONFIG_BLK_DEV_RAM
        int fd;
        printk(KERN_INFO "Trying to unpack rootfs image as initramfs...\n");
        err = unpack_to_rootfs((char *)initrd_start,
            initrd_end - initrd_start);
        if (!err) {
            free_initrd();
            goto done;
        } else {
            clean_rootfs();
            unpack_to_rootfs(__initramfs_start, __initramfs_size);
        }
        printk(KERN_INFO "rootfs image is not initramfs (%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();
        }
    done:
#else
        printk(KERN_INFO "Unpacking initramfs...\n");
        err = unpack_to_rootfs((char *)initrd_start,
            initrd_end - initrd_start);
        if (err)
            printk(KERN_EMERG "Initramfs unpacking failed: %s\n", err);
        free_initrd();
#endif
        /*
         * Try loading default modules from initramfs.  This gives
         * us a chance to load before device_initcalls.
         */
        load_default_modules();
    }
    return 0;
}
rootfs_initcall(populate_rootfs);

　　（２）检测根文件系统中是否存在ramdisk_execute_command文件。
　　这个值由uboot传给内核的参数中rdinit=指定，如果未指定则采用默认的/init。如果ramdisk_execute_command文件不存在则执行prepare_namespace()挂载根文件系统。
　　如果是cpio-initrd，populate_rootfs已经成功解压cpio-initrd到rootfs中，这种情况下rootfs就是真实的根文件系统，所以这时一般会存在ramdisk_execute_command。
　　如果是Image-initrd或者noinitrd的情况，一般不会存在ramdisk_execute_command，所以执行prepare_namespace()挂载根文件系统。
　　start_kernel->rest_init->kernel_init->kernel_init_freeable

static noinline void __init kernel_init_freeable(void)
{
    /*
     * Wait until kthreadd is all set-up.
     */
    wait_for_completion(&kthreadd_done);

    /* Now the scheduler is fully set up and can do blocking allocations */
    gfp_allowed_mask = __GFP_BITS_MASK;

    /*
     * init can allocate pages on any node
     */
    set_mems_allowed(node_states[N_MEMORY]);
    /*
     * init can run on any cpu.
     */
    set_cpus_allowed_ptr(current, cpu_all_mask);

    cad_pid = task_pid(current);

    smp_prepare_cpus(setup_max_cpus);

    do_pre_smp_initcalls();
    lockup_detector_init();

    smp_init();
    sched_init_smp();

    do_basic_setup();

    /* Open the /dev/console on the rootfs, this should never fail */
    if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
        pr_err("Warning: unable to open an initial console.\n");

    (void) sys_dup(0);
    (void) sys_dup(0);
    /*
     * 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..
     */

    /* rootfs is available now, try loading default modules */
    load_default_modules();
}

　　（３）挂载真实的根文件系统，并把真实的根文件系统的根目录作为进程的根目录。本函数的具体流程，请看注释。

void __init prepare_namespace(void)
{
    int is_floppy;

　　/*************************
　　*对于将根文件系统存在usb或者scsi的情况，
　　*kernel需要等待这些耗费时间比较久的驱动
　　*加载完毕，所以这里存在一个delay。
　　*************************/
    if (root_delay) {
        printk(KERN_INFO "Waiting %d sec before mounting root device...\n",
               root_delay);
        ssleep(root_delay);
    }

    /*
     * wait for the known devices to complete their probing
     *
     * Note: this is a potential source of long boot delays.
     * For example, it is not atypical to wait 5 seconds here
     * for the touchpad of a laptop to initialize.
     */
    /********************
    *等待根文件系统所在的设备的探测函数的完成。
    ********************/
    wait_for_device_probe();

    md_run_setup();

        /******************************
        *saved_root_name是uboot传进来的参数root=/dev/mtdblock3
        ******************************/
    if (saved_root_name[0]) {
        root_device_name = saved_root_name;
        if (!strncmp(root_device_name, "mtd", 3) ||
            !strncmp(root_device_name, "ubi", 3)) {
            mount_block_root(root_device_name, root_mountflags);
            goto out;
        }
        /*********************
        *ROOT_DEV存放saved_root_name的设备节点号。
        *********************/
        ROOT_DEV = name_to_dev_t(root_device_name);
        if (strncmp(root_device_name, "/dev/", 5) == 0)
            root_device_name += 5;
    }
        /************************************
        *挂载Image-initrd，如果bootargs指定了noinitrd，
        *那么initrd_load()是空操作。
        *************************************/
    if (initrd_load())
        goto out;

    /* wait for any asynchronous scanning to complete */
    if ((ROOT_DEV == 0) && root_wait) {
        printk(KERN_INFO "Waiting for root device %s...\n",
            saved_root_name);
        while (driver_probe_done() != 0 ||
            (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
            msleep(100);
        async_synchronize_full();
    }

    is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;

    if (is_floppy && rd_doload && rd_load_disk(0))
        ROOT_DEV = Root_RAM0;
        /**********************
        *把真实的根文件系统挂在到rootfs的/root目录下。
        **********************/
    mount_root();
out:
    devtmpfs_mount("dev");
    /****************************************
    *将真实根文件系统从当前目录移动到rootfs的根目录后，
    *并进入根目录。
    *然后将当前目录设置为系统的根目录，即作为当前进程的根目录。
    *所以，最终把虚拟的文件系统切换到了真实的根文件系统。
    ****************************************/
    sys_mount(".", "/", NULL, MS_MOVE, NULL);
    sys_chroot(".");
}

　　（４）initrd_load()是针对Image-initrd的函数，注意，前面已经把Image-initrd解压到了/initrd.image里面。

int __init initrd_load(void)
{
        /***********************************
        *mount_initrd的默认值为1，如果uboot传给kernel
        *的参数指明noinitrd，则mount_initrd被置成0。
        ***********************************/
    if (mount_initrd) {
        create_dev("/dev/ram", Root_RAM0);
        /*
         * Load the initrd data into /dev/ram0. Execute it as initrd
         * unless /dev/ram0 is supposed to be our actual root device,
         * in that case the ram disk is just set up here, and gets
         * mounted in the normal path.
         */
        /*****************************************
        *rd_load_image函数将/initrd.image的内容释放到/dev/ram设备节点。
        *如果根文件系统设备号不是Root_RAM0，即给内核指定的参数不是/dev/ram，
        *则会调用handle_initrd()。但是一般我们给内核指定的参数是/dev/ram。
        ******************************************/
        if (rd_load_image("/initrd.image") && ROOT_DEV != Root_RAM0) {
            sys_unlink("/initrd.image");
            handle_initrd();
            return 1;
        }
    }
    sys_unlink("/initrd.image");
    return 0;
}

　　（５）执行/linuxrc脚本确定真实的根文件系统，接着调用mount_root将真实的根文件系统挂载到rootfs的/root目录下。

static void __init handle_initrd(void)
{
    struct subprocess_info *info;
    static char *argv[] = { "linuxrc", NULL, };
    extern char *envp_init[];
    int error;

        /**********************************
        *real_root_dev为一个全局变量，用来保存真实根文件系统的设备号。
        **********************************/
    real_root_dev = new_encode_dev(ROOT_DEV);

        /**********************************************
        */dev/root.old的设备号是Root_RAM0，而前面已经把Image-initrd释放到了
        *Root_RAM0，所以/dev/root.old下的内容就是真实的根文件系统Image-initrd。
        **********************************************/
    create_dev("/dev/root.old", Root_RAM0);
    /* mount initrd on rootfs' /root */
    /************************************
    *将真实的根文件系统挂载到rootfs的/root目录下。
    ************************************/
    mount_block_root("/dev/root.old", root_mountflags & ~MS_RDONLY);
    sys_mkdir("/old", 0700);
    sys_chdir("/old");

    /* try loading default modules from initrd */
    load_default_modules();

    /*
     * In case that a resume from disk is carried out by linuxrc or one of
     * its children, we need to tell the freezer not to wait for us.
     */
    current->flags |= PF_FREEZER_SKIP;

    info = call_usermodehelper_setup("/linuxrc", argv, envp_init,
                     GFP_KERNEL, init_linuxrc, NULL, NULL);
    if (!info)
        return;
    call_usermodehelper_exec(info, UMH_WAIT_PROC);

    current->flags &= ~PF_FREEZER_SKIP;

    /* move initrd to rootfs' /old */
    sys_mount("..", ".", NULL, MS_MOVE, NULL);
    /* switch root and cwd back to / of rootfs */
    sys_chroot("..");

    if (new_decode_dev(real_root_dev) == Root_RAM0) {
        sys_chdir("/old");
        return;
    }

    sys_chdir("/");
    /*************************************
    *执行完linuxrc后，真实的根文件系统已经确定，则执行
    *mount_root将真实的根文件系统挂载到rootfs的/root目录下。
    **************************************/
    ROOT_DEV = new_decode_dev(real_root_dev);
    mount_root();

    printk(KERN_NOTICE "Trying to move old root to /initrd ... ");
    error = sys_mount("/old", "/root/initrd", NULL, MS_MOVE, NULL);
    if (!error)
        printk("okay\n");
    else {
        int fd = sys_open("/dev/root.old", O_RDWR, 0);
        if (error == -ENOENT)
            printk("/initrd does not exist. Ignored.\n");
        else
            printk("failed\n");
        printk(KERN_NOTICE "Unmounting old root\n");
        sys_umount("/old", MNT_DETACH);
        printk(KERN_NOTICE "Trying to free ramdisk memory ... ");
        if (fd < 0) {
            error = fd;
        } else {
            error = sys_ioctl(fd, BLKFLSBUF, 0);
            sys_close(fd);
        }
        printk(!error ? "okay\n" : "failed\n");
    }
}