Como usar o comando timeout no Linux

OK, é tempo de computador suficiente. Você pode dar limites de tempo aos processos, definindo um tempo máximo para que eles possam ser executados com o comando timeout. Aqui está um tutorial para colocar limites na execução de programas com este comando.

O que o tempo limite faz por você?

O comando timeout permite que você definir um limite para o período de tempo um programa será executado. Mas porque você iria querer fazer aquilo?

Um caso é quando você sabe exatamente por quanto tempo deseja que um processo seja executado. Um caso de uso comum é ter o tempo limite de controle de um programa de registro ou captura de dados para que os arquivos de registro não devorem implacavelmente o espaço do seu disco rígido.

Outro caso é quando você não sabe por quanto tempo deseja que um processo seja executado, mas sabe que não deseja que ele seja executado indefinidamente. Você pode ter o hábito de definir processos em execução, minimizar a janela do terminal e esquecê-los.

Alguns programas – mesmo utilitários simples – podem gerar tráfego de rede em níveis que podem impedir o desempenho de sua rede. Ou eles podem amarrar os recursos em um dispositivo de destino, diminuindo seu desempenho. (ping, estou olhando para você.) Deixar esses tipos de programas em execução por longos períodos enquanto você está longe do computador é uma prática ruim.

o tempo limite é parte do GNU Core Utils portanto, os sistemas operacionais Linux e semelhantes ao Unix, como o macOS, têm tempo limite integrado. Não há nada para instalar; você pode usá-lo imediatamente.

Introdução ao tempo limite

Aqui está um exemplo simples. Por exemplo, com suas opções de linha de comando padrão, o comando ping será executado até que você o interrompa pressionando Ctrl + C. Se você não interromper, ele simplesmente continuará.

ping 192.168.4.28

Ao usar o tempo limite, podemos garantir que o ping não seja executado indefinidamente, consumindo a largura de banda da rede e incomodando qualquer dispositivo que esteja recebendo o ping.

  Como criar um volume LVM básico no Linux

Este próximo comando usa o tempo limite para limitar o tempo do ping. Estamos permitindo 15 segundos de tempo de execução para o ping.

timeout 15 ping 192.168.4.28

Após 15 segundos, o tempo limite encerra a sessão de ping e voltamos ao prompt da linha de comando.

Usando o tempo limite com outras unidades de tempo

Observe que não precisamos adicionar um “s” atrás de 15. O tempo limite assume que o valor está em segundos. Você pode adicionar um “s”, mas realmente não faz diferença.

Para usar um valor de tempo medido em minutos, horas ou dias, adicione “m”, “h” ou “d”.

Para que o ping seja executado por três minutos, use o seguinte comando:

timeout 3m ping 192.168.4.28

O ping será executado por três minutos antes que o tempo limite seja atingido e interrompa a sessão de ping.

Limitando a captura de dados com tempo limite

Alguns arquivos de captura de dados podem crescer muito rapidamente. Para evitar que esses arquivos se tornem pesados ​​ou mesmo problemáticos em tamanho, limite a quantidade de tempo que o programa de captura pode ser executado.

Neste exemplo, estamos usando tcpdump, um captura de tráfego de rede ferramenta. Nas máquinas de teste nas quais este artigo foi pesquisado, o tcpdump já estava instalado no Ubuntu Linux e no Fedora Linux. Teve que ser instalado no Manjaro Linux e Arch Linux, com o seguinte comando:

sudo pacman -Syu tcpdump

Podemos executar tcpdump por 10 segundos com suas opções padrão e redirecionar sua saída para um arquivo chamado capture.txt com o seguinte comando:

timeout 10 sudo tcpdump > capture.txt

tempo limite 10 sudo tcpdump> capture.txt em uma janela de terminal ”largura =” 646 ″ altura = ”77 ″ onload =” pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon (this); ”  onerror = ”this.onerror = null; pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon (this);”> </p>
<p> (tcpdump tem suas próprias opções para salvar o tráfego de rede capturado em um arquivo. Este é um hack rápido porque nós ‘ estamos discutindo o tempo limite, não o tcpdump.) </p>
<p> O tcpdump começa a capturar o tráfego da rede e esperamos 10 segundos.  E 10 segundos vão e vêm e o tcpdump ainda está em execução e o capture.txt ainda está crescendo em tamanho.  Vai demorar um Ctrl + C apressado para parar o tcpdump. </p>
<p> Verificar o tamanho de capture.txt com ls mostra que ele cresceu para 209K em questão de segundos.  Esse arquivo estava crescendo rapidamente! </p>
<pre> ls -lh capture.txt </pre>
<p> <img src =

O que aconteceu? Por que o tempo limite não interrompeu o tcpdump?

  Como usar o comando ar do Linux para criar bibliotecas estáticas

Tem tudo a ver com sinais.

Enviando o sinal correto

