【Linux】历程程序更换

思维导图

学习目标

       学习历程更换的原理，掌握一些exec*函数的用法。
一、历程的程序更换的原理

       用fork创建子历程后，子历程实行的是和父历程雷同的程序（但有可能实行不同的代码分支），若想让子历程实行另一个程序，每每需要调用一种exec函数。
       当历程调用一种exec函数时，该历程的用户空间代码和数据完全被新程序更换，并重新程序的启动例程开始实行。这种更换类似于数据修改时的写时拷贝，不会将代码直接覆盖影响到父历程的后续代码。

       历程 = 内核数据结构 + 代码 + 数据，代码和数据是要被更换的，而内核数据结构根本不变，没有释放结构，没有创建新的历程。 我们可以通过代码来查验是否创建了子历程？

1. #include <stdio.h>
2. #include <unistd.h>
3. #include <stdlib.h>
4. #include <sys/wait.h>
5. #include <sys/types.h>
7. int main()
8. {
9.   printf("taskexec.....begin\n");
10.   pid_t id = fork();
12.   if(id == 0)
13.   {
14.     printf("child pid : %d\n", getpid());
15.     sleep(2);
16.     execvpe("./pragma", argv, environ);
17.     exit(1);
18.   }
19.   int status = 0;
20.   pid_t rid = waitpid(id, &status, 0);
21.   if(rid > 0)
22.   {
23.     if(WIFEXITED(status))
24.     {
25.       printf("child quit success, child exit code: %d\n", WEXITSTATUS(status));
26.     }
27.     else{
28.       printf("child quit failed\n");
29.     }
30.   }
31.   printf("taskexec.....end\n");
33.   return 0;
34. }

复制代码

       站在被更换的历程的角度来看，本质上就是这个程序被加载到内存中去的。怎么将程序加载到内存中？？在Linux体系中，exec*函数类似于加载函数。
       为什么我们要先将程序加载到内存中呢？？因为冯诺依曼体系结构要求，程序先放入内存中去，CPU只会去内存去探求数据和代码。
二、更换函数

这些函数不是体系调用，而是一些封装函数。真正的体系调用函数是execve函数：

2.1 exec*系列函数

       加载过程中需要操作体系进行，这种函数底层包括体系调用，因为要将程序加载到内存中。exec*系列函数实行完毕之后，后续的代码不见是正常的，因为代码被更换了，假如不想让后续代码被更换，我们可以利用多历程，让子历程区完成一些代码覆盖。exec*函数的返回值不消关心，只要更换成功，就不会向后走，反之，假如没有更换成功，就一定往后走。
2.2 利用多历程来进行函数更换

       利用子历程进行函数更换操作，防止父历程的后续代码被覆盖，改成多历程版。创建子历程，让子历程自己去更换，父历程进行期待操作：可以让子历程实行父历程的一份代码，大概让子历程实行一份新的代码。创建子历程是为了让子历程去完成工作，在子历程中程序更换会发生写时拷贝。

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <sys/wait.h>
4. #include <sys/types.h>
5. #include <unistd.h>
7. int main()
8. {
9.   printf("myprocess begin.....\n");
11.   pid_t id = fork();
12.   if(id == 0)
13.   {
14.     sleep(2);
15.     execl("/usr/bin/ls", "ls", "-a", "-l", NULL);
16.     exit(1);
17.   }
18.   int status = 0;
19.   pid_t rid = waitpid(id, &status, 0);
20.   if(rid > 0)
21.   {
22.     printf("father wait success, child exit code: %d\n", WEXITSTATUS(status));
23.   }
24.   printf("myprocess end.....\n");
25.   return 0;
26. }

复制代码

2.3 一系列exec*函数（返回值不重要）

2.3.1 execl函数

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

复制代码

l(list)：列表。 列表来记录命令行中实行的命令。
execl函数的参数：第一个参数path：我们实行的程序需要带路径（怎么找到程序，用户要告诉函数）， 后面几个参数是可变参数，在命令行中怎么实行，我们就怎么进行传参。
总结：第一个参数的含义是帮我们怎么找到实行的程序，后面几个参数的含义是我们想怎么进行实行程序。
代码：

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <sys/wait.h>
4. #include <sys/types.h>
5. #include <unistd.h>
7. int main()
8. {
9.   printf("myprocess begin.....\n");
10.   execl("/usr/bin/ls", "ls", "-a", "-l", NULL);
11.   printf("myprocess end.....\n");
12.   return 0;
13. }

复制代码

这种函数不止能更换一些Linux指令，还能更换我们所写的程序：

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <sys/wait.h>
4. #include <sys/types.h>
5. #include <unistd.h>
7. int main()
8. {
9.   printf("myprocess begin.....\n");
10.   pid_t id = fork();
11.   if(id == 0)
12.   {
13.     sleep(2);
14.     execl("./test", "test", NULL);
15.     exit(1);
16.   }
17.   int status = 0;
18.   pid_t rid = waitpid(id, &status, 0);
19.   if(rid > 0)
20.   {
21.     printf("father wait success, child exit code: %d\n", WEXITSTATUS(status));
22.   }
23.   printf("myprocess end.....\n");
24.   return 0;
25. }

复制代码

1. #include <iostream>
2. #include <algorithm>
3. #include <unistd.h>
4. #include <sys/types.h>
6. using namespace std;
8. int main()
9. {
10.   cout << "C++: pid: %d\n" << getpid() << endl;
11.   cout << "C++: pid: %d\n" << getpid() << endl;
12.   cout << "C++: pid: %d\n" << getpid() << endl;
13.   return 0;
14. }

复制代码

2.3.2 execv函数 

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

复制代码

