Provided by: manpages-fr-dev_3.27fr1.4-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 fonctionnalites pour la glibc (consultez
   feature_test_macros(7)) :

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

DESCRIPTION

       Tous ces appels systeme attendent qu'un des fils du processus  appelant
       change  d'etat, et permettent d'obtenir des informations sur le fils en
       question. Un  processus  est  considere  comme  changeant  d'etat  s'il
       termine,  s'il  est  stoppe  par  un signal, ou s'il est relance par un
       signal. Dans le cas d'un fils qui  se  termine,  l'attendre  permet  au
       systeme  de  liberer  les  ressources  qui lui etaient allouees ; si le
       processus n'est pas attendu, il reste en etat de << zombie >> (voir les
       NOTES plus bas).

       Si  un  fils  a  deja  change  d'etat,  ces  appels  systeme retournent
       immediatement. Sinon, ils bloquent jusqu'a ce qu'un fils change  d'etat
       ou  qu'un gestionnaire de signal interrompe l'appel (sauf si les appels
       systeme  sont  relances  automatiquement  par  l'option  SA_RESTART  de
       sigaction(2)). Dans la suite de cette page, un fils qui a change d'etat
       et qui n'a pas ete attendu est appele pr^et (waitable).

   wait() et waitpid()
       L'appel  systeme  wait()  suspend  l'execution  du  processus  appelant
       jusqu'a  ce  que  l'un de ses enfants se termine. L'appel wait(&status)
       est equivalent a :

           waitpid(-1, &status, 0);

       L'appel systeme waitpid() suspend  l'execution  du  processus  appelant
       jusqu'a  ce  qu'un  fils specifie par l'argument pid change d'etat. Par
       defaut, waitpid() n'attend que les fils termines, mais ce  comportement
       peut   etre  modifie  par  l'argument  options,  de  la  facon  decrite
       ci-dessous.

       La valeur de pid peut etre 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 meme groupe
              que l'appelant.

       > 0    Attendre la fin du processus numero 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 termine.

       WUNTRACED   Recevoir   l'information   concernant  egalement  les  fils
                   bloques (mais non suivis par ptrace(2)) si on  ne  l'a  pas
                   encore  recue.  L'etat des fils suivis est fourni meme sans
                   cette option.

       WCONTINUED (Depuis Linux 2.6.10)
                   Renvoyer egalement  si  un  processus  fils  stoppe  a  ete
                   relance par le signal SIGCONT.

       (Pour les options specifiques a Linux, voir plus bas.)

       Si  status  n'est pas NULL, wait() et waitpid() stockent l'etat du fils
       dans la variable de type int pointee. Cet entier peut etre evalue  avec
       les macros suivantes (qui prennent l'entier lui-meme comme argument, et
       pas un pointeur vers celui-ci, comme le font wait() et waitpid() !) :

       WIFEXITED(status)
              Vrai si le fils s'est termine normalement, c'est-a-dire  par  un
              appel a 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 parametre status fourni a exit(3) ou _exit(2) ou dans
              le return de la routine main(). Cette macro ne peut etre evaluee
              que si WIFEXITED est non nul.

       WIFSIGNALED(status)
              Vrai  si  le  fils  s'est  termine  a  cause  d'un  signal   non
              intercepte.

       WTERMSIG(status)
              Donne  le  numero  du  signal  qui a cause la fin du fils. Cette
              macro ne peut etre evaluee que si WIFSIGNALED est non nul.

       WCOREDUMP(status)
              Vrai si le processus fils a produit une image  memoire  (<< core
              dump >>).  Cette macro ne doit etre evaluee que si WIFSIGNALED a
              renvoye une valeur non nulle. Cette macro n'est pas decrite  par
              POSIX.1-2001  et  n'est  pas  disponible sur certaines variantes
              d'Unix (par  exemple  AIX  ou  SunOS).  N'utilisez  cette  macro
              qu'entouree de #ifdef WCOREDUMP ... #endif.

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

       WSTOPSIG(status)
              Donne  le  numero  du  signal qui a cause l'arret du fils. Cette
              macro ne peut etre evaluee que si WIFSTOPPED est non nul.

       WIFCONTINUED(status)
              (Depuis Linux 2.6.10) Vrai si le processus fils  a  ete  relance
              par SIGCONT.

   waitid()
       L'appel  systeme  waitid(),  disponible depuis Linux 2.6.9, fournit des
       moyens plus fins de controler quels changements d'etats attendre.

       Les arguments idtype et id selectionnent le(s) fils a  attendre,  comme
       suit :

       idtype == P_PID
              Attendre la fin du processus numero id.

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

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

       Les changements d'etat a attendre sont indiques par un OU  binaire  des
       attributs suivants dans le parametre options :

       WEXITED     Attendre les fils qui se sont termines.

       WSTOPPED    Attendre les enfants qui ont ete arretes par un signal.

       WCONTINUED  Attendre  les  enfants  precedemment  arretes  qui  ont ete
                   relances par le signal SIGCONT.

       Les attributs suivants peuvent egalement etre utilises dans options :

       WNOHANG     Comme pour waitpid().

       WNOWAIT     Laisser le fils dans un etat pret ; un  appel  ulterieur  a
                   wait()  pourra  de  nouveau  fournir  des  informations sur
                   l'etat du fils.

       Si  l'appel  reussit,  waitid()  remplit  les  champs  suivants  de  la
       structure siginfo_t pointee par infop :

       si_pid      L'identifiant de processus du fils.

       si_uid      L'UID  reel  du  fils.  Ce  champ  n'est  pas rempli par la
                   plupart des autres implementations.

       si_signo    Toujours SIGCHLD.

       si_status   Soit le code de retour du fils donne a _exit(2) ou exit(3),
                   soit  le  signal ayant provoque la terminaison, l'arret, ou
                   la relance du fils.  Le  champ  si_code  permet  de  savoir
                   comment interpreter ce champ.

       si_code     L'un  de CLD_EXITED (le fils a appele _exit(2)), CLD_KILLED
                   (le fils a ete tue par un signal), CLD_DUMPED  (le  fils  a
                   ete tue par un signal, et a produit une image (core dump)),
                   CLD_STOPPED  (le  fils  a  ete  arrete  par   un   signal),
                   CLD_TRAPPED (le fils suivi a ete rattrape) ou CLD_CONTINUED
                   (le fils a ete relance par SIGCONT).

       Si WNOHANG est utilise dans options et aucun fils n'est pret,  waitid()
       renvoie 0 immediatement et l'etat de la structure siginfo_t pointee par
       infop n'est pas precise. Pour differencier ce cas de celui  ou  un  des
       fils  etait  pret,  fixez le champ si_pid avant l'appel, et verifiez sa
       valeur apres le retour.

