从start_kernel到init进程启动 《Linux内核分析》笔记

从start_kernel到init进程启动 《Linux内核分析》笔记

GDB的使用

在进入GDB调试前，首先掌握GDB最常用的命令，以方便完成跟踪。

• b[reak] linenumber：加断点
• s[tep]：单步进入
• n[ext]：单步跳过
• c[ontinue]：继续执行
• r[un]：运行至结束或者崩溃
• q[uit]：退出
• info：查看已设置的断点和观察点
• watch：设置观察点

其他有用的命令包括：

命令	用途
ptype	打印变量的数据类型
info share	打印当前装入的共享库的名称
info functions	打印所有函数原型
list	显示当前行周围的 10 行源代码
help	显示主题列表

计算机的启动过程

• x86 CPU启动的第一个动作CS:EIP=FFFF:0000H（换算为物理地址为000FFFF0H，因为16位CPU有20根地址线)，即BIOS程序的位置。http://wenku.baidu.com/view/4e5c49eb172ded630b1cb699.html
• BIOS例行程序检测完硬件并完成相应的初始化之后就会寻找可引导介质，找到后把引导程序加载到指定内存区域后，就把控制权交给了引导程序。这里一般是把硬盘的第一个扇区MBR和活动分区的引导程序加载到内存（即加载BootLoader），加载完整后把控制权交给BootLoader。
• 引导程序BootLoader开始负责操作系统初始化，然后起动操作系统。启动操作系统时一般会指定kernel、initrd和root所在的分区和目录，比如root (hd0,0)，kernel (hd0,0)/bzImage root=/dev/ram init=/bin/ash，initrd (hd0,0)/myinitrd4M.img
• 内核启动过程包括start_kernel之前和之后，之前全部是做初始化的汇编指令，之后开始C代码的操作系统初始化，最后执行第一个用户态进程init。
• 一般分两阶段启动，先是利用initrd的内存文件系统，然后切换到硬盘文件系统继续启动。initrd文件的功能主要有两个：1、提供开机必需的但kernel文件(即vmlinuz)没有提供的驱动模块(modules) 2、负责加载硬盘上的根文件系统并执行其中的/sbin/init程序进而将开机过程持续下去

计算机一旦加电以后，PC就指向BIOS的一段区域，这段区域会完成硬件自检，当硬件检查完成以后，没有发现问题。便开始从硬盘的一个扇区（大小为512个字节，在Linux中可以认为是grub）读取字节，然后把控制权交给这段代码，这段代码大小比较小，能做的事情比较少，能让用户进行一些选择操作。当选择完成以后，这样这段代码就负责加载内核到内存里了，加载完成以后，控制权就交给操作系统了，这样一个操作系统就加载并开始运行起来了。

跟踪分析Linux内核的启动过程

使用实验楼的虚拟机打开shell

cd LinuxKernel/
qemu -kernel linux-3.18.6/arch/x86/boot/bzImage -initrd rootfs.img

内核启动完成后进入menu程序（《软件工程C编码实践篇》的课程项目），支持三个命令help、version和quit，您也可以添加更多的命令，对选修过《软件工程C编码实践篇》的童鞋应该是a piece of cake.

使用gdb跟踪调试内核

qemu -kernel linux-3.18.6/arch/x86/boot/bzImage -initrd rootfs.img -s -S # 关于-s和-S选项的说明：
 -S freeze CPU at startup (use ’c’ to start execution)
-s shorthand for -gdb tcp::1234 若不想使用1234端口，则可以使用-gdb tcp:xxxx来取代-s选项

另开一个shell窗口

gdb
（gdb）file linux-3.18.6/vmlinux # 在gdb界面中targe remote之前加载符号表
（gdb）target remote:1234 # 建立gdb和gdbserver之间的连接,按c 让qemu上的Linux继续运行
（gdb）break start_kernel # 断点的设置可以在target remote之前，也可以在之后

Linux操作系统的基本初始化在init模块中完成，我们实验也从这个模块开始。
首先按照说明断点打在其中的main.c函数的start_kernel函数，然后执行c[ontinue]，接着就停在了main.c:501行的start_kernel函数。

使用list函数打印出上下文，我们可以看到这个模块中有很多初始化操作，如：trap_init(中断)、ipc_init(进程)、mm_init(内存管理)、sched_init(进程调度)等等。

我们再在rest_init打一个断点，在list中可以看到，rest_init已经是start_kernel最后调用的函数了。

分析启动的过程

回过头来再看start_kernel，在构架相关的汇编代码运行完之后，程序跳入了构架无关的内核C语言代码：init/main.c中的start_kernel函数，在这个函数中Linux内核开始真正进入初始化阶段。

