Unix环境高级编程(六)进程控制

本章介绍Unix的进程控制，包括进程创建，执行程序和进程终止，进程的属性，exec函数系列，system函数，进程会计机制。

1、进程标识符

　　每一个进程都有一个非负整数标识的唯一进程ID。ID为0表示调度进程，即交换进程，是内核的一部分，也称为系统进程，不执行任何磁盘操作。ID为1的进程为init进程，init进程不会终止，他是一个普通的用户进程，需要超级用户特权运行。获取标识符函数如下：

#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void);  　　//调用进程的进程ID
pid_t getppid(void);     //调用进程的父进程ID
gid_t getgid(void);       //调用进程的实际组ID
gid_t getegid(void);    //调用进程的有效组ID
uid_t getuid(void);     //调用进程的实际用户ID
uid_t geteuid(void);   //调用进程的有效用户ID

2、fork函数

　　一个现有的进程可以调用fork函数创建一个新进程。函数原型为：pid_t
fork(void)。有fork创建的新进程称为子进程，fork函数调用一次返回两次。子进程的返回值为0，父进程的返回值为新子进程的ID。子进程和父进程举行执行fork调用后的指令，子进程是父进程的副本。子进程获得父进程的数据空间、栈和队的副本，父子进程不共享这些存储空间部分，共享正文段。子进程相当于父进程克隆了一份自己。 创建新进程成功后，系统中出现两个基本完全相同的进程，这两个进程执行没有固定的先后顺序，哪个进程先执行要看系统的进程调度策略。

　 fork出错可能有两种原因：
    1）当前的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN。
    2）系统内存不足，这时errno的值被设置为ENOMEM。

注意的是：父进程设置的文件锁不会被子进程继承。

写个程序，创建一个子进程，在子进程中改变变量的值，然后父子进程同时输出变量的值，看看有什么变化，同时输出子进程的标识符信息。程序如下：

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <string.h>
 4 #include <sys/types.h>
 5 #include <unistd.h>
 6 #include <errno.h>
 7 //全局变量
 8 int global = 100;
 9 char buf[]="a write to stdout.\n";
10
11 int main()
12 {
13     int     var;
14     pid_t   pid;
15
16     var = 90;
17     write(STDOUT_FILENO,buf,sizeof(buf)-1);
18     //创建一个子进程
19     pid = fork();
20     if(pid == -1)      //出错
21     {
22         perror("fork() error");
23         exit(-1);
24     }
25     if(pid == 0)     //子进程
26     {
27         printf("This is child process.\n");
28         printf("Child process id is:%d\n",getpid());
29         printf("Father process id is:%d\n",getppid());
30         //子进程修改数据
31         global++;
32         var++;
33     }
34     if(pid > 0)   //父进程
35       sleep(3);  //等待子进程先执行
36     printf("pid = %d,ppid =%d,global=%d,var=%d\n",getpid(),getppid(),global,var);
37     return 0;
38 }

 程序执行结果如下：

从结果可以看出子进程拥有自己的数据空间，不与父进程共享数据空间。

　　vfork函数的调用序列和返回值与fork相同，但是vfork并不将父进程的地址空间完全复制到子进程中，在调用exec和exit之前在父进程的空间中运行。vfork保证子进程先运行，在它调用exec或exit之后父进程才可能被调度运行。

　　进程终止最后都会执行内核中的同一段代码，为相应的进程关闭所有打开描述符，释放它所使用的存储器等。子进程可以通过exit函数通知父进程是如何终止的，父进程调用wait或waitpid函数可以获取终止状态。子进程是在父进程调用fork后产生的，如果父进程在子进程之前终止，则将子进程的父进程改变为init进程，保证每一个进程都有一个父进程。一个已经终止，但其父进程尚没有对其进行善后处理的进程称为僵死进程（zombie）。由init进程领养的子进程不会变成僵死进程，因为init进程在子进程终止的时候会调用一个wait函数取得子进程的终止状态。

