【Linux操作系统】进程控制

ZLRRLZ2025-10-12 9:47

目录

[1. 进程创建](#1. 进程创建)

[1-1 fork函数初识](#1-1 fork函数初识)

[1-2 fork函数返回值](#1-2 fork函数返回值)

[1-3 写时拷贝](#1-3 写时拷贝)

[1-4 fork常规用法](#1-4 fork常规用法)

[1-5 fork调用失败的原因](#1-5 fork调用失败的原因)

[2. 进程终止](#2. 进程终止)

[2-1 进程退出场景](#2-1 进程退出场景)

[2-2 进程常见退出方法](#2-2 进程常见退出方法)

[2.2.1. exit函数](#2.2.1. exit函数)

[2.2.2 _exit函数](#2.2.2 _exit函数)

[2.2.3 从main返回--return退出](#2.2.3 从main返回--return退出)

2.2.4异常退出：

[2-3 退出码](#2-3 退出码)

[3. 进程等待](#3. 进程等待)

[3-1 进程等待必要性](#3-1 进程等待必要性)

[3-2 进程等待的方法](#3-2 进程等待的方法)

[3-2-1 wait方法](#3-2-1 wait方法)

[3-2-2 waitpid方法](#3-2-2 waitpid方法)

[3-2-3 获取子进程status](#3-2-3 获取子进程status)

[3-2-4 阻塞与非阻塞等待](#3-2-4 阻塞与非阻塞等待)

[4. 进程程序替换](#4. 进程程序替换)

[4-1 替换原理](#4-1 替换原理)

[4-2 替换函数](#4-2 替换函数)

[4-2-1 函数解释](#4-2-1 函数解释)

[4-2-2 命名理解](#4-2-2 命名理解)

[5. 自主Shell命令行解释器](#5. 自主Shell命令行解释器)

[5-1 目标](#5-1 目标)

[5-2 实现原理](#5-2 实现原理)

[5-3 源码](#5-3 源码)

[5-4 总结](#5-4 总结)

1. 进程创建

1-1 fork函数初识

在linux中fork函数是非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。（关于fork更多详细细节上一篇文章已详细解释，本文仅简单介绍）

cpp 复制代码 
#include <unistd.h>
pid_t fork(void);
返回值：自进程中返回0，父进程返回子进程id，出错返回 - 1

进程调用fork，当控制转移到内核中的fork代码后，内核做：

• 分配新的内存块和内核数据结构给子进程

• 将父进程部分数据结构内容拷贝至子进程

• 添加子进程到系统进程列表当中

• fork返回，开始调度器调度

当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以开始它们自己的旅程，看如下程序。

cpp 复制代码 
int main(void)
{
	pid_t pid;
	printf("Before: pid is %d\n", getpid());
	if ((pid = fork()) == -1)perror("fork()"), exit(1);
	printf("After:pid is %d, fork return %d\n", getpid(), pid);
	sleep(1);
	return 0;
}
运行结果：
[root@localhost linux]# . / a.out
Before : pid is 43676
After : pid is 43676, fork return 43677
After : pid is 43677, fork return 0

这里看到了三行输出，一行before，两行after。进程43676先打印before消息，然后它有打印after。另一个after消息有43677打印的。注意到进程43677没有打印before，为什么呢？如下图所示

所以，fork之前父进程独立执行，fork之后，父子两个执行流分别执行。注意，fork之后，谁先执行完全由调度器决定。

1-2 fork函数返回值

• 子进程返回0，

• 父进程返回的是子进程的pid。

1-3 写时拷贝

当进程创建子进程时，不光会创建子进程，OS也会将对应的代码和数据权限修改成只读，因此父进程和子进程管理的代码和数据就是只读的，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，OS检测到修改的是数据段，位置、地址合理，但是此时却是只读权限，OS就会触发错误，进行写时拷贝，便以写时拷贝的方式各自一份副本，同时将父进程对应的数据段权限载改回可写，具体见下图:

因为有写时拷贝技术的存在,所以父子进程得以彻底分离离！完成了进程独立性的技术保证!

写时拷贝,是一种延时申请技术,可以提高整机内存的使用率。在实际的使用中，我们采用写时拷贝技术，创建一个进程不需要拷贝大量的数据，实际上就减少我们创建进程的时间，并且我们创建一个进程可能也并不会修改数据，那么这就减少了内存中的重复数据。

1-4 fork常规用法

• 一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，

生成子进程来处理请求。

• 一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。

所以现在结合上文以及之前所学的内容，如果此时子进程执行的是一款操作系统的代码，依然可以正常运行，这也就是我们内存级虚拟机的实现原理，虚拟机之间相互独立。

1-5 fork调用失败的原因

• 系统中有太多的进程

• 实际用户的进程数超过了限制

2. 进程终止

进程终止的本质是释放系统资源，就是释放进程申请的相关内核数据结构和对应的数据和代码。

2-1 进程退出场景

• 代码运行完毕，结果正确

• 代码运行完毕，结果不正确

• 代码异常终止

子进程是由父进程创建，通常是为了完成某种任务，所以子进程就需要将自己执行的结果告知父进程，而只要子进程将上述三种状况告知父进程，那么父进程自然就可以知道子进程的执行结果了。

而我们C语言中的main函数，之前学习中我们可能并没有关注过main返回值的问题，而今天我们就清楚了，main返回值就是返回的前两种情况，即代码运行完毕，结果是否正确的问题，如果代码正确，函数返回0，如果代码不正确，函数返回非0正整数（1,2,3,4......，实际上就是宏定义，一个数字对应一种错误情况），main底层的返回值是通过寄存器返回给外部的，所以即使我们不写返回值，也会默认返回0，

注：这里的echo $?打印的是上一个进程的进程退出码，？是一个特殊符号，代表上一个进程的特殊变量。

所以main只是我们程序的入口，我们的整个程序会被编译器动手脚，编译器会将相关的退出码交给OS,OS又会将对应进程的退出码写到进程的PCB即task_struct中。

对于非0整数的退出码，C标准库中提供一套对应的描述（当然退出码这个实际开发也可以自己设置）

对于程序异常的情况来说，就特殊一点了，进程一但出现异常，一般是OS检测到错误像进程发送了对应信号（详细内容后文再详细介绍），提前终止了对应进程，那么此时进程的退出码就无意义。

2-2 进程常见退出方法

正常终止（可以通过echo $? 查看进程退出码）：

2.2.1. exit函数

cpp 复制代码 
#include <unistd.h>
void exit(int status);

exit最后也会调用_exit, 但在调用_exit之前，还做了其他工作：

exit是库提供的方法，这里的参数status就是对应的需要返回的退出码

任何地方exit，表示进程结束，并返回给父进程bash子进程的退出码，exit之后的代码不再执行。

2.2.2 _exit函数

cpp 复制代码 
#include <unistd.h>
void _exit(int status);
参数：status 定义了进程的终止状态，父进程通过wait来获取该值

• 说明：虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现

返回值是255。

_exit是系统调用提供的进程退出方法，exit本质上底层就是调用的_exit方法。

exit一共执行了如下操作

  1. 执行用户通过 atexit或on_exit定义的清理函数。

  2. 关闭所有打开的流，所有的缓存数据均被写入

  3. 调用_exit

不同的是进程如果exit退出的时候，exit()进程退出的时候，会进行缓冲区的刷新;如果exit()，_exit()进程退出的时候，不会进行缓冲区的刷新。所以通过上面的代码实验，我们也发现了我们之前一直在谈论的缓冲区本质上是C语言提供的库缓冲区（如果是系统缓冲区，使用_exit也应该将缓冲区中的数据刷新出来才是）

2.2.3 从main返回--return退出

return是一种更常见的退出进程方法。执行return n等同于执行exit(n),因为调用main的运行时函数会将main的返回值当做 exit的参数。

main函数结束表示进程结束，其他函数，只表示自己函数调用完成返回。

2.2.4异常退出：

• ctrl + c，信号终止（这个暂时按下不表）

2-3 退出码

退出码（退出状态）可以告诉我们最后一次执行的命令的状态。在命令结束以后，我们可以知道命令是成功完成的还是以错误结束的。其基本思想是，程序返回退出代码 0 时表示执行成功，没有问题。代码 1 或 0 以外的任何代码都被视为不成功。

Linux Shell 中的主要退出码：

• 退出码 0 表示命令执行无误，这是完成命令的理想状态。

• 退出码 1 我们也可以将其解释为 "不被允许的操作"。例如在没有 sudo 权限的情况下使用

yum；再例如除以 0 等操作也会返回错误码 1 ，对应的命令为let a=1/0

• 130 （ SIGINT 或 ^C ）和 143 （ SIGTERM ）等终止信号是非常典型的，它们属于

128+n 信号，其中 n 代表终止码。

• 可以使用strerror函数来获取退出码对应的描述。

3. 进程等待

3-1 进程等待必要性

• 之前讲过，子进程退出，父进程如果不管不顾，就可能造成'僵尸进程'的问题，进而造成内存泄漏。

• 另外，进程一旦变成僵尸状态，那就刀枪不入，"杀人不眨眼"的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。

• 最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。

• 父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息，其实回收子进程资源是最重要的，而获取退出信息有些时候我们也并不关心，所以通常这个是作为可选参数设置的。

3-2 进程等待的方法

3-2-1 wait方法

cpp 复制代码 
#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int* status);

wait等待任意进程，当多个进程其中一个进程执行完，wait会等待这个先执行完的进程
返回值：
成功返回被等待进程pid，失败返回-1。
参数：
输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

未出现僵尸，进程退出成功。

如果等待子进程，子进程没有退出，父进程会阻塞在wait调用处。

3-2-2 waitpid方法

cpp 复制代码 
pid_ t waitpid(pid_t pid, int *status, int options);
返回值：
        当正常返回的时候waitpid返回收集到的子进程的进程ID；
        如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
        如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；
参数：
        pid：
                Pid=-1,等待任一个子进程。与wait等效。
                Pid>0.等待其进程ID与pid相等的子进程。
        status: 输出型参数
                WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是
否是正常退出）
                WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的
退出码）
        options:默认为0，表示阻塞等待
                WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等
待。若正常结束，则返回该子进程的ID。

• 如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子

进程退出信息。

• 如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。

• 如果不存在该子进程，则立即出错返回。

3-2-3 获取子进程status

• wait和waitpid，都有一个status参数，该参数是一个输出型参数（内部的数据会赋值给这个外部变量，这样内部的数据外部就可以看到了），由操作系统填充。

• 如果传递NULL，表示不关心子进程的退出状态信息。

• 否则，操作系统会根据该参数，将子进程的退出信息（退出码）反馈给父进程（父进程评估进程执行是出于代码运行完毕，结果正确、代码运行完毕，结果不正确、代码异常终止哪一种情况）。

cpp 复制代码 
测试代码：
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main(void)
{
	pid_t pid;
	if ((pid = fork()) == -1)
		perror("fork"), exit(1);
	if (pid == 0) {
		sleep(20);
		exit(10);
	}
	else {
		int st;
		int ret = wait(&st);
		if (ret > 0 && (st & 0X7F) == 0) { // 正常退出
			printf("child exit code:%d\n", (st >> 8) & 0XFF);
		}
		else if (ret > 0) { // 异常退出
			printf("sig code : %d\n", st & 0X7F);
		}
	}
}

测试结果：
# ./a.out #等20秒退出
child exit code : 10
# ./a.out #在其他终端kill掉
sig code : 9

• status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（int 类型高16位不看，只研究status低16比特位）：

前8位用来表示退出状态，后8位只跟信号有关，目前我们不研究程序执行异常的情况，所以只看前8位。

所以我们需要使用位操作，拿到表示正常状态的8个比特位，我们也就能拿到退出码了。

所谓的信号其实也就是通过宏定义的一些整形变量（信号前面的数就是信号对应的值），所以status上图中的低7个比特位表示的就是对应的异常信号，当没有收到异常信号，低7个比特位为0，而一旦是异常退出的，低7个比特位不为0，程序退出码无意义。

位操作拿到对应的低7个比特位，我们也就可以知道对应的异常退出信号了。

而上面这些位操作 ,系统也提供两个宏：

WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是

否是正常退出）

WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的

退出码）

而上面所有这些退出信息本质上父进程不能直接拿到，所以我们查阅源码，发现这些信息本质上就是存储在PCB中的，父进程通过系统调用，让OS帮助自己拿到对应的信息。

3-2-4 阻塞与非阻塞等待

cpp 复制代码 
pid_ t waitpid(pid_t pid, int *status, int options);
返回值：
        当正常返回的时候waitpid返回收集到的子进程的进程ID；
        如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
        如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；
参数：
        pid：
                Pid=-1,等待任一个子进程。与wait等效。
                Pid>0.等待其进程ID与pid相等的子进程。
        status: 输出型参数
                WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是
否是正常退出）
                WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的
退出码）
        options:默认为0，表示阻塞等待
                WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等
待。若正常结束，则返回该子进程的ID。

• 进程的阻塞等待方式：为了等待对应的子进程，父进程会阻塞在waitpid调用处，直到子进程执行完毕，waitpid等到了子进程，父进程才继续执行接下来的代码

cpp 复制代码 
int main()
{
	pid_t pid;
	pid = fork();
	if (pid < 0) {
		printf("%s fork error\n", __FUNCTION__);
		return 1;
	}
	else if (pid == 0) { //child
		printf("child is run, pid is : %d\n", getpid());
		sleep(5);
		exit(257);
	}
	else {
		int status = 0;
		pid_t ret = waitpid(-1, &status, 0);//阻塞式等待，等待5S
		printf("this is test for wait\n");
		if (WIFEXITED(status) && ret == pid) {
			printf("wait child 5s success, child return code is
				: % d.\n",WEXITSTATUS(status));
		}
		else {
			printf("wait child failed, return.\n");
			return 1;
		}
	}
	return 0;
}

运行结果:
[root@localhost linux] # . / a.out
child is run, pid is : 45110
this is test for wait
wait child 5s success, child return code is : 1.

• 进程的非阻塞等待方式：

所谓的非阻塞即waitpid会查看一次子进程是否调用完毕，如果没有，waitpid不会阻塞，直接函数调用完毕。而查看一次无法成功等待子进程执行结束，所以通常采用非阻塞轮询的方式（轮询就是通过循环完成），查看一次，进程没有调用完成，调用结束，下一次继续查看............直到waitpid查到子进程执行结束，回收资源。

比起阻塞等待，非阻塞轮询期间，等待方不会卡住，可以去做其他事情，也就是为什么我们说非阻塞的效率更高的原因，如下图，我们可以注册一些方法，在非阻塞轮询期间调用对应方法完成对应任务。

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include <vector>
typedef void (*handler_t)(); // 函数指针类型
std::vector<handler_t> handlers; // 函数指针数组
void fun_one() {
	printf("这是一个临时任务1\n");
}
void fun_two() {
	printf("这是一个临时任务2\n");
}
void Load() {
	handlers.push_back(fun_one);
	handlers.push_back(fun_two);
}
void handler() {
	if (handlers.empty())
		Load();
	for (auto iter : handlers)
		iter();
}
int main() {
	pid_t pid;
	pid = fork();
	if (pid < 0) {
		printf("%s fork error\n", __FUNCTION__);
		return 1;
	}
	else if (pid == 0) { // child
		printf("child is run, pid is : %d\n", getpid());
		sleep(5);
		exit(1);
	}
	else {
		int status = 0;
		pid_t ret = 0;
		do {
			ret = waitpid(-1, &status, WNOHANG); // 非阻塞式等待
			if (ret == 0) {
				printf("child is running\n");
			}
			handler();
		} while (ret == 0);
		if (WIFEXITED(status) && ret == pid) {
			printf("wait child 5s success, child return code is :%d.\n",
				WEXITSTATUS(status));
		}
		else {
			printf("wait child failed, return.\n");
			return 1;
		}
	}
	return 0;
}

4. 进程程序替换

fork() 之后,父子各自执行父进程代码的一部分如果子进程就想执行一个全新的程序呢？进程的程序

替换来完成这个功能！

程序替换是通过特定的接口，加载磁盘上的一个全新的程序(代码和数据)，加载到调用进程的地址空间中！

当程序执行到execl，我们的程序就去执行系统指令了，对与这种现象就是程序替换

4-1 替换原理

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,虚拟内存上不发生改变，但是物理内存上对应的代码会和数据会被新的代码和数据覆盖，页表重新建立映射。一但程序替换成功，就去执行新代码了，原始代码的后半部分，已经不存在了

本质上程序替换的过程中并没有创建新进程，只是把当前进程的代码和数据用心的程序的代码和数据覆盖式的进行替换了,所以调用exec前后该进程的id并未改变。

这里程序替换子进程子所以不影响父进程，是因为进程具有独立性，本质上也是发生写时拷贝父子进程的各自具有各自的代码和数据

4-2 替换函数

其实有六种以exec开头的函数,统称exec函数:

cpp 复制代码 
#include <unistd.h>
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);

4-2-1 函数解释

• 这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。

• 如果调用出错则返回-1

• 所以exec函数只有出错的返回值而没有成功的返回值。

exec系列的函数只有失败返回值，没有成功返回值，所以我们不用做返回值判断，只要返回就是失败（成功就直接执行其他代码和数据了，没有判断必要）

4-2-2 命名理解

这些函数原型看起来很容易混,但只要掌握了规律就很好记。

• l(list) : 表示参数采用列表

• v(vector) : 参数用数组

• p(path) : 有p自动搜索环境变量PATH

• e(env) : 表示自己维护环境变量

int execl(const char *path, const char *arg, ...);

第一个参数是路径+程序名的形式，作用是告诉OS应该执行谁，第二个是命令行参数表，命令行这么写，就怎么传，这是告诉OS要怎么执行它，......表示的是不定参数，主要是配合arg的，必须以NULL结尾，表示参数传递完成

所以上面这个参数传递本质上就将一个一个参数作为一个list传递，所以execl的l就代表list的意思

可以让子进程程序替换去执行对应的任务。

注：实际上我们的代码和数据加载到内存中，是依靠的加载器，而exec系列的结构本质上就是加载器内部所使用的方法。

int execlp(const char *file, const char *arg, ...);

execlp中的p代表的是环境变量PATH,第一个参数file只需要告诉要执行的程序名即可，这个参数该生OS要执行谁（execlp会自动到环境变量PATH中查找指定的命令），第二个参数及后面可以变参数使用同execl。

注：如果指明程序的路径，也是可以执行不在PATH中的程序的（比如我们自己写的文件）

int execv(const char *path, char *const argv[]);

execv的v可以理解为vector,第一个参数同execlp，而后面的这个指针数据，就是明确提供的一个命令行参数表

上面的代码中ls中也有main函数，main也有一个argv数组，所以学习了exec系列函数之后，我们现在也就可以理解了bash调用命令的main本质上就是通过exec系列来传递命令行参数表的。

int execvp(const char *file, char *const argv[]);

参数作用同上

int execvpe(const char *path, char *const argv[], char *const envp[]);

第三个参数传入的是环境变量表，会要求程序使用传入的环境变量表，父进程传入的环境变量会被覆盖。

所谓如果为了能够原有环境变量表基础上新增变量并使用，我们可以使用putenv新增变量，然后传入environ(这是个全局变量，指向环境变量表)

事实上,只有execve是真正的系统调用,其它五个函数最终都调用execve,所以execve在man手册 第2节,其它函数在man手册第3节。这些函数之间的关系如下图所示。

下图exec函数簇 一个完整的例子:

即exec的环境变量表和命令行参数表的参数默认使用原来的，库函数传入了，就使用传入的。

5. 自主Shell命令行解释器

5-1 目标

• 要能处理普通命令

• 要能处理内建命令

• 要能帮助我们理解内建命令/本地变量/环境变量这些概念

• 要能帮助我们理解shell的允许原理

5-2 实现原理

考虑下面这个与shell典型的互动：

bash 复制代码 
[root@localhost epoll]# ls
client.cpp readme.md server.cpp utility.h
[root@localhost epoll]# ps
    PID TTY TIME CMD
3451 pts/0 00:00:00 bash
3514 pts/0 00:00:00 ps

用下图的时间轴来表示事件的发生次序。其中时间从左向右。shell由标识为sh的方块代表，它随着时间的流逝从左向右移动。shell从用户读入字符串"ls"。shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束。

然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序 并等待这个进程结束。

所以要写一个shell，需要循环以下过程:

  1. 获取命令行

  2. 解析命令行

  3. 建立一个子进程（fork）

  4. 替换子进程（execvp）

  5. 父进程等待子进程退出（wait）

根据这些思路，和我们前面的学的技术，就可以自己来实现一个shell了。

5-3 源码

实现代码:

cpp 复制代码 
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <ctype.h>
using namespace std;
const int basesize = 1024;
const int argvnum = 64;
const int envnum = 64;
// 全局的命令行参数表
char* gargv[argvnum];
int gargc = 0;
// 全局的变量
int lastcode = 0;
// 我的系统的环境变量
char* genv[envnum];
// 全局的当前shell工作路径
char pwd[basesize];
char pwdenv[basesize];
// " "file.txt
#define TrimSpace(pos) do{\
while(isspace(*pos)){\
pos++;\
}\
}while(0)
string GetUserName()
{
	string name = getenv("USER");
	return name.empty() ? "None" : name;
}
string GetHostName()
{
	string hostname = getenv("HOSTNAME");
	return hostname.empty() ? "None" : hostname;
}
string GetPwd()
{
	if (nullptr == getcwd(pwd, sizeof(pwd))) return "None";
	snprintf(pwdenv, sizeof(pwdenv), "PWD=%s", pwd);
	putenv(pwdenv); // PWD=XXX
	return pwd;
	//string pwd = getenv("PWD");
	//return pwd.empty() ? "None" : pwd;
}
string LastDir()
{
	string curr = GetPwd();
	if (curr == "/" || curr == "None") return curr;
	// /home/whb/XXX
	size_t pos = curr.rfind("/");
	if (pos == std::string::npos) return curr;
	return curr.substr(pos + 1);
}
string MakeCommandLine()
{
	// [whb@bite-alicloud myshell]$
	char command_line[basesize];
	snprintf(command_line, basesize, "[%s@%s %s]# ", \
		GetUserName().c_str(), GetHostName().c_str(), LastDir().c_str());
	return command_line;
}
void PrintCommandLine() // 1. 命令行提示符
{
	printf("%s", MakeCommandLine().c_str());
	fflush(stdout);
}
bool GetCommandLine(char command_buffer[], int size) // 2. 获取用户命令
{
	// 我们认为：我们要将用户输入的命令行，当做一个完整的字符串
	// "ls -a -l -n"
	char* result = fgets(command_buffer, size, stdin);
	if (!result)
	{
		return false;
	}
	command_buffer[strlen(command_buffer) - 1] = 0;
	if (strlen(command_buffer) == 0) return false;
	return true;
}
void ParseCommandLine(char command_buffer[], int len) // 3. 分析命令
{
	(void)len;
	memset(gargv, 0, sizeof(gargv));
	gargc = 0;
	// "ls -a -l -n"
	const char* sep = " ";
	gargv[gargc++] = strtok(command_buffer, sep);
	// =是刻意写的
	while ((bool)(gargv[gargc++] = strtok(nullptr, sep)));
	gargc--;
}
void debug()
{
	printf("argc: %d\n", gargc);
	for (int i = 0; gargv[i]; i++)
	{
		printf("argv[%d]: %s\n", i, gargv[i]);
	}
}
// 在shell中
// 有些命令，必须由子进程来执行
// 有些命令，不能由子进程执行，要由shell自己执行 --- 内建命令 built command
bool ExecuteCommand() // 4. 执行命令
{
	// 让子进程进行执行
	pid_t id = fork();
	if (id < 0) return false;
	if (id == 0)
	{
		//子进程
		// 1. 执行命令
		execvpe(gargv[0], gargv, genv);
		// 2. 退出
		exit(1);
	}
	int status = 0;
	pid_t rid = waitpid(id, &status, 0);
	if (rid > 0)
	{
		if (WIFEXITED(status))
		{
			lastcode = WEXITSTATUS(status);
		}
		else
		{
			lastcode = 100;
		}
		return true;
	}
	return false;
}
void AddEnv(const char* item)
{
	int index = 0;
	while (genv[index])
	{
		index++;
	}
	genv[index] = (char*)malloc(strlen(item) + 1);
	strncpy(genv[index], item, strlen(item) + 1);
	genv[++index] = nullptr;
}
// shell自己执行命令，本质是shell调用自己的函数
bool CheckAndExecBuiltCommand()
{
	if (strcmp(gargv[0], "cd") == 0)
	{
		// 内建命令
		if (gargc == 2)
		{
			chdir(gargv[1]);
			lastcode = 0;
		}
		else
		{
			lastcode = 1;
		}
		return true;
	}
	else if (strcmp(gargv[0], "export") == 0)
	{
		// export也是内建命令
		if (gargc == 2)
		{
			AddEnv(gargv[1]);
			lastcode = 0;
		}
		else
		{
			lastcode = 2;
		}
		return true;
	}
	else if (strcmp(gargv[0], "env") == 0)
	{
		for (int i = 0; genv[i]; i++)
		{
			printf("%s\n", genv[i]);
		}
		lastcode = 0;
		return true;
	}
	else if (strcmp(gargv[0], "echo") == 0)
	{
		if (gargc == 2)
		{
			// echo $?
			// echo $PATH
			// echo hello
			if (gargv[1][0] == '$')
			{
				if (gargv[1][1] == '?')
				{
					printf("%d\n", lastcode);
					lastcode = 0;
				}
			}
			else
			{
				printf("%s\n", gargv[1]);
				lastcode = 0;
			}
		}
		else
		{
			lastcode = 3;
		}
		return true;
	}
	return false;
}
// 作为一个shell，获取环境变量应该从系统的配置来
// 我们今天就直接从父shell中获取环境变量
void InitEnv()
{
	extern char** environ;
	int index = 0;
	while (environ[index])
	{
		genv[index] = (char*)malloc(strlen(environ[index]) + 1);
		strncpy(genv[index], environ[index], strlen(environ[index]) + 1);
		index++;
	}
	genv[index] = nullptr;
}
int main()
{
	InitEnv();
	char command_buffer[basesize];
	while (true)
	{
		PrintCommandLine(); // 1. 命令行提示符
		// command_buffer -> output
		if (!GetCommandLine(command_buffer, basesize)) // 2. 获取用户命令
		{
			continue;
		}
		//printf("%s\n", command_buffer);
		ParseCommandLine(command_buffer, strlen(command_buffer)); // 3. 分析命令
		if (CheckAndExecBuiltCommand())
		{
			continue;
		}
		ExecuteCommand(); // 4. 执行命令
	}
	return 0;
}

5-4 总结

我们来思考函数和进程之间的相似性：exec/exit就像call/return

一个C程序有很多函数组成。一个函数可以调用另外一个函数，同时传递给它一些参数。被调用的函数执行一定的操作，然后返回一个值。每个函数都有他的局部变量，不同的函数通过call/return系统进行通信。

这种通过参数和返回值在拥有私有数据的函数间通信的模式是结构化程序设计的基础。Linux鼓励将这种应用于程序之内的模式扩展到程序之间。如下图

一个C程序可以fork/exec另一个程序，并传给它一些参数。这个被调用的程序执行一定的操作，然后通过exit(n)来返回值。调用它的进程可以通过wait（&ret）来获取exit的返回值。

相关推荐
我想吃余3 小时前
Linux的Ext文件系统：硬盘理解和inode及软硬链接
linux·运维·电脑
qq762118223 小时前
Linux c 在内存中创建zip，最后写入测试
linux·运维·服务器
jayxuyj4 小时前
MySQL8.0新特性探秘深入解析窗口函数的性能优化策略
服务器
半路_出家ren4 小时前
Shell脚本基础应用
linux·网络·shell
故事很腻i4 小时前
安装elk
运维·elk·jenkins
华纳云IDC服务商4 小时前
网站服务器频繁掉线的主要原因是什么
运维·服务器
小黄人软件4 小时前
【部署python网站】宝塔面板 小目标2：实时搜索网上资源文件网站放在服务器上 用AI做一个作品，不断迭代。
运维·服务器
未来之窗软件服务4 小时前
服务器运维(四)服务器漏洞扫描工具与审查——东方仙化神期
运维·服务器·仙盟创梦ide·东方仙盟·东方仙盟运维
小猪写代码4 小时前
服务器相关：什么是 alios. centos. cuda. cuda tookit. gcc. cudann. pytorch.
服务器·pytorch·centos
热门推荐
01BongoCat - 跨平台键盘猫动画工具02智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践03两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答04GitHub 镜像站点05UV安装并设置国内源0646个Nano-banana 精选提示词，持续更新中07Linux下V2Ray安装配置指南08Cursor Plan Mode：AI 终于知道先想后做了09Spring Boot 实现微信登录，So Easy !105大DOM/BOM核心考点：从入门到精通，让面试官眼前一亮