从 `forkpty` 子进程读取：`ls /` 输出产生 `EIO`

Question

我正在尝试使用 forkpty 到 execvp 一个 ls /，然后从父进程读取其输出并写入标准输出。

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

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

然而，最后的 read 总是 returns -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

pty驱动调用一个内核内部函数使slave pty端失效，returnsEIO从那时起，直到slave端关闭。这种情况总是发生在主控端被控制进程关闭。

这个过程是当今所有 unix 变体的标准。这是一种解决方法，可以避免进程在主端消失后继续使用设备。即使你用一个新的进程再次附加主端，旧的从属进程也会被阻塞，直到它关闭打开的描述符。

Answer 2

问题似乎分为三个部分：

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 处理提供足够的时间，但最终读取仍会失败 (return -1)，在这种情况下使用 EIO。

从 `forkpty` 子进程读取：`ls /` 输出产生 `EIO`

Reading from `forkpty` child process: `ls /` output yields `EIO`

c

ipc

pty

execvp