Linux--根文件系统的挂载过程分析

CONfig_CMDliNE="console=ttyS0,115200 mem=108M rdinit=/linuxrc root=/dev/mtdblock2"

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

dcache_init();

inode_init();

files_init(mempages);

[1] mnt_init();

bdev_cache_init();

chrdev_init();

}

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

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

for (u = 0; u < HASH_SIZE; u++)

INIT_List_head(&mount_hashtable[u]);

err = sysfs_init();

if (err)

printk(KERN_WARNING "%s: sysfs_init error: %d/n",

__func__, err);

fs_kobj = kobject_create_and_add("fs", NulL);

if (!fs_kobj)

printk(KERN_WARNING "%s: kobj create error/n", __func__);

[1] init_rootfs();

[2] init_mount_tree();

}

static voID __init init_mount_tree(voID)

{

struct vfsmount *mnt;

struct mnt_namespace *ns;

struct path root;

[1] 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);

[2] set_fs_root(current->fs, &root);

}

/*

* We need to finalize in a non-__init function or else race conditions

* between the root thread and the init thread may cause start_kernel to

* be reaped by free_initmem before the root thread has proceeded to

* cpu_IDle.

*

* gcc-3.4 accIDentally inlines this function, so use noinline.

*/

static noinline voID __init_refok rest_init(voID)

__releases(kernel_lock)

{

int pID;

kernel_thread(kernel_init, NulL, CLONE_FS | CLONE_SIGHAND);

numa_default_policy();

pID = kernel_thread(kthreadd, NulL, CLONE_FS | CLONE_fileS);

kthreadd_task = find_task_by_pID_ns(pID, &init_pID_ns);

unlock_kernel();

/*

* The boot IDle thread must execute schedule()

* at least once to get things moving:

*/

init_IDle_bootup_task(current);

rcu_scheduler_starting();

preempt_enable_no_resched();

schedule();

preempt_disable();

/* Call into cpu_IDle with preempt Disabled */

cpu_IDle();

}

static int __init kernel_init(voID * unused)

{

lock_kernel();

/*

* init can run on any cpu.

*/

set_cpus_allowed_ptr(current, cpu_MASK_ALL_PTR);

/*

* Tell the world that we're going to be the grim

* reaper of innocent orphaned children.

*

* We don't want people to have to make incorrect

* assumptions about where in the task array this

* can be found.

*/

init_pID_ns.child_reaper = current;

cad_pID = task_pID(current);

smp_prepare_cpus(setup_max_cpus);

do_pre_smp_initcalls();

start_boot_trace();

smp_init();

sched_init_smp();

cpuset_init_smp();

[1] do_basic_setup();

/*

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

* the work

*/

[2] if (!ramdisk_execute_command)

ramdisk_execute_command = "/init";

[3] 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;

}

rootfs_initcall(populate_rootfs);

#

# Makefile for the linux kernel.

#

obj-y := main.o version.o mounts.o

ifneq ($(CONfig_BLK_DEV_INITRD),y)

obj-y += noinitramfs.o

else

obj-$(CONfig_BLK_DEV_INITRD) += initramfs.o

endif

obj-$(CONfig_GENERIC_CAliBRATE_DELAY) += calibrate.o

mounts-y := do_mounts.o

mounts-$(CONfig_BLK_DEV_RAM) += do_mounts_rd.o

mounts-$(CONfig_BLK_DEV_INITRD) += do_mounts_initrd.o

mounts-$(CONfig_BLK_DEV_MD) += do_mounts_md.o

static int __init populate_rootfs(voID)

{

[1] char *err = unpack_to_rootfs(__initramfs_start,

__initramfs_end - __initramfs_start, 0);

if (err)

panic(err);

[2] if (initrd_start) {

#ifdef CONfig_BLK_DEV_RAM

int fd;

printk(KERN_INFO "checking if image is initramfs...");

[3] 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);

[4] fd = sys_open("/initrd.image", O_WRONLY|O_CREAT, 0700);

if (fd >= 0) {

[5] sys_write(fd, (char *)initrd_start,

initrd_end - initrd_start);

sys_close(fd);

[6] free_initrd();

}

#else

printk(KERN_INFO "Unpacking initramfs...");

[7] err = unpack_to_rootfs((char *)initrd_start,

initrd_end - initrd_start, 0);

if (err)

panic(err);

printk(" done/n");

free_initrd();

#endif

}

