posix: Implement self-contained POSIX semaphores

For semaphore object pointer and object validation see
POSIX_SEMAPHORE_VALIDATE_OBJECT().

Destruction or close of a busy semaphore returns an error status.  The
object is not flushed.

POSIX semaphores are now available in all configurations and no longer
depend on --enable-posix.

Update #2514.
Update #3116.

1 files changed, 13 insertions, 60 deletions

diff --git a/cpukit/score/src/semaphore.c b/cpukit/score/src/semaphore.c
index 28a2f0a76d..e670367e86 100644
--- a/cpukit/score/src/semaphore.c
+++ b/cpukit/score/src/semaphore.c
@@ -16,92 +16,45 @@
   #include "config.h"
 #endif
 
-#include <sys/lock.h>
+#include <rtems/score/semaphoreimpl.h>
+#include <rtems/score/statesimpl.h>
 
 #include <limits.h>
 
-#include <rtems/score/assert.h>
-#include <rtems/score/threadimpl.h>
-#include <rtems/score/threadqimpl.h>
-
-#define SEMAPHORE_TQ_OPERATIONS &_Thread_queue_Operations_priority
-
-typedef struct {
-  Thread_queue_Syslock_queue Queue;
-  unsigned int count;
-} Semaphore_Control;
-
 RTEMS_STATIC_ASSERT(
-  offsetof( Semaphore_Control, Queue )
+  offsetof( Sem_Control, Queue )
     == offsetof( struct _Semaphore_Control, _Queue ),
   SEMAPHORE_CONTROL_QUEUE
 );
 
 RTEMS_STATIC_ASSERT(
-  offsetof( Semaphore_Control, count )
+  offsetof( Sem_Control, count )
     == offsetof( struct _Semaphore_Control, _count ),
   SEMAPHORE_CONTROL_COUNT
 );
 
 RTEMS_STATIC_ASSERT(
-  sizeof( Semaphore_Control ) == sizeof( struct _Semaphore_Control ),
+  sizeof( Sem_Control ) == sizeof( struct _Semaphore_Control ),
   SEMAPHORE_CONTROL_SIZE
 );
 
-static Semaphore_Control *_Semaphore_Get(
-  struct _Semaphore_Control *_sem
-)
-{
-  return (Semaphore_Control *) _sem;
-}
-
-static Thread_Control *_Semaphore_Queue_acquire_critical(
-  Semaphore_Control    *sem,
-  Thread_queue_Context *queue_context
-)
-{
-  Thread_Control *executing;
-
-  executing = _Thread_Executing;
-  _Thread_queue_Queue_acquire_critical(
-    &sem->Queue.Queue,
-    &executing->Potpourri_stats,
-    &queue_context->Lock_context.Lock_context
-  );
-
-  return executing;
-}
-
-static void _Semaphore_Queue_release(
-  Semaphore_Control    *sem,
-  ISR_Level             level,
-  Thread_queue_Context *queue_context
-)
-{
-  _Thread_queue_Queue_release_critical(
-    &sem->Queue.Queue,
-    &queue_context->Lock_context.Lock_context
-  );
-  _ISR_Local_enable( level );
-}
-
 void _Semaphore_Wait( struct _Semaphore_Control *_sem )
 {
-  Semaphore_Control    *sem ;
+  Sem_Control          *sem;
   ISR_Level             level;
   Thread_queue_Context  queue_context;
   Thread_Control       *executing;
   unsigned int          count;
 
-  sem = _Semaphore_Get( _sem );
+  sem = _Sem_Get( _sem );
   _Thread_queue_Context_initialize( &queue_context );
   _Thread_queue_Context_ISR_disable( &queue_context, level );
-  executing = _Semaphore_Queue_acquire_critical( sem, &queue_context );
+  executing = _Sem_Queue_acquire_critical( sem, &queue_context );
 
   count = sem->count;
   if ( __predict_true( count > 0 ) ) {
     sem->count = count - 1;
-    _Semaphore_Queue_release( sem, level, &queue_context );
+    _Sem_Queue_release( sem, level, &queue_context );
   } else {
     _Thread_queue_Context_set_thread_state(
       &queue_context,
@@ -121,21 +74,21 @@ void _Semaphore_Wait( struct _Semaphore_Control *_sem )
 
 void _Semaphore_Post( struct _Semaphore_Control *_sem )
 {
-  Semaphore_Control    *sem;
+  Sem_Control          *sem;
   ISR_Level             level;
   Thread_queue_Context  queue_context;
   Thread_queue_Heads   *heads;
 
-  sem = _Semaphore_Get( _sem );
+  sem = _Sem_Get( _sem );
   _Thread_queue_Context_initialize( &queue_context );
   _Thread_queue_Context_ISR_disable( &queue_context, level );
-  _Semaphore_Queue_acquire_critical( sem, &queue_context );
+  _Sem_Queue_acquire_critical( sem, &queue_context );
 
   heads = sem->Queue.Queue.heads;
   if ( __predict_true( heads == NULL ) ) {
     _Assert( sem->count < UINT_MAX );
     ++sem->count;
-    _Semaphore_Queue_release( sem, level, &queue_context );
+    _Sem_Queue_release( sem, level, &queue_context );
   } else {
     const Thread_queue_Operations *operations;
     Thread_Control *first;