源码地址https://github.com/torvalds/linux/blob/master/init/main.c
内核的启动从入口函数 start_kernel() 开始。在 init/main.c 文件中，start_kernel 相当于内核的 main 函数。打开这个函数，你会发现，里面是各种各样初始化函数 XXXX_init。

  1. asmlinkage __visible void __init start_kernel(void)

初始化函数

setup_arch(&command_line);

处理cmdline uboot传递给kernel的参数

trap_init()

trap_init()，里面设置了很多中断门（Interrupt Gate），用于处理各种中断,异常向量表

mm_init()

mm_init() 就是用来初始化内存管理模块。

sched_init()

sched_init() 就是用于初始化调度模块。

console_init()

控制台初始化

rest_init()

vfs_caches_init() 会用来初始化基于内存的文件系统 rootfs。在这个函数里面，会调用 mnt_init()->init_rootfs()。
register_filesystem(&rootfs_fs_type)。在 VFS 虚拟文件系统里面注册了一种类型，我们定义为 struct file_system_type rootfs_fs_type。
文件系统是我们的项目资料库，为了兼容各种各样的文件系统，我们需要将文件的相关数据结构和操作抽象出来，形成一个抽象层对上提供统一的接口，这个抽象层就是 VFS（Virtual File System），虚拟文件系统。
最后，start_kernel() 调用的是 rest_init()，用来做其他方面的初始化，这里面做了好多的工作。

  1. void cpu_idle(void)
  2. {
  3.     int cpu = smp_processor_id();
  4.     current_thread_info()->status |= TS_POLLING;
  5.     while (1) {
  6.         tick_nohz_stop_sched_tick(1);
  7.         while (!need_resched()) {
  8.             check_pgt_cache();
  9.             rmb();
  10.             if (rcu_pending(cpu))
  11.                 rcu_check_callbacks(cpu, 0);
  12.             if (cpu_is_offline(cpu))
  13.                 play_dead();
  14.             local_irq_disable();
  15.             __get_cpu_var(irq_stat).idle_timestamp = jiffies;
  16.             stop_critical_timings();
  17.             pm_idle();
  18.             start_critical_timings();
  19.         }
  20.         tick_nohz_restart_sched_tick();
  21.         preempt_enable_no_resched();
  22.         schedule();
  23.         preempt_disable();
  24.     }
  25. }

reset_init 最终调用cpu_idle函数结束了整个内核的启动，cpu_idle函数是一个死循环函数

内核态&用户态

image.jpeg
Ring0，我们称为内核态（Kernel Mode）；
普通的程序代码放在 Ring3，我们称为用户态（User Mode）。
当处于用户态的代码想要执行更高权限的指令，这种行为是被禁止的，要防止他们为所欲为。
当一个用户态的程序运行到一半，要访问一个核心资源，例如访问网卡发一个网络包，就需要暂停当前的运行，调用系统调用，接下来就轮到内核中的代码运行了。
首先，内核将从系统调用传过来的包，在网卡上排队，轮到的时候就发送。发送完了，系统调用就结束了，返回用户态，让暂停运行的程序接着运行。
这个暂停怎么实现呢？其实就是把程序运行到一半的情况保存下来。例如，我们知道，内存是用来保存程序运行时候的中间结果的，现在要暂时停下来，这些中间结果不能丢，因为再次运行的时候，还要基于这些中间结果接着来。另外就是，当前运行到代码的哪一行了，当前的栈在哪里，这些都是在寄存器里面的。
所以，暂停的那一刻，要把当时 CPU 的寄存器的值全部暂存到一个地方，这个地方可以放在进程管理系统很容易获取的地方。在后面讨论进程管理数据结构的时候，我们还会详细讲。当系统调用完毕，返回的时候，再从这个地方将寄存器的值恢复回去，就能接着运行了。
image.jpeg
这个过程就是这样的：用户态 - 系统调用 - 保存寄存器 - 内核态执行系统调用 - 恢复寄存器 - 返回用户态，然后接着运行。
image.jpeg

我们再回到 1 号进程启动的过程。当前执行 kernel_thread 这个函数的时候，我们还在内核态，现在我们就来跨越这道屏障，到用户态去运行一个程序。这该怎么办呢？很少听说“先内核态再用户态”的。
kernel_thread 的参数是一个函数 kernel_init，也就是这个进程会运行这个函数。在 kernel_init 里面，会调用 kernel_init_freeable()，里面有这样的代码：

  1. if (!ramdisk_execute_command)
  2.         ramdisk_execute_command = "/init";

先不管 ramdisk 是啥，我们回到 kernel_init 里面。这里面有这样的代码块：

  1. if (ramdisk_execute_command) {
  2.         ret = run_init_process(ramdisk_execute_command);
  3. ......
  4.     }
  5. ......
  6.     if (!try_to_run_init_process("/sbin/init") ||
  7.         !try_to_run_init_process("/etc/init") ||
  8.         !try_to_run_init_process("/bin/init") ||
  9.         !try_to_run_init_process("/bin/sh"))
  10.         return 0;
  11. 复制代码

