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 fonctionnalites 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 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.32  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> >>.