Handle error from pthread_cond_wait()

[maxsharabayko]

pthread_cond_wait() can report an error. The wrapper ignores it. Throw an exception similar to C++11 condition_variable. See this comment: link.

Extracted from #1103.

[ethouris]

This is the excerpt from the manpage for pthread_cond_wait (cut off parts that refer to pthread_cond_timedwait only):

ERRORS
       These functions shall fail if:

       ENOTRECOVERABLE
              The state protected by the mutex is not recoverable.

       EOWNERDEAD
              The  mutex  is  a robust mutex and the process containing the previous owning thread terminated while holding the mutex lock. The mutex lock shall be acquired by the calling thread and it is up to the new owner to make the
              state consistent.

       EPERM  The mutex type is PTHREAD_MUTEX_ERRORCHECK or the mutex is a robust mutex, and the current thread does not own the mutex.

Every error in this list concerns exclusively the "robust mutex", which isn't the default type of the mutex and must be set so explicitly, nor do we use such kind of mutex in the POSIX wrapper. It's not explicitly described by ENOTRECOVERABLE, but this same error is described more thoroughyl in the manpage of pthread_mutexattr_setrobust:

       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.

In result, every error in the list may only be reported in case of using a robust mutex associated with the condition here. Which means that in the current implementation pthread_cond_wait doesn't report any errors. Of course, it could still report errors if you pass NULL for mutex or condition, but it is believed that the POSIX wrapper is taking care of it earlier.

It might be a good idea to implement robust mutexes as a special "robust mode" enabled at compile time to try to reproduce any thread errors - such mutexes are armed in extra bug tracing abilities, such as report error when trying to lock a mutex that a dying thread has left locked. But that's for another activity.

[maxsharabayko]

Closing as nothing to do according to the analysis by @ethouris:

... in the current implementation pthread_cond_wait doesn't report any errors. Of course, it could still report errors if you pass NULL for mutex or condition, but it is believed that the POSIX wrapper is taking care of it earlier.