SetupDiEnumDeviceInterfaces 返回259

转载

技术博主 2024-10-10 09:06:15

文章标签 linux 命令子进程函数返回 linux 文章分类 架构后端开发

一、system

为了更好的理解 system() 函数返回值，需要了解其执行过程，实际上 system() 函数执行了三步操作：

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

对于 fork 失败，system() 函数返回 -1。

如果 exec 执行成功，也即 command 顺利执行完毕，则返回 command 通过 exit 或 return 返回的值。(注意，command 顺利执行不代表执行成功，比如 command："rm debuglog.txt"，不管文件存不存在该 command 都顺利执行了）。

如果 exec 执行失败，也即 command 没有顺利执行，比如被信号中断，或者 command 命令根本不存在，system() 函数返回127。

如果 command 为 NULL，则 system() 函数返回非 0 值，一般为 1。

二、system() 和 popen() 简介

在 linux 中我们可以通过 system() 来执行一个 shell 命令，popen() 也是执行 shell 命令并且通过管道和 shell 命令进行通信。

system()、popen() 给我们处理了 fork、exec、waitpid

三、system()、popen() 源码

1、system() 源码

int system(const char *command)
{
    struct sigaction sa_ignore, sa_intr, sa_quit;
    sigset_t block_mask, orig_mask;
    pid_t pid;

    sigemptyset(&block_mask);
    sigaddset(&block_mask, SIGCHLD);
    sigprocmask(SIG_BLOCK, &block_mask, &orig_mask); //1. block SIGCHLD
    sa_ignore.sa_handler = SIG_IGN;
    sa_ignore.sa_flags = 0;
    sigemptyset(&sa_ignore.sa_mask);

    sigaction(SIGINT, &sa_ignore, &sa_intr); //2. ignore SIGINT signal
    sigaction(SIGQUIT, &sa_ignore, &sa_quit); //3. ignore SIGQUIT signal
    switch ((pid = fork())) {
    case -1:
        return -1;
    case 0:
        sigaction(SIGINT, &sa_intr, NULL);
        sigaction(SIGQUIT, &sa_quit, NULL);
        sigprocmask(SIG_SETMASK, &orig_mask, NULL);
        execl("/bin/sh", "sh", "-c", command, (char *)0);
        exit(127);
    default:
        while (waitpid(pid, NULL, 0) == -1) //4. wait child process exit { if(errno != EINTR)
        {
            break;
        }
    }
    return 0;
}

2、popen() 的源码。

static pid_t *childpid = NULL; /* ptr to array allocated at run-time */
static int maxfd; /* from our open_max(), {Prog openmax} */
#define SHELL "/bin/sh"

FILE *popen(const char *cmdstring, const char *type)
{
    int i, pfd[2];
    pid_t pid;
    FILE *fp; /* only allow "r" or "w" */
    if ((type[0] != 'r' && type[0] != 'w') || type[1] != 0) {
        errno = EINVAL; /* required by POSIX.2 */
        return (NULL);
    }
    if (childpid == NULL) { /* first time through */ /* allocate zeroed out array for child pids */
        maxfd = open_max();
        if ((childpid = calloc(maxfd, sizeof(pid_t))) == NULL)
            return (NULL);
    }
    if (pipe(pfd) < 0)
        return (NULL); /* errno set by pipe() */
    if ((pid = fork()) < 0)
        return (NULL); /* errno set by fork() */
    else if (pid == 0) { /* child */
        if (*type == 'r') {
            close(pfd[0]);
            if (pfd[1] != STDOUT_FILENO) {
                dup2(pfd[1], STDOUT_FILENO);
                close(pfd[1]);
            }
        } else {
            close(pfd[1]);
            if (pfd[0] != STDIN_FILENO) {
                dup2(pfd[0], STDIN_FILENO);
                close(pfd[0]);
            }
        } /* close all descriptors in childpid[] */
        for (i = 0; i < maxfd; i++)
            if (childpid[i] > 0)
                close(i);
        execl(SHELL, "sh", "-c", cmdstring, (char *)0);
        _exit(127);
    } /* parent */
    if (*type == 'r') {
        close(pfd[1]);
        if ((fp = fdopen(pfd[0], type)) == NULL)
            return (NULL);
    } else {
        close(pfd[0]);
        if ((fp = fdopen(pfd[1], type)) == NULL)
            return (NULL);
    }
    childpid[fileno(fp)] = pid; /* remember child pid for this fd */
    return (fp);
}

四、执行流程

从上面的源码可以看到 system 和 popen 都是执行了类似的运行流程，大致是

fork -> execl -> return

但是我们看到 system 在执行期间调用进程会一直等待 shell 命令执行完成（waitpid 等待子进程结束）才返回，但是 popen 无须等待 shell 命令执行完成就返回了。我们可以理解 system 为串行执行，在执行期间调用进程放弃了”控制权”，popen 为并行执行。

popen 中的子进程没人给它”收尸”了啊？是的，如果你没有在调用 popen 后调用 pclose 那么这个子进程就可能变成”僵尸”。

上面我们没有给出 pclose 的源码，其实我们根据 system 的源码差不多可以猜测出 pclose 的源码就是 system 中第 4 部分的内容。

五、信号处理

我们看到 system 中对 SIGCHLD、SIGINT、SIGQUIT 都做了处理，但是在 popen 中没有对信号做任何的处理。

SIGCHLD 是子进程退出的时候发给父进程的一个信号，system() 中为什么要屏蔽 SIGCHLD 信号可以参考：system 函数的总结、waitpid（or wait）和 SIGCHILD 的关系，总结一句就是为了system() 调用能够及时的退出并且能够正确的获取子进程的退出状态（成功回收子进程）。

popen 没有屏蔽 SIGCHLD，主要的原因就是 popen 是”并行”的。如果我们在调用 popen 的时候屏蔽了 SIGCHLD，那么如果在调用 popen 和 pclose 之间调用进程又创建了其它的子进程并且调用进程注册了 SIGCHLD 信号处理句柄来处理子进程的回收工作（waitpid）那么这个回收工作会一直阻塞到 pclose 调用。这也意味着如果调用进程在 pclose 之前执行了一个 wait() 操作的话就可能获取到 popen 创建的子进程的状态，这样在调用 pclose 的时候就会回收（waitpid）子进程失败，返回-1，同时设置 errno 为 ECHLD，标示 pclose 无法获取子进程状态。