perkamon - en to fr translation catalogue (202 entries)

note: type: TH
en: 2023-05-03
fr: 3 mai 2023

note: type: TH
en: Linux man-pages 6.05.01
fr: Pages du manuel de Linux 6.05.01

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: futex - fast user-space locking
fr: futex – Verrouillage rapide en mode utilisateur

note: type: SH
en: LIBRARY
fr: BIBLIOTHÈQUE

note: type: Plain text
en: Standard C library (I<libc>, I<-lc>)
fr: Bibliothèque C standard (I<libc>, I<-lc>)

note: type: Plain text
en: B<#include E<lt>linux/futex.hE<gt>>      /* Definition of B<FUTEX_*> constants */
    B<#include E<lt>sys/syscall.hE<gt>>      /* Definition of B<SYS_*> constants */
    B<#include E<lt>unistd.hE<gt>>
fr: B<#include E<lt>linux/futex.hE<gt>>   /* Définition des constantes B<FUTEX_*> */
    B<#include E<lt>sys/syscall.hE<gt>>   /* Définition des constantes B<SYS_*> */
    B<#include E<lt>unistd.hE<gt>>

note: type: Plain text
en: B<long syscall(SYS_futex, uint32_t *>I<uaddr>B<, int >I<futex_op>B<, uint32_t >I<val>B<,>
    B<             const struct timespec *>I<timeout>B<,>I< >  /* or: B<uint32_t >I<val2>B< */>
    B<             uint32_t *>I<uaddr2>B<, uint32_t >I<val3>B<);>
fr: B<long syscall(SYS_futex, uint32_t *>I<uaddr>B<, int >I<futex_op>B<, uint32_t >I<val>B<,>
    B<             const struct timespec *>I<timeout>B<,>I< >  /* ou : B<uint32_t >I<val2>B< */>
    B<             uint32_t *>I<uaddr2>B<, uint32_t >I<val3>B<);>

note: type: Plain text
en: I<Note>: glibc provides no wrapper for B<futex>(), necessitating the use of B<syscall>(2).
fr: I<Remarque> : la glibc ne fournit pas de fonction autour de B<futex>(), nécessitant l'utilisation de B<syscall>(2).

note: type: Plain text
en: The B<futex>()  system call provides a method for waiting until a certain condition becomes true.  It is typically used as a blocking construct in the context of shared-memory synchronization.  When using futexes, the majority of the synchronization operations are performed in user space.  A user-space program employs the B<futex>()  system call only when it is likely that the program has to block for a longer time until the condition becomes true.  Other B<futex>()  operations can be used to wake any processes or threads waiting for a particular condition.
fr: L'appel système B<futex>() offre une méthode pour attendre qu'une condition soit vraie. On l'utilise en général comme construction de blocage dans le contexte de la synchronisation de la mémoire partagée. Quand on utilise des futex, la majorité des opérations de synchronisation s'effectue dans l'espace utilisateur. Un programme de l'espace utilisateur n'utilise l'appel système B<futex>() que lorsqu'il est probable qu'il doive se bloquer plus longtemps avant que la condition ne soit vraie. D'autres opérations B<futex>() peuvent être utilisées pour réveiller des processus ou des threads qui attendent une condition en particulier.

note: type: Plain text
en: A futex is a 32-bit value\[em]referred to below as a I<futex word>\[em]whose address is supplied to the B<futex>()  system call.  (Futexes are 32 bits in size on all platforms, including 64-bit systems.)  All futex operations are governed by this value.  In order to share a futex between processes, the futex is placed in a region of shared memory, created using (for example)  B<mmap>(2)  or B<shmat>(2).  (Thus, the futex word may have different virtual addresses in different processes, but these addresses all refer to the same location in physical memory.)  In a multithreaded program, it is sufficient to place the futex word in a global variable shared by all threads.
fr: Un futex est une valeur 32 bits — désignée ci-dessous comme « I<mot futex> » —dont l'adresse est fournie à l'appel système B<futex>() (les futex ont une taille de 32 bits sur toutes les plateformes, y compris les systèmes 64 bits). Toutes les opérations futex sont pilotées par cette valeur. Afin de partager un futex entre des processus, le futex est placé dans une zone de la mémoire partagée créée en utilisant (par exemple) B<mmap>(2) ou B<shmat>(2) (ainsi, le mot futex peut avoir plusieurs adresses virtuelles dans différents processus, mais ces adresses se rapportent toutes au même emplacement de la mémoire physique). Dans un programme multithreadé, il suffit de mettre le mot futex dans une variable globale partagée par tous les threads.

note: Notes from Darren Hart (Dec 2015): Totally ordered with respect futex operations refers to semantics of the ACQUIRE/RELEASE operations and how they impact ordering of memory reads and writes. The kernel futex operations are protected by spinlocks, which ensure that all operations are serialized with
en: When executing a futex operation that requests to block a thread, the kernel will block only if the futex word has the value that the calling thread supplied (as one of the arguments of the B<futex>()  call) as the expected value of the futex word.  The loading of the futex word's value, the comparison of that value with the expected value, and the actual blocking will happen atomically and will be totally ordered with respect to concurrent operations performed by other threads on the same futex word.  Thus, the futex word is used to connect the synchronization in user space with the implementation of blocking by the kernel.  Analogously to an atomic compare-and-exchange operation that potentially changes shared memory, blocking via a futex is an atomic compare-and-block operation.
fr: Lors de l'exécution d'une opération futex qui demande le blocage d'un thread, le noyau ne le bloquera que si le mot futex a une valeur fournie par le thread appelant (en tant qu'un des paramètres de l'appel B<futex>()) correspondant à celle prévue du mot futex. Le chargement de la valeur du mot futex, la comparaison de cette valeur avec celle attendue et le blocage s'effectueront de manière atomique et seront entièrement organisés par rapport aux opérations qui sont effectuées en parallèle par d'autres threads sur le même mot futex. Ainsi, le mot futex est utilisé pour relier la synchronisation de l'espace utilisateur et l'implémentation du blocage par le noyau. Tout comme une opération compare-and-exchange atomique qui modifie potentiellement la mémoire partagée, le blocage par futex est une opération compare-and-block atomique.

