SIGINT, SIGTERT e SIGKILL: CLOUDSAVVY IT

As interrupções de software em sistemas Linux e Unix são feitas usando sinais. Existem muitos sinais diferentes do Linux, mas alguns se destacam e são importantes para entender e se familiarizar: SIGINT, SIGTERM e SIGKILL. É assim que eles funcionam.

índice

  1. O que é um selo Linux?
  2. SIGKILL & SIGTERM
  3. Enviando sinais do Linux com sequências de teclado
  4. Final

O que é um selo Linux?

Todos sabemos que uma luz vermelha significa que devemos parar de andar ou dirigir. Da mesma forma, em sistemas Linux e Unix, você pode passar um sinal para um programa ou serviço em execução para interagir com ele. Por exemplo, você pode enviar uma luz vermelha para um programa simplesmente emitindo um sinal SIGTERM .

Assim como no sinal vermelho, as pessoas podem optar por continuar andando ou dirigindo quando o sinal estiver vermelho. Embora possa não ser uma ideia segura para todos os envolvidos, o sinal SIGTERM enviado a um processo fará exatamente isso; o processo/programa pode optar por ignorar este sinal.

Todos os sinais básicos do Linux têm um número (1-30 +). Depois de um tempo, um usuário Linux experiente geralmente conhecerá um ou mais desses. Por exemplo, o sinal SIGTERM corresponde ao número 15 e o sinal 9 ( SIGKILL ) é provavelmente o mais conhecido, pois permite encerrar um processo à força, ao contrário do nosso. Exemplo de luz vermelha SIGTERM .

Aqui vemos a tela principal do htop (você pode instalar este prático utilitário digitando sudo apt install htop no Ubuntu / Mint ou sudo yum install htop no RedHat / Centos / Fedora) com um número de terminação e outros tokens (mais abaixo na lista; são 37 no total) que podem ser enviados para um processo previamente selecionado à direita. Você pode 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, a gíria comum do Linux para terminação de processos é que você "mata" um processo. Em geral, só queremos matar um processo com um relatório -9 ( SIGKILL ) se este processo/programa estiver pendente. Tenha em mente que sempre que falamos sobre processo ou programa, as palavras podem ser trocadas à vontade. Basicamente, um processo é qualquer programa em execução (ou serviço) ao qual foi atribuído um arquivo PID (um identificador de processo).

Vejamos um exemplo de matar um processo em segundo plano em execução usando um sinal SIGKILL para o processo em execução. Observe que, como explicado, o SIGKILL é bastante destrutivo e matará o processo, independentemente do que você gostaria de fazer com o sinal. O processo pode capturar e redirecionar vários sinais, enquanto outros não.

Aqui iniciamos o sleep 1800 em segundo plano (usando & no final do comando), que foi iniciado como o primeiro ( [1] ) processo em segundo plano com PID 574660 . Em seguida, matamos esse processo em segundo plano usando kill -9 574660 , onde -9 representa SIGKILL .

Mesmo que o processo termine 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 mais rápido do que finalizar o processo ou similar.

Verificamos a lista de processos procurando o PID ps -ef | grep 574660 . Embora haja saída, a saída mostrada é apenas para nosso comando grep em execução; o processo de sleep já terminou.

Avaliamos a mesma coisa com SIGTERM , ou seja, kill -15 ${PID} Onde está ${PID} é o processo que queremos matar.

Tivemos que pressionar Enter para acionar/exibir a mensagem de encerramento (como explicado acima). Podemos ver que o programa foi finalizado com sucesso novamente. No entanto, desta vez, embora invisível para este exemplo em particular (leia!), internamente dentro do arquivo de sleep de código do programa, as coisas foram um pouco diferentes.

Nesse caso (usando -15 , ou seja, SIGTERM para matar o processo), o processo de sleep foi notificado e teve a chance de manipular o sinal internamente. Ele pode então responder fechando automaticamente, ignorando o sinal ou qualquer outra ação incorporada ao código. Também podemos provar que isso é verdade verificando o sinal de saída e/ou a saída:

Aqui iniciamos o processo sleep 2000 duas vezes, então usamos outra sessão shell/terminal para encerrar o programa. Na primeira vez usamos kill -9 e na segunda vez usamos kill -15 para parar os processos de sleep do arquivo.

