| WAIT(2) | Manuale del programmatore di Linux | WAIT(2) |
wait, waitpid, waitid - aspetta che il processo cambi stato
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *wstatus);
pid_t waitpid(pid_t pid, int *wstatus, int opzioni);
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. */
waitid():
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.
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:
Il valore di opzioni è un OR di zero o più delle seguenti costanti:
(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()!):
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:
Il cambiamento di stato del processo figlio da aspettare è specificato eseguendo un OR su uno o più dei seguenti flag in opzioni:
Si può inoltre eseguire un OR sui seguenti flag in opzioni:
In seguito a un ritorno con successo, waitid() riempie i seguenti campi della struttura siginfo_t a cui punta infop:
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.
wait(): in caso di successo, restituisce l'ID del processo del processo figlio terminato; in caso di errore 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 errore 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 errore restituisce -1.
Ciascuna di queste chiamate imposta errno ad un valore appropriato in caso di errore.
SVr4, 4.3BSD, POSIX.1-2001.
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.
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():
A partire da Linux 4.7, il flag __WALL è automaticamente sottinteso se il processo figlio è tracciato con ptrace.
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.
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.
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 $
#include <sys/wait.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
int
main(int argc, char *argv[])
{
pid_t cpid, w;
int wstatus;
cpid = fork();
if (cpid == -1) {
perror("fork");
exit(EXIT_FAILURE);
}
if (cpid == 0) { /* Codice eseguito dal processo figlio */
printf("Child PID is %jd\n", (intmax_t) getpid());
if (argc == 1)
pause(); /* Aspetta i segnali */
_exit(atoi(argv[1]));
} else { /* codice eseguito dal genitore */
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);
}
}
_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)
Questa pagina fa parte del rilascio 5.10 del progetto Linux man-pages. Una descrizione del progetto, le istruzioni per la segnalazione degli errori, e l'ultima versione di questa pagina si trovano su https://www.kernel.org/doc/man-pages/.
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 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.
| 1 novembre 2020 | Linux |