编写迷你Linux Shell时管道执行失效，求故障排查思路

问题背景 #

实现的Shell支持以;分隔的多命令，当前需支持任意数量的管道（如ps|wc），但执行ps|wc时管道未正常传递数据，wc未执行预期功能，仅输出调试信息。

核心问题分析 #

1. 命令拆分不完整 #

pipe_parse的循环条件为i < strlen(str)，导致字符串末尾的最后一条命令（如ps|wc中的wc）无法被处理——当i遍历到最后一个字符时循环结束，不会触发str[i] == '\0'的分支去解析最后一条命令，最终仅执行了ps，wc完全未被处理。

2. 管道描述符传递失效 #

• pipe_parse循环内部每次都声明局部变量prev_pipefd[2] = {-1, -1}，导致每次调用exec_command时，prev_pipefd都是初始值，无法传递上一个管道的读写描述符，后续命令无法获取前序命令的输出。
• 父进程中直接将pipefd的地址赋值给prev_pipefd，但pipefd是循环内的局部变量，下一次迭代时栈空间会被覆盖，导致prev_pipefd指向无效内存。

3. 管道资源未正确关闭 #

• 子进程完成dup2重定向后，未关闭不需要的管道描述符。例如第一个命令的子进程dup2(pipefd[1], STDOUT_FILENO)后，未关闭pipefd[1]，导致管道写端始终打开，后续读端（如wc）会一直等待写端关闭，无法结束。
• 父进程处理完子进程后，未正确关闭当前管道的无用描述符，同样会导致管道无法正常终止。

4. 最后一个命令无需创建新管道 #

当前代码每次处理命令都会创建新管道，但管道链的最后一个命令不需要输出到管道，多余的管道会干扰执行逻辑。

修复方案 #

1. 修复命令拆分逻辑 #

调整循环条件并在循环外维护prev_pipefd，确保所有命令被解析，且管道描述符正确传递：

void pipe_parse(char **args, char *str, int pipes_amount) {
    char curr_cmd[510];
    memset(curr_cmd, 0, sizeof(curr_cmd));
    int pipes_executed = 0;
    char *token;
    // 循环外维护上一个管道的描述符
    int prev_pipefd[2] = {-1, -1};

    int len = strlen(str);
    // 改为i <= len，处理字符串末尾的'\0'
    for (int i = 0, j = 0; i <= len; ++i) { 
        if (i == len || str[i] == '|') { 
            curr_cmd[j] = '\0';
            j = 0;
            // 解析当前命令参数
            token = strtok(curr_cmd, " ");
            int k = 0;
            while (token != NULL) {
                args[k++] = token;
                token = strtok(NULL, " ");
            }
            while (k < 10) args[k++] = NULL;

            int pipefd[2] = {-1, -1};
            // 仅非最后一个命令创建管道
            if (pipes_executed < pipes_amount) {
                if (pipe(pipefd) == -1) {
                    perror("ERR pipe");
                    exit(1);
                }
            }

            exec_command(args, 0, NULL, pipes_executed, pipes_amount, pipefd, prev_pipefd);
            pipes_executed++;

            // 更新上一个管道描述符，先关闭旧的资源
            if (pipefd[0] != -1) {
                if (prev_pipefd[0] != -1) close(prev_pipefd[0]);
                if (prev_pipefd[1] != -1) close(prev_pipefd[1]);
                prev_pipefd[0] = pipefd[0];
                prev_pipefd[1] = pipefd[1];
            }
        } else {
            curr_cmd[j++] = str[i];
        }
    }
}

2. 修复管道重定向与资源关闭逻辑 #

修改exec_command，确保重定向后关闭无用描述符，父进程也正确清理管道资源：

void exec_command(char **args, int ampersand, char *file_name, int pipe_num, int pipe_amount, int *pipefd,
                  int *prev_pipefd) {
    int status;
    pid_t pidd = fork();

    if (pidd == 0) {
        signal(SIGTSTP, SIG_DFL);

        if (redirect_flag == 1) {
            int fd = open(file_name, O_WRONLY | O_TRUNC | O_CREAT, 0644);
            if (fd == -1) {
                perror("ERR file");
                exit(1);
            }
            dup2(fd, STDOUT_FILENO);
            close(fd); // 关闭原文件描述符
        }

        if (pipe_amount != 0) {
            // 处理第一个命令：重定向stdout到当前管道写端
            if (pipe_num == 0) {
                close(pipefd[0]);
                dup2(pipefd[1], STDOUT_FILENO);
                close(pipefd[1]); // 关闭原写端
            }
            // 处理最后一个命令：重定向stdin到上一个管道读端
            else if (pipe_num == pipe_amount) {
                close(prev_pipefd[1]);
                dup2(prev_pipefd[0], STDIN_FILENO);
                close(prev_pipefd[0]); // 关闭原读端
            }
            // 处理中间命令：同时重定向stdin和stdout
            else {
                close(prev_pipefd[1]);
                dup2(prev_pipefd[0], STDIN_FILENO);
                close(prev_pipefd[0]);

                close(pipefd[0]);
                dup2(pipefd[1], STDOUT_FILENO);
                close(pipefd[1]);
            }
        }

        execvp(args[0], args);
        perror("ERR0");
        exit(1);
    } else if (pidd < 0) {
        perror("ERR1");
        exit(1);
    } else {
        signal(SIGTSTP, father_handler);
        
        if (pipe_amount != 0) {
            // 父进程关闭无用的管道描述符
            if (pipe_num == 0) {
                close(pipefd[1]);
            } else if (pipe_num == pipe_amount) {
                close(prev_pipefd[0]);
            } else {
                close(prev_pipefd[0]);
                close(pipefd[1]);
            }
        }
        
        if (ampersand == 0)
            waitpid(pidd, &status, WUNTRACED);

        legalCmds += 1;
        for (int i = 0; i < 10; ++i)
            if (args[i] != NULL)
                legalArgs += 1;
    }
}

3. 补充说明 #

• 确保pipes_amount计算正确：对于ps|wc，管道数量为1（等于管道符的个数），命令数量为2。
• 可在pipe_parse末尾添加循环，等待所有子进程执行完成，避免僵尸进程。

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