c - 从 `forkpty` 子进程读取 : `ls/` output yields `EIO`

Question

我正在尝试使用forkpty来execvp一个ls/，然后从父进程读取它的输出并写入stdout .

我让它工作了，并且在 Valgrind 下运行它也没有显示任何错误。

编辑:Valgrind 没有显示内存错误。最后的 read 仍然在 Valgrind 下产生 EIO。

但是，最后的read 总是返回-1 并将errno 设置为EIO。我一直在研究和阅读手册页，但我仍然不明白为什么会这样:

  EIO    I/O  error.  This will happen for example when the process is in
         a background process group, tries to read from  its  controlling
         terminal,  and  either it is ignoring or blocking SIGTTIN or its
         process group is orphaned.  It may also occur when  there  is  a
         low-level I/O error while reading from a disk or tape.

我还注意到，如果我捕捉到 SIGCHLD 信号，我可以知道 ls 何时退出，但是如果我列出一个更大的目录，例如 /usr/bin 然后我得到 ls 子进程的信号，即使在成功之后有许多 read。

这是一个示例输出:

$ ./a.out
bin    dev         initrd.img.old  libx32      opt   sbin  usr
boot   etc         lib             lost+found  proc  srv   var
build  home        lib32           media       root  sys   vmlinuz
core   initrd.img  lib64           mnt         run   tmp   vmlinuz.old
# read: Input/output error

我是否漏掉了一些明显的东西？

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

int main(int argc, char* argv[]) {
    int master_fd;
    pid_t child_pid = forkpty(&master_fd, NULL, NULL, NULL);

    if (child_pid == -1) {
        perror("# forkpty");
        return EXIT_FAILURE;
    }
    else if (!child_pid) { /* CHILD */
        char* ls_argv[] = {
            "ls",
            "/",
            NULL,
        };

        execvp(ls_argv[0], ls_argv);
        perror("# execvp");
        abort();
    }
    else { /* PARENT */
        uint8_t buffer[BUFSIZ];
        ssize_t read_count;

        while ((read_count = read(master_fd, buffer, BUFSIZ)) > 0) {
            uint8_t* ptr = buffer;
            size_t ptr_len = (size_t) read_count;

            while (ptr_len > 0) {
                ssize_t write_count = write(STDOUT_FILENO, ptr, ptr_len);

                if (write_count == -1) {
                    perror("# write");
                    return EXIT_FAILURE;
                }

                ptr += write_count;
                ptr_len -= write_count;
            }
        }

        if (read_count == -1) {
            perror("# read");
            return EXIT_FAILURE;
        }

        if (close(master_fd) == -1) {
            perror("# close");
            return EXIT_FAILURE;
        }

        int child_status;

        if (waitpid(child_pid, &child_status, 0) == -1) {
            perror("# waitpid");
            return EXIT_FAILURE;
        }

        if (!WIFEXITED(child_status)) {
            fprintf(stderr, "# main: subprocess did not exit normally\n");
            return EXIT_FAILURE;
        }

        return child_status;
    }
}

Answer 1

问题似乎分为三个部分:

a) 在这种情况下(在最后一次读取时)EIO 是有效错误吗？

b) 为什么在预期的 I/O 完成之前收到 SIGCHLD，

c) 为什么 Valgrind 没有发生错误？

a) 最后一次读取预计会失败，因为读取类似于子进程已退出的破损管道上的读取。与 EIO 相比，EOF 似乎是一个更有意义的错误。(当从磁盘或磁带读取时出现低级 I/O 错误时也可能发生。)

b) CPU 处理远远领先于 I/O 导致了这种情况。收到 SIGCHLD(并设置标志以指示子进程已退出)后，父进程应该期望读取失败，一旦完成读取子进程写入 slave-pty 的信息，因此可以安全地忽略 EIO。

c) 我不确定这个。虽然 Valgrind 可能会放慢速度，为 I/O 处理提供足够的时间，但最终读取仍会失败(返回 -1)，在本例中使用 EIO。