Robust mutexes merged from devel branchpost_merge_with_ROBUST_MUTEXES

1 files changed, 80 insertions, 18 deletions

diff --git a/pthread_mutex_trylock.c b/pthread_mutex_trylock.c
index 50e8bc6..6fcff75 100644
--- a/pthread_mutex_trylock.c
+++ b/pthread_mutex_trylock.c
@@ -41,8 +41,9 @@
 int
 pthread_mutex_trylock (pthread_mutex_t * mutex)
 {
-  int result = 0;
   pthread_mutex_t mx;
+  int kind;
+  int result = 0;
 
   /*
    * Let the system deal with invalid pointers.
@@ -63,29 +64,90 @@ pthread_mutex_trylock (pthread_mutex_t * mutex)
     }
 
   mx = *mutex;
+  kind = mx->kind;
 
-  if (0 == (LONG) PTW32_INTERLOCKED_COMPARE_EXCHANGE (
-		     (PTW32_INTERLOCKED_LPLONG) &mx->lock_idx,
-		     (PTW32_INTERLOCKED_LONG) 1,
-		     (PTW32_INTERLOCKED_LONG) 0))
+  if (kind >= 0)
     {
-      if (mx->kind != PTHREAD_MUTEX_NORMAL)
-	{
-	  mx->recursive_count = 1;
-	  mx->ownerThread = pthread_self ();
-	}
+      /* Non-robust */
+      if (0 == (LONG) PTW32_INTERLOCKED_COMPARE_EXCHANGE (
+		         (PTW32_INTERLOCKED_LPLONG) &mx->lock_idx,
+		         (PTW32_INTERLOCKED_LONG) 1,
+		         (PTW32_INTERLOCKED_LONG) 0))
+        {
+          if (kind != PTHREAD_MUTEX_NORMAL)
+	    {
+	      mx->recursive_count = 1;
+	      mx->ownerThread = pthread_self ();
+	    }
+        }
+      else
+        {
+          if (kind == PTHREAD_MUTEX_RECURSIVE &&
+	      pthread_equal (mx->ownerThread, pthread_self ()))
+	    {
+	      mx->recursive_count++;
+	    }
+          else
+	    {
+	      result = EBUSY;
+	    }
+        }
     }
   else
     {
-      if (mx->kind == PTHREAD_MUTEX_RECURSIVE &&
-	  pthread_equal (mx->ownerThread, pthread_self ()))
-	{
-	  mx->recursive_count++;
-	}
+      /*
+       * Robust types
+       * All types record the current owner thread.
+       * The mutex is added to a per thread list when ownership is acquired.
+       */
+      pthread_t self;
+      ptw32_robust_state_t* statePtr = &mx->robustNode->stateInconsistent;
+
+      if ((LONG)PTW32_ROBUST_NOTRECOVERABLE ==
+                  PTW32_INTERLOCKED_EXCHANGE_ADD(
+                    (LPLONG)statePtr,
+                    0L))
+        {
+          return ENOTRECOVERABLE;
+        }
+
+      self = pthread_self();
+      kind = -kind - 1; /* Convert to non-robust range */
+
+      if (0 == (LONG) PTW32_INTERLOCKED_COMPARE_EXCHANGE (
+        	         (PTW32_INTERLOCKED_LPLONG) &mx->lock_idx,
+        	         (PTW32_INTERLOCKED_LONG) 1,
+        	         (PTW32_INTERLOCKED_LONG) 0))
+        {
+          if (kind != PTHREAD_MUTEX_NORMAL)
+            {
+              mx->recursive_count = 1;
+            }
+          ptw32_robust_mutex_add(mutex, self);
+        }
       else
-	{
-	  result = EBUSY;
-	}
+        {
+          if (PTHREAD_MUTEX_RECURSIVE == kind &&
+              pthread_equal (mx->ownerThread, pthread_self ()))
+            {
+              mx->recursive_count++;
+            }
+          else
+            {
+              if (EOWNERDEAD == (result = ptw32_robust_mutex_inherit(mutex)))
+                {
+                  mx->recursive_count = 1;
+                  ptw32_robust_mutex_add(mutex, self);
+                }
+              else
+                {
+                  if (0 == result)
+                    { 
+	              result = EBUSY;
+                    }
+                }
+	    }
+        }
     }
 
   return (result);