Linux(fork+exec创建进程)

本文介绍: ece cl,execlp,execle,exec v,exec v p //库函数 exec ve //系统调用//path name:新替换的程序的路径+名字//ar g :传给新程序主函数的第一个参数，一般为程序的名字//ar g 后面是剩余参数列表，参数个数可变，必须以空指针作为最后一个参数//系统调用//前五个是库函数,最后一个是系统调用,所以本质上上面5个都是通过第六个系统调用实现的也就是说,上面5个都是调用的exec ve,不过都是。

1.进程 创建

内核设计与实现43页;

执行了3次ps -f ,ps -f的父进程的ID(PPID)都是一样的,即bash.

实际上Linux上这个bash就是不断的复制自身,然后把复制出来的用exec 替换成想要执行的程序(比如ps);

运行 ps,发现 ps是bash的一个子进程;原因就是bash把自己复制一份,然后替换成ps;

替换,这里就体现了写时拷贝的意义,如果全部都要替换,那么最开始的复制是没有意义的;
注意,用了写时拷贝就只复制了几个页表的映射,内容还没有复制,然后执行了替换 exec.

在Linux新的进程的产生过程(进程创建):

fork:复制进程
exec 系列:将当前进程替换为另外一个进程.

2.进程替换 exe c 系列 介绍

ece cl,exe clp,exe cle,exe cv,exe cv p //库函数

execve //系统调用

例1:execl

wh ic h ps

#include <std io.h&g t;
#include <std lib.h>
#include <uni std.h>
int main()
{
printf(“main pid=%dn”,get pid());
execl(“/usr/bin/ps“,”ps“,”-f”,(char *)0);
exit(0);
}

注意,就是原来的程序换成了ps程序,但是PCB没有改变,但是PCB里面的有些值被修改了,比如pc b中程序的名字换成了新进程的名字;

思考1,新的进程从哪里执行呢?

新的进程从主函数的第一行开始执行,也就是ps程序的主函数的第一行代码开始执行,这个和fork 方法不一样,fork 返回以后,从fork所在位置开始执行;
所以可以直接在execl下面打印一个失败,如果成功就根本不会执行到这里;
printf(“execl errorn”);

思考2:如果将execl里面的第二个参数改为”abc“,程序还能否执行?

可以正常执行,只是程序命令改为了abc;

execl(“/usr/bin/ps“,”abc“,”-f”,(char *)0);

思考3:如果将execl里面的第一个参数改为”abc“,程序还能否执行?

只要execl第一个参数不出错,第一个参数如果出错了,你就找不到这个程序了; 那么就运行不成功了;比如:

execl(“/usr/bin/abc“,”ps“,”-f”,(char *)0);

一定要在exec替换函数之后写:

printf(“exec error!n”);

失败了才运行到这一句.

例2:execlp

execlp(“ps“,”ps”,”-f”,(char *)0);

只给文件名,不需要给文件路径,因为它可以去环境变量PATH所指的位置去搜索;

注意,第一句,虽然有两个ps,但是不能省,第一个代表我们启动的是ps(去环境变量下搜索),第二个代表的是替换的程序也就是新程序的名字;

例3:execle

和execl一样的参数,只是多了最后一个环境变量.

//int main(int ar gc,char *arg v[],char *envp[])
execle(“/usr/bin/ps”,”ps”,”-f”,(char *)0,envp);

思考:如何使用自己的环境变量呢?

例4:execv

//int m ain(int argc,char *arg v[],char *envp[])

char *myargv[]={“ps”,”-f”,0};
execv(“/usr/bin/ps”,myargv);

例5:execvp

第一个参数只要文件名,不要路径;

//int m ain(int argc,char *argv[],char *envp[])

char *myargv[]={“ps”,”-f”,0};
execvp(“ps”,myargv);

看帮助手册,execvpe是GNU的扩展,不通用,所以我们这里不做介绍.

例6:execve

int execve(const char * path, char* const argv[],char* const envp[]); //系统调用

代码如下:

//int main(int argc,char *argv[],char *envp[])

char *myargv[]={“ps”,”-f”,0};
execve(“/usr/bin/ps”,myargv,envp);

3.总结:

//pathname:新替换的程序的路径+名字
//arg :传给新程序主函数的第一个参数，一般为程序的名字
//arg 后面是剩余参数列表，参数个数可变，必须以空指针作为最后一个参数
int execl(const char* pathname, const char * arg,…);
int execlp(const char* file, const char * arg,…);
int execle(const char* pathname, const char * arg,…,char* const envp[]);
int execv(const char * pathname, char* const argv[]);
int execvp(const char * file, char* const argv[]);
int execve(const char * pathname, char* const argv[],char* const envp[]); //系统调用

