C Sinais (signal)

Você aperta Ctrl+C e o programa para. Um programa lê um ponteiro nulo e morre com "Falha de segmentação". O computador vai desligar e avisa os programas para fecharem. Em todos esses casos, quem avisa o programa é um sinal: uma mensagem curtinha que o sistema operacional entrega a um programa que está rodando, interrompendo o que ele estiver fazendo. Nesta aula você vai conhecer os sinais mais comuns, entender os códigos de saída 130, 137, 139 e 143, e fazer o seu programa responder a um sinal, por exemplo salvando o trabalho antes de sair quando o usuário aperta Ctrl+C.

Todos os programas foram compilados com o gcc 15.2 na máquina fictícia da Ana (usuária ana, computador notebook), na pasta ~/c/sinais, com gcc -std=c23 -Wall -Wextra arquivo.c -o programa. Os sinais existem em todo Linux e macOS; no Windows, só uma parte deles (para seguir esta aula no Windows, use o WSL: aula Instalar no Windows e no Mac).

A ideia: a campainha da casa

A Ana está cozinhando. A campainha toca. Ela tem três escolhas:

• Fazer o de sempre: largar tudo e ir atender. É a ação padrão do sinal; para a maioria dos sinais, o padrão é terminar o programa.
• Ignorar: continuar cozinhando como se nada tivesse acontecido.
• Ter um combinado: "se tocar, desligo o fogão primeiro e depois atendo". É um tratador (em inglês, handler): uma função sua que roda quando o sinal chega.

E existe um toque que não dá para ignorar: os bombeiros arrombando a porta. Esse é o SIGKILL, que nenhum programa consegue tratar nem ignorar.

1. Os sinais que você já viu

Cada sinal tem um número e um nome que começa com SIG (de signal, sinal). O comando kill -l ("list", listar) do terminal mostra todos; as três primeiras linhas têm os mais conhecidos:

$ kill -l | head -3
 1) SIGHUP	 2) SIGINT	 3) SIGQUIT	 4) SIGILL	 5) SIGTRAP
 6) SIGABRT	 7) SIGBUS	 8) SIGFPE	 9) SIGKILL	10) SIGUSR1
11) SIGSEGV	12) SIGUSR2	13) SIGPIPE	14) SIGALRM	15) SIGTERM

Quando um programa morre por causa de um sinal, o terminal (o Bash) mostra o código de saída 128 + o número do sinal. Você já encontrou vários deles nas aulas anteriores:

Os números da tabela são os do Linux. Só seis sinais fazem parte do C padrão (SIGINT, SIGTERM, SIGABRT, SIGFPE, SIGSEGV e SIGILL); os outros vêm do POSIX. No código, use sempre os nomes, nunca os números.

2. raise: mandar um sinal para si mesmo

O jeito mais simples de ver um sinal funcionando é o programa mandar um para ele mesmo, com raise ("levantar", erguer a mão), do cabeçalho <signal.h>:

#include <stdio.h>
#include <signal.h>

