pthread_mutexattr_setrobust(3) Library Functions Manual NOM pthread_mutexattr_getrobust, pthread_mutexattr_setrobust -- Definir ou obtenir l'attribut de robustesse d'un objet d'attributs de mutex BIBLIOTHEQUE Bibliotheque de threads POSIX (libpthread, -lpthread) SYNOPSIS #include 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 fonctionnalites 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 reference dans *robustesse. La fonction pthread_mutexattr_setrobust() definit a la valeur specifiee dans *robustesse la valeur de l'attribut de robustesse de l'objet d'attributs de mutex auquel attr fait reference. L'attribut de robustesse definit le comportement du mutex quand le thread proprietaire finit sans deverrouiller le mutex. Les valeurs suivantes sont permises pour robustesse : PTHREAD_MUTEX_STALLED C'est la valeur par defaut pour un objet d'attributs de mutex. Si un mutex est initialise avec l'attribut PTHREAD_MUTEX_STALLED et si son proprietaire finit sans le deverrouiller, le mutex demeure verrouille ensuite et toute tentative ulterieure pour appeler pthread_mutex_lock(3) sur le mutex bloquera indefiniment. PTHREAD_MUTEX_ROBUST Si un mutex est initialise avec l'attribut PTHREAD_MUTEX_ROBUST et si son proprietaire finit sans le deverrouiller, toute tentative ulterieure pour appeler pthread_mutex_lock(3) sur ce mutex reussira et renverra EOWNERDEAD pour indiquer que le proprietaire d'origine n'existe plus et que le mutex est dans un etat incoherent. Habituellement, apres l'envoi de EOWNERDEAD, le proprietaire suivant devrait appeler pthread_mutex_consistent(3) sur le mutex acquis pour le rendre a nouveau coherent avant de l'utiliser plus avant. Si le proprietaire suivant deverrouille le mutex avec pthread_mutex_unlock(3) avant de le rendre coherent, le mutex demeurera inutilisable de facon permanente et toute tentative ulterieure pour le verrouiller avec pthread_mutex_lock(3) echouera avec l'erreur ENOTRECOVERABLE. pthread_mutex_destroy(3) est la seule operation permise sur un mutex dans cet etat. Si le proprietaire suivant termine avant d'appeler pthread_mutex_consistent(3), les operations pthread_mutex_lock(3) ulterieures sur ce mutex renverront encore EOWNERDEAD. Veuillez noter que l'argument attr de pthread_mutexattr_getrobust() et de pthread_mutexattr_setrobust() doit faire reference a l'objet d'attributs de mutex initialise par pthread_mutexattr_init(3), autrement le comportement est indefini. VALEUR RENVOYEE En cas de reussite, ces fonctions renvoient 0 ; en cas d'erreur, elles renvoient un code d'erreur positif. Dans l'implementation de la glibc, pthread_mutexattr_getrobust() renvoie toujours zero. ERREURS EINVAL Une valeur autre que PTHREAD_MUTEX_STALLED ou PTHREAD_MUTEX_ROBUST a ete passee a pthread_mutexattr_setrobust(). VERSIONS Dans l'implementation de Linux, lors de l'utilisation de mutex a processus partage robustes, un thread en attente recoit egalement la notification EOWNERDEAD si le proprietaire d'un mutex robuste realise une commande execve(2) sans avoir prealablement deverrouille le mutex. POSIX.1 ne specifie pas ce detail, mais le meme comportement se produit aussi dans au moins quelques autres implementations. STANDARDS POSIX.1-2008. HISTORIQUE glibc 2.12. POSIX.1-2008. Avant l'ajout a POSIX de pthread_mutexattr_getrobust() et pthread_mutexattr_setrobust(), la glibc definissait les fonctions non standard equivalentes suivantes si _GNU_SOURCE etait defini : [[obsolete]] int pthread_mutexattr_getrobust_np(const pthread_mutexattr_t *attr, int *robustesse); [[obsolete]] int pthread_mutexattr_setrobust_np(const pthread_mutexattr_t *attr, int robustesse); De la meme facon, les constantes PTHREAD_MUTEX_STALLED_NP et PTHREAD_MUTEX_ROBUST_NP etaient egalement definies. Ces API propres a GNU, apparues dans la glibc 2.4, sont a present obsoletes et ne devraient pas etre utilisees dans de nouveaux programmes. Depuis la glibc 2.34, ces API sont marquees comme obsoletes. 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 possedant le mutex s'interrompt prematurement sans deverrouiller le mutex. Le thread principal acquiert ensuite le mutex avec succes et recoit l'erreur EOWNERDEAD apres quoi il rend le mutex coherent. La session d'interpreteur de commande suivante montre l'execution de ce programme : $ ./a.out [original owner] Mise en place du verrou... [original owner] Verrouille. Sortie sans deverrouillage. [main] Tentative de verrouillage du mutex robuste. [main] pthread_mutex_lock() renvoie EOWNERDEAD [main] Maintenant rendre le mutex coherent [main] Le mutex est maintenant coherent ; deverrouillage Source du programme #include #include #include #include #include #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] Verrouille. Sortie sans deverrouillage.\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 quitte 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 coherent\n"); s = pthread_mutex_consistent(&mtx); if (s != 0) handle_error_en(s, "pthread_mutex_consistent"); printf("[main] Le mutex est maintenant coherent ; deverrouillage\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() reussit de facon inattendue\n"); exit(EXIT_FAILURE); } else { printf("[main] pthread_mutex_lock() echoue de facon 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 francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot , Frederic Hantrais et Jean- Pierre Giraud Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.06 31 octobre 2023 pthread_mutexattr_setrobust(3)