VALEUR RENVOY'EE

       wait() : en cas de reussite, l'identifiant du  processus  fils  termine
       est renvoye ; en cas d'erreur, la valeur de retour est -1.

       waitpid() :  s'il  reussit,  l'appel renvoie l'identifiant du processus
       fils dont l'etat a change ; si WNOHANG est utilise et un fils (ou plus)
       specifie par pid existe, mais n'a toujours pas change d'etat, la valeur
       de retour est 0. En cas d'erreur, -1 est renvoye.

       waitid() : renvoie 0 s'il reussit ou si WNOHANG est  utilise  et  aucun
       fils  n'a  change d'etat. En cas d'erreur, il renvoie -1. Chacun de ces
       appels systeme positionne errno a la valeur appropriee en cas d'erreur.

ERREURS

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

       ECHILD (pour  waitpid()  ou  waitid())  Le  processus  indique  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 place sur  SIG_IGN,  voir
              egalement  le  passage  de la section Notes sur Linux concernant
              les threads.)

       EINTR  WNOHANG n'est pas indique, et un signal a intercepter ou SIGCHLD
              a ete recu ; consultez signal(7).

       EINVAL L'argument options est invalide.

CONFORMIT'E

       SVr4, BSD 4.3, POSIX.1-2001.

NOTES

       Un   fils   qui  se  termine  mais  n'a  pas  ete  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 efface du systeme par une attente, il prendra un  emplacement
       dans la table des processus du noyau, et si cette table est remplie, il
       sera impossible de creer de nouveaux processus. Si un processus  parent
       se  termine,  ses fils zombies sont adoptes par init(8), qui les attend
       automatiquement pour les supprimer.

       POSIX.1-2001 indique que si l'action pour SIGCHLD est fixee  a  SIG_IGN
       ou   si   l'attribut   SA_NOCLDWAIT  est  indique  pour  SIGCHLD  (voir
       sigaction(2)), les enfants qui  se  terminent  ne  deviennent  pas  des
       zombies  et un appel a wait() ou waitpid() sera bloquant jusqu'a ce que
       tous les fils soient termines,  et  echouera  ensuite  en  positionnant
       errno  a  ECHILD.  (La  norme  POSIX  originale  ne  decrivait  pas  le
       comportement si l'action pour SIGCHLD etait SIG_IGN. Veuillez noter que
       meme  si  la  disposition  par  defaut  de SIGCHLD est << ignore >>, la
       configuration explicite  de  la  disposition  de  SIG_IGN  entraine  un
       traitement different des processus fils zombies.) Linux 2.6 se conforme
       a cette norme.  Cependant,  ce  n'est  pas  le  cas  de  Linux  2.4  et
       precedents :  si  un  appel  a  wait()  ou waitpid() est fait alors que
       SIGCHLD est ignore, l'appel se comporte comme si  SIGCHLD  n'etait  pas
       ignore,  ce  qui veut dire qu'il attend jusqu'a 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  ordonnance  par  le  noyau  n'est  pas
       different  d'un  simple  processus.  En  fait,  un  thread est juste un
       processus qui est cree a l'aide de la routine -- specifique a Linux  --
       clone(2).   Les   routines  portables,  comme  pthread_create(3),  sont
       implementees en appelant clone(2). Avant Linux  2.4,  un  thread  etait
       simplement un cas particulier de processus, et en consequence un thread
       ne pouvait pas attendre les enfants  d'un  autre  thread,  meme  si  ce
       dernier appartenait au meme groupe de threads. Toutefois, POSIX reclame
       une telle fonctionnalite, et depuis  Linux  2.4  un  thread  peut,  par
       defaut, attendre les enfants des autres threads du meme groupe.

       Les  options  suivantes  sont  specifiques a Linux, et servent pour les
       enfants crees avec clone(2) ; elles ne peuvent pas etre utilisees  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 a son pere a sa terminaison). Cette option  est  ignoree
              si __WALL est aussi indique.

       __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 meme groupe de
              threads. Ceci etait le cas par defaut avant Linux 2.4.

