* thread.cc: Use "%E" in *_printf throughout rather than calling GetLastError.

GNUify comments.
(__pthread_mutex_lock): Don't return error on EBUSY since that just means that
the mutex has already been initialized.

2 files changed, 152 insertions, 158 deletions

diff --git a/winsup/cygwin/ChangeLog b/winsup/cygwin/ChangeLog
index 970291a..077111f 100644
--- a/winsup/cygwin/ChangeLog
+++ b/winsup/cygwin/ChangeLog
@@ -1,3 +1,10 @@
+2002-09-29  Christopher Faylor  <cgf@redhat.com>
+
+	* thread.cc: Use "%E" in *_printf throughout rather than calling
+	GetLastError.  GNUify comments.
+	(__pthread_mutex_lock): Don't return error on EBUSY since that just
+	means that the mutex has already been initialized.
+
 2002-09-30  Robert Collins <rbtcollins@hotmail.com>
 
 	* pthread.cc (pthread_mutex_init): Use new pthread_mutex::init.
diff --git a/winsup/cygwin/thread.cc b/winsup/cygwin/thread.cc
index 413d694..0f27ef3 100644
--- a/winsup/cygwin/thread.cc
+++ b/winsup/cygwin/thread.cc
@@ -265,7 +265,7 @@ pthread::self ()
 void
 pthread::setTlsSelfPointer (pthread *thisThread)
 {
-  /*the OS doesn't check this for <= 64 Tls entries (pre win2k) */
+  /* the OS doesn't check this for <= 64 Tls entries (pre win2k) */
   TlsSetValue (MT_INTERFACE->thread_self_dwTlsIndex, thisThread);
 }
 
@@ -297,7 +297,7 @@ pthread::precreate (pthread_attr *newattr)
 {
   pthread_mutex *verifyable_mutex_obj = &mutex;
 
-  /*already running ? */
+  /* already running ? */
   if (win32_obj_id)
     return;
 
@@ -320,8 +320,8 @@ pthread::precreate (pthread_attr *newattr)
   cancel_event = ::CreateEvent (NULL,TRUE,FALSE,NULL);
   if (!cancel_event)
     {
-      system_printf ("couldn't create cancel event, this %p LastError %d", this, GetLastError () );
-      /*we need the event for correct behaviour */
+      system_printf ("couldn't create cancel event, this %p LastError %E", this);
+      /* we need the event for correct behaviour */
       magic = 0;
       return;
     }
@@ -356,11 +356,11 @@ void
 pthread::postcreate ()
 {
     InterlockedIncrement (&MT_INTERFACE->threadcount);
-    /*FIXME: set the priority appropriately for system contention scope */
+    /* FIXME: set the priority appropriately for system contention scope */
     if (attr.inheritsched == PTHREAD_EXPLICIT_SCHED)
       {
-	/*FIXME: set the scheduling settings for the new thread */
-	/*sched_thread_setparam (win32_obj_id, attr.schedparam); */
+	/* FIXME: set the scheduling settings for the new thread */
+	/* sched_thread_setparam (win32_obj_id, attr.schedparam); */
       }
 }
 
@@ -376,7 +376,7 @@ pthread::exit (void *value_ptr)
 
   mutex.Lock ();
   // cleanup if thread is in detached state and not joined
-  if (__pthread_equal (&joiner, &thread ) )
+  if (__pthread_equal (&joiner, &thread))
     delete this;
   else
     {
@@ -612,7 +612,7 @@ pthread::testcancel (void)
   if (cancelstate == PTHREAD_CANCEL_DISABLE)
     return;
 
-  if (WAIT_OBJECT_0 == WaitForSingleObject (cancel_event, 0 ) )
+  if (WAIT_OBJECT_0 == WaitForSingleObject (cancel_event, 0))
     cancel_self ();
 }
 
@@ -672,7 +672,7 @@ pthread::push_cleanup_handler (__pthread_cleanup_handler *handler)
     // TODO: do it?
     api_fatal ("Attempt to push a cleanup handler across threads");
   handler->next = cleanup_stack;
-  InterlockedExchangePointer (&cleanup_stack, handler );
+  InterlockedExchangePointer (&cleanup_stack, handler);
 }
 
 void
