Linux进程控制【进程程序替换】

子进程在被创建后，会共享父进程的代码，如果想让子进程执行其他任务，就需要把当前子进程的程序替换为目标程序，这就是进程程序替换

1. 程序替换原理

我们使用一个替换函数execl，来看看现象

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

int main()
{
   
  printf("begin......\n");
  printf("begin......\n");
  printf("begin......\n");

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

  printf("end.....\n");
  printf("end.....\n");
  printf("end.....\n");
  return 0;
}

我们发现在myfile程序执行的过程中，调用execl来执行另一个程序，新的代码和数据加载了，但执行完新程序后并没有回来继续执行原程序，原程序中后续的代码直接被替换了，没机会执行了，这就是程序替换

进程程序替换原理

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支)
进程有对应的PCB，数据和代码会被加载到内存中，子进程调用一种exec函数(替换函数)时，该进程的代码和数据完全被新程序替换，执行新程序
进程的程序替换并没有创建新的进程，而是对原有程序中的数据和代码进行修改，调用exec函数前后该进程的PID并没有变化

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/wait.h>

int main()
{
   
  pid_t id = fork();
  if(id == 0)
  {
   
    printf("我是子进程, 我的PID:%d, PPID:%d\n", getpid(), getppid());
    execl("/bin/ls","ls", "-a", "-l");
  }
  sleep(3);

  printf("我是父进程,我的PID:%d\n", getpid());
  waitpid(id, NULL, 0);

  return 0;
}

进程程序替换图解

进程程序替换的目的就是是让子进程帮我们执行特定的任务

shell外壳中的bash就是一个任务处理平台，当我们发出指令后，bash会创建子进程，将其替换为对应的指令程序并执行任务，就能实现各种指令
bash运行后，使用指令本质上就是在进行程序替换

2. 替换函数

进程程序替换函数一共有七个，其中六个都是对系统级接口execve的封装

各替换函数关系图示

2.1 execl函数

#include <unistd.h>

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

execl函数

返回值：替换失败返回-1，成功后不返回
path参数：代替换程序的路径
arg参数：代替换程序名
. . .：可变参数列表，可以传递多个参数(这里是链式传递)，表示待替换的程序选项，最后一个必须以NULL结尾，表示选项传递结束

七个替换函数都是失败返回-1，成功不返回，成功后代码都被替换了，返回就没有意义了

使用实例

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

int main()
{
   
    printf("Can you see me?\n");

  int ret = execl("/bin/pwd", "pwd", NULL);

  if(ret == -1)
    printf("程序替换失败");

  printf("Can you see me?\n");
  return 0;
}

2.2 execv函数

#include <unistd.h>

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

execv函数

path参数：待替换程序的路径
argv[]参数：代替换程序名及其选项，是一个指针数组，相当于用一张表传递参数

使用实例

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

int main()
{
   
  char* const argv[] = {
   "ls", "-a", "-l", NULL}; //最后一个参数也要设为NULL

  execv("/bin/ls", argv);
  return 0;
}

2.3 execlp函数

#include <unistd.h>

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

execlp函数

file参数：执行文件名
arg参数：代替换程序名
. . .：可变参数列表，待替换的程序选项

使用实例

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

int main()
{
   
  execlp("ls", "ls", "-a", "-l", NULL);  

  return 0;
}
//第一个ls是执行文件名，第二个ls及以后是怎样执行的参数

execlp函数不用填写文件路径，可以自动到PATH变量中去查找程序，如果程序路径不在PATH变量中，则无法进行替换

2.4 execvp函数

#include <unistd.h>

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

execvp函数

file参数：待替换程序名，需要位于PATH中
argv[]参数：代替换程序名及其选项，是一个指针数组，相当于用一张表传递参数

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

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

  execvp("ls", argv);
  return 0;
}

如果file的路径不在 PATH中，程序会替换错误，想替换自己写的程序，需要将路径添加至 PATH 中

2.5 execle函数

execle最后的一个e，就表示环境变量表，可以将自定义的或者当前程序中的环境变量表传给待替换程序，其他没有带 e 的替换函数，默认传递当前程序中的环境变量表

#include <unistd.h>

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

execle函数

path参数：代替换程序的路径
arg参数：代替换程序名
. . .：可变参数列表，待替换的程序选项
envp[]：可自定义待替换程序的环境变量表

使用实例

//myfile.c
#include <stdio.h>
#include <unistd.h>

int main()
{
   
  char* const myenv[] = {
   "MYENV=study9/test.c", NULL};

  execle("./exec/otherTest", "otherTest", NULL, myenv);
  return 0;
}

//Test.c
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
using namespace std;

int main()
{
   
  for(int i = 0; i < 3; ++i)
  {
   
    cout << "我是exec路径下的程序,我的PID是: " << getpid() << " " << "MYENV:"<< (getenv("MYENV") == NULL ? "NULL" : getenv("MYENV")) << endl;
    sleep(1);
  }
  return 0;
}

我们改写一下Test.cc中的代码，来观察一个现象

//Test.c
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
using namespace std;

int main()
{
   
    cout << "------------------------------------------------------" << endl;
    cout << "我是exec路径下的程序,我的PID是: " << getpid() << endl;
    cout << "MYENV:"<< (getenv("MYENV") == NULL ? "NULL" : getenv("MYENV")) << endl;
    cout << "PATH:"<< (getenv("PATH") == NULL ? "NULL" : getenv("PATH")) << endl;
    cout << "------------------------------------------------------" << endl;  
  return 0;
}

