【Linux】剧幕中的灵魂更迭：探索Shell下的程序替换

🎬 个人主页：谁在夜里看海.****

📖 个人专栏：《C++系列》《Linux系列》《算法系列》

⛰️ 一念既出，万山无阻

📖一、进程程序替换

上一篇博客我们讲到了进程的诞生过程：父进程调用fork创建子进程，子进程执行父进程相同的程序。但是很多时候我们希望子进程执行另一个程序，此时就要用到exec函数调用，子进程中调用exec函数之后，该程序就会被调用的程序代替，这就是程序替换：

1.替换的演示

#include<stdio.h>
#include<unistd.h>
int main()
{
   int a = 0;
   a++;
   execl("/usr/bin/pwd", "pwd", NULL);
   printf("%d\n", a++);
}

此时程序执行结果：

我们可以看到，原先的程序执行结果应该是打印变量a，但是被替换成了pwd指令（指令本身也是一个可执行程序），这就是程序替换的过程：当进程调用exec函数时，该进程的代码和数据完全被新程序替换，从新程序的启动例程开始执行。

❓替换与执行流

int main()
{
  int a = 0;
  printf("Before: %d\n",a++);
  execl("/usr/bin/pwd", "pwd", NULL);
  printf("After: %d\n", a++);
}

不对呢，不是说程序替换之后原来的代码和数据都会被替换吗，那为什么这里还会显示原程序的打印信息呢？下面进行分析：

✅虽然进程调用exec函数后会发生程序替换，原程序的代码和数据会被覆盖，但在调用

exec

函数之前，执行流还是要经过原来的步骤的，上述代码中，在调用execl之前，执行流先执行printf函数代码，由于以“\n”结尾，输出缓冲区的数据会被刷新到终端，所以我们能看到“Before: 0”：

修改一下代码，结尾不加“\n”， 此时数据会被保留在输出缓冲区当中，后面又因为发生程序替换，缓冲区的内容被清除了，所以最终终端不会显示"Before: 0"内容：

int main()
{
  int a = 0;
  printf("Before: %d",a++);
  execl("/usr/bin/pwd", "pwd", NULL);
  printf("After: %d\n", a++);
}

❓程序替换≠进程替换

程序替换会改变进程的执行内容，但它不会改变进程的进程ID，也就是说，进程还是原来的进程，程序替换并不是进程替换，且看下面示例：

先写一个可执行程序test2，源代码为：

#include<stdio.h>
#include<unistd.h>
int main()
{
  // 打印当前pid，ppid
  printf("After: pid = %d, ppid = %d\n",getpid(),getppid()); 
}

另一个可执行程序test源代码为：

#include<stdio.h>
#include<unistd.h>
int main()
{
  // \n结尾直接打印当前内容
  printf("Before: pid = %d, ppid = %d\n",getpid(),getppid());
  // 程序替换成test2
  execl("/home/ywh/linux_gitee/test_excel/test2", "test2", NULL);
}

test执行结果：

我们可以看到，程序替换前后都是同一个进程，结论：exec并不创建新进程。

2.替换的原理

📚 系统调用exec

exec

系列函数（如

execl

,

execv

,

execve

等）是用来将当前进程的内存空间、程序代码段、数据段等替换成一个新的程序。该系统调用不会创建新进程，而是直接用新程序替换当前进程的内容。

具体来说，

exec

调用会：

①：清空当前进程的代码段、数据段、堆栈等。

②：加载并执行新程序的代码段、数据段、堆栈等。

③：保留当前进程的进程 ID (PID)、父进程标识符 (PPID)、文件描述符等。

📚 进程控制块 (PCB)

操作系统通过 进程控制块 (PCB) 来管理进程，每个进程都有一个独立的 PCB，包含了进程的各种状态信息，比如进程的 PID、父进程 ID、程序计数器、堆栈指针等。

当调用

exec

时，进程的 PCB 中的状态信息并没有被改变，操作系统只会根据