note: type: Plain text
en: One use of futexes is for implementing locks.  The state of the lock (i.e., acquired or not acquired)  can be represented as an atomically accessed flag in shared memory.  In the uncontended case, a thread can access or modify the lock state with atomic instructions, for example atomically changing it from not acquired to acquired using an atomic compare-and-exchange instruction.  (Such instructions are performed entirely in user mode, and the kernel maintains no information about the lock state.)  On the other hand, a thread may be unable to acquire a lock because it is already acquired by another thread.  It then may pass the lock's flag as a futex word and the value representing the acquired state as the expected value to a B<futex>()  wait operation.  This B<futex>()  operation will block if and only if the lock is still acquired (i.e., the value in the futex word still matches the "acquired state").  When releasing the lock, a thread has to first reset the lock state to not acquired and then execute a futex operation that wakes threads blocked on the lock flag used as a futex word (this can be further optimized to avoid unnecessary wake-ups).  See B<futex>(7)  for more detail on how to use futexes.
fr: Une utilisation des futex consiste à implémenter des verrous. L'état du verrou (c'est-à-dire acquis ou non acquis) peut se représenter comme un drapeau auquel on a un accès atomique en mémoire partagée. En absence de conflit (uncontended case), un thread peut accéder et modifier l'état du verrou avec des instructions atomiques, par exemple le passer de manière atomique de l'état non acquis à acquis, en utilisant une instruction compare-and-exchange atomique (de telles instructions s'effectuent entièrement dans l'espace utilisateur et le noyau ne conserve aucune information sur l'état du verrou). D'un autre côté, un thread peut être incapable d'acquérir un verrou parce qu'il est déjà acquis par un autre thread. Il peut alors passer l'attribut du verrou en tant que mot futex, et la valeur représentant l'état acquis en tant que valeur attendue pour l'opération d'attente de B<futex>(). Cette opération B<futex>() bloquera si et seulement si le verrou est encore acquis (c'est-à-dire si la valeur du mot futex correspond toujours à « l'état acquis »). Lorsque le verrou est relâché, le thread doit d'abord réinitialiser l'état du verrou sur non acquis puis exécuter une opération futex qui réveille les threads bloqués par le drapeau de verrou utilisé en tant que mot futex (cela peut être mieux optimisé pour éviter les réveils inutiles). Voir B<futex>(7) pour plus de détails sur la manière d'utiliser les futex.

note: type: Plain text
en: Besides the basic wait and wake-up futex functionality, there are further futex operations aimed at supporting more complex use cases.
fr: Outre la fonctionnalité de base du futex consistant à attendre et à réveiller, d'autres opérations futex visent à gérer des cas d'utilisation plus complexes.

note: type: Plain text
en: Note that no explicit initialization or destruction is necessary to use futexes; the kernel maintains a futex (i.e., the kernel-internal implementation artifact)  only while operations such as B<FUTEX_WAIT>, described below, are being performed on a particular futex word.
fr: Remarquez qu'aucune initialisation ou destruction explicite n'est nécessaire pour utiliser les futex ; le noyau ne garde un futex (c'est-à-dire un artefact d'implémentation interne au noyau) que pendant que les opérations telles que B<FUTEX_WAIT>, décrite ci-dessous, s'effectuent sur un mot futex en particulier.

note: type: Plain text
en: The I<uaddr> argument points to the futex word.  On all platforms, futexes are four-byte integers that must be aligned on a four-byte boundary.  The operation to perform on the futex is specified in the I<futex_op> argument; I<val> is a value whose meaning and purpose depends on I<futex_op>.
fr: Le paramètre I<uaddr> pointe vers un mot futex. Sur toutes les plateformes, les futex sont des entiers de quatre octets qui doivent être alignés sur une limite de quatre octets. L'opération à effectuer sur le futex est indiquée dans le paramètre de I<futex_op> ; I<val> est une valeur dont la signification et l'objectif dépendent de I<futex_op>.

note: type: Plain text
en: The remaining arguments (I<timeout>, I<uaddr2>, and I<val3>)  are required only for certain of the futex operations described below.  Where one of these arguments is not required, it is ignored.
fr: Les autres paramètres (I<timeout>, I<uaddr2> et I<val3>) ne sont nécessaires que pour certaines opérations futex décrites ci-dessous. Si un de ces arguments n'est pas nécessaire, il est ignoré.

note: type: Plain text
en: For several blocking operations, the I<timeout> argument is a pointer to a I<timespec> structure that specifies a timeout for the operation.  However, notwithstanding the prototype shown above, for some operations, the least significant four bytes of this argument are instead used as an integer whose meaning is determined by the operation.  For these operations, the kernel casts the I<timeout> value first to I<unsigned long>, then to I<uint32_t>, and in the remainder of this page, this argument is referred to as I<val2> when interpreted in this fashion.
fr: Pour plusieurs opérations de blocage, le paramètre I<timeout> est un pointeur vers une structure I<timespec> qui indique la durée maximale de l'opération. Toutefois, contrairement au prototype décrit ci-dessus, pour certaines opérations, les quatre octets les moins significatifs de ce paramètre sont utilisés comme un entier dont la signification est déterminée par l'opération. Pour ces opérations, le noyau diffuse la valeur I<timeout> d'abord à I<unsigned long>, puis à I<uint32_t>, et dans le reste de cette page, ce paramètre est désigné par I<val2> quand il est interprété de cette manière.

note: type: Plain text
en: Where it is required, the I<uaddr2> argument is a pointer to a second futex word that is employed by the operation.
fr: Lorsqu'il est nécessaire, le paramètre I<uaddr2> est un pointeur vers un deuxième mot futex utilisé par l'opération.

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: The interpretation of the final integer argument, I<val3>, depends on the operation.
fr: L'interprétation du paramètre de l'entier final, I<val3>, dépend de l'opération.

note: type: SS
en: Futex operations
fr: Opérations futex

note: type: Plain text
en: The I<futex_op> argument consists of two parts: a command that specifies the operation to be performed, bitwise ORed with zero or more options that modify the behaviour of the operation.  The options that may be included in I<futex_op> are as follows:
fr: Le paramètre I<futex_op> est en deux parties : une commande qui indique l'opération à effectuer et un bit ORed avec zéro ou plusieurs options qui changent le comportement de l'opération. Les options qui peuvent être incluses dans I<futex_op> sont les suivantes :

note: type: TP
en: B<FUTEX_PRIVATE_FLAG> (since Linux 2.6.22)
fr: B<FUTEX_PRIVATE_FLAG> (depuis Linux 2.6.22)

note: commit 34f01cc1f512fa783302982776895c73714ebbc2 I.e., It allows the kernel choose the fast path for validating the user-space address and avoids expensive VMA lookups, taking reference counts on file backing store, and so on. type: Plain text
en: This option bit can be employed with all futex operations.  It tells the kernel that the futex is process-private and not shared with another process (i.e., it is being used for synchronization only between threads of the same process).  This allows the kernel to make some additional performance optimizations.
fr: Ce bit d'option peut être utilisé avec toutes les opérations futex. Il dit au noyau que le futex est un processus privé non partagé avec d'autres processus (c'est-à-dire qu'il n'est utilisé que pour la synchronisation entre les threads du même processus). Cela permet au noyau d'effectuer des optimisations de performance supplémentaires.

note: except the obsolete FUTEX_FD, for which the "private" flag was meaningless type: Plain text
en: As a convenience, I<E<lt>linux/futex.hE<gt>> defines a set of constants with the suffix B<_PRIVATE> that are equivalents of all of the operations listed below, but with the B<FUTEX_PRIVATE_FLAG> ORed into the constant value.  Thus, there are B<FUTEX_WAIT_PRIVATE>, B<FUTEX_WAKE_PRIVATE>, and so on.
fr: Par commodité, I<E<lt>linux/futex.hE<gt>> définit un ensemble de constantes dont le suffixe est B<_PRIVATE> et qui sont équivalentes à toutes les opérations listées ci-dessous mais avec l'attribut B<FUTEX_PRIVATE_FLAG> ORed dans la valeur de la constante. On trouve ainsi B<FUTEX_WAIT_PRIVATE>, B<FUTEX_WAKE_PRIVATE> et ainsi de suite.

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

note: commit 1acdac104668a0834cfa267de9946fac7764d486 commit 337f13046ff03717a9e99675284a817527440a49 commit bf22a6976897977b0a3f1aeba6823c959fc4fdae type: Plain text
en: This option bit can be employed only with the B<FUTEX_WAIT_BITSET>, B<FUTEX_WAIT_REQUEUE_PI>, (since Linux 4.5)  B<FUTEX_WAIT>, and (since Linux 5.14)  B<FUTEX_LOCK_PI2> operations.
fr: Ce bit d'option ne peut être utilisé qu'avec les opérations B<FUTEX_WAIT_BITSET>, B<FUTEX_WAIT_REQUEUE_PI> (depuis Linux 4.5), B<FUTEX_WAIT> (depuis Linux 4.5) et B<FUTEX_LOCK_PI2> (depuis Linux 5.14).

note: type: Plain text
en: If this option is set, the kernel measures the I<timeout> against the B<CLOCK_REALTIME> clock.
fr: Si cette option est positionnée, le noyau mesure le I<timeout> par rapport à l'horloge B<CLOCK_REALTIME>.

note: type: Plain text
en: If this option is not set, the kernel measures the I<timeout> against the B<CLOCK_MONOTONIC> clock.
fr: Si cette option n'est pas positionnée, le noyau mesure le I<timeout> par rapport à l'horloge B<CLOCK_MONOTONIC>.

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: The operation specified in I<futex_op> is one of the following:
fr: L'opération indiquée dans I<futex_op> prend une de ces valeurs\ :

note: type: TP
en: B<FUTEX_WAIT> (since Linux 2.6.0)
fr: B<FUTEX_WAIT> (depuis Linux 2.6.0)

note: Strictly speaking, since some time in Linux 2.5.x FIXME: Torvald, I think we may need to add some explanation of "totally ordered" here. type: Plain text
en: This operation tests that the value at the futex word pointed to by the address I<uaddr> still contains the expected value I<val>, and if so, then sleeps waiting for a B<FUTEX_WAKE> operation on the futex word.  The load of the value of the futex word is an atomic memory access (i.e., using atomic machine instructions of the respective architecture).  This load, the comparison with the expected value, and starting to sleep are performed atomically and totally ordered with respect to other futex operations on the same futex word.  If the thread starts to sleep, it is considered a waiter on this futex word.  If the futex value does not match I<val>, then the call fails immediately with the error B<EAGAIN>.
fr: Cette option teste que la valeur du mot futex vers laquelle pointe l'adresse I<uaddr> contient toujours la valeur I<val> attendue, et si tel est le cas, elle s'endort jusqu'à une opération B<FUTEX_WAKE> sur le mot futex. Le chargement de la valeur du mot futex est un accès en mémoire atomique (c'est-à-dire qu'il utilise des instructions machine atomiques de l'architecture concernée). Ce chargement, la comparaison avec la valeur attendue et la mise en sommeil s'effectuent de manière atomique et sont totalement organisés selon les autres opérations futex sur le même mot futex. Si le thread commence à dormir, il est considéré comme en attente de ce mot futex. Si la valeur futex ne correspond pas à I<val>, l'appel échoue immédiatement avec l'erreur B<EAGAIN>.

note: type: Plain text
en: The purpose of the comparison with the expected value is to prevent lost wake-ups.  If another thread changed the value of the futex word after the calling thread decided to block based on the prior value, and if the other thread executed a B<FUTEX_WAKE> operation (or similar wake-up) after the value change and before this B<FUTEX_WAIT> operation, then the calling thread will observe the value change and will not start to sleep.
fr: Le but de la comparaison avec la valeur attendue est d'empêcher des réveils perdus. Si un autre thread a changé la valeur du mot futex après que le thread a décidé de se bloquer en se fondant sur la valeur d'avant, et si l'autre thread a effectué une opération B<FUTEX_WAKE> (ou un réveil équivalent) après le changement de cette valeur et avant cette opération B<FUTEX_WAIT>, le thread appelant observera cette valeur et ne commencera pas à dormir.

note: type: Plain text
en: If the I<timeout> is not NULL, the structure it points to specifies a timeout for the wait.  (This interval will be rounded up to the system clock granularity, and is guaranteed not to expire early.)  The timeout is by default measured according to the B<CLOCK_MONOTONIC> clock, but, since Linux 4.5, the B<CLOCK_REALTIME> clock can be selected by specifying B<FUTEX_CLOCK_REALTIME> in I<futex_op>.  If I<timeout> is NULL, the call blocks indefinitely.
fr: Si le I<timeout> n'est pas NULL, la structure vers laquelle il pointe indique un délai d'attente (cet intervalle sera arrondi à la valeur supérieure à partir de la granularité de l'horloge système et il est garanti de ne pas expirer en avance). Le délai est mesuré par défaut par rapport à l'horloge B<CLOCK_MONOTONIC> mais depuis Linux 4.5, l'horloge B<CLOCK_REALTIME> peut être choisie en indiquant B<FUTEX_CLOCK_REALTIME> dans I<futex_op>. Si le I<timeout> est NULL, l'appel se bloque indéfiniment.

note: type: Plain text
en: I<Note>: for B<FUTEX_WAIT>, I<timeout> is interpreted as a I<relative> value.  This differs from other futex operations, where I<timeout> is interpreted as an absolute value.  To obtain the equivalent of B<FUTEX_WAIT> with an absolute timeout, employ B<FUTEX_WAIT_BITSET> with I<val3> specified as B<FUTEX_BITSET_MATCH_ANY>.
fr: I<Remarque> : pour B<FUTEX_WAIT>, le I<timeout> est interprété comme une I<valeur> relative. Cela diffère des autres opérations futex où le I<timeout> est interprété comme une valeur absolue. Pour obtenir l'équivalent de B<FUTEX_WAIT>, avec un délai absolu, utilisez B<FUTEX_WAIT_BITSET> en indiquant I<val3> comme B<FUTEX_BITSET_MATCH_ANY>.

note: FIXME . (Torvald) I think we should remove this.  Or maybe adapt to a different example. For .BR futex (7), this call is executed if decrementing the count gave a negative value (indicating contention), and will sleep until another process or thread releases the futex and executes the .B FUTEX_WAKE 
en: The arguments I<uaddr2> and I<val3> are ignored.
fr: Les paramètres I<uaddr2> et I<val3> sont ignorés.

note: type: TP
en: B<FUTEX_WAKE> (since Linux 2.6.0)
fr: B<FUTEX_WAKE> (depuis Linux 2.6.0)

note: Strictly speaking, since Linux 2.5.x type: Plain text
en: This operation wakes at most I<val> of the waiters that are waiting (e.g., inside B<FUTEX_WAIT>)  on the futex word at the address I<uaddr>.  Most commonly, I<val> is specified as either 1 (wake up a single waiter) or B<INT_MAX> (wake up all waiters).  No guarantee is provided about which waiters are awoken (e.g., a waiter with a higher scheduling priority is not guaranteed to be awoken in preference to a waiter with a lower priority).
fr: Cette opération réveille jusqu'à I<val> éléments en attente (comme dans B<FUTEX_WAIT>) sur le mot futex à l'adresse I<uaddr>. Généralement, I<val> est indiqué soit sous la forme de B<1> (réveil d'un seul élément en attente) soit avec B<INT_MAX> (réveil de tous les éléments en attente). Vous n'avez aucune garantie quant aux éléments qui sont réveillés (par exemple un élément en attente dont la priorité d'ordonnancement élevée n'est pas garanti de se réveiller avant un autre d'une priorité plus basse).

note: type: Plain text
en: The arguments I<timeout>, I<uaddr2>, and I<val3> are ignored.
fr: Les paramètres I<timeout>, I<uaddr2> et I<val3> sont ignorés.

note: type: TP
en: B<FUTEX_FD> (from Linux 2.6.0 up to and including Linux 2.6.25)
fr: B<FUTEX_FD> (de Linux 2.6.0 jusqu'à Linux 2.6.25 inclus)

note: Strictly speaking, from Linux 2.5.x to Linux 2.6.25 type: Plain text
en: This operation creates a file descriptor that is associated with the futex at I<uaddr>.  The caller must close the returned file descriptor after use.  When another process or thread performs a B<FUTEX_WAKE> on the futex word, the file descriptor indicates as being readable with B<select>(2), B<poll>(2), and B<epoll>(7)
fr: Cette opération crée un descripteur de fichier associé au futex sur I<uaddr>. L'appelant doit fermer le descripteur de fichier renvoyé après l'avoir utilisé. Quand un autre processus ou un autre thread effectue un B<FUTEX_WAKE> sur le mot futex, le descripteur de fichier indique qu'il est accessible en lecture avec B<select>(2), B<poll>(2), et B<epoll>(7)

note: type: Plain text
en: The file descriptor can be used to obtain asynchronous notifications: if I<val> is nonzero, then, when another process or thread executes a B<FUTEX_WAKE>, the caller will receive the signal number that was passed in I<val>.
fr: Le descripteur de fichier peut être utilisé pour avoir des notifications asynchrones, si I<val> n'est pas nul, puis, quand un autre processus ou un autre thread exécute B<FUTEX_WAKE>, l'appelant recevra le numéro du signal passé à I<val>.

note: commit 82af7aca56c67061420d618cc5a30f0fd4106b80 """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: Because it was inherently racy, B<FUTEX_FD> has been removed from Linux 2.6.26 onward.
fr: Parce qu'il était de façon inhérente sujet à des situations de concurrence, B<FUTEX_FD> a été supprimé de Linux 2.6.26 et les suivants.

note: type: TP
en: B<FUTEX_REQUEUE> (since Linux 2.6.0)
fr: B<FUTEX_REQUEUE> (depuis Linux 2.6.0)

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: This operation performs the same task as B<FUTEX_CMP_REQUEUE> (see below), except that no check is made using the value in I<val3>.  (The argument I<val3> is ignored.)
fr: Cette opération effectue la même chose que B<FUTEX_CMP_REQUEUE> (voir ci-dessous), sauf qu'elle ne vérifie rien en utilisant la valeur dans I<val3> (le paramètre I<val3> est ignoré).

note: type: TP
en: B<FUTEX_CMP_REQUEUE> (since Linux 2.6.7)
fr: B<FUTEX_CMP_REQUEUE> (depuis Linux 2.6.7)

note: type: Plain text
en: This operation first checks whether the location I<uaddr> still contains the value I<val3>.  If not, the operation fails with the error B<EAGAIN>.  Otherwise, the operation wakes up a maximum of I<val> waiters that are waiting on the futex at I<uaddr>.  If there are more than I<val> waiters, then the remaining waiters are removed from the wait queue of the source futex at I<uaddr> and added to the wait queue of the target futex at I<uaddr2>.  The I<val2> argument specifies an upper limit on the number of waiters that are requeued to the futex at I<uaddr2>.
fr: Cette opération vérifie d'abord si l'emplacement I<uaddr> contient toujours la valeur I<val3>. Si tel n'est pas le cas, l'opération échoue avec l'erreur B<EAGAIN>. Si tel est le cas, l'opération réveille un maximum de I<val> éléments en attente du futex sur I<uaddr>. S'il y a plus de I<val> éléments en attente, les autres sont supprimés de la file d'attente du futex source sur I<uaddr> et ajoutés à la file d'attente du futex cible sur I<uaddr2>. Le paramètre I<val2> indique une limite supérieure du nombre d'éléments remis en attente dans le futex sur I<uaddr2>.

note: FIXME(Torvald) Is the following correct?  Or is just the decision which threads to wake or requeue part of the atomic operation? Notes from a f2f conversation with Thomas Gleixner (Aug 2015): ### The operation is serialized with respect to operations on both source and target futex. No other waiter 
en: The load from I<uaddr> is an atomic memory access (i.e., using atomic machine instructions of the respective architecture).  This load, the comparison with I<val3>, and the requeueing of any waiters are performed atomically and totally ordered with respect to other operations on the same futex word.
fr: Le chargement à partir de I<uaddr> est un accès atomique en mémoire (c'est-à-dire qu'il utilise les instructions machine atomiques de l'architecture concernée). Ce chargement, la comparaison avec I<val3> et la remise en attente d'éléments s'effectuent de manière atomique et sont totalement organisées par rapport aux autres opérations sur le même mot futex.

note: type: Plain text
en: Typical values to specify for I<val> are 0 or 1.  (Specifying B<INT_MAX> is not useful, because it would make the B<FUTEX_CMP_REQUEUE> operation equivalent to B<FUTEX_WAKE>.)  The limit value specified via I<val2> is typically either 1 or B<INT_MAX>.  (Specifying the argument as 0 is not useful, because it would make the B<FUTEX_CMP_REQUEUE> operation equivalent to B<FUTEX_WAIT>.)
fr: Les valeurs classiques qu'on indique à I<val> sont B<0> ou B<1> (indiquer B<INT_MAX> n'est pas utile car cela rendrait l'opération B<FUTEX_CMP_REQUEUE> équivalente à B<FUTEX_WAKE>). La valeur limite indiquée avec I<val2> est généralement B<1> ou B<INT_MAX> (indiquer B<0> en paramètre n'est pas utile car cela rendrait l'opération B<FUTEX_CMP_REQUEUE> équivalente à B<FUTEX_WAIT>).

note: But, as Rich Felker points out, there remain valid use cases for FUTEX_REQUEUE, for example, when the calling thread is requeuing the target(s) to a lock that the calling thread owns From: Rich Felker <dalias@libc.org> Date: Wed, 29 Oct 2014 22:43:17 -0400 To: Darren Hart <dvhart@infradead.org> CC: 
en: The B<FUTEX_CMP_REQUEUE> operation was added as a replacement for the earlier B<FUTEX_REQUEUE>.  The difference is that the check of the value at I<uaddr> can be used to ensure that requeueing happens only under certain conditions, which allows race conditions to be avoided in certain use cases.
fr: L'opération B<FUTEX_CMP_REQUEUE> a été ajoutée pour remplacer l'ancienne B<FUTEX_REQUEUE>. La différence est que la vérification de la valeur sur I<uaddr> peut être utilisée pour s'assurer que la remise en attente ne se produit que sous certaines conditions, ce qui évite les conflits de mémoire (race conditions) dans certains cas d'utilisation.

note: type: Plain text
en: Both B<FUTEX_REQUEUE> and B<FUTEX_CMP_REQUEUE> can be used to avoid "thundering herd" wake-ups that could occur when using B<FUTEX_WAKE> in cases where all of the waiters that are woken need to acquire another futex.  Consider the following scenario, where multiple waiter threads are waiting on B, a wait queue implemented using a futex:
fr: B<FUTEX_REQUEUE> et B<FUTEX_CMP_REQUEUE> peuvent être utilisées pour éviter des réveils en troupeau (thundering herd) qui peuvent survenir quand on utilise B<FUTEX_WAKE> dans des cas où tous les éléments en attente qu'on réveille doivent acquérir un autre futex. Imaginons le scénario suivant où plusieurs threads attendent en B, une file d'attente implémentée en utilisant un futex :

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: If a waker thread used B<FUTEX_WAKE>, then all waiters waiting on B would be woken up, and they would all try to acquire lock A.  However, waking all of the threads in this manner would be pointless because all except one of the threads would immediately block on lock A again.  By contrast, a requeue operation wakes just one waiter and moves the other waiters to lock A, and when the woken waiter unlocks A then the next waiter can proceed.
fr: Si un thread qui se réveille utilisait B<FUTEX_WAKE>, tous les éléments attendant en B se réveilleraient et essaieraient d'acquérir le verrou A. Cependant, réveiller tous ces threads de cette manière serait vain car tous les threads, sauf un, se bloqueraient immédiatement à nouveau via le verrou A. Au contraire, une remise dans la file d'attente ne réveille qu'un élément et déplace les autres sur le verrou A et quand celui réveillé déverrouille A, le suivant peut continuer.

note: type: TP
en: B<FUTEX_WAKE_OP> (since Linux 2.6.14)
fr: B<FUTEX_WAKE_OP> (depuis Linux 2.6.14)

note: commit 4732efbeb997189d9f9b04708dc26bf8613ed721 Author: Jakub Jelinek <jakub@redhat.com> Date:   Tue Sep 6 15:16:25 2005 -0700 FIXME. (Torvald) The glibc condvar implementation is currently being revised (e.g., to not use an internal lock anymore). It is probably more future-proof to remove this par
en: This operation was added to support some user-space use cases where more than one futex must be handled at the same time.  The most notable example is the implementation of B<pthread_cond_signal>(3), which requires operations on two futexes, the one used to implement the mutex and the one used in the implementation of the wait queue associated with the condition variable.  B<FUTEX_WAKE_OP> allows such cases to be implemented without leading to high rates of contention and context switching.
fr: Cette opération a été ajoutée pour prendre en charge certains cas d'utilisation de l'espace utilisateur où plus d'un futex à la fois doit être géré. L'exemple le plus frappant est l'implémentation de B<pthread_cond_signal>(3), qui nécessite des opérations sur deux futex, une pour implémenter le mutex, l'autre pour utiliser dans l'implémentation de la file d'attente associée à la variable conditionnelle. B<FUTEX_WAKE_OP> permet d'implémenter de tels cas sans augmenter le nombre de conflits et de changement de contexte.

note: type: Plain text
en: The B<FUTEX_WAKE_OP> operation is equivalent to executing the following code atomically and totally ordered with respect to other futex operations on any of the two supplied futex words:
fr: L'opération B<FUTEX_ WAKE_OP> revient à exécuter le code suivant de manière atomique et complètement organisé en fonction des opérations futex sur un des deux mots futex fournis :

note: type: Plain text
en: In other words, B<FUTEX_WAKE_OP> does the following:
fr: En d'autres termes, B<FUTEX_WAKE_OP> fait ce qui suit :

note: type: IP
en: \[bu]
fr: -

note: type: Plain text
en: saves the original value of the futex word at I<uaddr2> and performs an operation to modify the value of the futex at I<uaddr2>; this is an atomic read-modify-write memory access (i.e., using atomic machine instructions of the respective architecture)
fr: sauvegarde la valeur d'origine du mot futex sur I<uaddr2> et effectue une opération pour modifier la valeur du futex sur I<uaddr2> ; il s'agit d'un accès en mémoire read-modify-write atomique (c'est-à-dire d'une utilisation des instructions machine atomiques liées à l'architecture concernée)

note: type: Plain text
en: wakes up a maximum of I<val> waiters on the futex for the futex word at I<uaddr>; and
fr: réveille un maximum de I<val> éléments en attente sur le futex pour le mot futex sur I<uaddr> ;

note: type: Plain text
en: dependent on the results of a test of the original value of the futex word at I<uaddr2>, wakes up a maximum of I<val2> waiters on the futex for the futex word at I<uaddr2>.
fr: et selon les résultats d'un test de la valeur d'origine du mot futex sur I<uaddr2>, réveille un maximum de I<val2> éléments en attente du mot futex sur le futex sur I<uaddr2>.

note: type: Plain text
en: The operation and comparison that are to be performed are encoded in the bits of the argument I<val3>.  Pictorially, the encoding is:
fr: L'opération et la comparaison qui doivent être effectuées sont encodées dans les bits du paramètre I<val3>. Visuellement, l'encodage est :

note: type: Plain text
en: Expressed in code, the encoding is:
fr: Exprimé en code, l'encodage est :

note: type: Plain text
en: In the above, I<op> and I<cmp> are each one of the codes listed below.  The I<oparg> and I<cmparg> components are literal numeric values, except as noted below.
fr: Dans ce qui précède, I<op> et I<cmp> sont chacun des codes listés ci-dessous. Les composants I<oparg> et I<cmparg> sont des valeurs numériques littérales, sauf les remarques ci-dessous.

note: type: Plain text
en: The I<op> component has one of the following values:
fr: Le composant I<op> prend une de ces valeurs\ :

note: type: Plain text
en: In addition, bitwise ORing the following value into I<op> causes I<(1\~E<lt>E<lt>\~oparg)> to be used as the operand:
fr: En outre, comparer bit à bit (ORing) la valeur suivante dans I<op> a pour conséquence que I<(1\~E<lt>E<lt>\~oparg)> sera utilisé en tant qu'opérande :

note: type: Plain text
en: FUTEX_OP_ARG_SHIFT  8  /* Use (1 E<lt>E<lt> oparg) as operand */
fr: FUTEX_OP_ARG_SHIFT  8  /* Utiliser (1 E<lt>E<lt> oparg) comme opérande */

note: type: Plain text
en: The I<cmp> field is one of the following:
fr: Le champ I<cmp> prend une de ces valeurs\ :

note: type: Plain text
en: FUTEX_OP_CMP_EQ     0  /* if (oldval == cmparg) wake */
    FUTEX_OP_CMP_NE     1  /* if (oldval != cmparg) wake */
    FUTEX_OP_CMP_LT     2  /* if (oldval E<lt> cmparg) wake */
    FUTEX_OP_CMP_LE     3  /* if (oldval E<lt>= cmparg) wake */
    FUTEX_OP_CMP_GT     4  /* if (oldval E<gt> cmparg) wake */
    FUTEX_OP_CMP_GE     5  /* if (oldval E<gt>= cmparg) wake */
fr: FUTEX_OP_CMP_EQ     0  /* si (oldval == cmparg) réveiller */
    FUTEX_OP_CMP_NE     1  /* si (oldval != cmparg) réveiller */
    FUTEX_OP_CMP_LT     2  /* si (oldval E<lt> cmparg) réveiller */
    FUTEX_OP_CMP_LE     3  /* si (oldval E<lt>= cmparg) réveiller */
    FUTEX_OP_CMP_GT     4  /* si (oldval E<gt> cmparg) réveiller */
    FUTEX_OP_CMP_GE     5  /* si (oldval E<gt>= cmparg) réveiller */

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: The return value of B<FUTEX_WAKE_OP> is the sum of the number of waiters woken on the futex I<uaddr> plus the number of waiters woken on the futex I<uaddr2>.
fr: Le code de retour de B<FUTEX_WAKE_OP> est la somme du nombre d'éléments en attente réveillés par le futex I<uaddr> et du nombre d'éléments en attente réveillés sur le futex I<uaddr2>.

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

note: commit cd689985cf49f6ff5c8eddc48d98b9d581d9475d type: Plain text
en: This operation is like B<FUTEX_WAIT> except that I<val3> is used to provide a 32-bit bit mask to the kernel.  This bit mask, in which at least one bit must be set, is stored in the kernel-internal state of the waiter.  See the description of B<FUTEX_WAKE_BITSET> for further details.
fr: Cette opération est équivalente à B<FUTEX_WAIT>, sauf que I<val3> est utilisé pour fournir un masque de bit de 32 bits au noyau. Ce masque, où au moins un bit doit être positionné, est stocké dans la partie interne du noyau de l'élément en attente. Voir la description de B<FUTEX_WAKE_BITSET> pour plus de détails.

note: type: Plain text
en: If I<timeout> is not NULL, the structure it points to specifies an absolute timeout for the wait operation.  If I<timeout> is NULL, the operation can block indefinitely.
fr: Si I<timeout> n'est pas NULL, la structure vers laquelle il pointe indique un délai absolu de l'opération d'attente. Si I<timeout> est NULL, l'opération peut se bloquer indéfiniment.

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: The I<uaddr2> argument is ignored.
fr: L'argument I<uaddr2> est ignoré.

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

note: commit cd689985cf49f6ff5c8eddc48d98b9d581d9475d type: Plain text
en: This operation is the same as B<FUTEX_WAKE> except that the I<val3> argument is used to provide a 32-bit bit mask to the kernel.  This bit mask, in which at least one bit must be set, is used to select which waiters should be woken up.  The selection is done by a bitwise AND of the "wake" bit mask (i.e., the value in I<val3>)  and the bit mask which is stored in the kernel-internal state of the waiter (the "wait" bit mask that is set using B<FUTEX_WAIT_BITSET>).  All of the waiters for which the result of the AND is nonzero are woken up; the remaining waiters are left sleeping.
fr: Cette opération est identique à B<FUTEX_WAKE>, sauf que le paramètre I<val3> est utilisé pour fournir un masque de bit de 32 bits au noyau. Ce masque, où au moins un bit doit être positionné, est utilisé pour choisir les éléments en attente qui doivent être réveillés. Le choix se fait par une comparaison bit à bit AND du masque de bit « wait » (à savoir la valeur de I<val3>) et par un masque de bit stocké dans la partie interne de l'élément en attente (le masque de bit « wait » positionné en utilisant B<FUTEX_WAIT_BITSET>). Tous les éléments en attente pour lesquels le AND est positif sont réveillés ; les autres restent endormis.

note: According to http://locklessinc.com/articles/futex_cheat_sheet/: "The original reason for the addition of these extensions was to improve the performance of pthread read-write locks in glibc. However, the pthreads library no longer uses the same locking algorithm, and these extensions are not used w
en: The effect of B<FUTEX_WAIT_BITSET> and B<FUTEX_WAKE_BITSET> is to allow selective wake-ups among multiple waiters that are blocked on the same futex.  However, note that, depending on the use case, employing this bit-mask multiplexing feature on a futex can be less efficient than simply using multiple futexes, because employing bit-mask multiplexing requires the kernel to check all waiters on a futex, including those that are not interested in being woken up (i.e., they do not have the relevant bit set in their "wait" bit mask).
fr: L'effet de B<FUTEX_WAIT_BITSET> et de B<FUTEX_WAKE_BITSET> est de permettre un réveil sélectif parmi les éléments en attente bloqués sur le même futex. Cependant, remarquez que selon le cas, l'utilisation de cette fonction de mélange de masques de bit sur un futex peut être moins efficace que le fait d'avoir plusieurs futex, car elle a besoin que le noyau vérifie tous les éléments en attente sur un futex, y compris ceux non concernés par le réveil (à savoir qu'ils n'ont pas de bit pertinent positionné dans leur masque de bit « wait »).

note: type: Plain text
en: The constant B<FUTEX_BITSET_MATCH_ANY>, which corresponds to all 32 bits set in the bit mask, can be used as the I<val3> argument for B<FUTEX_WAIT_BITSET> and B<FUTEX_WAKE_BITSET>.  Other than differences in the handling of the I<timeout> argument, the B<FUTEX_WAIT> operation is equivalent to B<FUTEX_WAIT_BITSET> with I<val3> specified as B<FUTEX_BITSET_MATCH_ANY>; that is, allow a wake-up by any waker.  The B<FUTEX_WAKE> operation is equivalent to B<FUTEX_WAKE_BITSET> with I<val3> specified as B<FUTEX_BITSET_MATCH_ANY>; that is, wake up any waiter(s).
fr: La constante B<FUTEX_BITSET_MATCH_ANY>, qui correspond à tous les positionnements 32 bits du masque, peut être utilisé en tant que I<val3> de B<FUTEX_WAIT_BITSET> et de B<FUTEX_WAKE_BITSET>. En dehors des différences dans la gestion du paramètre I<timeout>, l'opération B<FUTEX_WAIT> est équivalente à B<FUTEX_WAIT_BITSET> où I<val3> est indiqué en tant que B<FUTEX_BITSET_MATCH_ANY> ; c'est-à-dire permettre le réveil par n'importe quel élément en attente). L’opération B<FUTEX_WAKE> est équivalente à B<FUTEX_WAKE_BITSET> où I<val3> est indiqué en tant que B<FUTEX_BITSET_MATCH_ANY> ; c'est-à-dire, réveiller n’importe quel élément en attente.

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: The I<uaddr2> and I<timeout> arguments are ignored.
fr: Les arguments I<uaddr2> et I<timeout> sont ignorés.

note: type: SS
en: Priority-inheritance futexes
fr: Futex et héritage de priorité

note: type: Plain text
en: Linux supports priority-inheritance (PI) futexes in order to handle priority-inversion problems that can be encountered with normal futex locks.  Priority inversion is the problem that occurs when a high-priority task is blocked waiting to acquire a lock held by a low-priority task, while tasks at an intermediate priority continuously preempt the low-priority task from the CPU.  Consequently, the low-priority task makes no progress toward releasing the lock, and the high-priority task remains blocked.
fr: Linux prend en charge l'héritage de priorité (priority inheritance, PI) des futex, afin de gérer des problèmes d'inversion des priorités qu'on peut rencontrer avec des verrous futex normaux. L'inversion des priorités est un problème qui survient quand une tâche de haute priorité est bloquée en attente d'acquérir un verrou que possède une tâche de basse priorité issue du processeur. Du coup, la tâche de priorité basse ne va pas relâcher le verrou et celle de haute priorité reste bloquée.

note: type: Plain text
en: Priority inheritance is a mechanism for dealing with the priority-inversion problem.  With this mechanism, when a high-priority task becomes blocked by a lock held by a low-priority task, the priority of the low-priority task is temporarily raised to that of the high-priority task, so that it is not preempted by any intermediate level tasks, and can thus make progress toward releasing the lock.  To be effective, priority inheritance must be transitive, meaning that if a high-priority task blocks on a lock held by a lower-priority task that is itself blocked by a lock held by another intermediate-priority task (and so on, for chains of arbitrary length), then both of those tasks (or more generally, all of the tasks in a lock chain)  have their priorities raised to be the same as the high-priority task.
fr: L'héritage de priorité est un mécanisme pour gérer le problème d'inversion des priorités. Avec ce mécanisme, quand une tâche à haute priorité est bloquée par un verrou possédé par une tâche à basse priorité, la priorité de la seconde est temporairement amenée au même niveau que celle à haute priorité, de sorte qu'elle ne soit pas doublée par une tâche de niveau intermédiaire et qu'elle puisse ainsi avancer pour relâcher le verrou. Pour fonctionner, l'héritage de priorité doit être transitif, ce qui signifie que si une tâche à haute priorité bloque sur le verrou d'une tâche à priorité intermédiaire (et ainsi de suite sur des chaînes de la taille de votre choix), les deux tâches (ou plus généralement toutes les tâches de la chaîne de verrous) voient leur niveau de priorité amené à celui de la tâche à haute priorité.

note: Quoting Darren Hart: These opcodes paired with the PI futex value policy (described below) defines a "futex" as PI aware. These were created very specifically in support of PI pthread_mutexes, so it makes a lot more sense to talk about a PI aware pthread_mutex, than a PI aware futex, since there is 
en: From a user-space perspective, what makes a futex PI-aware is a policy agreement (described below)  between user space and the kernel about the value of the futex word, coupled with the use of the PI-futex operations described below.  (Unlike the other futex operations described above, the PI-futex operations are designed for the implementation of very specific IPC mechanisms.)
fr: Du point de vue de l'espace utilisateur, le futex a conscience d'un PI en acceptant une réglementation (décrite ci-dessous) entre l'espace utilisateur et le noyau sur la valeur du mot futex, couplé à l'utilisation d'opérations futex PI décrites ci-dessous (contrairement aux autres opérations futex décrites ci-dessus, celles PI-futex sont conçues pour l'implémentation de mécanismes IPC très spécifiques).

note: mtk: The following text is drawn from the Hart/Guniguntala paper (listed in SEE ALSO), but I have reworded some pieces significantly. type: Plain text
en: The PI-futex operations described below differ from the other futex operations in that they impose policy on the use of the value of the futex word:
fr: Les opérations PI-futex décrites ci-dessous diffèrent des autres opérations dans le sens où elles imposent des règles dans l'utilisation de la valeur du mot futex :

note: type: Plain text
en: If the lock is not acquired, the futex word's value shall be 0.
fr: Si le verrou n'est pas acquis, la valeur du mot futex doit être B<0>.

note: type: Plain text
en: If the lock is acquired, the futex word's value shall be the thread ID (TID; see B<gettid>(2))  of the owning thread.
fr: Si le verrou est acquis, la valeur du mot futex doit être l'ID du thread (TID ; voir B<gettid>(2)) du thread propriétaire.

note: type: Plain text
en: If the lock is owned and there are threads contending for the lock, then the B<FUTEX_WAITERS> bit shall be set in the futex word's value; in other words, this value is:
fr: Si le verrou a un propriétaire et s'il y a des threads en concurrence pour le verrou, le bit B<FUTEX_WAITERS> doit être positionné dans la valeur du mot futex ; autrement dit, cette valeur est :

note: type: Plain text
en: (Note that is invalid for a PI futex word to have no owner and B<FUTEX_WAITERS> set.)
fr: (Remarquez que cela n'est pas possible pour un mot futex PI d'être sans propriétaire ni B<FUTEX_WAITERS> défini).

note: type: Plain text
en: With this policy in place, a user-space application can acquire an unacquired lock or release a lock using atomic instructions executed in user mode (e.g., a compare-and-swap operation such as I<cmpxchg> on the x86 architecture).  Acquiring a lock simply consists of using compare-and-swap to atomically set the futex word's value to the caller's TID if its previous value was 0.  Releasing a lock requires using compare-and-swap to set the futex word's value to 0 if the previous value was the expected TID.
fr: Avec cette règle, une application de l'espace utilisateur peut acquérir un verrou non acquis ou en relâcher un en utilisant des instructions atomiques dans l'espace utilisateur (comme une opération compare-and-swap telle que I<cmpxchg> sur l'architecture x86). L'acquisition d'un verrou consiste simplement dans l'utilisation de compare-and-swap pour positionner la valeur du mot futex de manière atomique sur le TID de l'appelant si sa valeur précédente était B<0>. Relâcher un verrou exige d'utiliser compare-and-swap pour positionner la valeur du mot futex sur B<0> si la valeur précédente était le TID prévu.

note: type: Plain text
en: If a futex is already acquired (i.e., has a nonzero value), waiters must employ the B<FUTEX_LOCK_PI> or B<FUTEX_LOCK_PI2> operations to acquire the lock.  If other threads are waiting for the lock, then the B<FUTEX_WAITERS> bit is set in the futex value; in this case, the lock owner must employ the B<FUTEX_UNLOCK_PI> operation to release the lock.
fr: Si un futex est déjà acquis (c'est-à-dire qu'il a une valeur positive), les éléments en attente doivent utiliser l'opération B<FUTEX_LOCK_PI> pour acquérir le verrou. Si d'autres threads attendent le verrou, le bit B<FUTEX_WAITERS> est défini dans la valeur du futex ; dans ce cas le détenteur du verrou doit utiliser l'opération B<FUTEX_UNLOCK_PI> pour relâcher le verrou.

note: type: Plain text
en: In the cases where callers are forced into the kernel (i.e., required to perform a B<futex>()  call), they then deal directly with a so-called RT-mutex, a kernel locking mechanism which implements the required priority-inheritance semantics.  After the RT-mutex is acquired, the futex value is updated accordingly, before the calling thread returns to user space.
fr: Dans le cas où les appelants sont bloqués dans le noyau (c'est-à-dire qu'ils doivent effectuer un appel B<futex>()), ils traitent directement avec ce qu'on appelle un RT-mutex, un mécanisme de verrouillage du noyau qui implémente la sémantique de l'héritage de priorité requis. Après que le RT-mutex est acquis, la valeur futex est mise à jour en fonction, avant que le thread appelant ne renvoie vers l'espace utilisateur.

note: tglx (July 2015): If there are multiple waiters on a pi futex then a wake pi operation will wake the first waiter and hand over the lock to this waiter. This includes handing over the rtmutex which represents the futex in the kernel. The strict requirement is that the futex owner and the rtmutex own
en: It is important to note that the kernel will update the futex word's value prior to returning to user space.  (This prevents the possibility of the futex word's value ending up in an invalid state, such as having an owner but the value being 0, or having waiters but not having the B<FUTEX_WAITERS> bit set.)
fr: Il est important de remarquer que le noyau mettra à jour la valeur du mot futex avant de renvoyer vers l'espace utilisateur (cela enlève la possibilité pour la valeur d'un mot futex de se terminer dans un état non valable, par exemple en ayant un propriétaire mais en ayant la valeur B<0>, ou en ayant des éléments en attente mais aucun bit B<FUTEX_WAITERS> positionné).

note: tglx (July 2015): The FUTEX_OWNER_DIED bit can also be set on uncontended futexes, where the kernel has no state associated. This happens via the robust futex mechanism. In that case the futex value will be set to FUTEX_OWNER_DIED. The robust futex mechanism is also available for non PI futexes. typ
en: If a futex has an associated RT-mutex in the kernel (i.e., there are blocked waiters)  and the owner of the futex/RT-mutex dies unexpectedly, then the kernel cleans up the RT-mutex and hands it over to the next waiter.  This in turn requires that the user-space value is updated accordingly.  To indicate that this is required, the kernel sets the B<FUTEX_OWNER_DIED> bit in the futex word along with the thread ID of the new owner.  User space can detect this situation via the presence of the B<FUTEX_OWNER_DIED> bit and is then responsible for cleaning up the stale state left over by the dead owner.
fr: Si un futex a un RT-mutex associé dans le noyau (c'est-à-dire qu'il y a des éléments en attente bloqués) et si le propriétaire du futex/RT-mutex meurt de manière inattendue, le noyau nettoie le RT-mutex et passe la main au prochain élément en attente. Cela implique, en retour, que la valeur dans l'espace utilisateur soit mise à jour en fonction. Pour dire que c'est nécessaire, le noyau positionne le bit B<FUTEX_OWNER_DIED> dans le mot futex ainsi que dans l'ID du thread du nouveau propriétaire. L'espace utilisateur peut détecter cette situation par la présence du bit B<FUTEX_OWNER_DIED> et il est alors responsable pour nettoyer l'espace laissé par le propriétaire mort.

note: type: Plain text
en: PI futexes are operated on by specifying one of the values listed below in I<futex_op>.  Note that the PI futex operations must be used as paired operations and are subject to some additional requirements:
fr: Les PI futex sont utilisés en indiquant une des valeurs listées ci-dessous dans I<futex_op>. Remarquez que les opérations de PI futex doivent être utilisées par paires et sont soumises à des exigences supplémentaires :

note: type: Plain text
en: B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, and B<FUTEX_TRYLOCK_PI> pair with B<FUTEX_UNLOCK_PI>.  B<FUTEX_UNLOCK_PI> must be called only on a futex owned by the calling thread, as defined by the value policy, otherwise the error B<EPERM> results.
fr: B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2> et B<FUTEX_TRYLOCK_PI> vont de pair avec B<FUTEX_UNLOCK_PI>. B<FUTEX_UNLOCK_PI> ne doit être appelé que sur un futex appartenant au thread appelant, tel que défini par les règles de la valeur, sans quoi on obtient l'erreur B<EPERM>.

note: type: Plain text
en: B<FUTEX_WAIT_REQUEUE_PI> pairs with B<FUTEX_CMP_REQUEUE_PI>.  This must be performed from a non-PI futex to a distinct PI futex (or the error B<EINVAL> results).  Additionally, I<val> (the number of waiters to be woken) must be 1 (or the error B<EINVAL> results).
fr: B<FUTEX_WAIT_REQUEUE_PI> va de pair avec B<FUTEX_CMP_REQUEUE_PI>. Elles doivent s'effectuer depuis un futex non-PI vers un PI futex distinct (sans quoi on obtient l'erreur B<EINVAL>). De plus, I<val> (le nombre d'éléments en attente à réveiller) doit être de B<1> (sans quoi on obtient l'erreur B<EINVAL>).

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: The PI futex operations are as follows:
fr: Les opérations PI futex sont comme suit :

note: type: TP
en: B<FUTEX_LOCK_PI> (since Linux 2.6.18)
fr: B<FUTEX_LOCK_PI> (depuis Linux 2.6.18)

note: commit c87e2837be82df479a6bae9f155c43516d2feebc type: Plain text
en: This operation is used after an attempt to acquire the lock via an atomic user-mode instruction failed because the futex word has a nonzero value\[em]specifically, because it contained the (PID-namespace-specific) TID of the lock owner.
fr: Cette opération est utilisée après avoir essayé sans succès d'acquérir un verrou en utilisant une instruction atomique en mode utilisateur, car le mot futex a une valeur positive – en particulier parce qu'il contenait le TID (spécifique à l’espace de noms PID) du verrou propriétaire.

note: tglx (July 2015): The operation here is similar to the FUTEX_WAIT logic. When the user space atomic acquire does not succeed because the futex value was non zero, then the waiter goes into the kernel, takes the kernel internal lock and retries the acquisition under the lock. If the acquisition does 
en: The operation checks the value of the futex word at the address I<uaddr>.  If the value is 0, then the kernel tries to atomically set the futex value to the caller's TID.  If the futex word's value is nonzero, the kernel atomically sets the B<FUTEX_WAITERS> bit, which signals the futex owner that it cannot unlock the futex in user space atomically by setting the futex value to 0.  After that, the kernel:
fr: L'opération vérifie la valeur du mot futex sur l'adresse I<uaddr>. Si la valeur est de B<0>, le noyau essaie de positionner de manière atomique la valeur du futex sur le TID de l'appelant. Si la valeur du mot futex est positive, le noyau positionne de manière atomique le bit B<FUTEX_WAITERS>, qui signale au propriétaire du futex qu'il ne peut pas déverrouiller le futex dans l'espace utilisateur de manière atomique, en positionnant la valeur du futex à B<0>. Après cela, le noyau :

note: type: Plain text
en: Tries to find the thread which is associated with the owner TID.
fr: Essaie de trouver le thread associé au TID du propriétaire.

note: type: Plain text
en: Creates or reuses kernel state on behalf of the owner.  (If this is the first waiter, there is no kernel state for this futex, so kernel state is created by locking the RT-mutex and the futex owner is made the owner of the RT-mutex.  If there are existing waiters, then the existing state is reused.)
fr: Crée ou réutilise l'état du noyau sur la base du propriétaire (s'il s'agit du premier élément en attente, il n'existe pas d'état du noyau pour ce futex, donc il est créé en verrouillant le RT-mutex et le propriétaire du futex devient propriétaire du RT-mutex). Si des éléments en attente existent, l'état existant est réutilisé.

note: type: Plain text
en: Attaches the waiter to the futex (i.e., the waiter is enqueued on the RT-mutex waiter list).
fr: Rattache l'élément en attente au futex (c'est-à-dire que l'élément est mis dans la file d'attente du RT-futex).

note: August 2015: mtk: If the realm is restricted purely to SCHED_OTHER (SCHED_NORMAL) processes, does the nice value come into play also? tglx: No. SCHED_OTHER/NORMAL tasks are handled in FIFO order (i.e., task 1 blocks on lock A, held by task 2, while task 2 blocks on lock B, held by task 3) type: Plai
en: If more than one waiter exists, the enqueueing of the waiter is in descending priority order.  (For information on priority ordering, see the discussion of the B<SCHED_DEADLINE>, B<SCHED_FIFO>, and B<SCHED_RR> scheduling policies in B<sched>(7).)  The owner inherits either the waiter's CPU bandwidth (if the waiter is scheduled under the B<SCHED_DEADLINE> policy) or the waiter's priority (if the waiter is scheduled under the B<SCHED_RR> or B<SCHED_FIFO> policy).  This inheritance follows the lock chain in the case of nested locking and performs deadlock detection.
fr: S'il existe plus d'un élément en attente, la mise dans la file d'un élément se fait par ordre de priorité descendant (pour des informations sur l'ordre des priorités, voir les points sur l'ordonnancement B<SCHED_DEADLINE>, B<SCHED_FIFO> et B<SCHED_RR> dans B<sched>(7)). Le propriétaire hérite soit de la bande passante de processeur de l'élément en attente (si l'élément est programmé sous la règle B<SCHED_DEADLINE> ou B<SCHED_FIFO>), soit de la priorité de l'élément en attente (s'il est programmé sous la règle B<SCHED_RR> ou B<SCHED_FIFO>). Cet héritage suit la chaîne de verrous dans les cas de verrous imbriqués et il effectue la détection des verrous morts (deadlocks).

note: 2016-07-07 response from Thomas Gleixner on LKML: From: Thomas Gleixner <tglx@linutronix.de> Date: 6 July 2016 at 20:57 Subject: Re: futex: Allow FUTEX_CLOCK_REALTIME with FUTEX_WAIT op On Thu, 23 Jun 2016, Michael Kerrisk (man-pages) wrote: > On 06/23/2016 08:28 PM, Darren Hart wrote: > > And as a 
en: The I<timeout> argument provides a timeout for the lock attempt.  If I<timeout> is not NULL, the structure it points to specifies an absolute timeout, measured against the B<CLOCK_REALTIME> clock.  If I<timeout> is NULL, the operation will block indefinitely.
fr: Le paramètre I<timeout> fournit un délai de tentative de verrouillage. Si I<timeout> est positif, la structure vers laquelle il pointe indique un délai absolu mesuré en fonction de l'horloge B<CLOCK_REALTIME>. Si I<timeout> est NULL, l'opération se bloquera indéfiniment.

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: The I<uaddr2>, I<val>, and I<val3> arguments are ignored.
fr: Les paramètres I<uaddr2>, I<val> et I<val3> sont ignorés.

note: type: TP
en: B<FUTEX_LOCK_PI2> (since Linux 5.14)
fr: B<FUTEX_LOCK_PI2> (depuis Linux 5.14)

note: commit bf22a6976897977b0a3f1aeba6823c959fc4fdae """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: This operation is the same as B<FUTEX_LOCK_PI>, except that the clock against which I<timeout> is measured is selectable.  By default, the (absolute) timeout specified in I<timeout> is measured against the B<CLOCK_MONOTONIC> clock, but if the B<FUTEX_CLOCK_REALTIME> flag is specified in I<futex_op>, then the timeout is measured against the B<CLOCK_REALTIME> clock.
fr: Cette opération est la même que B<FUTEX_LOCK_PI>, sauf que l'horloge par rapport à laquelle I<timeout> est mesuré peut être sélectionnée. Par défaut, le délai (absolu) indiqué dans I<timeout> est mesuré par rapport à l'horloge B<CLOCK_MONOTONIC> mais si l'attribut B<FUTEX_CLOCK_REALTIME> est indiqué dans I<futex_op>, le délai est mesuré par rapport à l'horloge B<CLOCK_REALTIME>.

note: type: TP
en: B<FUTEX_TRYLOCK_PI> (since Linux 2.6.18)
fr: B<FUTEX_TRYLOCK_PI> (depuis Linux 2.6.18)

note: commit c87e2837be82df479a6bae9f155c43516d2feebc type: Plain text
en: This operation tries to acquire the lock at I<uaddr>.  It is invoked when a user-space atomic acquire did not succeed because the futex word was not 0.
fr: L'opération essaie d'acquérir le verrou sur I<uaddr>. Elle est appelée quand l'acquisition atomique dans l'espace utilisateur n'a pas réussi parce que le mot futex ne valait pas B<0>.

note: Paraphrasing a f2f conversation with Thomas Gleixner about the above point (Aug 2015): ### There is a rare possibility of a race condition involving an uncontended futex with no owner, but with waiters.  The kernel-user-space contract is that if a futex is nonzero, you must go into kernel.  The fute
en: Because the kernel has access to more state information than user space, acquisition of the lock might succeed if performed by the kernel in cases where the futex word (i.e., the state information accessible to use-space) contains stale state (B<FUTEX_WAITERS> and/or B<FUTEX_OWNER_DIED>).  This can happen when the owner of the futex died.  User space cannot handle this condition in a race-free manner, but the kernel can fix this up and acquire the futex.
fr: Du fait que le noyau accède à plus d'informations d'état que l'espace utilisateur, l'acquisition du verrou pourrait réussir si elle est effectuée par le noyau dans les cas où le mot futex (c'est-à-dire les informations d'état accessibles dans l'espace utilisateur) contient un état stable (B<FUTEX_WAITERS> et/ou B<FUTEX_OWNER_DIED>). Cela peut arriver quand le propriétaire du futex est mort. L'espace utilisateur ne peut pas gérer cette condition de manière "race-free", mais le noyau peut corriger cela et acquérir le futex.

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: The I<uaddr2>, I<val>, I<timeout>, and I<val3> arguments are ignored.
fr: Les paramètres I<uaddr2>, I<val>, I<timeout> et I<val3> sont ignorés.

note: type: TP
en: B<FUTEX_UNLOCK_PI> (since Linux 2.6.18)
fr: B<FUTEX_UNLOCK_PI> (depuis Linux 2.6.18)

note: commit c87e2837be82df479a6bae9f155c43516d2feebc type: Plain text
en: This operation wakes the top priority waiter that is waiting in B<FUTEX_LOCK_PI> or B<FUTEX_LOCK_PI2> on the futex address provided by the I<uaddr> argument.
fr: Cette opération réveille l'élément ayant la plus haute priorité et attendant un B<FUTEX_LOCK_PI> ou un B<FUTEX_LOCK_PI2> à l'adresse indiquée par le paramètre I<uaddr>.

note: type: Plain text
en: This is called when the user-space value at I<uaddr> cannot be changed atomically from a TID (of the owner) to 0.
fr: Cela est appelé quand la valeur dans l'espace utilisateur sur I<uaddr> ne peut pas être passée à B<0> de manière atomique depuis un TID (du propriétaire).

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

note: commit 52400ba946759af28442dee6265c5c0180ac7122 type: Plain text
en: This operation is a PI-aware variant of B<FUTEX_CMP_REQUEUE>.  It requeues waiters that are blocked via B<FUTEX_WAIT_REQUEUE_PI> on I<uaddr> from a non-PI source futex (I<uaddr>)  to a PI target futex (I<uaddr2>).
fr: Cette opération est une variante PI-aware de B<FUTEX_CMP_REQUEUE>. Elle remet en attente des éléments bloqués avec B<FUTEX_WAIT_REQUEUE_PI> sur I<uaddr> à partir d'un futex source non-PI (I<uaddr>) vers un futex cible PI (I<uaddr2>).

note: type: Plain text
en: As with B<FUTEX_CMP_REQUEUE>, this operation wakes up a maximum of I<val> waiters that are waiting on the futex at I<uaddr>.  However, for B<FUTEX_CMP_REQUEUE_PI>, I<val> is required to be 1 (since the main point is to avoid a thundering herd).  The remaining waiters are removed from the wait queue of the source futex at I<uaddr> and added to the wait queue of the target futex at I<uaddr2>.
fr: Comme avec B<FUTEX_CMP_REQUEUE>, cette opération réveille un maximum de I<val> éléments qui attendent le futex sur I<uaddr>. Toutefois, pour B<FUTEX_CMP_REQUEUE_PI>, I<val> doit valoir B<1> (puisque son but principal est d'éviter l’effet de troupeau (thundering herd). Les autres éléments sont supprimés de la file d'attente du futex source sur I<uaddr> et ajoutés sur celle du futex cible sur I<uaddr2>.

note: val2 is the cap on the number of requeued waiters. In the glibc pthread_cond_broadcast() implementation, this argument is specified as INT_MAX, and for pthread_cond_signal() it is 0. The page at http://locklessinc.com/articles/futex_cheat_sheet/ notes that "priority-inheritance Futex to priority-inh
en: The I<val2> and I<val3> arguments serve the same purposes as for B<FUTEX_CMP_REQUEUE>.
fr: Les paramètres I<val2> et I<val3> ont le même objectif qu'avec B<FUTEX_CMP_REQUEUE>.

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

note: commit 52400ba946759af28442dee6265c5c0180ac7122 type: Plain text
en: Wait on a non-PI futex at I<uaddr> and potentially be requeued (via a B<FUTEX_CMP_REQUEUE_PI> operation in another task) onto a PI futex at I<uaddr2>.  The wait operation on I<uaddr> is the same as for B<FUTEX_WAIT>.
fr: Attendre un futex non-PI sur I<uaddr> et se mettre potentiellement en attente (avec une opération B<FUTEX_CMP_REQUEUE_PI> dans une autre tâche), d'un futex PI sur I<uaddr2>. L'opération d'attente sur I<uaddr> est la même que pour B<FUTEX_WAIT>.

note: type: Plain text
en: The waiter can be removed from the wait on I<uaddr> without requeueing on I<uaddr2> via a B<FUTEX_WAKE> operation in another task.  In this case, the B<FUTEX_WAIT_REQUEUE_PI> operation fails with the error B<EAGAIN>.
fr: L'élément peut être retiré de la file d'attente sur I<uaddr> sans être transféré sur I<uaddr2> à l’aide d’une opération B<FUTEX_WAKE> dans une autre tâche. Dans ce cas, l'opération B<FUTEX_WAIT_REQUEUE_PI> échoue avec l'erreur B<EAGAIN>.

note: type: Plain text
en: The I<val3> argument is ignored.
fr: L'argument I<val3> est ignoré.

note: Darren Hart notes that a patch to allow glibc to fully support PI-aware pthreads condition variables has not yet been accepted into glibc. The story is complex, and can be found at https://sourceware.org/bugzilla/show_bug.cgi?id=11588 Darren notes that in the meantime, the patch is shipped with vari
en: The B<FUTEX_WAIT_REQUEUE_PI> and B<FUTEX_CMP_REQUEUE_PI> were added to support a fairly specific use case: support for priority-inheritance-aware POSIX threads condition variables.  The idea is that these operations should always be paired, in order to ensure that user space and the kernel remain in sync.  Thus, in the B<FUTEX_WAIT_REQUEUE_PI> operation, the user-space application pre-specifies the target of the requeue that takes place in the B<FUTEX_CMP_REQUEUE_PI> operation.
fr: B<FUTEX_WAIT_REQUEUE_PI> et B<FUTEX_CMP_REQUEUE_PI> ont été ajoutés pour gérer un cas d'utilisation bien particulier : la prise en charge des variables conditionnelles de threads POSIX ayant connaissance de l'héritage de priorité. L'idée est que ces opérations devraient toujours aller par paires, afin de garantir que l'espace utilisateur et le noyau restent toujours synchronisés. Ainsi, dans l'opération B<FUTEX_WAIT_REQUEUE_PI>, l'application dans l'espace utilisateur pré-indique la cible de la remise en attente qui va se faire dans l'opération B<FUTEX_CMP_REQUEUE_PI>.

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

note: type: Plain text
en: In the event of an error (and assuming that B<futex>()  was invoked via B<syscall>(2)), all operations return -1 and set I<errno> to indicate the error.
fr: En cas d'erreur (en supposant que B<futex>() a été appelé à l’aide de B<syscall>(2)), toutes les opérations renvoient B<-1> et positionnent I<errno> pour indiquer l'erreur.

note: type: Plain text
en: The return value on success depends on the operation, as described in the following list:
fr: En cas de succès, le code de retour dépend de l'opération, comme décrit dans la liste suivante :

note: type: Plain text
en: Returns 0 if the caller was woken up.  Note that a wake-up can also be caused by common futex usage patterns in unrelated code that happened to have previously used the futex word's memory location (e.g., typical futex-based implementations of Pthreads mutexes can cause this under some conditions).  Therefore, callers should always conservatively assume that a return value of 0 can mean a spurious wake-up, and use the futex word's value (i.e., the user-space synchronization scheme)  to decide whether to continue to block or not.
fr: Renvoie B<0> si l'appelant a été réveillé. Remarquez qu'un réveil peut également résulter de l'utilisation de motifs d'utilisation classiques de futex dans du code non lié qui a pu utiliser l'emplacement mémoire du mot futex (par exemple des implémentations classiques basées sur futex de mutex Pthreads peuvent provoquer cela dans certaines conditions). Donc, les appelants devraient toujours, à titre conservatoire, supposer qu'un code de retour B<0> peut signifier un faux réveil, et donc utiliser la valeur du mot futex (à savoir le schéma de synchronisation de l'espace utilisateur) pour décider de rester bloqués ou pas.

note: type: Plain text
en: Returns the number of waiters that were woken up.
fr: Renvoie le nombre de processus en attente qui ont été réveillés.

note: type: Plain text
en: Returns the new file descriptor associated with the futex.
fr: Renvoie le nouveau descripteur de fichier associé au futex.

note: type: Plain text
en: Returns the total number of waiters that were woken up or requeued to the futex for the futex word at I<uaddr2>.  If this value is greater than I<val>, then the difference is the number of waiters requeued to the futex for the futex word at I<uaddr2>.
fr: Renvoie le nombre total d'éléments en attente réveillés ou remis dans la file du futex pour le mot futex sur I<uaddr2>. Si cette valeur est supérieure à I<val>, la différence devient le nombre d'éléments en attente remis dans la file du futex pour le mot futex sur I<uaddr2>.

note: type: Plain text
en: Returns the total number of waiters that were woken up.  This is the sum of the woken waiters on the two futexes for the futex words at I<uaddr> and I<uaddr2>.
fr: Renvoie le nombre total d'éléments en attente réveillés. Il s'agit de la somme des éléments réveillés sur les deux futex pour les mots futex sur I<uaddr> et I<uaddr2>.

note: type: Plain text
en: Returns 0 if the caller was woken up.  See B<FUTEX_WAIT> for how to interpret this correctly in practice.
fr: Renvoie B<0> si l'appelant a été réveillé. Voir B<FUTEX_WAIT> sur la manière d'interpréter cela correctement en pratique.

note: type: Plain text
en: Returns 0 if the futex was successfully locked.
fr: Renvoie B<0> si le futex a appliqué le verrou avec succès.

note: type: Plain text
en: Returns 0 if the futex was successfully unlocked.
fr: Renvoie B<0> si le futex a correctement enlevé le verrou.

note: type: Plain text
en: Returns the total number of waiters that were woken up or requeued to the futex for the futex word at I<uaddr2>.  If this value is greater than I<val>, then difference is the number of waiters requeued to the futex for the futex word at I<uaddr2>.
fr: Renvoie le nombre total d'éléments en attente réveillés ou remis dans la file du futex pour le mot futex sur I<uaddr2>. Si cette valeur est supérieure à I<val>, la différence devient le nombre d'éléments en attente remis dans la file du futex pour le mot futex sur I<uaddr2>.

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: Returns 0 if the caller was successfully requeued to the futex for the futex word at I<uaddr2>.
fr: Renvoie B<0> si l'appelant a été mis dans la file d'attente avec succès au futex pour le mot futex sur I<uaddr2>.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: No read access to the memory of a futex word.
fr: Pas d'accès en lecture à la mémoire d'un mot futex.

note: type: Plain text
en: (B<FUTEX_WAIT>, B<FUTEX_WAIT_BITSET>, B<FUTEX_WAIT_REQUEUE_PI>)  The value pointed to by I<uaddr> was not equal to the expected value I<val> at the time of the call.
fr: (B<FUTEX_WAIT>, B<FUTEX_WAIT_BITSET>, B<FUTEX_WAIT_REQUEUE_PI>) La valeur vers laquelle pointait I<uaddr> n'était pas égale à la valeur I<val> attendue au moment de l'appel.

note: type: Plain text
en: B<Note>: on Linux, the symbolic names B<EAGAIN> and B<EWOULDBLOCK> (both of which appear in different parts of the kernel futex code)  have the same value.
fr: B<Remarque> : sur Linux, les noms symboliques B<EAGAIN> et B<EWOULDBLOCK> (les deux apparaissent dans différents endroits du code futex du noyau) ont la même valeur.

note: type: Plain text
en: (B<FUTEX_CMP_REQUEUE>, B<FUTEX_CMP_REQUEUE_PI>)  The value pointed to by I<uaddr> is not equal to the expected value I<val3>.
fr: (B<FUTEX_CMP_REQUEUE>, B<FUTEX_CMP_REQUEUE_PI>) La valeur vers laquelle pointait I<uaddr> n'était pas égale à la valeur I<val3> attendue.

note: type: Plain text
en: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>)  The futex owner thread ID of I<uaddr> (for B<FUTEX_CMP_REQUEUE_PI>: I<uaddr2>)  is about to exit, but has not yet handled the internal state cleanup.  Try again.
fr: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>) L'ID du thread propriétaire du futex sur I<uaddr> (pour B<FUTEX_CMP_REQUEUE_PI> : I<uaddr2>) est sur le point de se terminer, mais il n'a pas encore géré le nettoyage de l'état interne. Réessayez.

note: type: Plain text
en: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>)  The futex word at I<uaddr> is already locked by the caller.
fr: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>) Le mot futex sur I<uaddr> est déjà verrouillé par l'appelant.

note: FIXME . I see that kernel/locking/rtmutex.c uses EDEADLK in some places, and EDEADLOCK in others. On almost all architectures these constants are synonymous. Is there a reason that both names are used? tglx (July 2015): "No. We should probably fix that." type: Plain text
en: (B<FUTEX_CMP_REQUEUE_PI>)  While requeueing a waiter to the PI futex for the futex word at I<uaddr2>, the kernel detected a deadlock.
fr: (B<FUTEX_CMP_REQUEUE_PI>) Pendant qu'il remettait en attente un élément du PI futex pour le mot futex sur I<uaddr2>, le noyau a détecté un verrou mort (deadlock).

note: type: Plain text
en: A required pointer argument (i.e., I<uaddr>, I<uaddr2>, or I<timeout>)  did not point to a valid user-space address.
fr: Le paramètre d'un pointeur nécessaire (c'est-à-dire I<uaddr>, I<uaddr2> ou I<timeout>) ne pointait pas vers une adresse valable de l'espace utilisateur.

note: type: Plain text
en: A B<FUTEX_WAIT> or B<FUTEX_WAIT_BITSET> operation was interrupted by a signal (see B<signal>(7)).  Before Linux 2.6.22, this error could also be returned for a spurious wakeup; since Linux 2.6.22, this no longer happens.
fr: Une opération B<FUTEX_WAIT> ou B<FUTEX_WAIT_BITSET> a été interrompue par un signal (voir B<signal>(7)). Dans Linux 2.6.22, cette erreur pouvait aussi être renvoyée pour un faux réveil ; depuis Linux 2.6.22, cela n'arrive plus.

note: type: Plain text
en: The operation in I<futex_op> is one of those that employs a timeout, but the supplied I<timeout> argument was invalid (I<tv_sec> was less than zero, or I<tv_nsec> was not less than 1,000,000,000).
fr: L'opération dans I<futex_op> fait partie de celles qui utilisent un délai, mais le paramètre I<timeout> fourni n'était pas valable (I<tv_sec> valait moins de B<0> ou I<tv_nsec> ne valait pas moins de 1 000 000 000).

note: type: Plain text
en: The operation specified in I<futex_op> employs one or both of the pointers I<uaddr> and I<uaddr2>, but one of these does not point to a valid object\[em]that is, the address is not four-byte-aligned.
fr: L'opération indiquée dans I<futex_op> utilise I<uaddr> et/ou I<uaddr2> mais l'un d'eux ne pointe pas vers un objet valable — c'est-à-dire, l'adresse n'est pas alignée sur quatre octets.

note: type: Plain text
en: (B<FUTEX_WAIT_BITSET>, B<FUTEX_WAKE_BITSET>)  The bit mask supplied in I<val3> is zero.
fr: (B<FUTEX_WAIT_BITSET>, B<FUTEX_WAKE_BITSET>) Le masque de bit fourni dans I<val3> vaut zéro.

note: type: Plain text
en: (B<FUTEX_CMP_REQUEUE_PI>)  I<uaddr> equals I<uaddr2> (i.e., an attempt was made to requeue to the same futex).
fr: (B<FUTEX_CMP_REQUEUE_PI>)  I<uaddr> est égal à I<uaddr2> (c'est-à-dire qu'une remise en attente a été tentée sur le même futex).

note: type: Plain text
en: (B<FUTEX_FD>)  The signal number supplied in I<val> is invalid.
fr: (B<FUTEX_FD>) Le numéro du signal fourni dans I<val> n'est pas valable.

note: type: Plain text
en: (B<FUTEX_WAKE>, B<FUTEX_WAKE_OP>, B<FUTEX_WAKE_BITSET>, B<FUTEX_REQUEUE>, B<FUTEX_CMP_REQUEUE>)  The kernel detected an inconsistency between the user-space state at I<uaddr> and the kernel state\[em]that is, it detected a waiter which waits in B<FUTEX_LOCK_PI> or B<FUTEX_LOCK_PI2> on I<uaddr>.
fr: (B<FUTEX_WAKE>, B<FUTEX_WAKE_OP>, B<FUTEX_WAKE_BITSET>, B<FUTEX_REQUEUE>, B<FUTEX_CMP_REQUEUE>) Le noyau a détecté une incohérence entre l'état de l'espace utilisateur sur I<uaddr> et l'état du noyau — c'est-à-dire qu'il a détecté un élément qui attend dans B<FUTEX_LOCK_PI> ou B<FUTEX_LOCK_PI2> sur I<uaddr>.

note: type: Plain text
en: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_UNLOCK_PI>)  The kernel detected an inconsistency between the user-space state at I<uaddr> and the kernel state.  This indicates either state corruption or that the kernel found a waiter on I<uaddr> which is waiting via B<FUTEX_WAIT> or B<FUTEX_WAIT_BITSET>.
fr: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_UNLOCK_PI>) Le noyau a détecté une incohérence entre l'état de l'espace utilisateur sur I<uaddr> et l'état du noyau. Cela indique soit une corruption d'état, soit que le noyau a trouvé un élément en attente sur I<uaddr> qui attend aussi à l'aide de B<FUTEX_WAIT> ou de B<FUTEX_WAIT_BITSET>.

note: From a conversation with Thomas Gleixner (Aug 2015): ### The kernel sees: I have non PI state for a futex you tried to tell me was PI type: Plain text
en: (B<FUTEX_CMP_REQUEUE_PI>)  The kernel detected an inconsistency between the user-space state at I<uaddr2> and the kernel state; that is, the kernel detected a waiter which waits via B<FUTEX_WAIT> or B<FUTEX_WAIT_BITSET> on I<uaddr2>.
fr: (B<FUTEX_CMP_REQUEUE_PI>) Le noyau a détecté une incohérence entre l'état de l'espace utilisateur sur I<uaddr> et l'état du noyau ; c'est-à-dire qu'il a détecté un élément qui attend via B<FUTEX_WAIT> ou B<FUTEX_WAIT_BITSET> sur I<uaddr2>.

note: type: Plain text
en: (B<FUTEX_CMP_REQUEUE_PI>)  The kernel detected an inconsistency between the user-space state at I<uaddr> and the kernel state; that is, the kernel detected a waiter which waits via B<FUTEX_WAIT> or B<FUTEX_WAIT_BITSET> on I<uaddr>.
fr: (B<FUTEX_CMP_REQUEUE_PI>) Le noyau a détecté une incohérence entre l'état de l'espace utilisateur sur I<uaddr> et l'état du noyau ; c'est-à-dire qu'il a détecté un élément qui attend à l'aide de B<FUTEX_WAIT> ou de B<FUTEX_WAIT_BITESET> sur I<uaddr>.

note: type: Plain text
en: (B<FUTEX_CMP_REQUEUE_PI>)  The kernel detected an inconsistency between the user-space state at I<uaddr> and the kernel state; that is, the kernel detected a waiter which waits on I<uaddr> via B<FUTEX_LOCK_PI> or B<FUTEX_LOCK_PI2> (instead of B<FUTEX_WAIT_REQUEUE_PI>).
fr: (B<FUTEX_CMP_REQUEUE_PI>) Le noyau a détecté une incohérence entre l'état de l'espace utilisateur sur I<uaddr> et l'état du noyau ; c'est-à-dire qu'il a détecté un élément qui attend à l'aide de B<FUTEX_LOCK_PI> ou de B<FUTEX_LOCK_PI2> (au lieu de B<FUTEX_WAIT_REQUEUE_PI>).

note: This deals with the case: wait_requeue_pi(A, B); requeue_pi(A, C); type: Plain text
en: (B<FUTEX_CMP_REQUEUE_PI>)  An attempt was made to requeue a waiter to a futex other than that specified by the matching B<FUTEX_WAIT_REQUEUE_PI> call for that waiter.
fr: (B<FUTEX_CMP_REQUEUE_PI>) Tentative de remise dans la file d'un élément en attente vers un futex différent de celui indiqué avec l'appel B<FUTEX_WAIT_REQUEUE_PI> correspondant pour cet élément.

note: type: Plain text
en: (B<FUTEX_CMP_REQUEUE_PI>)  The I<val> argument is not 1.
fr: (B<FUTEX_CMP_REQUEUE_PI>) Le paramètre I<val> ne vaut pas B<1>.

note: type: Plain text
en: Invalid argument.
fr: Argument incorrect.

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

note: type: Plain text
en: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>)  The kernel could not allocate memory to hold state information.
fr: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>) Le noyau n'a pas pu allouer de la mémoire pour conserver les informations d'état.