v(vector)：指针数组，将命令全部存储在数组中，再将数组传递给execv函数。
execv函数的参数：由原来的可变参数变成了指针数组。
代码：

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <sys/wait.h>
4. #include <sys/types.h>
5. #include <unistd.h>
7. int main()
8. {
9.   printf("myprocess begin.....\n");
10.   char* argv[] = {
11.     "ls",
12.     "-a",
13.     "-l",
14.     NULL
15.   };
17.   pid_t id = fork();
18.   if(id == 0)
19.   {
20.     sleep(2);
21.     //execl("/usr/bin/ls", "ls", "-a", "-l", NULL);
22.     execv("/usr/bin/ls", argv);
23.     exit(1);
24.   }
25.   int status = 0;
26.   pid_t rid = waitpid(id, &status, 0);
27.   if(rid > 0)
28.   {
29.     printf("father wait success, child exit code: %d\n", WEXITSTATUS(status));
30.   }
31.   printf("myprocess end.....\n");
32.   return 0;
33. }

复制代码

2.3.3 execvp函数

       v(vector)：指针数组，将命令全部存储在数组中，再将数组传递给execv函数。p(path)：路径，用户可以不传要实行的文件的路径（但是文件名要传递），直接告诉exec*，我要实行谁就可以。p：查找这个程序，体系会自动在情况变量PATH中进行查找。

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <sys/wait.h>
4. #include <sys/types.h>
5. #include <unistd.h>
7. int main()
8. {
9.   printf("myprocess begin.....\n");
10.   char* argv[] = {
11.     "ls",
12.     "-a",
13.     "-l",
14.     NULL
15.   };
17.   pid_t id = fork();
18.   if(id == 0)
19.   {
20.     sleep(2);
21.     execvp("ls", argv);
22.     exit(1);
23.   }
24.   int status = 0;
25.   pid_t rid = waitpid(id, &status, 0);
26.   if(rid > 0)
27.   {
28.     printf("father wait success, child exit code: %d\n", WEXITSTATUS(status));
29.   }
30.   printf("myprocess end.....\n");
31.   return 0;
32. }

复制代码

2.3.4 execvpe函数

       v(vector)：指针数组，将命令全部存储在数组中，再将数组传递给execv函数。p(path)：路径，用户可以不传要实行的文件的路径（但是文件名要传递），直接告诉exec*，我要实行谁就可以。p：查找这个程序，体系会自动在情况变量PATH中进行查找。e(environment)：情况变量。

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <sys/wait.h>
4. #include <sys/types.h>
5. #include <unistd.h>
7. int main()
8. {
9.   printf("myprocess begin.....\n");
10.   char* argv[] = {
11.     "test",
12.     NULL
13.   };
15.   char* engv[] = {
16.     "haha=1111111",
17.     "hehe=2222222"
18.   };
20.   pid_t id = fork();
21.   if(id == 0)
22.   {
23.     sleep(2);
24.     execvpe("./test", argv, engv);
25.     exit(1);
26.   }
27.   int status = 0;
28.   pid_t rid = waitpid(id, &status, 0);
29.   if(rid > 0)
30.   {
31.     printf("father wait success, child exit code: %d\n", WEXITSTATUS(status));
32.   }
33.   printf("myprocess end.....\n");
34.   return 0;
35. }

复制代码

1. #include <iostream>
2. #include <algorithm>
3. #include <unistd.h>
4. #include <sys/types.h>
6. using namespace std;
8. int main(int argc, char* argv[], char* engv[])
9. {
10.   int i = 0;
11.   for(i = 0; argv[i]; i++)
12.   {
13.     cout << argv[i] << endl;
14.   }
15.   for(i = 0; engv[i]; i++)
16.   {
17.     cout << engv[i] << endl;
18.   }
19.   cout << "C++: pid: %d\n" << getpid() << endl;
20.   cout << "C++: pid: %d\n" << getpid() << endl;
21.   cout << "C++: pid: %d\n" << getpid() << endl;
22.   return 0;
23. }

复制代码

       所以，在一个程序中的情况变量和可实行参数是父历程给予的，我们可以通过extern来观察bash历程给予的情况变量和参数部门。

1. extern char** environ; // 获取父进程的环境变量

复制代码

    

参数情况变量有三种情况：

• 用新的情况变量整体更换
  
• 用老的情况便令
  
• 只增加某一个情况变量：putenv函数 
  

putenv函数：

1. #include <stdlib.h>
2. int putenv(char* string);

复制代码

       putenv函数添加的情况变量会被添加在当前历程的情况变量表中。 

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <sys/wait.h>
4. #include <sys/types.h>
5. #include <unistd.h>
7. int main()
8. {
9.   printf("myprocess begin.....\n");
10.   char* argv[] = {
11.     "test",
12.     NULL
13.   };
15.   char* engv[] = {
16.     "haha=1111111",
17.     "hehe=2222222"
18.   };
19.   putenv("papa=333333");
20.   pid_t id = fork();
21.   if(id == 0)
22.   {
23.     extern char** environ;
24.     sleep(2);
25.     execvpe("./test", argv, environ);
26.     exit(1);
27.   }
28.   int status = 0;
29.   pid_t rid = waitpid(id, &status, 0);
30.   if(rid > 0)
31.   {
32.     printf("father wait success, child exit code: %d\n", WEXITSTATUS(status));
33.   }
34.   printf("myprocess end.....\n");
35.   return 0;
36. }

复制代码

三、函数解释

• 这些函数假如调用成功则加载新的程序从启动代码开始实行，不在返回
  
• 假如调用失败返回-1
  
• exec函数只有堕落的返回值，而没有成功的返回值
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。