perkamon - en to fr translation catalogue (247 entries)

note: type: TH
en: 2012-05-13
fr: 13 mai 2012

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

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: sem_close - close a named semaphore
fr: sem_close - Fermer un sémaphore nommé

note: type: Plain text
en: Link with I<-pthread>.
fr: Effectuez l'édition des liens avec l'option I<-pthread>.

note: type: Plain text
en: B<sem_close>()  closes the named semaphore referred to by I<sem>, allowing any resources that the system has allocated to the calling process for this semaphore to be freed.
fr: B<sem_close>() ferme le sémaphore nommé référencé par I<sem>, permettant à toutes les ressources que le système a alloué au processus appelant pour ce sémaphore d'être libérées.

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

note: type: Plain text
en: On success B<sem_close>()  returns 0; on error, -1 is returned, with I<errno> set to indicate the error.
fr: S'il réussit, B<sem_close>() renvoie 0. S'il échoue, il renvoie -1 et écrit I<errno> en conséquence.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: I<sem> is not a valid semaphore.
fr: I<sem> n'est pas un sémaphore valide.

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

note: type: Plain text
en: All open named semaphores are automatically closed on process termination, or upon B<execve>(2).
fr: Tous les sémaphores nommés ouverts sont automatiquement fermés à la fin du processus ou dans le cas d'un B<execve>(2).

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

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

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

note: type: Plain text
en: sem_destroy - destroy an unnamed semaphore
fr: sem_destroy - Détruire un sémaphore non nommé

note: type: Plain text
en: B<sem_destroy>()  destroys the unnamed semaphore at the address pointed to by I<sem>.
fr: B<sem_destroy>() détruit le sémaphore non nommé situé à l'adresse pointée par I<sem>.

note: type: Plain text
en: Only a semaphore that has been initialized by B<sem_init>(3)  should be destroyed using B<sem_destroy>().
fr: Seul un sémaphore initialisé avec B<sem_init>(3) peut être détruit avec B<sem_destroy>().

note: type: Plain text
en: Destroying a semaphore that other processes or threads are currently blocked on (in B<sem_wait>(3))  produces undefined behavior.
fr: La destruction d'un sémaphore sur lequel des processus ou threads sont bloqués (dans B<sem_wait>(3)) produira un comportement indéfini.

note: type: Plain text
en: Using a semaphore that has been destroyed produces undefined results, until the semaphore has been reinitialized using B<sem_init>(3).
fr: L'utilisation d'un sémaphore détruit produira des résultats indéfinis jusqu'à ce que le sémaphore soit réinitialisé avec B<sem_init>(3).

note: type: Plain text
en: B<sem_destroy>()  returns 0 on success; on error, -1 is returned, and I<errno> is set to indicate the error.
fr: B<sem_destroy>() renvoie 0 s'il réussit. S'il échoue, il renvoie -1 et écrit I<errno> en conséquence.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

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

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

note: But not on NPTL, where sem_destroy () is a no-op.. type: Plain text
en: An unnamed semaphore should be destroyed with B<sem_destroy>()  before the memory in which it is located is deallocated.  Failure to do this can result in resource leaks on some implementations.
fr: Un sémaphore non nommé devrait être détruit avec B<sem_destroy>() avant que la mémoire dans laquelle il est situé ne soit libérée. Ne pas le faire peut provoquer des fuites de ressource sur certaines implémentations.

note: type: Plain text
en: sem_getvalue - get the value of a semaphore
fr: sem_getvalue - Obtenir la valeur d'un sémaphore

note: type: Plain text
en: B<sem_getvalue>()  places the current value of the semaphore pointed to I<sem> into the integer pointed to by I<sval>.
fr: B<sem_getvalue>() place la valeur actuelle du sémaphore pointé par I<sem> dans l'entier pointé par I<sval>.

note: type: Plain text
en: If one or more processes or threads are blocked waiting to lock the semaphore with B<sem_wait>(3), POSIX.1-2001 permits two possibilities for the value returned in I<sval>: either 0 is returned; or a negative number whose absolute value is the count of the number of processes and threads currently blocked in B<sem_wait>(3).  Linux adopts the former behavior.
fr: Si un ou plusieurs processus ou threads sont bloqués en attente de verrouiller le sémaphore avec B<sem_wait>(3), POSIX.1-2001 permet deux valeurs de retour possibles pour I<sval>\ : soit 0 est renvoyé, soit une valeur négative dont la valeur absolue est le nombre de processus et de threads actuellement bloqués dans B<sem_wait>(3). Linux adopte le premier comportement.

note: type: Plain text
en: B<sem_getvalue>()  returns 0 on success; on error, -1 is returned and I<errno> is set to indicate the error.
fr: B<sem_getvalue>() renvoie 0 s'il réussit. S'il échoue, il renvoie -1 et écrit I<errno> en conséquence.

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

note: type: Plain text
en: The value of the semaphore may already have changed by the time B<sem_getvalue>()  returns.
fr: La valeur du sémaphore peut déjà être modifiée le temps que B<sem_getvalue>() revienne.

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

note: type: Plain text
en: sem_init - initialize an unnamed semaphore
fr: sem_init - Initialiser un sémaphore non nommé

note: type: Plain text
en: B<sem_init>()  initializes the unnamed semaphore at the address pointed to by I<sem>.  The I<value> argument specifies the initial value for the semaphore.
fr: B<sem_init>() initialise le sémaphore non nommé situé à l'adresse pointée par I<sem>. L'argument I<value> spécifie la valeur initiale du sémaphore.

note: type: Plain text
en: The I<pshared> argument indicates whether this semaphore is to be shared between the threads of a process, or between processes.
fr: L'argument I<pshared> indique si ce sémaphore sera partagé entre les threads d'un processus ou entre processus.

note: type: Plain text
en: If I<pshared> has the value 0, then the semaphore is shared between the threads of a process, and should be located at some address that is visible to all threads (e.g., a global variable, or a variable allocated dynamically on the heap).
fr: Si I<pshared> vaut 0, le sémaphore est partagé entre les threads d'un processus et devrait être situé à une adresse visible par tous les threads (par exemple, une variable globale ou une variable allouée dynamiquement dans le tas).

note: type: Plain text
en: If I<pshared> is nonzero, then the semaphore is shared between processes, and should be located in a region of shared memory (see B<shm_open>(3), B<mmap>(2), and B<shmget>(2)).  (Since a child created by B<fork>(2)  inherits its parent's memory mappings, it can also access the semaphore.)  Any process that can access the shared memory region can operate on the semaphore using B<sem_post>(3), B<sem_wait>(3), and so on.
fr: Si I<pshared> n'est pas nul, le sémaphore est partagé entre processus et devrait être situé dans une région de mémoire partagée (consultez B<shm_open>(3), B<mmap>(2) et B<shmget>(2)) (puisqu'un fils créé avec B<fork>(2) hérite de la projection mémoire du père, il peut accéder au sémaphore). Tout processus qui peut accéder à la région de mémoire partagée peut opérer sur le sémaphore avec B<sem_post>(3), B<sem_wait>(3), etc.

note: type: Plain text
en: Initializing a semaphore that has already been initialized results in undefined behavior.
fr: L'initialisation d'un sémaphore qui a déjà été initialisé résulte en un comportement indéfini.

note: type: Plain text
en: B<sem_init>()  returns 0 on success; on error, -1 is returned, and I<errno> is set to indicate the error.
fr: B<sem_init>() renvoie 0 s'il réussit. S'il échoue, il renvoie -1 et écrit I<errno> en conséquence.

note: type: Plain text
en: I<value> exceeds B<SEM_VALUE_MAX>.
fr: I<value> est plus grand que B<SEM_VALUE_MAX>.

note: type: Plain text
en: I<pshared> is nonzero, but the system does not support process-shared semaphores (see B<sem_overview>(7)).
fr: I<pshared> n'est pas nul, mais le système ne supporte pas les sémaphores partagés entre processus (consultez B<sem_overview>(7)).

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

note: type: Plain text
en: Bizarrely, POSIX.1-2001 does not specify the value that should be returned by a successful call to B<sem_init>().  POSIX.1-2008 rectifies this, specifying the zero return on success.
fr: Bizarrement, POSIX.1-2001 ne spécifie pas la valeur que devrait retourner un appel réussi à B<sem_init>(). POSIX.1-2008 corrige ceci et spécifie une valeur de retour nulle en cas de succès.

note: type: Plain text
en: sem_open - initialize and open a named semaphore
fr: sem_open - Initialiser et ouvrir un sémaphore nommé