return 0;

}

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

[1] 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;

}

/*

* Prepare the namespace - decIDe what/where to mount, load ramdisks, etc.

*/

voID __init prepare_namespace(voID)

{

int is_floppy;

[1] if (root_delay) {

printk(KERN_INFO "Waiting %dsec 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.

*/

[2] wait_for_device_probe();

md_run_setup();

[3] if (saved_root_name[0]) {

root_device_name = saved_root_name;

if (!strncmp(root_device_name, "mtd", 3) ||

!strncmp(root_device_name, "ubi", 3)) {

[4] mount_block_root(root_device_name, root_mountflags);

goto out;

}

[5] ROOT_DEV = name_to_dev_t(root_device_name);

if (strncmp(root_device_name, "/dev/", 5) == 0)

root_device_name += 5;

}

[6] if (initrd_load())

goto out;

[7] /* 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;

mount_root();

out:

[9] sys_mount(".", "/", NulL, MS_MOVE, NulL);

[10] sys_chroot(".");

}

CONfig_CMDliNE="console=ttyS0,115200 mem=108M rdinit=/linuxrc root=/dev/mtdblock2"

int __init initrd_load(voID)

{

[1] if (mount_initrd) {

[2] 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.

*/

[3] if (rd_load_image("/initrd.image") && ROOT_DEV != Root_RAM0) {

sys_unlink("/initrd.image");

[4] handle_initrd();

return 1;

}

}

sys_unlink("/initrd.image");

return 0;

}

static voID __init handle_initrd(voID)

{

int error;

int pID;

[1] real_root_dev = new_encode_dev(ROOT_DEV);

[2] create_dev("/dev/root.old", Root_RAM0);

/* mount initrd on rootfs' /root */

mount_block_root("/dev/root.old", root_mountflags & ~MS_RDONLY);

[3] sys_mkdir("/old", 0700);

root_fd = sys_open("/", 0, 0);

old_fd = sys_open("/old", 0, 0);

/* move initrd over / and chdir/chroot in initrd root */

[4] sys_chdir("/root");

sys_mount(".", "/", NulL, MS_MOVE, NulL);

sys_chroot(".");

/*

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

[5] pID = kernel_thread(do_linuxrc, "/linuxrc", SIGCHLD);

if (pID > 0)

while (pID != sys_wait4(-1, NulL, 0, NulL))

yIEld();

current->flags &= ~PF_FREEZER_SKIP;

/* move initrd to rootfs' /old */

sys_fchdir(old_fd);

sys_mount("/", ".", NulL, MS_MOVE, NulL);

/* switch root and cwd back to / of rootfs */

[6] sys_fchdir(root_fd);

sys_chroot(".");

sys_close(old_fd);

sys_close(root_fd);

[7] if (new_decode_dev(real_root_dev) == Root_RAM0) {

sys_chdir("/old");

return;

}

[8] ROOT_DEV = new_decode_dev(real_root_dev);

mount_root();

[9] 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");

}

}

/* This is a non __init function. Force it to be noinline otherwise gcc

* makes it inline to init() and it becomes part of init.text section

*/

static noinline int init_post(voID)

{

/* need to finish all async __init code before freeing the memory */

async_synchronize_full();

free_initmem();

unlock_kernel();

mark_rodata_ro();

system_state = SYstem_RUNNING;

numa_default_policy();

if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)

printk(KERN_WARNING "Warning: unable to open an initial console./n");

(voID) sys_dup(0);

(voID) sys_dup(0);

current->signal->flags |= SIGNAL_UNKILLABLE;

if (ramdisk_execute_command) {

run_init_process(ramdisk_execute_command);

printk(KERN_WARNING "Failed to execute %s/n",

ramdisk_execute_command);

}

/*

* We try each of these until one succeeds.

*

* The Bourne shell can be used instead of init if we are

* trying to recover a really broken machine.

*/

if (execute_command) {

run_init_process(execute_command);

printk(KERN_WARNING "Failed to execute %s. Attempting "

"defaults.../n", execute_command);

}

run_init_process("/sbin/init");

run_init_process("/etc/init");

run_init_process("/bin/init");

run_init_process("/bin/sh");

panic("No init found. Try passing init= option to kernel.");

}