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

进程程序替换的必要性

父进程创建出来的子进程的代码段是和父进程一样的，当我们要让子进程执行不同的程序的时候，就需要让子进程调用进程程序替换的接口，从而让子进程执行不一样的代码。需要注意的是，进行进程程序替换的是正在运行的进程。

进程程序替换的原理

替换进程的代码段和数据段，更新堆栈（从main函数开始重新执行）。

exec函数簇

execl函数

函数原型：

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

参数：
path：带路径的可执行程序（需要路径），要替换成为的就是这个程序。
arg：传递给可执行程序的命令行参数。第一个参数是可执行程序本身，如果要传递多个参数，用“，”隔开。三个点代表函数是可变参数列表，所以末尾要用NULL来标志结束。
返回值：
调用出错，也就是没有替换成功则返回-1；
调用成功则加载新的程序从启动代码开始执行，不再返回。
代码验证：

 #include <unistd.h>
  2 #include <stdio.h>
  3 int main(){
  4   printf("I am main, I am starting...\n");
  5   execl("/usr/bin/ls","-a","-l",NULL);
  6   printf("I am main,I will finish.\n");
  7   return 0;
  8 } 
1
2
3
4
5
6
7
8

执行结果：

main函数没有打印最后那句话，就证明进程程序替换成功了，执行完execl函数之后就退出了当前代码段，也不再返回。如果失败是什么样子呢？我们把路径修改一下。

 #include <unistd.h>
  2 #include <stdio.h>
  3 int main(){
  4   printf("I am main, I am starting...\n");
  5   int ret = execl("/usr/binnnnn/ls","-a","-l",NULL);
  6   printf("ret = %d\n",ret);
  7   printf("I am main,I will finish.\n");
  8   return 0;
  9 }  
1
2
3
4
5
6
7
8
9

执行结果：

execlp函数

函数原型：

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

参数：
file：可执行程序，可以带路径，也可以不带路径
arg：传递给可执行程序的命令行参数。第一个参数是可执行程序本身，如果要传递多个参数，用“，”隔开。可变参数列表，所以末尾要用NULL来标志结束。
返回值：
调用出错则返回-1；
调用成功则加载新的程序从启动代码开始执行，不再返回。

 #include <unistd.h>
  2 #include <stdio.h>
  3 int main(){
  4   printf("I am main, I am starting...\n");
  5   execlp("/usr/bin/ls","-l",NULL);                                                                                                                                     
  6   printf("I am main,I will finish.\n");
  7   return 0;
  8 }

1
2
3
4
5
6
7
8
9

执行结果：

观察执行结果，不难发现，它并没有完成既定的功能，为什么呢？因为要求第一个参数是可执行程序本身，我们修改一下：

1 #include <unistd.h>
  2 #include <stdio.h>
  3 int main(){
  4   printf("I am main, I am starting...\n");
  5   execlp("/usr/bin/ls","ls","-l",NULL);                                                                                                                                
  6   printf("I am main,I will finish.\n");
  7   return 0;
  8 }

1
2
3
4
5
6
7
8
9

执行结果：

不带路径：

1 #include <unistd.h>
  2 #include <stdio.h>
  3 int main(){
  4   printf("I am main, I am starting...\n");
  5   execlp("ls","ls","-l",NULL);                                                                                                                                         
  6   printf("I am main,I will finish.\n");
  7   return 0;
  8 }
1
2
3
4
5
6
7
8

上述不带路径的代码和再上面带路径的代码完成的功能一样。那加不加路径有什么区别呢？怎么区分要不要加路径呢？这个主要是和环境变量PATH有关。
函数名中带有“p”：可以使用环境变量PATH，无需写全路径，也就是说，函数会搜索可执行程序PATH，找到可执行程序，所以不用写路径。那环境变量是从哪来的呢？是从被替换的那个进程当中来的。
函数名中带有“l”：传递给可执行程序的参数是以可变参数列表的方式传递，参数是传递给替换成为的那个可执行程序的。第一个参数是可执行程序本身；如果要传递多个参数，用“，”隔开；末尾以NULL结尾。

