[C] Processi zombie e orfani

[vfldj]

Ciao a tutti, ho molti dubbi sulla system call fork().. Non ho capito bene come funziona e quindi non ho capito cosa sono i processi zombie e quelli orfani.
So che la fork serve per creare un nuovo processo. Il processo che ha fatto fork diventa un padre mentre quello creato è il figlio il quale svolge le stesse operazioni del padre a meno che non si esegua una exec().
Ora, se un figlio muore e il padre resta vivo che succede?
Se invece muore il padre e non il figlio? In quest'ultimo caso ho capito che il processo figlio viene adottato dal processo init, giusto? Cos'è quest'init?
Gli zombie e gli orfani come si creano? Come si evitano?
Cosa cambia (supponiamo in un ciclo infinito) se faccio forkare ogni volta il padre oppure se faccio forkare il figlio?

Per farove spiegatemelo in maniera moooolto semplice.. Ho già letto parecchie cose sul web ma non mi è ancora tutto chiaro.. Non ho trovato nessun disegno che "spiegasse" in maniera chiara il fatto che un processo viene adottato.. Non me lo immagino..

Grazie infinite

[MItaly]

La fork() crea un clone del processo correntemente in esecuzione; uno dei due (quello a cui la fork restituisce un pid) diventa il processo "padre", l'altro è figlio di quest'ultimo (e spesso userà una qualche variante della exec per caricare il codice di un altro programma da eseguire).

Ovviamente questo porta al formarsi di una gerarchia (ad albero) di processi, in cima alla quale c'è il processo init, che è il primo processo user-mode del sistema; esso ha PID 1, è sempre in esecuzione, si occupa di avviare/terminare tutti gli altri processi fondamentali all'avvio e ai cambiamenti di runlevel e adotta i processi orfani (su questo torno dopo).

Quello che accade di solito è che il processo padre, ad un certo punto, attenderà la terminazione del processo figlio usando la syscall wait; questa attende che il processo figlio termini e fornisce al processo padre il codice di uscita.
Uno scenario di questo genere si ha ad esempio in una shell: quando esegui un comando (che so, ls) la shell fa una fork; il processo figlio fa una exec per eseguire effettivamente il programma richiesto al suo interno, mentre il processo padre (la shell) farà una wait sul pid del figlio, bloccando l'esecuzione finché il figlio non ha terminato.

Rispetto a questo scenario "classico" possono capitare fondamentalmente due "deviazioni":
- il processo figlio termina prima che il processo padre chiami la wait su di esso; si ha un processo zombie;
- il processo padre termina prima del processo figlio; si ha un processo orfano.

Come detto, un processo zombie è un processo che ha terminato la sua esecuzione, ma che non è stato "atteso" (tramite la wait) dal processo padre; per tutti i fini pratici è ormai un processo "morto" (dato che è terminato non ha più bisogno di tempo di CPU, di spazio di indirizzi virtuale, tabelle di descrittori file, ...), ma sopravvive nella tabella dei processi del kernel perché il processo padre ha ancora il "diritto" di fare una wait su di esso (per ottenerne il codice di uscita e altre informazioni sullo stato del processo figlio nel momento in cui è terminato); nel momento in cui il processo padre effettua la wait, gli viene fornito il codice di uscita, il processo zombie sparisce (perché non serve più a niente) e il suo PID può essere riciclato per altri processi.

Se invece il processo padre termina prima che il figlio abbia terminato, il processo figlio diventa un "orfano", e viene "adottato" da init - ovvero, il suo processo padre diventa init; init quindi si occupa di chiamare la wait sui processi orfani, in maniera tale da evitare che questi quando terminano diventino indefinitamente zombie (se fossero privi di un processo padre non ci sarebbe modo di chiamare la wait su di essi, e, una volta terminati, resterebbero indefinitamente zombie).

Questo è di base come funziona la questione sui sistemi di famiglia Unix, poi di fatto ci sono un po' di varianti sul tema, a cui si accenna negli articoli di Wikipedia su processi zombie e processi orfani, e/o nella documentazione del sistema operativo particolare in uso (in particolare vedi la manpage di wait & co.).

[vfldj]

Sei stato chiarissimo!
Ho solo un dubbio: se ho una gerarchia del tipo bisnonno-nonno-padre-figlio-ecc.. (quindi è il figlio che genera altri figli, non l'unico padre) e il processo padre termina, in questo caso il processo figlio viene adottato da init o da nonno? E poi, appena figlio termina sarà per pochissimo tempo un orfano e poi diventerà figlio di nonno/init, oppure è considerato immediatamente adottato?
Non so se sono riuscito a spiegarmi bene...
Comunque grazie mille!

[MItaly]

Originariamente inviato da vfldj
Sei stato chiarissimo!
Ho solo un dubbio: se ho una gerarchia del tipo bisnonno-nonno-padre-figlio-ecc.. (quindi è il figlio che genera altri figli, non l'unico padre) e il processo padre termina, in questo caso il processo figlio viene adottato da init o da nonno?

Da init; il nonno in effetti in generale non ha idea di che processi possano aver creato i suoi processi figli, e trovarseli "tra i piedi" inaspettatamente darebbe diversi problemi. init, invece, sa che tra i suoi compiti c'è quello di adottare gli orfani, e non è quindi una condizione imprevista trovarsi dei processi figli in più.

E poi, appena figlio termina sarà per pochissimo tempo un orfano e poi diventerà figlio di nonno/init, oppure è considerato immediatamente adottato?

Nel momento in cui il processo padre termina i processi figli vengono direttamente passati come figli di init, per cui non sono mai davvero senza un processo padre; la terminologia "processo orfano" non si riferisce quindi al non avere un processo padre in assoluto, quanto alla perdita del processo padre originario.

[vfldj]

Capito! Grazie