note: type: Plain text
en: Invalid operation specified in I<futex_op>.
fr: Opération non valable indiquée dans I<futex_op>.

note: type: Plain text
en: The B<FUTEX_CLOCK_REALTIME> option was specified in I<futex_op>, but the accompanying operation was neither B<FUTEX_WAIT>, B<FUTEX_WAIT_BITSET>, B<FUTEX_WAIT_REQUEUE_PI>, nor B<FUTEX_LOCK_PI2>.
fr: L'option B<FUTEX_CLOCK_REALTIME> était indiquée dans I<futex_op>, mais l'opération qui l'accompagne n'est ni B<FUTEX_WAIT>, ni B<FUTEX_WAIT_BITSET>, ni B<FUTEX_WAIT_REQUEUE_PI>, ni B<FUTEX_LOCK_PI2>.

note: type: Plain text
en: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_UNLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>, B<FUTEX_WAIT_REQUEUE_PI>)  A run-time check determined that the operation is not available.  The PI-futex operations are not implemented on all architectures and are not supported on some CPU variants.
fr: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_UNLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>, B<FUTEX_WAIT_REQUEUE_PI>) Une vérification pendant l'exécution a déterminé que l'opération n'est pas disponible. Les opérations PI-futex ne sont pas implémentées sur toutes les architectures et ne sont pas prises en charge sur certaines variantes de processeur.

