# pthread_mutexattr_getprotocol

## 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_mutexattr_getprotocol, pthread_mutexattr_setprotocol — get
           and set the protocol attribute of the mutex attributes object
           (**REALTIME THREADS**)
    


## SYNOPSIS



           #include <pthread.h>
    
           int pthread_mutexattr_getprotocol(const pthread_mutexattr_t
               *restrict _attr_ , int *restrict _protocol_);
           int pthread_mutexattr_setprotocol(pthread_mutexattr_t *_attr_ ,
               int _protocol_);
    


## DESCRIPTION



           The _pthread_mutexattr_getprotocol_() and
           _pthread_mutexattr_setprotocol_() functions, respectively, shall get
           and set the protocol attribute of a mutex attributes object
           pointed to by _attr_ which was previously created by the function
           _pthread_mutexattr_init_().
    
           The _protocol_ attribute defines the protocol to be followed in
           utilizing mutexes.  The value of _protocol_ may be one of:
    
           PTHREAD_PRIO_INHERIT
           PTHREAD_PRIO_NONE
           PTHREAD_PRIO_PROTECT
    
           which are defined in the _< pthread.h>_ header. The default value of
           the attribute shall be PTHREAD_PRIO_NONE.
    
           When a thread owns a mutex with the PTHREAD_PRIO_NONE _protocol_
           attribute, its priority and scheduling shall not be affected by
           its mutex ownership.
    
           When a thread is blocking higher priority threads because of
           owning one or more robust mutexes with the PTHREAD_PRIO_INHERIT
           _protocol_ attribute, it shall execute at the higher of its priority
           or the priority of the highest priority thread waiting on any of
           the robust mutexes owned by this thread and initialized with this
           protocol.
    
           When a thread is blocking higher priority threads because of
           owning one or more non-robust mutexes with the
           PTHREAD_PRIO_INHERIT _protocol_ attribute, it shall execute at the
           higher of its priority or the priority of the highest priority
           thread waiting on any of the non-robust mutexes owned by this
           thread and initialized with this protocol.
    
           When a thread owns one or more robust mutexes initialized with the
           PTHREAD_PRIO_PROTECT protocol, it shall execute at the higher of
           its priority or the highest of the priority ceilings of all the
           robust mutexes owned by this thread and initialized with this
           attribute, regardless of whether other threads are blocked on any
           of these robust mutexes or not.
    
           When a thread owns one or more non-robust mutexes initialized with
           the PTHREAD_PRIO_PROTECT protocol, it shall execute at the higher
           of its priority or the highest of the priority ceilings of all the
           non-robust mutexes owned by this thread and initialized with this
           attribute, regardless of whether other threads are blocked on any
           of these non-robust mutexes or not.
    
           While a thread is holding a mutex which has been initialized with
           the PTHREAD_PRIO_INHERIT or PTHREAD_PRIO_PROTECT protocol
           attributes, it shall not be subject to being moved to the tail of
           the scheduling queue at its priority in the event that its
           original priority is changed, such as by a call to
           _sched_setparam_().  Likewise, when a thread unlocks a mutex that
           has been initialized with the PTHREAD_PRIO_INHERIT or
           PTHREAD_PRIO_PROTECT protocol attributes, it shall not be subject
           to being moved to the tail of the scheduling queue at its priority
           in the event that its original priority is changed.
    
           If a thread simultaneously owns several mutexes initialized with
           different protocols, it shall execute at the highest of the
           priorities that it would have obtained by each of these protocols.
    
           When a thread makes a call to _pthread_mutex_lock_(), the mutex was
           initialized with the protocol attribute having the value
           PTHREAD_PRIO_INHERIT, when the calling thread is blocked because
           the mutex is owned by another thread, that owner thread shall
           inherit the priority level of the calling thread as long as it
           continues to own the mutex. The implementation shall update its
           execution priority to the maximum of its assigned priority and all
           its inherited priorities.  Furthermore, if this owner thread
           itself becomes blocked on another mutex with the _protocol_
           attribute having the value PTHREAD_PRIO_INHERIT, the same priority
           inheritance effect shall be propagated to this other owner thread,
           in a recursive manner.
    
           The behavior is undefined if the value specified by the _attr_
           argument to _pthread_mutexattr_getprotocol_() or
           _pthread_mutexattr_setprotocol_() does not refer to an initialized
           mutex attributes object.
    


## RETURN VALUE



           Upon successful completion, the _pthread_mutexattr_getprotocol_()
           and _pthread_mutexattr_setprotocol_() functions shall return zero;
           otherwise, an error number shall be returned to indicate the
           error.
    


## ERRORS



           The _pthread_mutexattr_setprotocol_() function shall fail if:
    
           **ENOTSUP**
                  The value specified by _protocol_ is an unsupported value.
    
           The _pthread_mutexattr_getprotocol_() and
           _pthread_mutexattr_setprotocol_() functions may fail if:
    
           **EINVAL** The value specified by _protocol_ is invalid.
    
           **EPERM** The caller does not have the privilege to perform the
                  operation.
    
           These functions shall not return an error code of **[EINTR]**.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



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


## FUTURE DIRECTIONS



           None.
    


* * *