note: type: Plain text
en: B<#include E<lt>fcntl.hE<gt>>           /* For O_* constants */
    B<#include E<lt>sys/stat.hE<gt>>        /* For mode constants */
    B<#include E<lt>semaphore.hE<gt>>
fr: B<#include E<lt>fcntl.hE<gt>>           /* Pour les constantes O_* */
    B<#include E<lt>sys/stat.hE<gt>>        /* Pour les constantes des modes */
    B<#include E<lt>semaphore.hE<gt>>

note: type: Plain text
en: B<sem_open>()  creates a new POSIX semaphore or opens an existing semaphore.  The semaphore is identified by I<name>.  For details of the construction of I<name>, see B<sem_overview>(7).
fr: B<sem_open>() crée un nouveau sémaphore POSIX ou en ouvre un existant. Le sémaphore est identifié par I<name>. Pour les détails de la construction de I<name>, consultez B<sem_overview>(7).

note: In reality the filesystem IDs are used on Linux. type: Plain text
en: The I<oflag> argument specifies flags that control the operation of the call.  (Definitions of the flags values can be obtained by including I<E<lt>fcntl.hE<gt>>.)  If B<O_CREAT> is specified in I<oflag>, then the semaphore is created if it does not already exist.  The owner (user ID) of the semaphore is set to the effective user ID of the calling process.  The group ownership (group ID) is set to the effective group ID of the calling process.  If both B<O_CREAT> and B<O_EXCL> are specified in I<oflag>, then an error is returned if a semaphore with the given I<name> already exists.
fr: L'argument I<oflag> spécifie les attributs qui contrôlent la manière d'opérer de l'appel (les définitions des valeurs des attributs peuvent être obtenues en incluant I<E<lt>fcntl.hE<gt>>). Si B<O_CREAT> est spécifié dans I<oflag>, le sémaphore est créé s'il n'existe pas déjà. Le propriétaire (UID) du sémaphore est l'UID effectif du processus appelant. Le groupe propriétaire (GID) est le GID effectif du processus appelant. Si B<O_CREAT> et B<O_EXCL> sont tous les deux spécifiés dans I<oflag>, une erreur sera renvoyée si le sémaphore du nom de I<name> existe déjà.

note: type: Plain text
en: If B<O_CREAT> is specified in I<oflag>, then two additional arguments must be supplied.  The I<mode> argument specifies the permissions to be placed on the new semaphore, as for B<open>(2).  (Symbolic definitions for the permissions bits can be obtained by including I<E<lt>sys/stat.hE<gt>>.)  The permissions settings are masked against the process umask.  Both read and write permission should be granted to each class of user that will access the semaphore.  The I<value> argument specifies the initial value for the new semaphore.  If B<O_CREAT> is specified, and a semaphore with the given I<name> already exists, then I<mode> and I<value> are ignored.
fr: Si B<O_CREAT> est spécifié dans I<oflag>, deux autres arguments doivent être fournis. L'argument I<mode> spécifie les permissions à placer sur le nouveau sémaphore, comme pour B<open>(2) (les définitions symboliques des bits de permissions peuvent être obtenues en incluant I<E<lt>sys/stat.hE<gt>>). Ces permissions sont «\ masquées\ » avec le umask du processus. Les permissions de lecture et d'écriture devraient être accordées à chaque classe d'utilisateurs qui aura accès au sémaphore. L'argument I<value> spécifie la valeur initiale du nouveau sémaphore. Si B<O_CREAT> est spécifié et que le sémaphore du nom de I<name> existe déjà, I<mode> et I<value> sont ignorés.

note: type: Plain text
en: On success, B<sem_open>()  returns the address of the new semaphore; this address is used when calling other semaphore-related functions.  On error, B<sem_open>()  returns B<SEM_FAILED>, with I<errno> set to indicate the error.
fr: S'il réussit, B<sem_open>() renvoie l'adresse du nouveau sémaphore\ ; cette adresse est utilisée lors de l'appel des autres fonctions sur les sémaphores. S'il échoue, B<sem_open>() renvoie B<SEM_FAILED> et écrit I<errno> en conséquence.

note: type: Plain text
en: The semaphore exists, but the caller does not have permission to open it.
fr: Le sémaphore existe mais l'appelant n'a pas la permission de l'ouvrir.

note: type: Plain text
en: Both B<O_CREAT> and B<O_EXCL> were specified in I<oflag>, but a semaphore with this I<name> already exists.
fr: B<O_CREAT> et B<O_EXCL> ont été tous les deux spécifiés dans I<oflag>, mais un sémaphore avec le nom de I<name> existe déjà.

note: type: Plain text
en: I<value> was greater than B<SEM_VALUE_MAX>.
fr: I<value> était plus grand que B<SEM_VALUE_MAX>.

note: type: Plain text
en: I<name> consists of just "/", followed by no other characters.
fr: I<name> consiste en une barre oblique « / », suivie d'aucun autre caractère.

note: type: Plain text
en: The process already has the maximum number of files and open.
fr: Le processus a déjà le nombre maximal de fichiers ouverts.

note: type: Plain text
en: I<name> was too long.
fr: I<name> est trop long.

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

note: this error can occur if we have a name of the (nonportable) form /dir/name, and the directory /dev/shm/dir does not exist. type: Plain text
en: The B<O_CREAT> flag was not specified in I<oflag> and no semaphore with this I<name> exists; or, B<O_CREAT> was specified, but I<name> wasn't well formed.
fr: L'attribut B<O_CREAT> n'était pas spécifié dans I<oflag>, et aucun sémaphore avec le nom de I<name> n'existe ; ou B<O_CREAT> était spécifié, mais I<name> n'était pas correctement formé.

note: type: Plain text
en: Insufficient memory.
fr: Mémoire insuffisante.

note: type: Plain text
en: sem_overview - overview of POSIX semaphores
fr: sem_overview - Panorama des sémaphores POSIX

note: type: Plain text
en: POSIX semaphores allow processes and threads to synchronize their actions.
fr: Les sémaphores POSIX permettent aux processus et aux threads de se synchroniser.

note: type: Plain text
en: A semaphore is an integer whose value is never allowed to fall below zero.  Two operations can be performed on semaphores: increment the semaphore value by one (B<sem_post>(3)); and decrement the semaphore value by one (B<sem_wait>(3)).  If the value of a semaphore is currently zero, then a B<sem_wait>(3)  operation will block until the value becomes greater than zero.
fr: Un sémaphore est un entier dont la valeur ne peut jamais être négative. Deux opérations peuvent être effectuées\ : incrémenter la valeur du sémaphore de 1 (B<sem_post>(3)), ou décrémenter la valeur du sémaphore de 1 (B<sem_wait>(3)). Si la valeur courante est 0, une opération B<sem_wait>(3) bloque jusqu'à ce que la valeur devienne strictement positive.

note: type: Plain text
en: POSIX semaphores come in two forms: named semaphores and unnamed semaphores.
fr: Les sémaphores POSIX sont de deux types\ : les sémaphores nommés et les sémaphores anonymes.

note: type: TP
en: B<Named semaphores>
fr: B<Sémaphores nommés>

note: glibc allows the initial slash to be omitted, and makes multiple initial slashes equivalent to a single slash. This differs from the implementation of POSIX message queues. glibc allows subdirectory components in the name, in which case the subdirectory tree must exist under /dev/shm, and the fist s
en: A named semaphore is identified by a name of the form I</somename>; that is, a null-terminated string of up to B<NAME_MAX>I<-4> (i.e., 251) characters consisting of an initial slash, followed by one or more characters, none of which are slashes.  Two processes can operate on the same named semaphore by passing the same name to B<sem_open>(3).
fr: Un sémaphore nommé est identifié par un nom de la forme I</un_nom> ; c'est-à-dire un chaîne terminée par un caractère nul pouvant avoir jusqu'à B<NAME_MAX>I<-4> (251) caractères, commençant par une barre oblique (« / ») suivie d'un caractère ou plus, aucun de ces derniers n'étant une barre oblique. Deux processus peuvent utiliser un même sémaphore nommé en passant le même nom à B<sem_open>(3).

