Linux POSIX管道读取超65536字节失败，如何解决？

1. 非阻塞读取的错误处理缺失：在非阻塞模式下，read() 返回 -1 并不一定代表读取失败。当管道当前无数据但写入端未关闭时，read() 会返回 -1 并将 errno 设置为 EAGAIN（或 EWOULDBLOCK）。你的代码直接将这种情况判定为读取结束，导致管道中后续到达的数据被遗漏——而64KB恰好是很多系统中管道的默认缓冲区大小，当数据超过这个值时，子进程可能分批写入，第一次读完缓冲区后，剩余数据还未到达，此时read()返回EAGAIN，循环直接退出。
2. 串行读取逻辑缺陷：你先完整读取标准输出管道，再读取标准错误管道。但子进程可能同时往两个管道写数据，当标准输出管道暂时无数据时，你直接停止读取，此时标准错误管道可能还有数据未写完，甚至标准输出管道后续还有数据会被写入，但你的代码已经不再尝试读取。
3. 未判断管道写入端状态：只有当管道的写入端被关闭时，read() 返回 0 才代表数据完全读取完毕。你的代码没有区分“暂时无数据”和“数据已全部读完”这两种情况。

使用select()（或poll()）同时监听两个管道的可读事件，循环读取直到两个管道的写入端都关闭（即read()返回0）。同时正确处理EAGAIN错误，在无数据时等待而非退出。

以下是修改后的代码：

#include <sys/select.h>
#include <errno.h>
#include <unistd.h>
#include <tuple>
#include <string>
#include <iostream>

void SetFdAsync(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) flags = 0;
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

std::tuple<std::string, std::string> ReadPipe(int pipe_out, int pipe_err) {
    char buf[PIPE_BUF];
    std::string str_out, str_err;
    bool out_done = false, err_done = false;

    SetFdAsync(pipe_out);
    SetFdAsync(pipe_err);

    while (!out_done || !err_done) {
        fd_set read_fds;
        FD_ZERO(&read_fds);
        int max_fd = -1;

        if (!out_done) {
            FD_SET(pipe_out, &read_fds);
            max_fd = std::max(max_fd, pipe_out);
        }
        if (!err_done) {
            FD_SET(pipe_err, &read_fds);
            max_fd = std::max(max_fd, pipe_err);
        }

        // 等待至少一个管道可读
        int ret = select(max_fd + 1, &read_fds, nullptr, nullptr, nullptr);
        if (ret == -1) {
            // 处理select错误，比如被信号中断
            if (errno == EINTR) continue;
            break;
        }

        // 读取标准输出
        if (!out_done && FD_ISSET(pipe_out, &read_fds)) {
            ssize_t rd = read(pipe_out, buf, PIPE_BUF);
            if (rd > 0) {
                str_out.append(buf, rd);
            } else if (rd == 0) {
                // 写入端关闭，标准输出读取完成
                out_done = true;
            } else {
                // 处理EAGAIN，继续等待
                if (errno != EAGAIN && errno != EWOULDBLOCK) {
                    // 真正的错误，标记为完成
                    out_done = true;
                }
            }
        }

        // 读取标准错误
        if (!err_done && FD_ISSET(pipe_err, &read_fds)) {
            ssize_t rd_err = read(pipe_err, buf, PIPE_BUF);
            if (rd_err > 0) {
                str_err.append(buf, rd_err);
            } else if (rd_err == 0) {
                err_done = true;
            } else {
                if (errno != EAGAIN && errno != EWOULDBLOCK) {
                    err_done = true;
                }
            }
        }
    }

    return std::make_tuple(str_out, str_err);
}

• 使用select()同时监听两个管道的可读事件，避免串行读取导致的遗漏。
• 明确区分read()返回值的三种情况：
  • >0：读取到数据，追加到结果字符串。
  • =0：写入端关闭，该管道读取完成。
  • -1：若errno为EAGAIN/EWOULDBLOCK则继续等待，否则判定为读取错误并停止。
• 用out_done和err_done标记两个管道是否读取完成，直到两者都完成才退出循环。

内容的提问来源于stack exchange，提问作者Alex