Salta al contenuto principale

strace: vedere le chiamate di sistema di un programma

Inviato da tuxsa il

Un programma si blocca, fallisce senza dire perché, oppure non trova un file di configurazione che "dovrebbe" esserci. I log non aiutano e il messaggio di errore è generico. strace permette di guardare dentro il programma dal di fuori: mostra ogni richiesta che fa al kernel, con argomenti e risultato.

Cos'è

strace è uno strumento di diagnostica che intercetta e stampa le chiamate di sistema (system call) di un processo. Le chiamate di sistema sono il modo in cui un programma chiede qualcosa al kernel: aprire un file (openat), leggere (read), scrivere (write), creare un processo (execve), aprire una connessione (connect) e così via. Qualunque cosa un programma faccia nel mondo esterno passa da lì.

Su Debian e Ubuntu si installa con sudo apt install strace. Non serve il codice sorgente del programma né una versione di debug: funziona con qualsiasi eseguibile.

Cosa fa

strace avvia il comando (oppure si aggancia a un processo già in esecuzione) e, per ogni chiamata di sistema, stampa su stderr una riga con il nome, gli argomenti e il valore restituito. Se la chiamata fallisce, mostra anche il codice di errore, ad esempio ENOENT (file inesistente) o EACCES (permesso negato).

È utile per rispondere a domande molto concrete: quale file di configurazione sta leggendo davvero? Perché dice "No such file or directory"? Su quale chiamata è bloccato? A quale host e porta si sta connettendo? Quanto tempo passa in attesa del disco?

Come si usa

$ strace [opzioni] comando [argomenti]
$ strace [opzioni] -p PID

Nei risultati che seguono ho accorciato alcune righe con cut o con "..." per farle stare nella pagina. Gli output sono in inglese: su un sistema con locale italiano i messaggi di errore dei programmi possono essere tradotti, mentre i nomi delle chiamate e dei codici (ENOENT) restano uguali.

Esempio 1: scoprire quale file non viene trovato

$ strace -e trace=openat cat /tmp/manca.txt
openat(AT_FDCWD, "/tmp/manca.txt", O_RDONLY) = -1 ENOENT (No such file or directory)
cat: /tmp/manca.txt: No such file or directory
+++ exited with 1 +++

Senza -e l'output conterrebbe decine di righe di caricamento delle librerie. Con -e trace=openat si seleziona solo l'apertura dei file. La riga con = -1 ENOENT dice esattamente quale percorso è stato cercato: è il caso tipico di un programma che cerca la configurazione in un posto diverso da quello che ci aspettiamo. Nelle versioni meno recenti la chiamata può chiamarsi open invece di openat.

Esempio 2: vedere cosa legge e cosa scrive

$ strace -y -e trace=read,write cat f.txt
read(3</tmp/st/f.txt>, "ciao\n", 131072) = 5
write(1<pipe:[2446]>, "ciao\n", 5)      = 5
read(3</tmp/st/f.txt>, "", 131072)      = 0

L'opzione -y affianca a ogni descrittore di file il suo percorso (qui f.txt, oppure una pipe, un socket e così via), così non bisogna indovinare cosa sia "il 3". Ho tolto la prima riga, che riguardava la lettura della libreria C. In questa prova l'output di cat andava su una pipe; il numero tra parentesi quadre cambia a ogni esecuzione.

Esempio 3: riepilogo con -c

$ strace -c cat f.txt > /dev/null
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
  0.00    0.000000           0         3           read
  0.00    0.000000           0         1           write
  0.00    0.000000           0         5           close
  0.00    0.000000           0         4           fstat
  0.00    0.000000           0         8           mmap

Con -c strace non stampa le singole chiamate ma una tabella finale: quante volte è stata usata ciascuna, quanto tempo ha richiesto e quante volte ha dato errore. Qui l'ho accorciata alle prime righe. Su un comando così breve i tempi sono zero; su un programma che lavora davvero la colonna errors e le chiamate in cima per tempo sono le prime da guardare. Con -S calls si ordina per numero di chiamate invece che per tempo.

Esempio 4: tempi di ogni chiamata

$ strace -T -e trace=openat cat f.txt 2>&1 >/dev/null | tail -2
openat(AT_FDCWD, "f.txt", O_RDONLY)     = 3 <0.000018>
+++ exited with 0 +++

-T aggiunge in fondo a ogni riga, tra parentesi angolari, il tempo trascorso dentro la chiamata (qui 18 microsecondi). Cercare i valori alti permette di capire dove un programma "perde tempo" in attesa del disco, della rete o di un altro processo. Esistono anche -tt, che prefissa l'ora con i microsecondi, e -r, che mostra il tempo trascorso dalla chiamata precedente.

Esempio 5: seguire anche i processi figli

$ strace -f -e trace=execve sh -c 'ls /tmp/st >/dev/null'
execve("/usr/bin/sh", ["sh", "-c", "ls /tmp/st >/dev/null"], ... /* 241 vars */) = 0
strace: Process 706 attached
[pid   706] execve("/usr/bin/ls", ["ls", "/tmp/st"], ... /* 241 vars */) = 0
[pid   706] +++ exited with 0 +++

Per default strace segue solo il processo lanciato. Se questo crea dei figli (una shell che avvia comandi, un server che fa il fork dei worker) servono -f e un po' di attenzione: ogni riga dei figli è prefissata da [pid N]. In questo esempio ho accorciato la riga di execve con "..."; il numero di variabili d'ambiente (241 vars) dipende dal sistema. Se si vuole un file separato per ogni processo si usa -ff -o nome, che crea nome.PID.

Esempio 6: connessioni di rete e categorie di chiamate