exec

调用的参数加载新的程序内容（代码段、数据段等），并且更新程序计数器和堆栈指针等信息。

📚 内存管理

操作系统中的内存管理模块负责为进程分配内存。当进程调用

exec

时，操作系统会：

①：释放原进程的内存（代码段、数据段、堆栈）。

②：加载新程序的内存：从磁盘（例如 ELF 文件或其他可执行文件）中加载新的程序到内存，包括新的代码段、数据段等。

③：更新堆栈和堆的布局，准备新程序的运行环境。

3. 替换的函数

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

 #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[]);

为了便于理解，我们可以把exec后面出现的 **l、p、e、v **看作exec的四个选项，下面我们依次介绍这些选项：

📚 execl

**l(list) : 参数采用列表 **

path：表示要执行的程序路径；

arg：表示程序本身的参数，第一个是程序本身的名称，后续为程序的参数（传递系统指令时，参数就是指令的选项），必须以NULL结尾。

示例：

execl("/bin/ls", "ls", "-l", (char *)NULL);

📚 execv

v(vector) : 参数用数组

path：表示要执行的程序路径；

argv：参数列表，程序的参数以数组的形式传递，数组内部也必须以NULL结尾。

示例：

execv("/bin/ls", (char *[]){"ls", "-l", NULL});

📚 execp

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

它可以通过环境变量

PATH

来查找可执行文件，而不需要提供绝对路径。

示例：

execlp("ls", "ls", "-l", (char *)NULL);

📚 exece

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

execle

允许显式地传递一个 环境变量数组，而不是继承当前进程的环境变量。通过

execle

，你可以自定义新进程的环境变量。

示例：

char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
execle("ps", "ps", "-ef", NULL, envp);

🚩本质

事实上，只有execve才是真正的系统调用，而其他四个函数最后都会调用execve：

📖二、命令行解释器shell

我们在linux学习过程中离不开shell，shell是命令行解释工具，是用户与内核之间的工具，提供了一个接口，通过它，我们可以执行命令、启动程序等与操作系统进行交互。shell解析用户输入的命令，返回执行结果。

❓shell的本质是什么呢？

1.shell的本质

✅shell本质其实是一个进程：

当我们启动一个终端或打开一个命令行窗口的时候，相当于启动了一个shell进程（也叫bash进程），这个进程会等待用户输入的命令，并将命令通过系统调用传递给内核，内核执行相应的操作后，返回给shell。

shell的工作原理就是循环以下操作：

1️⃣获取命令行 --> 2️⃣解析命令行 --> 3️⃣fork创建子进程

--> 4️⃣execve替换子进程 --> 5️⃣wait等待子进程退出 ->1️⃣

根据这些思路，我们可以模拟实现一个shell：

2.shell的模拟实现

实现一个简化版的shell，需要执行以下功能：

① 获取当前工作目录、用户名、主机名。

② 解析用户输入的命令行并执行命令。

③ 内置支持一些常见命令，如

cd

、

echo

、

export

等。

④ 创建子进程来执行普通命令，并支持基本的命令分割和管道处理。

📚头文件

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

这些头文件提供了标准输入输出、字符串处理、系统调用等功能。unistd包含与进程相关的函数（如fork，exit）

📚宏定义

#define LEFT "["
#define RIGHT "]"
#define LABLE "#"
#define DELIM " \t"
#define LINE_SIZE 1024
#define ARGC_SIZE 32
#define EXIT_CODE 44

LEFT、RIGHT、LABLE：用于命令行提示符的格式化；

DELIM：用于命令行字符串的分隔符；

LINE_SIZE、ARGC_SIZE：定义了命令行和参数的缓冲区大小；

EXIT_CODE：用于子进程异常退出的返回值。

📚全局变量

int lastcode = 0;
int quit = 0;
extern char **environ;
char commandline[LINE_SIZE];
char *argv[ARGC_SIZE];
char pwd[LINE_SIZE];
char myenv[LINE_SIZE];

