进程相关的系统调用

进程创建

fork&vfork

fork 与 vfork 同样都是创建子进程,但是注意两者的区别:

  • fork ():子进程拷贝父进程的 数据段,代码段
  • vfork ():子进程与父进程 共享数据段
  • fork ():父子进程的 执行次序不确定
  • vfork (): 保证子进程先运行 ,在调用 exec 或 exit 之前与父进程数据是共享的,在它调用 exec 或 exit 之后父进程才可能被调度运行
  • vfork ():保证子进程先运行,在她调用 exec 或 exit 之后父进程才可能被调度运行。 如果在调用这两个函数之前子进程依赖于父进程的进一步动作,则会导致死锁
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int g_val = 100;

int main(int argc, char *argv []){
pid_t pid = vfork ();
if(pid == 0){
sleep (5);
g_val = 200;
printf("% d\n",g_val);
exit(0);
}else{
printf("% d\n",g_val);
}

return 0;
}

mark

可以看出,vfork 出来的子进程实际上和父进程共享数据段!

进程终止

进程退出的三种状况

  • 代码运行完毕、结果正确

  • 代码运行完毕、结果不正确

  • main 函数返回

  • 调用 exit ()
  • 调用 _exit ()
  • 代码异常终止
  • 信号终止:
1
kill -9

_exit ()

1
2
3
#include <unistd.h>
void _exit (int status);
参数:status 定义了进程的终止状态,父进程通过 wait 来获取该值

exit ()

1
2
#include <stdlib.h>
void exit(int status);

exit () 最后也会调用 _exit (),只不过在调用 _exit () 之前做了些其他的事情:

  • 执行用户通过 atexit () 或者 on_exit () 定义的清理函数
  • 关闭所有打开的流,所有的缓存数据均被写入
  • 调用 _exit ()

return 退出

return 退出是一种更常见的退出,执行 等同于,因为调用 main 函数的函数会把 main 函数的返回值当做的参数

进程等待

  • 子进程退出,父进程如果不管不顾,就可能造成 僵尸进程 的问题,进而造成内存泄漏。
  • 另外,进程一旦变成僵尸状态,那就刀枪不入,kill -9 也无能为力,因为谁也没有办法杀死一个已经死去的进程。
  • 最后,父进程派给子进程的任务完成的如何,我们需要知道。子进程运行完成,结果对还是不对,或者是否正常退出。
  • 父进程通过进程等待的方式,回收子进程资源,获取子进程退出信息

wait 方法

1
2
3
4
5
6
7
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status);
返回值:
成功返回被等待进程的 pid,失败返回 < span class="number">-1
参数:
输出型参数,获取子进程退出状态,不用关心此状态则设置为 < span class="literal">NULL

waitpid 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <sys/types.h>
#include <sys/wait.h>
pid _ t waitpid ( pid _ t pid , int * status , int options ) ;
返回值:
当正常返回的时候 waitpid 返回收集到的子进程的进程 ID
如果设置了选项 wNOHANG ,而调用中 waitpid 发现没有已退出的子进程可收集,则返回 < span class="number">0
如果调用中出错,则返回一 1 ,这时 errno 会被设置成相应的值以指示错误所在;
参数:
pid : pid = -1 ,等待任一个子进程,与 wait 等效
pid >0 等待其进程 ID 与 pid 相等的子进程。
status: WIFEXITED (status) :若为正常终止子进程返回的状态,则为真。(查看进程是否是正常退出)
status: WEXITSTATUS (status) :若 WIFEXITED 非零,提取子进程退出码。(查看进程的退出码)
options :WNOHANG:若 pid 指定的子进程没有结束,则 waitpid () 函数返回 < span class="number">0,不予以等待。若正常结束,则返回该子进程的 ID

如果子进程已经退出,调用 waitwaitpid 时, wait/waitpid 会立即返回,并且释放资源,获得子进程退出信息。
如果在任意时刻调用 waitwaitpid ,子进程存在且正常运行,则进程可能阻塞。如果不存在该子进程,则立即出错返回。

mark

获取子进程 status