//前五个是库函数,最后一个是系统调用,所以本质上上面5个都是通过第六个系统调用实现的

也就是说,上面5个都是调用的execve,不过都是把参数放进数组,然后把数组传递给这个系统调用execve;
也就是说,这些方法没有本质区别;
也就是说,本质上只有一个替换方法,就是execve;

注意,写一个(char *)NULL也是可以的;

助记:
l(list) 参数地址列表,以空指针结尾
v(vector) 存放各个参数地址的指针数组的地址
p(path) 按PATH环境变量指定的目录搜索可执行文件
e(enviroment) 存放环境变量字符地址的指针数组的地址

4.环境 变量也可以自己添加

#include <std io.h>
#include <std lib.h>
#include <uni std.h>
#include <assert.h>
#include <assert.h>
int main()
{
//存放传给新程序主函数的参数
char * myargv[]={“ps”,”-f”,(char *)0};
//存放传给新程序主函数的环境变量
char *myenvp[]={“MYSTR=hello“,”VAL=100”,(char *)0};
printf(“main pid=%dn”,get pid());
//excel执行成功不返回,失败返回错误码
execve(“/bin/ps”,myargv,myenvp);
perror(“execve errorn”);
exit(0);
}

5.进程替换的应用

写一个程序main.c,运行起来之后替换执行test程序(test打印参数内容)

//test.c
#include <std io.h>
#include <std lib.h>
#include <unistd.h>

int main(int argc,char *argv[])
{
printf(“test start and test_pid=%dn”,get pid());

int i=0;
for(;i<argc;i++)
{
printf(“argv[%d]=%sn”,i,argv[i]);
}

printf(“test endn”);
exit(0);
}

//main.c
#include <std io.h>
#include <std lib.h>
#include <unistd.h>

int main(int argc,char *argv[],char *envp[])
{
printf(“main start and mainpid=%dn”,get pid());

execl(“./test“,”./test“,”a”,”b“,”c”,(char *)0);
perror(“execl error”);执行结果如下:

printf(“main endn”);//执行了之后替换了程序,这一句不会被执行到;
exit(0);
}

6.进程创建 示例

1).创建ps命令-execl的使用(结合fork 1)

exec系列单独是能使用的,但是没有多大意义.通常我们会结合fork一起使用;

fork+exec()是Linux上创建新进程的方式;

#include<std io.h>
#include<stdlib.h>
#include<unistd.h>
#include<assert.h>
#include<wait.h>

int main()
{
printf(“main pid=%d,ppid=%dn”,getpid(),getppid());
pid_t pid=fork();
assert(pid!=-1);

if(pid==0)
{
printf(“child pid=%d,ppid=%dn”,getpid(),getppid());
// execl(“/bin/ps”,”-f”,(char *)0);//省略了ps也对,但是最好写成上面的;
execl(“/usr/bin/ps”,”ps”,”-f”,NULL);
printf(“execl error”);
exit(0);
}

wait(NULL);

exit(0);
}

比如我们在子进程退出前:

printf(“child end!n”);

我们发现执行不到这一句,因为去执行ps去了,然后从ps退出进程了,除非execl执行失败.

2.fork和exec联合使用创建一个全新的进程(结合 fork2 )

当前主程序main通过fork复制产生一个子进程,子进程用新程序”newmain”替换自身; (newmain:打印参数内容和环境变量)

//main.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <wait.h>
int main(int argc,char *argv[],char *envp[])
{
printf(“main pid=%dn”,getpid());
pid_t pid=fork();
assert(pid!=-1);
if(pid==0)
{
char *myargv[]={“newmain”,”hello“,”abc“,”123”,(char *)0};
//char *myenvp[]={“MYSTR=hello“,”VAL=100”,(char *)0};
execve(“./newmain”,myargv,envp);
perror(“execl error”);
exit(0);
}
wait(NULL);
printf(“main overn”);
exit(0);
}

//newmain.c
#include <stdio.h>
#include <stdli b.h>
#include <unistd.h>

int main(int argc,char *argv[],char *envp[])
{
printf(“newmain pid=%dn”,getpid());
int i=0;
printf(“argc=%dn”,argc);

for(;i<argc;i++)
{
printf(“argv[%d]=%sn”,i,argv[i]);
}
for(i=0;envp[i]!=NULL;i++)
{
printf(“envp[%d]=%sn”,i,envp[i]);
}
exit(0);
}