note: type: Plain text
en: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>)  The caller is not allowed to attach itself to the futex at I<uaddr> (for B<FUTEX_CMP_REQUEUE_PI>: the futex at I<uaddr2>).  (This may be caused by a state corruption in user space.)
fr: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>) L'appelant n'est pas autorisé à se rattacher au futex sur I<uaddr> (pour B<FUTEX_CMP_REQUEUE_PI> : le futex sur I<uaddr2>) (cela peut venir d'une corruption de l'état dans l'espace utilisateur).

note: type: Plain text
en: (B<FUTEX_UNLOCK_PI>)  The caller does not own the lock represented by the futex word.
fr: (B<FUTEX_UNLOCK_PI>) Le verrou représenté par le mot futex n'appartient pas à l'appelant.

note: type: Plain text
en: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>)  The thread ID in the futex word at I<uaddr> does not exist.
fr: (B<FUTEX_LOCK_PI>, B<FUTEX_LOCK_PI2>, B<FUTEX_TRYLOCK_PI>, B<FUTEX_CMP_REQUEUE_PI>) L'ID du thread dans le mot futex sur I<uaddr> n'existe pas.

note: type: Plain text
en: (B<FUTEX_CMP_REQUEUE_PI>)  The thread ID in the futex word at I<uaddr2> does not exist.
fr: (B<FUTEX_CMP_REQUEUE_PI>) L'ID du thread dans le mot futex sur I<uaddr2> n'existe pas.

