操作系统学习笔记5 | 用户级线程 && 内核级线程

在上一部分中，我们了解到操作系统实现多进程图像需要组织、切换、考虑进程之间的影响，组织就是用PCB的队列实现，用到了一些简单的数据结构知识。而本部分重点就是进程之间的切换。

参考资料：

课程：哈工大操作系统（本部分对应 L10 && L11 && L12）
实验：操作系统原理与实践_Linux - 蓝桥云课 (lanqiao.cn)
笔记：操作系统学习导引 · 语雀 (yuque.com)

这一部分比较难，一难在理解，二难在实现，其中L12是最难的，反复看了很多遍。之后需要反复回顾。

1. 用户级线程

1.1 线程

我们聊的是进程切换，为什么引入了线程？

进程 = 资源 + 指令执行序列，资源包括内存映射表等等

实现进程之间的切换是需要消耗资源的，当进程切换频繁，这种消耗就不能忽视了；
是否可以资源不变，而只切换指令执行序列呢？实现了多段程序交替执行，而且不需要切换资源这种消耗时间的操作，时间上还会更快；

实质就是映射表不变而PC指针变
由此引入线程的概念，Thread.
进程 = 一个资源 + 多个指令执行序列（即多个线程）
- 只切换指令执行序列，而不切换资源
- 保留了并发的优点，避免了进程切换代价

本部分专注于线程的切换，而不关注资源的切换，而大的进程切换，需要结合内存管理来理解。

线程切换也是进程切换的一部分，学习线程的切换也就是在学习进程切换的一个部分。

可以理解为：进程切换=线程切换 + 内存映射表切换。

1.2 线程设计的实用性

上面提出了一种轻量化进程的想法，下面分析这种想法是否实用。

以浏览器为例，
- 当前浏览器打开多个 Tab 页面是多进程，而加载同一个页面的不同资源是多线程，比如：js引擎线程；定时触发器线程；GUI渲染线程等等
- 这样就比单线程顺序加载好很多；
- 而且这些线程还要共享资源，比如接收数据的线程从网站上接收的数据还需要在显示文本、显示图片的线程上使用；所以没有必要进行地址分离，在同一套地址上处理更为方便；

1.3 浏览器多线程的设计理解

尝试简单实现这个浏览器多线程模型，借此理解操作系统的实现方式.

//下面代码，启动了多个线程，同时出发

void WebExplorer(){

    char URL[] = "http://cms.hit.edu.cn"

    char buffer[1000];

    pthread_create(...,GetData, URL, buffer);

    pthread_create(...,Show, buffer);

}

// 从网站上下载数据包，如文本、图片

void GetData(char *URL, char *p){...};

// 到显示器上显示内容

void Show(char* p){...};

上面代码只讲了多个线程同时出发，下面还要实现线程之间的交替执行，才叫多线程，才能提高CPU利用率：

需要在线程的执行函数中（如GetData()）增加一些内容

上文提到过的在读写磁盘时释放CPU需要内核级线程的支持，本部分先讲解用户级。用户级线程完全是用户态，不会进入内核。
要想切换用户级线程，需要主动调用 yeild 来释放CPU

可以完全不靠操作系统实现线程切换，也就是说线程切换可以手操切换，这也是多线程编程的理论基础。具体可见yeild源码
比如，当GetData将文本下载完成后，调用yeild主动释放CPU，切换出去，进行文本的显示工作

yield 礼让，让当前线程从运行态进入就绪态，重新与其他线程争夺进入运行态

1.4 Create && Yield 函数理解

Yield 函数

释放CPU控制权，进行进程间的切换，
Create函数

创建线程，就可以实现同时触发多段代码，Create就是要制造出第一次切换时应该的样子

1.4.1 Yield && 线程切换机制

举个实际程序例子：

首先执行A，会跳到B执行，由于B执行完之后会返回A执行，所以要将B函数返回地址104 压栈

这是线程内部的函数调用
B执行时调用了 Yield，于是跳到Yield 去执行，同样地，把返回地址压栈。
Yield 的核心操作就是修改PC指针；在该例子中指向了线程二地址为300的C函数，调用D函数，压栈返回地址304；
执行D函数，又使用了 Yield，压栈404；而此处的Yield的跳转就是找下一个线程需要进行处的程序地址。如果从（2）跳回（3），则为204.
返回左侧204处后进行到右大括号，会成为ret汇编指令，进行弹栈操作，弹出了404，
这样，程序就出错了，因为线程由于函数调用的关系在栈中纠缠起来了。

