Linux教程

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

本文主要是介绍操作系统学习笔记5 | 用户级线程 && 内核级线程，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

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

参考资料：

  • 课程：哈工大操作系统（本部分对应 L10 && L11 && L12）

  • 实验：操作系统原理与实践_Linux - 蓝桥云课 (lanqiao.cn)

  • 笔记：操作系统学习导引 · 语雀 (yuque.com)

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

1. 用户级线程

1.1 线程

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

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

    实现进程之间的切换是需要消耗资源的，当进程切换频繁，这种消耗就不能忽视了；

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

    实质就是映射表不变而PC指针变

  • 由此引入线程的概念，Thread.

  • 进程 = 一个资源 + 多个指令执行序列（即多个线程）

    • 只切换指令执行序列，而不切换资源
    • 保留了并发的优点，避免了进程切换代价

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

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

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

image.png

image.png

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 礼让，让当前线程从运行态进入就绪态，重新与其他线程争夺进入运行态

image.png

1.4 Create && Yield 函数理解

  • Yield 函数

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

  • Create函数

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

1.4.1 Yield && 线程切换机制

举个实际程序例子：

image.png

  • 首先执行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.
  • 本质问题：两个线程共用了一个栈
  • 我们需要将不同线程的栈分开：如下图所示：

image.png

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

  • 每个线程拥有自己的栈，但切换线程也需要切换栈，需要结构来存储栈的情况；

  • 在线程跳转前，用 TCB 存储栈情况，

    TCB：Tread Control Block

    ESP（Extended Stack Pointer）：扩展栈指针寄存器

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

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

    image.png

    栈切换完成后，（栈只存储了函数调用的返回的地址等信息），还需要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返回的时候，从栈里弹出的地址就是线程的初始地址

具体见下面代码：

image.png

1.5 梳理整合

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

  • 用一个主程序，开启各个线程，每个线程设计自己的函数进行自己的工作；

  • 在浏览器的各线程中调用 Yield ，使 CPU 进行线程切换。

  • 而通过Yield函数弹栈，实现PC的切换；

  • 将这些函数统一编译在一起，就得到了浏览器

image.png

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）
    单个处理器多核架构，只有一套缓存+内存映射，有多个运算部件

    image.png

  • 两者的区别是多处理器的每个CPU都有自己的一套缓存和MMU（内存映射，Memory Management Unit）；后者多核中多个CPU使用同一套缓存和映射，多个执行序列使用同一套资源和映射，所以多核实际上就是多线程。

  • 而如果我们要使用多核，也即我们要将多个程序分配到多核架构的多个CPU上，这时我们的操作需要面向硬件、分配到物理设备CPU上；需要穿过内核，所以这时线程需要是内核级线程。

  • 小总结，为什么进程不能满足需求呢，以及内核级线程为什么是必要的？

    如果没有线程，只有多进程，那么 MMU 内存映射在多进程切换的时候就必须跟着切换，共享的Cache、MMU 就会失去意义，变得很麻烦；

    充分发挥多核架构的效果是并行。

    并行和并发：

    • 并行是同时触发、同时执行，相当于多个人分别同时来做多件事；
    • 并发是同时出发交替执行，只有一套资源；相当于一个人干干这个又干干那个；
    • 不要把多核、多处理器的架构概念和并行、并发捆绑在一起。两种概念的判定标准并不一样。

    如果没有内核级线程，只有用户级线程，那么操作系统内核就无法感知这些线程，也就无法把这些线程分配到多个核上，多核就失去了意义

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

image.png

2.2 内核级线程实现原理

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

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

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

关于用户栈和内核栈：

  • 我们平时使用的是在用户级别的程序，所以还是需要用户栈；
  • 而进行内核级线程切换需要进入内核，并且内核中相应也有函数调用，所以需要内核栈。

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

  • 进入内核时；具体点说，进入内核的唯一方式就是 中断；

  • 在用户态执行时就使用用户栈，一有对应中断，操作系统通过硬件会找到内核栈并启用

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

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