note: """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: The operation in I<futex_op> employed the timeout specified in I<timeout>, and the timeout expired before the operation completed.
fr: L'opération de I<futex_op> a utilisé un délai indiqué dans I<timeout> et le délai a expiré avant la fin de l'opération.

note: type: SH
en: HISTORY
fr: HISTORIQUE

note: type: Plain text
en: Initial futex support was merged in Linux 2.5.7 but with different semantics from what was described above.  A four-argument system call with the semantics described in this page was introduced in Linux 2.5.40.  A fifth argument was added in Linux 2.5.70, and a sixth argument was added in Linux 2.6.7.
fr: La prise en charge initiale des futex a été ajoutée dans Linux 2.5.7 mais avec une sémantique différente de celle décrite ci\(hydessus. Un appel système à 4 paramètres avec la sémantique décrite dans cette page a été ajouté dans Linux 2.5.40. Dans Linux 2.5.70, un cinquième paramètre a été ajouté. Un sixième paramètre a été ajouté dans Linux 2.6.7.

note: type: SH
en: EXAMPLES
fr: EXEMPLES

note: type: Plain text
en: The program below demonstrates use of futexes in a program where a parent process and a child process use a pair of futexes located inside a shared anonymous mapping to synchronize access to a shared resource: the terminal.  The two processes each write I<nloops> (a command-line argument that defaults to 5 if omitted)  messages to the terminal and employ a synchronization protocol that ensures that they alternate in writing messages.  Upon running this program we see output such as the following:
fr: Le programme ci-dessous montre l'utilisation des futex dans un programme où un processus parent et un processus enfant utilisent une paire de futex située dans un tableau anonyme partagé pour synchroniser l'accès à une ressource partagée : le terminal. Les deux processus écrivent chacun un message I<nloops> (un paramètre en ligne de commande qui vaut 5 par défaut s'il est absent) sur le terminal et ils utilisent un protocole de synchronisation pour garantir qu'ils alternent dans l'écriture des messages. Pendant l'exécution de ce programme, nous voyons un affichage comme suit :

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

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

note: type: Plain text
en: The following kernel source files:
fr: Les fichiers suivants des sources du noyau :

note: type: Plain text
en: Franke, H., Russell, R., and Kirwood, M., 2002.  I<Fuss, Futexes and Furwocks: Fast Userlevel Locking in Linux> (from proceedings of the Ottawa Linux Symposium 2002),
fr: Franke, H., Russell, R., and Kirwood, M., 2002.  I<Fuss, Futexes and Furwocks: Fast Userlevel Locking in Linux> (à partir des actions d'Ottawa Linux Symposium 2002),

note: type: Plain text
en: Hart, D.\& and Guniguntala, D., 2009.  I<Requeue-PI: Making glibc Condvars PI-Aware> (from proceedings of the 2009 Real-Time Linux Workshop), E<.UR http://lwn.net/images/conf/rtlws11/papers/proc/p10.pdf> E<.UE>
fr: Hart, D. et Guniguntala, D., 2009.  I<Requeue-PI: Making Glibc Condvars PI-Aware> (à partir des comptes rendus de l'atelier Real-Time Linux 2009), E<.UR http://lwn.net/images/conf/rtlws11/papers/proc/p10.pdf> E<.UE>

note: type: Plain text
en: Futex example library, futex-*.tar.bz2 at
fr: La bibliothèque d'exemples de futex, futex-*.tar.bz2 à

note: type: TH
en: 2023-02-05
fr: 5 février 2023

note: type: TH
en: Linux man-pages 6.03
fr: Pages du manuel de Linux 6.03

note: type: Plain text
en: Futexes were first made available in a stable kernel release with Linux 2.6.0.
fr: Les futex ont d'abord été disponibles dans une version stable du noyau avec Linux 2.6.0.

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

note: TODO FIXME(Torvald) Above, we cite this section and claim it contains details on the synchronization semantics; add the C11 equivalents here (or whatever we find consensus for). """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: Several higher-level programming abstractions are implemented via futexes, including POSIX semaphores and various POSIX threads synchronization mechanisms (mutexes, condition variables, read-write locks, and barriers).
fr: Plusieurs abstractions programmatiques de haut niveau sont implémentées avec des futex, notamment les mécanismes POSIX de sémaphore et de synchronisation de threads (mutex, variables conditionnelles, verrous en lecture/écriture et barrières).

