进程控制

#include <unistd.h>

/* 分别获取进程ID和父进程ID */
pid_t getpid();
pid_t getppid();

/* 分别获取进程的实际用户ID和有效用户ID */
uid_t getuid();
uid_t geteuid();

/* 分别获取进程的实际组ID和有效组ID */
gid_t getgid();
gid_t getegid();

#include <stdio.h>
#include <unistd.h>

int main()
{
    pid_t pid = getpid();
    pid_t ppid = getppid();
    printf("pid=%d, ppid=%d\n", pid, ppid);

    uid_t realUID = getuid();
    uid_t effectiveUID = geteuid();
    printf("realUID=%d, effectiveUID==%d\n", realUID, effectiveUID);

    gid_t realGID = getgid();
    gid_t effectiveGID = getegid();
    printf("realGID=%d, effectiveGID=%d\n", realGID, effectiveGID);
    return 0;
}

$ ./proc_identifier
pid=67679, ppid=51979
realUID=1000, effectiveUID==1000
realGID=1000, effectiveGID=1000

#include <unistd.h>

pid_t fork();
/* 成功：子进程返回0，父进程返回子进程ID；失败：返回-1*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

static int gVal = 1;
static char buf[] = "a write to stdout\n";
int main()
{
    pid_t pid;
    int var = 88;

    if (write(STDOUT_FILENO, buf, sizeof(buf) - 1) != sizeof(buf) - 1)
        perror("write error: ");
    printf("before fork\n");
    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
    }
    else if (pid == 0)
    {
        gVal++;
        var++;
    }
    else
    {
        sleep(2);
    }
    printf("pid=%ld, gVal=%d, var=%d\n", pid, gVal, var);
    exit(0);
}

$ ./fork_demo
a write to stdout
before fork
pid=0, gVal=2, var=89
pid=75104, gVal=1, var=88
$ ./fork_demo > temp
$ cat temp
a write to stdout
before fork
pid=0, gVal=2, var=89
before fork
pid=75106, gVal=1, var=88

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

static int gVal = 1;
int main()
{
    pid_t pid;
    int var = 88;

    printf("before fork\n");
    if ((pid = vfork()) < 0)
    {
        perror("fork error: ");
    }
    else if (pid == 0)
    {
        gVal++;
        var++;
        _exit(0);
    }
    else
    {
        sleep(2);
    }
    printf("pid=%ld, gVal=%d, var=%d\n", pid, gVal, var);
    exit(0);
}

$ ./vfork_demo
before fork
pid=83780, gVal=2, var=89

#include <unistd.h>
extern char **environ;
int execl(const char* pathname, const char *arg, ... /* char* NULL */);
int execlp(const char* file, const char* arg, ... /* char* NULL */);
int execle(const char* pathname, const char* arg, ... /* char* NULL, char *const envp[] */);

int execv(const char* pathname, char* const argv[]);
int execve(const char *pathname, char *const argv[], char *const envp[]);
int execvp(const char* file, char* const argv[]);
int execvpe(const char* file, char* const argv[], char* const envp[]);

int fexecve(int fd, char* const argv[], char* const envp[]);

/* 成功不返回，失败返回-1. */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

char* env_init[] = {"USER=unkonw", "PATH=/tmp", NULL};

int main()
{
    pid_t pid;
    /* 1.验证传递命令行参数 */
    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
        return 0;
    }
    else if (pid > 0)
    {
        printf("current process id is %d\n", getpid());
        printf("child process id is %d\n", pid);

        /* 休眠5s保证子进程先结束 */
        sleep(5);
    }
    else
    {
        /* 从外部获取环境变量 */
        if (execl("./echoall", "echoall", "arg1", "arg2", NULL) == -1)
        {
            perror("execl error: ");
        }
        exit(0);
    }

    /* 2.验证传递环境变量 */
    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
        return 0;
    }
    else if (pid > 0)
    {
        printf("current process id is %d\n", getpid());
        printf("child process id is %d\n", pid);

        /* 休眠5s保证子进程先结束 */
        sleep(5);
    }
    else
    {
        /* echoall进程的环境变量来源于传入的参数 */
        if (execle("./echoall", "echoall", "arg3", "arg4", NULL, env_init) < 0)
        {
            perror("execle error: ");
        }
    }

    /* 3.验证传递命令行参数数组 */
    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
        return 0;
    }
    else if (pid > 0)
    {
        printf("current process id is %d\n", getpid());
        printf("child process id is %d\n", pid);

        /* 休眠5s保证子进程先结束 */
        sleep(5);
    }
    else
    {
        char* arg[] = {"echoall", "arg5", "arg6", NULL};
        /* 以数组方式传递命令行参数，第一个元素是执行文件名 */
        if (execve("./echoall", arg, env_init) < 0)
        {
            perror("execve error: ");
        }
    }
}

