Initialize robust_list head for pthread_t structure. Fixes a crash with locking recursive mutexes, #5038. Clean up unused mutex control field for old Emscripten specific mutex implementation (removed from use since d86e9b3)

Author: juj

src/library_pthread.js

@@ -579,6 +579,10 @@ var LibraryPThread = {
     // structure is 'alive'.
     {{{ makeSetValue('threadInfoStruct', C_STRUCTS.pthread.self, 'threadInfoStruct', 'i32') }}};
 
+    // pthread struct robust_list head should point to itself.
+    var headPtr = threadInfoStruct + {{{ C_STRUCTS.pthread.robust_list }}};
+    {{{ makeSetValue('headPtr', 0, 'headPtr', 'i32') }}};
+
     var threadParams = {
       stackBase: stackBase,
       stackSize: stackSize,

src/struct_info.compiled.json

@@ -1484,6 +1484,7 @@
               "stack",
               "stack_size",
               "attr",
+              "robust_list",
               "tid",
               "pid",
               "canceldisable",

src/struct_info.json

@@ -94,13 +94,7 @@ typedef struct { union { int __i[10]; volatile int __vi[10]; unsigned __s[10]; }
 #endif
 
 #if defined(__NEED_pthread_mutex_t) && !defined(__DEFINED_pthread_mutex_t)
-#ifdef __EMSCRIPTEN__
-// For mutex implementation in Emscripten, need to use an extra eighth control field
-// to hold a temporary futex wait & wake location, designated as mutex->_m_addr.
-typedef struct { union { int __i[8]; volatile int __vi[8]; volatile void *__p[8]; } __u; } pthread_mutex_t;
-#else
 typedef struct { union { int __i[7]; volatile int __vi[7]; volatile void *__p[7]; } __u; } pthread_mutex_t;
-#endif
 typedef pthread_mutex_t mtx_t;
 #define __DEFINED_pthread_mutex_t
 #endif

system/lib/libc/musl/arch/emscripten/bits/alltypes.h

@@ -84,9 +84,6 @@ struct __timer {
 #define _m_prev __u.__p[3]
 #define _m_next __u.__p[4]
 #define _m_count __u.__i[5]
-#ifdef __EMSCRIPTEN__
-#define _m_addr __u.__i[7]
-#endif
 #define _c_shared __u.__p[0]
 #define _c_seq __u.__vi[2]
 #define _c_waiters __u.__vi[3]

system/lib/libc/musl/src/internal/pthread_impl.h

@@ -70,130 +70,6 @@ double _pthread_msecs_until(const struct timespec *restrict at)
 	return msecs;
 }
 
-#if 0
-int pthread_mutex_lock(pthread_mutex_t *mutex)
-{
-	if (!mutex) return EINVAL;
-	assert(pthread_self() != 0);
-	assert(pthread_self()->tid != 0);
-
-	if (mutex->_m_lock == pthread_self()->tid) {
-		if ((mutex->_m_type&3) == PTHREAD_MUTEX_RECURSIVE) {
-			if ((unsigned)mutex->_m_count >= INT_MAX) return EAGAIN;
-			++mutex->_m_count;
-			return 0;
-		} else if ((mutex->_m_type&3) == PTHREAD_MUTEX_ERRORCHECK) {
-			return EDEADLK;
-		}
-	}
-
-	int threadCancelType = _pthread_getcanceltype();
-
-	int c = emscripten_atomic_cas_u32(&mutex->_m_addr, 0, 1);
-	if (c != 0) {
-		do {
-			if (c == 2 || emscripten_atomic_cas_u32(&mutex->_m_addr, 1, 2) != 0) {
-				double msecs = INFINITY;
-				if (threadCancelType == PTHREAD_CANCEL_ASYNCHRONOUS) {
-					// Sleep in small slices so that we can test cancellation to honor PTHREAD_CANCEL_ASYNCHRONOUS.
-					__pthread_testcancel();
-					msecs = 100;
-				}
-				emscripten_futex_wait(&mutex->_m_addr, 2, msecs);
-			}
-		} while((c = emscripten_atomic_cas_u32(&mutex->_m_addr, 0, 2)));
-	}
-
-	__pthread_mutex_locked(mutex);
-	return 0;
-}
-
-int pthread_mutex_unlock(pthread_mutex_t *mutex)
-{
-	if (!mutex) return EINVAL;
-	assert(pthread_self() != 0);
-
-	if (mutex->_m_type != PTHREAD_MUTEX_NORMAL) {
-		if (mutex->_m_lock != pthread_self()->tid) return EPERM;
-		if ((mutex->_m_type&3) == PTHREAD_MUTEX_RECURSIVE && mutex->_m_count) {
-			--mutex->_m_count;
-			return 0;
-		}
-	}
-
-	mutex->_m_lock = 0;
-	if (emscripten_atomic_sub_u32((uint32_t*)&mutex->_m_addr, 1) != 1)
-	{
-		emscripten_atomic_store_u32((uint32_t*)&mutex->_m_addr, 0);
-		emscripten_futex_wake((uint32_t*)&mutex->_m_addr, 1);
-	}
-	return 0;
-}
-
-int pthread_mutex_trylock(pthread_mutex_t *mutex)
-{
-	if (!mutex) return EINVAL;
-	if (mutex->_m_lock == pthread_self()->tid) {
-		if ((mutex->_m_type&3) == PTHREAD_MUTEX_RECURSIVE) {
-			if ((unsigned)mutex->_m_count >= INT_MAX) return EAGAIN;
-			++mutex->_m_count;
-			return 0;
-		} else if ((mutex->_m_type&3) == PTHREAD_MUTEX_ERRORCHECK) {
-			return EDEADLK;
-		}
-	}
-
-	if (emscripten_atomic_cas_u32(&mutex->_m_addr, 0, 1) == 0) {
-		__pthread_mutex_locked(mutex);
-		return 0;
-	}
-	else
-		return EBUSY;
-}
-
-int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex, const struct timespec *restrict at)
-{
-	if (!mutex || !at) return EINVAL;
-	if (mutex->_m_lock == pthread_self()->tid) {
-		if ((mutex->_m_type&3) == PTHREAD_MUTEX_RECURSIVE) {
-			if ((unsigned)mutex->_m_count >= INT_MAX) return EAGAIN;
-			++mutex->_m_count;
-			return 0;
-		} else if ((mutex->_m_type&3) == PTHREAD_MUTEX_ERRORCHECK) {
-			return EDEADLK;
-		}
-	}
-
-	int threadCancelType = _pthread_getcanceltype();
-	int c = emscripten_atomic_cas_u32(&mutex->_m_addr, 0, 1);
-	if (c != 0) {
-		do {
-			if (c == 2 || emscripten_atomic_cas_u32(&mutex->_m_addr, 1, 2) != 0)
-			{
-				if (at->tv_nsec < 0 || at->tv_nsec >= 1000000000) return EINVAL;
-				double msecs = _pthread_msecs_until(at);
-				if (msecs <= 0) return ETIMEDOUT;
-
-				// Sleep in small slices if thread type is PTHREAD_CANCEL_ASYNCHRONOUS
-				// so that we can honor PTHREAD_CANCEL_ASYNCHRONOUS requests.
-				if (threadCancelType == PTHREAD_CANCEL_ASYNCHRONOUS) {
-					__pthread_testcancel();
-					if (msecs > 100) msecs = 100;
-				}
-				int ret = emscripten_futex_wait(&mutex->_m_addr, 2, msecs);
-				if (ret == 0) break;
-				else if (threadCancelType != PTHREAD_CANCEL_ASYNCHRONOUS || _pthread_msecs_until(at) <= 0) {
-					return ETIMEDOUT;
-				}
-			}
-		} while((c = emscripten_atomic_cas_u32(&mutex->_m_addr, 0, 2)));
-	}
-
-	__pthread_mutex_locked(mutex);
-	return 0;
-}
-#endif
-
 int sched_get_priority_max(int policy)
 {
 	// Web workers do not actually support prioritizing threads,

system/lib/pthread/library_pthread.c

@@ -90,7 +90,10 @@ void WaitToJoin()
 
 int main()
 {
-	pthread_mutex_init(&lock, NULL);
+	pthread_mutexattr_t attr;
+	pthread_mutexattr_init(&attr);
+	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+	pthread_mutex_init(&lock, &attr);
 
 	if (emscripten_has_threading_support()) {
 		// Create new threads in parallel.