diff options
| author | Sebastian Huber <sebastian.huber@embedded-brains.de> | 2016-05-23 11:40:18 +0200 |
|---|---|---|
| committer | Sebastian Huber <sebastian.huber@embedded-brains.de> | 2016-05-25 12:43:54 +0200 |
| commit | 631b3c8967a329cdd53e54365e4e4c0aa93a4251 (patch) | |
| tree | 3a750b145a90c90aa86222c26ee68aeb8c87a417 | |
| parent | score: Get rid of mp_id parameter (diff) | |
| download | rtems-631b3c8967a329cdd53e54365e4e4c0aa93a4251.tar.bz2 | |
score: Move thread queue MP callout to context
Drop the multiprocessing (MP) dependent callout parameter from the
thread queue extract, dequeue, flush and unblock methods. Merge this
parameter with the lock context into new structure Thread_queue_Context.
This helps to gets rid of the conditionally compiled method call
helpers.
98 files changed, 1048 insertions, 1306 deletions
diff --git a/cpukit/libnetworking/rtems/rtems_glue.c b/cpukit/libnetworking/rtems/rtems_glue.c index 9ece2b10d4..edf551e165 100644 --- a/cpukit/libnetworking/rtems/rtems_glue.c +++ b/cpukit/libnetworking/rtems/rtems_glue.c @@ -371,18 +371,19 @@ void rtems_bsdnet_semaphore_obtain (void) { #ifdef RTEMS_FAST_MUTEX - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; Thread_Control *executing; - _ISR_lock_ISR_disable(&lock_context); if (!the_networkSemaphore) rtems_panic ("rtems-net: network sema obtain: network not initialised\n"); + _Thread_queue_Context_initialize(&queue_context, NULL); + _ISR_lock_ISR_disable(&queue_context.Lock_context); executing = _Thread_Executing; _CORE_mutex_Seize ( &the_networkSemaphore->Core_control.mutex, executing, 1, /* wait */ 0, /* forever */ - &lock_context + &queue_context ); if (executing->Wait.return_code) rtems_panic ("rtems-net: can't obtain network sema: %d\n", @@ -404,16 +405,16 @@ void rtems_bsdnet_semaphore_release (void) { #ifdef RTEMS_FAST_MUTEX - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; CORE_mutex_Status status; if (!the_networkSemaphore) rtems_panic ("rtems-net: network sema obtain: network not initialised\n"); - _ISR_lock_ISR_disable(&lock_context); + _Thread_queue_Context_initialize(&queue_context, NULL); + _ISR_lock_ISR_disable(&queue_context.Lock_context); status = _CORE_mutex_Surrender ( &the_networkSemaphore->Core_control.mutex, - NULL, - &lock_context + &queue_context ); if (status != CORE_MUTEX_STATUS_SUCCESSFUL) rtems_panic ("rtems-net: can't release network sema: %i\n"); diff --git a/cpukit/posix/include/rtems/posix/barrierimpl.h b/cpukit/posix/include/rtems/posix/barrierimpl.h index 5173531f37..e04f1354ae 100644 --- a/cpukit/posix/include/rtems/posix/barrierimpl.h +++ b/cpukit/posix/include/rtems/posix/barrierimpl.h @@ -77,14 +77,15 @@ RTEMS_INLINE_ROUTINE void _POSIX_Barrier_Free ( _Objects_Free( &_POSIX_Barrier_Information, &the_barrier->Object ); } -RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get ( +RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get( const pthread_barrier_t *barrier, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { + _Thread_queue_Context_initialize( queue_context, NULL ); return (POSIX_Barrier_Control *) _Objects_Get( (Objects_Id) *barrier, - lock_context, + &queue_context->Lock_context, &_POSIX_Barrier_Information ); } diff --git a/cpukit/posix/include/rtems/posix/condimpl.h b/cpukit/posix/include/rtems/posix/condimpl.h index b17886948e..736f06be7b 100644 --- a/cpukit/posix/include/rtems/posix/condimpl.h +++ b/cpukit/posix/include/rtems/posix/condimpl.h @@ -63,18 +63,21 @@ RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Destroy( RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Acquire_critical( POSIX_Condition_variables_Control *the_cond, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { - _Thread_queue_Acquire_critical( &the_cond->Wait_queue, lock_context ); + _Thread_queue_Acquire_critical( + &the_cond->Wait_queue, + &queue_context->Lock_context + ); } RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Release( POSIX_Condition_variables_Control *the_cond, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { - _Thread_queue_Release( &the_cond->Wait_queue, lock_context ); + _Thread_queue_Release( &the_cond->Wait_queue, &queue_context->Lock_context ); } /** @@ -107,8 +110,8 @@ RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free ( } POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get( - pthread_cond_t *cond, - ISR_lock_Context *lock_context + pthread_cond_t *cond, + Thread_queue_Context *queue_context ); /** diff --git a/cpukit/posix/include/rtems/posix/mqueueimpl.h b/cpukit/posix/include/rtems/posix/mqueueimpl.h index 3185970035..2317358f64 100644 --- a/cpukit/posix/include/rtems/posix/mqueueimpl.h +++ b/cpukit/posix/include/rtems/posix/mqueueimpl.h @@ -43,7 +43,7 @@ extern Objects_Information _POSIX_Message_queue_Information; */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ); /*@ @@ -107,12 +107,16 @@ RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free( RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get( - Objects_Id id, - ISR_lock_Context *lock_context + Objects_Id id, + Thread_queue_Context *queue_context ) { - return (POSIX_Message_queue_Control *) - _Objects_Get( id, lock_context, &_POSIX_Message_queue_Information ); + _Thread_queue_Context_initialize( queue_context, NULL ); + return (POSIX_Message_queue_Control *) _Objects_Get( + id, + &queue_context->Lock_context, + &_POSIX_Message_queue_Information + ); } /* diff --git a/cpukit/posix/include/rtems/posix/muteximpl.h b/cpukit/posix/include/rtems/posix/muteximpl.h index 7627d3d1f7..4c7852b2c5 100644 --- a/cpukit/posix/include/rtems/posix/muteximpl.h +++ b/cpukit/posix/include/rtems/posix/muteximpl.h @@ -127,8 +127,8 @@ RTEMS_INLINE_ROUTINE int _POSIX_Mutex_Translate_core_mutex_return_code( * @note: This version of the method uses an interrupt critical section. */ POSIX_Mutex_Control *_POSIX_Mutex_Get( - pthread_mutex_t *mutex, - ISR_lock_Context *lock_context + pthread_mutex_t *mutex, + Thread_queue_Context *queue_context ); RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Get_no_protection( diff --git a/cpukit/posix/include/rtems/posix/posixapi.h b/cpukit/posix/include/rtems/posix/posixapi.h index a16b6ad54b..a5afe92872 100644 --- a/cpukit/posix/include/rtems/posix/posixapi.h +++ b/cpukit/posix/include/rtems/posix/posixapi.h @@ -71,7 +71,7 @@ RTEMS_INLINE_ROUTINE int _POSIX_Get_by_name_error( #define _POSIX_Get_object_body( \ type, \ id, \ - lock_context, \ + queue_context, \ info, \ initializer, \ init \ @@ -80,14 +80,16 @@ RTEMS_INLINE_ROUTINE int _POSIX_Get_by_name_error( if ( id == NULL ) { \ return NULL; \ } \ - the_object = _Objects_Get( (Objects_Id) *id, lock_context, info ); \ + the_object = \ + _Objects_Get( (Objects_Id) *id, &queue_context->Lock_context, info ); \ if ( the_object == NULL ) { \ _Once_Lock(); \ if ( *id == initializer ) { \ init( id, NULL ); \ } \ _Once_Unlock(); \ - the_object = _Objects_Get( (Objects_Id) *id, lock_context, info ); \ + the_object = \ + _Objects_Get( (Objects_Id) *id, &queue_context->Lock_context, info ); \ } \ return (type *) the_object diff --git a/cpukit/posix/include/rtems/posix/rwlockimpl.h b/cpukit/posix/include/rtems/posix/rwlockimpl.h index 6f3088ebd4..4ab9395489 100644 --- a/cpukit/posix/include/rtems/posix/rwlockimpl.h +++ b/cpukit/posix/include/rtems/posix/rwlockimpl.h @@ -87,8 +87,8 @@ RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free ( } POSIX_RWLock_Control *_POSIX_RWLock_Get( - pthread_rwlock_t *rwlock, - ISR_lock_Context *lock_context + pthread_rwlock_t *rwlock, + Thread_queue_Context *queue_context ); #ifdef __cplusplus diff --git a/cpukit/posix/include/rtems/posix/semaphoreimpl.h b/cpukit/posix/include/rtems/posix/semaphoreimpl.h index 402329a882..10d7cee28b 100644 --- a/cpukit/posix/include/rtems/posix/semaphoreimpl.h +++ b/cpukit/posix/include/rtems/posix/semaphoreimpl.h @@ -61,13 +61,14 @@ RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free ( } RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get( - const sem_t *id, - ISR_lock_Context *lock_context + const sem_t *id, + Thread_queue_Context *queue_context ) { + _Thread_queue_Context_initialize( queue_context, NULL ); return (POSIX_Semaphore_Control *) _Objects_Get( (Objects_Id) *id, - lock_context, + &queue_context->Lock_context, &_POSIX_Semaphore_Information ); } @@ -93,7 +94,7 @@ int _POSIX_Semaphore_Create_support( */ void _POSIX_Semaphore_Delete( POSIX_Semaphore_Control *the_semaphore, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ); /** diff --git a/cpukit/posix/src/conddestroy.c b/cpukit/posix/src/conddestroy.c index d47c6b2bed..a2c8dc188f 100644 --- a/cpukit/posix/src/conddestroy.c +++ b/cpukit/posix/src/conddestroy.c @@ -29,20 +29,20 @@ int pthread_cond_destroy( ) { POSIX_Condition_variables_Control *the_cond; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; _Objects_Allocator_lock(); - the_cond = _POSIX_Condition_variables_Get( cond, &lock_context ); + the_cond = _POSIX_Condition_variables_Get( cond, &queue_context ); if ( the_cond == NULL ) { _Objects_Allocator_unlock(); return EINVAL; } - _POSIX_Condition_variables_Acquire_critical( the_cond, &lock_context ); + _POSIX_Condition_variables_Acquire_critical( the_cond, &queue_context ); if ( !_Thread_queue_Is_empty( &the_cond->Wait_queue.Queue ) ) { - _POSIX_Condition_variables_Release( the_cond, &lock_context ); + _POSIX_Condition_variables_Release( the_cond, &queue_context ); _Objects_Allocator_unlock(); return EBUSY; } @@ -51,7 +51,7 @@ int pthread_cond_destroy( &_POSIX_Condition_variables_Information, &the_cond->Object ); - _POSIX_Condition_variables_Release( the_cond, &lock_context ); + _POSIX_Condition_variables_Release( the_cond, &queue_context ); _POSIX_Condition_variables_Destroy( the_cond ); _POSIX_Condition_variables_Free( the_cond ); _Objects_Allocator_unlock(); diff --git a/cpukit/posix/src/condget.c b/cpukit/posix/src/condget.c index 5676de861a..5b086ef7c9 100644 --- a/cpukit/posix/src/condget.c +++ b/cpukit/posix/src/condget.c @@ -15,14 +15,14 @@ #include <rtems/posix/posixapi.h> POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get( - pthread_cond_t *cond, - ISR_lock_Context *lock_context + pthread_cond_t *cond, + Thread_queue_Context *queue_context ) { _POSIX_Get_object_body( POSIX_Condition_variables_Control, cond, - lock_context, + queue_context, &_POSIX_Condition_variables_Information, PTHREAD_COND_INITIALIZER, pthread_cond_init diff --git a/cpukit/posix/src/condsignalsupp.c b/cpukit/posix/src/condsignalsupp.c index 38aa053f9f..e42476e1c4 100644 --- a/cpukit/posix/src/condsignalsupp.c +++ b/cpukit/posix/src/condsignalsupp.c @@ -36,15 +36,15 @@ int _POSIX_Condition_variables_Signal_support( do { POSIX_Condition_variables_Control *the_cond; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; - the_cond = _POSIX_Condition_variables_Get( cond, &lock_context ); + the_cond = _POSIX_Condition_variables_Get( cond, &queue_context ); if ( the_cond == NULL ) { return EINVAL; } - _POSIX_Condition_variables_Acquire_critical( the_cond, &lock_context ); + _POSIX_Condition_variables_Acquire_critical( the_cond, &queue_context ); the_thread = _Thread_queue_First_locked( &the_cond->Wait_queue, @@ -56,12 +56,11 @@ int _POSIX_Condition_variables_Signal_support( &the_cond->Wait_queue.Queue, POSIX_CONDITION_VARIABLES_TQ_OPERATIONS, the_thread, - NULL, - &lock_context + &queue_context ); } else { the_cond->mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; - _POSIX_Condition_variables_Release( the_cond, &lock_context ); + _POSIX_Condition_variables_Release( the_cond, &queue_context ); } } while ( is_broadcast && the_thread != NULL ); diff --git a/cpukit/posix/src/condwaitsupp.c b/cpukit/posix/src/condwaitsupp.c index 11b05872f3..4e89ef0b50 100644 --- a/cpukit/posix/src/condwaitsupp.c +++ b/cpukit/posix/src/condwaitsupp.c @@ -35,7 +35,7 @@ int _POSIX_Condition_variables_Wait_support( { POSIX_Condition_variables_Control *the_cond; POSIX_Mutex_Control *the_mutex; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; int status; int mutex_status; CORE_mutex_Status core_mutex_status; @@ -46,25 +46,25 @@ int _POSIX_Condition_variables_Wait_support( return EINVAL; } - the_cond = _POSIX_Condition_variables_Get( cond, &lock_context ); + the_cond = _POSIX_Condition_variables_Get( cond, &queue_context ); if ( the_cond == NULL ) { return EINVAL; } - _POSIX_Condition_variables_Acquire_critical( the_cond, &lock_context ); + _POSIX_Condition_variables_Acquire_critical( the_cond, &queue_context ); if ( the_cond->mutex != POSIX_CONDITION_VARIABLES_NO_MUTEX && the_cond->mutex != *mutex ) { - _POSIX_Condition_variables_Release( the_cond, &lock_context ); + _POSIX_Condition_variables_Release( the_cond, &queue_context ); return EINVAL; } the_cond->mutex = *mutex; - cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); + cpu_self = _Thread_Dispatch_disable_critical( &queue_context.Lock_context ); executing = _Per_CPU_Get_executing( cpu_self ); /* @@ -78,7 +78,7 @@ int _POSIX_Condition_variables_Wait_support( the_mutex == NULL || !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing ) ) { - _POSIX_Condition_variables_Release( the_cond, &lock_context ); + _POSIX_Condition_variables_Release( the_cond, &queue_context ); _Thread_Dispatch_enable( cpu_self ); return EPERM; } @@ -92,18 +92,17 @@ int _POSIX_Condition_variables_Wait_support( STATES_WAITING_FOR_CONDITION_VARIABLE, timeout, ETIMEDOUT, - &lock_context + &queue_context.Lock_context ); } else { - _POSIX_Condition_variables_Release( the_cond, &lock_context ); + _POSIX_Condition_variables_Release( the_cond, &queue_context ); executing->Wait.return_code = ETIMEDOUT; } - _ISR_lock_ISR_disable( &lock_context ); + _ISR_lock_ISR_disable( &queue_context.Lock_context ); core_mutex_status = _CORE_mutex_Surrender( &the_mutex->Mutex, - NULL, - &lock_context + &queue_context ); _Assert( core_mutex_status == CORE_MUTEX_STATUS_SUCCESSFUL ); (void) core_mutex_status; diff --git a/cpukit/posix/src/mqueueclose.c b/cpukit/posix/src/mqueueclose.c index 28a7d164d9..60d3ce3ea9 100644 --- a/cpukit/posix/src/mqueueclose.c +++ b/cpukit/posix/src/mqueueclose.c @@ -42,10 +42,10 @@ int mq_close( ) { POSIX_Message_queue_Control *the_mq; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; _Objects_Allocator_lock(); - the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context ); + the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { _Objects_Allocator_unlock(); @@ -54,17 +54,17 @@ int mq_close( _CORE_message_queue_Acquire_critical( &the_mq->Message_queue, - &lock_context + &queue_context ); if ( the_mq->open_count == 0 ) { - _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); _Objects_Allocator_unlock(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq->open_count -= 1; - _POSIX_Message_queue_Delete( the_mq, &lock_context ); + _POSIX_Message_queue_Delete( the_mq, &queue_context ); _Objects_Allocator_unlock(); return 0; diff --git a/cpukit/posix/src/mqueuedeletesupp.c b/cpukit/posix/src/mqueuedeletesupp.c index 485136c864..850707a0d9 100644 --- a/cpukit/posix/src/mqueuedeletesupp.c +++ b/cpukit/posix/src/mqueuedeletesupp.c @@ -22,17 +22,13 @@ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { if ( !the_mq->linked && the_mq->open_count == 0 ) { - _CORE_message_queue_Close( - &the_mq->Message_queue, - NULL, /* no MP support */ - lock_context - ); + _CORE_message_queue_Close( &the_mq->Message_queue, queue_context ); _POSIX_Message_queue_Free( the_mq ); } else { - _CORE_message_queue_Release( &the_mq->Message_queue, lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, queue_context ); } } diff --git a/cpukit/posix/src/mqueuegetattr.c b/cpukit/posix/src/mqueuegetattr.c index dae14e3f2e..5efcc0b154 100644 --- a/cpukit/posix/src/mqueuegetattr.c +++ b/cpukit/posix/src/mqueuegetattr.c @@ -42,13 +42,13 @@ int mq_getattr( ) { POSIX_Message_queue_Control *the_mq; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; if ( mqstat == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); } - the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context ); + the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { rtems_set_errno_and_return_minus_one( EBADF ); @@ -56,11 +56,11 @@ int mq_getattr( _CORE_message_queue_Acquire_critical( &the_mq->Message_queue, - &lock_context + &queue_context ); if ( the_mq->open_count == 0 ) { - _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); rtems_set_errno_and_return_minus_one( EBADF ); } @@ -72,6 +72,6 @@ int mq_getattr( mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; - _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); return 0; } diff --git a/cpukit/posix/src/mqueuenotify.c b/cpukit/posix/src/mqueuenotify.c index adcfdcb8f2..a1f9a089f8 100644 --- a/cpukit/posix/src/mqueuenotify.c +++ b/cpukit/posix/src/mqueuenotify.c @@ -24,7 +24,7 @@ static void _POSIX_Message_queue_Notify_handler( CORE_message_queue_Control *the_message_queue, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { POSIX_Message_queue_Control *the_mq; @@ -38,7 +38,7 @@ static void _POSIX_Message_queue_Notify_handler( signo = the_mq->notification.sigev_signo; _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL ); - _CORE_message_queue_Release( &the_mq->Message_queue, lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, queue_context ); kill( getpid(), signo ); } @@ -49,9 +49,9 @@ int mq_notify( ) { POSIX_Message_queue_Control *the_mq; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; - the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context ); + the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { rtems_set_errno_and_return_minus_one( EBADF ); @@ -59,17 +59,17 @@ int mq_notify( _CORE_message_queue_Acquire_critical( &the_mq->Message_queue, - &lock_context + &queue_context ); if ( the_mq->open_count == 0 ) { - _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); rtems_set_errno_and_return_minus_one( EBADF ); } if ( notification != NULL ) { if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { - _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); rtems_set_errno_and_return_minus_one( EBUSY ); } @@ -83,6 +83,6 @@ int mq_notify( _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL ); } - _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); return 0; } diff --git a/cpukit/posix/src/mqueuerecvsupp.c b/cpukit/posix/src/mqueuerecvsupp.c index b5a790a2bd..541786a850 100644 --- a/cpukit/posix/src/mqueuerecvsupp.c +++ b/cpukit/posix/src/mqueuerecvsupp.c @@ -44,24 +44,24 @@ ssize_t _POSIX_Message_queue_Receive_support( ) { POSIX_Message_queue_Control *the_mq; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; size_t length_out; bool do_wait; Thread_Control *executing; - the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context ); + the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { rtems_set_errno_and_return_minus_one( EBADF ); } if ( ( the_mq->oflag & O_ACCMODE ) == O_WRONLY ) { - _ISR_lock_ISR_enable( &lock_context ); + _ISR_lock_ISR_enable( &queue_context.Lock_context ); rtems_set_errno_and_return_minus_one( EBADF ); } if ( msg_len < the_mq->Message_queue.maximum_message_size ) { - _ISR_lock_ISR_enable( &lock_context ); + _ISR_lock_ISR_enable( &queue_context.Lock_context ); rtems_set_errno_and_return_minus_one( EMSGSIZE ); } @@ -83,11 +83,11 @@ ssize_t _POSIX_Message_queue_Receive_support( _CORE_message_queue_Acquire_critical( &the_mq->Message_queue, - &lock_context + &queue_context ); if ( the_mq->open_count == 0 ) { - _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); rtems_set_errno_and_return_minus_one( EBADF ); } @@ -102,7 +102,7 @@ ssize_t _POSIX_Message_queue_Receive_support( &length_out, do_wait, timeout, - &lock_context + &queue_context ); if ( msg_prio != NULL ) { diff --git a/cpukit/posix/src/mqueuesendsupp.c b/cpukit/posix/src/mqueuesendsupp.c index 8933fc691e..2d88eec7a8 100644 --- a/cpukit/posix/src/mqueuesendsupp.c +++ b/cpukit/posix/src/mqueuesendsupp.c @@ -44,7 +44,7 @@ int _POSIX_Message_queue_Send_support( ) { POSIX_Message_queue_Control *the_mq; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; CORE_message_queue_Status msg_status; bool do_wait; Thread_Control *executing; @@ -58,14 +58,14 @@ int _POSIX_Message_queue_Send_support( rtems_set_errno_and_return_minus_one( EINVAL ); } - the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context ); + the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { rtems_set_errno_and_return_minus_one( EBADF ); } if ( ( the_mq->oflag & O_ACCMODE ) == O_RDONLY ) { - _ISR_lock_ISR_enable( &lock_context ); + _ISR_lock_ISR_enable( &queue_context.Lock_context ); rtems_set_errno_and_return_minus_one( EBADF ); } @@ -80,11 +80,11 @@ int _POSIX_Message_queue_Send_support( _CORE_message_queue_Acquire_critical( &the_mq->Message_queue, - &lock_context + &queue_context ); if ( the_mq->open_count == 0 ) { - _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); rtems_set_errno_and_return_minus_one( EBADF ); } @@ -97,11 +97,10 @@ int _POSIX_Message_queue_Send_support( executing, msg_ptr, msg_len, - NULL, _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout, - &lock_context + &queue_context ); if ( msg_status != CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL ) { diff --git a/cpukit/posix/src/mqueuesetattr.c b/cpukit/posix/src/mqueuesetattr.c index dfd9bab216..fc9fc75ecf 100644 --- a/cpukit/posix/src/mqueuesetattr.c +++ b/cpukit/posix/src/mqueuesetattr.c @@ -27,13 +27,13 @@ int mq_setattr( ) { POSIX_Message_queue_Control *the_mq; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; if ( mqstat == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); } - the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context ); + the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { rtems_set_errno_and_return_minus_one( EBADF ); @@ -41,11 +41,11 @@ int mq_setattr( _CORE_message_queue_Acquire_critical( &the_mq->Message_queue, - &lock_context + &queue_context ); if ( the_mq->open_count == 0 ) { - _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); rtems_set_errno_and_return_minus_one( EBADF ); } @@ -62,6 +62,6 @@ int mq_setattr( the_mq->oflag = mqstat->mq_flags; - _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context ); + _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); return 0; } diff --git a/cpukit/posix/src/mqueueunlink.c b/cpukit/posix/src/mqueueunlink.c index dc485ba657..812f249df5 100644 --- a/cpukit/posix/src/mqueueunlink.c +++ b/cpukit/posix/src/mqueueunlink.c @@ -30,7 +30,7 @@ int mq_unlink( { POSIX_Message_queue_Control *the_mq; Objects_Get_by_name_error error; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; _Objects_Allocator_lock(); @@ -42,10 +42,10 @@ int mq_unlink( _POSIX_Message_queue_Namespace_remove( the_mq ); - _CORE_message_queue_Acquire( &the_mq->Message_queue, &lock_context ); + _CORE_message_queue_Acquire( &the_mq->Message_queue, &queue_context ); the_mq->linked = false; - _POSIX_Message_queue_Delete( the_mq, &lock_context ); + _POSIX_Message_queue_Delete( the_mq, &queue_context ); _Objects_Allocator_unlock(); return 0; diff --git a/cpukit/posix/src/mutexdestroy.c b/cpukit/posix/src/mutexdestroy.c index 640acc0e5a..7fda7d3ac9 100644 --- a/cpukit/posix/src/mutexdestroy.c +++ b/cpukit/posix/src/mutexdestroy.c @@ -28,16 +28,16 @@ int pthread_mutex_destroy( pthread_mutex_t *mutex ) { - POSIX_Mutex_Control *the_mutex; - ISR_lock_Context lock_context; - int eno; + POSIX_Mutex_Control *the_mutex; + Thread_queue_Context queue_context; + int eno; _Objects_Allocator_lock(); - the_mutex = _POSIX_Mutex_Get( mutex, &lock_context ); + the_mutex = _POSIX_Mutex_Get( mutex, &queue_context ); if ( the_mutex != NULL ) { - _CORE_mutex_Acquire_critical( &the_mutex->Mutex, &lock_context ); + _CORE_mutex_Acquire_critical( &the_mutex->Mutex, &queue_context ); /* * XXX: There is an error for the mutex being locked @@ -46,12 +46,12 @@ int pthread_mutex_destroy( if ( !_CORE_mutex_Is_locked( &the_mutex->Mutex ) ) { _Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object ); - _CORE_mutex_Release( &the_mutex->Mutex, &lock_context ); + _CORE_mutex_Release( &the_mutex->Mutex, &queue_context ); _CORE_mutex_Destroy( &the_mutex->Mutex ); _POSIX_Mutex_Free( the_mutex ); eno = 0; } else { - _CORE_mutex_Release( &the_mutex->Mutex, &lock_context ); + _CORE_mutex_Release( &the_mutex->Mutex, &queue_context ); eno = EBUSY; } } else { diff --git a/cpukit/posix/src/mutexget.c b/cpukit/posix/src/mutexget.c index f8f003353a..e90c41c3a2 100644 --- a/cpukit/posix/src/mutexget.c +++ b/cpukit/posix/src/mutexget.c @@ -22,14 +22,14 @@ #include <rtems/posix/posixapi.h> POSIX_Mutex_Control *_POSIX_Mutex_Get( - pthread_mutex_t *mutex, - ISR_lock_Context *lock_context + pthread_mutex_t *mutex, + Thread_queue_Context *queue_context ) { _POSIX_Get_object_body( POSIX_Mutex_Control, mutex, - lock_context, + queue_context, &_POSIX_Mutex_Information, PTHREAD_MUTEX_INITIALIZER, pthread_mutex_init diff --git a/cpukit/posix/src/mutexgetprioceiling.c b/cpukit/posix/src/mutexgetprioceiling.c index 232b2e2a80..268457a73e 100644 --- a/cpukit/posix/src/mutexgetprioceiling.c +++ b/cpukit/posix/src/mutexgetprioceiling.c @@ -30,26 +30,26 @@ int pthread_mutex_getprioceiling( int *prioceiling ) { - POSIX_Mutex_Control *the_mutex; - ISR_lock_Context lock_context; + POSIX_Mutex_Control *the_mutex; + Thread_queue_Context queue_context; if ( prioceiling == NULL ) { return EINVAL; } - the_mutex = _POSIX_Mutex_Get( mutex, &lock_context ); + the_mutex = _POSIX_Mutex_Get( mutex, &queue_context ); if ( the_mutex == NULL ) { return EINVAL; } - _CORE_mutex_Acquire_critical( &the_mutex->Mutex, &lock_context ); + _CORE_mutex_Acquire_critical( &the_mutex->Mutex, &queue_context ); *prioceiling = _POSIX_Priority_From_core( the_mutex->Mutex.Attributes.priority_ceiling ); - _CORE_mutex_Release( &the_mutex->Mutex, &lock_context ); + _CORE_mutex_Release( &the_mutex->Mutex, &queue_context ); return 0; } diff --git a/cpukit/posix/src/mutexlocksupp.c b/cpukit/posix/src/mutexlocksupp.c index 0c70cf06e2..f17269bf21 100644 --- a/cpukit/posix/src/mutexlocksupp.c +++ b/cpukit/posix/src/mutexlocksupp.c @@ -28,11 +28,11 @@ int _POSIX_Mutex_Lock_support( Watchdog_Interval timeout ) { - POSIX_Mutex_Control *the_mutex; - ISR_lock_Context lock_context; - Thread_Control *executing; + POSIX_Mutex_Control *the_mutex; + Thread_queue_Context queue_context; + Thread_Control *executing; - the_mutex = _POSIX_Mutex_Get( mutex, &lock_context ); + the_mutex = _POSIX_Mutex_Get( mutex, &queue_context ); if ( the_mutex == NULL ) { return EINVAL; @@ -44,7 +44,7 @@ int _POSIX_Mutex_Lock_support( executing, blocking, timeout, - &lock_context + &queue_context ); return _POSIX_Mutex_Translate_core_mutex_return_code( (CORE_mutex_Status) executing->Wait.return_code diff --git a/cpukit/posix/src/mutexsetprioceiling.c b/cpukit/posix/src/mutexsetprioceiling.c index f29c0ad116..09554f84c4 100644 --- a/cpukit/posix/src/mutexsetprioceiling.c +++ b/cpukit/posix/src/mutexsetprioceiling.c @@ -33,7 +33,7 @@ int pthread_mutex_setprioceiling( { register POSIX_Mutex_Control *the_mutex; Priority_Control the_priority; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; if ( !old_ceiling ) return EINVAL; @@ -57,7 +57,7 @@ int pthread_mutex_setprioceiling( * NOTE: This makes it easier to get 100% binary coverage since the * bad Id case is handled by the switch. */ - the_mutex = _POSIX_Mutex_Get( mutex, &lock_context ); + the_mutex = _POSIX_Mutex_Get( mutex, &queue_context ); if ( the_mutex == NULL ) { return EINVAL; @@ -73,8 +73,7 @@ int pthread_mutex_setprioceiling( */ _CORE_mutex_Surrender( &the_mutex->Mutex, - NULL, - &lock_context + &queue_context ); return 0; } diff --git a/cpukit/posix/src/mutexunlock.c b/cpukit/posix/src/mutexunlock.c index 94fcc63364..ff7fc1c789 100644 --- a/cpukit/posix/src/mutexunlock.c +++ b/cpukit/posix/src/mutexunlock.c @@ -30,20 +30,16 @@ int pthread_mutex_unlock( pthread_mutex_t *mutex ) { - POSIX_Mutex_Control *the_mutex; - CORE_mutex_Status status; - ISR_lock_Context lock_context; + POSIX_Mutex_Control *the_mutex; + CORE_mutex_Status status; + Thread_queue_Context queue_context; - the_mutex = _POSIX_Mutex_Get( mutex, &lock_context ); + the_mutex = _POSIX_Mutex_Get( mutex, &queue_context ); if ( the_mutex == NULL ) { return EINVAL; } - status = _CORE_mutex_Surrender( - &the_mutex->Mutex, - NULL, - &lock_context - ); + status = _CORE_mutex_Surrender( &the_mutex->Mutex, &queue_context ); return _POSIX_Mutex_Translate_core_mutex_return_code( status ); } diff --git a/cpukit/posix/src/pbarrierdestroy.c b/cpukit/posix/src/pbarrierdestroy.c index 709644bf4e..8f85762211 100644 --- a/cpukit/posix/src/pbarrierdestroy.c +++ b/cpukit/posix/src/pbarrierdestroy.c @@ -36,30 +36,30 @@ int pthread_barrier_destroy( ) { POSIX_Barrier_Control *the_barrier; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; if ( barrier == NULL ) { return EINVAL; } _Objects_Allocator_lock(); - the_barrier = _POSIX_Barrier_Get( barrier, &lock_context ); + the_barrier = _POSIX_Barrier_Get( barrier, &queue_context ); if ( the_barrier == NULL ) { _Objects_Allocator_unlock(); return EINVAL; } - _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &lock_context ); + _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &queue_context ); if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) { - _CORE_barrier_Release( &the_barrier->Barrier, &lock_context ); + _CORE_barrier_Release( &the_barrier->Barrier, &queue_context ); _Objects_Allocator_unlock(); return EBUSY; } _Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object ); - _CORE_barrier_Release( &the_barrier->Barrier, &lock_context ); + _CORE_barrier_Release( &the_barrier->Barrier, &queue_context ); _POSIX_Barrier_Free( the_barrier ); _Objects_Allocator_unlock(); return 0; diff --git a/cpukit/posix/src/pbarrierwait.c b/cpukit/posix/src/pbarrierwait.c index adfd40df1b..522c18ec84 100644 --- a/cpukit/posix/src/pbarrierwait.c +++ b/cpukit/posix/src/pbarrierwait.c @@ -37,14 +37,14 @@ int pthread_barrier_wait( ) { POSIX_Barrier_Control *the_barrier; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; Thread_Control *executing; if ( barrier == NULL ) { return EINVAL; } - the_barrier = _POSIX_Barrier_Get( barrier, &lock_context ); + the_barrier = _POSIX_Barrier_Get( barrier, &queue_context ); if ( the_barrier == NULL ) { return EINVAL; @@ -56,8 +56,7 @@ int pthread_barrier_wait( executing, true, 0, - NULL, - &lock_context + &queue_context ); return _POSIX_Barrier_Translate_core_barrier_return_code( executing->Wait.return_code diff --git a/cpukit/posix/src/prwlockdestroy.c b/cpukit/posix/src/prwlockdestroy.c index 6f9eec8a1d..0ced556146 100644 --- a/cpukit/posix/src/prwlockdestroy.c +++ b/cpukit/posix/src/prwlockdestroy.c @@ -24,24 +24,24 @@ int pthread_rwlock_destroy( ) { POSIX_RWLock_Control *the_rwlock; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; _Objects_Allocator_lock(); - the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context ); + the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context ); if ( the_rwlock == NULL ) { _Objects_Allocator_unlock(); return EINVAL; } - _CORE_RWLock_Acquire_critical( &the_rwlock->RWLock, &lock_context ); + _CORE_RWLock_Acquire_critical( &the_rwlock->RWLock, &queue_context ); /* * If there is at least one thread waiting, then do not delete it. */ if ( !_Thread_queue_Is_empty( &the_rwlock->RWLock.Wait_queue.Queue ) ) { - _CORE_RWLock_Release( &the_rwlock->RWLock, &lock_context ); + _CORE_RWLock_Release( &the_rwlock->RWLock, &queue_context ); _Objects_Allocator_unlock(); return EBUSY; } @@ -51,7 +51,7 @@ int pthread_rwlock_destroy( */ _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object ); - _CORE_RWLock_Release( &the_rwlock->RWLock, &lock_context ); + _CORE_RWLock_Release( &the_rwlock->RWLock, &queue_context ); _POSIX_RWLock_Free( the_rwlock ); _Objects_Allocator_unlock(); return 0; diff --git a/cpukit/posix/src/prwlockinit.c b/cpukit/posix/src/prwlockinit.c index fcf4e29a34..34ab1aeff1 100644 --- a/cpukit/posix/src/prwlockinit.c +++ b/cpukit/posix/src/prwlockinit.c @@ -24,14 +24,14 @@ #include <rtems/posix/posixapi.h> POSIX_RWLock_Control *_POSIX_RWLock_Get( - pthread_rwlock_t *rwlock, - ISR_lock_Context *lock_context + pthread_rwlock_t *rwlock, + Thread_queue_Context *queue_context ) { _POSIX_Get_object_body( POSIX_RWLock_Control, rwlock, - lock_context, + queue_context, &_POSIX_RWLock_Information, PTHREAD_RWLOCK_INITIALIZER, pthread_rwlock_init diff --git a/cpukit/posix/src/prwlockrdlock.c b/cpukit/posix/src/prwlockrdlock.c index 3459399c6b..e59aaf9adb 100644 --- a/cpukit/posix/src/prwlockrdlock.c +++ b/cpukit/posix/src/prwlockrdlock.c @@ -25,10 +25,10 @@ int pthread_rwlock_rdlock( ) { POSIX_RWLock_Control *the_rwlock; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; Thread_Control *executing; - the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context ); + the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context ); if ( the_rwlock == NULL ) { return EINVAL; @@ -40,7 +40,7 @@ int pthread_rwlock_rdlock( executing, true, /* we are willing to wait forever */ 0, - &lock_context + &queue_context ); return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) executing->Wait.return_code diff --git a/cpukit/posix/src/prwlocktimedrdlock.c b/cpukit/posix/src/prwlocktimedrdlock.c index 829e1696a3..9e849438dd 100644 --- a/cpukit/posix/src/prwlocktimedrdlock.c +++ b/cpukit/posix/src/prwlocktimedrdlock.c @@ -27,7 +27,7 @@ int pthread_rwlock_timedrdlock( ) { POSIX_RWLock_Control *the_rwlock; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; Watchdog_Interval ticks; bool do_wait; TOD_Absolute_timeout_conversion_results status; @@ -49,7 +49,7 @@ int pthread_rwlock_timedrdlock( status = _TOD_Absolute_timeout_to_ticks( abstime, &ticks ); do_wait = ( status == TOD_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ); - the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context ); + the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context ); if ( the_rwlock == NULL ) { return EINVAL; @@ -61,7 +61,7 @@ int pthread_rwlock_timedrdlock( executing, do_wait, ticks, - &lock_context + &queue_context ); if ( diff --git a/cpukit/posix/src/prwlocktimedwrlock.c b/cpukit/posix/src/prwlocktimedwrlock.c index 1258c2bebb..6be8397ef7 100644 --- a/cpukit/posix/src/prwlocktimedwrlock.c +++ b/cpukit/posix/src/prwlocktimedwrlock.c @@ -29,7 +29,7 @@ int pthread_rwlock_timedwrlock( ) { POSIX_RWLock_Control *the_rwlock; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; Watchdog_Interval ticks; bool do_wait; TOD_Absolute_timeout_conversion_results status; @@ -51,7 +51,7 @@ int pthread_rwlock_timedwrlock( status = _TOD_Absolute_timeout_to_ticks( abstime, &ticks ); do_wait = ( status == TOD_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ); - the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context ); + the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context ); if ( the_rwlock == NULL ) { return EINVAL; @@ -63,7 +63,7 @@ int pthread_rwlock_timedwrlock( executing, do_wait, ticks, - &lock_context + &queue_context ); if ( diff --git a/cpukit/posix/src/prwlocktryrdlock.c b/cpukit/posix/src/prwlocktryrdlock.c index a73d122ed6..1a7cf9efe1 100644 --- a/cpukit/posix/src/prwlocktryrdlock.c +++ b/cpukit/posix/src/prwlocktryrdlock.c @@ -25,10 +25,10 @@ int pthread_rwlock_tryrdlock( ) { POSIX_RWLock_Control *the_rwlock; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; Thread_Control *executing; - the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context ); + the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context ); if ( the_rwlock == NULL ) { return EINVAL; @@ -40,7 +40,7 @@ int pthread_rwlock_tryrdlock( executing, false, /* do not wait for the rwlock */ 0, - &lock_context + &queue_context ); return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) executing->Wait.return_code diff --git a/cpukit/posix/src/prwlocktrywrlock.c b/cpukit/posix/src/prwlocktrywrlock.c index a44a54ffb5..b6031f9b42 100644 --- a/cpukit/posix/src/prwlocktrywrlock.c +++ b/cpukit/posix/src/prwlocktrywrlock.c @@ -25,10 +25,10 @@ int pthread_rwlock_trywrlock( ) { POSIX_RWLock_Control *the_rwlock; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; Thread_Control *executing; - the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context ); + the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context ); if ( the_rwlock == NULL ) { return EINVAL; @@ -40,7 +40,7 @@ int pthread_rwlock_trywrlock( executing, false, /* we are not willing to wait */ 0, - &lock_context + &queue_context ); return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) executing->Wait.return_code diff --git a/cpukit/posix/src/prwlockunlock.c b/cpukit/posix/src/prwlockunlock.c index bf6b4deaf0..dd4337d7d0 100644 --- a/cpukit/posix/src/prwlockunlock.c +++ b/cpukit/posix/src/prwlockunlock.c @@ -27,15 +27,15 @@ int pthread_rwlock_unlock( ) { POSIX_RWLock_Control *the_rwlock; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; CORE_RWLock_Status status; - the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context ); + the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context ); if ( the_rwlock == NULL ) { return EINVAL; } - status = _CORE_RWLock_Surrender( &the_rwlock->RWLock, &lock_context ); + status = _CORE_RWLock_Surrender( &the_rwlock->RWLock, &queue_context ); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); } diff --git a/cpukit/posix/src/prwlockwrlock.c b/cpukit/posix/src/prwlockwrlock.c index 568316363a..84a4e0f04b 100644 --- a/cpukit/posix/src/prwlockwrlock.c +++ b/cpukit/posix/src/prwlockwrlock.c @@ -32,10 +32,10 @@ int pthread_rwlock_wrlock( ) { POSIX_RWLock_Control *the_rwlock; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; Thread_Control *executing; - the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context ); + the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context ); if ( the_rwlock == NULL ) { return EINVAL; @@ -47,7 +47,7 @@ int pthread_rwlock_wrlock( executing, true, /* do not timeout -- wait forever */ 0, - &lock_context + &queue_context ); return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) executing->Wait.return_code diff --git a/cpukit/posix/src/semaphoredeletesupp.c b/cpukit/posix/src/semaphoredeletesupp.c index c205b1223f..2d39b2aad5 100644 --- a/cpukit/posix/src/semaphoredeletesupp.c +++ b/cpukit/posix/src/semaphoredeletesupp.c @@ -22,18 +22,14 @@ void _POSIX_Semaphore_Delete( POSIX_Semaphore_Control *the_semaphore, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { if ( !the_semaphore->linked && !the_semaphore->open_count ) { _Objects_Close( &_POSIX_Semaphore_Information, &the_semaphore->Object ); - _CORE_semaphore_Destroy( - &the_semaphore->Semaphore, - NULL, - lock_context - ); + _CORE_semaphore_Destroy( &the_semaphore->Semaphore, queue_context ); _POSIX_Semaphore_Free( the_semaphore ); } else { - _CORE_semaphore_Release( &the_semaphore->Semaphore, lock_context ); + _CORE_semaphore_Release( &the_semaphore->Semaphore, queue_context ); } } diff --git a/cpukit/posix/src/semaphorewaitsupp.c b/cpukit/posix/src/semaphorewaitsupp.c index f08efa8e22..9382107d90 100644 --- a/cpukit/posix/src/semaphorewaitsupp.c +++ b/cpukit/posix/src/semaphorewaitsupp.c @@ -32,9 +32,9 @@ int _POSIX_Semaphore_Wait_support( { POSIX_Semaphore_Control *the_semaphore; Thread_Control *executing; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; - the_semaphore = _POSIX_Semaphore_Get( sem, &lock_context ); + the_semaphore = _POSIX_Semaphore_Get( sem, &queue_context ); if ( the_semaphore == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); @@ -47,7 +47,7 @@ int _POSIX_Semaphore_Wait_support( executing, blocking, timeout, - &lock_context + &queue_context ); if ( executing->Wait.return_code == CORE_SEMAPHORE_STATUS_SUCCESSFUL ) { diff --git a/cpukit/posix/src/semclose.c b/cpukit/posix/src/semclose.c index 3f18ff1efe..ebcf7a26b3 100644 --- a/cpukit/posix/src/semclose.c +++ b/cpukit/posix/src/semclose.c @@ -27,10 +27,10 @@ int sem_close( ) { POSIX_Semaphore_Control *the_semaphore; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; _Objects_Allocator_lock(); - the_semaphore = _POSIX_Semaphore_Get( sem, &lock_context ); + the_semaphore = _POSIX_Semaphore_Get( sem, &queue_context ); if ( the_semaphore == NULL ) { _Objects_Allocator_unlock(); @@ -39,10 +39,10 @@ int sem_close( _CORE_semaphore_Acquire_critical( &the_semaphore->Semaphore, - &lock_context + &queue_context ); the_semaphore->open_count -= 1; - _POSIX_Semaphore_Delete( the_semaphore, &lock_context ); + _POSIX_Semaphore_Delete( the_semaphore, &queue_context ); _Objects_Allocator_unlock(); return 0; diff --git a/cpukit/posix/src/semdestroy.c b/cpukit/posix/src/semdestroy.c index 5264472156..8b81470bbf 100644 --- a/cpukit/posix/src/semdestroy.c +++ b/cpukit/posix/src/semdestroy.c @@ -27,10 +27,10 @@ int sem_destroy( ) { POSIX_Semaphore_Control *the_semaphore; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; _Objects_Allocator_lock(); - the_semaphore = _POSIX_Semaphore_Get( sem, &lock_context ); + the_semaphore = _POSIX_Semaphore_Get( sem, &queue_context ); if ( the_semaphore == NULL ) { _Objects_Allocator_unlock(); @@ -39,17 +39,17 @@ int sem_destroy( _CORE_semaphore_Acquire_critical( &the_semaphore->Semaphore, - &lock_context + &queue_context ); if ( the_semaphore->named ) { /* Undefined operation on a named semaphore */ - _CORE_semaphore_Release( &the_semaphore->Semaphore, &lock_context ); + _CORE_semaphore_Release( &the_semaphore->Semaphore, &queue_context ); _Objects_Allocator_unlock(); rtems_set_errno_and_return_minus_one( EINVAL ); } - _POSIX_Semaphore_Delete( the_semaphore, &lock_context ); + _POSIX_Semaphore_Delete( the_semaphore, &queue_context ); _Objects_Allocator_unlock(); return 0; diff --git a/cpukit/posix/src/semgetvalue.c b/cpukit/posix/src/semgetvalue.c index 63e3823dff..1b752944fa 100644 --- a/cpukit/posix/src/semgetvalue.c +++ b/cpukit/posix/src/semgetvalue.c @@ -28,20 +28,21 @@ int sem_getvalue( ) { POSIX_Semaphore_Control *the_semaphore; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; - the_semaphore = _POSIX_Semaphore_Get( sem, &lock_context ); + the_semaphore = _POSIX_Semaphore_Get( sem, &queue_context ); if ( the_semaphore == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); } - /* - * Assume a relaxed atomic load of the value on SMP configurations. - * Thus, there is no need to acquire a lock. - */ + _CORE_semaphore_Acquire_critical( + &the_semaphore->Semaphore, + &queue_context + ); + *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); - _ISR_lock_ISR_enable( &lock_context ); + _CORE_semaphore_Release( &the_semaphore->Semaphore, &queue_context ); return 0; } diff --git a/cpukit/posix/src/sempost.c b/cpukit/posix/src/sempost.c index 313ff3cdf3..86d2f5acf6 100644 --- a/cpukit/posix/src/sempost.c +++ b/cpukit/posix/src/sempost.c @@ -27,9 +27,9 @@ int sem_post( ) { POSIX_Semaphore_Control *the_semaphore; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; - the_semaphore = _POSIX_Semaphore_Get( sem, &lock_context ); + the_semaphore = _POSIX_Semaphore_Get( sem, &queue_context ); if ( the_semaphore == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); @@ -37,8 +37,7 @@ int sem_post( _CORE_semaphore_Surrender( &the_semaphore->Semaphore, - NULL, - &lock_context + &queue_context ); return 0; } diff --git a/cpukit/posix/src/semunlink.c b/cpukit/posix/src/semunlink.c index 665aa7337c..6ba1df17a4 100644 --- a/cpukit/posix/src/semunlink.c +++ b/cpukit/posix/src/semunlink.c @@ -28,7 +28,7 @@ int sem_unlink( { POSIX_Semaphore_Control *the_semaphore; Objects_Get_by_name_error error; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; _Objects_Allocator_lock(); @@ -40,10 +40,10 @@ int sem_unlink( _POSIX_Semaphore_Namespace_remove( the_semaphore ); - _ISR_lock_ISR_disable( &lock_context ); - _CORE_semaphore_Acquire_critical( &the_semaphore->Semaphore, &lock_context ); + _ISR_lock_ISR_disable( &queue_context.Lock_context ); + _CORE_semaphore_Acquire_critical( &the_semaphore->Semaphore, &queue_context ); the_semaphore->linked = false; - _POSIX_Semaphore_Delete( the_semaphore, &lock_context ); + _POSIX_Semaphore_Delete( the_semaphore, &queue_context ); _Objects_Allocator_unlock(); return 0; diff --git a/cpukit/rtems/include/rtems/rtems/barrierimpl.h b/cpukit/rtems/include/rtems/rtems/barrierimpl.h index 39632fcd00..0eaadfc046 100644 --- a/cpukit/rtems/include/rtems/rtems/barrierimpl.h +++ b/cpukit/rtems/include/rtems/rtems/barrierimpl.h @@ -70,12 +70,13 @@ RTEMS_INLINE_ROUTINE void _Barrier_Free ( } RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get( - Objects_Id id, - ISR_lock_Context *lock_context + Objects_Id id, + Thread_queue_Context *queue_context ) { + _Thread_queue_Context_initialize( queue_context, NULL ); return (Barrier_Control *) - _Objects_Get( id, lock_context, &_Barrier_Information ); + _Objects_Get( id, &queue_context->Lock_context, &_Barrier_Information ); } /** diff --git a/cpukit/rtems/include/rtems/rtems/messageimpl.h b/cpukit/rtems/include/rtems/rtems/messageimpl.h index 199af1cacb..d6217f171e 100644 --- a/cpukit/rtems/include/rtems/rtems/messageimpl.h +++ b/cpukit/rtems/include/rtems/rtems/messageimpl.h @@ -101,18 +101,31 @@ RTEMS_INLINE_ROUTINE void _Message_queue_Free ( _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); } -RTEMS_INLINE_ROUTINE Message_queue_Control * _Message_queue_Get( - Objects_Id id, - ISR_lock_Context *lock_context +RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Do_get( + Objects_Id id, + Thread_queue_Context *queue_context +#if defined(RTEMS_MULTIPROCESSING) + , + Thread_queue_MP_callout mp_callout +#endif ) { + _Thread_queue_Context_initialize( queue_context, mp_callout ); return (Message_queue_Control *) _Objects_Get( id, - lock_context, + &queue_context->Lock_context, &_Message_queue_Information ); } +#if defined(RTEMS_MULTIPROCESSING) + #define _Message_queue_Get( id, queue_context, mp_callout ) \ + _Message_queue_Do_get( id, queue_context, mp_callout ) +#else + #define _Message_queue_Get( id, queue_context, mp_callout ) \ + _Message_queue_Do_get( id, queue_context ) +#endif + RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Allocate( void ) { return (Message_queue_Control *) diff --git a/cpukit/rtems/include/rtems/rtems/semimpl.h b/cpukit/rtems/include/rtems/rtems/semimpl.h index ac55bc7354..c23bef905a 100644 --- a/cpukit/rtems/include/rtems/rtems/semimpl.h +++ b/cpukit/rtems/include/rtems/rtems/semimpl.h @@ -134,18 +134,31 @@ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); } -RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get( - Objects_Id id, - ISR_lock_Context *lock_context +RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Do_get( + Objects_Id id, + Thread_queue_Context *queue_context +#if defined(RTEMS_MULTIPROCESSING) + , + Thread_queue_MP_callout mp_callout +#endif ) { + _Thread_queue_Context_initialize( queue_context, mp_callout ); return (Semaphore_Control *) _Objects_Get( id, - lock_context, + &queue_context->Lock_context, &_Semaphore_Information ); } +#if defined(RTEMS_MULTIPROCESSING) + #define _Semaphore_Get( id, queue_context, mp_callout ) \ + _Semaphore_Do_get( id, queue_context, mp_callout ) +#else + #define _Semaphore_Get( id, queue_context, mp_callout ) \ + _Semaphore_Do_get( id, queue_context ) +#endif + #ifdef __cplusplus } #endif diff --git a/cpukit/rtems/src/barrierdelete.c b/cpukit/rtems/src/barrierdelete.c index 05d6a3f7d0..3d57908326 100644 --- a/cpukit/rtems/src/barrierdelete.c +++ b/cpukit/rtems/src/barrierdelete.c @@ -24,20 +24,20 @@ rtems_status_code rtems_barrier_delete( rtems_id id ) { - Barrier_Control *the_barrier; - ISR_lock_Context lock_context; + Barrier_Control *the_barrier; + Thread_queue_Context queue_context; _Objects_Allocator_lock(); - the_barrier = _Barrier_Get( id, &lock_context ); + the_barrier = _Barrier_Get( id, &queue_context ); if ( the_barrier == NULL ) { _Objects_Allocator_unlock(); return RTEMS_INVALID_ID; } - _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &lock_context ); + _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &queue_context ); _Objects_Close( &_Barrier_Information, &the_barrier->Object ); - _CORE_barrier_Flush( &the_barrier->Barrier, NULL, &lock_context ); + _CORE_barrier_Flush( &the_barrier->Barrier, &queue_context ); _Barrier_Free( the_barrier ); _Objects_Allocator_unlock(); return RTEMS_SUCCESSFUL; diff --git a/cpukit/rtems/src/barrierrelease.c b/cpukit/rtems/src/barrierrelease.c index 2c7d222c0d..2c7f72d303 100644 --- a/cpukit/rtems/src/barrierrelease.c +++ b/cpukit/rtems/src/barrierrelease.c @@ -25,24 +25,23 @@ rtems_status_code rtems_barrier_release( uint32_t *released ) { - Barrier_Control *the_barrier; - ISR_lock_Context lock_context; + Barrier_Control *the_barrier; + Thread_queue_Context queue_context; if ( released == NULL ) { return RTEMS_INVALID_ADDRESS; } - the_barrier = _Barrier_Get( id, &lock_context ); + the_barrier = _Barrier_Get( id, &queue_context ); if ( the_barrier == NULL ) { return RTEMS_INVALID_ID; } - _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &lock_context ); + _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &queue_context ); *released = _CORE_barrier_Surrender( &the_barrier->Barrier, - NULL, - &lock_context + &queue_context ); return RTEMS_SUCCESSFUL; } diff --git a/cpukit/rtems/src/barrierwait.c b/cpukit/rtems/src/barrierwait.c index 7f463aa217..6e133751aa 100644 --- a/cpukit/rtems/src/barrierwait.c +++ b/cpukit/rtems/src/barrierwait.c @@ -27,11 +27,11 @@ rtems_status_code rtems_barrier_wait( rtems_interval timeout ) { - Barrier_Control *the_barrier; - ISR_lock_Context lock_context; - Thread_Control *executing; + Barrier_Control *the_barrier; + Thread_queue_Context queue_context; + Thread_Control *executing; - the_barrier = _Barrier_Get( id, &lock_context ); + the_barrier = _Barrier_Get( id, &queue_context ); if ( the_barrier == NULL ) { return RTEMS_INVALID_ID; @@ -43,8 +43,7 @@ rtems_status_code rtems_barrier_wait( executing, true, timeout, - NULL, - &lock_context + &queue_context ); return _Barrier_Translate_core_barrier_return_code( executing->Wait.return_code diff --git a/cpukit/rtems/src/msgmp.c b/cpukit/rtems/src/msgmp.c index c336ba48c1..d8077a71ec 100644 --- a/cpukit/rtems/src/msgmp.c +++ b/cpukit/rtems/src/msgmp.c @@ -576,17 +576,7 @@ void _Message_queue_MP_Send_extract_proxy ( ); } -/* - * _Message_queue_Core_message_queue_mp_support - * - * Input parameters: - * the_thread - the remote thread the message was submitted to - * id - id of the message queue - * - * Output parameters: NONE - */ - -void _Message_queue_Core_message_queue_mp_support ( +void _Message_queue_Core_message_queue_mp_support( Thread_Control *the_thread, Objects_Id id ) diff --git a/cpukit/rtems/src/msgqbroadcast.c b/cpukit/rtems/src/msgqbroadcast.c index 45d9097326..75f9d60e1b 100644 --- a/cpukit/rtems/src/msgqbroadcast.c +++ b/cpukit/rtems/src/msgqbroadcast.c @@ -28,7 +28,7 @@ rtems_status_code rtems_message_queue_broadcast( ) { Message_queue_Control *the_message_queue; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; CORE_message_queue_Status status; if ( buffer == NULL ) { @@ -39,7 +39,11 @@ rtems_status_code rtems_message_queue_broadcast( return RTEMS_INVALID_ADDRESS; } - the_message_queue = _Message_queue_Get( id, &lock_context ); + the_message_queue = _Message_queue_Get( + id, + &queue_context, + _Message_queue_Core_message_queue_mp_support + ); if ( the_message_queue == NULL ) { #if defined(RTEMS_MULTIPROCESSING) @@ -53,9 +57,8 @@ rtems_status_code rtems_message_queue_broadcast( &the_message_queue->message_queue, buffer, size, - _Message_queue_Core_message_queue_mp_support, count, - &lock_context + &queue_context ); return _Message_queue_Translate_core_message_queue_return_code( status ); } diff --git a/cpukit/rtems/src/msgqdelete.c b/cpukit/rtems/src/msgqdelete.c index c39cfea5a7..94175e6993 100644 --- a/cpukit/rtems/src/msgqdelete.c +++ b/cpukit/rtems/src/msgqdelete.c @@ -26,10 +26,14 @@ rtems_status_code rtems_message_queue_delete( ) { Message_queue_Control *the_message_queue; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; _Objects_Allocator_lock(); - the_message_queue = _Message_queue_Get( id, &lock_context ); + the_message_queue = _Message_queue_Get( + id, + &queue_context, + _Message_queue_MP_Send_object_was_deleted + ); if ( the_message_queue == NULL ) { _Objects_Allocator_unlock(); @@ -45,15 +49,14 @@ rtems_status_code rtems_message_queue_delete( _CORE_message_queue_Acquire_critical( &the_message_queue->message_queue, - &lock_context + &queue_context ); _Objects_Close( &_Message_queue_Information, &the_message_queue->Object ); _CORE_message_queue_Close( &the_message_queue->message_queue, - _Message_queue_MP_Send_object_was_deleted, - &lock_context + &queue_context ); #if defined(RTEMS_MULTIPROCESSING) diff --git a/cpukit/rtems/src/msgqflush.c b/cpukit/rtems/src/msgqflush.c index baca1767f6..b4419d173d 100644 --- a/cpukit/rtems/src/msgqflush.c +++ b/cpukit/rtems/src/msgqflush.c @@ -26,13 +26,13 @@ rtems_status_code rtems_message_queue_flush( ) { Message_queue_Control *the_message_queue; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; if ( count == NULL ) { return RTEMS_INVALID_ADDRESS; } - the_message_queue = _Message_queue_Get( id, &lock_context ); + the_message_queue = _Message_queue_Get( id, &queue_context, NULL ); if ( the_message_queue == NULL ) { #if defined(RTEMS_MULTIPROCESSING) @@ -44,7 +44,7 @@ rtems_status_code rtems_message_queue_flush( *count = _CORE_message_queue_Flush( &the_message_queue->message_queue, - &lock_context + &queue_context ); return RTEMS_SUCCESSFUL; } diff --git a/cpukit/rtems/src/msgqgetnumberpending.c b/cpukit/rtems/src/msgqgetnumberpending.c index f655c0bba4..d2f7820553 100644 --- a/cpukit/rtems/src/msgqgetnumberpending.c +++ b/cpukit/rtems/src/msgqgetnumberpending.c @@ -26,13 +26,13 @@ rtems_status_code rtems_message_queue_get_number_pending( ) { Message_queue_Control *the_message_queue; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; if ( count == NULL ) { return RTEMS_INVALID_ADDRESS; } - the_message_queue = _Message_queue_Get( id, &lock_context ); + the_message_queue = _Message_queue_Get( id, &queue_context, NULL ); if ( the_message_queue == NULL ) { #if defined(RTEMS_MULTIPROCESSING) @@ -44,12 +44,12 @@ rtems_status_code rtems_message_queue_get_number_pending( _CORE_message_queue_Acquire_critical( &the_message_queue->message_queue, - &lock_context + &queue_context ); *count = the_message_queue->message_queue.number_of_pending_messages; _CORE_message_queue_Release( &the_message_queue->message_queue, - &lock_context + &queue_context ); return RTEMS_SUCCESSFUL; } diff --git a/cpukit/rtems/src/msgqreceive.c b/cpukit/rtems/src/msgqreceive.c index dada8dff81..6ed3d25674 100644 --- a/cpukit/rtems/src/msgqreceive.c +++ b/cpukit/rtems/src/msgqreceive.c @@ -32,7 +32,7 @@ rtems_status_code rtems_message_queue_receive( ) { Message_queue_Control *the_message_queue; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; Thread_Control *executing; if ( buffer == NULL ) { @@ -43,7 +43,7 @@ rtems_status_code rtems_message_queue_receive( return RTEMS_INVALID_ADDRESS; } - the_message_queue = _Message_queue_Get( id, &lock_context ); + the_message_queue = _Message_queue_Get( id, &queue_context, NULL ); if ( the_message_queue == NULL ) { #if defined(RTEMS_MULTIPROCESSING) @@ -55,7 +55,7 @@ rtems_status_code rtems_message_queue_receive( _CORE_message_queue_Acquire_critical( &the_message_queue->message_queue, - &lock_context + &queue_context ); executing = _Thread_Executing; @@ -66,7 +66,7 @@ rtems_status_code rtems_message_queue_receive( size, !_Options_Is_no_wait( option_set ), timeout, - &lock_context + &queue_context ); return _Message_queue_Translate_core_message_queue_return_code( executing->Wait.return_code diff --git a/cpukit/rtems/src/msgqsend.c b/cpukit/rtems/src/msgqsend.c index c306deb18b..c5bde9d348 100644 --- a/cpukit/rtems/src/msgqsend.c +++ b/cpukit/rtems/src/msgqsend.c @@ -27,14 +27,18 @@ rtems_status_code rtems_message_queue_send( ) { Message_queue_Control *the_message_queue; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; CORE_message_queue_Status status; if ( buffer == NULL ) { return RTEMS_INVALID_ADDRESS; } - the_message_queue = _Message_queue_Get( id, &lock_context ); + the_message_queue = _Message_queue_Get( + id, + &queue_context, + _Message_queue_Core_message_queue_mp_support + ); if ( the_message_queue == NULL ) { #if defined(RTEMS_MULTIPROCESSING) @@ -46,16 +50,15 @@ rtems_status_code rtems_message_queue_send( _CORE_message_queue_Acquire_critical( &the_message_queue->message_queue, - &lock_context + &queue_context ); status = _CORE_message_queue_Send( &the_message_queue->message_queue, buffer, size, - _Message_queue_Core_message_queue_mp_support, false, /* sender does not block */ 0, /* no timeout */ - &lock_context + &queue_context ); /* diff --git a/cpukit/rtems/src/msgqurgent.c b/cpukit/rtems/src/msgqurgent.c index 56522a1c10..add5f09bb2 100644 --- a/cpukit/rtems/src/msgqurgent.c +++ b/cpukit/rtems/src/msgqurgent.c @@ -27,14 +27,18 @@ rtems_status_code rtems_message_queue_urgent( ) { Message_queue_Control *the_message_queue; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; CORE_message_queue_Status status; if ( buffer == NULL ) { return RTEMS_INVALID_ADDRESS; } - the_message_queue = _Message_queue_Get( id, &lock_context ); + the_message_queue = _Message_queue_Get( + id, + &queue_context, + _Message_queue_Core_message_queue_mp_support + ); if ( the_message_queue == NULL ) { #if defined(RTEMS_MULTIPROCESSING) @@ -46,16 +50,15 @@ rtems_status_code rtems_message_queue_urgent( _CORE_message_queue_Acquire_critical( &the_message_queue->message_queue, - &lock_context + &queue_context ); status = _CORE_message_queue_Urgent( &the_message_queue->message_queue, buffer, size, - _Message_queue_Core_message_queue_mp_support, false, /* sender does not block */ 0, /* no timeout */ - &lock_context + &queue_context ); /* diff --git a/cpukit/rtems/src/semdelete.c b/cpukit/rtems/src/semdelete.c index cf2283830c..023a57cf23 100644 --- a/cpukit/rtems/src/semdelete.c +++ b/cpukit/rtems/src/semdelete.c @@ -25,12 +25,16 @@ rtems_status_code rtems_semaphore_delete( rtems_id id ) { - Semaphore_Control *the_semaphore; - ISR_lock_Context lock_context; - rtems_attribute attribute_set; + Semaphore_Control *the_semaphore; + Thread_queue_Context queue_context; + rtems_attribute attribute_set; _Objects_Allocator_lock(); - the_semaphore = _Semaphore_Get( id, &lock_context ); + the_semaphore = _Semaphore_Get( + id, + &queue_context, + _Semaphore_MP_Send_object_was_deleted + ); if ( the_semaphore == NULL ) { _Objects_Allocator_unlock(); @@ -52,13 +56,13 @@ rtems_status_code rtems_semaphore_delete( _MRSP_Acquire_critical( &the_semaphore->Core_control.mrsp, - &lock_context + &queue_context ); mrsp_status = _MRSP_Can_destroy( &the_semaphore->Core_control.mrsp ); if ( mrsp_status != MRSP_SUCCESSFUL ) { _MRSP_Release( &the_semaphore->Core_control.mrsp, - &lock_context + &queue_context ); _Objects_Allocator_unlock(); return _Semaphore_Translate_MRSP_status_code( mrsp_status ); @@ -68,7 +72,7 @@ rtems_status_code rtems_semaphore_delete( if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { _CORE_mutex_Acquire_critical( &the_semaphore->Core_control.mutex, - &lock_context + &queue_context ); if ( @@ -77,7 +81,7 @@ rtems_status_code rtems_semaphore_delete( ) { _CORE_mutex_Release( &the_semaphore->Core_control.mutex, - &lock_context + &queue_context ); _Objects_Allocator_unlock(); return RTEMS_RESOURCE_IN_USE; @@ -85,7 +89,7 @@ rtems_status_code rtems_semaphore_delete( } else { _CORE_semaphore_Acquire_critical( &the_semaphore->Core_control.semaphore, - &lock_context + &queue_context ); } @@ -93,22 +97,20 @@ rtems_status_code rtems_semaphore_delete( #if defined(RTEMS_SMP) if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) { - _MRSP_Destroy( &the_semaphore->Core_control.mrsp, &lock_context ); + _MRSP_Destroy( &the_semaphore->Core_control.mrsp, &queue_context ); } else #endif if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { _CORE_mutex_Flush( &the_semaphore->Core_control.mutex, _CORE_mutex_Was_deleted, - _Semaphore_MP_Send_object_was_deleted, - &lock_context + &queue_context ); _CORE_mutex_Destroy( &the_semaphore->Core_control.mutex ); } else { _CORE_semaphore_Destroy( &the_semaphore->Core_control.semaphore, - _Semaphore_MP_Send_object_was_deleted, - &lock_context + &queue_context ); } diff --git a/cpukit/rtems/src/semflush.c b/cpukit/rtems/src/semflush.c index 73e9ad06cb..b18de6d4a7 100644 --- a/cpukit/rtems/src/semflush.c +++ b/cpukit/rtems/src/semflush.c @@ -23,11 +23,15 @@ rtems_status_code rtems_semaphore_flush( rtems_id id ) { - Semaphore_Control *the_semaphore; - ISR_lock_Context lock_context; - rtems_attribute attribute_set; + Semaphore_Control *the_semaphore; + Thread_queue_Context queue_context; + rtems_attribute attribute_set; - the_semaphore = _Semaphore_Get( id, &lock_context ); + the_semaphore = _Semaphore_Get( + id, + &queue_context, + _Semaphore_MP_Send_object_was_deleted + ); if ( the_semaphore == NULL ) { #if defined(RTEMS_MULTIPROCESSING) @@ -43,30 +47,28 @@ rtems_status_code rtems_semaphore_flush( rtems_id id ) #if defined(RTEMS_SMP) if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) { - _ISR_lock_ISR_enable( &lock_context ); + _ISR_lock_ISR_enable( &queue_context.Lock_context ); return RTEMS_NOT_DEFINED; } else #endif if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { _CORE_mutex_Acquire_critical( &the_semaphore->Core_control.mutex, - &lock_context + &queue_context ); _CORE_mutex_Flush( &the_semaphore->Core_control.mutex, _CORE_mutex_Unsatisfied_nowait, - _Semaphore_MP_Send_object_was_deleted, - &lock_context + &queue_context ); } else { _CORE_semaphore_Acquire_critical( &the_semaphore->Core_control.semaphore, - &lock_context + &queue_context ); _CORE_semaphore_Flush( &the_semaphore->Core_control.semaphore, - _Semaphore_MP_Send_object_was_deleted, - &lock_context + &queue_context ); } return RTEMS_SUCCESSFUL; diff --git a/cpukit/rtems/src/semobtain.c b/cpukit/rtems/src/semobtain.c index 3cf780aa28..6d994f4707 100644 --- a/cpukit/rtems/src/semobtain.c +++ b/cpukit/rtems/src/semobtain.c @@ -38,13 +38,13 @@ rtems_status_code rtems_semaphore_obtain( rtems_interval timeout ) { - Semaphore_Control *the_semaphore; - ISR_lock_Context lock_context; - Thread_Control *executing; - rtems_attribute attribute_set; - bool wait; + Semaphore_Control *the_semaphore; + Thread_queue_Context queue_context; + Thread_Control *executing; + rtems_attribute attribute_set; + bool wait; - the_semaphore = _Semaphore_Get( id, &lock_context ); + the_semaphore = _Semaphore_Get( id, &queue_context, NULL ); if ( the_semaphore == NULL ) { #if defined(RTEMS_MULTIPROCESSING) @@ -66,7 +66,7 @@ rtems_status_code rtems_semaphore_obtain( executing, wait, timeout, - &lock_context + &queue_context ); return _Semaphore_Translate_MRSP_status_code( mrsp_status ); } else @@ -77,7 +77,7 @@ rtems_status_code rtems_semaphore_obtain( executing, wait, timeout, - &lock_context + &queue_context ); return _Semaphore_Translate_core_mutex_return_code( executing->Wait.return_code @@ -90,7 +90,7 @@ rtems_status_code rtems_semaphore_obtain( executing, wait, timeout, - &lock_context + &queue_context ); return _Semaphore_Translate_core_semaphore_return_code( executing->Wait.return_code diff --git a/cpukit/rtems/src/semrelease.c b/cpukit/rtems/src/semrelease.c index c39455c167..197e4d81b0 100644 --- a/cpukit/rtems/src/semrelease.c +++ b/cpukit/rtems/src/semrelease.c @@ -30,9 +30,13 @@ rtems_status_code rtems_semaphore_release( rtems_id id ) CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; rtems_attribute attribute_set; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; - the_semaphore = _Semaphore_Get( id, &lock_context ); + the_semaphore = _Semaphore_Get( + id, + &queue_context, + _Semaphore_Core_mutex_mp_support + ); if ( the_semaphore == NULL ) { #if defined(RTEMS_MULTIPROCESSING) @@ -50,7 +54,7 @@ rtems_status_code rtems_semaphore_release( rtems_id id ) mrsp_status = _MRSP_Surrender( &the_semaphore->Core_control.mrsp, _Thread_Executing, - &lock_context + &queue_context ); return _Semaphore_Translate_MRSP_status_code( mrsp_status ); } else @@ -58,15 +62,13 @@ rtems_status_code rtems_semaphore_release( rtems_id id ) if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { mutex_status = _CORE_mutex_Surrender( &the_semaphore->Core_control.mutex, - _Semaphore_Core_mutex_mp_support, - &lock_context + &queue_context ); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( &the_semaphore->Core_control.semaphore, - _Semaphore_Core_mutex_mp_support, - &lock_context + &queue_context ); return _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } diff --git a/cpukit/rtems/src/semsetpriority.c b/cpukit/rtems/src/semsetpriority.c index 18fb66ab7f..4deee3d189 100644 --- a/cpukit/rtems/src/semsetpriority.c +++ b/cpukit/rtems/src/semsetpriority.c @@ -22,11 +22,11 @@ #include <rtems/score/schedulerimpl.h> static rtems_status_code _Semaphore_Set_priority( - Semaphore_Control *the_semaphore, - rtems_id scheduler_id, - rtems_task_priority new_priority, - rtems_task_priority *old_priority_p, - ISR_lock_Context *lock_context + Semaphore_Control *the_semaphore, + rtems_id scheduler_id, + rtems_task_priority new_priority, + rtems_task_priority *old_priority_p, + Thread_queue_Context *queue_context ) { rtems_status_code sc; @@ -40,7 +40,7 @@ static rtems_status_code _Semaphore_Set_priority( MRSP_Control *mrsp = &the_semaphore->Core_control.mrsp; uint32_t scheduler_index = _Scheduler_Get_index_by_id( scheduler_id ); - _MRSP_Acquire_critical( mrsp, lock_context ); + _MRSP_Acquire_critical( mrsp, queue_context ); old_priority = _MRSP_Get_ceiling_priority( mrsp, scheduler_index ); @@ -48,7 +48,7 @@ static rtems_status_code _Semaphore_Set_priority( _MRSP_Set_ceiling_priority( mrsp, scheduler_index, new_priority ); } - _MRSP_Release( mrsp, lock_context ); + _MRSP_Release( mrsp, queue_context ); sc = RTEMS_SUCCESSFUL; } else @@ -56,7 +56,7 @@ static rtems_status_code _Semaphore_Set_priority( if ( _Attributes_Is_priority_ceiling( attribute_set ) ) { CORE_mutex_Control *mutex = &the_semaphore->Core_control.mutex; - _CORE_mutex_Acquire_critical( mutex, lock_context ); + _CORE_mutex_Acquire_critical( mutex, queue_context ); old_priority = mutex->Attributes.priority_ceiling; @@ -64,11 +64,11 @@ static rtems_status_code _Semaphore_Set_priority( mutex->Attributes.priority_ceiling = new_priority; } - _CORE_mutex_Release( mutex, lock_context ); + _CORE_mutex_Release( mutex, queue_context ); sc = RTEMS_SUCCESSFUL; } else { - _ISR_lock_ISR_enable( lock_context ); + _ISR_lock_ISR_enable( &queue_context->Lock_context ); old_priority = 0; @@ -87,8 +87,8 @@ rtems_status_code rtems_semaphore_set_priority( rtems_task_priority *old_priority ) { - Semaphore_Control *the_semaphore; - ISR_lock_Context lock_context; + Semaphore_Control *the_semaphore; + Thread_queue_Context queue_context; if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) { @@ -103,7 +103,7 @@ rtems_status_code rtems_semaphore_set_priority( return RTEMS_INVALID_ID; } - the_semaphore = _Semaphore_Get( semaphore_id, &lock_context ); + the_semaphore = _Semaphore_Get( semaphore_id, &queue_context, NULL ); if ( the_semaphore == NULL ) { #if defined(RTEMS_MULTIPROCESSING) @@ -120,6 +120,6 @@ rtems_status_code rtems_semaphore_set_priority( scheduler_id, new_priority, old_priority, - &lock_context + &queue_context ); } diff --git a/cpukit/score/include/rtems/score/corebarrierimpl.h b/cpukit/score/include/rtems/score/corebarrierimpl.h index d5133cd1cf..051990e818 100644 --- a/cpukit/score/include/rtems/score/corebarrierimpl.h +++ b/cpukit/score/include/rtems/score/corebarrierimpl.h @@ -84,31 +84,26 @@ RTEMS_INLINE_ROUTINE void _CORE_barrier_Destroy( RTEMS_INLINE_ROUTINE void _CORE_barrier_Acquire_critical( CORE_barrier_Control *the_barrier, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { - _Thread_queue_Acquire_critical( &the_barrier->Wait_queue, lock_context ); + _Thread_queue_Acquire_critical( + &the_barrier->Wait_queue, + &queue_context->Lock_context + ); } RTEMS_INLINE_ROUTINE void _CORE_barrier_Release( CORE_barrier_Control *the_barrier, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { - _Thread_queue_Release( &the_barrier->Wait_queue, lock_context ); + _Thread_queue_Release( + &the_barrier->Wait_queue, + &queue_context->Lock_context + ); } -void _CORE_barrier_Do_seize( - CORE_barrier_Control *the_barrier, - Thread_Control *executing, - bool wait, - Watchdog_Interval timeout, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context -); - /** * @brief Wait for the barrier. * @@ -127,48 +122,18 @@ void _CORE_barrier_Do_seize( * * @note Status is returned via the thread control block. */ -#if defined(RTEMS_MULTIPROCESSING) - #define _CORE_barrier_Seize( \ - the_barrier, \ - executing, \ - wait, \ - timeout, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_barrier_Do_seize( \ - the_barrier, \ - executing, \ - wait, \ - timeout, \ - mp_callout, \ - lock_context \ - ) -#else - #define _CORE_barrier_Seize( \ - the_barrier, \ - executing, \ - wait, \ - timeout, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_barrier_Do_seize( \ - the_barrier, \ - executing, \ - wait, \ - timeout, \ - lock_context \ - ) -#endif +void _CORE_barrier_Seize( + CORE_barrier_Control *the_barrier, + Thread_Control *executing, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context +); -uint32_t _CORE_barrier_Do_surrender( +uint32_t _CORE_barrier_Do_flush( CORE_barrier_Control *the_barrier, Thread_queue_Flush_filter filter, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ); /** @@ -183,62 +148,35 @@ uint32_t _CORE_barrier_Do_surrender( * * @retval the number of unblocked threads */ -#if defined(RTEMS_MULTIPROCESSING) - #define _CORE_barrier_Surrender( \ - the_barrier, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_barrier_Do_surrender( \ - the_barrier, \ - _Thread_queue_Flush_default_filter, \ - mp_callout, \ - lock_context \ - ) -#else - #define _CORE_barrier_Surrender( \ - the_barrier, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_barrier_Do_surrender( \ - the_barrier, \ - _Thread_queue_Flush_default_filter, \ - lock_context \ - ) -#endif +RTEMS_INLINE_ROUTINE uint32_t _CORE_barrier_Surrender( + CORE_barrier_Control *the_barrier, + Thread_queue_Context *queue_context +) +{ + return _CORE_barrier_Do_flush( + the_barrier, + _Thread_queue_Flush_default_filter, + queue_context + ); +} Thread_Control *_CORE_barrier_Was_deleted( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ); -/* Must be a macro due to the multiprocessing dependent parameters */ -#if defined(RTEMS_MULTIPROCESSING) - #define _CORE_barrier_Flush( \ - the_barrier, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_barrier_Do_surrender( \ - the_barrier, \ - _CORE_barrier_Was_deleted, \ - mp_callout, \ - lock_context \ - ) -#else - #define _CORE_barrier_Flush( \ - the_barrier, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_barrier_Do_surrender( \ - the_barrier, \ - _CORE_barrier_Was_deleted, \ - lock_context \ - ) -#endif +RTEMS_INLINE_ROUTINE void _CORE_barrier_Flush( + CORE_barrier_Control *the_barrier, + Thread_queue_Context *queue_context +) +{ + _CORE_barrier_Do_flush( + the_barrier, + _CORE_barrier_Was_deleted, + queue_context + ); +} /** * This function returns true if the automatic release attribute is diff --git a/cpukit/score/include/rtems/score/coremsg.h b/cpukit/score/include/rtems/score/coremsg.h index af42e7d63d..8d25529fdc 100644 --- a/cpukit/score/include/rtems/score/coremsg.h +++ b/cpukit/score/include/rtems/score/coremsg.h @@ -122,7 +122,7 @@ typedef enum { */ typedef void (*CORE_message_queue_Notify_Handler)( CORE_message_queue_Control *, - ISR_lock_Context * + Thread_queue_Context * ); #endif diff --git a/cpukit/score/include/rtems/score/coremsgimpl.h b/cpukit/score/include/rtems/score/coremsgimpl.h index 4113aa6d5d..30abe0470e 100644 --- a/cpukit/score/include/rtems/score/coremsgimpl.h +++ b/cpukit/score/include/rtems/score/coremsgimpl.h @@ -126,14 +126,6 @@ bool _CORE_message_queue_Initialize( size_t maximum_message_size ); -void _CORE_message_queue_Do_close( - CORE_message_queue_Control *the_message_queue, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context -); - /** * @brief Close a message queue. * @@ -145,33 +137,13 @@ void _CORE_message_queue_Do_close( * flushing @a the_message_queue's task wait queue. * * @param[in] the_message_queue points to the message queue to close - * @param[in] mp_callout is the routine to call for each thread - * that is extracted from the set of waiting threads - * @param[in] lock_context The lock context of the + * @param[in] queue_context The thread queue context used for * _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical(). */ -#if defined(RTEMS_MULTIPROCESSING) - #define _CORE_message_queue_Close( \ - the_message_queue, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_message_queue_Do_close( \ - the_message_queue, \ - mp_callout, \ - lock_context \ - ) -#else - #define _CORE_message_queue_Close( \ - the_message_queue, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_message_queue_Do_close( \ - the_message_queue, \ - lock_context \ - ) -#endif +void _CORE_message_queue_Close( + CORE_message_queue_Control *the_message_queue, + Thread_queue_Context *queue_context +); /** * @brief Flush pending messages. @@ -184,13 +156,13 @@ void _CORE_message_queue_Do_close( * number of messages flushed from the queue is returned. * * @param[in] the_message_queue points to the message queue to flush - * @param[in] lock_context The lock context of the interrupt disable. + * @param[in] queue_context The thread queue context with interrupts disabled. * * @retval This method returns the number of message pending messages flushed. */ uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ); #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API) @@ -210,17 +182,6 @@ uint32_t _CORE_message_queue_Flush( ); #endif -CORE_message_queue_Status _CORE_message_queue_Do_broadcast( - CORE_message_queue_Control *the_message_queue, - const void *buffer, - size_t size, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - uint32_t *count, - ISR_lock_Context *lock_context -); - /** * @brief Broadcast a message to the message queue. * @@ -234,61 +195,19 @@ CORE_message_queue_Status _CORE_message_queue_Do_broadcast( * @param[in] the_message_queue points to the message queue * @param[in] buffer is the starting address of the message to broadcast * @param[in] size is the size of the message being broadcast - * @param[in] mp_callout is the routine to invoke if - * a thread that is unblocked is actually a remote thread. * @param[out] count points to the variable that will contain the * number of tasks that are sent this message - * @param[in] lock_context The lock context of the interrupt disable. + * @param[in] queue_context The thread queue context used for + * _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical(). * @retval @a *count will contain the number of messages sent * @retval indication of the successful completion or reason for failure */ -#if defined(RTEMS_MULTIPROCESSING) - #define _CORE_message_queue_Broadcast( \ - the_message_queue, \ - buffer, \ - size, \ - mp_callout, \ - count, \ - lock_context \ - ) \ - _CORE_message_queue_Do_broadcast( \ - the_message_queue, \ - buffer, \ - size, \ - mp_callout, \ - count, \ - lock_context \ - ) -#else - #define _CORE_message_queue_Broadcast( \ - the_message_queue, \ - buffer, \ - size, \ - mp_callout, \ - count, \ - lock_context \ - ) \ - _CORE_message_queue_Do_broadcast( \ - the_message_queue, \ - buffer, \ - size, \ - count, \ - lock_context \ - ) -#endif - -CORE_message_queue_Status _CORE_message_queue_Do_submit( - CORE_message_queue_Control *the_message_queue, - Thread_Control *executing, - const void *buffer, - size_t size, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - CORE_message_queue_Submit_types submit_type, - bool wait, - Watchdog_Interval timeout, - ISR_lock_Context *lock_context +CORE_message_queue_Status _CORE_message_queue_Broadcast( + CORE_message_queue_Control *the_message_queue, + const void *buffer, + size_t size, + uint32_t *count, + Thread_queue_Context *queue_context ); /** @@ -304,63 +223,26 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit( * @param[in] the_message_queue points to the message queue * @param[in] buffer is the starting address of the message to send * @param[in] size is the size of the message being send - * @param[in] mp_callout is the routine to invoke if - * a thread that is unblocked is actually a remote thread. * @param[in] submit_type determines whether the message is prepended, * appended, or enqueued in priority order. * @param[in] wait indicates whether the calling thread is willing to block * if the message queue is full. * @param[in] timeout is the maximum number of clock ticks that the calling * thread is willing to block if the message queue is full. - * @param[in] lock_context The lock context of the interrupt disable. + * @param[in] queue_context The thread queue context used for + * _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical(). * @retval indication of the successful completion or reason for failure */ -#if defined(RTEMS_MULTIPROCESSING) - #define _CORE_message_queue_Submit( \ - the_message_queue, \ - executing, \ - buffer, \ - size, \ - mp_callout, \ - submit_type, \ - wait, \ - timeout, \ - lock_context \ - ) \ - _CORE_message_queue_Do_submit( \ - the_message_queue, \ - executing, \ - buffer, \ - size, \ - mp_callout, \ - submit_type, \ - wait, \ - timeout, \ - lock_context \ - ) -#else - #define _CORE_message_queue_Submit( \ - the_message_queue, \ - executing, \ - buffer, \ - size, \ - mp_callout, \ - submit_type, \ - wait, \ - timeout, \ - lock_context \ - ) \ - _CORE_message_queue_Do_submit( \ - the_message_queue, \ - executing, \ - buffer, \ - size, \ - submit_type, \ - wait, \ - timeout, \ - lock_context \ - ) -#endif +CORE_message_queue_Status _CORE_message_queue_Submit( + CORE_message_queue_Control *the_message_queue, + Thread_Control *executing, + const void *buffer, + size_t size, + CORE_message_queue_Submit_types submit_type, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context +); /** * @brief Size a message from the message queue. @@ -383,7 +265,8 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit( * if the message queue is empty. * @param[in] timeout is the maximum number of clock ticks that the calling * thread is willing to block if the message queue is empty. - * @param[in] lock_context The lock context of the interrupt disable. + * @param[in] queue_context The thread queue context used for + * _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical(). * * @retval indication of the successful completion or reason for failure. * On success, the location pointed to @a size_p will contain the @@ -396,13 +279,13 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit( * + wait */ void _CORE_message_queue_Seize( - CORE_message_queue_Control *the_message_queue, - Thread_Control *executing, - void *buffer, - size_t *size_p, - bool wait, - Watchdog_Interval timeout, - ISR_lock_Context *lock_context + CORE_message_queue_Control *the_message_queue, + Thread_Control *executing, + void *buffer, + size_t *size_p, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context ); /** @@ -426,76 +309,79 @@ void _CORE_message_queue_Insert_message( CORE_message_queue_Submit_types submit_type ); -/** - * This routine sends a message to the end of the specified message queue. - */ -#define _CORE_message_queue_Send( \ - the_message_queue, \ - buffer, \ - size, \ - mp_callout, \ - wait, \ - timeout, \ - lock_context \ -) \ - _CORE_message_queue_Submit( \ - the_message_queue, \ - _Thread_Executing, \ - buffer, \ - size, \ - mp_callout, \ - CORE_MESSAGE_QUEUE_SEND_REQUEST, \ - wait, \ - timeout, \ - lock_context \ - ) +RTEMS_INLINE_ROUTINE CORE_message_queue_Status _CORE_message_queue_Send( + CORE_message_queue_Control *the_message_queue, + const void *buffer, + size_t size, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context +) +{ + return _CORE_message_queue_Submit( + the_message_queue, + _Thread_Executing, + buffer, + size, + CORE_MESSAGE_QUEUE_SEND_REQUEST, + wait, + timeout, + queue_context + ); +} -/** - * This routine sends a message to the front of the specified message queue. - */ -#define _CORE_message_queue_Urgent( \ - the_message_queue, \ - buffer, \ - size, \ - mp_callout, \ - wait, \ - timeout, \ - lock_context \ -) \ - _CORE_message_queue_Submit( \ - the_message_queue, \ - _Thread_Executing, \ - buffer, \ - size, \ - mp_callout, \ - CORE_MESSAGE_QUEUE_URGENT_REQUEST, \ - wait,\ - timeout, \ - lock_context \ - ) +RTEMS_INLINE_ROUTINE CORE_message_queue_Status _CORE_message_queue_Urgent( + CORE_message_queue_Control *the_message_queue, + const void *buffer, + size_t size, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context +) +{ + return _CORE_message_queue_Submit( + the_message_queue, + _Thread_Executing, + buffer, + size, + CORE_MESSAGE_QUEUE_URGENT_REQUEST, + wait, + timeout, + queue_context + ); +} RTEMS_INLINE_ROUTINE void _CORE_message_queue_Acquire( CORE_message_queue_Control *the_message_queue, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { - _Thread_queue_Acquire( &the_message_queue->Wait_queue, lock_context ); + _Thread_queue_Acquire( + &the_message_queue->Wait_queue, + &queue_context->Lock_context + ); } RTEMS_INLINE_ROUTINE void _CORE_message_queue_Acquire_critical( CORE_message_queue_Control *the_message_queue, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { - _Thread_queue_Acquire_critical( &the_message_queue->Wait_queue, lock_context ); + _Thread_queue_Acquire_critical( + &the_message_queue->Wait_queue, + &queue_context->Lock_context + ); } RTEMS_INLINE_ROUTINE void _CORE_message_queue_Release( CORE_message_queue_Control *the_message_queue, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { - _Thread_queue_Release( &the_message_queue->Wait_queue, lock_context ); + _Thread_queue_Release( + &the_message_queue->Wait_queue, + &queue_context->Lock_context + ); } /** @@ -597,15 +483,12 @@ RTEMS_INLINE_ROUTINE do { } while ( 0 ) #endif -RTEMS_INLINE_ROUTINE Thread_Control *_CORE_message_queue_Do_dequeue_receiver( +RTEMS_INLINE_ROUTINE Thread_Control *_CORE_message_queue_Dequeue_receiver( CORE_message_queue_Control *the_message_queue, const void *buffer, size_t size, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif CORE_message_queue_Submit_types submit_type, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { Thread_Control *the_thread; @@ -647,48 +530,12 @@ RTEMS_INLINE_ROUTINE Thread_Control *_CORE_message_queue_Do_dequeue_receiver( &the_message_queue->Wait_queue.Queue, the_message_queue->operations, the_thread, - mp_callout, - lock_context + queue_context ); return the_thread; } -#if defined(RTEMS_MULTIPROCESSING) - #define _CORE_message_queue_Dequeue_receiver( \ - the_message_queue, \ - buffer, \ - size, \ - mp_callout, \ - submit_type, \ - lock_context \ - ) \ - _CORE_message_queue_Do_dequeue_receiver( \ - the_message_queue, \ - buffer, \ - size, \ - mp_callout, \ - submit_type, \ - lock_context \ - ) -#else - #define _CORE_message_queue_Dequeue_receiver( \ - the_message_queue, \ - buffer, \ - size, \ - mp_callout, \ - submit_type, \ - lock_context \ - ) \ - _CORE_message_queue_Do_dequeue_receiver( \ - the_message_queue, \ - buffer, \ - size, \ - submit_type, \ - lock_context \ - ) -#endif - /** @} */ #ifdef __cplusplus diff --git a/cpukit/score/include/rtems/score/coremuteximpl.h b/cpukit/score/include/rtems/score/coremuteximpl.h index 4531e46e87..a32022aa23 100644 --- a/cpukit/score/include/rtems/score/coremuteximpl.h +++ b/cpukit/score/include/rtems/score/coremuteximpl.h @@ -107,19 +107,25 @@ RTEMS_INLINE_ROUTINE void _CORE_mutex_Destroy( CORE_mutex_Control *the_mutex ) } RTEMS_INLINE_ROUTINE void _CORE_mutex_Acquire_critical( - CORE_mutex_Control *the_mutex, - ISR_lock_Context *lock_context + CORE_mutex_Control *the_mutex, + Thread_queue_Context *queue_context ) { - _Thread_queue_Acquire_critical( &the_mutex->Wait_queue, lock_context ); + _Thread_queue_Acquire_critical( + &the_mutex->Wait_queue, + &queue_context->Lock_context + ); } RTEMS_INLINE_ROUTINE void _CORE_mutex_Release( - CORE_mutex_Control *the_mutex, - ISR_lock_Context *lock_context + CORE_mutex_Control *the_mutex, + Thread_queue_Context *queue_context ) { - _Thread_queue_Release( &the_mutex->Wait_queue, lock_context ); + _Thread_queue_Release( + &the_mutex->Wait_queue, + &queue_context->Lock_context + ); } /** @@ -219,7 +225,7 @@ RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_priority_ceiling( * * @param[in,out] executing The currently executing thread. * @param[in,out] the_mutex is the mutex to attempt to lock - * @param[in] lock_context is the interrupt level + * @param[in] queue_context is the interrupt level * * @retval This routine returns 0 if "trylock" can resolve whether or not * the mutex is immediately obtained or there was an error attempting to @@ -227,9 +233,9 @@ RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_priority_ceiling( * the mutex and will have to block to do so. */ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock( - CORE_mutex_Control *the_mutex, - Thread_Control *executing, - ISR_lock_Context *lock_context + CORE_mutex_Control *the_mutex, + Thread_Control *executing, + Thread_queue_Context *queue_context ) { /* disabled when you get here */ @@ -244,7 +250,7 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock( } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { - _CORE_mutex_Release( the_mutex, lock_context ); + _CORE_mutex_Release( the_mutex, queue_context ); return 0; } /* else must be CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING * @@ -258,15 +264,17 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock( ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { - _CORE_mutex_Release( the_mutex, lock_context ); + _CORE_mutex_Release( the_mutex, queue_context ); return 0; } if ( current > ceiling ) { Per_CPU_Control *cpu_self; - cpu_self = _Thread_Dispatch_disable_critical( lock_context ); - _CORE_mutex_Release( the_mutex, lock_context ); + cpu_self = _Thread_Dispatch_disable_critical( + &queue_context->Lock_context + ); + _CORE_mutex_Release( the_mutex, queue_context ); _Thread_Raise_priority( executing, ceiling ); _Thread_Dispatch_enable( cpu_self ); return 0; @@ -276,7 +284,7 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock( the_mutex->holder = NULL; the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ - _CORE_mutex_Release( the_mutex, lock_context ); + _CORE_mutex_Release( the_mutex, queue_context ); return 0; } } @@ -292,12 +300,12 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock( switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; - _CORE_mutex_Release( the_mutex, lock_context ); + _CORE_mutex_Release( the_mutex, queue_context ); return 0; #if defined(RTEMS_POSIX_API) case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; - _CORE_mutex_Release( the_mutex, lock_context ); + _CORE_mutex_Release( the_mutex, queue_context ); return 0; #endif case CORE_MUTEX_NESTING_BLOCKS: @@ -322,7 +330,7 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock( * @param[in] the_mutex is the mutex to attempt to lock * @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] lock_context is a temporary variable used to contain the ISR + * @param[in] queue_context is a temporary variable used to contain the ISR * disable level cookie * * @note If the mutex is called from an interrupt service routine, @@ -339,11 +347,11 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock( * then they are blocked. */ RTEMS_INLINE_ROUTINE void _CORE_mutex_Seize( - CORE_mutex_Control *the_mutex, - Thread_Control *executing, - bool wait, - Watchdog_Interval timeout, - ISR_lock_Context *lock_context + CORE_mutex_Control *the_mutex, + Thread_Control *executing, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context ) { if ( _CORE_mutex_Check_dispatch_for_seize( wait ) ) { @@ -353,10 +361,12 @@ RTEMS_INLINE_ROUTINE void _CORE_mutex_Seize( INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE ); } - _CORE_mutex_Acquire_critical( the_mutex, lock_context ); - if ( _CORE_mutex_Seize_interrupt_trylock( the_mutex, executing, lock_context ) ) { + _CORE_mutex_Acquire_critical( the_mutex, queue_context ); + if ( + _CORE_mutex_Seize_interrupt_trylock( the_mutex, executing, queue_context ) + ) { if ( !wait ) { - _CORE_mutex_Release( the_mutex, lock_context ); + _CORE_mutex_Release( the_mutex, queue_context ); executing->Wait.return_code = CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT; } else { @@ -364,69 +374,42 @@ RTEMS_INLINE_ROUTINE void _CORE_mutex_Seize( the_mutex, executing, timeout, - lock_context + &queue_context->Lock_context ); } } } -CORE_mutex_Status _CORE_mutex_Do_surrender( - CORE_mutex_Control *the_mutex, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context +CORE_mutex_Status _CORE_mutex_Surrender( + CORE_mutex_Control *the_mutex, + Thread_queue_Context *queue_context ); -#if defined(RTEMS_MULTIPROCESSING) - #define _CORE_mutex_Surrender( \ - the_mutex, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_mutex_Do_surrender( \ - the_mutex, \ - mp_callout, \ - lock_context \ - ) -#else - #define _CORE_mutex_Surrender( \ - the_mutex, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_mutex_Do_surrender( \ - the_mutex, \ - lock_context \ - ) -#endif - Thread_Control *_CORE_mutex_Was_deleted( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ); Thread_Control *_CORE_mutex_Unsatisfied_nowait( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ); -/* Must be a macro due to the multiprocessing dependent parameters */ -#define _CORE_mutex_Flush( \ - the_mutex, \ - filter, \ - mp_callout, \ - lock_context \ -) \ - _Thread_queue_Flush_critical( \ - &( the_mutex )->Wait_queue.Queue, \ - ( the_mutex )->operations, \ - filter, \ - mp_callout, \ - lock_context \ - ) +RTEMS_INLINE_ROUTINE void _CORE_mutex_Flush( + CORE_mutex_Control *the_mutex, + Thread_queue_Flush_filter filter, + Thread_queue_Context *queue_context +) +{ + _Thread_queue_Flush_critical( + &the_mutex->Wait_queue.Queue, + the_mutex->operations, + filter, + queue_context + ); +} RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_owner( const CORE_mutex_Control *the_mutex, diff --git a/cpukit/score/include/rtems/score/corerwlockimpl.h b/cpukit/score/include/rtems/score/corerwlockimpl.h index ed59d696b6..67084c136a 100644 --- a/cpukit/score/include/rtems/score/corerwlockimpl.h +++ b/cpukit/score/include/rtems/score/corerwlockimpl.h @@ -87,19 +87,25 @@ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Destroy( } RTEMS_INLINE_ROUTINE void _CORE_RWLock_Acquire_critical( - CORE_RWLock_Control *the_rwlock, - ISR_lock_Context *lock_context + CORE_RWLock_Control *the_rwlock, + Thread_queue_Context *queue_context ) { - _Thread_queue_Acquire_critical( &the_rwlock->Wait_queue, lock_context ); + _Thread_queue_Acquire_critical( + &the_rwlock->Wait_queue, + &queue_context->Lock_context + ); } RTEMS_INLINE_ROUTINE void _CORE_RWLock_Release( - CORE_RWLock_Control *the_rwlock, - ISR_lock_Context *lock_context + CORE_RWLock_Control *the_rwlock, + Thread_queue_Context *queue_context ) { - _Thread_queue_Release( &the_rwlock->Wait_queue, lock_context ); + _Thread_queue_Release( + &the_rwlock->Wait_queue, + &queue_context->Lock_context + ); } /** @@ -116,11 +122,11 @@ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Release( */ void _CORE_RWLock_Seize_for_reading( - CORE_RWLock_Control *the_rwlock, - Thread_Control *executing, - bool wait, - Watchdog_Interval timeout, - ISR_lock_Context *lock_context + CORE_RWLock_Control *the_rwlock, + Thread_Control *executing, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context ); /** @@ -136,11 +142,11 @@ void _CORE_RWLock_Seize_for_reading( * @note Status is returned via the thread control block. */ void _CORE_RWLock_Seize_for_writing( - CORE_RWLock_Control *the_rwlock, - Thread_Control *executing, - bool wait, - Watchdog_Interval timeout, - ISR_lock_Context *lock_context + CORE_RWLock_Control *the_rwlock, + Thread_Control *executing, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context ); /** @@ -154,8 +160,8 @@ void _CORE_RWLock_Seize_for_writing( * @retval Status is returned to indicate successful or failure. */ CORE_RWLock_Status _CORE_RWLock_Surrender( - CORE_RWLock_Control *the_rwlock, - ISR_lock_Context *lock_context + CORE_RWLock_Control *the_rwlock, + Thread_queue_Context *queue_context ); /** @} */ diff --git a/cpukit/score/include/rtems/score/coresemimpl.h b/cpukit/score/include/rtems/score/coresemimpl.h index 0e04cc930c..1660c1d089 100644 --- a/cpukit/score/include/rtems/score/coresemimpl.h +++ b/cpukit/score/include/rtems/score/coresemimpl.h @@ -88,54 +88,68 @@ void _CORE_semaphore_Initialize( RTEMS_INLINE_ROUTINE void _CORE_semaphore_Acquire_critical( CORE_semaphore_Control *the_semaphore, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { - _Thread_queue_Acquire_critical( &the_semaphore->Wait_queue, lock_context ); + _Thread_queue_Acquire_critical( + &the_semaphore->Wait_queue, + &queue_context->Lock_context + ); } RTEMS_INLINE_ROUTINE void _CORE_semaphore_Release( CORE_semaphore_Control *the_semaphore, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { - _Thread_queue_Release( &the_semaphore->Wait_queue, lock_context ); + _Thread_queue_Release( + &the_semaphore->Wait_queue, + &queue_context->Lock_context + ); } Thread_Control *_CORE_semaphore_Was_deleted( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ); Thread_Control *_CORE_semaphore_Unsatisfied_nowait( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ); -#define _CORE_semaphore_Destroy( \ - the_semaphore, \ - mp_callout, \ - lock_context \ -) \ - do { \ - _Thread_queue_Flush_critical( \ - &( the_semaphore )->Wait_queue.Queue, \ - ( the_semaphore )->operations, \ - _CORE_semaphore_Was_deleted, \ - mp_callout, \ - lock_context \ - ); \ - _Thread_queue_Destroy( &( the_semaphore )->Wait_queue ); \ - } while ( 0 ) +RTEMS_INLINE_ROUTINE void _CORE_semaphore_Destroy( + CORE_semaphore_Control *the_semaphore, + Thread_queue_Context *queue_context +) +{ + _Thread_queue_Flush_critical( + &the_semaphore->Wait_queue.Queue, + the_semaphore->operations, + _CORE_semaphore_Was_deleted, + queue_context + ); + _Thread_queue_Destroy( &the_semaphore->Wait_queue ); +} -RTEMS_INLINE_ROUTINE CORE_semaphore_Status _CORE_semaphore_Do_surrender( +/** + * @brief Surrender a unit to a semaphore. + * + * This routine frees a unit to the semaphore. If a task was blocked waiting + * for a unit from this semaphore, then that task will be readied and the unit + * given to that task. Otherwise, the unit will be returned to the semaphore. + * + * @param[in] the_semaphore is the semaphore to surrender + * @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 CORE_semaphore_Status _CORE_semaphore_Surrender( CORE_semaphore_Control *the_semaphore, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { Thread_Control *the_thread; @@ -143,7 +157,7 @@ RTEMS_INLINE_ROUTINE CORE_semaphore_Status _CORE_semaphore_Do_surrender( status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; - _CORE_semaphore_Acquire_critical( the_semaphore, lock_context ); + _CORE_semaphore_Acquire_critical( the_semaphore, queue_context ); the_thread = _Thread_queue_First_locked( &the_semaphore->Wait_queue, @@ -154,8 +168,7 @@ RTEMS_INLINE_ROUTINE CORE_semaphore_Status _CORE_semaphore_Do_surrender( &the_semaphore->Wait_queue.Queue, the_semaphore->operations, the_thread, - mp_callout, - lock_context + queue_context ); } else { if ( the_semaphore->count < UINT32_MAX ) @@ -163,65 +176,24 @@ RTEMS_INLINE_ROUTINE CORE_semaphore_Status _CORE_semaphore_Do_surrender( else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; - _CORE_semaphore_Release( the_semaphore, lock_context ); + _CORE_semaphore_Release( the_semaphore, queue_context ); } return status; } -/** - * @brief Surrender a unit to a semaphore. - * - * This routine frees a unit to the semaphore. If a task was blocked waiting - * for a unit from this semaphore, then that task will be readied and the unit - * given to that task. Otherwise, the unit will be returned to the semaphore. - * - * @param[in] the_semaphore is the semaphore to surrender - * @param[in] mp_callout is the routine to invoke if the - * thread unblocked is remote - * @param[in] lock_context is a temporary variable used to contain the ISR - * disable level cookie - * - * @retval an indication of whether the routine succeeded or failed - */ -#if defined(RTEMS_MULTIPROCESSING) - #define _CORE_semaphore_Surrender( \ - the_semaphore, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_semaphore_Do_surrender( \ - the_semaphore, \ - mp_callout, \ - lock_context \ - ) -#else - #define _CORE_semaphore_Surrender( \ - the_semaphore, \ - mp_callout, \ - lock_context \ - ) \ - _CORE_semaphore_Do_surrender( \ - the_semaphore, \ - lock_context \ - ) -#endif - -/* Must be a macro due to the multiprocessing dependent parameters */ -#define _CORE_semaphore_Flush( \ - the_semaphore, \ - mp_callout, \ - lock_context \ -) \ - do { \ - _Thread_queue_Flush_critical( \ - &( the_semaphore )->Wait_queue.Queue, \ - ( the_semaphore )->operations, \ - _CORE_semaphore_Unsatisfied_nowait, \ - mp_callout, \ - lock_context \ - ); \ - } while ( 0 ) +RTEMS_INLINE_ROUTINE void _CORE_semaphore_Flush( + CORE_semaphore_Control *the_semaphore, + Thread_queue_Context *queue_context +) +{ + _Thread_queue_Flush_critical( + &the_semaphore->Wait_queue.Queue, + the_semaphore->operations, + _CORE_semaphore_Unsatisfied_nowait, + queue_context + ); +} /** * This routine returns the current count associated with the semaphore. @@ -247,31 +219,31 @@ RTEMS_INLINE_ROUTINE uint32_t _CORE_semaphore_Get_count( * @param[in,out] 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] lock_context is a temporary variable used to contain the ISR + * @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 void _CORE_semaphore_Seize( - CORE_semaphore_Control *the_semaphore, - Thread_Control *executing, - bool wait, - Watchdog_Interval timeout, - ISR_lock_Context *lock_context + CORE_semaphore_Control *the_semaphore, + Thread_Control *executing, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context ) { /* disabled when you get here */ executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; - _CORE_semaphore_Acquire_critical( the_semaphore, lock_context ); + _CORE_semaphore_Acquire_critical( the_semaphore, queue_context ); if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; - _CORE_semaphore_Release( the_semaphore, lock_context ); + _CORE_semaphore_Release( the_semaphore, queue_context ); return; } if ( !wait ) { - _CORE_semaphore_Release( the_semaphore, lock_context ); + _CORE_semaphore_Release( the_semaphore, queue_context ); executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; return; } @@ -283,7 +255,7 @@ RTEMS_INLINE_ROUTINE void _CORE_semaphore_Seize( STATES_WAITING_FOR_SEMAPHORE, timeout, CORE_SEMAPHORE_TIMEOUT, - lock_context + &queue_context->Lock_context ); } diff --git a/cpukit/score/include/rtems/score/mrspimpl.h b/cpukit/score/include/rtems/score/mrspimpl.h index d5cf55dcbf..5173343293 100644 --- a/cpukit/score/include/rtems/score/mrspimpl.h +++ b/cpukit/score/include/rtems/score/mrspimpl.h @@ -54,19 +54,19 @@ RTEMS_INLINE_ROUTINE void _MRSP_Giant_release( ISR_lock_Context *lock_context ) } RTEMS_INLINE_ROUTINE void _MRSP_Acquire_critical( - MRSP_Control *mrsp, - ISR_lock_Context *lock_context + MRSP_Control *mrsp, + Thread_queue_Context *queue_context ) { - _ISR_lock_Acquire( &mrsp->Lock, lock_context ); + _ISR_lock_Acquire( &mrsp->Lock, &queue_context->Lock_context ); } RTEMS_INLINE_ROUTINE void _MRSP_Release( - MRSP_Control *mrsp, - ISR_lock_Context *lock_context + MRSP_Control *mrsp, + Thread_queue_Context *queue_context ) { - _ISR_lock_Release_and_ISR_enable( &mrsp->Lock, lock_context ); + _ISR_lock_Release_and_ISR_enable( &mrsp->Lock, &queue_context->Lock_context ); } RTEMS_INLINE_ROUTINE bool _MRSP_Restore_priority_filter( @@ -104,11 +104,11 @@ RTEMS_INLINE_ROUTINE void _MRSP_Restore_priority( } RTEMS_INLINE_ROUTINE void _MRSP_Claim_ownership( - MRSP_Control *mrsp, - Thread_Control *new_owner, - Priority_Control initial_priority, - Priority_Control ceiling_priority, - ISR_lock_Context *lock_context + MRSP_Control *mrsp, + Thread_Control *new_owner, + Priority_Control initial_priority, + Priority_Control ceiling_priority, + Thread_queue_Context *queue_context ) { Per_CPU_Control *cpu_self; @@ -118,8 +118,8 @@ RTEMS_INLINE_ROUTINE void _MRSP_Claim_ownership( mrsp->initial_priority_of_owner = initial_priority; _Scheduler_Thread_change_help_state( new_owner, SCHEDULER_HELP_ACTIVE_OWNER ); - cpu_self = _Thread_Dispatch_disable_critical( lock_context ); - _MRSP_Release( mrsp, lock_context ); + cpu_self = _Thread_Dispatch_disable_critical( &queue_context->Lock_context ); + _MRSP_Release( mrsp, queue_context ); _Thread_Raise_priority( new_owner, ceiling_priority ); @@ -180,10 +180,11 @@ RTEMS_INLINE_ROUTINE void _MRSP_Timeout( Watchdog_Control *watchdog ) MRSP_Rival *rival = RTEMS_CONTAINER_OF( watchdog, MRSP_Rival, Watchdog ); MRSP_Control *mrsp = rival->resource; Thread_Control *thread = rival->thread; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; - _ISR_lock_ISR_disable( &lock_context ); - _MRSP_Acquire_critical( mrsp, &lock_context ); + _Thread_queue_Context_initialize( &queue_context, NULL ); + _ISR_lock_ISR_disable( &queue_context.Lock_context ); + _MRSP_Acquire_critical( mrsp, &queue_context ); if ( rival->status == MRSP_WAIT_FOR_OWNERSHIP ) { ISR_lock_Context giant_lock_context; @@ -200,20 +201,20 @@ RTEMS_INLINE_ROUTINE void _MRSP_Timeout( Watchdog_Control *watchdog ) rival->status = MRSP_TIMEOUT; - _MRSP_Release( mrsp, &lock_context ); + _MRSP_Release( mrsp, &queue_context ); } else { - _MRSP_Release( mrsp, &lock_context ); + _MRSP_Release( mrsp, &queue_context ); } } RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Wait_for_ownership( - MRSP_Control *mrsp, - Resource_Node *owner, - Thread_Control *executing, - Priority_Control initial_priority, - Priority_Control ceiling_priority, - Watchdog_Interval timeout, - ISR_lock_Context *lock_context + MRSP_Control *mrsp, + Resource_Node *owner, + Thread_Control *executing, + Priority_Control initial_priority, + Priority_Control ceiling_priority, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context ) { MRSP_Status status; @@ -243,8 +244,8 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Wait_for_ownership( _MRSP_Giant_release( &giant_lock_context ); - cpu_self = _Thread_Dispatch_disable_critical( lock_context ); - _MRSP_Release( mrsp, lock_context ); + cpu_self = _Thread_Dispatch_disable_critical( &queue_context->Lock_context ); + _MRSP_Release( mrsp, queue_context ); _Thread_Raise_priority( executing, ceiling_priority ); @@ -286,11 +287,11 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Wait_for_ownership( } RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Seize( - MRSP_Control *mrsp, - Thread_Control *executing, - bool wait, - Watchdog_Interval timeout, - ISR_lock_Context *lock_context + MRSP_Control *mrsp, + Thread_Control *executing, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context ) { MRSP_Status status; @@ -306,11 +307,11 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Seize( Resource_Node *owner; if ( !priority_ok) { - _ISR_lock_ISR_enable( lock_context ); + _ISR_lock_ISR_enable( &queue_context->Lock_context ); return MRSP_INVALID_PRIORITY; } - _MRSP_Acquire_critical( mrsp, lock_context ); + _MRSP_Acquire_critical( mrsp, queue_context ); owner = _Resource_Get_owner( &mrsp->Resource ); if ( owner == NULL ) { _MRSP_Claim_ownership( @@ -318,7 +319,7 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Seize( executing, initial_priority, ceiling_priority, - lock_context + queue_context ); status = MRSP_SUCCESSFUL; } else if ( @@ -332,10 +333,10 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Seize( initial_priority, ceiling_priority, timeout, - lock_context + queue_context ); } else { - _MRSP_Release( mrsp, lock_context ); + _MRSP_Release( mrsp, queue_context ); /* Not available, nested access or deadlock */ status = MRSP_UNSATISFIED; } @@ -344,9 +345,9 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Seize( } RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Surrender( - MRSP_Control *mrsp, - Thread_Control *executing, - ISR_lock_Context *lock_context + MRSP_Control *mrsp, + Thread_Control *executing, + Thread_queue_Context *queue_context ) { Priority_Control initial_priority; @@ -354,7 +355,7 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Surrender( ISR_lock_Context giant_lock_context; if ( _Resource_Get_owner( &mrsp->Resource ) != &executing->Resource_node ) { - _ISR_lock_ISR_enable( lock_context ); + _ISR_lock_ISR_enable( &queue_context->Lock_context ); return MRSP_NOT_OWNER_OF_RESOURCE; } @@ -364,13 +365,13 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Surrender( &executing->Resource_node ) ) { - _ISR_lock_ISR_enable( lock_context ); + _ISR_lock_ISR_enable( &queue_context->Lock_context ); return MRSP_INCORRECT_STATE; } initial_priority = mrsp->initial_priority_of_owner; - _MRSP_Acquire_critical( mrsp, lock_context ); + _MRSP_Acquire_critical( mrsp, queue_context ); _MRSP_Giant_acquire( &giant_lock_context ); @@ -405,8 +406,8 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Surrender( _MRSP_Giant_release( &giant_lock_context ); - cpu_self = _Thread_Dispatch_disable_critical( lock_context ); - _MRSP_Release( mrsp, lock_context ); + cpu_self = _Thread_Dispatch_disable_critical( &queue_context->Lock_context ); + _MRSP_Release( mrsp, queue_context ); _MRSP_Restore_priority( executing, initial_priority ); @@ -425,11 +426,11 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Can_destroy( MRSP_Control *mrsp ) } RTEMS_INLINE_ROUTINE void _MRSP_Destroy( - MRSP_Control *mrsp, - ISR_lock_Context *lock_context + MRSP_Control *mrsp, + Thread_queue_Context *queue_context ) { - _MRSP_Release( mrsp, lock_context ); + _MRSP_Release( mrsp, queue_context ); _ISR_lock_Destroy( &mrsp->Lock ); _Workspace_Free( mrsp->ceiling_priorities ); } diff --git a/cpukit/score/include/rtems/score/threadq.h b/cpukit/score/include/rtems/score/threadq.h index 7ada3fc355..27af89fa75 100644 --- a/cpukit/score/include/rtems/score/threadq.h +++ b/cpukit/score/include/rtems/score/threadq.h @@ -58,6 +58,18 @@ typedef void ( *Thread_queue_MP_callout )( #endif /** + * @brief Thread queue context for the thread queue methods. + * + * @see _Thread_queue_Context_initialize(). + */ +typedef struct { + ISR_lock_Context Lock_context; +#if defined(RTEMS_MULTIPROCESSING) + Thread_queue_MP_callout mp_callout; +#endif +} Thread_queue_Context; + +/** * @brief Thread priority queue. */ typedef struct { diff --git a/cpukit/score/include/rtems/score/threadqimpl.h b/cpukit/score/include/rtems/score/threadqimpl.h index 011c410fa1..752e13e76e 100644 --- a/cpukit/score/include/rtems/score/threadqimpl.h +++ b/cpukit/score/include/rtems/score/threadqimpl.h @@ -53,6 +53,49 @@ typedef struct { #endif } Thread_queue_Syslock_queue; +RTEMS_INLINE_ROUTINE void _Thread_queue_Do_context_initialize( + Thread_queue_Context *queue_context +#if defined(RTEMS_MULTIPROCESSING) + , + Thread_queue_MP_callout mp_callout +#endif +) +{ +#if defined(RTEMS_MULTIPROCESSING) + queue_context->mp_callout = mp_callout; +#else + (void) queue_context; +#endif +} + +/** + * @brief Initializes a thread queue context. + * + * @param queue_context The thread queue context to initialize. + * @param mp_callout Callout to unblock the thread in case it is actually a + * thread proxy. This parameter is only used on multiprocessing + * configurations. Used by thread queue extract and unblock methods for + * objects with multiprocessing (MP) support. + */ +#if defined(RTEMS_MULTIPROCESSING) + #define _Thread_queue_Context_initialize( \ + queue_context, \ + mp_callout \ + ) \ + _Thread_queue_Do_context_initialize( \ + queue_context, \ + mp_callout \ + ) +#else + #define _Thread_queue_Context_initialize( \ + queue_context, \ + mp_callout \ + ) \ + _Thread_queue_Do_context_initialize( \ + queue_context \ + ) +#endif + RTEMS_INLINE_ROUTINE void _Thread_queue_Heads_initialize( Thread_queue_Heads *heads ) @@ -344,7 +387,7 @@ bool _Thread_queue_Do_extract_locked( Thread_Control *the_thread #if defined(RTEMS_MULTIPROCESSING) , - Thread_queue_MP_callout mp_callout + const Thread_queue_Context *queue_context #endif ); @@ -358,9 +401,8 @@ bool _Thread_queue_Do_extract_locked( * @param[in] queue The actual thread queue. * @param[in] operations The thread queue operations. * @param[in] the_thread The thread to extract. - * @param[in] mp_callout Callout to unblock the thread in case it is actually a - * thread proxy. This parameter is only used on multiprocessing - * configurations. + * @param[in] queue_context The thread queue context. This parameter is only + * used on multiprocessing configurations. * * @return Returns the unblock indicator for _Thread_queue_Unblock_critical(). * True indicates, that this thread must be unblocked by the scheduler later in @@ -375,20 +417,20 @@ bool _Thread_queue_Do_extract_locked( unblock, \ queue, \ the_thread, \ - mp_callout \ + queue_context \ ) \ _Thread_queue_Do_extract_locked( \ unblock, \ queue, \ the_thread, \ - mp_callout \ + queue_context \ ) #else #define _Thread_queue_Extract_locked( \ unblock, \ queue, \ the_thread, \ - mp_callout \ + queue_context \ ) \ _Thread_queue_Do_extract_locked( \ unblock, \ @@ -418,16 +460,6 @@ void _Thread_queue_Unblock_critical( ISR_lock_Context *lock_context ); -void _Thread_queue_Do_extract_critical( - Thread_queue_Queue *queue, - const Thread_queue_Operations *operations, - Thread_Control *the_thread, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context -); - /** * @brief Extracts the thread from the thread queue and unblocks it. * @@ -450,10 +482,11 @@ void _Thread_queue_Do_extract_critical( * * void _Mutex_Release( Mutex *mutex ) * { - * ISR_lock_Context lock_context; - * Thread_Control *first; + * Thread_queue_Context queue_context; + * Thread_Control *first; * - * _Thread_queue_Acquire( &mutex->Queue, &lock_context ); + * _Thread_queue_Context_initialize( &queue_context, NULL ); + * _Thread_queue_Acquire( &mutex->Queue, &queue_context.Lock_context ); * * first = _Thread_queue_First_locked( &mutex->Queue ); * mutex->owner = first; @@ -463,9 +496,7 @@ void _Thread_queue_Do_extract_critical( * &mutex->Queue.Queue, * mutex->Queue.operations, * first, - * NULL, - * 0, - * &lock_context + * &queue_context * ); * } * @endcode @@ -473,41 +504,14 @@ void _Thread_queue_Do_extract_critical( * @param[in] queue The actual thread queue. * @param[in] operations The thread queue operations. * @param[in] the_thread The thread to extract. - * @param[in] mp_callout Callout to unblock the thread in case it is actually a - * thread proxy. This parameter is only used on multiprocessing - * configurations. - * @param[in] lock_context The lock context of the lock acquire. + * @param[in] queue_context The thread queue context of the lock acquire. */ -#if defined(RTEMS_MULTIPROCESSING) - #define _Thread_queue_Extract_critical( \ - queue, \ - operations, \ - the_thread, \ - mp_callout, \ - lock_context \ - ) \ - _Thread_queue_Do_extract_critical( \ - queue, \ - operations, \ - the_thread, \ - mp_callout, \ - lock_context \ - ) -#else - #define _Thread_queue_Extract_critical( \ - queue, \ - operations, \ - the_thread, \ - mp_callout, \ - lock_context \ - ) \ - _Thread_queue_Do_extract_critical( \ - queue, \ - operations, \ - the_thread, \ - lock_context \ - ) -#endif +void _Thread_queue_Extract_critical( + Thread_queue_Queue *queue, + const Thread_queue_Operations *operations, + Thread_Control *the_thread, + Thread_queue_Context *queue_context +); /** * @brief Extracts thread from thread queue. @@ -592,9 +596,10 @@ Thread_Control *_Thread_queue_First( * optimize for architectures that use the same register for the first * parameter and the return value. * @param queue The actual thread queue. - * @param lock_context The lock context of the lock acquire. May be used to - * pass additional data to the filter function via an overlay structure. The - * filter function should not release or acquire the thread queue lock. + * @param queue_context The thread queue context of the lock acquire. May be + * used to pass additional data to the filter function via an overlay + * structure. The filter function should not release or acquire the thread + * queue lock. * * @retval the_thread Extract this thread. * @retval NULL Do not extract this thread and stop the thread queue flush @@ -602,9 +607,9 @@ Thread_Control *_Thread_queue_First( * operation. */ typedef Thread_Control *( *Thread_queue_Flush_filter )( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ); /** @@ -612,24 +617,14 @@ typedef Thread_Control *( *Thread_queue_Flush_filter )( * * @param the_thread The thread to extract. * @param queue Unused. - * @param lock_context Unused. + * @param queue_context Unused. * * @retval the_thread Extract this thread. */ Thread_Control *_Thread_queue_Flush_default_filter( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context -); - -size_t _Thread_queue_Do_flush_critical( - Thread_queue_Queue *queue, - const Thread_queue_Operations *operations, - Thread_queue_Flush_filter filter, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ); /** @@ -647,41 +642,19 @@ size_t _Thread_queue_Do_flush_critical( * the thread queue lock, for example to set the thread wait return code. * The return value of the filter function controls if the thread queue flush * operation should stop or continue. - * @param mp_callout Callout to extract the proxy of a remote thread. This - * parameter is only used on multiprocessing configurations. + * @param queue_context The thread queue context of the lock acquire. May be + * used to pass additional data to the filter function via an overlay + * structure. The filter function should not release or acquire the thread + * queue lock. * * @return The count of extracted threads. */ -#if defined(RTEMS_MULTIPROCESSING) - #define _Thread_queue_Flush_critical( \ - queue, \ - operations, \ - filter, \ - mp_callout, \ - lock_context \ - ) \ - _Thread_queue_Do_flush_critical( \ - queue, \ - operations, \ - filter, \ - mp_callout, \ - lock_context \ - ) -#else - #define _Thread_queue_Flush_critical( \ - queue, \ - operations, \ - filter, \ - mp_callout, \ - lock_context \ - ) \ - _Thread_queue_Do_flush_critical( \ - queue, \ - operations, \ - filter, \ - lock_context \ - ) -#endif +size_t _Thread_queue_Flush_critical( + Thread_queue_Queue *queue, + const Thread_queue_Operations *operations, + Thread_queue_Flush_filter filter, + Thread_queue_Context *queue_context +); void _Thread_queue_Initialize( Thread_queue_Control *the_thread_queue ); diff --git a/cpukit/score/src/apimutexlock.c b/cpukit/score/src/apimutexlock.c index 79729d4d24..11d12c5a7e 100644 --- a/cpukit/score/src/apimutexlock.c +++ b/cpukit/score/src/apimutexlock.c @@ -25,20 +25,21 @@ void _API_Mutex_Lock( API_Mutex_Control *the_mutex ) { - Thread_Life_state previous_thread_life_state; - ISR_lock_Context lock_context; + Thread_Life_state previous_thread_life_state; + Thread_queue_Context queue_context; previous_thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED ); - _ISR_lock_ISR_disable( &lock_context ); + _Thread_queue_Context_initialize( &queue_context, NULL ); + _ISR_lock_ISR_disable( &queue_context.Lock_context ); _CORE_mutex_Seize( &the_mutex->Mutex, _Thread_Executing, true, 0, - &lock_context + &queue_context ); if ( the_mutex->Mutex.nest_count == 1 ) { diff --git a/cpukit/score/src/apimutexunlock.c b/cpukit/score/src/apimutexunlock.c index 082961f4fe..f0f114e0bf 100644 --- a/cpukit/score/src/apimutexunlock.c +++ b/cpukit/score/src/apimutexunlock.c @@ -24,19 +24,16 @@ void _API_Mutex_Unlock( API_Mutex_Control *the_mutex ) { - ISR_lock_Context lock_context; - Thread_Life_state previous_thread_life_state; - bool restore_thread_life_protection; + Thread_queue_Context queue_context; + Thread_Life_state previous_thread_life_state; + bool restore_thread_life_protection; previous_thread_life_state = the_mutex->previous_thread_life_state; restore_thread_life_protection = the_mutex->Mutex.nest_count == 1; - _ISR_lock_ISR_disable( &lock_context ); - _CORE_mutex_Surrender( - &the_mutex->Mutex, - NULL, - &lock_context - ); + _Thread_queue_Context_initialize( &queue_context, NULL ); + _ISR_lock_ISR_disable( &queue_context.Lock_context ); + _CORE_mutex_Surrender( &the_mutex->Mutex, &queue_context ); if ( restore_thread_life_protection ) { _Thread_Set_life_protection( previous_thread_life_state ); diff --git a/cpukit/score/src/condition.c b/cpukit/score/src/condition.c index fcd93b201b..c0320b28d4 100644 --- a/cpukit/score/src/condition.c +++ b/cpukit/score/src/condition.c @@ -220,54 +220,54 @@ int _Condition_Wait_recursive_timed( } typedef struct { - ISR_lock_Context Base; - int count; -} Condition_Lock_context; + Thread_queue_Context Base; + int count; +} Condition_Context; static Thread_Control *_Condition_Flush_filter( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ) { - Condition_Lock_context *condition_lock_context; + Condition_Context *context; - condition_lock_context = (Condition_Lock_context *) lock_context; + context = (Condition_Context *) queue_context; - if ( condition_lock_context->count <= 0 ) { + if ( context->count <= 0 ) { return NULL; } - --condition_lock_context->count; + --context->count; return the_thread; } static void _Condition_Wake( struct _Condition_Control *_condition, int count ) { - Condition_Control *condition; - Condition_Lock_context lock_context; + Condition_Control *condition; + Condition_Context context; condition = _Condition_Get( _condition ); - _ISR_lock_ISR_disable( &lock_context.Base ); - _Condition_Queue_acquire_critical( condition, &lock_context.Base ); + _Thread_queue_Context_initialize( &context.Base, NULL ); + _ISR_lock_ISR_disable( &context.Base.Lock_context ); + _Condition_Queue_acquire_critical( condition, &context.Base.Lock_context ); /* * In common uses cases of condition variables there are normally no threads * on the queue, so check this condition early. */ if ( __predict_true( _Thread_queue_Is_empty( &condition->Queue.Queue ) ) ) { - _Condition_Queue_release( condition, &lock_context.Base ); + _Condition_Queue_release( condition, &context.Base.Lock_context ); return; } - lock_context.count = count; + context.count = count; _Thread_queue_Flush_critical( &condition->Queue.Queue, CONDITION_TQ_OPERATIONS, _Condition_Flush_filter, - NULL, - &lock_context.Base + &context.Base ); } diff --git a/cpukit/score/src/corebarrier.c b/cpukit/score/src/corebarrier.c index 3cb7906289..a32f88c46b 100644 --- a/cpukit/score/src/corebarrier.c +++ b/cpukit/score/src/corebarrier.c @@ -33,9 +33,9 @@ void _CORE_barrier_Initialize( } Thread_Control *_CORE_barrier_Was_deleted( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ) { the_thread->Wait.return_code = CORE_BARRIER_WAS_DELETED; diff --git a/cpukit/score/src/corebarrierrelease.c b/cpukit/score/src/corebarrierrelease.c index c9c80f47dd..8a23856d53 100644 --- a/cpukit/score/src/corebarrierrelease.c +++ b/cpukit/score/src/corebarrierrelease.c @@ -21,13 +21,10 @@ #include <rtems/score/corebarrierimpl.h> -uint32_t _CORE_barrier_Do_surrender( +uint32_t _CORE_barrier_Do_flush( CORE_barrier_Control *the_barrier, Thread_queue_Flush_filter filter, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { the_barrier->number_of_waiting_threads = 0; @@ -35,7 +32,6 @@ uint32_t _CORE_barrier_Do_surrender( &the_barrier->Wait_queue.Queue, CORE_BARRIER_TQ_OPERATIONS, filter, - mp_callout, - lock_context + queue_context ); } diff --git a/cpukit/score/src/corebarrierwait.c b/cpukit/score/src/corebarrierwait.c index 54e90965f0..33f1718a66 100644 --- a/cpukit/score/src/corebarrierwait.c +++ b/cpukit/score/src/corebarrierwait.c @@ -21,22 +21,19 @@ #include <rtems/score/corebarrierimpl.h> #include <rtems/score/statesimpl.h> -void _CORE_barrier_Do_seize( - CORE_barrier_Control *the_barrier, - Thread_Control *executing, - bool wait, - Watchdog_Interval timeout, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context +void _CORE_barrier_Seize( + CORE_barrier_Control *the_barrier, + Thread_Control *executing, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context ) { uint32_t number_of_waiting_threads; executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; - _CORE_barrier_Acquire_critical( the_barrier, lock_context ); + _CORE_barrier_Acquire_critical( the_barrier, queue_context ); number_of_waiting_threads = the_barrier->number_of_waiting_threads; ++number_of_waiting_threads; @@ -46,7 +43,7 @@ void _CORE_barrier_Do_seize( && number_of_waiting_threads == the_barrier->Attributes.maximum_count ) { executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; - _CORE_barrier_Surrender( the_barrier, mp_callout, lock_context ); + _CORE_barrier_Surrender( the_barrier, queue_context ); } else { the_barrier->number_of_waiting_threads = number_of_waiting_threads; _Thread_queue_Enqueue_critical( @@ -56,7 +53,7 @@ void _CORE_barrier_Do_seize( STATES_WAITING_FOR_BARRIER, timeout, CORE_BARRIER_TIMEOUT, - lock_context + &queue_context->Lock_context ); } } diff --git a/cpukit/score/src/coremsgbroadcast.c b/cpukit/score/src/coremsgbroadcast.c index a7a962f16f..23dd343c05 100644 --- a/cpukit/score/src/coremsgbroadcast.c +++ b/cpukit/score/src/coremsgbroadcast.c @@ -21,28 +21,25 @@ #include <rtems/score/coremsgimpl.h> #include <rtems/score/objectimpl.h> -CORE_message_queue_Status _CORE_message_queue_Do_broadcast( +CORE_message_queue_Status _CORE_message_queue_Broadcast( CORE_message_queue_Control *the_message_queue, const void *buffer, size_t size, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif uint32_t *count, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { Thread_Control *the_thread; uint32_t number_broadcasted; if ( size > the_message_queue->maximum_message_size ) { - _ISR_lock_ISR_enable( lock_context ); + _ISR_lock_ISR_enable( &queue_context->Lock_context ); return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE; } number_broadcasted = 0; - _CORE_message_queue_Acquire_critical( the_message_queue, lock_context ); + _CORE_message_queue_Acquire_critical( the_message_queue, queue_context ); while ( ( the_thread = @@ -50,18 +47,17 @@ CORE_message_queue_Status _CORE_message_queue_Do_broadcast( the_message_queue, buffer, size, - mp_callout, 0, - lock_context + queue_context ) ) ) { number_broadcasted += 1; - _CORE_message_queue_Acquire( the_message_queue, lock_context ); + _CORE_message_queue_Acquire( the_message_queue, queue_context ); } - _CORE_message_queue_Release( the_message_queue, lock_context ); + _CORE_message_queue_Release( the_message_queue, queue_context ); *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; diff --git a/cpukit/score/src/coremsgclose.c b/cpukit/score/src/coremsgclose.c index 1951e9ffd1..e24d756002 100644 --- a/cpukit/score/src/coremsgclose.c +++ b/cpukit/score/src/coremsgclose.c @@ -22,9 +22,9 @@ #include <rtems/score/wkspace.h> static Thread_Control *_CORE_message_queue_Was_deleted( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ) { the_thread->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_WAS_DELETED; @@ -32,12 +32,9 @@ static Thread_Control *_CORE_message_queue_Was_deleted( return the_thread; } -void _CORE_message_queue_Do_close( +void _CORE_message_queue_Close( CORE_message_queue_Control *the_message_queue, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { @@ -50,8 +47,7 @@ void _CORE_message_queue_Do_close( &the_message_queue->Wait_queue.Queue, the_message_queue->operations, _CORE_message_queue_Was_deleted, - mp_callout, - lock_context + queue_context ); (void) _Workspace_Free( the_message_queue->message_buffers ); diff --git a/cpukit/score/src/coremsgflush.c b/cpukit/score/src/coremsgflush.c index 38f26b7b87..e5b51f9306 100644 --- a/cpukit/score/src/coremsgflush.c +++ b/cpukit/score/src/coremsgflush.c @@ -23,7 +23,7 @@ uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { Chain_Node *inactive_head; @@ -59,7 +59,7 @@ uint32_t _CORE_message_queue_Flush( * fixed execution time that only deals with pending messages. */ - _CORE_message_queue_Acquire_critical( the_message_queue, lock_context ); + _CORE_message_queue_Acquire_critical( the_message_queue, queue_context ); count = the_message_queue->number_of_pending_messages; if ( count != 0 ) { @@ -78,6 +78,6 @@ uint32_t _CORE_message_queue_Flush( _Chain_Initialize_empty( &the_message_queue->Pending_messages ); } - _CORE_message_queue_Release( the_message_queue, lock_context ); + _CORE_message_queue_Release( the_message_queue, queue_context ); return count; } diff --git a/cpukit/score/src/coremsgseize.c b/cpukit/score/src/coremsgseize.c index fcc95a7d28..b05ddd63f3 100644 --- a/cpukit/score/src/coremsgseize.c +++ b/cpukit/score/src/coremsgseize.c @@ -24,7 +24,6 @@ #include <rtems/score/coremsgimpl.h> #include <rtems/score/thread.h> #include <rtems/score/statesimpl.h> -#include <rtems/score/wkspace.h> void _CORE_message_queue_Seize( CORE_message_queue_Control *the_message_queue, @@ -33,7 +32,7 @@ void _CORE_message_queue_Seize( size_t *size_p, bool wait, Watchdog_Interval timeout, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { CORE_message_queue_Buffer_control *the_message; @@ -58,7 +57,7 @@ void _CORE_message_queue_Seize( * So return immediately. */ _CORE_message_queue_Free_message_buffer(the_message_queue, the_message); - _CORE_message_queue_Release( the_message_queue, lock_context ); + _CORE_message_queue_Release( the_message_queue, queue_context ); return; #else { @@ -80,7 +79,7 @@ void _CORE_message_queue_Seize( the_message_queue, the_message ); - _CORE_message_queue_Release( the_message_queue, lock_context ); + _CORE_message_queue_Release( the_message_queue, queue_context ); return; } @@ -100,8 +99,7 @@ void _CORE_message_queue_Seize( &the_message_queue->Wait_queue.Queue, the_message_queue->operations, the_thread, - NULL, - lock_context + queue_context ); return; } @@ -109,7 +107,7 @@ void _CORE_message_queue_Seize( } if ( !wait ) { - _CORE_message_queue_Release( the_message_queue, lock_context ); + _CORE_message_queue_Release( the_message_queue, queue_context ); executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; return; } @@ -125,6 +123,6 @@ void _CORE_message_queue_Seize( STATES_WAITING_FOR_MESSAGE, timeout, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT, - lock_context + &queue_context->Lock_context ); } diff --git a/cpukit/score/src/coremsgsubmit.c b/cpukit/score/src/coremsgsubmit.c index 68067cccb6..a86774175f 100644 --- a/cpukit/score/src/coremsgsubmit.c +++ b/cpukit/score/src/coremsgsubmit.c @@ -25,25 +25,22 @@ #include <rtems/score/statesimpl.h> #include <rtems/score/wkspace.h> -CORE_message_queue_Status _CORE_message_queue_Do_submit( +CORE_message_queue_Status _CORE_message_queue_Submit( CORE_message_queue_Control *the_message_queue, Thread_Control *executing, const void *buffer, size_t size, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout, - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { - _CORE_message_queue_Release( the_message_queue, lock_context ); + _CORE_message_queue_Release( the_message_queue, queue_context ); return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE; } @@ -55,9 +52,8 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit( the_message_queue, buffer, size, - mp_callout, submit_type, - lock_context + queue_context ); if ( the_thread != NULL ) { return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; @@ -90,20 +86,20 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit( ) { ( *the_message_queue->notify_handler )( the_message_queue, - lock_context + queue_context ); } else { - _CORE_message_queue_Release( the_message_queue, lock_context ); + _CORE_message_queue_Release( the_message_queue, queue_context ); } #else - _CORE_message_queue_Release( the_message_queue, lock_context ); + _CORE_message_queue_Release( the_message_queue, queue_context ); #endif return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } #if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND) - _CORE_message_queue_Release( the_message_queue, lock_context ); + _CORE_message_queue_Release( the_message_queue, queue_context ); return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY; #else /* @@ -112,7 +108,7 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit( * on the queue. */ if ( !wait ) { - _CORE_message_queue_Release( the_message_queue, lock_context ); + _CORE_message_queue_Release( the_message_queue, queue_context ); return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY; } @@ -121,7 +117,7 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit( * deadly to block in an ISR. */ if ( _ISR_Is_in_progress() ) { - _CORE_message_queue_Release( the_message_queue, lock_context ); + _CORE_message_queue_Release( the_message_queue, queue_context ); return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; } @@ -143,7 +139,7 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit( STATES_WAITING_FOR_MESSAGE, timeout, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT, - lock_context + &queue_context->Lock_context ); return executing->Wait.return_code; #endif diff --git a/cpukit/score/src/coremutex.c b/cpukit/score/src/coremutex.c index ea5e759dc4..ecca2441e0 100644 --- a/cpukit/score/src/coremutex.c +++ b/cpukit/score/src/coremutex.c @@ -92,9 +92,9 @@ CORE_mutex_Status _CORE_mutex_Initialize( } Thread_Control *_CORE_mutex_Was_deleted( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ) { the_thread->Wait.return_code = CORE_MUTEX_WAS_DELETED; @@ -103,9 +103,9 @@ Thread_Control *_CORE_mutex_Was_deleted( } Thread_Control *_CORE_mutex_Unsatisfied_nowait( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ) { the_thread->Wait.return_code = CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT; diff --git a/cpukit/score/src/coremutexsurrender.c b/cpukit/score/src/coremutexsurrender.c index 746fee118e..040a580592 100644 --- a/cpukit/score/src/coremutexsurrender.c +++ b/cpukit/score/src/coremutexsurrender.c @@ -23,12 +23,9 @@ #include <rtems/score/coremuteximpl.h> #include <rtems/score/thread.h> -CORE_mutex_Status _CORE_mutex_Do_surrender( - CORE_mutex_Control *the_mutex, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context +CORE_mutex_Status _CORE_mutex_Surrender( + CORE_mutex_Control *the_mutex, + Thread_queue_Context *queue_context ) { Thread_Control *the_thread; @@ -46,17 +43,17 @@ CORE_mutex_Status _CORE_mutex_Do_surrender( if ( the_mutex->Attributes.only_owner_release ) { if ( !_Thread_Is_executing( holder ) ) { - _ISR_lock_ISR_enable( lock_context ); + _ISR_lock_ISR_enable( &queue_context->Lock_context ); return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } } - _Thread_queue_Acquire_critical( &the_mutex->Wait_queue, lock_context ); + _CORE_mutex_Acquire_critical( the_mutex, queue_context ); /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) { - _Thread_queue_Release( &the_mutex->Wait_queue, lock_context ); + _CORE_mutex_Release( the_mutex, queue_context ); return CORE_MUTEX_STATUS_SUCCESSFUL; } @@ -71,12 +68,12 @@ CORE_mutex_Status _CORE_mutex_Do_surrender( #if defined(RTEMS_DEBUG) switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: - _Thread_queue_Release( &the_mutex->Wait_queue, lock_context ); + _CORE_mutex_Release( the_mutex, queue_context ); return CORE_MUTEX_STATUS_SUCCESSFUL; #if defined(RTEMS_POSIX_API) case CORE_MUTEX_NESTING_IS_ERROR: /* should never occur */ - _Thread_queue_Release( &the_mutex->Wait_queue, lock_context ); + _CORE_mutex_Release( the_mutex, queue_context ); return CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; #endif case CORE_MUTEX_NESTING_BLOCKS: @@ -84,7 +81,7 @@ CORE_mutex_Status _CORE_mutex_Do_surrender( break; } #else - _Thread_queue_Release( &the_mutex->Wait_queue, lock_context ); + _CORE_mutex_Release( the_mutex, queue_context ); /* must be CORE_MUTEX_NESTING_ACQUIRES or we wouldn't be here */ return CORE_MUTEX_STATUS_SUCCESSFUL; #endif @@ -126,7 +123,7 @@ CORE_mutex_Status _CORE_mutex_Do_surrender( &the_mutex->Wait_queue.Queue, the_mutex->operations, the_thread, - mp_callout + queue_context ); #if defined(RTEMS_MULTIPROCESSING) @@ -155,10 +152,10 @@ CORE_mutex_Status _CORE_mutex_Do_surrender( unblock, &the_mutex->Wait_queue.Queue, the_thread, - lock_context + &queue_context->Lock_context ); } else { - _Thread_queue_Release( &the_mutex->Wait_queue, lock_context ); + _CORE_mutex_Release( the_mutex, queue_context ); } /* diff --git a/cpukit/score/src/corerwlockobtainread.c b/cpukit/score/src/corerwlockobtainread.c index fcbaf4a829..639ea7052d 100644 --- a/cpukit/score/src/corerwlockobtainread.c +++ b/cpukit/score/src/corerwlockobtainread.c @@ -24,11 +24,11 @@ #include <rtems/score/watchdog.h> void _CORE_RWLock_Seize_for_reading( - CORE_RWLock_Control *the_rwlock, - Thread_Control *executing, - bool wait, - Watchdog_Interval timeout, - ISR_lock_Context *lock_context + CORE_RWLock_Control *the_rwlock, + Thread_Control *executing, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context ) { /* @@ -37,13 +37,13 @@ void _CORE_RWLock_Seize_for_reading( * If any thread is waiting, then we wait. */ - _CORE_RWLock_Acquire_critical( the_rwlock, lock_context ); + _CORE_RWLock_Acquire_critical( the_rwlock, queue_context ); switch ( the_rwlock->current_state ) { case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; the_rwlock->number_of_readers += 1; - _CORE_RWLock_Release( the_rwlock, lock_context ); + _CORE_RWLock_Release( the_rwlock, queue_context ); executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; return; @@ -55,7 +55,7 @@ void _CORE_RWLock_Seize_for_reading( ); if ( !waiter ) { the_rwlock->number_of_readers += 1; - _CORE_RWLock_Release( the_rwlock, lock_context ); + _CORE_RWLock_Release( the_rwlock, queue_context ); executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; return; } @@ -70,7 +70,7 @@ void _CORE_RWLock_Seize_for_reading( */ if ( !wait ) { - _CORE_RWLock_Release( the_rwlock, lock_context ); + _CORE_RWLock_Release( the_rwlock, queue_context ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return; } @@ -89,6 +89,6 @@ void _CORE_RWLock_Seize_for_reading( STATES_WAITING_FOR_RWLOCK, timeout, CORE_RWLOCK_TIMEOUT, - lock_context + &queue_context->Lock_context ); } diff --git a/cpukit/score/src/corerwlockobtainwrite.c b/cpukit/score/src/corerwlockobtainwrite.c index e1bb1bd14a..a7d1bb1b6a 100644 --- a/cpukit/score/src/corerwlockobtainwrite.c +++ b/cpukit/score/src/corerwlockobtainwrite.c @@ -24,11 +24,11 @@ #include <rtems/score/watchdog.h> void _CORE_RWLock_Seize_for_writing( - CORE_RWLock_Control *the_rwlock, - Thread_Control *executing, - bool wait, - Watchdog_Interval timeout, - ISR_lock_Context *lock_context + CORE_RWLock_Control *the_rwlock, + Thread_Control *executing, + bool wait, + Watchdog_Interval timeout, + Thread_queue_Context *queue_context ) { /* @@ -38,12 +38,12 @@ void _CORE_RWLock_Seize_for_writing( * If any thread is waiting, then we wait. */ - _CORE_RWLock_Acquire_critical( the_rwlock, lock_context ); + _CORE_RWLock_Acquire_critical( the_rwlock, queue_context ); switch ( the_rwlock->current_state ) { case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; - _CORE_RWLock_Release( the_rwlock, lock_context ); + _CORE_RWLock_Release( the_rwlock, queue_context ); executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; return; @@ -57,7 +57,7 @@ void _CORE_RWLock_Seize_for_writing( */ if ( !wait ) { - _CORE_RWLock_Release( the_rwlock, lock_context ); + _CORE_RWLock_Release( the_rwlock, queue_context ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return; } @@ -76,6 +76,6 @@ void _CORE_RWLock_Seize_for_writing( STATES_WAITING_FOR_RWLOCK, timeout, CORE_RWLOCK_TIMEOUT, - lock_context + &queue_context->Lock_context ); } diff --git a/cpukit/score/src/corerwlockrelease.c b/cpukit/score/src/corerwlockrelease.c index 6f76aad3e5..81e01d1b67 100644 --- a/cpukit/score/src/corerwlockrelease.c +++ b/cpukit/score/src/corerwlockrelease.c @@ -35,9 +35,9 @@ static bool _CORE_RWLock_Is_waiting_for_reading( } static Thread_Control *_CORE_RWLock_Flush_filter( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ) { CORE_RWLock_Control *the_rwlock; @@ -74,8 +74,8 @@ static Thread_Control *_CORE_RWLock_Flush_filter( } CORE_RWLock_Status _CORE_RWLock_Surrender( - CORE_RWLock_Control *the_rwlock, - ISR_lock_Context *lock_context + CORE_RWLock_Control *the_rwlock, + Thread_queue_Context *queue_context ) { /* @@ -85,11 +85,11 @@ CORE_RWLock_Status _CORE_RWLock_Surrender( * If any thread is waiting, then we wait. */ - _CORE_RWLock_Acquire_critical( the_rwlock, lock_context ); + _CORE_RWLock_Acquire_critical( the_rwlock, queue_context ); if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ /* This is an error at the caller site */ - _CORE_RWLock_Release( the_rwlock, lock_context ); + _CORE_RWLock_Release( the_rwlock, queue_context ); return CORE_RWLOCK_SUCCESSFUL; } @@ -98,7 +98,7 @@ CORE_RWLock_Status _CORE_RWLock_Surrender( if ( the_rwlock->number_of_readers != 0 ) { /* must be unlocked again */ - _CORE_RWLock_Release( the_rwlock, lock_context ); + _CORE_RWLock_Release( the_rwlock, queue_context ); return CORE_RWLOCK_SUCCESSFUL; } } @@ -119,8 +119,7 @@ CORE_RWLock_Status _CORE_RWLock_Surrender( &the_rwlock->Wait_queue.Queue, CORE_RWLOCK_TQ_OPERATIONS, _CORE_RWLock_Flush_filter, - NULL, - lock_context + queue_context ); return CORE_RWLOCK_SUCCESSFUL; } diff --git a/cpukit/score/src/coresem.c b/cpukit/score/src/coresem.c index 02a3837410..c94f2b7e86 100644 --- a/cpukit/score/src/coresem.c +++ b/cpukit/score/src/coresem.c @@ -38,9 +38,9 @@ void _CORE_semaphore_Initialize( } Thread_Control *_CORE_semaphore_Was_deleted( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ) { the_thread->Wait.return_code = CORE_SEMAPHORE_WAS_DELETED; @@ -49,9 +49,9 @@ Thread_Control *_CORE_semaphore_Was_deleted( } Thread_Control *_CORE_semaphore_Unsatisfied_nowait( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ) { the_thread->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; diff --git a/cpukit/score/src/futex.c b/cpukit/score/src/futex.c index 66085a8a0a..d7945d12ee 100644 --- a/cpukit/score/src/futex.c +++ b/cpukit/score/src/futex.c @@ -104,25 +104,25 @@ int _Futex_Wait( struct _Futex_Control *_futex, int *uaddr, int val ) } typedef struct { - ISR_lock_Context Base; - int count; -} Futex_Lock_context; + Thread_queue_Context Base; + int count; +} Futex_Context; static Thread_Control *_Futex_Flush_filter( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ) { - Futex_Lock_context *futex_lock_context; + Futex_Context *context; - futex_lock_context = (Futex_Lock_context *) lock_context; + context = (Futex_Context *) queue_context; - if ( futex_lock_context->count <= 0 ) { + if ( context->count <= 0 ) { return NULL; } - --futex_lock_context->count; + --context->count; return the_thread; } @@ -130,10 +130,10 @@ static Thread_Control *_Futex_Flush_filter( int _Futex_Wake( struct _Futex_Control *_futex, int count ) { Futex_Control *futex; - Futex_Lock_context lock_context; + Futex_Context context; futex = _Futex_Get( _futex ); - _Futex_Queue_acquire( futex, &lock_context.Base ); + _Futex_Queue_acquire( futex, &context.Base.Lock_context ); /* * For some synchronization objects like barriers the _Futex_Wake() must be @@ -141,17 +141,16 @@ int _Futex_Wake( struct _Futex_Control *_futex, int count ) * check this condition early. */ if ( __predict_true( _Thread_queue_Is_empty( &futex->Queue.Queue ) ) ) { - _Futex_Queue_release( futex, &lock_context.Base ); + _Futex_Queue_release( futex, &context.Base.Lock_context ); return 0; } - lock_context.count = count; + context.count = count; return (int) _Thread_queue_Flush_critical( &futex->Queue.Queue, FUTEX_TQ_OPERATIONS, _Futex_Flush_filter, - NULL, - &lock_context.Base + &context.Base ); } diff --git a/cpukit/score/src/mpci.c b/cpukit/score/src/mpci.c index 0b51e382e3..4022a800f1 100644 --- a/cpukit/score/src/mpci.c +++ b/cpukit/score/src/mpci.c @@ -321,24 +321,25 @@ void _MPCI_Receive_server( ) { - MP_packet_Prefix *the_packet; - MPCI_Packet_processor the_function; - Thread_Control *executing; - ISR_lock_Context lock_context; + MP_packet_Prefix *the_packet; + MPCI_Packet_processor the_function; + Thread_Control *executing; + Thread_queue_Context queue_context; executing = _Thread_Get_executing(); + _Thread_queue_Context_initialize( &queue_context, NULL ); for ( ; ; ) { executing->receive_packet = NULL; - _ISR_lock_ISR_disable( &lock_context ); + _ISR_lock_ISR_disable( &queue_context.Lock_context ); _CORE_semaphore_Seize( &_MPCI_Semaphore, executing, true, WATCHDOG_NO_TIMEOUT, - &lock_context + &queue_context ); for ( ; ; ) { @@ -370,10 +371,10 @@ void _MPCI_Receive_server( void _MPCI_Announce ( void ) { - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; - _ISR_lock_ISR_disable( &lock_context ); - (void) _CORE_semaphore_Surrender( &_MPCI_Semaphore, 0, &lock_context ); + _ISR_lock_ISR_disable( &queue_context.Lock_context ); + (void) _CORE_semaphore_Surrender( &_MPCI_Semaphore, &queue_context ); } void _MPCI_Internal_packets_Send_process_packet ( diff --git a/cpukit/score/src/mutex.c b/cpukit/score/src/mutex.c index e27075ed8b..0b12232145 100644 --- a/cpukit/score/src/mutex.c +++ b/cpukit/score/src/mutex.c @@ -125,11 +125,11 @@ static void _Mutex_Acquire_slow( } static void _Mutex_Release_slow( - Mutex_Control *mutex, - Thread_Control *executing, - Thread_queue_Heads *heads, - bool keep_priority, - ISR_lock_Context *lock_context + Mutex_Control *mutex, + Thread_Control *executing, + Thread_queue_Heads *heads, + bool keep_priority, + Thread_queue_Context *queue_context ) { if (heads != NULL) { @@ -146,17 +146,17 @@ static void _Mutex_Release_slow( &mutex->Queue.Queue, operations, first, - NULL + queue_context ); _Thread_queue_Boost_priority( &mutex->Queue.Queue, first ); _Thread_queue_Unblock_critical( unblock, &mutex->Queue.Queue, first, - lock_context + &queue_context->Lock_context ); } else { - _Mutex_Queue_release( mutex, lock_context); + _Mutex_Queue_release( mutex, &queue_context->Lock_context ); } if ( !keep_priority ) { @@ -169,9 +169,9 @@ static void _Mutex_Release_slow( } static void _Mutex_Release_critical( - Mutex_Control *mutex, - Thread_Control *executing, - ISR_lock_Context *lock_context + Mutex_Control *mutex, + Thread_Control *executing, + Thread_queue_Context *queue_context ) { Thread_queue_Heads *heads; @@ -193,14 +193,14 @@ static void _Mutex_Release_critical( || !executing->priority_restore_hint; if ( __predict_true( heads == NULL && keep_priority ) ) { - _Mutex_Queue_release( mutex, lock_context ); + _Mutex_Queue_release( mutex, &queue_context->Lock_context ); } else { _Mutex_Release_slow( mutex, executing, heads, keep_priority, - lock_context + queue_context ); } } @@ -297,16 +297,17 @@ int _Mutex_Try_acquire( struct _Mutex_Control *_mutex ) void _Mutex_Release( struct _Mutex_Control *_mutex ) { - Mutex_Control *mutex; - ISR_lock_Context lock_context; - Thread_Control *executing; + Mutex_Control *mutex; + Thread_queue_Context queue_context; + Thread_Control *executing; mutex = _Mutex_Get( _mutex ); - executing = _Mutex_Queue_acquire( mutex, &lock_context ); + _Thread_queue_Context_initialize( &queue_context, NULL ); + executing = _Mutex_Queue_acquire( mutex, &queue_context.Lock_context ); _Assert( mutex->owner == executing ); - _Mutex_Release_critical( mutex, executing, &lock_context ); + _Mutex_Release_critical( mutex, executing, &queue_context ); } static Mutex_recursive_Control *_Mutex_recursive_Get( @@ -426,23 +427,27 @@ int _Mutex_recursive_Try_acquire( struct _Mutex_recursive_Control *_mutex ) void _Mutex_recursive_Release( struct _Mutex_recursive_Control *_mutex ) { Mutex_recursive_Control *mutex; - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; Thread_Control *executing; unsigned int nest_level; mutex = _Mutex_recursive_Get( _mutex ); - executing = _Mutex_Queue_acquire( &mutex->Mutex, &lock_context ); + _Thread_queue_Context_initialize( &queue_context, NULL ); + executing = _Mutex_Queue_acquire( + &mutex->Mutex, + &queue_context.Lock_context + ); _Assert( mutex->Mutex.owner == executing ); nest_level = mutex->nest_level; if ( __predict_true( nest_level == 0 ) ) { - _Mutex_Release_critical( &mutex->Mutex, executing, &lock_context ); + _Mutex_Release_critical( &mutex->Mutex, executing, &queue_context ); } else { mutex->nest_level = nest_level - 1; - _Mutex_Queue_release( &mutex->Mutex, &lock_context ); + _Mutex_Queue_release( &mutex->Mutex, &queue_context.Lock_context ); } } diff --git a/cpukit/score/src/semaphore.c b/cpukit/score/src/semaphore.c index 4e70b79a6a..3d0d5f53ab 100644 --- a/cpukit/score/src/semaphore.c +++ b/cpukit/score/src/semaphore.c @@ -110,18 +110,19 @@ void _Semaphore_Wait( struct _Semaphore_Control *_sem ) void _Semaphore_Post( struct _Semaphore_Control *_sem ) { - Semaphore_Control *sem; - ISR_lock_Context lock_context; - Thread_queue_Heads *heads; + Semaphore_Control *sem; + Thread_queue_Context queue_context; + Thread_queue_Heads *heads; sem = _Semaphore_Get( _sem ); - _Semaphore_Queue_acquire( sem, &lock_context ); + _Thread_queue_Context_initialize( &queue_context, NULL ); + _Semaphore_Queue_acquire( sem, &queue_context.Lock_context ); heads = sem->Queue.Queue.heads; if ( heads == NULL ) { _Assert( sem->count < UINT_MAX ); ++sem->count; - _Semaphore_Queue_release( sem, &lock_context ); + _Semaphore_Queue_release( sem, &queue_context.Lock_context ); } else { const Thread_queue_Operations *operations; Thread_Control *first; @@ -133,8 +134,7 @@ void _Semaphore_Post( struct _Semaphore_Control *_sem ) &sem->Queue.Queue, operations, first, - NULL, - &lock_context + &queue_context ); } } diff --git a/cpukit/score/src/threadqenqueue.c b/cpukit/score/src/threadqenqueue.c index cda7c86efb..a1a37e1ed1 100644 --- a/cpukit/score/src/threadqenqueue.c +++ b/cpukit/score/src/threadqenqueue.c @@ -99,7 +99,7 @@ bool _Thread_queue_Do_extract_locked( Thread_Control *the_thread #if defined(RTEMS_MULTIPROCESSING) , - Thread_queue_MP_callout mp_callout + const Thread_queue_Context *queue_context #endif ) { @@ -108,12 +108,13 @@ bool _Thread_queue_Do_extract_locked( #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) { - Thread_Proxy_control *the_proxy; - - _Assert( mp_callout != NULL ); + Thread_Proxy_control *the_proxy; + Thread_queue_MP_callout mp_callout; the_proxy = (Thread_Proxy_control *) the_thread; - the_proxy->thread_queue_callout = mp_callout; + mp_callout = queue_context->mp_callout; + _Assert( mp_callout != NULL ); + the_proxy->thread_queue_callout = queue_context->mp_callout; } #endif @@ -164,14 +165,11 @@ void _Thread_queue_Unblock_critical( } } -void _Thread_queue_Do_extract_critical( +void _Thread_queue_Extract_critical( Thread_queue_Queue *queue, const Thread_queue_Operations *operations, Thread_Control *the_thread, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { bool unblock; @@ -180,24 +178,28 @@ void _Thread_queue_Do_extract_critical( queue, operations, the_thread, - mp_callout + queue_context ); _Thread_queue_Unblock_critical( unblock, queue, the_thread, - lock_context + &queue_context->Lock_context ); } void _Thread_queue_Extract( Thread_Control *the_thread ) { - ISR_lock_Context lock_context; - void *lock; - Thread_queue_Queue *queue; + Thread_queue_Context queue_context; + void *lock; + Thread_queue_Queue *queue; - lock = _Thread_Lock_acquire( the_thread, &lock_context ); + _Thread_queue_Context_initialize( + &queue_context, + _Thread_queue_MP_callout_do_nothing + ); + lock = _Thread_Lock_acquire( the_thread, &queue_context.Lock_context ); queue = the_thread->Wait.queue; @@ -208,11 +210,10 @@ void _Thread_queue_Extract( Thread_Control *the_thread ) queue, the_thread->Wait.operations, the_thread, - _Thread_queue_MP_callout_do_nothing, - &lock_context + &queue_context ); } else { - _Thread_Lock_release( lock, &lock_context ); + _Thread_Lock_release( lock, &queue_context.Lock_context ); } } @@ -225,10 +226,11 @@ Thread_Control *_Thread_queue_Do_dequeue( #endif ) { - ISR_lock_Context lock_context; - Thread_Control *the_thread; + Thread_queue_Context queue_context; + Thread_Control *the_thread; - _Thread_queue_Acquire( the_thread_queue, &lock_context ); + _Thread_queue_Context_initialize( &queue_context, mp_callout ); + _Thread_queue_Acquire( the_thread_queue, &queue_context.Lock_context ); the_thread = _Thread_queue_First_locked( the_thread_queue, operations ); @@ -239,11 +241,10 @@ Thread_Control *_Thread_queue_Do_dequeue( &the_thread_queue->Queue, operations, the_thread, - mp_callout, - &lock_context + &queue_context ); } else { - _Thread_queue_Release( the_thread_queue, &lock_context ); + _Thread_queue_Release( the_thread_queue, &queue_context.Lock_context ); } return the_thread; diff --git a/cpukit/score/src/threadqflush.c b/cpukit/score/src/threadqflush.c index 0413388f5d..8b23194357 100644 --- a/cpukit/score/src/threadqflush.c +++ b/cpukit/score/src/threadqflush.c @@ -21,24 +21,21 @@ #include <rtems/score/threadimpl.h> Thread_Control *_Thread_queue_Flush_default_filter( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ) { (void) queue; - (void) lock_context; + (void) queue_context; return the_thread; } -size_t _Thread_queue_Do_flush_critical( +size_t _Thread_queue_Flush_critical( Thread_queue_Queue *queue, const Thread_queue_Operations *operations, Thread_queue_Flush_filter filter, -#if defined(RTEMS_MULTIPROCESSING) - Thread_queue_MP_callout mp_callout, -#endif - ISR_lock_Context *lock_context + Thread_queue_Context *queue_context ) { size_t flushed; @@ -60,7 +57,7 @@ size_t _Thread_queue_Do_flush_critical( } first = ( *operations->first )( heads ); - first = ( *filter )( first, queue, lock_context ); + first = ( *filter )( first, queue, queue_context ); if ( first == NULL ) { break; } @@ -69,7 +66,7 @@ size_t _Thread_queue_Do_flush_critical( queue, operations, first, - mp_callout + queue_context ); if ( do_unblock ) { _Chain_Append_unprotected( &unblock, &first->Wait.Node.Chain ); @@ -84,8 +81,10 @@ size_t _Thread_queue_Do_flush_critical( if ( node != tail ) { Per_CPU_Control *cpu_self; - cpu_self = _Thread_Dispatch_disable_critical( lock_context ); - _Thread_queue_Queue_release( queue, lock_context ); + cpu_self = _Thread_Dispatch_disable_critical( + &queue_context->Lock_context + ); + _Thread_queue_Queue_release( queue, &queue_context->Lock_context ); do { Thread_Control *the_thread; @@ -100,7 +99,7 @@ size_t _Thread_queue_Do_flush_critical( _Thread_Dispatch_enable( cpu_self ); } else { - _Thread_queue_Queue_release( queue, lock_context ); + _Thread_queue_Queue_release( queue, &queue_context->Lock_context ); } return flushed; diff --git a/cpukit/score/src/threadrestart.c b/cpukit/score/src/threadrestart.c index 30536f748a..52d68de69a 100644 --- a/cpukit/score/src/threadrestart.c +++ b/cpukit/score/src/threadrestart.c @@ -87,24 +87,24 @@ static void _Thread_Raise_real_priority( } typedef struct { - ISR_lock_Context Base; + Thread_queue_Context Base; #if defined(RTEMS_POSIX_API) - void *exit_value; + void *exit_value; #endif -} Thread_Join_lock_context; +} Thread_Join_context; #if defined(RTEMS_POSIX_API) static Thread_Control *_Thread_Join_flush_filter( - Thread_Control *the_thread, - Thread_queue_Queue *queue, - ISR_lock_Context *lock_context + Thread_Control *the_thread, + Thread_queue_Queue *queue, + Thread_queue_Context *queue_context ) { - Thread_Join_lock_context *join_lock_context; + Thread_Join_context *join_context; - join_lock_context = (Thread_Join_lock_context *) lock_context; + join_context = (Thread_Join_context *) queue_context; - the_thread->Wait.return_argument = join_lock_context->exit_value; + the_thread->Wait.return_argument = join_context->exit_value; return the_thread; } @@ -112,13 +112,17 @@ static Thread_Control *_Thread_Join_flush_filter( static void _Thread_Wake_up_joining_threads( Thread_Control *the_thread ) { - Thread_Join_lock_context join_lock_context; + Thread_Join_context join_context; #if defined(RTEMS_POSIX_API) - join_lock_context.exit_value = the_thread->Life.exit_value; + join_context.exit_value = the_thread->Life.exit_value; #endif - _Thread_State_acquire( the_thread, &join_lock_context.Base ); + _Thread_queue_Context_initialize( &join_context.Base, NULL ); + _Thread_queue_Acquire( + &the_thread->Join_queue, + &join_context.Base.Lock_context + ); _Thread_queue_Flush_critical( &the_thread->Join_queue.Queue, THREAD_JOIN_TQ_OPERATIONS, @@ -127,8 +131,7 @@ static void _Thread_Wake_up_joining_threads( Thread_Control *the_thread ) #else _Thread_queue_Flush_default_filter, #endif - NULL, - &join_lock_context.Base + &join_context.Base ); } diff --git a/testsuites/sptests/spintrcritical22/init.c b/testsuites/sptests/spintrcritical22/init.c index b5044d915f..3670d1ae8d 100644 --- a/testsuites/sptests/spintrcritical22/init.c +++ b/testsuites/sptests/spintrcritical22/init.c @@ -33,12 +33,12 @@ static test_context ctx_instance; static Semaphore_Control *get_semaphore_control(rtems_id id) { - ISR_lock_Context lock_context; + Thread_queue_Context queue_context; Semaphore_Control *sem; - sem = _Semaphore_Get(id, &lock_context); + sem = _Semaphore_Get(id, &queue_context, NULL); rtems_test_assert(sem != NULL); - _ISR_lock_ISR_enable(&lock_context); + _ISR_lock_ISR_enable(&queue_context.Lock_context); return sem; } diff --git a/testsuites/tmtests/tm26/task1.c b/testsuites/tmtests/tm26/task1.c index da37eee73e..68cb246cd0 100644 --- a/testsuites/tmtests/tm26/task1.c +++ b/testsuites/tmtests/tm26/task1.c @@ -477,9 +477,10 @@ rtems_task Floating_point_task_2( void complete_test( void ) { - uint32_t index; - rtems_id task_id; - ISR_lock_Context lock_context; + uint32_t index; + rtems_id task_id; + ISR_lock_Context lock_context; + Thread_queue_Context queue_context; benchmark_timer_initialize(); thread_resume( Middle_tcb ); @@ -513,8 +514,8 @@ void complete_test( void ) benchmark_timer_initialize(); for ( index=1 ; index <= OPERATION_COUNT ; index++ ) { - (void) _Semaphore_Get( Semaphore_id, &lock_context ); - _ISR_lock_ISR_enable( &lock_context ); + (void) _Semaphore_Get( Semaphore_id, &queue_context, NULL ); + _ISR_lock_ISR_enable( &queue_context.Lock_context ); } semaphore_get_time = benchmark_timer_read(); |