Provided by: manpages-it_2.80-3_all bug

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/