*** linuxthreads-old/mutex.c	Wed Nov 18 18:59:53 1998
--- linuxthreads/mutex.c	Mon Jun 12 12:35:43 2000
***************
*** 37,43 ****
  
  int __pthread_mutex_destroy(pthread_mutex_t * mutex)
  {
!   if (mutex->__m_lock.__status != 0) return EBUSY;
    return 0;
  }
  strong_alias (__pthread_mutex_destroy, pthread_mutex_destroy)
--- 37,43 ----
  
  int __pthread_mutex_destroy(pthread_mutex_t * mutex)
  {
!   if ((mutex->__m_lock.__status & 1) != 0) return EBUSY;
    return 0;
  }
  strong_alias (__pthread_mutex_destroy, pthread_mutex_destroy)
***************
*** 120,126 ****
      __pthread_unlock(&mutex->__m_lock);
      return 0;
    case PTHREAD_MUTEX_ERRORCHECK_NP:
!     if (mutex->__m_owner != thread_self() || mutex->__m_lock.__status == 0)
        return EPERM;
      mutex->__m_owner = NULL;
      __pthread_unlock(&mutex->__m_lock);
--- 120,126 ----
      __pthread_unlock(&mutex->__m_lock);
      return 0;
    case PTHREAD_MUTEX_ERRORCHECK_NP:
!     if (mutex->__m_owner != thread_self() || (mutex->__m_lock.__status & 1) == 0)
        return EPERM;
      mutex->__m_owner = NULL;
      __pthread_unlock(&mutex->__m_lock);
diff -c linuxthreads-old/spinlock.c linuxthreads/spinlock.c
*** linuxthreads-old/spinlock.c	Wed Jan  5 11:07:35 2000
--- linuxthreads/spinlock.c	Mon Jun 12 16:17:23 2000
***************
*** 22,34 ****
  #include "spinlock.h"
  #include "restart.h"
  
! /* The status field of a fastlock has the following meaning:
!      0: fastlock is free
!      1: fastlock is taken, no thread is waiting on it
!   ADDR: fastlock is taken, ADDR is address of thread descriptor for
!         first waiting thread, other waiting threads are linked via
!         their p_nextlock field.
!    The waiting list is not sorted by priority order.
     Actually, we always insert at top of list (sole insertion mode
     that can be performed without locking).
     For __pthread_unlock, we perform a linear search in the list
--- 22,42 ----
  #include "spinlock.h"
  #include "restart.h"
  
! /* The status field of a spinlock is a pointer whose least significant
!     bit is a locked flag.
!  
!     Thus the field values have the following meanings:
!  
!     status == 0:       spinlock is free
!     status == 1:       spinlock is taken; no thread is waiting on it
!  
!     (status & 1) == 1: spinlock is taken and (status & ~1L) is a
!                        pointer to the first waiting thread; other
!  		      waiting threads are linked via the p_nextlock 
!  		      field.
!     (status & 1) == 0: same as above, but spinlock is not taken.
!  
!   The waiting list is not sorted by priority order.
     Actually, we always insert at top of list (sole insertion mode
     that can be performed without locking).
     For __pthread_unlock, we perform a linear search in the list
***************
*** 40,59 ****
  				      pthread_descr self)
  {
    long oldstatus, newstatus;
!   int spurious_wakeup_count = 0;
  
    do {
      oldstatus = lock->__status;
!     if (oldstatus == 0) {
!       newstatus = 1;
      } else {
        if (self == NULL)
  	self = thread_self();
!       newstatus = (long) self;
      }
      if (self != NULL) {
        ASSERT(self->p_nextlock == NULL);
!       THREAD_SETMEM(self, p_nextlock, (pthread_descr) oldstatus);
      }
    } while(! compare_and_swap(&lock->__status, oldstatus, newstatus,
                               &lock->__spinlock));
--- 48,73 ----
  				      pthread_descr self)
  {
    long oldstatus, newstatus;
!   int successful_seizure, spurious_wakeup_count = 0;
! 
! again:
  
    do {
      oldstatus = lock->__status;
!     successful_seizure = 0;
! 
!     if ((oldstatus & 1) == 0) {
!       newstatus = oldstatus | 1;
!       successful_seizure = 1;
      } else {
        if (self == NULL)
  	self = thread_self();
!       newstatus = (long) self | 1;
      }
+ 
      if (self != NULL) {
        ASSERT(self->p_nextlock == NULL);
!       THREAD_SETMEM(self, p_nextlock, (pthread_descr) (oldstatus & ~1L));
      }
    } while(! compare_and_swap(&lock->__status, oldstatus, newstatus,
                               &lock->__spinlock));
***************
*** 64,70 ****
       locks the queue to remove itself. At that point it may still be on the
       queue, and may be resumed by a condition signal. */
  
