Newsgroup: it.comp.os.linux.development
Titolo: Processi zombie

Salve,
ho programmato una semplice architettura client-server dove il server ha lo
scopo di fornire servizi richiesti da un certo numero di client.
L'ambiente dove programmo è la Suse Linux 6.3
Il server si mette in attesa di richieste da parte dei client, e, ogni volta
che arriva una richiesta, genera un figlio (tramite una fork()) il quale
comincia ad effettuare il servizio.
Nel frattempo il padre, invece di mettersi in attesa della terminazione del
figlio, si rimette immediatamente ad attendere altre eventuali richieste.
Ecco il problema:
quando i figli terminano il loro compito, questi rimangono nel sistema sotto
forma di processi zombie (basta sare un'occhiata al task-manager), nonostante
io tenti di terminarli ponendo una istruzione exit() alla fine della loro
esecuzione.
COme faccio a fare in modo che una volta terminati, essi abbandonino il sistema
in modo definitivo?
Grazie
-- 
Posted from 
net145-162.mclink.it
 [195.110.145.162] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 in modo definitivo?
Roberto,
   i figli restano in zombie per permettere al padre di accedere alla loro
informazione di uscita. Se escono, il padre non potra` piu' sapere come e
quando hanno finito. Per questa ragione Linux tiene i processi figli disponibili
come zombies.
  Per farli uscire da questo stato il padre deve dichiarare di non essere
piu' interessato allo stato dei figli. Per farlo, bisogna dichiarare un
handler per SIGCHLD, handler che chiama wait() e esce. Questa e` la procedura
piu' standard. Una seconda procedura, che funziona solo su qualche Unix, e`
di mettere SIGCHLD a SIG_IGN.
  Quindi, soluzione preferita (da verificare, scrivo a memoria):
signal( SIGCHLD, fineProc );
void fineProc( int signo ) {
  int   stat;
  wait( &stat );
}
Ciao,
-- 
       Roberto Divia`             Love at first sight is one of the greatest
       =============             labor-saving devices the world has ever seen.
Mailbox: C02110                 CERN-European Organization for Nuclear Research
E-mail: 
Robert...@cern.ch
           CH-1211 GENEVE 23, Switzerland

 }
anche qui e` meglio usare waitpid e fare un loop tipo:
void sampleserv_chld_hand(int signo)
{
    pid_t pid;
    int stat;
    while ( (pid=waitpid(-1,&stat,WNOHANG))>0 ) {
        debug("child %d terminated\n",pid);
    }
    return;
}
Ciao
Simone

purtroppo non ho modo di postare un esempio concreto pero' mi sono imbattuto
talvolta in zombie che non erano figli su cui non si era eseguito wait e
cose ancora piu' strane
in teoria poi, killando il padre i suoi figli-zombie dovrebbero diventare
figli di init e quindi scomparire, eppure anche per questo ho esempi strani
di zombie "resistenti".
mi spiace essere cosi' approssimativo, ma spero che sappiate darmi
ugualmente qualche delucidazione
bye
Touch

 strani di zombie "resistenti".
Se il processo resta bloccato dentro il kernel in uninterruptible sleep non 
lo ucciderai mai (se succede lo vedi perche` suo ppid e` 1), ma questo e` 
molto raro ed in genere indica un problema del driver.
Ciao
Simone

init sono figli di un altro processo.
io leggo: "non erano figli su cui non si era eseguito wait"
-- 
Nato nel vizio, morto nel supplizio
Nato nel peccato, ad entrare sia invitato

 typedef void SigFunc(int);
Forse e' meglio typedef void (SigFunc*)(int)
ci sono in giro compilatori riottosi ad accettare
la prima forma :-).
C:\>iao Angelo