YouDieInADream

Nope.

Series One of Basic of Virtulization - Processes and API

发布于 2020-08-15 | 标签: 存储 、 读书笔记 、 OS | 18分钟 | 4417字数 | 浏览量::
  • 威斯康辛州大学操作系统书籍《Operating Systems: Three Easy Pieces》读书笔记系列之 Virtulization（虚拟化）。本篇为虚拟化技术的基础篇系列第一篇（Processes and API），进程和进程API。
  • 突然看到知乎上 关于七龙珠里龟仙人和鹤仙人的讨论，相比之下龟仙人的徒弟之所以更强除了天赋以外，更多的是龟仙人的信奉的理念。基础打好了，一拳一招就是招式。龟仙流的训练方法就是 好好锻炼、好好学习、好好玩耍、好好吃饭、好好睡觉。
  • 龟仙流的训练方法字面上仿佛与平安经无异，但传递的其实是习武最本质的内涵。以无法为有法，以无限为有限。做学术亦是如此，所以比起漫无目的地看论文，还是再回顾回顾一知半解的基础吧。
  • 威斯康辛州大学操作系统书籍《Operating Systems: Three Easy Pieces》读书笔记系列之 Virtulization（虚拟化）。本篇为虚拟化技术的基础篇系列第一篇（Processes and API），进程和进程API。

Chapter Index

  • TODO

Virtualization

Dialogue

  • Conversation 以桃子为例，即多人共享一个桃子，但是每个人可能都以为自己完整拥有这个桃子，然后联系到计算机领域中的资源，如 CPU。物理上就有限的 CPU（比如只有一个 CPU），但是当很多用户或者进程使用时，完全以为这个 CPU 就是自己的，这就是虚拟化技术。

Processes

  • 进程：运行的程序。
  • 程序本身无生命。就是存储在磁盘上的一系列指令的集合，包括一些静态数据，然后等待执行。操作系统会从磁盘中读取出这些指令并执行，从而运行程序。
  • 一次可能会运行很多个程序，一个系统看起来可能同时运行了上百上千个程序，系统的易用性使得程序不用考虑是否有 CPU 空闲，所以就引出了关键问题：如何表现出有成百上千个 CPU 的假象？ 答案就是 虚拟化。
  • CPU 资源常常会使用到 时分共享（time sharing）的技术，即允许一个实体使用该资源一段时间后停止，由另一个实体使用该资源持续一段时间，如此循环往复，来保证资源共享。CPU 上的时分共享最终就能让人感觉到大量程序并发地被执行。

资源共享技术中除了时分共享以外，还有空分共享。如磁盘就是空分共享资源，磁盘上的空间被释放后则可以被其他实体使用。

  • 虚拟化需要两层实现：
    • 底层实现称之为 mechanism，主要是实现一些低级方法和协议。
    • 上层实现为 policy，即需要在操作系统中需要借助一定的数据依据做出某种决策，也称之为调度策略。

抽象：进程

  • 操作系统对运行的程序的抽象即为进程。
  • 进程的组成，也就是所谓的 machine state:
    • memory，正在运行的程序、读取或写入的数据都在内存中，进程可以访问的内存即为进程的一部分（也称地址空间 address space）
    • register，寄存器。许多指令需要读取或更新寄存器。还包括一些比较重要的寄存器，如 program counterm (或者叫 instruction pointer) 来指示程序运行的下一个位置，还有 stack pointer 以及 frame pointer 用于管理函数参数、局部变量、返回值地址等。
    • 还有一些打开的 I/O 描述符（eg. open file table）

进程 API 分类

  • create
  • destroy
  • wait：等待进程停止运行
  • miscellaneous control：常用于暂停某个进程，然后恢复执行
  • status：获取进程状态信息