asmlinkage __visible void __init start_kernel(void)
{
//命令行，存放bootloader传递过来的参数
char *command_line;
char *after_dashes;

//初始化内核调试模块
    lockdep_init();
//init_task即手工创建的PCB
    set_task_stack_end_magic(&init_task);
//获取当前CPU的硬件ID
    smp_setup_processor_id();
//初始化哈希桶
    debug_objects_early_init();
//防止栈溢出
    boot_init_stack_canary();
//初始化cgroups
    cgroup_init_early();
//关闭当前CPU的所有中断
    local_irq_disable();
//系统中断标志
    early_boot_irqs_disabled = true;
//激活当前CPU
    boot_cpu_init();
//初始化高端内存映射表
    page_address_init();
//输出各种信息
    pr_notice("%s", linux_banner);
//内核构架相关初始化函数
    setup_arch(&command_line);
//每一个任务都有一个mm_struct结构来管理内存空间
    mm_init_cpumask(&init_mm);
//对cmdline进行备份和保存
    setup_command_line(command_line);
//设置最多有多少个nr_cpu_ids结构
    setup_nr_cpu_ids();
//为系统中每个CPU的per_cpu变量申请空间
    setup_per_cpu_areas();
//为SMP系统里引导CPU(boot-cpu)进行准备工作
    smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */
//设置内存管理相关的node
    build_all_zonelists(NULL, NULL);
//设置内存页分配通知器
    page_alloc_init();

    pr_notice("Kernel command line: %s\n", boot_command_line);
//解析cmdline中的启动参数
    parse_early_param();
//对传入内核参数进行解释
    after_dashes = parse_args("Booting kernel",
                  static_command_line, __start___param,
                  __stop___param - __start___param,
                  -1, -1, &unknown_bootoption);
if (!IS_ERR_OR_NULL(after_dashes))
        parse_args("Setting init args", after_dashes, NULL, 0, -1, -1,
               set_init_arg);

    jump_label_init();

//使用bootmeme分配一个记录启动信息的缓冲区
    setup_log_buf(0);
//进程ID的HASH表初始化
    pidhash_init();
//前期虚拟文件系统(vfs)的缓存初始化
    vfs_caches_init_early();
//对内核异常表(exception table)按照异常向量号大小进行排序，以便加速访问
    sort_main_extable();
//对内核陷阱异常进行初始化
    trap_init();
//标记哪些内存可以使用
    mm_init();
//对进程调度器的数据结构进行初始化
    sched_init();
//关闭优先级调度
    preempt_disable();
//这段代码主要判断是否过早打开中断，如果是这样，就会提示，并把中断关闭
if (WARN(!irqs_disabled(),
"Interrupts were enabled *very* early, fixing it\n"))
        local_irq_disable();
//为IDR机制分配缓存
    idr_init_cache();
//初始化直接读拷贝更新的锁机制
    rcu_init();
    context_tracking_init();
//内核radis 树算法初始化
    radix_tree_init();
//前期外部中断描述符初始化，主要初始化数据结构
    early_irq_init();
//对应架构特定的中断初始化函数
    init_IRQ();
//初始化内核时钟系统
    tick_init();
    rcu_init_nohz();
//初始化引导CPU的时钟相关的数据结构
    init_timers();
//初始化高精度的定时器
    hrtimers_init();
//初始化软件中断
    softirq_init();
//初始化系统时钟计时
    timekeeping_init();
//初始化系统时钟
    time_init();
    sched_clock_postinit();
//CPU性能监视机制初始化
    perf_event_init();  
//为内核性能参数分配内存空间
    profile_init();
//初始化所有CPU的call_single_queue
    call_function_init();
    WARN(!irqs_disabled(), "Interrupts were enabled early\n");
    early_boot_irqs_disabled = false;
    local_irq_enable();
//这是内核内存缓存(slab分配器)的后期初始化
    kmem_cache_init_late();
//初始化控制台
    console_init();
if (panic_later)
        panic("Too many boot %s vars at `%s'", panic_later,
              panic_param);
//打印锁的依赖信息
    lockdep_info();
//测试锁的API是否使用正常
    locking_selftest();

#ifdef CONFIG_BLK_DEV_INITRD
if (initrd_start && !initrd_below_start_ok &&
        page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) {
        pr_crit("initrd overwritten (0x%08lx < 0x%08lx) - disabling it.\n",
            page_to_pfn(virt_to_page((void *)initrd_start)),
            min_low_pfn);
        initrd_start = 0;
    }
#endif
    page_cgroup_init();
    debug_objects_mem_init();
    kmemleak_init();
    setup_per_cpu_pageset();
    numa_policy_init();
if (late_time_init)
        late_time_init();
    sched_clock_init();
    calibrate_delay();
    pidmap_init();
    anon_vma_init();
    acpi_early_init();
#ifdef CONFIG_X86
if (efi_enabled(EFI_RUNTIME_SERVICES))
        efi_enter_virtual_mode();
#endif
#ifdef CONFIG_X86_ESPFIX64
/* Should be run before the first non-init thread is created */
    init_espfix_bsp();
#endif
    thread_info_cache_init();
    cred_init();
    fork_init(totalram_pages);
    proc_caches_init(); 
//初始化文件系统的缓冲区
    buffer_init();
//初始化内核密钥管理系统
    key_init();
//初始化内核安全管理框架
    security_init();
    dbg_late_init();
    vfs_caches_init(totalram_pages);
    signals_init();
/* rootfs populating might need page-writeback */
    page_writeback_init();
    proc_root_init();
    cgroup_init();
    cpuset_init();
    taskstats_init_early();
    delayacct_init();
    check_bugs();
    sfi_init_late();
if (efi_enabled(EFI_RUNTIME_SERVICES)) {
        efi_late_init();
        efi_free_boot_services();
    }
    ftrace_init();
    rest_init();//剩余的初始化
}

