Newsgroup: it.comp.os.linux.development
Titolo: execl() e zombie (crosspost)

 
è normale che dopo execl() in un fork() ksysguard si riempie di 
zombie? cosa c'è di sbagliato?
 
codice di test:
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
int run(void) {
   if (!fork()) {
     puts("questo è il processo figlio");
     execl("/bin/sleep", "sleep", "6", NULL);
     puts("execl() non ha funzionato");
     _exit (EXIT_FAILURE);
   }
}
 
int main(int argc, char **argv) {
   int i;
   puts("questo è il processo padre");
   for (i = 0; i < 10; ++i) {
     run();
     sleep(2);
   }
   puts("dopo l\'ultima chiamata di execl() aspetto 10 secondi");
   sleep(10);
   return 0;
}
 
-- 
bye
!(!1|1)
 
 


wrote:

Cio' che si vede, e'.
 

 cosa c'� di sbagliato?
 
I processi zombie sono quei processi morti
il cui processo padre non ha ancora recepito
(e credo confermato) che sono morti.
 
Come scrive Marco, "wait" dovrebbe fare al
caso tuo.
 
bye,
 
-- 
 
piergiorgio

 man 2 wait
 
grazie
mi ero fatto fuorviare dal fatto che non volevo bloccare il processo 
parent in attesa del child, ma tutto sommato questo non dovrebbe 
creare problemi...
 
-- 
bye
!(!1|1)

 problemi...
 
Credo sia possibile, ma non so come, far
ereditare i processi figli ad "init".
 
Devi dare un'occhiata a qualche sorgente
di qualche demone.
 
bye,
 
-- 
 
piergiorgio


 
Basta che il padre muoia prima dei figli, è ' unico modo


 dovrebbe creare problemi...
 
$ man 3 daemon
 
Il processo padre diventa uno zombie perchï¿œ i figli ereditano i 
descrittori standard di I/O ed impediscono al padre di liberare le 
risorse.
 
La funzione daemon() non ï¿œ direttamente applicabile all'esempio ma 
dovrebbe essere facilmente emulabile.
 
Ciao
Giovanni
-- 
   A computer is like an air conditioner,
   it stops working when you open Windows.
   < 
http://giovanni.homelinux.net/
 >


il motivo è semplice, il padre deve recepire la morte del figlio
Se non lo fa il kernel mette il processo defunto in stato zombi in 
attesa che il processo padre prima o poi lo faccia
Esistono due modi, uno sincrono e l' altro asincrono
In modalità sincrona basta una chiamata ad una syscall della famiglia 
wait,in modalità asincrona occorre impostare un handler sul segnale SIGCHLD
Quando un figlio muore l' handler viene eseguito ed il padre può fare la 
wait
 
 
 


Non serve bloccare, puoi chiamare wait in un signal handler, vedi SIGCHLD.
 
 
Ciao  Manlio

 La funzione daemon() non è direttamente applicabile all'esempio ma


 eseguito ed il padre può fare la wait
 
Leggendo la pagina di wikipedia, esiste un altro modo in POSIX.1-2001: 
dire al kernel di fare il reap del processo figlio in modo automatico.
http://en.wikipedia.org/wiki/Child_process
 
 
 
Ciao  Manlio

 ereditare i processi figli ad "init".
 
se non ho frainteso il man waitpid() o waitid() con WNOHANG o WNOWAIT 
come parametro non bloccano il processo parent, solo che forse poi 
bisognerebbe richiamarle fino a che il child non ha terminato...
 
comunque ho visto che il processo che avviavo (una notifica con 
kdialog --nopopup) ritorna subito (poi proverò ad interfacciarmi 
direttamente con dbus o con libnotify)
 
-- 
bye
!(!1|1)
 

 Non serve bloccare, puoi chiamare wait in un signal handler, vedi SIGCHLD.
 
grazie... farò una ricerca con google...
-- 
bye
!(!1|1)
 

 
http://en.wikipedia.org/wiki/Child_process
 
 
grazie... proverò anche quello...
 
-- 
bye
!(!1|1)
 

 la wait
 
ok, grazie
 
-- 
bye
!(!1|1)