Como usar strace para monitorar chamadas de sistema Linux

Os programas Linux pedem ao kernel para fazer algumas coisas por eles. O comando strace revela essas chamadas de sistema. Você pode usá-los para entender como os programas funcionam e por que, às vezes, eles não funcionam.

O kernel e as chamadas do sistema

Por mais inteligentes que sejam, os programas de computador não podem fazer tudo sozinhos. Eles precisam fazer solicitações para que determinadas funções sejam executadas para eles. Essas solicitações vão para o kernel do Linux. Normalmente, há uma biblioteca ou outra interface de software que o programa chama, e a biblioteca então faz a solicitação apropriada – chamada de chamada de sistema – ao kernel.

Ser capaz de ver as chamadas de sistema que um programa fez e quais foram as respostas pode ajudá-lo a entender o funcionamento interno dos programas que lhe interessam ou que você escreveu. Isso é o que o strace faz. Ele pode ajudar a solucionar problemas e procurar gargalos.

Isso não é o mesmo que depurar um aplicativo com uma ferramenta como gdb . Um programa de depuração permite investigar a operação interna de um programa enquanto ele é executado. Ele permite que você percorra a lógica do seu programa e inspecione a memória e os valores das variáveis. Em comparação, o que o strace faz é capturar as informações da chamada do sistema enquanto o programa está sendo executado. Quando o programa rastreado termina, o strace lista as informações da chamada do sistema na janela do terminal.

As chamadas do sistema fornecem todos os tipos de funcionalidade de baixo nível, como ações de leitura e gravação em arquivos, eliminação de processos e assim por diante. Há uma lista de centenas de chamadas de sistema na página man syscalls.

RELACIONADO: Depuração com GDB: Introdução

Instalando o strace

Se o strace ainda não estiver instalado em seu computador, você poderá instalá-lo com muita facilidade.

No Ubuntu, use este comando:

 sudo apt install strace 

No Fedora, digite este comando:

 sudo dnf install strace 

No Manjaro, o comando é:

 sudo pacman -Sy strace 

Primeiros passos com strace

Usaremos um pequeno programa para demonstrar o strace . Não faz muito: abre um arquivo e escreve uma linha de texto nele, e não tem nenhum erro de verificação nele. É apenas um hack rápido para que tenhamos algo para usar com strace .

 #include <stdio.h>

int main(int argc, char argv[]) { 

  // tratamento do arquivo 
  ARQUIVO *arquivoGeek;

  // abre um arquivo chamado "strace_demo.txt", ou cria-o 
  fileGeek = fopen("strace_demo.txt", "w");

  // escreve algum texto no arquivo 
  fprintf(fileGeek, "Grave isso no arquivo" );

  //fecha o arquivo 
  fclose(fileGeek);

  //sai do programa 
  retorno (0); 

} // fim do principal

Nós salvamos isso em um arquivo chamado “file-io.c” e compilamos com gcc em um executável chamado stex , nomeado para “ st race ex ample”.

 gcc -o arquivo stex-io.c

Chamaremos strace da linha de comando e passaremos o nome do nosso novo executável para ele como o processo que queremos rastrear. Poderíamos facilmente rastrear qualquer um dos comandos do Linux ou qualquer outro executável binário. Estamos usando nosso pequeno programa por dois motivos.

A primeira razão é que o strace é verboso. Pode haver muita saída. Isso é ótimo quando você está usando strace com raiva, mas pode ser esmagador no começo. Há saída de strace limitada para nosso pequeno programa. A segunda razão é que nosso programa tem funcionalidade limitada e o código-fonte é curto e direto. Isso torna mais fácil identificar quais seções da saída se referem às diferentes partes do funcionamento interno do programa.

 strace ./stex 

Podemos ver claramente a chamada do sistema write enviando o texto “Write this to the file” para o nosso arquivo aberto e a chamada do sistema exit_group . Isso encerra todos os encadeamentos no aplicativo e envia um valor de retorno de volta ao shell.

Filtrando a saída

Mesmo com nosso programa de demonstração simples, há bastante saída. Podemos usar a opção -e (expressão). Passaremos o nome da chamada de sistema que queremos ver.

 strace -e write ./stex 

