Linux进程控制（四）之进程程序替换

进程程序替换

如果要让子进程执行与父进程完全不同的代码，就要进行进程程序替换。

单进程版程序替换

执行一个可执行文件

makefile

mycommand:mycommand.cgcc -o $@ $^ -std=c99
.PHONY:clean
clean:rm -rf mycommand    

mycommand.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>int main()
{printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());//这类方法的标准写法 execl("/usr/bin/ls","ls","-a","-l",NULL);//必须以NULL结尾                              printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());return 0;
}

现象：after没有执行，把ls -a -l执行了，每个pid也不一样了。

mycommand.c

#include <stdio.h>  
#include <unistd.h>  
#include <stdlib.h>  int main()  
{  printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid()); //这类方法的标准写法   //execl("/usr/bin/ls","ls","-a","-l",NULL);//必须以NULL结尾  execl("/usr/bin/top","top",NULL);//必须以NULL结尾                                      printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());  return 0;                                               
}

程序可以把系统里的命令封装起来，程序变成进程之后把命令跑起来。

替换原理

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),

子进程往往要调用一种exec函数以执行另一个程序。

当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。

调用exec并不创建新进程,所以调用exec前后该进程的id并未改变。

---

代码运行起来就是我们系统当中的一个进程，

创建新进程总会创建一个进程的PCB(task_struct)，地址空间，页表等，

要把代码、数据加载到内存里，通过页表映射内存，

然后CPU根据PCB找到虚拟地址、页表映射代码和数据并执行。

以ls为例，ls用execl加载进内存，

直接把ls的代码替换原来的代码，

ls的数据直接替换原来的数据。（没有创建新进程！）

（如果ls代码数据加载到内存了，小了就新增空间，大了就释放空间）

把页表的右侧的映射地址改变一下（收缩一下）。

新加载的程序从main函数重新运行（从0开始执行）。

–程序替换！

多进程版程序替换

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{pid_t id=fork();if(id==0){printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());sleep(5);//这类方法的标准写法 execl("/usr/bin/ls","ls","-a","-l",NULL);//必须以NULL结尾printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);        }                   pid_t ret=waitpid(id,NULL,0);if(ret>0)                                                                         {                                                                                 printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);              }sleep(5);return 0;
}  

在子进程sleep(5)的时候，父进程阻塞等待子进程退出。

子进程在调用execl时，不会影响父进程。

原因：发生了写时拷贝，进程之间是相互独立的。

没有调用execl的时候，子进程只指向父进程的代码和数据，

当子进程执行execl时，ls代码数据替换进来的时候，

发生写时拷贝，不管是代码还是数据都有写时拷贝。

代码不一定是不可被写入的，用户直接写，操作系统会拦截崩溃，

但是execl是让操作系统写。

---

程序替换没有创建新进程，只进行代码和数据的程序替换。

父子进程的pid一直都没有变。

子进程结束前是2254，结束后还是2254。

所以，task_struct,mm_struct是没有被释放或者重新建立的。（字段可能会稍微修改）

替换函数

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

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

函数解释

after及之后的代码没有被执行，

原因：after及后面代码是在execl程序替换之后的，

原来的代码会被替换，所以，after及后面代码被ls的代码替换了，

所以后续代码不会被执行。

程序替换成功之后，exec* 后续的代码不会被执行。

程序替换失败了，才可能执行后续代码。

这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。

如果调用出错则返回-1

所以exec* 函数只有失败的返回值而没有成功的返回值。

小知识

CPU如何得知程序的入口地址？

Linux中形成的可执行程序，是由格式（ELF）的，可执行程序的表头，可执行程序的入口地址就在表头！！！

可执行程序的表包括：代码段，数据段，只读数据区等，这些段区的地址在表头。

加载可执行程序时，代码和数据可以先不加载，

但是一定要先加载表头，每个数据区的开始的数字（start）就是在表头中来的。

当我们替换了一个新进程，新进程也有表头，CPU就可以在表头读到对应的可执行程序的入口。

可执行程序在编译的时候，就产生了一个STARTART的地址（程序入口），

编写到表头中，加载到内存时，CPU可以获取。

表头一方面初始化我们的地址空间、页表等，另一方面告诉CPU代码的程序入口在哪里。

命名理解

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

