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é prt (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> ».