image.png

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

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

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

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

2.3 内核级线程原理举例

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

image.png

  • 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 切换到用户程序。

    image.png

    更详细地说：

    用当前的 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 中断返回的 代码地址

image.png

2.4 内核线程 switch_to 的五段论

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

  1. 中断入口：由 线程A 的 用户态代码进入内核，才能完成内核栈与用户栈的联系

  2. 中断处理：引发线程切换，找到下一个线程的TCB

    这里引发线程切换的原因有很多，比如操作系统的分时系统，当时钟中断时，也会引出 schedule。

  3. 根据 找到的TCB ，调用 switch_to；

  4. 内核栈切换

  5. 中断出口：使用 iret 内核栈返回到线程 B 的用户栈和用户态代码

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

image.png

2.5 ThreadCreate 的实现原理

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

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

  • 用户栈 + 内核栈 + TCB

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

  • 申请一段内存作为 TCB；

  • 申请一段内存作为 内核栈；

  • 初始化内核栈；

  • 申请一段用户段内存作为用户栈；

  • 将内核栈指针指向用户栈；

  • 设置函数地址；

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

  • TCB关联内核栈；

image.png

2.6 简单总结

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

image.png

  • 代价：用户级线程完全不需要进入内核，也就不需要额外的内核数据结构，用户想起多少个用户级线程都行，就像浏览器想开多少个标签都行，如果用内核级线程来启动浏览器标签，那么启动多了之后就卡了；

  • 用户灵活性：用户级线程可以由用户利用 Yield 自己实现调度，自己决定什么时候切换，而核心级线程的调度与切换是在内核中提前写好的。

3. 内核级线程实现

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

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

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

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

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

image.png

  • 用户栈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的代码

image.png

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. 返回到用户层。

image.png

image.png

那么 schedule 引发了什么：

  1. 调度 next，依据一定的规则找到下一个线程/进程以及PCB，这个规则后面专门用一篇笔记来学习。

  2. switch_to，linux0.11目前不是用内核栈切换的，而是通过TSS，tasks struct segment进行切换的，实验四是要将其变成基于 内核栈Kernel Thread 的切换。

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

3.2.1 TSS 切换

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

image.png

  • 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内核完全解析》第五章

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

image.png image.png

分析：

  • 与 内核栈的对比：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 后才准备的参数

  • 这样子进程就跟父进程基本一样；（只有一个地方有差别）

image.png

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函数

image.png

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

  • p->tss.eip =父进程传入的 eip，也就是说返回用户态后，执行的第一条指令地址（int 0x80的下一条指令）和父进程保持一致

  • p->tss.cs 同理

  • p->tss.eax 置为0，eax保存的是返回值，见上文3.1.1中 的汇编代码最后一句；

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

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

image.png

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

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

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

    # 首先将__NR_fork(即系统调用 fork 的编号)放入 eax 寄存器
mov %eax,__NR_fork
# 然后就是int 0x80中断指令，开始做进入内核态的准备工作
INT 0X80
mov res,%eax

  2. fork 执行完毕，新建了一个子进程，此时还没有执行子进程。则int指令结束，返回，接下来会执行 3.1.2 中的 _system_call

  3. 虽说fork的功能代码不会引发阻塞，但是我们假设其引发了阻塞（比如系统的时间片用完了，需要切换），于是system_call检测到阻塞，的调度下一个进程后，进行 switch_to

  4. 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 是可执行程序入口地址，在编译时产生可执行文件时写入。

image.png

image.png

4. 总结

  • 理解 switch_to 对应的栈切换，将自己变成计算机，能够执行整个过程
  • ThreadCreate的目的就是初始化一套栈。
这篇关于操作系统学习笔记5 | 用户级线程 && 内核级线程的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
栏目导航