NOM

       sigwaitinfo, sigtimedwait, rt_sigtimedwait - synchronously wait for queued signals

SYNOPSIS

       #include <signal.h>

       int sigwaitinfo(const sigset_t *set, siginfo_t *info);

       int sigtimedwait(const sigset_t *set, siginfo_t *info,
                        const struct timespec *timeout);

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

       sigwaitinfo(), sigtimedwait() : _POSIX_C_SOURCE >= 199309L

DESCRIPTION

       sigwaitinfo() suspend l'exécution du thread appelant jusqu'à ce que l'un  des  signaux  de
       l'ensemble set soit en attente. (Si l'un des signaux de l'ensemble set est déjà en attente
       pour le thread appelant, sigwaitinfo() retourne immédiatement).

       sigwaitinfo() retire le signal de l'ensemble des signaux en attente, et renvoie le  numéro
       du  signal comme valeur de retour. Si l'argument info n'est pas NULL, alors le tampon vers
       lequel il pointe est utilisé pour renvoyer une  structure  du  type  siginfo_t  (consultez
       sigaction(2)) contenant les informations concernant le signal.

       Si  plusieurs  signaux  de  set  sont  mis  en attente pour l'appelant, le signal récupéré
       sigwaitinfo() est déterminé par les règles de classement habituelles. Consultez  signal(7)
       pour plus de détails.

       sigtimedwait()   opère   exactement   comme   sigwaitinfo()   mais   elle  a  un  argument
       supplémentaire, timeout, qui permet de définir le  temps  pendant  lequel  le  thread  est
       suspendu dans l'attente d'un signal. (Cet intervalle de temps est arrondi à la granularité
       de l'horloge système et cet intervalle peut être modifié légèrement  à  cause  des  délais
       d'ordonnancement du noyau.) Cet argument est du type :

           struct timespec {
               long    tv_sec;         /* secondes */
               long    tv_nsec;        /* nanosecondes */
           }

       Si  les  deux  champs  de cette structure sont nuls, sigtimedwait() revient tout de suite,
       soit avec des informations sur un signal déjà en attente, soit avec une  erreur  si  aucun
       signaux de l'ensemble set n'étaient disponibles.

VALEUR RENVOYÉE

       S'ils  réussissent  sigwaitinfo()  et  sigtimedwait()  renvoient  un numéro de signal (une
       valeur supérieure à zéro). S'ils échouent, ils renvoient -1, et  errno  contient  le  code
       d'erreur.

ERREURS

       EAGAIN Aucun  signal  de  l'ensemble  set n'a été mis en attente avant expiration du délai
              timeout indiqué pour sigtimedwait().

       EINTR  L'appel a été interrompu par un gestionnaire de signal ; consultez  signal(7).  (Un
              signal autre que ceux présents dans l'ensemble set.)

       EINVAL timeout était invalide.

CONFORMITÉ

       POSIX.1-2001, POSIX.1-2008.

NOTES

       En  utilisation  habituelle,  l'appelant bloque les signaux de l'ensemble set au préalable
       avec un appel sigprocmask(2) (afin que la délivrance des signaux ne se produise pas  s'ils
       sont  mis  en  attente  entre deux appels successifs à sigwaitinfo() ou sigtimedwait()) et
       n'installe pas de gestionnaire pour ces signaux. Dans un programme multithreadé, le signal
       doit  être  bloqué  dans  tous  les  threads  pour  empêcher  que le signal ne soit traité
       conformément à sa disposition  par  défaut  dans  un  autre  thread  que  celui  exécutant
       sigwaitinfo() ou sigtimedwait().

       L'ensemble des signaux qui sont en attente pour une thread donné est l'union de l'ensemble
       des signaux spécifiquement en attente pour ce thread  et  de  l'ensemble  des  signaux  en
       attente pour le processus lui-même (consultez signal(7)).

       Les tentatives pour attendre SIGKILL or SIGSTOP seront ignorées silencieusement.

       Si  plusieurs  threads d'un processus sont bloqués dans sigwaitinfo() ou sigtimedwait() en
       attente du ou des mêmes signaux, un seul des threads recevra réellement le signal s'il est
       mis  en  attente pour le processus (dans son ensemble) ; on ne peut pas savoir quel thread
       recevra le signal.

       sigwaitinfo()  or sigtimedwait(), can't be used to receive signals that are  synchronously
       generated,  such  as  the  SIGSEGV  signal  that  results from accessing an invalid memory
       address or the SIGFPE signal that results from an arithmetic error. Such  signals  can  be
       caught only via signal handler.

       POSIX  ne  spécifie  pas  le  comportement si une valeur NULL est indiquée pour l'argument
       timeout de sigtimedwait(), permettant par exemple d'avoir le même comportement  que  celui
       de sigwaitinfo(), ce qui est le cas sous Linux.

   différences entre bibliothèque C et noyau
       Sous  Linux,  sigwaitinfo()  est  une  fonction  de  bibliothèque implémentée au dessus de
       sigtimedwait().

       The glibc wrapper functions for sigwaitinfo()  and sigtimedwait() silently ignore attempts
       to  wait  for  the  two  real-time  signals that are used internally by the NPTL threading
       implementation. See nptl(7)  for details.

       The original Linux system call was named sigtimedwait(). However,  with  the  addition  of
       real-time  signals  in  Linux  2.2, the fixed-size, 32-bit sigset_t type supported by that
       system  call  was  no  longer  fit  for  purpose.  Consequently,  a   new   system   call,
       rt_sigtimedwait(),  was  added  to  support an enlarged sigset_t type. The new system call
       takes a fourth argument, size_t sigsetsize, which specifies  the  size  in  bytes  of  the
       signal  set in set. This argument is currently required to have the value sizeof(sigset_t)
       (or the error EINVAL results). The glibc  sigtimedwait()   wrapper  function  hides  these
       details from us, transparently calling rt_sigtimedwait()  when the kernel provides it.

VOIR AUSSI

       kill(2), sigaction(2), signal(2), signalfd(2), sigpending(2), sigprocmask(2), sigqueue(3),
       sigsetops(3), sigwait(3), signal(7), time(7)

COLOPHON

       Cette page fait partie de la publication 5.10 du projet man-pages Linux.  Une  description
       du  projet et des instructions pour signaler des anomalies et la dernière version de cette
       page peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.

TRADUCTION

       La traduction française de cette  page  de  manuel  a  été  créée  par  Christophe  Blaess
       <https://www.blaess.fr/christophe/>,  Stéphan  Rafin  <stephan.rafin@laposte.net>, Thierry
       Vignaud <tvignaud@mandriva.com>, François Micaux, Alain  Portal  <aportal@univ-montp2.fr>,
       Jean-Philippe    Guérard   <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)   <jean-
       luc.coulon@wanadoo.fr>,   Julien    Cristau    <jcristau@debian.org>,    Thomas    Huriaux
       <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
       Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>,  Denis
       Barbier   <barbier@debian.org>,   David   Prévot  <david@tilapin.org>,  Cédric  Boutillier
       <cedric.boutillier@gmail.com> et Frédéric Hantrais <fhantrais@gmail.com>

       Cette traduction est une documentation libre ; veuillez vous reporter  à  la  GNU  General
       Public   License   version 3  ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩  concernant  les
       conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
       message à debian-l10n-french@lists.debian.org ⟨⟩.