　　当一个进程正常或者异常终止的时，内核就像其父进程发送SIGCHLD信号。调用wait和waitpid函数可能发生的情况：（1）如果所有子进程都还在运行，则阻塞；（2）如果一个子进程已经终止，正等待父进程获取进程终止状态，则取得孩子的终止状态立刻返回；（3）若果没有任何子进程，则立即出错返回。如果在任意时刻调用wait，则进程可能会阻塞。

#include <sys/types.h>
#include <sys/wait.h>

pid_t wait(int *status);   //在一个子进程终止前，wait使调用者阻塞

pid_t waitpid(pid_t pid, int *status, int options); //可以使调用者不阻塞

#include <sys/types.h>
#include <sys/resource.h>
#include <sys/wait.h>
pid_t wait3(int *status, int options,struct rusage *rusage);
pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage);
写个程序，子进程给出退出状态，父进程通过wait和waitpid获取退出状态。程序如下：

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <unistd.h>
 4 #include <sys/wait.h>
 5 #include <sys/types.h>
 6 #include <signal.h>
 7
 8 int main()
 9 {
10     pid_t pid;
11     int status;
12     if((pid = fork()) == -1)
13     {
14         perror("fork() error");
15         exit(-1);
16     }
17     if(pid == 0)
18       exit(0);
19     if(wait(&status) == pid)
20             printf("child normal exit,exit status=%d\n",WEXITSTATUS(status));
21     if((pid = fork()) == -1)
22     {
23         perror("fork() error");
24         exit(-1);
25     }
26     if(pid == 0)
27         abort();
28     if(waitpid(pid,&status,0) == pid)
29             printf("child abnormal termination,signal number=%d\n",WTERMSIG(status));
30 }

程序执行结果如下：

waitpid函数中的pid参数取值情况：
pid=-1  　等待任一子进程，此时相当于wait
pid>0     等待期进程ID与pid相等的子进程
pid==0    等待期组ID等于调用进程组ID的任一个子进程
pid<-1    等待其组ID等于pid绝对值的任一子进程

另外提供了一种避免僵死进程的方法：调用fork两次。

　　exec函数，用fork函数创建子进程后，子进程往往要调用一种exec函数以执行另外一个程序。当调用exec函数时，该进程执行的程序完全替换为新进程，exec函数不新建进程，只是用一个全新的程序替换了当前的正文、数据、堆和栈段。执行完之后，进程ID不会改变。在进程间通信的时候，经常需要调用exec函数启动另外一个例程。函数原型如下：

#include <unistd.h>
extern char **environ;
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 execve(const char *file, char *const argv[],char *const envp[]);

其中l表示列表(list)，v标识矢量(vector)。execl、execlp、execle中每个命令行参数都是一个单独参数，这种参数以空指针结尾。execv、execvp、execve命令行参数是一个指针数组。e标识环境变量，传递参数。写个程序进行测试，程序分为两部分，exec调用的程序，exec执行程序。程序如下：

exec调用程序如下，可执行文件名称为exectest，存放在/home/anker/Programs目录下。

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3
 4 int main(int argc,char *argv[])
 5 {
 6     int         i;
 7     char        **ptr;
 8     extern char **environ;
 9
10     for(i=0;i<argc;++i)
11         printf("argv[%d]=%s\n",i,argv[i]);
12     for(ptr=environ;*ptr!=0;ptr++)
13         printf("%s\n",*ptr);
14     exit(0);
15 }

exec执行程序如下：存放在/home/anker/Programs目录下。

#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>

char *env_init[] = {"LENGTH=100","PAHT=/tmp",NULL};