再来运行myfile

我们观察到当本程序中设定自定义环境变量，待替换的程序中有系统环境变量，此时运行本程序时，待替换程序中的系统环境变量为NULL

如果主动传入环境变量后，待替换程序中的原环境变量表会被覆盖

这里可以使用putenv函数来解决这个现象

int putenv(char* string);  //改变或者添加一个环境变量

对myfile.c中的代码进行改造

//myfile.c
#include <stdio.h>
#include <unistd.h>

extern char** environ; //声明环境变量表

int main()
{
  char* const myenv[] = {"MYENV=Test/myfile.c", NULL};
  putenv("MYENV=Test/myfile.c");
  execle("./exec/MyTest", "MyTest", NULL, environ);

  return 0;
}

环境变量表具有全局属性，可以被继承下去，原理就体现出来了

所有的指令都是bash的子进程，在bash下执行程序，就是在bash下将子进程替换为指定程序，并将bash中的环境变量表environ传递给指定程序使用
bash执行指令都可以使用execl来执行，我们要把bash的环境变量交给子进程，子进程只需要调用execle，再把对应的bash的环境变量作为参数即可被子进程继承下去

2.6 execve函数

execve是系统级的程序替换函数，其他替换函数都是对execve的封装调用

#include <unistd.h>

int execve(const char* filename, char* const argv[], char* const envp[]);

execve函数

filename参数：待替换程序的路径
argv[]参数：代替换程序名及其选项，是一个指针数组，相当于用一张表传递参数
envp[]参数：可自定义待替换程序的环境变量表

系统及接口是不分语言的，无论什么语言最终都要调用系统接口，所以这里的替换函数还可以替换其他语言写的程序

2.7 execvpe函数

使用方法和execvp 一样，多了一个参数可以传递环境变量表

#include <unistd.h>

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

execvpe函数

file参数：待替换程序名，需要位于PATH中
argv[]参数：代替换程序名及其选项，是一个指针数组，相当于用一张表传递参数
envp[]参数：传递给待替换程序的环境变量表

2.8 函数记忆

函数名	参数格式	是否带路径	是否使用当前环境变量
execl	列表	不是	是
execlp	列表	是	是
execle	列表	不是	不是，必须自己组装环境变量
execv	数组	不是	是
execvp	数组	是	是
execve	数组	不是	不是，必须自己组装环境变量
execvpe	数组	是	不是，必须自己组装环境变量

exec系列替换函数的命名是有意义的

l就是list，表示链式传递
v就是vector，表示顺序表式传递
p就是PATH，表示能根据程序名自动在PATH变量中查找，无需写全路径
e就是environ，表示需要自己组装环境变量，可以传递自定义环境变量表

3. 模拟实现简易版shell

有了前面讲到的进程创建、进程退出、进程程序替换等知识的铺垫，我们可以自己写一个简易版的shell

shell 的循环过程

获取命令行
解析命令行
建立一个子进程（fork）
替换子进程（execvp）
父进程等待子进程退出（wait）

编写有些粗糙，仅供理解框架思路

//模拟实现简易版bash命令行
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <sys/wait.h>
#include <sys/types.h>

#define COMMANDMAXSIZE 1024
#define ARGVMAXSIZE 64

int split(char* command_string, char* argv[])
{
   
  assert(command_string != NULL && argv != NULL);
  argv[0] = strtok(command_string, " ");
  if(argv[0] == NULL) 
  {
   
    return -1;
  }
  int i = 1;
  while((argv[i++] = strtok(NULL, " ")));
  return 0;
}

void debugOut(char* argv[])
{
   
  int i = 0;
  while(argv[i] != NULL)
  {
   
    printf("%d->%s\n", i, argv[i]);
    ++i;
  }
}

int main()
{
   
  while(1)
  {
   
    char command_string[COMMANDMAXSIZE] = {
   0};
    printf("[name@my_root currpath]# ");
    fflush(stdout);
    char* s = fgets(command_string, sizeof(command_string), stdin);
    assert(s != NULL);
    (void)s; //保证release版本时,因为去掉assert()导致ret未被使用，而带来的编译告警
    command_string[strlen(command_string) - 1] = '\0'; //去掉回车导致的换行
    char* argv[ARGVMAXSIZE] = {
   NULL};
    int ret = split(command_string, argv); //命令字符串切割
    if(ret != 0)
    {
   
      continue;
    }
    //debugOut(argv);

    pid_t id = fork();
    assert(id >= 0);
    if(id == 0) //子进程
    {
   
      execvp(argv[0], argv);
      exit(0); 
    }

    //父进程
    int status = 0;
    waitpid(id, &status, 0);

    //子进程去执行对应的命令，父进程等待子进程
  }
  return 0;
}

Linux进程控制—进程程序替换，到这里就介绍结束了，本篇文章对你由帮助的话，期待大佬们的三连，你们的支持是我最大的动力！

文章有写的不足或是错误的地方，欢迎评论或私信指出，我会在第一时间改正

Linux进程控制【进程程序替换】

Linux进程控制【进程程序替换】

1. 程序替换原理

2. 替换函数

2.1 execl函数

2.2 execv函数

2.3 execlp函数

2.4 execvp函数

2.5 execle函数

2.6 execve函数

2.7 execvpe函数

2.8 函数记忆

3. 模拟实现简易版shell

龙蜥操作系统

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像