$ ./exec_test
current process id is 26173
child process id is 26174
uid=1000, euid=1000, gid=1000, egid=1000, pid=26174, ppid=26173
argv:
argv[0]=echoall
argv[1]=arg1
argv[2]=arg2
environ:
environ[0]=SHELL=/bin/bash
environ[1]=LC_ADDRESS=zh_CN.UTF-8
environ[2]=LC_NAME=zh_CN.UTF-8
environ[3]=LC_MONETARY=zh_CN.UTF-8
...
environ[34]=_=./exec_test
current process id is 26173
child process id is 26175
uid=1000, euid=1000, gid=1000, egid=1000, pid=26175, ppid=26173
argv:
argv[0]=echoall
argv[1]=arg3
argv[2]=arg4
environ:
environ[0]=USER=unkonw
environ[1]=PATH=/tmp
current process id is 26173
child process id is 26176
uid=1000, euid=1000, gid=1000, egid=1000, pid=26176, ppid=26173
argv:
argv[0]=echoall
argv[1]=arg5
argv[2]=arg6
environ:
environ[0]=USER=unkonw
environ[1]=PATH=/tmp

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

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

int main()
{
    int status = system("/tmp/test");
    /* 1. 判断是否是fork或waitpid错误 */
    if (status == -1)
    {
        perror("system error: ");
        return 0;
    }
    else
    {
        /* 2. 判断进程是否正常终止 */
        if (WIFEXITED(status))
        {
            /* 正常终止 */
            printf("normal termination, exit status is %d\n", WEXITSTATUS(status));
            /* 3. 判断退出码是否是指定值 */
            if (WEXITSTATUS(status) == 3)
            {
                /* 是，表示命令执行成功 */
                printf("command executed successfully\n");
            }
            else
            {
                printf("command executed failed\n");
            }
        }
        else if (WIFSIGNALED(status))
        {
            /* 异常终止 */
            printf("abnormal termination, signal is %d\n", WTERMSIG(status));
        }
        else
        {
            printf("exception\n");
        }
    }
}

$ ./system_test
sh: 1: /tmp/test: not found
# 下面的结果表示fork创建进程成功，但是sh执行失败。
normal termination, exit status is 127
command executed failed

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

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

    if (cmdstring == NULL)
    {
        return 1;
    }

    if ((pid = fork()) < 0)
    {
        status = -1;
    }
    else if (pid == 0)
    {
        execl("/bin/sh", "sh", "-c", cmdstring, NULL);
        _exit(127);
    }
    else
    {
        while (waitpid(pid, &status, 0) < 0)
        {
            if (errno != EINTR)
            {
                status = -1;
                break;
            }
        }
    }
    return status;
}

static void print_exit(int status)
{
    if (WIFEXITED(status))
    {
        printf("normal termination, exit status = %d\n", WEXITSTATUS(status));
    }
    else if (WIFSIGNALED(status))
    {
        /* 异常终止子进程的信号编号 */
        printf("abnormal termination, signal number = %d%s\n", WTERMSIG(status),
        /* 是否已经产生core文件 */
#ifdef WCOREDUMP
            WCOREDUMP(status) ? "(core file generated)" : ""
#else
            ""
#endif
        );
    }
    else if (WIFSTOPPED(status))
    {
        /* 当前暂停子进程的信号编号 */
        printf("child stopped, signal number = %d\n", WSTOPSIG(status));
    }
}

int main()
{
    int status;
    if ((status = mysystem("date")) < 0)
    {
        perror("mysystem error: ");
    }
    print_exit(status);

    if ((status = mysystem("nosuchcommand")) < 0)
    {
        perror("mysystem error: ");
    }
    print_exit(status);

    if ((status = mysystem("who; exit 44")) < 0)
    {
        perror("mysystem error: ");
    }
    print_exit(status);

    exit(0);
}

