从exec到Shell：深度解析Linux进程等待，程序替换与自主Shell实现

一、进程等待

1. 进程等待的必要性

这个前面是说过的哦。

1、回收子进程资源。

2、获取子进程的退出信息。

2. 什么是进程等待

让父进程通过等待的方式，回收子进程的PCB，Z，如果需要，获取子进程的退出信息。

3. 怎么做

//等待任意一个子进程，成功的话返回子进程的pid，失败返回-1
pid_t wait(int* status);//这里status暂时设置为NULL，不关心

父进程调用wait，表示父进程等待任意一个子进程。

1、如果子进程没有退出，父进程wait的时候，就会阻塞。

2、如果子进程退出了，父进程wait的时候，wait就会返回了，让系统自动解决子进程的僵尸问题。

通过这段代码，就可以验证父进程等待子进程是否成功，成功的话子进程的僵尸状态就没有了。子进程会从阻塞状态变为僵尸状态，最后被父进程回收。

上面只回收了一个子进程，如何回收多进程呢？

多进程中，父进程往往最先创建，最后退出。fork之前，只有一个父进程，fork之后，父进程需要对所有的子进程进行回收。

//pid为-1，表示等待任意进程，pid > 0，等待进程id与pid相等的进程
//status输出型参数，目的是为了带出一些数据
//options为0，阻塞等待，options为WNOHANG，非阻塞等待
//等待成功，返回子进程的pid，等待失败，返回0
//既没有等待成功也没有失败返回0(子进程在运行，暂时未退出)
pid_t waitpid(pid_t pid, int* status, int options);

子进程的退出码为1，可是status为什么是256呢？这里的status不仅仅是退出码。

status是一个int(整型)，32个bit，高16位不考虑。剩下的16位，次8位是子进程的退出码，所以，进程的退出码取值范围是[0,255]，低7位是终止信号，还有一位是core dump(这个后面再讲)。

进程正常终止，终止信号为0，子进程退出码为1，但是后面有8个0，所以status为256。要想拿到子进程的退出码，exit_code = (status >> 8) & 0xFF。

上面所述都是基于进程正常终止的情况。那么，如果是进程异常呢？我们都知道，进程异常了，退出码是没有意义的。因此，我们的重点应该是进程为什么会异常？

是因为程序出现了问题，导致OS给你的进程发送信号了。

kill -l //查看所有的进程信号

退出信号没有0号信号。所以我们是如何判断进程是否是正常运行结束呢？status->信号的数字 == 0。

我们用两个数字来表示子进程的执行情况：

1.进程的退出码。

2.进程的退出信号。

那我们要如何拿到进程的退出信号呢？status低7位表示的是进程信号，exit_signal = status & 0x7F。

但是获取进程退出码，进程退出信号的方式太麻烦，所以操作系统提供了两个宏，WIFEXITED(status)，WEXITSTATUS(status)，分别用来表示进程是否正常退出(正常退出返回非零值，反之，返回0)和获取进程退出状态码。

不知道大家有没有疑问呢。waitpid(pid_t pid, int* status, int options)中 pid > 0表示的是等待与pid相等的子进程，是因为父进程可以拿pid找到该子进程。

可是，如果是-1呢？父进程怎么知道要等待哪一个子进程。那是因为父进程的task_struct里有对于子进程进行管理，等待子进程就看哪一个是僵尸状态就可以了。

我们可以通过控制代码来验证进程等待的效果。

上面所说都是阻塞等待。现在，该解释什么是非阻塞等待了。

像scanf函数就是典型的阻塞等待，资源没有就绪，就会一直卡住。而非阻塞等待，就是资源没有就绪的情况，它并不会一直卡在哪里，会去做别的事情的同时也会继续等待资源就绪。

例子：明天就是C语言考试，你的好朋友李四是一个学霸，你需要借助李四的笔记来复习应对明天的考试，但是李四也要用笔记来复习。但是他说等他复习好了，就可以把笔记借给你。这时候你是很开心的，但是你也很慌张，因为平时你没有好好学习。所以你就不停的给李四打电话，问他复习好了吗？他说没有，这时候你就把电话挂断了，你就去刷抖音了，刷大学生期末挂科应该怎么办？过了一会儿，你又给李四打电话，李四说还没好呢，你又去做自己的事情了。

这就是非阻塞等待。有时候你会听到非阻塞等待比阻塞等待更高效就是这个原因。

二、进程程序替换

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

进程的程序替换来完成这个功能。

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

1. 初识程序替换函数

//pathname 你想执行的程序（路径+文件名）
//arg 我们要执行程序的程序名称
//... 给程序传递的命令行选项，必须以NULL结尾(参数包)
//失败了，返回-1
int execl(const char* pathname, const char* arg, ...);

可以看到，程序是替换成功了的。但是，有一个问题，execl 结束之后，为什么没有打印后续的 printf 呢？

