change locks to avoid capturing pthread_self value

It was observed in TSAN that we might get incorrectly locked mutexes
when this code is inlined, due to pthread_self being normally marked
const.

(cherry-picked from 95fac8f92dZ)

Author: vtjnash

src/jltypes.c

@@ -2623,13 +2623,8 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_svecset(jl_methtable_type->types, 4, jl_long_type);
     jl_svecset(jl_methtable_type->types, 6, jl_module_type);
     jl_svecset(jl_methtable_type->types, 7, jl_array_any_type);
-#ifdef __LP64__
-    jl_svecset(jl_methtable_type->types, 8, jl_int64_type); // unsigned long
-    jl_svecset(jl_methtable_type->types, 9, jl_int64_type); // uint32_t plus alignment
-#else
-    jl_svecset(jl_methtable_type->types, 8, jl_int32_type); // DWORD
-    jl_svecset(jl_methtable_type->types, 9, jl_int32_type); // uint32_t
-#endif
+    jl_svecset(jl_methtable_type->types, 8, jl_long_type); // jl_task_t*
+    jl_svecset(jl_methtable_type->types, 9, jl_long_type); // uint32_t plus alignment
     jl_svecset(jl_methtable_type->types, 10, jl_uint8_type);
     jl_svecset(jl_methtable_type->types, 11, jl_uint8_type);
     jl_svecset(jl_method_type->types, 12, jl_method_instance_type);

src/julia_threads.h

@@ -97,7 +97,7 @@ typedef pthread_t jl_thread_t;
 
 // Recursive spin lock
 typedef struct {
-    volatile jl_thread_t owner;
+    struct _jl_task_t *owner;
     uint32_t count;
 } jl_mutex_t;
 

src/locks.h

@@ -11,29 +11,27 @@ extern "C" {
 
 // Lock acquire and release primitives
 
-// JL_LOCK and jl_mutex_lock are GC safe points while JL_LOCK_NOGC
-// and jl_mutex_lock_nogc are not.
+// JL_LOCK and jl_mutex_lock are GC safe points, use uv_mutex_t if that is not desired.
 // Always use JL_LOCK unless no one holding the lock can trigger a GC or GC
-// safepoint. JL_LOCK_NOGC should only be needed for GC internal locks.
+// safepoint. uv_mutex_t should only be needed for GC internal locks.
 // The JL_LOCK* and JL_UNLOCK* macros are no-op for non-threading build
 // while the jl_mutex_* functions are always locking and unlocking the locks.
 
 static inline void jl_mutex_wait(jl_mutex_t *lock, int safepoint)
 {
-    jl_thread_t self = jl_thread_self();
-    jl_thread_t owner = jl_atomic_load_relaxed(&lock->owner);
-    jl_task_t *ct = jl_current_task;
+    jl_task_t *self = jl_current_task;
+    jl_task_t *owner = jl_atomic_load_relaxed(&lock->owner);
     if (owner == self) {
         lock->count++;
         return;
     }
     while (1) {
-        if (owner == 0 && jl_atomic_cmpswap(&lock->owner, &owner, self)) {
+        if (owner == NULL && jl_atomic_cmpswap(&lock->owner, &owner, self)) {
             lock->count = 1;
             return;
         }
         if (safepoint) {
-            jl_gc_safepoint_(ct->ptls);
+            jl_gc_safepoint_(self->ptls);
         }
         jl_cpu_pause();
         owner = jl_atomic_load_relaxed(&lock->owner);
@@ -90,13 +88,13 @@ static inline void jl_mutex_lock(jl_mutex_t *lock)
 
 static inline int jl_mutex_trylock_nogc(jl_mutex_t *lock)
 {
-    jl_thread_t self = jl_thread_self();
-    jl_thread_t owner = jl_atomic_load_acquire(&lock->owner);
+    jl_task_t *self = jl_current_task;
+    jl_task_t *owner = jl_atomic_load_acquire(&lock->owner);
     if (owner == self) {
         lock->count++;
         return 1;
     }
-    if (owner == 0 && jl_atomic_cmpswap(&lock->owner, &owner, self)) {
+    if (owner == NULL && jl_atomic_cmpswap(&lock->owner, &owner, self)) {
         lock->count = 1;
         return 1;
     }
@@ -115,10 +113,10 @@ static inline int jl_mutex_trylock(jl_mutex_t *lock)
 static inline void jl_mutex_unlock_nogc(jl_mutex_t *lock) JL_NOTSAFEPOINT
 {
 #ifndef __clang_analyzer__
-    assert(lock->owner == jl_thread_self() &&
+    assert(jl_atomic_load_relaxed(&lock->owner) == jl_current_task &&
            "Unlocking a lock in a different thread.");
     if (--lock->count == 0) {
-        jl_atomic_store_release(&lock->owner, 0);
+        jl_atomic_store_release(&lock->owner, (jl_task_t*)NULL);
         jl_cpu_wake();
     }
 #endif
@@ -129,14 +127,14 @@ static inline void jl_mutex_unlock(jl_mutex_t *lock)
     jl_mutex_unlock_nogc(lock);
     jl_lock_frame_pop();
     JL_SIGATOMIC_END();
-    if (jl_gc_have_pending_finalizers) {
+    if (jl_atomic_load_relaxed(&jl_gc_have_pending_finalizers)) {
         jl_gc_run_pending_finalizers(jl_current_task); // may GC
     }
 }
 
 static inline void jl_mutex_init(jl_mutex_t *lock) JL_NOTSAFEPOINT
 {
-    lock->owner = 0;
+    jl_atomic_store_relaxed(&lock->owner, (jl_task_t*)NULL);
     lock->count = 0;
 }