waitwaitpid ,都一个 status 参数,该参数是一个输出型参数,由操作系统填充。如果传递 NULL ,表示不关心子进程的退出状态信息。否则,操作系统会根据该参数,将子进程的退出信息反馈给父进程。
status 不能简单的当作整形来看待,可以当作位图来看待 ,具体细节如下图(只研究 status 低 16 比特位) :

mark

先看这样一段代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(int argc, char *argv []){
pid_t pid = fork ();
if(pid < 0){
printf("fork error");
exit(1);
}else if(pid == 0){
sleep (20);
exit(10);
}else{
int st = 0;
int ret = wait (&st);

if(ret>0 && (st & 0X7F)==0){// 正常退出
printf("child exit code: % d\n",(st>>8&0XFF));
}else if(ret > 0){// 异常退出
printf("sig code: % d\n",st&0X7F);
}
}
return 0;
}

进程阻塞式等待方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(int argc, char *argv []){
pid_t pid = fork ();
if(pid == 0){
printf("child is run, pid is % d\n", getpid ());
sleep (5);
exit(27);
}else{
int status = 0;
pid_t ret = waitpid (-1,&status,0);// 阻塞式等待 5s
printf("this is test forwait\n");
if(WIFEXITED (status) && ret == pid){
printf("wait child 5s success,child return code is % d\n",WEXITSTATUS (status));
}else{
printf("wait child failed,return .\n");
return 1;
}
}
return 0;
}

进程的非阻塞等待

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main(){

pid_t pid;
pid = fork ();
if(pid < 0){
printf("% s fork error\n", __FUNCTION__);
return 1;
}else if(pid == 0){
printf("child is run, pid is :% d\n", getpid ());
sleep (5);
exit(1);
}else{
int status = 0;
pid_t ret = 0;
do{
ret = waitpid (-1, &status, WNOHANG);// 非阻塞式等待
if(ret == 0){
printf("child is running\n");
}
sleep (1);
}while(ret == 0);
if(WIFEXITED (status) && ret == pid){
printf("wait child 5s success, child return code is :% d\n", WEXITSTATUS (status));
}else{
printf("wait child failed, return \n");
return 1;
}
}
return 0;
}

mark

进程程序替换

用 fork 创建子进程后执行的是和父进程相同的程序 (但有可能执行不同的代码分支),子进程往往要调用一种 exec 函数以执行另一个程序。当进程调用一种 exec 函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用 exec 并不创建新进程,所以调用 exec 前后该进程的 id 并未改变。

mark

替换函数

1
2
3
4
5
6
7
#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 []);
int execvpe(const char *file, char *const argv [], char *const envp []);

这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
如果调用出错则返回一 1
所以 exec 函数只有出错的返回值而没有成功的返回值。
这么多函数如何区分?

函数名 参数格式 是否带路径 是否使用当前环境变量
execl 列表 不是
execlp 列表
execle 列表 不是 不是,需自己组装环境变量
execv 数组 不是
execvp 数组
execve 数组 不是 不是,需自己组装环境变量

只有 execve 才是真正的系统调用,其它五个函数最终都是调用 execve

mark

利用前面的知识写一个 shell

shell 的运行原理其实不难,就是从标准输入读入命令和命令参数然后开启一个子进程去执行这个程序,根据程序替换的原理,我们只要使用 execve 这个系统接口去把要执行的程序的代码段和数据段进行替换,便把一个磁盘上的程序加载到了内存中,变成了进程!此时,我们自己编写的 shell 变成了该进程父进程!

mark

主要分为以下几个步骤:
1、获取命令行
2、解析命令行
3、建立一个子进程(fork)
4、子进程程序替换(execvp)
5、父进程等待子进程退出(wait)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <unistd.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

char* argv [8];
int argc = 0;

void do_parse(char *buf){
int i;
int status = 0;

for(argc=i=0;buf [i];i++){
if(!isspace(buf [i]) && status == 0){
argv [argc++] = buf+i;
status = 1;
}else if(isspace(buf [i])){
status = 0;
buf [i] = 0;
}
}
argv [argc] = NULL;
}

void do_execute(void){
pid_t pid = fork ();
switch(pid){
case -1:
perror ("fork");
exit(EXIT_FAILURE);
break;
case 0:
execvp (argv [0], argv);
perror ("execvp");
exit(EXIT_FAILURE);
default:
{
int st;
while(wait (&st) != pid);
}
}
}

