Provided by: manpages-fr-dev_4.21.0-2_all bug

NOM

       pthread_mutexattr_getrobust,  pthread_mutexattr_setrobust  — Définir ou obtenir l'attribut
       de robustesse d'un objet d'attributs de mutex

BIBLIOTHÈQUE

       Bibliothèque de threads POSIX (libpthread, -lpthread)

SYNOPSIS

       #include <pthread.h>

       int pthread_mutexattr_getrobust(const pthread_mutexattr_t *attr,
                                       int *robustesse);
       int pthread_mutexattr_setrobust(pthread_mutexattr_t *attr,
                                       int robustesse);

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

       pthread_mutexattr_getrobust(), pthread_mutexattr_setrobust() :
           _POSIX_C_SOURCE >= 200809L

DESCRIPTION

       La  fonction  pthread_mutexattr_getrobust() place la valeur de l'attribut de robustesse de
       l'objet d'attributs de mutex auquel attr fait  référence  dans  *robustesse.  La  fonction
       pthread_mutexattr_setrobust()  définit à la valeur spécifiée dans *robustesse la valeur de
       l'attribut de robustesse de l'objet d'attributs de mutex auquel attr fait référence.

       L'attribut de robustesse définit le comportement du mutex  quand  le  thread  propriétaire
       finit sans déverrouiller le mutex. Les valeurs suivantes sont permises pour robustesse :

       PTHREAD_MUTEX_STALLED
              C'est  la  valeur  par  défaut  pour un objet d'attributs de mutex. Si un mutex est
              initialisé avec l'attribut PTHREAD_MUTEX_STALLED et si son propriétaire finit  sans
              le déverrouiller, le mutex demeure verrouillé ensuite et toute tentative ultérieure
              pour appeler pthread_mutex_lock(3) sur le mutex bloquera indéfiniment.

       PTHREAD_MUTEX_ROBUST
              Si  un  mutex  est  initialisé  avec  l'attribut  PTHREAD_MUTEX_ROBUST  et  si  son
              propriétaire  finit  sans le déverrouiller, toute tentative ultérieure pour appeler
              pthread_mutex_lock(3) sur ce mutex réussira et renverra  EOWNERDEAD  pour  indiquer
              que  le  propriétaire  d'origine  n'existe  plus  et  que le mutex est dans un état
              incohérent. Habituellement, après l'envoi de EOWNERDEAD,  le  propriétaire  suivant
              devrait  appeler  pthread_mutex_consistent(3)  sur le mutex acquis pour le rendre à
              nouveau cohérent avant de l'utiliser plus avant.

              Si le propriétaire suivant déverrouille le mutex avec pthread_mutex_unlock(3) avant
              de le rendre cohérent, le mutex demeurera inutilisable de façon permanente et toute
              tentative ultérieure pour le verrouiller avec pthread_mutex_lock(3)  échouera  avec
              l'erreur  ENOTRECOVERABLE.  pthread_mutex_destroy(3) est la seule opération permise
              sur un mutex dans cet état.

              Si le propriétaire suivant termine avant d'appeler pthread_mutex_consistent(3), les
              opérations   pthread_mutex_lock(3)  ultérieures  sur  ce  mutex  renverront  encore
              EOWNERDEAD.

       Veuillez   noter   que   l'argument   attr   de   pthread_mutexattr_getrobust()   et    de
       pthread_mutexattr_setrobust()   doit  faire  référence  à  l'objet  d'attributs  de  mutex
       initialisé par pthread_mutexattr_init(3), autrement le comportement est indéfini.

VALEUR RENVOYÉE

       En cas de réussite, ces fonctions renvoient 0 ; en cas d'erreur, elles renvoient  un  code
       d'erreur positif.

       Dans l'implémentation de la glibc, pthread_mutexattr_getrobust() renvoie toujours zéro.

ERREURS

       EINVAL Une  valeur  autre que PTHREAD_MUTEX_STALLED ou PTHREAD_MUTEX_ROBUST a été passée à
              pthread_mutexattr_setrobust().

VERSIONS

       pthread_mutexattr_getrobust() et pthread_mutexattr_setrobust() ont été  ajoutées  dans  la
       glibc version 2.12.

STANDARDS

       POSIX.1-2008.

