perkamon - en to fr translation catalogue (64 entries)

note: type: TH
en: 2019-08-02
fr: 2 août 2019

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: semop, semtimedop - System V semaphore operations
fr: semop, semtimedop - Opérations sur les sémaphores System V

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<semtimedop>(): _GNU_SOURCE
fr: B<semtimedop>() : _GNU_SOURCE

note: type: Plain text
en: Each semaphore in a System\ V semaphore set has the following associated values:
fr: Chaque sémaphore dans un ensemble de sémaphores System V se voit associer les valeurs suivantes\ :

note: type: Plain text
en: unsigned short  semval;   /* semaphore value */
    unsigned short  semzcnt;  /* # waiting for zero */
    unsigned short  semncnt;  /* # waiting for increase */
    pid_t           sempid;   /* PID of process that last
fr: unsigned short  semval;   /* Valeur du sémaphore   */
    unsigned short  semzcnt;  /* # Attente pour zéro   */
    unsigned short  semncnt;  /* # Attente d'incrément */
    pid_t           sempid;   /* PID du dernier processus agissant */

note: type: Plain text
en: B<semop>()  performs operations on selected semaphores in the set indicated by I<semid>.  Each of the I<nsops> elements in the array pointed to by I<sops> is a structure that specifies an operation to be performed on a single semaphore.  The elements of this structure are of type I<struct sembuf>, containing the following members:
fr: La fonction B<semop>() effectue des opérations sur les membres de l'ensemble de sémaphores identifié par I<semid>. Chacun des I<nsops> éléments dans le tableau pointé par I<sops> indique une opération à effectuer sur un sémaphore en utilisant une structure I<struct sembuf> contenant les membres suivants\ :

note: type: Plain text
en: unsigned short sem_num;  /* semaphore number */
    short          sem_op;   /* semaphore operation */
    short          sem_flg;  /* operation flags */
fr: unsigned short sem_num;  /* Numéro du sémaphore        */
    short          sem_op;   /* Opération sur le sémaphore */
    short          sem_flg;  /* Options pour l'opération   */

note: type: Plain text
en: Flags recognized in I<sem_flg> are B<IPC_NOWAIT> and B<SEM_UNDO>.  If an operation specifies B<SEM_UNDO>, it will be automatically undone when the process terminates.
fr: Les options possibles pour I<sem_flg> sont B<IPC_NOWAIT> et B<SEM_UNDO>. Si une opération indique l'option B<SEM_UNDO>, elle sera annulée lorsque le processus se terminera.

note: type: Plain text
en: The set of operations contained in I<sops> is performed in I<array order>, and I<atomically>, that is, the operations are performed either as a complete unit, or not at all.  The behavior of the system call if not all operations can be performed immediately depends on the presence of the B<IPC_NOWAIT> flag in the individual I<sem_flg> fields, as noted below.
fr: L'ensemble des opérations contenues dans I<sops> est effectué I<dans l'ordre> et I<atomiquement>. Les opérations sont toutes réalisées en même temps, et seulement si elles peuvent toutes être effectuées. Le comportement de l'appel système, si toutes les opérations ne sont pas réalisables, dépend de la présence de l'attribut B<IPC_NOWAIT> dans les champs I<sem_flg> décrits plus bas.

note: type: Plain text
en: Each operation is performed on the I<sem_num>-th semaphore of the semaphore set, where the first semaphore of the set is numbered 0.  There are three types of operation, distinguished by the value of I<sem_op>.
fr: Chaque opération est effectuée sur le I<sem_num>-ième sémaphore de l'ensemble. Le premier sémaphore est le numéro 0. Pour chaque sémaphore, l'opération est l'une des trois décrites ci-dessous.

