.\" -*- coding: UTF-8 -*- .\" Copyright (c) 2017, Yubin Ruan .\" and Copyright (c) 2017, Michael Kerrisk .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH pthread_mutexattr_setrobust 3 "2 mai 2024" "Pages du manuel de Linux 6.8" .SH NOM pthread_mutexattr_getrobust, pthread_mutexattr_setrobust — Définir ou obtenir l'attribut de robustesse d'un objet d'attributs de mutex .SH BIBLIOTHÈQUE Bibliothèque de threads POSIX (\fIlibpthread\fP, \fI\-lpthread\fP) .SH SYNOPSIS .nf \fB#include \fP .P \fBint pthread_mutexattr_getrobust(const pthread_mutexattr_t *\fP\fIattr\fP\fB,\fP \fB int *\fP\fIrobustesse\fP\fB);\fP \fBint pthread_mutexattr_setrobust(pthread_mutexattr_t *\fP\fIattr\fP\fB,\fP \fB int \fP\fIrobustesse\fP\fB);\fP .fi .P .RS -4 Exigences de macros de test de fonctionnalités pour la glibc (consulter \fBfeature_test_macros\fP(7)) : .RE .P \fBpthread_mutexattr_getrobust\fP(), \fBpthread_mutexattr_setrobust\fP() : .nf .\" FIXME . .\" But see https://sourceware.org/bugzilla/show_bug.cgi?id=22125 _POSIX_C_SOURCE >= 200809L .fi .SH DESCRIPTION La fonction \fBpthread_mutexattr_getrobust\fP() place la valeur de l'attribut de robustesse de l'objet d'attributs de mutex auquel \fIattr\fP fait référence dans \fI*robustesse\fP. La fonction \fBpthread_mutexattr_setrobust\fP() définit à la valeur spécifiée dans \fI*robustesse\fP la valeur de l'attribut de robustesse de l'objet d'attributs de mutex auquel \fIattr\fP fait référence. .P 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 \fIrobustesse\fP : .TP \fBPTHREAD_MUTEX_STALLED\fP C'est la valeur par défaut pour un objet d'attributs de mutex. Si un mutex est initialisé avec l'attribut \fBPTHREAD_MUTEX_STALLED\fP et si son propriétaire finit sans le déverrouiller, le mutex demeure verrouillé ensuite et toute tentative ultérieure pour appeler \fBpthread_mutex_lock\fP(3) sur le mutex bloquera indéfiniment. .TP \fBPTHREAD_MUTEX_ROBUST\fP Si un mutex est initialisé avec l'attribut \fBPTHREAD_MUTEX_ROBUST\fP et si son propriétaire finit sans le déverrouiller, toute tentative ultérieure pour appeler \fBpthread_mutex_lock\fP(3) sur ce mutex réussira et renverra \fBEOWNERDEAD\fP 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 \fBEOWNERDEAD\fP, le propriétaire suivant devrait appeler \fBpthread_mutex_consistent\fP(3) sur le mutex acquis pour le rendre à nouveau cohérent avant de l'utiliser plus avant. .IP Si le propriétaire suivant déverrouille le mutex avec \fBpthread_mutex_unlock\fP(3) avant de le rendre cohérent, le mutex demeurera inutilisable de façon permanente et toute tentative ultérieure pour le verrouiller avec \fBpthread_mutex_lock\fP(3) échouera avec l'erreur \fBENOTRECOVERABLE\fP. \fBpthread_mutex_destroy\fP(3) est la seule opération permise sur un mutex dans cet état. .IP Si le propriétaire suivant termine avant d'appeler \fBpthread_mutex_consistent\fP(3), les opérations \fBpthread_mutex_lock\fP(3) ultérieures sur ce mutex renverront encore \fBEOWNERDEAD\fP. .P Veuillez noter que l'argument \fIattr\fP de \fBpthread_mutexattr_getrobust\fP() et de \fBpthread_mutexattr_setrobust\fP() doit faire référence à l'objet d'attributs de mutex initialisé par \fBpthread_mutexattr_init\fP(3), autrement le comportement est indéfini. .SH "VALEUR RENVOYÉE" En cas de réussite, ces fonctions renvoient \fB0\fP ; en cas d'erreur, elles renvoient un code d'erreur positif. .P Dans l'implémentation de la glibc, \fBpthread_mutexattr_getrobust\fP() renvoie toujours zéro. .SH ERREURS .TP \fBEINVAL\fP Une valeur autre que \fBPTHREAD_MUTEX_STALLED\fP ou \fBPTHREAD_MUTEX_ROBUST\fP a été passée à \fBpthread_mutexattr_setrobust\fP(). .SH VERSIONS .\" E.g., Solaris, according to its manual page Dans l'implémentation de Linux, lors de l'utilisation de mutex à processus partagé robustes, un thread en attente reçoit également la notification \fBEOWNERDEAD\fP si le propriétaire d'un mutex robuste réalise une commande \fBexecve\fP(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. .SH STANDARDS POSIX.1\-2008. .SH HISTORIQUE glibc 2.12. POSIX.1\-2008. .P Avant l'ajout à POSIX de \fBpthread_mutexattr_getrobust\fP() et \fBpthread_mutexattr_setrobust\fP(), la glibc définissait les fonctions non standard équivalentes suivantes si \fB_GNU_SOURCE\fP était défini : .P .nf \fB[[obsolète]]\fP \fBint pthread_mutexattr_getrobust_np(const pthread_mutexattr_t *\fP\fIattr\fP\fB,\fP \fB int *\fP\fIrobustesse\fP\fB);\fP \fB[[obsolète]]\fP \fBint pthread_mutexattr_setrobust_np(const pthread_mutexattr_t *\fP\fIattr\fP\fB,\fP \fB int \fP\fIrobustesse\fP\fB);\fP .fi .P De la même façon, les constantes \fBPTHREAD_MUTEX_STALLED_NP\fP et \fBPTHREAD_MUTEX_ROBUST_NP\fP étaient également définies. .P 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. .SH 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 \fBEOWNERDEAD\fP après quoi il rend le mutex cohérent. .P La session d'interpréteur de commande suivante montre l'exécution de ce programme : .P .in +4n .EX $ \fB./a.out\fP [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 .EE .in .SS "Source du programme" .\" SRC BEGIN (pthread_mutexattr_setrobust.c) .EX #include #include #include #include #include \& #define handle_error_en(en, msg) \e 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...\en"); pthread_mutex_lock(&mtx); printf("[original owner] Verrouillé. Sortie sans déverrouillage.\en"); 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.\en"); s = pthread_mutex_lock(&mtx); if (s == EOWNERDEAD) { printf("[main] pthread_mutex_lock() renvoie EOWNERDEAD\en"); printf("[main] Maintenant rendre le mutex cohérent\en"); 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\en"); 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\en"); exit(EXIT_FAILURE); } else { printf("[main] pthread_mutex_lock() échoue de façon inattendue\en"); handle_error_en(s, "pthread_mutex_lock"); } } .EE .\" SRC END .SH "VOIR AUSSI" .ad l .nh \fBget_robust_list\fP(2), \fBset_robust_list\fP(2), \fBpthread_mutex_consistent\fP(3), \fBpthread_mutex_init\fP(3), \fBpthread_mutex_lock\fP(3), \fBpthreads\fP(7) .PP .SH TRADUCTION La traduction française de cette page de manuel a été créée par Christophe Blaess , Stéphan Rafin , Thierry Vignaud , François Micaux, Alain Portal , Jean-Philippe Guérard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas François , Florentin Duneau , Simon Paillard , Denis Barbier , David Prévot , Frédéric Hantrais et Jean-Pierre Giraud . .PP Cette traduction est une documentation libre ; veuillez vous reporter à la .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3 .UE concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE. .PP Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à .MT debian-l10n-french@lists.debian.org .ME .