$ ./system_new
2022年 07月 18日 星期一 23:24:33 JST
normal termination, exit status = 0
sh: 1: nosuchcommand: not found
normal termination, exit status = 127
blduan   tty2         2022-07-18 22:52 (tty2)
blduan   pts/0        2022-07-18 22:52 (192.168.1.4)
normal termination, exit status = 44

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

int main()
{
    pid_t pid;
    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
        return 0;
    }
    else if (pid == 0)
    {
        if (execl("./testinterp", "testinterp", "myarg1", "MY ARG2", NULL) < 0)
        {
            perror("execl error: ");
        }
    }
    if (waitpid(pid, NULL, 0) <= 0)
    {
        perror("waitpid error: ");
    }
    exit(0);
}

# 下面查看解释器文件的内容
$ cat testinterp
#! /home/blduan/projects/code_snippet/unix_code/8_chapter/echoarg foo
$ ./exec_interpreter
# argv[0]是解释器文件中的pathname, argv[1]是解释器文件的可选参数。
argv[0]=/home/blduan/projects/code_snippet/unix_code/8_chapter/echoarg
argv[1]=foo
# execl携带的命令行参数偏移了两个位置，
# 并且将execl函数的第一个参数作为传递给子进程的第一个命令行参数输出，而本来的第一个命令行参数被忽略。
argv[2]=./testinterp
argv[3]=myarg1
argv[4]=MY ARG2

# -f参数指定了从接下来的内容中读取解释器awk要执行代码
$ cat awkexample
#! /usr/bin/awk -f
# Note: on Ubuntu, use nawk instead
BEGIN {
    for (i=0; i<ARGC; i++)
        printf "ARGV[%d]=%s\n", i, ARGV[i]
    exit
}
# 使用execl函数执行和下面的效果一致
$ /usr/bin/awk -f ./awkexample myarg1 "MY ARG2"
ARGV[0]=awk
ARGV[1]=myarg1
ARGV[2]=MY ARG2

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    pid_t pid;
    if ((pid = fork()) < 0)
        perror("fork error: ");
    else if (pid == 0)
    {
        while (1)
        {
            sleep(3);
        }
    }

    else
    {
        printf("pid=%d\n", pid);
        exit(0);
    }
}

$ ./parent_proc_init
pid=94706
$ ps -ef | grep 94706
blduan     94706       1  0 00:02 pts/0    00:00:00 ./parent_proc_init

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    pid_t pid;
    if ((pid = fork()) < 0)
        perror("fork error: ");
    else if (pid > 0)
    {
        printf("pid=%d\n", pid);
        while (1)
        {
            sleep(3);
        }
    }
    else
    {
        exit(0);
    }
}

$ ./child_proc_zombie
pid=95612
^C
$ ps -aux | grep 95612
blduan     95612  0.0  0.0      0     0 pts/0    Z+   00:07   0:00 [child_proc_zomb] <defunct>

#include <sys/wait.h>

pid_t wait(int *statloc);
pid_t waitpid(pid_t pid, int *statloc, int options);
/* 成功返回进程ID，失败返回0 */

#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
int main()
{
    if (wait(NULL) <= 0)
    {
        perror("wait error: ");
    }
    return 0;
}

wait error: : No child processes

#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
int main()
{
    pid_t pid;
    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
    }
    else if (pid == 0)
    {
        printf("child process is running\n");
        while (1)
        {
            sleep(3);
        }
    }
    else
    {
        printf("child process is blocking\n");
        if (wait(NULL) <= 0)
        {
            perror("wait error: ");
        }
        else
        {
            printf("wait return\n");
        }
    }
}

r$ ./wait_block
child process is blocking
child process is running

#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
int main()
{
    pid_t pid;
    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
    }
    else if (pid == 0)
    {
        printf("child process exit\n");
        exit(3);
    }
    else
    {
        printf("child process id is %d\n", pid);
        sleep(2);
        int statloc;
        printf("wait return is %d\n", wait(&statloc));
        printf("exit code is %d\n", statloc);
        if (WIFEXITED(statloc))
        {
            printf("%d\n", WEXITSTATUS(statloc));
        }
        else if (WIFSIGNALED(statloc))
        {
            printf("%d\n", WTERMSIG(statloc));
        }
    }
}

