操作系统之进程基础

最新推荐文章于 2023-11-29 19:00:00 发布

zhabit

最新推荐文章于 2023-11-29 19:00:00 发布

阅读量365

点赞数

文章标签：操作系统进程 fork 系统调用 trap handler

本文链接：https://blog.csdn.net/wen524/article/details/89146812

版权

进程

A process is simply a running program

进程是对操作系统如何运行程序的一种抽象。

进程的组成：由程序运行过程中的机器状态(machine state)决定

内存：程序的代码（指令）和静态数据必须先载入内存，所以进程必须包括它可寻址的内存（address space）。
寄存器：指令由CPU执行，包括取指令，操作数据等等，由CPU中的各种寄存器完成；
- 通用寄存器，用于传送和暂存数据，也可用于参与运算并保存运算结果（如累加器）。
- 程序计数器（program counter ），也叫指令指针（instruction pointer），记录当前正被执行的指令。
- 栈指针（stack pointer）和帧指针（frame pointer），管理函数调用栈，函数调用栈包括参数、局部变量和返回地址等信息。
IO：很多程序有持久化操作，操作系统将所有IO都抽象成文件，所以进程还包括它打开的所有文件列表

创建进程

进程的创建过程包括：

加载：加载程序代码和静态数据到内存
- 预加载：在运行程序之前一次全部加载完。
- 懒加载：只加载程序运行时需要的部分代码和数据，由分页和交换（ paging and swapping）实现。
初始化：分配内存及初始化IO
- 栈空间：函数的局部变量，参数，返回地址；main函数的实参（argc或argv）
- 堆空间：代码和静态数据以及动态分配的对象(malloc，free）
- IO：标准输入、输出、错误
执行：从entry point运行程序，即执行main方法

fork()

fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程。

为了方便起见，把调用fork()的进程称作父进程，新创建的进程称作子进程。

父进程调用fork()函数后，系统先给子进程分配资源，然后把父进程的所有值都复制到子进程中（只有少数值与父进程的值不同），相当于父进程克隆了自己。

fork()函数的奇怪之处在于它仅仅被调用一次，却能够返回两次。

它可能有三种不同的返回值：

在父进程中，返回新创建子进程的进程ID；
在子进程中，返回0，可以理解为子进程的子进程ID（没有，就0呗）；
如果出现错误，返回一个负值。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char *argv[]){
	printf("hello world (pid:%d)\n", (int) getpid());
	int rc = fork();
	if (rc < 0) { // fork failed; exit
		fprintf(stderr, "fork failed\n");
		exit(1);
	} else if (rc == 0) { // child (new process)
		printf("hello, I am child (pid:%d)\n", (int) getpid());
	} else { // parent goes down this path (main)
		printf("hello, I am parent of %d (pid:%d)\n",rc, (int) getpid());
	}	
	return 0;
}

hello world (pid:29146)
hello, I am parent of 29147 (pid:29146)
hello, I am child (pid:29147)

fork()成功后，系统中出现两个基本完全相同的进程，这两个进程执行顺序是不固定的，取决于系统的调度策略。

每个进程都有一个唯一的进程标识，可以通过getpid()函数获得；还有一个记录父进程标识的变量，可以通过getppid()函数获得。

wait()

the wait() system call allows a parent to wait for a child process to finish what it has been doing

修改之前的例子，让父进程等待子进程执行完再执行。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char *argv[]){
	printf("hello world (pid:%d)\n", (int) getpid());
	int rc = fork();
	if (rc < 0) { // fork failed; exit
		fprintf(stderr, "fork failed\n");
		exit(1);
	} else if (rc == 0) { // child (new process)
		printf("hello, I am child (pid:%d)\n", (int) getpid());
	} else { // parent goes down this path (main)
		int wc = wait(NULL);
		printf("hello, I am parent of %d (wc:%d) (pid:%d)\n", rc, wc, (int) getpid());
	}	
	return 0;
}

exec()

The exec() system call allows a program to run a different program.

调用exec()不会创建新进程，而是将当前运行的程序转换为不同的运行程序。

进程调用exec()时，会从可执行文件加载代码和静态数据，并覆盖它当前的代码段和静态数据，因此，进程内存空间的堆栈以及其他部分都将重新初始化。

使用execvp调用wc程序计算文件p3.c中的单词个数：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

int main(int argc, char *argv[]){
	printf("hello world (pid:%d)\n", (int) getpid());
	int rc = fork();
	if (rc < 0) { // fork failed; exit
		fprintf(stderr, "fork failed\n");
		exit(1);
	} else if (rc == 0) { // child (new process)
		printf("hello, I am child (pid:%d)\n", (int) getpid());
		char *myargs[3];
		myargs[0] = strdup("wc"); // program: "wc" (word count)
		myargs[1] = strdup("p3.c"); // argument: file to count
		myargs[2] = NULL; // marks end of array
		execvp(myargs[0], myargs); // runs word count
		printf("this shouldn’t print out");
	} else { // parent goes down this path (main)
		int wc = wait(NULL);
		printf("hello, I am parent of %d (wc:%d) (pid:%d)\n", rc, wc, (int) getpid());
	}
	return 0;
}

