Linux0.11内核学习
对
的完整总结转载，侵删。
第一部分 进入内核前的苦力活
当你按下开机键的那一刻，在主板上提前写死的固件程序 BIOS 会将硬盘中启动区的 512 字节的数据，原封不动复制到内存中的 0x7c00 这个位置，并跳转到那个位置进行执行，
有了这个步骤之后，我们就可以把代码写在硬盘第一扇区，让 BIOS 帮我们加载到内存并由 CPU 去执行，我们不用操心这个过程。
而这一个扇区的代码，就是操作系统源码中最最最开始的部分，它可以执行一些指令，也可以把硬盘的其他部分加载到内存，其实本质上也是执行一些指令。这样，整个计算机今后如何运作，就完全交到我们自己的手中，想怎么玩就怎么玩了。
这是 第一回 | 最开始的两行代码 讲的内容。
接下来，直到 第四回 | 把自己在硬盘里的其他部分也放到内存来，我们才讲到整个操作系统的编译和加载过程的全貌，就是下面这张图。
而我们整个的第一部分，其实就在讲 boot 文件夹下的三个汇编文件的内容，bootsect.s，setup.s 以及后面要和其他全部操作系统代码做链接的 head.s。
前五回的内容一直在调整内存的布局，把这块内存复制到那块，又把那块内存复制到这块，所以在 第五回 | 进入保护模式前的最后一次折腾内存 的结尾，我让你记住这样一张图，在很长一段时间这个内存布局的大体框架就不会再变了，前五回的内容你也可以抛在脑后了。
从第六回开始往后，就是逐渐进入保护模式，并设置分段、分页、中断等机制的地方。最终的内存布局变成了这个样子。
你看，idtr 寄存器指向了 idt，这个就是中断的设置；gdtr 寄存器指向了 gdt，这个就是全局描述符表的设置，可以简单理解为分段机制的设置；cr3 寄存器指向了页目录表的位置，这个就是分页机制的设置。
中断的设置，就引出了 CPU 与操作系统处理中断的流程。
分段和分页的设置，引出了逻辑地址到物理地址的转换。
具体来说，逻辑地址到线性地址的转换，依赖 Intel 的分段机制。
而线性地址到物理地址的转换，依赖 Intel 的分页机制。
分段和分页，就是 Intel 管理内存的两大利器，也是内存管理最最最最底层的支撑。
而 Intel 本身对于访问内存就分成三类：
代码
数据
栈
而 Intel 也提供了三个段寄存器来分别对应着三类内存：
代码段寄存器（cs）
数据段寄存器（ds）
栈段寄存器（ss）
具体来说：
cs:eip 表示了我们要执行哪里的代码。
ds:xxx 表示了我们要访问哪里的数据。
ss:esp 表示了我们的栈顶地址在哪里。
而第一部分的代码，也做了如下工作：
将 ds 设置为了 0x10，表示指向了索引值为 2 的全局描述符，即数据段描述符。
将 cs 通过一次长跳转指令设置为了 8，表示指向了索引值为 1 的全局描述符，即代码段描述符。
将 ss:esp 这个栈顶地址设置为 user_stack 数组的末端。
你看，分段和分页，以及这几个寄存器的设置，其实本质上就是安排我们今后访问内存的方式，做了一个初步规划，包括去哪找代码、去哪找数据、去哪找栈，以及如何通过分段和分页机制将逻辑地址转换为最终的物理地址。
而所有上面说的这一切，和 Intel CPU 这个硬件打交道比较多，设置了一些最最最最基础的环境和内存布局，为之后进入 main 函数做了充分的准备，因为 c 语言虽然很底层了，但也有其不擅长的事情，就交给第一部分的汇编语言来做，所以我称第一部分为进入内核前的苦力活。
第二部分 大战前期的初始化工作
第二部分所讲的代码，就和第二部分的目录一样规整，一个 init 方法对应一个章节，简单粗暴。
void main(void) {
...
mem_init(main_memory_start,memory_end);
trap_init();
blk_dev_init();
chr_dev_init();
tty_init();
time_init();
sched_init();
buffer_init(buffer_memory_end);
hd_init();
floppy_init();
sti();
move_to_user_mode();
if (!fork()) {init();}
for(;;) pause();
}
------- 开始 -------
电脑开机后，首先由 BIOS 将操作系统程序加载到内存，之后在进入 main 函数前，我们用汇编语言（boot 包下的三个汇编文件）做了好多苦力活。
这些苦力活做好后，内存布局变成了这个样子。
其中页表的映射关系，被做成了线性地址与物理地址相同。
也因为有了页表的存在，所以多了线性地址空间的概念，即经过分段机制转化后，分页机制转化前的地址，不考虑段限长的话，32 位的 CPU 线性地址空间应为 4G。
以上这些，是进入 main 函数之前的事情，由 boot 文件夹下的三个汇编文件完成，具体可以看整个第一部分的总结：第一部分完结 进入内核前的苦力活
-------- 进入 main 函数后 ---------
进入 main 函数后，首先进行了内存划分，其实就是设置几个边界值，将内核程序、缓冲区、主内存三个部分划分开界限。这就是 第12回 | 管理内存前先划分出三个边界值 所做的事情。
随后，通过 mem_init 函数，对主内存区域用 mem_map[] 数组管理了起来，其实就是每个位置表示一个 4K 大小的内存页的使用次数而已，今后对主内存的申请和释放，其实都是对 mem_map 数组的操作。这是 第13回 | 主内存初始化 mem_init 所做的事。
后面又通过 buffer_init 函数，对缓冲区区域用多种数据结构管理起来。其中包括双向链表缓冲头 h 和每个缓冲头管理的 1024 字节大小的缓冲块 b。这是 第19回 | 缓冲区初始化 buffer_init 的内容。
同时，又用一个 hashmap 结构，索引到所有缓冲头，方便快速查找，为之后的通过 LRU 算法使用缓冲区做准备。
这些结构，就是缓冲区部分的管理，而缓冲区的目的是为了加速磁盘的读写效率，后面将读写文件全流程的时候，你会看到它在整个流程中起到中流砥柱的作用。
再往后，通过 trap_init 函数把中断描述符表的一些默认中断都设置好了，随后再由各个模块设置它们自己需要的个性化的中断（比如硬盘中断、时钟中断、键盘中断等）。这是 第14回 | 中断初始化 trap_init 的内容。
再之后，通过 blk_dev_init 对读写块设备（比如硬盘）的管理进行了初始化，比如对硬盘的读写操作，都要封装为一个 request 结构放在 request[] 数组里，后面用电梯调度算法进行排队读写硬盘。这是 第15回 | 块设备请求项初始化 blk_dev_init 的内容。
再往后，通过 tty_init 里的 con_init，实现了在控制台输出字符的功能，并且可以支持换行、滚屏等效果。当然此处也开启了键盘中断，如果此时中断已经处于打开状态，我们就可以用键盘往屏幕上输出字符啦。这是 第16回 | 控制台初始化 tty_init 的内容。
再之后，整个操作系统的精髓，进程调度，其初始化函数 shed_init，定义好了全部进程的管理结构 task[64] 数组，并在索引 0 位置处赋上了初始值，作为零号进程的结构体。这是 第18回 | 进程调度初始化 sched_init 的内容。
然后又将全局描述符表增添了 TSS 和 LDT，用来管理 0 号进程的上下文信息以及内存规划，结构里面具体是什么，先不用管哟。
同时，将这两个结构的地址，告诉 tr 寄存器和 ldt 寄存器，让 CPU 能够找到它们。
随后，开启定时器，以及设置了时钟中断，用于响应定时器每隔 100ms 发来的中断信号。
这样就算把进程调度的初始化工作完成了，之后进程调度就从定时器发出中断开始，先判断当前进程时间片是不是到了，如果到了就去 task[64] 数组里找下一个被调度的进程的信息，切换过去。
这就是进程调度的简单流程，也是后面要讲的一个非常精彩的环节。
最后最后，一个简单的硬盘初始化 hd_init，为我们开启了硬盘中断，并设置了硬盘中断处理函数，此时我们便可以真正通过硬盘的端口与其进行读写交互了。这是 第20回 | 硬盘初始化 hd_init 的内容。
把之前几个模块设置的中断放一块，此时的中断表我们看一下。
| 中断号 | 中断处理函数 |
|---|---|
| 0 ~ 0x10 | trap_init 里设置的一堆 |
| 0x20 | timer_interrupt |
| 0x21 | keyboard_interrupt |
| 0x2E | hd_interrupt |
| 0x80 | system_call |
这里我又提了一嘴，操作系统本质上就是个中断驱动的死循环，这个后面你会慢慢体会到。
而我们再往下看一行 main 方法。
#define sti() __asm__ ("sti"::)
void main(void) {
...
sti();
...
}
是一个 sti 汇编指令，意思是打开中断。其本质上是将 eflags 寄存器里的中断允许标志位 IF 位置 1。（由于已经是 32 位保护模式了，所以我把寄存器也都偷偷换成了 32 位的名字）
这样 CPU 就开始可以接收并处理中断信号了，键盘可以按了，硬盘可以读写了，时钟可以震荡了，系统调用也可以生效了！
这就代表着，操作系统具有了控制台交互能力，硬盘读写能力，进程调度能力，以及响应用户进程的系统调用请求！
至此，全部初始化工作，就结束了！这里有几个初始化函数没有讲，都是可以忽略的，不要担心。
一个是 chr_dev_init，因为这个函数里面本身就是空的，什么也没做。
一个是 tty_init 里的 rs_init，这个方法是串口中断的开启，以及设置对应的中断处理程序，串口在我们现在的 PC 机上已经很少用到了，所以这个直接忽略。
还一个是 floppy_init，这个是软盘的初始化，软盘现在已经被淘汰了，且电脑上也没有软盘控制器了，所以也忽略即可。
第三部分 一个新进程的诞生
整个第三部分，我们用前四回的内容讲述了进程调度机制，又用后三回内容讲述了 fork 函数的全部细节。先看进程调度机制。
进程调度机制
前四回内容循序渐进地讲述了进程调度机制的设计思路和细节。
进程调度的始作俑者，就是那个每 10ms 触发一次的定时器滴答。
而这个滴答将会给 CPU 产生一个时钟中断信号。
而这个中断信号会使 CPU 查找中断向量表，找到操作系统写好的一个时钟中断处理函数 do_timer。
do_timer 会首先将当前进程的 counter 变量 -1，如果 counter 此时仍然大于 0，则就此结束。
但如果 counter = 0 了，就开始进行进程的调度。
进程调度就是找到所有处于 RUNNABLE 状态的进程，并找到一个 counter 值最大的进程，把它丢进 switch_to 函数的入参里。
switch_to 这个终极函数，会保存当前进程上下文，恢复要跳转到的这个进程的上下文，同时使得 CPU 跳转到这个进程的偏移地址处。
上图来源于《Linux内核完全注释V5.0》
接着，这个进程就舒舒服服地运行了起来，等待着下一次时钟中断的来临。
聊完进程调度机制，我们再看看 fork 函数的原理。
fork
后三回内容讲述了 fork 函数的全部细节。
用一张图来表示的话，就是。
其中 copy_process 是复制进程的关键，总共分三步来。
第一，原封不动复制了一下 task_struct。
并且覆盖了一些基本信息，包括元信息和一些寄存器的信息。其中比较重要的是将内核态堆栈栈顶指针的指向了自己进程结构所在 4K 内存页的最顶端。
第二，LDT 的复制和改造，使得进程 0 和进程 1 分别映射到了不同的线性地址空间。
第三，页表的复制，使得进程 0 和进程 1 又从不同的线性地址空间，被映射到了相同的物理地址空间。
最后，将新老进程的页表都变成只读状态，为后面写时复制的缺页中断做准备。
这一部分的 fork 函数只用于进程 0 创造进程 1 的过程，而之后的新进程创建，比如进程 1 里 fork 创建进程 2，也都是这样的套路。
整个核心函数 copy_process 的代码如下。
int copy_process(int nr, ...) {
struct task_struct p =
(struct task_struct *) get_free_page();
task[nr] = p;
*p = *current;
p->state = TASK_UNINTERRUPTIBLE;
p->pid = last_pid;
p->counter = p->priority;
..
p->tss.edx = edx;
p->tss.ebx = ebx;
p->tss.esp = esp;
...
copy_mem(nr,p);
...
set_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,&(p->ldt));
p->state = TASK_RUNNING;
return last_pid;
}
注意图中的两个标黄的代码。
开始复制进程信息的时候，由于进程 1 的结构还没弄好，此时如果进程调度到了进程 1，那就坏事了。
所以一开始把进程 1 的状态先设置为 TASK_UNINTERRUPTIBLE，使得其不会被进程调度算法选中。
而所有复制工作完成后，进程 1 就拥有了运行的内容，进程基本信息也有了，进程的内存规划也完成了。
此时就把进程设置为 TASK_RUNNING，允许被 CPU 调度。
看到这行代码，其实我们也可以很自信地认为，到这里进程 1 的初步建立工作已经圆满结束，可以达到运行在 CPU 上的标准了。
第四部分的展望
那我们此时又该回到之前的 main 方法，是不是都忘了最初的目的了？哈哈。
void main(void) {
...
mem_init(main_memory_start,memory_end);
trap_init();
blk_dev_init();
chr_dev_init();
tty_init();
time_init();
sched_init();
buffer_init(buffer_memory_end);
hd_init();
floppy_init();
sti();
move_to_user_mode();
if (!fork()) {
init();
}
for(;;) pause();
}
看，下一行代码，是 init。
fork 只是把进程 1 搞成可以在 CPU 中运行的进程，之后创建新进程，都可以用这个 fork 方法。
不过进程 1 具体要做什么事情呢？那就是 init 这个函数的故事了。
虽然就一行代码，但这里的事情可多了去了，我们先看一下整体结构。我已经把单纯的日志打印和错误校验逻辑去掉了。
void init(void) {
int pid,i;
setup((void *) &drive_info);
(void) open("/dev/tty0",O_RDWR,0);
(void) dup(0);
(void) dup(0);
if (!(pid=fork())) {
open("/etc/rc",O_RDONLY,0);
execve("/bin/sh",argv_rc,envp_rc);
}
if (pid>0)
while (pid != wait(&i))
/* nothing */;
while (1) {
if (!pid=fork()) {
close(0);close(1);close(2);
setsid();
(void) open("/dev/tty0",O_RDWR,0);
(void) dup(0);
(void) dup(0);
_exit(execve("/bin/sh",argv,envp));
}
while (1)
if (pid == wait(&i))
break;
sync();
}
_exit(0); /* NOTE! _exit, not exit() */
}
是不是看着还挺复杂？
不过还好，我们几乎已经把计算机体系结构，和操作系统的设计思想，通过前面的源码阅读，不知不觉建立起来了。
接下来的工作，就是基于这些建立好的能力，站在巨人的肩膀上，做些更伟大的事情！
说伟大其实也没什么伟大的，就是最终建立好一个人机交互的 shell 程序，无限等待用户输入的命令。
第四部分 shell 程序的到来
整个操作系统终于通过四个部分的讲解，完成了它的启动，达到了一个怠速状态，留下了一个 shell 程序等待用户指令的输入并执行。
具体来说。
通过 第一部分 | 进入内核前的苦力活 完成了执行 main 方法前的准备工作，如加载内核代码，开启保护模式，开启分页机制等工作，对应内核源码中 boot 文件夹里的三个汇编文件 bootsect.s setup.s head.s。
通过 第二部分 | 大战前期的初始化工作 完成了内核中各种管理结构的初始化，如内存管理结构初始化 mem_init，进程调度管理结构初始化 shed_init 等，对应 main 方法中的 xxx_init 系列方法。
通过 第三部分 | 一个新进程的诞生 讲述了 fork 函数的原理，也就是进程 0 创建进程 1 的过程，对应 main 方法中的 fork 函数。
通过 第四部分 | shell 程序的到来 讲述了从加载根文件系统到最终创建出与用户交互的 shell 进程的过程，对应 main 方法中的 init 函数。
至此操作系统启动完毕，达到怠速状态。
纵观整个操作系统的源码，前四部分对应的代码如下，这就是启动流程中的全部代码了。
--- 第一部分 进入内核前的苦力活 ---
bootsect.s
setup.s
head.s
main.c
void main(void) {
--- 第二部分 大战前期的初始化工作 ---
mem_init(main_memory_start,memory_end);
trap_init();
blk_dev_init();
chr_dev_init();
tty_init();
time_init();
sched_init();
buffer_init(buffer_memory_end);
hd_init();
floppy_init();
sti();
--- 第三部分 一个新进程的诞生 ---
move_to_user_mode();
if (!fork()) {
--- 第四部分 shell程序的到来 ---
init();
}
for(;;) pause();
}
------
具体展开第四部分，我们首先通过 第31回 | 拿到硬盘信息 和 第32回 | 加载根文件系统 使得内核具有了以文件系统的形式管理硬盘中的数据的能力。
接下来 第33回 | 打开终端设备文件 使用刚刚建立好的文件系统能力，打开了 /dev/tty0 这个终端设备文件，此时内核便具有了与外设交互的能力，具体可以体现为调用 printf 函数可以往屏幕上打印字符串了。
再接下来，第34回 | 进程2的创建 利用刚刚建立好的文件系统，以及进程 1 的与外设交互的能力，创建出了进程 2，此时进程 2 与进程 1 一样也具有与外设交互的能力，这为后面 shell 程序的创建打好了基础。
然后，进程 2 此时摇身一变，在 第35回 | execve 加载并执行 shell 程序 利用 execve 函数使自己变成了 shell 程序，配合上一回 fork 的进程 2 的过程，这就是 Linux 里经典的 fork + execve 函数。
execve 函数摇身一变的关键，其实就是改变了栈空间中的 EIP 和 ESP 的值，使得中断返回后的地址被程序进行了魔改，改到了 shell 程序加载到的内存地址上。
此时，execve 系统调用的中断返回后，指向了 shell 程序所在的内存地址起始处，就要开始执行 shell 程序了。但此时 shell 程序还没有从硬盘中加载到内存呢，所以此时会触发缺页中断，将硬盘中的 shell 程序（除 exec 头部的其他部分）按需加载到内存，这就是 第36回 | 缺页中断 里讲述的过程。
这回，终于可以开始执行 shell 程序了，在 第37回 | shell 程序跑起来了 中我们以 xv6 源码中的超级简单的 shell 程序源码为例，讲解了 shell 程序的原理。
就是不断读取我们用户输入的命令，创建一个新的进程并执行刚刚读取到的命令，最后等待进程退出，再次进入读取下一条命令的循环中。
// xv6-public sh.c
int main(void) {
static char buf[100];
// 读取命令
while(getcmd(buf, sizeof(buf)) >= 0){
// 创建新进程
if(fork() == 0)
// 执行命令
runcmd(parsecmd(buf));
// 等待进程退出
wait();
}
}
shell 程序是个死循环，我们再回过头来看操作系统的死循环。
在 第38回 | 操作系统启动完毕 中给出了整个操作系统启动代码的鸟瞰视角。
// main.c
void main() {
// 初始化环境
...
// 外层操作系统大循环
while(1) {
// 内层 shell 程序小循环
while(1) {
// 读取命令 read
...
// 创建进程 fork
...
// 执行命令 execve
...
}
}
}
可以看出，不仅 shell 程序是个死循环，整个操作系统也是个死循环。
除此之外，这里所有的键盘输入、系统调用、进程调度，统统都需要中断来驱动，所以很久之前我说过，操作系统就是个中断驱动的死循环，就是这个道理。
OK！到此为止，操作系统终于启动完毕，达到了怠速的状态，它本身设置好了一堆中断处理程序，随时等待着中断的到来进行处理，同时它运行了一个 shell 程序用来接受我们普通用户的命令，以同人类友好的方式进行交互。
------
我们前四个部分，终于把整个操作系统的启动流程讲述清楚了，如果你头脑中已经有像过电影般把整个启动流程清晰地印在脑子里，相信你已经不再恐惧操作系统源码了。
但理解操作系统不单单是启动流程这个视角，还需要内存管理、文件系统、进程调度、设备管理、系统调用等操作系统提供的功能的视角看。
启动流程是一次性的，就这么来一下子，而这些功能是持续不断的，用户程序不断通过系统调用和操作系统提供的这些功能，完成自己想要让计算机帮忙做的事情。
所以接下来的第五部分，我打算用一条 shell 命令的执行过程，来把操作系统这些模块和所提供的功能讲述清楚。
因为一条 shell 命令的执行，包括了内存管理、文件系统、进程调度、设备管理、中断控制、特权级切换等等各方面的内容，实在是把它们都串起来的好办法。
第五部分 一条 shell 命令的执行
一个命令的执行，可以说调用了操作系统所有模块的运作，就光键盘输入命令到 shell 进程读取到这个命令，就涉及到了文件系统以及其下方的字符设备驱动程序。
以及字符设备队列读取时的阻塞与唤醒机制。
扫一扫
4368
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
