NOME

       fork - crea un processo figlio

SINTASSI

       #include <unistd.h>

       pid_t fork(void);

DESCRIZIONE

       fork() crea un nuovo processo duplicando il processo chiamante. Il nuovo processo, che chiameremo figlio,
       è un esatto duplicato del processo chiamante, chiamato genitore, tranne che per i seguenti punti:

       *      Il  figlio  ha il suo ID unico di processo, e questo ID non corrisponde all'ID di nessun gruppo di
              processi esistente (setpgid(2)).

       *      L'ID di processo del figlio di un genitore è uguale all'ID di processo del genitore.

       *      Il figlio non eredita i blocchi di memoria del suo genitore (mlock(2), mlockall(2)).

       *      L'utilizzo delle risorse di processo (getrusage(2)) e i contatori del tempo  CPU  (times(2))  sono
              reimpostati a zero nel figlio.

       *      Il set di segnali in attesa nel figlio è inizialmente vuoto. (sigpending(2)).

       *      Il figlio non eredita le regolazioni dei semafori dal suo genitore (semop(2)).

       *      Il figlio non eredita i blocchi sui record dal genitore (fcntl(2)).

       *      Il figlio non eredita i temporizzatori dal genitore (setitimer(2), alarm(2), timer_create(3)).

       *      Il  figlio  non  eredita  le  operazioni rilevanti di I/O asincrono dal suo genitore (aio_read(3),
              aio_write(3)).

       Gli attributi del processo nel precedente elenco sono  tutti  specificati  in  POSIX.1-2001.  Genitore  e
       figlio inoltre sono differenti tra loro rispetto ai seguenti attributi dei processi specifici di Linux:

       *   Il  figlio  non  eredita  le  notifiche  di  cambio  directory (dnotify) dal suo genitore (si veda la
           descrizione di F_NOTIFY in fcntl(2)).

       *   Le impostazioni di prctl(2) PR_SET_PDEATHSIG sono azzerate in  modo  che  il  figlio  non  riceva  un
           segnale quando il suo genitore termina.

       *   Le  mappe  di  memoria che sono state marcate con il flag madvise(2) MADV_DONTFORK non sono ereditate
           attraverso un fork(2).

       *   Il segnale di termine del figlio è sempre SIGCHLD (vedere clone(2)).

       Notare i seguenti punti ulteriori:

       *   Il processo figlio è creato con un thread singolo — quello che ha chiamato fork(2).  L'intero  spazio
           di  indirizzamento  virtuale  del  genitore  è  replicato  nel  figlio,  inclusi gli stati dei mutex,
           variabili condizionali, e altri oggetti pthreads; l'uso di pthread_atfork(3) può essere di aiuto  per
           trattare i problemi che questo può causare.

       *   Il  figlio  eredita copie del set di descrittori del file aperto del genitore. Ciascun descrittore di
           file nel figlio fa  riferimento  alla  stessa  descrizione  di  file  aperto  (vedere  open(2))  come
           corrispondente descrittore di file nel genitore. Questo significa che i due descrittori condividono i
           flag  di  stato del file aperto, gli offset correnti del file, e gli attributi degli I/O pilotati dai
           segnali (vedere la descrizione di F_SETOWN e F_SETSIG in fcntl(2)).

       *   Il figlio eredita copie del set di descrittori della coda dei messaggi aperti  del  genitore  (vedere
           mq_overview(7)).  Ciascun descrittore nel figlio fa riferimento alla stessa descrizione della coda di
           messaggi aperti del corrispondente descrittore nel genitore. Questo significa che i  due  descrittori
           condividono gli stessi flag (mq_flags).

       *   Il  figlio  eredita  copie  del  set  di flussi di directory aperti dal genitore (vedere opendir(3)).
           POSIX.1-2001 dice che i corrispondenti flussi di directory  nel  genitore  e  nel  figlio  potrebbero
           condividere il posizionamento dei flussi di directory; in Linux/glicb non lo fanno.

VALORE RESTITUITO

       In  caso  di  successo il PID del processo figlio viene restituito nel genitore, e viene restituito 0 nel
       figlio. In caso di fallimento verrà restituito -1 nel genitore, non verrà creato alcun processo figlio, e
       errno verrà impostata di conseguenza.

ERRORI

       EAGAIN fork() non può allocare memoria sufficiente per copiare per copiare le tabelle  della  pagina  del
              genitore e allocare un struttura di task per il figlio.

       EAGAIN Non  è  stato  possibile  creare  un  nuovo  processo, perché è stato raggiunto il limite delle le
              risorse del RLIMIT_NPROC chiamante. Per superare tale  limite  il  processo  deve  avere  capacità
              CAP_SYS_ADMIN o CAP_SYS_RESOURCE.

       ENOMEM fork() non è stato possibile allocare le strutture necessarie del kernel perché c'è poca memoria.

CONFORME A

       SVr4, 4.3BSD, POSIX.1-2001.

NOTE

       Sotto  Linux,  fork()  è  implementato  usando  pagine copy-on-write, in modo che la penalità nella quale
       incorre sia il tempo e la memoria necessari per duplicare le page table del genitore, e  per  creare  una
       struttura di task unica per il figlio.

       A  partire  dalla  versione  2.3.3  il  wrapper  di  glibc fork() fornito insieme all'implementazione del
       threading di NPTL, anziché invocare la chiamata di sistema del  kernel  fork()  chiama  clone(2)  con  le
       opzioni  necessarie  per  ottenere lo stesso risultato della chiamata di sistema tradizionale. Il wrapper
       glibc invocherà ogni gestore di fork definito usando pthread_atfork(3).

ESEMPIO

       Vedere pipe(2) e wait(2).

VEDERE ANCHE

       clone(2), execve(2), setrlimit(2), unshare(2), vfork(2), wait(2), capabilities(7), credentials(7)

COLOPHON

       Questa pagina fa parte del rilascio 2.80 del progetto man-pages di Linux. Si può trovare una  descrizione
       del progetto, e informazioni su come riportare bachi, presso http://www.kernel.org/doc/man-pages/. Per la
       traduzione in italiano si può fare riferimento a http://www.pluto.it/ildp/collaborare/

Linux                                            22 aprile 2008                                          FORK(2)