@@ -761,15 +761,15 @@ pthread_cond::pthread_cond (pthread_condattr *attr):verifyable_object (PTHREAD_C
   this->mutex = NULL;
   this->waiting = 0;
 
-  this->win32_obj_id = ::CreateEvent (&sec_none_nih, false,	/*auto signal reset - which I think is pthreads like ? */
-				     false,	/*start non signaled */
-				     NULL /*no name */);
-  /*TODO: make a shared mem mutex if out attributes request shared mem cond */
+  this->win32_obj_id = ::CreateEvent (&sec_none_nih, false,	/* auto signal reset - which I think is pthreads like ? */
+				     false,	/* start non signaled */
+				     NULL /* no name */);
+  /* TODO: make a shared mem mutex if out attributes request shared mem cond */
   cond_access = NULL;
   if ((temperr = pthread_mutex_init (&this->cond_access, NULL)))
     {
       system_printf ("couldn't init mutex, this %p errno %d", this, temperr);
-      /*we need the mutex for correct behaviour */
+      /* we need the mutex for correct behaviour */
       magic = 0;
     }
 
@@ -808,7 +808,7 @@ pthread_cond::BroadCast ()
     {
       if (pthread_mutex_unlock (&cond_access))
 	system_printf ("Failed to unlock condition variable access mutex, this %p", this);
-      /*This isn't and API error - users are allowed to call this when no threads
+      /* This isn't and API error - users are allowed to call this when no threads
 	 are waiting
 	 system_printf ("Broadcast called with invalid mutex");
       */
@@ -903,12 +903,12 @@ pthread_cond::TimedWait (DWORD dwMilliseconds)
   switch (rv)
     {
     case WAIT_FAILED:
-      return 0;			/*POSIX doesn't allow errors after we modify the mutex state */
+      return 0;			/* POSIX doesn't allow errors after we modify the mutex state */
     case WAIT_ABANDONED:
     case WAIT_TIMEOUT:
       return ETIMEDOUT;
     case WAIT_OBJECT_0:
-      return 0;			/*we have been signaled */
+      return 0;			/* we have been signaled */
     default:
       return 0;
     }
@@ -1006,7 +1006,7 @@ pthread_key::~pthread_key ()
 int
 pthread_key::set (const void *value)
 {
-  /*the OS function doesn't perform error checking */
+  /* the OS function doesn't perform error checking */
   TlsSetValue (dwTlsIndex, (void *) value);
   return 0;
 }
@@ -1038,9 +1038,9 @@ pthread_key::recreateKeyFromBuffer ()
 void
 pthread_key::run_destructor ()
 {
-  if (destructor) 
+  if (destructor)
     {
-      void *oldValue = get();
+      void *oldValue = get ();
       if (oldValue)
 	{
     	  set (NULL);
@@ -1049,29 +1049,28 @@ pthread_key::run_destructor ()
     }
 }
 
-/*pshared mutexs:
-
- * REMOVED FROM CURRENT. These can be reinstated with the daemon, when all the
- gymnastics can be a lot easier.
-
- *the mutex_t (size 4) is not used as a verifyable object because we cannot
- *guarantee the same address space for all processes.
- *we use the following:
- *high bit set (never a valid address).
- *second byte is reserved for the priority.
- *third byte is reserved
- *fourth byte is the mutex id. (max 255 cygwin mutexs system wide).
- *creating mutex's does get slower and slower, but as creation is a one time
- *job, it should never become an issue
- *
- *And if you're looking at this and thinking, why not an array in cygwin for all mutexs,
- *- you incur a penalty on _every_ mutex call and you have toserialise them all.
- *... Bad karma.
- *
- *option 2? put everything in userspace and update the ABI?
- *- bad karma as well - the HANDLE, while identical across process's,
- *Isn't duplicated, it's reopened.
- */
+/* pshared mutexs:
+
+   REMOVED FROM CURRENT. These can be reinstated with the daemon, when all the
+   gymnastics can be a lot easier.
+
+   the mutex_t (size 4) is not used as a verifyable object because we cannot
+   guarantee the same address space for all processes.
+   we use the following:
+   high bit set (never a valid address).
+   second byte is reserved for the priority.
+   third byte is reserved
+   fourth byte is the mutex id. (max 255 cygwin mutexs system wide).
+   creating mutex's does get slower and slower, but as creation is a one time
+   job, it should never become an issue
+
+   And if you're looking at this and thinking, why not an array in cygwin for all mutexs,
+   - you incur a penalty on _every_ mutex call and you have toserialise them all.
+   ... Bad karma.
+
+   option 2? put everything in userspace and update the ABI?
+   - bad karma as well - the HANDLE, while identical across process's,
+   Isn't duplicated, it's reopened. */
 
 /* static members */
 bool
@@ -1101,21 +1100,20 @@ pthread_mutex::isGoodInitializerOrObject (pthread_mutex_t const *mutex)
 HANDLE pthread_mutex::mutexInitializationLock;
 
 /* We can only be called once.
- * TODO: (no rush) use a non copied memory section to 
- * hold an initialization flag.
- */
+   TODO: (no rush) use a non copied memory section to
+   hold an initialization flag.  */
 void
 pthread_mutex::initMutex ()
 {
   mutexInitializationLock = CreateMutex (NULL, FALSE, NULL);
   if (!mutexInitializationLock)
-    api_fatal ("Could not create win32 Mutex for pthread mutex static initializer support. The error code was %d\n", GetLastError());
-  
+    api_fatal ("Could not create win32 Mutex for pthread mutex static initializer support. The error code was %E");
+
 }
 
 pthread_mutex::pthread_mutex (pthread_mutexattr *attr):verifyable_object (PTHREAD_MUTEX_MAGIC)
 {
-  /*attr checked in the C call */
+  /* attr checked in the C call */
   if (attr && attr->pshared == PTHREAD_PROCESS_SHARED)
     {
       // fail
@@ -1273,7 +1271,7 @@ semaphore::Post ()
 int
 semaphore::TryWait ()
 {
-  /*FIXME: signals should be able to interrupt semaphores...
+  /* FIXME: signals should be able to interrupt semaphores...
    *We probably need WaitForMultipleObjects here.
    */
   if (WaitForSingleObject (win32_obj_id, 0) == WAIT_TIMEOUT)
@@ -1314,7 +1312,7 @@ verifyable_object::~verifyable_object ()
   magic = 0;
 }
 
-/*Generic memory acccess routine - where should it live ? */
+/* Generic memory acccess routine - where should it live ? */
 int __stdcall
 check_valid_pointer (void const *pointer)
 {
@@ -1358,7 +1356,7 @@ pthread::thread_init_wrapper (void *_arg)
   struct _reent local_clib = _REENT_INIT (local_clib);
 
   struct sigaction _sigs[NSIG];
-  sigset_t _sig_mask;		/*one set for everything to ignore. */
+  sigset_t _sig_mask;		/* one set for everything to ignore. */
   LONG _sigtodo[NSIG + __SIGOFFSET];
 
   // setup signal structures
@@ -1373,7 +1371,7 @@ pthread::thread_init_wrapper (void *_arg)
 
   local_winsup._process_logmask = LOG_UPTO (LOG_DEBUG);
 
-  /*This is not checked by the OS !! */
+  /* This is not checked by the OS !! */
   if (!TlsSetValue (MT_INTERFACE->reent_index, &local_reent))
     system_printf ("local storage for thread couldn't be set");
 
@@ -1402,7 +1400,7 @@ pthread::thread_init_wrapper (void *_arg)
 // ??? This code only runs if the thread exits by returning.
 // it's all now in __pthread_exit ();
 #endif
-  /*never reached */
+  /* never reached */
   return 0;
 }
 
@@ -1448,8 +1446,8 @@ pthread::once (pthread_once_t *once_control, void (*init_routine) (void))
     return 0;
 
   pthread_mutex_lock (&once_control->mutex);
-  /*Here we must set a cancellation handler to unlock the mutex if needed */
-  /*but a cancellation handler is not the right thing. We need this in the thread
+  /* Here we must set a cancellation handler to unlock the mutex if needed */
+  /* but a cancellation handler is not the right thing. We need this in the thread
    *cleanup routine. Assumption: a thread can only be in one pthread_once routine
    *at a time. Stote a mutex_t *in the pthread_structure. if that's non null unlock
    *on pthread_exit ();
@@ -1459,7 +1457,7 @@ pthread::once (pthread_once_t *once_control, void (*init_routine) (void))
       init_routine ();
       once_control->state = 1;
     }
-  /*Here we must remove our cancellation handler */
+  /* Here we must remove our cancellation handler */
   pthread_mutex_unlock (&once_control->mutex);
   return 0;
 }
@@ -1473,24 +1471,22 @@ pthread::cancel (pthread_t thread)
   return thread->cancel ();
 }
 
-/*
- *Races in pthread_atfork:
- *We are race safe in that any additions to the lists are made via
- *InterlockedExchangePointer.
- *However, if the user application doesn't perform syncronisation of some sort
- *It's not guaranteed that a near simultaneous call to pthread_atfork and fork
- *will result in the new atfork handlers being calls.
- *More rigorous internal syncronisation isn't needed as the user program isn't
- *guaranteeing their own state.
- *
- *as far as multiple calls to pthread_atfork, the worst case is simultaneous calls
- *will result in an indeterminate order for parent and child calls (what gets inserted
- *first isn't guaranteed.)
- *
- *There is one potential race... Does the result of InterlockedExchangePointer
- *get committed to the return location _before_ any context switches can occur?
- *If yes, we're safe, if no, we're not.
- */
+/* Races in pthread_atfork:
+   We are race safe in that any additions to the lists are made via
+   InterlockedExchangePointer.
+   However, if the user application doesn't perform syncronisation of some sort
+   It's not guaranteed that a near simultaneous call to pthread_atfork and fork
+   will result in the new atfork handlers being calls.
+   More rigorous internal syncronisation isn't needed as the user program isn't
+   guaranteeing their own state.
+
+   as far as multiple calls to pthread_atfork, the worst case is simultaneous calls
+   will result in an indeterminate order for parent and child calls (what gets inserted
+   first isn't guaranteed.)
+
+   There is one potential race... Does the result of InterlockedExchangePointer
+   get committed to the return location _before_ any context switches can occur?
+   If yes, we're safe, if no, we're not.  */
 void
 pthread::atforkprepare (void)
 {
@@ -1528,10 +1524,9 @@ pthread::atforkchild (void)
     }
 }
 
-/*Register a set of functions to run before and after fork.
- *prepare calls are called in LI-FC order.
- *parent and child calls are called in FI-FC order.
- */
+/* Register a set of functions to run before and after fork.
+   prepare calls are called in LI-FC order.
+   parent and child calls are called in FI-FC order.  */
 int
 pthread::atfork (void (*prepare)(void), void (*parent)(void), void (*child)(void))
 {
@@ -1576,7 +1571,7 @@ pthread::atfork (void (*prepare)(void), void (*parent)(void), void (*child)(void
     callback **t = &MT_INTERFACE->pthread_parent;
     while (*t)
       t = &(*t)->next;
-    /*t = pointer to last next in the list */
+    /* t = pointer to last next in the list */
     parentcb->next = (callback *) InterlockedExchangePointer ((LONG *) t, (long int) parentcb);
   }
   if (childcb)
@@ -1585,7 +1580,7 @@ pthread::atfork (void (*prepare)(void), void (*parent)(void), void (*child)(void
     callback **t = &MT_INTERFACE->pthread_child;
     while (*t)
       t = &(*t)->next;
-    /*t = pointer to last next in the list */
+    /* t = pointer to last next in the list */
     childcb->next = (callback *) InterlockedExchangePointer ((LONG *) t, (long int) childcb);
   }
   return 0;
@@ -1626,10 +1621,9 @@ __pthread_attr_getschedparam (const pthread_attr_t *attr,
   return 0;
 }
 
-/*From a pure code point of view, this should call a helper in sched.cc,
- *to allow for someone adding scheduler policy changes to win32 in the future.
- *However that's extremely unlikely, so short and sweet will do us
- */
+/* From a pure code point of view, this should call a helper in sched.cc,
+   to allow for someone adding scheduler policy changes to win32 in the future.
+   However that's extremely unlikely, so short and sweet will do us */
 int
 __pthread_attr_getschedpolicy (const pthread_attr_t *attr, int *policy)
 {
@@ -1693,7 +1687,7 @@ __pthread_attr_setschedparam (pthread_attr_t *attr,
   return 0;
 }
 
-/*See __pthread_attr_getschedpolicy for some notes */
+/* See __pthread_attr_getschedpolicy for some notes */
 int
 __pthread_attr_setschedpolicy (pthread_attr_t *attr, int policy)
 {
@@ -1712,8 +1706,8 @@ __pthread_attr_setscope (pthread_attr_t *attr, int contentionscope)
   if (contentionscope != PTHREAD_SCOPE_SYSTEM
       && contentionscope != PTHREAD_SCOPE_PROCESS)
     return EINVAL;
-  /*In future, we may be able to support system scope by escalating the thread
-   *priority to exceed the priority class. For now we only support PROCESS scope. */
+  /* In future, we may be able to support system scope by escalating the thread
+     priority to exceed the priority class. For now we only support PROCESS scope. */
   if (contentionscope != PTHREAD_SCOPE_PROCESS)
     return ENOTSUP;
   (*attr)->contentionscope = contentionscope;
@@ -1757,7 +1751,7 @@ pthread::join (pthread_t *thread, void **return_val)
    if (return_val)
      *return_val = NULL;
 
-  /*FIXME: wait on the thread cancellation event as well - we are a cancellation point*/
+  /* FIXME: wait on the thread cancellation event as well - we are a cancellation point*/
   if (!isGoodObject (thread))
     return ESRCH;
 
@@ -1781,7 +1775,7 @@ pthread::join (pthread_t *thread, void **return_val)
 	 *return_val = (*thread)->return_ptr;
       // cleanup
       delete (*thread);
-    }	/*End if */
+    }	/* End if */
 
   pthread_testcancel ();
 
@@ -1802,7 +1796,7 @@ pthread::detach (pthread_t *thread)
     }
 
   // check if thread is still alive
-  if (WAIT_TIMEOUT == WaitForSingleObject ((*thread)->win32_obj_id, 0) )
+  if (WAIT_TIMEOUT == WaitForSingleObject ((*thread)->win32_obj_id, 0))
     {
       // force cleanup on exit
       (*thread)->joiner = *thread;
@@ -1848,16 +1842,16 @@ pthread::resume (pthread_t *thread)
   return 0;
 }
 
-/*provided for source level compatability.
- *See http://www.opengroup.org/onlinepubs/007908799/xsh/pthread_getconcurrency.html
- */
+/* provided for source level compatability.
+   See http://www.opengroup.org/onlinepubs/007908799/xsh/pthread_getconcurrency.html
+*/
 int
 __pthread_getconcurrency (void)
 {
   return MT_INTERFACE->concurrency;
 }
 
-/*keep this in sync with sched.cc */
+/* keep this in sync with sched.cc */
 int
 __pthread_getschedparam (pthread_t thread, int *policy,
 			 struct sched_param *param)
@@ -1865,19 +1859,18 @@ __pthread_getschedparam (pthread_t thread, int *policy,
   if (!pthread::isGoodObject (&thread))
     return ESRCH;
   *policy = SCHED_FIFO;
-  /*we don't return the current effective priority, we return the current requested
-   *priority */
+  /* we don't return the current effective priority, we return the current
+     requested priority */
   *param = thread->attr.schedparam;
   return 0;
 }
 
-/*Thread SpecificData */
+/* Thread SpecificData */
 int
 __pthread_key_create (pthread_key_t *key, void (*destructor) (void *))
 {
-  /*The opengroup docs don't define if we should check this or not,
-   *but creation is relatively rare..
-   */
+  /* The opengroup docs don't define if we should check this or not,
+     but creation is relatively rare.  */
   if (pthread_key::isGoodObject (key))
     return EBUSY;
 
@@ -1902,9 +1895,9 @@ __pthread_key_delete (pthread_key_t key)
   return 0;
 }
 
-/*provided for source level compatability.
- *See http://www.opengroup.org/onlinepubs/007908799/xsh/pthread_getconcurrency.html
- */
+/* provided for source level compatability.  See
+http://www.opengroup.org/onlinepubs/007908799/xsh/pthread_getconcurrency.html
+*/
 int
 __pthread_setconcurrency (int new_level)
 {
@@ -1914,7 +1907,7 @@ __pthread_setconcurrency (int new_level)
   return 0;
 }
 
-/*keep syncronised with sched.cc */
+/* keep syncronised with sched.cc */
 int
 __pthread_setschedparam (pthread_t thread, int policy,
 			 const struct sched_param *param)
@@ -1952,7 +1945,7 @@ __pthread_getspecific (pthread_key_t key)
 
 }
 
-/*Thread synchronisation */
+/* Thread synchronisation */
 bool
 pthread_cond::isGoodObject (pthread_cond_t const *cond)
 {
@@ -1985,7 +1978,7 @@ __pthread_cond_destroy (pthread_cond_t *cond)
   if (!pthread_cond::isGoodObject (cond))
     return EINVAL;
 
-  /*reads are atomic */
+  /* reads are atomic */
   if ((*cond)->waiting)
     return EBUSY;
 
@@ -2061,7 +2054,7 @@ __pthread_cond_dowait (pthread_cond_t *cond, pthread_mutex_t *mutex,
   if (!pthread_cond::isGoodObject (cond))
     return EINVAL;
 
-  /*if the cond variable is blocked, then the above timer test maybe wrong. *shrug**/
+  /* if the cond variable is blocked, then the above timer test maybe wrong. *shrug**/
   if (pthread_mutex_lock (&(*cond)->cond_access))
     system_printf ("Failed to lock condition variable access mutex, this %p", *cond);
 
@@ -2079,13 +2072,11 @@ __pthread_cond_dowait (pthread_cond_t *cond, pthread_mutex_t *mutex,
   if (pthread_mutex_unlock (&(*cond)->cond_access))
     system_printf ("Failed to unlock condition variable access mutex, this %p", *cond);
   /* At this point calls to Signal will progress evebn if we aren' yet waiting
-   * However, the loop there should allow us to get scheduled and call wait,
-   * and have them call PulseEvent again if we dont' respond.
-   */
+     However, the loop there should allow us to get scheduled and call wait,
+     and have them call PulseEvent again if we dont' respond.  */
   rv = (*cond)->TimedWait (waitlength);
-  /* this may allow a race on the mutex acquisition and waits..
-   * But doing this within the cond access mutex creates a different race
-   */
+  /* this may allow a race on the mutex acquisition and waits.
+     But doing this within the cond access mutex creates a different race */
   InterlockedDecrement (&((*cond)->waiting));
   /* Tell Signal that we have been released */
   InterlockedDecrement (&((*cond)->ExitingWait));
@@ -2153,7 +2144,7 @@ __pthread_condattr_setpshared (pthread_condattr_t *attr, int pshared)
     return EINVAL;
   if ((pshared < 0) || (pshared > 1))
     return EINVAL;
-  /*shared cond vars not currently supported */
+  /* shared cond vars not currently supported */
   if (pshared != PTHREAD_PROCESS_PRIVATE)
     return EINVAL;
   (*attr)->shared = pshared;
@@ -2170,11 +2161,11 @@ __pthread_condattr_destroy (pthread_condattr_t *condattr)
   return 0;
 }
 
-/*Thread signal */
+/* Thread signal */
 int
 __pthread_kill (pthread_t thread, int sig)
 {
-// lock myself, for the use of thread2signal
+  // lock myself, for the use of thread2signal
   // two different kills might clash: FIXME
 
   if (!pthread::isGoodObject (&thread))
@@ -2215,7 +2206,7 @@ __pthread_equal (pthread_t *t1, pthread_t *t2)
   return (*t1 == *t2);
 }
 
-/*Mutexes  */
+/* Mutexes  */
 
 /* FIXME: there's a potential race with PTHREAD_MUTEX_INITALIZER:
    the mutex is not actually inited until the first use.
@@ -2234,15 +2225,15 @@ pthread_mutex::init (pthread_mutex_t *mutex,
   DWORD waitResult = WaitForSingleObject (mutexInitializationLock, INFINITE);
   if (waitResult != WAIT_OBJECT_0)
     {
-      system_printf ("Recieved a unexpected wait result on mutexInitializationLock %d\n", waitResult);
+      system_printf ("Received a unexpected wait result on mutexInitializationLock %d\n", waitResult);
       return EINVAL;
     }
 
   /* FIXME: bugfix: we should check *mutex being a valid address */
   if (isGoodObject (mutex))
     {
-      if (! ReleaseMutex(mutexInitializationLock))
-	  system_printf ("Recieved a unexpected result releasing mutexInitializationLock %d\n", GetLastError());
+      if (!ReleaseMutex (mutexInitializationLock))
+	  system_printf ("Received a unexpected result releasing mutexInitializationLock %E");
       return EBUSY;
     }
 
@@ -2251,12 +2242,12 @@ pthread_mutex::init (pthread_mutex_t *mutex,
     {
       delete (*mutex);
       *mutex = NULL;
-      if (! ReleaseMutex(mutexInitializationLock))
-	  system_printf ("Recieved a unexpected result releasing mutexInitializationLock %d\n", GetLastError());
+      if (!ReleaseMutex (mutexInitializationLock))
+	  system_printf ("Received a unexpected result releasing mutexInitializationLock %E");
       return EAGAIN;
     }
-  if (! ReleaseMutex(mutexInitializationLock))
-      system_printf ("Recieved a unexpected result releasing mutexInitializationLock %d\n", GetLastError());
+  if (!ReleaseMutex (mutexInitializationLock))
+      system_printf ("Received a unexpected result releasing mutexInitializationLock %E");
   return 0;
 }
 
@@ -2269,14 +2260,13 @@ __pthread_mutex_getprioceiling (const pthread_mutex_t *mutex,
     pthread_mutex::init ((pthread_mutex_t *) mutex, NULL);
   if (!pthread_mutex::isGoodObject (themutex))
     return EINVAL;
-  /*We don't define _POSIX_THREAD_PRIO_PROTECT because we do't currently support
-   *mutex priorities.
-   *
-   *We can support mutex priorities in the future though:
-   *Store a priority with each mutex.
-   *When the mutex is optained, set the thread priority as appropriate
-   *When the mutex is released, reset the thread priority.
-   */
+  /* We don't define _POSIX_THREAD_PRIO_PROTECT because we do't currently support
+     mutex priorities.
+
+     We can support mutex priorities in the future though:
+     Store a priority with each mutex.
+     When the mutex is optained, set the thread priority as appropriate
+     When the mutex is released, reset the thread priority.  */
   return ENOSYS;
 }
 
@@ -2286,8 +2276,7 @@ __pthread_mutex_lock (pthread_mutex_t *mutex)
   pthread_mutex_t *themutex = mutex;
   /* This could be simplified via isGoodInitializerOrObject
      and isGoodInitializer, but in a performance critical call like this....
-     no.
-     */
+     no.  */
   switch (verifyable_object_isvalid (themutex, PTHREAD_MUTEX_MAGIC, PTHREAD_MUTEX_INITIALIZER))
     {
     case INVALID_OBJECT:
@@ -2297,12 +2286,11 @@ __pthread_mutex_lock (pthread_mutex_t *mutex)
       if (pthread_mutex::isGoodInitializer (mutex))
 	{
 	  int rv = pthread_mutex::init (mutex, NULL);
-	  if (rv)
+	  if (rv && rv != EBUSY)
 	    return rv;
 	}
       /* No else needed. If it's been initialized while we waited,
-       * we can just attempt to lock it
-       */
+         we can just attempt to lock it */
       break;
     case VALID_OBJECT:
       break;
@@ -2343,7 +2331,7 @@ __pthread_mutex_destroy (pthread_mutex_t *mutex)
   if (!pthread_mutex::isGoodObject (mutex))
     return EINVAL;
 
-  /*reading a word is atomic */
+  /* reading a word is atomic */
   if ((*mutex)->condwaits)
     return EBUSY;
 
@@ -2364,8 +2352,8 @@ __pthread_mutex_setprioceiling (pthread_mutex_t *mutex, int prioceiling,
   return ENOSYS;
 }
 
-/*Win32 doesn't support mutex priorities - see __pthread_mutex_getprioceiling
- *for more detail */
+/* Win32 doesn't support mutex priorities - see __pthread_mutex_getprioceiling
+   for more detail */
 int
 __pthread_mutexattr_getprotocol (const pthread_mutexattr_t *attr,
 				 int *protocol)
@@ -2385,10 +2373,10 @@ __pthread_mutexattr_getpshared (const pthread_mutexattr_t *attr,
   return 0;
 }
 
-/*Win32 mutex's are equivalent to posix RECURSIVE mutexs.
- *We need to put glue in place to support other types of mutex's. We map
- *PTHREAD_MUTEX_DEFAULT to PTHREAD_MUTEX_RECURSIVE and return EINVAL for other types.
- */
+/* Win32 mutex's are equivalent to posix RECURSIVE mutexs.
+   We need to put glue in place to support other types of mutex's. We map
+   PTHREAD_MUTEX_DEFAULT to PTHREAD_MUTEX_RECURSIVE and return EINVAL for
+   other types.  */
 int
 __pthread_mutexattr_gettype (const pthread_mutexattr_t *attr, int *type)
 {
@@ -2398,11 +2386,10 @@ __pthread_mutexattr_gettype (const pthread_mutexattr_t *attr, int *type)
   return 0;
 }
 
-/*Currently pthread_mutex_init ignores the attr variable, this is because
- *none of the variables have any impact on it's behaviour.
- *
- *FIXME: write and test process shared mutex's.
- */
+/* Currently pthread_mutex_init ignores the attr variable, this is because
+   none of the variables have any impact on it's behaviour.
+
+   FIXME: write and test process shared mutex's.  */
 int
 __pthread_mutexattr_init (pthread_mutexattr_t *attr)
 {
@@ -2430,7 +2417,7 @@ __pthread_mutexattr_destroy (pthread_mutexattr_t *attr)
 }
 
 
-/*Win32 doesn't support mutex priorities */
+/* Win32 doesn't support mutex priorities */
 int
 __pthread_mutexattr_setprotocol (pthread_mutexattr_t *attr, int protocol)
 {
@@ -2439,7 +2426,7 @@ __pthread_mutexattr_setprotocol (pthread_mutexattr_t *attr, int protocol)
   return ENOSYS;
 }
 
-/*Win32 doesn't support mutex priorities */
+/* Win32 doesn't support mutex priorities */
 int
 __pthread_mutexattr_setprioceiling (pthread_mutexattr_t *attr,
 				    int prioceiling)
@@ -2463,7 +2450,7 @@ __pthread_mutexattr_setpshared (pthread_mutexattr_t *attr, int pshared)
 {
   if (!pthread_mutexattr::isGoodObject (attr))
     return EINVAL;
-  /*we don't use pshared for anything as yet. We need to test PROCESS_SHARED
+  /* we don't use pshared for anything as yet. We need to test PROCESS_SHARED
    *functionality
    */
   if (pshared != PTHREAD_PROCESS_PRIVATE)
@@ -2472,7 +2459,7 @@ __pthread_mutexattr_setpshared (pthread_mutexattr_t *attr, int pshared)
   return 0;
 }
 
-/*see __pthread_mutex_gettype */
+/* see __pthread_mutex_gettype */
 int
 __pthread_mutexattr_settype (pthread_mutexattr_t *attr, int type)
 {
@@ -2484,7 +2471,7 @@ __pthread_mutexattr_settype (pthread_mutexattr_t *attr, int type)
   return 0;
 }
 
-/*Semaphores */
+/* Semaphores */
 
 /* static members */
 bool
@@ -2498,7 +2485,7 @@ semaphore::isGoodObject (sem_t const * sem)
 int
 semaphore::init (sem_t *sem, int pshared, unsigned int value)
 {
-  /*opengroup calls this undefined */
+  /* opengroup calls this undefined */
   if (isGoodObject (sem))
     return EBUSY;
 
@@ -2522,7 +2509,7 @@ semaphore::destroy (sem_t *sem)
   if (!isGoodObject (sem))
     return EINVAL;
 
-  /*FIXME - new feature - test for busy against threads... */
+  /* FIXME - new feature - test for busy against threads... */
 
   delete (*sem);
   *sem = NULL;