C语言信号异常：kill函数执行顺序问题及VSCode信号调试方法

相关代码 #

struct job_t {              /* The job struct */
    pid_t pid;              /* job PID */
    int jid;                /* job ID [1, 2, ...] */
    int state;              /* UNDEF, BG, FG, or ST */
    char cmdline[MAXLINE];  /* command line */
};
struct job_t jobs[MAXJOBS]; /* The job list */

/* clearjob - Clear the entries in a job struct */
void clearjob(struct job_t *job) {
    job->pid = 0;
    job->jid = 0;
    job->state = UNDEF;
    job->cmdline[0] = '\0';
}

/* initjobs - Initialize the job list */
void initjobs(struct job_t *jobs) {
    int i;

    for (i = 0; i < MAXJOBS; i++)
    clearjob(&jobs[i]);
}

/* deletejob - Delete a job whose PID=pid from the job list */
int deletejob(struct job_t *jobs, pid_t pid) 
{
    int i;

    if (pid < 1)
    return 0;

    for (i = 0; i < MAXJOBS; i++) {
    if (jobs[i].pid == pid) {
        clearjob(&jobs[i]);
        nextjid = maxjid(jobs)+1;
        return 1;
    }
    }
    return 0;
}

/* fgpid - Return PID of current foreground job, 0 if no such job */
pid_t fgpid(struct job_t *jobs) {
    int i;

    for (i = 0; i < MAXJOBS; i++)
    if (jobs[i].state == FG)
        return jobs[i].pid;
    return 0;
}


/*********************functions above for prepare***********************/


/* 
 * waitfg - Block until process pid is no longer the foreground process
 */
void waitfg(pid_t pid)
{   
    sigset_t mask, prev, emp;
    sigfillset(&mask);

    sigprocmask(SIG_BLOCK, &mask, &prev);
    
    while (fgpid(jobs) == pid) {
        printf("waitfg\n");
        sigsuspend(&prev);  /* Just wait for a signal */
    }
        
    sigprocmask(SIG_SETMASK, &prev, NULL);
    return;
}


/* 
 * sigint_handler - The kernel sends a SIGINT to the shell whenver the
 *    user types ctrl-c at the keyboard.  Catch it and send it along
 *    to the foreground job.  
 */
void sigint_handler(int sig) 
{   
    int olderrno = errno;
    pid_t pid;

    pid = fgpid(jobs);
    if (pid == 0)
        return; /* Seem always return here */

    /* Just print something */
    Sio_puts("sigint runned: ");    /* But never print ? */
    Sio_putl((long) pid);
    Sio_puts("\n");

    kill(pid, SIGINT);


    errno = olderrno;    
    return;
}

/* 
 * sigchld_handler - The kernel sends a SIGCHLD to the shell whenever
 *     a child job terminates (becomes a zombie), or stops because it
 *     received a SIGSTOP or SIGTSTP signal. The handler reaps all
 *     available zombie children, but doesn't wait for any other
 *     currently running children to terminate.  
 */
void sigchld_handler(int sig) 
{
    int olderrno = errno;
    sigset_t mask_all, prev_all;
    pid_t pid;

    sigfillset(&mask_all);
    while ((pid = waitpid(-1, NULL, 0)) > 0) {  /* Reap child */
        sigprocmask(SIG_BLOCK, &mask_all, &prev_all);
        if (!deletejob(jobs, pid))
            Sio_puts("warning!: deletejob return 0\n");
        sigprocmask(SIG_SETMASK, &prev_all, NULL);
    }
    if (errno != ECHILD)
        Sio_error("waitpid error");
    errno = olderrno;
    return;
}

问题描述 #

1. 预期代码按逻辑执行，但实际sigint_handler中调用fgpid(jobs)得到的pid始终为0，导致后续打印语句和kill(pid, SIGINT)从未执行，与预期不符；
2. 移除sigint_handler中的if (pid == 0) return;语句后，程序无限循环打印“sigint runned: 0”；
3. 希望了解如何在VSCode中调试这类信号相关问题。

问题原因与解决方法 #

问题1、2的核心原因 #

1. 作业列表维护缺失：fgpid返回0说明jobs数组中没有标记为FG（前台）的作业项。大概率是启动前台作业的代码中，没有将子进程的PID、状态正确写入jobs数组——比如fork+exec后，未找到空闲的job项，或未将其state设为FG、pid设为子进程PID。
2. 无限循环的根源：当pid=0时调用kill(0, SIGINT)，会给当前进程组的所有进程发送SIGINT信号，而shell本身也属于该进程组，因此会再次触发sigint_handler，形成死循环。

修复步骤 #

1. 补全前台作业初始化逻辑：在启动前台作业的代码中（你提供的代码未包含这部分），必须完成以下操作：
   • 遍历jobs数组找到空闲项（state=UNDEF）；
   • 将该项的pid设为子进程PID，state设为FG，并填充cmdline等字段；
   • 确保nextjid和maxjid逻辑正常，正确分配作业ID。
2. 修复sigchld_handler的waitpid调用：当前代码中waitpid(-1, NULL, 0)会阻塞等待子进程终止，无法处理子进程暂停的情况，且可能导致shell卡住。应改为：

   int status;
   while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
       sigprocmask(SIG_BLOCK, &mask_all, &prev_all);
       if (WIFEXITED(status) || WIFSIGNALED(status)) {
           // 进程终止，删除作业
           if (!deletejob(jobs, pid))
               Sio_puts("warning!: deletejob return 0\n");
       } else if (WIFSTOPPED(status)) {
           // 进程暂停，更新状态为ST
           for (int i = 0; i < MAXJOBS; i++) {
               if (jobs[i].pid == pid) {
                   jobs[i].state = ST;
                   break;
               }
           }
       }
       sigprocmask(SIG_SETMASK, &prev_all, NULL);
   }
   

   这样可以非阻塞地回收终止的子进程，同时处理暂停的子进程，避免作业状态异常。
3. 保留if (pid == 0) return;判断：这是防止无限循环的关键，同时必须先修复作业列表的维护问题，确保fgpid能正确返回前台进程PID。

VSCode调试信号相关问题的方法 #

1. 配置调试环境 #

在.vscode/launch.json中添加或修改配置，确保信号能正确传递给程序：

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "C/C++: 你的程序名称",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/你的可执行文件路径",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": true, // 使用外部终端，避免调试器拦截SIGINT
            "MIMode": "gdb",
            "setupCommands": [
                {
                    "text": "handle SIGINT stop print", // 触发SIGINT时暂停程序并打印信息
                    "description": "处理SIGINT信号"
                },
                {
                    "text": "handle SIGCHLD stop print", // 可选，跟踪SIGCHLD触发时机
                    "description": "处理SIGCHLD信号"
                }
            ]
        }
    ]
}

2. 断点调试技巧 #

• 在sigint_handler、fgpid、waitfg函数内部设置断点，触发SIGINT时程序会自动暂停，查看jobs数组的内容，确认是否有状态为FG的作业项；
• 在启动前台作业的代码中设置断点，检查是否正确将作业信息写入jobs数组；
• 使用调试控制台的print命令查看变量，比如输入print jobs可以查看整个作业列表的状态。

3. 避免调试器拦截信号 #

默认情况下，VSCode的调试器会拦截SIGINT用于终止调试会话，开启externalConsole: true后，程序会在独立终端运行，按Ctrl+C时信号会直接发给程序，便于测试信号处理逻辑。

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