$ ./wait_return
child process id is 110121
child process exit
wait return is 110121
3

#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
static void handle_sig_cancel(int sig)
{
    /* 验证信号处理函数中执行wait是否阻塞 */
    printf("signal handle\n");
    if (wait(NULL) <= 0)
    {
        perror("wait error: ");
    }
    else
    {
        printf("wait return\n");
    }
}
int main()
{
    signal(SIGCHLD, handle_sig_cancel);
    pid_t pid;
    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
    }
    else if (pid == 0)
    {
        printf("child process is running\n");
        while (1)
        {
            sleep(3);
        }
    }
    else
    {
        printf("child process id is %d\n", pid);
        printf("child process is blocking\n");
        /* 阻止父进程退出 */
        while (1)
        {
            sleep(3);
        }
    }
}

$ ./wait_sig_cancel
child process id is 109947
child process is blocking
child process is running
signal handle
wait return

static void print_exit(int status)
{
    if (WIFEXITED(status))
    {
        printf("normal termination, exit status = %d\n", WEXITSTATUS(status));
    }
    else if (WIFSIGNALED(status))
    {
        /* 异常终止子进程的信号编号 */
        printf("abnormal termination, signal number = %d%s\n", WTERMSIG(status),
        /* 是否已经产生core文件 */
#ifdef WCOREDUMP
            WCOREDUMP(status) ? "(core file generated)" : ""
#else
            ""
#endif
        );
    }
    else if (WIFSTOPPED(status))
    {
        /* 当前暂停子进程的信号编号 */
        printf("child stopped, signal number = %d\n", WSTOPSIG(status));
    }
}

int main()
{
    pid_t pid;
    int status;

    if ((pid = fork()) < 0)
        perror("fork error: ");
    else if (pid == 0)
        /* 子进程正常终止 */
        exit(7);

    if (wait(&status) != pid)
    {
        perror("wait error: ");
        return 0;
    }
    print_exit(status);

    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
        return 0;
    }
    else if (pid == 0)
    {
        /* 子进程异常终止，产生信号SIGABRT */
        abort();
    }
    if (wait(&status) != pid)
    {
        perror("wait error: ");
        return 0;
    }
    print_exit(status);

    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
        return 0;
    }
    else if (pid == 0)
    {
        /* 子进程异常终止，产生SIGFPE信号 */
        status /= 0;
    }
    if (wait(&status) != pid)
    {
        perror("wait error: ");
        return 0;
    }
    print_exit(status);
    return 0;
}

$ ./print_exit
normal termination, exit status = 7
abnormal termination, signal number = 6(core file generated)
abnormal termination, signal number = 8(core file generated)

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

int main()
{
    pid_t pid;
    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
        return 0;
    }
    else if (pid == 0)
    {
        printf("child process is running\n");
        while (1)
        {
            sleep(3);
        }
    }
    else
    {
        /* WNOHANG表示pid指定的子进程不是可用的，则立即返回0 */
        int ret = waitpid(pid, NULL, WNOHANG);
        if (ret == 0)
        {
            printf("waitpid return\n");
        }
        else if (ret > 0)
        {
            printf("child process id is %d\n", ret);
        }
        else
        {
            perror("waitpid error: ");
        }
    }
}

$ ./waitpid_nohang
waitpid return
child process is running
$ ps -a
    PID TTY          TIME CMD
   1562 pts/0    00:00:00 waitpid_nohang
   1567 pts/0    00:00:00 ps

#include <sys/type.h>
#include <sys/wait.h>
int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);
/* 成功返回0， 失败返回-1 */

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int main()
{
    pid_t pid;
    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
        return 0;
    }
    else if (pid == 0)
    {
        sleep(10);
        exit(3);
    }
    else
    {
        siginfo_t sig;
        if (waitid(P_PID, pid, &sig, WEXITED) == 0)
        {
            printf("child process id is %d, and exited\n", pid);
            printf("%d %d %d\n", sig.si_code, sig.si_errno, sig.si_signo);
        }
        else
        {
            perror("waitid error: ");
        }
    }
}

$ ./waitid_test
# 下面的结果是10s之后打印的，可见waitid会阻塞调用进程。
child process id is 3715, and exited
1 0 17

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

pid_t wait3(int *wstatus, int options, struct rusage *rusage);
pid_t wait4(pid_t pid, int *wstatus, int options, struct rusage *rusage);
/* 成功返回进程id， 失败返回-1 */

