Newsgroup: it.comp.os.linux.development
Titolo: Fork: ma il figlio deve chiudere tutto?

Salve NG,
In una fork la parte del programma del figlio (pid == 0) deve proprio
chiudere tutti i file descriptor aperti dal padre ?
Cioe' se prima di chiamare fork ho file aperti, socket, comunicazione
seriale, ecc. il figlio deve per prima cosa occuparsi di chiudere tutta sta
roba prima di fare le sue cose ?
Grazie, Nicola.
-- 
chi va pian va san e va lontan

 roba prima di fare le sue cose ?
Per esserti d'aiuto
http://www.die.net/doc/linux/man/man2/fork.2.html
"
Dopo il successo dell'esecuzione di una fork sia il processo padre che
il processo figlio continuano ad essere eseguiti normalmente a partire
dall'istruzione successiva alla fork; il processo figlio è però una
copia del padre, e riceve una copia dei segmenti di testo, stack e dati
(vedi sez. 2.2.2), ed esegue esattamente lo stesso codice del padre. Si
tenga presente però che la memoria è copiata, non condivisa, pertanto
padre e figlio vedono variabili diverse. "
http://www.lilik.it/~mirko/gapil/gapilsu37.html#x82-520003.2.2
Ritornando alla tua domanda, no non ne hai di bisogno.

 chiudere tutti i file descriptor aperti dal padre ?
Non c'è scritto da nessuna parte che deve chiuderli tutti, anche perché
alcuni potrebbero servire. (Il caso tipico è la pipe creata nel padre e
usata per far comunicare i due processi.)
Quelli che non chiude, però, restano aperti. Se nel padre c'è una
connessionea aperta, nel figlio ci sarà un "clone" di quella connessione,
che resterà aperta finché non saranno chiusi entrambi i file descriptor.
Max
 

 
Questo mi preoccupa, perche' temo di avere troppa roba aperta da gestire.


Salvatore Di Fazio wrote:

Scusa un momento: il padre ha una connessione seriale aperta e il figlio
anzi i figli hanno aperta la stessa porta seriale. Se i figli non chiudono
il proprio file descriptor della porta seriale, questa non potra' mai
essere chiusa, o sbaglio ?


 essere chiusa, o sbaglio ?
Se il padre sta occupando una seriale e i figli vogliono usare la
stessa (dove, logicamente
non dovrai cambiare la velocità e tutti i dati relativi alla seriale)
dovrai gestire opportunamente
il tutto con dei semafori e chi apre l'fd per la seriale dovrà
chiuderlo.
Tipicamente:
 padre (fd seriale)
   |
   | -> figlio (fd passato dal padre, fa il suo lavoro, esce)
   | -> figlio (fd passato dal padre, fa il suo lavoro, esce)
   | -> figlio (fd passato dal padre, fa il suo lavoro, esce)
   | fine
padre libera l'fd.

Salvatore Di Fazio wrote:

A dire il vero i figli non la devono proprio usare la seriale, e nemmeno i
socket che ho aperto con altre 2 apparecchi, per non parlare della
connessione a mysql. Devono solo fornire i dati di una struttura (circa 200
variabili).
E qui ho il problema di reperire il valore delle variabili del padre
(memoria condivisa ?)


 (memoria condivisa ?)
Si devi usare la memoria condivisa.

Salvatore Di Fazio wrote:

Ok, grazie.
Avevo pensato anche di forkare subito il programma prima di aprire i vari
fd, ed usare il figlio per forkare a sua volta le connessioni via socket
dei client. Cosi' i figli in questo caso non erediterebbero fd aperti.
Non so pero' se e' una cosa furba :P