$ strace -e trace=%network python3 -c 'import socket
> socket.socket().connect(("127.0.0.1", 9))'
socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC, IPPROTO_IP) = 3
connect(3, {sa_family=AF_INET, sin_port=htons(9), sin_addr=inet_addr("127.0.0.1")}, 16)
 = -1 ECONNREFUSED (Connection refused)

Oltre ai nomi singoli, -e trace= accetta categorie: %network (socket, connect, send...), %file (chiamate che usano percorsi), %process (fork, exec, exit), %signal e altre. Qui si vede a quale indirizzo e porta il programma prova a connettersi e il motivo del rifiuto. Nella prova reale la riga di connect è su una sola riga, l'ho spezzata io per la pagina; nell'output compare anche qualche altra chiamata di rete e il traceback di Python, che ho omesso.

Esempio 7: agganciarsi a un processo già in esecuzione

$ sudo strace -p 628 -tt
strace: Process 628 attached
06:01:03.667224 clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, {tv_sec=388, ...
06:01:03.873861 clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, {tv_sec=388, ...

Con -p ci si aggancia a un processo che sta già girando, senza riavviarlo: ideale per un servizio che sembra "appeso". Se l'ultima riga è una chiamata che non ritorna (futex, read da un socket, poll), il programma è fermo lì in attesa. Qui il processo era uno script Python che dorme: dalle chiamate si vede che si sveglia ogni 0,2 secondi. Si esce con Ctrl+C: il processo osservato continua a vivere. Il PID si trova con ps o pgrep.

Esempio 8: uso negli script

#!/bin/bash
# Elenca i file che un comando apre davvero e quelli che non trova
[ $# -ge 1 ] || { echo "Uso: $0 comando [argomenti...]" >&2; exit 2; }
command -v strace >/dev/null || { echo "strace non installato" >&2; exit 3; }
log=$(mktemp) || exit 1
trap 'rm -f "$log"' EXIT
strace -f -e trace=openat -o "$log" "$@" >/dev/null 2>&1
echo "--- aperti ---"
grep -v ENOENT "$log" | grep -o '"[^"]*"' | tr -d '"' | sort -u | head -20
echo "--- mancanti ---"
grep ENOENT "$log" | grep -o '"[^"]*"' | tr -d '"' | sort -u | head -20

Lo script lancia qualsiasi comando sotto strace -f, scrive la traccia in un file temporaneo con -o (così non si mischia con l'output del programma) e poi estrae i percorsi tra virgolette, separando quelli aperti con successo da quelli con ENOENT. Il file temporaneo viene cancellato all'uscita con trap. Si usa così: ./files-aperti.sh nginx -t. Il codice di uscita è 2 senza argomenti e 3 se strace manca. Il comando osservato vede il proprio output scartato, quindi è adatto a diagnosi, non a catene di comandi.

Opzioni utili

  • -e trace=nome,nome: mostra solo le chiamate indicate (o categorie come %file, %network, %process).
  • -e status=failed: mostra solo le chiamate andate in errore.
  • -f / -ff: segue i processi figli; con -ff -o file scrive un file per ciascuno.
  • -p PID: si aggancia a un processo in esecuzione.
  • -o file: scrive la traccia su file invece che su stderr.
  • -c e -S campo: riepilogo statistico, con ordinamento a scelta.
  • -T, -tt, -r: tempi per chiamata, orario, tempo dalla chiamata precedente.
  • -y: mostra il percorso accanto ai descrittori di file.
  • -s N: lunghezza massima delle stringhe stampate (default 32). Con -s 8 una scrittura di 13 byte appare come "ciaociao"....
  • -x: stampa le stringhe non stampabili in esadecimale.
  • -k: mostra anche lo stack delle chiamate (se strace è compilato con questo supporto).
  • -q: silenzia i messaggi di attach e di uscita.

Attenzione a

  • Rallenta molto il programma. Ogni chiamata viene fermata e ispezionata, quindi un programma può diventare decine di volte più lento. Su un servizio in produzione con molto traffico meglio limitare con -e trace= e per poco tempo. Non ho misurato l'overhead su carichi reali.
  • Output del programma e della traccia si mischiano. strace scrive su stderr, il programma su stdout, e sul terminale le righe si intercalano (si vede nell'esempio 2). Usare -o file per tenerli separati.
  • Servono i permessi. Per agganciarsi a un processo di un altro utente di solito serve sudo. Su molte distribuzioni anche il modulo di sicurezza Yama (kernel.yama.ptrace_scope) limita l'uso di -p anche sui propri processi. Nei miei test ero root e non ho verificato il comportamento da utente normale.
  • La traccia può contenere segreti. Le stringhe passate a read, write e sendto possono includere password, token e cookie. Non incollare una traccia in un ticket o in una chat senza averla controllata.
  • Le stringhe sono tagliate. Di default si vedono solo i primi 32 byte; se serve di più, aumentare -s. L'ambiente di execve è abbreviato in /* N vars */.
  • Non tutto passa dalle chiamate di sistema. Una funzione di libreria o un ciclo che consuma CPU non compaiono: per quello servono altri strumenti (top, pidstat, un profiler).

Riepilogo

ComandoCosa fa
strace comandoMostra tutte le chiamate di sistema del comando
strace -e trace=openat comandoMostra solo l'apertura dei file
strace -e status=failed comandoMostra solo le chiamate fallite
strace -c comandoTabella riassuntiva per chiamata
strace -T -tt comandoAggiunge orario e durata di ogni chiamata
strace -f comandoSegue anche i processi figli
strace -y -e trace=read,write comandoLetture e scritture con i percorsi
strace -o traccia.txt comandoSalva la traccia in un file
sudo strace -p PIDSi aggancia a un processo già avviato