进程创建

  • 操作系统运行程序必须做的第一件事是将代码和所有静态数据（例如初始化变量）加载（load）到内存中，加载到进程的地址空间中。程序最初以某种可执行格式驻留在磁盘上（disk，或者在某些现代系统中，在基于闪存的 SSD 上）。因此，将程序和静态数据加载到内存中的过程，需要操作系统从磁盘读取这些字节，并将它们放在内存中的某处（见图 4.1）。
    20200814112847
  • 在早期的（或简单的）操作系统中，加载过程尽早（eagerly）完成，即在运行程序之前全部完成。现代操作系统惰性（lazily）执行该过程，即仅在程序执行期间需要加载的代码或数据片段，才会加载。
  • 将代码和静态数据加载到内存后，操作系统在运行此进程之前还需要执行其他一些操作。必须为程序的运行时栈（run-time stack 或 stack）分配一些内存。C 语言程序使用栈存放局部变量、函数参数和返回地址，操作系统分配这些内存，并提供给进程。操作系统也可能会用参数初始化栈。具体来说，它会将参数填入 main() 函数，即 argc 和 argv 数组。
  • 操作系统也可能为程序的堆（heap）分配一些内存。在 C 程序中，堆用于显式请求的动态分配数据。程序通过调用 malloc()来请求这样的空间，并通过调用 free()来明确地释放它。数据结构（如链表、散列表、树和其他有趣的数据结构）需要堆。起初堆会很小。随着程序运行，通过 malloc()库 API 请求更多内存，操作系统可能会参与分配更多内存给进程，以满足这些调用。
  • 操作系统还会执行一些 I/O 相关的初始化任务。
  • 通过将代码和静态数据加载到内存中，通过创建和初始化栈以及执行与 I/O 设置相关的其他工作，OS 现在（终于）为程序执行搭好了舞台。然后它有最后一项任务：启动程序，在入口处运行，即 main()。通过跳转到 main() 例程，OS 将 CPU 的控制权转移到新创建的进程中，从而程序开始执行。

进程状态

  • running
  • ready
  • block
    20200814114542

数据结构

  • 如下所示为 xv6 内核中进程的数据结构定义。
    • context 包含了所有寄存器的信息，便于进程的恢复，也就是我们常常说到的 context switch。所以进程中的上下文切换的本质其实就是寄存器数据的切换。
    • proc_state 除了上文所述的三种状态以外还有其他状态，如 EMBRYO 表示进程在创建时处于的状态；ZOMBIE 表示进程已经退出但尚未清理的状态，该状态将允许其他进程检查该进程的执行情况来决定下一步操作。
// the registers xv6 will save and restore
// to stop and subsequently restart a process
struct context {
  int eip;
  int esp;
  int ebx;
  int ecx;
  int edx;
  int esi;
  int edi;
  int ebp;
};

// the different states a process can be in
enum proc_state { UNUSED, EMBRYO, SLEEPING, 
                  RUNNABLE, RUNNING, ZOMBIE };

// the information xv6 tracks about each process
// including its register context and state
struct proc {
  char *mem; // Start of process memory
  uint sz; // Size of process memory
  char *kstack; // Bottom of kernel stack for this process

  enum proc_state state; // Process state
  int pid; // Process ID
  struct proc *parent; // Parent process
  void *chan; // If !zero, sleeping on chan
  int killed; // If !zero, has been killed
  struct file *ofile[NOFILE]; // Open files
  struct inode *cwd; // Current directory
  struct context context; // Switch here to run process
  struct trapframe *tf; // Trap frame for the current interrupt
};

进程列表 process list 被用于跟踪系统中正在运行的所有程序，任何能够同时运行多个程序的操作系统都包含这样的数据结构，进程列表中的每一个进程信息块常常又被称为进程控制块（Process Control Block, PCB）

Process API

  • 主要涉及到一组系统调用 fork() 和 exec() 以及 wait() 的使用。
  • CRUX：OS 为了创建以及控制进程需要提供什么样的接口？如何设计这些接口以实现强大的功能、易用性和高性能？

fork()

  • 用于创建一个新进程。
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <unistd.h>
4
5 int main(int argc, char *argv[]) {
6   printf("hello world (pid:%d)\n", (int) getpid());
7   int rc = fork();
8   if (rc < 0) {
9     // fork failed
10    fprintf(stderr, "fork failed\n");
11    exit(1);
12   } else if (rc == 0) {
13    // child (new process)
14    printf("hello, I am child (pid:%d)\n", (int) getpid());
15   } else {
16    // parent goes down this path (main)
17    printf("hello, I am parent of %d (pid:%d)\n", 
18            rc, (int) getpid());
19  }
20  return 0;
21 }
  • 输出如下：p1 进程首先输出了自己的进程 ID (process identifier)，然后执行 fork 创建新进程。新创建的进程叫子进程。原进程为父进程。此例中即为 29146 进程创建了子进程 29147。父进程按照原有的逻辑继续执行，子进程则是从 fork 调用后返回，所以才出现如下的输出结果。
  • 此时的系统中相当于有两个 p1 进程，但是子进程和父进程不完全相同，除了拥有各自的地址空间、寄存器、PC 以外，fork 的返回值也是不同的。父进程的 fork 返回的是子进程的值，子进程的 fork 返回的是 0。
