C'è un modo per uccidere un processo di zombi senza riavviare?

C'è un modo per uccidere un processo di zombi senza riavviare? Ecco come è successo:

Voglio scaricare un file da 12 GB usando torrent. Dopo aver aggiunto il file .torrent, la trasmissione si è trasformata in un processo zombie (ho provato anche ktorrent. Stesso comportamento). Finalmente ho potuto scaricare il file usando µTorrent ma dopo aver chiuso il programma, si trasforma anche in uno zombi.

Ho provato ad utilizzare kill, skille pkillcon diverse opzioni e -9di segnale, ma senza successo.

Dopo aver letto alcune soluzioni sul web, ho scoperto che uccidere il genitore può uccidere lo zombi. Ma uccidere il vino non ha aiutato neanche.

C'è un altro modo?

Modificare:

ps -o pid, ppid, stat, comm

PID  PPID STAT COMMAND
7121  2692 Ss   bash
7317  7121 R+   ps

uscita pstree:

init─┬─GoogleTalkPlugi───4*[{GoogleTalkPlug}]
 ├─NetworkManager─┬─dhclient
 │                └─{NetworkManager}
 ├─acpid
 ├─amarok───19*[{amarok}]
 ├─apache2───5*[apache2]
 ├─atd
 ├─avahi-daemon───avahi-daemon
 ├─bonobo-activati───{bonobo-activat}
 ├─clock-applet
 ├─console-kit-dae───63*[{console-kit-da}]
 ├─cron
 ├─cupsd
 ├─2*[dbus-daemon]
 ├─2*[dbus-launch]
 ├─desktopcouch-se───desktopcouch-se
 ├─firefox───run-mozilla.sh───firefox-bin─┬─plugin-containe───8*[{plugin-contain}]
 │                                        └─14*[{firefox-bin}]
 ├─gconfd-2
 ├─gdm-binary─┬─gdm-simple-slav─┬─Xorg
 │            │                 ├─gdm-session-wor─┬─gnome-session─┬─bluetooth-apple
 │            │                 │                 │               ├─compiz───sh───gtk-window-deco
 │            │                 │                 │               ├─fusion-icon
 │            │                 │                 │               ├─gdu-notificatio
 │            │                 │                 │               ├─gnome-panel───{gnome-panel}
 │            │                 │                 │               ├─gnome-power-man
 │            │                 │                 │               ├─gpg-agent
 │            │                 │                 │               ├─gwibber-service
 │            │                 │                 │               ├─nautilus
 │            │                 │                 │               ├─nm-applet
 │            │                 │                 │               ├─polkit-gnome-au
 │            │                 │                 │               ├─2*[python]
 │            │                 │                 │               ├─qstardict───{qstardict}
 │            │                 │                 │               ├─ssh-agent
 │            │                 │                 │               ├─tracker-applet
 │            │                 │                 │               ├─trackerd
 │            │                 │                 │               ├─wakoopa─┬─wakoopa
 │            │                 │                 │               │         └─3*[{wakoopa}]
 │            │                 │                 │               └─{gnome-session}
 │            │                 │                 └─{gdm-session-wo}
 │            │                 └─{gdm-simple-sla}
 │            └─{gdm-binary}
 ├─6*[getty]
 ├─gnome-keyring-d───2*[{gnome-keyring-}]
 ├─gnome-screensav
 ├─gnome-settings-
 ├─gnome-system-mo
 ├─gnome-terminal─┬─bash───ssh
 │                ├─bash───pstree
 │                ├─gnome-pty-helpe
 │                └─{gnome-terminal}
 ├─gvfs-afc-volume───{gvfs-afc-volum}
 ├─gvfs-fuse-daemo───3*[{gvfs-fuse-daem}]
 ├─gvfs-gdu-volume
 ├─gvfsd
 ├─gvfsd-burn
 ├─gvfsd-computer
 ├─gvfsd-metadata
 ├─gvfsd-trash
 ├─hald─┬─hald-runner─┬─hald-addon-acpi
 │      │             ├─hald-addon-cpuf
 │      │             ├─hald-addon-inpu
 │      │             └─hald-addon-stor
 │      └─{hald}
 ├─indicator-apple
 ├─indicator-me-se
 ├─indicator-sessi
 ├─irqbalance
 ├─kded4
 ├─kdeinit4─┬─kio_http_cache_
 │          └─klauncher
 ├─kglobalaccel
 ├─modem-manager
 ├─multiload-apple
 ├─mysqld───10*[{mysqld}]
 ├─named───10*[{named}]
 ├─nmbd
 ├─notification-ar
 ├─notify-osd
 ├─polkitd
 ├─pulseaudio─┬─gconf-helper
 │            └─2*[{pulseaudio}]
 ├─rsyslogd───2*[{rsyslogd}]
 ├─rtkit-daemon───2*[{rtkit-daemon}]
 ├─smbd───smbd
 ├─snmpd
 ├─sshd
 ├─timidity
 ├─trashapplet
 ├─udevd───2*[udevd]
 ├─udisks-daemon─┬─udisks-daemon
 │               └─{udisks-daemon}
 ├─upowerd
 ├─upstart-udev-br
 ├─utorrent.exe───{utorrent.exe}
 ├─vnstatd
 ├─winbindd───2*[winbindd]
 ├─wnck-applet
 ├─wpa_supplicant
 └─xinetd

