Man Wait en français
WAIT(2)                   Manuel du programmeur Linux                  WAIT(2)



 

NOM


       wait, waitpid - Attendre qu'un processus change d'etat.

 

SYNOPSIS


       #include 
       #include 

       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);

 

DESCRIPTION






       Tous  ces  appels  systemes  sont  utilises pour attendre le changement
       d'etat du fils d'un processus appelant, et pour  obtenir  des  informa-
       tions sur le fils dont l'etat a change.  Un changement d'etat peut etre
       le fils est termine ; le fils a ete interrompu par un  signal ;  ou  le
       fils  a  ete relance par un signal.  Dans le cas de la fin d'un proces-
       sus, la realisation d'un  wait()  permet  au  systeme  de  liberer  les
       ressources associees au fils ; si un wait() n'est pas effectue, le fils
       qui s'est termine reste dans l'etat de  zombie  (voir la section  NOTES
       plus bas).

       Si  le  fils a deja change d'etat, ces appels reviennent immediatement.
       Autrement, ils bloquent jusqu'a ce que soit un fils change d'etat, soit
       un  gestionnaire de signaux interrompe l'appel (suposant que les appels
       systeme ne sont pas automatiquement  relances  en  utilsant  l'attribut
       SA_RESTART  de sigaction(2)).  Dans la suite de cette page, nous quali-
       fierons d'attentiste (Ndt : waitable) un fils dont l'etat a  change  et
       qui n'a pas encore ete attendu par l'un de ces appels systeme.

   wait() et waitpid()
       L'appel systeme wait() suspend l'execution du processus courant jusqu'a
       ce que l'un de ses fils soit acheve. L'appel wait(&status) est  equiva-
       lent a :

           waitpid(-1, &status, 0);

       L'appel  systeme  waitpid()  suspend  l'execution  du processus courant
       jusqu'a ce que le fils specifie par son pid  ait  change  d'etat.   Par
       defaut,  waitpid()  attends seulement la fin des fils mais ce comporte-
       ment est modifiable avec l'argument options comme decrit plus loin.

       La valeur de pid peut etre :

       < -1   signifiant d'attendre tous les processus fils  dont  le  GID  du
              processus est egal a la valeur absolue de pid.

       -1     signifiant d'attendre tous les processus fils.

       0      signifiant  d'attendre  tous  les  processus fils dont le GID du
              processus est egal a celui du processus appelant.

       > 0    signifiant d'attendre tous les processus fils dont  le  PID  est
              egal a pid.

       La  valeur  de  options  est un OU de zero ou plus des constantes suiv-
       antes :

 

       WNOHANG


              revenir immediatement si aucun fils n'est acheve.

 

       WUNTRACED


              revenir si un fils est bloque (mais non  suivi  par  ptrace(2)).
              L'etat  des  fils  suivis  est  fourni  meme  sans cette option.
              traced

 

       WCONTINUED


              (Depuis Linux 2.6.10) revenir si un fils bloque  a  ete  relance
              par la delivrance du signal SIGCONT.

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

       Les   options  WUNTRACED  et  WCONTINUED  ne  sont  effectives  que  si
       l'attribut SA_NOCLDSTOP n'a pas ete specifie  pour  le  signal  SIGCHLD
       (voir sigaction(2)).

       Si  status  n'est pas NULL, wait() et waitpid() enregistre les informa-
       tions sur l'etat dans l'entier int sur lequel il pointe. cet entier est
       analyse  avec  les  macros suivantes (qui prennent en argument l'entier
       lui-meme, pas un pointeur sur lui, comme cela est fait dans  wait()  et
       waitpid()!) :

       WIFEXITED(status)
              renvoie  vrai si le fils s'est termine normalement, c'est-a-dire
              par un appel a exit(3) ou _exit(2), ou bien  par  un  retour  de
              main().

       WEXITSTATUS(status)
              renvoie le code de sortie du fils. Ce code est constitue par les
              8 bits de poids faibles de  l'argument  status  que  le  fils  a
              fourni  a  exit()  ou  a _exit() ou l'argument d'une commande de
              retour dans main().  Cette macro ne peut  etre  evaluee  que  si
              WIFEXITED a renvoye vrai.

       WIFSIGNALED(status)
              renvoie vrai si le fils s'est termine a cause d'un signal.

       WTERMSIG(status)
              renvoie  le  numero  du signal qui a cause la fin du fils. Cette
              macro ne peut etre evaluee que si WIFSIGNALED a renvoye vrai.

       WCOREDUMP(status)
              renvoie vrai si le fils a cree un fichier core.  returns true if
              the  child produced a core dump.. Cette macro ne peut etre eval-
              uee que si WIFSIGNALED a renvoye vrai.  Cette  macro  n'est  pas
              specifiee  dans  POSIX.1-2001  et  n'est pas disponible sur cer-
              taines implementations (par  exemple  AIS,  SunOS).   N'utilisez
              ceci qu'encadre par #ifdef WCOREDUMP ... #endif.

       WIFSTOPPED(status)
              renvoie vrai si le fils a ete arrete par la delivrance d'un sig-
              nal. Cette macro n'a de sens que si l'on a effectue l'appel avec
              l'option  WUNTRACED  ou  lorsque  l'appel  est en cours de suivi
              (voir ptrace(2)).

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

       WIFCONTINUED(status)
              (Depuis  Linux  2.6.10) renvoie vrai si le processus fils  a ete
              relance par la delivrance du signal SIGCONT.

   waitid()
       L'appel systeme waitid() (disponible depuis  Linux  2.6.9)  fournit  un
       controle  plus  precis  sur  les  changements d'etats des fils que l'on
       attend.

       Les arguments idtype et id selectionnent, de la maniere suivante, le(s)
       fils a attendre :

       idtype == P_PID
              Attendre le fils dont le PID est id.

       idtype == P_PGID
              Attendre tous les fils dont le GID du processus est id.

       idtype == P_ALL
              Attendre tous les fils ; id est ignore.

       Les changement d'etat du fils a attendre sont specifies par un OU entre
       un ou plusieurs des attributs d'options suivants :

 

       WEXITED


              Attendre les fils qui se sont termines.

 

       WSTOPPED


              Attendre les fils qui ont ete bloques  par  la  delivrance  d'un
              signal.

 

       WCONTINUED


              Attendre  les  fils,  precedemment bloques, qui ont ete relances
              par la delivrance d'un signal SIGCONT.

       Les attributs suivants peuvent egalement etre utilises dans options :

 

       WNOHANG


              Comme pour waitpid().

 

       WNOWAIT


              Laisser le fils dans un etat attentiste : un  appel  ulerieur  a
              wait  pourra etre utilise pour recuperer l'information d'etat du
              fils.

       En cas de succes, waitid() remplit les champs suivants de la  structure
       siginfo_t pointee par infop :

       si_pid Le PID du fils.

       si_uid L'UID  reel  du fils.  (Ce champ n'est pas configure sur la plu-
              part des implementations.)

       si_signo
              Toujous remplit avec SIGCHLD.

       si_status
              Soit le code de retour  du  fils,  tel  qu'il  a  ete  fourni  a
              _exit(2)  (ou  a exit(3)), soit le signal qui a provoque la fin,
              le blocage ou la continuaison du fils.  Le  champ  si_code  peut
              etre utilise pour savoir comment interpreter ce champ.

       si_code
              Remplit avec l'une des valeurs suivantes : CLD_EXITED (le fils a
              appele _exit(2)) ; CLD_KILLED (le fils a ete  tue  par  un  sig-
              nal) ;  CLD_STOPPED  (le  fils  a ete bloque par un signal) ; ou
              CLD_CONTINUED (le fils a ete relance par SIGCONT).

       Si WNOHANG a ete specifie dans options et qu'il n'y a aucun  fils  dans
       un  etet  attentiste,  waitid() renvoie immediatement 0 et l'etat de la
       structure siginfo_t pointee par infop est indeterminee.   Pour  differ-
       encier ce cas ou un fils etait dans un etat attentiste, remplissez avec
       zero le champ si_pid avant l'appel et verifier s'il y a une valeur  non
       nulle dans ce champ apres le retour de l'appel.

 

