攻破：进程替换

前言：

​ 承接上文的进程控制，我们接下来想要来聊一聊进程替换，进程替换是怎么实现的呢？理解完进程替换后，我想我们就对命令行解释器bash有了一定的了解。所以这一章结束之后，我会带领大家自主编写一份属于自己的shell命令行解释器。

进程程序替换

解释：

​ 首先我们需要了解关于替换的六种以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[]);

函数解释 :

• 这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
• 如果调用出错则返回-1
• 所以exec函数只有出错的返回值而没有成功的返回值

命名理解 :

• l(list) : 表示参数采用列表
• v(vector) : 参数用数组
• p(path) : 有p自动搜索环境变量PATH
• e(env) : 表示自己维护环境变量

代码和现象：

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

int main()
{
    printf("This is the beginning of process....\n");

    execl("/usr/bin/ls", "ls", "-l", "-a", NULL);

    printf("This is the end of process...\n");
    return 0;
}

​

解释加分析：

我们在此是将新的程序，从磁盘中取出并且覆盖掉老的代码和数据，需要的话重新建立页表映射关系，这就叫——程序替换

当然在整个过程中，我们是不会创建新的额外进程来实现替换操作。相当于拿着老进程的pcb执行新进程的代码。
站在被替换进程的高度（ls命令）：本质就是这个程序被加载到内存之中。

• 怎么加载？

  exec系列函数类似于一种Linux的加载函数。

• 怎么执行完ls命令后，关于end of process的输出语句不见了？

  exec系列的函数执行完毕后，后续的代码不见了这是正常的，因为被替换了！

  

• 为什么我们不关心exec系列函数的返回值？

  只要替换成功了，就不会向后运行了
  但是只要向后运行了，一定是替换失败了！

将代码改为多进程版

​ 以前我们谈论为什么我们要创建子进程时，讨论过创建子进程一方面是想实现别的功能，以前我们只能执行当前父进程继承下来的代码，但是现在我们可以让子进程执行全新的代码，甚至说不同语言的代码都已实现。

​ 具体的实现操作就如同咱们在讲解地址空间时讲解的——写实拷贝。
​ 本来子进程在不修改代码和数据的时候，在物理内存中是不会发生变化的，但是由于进程替换，子进程被替换成了别的进程的代码和数据，所以OS就会发生写实拷贝！！！

​ 下面我们就来动手实操一些代码来看看结果：

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

int main()
{
    printf("This is a process! pid: %d\n", getpid());
    
    pid_t id = fork();
    if(id == 0)
    {
        //child
        printf("This is child process! pid: %d, ppid: %d\n", getpid(), getppid());
        sleep(1);
        execl("/usr/bin/ls", "ls", "-l", "-a", NULL);
        exit(1); // return 1 if failed to substitution
    }
    
    //father
    printf("This is father process! pid: %d, ppid: %d\n", getpid(), getppid());
    int status = 0;
    pid_t rid = waitpid(id, &status, 0); // pend waiting
    if(rid > 0)
    {
        printf("wait success!\n");
        if(WIFEXITED(status))
        {
            sleep(1);
            printf("success quit, exit_code: %d\n", WEXITSTATUS(status));
        }
    }
    else
    {
        printf("wait falied!\n");
    }
    return 0;
}

​

​ 当然上面的代码是百分之百正确的，接下来我将execl函数里的参数乱写一份，这样就是替换错误，那么我们来看看最后的退出码会是多少：

所以进程替换还是很容易检测是否成功，看看有没有执行被替换的程序即可。

替换不同语言：

​ 我们当然不仅仅可以使用系统指令进行替换，下面我们来看看能否用C++来进行替换：

#include <iostream>
#include <unistd.h>
#include <sys/types.h>

using namespace std;

int main()
{
    cout << "process pid: " << getpid() << endl;
    cout << "This is C++!!!\n" << endl;
    cout << "This is C++!!!\n" << endl;
    cout << "This is C++!!!\n" << endl;
    cout << "This is C++!!!\n" << endl;
    cout << "This is C++!!!\n" << endl;
    cout << "This is C++!!!\n" << endl;
    cout << "This is C++!!!\n" << endl;
    return 0;
}