note: type: Plain text
en: The B<sem_open>(3)  function creates a new named semaphore or opens an existing named semaphore.  After the semaphore has been opened, it can be operated on using B<sem_post>(3)  and B<sem_wait>(3).  When a process has finished using the semaphore, it can use B<sem_close>(3)  to close the semaphore.  When all processes have finished using the semaphore, it can be removed from the system using B<sem_unlink>(3).
fr: La fonction B<sem_open>(3) crée un nouveau sémaphore nommé ou en ouvre un existant. Après l'ouverture de ce sémaphore, il peut être utilisé avec B<sem_post>(3) et B<sem_wait>(3). Lorsqu'un processus a fini d'utiliser le sémaphore, il peut utiliser B<sem_close>(3) pour le fermer. Lorsque tous les processus ont terminé de l'utiliser, il peut être supprimé du système avec B<sem_unlink>(3).

note: type: TP
en: B<Unnamed semaphores (memory-based semaphores)>
fr: B<Sémaphores anonymes (sémaphores en mémoire)>

note: type: Plain text
en: An unnamed semaphore does not have a name.  Instead the semaphore is placed in a region of memory that is shared between multiple threads (a I<thread-shared semaphore>)  or processes (a I<process-shared semaphore>).  A thread-shared semaphore is placed in an area of memory shared between the threads of a process, for example, a global variable.  A process-shared semaphore must be placed in a shared memory region (e.g., a System V shared memory segment created using B<shmget>(2), or a POSIX shared memory object built created using B<shm_open>(3)).
fr: Un sémaphore anonyme n'a pas de nom. Il est placé dans une région de la mémoire qui est partagée entre plusieurs threads (I<sémaphore partagé par des threads>) ou processus (I<sémaphore partagé par des processus>). Un sémaphore partagé par des threads est placé dans une région de la mémoire partagée entre les threads d'un processus, par exemple une variable globale. Un sémaphore partagé par des processus doit être placé dans une région de mémoire partagée (par exemple un segment de mémoire partagée System V créé avec B<shmget>(2), ou un objet de mémoire partagée POSIX créé avec B<shm_open>(3)).

note: type: Plain text
en: Before being used, an unnamed semaphore must be initialized using B<sem_init>(3).  It can then be operated on using B<sem_post>(3)  and B<sem_wait>(3).  When the semaphore is no longer required, and before the memory in which it is located is deallocated, the semaphore should be destroyed using B<sem_destroy>(3).
fr: Avant son utilisation, un sémaphore anonyme doit être initialisé avec B<sem_init>(3). Il peut ensuite être utilisé avec B<sem_post>(3) et B<sem_wait>(3). Lorsque le sémaphore n'est plus nécessaire, et avant que la mémoire où il est placé ne soit libérée, le sémaphore doit être détruit avec B<sem_destroy>(3).

note: type: Plain text
en: The remainder of this section describes some specific details of the Linux implementation of POSIX semaphores.
fr: Le reste de cette section décrit certains détails spécifiques à l'implémentation Linux des sémaphores POSIX.

note: type: Plain text
en: Prior to kernel 2.6, Linux supported only unnamed, thread-shared semaphores.  On a system with Linux 2.6 and a glibc that provides the NPTL threading implementation, a complete implementation of POSIX semaphores is provided.
fr: Avant le noyau 2.6, Linux ne proposait que les sémaphores anonymes partagés par des threads. Sur un système Linux 2.6 avec une glibc fournissant l'implémentation des threads NPTL, une implémentation complète des sémaphores POSIX est fournie.

note: type: SS
en: Persistence
fr: Persistance

note: type: Plain text
en: POSIX named semaphores have kernel persistence: if not removed by B<sem_unlink>(3), a semaphore will exist until the system is shut down.
fr: Les sémaphores POSIX nommés sont persistants dans le noyau\ : s'il n'est pas supprimé avec B<sem_unlink>(3) un sémaphore existe tant que le système n'est pas éteint.

note: type: SS
en: Linking
fr: Édition des liens

note: type: Plain text
en: Programs using the POSIX semaphores API must be compiled with I<cc -pthread> to link against the real-time library, I<librt>.
fr: Les programmes utilisant l'API des sémaphores POSIX doit être compilé avec I<cc -pthread> pour être lié avec la bibliothèque temps\(hyréel, I<librt>.

note: type: SS
en: Accessing named semaphores via the filesystem
fr: Accéder aux sémaphores nommés par le système de fichiers

note: type: Plain text
en: On Linux, named semaphores are created in a virtual filesystem, normally mounted under I</dev/shm>, with names of the form B<sem.>I<somename>.  (This is the reason that semaphore names are limited to B<NAME_MAX>I<-4> rather than B<NAME_MAX> characters.)
fr: Sous Linux, les sémaphores nommés sont créés sur un système de fichiers virtuel, en général monté sur I</dev/shm>, avec des noms de la forme B<sem.>I<un_nom> (ce qui explique que les noms des sémaphores soient limités à B<NAME_MAX>I<-4> plutôt qu'à B<NAME_MAX> caractères).

note: type: Plain text
en: Since Linux 2.6.19, ACLs can be placed on files under this directory, to control object permissions on a per-user and per-group basis.
fr: Depuis Linux 2.6.19, il est possible de placer des listes de contrôle d'accès sur les fichiers de ce répertoire au niveau groupe et utilisateur.

note: type: Plain text
en: System V semaphores (B<semget>(2), B<semop>(2), etc.) are an older semaphore API.  POSIX semaphores provide a simpler, and better designed interface than System V semaphores; on the other hand POSIX semaphores are less widely available (especially on older systems) than System V semaphores.
fr: Les sémaphores System V (B<semget>(2), B<semop>(2), etc.) sont une API de sémaphores plus vieille. Les sémaphores POSIX fournissent une interface plus simple et mieux conçue que les sémaphores System V. En revanche, les sémaphores POSIX sont moins largement disponibles que les sémaphores System V (surtout sur les systèmes plus anciens).

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: An example of the use of various POSIX semaphore functions is shown in B<sem_wait>(3).
fr: Un exemple d'utilisation des diverses fonctions des sémaphores POSIX est donné dans B<sem_wait>(3).

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

note: type: Plain text
en: sem_post - unlock a semaphore
fr: sem_post - Déverrouiller un sémaphore

note: type: Plain text
en: B<sem_post>()  increments (unlocks) the semaphore pointed to by I<sem>.  If the semaphore's value consequently becomes greater than zero, then another process or thread blocked in a B<sem_wait>(3)  call will be woken up and proceed to lock the semaphore.
fr: B<sem_post>() incrémente (déverrouille) le sémaphore pointé par I<sem>. Si, à la suite de cet incrément, la valeur du sémaphore devient supérieure à zéro, un autre processus ou thread bloqué dans un appel B<sem_wait>(3) sera réveillé et procédera au verrouillage du sémaphore.

note: type: Plain text
en: B<sem_post>()  returns 0 on success; on error, the value of the semaphore is left unchanged, -1 is returned, and I<errno> is set to indicate the error.
fr: B<sem_post>() renvoie 0 s'il réussit. S'il échoue, la valeur du sémaphore n'est pas modifiée, il renvoie -1 et écrit I<errno> en conséquence.

note: Added in POSIX.1-2008 TC1 (Austin Interpretation 213) type: Plain text
en: The maximum allowable value for a semaphore would be exceeded.
fr: La valeur maximale autorisée pour un sémaphore serait dépassée.

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

note: type: Plain text
en: B<sem_post>()  is async-signal-safe: it may be safely called within a signal handler.
fr: B<sem_post>() est sûr du point de vue des signaux asynchrones\ : il peut être utilisé sûrement dans un gestionnaire de signaux.

note: type: Plain text
en: See B<sem_wait>(3).
fr: Consultez B<sem_wait>(3).

note: type: Plain text
en: sem_unlink - remove a named semaphore
fr: sem_unlink - Supprimer un sémaphore nommé

note: type: Plain text
en: B<sem_unlink>()  removes the named semaphore referred to by I<name>.  The semaphore name is removed immediately.  The semaphore is destroyed once all other processes that have the semaphore open close it.
fr: B<sem_unlink>() supprime un sémaphore nommé référencé par I<name>. Le nom du sémaphore est immédiatement supprimé. Le sémaphore est détruit une fois que tous les autres processus qui l'avaient ouvert l'ont fermé.

note: type: Plain text
en: On success B<sem_unlink>()  returns 0; on error, -1 is returned, with I<errno> set to indicate the error.
fr: S'il réussit, B<sem_unlink>() renvoie 0. S'il échoue, il renvoie -1 et écrit I<errno> en conséquence.

note: type: Plain text
en: The caller does not have permission to unlink this semaphore.
fr: L'appelant n'a pas la permission de supprimer le sémaphore.

note: type: Plain text
en: There is no semaphore with the given I<name>.
fr: Il n'y a pas de sémaphore du nom de I<name>.

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

note: type: Plain text
en: sem_wait, sem_timedwait, sem_trywait - lock a semaphore
fr: sem_wait, sem_timedwait, sem_trywait - Verrouiller un sémaphore

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

note: type: Plain text
en: B<sem_timedwait>(): _POSIX_C_SOURCE\ E<gt>=\ 200112L || _XOPEN_SOURCE\ E<gt>=\ 600
fr: B<sem_timedwait>() : _POSIX_C_SOURCE\ E<gt>=\ 200112L || _XOPEN_SOURCE\ E<gt>=\ 600

note: type: Plain text
en: B<sem_wait>()  decrements (locks) the semaphore pointed to by I<sem>.  If the semaphore's value is greater than zero, then the decrement proceeds, and the function returns, immediately.  If the semaphore currently has the value zero, then the call blocks until either it becomes possible to perform the decrement (i.e., the semaphore value rises above zero), or a signal handler interrupts the call.
fr: B<sem_wait>() décrémente (verrouille) le sémaphore pointé par I<sem>. Si la valeur du sémaphore est plus grande que 0, la décrémentation s'effectue et la fonction revient immédiatement. Si le sémaphore vaut zéro, l'appel bloquera jusqu'à ce que soit il devienne disponible d'effectuer la décrémentation (c'est-à-dire la valeur du sémaphore n'est plus nulle), soit un gestionnaire de signaux interrompe l'appel.

note: type: Plain text
en: B<sem_trywait>()  is the same as B<sem_wait>(), except that if the decrement cannot be immediately performed, then call returns an error (I<errno> set to B<EAGAIN>)  instead of blocking.
fr: B<sem_trywait>() est pareil que B<sem_wait>(), excepté que si la décrémentation ne peut pas être effectuée immédiatement, l'appel renvoie une erreur (I<errno> vaut B<EAGAIN>) plutôt que bloquer.

note: type: Plain text
en: B<sem_timedwait>()  is the same as B<sem_wait>(), except that I<abs_timeout> specifies a limit on the amount of time that the call should block if the decrement cannot be immediately performed.  The I<abs_timeout> argument points to a structure that specifies an absolute timeout in seconds and nanoseconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).  This structure is defined as follows:
fr: B<sem_timedwait>() est pareil que B<sem_wait>(), excepté que I<abs_timeout> spécifie une limite sur le temps pendant lequel l'appel bloquera si la décrémentation ne peut pas être effectuée immédiatement. L'argument I<abs_timeout> pointe sur une structure qui spécifie un temps absolu en secondes et nanosecondes depuis l'époque, 1er\ janvier 1970 à\ 00:00:00 (UTC). Cette structure est définie de la manière suivante\ :

