Status_Control _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;
_CORE_barrier_Acquire_critical( the_barrier, queue_context );
number_of_waiting_threads = the_barrier->number_of_waiting_threads;
++number_of_waiting_threads;
if (
_CORE_barrier_Is_automatic( &the_barrier->Attributes )
&& number_of_waiting_threads == the_barrier->Attributes.maximum_count
) {
_CORE_barrier_Surrender( the_barrier, queue_context );
return STATUS_BARRIER_AUTOMATICALLY_RELEASED;
} else {
the_barrier->number_of_waiting_threads = number_of_waiting_threads;
_Thread_queue_Context_set_expected_level( queue_context, 1 );
_Thread_queue_Enqueue_critical(
&the_barrier->Wait_queue.Queue,
CORE_BARRIER_TQ_OPERATIONS,
executing,
STATES_WAITING_FOR_BARRIER,
timeout,
queue_context
);
return _Thread_Wait_get_status( executing );
}
}
void _Semaphore_Wait( struct _Semaphore_Control *_sem )
{
Semaphore_Control *sem ;
Thread_queue_Context queue_context;
Thread_Control *executing;
unsigned int count;
sem = _Semaphore_Get( _sem );
_Thread_queue_Context_initialize( &queue_context );
executing = _Semaphore_Queue_acquire( sem, &queue_context );
count = sem->count;
if ( count > 0 ) {
sem->count = count - 1;
_Semaphore_Queue_release( sem, &queue_context );
} else {
_Thread_queue_Context_set_expected_level( &queue_context, 1 );
_Thread_queue_Context_set_no_timeout( &queue_context );
_Thread_queue_Enqueue_critical(
&sem->Queue.Queue,
SEMAPHORE_TQ_OPERATIONS,
executing,
STATES_WAITING_FOR_SYS_LOCK_SEMAPHORE,
&queue_context
);
}
}
static Per_CPU_Control *_Condition_Do_wait(
struct _Condition_Control *_condition,
Watchdog_Interval timeout,
ISR_lock_Context *lock_context
)
{
Condition_Control *condition;
Thread_Control *executing;
Per_CPU_Control *cpu_self;
condition = _Condition_Get( _condition );
executing = _Condition_Queue_acquire_critical( condition, lock_context );
cpu_self = _Thread_Dispatch_disable_critical( lock_context );
executing->Wait.return_code = 0;
_Thread_queue_Enqueue_critical(
&condition->Queue.Queue,
CONDITION_TQ_OPERATIONS,
executing,
STATES_WAITING_FOR_SYS_LOCK_CONDITION,
timeout,
ETIMEDOUT,
lock_context
);
return cpu_self;
}
void _CORE_RWLock_Obtain_for_writing(
CORE_RWLock_Control *the_rwlock,
Thread_Control *executing,
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
ISR_lock_Context lock_context;
/*
* If unlocked, then OK to read.
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_Thread_queue_Acquire( &the_rwlock->Wait_queue, &lock_context );
switch ( the_rwlock->current_state ) {
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
_Thread_queue_Release( &the_rwlock->Wait_queue, &lock_context );
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
return;
case CORE_RWLOCK_LOCKED_FOR_READING:
case CORE_RWLOCK_LOCKED_FOR_WRITING:
break;
}
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
_Thread_queue_Release( &the_rwlock->Wait_queue, &lock_context );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return;
}
/*
* We need to wait to enter this critical section
*/
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
_Thread_queue_Enqueue_critical(
&the_rwlock->Wait_queue,
executing,
STATES_WAITING_FOR_RWLOCK,
timeout,
CORE_RWLOCK_TIMEOUT,
&lock_context
);
/* return to API level so it can dispatch and we block */
}
Status_Control _CORE_RWLock_Seize_for_writing(
CORE_RWLock_Control *the_rwlock,
Thread_Control *executing,
bool wait,
Watchdog_Interval timeout,
Thread_queue_Context *queue_context
)
{
/*
* If unlocked, then OK to read.
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_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, queue_context );
return STATUS_SUCCESSFUL;
case CORE_RWLOCK_LOCKED_FOR_READING:
case CORE_RWLOCK_LOCKED_FOR_WRITING:
break;
}
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
_CORE_RWLock_Release( the_rwlock, queue_context );
return STATUS_UNAVAILABLE;
}
/*
* We need to wait to enter this critical section
*/
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
_Thread_queue_Context_set_expected_level( queue_context, 1 );
_Thread_queue_Enqueue_critical(
&the_rwlock->Wait_queue.Queue,
CORE_RWLOCK_TQ_OPERATIONS,
executing,
STATES_WAITING_FOR_RWLOCK,
timeout,
queue_context
);
return _Thread_Wait_get_status( executing );
}
void _CORE_mutex_Seize_interrupt_blocking(
CORE_mutex_Control *the_mutex,
Thread_Control *executing,
Watchdog_Interval timeout,
ISR_lock_Context *lock_context
)
{
#if !defined(RTEMS_SMP)
/*
* We must disable thread dispatching here since we enable the interrupts for
* priority inheritance mutexes.
*/
_Thread_Dispatch_disable();
#endif
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) {
Thread_Control *holder = the_mutex->holder;
#if !defined(RTEMS_SMP)
/*
* To enable interrupts here works only since exactly one executing thread
* exists and only threads are allowed to seize and surrender mutexes with
* the priority inheritance protocol. On SMP configurations more than one
* executing thread may exist, so here we must not release the lock, since
* otherwise the current holder may be no longer the holder of the mutex
* once we released the lock.
*/
_Thread_queue_Release( &the_mutex->Wait_queue, lock_context );
#endif
_Thread_Inherit_priority( holder, executing );
#if !defined(RTEMS_SMP)
_Thread_queue_Acquire( &the_mutex->Wait_queue, lock_context );
#endif
}
_Thread_queue_Enqueue_critical(
&the_mutex->Wait_queue.Queue,
the_mutex->operations,
executing,
STATES_WAITING_FOR_MUTEX,
timeout,
CORE_MUTEX_TIMEOUT,
lock_context
);
#if !defined(RTEMS_SMP)
_Thread_Dispatch_enable( _Per_CPU_Get() );
#endif
}
static void _Mutex_Acquire_slow(
Mutex_Control *mutex,
Thread_Control *owner,
Thread_Control *executing,
Watchdog_Interval timeout,
ISR_lock_Context *lock_context
)
{
_Thread_Inherit_priority( owner, executing );
_Thread_queue_Enqueue_critical(
&mutex->Queue.Queue,
MUTEX_TQ_OPERATIONS,
executing,
STATES_WAITING_FOR_SYS_LOCK_MUTEX,
timeout,
ETIMEDOUT,
lock_context
);
}
static void _Mutex_Acquire_slow(
Mutex_Control *mutex,
Thread_Control *owner,
Thread_Control *executing,
Thread_queue_Context *queue_context
)
{
_Thread_queue_Context_set_expected_level( queue_context, 1 );
_Thread_queue_Context_set_deadlock_callout(
queue_context,
_Thread_queue_Deadlock_fatal
);
_Thread_queue_Enqueue_critical(
&mutex->Queue.Queue,
MUTEX_TQ_OPERATIONS,
executing,
STATES_WAITING_FOR_SYS_LOCK_MUTEX,
queue_context
);
}
void _Thread_Join(
Thread_Control *the_thread,
States_Control waiting_for_join,
Thread_Control *executing,
Thread_queue_Context *queue_context
)
{
_Assert( the_thread != executing );
_Assert( _Thread_State_is_owner( the_thread ) );
#if defined(RTEMS_POSIX_API)
executing->Wait.return_argument = NULL;
#endif
_Thread_queue_Enqueue_critical(
&the_thread->Join_queue.Queue,
THREAD_JOIN_TQ_OPERATIONS,
executing,
waiting_for_join,
queue_context
);
}
int _POSIX_Condition_variables_Wait_support(
pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
POSIX_Condition_variables_Control *the_cond;
Thread_queue_Context queue_context;
int error;
int mutex_error;
Per_CPU_Control *cpu_self;
Thread_Control *executing;
Watchdog_Interval timeout;
bool already_timedout;
TOD_Absolute_timeout_conversion_results status;
if ( mutex == NULL ) {
return EINVAL;
}
the_cond = _POSIX_Condition_variables_Get( cond, &queue_context );
if ( the_cond == NULL ) {
return EINVAL;
}
already_timedout = false;
if ( abstime != NULL ) {
/*
* POSIX requires that blocking calls with timeouts that take
* an absolute timeout must ignore issues with the absolute
* time provided if the operation would otherwise succeed.
* So we check the abstime provided, and hold on to whether it
* is valid or not. If it isn't correct and in the future,
* then we do a polling operation and convert the UNSATISFIED
* status into the appropriate error.
*/
_Assert( the_cond->clock );
status = _TOD_Absolute_timeout_to_ticks(abstime, the_cond->clock, &timeout);
if ( status == TOD_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == TOD_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == TOD_ABSOLUTE_TIMEOUT_IS_NOW ) {
already_timedout = true;
} else {
_Thread_queue_Context_set_relative_timeout( &queue_context, timeout );
}
} else {
_Thread_queue_Context_set_no_timeout( &queue_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, &queue_context );
return EINVAL;
}
the_cond->mutex = *mutex;
cpu_self = _Thread_Dispatch_disable_critical( &queue_context.Lock_context );
executing = _Per_CPU_Get_executing( cpu_self );
if ( !already_timedout ) {
_Thread_queue_Context_set_expected_level( &queue_context, 2 );
_Thread_queue_Enqueue_critical(
&the_cond->Wait_queue.Queue,
POSIX_CONDITION_VARIABLES_TQ_OPERATIONS,
executing,
STATES_WAITING_FOR_CONDITION_VARIABLE,
&queue_context
);
} else {
_POSIX_Condition_variables_Release( the_cond, &queue_context );
executing->Wait.return_code = STATUS_TIMEOUT;
}
mutex_error = pthread_mutex_unlock( mutex );
if ( mutex_error != 0 ) {
/*
* Historically, we ignored the unlock status since the behavior
* is undefined by POSIX. But GNU/Linux returns EPERM in this
* case, so we follow their lead.
*/
_Assert( mutex_error == EINVAL || mutex_error == EPERM );
_Thread_queue_Extract( executing );
_Thread_Dispatch_enable( cpu_self );
return EPERM;
}
/*
* Switch ourself out because we blocked as a result of the
* _Thread_queue_Enqueue_critical().
*/
_Thread_Dispatch_enable( cpu_self );
error = _POSIX_Get_error_after_wait( executing );
/*
* If the thread is interrupted, while in the thread queue, by
* a POSIX signal, then pthread_cond_wait returns spuriously,
* according to the POSIX standard. It means that pthread_cond_wait
* returns a success status, except for the fact that it was not
* woken up a pthread_cond_signal() or a pthread_cond_broadcast().
*/
if ( error == EINTR ) {
error = 0;
}
/*
* When we get here the dispatch disable level is 0.
*/
mutex_error = pthread_mutex_lock( mutex );
if ( mutex_error != 0 ) {
_Assert( mutex_error == EINVAL );
return EINVAL;
}
return error;
}
CORE_message_queue_Status _CORE_message_queue_Submit(
CORE_message_queue_Control *the_message_queue,
Thread_Control *executing,
const void *buffer,
size_t size,
Objects_Id id,
#if defined(RTEMS_MULTIPROCESSING)
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
#else
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support RTEMS_UNUSED,
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout,
ISR_lock_Context *lock_context
)
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
_ISR_lock_ISR_enable( lock_context );
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
}
_CORE_message_queue_Acquire_critical( the_message_queue, lock_context );
/*
* Is there a thread currently waiting on this message queue?
*/
the_thread = _CORE_message_queue_Dequeue_receiver(
the_message_queue,
buffer,
size,
submit_type,
lock_context
);
if ( the_thread != NULL ) {
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
_Thread_Dispatch_enable( _Per_CPU_Get() );
#endif
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
/*
* No one waiting on the message queue at this time, so attempt to
* queue the message up for a future receive.
*/
the_message =
_CORE_message_queue_Allocate_message_buffer( the_message_queue );
if ( the_message ) {
the_message->Contents.size = size;
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
_CORE_message_queue_Insert_message(
the_message_queue,
the_message,
submit_type
);
_CORE_message_queue_Release( the_message_queue, lock_context );
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
#if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND)
_CORE_message_queue_Release( the_message_queue, lock_context );
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
#else
/*
* No message buffers were available so we may need to return an
* overflow error or block the sender until the message is placed
* on the queue.
*/
if ( !wait ) {
_CORE_message_queue_Release( the_message_queue, lock_context );
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
}
/*
* Do NOT block on a send if the caller is in an ISR. It is
* deadly to block in an ISR.
*/
if ( _ISR_Is_in_progress() ) {
_CORE_message_queue_Release( the_message_queue, lock_context );
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
}
/*
* WARNING!! executing should NOT be used prior to this point.
* Thus the unusual choice to open a new scope and declare
* it as a variable. Doing this emphasizes how dangerous it
* would be to use this variable prior to here.
*/
executing->Wait.id = id;
executing->Wait.return_argument_second.immutable_object = buffer;
executing->Wait.option = (uint32_t) size;
executing->Wait.count = submit_type;
_Thread_queue_Enqueue_critical(
&the_message_queue->Wait_queue.Queue,
the_message_queue->Wait_queue.operations,
executing,
STATES_WAITING_FOR_MESSAGE,
timeout,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT,
lock_context
);
#if defined(RTEMS_MULTIPROCESSING)
_Thread_Dispatch_enable( _Per_CPU_Get() );
#endif
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
