Come utilizzare strace per monitorare le chiamate di sistema Linux

I programmi Linux chiedono al kernel di fare alcune cose per loro. Il comando strace rivela queste chiamate di sistema. Puoi usarli per capire come funzionano i programmi e perché, a volte, non lo fanno.

Il kernel e le chiamate di sistema

Per quanto intelligenti possano essere, i programmi per computer non possono fare tutto da soli. Devono fare richieste per eseguire determinate funzioni per loro. Queste richieste vanno al kernel Linux. Tipicamente, c'è una libreria o un'altra interfaccia software che il programma chiama, e la libreria quindi fa la richiesta appropriata, chiamata chiamata di sistema, al kernel.

Essere in grado di vedere le chiamate di sistema che un programma ha fatto e quali sono state le risposte può aiutarti a capire il funzionamento interno dei programmi che ti interessano o che hai scritto. Questo è ciò che fa strace . Può aiutare a risolvere i problemi e cercare colli di bottiglia.

Non è lo stesso che eseguire il debug di un'applicazione con uno strumento come gdb . Un programma di debug consente di esaminare il funzionamento interno di un programma durante l'esecuzione. Ti consente di scorrere la logica del tuo programma e di ispezionare la memoria e i valori delle variabili. In confronto, ciò che fa strace è acquisire le informazioni sulla chiamata di sistema mentre il programma è in esecuzione. Quando il programma tracciato termina, strace elenca le informazioni sulla chiamata di sistema nella finestra del terminale.

Le chiamate di sistema forniscono tutti i tipi di funzionalità di basso livello, come leggere e scrivere azioni sui file, uccidere processi e così via. C'è un elenco di centinaia di chiamate di sistema nella pagina man di syscalls.

CORRELATI: Debug con GDB: Guida introduttiva

Installazione di strace

Se strace non è già installato sul tuo computer, puoi installarlo molto facilmente.

Su Ubuntu, usa questo comando:

 sudo apt install strace 

Su Fedora, digita questo comando:

 sudo dnf install strace 

Su Manjaro, il comando è:

 sudo pacman -Sy strace 

Primi passi con strace

Useremo un piccolo programma per dimostrare strace . Non fa molto: apre un file e vi scrive una riga di testo, e non ha alcun errore durante il check-in. È solo un trucco veloce in modo da avere qualcosa da usare con strace .

 #include <stdio.h>

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

  // gestore del file 
  FILE *fileGeek;

  // apri un file chiamato "strace_demo.txt" o crealo 
  fileGeek = fopen("strace_demo.txt", "w");

  // scrivi del testo nel file 
  fprintf(fileGeek, "Scrivi questo nel file");

  // chiudi il file 
  fclose(fileGeek);

  // esce dal programma 
  ritorno (0); 

} // fine del main

Lo abbiamo salvato in un file chiamato "file-io.c" e lo abbiamo compilato con gcc in un eseguibile chiamato stex , chiamato per " st race ex ample".

 gcc -o stex file-io.c

Chiameremo strace dalla riga di comando e gli passeremo il nome del nostro nuovo eseguibile come processo che vogliamo tracciare. Potremmo facilmente rintracciare qualsiasi comando Linux o qualsiasi altro eseguibile binario. Stiamo usando il nostro piccolo programma per due motivi.

Il primo motivo è che strace è prolisso. Ci può essere un sacco di output. È fantastico quando usi strace con rabbia, ma all'inizio può essere opprimente. C'è un output di strace limitato per il nostro piccolo programma. Il secondo motivo è che il nostro programma ha funzionalità limitate e il codice sorgente è breve e diretto. Ciò rende più facile identificare quali sezioni dell'output si riferiscono alle diverse parti del funzionamento interno del programma.

 strace ./stex 

Possiamo vedere chiaramente la chiamata di sistema di write che invia il testo "Scrivi questo nel file" al nostro file aperto e la chiamata di sistema exit_group . Questo termina tutti i thread nell'applicazione e invia un valore di ritorno alla shell.

Filtraggio dell'output

Anche con il nostro semplice programma dimostrativo, c'è un bel risultato. Possiamo usare l'opzione -e (espressione). Passeremo il nome della chiamata di sistema che vogliamo vedere.

 strace -e scrivi ./stex 

È possibile generare rapporti su più chiamate di sistema aggiungendole come un elenco separato da virgole. Non includere spazi bianchi nell'elenco delle chiamate di sistema.

 strace -e chiudi, scrivi ./stex 

