--- hurd_condition_wait.old.c	2002-11-17 17:41:49.000000000 +0100
+++ hurd_condition_wait.c	2002-11-17 13:01:02.000000000 +0100
@@ -1,21 +1,20 @@
 /* Just like condition_wait, but cancellable.  Returns true if cancelled.  */
 int
-hurd_condition_wait (condition_t c, mutex_t m)
+hurd_condition_wait (pthread_cond_t c, pthread_mutex_t m)
 {
   /* This function will be called by hurd_thread_cancel while we are blocked
      in the condition_wait.  We wake up all threads blocked on C,
      so our thread will wake up and notice the cancellation flag.  */
   void cancel_me (void)
     {
-      condition_broadcast (c);
+      pthread_cond_broadcast (&c);
     }
   struct hurd_sigstate *ss = _hurd_self_sigstate ();
-  cproc_t p = cproc_self ();
+  struct __pthread *self = _pthread_self ();
   int cancel;
 
   assert (ss->intr_port == MACH_PORT_NULL); /* Sanity check for signal bugs. */
 
-  p->state = CPROC_CONDWAIT | CPROC_SWITCHING;
 
   /* Atomically enqueue our cproc on the condition variable's queue of
      waiters, and mark our sigstate to indicate that `cancel_me' must be
@@ -24,8 +23,8 @@
      hurd_thread_cancel can never suspend us and then deadlock in
      condition_broadcast waiting for the condition variable's lock.  */
 
-  spin_lock (&ss->lock);
-  spin_lock (&c->lock);
+  __pthread_spin_lock (&ss->lock);
+  __pthread_spin_lock (&c->__lock);
   cancel = ss->cancel;
   if (cancel)
     /* We were cancelled before doing anything.  Don't block at all.  */
@@ -34,46 +33,26 @@
     {
       /* Put us on the queue so that condition_broadcast will know to wake
          us up.  */
-      cthread_queue_enq (&c->queue, p);
+      __pthread_enqueue (&c->__queue, self);
       /* Tell hurd_thread_cancel how to unblock us.  */
       ss->cancel_hook = &cancel_me;
     }
-  spin_unlock (&c->lock);
-  spin_unlock (&ss->lock);
+  __pthread_spin_unlock (&c->__lock);
+  __pthread_spin_unlock (&ss->lock);
 
   if (cancel)
     {
       /* Cancelled on entry.  Just leave the mutex locked.  */
       m = NULL;
-      p->state = CPROC_RUNNING;
     }
   else
     {
       /* Now unlock the mutex and block until woken.  */
-
-#ifdef	WAIT_DEBUG
-      p->waiting_for = (char *)c;
-#endif	 /* WAIT_DEBUG */
-
-      mutex_unlock (m);
-
-      spin_lock (&p->lock);
-      if (p->state & CPROC_SWITCHING)
-	cproc_block ();
-      else
-	{
-	  /* We were woken up someplace before reacquiring P->lock.
-	     We can just continue on.  */
-	  p->state = CPROC_RUNNING;
-	  spin_unlock(&p->lock);
-	}
-
-#ifdef	WAIT_DEBUG
-      p->waiting_for = (char *)0;
-#endif	 /* WAIT_DEBUG */
+      pthread_mutex_unlock (&m);
+      __pthread_block (self);
     }
 
-  spin_lock (&ss->lock);
+  __pthread_spin_lock (&ss->lock);
   /* Clear the hook, now that we are done blocking.  */
   ss->cancel_hook = NULL;
   /* Check the cancellation flag; we might have unblocked due to
@@ -82,11 +61,11 @@
      right after waking up).  */
   cancel |= ss->cancel;
   ss->cancel = 0;
-  spin_unlock (&ss->lock);
+  __pthread_spin_unlock (&ss->lock);
 
   if (m)
     /* Reacquire the mutex and return.  */
-    mutex_lock (m);
+    __pthread_mutex_lock (&m);
 
   return cancel;
 }