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);

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

#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 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.