RTEMS_INLINE_ROUTINE bool _Scheduler_Set_root_visitor( Resource_Node *resource_node, void *arg ) { Scheduler_Set_root_context *ctx = arg; Thread_Control *root = ctx->root; Thread_Control *needs_help = root; Thread_Control *offers_help = THREAD_RESOURCE_NODE_TO_THREAD( resource_node ); const Scheduler_Control *scheduler = _Scheduler_Get_own( offers_help ); Thread_Control *needs_help_too; _Resource_Node_set_root( resource_node, &root->Resource_node ); needs_help_too = ( *scheduler->Operations.ask_for_help )( scheduler, offers_help, needs_help ); if ( needs_help_too != needs_help && needs_help_too != NULL ) { _Assert( ctx->needs_help == NULL ); ctx->needs_help = needs_help_too; } return false; }
static bool _Thread_Inherit_priority_filter( Thread_Control *inheritor, Priority_Control *new_priority, void *arg ) { Thread_Control *ancestor = arg; if ( _Scheduler_Get_own( inheritor ) == _Scheduler_Get_own( ancestor ) ) { *new_priority = ancestor->current_priority; } return _Thread_Priority_less_than( inheritor->current_priority, *new_priority ); }
rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority_p ) { Thread_Control *the_thread; ISR_lock_Context lock_context; const Scheduler_Control *scheduler; Priority_Control old_priority; rtems_status_code status; if ( old_priority_p == NULL ) { return RTEMS_INVALID_ADDRESS; } the_thread = _Thread_Get( id, &lock_context ); if ( the_thread == NULL ) { #if defined(RTEMS_MULTIPROCESSING) return _RTEMS_tasks_MP_Set_priority( id, new_priority, old_priority_p ); #else return RTEMS_INVALID_ID; #endif } if ( new_priority != RTEMS_CURRENT_PRIORITY ) { RTEMS_tasks_Set_priority_context context; Per_CPU_Control *cpu_self; cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); _ISR_lock_ISR_enable( &lock_context ); context.new_priority = new_priority; _Thread_Change_priority( the_thread, 0, &context, _RTEMS_tasks_Set_priority_filter, false ); _Thread_Dispatch_enable( cpu_self ); scheduler = context.scheduler; old_priority = context.old_priority; status = context.status; } else { _Thread_State_acquire_critical( the_thread, &lock_context ); scheduler = _Scheduler_Get_own( the_thread ); old_priority = _Thread_Get_priority( the_thread ); _Thread_State_release( the_thread, &lock_context ); status = RTEMS_SUCCESSFUL; } *old_priority_p = _RTEMS_Priority_From_core( scheduler, old_priority ); return status; }
static void _Thread_queue_Priority_inherit_enqueue( Thread_queue_Queue *queue, Thread_Control *the_thread, Thread_queue_Path *path ) { Thread_queue_Heads *heads; Thread_Control *owner; Priority_Control priority; heads = _Thread_queue_Queue_enqueue( queue, the_thread, _Thread_queue_Priority_do_initialize, _Thread_queue_Priority_do_enqueue ); owner = queue->owner; #if defined(RTEMS_SMP) if ( _Chain_Has_only_one_node( &heads->Heads.Fifo ) ) { priority = the_thread->current_priority; } else { priority = _Scheduler_Map_priority( _Scheduler_Get_own( the_thread ), PRIORITY_PSEUDO_ISR ); } #else (void) heads; priority = the_thread->current_priority; #endif if ( priority < owner->current_priority ) { path->update_priority = owner; owner->priority_restore_hint = true; _Atomic_Fence( ATOMIC_ORDER_ACQ_REL ); _Scheduler_Thread_set_priority( owner, priority, false ); ( *owner->Wait.operations->priority_change )( owner->Wait.queue, owner, priority ); } else { path->update_priority = NULL; } }
static Thread_queue_Priority_queue *_Thread_queue_Priority_queue( Thread_queue_Heads *heads, const Thread_Control *the_thread ) { #if defined(RTEMS_SMP) return &heads->Priority[ _Scheduler_Get_index( _Scheduler_Get_own( the_thread ) ) ]; #else (void) the_thread; return &heads->Heads.Priority; #endif }
int pthread_setschedprio( pthread_t thread, int prio ) { Thread_Control *the_thread; Per_CPU_Control *cpu_self; Thread_queue_Context queue_context; const Scheduler_Control *scheduler; Priority_Control new_priority; bool valid; the_thread = _Thread_Get( thread, &queue_context.Lock_context.Lock_context ); if ( the_thread == NULL ) { return ESRCH; } _Thread_queue_Context_clear_priority_updates( &queue_context ); _Thread_Wait_acquire_critical( the_thread, &queue_context ); scheduler = _Scheduler_Get_own( the_thread ); new_priority = _POSIX_Priority_To_core( scheduler, prio, &valid ); if ( !valid ) { _Thread_Wait_release( the_thread, &queue_context ); return EINVAL; } _Thread_Priority_change( the_thread, &the_thread->Real_priority, new_priority, true, &queue_context ); cpu_self = _Thread_Dispatch_disable_critical( &queue_context.Lock_context.Lock_context ); _Thread_Wait_release( the_thread, &queue_context ); _Thread_Priority_update( &queue_context ); _Thread_Dispatch_enable( cpu_self ); return 0; }
static bool _RTEMS_tasks_Set_priority_filter( Thread_Control *the_thread, Priority_Control *new_priority_p, void *arg ) { RTEMS_tasks_Set_priority_context *context; const Scheduler_Control *scheduler; bool valid; Priority_Control current_priority; Priority_Control new_priority; context = arg; scheduler = _Scheduler_Get_own( the_thread ); current_priority = _Thread_Get_priority( the_thread ); context->scheduler = scheduler; context->old_priority = current_priority; new_priority = _RTEMS_Priority_To_core( scheduler, context->new_priority, &valid ); *new_priority_p = new_priority; if ( !valid ) { context->status = RTEMS_INVALID_PRIORITY; return false; } the_thread->real_priority = new_priority; context->status = STATUS_SUCCESSFUL; return _Thread_Priority_less_than( current_priority, new_priority ) || !_Thread_Owns_resources( the_thread ); }
static void _Thread_queue_Boost_priority( Thread_queue_Heads *heads, Thread_Control *the_thread ) { #if defined(RTEMS_SMP) if ( !_Chain_Has_only_one_node( &heads->Heads.Fifo ) ) { const Scheduler_Control *scheduler; Priority_Control boost_priority; the_thread->priority_restore_hint = true; _Atomic_Fence( ATOMIC_ORDER_ACQ_REL ); scheduler = _Scheduler_Get_own( the_thread ); boost_priority = _Scheduler_Map_priority( scheduler, PRIORITY_PSEUDO_ISR ); _Scheduler_Thread_set_priority( the_thread, boost_priority, false ); } #else (void) heads; (void) the_thread; #endif }
int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { Thread_Control *the_thread; Thread_queue_Context queue_context; POSIX_API_Control *api; const Scheduler_Control *scheduler; Priority_Control priority; if ( policy == NULL || param == NULL ) { return EINVAL; } the_thread = _Thread_Get( thread, &queue_context.Lock_context ); if ( the_thread == NULL ) { return ESRCH; } api = the_thread->API_Extensions[ THREAD_API_POSIX ]; _Thread_Wait_acquire_critical( the_thread, &queue_context ); *policy = api->Attributes.schedpolicy; *param = api->Attributes.schedparam; scheduler = _Scheduler_Get_own( the_thread ); priority = the_thread->real_priority; _Thread_Wait_release( the_thread, &queue_context ); param->sched_priority = _POSIX_Priority_From_core( scheduler, priority ); return 0; }