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 PID non corrisponde all'ID di nessun
          gruppo di processi esistente (setpgid(2)).

       *  L'ID di processo-genitore del figlio è 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  dal  genitore  i  blocchi  sui  record  associati ai processi
          (fcntl(2)).  (D'altra parte, esso non eredita i  blocchi  delle  descrizioni  dei  file
          aperti fcntl(2) e i blocchi flock(2) dal suo genitore.)

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

       *  Il figlio non eredita le  operazioni  rilevanti  di  I/O  asincrono  dal  suo  genitore
          (aio_read(3),  aio_write(3)),  né  eredita  alcun  contesto  di  I/O  asincrono dal suo
          genitore (vedere io_setup(2)).

       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.

       *  Il valore predefinito della tolleranza del temporizzatore (timer slack) è impostato  al
          valore   corrente   della   tolleranza   del  genitore.   Si  veda  la  descrizione  di
          PR_SET_TIMERSLACK in prctl(2).

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

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

       *  I  bit dei permessi della porta di accesso impostati da ioperm(2) non vengono ereditati
          dal figlio; il figlio deve rendere attivo ogni bit che  è  richiesto  richiesto  usando
          ioperm(2).

       Notare i seguenti punti ulteriori:

       *  Il  processo  figlio  è  creato  con un thread singolo — quello che ha chiamato fork().
          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 le opzioni 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  le  stesse  opzioni
          (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  possono  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 le tabelle della pagina del
              genitore e allocare un struttura di task per il figlio.

       EAGAIN

              È  stato  raggiunto  un  limite  imposto dal sistema sul numero di thread.  Ci sono
              diversi limiti che possono causare questo errore: è stato raggiunto il limite delle
              risorse  soft  RLIMIT_NPROC  (impostato  con setrlimit(2)), che limita il numero di
              processi e di thread per l'ID dell'utente reale; è stato  raggiunto  il  limite  di
              sistema del kernel sul numero di processi e di thread, /proc/sys/kernel/threads-max
              (vedi   proc(5));   o   è   stato   raggiunto   il   mumero   massimo    di    PID,
              /proc/sys/kernel/pid_max (vedi proc(5)).

       EAGAIN Il   chiamante  sta  operando  sotto  le  regole  di  pianificazione  dei  processi
              SCHED_DEADLINE e non ha l'opzione reset-on-fork impostato.  Vedi sched(7).

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

       ENOSYS fork()  non  è  supportato  su  questa piattaforma (per esempio, hardware senza una
              Memory-Management Unit).

CONFORME A

       SVr4, 4.3BSD, POSIX.1-2001.

NOTE

       Sotto Linux, fork() è implementato usando  pagine  copy-on-write,  in  modo  che  la  sola
       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.   (Una  chiamata  a fork() è equivalente a una
       chiamata a clone(2)  specificando  le  opzioni  solo  come  SIGCHLD.)   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),  exit(2),  setrlimit(2),  unshare(2),  vfork(2), wait(2), daemon(3),
       capabilities(7), credentials(7)

COLOPHON

       Questa pagina fa parte del rilascio 3.73 del progetto Linux  man-pages.   Una  descrizione
       del  progetto,  le  istruzioni  per  la  segnalazione degli errori, e l'ultima versione di
       questa pagina si trova su http://www.kernel.org/doc/man-pages/.

       La versione italiana fa parte del pacchetto man-pages-it v. 3.73, a cura di: ILDP "Italian
       Linux Documentation Project" http://www.pluto.it/ildp
       Per     la     traduzione     in     italiano     si     può     fare     riferimento    a
       http://www.pluto.it/ildp/collaborare/
       Segnalare eventuali errori di traduzione a ildp@pluto.it