Обработка, блокировка и игнорирование сигналов

Три способа отреагировать

Для каждого сигнала у процесса есть диспозиция:

sigaction

Старая функция signal() ведёт себя по-разному в разных системах. Используйте sigaction:

#include <signal.h>
#include <string.h>
#include <unistd.h>

volatile sig_atomic_t got_int = 0;

void on_int(int sig)
{
    (void)sig;
    got_int = 1;                              /* только простые действия! */
    const char msg[] = "получен SIGINT\n";
    write(STDOUT_FILENO, msg, sizeof(msg) - 1); /* write безопасна в обработчике */
}

int main(void)
{
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = on_int;
    sigemptyset(&sa.sa_mask);     /* какие сигналы дополнительно блокировать во время обработчика */
    sa.sa_flags = SA_RESTART;     /* перезапускать прерванные системные вызовы */
    sigaction(SIGINT, &sa, NULL);

    while (!got_int)
        pause();                  /* ждать любой сигнал */
    return 0;
}

Во время выполнения обработчика сам сигнал автоматически блокируется (если не указан SA_NODEFER), плюс сигналы из sa_mask.

Флаги sa_flags

Правила для обработчиков

Обработчик может сработать в любой точке программы — даже посреди malloc или printf. Поэтому:

1. Вызывайте только async-signal-safe функции: write, _exit, kill, signal, sem_post, waitpid и другие из списка man 7 signal-safety. Нельзя: printf, malloc, free, exit.
2. Общие с программой переменные объявляйте volatile sig_atomic_t.
3. Сохраняйте и восстанавливайте errno, если вызываете функции, которые его меняют.
4. Лучшая стратегия — в обработчике только поставить флаг, а работу сделать в основном цикле.

Блокировка: маска сигналов

У каждого потока есть маска — множество заблокированных сигналов. Заблокированный сигнал не теряется: он остаётся ожидающим и будет доставлен сразу после снятия блокировки.

sigset_t set, old;
sigemptyset(&set);
sigaddset(&set, SIGINT);
sigprocmask(SIG_BLOCK, &set, &old);   /* SIG_BLOCK / SIG_UNBLOCK / SIG_SETMASK */
/* ... здесь SIGINT не прервёт ... */
sigprocmask(SIG_SETMASK, &old, NULL); /* если SIGINT пришёл — будет доставлен сейчас */

sigset_t pending;
sigpending(&pending);                 /* какие сигналы сейчас ждут */
if (sigismember(&pending, SIGINT)) { ... }

Блокировка ≠ игнорирование

Ожидание сигнала без гонок

Наивный код содержит гонку: сигнал может прийти между проверкой флага и pause(), и программа уснёт навсегда.

/* правильно: атомарно снять блокировку и уснуть */
sigset_t block, old;
sigemptyset(&block);
sigaddset(&block, SIGUSR1);
sigprocmask(SIG_BLOCK, &block, &old);
while (!got_usr1)
    sigsuspend(&old);         /* на время ожидания маска = old, SIGUSR1 разблокирован */
sigprocmask(SIG_SETMASK, &old, NULL);

Прерванные системные вызовы

Если сигнал пришёл, пока процесс спит в медленном вызове (read с терминала, wait, pause), после обработчика вызов вернёт −1 с errno = EINTR — если не установлен SA_RESTART.

ssize_t n;
do {
    n = read(fd, buf, sizeof buf);
} while (n == -1 && errno == EINTR);

Наследование

Поэтому nohup работает так: устанавливает SIG_IGN для SIGHUP и делает exec нужной программы.

Итог

• Диспозиции: SIG_DFL, SIG_IGN, обработчик; устанавливаются через sigaction.
• В обработчике — только async-signal-safe функции и volatile sig_atomic_t флаги.
• Блокировка (маска) откладывает доставку; игнорирование выбрасывает сигнал.
• SIGKILL и SIGSTOP нельзя заблокировать, игнорировать или перехватить.
• sigsuspend — ожидание без гонок; EINTR и SA_RESTART — для прерванных вызовов.