Il monitor di sistema e la parte superiore mostrano che il processo di zombi utilizza risorse:

Modifica 2: Penso di aver trovato qualcosa. Ho provato a disconnettermi e ho visto questo messaggio:

Dato che altri client torrent hanno lo stesso problema, forse è qualcosa che riguarda le dimensioni del file. Sto usando Ubuntu 10.04 su partizioni ext4. Uccidere nautilus e inviare il segnale SIGCHLD non ha funzionato.

Non credo che il processo degli zombi sia un gran mal di testa. Un processo di zombi non richiede alcuna risorsa. È solo che ha la sua voce nella tabella dei processi.

Un processo Zombie non è un processo orfano, ha un genitore.

kill, skill pkillnon funzionerà poiché il processo è già terminato, solo che la sua voce non è stata rimossa.

Il processo di zombi può essere ucciso inviando un SIGCHLDsegnale al genitore. Penso che il numero del segnale SIGCHLDsia 17o18

Se anche questo fallisce, allora potresti voler uccidere il genitore stesso.

Da Wikipedia sul segnale SIGCHLD:

Quando un processo figlio termina prima che il genitore abbia chiamato wait, il kernel conserva alcune informazioni sul processo per consentire al suo genitore di chiamare wait in seguito. Poiché il bambino sta ancora consumando risorse di sistema, ma non eseguendolo, è noto come processo di zombi.

EDIT 1 : le risorse di sistema utilizzate sono principalmente la voce della tabella dei processi. Se qualcuno sa se consuma più di questo: memoria o ciclo della CPU, aggiungi una spiegazione. AFAIK difficilmente occupa risorse di sistema significative.

EDIT 2: Citando da Wikipedia

Sui sistemi operativi per computer Unix e Unix, un processo zombie o un processo defunto è un processo che ha completato l'esecuzione ma ha ancora una voce nella tabella dei processi. Questa voce è ancora necessaria per consentire al processo che ha avviato il processo (ora zombi) di leggere il suo stato di uscita.

Quindi la voce viene mantenuta in modo tale che il processo padre possa conoscere lo stato di uscita poiché nel momento in cui il figlio esce, il genitore probabilmente non è in uno stato o non è pronto a leggere il suo stato di uscita.

MODIFICA 3

Fino ad oggi non ho mai sperimentato un processo di zombi che prendesse il 100% della CPU. Vedendolo per la prima volta.

Prova a fare un killall utorrent.exe

Vedo che ci sono due casi utorrent.exee uno di questi è zombi. Probabilmente il secondo (bambino). killall dovrebbe uccidere il genitore poiché il bambino (zombi) non può essere ucciso.

MODIFICA 4

Sembra che il killall non abbia funzionato dato che stava dando il segnale TERM invece di KILL.

Provalo killall --signal=KILL utorrent.exe

Se questo non funziona, prova a terminare il processo in modo selettivo.

Ottieni l'elenco dei processi PID utorrent.exe

ps -e | grep -i utorrent