Você pode relatar várias chamadas do sistema adicionando-as como uma lista separada por vírgulas. Não inclua nenhum espaço em branco na lista de chamadas do sistema.

 strace -e close,write ./stex 

Enviando a saída para um arquivo

O benefício de filtrar a saída também é o problema de filtrar a saída. Você vê o que pediu para ver, mas não vê mais nada. E algumas dessas outras saídas podem ser mais úteis para você do que as coisas que você pediu para ver.

Às vezes, é mais conveniente capturar tudo, pesquisar e percorrer todo o conjunto de resultados. Dessa forma, você não excluirá acidentalmente nada importante. A opção -o (saída) permite enviar a saída de uma sessão strace para um arquivo de texto.

 strace -o trace-output.txt ./stex 

Você pode então usar o comando less para rolar pela lista e procurar chamadas do sistema — ou qualquer outra coisa — pelo nome.

 menos trace-output.txt 

Agora você pode usar todos os recursos de pesquisa do less para investigar a saída.

RELACIONADO: Como usar o comando less no Linux

Adicionando carimbos de data/hora

Você pode adicionar vários timestamps diferentes à saída. A opção -r (timestamps relativos) adiciona timestamps que mostram a diferença de tempo entre o início de cada chamada de sistema sucessiva. Observe que esses valores de tempo incluirão o tempo gasto na chamada do sistema anterior e qualquer outra coisa que o programa estava fazendo antes da próxima chamada do sistema.

 strace -r ./stex 

Os carimbos de data/hora são exibidos no início de cada linha de saída.

Para ver a quantidade de tempo gasto em cada chamada do sistema, use a opção -T (syscall-times). Isso mostra a duração do tempo gasto dentro de cada chamada do sistema.

 strace -T ./stex 

As durações de tempo são mostradas no final de cada linha de chamada do sistema.

Para ver a hora em que cada chamada do sistema foi chamada, use a opção -tt (timestamps absolutos). Isso mostra a hora do “relógio de parede”, com resolução de microssegundos.

 strace -tt ./stex 

Os tempos são exibidos no início de cada linha.

Rastreando um processo em execução

Se o processo que você deseja rastrear já estiver em execução, você ainda poderá anexar strace a ele. Para fazer isso, você precisa saber o ID do processo. Você pode usar ps com grep para encontrar isso. Temos o Firefox em execução. Para descobrir o ID do processo do firefox , podemos usar ps e canalizá-lo através de grep .

 ps -e | grep firefox 

Podemos ver que o ID do processo é 8483. Usaremos a opção -p (ID do processo) para informar ao strace a qual processo anexar. Observe que você precisará usar sudo :

 sudo strace -p 8483 

Você verá uma notificação de que o strace se anexou ao processo e, em seguida, as chamadas de rastreamento do sistema serão exibidas na janela do terminal como de costume.

Criando um relatório

A opção -c (somente resumo) faz com que o strace imprima um relatório. Gera uma tabela para informações sobre as chamadas de sistema que foram feitas pelo programa rastreado.

 strace -c ./stex 

As colunas são:

• % time : A porcentagem do tempo de execução que foi gasto em cada chamada do sistema.
• segundos : O tempo total expresso em segundos e microssegundos gasto em cada chamada do sistema.
• usecs/call : o tempo médio em microssegundos gasto em cada chamada do sistema.
• chamadas : O número de vezes que cada chamada do sistema foi executada.
• errors : O número de falhas para cada chamada do sistema.
• syscall : O nome da chamada do sistema.

Esses valores mostrarão zeros para programas triviais que executam e terminam rapidamente. Os valores do mundo real são mostrados para programas que fazem algo mais significativo do que nosso aplicativo de demonstração.

Insights profundos, facilmente

A saída strace pode mostrar quais chamadas de sistema estão sendo feitas, quais estão sendo feitas repetidamente e quanto tempo de execução está sendo gasto dentro do código do kernel. Essa é uma ótima informação. Muitas vezes, quando você está tentando entender o que está acontecendo dentro do seu código, é fácil esquecer que seu binário está interagindo quase sem parar com o kernel para executar muitas de suas funções.

Usando strace , você vê a imagem completa.