note: type: Plain text
en: struct timespec {
        time_t tv_sec;      /* Seconds */
        long   tv_nsec;     /* Nanoseconds [0 .. 999999999] */
    };
fr: struct timespec {
        time_t tv_sec;      /* Secondes */
        long   tv_nsec;     /* Nanosecondes [0 .. 999999999] */
    };

note: type: Plain text
en: If the timeout has already expired by the time of the call, and the semaphore could not be locked immediately, then B<sem_timedwait>()  fails with a timeout error (I<errno> set to B<ETIMEDOUT>).
fr: Si le délai est déjà expiré à l'heure de l'appel et si le sémaphore ne peut pas être verrouillé immédiatement, B<sem_timedwait>() échoue avec l'erreur d'expiration de délai (I<errno> vaut B<ETIMEDOUT>).

note: type: Plain text
en: If the operation can be performed immediately, then B<sem_timedwait>()  never fails with a timeout error, regardless of the value of I<abs_timeout>.  Furthermore, the validity of I<abs_timeout> is not checked in this case.
fr: Si l'opération peut être effectuée immédiatement, B<sem_timedwait>() n'échoue jamais avec une valeur d'expiration de délai, quelque soit la valeur de I<abs_timeout>. De plus, la validité de I<abs_timeout> n'est pas vérifiée dans ce cas.

note: type: Plain text
en: All of these functions return 0 on success; on error, the value of the semaphore is left unchanged, -1 is returned, and I<errno> is set to indicate the error.
fr: Toutes ces fonctions renvoient 0 si elles réussissent. Si elles échouent, la valeur du sémaphore n'est pas modifiée, elles renvoient -1 et écrivent I<errno> en conséquence.

note: type: Plain text
en: The call was interrupted by a signal handler; see B<signal>(7).
fr: L'appel a été interrompu par un gestionnaire de signal ; consultez B<signal>(7).

note: type: Plain text
en: The following additional error can occur for B<sem_trywait>():
fr: L'erreur supplémentaire suivante peut survenir pour B<sem_trywait>()\ :

note: type: Plain text
en: The operation could not be performed without blocking (i.e., the semaphore currently has the value zero).
fr: L'opération ne peut pas être effectuée sans bloquer (c'est-à-dire, le sémaphore a une valeur nulle).

note: type: Plain text
en: The following additional errors can occur for B<sem_timedwait>():
fr: Les erreurs supplémentaires suivantes peuvent survenir pour B<sem_timedwait>()\ :

note: type: Plain text
en: The value of I<abs_timeout.tv_nsecs> is less than 0, or greater than or equal to 1000 million.
fr: La valeur de I<abs_timeout.tv_nsecs> est plus petite que 0 ou supérieure ou égale à 1 milliard.

note: POSIX.1-2001 also allows EDEADLK -- "A deadlock condition was detected", but this does not occur on Linux(?). type: Plain text
en: The call timed out before the semaphore could be locked.
fr: Le délai a expiré avant que le sémaphore ait pu être verrouillé.

note: type: Plain text
en: The B<sem_wait>(), B<sem_trywait>(), and B<sem_timedwait>()  functions are thread-safe.
fr: Les fonctions B<sem_wait>(), B<sem_trywait>() et B<sem_timedwait>() sont sûres dans un contexte multithread.

note: sem_wait() is always interrupted on most other implementations, but on FreeBSD 5.4 SA_RESTART does cause restarting. type: Plain text
en: A signal handler always interrupts a blocked call to one of these functions, regardless of the use of the B<sigaction>(2)  B<SA_RESTART> flag.
fr: Un gestionnaire de signaux interrompra toujours un appel bloqué à l'une de ces fonctions, quelque soit l'utilisation de l'attribut B<SA_RESTART> de B<sigaction>(2).

note: type: Plain text
en: The (somewhat trivial) program shown below operates on an unnamed semaphore.  The program expects two command-line arguments.  The first argument specifies a seconds value that is used to set an alarm timer to generate a B<SIGALRM> signal.  This handler performs a B<sem_post>(3)  to increment the semaphore that is being waited on in I<main()> using B<sem_timedwait>().  The second command-line argument specifies the length of the timeout, in seconds, for B<sem_timedwait>().  The following shows what happens on two different runs of the program:
fr: Le (quelque peu trivial) programme suivant opère sur un sémaphore non nommé. Il attend deux arguments sur la ligne de commande. Le premier argument spécifie une valeur en secondes qui est utilisée pour configurer une alarme pour générer un signal B<SIGALRM>. Ce gestionnaire effectue un B<sem_post>(3) pour incrémenter le sémaphore qui est attendu dans le I<main()> en utilisant B<sem_timedwait>(). Le second argument de la ligne de commande spécifie la durée, en secondes, du délai d'attente pour B<sem_timedwait>(). Ci-dessous, le résultat de deux exécutions différentes du programme\ :

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

note: type: TH
en: 2013-06-03
fr: 3 juin 2013

note: type: Plain text
en: semctl - System V semaphore control operations
fr: semctl - Opérations de contrôle sur les sémaphores System V