Invio dell'output a un file

Il vantaggio del filtraggio dell'output è anche il problema del filtraggio dell'output. Vedi quello che hai chiesto di vedere, ma non vedi nient'altro. E alcuni di quegli altri output potrebbero esserti più utili delle cose che hai chiesto di vedere.

A volte, è più conveniente acquisire tutto e cercare e scorrere l'intero set di risultati. In questo modo, non escluderai accidentalmente nulla di importante. L'opzione -o (output) ti consente di inviare l'output da una sessione strace a un file di testo.

 strace -o trace-output.txt ./stex 

È quindi possibile utilizzare il comando less per scorrere l'elenco e cercare le chiamate di sistema, o qualsiasi altra cosa, per nome.

 meno trace-output.txt 

Ora puoi utilizzare tutte le capacità di ricerca di less per analizzare l'output.

CORRELATI: Come utilizzare meno comando su Linux

Aggiunta di timestamp

È possibile aggiungere diversi timestamp all'output. L'opzione -r (timestamp relative) aggiunge timestamp che mostrano la differenza di tempo tra l'inizio di ogni chiamata di sistema successiva. Si noti che questi valori di tempo includeranno il tempo trascorso nella chiamata di sistema precedente e qualsiasi altra cosa che il programma stava facendo prima della chiamata di sistema successiva.

 strace -r ./stex 

I timestamp vengono visualizzati all'inizio di ogni riga di output.

Per vedere la quantità di tempo trascorso in ciascuna chiamata di sistema, utilizzare l' -T (syscall-times). Questo mostra la durata del tempo trascorso all'interno di ciascuna chiamata di sistema.

 strace -T ./stex 

Le durate di tempo sono visualizzate alla fine di ogni linea di chiamata di sistema.

Per vedere l'ora in cui è stata chiamata ogni chiamata di sistema, utilizzare l'opzione -tt (timestamp assoluti). Questo mostra l'ora "orologio da parete", con una risoluzione di microsecondi.

 strace -tt ./stex 

Gli orari sono visualizzati all'inizio di ogni riga.

Tracciare un processo in esecuzione

Se il processo che vuoi tracciare è già in esecuzione, puoi comunque strace . Per fare ciò, è necessario conoscere l'ID del processo. Puoi usare ps con grep per trovare questo. Abbiamo Firefox in esecuzione. Per scoprire l'ID del processo firefox , possiamo usare ps e inviarlo tramite pipe tramite grep .

 ps -e | grep firefox 

Possiamo vedere che l'ID del processo è 8483. Useremo l'opzione -p (ID processo) per dire a strace a quale processo collegarci. Nota che dovrai usare sudo :

 sudo strace -p 8483 

Vedrai una notifica che strace si è allegata al processo, quindi le chiamate di traccia del sistema verranno visualizzate nella finestra del terminale come al solito.

Creazione di un rapporto

L' -c (solo riepilogo) fa in modo che strace stampi un report. Genera una tabella per informazioni sulle chiamate di sistema effettuate dal programma tracciato.

 strace -c ./stex 

Le colonne sono:

• % tempo : la percentuale del tempo di esecuzione speso in ciascuna chiamata di sistema.
• secondi : il tempo totale espresso in secondi e microsecondi spesi in ciascuna chiamata di sistema.
• usecs/call : il tempo medio in microsecondi spesi in ciascuna chiamata di sistema.
• chiamate : il numero di volte in cui è stata eseguita ciascuna chiamata di sistema.
• errori : il numero di errori per ciascuna chiamata di sistema.
• syscall : il nome della chiamata di sistema.

Questi valori mostreranno zeri per programmi banali che vengono eseguiti e terminati rapidamente. I valori del mondo reale vengono mostrati per i programmi che fanno qualcosa di più significativo della nostra applicazione dimostrativa.

Approfondimenti, facilmente

L'output di strace può mostrarti quali chiamate di sistema vengono effettuate, quali vengono eseguite ripetutamente e quanto tempo di esecuzione viene speso all'interno del codice lato kernel. Questa è un'ottima informazione. Spesso, quando stai cercando di capire cosa sta succedendo all'interno del tuo codice, è facile dimenticare che il tuo binario interagisce quasi ininterrottamente con il kernel per eseguire molte delle sue funzioni.

Usando strace , vedi l'immagine completa.