Provided by: manpages-dev_6.8-2_all 
NAME
pthread_mutexattr_getrobust, pthread_mutexattr_setrobust - get and set the robustness attribute of a
mutex attributes object
LIBRARY
POSIX threads library (libpthread, -lpthread)
SYNOPSIS
#include <pthread.h>
int pthread_mutexattr_getrobust(const pthread_mutexattr_t *attr,
int *robustness);
int pthread_mutexattr_setrobust(pthread_mutexattr_t *attr,
int robustness);
Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
pthread_mutexattr_getrobust(), pthread_mutexattr_setrobust():
_POSIX_C_SOURCE >= 200809L
DESCRIPTION
The pthread_mutexattr_getrobust() function places the value of the robustness attribute of the mutex
attributes object referred to by attr in *robustness. The pthread_mutexattr_setrobust() function sets
the value of the robustness attribute of the mutex attributes object referred to by attr to the value
specified in *robustness.
The robustness attribute specifies the behavior of the mutex when the owning thread dies without
unlocking the mutex. The following values are valid for robustness:
PTHREAD_MUTEX_STALLED
This is the default value for a mutex attributes object. If a mutex is initialized with the
PTHREAD_MUTEX_STALLED attribute and its owner dies without unlocking it, the mutex remains locked
afterwards and any future attempts to call pthread_mutex_lock(3) on the mutex will block
indefinitely.
PTHREAD_MUTEX_ROBUST
If a mutex is initialized with the PTHREAD_MUTEX_ROBUST attribute and its owner dies without
unlocking it, any future attempts to call pthread_mutex_lock(3) on this mutex will succeed and
return EOWNERDEAD to indicate that the original owner no longer exists and the mutex is in an
inconsistent state. Usually after EOWNERDEAD is returned, the next owner should call
pthread_mutex_consistent(3) on the acquired mutex to make it consistent again before using it any
further.
If the next owner unlocks the mutex using pthread_mutex_unlock(3) before making it consistent, the
mutex will be permanently unusable and any subsequent attempts to lock it using
pthread_mutex_lock(3) will fail with the error ENOTRECOVERABLE. The only permitted operation on
such a mutex is pthread_mutex_destroy(3).
If the next owner terminates before calling pthread_mutex_consistent(3), further
pthread_mutex_lock(3) operations on this mutex will still return EOWNERDEAD.
Note that the attr argument of pthread_mutexattr_getrobust() and pthread_mutexattr_setrobust() should
refer to a mutex attributes object that was initialized by pthread_mutexattr_init(3), otherwise the
behavior is undefined.
RETURN VALUE
On success, these functions return 0. On error, they return a positive error number.
In the glibc implementation, pthread_mutexattr_getrobust() always return zero.
ERRORS
EINVAL A value other than PTHREAD_MUTEX_STALLED or PTHREAD_MUTEX_ROBUST was passed to
pthread_mutexattr_setrobust().
VERSIONS
In the Linux implementation, when using process-shared robust mutexes, a waiting thread also receives the
EOWNERDEAD notification if the owner of a robust mutex performs an execve(2) without first unlocking the
mutex. POSIX.1 does not specify this detail, but the same behavior also occurs in at least some other
implementations.
STANDARDS
POSIX.1-2008.
HISTORY
glibc 2.12. POSIX.1-2008.
Before the addition of pthread_mutexattr_getrobust() and pthread_mutexattr_setrobust() to POSIX, glibc
defined the following equivalent nonstandard functions if _GNU_SOURCE was defined:
[[deprecated]]
int pthread_mutexattr_getrobust_np(const pthread_mutexattr_t *attr,
int *robustness);
[[deprecated]]
int pthread_mutexattr_setrobust_np(const pthread_mutexattr_t *attr,
int robustness);
Correspondingly, the constants PTHREAD_MUTEX_STALLED_NP and PTHREAD_MUTEX_ROBUST_NP were also defined.
These GNU-specific APIs, which first appeared in glibc 2.4, are nowadays obsolete and should not be used
in new programs; since glibc 2.34 these APIs are marked as deprecated.
EXAMPLES
The program below demonstrates the use of the robustness attribute of a mutex attributes object. In this
program, a thread holding the mutex dies prematurely without unlocking the mutex. The main thread
subsequently acquires the mutex successfully and gets the error EOWNERDEAD, after which it makes the
mutex consistent.
The following shell session shows what we see when running this program:
$ ./a.out
[original owner] Setting lock...
[original owner] Locked. Now exiting without unlocking.
[main] Attempting to lock the robust mutex.
[main] pthread_mutex_lock() returned EOWNERDEAD
[main] Now make the mutex consistent
[main] Mutex is now consistent; unlocking
Program source
#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");
}
}
SEE ALSO
get_robust_list(2), set_robust_list(2), pthread_mutex_consistent(3), pthread_mutex_init(3),
pthread_mutex_lock(3), pthreads(7)