那是因为你的进程已经执行另一个程序的代码了，你自己的代码已经没有了。

总结：程序替换函数，一旦调用成功，后续代码不再执行，因为已经没有了。

那如果失败呢？

程序替换，如果成功，不需要也不会有返回值，失败返回 -1。

也就是说exe系列的函数，只要返回，必然失败。

那么，如果我们想用子进程进行程序替换呢？父子进程代码是共享的，数据以写时拷贝的方式各自私有。如果用子进程程序替换，是不是也影响到了父进程呢？不是说好进程之间具有独立性吗？

我们可以认为，fork之后，父子进程的代码和数据都以写时拷贝的方式各自私有。这样就不会影响父进程了，子进程会加载新的代码和数据（物理内存上新开一段空间），更改页表与物理内存的映射关系。

2. 关联linux历史知识

1、命令行上的命令是bash的子进程，那它和bash是共享代码和数据的，但是不同的命令有不同的功能。这是为什么呢？

我们已经知道，子进程是由父进程fork创建出来的，那么父进程不就可以对子进程进行程序替换，进程等待...等操作了吗。

2、二进制文件，先加载程序到内存，为什么呢？

由冯诺依曼体系结构决定的。

进程 = PCB（内核数据结构）+ 自己的代码和数据。

我们都知道，进程是先有数据结构的，在加载代码和数据，甚至是需要的时候在加载(惰性加载)，那么你的程序，是如何加载到内存的呢？

加载的本质是为了变成进程，那么是怎么加载的呢？我们使用的exe系列的函数不就是相当于一种“加载器”吗？程序从磁盘上拷贝到内存，不就是硬件到硬件吗，只有操作系统有这个权利，所以加载一定要调用系统调用或者是对系统调用做封装。

3. 详解程序替换函数

//pathname 依旧是路径+文件名
//argv[] 与execl后半部分的参数一致,只不过是用数组组织起来
int execv(const char* pathname, char* const argv[]);

子进程执行程序替换，我们不需要自己的可执行程序名，因此从命令行参数表下标为1的参数开始。

//执行指定的命令，需要让execlp自己在环境变量PATH中寻找指定的程序
int execlp(const char* file, const char* arg, ...);

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

上面执行的都是系统命令，那么，可不可以执行我们自己的命令呢？

execl 执行 mycmd的时候，之所以第二个参数不用带./是因为第一个参数已经表明了路径，系统已经能够找到该文件了。

//argv[]命令行参数表
//envp[]环境变量表
//这两张表可以是系统的，也可以自定义
int execvpe(const char* file, char* const argv[], char* const envp[]);

execvpe函数传递环境变量表，会默认摒弃旧的环境变量，使用你自己设置的全新的环境变量表，如果你要用系统提供的，就传入系统的环境变量表。

那如果我们既想使用系统的环境变量表又想使用自定义的呢？

//成功返回0，失败返回非0
int putenv(char* string);//默认的环境变量中新增一项

程序替换函数一共有7个。这六个都是execve衍生出来的。剩下的就不多做介绍了。

三、mini shell

myshell.h

#ifndef _SHELL_H_
#define _SHELL_H_#include<cstdio>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<sys/wait.h>
#include<ctype.h>#define MAX 1024#define ARGS 64#define NONE_REDIR 0
#define INPUT_REDIR 1
#define OUTPUT_REDIR 2
#define APPEND_REDIR 3void InitGlobal();
void PrintCommandLinePrompt();
bool GetUserCommand(char usercommand[], int len);
void CheckRedir(char usercommand[]);
bool PraseUserCommand(char usercommand[]);
bool BuiltInCommandExec();
bool ForkAndExec();
#endif

myshell.cc