Percebemos imediatamente como a saída retorna. Killed na primeira instância (ação kill -9 ). Para a segunda tentativa (usando kill -15 ), vemos a saída Terminated em vez de; o programa terminou sozinho. Após os respectivos preenchimentos, também verificamos os sinais de saída e constatamos que os códigos de saída eram diferentes.

Por que isso é importante? Considere programas maiores; neste caso, estávamos terminando um simples comando de sleep . Não havia dados gerenciados, tráfego enviado para frente/para trás etc. Mas e se enviarmos um arquivo? kill -9 comando para nosso servidor de banco de dados (isso geralmente exigiria privilégios de nível root/sudo)?

Isso acionaria o banco de dados para entrar no modo de travamento na próxima inicialização porque, até onde o software do banco de dados sabe, tudo o que aconteceu foi "lá" seguido de "nada". Em outras palavras, caiu. Se tivéssemos emitido um comando kill -15 , o software de banco de dados poderia ter realizado um desligamento controlado, por exemplo, primeiro bloqueando a conexão de novos usuários, depois desconectando/encerrando usuários existentes e, em seguida, encerrando a gravação de dados etc. antes de finalmente terminar.

Enviando sinais do Linux com sequências de teclado

Você sabia que sempre que você envia um pressionamento de tecla CTRL+c para um programa em execução, digamos, em um terminal, esse SIGINT é enviado? Vamos dar um passo atrás em nosso comando de sleep confiável e tentar isto:

Aqui iniciamos o sleep novamente e, em seguida, pressionamos a combinação de CTRL+c . O programa terminou, ou melhor, foi interrompido desde que o sinal SIGINT 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 esse código de saída, para dormir, sempre corresponderá ao sinal enviado, embora nem todos os sinais sejam cobertos. Em outras palavras, ao usar CTRL+c na linha de comando, o código de saída sempre será 130 , 137 quando morto com kill -9 , é 143 quando kill -15 foi usado.

Você pode testar os códigos de saída dos comandos olhando o arquivo $? variável, que contém o código de saída do comando anterior (desde que um novo comando não tenha sido iniciado). Conhecer o código de saída de um determinado comando em uma determinada situação e/ou como resultado de um determinado sinal enviado a esse comando ajuda na hora de criar scripts de soluções que lidam com outros processos, etc. (O que é o caso de muitos scripts de shell, principalmente no gerenciamento de servidores ou ambientes automatizados.)

Outra sequência de teclado frequentemente usada é CTRL+z . Isso enviará um selo de arquivo SIGTSTP , um sinal de suspend que suspende imediatamente um processo até que (digamos) 'fg' O comando seja emitido para o mesmo processo que o trará de volta ao primeiro plano.

Para obter mais informações sobre gerenciamento de processos, consulte Bash Process Termination Hacks.

Final

Neste artigo, discutimos os sinais Linux mais importantes e como podemos usá-los na prática em um ambiente Linux ou Unix. Conhecer os sinais básicos do Linux ajuda no uso diário e na administração do Linux, por exemplo, quando um processo está pendente e precisa ser encerrado com kill -9 . Em um artigo futuro, podemos considerar a aquisição de um sinal usando a extensão do comando trap de dentro de um script Bash, que permite definir um procedimento personalizado a ser executado quando esse sinal for emitido.

Se você gostou de ler este artigo, confira nossa série Bash Automation começando com Bash Automation & Scripting Basics. No terceiro artigo dessa série, também discutimos o gerenciamento de processos em segundo plano, mencionado anteriormente neste artigo.

  • Como executar o MySQL em um contêiner do Docker
  • Google "The Fresh Prince of Bel-Air" para um divertido Easter Egg – Geek Review

descubra mais conteúdo

Google Pixel Watch também tem detecção de queda, mas não até o próximo ano

As melhores xícaras de café aquecidas de 2022

Como automatizar seu iPhone com base na hora, atividade ou localização

"Isso deve ter sido antes do meu tempo"

Por que a NASA enviou Snoopy para a Lua? – Revisão Geek

O que é uma carga fantasma?

Deixe uma resposta Cancelar resposta

Um sinal é uma forma limitada de comunicação entre processos usada no Unix e em outros sistemas operacionais compatíveis com POSIX. É essencialmente uma notificação assíncrona enviada a um processo para informá-lo de um evento. Quando um sinal é enviado a um processo, o sistema operacional modifica sua execução normal.

Ir arriba