问题出在哪呢？

我们想要实现的是，单个线程中就做该线程中的事情，因而204返回后应当弹出104，但是弹出了404.
本质问题：两个线程共用了一个栈
我们需要将不同线程的栈分开：如下图所示：

这个跟进程不能共享内存需要地址映射的原因相似，因而处理时采取的操作也类似：

每个线程拥有自己的栈，但切换线程也需要切换栈，需要结构来存储栈的情况；
在线程跳转前，用 TCB 存储栈情况，

TCB：Tread Control Block

ESP（Extended Stack Pointer）：扩展栈指针寄存器
比如线程1切换到线程2时，将左侧的栈放入TCB1（具体操作是esp的当前值1000放入TCB，保存了当前指令地址），切换回来时，就从TCB1中恢复（具体操作为TCB中的esp重新赋值给esp，使其指向原先指令地址）。

线程2 转移到线程1 同理；

栈切换完成后，（栈只存储了函数调用的返回的地址等信息），还需要PC的切换，即进行上图的jmp 204，到达204处向下执行，到达ret指令，要弹栈返回；

结果，弹栈返回204，重新回到了204处。乱套了。
虽然这样保证了函数调用只在一个栈中跳，但是还是出现了问题。

我们想一下204是怎么来的？
- 在调用 Yield() 时，将 204 压入栈中，那就应当在 Yield 返回时弹，而 Yield 返回处实在上图的右括号处，而右括号前面的jmp指令导致其永远不会返回，也就永远弹不出204.
- 所以把 jmp 204 去掉。
  
  即 Yield 只需要切换栈，不需要进行PC的转换
  
  函数调用的压栈机制已经做了这件事。

1.4.2 Create

前面已经提到过了，Create 即做出切换所需的样子：

三样：栈 + TCB + 存放在栈中的返回地址

执行过程：

申请内存分配TCB
申请内存来分配栈
栈顶压入线程的初始地址
TCB中保存栈顶指针
Create返回的时候，从栈里弹出的地址就是线程的初始地址

具体见下面代码：

1.5 梳理整合

上面Create 和 Yield 都明白后，多线程的情况也就基本实现了。可以把上面的浏览器代码和多线程组装在一起：

用一个主程序，开启各个线程，每个线程设计自己的函数进行自己的工作；
在浏览器的各线程中调用 Yield ，使 CPU 进行线程切换。
而通过Yield函数弹栈，实现PC的切换；
将这些函数统一编译在一起，就得到了浏览器

1.6 Yield 是用户程序

为什么这一部分是用户级线程呢？

上述举的例子是浏览器的例子，我们的实现（Yield）也没有涉及太多操作系统的内容， Yield 是一个用户程序层面的函数，完全没有进入内核。

用户级线程是内核级线程切换的子部分，而且这个子部分是可以单独使用，与操作系统的联系并不紧密；理解起来较为简单；

Yeild 中包含next()，它是用来线程调度的，即选择下一个占用CPU的线程
缺点：
- 以上述浏览器为例，执行GetData时，由于时从网上下载数据，需要进行网卡IO，网卡是计算机硬件，要想访问硬件必须通过操作系统；
- 而网卡IO会慢一些，会引发进程阻塞，进而执行其他进程
- 重点来了，由于内核看不到同进程的其他线程，OS 就切换到了其他进程，达不到上述线程切换的效果；
  
  即使CPU只有当前浏览器一个进程，OS 也会空转，因为用户级线程对操作系统不可见。

而核心级线程 ThreadCreate 是系统调用，创建线程时，会进入内核；TCB也在内核中；此时各个线程对于操作系统是可见的，当 GetData 停滞，操作系统就会切换到其他线程（如Show）

内核级线程的并发性更好。

当然，对于内核级线程而言，此时原先的 Yield 成为内核级的程序 Schedule，对于用户就不可访问了。

2. 内核级线程

Kernel Threads.

回到我们提出线程的初心，是想分而治之地实现进程切换，线程切换即进程切换中的指令流切换，而在用户级的线程无法实现进程切换的全部特征（因为进程是在内核中的，用户级线程无法深入内核）。

