Provided by: manpages-fr-dev_3.32d0.2p4-1_all bug

NOM

       wait, waitpid, waitid - Attendre la fin d'un processus

SYNOPSIS

       #include <sys/types.h>
       #include <sys/wait.h>

       pid_t wait(int *status);

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

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

   Exigences    de    macros    de   test   de   fonctionnalités   pour   la   glibc   (consultez
   feature_test_macros(7)) :

       waitid() :
           _SVID_SOURCE || _XOPEN_SOURCE >= 500 || _XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED
           || /* Depuis la glibc 2.12 : */ _POSIX_C_SOURCE >= 200809L

DESCRIPTION

       Tous ces appels système attendent qu'un des fils du processus appelant change  d'état,  et
       permettent  d'obtenir des informations sur le fils en question. Un processus est considéré
       comme changeant d'état s'il termine, s'il est stoppé par un signal, ou  s'il  est  relancé
       par  un  signal.  Dans  le  cas  d'un fils qui se termine, l'attendre permet au système de
       libérer les ressources qui lui étaient allouées ; si le processus n'est  pas  attendu,  il
       reste en état de « zombie » (voir les NOTES plus bas).

       Si  un  fils a déjà changé d'état, ces appels système retournent immédiatement. Sinon, ils
       bloquent jusqu'à ce qu'un fils change d'état ou qu'un gestionnaire  de  signal  interrompe
       l'appel  (sauf si les appels système sont relancés automatiquement par l'option SA_RESTART
       de sigaction(2)). Dans la suite de cette page, un fils qui a changé d'état et qui n'a  pas
       été attendu est appelé prêt (waitable).

   wait() et waitpid()
       L'appel  système  wait()  suspend l'exécution du processus appelant jusqu'à ce que l'un de
       ses enfants se termine. L'appel wait(&status) est équivalent à :

           waitpid(-1, &status, 0);

       L'appel système waitpid() suspend l'exécution du processus appelant jusqu'à ce qu'un  fils
       spécifié  par  l'argument  pid  change d'état. Par défaut, waitpid() n'attend que les fils
       terminés, mais ce comportement peut être modifié  par  l'argument  options,  de  la  façon
       décrite ci-dessous.

       La valeur de pid peut être l'une des suivantes :

       < -1   Attendre la fin de n'importe quel processus fils appartenant au groupe de processus
              d'ID -pid.

       -1     Attendre n'importe lequel des processus fils.

       0      Attendre la fin de n'importe quel processus fils du même groupe que l'appelant.

       > 0    Attendre la fin du processus numéro pid.

       La valeur de l'argument option options est un OU binaire entre les constantes suivantes :

       WNOHANG     Ne pas bloquer si aucun fils ne s'est terminé.

       WUNTRACED   Recevoir l'information concernant également les fils bloqués (mais non  suivis
                   par  ptrace(2))  si  on  ne  l'a  pas encore reçue. L'état des fils suivis est
                   fourni même sans cette option.

       WCONTINUED (Depuis Linux 2.6.10)
                   Renvoyer également si un processus fils stoppé a été  relancé  par  le  signal
                   SIGCONT.

       (Pour les options spécifiques à Linux, voir plus bas.)

       Si  status n'est pas NULL, wait() et waitpid() stockent l'état du fils dans la variable de
       type int pointée. Cet entier peut être évalué avec  les  macros  suivantes  (qui  prennent
       l'entier  lui-même  comme argument, et pas un pointeur vers celui-ci, comme le font wait()
       et waitpid() !) :

       WIFEXITED(status)
              Vrai si le fils s'est terminé normalement, c'est-à-dire par un appel à  exit(3)  ou
              _exit(2), ou par un return depuis main().

       WEXITSTATUS(status)
              Donne  le  code  de  retour, consistant en les 8 bits de poids faibles du paramètre
              status fourni à exit(3) ou _exit(2) ou dans le return de la routine  main().  Cette
              macro ne peut être évaluée que si WIFEXITED est non nul.

       WIFSIGNALED(status)
              Vrai si le fils s'est terminé à cause d'un signal non intercepté.

       WTERMSIG(status)
              Donne  le  numéro  du  signal  qui a causé la fin du fils. Cette macro ne peut être
              évaluée que si WIFSIGNALED est non nul.

       WCOREDUMP(status)
              Vrai si le processus fils a produit une image mémoire (« core dump »). Cette  macro
              ne doit être évaluée que si WIFSIGNALED a renvoyé une valeur non nulle. Cette macro
              n'est pas décrite par POSIX.1-2001 et n'est pas disponible sur certaines  variantes
              d'UNIX  (par  exemple  AIX  ou SunOS). N'utilisez cette macro qu'entourée de #ifdef
              WCOREDUMP ... #endif.

       WIFSTOPPED(status)
              Vrai si le fils est actuellement arrêté. Cela n'est possible que si l'on a effectué
              l'appel avec l'option WUNTRACED ou si le fils est suivi (voir ptrace(2)).

       WSTOPSIG(status)
              Donne  le  numéro  du  signal qui a causé l'arrêt du fils. Cette macro ne peut être
              évaluée que si WIFSTOPPED est non nul.

       WIFCONTINUED(status)
              (Depuis Linux 2.6.10) Vrai si le processus fils a été relancé par SIGCONT.

   waitid()
       L'appel système waitid(), disponible depuis Linux 2.6.9, fournit des moyens plus  fins  de
       contrôler quels changements d'états attendre.

       Les arguments idtype et id sélectionnent le(s) fils à attendre, comme suit :

       idtype == P_PID
              Attendre la fin du processus numéro id.

       idtype == P_PGID
              Attendre  la  fin  de  n'importe  quel  processus  fils  appartenant à un groupe de
              processus d'ID id.

       idtype == P_ALL
              Attendre n'importe quel fils ; l'argument id est ignoré.

       Les changements d'état à attendre sont indiqués par un OU binaire des  attributs  suivants
       dans le paramètre options :

       WEXITED     Attendre les fils qui se sont terminés.

       WSTOPPED    Attendre les enfants qui ont été arrêtés par un signal.

       WCONTINUED  Attendre  les  enfants précédemment arrêtés qui ont été relancés par le signal
                   SIGCONT.

       Les attributs suivants peuvent également être utilisés dans options :

       WNOHANG     Comme pour waitpid().

       WNOWAIT     Laisser le fils dans un état prêt ; un appel  ultérieur  à  wait()  pourra  de
                   nouveau fournir des informations sur l'état du fils.

       Si l'appel réussit, waitid() remplit les champs suivants de la structure siginfo_t pointée
       par infop :

       si_pid      L'identifiant de processus du fils.

       si_uid      L'UID réel du fils. Ce champ n'est  pas  rempli  par  la  plupart  des  autres
                   implémentations.

       si_signo    Toujours SIGCHLD.

       si_status   Soit  le  code  de  retour du fils donné à _exit(2) ou exit(3), soit le signal
                   ayant provoqué la terminaison, l'arrêt,  ou  la  relance  du  fils.  Le  champ
                   si_code permet de savoir comment interpréter ce champ.

       si_code     L'un  de CLD_EXITED (le fils a appelé _exit(2)), CLD_KILLED (le fils a été tué
                   par un signal), CLD_DUMPED (le fils a été tué par un signal, et a produit  une
                   image  (core  dump)),  CLD_STOPPED  (le  fils  a  été  arrêté  par un signal),
                   CLD_TRAPPED (le fils suivi a été rattrapé) ou CLD_CONTINUED  (le  fils  a  été
                   relancé par SIGCONT).

       Si  WNOHANG  est  utilisé  dans  options  et  aucun  fils  n'est  prêt, waitid() renvoie 0
       immédiatement et l'état de la structure siginfo_t pointée par  infop  n'est  pas  précisé.
       Pour  différencier  ce cas de celui où un des fils était prêt, fixez le champ si_pid avant
       l'appel, et vérifiez sa valeur après le retour.

