Provided by: manpages-fr-dev_4.23.1-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] 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⟩.