VALEUR RENVOYEE


       wait() :  En cas de reussite, le PID du fils qui s'est termine est ren-
       voye, en cas d'echec -1 est renvoye.

       waitpid() : En cas de reussite, le PID du fils dont l'etat a change est
       renvoye,  en  cas d'echec -1 est renvoye ; si WNOHANG etait specifie et
       qu'aucun fils specifie par pid n'a encore change d'etat, 0 est renvoye.

       waitid() :  renvoie  0  s'il  reussit  ou  si WNOHANG etait specifie et
       qu'aucun fils specifie par id n'a encore change d'etat ; en cas d'echec
       -1 est renvoye.

       Chacun  de ces appels remplissent errno avec une valeur appropriee dans
       le cas d'une erreur.

 

ERREURS


       ECHILD (pour wait())
              Le processus appelant n'a aucun fils a attendre.

       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 placee sur SIG_IGN, voir egalement le passage de
              la section SPECIFICITES LINUX concernant les threads).

       EINTR  WNOHANG n'est pas indique, et un signal a intercepter ou SIGCHLD
              a ete recu.

       EINVAL L'argument options est invalide.

 

NOTES


       Un  fils qui se termine et qui n'etait pas attendu devient un  zombie .
       Le noyau conserve un ensemble minimal d'informations sur  le  processus
       zombie  (PID,  etat  de  fin, information d'utilisation des ressources)
       pour permettre au pere d'effectuer plus tard un wait() pour obtenir les
       informations sur le fils.

       Aussi  longtemps  qu'un  zombie  n'est  pas  supprime du systeme par un
       wait(), il utilisera un emplacement dans  la  table  des  processus  du
       noyau  et  si  la  table  est pleine, il ne sera plus possible de creer
       d'autres processus.  Si un processus pere se termine,  ses  fils   zom-
       bie , s'il en existe, seront adopte par init(8), qui effectuera automa-
       tiquement un wait() pour supprimer les zombies.

       POSIX.1-2001 indique que si la disposition de SIGCHLD est configuree  a
       SIG_IGN ou que l'attribut SA_NOCLDWAIT est configure pour SIGCHLD (voir
       sigaction(2)), les fils qui se terminent ne deviennent pas des  zombies
       et un appel a wait() ou waitpid() bloquera jusqu'a ce que tous les fils
       se terminent, puis echouera et ecrira ECHILD  dans  errno.   (La  norme
       POSIX  originale  laissait le comportement avec SIGCHLD a SIG_IGN inde-
       termine.)  Linux 2.6 est conforme a  cette  specification.   Toutefois,
       Linux 2.4 (et precedent) ne le sont pas : si un appel a wait() ou wait-
       pid() est effectue alors SIGCHLD est ignore, l'appel se comporte  comme
       si  SIGCHLD  n'etait pas ignore, c'est-a-dire qu'il bloquera jusqu'a la
       premiere fin d'un fils et renverra le PID et l'etat du fils.

 

