* shared_info.h (user_info): Add dll_crt0_1 as a friend.

(user_info::version): Make LONG to accommodate spinlock use.
(user_info::create): New static function renamed from user_info_create.
(user_info::initialize): New private function renamed from
user_info_initialize.
(SHARED_VERSION): Delete.
(SHARED_VERSION_MAGIC): Ditto.
(USER_VERSION_MAGIC): Ditto.
(SHARED_INFO_CB): Ditto.
(USER_VERSION): Ditto.
(USER_VERSION_MAGIC): Ditto.
(CURR_SHARED_MAGIC): Update.
(CURR_USER_MAGIC): Ditto.
(shared_info::version): Make LONG to accommodate spinlock use.
(shared_info::create): New static function mirroring user_info::create.
(dll_crt0_1): Accommodate change to user_info::initialize.
* spinlock.h (spinlock::setto): New variable member.
(spinlock::done): New function.
(spinlock::spinlock): Generalize to allow arbitrary values and timeouts.  Call
done() when lock is not needed.
* ntdll.h: Make multiple-inclusion safe.
(NtQuerySystemTime): Declare.
* shared.cc (installation_root_inited): Rename from shared_mem_inited.
(init_installation_root): Make inline.  Use a spinlock to ensure that this is
initialized only once per session.
(user_info::initialize): Rename from user_shared_initialize.  Protect with
spinlock on sversion and remove other spinlock-like things.  Remove reference
to user_shared since it is now implicit.  Refer to spinlock version of
multiple_cygwin_problem to ensure that any spinlock is released.
(user_info::create): Rename from user_shared_create.  Accommodate change from
user_shared_initialize to user_info::initialize.
(shared_info::create): New inline function.
(shared_info::initialize): Protect with spinlock on sversion.  Move heap_init
back under specific control of shared_info spinlock.  Remove reference to
SHARED_INFO_CB and just use sizeof(*this).
(memory_init): Move all locking into respective functions where it is needed.
Accommodate name changes.  Remove call to heap_init().
* syscalls.cc (seteuid32): Accommodate name change to user_info::create().
* mount.cc (mount_info::create_root_entry): Report on errors from add_item
since they should be nonexistent.
(mount_info::init): Don't initialize nmounts.  It should already be zero.  Give
more verbose error when root_idx < 0.  Implicitly use this pointer rather than
explicitly referencing mount_table->.
(mount_info::add_item): Minor whitespace fix.

1 files changed, 53 insertions, 13 deletions

diff --git a/winsup/cygwin/spinlock.h b/winsup/cygwin/spinlock.h
index abf723acc..b55817245 100644
--- a/winsup/cygwin/spinlock.h
+++ b/winsup/cygwin/spinlock.h
@@ -11,30 +11,70 @@ details. */
 #ifndef _SPINLOCK_H
 #define _SPINLOCK_H
 
-#include "hires.h"
+#include "ntdll.h"
+
+#define SPINLOCK_WAIT (15000LL * 10000LL)
 
 class spinlock
 {
   LONG *locker;
   LONG val;
+  LONG setto;
+  void done (LONG what)
+  {
+    if (locker)
+      {
+	InterlockedExchange (locker, what);
+	locker = NULL;
+      }
+  }
+  long long time ()
+  {
+    LARGE_INTEGER t;
+    if (NtQuerySystemTime (&t) == STATUS_SUCCESS)
+      return get_ll (t);
+    return 0LL;
+  }
 public:
-  spinlock (LONG& locktest, LONGLONG timeout):
-    locker (&locktest)
+  spinlock (LONG& locktest, LONG wanted_val = 1, LONGLONG timeout = SPINLOCK_WAIT):
+    locker (&locktest), setto (wanted_val)
   {
-    if ((val = locktest) == 1)
-      return;
-    LONGLONG then = gtod.msecs ();
-    for (;;)
+    /* Quick test to see if we're already initialized */
+    if ((val = locktest) == wanted_val)
+      locker = NULL;
+    /* Slightly less quick test to see if we are the first cygwin process */
+    else if ((val = InterlockedExchange (locker, -1)) == 0)
+      /* We're armed and dangerous */;
+    else if (val == wanted_val)
+      done (val);	/* This was initialized while we weren't looking */
+    else
       {
-	if ((val = InterlockedExchange (locker, -1)) != -1
-	    || (gtod.msecs () - then) >= timeout)
-	  break;
-	yield ();
+	long long then = time ();
+	/* Loop waiting for some other process to set locktest to something
+	   other than -1, indicating that initialization has finished.  Or,
+	   wait a default of 15 seconds for that to happen and, if it doesn't
+	   just grab the lock ourselves. */
+	while ((val = InterlockedExchange (locker, -1)) == -1
+	       && (time () - then) < timeout)
+	  yield ();
+	/* Reset the lock back to wanted_value under the assumption that is
+	   what caused the above loop to kick out.  */
+	if (val == -1)
+	  val = 0;	/* Timed out.  We'll initialize things ourselves. */
+	else
+	  done (val);	/* Put back whatever was there before, assuming that
+			   it is actually wanted_val. */
       }
   }
-  ~spinlock () {InterlockedExchange (locker, 1);}
+  ~spinlock () {done (setto);}
   operator LONG () const {return val;}
+  /* FIXME: This should be handled in a more general fashion, probably by
+     establishing a linked list of spinlocks which are freed on process exit. */
+  void multiple_cygwin_problem (const char *w, unsigned m, unsigned v)
+  {
+    done (val);
+    ::multiple_cygwin_problem (w, m, v);
+  }
 };
 
 #endif /*_SPINLOCK_H*/
-