这就说明，1 号进程运行的是一个文件。如果我们打开 runinit_process 函数，会发现它调用的是 do_execve。
这个名字是不是看起来很熟悉？前面讲系统调用的时候，execve 是一个系统调用，它的作用是运行一个执行文件。加一个 do 的往往是内核系统调用的实现。没错，这就是一个系统调用，它会尝试运行 ramdisk 的“/init”，或者普通文件系统上的“/sbin/init”“/etc/init”“/bin/init”“/bin/sh”。不同版本的 Linux 会选择不同的文件启动，但是只要有一个起来了就可以。

  1. static int run_init_process(const char *init_filename)
  2. {
  3.     argv_init[0] = init_filename;
  4.     return do_execve(getname_kernel(init_filename),
  5.         (const char __user *const __user *)argv_init,
  6.         (const char __user *const __user *)envp_init);
  7. }
  8. 复制代码

如何利用执行 init 文件的机会，从内核态回到用户态呢？
我们从系统调用的过程可以得到启发，“用户态 - 系统调用 - 保存寄存器 - 内核态执行系统调用 - 恢复寄存器 - 返回用户态”，然后接着运行。而咱们刚才运行 init，是调用 do_execve，正是上面的过程的后半部分，从内核态执行系统调用开始。
do_execve->do_execveat_common->exec_binprm->search_binary_handler，这里面会调用这段内容：

  1. int search_binary_handler(struct linux_binprm *bprm)
  2. {
  3. ......
  4. struct linux_binfmt *fmt;
  5. ......
  6. retval = fmt->load_binary(bprm);
  7. ......
  8. }

也就是说，我要运行一个程序，需要加载这个二进制文件，这就是我们常说的项目执行计划书。它是有一定格式的。Linux 下一个常用的格式是ELF（Executable and Linkable Format，可执行与可链接格式）。于是我们就有了下面这个定义：

  1. static struct linux_binfmt elf_format = {
  2. .module    = THIS_MODULE,
  3. .load_binary    = load_elf_binary,
  4. .load_shlib    = load_elf_library,
  5. .core_dump    = elf_core_dump,
  6. .min_coredump    = ELF_EXEC_PAGESIZE,
  7. };

这其实就是先调用 load_elf_binary，最后调用 start_thread。

  1. void
  2. start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
  3. {
  4. set_user_gs(regs, 0);
  5. regs->fs    = 0;
  6. regs->ds    = __USER_DS;
  7. regs->es    = __USER_DS;
  8. regs->ss    = __USER_DS;
  9. regs->cs    = __USER_CS;
  10. regs->ip    = new_ip;
  11. regs->sp    = new_sp;
  12. regs->flags    = X86_EFLAGS_IF;
  13. force_iret();
  14. }
  15. EXPORT_SYMBOL_GPL(start_thread);
  16. 复制代码

看到这里，你是不是有点感觉了？struct pt_regs，看名字里的 register，就是寄存器啊！这个结构就是在系统调用的时候，内核中保存用户态运行上下文的，里面将用户态的代码段 CS 设置为 USER_CS，将用户态的数据段 DS 设置为 USER_DS，以及指令指针寄存器 IP、栈指针寄存器 SP。这里相当于补上了原来系统调用里，保存寄存器的一个步骤。
最后的 iret 是干什么的呢？它是用于从系统调用中返回。这个时候会恢复寄存器。从哪里恢复呢？按说是从进入系统调用的时候，保存的寄存器里面拿出。好在上面的函数补上了寄存器。CS 和指令指针寄存器 IP 恢复了，指向用户态下一个要执行的语句。DS 和函数栈指针 SP 也被恢复了，指向用户态函数栈的栈顶。所以，下一条指令，就从用户态开始运行了。

内核态到用户态切换

(1)一个进程2种状态。init进程刚开始运行的时候是内核态，它属于一个内核线程，然后他自己运行了一个用户态下面的程序后把自己强行转成了用户态。因为init进程自身完成了从内核态到用户态的过度，因此后续的其他进程都可以工作在用户态下面了。
(2)init进程内核态下就是挂载根文件系统并试图找到用户态下的那个init程序。init进程要把自己转成用户态就必须运行一个用户态的应用程序（这个应用程序名字一般也叫init），要运行这个应用程序就必须得找到这个应用程序，要找到它就必须得挂载根文件系统，因为所有的应用程序都在文件系统中。
内核源代码中的所有函数都是内核态下面的，执行任何一个都不能脱离内核态。应用程序必须不属于内核源代码，这样才能保证自己是用户态。也就是说我们这里执行的这个init程序和内核不在一起，他是另外提供的。提供这个init程序的那个人就是根文件系统。
(3)init进程用户态下让其他所有的用户进程都直接或者间接派生自init进程。
(4)如何从内核态跳跃到用户态？还能回来不？
init进程在内核态下面时，通过一个函数kernel_execve来执行一个用户空间编译连接的应用程序就跳跃到用户态了。注意这个跳跃过程中进程号是没有改变的，所以一直是进程1.这个跳跃过程是单向的，也就是说一旦执行了init程序转到了用户态下整个操作系统就算真正的运转起来了，以后只能在用户态下工作了，用户态下想要进入内核态只有走API这一条路了。
init进程构建了用户交互界面
(1)init进程是其他用户进程的老祖宗。linux系统中一个进程的创建是通过其父进程创建出来的。根据这个理论只要有一个父进程就能生出一堆子孙进程了。
(2)init启动了login进程、命令行进程、shell进程
(3)shell进程启动了其他用户进程。命令行和shell一旦工作了，用户就可以在命令行下通过./xx的方式来执行其他应用程序，每一个应用程序的运行就是一个进程。