VALEUR RENVOYÉE

       wait() : en cas de réussite, l'identifiant du processus fils terminé est renvoyé ; en  cas
       d'erreur, la valeur de retour est -1.

       waitpid() :  s'il  réussit,  l'appel renvoie l'identifiant du processus fils dont l'état a
       changé ; si WNOHANG est utilisé et un fils (ou plus) spécifié par  pid  existe,  mais  n'a
       toujours pas changé d'état, la valeur de retour est 0. En cas d'erreur, -1 est renvoyé.

       waitid() :  renvoie  0  s'il  réussit  ou  si WNOHANG est utilisé et aucun fils n'a changé
       d'état. En cas d'erreur, il renvoie -1. Chacun de ces appels système positionne errno à la
       valeur appropriée en cas d'erreur.

ERREURS

       ECHILD (pour wait()) Le processus appelant n'a pas de fils qui n'ont pas été attendus.

       ECHILD (pour  waitpid() ou waitid()) Le processus indiqué par pid (waitpid()) ou idtype et
              id (waitid()) n'existe pas, ou n'est pas un fils du processus appelant. (Ceci  peut
              arriver  pour  son  propre  fils si l'action de SIGCHLD est placé sur SIG_IGN, voir
              également le passage de la section Notes sur Linux concernant les threads.)

       EINTR  WNOHANG n'est pas indiqué, et un signal à  intercepter  ou  SIGCHLD  a  été  reçu ;
              consultez signal(7).

       EINVAL L'argument options est invalide.