#include <unistd.h>
char* getlogin();
/* 成功返回登录用户名，失败返回NULL */

#include <unistd.h>
#include <stdio.h>
int main(){
    printf("%s\n",getlogin());
}

/* 执行结果如下： */
$ ./get_login_name
blduan

while(getppid() != 1){
    sleep(1);
}

#include <unistd.h>

int nice(int incr);
/* 成功返回新的友好值，失败返回-1 */

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>

static unsigned long long count = 0;
static struct timeval end;
static void check_time(char* str)
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    if (tv.tv_sec >= end.tv_sec && tv.tv_usec >= end.tv_usec)
    {
        printf("%s count=%lld\n", str, count);
        exit(0);
    }
}

int main(int argc, char* argv[])
{
    /* 1.获取友好值范围 */
    int nzero = 0;
    int ret = 0;
    int incr = 0;
    pid_t pid;
    char* name = NULL;
    setbuf(stdout, NULL);
#ifdef NZERO
    nzero = NZERO;
#elif _SC_NZERO
    nzero = sysconf(_SC_NZERO);
#else
#endif
    printf("NZERO=%d\n", nzero);

    /* 2. 从输入参数中获取incr */
    if (argc == 2)
    {
        incr = strtol(argv[1], NULL, 10);
    }

    gettimeofday(&end, NULL);
    end.tv_sec += 10;

    /* 3. 创建子进程和父进程运行相同的时间，并计数 */
    if ((pid = fork()) < 0)
    {
        perror("fork error");
    }
    else if (pid == 0)
    {
        /* 子进程 */
        name = "child";
        printf("current nice value in child is %d\n", nice(0));
        errno = 0;
        if ((ret = nice(incr)) == -1 && errno != 0)
        {
            perror("nice error");
        }
        printf("current nice value in child is %d\n", ret);
    }
    else
    {
        /* 父进程 */
        name = "parent";
        printf("current nice value in parent is %d\n", nice(0));
    }

    /* 4. 父子进程开始计数，根据计数的值来判断占用CPU的时间长度 */
    while (1)
    {
        if (++count == 0)
        {
            exit(0);
        }
        check_time(name);
    }
    return 0;
}

$ ./nice_test
NZERO=0
current nice value in parent is 0
current nice value in child is 0
current nice value in child is 0
parent count=320828014
child count=321910059

$ ./nice_test 20
NZERO=0
current nice value in parent is 0
current nice value in child is 0
current nice value in child is 19
parent count=652649803
child count=9793971

$ sudo ./nice_test -20
NZERO=0
current nice value in parent is 0
current nice value in child is 0
current nice value in child is -20
child count=655302483
parent count=7797852

#include <sys/resource.h>

int getpriority(int which, id_t who);
/* 成功返回友好值，失败返回-1 */
int setpriority(int which, id_t who, int value);
/* 增加value到现有友好值上，成功返回0， 失败返回-1 */

#include <stdio.h>
#include <sys/resource.h>
#include <unistd.h>

int main()
{
    printf("PRIO_PROCESS: %d PRIO_PGRP: %d PRIO_USER: %d\n", getpriority(PRIO_PROCESS, 0), getpriority(PRIO_PGRP, 0),
        getpriority(PRIO_USER, 0));
}
// PRIO_PROCESS: 0 PRIO_PGRP: 0 PRIO_USER: -11

#include <unistd.h>

int setuid(uid_t uid);
int setgid(gid_t gid);

int setreuid(uid_t ruid, uid_t euid);
int setregid(gid_t rgid, gid_t egid);

int seteuid(uid_t uid);
int setegid(gid_t gid);
/* 成功返回0， 失败返回-1 */

#include <stdio.h>
#include <stdlib.h>
#define _GNU_SOURCE
#include <unistd.h>

static void print_ids()
{
    uid_t ruid;
    uid_t euid;
    uid_t saved_uid;
    if (getresuid(&ruid, &euid, &saved_uid) == 0)
    {
        printf("real uid=%d, effective uid=%d saved uid =%d\n", ruid, euid, saved_uid, saved_uid);
    }
    else
    {
        perror("getresuid error: ");
        return;
    }
}