第一步：第0号进程的诞生

首先关注start_kernel()里面第二句。

set_task_stack_end_magic(&init_task);

init_task在文件linux-3.18.6/init/init_task.c中定义如下：

struct task_struct init_task = INIT_TASK(init_task);

实际上这里task_struct手工实现了一个PCB的功能，产生了最初的进程，也就是0号进程。

而INIT_TASK宏在linux/init_task.h头文件里，这里表明了，INIT_TASK的使命就是产生0号进程。


这个struct完整包含了进程所有的信息，特殊就在于这个手工创建的进程PID设为0。

第二步：1号进程的创建

再来看rest_init函数。
里面有kernel_thread这样一个函数。

kernel_thread(kernel_init, NULL, CLONE_FS);

其中kernel_thread()的源码在文件linux-3.18.6/kernel/fork.c中定义是这样的：

pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
{
return do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn,
        (unsigned long)arg, NULL, NULL);
}

它的功能是调用fork产生新进程运行kernel_init。

而kernel_init()函数的定义在文件linux-3.18.6/init/main.c中定义，如下：

//创建的内核线程运行本函数，在本函数里面启动run_init_process
static int __ref kernel_init(void *unused)
{
int ret;
    kernel_init_freeable();
    async_synchronize_full();
    free_initmem();
    mark_rodata_ro();
    system_state = SYSTEM_RUNNING;
    numa_default_policy();
    flush_delayed_fput();
if (ramdisk_execute_command) {
//启动run_init_process
        ret = run_init_process(ramdisk_execute_command);
if (!ret)
return 0;
        pr_err("Failed to execute %s (error %d)\n",
               ramdisk_execute_command, ret);
    }
if (execute_command) {
        ret = run_init_process(execute_command);
if (!ret)
return 0;
        pr_err("Failed to execute %s (error %d). Attempting defaults...\n",
            execute_command, ret);
    }
/*try_to_run_init_process()通过嵌入汇编构造一个
 类似用户态代码一样的sys_execve()调用，其参数就是
 要执行的可执行文件名。
 */
/*这里是内核初始化结束并开始用户态初始化的阴阳界
 */
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;

    panic("No working init found. Try passing init= option to kernel. "
"See Linux Documentation/init.txt for guidance.");
}

我们可以很清晰地看到函数最后在调用execute命令执行硬盘上的init程序，此时便是1号进程产生的时候，内核态走向了用户态。

第三步：0号进程转变

static noinline void __init_refok rest_init(void)
{
int pid;
    rcu_scheduler_starting();
//很重要，创建一个内核线程，PID=1，创建好了，但不能去调度它
    kernel_thread(kernel_init, NULL, CLONE_FS);
    numa_default_policy();
//很重要，创建第二个内核线程，PID=2，负责管理和调度其它内核线程。
    pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
    rcu_read_lock();
    kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
    rcu_read_unlock();
    complete(&kthreadd_done);
    init_idle_bootup_task(current);
    schedule_preempt_disabled();
    cpu_startup_entry(CPUHP_ONLINE);
}

这是rest_init函数，创建了两个进程kernel_init和kthreadd。最后最后cpu_stargup_entry。

cpu_startup_entry(CPUHP_ONLINE);

定义如下：

void cpu_startup_entry(enum cpuhp_state state)
{
#ifdef CONFIG_X86
    boot_init_stack_canary();
#endif
    arch_cpu_idle_prepare();
    cpu_idle_loop();
}

最后的cpu_idle_loop()是一个无限循环，0号进程在启动1号进程和其他工作以后，就成为idle这个无限循环，在内核态中空转。

小结

整个过程尤其是0号进程和1号进程还有idle进程是怎么来的，到这里基本清楚了。简单总结一下，start_kernel是汇编代码运行后，对系统环境初始化的开始，0号进程是启动时较早人为建立的，然后0号进程fork产生了第一个用户态进程1号进程，1号进程载入磁盘上的init程序，生成了系统所需的所有进程，然后0号进程就转变为idle进程，在系统中空转。

道生一（start_kernel....cpu_idle），一生二（kernel_init和kthreadd），二生三（即前面0、1和2三个进程），三生万物（1号进程是所有用户态进程的祖先，2号进程是所有内核线程的祖先），新内核的核心代码已经优化的相当干净，都符合中国传统文化精神了。

经过更多学习，idle进程不是只有一个，在SMP多处理器机上，主处理器的idle进程是由最初的0号转变而来，从处理器的idle是由主处理器fork产生，PID皆为0，每个处理器的idle在机器空闲时空转，参与调度功能。

Jin Youzhi原创作品
转载请注明出处《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000