WAIT

NOME

SINTASSI

pid_t wait(int *status);

pid_t waitpid(pid_t pid, int *status, int opzioni);

int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int opzioni);

Test delle funzioni e requisiti delle macro per glibc (vedere feature_test_macros(7)):

waitid(): _SVID_SOURCE || _XOPEN_SOURCE  

DESCRIZIONE

Se un figlio ha già cambiato stato, allora le chiamate tornano immediatamente. Altrimenti esse si bloccano fino a quando un 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 figlio il cui stato è cambiato, e che nessuna di queste chiamate di sistema ha aspettato, è definito aspettabile.  

wait() e waitpid()

    waitpid(-1, &status, 0);

La chiamata di sistema waitpid() sospende l'esecuzione del processo chiamante fino a quando un 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.

> 0

che significa aspettare il 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 figlio è uscito.

WUNTRACED

torna anche se un figlio si è arrestato (ma non tracciato attraverso ptrace(2)). Lo stato del 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 figlio arrestato è stato riesumato inviando SIGCONT.

(Per le opzioni solo Linux vedere oltre).

Le opzioni WUNTRACED e WCONTINUED hanno effetto solo se il flag SA_NOCLDSTOP non è stato impostato per il segnale SIGCHLD (vedere sigaction(2)).

Se status 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(stato)

restituisce true se il figlio è terminato normalmente, ovvero, chiamando exit(3) o _exit(2), o tornando da main().

WEXITSTATUS(stato)

ritorna lo stato di uscita del figlio. Esso consiste negli 8 bit meno significativi dell'argomento status che il 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(stato)

restituisce true se il processo figlio è stato terminato da un segnale.

WTERMSIG(stato)

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(stato)

restituisce true se il figlio ha prodotto un core dump. 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 tra #ifdef WCOREDUMP ... #endif.

WIFSTOPPED(stato)

restituisce true se il processo figlio è stato arrestato inviando un segnale; questo è possibile solo se la chiamata è stata effettuata usando WUNTRACED o quando il figlio è stato tracciato (vedere ptrace(2)).

WSTOPSIG(stato)

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(stato)

(A partire da Linux 2.6.10) restituisce true se il processo figlio è stato riesumato inviando SIGCONT.

waitid()

Gli argomenti idtype e id selezionano il figlio(i) da aspettare, come segue:

idtype == P_PID

Aspetta il figlio il cui ID di processo corrisponde a id.

idtype == P_PGID

Aspetta qualunque figlio il cui ID di gruppo del processo corrisponda a id.

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 figlio che è terminato.

WSTOPPED

Aspetta il 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 figlio in uno stato in attesa; una successiva chiamata di attesa può essere usata per trovare di nuovo l'informazione sullo stato del 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 figlio.

si_uid

L'ID reale dell'utente del 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 figlio, come dato a _exit(2) (o exit(3)), o il segnale che ha causato la terminazione, l'arresto o la continuazione del figlio. Il campo si_code può essere usato per determinare come interpretare questo campo.

si_code

Imposta a uno tra: CLD_EXITED (figlio chiamato _exit(2)); CLD_KILLED (figlio terminato da un segnale); CLD_STOPPED (figlio arrestato da un segnale); o CLD_CONTINUED (figlio continuato da SIGCONT).

Se WNOHANG è stato specificato in opzioni e non c'erano figli in uno stato di attesa, allora waitid() restituisce immediatamente 0, e lo stato della struttura siginfo_t a cui punta infop non è specificato. Per distinguere questo caso da quello in cui un figlio era in uno stato di attesa, 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.  

VALORI RESTITUITI

waitpid(): in caso di successo, restituisce l'ID del processo del 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 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.  

ERRORI

ECHILD

(per wait()) Il processo chiamante non ha nessun figlio inaspettato.

ECHILD

(per waitpid() o waitid()) Il processo specificato da pid (waitpid()) o idtype e id (waitid()) non esiste o non è un figlio del processo chiamante. (Ciò può accadere per il 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 untercettato un segnale sbloccato o un SIGCHLD.

EINVAL

Gli argomenti delle opzioni non erano validi.

CONFORME A

NOTE

POSIX.1-2001 specifica che se la disposizione di SIGCHLD è impostata a SIG_IGN o il flag SA_NOCLDWAIT è settato per SIGCHLD (vedere sigaction(2)), allora 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 SIGCHILD è "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 figlio termina e quindi restituisce l'ID del processo e lo stato di questo figlio.  

Note Linux

Le seguenti opzioni specifiche di Linux devono essere usate con i figli creati usando clone(2); esse non possono essere usate con waitid():

__WCLONE

Aspetta solo i figli di "clone". Se omessa allora aspetta solo i figli "non-clone". (Un 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(apartiredaLinux2.4)

Non aspetta figli di altri thread nello stesso gruppo del thread. Questo era il comportamento predefinito prima di Linux 2.4.

ESEMPIO

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 <stdlib.h>
#include <unistd.h>
#include <stdio.h>

int
main(int argc, char *argv[])
{
    pid_t cpid, w;
    int status;

    cpid = fork();
    if (cpid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (cpid == 0) {            /* Codice eseguito dal figlio */
        printf("Child PID is %ld\n", (long) getpid());
        if (argc == 1)
            pause();                    /* Aspetta i segnali */
        _exit(atoi(argv[1]));

    } else {                    /* codice eseguito dal genitore */
        do {
            w = waitpid(cpid, &status, WUNTRACED | WCONTINUED);
            if (w == -1) {
                perror("waitpid");
                exit(EXIT_FAILURE);
            }

            if (WIFEXITED(status)) {
                printf("exited, status=%d\n", WEXITSTATUS(status));
            } else if (WIFSIGNALED(status)) {
                printf("killed by signal %d\n", WTERMSIG(status));
            } else if (WIFSTOPPED(status)) {
                printf("stopped by signal %d\n", WSTOPSIG(status));
            } else if (WIFCONTINUED(status)) {
                printf("continued\n");
            }
        } while (!WIFEXITED(status) && !WIFSIGNALED(status));
        exit(EXIT_SUCCESS);
    }
}

VEDERE ANCHE

COLOPHON

Index

NOME

SINTASSI

DESCRIZIONE

wait() e waitpid()

waitid()

VALORI RESTITUITI

ERRORI

CONFORME A

NOTE

Note Linux

ESEMPIO

VEDERE ANCHE

COLOPHON