Provided by: manpages-it-dev_4.23.1-1_all 
NOME
wait, waitpid, waitid - aspetta che il processo cambi stato
LIBRERIA
Libreria C standard (libc, -lc)
SINTASSI
#include <sys/wait.h>
pid_t wait(int *_Nullable wstatus);
pid_t waitpid(pid_t pid, int *_Nullable wstatus, int options);
int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int opzioni);
/* Questa è l'interfaccia di glibc e POSIX ; si veda
NOTES for informazioni sulla chiamata di sistema diretta. */
Macro per test di funzionalità per glibc (vedere feature_test_macros(7)):
waitid():
Since glibc 2.26:
_XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L
glibc 2.25 and earlier:
_XOPEN_SOURCE
|| /* Since glibc 2.12: */ _POSIX_C_SOURCE >= 200809L
|| /* glibc <= 2.19: */ _BSD_SOURCE
DESCRIZIONE
Tutte queste chiamate di sistema si usano per attendere cambiamenti di stato in un
processo figlio del processo chiamante, e ottenere informazioni sul processo figlio il cui
stato è cambiato. Un cambiamento di stato avviene quando: il processo figlio è terminato;
il processo figlio è stato arrestato da un segnale; il processo figlio è stato
ripristinato da un segnale. In caso di un processo figlio terminato, un'attesa permette
al sistema di rilasciare le risorse associate al processo figlio; se non viene eseguita
un'attesa, allora il processo figlio terminato rimane in uno stato "zombie" (vedere le
NOTE sotto).
Se un processo figlio ha già cambiato stato, allora le chiamate tornano immediatamente.
Altrimenti esse si bloccano fino a quando un processo figlio cambia stato o un gestore di
segnale interrompe la chiamata (supponendo che le chiamate di sistema non siano
automaticamente riavviate usando il flag SA_RESTART di sigaction(2)). Nel resto di questa
pagina un processo figlio il cui stato è cambiato, e che nessuna di queste chiamate di
sistema ha aspettato, è definito aspettabile.
wait() e waitpid()
La chiamata di sistema wait() sospende l'esecuzione del thread chiamante fino a quando uno
dei suoi figli termina. La chiamata wait(&wstatus) è equivalente a:
waitpid(-1, &wstatus, 0);
La chiamata di sistema waitpid() sospende l'esecuzione del thread chiamante fino a quando
un processo figlio specificato dall'argomento pid ha cambiato stato. Il comportamento
predefinito di waitpid() è attendere solo i figli terminati, ma questo comportamento è
modificabile attraverso l'argomento opzioni come descritto di seguito.
Il valore di pid può essere:
< -1 che significa attesa di qualunque processo figlio il cui gruppo ID del processo sia
uguale al valore assoluto di pid.
-1 che significa aspettare qualunque processo figlio.
0 che significa aspettare qualunque processo figlio il cui gruppo ID del processo sia
uguale a quello del processo chiamante al momento della chiamata a waitpid().
> 0 che significa aspettare il processo figlio il cui ID di processo sia uguale al
valore di pid.
Il valore di opzioni è un OR di zero o più delle seguenti costanti:
WNOHANG
torna immediatamente se nessun processo figlio è uscito.
WUNTRACED
torna anche se un processo figlio si è arrestato (ma non tracciato attraverso
ptrace(2)). Lo stato del processo figlio non tracciato che è stato arrestato è
fornito anche se l'opzione non è specificata.
WCONTINUED (a partire da Linux 2.6.10)
torna anche se un processo figlio arrestato è stato riesumato inviando SIGCONT.
(Per le opzioni solo Linux vedere oltre).
Se wstatus non è NULL, wait() e waitpid() memorizzano l'informazione di stato in int a cui
punta. Questo intero può essere verificato con le seguenti macro (che prendono lo stesso
intero come argomento, non come un puntatore ad esso, come fanno wait() e waitpid()!):
WIFEXITED(wstatus)
restituisce true se il processo figlio è terminato normalmente, ovvero, chiamando
exit(3) o _exit(2), o tornando da main().
WEXITSTATUS(wstatus)
ritorna lo stato di uscita del processo figlio. Esso consiste negli 8 bit meno
significativi dell'argomento status che il processo figlio ha specificato in una
chiamata a exit(3) o _exit(2) o come argomento per una dichiarazione di ritorno in
main(). Questa macro deve essere impiegata solo se WIFEXITED restituisce true.
WIFSIGNALED(wstatus)
restituisce true se il processo figlio è stato terminato da un segnale.
WTERMSIG(wstatus)
restituisce il numero del segnale che ha causato l'arresto del processo figlio.
Questa macro deve essere impiegata solo se WIFSIGNALED ha restituito true.
WCOREDUMP(wstatus)
restituisce true se il processo figlio ha prodotto un core dump (si veda core(5)).
Questa macro deve essere impiegata solo se WIFSIGNALED ha restituito true.
Questa macro non è specificata in POSIX.1-2001 e non è disponibile in alcune
implementazioni Unix (per esempio AIX, SunOS). Usarla solo racchiusa all'interno di
#ifdef WCOREDUMP ... #endif.
WIFSTOPPED(wstatus)
restituisce true se il processo figlio è stato arrestato inviando un segnale;
questo è possibile solo se la chiamata è stata effettuata usando WUNTRACED o quando
il processo figlio è stato tracciato (vedere ptrace(2)).
WSTOPSIG(wstatus)
restituisce il numero del segnale che ha causato l'arresto del processo figlio.
Questa macro deve essere impiegata solo se WIFSTOPPED ha restituito true.
WIFCONTINUED(wstatus)
(A partire da Linux 2.6.10) restituisce true se il processo figlio è stato
riesumato inviando SIGCONT.
waitid()
La chiamata di sistema waitid() (disponibile a partire da Linux 2.6.9) fornisce un
controllo più preciso su quale cambiamento di stato del processo figlio aspettare.
Gli argomenti idtype e id selezionano il processo figlio(i) da aspettare, come segue:
idtype == P_PID
Aspetta il processo figlio il cui ID di processo corrisponde a id.
idtype == P_PIDFD (a partire da Linux 5.4)
Aspetta il processo figlio a cui fa riferimento il descrittore di file di PID
specificato in id. (Si veda pidfd_open(2) per ulteriori informazioni sui
descrittori di file di PID.)
idtype == P_PGID
Aspetta qualunque processo figlio il cui ID di gruppo del processo corrisponda a
id. Da Linux 5.4, se id è zero, aspetta qualsiasi processo figlio che è nello
stesso gruppo di processi del gruppo di processi del chiamante al momento della
chiamata.
idtype == P_ALL
Aspetta qualunque processo figlio; id è ignorato.
Il cambiamento di stato del processo figlio da aspettare è specificato eseguendo un OR su
uno o più dei seguenti flag in opzioni:
WEXITED
Aspetta il processo figlio che è terminato.
WSTOPPED
Aspetta il processo figlio che è stato arrestato con l'invio di un segnale.
WCONTINUED
Aspetta i figli (precedentemente arrestati) che sono stati riesumati inviando
SIGCONT.
Si può inoltre eseguire un OR sui seguenti flag in opzioni:
WNOHANG
Come per waitpid().
WNOWAIT
Lascia il processo figlio in uno stato aspettabile; una successiva chiamata di
attesa può essere usata per trovare di nuovo l'informazione sullo stato del
processo figlio.
In seguito a un ritorno con successo, waitid() riempie i seguenti campi della struttura
siginfo_t a cui punta infop:
si_pid L'ID di processo del processo figlio.
si_uid L'ID reale dell'utente del processo figlio. (Questo campo non viene impostato nella
maggior parte delle altre implementazioni.)
si_signo
Imposta sempre a SIGCHLD.
si_status
O lo stato di uscita del processo figlio, come dato a _exit(2) (o exit(3)), o il
segnale che ha causato la terminazione, l'arresto o la continuazione del processo
figlio. Il campo si_code può essere usato per determinare come interpretare questo
campo.
si_code
Imposta a uno tra: CLD_EXITED (processo figlio chiamato _exit(2)); CLD_KILLED
(processo figlio terminato da un segnale); CLD_DUMPED (processo figlio terminato da
un segnale, ed eseguito un core dump); CLD_STOPPED (processo figlio arrestato da un
segnale); CLD_TRAPPED (il processo figlio tracciato è stato bloccato); o
CLD_CONTINUED (processo figlio continuato da SIGCONT).
Se WNOHANG è stato specificato in opzioni e non c'erano figli in uno stato aspettabile,
allora waitid() restituisce immediatamente 0, e lo stato della struttura siginfo_t a cui
punta infop dipende dall'implementazione. Per distinguere (in modo portabile) questo caso
da quello in cui un processo figlio era in uno stato aspettabile, il campo si_pid viene
impostato a zero prima della chiamata e, dopo il ritorno della chiamata, verifica che in
questo campo non ci sia un valore zero.
POSIX.1-2008 Technical Corrigendum 1 (2013) aggiunge il requisito secondo il quale, quando
viene specificato WNOHANG nelle opzioni e non ci sono figli in uno stato aspettabile,
waitid() dovrebbe impostate a zero i campi si_pid e si_signo della struttura. Su Linux e
altre implementazioni che aderiscono a questi requisiti, non è necessario azzerare il
campo si_pid prima di chiamare waitid(). Comunque, non tutte le implementazioni seguono le
specifiche POSIX.1 riguardo a questo punto.
VALORE RESTITUITO
wait(): in caso di successo, restituisce l'ID del processo del processo figlio terminato;
in caso di insuccesso restituisce -1.
waitpid(): in caso di successo, restituisce l'ID del processo del processo figlio il cui
stato è cambiato; se WNOHANG era specificato e uno o più figli specificati da pid esiste,
ma non ha ancora cambiato stato, allora viene restituito 0. In caso di insuccesso
restituisce -1.
waitid(): restituisce 0 in caso di successo o se WNOHANG era specificato e nessun processo
figlio(i) specificato da id ha ancora cambiato stato; in caso di insuccesso restituisce
-1.
Ciascuna di queste chiamate imposta errno ad un valore per indicare l'errore.
ERRORI
EAGAIN The PID file descriptor specified in id is nonblocking and the process that it
refers to has not terminated.
ECHILD (per wait()) Il processo chiamante non ha nessun processo figlio inaspettato.
ECHILD (per waitpid() o waitid()) Il processo specificato da pid (waitpid()) o idtype e id
(waitid()) non esiste o non è un processo figlio del processo chiamante (ciò può
accadere per il processo figlio di un processo se l'azione per SIGCHLD è impostata
a SIG_IGN. Vedere anche la sezione Note Linux sui thread).
EINTR WNOHANG non era impostata ed è stato intercettato un segnale sbloccato o un
SIGCHLD; vedere signal(7).
EINVAL Gli argomenti delle opzioni non erano validi.
ESRCH (per wait() o waitpid()) pid è uguale a INT_MIN.
VERSIONI
Differenze tra la libreria C e il kernel
wait() è in realtà una funzione di libreria che (in glibc) è implementata come una
chiamata a wait4(2).
Su alcune architetture, non c'è nessuna chiamata di sistema waitpid(); invece, questa
interfaccia è implementata attraverso una funzione wrapper della libreria C che chiama
wait4(2).
La chiamata di sistema diretta waitid() accetta un quinto argomento, di tipo struct
rusage *. Se questo argomento non è NULL, viene usato per restituire informazioni sull'uso
delle risorse del processofiglio, allo stesso modo di wait4(2). Vedere getrusage(2) per i
dettagli.
CONFORME A
POSIX.1-2008.
STORIA
SVr4, 4.3BSD, POSIX.1-2001.
NOTE
Un processo figlio che termina, ma in modo inaspettato, diviene uno "zombie". Il kernel
mantiene un insieme minimo di informazioni sui processi zombie (PID, stato di
terminazione, informazioni sull'uso delle risorse) allo scopo di permettere al padre di
eseguire in seguito un wait per ottenere informazioni sul processo figlio. Se uno zombie
non viene rimosso dal sistema attraverso un wait, esso consumerà uno slot nella tabella
dei processi del kernel, e se questa tabella si riempie, non sarà possibile creare
ulteriori processi. Se un processo padre termina, allora i suoi figli "zombie" (se ce ne
sono) sono adottati da init(1) (o dal processo "subreaper" più vicino come definito
attraverso l'uso dell'operazione prctl(2) PR_SET_CHILD_SUBREAPER); init(1) esegue
automaticamente un wait per rimuovere gli zombie.
POSIX.1-2001 specifica che se la disposizione di SIGCHLD è impostata a SIG_IGN o il flag
SA_NOCLDWAIT è impostato per SIGCHLD (vedere sigaction(2)), i figli terminati non
diventano zombie e una chiamata a wait() o waitpid() verrà bloccata fino a quando tutti i
figli sono terminati, e in seguito fallisce con errno impostato a ECHILD. (Lo standard
POSIX originale lasciava il comportamento di impostare SIGCHLD a SIG_IGN non specificato.
Si noti che, anche se la disposizione predefinita di SIGCHLD è "ignore", impostarla
esplicitamente a SIG_IGN comporterà un diverso trattamento dei processi figlio zombie).
Linux 2.6 è conforme a questa specifica. Tuttavia Linux 2.4 (e precedenti) non lo è: se
una chiamata wait() o waitpid() è effettuata mentre SIGCHLD è ignorato, la chiamata si
comporta come se SIGCHLD non fosse stato ignorato, ovvero, la chiamata si blocca fino a
quando il prossimo processo figlio termina e quindi restituisce l'ID del processo e lo
stato di questo processo figlio.
Note Linux
Nel kernel Linux un thread programmato dal kernel non è un costrutto distinto da un
processo. Invece un thread è semplicemente un processo creato usando la chiamata esclusiva
di Linux clone(2); altre routine come la chiamata portabile pthread_create(3) sono
implementate usando clone(2). Prima di Linux 2.4 un thread era solo un caso speciale di un
processo, e come conseguenza un thread non poteva aspettare il processo figlio di un altro
thread, anche se l'ultimo apparteneva allo stesso gruppo del thread. Tuttavia POSIX
prescrive tale funzionalità, e a partire da Linux 2.4 un thread può, e in modo predefinito
lo fa, aspettare il processo figlio di un altro thread nello stesso gruppo del thread.
Le seguenti opzioni specifiche di Linux devono essere usate con i figli creati usando
clone(2); esse possono anche essere usate, a partire da Linux 4.07, con waitid():
__WCLONE
Aspetta solo i figli di "clone". Se omessa allora aspetta solo i figli "non-clone".
(Un processo figlio "clone" è uno che non invia segnali, o un segnale diverso da
SIGCHLD ai suoi genitori quando viene terminato). Questa opzione è ignorata se
viene anche specificato __WALL.
__WALL (a partire da Linux 2.4)
Aspetta tutti i figli, qualunque sia il loro tipo ("clone" o "non-clone").
__WNOTHREAD (a partire da Linux 2.4)
Non aspetta figli di altri thread nello stesso gruppo del thread. Questo era il
comportamento predefinito prima di Linux 2.4.
A partire da Linux 4.7, il flag __WALL è automaticamente sottinteso se il processo figlio
è tracciato con ptrace.
BUG
Secondo POSIX.1-2008, un'applicazione che chiama waitid() deve assicurarsi che infop punti
ala struttura siginfo_t (cioé, che sia un puntatore non-NULL). Su Linux, se infop è NULL,
waitid() va a buon fine, e ritorna l'ID di processo del processo figlio aspettato. Le
applicazioni dovrebbero evitare di contare su questa caratteristica non conforme, non
standard e non necessaria.
ESEMPI
Il seguente programma dimostra l'uso di fork(2) e waitpid(). Il programma crea un processo
figlio. Se dalla linea di comando non viene fornito alcun argomento al programma, allora
il processo figlio sospende la propria esecuzione usando pause(2), per permettere
all'utente di mandare il segnale al processo figlio. Altrimenti, se viene fornito un
argomento dalla linea di comando, allora il processo figlio esce immediatamente, usando
l'intero fornito dalla linea di comando come stato di uscita. Il processo genitore esegue
un ciclo che controlla il processo figlio usando waitpid(), e usa le macro W*() descritte
sopra per analizzare il valore dello stato diattesa.
La seguente sessione di shell dimostra l'uso del programma:
$ ./a.out &
Child PID is 32360
[1] 32359
$ kill -STOP 32360
stopped by signal 19
$ kill -CONT 32360
continued
$ kill -TERM 32360
killed by signal 15
[1]+ Done ./a.out
$
Sorgente del programma
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int
main(int argc, char *argv[])
{
int wstatus;
pid_t cpid, w;
cpid = fork();
if (cpid == -1) {
perror("fork");
exit(EXIT_FAILURE);
}
if (cpid == 0) { /* Code executed by child */
printf("Child PID is %jd\n", (intmax_t) getpid());
if (argc == 1)
pause(); /* Wait for signals */
_exit(atoi(argv[1]));
} else { /* Code executed by parent */
do {
w = waitpid(cpid, &wstatus, WUNTRACED | WCONTINUED);
if (w == -1) {
perror("waitpid");
exit(EXIT_FAILURE);
}
if (WIFEXITED(wstatus)) {
printf("exited, status=%d\n", WEXITSTATUS(wstatus));
} else if (WIFSIGNALED(wstatus)) {
printf("killed by signal %d\n", WTERMSIG(wstatus));
} else if (WIFSTOPPED(wstatus)) {
printf("stopped by signal %d\n", WSTOPSIG(wstatus));
} else if (WIFCONTINUED(wstatus)) {
printf("continued\n");
}
} while (!WIFEXITED(wstatus) && !WIFSIGNALED(wstatus));
exit(EXIT_SUCCESS);
}
}
VEDERE ANCHE
_exit(2), clone(2), fork(2), kill(2), ptrace(2), sigaction(2), signal(2), wait4(2),
pthread_create(3), core(5), credentials(7), signal(7)
TRADUZIONE
La traduzione italiana di questa pagina di manuale è stata creata da Giulio Daprelà
<giulio@pluto.it>, Elisabetta Galli <lab@kkk.it> e Marco Curreli <marcocurreli@tiscali.it>
Questa traduzione è documentazione libera; leggere la GNU General Public License Versione
3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ o successiva per le condizioni di copyright.
Non ci assumiamo alcuna responsabilità.
Per segnalare errori nella traduzione di questa pagina di manuale inviare un messaggio a
⟨pluto-ildp@lists.pluto.it⟩.