Dovresti ottenere due processi come

xxxx ?        aa:bb:cc utorrent.exe defunct
yyyy ?        aa:bb:cc utorrent.exe

Quindi il secondo è il genitore. Uccidilo usando

uccidere -9 yyyy

MODIFICA 5

Prova a trovare l'ID principale del processo con questo comando bash

cat / proc / {defunctpid} / status | grep -i ppid

nel tuo caso è

cat / proc / 7298 / status | grep -i ppid

Se l'output arriva come

PPid: 1

Quindi, purtroppo, penso che tu sia sfortunato. L'ID processo 1appartiene a init senza il quale il sistema non può essere eseguito

L'uso killsul processo stesso è effettivamente inefficace, poiché il processo è già morto; killporta un processo live allo stato zombi.

Il processo principale è responsabile della raccolta del codice di uscita del processo; il processo rimane uno zombi fino a quando non viene fatto. Il initprocesso raccoglierà il codice di uscita di qualsiasi processo e lo getterà via, quindi è il genitore "di ultima istanza" che pulirà qualsiasi zombi che è un discendente diretto.

Uccidere il genitore del processo zombi è di solito efficace perché il processo zombi torna a initessere il suo genitore non appena il processo genitore è andato (cioè uccidere il genitore ha trasformato quel processo in uno zombi e il nonno ha letto il codice di uscita del genitore , quindi il genitore se n'è veramente andato). Uno zombi può essere genitore di uno zombi, quindi semplicemente uccidere il genitore non è sufficiente, ma deve anche essere raccolto da un altro processo stesso.

Nota che i processi non sono mai responsabili della pulizia dei loro nipoti: tornano sempre al processo 1 come genitore (motivo per cui gli autori dei demoni a volte usano un doppio fork () e terminano il processo nel mezzo per dissociare completamente il processo figlio dall'invocazione conchiglia)

Il motivo per cui uccidere wineprobabilmente non è efficace è perché non era proprio il genitore del processo degli zombi; piuttosto, "utorrent.exe" che è un discendente diretto di init è. Questo processo tuttavia continua a funzionare normalmente, trascurando semplicemente i suoi doveri.

Modo molto più semplice di killall, -9, ecc:

1) Usa qBitorrent invece della console uTorrent (sto aspettando anche una versione della GUI e qBitorrent lo è essenzialmente).

2) Se stai usando 11.04 o versioni successive, premi alt + f2 (apre una finestra di comandi speciali), digita xkill e il tuo mouse ora è una x. Fai clic sul programma che vuoi chiudere (UI = ID processo) e lo ucciderà per te.

Suggerimento avanzato: associa una scorciatoia da tastiera per "xkill" come nella mia tastiera macro G15.

Nel mio caso in cui il vino si blocca e non posso uccidere il bambino Zombi con un fucile da caccia farei:

wineserver -kquindi ucciderei il "Figlio del processo" killall -9 Oblivion.exe(ad esempio)

Per quello che ho capito, wineerver invia un segnale a tutti i suoi bambini zombi che moriranno tutti (a causa del fucile che conosci) ma a volte un bambino pensa da solo e vuole prendere d'assalto il mondo. Quindi faccio l'ulteriore killall -9o il kill -9con l'id del processo.

La mia ipotesi è che stai usando un SSD.

Quando si aggiungono torrent di grandi dimensioni a un client torrent, i file "segnaposto" del torrent che si sta scaricando vengono effettivamente creati sul disco, ma sono vuoti fino a quando non vengono riempiti gradualmente durante il processo di download.

Con un normale disco rigido, il disco è il collo di bottiglia e non si noterà un problema di prestazioni con il resto del desktop.

Quando si utilizza un SSD, tuttavia, la CPU è il collo di bottiglia e l'applicazione sembra bloccarsi (diventa grigia). Se lo lasci per un po ', si riprenderà e tutto andrà bene. Questa è stata la mia esperienza da quando sono passato a un SSD.

Per quanto riguarda i processi di uccisione, altri hanno fornito consigli migliori di quelli che posso - usare il segnale KILL di solito funziona, ma ho avuto quello strano che ha richiesto un riavvio nel corso degli anni.