Newsgroup: it.comp.os.linux.sys
Titolo: Netscape, l'immortale...

Oggi mi e' successa una cosa stranissima: un'istanza di netscape s'e'
bloccata e non riesco ad ucciderla neppure piu' con un kill -9; facendo
ps continua rimanere li', con due figli zombie:
18275 ?        00:00:26 netscape-commun
18291 ?        00:00:00 netscape <defunct>
18292 ?        00:00:00 netscape-commun <defunct>
Devo rassegnarmi a tenermelo sino al prossimo reboot (e' previsto solo
alla prima interruzione di corrente...:)?
ByE,
FF

 alla prima interruzione di corrente...:)?
Si, i processi zombi non si uccidono: occupano solamente un'entry nella
process table ma non danno fastidio a nessuno.
-- 
Pierluigi De Rosa (
tho...@durin.khazad-dum.net
).
<<      LINUX: the choice of a GNU generation     >>
<<   For my real address... ask the Balrog.       >>
* Sostenete la Lega per la Soppressione dei Troll *

 
Ma il primo dei tre non e' (o non appare) zombie al contrario dei suoi
due figli, che probabilmente sono tali proprio perche' il padre continua
ad essere in qualche modo vivo ed immortale... E' questo che mi sembra
strano.
ByE,
FF

 strano.
Gli unici processi che non puoi uccidere sono quelli con PPID 1 e cioe'
init. Che PPID ha questo padre che e' ancora attivo?


 alla prima interruzione di corrente...:)?
Probabilmente, devi essere più convincente:
kill -s KILL pid
dove pid è il numero di processo che vuoi terminare. Ovviamente, gli
zombie non li puoi uccidere (ma non fanno male a nessuno!!), ma se
ammazzi il padre _dovrebbero_ andare giù anche loro.
Prova, male non ne fa!
-- 
echo f 0:0 ffff 0 | debug
La leggerezza del VOLER essere ....

alla prima interruzione di corrente...:)?
Prova a fare "ps l", il campo WCHAN ti dice dove e` fermo 18275.
Guarda anche lo stato di 18275, se e` D non puoi ucciderlo.
-- 
Lorenzo
"Given enough eyeballs, all bugs are shallow", Linus'Law
(address rot13 encoded)


Azzo... non posso piu' vederlo. 'Provvidenzialmente' s'e' dovuto fare
uno spostamento di PC e sono stato costretto a  spegnere e quindi e'
tutto tornato normale.
Quindi se per un qualche motivo init 'adotta' un processo non posso piu'
fare nulla? E, soprattutto, come puo' succedere un caso del genere?
ByE,
FF

 strano.
Lo so... ma non riesco a trattenermi.... scusa scusa scusa... ma...
hai provato a tagliargli la testa con uno spadone del 1200? 8o)
Wiz

 fare nulla? E, soprattutto, come puo' succedere un caso del genere?
Per farlo andare AFAIK si, ripeto. Poi per quanto riguarda il come possa
succedere non so, magari il processo puo' andare in core dump e non fare
piu' corretto riferimento ad un PPID nella process table: ma e' una
supposizione, niente di piu'.


 hai provato a tagliargli la testa con uno spadone del 1200? 8o)
No, non serve neanche quello...