我们可以通过用户级线程理解线程的相关特点，而前文所说的：进程切换 = 线程切换 + 资源切换（内存管理）中的线程，实际上应当是内核级线程。

而实际上，用户级线程也是内核级线程的一部分。

这部分就主要来看如何切换内核级线程。

2.1 为什么会有内核级线程

核心级线程的优点和必要性原因有很多，我们只挑其中一个讲解。

当前PC机多核居多，如果操作系统不支持核心级线程，那么计算机多核的设计是无效的。
下图左侧为多处理器，右侧为多核；

多处理器架构，每个处理器有自己的缓存、内存映射（MMU）

单个处理器多核架构，只有一套缓存+内存映射，有多个运算部件
两者的区别是多处理器的每个CPU都有自己的一套缓存和MMU（内存映射，Memory Management Unit）；后者多核中多个CPU使用同一套缓存和映射，多个执行序列使用同一套资源和映射，所以多核实际上就是多线程。
而如果我们要使用多核，也即我们要将多个程序分配到多核架构的多个CPU上，这时我们的操作需要面向硬件、分配到物理设备CPU上；需要穿过内核，所以这时线程需要是内核级线程。
小总结，为什么进程不能满足需求呢，以及内核级线程为什么是必要的？

如果没有线程，只有多进程，那么 MMU 内存映射在多进程切换的时候就必须跟着切换，共享的Cache、MMU 就会失去意义，变得很麻烦；
充分发挥多核架构的效果是并行。

并行和并发：
- 并行是同时触发、同时执行，相当于多个人分别同时来做多件事；
- 并发是同时出发交替执行，只有一套资源；相当于一个人干干这个又干干那个；
- 不要把多核、多处理器的架构概念和并行、并发捆绑在一起。两种概念的判定标准并不一样。
如果没有内核级线程，只有用户级线程，那么操作系统内核就无法感知这些线程，也就无法把这些线程分配到多个核上，多核就失去了意义

下图展示的就是，用户程序级别的函数只有通过内核，才能分配到底层的核中合理使用。

2.2 内核级线程实现原理

内核级线程和用户级线程的区别：

用户级线程两个线程之间分用两个栈；
内核级线程两个线程之间分用两套栈；

一套栈是指每个内核级线程有一个用户栈和一个内核栈；进行两个内核级线程的切换就需要切换的两个线程的栈，即两套栈。

关于用户栈和内核栈：

我们平时使用的是在用户级别的程序，所以还是需要用户栈；

而进行内核级线程切换需要进入内核，并且内核中相应也有函数调用，所以需要内核栈。

什么时候会出现内核栈呢？

进入内核时；具体点说，进入内核的唯一方式就是中断；
在用户态执行时就使用用户栈，一有对应中断，操作系统通过硬件会找到内核栈并启用

如何找到内核栈下部分 3 会细说。

收到中断，内核态启用后需要压栈，需要在内核栈中先依次压入源SS、源SP、EFLAGS、源PC、源CS等内容

源SS和源SP是指向用户栈的指针，也就是说内核栈中存放了指向用户栈的指针；源PC和源CS是用户栈中的返回地址；（这点非常重要！）

SS：存放栈顶段地址，SP：存放栈顶偏移地址

EFLAGS 是标志寄存器，用于存放一些标志位，保存当前运行状态；比如进位,溢出,奇偶等等，详见：X86标志寄存器EFLAGS详解

从内核态返回用户态的时候（IRET中断返回指令），会从内核栈弹出这些信息，根据这些信息就可以恢复到用户栈；

2.3 内核级线程原理举例

通过一个例子来看看通过中断进入内核级线程，过程是什么样的。

A调用B，B中不再调用yield，调用read()库函数，展开为一段含 int 0x80 的指令
触发中断，进入内核，启动内核栈
内核栈按次序保存了
- SS:SP，指向用户栈的指针
- EFLAGS，标志位
- 304（PC），返回用户程序的偏移地址
- CS，返回用户程序的段基址
- 1000是调用 sys_read 时压入栈中的PC值，
系统调用返回（IRET）的时候，就会根据 SS:SP 切换回用户栈，根据 CS:PC 切换到用户程序的指令；

那么如何实现内核级线程切换呢？

sys_read 启动磁盘读，将自己变成阻塞，操作系统去找下一个线程并切换