note: type: Plain text
en: B<semctl>()  performs the control operation specified by I<cmd> on the System V semaphore set identified by I<semid>, or on the I<semnum>-th semaphore of that set.  (The semaphores in a set are numbered starting at 0.)
fr: Cette fonction effectue l'opération de contrôle indiquée par I<cmd> sur l'ensemble de sémaphores System V (ou sur le I<semnum>-ième sémaphore de l'ensemble) identifié par I<semid>. (Les sémaphores sont numérotés à partir de zéro.)

note: type: Plain text
en: This function has three or four arguments, depending on I<cmd>.  When there are four, the fourth has the type I<union semun>.  The I<calling program> must define this union as follows:
fr: La fonction a trois ou quatre arguments, selon la valeur de I<cmd>. Quand il y en a quatre, le quatrième est de type I<union semun>. Le I<programme appelant> doit définir cette union de la façon suivante\ :

note: type: Plain text
en: union semun {
        int              val;    /* Value for SETVAL */
        struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
        unsigned short  *array;  /* Array for GETALL, SETALL */
        struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                    (Linux-specific) */
    };
fr: union semun {
        int              val;    /* Valeur pour SETVAL */
        struct semid_ds *buf;    /* Tampon pour IPC_STAT, IPC_SET */
        unsigned short  *array;  /* Tableau pour GETALL, SETALL */
        struct seminfo  *__buf;  /* Tampon pour IPC_INFO
                                    (spécifique à Linux) */
    };

note: type: Plain text
en: The I<semid_ds> data structure is defined in I<E<lt>sys/sem.hE<gt>> as follows:
fr: La structure I<semid_ds> est définie dans I<E<lt>sys/sem.hE<gt>> comme suit :

note: type: Plain text
en: struct semid_ds {
        struct ipc_perm sem_perm;  /* Ownership and permissions */
        time_t          sem_otime; /* Last semop time */
        time_t          sem_ctime; /* Last change time */
        unsigned long   sem_nsems; /* No. of semaphores in set */
    };
fr: struct semid_ds {
        struct ipc_perm sem_perm;   /* Permissions d'accès */
        time_t          sem_otime;  /* Heure dernier semop() */
        time_t          sem_ctime;  /* Heure dernier changement */
        unsigned long   sem_nsems;  /* Nombre de sémaphores dans l'ensemble */
    };

note: type: Plain text
en: The I<ipc_perm> structure is defined as follows (the highlighted fields are settable using B<IPC_SET>):
fr: La structure I<ipc_perm> est définie de la façon suivante (les champs en gras peuvent être modifiés en utilisant B<IPC_SET>) :

note: type: Plain text
en: struct ipc_perm {
        key_t          __key; /* Key supplied to semget(2) */
        uid_t          B<uid>;   /* Effective UID of owner */
        gid_t          B<gid>;   /* Effective GID of owner */
        uid_t          cuid;  /* Effective UID of creator */
        gid_t          cgid;  /* Effective GID of creator */
        unsigned short B<mode>;  /* Permissions */
        unsigned short __seq; /* Sequence number */
    };
fr: struct ipc_perm {
        key_t          __key; /* Clé fournie à semget(2) */
        uid_t          B<uid>;   /* UID effectif du propriétaire */
        gid_t          B<gid>;   /* GID effectif du propriétaire */
        uid_t          cuid;  /* UID effectif du créateur */
        gid_t          cgid;  /* GID effectif du créateur */
        unsigned short B<mode>;  /* Permissions */
        unsigned short __seq; /* Numéro de séquence */
    };

note: type: Plain text
en: Valid values for I<cmd> are:
fr: Les valeurs autorisées pour I<cmd> sont\ :

note: type: Plain text
en: Copy information from the kernel data structure associated with I<semid> into the I<semid_ds> structure pointed to by I<arg.buf>.  The argument I<semnum> is ignored.  The calling process must have read permission on the semaphore set.
fr: Copier dans la structure I<semid_ds> pointée par I<arg.buf> la structure de données du noyau concernant l'ensemble de sémaphores. L'argument I<semnum> est alors ignoré. Le processus appelant doit avoir des privilèges de lecture sur le jeu de sémaphores.

note: type: Plain text
en: Write the values of some members of the I<semid_ds> structure pointed to by I<arg.buf> to the kernel data structure associated with this semaphore set, updating also its I<sem_ctime> member.  The following members of the structure are updated: I<sem_perm.uid>, I<sem_perm.gid>, and (the least significant 9 bits of)  I<sem_perm.mode>.  The effective UID of the calling process must match the owner (I<sem_perm.uid>)  or creator (I<sem_perm.cuid>)  of the semaphore set, or the caller must be privileged.  The argument I<semnum> is ignored.
fr: Écrire les valeurs de certains des membres de la structure I<semid_ds> pointée par I<arg.buf> dans la structure de données du noyau associée à cet ensemble de sémaphores, en mettant à jour son champ I<sem_ctime>. Les membres suivants de la structure sont mis à jour\ : I<sem_perm.uid>, I<sem_perm.gid>, et les neuf bits de poids faibles de I<sem_perm.mode>. L'UID effectif du processus appelant doit être celle du propriétaire (I<sem_perm.uid>) ou du créateur (I<sem_perm.cuid>) de l'ensemble de sémaphores, ou l'appelant doit être privilégié. L'argument I<semnum> est ignoré.

note: type: Plain text
en: Immediately remove the semaphore set, awakening all processes blocked in B<semop>(2)  calls on the set (with an error return and I<errno> set to B<EIDRM>).  The effective user ID of the calling process must match the creator or owner of the semaphore set, or the caller must be privileged.  The argument I<semnum> is ignored.
fr: Supprimer immédiatement l'ensemble de sémaphores en réveillant tous les processus en attente dans B<semop>(2). Ils obtiendront un code d'erreur, et I<errno> aura la valeur B<EIDRM>. L'UID effectif du processus appelant doit être soit celui du créateur ou du propriétaire du jeu de sémaphores, ou l'appelant doit être privilégié. L'argument I<semnum> est ignoré.

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

note: type: Plain text
en: Returns information about system-wide semaphore limits and parameters in the structure pointed to by I<arg.__buf>.  This structure is of type I<seminfo>, defined in I<E<lt>sys/sem.hE<gt>> if the B<_GNU_SOURCE> feature test macro is defined:
fr: Renvoyer des informations sur les limites et paramètres du système concernant les sémaphores dans la structure pointée par I<arg.__buf>. Cette structure est de type I<seminfo>, défini dans I<E<lt>sys/sem.hE<gt>> si la macro B<_GNU_SOURCE> est définie\ :

note: type: Plain text
en: struct  seminfo {
        int semmap;  /* Number of entries in semaphore
                        map; unused within kernel */
        int semmni;  /* Maximum number of semaphore sets */
        int semmns;  /* Maximum number of semaphores in all
                        semaphore sets */
        int semmnu;  /* System-wide maximum number of undo
                        structures; unused within kernel */
        int semmsl;  /* Maximum number of semaphores in a
                        set */
        int semopm;  /* Maximum number of operations for
                        semop(2) */
        int semume;  /* Maximum number of undo entries per
                        process; unused within kernel */
        int semusz;  /* Size of struct sem_undo */
        int semvmx;  /* Maximum semaphore value */
        int semaem;  /* Max. value that can be recorded for
                        semaphore adjustment (SEM_UNDO) */
    };
fr: struct  seminfo {
        int semmap;  /* Nombre d'entrées dans la table de sémaphores ; 
                        pas utilisé par le noyau */
        int semmni;  /* Nombre maximal d'ensembles de sémaphores */
        int semmns;  /* Nombre maximal de sémaphores dans tous les 
                        ensembles de sémaphores */
        int semmnu;  /* Nombre maximal de structures «\ undo\ » 
                        sur le système\ ; pas utilisé par le noyau */
        int semmsl;  /* Nombre maximal de sémaphores dans un ensemble */
        int semopm;  /* Nombre maximal d'opérations pour semop(2) */
        int semume;  /* Nombre maximal d'entrées «\ undo\ » par
                        processus\ ; pas utilisé par le noyau */
        int semusz;  /* Taille de struct sem_undo */
        int semvmx;  /* Valeur maximale d'un sémaphore */
        int semaem;  /* Valeur maximale pouvant être enregistrée pour 
                        la mise à jour d'un sémaphore (SEM_UNDO) */
    };

note: type: Plain text
en: The I<semmsl>, I<semmns>, I<semopm>, and I<semmni> settings can be changed via I</proc/sys/kernel/sem>; see B<proc>(5)  for details.
fr: Les paramètres I<semmsl>, I<semmns>, I<semopm> et I<semmni> peuvent être modifiés via I</proc/sys/kernel/sem>\ ; consultez B<proc>(5) pour plus de détails.

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

note: type: Plain text
en: Returns a I<seminfo> structure containing the same information as for B<IPC_INFO>, except that the following fields are returned with information about system resources consumed by semaphores: the I<semusz> field returns the number of semaphore sets that currently exist on the system; and the I<semaem> field returns the total number of semaphores in all semaphore sets on the system.
fr: Renvoyer une structure I<seminfo> contenant les mêmes informations que pour B<IPC_INFO>, sauf les champs suivants qui sont remplis avec des informations sur les ressources système actuellement utilisées par les sémaphores\ : le champ I<semusz> renvoie le nombre d'ensemble de sémaphores existant sur le système, et le champ I<semaem> renvoie le nombre total de sémaphores dans tous les ensembles de sémaphores du système.

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

note: type: Plain text
en: Returns a I<semid_ds> structure as for B<IPC_STAT>.  However, the I<semid> argument is not a semaphore identifier, but instead an index into the kernel's internal array that maintains information about all semaphore sets on the system.
fr: Renvoyer une structure I<semid_ds> comme pour B<IPC_STAT>. Cependant, l'argument I<semid> n'est pas un identifiant de sémaphore, mais un index dans la table interne du noyau qui contient des informations sur tous les ensembles de sémaphores du système.

note: type: Plain text
en: Return B<semval> (i.e., the current value)  for all semaphores of the set into I<arg.array>.  The argument I<semnum> is ignored.  The calling process must have read permission on the semaphore set.
fr: Renvoyer la valeur B<semval> de chaque sémaphore de l'ensemble dans le tableau I<arg.array>. L'argument I<semnum> est ignoré. Le processus appelant doit avoir des privilèges de lecture sur le jeu de sémaphores.

note: type: Plain text
en: The system call returns the value of B<semncnt> for the I<semnum>-th semaphore of the set (i.e., the number of processes waiting for an increase of B<semval> for the I<semnum>-th semaphore of the set).  The calling process must have read permission on the semaphore set.
fr: L'appel système renvoie la valeur de B<semncnt> pour le I<semnum>-ième sémaphore de l'ensemble (c'est-à-dire le nombre de processus attendant pour une augmentation de B<semval> du  I<semnum>-ième sémaphore de l'ensemble). Le processus appelant doit avoir des privilèges de lecture sur le jeu de sémaphores.

note: type: Plain text
en: The system call returns the value of B<sempid> for the I<semnum>-th semaphore of the set (i.e., the PID of the process that executed the last B<semop>(2)  call for the I<semnum>-th semaphore of the set).  The calling process must have read permission on the semaphore set.
fr: Renvoyer la valeur de B<sempid> pour le I<semnum>-ième sémaphore de l'ensemble (c'est-à-dire le PID du processus ayant exécuté le dernier appel système B<semop>(2) sur le I<semnum>-ième sémaphore). Le processus appelant doit avoir des privilèges de lecture sur le jeu de sémaphores.