alla prima interruzione di corrente...:)?
Se non funziona -9, si`.
-- 
ciao, |
Marco | * The Internet is full. Go away.  -- Joel Furr *
      | (Ri)scoprire fidonet: 
http://bbs.mi.linux.it

hai provato a tagliargli la testa con uno spadone del 1200? 8o)
Ma quelli non sono gli zombi, sono strani personaggi delle alte terre
scozzesi, contro gli zombi ci vuole la polverina del barone samdi'
Ciao.roberto
-- 
Ciao     |Save our planet!
         |Save wildlife;
 roberto |For your E-MAIL use only recycled Bytes !!
         |roberto poggi  
rpo...@softhome.net

Se non funziona -9, si`.
Si puo` sempre mettere mano a /dev/kmem, in teoria :-)


 e' una supposizione, niente di piu'.
Se non ricordo male viene messo a "1" il PPID dei
processi che sopravvivono al proprio padre, oltre a
quelli forkati da init stesso (ma questo e' il caso
ovvio...).
Daniele

 Prova, male non ne fa!
Veramente, se non ricordo male, gli zombie sono processi
morti senza che il padre abbia potuto leggerne lo stato
in uscita. Quindi se ad un processo tu ammazzi il padre
e' probabile che lo trasformi in uno zombie...
Daniele

 scozzesi, contro gli zombi ci vuole la polverina del barone samdi'
Chiamate Yama, chiamate Yamaaa !!


 ovvio...).
Eh, gia'... quindi l'unico modo per farli andare via e' lo shutdown
anche se non dovrebbe essere necessario in quanto non occupano piu' una
entry nella process table, o ricordo male?


 
Magari dico una cavolata, ma l'entry nella process table non e' l'unica
cosa che occupano?
ByE,
FF

 
Non riuscivo a distinguere i bit della testa da quelli degli altri
arti... Sai segli tagli solo un braccio non serve a nulla e lo fai
incazzare ;)
ByE,
FF

 cosa che occupano?
Non piu' se sono zombi.


 Daniele
Citando dal "Advanced UNIX programming" Rochkind:
"A process may terminate at a time when its parent is not waiting for
it. Because the kernel must ensure that every process gets waited for,
such an unwaited process becomes a zombie process. Its instruction,
user-data, and system-data segments are discarded, but it still occupies
a process-table slot in the kernel. When its turn comes to be waited for
it finally goes away."
Quindi deve essere un processo:
1) ucciso
2) il suo parent non ha fatto una wait() system-call.
Si può usare pstree, un programma molto carino che ti dice quali sono i
parent dei vari processi in forma grafica. con -p dà anche i PID.
Che sappia io, poi, init quando eredita un figlio non fa che fare una
wait() e aspettare, quindi non ci sono problemi se questo succede. (me
lo conferma il Tanenbaum)
Il fatto che ci sia uno zombie in giro quindi significa:
- che il suo parent non è terminato (e qui con kill -9 PID non c'è
speranza, _viene ucciso!_)
- che c'è un problema nel sistema operativo.
(nel secondo caso, sarebbe interessante informare chi di dovere)
Ciao,
    Matteo

 - che c'è un problema nel sistema operativo.
OK, grazie per avermi rinfrescato la memoria. Quindi
se non ho capito male il succo e' che se il padre viene
ucciso ci pensa init a leggere lo status del processo
zombie, eliminandolo dalla process table. Giusto?
Daniele

 Non piu' se sono zombi.
No, no la occupano eccome. Sono i loro segmenti di
memoria che vengono liberati, ma la entry nella process
table la mantengono, anche perche' se non fossero nella
process table non sarebbero visibili da "ps".
A proposito: mi sembra che tra i vari "figli di init" ci
siano anche i processi che si detacchano dal terminale
da cui sono lanciati, tipo Netscape e demoni vari...
Daniele

 da cui sono lanciati, tipo Netscape e demoni vari...
Ma per esempio nel caso di Netscape (mettiamo nei casi in cui lo trombo
con un kill -9 secco quando si pianta per Javascript) non dovrebbe
sparire del tutto?


 
E che è ... la notte dei morti viventi?? ;-))
Cmq, sempre sottolineando il "se non erro", se hai il pid 666 (che tanto
di zombie si parla!) che crea il child 667 e ammazzi di brutto il 666,
anche il 667 _dovrebbe_ sparire.


 per Javascript) non dovrebbe sparire del tutto?
Come mi ha giustamente ricordato Matteo Fortini nel suo
post piu' sotto: il padre sparisce perche' lo seghi con
un kill -9, pero' gli zombie sono i processi che sono
morti prima che il padre li abbia terminati correttamente
leggendone lo stato d'uscita. Quindi se Netscape aveva
forkato qualche figlio che e' morto e non aveva fatto in
tempo a leggerne lo stato d'uscita prima del tuo kill,
quel processi rimangono zombie e vengono adottati da
init che *dovrebbe* provvedere a terminarli leggendone
lui lo stato d'uscita. Ora, il problema e': quando li
termina init dato che gli zombie se ne rimangono
allegramente a spasso per ere geologiche? Di certo non
provvede periodicamente a segarli, quindi la mia ipotesi
(perdona, ma adesso non ho proprio voglia di andarmi a
spulciare i sorgenti di init per verificare) e' che lo
faccia quando c'e' un cambio di runlevel.
Daniele

 
Scusate ma un processo zombie non č un processo che č morto,il kernel ha inviato
un SIGCHLD al padre e questo non ha ancora potuto leggere lo stato del figlio? (che
 assieme alla entry nella process table č l'unica cosa che rimane in memoria di uno zombie)
E dato che se un processo rimane "orfano di padre" viene ereditato da init (quindi il suo
 PPID va a 1) e init per dovere istituzionale fa delle wait leggendo lo stato di tutti i
 suoi figli morti uccidendo cosi gli zombie allora non possono esistere zombie immortali.....
 basta uccidere loro padre :-) e init fa il resto! o mi sbaglio?
-- 
---------------------------------------------------------
 Cesare Fontana
---------------------------------------------------------
 CSITE - CNR, Universita` degli Studi di Bologna (DEIS)
 Viale Risorgimento, 2 I-40136 Bologna Italy
 tel. (direct)    