sys_read(){

    //找到next;

    switch_to(cur,next);

    // next 和 cur 分别是下一个和当前的 TCB

}

这里 TCB 和用户级线程相似，依然是要保存当前栈指针，通过下一个内核级线程的 TCB 找到内核栈指针，然后通过 ret 切换到某个内核程序，再通过上面提过的 cs:pc 切换到用户程序。

更详细地说：

用当前的 S 线程的 TCB，把当前S的栈顶地址 esp 存下来；存下来之后，进入到 next 下一个线程 T；

这时要把 T 线程的 TCB 中的栈顶地址拿出来赋给esp寄存器，这样才能把T线程的栈利用起来；

进入 T 线程后，在内核中的工作往往只是任务的一部分，我们还需要回到 T 线程的用户级去进行，所以借助 T 线程的栈中的 PC 和 CS 能够链接到 T 线程的用户态代码，接着去执行它；

而利用 ss:sp 就可以链接到线程 T 的用户栈；

如何实现线程T 栈的切换（即拿到内核栈向用户态切换）？

答：包含 iret 中断返回的代码。
上图问号处的具体填写，如下图：
PC:CS 是500，是函数 C 的开始地址
????是包含 iret 中断返回的代码地址

2.4 内核线程 switch_to 的五段论

这里对 2.3 中的内容再做一次梳理，归纳整理为五个部分。

中断入口：由线程A 的用户态代码进入内核，才能完成内核栈与用户栈的联系
中断处理：引发线程切换，找到下一个线程的TCB

这里引发线程切换的原因有很多，比如操作系统的分时系统，当时钟中断时，也会引出 schedule。
根据找到的TCB ，调用 switch_to；
内核栈切换
中断出口：使用 iret 内核栈返回到线程 B 的用户栈和用户态代码

下部分会再详细讲解这部分的代码。

2.5 ThreadCreate 的实现原理

跟用户级线程一样，讲完线程切换的机制，就要说一说线程的初始化与创建机制（1.4.2的 Create）。

回忆上文内核栈线程切换所需的结构：

用户栈 + 内核栈 + TCB

将它们做成可以如上文切换的样子就可以；

申请一段内存作为 TCB；
申请一段内存作为内核栈；
初始化内核栈；
申请一段用户段内存作为用户栈；
将内核栈指针指向用户栈；
设置函数地址；

此处CS一定是0F，至于为什么，在内存管理处会提及，也可以参见《Linux 源码剖析》。
TCB关联内核栈；

2.6 简单总结

用户级线程、核心级线程的对比，用户级线程和核心级线程搭配的效果最好；

代价：用户级线程完全不需要进入内核，也就不需要额外的内核数据结构，用户想起多少个用户级线程都行，就像浏览器想开多少个标签都行，如果用内核级线程来启动浏览器标签，那么启动多了之后就卡了；
用户灵活性：用户级线程可以由用户利用 Yield 自己实现调度，自己决定什么时候切换，而核心级线程的调度与切换是在内核中提前写好的。

3. 内核级线程实现

这部分来讲内核级线程的具体代码实现。

linux0.11 不支持内核级线程，但是进程和内核级线程非常像，只是没有资源切换。大实验就是在0.11内核上实现内核级线程；

内核级线程的切换过程对用户程序来说是透明的，用户可以看见的只是用户栈、用户级线程的切换。

具体实现过程如下图所示，

切换的原理就是上面第二部分的五段论，两套栈之间的切换

用户栈1通过 int 中断进入内核
内核栈1 -> TCB1
TCB切换，即找到下一个 TCB2
TCB2 -> 内核栈2
完成切换后通过 iret 返回用户态2

3.1 中断入口：进入内核

3.1.1 int 0x80

这一部分应当与上文2.3结合着看。

前面提到过，进入内核靠的是中断，引起中断的原因有很多：系统调用、时钟中断、键盘中断等；我们比较熟悉的是系统调用引起的中断，比如 fork() 这个系统调用。

fork，创建系统线程调用；从这里进去内核就可以看到创建线程、切换线程两个过程。

代码：

main(){

    A();

    B();

}

A(){

    fork();

}

调用main，将返回地址exit压入用户栈
然后main函数中，首先调用A，将返回地址B压入用户栈

A 的返回地址就是 B的初始地址，所以是 ret=B；

