perkamon - en to fr translation catalogue (1129 entries)

note: type: TH
en: 2013-10-22
fr: 22 octobre 2013

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: bsd_signal - signal handling with BSD semantics
fr: bsd_signal - Gestion des signaux avec la sémantique BSD

note: type: Plain text
en: B<#define _XOPEN_SOURCE> /* See feature_test_macros(7) */
fr: B<#define _XOPEN_SOURCE> /* Consultez feature_test_macros(7) */

note: type: Plain text
en: The B<bsd_signal>()  function takes the same arguments, and performs the same task, as B<signal>(2).
fr: La fonction B<bsd_signal>() prend les mêmes paramètres et effectue la même tâche que B<signal>(2).

note: type: Plain text
en: The difference between the two is that B<bsd_signal>()  is guaranteed to provide reliable signal semantics, that is: a) the disposition of the signal is not reset to the default when the handler is invoked; b) delivery of further instances of the signal is blocked while the signal handler is executing; and c) if the handler interrupts a blocking system call, then the system call is automatically restarted.  A portable application cannot rely on B<signal>(2)  to provide these guarantees.
fr: La différence entre les deux est que B<bsd_signal>() garantit de fournir une sémantique de signal fiable, qui est\ : a) le signal n'est pas remis à sa valeur par défaut lorsque le gestionnaire de signal est appelé\ ; b) les autres occurrences du signal sont bloquées pendant l'exécution du gestionnaire\ ; c) si le gestionnaire interrompt un appel système bloquant, alors l'appel système est automatiquement redémarré. Une application portable ne peut pas se baser sur B<signal>(2) pour fournir ces garanties.

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: The B<bsd_signal>()  function returns the previous value of the signal handler, or B<SIG_ERR> on error.
fr: La fonction B<bsd_signal> renvoie la valeur précédente du gestionnaire de signal ou B<SIG_ERR> lors d'une erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: As for B<signal>(2).
fr: Comme pour B<signal>(2).

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: SS
en: Multithreading (see pthreads(7))
fr: Multithreading (voir pthreads(7))

note: type: Plain text
en: The B<bsd_signal>()  function is thread-safe.
fr: La fonction B<bsd_signal>() est sûre dans un contexte multithread.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: 4.2BSD, POSIX.1-2001.  POSIX.1-2008 removes the specification of B<bsd_signal>(), recommending the use of B<sigaction>(2)  instead.
fr: BSD 4.2, POSIX.1-2001. POSIX.1-2008 supprime la spécification de B<bsd_signal>() et recommande à la place l'utilisation de B<sigaction>(2).

note: type: Plain text
en: Use of B<bsd_signal>()  should be avoided; use B<sigaction>(2)  instead.
fr: L'utilisation de B<bsd_signal>() est à éviter, utilisez B<sigaction>(2) à la place.

note: type: Plain text
en: On modern Linux systems, B<bsd_signal>()  and B<signal>(2)  are equivalent.  But on older systems, B<signal>(2)  provided unreliable signal semantics; see B<signal>(2)  for details.
fr: Sur des systèmes Linux modernes, B<bsd_signal>() et B<signal>(2) sont équivalents. Cependant, sur de vieux systèmes, B<signal>(2) fournit une sémantique de signal non fiable\ ; consultez B<signal>(2) pour plus de détails.

note: type: Plain text
en: The use of I<sighandler_t> is a GNU extension; this type is defined only if the B<_GNU_SOURCE> feature test macro is defined.
fr: Le type I<sighandler_t> est une extension GNU ; ce type n'est défini que si la macro de test de fonctionnalités B<_GNU_SOURCE> est définie.

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%http://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2010-08-30
fr: 30 août 2010

note: type: Plain text
en: eventfd - create a file descriptor for event notification
fr: eventfd - Créer un descripteur de fichier pour la notification d'événements

note: type: Plain text
en: B<eventfd>()  creates an "eventfd object" that can be used as an event wait/notify mechanism by user-space applications, and by the kernel to notify user-space applications of events.  The object contains an unsigned 64-bit integer (I<uint64_t>)  counter that is maintained by the kernel.  This counter is initialized with the value specified in the argument I<initval>.
fr: B<eventfd>() créée un « objet eventfd » qui peut être utilisé par les applications de l'espace utilisateur pour l'attente ou la notification d'un événement et par le noyau pour notifier des applications de certains événements. Les objets contiennent un compteur entier non signé sur 64 bits (I<uint64_t>) qui est maintenu par le noyau. Ce compteur est initialisé à la valeur spécifiée par le paramètre I<initval>.

note: type: Plain text
en: The following values may be bitwise ORed in I<flags> to change the behaviour of B<eventfd>():
fr: Les valeurs suivantes peuvent être incluses (avec un OU logique) dans I<flags> pour changer le comportement de B<eventfd>() :

note: type: TP
en: B<EFD_CLOEXEC> (since Linux 2.6.27)
fr: B<EFD_CLOEXEC> (depuis Linux 2.6.27)

note: type: Plain text
en: Set the close-on-exec (B<FD_CLOEXEC>)  flag on the new file descriptor.  See the description of the B<O_CLOEXEC> flag in B<open>(2)  for reasons why this may be useful.
fr: Placer l'attribut « close-on-exec » (B<FD_CLOEXEC>) sur le nouveau descripteur de fichier. Consultez la description de l'attribut B<O_CLOEXEC> dans B<open>(2) pour savoir pourquoi cela peut être utile.

note: type: TP
en: B<EFD_NONBLOCK> (since Linux 2.6.27)
fr: B<EFD_NONBLOCK> (depuis Linux 2.6.27)

note: type: Plain text
en: Set the B<O_NONBLOCK> file status flag on the new open file description.  Using this flag saves extra calls to B<fcntl>(2)  to achieve the same result.
fr: Placer l'attribut d'état de fichier B<O_NONBLOCK> sur le nouveau descripteur de fichier ouvert. Utiliser cet attribut économise des appels supplémentaires à B<fcntl>(2) pour obtenir le même résultat.

note: type: TP
en: B<EFD_SEMAPHORE> (since Linux 2.6.30)
fr: B<EFD_SEMAPHORE> (depuis Linux 2.6.30)

note: type: Plain text
en: Provide semaphore-like semantics for reads from the new file descriptor.  See below.
fr: Fournir une sémantique similaire aux sémaphores pour les lectures sur le nouveau descripteur de fichier. Voir ci-dessous.

note: type: Plain text
en: In Linux up to version 2.6.26, the I<flags> argument is unused, and must be specified as zero.
fr: Dans les versions de Linux jusqu'à la version 2.6.26, le paramètre I<flags> n'est pas utilisé et doit valoir zéro.

note: type: Plain text
en: As its return value, B<eventfd>()  returns a new file descriptor that can be used to refer to the eventfd object.  The following operations can be performed on the file descriptor:
fr: Comme valeur de retour, B<eventfd>() renvoie un nouveau descripteur de fichier qui peut être utilisé pour se référer à l'objet eventfd. Les opérations suivantes peuvent être effectuées sur le descripteur de fichier :

note: type: Plain text
en: Each successful B<read>(2)  returns an 8-byte integer.  A B<read>(2)  will fail with the error B<EINVAL> if the size of the supplied buffer is less than 8 bytes.
fr: Chaque B<read>(2) qui réussit renvoie un entier sur 8 octets. B<read>(2) échouera avec l'erreur B<EINVAL> si la taille du tampon fourni est de moins de 8 octets.

note: type: Plain text
en: The value returned by B<read>(2)  is in host byte order\(emthat is, the native byte order for integers on the host machine.
fr: La valeur renvoyée par B<read>(2) utilise l'ordre des octets de l'hôte, c'est-à-dire l'ordre des octets natif pour les entiers sur la machine hôte.

note: type: Plain text
en: The semantics of B<read>(2)  depend on whether the eventfd counter currently has a nonzero value and whether the B<EFD_SEMAPHORE> flag was specified when creating the eventfd file descriptor:
fr: La sémantique de B<read>(2) dépend du fait que le compteur eventfd a actuellement une valeur non nulle, et que l'attribut B<EFD_SEMAPHORE> était spécifié lors de la création du descripteur de fichier eventfd :

note: type: Plain text
en: If B<EFD_SEMAPHORE> was not specified and the eventfd counter has a nonzero value, then a B<read>(2)  returns 8 bytes containing that value, and the counter's value is reset to zero.
fr: Si B<EFD_SEMAPHORE> n'était pas spécifié et si le compteur eventfd a une valeur non nulle, un B<read>(2) renverra 8 octets contenant cette valeur, et la valeur du compteur sera remise à zéro.

note: type: Plain text
en: If B<EFD_SEMAPHORE> was specified and the eventfd counter has a nonzero value, then a B<read>(2)  returns 8 bytes containing the value 1, and the counter's value is decremented by 1.
fr: Si B<EFD_SEMAPHORE> était spécifié et si le compteur eventfd a une valeur non nulle, un B<read>(2) renverra 8 octets contenant la valeur 1, et la valeur du compteur sera décrémentée de 1.

note: type: Plain text
en: If the eventfd counter is zero at the time of the call to B<read>(2), then the call either blocks until the counter becomes nonzero (at which time, the B<read>(2)  proceeds as described above)  or fails with the error B<EAGAIN> if the file descriptor has been made nonblocking.
fr: Si le compteur eventfd est nul au moment de l'appel à B<read>(2), l'appel bloquera jusqu'à ce que le compteur devienne non nul (auquel cas l'appel à B<read>(2) sera traité comme décrit ci-dessus), ou échouera avec l'erreur B<EAGAIN> si le descripteur de fichier est en mode non bloquant.

note: type: Plain text
en: A B<write>(2)  call adds the 8-byte integer value supplied in its buffer to the counter.  The maximum value that may be stored in the counter is the largest unsigned 64-bit value minus 1 (i.e., 0xfffffffffffffffe).  If the addition would cause the counter's value to exceed the maximum, then the B<write>(2)  either blocks until a B<read>(2)  is performed on the file descriptor, or fails with the error B<EAGAIN> if the file descriptor has been made nonblocking.
fr: Un appel à B<write>(2) ajoute au compteur la valeur de l'entier sur 8 octets fourni dans le tampon. La valeur maximale qui peut être stockée dans le compteur est le plus grand entier non signé sur 64 bits moins 1 (c'est-à-dire 0xfffffffffffffffe). Si l'addition résulte en un compteur qui dépasserait la valeur maximale, le B<write>(2) bloquera jusqu'à ce qu'un B<read>(2) soit effectué sur le descripteur de fichier, ou échouera avec l'erreur B<EAGAIN> si le descripteur de fichier est en mode non bloquant.

note: type: Plain text
en: A B<write>(2)  will fail with the error B<EINVAL> if the size of the supplied buffer is less than 8 bytes, or if an attempt is made to write the value 0xffffffffffffffff.
fr: Un B<write>(2) échouera avec l'erreur B<EINVAL> si la taille du tampon fourni est de moins de 8 octets ou si l'on essaie d'écrire la valeur 0xffffffffffffffff.

note: type: TP
en: B<poll>(2), B<select>(2) (and similar)
fr: B<poll>(2), B<select>(2) (et similaires)

note: type: Plain text
en: The returned file descriptor supports B<poll>(2)  (and analogously B<epoll>(7))  and B<select>(2), as follows:
fr: Le descripteur de fichier prend en charge les B<poll>(2) (et de façon analogue B<epoll>(7)) et B<select>(2) de la façon suivante :

note: type: Plain text
en: The file descriptor is readable (the B<select>(2)  I<readfds> argument; the B<poll>(2)  B<POLLIN> flag)  if the counter has a value greater than 0.
fr: Le descripteur de fichier est lisible (le paramètre I<readfds> de B<select>(2) ; l'attribut B<POLLIN> de B<poll>(2)) si le compteur a une valeur supérieure à 0.

note: type: Plain text
en: The file descriptor is writable (the B<select>(2)  I<writefds> argument; the B<poll>(2)  B<POLLOUT> flag)  if it is possible to write a value of at least "1" without blocking.
fr: Le descripteur de fichier est disponible en écriture (le paramètre I<writefds> de B<select>(2) ; l'attribut B<POLLOUT> de B<poll>(2)) s'il est possible d'écrire une valeur d'au moins « 1 » sans bloquer.

note: type: Plain text
en: If an overflow of the counter value was detected, then B<select>(2)  indicates the file descriptor as being both readable and writable, and B<poll>(2)  returns a B<POLLERR> event.  As noted above, B<write>(2)  can never overflow the counter.  However an overflow can occur if 2^64 eventfd "signal posts" were performed by the KAIO subsystem (theoretically possible, but practically unlikely).  If an overflow has occurred, then B<read>(2)  will return that maximum I<uint64_t> value (i.e., 0xffffffffffffffff).
fr: Si un dépassement de la valeur du compteur a été détectée, B<select>(2) indique que le descripteur de fichier est disponible en lecture et en écriture et B<poll>(2) renvoie un événement B<POLLERR>. Comme indiquée ci-dessus, un B<write>(2) ne peut jamais produire de dépassement. Cependant, un dépassement peut se produire si un « signal post » eventfd de 2^64 a été effectué par le sous-système KAIO (théoriquement possible, mais très peut probable en pratique). Si un dépassement survient, un B<read>(2) renverra la valeur maximale d'un I<uint64_t> (c'est-à-dire 0xffffffffffffffff).

note: type: Plain text
en: The eventfd file descriptor also supports the other file-descriptor multiplexing APIs: B<pselect>(2)  and B<ppoll>(2).
fr: Le descripteur de fichier eventfd prend également en charge les autres interfaces de multiplexage de descripteurs de fichier : B<pselect>(2) et B<ppoll>(2).

note: type: Plain text
en: When the file descriptor is no longer required it should be closed.  When all file descriptors associated with the same eventfd object have been closed, the resources for object are freed by the kernel.
fr: Quand le descripteur de fichier n'est plus nécessaire il doit être fermé. Quand tous les descripteurs de fichier associés au même objet eventfd ont été fermés, les ressources pour cet objet sont libérées par le noyau.

note: type: Plain text
en: A copy of the file descriptor created by B<eventfd>()  is inherited by the child produced by B<fork>(2).  The duplicate file descriptor is associated with the same eventfd object.  File descriptors created by B<eventfd>()  are preserved across B<execve>(2), unless the close-on-exec flag has been set.
fr: Une copie d'un descripteur de fichier créé par B<eventfd>() est héritée par le fils produit par B<fork>(2). Le duplicata du descripteur de fichier est associé au même objet eventfd. Les descripteurs de fichier créés par B<eventfd>() sont préservés au travers des exécutions par B<execve>(2), sauf si l'attribut «\ close\(hyon\(hyexec\ » est positionné.

note: type: Plain text
en: On success, B<eventfd>()  returns a new eventfd file descriptor.  On error, -1 is returned and I<errno> is set to indicate the error.
fr: S'il réussit, B<eventfd>() renvoie un nouveau descripteur de fichier eventfd. En cas d'erreur, il renvoie -1 et remplit I<errno> avec la valeur d'erreur.

note: type: Plain text
en: An unsupported value was specified in I<flags>.
fr: Une valeur non prise en compte a été spécifiée dans I<flags>.

note: type: Plain text
en: The per-process limit on open file descriptors has been reached.
fr: La limite des descripteurs ouverts pour le processus a été atteinte.

note: type: Plain text
en: The system-wide limit on the total number of open files has been reached.
fr: La limite du nombre total de fichiers ouverts sur le système a été atteinte.

note: type: Plain text
en: Could not mount (internal) anonymous inode device.
fr: Impossible de monter (en interne) le périphérique anonyme d'inœud.

note: type: Plain text
en: There was insufficient memory to create a new eventfd file descriptor.
fr: Il n'y a pas assez de mémoire pour que le noyau crée le nouveau descripteur de fichier eventfd.

note: eventfd() is in glibc 2.7, but reportedly does not build type: Plain text
en: B<eventfd>()  is available on Linux since kernel 2.6.22.  Working support is provided in glibc since version 2.8.  The B<eventfd2>()  system call (see NOTES) is available on Linux since kernel 2.6.27.  Since version 2.9, the glibc B<eventfd>()  wrapper will employ the B<eventfd2>()  system call, if it is supported by the kernel.
fr: B<eventfd>() est disponible sous Linux depuis le noyau 2.6.22. Le support fonctionnel est fourni par la glibc depuis la version 2.8. L'appel système B<eventfd2>() (consultez les NOTES) est disponible sous Linux depuis le noyau 2.6.27. Depuis la version 2.9, la fonction enveloppe de la glibc pour B<eventfd>() utilise l'appel système B<eventfd2>() s'il est pris en charge par le noyau.

note: type: Plain text
en: B<eventfd>()  and B<eventfd2>()  are Linux-specific.
fr: B<eventfd>() et B<eventfd2>() sont spécifiques à Linux.

note: type: Plain text
en: Applications can use an eventfd file descriptor instead of a pipe (see B<pipe>(2))  in all cases where a pipe is used simply to signal events.  The kernel overhead of an eventfd file descriptor is much lower than that of a pipe, and only one file descriptor is required (versus the two required for a pipe).
fr: Les applications peuvent utiliser un descripteur de fichier eventfd à la place d'un tube (consultez B<pipe>(2)) à chaque fois qu'un tube est utilisé pour signaler des événements. La surcharge du noyau pour un descripteur de fichier est bien plus faible que pour un tube. De plus un seul descripteur de fichier est nécessaire (alors que deux sont nécessaires pour un tube).

note: or eventually syslets/threadlets type: Plain text
en: When used in the kernel, an eventfd file descriptor can provide a bridge from kernel to user space, allowing, for example, functionalities like KAIO (kernel AIO)  to signal to a file descriptor that some operation is complete.
fr: Quand un descripteur de fichier eventfd est utilisé par le noyau, il peut fournir un pont entre l'espace utilisateur et l'espace noyau. Par exemple, les fonctionnalités comme KAIO (« kernel AIO ») pour signaler dans un descripteur de fichier que certaines opérations sont finies.

note: type: Plain text
en: A key point about an eventfd file descriptor is that it can be monitored just like any other file descriptor using B<select>(2), B<poll>(2), or B<epoll>(7).  This means that an application can simultaneously monitor the readiness of "traditional" files and the readiness of other kernel mechanisms that support the eventfd interface.  (Without the B<eventfd>()  interface, these mechanisms could not be multiplexed via B<select>(2), B<poll>(2), or B<epoll>(7).)
fr: Un aspect important d'un descripteur de fichier eventfd est qu'il peut être surveillé comme n'importe quel descripteur de fichier avec B<select>(2), B<poll>(2) ou B<epoll>(7). Ceci signifie qu'une application peut surveiller simultanément la disponibilité de fichiers « traditionnels » et la disponibilité de mécanismes noyau qui gèrent une interface eventfd. (Sans l'interface B<eventfd>(), ces mécanismes ne pouvaient pas être multiplexés avec B<select>(2), B<poll>(2) ou B<epoll>(7))

note: type: SS
en: Underlying Linux system calls
fr: Appels système Linux sous-jacents

note: type: Plain text
en: There are two underlying Linux system calls: B<eventfd>()  and the more recent B<eventfd2>().  The former system call does not implement a I<flags> argument.  The latter system call implements the I<flags> values described above.  The glibc wrapper function will use B<eventfd2>()  where it is available.
fr: Il y a deux appels système sous-jacent : B<eventfd>() et B<eventfd2>(), plus récent. Le premier appel système n'implémente pas le paramètre I<flags>. Le dernier appel système implémente les valeurs de I<flags> décrite ci-dessus. La fonction enveloppe de la glibc utilisera B<eventfd2>() quand il est présent.

note: type: SS
en: Additional glibc features
fr: Fonctionnalités supplémentaires de la glibc

note: type: Plain text
en: The GNU C library defines an additional type, and two functions that attempt to abstract some of the details of reading and writing on an eventfd file descriptor:
fr: La bibliothèque C de GNU définie un type supplémentaire et deux fonctions qui tentent d'abstraire certains détails pour la lecture ou l'écriture avec des descripteurs de fichier eventfd :

note: type: Plain text
en: The functions perform the read and write operations on an eventfd file descriptor, returning 0 if the correct number of bytes was transferred, or -1 otherwise.
fr: Les fonctions effectuent des actions de lecture ou écriture sur le descripteur de fichier eventfd, en renvoyant 0 si un nombre correct d'octets a été transféré, ou -1 sinon.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The following program creates an eventfd file descriptor and then forks to create a child process.  While the parent briefly sleeps, the child writes each of the integers supplied in the program's command-line arguments to the eventfd file descriptor.  When the parent has finished sleeping, it reads from the eventfd file descriptor.
fr: Le programme suivant crée un descripteur de fichier eventfd puis crée un processus fils. Alors que le père commence par s'endormir, le fils écrit tous les entiers fournis sur la ligne de commande au descripteur de fichier eventfd. Quand le père se réveille, il lit dans le descripteur de fichier eventfd.

note: type: Plain text
en: The following shell session shows a sample run of the program:
fr: La session shell suivante montre un exemple d'exécution du programme :

note: type: SS
en: Program source
fr: Source du programme

note: type: Plain text
en: #include E<lt>sys/eventfd.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdint.hE<gt>             /* Definition of uint64_t */
fr: #include E<lt>sys/eventfd.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdint.hE<gt>             /* Definition de uint64_t */

note: type: TH
en: 2012-10-01
fr: 1er octobre 2012

note: type: Plain text
en: getitimer, setitimer - get or set value of an interval timer
fr: getitimer, setitimer - Lire/écrire la valeur d'une temporisation

note: type: Plain text
en: The system provides each process with three interval timers, each decrementing in a distinct time domain.  When any timer expires, a signal is sent to the process, and the timer (potentially) restarts.
fr: Le système fournit pour chaque processus trois temporisations, chacune avec un fonctionnement particulier. Lorsqu'une temporisation expire, un signal est envoyé au processus et la temporisation redémarre éventuellement.

note: type: Plain text
en: decrements in real time, and delivers B<SIGALRM> upon expiration.
fr: décroît en temps réel et un signal B<SIGALRM> est émis à l'expiration du délai.

note: type: Plain text
en: decrements only when the process is executing, and delivers B<SIGVTALRM> upon expiration.
fr: décroît uniquement quand le processus s'exécute, et un signal B<SIGVTALRM> est émis à l'expiration du délai.

note: type: Plain text
en: decrements both when the process executes and when the system is executing on behalf of the process.  Coupled with B<ITIMER_VIRTUAL>, this timer is usually used to profile the time spent by the application in user and kernel space.  B<SIGPROF> is delivered upon expiration.
fr: décroît à la fois quand le processus s'exécute, et quand le processeur exécute des fonctions systèmes à la demande du processus. Cette temporisation, utilisée conjointement avec B<ITIMER_VIRTUAL>, est généralement utilisée pour obtenir le profil d'exécution du processus entre les fonctionnalités utilisateur et le noyau. B<SIGPROF> est émis à l'expiration du délai.

note: type: Plain text
en: Timer values are defined by the following structures:
fr: Les valeurs des temporisations sont définies avec les structures suivantes\ :

note: type: Plain text
en: struct itimerval {
        struct timeval it_interval; /* next value */
        struct timeval it_value;    /* current value */
    };
fr: struct itimerval {
        struct timeval it_interval; /* valeur suivante */
        struct timeval it_value;    /* valeur actuelle */
    };

note: type: Plain text
en: struct timeval {
        time_t      tv_sec;         /* seconds */
        suseconds_t tv_usec;        /* microseconds */
    };
fr: struct timeval {
        time_t tv_sec;                /* secondes        */
        suseconds_t tv_usec;          /* microsecondes   */
    };

note: type: Plain text
en: The function B<getitimer>()  fills the structure pointed to by I<curr_value> with the current setting for the timer specified by I<which> (one of B<ITIMER_REAL>, B<ITIMER_VIRTUAL>, or B<ITIMER_PROF>).  The element I<it_value> is set to the amount of time remaining on the timer, or zero if the timer is disabled.  Similarly, I<it_interval> is set to the reset value.
fr: La fonction B<getitimer>() renseigne la structure pointée par I<curr_value> avec le paramétrage de la temporisation indiqué par I<which> (parmi B<ITIMER_REAL>, B<ITIMER_VIRTUAL>, ou B<ITIMER_PROF>). L'élément I<it_value> est rempli avec le délai restant dans la temporisation, ou zéro si la temporisation est désactivée. De même, I<it_interval> sera rempli avec la valeur originale de la temporisation.

note: type: Plain text
en: The function B<setitimer>()  sets the specified timer to the value in I<new_value>.  If I<old_value> is non-NULL, the old value of the timer is stored there.
fr: La fonction B<setitimer>() positionne la temporisation avec les valeurs de I<new_value>. Si I<old_value> n'est pas NULL, les paramètres précédents de la temporisation y sont inscrits.

note: type: Plain text
en: Timers decrement from I<it_value> to zero, generate a signal, and reset to I<it_interval>.  A timer which is set to zero (I<it_value> is zero or the timer expires and I<it_interval> is zero) stops.
fr: Les temporisations décroissent de I<it_value> à zéro, déclenchent un signal, et sont replacées à I<it_interval>. Une temporisation s'arrête si elle est mise à zéro (I<it_value> vaut zéro) ou bien elle expire et I<it_interval> vaut zéro.

note: type: Plain text
en: Both I<tv_sec> and I<tv_usec> are significant in determining the duration of a timer.
fr: Les deux champs I<tv_sec> et I<tv_usec> sont utilisés pour déterminer la durée d'une temporisation.

note: type: Plain text
en: Timers will never expire before the requested time, but may expire some (short) time afterward, which depends on the system timer resolution and on the system load; see B<time>(7).  (But see BUGS below.)  Upon expiration, a signal will be generated and the timer reset.  If the timer expires while the process is active (always true for B<ITIMER_VIRTUAL>), the signal will be delivered immediately when generated.  Otherwise the delivery will be offset by a small time dependent on the system loading.
fr: Les temporisations n'expirent jamais avant la fin du temps requis, et expirent plutôt avec un court délai après la limite. Ce délai dépend de la résolution de la temporisation système et de la charge du système ; consultez B<time>(7) (mais consultez la section BOGUES ci\(hydessous). À l'expiration, un signal est déclenché puis la temporisation réinitialisée. Si la temporisation expire alors que le processus est actif (toujours vrai avec B<ITIMER_VIRTUAL>) le signal sera délivré immédiatement. Autrement, il y aura un petit délai avant réception du signal, dépendant de la charge du système.

note: type: Plain text
en: On success, zero is returned.  On error, -1 is returned, and I<errno> is set appropriately.
fr: S'il réussit, cet appel système renvoie 0. S'il échoue, il renvoie -1 et remplit I<errno> en conséquence.

note: type: Plain text
en: I<new_value>, I<old_value>, or I<curr_value> is not valid a pointer.
fr: I<new_value>, I<old_value> ou I<curr_value> n'est pas un pointeur valable.

note: type: Plain text
en: I<which> is not one of B<ITIMER_REAL>, B<ITIMER_VIRTUAL>, or B<ITIMER_PROF>; or (since Linux 2.6.22) one of the I<tv_usec> fields in the structure pointed to by I<new_value> contains a value outside the range 0 to 999999.
fr: I<which> n'est ni B<ITIMER_REAL>, ni B<ITIMER_VIRTUAL>, ni B<ITIMER_PROF> ; ou (depuis Linux 2.6.22) un des champs I<tv_usec> dans la structure pointée par I<new_value> contient une valeur hors de l'intervalle 0 à 999 999.

note: type: Plain text
en: POSIX.1-2001, SVr4, 4.4BSD (this call first appeared in 4.2BSD).  POSIX.1-2008 marks B<getitimer>()  and B<setitimer>()  obsolete, recommending the use of the POSIX timers API (B<timer_gettime>(2), B<timer_settime>(2), etc.) instead.
fr: POSIX.1-2001, SVr4, BSD\ 4.4 (cet appel est apparu dans BSD\ 4.2). POSIX.1-2008 marque B<getitimer>() et B<setitimer>() comme étant obsolètes, en recommandant d'utiliser à la place l'API des temporisations POSIX (B<timer_gettime>(2), B<timer_settime>(2), etc.).

note: type: Plain text
en: A child created via B<fork>(2)  does not inherit its parent's interval timers.  Interval timers are preserved across an B<execve>(2).
fr: Un fils créé avec B<fork>(2) n'hérite pas des temporisations périodiques de son père. Les temporisations périodiques sont conservées au travers d'un B<execve>(2).

note: type: Plain text
en: POSIX.1 leaves the interaction between B<setitimer>()  and the three interfaces B<alarm>(2), B<sleep>(3), and B<usleep>(3)  unspecified.
fr: POSIX.1 laisse indéterminées les actions entre B<setitimer>() et les trois interfaces B<alarm>(2), B<sleep>(3) et B<usleep>(3).

note: type: Plain text
en: The standards are silent on the meaning of the call:
fr: Les normes ne donnent pas la signification de l'appel :

note: type: Plain text
en: Many systems (Solaris, the BSDs, and perhaps others)  treat this as equivalent to:
fr: De nombreux systèmes d'exploitation (Solaris, les BSD et peut-être d'autres) le traitent comme étant équivalent à :

note: type: Plain text
en: In Linux, this is treated as being equivalent to a call in which the I<new_value> fields are zero; that is, the timer is disabled.  I<Don't use this Linux misfeature>: it is nonportable and unnecessary.
fr: Dans Linux, il est traité comme étant équivalent à un appel dans lequel les champs de I<new_value> sont égaux à zéro, ce qui correspondrait à une temporisation désactivée. I<N'utilisez pas cette non-fonctionnalité de Linux> : elle est non portable et inutile.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: The generation and delivery of a signal are distinct, and only one instance of each of the signals listed above may be pending for a process.  Under very heavy loading, an B<ITIMER_REAL> timer may expire before the signal from a previous expiration has been delivered.  The second signal in such an event will be lost.
fr: Sous Linux, l'émission et la réception d'un signal sont distincts, et un même signal ne peut pas être émis deux fois de suite si le premier n'a pas été reçu. Il est ainsi possible qu'avec une charge système très élevée, une temporisation B<ITIMER_REAL> expire avant que le signal d'une expiration précédente n'ait été reçu. Le second signal sera alors perdu.

note: type: Plain text
en: On Linux kernels before 2.6.16, timer values are represented in jiffies.  If a request is made set a timer with a value whose jiffies representation exceeds B<MAX_SEC_IN_JIFFIES> (defined in I<include/linux/jiffies.h>), then the timer is silently truncated to this ceiling value.  On Linux/i386 (where, since Linux 2.6.13, the default jiffy is 0.004 seconds), this means that the ceiling value for a timer is approximately 99.42 days.  Since Linux 2.6.16, the kernel uses a different internal representation for times, and this ceiling is removed.
fr: Sous les noyaux Linux antérieurs au 2.6.16, les valeurs des temporisations sont exprimées en «\ jiffies\ ». Si une temporisation est initialisée à une valeur en jiffies dépassant la constante B<MAX_SEC_IN_JIFFIES> (définie dans I<include/linux/jiffies.h>), la temporisation est silencieusement tronquée à cette valeur maximale. Sous Linux sur i386 (où, depuis Linux 2.6.13, un jiffy correspond par défaut à 4 millisecondes), cela signifie que la valeur maximale d'une temporisation est environ 99,42 jours. Depuis Linux 2.6.16, le noyau utilise une représentation interne du temps différente et le plafond est supprimé.

note: 4 Jul 2005: It looks like this bug may remain in 2.4.x. http://lkml.org/lkml/2005/7/1/165 type: Plain text
en: On certain systems (including i386), Linux kernels before version 2.6.12 have a bug which will produce premature timer expirations of up to one jiffy under some circumstances.  This bug is fixed in kernel 2.6.12.
fr: Sur certains systèmes (y compris i386), les noyaux Linux avant la version 2.6.12 ont un bogue qui cause des expirations prématurées de temporisation, avec une avance pouvant aller jusqu'à un jiffy dans certaines circonstances. Ce bogue est corrigé dans Linux 2.6.12.

note: Bugzilla report 25 Apr 2006: http://bugzilla.kernel.org/show_bug.cgi?id=6443 "setitimer() should reject noncanonical arguments" type: Plain text
en: POSIX.1-2001 says that B<setitimer>()  should fail if a I<tv_usec> value is specified that is outside of the range 0 to 999999.  However, in kernels up to and including 2.6.21, Linux does not give an error, but instead silently adjusts the corresponding seconds value for the timer.  From kernel 2.6.22 onward, this nonconformance has been repaired: an improper I<tv_usec> value results in an B<EINVAL> error.
fr: Selon POSIX.1-2001, B<setitimer>() devrait échouer si la valeur de I<tv_usec> fournie n'est pas entre 0 et 999999. Cependant, dans les noyaux de version inférieure ou égale à 2.6.21, Linux ne renvoie pas d'erreur, et se contente d'ajuster la valeur de I<tv_sec> correspondante. Depuis le noyau 2.6.22, cette non conformité a été corrigée\ ; une valeur non valable de I<tv_usec> résulte en une erreur B<EINVAL>.

note: type: TH
en: 2007-07-26
fr: 26 juillet 2007

note: type: Plain text
en: gsignal, ssignal - software signal facility
fr: gsignal, ssignal - Gestion de signaux

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<gsignal>(), B<ssignal>(): _SVID_SOURCE
fr: B<gsignal>(), B<ssignal>()\ : _SVID_SOURCE

note: type: Plain text
en: Don't use these functions under Linux.  Due to a historical mistake, under Linux these functions are aliases for B<raise>(3)  and B<signal>(2), respectively.
fr: N'utilisez pas ces fonctions sous Linux. À cause d'une ancienne méprise, elles sont en réalité des synonymes de B<raise>(3) et B<signal>(2), respectivement.

note: type: Plain text
en: Elsewhere, on System V-like systems, these functions implement software signaling, entirely independent of the classical B<signal>(2)  and B<kill>(2)  functions.  The function B<ssignal>()  defines the action to take when the software signal with number I<signum> is raised using the function B<gsignal>(), and returns the previous such action or B<SIG_DFL>.  The function B<gsignal>()  does the following: if no action (or the action B<SIG_DFL>)  was specified for I<signum>, then it does nothing and returns 0.  If the action B<SIG_IGN> was specified for I<signum>, then it does nothing and returns 1.  Otherwise, it resets the action to B<SIG_DFL> and calls the action function with argument I<signum>, and returns the value returned by that function.  The range of possible values I<signum> varies (often 1-15 or 1-17).
fr: Ailleurs, sur des systèmes System V, ces fonctions implémentent une gestion des signaux entièrement indépendante des appels système classiques B<signal>(2) et B<kill>(2). La fonction B<ssignal>() définit l'action à entreprendre quand le signal numéro I<signum> est envoyé au processus à l'aide de la fonction B<gsignal>(), et renvoie l'action précédente, comme B<SIG_DFL>. La fonction B<gsignal>() agit ainsi\ : si aucune action (ou l'action B<SIG_DFL>) n'est indiquée pour I<signum>, alors elle ne fait rien et renvoie zéro. Si l'action B<SIG_IGN> est indiquée pour I<signum>, alors elle ne fait rien et renvoie 1. Sinon, elle replace l'action à B<SIG_DFL> et appelle le gestionnaire concerné, avec l'argument I<signum>, et renvoie la valeur de retour de cette fonction. L'intervalle de valeurs possibles de I<signum> varie (souvent [1, 15] ou [1, 17]).

note: type: Plain text
en: These functions are available under AIX, DG/UX, HP-UX, SCO, Solaris, Tru64.  They are called obsolete under most of these systems, and are broken under Linux libc and glibc.  Some systems also have B<gsignal_r>()  and B<ssignal_r>().
fr: Ces fonctions sont disponibles sous AIX, DG/UX, HP-UX, SCO, Solaris, Tru64. Elles sont considérées comme obsolètes sur la plupart de ces systèmes et sont erronées avec les bibliothèques libc Linux et glibc. Certains systèmes ont B<gsignal_r>() et B<ssignal_r>().

note: type: TH
en: 2013-09-17
fr: 17 septembre 2013

note: type: Plain text
en: kill - send signal to a process
fr: kill - Envoyer un signal à un processus

note: type: Plain text
en: B<kill>(): _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE
fr: B<kill>() : _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE

note: type: Plain text
en: The B<kill>()  system call can be used to send any signal to any process group or process.
fr: L'appel système B<kill>() peut être utilisé pour envoyer n'importe quel signal à n'importe quel processus ou groupe de processus.

note: type: Plain text
en: If I<pid> is positive, then signal I<sig> is sent to the process with the ID specified by I<pid>.
fr: Si I<pid> est positif, le signal I<sig> est envoyé au processus dont l'identifiant est indiqué par I<pid>.

note: type: Plain text
en: If I<pid> equals 0, then I<sig> is sent to every process in the process group of the calling process.
fr: Si I<pid> vaut zéro, alors le signal I<sig> est envoyé à tous les processus appartenant au même groupe que le processus appelant.

note: type: Plain text
en: If I<pid> equals -1, then I<sig> is sent to every process for which the calling process has permission to send signals, except for process 1 (I<init>), but see below.
fr: Si I<pid> vaut -1, alors le signal I<sig> est envoyé à tous les processus sauf celui de PID 1 (I<init>), mais voir plus bas.

note: type: Plain text
en: If I<pid> is less than -1, then I<sig> is sent to every process in the process group whose ID is I<-pid>.
fr: Si I<pid> est inférieur à -1, alors le signal I<sig> est envoyé à tous les processus du groupe dont l'identifiant est I<-pid>.

note: type: Plain text
en: If I<sig> is 0, then no signal is sent, but error checking is still performed; this can be used to check for the existence of a process ID or process group ID.
fr: Si I<sig> vaut 0, aucun signal n'est envoyé mais les conditions d'erreur sont vérifiées ; ceci peut être utilisé pour vérifier l'existence d'un identifiant de processus ou d'un identifiant de groupes de processus.

note: type: Plain text
en: For a process to have permission to send a signal it must either be privileged (under Linux: have the B<CAP_KILL> capability), or the real or effective user ID of the sending process must equal the real or saved set-user-ID of the target process.  In the case of B<SIGCONT> it suffices when the sending and receiving processes belong to the same session.  (Historically, the rules were different; see NOTES.)
fr: Pour qu'un processus puisse envoyer un signal, il doit avoir les privilèges nécessaires (sous Linux\ : avoir la capacité B<CAP_KILL>), ou l'UID effectif ou réel du processus qui envoie le signal doit être égal au Set-UID sauvé ou réel du processus cible. Dans le cas du signal B<SIGCONT>, il suffit que les processus envoyant et recevant le signal appartiennent à la même session. (Historiquement, les règles étaient différentes. Consultez les NOTES.)

note: type: Plain text
en: On success (at least one signal was sent), zero is returned.  On error, -1 is returned, and I<errno> is set appropriately.
fr: En cas de réussite (au moins un signal a été envoyé) 0 est renvoyé, en cas d'échec -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: An invalid signal was specified.
fr: Un signal invalide a été spécifié.

note: type: Plain text
en: The process does not have permission to send the signal to any of the target processes.
fr: Le processus appelant n'a pas l'autorisation d'envoyer un signal aux processus cibles.

note: type: Plain text
en: The pid or process group does not exist.  Note that an existing process might be a zombie, a process which already committed termination, but has not yet been B<wait>(2)ed for.
fr: Le processus ou le groupe de processus n'existe pas. Remarquez qu'un processus existant peut être un zombie, c'est\(hyà\(hydire qu'il s'est déjà terminé mais que son père n'a pas encore lu sa valeur de retour avec B<wait>(2).

note: type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001.
fr: SVr4, BSD\ 4.3, POSIX.1-2001.

note: type: Plain text
en: The only signals that can be sent to process ID 1, the I<init> process, are those for which I<init> has explicitly installed signal handlers.  This is done to assure the system is not brought down accidentally.
fr: On ne peut envoyer au processus numéro 1 (I<init>) que des signaux pour lesquels il a expressément installé un gestionnaire. Ceci évite que le système soit arrêté accidentellement.

note: type: Plain text
en: POSIX.1-2001 requires that I<kill(-1,sig)> send I<sig> to all processes that the calling process may send signals to, except possibly for some implementation-defined system processes.  Linux allows a process to signal itself, but on Linux the call I<kill(-1,sig)> does not signal the calling process.
fr: POSIX.1-2001 réclame que I<kill(-1,sig)> envoie I<sig> à tous les processus accessibles par le processus appelant, sauf à certains processus système dépendant de l'implémentation. Linux autorise un processus à s'envoyer un signal à lui\(hymême, mais l'appel I<kill(-1,sig)> n'envoie pas le signal au processus appelant.

note: type: Plain text
en: POSIX.1-2001 requires that if a process sends a signal to itself, and the sending thread does not have the signal blocked, and no other thread has it unblocked or is waiting for it in B<sigwait>(3), at least one unblocked signal must be delivered to the sending thread before the B<kill>()  returns.
fr: POSIX.1-2001 réclame que si un processus s'envoie un signal à lui\(hymême, que ce thread ne bloque pas le signal et qu'aucun autre thread ne l'a non bloqué ou et en attente dans un B<sigwait>(3), au moins un signal non bloqué doit être délivré au thread courant avant que l'appel à B<kill>() ne revienne.

note: type: SS
en: Linux notes
fr: Notes sur Linux

note: In the 0.* kernels things chopped and changed quite a bit - MTK, 24 Jul 02 type: Plain text
en: Across different kernel versions, Linux has enforced different rules for the permissions required for an unprivileged process to send a signal to another process.  In kernels 1.0 to 1.2.2, a signal could be sent if the effective user ID of the sender matched effective user ID of the target, or the real user ID of the sender matched the real user ID of the target.  From kernel 1.2.3 until 1.3.77, a signal could be sent if the effective user ID of the sender matched either the real or effective user ID of the target.  The current rules, which conform to POSIX.1-2001, were adopted in kernel 1.3.78.
fr: Suivant les différentes versions du noyau, Linux a utilisé différentes règles pour les permissions nécessaires à un processus non privilégié pour envoyer un signal a un autre processus. Dans les noyaux 1.0 à 1.2.2, un signal pouvait être envoyé si l'UID effectif du processus émetteur correspondait à celui du processus cible, ou si l'UID réel du processus émetteur correspondait à celui du processus cible. Dans les noyaux 1.2.3 à 1.3.77, un signal pouvait être envoyé si l'UID effectif du processus émetteur correspondait à l'UID effectif ou réel du processus cible. Les règles actuelles, conformes à POSIX.1-2001 ont été adoptées dans le noyau 1.3.78.

note: type: Plain text
en: In 2.6 kernels up to and including 2.6.7, there was a bug that meant that when sending signals to a process group, B<kill>()  failed with the error B<EPERM> if the caller did not have permission to send the signal to I<any> (rather than I<all>) of the members of the process group.  Notwithstanding this error return, the signal was still delivered to all of the processes for which the caller had permission to signal.
fr: Dans les noyaux 2.6 jusqu'à 2.6.7 inclus, en raison d'un bogue, lorsqu'un signal était envoyé à un groupe de processus, B<kill>() échouait avec l'erreur B<EPERM> si l'appelant n'avait pas la permission d'envoyer le signal à I<tous> les membres du groupe. En dépit de ce code d'erreur, le signal était cependant bien envoyé à tous les processus pour lesquels l'appelant en avait la permission.

note: type: TH
en: 2010-09-20
fr: 20 septembre 2010

note: type: Plain text
en: killpg - send signal to a process group
fr: killpg - Envoyer un signal à un groupe de processus

note: type: TP
en: B<killpg>():
fr: B<killpg>()\ :

note: type: Plain text
en: B<killpg>()  sends the signal I<sig> to the process group I<pgrp>.  See B<signal>(7)  for a list of signals.
fr: B<killpg>() envoie le signal I<sig> au groupe de processus I<pgrp>. Consultez B<signal>(7) pour la liste des signaux.

note: type: Plain text
en: If I<pgrp> is 0, B<killpg>()  sends the signal to the calling process's process group.  (POSIX says: If I<pgrp> is less than or equal to 1, the behavior is undefined.)
fr: Si I<pgrp> vaut 0, B<killpg>() envoie le signal au groupe de processus du processus appelant. (POSIX dit\ : si I<pgrp> est inférieur ou égal à 1, le comportement est indéterminé.)

note: type: Plain text
en: For a process to have permission to send a signal it must either be privileged (under Linux: have the B<CAP_KILL> capability), or the real or effective user ID of the sending process must equal the real or saved set-user-ID of the target process.  In the case of B<SIGCONT> it suffices when the sending and receiving processes belong to the same session.
fr: Pour qu'un processus puisse envoyer un signal, il doit avoir les privilèges nécessaires (sous Linux\ : avoir la capacité B<CAP_KILL>), ou l'UID effectif ou réel du processus qui envoie le signal doit être égal au Set-UID sauvé ou réel du processus cible. Dans le cas du signal B<SIGCONT>, il suffit que les processus envoyant et recevant le signal appartiennent à la même session.

note: type: Plain text
en: I<sig> is not a valid signal number.
fr: I<sig> n'est pas un numéro de signal valide.

note: type: Plain text
en: No process can be found in the process group specified by I<pgrp>.
fr: Aucun processus n'appartient au groupe I<pgrp>.

note: type: Plain text
en: The process group was given as 0 but the sending process does not have a process group.
fr: On a voulu émettre vers le groupe 0, mais le processus en cours n'appartient pas à un groupe.

note: type: Plain text
en: SVr4, 4.4BSD (the B<killpg>()  function call first appeared in 4BSD), POSIX.1-2001.
fr: SVr4, BSD\ 4.4 (la fonction B<killpg>() est apparue dans BSD\ 4), POSIX.1-2001.

note: type: Plain text
en: There are various differences between the permission checking in BSD-type systems and System V-type systems.  See the POSIX rationale for B<kill>().  A difference not mentioned by POSIX concerns the return value B<EPERM>: BSD documents that no signal is sent and B<EPERM> returned when the permission check failed for at least one target process, while POSIX documents B<EPERM> only when the permission check failed for all target processes.
fr: Il y a des différences dans la vérification des permissions entre les systèmes de type BSD et ceux de type System V. Consultez l'explication de POSIX pour B<kill>(). Une différence non mentionnée dans POSIX concerne la valeur de retour B<EPERM>\ : BSD dit que lorsque la vérification des permissions échoue pour au moins un des processus cible, aucun signal n'est envoyé et B<EPERM> et retournée, alors que POSIX dit que B<EPERM> est retournée seulement lorsque la vérification des permissions échoue pour tous les processus cible.

note: type: Plain text
en: On Linux, B<killpg>()  is implemented as a library function that makes the call I<kill(-pgrp,\ sig)>.
fr: Sous Linux, B<killpg>() est implémenté comme une fonction de bibliothèque appelant I<kill(-pgrp,\ sig)>.

note: type: TH
en: 2008-10-06
fr: 6 octobre 2008

note: type: Plain text
en: pause - wait for signal
fr: pause - Attendre un signal

note: type: Plain text
en: B<pause>()  causes the calling process (or thread) to sleep until a signal is delivered that either terminates the process or causes the invocation of a signal-catching function.
fr: B<pause>() force le processus (ou le thread) appelant à s'endormir jusqu'à ce qu'un signal soit distribué, qui termine le processus ou provoque l'appel d'une fonction de gestionnaire de signal.

note: .BR ERESTARTNOHAND . type: Plain text
en: B<pause>()  returns only when a signal was caught and the signal-catching function returned.  In this case, B<pause>()  returns -1, and I<errno> is set to B<EINTR>.
fr: B<pause>() ne rend la main que lorsqu'un signal a été intercepté et que le gestionnaire s'est terminé. Dans ce cas B<pause>() renvoie -1 et I<errno> est positionné à la valeur B<EINTR>.

note: type: Plain text
en: a signal was caught and the signal-catching function returned.
fr: Un signal a été intercepté et le gestionnaire s'est terminé.

note: type: TH
en: 2014-04-14
fr: 14 avril 2014

note: type: Plain text
en: prctl - operations on a process
fr: prctl - Opérations sur un processus

note: type: Plain text
en: B<prctl>()  is called with a first argument describing what to do (with values defined in I<E<lt>linux/prctl.hE<gt>>), and further arguments with a significance depending on the first one.  The first argument can be:
fr: B<prctl>() est invoqué avec un premier paramètre indiquant ce qu'il faut faire, (ses valeurs sont définies dans I<E<lt>linux/prctl.hE<gt>>), et des paramètres supplémentaires dont la signification dépend du premier paramètre. Celui-ci peut être\ :

note: type: TP
en: B<PR_CAPBSET_READ> (since Linux 2.6.25)
fr: B<PR_CAPBSET_READ> (depuis Linux 2.6.25)

note: type: Plain text
en: Return (as the function result) 1 if the capability specified in I<arg2> is in the calling thread's capability bounding set, or 0 if it is not.  (The capability constants are defined in I<E<lt>linux/capability.hE<gt>>.)  The capability bounding set dictates whether the process can receive the capability through a file's permitted capability set on a subsequent call to B<execve>(2).
fr: Renvoyer (en résultat de fonction) 1 si la capacité indiquée par I<arg2> est présente dans la limitation de capacités du thread appelant ou 0 si elle ne l'est pas. Les constantes des capacités sont définies dans I<E<lt>linux/capability.hE<gt>>. L'ensemble des capacités liées contrôle si le processus peut recevoir la capacité par un ensemble de capacités autorisées pour un fichier lors d'un appel futur à B<execve>(2).

note: type: Plain text
en: If the capability specified in I<arg2> is not valid, then the call fails with the error B<EINVAL>.
fr: Si la capacité indiquée dans I<arg2> n'est pas valable, alors l'appel échoue avec l'erreur B<EINVAL>.

note: type: TP
en: B<PR_CAPBSET_DROP> (since Linux 2.6.25)
fr: B<PR_CAPBSET_DROP> (depuis Linux 2.6.25)

note: type: Plain text
en: If the calling thread has the B<CAP_SETPCAP> capability, then drop the capability specified by I<arg2> from the calling thread's capability bounding set.  Any children of the calling thread will inherit the newly reduced bounding set.
fr: Si le thread appelant a la capacité B<CAP_SETPCAP>, alors enlever la capacité indiquée par I<arg2> dans l'ensemble de limitation de capacités du thread appelant. Les fils du thread appelant hériteront de cette nouvelle limitation de capacités réduite.

note: type: Plain text
en: The call fails with the error: B<EPERM> if the calling thread does not have the B<CAP_SETPCAP>; B<EINVAL> if I<arg2> does not represent a valid capability; or B<EINVAL> if file capabilities are not enabled in the kernel, in which case bounding sets are not supported.
fr: L'appel échoue avec l'erreur B<EPERM> si le thread appelant n'a pas la capacité B<CAP_SETPCAP> ; ou avec l'erreur B<EINVAL> si I<arg2> ne représente pas une capacité correcte ; ou avec l'erreur B<EINVAL> si les capacités de fichier ne sont pas activée dans le noyau, auquel cas les limitations ne sont pas prises en charge par le noyau.

note: type: TP
en: B<PR_SET_CHILD_SUBREAPER> (since Linux 3.4)
fr: B<PR_SET_CHILD_SUBREAPER> (depuis Linux 3.4)

note: commit ebec18a6d3aa1e7d84aab16225e87fd25170ec2b type: Plain text
en: If I<arg2> is nonzero, set the "child subreaper" attribute of the calling process; if I<arg2> is zero, unset the attribute.  When a process is marked as a child subreaper, all of the children that it creates, and their descendants, will be marked as having a subreaper.  In effect, a subreaper fulfills the role of B<init>(1)  for its descendant processes.  Upon termination of a process that is orphaned (i.e., its immediate parent has already terminated)  and marked as having a subreaper, the nearest still living ancestor subreaper will receive a B<SIGCHLD> signal and be able to B<wait>(2)  on the process to discover its termination status.
fr: Si I<arg2> n'est pas égal à zéro, activer l'attribut « child subreaper » du processus appelant ; si I<arg2> vaut zéro, désactiver l'attribut. Si processus est marqué comme « child subreaper », tous ses fils et descendants sont marqués comme ayant un « reaper ». En pratique, un « subreaper » remplit la fonction de B<init>(1) pour ses descendants. Lorsqu'un processus orphelin se termine (orphelin : dont le parent immédiat est déjà terminé) et que ce processus est marqué comme ayant un « subreaper », alors l'ancêtre le plus proche et toujours en cours d'exécution reçoit un signal B<SIGCHLD> qui lui permet de se mettre en attente (B<wait>(2)) du processus orphelin, et de déterminer son code de retour.

note: type: TP
en: B<PR_GET_CHILD_SUBREAPER> (since Linux 3.4)
fr: B<PR_GET_CHILD_SUBREAPER> (depuis Linux 3.4)

note: type: Plain text
en: Return the "child subreaper" setting of the caller, in the location pointed to by I<(int\ *) arg2>.
fr: Renvoyer l'état « child subreaper » du processus appelant, dans l'emplacement pointé par I<(int\ *) arg2>.

note: type: TP
en: B<PR_SET_DUMPABLE> (since Linux 2.3.20)
fr: B<PR_SET_DUMPABLE> (depuis Linux 2.3.20)

note: See http://marc.theaimsgroup.com/?l=linux-kernel&m=115270289030630&w=2 Subject:    Fix prctl privilege escalation (CVE-2006-2451) From:       Marcel Holtmann <marcel () holtmann ! org> Date:       2006-07-12 11:12:00 type: Plain text
en: Set the state of the flag determining whether core dumps are produced for the calling process upon delivery of a signal whose default behavior is to produce a core dump.  (Normally, this flag is set for a process by default, but it is cleared when a set-user-ID or set-group-ID program is executed and also by various system calls that manipulate process UIDs and GIDs).  In kernels up to and including 2.6.12, I<arg2> must be either 0 (process is not dumpable) or 1 (process is dumpable).  Between kernels 2.6.13 and 2.6.17, the value 2 was also permitted, which caused any binary which normally would not be dumped to be dumped readable by root only; for security reasons, this feature has been removed.  (See also the description of I</proc/sys/fs/suid_dumpable> in B<proc>(5).)  Processes that are not dumpable can not be attached via B<ptrace>(2)  B<PTRACE_ATTACH>.
fr: Définir l'attribut déterminant si un fichier core est produit lorsque le processus appelant reçoit un signal dont le comportement par défaut est de produire un fichier core. (Normalement cet attribut est par défaut validé pour un processus, mais est effacé à l'exécution d'un programme Set-UID ou Set-GID ainsi que par divers appels système manipulant des UID et GID). Dans les noyaux jusqu'à 2.6.12 inclus, I<arg2> doit valoir 0 (pas de fichier core) ou 1 (fichier core possible). Entre les noyaux 2.6.13 et 2.6.17, la valeur 2 était également autorisée\ ; elle permettait à un binaire qui ne produirait normalement pas de fichier core d'en créer un lisible uniquement par root\ ; cette fonctionnalité a été supprimée pour des raisons de sécurité. (Consultez aussi la description de I</proc/sys/fs/suid_dumpable> dans B<proc>(5).) La commande B<ptrace>(2) B<PTRACE_ATTACH> ne permet pas d'attacher des processus qui ne produisent pas normalement de fichier core.

note: type: TP
en: B<PR_GET_DUMPABLE> (since Linux 2.3.20)
fr: B<PR_GET_DUMPABLE> (depuis Linux 2.3.20)

note: Since Linux 2.6.13, the dumpable flag can have the value 2, but in 2.6.13 PR_GET_DUMPABLE simply returns 1 if the dumpable flags has a nonzero value.  This was fixed in 2.6.14. type: Plain text
en: Return (as the function result) the current state of the calling process's dumpable flag.
fr: Renvoyer (en résultat de fonction) l'état actuel de l'attribut de création de fichier core du processus appelant.

note: type: TP
en: B<PR_SET_ENDIAN> (since Linux 2.6.18, PowerPC only)
fr: B<PR_SET_ENDIAN> (depuis Linux 2.6.18, seulement sur PowerPC)

note: Respectively 0, 1, 2 type: Plain text
en: Set the endian-ness of the calling process to the value given in I<arg2>, which should be one of the following: B<PR_ENDIAN_BIG>, B<PR_ENDIAN_LITTLE>, or B<PR_ENDIAN_PPC_LITTLE> (PowerPC pseudo little endian).
fr: Définir le boutisme (endianness) du processus appelant à la valeur donnée dans I<arg2>, qui doit être l'une des valeurs suivantes\ : B<PR_ENDIAN_BIG>, B<PR_ENDIAN_LITTLE>, ou B<PR_ENDIAN_PPC_LITTLE> (PowerPC pseudopetit boutiste).

note: type: TP
en: B<PR_GET_ENDIAN> (since Linux 2.6.18, PowerPC only)
fr: B<PR_GET_ENDIAN> (depuis Linux 2.6.18, seulement sur PowerPC)

note: type: Plain text
en: Return the endian-ness of the calling process, in the location pointed to by I<(int\ *) arg2>.
fr: Renvoyer le boutisme (endianness) du processus appelant, dans l'emplacement pointé par I<(int\ *) arg2>.

note: type: TP
en: B<PR_SET_FPEMU> (since Linux 2.4.18, 2.5.9, only on ia64)
fr: B<PR_SET_FPEMU> (depuis Linux 2.4.18, 2.5.9, seulement sur ia64)

note: type: Plain text
en: Set floating-point emulation control bits to I<arg2>.  Pass B<PR_FPEMU_NOPRINT> to silently emulate fp operations accesses, or B<PR_FPEMU_SIGFPE> to not emulate fp operations and send B<SIGFPE> instead.
fr: Définir les bits de contrôle de l'émulation de FPU à I<arg2>. Passer B<PR_FPEMU_NOPRINT> pour émuler silencieusement les opérations flottantes, ou B<PR_FPEMU_SIGFPE> pour ne pas émuler les opérations flottantes, et envoyer B<SIGFPE>.

note: type: TP
en: B<PR_GET_FPEMU> (since Linux 2.4.18, 2.5.9, only on ia64)
fr: B<PR_GET_FPEMU> (depuis Linux 2.4.18, 2.5.9, seulement sur ia64)

note: type: Plain text
en: Return floating-point emulation control bits, in the location pointed to by I<(int\ *) arg2>.
fr: Renvoyer les bits de contrôle de l'émulation de FPU, dans l'emplacement pointé par I<(int\ *) arg2>.

note: type: TP
en: B<PR_SET_FPEXC> (since Linux 2.4.21, 2.5.32, only on PowerPC)
fr: B<PR_SET_FPEXC> (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC)

note: type: Plain text
en: Set floating-point exception mode to I<arg2>.  Pass B<PR_FP_EXC_SW_ENABLE> to use FPEXC for FP exception enables, B<PR_FP_EXC_DIV> for floating-point divide by zero, B<PR_FP_EXC_OVF> for floating-point overflow, B<PR_FP_EXC_UND> for floating-point underflow, B<PR_FP_EXC_RES> for floating-point inexact result, B<PR_FP_EXC_INV> for floating-point invalid operation, B<PR_FP_EXC_DISABLED> for FP exceptions disabled, B<PR_FP_EXC_NONRECOV> for async nonrecoverable exception mode, B<PR_FP_EXC_ASYNC> for async recoverable exception mode, B<PR_FP_EXC_PRECISE> for precise exception mode.
fr: Définir le mode d'exception flottante à I<arg2>. Passer la valeur B<PR_FP_EXC_SW_ENABLE> pour utiliser FPEXC pour activer les exceptions flottantes, B<PR_FP_EXC_DIV> pour les divisions flottantes par zéro, B<PR_FP_EXC_OVF> pour les dépassements de capacité vers le haut, B<PR_FP_EXC_UND> pour les dépassements de capacité vers le bas, B<PR_FP_EXC_RES> pour les résultats flottants inexacts, B<PR_FP_EXC_INV> pour les opérations flottantes invalides, B<PR_FP_EXC_DISABLED> pour désactiver les exceptions flottantes, B<PR_FP_EXC_NONRECOV> pour le mode d'exceptions asynchrone non récupérable, B<PR_FP_EXC_ASYNC> pour le mode d'exceptions asynchrone récupérable, B<PR_FP_EXC_PRECISE> pour le mode d'exception précis.

note: type: TP
en: B<PR_GET_FPEXC> (since Linux 2.4.21, 2.5.32, only on PowerPC)
fr: B<PR_GET_FPEXC> (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC)

note: type: Plain text
en: Return floating-point exception mode, in the location pointed to by I<(int\ *) arg2>.
fr: Renvoyer le mode d'exception flottante, dans l'emplacement pointé par I<(int\ *) arg2>.

note: type: TP
en: B<PR_SET_KEEPCAPS> (since Linux 2.2.18)
fr: B<PR_SET_KEEPCAPS> (depuis Linux 2.2.18)

note: type: Plain text
en: Set the state of the thread's "keep capabilities" flag, which determines whether the threads's permitted capability set is cleared when a change is made to the threads's user IDs such that the threads's real UID, effective UID, and saved set-user-ID all become nonzero when at least one of them previously had the value 0.  By default, the permitted capability set is cleared when such a change is made; setting the "keep capabilities" flag prevents it from being cleared.  I<arg2> must be either 0 (permitted capabilities are cleared)  or 1 (permitted capabilities are kept).  (A thread's I<effective> capability set is always cleared when such a credential change is made, regardless of the setting of the "keep capabilities" flag.)  The "keep capabilities" value will be reset to 0 on subsequent calls to B<execve>(2).
fr: Définir l'état de l'attribut de conservation des capacités du thread (I<keep capabilities>), qui détermine si l'ensemble des capacités disponibles est effacé lorsqu'on modifie les UID réel, effectif et sauvé du thread de manière à ce que tous soient non nuls alors qu'auparavant l'un au moins était nul. Par défaut, l'ensemble des capacités disponibles est effacé lorsqu'un tel changement intervient. Définir l'attribut de conservation des capacités du thread l'empêche d'être effacé. I<arg2> doit valoir 0 (les capacités disponibles sont effacées) ou 1 (capacités disponibles conservées). L'ensemble des capacités effectives est toujours effacé lorsqu'un tel changement intervient, quelle que soit la valeur de l'attribut de conservation des capacités. Cet attribut est remis à zéro pour les appels ultérieurs à B<execve>(2).

note: type: TP
en: B<PR_GET_KEEPCAPS> (since Linux 2.2.18)
fr: B<PR_GET_KEEPCAPS> (depuis Linux 2.2.18)

note: type: Plain text
en: Return (as the function result) the current state of the calling threads's "keep capabilities" flag.
fr: Renvoyer (en résultat de fonction) l'état actuel de l'attribut de conservation des capacités du thread appelant.

note: type: TP
en: B<PR_SET_NAME> (since Linux 2.6.9)
fr: B<PR_SET_NAME> (depuis Linux 2.6.9)

note: TASK_COMM_LEN in include/linux/sched.h type: Plain text
en: Set the name of the calling thread, using the value in the location pointed to by I<(char\ *) arg2>.  The name can be up to 16 bytes long, and should be null-terminated if it contains fewer bytes.  This is the same attribute that can be set via B<pthread_setname_np>(3)  and retrieved using B<pthread_getname_np>(3).  The attribute is likewise accessible via I</proc/self/task/[tid]/comm>, where I<tid> is the name of the calling thread.
fr: Définir le nom du thread appelant, en utilisant la valeur de l'emplacement pointé par I<(char\ *) arg2>. Le nom peut avoir jusqu'à 16 octets de long et doit être terminé par un caractère nul s'il est plus petit. Ce même attribut peut être défini par  B<pthread_setname_np>(3) et consulté par B<pthread_getname_np>(3). On peut également y accéder via I</proc/self/task/[tid]/comm>, où  I<tid> désigne le nom du thread appelant.

note: type: TP
en: B<PR_GET_NAME> (since Linux 2.6.11)
fr: B<PR_GET_NAME> (depuis Linux 2.6.11)

note: type: Plain text
en: Return the name of the calling thread, in the buffer pointed to by I<(char\ *) arg2>.  The buffer should allow space for up to 16 bytes; the returned string will be null-terminated if it is shorter than that.
fr: Renvoyer le nom du thread appelant, dans le tampon pointé par I<(char\ *) arg2>. Le tampon doit être suffisamment grand pour contenir jusqu'à 16 octets ; la chaîne sera terminée par un caractère nul si elle est plus petite.

note: type: TP
en: B<PR_SET_NO_NEW_PRIVS> (since Linux 3.5)
fr: B<PR_SET_NO_NEW_PRIVS> (depuis Linux 3.5)

note: type: Plain text
en: Set the calling process's I<no_new_privs> bit to the value in I<arg2>.  With I<no_new_privs> set to 1, B<execve>(2)  promises not to grant privileges to do anything that could not have been done without the B<execve>(2)  call (for example, rendering the set-user-ID and set-group-ID permission bits, and file capabilities non-functional).  Once set, this bit cannot be unset.  The setting of this bit is inherited by children created by B<fork>(2)  and B<clone>(2), and preserved across B<execve>(2).
fr: Affecter au bit I<no_new_privs> du processus appelant la valeur dans I<arg2>. Lorsque I<no_new_privs> a la valeur 1, B<execve>(2) promet de ne pas donner de droits à quoique ce soit qui n'aurait pas pu être fait sans l'appel B<execve>(2) (par exemple, rendre non fonctionnels les bits de permission set-user-ID et set-group-ID, ou bien les capacités de fichiers). Une fois affecté, le bit ne peut pas être réinitialisé. L'affectation de ce bit est héritée par les enfants créés par B<fork>(2) et B<clone>(2), et préservée à travers B<execve>(2).

note: type: Plain text
en: For more information, see the kernel source file I<Documentation/prctl/no_new_privs.txt>.
fr: Pour plus d'informations, consultez le fichier I<Documentation/prctl/no_new_privs.txt> dans les sources du noyau.

note: type: TP
en: B<PR_GET_NO_NEW_PRIVS> (since Linux 3.5)
fr: B<PR_GET_NO_NEW_PRIVS> (depuis Linux 3.5)

note: type: Plain text
en: Return (as the function result) the value of the I<no_new_privs> bit for the current process.  A value of 0 indicates the regular B<execve>(2)  behavior.  A value of 1 indicates B<execve>(2)  will operate in the privilege-restricting mode described above.
fr: Renvoyer (comme résultat de la fonction) la valeur du bit I<no_new_privs> du processus actuel. La valeur 0 indique le comportement habituel de B<execve>(2). La valeur 1 indique que B<execve>(2) va opérer dans le mode limiteur de droits décrit ci-dessus.

note: type: TP
en: B<PR_SET_PDEATHSIG> (since Linux 2.1.57)
fr: B<PR_SET_PDEATHSIG> (depuis Linux 2.1.57)

note: type: Plain text
en: Set the parent process death signal of the calling process to I<arg2> (either a signal value in the range 1..maxsig, or 0 to clear).  This is the signal that the calling process will get when its parent dies.  This value is cleared for the child of a B<fork>(2)  and (since Linux 2.4.36 / 2.6.23)  when executing a set-user-ID or set-group-ID binary.  This value is preserved across B<execve>(2).
fr: Configurer le signal de mort du père du processus appelant avec la valeur I<arg2> (qui peut être un numéro de signal dans l'intervalle 1..maxsig, ou être nul pour effacer le signal). Il s'agit du numéro du signal que le processus appelant recevra si son père se termine. Cette valeur est effacée pour le fils d'un B<fork>(2), et (depuis Linux 2.4.36 et 2.6.23) lors de l'exécution d'un binaire Set-UID ou Set-GID. Cette valeur est préservée par B<execve>(2).

note: type: TP
en: B<PR_GET_PDEATHSIG> (since Linux 2.3.15)
fr: B<PR_GET_PDEATHSIG> (depuis Linux 2.3.15)

note: type: Plain text
en: Return the current value of the parent process death signal, in the location pointed to by I<(int\ *) arg2>.
fr: Renvoyer la valeur actuelle du signal de mort du processus père, dans l'emplacement pointé par I<(int\ *) arg2>.

note: type: TP
en: B<PR_SET_PTRACER> (since Linux 3.4)
fr: B<PR_SET_PTRACER> (depuis Linux 3.4)

note: commit 2d514487faf188938a4ee4fb3464eeecfbdcf8eb commit bf06189e4d14641c0148bea16e9dd24943862215 type: Plain text
en: This is meaningful only when the Yama LSM is enabled and in mode 1 ("restricted ptrace", visible via I</proc/sys/kernel/yama/ptrace_scope>).  When a "ptracer process ID" is passed in I<arg2>, the caller is declaring that the ptracer process can B<ptrace>(2)  the calling process as if it were a direct process ancestor.  Each B<PR_SET_PTRACER> operation replaces the previous "ptracer process ID".  Employing B<PR_SET_PTRACER> with I<arg2> set to 0 clears the caller's "ptracer process ID".  If I<arg2> is B<PR_SET_PTRACER_ANY>, the ptrace restrictions introduced by Yama are effectively disabled for the calling process.
fr: Cela n'a de sens que lorsque le LSM Yama est actif et en mode 1 ("restricted ptrace", visible dans I</proc/sys/kernel/yama/ptrace_scope>). Lorsqu'un identifiant de processus ptracer (« ptracer process ID ») est passé en argument I<arg2>, le composant appelant déclare que le processus ptracer peut appeler la fonction B<ptrace>(2) appliquée au processus appelant, comme si celui-ci était un ancêtre direct. Chaque opération B<PR_SET_PTRACER> remplace l'identifiant du processus ptracer précédent. L'emploi de B<PR_SET_PTRACER> avec l'argument I<arg2> égal à 0 supprime tous les identifiants de processus ptracer de l'appelant. Si I<arg2>est égal à B<PR_SET_PTRACER_ANY>, les restrictions ptrace apportées par Yama sont de fait désactivées pour le processus appelant.

note: type: Plain text
en: For further information, see the kernel source file I<Documentation/security/Yama.txt>.
fr: Pour plus d'informations, consultez le fichier I<Documentation/security/Yama.txt> dans les sources du noyau.

note: type: TP
en: B<PR_SET_SECCOMP> (since Linux 2.6.23)
fr: B<PR_SET_SECCOMP> (depuis Linux 2.6.23)

note: See http://thread.gmane.org/gmane.linux.kernel/542632 [PATCH 0 of 2] seccomp updates andrea@cpushare.com type: Plain text
en: Set the secure computing (seccomp) mode for the calling thread, to limit the available system calls.  The seccomp mode is selected via I<arg2>.  (The seccomp constants are defined in I<E<lt>linux/seccomp.hE<gt>>.)
fr: Sélectionner le mode de traitement sécurisé (seccomp) pour le thread appelant, afin de limiter les appels système disponibles. Le mode de traitement sécurisé est sélectionné par I<arg2> (les constantes du mode de traitement sécurisé sont définies dans I<E<lt>linux/seccomp.hE<gt>>).

note: type: Plain text
en: With I<arg2> set to B<SECCOMP_MODE_STRICT> the only system calls that the thread is permitted to make are B<read>(2), B<write>(2), B<_exit>(2), and B<sigreturn>(2).  Other system calls result in the delivery of a B<SIGKILL> signal.  Strict secure computing mode is useful for number-crunching applications that may need to execute untrusted byte code, perhaps obtained by reading from a pipe or socket.  This operation is available only if the kernel is configured with B<CONFIG_SECCOMP> enabled.
fr: Lorsque I<arg2> vaut B<SECCOMP_MODE_STRICT>, les seuls appels système permis pour le thread sont B<read>(2), B<write>(2), B<_exit>(2) et B<sigreturn>(2). Les autres appels système provoque la réception d'un signal B<SIGKILL>. Le mode de traitement sécurisé strict est utile pour les applications de traitement numérique qui peuvent avoir besoin d'exécuter des instructions ne provenant pas d'une source de confiance, lues à partir d'un tuyau (« pipe ») ou d'une socket. Cette opération n'est disponible que si le noyau a été configuré avec l'option B<CONFIG_SECCOMP> activée.

note: type: Plain text
en: With I<arg2> set to B<SECCOMP_MODE_FILTER> (since Linux 3.5)  the system calls allowed are defined by a pointer to a Berkeley Packet Filter passed in I<arg3>.  This argument is a pointer to I<struct sock_fprog>; it can be designed to filter arbitrary system calls and system call arguments.  This mode is available only if the kernel is configured with B<CONFIG_SECCOMP_FILTER> enabled.
fr: Lorsque I<arg2> vaut B<SECCOMP_MODE_FILTER> (depuis Linux 3.5) les appels système autorisés sont définis par un pointeur vers un filtre de paquets Berkeley passé en I<arg3>. Cet argument est un pointeur vers I<struct sock_fprog> ; il peut être conçu pour filtrer des appels système arbitraires et les arguments des appels système. Ce mode est seulement disponible si le noyau est configuré avec l'option B<CONFIG_SECCOMP_FILTER> activée.

note: type: Plain text
en: If B<SECCOMP_MODE_FILTER> filters permit B<fork>(2), then the seccomp mode is inherited by children created by B<fork>(2); if B<execve>(2)  is permitted, then the seccomp mode is preserved across B<execve>(2).  If the filters permit B<prctl>()  calls, then additional filters can be added; they are run in order until the first non-allow result is seen.
fr: Si les filtres B<SECCOMP_MODE_FILTER> autorisent B<fork>(2), alors le mode de traitement sécurisé est hérité par les enfants créés par B<fork>(2) ; si B<execve>(2) est autorisé, alors le mode de traitement sécurisé est préservé à travers B<execve>(2). Si les filtres autorisent les appels B<prctl>(), alors des filtres additionnels peuvent être ajoutés ; ils sont exécutés dans l'ordre jusqu'au premier résultat non autorisé.

note: type: Plain text
en: For further information, see the kernel source file I<Documentation/prctl/seccomp_filter.txt>.
fr: Pour plus d'informations, consultez le fichier I<Documentation/prctl/seccomp_filter.txt> dans les sources du noyau.

note: type: TP
en: B<PR_GET_SECCOMP> (since Linux 2.6.23)
fr: B<PR_GET_SECCOMP> (depuis Linux 2.6.23)

note: type: Plain text
en: Return (as the function result)  the secure computing mode of the calling thread.  If the caller is not in secure computing mode, this operation returns 0; if the caller is in strict secure computing mode, then the B<prctl>()  call will cause a B<SIGKILL> signal to be sent to the process.  If the caller is in filter mode, and this system call is allowed by the seccomp filters, it returns 2.  This operation is available only if the kernel is configured with B<CONFIG_SECCOMP> enabled.
fr: Renvoyer (comme résultat de la fonction) le mode de traitement sécurisé du thread appelant. Si l'appelant n'est pas dans un mode de traitement sécurisé, cette opération renvoie 0 ; si l'appelant est dans le mode de traitement sécurisé strict, alors l'appel B<prctl>() provoquera l'envoi d'un signal B<SIGKILL> au processus. Si l'appelant est dans le mode filtre et que cet appel système est autorisé par les filtres seccomp, cette opération renvoie 2. Cette opération n'est disponible que si le noyau a été configuré avec l'option B<CONFIG_SECCOMP> activée.

note: type: TP
en: B<PR_SET_SECUREBITS> (since Linux 2.6.26)
fr: B<PR_SET_SECUREBITS> (depuis Linux 2.6.26)

note: type: Plain text
en: Set the "securebits" flags of the calling thread to the value supplied in I<arg2>.  See B<capabilities>(7).
fr: Configurer l'attribut « securebits » du thread appelant à la valeur fournie par I<arg2>. Consultez B<capabilities>(7).

note: type: TP
en: B<PR_GET_SECUREBITS> (since Linux 2.6.26)
fr: B<PR_GET_SECUREBITS> (depuis Linux 2.6.26)

note: type: Plain text
en: Return (as the function result)  the "securebits" flags of the calling thread.  See B<capabilities>(7).
fr: Renvoyer (en résultat de fonction) l'état actuel de l'attribut « securebits » du thread appelant. Consultez B<capabilities>(7).

note: type: TP
en: B<PR_SET_THP_DISABLE> (since Linux 3.15)
fr: B<PR_SET_THP_DISABLE> (depuis Linux 3.15)

note: commit a0715cc22601e8830ace98366c0c2bd8da52af52 type: Plain text
en: Set the state of the "THP disable" flag for the calling thread.  If I<arg2> has a nonzero value, the flag is set, otherwise it is cleared.  Setting this flag provides a method for disabling transparent huge pages for jobs where the code cannot be modified, and using a malloc hook with B<madvise>(2)  is not an option (i.e., statically allocated data).  The setting of the "THP disable" flag is inherited by a child created via B<fork>(2)  and is preserved across B<execve>(2).
fr: Affecter l'état de l'attribut « THP disable » pour le thread appelant. Si I<arg2> a une valeur non nulle, l'attribut est activé ; dans le cas contraire, il est désactivé. L'utilisation de cet attribut fournit un moyen de supprimer les pages de très grande taille correspondant à des jobs pour lesquels le code ne peut pas être modifié, et dans les cas où le recours à des routines malloc associées à des appels B<madvise>(2) n'offre pas de solution (c'est-à-dire pour des données allouées statiquement). L'activation de l'attribut « THP disable » est transmis aux fils créés au moyen de B<fork>(2) et est conservé lors d'un appel à B<execve>(2).

note: type: TP
en: B<PR_GET_THP_DISABLE> (since Linux 3.15)
fr: B<PR_GET_THP_DISABLE> (depuis Linux 3.15)

note: type: Plain text
en: Return (via the function result) the current setting of the "THP disable" flag for the calling thread: either 1, if the flag is set, or 0, if it is not.
fr: Renvoyer (en résultat de fonction) l'état actuel de l'attribut « THP disable » du thread appelant, c'est à dire 1 si l'attribut est activé, et 0 dans le cas contraire.

note: type: TP
en: B<PR_GET_TID_ADDRESS> (since Linux 3.5)
fr: B<PR_GET_TID_ADDRESS> (depuis Linux 3.5)

note: commit 300f786b2683f8bb1ec0afb6e1851183a479c86d type: Plain text
en: Retrieve the I<clear_child_tid> address set by B<set_tid_address>(2)  and the B<clone>(2)  B<CLONE_CHILD_CLEARTID> flag, in the location pointed to by I<(int\ **)\ arg2>.  This feature is available only if the kernel is built with the B<CONFIG_CHECKPOINT_RESTORE> option enabled.
fr: Récupérer l'adresse I<clear_child_tid> configurée par B<set_tid_address>(2) et par l'attribut B<CLONE_CHILD_CLEARTID> de B<clone>(2), à l'emplacement que pointe I<(int\ **)\ arg2>. Cette option n'est disponible que si le noyau est construit avec l'option B<CONFIG_CHECKPOINT_RESTORE>.

note: type: TP
en: B<PR_SET_TIMERSLACK> (since Linux 2.6.28)
fr: B<PR_SET_TIMERSLACK> (depuis Linux 2.6.28)

note: See https://lwn.net/Articles/369549/ commit 6976675d94042fbd446231d1bd8b7de71a980ada It seems that it's not possible to set the timer slack to zero; The minimum value is 1? Seems a little strange. type: Plain text
en: Set the current timer slack for the calling thread to the nanosecond value supplied in I<arg2>.  If I<arg2> is less than or equal to zero, reset the current timer slack to the thread's default timer slack value.  The timer slack is used by the kernel to group timer expirations for the calling thread that are close to one another; as a consequence, timer expirations for the thread may be up to the specified number of nanoseconds late (but will never expire early).  Grouping timer expirations can help reduce system power consumption by minimizing CPU wake-ups.
fr: Définir la valeur actuelle de temporisation relâchée pour le thread appelant à la valeur fournie par I<arg2> en nanoseconde. Si I<arg2> est inférieur ou égal à zéro, réinitialiser la temporisation relâchée actuelle à la valeur de temporisation relâchée par défaut du thread. La temporisation relâchée est utilisée par le noyau pour grouper les délais d'expiration des threads appelants qui sont proches les uns des autres. Par conséquent, les délais d'expiration des threads pourraient être en retard jusqu'au nombre de nanosecondes indiqué (mais jamais en avance). Le groupement des délais d'expiration permet de réduire la consommation d'énergie du système en minimisant les réveils du processeur.

note: List obtained by grepping for futex usage in glibc source type: Plain text
en: The timer expirations affected by timer slack are those set by B<select>(2), B<pselect>(2), B<poll>(2), B<ppoll>(2), B<epoll_wait>(2), B<epoll_pwait>(2), B<clock_nanosleep>(2), B<nanosleep>(2), and B<futex>(2)  (and thus the library functions implemented via futexes, including B<pthread_cond_timedwait>(3), B<pthread_mutex_timedlock>(3), B<pthread_rwlock_timedrdlock>(3), B<pthread_rwlock_timedwrlock>(3), and B<sem_timedwait>(3)).
fr: Les délais d'expiration affectés par la temporisation relâchée sont ceux définis par B<select>(2), B<pselect>(2), B<poll>(2), B<ppoll>(2), B<epoll_wait>(2), B<epoll_pwait>(2), B<clock_nanosleep>(2), B<nanosleep>(2) et B<futex>(2) (et donc les fonctions de bibliothèque implémentés par futex, y compris B<pthread_cond_timedwait>(3), B<pthread_mutex_timedlock>(3), B<pthread_rwlock_timedrdlock>(3), B<pthread_rwlock_timedwrlock>(3) et B<sem_timedwait>(3)).

note: type: Plain text
en: Timer slack is not applied to threads that are scheduled under a real-time scheduling policy (see B<sched_setscheduler>(2)).
fr: La temporisation relâchée ne s'applique pas aux threads qui sont programmés avec une stratégie d'ordonnancement en temps réel (consultez B<sched_setscheduler>(2)).

note: type: Plain text
en: Each thread has two associated timer slack values: a "default" value, and a "current" value.  The current value is the one that governs grouping of timer expirations.  When a new thread is created, the two timer slack values are made the same as the current value of the creating thread.  Thereafter, a thread can adjust its current timer slack value via B<PR_SET_TIMERSLACK> (the default value can't be changed).  The timer slack values of I<init> (PID 1), the ancestor of all processes, are 50,000 nanoseconds (50 microseconds).  The timer slack values are preserved across B<execve>(2).
fr: Tous les threads ont deux valeurs de temporisation relâchée associées : une valeur par défaut (« default », et une actuelle (« current »). La valeur actuelle est celle qui gouverne le groupement des délais d'expiration. Quand un nouveau thread est créé, les deux valeurs de temporisation relâchée sont rendues identiques à la valeur actuelle du thread qui l'a créé. Ensuite, un thread peut ajuster sa valeur de temporisation relâchée actuelle à l'aide de B<PR_SET_TIMERSLACK> (la valeur par défaut peut être modifiée). Les valeurs de temporisation relâchée d'I<init> (PID 1), l'ancêtre de tous les processus, sont de 50 000 nanosecondes (50 microsecondes). Les valeurs de temporisation relâchée sont préservées à travers B<execve>(2).

note: type: TP
en: B<PR_GET_TIMERSLACK> (since Linux 2.6.28)
fr: B<PR_GET_TIMERSLACK> (depuis Linux 2.6.28)

note: type: Plain text
en: Return (as the function result)  the current timer slack value of the calling thread.
fr: Renvoyer (comme résultat de la fonction) la valeur actuelle de temporisation relâchée du thread appelant.

note: type: TP
en: B<PR_SET_TIMING> (since Linux 2.6.0-test4)
fr: B<PR_SET_TIMING> (depuis Linux 2.6.0-test4)

note: 0 1 PR_TIMING_TIMESTAMP doesn't do anything in 2.6.26-rc8, and looking at the patch history, it appears that it never did anything. type: Plain text
en: Set whether to use (normal, traditional) statistical process timing or accurate timestamp-based process timing, by passing B<PR_TIMING_STATISTICAL> or B<PR_TIMING_TIMESTAMP> to I<arg2>.  B<PR_TIMING_TIMESTAMP> is not currently implemented (attempting to set this mode will yield the error B<EINVAL>).
fr: Permettre de choisir la méthode de mesure du temps du processus à utiliser, en passant dans I<arg2> soit B<PR_TIMING_STATISTICAL> (méthode statistique traditionnelle) ou B<PR_TIMING_TIMESTAMP> (méthode exacte utilisant des horodatages). B<PR_TIMING_TIMESTAMP> n'est pas implémenté pour l'instant (l'utilisation de ce mode renverra l'erreur B<EINVAL>).

note: type: TP
en: B<PR_GET_TIMING> (since Linux 2.6.0-test4)
fr: B<PR_GET_TIMING> (depuis Linux 2.6.0-test4)

note: type: Plain text
en: Return (as the function result) which process timing method is currently in use.
fr: Renvoyer (en résultat de fonction) quelle méthode de mesure du temps du processus est utilisée actuellement.

note: type: TP
en: B<PR_TASK_PERF_EVENTS_DISABLE> (since Linux 2.6.31)
fr: B<PR_TASK_PERF_EVENTS_DISABLE> (depuis Linux 2.6.31)

note: type: Plain text
en: Disable all performance counters attached to the calling process, regardless of whether the counters were created by this process or another process.  Performance counters created by the calling process for other processes are unaffected.  For more information on performance counters, see the Linux kernel source file I<tools/perf/design.txt>.
fr: Désactiver tous les compteurs de performance attachés au processus appelant, indépendamment du fait que ces compteurs ont été créés par ce processus ou par un autre. Les compteurs de performance créés par le processus appelant pour d'autres processus ne sont pas concernés. Pour plus d'informations sur les compteurs de performance, consultez le fichier source I<tools/perf/design.txt> du noyau Linux.

note: commit 1d1c7ddbfab358445a542715551301b7fc363e28 type: Plain text
en: Originally called B<PR_TASK_PERF_COUNTERS_DISABLE>; renamed (with same numerical value)  in Linux 2.6.32.
fr: Initialement appelé B<PR_TASK_PERF_COUNTERS_DISABLE>. Renommé (avec la même valeur numérique) dans Linux 2.6.32.

note: type: TP
en: B<PR_TASK_PERF_EVENTS_ENABLE> (since Linux 2.6.31)
fr: B<PR_TASK_PERF_EVENTS_ENABLE> (depuis Linux 2.6.31)

note: type: Plain text
en: The converse of B<PR_TASK_PERF_EVENTS_DISABLE>; enable performance counters attached to the calling process.
fr: L'inverse de B<PR_TASK_PERF_EVENTS_DISABLE>. Activer les compteurs de performance attachés au processus appelant.

note: commit 1d1c7ddbfab358445a542715551301b7fc363e28 commit cdd6c482c9ff9c55475ee7392ec8f672eddb7be6 type: Plain text
en: Originally called B<PR_TASK_PERF_COUNTERS_ENABLE>; renamed in Linux 2.6.32.
fr: Initialement appelé B<PR_TASK_PERF_COUNTERS_ENABLE>. Renommé dans Linux 2.6.32.

note: type: TP
en: B<PR_SET_TSC> (since Linux 2.6.26, x86 only)
fr: B<PR_SET_TSC> (depuis Linux 2.6.26, seulement sur x86)

note: type: Plain text
en: Set the state of the flag determining whether the timestamp counter can be read by the process.  Pass B<PR_TSC_ENABLE> to I<arg2> to allow it to be read, or B<PR_TSC_SIGSEGV> to generate a B<SIGSEGV> when the process tries to read the timestamp counter.
fr: Configurer l'état de l'attribut qui indique si le compteur d'horodatage peut être lu par le processus. Utilisez B<PR_TSC_ENABLE> pour I<arg2> permet d'autoriser les lectures ou B<PR_TSC_SIGSEGV> pour produire un B<SIGSEGV> quand le processus essaie de lire le compteur d'horodatage.

note: type: TP
en: B<PR_GET_TSC> (since Linux 2.6.26, x86 only)
fr: B<PR_GET_TSC> (depuis Linux 2.6.26, seulement sur x86)

note: type: Plain text
en: Return the state of the flag determining whether the timestamp counter can be read, in the location pointed to by I<(int\ *) arg2>.
fr: Renvoyer, dans l'emplacement pointé par I<(int\ *) arg2>, l'état de l'attribut qui indique si le compteur d'horodatage peut être lu.

note: type: Plain text
en: (Only on: ia64, since Linux 2.3.48; parisc, since Linux 2.6.15; PowerPC, since Linux 2.6.18; Alpha, since Linux 2.6.22)  Set unaligned access control bits to I<arg2>.  Pass B<PR_UNALIGN_NOPRINT> to silently fix up unaligned user accesses, or B<PR_UNALIGN_SIGBUS> to generate B<SIGBUS> on unaligned user access.
fr: (Seulement sur : ia64, depuis Linux 2.3.48 ; parisc, depuis Linux 2.6.15 ; PowerPC, depuis Linux 2.6.18 ; Alpha, depuis Linux 2.6.22) Définir les bits de contrôle pour les accès non alignés à I<arg2>. La valeur B<PR_UNALIGN_NOPRINT> signifie que les accès non alignés en espace utilisateurs sont silencieusement corrigés, et B<PR_UNALIGN_SIGBUS> cause l'envoi de B<SIGBUS> lors d'un accès non aligné.

note: type: Plain text
en: (see B<PR_SET_UNALIGN> for information on versions and architectures)  Return unaligned access control bits, in the location pointed to by I<(int\ *) arg2>.
fr: (Consultez B<PR_SET_UNALIGN> pour les informations sur les versions et les architectures) Renvoyer les bits de contrôle des accès non alignés, dans l'emplacement pointé par I<(int\ *) arg2>.

note: type: TP
en: B<PR_MCE_KILL> (since Linux 2.6.32)
fr: B<PR_MCE_KILL> (depuis Linux 2.6.32)

note: type: Plain text
en: Set the machine check memory corruption kill policy for the current thread.  If I<arg2> is B<PR_MCE_KILL_CLEAR>, clear the thread memory corruption kill policy and use the system-wide default.  (The system-wide default is defined by I</proc/sys/vm/memory_failure_early_kill>; see B<proc>(5).)  If I<arg2> is B<PR_MCE_KILL_SET>, use a thread-specific memory corruption kill policy.  In this case, I<arg3> defines whether the policy is I<early kill> (B<PR_MCE_KILL_EARLY>), I<late kill> (B<PR_MCE_KILL_LATE>), or the system-wide default (B<PR_MCE_KILL_DEFAULT>).  Early kill means that the thread receives a B<SIGBUS> signal as soon as hardware memory corruption is detected inside its address space.  In late kill mode, the process is killed only when it accesses a corrupted page.  See B<sigaction>(2)  for more information on the B<SIGBUS> signal.  The policy is inherited by children.  The remaining unused B<prctl>()  arguments must be zero for future compatibility.
fr: Définir la politique de suppression de mémoire corrompue de la machine pour le thread actuel. Si I<arg2> vaut B<PR_MCE_KILL_CLEAR>, effacer la politique de suppression de mémoire corrompue et utiliser la valeur par défaut du système (qui est définie dans I</proc/sys/vm/memory_failure_early_kill>, consultez B<proc>(5)). Si I<arg2> vaut B<PR_MCE_KILL_SET>, utiliser une politique de suppression de mémoire corrompue spécifique au thread. Dans ce cas, I<arg3> définit si la politique est immédiate (I<early kill> avec B<PR_MCE_KILL_EARLY>), différée (I<late kill> avec B<PR_MCE_KILL_LATE>), ou la valeur par défaut du système (B<PR_MCE_KILL_DEFAULT>). Une suppression immédiate signifie que le thread reçoit un signal B<SIGBUS> dès que la corruption mémoire matérielle est détectée à l'intérieur de son espace d'adressage. En mode retardé, le processus n'est tué que lorsqu'il accède à une page corrompue. Consultez I<sigaction>(2) pour plus d'informations sur le signal B<SIGBUS>. Cette politique est héritée par les fils. Les arguments restants de B<prctl>(), non utilisés, doivent être mis à zéro pour préparer la future compatibilité.

note: type: TP
en: B<PR_MCE_KILL_GET> (since Linux 2.6.32)
fr: B<PR_MCE_KILL_GET> (depuis Linux 2.6.32)

note: type: Plain text
en: Return the current per-process machine check kill policy.  All unused B<prctl>()  arguments must be zero.
fr: Renvoyer la politique actuelle (par processus) de suppression des processus empoisonnés. Tous les arguments non utilisés de B<prctl>()  doivent être nuls.

note: type: TP
en: B<PR_SET_MM> (since Linux 3.3)
fr: B<PR_SET_MM> (depuis Linux 3.3)

note: commit 028ee4be34a09a6d48bdf30ab991ae933a7bc036 type: Plain text
en: Modify certain kernel memory map descriptor fields of the calling process.  Usually these fields are set by the kernel and dynamic loader (see B<ld.so>(8)  for more information) and a regular application should not use this feature.  However, there are cases, such as self-modifying programs, where a program might find it useful to change its own memory map.  This feature is available only if the kernel is built with the B<CONFIG_CHECKPOINT_RESTORE> option enabled.  The calling process must have the B<CAP_SYS_RESOURCE> capability.  The value in I<arg2> is one of the options below, while I<arg3> provides a new value for the option.
fr: Modifier certains champs du descripteur de projection de mémoire du noyau pour le processus appelant. D'habitude, ces champs sont déterminés par le noyau et le chargeur de liens dynamique (consultez B<ld.so>(8) pour plus d'informations) et une application normale ne devrait pas utiliser cette fonctionnalité. En revanche, dans certaines situations, telles que celle de programmes se modifiant eux-mêmes, un programme pourra trouver utile de pouvoir changer sa propre projection de mémoire. Cette fonctionnalité n'est disponible que si le noyau est construit avec l'option B<CONFIG_CHECKPOINT_RESTORE> activée. Le processus appelant doit avoir la capacité B<CAP_SYS_RESOURCE>. La valeur d'I<arg2> est l'une des options ci-dessous, alors qu'I<arg3> fournit une nouvelle valeur pour l'option.

note: type: Plain text
en: Set the address above which the program text can run.  The corresponding memory area must be readable and executable, but not writable or sharable (see B<mprotect>(2)  and B<mmap>(2)  for more information).
fr: Sélectionner l'adresse au dessus de laquelle le texte du programme peut être exécuté. La zone de mémoire correspondante doit être accessible en lecture et en exécution, mais pas en écriture et doit ne pas pouvoir être partagée (consultez B<mprotect>(2) et B<mmap>(2) pour plus d'informations).

note: type: Plain text
en: Set the address below which the program text can run.  The corresponding memory area must be readable and executable, but not writable or sharable.
fr: Sélectionner l'adresse en dessous de laquelle le texte du programme peut être exécuté. La zone de mémoire correspondante doit être accessible en lecture et en exécution, mais pas en écriture et doit ne pas pouvoir être partagée.

note: type: Plain text
en: Set the address above which initialized and uninitialized (bss) data are placed.  The corresponding memory area must be readable and writable, but not executable or sharable.
fr: Sélectionner l'adresse au dessus de laquelle les données initialisées et non initialisées (bss) sont placées. La zone de mémoire correspondante doit être accessible en lecture et en écriture, mais pas en exécution et doit ne pas pouvoir être partagée.

note: type: Plain text
en: Set the address below which initialized and uninitialized (bss) data are placed.  The corresponding memory area must be readable and writable, but not executable or sharable.
fr: Sélectionner l'adresse en dessous de laquelle les données initialisées et non initialisées (bss) sont placées. La zone de mémoire correspondante doit être accessible en lecture et en écriture, mais pas en exécution et doit ne pas pouvoir être partagée.

note: type: Plain text
en: Set the start address of the stack.  The corresponding memory area must be readable and writable.
fr: Sélectionner l'adresse du début de la pile. La région de mémoire correspondante doit être accessible en lecture et en écriture.

note: type: Plain text
en: Set the address above which the program heap can be expanded with B<brk>(2)  call.  The address must be greater than the ending address of the current program data segment.  In addition, the combined size of the resulting heap and the size of the data segment can't exceed the B<RLIMIT_DATA> resource limit (see B<setrlimit>(2)).
fr: Sélectionner l'adresse au dessus de laquelle le tas du programme peut être étendu avec l'appel B<brk>(2). L'adresse doit être au dessus de l'adresse terminant le segment de données actuel du programme. De plus, la taille combinée du tas obtenu et la taille du segment de données ne peut dépasser la limite de ressource B<RLIMIT_DATA> (consultez B<setrlimit>(2)).

note: type: Plain text
en: Set the current B<brk>(2)  value.  The requirements for the address are the same as for the B<PR_SET_MM_START_BRK> option.
fr: Sélectionnez la valeur actuelle de B<brk>(2). Les conditions pour l'adresse sont les mêmes que pour l'option B<PR_SET_MM_START_BRK>.

note: commit fe8c7f5cbf91124987106faa3bdf0c8b955c4cf7 type: Plain text
en: The following options are available since Linux 3.5.
fr: Les options suivantes sont disponibles depuis Linux 3.5.

note: type: Plain text
en: Set the address above which the program command line is placed.
fr: Sélectionner l'adresse au dessus de laquelle la ligne de commande du programme est placée.

note: type: Plain text
en: Set the address below which the program command line is placed.
fr: Sélectionner l'adresse en dessous de laquelle la ligne de commande du programme est placée.

note: type: Plain text
en: Set the address above which the program environment is placed.
fr: Sélectionner l'adresse au dessus de laquelle l'environnement du programme est placé.

note: type: Plain text
en: Set the address below which the program environment is placed.
fr: Sélectionner l'adresse en dessous de laquelle l'environnement du programme est placé.

note: type: Plain text
en: The address passed with B<PR_SET_MM_ARG_START>, B<PR_SET_MM_ARG_END>, B<PR_SET_MM_ENV_START>, and B<PR_SET_MM_ENV_END> should belong to a process stack area.  Thus, the corresponding memory area must be readable, writable, and (depending on the kernel configuration) have the B<MAP_GROWSDOWN> attribute set (see B<mmap>(2)).
fr: L'adresse transmise au moyen de  B<PR_SET_MM_ARG_START>, B<PR_SET_MM_ARG_END>, B<PR_SET_MM_ENV_START>, et de B<PR_SET_MM_ENV_END> doit appartenir à l'espace mémoire d'une pile de processus. Par conséquent, l'espace mémoire correspondant doit être accessible en lecture, en écriture et (selon la configuration du noyau) disposer de l'attribut B<MAP_GROWSDOWN> défini (consultez B<mmap>(2)).

note: type: Plain text
en: Set a new auxiliary vector.  The I<arg3> argument should provide the address of the vector.  The I<arg4> is the size of the vector.
fr: Sélectionner le nouveau vecteur auxiliaire. Le paramètre I<arg3> doit fournir l'adresse du vecteur. Le paramètre I<arg4> est la taille du vecteur.

note: commit b32dfe377102ce668775f8b6b1461f7ad428f8b6 type: Plain text
en: Supersede the I</proc/pid/exe> symbolic link with a new one pointing to a new executable file identified by the file descriptor provided in I<arg3> argument.  The file descriptor should be obtained with a regular B<open>(2)  call.
fr: Remplace le lien symbolique I</proc/pid/exe> par un nouveau lien pointant vers un nouveau fichier exécutable identifié par le descripteur de fichier fourni via le paramètre I<arg3>. Le descripteur de fichier peut être obtenu au moyen d'un appel à B<open>(2).

note: type: Plain text
en: To change the symbolic link, one needs to unmap all existing executable memory areas, including those created by the kernel itself (for example the kernel usually creates at least one executable memory area for the ELF I<.text> section).
fr: Pour changer le lien symbolique, il faut supprimer tous les espaces alloués en mémoire et contenant du code exécutable, y compris ceux créés par le noyau (par example, le noyau crée en général au moins un espace mémoire d'exécutable pour la section ELF I<.text>).

note: type: Plain text
en: The second limitation is that such transitions can be done only once in a process life time.  Any further attempts will be rejected.  This should help system administrators monitor unusual symbolic-link transitions over all processes running on a system.
fr: La seconde restriction est que de tels changements ne peuvent être réalisés qu'une fois dans la vie d'un processus. Au delà, tout tentative sera refusée. Cela peut aider les administrateurs système à repérer des transitions de liens symboliques anormales parmi l'ensemble de processus en cours d'exécution dans le système.

note: type: Plain text
en: On success, B<PR_GET_DUMPABLE>, B<PR_GET_KEEPCAPS>, B<PR_GET_NO_NEW_PRIVS>, B<PR_GET_THP_DISABLE>, B<PR_CAPBSET_READ>, B<PR_GET_TIMING>, B<PR_GET_TIMERSLACK>, B<PR_GET_SECUREBITS>, B<PR_MCE_KILL_GET>, and (if it returns)  B<PR_GET_SECCOMP> return the nonnegative values described above.  All other I<option> values return 0 on success.  On error, -1 is returned, and I<errno> is set appropriately.
fr: En cas de réussite, B<PR_GET_DUMPABLE>, B<PR_GET_KEEPCAPS>, B<PR_GET_NO_NEW_PRIVS>, B<PR_GET_THP_DISABLE>, B<PR_CAPBSET_READ>, B<PR_GET_TIMING>, B<PR_GET_TIMERSLACK>, B<PR_GET_SECUREBITS>, B<PR_MCE_KILL_GET> et (si elle rend la main) B<PR_GET_SECCOMP> renvoient les valeurs positives décrites ci-dessus. Toute autre valeur d'I<option> renvoie 0 en cas de réussite. En cas d'échec, -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: I<arg2> is an invalid address.
fr: I<arg2> est une adresse non valable.

note: type: Plain text
en: The value of I<option> is not recognized.
fr: La valeur de I<option> n'est pas reconnue.

note: type: Plain text
en: I<option> is B<PR_MCE_KILL> or B<PR_MCE_KILL_GET> or B<PR_SET_MM>, and unused B<prctl>()  arguments were not specified as zero.
fr: I<option> vaut B<PR_MCE_KILL>, B<PR_MCE_KILL_GET> ou B<PR_SET_MM>, et au moins un des paramètres non utilisés de B<prctl>()  n'est pas nul.

note: type: Plain text
en: I<arg2> is not valid value for this I<option>.
fr: I<arg2> n'est pas une valeur valable pour cette I<option>.

note: type: Plain text
en: I<option> is B<PR_SET_SECCOMP> or B<PR_GET_SECCOMP>, and the kernel was not configured with B<CONFIG_SECCOMP>.
fr: I<option> vaut B<PR_SET_SECCOMP> ou B<PR_GET_SECCOMP> et le noyau n'a pas été configuré avec B<CONFIG_SECCOMP>.

note: type: Plain text
en: I<option> is B<PR_SET_MM>, and one of the following is true
fr: I<option> vaut B<PR_SET_MM>, et l'une des assertions suivantes est vraie

note: type: Plain text
en: I<arg4> or I<arg5> is nonzero;
fr: I<arg4> ou I<arg5> est non nul ;

note: type: Plain text
en: I<arg3> is greater than B<TASK_SIZE> (the limit on the size of the user address space for this architecture);
fr: I<arg3> est strictement plus grand que B<TASK_SIZE> (la limite sur la taille de l'espace d'adressage utilisateur pour cette architecture) ;

note: type: Plain text
en: I<arg2> is B<PR_SET_MM_START_CODE>, B<PR_SET_MM_END_CODE>, B<PR_SET_MM_START_DATA>, B<PR_SET_MM_END_DATA>, or B<PR_SET_MM_START_STACK>, and the permissions of the corresponding memory area are not as required;
fr: I<arg2> vaut B<PR_SET_MM_START_CODE>, B<PR_SET_MM_END_CODE>, B<PR_SET_MM_START_DATA>, B<PR_SET_MM_END_DATA> ou B<PR_SET_MM_START_STACK>, et les permissions pour la zone de mémoire correspondante ne satisfont pas les conditions requises ;

note: type: Plain text
en: I<arg2> is B<PR_SET_MM_START_BRK> or B<PR_SET_MM_BRK>, and I<arg3> is less than or equal to the end of the data segment or specifies a value that would cause the B<RLIMIT_DATA> resource limit to be exceeded.
fr: I<arg2> vaut B<PR_SET_MM_START_BRK> ou B<PR_SET_MM_BRK>, et I<arg3> est inférieur ou égal à la fin du segment de données, ou indique une valeur qui causerait le dépassement de la limite de ressource B<RLIMIT_DATA>.

note: type: Plain text
en: I<option> is B<PR_SET_PTRACER> and I<arg2> is not 0, B<PR_SET_PTRACER_ANY>, or the PID of an existing process.
fr: I<option> vaut B<PR_SET_PTRACER> et I<arg2> ne vaut ni 0, ni B<PR_SET_PTRACER_ANY>, ni le PID d'un processus existant.

note: type: Plain text
en: I<option> is B<PR_SET_PDEATHSIG> and I<arg2> is not a valid signal number.
fr: I<option> vaut B<PR_SET_PDEATHSIG> et I<arg2> n'est pas un numéro de signal valide.

note: type: Plain text
en: I<option> is B<PR_SET_DUMPABLE> and I<arg2> is neither B<SUID_DUMP_DISABLE> nor B<SUID_DUMP_USER>.
fr: I<option> vaut B<PR_SET_DUMPABLE> et I<arg2> ne vaut ni B<SUID_DUMP_DISABLE>, ni B<SUID_DUMP_USER>.

note: type: Plain text
en: I<option> is B<PR_SET_TIMING> and I<arg2> is not B<PR_TIMING_STATISTICAL>.
fr: I<option> vaut B<PR_SET_TIMING> et I<arg2> n'a pas la valeur B<PR_TIMING_STATISTICAL>.

note: type: Plain text
en: I<option> is B<PR_SET_NO_NEW_PRIVS> and I<arg2> is not equal to 1 or I<arg3>, I<arg4>, or I<arg5> is nonzero.
fr: I<option> vaut B<PR_SET_NO_NEW_PRIVS> et I<arg2> ne vaut pas 1, ouI<arg3>, I<arg4> ou I<arg5> est non nul.

note: type: Plain text
en: I<option> is B<PR_GET_NO_NEW_PRIVS> and I<arg2>, I<arg3>, I<arg4>, or I<arg5> is nonzero.
fr: I<option> vaut B<PR_GET_NO_NEW_PRIVS> et I<arg2>, I<arg3>, I<arg4> ou I<arg5> est non nul.

note: type: Plain text
en: I<option> is PR_SET_THP_DISABLE and I<arg3>, I<arg4>, or I<arg5> is nonzero.
fr: I<option> vaut B<PR_SET_THP_DISABLE> et I<arg3>, I<arg4> ou I<arg5> est non nul.

note: type: Plain text
en: I<option> is PR_GET_THP_DISABLE and I<arg2>, I<arg3>, I<arg4>, or I<arg5> is nonzero.
fr: I<option> vaut B<PR_GET_THP_DISABLE> et I<arg2>, I<arg3>, I<arg4> ou I<arg5> estnon nul.

note: type: Plain text
en: I<option> is B<PR_SET_SECUREBITS>, and the caller does not have the B<CAP_SETPCAP> capability, or tried to unset a "locked" flag, or tried to set a flag whose corresponding locked flag was set (see B<capabilities>(7)).
fr: I<option> vaut B<PR_SET_SECUREBITS> et l'appelant n'a pas la capacité B<CAP_SETPCAP>, a essayé d'enlever un attribut de « verrouillage » ou a essayé de positionner un attribut pour lequel l'attribut de verrouillage était positionné (consultez B<capabilities>(7)).

note: type: Plain text
en: I<option> is B<PR_SET_KEEPCAPS>, and the callers's B<SECURE_KEEP_CAPS_LOCKED> flag is set (see B<capabilities>(7)).
fr: I<option> vaut B<PR_SET_KEEPCAPS> et l'attribut B<SECURE_KEEP_CAPS_LOCKED> de l'appelant est positionné (consultez B<capabilities>(7)).

note: type: Plain text
en: I<option> is B<PR_CAPBSET_DROP>, and the caller does not have the B<CAP_SETPCAP> capability.
fr: I<option> vaut B<PR_CAPBSET_DROP> et l'appelant n'a pas la capacité B<CAP_SETPCAP>.

note: type: Plain text
en: I<option> is B<PR_SET_MM>, and the caller does not have the B<CAP_SYS_RESOURCE> capability.
fr: I<option> vaut B<PR_SET_MM> et l'appelant n'a pas la capacité B<CAP_SYS_RESOURCE>.

note: type: Plain text
en: I<option> is B<PR_SET_MM>, and I<arg3> is B<PR_SET_MM_EXE_FILE>, the file is not executable.
fr: I<option> vaut B<PR_SET_MM>, et I<arg3> vaut B<PR_SET_MM_EXE_FILE>, le fichier n'est pas exécutable.

note: type: Plain text
en: I<option> is B<PR_SET_MM>, I<arg3> is B<PR_SET_MM_EXE_FILE>, and this the second attempt to change the I</proc/pid/exe> symbolic link, which is prohibited.
fr: I<option> vaut B<PR_SET_MM>, I<arg3> vaut B<PR_SET_MM_EXE_FILE>, et il s'agit de la seconde tentative de modification du lien symbolique I</proc/pid/exe>, ce qui n'est pas autorisé.

note: The following can't actually happen, because prctl() in seccomp mode will cause SIGKILL. .TP .B EPERM .I option is .BR PR_SET_SECCOMP , and secure computing mode is already 1. type: Plain text
en: I<option> is B<PR_SET_MM>, I<arg3> is B<PR_SET_MM_EXE_FILE>, and the file descriptor passed in I<arg4> is not valid.
fr: I<option> vaut B<PR_SET_MM>, I<arg3> vaut B<PR_SET_MM_EXE_FILE>, et le descripteur de fichier passé dans le paramètre I<arg4> n'est pas valide.

note: The library interface was added in glibc 2.0.6 type: Plain text
en: The B<prctl>()  system call was introduced in Linux 2.1.57.
fr: L'appel système B<prctl>() a été introduit dans Linux 2.1.57.

note: type: Plain text
en: This call is Linux-specific.  IRIX has a B<prctl>()  system call (also introduced in Linux 2.1.44 as irix_prctl on the MIPS architecture), with prototype
fr: Cet appel système est spécifique à Linux. IRIX dispose d'un appel système B<prctl>() (également introduit dans Linux 2.1.44 sur l'architecture MIPS sous le nom irix_prctl), dont le prototype est

note: type: Plain text
en: and options to get the maximum number of processes per user, get the maximum number of processors the calling process can use, find out whether a specified process is currently blocked, get or set the maximum stack size, and so on.
fr: et les options permettent de d'obtenir le nombre maximal de processus par utilisateur, le nombre maximal de processeurs utilisables par un processus, vérifier si un processus est bloqué, lire ou définir la taille des piles, etc.

note: type: Plain text
en: profil - execution time profile
fr: profil - Suivi du temps d'exécution

note: type: Plain text
en: B<int profil(unsigned short *>I<buf>B<, size_t >I<bufsiz>B<,>
    B<           size_t >I<offset>B<, unsigned int >I<scale>B<);>
fr: B<int profil(unsigned short *>I<tampon>B<, size_t >I<taille_tampon>B<,>
    B<           size_t >I<offset>B<, unsigned int >I<echelle>B<);>

note: type: Plain text
en: B<profil>(): _BSD_SOURCE || (_XOPEN_SOURCE && _XOPEN_SOURCE\ E<lt>\ 500)
fr: B<profil>() : _BSD_SOURCE || (_XOPEN_SOURCE && _XOPEN_SOURCE\ E<lt>\ 500)

note: type: Plain text
en: This routine provides a means to find out in what areas your program spends most of its time.  The argument I<buf> points to I<bufsiz> bytes of core.  Every virtual 10 milliseconds, the user's program counter (PC)  is examined: I<offset> is subtracted and the result is multiplied by I<scale> and divided by 65536.  If the resulting value is less than I<bufsiz>, then the corresponding entry in I<buf> is incremented.  If I<buf> is NULL, profiling is disabled.
fr: Cette routine fournit un moyen de détecter les zones où votre programme passe l'essentiel de son temps. L'argument I<tampon> pointe sur I<taille_tampon> octets de mémoire. Toutes les 10 millisecondes virtuelles, le compteur de programme (PC) est examiné. On lui soustrait la valeur I<offset> et le résultat est multiplié par I<echelle> puis divisé par 65536. Si la valeur résultant est inférieure à I<taille_tampon>, l'élément correspondant du I<tampon> est incrémenté. Si I<tampon> est NULL, Le suivi est désactivé.

note: type: Plain text
en: Zero is always returned.
fr: Cette routine renvoie toujours zéro.

note: type: Plain text
en: Similar to a call in SVr4 (but not POSIX.1-2001).
fr: Similaire à un appel de SVr4 (mais pas POSIX.1-2001).

note: type: Plain text
en: B<profil>()  cannot be used on a program that also uses B<ITIMER_PROF> interval timers (see B<setitimer>(2)).
fr: B<profil>() ne doit pas être invoqué dans les programmes qui utilisent des horloges internes B<ITIMER_PROF> (consultez B<setitimer>(2)).

note: type: Plain text
en: True kernel profiling provides more accurate results.  Libc 4.4 contained a kernel patch providing a system call profil.
fr: Un vrai suivi fourni par le noyau donnerait des résultats plus précis. La bibliothèque libc 4.4 contenait un patch pour implémenter un appel système profil dans le noyau.

note: type: TH
en: 2010-10-06
fr: 6 octobre 2010

note: type: Plain text
en: psignal, psiginfo - print signal message
fr: psignal, psiginfo - Afficher le libellé d'un signal

note: type: Plain text
en: B<psignal>(): _SVID_SOURCE || _BSD_SOURCE
fr: B<psignal>() : _SVID_SOURCE || _BSD_SOURCE

note: type: Plain text
en: B<psiginfo>(): _XOPEN_SOURCE\ E<gt>=\ 700 || _POSIX_C_SOURCE\ E<gt>=\ 200809L
fr: B<psiginfo>()\ : _XOPEN_SOURCE\ E<gt>=\ 700 || _POSIX_C_SOURCE\ E<gt>=\ 200809L

note: type: Plain text
en: I<sys_siglist>: _BSD_SOURCE
fr: I<sys_siglist> : _BSD_SOURCE

note: type: Plain text
en: The B<psignal>()  function displays a message on I<stderr> consisting of the string I<s>, a colon, a space, a string describing the signal number I<sig>, and a trailing newline.  If the string I<s> is NULL or empty, the colon and space are omitted.  If I<sig> is invalid, the message displayed will indicate an unknown signal.
fr: La fonction B<psignal>() affiche un message sur I<stderr> constitué de la chaîne I<s>, d'un deux-points, d'un espace, et d'un libellé décrivant le signal numéro I<sig>. Si la chaîne I<s> vaut NULL ou est vide, le deux-points et l'espace ne sont pas affichés. Si I<sig> est invalide, le message affiché indiquera un signal inconnu.

note: type: Plain text
en: The B<psiginfo>()  function is like B<psignal>(), except that it displays information about the signal described by I<pinfo>, which should point to a valid I<siginfo_t> structure.  As well as the signal description, B<psiginfo>()  displays information about the origin of the signal, and other information relevant to the signal (e.g., the relevant memory address for hardware-generated signals, the child process ID for B<SIGCHLD>, and the user ID and process ID of the sender, for signals set using B<kill>(2)  or B<sigqueue>(3)).
fr: La fonction B<psiginfo>() agit comme B<psignal>(), sauf qu'elle affiche les informations sur le signal décrit par I<pinfo>, qui devrait pointer vers une structure I<siginfo_t> valide. En plus de la description du signal, B<psiginfo>() affiche des informations sur l'origine du signal, et toute autre information relative au signal (comme par exemple, l'adresse mémoire pertinente pour les signaux générés par le matériel, l'identifiant du processus fils pour B<SIGCHLD>, et, pour les signaux activés par B<kill>(2) ou B<sigqueue>(3), l'identifiant du processus et de l'utilisateur émetteur du signal).

note: type: Plain text
en: The array I<sys_siglist> holds the signal description strings indexed by signal number.
fr: La table I<sys_siglist> contient les libellés des messages, indexés par le numéro de signal.

note: type: Plain text
en: The B<psignal>()  and B<psiginfo>()  functions return no value.
fr: Les fonctions B<psignal>() et B<psiginfo>() ne renvoient aucune valeur.

note: type: Plain text
en: The B<psiginfo>()  function was added to glibc in version 2.10.
fr: La fonction B<psiginfo>() a été ajoutée à la glibc dans la version 2.10.

note: type: Plain text
en: POSIX.1-2008, 4.3BSD.
fr: POSIX.1-2008, BSD 4.3.

note: type: Plain text
en: In glibc versions up to 2.12, B<psiginfo>()  had the following bugs:
fr: Dans les versions de la glibc antérieures à 2.12, B<psiginfo>() avait les bogues suivants :

note: FIXME http://sourceware.org/bugzilla/show_bug.cgi?id=12107 Reportedly now fixed; check glibc 2.13 type: Plain text
en: In some circumstances, a trailing newline is not printed.
fr: Dans certaines circonstances, un saut de ligne terminal n'est pas affiché.

note: FIXME http://sourceware.org/bugzilla/show_bug.cgi?id=12108 Reportedly now fixed; check glibc 2.13 type: Plain text
en: Additional details are not displayed for real-time signals.
fr: Les détails supplémentaires ne sont pas affichés pour les signaux temps-réel.

note: type: TH
en: 2014-03-10
fr: 10 mars 2014

note: type: Plain text
en: raise - send a signal to the caller
fr: raise - Envoyer un signal à l'appelant

note: type: Plain text
en: The B<raise>()  function sends a signal to the calling process or thread.  In a single-threaded program it is equivalent to
fr: La fonction B<raise>() envoie un signal au processus ou au thread appelant. Dans un programme monothreadé, elle est équivalente à :

note: type: Plain text
en: In a multithreaded program it is equivalent to
fr: Dans un programme multithreadé, elle est équivalente à :

note: type: Plain text
en: If the signal causes a handler to be called, B<raise>()  will return only after the signal handler has returned.
fr: Si le signal provoque l'appel d'un gestionnaire, B<raise>() ne reviendra qu'après le retour du gestionnaire de signal.

note: type: Plain text
en: B<raise>()  returns 0 on success, and nonzero for failure.
fr: B<raise>() renvoie 0 si elle réussit, et une valeur non nulle en cas d'échec.

note: type: Plain text
en: The B<raise>()  function is thread-safe.
fr: La fonction B<raise>() est sûre dans un contexte multithread.

note: 2.3.2 used the obsolete tkill(), if available. type: Plain text
en: Since version 2.3.3, glibc implements B<raise>()  by calling B<tgkill>(2), if the kernel supports that system call.  Older glibc versions implemented B<raise>()  using B<kill>(2).
fr: Depuis la version 2.3.3, la glibc implémente B<raise>() en appelant B<tgkill>(2) si le noyau prend en charge cet appel système. Les versions antérieures de la glibc implémentaient B<raise>() en utilisant B<kill>(2).

note: type: TH
en: 2014-02-11
fr: 11 février 2014

note: type: Plain text
en: restart_syscall - restart a system call after interruption by a stop signal
fr: restart_syscall - redémarre un appel système après qu'il a été interrompu par un signal d'arrêt.

note: type: Plain text
en: I<Note>: There is no glibc wrapper for this system call; see NOTES.
fr: La glibc ne fournit pas de fonction autour de cet appel système\ ; consultez les NOTES.

note: type: Plain text
en: The B<restart_syscall>()  system call is used to restart certain system calls after a process that was stopped by a signal (e.g., B<SIGSTOP> or B<SIGTSTP>)  is later resumed after receiving a B<SIGCONT> signal.  This system call is designed only for internal use by the kernel.
fr: L'appel système B<restart_syscall>() est utilisé pour redémarrer certains appels système lorsqu'un processus qui a été arrêté par un signal (par exemple B<SIGSTOP> ou B<SIGTSTP>) est ensuite relancé par un signal B<SIGCONT>. Cet appel système est exclusivement destiné à un usage interne par le noyau.

note: These system calls correspond to the special internal errno value ERESTART_RESTARTBLOCK. Each of the system calls has a "restart" helper function that is invoked by restart_syscall(). type: Plain text
en: B<restart_syscall>()  is used for restarting only those system calls that, when restarted, should adjust their time-related parameters\(emnamely B<poll>(2)  (since Linux 2.6.24), B<nanosleep>(2)  (since Linux 2.6), B<clock_nanosleep>(2)  (since Linux 2.6), and B<futex>(2), when employed with the B<FUTEX_WAIT> (since Linux 2.6.22)  and B<FUTEX_WAIT_BITSET> (since Linux 2.6.31)  operations.  B<restart_syscall>()  restarts the interrupted system call with a time argument that is suitably adjusted to account for the time that has already elapsed (including the time where the process was stopped by a signal).  Without the B<restart_syscall>()  mechanism, restarting these system calls would not correctly deduce the already elapsed time when the process continued execution.
fr: B<restart_syscall>() est utilisé pour redémarrer uniquement ceux des appels systèmes qui, lorsqu'ils sont redémarrés, doivent ajuster leurs paramètres temporels, \(emc'est-à-dire B<poll>(2) (à partir de Linux 2.6.24), B<nanosleep>(2) (à partir de Linux 2.6), B<clock_nanosleep>(2) (à partir de Linux 2.6) et B<futex>(2), lorsqu'ils sont utilisés avec les opérations B<FUTEX_WAIT> (à partir de 2.6.22)  et B<FUTEX_WAIT_BITSET> (à partir de Linux 2.6.31). B<restart_syscall>() redémarre l'appel système interrompu avec un paramètre de temps ajusté pour prendre en compte le temps écoulé (comprenant le temps nécessaire à l'arrêt du processus par le signal). Sans le mécanisme B<restart_syscall>(), l'estimation du temps écoulé ne pourrait être correctement effectuée lors du redémarrage de ces appels système.

note: type: Plain text
en: The return value of B<restart_syscall>()  is the return value of whatever system call is being restarted.
fr: La valeur renvoyée par B<restart_syscall>() est celle renvoyée par l'appel système qui est redémarré.

note: type: Plain text
en: I<errno> is set as per the errors for whatever system call is being restarted by B<restart_syscall>().
fr: I<errno> est défini selon l'erreur avec la même valeur que celle définie par l'appel système qui est redémarré par B<restart_syscall>().

note: type: Plain text
en: The B<restart_syscall>()  system call is present since Linux 2.6.
fr: L'appel système B<restart_syscall>() existe depuis Linux 2.6.

note: type: Plain text
en: This system call is Linux-specific.
fr: Cet appel système est spécifique à Linux.

note: type: Plain text
en: There is no glibc wrapper for this system call, because it is intended for use only by the kernel and should never be called by applications.
fr: Il n'y a pas d'enrobage glibc pour cet appel système puisqu'il ne doit être appelé que par le noyau et jamais par une application.

note: FIXME There is one oddness in the implementation though, with respect to nanosleep() (and probably also clock_nanosleep()). The scenario is as follows: 1. Start a nanosleep() for (say) 30 seconds, 2. Stop the process with (say) SIGTSTP (^Z). 3. Resume the process with SIGCONT, 4. Upon return, the 'r
en: From user space, the operation of B<restart_syscall>(2)  is largely invisible: to the process that made the system call that is restarted, it appears as though that system call executed and returned in the usual fashion.
fr: Depuis l'espace utilisateur, l'exécution de B<restart_syscall>(2) est pratiquement transparente : du point de vue du processus auteur de l'appel système qui est redémarré, tout se passe comme si l'appel système s'exécutait et se relançait de façon habituelle.

note: type: TH
en: 2012-07-13
fr: 13 juillet 2012

note: type: Plain text
en: rt_sigqueueinfo, rt_tgsigqueueinfo - queue a signal and data
fr: rt_sigqueueinfo, rt_tgsigqueueinfo - Mettre un signal et des données dans la file d'attente  d'un processus

note: type: Plain text
en: I<Note>: There are no glibc wrappers for these system calls; see NOTES.
fr: La glibc ne fournit pas de fonction autour de ces appels système\ ; consultez les NOTES.

note: type: Plain text
en: The B<rt_sigqueueinfo>()  and B<rt_tgsigqueueinfo>()  system calls are the low-level interfaces used to send a signal plus data to a process or thread.  The receiver of the signal can obtain the accompanying data by establishing a signal handler with the B<sigaction>(2)  B<SA_SIGINFO> flag.
fr: Les appels système B<rt_sigqueueinfo>() et B<rt_tgsigqueueinfo>() sont les interfaces de bas niveau utilisées pour envoyer un signal accompagné de données à un processus ou à un thread. Le récepteur du signal peut obtenir les données associées en établissant un gestionnaire de signal à l'aide de l'attribut B<SA_SIGINFO> de B<sigaction>(2).

note: type: Plain text
en: These system calls are not intended for direct application use; they are provided to allow the implementation of B<sigqueue>(3)  and B<pthread_sigqueue>(3).
fr: Ces appels système ne sont pas destinés à être utilisés directement par une application ; ils sont fournis pour permettre l'implémentation de B<sigqueue>(3) et B<pthread_sigqueue>(3).

note: type: Plain text
en: The B<rt_sigqueueinfo>()  system call sends the signal I<sig> to the thread group with the ID I<tgid>.  (The term "thread group" is synonymous with "process", and I<tid> corresponds to the traditional UNIX process ID.)  The signal will be delivered to an arbitrary member of the thread group (i.e., one of the threads that is not currently blocking the signal).
fr: L'appel système B<rt_sigqueueinfo>() envoie le signal I<sig> au groupe de threads dont l'identifiant est I<tgid>. (Le terme « groupe de threads » est synonyme de « processus », et I<tid> correspond à l'identifiant de processus UNIX traditionnel.) Le signal sera délivré à un membre arbitraire de ce groupe de threads (c.-à-d. un des threads qui n'est pas en train de bloquer le signal).

note: type: Plain text
en: The I<uinfo> argument specifies the data to accompany the signal.  This argument is a pointer to a structure of type I<siginfo_t>, described in B<sigaction>(2)  (and defined by including I<E<lt>sigaction.hE<gt>>).  The caller should set the following fields in this structure:
fr: Le paramètre I<uinfo> spécifie les données devant accompagnant le signal. Ce paramètre est un pointeur vers une structure de type I<siginfo_t>, décrite dans B<sigaction>(2) (et définie en incluant I<E<lt>sigaction.hE<gt>>). L'appelant doit positionner dans cette structure les champs suivants :

note: tkill(2) or type: Plain text
en: This must be one of the B<SI_*> codes in the Linux kernel source file I<include/asm-generic/siginfo.h>, with the restriction that the code must be negative (i.e., cannot be B<SI_USER>, which is used by the kernel to indicate a signal sent by B<kill>(2))  and cannot (since Linux 2.6.39) be B<SI_TKILL> (which is used by the kernel to indicate a signal sent using B<tgkill>(2)).
fr: Ceci doit être un des codes B<SI_*> du fichier source du noyau Linux I<include/asm-generic/siginfo.h>, avec la restriction que le code doit être strictement négatif (c.-à-d. qu'il ne peut être égal à B<SI_USER>, qui est utilisé par le noyau pour indiquer un signal envoyé par B<kill>(2)) et ne peut pas (depuis Linux 2.6.39) être égal à B<SI_TKILL> (qui est utilisé par le noyau pour indiqué un signal envoyé en utilisant B<tgkill>(2)).

note: type: Plain text
en: This should be set to a process ID, typically the process ID of the sender.
fr: Ceci doit être égal à l'identifiant d'un processus, typiquement celui du processus émetteur.

note: type: Plain text
en: This should be set to a user ID, typically the real user ID of the sender.
fr: Ceci doit être égal à l'identifiant d'un utilisateur, typiquement l'identifiant utilisateur réel de l'émetteur.

note: type: Plain text
en: This field contains the user data to accompany the signal.  For more information, see the description of the last (I<union sigval>)  argument of B<sigqueue>(3).
fr: Ce champ contien les données utilisateur pour accompagner le signal. Pour plus d'informations, consultez la description du dernier argument (I<union_sigval>) de B<sigqueue>(3).

note: type: Plain text
en: Internally, the kernel sets the I<si_signo> field to the value specified in I<sig>, so that the receiver of the signal can also obtain the signal number via that field.
fr: De manière interne, le noyau positionne le champ I<si_signo> à la valeur indiquée dans I<sig>, de sorte que le récepteur du signal puisse aussi obtenir le numéro du signal via ce champ.

note: type: Plain text
en: The B<rt_tgsigqueueinfo>()  system call is like B<rt_sigqueueinfo>(), but sends the signal and data to the single thread specified by the combination of I<tgid>, a thread group ID, and I<tid>, a thread in that thread group.
fr: L'appel système B<rt_tgsigqueueinfo>() fonctionne comme B<rt_sigqueueinfo>(), mais n'envoie le signal et les données qu'à l'unique thread indiqué par la combinaison de I<tgid>, un identifiant de groupe de threads, et I<tid>, un thread dans ce groupe.

note: type: Plain text
en: On success, these system calls return 0.  On error, they return -1 and I<errno> is set to indicate the error.
fr: En cas du succès, ces appels système renvoient zéro. Dans le cas contraire, ils renvoient -1 et remplissent I<errno> avec le code d'erreur.

note: type: Plain text
en: The limit of signals which may be queued has been reached.  (See B<signal>(7)  for further information.)
fr: La limite du nombre de signaux en file a été atteinte (consultez B<signal>(7) pour plus d'informations).

note: type: Plain text
en: I<sig>, I<tgid>, or I<tid> was invalid.
fr: I<sig>, I<tgid>, or I<tid> n'est pas valable.

note: type: Plain text
en: The caller does not have permission to send the signal to the target.  For the required permissions, see B<kill>(2).  Or: I<uinfo-E<gt>si_code> is invalid.
fr: Le processus n'a pas la permission d'envoyer un signal au processus visé. Pour les permissions nécessaires, consultez B<kill>(2). Ou bien I<uinfo-E<gt>si_code> n'est pas valable.

note: type: Plain text
en: B<rt_sigqueueinfo>(): No thread group matching I<tgid> was found.
fr: B<rt_sigqueueinfo>() : aucun groupe de threads correspondant à I<tgid> n'a été trouvé.

note: type: Plain text
en: B<rt_tgsigqueinfo>(): No thread matching I<tgid> and I<tid> was found.
fr: B<rt_tgsigqueinfo>() : aucun thread correspondant à I<tgid> et I<tid> n'a été trouvé.

note: type: Plain text
en: The B<rt_sigqueueinfo>()  system call was added to Linux in version 2.2.  The B<rt_tgsigqueueinfo>()  system call was added to Linux in version 2.6.31.
fr: L'appel système B<rt_sigqueueinfo>() a été ajouté à Linux dans la version 2.2. L'appel système B<rt_tgsigqueueinfo>() a été ajouté à Linux dans la version 2.6.31.

note: type: Plain text
en: These system calls are Linux-specific.
fr: Ces appels système sont spécifiques à Linux.

note: type: Plain text
en: Since these system calls are not intended for application use, there are no glibc wrapper functions; use B<syscall>(2)  in the unlikely case that you want to call them directly.
fr: Comme ces appels système ne sont pas destinés à être utilisés par une application, il n'existe aucune fonction d'encapsulation glibc ; utiliser B<syscall>(2) dans le cas peu probable où vous voudriez les appeler directement.

note: type: Plain text
en: As with B<kill>(2), the null signal (0) can be used to check if the specified process or thread exists.
fr: Comme pour B<kill>(2), le signal nul (0) peut être utilisé pour vérifier si le processus ou le thread indiqué existe.

note: type: TH
en: 2012-12-17
fr: 17 décembre 2012

note: type: Plain text
en: s390_runtime_instr - enable/disable s390 CPU run-time instrumentation
fr: s390_runtime_instr - Activer ou désactiver la collecte des traces de l'activité du processeur s390

note: type: Plain text
en: The B<s390_runtime_instr>()  system call starts or stops CPU run-time instrumentation for the calling thread.
fr: L'appel système B<s390_runtime_instr>() démarre ou arrête la collecte des traces de l'activité du processeur pour le thread appelant.

note: type: Plain text
en: The I<command> argument controls whether run-time instrumentation is started (B<S390_RUNTIME_INSTR_START>, 1) or stopped (B<S390_RUNTIME_INSTR_STOP>, 2) for the calling thread.
fr: L'argument I<command> décide du démarrage (B<S390_RUNTIME_INSTR_START>, 1) ou de l'arrêt  (B<S390_RUNTIME_INSTR_STOP>, 2) de la collecte des traces lors de l'exécution du thread appelant.

note: type: Plain text
en: The I<signum> argument specifies the number of a real-time signal.  The real-time signal is sent to the thread if the run-time instrumentation buffer is full or if the run-time-instrumentation-halted interrupt occurred.
fr: L'argument  I<signum> précise le nombre de signaux temps-réel. Le signal temps-réel est envoyé au thread si le tampon de collecte des traces est plein, ou si l'interruption « run-time-instrumentation-halted » est survenue.

note: type: Plain text
en: On success, B<s390_runtime_instr>()  returns 0 and enables the thread for run-time instrumentation by assigning the thread a default run-time instrumentation control block.  The caller can then read and modify the control block and start the run-time instrumentation.  On error, -1 is returned and I<errno> is set to one of the error codes listed below.
fr: S'il réussit, l'appel B<s390_runtime_instr>() renvoie la valeur 0 et active le thread pour la collecte des traces d'exécution en lui assignant un bloc de contrôle de collecte des traces par défaut. Le composant appelant peut alors accéder en lecture ou modifier le bloc de contrôle et démarrer la collecte des traces. S'il échoue, l'appel retourne -1 et I<errno> prend pour valeur l'un des codes erreur décrits plus bas.

note: type: Plain text
en: The value specified in I<command> is not a valid command or the value specified in I<signum> is not a real-time signal number.
fr: La valeur spécifiée dans  I<command> n'est pas une commande valide ou la valeur spécifiée dans  I<signum> n'est pas une valeur numérique admise pour le signal temps-réel.

note: type: Plain text
en: Allocating memory for the run-time instrumentation control block failed.
fr: L'allocation de la mémoire pour le bloc de contrôle de collecte des traces a échoué.

note: type: Plain text
en: The run-time instrumentation facility is not available.
fr: Le mécanisme des collecte des traces d'exécution n'est pas disponible.

note: type: Plain text
en: This system call is available since Linux 3.7.
fr: Cet appel système est disponible depuis Linux 3.7.

note: type: Plain text
en: This Linux-specific system call is available only on the s390 architecture.  The run-time instrumentation facility is available beginning with System z EC12.
fr: L'appel système spécifique à Linux n'est disponible que pour l'architecture s390. Le mécanisme de collecte des traces d'exécution est disponible à partir du System z EC12.

note: type: Plain text
en: Glibc does not provide a wrapper for this system call, use B<syscall>(2)  to call it.
fr: La glibc ne fournit pas de fonction autour de cet appel système\ ; utilisez B<syscall>(2) pour l'appeler.

note: type: TH
en: 2014-02-25
fr: 25 février 2014

note: type: Plain text
en: sgetmask, ssetmask - manipulation of signal mask (obsolete)
fr: sgetmask, ssetmask - Manipuler les masquages de signaux (obsolète)

note: type: Plain text
en: These system calls are obsolete.  I<Do not use them>; use B<sigprocmask>(2)  instead.
fr: Ces appels système sont obsolètes. I<Ne les utilisez pas> ; utilisez plutôt B<sigprocmask>(2).

note: type: Plain text
en: B<sgetmask>()  returns the signal mask of the calling process.
fr: B<sgetmask>() renvoie le masque de signaux du processus appelant.

note: type: Plain text
en: B<ssetmask>()  sets the signal mask of the calling process to the value given in I<newmask>.  The previous signal mask is returned.
fr: B<ssetmask>() définit le masque de signaux du processus appelant à la valeur fournie dans I<newmask>. Le masque précédent est renvoyé.

note: type: Plain text
en: The signal masks dealt with by these two system calls are plain bit masks (unlike the I<sigset_t> used by B<sigprocmask>(2)); use B<sigmask>(3)  to create and inspect these masks.
fr: Le masque de signaux utilisé pour ces deux appels système sont des masques de bits bruts (contrairement aux I<sigset_t> utilisés par B<sigprocmask>(2)) ; utilisez B<sigmask>(3) pour créer et inspecter ces masques.

note: type: Plain text
en: B<sgetmask>()  always successfully returns the signal mask.  B<ssetmask>()  always succeeds, and returns the previous signal mask.
fr: B<sgetmask>() retourne toujours avec succès le masque de signaux. B<ssetmask>() réussit toujours et renvoie le masque de signaux précédent.

note: type: Plain text
en: These system calls always succeed.
fr: Ces appels système réussissent toujours.

note: type: Plain text
en: Glibc does not provide wrappers for these obsolete system calls; in the unlikely event that you want to call them, use B<syscall>(2).
fr: La glibc ne fournit pas de fonction autour de ces appels système obsolètes\ ; dans l'éventualité où vous souhaiteriez quand même les appeler, utilisez B<syscall>(2).

note: type: Plain text
en: These system calls are unaware of signal numbers greater than 31 (i.e., real-time signals).
fr: Ces appels système ne gèrent pas les numéros de signaux supérieurs à 32 (c'est-à-dire les signaux temps-réel).

note: type: Plain text
en: These system calls do not exist on x86-64.
fr: Ces appels système n'existent pas sur x86-64.

note: type: Plain text
en: It is not possible to block B<SIGSTOP> or B<SIGKILL>.
fr: Il est impossible de bloquer un B<SIGSTOP> ou un B<SIGKILL>.

note: type: TH
en: 2013-07-30
fr: 30 juillet 2013

note: type: Plain text
en: sigaction - examine and change a signal action
fr: sigaction - Examiner et modifier l'action associée à un signal

note: type: Plain text
en: B<sigaction>(): _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE
fr: B<sigaction>() : _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE

note: type: Plain text
en: I<siginfo_t>: _POSIX_C_SOURCE E<gt>= 199309L
fr: I<siginfo_t> : _POSIX_C_SOURCE E<gt>= 199309L

note: type: Plain text
en: The B<sigaction>()  system call is used to change the action taken by a process on receipt of a specific signal.  (See B<signal>(7)  for an overview of signals.)
fr: L'appel système B<sigaction>() sert à modifier l'action effectuée par un processus à la réception d'un signal spécifique. (Consultez B<signal>(7) pour une vue d'ensemble sur les signaux)

note: type: Plain text
en: I<signum> specifies the signal and can be any valid signal except B<SIGKILL> and B<SIGSTOP>.
fr: I<signum> indique le signal concerné, à l'exception de B<SIGKILL> et B<SIGSTOP>.

note: type: Plain text
en: If I<act> is non-NULL, the new action for signal I<signum> is installed from I<act>.  If I<oldact> is non-NULL, the previous action is saved in I<oldact>.
fr: Si I<act> n'est pas NULL, la nouvelle action pour le signal I<signum> est définie par I<act>. Si I<oldact> n'est pas NULL, l'ancienne action est sauvegardée dans I<oldact>.

note: type: Plain text
en: The I<sigaction> structure is defined as something like:
fr: La structure I<sigaction> est définie par quelque chose comme\ :

note: type: Plain text
en: On some architectures a union is involved: do not assign to both I<sa_handler> and I<sa_sigaction>.
fr: Sur certaines architectures, on emploie une union. Il ne faut donc pas utiliser ou remplir simultanément I<sa_handler> et I<sa_sigaction>.

note: type: Plain text
en: The I<sa_restorer> element is obsolete and should not be used.  POSIX does not specify a I<sa_restorer> element.
fr: L'élément I<sa_restorer> est obsolète et ne devrait pas être utilisé, POSIX ne mentionne pas de membre I<sa_restorer>.

note: type: Plain text
en: I<sa_handler> specifies the action to be associated with I<signum> and may be B<SIG_DFL> for the default action, B<SIG_IGN> to ignore this signal, or a pointer to a signal handling function.  This function receives the signal number as its only argument.
fr: I<sa_handler> indique l'action affectée au signal I<signum>, et peut être B<SIG_DFL> pour l'action par défaut, B<SIG_IGN> pour ignorer le signal, ou un pointeur sur une fonction de gestion de signaux.

note: type: Plain text
en: If B<SA_SIGINFO> is specified in I<sa_flags>, then I<sa_sigaction> (instead of I<sa_handler>)  specifies the signal-handling function for I<signum>.  This function receives the signal number as its first argument, a pointer to a I<siginfo_t> as its second argument and a pointer to a I<ucontext_t> (cast to I<void\ *>) as its third argument.  (Commonly, the handler function doesn't make any use of the third argument.  See B<getcontext>(3)  for further information about I<ucontext_t>.)
fr: Si B<SA_SIGINFO> est indiqué dans I<sa_flags>, alors I<sa_sigaction> (plutôt que I<sa_handler>) pointe vers le gestionnaire de signal pour I<signum>. Cette fonction prend le numéro du signal comme premier argument, un pointeur vers un I<siginfo_t> comme second argument, et un pointeur vers un I<ucontext_t> (transtypé en I<void\ *>) comme troisième paramètre. (Généralement, le gestionnaire de signal n'utilise pas le troisième argument. Consultez B<getcontext>(3) pour plus d'informations au sujet de I<ucontext_t>.)

note: type: Plain text
en: I<sa_mask> specifies a mask of signals which should be blocked (i.e., added to the signal mask of the thread in which the signal handler is invoked)  during execution of the signal handler.  In addition, the signal which triggered the handler will be blocked, unless the B<SA_NODEFER> flag is used.
fr: I<sa_mask> spécifie un masque de signaux à bloquer (c'est-à-dire ajoutés au masque de signaux du thread dans lequel le gestionnaire est appelé) pendant l'exécution du gestionnaire. De plus le signal ayant appelé le gestionnaire est bloqué à moins que l'attribut B<SA_NODEFER> soit précisé.

note: type: Plain text
en: I<sa_flags> specifies a set of flags which modify the behavior of the signal.  It is formed by the bitwise OR of zero or more of the following:
fr: I<sa_flags> spécifie un ensemble d'attributs qui modifient le comportement du signal. Il est formé par un OU binaire «\ |\ ») entre les options suivantes\ :

note: type: Plain text
en: If I<signum> is B<SIGCHLD>, do not receive notification when child processes stop (i.e., when they receive one of B<SIGSTOP>, B<SIGTSTP>, B<SIGTTIN>, or B<SIGTTOU>)  or resume (i.e., they receive B<SIGCONT>)  (see B<wait>(2)).  This flag is meaningful only when establishing a handler for B<SIGCHLD>.
fr: Si I<signum> vaut B<SIGCHLD>, ne pas recevoir les signaux de notification d'arrêt (quand le fils reçoit un signal B<SIGSTOP>, B<SIGTSTP>, B<SIGTTIN> ou B<SIGTTOU>) ou de relance (quand il reçoit B<SIGCONT>) des processus fils. Consultez B<wait>(2). Cet attribut n'a de sens que lors de la mise en place d'un gestionnaire pour B<SIGCHLD>.

note: type: TP
en: B<SA_NOCLDWAIT> (since Linux 2.6)
fr: B<SA_NOCLDWAIT> (depuis Linux 2.6)

note: To be precise: Linux 2.5.60 -- MTK type: Plain text
en: If I<signum> is B<SIGCHLD>, do not transform children into zombies when they terminate.  See also B<waitpid>(2).  This flag is meaningful only when establishing a handler for B<SIGCHLD>, or when setting that signal's disposition to B<SIG_DFL>.
fr: Si I<signum> vaut B<SIGCHLD>, ne pas transformer les fils en zombies lorsqu'ils se terminent. Consultez aussi B<waitpid>(2). Cet attribut n'a de sens que lors de la mise en place d'un gestionnaire pour B<SIGCHLD>, ou lors de la configuration de la disposition de signal de B<SIG_DFL>.

note: type: Plain text
en: If the B<SA_NOCLDWAIT> flag is set when establishing a handler for B<SIGCHLD>, POSIX.1 leaves it unspecified whether a B<SIGCHLD> signal is generated when a child process terminates.  On Linux, a B<SIGCHLD> signal is generated in this case; on some other implementations, it is not.
fr: Si l'attribut B<SA_NOCLDWAIT> est défini lors de la mise en place d'un gestionnaire pour B<SIGCHLD>, POSIX.1 ne spécifie pas si le signal B<SIGCHLD> est généré lorsqu'un processus fils se termine. Sous Linux, un signal B<SIGCHLD> est généré dans ce cas ; sur d'autres implémentations, il ne l'est pas.

note: type: Plain text
en: Do not prevent the signal from being received from within its own signal handler.  This flag is meaningful only when establishing a signal handler.  B<SA_NOMASK> is an obsolete, nonstandard synonym for this flag.
fr: Ne pas empêcher un signal d'être reçu depuis l'intérieur de son propre gestionnaire. Cet attribut n'a de sens que lors de la mise en place d'un gestionnaire de signal. B<SA_NOMASK> est un synonyme obsolète et non standard pour cet attribut.

note: type: Plain text
en: Call the signal handler on an alternate signal stack provided by B<sigaltstack>(2).  If an alternate stack is not available, the default stack will be used.  This flag is meaningful only when establishing a signal handler.
fr: Appeler le gestionnaire avec une pile différente fournie par B<sigaltstack>(2). Si cette pile est indisponible, on utilisera la pile par défaut. Cet attribut n'a de sens que lors de la mise en place d'un gestionnaire de signal.

note: type: Plain text
en: Restore the signal action to the default upon entry to the signal handler.  This flag is meaningful only when establishing a signal handler.  B<SA_ONESHOT> is an obsolete, nonstandard synonym for this flag.
fr: Rétablir l'action à son comportement par défaut à l'entrée dans le gestionnaire de signal. Cet attribut n'a de sens que lors de la mise en place d'un gestionnaire de signal. B<SA_ONESHOT> est un synonyme obsolète et non standard pour cet attribut.

note: type: Plain text
en: Provide behavior compatible with BSD signal semantics by making certain system calls restartable across signals.  This flag is meaningful only when establishing a signal handler.  See B<signal>(7)  for a discussion of system call restarting.
fr: Fournir un comportement compatible avec la sémantique BSD en redémarrant automatiquement les appels système lents interrompus par l'arrivée du signal. Cet attribut n'a de sens que lors de la mise en place d'un gestionnaire de signal. Consultez B<signal>(7) pour une discussion sur le redémarrage d'un appel système.

note: type: TP
en: B<SA_SIGINFO> (since Linux 2.2)
fr: B<SA_SIGINFO> (depuis Linux 2.2)

note: (The .I sa_sigaction field was added in Linux 2.1.86.) type: Plain text
en: The signal handler takes three arguments, not one.  In this case, I<sa_sigaction> should be set instead of I<sa_handler>.  This flag is meaningful only when establishing a signal handler.
fr: Le gestionnaire de signal recevra trois arguments, et non plus un seul. Dans ce cas, il faut utiliser le membre I<sa_sigaction> au lieu de I<sa_handler>. Cet attribut n'a de sens que lors de la mise en place d'un gestionnaire de signal.

note: type: Plain text
en: The I<siginfo_t> argument to I<sa_sigaction> is a struct with the following elements:
fr: Le paramètre I<siginfo_t> de la routine I<sa_sigaction> est une structure contenant les éléments suivants\ :

note: FIXME si_trapno seems to be only used on SPARC and Alpha; this page could use a little more detail on its purpose there. In the kernel: si_tid type: Plain text
en: siginfo_t {
        int      si_signo;    /* Signal number */
        int      si_errno;    /* An errno value */
        int      si_code;     /* Signal code */
        int      si_trapno;   /* Trap number that caused
                                 hardware-generated signal
                                 (unused on most architectures) */
        pid_t    si_pid;      /* Sending process ID */
        uid_t    si_uid;      /* Real user ID of sending process */
        int      si_status;   /* Exit value or signal */
        clock_t  si_utime;    /* User time consumed */
        clock_t  si_stime;    /* System time consumed */
        sigval_t si_value;    /* Signal value */
        int      si_int;      /* POSIX.1b signal */
        void    *si_ptr;      /* POSIX.1b signal */
        int      si_overrun;  /* Timer overrun count; POSIX.1b timers */
        int      si_timerid;  /* Timer ID; POSIX.1b timers */
        void    *si_addr;     /* Memory location which caused fault */
        long     si_band;     /* Band event (was I<int> in
                                 glibc 2.3.2 and earlier) */
        int      si_fd;       /* File descriptor */
        short    si_addr_lsb; /* Least significant bit of address
                                 (since Linux 2.6.32) */
    }
fr: siginfo_t {
        int      si_signo;    /* Numéro de signal           */
        int      si_errno;    /* Numéro d'erreur            */
        int      si_code;     /* Code du signal             */
        int      si_trapno;   /* Numéro de trappe qui a causé
                                 le signal généré par le
                                 matériel (pas utilisé sur la
                                 plupart des architectures) */
        pid_t    si_pid;      /* PID de l'émetteur          */
        uid_t    si_uid;      /* UID réel de l'émetteur     */
        int      si_status;   /* Valeur de sortie ou signal */
        clock_t  si_utime;    /* Temps utilisateur écoulé   */
        clock_t  si_stime;    /* Temps système écoulé       */
        sigval_t si_value;    /* Valeur de signal           */
        int      si_int;      /* Signal POSIX.1b            */
        void    *si_ptr;      /* Signal POSIX.1b            */
        int      si_overrun;  /* Décompte de dépassement des
                                 horloges (POSIX.1b)        */
        int      si_timerid;  /* ID d'horloge (POSIX.1b)    */
        void    *si_addr;     /* Emplacement mémoire ayant
                                 causé l'erreur             */
        long     si_band;     /* Band event (était I<int> dans
                                 glibc 2.3.2 et antérieures */
        int      si_fd;       /* Descripteur de fichier     */
        short    si_addr_lsb; /* Bit le moins significatif de l'adresse
                                 (depuis Linux 2.6.32)   */
    }

note: type: Plain text
en: I<si_signo>, I<si_errno> and I<si_code> are defined for all signals.  (I<si_errno> is generally unused on Linux.)  The rest of the struct may be a union, so that one should read only the fields that are meaningful for the given signal:
fr: I<si_signo>, I<si_errno> et I<si_code> sont définis pour tous les signaux (I<si_errno> n'est généralement pas utilisé sous Linux). Le reste de la structure peut être une union, de telle sorte qu'on puisse ne lire que les champs spécifiques à un signal donné :

note: type: Plain text
en: Signals sent with B<kill>(2)  and B<sigqueue>(3)  fill in I<si_pid> and I<si_uid>.  In addition, signals sent with B<sigqueue>(3)  fill in I<si_int> and I<si_ptr> with the values specified by the sender of the signal; see B<sigqueue>(3)  for more details.
fr: Les signaux envoyés avec B<kill>(2) et B<sigqueue>(3) remplissent I<si_pid> et I<si_uid>. De plus, les signaux envoyés avec B<sigqueue>(3) remplissent I<si_int> et I<si_ptr> avec les valeurs indiquées par l'émetteur du signal ; consultez B<sigqueue>(3) pour plus de détails.

note: type: Plain text
en: Signals sent by POSIX.1b timers (since Linux 2.6) fill in I<si_overrun> and I<si_timerid>.  The I<si_timerid> field is an internal ID used by the kernel to identify the timer; it is not the same as the timer ID returned by B<timer_create>(2).  The I<si_overrun> field is the timer overrun count; this is the same information as is obtained by a call to B<timer_getoverrun>(2).  These fields are nonstandard Linux extensions.
fr: Les signaux envoyés par les horloges POSIX.1b (depuis Linux 2.6) remplissent I<si_overrun> et I<si_timerid>. Le champ I<si_timerid> est un identifiant interne utilisé par le noyau pour identifier l'horloge ; ce n'est pas la même chose que l'identifient d'horloge renvoyé par B<timer_create>(2). Le champ I<si_overrun> est le compteur de dépassement de l'horloge ; il s'agit de la même information renvoyée par un appel à B<timer_getoverrun>(2). Ces champs sont des extensions Linux non standard.

note: type: Plain text
en: Signals sent for message queue notification (see the description of B<SIGEV_SIGNAL> in B<mq_notify>(3))  fill in I<si_int>/I<si_ptr>, with the I<sigev_value> supplied to B<mq_notify>(3); I<si_pid>, with the process ID of the message sender; and I<si_uid>, with the real user ID of the message sender.
fr: Les signaux envoyés pour les notifications de files de messages (voyez la description de B<SIGEV_SIGNAL> dans B<mq_notify>(3)) remplissent I<si_int>/I<si_ptr> avec la valeur I<sigev_value> fournie à B<mq_notify>(3) ; I<si_pid> avec l'identifiant du processus de l'émetteur du message ; et I<si_uid> avec l'identifiant d'utilisateur réel de l'émetteur du message.

note: FIXME . When si_utime and si_stime where originally implemented, the measurement unit was HZ, which was the same as clock ticks (sysconf(_SC_CLK_TCK)).  In 2.6, HZ became configurable, and was *still* used as the unit to return the info these fields, with the result that the field values depended on
en: B<SIGCHLD> fills in I<si_pid>, I<si_uid>, I<si_status>, I<si_utime>, and I<si_stime>, providing information about the child.  The I<si_pid> field is the process ID of the child; I<si_uid> is the child's real user ID.  The I<si_status> field contains the exit status of the child (if I<si_code> is B<CLD_EXITED>), or the signal number that caused the process to change state.  The I<si_utime> and I<si_stime> contain the user and system CPU time used by the child process; these fields do not include the times used by waited-for children (unlike B<getrusage>(2)  and B<time>(2)).  In kernels up to 2.6, and since 2.6.27, these fields report CPU time in units of I<sysconf(_SC_CLK_TCK)>.  In 2.6 kernels before 2.6.27, a bug meant that these fields reported time in units of the (configurable) system jiffy (see B<time>(7)).
fr: B<SIGCHLD> remplit I<si_pid>, I<si_uid>, I<si_status>, I<si_utime> et I<si_stime>, pour fournir des informations au sujet des fils. Le champ I<si_pid> est l'identifiant de processus du fils ; I<si_uid> est l'identifiant d'utilisateur réel du fils. Le champ I<si_status> contient le code de sortie du fils (si I<si_code> vaut B<CLD_EXITED>), ou le numéro du signal qui a changé l'etat du processus. Les champs I<si_utime> et I<si_stime> comprennent les temps utilisateur et système utilisé par le processus fils ; ces champs ne comprennent pas le temps utilisé par les fils lorsqu'ils sont attendus (au contraire de B<getrusage>(2) et B<time>(2)). Dans les noyaux antérieurs à la version 2.6, et depuis la version 2.6.27, ces champs renvoient le temps CPU en unité de I<sysconf(_SC_CLK_TCK)>. Dans les noyaux de la série 2.6, avant le noyau 2.6.27, un bogue faisait que ces champs renvoyaient des temps mesurés en jiffy système (consultez B<time>(7)).

note: FIXME SIGTRAP also sets the following for ptrace_notify() ? info.si_code = exit_code; info.si_pid = task_pid_vnr(current); info.si_uid = current_uid();  /* Real UID */ type: Plain text
en: B<SIGILL>, B<SIGFPE>, B<SIGSEGV>, B<SIGBUS>, and B<SIGTRAP> fill in I<si_addr> with the address of the fault.  On some architectures, these signals also fill in the I<si_trapno> field.  Some suberrors of B<SIGBUS>, in particular B<BUS_MCEERR_AO> and B<BUS_MCEERR_AR>, also fill in I<si_addr_lsb>.  This field indicates the least significant bit of the reported address and therefore the extent of the corruption.  For example, if a full page was corrupted, I<si_addr_lsb> contains I<log2(sysconf(_SC_PAGESIZE))>.  B<BUS_MCERR_*> and I<si_addr_lsb> are Linux-specific extensions.
fr: B<SIGILL>, B<SIGFPE>, B<SIGSEGV>, B<SIGBUS> et B<SIGTRAP> remplissent I<si_addr> avec l'adresse de l'erreur. Sur certaines architectures, ces signaux remplissent aussi le champ I<si_trapno>. Certaines catégories d'erreurs de B<SIGBUS>, en particulier B<BUS_MCEERR_AO> et B<BUS_MCEERR_AR>, remplissent aussi le champ I<si_addr_lsb>, qui contient le bit le moins significatif de l'erreur signalée, et permet donc de connaître l'étendue de la corruption des données. Par exemple, si une page entière est corrompue, I<si_addr_lsb> contient I<log2(sysconf(_SC_PAGESIZE))>. B<BUS_MCERR_*> et I<si_addr_lsb> sont des extensions spécifiques à Linux.

note: type: Plain text
en: B<SIGIO>/B<SIGPOLL> (the two names are synonyms on Linux)  fills in I<si_band> and I<si_fd>.  The I<si_band> event is a bit mask containing the same values as are filled in the I<revents> field by B<poll>(2).  The I<si_fd> field indicates the file descriptor for which the I/O event occurred.
fr: B<SIGPOLL>/B<SIGIO> (synonymes sous Linux) remplissent I<si_band> et I<si_fd>. L'événement I<si_band> est un masque de bits contenant les mêmes valeurs que celles qui sont remplies dans le champ I<revents> par B<poll>(2). Le champ I<si_fd> donne le descripteur de fichiers sur lequel l'événement d'entrées-sorties s'est produit.

note: type: Plain text
en: I<si_code> is a value (not a bit mask)  indicating why this signal was sent.  The following list shows the values which can be placed in I<si_code> for any signal, along with reason that the signal was generated.
fr: I<si_code> est une valeur (pas un masque de bits) qui indique pourquoi ce signal a été envoyé. La liste suivante indique les valeurs que peut prendre I<si_code> pour n'importe quel signal, avec la raison associée.

note: type: Plain text
en: Sent by the kernel.
fr: Envoyé par le noyau.

note: type: Plain text
en: POSIX timer expired
fr: Fin d'une temporisation POSIX

note: type: Plain text
en: POSIX message queue state changed (since Linux 2.6.6); see B<mq_notify>(3)
fr: Changement d'état d'une file de messages (depuis Linux 2.6.6) ; consultez B<mq_notify>(3)

note: type: Plain text
en: AIO completed
fr: Fin d'une AIO

note: type: Plain text
en: Queued B<SIGIO> (only in kernels up to Linux 2.2; from Linux 2.4 onward B<SIGIO>/B<SIGPOLL> fills in I<si_code> as described below).
fr: B<SIGIO> avec file d'attente (seulement dans les noyaux Linux jusqu'aux versions 2.2 ; à partir de Linux 2.4, B<SIGIO>/B<SIGPOLL> remplit I<si_code> de la façon décrite plus bas).

note: SI_DETHREAD is defined in 2.6.9 sources, but isn't implemented It appears to have been an idea that was tried during 2.5.6 through to 2.5.24 and then was backed out. type: Plain text
en: B<tkill>(2)  or B<tgkill>(2)  (since Linux 2.4.19)
fr: B<tkill>(2) ou B<tgkill>(2) (depuis Linux 2.4.19)

note: type: Plain text
en: The following values can be placed in I<si_code> for a B<SIGILL> signal:
fr: Les valeurs suivantes peuvent être prises par I<si_code> pour un signal B<SIGILL> :

note: type: Plain text
en: illegal opcode
fr: opcode illégal

note: type: Plain text
en: illegal operand
fr: opérande illégale

note: type: Plain text
en: illegal addressing mode
fr: mode d'adressage illégal

note: type: Plain text
en: illegal trap
fr: trappe illégale

note: type: Plain text
en: privileged opcode
fr: opcode privilégié

note: type: Plain text
en: privileged register
fr: registre privilégié

note: type: Plain text
en: coprocessor error
fr: erreur de coprocesseur

note: type: Plain text
en: internal stack error
fr: erreur interne de pile

note: type: Plain text
en: The following values can be placed in I<si_code> for a B<SIGFPE> signal:
fr: Les valeurs suivantes peuvent être prises par I<si_code> pour un signal B<SIGFPE> :

note: type: Plain text
en: integer divide by zero
fr: division entière par zéro

note: type: Plain text
en: integer overflow
fr: débordement entier

note: type: Plain text
en: floating-point divide by zero
fr: division flottante par zéro

note: type: Plain text
en: floating-point overflow
fr: débordement flottant

note: type: Plain text
en: floating-point underflow
fr: débordement inférieur flottant

note: type: Plain text
en: floating-point inexact result
fr: résultat flottant inexact

note: type: Plain text
en: floating-point invalid operation
fr: opération flottante invalide

note: type: Plain text
en: subscript out of range
fr: indice hors intervalle

note: type: Plain text
en: The following values can be placed in I<si_code> for a B<SIGSEGV> signal:
fr: Les valeurs suivantes peuvent être prises par I<si_code> pour un signal B<SIGSEGV> :

note: type: Plain text
en: address not mapped to object
fr: adresse sans objet

note: type: Plain text
en: invalid permissions for mapped object
fr: permissions invalides pour l'objet

note: type: Plain text
en: The following values can be placed in I<si_code> for a B<SIGBUS> signal:
fr: Les valeurs suivantes peuvent être prises par I<si_code> pour un signal B<SIGBUS> :

note: type: Plain text
en: invalid address alignment
fr: alignement d'adresse invalide

note: type: Plain text
en: nonexistent physical address
fr: adresse physique inexistante

note: type: Plain text
en: object-specific hardware error
fr: erreur matérielle spécifique

note: type: TP
en: B<BUS_MCEERR_AR> (since Linux 2.6.32)
fr: B<BUS_MCEERR_AR> (depuis Linux 2.6.32)

note: type: Plain text
en: Hardware memory error consumed on a machine check; action required.
fr: erreur mémoire matérielle consommée lors de vérification de la machine ; action requise.

note: type: TP
en: B<BUS_MCEERR_AO> (since Linux 2.6.32)
fr: B<BUS_MCEERR_AO> (depuis Linux 2.6.32)

note: type: Plain text
en: Hardware memory error detected in process but not consumed; action optional.
fr: erreur mémoire matérielle détectée dans le processus mais non consommée ; action optionnelle.

note: type: Plain text
en: The following values can be placed in I<si_code> for a B<SIGTRAP> signal:
fr: Les valeurs suivantes peuvent être prises par I<si_code> pour un signal B<SIGTRAP> :

note: type: Plain text
en: process breakpoint
fr: point d'arrêt du processus

note: type: Plain text
en: process trace trap
fr: suivi d'exécution du processus

note: type: TP
en: B<TRAP_BRANCH> (since Linux 2.4)
fr: B<TRAP_BRANCH> (depuis Linux 2.4)

note: type: Plain text
en: process taken branch trap
fr: suivi des branches prises par le processus

note: type: TP
en: B<TRAP_HWBKPT> (since Linux 2.4)
fr: B<TRAP_HWBKPT> (depuis Linux 2.4)

note: type: Plain text
en: hardware breakpoint/watchpoint
fr: point d'arrêt/point à surveiller matériels

note: type: Plain text
en: The following values can be placed in I<si_code> for a B<SIGCHLD> signal:
fr: Les valeurs suivantes peuvent être prises par I<si_code> pour un signal B<SIGCHLD> :

note: type: Plain text
en: child has exited
fr: fils terminé normalement

note: type: Plain text
en: child was killed
fr: fils tué par un signal

note: type: Plain text
en: child terminated abnormally
fr: fils terminé anormalement

note: type: Plain text
en: traced child has trapped
fr: fils en cours de suivi

note: type: Plain text
en: child has stopped
fr: fils arrêté

note: type: Plain text
en: stopped child has continued (since Linux 2.6.9)
fr: fils arrêté a redémarré (depuis Linux 2.6.9)

note: type: Plain text
en: The following values can be placed in I<si_code> for a B<SIGIO>/B<SIGPOLL> signal:
fr: Les valeurs suivantes peuvent être prises par I<si_code> pour un signal B<SIGIO>/B<SIGPOLL> :

note: type: Plain text
en: data input available
fr: données disponibles en entrée

note: type: Plain text
en: output buffers available
fr: tampons de sortie libres

note: type: Plain text
en: input message available
fr: message disponible en entrée

note: type: Plain text
en: I/O error
fr: erreur d'entrée-sortie

note: type: Plain text
en: high priority input available
fr: entrée haute priorité disponible

note: type: Plain text
en: device disconnected
fr: périphérique débranché

note: type: Plain text
en: B<sigaction>()  returns 0 on success; on error, -1 is returned, and I<errno> is set to indicate the error.
fr: B<sigaction>() renvoie 0 s'il réussit. En cas d'erreur, -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: I<act> or I<oldact> points to memory which is not a valid part of the process address space.
fr: I<act> ou I<oldact> pointent en-dehors de l'espace d'adressage accessible.

note: type: Plain text
en: An invalid signal was specified.  This will also be generated if an attempt is made to change the action for B<SIGKILL> or B<SIGSTOP>, which cannot be caught or ignored.
fr: Un signal invalide est indiqué. Ceci se produit également si l'on tente de modifier l'action associée aux signaux B<SIGKILL> ou B<SIGSTOP>, qui ne peuvent pas être interceptés ou ignorés.

note: type: Plain text
en: A child created via B<fork>(2)  inherits a copy of its parent's signal dispositions.  During an B<execve>(2), the dispositions of handled signals are reset to the default; the dispositions of ignored signals are left unchanged.
fr: Un fils créé par B<fork>(2) hérite d'une copie des dispositions de signaux de son père. Lors d'un B<execve>(2), les dispositions des signaux pris en charge sont remises aux valeurs par défaut ; les dispositions des signaux ignorés ne sont pas modifiées.

note: type: Plain text
en: According to POSIX, the behavior of a process is undefined after it ignores a B<SIGFPE>, B<SIGILL>, or B<SIGSEGV> signal that was not generated by B<kill>(2)  or B<raise>(3).  Integer division by zero has undefined result.  On some architectures it will generate a B<SIGFPE> signal.  (Also dividing the most negative integer by -1 may generate B<SIGFPE>.)  Ignoring this signal might lead to an endless loop.
fr: Comme spécifié par POSIX, le comportement d'un processus est indéfini après la réception d'un signal B<SIGFPE>, B<SIGILL>, ou B<SIGSEGV> qui n'a pas été engendré par une fonction B<kill>(2) ou B<raise>(3). La division entière par zéro a un résultat indéfini, sur certaines architectures elle déclenche un signal B<SIGFPE>. De même, diviser l'entier le plus négatif par -1 peut déclencher B<SIGFPE>.

note: type: Plain text
en: POSIX.1-1990 disallowed setting the action for B<SIGCHLD> to B<SIG_IGN>.  POSIX.1-2001 allows this possibility, so that ignoring B<SIGCHLD> can be used to prevent the creation of zombies (see B<wait>(2)).  Nevertheless, the historical BSD and System V behaviors for ignoring B<SIGCHLD> differ, so that the only completely portable method of ensuring that terminated children do not become zombies is to catch the B<SIGCHLD> signal and perform a B<wait>(2)  or similar.
fr: POSIX.1-1990 interdisait d'ignorer B<SIGCHLD> avec B<SIG_IGN>. POSIX.1-2001 l'autorise, et ignorer B<SIGCHLD> permet donc d'éviter la création de zombies (consultez B<wait>(2)). Cependant, les comportements historiques de BSD et de System V quand B<SIGCHLD> est ignoré diffèrent, donc la seule méthode complètement portable pour s'assurer que les fils ne deviennent pas des zombies à leur terminaison est d'intercepter le signal B<SIGCHLD> et d'invoquer B<wait>(2) ou équivalent.

note: type: Plain text
en: POSIX.1-1990 specified only B<SA_NOCLDSTOP>.  POSIX.1-2001 added B<SA_NOCLDWAIT>, B<SA_RESETHAND>, B<SA_NODEFER>, and B<SA_SIGINFO>.  Use of these latter values in I<sa_flags> may be less portable in applications intended for older UNIX implementations.
fr: POSIX.1-1990 ne documentait que B<SA_NOCLDSTOP>. POSIX.1-2001 a ajouté B<SA_NOCLDWAIT>, B<SA_RESETHAND>, B<SA_NODEFER> et B<SA_SIGINFO>. L'utilisation de ces dernières valeurs dans I<sa_flags> peut être moins portable dans les applications censées s'exécuter sur des implémentations UNIX anciennes.

note: type: Plain text
en: The B<SA_RESETHAND> flag is compatible with the SVr4 flag of the same name.
fr: L'option B<SA_RESETHAND> est compatible avec l'option SVr4 du même nom.

note: type: Plain text
en: The B<SA_NODEFER> flag is compatible with the SVr4 flag of the same name under kernels 1.3.9 and newer.  On older kernels the Linux implementation allowed the receipt of any signal, not just the one we are installing (effectively overriding any I<sa_mask> settings).
fr: L'option B<SA_NODEFER> est compatible avec l'option SVr4 du même nom pour les noyaux 1.3.9 et ultérieurs. Pour les noyaux plus anciens, Linux autorisera la réception de tous les signaux et pas seulement celui qui vient de se déclencher (écrasant effectivement I<sa_mask> ).

note: type: Plain text
en: B<sigaction>()  can be called with a NULL second argument to query the current signal handler.  It can also be used to check whether a given signal is valid for the current machine by calling it with NULL second and third arguments.
fr: B<sigaction>() peut être appelé avec un second argument à NULL pour obtenir le gestionnaire de signaux actuel. On peut aussi vérifier si un signal est valide sur la machine actuelle en l'appelant avec les deuxième et troisième arguments qui valent NULL.

note: type: Plain text
en: It is not possible to block B<SIGKILL> or B<SIGSTOP> (by specifying them in I<sa_mask>).  Attempts to do so are silently ignored.
fr: Il est impossible de bloquer B<SIGKILL> or B<SIGSTOP> (en les indiquant dans I<sa_mask>). Les tentatives seront ignorées silencieusement.

note: type: Plain text
en: See B<sigsetops>(3)  for details on manipulating signal sets.
fr: Consultez B<sigsetops>(3) pour les détails concernant les ensembles de signaux.

note: type: Plain text
en: See B<signal>(7)  for a list of the async-signal-safe functions that can be safely called inside from inside a signal handler.
fr: Consultez B<signal>(7) pour une liste de fonctions sûres pour les signaux asynchrones qui peuvent être appelée dans les gestionnaires de signaux.

note: type: SS
en: Undocumented
fr: Non documenté

note: type: Plain text
en: Before the introduction of B<SA_SIGINFO> it was also possible to get some additional information, namely by using a I<sa_handler> with second argument of type I<struct sigcontext>.  See the relevant Linux kernel sources for details.  This use is obsolete now.
fr: Avant l'introduction de l'attribut B<SA_SIGINFO> il était déjà possible d'obtenir des informations supplémentaires, en ajoutant au I<sa_handler> un second paramètre de type I<struct sigcontext>. On peut retrouver ceci dans les sources du noyau Linux. Ce mécanisme est désormais obsolète.

note: type: Plain text
en: In kernels up to and including 2.6.13, specifying B<SA_NODEFER> in I<sa_flags> prevents not only the delivered signal from being masked during execution of the handler, but also the signals specified in I<sa_mask>.  This bug was fixed in kernel 2.6.14.
fr: Dans les noyaux jusqu'à 2.6.13 inclus, indiquer B<SA_NODEFER> dans I<sa_flags> empêchait non seulement le signal reçu d'être masqué pendant l'exécution du gestionnaire, mais empêchait également les signaux de I<sa_mask> d'être masqués. Ce bogue a été corrigé dans Linux 2.6.14.

note: type: Plain text
en: See B<mprotect>(2).
fr: Consultez B<mprotect>(2).

note: type: TH
en: 2010-09-26
fr: 26 septembre 2010

note: type: Plain text
en: sigaltstack - set and/or get signal stack context
fr: sigaltstack - Consultez ou définir la pile de signal

note: type: Plain text
en: B<sigaltstack>():
fr: B<sigaltstack>()\ :

note: type: Plain text
en: || /* Since glibc 2.12: */ _POSIX_C_SOURCE\ E<gt>=\ 200809L
fr: || /* Depuis la glibc 2.12 : */ _POSIX_C_SOURCE\ E<gt>=\ 200809L

note: type: Plain text
en: B<sigaltstack>()  allows a process to define a new alternate signal stack and/or retrieve the state of an existing alternate signal stack.  An alternate signal stack is used during the execution of a signal handler if the establishment of that handler (see B<sigaction>(2))  requested it.
fr: B<sigaltstack>() permet à un processus de définir une nouvelle pile spécifique pour les gestionnaires de signaux et/ou de récupérer l'état d'une pile spécifique de signal déjà existante. Une pile spécifique de signal est utilisée durant l'exécution d'un gestionnaire de signal si la mise en place de ce gestionnaire (consultez B<sigaction>(2)) le spécifiait.

note: type: Plain text
en: The normal sequence of events for using an alternate signal stack is the following:
fr: La séquence d'actions nominale pour utiliser une pile spécifique de signal est la suivante\ :

note: type: Plain text
en: Allocate an area of memory to be used for the alternate signal stack.
fr: Allouer une zone mémoire qui sera utilisée comme pile spécifique de signal.

note: type: Plain text
en: Use B<sigaltstack>()  to inform the system of the existence and location of the alternate signal stack.
fr: Utiliser B<sigaltstack>() afin d'informer le système de l'existence et de la position de la pile spécifique de signal.

note: type: Plain text
en: When establishing a signal handler using B<sigaction>(2), inform the system that the signal handler should be executed on the alternate signal stack by specifying the B<SA_ONSTACK> flag.
fr: Lors de la mise en place du gestionnaire de signal en utilisant B<sigaction>(2), informer le système que ce gestionnaire de signal doit être exécuté sur la pile spécifique de signal en positionnant le drapeau B<SA_ONSTACK>.

note: type: Plain text
en: The I<ss> argument is used to specify a new alternate signal stack, while the I<oss> argument is used to retrieve information about the currently established signal stack.  If we are interested in performing just one of these tasks, then the other argument can be specified as NULL.  Each of these arguments is a structure of the following type:
fr: L'argument I<ss> est utilisé afin de définir une nouvelle pile spécifique de signal, tandis que l'argument I<oss> est utilisé afin de récupérer des informations sur la pile de signal actuellement en place. Si une seule de ces actions vous intéresse, alors l'autre argument peut être positionné à NULL. Chacun de ces paramètres est une structure du type suivant\ :

note: type: Plain text
en: typedef struct {
        void  *ss_sp;     /* Base address of stack */
        int    ss_flags;  /* Flags */
        size_t ss_size;   /* Number of bytes in stack */
    } stack_t;
fr: typedef struct {
        void  *ss_sp;     /* Adresse de base de la pile*/
        int    ss_flags;  /* drapeaux */
        size_t ss_size;   /* Nombre d'octets dans la pile */
    } stack_t;

note: type: Plain text
en: To establish a new alternate signal stack, I<ss.ss_flags> is set to zero, and I<ss.ss_sp> and I<ss.ss_size> specify the starting address and size of the stack.  The constant B<SIGSTKSZ> is defined to be large enough to cover the usual size requirements for an alternate signal stack, and the constant B<MINSIGSTKSZ> defines the minimum size required to execute a signal handler.
fr: Afin de mettre en place une nouvelle pile spécifique de signal, I<ss.ss_flags> est positionné à zéro, et I<ss.ss_sp> et I<ss.ss_size> spécifient l'adresse de début et la taille de la pile. La constante B<SIGSTKSZ> est définie de façon à être suffisamment grande pour couvrir les besoins typiques en espace mémoire d'une pile spécifique de signal, et la constante B<MINSIGSTKSZ> définit la taille minimum nécessaire à l'exécution d'un gestionnaire de signal.

note: type: Plain text
en: When a signal handler is invoked on the alternate stack, the kernel automatically aligns the address given in I<ss.ss_sp> to a suitable address boundary for the underlying hardware architecture.
fr: Lorsqu'un gestionnaire de signal est invoqué sur la pile spécifique, le noyau aligne automatiquement l'adresse donnée dans I<ss.ss_sp> sur une valeur correcte pour l'architecture matérielle utilisée.

note: type: Plain text
en: To disable an existing stack, specify I<ss.ss_flags> as B<SS_DISABLE>.  In this case, the remaining fields in I<ss> are ignored.
fr: Afin de désactiver une pile existante, positionnez I<ss.ss_flags> à B<SS_DISABLE>. Dans ce cas, les autres champs de I<ss> sont ignorés.

note: type: Plain text
en: If I<oss> is not NULL, then it is used to return information about the alternate signal stack which was in effect prior to the call to B<sigaltstack>().  The I<oss.ss_sp> and I<oss.ss_size> fields return the starting address and size of that stack.  The I<oss.ss_flags> may return either of the following values:
fr: Si I<oss> ne vaut pas NULL, alors il est utilisé afin de renvoyer des informations sur la pile spécifique de signal qui était utilisée avant l'appel à B<sigaltstack>(). Les champs I<oss.ss_sp> et I<oss.ss_size> renvoient l'adresse de départ et la taille de cette pile. Le champ I<oss.ss_flags> peut renvoyer l'une des valeurs suivantes\ :

note: type: Plain text
en: The process is currently executing on the alternate signal stack.  (Note that it is not possible to change the alternate signal stack if the process is currently executing on it.)
fr: Le processus s'exécute actuellement sur la pile spécifique de signal. (Remarquez qu'il n'est pas possible de changer la pile spécifique de signal si le processus est en train de s'exécuter sur cette dernière.)

note: type: Plain text
en: The alternate signal stack is currently disabled.
fr: La pile spécifique de signal est actuellement désactivée.

note: type: Plain text
en: B<sigaltstack>()  returns 0 on success, or -1 on failure with I<errno> set to indicate the error.
fr: B<sigaltstack>() renvoie 0 en cas de succès, ou -1 en cas d'échec en positionnant alors I<errno> pour préciser l'erreur.

note: type: Plain text
en: Either I<ss> or I<oss> is not NULL and points to an area outside of the process's address space.
fr: L'un des paramètres I<ss> ou I<oss> ne vaut pas NULL et pointe vers une zone mémoire n'appartenant pas à l'espace d'adressage du processus.

note: type: Plain text
en: I<ss> is not NULL and the I<ss_flags> field contains a nonzero value other than B<SS_DISABLE>.
fr: I<ss> ne vaut pas NULL et le champ I<ss_flags> contient une valeur non nulle différente de B<SS_DISABLE>.

note: type: Plain text
en: The specified size of the new alternate signal stack (I<ss.ss_size>) was less than B<MINSTKSZ>.
fr: La taille de la nouvelle pile spécifique de signal indiquée (I<ss.ss_size>) est inférieure à B<MINSTKSZ>.

note: type: Plain text
en: An attempt was made to change the alternate signal stack while it was active (i.e., the process was already executing on the current alternate signal stack).
fr: On a essayé de modifier la pile spécifique de signal alors que celle-ci était active (c'est-à-dire, le processus était déjà en train de s'exécuter sur la pile spécifique de signal courante).

note: type: Plain text
en: The most common usage of an alternate signal stack is to handle the B<SIGSEGV> signal that is generated if the space available for the normal process stack is exhausted: in this case, a signal handler for B<SIGSEGV> cannot be invoked on the process stack; if we wish to handle it, we must use an alternate signal stack.
fr: Le cas le plus courant d'utilisation d'une pile spécifique est pour la gestion du signal B<SIGSEGV> qui est généré si la place disponible pour la pile normale du processus est épuisée. Dans ce cas, un gestionnaire pour B<SIGSEGV> ne peut pas être exécuté sur la pile du processus\ ; si l'on souhaite l'intercepter, on doit utiliser une pile spécifique.

note: type: Plain text
en: Establishing an alternate signal stack is useful if a process expects that it may exhaust its standard stack.  This may occur, for example, because the stack grows so large that it encounters the upwardly growing heap, or it reaches a limit established by a call to B<setrlimit(RLIMIT_STACK, &rlim)>.  If the standard stack is exhausted, the kernel sends the process a B<SIGSEGV> signal.  In these circumstances the only way to catch this signal is on an alternate signal stack.
fr: La mise en place d'une pile spécifique de signal est utile si un processus soupçonne qu'il est susceptible d'épuiser sa pile standard. Cela peut se produire, par exemple, lorsque la pile grossit au point de rencontrer la limite supérieure du tas, ou si elle atteint une limite établie par un appel à B<setrlimit(RLIMIT_STACK, &rlim)>. Si la pile standard est épuisée, le noyau envoie au processus un signal B<SIGSEGV>. Dans ces circonstances, la seule façon d'intercepter ce signal est d'utiliser une pile spécifique de signal.

note: type: Plain text
en: On most hardware architectures supported by Linux, stacks grow downward.  B<sigaltstack>()  automatically takes account of the direction of stack growth.
fr: Sur la plupart des architectures supportées par Linux, les piles s'étendent vers les adresses décroissantes. B<sigaltstack>() prend automatiquement en charge le sens d'expansion de la pile.

note: type: Plain text
en: Functions called from a signal handler executing on an alternate signal stack will also use the alternate signal stack.  (This also applies to any handlers invoked for other signals while the process is executing on the alternate signal stack.)  Unlike the standard stack, the system does not automatically extend the alternate signal stack.  Exceeding the allocated size of the alternate signal stack will lead to unpredictable results.
fr: Les fonctions appelées depuis un gestionnaire de signal s'exécutant sur une pile spécifique de signal utilisent également cette pile. (Cela s'applique également à tous les gestionnaires invoqués pour d'autres signaux alors que le processus s'exécute sur la pile spécifique de signal.) Contrairement à la pile standard, le système n'accroît pas automatiquement la pile spécifique de signal. Dépasser la taille allouée pour la pile spécifique de signal conduit à des résultats imprévisibles.

note: type: Plain text
en: A successful call to B<execve>(2)  removes any existing alternate signal stack.  A child process created via B<fork>(2)  inherits a copy of its parent's alternate signal stack settings.
fr: Un appel B<execve>(2) réussi détruit toutes piles spécifiques de signal existantes. Un processus fils créé avec B<fork>(2) hérite d'une copie des paramètres de la pile spécifique de signal de son père.

note: type: Plain text
en: B<sigaltstack>()  supersedes the older B<sigstack>()  call.  For backward compatibility, glibc also provides B<sigstack>().  All new applications should be written using B<sigaltstack>().
fr: B<sigaltstack>() succède à l'ancien appel B<sigstack>(). Pour des raisons de compatibilité, la glibc implémente B<sigstack>(). Toutes les nouvelles applications devraient être écrites en utilisant B<sigaltstack>().

note: type: SS
en: History
fr: Historique

note: type: Plain text
en: 4.2BSD had a B<sigstack>()  system call.  It used a slightly different struct, and had the major disadvantage that the caller had to know the direction of stack growth.
fr: BSD\ 4.2 possédait un appel système B<sigstack>(). Il utilisait une structure légèrement différente, et avait comme désavantage principal la nécessité pour l'appelant de connaître le sens d'expansion de la pile.

note: type: Plain text
en: The following code segment demonstrates the use of B<sigaltstack>():
fr: Le segment de code suivant donne un exemple d'utilisation de B<sigaltstack>()\ :

note: type: Plain text
en: ss.ss_sp = malloc(SIGSTKSZ);
    if (ss.ss_sp == NULL)
        /* Handle error */;
    ss.ss_size = SIGSTKSZ;
    ss.ss_flags = 0;
    if (sigaltstack(&ss, NULL) == -1)
        /* Handle error */;
fr: ss.ss_sp = malloc(SIGSTKSZ);
    if (ss.ss_sp == NULL)
        /* Traitement de l'erreur */;
    ss.ss_size = SIGSTKSZ;
    ss.ss_flags = 0;
    if (sigaltstack(&ss, NULL) == -1)
        /* Traitement de l'erreur */;

note: type: TH
en: 2011-09-09
fr: 9 septembre 2011

note: type: Plain text
en: sigevent - structure for notification from asynchronous routines
fr: sigevent - Structure de notification des routines asynchrones

note: type: Plain text
en: union sigval {          /* Data passed with notification */
        int     sival_int;         /* Integer value */
        void   *sival_ptr;         /* Pointer value */
    };
fr: union sigval {          /* Données transmises avec la notification */
        int     sival_int;         /* Valeur entière */
        void   *sival_ptr;         /* Valeur du pointeur */
    };

note: type: Plain text
en: struct sigevent {
        int          sigev_notify; /* Notification method */
        int          sigev_signo;  /* Notification signal */
        union sigval sigev_value;  /* Data passed with
                                      notification */
        void       (*sigev_notify_function) (union sigval);
                         /* Function used for thread
                            notification (SIGEV_THREAD) */
        void        *sigev_notify_attributes;
                         /* Attributes for notification thread
                            (SIGEV_THREAD) */
        pid_t        sigev_notify_thread_id;
                         /* ID of thread to signal (SIGEV_THREAD_ID) */
    };
fr: struct sigevent {
        int          sigev_notify; /* Méthode de notification */
        int          sigev_signo;  /* Signal de notification */
        union sigval sigev_value;  /* Données transmises avec
                                      la notification */
        void       (*sigev_notify_function) (union sigval);
                         /* Fonction utilisée pour la notification
                            du thread (SIGEV_THREAD) */
        void        *sigev_notify_attributes;
                         /* Attributs pour la notification
                            du thread (SIGEV_THREAD) */
        pid_t        sigev_notify_thread_id;
                         /* Identifiant du thread à signaler (SIGEV_THREAD_ID) */
    };

note: type: Plain text
en: The I<sigevent> structure is used by various APIs to describe the way a process is to be notified about an event (e.g., completion of an asynchronous request, expiration of a timer, or the arrival of a message).
fr: La structure de I<sigevent> est utilisée par différentes API pour décrire la façon dont un processus sera averti d'un évènement (par exemple la fin d'une requête asynchrone, l'expiration d'une temporisation ou l'arrivée d'un message).

note: type: Plain text
en: The definition shown in the SYNOPSIS is approximate: some of the fields in the I<sigevent> structure may be defined as part of a union.  Programs should employ only those fields relevant to the value specified in I<sigev_notify>.
fr: La définition du SYNOPSIS est approximative : certains champs de la structure I<sigevent> peuvent être définis comme faisant partie d'une union. Les programmes ne devraient utiliser ces champs qu'en fonction de la valeur indiquée dans I<sigev_notify>.

note: type: Plain text
en: The I<sigev_notify> field specifies how notification is to be performed.  This field can have one of the following values:
fr: Le champ I<sigev_notify> indique comment les notifications seront effectuées. Ce champ peut prendre une des valeurs suivantes :

note: type: Plain text
en: A "null" notification: don't do anything when the event occurs.
fr: Une notification « vide » : ne fait rien quand l'évènement se produit.

note: type: Plain text
en: Notify the process by sending the signal specified in I<sigev_signo>.
fr: Notifie le processus en envoyant le signal indiqué en I<sigev_signo>.

note: type: Plain text
en: If the signal is caught with a signal handler that was registered using the B<sigaction>(2)  B<SA_SIGINFO> flag, then the following fields are set in the I<siginfo_t> structure that is passed as the second argument of the handler:
fr: Si le signal est intercepté avec un gestionnaire de signal qui a été enregistré avec l'option B<SA_SIGINFO> de B<sigaction>(2), les champs suivants sont définis dans la structure I<siginfo_t> qui est transmise en tant que deuxième argument au gestionnaire :

note: type: Plain text
en: This field is set to a value that depends on the API delivering the notification.
fr: La valeur de ce champ dépend de l'API qui transmet la notification.

note: type: Plain text
en: This field is set to the signal number (i.e., the same value as in I<sigev_signo>).
fr: Le numéro du signal est attribué à ce champ (par exemple la même valeur que dans I<sigev_signo>).

note: type: Plain text
en: This field is set to the value specified in I<sigev_value>.
fr: La valeur indiquée dans I<sigev_value> est attribuée à ce champ.

note: type: Plain text
en: Depending on the API, other fields may also be set in the I<siginfo_t> structure.
fr: En fonction de l'API, d'autres champs peuvent être définis dans la structure I<siginfo_t>.

note: type: Plain text
en: The same information is also available if the signal is accepted using B<sigwaitinfo>(2).
fr: Les mêmes renseignements sont aussi disponibles si le signal permet d'utiliser B<sigwaitinfo>(2).

note: type: Plain text
en: Notify the process by invoking I<sigev_notify_function> "as if" it were the start function of a new thread.  (Among the implementation possibilities here are that each timer notification could result in the creation of a new thread, or that a single thread is created to receive all notifications.)  The function is invoked with I<sigev_value> as its sole argument.  If I<sigev_notify_attributes> is not NULL, it should point to a I<pthread_attr_t> structure that defines attributes for the new thread (see B<pthread_attr_init>(3)).
fr: Notifie le processus par l'appel de I<sigev_notify_function> « comme s'il » s'agissait de la fonction de démarrage d'un nouveau thread (il y a plusieurs possibilités d'implémentation, dont la création d'un nouveau thread pour chaque notification de minuterie, ou la création d'un unique thread pour la réception de toutes les notifications). La fonction est appelée avec I<sigev_value> comme unique paramètre. Si I<sigev_notify_attributes> n'est pas NULL, il doit pointer vers une structure I<pthread_attr_t> qui définie les paramètres pour le nouveau thread (voir B<pthread_attr_init>(3)).

note: type: TP
en: B<SIGEV_THREAD_ID> (Linux-specific)
fr: B<SIGEV_THREAD_ID> (spécifique à Linux)

note: | SIGEV_SIGNAL vs not? type: Plain text
en: Currently used only by POSIX timers; see B<timer_create>(2).
fr: Seulement utilisée par les temporisations POSIX pour le moment, consultez B<timer_create>(2).

note: type: TH
en: 2013-04-19
fr: 19 avril 2013

note: type: Plain text
en: siginterrupt - allow signals to interrupt system calls
fr: siginterrupt - Permettre aux signaux d'interrompre les appels système

note: type: Plain text
en: B<siginterrupt>():
fr: B<siginterrupt>() :

note: type: Plain text
en: The B<siginterrupt>()  function changes the restart behavior when a system call is interrupted by the signal I<sig>.  If the I<flag> argument is false (0), then system calls will be restarted if interrupted by the specified signal I<sig>.  This is the default behavior in Linux.
fr: La fonction B<siginterrupt>() modifie le comportement de redémarrage d'un appel système interrompu par le signal I<sig>. Si l'argument I<flag> vaut zéro, l'appel système recommencera après la réception d'un signal I<sig>. C'est le comportement par défaut sous Linux.

note: type: Plain text
en: If the I<flag> argument is true (1) and no data has been transferred, then a system call interrupted by the signal I<sig> will return -1 and I<errno> will be set to B<EINTR>.
fr: Si l'argument I<flag> vaut 1 et qu'aucun transfert de données n'a commencé, un appel système interrompu par le signal I<sig> renverra -1 et I<errno> contiendra le code d'erreur B<EINTR>.

note: type: Plain text
en: If the I<flag> argument is true (1) and data transfer has started, then the system call will be interrupted and will return the actual amount of data transferred.
fr: Si I<flag> vaut 1, et si un transfert de données a commencé, alors l'appel système interrompu renverra le nombre réel de données transférées.

note: type: Plain text
en: The B<siginterrupt>()  function returns 0 on success.  It returns -1 if the signal number I<sig> is invalid, with I<errno> set to indicate the cause of the error.
fr: La fonction B<siginterrupt>() renvoie 0 si elle réussit. Elle renvoie -1 si le numéro de signal I<sig> est invalide et I<errno> contient le code d'erreur.

note: type: Plain text
en: The specified signal number is invalid.
fr: Le numéro de signal indiqué n'est pas valable.

note: type: Plain text
en: 4.3BSD, POSIX.1-2001.  POSIX.1-2008 marks B<siginterrupt>()  as obsolete, recommending the use of B<sigaction>(2)  with the B<SA_RESTART> flag instead.
fr: BSD 4.3, POSIX.1-2001. POSIX.1-2008 marque B<siginterrupt>() comme étant obsolète, en recommendant d'utiliser à la place B<sigaction>(2) avec l'attribut B<SA_RESTART>.

note: type: Plain text
en: signal - ANSI C signal handling
fr: signal - Gestion de signaux ANSI C

note: type: Plain text
en: The behavior of B<signal>()  varies across UNIX versions, and has also varied historically across different versions of Linux.  B<Avoid its use>: use B<sigaction>(2)  instead.  See I<Portability> below.
fr: Le comportement de B<signal>() varie selon les versions d'UNIX, et a aussi varié au cours du temps dans les différentes versions de Linux. B<Évitez de l'utiliser>\ : utilisez plutôt B<sigaction>(2). Consultez la section I<Portabilité> plus bas.

note: type: Plain text
en: B<signal>()  sets the disposition of the signal I<signum> to I<handler>, which is either B<SIG_IGN>, B<SIG_DFL>, or the address of a programmer-defined function (a "signal handler").
fr: B<signal>() installe le gestionnaire I<handler> pour le signal I<signum>. I<handler> peut être B<SIG_IGN>, B<SIG_DFL> ou l'adresse d'une fonction définie par le programmeur (un «\ gestionnaire de signal\ »).

note: type: Plain text
en: If the signal I<signum> is delivered to the process, then one of the following happens:
fr: Lors de l'arrivée d'un signal correspondant au numéro I<signum>, l'un des événements suivants se produit\ :

note: type: Plain text
en: If the disposition is set to B<SIG_IGN>, then the signal is ignored.
fr: Si le gestionnaire vaut B<SIG_IGN>, le signal est ignoré.

note: type: Plain text
en: If the disposition is set to B<SIG_DFL>, then the default action associated with the signal (see B<signal>(7))  occurs.
fr: Si le gestionnaire est B<SIG_DFL>, l'action par défaut associée à ce signal est entreprise (consultez B<signal>(7)).

note: type: Plain text
en: If the disposition is set to a function, then first either the disposition is reset to B<SIG_DFL>, or the signal is blocked (see I<Portability> below), and then I<handler> is called with argument I<signum>.  If invocation of the handler caused the signal to be blocked, then the signal is unblocked upon return from the handler.
fr: Si le gestionnaire est une fonction, alors tout d'abord le gestionnaire est reconfiguré à  B<SIG_DFL>, ou le signal est bloqué (voir la section I<Portabilité> ci\(hydessous), puis I<handler> est appelée avec l'argument I<signum>. Si l'invocation du gestionnaire a bloqué le signal, le signal est débloqué au retour du gestionnaire.

note: type: Plain text
en: The signals B<SIGKILL> and B<SIGSTOP> cannot be caught or ignored.
fr: Les signaux B<SIGKILL> et B<SIGSTOP> ne peuvent être ni ignorés, ni interceptés.

note: type: Plain text
en: B<signal>()  returns the previous value of the signal handler, or B<SIG_ERR> on error.  In the event of an error, I<errno> is set to indicate the cause.
fr: B<signal>() renvoie la valeur précédente du gestionnaire de signaux, ou B<SIG_ERR> en cas d'erreur. En cas d'erreur, I<errno> contient le code d'erreur.

note: type: Plain text
en: I<signum> is invalid.
fr: I<signum> est invalide.

note: type: Plain text
en: The effects of B<signal>()  in a multithreaded process are unspecified.
fr: Les effets de B<signal>() dans un processus multithreadé sont indéterminés.

note: type: Plain text
en: See B<sigaction>(2)  for details on what happens when B<SIGCHLD> is set to B<SIG_IGN>.
fr: Consultez B<sigaction>(2) pour des détails sur ce qui se passe quand on place B<SIGCHLD> à B<SIG_IGN>.

note: type: Plain text
en: See B<signal>(7)  for a list of the async-signal-safe functions that can be safely called from inside a signal handler.
fr: Consultez B<signal>(7) pour une liste de fonctions sûres pour les signaux asynchrones qui peuvent être appelées dans les gestionnaires de signaux.

note: libc4 and libc5 define .IR SignalHandler ; type: Plain text
en: The use of I<sighandler_t> is a GNU extension, exposed if B<_GNU_SOURCE> is defined; glibc also defines (the BSD-derived)  I<sig_t> if B<_BSD_SOURCE> is defined.  Without use of such a type, the declaration of B<signal>()  is the somewhat harder to read:
fr: L'utilisation du type I<sighandler_t> est une extension GNU, exposée si B<_GNU_SOURCE> est définie. La glibc définit aussi I<sig_t> (dérivé de BSD) si B<_GNU_SOURCE> est définie. Sans cette définition de ce type, la déclaration de B<signal>() est plus difficile à lire :

note: type: SS
en: Portability
fr: Portabilité

note: type: Plain text
en: The only portable use of B<signal>()  is to set a signal's disposition to B<SIG_DFL> or B<SIG_IGN>.  The semantics when using B<signal>()  to establish a signal handler vary across systems (and POSIX.1 explicitly permits this variation); B<do not use it for this purpose.>
fr: La seule utilisation portable de B<signal>() est de de configurer le gestionnaire du signal à B<SIG_DFL> ou B<SIG_IGN>. La sémantique associée à l'utilisation de B<signal>() pour définir un gestionnaire de signal dépend suivant les systèmes (et POSIX.1 autorise explicitement ces écarts) ; B<ne l'utiliser pas pour cela.>

note: type: Plain text
en: POSIX.1 solved the portability mess by specifying B<sigaction>(2), which provides explicit control of the semantics when a signal handler is invoked; use that interface instead of B<signal>().
fr: POSIX.1 a résolu ce problème de portabilité est spécifiant B<sigaction>(2), qui fournit un contrôle explicite de la sémantique quand un gestionnaire de signal est appelé ; utilisez cette interface plutôt que B<signal>().

note: type: Plain text
en: In the original UNIX systems, when a handler that was established using B<signal>()  was invoked by the delivery of a signal, the disposition of the signal would be reset to B<SIG_DFL>, and the system did not block delivery of further instances of the signal.  This is equivalent to calling B<sigaction>(2)  with the following flags:
fr: Dans les systèmes UNIX d'origine, quand un gestionnaire défini par B<signal>() était appelé lors de la distribution d'un signal, le gestionnaire du signal était remis à B<SIG_DFL>, et le système ne bloquait pas la distribution des instances suivantes du signal. Cela revenait à appeler B<sigaction>(2) avec les attribut suivants :

note: type: Plain text
en: System V also provides these semantics for B<signal>().  This was bad because the signal might be delivered again before the handler had a chance to reestablish itself.  Furthermore, rapid deliveries of the same signal could result in recursive invocations of the handler.
fr: System V fournit également cette sémantique pour B<signal>(). Cela posait problème parce qu'un signal pouvait être distribué avant que le gestionnaire ait le temps de se réactiver. De plus, la distribution rapide d'un même signal pouvait causer des appels récursif au gestionnaire.

note: type: Plain text
en: BSD improved on this situation, but unfortunately also changed the semantics of the existing B<signal>()  interface while doing so.  On BSD, when a signal handler is invoked, the signal disposition is not reset, and further instances of the signal are blocked from being delivered while the handler is executing.  Furthermore, certain blocking system calls are automatically restarted if interrupted by a signal handler (see B<signal>(7)).  The BSD semantics are equivalent to calling B<sigaction>(2)  with the following flags:
fr: BSD a amélioré la situation, mais a malheureusement également modifié la sémantique de l'interface de B<signal>() en procédant de cette façon. Sous BSD, lorsqu'un gestionnaire de signal est appelé, la disposition du signal n'est pas réinitialisée, et les instances suivantes du signal ne peuvent être distribuées tant que le gestionnaire s'exécute. En outre, certains appels système bloquants sont automatiquement relancés s'ils sont interrompus par le gestionnaire de signal (consultez B<signal>(7)). La sémantique BSD est équivalente à un appel de B<sigaction>(2) avec les attributs suivants :

note: type: Plain text
en: The situation on Linux is as follows:
fr: La situation sous Linux est la suivante :

note: type: Plain text
en: The kernel's B<signal>()  system call provides System V semantics.
fr: L'appel système B<signal>() du noyau fournit la sémantique System V.

note: type: Plain text
en: By default, in glibc 2 and later, the B<signal>()  wrapper function does not invoke the kernel system call.  Instead, it calls B<sigaction>(2)  using flags that supply BSD semantics.  This default behavior is provided as long as the B<_BSD_SOURCE> feature test macro is defined.  By default, B<_BSD_SOURCE> is defined; it is also implicitly defined if one defines B<_GNU_SOURCE>, and can of course be explicitly defined.
fr: Par défaut, dans la glibc 2 et les suivantes, la fonction de bibliothèque B<signal>() n'appelle pas l'appel système. À la place, elle appelle B<sigaction>(2) est fournissant un attribut qui fournit la sémantique BSD. Ce comportement par défaut est fourni tant que la macro de test de fonctionnalités B<_BSD_SOURCE> est définie. Par défaut, B<_BSD_SOURCE> est définie ; elle est également implicitement définie si on défini B<_GNU_SOURCE>, et peut également être définie explicitement.

note: System V semantics are also provided if one uses the separate .BR sysv_signal (3) function. type: Plain text
en: On glibc 2 and later, if the B<_BSD_SOURCE> feature test macro is not defined, then B<signal>()  provides System V semantics.  (The default implicit definition of B<_BSD_SOURCE> is not provided if one invokes B<gcc>(1)  in one of its standard modes (I<-std=xxx> or I<-ansi>)  or defines various other feature test macros such as B<_POSIX_SOURCE>, B<_XOPEN_SOURCE>, or B<_SVID_SOURCE>; see B<feature_test_macros>(7).)
fr: Dans la glibc 2 et les suivantes, si la macro de test de fonctionnalités B<_BSD_SOURCE> n'est pas définie, alors B<signal>() fourni la sémantique System V. (la définition implicite de B<_BSD_SOURCE> par défaut n'est pas fournie si on appelle B<gcc>(1) dans un de ses modes demandant le respect d'une norme (I<-std=xxx> ou I<-ansi>) ou si on définie certaines autres macro de test de fonctionnalités comme B<_POSIX_SOURCE>, B<_XOPEN_SOURCE> ou B<_SVID_SOURCE> ; consultez B<feature_test_macros>(7).)

note: type: Plain text
en: The B<signal>()  function in Linux libc4 and libc5 provide System V semantics.  If one on a libc5 system includes I<E<lt>bsd/signal.hE<gt>> instead of I<E<lt>signal.hE<gt>>, then B<signal>()  provides BSD semantics.
fr: La fonction B<signal>() de la libc4 et de la libc5 Linux fournissent la sémantique System V. Si on inclue I<E<lt>bsd/signal.hE<gt>> sur une libc5 au lieu de I<E<lt>signal.hE<gt>>, alors B<signal>() fournie la sémantique BSD.

note: type: Plain text
en: signal - overview of signals
fr: signal - Panorama des signaux

note: type: Plain text
en: Linux supports both POSIX reliable signals (hereinafter "standard signals") and POSIX real-time signals.
fr: Linux prend en charge à la fois les signaux POSIX classiques («\ signaux standards\ ») et les signaux POSIX temps-réel.

note: type: SS
en: Signal dispositions
fr: Dispositions de signaux

note: type: Plain text
en: Each signal has a current I<disposition>, which determines how the process behaves when it is delivered the signal.
fr: Chaque signal a une I<disposition> courante, qui détermine le comportement du processus lorsqu'il reçoit ce signal.

note: type: Plain text
en: The entries in the "Action" column of the tables below specify the default disposition for each signal, as follows:
fr: Les symboles de la colonne «\ Action\ » indiquent l'action par défaut pour chaque signal, avec la signification suivante\ :

note: type: Plain text
en: Default action is to terminate the process.
fr: Par défaut, terminer le processus.

note: type: Plain text
en: Default action is to ignore the signal.
fr: Par défaut, ignorer le signal.

note: type: Plain text
en: Default action is to terminate the process and dump core (see B<core>(5)).
fr: Par défaut, créer un fichier core et terminer le processus (consultez B<core>(5)).

note: type: Plain text
en: Default action is to stop the process.
fr: Par défaut, arrêter le processus.

note: type: Plain text
en: Default action is to continue the process if it is currently stopped.
fr: Par défaut, continuer le processus s'il est actuellement arrêté.

note: type: Plain text
en: A process can change the disposition of a signal using B<sigaction>(2)  or B<signal>(2).  (The latter is less portable when establishing a signal handler; see B<signal>(2)  for details.)  Using these system calls, a process can elect one of the following behaviors to occur on delivery of the signal: perform the default action; ignore the signal; or catch the signal with a I<signal handler>, a programmer-defined function that is automatically invoked when the signal is delivered.  (By default, the signal handler is invoked on the normal process stack.  It is possible to arrange that the signal handler uses an alternate stack; see B<sigaltstack>(2)  for a discussion of how to do this and when it might be useful.)
fr: Un processus peut changer la disposition d'un signal avec B<sigaction>(2) ou B<signal>(2) (la deuxième option est moins portable quand on définit un gestionnaire de signal ; consultez B<signal>(2)  pour plus de détails). Avec ces appels système, un processus peut choisir de se comporter de l'une des façons suivantes lorsqu'il reçoit ce signal\ : effectuer l'action par défaut, ignorer le signal, ou rattraper le signal avec un I<gestionnaire de signal>, c'est-à-dire une fonction définie par le programme, qui est invoquée automatiquement lorsque le signal est distribué. (Par défaut, le gestionnaire de signaux est appelé sur la pile normale des processus. Il est possible de s'arranger pour que le gestionnaire de signaux utilise une autre pile ; consultez B<sigaltstack>(2) pour une discussion sur comment faire ceci et quand ça peut être utile.)

note: type: Plain text
en: The signal disposition is a per-process attribute: in a multithreaded application, the disposition of a particular signal is the same for all threads.
fr: La disposition d'un signal est un attribut du processus\ : dans une application multithreadée, la disposition d'un signal particulier est la même pour tous les threads.

note: type: SS
en: Sending a signal
fr: Envoyer un signal

note: type: Plain text
en: The following system calls and library functions allow the caller to send a signal:
fr: Les appels système suivants permettent à l'appelant d'envoyer un signal :

note: type: Plain text
en: Sends a signal to the calling thread.
fr: Envoie un signal au thread appelant.

note: type: Plain text
en: Sends a signal to a specified process, to all members of a specified process group, or to all processes on the system.
fr: Envoie un signal au processus indiqué, à tous les membres du groupe de processus indiqué, ou à tous les processus du système.

note: type: Plain text
en: Sends a signal to all of the members of a specified process group.
fr: Envoie un signal à tous les membres du groupe de processus indiqué.

note: type: Plain text
en: Sends a signal to a specified POSIX thread in the same process as the caller.
fr: Envoie un signal au thread POSIX indiqué, dans le même processus que l'appelant.

note: type: Plain text
en: Sends a signal to a specified thread within a specific process.  (This is the system call used to implement B<pthread_kill>(3).)
fr: Envoie un signal au thread indiqué, à l'intérieur d'un processus donné. (C'est l'appel système qui était utilisé pour implémenter B<pthread_kill>(3))

note: type: Plain text
en: Sends a real-time signal with accompanying data to a specified process.
fr: Envoie un signal temps-réel, avec ses données jointes, au processus indiqué.

note: type: SS
en: Waiting for a signal to be caught
fr: Attente de la capture d'un signal

note: type: Plain text
en: The following system calls suspend execution of the calling process or thread until a signal is caught (or an unhandled signal terminates the process):
fr: Les appels système suivants suspendent l'exécution du processus ou du thread appelant jusqu'à ce qu'un signal soit attrapé (ou qu'un signal non pris en charge termine le processus) :

note: type: Plain text
en: Suspends execution until any signal is caught.
fr: Suspend l'exécution jusqu'à ce que n'importe quel signal soit reçu.

note: type: Plain text
en: Temporarily changes the signal mask (see below) and suspends execution until one of the unmasked signals is caught.
fr: Change temporairement le masque de signaux (voir ci-dessous) et suspend l'exécution jusqu'à ce qu'un des signaux masqué soit reçu.

note: type: SS
en: Synchronously accepting a signal
fr: Accepter un signal de façon synchrone

note: type: Plain text
en: Rather than asynchronously catching a signal via a signal handler, it is possible to synchronously accept the signal, that is, to block execution until the signal is delivered, at which point the kernel returns information about the signal to the caller.  There are two general ways to do this:
fr: Au lieu de rattraper un signal de façon asynchrone avec un gestionnaire de signal, il est possible accepter un signal de façon synchrone, c'est-à-dire de bloquer l'exécution jusqu'à ce qu'un signal soit distribué. À ce moment, le noyau renvoie des informations concernant le signal à l'appelant. Il y a deux façon générale pour faire cela :

note: type: Plain text
en: B<sigwaitinfo>(2), B<sigtimedwait>(2), and B<sigwait>(3)  suspend execution until one of the signals in a specified set is delivered.  Each of these calls returns information about the delivered signal.
fr: B<sigwaitinfo>(2), B<sigtimedwait>(2) et B<sigwait>(3) suspendent l'exécution jusqu'à ce qu'un des signaux dans l'ensemble indiqué soit distribué. Chacun de ces appels renvoie des informations concernant le signal distribué.

note: type: Plain text
en: B<signalfd>(2)  returns a file descriptor that can be used to read information about signals that are delivered to the caller.  Each B<read>(2)  from this file descriptor blocks until one of the signals in the set specified in the B<signalfd>(2)  call is delivered to the caller.  The buffer returned by B<read>(2)  contains a structure describing the signal.
fr: B<signalfd>(2) renvoie un descripteur de fichier qui peut être utilisé pour lire des informations concernant les signaux qui sont distribué à l'appelant. Chaque B<read>(2) dans ce descripteur de fichier est bloquant jusqu'à ce que des signaux de l'ensemble fournit à B<signalfd>(2) soit distribué à l'appelant. Le tampon renvoyé par B<read>(2) contient une structure qui décrit le signal.

note: type: SS
en: Signal mask and pending signals
fr: Masque de signaux et signaux en attente

note: type: Plain text
en: A signal may be I<blocked>, which means that it will not be delivered until it is later unblocked.  Between the time when it is generated and when it is delivered a signal is said to be I<pending>.
fr: Un signal peut être I<bloqué>, ce qui signifie qu'il ne sera pas reçu par le processus avant d'être débloqué. Entre sa création et sa réception, le signal est dit I<en attente>.

note: type: Plain text
en: Each thread in a process has an independent I<signal mask>, which indicates the set of signals that the thread is currently blocking.  A thread can manipulate its signal mask using B<pthread_sigmask>(3).  In a traditional single-threaded application, B<sigprocmask>(2)  can be used to manipulate the signal mask.
fr: Chaque thread d'un processus a un I<masque de signaux> indépendant, qui indique l'ensemble des signaux bloqués par le thread. Un thread peut modifier son masque de signaux avec B<pthread_sigmask>(3). Dans une application traditionnelle, à un seul thread, B<sigprocmask>(2) peut être utilisée pour modifier le masque de signaux.

note: type: Plain text
en: A child created via B<fork>(2)  inherits a copy of its parent's signal mask; the signal mask is preserved across B<execve>(2).
fr: Un processus fils créé avec B<fork>(2) hérite d'une copie du masque de signaux de son père ; le masque de signaux est conservé au travers d'un B<execve>(2).

note: type: Plain text
en: A signal may be generated (and thus pending)  for a process as a whole (e.g., when sent using B<kill>(2))  or for a specific thread (e.g., certain signals, such as B<SIGSEGV> and B<SIGFPE>, generated as a consequence of executing a specific machine-language instruction are thread directed, as are signals targeted at a specific thread using B<pthread_kill>(3)).  A process-directed signal may be delivered to any one of the threads that does not currently have the signal blocked.  If more than one of the threads has the signal unblocked, then the kernel chooses an arbitrary thread to which to deliver the signal.
fr: Un signal peut être créé (et donc mis en attente) pour un processus dans son ensemble (par exemple avec B<kill>(2)), ou pour un thread en particulier (par exemple, certains signaux comme B<SIGSEGV> et B<SIGFPE> sont générés suite à une instruction particulière en langage machine, et sont dirigés vers un thread, de même que les signaux envoyés avec B<pthread_kill>(3)). Un signal envoyé à un processus peut être traité par n'importe lequel des threads qui ne le bloquent pas. Si plus d'un thread ne bloque pas le signal, le noyau choisit l'un de ces threads arbitrairement, et lui envoie le signal.

note: type: Plain text
en: A thread can obtain the set of signals that it currently has pending using B<sigpending>(2).  This set will consist of the union of the set of pending process-directed signals and the set of signals pending for the calling thread.
fr: Un thread peut obtenir l'ensemble des signaux en attente avec B<sigpending>(2). Cet ensemble est l'union des signaux en attente envoyés au processus, et de ceux en attente pour le thread appelant.

note: type: Plain text
en: A child created via B<fork>(2)  initially has an empty pending signal set; the pending signal set is preserved across an B<execve>(2).
fr: Un fils créé avec B<fork>(2) démarre avec un ensemble de signaux en attente vide ; l'ensemble de signaux en attente est conservé au travers d'un B<execve>(2).

note: type: SS
en: Standard signals
fr: Signaux standards

note: type: Plain text
en: Linux supports the standard signals listed below.  Several signal numbers are architecture-dependent, as indicated in the "Value" column.  (Where three values are given, the first one is usually valid for alpha and sparc, the middle one for x86, arm, and most other architectures, and the last one for mips.  (Values for parisc are I<not> shown; see the Linux kernel source for signal numbering on that architecture.)  A - denotes that a signal is absent on the corresponding architecture.)
fr: Linux prend en charge les signaux standards indiqués ci-dessous. Plusieurs d'entre eux dépendent de l'architecture, comme on le voit dans la colonne «\ Valeur\ ». Lorsque trois valeurs sont indiquées, la première correspond normalement aux architectures Alpha et Sparc, la seconde aux architectures x86, Arm, ainsi que la majorité des autres architectures, et la dernière aux Mips. (Les valeurs pour l'architecture Parisc I<ne> sont I<pas> indiquées ; consultez les sources du noyau Linux pour la numérotation des signaux sur cette architecture.) Un «\ -\ » dénote un signal absent pour l'architecture correspondante.

note: type: Plain text
en: First the signals described in the original POSIX.1-1990 standard.
fr: Voici tout d'abord les signaux décrits dans le standard POSIX.1-1990 original\ :

note: type: tbl table
en: Signal	Value	Action	Comment
fr: Signal	Valeur	Action	Commentaire

note: type: tbl table
en: SIGHUP	\01	Term	Hangup detected on controlling terminal
fr: SIGHUP	\01	Term	Déconnexion détectée sur le terminal

note: type: tbl table
en: 			or death of controlling process
fr: 			de contrôle ou mort du processus de
    			contrôle.

note: type: tbl table
en: SIGINT	\02	Term	Interrupt from keyboard
fr: SIGINT	\02	Term	Interruption depuis le clavier.

note: type: tbl table
en: SIGQUIT	\03	Core	Quit from keyboard
fr: SIGQUIT	\03	Core	Demande «\ Quitter\ » depuis le clavier.

note: type: tbl table
en: SIGILL	\04	Core	Illegal Instruction
fr: SIGILL	\04	Core	Instruction illégale.

note: type: tbl table
en: SIGABRT	\06	Core	Abort signal from B<abort>(3)
fr: SIGABRT	\06	Core	Signal d'arrêt depuis B<abort>(3).

note: type: tbl table
en: SIGFPE	\08	Core	Floating point exception
fr: SIGFPE	\08	Core	Erreur mathématique virgule flottante.

note: type: tbl table
en: SIGKILL	\09	Term	Kill signal
fr: SIGKILL	\09	Term	Signal «\ KILL\ ».

note: type: tbl table
en: SIGSEGV	11	Core	Invalid memory reference
fr: SIGSEGV	11	Core	Référence mémoire invalide.

note: type: tbl table
en: SIGPIPE	13	Term	Broken pipe: write to pipe with no
fr: SIGPIPE	13	Term	Écriture dans un tube sans

note: type: tbl table
en: 			readers
fr: 			lecteur.

note: type: tbl table
en: SIGALRM	14	Term	Timer signal from B<alarm>(2)
fr: SIGALRM	14	Term	Temporisation B<alarm>(2) écoulée.

note: type: tbl table
en: SIGTERM	15	Term	Termination signal
fr: SIGTERM	15	Term	Signal de fin.

note: type: tbl table
en: SIGUSR1	30,10,16	Term	User-defined signal 1
fr: SIGUSR1	30,10,16	Term	Signal utilisateur 1.

note: type: tbl table
en: SIGUSR2	31,12,17	Term	User-defined signal 2
fr: SIGUSR2	31,12,17	Term	Signal utilisateur 2.

note: type: tbl table
en: SIGCHLD	20,17,18	Ign	Child stopped or terminated
fr: SIGCHLD	20,17,18	Ign	Fils arrêté ou terminé.

note: type: tbl table
en: SIGCONT	19,18,25	Cont	Continue if stopped
fr: SIGCONT	19,18,25	Cont	Continuer si arrêté.

note: type: tbl table
en: SIGSTOP	17,19,23	Stop	Stop process
fr: SIGSTOP	17,19,23	Stop	Arrêt du processus.

note: type: tbl table
en: SIGTSTP	18,20,24	Stop	Stop typed at terminal
fr: SIGTSTP	18,20,24	Stop	Stop invoqué depuis le terminal.

note: type: tbl table
en: SIGTTIN	21,21,26	Stop	Terminal input for background process
fr: SIGTTIN	21,21,26	Stop	Lecture sur le terminal en arrière-plan.

note: type: tbl table
en: SIGTTOU	22,22,27	Stop	Terminal output for background process
fr: SIGTTOU	22,22,27	Stop	Écriture dans le terminal en arrière-plan.

note: type: Plain text
en: The signals B<SIGKILL> and B<SIGSTOP> cannot be caught, blocked, or ignored.
fr: Les signaux B<SIGKILL> et B<SIGSTOP> ne peuvent ni capturés ni ignorés.

note: type: Plain text
en: Next the signals not in the POSIX.1-1990 standard but described in SUSv2 and POSIX.1-2001.
fr: Ensuite, les signaux non décrits par POSIX.1-1990, mais présents dans les spécifications SUSv2 et POSIX.1-2001\ :

note: type: tbl table
en: SIGBUS	10,7,10	Core	Bus error (bad memory access)
fr: SIGBUS	10,7,10	Core	Erreur de bus (mauvais accès mémoire).

note: type: tbl table
en: SIGPOLL		Term	Pollable event (Sys V).
fr: SIGPOLL		Term	Événement «\ pollable\ » (System V).

note: type: tbl table
en: 			Synonym for B<SIGIO>
fr: 			Synonyme de B<SIGIO>.

note: type: tbl table
en: SIGPROF	27,27,29	Term	Profiling timer expired
fr: SIGPROF	27,27,29	Term	Expiration de la temporisation
    			pour le suivi.

note: type: tbl table
en: SIGSYS	12,31,12	Core	Bad argument to routine (SVr4)
fr: SIGSYS	12,31,12	Core	Mauvais argument de fonction (SVr4).

note: type: tbl table
en: SIGTRAP	5	Core	Trace/breakpoint trap
fr: SIGTRAP	5	Core	Point d'arrêt rencontré.

note: type: tbl table
en: SIGURG	16,23,21	Ign	Urgent condition on socket (4.2BSD)
fr: SIGURG	16,23,21	Ign	Condition urgente sur socket (BSD\ 4.2).

note: type: tbl table
en: SIGVTALRM	26,26,28	Term	Virtual alarm clock (4.2BSD)
fr: SIGVTALRM	26,26,28	Term	Alarme virtuelle (BSD\ 4.2).

note: type: tbl table
en: SIGXCPU	24,24,30	Core	CPU time limit exceeded (4.2BSD)
fr: SIGXCPU	24,24,30	Core	Limite de temps CPU dépassée (BSD\ 4.2).

note: type: tbl table
en: SIGXFSZ	25,25,31	Core	File size limit exceeded (4.2BSD)
fr: SIGXFSZ	25,25,31	Core	Taille de fichier excessive (BSD\ 4.2).

note: type: Plain text
en: Up to and including Linux 2.2, the default behavior for B<SIGSYS>, B<SIGXCPU>, B<SIGXFSZ>, and (on architectures other than SPARC and MIPS)  B<SIGBUS> was to terminate the process (without a core dump).  (On some other UNIX systems the default action for B<SIGXCPU> and B<SIGXFSZ> is to terminate the process without a core dump.)  Linux 2.4 conforms to the POSIX.1-2001 requirements for these signals, terminating the process with a core dump.
fr: Jusqu'à Linux 2.2 inclus, l'action par défaut pour B<SIGSYS>, B<SIGXCPU>, B<SIGXFSZ> et (sur les architectures autres que Sparc ou Mips) B<SIGBUS> était de terminer simplement le processus, sans fichier core. (Sur certains UNIX, l'action par défaut pour B<SIGXCPU> et B<SIGXFSZ> est de finir le processus sans fichier core). Linux 2.4 se conforme à POSIX.1-2001 pour ces signaux et termine le processus avec un fichier core.

note: type: Plain text
en: Next various other signals.
fr: Puis quelques signaux divers\ :

note: type: tbl table
en: SIGIOT	6	Core	IOT trap. A synonym for B<SIGABRT>
fr: SIGIOT	6	Core	Arrêt IOT. Un synonyme de B<SIGABRT>.

note: type: tbl table
en: SIGSTKFLT	-,16,-	Term	Stack fault on coprocessor (unused)
fr: SIGSTKFLT	-,16,-	Term	T{
    Erreur de pile sur coprocesseur (inutilisé).
    T}

note: type: tbl table
en: SIGIO	23,29,22	Term	I/O now possible (4.2BSD)
fr: SIGIO	23,29,22	Term	E/S à nouveau possible(BSD\ 4.2).

note: type: tbl table
en: SIGCLD	-,-,18	Ign	A synonym for B<SIGCHLD>
fr: SIGCLD	-,-,18	Ign	Synonyme de B<SIGCHLD>.

note: type: tbl table
en: SIGPWR	29,30,19	Term	Power failure (System V)
fr: SIGPWR	29,30,19	Term	Chute d'alimentation (System V).

note: type: tbl table
en: SIGINFO	29,-,-		A synonym for B<SIGPWR>
fr: SIGINFO	29,-,-		Synonyme de B<SIGPWR>.

note: type: tbl table
en: SIGLOST	-,-,-	Term	File lock lost (unused)
fr: SIGLOST	-,-,-	Term	Perte de verrou de fichier (inusité).

note: type: tbl table
en: SIGWINCH	28,28,20	Ign	Window resize signal (4.3BSD, Sun)
fr: SIGWINCH	28,28,20	Ign	Fenêtre redimensionnée (BSD\ 4.3, Sun).

note: type: tbl table
en: SIGUNUSED	-,31,-	Core	Synonymous with B<SIGSYS>
fr: SIGUNUSED	-,31,-	Core	Synonyme de B<SIGSYS>

note: type: Plain text
en: (Signal 29 is B<SIGINFO> / B<SIGPWR> on an alpha but B<SIGLOST> on a sparc.)
fr: (Le signal 29 est B<SIGINFO> / B<SIGPWR> sur Alpha mais B<SIGLOST> sur Sparc).

note: type: Plain text
en: B<SIGEMT> is not specified in POSIX.1-2001, but nevertheless appears on most other UNIX systems, where its default action is typically to terminate the process with a core dump.
fr: B<SIGEMT> n'est pas spécifié par POSIX.1-2001 mais apparaît néanmoins sur la plupart des UNIX, avec une action par défaut typique correspondant à une fin du processus avec fichier core.

note: type: Plain text
en: B<SIGPWR> (which is not specified in POSIX.1-2001) is typically ignored by default on those other UNIX systems where it appears.
fr: B<SIGPWR> (non spécifié dans POSIX.1-2001) est typiquement ignoré sur les autres UNIX où il apparaît.

note: type: Plain text
en: B<SIGIO> (which is not specified in POSIX.1-2001) is ignored by default on several other UNIX systems.
fr: B<SIGIO> (non sécifié par POSIX.1-2001) est ignoré par défaut sur plusieurs autres systèmes UNIX.

note: parisc is the only exception: SIGSYS is 12, SIGUNUSED is 31 type: Plain text
en: Where defined, B<SIGUNUSED> is synonymous with B<SIGSYS> on most architectures.
fr: Si défini, B<SIGUNUSED> est synonyme de B<SIGSYS> sur la plupart des architectures.

note: type: SS
en: Real-time signals
fr: Signaux temps-réel

note: type: Plain text
en: Linux supports real-time signals as originally defined in the POSIX.1b real-time extensions (and now included in POSIX.1-2001).  The range of supported real-time signals is defined by the macros B<SIGRTMIN> and B<SIGRTMAX>.  POSIX.1-2001 requires that an implementation support at least B<_POSIX_RTSIG_MAX> (8) real-time signals.
fr: Linux prend en charge les signaux temps-réel tels qu'ils ont été définis à l'origine dans les extensions temps-réel POSIX.1b (et inclus à présent dans POSIX.1-2001). L'intervalle des signaux temps-réels gérés est défini par les macros B<SIGRTMIN> et B<SIGRTMAX>. POSIX.1-2001 exige qu'une implémentation gère au moins B<_POSIX_RTSIG_MAX> (8) signaux temps-réels.

note: type: Plain text
en: The Linux kernel supports a range of 32 different real-time signals, numbered 33 to 64.  However, the glibc POSIX threads implementation internally uses two (for NPTL) or three (for LinuxThreads) real-time signals (see B<pthreads>(7)), and adjusts the value of B<SIGRTMIN> suitably (to 34 or 35).  Because the range of available real-time signals varies according to the glibc threading implementation (and this variation can occur at run time according to the available kernel and glibc), and indeed the range of real-time signals varies across UNIX systems, programs should I<never refer to real-time signals using hard-coded numbers>, but instead should always refer to real-time signals using the notation B<SIGRTMIN>+n, and include suitable (run-time) checks that B<SIGRTMIN>+n does not exceed B<SIGRTMAX>.
fr: Le noyau Linux gère une gamme de 32 signaux temps-réel, numérotés de 33 à 64. Cependant, l'implémentation des threads POSIX de la glibc utilise en interne deux (pour l'implémentation NPTL) ou trois (pour l'implémentation LinuxThreads) signaux temps-réel (consultez B<pthreads>(7)) et ajuste la valeur de B<SIGRTMIN> en conséquence (à 34 ou 35). Comme la gamme de signaux temps-réel varie en fonction de l'implémentation des threads par la glibc (et cette implémentation peut changer à l'exécution en fonction du noyau et de la glibc) et que la gamme de signaux temps-réel varie bien sûr également suivant les systèmes UNIX, les programmes ne devraient I<jamais faire référence à des signaux temps-réel en utilisant des numéros>, mais devraient toujours à la place utiliser des signaux temps-réel avec la notation B<SIGRTMIN>+n en vérifiant à l'exécution que B<SIGRTMIN>+n ne dépasse pas B<SIGRTMAX>.

note: type: Plain text
en: Unlike standard signals, real-time signals have no predefined meanings: the entire set of real-time signals can be used for application-defined purposes.
fr: Contrairement aux signaux standards, les signaux temps-réel n'ont pas de signification prédéfinie\ : l'ensemble complet de ces signaux peut être utilisé à des fins spécifiques à l'application.

note: type: Plain text
en: The default action for an unhandled real-time signal is to terminate the receiving process.
fr: L'action par défaut pour un signal temps-réel non capturé est de terminer le processus récepteur.

note: type: Plain text
en: Real-time signals are distinguished by the following:
fr: Les signaux temps-réel se distinguent de leurs homologues classiques ainsi\ :

note: type: Plain text
en: Multiple instances of real-time signals can be queued.  By contrast, if multiple instances of a standard signal are delivered while that signal is currently blocked, then only one instance is queued.
fr: Plusieurs instances d'un signal temps-réel peuvent être empilées. Au contraire, si plusieurs instances d'un signal standard arrivent alors qu'il est bloqué, une seule instance sera mémorisée.

note: type: Plain text
en: If the signal is sent using B<sigqueue>(3), an accompanying value (either an integer or a pointer) can be sent with the signal.  If the receiving process establishes a handler for this signal using the B<SA_SIGINFO> flag to B<sigaction>(2), then it can obtain this data via the I<si_value> field of the I<siginfo_t> structure passed as the second argument to the handler.  Furthermore, the I<si_pid> and I<si_uid> fields of this structure can be used to obtain the PID and real user ID of the process sending the signal.
fr: Si le signal est envoyé en utilisant B<sigqueue>(3), il peut être accompagné d'une valeur (un entier ou un pointeur). Si le processus récepteur positionne un gestionnaire en utilisant l'attribut B<SA_SIGINFO> de l'appel B<sigaction>(2) alors il peut accéder à la valeur transmise dans le champ I<si_value> de la structure I<siginfo_t> passée en second argument au gestionnaire. De plus, les champs I<si_pid> et I<si_uid> de cette structure fournissent le PID et l'UID réel du processus émetteur.

note: type: Plain text
en: Real-time signals are delivered in a guaranteed order.  Multiple real-time signals of the same type are delivered in the order they were sent.  If different real-time signals are sent to a process, they are delivered starting with the lowest-numbered signal.  (I.e., low-numbered signals have highest priority.)  By contrast, if multiple standard signals are pending for a process, the order in which they are delivered is unspecified.
fr: Les signaux temps-réel sont délivrés dans un ordre précis. Les divers signaux temps-réel du même type sont délivrés dans l'ordre où ils ont été émis. Si différents signaux temps-réel sont envoyés au processus, ils sont délivrés en commençant par le signal de numéro le moins élevé (le signal de plus fort numéro est celui de priorité la plus faible). Par contre, si plusieurs signaux standards sont en attente dans un processus, l'ordre dans lequel ils sont délivrés n'est pas défini.

note: type: Plain text
en: If both standard and real-time signals are pending for a process, POSIX leaves it unspecified which is delivered first.  Linux, like many other implementations, gives priority to standard signals in this case.
fr: Si des signaux standards et des signaux temps-réel sont simultanément en attente pour un processus, Posix ne précise pas d'ordre de délivrance. Linux, comme beaucoup d'autres implémentations, donne priorité aux signaux temps-réel dans ce cas.

note: type: Plain text
en: According to POSIX, an implementation should permit at least B<_POSIX_SIGQUEUE_MAX> (32) real-time signals to be queued to a process.  However, Linux does things differently.  In kernels up to and including 2.6.7, Linux imposes a system-wide limit on the number of queued real-time signals for all processes.  This limit can be viewed and (with privilege) changed via the I</proc/sys/kernel/rtsig-max> file.  A related file, I</proc/sys/kernel/rtsig-nr>, can be used to find out how many real-time signals are currently queued.  In Linux 2.6.8, these I</proc> interfaces were replaced by the B<RLIMIT_SIGPENDING> resource limit, which specifies a per-user limit for queued signals; see B<setrlimit>(2)  for further details.
fr: D'après POSIX, une implémentation doit permettre l'empilement d'au moins B<_POSIX_SIGQUEUE_MAX> (32) signaux temps-réel pour un processus. Néanmoins, Linux fonctionne différemment. Jusqu'au noyau 2.6.7 inclus, Linux impose une limite pour l'ensemble des signaux empilés sur le système pour tous les processus. Cette limite peut être consultée, et modifiée (avec les privilèges adéquats) grâce au fichier I</proc/sys/kernel/rtsig-max>. Un fichier associé, I</proc/sys/kernel/rtsig-nr>, indique combien de signaux temps-réel sont actuellement empilés. Dans Linux 2.6.8, ces interfaces I</proc> ont été remplacées par la limite de ressources B<RLIMIT_SIGPENDING>, qui spécifie une limite par utilisateur pour les signaux empilés\ ; voir B<setrlimit>(2) pour plus de détails.

note: type: SS
en: Async-signal-safe functions
fr: Fonctions pour signaux sûr asynchrones

note: type: Plain text
en: A signal handler function must be very careful, since processing elsewhere may be interrupted at some arbitrary point in the execution of the program.  POSIX has the concept of "safe function".  If a signal interrupts the execution of an unsafe function, and I<handler> calls an unsafe function, then the behavior of the program is undefined.
fr: Un gestionnaire de signal doit prendre beaucoup de précautions, puisqu'il peut interrompre à n'importe quel endroit l'exécution du programme. POSIX possède la notion de « fonctions sûres ». Si un signal interrompt l'exécution d'une fonction non sûre, et que le I<gestionnaire> appelle une fonction non sûre, alors le comportement du programme n'est pas défini.

note: type: Plain text
en: POSIX.1-2004 (also known as POSIX.1-2001 Technical Corrigendum 2)  requires an implementation to guarantee that the following functions can be safely called inside a signal handler:
fr: POSIX.1-2004 (également appelée « POSIX.1-2001 Technical Corrigendum 2 ») impose qu'une implémentation garantisse que les fonctions suivantes puissent être appelée sans risque à l'intérieur d'un gestionnaire de signal :

note: type: Plain text
en: POSIX.1-2008 removes fpathconf(), pathconf(), and sysconf()  from the above list, and adds the following functions:
fr: POSIX.1-2008 supprime fpathconf(), pathconf() et sysconf() de la liste ci-dessus et ajoute les fonctions suivantes :

note: type: SS
en: Interruption of system calls and library functions by signal handlers
fr: Interruption des appels système et des fonctions de bibliothèque par des gestionnaires de signal

note: type: Plain text
en: If a signal handler is invoked while a system call or library function call is blocked, then either:
fr: Si un gestionnaire de signal est invoqué pendant qu'un appel système ou une fonction de bibliothèque est bloqué, alors :

note: type: Plain text
en: the call is automatically restarted after the signal handler returns; or
fr: soit l'appel est automatiquement redémarré après le retour du gestionnaire de signal ;

note: type: Plain text
en: the call fails with the error B<EINTR>.
fr: soit l'appel échoue avec l'erreur B<EINTR>.

note: type: Plain text
en: Which of these two behaviors occurs depends on the interface and whether or not the signal handler was established using the B<SA_RESTART> flag (see B<sigaction>(2)).  The details vary across UNIX systems; below, the details for Linux.
fr: Lequel de ces deux comportements se produira dépend de l'interface et de si le gestionnaire de signal a été mis en place avec l'attribut B<SA_RESTART> (consultez B<sigaction>(2)). Les détails varient selon les systèmes UNIX ; voici ceux pour Linux.

note: The following system calls use ERESTARTSYS, so that they are restartable type: Plain text
en: If a blocked call to one of the following interfaces is interrupted by a signal handler, then the call will be automatically restarted after the signal handler returns if the B<SA_RESTART> flag was used; otherwise the call will fail with the error B<EINTR>:
fr: Si un appel bloqué à l'une des interfaces suivantes est interrompu par un gestionnaire de signal, l'appel sera automatiquement redémarré après le retour du gestionnaire de signal si l'attribut B<SA_RESTART> a été indiqué ; autrement, l'appel échouera avec l'erreur B<EINTR> :

note: type: Plain text
en: B<read>(2), B<readv>(2), B<write>(2), B<writev>(2), and B<ioctl>(2)  calls on "slow" devices.  A "slow" device is one where the I/O call may block for an indefinite time, for example, a terminal, pipe, or socket.  (A disk is not a slow device according to this definition.)  If an I/O call on a slow device has already transferred some data by the time it is interrupted by a signal handler, then the call will return a success status (normally, the number of bytes transferred).
fr: Les appels B<read>(2), B<readv>(2), B<write>(2), B<writev>(2) et B<ioctl>(2) sur des périphériques « lents ». Un périphérique « lent » est un périphérique où un appel d'entrées-sorties peut bloquer pendant un temps infini, par exemple un terminal, un tube ou une socket. (Selon cette définition, un disque n'est pas un périphérique lent.) Si un appel d'entrées-sorties sur un périphérique lent a déjà transféré des données au moment où il est interrompu par un gestionnaire de signal, l'appel renverra un code de succès (normalement, le nombre d'octets transférés).

note: type: Plain text
en: B<open>(2), if it can block (e.g., when opening a FIFO; see B<fifo>(7)).
fr: B<open >(2), s'il peut bloquer (par exemple, lors de l'ouverture d'une FIFO ; consultez B<fifo>(7)).

note: type: Plain text
en: B<wait>(2), B<wait3>(2), B<wait4>(2), B<waitid>(2), and B<waitpid>(2).
fr: B<wait>(2), B<wait3>(2), B<wait4>(2), B<waitid>(2), et B<waitpid>(2).

note: If a timeout (setsockopt()) is in effect on the socket, then these system calls switch to using EINTR.  Consequently, they and are not automatically restarted, and they show the stop/cont behavior described below.  (Verified from 2.6.26 source, and by experiment; mtk) type: Plain text
en: Socket interfaces: B<accept>(2), B<connect>(2), B<recv>(2), B<recvfrom>(2), B<recvmsg>(2), B<send>(2), B<sendto>(2), and B<sendmsg>(2), unless a timeout has been set on the socket (see below).
fr: Interfaces de sockets : B<accept>(2), B<connect>(2), B<recv>(2), B<recvfrom>(2), B<recvmsg>(2), B<send>(2), B<sendto>(2) et B<sendmsg>(2), à moins qu'une temporisation n'ai été placée sur la socket (voir ci-dessous).

note: type: Plain text
en: File locking interfaces: B<flock>(2)  and B<fcntl>(2)  B<F_SETLKW>.
fr: Interfaces de verrouillage de fichiers : opération B<F_SETLKW> de B<flock>(2) et B<fcntl>(2).

note: type: Plain text
en: POSIX message queue interfaces: B<mq_receive>(3), B<mq_timedreceive>(3), B<mq_send>(3), and B<mq_timedsend>(3).
fr: Interfaces de files de messages POSIX : B<mq_receive>(3), B<mq_timedreceive>(3), B<mq_send>(3) et B<mq_timedsend>(3).

note: type: Plain text
en: B<futex>(2)  B<FUTEX_WAIT> (since Linux 2.6.22; beforehand, always failed with B<EINTR>).
fr: Opération B<FUTEX_WAIT> de B<futex>(2) (depuis Linux 2.6.22 ; auparavant, échouait toujours avec l'erreur B<EINTR>).

note: type: Plain text
en: POSIX semaphore interfaces: B<sem_wait>(3)  and B<sem_timedwait>(3)  (since Linux 2.6.22; beforehand, always failed with B<EINTR>).
fr: Interfaces de sémaphores POSIX : B<sem_wait>(3) et B<sem_timedwait>(3) (depuis Linux 2.6.22 ; auparavant, échouait toujours avec l'erreur B<EINTR>).

note: These are the system calls that give EINTR or ERESTARTNOHAND on interruption by a signal handler. type: Plain text
en: The following interfaces are never restarted after being interrupted by a signal handler, regardless of the use of B<SA_RESTART>; they always fail with the error B<EINTR> when interrupted by a signal handler:
fr: Les interfaces suivantes ne sont jamais relancées après avoir été interrompues par un gestionnaire de signal, quelle que soit l'utilisation de B<SA_RESTART> ; elles échouent toujours avec l'erreur B<EINTR> lorsqu'elles sont interrompues par un gestionnaire de signal :

note: type: Plain text
en: Socket interfaces, when a timeout has been set on the socket using B<setsockopt>(2): B<accept>(2), B<recv>(2), B<recvfrom>(2), and B<recvmsg>(2), if a receive timeout (B<SO_RCVTIMEO>)  has been set; B<connect>(2), B<send>(2), B<sendto>(2), and B<sendmsg>(2), if a send timeout (B<SO_SNDTIMEO>)  has been set.
fr: Les interfaces de socket, quand une temporisation a été définie sur la socket en utilisant B<setsockopt>(2) ; B<accept>(2), B<recv>(2), B<recvfrom>(2) et B<recvmsg>(2), si un délai de réception (B<SO_RCVTIMEO>) a été défini ; B<connect>(2), B<send>(2), B<sendto>(2) et B<sendmsg>(2), si un délai de transmission (B<SO_SNDTIMEO>) a été défini.

note: type: Plain text
en: Interfaces used to wait for signals: B<pause>(2), B<sigsuspend>(2), B<sigtimedwait>(2), and B<sigwaitinfo>(2).
fr: Interfaces utilisées pour attendre des signaux : B<pause>(2), B<sigsuspend>(2), B<sigtimedwait>(2) et B<sigwaitinfo>(2).

note: type: Plain text
en: File descriptor multiplexing interfaces: B<epoll_wait>(2), B<epoll_pwait>(2), B<poll>(2), B<ppoll>(2), B<select>(2), and B<pselect>(2).
fr: Interfaces de multiplexage de descripteurs de fichier : B<epoll_wait>(2), B<epoll_pwait>(2), B<poll>(2), B<ppoll>(2), B<select>(2) et B<pselect>(2).

note: On some other systems, SA_RESTART does restart these system calls type: Plain text
en: System V IPC interfaces: B<msgrcv>(2), B<msgsnd>(2), B<semop>(2), and B<semtimedop>(2).
fr: Interfaces IPC de System V : B<msgrcv>(2), B<msgsnd>(2), B<semop>(2) et B<semtimedop>(2).

note: type: Plain text
en: Sleep interfaces: B<clock_nanosleep>(2), B<nanosleep>(2), and B<usleep>(3).
fr: Interfaces de sommeil : B<clock_nanosleep>(2), B<nanosleep>(2) et B<usleep>(3).

note: type: Plain text
en: B<read>(2)  from an B<inotify>(7)  file descriptor.
fr: B<read>(2) sur un descripteur de fichier B<inotify>(7).

note: type: Plain text
en: The B<sleep>(3)  function is also never restarted if interrupted by a handler, but gives a success return: the number of seconds remaining to sleep.
fr: La fonction B<sleep>(3) n'est également jamais relancée si elle est interrompue par un gestionnaire, mais elle renvoie un code de retour de succès, le nombre de secondes restantes pour le sommeil.

note: type: SS
en: Interruption of system calls and library functions by stop signals
fr: Interruption des appels système et des fonctions de bibliothèque par des signaux d'arrêt

note: type: Plain text
en: On Linux, even in the absence of signal handlers, certain blocking interfaces can fail with the error B<EINTR> after the process is stopped by one of the stop signals and then resumed via B<SIGCONT>.  This behavior is not sanctioned by POSIX.1, and doesn't occur on other systems.
fr: Sous Linux, même en l'absence de gestionnaires de signal, certaines interfaces en mode bloquant peuvent échouer avec l'erreur B<EINTR> après que le processus a été arrêté par l'un des signaux d'arrêt et relancé avec le signal B<SIGCONT>. Ce comportement n'est pas ratifié par POSIX.1 et n'apparaît pas sur d'autres systèmes.

note: type: Plain text
en: The Linux interfaces that display this behavior are:
fr: Les interfaces Linux qui affichent ce comportement sont :

note: type: Plain text
en: Linux 2.6.21 and earlier: B<futex>(2)  B<FUTEX_WAIT>, B<sem_timedwait>(3), B<sem_wait>(3).
fr: Linux 2.6.21 et antérieurs : opération B<FUTEX_WAIT> de B<futex>(2), B<sem_timedwait>(3), B<sem_wait>(3).

note: type: Plain text
en: Linux 2.6.8 and earlier: B<msgrcv>(2), B<msgsnd>(2).
fr: Linux 2.6.8 et antérieurs : B<msgrcv>(2), B<msgsnd>(2).

note: type: Plain text
en: Linux 2.4 and earlier: B<nanosleep>(2).
fr: Linux 2.4 et antérieurs : B<nanosleep>(2).

note: It must be a *very* long time since this was true: .SH BUGS .B SIGIO and .B SIGLOST have the same value. The latter is commented out in the kernel source, but the build process of some software still thinks that signal 29 is .BR SIGLOST . type: Plain text
en: POSIX.1, except as noted.
fr: POSIX.1, sauf indication contraire.

note: type: TH
en: 2009-01-13
fr: 13 janvier 2009

note: type: Plain text
en: signalfd - create a file descriptor for accepting signals
fr: signalfd - Créer un descripteur de fichier pour accepter des signaux

note: type: Plain text
en: B<signalfd>()  creates a file descriptor that can be used to accept signals targeted at the caller.  This provides an alternative to the use of a signal handler or B<sigwaitinfo>(2), and has the advantage that the file descriptor may be monitored by B<select>(2), B<poll>(2), and B<epoll>(7).
fr: B<signalfd>() crée un descripteur de fichier qui peut être utilisé pour accepter des signaux à destination de l'appelant. Ceci fournit une alternative à l'utilisation d'un gestionnaire de signal ou de B<sigwaitinfo>(2), et a l'avantage que le descripteur de fichier peut être surveillé avec B<select>(2), B<poll>(2) ou B<epoll>(7).

note: type: Plain text
en: The I<mask> argument specifies the set of signals that the caller wishes to accept via the file descriptor.  This argument is a signal set whose contents can be initialized using the macros described in B<sigsetops>(3).  Normally, the set of signals to be received via the file descriptor should be blocked using B<sigprocmask>(2), to prevent the signals being handled according to their default dispositions.  It is not possible to receive B<SIGKILL> or B<SIGSTOP> signals via a signalfd file descriptor; these signals are silently ignored if specified in I<mask>.
fr: Le paramètre I<mask> spécifie l'ensemble des signaux que l'appelant veut accepter par le descripteur de fichier. Ce paramètre est un ensemble de signaux dont le contenu peut être initialisé en utilisant les macros décrites dans B<sigsetops>(3). Normalement, l'ensemble des signaux reçus par le descripteur de fichier devrait être bloqués en utilisant B<sigprocmask>(2) pour éviter que les signaux soient pris en charge par les gestionnaires par défaut. Il n'est pas possible de recevoir les signaux B<SIGKILL> ou B<SIGSTOP> par un descripteur de fichier signalfd ; ces signaux sont ignorés sans rien dire s'ils sont spécifiés dans I<mask>.

note: type: Plain text
en: If the I<fd> argument is -1, then the call creates a new file descriptor and associates the signal set specified in I<mask> with that descriptor.  If I<fd> is not -1, then it must specify a valid existing signalfd file descriptor, and I<mask> is used to replace the signal set associated with that descriptor.
fr: Si le paramètre I<fd> vaut -1, l'appel crée un nouveau descripteur de fichier et associe l'ensemble des signaux spécifiés dans I<mask> avec ce descripteur. Si I<fd> ne vaut pas -1, alors il doit indiquer un descripteur de fichier signalfd existant valable, et I<mask> est utilisé pour remplacer l'ensemble des signaux associés avec ce descripteur.

note: type: Plain text
en: Starting with Linux 2.6.27, the following values may be bitwise ORed in I<flags> to change the behaviour of B<signalfd>():
fr: À partir de Linux 2.6.27, les valeurs suivantes peuvent être incluses avec un OU binaire dans I<flags> pour changer le comportement de B<signalfd>() :

note: type: Plain text
en: B<signalfd>()  returns a file descriptor that supports the following operations:
fr: B<signalfd>() renvoie un descripteur de fichier qui gère les opérations suivantes :

note: type: Plain text
en: If one or more of the signals specified in I<mask> is pending for the process, then the buffer supplied to B<read>(2)  is used to return one or more I<signalfd_siginfo> structures (see below) that describe the signals.  The B<read>(2)  returns information for as many signals as are pending and will fit in the supplied buffer.  The buffer must be at least I<sizeof(struct signalfd_siginfo)> bytes.  The return value of the B<read>(2)  is the total number of bytes read.
fr: Si un (ou plus) des signaux spécifiés dans I<mask> est en attente pour le processus, alors le tampon fourni à B<read>(2) est utilisé pour renvoyer une structure (ou plus) de type I<signalfd_siginfo> (voir ci-dessous) qui décrit les signaux. B<read>(2) renvoie les informations pour tous les signaux qui sont en attente et qui tiennent dans le tampon fourni. Le tampon doit avoir une taille d'au moins I<sizeof(struct signalfd_siginfo)> octets. La valeur de retour de B<read>(2) est égale au nombre total d'octets lus.

note: type: Plain text
en: As a consequence of the B<read>(2), the signals are consumed, so that they are no longer pending for the process (i.e., will not be caught by signal handlers, and cannot be accepted using B<sigwaitinfo>(2)).
fr: En conséquence du B<read>(2), les signaux sont consommés, de telle sorte qu'ils ne seront plus en attente pour le processus (c'est-à-dire qu'ils ne seront plus attrapés par les gestionnaires de signaux, et ne seront plus acceptés par B<sigwaitinfo>(2)).

note: type: Plain text
en: If none of the signals in I<mask> is pending for the process, then the B<read>(2)  either blocks until one of the signals in I<mask> is generated for the process, or fails with the error B<EAGAIN> if the file descriptor has been made nonblocking.
fr: Si aucun des signaux de I<mask> ne sont en attente pour le processus, B<read>(2) sera bloquera jusqu'à ce qu'un des signaux de I<mask> soit généré pour le processus, ou échouera avec l'erreur B<EAGAIN> si le descripteur de fichier est en mode non bloquant.

note: type: Plain text
en: The file descriptor is readable (the B<select>(2)  I<readfds> argument; the B<poll>(2)  B<POLLIN> flag)  if one or more of the signals in I<mask> is pending for the process.
fr: Le descripteur de fichier est lisible (le paramètre I<readfds> de B<select>(2) ; l'attribut B<POLLIN> de B<poll>(2)) si un signal ou plus de I<mask> est en attente pour le processus.

note: type: Plain text
en: The signalfd file descriptor also supports the other file-descriptor multiplexing APIs: B<pselect>(2), B<ppoll>(2), and B<epoll>(7).
fr: Le descripteur de fichier signalfd gère également les autres interfaces de multiplexage de descripteurs de fichier : B<pselect>(2), B<ppoll>(2) et B<epoll>(7).

note: type: Plain text
en: When the file descriptor is no longer required it should be closed.  When all file descriptors associated with the same signalfd object have been closed, the resources for object are freed by the kernel.
fr: Quand le descripteur de fichier n'est plus nécessaire il doit être fermé. Quand tous les descripteurs de fichier associés au même objet signalfd ont été fermés, les ressources pour cet objet sont libérées par le noyau.

note: type: SS
en: The signalfd_siginfo structure
fr: La structure signalfd_siginfo

note: type: Plain text
en: The format of the I<signalfd_siginfo> structure(s) returned by B<read>(2)s from a signalfd file descriptor is as follows:
fr: Les structures I<signalfd_siginfo> renvoyées par B<read>(2) sur une descripteur de fichier signalfd sont au format suivant :

note: ssi_trapno is unused on most arches FIXME Since Linux 2.6.37 there is 'uint16_t ssi_addr_lsb' which is not yet documented type: Plain text
en: struct signalfd_siginfo {
        uint32_t ssi_signo;   /* Signal number */
        int32_t  ssi_errno;   /* Error number (unused) */
        int32_t  ssi_code;    /* Signal code */
        uint32_t ssi_pid;     /* PID of sender */
        uint32_t ssi_uid;     /* Real UID of sender */
        int32_t  ssi_fd;      /* File descriptor (SIGIO) */
        uint32_t ssi_tid;     /* Kernel timer ID (POSIX timers)
        uint32_t ssi_band;    /* Band event (SIGIO) */
        uint32_t ssi_overrun; /* POSIX timer overrun count */
        uint32_t ssi_trapno;  /* Trap number that caused signal */
        int32_t  ssi_status;  /* Exit status or signal (SIGCHLD) */
        int32_t  ssi_int;     /* Integer sent by sigqueue(3) */
        uint64_t ssi_ptr;     /* Pointer sent by sigqueue(3) */
        uint64_t ssi_utime;   /* User CPU time consumed (SIGCHLD) */
        uint64_t ssi_stime;   /* System CPU time consumed (SIGCHLD) */
        uint64_t ssi_addr;    /* Address that generated signal
                                 (for hardware-generated signals) */
        uint8_t  pad[I<X>];      /* Pad size to 128 bytes (allow for
                                  additional fields in the future) */
    };
fr: struct signalfd_siginfo {
        uint32_t ssi_signo;   /* Numéro de signal */
        int32_t  ssi_errno;   /* Numéro d'erreur (pas utilisé) */
        int32_t  ssi_code;    /* Code du signal */
        uint32_t ssi_pid;     /* PID de l'émetteur */
        uint32_t ssi_uid;     /* UID réel de l'émetteur */
        int32_t  ssi_fd;      /* Descripteur de fichier (SIGIO) */
        uint32_t ssi_tid;     /* Identifiant de la temporisation
                                 du noyau (timers POSIX) */
        uint32_t ssi_band;    /* Événement de bande (SIGIO) */
        uint32_t ssi_overrun; /* Compte des dépassements de la
                                 temporisation POSIX */
        uint32_t ssi_trapno;  /* Numéro de trappe ayant causé le signal */
        int32_t  ssi_status;  /* Code de sortie ou signal (SIGCHLD) */
        int32_t  ssi_int;     /* Entier envoyé par sigqueue(3) */
        uint64_t ssi_ptr      /* Pointeur envoyé par sigqueue(3) */
        uint64_t ssi_utime;   /* Temps CPU utilisateur consommé (SIGCHLD) */
        uint64_t ssi_stime;   /* Temps CPU système consommé (SIGCHLD) */
        uint64_t ssi_addr;    /* Adresse qui a généré le signal
                                 (pour les signaux issu du matériel) */
        uint8_t  pad[I<X>];      /* Remplissage jusqu'à 128 octets
                                 (espace prévu pour des champs
                                 supplémentaires futurs) */
    };

note: type: Plain text
en: Each of the fields in this structure is analogous to the similarly named field in the I<siginfo_t> structure.  The I<siginfo_t> structure is described in B<sigaction>(2).  Not all fields in the returned I<signalfd_siginfo> structure will be valid for a specific signal; the set of valid fields can be determined from the value returned in the I<ssi_code> field.  This field is the analog of the I<siginfo_t> I<si_code> field; see B<sigaction>(2)  for details.
fr: Chacun des champs de cette structure est analogue aux champs de noms similaires d'une structure I<siginfo_t>. La structure I<siginfo_t> est décrite dans B<sigaction>(2). Tous les champs de la structure I<signalfd_siginfo> renvoyée ne seront pas valable pour un signal donné ; l'ensemble des champs valables peut être déterminé grâce au champ I<ssi_code> de la valeur de retour. Ce champ est analogue au champ I<si_code> de I<siginfo_t> ; consultez B<sigaction>(2) pour plus de détails.

note: type: SS
en: fork(2) semantics
fr: Sémantique de fork(2)

note: type: Plain text
en: After a B<fork>(2), the child inherits a copy of the signalfd file descriptor.  A B<read>(2)  from the file descriptor in the child will return information about signals queued to the child.
fr: Après un B<fork>(2), le fils hérite d'une copie du descripteur de fichier signalfd. Un appel à B<read>(2) sur le descripteur de fichier depuis le fils en attente pour le fils.

note: type: SS
en: execve(2) semantics
fr: Sémantique de execve(2)

note: type: Plain text
en: Just like any other file descriptor, a signalfd file descriptor remains open across an B<execve>(2), unless it has been marked for close-on-exec (see B<fcntl>(2)).  Any signals that were available for reading before the B<execve>(2)  remain available to the newly loaded program.  (This is analogous to traditional signal semantics, where a blocked signal that is pending remains pending across an B<execve>(2).)
fr: Comme tout descripteur de fichier, un descripteur de fichier signalfd reste ouvert au travers d'un B<execve>(2), à moins qu'il ait été marqué comme « close-on-exec » (consultez B<fcntl>(2)). Tout signal qui était disponible en lecture avant un B<execve>(2) reste disponible pour le nouveau programme. (C'est analogue à la sémantique traditionnelle des signaux, pour laquelle un signal bloqué qui est en attente reste en attente au travers d'un B<execve>(2))

note: type: SS
en: Thread semantics
fr: Sémantique des threads

note: type: Plain text
en: The semantics of signalfd file descriptors in a multithreaded program mirror the standard semantics for signals.  In other words, when a thread reads from a signalfd file descriptor, it will read the signals that are directed to the thread itself and the signals that are directed to the process (i.e., the entire thread group).  (A thread will not be able to read signals that are directed to other threads in the process.)
fr: La sémantique des descripteurs de fichier signalfd dans un programme multithreadé copie la sémantique standard des signaux. En d'autres mots, quand un thread lit un descripteur de fichier signalfd, il lira les signaux qui sont envoyés pour le thread lui-même ou pour le processus (c'est-à-dire l'ensemble du group de threads). (Un thread ne sera pas capable de lire les signaux qui sont envoyés aux autres threads du processus)

note: type: Plain text
en: On success, B<signalfd>()  returns a signalfd file descriptor; this is either a new file descriptor (if I<fd> was -1), or I<fd> if I<fd> was a valid signalfd file descriptor.  On error, -1 is returned and I<errno> is set to indicate the error.
fr: S'il réussit, B<signalfd>() renvoie un descripteur de fichier signalfd ; il s'agit soit d'un nouveau descripteur de fichier (si I<fd> valait -1), ou I<fd> si I<fd> était un descripteur de fichier signalfd valable. En cas d'erreur, il renvoie -1 et I<errno> contient le code d'erreur.

note: type: Plain text
en: The I<fd> file descriptor is not a valid file descriptor.
fr: Le descripteur de fichier I<fd> n'est pas un descripteur de fichier valable.

note: or, the .I sizemask argument is not equal to .IR sizeof(sigset_t) ; type: Plain text
en: I<fd> is not a valid signalfd file descriptor.
fr: I<fd> n'est pas un descripteur de fichier signalfd valable.

note: type: Plain text
en: I<flags> is invalid; or, in Linux 2.6.26 or earlier, I<flags> is nonzero.
fr: I<flags> n'est pas correct ; ou, pour les versions de Linux 2.6.26 ou ultérieures, I<flags> n'est pas nul.

note: type: Plain text
en: The per-process limit of open file descriptors has been reached.
fr: La limite du nombre total de descripteurs de fichier ouverts par processus a été atteinte.

note: type: Plain text
en: There was insufficient memory to create a new signalfd file descriptor.
fr: Pas assez de mémoire pour créer le descripteur de fichier signalfd.

note: signalfd() is in glibc 2.7, but reportedly does not build type: Plain text
en: B<signalfd>()  is available on Linux since kernel 2.6.22.  Working support is provided in glibc since version 2.8.  The B<signalfd4>()  system call (see NOTES) is available on Linux since kernel 2.6.27.
fr: B<signalfd>() est disponible sous Linux depuis le noyau 2.6.22. La glibc le gère depuis la version 2.8. L'appel système B<signalfd4>() (voir NOTES) est disponible sous Linux depuis le noyau 2.6.27.

note: type: Plain text
en: B<signalfd>()  and B<signalfd4>()  are Linux-specific.
fr: B<signalfd>() et B<signalfd4>() sont spécifiques à Linux.

note: type: Plain text
en: The underlying Linux system call requires an additional argument, I<size_t sizemask>, which specifies the size of the I<mask> argument.  The glibc B<signalfd>()  wrapper function does not include this argument, since it provides the required value for the underlying system call.
fr: L'appel système Linux sous-jacent nécessite un paramètre supplémentaire, I<size_t sizemask>, qui spécifie la taille du paramètre I<mask>. La fonction enveloppe B<signalfd>() de la glibc n'a pas ce paramètre, puisqu'elle fournit ce paramètre à l'appel système sous-jacent.

note: type: Plain text
en: A process can create multiple signalfd file descriptors.  This makes it possible to accept different signals on different file descriptors.  (This may be useful if monitoring the file descriptors using B<select>(2), B<poll>(2), or B<epoll>(7): the arrival of different signals will make different descriptors ready.)  If a signal appears in the I<mask> of more than one of the file descriptors, then occurrences of that signal can be read (once) from any one of the descriptors.
fr: Un processus peut créer plusieurs descripteurs de fichier signalfd. Ceci permet d'accepter différents signaux sur différents descripteurs de fichier (et peut être utile si les descripteurs de fichier sont surveillés en utilisant B<select>(2), B<poll>(2) ou B<epoll>(7) : l'arrivée de différents signaux rendra différents descripteurs de fichier disponibles). Si un signal apparaît dans le I<mask> de plusieurs descripteurs de fichier, un signal reçu pourra être lu (une seule fois) depuis n'importe lequel des descripteurs.

note: type: Plain text
en: There are two underlying Linux system calls: B<signalfd>()  and the more recent B<signalfd4>().  The former system call does not implement a I<flags> argument.  The latter system call implements the I<flags> values described above.  Starting with glibc 2.9, the B<signalfd>()  wrapper function will use B<signalfd4>()  where it is available.
fr: Il y a deux appels système sous-jacent : B<signalfd>() et B<signalfd4>(), qui est plus récent. Le premier appel système n'implémente pas de paramètre I<flags>. Le dernier appel système implémente les valeurs de I<flags> décrites ci-dessous. À partir de la glibc 2.9, la fonction enveloppe B<signalfd>() utilisera B<signalfd4>() quand il est disponible.

note: The fix also was put into 2.6.24.5 type: Plain text
en: In kernels before 2.6.25, the I<ssi_ptr> and I<ssi_int> fields are not filled in with the data accompanying a signal sent by B<sigqueue>(3).
fr: Dans les noyaux antérieurs à 2.6.25, les champs I<ssi_ptr> et I<ssi_int> n'étaient pas renseignés avec les données accompagnant un signal envoyé par B<sigqueue>(3).

note: type: Plain text
en: The program below accepts the signals B<SIGINT> and B<SIGQUIT> via a signalfd file descriptor.  The program terminates after accepting a B<SIGQUIT> signal.  The following shell session demonstrates the use of the program:
fr: Le programme ci-dessous accèpte les signaux B<SIGINT> et B<SIGQUIT> en utilisant un descripteur de fichier signalfd. Le programme se termine après avoir accepté le signal B<SIGQUIT>. La session shell suivante montre l'utilisation du programme :

note: type: Plain text
en: $B< ./signalfd_demo>
    B<^C>                   # Control-C generates SIGINT
    Got SIGINT
    B<^C>
    Got SIGINT
    B<^\e>                    # Control-\e generates SIGQUIT
    Got SIGQUIT
    $
fr: $B< ./signalfd_demo>
    B<^C>                   # Contrôle-C génère un SIGINT
    Got SIGINT
    B<^C>
    Got SIGINT
    B<^\e>                    # Contrôle-\e génère un SIGQUIT
    Got SIGQUIT
    $

note: type: Plain text
en:     /* Block signals so that they aren\(aqt handled
           according to their default dispositions */
fr:     /* Bloquer les signaux pour qu'il ne soit plus géré
           par les gestionnaires par défaut */

note: type: TH
en: 2014-01-07
fr: 7 janvier 2014

note: type: Plain text
en: sigpause - atomically release blocked signals and wait for interrupt
fr: sigpause - Débloquer individuellement des signaux et les attendre

note: type: Plain text
en: B<int sigpause(int >I<sigmask>B<);  /* BSD (but see NOTES) */>
fr: B<int sigpause(int >I<sigmask>B<);  /* BSD (mais consultez les NOTES) */>

note: type: Plain text
en: Don't use this function.  Use B<sigsuspend>(2)  instead.
fr: N'utilisez pas cette fonction. Utilisez plutôt B<sigsuspend>(2).

note: type: Plain text
en: The function B<sigpause>()  is designed to wait for some signal.  It changes the process's signal mask (set of blocked signals), and then waits for a signal to arrive.  Upon arrival of a signal, the original signal mask is restored.
fr: La fonction B<sigpause>() est conçue pour attendre un signal. Elle modifie le masque signal d'un processus (ensemble de signaux bloqués) et attend qu'un signal arrive. À l'arrivée d'un signal, le masque signal original est rétabli.

note: type: Plain text
en: If B<sigpause>()  returns, it was interrupted by a signal and the return value is -1 with I<errno> set to B<EINTR>.
fr: Si B<sigpause>() se termine, c'est qu'elle a été interrompue par un signal et la valeur de retour est -1 avec I<errno> positionnée à B<EINTR>.

note: type: Plain text
en: The B<sigpause>()  function is thread-safe.
fr: La fonction B<sigpause>() est sûre dans un contexte multithread.

note: type: Plain text
en: The System V version of B<sigpause>()  is standardized in POSIX.1-2001.
fr: La version System V de B<sigpause>() est standardisée dans POSIX.1-2001.

note: __xpg_sigpause: UNIX 95, spec 1170, SVID, SVr4, XPG type: Plain text
en: The classical BSD version of this function appeared in 4.2BSD.  It sets the process's signal mask to I<sigmask>.  UNIX 95 standardized the incompatible System V version of this function, which removes only the specified signal I<sig> from the process's signal mask.  The unfortunate situation with two incompatible functions with the same name was solved by the B<\%sigsuspend>(2)  function, that takes a I<sigset_t\ *> argument (instead of an I<int>).
fr: La version BSD classique de cette fonction est apparue dans BSD\ 4.2. Elle positionne le masque signal de processus à I<sigmask>. UNIX 95 a standardisé les versions incompatibles System V de cette fonction, qui supprime seulement le signal I<sig> spécifié du masque signal de processus La situation malheureuse de deux fonctions incompatibles possédant le même nom a été résolue avec la fonction B<\%sigsuspend>(2), qui prend un paramètre de type I<sigset_t\ *> (au lieu d'un entier de type I<int>).

note: type: Plain text
en: On Linux, this routine is a system call only on the Sparc (sparc64)  architecture.
fr: Sous Linux, cette routine n'est un appel système que pour l'architecture Sparc (sparc64).

note: type: Plain text
en: Libc4 and libc5 know only about the BSD version.
fr: Les bibliothèques libc4 et libc5 ne connaissent que la version BSD.

note: For the BSD version, one usually uses a zero .I sigmask to indicate that no signals are to be blocked. type: Plain text
en: Glibc uses the BSD version if the B<_BSD_SOURCE> feature test macro is defined and none of B<_POSIX_SOURCE>, B<_POSIX_C_SOURCE>, B<_XOPEN_SOURCE>, B<_GNU_SOURCE>, or B<_SVID_SOURCE> is defined.  Otherwise, the System V version is used (and B<_XOPEN_SOURCE> must be defined to obtain the declaration).  Since glibc 2.19, only the System V version is exposed by I<E<lt>signal.hE<gt>>; applications that formerly used the BSD B<sigpause>()  should be amended to use B<sigsuspend>(2).
fr: La glibc utilise la version BSD si la macro de test de fonctionnalités B<_BSD_SOURCE> est définie et qu'aucune des macros B<_POSIX_SOURCE>, B<_POSIX_C_SOURCE>, B<_XOPEN_SOURCE>, B<_GNU_SOURCE> ou B<_SVID_SOURCE> n'est définie. Sinon, la version System V est utilisée (et B<_XOPEN_SOURCE> doit être définie pour obtenir la déclaration). A partir de glibc 2.19, seule la version System V est présente dans I<E<lt>signal.hE<gt>> ; les applications qui utilisaient précédemment l'appel BSD B<sigpause>() doivent être mises à jour afin d'appeler B<sigsuspend>(2) à la place.

note: type: TH
en: 2013-12-11
fr: 11 décembre 2013

note: type: Plain text
en: sigpending - examine pending signals
fr: sigpending - Examiner les signaux en attente

note: type: Plain text
en: B<sigpending>(): _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE
fr: B<sigpending>() : _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE

note: type: Plain text
en: B<sigpending>()  returns the set of signals that are pending for delivery to the calling thread (i.e., the signals which have been raised while blocked).  The mask of pending signals is returned in I<set>.
fr: L'appel B<sigpending>() permet l'examen des signaux en attente (qui se sont déclenchés en étant bloqués). Le masque de signaux en attente est stocké dans I<set>.

note: type: Plain text
en: B<sigpending>()  returns 0 on success and -1 on error.  In the event of an error, I<errno> is set to indicate the cause.
fr: B<sigpending>() renvoie 0 s'il réussit, et -1 en cas d'erreur. En cas d'erreur, I<errno> contient le code d'erreur.

note: type: Plain text
en: I<set> points to memory which is not a valid part of the process address space.
fr: I<set> pointe en-dehors de l'espace d'adressage accessible.

note: type: Plain text
en: If a signal is both blocked and has a disposition of "ignored", it is I<not> added to the mask of pending signals when generated.
fr: Si le signal est bloqué et que son dispositif est dans l'état "ignoré", il I<n'est pas> ajouté au masque des signaux en attente lors de sa génération.

note: type: Plain text
en: The set of signals that is pending for a thread is the union of the set of signals that is pending for that thread and the set of signals that is pending for the process as a whole; see B<signal>(7).
fr: L'ensemble des signaux qui sont en attente pour un thread est l'union de l'ensemble des signaux qui sont en attente pour ce thread et de l'ensemble des signaux qui sont en attente pour le processus lui-même ; consultez B<signal>(7).

note: type: Plain text
en: In versions of glibc up to and including 2.2.1, there is a bug in the wrapper function for B<sigpending>()  which means that information about pending real-time signals is not correctly returned.
fr: En raison d'un bogue dans la fonction enveloppe de B<sigpending>() des versions de glibc jusqu'à 2.2.1 incluse, l'information concernant les signaux temps\(hyréel n'était pas renvoyée correctement.

note: type: Plain text
en: sigprocmask - examine and change blocked signals
fr: sigprocmask - Examiner et modifier les signaux bloqués

note: type: Plain text
en: B<sigprocmask>(): _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE
fr: B<sigprocmask>() : _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE

note: type: Plain text
en: B<sigprocmask>()  is used to fetch and/or change the signal mask of the calling thread.  The signal mask is the set of signals whose delivery is currently blocked for the caller (see also B<signal>(7)  for more details).
fr: L'appel B<sigprocmask>() est utilisé pour récupérer et/ou changer le masque de signaux du thread appelant. Le masque de signaux est l'ensemble des signaux dont la distribution est actuellement bloquée pour l'appelant (consultez également B<signal>(7) pour plus de détails).

note: type: Plain text
en: The behavior of the call is dependent on the value of I<how>, as follows.
fr: Son comportement est dépendant de la valeur de I<how>, avec les conventions suivantes\ :

note: type: Plain text
en: The set of blocked signals is the union of the current set and the I<set> argument.
fr: L'ensemble des signaux bloqués est l'union de l'ensemble actuel et de l'argument I<set>.

note: type: Plain text
en: The signals in I<set> are removed from the current set of blocked signals.  It is permissible to attempt to unblock a signal which is not blocked.
fr: Les signaux dans l'ensemble I<set> sont supprimés de la liste des signaux bloqués. Il est permis de débloquer un signal non bloqué.

note: type: Plain text
en: The set of blocked signals is set to the argument I<set>.
fr: L'ensemble des signaux bloqués est égal à l'argument I<set>.

note: type: Plain text
en: If I<oldset> is non-NULL, the previous value of the signal mask is stored in I<oldset>.
fr: Si I<oldset> n'est pas NULL, la valeur précédente du masque de signaux est stockée dans I<oldset>.

note: type: Plain text
en: If I<set> is NULL, then the signal mask is unchanged (i.e., I<how> is ignored), but the current value of the signal mask is nevertheless returned in I<oldset> (if it is not NULL).
fr: Si I<set> est NULL, le masque de signaux n'est pas modifié (I<how> est donc ignoré), mais la valeur actuelle du masque de signaux est tout de même renvoyée dans I<oldset> (s'il n'est pas NULL).

note: type: Plain text
en: The use of B<sigprocmask>()  is unspecified in a multithreaded process; see B<pthread_sigmask>(3).
fr: L'utilisation de B<sigprocmask>() dans un processus multithreadé n'est pas définie\ ; consultez B<pthread_sigmask>(3).

note: type: Plain text
en: B<sigprocmask>()  returns 0 on success and -1 on error.  In the event of an error, I<errno> is set to indicate the cause.
fr: B<sigprocmask>() renvoie 0 s'il réussit et -1 en cas d'erreur. En cas d'erreur, I<errno> contient le code d'erreur.

note: type: Plain text
en: the I<set> or I<oldset> argument points outside the process's allocated address space.
fr: L'un des paramètres I<set> ou I<oldset> pointe vers une zone mémoire n'appartenant pas à l'espace d'adressage alloué du processus.

note: type: Plain text
en: The value specified in I<how> was invalid.
fr: La valeur de I<how> est invalide.

note: type: Plain text
en: It is not possible to block B<SIGKILL> or B<SIGSTOP>.  Attempts to do so are silently ignored.
fr: Il est impossible de bloquer B<SIGKILL> or B<SIGSTOP> avec l'appel sigprocmask. Les tentatives seront ignorées silencieusement.

note: type: Plain text
en: Each of the threads in a process has its own signal mask.
fr: Chacun des threads d'un processus a son propre masque de signaux.

note: type: Plain text
en: If B<SIGBUS>, B<SIGFPE>, B<SIGILL>, or B<SIGSEGV> are generated while they are blocked, the result is undefined, unless the signal was generated by B<kill>(2), B<sigqueue>(3), or B<raise>(3).
fr: Si l'un des signaux B<SIGBUS>, B<SIGFPE>, B<SIGILL> ou B<SIGSEGV> est généré alors qu'il est bloqué, le résultat est indéfini, sauf si le signal a été généré par B<kill>(2), B<sigqueue>(3) ou B<raise>(3).

note: type: TH
en: 2013-12-16
fr: 16 décembre 2013

note: type: Plain text
en: sigqueue - queue a signal and data to a process
fr: sigqueue - Enregistrer un signal et des données pour un processus

note: type: Plain text
en: B<int sigqueue(pid_t >I<pid>B<, int >I<sig>B<, const union sigval >I<value>B<);>
fr: B<int sigqueue(pid_t >I<pid>B<, int >I<sig>B<, const union sigval >I<valeur>B<);>

note: type: Plain text
en: B<sigqueue>(): _POSIX_C_SOURCE\ E<gt>=\ 199309L
fr: B<sigqueue>() : _POSIX_C_SOURCE\ E<gt>=\ 199309L

note: type: Plain text
en: B<sigqueue>()  sends the signal specified in I<sig> to the process whose PID is given in I<pid>.  The permissions required to send a signal are the same as for B<kill>(2).  As with B<kill>(2), the null signal (0) can be used to check if a process with a given PID exists.
fr: B<sigqueue>() envoie le signal I<sig> au processus indiqué par I<pid>. Les permissions requises pour l'émission du signal sont les mêmes que pour B<kill>(2). Comme avec B<kill>(2), le signal nul (0) peut servir à vérifier si un processus existe avec un PID donné.

note: type: Plain text
en: The I<value> argument is used to specify an accompanying item of data (either an integer or a pointer value) to be sent with the signal, and has the following type:
fr: L'argument I<valeur> sert à indiquer une donnée (soit un entier, soit un pointeur) qui accompagnera le signal et se présente avec le type suivant\ :

note: type: Plain text
en: If the receiving process has installed a handler for this signal using the B<SA_SIGINFO> flag to B<sigaction>(2), then it can obtain this data via the I<si_value> field of the I<siginfo_t> structure passed as the second argument to the handler.  Furthermore, the I<si_code> field of that structure will be set to B<SI_QUEUE>.
fr: Si le processus récepteur a installé un gestionnaire pour le signal avec l'option B<SA_SIGINFO> lors du B<sigaction>(2), il pourra obtenir la donnée dans le champ I<si_value> de la structure I<siginfo_t> passée en second argument au gestionnaire. De plus, le champ I<si_code> de la structure contiendra B<SI_QUEUE>.

note: type: Plain text
en: On success, B<sigqueue>()  returns 0, indicating that the signal was successfully queued to the receiving process.  Otherwise -1 is returned and I<errno> is set to indicate the error.
fr: L'appel B<sigqueue>() renvoie 0 s'il réussit, indiquant que le signal a bien été mis dans la file du processus récepteur. Sinon il renvoie -1 et I<errno> contient le code de l'erreur.

note: type: Plain text
en: I<sig> was invalid.
fr: I<sig> est invalide.

note: type: Plain text
en: The process does not have permission to send the signal to the receiving process.  For the required permissions, see B<kill>(2).
fr: Le processus n'a pas la permission d'envoyer un signal au processus visé. Pour les permissions nécessaires, consultez B<kill>(2).

note: type: Plain text
en: No process has a PID matching I<pid>.
fr: Il n'y a pas de processus correspondant au I<pid>.

note: type: Plain text
en: This system call first appeared in Linux 2.2.
fr: Cet appel système est apparu dans Linux 2.2.

note: type: Plain text
en: The B<sigqueue>()  function is thread-safe.
fr: La fonction B<sigqueue>() est sûre dans un contexte multithread.

note: type: Plain text
en: If this function results in the sending of a signal to the process that invoked it, and that signal was not blocked by the calling thread, and no other threads were willing to handle this signal (either by having it unblocked, or by waiting for it using B<sigwait>(3)), then at least some signal must be delivered to this thread before this function returns.
fr: Si l'appel consiste à envoyer un signal au processus qui l'a invoqué, et si le signal n'est pas bloqué par le thread appelant, et si aucun autre thread ne peut traiter le signal (soit en l'ayant débloqué, ou en faisant une attente avec B<sigwait>(3)), alors au moins quelques signaux seront délivrés au thread appelant avant que la fonction ne revienne.

note: type: Plain text
en: On Linux, this function is implemented using the B<rt_sigqueueinfo>(2)  system call.  The system call differs in its third argument, which is the I<siginfo_t> structure that will be supplied to the receiving process's signal handler or returned by the receiving process's B<sigtimedwait>(2)  call.  Inside the glibc B<sigqueue>()  wrapper, this argument, I<uinfo>, is initialized as follows:
fr: Sous Linux, l'implémentation de la fonction utilise l'appel système B<rt_sigqueueinfo>(2).Le troisième paramètre de l'appel système diffère, puisqu'il correspond à la structure I<siginfo_t> qui sera fournie au gestionnaire de signal du processus recevant le signal ou qui sera renvoyée par l'appel B<sigtimedwait>(2) du processus recevant le signal. Dans la fonction B<sigqueue>() de la glibc, ce paramètre I<uinfo> est initialisé de cette façon :

note: type: Plain text
en: uinfo.si_signo = sig;      /* argument supplied to sigqueue() */
    uinfo.si_code = SI_QUEUE;
    uinfo.si_pid = getpid();   /* Process ID of sender */
    uinfo.si_uid = getuid();   /* Real UID of sender */
    uinfo.si_value = val;      /* argument supplied to sigqueue() */
fr: uinfo.si_signo = sig;      /* paramètre fourni à sigqueue() */
    uinfo.si_code = SI_QUEUE;
    uinfo.si_pid = getpid();   /* identifiant du processus émetteur */
    uinfo.si_uid = getuid();   /* UID réel de l'émetteur */
    uinfo.si_value = val;      /* paramètre fourni à sigqueue() */

note: type: Plain text
en: sigreturn - return from signal handler and cleanup stack frame
fr: sigreturn - Revenir d'un gestionnaire de signaux et nettoyer la pile

note: type: Plain text
en: When the Linux kernel creates the stack frame for a signal handler, a call to B<sigreturn>()  is inserted into the stack frame so that upon return from the signal handler, B<sigreturn>()  will be called.
fr: Quand le noyau Linux crée un cadre de pile pour un gestionnaire de signaux, un appel à B<sigreturn>() est inséré dans ce cadre de manière à ce que le retour du gestionnaire appelle B<sigreturn>() avant le retour effectif.

note: type: Plain text
en: This B<sigreturn>()  call undoes everything that was done\(emchanging the process's signal mask, switching stacks (see B<sigaltstack>(2))\(emin order to invoke the signal handler: it restores the process's signal mask, switches stacks, and restores the process's context (registers, processor flags), so that the process directly resumes execution at the point where it was interrupted by the signal.
fr: Cet appel à B<sigreturn>() défait tout ce qui a été fait \(em modifier le masque de signaux du processus, commutation des piles (consultez B<sigaltstack>(2)) \(em de façon à invoquer le gestionnaire de signal\ : il restaure le masque de signaux du processus, commute les piles et restaure le contexte du processus (registres, drapeaux du processeur), de sorte que le processus relance l'exécution à partir du moment où elle a été interrompue par le signal.

note: type: Plain text
en: B<sigreturn>()  never returns.
fr: B<sigreturn>() ne revient jamais.

note: type: SH
en: FILES
fr: FICHIERS

note: type: Plain text
en: B<sigreturn>()  is specific to Linux and should not be used in programs intended to be portable.
fr: B<sigreturn>() est spécifique à Linux et ne devrait pas être employé dans un programme destiné à être portable.

note: type: Plain text
en: The B<sigreturn>()  call is used by the kernel to implement signal handlers.  It should B<never> be called directly.  Better yet, the specific use of the I<__unused> argument varies depending on the architecture.
fr: L'appel B<sigreturn>() est utilisé dans le noyau pour implémenter les gestionnaires de signaux. Il ne doit B<jamais> être appelé directement. Mieux, l'utilisation de l'argument I<__unused> dépend de l'architecture matérielle.

note: type: Plain text
en: sigset, sighold, sigrelse, sigignore - System V signal API
fr: sigset, sighold, sigrelse, sigignore - API signaux System V

note: type: Plain text
en: B<sigset>(), B<sighold>(), B<sigrelse>(), B<sigignore>():
fr: B<sigset>(), B<sighold>(), B<sigrelse>(), B<sigignore>() :

note: type: Plain text
en: These functions are provided in glibc as a compatibility interface for programs that make use of the historical System V signal API.  This API is obsolete: new applications should use the POSIX signal API (B<sigaction>(2), B<sigprocmask>(2), etc.)
fr: Ces fonctions sont fournies dans la glibc comme interface de compatibilité pour les programmes qui utilisent l'API signaux System V historique. Cette API est obsolète, les nouvelles applications devraient utiliser l'API signaux POSIX (B<sigaction>(2), B<sigprocmask>(2), etc.).

note: type: Plain text
en: The B<sigset>()  function modifies the disposition of the signal I<sig>.  The I<disp> argument can be the address of a signal handler function, or one of the following constants:
fr: La fonction B<sigset>() modifie le dispositif du signal I<sig>. L'argument I<disp> peut être l'adresse d'une fonction gestionnaire de signaux ou l'une des constantes suivantes\ :

note: type: Plain text
en: Reset the disposition of I<sig> to the default.
fr: Réinitialiser le dispositif de I<sig> à sa valeur par défaut.

note: type: Plain text
en: Ignore I<sig>.
fr: Ignorer I<sig>.

note: type: Plain text
en: Add I<sig> to the process's signal mask, but leave the disposition of I<sig> unchanged.
fr: Ajouter I<sig> au masque de signaux du processus, mais laisser le dispositif de I<sig> inchangé.

note: type: Plain text
en: If I<disp> specifies the address of a signal handler, then I<sig> is added to the process's signal mask during execution of the handler.
fr: Si I<disp> spécifie l'adresse d'un gestionnaire de signaux, I<sig> est ajouté au masque de signaux du processus pendant l'exécution du gestionnaire.

note: type: Plain text
en: If I<disp> was specified as a value other than B<SIG_HOLD>, then I<sig> is removed from the process's signal mask.
fr: Si I<disp> a été spécifié à une autre valeur que B<SIG_HOLD>, I<sig> est retiré du masque de signaux du processus.

note: type: Plain text
en: The dispositions for B<SIGKILL> and B<SIGSTOP> cannot be changed.
fr: Les dispositifs pour B<SIGKILL> et B<SIGSTOP> ne peuvent pas être modifiés.

note: type: Plain text
en: The B<sighold>()  function adds I<sig> to the calling process's signal mask.
fr: La fonction B<sighold>() ajoute I<sig> au masque de signaux du processus appelant.

note: type: Plain text
en: The B<sigrelse>()  function removes I<sig> from the calling process's signal mask.
fr: La fonction B<sigrelse>() retire I<sig> du masque de signaux du processus appelant.

note: type: Plain text
en: The B<sigignore>()  function sets the disposition of I<sig> to B<SIG_IGN>.
fr: La fonction B<sigignore>() configure le dispositif de I<sig> à B<SIG_IGN>.

note: type: Plain text
en: On success, B<sigset>()  returns B<SIG_HOLD> if I<sig> was blocked before the call, or the signal's previous disposition if it was not blocked before the call.  On error, B<sigset>()  returns -1, with I<errno> set to indicate the error.  (But see BUGS below.)
fr: Si elle réussit, B<sigset>() renvoie B<SIG_HOLD> si I<sig> était bloqué avant l'appel ou le dispositif précédent du signal s'il n'était pas bloqué avant l'appel. Si elle échoue, B<sigset>() renvoie -1 et écrit I<errno> pour indiquer l'erreur (mais consultez la section des BOGUES ci-dessous).

note: type: Plain text
en: The B<sighold>(), B<sigrelse>(), and B<sigignore>()  functions return 0 on success; on error, these functions return -1 and set I<errno> to indicate the error.
fr: Les fonctions B<sighold>(), B<sigrelse>() et B<sigignore>() renvoient 0 si elle réussissent et -1 si elles échouent et écrivent I<errno> pour indiquer l'erreur.

note: type: Plain text
en: For B<sigset>()  see the ERRORS under B<sigaction>(2)  and B<sigprocmask>(2).
fr: Pour B<sigset>(), voir la section ERREURS des pages de manuel B<sigaction>(2) et B<sigprocmask>(2).

note: type: Plain text
en: For B<sighold>()  and B<sigrelse>()  see the ERRORS under B<sigprocmask>(2).
fr: Pour B<sighold>() et B<sigrelse>(), voir la section ERREURS de la page de manuel B<sigprocmask>(2).

note: type: Plain text
en: For B<sigignore>(), see the errors under B<sigaction>(2).
fr: Pour B<sigignore>(), voir la section ERREURS de la page de manuel B<sigaction>(2).

note: type: Plain text
en: SVr4, POSIX.1-2001.  These functions are obsolete: do not use them in new programs.  POSIX.1-2008 marks B<sighold>(), B<sigignore>(), B<sigpause>(), B<sigrelse>(), and B<sigset>()  as obsolete, recommending the use of B<sigaction>(2), B<sigprocmask>(2), B<pthread_sigmask>(3), and B<sigsuspend>(2)  instead.
fr: SVr4, POSIX.1-2001. Ces fonctions sont obsolètes. Ne les utilisez pas dans de nouveaux programmes. POSIX.1-2008 marque B<sighold>(), B<sigignore>(), B<sigpause>(), B<sigrelse>() et B<sigset>() comme étant obsolètes, en recommandant d'utiliser à la place B<sigaction>(2), B<sigprocmask>(2), B<pthread_sigmask>(3) et B<sigsuspend>(2).

note: type: Plain text
en: These functions appeared in glibc version 2.1.
fr: Ces fonctions sont apparues dans la glibc version 2.1.

note: type: Plain text
en: The I<sighandler_t> type is a GNU extension; it is used on this page only to make the B<sigset>()  prototype more easily readable.
fr: Le type I<sighandler_t> est une extension GNU. Il n'est utilisé dans cette page que pour rendre le prototype de B<sigset>() plus lisible.

note: type: Plain text
en: The B<sigset>()  function provides reliable signal handling semantics (as when calling B<sigaction>(2)  with I<sa_mask> equal to 0).
fr: La fonction B<sigset>() fournit une sémantique de gestion des signaux fiable (comme lorsqu'on appelle B<sigaction>(2) avec I<sa_mask> valant 0).

note: type: Plain text
en: On System V, the B<signal>()  function provides unreliable semantics (as when calling B<sigaction>(2)  with I<sa_mask> equal to I<SA_RESETHAND | SA_NODEFER>).  On BSD, B<signal>()  provides reliable semantics.  POSIX.1-2001 leaves these aspects of B<signal>()  unspecified.  See B<signal>(2)  for further details.
fr: Sur System V, la fonction B<signal>() fournit une sémantique non fiable (comme lorsqu'on appelle B<sigaction>(2) avec I<sa_mask> valant I<SA_RESETHAND | SA_NODEFER>). Sur BSD, B<signal>() fournit une sémantique fiable. POSIX.1-2001 laisse ces aspects de B<signal>() non spécifiés. Consultez B<signal>(2) pour plus de détails.

note: type: Plain text
en: In order to wait for a signal, BSD and System V both provided a function named B<sigpause>(3), but this function has a different argument on the two systems.  See B<sigpause>(3)  for details.
fr: Afin d'attendre un signal, BSD et System V fournissent tous les deux une fonction nommée B<sigpause>(3), mais cette fonction n'a pas le même argument sur les deux systèmes. Consultez B<sigpause>(3) pour les détails.

note: type: Plain text
en: In versions of glibc before 2.2, B<sigset>()  did not unblock I<sig> if I<disp> was specified as a value other than B<SIG_HOLD>.
fr: Dans les versions de la glibc antérieures à la 2.2, B<sigset>() ne débloquait pas I<sig> si I<disp> était spécifié à une autre valeur que B<SIG_HOLD>.

note: See http://sourceware.org/bugzilla/show_bug.cgi?id=1951 type: Plain text
en: In versions of glibc before 2.5, B<sigset>()  does not correctly return the previous disposition of the signal in two cases.  First, if I<disp> is specified as B<SIG_HOLD>, then a successful B<sigset>()  always returns B<SIG_HOLD>.  Instead, it should return the previous disposition of the signal (unless the signal was blocked, in which case B<SIG_HOLD> should be returned).  Second, if the signal is currently blocked, then the return value of a successful B<sigset>()  should be B<SIG_HOLD>.  Instead, the previous disposition of the signal is returned.  These problems have been fixed since glibc 2.5.
fr: Dans les versions de la glibc antérieures à 2.5, B<sigset>() ne renvoyait pas correctement le dispositif précédent du signal dans deux cas. Le premier, si I<disp> était spécifié à B<SIG_HOLD>, un appel réussi à B<sigset>() renvoyait toujours B<SIG_HOLD>. À la place, elle aurait dû renvoyer le dispositif précédent du signal (à moins que le signal ne fût bloqué, auquel cas B<SIG_HOLD> aurait été renvoyé). Le second, si le signal est actuellement bloqué, la valeur renvoyée par un appel à B<sigset>() réussi devait renvoyer B<SIG_HOLD>. À la place, elle renvoyait le dispositif précédent du signal. Ces problèmes ont été résolus depuis la version 2.5 de la glibc.

note: type: Plain text
en: sigemptyset, sigfillset, sigaddset, sigdelset, sigismember - POSIX signal set operations
fr: sigsetops, sigemptyset, sigfillset, sigaddset, sigdelset, sigismember - Opérations sur les ensembles de signaux POSIX

note: type: Plain text
en: B<sigemptyset>(), B<sigfillset>(), B<sigaddset>(), B<sigdelset>(), B<sigismember>():
fr: B<sigemptyset>(), B<sigfillset>(), B<sigaddset>(), B<sigdelset>(), B<sigismember>()\ :

note: type: Plain text
en: These functions allow the manipulation of POSIX signal sets.
fr: Ces fonctions permettent la manipulation des ensembles de signaux POSIX.

note: type: Plain text
en: B<sigemptyset>()  initializes the signal set given by I<set> to empty, with all signals excluded from the set.
fr: B<sigemptyset>() vide l'ensemble de signaux fourni par I<set>, tous les signaux étant exclus de cet ensemble.

note: type: Plain text
en: B<sigfillset>()  initializes I<set> to full, including all signals.
fr: B<sigfillset>() remplit totalement l'ensemble de signaux I<set> en incluant tous les signaux.

note: type: Plain text
en: B<sigaddset>()  and B<sigdelset>()  add and delete respectively signal I<signum> from I<set>.
fr: B<sigaddset>() et B<sigdelset>() ajoutent ou suppriment respectivement le signal I<signum> de l'ensemble I<set>.

note: type: Plain text
en: B<sigismember>()  tests whether I<signum> is a member of I<set>.
fr: B<sigismember>() teste si le signal I<signum> est membre de l'ensemble I<set>.

note: type: Plain text
en: Objects of type I<sigset_t> must be initialized by a call to either B<sigemptyset>()  or B<sigfillset>()  before being passed to the functions B<sigaddset>(), B<sigdelset>()  and B<sigismember>()  or the additional glibc functions described below (B<sigisemptyset>(), B<sigandset>(), and B<sigorset>()).  The results are undefined if this is not done.
fr: Les objets de type I<sigset_t> doivent être initialisés par un appel à B<sigemptyset>() ou B<sigfillset>() avant d'être passé aux fonctions B<sigaddset>(), B<sigdelset>() et B<sigismember>() ou aux fonctions aupplémentaires de la glibc décrites ci-dessous (B<sigisemptyset>(), B<sigandset>() et B<sigorset>()). Les résultats ne sont pas définis si ce n'est pas fait.

note: type: Plain text
en: B<sigemptyset>(), B<sigfillset>(), B<sigaddset>(), and B<sigdelset>()  return 0 on success and -1 on error.
fr: B<sigemptyset>(), B<sigfillset>(), B<sigaddset>() et B<sigdelset>() renvoient 0 s'il réussissent, et -1 s'ils échouent.

note: type: Plain text
en: B<sigismember>()  returns 1 if I<signum> is a member of I<set>, 0 if I<signum> is not a member, and -1 on error.  On error, these functions set I<errno> to indicate the cause.
fr: B<sigismember>() renvoie 1 si le signal I<signum> est dans l'ensemble I<set>, 0 si I<signum> n'y est pas, et -1 en cas d'erreur.En cas d'erreur, I<errno> contient le code d'erreur.

note: type: Plain text
en: I<sig> is not a valid signal.
fr: I<sig> n'est pas un signal valide.

note: type: Plain text
en: The B<sigemptyset>(), B<sigfillset>(), B<sigaddset>(), B<sigdelset>(), B<sigismember>(), B<sigisemptyset>(), B<sigorset>(), and B<sigandset>()  functions are thread-safe.
fr: Les fonctions B<sigemptyset>(), B<sigfillset>(), B<sigaddset>(), B<sigdelset>(), B<sigismember>(), B<sigisemptyset>(), B<sigorset>() et B<sigandset>()  sont sûres dans un contexte multithread.

note: type: SS
en: Glibc notes
fr: Notes sur la glibc

note: type: Plain text
en: If the B<_GNU_SOURCE> feature test macro is defined, then I<E<lt>signal.hE<gt>> exposes three other functions for manipulating signal sets:
fr: Si la macro de test de fonctionnalités B<_GNU_SOURCE> est définie, I<E<lt>signal.hE<gt>> expose trois autres fonctions pour la manipulation des ensembles de signaux :

note: type: Plain text
en: B<sigisemptyset>()  returns 1 if I<set> contains no signals, and 0 otherwise.
fr: B<sigisemptyset>() renvoie 1 si I<set> ne contient pas de signaux et 0 autrement.

note: type: Plain text
en: B<sigorset>()  places the union of the sets I<left> and I<right> in I<dest>.  B<sigandset>()  places the intersection of the sets I<left> and I<right> in I<dest>.  Both functions return 0 on success, and -1 on failure.
fr: B<sigorset>() place l'union des ensembles I<left> et I<right> dans I<dest>. B<sigandset>()  place l'intersection des ensembles I<left> et I<right> dans I<dest>. Les deux fonctions renvoient 0 si elles réussissent et -1 si elles échouent.

note: type: Plain text
en: These functions are nonstandard (a few other systems provide similar functions) and their use should be avoided in portable applications.
fr: Ces fonctions ne sont pas standards (quelques autres systèmes ont des fonctions similaires) et ne devraient pas être utilisées dans des applications conçues pour être portables.

note: type: Plain text
en: sigsuspend - wait for a signal
fr: sigsuspend - Attendre un signal

note: type: Plain text
en: B<sigsuspend>(): _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE
fr: B<sigsuspend>() : _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE

note: type: Plain text
en: B<sigsuspend>()  temporarily replaces the signal mask of the calling process with the mask given by I<mask> and then suspends the process until delivery of a signal whose action is to invoke a signal handler or to terminate a process.
fr: L'appel B<sigsuspend>() remplace temporairement le masque de signaux bloqués par celui fourni dans I<mask> puis endort le processus jusqu'à arrivée d'un signal qui déclenche un gestionnaire de signal ou termine le processus.

note: type: Plain text
en: If the signal terminates the process, then B<sigsuspend>()  does not return.  If the signal is caught, then B<sigsuspend>()  returns after the signal handler returns, and the signal mask is restored to the state before the call to B<sigsuspend>().
fr: Si le signal termine le processus, B<sigsuspend>() ne retourne pas à l'appelant. Si le signal est intercepté, B<sigsuspend>() retourne après l'exécution du gestionnaire, et le masque de signaux bloqués est restauré à sa valeur précédant l'appel à B<sigsuspend>().

note: type: Plain text
en: It is not possible to block B<SIGKILL> or B<SIGSTOP>; specifying these signals in I<mask>, has no effect on the process's signal mask.
fr: Il n'est pas possible de bloquer B<SIGKILL> ou B<SIGSTOP> ; spécifier ces signaux dans I<mask> n'a aucun effet sur le masque de signaux du processus.

note: type: Plain text
en: B<sigsuspend>()  always returns -1, with I<errno> set to indicate the error (normally, B<EINTR>).
fr: B<sigsuspend>() renvoie toujours -1, et I<errno> est normalement positionné à B<EINTR>.

note: type: Plain text
en: I<mask> points to memory which is not a valid part of the process address space.
fr: I<mask> pointe en-dehors de l'espace d'adressage accessible.

note: type: Plain text
en: The call was interrupted by a signal.
fr: L'appel a été interrompu par un signal.

note: type: Plain text
en: Normally, B<sigsuspend>()  is used in conjunction with B<sigprocmask>(2)  in order to prevent delivery of a signal during the execution of a critical code section.  The caller first blocks the signals with B<sigprocmask>(2).  When the critical code has completed, the caller then waits for the signals by calling B<sigsuspend>()  with the signal mask that was returned by B<sigprocmask>(2)  (in the I<oldset> argument).
fr: En général, B<sigsuspend>() est utilisé conjointement avec B<sigprocmask>(2) pour empêcher l'arrivée d'un signal pendant l'exécution d'une section de code critique. L'appelant commence par bloquer les signaux avec B<sigprocmask>(2). Après la fin de la section critique, l'appelant attend les signaux avec B<sigsuspend>() utilisé avec le masque renvoyé par B<sigprocmask>(2) (dans l'argument I<oldset>).

note: type: TH
en: 2014-03-24
fr: 24 mars 2014

note: type: Plain text
en: sigvec, sigblock, sigsetmask, siggetmask, sigmask - BSD signal API
fr: sigvec, sigblock, sigsetmask, siggetmask, sigmask - API signaux BSD

note: type: Plain text
en: All functions shown above: _BSD_SOURCE
fr: Toutes les fonctions ci-dessus : _BSD_SOURCE

note: type: Plain text
en: These functions are provided in glibc as a compatibility interface for programs that make use of the historical BSD signal API.  This API is obsolete: new applications should use the POSIX signal API (B<sigaction>(2), B<sigprocmask>(2), etc.).
fr: Ces fonctions sont fournies dans la glibc comme interface de compatibilité pour les programmes qui utilisent l'API signaux BSD historique. Cette API est obsolète, les nouvelles applications devraient utiliser l'API signaux POSIX (B<sigaction>(2), B<sigprocmask>(2), etc.).

note: type: Plain text
en: The B<sigvec>()  function sets and/or gets the disposition of the signal I<sig> (like the POSIX B<sigaction>(2)).  If I<vec> is not NULL, it points to a I<sigvec> structure that defines the new disposition for I<sig>.  If I<ovec> is not NULL, it points to a I<sigvec> structure that is used to return the previous disposition of I<sig>.  To obtain the current disposition of I<sig> without changing it, specify NULL for I<vec>, and a non-null pointer for I<ovec>.
fr: La fonction B<sigvec>() configure et/ou récupère le dispositif du signal I<sig> (comme l'appel POSIX B<sigaction>(2)). Si I<vec> n'est pas NULL, il pointe sur une structure I<sigvec> qui définit le nouveau dispositif pour I<sig>. Si I<ovec> n'est pas NULL, il pointe sur une structure I<sigvec> qui est utilisée pour renvoyer le dispositif précédent de I<sig>. Pour obtenir le dispositif courant de I<sig> sans le modifier, vous devez spécifier NULL pour I<vec>, et un pointeur non NULL pour I<ovec>.

note: type: Plain text
en: The I<sigvec> structure has the following form:
fr: La structure I<sigvec> à la forme suivante\ :

note: type: Plain text
en: struct sigvec {
        void (*sv_handler)(int); /* Signal disposition */
        int    sv_mask;          /* Signals to be blocked in handler */
        int    sv_flags;         /* Flags */
    };
fr: struct sigvec {
        void (*sv_handler)(int); /* Dispositif du signal*/
        int    sv_mask;          /* Signaux à bloquer dans le gestionnaire */
        int    sv_flags;         /* Drapeaux */
    };

note: type: Plain text
en: The I<sv_handler> field specifies the disposition of the signal, and is either: the address of a signal handler function; B<SIG_DFL>, meaning the default disposition applies for the signal; or B<SIG_IGN>, meaning that the signal is ignored.
fr: Le champ I<sv_handler> spécifie le dispositif du signal et est soit l'adresse de la fonction gestionnaire de signal, soit B<SIG_DFL> signifiant que le dispositif par défaut s'applique au signal, soit B<SIG_IGN> signifiant que le signal est ignoré.

note: type: Plain text
en: If I<sv_handler> specifies the address of a signal handler, then I<sv_mask> specifies a mask of signals that are to be blocked while the handler is executing.  In addition, the signal for which the handler is invoked is also blocked.  Attempts to block B<SIGKILL> or B<SIGSTOP> are silently ignored.
fr: Si I<sv_handler> spécifie l'adresse d'un gestionnaire de signal, I<sv_mask> spécifie un masque de signaux qui seront bloqués pendant que le gestionnaire s'exécute. De plus, le signal pour lequel le gestionnaire est appelé est également bloqué. Toute tentative de bloquer B<SIGKILL> ou B<SIGSTOP> est silencieusement ignorée.

note: type: Plain text
en: If I<sv_handler> specifies the address of a signal handler, then the I<sv_flags> field specifies flags controlling what happens when the handler is called.  This field may contain zero or more of the following flags:
fr: Si I<sv_handler> spécifie l'adresse d'un gestionnaire de signal, le champ I<sv_flags> spécifie des attributs contrôlant ce qui se passe lorsque le gestionnaire est appelé. Ce champ peut contenir zéro ou plus des attributs suivants\ :

note: type: Plain text
en: If the signal handler interrupts a blocking system call, then upon return from the handler the system call will not be restarted: instead it will fail with the error B<EINTR>.  If this flag is not specified, then system calls are restarted by default.
fr: Si le gestionnaire de signaux interrompt un appel système bloquant, l'appel système ne sera pas relancé au retour du gestionnaire. À la place, il échouera avec l'erreur B<EINTR>. Si cet attribut n'est pas spécifié, les appels système sont relancés par défaut.

note: type: Plain text
en: Reset the disposition of the signal to the default before calling the signal handler.  If this flag is not specified, then the handler remains established until explicitly removed by a later call to B<sigvec>()  or until the process performs an B<execve>(2).
fr: Réinitialiser le dispositif du signal à sa valeur par défaut avant d'appeler le gestionnaire de signaux. Si cet attribut n'est pas spécifié, le gestionnaire reste positionné jusqu'à ce qu'il soit explicitement supprimé par un appel ultérieur à B<sigvec>() ou jusqu'à ce que le processus effectue un B<execve>(2).

note: type: Plain text
en: Handle the signal on the alternate signal stack (historically established under BSD using the obsolete B<sigstack>()  function; the POSIX replacement is B<sigaltstack>(2)).
fr: Gère le signal sur la pile de signaux spécifique (historiquement positionné sous BSD avec la fonction obsolète B<sigstack>()\ ; la fonction POSIX qui la remplace est B<sigaltstack>(2)).

note: type: Plain text
en: The B<sigmask>()  macro constructs and returns a "signal mask" for I<signum>.  For example, we can initialize the I<vec.sv_mask> field given to B<sigvec>()  using code such as the following:
fr: La macro B<sigmask>() construit et renvoie un masque de signaux pour I<signum>. Par exemple, on peut initialiser le champ I<vec.sv_mask> passé à B<sigvec>() avec un code tel que le suivant\ :

note: type: Plain text
en:     vec.sv_mask = sigmask(SIGQUIT) | sigmask(SIGABRT);
                    /* Block SIGQUIT and SIGABRT during
                       handler execution */
fr:     vec.sv_mask = sigmask(SIGQUIT) | sigmask(SIGABRT);
                    /* Bloquer SIGQUIT et SIGABRT pendant
                       l'exécution du gestionnaire */

note: type: Plain text
en: The B<sigblock>()  function adds the signals in I<mask> to the process's signal mask (like POSIX I<sigprocmask(SIG_BLOCK)>), and returns the process's previous signal mask.  Attempts to block B<SIGKILL> or B<SIGSTOP> are silently ignored.
fr: La fonction B<sigblock>() ajoute les signaux de I<mask> au masque de signaux du processus (comme l'appel POSIX I<sigprocmask(SIG_BLOCK)>), et renvoie le masque de signaux précédent du processus. Toute tentative de bloquer B<SIGKILL> ou B<SIGSTOP> est silencieusement ignorée.

note: type: Plain text
en: The B<sigsetmask>()  function sets the process's signal mask to the value given in I<mask> (like POSIX I<sigprocmask(SIG_SETMASK)>), and returns the process's previous signal mask.
fr: La fonction B<sigsetmask>() configure le masque de signaux du processus à la valeur donnée dans I<mask> (comme l'appel POSIX I<sigprocmask(SIG_SETMASK)>), et renvoie le masque de signaux précédent du processus.

note: type: Plain text
en: The B<siggetmask>()  function returns the process's current signal mask.  This call is equivalent to I<sigblock(0)>.
fr: La fonction B<siggetmask>() renvoie le masque de signaux courant du processus. Cet appel est équivalent à I<sigblock(0)>.

note: type: Plain text
en: The B<sigvec>()  function returns 0 on success; on error, it returns -1 and sets I<errno> to indicate the error.
fr: Si elle réussit, la fonction B<sigvec>() renvoie 0. Si elle échoue, elle renvoie -1 et écrit I<errno> pour indiquer l'erreur.

note: type: Plain text
en: The B<sigblock>()  and B<sigsetmask>()  functions return the previous signal mask.
fr: Les fonctions B<sigblock>() et B<sigsetmask>() renvoient le masque de signaux précédent.

note: type: Plain text
en: The B<sigmask>()  macro returns the signal mask for I<signum>.
fr: La macro B<sigmask>() renvoie le masque de signaux pour I<signum>.

note: type: Plain text
en: See the ERRORS under B<sigaction>(2)  and B<sigprocmask>(2).
fr: Consultez la section ERREURS des pages de manuel B<sigaction>(2) et B<sigprocmask>(2).

note: type: Plain text
en: The B<sigvec>(), B<sigblock>(), B<sigsetmask>(), and B<siggetmask>()  functions are thread-safe.
fr: Les fonctions B<sigvec>(), B<sigblock>(), B<sigsetmask>() et B<siggetmask>() sont sûres dans un contexte multithread.

note: type: Plain text
en: The B<sigmask>()  macro is thread-safe.
fr: La macro B<sigmask>() est sûre dans un contexte multithread.

note: type: Plain text
en: All of these functions were in 4.3BSD, except B<siggetmask>(), whose origin is unclear.  These functions are obsolete: do not use them in new programs.
fr: Toutes ces fonctions étaient dans BSD\ 4.3, excepté B<siggetmask>(), dont l'origine n'est pas claire. Ces fonctions sont obsolètes. Ne les utilisez pas dans de nouveaux programmes.

note: type: Plain text
en: On 4.3BSD, the B<signal>()  function provided reliable semantics (as when calling B<sigvec>()  with I<vec.sv_mask> equal to 0).  On System V, B<signal>()  provides unreliable semantics.  POSIX.1-2001 leaves these aspects of B<signal>()  unspecified.  See B<signal>(2)  for further details.
fr: Sur BSD\ 4.3, la fonction B<signal>() fournit une sémantique fiable (comme lorsqu'on appelle B<sigvec>() avec I<vec.sv_mask> valant 0). Sur System V, la fonction B<signal>() fournit une sémantique non fiable. POSIX.1-2001 laisse ces aspects de B<signal>() non spécifiés. Consultez B<signal>(2) pour plus de détails.

note: type: Plain text
en: sigwait - wait for a signal
fr: sigwait - Attendre un signal

note: type: Plain text
en: The B<sigwait>()  function suspends execution of the calling thread until one of the signals specified in the signal set I<set> becomes pending.  The function accepts the signal (removes it from the pending list of signals), and returns the signal number in I<sig>.
fr: La fonction B<sigwait>()  suspend l'exécution du thread appelant jusqu'à ce que l'un des signaux indiqués dans l'ensemble de signaux I<set> soit en attente. La fonction accepte le signal (le supprime de la liste des signaux en attente), et retourne le numéro du signal dans I<sig>.

note: type: Plain text
en: The operation of B<sigwait>()  is the same as B<sigwaitinfo>(2), except that:
fr: L'action de B<sigwait>()  est identique à celle de B<sigwaitinfo>(2), excepté que\ :

note: type: Plain text
en: B<sigwait>()  returns only the signal number, rather than a I<siginfo_t> structure describing the signal.
fr: B<sigwait>()  ne retourne que le numéro du signal et pas la structure I<siginfo_t> décrivant le signal.

note: type: Plain text
en: The return values of the two functions are different.
fr: Les valeurs de retour des deux fonctions sont différentes.

note: type: Plain text
en: On success, B<sigwait>()  returns 0.  On error, it returns a positive error number (listed in ERRORS).
fr: Si elle réussit, B<sigwait>()  renvoie 0. Si elle échoue, elle renvoie un code d'erreur strictement positif (listé dans ERREURS).

note: Does not occur for glibc. type: Plain text
en: I<set> contains an invalid signal number.
fr: I<set> ne contient pas de numéro de signal valide.

note: type: Plain text
en: The B<sigwait>()  function is thread-safe.
fr: La fonction B<sigwait>() est sûre dans un contexte multithread.

note: type: Plain text
en: B<sigwait>()  is implemented using B<sigtimedwait>(2).
fr: B<sigwait>()  est implémentée autour de B<sigtimedwait>(2).

note: type: Plain text
en: See B<pthread_sigmask>(3).
fr: Consultez B<pthread_sigmask>(3).

note: type: TH
en: 2013-09-04
fr: 4 septembre 2013

note: type: Plain text
en: sigwaitinfo, sigtimedwait - synchronously wait for queued signals
fr: sigwaitinfo, sigtimedwait - Attente synchrone de signaux

note: type: Plain text
en: B<sigwaitinfo>(), B<sigtimedwait>(): _POSIX_C_SOURCE\ E<gt>=\ 199309L
fr: B<sigwaitinfo>(), B<sigtimedwait>() : _POSIX_C_SOURCE\ E<gt>=\ 199309L

note: type: Plain text
en: B<sigwaitinfo>()  suspends execution of the calling thread until one of the signals in I<set> is pending (If one of the signals in I<set> is already pending for the calling thread, B<sigwaitinfo>()  will return immediately.)
fr: B<sigwaitinfo>() suspend l'exécution du thread appelant jusqu'à ce que l'un des signaux de l'ensemble I<set> soit en attente. (Si l'un des signaux de l'ensemble I<set> est déjà en attente pour le thread appelant, B<sigwaitinfo>() retourne immédiatement).

note: type: Plain text
en: B<sigwaitinfo>()  removes the signal from the set of pending signals and returns the signal number as its function result.  If the I<info> argument is not NULL, then the buffer that it points to is used to return a structure of type I<siginfo_t> (see B<sigaction>(2))  containing information about the signal.
fr: B<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 I<info> n'est pas B<NULL>, alors le tampon vers lequel il pointe est utilisé pour renvoyer une structure du type I<siginfo_t> (consultez B<sigaction>(2)) contenant les informations concernant le signal.

note: type: Plain text
en: If multiple signals in I<set> are pending for the caller, the signal that is retrieved by B<sigwaitinfo>()  is determined according to the usual ordering rules; see B<signal>(7)  for further details.
fr: Si plusieurs signaux de I<set> sont mis en attente pour l'appelant, le signal récupéré B<sigwaitinfo>() est déterminé par les règles de classement habituelles. Consultez B<signal>(7) pour plus de détails.

note: type: Plain text
en: B<sigtimedwait>()  operates in exactly the same way as B<sigwaitinfo>()  except that it has an additional argument, I<timeout>, which specifies the interval for which the thread is suspended waiting for a signal.  (This interval will be rounded up to the system clock granularity, and kernel scheduling delays mean that the interval may overrun by a small amount.)  This argument is of the following type:
fr: B<sigtimedwait>() opère exactement comme B<sigwaitinfo>() mais elle a un argument supplémentaire, I<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\ :

note: type: Plain text
en: struct timespec {
        long    tv_sec;         /* seconds */
        long    tv_nsec;        /* nanoseconds */
    }
fr: struct timespec {
        long    tv_sec;         /* secondes */
        long    tv_nsec;        /* nanosecondes */
    }

note: type: Plain text
en: If both fields of this structure are specified as 0, a poll is performed: B<sigtimedwait>()  returns immediately, either with information about a signal that was pending for the caller, or with an error if none of the signals in I<set> was pending.
fr: Si les deux champs de cette structure sont nuls, B<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 I<set> n'étaient disponibles.

note: type: Plain text
en: On success, both B<sigwaitinfo>()  and B<sigtimedwait>()  return a signal number (i.e., a value greater than zero).  On failure both calls return -1, with I<errno> set to indicate the error.
fr: S'ils réussissent B<sigwaitinfo>() et B<sigtimedwait>() renvoient un numéro de signal (une valeur supérieure à zéro). S'ils échouent, ils renvoient -1, et I<errno> contient le code d'erreur.

note: type: Plain text
en: No signal in I<set> was became pending within the I<timeout> period specified to B<sigtimedwait>().
fr: Aucun signal de l'ensemble I<set> n'a été mis en attente avant expiration du délai I<timeout> indiqué pour B<sigtimedwait>().

note: type: Plain text
en: The wait was interrupted by a signal handler; see B<signal>(7).  (This handler was for a signal other than one of those in I<set>.)
fr: L'appel a été interrompu par un gestionnaire de signal ; consultez B<signal>(7). (Un signal autre que ceux présents dans l'ensemble I<set>.)

note: type: Plain text
en: I<timeout> was invalid.
fr: I<timeout> était invalide.

note: type: Plain text
en: In normal usage, the calling program blocks the signals in I<set> via a prior call to B<sigprocmask>(2)  (so that the default disposition for these signals does not occur if they become pending between successive calls to B<sigwaitinfo>()  or B<sigtimedwait>())  and does not establish handlers for these signals.  In a multithreaded program, the signal should be blocked in all threads, in order to prevent the signal being treated according to its default disposition in a thread other than the one calling B<sigwaitinfo>()  or B<sigtimedwait>()).
fr: En utilisation habituelle, l'appelant bloque les signaux de l'ensemble I<set> au préalable avec un appel B<sigprocmask>(2) (afin que la délivrance des signaux ne se produise pas s'ils sont mis en attente entre deux appels successifs à B<sigwaitinfo>() ou B<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 B<sigwaitinfo>() ou B<sigtimedwait>().

note: type: Plain text
en: The set of signals that is pending for a given thread is the union of the set of signals that is pending specifically for that thread and the set of signals that is pending for the process as a whole (see B<signal>(7)).
fr: 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 B<signal>(7)).

note: type: Plain text
en: Attempts to wait for B<SIGKILL> and B<SIGSTOP> are silently ignored.
fr: Les tentatives pour attendre B<SIGKILL> or B<SIGSTOP> seront ignorées silencieusement.

note: type: Plain text
en: If multiple threads of a process are blocked waiting for the same signal(s) in B<sigwaitinfo>()  or B<sigtimedwait>(), then exactly one of the threads will actually receive the signal if it becomes pending for the process as a whole; which of the threads receives the signal is indeterminate.
fr: Si plusieurs threads d'un processus sont bloqués dans B<sigwaitinfo>() ou B<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.

note: type: Plain text
en: POSIX leaves the meaning of a NULL value for the I<timeout> argument of B<sigtimedwait>()  unspecified, permitting the possibility that this has the same meaning as a call to B<sigwaitinfo>(), and indeed this is what is done on Linux.
fr: POSIX ne spécifie pas le comportement si une valeur NULL est indiquée pour l'argument I<timeout> de B<sigtimedwait>(), permettant par exemple d'avoir le même comportement que celui de B<sigwaitinfo>(), ce qui est le cas sous Linux.

note: type: Plain text
en: On Linux, B<sigwaitinfo>()  is a library function implemented on top of B<sigtimedwait>().
fr: Sous Linux, B<sigwaitinfo>() est une fonction de bibliothèque implémentée au dessus de B<sigtimedwait>().

note: type: TH
en: 2014-01-06
fr: 6 janvier 2014

note: type: Plain text
en: sysv_signal - signal handling with System V semantics
fr: sysv_signal - Gestion des signaux avec la sémantique System V

note: type: Plain text
en: B<#define _GNU_SOURCE> /* See feature_test_macros(7) */
fr: B<#define _GNU_SOURCE> /* Consultez feature_test_macros(7) */

note: type: Plain text
en: The B<sysv_signal>()  function takes the same arguments, and performs the same task, as B<signal>(2).
fr: La fonction B<sysv_signal>() prend les mêmes paramètres et effectue la même tâche que B<signal>(2).

note: type: Plain text
en: However B<sysv_signal>()  provides the System V unreliable signal semantics, that is: a) the disposition of the signal is reset to the default when the handler is invoked; b) delivery of further instances of the signal is not blocked while the signal handler is executing; and c) if the handler interrupts (certain) blocking system calls, then the system call is not automatically restarted.
fr: Cependant B<sysv_signal>() fournit la sémantique de gestion des signaux non sûrs de System V, c'est-à-dire : a) les caractéristiques des signaux sont remises aux valeur par défaut quand le gestionnaire est appelé ; b) la distribution des instances suivantes du signal n'est pas bloquée quand le gestionnaire de signal est exécuté ; et c) SI le gestionnaire interrompt (certains) appels système bloquants, alors l'appel système n'est pas redémarré automatiquement.

note: type: Plain text
en: The B<sysv_signal>()  function returns the previous value of the signal handler, or B<SIG_ERR> on error.
fr: La fonction B<sysv_signal>() renvoie le gestionnaire de signaux précédent ou B<SIG_ERR> en cas d'erreur.

note: type: Plain text
en: The B<sysv_signal>()  function is thread-safe.
fr: La fonction B<sysv_signal>() est sûre dans un contexte multithread.

note: type: Plain text
en: This function is nonstandard.
fr: Cette fonction n'est pas standard.

note: type: Plain text
en: Use of B<sysv_signal>()  should be avoided; use B<sigaction>(2)  instead.
fr: L'utilisation de B<sysv_signal>() est à éviter ; utilisez plutôt B<sigaction>(2).

note: type: Plain text
en: On older Linux systems, B<sysv_signal>()  and B<signal>(2)  were equivalent.  But on newer systems, B<signal>(2)  provides reliable signal semantics; see B<signal>(2)  for details.
fr: Sur les systèmes Linux plus anciens, B<sysv_signal>() et B<signal>(2) étaient équivalents. Mais sur les systèmes plus récents, B<signal>(2) fournit la sémantique pour les signaux sûrs ; consultez B<signal>(2) pour plus de détails.

note: type: TH
en: 2014-01-20
fr: 20 janvier 2014

note: type: Plain text
en: timer_create - create a POSIX per-process timer
fr: timer_create - Créer une minuterie POSIX pour un processus

note: type: Plain text
en: Link with I<-lrt>.
fr: Effectuez l'édition des liens avec l'option I<-lrt>.

note: type: Plain text
en: B<timer_create>(): _POSIX_C_SOURCE\ E<gt>=\ 199309L
fr: B<timer_create>()\ : _POSIX_C_SOURCE\ E<gt>=\ 199309L

note: type: Plain text
en: B<timer_create>()  creates a new per-process interval timer.  The ID of the new timer is returned in the buffer pointed to by I<timerid>, which must be a non-null pointer.  This ID is unique within the process, until the timer is deleted.  The new timer is initially disarmed.
fr: B<timer_create>() crée une nouvelle minuterie pour un processus. L'identifiant de cette nouvelle minuterie est renvoyé dans le tampon pointé par I<timerid>, qui doit être un pointeur différent de NULL. L'identifiant est unique pour le processus, jusqu'à ce que la minuterie soit détruite. La nouvelle minuterie est initialement désarmée.

note: type: Plain text
en: The I<clockid> argument specifies the clock that the new timer uses to measure time.  It can be specified as one of the following values:
fr: Le paramètre I<clockid> indique l'horloge que la nouvelle minuterie utilise pour mesurer le temps. Il peut prendre une des valeurs suivantes :

note: type: Plain text
en: A settable system-wide real-time clock.
fr: Une horloge temps réel configurable à l'échelle du système.

note: Note: the CLOCK_MONOTONIC_RAW clock added for clock_gettime() in 2.6.28 is not supported for POSIX timers -- mtk, Feb 2009 type: Plain text
en: A nonsettable monotonically increasing clock that measures time from some unspecified point in the past that does not change after system startup.
fr: Une horloge non configurable, toujours croissante qui mesure le temps depuis un instant non spécifié dans le passé et qui ne change pas après le démarrage du système.

note: type: TP
en: B<CLOCK_PROCESS_CPUTIME_ID> (since Linux 2.6.12)
fr: B<CLOCK_PROCESS_CPUTIME_ID> (depuis Linux 2.6.12)

note: type: Plain text
en: A clock that measures (user and system) CPU time consumed by (all of the threads in) the calling process.
fr: Une horloge qui mesure le temps CPU (utilisateur et système) consommé par le processus appelant (et tous ses threads).

note: type: TP
en: B<CLOCK_THREAD_CPUTIME_ID> (since Linux 2.6.12)
fr: B<CLOCK_THREAD_CPUTIME_ID> (depuis Linux 2.6.12)

note: The CLOCK_MONOTONIC_RAW that was added in 2.6.28 can't be used to create a timer -- mtk, Feb 2009 type: Plain text
en: A clock that measures (user and system) CPU time consumed by the calling thread.
fr: Une horloge qui mesure le temps CPU (utilisateur et système) consommé par le processus appelant.

note: type: Plain text
en: As well as the above values, I<clockid> can be specified as the I<clockid> returned by a call to B<clock_getcpuclockid>(3)  or B<pthread_getcpuclockid>(3).
fr: Comme pour les valeurs ci-dessus, I<clockid> peut être l'identifiant I<clockid> renvoyé par un appel à B<clock_getcpuclockid>(3) ou B<pthread_getcpuclockid>(3).

note: type: Plain text
en: The I<sevp> argument points to a I<sigevent> structure that specifies how the caller should be notified when the timer expires.  For the definition and general details of this structure, see B<sigevent>(7).
fr: Le paramètre I<sevp> pointe vers une structure I<sigevent> qui indique comment l'appelant devrait être notifié quand la minuterie expire. Pour la définition et des détails généraux sur cette structure, consultez B<sigevent>(7).

note: type: Plain text
en: The I<sevp.sigev_notify> field can have the following values:
fr: Le champ I<sevp.sigev_notify> peut avoir les valeurs suivantes\ :

note: type: Plain text
en: Don't asynchronously notify when the timer expires.  Progress of the timer can be monitored using B<timer_gettime>(2).
fr: Ne pas notifier de façon asynchrone quand la minuterie expire. La progression de la minuterie peut être observée en utilisant B<timer_gettime>(2).

note: type: Plain text
en: Upon timer expiration, generate the signal I<sigev_signo> for the process.  See B<sigevent>(7)  for general details.  The I<si_code> field of the I<siginfo_t> structure will be set to B<SI_TIMER>.  At any point in time, at most one signal is queued to the process for a given timer; see B<timer_getoverrun>(2)  for more details.
fr: Lors de l'expiration de la minuterie, produire le signal I<sigev_signo> pour le processus. Consultez B<sigevent>(7) pour des détails généraux. Le champ I<si_code> de la structure I<siginfo_t> sera mis à B<SI_TIMER>. À tout moment, au plus un signal est mis en attente pour le processus pour une horloge donnée ; consultez B<timer_getoverrun>(2) pour plus de détails.

note: type: Plain text
en: Upon timer expiration, invoke I<sigev_notify_function> as if it were the start function of a new thread.  See B<sigevent>(7)  for details.
fr: Lors de l'expiration de la minuterie, appeler I<sigev_notify_function> comme si elle était la fonction de démarrage d'un nouveau thread. Consultez B<sigevent>(7) pour plus de détails.

note: type: Plain text
en: As for B<SIGEV_SIGNAL>, but the signal is targeted at the thread whose ID is given in I<sigev_notify_thread_id>, which must be a thread in the same process as the caller.  The I<sigev_notify_thread_id> field specifies a kernel thread ID, that is, the value returned by B<clone>(2)  or B<gettid>(2).  This flag is intended only for use by threading libraries.
fr: Comme B<SIGEV_SIGNAL>, mais le signal est envoyé au thread dont l'identifiant est fourni dans I<sigev_notify_thread_id>, qui doit être un thread du même processus que le thread appelant. Le champ I<sigev_notify_thread_id> indique un identifiant de thread noyau, c'est-à-dire la valeur renvoyée par B<clone>(2) ou B<gettid>(2). Ce drapeau n'est destiné à être utilisé que par la bibliothèque des threads.

note: type: Plain text
en: Specifying I<sevp> as NULL is equivalent to specifying a pointer to a I<sigevent> structure in which I<sigev_notify> is B<SIGEV_SIGNAL>, I<sigev_signo> is B<SIGALRM>, and I<sigev_value.sival_int> is the timer ID.
fr: Une valeur NULL pour I<sevp> équivaut à indiquer un pointeur vers une structure I<sigevent> dans laquelle I<sigev_notify> vaut B<SIGEV_SIGNAL>, I<sigev_signo> vaut B<SIGALRM> et I<sigev_value.sival_int> vaut l'identifiant de l'horloge.

note: type: Plain text
en: On success, B<timer_create>()  returns 0, and the ID of the new timer is placed in I<*timerid>.  On failure, -1 is returned, and I<errno> is set to indicate the error.
fr: S'il réussit, B<timer_create>() renvoie zéro et l'identifiant de la nouvelle minuterie est placé dans I<*timerid>. En cas d'erreur, il renvoie -1 et I<errno> contient le code d'erreur.

note: type: Plain text
en: Temporary error during kernel allocation of timer structures.
fr: Erreur temporaire lors de l'allocation de la structure de la minuterie par le noyau.

note: type: Plain text
en: Clock ID, I<sigev_notify>, I<sigev_signo>, or I<sigev_notify_thread_id> is invalid.
fr: L'identifiant d'horloge, I<sigev_notify>, I<sigev_signo> ou I<sigev_notify_thread_id> n'est pas valable.

note: glibc layer: malloc() type: Plain text
en: Could not allocate memory.
fr: Impossible d'allouer de la mémoire.

note: type: Plain text
en: This system call is available since Linux 2.6.
fr: Cet appel système est disponible depuis Linux 2.6.

note: type: Plain text
en: A program may create multiple interval timers using B<timer_create>().
fr: Un programme peut créer plusieurs minuterie en utilisant B<timer_create>().

note: type: Plain text
en: Timers are not inherited by the child of a B<fork>(2), and are disarmed and deleted during an B<execve>(2).
fr: Les minuteries ne sont pas héritées par ses enfants lors d'un B<fork>(2) et sont désarmées et détruites lors d'un appel système B<execve>(2).

note: type: Plain text
en: The kernel preallocates a "queued real-time signal" for each timer created using B<timer_create>().  Consequently, the number of timers is limited by the B<RLIMIT_SIGPENDING> resource limit (see B<setrlimit>(2)).
fr: Le noyau alloue par avance un « signal temps réel en attente » pour chaque minuterie créée par B<timer_create>(). De ce fait, le nombre de minuteries est limité par la limite de ressources B<RLIMIT_SIGPENDING> (voir B<setrlimit>(2)).

note: type: Plain text
en: The timers created by B<timer_create>()  are commonly known as "POSIX (interval) timers".  The POSIX timers API consists of the following interfaces:
fr: Les minuteries créée par B<timer_create>() sont communément appelées « horloges (d'intervalle) POSIX ». L'API des minuteries POSIX est constituée des interfaces suivantes :

note: type: Plain text
en: B<timer_create>(): Create a timer.
fr: B<timer_create>() : Créer une minuterie.

note: type: Plain text
en: B<timer_settime>(2): Arm (start) or disarm (stop) a timer.
fr: B<timer_settime>(2) : Armer (démarrer) ou désarmer (stopper) une minuterie.

note: type: Plain text
en: B<timer_gettime>(2): Fetch the time remaining until the next expiration of a timer, along with the interval setting of the timer.
fr: B<timer_gettime>(2) : Récupérer le temps restant jusqu'à l'expiration suivante d'une minuterie, en plus de l'intervalle de la minuterie.

note: type: Plain text
en: B<timer_getoverrun>(2): Return the overrun count for the last timer expiration.
fr: B<timer_getoverrun>(2) : Renvoyer le décompte de dépassements pour la dernière expiration de la minuterie.

note: type: Plain text
en: B<timer_delete>(2): Disarm and delete a timer.
fr: B<timer_delete>(2) : Désarmer et détruire une minuterie.

note: type: Plain text
en: Part of the implementation of the POSIX timers API is provided by glibc.  In particular:
fr: Une partie de l'implémentation des minuteries POSIX est fournie par la glibc. En particulier :

note: type: Plain text
en: The functionality for B<SIGEV_THREAD> is implemented within glibc, rather than the kernel.
fr: La fonctionnalité de B<SIGEV_THREAD> est implémentée dans la glibc, plutôt que par le noyau.

note: See the glibc source file kernel-posix-timers.h for the structure that glibc uses to map user-space timer IDs to kernel timer IDs The kernel-level timer ID is exposed via siginfo.si_tid. type: Plain text
en: The timer IDs presented at user level are maintained by glibc, which maps these IDs to the timer IDs employed by the kernel.
fr: Les identifiants de minuteries fournis au niveau utilisateur sont maintenus par la glibc, qui fait la correspondance avec les identifiants utilisés par le noyau.

note: type: Plain text
en: The POSIX timers system calls first appeared in Linux 2.6.  Prior to this, glibc provided an incomplete user-space implementation (B<CLOCK_REALTIME> timers only) using POSIX threads, and current glibc falls back to this implementation on systems running pre-2.6 Linux kernels.
fr: Les appels système pour les minuteries POSIX sont apparus dans le noyaux Linux 2.6. Auparavant, la glibc fournissait une implémentation incomplète en espace utilisateur (les minuteries B<CLOCK_REALTIME> uniquement) en utilisant les threads POSIX, et la glibc actuelle utilise toujours cette implémentation sur les systèmes ayant un noyau antérieur au noyau Linux 2.6.

note: type: Plain text
en: Since Linux 3.10, the I</proc/[pid]/timers> file can be used to list the POSIX timers for the process with PID I<pid>.  See B<proc>(5)  for further information.
fr: Depuis Linux 3.10, le fichier I</proc/[pid]/timers> peut être utilisé pour lister les minuteries POSIX du processus de PID I<pid>. Consultez B<proc>(5) pour plus de détails.

note: type: Plain text
en: The program below takes two arguments: a sleep period in seconds, and a timer frequency in nanoseconds.  The program establishes a handler for the signal it uses for the timer, blocks that signal, creates and arms a timer that expires with the given frequency, sleeps for the specified number of seconds, and then unblocks the timer signal.  Assuming that the timer expired at least once while the program slept, the signal handler will be invoked, and the handler displays some information about the timer notification.  The program terminates after one invocation of the signal handler.
fr: Le programme ci-dessous reçoit deux paramètres : une durée de sommeil, en seconde, et une fréquence de minuterie en nanosecondes. Le programme établit un gestionnaire pour le signal qu'il utilise avec la minuterie, puis il bloque le signal, crée et arme une minuterie qui expire à la fréquence donnée, s'endort pendant la durée indiquée et enfin débloque le signal de la minuterie. En supposant que la minuterie ait expiré au moins une fois pendant le sommeil du programme, le gestionnaire de signal sera appelé et le gestionnaire de signal affiche des informations concernant la notification de la minuterie. Le programme se termine après un appel au gestionnaire de signal.

note: type: Plain text
en: In the following example run, the program sleeps for 1 second, after creating a timer that has a frequency of 100 nanoseconds.  By the time the signal is unblocked and delivered, there have been around ten million overruns.
fr: Dans l'exemple d'exécution qui suit, le programme s'endort pour une seconde après avoir créé une minuterie de d'une fréquence de 100 nanosecondes. Le temps que le signal soit débloqué et fournit, il y a eu environ dix millions de dépassements.

note: type: Plain text
en: $ B<./a.out 1 100>
    Establishing handler for signal 34
    Blocking signal 34
    timer ID is 0x804c008
    Sleeping for 1 seconds
    Unblocking signal 34
    Caught signal 34
        sival_ptr = 0xbfb174f4;     *sival_ptr = 0x804c008
        overrun count = 10004886
fr: $ B<./a.out 1 10>
    Establishing handler for signal 34
    Blocking signal 34
    timer ID is 0x804c008
    Sleeping for 1 seconds
    Unblocking signal 34
    Caught signal 34
        sival_ptr = 0xbfb174f4;     *sival_ptr = 0x804c008
        overrun count = 10004886

note: type: TH
en: 2009-02-20
fr: 20 février 2009

note: type: Plain text
en: timer_delete - delete a POSIX per-process timer
fr: timer_delete - Détruire une minuterie POSIX d'un processus

note: type: Plain text
en: B<timer_delete>(): _POSIX_C_SOURCE\ E<gt>=\ 199309L
fr: B<timer_delete>()\ : _POSIX_C_SOURCE\ E<gt>=\ 199309L

note: type: Plain text
en: B<timer_delete>()  deletes the timer whose ID is given in I<timerid>.  If the timer was armed at the time of this call, it is disarmed before being deleted.  The treatment of any pending signal generated by the deleted timer is unspecified.
fr: B<timer_delete>() détruit la minuterie dont l'identifiant est fournit par I<timerid>. Si la minuterie était armée au moment de l'appel, elle est désarmée avant d'être détruite. Le traitement des signaux en cours produits par la minuterie détruite n'est pas spécifié.

note: type: Plain text
en: On success, B<timer_delete>()  returns 0.  On failure, -1 is returned, and I<errno> is set to indicate the error.
fr: S'il réussit B<timer_delete>() renvoie zéro, sinon il renvoie -1 et remplit I<errno> avec le code d'erreur.

note: type: Plain text
en: I<timerid> is not a valid timer ID.
fr: I<timerid> n'est pas un identifiant de minuterie valable.

note: type: Plain text
en: timer_getoverrun - get overrun count for a POSIX per-process timer
fr: timer_getoverrun - Obtenir le nombre de dépassements d'une minuterie POSIX d'un processus

note: type: Plain text
en: B<timer_getoverrun>(): _POSIX_C_SOURCE\ E<gt>=\ 199309L
fr: B<timer_getoverrun>() : _POSIX_C_SOURCE\ E<gt>=\ 199309L

note: type: Plain text
en: B<timer_getoverrun>()  returns the "overrun count" for the timer referred to by I<timerid>.  An application can use the overrun count to accurately calculate the number of timer expirations that would have occurred over a given time interval.  Timer overruns can occur both when receiving expiration notifications via signals (B<SIGEV_SIGNAL>), and via threads (B<SIGEV_THREAD>).
fr: B<timer_getoverrun>() renvoie le compteur de dépassements pour la minuterie indiquée par I<timerid>. Une application peut utiliser le compteur de dépassements pour calculer avec précision le nombre d'expiration qui se seraient écoulée dans un intervalle de temps donné. Les dépassements de minuterie peuvent survenir lors de la réception d'une notification par un signal (B<SIGEV_SIGNAL>) ou par un thread (B<SIGEV_THREAD>).

note: type: Plain text
en: When expiration notifications are delivered via a signal, overruns can occur as follows.  Regardless of whether or not a real-time signal is used for timer notifications, the system queues at most one signal per timer.  (This is the behavior specified by POSIX.1-2001.  The alternative, queuing one signal for each timer expiration, could easily result in overflowing the allowed limits for queued signals on the system.)  Because of system scheduling delays, or because the signal may be temporarily blocked, there can be a delay between the time when the notification signal is generated and the time when it is delivered (e.g., caught by a signal handler) or accepted (e.g., using B<sigwaitinfo>(2)).  In this interval, further timer expirations may occur.  The timer overrun count is the number of additional timer expirations that occurred between the time when the signal was generated and when it was delivered or accepted.
fr: Quand les notifications d'expiration sont fournies par un signal, les dépassements peuvent survenir de cette façon. Qu'un signal temps réel soit utilisé ou non pour les notifications de la minuterie, le système empile au plus un signal par minuterie. (Il s'agit du comportement spécifié par POSIX.1-2001. L'alternative, empiler un signal pour chaque expiration de minuterie, pourrait facilement dépasser les limites permises pour l'empilement de signaux sur le système.) Pour des raisons de délais d'ordonnancement, ou parce que le signal peut avoir été bloqué pendant un moment, il peut y avoir un délai entre le moment ou le signal de notification est produit et le moment ou il est reçu (par le gestionnaire de signal) ou accepté (par exemple en utilisant B<sigwaitinfo>(2)). Dans cet intervalle, d'autres expirations de minuterie peuvent survenir. Le compteur de dépassements de la minuterie correspond au nombre d'expirations supplémentaires qui se sont produites entre le moment où le signal a été produit et le moment ou il a été reçu ou accepté.

note: type: Plain text
en: Timer overruns can also occur when expiration notifications are delivered via invocation of a thread, since there may be an arbitrary delay between an expiration of the timer and the invocation of the notification thread, and in that delay interval, additional timer expirations may occur.
fr: Les dépassements de minuterie peuvent aussi se produire lorsque les notifications d'expirations sont fournies par un appel à un thread puisqu'il peut y avoir un délai arbitraire entre l'expiration de la minuterie et l'exécution du thread de notification et que dans l'intervalle de ce délai, d'autres expirations de minuterie peuvent se produire.

note: type: Plain text
en: On success, B<timer_getoverrun>()  returns the overrun count of the specified timer; this count may be 0 if no overruns have occurred.  On failure, -1 is returned, and I<errno> is set to indicate the error.
fr: S'il réussit, B<timer_getoverrun>() renvoie le compteur d'expirations de la minuterie indiquée ; ce compteur peut valoir 0 si aucune expiration n'a eu lieu. S'il échoue, il renvoie -1 et écrit I<errno> en conséquence.

note: type: Plain text
en: When timer notifications are delivered via signals (B<SIGEV_SIGNAL>), on Linux it is also possible to obtain the overrun count via the I<si_overrun> field of the I<siginfo_t> structure (see B<sigaction>(2)).  This allows an application to avoid the overhead of making a system call to obtain the overrun count, but is a nonportable extension to POSIX.1-2001.
fr: Lorsque les notifications de minuterie sont fournies par des signaux (B<SIGEV_SIGNAL>), il est possible sous Linux d'obtenir le compteur de dépassements par le champ I<si_overrun> de la structure I<siginfo_t> (consultez B<sigaction>(2)). Ce permet à une application d'éviter le surcoût d'un appel système pour obtenir le compteur de dépassements, mais est une extension à POSIX.1-2001 non portable.

note: FIXME . Austin bug filed, 11 Feb 09 type: Plain text
en: POSIX.1-2001 discusses timer overruns only in the context of timer notifications using signals.
fr: POSIX.1-2001 ne mentionne les dépassements de minuteries que dans le contexte de notifications de minuteries par des signaux.

note: Bug filed: http://bugzilla.kernel.org/show_bug.cgi?id=12665 http://thread.gmane.org/gmane.linux.kernel/113276/ type: Plain text
en: POSIX.1-2001 specifies that if the timer overrun count is equal to or greater than an implementation-defined maximum, B<DELAYTIMER_MAX>, then B<timer_getoverrun>()  should return B<DELAYTIMER_MAX>.  However, Linux does not implement this feature: instead, if the timer overrun value exceeds the maximum representable integer, the counter cycles, starting once more from low values.
fr: POSIX.1-2001 spécifie que si le compteur de dépassements de la minuterie est supérieur ou égal au maximum défini par l'implémentation (B<DELAYTIMER_MAX>), alors B<timer_getoverrun>() devrait renvoyer B<DELAYTIMER_MAX>. Cependant Linux n'implémente pas cette fonctionnalité : à la place, si le nombre de dépassements dépasse l'entier le plus grand représentable, le compteur redémarre à partir des petites valeurs.

note: type: Plain text
en: See B<timer_create>(2).
fr: Consultez B<timer_create>(2).

note: type: TH
en: 2012-10-15
fr: 15 octobre 2012

note: type: Plain text
en: timer_settime, timer_gettime - arm/disarm and fetch state of POSIX per-process timer
fr: timer_settime, timer_gettime - Armer, désarmer et récupérer l'état d'une minuterie POSIX d'un processus

note: type: Plain text
en: B<timer_settime>()  arms or disarms the timer identified by I<timerid>.  The I<new_value> argument is pointer to an I<itimerspec> structure that specifies the new initial value and the new interval for the timer.  The I<itimerspec> structure is defined as follows:
fr: B<timer_settime>() arme et désarme la minuterie indiquée par I<timerid>. Le paramètre I<new_value> est un pointeur vers une structure I<itimerspec> qui indique la nouvelle valeur initiale et le nouvel intervalle pour la minuterie. La structure I<itimerspec> est définie comme ceci :

note: type: Plain text
en: struct timespec {
        time_t tv_sec;                /* Seconds */
        long   tv_nsec;               /* Nanoseconds */
    };
fr: struct timespec {
        time_t tv_sec;                /* Secondes */
        long   tv_nsec;               /* Nanosecondes */
    };

note: type: Plain text
en: struct itimerspec {
        struct timespec it_interval;  /* Timer interval */
        struct timespec it_value;     /* Initial expiration */
    };
fr: struct itimerspec {
        struct timespec it_interval;  /* Intervalle pour les
                                         minuteries périodiques */
        struct timespec it_value;     /* Expiration initiale */
    };

note: type: Plain text
en: Each of the substructures of the I<itimerspec> structure is a I<timespec> structure that allows a time value to be specified in seconds and nanoseconds.  These time values are measured according to the clock that was specified when the timer was created by B<timer_create>(2)
fr: Chacune des sous-structures de la structure I<itimerspec> est une structure I<timespec> qui permet d'indiquer une valeur en secondes et en nanosecondes. Ces valeurs sont mesurée en fonction de l'horloge qui a été indiquée lorsque la minuterie a été créée avec B<timer_create>(2).

note: type: Plain text
en: If I<new_value-E<gt>it_value> specifies a nonzero value (i.e., either subfield is nonzero), then B<timer_settime>()  arms (starts) the timer, setting it to initially expire at the given time.  (If the timer was already armed, then the previous settings are overwritten.)  If I<new_value-E<gt>it_value> specifies a zero value (i.e., both subfields are zero), then the timer is disarmed.
fr: Si I<new_value-E<gt>it_value> indique une valeur non nulle (c'est-à-dire qu'un de ses champs n'est pas nul), alors B<timer_settime>() arme (démarre) la minuterie, en la configurant pour qu'elle expire au moment donnée (si la minuterie était déjà armée, sa configuration précédente est remplacée). Si I<new_value-E<gt>it_value> a une valeur nulle (c'est-à-dire si ses deux champs sont nuls), alors la minuterie est désarmée.

note: type: Plain text
en: The I<new_value-E<gt>it_interval> field specifies the period of the timer, in seconds and nanoseconds.  If this field is nonzero, then each time that an armed timer expires, the timer is reloaded from the value specified in I<new_value-E<gt>it_interval>.  If I<new_value-E<gt>it_interval> specifies a zero value, then the timer expires just once, at the time specified by I<it_value>.
fr: Le champ I<new_value-E<gt>it_interval> indique la période de la minuterie, en secondes et nanosecondes. Si ce champ n'est pas nul alors à chaque fois qu'une minuterie armée expire, la minuterie est rechargée avec la valeur indiquée dans I<new_value-E<gt>it_interval>. Si I<new_value-E<gt>it_interval> est nul, alors la minuterie n'expire qu'une fois, une fois que le temps défini par I<it_value> est écoulé.

note: By experiment: the overrun count is set correctly, for CLOCK_REALTIME. type: Plain text
en: By default, the initial expiration time specified in I<new_value-E<gt>it_value> is interpreted relative to the current time on the timer's clock at the time of the call.  This can be modified by specifying B<TIMER_ABSTIME> in I<flags>, in which case I<new_value-E<gt>it_value> is interpreted as an absolute value as measured on the timer's clock; that is, the timer will expire when the clock value reaches the value specified by I<new_value-E<gt>it_value>.  If the specified absolute time has already passed, then the timer expires immediately, and the overrun count (see B<timer_getoverrun>(2))  will be set correctly.
fr: Par défaut, le temps d'expiration initial indiqué par I<new_value-E<gt>it_value> est interprété par rapport à l'instant actuel sur l'horloge de la minuterie au moment de l'appel. Ceci peut être modifié en indiquant B<TIMER_ABSTIME> dans I<flags>, I<new_value-E<gt>it_value> étant alors interprété comme une valeur absolue mesurée sur l'horloge de la minuterie ; c'est-à-dire que la minuterie expirera quand la valeur de l'horloge atteint la valeur indiquée par I<new_value-E<gt>it_value>. Si le temps absolu indiqué est déjà passé, alors la minuterie expire immédiatement et le compteur de dépassement (consultez B<timer_getoverrun>(2)) est positionné en conséquence.

note: Similar remarks might apply with respect to process and thread CPU time clocks, but these clocks are not currently (2.6.28) settable on Linux. type: Plain text
en: If the value of the B<CLOCK_REALTIME> clock is adjusted while an absolute timer based on that clock is armed, then the expiration of the timer will be appropriately adjusted.  Adjustments to the B<CLOCK_REALTIME> clock have no effect on relative timers based on that clock.
fr: Si la valeur de l'horloge B<CLOCK_REALTIME> est ajustée et qu'une minuterie absolue basée sur cette horloge est armée, alors l'expiration de cette minuterie sera ajustée en conséquence. Les ajustements de l'horloge B<CLOCK_REALTIME> n'ont aucun effet sur les minuteries relatives basées sur cette horloge.

note: type: Plain text
en: If I<old_value> is not NULL, then it points to a buffer that is used to return the previous interval of the timer (in I<old_value-E<gt>it_interval>)  and the amount of time until the timer would previously have next expired (in I<old_value-E<gt>it_value>).
fr: Si I<old_value> n'est pas NULL, alors il pointe vers un tampon qui est utilisé pour renvoyer l'intervalle précédent de la minuterie (dans I<old_value-E<gt>it_interval>) et la durée qu'il restait avant l'expiration suivante de la minuterie (dans I<old_value-E<gt>it_value>).

note: type: Plain text
en: B<timer_gettime>()  returns the time until next expiration, and the interval, for the timer specified by I<timerid>, in the buffer pointed to by I<curr_value>.  The time remaining until the next timer expiration is returned in I<curr_value-E<gt>it_value>; this is always a relative value, regardless of whether the B<TIMER_ABSTIME> flag was used when arming the timer.  If the value returned in I<curr_value-E<gt>it_value> is zero, then the timer is currently disarmed.  The timer interval is returned in I<curr_value-E<gt>it_interval>.  If the value returned in I<curr_value-E<gt>it_interval> is zero, then this is a "one-shot" timer.
fr: B<timer_gettime>() renvoie dans le tampon pointé par I<curr_value> le temps restant avant l'expiration suivante et l'intervalle de la minuterie indiquée par I<timerid>. Le temps restant avant l'expiration suivante est renvoyé dans I<curr_value-E<gt>it_value> ; il s'agit toujours d'une valeur relative, que le drapeau B<TIMER_ABSTIME> soit utilisé ou non lorsque la minuterie est armée. Si la valeur renvoyée dans I<curr_value-E<gt>it_value> est nulle, alors la minuterie était désarmée au moment de l'appel. L'intervalle de la minuterie est renvoyée dans I<curr_value-E<gt>it_interval>. Si la valeur renvoyée dans I<curr_value-E<gt>it_interval> est nulle, alors il s'agit d'une minuterie à un coup.

note: type: Plain text
en: On success, B<timer_settime>()  and B<timer_gettime>()  return 0.  On error, -1 is returned, and I<errno> is set to indicate the error.
fr: En cas de réussite, B<timer_settime>() et B<timer_gettime>() renvoient zéro. En cas d'erreur, -1 est renvoyé et I<errno> indique le code d'erreur.

note: type: Plain text
en: These functions may fail with the following errors:
fr: Ces fonctions peuvent échouer avec les erreurs suivantes :

note: type: Plain text
en: I<new_value>, I<old_value>, or I<curr_value> is not a valid pointer.
fr: I<new_value>, I<old_value> ou I<curr_value> n'est pas un pointeur valable.

note: FIXME . eventually: invalid value in flags type: Plain text
en: I<timerid> is invalid.
fr: I<timerid> n'est pas valable

note: type: Plain text
en: B<timer_settime>()  may fail with the following errors:
fr: B<timer_settime>() peut échouer avec les erreurs suivantes :

note: type: Plain text
en: I<new_value.it_value> is negative; or I<new_value.it_value.tv_nsec> is negative or greater than 999,999,999.
fr: I<new_value.it_value> est négatif ; ou I<new_value.it_value.tv_nsec> est négatif ou supérieur à 999,999,999.

note: type: Plain text
en: These system calls are available since Linux 2.6.
fr: Ces appels systèmes sont disponibles depuis Linux 2.6.

note: type: TH
en: 2011-09-14
fr: 14 septembre 2011

note: type: Plain text
en: timerfd_create, timerfd_settime, timerfd_gettime - timers that notify via file descriptors
fr: timerfd_create, timerfd_settime, timerfd_gettime - Minuteries qui informent par l'intermédiaire de descripteurs de fichier

note: type: Plain text
en: These system calls create and operate on a timer that delivers timer expiration notifications via a file descriptor.  They provide an alternative to the use of B<setitimer>(2)  or B<timer_create>(2), with the advantage that the file descriptor may be monitored by B<select>(2), B<poll>(2), and B<epoll>(7).
fr: Ces appels système créent et opèrent sur une minuterie qui fournit des notifications d'expiration par un descripteur de fichier. Ils fournissent une alternative à B<setitimer>(2) ou B<timer_create>(2) avec l'avantage que le descripteur de fichier peut être surveillé avec B<select>(2), B<poll>(2) ou B<epoll>(7).

note: type: Plain text
en: The use of these three system calls is analogous to the use of B<timer_create>(2), B<timer_settime>(2), and B<timer_gettime>(2).  (There is no analog of B<timer_getoverrun>(2), since that functionality is provided by B<read>(2), as described below.)
fr: L'utilisation de ces trois appels système est analogue à l'utilisation de B<timer_create>(2), B<timer_settime>(2) et B<timer_gettime>(2). (Il n'y a pas d'équivalent à B<timer_getoverrun>(2) puisque cette fonctionnalité est fournie par B<read>(2), comme décrit ci-dessous)

note: type: Plain text
en: B<timerfd_create>()  creates a new timer object, and returns a file descriptor that refers to that timer.  The I<clockid> argument specifies the clock that is used to mark the progress of the timer, and must be either B<CLOCK_REALTIME> or B<CLOCK_MONOTONIC>.  B<CLOCK_REALTIME> is a settable system-wide clock.  B<CLOCK_MONOTONIC> is a nonsettable clock that is not affected by discontinuous changes in the system clock (e.g., manual changes to system time).  The current value of each of these clocks can be retrieved using B<clock_gettime>(2).
fr: B<timerfd_create>() crée une minuterie, et renvoie un descripteur de fichier qui se réfère à cette minuterie. Le paramètre I<clockid> spécifie l'horloge qui est utilisée pour faire progresser la minuterie, et doit valoir soit B<CLOCK_REALTIME>, soit B<CLOCK_MONOTONIC>. B<CLOCK_REALTIME> est une horloge configurable du système. B<CLOCK_MONOTONIC> n'est pas configurable, c'est-à-dire qu'elle n'est pas affectée par des modifications discontinues de l'horloge système (par exemple, par des modifications manuelles de l'heure du système). L'heure de chacune de ces horloge peut être interrogée à l'aide de B<clock_gettime>(2).

note: type: Plain text
en: Starting with Linux 2.6.27, the following values may be bitwise ORed in I<flags> to change the behavior of B<timerfd_create>():
fr: À partir de Linux 2.6.27, les valeurs suivantes peuvent être incluses avec un OU binaire dans I<flags> pour changer le comportement de B<timerfd_create>() :

note: type: Plain text
en: In Linux versions up to and including 2.6.26, I<flags> must be specified as zero.
fr: Dans les versions de Linux jusqu'à la version 2.6.26 incluse, I<flags> doit être nul.

note: type: Plain text
en: B<timerfd_settime>()  arms (starts) or disarms (stops)  the timer referred to by the file descriptor I<fd>.
fr: B<timerfd_settime>() arme (démarre) ou désarme (stoppe) la minuterie à laquelle se réfère le descripteur de fichier I<fd>.

note: type: Plain text
en: The I<new_value> argument specifies the initial expiration and interval for the timer.  The I<itimer> structure used for this argument contains two fields, each of which is in turn a structure of type I<timespec>:
fr: Le paramètre I<new_value> spécifie l'expiration initiale et l'intervalle de la minuterie. La structure I<itimer> utilisée pour ce paramètre contient deux champs, chacun d'entre eux étant une structure de type I<timespec> :

note: type: Plain text
en: struct itimerspec {
        struct timespec it_interval;  /* Interval for periodic timer */
        struct timespec it_value;     /* Initial expiration */
    };
fr: struct itimerspec {
        struct timespec it_interval;  /* Intervalle pour les
                                         minuteries périodiques */
        struct timespec it_value;     /* Expiration initiale */
    };

note: type: Plain text
en: I<new_value.it_value> specifies the initial expiration of the timer, in seconds and nanoseconds.  Setting either field of I<new_value.it_value> to a nonzero value arms the timer.  Setting both fields of I<new_value.it_value> to zero disarms the timer.
fr: I<new_value.it_value> spécifie l'expiration initiale de la minuterie, en secondes et nanosecondes. Une valeur non nulle dans un des champs de I<new_value.it_value> arme la minuterie. La minuterie est désarmée si les deux champs de I<new_value.it_value> sont mis à zéro.

note: type: Plain text
en: Setting one or both fields of I<new_value.it_interval> to nonzero values specifies the period, in seconds and nanoseconds, for repeated timer expirations after the initial expiration.  If both fields of I<new_value.it_interval> are zero, the timer expires just once, at the time specified by I<new_value.it_value>.
fr: Une valeur non nulle dans un des champs de I<new_value.it_interval> configure la période, en secondes et nanosecondes, pour une expiration répétitive après l'expiration initiale. Si les deux champs de I<new_value.it_interval> sont nuls, la minuterie expirera qu'une seule fois, dont l'heure est spécifiée dans I<new_value.it_value>.

note: type: Plain text
en: The I<flags> argument is either 0, to start a relative timer (I<new_value.it_value> specifies a time relative to the current value of the clock specified by I<clockid>), or B<TFD_TIMER_ABSTIME>, to start an absolute timer (I<new_value.it_value> specifies an absolute time for the clock specified by I<clockid>; that is, the timer will expire when the value of that clock reaches the value specified in I<new_value.it_value>).
fr: Le paramètre I<flags> est soit nul, pour démarrer une minuterie « relative » (I<new_value.it_interval> spécifie un temps relatif à la valeur actuelle de l'horloge spécifiée par I<clockid>), ou B<TFD_TIMER_ABSTIME>, pour démarrer une minuterie « absolue » (I<new_value.it_value> spécifie un temps absolu pour l'horloge spécifiée par I<clockid> ; cela signifie que la minuterie expirera quand la valeur de l'horloge atteindra la valeur spécifiée par I<new_value.it_value>).

note: type: Plain text
en: If the I<old_value> argument is not NULL, then the I<itimerspec> structure that it points to is used to return the setting of the timer that was current at the time of the call; see the description of B<timerfd_gettime>()  following.
fr: Si le paramètre I<old_value> n'est pas égal à NULL. la structure I<itimerspec> vers laquelle il pointe est utilisée pour renvoyer la configuration de la minuterie au moment de l'appel ; consultez la description de B<timerfd_gettime>() ci-dessous.

note: type: Plain text
en: B<timerfd_gettime>()  returns, in I<curr_value>, an I<itimerspec> structure that contains the current setting of the timer referred to by the file descriptor I<fd>.
fr: B<timerfd_gettime>() renvoie, dans I<curr_value>, une structure I<itimerspec> qui contient les paramètres actuels de la minuterie auquel le descripteur de fichier I<fd> fait référence.

note: type: Plain text
en: The I<it_value> field returns the amount of time until the timer will next expire.  If both fields of this structure are zero, then the timer is currently disarmed.  This field always contains a relative value, regardless of whether the B<TFD_TIMER_ABSTIME> flag was specified when setting the timer.
fr: Le champ I<it_value> renvoie la durée jusqu'à la prochaine expiration. Si les deux champs de cette structure sont nuls, alors la minuterie est actuellement désactivée. Ce champ contient toujours une valeur relative, sans tenir compte d'un attribut B<TFD_TIMER_ABSTIME> qui aurait été spécifié quand la minuterie a été configurée.

note: type: Plain text
en: The I<it_interval> field returns the interval of the timer.  If both fields of this structure are zero, then the timer is set to expire just once, at the time specified by I<curr_value.it_value>.
fr: Le champ I<it_interval> renvoie la période de la minuterie. Si les deux champs de cette structure sont nuls, alors la minuteries est configurée pour n'expirer qu'une seule fois, à l'heure spécifiée par I<curr_value.it_value>.

note: type: SS
en: Operating on a timer file descriptor
fr: Opérations sur un descripteur de fichier de minuterie

note: type: Plain text
en: The file descriptor returned by B<timerfd_create>()  supports the following operations:
fr: Le descripteur de fichier renvoyé par B<timerfd_create>() gère les opérations suivante :

note: type: Plain text
en: If the timer has already expired one or more times since its settings were last modified using B<timerfd_settime>(), or since the last successful B<read>(2), then the buffer given to B<read>(2)  returns an unsigned 8-byte integer (I<uint64_t>)  containing the number of expirations that have occurred.  (The returned value is in host byte order\(emthat is, the native byte order for integers on the host machine.)
fr: Si la minuterie a déjà expirée une fois ou plus depuis que sa configuration a été modifiée la dernière fois à l'aide de B<timerfd_settime>() ou depuis la dernière lecture avec B<read>(2) qui a réussi, alors le tampon fourni à B<read>(2) renvoie un entier non signé sur 8 octets (I<uint64_t>) qui contient le nombre d'expirations qui se sont produites. (La valeur renvoyée utilise l'ordre des octets de l'hôte, c'est-à-dire l'ordre des octets natif pour les entiers sur la machine hôte)

note: type: Plain text
en: If no timer expirations have occurred at the time of the B<read>(2), then the call either blocks until the next timer expiration, or fails with the error B<EAGAIN> if the file descriptor has been made nonblocking (via the use of the B<fcntl>(2)  B<F_SETFL> operation to set the B<O_NONBLOCK> flag).
fr: Si aucune expiration ne s'est produite au moment de l'appel à B<read>(2), l'appel bloquera jusqu'à la prochaine expiration ou échouera avec l'erreur B<EAGAIN> si le descripteur de fichier est en mode non bloquant (l'opération B<fcntl>(2) B<F_SETFL> a été utilisée avec un attribut B<O_NONBLOCK>).

note: type: Plain text
en: A B<read>(2)  will fail with the error B<EINVAL> if the size of the supplied buffer is less than 8 bytes.
fr: Un B<read>(2) échouera avec l'erreur B<EINVAL> si la taille du tampon fourni est de moins de 8 octets.

note: type: Plain text
en: The file descriptor is readable (the B<select>(2)  I<readfds> argument; the B<poll>(2)  B<POLLIN> flag)  if one or more timer expirations have occurred.
fr: Le descripteur de fichier est lisible (le paramètre I<readfds> de B<select>(2) ; l'attribut B<POLLIN> de B<poll>(2)) si une expiration (ou plus) de la minuterie s'est produite.

note: type: Plain text
en: The file descriptor also supports the other file-descriptor multiplexing APIs: B<pselect>(2), B<ppoll>(2), and B<epoll>(7).
fr: Le descripteur de fichier prend également en charge les autres interfaces de multiplexage de descripteurs de fichier : B<pselect>(2), B<ppoll>(2) et B<epoll>(7).

note: type: Plain text
en: When the file descriptor is no longer required it should be closed.  When all file descriptors associated with the same timer object have been closed, the timer is disarmed and its resources are freed by the kernel.
fr: Quand le descripteur de fichier n'est plus nécessaire il doit être fermé. Quand tous les descripteurs de fichier associés au même objet minuterie ont été fermés, les ressources pour cet objet sont libérées par le noyau.

note: type: Plain text
en: After a B<fork>(2), the child inherits a copy of the file descriptor created by B<timerfd_create>().  The file descriptor refers to the same underlying timer object as the corresponding file descriptor in the parent, and B<read>(2)s in the child will return information about expirations of the timer.
fr: Après un B<fork>(2), le fils hérite d'une copie du descripteur de fichier créé par B<timerfd_create>(). Le descripteur de fichier se réfère à la même minuterie sous-jacente que le descripteur de fichier correspondant du père, et un B<read>(2) du fils renverra les informations sur la minuterie.

note: type: Plain text
en: A file descriptor created by B<timerfd_create>()  is preserved across B<execve>(2), and continues to generate timer expirations if the timer was armed.
fr: Un descripteur de fichier créé par B<timerfd_create>() est conservé au travers d'un B<execve>(2), et continue à générer des expirations de minuterie si la minuterie a été armée.

note: type: Plain text
en: On success, B<timerfd_create>()  returns a new file descriptor.  On error, -1 is returned and I<errno> is set to indicate the error.
fr: S'il réussit, B<timerfd_create>() renvoie un nouveau descripteur de fichier. En cas d'erreur, il renvoie -1 et I<errno> contient le code d'erreur.

note: type: Plain text
en: B<timerfd_settime>()  and B<timerfd_gettime>()  return 0 on success; on error they return -1, and set I<errno> to indicate the error.
fr: En cas de réussite, B<timerfd_settime>() et B<timerfd_gettime>() renvoient 0. Sinon ils renvoient -1 et B<errno> contient le code d'erreur.

note: type: Plain text
en: B<timerfd_create>()  can fail with the following errors:
fr: B<timerfd_create>() peut échouer avec les erreurs suivantes :

note: type: Plain text
en: The I<clockid> argument is neither B<CLOCK_MONOTONIC> nor B<CLOCK_REALTIME>;
fr: Le paramètre I<clockid> n'est ni B<CLOCK_MONOTONIC> ni B<CLOCK_REALTIME>;

note: type: Plain text
en: There was insufficient kernel memory to create the timer.
fr: Pas assez de mémoire noyau pour créer la minuterie.

note: type: Plain text
en: B<timerfd_settime>()  and B<timerfd_gettime>()  can fail with the following errors:
fr: B<timerfd_settime>() et B<timerfd_gettime>() peuvent échouer avec les erreurs suivantes :

note: type: Plain text
en: I<fd> is not a valid file descriptor.
fr: I<fd> n'est pas un descripteur de fichier valable.

note: type: Plain text
en: I<fd> is not a valid timerfd file descriptor.
fr: I<fd> n'est pas un descripteur de fichier de minuterie valable.

note: type: Plain text
en: B<timerfd_settime>()  can also fail with the following errors:
fr: B<timerfd_settime>() peut aussi échouer avec les erreurs suivantes :

note: type: Plain text
en: I<new_value> is not properly initialized (one of the I<tv_nsec> falls outside the range zero to 999,999,999).
fr: I<new_value> n'est pas initialisé correctement (un des champs I<tv_nsec> est en dehors de l'intervalle allant de 0 à 999 999 999).

note: This case only checked since 2.6.29, and 2.2.2[78].some-stable-version. In older kernel versions, no check was made for invalid flags. type: Plain text
en: I<flags> is invalid.
fr: I<flags> n'est pas correct.

note: type: Plain text
en: These system calls are available on Linux since kernel 2.6.25.  Library support is provided by glibc since version 2.8.
fr: Ces appels système sont disponibles sous Linux depuis le noyau 2.6.25. La glibc les gère depuis la version 2.8.

note: 2.6.29 type: Plain text
en: Currently, B<timerfd_create>()  supports fewer types of clock IDs than B<timer_create>(2).
fr: Actuellement, B<timerfd_create>() prend en charge moins de type d'identifiants d'horloges que B<timer_create>(2).

note: type: Plain text
en: The following program creates a timer and then monitors its progress.  The program accepts up to three command-line arguments.  The first argument specifies the number of seconds for the initial expiration of the timer.  The second argument specifies the interval for the timer, in seconds.  The third argument specifies the number of times the program should allow the timer to expire before terminating.  The second and third command-line arguments are optional.
fr: Le programme suivant crée une minuterie puis surveille sa progression. Le programme accepte jusqu'à trois paramètres en ligne de commande. Le premier paramètre spécifie le nombre de secondes pour l'expiration initiale de la minuterie. Le deuxième paramètre spécifie la période de la minuterie, en secondes. Le troisième paramètre spécifie le nombre de fois que le programme doit permettre à la minuterie d'expirer avant de quitter. Le deuxième et le troisième paramètre sont optionnels.

note: type: Plain text
en: The following shell session demonstrates the use of the program:
fr: La session interactive suivante montre l'utilisation de ce programme\ :

note: The commented out code here is what we currently need until the required stuff is in glibc /* Link with -lrt */ #define _GNU_SOURCE #include <sys/syscall.h> #include <unistd.h> #include <time.h> #if defined(__i386__) #define __NR_timerfd_create 322 #define __NR_timerfd_settime 325 #define __NR_timer
en: #include E<lt>sys/timerfd.hE<gt>
    #include E<lt>time.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdint.hE<gt>        /* Definition of uint64_t */
fr: #include E<lt>sys/timerfd.hE<gt>
    #include E<lt>time.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdint.hE<gt>        /* Définition de uint64_t */

note: type: Plain text
en: tkill, tgkill - send a signal to a thread
fr: tkill, tgkill - Envoyer un signal à un thread

note: type: Plain text
en: B<tgkill>()  sends the signal I<sig> to the thread with the thread ID I<tid> in the thread group I<tgid>.  (By contrast, B<kill>(2)  can be used to send a signal only to a process (i.e., thread group)  as a whole, and the signal will be delivered to an arbitrary thread within that process.)
fr: B<tgkill>() envoie le signal I<sig> au thread qui a pour identifiant I<tid> dans le groupe I<tgid>. (Contrairement à B<kill>(2) qui ne peut être utilisé que pour envoyer un signal à un processus (c'est-à-dire un groupe de thread) ; le signal étant envoyé à n'importe quel thread du processus)

note: FIXME: Maybe say something about the following: http://sourceware.org/bugzilla/show_bug.cgi?id=12889 Rich Felker <bugdal@aerifal.cx> There is a race condition in pthread_kill: it is possible that, between the time pthread_kill reads the pid/tid from the target thread descriptor and the time it makes
en: B<tkill>()  is an obsolete predecessor to B<tgkill>().  It allows only the target thread ID to be specified, which may result in the wrong thread being signaled if a thread terminates and its thread ID is recycled.  Avoid using this system call.
fr: B<tkill>() est l'ancienne version de B<tgkill>() et est obsolète. Il ne permet que de préciser l'identifiant du thread cible, qui peut résulter en un envoi du signal au mauvais thread si le thread se termine et que son identifiant est réutilisé. Évitez d'utiliser cet appel système.

note: type: Plain text
en: If I<tgid> is specified as -1, B<tgkill>()  is equivalent to B<tkill>().
fr: Si I<tgid> vaut -1, B<tgkill>() est équivalent à B<tkill>().

note: type: Plain text
en: These are the raw system call interfaces, meant for internal thread library use.
fr: Ce sont des appels système bruts, conçus pour une utilisation dans la bibliothèque des threads.

note: type: Plain text
en: An invalid thread ID, thread group ID, or signal was specified.
fr: L'identifiant de thread ou l'identifiant de groupe de thread ou le numéro de signal n'est pas valable.

note: type: Plain text
en: Permission denied.  For the required permissions, see B<kill>(2).
fr: Permission refusée. Pour les permissions nécessaires, consultez B<kill>(2).

note: type: Plain text
en: No process with the specified thread ID (and thread group ID) exists.
fr: Il n'y a pas de processus avec le TID (et TGID) indiqué.

note: type: Plain text
en: B<tkill>()  is supported since Linux 2.4.19 / 2.5.4.  B<tgkill>()  was added in Linux 2.5.75.
fr: B<tkill>() est supporté depuis Linux 2.4.19/2.5.4. B<tgkill>() a été ajouté dans Linux 2.5.75.

note: type: Plain text
en: B<tkill>()  and B<tgkill>()  are Linux-specific and should not be used in programs that are intended to be portable.
fr: B<tkill>() et B<tgkill>() sont spécifiques à Linux et ne doivent pas être utilisés dans un programme conçu pour être portable.

note: type: Plain text
en: See the description of B<CLONE_THREAD> in B<clone>(2)  for an explanation of thread groups.
fr: Consultez la description de B<CLONE_THREAD> dans B<clone>(2) pour une explication sur les groupes de threads.

note: type: Plain text
en: Glibc does not provide wrappers for these system calls; call them using B<syscall>(2).
fr: La glibc ne fournit pas de fonction autour de ces appels systène\ ; utilisez B<syscall>(2) pour les appeler.

note: type: Plain text
en: wait, waitpid, waitid - wait for process to change state
fr: wait, waitpid, waitid - Attendre la fin d'un processus

note: type: Plain text
en: B<int waitid(idtype_t >I<idtype>B<, id_t >I<id>B<, siginfo_t *>I<infop>B<, int >I<options>B<);>
                    /* This is the glibc and POSIX interface; see
                       NOTES for information on the raw system call. */
fr: B<int waitid(idtype_t >I<idtype>B<, id_t >I<id>B<, siginfo_t *>I<infop>B<, int >I<options>B<);>
                    /* Il s'agit de l'interface de glibc et POSIX ; consultez les
                       NOTES pour des informations sur les appels système bruts. */

note: type: Plain text
en: B<waitid>():
fr: B<waitid>() :

note: type: Plain text
en: All of these system calls are used to wait for state changes in a child of the calling process, and obtain information about the child whose state has changed.  A state change is considered to be: the child terminated; the child was stopped by a signal; or the child was resumed by a signal.  In the case of a terminated child, performing a wait allows the system to release the resources associated with the child; if a wait is not performed, then the terminated child remains in a "zombie" state (see NOTES below).
fr: 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).

note: type: Plain text
en: If a child has already changed state, then these calls return immediately.  Otherwise they block until either a child changes state or a signal handler interrupts the call (assuming that system calls are not automatically restarted using the B<SA_RESTART> flag of B<sigaction>(2)).  In the remainder of this page, a child whose state has changed and which has not yet been waited upon by one of these system calls is termed I<waitable>.
fr: 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 B<SA_RESTART> de B<sigaction>(2)). Dans la suite de cette page, un fils qui a changé d'état et qui n'a pas été attendu est appelé I<prêt> (I<waitable>).

note: type: SS
en: wait() and waitpid()
fr: wait() et waitpid()

note: type: Plain text
en: The B<wait>()  system call suspends execution of the calling process until one of its children terminates.  The call I<wait(&status)> is equivalent to:
fr: L'appel système B<wait>() suspend l'exécution du processus appelant jusqu'à ce que l'un de ses enfants se termine. L'appel I<wait(&status)> est équivalent à\ :

note: type: Plain text
en: The B<waitpid>()  system call suspends execution of the calling process until a child specified by I<pid> argument has changed state.  By default, B<waitpid>()  waits only for terminated children, but this behavior is modifiable via the I<options> argument, as described below.
fr: L'appel système B<waitpid>() suspend l'exécution du processus appelant jusqu'à ce qu'un fils spécifié par l'argument I<pid> change d'état. Par défaut, B<waitpid>() n'attend que les fils terminés, mais ce comportement peut être modifié par l'argument I<options>, de la façon décrite ci-dessous.

note: type: Plain text
en: The value of I<pid> can be:
fr: La valeur de I<pid> peut être l'une des suivantes\ :

note: type: Plain text
en: meaning wait for any child process whose process group ID is equal to the absolute value of I<pid>.
fr: Attendre la fin de n'importe quel processus fils appartenant au groupe de processus d'ID I<-pid>.

note: type: Plain text
en: meaning wait for any child process.
fr: Attendre n'importe lequel des processus fils.

note: type: Plain text
en: meaning wait for any child process whose process group ID is equal to that of the calling process.
fr: Attendre la fin de n'importe quel processus fils du même groupe que l'appelant.

note: type: Plain text
en: meaning wait for the child whose process ID is equal to the value of I<pid>.
fr: Attendre la fin du processus numéro I<pid>.

note: type: Plain text
en: The value of I<options> is an OR of zero or more of the following constants:
fr: La valeur de l'argument option I<options> est un I<OU> binaire entre les constantes suivantes\ :

note: type: Plain text
en: return immediately if no child has exited.
fr: Ne pas bloquer si aucun fils ne s'est terminé.

note: type: Plain text
en: also return if a child has stopped (but not traced via B<ptrace>(2)).  Status for I<traced> children which have stopped is provided even if this option is not specified.
fr: Recevoir l'information concernant également les fils bloqués (mais non suivis par B<ptrace>(2)) si on ne l'a pas encore reçue. L'état des fils suivis est fourni même sans cette option.

note: type: TP
en: B<WCONTINUED> (since Linux 2.6.10)
fr: B<WCONTINUED> (Depuis Linux 2.6.10)

note: type: Plain text
en: also return if a stopped child has been resumed by delivery of B<SIGCONT>.
fr: Renvoyer également si un processus fils stoppé a été relancé par le signal B<SIGCONT>.

note: type: Plain text
en: (For Linux-only options, see below.)
fr: (Pour les options spécifiques à Linux, voir plus bas.)

note: type: Plain text
en: If I<status> is not NULL, B<wait>()  and B<waitpid>()  store status information in the I<int> to which it points.  This integer can be inspected with the following macros (which take the integer itself as an argument, not a pointer to it, as is done in B<wait>()  and B<waitpid>()!):
fr: Si I<status> n'est pas NULL, B<wait>() et B<waitpid>() stockent l'état du fils dans la variable de type I<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 B<wait>() et B<waitpid>()\ !)\ :

note: type: Plain text
en: returns true if the child terminated normally, that is, by calling B<exit>(3)  or B<_exit>(2), or by returning from main().
fr: Vrai si le fils s'est terminé normalement, c'est-à-dire par un appel à B<exit>(3) ou B<_exit>(2), ou par un I<return> depuis main().

note: type: Plain text
en: returns the exit status of the child.  This consists of the least significant 8 bits of the I<status> argument that the child specified in a call to B<exit>(3)  or B<_exit>(2)  or as the argument for a return statement in main().  This macro should be employed only if B<WIFEXITED> returned true.
fr: Donne le code de retour, consistant en les 8 bits de poids faibles du paramètre I<status> fourni à B<exit>(3) ou B<_exit>(2) ou dans le I<return> de la routine main(). Cette macro ne peut être évaluée que si B<WIFEXITED> est non nul.

note: type: Plain text
en: returns true if the child process was terminated by a signal.
fr: Vrai si le fils s'est terminé à cause d'un signal non intercepté.

note: type: Plain text
en: returns the number of the signal that caused the child process to terminate.  This macro should be employed only if B<WIFSIGNALED> returned true.
fr: Donne le numéro du signal qui a causé la fin du fils. Cette macro ne peut être évaluée que si B<WIFSIGNALED> est non nul.

note: type: Plain text
en: returns true if the child produced a core dump.  This macro should be employed only if B<WIFSIGNALED> returned true.  This macro is not specified in POSIX.1-2001 and is not available on some UNIX implementations (e.g., AIX, SunOS).  Only use this enclosed in #ifdef WCOREDUMP ... #endif.
fr: Vrai si le processus fils a produit une image mémoire («\ core dump\ »). Cette macro ne doit être évaluée que si B<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.

note: type: Plain text
en: returns true if the child process was stopped by delivery of a signal; this is possible only if the call was done using B<WUNTRACED> or when the child is being traced (see B<ptrace>(2)).
fr: Vrai si le fils est actuellement arrêté. Cela n'est possible que si l'on a effectué l'appel avec l'option B<WUNTRACED> ou si le fils est suivi (voir B<ptrace>(2)).

note: type: Plain text
en: returns the number of the signal which caused the child to stop.  This macro should be employed only if B<WIFSTOPPED> returned true.
fr: Donne le numéro du signal qui a causé l'arrêt du fils. Cette macro ne peut être évaluée que si B<WIFSTOPPED> est non nul.

note: type: Plain text
en: (since Linux 2.6.10)  returns true if the child process was resumed by delivery of B<SIGCONT>.
fr: (Depuis Linux 2.6.10) Vrai si le processus fils a été relancé par B<SIGCONT>.

note: type: Plain text
en: The B<waitid>()  system call (available since Linux 2.6.9) provides more precise control over which child state changes to wait for.
fr: L'appel système B<waitid>(), disponible depuis Linux 2.6.9, fournit des moyens plus fins de contrôler quels changements d'états attendre.

note: type: Plain text
en: The I<idtype> and I<id> arguments select the child(ren) to wait for, as follows:
fr: Les arguments I<idtype> et I<id> sélectionnent le(s) fils à attendre, comme suit\ :

note: type: Plain text
en: Wait for the child whose process ID matches I<id>.
fr: Attendre la fin du processus numéro I<id>.

note: type: Plain text
en: Wait for any child whose process group ID matches I<id>.
fr: Attendre la fin de n'importe quel processus fils appartenant à un groupe de processus d'ID I<id>.

note: type: Plain text
en: Wait for any child; I<id> is ignored.
fr: Attendre n'importe quel fils\ ; l'argument I<id> est ignoré.

note: type: Plain text
en: The child state changes to wait for are specified by ORing one or more of the following flags in I<options>:
fr: Les changements d'état à attendre sont indiqués par un OU binaire des attributs suivants dans le paramètre I<options>\ :

note: type: Plain text
en: Wait for children that have terminated.
fr: Attendre les fils qui se sont terminés.

note: type: Plain text
en: Wait for children that have been stopped by delivery of a signal.
fr: Attendre les enfants qui ont été arrêtés par un signal.

note: type: Plain text
en: Wait for (previously stopped) children that have been resumed by delivery of B<SIGCONT>.
fr: Attendre les enfants précédemment arrêtés qui ont été relancés par le signal B<SIGCONT>.

note: type: Plain text
en: The following flags may additionally be ORed in I<options>:
fr: Les attributs suivants peuvent également être utilisés dans I<options>\ :

note: type: Plain text
en: As for B<waitpid>().
fr: Comme pour B<waitpid>().

note: type: Plain text
en: Leave the child in a waitable state; a later wait call can be used to again retrieve the child status information.
fr: Laisser le fils dans un état prêt\ ; un appel ultérieur à wait() pourra de nouveau fournir des informations sur l'état du fils.

note: type: Plain text
en: Upon successful return, B<waitid>()  fills in the following fields of the I<siginfo_t> structure pointed to by I<infop>:
fr: Si l'appel réussit, B<waitid>() remplit les champs suivants de la structure I<siginfo_t> pointée par I<infop>\ :

note: type: Plain text
en: The process ID of the child.
fr: L'identifiant de processus du fils.

note: type: Plain text
en: The real user ID of the child.  (This field is not set on most other implementations.)
fr: L'UID réel du fils. Ce champ n'est pas rempli par la plupart des autres implémentations.

note: type: Plain text
en: Always set to B<SIGCHLD>.
fr: Toujours B<SIGCHLD>.

note: type: Plain text
en: Either the exit status of the child, as given to B<_exit>(2)  (or B<exit>(3)), or the signal that caused the child to terminate, stop, or continue.  The I<si_code> field can be used to determine how to interpret this field.
fr: Soit le code de retour du fils donné à B<_exit>(2) ou B<exit>(3), soit le signal ayant provoqué la terminaison, l'arrêt, ou la relance du fils. Le champ I<si_code> permet de savoir comment interpréter ce champ.

note: type: Plain text
en: Set to one of: B<CLD_EXITED> (child called B<_exit>(2)); B<CLD_KILLED> (child killed by signal); B<CLD_DUMPED> (child killed by signal, and dumped core); B<CLD_STOPPED> (child stopped by signal); B<CLD_TRAPPED> (traced child has trapped); or B<CLD_CONTINUED> (child continued by B<SIGCONT>).
fr: L'un de B<CLD_EXITED> (le fils a appelé B<_exit>(2)), B<CLD_KILLED> (le fils a été tué par un signal), B<CLD_DUMPED> (le fils a été tué par un signal, et a produit une image (core dump)), B<CLD_STOPPED> (le fils a été arrêté par un signal), B<CLD_TRAPPED> (le fils suivi a été rattrapé) ou B<CLD_CONTINUED> (le fils a été relancé par B<SIGCONT>).

note: POSIX.1-2001 leaves this possibility unspecified; most implementations (including Linux) zero out the structure in this case, but at least one implementation (AIX 5.1) does not -- MTK Nov 04 type: Plain text
en: If B<WNOHANG> was specified in I<options> and there were no children in a waitable state, then B<waitid>()  returns 0 immediately and the state of the I<siginfo_t> structure pointed to by I<infop> is unspecified.  To distinguish this case from that where a child was in a waitable state, zero out the I<si_pid> field before the call and check for a nonzero value in this field after the call returns.
fr: Si B<WNOHANG> est utilisé dans I<options> et aucun fils n'est prêt, B<waitid>() renvoie 0 immédiatement et l'état de la structure I<siginfo_t> pointée par I<infop> n'est pas précisé. Pour différencier ce cas de celui où un des fils était prêt, définissez le champ I<si_pid> avant l'appel, et vérifiez sa valeur après le retour.

note: type: Plain text
en: B<wait>(): on success, returns the process ID of the terminated child; on error, -1 is returned.
fr: B<wait>()\ : en cas de réussite, l'identifiant du processus fils terminé est renvoyé\ ; en cas d'erreur, la valeur de retour est -1.

note: type: Plain text
en: B<waitpid>(): on success, returns the process ID of the child whose state has changed; if B<WNOHANG> was specified and one or more child(ren) specified by I<pid> exist, but have not yet changed state, then 0 is returned.  On error, -1 is returned.
fr: B<waitpid>()\ : s'il réussit, l'appel renvoie l'identifiant du processus fils dont l'état a changé\ ; si B<WNOHANG> est utilisé et un fils (ou plus) spécifié par I<pid> existe, mais n'a toujours pas changé d'état, la valeur de retour est 0. En cas d'erreur, -1 est renvoyé.

note: FIXME: As reported by Vegard Nossum, if infop is NULL, then waitid() returns the PID of the child.  Either this is a bug, or it is intended behavior that needs to be documented.  See my Jan 2009 LKML mail "waitid() return value strangeness when infop is NULL". type: Plain text
en: B<waitid>(): returns 0 on success or if B<WNOHANG> was specified and no child(ren) specified by I<id> has yet changed state; on error, -1 is returned.  Each of these calls sets I<errno> to an appropriate value in the case of an error.
fr: B<waitid>() : renvoie 0 s'il réussit ou si B<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 I<errno> à la valeur appropriée en cas d'erreur.

note: type: Plain text
en: (for B<wait>())  The calling process does not have any unwaited-for children.
fr: (pour B<wait>()) Le processus appelant n'a pas de fils qui n'ont pas été attendus.

note: type: Plain text
en: (for B<waitpid>()  or B<waitid>())  The process specified by I<pid> (B<waitpid>())  or I<idtype> and I<id> (B<waitid>())  does not exist or is not a child of the calling process.  (This can happen for one's own child if the action for B<SIGCHLD> is set to B<SIG_IGN>.  See also the I<Linux Notes> section about threads.)
fr: (pour B<waitpid>() ou B<waitid>()) Le processus indiqué par I<pid> (B<waitpid>()) ou I<idtype> et I<id> (B<waitid>()) n'existe pas, ou n'est pas un fils du processus appelant. (Ceci peut arriver pour son propre fils si l'action de B<SIGCHLD> est placé sur B<SIG_IGN>, voir également le passage de la section I<Notes sur Linux> concernant les threads.)

note: type: Plain text
en: B<WNOHANG> was not set and an unblocked signal or a B<SIGCHLD> was caught; see B<signal>(7).
fr: B<WNOHANG> n'est pas indiqué, et un signal à intercepter ou B<SIGCHLD> a été reçu ; consultez B<signal>(7).

note: type: Plain text
en: The I<options> argument was invalid.
fr: L'argument I<options> est invalide.

note: type: Plain text
en: A child that terminates, but has not been waited for becomes a "zombie".  The kernel maintains a minimal set of information about the zombie process (PID, termination status, resource usage information)  in order to allow the parent to later perform a wait to obtain information about the child.  As long as a zombie is not removed from the system via a wait, it will consume a slot in the kernel process table, and if this table fills, it will not be possible to create further processes.  If a parent process terminates, then its "zombie" children (if any)  are adopted by B<init>(8), which automatically performs a wait to remove the zombies.
fr: 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 B<init>(8), qui les attend automatiquement pour les supprimer.

note: type: Plain text
en: POSIX.1-2001 specifies that if the disposition of B<SIGCHLD> is set to B<SIG_IGN> or the B<SA_NOCLDWAIT> flag is set for B<SIGCHLD> (see B<sigaction>(2)), then children that terminate do not become zombies and a call to B<wait>()  or B<waitpid>()  will block until all children have terminated, and then fail with I<errno> set to B<ECHILD>.  (The original POSIX standard left the behavior of setting B<SIGCHLD> to B<SIG_IGN> unspecified.  Note that even though the default disposition of B<SIGCHLD> is "ignore", explicitly setting the disposition to B<SIG_IGN> results in different treatment of zombie process children.)  Linux 2.6 conforms to this specification.  However, Linux 2.4 (and earlier) does not: if a B<wait>()  or B<waitpid>()  call is made while B<SIGCHLD> is being ignored, the call behaves just as though B<SIGCHLD> were not being ignored, that is, the call blocks until the next child terminates and then returns the process ID and status of that child.
fr: POSIX.1-2001 indique que si l'action pour B<SIGCHLD> est définie à B<SIG_IGN> ou si l'attribut B<SA_NOCLDWAIT> est indiqué pour B<SIGCHLD> (voir B<sigaction>(2)), les enfants qui se terminent ne deviennent pas des zombies et un appel à B<wait>() ou B<waitpid>() sera bloquant jusqu'à ce que tous les fils soient terminés, et échouera ensuite en positionnant I<errno> à B<ECHILD>. (La norme POSIX originale ne décrivait pas le comportement si l'action pour B<SIGCHLD> était B<SIG_IGN>. Veuillez noter que même si la disposition par défaut de B<SIGCHLD> est « ignore », la configuration explicite de la disposition de B<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 à B<wait>() ou B<waitpid>() est fait alors que B<SIGCHLD> est ignoré, l'appel se comporte comme si B<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.

note: type: Plain text
en: In the Linux kernel, a kernel-scheduled thread is not a distinct construct from a process.  Instead, a thread is simply a process that is created using the Linux-unique B<clone>(2)  system call; other routines such as the portable B<pthread_create>(3)  call are implemented using B<clone>(2).  Before Linux 2.4, a thread was just a special case of a process, and as a consequence one thread could not wait on the children of another thread, even when the latter belongs to the same thread group.  However, POSIX prescribes such functionality, and since Linux 2.4 a thread can, and by default will, wait on children of other threads in the same thread group.
fr: 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 \(em spécifique à Linux \(em B<clone>(2). Les routines portables, comme B<pthread_create>(3), sont implémentées en appelant B<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.

note: type: Plain text
en: The following Linux-specific I<options> are for use with children created using B<clone>(2); they cannot be used with B<waitid>():
fr: Les I<options> suivantes sont spécifiques à Linux, et servent pour les enfants créés avec B<clone>(2)\ ; elles ne peuvent pas être utilisées avec B<waitid>()\ :

note: since 0.99pl10 type: Plain text
en: Wait for "clone" children only.  If omitted, then wait for "non-clone" children only.  (A "clone" child is one which delivers no signal, or a signal other than B<SIGCHLD> to its parent upon termination.)  This option is ignored if B<__WALL> is also specified.
fr: 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 B<SIGCHLD> à son père à sa terminaison). Cette option est ignorée si B<__WALL> est aussi indiqué.

note: type: TP
en: B<__WALL> (since Linux 2.4)
fr: B<__WALL> (depuis Linux 2.4)

note: since patch-2.3.48 type: Plain text
en: Wait for all children, regardless of type ("clone" or "non-clone").
fr: Attendre tous les enfants, quel que soit leur type (clone ou non-clone).

note: type: TP
en: B<__WNOTHREAD> (since Linux 2.4)
fr: B<__WNOTHREAD> (Depuis Linux 2.4)

note: since patch-2.4.0-test8 type: Plain text
en: Do not wait for children of other threads in the same thread group.  This was the default before Linux 2.4.
fr: 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.

note: type: Plain text
en: The raw B<waitid>()  system call takes a fith argument, of type I<struct rusage\ *>.  If this argument is non-NULL, then it is used to return resource usage information about the child, in the same manner as B<wait4>(2).  See B<getrusage>(2)  for details.
fr: L'appel système brut B<waitid>() prend un cinquième paramètre, de type I<struct rusage\ *>. Si ce paramètre n'est pas NULL, il est utilisé pour renvoyer les informations d'utilisation des ressources au sujet du thread fils, de la même façon que B<wait4>(2). Consultez B<getrusage>(2) pour plus de détails.

note: type: Plain text
en: According to POSIX.1-2008, an application calling B<waitid>()  must ensure that I<infop> points to a I<siginfo_t> structure (i.e., that it is a non-null pointer).  On Linux, if I<infop> is NULL, B<waitid>()  succeeds, and returns the process ID of the waited-for child.  Applications should avoid relying on this inconsistent, nonstandard, and unnecessary feature.
fr: Selon la norme POSIX.1-2008, une application appelant  B<waitid>() doit garantir que I<infop> pointe sur une structure I<siginfo_t> (c'est-à-dire qu'elle ne pointe pas sur NULL). Sur Linux, si I<infop> est NULL, B<waitid>() réussit, et renvoie l'identificateur du processus fils attendu. Dans la mesure du possible, les applications doivent éviter d'avoir recours à cette fonctionnalité incohérente, non standard et superflue.

note: fork.2 refers to this example program. type: Plain text
en: The following program demonstrates the use of B<fork>(2)  and B<waitpid>().  The program creates a child process.  If no command-line argument is supplied to the program, then the child suspends its execution using B<pause>(2), to allow the user to send signals to the child.  Otherwise, if a command-line argument is supplied, then the child exits immediately, using the integer supplied on the command line as the exit status.  The parent process executes a loop that monitors the child using B<waitpid>(), and uses the W*() macros described above to analyze the wait status value.
fr: Le programme suivant montre l'utilisation de B<fork>(2) et de B<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 B<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 B<waitpid>(), et utilise les macros W*() décrites ci-dessus pour analyser le code d'état du fils.

note: type: Plain text
en: $B< ./a.out &>
    Child PID is 32360
    [1] 32359
    $B< kill -STOP 32360>
    stopped by signal 19
    $B< kill -CONT 32360>
    continued
    $B< kill -TERM 32360>
    killed by signal 15
    [1]+  Done                    ./a.out
    $
fr: $B< ./a.out &>
    Le PID du fils est 32360
    [1] 32359
    $B< kill -STOP 32360>
    arrêté par le signal 19
    $B< kill -CONT 32360>
    relancé
    $B< kill -TERM 32360>
    tué par le signal 15
    [1]+  Done                    ./a.out
    $

note: type: Plain text
en:     if (cpid == 0) {            /* Code executed by child */
            printf("Child PID is %ld\en", (long) getpid());
            if (argc == 1)
                pause();                    /* Wait for signals */
            _exit(atoi(argv[1]));
fr:     if (cpid == 0) {            /* Code exécuté par le fils */
            printf("Le PID du fils est %ld\(rsn", (long) getpid());
            if (argc == 1)
                pause();                    /* Attendre un signal */
            _exit(atoi(argv[1]));

note: type: Plain text
en:     } else {                    /* Code executed by parent */
            do {
                w = waitpid(cpid, &status, WUNTRACED | WCONTINUED);
                if (w == -1) {
                    perror("waitpid");
                    exit(EXIT_FAILURE);
                }
fr:     } else {                    /* Code exécuté par le père */
            do {
                w = waitpid(cpid, &status, WUNTRACED | WCONTINUED);
                if (w == -1) {
                    perror("waitpid");
                    exit(EXIT_FAILURE);
                }

note: type: Plain text
en:             if (WIFEXITED(status)) {
                    printf("exited, status=%d\en", WEXITSTATUS(status));
                } else if (WIFSIGNALED(status)) {
                    printf("killed by signal %d\en", WTERMSIG(status));
                } else if (WIFSTOPPED(status)) {
                    printf("stopped by signal %d\en", WSTOPSIG(status));
                } else if (WIFCONTINUED(status)) {
                    printf("continued\en");
                }
            } while (!WIFEXITED(status) && !WIFSIGNALED(status));
            exit(EXIT_SUCCESS);
        }
    }
fr:             if (WIFEXITED(status)) {
                    printf("terminé, code=%d\(rsn", WEXITSTATUS(status));
                } else if (WIFSIGNALED(status)) {
                    printf("tué par le signal %d\(rsn", WTERMSIG(status));
                } else if (WIFSTOPPED(status)) {
                    printf("arrêté par le signal %d\(rsn", WSTOPSIG(status));
                } else if (WIFCONTINUED(status)) {
                    printf("relancé\(rsn");
                }
            } while (!WIFEXITED(status) && !WIFSIGNALED(status));
            exit(EXIT_SUCCESS);
        }
    }

note: type: TH
en: 2012-09-23
fr: 23 septembre 2012

note: type: Plain text
en: wait3, wait4 - wait for process to change state, BSD style
fr: wait3, wait4 - Attendre la fin d'un processus - Style BSD

note: type: Plain text
en: B<wait3>():
fr: B<wait3>() :

note: type: Plain text
en: B<wait4>():
fr: B<wait4>() :

note: type: Plain text
en: These functions are obsolete; use B<waitpid>(2)  or B<waitid>(2)  in new programs.
fr: Ces fonctions sont obsolètes, B<waitpid>(2) ou B<waitid>(2) doivent être utilisés dans les nouveaux programmes.

note: type: Plain text
en: The B<wait3>()  and B<wait4>()  system calls are similar to B<waitpid>(2), but additionally return resource usage information about the child in the structure pointed to by I<rusage>.
fr: Les appels système B<wait3>() et B<wait4>() sont similaires à B<waitpid>(2), mais retournent également des informations sur l'utilisation des ressources par le fils dans la structure pointée par I<rusage>.

note: type: Plain text
en: Other than the use of the I<rusage> argument, the following B<wait3>()  call:
fr: À part l'utilisation de l'argument I<rusage>, l'appel B<wait3>() suivant\ :

note: type: Plain text
en: is equivalent to:
fr: est équivalent à\ :

note: type: Plain text
en: Similarly, the following B<wait4>()  call:
fr: De même, l'appel B<wait4>() suivant\ :

note: type: Plain text
en: In other words, B<wait3>()  waits of any child, while B<wait4>()  can be used to select a specific child, or children, on which to wait.  See B<wait>(2)  for further details.
fr: En d'autres mots, B<wait3>() attend n'importe quel fils, et B<wait4>() peut être utilisé pour sélectionner un ou des fils spécifique(s) à attendre. Consultez B<wait>(2) pour plus de détails.

note: type: Plain text
en: If I<rusage> is not NULL, the I<struct rusage> to which it points will be filled with accounting information about the child.  See B<getrusage>(2)  for details.
fr: Si I<rusage> n'est pas NULL, La I<struct rusage> sur laquelle il pointe sera remplie avec les informations de comptabilité. Consultez B<getrusage>(2) pour plus de détails.

note: type: Plain text
en: As for B<waitpid>(2).
fr: Comme pour B<waitpid>(2).

note: type: Plain text
en: 4.3BSD.
fr: BSD\ 4.3.

note: type: Plain text
en: SUSv1 included a specification of B<wait3>(); SUSv2 included B<wait3>(), but marked it LEGACY; SUSv3 removed it.
fr: SUSv1 spécifiait B<wait3>() ; SUSv2 spécifiait B<wait3>() en la marquant obsolète ; SUSv3 a supprimé cette fonction.

note: type: Plain text
en: Including I<E<lt>sys/time.hE<gt>> is not required these days, but increases portability.  (Indeed, I<E<lt>sys/resource.hE<gt>> defines the I<rusage> structure with fields of type I<struct timeval> defined in I<E<lt>sys/time.hE<gt>>.)
fr: L'inclusion de I<E<lt>sys/time.hE<gt>> n'est plus obligatoire, mais améliore la portabilité. (En fait, I<E<lt>sys/resource.hE<gt>> définit la structure I<rusage> qui contient des champs de type I<struct timeval>, défini dans I<E<lt>sys/time.hE<gt>>).

note: type: Plain text
en: On Linux, B<wait3>()  is a library function implemented on top of the B<wait4>()  system call.
fr: Sous Linux, B<wait3>() est une fonction de bibliothèque implémentée au à l'aide de l'appel système B<wait4>().
