Provided by: manpages-fr-dev_3.65d1p1-1_all bug

NOM

       semop, semtimedop - Opérations sur les sémaphores System V

SYNOPSIS

       #include <sys/types.h>
       #include <sys/ipc.h>
       #include <sys/sem.h>

       int semop(int semid, struct sembuf *sops, unsigned nsops);

       int semtimedop(int semid, struct sembuf *sops, unsigned nsops,
                      struct timespec *timeout);

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

       semtimedop() : _GNU_SOURCE

DESCRIPTION

       Chaque sémaphore dans un ensemble de sémaphores System V se voit associer les valeurs suivantes :

           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 */

       La  fonction  semop()  effectue  des opérations sur les membres de l'ensemble de sémaphores identifié par
       semid. Chacun des nsops éléments dans le tableau pointé par sops indique une opération à effectuer sur un
       sémaphore en utilisant une structure struct sembuf contenant les membres suivants :

           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   */

       Les  options  possibles  pour  sem_flg  sont  IPC_NOWAIT  et  SEM_UNDO. Si une opération indique l'option
       SEM_UNDO, elle sera annulée lorsque le processus se terminera.

       L'ensemble des opérations contenues dans sops est effectué dans l'ordre et 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 IPC_NOWAIT dans les champs sem_flg décrits plus bas.

       Chaque  opération  est effectuée sur le 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.

       Si l'argument sem_op est un entier positif, la fonction ajoute cette valeur à semval. De plus si SEM_UNDO
       est  demandé,  le  système  soustrait  la valeur sem_op à la valeur de mise à jour de sémaphore (semadj).
       Cette opération n'est jamais bloquante. Le processus appelant doit avoir l'autorisation  de  modification
       sur le jeu de sémaphores.

       Si  sem_op  vaut  zéro le processus doit avoir l'autorisation de lecture sur l'ensemble de sémaphores. Le
       processus attend que semval soit nul : si semval  vaut  zéro,  l'appel  système  continue  immédiatement.
       Sinon,  si  l'on  a  réclamé IPC_NOWAIT dans sem_flg, l'appel système semop() échoue et errno contient le
       code d'erreur EAGAIN (et aucune des opérations de sops n'est réalisée). Sinon  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 :

       •  semval devient égal à 0, alors semzcnt est décrémenté.

       •  Le jeu de sémaphores est supprimé. L'appel système échoue et errno contient le code d'erreur EIDRM.

       •  Le thread reçoit un signal à intercepter, la valeur de semzcnt  est  décrémentée  et  l'appel  système
          échoue avec errno contenant le code d'erreur EINTR.

       •  La  limite  temporelle indiqué par timeout dans un semtimedop() a expiré : l'appel système échoue avec
          errno contenant EAGAIN.

       Si sem_op est inférieur à zéro, le processus appelant doit avoir l'autorisation de  modification  sur  le
       jeu  de  sémaphores.  Si semval est supérieur ou égal à la valeur absolue de sem_op, la valeur absolue de
       sem_op est soustraite de semval, et si SEM_UNDO est indiqué, le  système  ajoute  la  valeur  absolue  de
       sem_op à la valeur de mise à jour de sémaphore (semadj) pour ce sémaphore. Si la valeur absolue de sem_op
       est plus grande que semval, et si l'on a réclamé IPC_NOWAIT dans sem_flg, l'appel système échoue et errno
       contient  le  code  d'erreur  EAGAIN (et aucune des opérations de sops n'est réalisée). Sinon 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 :

       •  semval  devient  supérieur  ou  égal  à  la valeur absolue de sem_op : l'opération est effectuée comme
          décrit ci-dessus.

       •  Le jeu de sémaphores est supprimé. L'appel système échoue et errno contient le code d'erreur EIDRM.

       •  Le thread reçoit un signal à intercepter, la valeur de semncnt  est  décrémentée  et  l'appel  système
          échoue avec errno contenant le code d'erreur EINTR.

       •  La  limite  temporelle indiqué par timeout dans un semtimedop() a expiré : l'appel système échoue avec
          errno contenant EAGAIN.

       En cas de succès, le membre sempid de chacun des sémaphores indiqués dans le tableau pointé par sops  est
       rempli avec le PID de l'appelant. Enfin sem_otime est défini à l'heure actuelle.

       La  fonction  semtimedop()  se  comporte  comme 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 timespec  dont  l'adresse
       est  transmise  dans  le  paramètre  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 errno contenant EAGAIN (et
       aucune opération de sops n'est réalisée). Si  le  paramètre  timeout  est  NULL,  alors  semtimedop()  se
       comporte exactement comme semop().

VALEUR RENVOYÉE

       En cas de réussite, semop() et semtimedop() renvoient 0. Sinon ils renvoient -1 et errno contient le code
       d'erreur.

ERREURS

       En cas d'erreur, errno prend l'une des valeurs suivantes :

       E2BIG  l'argument nsops est supérieur à SEMOPM, le nombre maximal d'opérations par appel système.

       EACCES 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é CAP_IPC_OWNER.

       EAGAIN Une  opération  ne  pouvait  pas  être  effectuée  immédiatement  et IPC_NOWAIT a été indiqué dans
              l'argument sem_flg, ou la durée limite indiquée dans timeout a expiré.

       EFAULT sops ou timeout pointent en dehors de l'espace d'adressage accessible.

       EFBIG  La valeur de sem_num est inférieure à 0 ou supérieure  ou  égale  au  nombre  de  sémaphores  dans
              l'ensemble.

       EIDRM  Le jeu de sémaphores a été supprimé.

       EINTR  Un signal a été reçu pendant l'attente ; consultez signal(7).

       EINVAL L'ensemble  de  sémaphores  n'existe  pas  ou  semid  est  inférieur  à  zéro,  ou nsops n'est pas
              strictement positive.

       ENOMEM L'argument sem_flg de certaines opérations demande SEM_UNDO et le système n'a pas assez de mémoire
              pour allouer les structures nécessaires.

       ERANGE sem_op+semval est supérieur à SEMVMX (la valeur maximale de semval autorisée par l'implémentation)
              pour l'une des opérations.

VERSIONS

       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 semtimedop() dans la glibc date de la version 2.3.3.

CONFORMITÉ

       SVr4, POSIX.1-2001.

NOTES

       L'inclusion  de  <sys/types.h>  et <sys/ipc.h> 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.

       Les structures sem_undo d'un processus ne sont pas héritées par ses enfants lors d'un fork(2), mais elles
       le sont lors d'un appel système execve(2).

       semop()  n'est  jamais  relancé  automatiquement après avoir été interrompu par un gestionnaire de signal
       quelque soit l'attribut SA_RESTART durant l'installation du gestionnaire.

       Une valeur de mise à jour de sémaphore (semadj) est un entier propre à un  processus  et  sémaphore,  qui
       représente le compte négatif des opérations utilisant l'attribut SEM_UNDO. Chaque processus dispose d'une
       liste de valeurs semadj — une valeur pour chaque sémaphore où SEM_UNDO a été utilisé. Quand un  processus
       se  termine,  chacune  des  valeurs  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 SETVAL ou SETALL de semctl(2), la
       valeur semadj correspondante est effacée dans tous les processus.

       Les valeurs semval, sempid, semzcnt, et semnct pour un sémaphore peuvent être retrouvées avec des  appels
       semctl(2) spécifiques.

       Les limites système suivantes concernent semop() :

       SEMOPM Nombre  maximal d'opérations pour une appel à semop() (32). Sous Linux, cette limite peut être lue
              et modifiée via le troisième champ du fichier /proc/sys/kernel/sem.

       SEMVMX Valeur maximale pour semval : dépendante de l'implémentation (32767).

       L'implémentation n'a pas de limites intrinsèques pour la valeur maximale d'effacement en sortie (SEMAEM),
       le  nombre  de  structures  d'annulation  sur  le  système  (SEMMNU),  et le nombre maximal de structures
       d'annulation pour un processus.

BOGUES

       Quand un processus se termine, l'ensemble des structures 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 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  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.

       Dans les noyaux 2.6.x (x <= 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.

EXEMPLE

       Le bout de code suivant utilise 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.

           struct sembuf sops[2];
           int semid;

           /* Le code pour configurer semid est omis */

           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;

           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;

           if (semop(semid, sops, 2) == -1) {
               perror("semop");
               exit(EXIT_FAILURE);
           }

VOIR AUSSI

       clone(2), semctl(2), semget(2), sigaction(2), capabilities(7), sem_overview(7), svipc(7), time(7)

COLOPHON

       Cette page fait partie de la publication 3.65 du projet 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/.

TRADUCTION

       Depuis 2010, cette traduction est maintenue à l'aide de l'outil po4a <http://po4a.alioth.debian.org/> par
       l'équipe de traduction francophone au sein du projet perkamon <http://perkamon.alioth.debian.org/>.

       Christophe      Blaess      <http://www.blaess.fr/christophe/>      (1996-2003),       Alain       Portal
       <http://manpagesfr.free.fr/>  (2003-2006).  Julien  Cristau  et  l'équipe  francophone  de  traduction de
       Debian (2006-2009).

       Veuillez signaler toute erreur de traduction en écrivant à <debian-l10n-french@lists.debian.org>  ou  par
       un rapport de bogue sur le paquet manpages-fr.

       Vous pouvez toujours avoir accès à la version anglaise de ce document en utilisant la commande « man -L C
       <section> <page_de_man> ».