On Fri, May 27, 2016 at 9:50 AM, Sebastian Huber
<sebastian.hu...@embedded-brains.de> wrote:
> ---
> cpukit/posix/include/rtems/posix/semaphoreimpl.h | 2 +
> cpukit/posix/src/semaphorecreatesupp.c | 6 +--
> cpukit/posix/src/semaphoredeletesupp.c | 6 ++-
> cpukit/posix/src/semaphorewaitsupp.c | 1 +
> cpukit/posix/src/sempost.c | 1 +
> cpukit/rtems/include/rtems/rtems/sem.h | 18 +++++++
> cpukit/rtems/include/rtems/rtems/semimpl.h | 25 +++++++++
> cpukit/rtems/src/semcreate.c | 31 ++++++-----
> cpukit/rtems/src/semdelete.c | 68
> ++++++++++++++----------
> cpukit/rtems/src/semflush.c | 54 +++++++++----------
> cpukit/rtems/src/semobtain.c | 59 ++++++++++----------
> cpukit/rtems/src/semrelease.c | 44 +++++++--------
> cpukit/score/include/rtems/score/coresem.h | 17 ------
> cpukit/score/include/rtems/score/coresemimpl.h | 54 ++++++++++---------
> cpukit/score/src/coresem.c | 11 +---
> cpukit/score/src/mpci.c | 11 +++-
> 16 files changed, 227 insertions(+), 181 deletions(-)
>
> diff --git a/cpukit/posix/include/rtems/posix/semaphoreimpl.h
> b/cpukit/posix/include/rtems/posix/semaphoreimpl.h
> index 1521ead..17d3f64 100644
> --- a/cpukit/posix/include/rtems/posix/semaphoreimpl.h
> +++ b/cpukit/posix/include/rtems/posix/semaphoreimpl.h
> @@ -34,6 +34,8 @@ extern "C" {
> */
> extern Objects_Information _POSIX_Semaphore_Information;
>
> +#define POSIX_SEMAPHORE_TQ_OPERATIONS &_Thread_queue_Operations_FIFO
> +
> RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *
> _POSIX_Semaphore_Allocate_unprotected( void )
> {
> diff --git a/cpukit/posix/src/semaphorecreatesupp.c
> b/cpukit/posix/src/semaphorecreatesupp.c
> index 79db888..d66e194 100644
> --- a/cpukit/posix/src/semaphorecreatesupp.c
> +++ b/cpukit/posix/src/semaphorecreatesupp.c
> @@ -92,11 +92,7 @@ int _POSIX_Semaphore_Create_support(
> * thing is certain, no matter what we decide, it won't be
> * the same as all other POSIX implementations. :)
> */
> - _CORE_semaphore_Initialize(
> - &the_semaphore->Semaphore,
> - CORE_SEMAPHORE_DISCIPLINES_FIFO,
> - value
> - );
> + _CORE_semaphore_Initialize( &the_semaphore->Semaphore, value );
>
> /*
> * Make the semaphore available for use.
> diff --git a/cpukit/posix/src/semaphoredeletesupp.c
> b/cpukit/posix/src/semaphoredeletesupp.c
> index 2d39b2a..325e4a6 100644
> --- a/cpukit/posix/src/semaphoredeletesupp.c
> +++ b/cpukit/posix/src/semaphoredeletesupp.c
> @@ -27,7 +27,11 @@ void _POSIX_Semaphore_Delete(
> {
> if ( !the_semaphore->linked && !the_semaphore->open_count ) {
> _Objects_Close( &_POSIX_Semaphore_Information, &the_semaphore->Object );
> - _CORE_semaphore_Destroy( &the_semaphore->Semaphore, queue_context );
> + _CORE_semaphore_Destroy(
> + &the_semaphore->Semaphore,
> + POSIX_SEMAPHORE_TQ_OPERATIONS,
> + queue_context
> + );
> _POSIX_Semaphore_Free( the_semaphore );
> } else {
> _CORE_semaphore_Release( &the_semaphore->Semaphore, queue_context );
> diff --git a/cpukit/posix/src/semaphorewaitsupp.c
> b/cpukit/posix/src/semaphorewaitsupp.c
> index d8e0d69..9ba8d55 100644
> --- a/cpukit/posix/src/semaphorewaitsupp.c
> +++ b/cpukit/posix/src/semaphorewaitsupp.c
> @@ -43,6 +43,7 @@ int _POSIX_Semaphore_Wait_support(
>
> status = _CORE_semaphore_Seize(
> &the_semaphore->Semaphore,
> + POSIX_SEMAPHORE_TQ_OPERATIONS,
> _Thread_Executing,
> blocking,
> timeout,
> diff --git a/cpukit/posix/src/sempost.c b/cpukit/posix/src/sempost.c
> index 322663b..da2b1a5 100644
> --- a/cpukit/posix/src/sempost.c
> +++ b/cpukit/posix/src/sempost.c
> @@ -40,6 +40,7 @@ int sem_post(
>
> status = _CORE_semaphore_Surrender(
> &the_semaphore->Semaphore,
> + POSIX_SEMAPHORE_TQ_OPERATIONS,
> SEM_VALUE_MAX,
> &queue_context
> );
> diff --git a/cpukit/rtems/include/rtems/rtems/sem.h
> b/cpukit/rtems/include/rtems/rtems/sem.h
> index 2c99f57..fe74f44 100644
> --- a/cpukit/rtems/include/rtems/rtems/sem.h
> +++ b/cpukit/rtems/include/rtems/rtems/sem.h
> @@ -97,6 +97,24 @@ typedef struct {
> } Core_control;
>
> /**
> + * @brief The semaphore variant.
> + *
> + * @see Semaphore_Variant.
> + */
> + unsigned int variant : 3;
> +
Shouldn't this only need 1 bit in uniproc, and 2 bits in smp?
The width requirement for bit fields should be more explicitly stated,
and also mentioned in the cross-referenced enum so that if someone
increases the enum cases they would check the bit width here too.
I noticed the same bit width approach is used in patch 12/12, please
add similar doco there to cross-reference the enum and the bit field.
> + /**
> + * @brief The semaphore thread queue discipline.
> + *
> + * @see Semaphore_Discipline.
> + */
> + unsigned int discipline : 1;
> +
> +#if defined(RTEMS_MULTIPROCESSING)
> + unsigned int is_global : 1;
> +#endif
> +
> + /**
> * This is the Classic API attribute provided to the create directive.
> * It is translated into behavioral attributes on the SuperCore Semaphore
> * or Mutex instance.
> diff --git a/cpukit/rtems/include/rtems/rtems/semimpl.h
> b/cpukit/rtems/include/rtems/rtems/semimpl.h
> index a498927..813f885 100644
> --- a/cpukit/rtems/include/rtems/rtems/semimpl.h
> +++ b/cpukit/rtems/include/rtems/rtems/semimpl.h
> @@ -26,12 +26,37 @@
> extern "C" {
> #endif
>
> +typedef enum {
> + SEMAPHORE_VARIANT_MUTEX,
> + SEMAPHORE_VARIANT_COUNTING
> +#if defined(RTEMS_SMP)
> + ,
> + SEMAPHORE_VARIANT_MRSP
> +#endif
> +} Semaphore_Variant;
> +
> +typedef enum {
> + SEMAPHORE_DISCIPLINE_PRIORITY,
> + SEMAPHORE_DISCIPLINE_FIFO
> +} Semaphore_Discipline;
> +
> /**
> * The following defines the information control block used to manage
> * this class of objects.
> */
> extern Objects_Information _Semaphore_Information;
>
> +RTEMS_INLINE_ROUTINE const Thread_queue_Operations
> *_Semaphore_Get_operations(
> + const Semaphore_Control *the_semaphore
> +)
> +{
> + if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) {
> + return &_Thread_queue_Operations_priority;
> + } else {
> + return &_Thread_queue_Operations_FIFO;
> + }
> +}
> +
> /**
> * @brief Allocates a semaphore control block from
> * the inactive chain of free semaphore control blocks.
> diff --git a/cpukit/rtems/src/semcreate.c b/cpukit/rtems/src/semcreate.c
> index 83d46b6..be8f9f5 100644
> --- a/cpukit/rtems/src/semcreate.c
> +++ b/cpukit/rtems/src/semcreate.c
> @@ -61,10 +61,9 @@ rtems_status_code rtems_semaphore_create(
> rtems_id *id
> )
> {
> - Semaphore_Control *the_semaphore;
> - CORE_mutex_Attributes the_mutex_attr;
> - CORE_semaphore_Disciplines semaphore_discipline;
> - Status_Control status;
> + Semaphore_Control *the_semaphore;
> + CORE_mutex_Attributes the_mutex_attr;
> + Status_Control status;
>
> if ( !rtems_is_name_valid( name ) )
> return RTEMS_INVALID_NAME;
> @@ -125,6 +124,8 @@ rtems_status_code rtems_semaphore_create(
> }
>
> #if defined(RTEMS_MULTIPROCESSING)
> + the_semaphore->is_global = _Attributes_Is_global( attribute_set );
> +
> if ( _Attributes_Is_global( attribute_set ) &&
> ! ( _Objects_MP_Allocate_and_open( &_Semaphore_Information, name,
> the_semaphore->Object.id, false ) ) ) {
> @@ -136,29 +137,25 @@ rtems_status_code rtems_semaphore_create(
>
> the_semaphore->attribute_set = attribute_set;
>
> + if ( _Attributes_Is_priority( attribute_set ) ) {
> + the_semaphore->discipline = SEMAPHORE_DISCIPLINE_PRIORITY;
> + } else {
> + the_semaphore->discipline = SEMAPHORE_DISCIPLINE_FIFO;
> + }
> +
> /*
> * Initialize it as a counting semaphore.
> */
> if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
> - if ( _Attributes_Is_priority( attribute_set ) )
> - semaphore_discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
> - else
> - semaphore_discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
> -
> - /*
> - * The following are just to make Purify happy.
> - */
> - the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
> - the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
> -
> + the_semaphore->variant = SEMAPHORE_VARIANT_COUNTING;
> _CORE_semaphore_Initialize(
> &the_semaphore->Core_control.semaphore,
> - semaphore_discipline,
> count
> );
> status = STATUS_SUCCESSFUL;
> #if defined(RTEMS_SMP)
> } else if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set
> ) ) {
> + the_semaphore->variant = SEMAPHORE_VARIANT_MRSP;
> status = _MRSP_Initialize(
> &the_semaphore->Core_control.mrsp,
> priority_ceiling,
> @@ -167,6 +164,8 @@ rtems_status_code rtems_semaphore_create(
> );
> #endif
> } else {
> + the_semaphore->variant = SEMAPHORE_VARIANT_MUTEX;
> +
> /*
> * It is either simple binary semaphore or a more powerful mutex
> * style binary semaphore. This is the mutex style.
> diff --git a/cpukit/rtems/src/semdelete.c b/cpukit/rtems/src/semdelete.c
> index 16889cd..45c356f 100644
> --- a/cpukit/rtems/src/semdelete.c
> +++ b/cpukit/rtems/src/semdelete.c
> @@ -53,22 +53,27 @@ rtems_status_code rtems_semaphore_delete(
> &queue_context.Lock_context
> );
>
> + switch ( the_semaphore->variant ) {
> + case SEMAPHORE_VARIANT_MUTEX:
> + if (
> + _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex )
> + && !_Attributes_Is_simple_binary_semaphore( attribute_set )
> + ) {
> + status = STATUS_RESOURCE_IN_USE;
> + } else {
> + status = STATUS_SUCCESSFUL;
> + }
> +
> + break;
> #if defined(RTEMS_SMP)
> - if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
> - status = _MRSP_Can_destroy( &the_semaphore->Core_control.mrsp );
> - } else
> + case SEMAPHORE_VARIANT_MRSP:
> + status = _MRSP_Can_destroy( &the_semaphore->Core_control.mrsp );
> + break;
> #endif
> - if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
> - if (
> - _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex )
> - && !_Attributes_Is_simple_binary_semaphore( attribute_set )
> - ) {
> - status = STATUS_RESOURCE_IN_USE;
> - } else {
> + default:
> + _Assert( the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING );
> status = STATUS_SUCCESSFUL;
> - }
> - } else {
> - status = STATUS_SUCCESSFUL;
> + break;
> }
>
> if ( status != STATUS_SUCCESSFUL ) {
> @@ -82,27 +87,32 @@ rtems_status_code rtems_semaphore_delete(
>
> _Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
>
> + switch ( the_semaphore->variant ) {
> + case SEMAPHORE_VARIANT_MUTEX:
> + _CORE_mutex_Flush(
> + &the_semaphore->Core_control.mutex,
> + _Thread_queue_Flush_status_object_was_deleted,
> + &queue_context
> + );
> + _CORE_mutex_Destroy( &the_semaphore->Core_control.mutex );
> + break;
> #if defined(RTEMS_SMP)
> - if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
> - _MRSP_Destroy( &the_semaphore->Core_control.mrsp, &queue_context );
> - } else
> + case SEMAPHORE_VARIANT_MRSP:
> + _MRSP_Destroy( &the_semaphore->Core_control.mrsp, &queue_context );
> + break;
> #endif
> - if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
> - _CORE_mutex_Flush(
> - &the_semaphore->Core_control.mutex,
> - _Thread_queue_Flush_status_object_was_deleted,
> - &queue_context
> - );
> - _CORE_mutex_Destroy( &the_semaphore->Core_control.mutex );
> - } else {
> - _CORE_semaphore_Destroy(
> - &the_semaphore->Core_control.semaphore,
> - &queue_context
> - );
> + default:
> + _Assert( the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING );
> + _CORE_semaphore_Destroy(
> + &the_semaphore->Core_control.semaphore,
> + _Semaphore_Get_operations( the_semaphore ),
> + &queue_context
> + );
> + break;
> }
>
> #if defined(RTEMS_MULTIPROCESSING)
> - if ( _Attributes_Is_global( attribute_set ) ) {
> + if ( the_semaphore->is_global ) {
>
> _Objects_MP_Close( &_Semaphore_Information, id );
>
> diff --git a/cpukit/rtems/src/semflush.c b/cpukit/rtems/src/semflush.c
> index 07d4aa9..f768bbd 100644
> --- a/cpukit/rtems/src/semflush.c
> +++ b/cpukit/rtems/src/semflush.c
> @@ -19,13 +19,11 @@
> #endif
>
> #include <rtems/rtems/semimpl.h>
> -#include <rtems/rtems/attrimpl.h>
>
> rtems_status_code rtems_semaphore_flush( rtems_id id )
> {
> Semaphore_Control *the_semaphore;
> Thread_queue_Context queue_context;
> - rtems_attribute attribute_set;
>
> the_semaphore = _Semaphore_Get( id, &queue_context );
>
> @@ -39,38 +37,40 @@ rtems_status_code rtems_semaphore_flush( rtems_id id )
> return RTEMS_INVALID_ID;
> }
>
> - attribute_set = the_semaphore->attribute_set;
> -
> + _Thread_queue_Acquire_critical(
> + &the_semaphore->Core_control.Wait_queue,
> + &queue_context.Lock_context
> + );
> _Thread_queue_Context_set_MP_callout(
> &queue_context,
> _Semaphore_MP_Send_object_was_deleted
> );
>
> + switch ( the_semaphore->variant ) {
> #if defined(RTEMS_SMP)
> - if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
> - _ISR_lock_ISR_enable( &queue_context.Lock_context );
> - return RTEMS_NOT_DEFINED;
> - } else
> + case SEMAPHORE_VARIANT_MRSP:
> + _Thread_queue_Release(
> + &the_semaphore->Core_control.Wait_queue,
> + &queue_context.Lock_context
> + );
> + return RTEMS_NOT_DEFINED;
> #endif
> - if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
> - _CORE_mutex_Acquire_critical(
> - &the_semaphore->Core_control.mutex,
> - &queue_context
> - );
> - _CORE_mutex_Flush(
> - &the_semaphore->Core_control.mutex,
> - _Thread_queue_Flush_status_unavailable,
> - &queue_context
> - );
> - } else {
> - _CORE_semaphore_Acquire_critical(
> - &the_semaphore->Core_control.semaphore,
> - &queue_context
> - );
> - _CORE_semaphore_Flush(
> - &the_semaphore->Core_control.semaphore,
> - &queue_context
> - );
> + case SEMAPHORE_VARIANT_MUTEX:
> + _CORE_mutex_Flush(
> + &the_semaphore->Core_control.mutex,
> + _Thread_queue_Flush_status_unavailable,
> + &queue_context
> + );
> + break;
> + default:
> + _Assert( the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING );
> + _CORE_semaphore_Flush(
> + &the_semaphore->Core_control.semaphore,
> + _Semaphore_Get_operations( the_semaphore ),
> + &queue_context
> + );
> + break;
> }
> +
> return RTEMS_SUCCESSFUL;
> }
> diff --git a/cpukit/rtems/src/semobtain.c b/cpukit/rtems/src/semobtain.c
> index 8cb195c..00474da 100644
> --- a/cpukit/rtems/src/semobtain.c
> +++ b/cpukit/rtems/src/semobtain.c
> @@ -54,7 +54,6 @@ rtems_status_code rtems_semaphore_obtain(
> Semaphore_Control *the_semaphore;
> Thread_queue_Context queue_context;
> Thread_Control *executing;
> - rtems_attribute attribute_set;
> bool wait;
> Status_Control status;
>
> @@ -69,36 +68,40 @@ rtems_status_code rtems_semaphore_obtain(
> }
>
> executing = _Thread_Executing;
> - attribute_set = the_semaphore->attribute_set;
> wait = !_Options_Is_no_wait( option_set );
> +
> + switch ( the_semaphore->variant ) {
> #if defined(RTEMS_SMP)
> - if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
> - status = _MRSP_Seize(
> - &the_semaphore->Core_control.mrsp,
> - executing,
> - wait,
> - timeout,
> - &queue_context
> - );
> - } else
> + case SEMAPHORE_VARIANT_MRSP:
> + status = _MRSP_Seize(
> + &the_semaphore->Core_control.mrsp,
> + executing,
> + wait,
> + timeout,
> + &queue_context
> + );
> + break;
> #endif
> - if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
> - status = _CORE_mutex_Seize(
> - &the_semaphore->Core_control.mutex,
> - executing,
> - wait,
> - timeout,
> - &queue_context
> - );
> - } else {
> - /* must be a counting semaphore */
> - status = _CORE_semaphore_Seize(
> - &the_semaphore->Core_control.semaphore,
> - executing,
> - wait,
> - timeout,
> - &queue_context
> - );
> + case SEMAPHORE_VARIANT_MUTEX:
> + status = _CORE_mutex_Seize(
> + &the_semaphore->Core_control.mutex,
> + executing,
> + wait,
> + timeout,
> + &queue_context
> + );
> + break;
> + default:
> + _Assert( the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING );
> + status = _CORE_semaphore_Seize(
> + &the_semaphore->Core_control.semaphore,
> + _Semaphore_Get_operations( the_semaphore ),
> + executing,
> + wait,
> + timeout,
> + &queue_context
> + );
> + break;
> }
>
> return _Status_Get( status );
> diff --git a/cpukit/rtems/src/semrelease.c b/cpukit/rtems/src/semrelease.c
> index 10fe743..d18901a 100644
> --- a/cpukit/rtems/src/semrelease.c
> +++ b/cpukit/rtems/src/semrelease.c
> @@ -22,14 +22,12 @@
> #endif
>
> #include <rtems/rtems/semimpl.h>
> -#include <rtems/rtems/attrimpl.h>
> #include <rtems/rtems/statusimpl.h>
>
> rtems_status_code rtems_semaphore_release( rtems_id id )
> {
> Semaphore_Control *the_semaphore;
> Thread_queue_Context queue_context;
> - rtems_attribute attribute_set;
> Status_Control status;
>
> the_semaphore = _Semaphore_Get( id, &queue_context );
> @@ -47,27 +45,31 @@ rtems_status_code rtems_semaphore_release( rtems_id id )
> _Semaphore_Core_mutex_mp_support
> );
>
> - attribute_set = the_semaphore->attribute_set;
> + switch ( the_semaphore->variant ) {
> #if defined(RTEMS_SMP)
> - if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
> - status = _MRSP_Surrender(
> - &the_semaphore->Core_control.mrsp,
> - _Thread_Executing,
> - &queue_context
> - );
> - } else
> + case SEMAPHORE_VARIANT_MRSP:
> + status = _MRSP_Surrender(
> + &the_semaphore->Core_control.mrsp,
> + _Thread_Executing,
> + &queue_context
> + );
> + break;
> #endif
> - if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
> - status = _CORE_mutex_Surrender(
> - &the_semaphore->Core_control.mutex,
> - &queue_context
> - );
> - } else {
> - status = _CORE_semaphore_Surrender(
> - &the_semaphore->Core_control.semaphore,
> - UINT32_MAX,
> - &queue_context
> - );
> + case SEMAPHORE_VARIANT_MUTEX:
> + status = _CORE_mutex_Surrender(
> + &the_semaphore->Core_control.mutex,
> + &queue_context
> + );
> + break;
> + default:
> + _Assert( the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING );
> + status = _CORE_semaphore_Surrender(
> + &the_semaphore->Core_control.semaphore,
> + _Semaphore_Get_operations( the_semaphore ),
> + UINT32_MAX,
> + &queue_context
> + );
> + break;
> }
>
> return _Status_Get( status );
> diff --git a/cpukit/score/include/rtems/score/coresem.h
> b/cpukit/score/include/rtems/score/coresem.h
> index 84fde0b..f9d3ac8 100644
> --- a/cpukit/score/include/rtems/score/coresem.h
> +++ b/cpukit/score/include/rtems/score/coresem.h
> @@ -38,18 +38,6 @@ extern "C" {
> /**@{*/
>
> /**
> - * Blocking disciplines for a semaphore.
> - */
> -typedef enum {
> - /** This specifies that threads will wait for the semaphore in FIFO order.
> */
> - CORE_SEMAPHORE_DISCIPLINES_FIFO,
> - /** This specifies that threads will wait for the semaphore in
> - * priority order.
> - */
> - CORE_SEMAPHORE_DISCIPLINES_PRIORITY
> -} CORE_semaphore_Disciplines;
> -
> -/**
> * The following defines the control block used to manage each
> * counting semaphore.
> */
> @@ -59,11 +47,6 @@ typedef struct {
> */
> Thread_queue_Control Wait_queue;
>
> - /**
> - * @brief The thread queue operations according to the blocking discipline.
> - */
> - const Thread_queue_Operations *operations;
> -
> /** This element contains the current count of this semaphore. */
> uint32_t count;
> } CORE_semaphore_Control;
> diff --git a/cpukit/score/include/rtems/score/coresemimpl.h
> b/cpukit/score/include/rtems/score/coresemimpl.h
> index a55089e..24d8c51 100644
> --- a/cpukit/score/include/rtems/score/coresemimpl.h
> +++ b/cpukit/score/include/rtems/score/coresemimpl.h
> @@ -46,13 +46,11 @@ extern "C" {
> * This routine initializes the semaphore based on the parameters passed.
> *
> * @param[in] the_semaphore is the semaphore to initialize
> - * @param[in] discipline the blocking discipline
> * @param[in] initial_value is the initial count of the semaphore
> */
> void _CORE_semaphore_Initialize(
> - CORE_semaphore_Control *the_semaphore,
> - CORE_semaphore_Disciplines discipline,
> - uint32_t initial_value
> + CORE_semaphore_Control *the_semaphore,
> + uint32_t initial_value
> );
>
> RTEMS_INLINE_ROUTINE void _CORE_semaphore_Acquire_critical(
> @@ -78,13 +76,14 @@ RTEMS_INLINE_ROUTINE void _CORE_semaphore_Release(
> }
>
> RTEMS_INLINE_ROUTINE void _CORE_semaphore_Destroy(
> - CORE_semaphore_Control *the_semaphore,
> - Thread_queue_Context *queue_context
> + CORE_semaphore_Control *the_semaphore,
> + const Thread_queue_Operations *operations,
> + Thread_queue_Context *queue_context
> )
> {
> _Thread_queue_Flush_critical(
> &the_semaphore->Wait_queue.Queue,
> - the_semaphore->operations,
> + operations,
> _Thread_queue_Flush_status_object_was_deleted,
> queue_context
> );
> @@ -99,15 +98,17 @@ RTEMS_INLINE_ROUTINE void _CORE_semaphore_Destroy(
> * given to that task. Otherwise, the unit will be returned to the
> semaphore.
> *
> * @param[in] the_semaphore is the semaphore to surrender
> + * @param[in] operations The thread queue operations.
> * @param[in] queue_context is a temporary variable used to contain the ISR
> * disable level cookie
> *
> * @retval an indication of whether the routine succeeded or failed
> */
> RTEMS_INLINE_ROUTINE Status_Control _CORE_semaphore_Surrender(
> - CORE_semaphore_Control *the_semaphore,
> - uint32_t maximum_count,
> - Thread_queue_Context *queue_context
> + CORE_semaphore_Control *the_semaphore,
> + const Thread_queue_Operations *operations,
> + uint32_t maximum_count,
> + Thread_queue_Context *queue_context
> )
> {
> Thread_Control *the_thread;
> @@ -119,12 +120,12 @@ RTEMS_INLINE_ROUTINE Status_Control
> _CORE_semaphore_Surrender(
>
> the_thread = _Thread_queue_First_locked(
> &the_semaphore->Wait_queue,
> - the_semaphore->operations
> + operations
> );
> if ( the_thread != NULL ) {
> _Thread_queue_Extract_critical(
> &the_semaphore->Wait_queue.Queue,
> - the_semaphore->operations,
> + operations,
> the_thread,
> queue_context
> );
> @@ -141,13 +142,14 @@ RTEMS_INLINE_ROUTINE Status_Control
> _CORE_semaphore_Surrender(
> }
>
> RTEMS_INLINE_ROUTINE void _CORE_semaphore_Flush(
> - CORE_semaphore_Control *the_semaphore,
> - Thread_queue_Context *queue_context
> + CORE_semaphore_Control *the_semaphore,
> + const Thread_queue_Operations *operations,
> + Thread_queue_Context *queue_context
> )
> {
> _Thread_queue_Flush_critical(
> &the_semaphore->Wait_queue.Queue,
> - the_semaphore->operations,
> + operations,
> _Thread_queue_Flush_status_unavailable,
> queue_context
> );
> @@ -161,7 +163,7 @@ RTEMS_INLINE_ROUTINE void _CORE_semaphore_Flush(
> * @return the current count of this semaphore
> */
> RTEMS_INLINE_ROUTINE uint32_t _CORE_semaphore_Get_count(
> - CORE_semaphore_Control *the_semaphore
> + const CORE_semaphore_Control *the_semaphore
> )
> {
> return the_semaphore->count;
> @@ -174,23 +176,23 @@ RTEMS_INLINE_ROUTINE uint32_t
> _CORE_semaphore_Get_count(
> * available.
> *
> * @param[in] the_semaphore is the semaphore to obtain
> - * @param[in,out] executing The currently executing thread.
> + * @param[in] operations The thread queue operations.
> + * @param[in] executing The currently executing thread.
> * @param[in] wait is true if the thread is willing to wait
> * @param[in] timeout is the maximum number of ticks to block
> * @param[in] queue_context is a temporary variable used to contain the ISR
> * disable level cookie
> - *
> - * @note There is currently no MACRO version of this routine.
> */
> RTEMS_INLINE_ROUTINE Status_Control _CORE_semaphore_Seize(
> - CORE_semaphore_Control *the_semaphore,
> - Thread_Control *executing,
> - bool wait,
> - Watchdog_Interval timeout,
> - Thread_queue_Context *queue_context
> + CORE_semaphore_Control *the_semaphore,
> + const Thread_queue_Operations *operations,
> + Thread_Control *executing,
> + bool wait,
> + Watchdog_Interval timeout,
> + Thread_queue_Context *queue_context
> )
> {
> - /* disabled when you get here */
> + _Assert( _ISR_Get_level() != 0 );
>
> _CORE_semaphore_Acquire_critical( the_semaphore, queue_context );
> if ( the_semaphore->count != 0 ) {
> @@ -207,7 +209,7 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_semaphore_Seize(
> _Thread_queue_Context_set_expected_level( queue_context, 1 );
> _Thread_queue_Enqueue_critical(
> &the_semaphore->Wait_queue.Queue,
> - the_semaphore->operations,
> + operations,
> executing,
> STATES_WAITING_FOR_SEMAPHORE,
> timeout,
> diff --git a/cpukit/score/src/coresem.c b/cpukit/score/src/coresem.c
> index 2bdd81c..e928f3d 100644
> --- a/cpukit/score/src/coresem.c
> +++ b/cpukit/score/src/coresem.c
> @@ -21,18 +21,11 @@
> #include <rtems/score/coresemimpl.h>
>
> void _CORE_semaphore_Initialize(
> - CORE_semaphore_Control *the_semaphore,
> - CORE_semaphore_Disciplines discipline,
> - uint32_t initial_value
> + CORE_semaphore_Control *the_semaphore,
> + uint32_t initial_value
> )
> {
> the_semaphore->count = initial_value;
>
> _Thread_queue_Initialize( &the_semaphore->Wait_queue );
> -
> - if ( discipline == CORE_SEMAPHORE_DISCIPLINES_PRIORITY ) {
> - the_semaphore->operations = &_Thread_queue_Operations_priority;
> - } else {
> - the_semaphore->operations = &_Thread_queue_Operations_FIFO;
> - }
> }
> diff --git a/cpukit/score/src/mpci.c b/cpukit/score/src/mpci.c
> index 1e26b1f..721868e 100644
> --- a/cpukit/score/src/mpci.c
> +++ b/cpukit/score/src/mpci.c
> @@ -35,6 +35,8 @@ RTEMS_STATIC_ASSERT(
> MPCI_Internal_packet
> );
>
> +#define MPCI_SEMAPHORE_TQ_OPERATIONS &_Thread_queue_Operations_FIFO
> +
> bool _System_state_Is_multiprocessing;
>
> rtems_multiprocessing_table *_Configuration_MP_table;
> @@ -119,7 +121,6 @@ static void _MPCI_Handler_initialization( void )
>
> _CORE_semaphore_Initialize(
> &_MPCI_Semaphore,
> - CORE_SEMAPHORE_DISCIPLINES_FIFO,
> 0 /* initial_value */
> );
> }
> @@ -334,6 +335,7 @@ void _MPCI_Receive_server(
> _ISR_lock_ISR_disable( &queue_context.Lock_context );
> _CORE_semaphore_Seize(
> &_MPCI_Semaphore,
> + MPCI_SEMAPHORE_TQ_OPERATIONS,
> executing,
> true,
> WATCHDOG_NO_TIMEOUT,
> @@ -372,7 +374,12 @@ void _MPCI_Announce ( void )
> Thread_queue_Context queue_context;
>
> _ISR_lock_ISR_disable( &queue_context.Lock_context );
> - (void) _CORE_semaphore_Surrender( &_MPCI_Semaphore, UINT32_MAX,
> &queue_context );
> + (void) _CORE_semaphore_Surrender(
> + &_MPCI_Semaphore,
> + MPCI_SEMAPHORE_TQ_OPERATIONS,
> + UINT32_MAX,
> + &queue_context
> + );
> }
>
> void _MPCI_Internal_packets_Send_process_packet (
> --
> 1.8.4.5
>
> _______________________________________________
> devel mailing list
> devel@rtems.org
> http://lists.rtems.org/mailman/listinfo/devel
_______________________________________________
devel mailing list
devel@rtems.org
http://lists.rtems.org/mailman/listinfo/devel