note: type: Plain text
en: The system call returns the value of B<semval> for the I<semnum>-th semaphore of the set.  The calling process must have read permission on the semaphore set.
fr: Renvoyer la valeur du champ B<semval> du I<semnum>-ième sémaphore de l'ensemble. Le processus appelant doit avoir des privilèges de lecture sur le jeu de sémaphores.

note: type: Plain text
en: The system call returns the value of B<semzcnt> for the I<semnum>-th semaphore of the set (i.e., the number of processes waiting for B<semval> of the I<semnum>-th semaphore of the set to become 0).  The calling process must have read permission on the semaphore set.
fr: Renvoyer la valeur du champ B<semzcnt> du I<semnum>-ième sémaphore de l'ensemble (c'est-à-dire le nombre de processus attendant que le champ B<semval> du I<semnum>-ième sémaphore revienne à 0). Le processus appelant doit avoir des privilèges de lecture sur le jeu de sémaphores.

note: type: Plain text
en: Set B<semval> for all semaphores of the set using I<arg.array>, updating also the I<sem_ctime> member of the I<semid_ds> structure associated with the set.  Undo entries (see B<semop>(2))  are cleared for altered semaphores in all processes.  If the changes to semaphore values would permit blocked B<semop>(2)  calls in other processes to proceed, then those processes are woken up.  The argument I<semnum> is ignored.  The calling process must have alter (write) permission on the semaphore set.
fr: Positionner le champ B<semval> de tous les sémaphores de l'ensemble en utilisant le tableau I<arg.array> et en mettant à jour le champ I<sem_ctime> de la structure I<semid_ds> de contrôle du jeu de sémaphores. Les entrées «\ undo\ » (consultez B<semop>(2)) sont effacées de tous les processus pour les sémaphores modifiés. Si la nouvelle valeur du sémaphore permet à des appels B<semop>(2) bloqués dans d'autres processus de se poursuivre, ces processus sont réveillés. L'argument I<semnum> est ignoré. Le processus appelant doit avoir des privilèges d'écriture sur le jeu de sémaphores.

note: type: Plain text
en: Set the value of B<semval> to I<arg.val> for the I<semnum>-th semaphore of the set, updating also the I<sem_ctime> member of the I<semid_ds> structure associated with the set.  Undo entries are cleared for altered semaphores in all processes.  If the changes to semaphore values would permit blocked B<semop>(2)  calls in other processes to proceed, then those processes are woken up.  The calling process must have alter permission on the semaphore set.
fr: Placer la valeur I<arg.val> dans le champ B<semval> du I<semnum>-ième sémaphore de l'ensemble en mettant à jour le champ I<sem_ctime> dans la structure I<semid_ds> associée au jeu de sémaphores. Les entrées «\ undo\ » sont effacées de tous les processus pour les sémaphores modifiés. Si la nouvelle valeur du sémaphore permet à des appels B<semop>(2) bloqués dans d'autres processus de se poursuivre, ces processus sont réveillés. Le processus appelant doit avoir des privilèges d'écriture sur le jeu de sémaphores.

note: type: Plain text
en: On failure B<semctl>()  returns -1 with I<errno> indicating the error.
fr: B<semctl>() renvoie -1 s'il échoue auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: Otherwise the system call returns a nonnegative value depending on I<cmd> as follows:
fr: Autrement, l'appel système renvoie une valeur non négative dépendant de l'argument I<cmd>\ :

note: type: Plain text
en: the value of B<semncnt>.
fr: la valeur de B<semncnt>.

note: type: Plain text
en: the value of B<sempid>.
fr: La valeur B<sempid>.

note: type: Plain text
en: the value of B<semval>.
fr: La valeur B<semval>.

note: type: Plain text
en: the value of B<semzcnt>.
fr: La valeur B<semzcnt>.

note: type: Plain text
en: the index of the highest used entry in the kernel's internal array recording information about all semaphore sets.  (This information can be used with repeated B<SEM_STAT> operations to obtain information about all semaphore sets on the system.)
fr: Le plus grand indice d'une entrée utilisée dans la table interne du noyau contenant des informations sur tous les ensembles de sémaphores. Cette information peut ensuite être utilisée pour des opérations B<SEM_STAT> répétées afin d'obtenir des informations sur tous les ensembles de sémaphores du système.

note: type: Plain text
en: As for B<IPC_INFO>.
fr: Comme pour B<IPC_INFO>.

note: type: Plain text
en: the identifier of the semaphore set whose index was given in I<semid>.
fr: L'identifiant de l'ensemble de sémaphores dont l'indice était donné dans I<semid>.

note: type: Plain text
en: All other I<cmd> values return 0 on success.
fr: Toutes les autres commandes I<cmd> renvoient zéro en cas de réussite.

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

note: type: Plain text
en: The argument I<cmd> has one of the values B<GETALL>, B<GETPID>, B<GETVAL>, B<GETNCNT>, B<GETZCNT>, B<IPC_STAT>, B<SEM_STAT>, B<SETALL>, or B<SETVAL> and the calling process does not have the required permissions on the semaphore set and does not have the B<CAP_IPC_OWNER> capability.
fr: L'argument I<cmd> a l'une des valeurs suivantes B<GETALL>, B<GETPID>, B<GETVAL>, B<GETNCNT>, B<GETZCNT>, B<IPC_STAT>, B<SEM_STAT>, B<SETALL>, ou B<SETVAL> et le processus appelant n'a pas les permissions nécessaires sur le jeu de sémaphore et n'a pas la capacité B<CAP_IPC_OWNER>.

note: type: Plain text
en: The address pointed to by I<arg.buf> or I<arg.array> isn't accessible.
fr: I<arg.buf> ou I<arg.array> pointent en dehors de l'espace d'adressage accessible.

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

note: type: Plain text
en: Invalid value for I<cmd> or I<semid>.  Or: for a B<SEM_STAT> operation, the index value specified in I<semid> referred to an array slot that is currently unused.
fr: Valeur de I<cmd> ou I<semid> invalide. Ou bien, pour une opération B<SEM_STAT>, l'indice indiqué dans I<semid> référence une entrée actuellement inutilisée de la table.