CONFORMITÉ

       SVr4, BSD 4.3, POSIX.1-2001.

NOTES

       Un  fils  qui se termine mais n'a pas été attendu devient un « zombie ». Le noyau conserve
       des  informations  minimales  sur  le  processus  zombie  (identifiant,  code  de  retour,
       informations  d'utilisation  des  ressources)  pour permettre au parent de l'attendre plus
       tard et d'obtenir des informations sur le fils. Tant que le zombie  n'est  pas  effacé  du
       système  par  une attente, il prendra un emplacement dans la table des processus du noyau,
       et si cette table est remplie, il sera impossible de créer de nouveaux  processus.  Si  un
       processus  parent  se  termine,  ses fils zombies sont adoptés par init(8), qui les attend
       automatiquement pour les supprimer.

       POSIX.1-2001 indique que si l'action pour SIGCHLD est fixée à  SIG_IGN  ou  si  l'attribut
       SA_NOCLDWAIT est indiqué pour SIGCHLD (voir sigaction(2)), les enfants qui se terminent ne
       deviennent pas des zombies et un appel à wait() ou waitpid() sera bloquant jusqu'à ce  que
       tous  les  fils  soient  terminés, et échouera ensuite en positionnant errno à ECHILD. (La
       norme POSIX originale ne décrivait pas le comportement  si  l'action  pour  SIGCHLD  était
       SIG_IGN.  Veuillez  noter que même si la disposition par défaut de SIGCHLD est « ignore »,
       la configuration explicite de la disposition de SIG_IGN entraîne un  traitement  différent
       des  processus fils zombies.) Linux 2.6 se conforme à cette norme. Cependant, ce n'est pas
       le cas de Linux 2.4 et précédents : si un appel à wait() ou waitpid() est fait  alors  que
       SIGCHLD  est  ignoré, l'appel se comporte comme si SIGCHLD n'était pas ignoré, ce qui veut
       dire qu'il attend jusqu'à ce que le prochain fils se termine, et renvoie l'identifiant  et
       le code de retour de ce fils.

   Notes sur Linux
       Dans  le  noyau  Linux,  un thread ordonnancé par le noyau n'est pas différent d'un simple
       processus. En fait, un thread est juste un processus qui est créé à l'aide de la routine —
       spécifique  à  Linux  —  clone(2).  Les  routines portables, comme pthread_create(3), sont
       implémentées en appelant clone(2). Avant Linux 2.4, un  thread  était  simplement  un  cas
       particulier  de processus, et en conséquence un thread ne pouvait pas attendre les enfants
       d'un autre thread, même si ce dernier appartenait au même groupe  de  threads.  Toutefois,
       POSIX  réclame  une  telle fonctionnalité, et depuis Linux 2.4 un thread peut, par défaut,
       attendre les enfants des autres threads du même groupe.

       Les options suivantes sont spécifiques à Linux, et servent pour  les  enfants  créés  avec
       clone(2) ; elles ne peuvent pas être utilisées avec waitid() :

       __WCLONE
              Attendre  uniquement  des  enfants  clones.  Sinon, attendre uniquement les enfants
              non-clones (un enfant « clone » est un enfant qui n'envoie pas  de  signal,  ou  un
              autre  signal que SIGCHLD à son père à sa terminaison). Cette option est ignorée si
              __WALL est aussi indiqué.

       __WALL (depuis Linux 2.4)
              Attendre tous les enfants, quel que soit leur type (clone ou non-clone).

       __WNOTHREAD (Depuis Linux 2.4)
              Ne pas attendre les enfants des autres threads du  même  groupe  de  threads.  Ceci
              était le cas par défaut avant Linux 2.4.

EXEMPLE

       Le programme suivant montre l'utilisation de fork(2) et de waitpid(). Le programme crée un
       processus fils. Si aucun argument n'est fourni dans la ligne de commande du programme,  le
       fils  suspend  son  exécution avec pause(2), pour que l'utilisateur puisse lui envoyer des
       signaux. Sinon, le fils se termine immédiatement, en  utilisant  l'entier  fourni  sur  la
       ligne  de commande comme code de retour. Le processus père boucle en surveillant l'état du
       fils avec waitpid(), et utilise les macros W*() décrites ci-dessus pour analyser  le  code
       d'état du fils.

       La session interactive suivante montre l'utilisation de ce programme :

           $ ./a.out &
           Le PID du fils est 32360
           [1] 32359
           $ kill -STOP 32360
           arrêté par le signal 19
           $ kill -CONT 32360
           relancé
           $ kill -TERM 32360
           tué par le signal 15
           [1]+  Done                    ./a.out
           $

   Source du programme

       #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) {            /* Code exécuté par le fils */
               printf("Le PID du fils est %ld\n", (long) getpid());
               if (argc == 1)
                   pause();                    /* Attendre un signal */
               _exit(atoi(argv[1]));

           } else {                    /* Code exécuté par le père */
               do {
                   w = waitpid(cpid, &status, WUNTRACED | WCONTINUED);
                   if (w == -1) {
                       perror("waitpid");
                       exit(EXIT_FAILURE);
                   }

                   if (WIFEXITED(status)) {
                       printf("terminé, code=%d\n", WEXITSTATUS(status));
                   } else if (WIFSIGNALED(status)) {
                       printf("tué par le signal %d\n", WTERMSIG(status));
                   } else if (WIFSTOPPED(status)) {
                       printf("arrêté par le signal %d\n", WSTOPSIG(status));
                   } else if (WIFCONTINUED(status)) {
                       printf("relancé\n");
                   }
               } while (!WIFEXITED(status) && !WIFSIGNALED(status));
               exit(EXIT_SUCCESS);
           }
       }