note: type: Plain text
en:    Usage: futex_demo [nloops]
                        (Default: 5)
fr:    Utilisation: futex_demo [nloops]
                        (Par défaut : 5)

note: type: Plain text
en:    Demonstrate the use of futexes in a program where parent and child
       use a pair of futexes located inside a shared anonymous mapping to
       synchronize access to a shared resource: the terminal. The two
       processes each write \[aq]num-loops\[aq] messages to the terminal and employ
       a synchronization protocol that ensures that they alternate in
       writing messages.
    */
    #define _GNU_SOURCE
    #include E<lt>err.hE<gt>
    #include E<lt>errno.hE<gt>
    #include E<lt>linux/futex.hE<gt>
    #include E<lt>stdatomic.hE<gt>
    #include E<lt>stdint.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>sys/mman.hE<gt>
    #include E<lt>sys/syscall.hE<gt>
    #include E<lt>sys/time.hE<gt>
    #include E<lt>sys/wait.hE<gt>
    #include E<lt>unistd.hE<gt>
fr:    Montrer l'utilisation des futex dans un programme où le parent et
       l'enfant utilisent une paire de futex située dans un tableau anonyme
       partagé pour synchroniser l'accès à une ressource partagée : le
       terminal. Les processus écrivent chacun des messages \[aq]num-loops\[aq]
       sur le terminal et ils utilisent un protocole de synchronisation qui
       garantit qu'ils alternent l'écriture des messages.
    */
    #define _GNU_SOURCE
    #include E<lt>err.hE<gt>
    #include E<lt>errno.hE<gt>
    #include E<lt>linux/futex.hE<gt>
    #include E<lt>stdatomic.hE<gt>
    #include E<lt>stdint.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>sys/mman.hE<gt>
    #include E<lt>sys/syscall.hE<gt>
    #include E<lt>sys/time.hE<gt>
    #include E<lt>sys/wait.hE<gt>
    #include E<lt>unistd.hE<gt>

