Cygwin: thread: Allow fast_mutex to be acquired multiple times.

Previously, the fast_mutex defined in thread.h could not be aquired
multiple times, i.e., the thread causes deadlock if it attempted to
acquire a lock already acquired by the thread. For example, a deadlock
occurs if another pthread_key_create() is called in the destructor
specified in the previous pthread_key_create(). This is because the
run_all_destructors() calls the desructor via keys.for_each() where
both for_each() and pthread_key_create() (that calls List_insert())
attempt to acquire the lock. With this patch, the fast_mutex can be
acquired multiple times by the same thread similar to the behaviour
of a Windows mutex. In this implementation, the mutex is released
only when the number of unlock() calls matches the number of lock()
calls.

Addresses: https://cygwin.com/pipermail/cygwin/2025-March/257705.html
Fixes: 1a82139 ("fix race condition in List_insert")
Reported-by: Yuyi Wang <[email protected]>
Reviewed-by: Corinna Vinschen <[email protected]>
Signed-off-by: Takashi Yano <[email protected]>

Author: tyan0

winsup/cygwin/local_includes/thread.h

@@ -31,7 +31,7 @@ class fast_mutex
 {
 public:
   fast_mutex () :
-    lock_counter (0), win32_obj_id (0)
+    tid (0), counter_self (0), lock_counter (0), win32_obj_id (0)
   {
   }
 
@@ -55,17 +55,29 @@ class fast_mutex
 
   void lock ()
   {
-    if (InterlockedIncrement (&lock_counter) != 1)
+    if (!locked () && InterlockedIncrement (&lock_counter) != 1)
       cygwait (win32_obj_id, cw_infinite, cw_sig | cw_sig_restart);
+    tid = GetCurrentThreadId ();
+    counter_self++;
   }
 
   void unlock ()
   {
+    if (!locked () || --counter_self > 0)
+      return;
+    tid = 0;
     if (InterlockedDecrement (&lock_counter))
       ::SetEvent (win32_obj_id);
   }
 
+  bool locked ()
+  {
+    return tid == GetCurrentThreadId ();
+  }
+
 private:
+  DWORD tid;
+  int counter_self;
   LONG lock_counter;
   HANDLE win32_obj_id;
 };