Processi zombie in Linux: come individuarli e rimuoverli

Un processo zombie è un processo figlio che ha terminato l'esecuzione ma occupa ancora uno slot nella tabella dei processi del kernel. Esiste perché il processo padre non ha chiamato wait() per raccogliere il suo stato di uscita. Gli zombie non consumano CPU o memoria, ma ognuno di essi occupa un PID. Se se ne accumulano abbastanza, il sistema non può generare nuovi processi. Questo post spiega come individuarli, rimuoverli e impedire che compaiano in primo luogo.

Perché i processi zombie sono importanti sui server

Un singolo processo zombie è innocuo. Il problema inizia quando si accumulano. Linux ha uno spazio PID limitato: 32.768 sui sistemi a 32 bit, fino a 4.194.304 su quelli a 64 bit. Se i processi zombie riempiono la tabella dei processi, il kernel non può creare nuovi processi. Ciò significa niente nuove connessioni, niente nuovi thread di lavoro, niente di nuovo.

I server web come Apache e Nginx sono particolarmente esposti perché generano processi figli per gestire il traffico. I benchmark hanno mostrato un calo del 48% nella velocità di trasmissione quando gli zombie si accumulano su un server web molto trafficato. Nel 2019, una perdita di canale Golang in un pod DNS di Kubernetes ha creato oltre 26.000 zombie su un singolo nodo, riempiendo la tabella dei processi e causando il crash della risoluzione DNS a livello di cluster.

La tabella seguente mostra le differenze chiave tra un processo normale e uno zombie:

Il punto fondamentale: non puoi kill -9 uno zombie. È già morto. L'unico modo per eliminarlo è fare in modo che il processo padre lo raccolga, oppure uccidere il padre in modo che init (PID 1) lo erediti e lo elimini automaticamente.

Come individuare i processi zombie

I processi zombie sono contrassegnati da una Z nella colonna STAT e <defunct> accanto al nome del comando. Elencarli con:

ps aux | grep -w Z

Per visualizzare l'ID del processo padre (PPID), necessario per la rimozione:

ps -eo pid,ppid,stat,comm | grep -w Z

Il top comando riporta anche il conteggio totale degli zombie nella riga di intestazione. Per un controllo rapido non interattivo:

top -bn1 | grep zombie

Tracciare il processo padre con pstree

Una volta ottenuto il PID di uno zombie, risalire al processo padre responsabile:

pstree -p -s <zombie_pid>

Questo mostra l'albero genealogico completo init fino allo zombie. Se pstree non è installato, ps auxf fornisce una visualizzazione ad albero ASCII simile.

Conteggio degli zombie per il monitoraggio

Un conteggio pulito che esclude il processo grep stesso:

ps aux | awk '$8 ~ /Z/ {count++} END {print count+0}'

Per il monitoraggio continuo durante la risoluzione dei problemi:

watch -n 1 'ps aux | grep -w Z | wc -l'

Come rimuovere i processi zombie

Gli zombie possono essere rimossi solo raccogliendo il loro stato di uscita. Ciò significa operare attraverso il processo padre.

1. Trovare il processo padre.

ps -o ppid= -p <zombie_pid>

2. Segnalare al processo padre di terminare i propri processi figli.

kill -SIGCHLD <parent_pid>

Questo dice al processo padre di chiamare wait() su qualsiasi processo figlio terminato. È un'operazione non invasiva e funziona con applicazioni che si comportano correttamente.

3. Se SIGCHLD non funziona, riavviare il servizio.

systemctl restart <service_name>

4. Se il processo padre non risponde, terminarlo.

kill <parent_pid>

Oppure, se ignora SIGTERM:

kill -9 <parent_pid>

Quando il processo padre muore, init (PID 1) oppure systemd adotta gli zombie orfani e li elimina immediatamente. Prestare attenzione sui sistemi di produzione. Terminare il processo padre termina anche tutti i suoi processi figli attivi.

5. Verifica la pulizia.

ps aux | awk '$8 ~ /Z/ {count++} END {print count+0}'

Se il conteggio è 0, è tutto a posto.

Prevenzione dei processi zombie

Gestire i processi figli nel codice

La causa principale della maggior parte degli accumuli di zombie è un processo padre che non chiama mai wait(). Risolvi il problema alla fonte:

• C: Impostare signal(SIGCHLD, SIG_IGN); per scartare automaticamente le informazioni di uscita dei processi figli, oppure usa un gestore di segnali con waitpid(-1, NULL, WNOHANG) per la raccolta asincrona.
• Python: usa subprocess.run(), che attende automaticamente. Se si utilizza Popen, chiamare proc.wait() esplicitamente.
• Bash: Aggiungere wait alla fine degli script che avviano processi in background.

Configurare correttamente systemd

Per i servizi gestiti da systemd, queste impostazioni impediscono l'accumulo di zombie:

• KillMode=control-group garantisce che tutti i processi figli vengano terminati insieme quando il servizio si arresta.
• TimeoutStopSec dà al processo padre il tempo di terminare i processi figli prima che systemd invii SIGKILL.
• WatchdogSec riavvia automaticamente i servizi che non rispondono, individuando i casi in cui il processo padre si blocca e smette di terminare i processi figli.

Monitorare la tabella dei processi

Imposta un cron job che si esegua ogni 15 minuti per contare gli zombie e avvisare se il conteggio supera una soglia:

ps aux | awk '$8 ~ /Z/' | wc -l

Monitora anche l'utilizzo della tabella dei processi confrontando il conteggio attuale con /proc/sys/kernel/pid_max. Se supera l'80%, indagate prima che diventi un problema. Qualche zombie transitorio durante il normale funzionamento non è motivo di preoccupazione. Un conteggio in crescita che non torna a zero indica un bug dell'applicazione che deve essere risolto.

Conclusione

I processi zombie sono processi terminati che non sono stati eliminati. Non utilizzano CPU o memoria, ma occupano PID e una tabella dei processi piena impedisce al server di svolgere qualsiasi attività utile.

• Trovali con ps aux | grep -w Z e rintraccia il processo padre con pstree.
• Rimuovili inviando SIGCHLD al processo padre, riavviando il servizio o terminando il processo padre come ultima risorsa.
• Prevenili scrivendo codice che chiami wait(), configurando correttamente systemd e monitorando la tabella dei processi.

Se si gestiscono carichi di lavoro ad alto traffico e si necessita di un'infrastruttura affidabile con pieno accesso root, i server dedicati di FDC offrono il pieno controllo sulla gestione dei processi e sulla configurazione del sistema.