
As interrupções de software em sistemas Linux e Unix são feitas por meio de sinais. Existem muitos sinais diferentes do Linux, mas alguns se destacam e são importantes para entender e saber: SIGINT, SIGTERM e SIGKILL. Veja como eles funcionam.
O que é uma Linux Signal?
Todos nós entendemos que uma luz vermelha significa que temos que parar de andar ou dirigir. Da mesma forma, em sistemas Linux e Unix, pode-se passar um sinal para um programa ou serviço em execução para interagir com ele. Por exemplo, alguém poderia enviar um sinal de semáforo vermelho para um programa simplesmente emitindo um SIGTERM sinal.
Assim como com um semáforo vermelho, as pessoas podem optar por continuar a andar ou dirigir quando o semáforo estiver vermelho. Embora possa não ser uma ideia segura para todos os envolvidos, um SIGTERM o sinal enviado a um processo fará exatamente isso; o processo / programa pode escolher ignorar tal sinal.
Todos os sinais básicos do Linux têm um número (1-30 +). Depois de um tempo, um usuário experiente do Linux geralmente conhece um ou mais deles. Por exemplo, o SIGTERM o sinal corresponde ao número 15 e o sinal 9 (SIGKILL) é provavelmente o mais conhecido, pois permite encerrar um processo à força, ao contrário de nosso SIGTERM exemplo de luz vermelha.

Aqui vemos a tela principal do htop (você pode instalar este útil utilitário digitando sudo apt install htop no Ubuntu / Mint ou sudo yum install htop no RedHat / Centos / Fedora) com vários sinais de terminação e outros (mais abaixo na lista; são 37 no total) que podem ser enviados para um processo previamente selecionado à direita. Pode-se selecionar um processo pressionando o cursor para cima / para baixo e enviar um sinal usando F9.
SIGKILL & SIGTERM
Embora o nome possa soar um pouco sinistro, o jargão comum do Linux para término de processo é que alguém 'mata' um processo. De um modo geral, queremos apenas encerrar um processo com um -9 (SIGKILL) sinalizar se tal processo / programa estiver travando. Observe que sempre que falamos de processo ou programa, as palavras podem ser trocadas à vontade. Basicamente, um processo é qualquer programa (ou serviço) em execução que tenha recebido um PID (um identificador de processo).
Vejamos um exemplo de encerramento de um processo em execução em segundo plano usando um SIGKILL sinalizar para o processo em execução. Observe que, conforme explicado SIGKILL é bastante destrutivo e encerrará o processo, independentemente do que ele gostaria de fazer com o sinal. Vários sinais podem ser capturados e redirecionados pelo processo, enquanto outros não.

Aqui começamos um sleep 1800 no fundo (usando & no final do comando), que foi iniciado como o primeiro ([1]) processo em segundo plano com PID 574660. Posteriormente, eliminamos esse processo em segundo plano usando kill -9 574660, onde o -9 apoia SIGKILL.
Embora o processo seja encerrado imediatamente, não vemos a mensagem de encerramento (processo em segundo plano 1 morto, ou seja, [1]+ Killed), pois o prompt de comando retorna antes que a mensagem seja exibida, ou seja, retornar a linha de comando foi uma operação mais rápida do que o encerramento do processo ou semelhante.
Nós verificamos a lista de processos por grep para o PID ps -ef | grep 574660. Embora haja alguma saída, a saída mostrada é apenas para o nosso funcionamento grep comando; a sleep processo já foi encerrado.
Vamos avaliar o mesmo com SIGTERM, ie kill -15 ${PID} Onde ${PID} é o processo que queremos encerrar.

Tivemos que pressionar enter para acionar / mostrar a mensagem de encerramento (conforme explicado acima). Podemos ver que o programa foi encerrado corretamente novamente. No entanto, desta vez, embora invisível para este exemplo específico (continue lendo!), Internamente dentro do sleep código do programa, as coisas foram um pouco diferentes.
Neste caso (usando -15 ie SIGTERM para encerrar o processo), o sleep processo foi notificado e teve a oportunidade de lidar internamente com o sinal. Ele poderia, subsequentemente, responder por terminação automática, ignorando o sinal ou por qualquer outra ação desenvolvida no código. Também podemos provar que isso é verdade verificando o sinal de saída e / ou saída:

Aqui começamos o processo sleep 2000 duas vezes e, em seguida, usou outra sessão de shell / terminal para encerrar o programa. Na primeira vez, usamos kill -9 e a segunda vez que usamos kill -15 para parar o sleep processar.
Notamos imediatamente como a saída retorna Killed em primeiro (kill -9 ação) instância. Para a segunda tentativa (usando kill -15), vemos a saída Terminated em vez de; o programa se encerrou automaticamente. Após as respectivas terminações, também verificamos os sinais de saída e descobrimos que os códigos de saída eram diferentes.
Por que isso é importante? Considere programas maiores; neste caso, estávamos apenas encerrando um simples sleep comando. Não havia dados sendo tratados, nenhum tráfego sendo enviado para frente e para trás, etc. Mas o que aconteceria se enviássemos um kill -9 para o nosso servidor de banco de dados (em geral, isso exigiria privilégios de nível sudo / root)?
Isso faria com que o banco de dados entrasse no modo de recuperação de falha na próxima vez que fosse inicializado porque, pelo que o software de banco de dados sabe, tudo o que aconteceu foi “estava lá” seguido de “nada”. Em outras palavras, ele travou. Se tivéssemos emitido um kill -15 comando, o software de banco de dados poderia ter feito um desligamento controlado, por exemplo, primeiro bloqueando a conexão de novos usuários, em seguida, desconectando / encerrando usuários existentes e, em seguida, concluindo a gravação de dados, etc., antes de finalmente encerrar automaticamente.
Envio de sinais do Linux com sequências de teclado
Você sabia que sempre que enviava um CTRL+c sequência de teclas para um programa em execução, por exemplo, em um terminal, que em vez de um SIGINT é enviado? Vamos voltar ao nosso confiável sleep comando e teste isto:

Aqui começamos sleep novamente e, em seguida, pressionou a combinação do teclado CTRL+c. O programa foi encerrado, ou melhor foi interrompida pelo SIGINT sinal que foi enviado. Solicitamos o código de saída e confirmamos que mais uma vez o código de saída é diferente dos sinais anteriores.
Observe que este código de saída, para dormir, sempre será combinado com o sinal enviado, embora potencialmente nem todos os sinais possam ser cobertos. Em outras palavras, ao usar CTRL+c na linha de comando, o código de saída será sempre 130, 137 quando morto com kill -9, e 143 quando kill -15 foi usado.
Você pode testar códigos de saída para comandos consultando o $? variável, que contém o código de saída do comando anterior (desde que você não tenha iniciado um novo comando). Saber o código de saída de um determinado comando em uma situação particular e / ou como resultado de um determinado sinal enviado para esse comando ajuda a criar scripts de soluções que tratam de outros processos, etc. (que é o caso de muitos scripts de shell, especialmente ao gerenciar servidores ou ambientes automatizados).
Outra sequência de teclado frequentemente usada é CTRL+z. Isso vai enviar um SIGTSTP sinal, um suspend sinal que imediatamente coloca um processo em suspensão até (por exemplo) um 'fg' comando é emitido para o mesmo processo que o trará de volta para o primeiro plano.
Para saber mais sobre gerenciamento de processos, consulte Bash Process Termination Hacks.
Empacotando
Neste artigo, vimos os sinais mais importantes do Linux e como podemos usá-los na prática em um ambiente Linux ou Unix. Conhecer os sinais básicos do Linux ajuda no uso e gerenciamento diário do Linux, por exemplo, quando um processo está travado e precisa ser encerrado com kill -9. Em um artigo futuro, podemos analisar a captura de um sinal usando o trap comando de dentro de um script Bash, permitindo definir um procedimento personalizado a ser executado quando tal sinal for emitido.
Se você gostou de ler este artigo, dê uma olhada em nossa série de automação Bash começando em Bash Automation & Scripting Basics. No terceiro artigo dessa série, também discutimos o gerenciamento de processos em segundo plano, abordado anteriormente neste artigo.