EXEMPLE

       Le  programme  suivant montre l'utilisation de fork(2) et de waitpid().
       Le programme cree un processus fils. Si  aucun  argument  n'est  fourni
       dans  la  ligne de commande du programme, le fils suspend son execution
       avec pause(2), pour que l'utilisateur puisse lui envoyer  des  signaux.
       Sinon,  le  fils se termine immediatement, en utilisant l'entier fourni
       sur la ligne de commande comme code de retour. Le processus pere boucle
       en  surveillant  l'etat  du  fils avec waitpid(), et utilise les macros
       W*() decrites ci-dessus pour analyser le code d'etat 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
           arrete par le signal 19
           $ kill -CONT 32360
           relance
           $ kill -TERM 32360
           tue 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 execute 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 execute par le pere */
               do {
                   w = waitpid(cpid, &status, WUNTRACED | WCONTINUED);
                   if (w == -1) {
                       perror("waitpid");
                       exit(EXIT_FAILURE);
                   }

                   if (WIFEXITED(status)) {
                       printf("termine, code=%d\n", WEXITSTATUS(status));
                   } else if (WIFSIGNALED(status)) {
                       printf("tue par le signal %d\n", WTERMSIG(status));
                   } else if (WIFSTOPPED(status)) {
                       printf("arrete par le signal %d\n", WSTOPSIG(status));
                   } else if (WIFCONTINUED(status)) {
                       printf("relance\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.27 du projet man-pages
       Linux. Une description du projet et des instructions pour signaler  des
       anomalies       peuvent       etre       trouvees      a      l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis 2010, cette traduction est maintenue a l'aide  de  l'outil  po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   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'equipe francophone de traduction de Debian (2006-2009).

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

       Vous  pouvez  toujours avoir acces a la version anglaise de ce document
       en utilisant la commande << man -L C <section> <page_de_man> >>.