Quando o tempo limite deseja interromper um programa, ele envia o Sinal SIGTERM. Isso pede educadamente que o programa seja encerrado. Alguns programas podem escolher ignorar o sinal SIGTERM. Quando isso acontecer, precisamos dizer ao timeout para ser um pouco mais forte.

Podemos fazer isso solicitando o tempo limite para enviar o sinal SIGKILL.

O sinal SIGKILL não pode ser “capturado, bloqueado ou ignorado” – ele sempre chega. SIGKILL não pede educadamente que o programa pare. SIGKILL se esconde na esquina com um cronômetro e um cosh.

Podemos usar a opção -s (sinal) para informar o tempo limite para enviar o sinal SIGKILL.

timeout -s SIGKILL 10 sudo tcpdump > capture.txt

tempo limite -s SIGKILL 10 sudo tcpdump> capture.txt em uma janela de terminal ”largura =” 646 ″ altura = ”167 ″ onload =” pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon (this); ”  onerror = ”this.onerror = null; pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon (this);”> </p>
<p> Desta vez, assim que 10 segundos se passaram, o tcpdump é interrompido. </p>
<p> < img src =

Perguntar educadamente primeiro

Podemos pedir timeout para tentar parar o programa usando SIGTERM, e apenas enviar SIGKILL se SIGTERM não funcionar.

Para fazer isso, usamos a opção -k (matar após). A opção -k requer um valor de tempo como parâmetro.

Neste comando, estamos pedindo tempo limite para permitir que dmesg seja executado por 30 segundos e, em seguida, encerrá-lo com o sinal SIGTERM. Se dmesg ainda estiver em execução após 40 segundos, significa que o SIGTERM diplomático foi ignorado e o tempo limite deve ser enviado SIGKILL para concluir o trabalho.

dmesg é um utilitário que pode monitorar as mensagens do buffer de anel do kernel e exibi-los em uma janela de terminal.

timeout -k 40 30 dmseg -w

dmesg é executado por 30 segundos e para quando recebe o sinal SIGTERM.

Sabemos que não foi o SIGKILL que interrompeu o dmesg porque o SIGKILL sempre deixa um obituário de uma palavra na janela do terminal: “Mortos”. Isso não aconteceu neste caso.

Recuperando o Código de Saída do Programa

Programas bem comportados passam um valor de volta para o shell quando são encerrados. Isso é conhecido como código de saída. Normalmente, isso é usado para informar ao shell – ou a qualquer processo que tenha iniciado o programa – se os problemas foram encontrados pelo programa durante sua execução.

  Como encontrar informações críticas do sistema no Linux com o I-Nex

timeout fornece seu próprio código de saída, mas podemos não nos importar com isso. Provavelmente, estamos mais interessados ​​no código de saída do processo que o tempo limite está controlando.

Este comando permite que o ping seja executado por cinco segundos. Ele está executando o ping em um computador chamado Nostromo, que está na rede de teste usada para pesquisar este artigo.

timeout 5 ping Nostromo.local

O comando é executado por cinco segundos e o tempo limite o encerra. Podemos então verificar o código de saída usando este comando:

echo $?

O código de saída é 124. Este é o valor que o tempo limite usa para indicar que o programa foi encerrado usando SIGTERM. Se o SIGKILL encerrar o programa, o código de saída será 137.

Se interrompermos o programa com Ctrl + C, o código de saída do tempo limite será zero.

timeout 5 ping Nostromo.local
echo $?

Se a execução do programa terminar antes que o tempo limite seja encerrado, o tempo limite pode passar o código de saída do programa de volta para o shell.

Para que isso aconteça, o programa deve parar por conta própria (em outras palavras, ele não é encerrado por tempo limite) e devemos usar a opção –preserve-status.

Se usarmos a opção -c (contagem) com um valor de cinco, o ping disparará apenas cinco solicitações. Se dermos ao tempo limite a duração de um minuto, o ping será encerrado definitivamente por si só. Podemos então verificar o valor de saída usando echo.

timeout --preserve-status 1m ping -c 5 Nostromo.local
echo $?

ping completa suas cinco solicitações de ping e termina. O código de saída é zero.

Para verificar se o código de saída está vindo do ping, vamos forçar o ping a gerar um código de saída diferente. Se tentarmos enviar solicitações de ping para um endereço IP inexistente, o ping falhará com um código de saída de erro. Podemos então usar o eco para verificar se o código de saída é diferente de zero.

timeout --preserve-status 1m ping -c 5 NotHere.local
echo $?

O comando ping obviamente não pode alcançar o dispositivo inexistente, então ele relata o erro e fecha. O código de saída é dois. Este é o código de saída que o ping usa para erros gerais.

Definição de regras básicas

o tempo limite é fornecer alguns limites para os programas em execução. Se houver o perigo de os arquivos de log invadirem seu disco rígido ou de você esquecer que deixou uma ferramenta de rede em execução, coloque-os em tempo limite e deixe seu computador se autorregular.