prompt> ./p1
hello world (pid:29146)
hello, I am parent of 29147 (pid:29146)
hello, I am child (pid:29147)
prompt>
  • fork 之后其执行顺序就不太确定了，即此时存在两个活动的进程，如果是单个 CPU，则任何一个进程都有可能去执行，所以输出结果的顺序就不确定了。
prompt> ./p1
hello world (pid:29146)
hello, I am child (pid:29147)
hello, I am parent of 29147 (pid:29146)
prompt>
  • CPU Scheduler 决定了某个时刻执行哪个进程。但由于调度程序很复杂，并不能假设某个进程会先执行。这种不确定性就会导致一系列问题，特别是在多线程程序中，也就是我们说的并发。

wait()

  • 有时候父进程需要等待子进程执行完毕再决定下一步操作，这时候 wait 就发挥作用了。
  • 如下代码中，父进程调用了 wait 延迟自己的执行，直到子进程执行完毕。子进程结束时，wait 才返回父进程。
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <unistd.h>
4 #include <sys/wait.h>
5
6 int
7 main(int argc, char *argv[])
8 {
9   printf("hello world (pid:%d)\n", (int) getpid());
10  int rc = fork();
11  if (rc < 0) { // fork failed; exit
12    fprintf(stderr, "fork failed\n");
13    exit(1);
14  } else if (rc == 0) { // child (new process)
15    printf("hello, I am child (pid:%d)\n", (int) getpid());
16  } else { // parent goes down this path (main)
17    int wc = wait(NULL);
18    printf("hello, I am parent of %d (wc:%d) (pid:%d)\n",
19      rc, wc, (int) getpid());
20  }
21  return 0;
22 }
  • 输出结果的顺序一下就明确了，如果父进程先执行，会执行 wait，该调用会在子进程运行结束后才返回，因此还是会等待子进程先执行。
prompt> ./p2
hello world (pid:29266)
hello, I am child (pid:29267)
hello, I am parent of 29267 (wc:29267) (pid:29266)
prompt>

exec()

  • 用于执行和父进程不同的程序。
  • 如下所示代码中则调用了 execvp() 来执行字符计数程序 wc，并使用 p3.c 作为输入参数
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <unistd.h>
4 #include <string.h>
5 #include <sys/wait.h>
6
7 int
8 main(int argc, char *argv[])
9 {
10  printf("hello world (pid:%d)\n", (int) getpid());
11  int rc = fork();
12  if (rc < 0) { // fork failed; exit
13    fprintf(stderr, "fork failed\n");
14    exit(1);
15  } else if (rc == 0) { // child (new process)
16    printf("hello, I am child (pid:%d)\n", (int) getpid());
17    char *myargs[3];
18    myargs[0] = strdup("wc"); // program: "wc" (word count)
19    myargs[1] = strdup("p3.c"); // argument: file to count
20    myargs[2] = NULL; // marks end of array
21    execvp(myargs[0], myargs); // runs word count
22    printf("this shouldn't print out");
23  } else { // parent goes down this path (main)
24    int wc = wait(NULL);
25    printf("hello, I am parent of %d (wc:%d) (pid:%d)\n",
26    rc, wc, (int) getpid());
27  }
28  return 0;
29 }
  • 输出如下所示。exec() 会从可执行程序中加载代码和静态数据，并覆盖写自己的代码段，栈、堆以及其他内存空间也会被初始化，然后操作系统执行该程序，将参数通过 argv 传递给该进程。因此，它并没有创建新进程，而是直接将当前运行的程序（以前的 p3）替换为我同的运行程序（wc）。子进程执行 exec()之后，几乎就像 p3.c 从未运行过一样。对 exec() 的成功调用永远不会返回。
prompt> ./p3
hello world (pid:29383)
hello, I am child (pid:29384)
 29 107 1030 p3.c
hello, I am parent of 29384 (wc:29384) (pid:29383)
prompt>

为什么这样设计？

  • 分离 fork 和 exec 便于 shell 在 fork 之后 exec 之前调整新程序的环境。
  • shell 也是一个用户程序，它首先显示一个提示符（prompt），然后等待用户输入。你可以向它输入一个命令（一个可执行程序的名称及需要的参数），大多数情况下，shell 可以在文件系统中找到这个可执行程序，调用 fork() 创建新进程，并调用 exec() 的某个变体来执行这个可执行程序，调用 wait() 等待该命令完成。子进程执行结束后，shell 从 wait()返回并再次输出一个提示符，等待用户输入下一条命令。
  • shell 还可以实现一些有趣的功能，譬如重定向。如下所示将输出结果重定向到文件中