!   if (oldstatus != 0) {
      for (;;) {
        suspend(self);
        if (self->p_nextlock != NULL) {
--- 78,84 ----
       locks the queue to remove itself. At that point it may still be on the
       queue, and may be resumed by a condition signal. */
  
!   if (!successful_seizure) {
      for (;;) {
        suspend(self);
        if (self->p_nextlock != NULL) {
***************
*** 74,79 ****
--- 88,94 ----
        }
        break;
      }
+     goto again;
    }
  
    /* Put back any resumes we caught that don't belong to us. */
***************
*** 87,93 ****
--- 102,112 ----
    pthread_descr thr, * ptr, * maxptr;
    int maxprio;
  
+   /* If there are no waiting threads, try to atomically
+      give up the lock. If that works, nothing else needs to be done. */
+ 
  again:
+ 
    oldstatus = lock->__status;
    if (oldstatus == 0 || oldstatus == 1) {
      /* No threads are waiting for this lock.  Please note that we also
***************
*** 99,108 ****
    }
    /* Find thread in waiting queue with maximal priority */
    ptr = (pthread_descr *) &lock->__status;
!   thr = (pthread_descr) oldstatus;
    maxprio = 0;
    maxptr = ptr;
!   while (thr != (pthread_descr) 1) {
      if (thr->p_priority >= maxprio) {
        maxptr = ptr;
        maxprio = thr->p_priority;
--- 118,127 ----
    }
    /* Find thread in waiting queue with maximal priority */
    ptr = (pthread_descr *) &lock->__status;
!   thr = (pthread_descr) (oldstatus & ~1L);
    maxprio = 0;
    maxptr = ptr;
!   while (thr != 0) {
      if (thr->p_priority >= maxprio) {
        maxptr = ptr;
        maxprio = thr->p_priority;
***************
*** 110,129 ****
      ptr = &(thr->p_nextlock);
      thr = *ptr;
    }
    /* Remove max prio thread from waiting list. */
    if (maxptr == (pthread_descr *) &lock->__status) {
      /* If max prio thread is at head, remove it with compare-and-swap
!        to guard against concurrent lock operation */
!     thr = (pthread_descr) oldstatus;
!     if (! compare_and_swap(&lock->__status,
                             oldstatus, (long)(thr->p_nextlock),
                             &lock->__spinlock))
        goto again;
    } else {
      /* No risk of concurrent access, remove max prio thread normally */
      thr = *maxptr;
      *maxptr = thr->p_nextlock;
    }
    /* Wake up the selected waiting thread */
    thr->p_nextlock = NULL;
    restart(thr);
--- 129,162 ----
      ptr = &(thr->p_nextlock);
      thr = *ptr;
    }
+ 
    /* Remove max prio thread from waiting list. */
+ 
    if (maxptr == (pthread_descr *) &lock->__status) {
      /* If max prio thread is at head, remove it with compare-and-swap
!        to guard against concurrent lock operation. This removal
!        also has the side effect of marking the lock as released
!        because the new status comes from thr->p_nextlock whose
!        least significant bit is clear. */
! 
!     thr = (pthread_descr) (oldstatus & ~1L);
! 
!     if (!compare_and_swap(&lock->__status,
                             oldstatus, (long)(thr->p_nextlock),
                             &lock->__spinlock))
        goto again;
    } else {
      /* No risk of concurrent access, remove max prio thread normally */
+     /* But in this case we must also flip the least significant bit
+        of the status to mark the lock as released */
      thr = *maxptr;
      *maxptr = thr->p_nextlock;
+ 
+     do {
+       oldstatus = lock->__status;
+     } while (!compare_and_swap(&lock->__status, oldstatus, oldstatus & ~1L, &lock->__spinlock));
    }
+ 
    /* Wake up the selected waiting thread */
    thr->p_nextlock = NULL;
    restart(thr);