Minishell管道异常求助：cat | cat | ls执行未即时输出

1. 管道命令串行执行逻辑错误：当前实现会同步等待每个管道命令执行完毕后才启动下一个。比如cat | cat | ls中，前两个cat会因等待终端输入而阻塞，导致ls完全无法启动，直到按下Ctrl-C终止前面的cat进程，ls才会被执行输出。
2. 进程等待逻辑不合理：ft_ex中使用WNOHANG的忙等循环，会让父进程卡死在等待前一个阻塞的子进程上；若直接去掉等待逻辑，子进程会变成僵尸进程，且无法正确收集退出状态，引发后续命令执行异常。
3. 管道重定向与FD管理缺失：代码仅创建了管道，但未将前一个命令的stdout重定向到管道写端、后一个命令的stdin重定向到管道读端，且父进程未关闭闲置的管道文件描述符，可能导致管道阻塞。
4. execve参数错误：原代码中execve(*argv, envp, ft_getenv(env_list))的第二个参数应为命令参数列表argv，而非环境变量envp，会导致命令执行失败。

1. 修改ft_ex函数：分离单命令与管道命令的等待逻辑 #

让ft_ex支持两种模式：单命令时阻塞等待子进程，管道命令时仅启动子进程并保存PID，由上层统一等待。同时修复execve参数错误：

// 新增参数：wait_for_child（是否等待子进程）、pid_out（保存子进程PID）
int ft_ex(char **argv, char **envp, int i, t_node *env_list, int wait_for_child, pid_t *pid_out)
{   
    pid_t pid;
    int res;

    pid = fork();
    if (pid == -1)
    {
        perror("fork");
        return 1;
    }
    else if (!pid)
    {
        argv[i] = 0;
        // 修复execve参数错误：第二个参数传argv
        if (execve(argv[0], argv, ft_getenv(env_list)) == -1)
        {
            // 修复错误信息：打印命令名而非环境变量
            printf("Error: %s command not found\n", argv[0]);
            exit(1);
        }
    }
    else
    {   
        if (pid_out != NULL)
            *pid_out = pid; // 保存PID到外部列表
        
        if (wait_for_child)
        {
            // 单命令场景：阻塞等待子进程结束
            waitpid(pid, &res, 0);
            if (WIFEXITED(res))
                return (g_exit_num = WEXITSTATUS(res));
            else
                return (1);
        }
        // 管道场景：不等待，直接返回
        return 0;
    }
    return 0;
}

2. 实现管道命令并行执行逻辑 #

新增上层函数处理管道链，并行启动所有命令、设置管道重定向，最后统一等待所有子进程：

#include <sys/wait.h>
#include "libft.h" // 假设使用libft的链表工具

// 假设t_cmd是存储单命令信息的结构体，包含argv和argc
typedef struct s_cmd {
    char **argv;
    int argc;
} t_cmd;

int execute_pipeline(t_mini *mini, t_list *commands)
{
    pid_t *pids;
    int num_cmds = ft_lstsize(commands);
    int prev_pipe_read = -1;
    int curr_pipe[2];
    int i = 0;

    pids = malloc(sizeof(pid_t) * num_cmds);
    if (!pids)
        return 1;

    while (commands)
    {
        t_cmd *cmd = (t_cmd*)commands->content;
        int has_next = commands->next != NULL;

        // 非最后一个命令时创建管道
        if (has_next && pipe(curr_pipe) == -1)
        {
            perror("pipe");
            free(pids);
            return 1;
        }

        // 启动子进程，不等待，保存PID
        ft_ex(cmd->argv, mini->envp, cmd->argc, mini->env_list, 0, &pids[i]);

        // 子进程中设置管道重定向（需将此逻辑移到fork后的子进程中，可修改ft_ex传入重定向FD）
        // 示例：在ft_ex的子进程分支中添加以下逻辑（需新增stdin_fd和stdout_fd参数）
        /*
        if (stdin_fd != -1) {
            dup2(stdin_fd, STDIN_FILENO);
            close(stdin_fd);
        }
        if (stdout_fd != -1) {
            dup2(stdout_fd, STDOUT_FILENO);
            close(stdout_fd);
        }
        */
        // 当前示例中，stdin_fd为prev_pipe_read，stdout_fd为has_next时的curr_pipe[1]

        // 父进程关闭闲置管道FD
        if (prev_pipe_read != -1)
            close(prev_pipe_read);
        if (has_next)
        {
            prev_pipe_read = curr_pipe[0];
            close(curr_pipe[1]);
        }

        commands = commands->next;
        i++;
    }

    // 父进程关闭最后一个管道的读端
    if (prev_pipe_read != -1)
        close(prev_pipe_read);

    // 等待所有子进程，仅保留最后一个命令的退出状态
    int res;
    for (i = 0; i < num_cmds; i++)
    {
        waitpid(pids[i], &res, 0);
        if (i == num_cmds - 1)
        {
            g_exit_num = WIFEXITED(res) ? WEXITSTATUS(res) : 1;
        }
    }

    free(pids);
    return g_exit_num;
}

3. 调整管道重定向逻辑 #

在call_pipe_redirect中补充管道重定向的FD传递，确保每个命令的输入输出正确关联到管道：

void    call_pipe_redirect(t_mini *mini, t_token *command, t_token *tok)
{
    if (!command)
        return ;
    if (tok && tok->type == PIPE)
    {
        create_pipe(mini);
        // 标记当前命令的stdout需要重定向到pipe_write
        mini->stdout_redirect = mini->pipe_write;
        // 标记下一个命令的stdin需要重定向到pipe_read
        mini->next_stdin_redirect = mini->pipe_read;
        tok = tok->next;
    }
    // 其余重定向逻辑保持不变...
}

• 管道链中的所有命令会并行启动，ls无需等待前面的cat进程即可执行，即时输出结果。
• 父进程统一管理管道FD，避免因FD未关闭导致的阻塞问题。
• 所有子进程执行完毕后父进程才会返回，不会产生僵尸进程，且能正确收集最后一个命令的退出状态，不影响后续命令执行。

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