Hi all,

Now for a normal non-Robust mutex, like a normal mutex with type PTHREAD_MUTEX_RECURSIVE. I found it also will be add to robust_list in pthread in  __pthread_mutex_trylock_owner:
      volatile void *next = self->robust_list.head;      m->_m_next = next;
      m->_m_prev = &self->robust_list.head;
      if (next != &self->robust_list.head) *(volatile void *volatile *)
            ((char *)next - sizeof(void *)) = &m->_m_next;
      self->robust_list.head = &m->_m_next;
      self->robust_list.pending = 0;



However, it seems that for non-Robust mutexes added to the pthread robust_list, only when the pthread exits we will do a traversal wake-up operation in __pthread_exit:

      volatile void *volatile *rp;      while ((rp=self->robust_list.head) && rp != &self->robust_list.head) {
            pthread_mutex_t *m = (void *)((char *)rp
                  - offsetof(pthread_mutex_t, _m_next));
            int waiters = m->_m_waiters;
            int priv = (m->_m_type & 128) ^ 128;
            self->robust_list.pending = rp;
            self->robust_list.head = *rp;
            int cont = a_swap(&m->_m_lock, 0x40000000);
            self->robust_list.pending = 0;
            if (cont < 0 || waiters)
                  __wake(&amp;m-&gt;_m_lock, 1, priv);
      }





And taking a regular recursive mutex as an example, it will be added to the robust_list, if the thread ends but it is still not fully released, The robust_list still contains this mutex. We will swap the _m​_lock to owner died (0x40000000) and wake up one of the waiting thread. But due to this code in&nbsp;__pthread_mutex_trylock_owner：



      if (own == 0x3fffffff) return ENOTRECOVERABLE;
      if (own || (old &amp;&amp; !(type &amp; 4))) return EBUSY;



The waiting thread which has been waked up will nerver get the&nbsp;recursive mutex, the deadlock still occurred. So my question is, why do we need to add some non-Roubus mutexes, such as PTHREAD-MUTEX-RECURSIVE, to the robust list&nbsp;and try to do wake up in pthread​​_exit when the mutex isn't released by this thread.




I hope to receive your answer, thank you.

JinCheng Li






PS: This is a simple case for deadlock but musl still do something with robust_list such as waking up the waiters:
&nbsp;     pthread_mutex_t mutex;
void *dl_test1()
{
      pthread_mutex_lock(&amp;mutex);

      sleep(10);
      return 0;
}
      void *dl_test2()

{
      pthread_mutex_lock(&amp;mutex);

      return 0;
}
int main()
{
      void *res;

      pthread_mutexattr_t attr;

      pthread_mutexattr_init(&amp;attr);

      pthread_mutexattr_settype(&amp;attr, PTHREAD_MUTEX_RECURSIVE);

      pthread_mutex_init(&amp;mutex,&nbsp;&amp;attr);

      pthread_t thd1;

      pthread_t thd2;

      pthread_create(&amp;thd1, NULL, dl_test1, NULL);

      pthread_create(&amp;thd2, NULL, dl_test2, NULL);

      pthread_join(thd1, &amp;res);

      pthread_join(thd2, &amp;res);

      return 0;
}