int main()
{
    pid_t pid;
    char *path = "/home/anker/Programs/exectest";
    char *filename = "exectest";
    char *argv[3]= {0};
    argv[0] = "exec";
    argv[1] = "test";
    if((pid=fork()) == -1)
    {
        perror("fork() error");
        exit(-1);
    }
    else if(pid == 0)
    {
        printf("Call execle:\n");
        execle(path,argv[0],argv[1],(char*)0,env_init);
    }
    waitpid(pid,NULL,0);

    if((pid=fork()) == -1)
    {
        perror("fork() error");
        exit(-1);
    }
    else if(pid == 0)
    {
        printf("Call execve:\n");
        execve(filename,argv,env_init);
    }
    waitpid(pid,NULL,0);
    exit(0);

}

执行结果如下：

system函数，在程序中执行一个命令字符串。例如system("date > file")。函数原型如下：

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

system函数实现中调用了fork、exec和waitpid函数，因此有三种返回值。system函数实现一下，没有信号处理。程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>

int mysystem(const char * cmdstring);

int main()
{
    int status;
    status = mysystem("date");
    if(status < 0)
    {
       printf("mysystem() error.\n");
    }
    status = mysystem("who");
    if(status < 0)
    {
       printf("mysystem() error.\n");
    }
    exit(0);
}

int mysystem(const char * cmdstring)
{
    pid_t  pid;
    int status;

    if(cmdstring == NULL)
        return 1;
    if((pid = fork()) == -1)
    {
        status = -1;
    }
    else if(pid == 0)   //在子进程中调用shell脚本
    {
        execl("/bin/sh","sh","-c",cmdstring,(char *)0);
        _exit(127);
    }
    else
    {
        while(waitpid(pid,&status,0) < 0)
        {
            if(errno != EINTR)
            {
                status = -1;
                break;
            }
        }
    }
    return status;
}

程序执行结果如下：

system函数可以设置用户的ID，这是一个安全漏洞。

进程会计：启用后，每当进程结束时候内核就写一个会计记录，包括命令名、所使用的CPU时间总量、用户ID和组ID、启动时间等。accton命令启动会计处理，会计记录写到指定的文件中，Linux中位于/var/account/ pacct。会计记录结构定义在<sys/acct.h>头文件中。

#define ACCT_COMM 16

typedef u_int16_t comp_t;

struct acct {
    char ac_flag;           /* Accounting flags */
    u_int16_t ac_uid;       /* Accounting user ID */
    u_int16_t ac_gid;       /* Accounting group ID */
    u_int16_t ac_tty;       /* Controlling terminal */
    u_int32_t ac_btime;     /* Process creation time(seconds since the Epoch) */
    comp_t    ac_utime;     /* User CPU time */
    comp_t    ac_stime;     /* System CPU time */
    comp_t    ac_etime;     /* Elapsed time */
    comp_t    ac_mem;       /* Average memory usage (kB) */
    comp_t    ac_io;        /* Characters transferred (unused) */
    comp_t    ac_rw;        /* Blocks read or written (unused) */
    comp_t    ac_minflt;    /* Minor page faults */
    comp_t    ac_majflt;    /* Major page faults */
    comp_t    ac_swaps;     /* Number of swaps (unused) */
    u_int32_t ac_exitcode;  /* Process termination status(see wait(2)) */
    char      ac_comm[ACCT_COMM+1];/* Command name (basename of last executed command; null-terminated) */
    char      ac_pad[X];    /* padding bytes */
};
用户标识，用getlogin函数获取用户的登录名。函数原型如下：char *getlogin(void)。

进程时间：墙上时钟时间、用户CPU时间和系统CPU时间。任一个进程都可以调用times函数获取它自己及已终止子进程时间。进程时间操作函数及结构如下：

#include <sys/times.h>

clock_t times(struct tms *buf);

struct tms {
    clock_t tms_utime;  /* user time */
    clock_t tms_stime;  /* system time */
    clock_t tms_cutime; /* user time of children */
    clock_t tms_cstime; /* system time of children */
};

总结：通过本章的学习。完全的了解Unix的进程控制，掌握了fork、exec簇、wait和waitpid进程控制函数。另外学习了system函数和进程会计。了解了解释器文件及其工作方式，用户标识和进程时间。