Reimplemented _Core_MUTEX_Seize to return with interrupts disabled

if the mutex is successfully obtained.

1 files changed, 90 insertions, 0 deletions

diff --git a/cpukit/score/inline/rtems/score/coremutex.inl b/cpukit/score/inline/rtems/score/coremutex.inl
index 8ce3a9b214..5192528d87 100644
--- a/cpukit/score/inline/rtems/score/coremutex.inl
+++ b/cpukit/score/inline/rtems/score/coremutex.inl
@@ -101,5 +101,95 @@ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_priority_ceiling(
   return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
 }
  
+/*PAGE
+ *
+ *  _CORE_mutex_Seize_interrupt_trylock
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine returns 0 if "trylock" can resolve whether or not the
+ *  mutex is immediately obtained or there was an error attempting to
+ *  get it.  It returns 1 to indicate that the caller cannot obtain
+ *  the mutex and will have to block to do so.
+ *
+ *  NOTE: There is no MACRO version of this routine.
+ */
+
+RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock(
+  CORE_mutex_Control  *the_mutex,
+  ISR_Level           *level_p
+)
+{
+  Thread_Control   *executing;
+  ISR_Level         level = *level_p;
+
+  /* disabled when you get here */
+
+  executing = _Thread_Executing;
+  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
+  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
+    the_mutex->lock       = CORE_MUTEX_LOCKED;
+    the_mutex->holder     = executing;
+    the_mutex->holder_id  = executing->Object.id;
+    the_mutex->nest_count = 1;
+    executing->resource_count++;
+    if ( the_mutex->Attributes.discipline !=
+           CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING ) {
+        _ISR_Enable( level );
+        return 0;
+    }
+    /* else must be CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING */
+    {
+       Priority_Control  ceiling;
+       Priority_Control  current;
+
+       ceiling = the_mutex->Attributes.priority_ceiling;
+       current = executing->current_priority;
+       if ( current == ceiling ) {
+         _ISR_Enable( level );
+         return 0;
+       }
+       if ( current > ceiling ) {
+        _Thread_Disable_dispatch();
+        _ISR_Enable( level );
+        _Thread_Change_priority(
+          the_mutex->holder,
+          the_mutex->Attributes.priority_ceiling,
+          FALSE
+        );
+        _Thread_Enable_dispatch();
+        return 0;
+      }
+      /* if ( current < ceiling ) */ {
+        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
+        the_mutex->nest_count = 0;     /* undo locking above */
+        executing->resource_count--;   /* undo locking above */
+        _ISR_Enable( level );
+        return 0;
+      }
+    }
+    return 0;
+  }
+
+  if ( _Thread_Is_executing( the_mutex->holder ) ) {
+    switch ( the_mutex->Attributes.lock_nesting_behavior ) {
+      case CORE_MUTEX_NESTING_ACQUIRES:
+        the_mutex->nest_count++;
+        _ISR_Enable( level );
+        return 0;
+      case CORE_MUTEX_NESTING_IS_ERROR:
+        executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
+        _ISR_Enable( level );
+        return 0;
+      case CORE_MUTEX_NESTING_BLOCKS:
+        break;
+    }
+  }
+
+  return 1;
+}
+ 
+#endif
+
 #endif
 /* end of include file */