Zombieprocesser i Linux: Hur man hittar och tar bort dem

En zombieprocess är en underprocess som har slutfört sin körning men fortfarande upptar en plats i kärnans processtabell. Den finns kvar eftersom överordnad process inte har anropat wait() för att hämta dess avslutningsstatus. Zombier förbrukar inte CPU eller minne, men var och en har ett PID. Om tillräckligt många av dem samlas kan ditt system inte skapa nya processer. Det här inlägget handlar om hur man upptäcker dem, tar bort dem och förhindrar att de uppstår från början.

Varför zombieprocesser är viktiga på servrar

En enskild zombie är ofarlig. Problemet uppstår när de ackumuleras. Linux har ett begränsat PID-utrymme: 32 768 på 32-bitars system, upp till 4 194 304 på 64-bitars. Om zombieprocesser fyller processbordet kan kärnan inte skapa nya processer. Det innebär inga nya anslutningar, inga nya arbetstrådar, ingenting nytt.

Webbservrar som Apache och Nginx är särskilt utsatta eftersom de skapar underprocesser för att hantera trafiken. Benchmark-tester har visat en minskning av genomströmningen med 48 % när zombier ackumuleras på en belastad webbserver. År 2019 skapade en Golang-kanalläcka i en Kubernetes DNS-pod över 26 000 zombier på en enda nod, vilket fyllde processbordet och kraschade DNS-upplösningen i hela klustret.

Tabellen nedan visar de viktigaste skillnaderna mellan en normal process och en zombie:

Den avgörande slutsatsen: du kan inte kill -9 en zombie. Den är redan död. Det enda sättet att rensa den är att låta föräldraprocessen skörda den, eller döda föräldern så att init (PID 1) ärver och skördar den automatiskt.

Hur man hittar zombieprocesser

Zombier visas med ett Z i kolumnen STAT och <defunct> bredvid kommandot. Lista dem med:

ps aux | grep -w Z

För att se det överordnade process-ID:t (PPID), som du behöver för borttagning:

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

Kommandot top kommandot visar också det totala antalet zombier i rubrikraden. För en snabb icke-interaktiv kontroll:

top -bn1 | grep zombie

Spåra föräldern med pstree

När du har en zombies PID spårar du den tillbaka till den ansvariga överordnade processen:

pstree -p -s <zombie_pid>

Detta visar hela härstamningen från init ner till zombien. Om pstree inte är installerat, ps auxf ger en liknande ASCII-trädvy.

Räkna zombier för övervakning

En ren räkning som utesluter själva grep-processen:

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

För kontinuerlig övervakning under felsökning:

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

Hur man tar bort zombieprocesser

Zombier kan endast tas bort genom att deras avslutningsstatus samlas in. Det innebär att man måste gå via den överordnade processen.

1. Hitta den överordnade processen.

ps -o ppid= -p <zombie_pid>

2. Signalera till den överordnade processen att den ska ta bort sina underordnade processer.

kill -SIGCHLD <parent_pid>

Detta säger åt föräldern att anropa wait() på alla avslutade barnprocesser. Det är icke-störande och fungerar med välfungerande applikationer.

3. Om SIGCHLD inte fungerar, starta om tjänsten.

systemctl restart <service_name>

4. Om föräldran inte svarar, avsluta den.

kill <parent_pid>

Eller om den ignorerar SIGTERM:

kill -9 <parent_pid>

När föräldran avslutas init (PID 1) eller systemd adoptera de föräldralösa zombierna och skörda dem omedelbart. Var försiktig på produktionssystem. Att avsluta föräldern avslutar också alla dess aktiva barn.

5. Verifiera uppstädningen.

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

Om antalet är 0 är allt klart.

Förhindra zombieprocesser

Hantera underprocesser i din kod

Den främsta orsaken till de flesta zombie-ansamlingar är en överordnad process som aldrig anropar wait(). Åtgärda det vid källan:

• C: Ställ in signal(SIGCHLD, SIG_IGN); till att automatiskt kasta bort information om barnprocessers avslut, eller använd en signalhanterare med waitpid(-1, NULL, WNOHANG) för att skörda asynkront.
• Python: Använd subprocess.run(), som väntar automatiskt. Om du använder Popen, anropa proc.wait() explicit.
• Bash: Lägg till wait i slutet av skript som startar bakgrundsjobb.

Konfigurera systemd korrekt

För tjänster som hanteras av systemd förhindrar dessa inställningar uppbyggnad av zombier:

• KillMode=control-group säkerställer att alla underprocesser avslutas samtidigt när tjänsten stoppas.
• TimeoutStopSec ger föräldran tid att skörda barnprocesser innan systemd skickar SIGKILL.
• WatchdogSec startar om tjänster som inte svarar automatiskt, vilket fångar upp fall där föräldern hänger sig och slutar rensa.

Övervaka din processtabell

Ställ in ett cron-jobb som körs var 15:e minut för att räkna zombier och varna om antalet överskrider en tröskel:

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

Övervaka även användningen av din processtabell genom att jämföra det aktuella antalet med /proc/sys/kernel/pid_max. Om det överstiger 80 % bör du undersöka saken innan det blir ett problem. Några tillfälliga zombier under normal drift är inget att oroa sig för. Ett växande antal som inte sjunker tillbaka till noll tyder på en bugg i applikationen som behöver åtgärdas.

Slutsats

Zombieprocesser är döda barn som inte har rensats bort. De använder inte CPU eller minne, men de upptar PID:er, och en full processtabell hindrar din server från att göra något användbart.

• Hitta dem med ps aux | grep -w Z och spåra föräldern med pstree.
• Ta bort dem genom att skicka SIGCHLD till föräldern, starta om tjänsten eller avsluta föräldern som en sista utväg.
• Förhindra dem genom att skriva kod som anropar wait(), konfigurerar systemd korrekt och övervakar din processtabell.

Om du kör arbetsbelastningar med hög trafik och behöver en pålitlig infrastruktur med fullständig root-åtkomst ger FDC:s dedikerade servrar dig full kontroll över din processhantering och systemkonfiguration.