SPECIFICITES LINUX


       Dans le noyau Linux, un thread ordonnance par le noyau n'est  pas  dif-
       ferent d'un simple processus. En fait, un thread est juste un processus
       qui est cree a l'aide de la routine - specifique 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 fonc-
       tionnalite, 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 unique-
              ment 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, quelques soient
              leurs types (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 waitpid(2).  le
       programme  cree un processus fils.  Si aucun argument n'est fournit sur
       la ligne de commande du programme, le fils suspend son  execution  avec
       pause(2)  pour permettre a l'utilisateur d'envoyer des signaux au fils.
       Autrement, s'il y un  argument  sur  la  ligne  de  commande,  le  fils
       s'acheve immediatement, utilisant l'entier fournit sur la ligne de com-
       mande comme code de sortie.  Le processus pere execute une  boucle  qui
       surveille  le fils avec waitpid(2), et utilise les macros W*() decrites
       plus haut pour analyser la valeur d'etat de l'attente (wait(2)).

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

       $ ./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 
       #include 
       #include 
       #include 

       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("Child PID is %ld\n", (long) getpid());
               if (argc == 1)
                   pause();                    /* Wait for signals */
               _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("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);
           }
       }

 

CONFORMITE


       SVr4, BSD 4.3, POSIX.1-2001.

 

VOIR AUSSI


       _exit(2), clone(2), fork(2),  kill(2),  ptrace(2),  sigaction(2),  sig-
       nal(2), wait4(2), pthread_create(3), signal(7)

 

TRADUCTION


       Ce   document   est  une  traduction  realisee  par  Christophe  Blaess
        le 15 octobre 1996, mise a jour  par
       Alain  Portal  le 30 mai 2006 et revisee
       le 14 aot 2006.

       L'equipe de traduction a fait le maximum pour realiser  une  adaptation
       francaise de qualite. La version anglaise la plus a jour de ce document
       est toujours consultable via la commande :  LANG=C man 2 wait .  N'hes-
       itez  pas  a  signaler a l'auteur ou au traducteur, selon le cas, toute
       erreur dans cette page de manuel.



Linux                          11 novembre 2004                        WAIT(2)