+ 39 051 2093072
 fax              
+ 39 051 2093540
 internet:    
cfon...@deis.unibo.it
---------------------------------------------------------

 _dovrebbe_ sparire.
No invece: sopravvive tranquillo e viene adottato da
init...
Ciao,
Daniele

 faccia quando c'e' un cambio di runlevel.
Si, ti credo sulla parola anche perche' non ne ho molta voglia (e tanto
meno tempo) nemmeno io :-)


 anche il 667 _dovrebbe_ sparire.
Non e' mica detto e lui ha anche spiegato il perche'.


  basta uccidere loro padre :-) e init fa il resto! o mi sbaglio?
Si ma se il PPID di uno zombie e' init stesso che fa, si suicida? :-)


anche il 667 _dovrebbe_ sparire.
Se muore un processo a tutti i suoi figli viene assegnato un nuovo parent
process, che normalmente e' init. Se e' un session leader e controlla un
terminale viene mandato un segnale SIGHUP ad ogni suo figlio. Normalmente
questo segnale uccide il processo stesso, ma non sempre. Se ignora il
segnale questo sopravvive, pero' non puo' appartenere piu' al gruppo del
padre, e quindi diventa membro del gruppo orfano.
cfr pinfo libc
(Luke, la Forza e' dentro di te!.
Antonio, la Documentazione e' dentro il tuo HD!)
-- 
DOS, s.m.:
        Un piccolo e noioso boot virus che causa casuali e spontanei
        crash di sistema, talvolta subito prima di salvare un grosso
        lavoro.  Facilmente curabile con UNIX.
        Vedi anche MS-DOS, IBM-DOS, DR-DOS.

 padre, e quindi diventa membro del gruppo orfano.
AAH! La luce! Finalmente mi torna tutto... Brutta cosa
la memoria corta :)
Comunque ho fatto un paio di esperimenti veloci con un
processo che prima forka e poi sia padre che figlio
rimangono ad aspettare una decina di secondi. Succede
questo:
1) Se uccido il padre il figlio vive tranquillamente
   come figlio di init, e al suo termine esce senza
   lasciare traccia (probabilmente init ne legge lo
   stato per evitare che diventi uno zombie).
2) Se uccido prima il figlio questo diventa uno zombie,
   ma alla morte del padre esce senza lasciare traccia.
Quindi direi che ci siamo! Adesso per esercizio mi
vado a riguardare la documentazione della glibc, che
e' tuttora il miglior tutorial/reference su queste cose
che sia riuscito a trovare...
Daniele

 
dal man init:
..After  it has spawned all of the processes specified, init
       waits for one of its descendant processes to die, a power­
       fail  signal, or until it is signaled by telinit to change
       the system's runlevel....
effettuando la wait ascolta lo stato degli zombi che terminano!!!  
per questo si uccide il padre di un uno zombi proprio per farlo ascoltare da init...
se c'č uno zombie con ppid 1 prob c'č un bug da qualche parte. 


 se c'č uno zombie con ppid 1 prob c'č un bug da qualche parte. 
Ho capito, THNX per la spiegazione !!


scozzesi, contro gli zombi ci vuole la polverina del barone samdi'
Baron Samedi (pronunciato samedi', perche' infatti significa "Sabato")
...e quella penso che TRASFORMI in zombie.
Leonardo
".signature": bad command or file name