v(vector) : 参数用数组

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

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

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

execl：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{pid_t id=fork();if(id==0){printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());execl("/usr/bin/ls","ls","-a","-l",NULL);//必须以NULL结尾               printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);                                                   }                                                              pid_t ret=waitpid(id,NULL,0);                                  if(ret>0)                                                           {                                                                   printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);}                                                              return 0;                                                      
}

传参的时候，从第二个参数开始，一个一个地传递，最后一个必须为NULL。

函数名带 ‘l’ 的，传参采用可变参数，而且传参时，一个一个地传。

从第二个参数开始，在命令行当中怎么写的，就依次怎么传递参数给程序，

空格改成逗号，最后加上NULL。

要执行一个程序第一件事就是找到要执行的程序。

所有的exec* 第一个参数（const char *path） ：决定如何找到该程序。

名字不带 ‘p’ 必须是全路径（绝对或者相对路径的方式找到要执行的程序）

第一个参数解决：在什么路径下找到该程序。

第二个参数解决：如何执行这个程序，要不要涵盖选项，涵盖哪些。

execlp：

PATH：execlp会在默认的PATH环境变量中查找。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{pid_t id=fork();if(id==0){printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());//execlp("/usr/bin/ls","ls","-a","-l",NULL);execlp("ls","ls","-a","-l",NULL);             printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);                                                   }                                                              pid_t ret=waitpid(id,NULL,0);                                  if(ret>0)                                                           {                                                                   printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);}                                                              return 0;                                                      
}

可以带路径也可以不带路径。

函数名中带了 ‘p’ 就不用带路径了，execlp会自动在环境变量中查找，

所有子进程都会继承父进程的环境变量列表，

当前的进程所有的环境变量都是从bash里来的，

bash里面本来就有path，就会被所有的子进程继承。（环境变量具有全局属性）

ls在usr/bin目录下，找到之后执行。

有两个ls是因为：

第一个参数为了 找到程序，不仅要告诉execlp路径（路径由path解决），

而且要告诉execlp要执行什么程序。

第一个ls代表要执行谁，第二个ls代表要怎么执行。

---

execv：

char *const argv[] -> 字符串指针数组

第一个参数：怎么找到该程序。

第二个参数：如何执行这个程序。

就是把可变参数的传参形式变成了指针数组的形式。

中间const表示：

一旦写进去了，指向的地址不能改变。（指针本身不能改）

内容可以改，"-a"等可以改。（指针指向的内容可以修改）

  #include <stdio.h>#include <unistd.h>#include <stdlib.h>#include <sys/wait.h>#include <sys/types.h>int main(){pid_t id=fork();if(id==0){char *const myargv[]={"ls","-a","-l",NULL};printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());execv("/usr/bin/ls",myargv);                           printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);                                                      }                                                          pid_t ret=waitpid(id,NULL,0);                                     if(ret>0)                                                         {                                                                 printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);}                                                    return 0;                                            }

ls是一个程序，有main函数，main函数有命令行参数，命令行参数由execv系统调用，第二个参数传入的。

可变参数最终也要变成指针数组的形式，然后传入ls调用的main函数当中。

execv系统调用，系统获取的命令行参数，会把参数传递给ls的main函数。

在Linux当中，所有的进程都是别人的子进程，

在命令行当中，所有的进程都是bash的子进程。

所以，所有的进程在启动的时候都是采用exec*系列函数来启动执行的。

程序替换在单进程当中，是把对应的可执行程序的代码和数据加载到内存当中，

为当前进程开辟空间等，然后把自己的代码数据加载进内存。

所以，exec*系列函数 - 起到了加载器的作用。（代码级别的加载器）

exec*函数把磁盘当中的可执行程序加载到内存中。

所以，exec*里会存在诸如内存申请、外设访问等动作。

exec把可执行程序导入到内存里，可以获得命令行参数，

所以execv就可以直接调用ls的main函数时，把argv参数传递给程序。

所有的函数都是压栈，在调用main函数之前先形成一个简单的栈帧结构，

把argv的地址push进去，构造一个main函数被调用的上下文，就可以把argv传入。

所以我们是可以把命令行参数传递给可执行程序的。

---

