is recursive mutex lock? - c++

Question

I have a question about mutex_lock. My code does the following:
RIL_startEventLoop lock the mutex by pthread_mutex_lock(&s_startupMutex);
Call the thread eventLoop;
eventLoop locks the mutex by pthread_mutex_lock(&s_startupMutex);
eventLoop unlocks the mutex by pthread_mutex_unlock(&s_startupMutex);
RIL_startEventLoop unlocks the mutex by pthread_mutex_unlock(&s_startupMutex);
My understanding is the following (correct me if wrong):
Lock the mutex exclusively for this task. If the mutex is not available right now, it will sleep until it can get it.
The mutex must later on be released by the same task that acquired it. Recursive locking is not allowed.
Why can eventLoop lock same mutex that is not released by RIL_startEventLoop?
These 2 functions are in Ril.cpp:
RIL_startEventLoop(void) {
int ret;
pthread_attr_t attr;
#ifdef MTK_RIL
RIL_startRILProxys();
#endif /* MTK_RIL */
/* spin up eventLoop thread and wait for it to get started */
s_started = 0;
**pthread_mutex_lock(&s_startupMutex);**
pthread_attr_init (&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
ret = pthread_create(&s_tid_dispatch, &attr, **eventLoop**, NULL);
while (s_started == 0) {
pthread_cond_wait(&s_startupCond, &s_startupMutex);
}
**pthread_mutex_unlock(&s_startupMutex);**
if (ret < 0) {
LOGE("Failed to create dispatch thread errno:%d", errno);
return;
}
}
static void *
**eventLoop(void *param)** {
int ret;
int filedes[2];
ril_event_init();
**pthread_mutex_lock(&s_startupMutex);**
s_started = 1;
pthread_cond_broadcast(&s_startupCond);
**pthread_mutex_unlock(&s_startupMutex);**
ret = pipe(filedes);
if (ret < 0) {
LOGE("Error in pipe() errno:%d", errno);
return NULL;
}
s_fdWakeupRead = filedes[0];
s_fdWakeupWrite = filedes[1];
fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK);
ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true,
processWakeupCallback, NULL);
rilEventAddWakeup (&s_wakeupfd_event);
// Only returns on error
ril_event_loop();
LOGE ("error in event_loop_base errno:%d", errno);
return NULL;
}

Answer 1

Because the call to pthread_cond_wait() releases the mutex.
pthread_cond_wait() does this in an atomic fashion.
Release the mutex (It must already be acquired)
Suspend the thread until the condition is signalled
Acquires the mutex