note: type: Plain text
en: /* Acquire the futex pointed to by \[aq]futexp\[aq]: wait for its value to
       become 1, and then set the value to 0. */
fr: /* Acquérir le futex vers lequel pointe \[aq]futexp\[aq] : attendre que sa
       valeur passe à 1 puis positionner la valeur sur 0. */

note: type: Plain text
en:     /* atomic_compare_exchange_strong(ptr, oldval, newval)
           atomically performs the equivalent of:
fr:     /* atomic_compare_exchange_strong(ptr, oldval, newval)
           fait atomiquement comme :

note: type: Plain text
en:        It returns true if the test yielded true and *ptr was updated. */
fr:        Il renvoie true si le test a montré true et *ptr a été mis à jour. */

note: type: Plain text
en:         /* Is the futex available? */
            if (atomic_compare_exchange_strong(futexp, &one, 0))
                break;      /* Yes */
fr:         /* Le futex est-il disponible ? */
            if (atomic_compare_exchange_strong(futexp, &one, 0))
                break;      /* Oui */

note: type: Plain text
en:         /* Futex is not available; wait. */
fr:         /* Le futex n'est pas disponible ; attendre */

note: type: Plain text
en: /* Release the futex pointed to by \[aq]futexp\[aq]: if the futex currently
       has the value 0, set its value to 1 and then wake any futex waiters,
       so that if the peer is blocked in fwait(), it can proceed. */