int main(void){
char buf [1024] = {};
while(1){
scanf("%[^\n]%*c", buf);
do_parse (buf);
do_execute ();
}
return 0;
}

函数与进程之间的相似性能

exec/exit 就像 call/return
一个 C 程序有很多函数组成。一个函数可以调用另外一个函数,同时传递给它一些参数。被调用的函数执行一定的操作,然后返回一个值。每个函数都有他的局部变量,不同的函数通过 call/return 系统进行通信。这种通过参数和返回值在拥有私有数据的函数间通信的模式是结构化程序设计的基础。Linux 鼓励将这种应用于程序之内的模式扩展到程序之间。如下图:

一个 C 程序可以 fork/exec 另一个程序,并传给它一些参数。这个被调用的程序执行一定的操作,然后通过 exit (n) 来返回值。调用它的进程可以通过 wait (&ret) 来获取 exit 的返回值。

popen/system 和 fork 的区别

system 函数原型

1
2
#include <stdlib.h>
int system(const char *command);

system () 会调用 fork () 产生子进程,由子进程来调用 /bin/sh-c string 来执行参数 string 字符串所代表的命令,此命令执行完后随即返回原调用的进程。在调用 system () 期间 SIGCHLD 信号会被暂时搁置,SIGINTSIGQUIT 信号则会被忽略。
调用 /bin/sh 来执行参数指定的命令,/bin/sh 一般是一个软连接,指向某个具体的 shell。

实际上 system () 函数执行了三步操作:

  1. fork 一个子进程;
  2. 在子进程中调用 exec 函数去执行 command
  3. 在父进程中调用 wait 去等待子进程结束。

返回值:

  1. 如果 exec 执行成功,即 command 顺利执行,则返回 command 通过 exitreturn 的返回值。(注意 :command 顺利执行不代表执行成功,当参数中存在文件时,不论这个文件存不存在,command 都顺利执行)
  2. 如果 exec 执行失败,也即 command 没有顺利执行,比如被信号中断,或者 command 命令根本不存在, 返回 127
  3. 如果 commandNULL, 则 system 返回非 0 值.
  4. 对于 fork 失败,system () 函数返回 - 1。

popen () 函数

创建一个管道用于进程间通信,并调用 shell,因为管道被定义为单向的。所以 type 参数只能定义成只读或者只写,不能是两者同时,结果流也相应的是只读或者只写.
函数原型:

1
2
3
#include <stdio.h>
FILE *popen(const char *command, const char *type);
int pclose(FILE *stream);

函数功能:popen () 会调用 fork () 产生子进程,然后从子进程中调用 /bin/sh-c 来执行参数 command 的指令。这个进程必须由 pclose 关闭。

command 参数:
command 参数是一个字符串指针,指向的是一个以 null 结束符结尾的字符串,这个字符串包含一个 shell 命令。这个命令被送到 /bin/sh 以 -c 参数 执行,即由 shell 来执行

type 参数 也是一个指向 以 null 结束符结尾的 字符串的指针
参数 type 可使用 “r” 代表读取,“w” 代表写入。
依照此 type 值,popen () 会建立管道连到子进程的标准输出设备或标准输入设备,然后返回一个文件指针。 随后进程便可利用此文件指针来读取子进程的输出设备或是写入到子进程的标准输入设备中。

返回值:
若成功则返回文件指针,否则返回 NULL,错误原因存于 errno 中

区别

1.system 在执行期间,调用进程会一直等待 shell 命令执行完成 (waitpid),但是 popen 无需等待 shell 命令执行完成就返回了。可以理解为,system 为串行执行,popen 为并行执行。
2.popen 函数执行完毕后必须调用 pclose 来对所创建的子进程进行回收,否则会造成僵尸进程的情况。
3.popen 没有屏蔽 SIGCHLD ,如果我们在调用时屏蔽了 SIGCHLD ,如果在 popen 和 pclose 之间调用进程又创建了其他子进程并调用进程注册了 SIGCHLD 来处理子进程的回收工作,那么这个回收工作会一直阻塞到 pclose 调用。

参考:

《调研 popen/system, 理解这两个函数和 fork 的区别》
《popen/system, 理解这两个函数和 fork 的区别》