execle函数

函数原型：

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

参数：
path：带路径的可执行程序
arg：传递给可执行程序的命令行参数。第一个参数是可执行程序本身，如果要传递多个参数，用“，”隔开。可变参数列表，所以末尾要用NULL来标志结束。
envp：程序员传递环境变量，也就是说，程序员调用该函数的时候，需要自己组织环境变量传给函数。
返回值：
调用出错则返回-1；
调用成功则加载新的程序从启动代码开始执行。

代码验证：

#include <unistd.h>
  2 #include <stdio.h>
  3 int main(){
  4   printf("I am main, I am starting...\n");
  5   extern char** environ;
  6   //指向环境变量的二级指针
  7   execle("/usr/bin/ls","ls","-l","-a",NULL,environ);                                                                                                                   
  8   printf("I am main,I will finish.\n");
  9   return 0;          
 10 }   
1
2
3
4
5
6
7
8
9
10

函数名当中带有e的，需要程序员自己传递环境变量。

execv函数

函数原型：

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

参数：
path：带路径的可执行程序
argv：传递给可执行程序的命令行参数，以指针数组的方式传递，第一个参数要求是可执行程序本身，多个参数放入数组中，最后以NULL结尾。
返回值：
调用出错则返回-1；
调用成功则加载新的程序从启动代码开始执行。

代码验证：

#include <unistd.h>
    2 #include <stdio.h>
    3 int main(){
    4   printf("I am main, I am starting...\n");
    5   char* argv[10]={0};
    6   argv[0]="ls";
    7   argv[1]="-l";
    8   argv[2]=NULL;
    9   execv("/usr/bin/ls",argv);                                                                 
   10   printf("I am main,I will finish.\n");
   11   return 0;
   12 }
1
2
3
4
5
6
7
8
9
10
11
12

函数名带v的，传递给替换成为的程序的命令行参数都是以指针数组的方式进行传递。

execvp函数

函数原型：

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

参数：
file：可执行程序，可以带有路径，也可以不带路径
argv：传递给可执行程序的命令行参数，以指针数组的方式传递，第一个参数要求是可执行程序本身，多个参数放入数组中，最后以NULL结尾。
返回值：
调用出错则返回-1；
调用成功则加载新的程序从启动代码开始执行。

代码验证：

 #include <unistd.h>
    2 #include <stdio.h>
    3 int main(){
    4   printf("I am main, I am starting...\n");
    5   char* argv[10]={0};
    6   argv[0]="ls";
    7   argv[1]="-l";
    8   argv[2]=NULL;
    9   execvp("ls",argv);                                                                         
   10   printf("I am main,I will finish.\n");
   11   return 0;
   12 }

1
2
3
4
5
6
7
8
9
10
11
12
13

execve函数

函数原型：

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

参数：
path：带路径的可执行程序
argv：传递给可执行程序的命令行参数，以指针数组的方式传递，第一个参数要求是可执行程序本身，多个参数放入数组中，最后以NULL结尾。
envp：程序员传递环境变量，也就是说，程序员调用该函数的时候，需要自己组织环境变量传给函数。
返回值：
调用出错则返回-1；
调用成功则加载新的程序从启动代码开始执行。

代码验证：

#include <unistd.h>
    2 #include <stdio.h>
    3 int main(){
    4   printf("I am main, I am starting...\n");
    5   char* argv[10]={0};
    6   argv[0]="ls";
    7   argv[1]="-l";
    8   argv[2]=NULL;
    9   extern char** environ;
   10   execve("ls",argv,environ);                                                                 
   11   printf("I am main,I will finish.\n");
   12   return 0;
   13 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14

execve是系统调用函数，其他几个都是库函数。