[newlib-cygwin] Cygwin: cwd: use SRWLOCK instead of muto

[Corinna Vinschen <corinna@sourceware.org>]

https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;h=0819679a7a2101b7384b82f2449f56994359aa3a

commit 0819679a7a2101b7384b82f2449f56994359aa3a
Author: Corinna Vinschen <corinna@vinschen.de>
Date:   Tue Aug 23 11:58:38 2022 +0200

    Cygwin: cwd: use SRWLOCK instead of muto
    
    To reduce thread contention, use reader/writer locks as required.
    
    Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Diff:
---
 winsup/cygwin/local_includes/cygheap.h | 15 ++++++++++-----
 winsup/cygwin/nlsfuncs.cc              |  4 ++--
 winsup/cygwin/path.cc                  | 20 +++++++++-----------
 winsup/cygwin/syscalls.cc              | 12 ++++++------
 4 files changed, 27 insertions(+), 24 deletions(-)

diff --git a/winsup/cygwin/local_includes/cygheap.h b/winsup/cygwin/local_includes/cygheap.h
index 7f36c5837..6a844babd 100644
--- a/winsup/cygwin/local_includes/cygheap.h
+++ b/winsup/cygwin/local_includes/cygheap.h
@@ -303,25 +303,30 @@ private:
 
 public:
   UNICODE_STRING win32;
-  static muto cwd_lock;
+  static SRWLOCK NO_COPY cwd_lock;
+
+  static void acquire_read () { AcquireSRWLockShared (&cwd_lock); }
+  static void release_read () { ReleaseSRWLockShared (&cwd_lock); }
+  static void acquire_write () { AcquireSRWLockExclusive (&cwd_lock); }
+  static void release_write () { ReleaseSRWLockExclusive (&cwd_lock); }
   const char *get_posix () const { return posix; };
   void reset_posix (wchar_t *w_cwd);
   char *get (char *buf, int need_posix = 1, int with_chroot = 0,
 	     unsigned ulen = NT_MAX_PATH);
   PWCHAR get (PWCHAR buf, unsigned buflen = NT_MAX_PATH)
   {
-    cwd_lock.acquire ();
+    acquire_read ();
     buf[0] = L'\0';
     wcsncat (buf, win32.Buffer, buflen - 1);
-    cwd_lock.release ();
+    release_read ();
     return buf;
   }
   HANDLE get_handle () { return dir; }
   DWORD get_drive (char * dst)
   {
-    cwd_lock.acquire ();
+    acquire_read ();
     DWORD ret = sys_wcstombs (dst, NT_MAX_PATH, win32.Buffer, drive_length);
-    cwd_lock.release ();
+    release_read ();
     return ret;
   }
   int get_error () const { return error; }
diff --git a/winsup/cygwin/nlsfuncs.cc b/winsup/cygwin/nlsfuncs.cc
index 5edc0c0e6..ddd85bea1 100644
--- a/winsup/cygwin/nlsfuncs.cc
+++ b/winsup/cygwin/nlsfuncs.cc
@@ -1583,7 +1583,7 @@ internal_setlocale ()
       _sys_mbstowcs (cygheap->locale.mbtowc, w_path, 32768, path);
     }
   w_cwd = tp.w_get ();
-  cwdstuff::cwd_lock.acquire ();
+  cwdstuff::acquire_write ();
   _sys_mbstowcs (cygheap->locale.mbtowc, w_cwd, 32768,
 		   cygheap->cwd.get_posix ());
   /* Set charset for internal conversion functions. */
@@ -1592,7 +1592,7 @@ internal_setlocale ()
     cygheap->locale.mbtowc = __utf8_mbtowc;
   /* Restore CWD and PATH in new charset. */
   cygheap->cwd.reset_posix (w_cwd);
-  cwdstuff::cwd_lock.release ();
+  cwdstuff::release_write ();
   if (w_path)
     {
       char *c_path = tp.c_get ();
diff --git a/winsup/cygwin/path.cc b/winsup/cygwin/path.cc
index 227b99d0f..4babd10b8 100644
--- a/winsup/cygwin/path.cc
+++ b/winsup/cygwin/path.cc
@@ -103,7 +103,7 @@ struct symlink_info
   bool set_error (int);
 };
 
-muto NO_COPY cwdstuff::cwd_lock;
+SRWLOCK NO_COPY cwdstuff::cwd_lock;
 
 static const GUID GUID_shortcut
 			= { 0x00021401L, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46}};
@@ -4737,12 +4737,10 @@ cwdstuff::override_win32_cwd (bool init, ULONG old_dismount_count)
     }
 }
 