接下来进入A函数，调用 fork 函数，fork函数展开成汇编代码：

# 首先将__NR_fork(即系统调用 fork 的编号)放入 eax 寄存器

mov %eax,__NR_fork

# 然后就是int 0x80中断指令，开始做进入内核态的准备工作

INT 0X80

mov res,%eax

现在用户栈为下图中间的模样：

一旦执行 INT 指令，开始做进入内核的准备工作；
- CPU 就找到当前内核栈；
- 在内核栈中压入指向当前用户栈的 SS:SP
- 在内核栈中压入EFLAGS
- cs和ip：压入用户程序的返回地址，即 int 中断指令的下一条；
- int 0x80 对应的是系统调用，开始执行_system_call的代码

3.1.2 _system_call

前面几讲讲过，int0x80是由 system_call 函数来处理的。

这里需要复习第二讲，操作系统接口。当时以 whoami为例讲解了上层用户程序到 sys_write 级别函数的工作机制。

下面来看看 system_call 做了什么：

3.1.1 中，我们依然处于用户态，需要中断进入内核来实现上面所说的压栈工作，这与前文提到的压栈并不矛盾，只是更深入解析其实现过程；
将当前用户态的寄存器等数据放入内核栈中（保存现场），用于将来切换回该线程后弹栈返回该线程的用户层：
```
void sched_init(){

	set_system_gate(0x80,&system_call);

}
```
```
_system_call:

	push %ds..%fs

	push1 %edx...

	call sys_fork

	push1 %eax

	#这一句在3.4中又提到了
```
调用 sys_call_table 表中的 sys_fork进入内核来具体地处理创建线程这件事；

具体sys_fork的功能性代码，即创建进程的过程，这个在3.4 fork时再讲，

到这里就是五段论中的第一段：从用户栈到内核栈的关联建立；接下来需要在内核中进行中间三段。

3.2 中间三段：进行切换

这部分就是五段论中的中间三段

泛化一点讲，进行 sys_fork 级别的功能代码时，可能就会因为需要等待磁盘、键盘等设备响应而引起系统的阻塞，或者遇到系统的时钟阻塞，进而需要进行线程切换。

上文的例子中，sys_fork 的功能代码本身并不会引起阻塞（要想阻塞只会是类似于系统的时钟阻塞），所以在代码 call sys_fork 后会继续向下执行，会有如下判断程序：

mov1 _current,%eax

cmpl $0,state(%eax)

jne reschedule

cmpl $0,counter(%eax)

je reschedule

ret_from_sys_call:

注意这里是AT&T汇编，和 intel 汇编（王爽汇编）刚好反着的。

state 此前存放在PCB中：

current是当前的PCB结构体的地址。state是该结构体的一个成员，如果当前 state≠0，表示当前进程阻塞，就进行系统重新调度（schedule），实现线程切换：reschedule；至于下面又出现了 cmpl $0,counter(%eax)，并跟着一句 je；意思是判断操作系统的时间片是否用光，用光了也需要切换。

切换完后，就是五段论的第五段中断出口 iret ：ret_from_sys_call。见 3.3 中断返回。

reschedule 的汇编代码：

reschedule:

	push1 $ret_from_sys_call

	jmp _schedule

可见放入地址后，调用 _schedule 这个C函数；当C函数返回，就会从栈中弹出，执行上文的 ret_from_sys_call. 返回到用户层。

那么 schedule 引发了什么：

调度 next，依据一定的规则找到下一个线程/进程以及PCB，这个规则后面专门用一篇笔记来学习。
switch_to，linux0.11目前不是用内核栈切换的，而是通过TSS，tasks struct segment进行切换的，实验四是要将其变成基于内核栈Kernel Thread 的切换。

前者实现原理简单，但效率较低；后者是现代操作系统普遍使用的方法。

3.2.1 TSS 切换

intel CPU架构已经实现了这种方式，代码只需要 ljmp一句即可；下面看看这种跳转方式：

ljmp指令是长跳转指令，即TSS段的跳转切换，使用TR寄存器+GDT表，如上图所示：

TSS在内存中，104个字节保存着所有的寄存器的值
TR是TSS段的选择符（选择子），拿这个选择符TR去查GDT表，找到对应的TSS描述符，这个TSS描述符指向了TSS段

这一点跟前几讲中查找GDT表的方式一样。