NOTES

       Dans  l'implémentation  de  Linux,  lors  de  l'utilisation  de  mutex à processus partagé
       robustes, un  thread  en  attente  reçoit  également  la  notification  EOWNERDEAD  si  le
       propriétaire  d'un  mutex  robuste réalise une commande execve(2) sans avoir préalablement
       déverrouillé le mutex. POSIX.1 ne spécifie pas ce détail, mais  le  même  comportement  se
       produit aussi dans au moins quelques autres implémentations.

       Avant  l'ajout  à POSIX de pthread_mutexattr_getrobust() et pthread_mutexattr_setrobust(),
       la glibc définissait les fonctions non  standard  équivalentes  suivantes  si  _GNU_SOURCE
       était défini :

       [[obsolète]]
       int pthread_mutexattr_getrobust_np(const pthread_mutexattr_t *attr,
                                          int *robustesse);
       [[obsolète]]
       int pthread_mutexattr_setrobust_np(const pthread_mutexattr_t *attr,
                                          int robustesse);

       De  la  même  façon,  les  constantes  PTHREAD_MUTEX_STALLED_NP et PTHREAD_MUTEX_ROBUST_NP
       étaient également définies.

       Ces API propres à GNU, apparues  dans  la  glibc 2.4,  sont  à  présent  obsolètes  et  ne
       devraient  pas  être  utilisées dans de nouveaux programmes. Depuis la glibc 2.34, ces API
       sont marquées comme obsolètes.

EXEMPLES

       Le programme ci-dessous montre  l'utilisation  de  l'attribut  de  robustesse  d'un  objet
       d'attributs  de  mutex.  Dans  ce  programme,  un  thread  possédant le mutex s'interrompt
       prématurément sans déverrouiller le mutex. Le thread principal acquiert ensuite  le  mutex
       avec succès et reçoit l'erreur EOWNERDEAD après quoi il rend le mutex cohérent.

       La session d'interpréteur de commande suivante montre l'exécution de ce programme :

           $ ./a.out
           [original owner] Mise en place du verrou...
           [original owner] Verrouillé. Sortie sans déverrouillage.
           [main] Tentative de verrouillage du mutex robuste.
           [main] pthread_mutex_lock() renvoie EOWNERDEAD
           [main] Maintenant rendre le mutex cohérent
           [main] Le mutex est maintenant cohérent ; déverrouillage

   Source du programme
       #include <errno.h>
       #include <pthread.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <unistd.h>

       #define handle_error_en(en, msg) \
               do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

       static pthread_mutex_t mtx;

       static void *
       original_owner_thread(void *ptr)
       {
           printf("[original owner] Mise en place du verrou...\n");
           pthread_mutex_lock(&mtx);
           printf("[original owner] Verrouillé. Sortie sans déverrouillage.\n");
           pthread_exit(NULL);
       }

       int
       main(void)
       {
           pthread_t thr;
           pthread_mutexattr_t attr;
           int s;

           pthread_mutexattr_init(&attr);

           pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);

           pthread_mutex_init(&mtx, &attr);

           pthread_create(&thr, NULL, original_owner_thread, NULL);

           sleep(2);

           /* "original_owner_thread" devrait avoir quitté maintenant. */

           printf("[main] Tentative de verrouillage du mutex robuste.\n");
           s = pthread_mutex_lock(&mtx);
           if (s == EOWNERDEAD) {
               printf("[main] pthread_mutex_lock() renvoie EOWNERDEAD\n");
               printf("[main] Maintenant rendre le mutex cohérent\n");
               s = pthread_mutex_consistent(&mtx);
               if (s != 0)
                   handle_error_en(s, "pthread_mutex_consistent");
               printf("[main] Le mutex est maintenant cohérent ; déverrouillage\n");
               s = pthread_mutex_unlock(&mtx);
               if (s != 0)
                   handle_error_en(s, "pthread_mutex_unlock");

               exit(EXIT_SUCCESS);
           } else if (s == 0) {
               printf("[main] pthread_mutex_lock() réussit de façon inattendue\n");
               exit(EXIT_FAILURE);
           } else {
               printf("[main] pthread_mutex_lock() échoue de façon inattendue\n");
               handle_error_en(s, "pthread_mutex_lock");
           }
       }

VOIR AUSSI

       get_robust_list(2), set_robust_list(2), pthread_mutex_consistent(3),
       pthread_mutex_init(3), pthread_mutex_lock(3), pthreads(7)

TRADUCTION

       La traduction française de cette page de manuel a été créée par Christophe Blaess
       <https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry
       Vignaud <tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>,
       Jean-Philippe Guérard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-
       luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas Huriaux
       <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
       Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis
       Barbier <barbier@debian.org>, David Prévot <david@tilapin.org>, Frédéric Hantrais
       <fhantrais@gmail.com> et Jean-Pierre Giraud <jean-pierregiraud@neuf.fr>

       Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General
       Public License version 3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ concernant les
       conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
       message à ⟨debian-l10n-french@lists.debian.org⟩.