#include "myshell.h"int gargc = 0; //解析用户命令存储的数组下标
char* gargv[ARGS] = {NULL};//故意设置为全局的，方便使用,安全起见，保证命令行参数表全局有效
int exit_code = 0;
char pwd[MAX] = {0};
int redir;
std::string filename;void InitGlobal()
{gargc = 0;memset(gargv,0,sizeof(gargv));redir = NONE_REDIR;filename = "";}static std::string GetUserName()
{std::string username = getenv("USER");return username.empty()? "None": username;
}static std::string GetHostName()
{char name[256] = {0};if(gethostname(name, sizeof(name)) == 0){std::string hostname = name;return hostname;}else{perror("gethostname failed");return "None";}
}static std::string GetPwd()
{//std::string pwd = getenv("PWD");//return pwd.empty()? "None": pwd;char temp[MAX];char* ptr = getcwd(temp,sizeof(temp));//将ptr指针里面的内容和PWD=(这四个字符)一起写到pwd数组里，putenv会在环境变量中查找PWD，然后进行覆盖。snprintf(pwd, sizeof(pwd), "PWD=%s", ptr);putenv(pwd);std::string str = temp;std::string delim = "/";int pos = str.rfind(delim);std::string s = str.substr(pos+delim.size());return s.empty()? "/": s;}std::string GetHomePath()
{std::string home = getenv("HOME");return home.empty()? "/": home;
}void PrintCommandLinePrompt()
{std::string username = GetUserName();std::string hostname = GetHostName();std::string pwd = GetPwd();printf("[%s@%s %s]$ ",username.c_str(), hostname.c_str(), pwd.c_str());
}bool GetUserCommand(char usercommand[], int len)
{if(usercommand == NULL || len <= 0)return false;//fgets函数会自动在字符串的末尾加上'\0'char* res = fgets(usercommand, len, stdin);if(res == NULL){perror("fgets failed");return false;}//去掉末尾的换行符(\n)usercommand[strlen(usercommand) - 1] = 0;return strlen(usercommand) == 0? false: true;
}#define TrimeSpace(start) do{\while(isspace(*start)){\start++;\}\
}while(0)//检查是否有重定向
void CheckRedir(char usercommand[])
{char* start = usercommand, *end = usercommand + strlen(usercommand) - 1;while(start <= end){if(*start == '>'){*start = '\0';if(*(start+1) == '>'){redir = APPEND_REDIR;start += 2;TrimeSpace(start);filename = start;break;}else{redir = OUTPUT_REDIR;start += 1;TrimeSpace(start);filename = start;break;}}else if(*start == '<'){redir = INPUT_REDIR;*start = '\0';start++;TrimeSpace(start);filename  = start;break;}else{start++;}}
}bool PraseUserCommand(char usercommand[])
{if(usercommand == NULL)return false;//解析//"ls -l -s" -------->  "ls", "-l", "-a"
#define SEP " " 	gargv[gargc++] = strtok(usercommand, SEP);//最后一次解析失败，会存储NULL，但是我们不需要NULLchar* str = strtok(NULL,SEP);while(str){gargv[gargc++] = str;str = strtok(NULL, SEP);}
//#define DEBUG
#ifdef DEBUGprintf("gargc:%d\n",gargc);for(int i = 0; i < gargc; ++i)printf("gargv[%d]:%s\n",i,gargv[i]);
#endifreturn true;
}bool BuiltInCommandExec()
{std::string cmd = gargv[0];bool ret = false;if(strcmp(cmd.c_str(), "cd") == 0){if(gargc == 2){char* str = gargv[1];if(strcmp(str, "~") == 0){ret = true;const char* home = GetHomePath().c_str();chdir(home);}else{ret = true;chdir(str);}}else if(gargc == 1){ret = true;chdir(GetHomePath().c_str());}else{//TODO}}else if(cmd == "echo"){if(gargc == 2){std::string args = gargv[1];if(args[0] == '$'){if(args[1] == '?'){ret = true;printf("%d\n",exit_code);exit_code = 0;}else{const char* name = &args[1];printf("%s\n",getenv(name));ret = true;}}else{ret = true;printf("%s\n",args.c_str());}}}return ret;
}bool ForkAndExec()
{pid_t id = fork();if(id < 0){perror("fork");return false;}else if(id == 0){//更改文件描述符指向的文件，从而让子进程只需要执行系统命令就可以达到重定向的功能if(redir == OUTPUT_REDIR){int output = open(filename.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0666);dup2(output, 1);}else if(redir == INPUT_REDIR){int input = open(filename.c_str(), O_RDONLY);dup2(input, 0);}else if(redir == APPEND_REDIR){int append = open(filename.c_str(), O_CREAT | O_WRONLY | O_APPEND);dup2(append, 1);}else{//nothing to do}execvp(gargv[0],gargv);exit(0);}else{int status = 0;pid_t rid = waitpid(id, &status, 0);if(rid > 0){//exit_code = WIFEXITED(status);exit_code = WEXITSTATUS(status);}}return true;
}

main.cc

#include"myshell.h"int main()
{char UserCommand[MAX];while(true){//打印命令行提示符PrintCommandLinePrompt();//获取用户输入的命令if(!GetUserCommand(UserCommand, sizeof(UserCommand)))continue;InitGlobal();//printf("echo %s\n",UserCommand);CheckRedir(UserCommand);//解析用户命令PraseUserCommand(UserCommand);//检查内建命令if(BuiltInCommandExec())continue;//执行命令,不能让父进程自己去执行程序替换，否则父进程程序替换之后就结束了，而shell是一个死循环软件，应该让子进程去执行ForkAndExec();}return 0;
}

Makefile

myshell:myshell.cc main.ccg++ -o $@ $^ -g
.PHONY:clean
clean:rm -f myshell

运行结果：

至此，我们简易版的mini_shell就完成了。觉得不错的小伙伴给个一键三连吧。