execvp：

  #include <stdio.h>#include <unistd.h>#include <stdlib.h>#include <sys/wait.h>#include <sys/types.h>int main(){pid_t id=fork();if(id==0){char *const myargv[]={"ls","-a","-l",NULL};printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());execvp("ls",myargv);                           printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);                                                      }                                                          pid_t ret=waitpid(id,NULL,0);                                     if(ret>0)                                                         {                                                                 printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);}                                                    return 0;                                            }

---

exec*能够执行系统命令，那么也能执行我们自己的命令

一个c语言程序调用一个C++程序，两个可执行代码。

#include <stdio.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <sys/wait.h>  
#include <sys/types.h>  
int main()  
{  pid_t id=fork();  if(id==0)  {printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());  execl("./otherexe","otherexe",NULL);printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);}pid_t ret=waitpid(id,NULL,0);if(ret>0){printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);}return 0;
} 

第一个参数代表要执行的文件在哪，执行谁。

第二个参数代表怎么执行。

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

以上两个都可以跑，结果一样。

命令行带"./"是因为要告诉bash可执行程序在哪。

但是execl的第一个参数已经说明了可执行程序的路径，所以第二个参数可以不用写"./"了。

---

用c语言调用其他的语言

c语言调用sh

test.sh

#!usr/bin/bashfunction myfun()
{cnt=1while [ $cnt -le 10 ]doecho "Hello $cnt"let cnt++done
}
echo "Hello Linux!"
echo "Hello Linux!"
echo "Hello Linux!"ls -a -lmyfun     

所有的脚本语言都以"#!"开头，后面跟着脚本语言对应的解释器。

脚本语言并不是脚本在跑，而是由解释器来解释式执行的。

mycommand.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{pid_t id=fork();if(id==0){printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());execl("/usr/bin/bash","bash","test.sh",NULL);printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);                                                    }                                                               pid_t ret=waitpid(id,NULL,0);                                   if(ret>0)                                                       {                                                                   printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);}                                                               return 0;                                                       
}                                                                   

在命令行上，要执行的可执行文件不是脚本文件，而是脚本文件的解释器。

---

用c语言调用py

  1 #!/usr/bin/python3                                                              2                                                                                 3 print("Hello py!")      

mycommand.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{pid_t id=fork();if(id==0){printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());execl("/usr/bin/python3","python3","test.py",NULL);printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);                                                }                                                           pid_t ret=waitpid(id,NULL,0);                               if(ret>0)                                                   {                                                                   printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);}                                                           return 0;                                                   
}

---

无论是可执行程序，还是脚本语言，为什么能跨语言调用？

所有语言运行起来，本质都是进程！

只要是进程就可以被调用。

基本上所有的语言都有execl等的接口。

补充：

C++文件名后缀包括： .cc .cpp .cxx

otherex.cc

#include <iostream>
using namespace std;
int main()
{cout<<"Hello C++ Linux!"<<endl;cout<<"Hello C++ Linux!"<<endl;cout<<"Hello C++ Linux!"<<endl;return 0;
}

makefile

mycommand:mycommand.cgcc -o $@ $^ -std=c99
otherexe:otherexe.cppg++ -o $@ $^ -std=c++11
.PHONY:clean                     
clean:                       rm -rf mycommand otherexe

为什么只形成mycommand呢

在makefile中，自上往下的扫描，遇到的第一个文件就是目标文件，所以只执行目标文件的方法。

哪个目标文件在前就执行哪个依赖方法。

.PHONY:all
all:otherexe mycommandmycommand:mycommand.c      gcc -o $@ $^ -std=c99  
otherexe:otherexe.cpp      g++ -o $@ $^ -std=c++11  
.PHONY:clean                 
clean:                       rm -rf mycommand otherexe

在makefile自顶向下扫描时，遇到的第一个目标文件是伪目标all

all又依赖于otherexe和mycommand，

所以就先形成otherexe，再形成mycommand

all没有依赖方法，所以关系推导完之后，就不执行了。

---

execle:

我们可以在我们编写的代码里获取命令行参数和环境变量！

可以验证mycommand给otherexe传入命令行参数和环境变量

mycommand一个程序形成的环境变量如何导给另一个程序otherexe？

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h> 
int main(){pid_t id=fork();if(id==0){printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());char*const myargv[]={       "otherexe","-a","-b","-c",NULL};execv("./otherexe",myargv);printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);}pid_t ret=waitpid(id,NULL,0);if(ret>0){printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);}return 0;}