note: type: Plain text
en: The argument I<cmd> has the value B<IPC_SET> or B<IPC_RMID> but the effective user ID of the calling process is not the creator (as found in I<sem_perm.cuid>)  or the owner (as found in I<sem_perm.uid>)  of the semaphore set, and the process does not have the B<CAP_SYS_ADMIN> capability.
fr: L'argument I<cmd> réclame les commandes B<IPC_SET> ou B<IPC_RMID> mais l'UID effectif du processus appelant n'est pas le créateur (comme dans I<sem_perm.cuid>) ou le propriétaire (comme dans I<sem_perm.uid>) du jeu de sémaphores, et le processus n'a pas la capacité B<CAP_SYS_ADMIN>.

note: type: Plain text
en: The argument I<cmd> has the value B<SETALL> or B<SETVAL> and the value to which B<semval> is to be set (for some semaphore of the set) is less than 0 or greater than the implementation limit B<SEMVMX>.
fr: L'argument I<cmd> réclame les commandes B<SETALL> ou B<SETVAL> et la valeur de B<semval> (pour l'ensemble ou pour certains sémaphores) est inférieure à 0 ou supérieur à la valeur B<SEMVMX>.

note: type: Plain text
en: POSIX.1-2001 specifies the I<sem_nsems> field of the I<semid_ds> structure as having the type I<unsigned\ short>, and the field is so defined on most other systems.  It was also so defined on Linux 2.2 and earlier, but, since Linux 2.4, the field has the type I<unsigned\ long>.
fr: POSIX.1-2001 spécifie le champ I<sem_nsems> de la structure I<semid_ds> comme de type I<unsigned\ short>, ce qui est suivi par de nombreux systèmes. Ce champ était défini ainsi dans Linux 2.2 et dans les versions précédentes. Depuis Linux 2.4, ce champ et de type I<unsigned\ long>.

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

note: type: Plain text
en: The B<IPC_INFO>, B<SEM_STAT> and B<SEM_INFO> operations are used by the B<ipcs>(1)  program to provide information on allocated resources.  In the future these may modified or moved to a I</proc> filesystem interface.
fr: Les appels système B<IPC_INFO>, B<SEM_STAT> et B<SEM_INFO> sont utilisés par le programme B<ipcs>(1) pour fournir des informations sur les ressources allouées. Ceci peut changer dans le futur, en utilisant l'interface d'un système de fichiers I</proc>.

note: type: Plain text
en: Various fields in a I<struct semid_ds> were typed as I<short> under Linux 2.2 and have become I<long> under Linux 2.4.  To take advantage of this, a recompilation under glibc-2.1.91 or later should suffice.  (The kernel distinguishes old and new calls by an B<IPC_64> flag in I<cmd>.)
fr: Divers champs de la I<struct semid_ds> étaient de type I<short> sous Linux 2.2 et sont devenus des I<long> sous Linux 2.4. Pour en tirer parti, une recompilation sous glibc 2.1.91 ou ultérieure doit suffire. (Le noyau distingue les anciens et nouveaux appels par un drapeau B<IPC_64> dans I<cmd>.)

note: type: Plain text
en: In some earlier versions of glibc, the I<semun> union was defined in I<E<lt>sys/sem.hE<gt>>, but POSIX.1-2001 requires that the caller define this union.  On versions of glibc where this union is I<not> defined, the macro B<_SEM_SEMUN_UNDEFINED> is defined in I<E<lt>sys/sem.hE<gt>>.
fr: Dans certaines versions antérieures de glibc, l'union I<semun> était définie dans I<E<lt>sys/sem.hE<gt>>, mais POSIX.1-2001 documente que l'appelant doit définir cette union. Dans les versions de glibc où cette union n'est I<pas> définie, la macro B<_SEM_SEMUN_UNDEFINED> est définie dans I<E<lt>sys/sem.hE<gt>>.

note: type: Plain text
en: The following system limit on semaphore sets affects a B<semctl>()  call:
fr: La limite suivante influe sur l'appel système B<semctl>()\ :

note: type: Plain text
en: Maximum value for B<semval>: implementation dependent (32767).
fr: Valeur maximale pour B<semval> dépendant de l'implémentation (généralement 32767).

note: type: Plain text
en: For greater portability it is best to always call B<semctl>()  with four arguments.
fr: Pour améliorer la portabilité, il vaut mieux invoquer toujours B<semctl>() avec quatre arguments.

note: type: TH
en: 2012-05-31
fr: 31 mai 2012

note: type: Plain text
en: semget - get a System V semaphore set identifier
fr: semget - Obtenir l'identifiant d'un ensemble de sémaphores System V

note: type: Plain text
en: The B<semget>()  system call returns the System V semaphore set identifier associated with the argument I<key>.  A new set of I<nsems> semaphores is created if I<key> has the value B<IPC_PRIVATE> or if no existing semaphore set is associated with I<key> and B<IPC_CREAT> is specified in I<semflg>.
fr: L'appel système B<semget>() renvoie l'identifiant de l'ensemble de sémaphores System V associé à la valeur de clé I<key>. Un nouvel ensemble contenant I<nsems> sémaphores est créé si I<key> a la valeur B<IPC_PRIVATE> ou si aucun ensemble n'est associé à I<key>, et si l'option B<IPC_CREAT> est présente dans I<semflg>.

note: type: Plain text
en: If I<semflg> specifies both B<IPC_CREAT> and B<IPC_EXCL> and a semaphore set already exists for I<key>, then B<semget>()  fails with I<errno> set to B<EEXIST>.  (This is analogous to the effect of the combination B<O_CREAT | O_EXCL> for B<open>(2).)
fr: Si I<semflg> contient à la fois B<IPC_CREAT> et B<IPC_EXCL> et qu'un ensemble de sémaphores existe déjà pour la clé I<key>, B<semget>() échoue et I<errno> vaut B<EEXIST>. (Ceci est analogue à l'effet de la combinaison B<O_CREAT | O_EXCL> pour B<open>(2).)

note: type: Plain text
en: Upon creation, the least significant 9 bits of the argument I<semflg> define the permissions (for owner, group and others)  for the semaphore set.  These bits have the same format, and the same meaning, as the I<mode> argument of B<open>(2)  (though the execute permissions are not meaningful for semaphores, and write permissions mean permission to alter semaphore values).
fr: Pendant la création, les 9 bits de poids faibles de l'argument I<semflg> définissent les permissions d'accès (pour le propriétaire, le groupe et les autres) au jeu de sémaphores, en utilisant le même format et la même signification que les droits d'accès dans B<open>(2). Les permissions d'exécution ne sont pas utilisées par le système, et pour un jeu de sémaphores, l'autorisation d'écriture signifie autorisation de modification.

note: In truth, every one of the many implementations that I've tested sets the values to zero, but I suppose there is/was some obscure implementation out there that does not. type: Plain text
en: The values of the semaphores in a newly created set are indeterminate.  (POSIX.1-2001 is explicit on this point.)  Although Linux, like many other implementations, initializes the semaphore values to 0, a portable application cannot rely on this: it should explicitly initialize the semaphores to the desired values.
fr: Les valeurs des sémaphores dans un ensemble qui vient d'être créé sont indéterminées (POSIX.1-2001 est explicite sur ce point). Même si Linux, comme de nombreuses autres implémentations, initialise les valeurs des sémaphores à 0, une application portable ne peut pas compter sur cette initialisation\ : elle doit initialiser explicitement les sémaphores à la valeur souhaitée.

note: type: Plain text
en: When creating a new semaphore set, B<semget>()  initializes the set's associated data structure, I<semid_ds> (see B<semctl>(2)), as follows:
fr: Durant la création, la structure de données I<semid_ds> (consultez B<semctl>(2)) contrôlant le jeu de sémaphores est initialisée ainsi par B<semget>()\ :

note: type: Plain text
en: I<sem_perm.cuid> and I<sem_perm.uid> are set to the effective user ID of the calling process.
fr: I<sem_perm.cuid> et I<sem_perm.uid> contiennent l'UID effectif du processus appelant.

note: type: Plain text
en: I<sem_perm.cgid> and I<sem_perm.gid> are set to the effective group ID of the calling process.
fr: I<sem_perm.cgid> et I<sem_perm.gid> contiennent le GID effectif du processus appelant.

note: type: Plain text
en: The least significant 9 bits of I<sem_perm.mode> are set to the least significant 9 bits of I<semflg>.
fr: Les 9 bits de poids faibles de I<sem_perm.mode> contiennent les 9 bits de poids faibles de I<semflg>.

