# pthread_mutex_consistent

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           pthread_mutex_consistent — mark state protected by robust mutex as
           consistent
    


## SYNOPSIS



           #include <pthread.h>
    
           int pthread_mutex_consistent(pthread_mutex_t *_mutex_);
    


## DESCRIPTION



           If _mutex_ is a robust mutex in an inconsistent state, the
           _pthread_mutex_consistent_() function can be used to mark the state
           protected by the mutex referenced by _mutex_ as consistent again.
    
           If an owner of a robust mutex terminates while holding the mutex,
           the mutex becomes inconsistent and the next thread that acquires
           the mutex lock shall be notified of the state by the return value
           **[EOWNERDEAD]**.  In this case, the mutex does not become normally
           usable again until the state is marked consistent.
    
           If the thread which acquired the mutex lock with the return value
           **[EOWNERDEAD]** terminates before calling either
           _pthread_mutex_consistent_() or _pthread_mutex_unlock_(), the next
           thread that acquires the mutex lock shall be notified about the
           state of the mutex by the return value **[EOWNERDEAD]**.
    
           The behavior is undefined if the value specified by the _mutex_
           argument to _pthread_mutex_consistent_() does not refer to an
           initialized mutex.
    


## RETURN VALUE



           Upon successful completion, the _pthread_mutex_consistent_()
           function shall return zero. Otherwise, an error value shall be
           returned to indicate the error.
    


## ERRORS



           The _pthread_mutex_consistent_() function shall fail if:
    
           **EINVAL** The mutex object referenced by _mutex_ is not robust or does
                  not protect an inconsistent state.
    
           These functions shall not return an error code of **[EINTR]**.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           The _pthread_mutex_consistent_() function is only responsible for
           notifying the implementation that the state protected by the mutex
           has been recovered and that normal operations with the mutex can
           be resumed. It is the responsibility of the application to recover
           the state so it can be reused. If the application is not able to
           perform the recovery, it can notify the implementation that the
           situation is unrecoverable by a call to _pthread_mutex_unlock_()
           without a prior call to _pthread_mutex_consistent_(), in which case
           subsequent threads that attempt to lock the mutex will fail to
           acquire the lock and be returned **[ENOTRECOVERABLE]**.
    


## RATIONALE



           If an implementation detects that the value specified by the _mutex_
           argument to _pthread_mutex_consistent_() does not refer to an
           initialized mutex, it is recommended that the function should fail
           and report an **[EINVAL]** error.
    


## FUTURE DIRECTIONS



           None.
    


* * *