lastcode：保存上一个命令的退出码；

quit：用于控制shell是否退出；

commandline：存储用户输入的命令行字符串；

argv：存储解析后的命令和参数；

pwd：保存当前工作目录；

myenv：存储自定义的环境变量。

📚获取信息

const char *getusername() {
    return getenv("USER");
}
const char *gethostname() {
    return getenv("HOSTNAME");
}
void getpwd() {
    getcwd(pwd, sizeof(pwd));
}

getusername：获取用户名

gethostname：获取主机名

getpwd：获取当前工作目录

📚交互式命令行输入

void interact(char *cline, int size) {
    getpwd();
    printf(LEFT"%s@%s %s"RIGHT""LABLE" ", getusername(), gethostname(), pwd);
    char *s = fgets(cline, size, stdin);
    assert(s);
    (void)s;
    cline[strlen(cline)-1] = '\0';
}

interact函数显示格式化的提示符，并等待用户输入命令。输入命令存储在cline中；输入的命令符末行换行符替换成终止符 '\0'。

📚字符串分割

int splitstring(char cline[], char *_argv[]) {
    int i = 0;
    argv[i++] = strtok(cline, DELIM);
    while(_argv[i++] = strtok(NULL, DELIM));
    return i - 1;
}

splitstring函数使用strtok将输入的命令行字符串按空格和制表符分割成多个命令或参数，存储在指针数组argv中。

📚内置命令

int buildCommand(char *_argv[], int _argc) {
    if(_argc == 2 && strcmp(_argv[0], "cd") == 0) {
        chdir(argv[1]);
        getpwd();
        sprintf(getenv("PWD"), "%s", pwd);
        return 1;
    }
    else if(_argc == 2 && strcmp(_argv[0], "export") == 0) {
        strcpy(myenv, _argv[1]);
        putenv(myenv);
        return 1;
    }
    else if(_argc == 2 && strcmp(_argv[0], "echo") == 0) {
        if(strcmp(_argv[1], "$?") == 0) {
            printf("%d\n", lastcode);
            lastcode=0;
        }
        else if(*_argv[1] == '$') {
            char *val = getenv(_argv[1]+1);
            if(val) printf("%s\n", val);
        }
        else {
            printf("%s\n", _argv[1]);
        }
        return 1;
    }
    if(strcmp(_argv[0], "ls") == 0) {
        _argv[_argc++] = "--color";
        _argv[_argc] = NULL;
    }
    return 0;
}

提供了几个内置命令：

cd：改变当前目录

export：设置一个新的环境变量

enho：打印变量值或退出码

📚普通命令

队友普通命令的执行，需要调用exec程序替换成目标命令的程序：

void NormalExcute(char *_argv[]) {
    pid_t id = fork();
    if(id < 0) {
        perror("fork");
        return;
    }
    else if(id == 0) {
        execvp(_argv[0], _argv);
        exit(EXIT_CODE);
    }
    else {
        int status = 0;
        pid_t rid = waitpid(id, &status, 0);
        if(rid == id) {
            lastcode = WEXITSTATUS(status);
        }
    }
}

NormalExcute使用fork创建子进程，子进程调用execvp，替换当前程序，父进程等待子进程结束。

📚main函数

int main() {
    while(!quit) {
        interact(commandline, sizeof(commandline));
        int argc = splitstring(commandline, argv);
        if(argc == 0) continue;
        int n = buildCommand(argv, argc);
        if(!n) NormalExcute(argv);
    }
    return 0;
}

main函数进入循环，不断接收用户输入的命令并解析执行。

如果命令是内置命令，则在当前进程中执行；如果是普通命令，通过程序替换在子进程中执行。

以上就是【剧幕中的灵魂更迭：探索Shell下的程序替换】的全部内容，欢迎指正~

码文不易，还请多多关注支持，这是我持续创作的最大动力！