TR-> GDT表中的TSS的描述符-> TSS段
上面调度算法选择下一个进程后：
1. 原来的TSS段是通过一个TR来查找的（类似于一个指针存贮着任务信息的地址）
2. 当进行核心线切换的时候，会将TR指向第二个线程描述符，也就是通过调度算法找到的线程n，其对应的TSS(n)
3. 第2步中，将TR切换到新的线程段，所以将此时的线程信息填入到CPU中
  
  这里的 TSS(n) 中的 n 就是 GDT 表的索引

参考资料：《Linux内核完全解析》第五章

具体代码如下，是一段内嵌汇编，具体语义不细说了，就是上面的过程。

分析：

与内核栈的对比：TSS记录了所有的信息，而内核栈只记录必要的信息，并且利用函数调用栈的特性少记信息。
由于TSS保存了很多东西，所以切换很慢（保存现场和恢复现场的过程很慢），并且只用ljmp一条指令完成，也不能通过指令流水来优化，不能充分利用CPU的流水线加速

3.2.2 内核栈切换

这部分在实验四中，具体实现在实验中体会。

TSS方案：核心就是3条指令：int、switch_to中的ljmp、iret，再加上其它的代码，总共加起来20、30句；
改成栈的方案，也不会超过100句。

3.3 中断返回：返回用户态

前面3.2中3.2.1 之前的部分讲解到，ret_from_sys_call会实现返回用户层。

ret_from_sys_call:

	pop1 %eax

	pop %fs... ###一堆pop弹栈，弹出用户的东西

	iret ###最核心代码，返回到用户层

3.4 ThreadCreate | fork

3.4.1 fork 过程 && copy_process参数表

前文3.1.2中讲到了 sys_fork 的功能代码，下面继续接着这里向更深处讲解：

fork实际上是 linux 中创建子进程的一种方式，创建子进程，所以可以通过 fork 这个系统调用看看 ThreadCreate 的过程。

fork实际上要做的是，把原来的进程一分为二，一条为调用fork的父进程，另一条是父进程调用fork函数copy出来的子进程。

形状上像一个叉子。

sys_fork的功能代码如下图：

push语句，将当前进程的参数压入父进程的内核栈
调用了 copy_process 这个C函数，将上述参数传递给子进程；
调用 copy_process 时就会倒序从栈里取出参数，按照这些参数来创建子进程；
copy_process 的参数表与栈的对应情况：

（注意这里栈被分为左右两部分：
- 栈里的eax对应第一个参数int nr
- 栈里的ebp对应第二个参数long ebp
- ......
- 栈里的ret= ??1 对应参数 long eip，也就是int 0x80的下一条指令的地址作为返回地址，
  
  这里可见3.1.1 int0x80，也就是上面所说的B函数。
- 右部分的最底端就是 _sys_fork的第一条push指令放入的 gs
- 右部分的最顶端 ??4 就是 call _copy_process的时候的PC，对应指令 addl $20, %esp
- 左部分的最顶端 ??2 就是 call _sys_fork 的时候的PC，翻到上面的图可以看到，对应的指令是 pushl %eax
左部分的内容是从进入 int 0x80 中断到 call _sys_fork之前就准备好的，右部分的内容是进入 sys_fork 后才准备的参数
这样子进程就跟父进程基本一样；（只有一个地方有差别）

3.4.2 copy_proces 的细节

回忆一下前文2.5中的创建进程需要做的事情：

申请内存空间

创建TCB

创建内核栈和用户栈

填写两个栈

关联栈和TCB

copy_process 要做的事情是：

申请内存创建TCB
- get_free_page()；获得一页内存；
  
  而不是 malloc（用户态代码），这一点后续内存管理会讲；
- 页：系统初始化时，mem_map 将内存打成4k为单位的单元格；这里的 PAGE_SIZE 就是 4k。
- 通过强制类型转换作为PCB
- p是页的初始地址
初始化TSS，创建内核栈和用户栈：

注意，这里是3.2中TSS的切换方案，没有使用内核栈和用户栈，只是说相当于设置用户栈和内核栈