会把myargv作为参数传递给otherexe，otherexe就可以拿到对应的参数了。

  #include <iostream>using namespace std;int main(int argc,char *argv[]){cout<<argv[0]<<" begin running"<<endl;for(int i=0;argv[i];i++){cout<<i<<" : "<<argv[i]<<endl;}cout<<argv[0]<<" stop running"<<endl;return 0;                           }     

所以，exec所对应的参数就传入了。

  #include <iostream>using namespace std;int main(int argc,char *argv[],char*env[]){cout<<argv[0]<<" begin running"<<endl;cout<<"这是命令行参数："<<endl;for(int i=0;argv[i];i++){cout<<i<<" : "<<argv[i]<<endl;}cout<<"这是环境变量："<<endl;for(int i=0;env[i];i++){cout<<i<<" : "<<env[i]<<endl;}cout<<argv[0]<<" stop running"<<endl;return 0;}

命令行参数和环境变量都有！

在默认情况下，尽管没有传环境变量，但是子进程自动获取（继承）环境变量。

环境变量也是数据，在地址空间里是有命令行参数和环境变量列表的，

创建子进程的时候，环境变量就已经被子进程继承下去了。

extern char**environ 这个第三方变量直接指向进程的环境变量信息。

这个变量已经被父进程初始化，指向自己的环境变量表了。

这个变量拷贝的时候，也被子进程继承下去了。

不通过传参方式，在程序地址空间里也可以获得环境变量和命令行参数。

因为子进程会继承父进程的地址空间、页表等，所以命令行参数和环境变量就可以被继承。

程序替换只替换了代码和数据，环境变量信息不会被替换！

---

想给子进程传递环境变量，如何传递？

1.新增环境变量

给父进程导入新的环境变量，就会被子进程继承下去。

在Shell里新增环境变量

环境变量信息不随着进程替换而被替换，只会随着系统一路的被子进程获取。

bash -> mycommand ->otherexe 环境变量具有全局属性。

但如果只想在mycommand父进程中新增环境变量导入传递给otherexe呢？

putenv 添加一个环境变量 添加到调用进程的上下文。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h> 
int main(){putenv("MY_ENV=6666666666666");pid_t id=fork();if(id==0){printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());           char*const myargv[]={"otherexe","-a","-b","-c",NULL};execv("./otherexe",myargv);printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);}pid_t ret=waitpid(id,NULL,0);if(ret>0){printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);}return 0;
}

putenv可以导入属于自己和自己的子进程的环境变量。

所以mycommand导入新环境变量与bash（父进程）没关系！

如果非得传

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h> 
int main(){extern char** environ;pid_t id=fork();if(id==0){printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());           execle("./otherexe","otherexe","-a","-w",NULL,environ);printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);}pid_t ret=waitpid(id,NULL,0);if(ret>0){printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);}return 0;}

可以把环境变量交给子进程，那也可以把整型、字符串交给子进程。

可以通过子进程继承父进程的数据，并且不修改，这样就是共享的方式去传，

也可以通过环境变量去传。

2.彻底替换

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h> 
int main()
{pid_t id=fork();if(id==0){          printf("before,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());char *const myenv[]={"MYVAL=123666","MYlll=567999",NULL};execle("./otherexe","otherexe","-a","-w",NULL,myenv);printf("After,I am a process,pid:%d,ppid:%d\n",getpid(),getppid());exit(0);}pid_t ret=waitpid(id,NULL,0);if(ret>0){printf("wait successfully,father pid:%d,ret:%d\n",getpid(),ret);}return 0;}

当我们传入我们自己编写的环境变量时，采用的策略是覆盖，而不是追加。

如果不传入环境变量，子进程在被调用的时候，操作系统会把父进程的环境变量传给子进程。

如果有写相应的参数，操作系统就传对应的参数，如果没，就使用系统默认的。

---

事实上,只有execve是真正的系统调用,其它六个函数最终都调用 execve来完成程序替换。

所以execve在man手册 第2节–系统调用，

其它函数在man手册第3节–库函数。

区别：只是传参的不同。

这些函数之间的关系如下图所示。

下图exec函数族 一个完整的例子: