rtems_status_code rtems_task_set_scheduler(
rtems_id task_id,
rtems_id scheduler_id,
rtems_task_priority priority
)
{
const Scheduler_Control *scheduler;
Thread_Control *the_thread;
Thread_queue_Context queue_context;
ISR_lock_Context state_context;
Per_CPU_Control *cpu_self;
bool valid;
Priority_Control core_priority;
Status_Control status;
if ( !_Scheduler_Get_by_id( scheduler_id, &scheduler ) ) {
return RTEMS_INVALID_ID;
}
core_priority = _RTEMS_Priority_To_core( scheduler, priority, &valid );
if ( !valid ) {
return RTEMS_INVALID_PRIORITY;
}
_Thread_queue_Context_initialize( &queue_context );
the_thread = _Thread_Get( task_id, &queue_context.Lock_context.Lock_context );
if ( the_thread == NULL ) {
#if defined(RTEMS_MULTIPROCESSING)
if ( _Thread_MP_Is_remote( task_id ) ) {
return RTEMS_ILLEGAL_ON_REMOTE_OBJECT;
}
#endif
return RTEMS_INVALID_ID;
}
cpu_self = _Thread_Dispatch_disable_critical(
&queue_context.Lock_context.Lock_context
);
_Thread_Wait_acquire_critical( the_thread, &queue_context );
_Thread_State_acquire_critical( the_thread, &state_context );
status = _Scheduler_Set( scheduler, the_thread, core_priority );
_Thread_State_release_critical( the_thread, &state_context );
_Thread_Wait_release( the_thread, &queue_context );
_Thread_Dispatch_enable( cpu_self );
return _Status_Get( status );
}
static rtems_status_code _Partition_MP_Send_request_packet (
Objects_Id partition_id,
void *buffer,
Partition_MP_Remote_operations operation
)
{
Partition_MP_Packet *the_packet;
Status_Control status;
if ( !_Partition_MP_Is_remote( partition_id ) ) {
return RTEMS_INVALID_ID;
}
switch ( operation ) {
case PARTITION_MP_GET_BUFFER_REQUEST:
case PARTITION_MP_RETURN_BUFFER_REQUEST:
the_packet = _Partition_MP_Get_packet();
_Partition_MP_Initialize_packet( the_packet, partition_id, operation );
the_packet->buffer = buffer;
status = _MPCI_Send_request_packet(
_Objects_Get_node( partition_id ),
&the_packet->Prefix,
STATES_READY /* Not used */
);
return _Status_Get( status );
case PARTITION_MP_ANNOUNCE_CREATE:
case PARTITION_MP_ANNOUNCE_DELETE:
case PARTITION_MP_EXTRACT_PROXY:
case PARTITION_MP_GET_BUFFER_RESPONSE:
case PARTITION_MP_RETURN_BUFFER_RESPONSE:
break;
}
/*
* The following line is included to satisfy compilers which
* produce warnings when a function does not end with a return.
*/
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_message_queue_send(
rtems_id id,
const void *buffer,
size_t size
)
{
Message_queue_Control *the_message_queue;
Thread_queue_Context queue_context;
Status_Control status;
if ( buffer == NULL ) {
return RTEMS_INVALID_ADDRESS;
}
the_message_queue = _Message_queue_Get( id, &queue_context );
if ( the_message_queue == NULL ) {
#if defined(RTEMS_MULTIPROCESSING)
return _Message_queue_MP_Send( id, buffer, size );
#else
return RTEMS_INVALID_ID;
#endif
}
_CORE_message_queue_Acquire_critical(
&the_message_queue->message_queue,
&queue_context
);
_Thread_queue_Context_set_MP_callout(
&queue_context,
_Message_queue_Core_message_queue_mp_support
);
status = _CORE_message_queue_Send(
&the_message_queue->message_queue,
buffer,
size,
false, /* sender does not block */
&queue_context
);
return _Status_Get( status );
}
rtems_status_code rtems_semaphore_release( rtems_id id )
{
Semaphore_Control *the_semaphore;
Thread_queue_Context queue_context;
Thread_Control *executing;
Status_Control status;
the_semaphore = _Semaphore_Get( id, &queue_context );
if ( the_semaphore == NULL ) {
#if defined(RTEMS_MULTIPROCESSING)
return _Semaphore_MP_Release( id );
#else
return RTEMS_INVALID_ID;
#endif
}
executing = _Thread_Executing;
_Thread_queue_Context_set_MP_callout(
&queue_context,
_Semaphore_Core_mutex_mp_support
);
switch ( the_semaphore->variant ) {
case SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY:
status = _CORE_recursive_mutex_Surrender(
&the_semaphore->Core_control.Mutex.Recursive,
executing,
&queue_context
);
break;
case SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING:
status = _CORE_ceiling_mutex_Surrender(
&the_semaphore->Core_control.Mutex,
executing,
&queue_context
);
break;
case SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL:
_CORE_recursive_mutex_Surrender_no_protocol(
&the_semaphore->Core_control.Mutex.Recursive,
_Semaphore_Get_operations( the_semaphore ),
executing,
&queue_context
);
status = STATUS_SUCCESSFUL;
break;
case SEMAPHORE_VARIANT_SIMPLE_BINARY:
status = _CORE_semaphore_Surrender(
&the_semaphore->Core_control.Semaphore,
_Semaphore_Get_operations( the_semaphore ),
1,
&queue_context
);
_Assert(
status == STATUS_SUCCESSFUL
|| status == STATUS_MAXIMUM_COUNT_EXCEEDED
);
status = STATUS_SUCCESSFUL;
break;
#if defined(RTEMS_SMP)
case SEMAPHORE_VARIANT_MRSP:
status = _MRSP_Surrender(
&the_semaphore->Core_control.MRSP,
executing,
&queue_context
);
break;
#endif
default:
_Assert( the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING );
status = _CORE_semaphore_Surrender(
&the_semaphore->Core_control.Semaphore,
_Semaphore_Get_operations( the_semaphore ),
UINT32_MAX,
&queue_context
);
break;
}
return _Status_Get( status );
}
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
Semaphore_Control *the_semaphore;
Thread_queue_Context queue_context;
Status_Control status;
_Objects_Allocator_lock();
the_semaphore = _Semaphore_Get( id, &queue_context );
if ( the_semaphore == NULL ) {
_Objects_Allocator_unlock();
#if defined(RTEMS_MULTIPROCESSING)
if ( _Semaphore_MP_Is_remote( id ) ) {
return RTEMS_ILLEGAL_ON_REMOTE_OBJECT;
}
#endif
return RTEMS_INVALID_ID;
}
_Thread_queue_Acquire_critical(
&the_semaphore->Core_control.Wait_queue,
&queue_context.Lock_context
);
switch ( the_semaphore->variant ) {
case SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY:
case SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING:
case SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL:
if (
_CORE_mutex_Is_locked(
&the_semaphore->Core_control.Mutex.Recursive.Mutex
)
) {
status = STATUS_RESOURCE_IN_USE;
} else {
status = STATUS_SUCCESSFUL;
}
break;
#if defined(RTEMS_SMP)
case SEMAPHORE_VARIANT_MRSP:
status = _MRSP_Can_destroy( &the_semaphore->Core_control.MRSP );
break;
#endif
default:
_Assert(
the_semaphore->variant == SEMAPHORE_VARIANT_SIMPLE_BINARY
|| the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING
);
status = STATUS_SUCCESSFUL;
break;
}
if ( status != STATUS_SUCCESSFUL ) {
_Thread_queue_Release(
&the_semaphore->Core_control.Wait_queue,
&queue_context.Lock_context
);
_Objects_Allocator_unlock();
return _Status_Get( status );
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
switch ( the_semaphore->variant ) {
#if defined(RTEMS_SMP)
case SEMAPHORE_VARIANT_MRSP:
_MRSP_Destroy( &the_semaphore->Core_control.MRSP, &queue_context );
break;
#endif
default:
_Assert(
the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY
|| the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING
|| the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL
|| the_semaphore->variant == SEMAPHORE_VARIANT_SIMPLE_BINARY
|| the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING
);
_Thread_queue_Flush_critical(
&the_semaphore->Core_control.Wait_queue.Queue,
_Semaphore_Get_operations( the_semaphore ),
_Thread_queue_Flush_status_object_was_deleted,
&queue_context
);
_Thread_queue_Destroy( &the_semaphore->Core_control.Wait_queue );
break;
}
#if defined(RTEMS_MULTIPROCESSING)
if ( the_semaphore->is_global ) {
_Objects_MP_Close( &_Semaphore_Information, id );
_Semaphore_MP_Send_process_packet(
SEMAPHORE_MP_ANNOUNCE_DELETE,
id,
0, /* Not used */
0 /* Not used */
);
}
#endif
_Semaphore_Free( the_semaphore );
_Objects_Allocator_unlock();
return RTEMS_SUCCESSFUL;
}