这里esp0表示内核栈；esp表示用户栈；
- esp0指向页的顶端地址
- 0x10 表示内核数据段和内核堆栈段（一个段）
- 这样如下图所示，一页内存中底下是PCB，上面是内核栈；这样内核栈和PCB就设置好了；
- --------------------下面是设置用户栈---------------------------
- ss 和 esp 是上文 3.4.1 中的 copy_process 中的参数表的内容；由父进程传递给当前正要创建的子进程；
- 这说明：父进程和子进程用的是相同的用户栈
  
  当然，内核栈是分开的，用户栈可以共用。
- 并且这句话也关联了栈和TCB
  
  至此，除了填写两个栈没有做，其他四步都做了
- 而填写栈不需要，因为基于内核栈切换中，主要填写eip，而TSS切换中eip已经存入TSS，不需要填写栈，只需要用TSS初始化一下即可。
  
  eip是int指令执行后的下一句话，本文例子中的B函数

接下来初始化TSS，即使用copy_process传入的参数来初始化子进程的TSS。

p->tss.eip =父进程传入的 eip，也就是说返回用户态后，执行的第一条指令地址（int 0x80的下一条指令）和父进程保持一致
p->tss.cs 同理
p->tss.eax 置为0，eax保存的是返回值，见上文3.1.1中的汇编代码最后一句；

看下面我对于整个过程的梳理

剩下的部分与内存管理有关。

nr不是地址，而是task数组中空闲task_struct的标号！

下面梳理一下整个父子进程的过程：

在A函数中运行，遇到了fork，也就是父进程执行如下汇编代码（3.1.1~3.2的例子，以及其对应的汇编）

# 首先将__NR_fork(即系统调用 fork 的编号)放入 eax 寄存器

mov %eax,__NR_fork

# 然后就是int 0x80中断指令，开始做进入内核态的准备工作

INT 0X80

mov res,%eax

fork 执行完毕，新建了一个子进程，此时还没有执行子进程。则int指令结束，返回，接下来会执行 3.1.2 中的 _system_call
虽说fork的功能代码不会引发阻塞，但是我们假设其引发了阻塞（比如系统的时间片用完了，需要切换），于是system_call检测到阻塞，的调度下一个进程后，进行 switch_to
switch_to 切换到子进程，子进程进行3.2.1 中的TSS切换，由于前文提过的父子进程的eip相同，则子进程开始就工作上面汇编代码的最后一句 mov res,%eax，这里子进程的eax已经被赋值为0

操作系统学习笔记4中的4.1 中提到过if(!fork()){...}的经典语句。

而子进程调用fork()的返回值是0，父进程调用fork()的返回值是1，所以通常会用fork()的返回值区分是父进程还是子进程来编写代码。

达成的效果就是：

子进程执行 if 语句段内的语句；父进程跳过不执行；

形成了一个叉子（fork）状的分叉

3.5 如何执行我们的代码\实际举例

上述过程已经回扣了例子，可能还是抽象，用操作系统学习笔记4中终端shell 的例子再说明一下。

下图可见，子进程通过 if语句结构，在父进程的壳子里（shell终端），执行自己的功能，比如 ls （子进程）在终端（父进程）里，但是执行自己显示目录的功能。

简单看看 exec 的系统调用讲解（此时就是子进程了）：

exec 内部调用的是 sys_execve；
子进程在sys_execve之前执行的就是 fork 的代码（与父进程相同），fork 的代码准备好了子进程的内核栈，大部分信息来自父进程
随后子进程执行 _sys_execve，找到了命令功能性代码（实际上编译完成后是可执行文件），从可执行文件中取出必要的信息

例如可执行文件的入口地址，即第一条指令的地址

用这些信息修改了内核栈中用于 IRET 的参数，即返回地址，使得从sys_execve返回（IRET）后，就转而去执行输入的命令，之后执行的指令和父进程就完全没关系了

sys_execve（最后这里没太懂原理，涉及了编译）

下图2中就有 _sys_execve 的汇编代码

首先计算得到栈中EIP的地址

0x1C是28，esp+28就是 ret=??1 的位置，也就是返回用户程序的地址

压入栈中，作为 do_execve的参数，然后 call _do_execve
do_execve的代码如下2图

将栈中EIP修改为ex.a_entry，即可执行程序的入口地址

同时修改了即eip[3]即 SP为当前申请的页内存

ex.a_entry 是可执行程序入口地址，在编译时产生可执行文件时写入。

4. 总结

理解 switch_to 对应的栈切换，将自己变成计算机，能够执行整个过程
ThreadCreate的目的就是初始化一套栈。