Linux — 内核初始化

// init/main.c
asmlinkage __visible void __init start_kernel(void)
{
    // 0号进程（创始进程）
    set_task_stack_end_magic(&init_task);
    // 设置中断门（系统调用是通过中断的方式触发）
    trap_init();
    // 初始化内存管理模块
    mm_init();
    // 初始化调度模块
    sched_init();
    // 初始化基于内存的文件系统rootfs
    vfs_caches_init();
    // 创建1号进程（用户态总管）和2号进程（内核态总管）
    arch_call_rest_init();
    ...
}

// fs/dcache.c
void __init vfs_caches_init(void)
{
    mnt_init();
}

// init/do_mounts.c
void __init mnt_init(void)
{
    init_rootfs();
}

// init/do_mounts.c
int __init init_rootfs(void)
{
    // 在VFS虚拟文件系统里面注册一种类型
    int err = register_filesystem(&rootfs_fs_type);
}

// init/main.c
noinline void __ref rest_init(void)
{
    // 初始化1号进程，用户态总管，systemd
    pid = kernel_thread(kernel_init, NULL, CLONE_FS);
    ...
    // 初始化2号进程，内核态总管，kthreadd
    pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
}

$ top
PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND
103587 root      20   0  162004   2284   1612 R  0.3  0.2   0:00.42 top
103801 root      20   0       0      0      0 S  0.3  0.0   0:00.08 kworker/0:1
     1 root      20   0  127976   6544   4136 S  0.0  0.7   0:25.99 systemd
     2 root      20   0       0      0      0 S  0.0  0.0   0:00.03 kthreadd

// init/main.c
static int __ref kernel_init(void *unused)
{
    // 将ramdisk_execute_command设置为/init
    kernel_init_freeable();

    // 执行ramdisk的/init
    if (ramdisk_execute_command) {
        ret = run_init_process(ramdisk_execute_command);
    }

    // 执行根文件系统的/sbin/init、/etc/init、/bin/init、/bin/sh
    if (execute_command) {
        ret = run_init_process(execute_command);
    }
    if (!try_to_run_init_process("/sbin/init") ||
        !try_to_run_init_process("/etc/init") ||
        !try_to_run_init_process("/bin/init") ||
        !try_to_run_init_process("/bin/sh"))
        return 0;
}

// init/main.c
static noinline void __init kernel_init_freeable(void)
{
    if (!ramdisk_execute_command)
        ramdisk_execute_command = "/init";
}

// init/main.c
static int run_init_process(const char *init_filename)
{
    // 系统调用，运行一个可执行文件，do_xxx往往是内核系统调用的实现
    return do_execve(getname_kernel(init_filename)...);
}

// init/main.c
static int try_to_run_init_process(const char *init_filename)
{
    ret = run_init_process(init_filename);
}

// fs/exec.c
int do_execve(struct filename *filename...)
{
    return do_execveat_common(AT_FDCWD, filename, argv, envp, 0);
}

// fs/exec.c
static int do_execveat_common(int fd, struct filename *filename,...)
{
    return __do_execve_file(fd, filename, argv, envp, flags, NULL);
}

// fs/exec.c
static int __do_execve_file(int fd, struct filename *filename,...)
{
    retval = exec_binprm(bprm);
}

// fs/exec.c
static int exec_binprm(struct linux_binprm *bprm)
{
    ret = search_binary_handler(bprm);
}

// fs/exec.c
int search_binary_handler(struct linux_binprm *bprm)
{
    struct linux_binfmt *fmt;
    retval = fmt->load_binary(bprm);
}

// fs/binfmt_elf.c
static struct linux_binfmt elf_format = {
    .module         = THIS_MODULE,
    .load_binary    = load_elf_binary,
    .load_shlib     = load_elf_library,
    .core_dump      = elf_core_dump,
    .min_coredump   = ELF_EXEC_PAGESIZE,
};

// fs/binfmt_elf.c
static int load_elf_binary(struct linux_binprm *bprm)
{
    start_thread(regs, elf_entry, bprm->p);
}

// arch/x86/kernel/process_32.c
void start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
{
    set_user_gs(regs, 0);
    regs->fs     = 0;
    regs->ds     = __USER_DS;
    regs->es     = __USER_DS;
    regs->ss     = __USER_DS;
    regs->cs     = __USER_CS;
    regs->ip     = new_ip;
    regs->sp     = new_sp;
    regs->flags      = X86_EFLAGS_IF;
    force_iret();
}