-/* Initialize cygcwd 'muto' for serializing access to cwd info. */
+/* Initialize cwdstuff */
 void
 cwdstuff::init ()
 {
-  cwd_lock.init ("cwd_lock");
-
   /* Cygwin processes inherit the cwd from their parent.  If the win32 path
      buffer is not NULL, the cwd struct is already set up, and we only
      have to override the Win32 CWD with ours. */
@@ -4800,8 +4798,6 @@ cwdstuff::set (path_conv *nat_cwd, const char *posix_cwd)
      Win32 CWD to a "weird" directory in which all relative filesystem-related
      calls fail. */
 
-  cwd_lock.acquire ();
-
   if (nat_cwd)
     {
       upath = *nat_cwd->get_nt_native_path ();
@@ -4825,6 +4821,8 @@ cwdstuff::set (path_conv *nat_cwd, const char *posix_cwd)
 	}
     }
 
+  acquire_write ();
+
   /* Memorize old DismountCount before opening the dir.  This value is
      stored in the FAST_CWD structure.  It would be simpler to fetch the
      old DismountCount in override_win32_cwd, but Windows also fetches
@@ -4888,7 +4886,7 @@ cwdstuff::set (path_conv *nat_cwd, const char *posix_cwd)
 	  /* Called from chdir?  Just fail. */
 	  if (nat_cwd)
 	    {
-	      cwd_lock.release ();
+	      release_write ();
 	      __seterrno_from_nt_status (status);
 	      return -1;
 	    }
@@ -4905,7 +4903,7 @@ cwdstuff::set (path_conv *nat_cwd, const char *posix_cwd)
 			peb.ProcessParameters->CurrentDirectoryHandle,
 			GetCurrentProcess (), &h, 0, TRUE, 0))
 	    {
-	      cwd_lock.release ();
+	      release_write ();
 	      if (peb.ProcessParameters->CurrentDirectoryHandle)
 		debug_printf ("...and DuplicateHandle failed with %E.");
 	      dir = NULL;
@@ -5027,7 +5025,7 @@ cwdstuff::set (path_conv *nat_cwd, const char *posix_cwd)
   posix = (char *) crealloc_abort (posix, strlen (posix_cwd) + 1);
   stpcpy (posix, posix_cwd);
 
-  cwd_lock.release ();
+  release_write ();
   return 0;
 }
 
@@ -5079,7 +5077,7 @@ cwdstuff::get (char *buf, int need_posix, int with_chroot, unsigned ulen)
       goto out;
     }
 
-  cwd_lock.acquire ();
+  acquire_read ();
 
   char *tocopy;
   if (!need_posix)
@@ -5106,7 +5104,7 @@ cwdstuff::get (char *buf, int need_posix, int with_chroot, unsigned ulen)
 	strcpy (buf, "/");
     }
 
-  cwd_lock.release ();
+  release_read ();
 
 out:
   syscall_printf ("(%s) = cwdstuff::get (%p, %u, %d, %d), errno %d",
diff --git a/winsup/cygwin/syscalls.cc b/winsup/cygwin/syscalls.cc
index 94cb57648..1338853df 100644
--- a/winsup/cygwin/syscalls.cc
+++ b/winsup/cygwin/syscalls.cc
@@ -4437,9 +4437,9 @@ gen_full_path_at (char *path_ret, int dirfd, const char *pathname,
 
       if (dirfd == AT_FDCWD)
 	{
-	  cwdstuff::cwd_lock.acquire ();
+	  cwdstuff::acquire_read ();
 	  p = stpcpy (path_ret, cygheap->cwd.get_posix ());
-	  cwdstuff::cwd_lock.release ();
+	  cwdstuff::release_read ();
 	}
       else
 	{
@@ -4581,9 +4581,9 @@ fchownat (int dirfd, const char *pathname, uid_t uid, gid_t gid, int flags)
 	  /* pathname is an empty string.  Operate on dirfd. */
 	  if (dirfd == AT_FDCWD)
 	    {
-	      cwdstuff::cwd_lock.acquire ();
+	      cwdstuff::acquire_read ();
 	      strcpy (path, cygheap->cwd.get_posix ());
-	      cwdstuff::cwd_lock.release ();
+	      cwdstuff::release_read ();
 	    }
 	  else
 	    {
@@ -4626,9 +4626,9 @@ fstatat (int dirfd, const char *__restrict pathname, struct stat *__restrict st,
 	  /* pathname is an empty string.  Operate on dirfd. */
 	  if (dirfd == AT_FDCWD)
 	    {
-	      cwdstuff::cwd_lock.acquire ();
+	      cwdstuff::acquire_read ();
 	      strcpy (path, cygheap->cwd.get_posix ());
-	      cwdstuff::cwd_lock.release ();
+	      cwdstuff::release_read ();
 	    }
 	  else
 	    return fstat (dirfd, st);