fr: /* Relâcher le futex vers lequel pointe \[aq]futexp\[aq] : si le futex a
      actuellement la valeur 0, positionner la valeur à 1 et réveiller tous les
      futex en attente pour que si le pair est bloqué dans fwait(), ça puisse
      continuer. */

note: type: Plain text
en:     /* atomic_compare_exchange_strong() was described
           in comments above. */
fr:     /* atomic_compare_exchange_strong() a été décrit
           dans les commentaires ci-dessus. */

note: type: Plain text
en:     /* Create a shared anonymous mapping that will hold the futexes.
           Since the futexes are being shared between processes, we
           subsequently use the "shared" futex operations (i.e., not the
           ones suffixed "_PRIVATE"). */
fr:     /* Créer un tableau anonyme partagé qui gardera les futex.
           Comme les futex vont être partagés entre les processus, nous
            utilisons donc les opérations futex « shared » (donc pas celles
            dont le suffixe est "_PRIVATE") */

note: type: Plain text
en:     *futex1 = 0;        /* State: unavailable */
        *futex2 = 1;        /* State: available */
fr:     *futex1 = 0;        /* État : indisponible */
        *futex2 = 1;        /* État : disponible */

note: type: Plain text
en:     /* Create a child process that inherits the shared anonymous
           mapping. */
fr:     /* Créer un processus enfant qui hérite du tableau anonyme
           partagé. */

note: type: Plain text
en:     if (childPid == 0) {        /* Child */
            for (unsigned int j = 0; j E<lt> nloops; j++) {
                fwait(futex1);
                printf("Child  (%jd) %u\en", (intmax_t) getpid(), j);
                fpost(futex2);
            }
fr:     if (childPid == 0) {        /* Child */
            for (unsigned int j = 0; j E<lt> nloops; j++) {
                fwait(futex1);
                printf("Enfant (%jd) %d\en", (intmax_t) getpid(), j);
                fpost(futex2);
            }

note: type: Plain text
en:     /* Parent falls through to here. */
fr:     /* Le parent se retrouve ici. */

note: type: Plain text
en:     for (unsigned int j = 0; j E<lt> nloops; j++) {
            fwait(futex2);
            printf("Parent (%jd) %u\en", (intmax_t) getpid(), j);
            fpost(futex1);
        }
fr:     for (unsigned int j = 0; j E<lt> nloops; j++) {
            fwait(futex2);
            printf("Parent (%jd) %d\en", (intmax_t) getpid(), j);
            fpost(futex1);
        }

note: type: TH
en: Linux man-pages 6.05
fr: Pages du manuel de Linux 6.05

note: type: TH
en: 2023-03-30
fr: 30 mars 2023

note: type: TH
en: Linux man-pages 6.04
fr: Pages du manuel de Linux 6.04