ramdisk 的作用

init 终于从内核到用户态了。一开始到用户态的是 ramdisk 的 init，后来会启动真正根文件系统上的 init，成为所有用户态进程的祖先。
为什么会有 ramdisk 这个东西呢？还记得上一节咱们内核启动的时候，配置过这个参数：

  1. initrd16 /boot/initramfs-3.10.0-862.el7.x86_64.img

文件系统一定是在一个存储设备上的，例如硬盘。Linux 访问存储设备，要有驱动才能访问。如果存储系统数目很有限，那驱动可以直接放到内核里面，反正前面我们加载过内核到内存里了，现在可以直接对存储系统进行访问。
但是存储系统越来越多了，如果所有市面上的存储系统的驱动都默认放进内核，内核就太大了。这该怎么办呢？
我们只好先弄一个基于内存的文件系统。内存访问是不需要驱动的，这个就是 ramdisk。这个时候，ramdisk 是根文件系统。
然后，我们开始运行 ramdisk 上的 /init。等它运行完了就已经在用户态了。/init 这个程序会先根据存储系统的类型加载驱动，有了驱动就可以设置真正的根文件系统了。有了真正的根文件系统，ramdisk 上的 /init 会启动文件系统上的 init。
接下来就是各种系统的初始化。启动系统的服务，启动控制台，用户就可以登录进来了。
先别忙着高兴，rest_init 的第一个大事情才完成。我们仅仅形成了用户态所有进程的祖先。

进程

操作系统是用一个数字来表示/记录一个进程/线程的，这个数字就被称为这个进程的进程号。这个号码是从0开始分配的。因此这里涉及到的三个进程分别是linux系统的进程0、进程1、进程2.
在linux命令行下，使用ps命令可以查看当前linux系统中运行的进程情况。
我们在ubuntu下ps -aux可以看到当前系统运行的所有进程，可以看出进程号是从1开始的。为什么不从0开始，因为进程0不是一个用户进程，而属于内核进程。

0 号进程

进程0其实就是idle进程，叫空闲进程，也就是死循环。
在操作系统里面，先要有个创始进程，有一行指令 set_task_stack_end_magic(&init_task)。这里面有一个参数 init_task，它的定义是 struct task_struct init_task = INIT_TASK(init_task)。它是系统创建的第一个进程，我们称为0 号进程。这是唯一一个没有通过 fork 或者 kernel_thread 产生的进程，是进程列表的第一个。

1号进程

kernel_init函数就是进程1，这个进程被称为init进程。
rest_init 的第一大工作是，用 kernel_thread(kernel_init, NULL, CLONE_FS) 创建第二个进程，这个是1 号进程。
1 号进程对于操作系统来讲，有“划时代”的意义。因为它将运行一个用户进程，

2 号进程

kthreadd函数就是进程2，这个进程是linux内核的守护进程。这个进程是用来保证linux内核自己本身能正常工作的。
rest_init 第二大事情就是第三个进程，就是 2 号进程。
kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES) 又一次使用 kernel_thread 函数创建进程。这里需要指出一点，函数名 thread 可以翻译成“线程”，这也是操作系统很重要的一个概念。它和进程有什么区别呢？为什么这里创建的是进程，函数名却是线程呢？
从用户态来看，创建进程其实就是立项，也就是启动一个项目。这个项目包含很多资源，例如会议室、资料库等。这些东西都属于这个项目，但是这个项目需要人去执行。有多个人并行执行不同的部分，这就叫多线程（Multithreading）。如果只有一个人，那它就是这个项目的主线程。
但是从内核态来看，无论是进程，还是线程，我们都可以统称为任务（Task），都使用相同的数据结构，平放在同一个链表中。这些在进程的那一章节，我会更加详细地讲。
这里的函数 kthreadd，负责所有内核态的线程的调度和管理，是内核态所有线程运行的祖先。
这下好了，用户态和内核态都有人管了，可以开始接项目了。

参考文章

https://xinqiu.gitbooks.io/linux-insides-cn/content/Initialization/linux-initialization-4.html