为什么将fork()和exec()分开？

fork()和exec()的分离对于构建UNIX shell至关重要。

shell可以在fork()和exec()之间运行其它的代码，此代码可以改变即将运行的程序的环境，从而可以轻松实现各种有趣的功能。

例如：计算单词并将结果保存到文件

wc p3.c > newfile.txt

大概的过程如下：

当前shell进程调用fork()创建一个子进程，然后调用wait()等待子进程执行完
子进程先关闭标准输出并打开文件newfile.txt，然后调用exec()执行wc程序

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/wait.h>

int main(int argc, char *argv[]){
	int rc = fork();
	if (rc < 0) { // fork failed; exit
		fprintf(stderr, "fork failed\n");
		exit(1);
	} else if (rc == 0) { // child: redirect standard output to a file
		close(STDOUT_FILENO);
		open("./newfile.txt", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
	
		// now exec "wc"...
		char *myargs[3];
		myargs[0] = strdup("wc"); // program: "wc" (word count)
		myargs[1] = strdup("p4.c"); // argument: file to count
		myargs[2] = NULL; // marks end of array
		execvp(myargs[0], myargs); // runs word count
	} else { // parent goes down this path (main)
		int wc = wait(NULL);
	}
	return 0;
}

受限直接执行（Limited Direct Execution）

操作系统通过虚拟化CPU使得每个进程看来像是独占CPU。

操作系统通过分时(time sharing)来实现这种虚拟化：每次运行一个进程一段时间，再切换到另一个进程执行一段时间，以此类推。

实现分时虚拟化时面临的两个挑战：性能和控制。

如何在不增加系统额外开销的情况下实现这种虚拟化?
如何在保持对CPU控制的同时高效地运行进程？

操作系统权衡之下，采取了受限直接执行的方式来解决这两个问题。

直接执行（Direct Execution）

为了尽可能快地运行进程，让进程直接在CPU上运行，这就是直接执行地基本思想。

因此，当OS启动一个程序时，会在进程列表中为它创建一个进程条目，为进程分配内存页并将程序加载到内存中，定位并跳转到入口点(main函数)执行用户代码。
在这里插入图片描述
直接执行虽然快，但有两个重要的问题：

如何应对受限制的操作？如果进程希望执行某种受限制的操作，比如向磁盘发出I/O请求，或者访问更多的系统资源(如CPU或内存)，该怎么办?
如何切换进程？当我们运行一个进程时，操作系统如何停止它的运行并切换到另一个进程，从而实现虚拟化CPU所需的时间共享?

问题1：受限操作

如果进程可以使用CPU的任何操作，比如访问整个IO系统，那系统保护性荡然无存。

为此，操作系统引入一种新的处理器模式，称为用户模式(user mode)。

用户进程运行在用户模式，其代码功能会受到限制。例如，进程不能直接发出IO请求，这样做会导致处理器异常，然后操作系统可能会终止该进程。

与用户模式相反的是内核模式(kernel mode)，即操作系统(或内核)运行的模式。

在内核模式下运行的代码可以做它喜欢做的任何事情，包括特权操作，比如发出I/O请求和执行所有类型的受限指令。

那么问题来了：当用户进程希望执行某种特权操作时，它应该怎么办？

为了实现这一点，几乎所有现代硬件都为用户程序提供了执行系统调用(system call)的能力。

系统调用允许内核小心地向用户程序公开某些关键功能，比如访问文件系统、创建和销毁进程、与其他进程通信以及分配更多内存。

要执行系统调用，程序必须执行一条特殊的 trap 指令，同时该指令跳转到内核，将权限级别提升到内核模式。一旦进入内核，操作系统现在就可以执行所需的任何特权操作，从而为调用进程执行所需的工作。当操作完成时，操作系统调用一条特殊的 return-from-trap 指令，该指令返回到调用程序，同时将特权级别降低到用户模式。

在执行trap指令时，硬件必须保存足够多的调用者寄存器状态，以便能够在OS发出return-from-trap指令时正确返回。

例如，在x86上，执行trap指令时，处理器会把程序计数器、标志和一些其他寄存器保存到每个进程的内核堆栈(kernel stack)上，执行return-from-trap指令时将从内核堆栈中取出这些值并恢复用户模式程序的执行。

那么问题又来了：trap指令如何知道在操作系统中运行哪些代码?

显然，不能让调用进程直接指定要跳转的地址，这样做将允许程序跳转到内核的任何地方，这非常危险。因此内核必须小心控制trap执行的代码。