int main(void) {
    printf("Antes do sinal.\n");
    raise(SIGTERM);
    printf("Depois do sinal.\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra raise.c -o raise
$ ./raise
Antes do sinal.
Terminado                  ./raise
$ echo $?
143

O raise(SIGTERM) entregou o sinal na hora. Como o programa não disse o que fazer com ele, valeu a ação padrão do SIGTERM: terminar. O "Depois do sinal" nunca apareceu, o return 0 nunca rodou, e o Bash avisou Terminado com o código 143 (128 + 15).

#include <stdio.h>
#include <signal.h>

int main(void) {
    printf("Antes do sinal.\n");
    raise(SIGTERM);
    printf("Depois do sinal.\n");
    return 0;
}

3. O Ctrl+C é um sinal

Este programa trabalha por 10 segundos, mostrando cada segundo:

#include <stdio.h>
#include <unistd.h>

int main(void) {
    for (int s = 1; s <= 10; s++) {
        printf("Trabalhando... %d s\n", s);
        sleep(1);
    }
    printf("Terminei!\n");
    return 0;
}

O sleep(1), do <unistd.h> (POSIX), faz o programa dormir 1 segundo. A Ana roda e, no segundo 2, perde a paciência e aperta Ctrl+C (o terminal mostra ^C):

$ gcc -std=c23 -Wall -Wextra contar.c -o contar
$ ./contar
Trabalhando... 1 s
Trabalhando... 2 s
^C
$ echo $?
130

Quando você aperta Ctrl+C, quem mata o programa não é o teclado: o terminal manda o sinal SIGINT ao programa que está rodando, e a ação padrão do SIGINT é terminar. O código 130 é 128 + 2. Para um contador, tudo bem. Mas e se o programa estivesse no meio de gravar a lista de compras? O arquivo ficaria pela metade.

4. signal: o seu tratador

Com signal, você diz ao sistema "quando chegar este sinal, chame esta função". O jeito seguro de usar é o tratador só anotar que o sinal chegou, e o programa principal decidir com calma o que fazer:

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

volatile sig_atomic_t parar = 0;

void pedir_parada(int sinal) {
    (void) sinal;
    parar = 1;
}

int main(void) {
    signal(SIGINT, pedir_parada);

    int s = 0;
    while (!parar && s < 10) {
        s++;
        printf("Trabalhando... %d s\n", s);
        sleep(1);
    }

    if (parar) {
        printf("\nRecebi o Ctrl+C. Salvando a lista antes de sair...\n");
    }
    printf("Tchau!\n");
    return 0;
}

volatile sig_atomic_t parar = 0;

A "anotação". Uma variável global, para o tratador e o main enxergarem a mesma. sig_atomic_t é um inteiro que o processador lê e escreve de uma vez só, sem o sinal poder chegar "no meio" da escrita; volatile obriga o laço a reler a variável a cada volta (sem ele, com -O2, o laço pode nunca ver a mudança: aula volatile e restrict).

void pedir_parada(int sinal)

O tratador. Tem de ter exatamente este formato: recebe um int (o número do sinal que chegou) e não devolve nada.

(void) sinal;

"Sei que não uso este parâmetro." Sem isso, o -Wextra avisa unused parameter.

parar = 1;

Tudo o que o tratador faz. Curto de propósito (a próxima seção explica).

signal(SIGINT, pedir_parada)

Instala o tratador: daqui em diante, um SIGINT chama pedir_parada em vez de matar o programa. Repare que é o nome da função, sem parênteses: você passa a função, não a chama (aula Ponteiros para Funções).

while (!parar && s < 10)

O laço confere a anotação a cada volta.

if (parar)

Fora do tratador, com calma, o programa faz o que precisa: salvar, fechar arquivos, avisar.

$ gcc -std=c23 -Wall -Wextra tratador.c -o tratador
$ ./tratador
Trabalhando... 1 s
Trabalhando... 2 s
Trabalhando... 3 s
^C
Recebi o Ctrl+C. Salvando a lista antes de sair...
Tchau!
$ echo $?
0

O mesmo Ctrl+C, outro final: o programa terminou do jeito dele, com código 0. E a mensagem apareceu na hora, sem esperar o segundo acabar: quando um sinal chega e é tratado, o sleep é interrompido e volta mais cedo.

O que um tratador pode fazer

O sinal pode chegar em qualquer instante: até no meio de um printf ou de um malloc do programa principal. Se o tratador chamar printf nessa hora, as duas chamadas mexem nas mesmas estruturas internas ao mesmo tempo, e o resultado pode ser texto embaralhado ou o programa travado para sempre. O padrão C só garante um punhado de coisas dentro de um tratador:

5. kill: mandar sinais de fora

Qualquer programa pode receber sinais de outro programa. No terminal, quem manda é o comando kill (o nome é "matar", mas ele manda qualquer sinal). Ele precisa do PID ("process ID", o número do processo; aula Processos). Este programa simula o caixa da lojinha: ele fica esperando, e qualquer SIGINT ou SIGTERM o faz fechar com calma.

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

volatile sig_atomic_t sinal_recebido = 0;

void anotar(int sinal) {
    sinal_recebido = sinal;
}

int main(void) {
    signal(SIGINT, anotar);
    signal(SIGTERM, anotar);
    printf("Caixa da loja aberto (PID %d).\n", (int) getpid());

    while (sinal_recebido == 0) {
        sleep(1);
    }

    printf("Chegou o sinal %d. Fechando o caixa com calma.\n", (int) sinal_recebido);
    return 0;
}

sinal_recebido = sinal;

O mesmo tratador para os dois sinais. Agora o parâmetro é usado: ele diz qual sinal chegou.

getpid()

"Get process ID": o número deste processo, que o kill precisa.

while (sinal_recebido == 0) { sleep(1); }

Espera, dormindo de segundo em segundo, até chegar um sinal.

Na vida real, a Ana deixaria o caixa rodando num terminal e mandaria o kill de outro. Aqui, para caber numa linha só: o & roda o programa "em segundo plano", o $! é o PID dele, e o wait espera ele terminar e devolve o código de saída.

$ gcc -std=c23 -Wall -Wextra loja.c -o loja
$ ./loja & sleep 1; kill -TERM $!; wait $!; echo "código: $?"
[1] 4
Caixa da loja aberto (PID 4).
Chegou o sinal 15. Fechando o caixa com calma.
[1]+  Concluído                 ./loja
código: 0
$ ./loja & sleep 1; kill -INT $!; wait $!; echo "código: $?"
[1] 6
Caixa da loja aberto (PID 6).
Chegou o sinal 2. Fechando o caixa com calma.
[1]+  Concluído                 ./loja
código: 0
$ ./loja & sleep 1; kill -KILL $!; wait $!; echo "código: $?"
[1] 8
Caixa da loja aberto (PID 8).
[1]+  Morto                      ./loja
código: 137

Com SIGTERM e SIGINT, o tratador anotou e o caixa fechou com calma (código 0). Com SIGKILL, o tratador nem foi chamado: o sistema removeu o programa na hora (Morto, 137). É por isso que os administradores tentam primeiro kill PID (que manda SIGTERM, o pedido educado) e só depois, se o programa não sair, kill -9 PID (o SIGKILL).

O programa contar.c, que não tem tratador, morre com o kill comum:

$ ./contar & sleep 2.5; kill $!; wait $!; echo "código: $?"
[1] 12
Trabalhando... 1 s
Trabalhando... 2 s
Trabalhando... 3 s
[1]+  Terminado                  ./contar
código: 143

6. Ignorar e voltar ao padrão: SIG_IGN e SIG_DFL

No lugar de uma função, o signal aceita dois valores especiais:

• SIG_IGN ("ignore"): ignorar o sinal, como se nunca tivesse chegado;
• SIG_DFL ("default"): voltar à ação padrão.

#include <stdio.h>
#include <signal.h>

int main(void) {
    signal(SIGINT, SIG_IGN);
    printf("Vou mandar um Ctrl+C para mim mesmo...\n");
    raise(SIGINT);
    printf("Ainda estou aqui!\n");

    signal(SIGINT, SIG_DFL);
    printf("Agora de novo, com o comportamento padrão...\n");
    raise(SIGINT);
    printf("Esta linha não aparece.\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra ignorar.c -o ignorar
$ ./ignorar
Vou mandar um Ctrl+C para mim mesmo...
Ainda estou aqui!
Agora de novo, com o comportamento padrão...

$ echo $?
130

Ignorar o Ctrl+C serve, por exemplo, num programa que está gravando algo que não pode ser interrompido: ignore durante a gravação e volte ao padrão no fim. Mas cuidado: o usuário fica sem o jeito mais fácil de parar o programa.

SIGKILL e SIGSTOP não podem ser tratados

Imagine um programa com defeito que ignora todos os sinais: ninguém conseguiria pará-lo. Por isso o sistema reserva dois sinais que nenhum programa pode tratar nem ignorar: SIGKILL (matar) e SIGSTOP (pausar). Quem tenta recebe um erro:

#include <stdio.h>
#include <signal.h>

void anotar(int sinal) {
    (void) sinal;
}

int main(void) {
    if (signal(SIGKILL, anotar) == SIG_ERR) {
        perror("signal(SIGKILL)");
    }
    if (signal(SIGTERM, anotar) == SIG_ERR) {
        perror("signal(SIGTERM)");
    } else {
        printf("SIGTERM: tratador instalado.\n");
    }
    return 0;
}

$ gcc -std=c23 -Wall -Wextra sigkill.c -o sigkill
$ ./sigkill
signal(SIGKILL): Invalid argument
SIGTERM: tratador instalado.

Quando falha, o signal devolve SIG_ERR e põe o motivo em errno: aqui, EINVAL, "argumento inválido" (aula errno e perror). O editor do guia dá a mesma resposta.

#include <stdio.h>
#include <signal.h>

int main(void) {
    signal(SIGINT, SIG_IGN);
    printf("Vou mandar um Ctrl+C para mim mesmo...\n");
    raise(SIGINT);
    printf("Ainda estou aqui!\n");

    signal(SIGINT, SIG_DFL);
    printf("Agora de novo, com o comportamento padrão...\n");
    raise(SIGINT);
    printf("Esta linha não aparece.\n");
    return 0;
}

7. O signal pode esquecer o tratador: sigaction

O signal é do C padrão desde 1989, e o padrão deixou um detalhe em aberto: depois de chamar o tratador uma vez, o sistema pode voltar o sinal ao padrão. Cada biblioteca escolheu um jeito. Veja este programa, que conta quantos SIGINT recebeu:

#include <stdio.h>
#include <signal.h>

volatile sig_atomic_t vezes = 0;

void contar(int sinal) {
    (void) sinal;
    vezes++;
}

int main(void) {
    signal(SIGINT, contar);
    raise(SIGINT);
    printf("Depois do 1º sinal: vezes = %d\n", (int) vezes);
    raise(SIGINT);
    printf("Depois do 2º sinal: vezes = %d\n", (int) vezes);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra duas.c -o duas
$ ./duas
Depois do 1º sinal: vezes = 1

$ echo $?
130
$ gcc -Wall -Wextra duas.c -o duas-gnu        « sem o -std=c23
$ ./duas-gnu
Depois do 1º sinal: vezes = 1
Depois do 2º sinal: vezes = 2

Com -std=c23 (C puro), a glibc segue o comportamento antigo do Unix: o tratador vale uma vez só, e o segundo SIGINT matou o programa. Sem o -std, o gcc usa o modo "GNU", e a glibc mantém o tratador. No editor do guia (outra biblioteca C), o tratador também fica: o programa mostra as duas linhas. O mesmo código, três comportamentos possíveis, todos permitidos pelo padrão.

A solução do POSIX é o sigaction ("signal action", a ação do sinal), que existe em todo Linux e macOS e se comporta igual em todos:

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <signal.h>

volatile sig_atomic_t vezes = 0;

void contar(int sinal) {
    (void) sinal;
    vezes++;
}

int main(void) {
    struct sigaction acao = {0};
    acao.sa_handler = contar;
    sigemptyset(&acao.sa_mask);
    sigaction(SIGINT, &acao, NULL);

    raise(SIGINT);
    printf("Depois do 1º sinal: vezes = %d\n", (int) vezes);
    raise(SIGINT);
    printf("Depois do 2º sinal: vezes = %d\n", (int) vezes);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra duas2.c -o duas2
$ ./duas2
Depois do 1º sinal: vezes = 1
Depois do 2º sinal: vezes = 2

O sigaction não existe no editor do guia (a biblioteca dele só tem signal e raise): lá, struct sigaction dá error: variable has incomplete type 'struct sigaction'. Por isso as caixas desta aula usam signal, com um sinal só por tratador.

signal ou sigaction: qual usar?

Quando dá errado

$ gcc -std=c23 -Wall -Wextra assinatura.c -o assinatura
assinatura.c: In function ‘main’:
assinatura.c:9:20: error: passing argument 2 of ‘signal’ from incompatible pointer type [-Wincompatible-pointer-types]
    9 |     signal(SIGINT, tratar);
      |                    ^~~~~~
      |                    |
      |                    void (*)(void)
In file included from /usr/include/features.h:539,
                 from /usr/include/x86_64-linux-gnu/bits/libc-header-start.h:33,
                 from /usr/include/stdio.h:28,
                 from assinatura.c:1:
/usr/include/signal.h:93:23: note: expected ‘__sighandler_t’ {aka ‘void (*)(int)’} but argument is of type ‘void (*)(void)’
   93 | extern __sighandler_t __REDIRECT_NTH (signal,
      |                       ^~~~~~~~~~~~~~
assinatura.c:4:6: note: ‘tratar’ declared here
    4 | void tratar(void) {
      |      ^~~~~~
In file included from assinatura.c:2:
/usr/include/signal.h:72:16: note: ‘__sighandler_t’ declared here
   72 | typedef void (*__sighandler_t) (int);
      |                ^~~~~~~~~~~~~~

$ gcc -std=c23 -Wall -Wextra semvoid.c -o semvoid
semvoid.c: In function ‘pedir_parada’:
semvoid.c:5:23: warning: unused parameter ‘sinal’ [-Wunused-parameter]
    5 | void pedir_parada(int sinal) {
      |                   ~~~~^~~~~

Referência rápida

Exercícios

Missão final: fechar o caixa com calma

Atendendo o pedido 1
Atendendo o pedido 2
Atendendo o pedido 3
Recebi SIGTERM. Salvei os pedidos antes de sair.
Caixa fechado.

#include <stdio.h>
#include <signal.h>

volatile sig_atomic_t parar = 0;

void pedir_parada(int sinal) {
    (void) sinal;
    parar = 1;
}

int main(void) {
    // instale o tratador aqui

    for (int pedido = 1; pedido <= 5 && !parar; pedido++) {
        printf("Atendendo o pedido %d\n", pedido);
        if (pedido == 3) {
            raise(SIGTERM);       // alguém pediu para o programa parar
        }
    }

    if (parar) {
        printf("Recebi SIGTERM. Salvei os pedidos antes de sair.\n");
    }
    printf("Caixa fechado.\n");
    return 0;
}

#include <stdio.h>
#include <signal.h>

volatile sig_atomic_t parar = 0;

void pedir_parada(int sinal) {
    (void) sinal;
    parar = 1;
}

int main(void) {
    // instale o tratador aqui
    signal(SIGTERM, pedir_parada);

    for (int pedido = 1; pedido <= 5 && !parar; pedido++) {
        printf("Atendendo o pedido %d\n", pedido);
        if (pedido == 3) {
            raise(SIGTERM);       // alguém pediu para o programa parar
        }
    }

    if (parar) {
        printf("Recebi SIGTERM. Salvei os pedidos antes de sair.\n");
    }
    printf("Caixa fechado.\n");
    return 0;
}

No terminal da Ana, a solução dá a mesma saída:

$ gcc -std=c23 -Wall -Wextra pedidos.c -o pedidos
$ ./pedidos
Atendendo o pedido 1
Atendendo o pedido 2
Atendendo o pedido 3
Recebi SIGTERM. Salvei os pedidos antes de sair.
Caixa fechado.

Resumo

• Um sinal é um aviso do sistema a um programa: SIGINT (Ctrl+C), SIGTERM (pedido para terminar), SIGKILL (morte imediata), SIGSEGV, SIGABRT, SIGFPE.
• Morto por um sinal, o programa termina com o código 128 + o número: 130, 134, 136, 137, 139, 143.
• raise(sinal) manda um sinal para o próprio programa; o comando kill manda para outro, pelo PID.
• signal(sinal, tratador) instala uma função void f(int). O tratador só deve mudar uma variável volatile sig_atomic_t; o programa principal faz o resto.
• SIG_IGN ignora e SIG_DFL volta ao padrão. SIGKILL e SIGSTOP não podem ser tratados.
• O signal pode valer uma vez só (glibc com -std=c23); para tratar o mesmo sinal várias vezes no Linux e no macOS, use sigaction.
• No editor do guia: raise e os tratadores funcionam; sinais de fora e sigaction, não.