VOIR AUSSI

       _exit(2),  clone(2),  fork(2),  kill(2),  ptrace(2),  sigaction(2),  signal(2),  wait4(2),
       pthread_create(3), credentials(7), signal(7)

COLOPHON

       Cette page fait partie de la publication 3.32 du projet man-pages Linux.  Une  description
       du  projet  et  des  instructions  pour  signaler  des  anomalies  peuvent être trouvées à
       l'adresse <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis   2010,   cette   traduction   est   maintenue   à   l'aide   de    l'outil    po4a
       <URL:http://po4a.alioth.debian.org/>  par  l'équipe  de  traduction francophone au sein du
       projet perkamon <URL:http://perkamon.alioth.debian.org/>.

       Christophe  Blaess  <URL:http://www.blaess.fr/christophe/>   (1996-2003),   Alain   Portal
       <URL:http://manpagesfr.free.fr/>  (2003-2006).  Julien  Cristau et l'équipe francophone de
       traduction de Debian (2006-2009).

       Veuillez     signaler     toute     erreur     de     traduction     en     écrivant     à
       <debian-l10n-french@lists.debian.org>   ou   par   un  rapport  de  bogue  sur  le  paquet
       manpages-fr.

       Vous pouvez toujours avoir accès à la version anglaise de  ce  document  en  utilisant  la
       commande « man -L C <section> <page_de_man> ».