Linux下C语言作业控制Shell中SIGCHLD处理器误删进程问题

Let's dive into why your SIGCHLD handler is incorrectly deleting nodes for running processes, and how to fix it:

核心问题1：未正确处理waitpid()的返回值 #

Your current code calls waitpid() with WNOHANG and immediately checks WIFEXITED(process_status)—but here's the catch: when waitpid() returns 0, that means the target process hasn't exited yet. In this case, the process_status variable is uninitialized (or holds leftover data from previous calls), so WIFEXITED() will return a random value (sometimes non-zero) leading you to incorrectly mark the process as exited and delete its node.

You must always check the return value of waitpid() first:

• A return value > 0: the process with that PID has changed state, and process_status is valid.
• A return value == 0: no state change for the target process.
• A return value == -1: error (e.g., no more child processes to wait for).

核心问题2：遍历链表逐个waitpid的逻辑不合理 #

A single SIGCHLD signal can be triggered by multiple child processes exiting at the same time. Your current approach iterates through every job in the list and calls waitpid() on each—this is inefficient, and might miss some exited processes (or waste time checking running ones). Instead, you should loop calling waitpid(-1, ...) to catch all exited/suspended child processes in one go, then look up their corresponding nodes in the job list.

修复后的代码示例 #

Here's a revised version of your handler that fixes these issues, plus some additional best practices:

#include <signal.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <stdio.h>

// 假设你的job_state枚举定义是这样的
typedef enum {
    JOB_RUNNING,
    JOB_SUSPENDED,
    JOB_EXITED
} job_state;

typedef struct job_ {
    pid_t pgid;
    char *command;
    enum job_state state;
    struct job_ *next;
} job;

job *job_list; // 假设这是你的作业链表头节点

// 假设block_SIGCHLD和unblock_SIGCHLD是正确实现的信号阻塞函数
void block_SIGCHLD();
void unblock_SIGCHLD();

void mySIGCHLD_Handler(int signum) {
    block_SIGCHLD();
    if (signum == SIGCHLD) { // 使用宏代替硬编码17，提升可移植性
        int process_status;
        pid_t pid;

        // 循环捕获所有状态变化的子进程，直到没有更多
        while ((pid = waitpid(-1, &process_status, WNOHANG | WUNTRACED)) > 0) {
            job *current = job_list->next;
            job *prev = job_list;
            // 在链表中找到对应PGID的作业
            while (current) {
                if (current->pgid == pid) {
                    if (WIFEXITED(process_status) || WIFSIGNALED(process_status)) {
                        // 进程正常退出或被信号终止，删除节点
                        prev->next = current->next;
                        printf("Process #%d (%s) deleted from job list\n", pid, current->command);
                        // 记得释放内存，避免泄漏
                        free(current->command);
                        free(current);
                    } else if (WIFSTOPPED(process_status)) {
                        // 进程被暂停，更新状态而不是删除
                        current->state = JOB_SUSPENDED;
                        printf("Process #%d (%s) suspended\n", pid, current->command);
                    }
                    break;
                }
                prev = current;
                current = current->next;
            }
        }
    }
    unblock_SIGCHLD();
}

额外注意事项 #

• Avoid hardcoding signal numbers: Use SIGCHLD instead of 17—signal numbers can vary across different Unix-like systems.
• Memory management: Don't forget to free the command string and the job node itself when deleting, otherwise you'll have memory leaks.
• Handle suspended processes: Your original code didn't account for stopped processes (e.g., via Ctrl+Z). The WUNTRACED flag in waitpid() lets you catch these, and you should update the job's state instead of deleting it.
• Signal safety: Make sure any functions you call in the handler (like printf) are async-signal-safe. printf is technically not fully async-safe, but in practice it's often used in shell handlers—if you want to be strictly compliant, you could use write() instead.

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