prompt> wc p3.c > newfile.txt

  • shell 实现结果重定向的方式也很简单，当完成子进程的创建后，shell 谁调用 exec() 之前先关闭了标准输出（standard output），打开了文件 newfile.txt。这样，即将运行的程序 wc 的输出结果就被发送到该文件，而不是打印在屏幕上。

  • 如下代码展示了重定向的工作原理，是基于对操作系统管理文件描述符方式的假设。具体来说，UNIX 系统从 0 开始寻找可以使用的文件描述符。谁这个例子中，STDOUT_FILENO 将成为第一个可用的文件描述符，因此谁 open()被调用时，得到赋值。然后子进程向标准输出文件描述符的写入（例如通过 printf()这样的函数），都会被透明地转向新打开的文件，而不是屏幕。

1 #include <stdio.h>
2 #include <stdlib.h> 
3 #include <unistd.h>
4 #include <string.h>
5 #include <fcntl.h>
6 #include <sys/wait.h>
7
8 int
9 main(int argc, char *argv[])
10 {
11  int rc = fork();
12  if (rc < 0) { // fork failed; exit
13    fprintf(stderr, "fork failed\n");
14    exit(1);
15  } else if (rc == 0) { // child: redirect standard output to a file
16    close(STDOUT_FILENO);
17    open("./p4.output", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
18
19    // now exec "wc"...
20    char *myargs[3];
21    myargs[0] = strdup("wc"); // program: "wc" (word count)
22    myargs[1] = strdup("p4.c"); // argument: file to count
23    myargs[2] = NULL; // marks end of array
24    execvp(myargs[0], myargs); // runs word count
25  } else { // parent goes down this path (main)
26    int wc = wait(NULL);
27  }
28  return 0;
29 }
  • 输出结果如下。
prompt> ./p4
prompt> cat p4.output
 32 109 846 p4.c
prompt>
  • UNIX 管谁也是用类似的方式实现的，但用的是 pipe()系统调用。在这种情况下，一个进程的输出被链接到了一个内核管谁（pipe）上（队列），另一个进程的输入也被连接到了同一个管谁上。因此，前一个进程的输出无缝地作为后一个进程的输入，许多命令可以用这种方式串联谁一起，共同完成某项任务。比如通过将 grep、wc 命令用管谁连接可以完成从一个文件中查找某个词，并统计其出现次数的功能：grep -o foo file | wc -l

其他

  • 除了上述接口以外，还有很多其他系统调用接口用于进程的管理。譬如 kill() 向进程发送信号，还有如暂停等其他指令。为了方便起见，在大多数 UNIX shell中，配置某些按键组合以向当前运行的进程发送特定的信号，如常用的 ctrl-c 来中断进程，ctrl-z 来暂停进程
  • 整个信号子系统提供了丰富的基础设施来向流程交付外部事件，包括在各个流程内接收和处理这些信号的方法，以及向各个流程和整个流程组发送信号的方法。为了使用这种通信方式，进程应该使用 signal() 系统调用来“捕捉”各种信号;这样做可以确保当一个特定的信号被传递给一个进程时，它会暂停它的正常执行，并运行一个特定的代码片段来响应这个信号。
  • 谁可以发送信号？用户可以启动一个或多个进程，并对它们进行完全控制(暂停它们，杀死它们，等等)。
    用户通常只能控制自己的进程;操作系统的工作是将资源(如CPU、内存和磁盘)分配给每个用户(及其进程)，以满足总体系统目标。
  • ps、top、kill、killall
  • “A fork() in the road” by Andrew Baumann, Jonathan Appavoo, Orran Krieger, Timothy Roscoe. HotOS ’19, Bertinoro, Italy. 该文指出了 fork 存在的一些问题，考虑使用 spawn() 来代替 fork(). 参考：fork() 成为负担，需要淘汰 spawn
# 存储 # 读书笔记 # OS
Series Two of Basic of Virtulization - Mechanism and Policy Part.1 上一篇
GearDB: A GC-free Key-Value Store on HM-SMR Drives with Gear Compaction 下一篇
已运行:
浏览数: 次 | 访客数: 人
Powered by Gridea
0%