note: type: Plain text
en: If I<sem_op> is a positive integer, the operation adds this value to the semaphore value (I<semval>).  Furthermore, if B<SEM_UNDO> is specified for this operation, the system subtracts the value I<sem_op> from the semaphore adjustment (I<semadj>)  value for this semaphore.  This operation can always proceed\(emit never forces a thread to wait.  The calling process must have alter permission on the semaphore set.
fr: Si l'argument I<sem_op> est un entier positif, la fonction ajoute cette valeur à I<semval>. De plus si B<SEM_UNDO> est demandé, le système soustrait la valeur I<sem_op> à la valeur de mise à jour de sémaphore (I<semadj>). Cette opération n'est jamais bloquante. Le processus appelant doit avoir l'autorisation de modification sur le jeu de sémaphores.

note: type: Plain text
en: If I<sem_op> is zero, the process must have read permission on the semaphore set.  This is a "wait-for-zero" operation: if I<semval> is zero, the operation can immediately proceed.  Otherwise, if B<IPC_NOWAIT> is specified in I<sem_flg>, B<semop>()  fails with I<errno> set to B<EAGAIN> (and none of the operations in I<sops> is performed).  Otherwise, I<semzcnt> (the count of threads waiting until this semaphore's value becomes zero)  is incremented by one and the thread sleeps until one of the following occurs:
fr: Si I<sem_op> vaut zéro le processus doit avoir l'autorisation de lecture sur l'ensemble de sémaphores. Le processus attend que I<semval> soit nul\ : si I<semval> vaut zéro, l'appel système continue immédiatement. Sinon, si l'on a réclamé B<IPC_NOWAIT> dans I<sem_flg>, l'appel système B<semop>() échoue et I<errno> contient le code d'erreur B<EAGAIN> (et aucune des opérations de I<sops> n'est réalisée). Sinon, I<semzcnt> (le décompte de threads en attente jusqu'à ce que cette valeur de sémaphore devienne zéro) est incrémenté d'un et le thread s'endort jusqu'à ce que l'un des événements suivants se produise\ :

note: type: Plain text
en: I<semval> becomes 0, at which time the value of I<semzcnt> is decremented.
fr: I<semval> devient égal à 0, alors I<semzcnt> est décrémenté.

note: type: Plain text
en: The semaphore set is removed: B<semop>()  fails, with I<errno> set to B<EIDRM>.
fr: Le jeu de sémaphores est supprimé. L'appel système échoue et I<errno> contient le code d'erreur B<EIDRM>.

note: type: Plain text
en: The calling thread catches a signal: the value of I<semzcnt> is decremented and B<semop>()  fails, with I<errno> set to B<EINTR>.
fr: Le thread reçoit un signal à intercepter, la valeur de I<semzcnt> est décrémentée et l'appel système échoue avec I<errno> contenant le code d'erreur B<EINTR>.

note: type: Plain text
en: If I<sem_op> is less than zero, the process must have alter permission on the semaphore set.  If I<semval> is greater than or equal to the absolute value of I<sem_op>, the operation can proceed immediately: the absolute value of I<sem_op> is subtracted from I<semval>, and, if B<SEM_UNDO> is specified for this operation, the system adds the absolute value of I<sem_op> to the semaphore adjustment (I<semadj>)  value for this semaphore.  If the absolute value of I<sem_op> is greater than I<semval>, and B<IPC_NOWAIT> is specified in I<sem_flg>, B<semop>()  fails, with I<errno> set to B<EAGAIN> (and none of the operations in I<sops> is performed).  Otherwise, I<semncnt> (the counter of threads waiting for this semaphore's value to increase)  is incremented by one and the thread sleeps until one of the following occurs:
fr: Si I<sem_op> est inférieur à zéro, le processus appelant doit avoir l'autorisation de modification sur le jeu de sémaphores. Si I<semval> est supérieur ou égal à la valeur absolue de I<sem_op>, la valeur absolue de I<sem_op> est soustraite de I<semval>, et si B<SEM_UNDO> est indiqué, le système ajoute la valeur absolue de I<sem_op> à la valeur de mise à jour de sémaphore (I<semadj>) pour ce sémaphore. Si la valeur absolue de I<sem_op> est plus grande que I<semval>, et si l'on a réclamé B<IPC_NOWAIT> dans I<sem_flg>, l'appel système échoue et I<errno> contient le code d'erreur B<EAGAIN> (et aucune des opérations de I<sops> n'est réalisée). Sinon, I<semncnt> (le décompte de threads en attente jusqu'à ce que cette valeur de sémaphore soit incrémenté) est incrémenté de un et le thread s'endort jusqu'à ce que l'un des événements suivants se produise\ :

note: type: Plain text
en: I<semval> becomes greater than or equal to the absolute value of I<sem_op>: the operation now proceeds, as described above.
fr: I<semval> devient supérieur ou égal à la valeur absolue de I<sem_op> : l'opération est effectuée comme décrit ci-dessus.

note: type: Plain text
en: The semaphore set is removed from the system: B<semop>()  fails, with I<errno> set to B<EIDRM>.
fr: Le jeu de sémaphores est supprimé. L'appel système échoue et I<errno> contient le code d'erreur B<EIDRM>.

note: type: Plain text
en: The calling thread catches a signal: the value of I<semncnt> is decremented and B<semop>()  fails, with I<errno> set to B<EINTR>.
fr: Le thread reçoit un signal à intercepter, la valeur de I<semncnt> est décrémentée et l'appel système échoue avec I<errno> contenant le code d'erreur B<EINTR>.

note: and .I sem_ctime type: Plain text
en: On successful completion, the I<sempid> value for each semaphore specified in the array pointed to by I<sops> is set to the caller's process ID.  In addition, the I<sem_otime> is set to the current time.
fr: En cas de succès, le membre I<sempid> de chacun des sémaphores indiqués dans le tableau pointé par I<sops> est rempli avec le PID de l'appelant. Enfin I<sem_otime> est défini à l'heure actuelle.

note: type: Plain text
en: B<semtimedop>()  behaves identically to B<semop>()  except that in those cases where the calling thread would sleep, the duration of that sleep is limited by the amount of elapsed time specified by the I<timespec> structure whose address is passed in the I<timeout> argument.  (This sleep interval will be rounded up to the system clock granularity, and kernel scheduling delays mean that the interval may overrun by a small amount.)  If the specified time limit has been reached, B<semtimedop>()  fails with I<errno> set to B<EAGAIN> (and none of the operations in I<sops> is performed).  If the I<timeout> argument is NULL, then B<semtimedop>()  behaves exactly like B<semop>().
fr: La fonction B<semtimedop>() se comporte comme B<semop>() sauf que dans le cas où le thread doit dormir, la durée maximale du sommeil est limitée par la valeur spécifiée dans la structure I<timespec> dont l'adresse est transmise dans le paramètre I<timeout> (cet intervalle de sommeil sera arrondi à la granularité de l'horloge système, et les délais d'ordonnancement du noyau font que cette valeur peut être légèrement dépassée). Si la limite indiquée a été atteinte, l'appel système échoue avec I<errno> contenant B<EAGAIN> (et aucune opération de I<sops> n'est réalisée). Si le paramètre I<timeout> est NULL, alors B<semtimedop>() se comporte exactement comme B<semop>().

note: type: Plain text
en: Note that if B<semtimedop>()  is interrupted by a signal, causing the call to fail with the error B<EINTR>, the contents of I<timeout> are left unchanged.
fr: Si B<semtimedop>() est interrompu par un signal, causant l'échec de l'appel avec l'erreur B<EINTR>, les valeurs contenues dans I<timeout> restent inchangées.

note: type: SH
en: RETURN VALUE
fr: VALEUR DE RETOUR

note: type: Plain text
en: If successful, B<semop>()  and B<semtimedop>()  return 0; otherwise they return -1 with I<errno> indicating the error.
fr: En cas de réussite, B<semop>() et B<semtimedop>() renvoient 0. Sinon ils renvoient -1 et I<errno> contient le code d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: On failure, I<errno> is set to one of the following:
fr: En cas d'erreur, I<errno> prend l'une des valeurs suivantes\ :

note: type: Plain text
en: The argument I<nsops> is greater than B<SEMOPM>, the maximum number of operations allowed per system call.
fr: l'argument I<nsops> est supérieur à B<SEMOPM>, le nombre maximal d'opérations par appel système.

note: type: Plain text
en: The calling process does not have the permissions required to perform the specified semaphore operations, and does not have the B<CAP_IPC_OWNER> capability in the user namespace that governs its IPC namespace.
fr: Le processus appelant n'a pas les permissions nécessaires pour effectuer les opérations sur les sémaphores spécifiés et n'a pas la capacité B<CAP_IPC_OWNER> dans l'espace de noms utilisateur qui régit son espace de noms IPC.

note: type: Plain text
en: An operation could not proceed immediately and either B<IPC_NOWAIT> was specified in I<sem_flg> or the time limit specified in I<timeout> expired.
fr: Une opération ne pouvait pas être effectuée immédiatement et B<IPC_NOWAIT> a été indiqué dans l'argument I<sem_flg>, ou la durée limite indiquée dans I<timeout> a expiré.

note: type: Plain text
en: An address specified in either the I<sops> or the I<timeout> argument isn't accessible.
fr: I<sops> ou I<timeout> pointent en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: For some operation the value of I<sem_num> is less than 0 or greater than or equal to the number of semaphores in the set.
fr: La valeur de I<sem_num> est inférieure à 0 ou supérieure ou égale au nombre de sémaphores dans l'ensemble.

note: type: Plain text
en: The semaphore set was removed.
fr: Le jeu de sémaphores a été supprimé.

note: type: Plain text
en: While blocked in this system call, the thread caught a signal; see B<signal>(7).
fr: Un signal a été reçu pendant l'attente ; consultez B<signal>(7).

note: type: Plain text
en: The semaphore set doesn't exist, or I<semid> is less than zero, or I<nsops> has a nonpositive value.
fr: L'ensemble de sémaphores n'existe pas ou I<semid> est inférieur à zéro, ou I<nsops> n'est pas strictement positive.

note: type: Plain text
en: The I<sem_flg> of some operation specified B<SEM_UNDO> and the system does not have enough memory to allocate the undo structure.
fr: L'argument I<sem_flg> de certaines opérations demande B<SEM_UNDO> et le système n'a pas assez de mémoire pour allouer les structures nécessaires.

note: type: Plain text
en: For some operation I<sem_op+semval> is greater than B<SEMVMX>, the implementation dependent maximum value for I<semval>.
fr: I<sem_op+semval> est supérieur à B<SEMVMX> (la valeur maximale de I<semval> autorisée par l'implémentation) pour l'une des opérations.

note: type: Plain text
en: B<semtimedop>()  first appeared in Linux 2.5.52, and was subsequently backported into kernel 2.4.22.  Glibc support for B<semtimedop>()  first appeared in version 2.3.3.
fr: B<semtimedop>() est apparu pour la première fois dans Linux 2.5.52, puis a été rétroporté au noyau 2.4.22. La gestion de B<semtimedop>() dans la glibc date de la version 2.3.3.

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

note: Like Linux, the FreeBSD man pages still document the inclusion of these header files. type: Plain text
en: The inclusion of I<E<lt>sys/types.hE<gt>> and I<E<lt>sys/ipc.hE<gt>> isn't required on Linux or by any version of POSIX.  However, some old implementations required the inclusion of these header files, and the SVID also documented their inclusion.  Applications intended to be portable to such old systems may need to include these header files.
fr: L'inclusion de I<E<lt>sys/types.hE<gt>> et I<E<lt>sys/ipc.hE<gt>> n'est pas nécessaire sous Linux et n'est exigée par aucune version de POSIX. Cependant, certaines implémentations anciennes nécessitent l'inclusion de ces fichiers d'en-tête, et le SVID documente aussi leur inclusion. Les applications ayant pour but d'être portables pourraient inclure ces fichiers d'en-tête.

note: type: Plain text
en: The I<sem_undo> structures of a process aren't inherited by the child produced by B<fork>(2), but they are inherited across an B<execve>(2)  system call.
fr: Les structures I<sem_undo> d'un processus ne sont pas héritées par ses enfants lors d'un B<fork>(2), mais elles le sont lors d'un appel système B<execve>(2).

note: type: Plain text
en: B<semop>()  is never automatically restarted after being interrupted by a signal handler, regardless of the setting of the B<SA_RESTART> flag when establishing a signal handler.
fr: B<semop>() n'est jamais relancé automatiquement après avoir été interrompu par un gestionnaire de signal quelque soit l'attribut B<SA_RESTART> durant l'installation du gestionnaire.

note: type: Plain text
en: A semaphore adjustment (I<semadj>)  value is a per-process, per-semaphore integer that is the negated sum of all operations performed on a semaphore specifying the B<SEM_UNDO> flag.  Each process has a list of I<semadj> values\(emone value for each semaphore on which it has operated using B<SEM_UNDO>.  When a process terminates, each of its per-semaphore I<semadj> values is added to the corresponding semaphore, thus undoing the effect of that process's operations on the semaphore (but see BUGS below).  When a semaphore's value is directly set using the B<SETVAL> or B<SETALL> request to B<semctl>(2), the corresponding I<semadj> values in all processes are cleared.  The B<clone>(2)  B<CLONE_SYSVSEM> flag allows more than one process to share a I<semadj> list; see B<clone>(2)  for details.
fr: Une valeur de mise à jour de sémaphore (I<semadj>) est un entier propre à un processus et sémaphore, qui représente le compte négatif des opérations utilisant l'attribut B<SEM_UNDO>. Chaque processus dispose d'une liste de valeurs I<semadj> \(em une valeur pour chaque sémaphore où B<SEM_UNDO> a été utilisé. Quand un processus se termine, chacune des valeurs I<semadj>  de ses sémaphores est ajoutée au sémaphore correspondant, annulant ainsi l'effet des opérations du processus sur le sémaphore (voir la section BOGUES ci-dessous). Quand la valeur d'un sémaphore est définie directement par une requête B<SETVAL> ou B<SETALL> de B<semctl>(2), la valeur I<semadj> correspondante est effacée dans tous les processus. L'option B<CLONE_SYSVSEM> de B<clone>(2) permet à plusieurs processus de partager une liste de I<semadj>. Consultez B<clone>(2) pour plus d'informations.

note: type: Plain text
en: The I<semval>, I<sempid>, I<semzcnt>, and I<semnct> values for a semaphore can all be retrieved using appropriate B<semctl>(2)  calls.
fr: Les valeurs I<semval>, I<sempid>, I<semzcnt>, et I<semnct> pour un sémaphore peuvent être retrouvées avec des appels B<semctl>(2) spécifiques.

note: type: SS
en: Semaphore limits
fr: Limites des sémaphores

note: type: Plain text
en: The following limits on semaphore set resources affect the B<semop>()  call:
fr: Les limites suivantes de ressources concernent l'appel système B<semop>()\ :

note: commit e843e7d2c88b7db107a86bd2c7145dc715c058f4 This /proc file is not available in Linux 2.2 and earlier -- MTK See comment in Linux 3.19 source file include/uapi/linux/sem.h type: Plain text
en: Maximum number of operations allowed for one B<semop>()  call.  Before Linux 3.19, the default value for this limit was 32.  Since Linux 3.19, the default value is 500.  On Linux, this limit can be read and modified via the third field of I</proc/sys/kernel/sem>.  I<Note>: this limit should not be raised above 1000, because of the risk of that B<semop>()  fails due to kernel memory fragmentation when allocating memory to copy the I<sops> array.
fr: Nombre maximal d'opérations pour un appel à B<semop>. Avant Linux 3.19, la valeur par défaut pour cette limite était de 32. Depuis Linux 3.19, cette valeur est de 500. Sous Linux, cette limite peut être lue et modifiée via le troisième champ du fichier I</proc/sys/kernel/sem>. I<Note> : cette limite ne devrait pas être augmentée au-delà de 1000 à cause du risque que B<semop>() échoue en raison de la fragmentation de la mémoire du noyau pendant l'allocation de mémoire pour copier le tableau I<sops>.

note: type: Plain text
en: Maximum allowable value for I<semval>: implementation dependent (32767).
fr: Valeur maximale pour I<semval>\ : dépendante de l'implémentation (32767).

note: type: Plain text
en: The implementation has no intrinsic limits for the adjust on exit maximum value (B<SEMAEM>), the system wide maximum number of undo structures (B<SEMMNU>)  and the per-process maximum number of undo entries system parameters.
fr: L'implémentation n'a pas de limites intrinsèques pour la valeur maximale d'effacement en sortie (B<SEMAEM>), le nombre de structures d'annulation sur le système (B<SEMMNU>), et le nombre maximal de structures d'annulation pour un processus.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: When a process terminates, its set of associated I<semadj> structures is used to undo the effect of all of the semaphore operations it performed with the B<SEM_UNDO> flag.  This raises a difficulty: if one (or more) of these semaphore adjustments would result in an attempt to decrease a semaphore's value below zero, what should an implementation do? One possible approach would be to block until all the semaphore adjustments could be performed.  This is however undesirable since it could force process termination to block for arbitrarily long periods.  Another possibility is that such semaphore adjustments could be ignored altogether (somewhat analogously to failing when B<IPC_NOWAIT> is specified for a semaphore operation).  Linux adopts a third approach: decreasing the semaphore value as far as possible (i.e., to zero) and allowing process termination to proceed immediately.
fr: Quand un processus se termine, l'ensemble des structures I<semadj> qui lui sont associées servent à annuler les effets de toutes les opérations sur les sémaphores réalisées avec l'attribut B<SEM_UNDO>. Cela pose un problème\ : si l'une (ou plusieurs) des modifications sur les sémaphores demande une descente du compteur d'un sémaphore au-dessous de zéro, que doit faire l'implémentation\ ? Une approche possible consiste à bloquer jusqu'à ce que la modification du sémaphore soit possible. C'est néanmoins peu désirable car la terminaison du processus peut alors bloquer pendant une période arbitrairement longue. Une autre possibilité est d'ignorer la modification du sémaphore (comme un échec lorsque B<IPC_NOWAIT> est spécifié durant une opération). Linux adopte une troisième approche\ : décroître la valeur du sémaphore autant que possible (jusqu'à zéro) et permettre au processus de se terminer immédiatement.

note: The bug report: http://marc.theaimsgroup.com/?l=linux-kernel&m=110260821123863&w=2 the fix: http://marc.theaimsgroup.com/?l=linux-kernel&m=110261701025794&w=2 type: Plain text
en: In kernels 2.6.x, x E<lt>= 10, there is a bug that in some circumstances prevents a thread that is waiting for a semaphore value to become zero from being woken up when the value does actually become zero.  This bug is fixed in kernel 2.6.11.
fr: Dans les noyaux 2.6.x (x E<lt>= 10) un bogue peut, dans certaines circonstances, empêcher un thread, attendant que la valeur d'un sémaphore s'annule, d'être réveillé quand cette valeur atteint 0. Ce bogue est corrigé dans le noyau 2.6.11.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The following code segment uses B<semop>()  to atomically wait for the value of semaphore 0 to become zero, and then increment the semaphore value by one.
fr: Le bout de code suivant utilise B<semop>() pour attendre de façon atomique que la valeur du sémaphore 0 vaille zéro, puis incrémente la valeur du sémaphore de un.

note: type: Plain text
en: /* Code to set I<semid> omitted */
fr: /* Le code pour configurer I<semid> est omis */

note: type: Plain text
en: sops[0].sem_num = 0;        /* Operate on semaphore 0 */
    sops[0].sem_op = 0;         /* Wait for value to equal 0 */
    sops[0].sem_flg = 0;
fr: sops[0].sem_num = 0;        /* Agir sur le sémaphore 0 */
    sops[0].sem_op = 0;         /* Attendre que la valeur soit égale à 0 */
    sops[0].sem_flg = 0;

note: type: Plain text
en: sops[1].sem_num = 0;        /* Operate on semaphore 0 */
    sops[1].sem_op = 1;         /* Increment value by one */
    sops[1].sem_flg = 0;
fr: sops[1].sem_num = 0;        /* Agir sur le sémaphore 0 */
    sops[1].sem_op = 1;         /* Incrémenter la valeur de un */
    sops[1].sem_flg = 0;

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

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

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

note: type: TH
en: 2017-09-15
fr: 15 septembre 2017

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