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/