Provided by: manpages-fr-dev_4.27.0-1_all 
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
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.
STANDARDS
POSIX.1-2008.
HISTORIQUE
glibc 2.12. POSIX.1-2008.
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] Setting lock...\n");
pthread_mutex_lock(&mtx);
printf("[original owner] Locked. Now exiting without unlocking.\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" should have exited by now. */
printf("[main] Attempting to lock the robust mutex.\n");
s = pthread_mutex_lock(&mtx);
if (s == EOWNERDEAD) {
printf("[main] pthread_mutex_lock() returned EOWNERDEAD\n");
printf("[main] Now make the mutex consistent\n");
s = pthread_mutex_consistent(&mtx);
if (s != 0)
handle_error_en(s, "pthread_mutex_consistent");
printf("[main] Mutex is now consistent; unlocking\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() unexpectedly succeeded\n");
exit(EXIT_FAILURE);
} else {
printf("[main] pthread_mutex_lock() unexpectedly failed\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 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.
Pages du manuel de Linux 6.9.1 15 juin 2024 pthread_mutexattr_setrobust(3)