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进程控制—进程程序替换，到这里就介绍结束了，本篇文章对你由帮助的话，期待大佬们的三连，你们的支持是我最大的动力！
文章有写的不足或是错误的地方，欢迎评论或私信指出，我会在第一时间改正