note: type: Plain text
en: I<sem_nsems> is set to the value of I<nsems>.
fr: I<sem_nsems> reçoit la valeur I<nsems>.

note: type: Plain text
en: I<sem_otime> is set to 0.
fr: I<sem_otime> est mis à 0.

note: type: Plain text
en: I<sem_ctime> is set to the current time.
fr: I<sem_ctime> est rempli avec l'heure actuelle.

note: type: Plain text
en: The argument I<nsems> can be 0 (a don't care)  when a semaphore set is not being created.  Otherwise I<nsems> must be greater than 0 and less than or equal to the maximum number of semaphores per semaphore set (B<SEMMSL>).
fr: L'argument I<nsems> peut valoir 0 (ignore) si l'appel système n'est pas une création d'ensemble de sémaphores. Autrement I<nsems> doit être supérieur à 0 et inférieur ou égal au nombre maximal de sémaphores par ensemble (B<SEMMSL>).

note: and a check is made to see if it is marked for destruction. type: Plain text
en: If the semaphore set already exists, the permissions are verified.
fr: Si le jeu de sémaphores existe déjà, les permissions d'accès sont contrôlées.

note: type: Plain text
en: If successful, the return value will be the semaphore set identifier (a nonnegative integer), otherwise -1 is returned, with I<errno> indicating the error.
fr: Si l'appel réussit, il renvoie l'identifiant de l'ensemble (un entier positif), sinon il renvoie -1 et I<errno> contient le code d'erreur.

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

note: type: Plain text
en: A semaphore set exists for I<key>, but the calling process does not have permission to access the set, and does not have the B<CAP_IPC_OWNER> capability.
fr: Le jeu de sémaphore associé à I<key> existe, mais le processus n'a aucun droit d'accès sur lui et n'a pas la capacité B<CAP_IPC_OWNER>.

note: .TP .B EIDRM The semaphore set is marked to be deleted. type: Plain text
en: A semaphore set exists for I<key> and I<semflg> specified both B<IPC_CREAT> and B<IPC_EXCL>.
fr: Le jeu de sémaphore associé a I<key> existe mais l'argument I<semflg> précise à la fois B<IPC_CREAT> et B<IPC_EXCL>.

note: type: Plain text
en: I<nsems> is less than 0 or greater than the limit on the number of semaphores per semaphore set (B<SEMMSL>), or a semaphore set corresponding to I<key> already exists, and I<nsems> is larger than the number of semaphores in that set.
fr: I<nsems> est inférieur à zéro ou supérieur à la limite sur le nombre de sémaphores par ensemble, (B<SEMMSL>), ou l'ensemble de sémaphores identifié par I<key> existe déjà, et I<nsems> est plus grand que le nombre de sémaphores par ensemble.

note: type: Plain text
en: No semaphore set exists for I<key> and I<semflg> did not specify B<IPC_CREAT>.
fr: Aucun jeu de sémaphore associé a I<key> n'existe et l'argument I<semflg> ne précise pas B<IPC_CREAT>.

note: type: Plain text
en: A semaphore set has to be created but the system does not have enough memory for the new data structure.
fr: Pas assez de mémoire pour créer les structures nécessaires.

note: type: Plain text
en: A semaphore set has to be created but the system limit for the maximum number of semaphore sets (B<SEMMNI>), or the system wide maximum number of semaphores (B<SEMMNS>), would be exceeded.
fr: Le nombre maximal de jeux de sémaphores sur le système (B<SEMMNI>) est atteint, ou le nombre maximal de sémaphores sur le système est atteint (B<SEMMNS>).

note: type: Plain text
en: B<IPC_PRIVATE> isn't a flag field but a I<key_t> type.  If this special value is used for I<key>, the system call ignores everything but the least significant 9 bits of I<semflg> and creates a new semaphore set (on success).
fr: B<IPC_PRIVATE> n'est pas une option, mais un objet de type I<key_t>. Si l'on utilise cette valeur spéciale dans l'argument I<key>, l'appel système ne se préoccupera que des 9 bits de poids faibles de I<semflg> et tentera de créer un nouveau jeu de sémaphores.

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

note: This /proc file is not available in Linux 2.2 and earlier -- MTK type: Plain text
en: System wide maximum number of semaphore sets: policy dependent (on Linux, this limit can be read and modified via the fourth field of I</proc/sys/kernel/sem>).
fr: Nombre maximal de jeux de sémaphores sur le système\ : dépend de la politique (sous Linux, cette limite peut être lue et modifiée dans le quatrième champ de I</proc/sys/kernel/sem>).

note: type: Plain text
en: Maximum number of semaphores per semid: implementation dependent (on Linux, this limit can be read and modified via the first field of I</proc/sys/kernel/sem>).
fr: Nombre maximal de sémaphores par ensemble\ : dépendant de l'implémentation (sous Linux, cette limite peut être lue et modifiée dans le premier champ de I</proc/sys/kernel/sem>).

note: type: Plain text
en: System wide maximum number of semaphores: policy dependent (on Linux, this limit can be read and modified via the second field of I</proc/sys/kernel/sem>).  Values greater than B<SEMMSL * SEMMNI> makes it irrelevant.
fr: Nombre maximal de sémaphores sur le système\ : dépend de la politique (sous Linux, cette limite peut être lue et modifiée dans le second champ de I</proc/sys/kernel/sem>). Les valeurs supérieures à B<SEMMSL * SEMMNI> sont incorrectes.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: The name choice B<IPC_PRIVATE> was perhaps unfortunate, B<IPC_NEW> would more clearly show its function.
fr: Le choix du nom B<IPC_PRIVATE> est malheureux, B<IPC_NEW> aurait mieux décrit sa fonction.

note: In fact they are initialized to zero on Linux, but POSIX.1-2001 does not specify this, and we can't portably rely on it. type: Plain text
en: The semaphores in a set are not initialized by B<semget>().  In order to initialize the semaphores, B<semctl>(2)  must be used to perform a B<SETVAL> or a B<SETALL> operation on the semaphore set.  (Where multiple peers do not know who will be the first to initialize the set, checking for a nonzero I<sem_otime> in the associated data structure retrieved by a B<semctl>(2)  B<IPC_STAT> operation can be used to avoid races.)
fr: Les sémaphores dans un ensemble ne sont pas initialisés par B<semget>(). Pour initialiser les sémaphores, il faut utiliser B<semctl>(2) pour effectuer une opération B<SETVAL> ou B<SETALL> sur l'ensemble de sémaphores. (Lorsque plusieurs pairs ne savent pas lequel initialisera l'ensemble en premier, un test pour une valeur non nulle de I<sem_otime> dans la structure de données associée renvoyée par l'opération B<IPC_STAT> de B<semctl>(2) peut être utilisée pour éviter les problèmes d'accès concurrents.)

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

note: type: Plain text
en: semop, semtimedop - System V semaphore operations
fr: semop, semtimedop - Opérations sur les sémaphores System V

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

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

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

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

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

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

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

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

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

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

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

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

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

note: type: Plain text
en: The time limit specified by I<timeout> in a B<semtimedop>()  call expires: B<semop>()  fails, with I<errno> set to B<EAGAIN>.
fr: La limite temporelle indiqué par I<timeout> dans un B<semtimedop>() a expiré\ : l'appel système échoue avec I<errno> contenant B<EAGAIN>.

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

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

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

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

note: type: Plain text
en: The time limit specified by I<timeout> in a B<semtimedop>()  call expires: the system call fails, with I<errno> set to B<EAGAIN>.
fr: La limite temporelle indiqué par I<timeout> dans un B<semtimedop>() a expiré\ : l'appel système échoue avec I<errno> contenant B<EAGAIN>.

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

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

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

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

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

note: type: Plain text
en: The calling process does not have the permissions required to perform the specified semaphore operations, and does not have the B<CAP_IPC_OWNER> capability.
fr: Le processus appelant n'a pas les permissions nécessaires pour effectuer les opérations sur les sémaphores spécifiés et n'a pas la capacité B<CAP_IPC_OWNER>.

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

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

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

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

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

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

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

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

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

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

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

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

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

note: This /proc file is not available in Linux 2.2 and earlier -- MTK type: Plain text
en: Maximum number of operations allowed for one B<semop>()  call (32)  (on Linux, this limit can be read and modified via the third field of I</proc/sys/kernel/sem>).
fr: Nombre maximal d'opérations pour une appel à B<semop>() (32). Sous Linux, cette limite peut être lue et modifiée via le troisième champ du fichier I</proc/sys/kernel/sem>.

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

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

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

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

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

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

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

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