Os programas Linux pedem ao kernel para fazer algumas coisas por eles. O strace comando revela essas chamadas de sistema. Você pode usá-los para entender como os programas funcionam e por que, às vezes, não funcionam.
O kernel e as chamadas do sistema
Por mais espertos que sejam, os programas de computador não podem fazer tudo sozinhos. Eles precisam fazer solicitações para que certas funções sejam executadas por 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 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 interessam a você ou que você escreveu. Isso é o que strace faz. 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. Por comparação, o que strace faz é capturar as informações da chamada do sistema enquanto o programa está sendo executado. Quando o programa rastreado termina, strace lista as informações da chamada do sistema para a janela do terminal.
As chamadas de 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 do manual syscalls.
RELACIONADO: Depurando com GDB: Primeiros passos
Instalando Strace
Se strace ainda não está instalado no seu computador, você pode instalá-lo muito facilmente.
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 strace. Não faz muito: abre um arquivo e grava uma linha de texto nele, e não há 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[]) {
// file handle
FILE *fileGeek;
// open a file called "strace_demo.txt", or create it
fileGeek = fopen("strace_demo.txt", "w");
// write some text to the file
fprintf(fileGeek, "Write this to the file" );
// close the file
fclose(fileGeek);
// exit from program
return (0);
} // end of main Nós salvamos isso em um arquivo chamado “file-io.c” e compilamos com gcc em um executável chamado stex, nomeado para “stcorrida examplo."
gcc -o stex file-io.c
Vamos ligar strace da linha de comando e passe o nome do nosso novo executável para ele como o processo que queremos rastrear. Poderíamos rastrear facilmente 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 strace é prolixo. Pode haver muita produção. Isso é ótimo quando você está usando strace com raiva, mas pode ser opressor no início. É limitado strace saída 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 o write chamada de sistema enviando o texto “Grave isso no arquivo” para o nosso arquivo aberto e o exit_group chamada de sistema. Isso termina todos os threads 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 o -e opção (expressão). Passaremos o nome da chamada de sistema que queremos ver.
strace -e write ./stex

Você pode relatar várias chamadas de 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 rolar por todo o conjunto de resultados. Dessa forma, você não excluirá acidentalmente nada importante. O -o (saída) opção permite enviar a saída de um strace sessão para um arquivo de texto.
strace -o trace-output.txt ./stex

Você pode então usar o less para percorrer a lista e procurar chamadas do sistema - ou qualquer outra coisa - por nome.
less trace-output.txt

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

RELACIONADO: Como usar o comando less no Linux
Adicionando carimbos de data / hora
Você pode adicionar vários carimbos de data / hora diferentes à saída. O -r A opção (carimbos de data / hora relativos) adiciona carimbos de data / hora 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 de sistema anterior e tudo o mais que o programa estava fazendo antes da próxima chamada de 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 o -T opção (syscall-times). Mostra a duração do tempo gasto em cada chamada do sistema.
strace -T ./stex

As durações 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 o -tt opção (carimbos de data / hora absolutos). Mostra o tempo 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 pode anexar strace para isso. 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 firefox processo, podemos usar ps e canalizá-lo grep.
ps -e | grep firefox

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

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

Criação de um relatório
O -c (apenas resumo) causa da opção strace para imprimir um relatório. Ele gera uma tabela de informações sobre as chamadas do sistema que foram feitas pelo programa rastreado.
strace -c ./stex

As colunas são:
- % Tempo: A porcentagem do tempo de execução gasto em cada chamada do sistema.
- segundos: O tempo total expresso em segundos e microssegundos gasto em cada chamada do sistema.
- usecs / chamada: 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.
- erros: 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 são executados 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.
Percepções profundas, facilmente
O strace A saída 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 no código do lado do kernel. Essa é uma ótima informação. Freqüentemente, quando você está tentando entender o que está acontecendo dentro de 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.