int main()
{
    /* 1. 修改了进程文件的所有者和所有组为root，并设置了设置用户ID位和设置组ID位。
     *     此时进程的有效用户为root，保存的设置用户也为root. */
    print_ids();
    /* 2. 降低特权，调用seteuid会将有效用户设置为实际用户，此时保存的设置用户为root */
    seteuid(getuid());
    print_ids();
    /* 3. 提高特权，将有效用户设置为保存的设置用户 */
    setuid(0);
    print_ids();

    /* 4. 创建进程以执行特定用户的命令需要降低权限· */
    pid_t pid;
    if ((pid = fork()) < 0)
    {
        perror("fork error: ");
        return 0;
    }
    else if (pid == 0)
    {
        /* 运行用户命令，降低权限 */
        setuid(getuid());
        print_ids();
    }
}

$ ./setuid_test
real uid=1000, effective uid=0 saved uid =0
real uid=1000, effective uid=1000 saved uid =0
real uid=1000, effective uid=0 saved uid =0
real uid=1000, effective uid=1000 saved uid =1000

#include <sys/times.h>

clock_t times(struct tms *buf);
/* 成功返回时钟时间长度，失败返回-1. */ 

struct tms{
    clock_t tms_utime; /* 用户CPU时间*/
    clock_t tms_stime; /* 系统CPU时间 */
    clock_t tms_cutime; /* 子进程用户CPU时间 */
    clock_t tms_cstime; /* 子进程系统CPU时间 */
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/times.h>
#include <unistd.h>

static void print_exit(int status)
{
    if (WIFEXITED(status))
    {
        printf("normal termination, exit status = %d\n", WEXITSTATUS(status));
    }
    else if (WIFSIGNALED(status))
    {
        /* 异常终止子进程的信号编号 */
        printf("abnormal termination, signal number = %d%s\n", WTERMSIG(status),
        /* 是否已经产生core文件 */
#ifdef WCOREDUMP
            WCOREDUMP(status) ? "(core file generated)" : ""
#else
            ""
#endif
        );
    }
    else if (WIFSTOPPED(status))
    {
        /* 当前暂停子进程的信号编号 */
        printf("child stopped, signal number = %d\n", WSTOPSIG(status));
    }
}

static void print_times(clock_t real, struct tms* tmsstart, struct tms* tmsend)
{
    long clktck = 0;
    if (clktck == 0)
    {
        if ((clktck = sysconf(_SC_CLK_TCK)) < 0)
        {
            perror("sysconf error: ");
            exit(0);
        }
    }

    printf(" real: %7.2f\n", real / (double)clktck);
    printf(" user: %7.2f\n", (tmsend->tms_utime - tmsstart->tms_utime) / (double)clktck);
    printf(" system: %7.2f\n", (tmsend->tms_stime - tmsstart->tms_stime) / (double)clktck);
    printf(" child user: %7.2f\n", (tmsend->tms_cutime - tmsstart->tms_cutime) / (double)clktck);
    printf(" child system: %7.2f\n", (tmsend->tms_cstime - tmsstart->tms_cstime) / (double)clktck);
}

static void do_cmd(const char* cmd)
{
    struct tms tmsstart, tmsend;
    clock_t start, end;
    int status;

    printf("\ncommand: %s\n", cmd);
    if ((start = times(&tmsstart)) == -1)
        perror("times error: ");

    if ((status = system(cmd)) < 0)
        perror("system error: ");

    if ((end = times(&tmsend)) == 0)
        perror("system error: ");

    print_times(end - start, &tmsstart, &tmsend);
    print_exit(status);
}
int main(int argc, char* argv[])
{
    int i;
    setbuf(stdout, NULL);
    for (i = 1; i < argc; i++)
    {
        do_cmd(argv[i]);
    }
    exit(0);
}

$ ./process_clock "sleep 5" "date" "man bash > /dev/null"
command: sleep 5
 real:    5.01
 user:    0.00
 system:    0.00
 child user:    0.00
 child system:    0.00
normal termination, exit status = 0

command: date
2022年 07月 22日 星期五 00:23:12 JST
 real:    0.00
 user:    0.00
 system:    0.00
 child user:    0.00
 child system:    0.00
normal termination, exit status = 0

command: man bash> /dev/null
 real:    0.14
 user:    0.00
 system:    0.00
 child user:    0.13
 child system:    0.09
normal termination, exit status = 0