​ 那么此时我们的Makefile文件也需要重新编写：

.PHONY:all
all:testexec myprocess

myprocess:myprocess.cc
	g++ -o $@ $^

testexec:testexec.c
	gcc -o $@ $^
.PHONY:clean
clean:
	rm -f testexec myprocess

​ 最后还需要对函数参数进行修改：

execl("./myprocess", "myprocess", NULL);

​

最后的运行结果也正如预期一样，而且我们也能看到子进程的pid在替换后都是一样的值，这进一步证明了没有新的进程产生！

其他系列的函数：

​

​ 我们现在就可以来解释各个参数的含义：

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

• 对于出现path的参数，我们需要带上绝对路径，就比如/usr/bin/ls。
  而对于file参数我们则可以不带绝对路径，直接“ls”.
  告诉函数 “你要在哪里找到”

• 对于arg这个参数，会发现非常像之前讲解的命令行参数，告诉函数 “你想怎么执行”。
  如果是argv则需要我们将各个命令行参数存入数组里，进行传参。
  反正就是你在命令行怎么写指令，你就怎么传参。
  例如：要实现 ls -l -a，就可以写成—— “ls”, “-l”, “-a”

• 同理后面出现的e就是代表环境变量，需要将环境变量存入数组再进行传参。
  作用就是整体替换所有的环境变量，有以下三种方式：
  1、用全新的环境变量给子进程
  2、用老的环境变量给子进程
  3、对老的环境变量稍作修改给子进程。

代码演示：

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

  char* const  argv[] = 
  {
  	(char*)"ls",
  	(char*)"-l",
  	(char*)"-a",
  	NULL
  };
  
  execv("/usr/bin/ls", argv);
  

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

  char* const  argv[] = 
  {
  	(char*)"ls",
  	(char*)"-l",
  	(char*)"-a",
  NULL
  };
  
  execvp("ls", argv);
  

• int execle(const char *path, const char *arg, …,char *const envp[]);

  char* const envy[] = 
  {
  	(char*)"HEHE=11111",
  	(char*)"HAHA=22222",
  	NULL
  };
  
  execle("./myprocess", "myprocess", NULL, envy);
  

  对于该代码我想要验证一下结果是如何：我们需要对C++的代码改一改。

  #include <iostream>
  #include <unistd.h>
  #include <sys/types.h>
  #include <cstdio>
  
  using namespace std;
  
  int main(int argc, char* argv[], char* env[])
  {
  
      cout << "process pid: " << getpid() << endl;
      cout << "-----------------------------------------" << endl;
      cout << argc << endl;
      int i = 0;
      for(; argv[i]; ++i)
      {
          printf("argv[%d]->%s\n", i, argv[i]);
      }
      cout << "-----------------------------------------" << endl;
      for(i = 0; env[i]; ++i)
      {
          printf("env[%d]->%s\n", i, env[i]);
      }
      cout << "-----------------------------------------" << endl;
      cout << "This is C++!!!\n" << endl;
      cout << "This is C++!!!\n" << endl;
      cout << "This is C++!!!\n" << endl;
      cout << "This is C++!!!\n" << endl;
      cout << "This is C++!!!\n" << endl;
      cout << "This is C++!!!\n" << endl;
      cout << "This is C++!!!\n" << endl;
      return 0;
  }
  
  

  ​

  以上是将新定义的环境变量给子进程，当然我们可以用之前学习过的代码：
  extern char** environ进行传递，这代表将老的环境变量传递给子进程：

  extern char** environ;
  execle("./myprocess", "myprocess", NULL, environ);
  

  

  最后的运行结果也是将全部老的环境变量打印出来了。

  我们也可以在老的环境变量基础上，添加环境变量：

  

总结：

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

总结：

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

[外链图片转存中…(img-Bna9tNEa-1723785190414)]

​ 本章代码有点多，大家可以参考我的gitee：进程替换