Constants and Structures Related with Thread Dispatch. More...

Files
file	iterateoverthreads.c
	Iterates Over All Threads.

file	thread.c
	Initialize Thread Handler.

file	threadchangepriority.c
	Changes the Priority of a Thread.

file	threadclearstate.c
	Clear Thread state.

file	threadcreateidle.c
	Create Idle Thread.

file	threaddispatch.c
	Dispatch Thread.

file	threadget.c
	Maps Thread IDs to TCB Pointer.

file	threadhandler.c
	Thread Handler.

file	threadinitialize.c
	Initialize Thread.

file	threadloadenv.c
	Initializes Enviroment for A Thread.

file	threadrestart.c
	Restart Thread.

file	threadsetstate.c
	Sets States for a Thread.

file	threadstackallocate.c
	Stack Allocate Helper.

file	threadstackfree.c
	Deallocate Thread Stack.

file	threadstart.c
	Initializes Thread and Executes it.

file	threadstartmultitasking.c
	Start Thread Multitasking.

file	threadtimeout.c
	Thread Wait Timeout.

file	threadyield.c
	Thread Yield.

Data Structures
struct	Thread_Entry_idle
	Data for idle thread entry. More...

struct	Thread_Entry_numeric
	Data for thread entry with one numeric argument and no return value. More...

struct	Thread_Entry_pointer
	Data for thread entry with one pointer argument and a pointer return value. More...

struct	Thread_Entry_information
	Thread entry information. More...

struct	Thread_Start_information

struct	Thread_Scheduler_control
	Thread scheduler control. More...

union	Thread_Wait_information_Object_argument_type
	Union type to hold a pointer to an immutable or a mutable object. More...

struct	Thread_Wait_information
	Information required to manage a thread while it is blocked. More...

struct	Thread_Timer_information
	Information required to manage a thread timer. More...

struct	Thread_Proxy_control

struct	Thread_Action
	Thread action. More...

struct	Thread_Keys_information
	Per-thread information for POSIX Keys. More...

struct	Thread_Action_control
	Control block to manage thread actions. More...

struct	Thread_Life_control
	Thread life control. More...

struct	Thread_Capture_control

struct	_Thread_Control

struct	Thread_Control_add_on
	Thread control add-on. More...

struct	Thread_Information
	The thread object information. More...

struct	Thread_Close_context

Macros
#define	RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE

#define	RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT

#define	RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API

#define	THREAD_API_FIRST THREAD_API_RTEMS

#define	THREAD_API_LAST THREAD_API_POSIX

#define	_Thread_queue_Heads_size sizeof(Thread_queue_Heads)
	Size of the thread queue heads of a particular application. More...

#define	THREAD_INFORMATION_DEFINE_ZERO(name, api, cls)

#define	THREAD_INFORMATION_DEFINE(name, api, cls, max)

#define	RTEMS_SCORE_ROBUST_THREAD_DISPATCH
	Enables a robust thread dispatch. More...

#define	THREAD_STATUS_PROXY_BLOCKING 0x1111111

#define	THREAD_WAIT_FLAGS_INITIAL 0x0U
	The initial thread wait flags value set by _Thread_Initialize().

#define	THREAD_WAIT_STATE_MASK 0xffU
	Mask to get the thread wait state flags.

#define	THREAD_WAIT_STATE_INTEND_TO_BLOCK 0x1U
	Indicates that the thread begins with the blocking operation. More...

#define	THREAD_WAIT_STATE_BLOCKED 0x2U
	Indicates that the thread completed the blocking operation.

#define	THREAD_WAIT_STATE_READY_AGAIN 0x4U
	Indicates that a condition to end the thread wait occurred. More...

#define	THREAD_WAIT_CLASS_MASK 0xff00U
	Mask to get the thread wait class flags.

#define	THREAD_WAIT_CLASS_EVENT 0x100U
	Indicates that the thread waits for an event.

#define	THREAD_WAIT_CLASS_SYSTEM_EVENT 0x200U
	Indicates that the thread waits for a system event.

#define	THREAD_WAIT_CLASS_OBJECT 0x400U
	Indicates that the thread waits for an object.

#define	THREAD_WAIT_CLASS_PERIOD 0x800U
	Indicates that the thread waits for a period.

Typedefs
typedef void *Thread	RTEMS_DEPRECATED

typedef CPU_Uint32ptr	Thread_Entry_numeric_type
	Type of the numeric argument of a thread entry function with at least one numeric argument. More...

typedef void(*	Thread_CPU_budget_algorithm_callout) (Thread_Control *)

typedef unsigned int	Thread_Wait_flags
	This type is able to contain several flags used to control the wait class and state of a thread. More...

typedef struct Thread_Action	Thread_Action

typedef void(*	Thread_Action_handler) (Thread_Control the_thread, Thread_Action action, ISR_lock_Context *lock_context)
	Thread action handler. More...

typedef void(*	rtems_per_thread_routine) (Thread_Control *)

typedef struct Thread_Configured_control	Thread_Configured_control
	The configured thread control block. More...

typedef Thread_queue_Heads	Thread_queue_Configured_heads
	The configured thread queue heads. More...

typedef bool(*	Thread_Visitor) (Thread_Control the_thread, void arg)

Enumerations
enum	Thread_CPU_budget_algorithms { THREAD_CPU_BUDGET_ALGORITHM_NONE, THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE, THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE, THREAD_CPU_BUDGET_ALGORITHM_CALLOUT }

enum	Thread_APIs { THREAD_API_RTEMS, THREAD_API_POSIX }

enum	Thread_Life_state { THREAD_LIFE_PROTECTED = 0x1, THREAD_LIFE_RESTARTING = 0x2, THREAD_LIFE_TERMINATING = 0x4, THREAD_LIFE_CHANGE_DEFERRED = 0x8, THREAD_LIFE_DETACHED = 0x10 }
	Thread life states. More...

Functions
void	rtems_iterate_over_all_threads (rtems_per_thread_routine routine) RTEMS_DEPRECATED

RTEMS_INLINE_ROUTINE bool	_Thread_Dispatch_is_enabled (void)
	Indicates if the executing thread is inside a thread dispatch critical section. More...

RTEMS_INLINE_ROUTINE uint32_t	_Thread_Dispatch_get_disable_level (void)
	Gets thread dispatch disable level. More...

RTEMS_INLINE_ROUTINE void	_Thread_Dispatch_initialization (void)
	Thread dispatch initialization. More...

void	_Thread_Dispatch (void)
	Performs a thread dispatch if necessary. More...

void	_Thread_Dispatch_direct (Per_CPU_Control *cpu_self)
	Directly do a thread dispatch. More...

void	_Thread_Do_dispatch (Per_CPU_Control *cpu_self, ISR_Level level)
	Performs a thread dispatch on the current processor. More...

RTEMS_INLINE_ROUTINE Per_CPU_Control *	_Thread_Dispatch_disable_with_CPU (Per_CPU_Control cpu_self, const ISR_lock_Context lock_context)
	Disables thread dispatching inside a critical section (interrupts disabled) with the current processor. More...

RTEMS_INLINE_ROUTINE Per_CPU_Control *	_Thread_Dispatch_disable_critical (const ISR_lock_Context *lock_context)
	Disables thread dispatching inside a critical section (interrupts disabled). More...

RTEMS_INLINE_ROUTINE Per_CPU_Control *	_Thread_Dispatch_disable (void)
	Disables thread dispatching. More...

void	_Thread_Dispatch_enable (Per_CPU_Control *cpu_self)
	Enables thread dispatching. More...

RTEMS_INLINE_ROUTINE void	_Thread_Dispatch_unnest (Per_CPU_Control *cpu_self)
	Unnests thread dispatching. More...

RTEMS_INLINE_ROUTINE void	_Thread_Dispatch_request (Per_CPU_Control cpu_self, Per_CPU_Control cpu_target)
	Requests a thread dispatch on the target processor. More...

void	_Thread_Iterate (Thread_Visitor visitor, void *arg)

void	_Thread_Initialize_information (Thread_Information *information)

void	_Thread_Handler_initialization (void)
	Initialize thread handler. More...

void	_Thread_Create_idle (void)
	Create idle thread. More...

void	_Thread_Start_multitasking (void) RTEMS_NO_RETURN
	Start thread multitasking. More...

size_t	_Thread_Stack_Allocate (Thread_Control *the_thread, size_t stack_size)
	Allocate the requested stack space for the thread. More...

void	_Thread_Stack_Free (Thread_Control *the_thread)
	Deallocate thread stack. More...

bool	_Thread_Initialize (Thread_Information information, Thread_Control the_thread, const struct _Scheduler_Control scheduler, void stack_area, size_t stack_size, bool is_fp, Priority_Control priority, bool is_preemptible, Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name)
	Initialize thread. More...

bool	_Thread_Start (Thread_Control the_thread, const Thread_Entry_information entry, ISR_lock_Context *lock_context)
	Initializes thread and executes it. More...

void	_Thread_Restart_self (Thread_Control executing, const Thread_Entry_information entry, ISR_lock_Context *lock_context) RTEMS_NO_RETURN

bool	_Thread_Restart_other (Thread_Control the_thread, const Thread_Entry_information entry, ISR_lock_Context *lock_context)

void	_Thread_Yield (Thread_Control *executing)

Thread_Life_state	_Thread_Change_life (Thread_Life_state clear, Thread_Life_state set, Thread_Life_state ignore)

Thread_Life_state	_Thread_Set_life_protection (Thread_Life_state state)

void	_Thread_Kill_zombies (void)
	Kills all zombie threads in the system. More...

void	_Thread_Exit (Thread_Control executing, Thread_Life_state set, void exit_value)

void	_Thread_Join (Thread_Control the_thread, States_Control waiting_for_join, Thread_Control executing, Thread_queue_Context *queue_context)

void	_Thread_Cancel (Thread_Control the_thread, Thread_Control executing, void *exit_value)

void	_Thread_Close (Thread_Control the_thread, Thread_Control executing, Thread_Close_context *context)
	Closes the thread. More...

RTEMS_INLINE_ROUTINE bool	_Thread_Is_ready (const Thread_Control *the_thread)

States_Control	_Thread_Clear_state_locked (Thread_Control *the_thread, States_Control state)

States_Control	_Thread_Clear_state (Thread_Control *the_thread, States_Control state)
	Clears the specified thread state. More...

States_Control	_Thread_Set_state_locked (Thread_Control *the_thread, States_Control state)

States_Control	_Thread_Set_state (Thread_Control *the_thread, States_Control state)
	Sets the specified thread state. More...

void	_Thread_Load_environment (Thread_Control *the_thread)
	Initializes enviroment for a thread. More...

void	_Thread_Entry_adaptor_idle (Thread_Control *executing)

void	_Thread_Entry_adaptor_numeric (Thread_Control *executing)

void	_Thread_Entry_adaptor_pointer (Thread_Control *executing)

void	_Thread_Handler (void)
	Wrapper function for all threads. More...

RTEMS_INLINE_ROUTINE void	_Thread_State_acquire_critical (Thread_Control the_thread, ISR_lock_Context lock_context)

RTEMS_INLINE_ROUTINE void	_Thread_State_acquire (Thread_Control the_thread, ISR_lock_Context lock_context)

RTEMS_INLINE_ROUTINE Thread_Control *	_Thread_State_acquire_for_executing (ISR_lock_Context *lock_context)

RTEMS_INLINE_ROUTINE void	_Thread_State_release_critical (Thread_Control the_thread, ISR_lock_Context lock_context)

RTEMS_INLINE_ROUTINE void	_Thread_State_release (Thread_Control the_thread, ISR_lock_Context lock_context)

void	_Thread_Priority_perform_actions (Thread_Control start_of_path, Thread_queue_Context queue_context)
	Performs the priority actions specified by the thread queue context along the thread queue path. More...

void	_Thread_Priority_add (Thread_Control the_thread, Priority_Node priority_node, Thread_queue_Context *queue_context)
	Adds the specified thread priority node to the corresponding thread priority aggregation. More...

void	_Thread_Priority_remove (Thread_Control the_thread, Priority_Node priority_node, Thread_queue_Context *queue_context)
	Removes the specified thread priority node from the corresponding thread priority aggregation. More...

void	_Thread_Priority_changed (Thread_Control the_thread, Priority_Node priority_node, bool prepend_it, Thread_queue_Context *queue_context)
	Propagates a thread priority value change in the specified thread priority node to the corresponding thread priority aggregation. More...

RTEMS_INLINE_ROUTINE void	_Thread_Priority_change (Thread_Control the_thread, Priority_Node priority_node, Priority_Control new_priority, bool prepend_it, Thread_queue_Context *queue_context)
	Changes the thread priority value of the specified thread priority node in the corresponding thread priority aggregation. More...

void	_Thread_Priority_replace (Thread_Control the_thread, Priority_Node victim_node, Priority_Node *replacement_node)
	Replaces the victim priority node with the replacement priority node in the corresponding thread priority aggregation. More...

void	_Thread_Priority_update (Thread_queue_Context *queue_context)
	Adds a priority node to the corresponding thread priority aggregation. More...

RTEMS_INLINE_ROUTINE bool	_Thread_Priority_less_than (Priority_Control left, Priority_Control right)
	Returns true if the left thread priority is less than the right thread priority in the intuitive sense of priority and false otherwise.

RTEMS_INLINE_ROUTINE Priority_Control	_Thread_Priority_highest (Priority_Control left, Priority_Control right)
	Returns the highest priority of the left and right thread priorities in the intuitive sense of priority.

RTEMS_INLINE_ROUTINE Objects_Information *	_Thread_Get_objects_information (Objects_Id id)

Thread_Control *	_Thread_Get (Objects_Id id, ISR_lock_Context *lock_context)
	Gets a thread by its identifier. More...

RTEMS_INLINE_ROUTINE Per_CPU_Control *	_Thread_Get_CPU (const Thread_Control *thread)

RTEMS_INLINE_ROUTINE void	_Thread_Set_CPU (Thread_Control thread, Per_CPU_Control cpu)

RTEMS_INLINE_ROUTINE bool	_Thread_Is_executing (const Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE bool	_Thread_Is_heir (const Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE void	_Thread_Unblock (Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE bool	_Thread_Is_allocated_fp (const Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE void	_Thread_Save_fp (Thread_Control *executing)

RTEMS_INLINE_ROUTINE void	_Thread_Restore_fp (Thread_Control *executing)

RTEMS_INLINE_ROUTINE void	_Thread_Deallocate_fp (void)

RTEMS_INLINE_ROUTINE bool	_Thread_Is_context_switch_necessary (void)

RTEMS_INLINE_ROUTINE bool	_Thread_Is_null (const Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE bool	_Thread_Is_proxy_blocking (uint32_t code)
	Is proxy blocking. More...

RTEMS_INLINE_ROUTINE uint32_t	_Thread_Get_maximum_internal_threads (void)

RTEMS_INLINE_ROUTINE Thread_Control *	_Thread_Internal_allocate (void)

RTEMS_INLINE_ROUTINE Thread_Control *	_Thread_Get_heir_and_make_it_executing (Per_CPU_Control *cpu_self)
	Gets the heir of the processor and makes it executing. More...

RTEMS_INLINE_ROUTINE void	_Thread_Update_CPU_time_used (Thread_Control the_thread, Per_CPU_Control cpu)

void	_Thread_Get_CPU_time_used (Thread_Control the_thread, Timestamp_Control cpu_time_used)

RTEMS_INLINE_ROUTINE void	_Thread_Action_control_initialize (Thread_Action_control *action_control)

RTEMS_INLINE_ROUTINE void	_Thread_Action_initialize (Thread_Action *action)

RTEMS_INLINE_ROUTINE void	_Thread_Add_post_switch_action (Thread_Control the_thread, Thread_Action action, Thread_Action_handler handler)

RTEMS_INLINE_ROUTINE bool	_Thread_Is_life_restarting (Thread_Life_state life_state)

RTEMS_INLINE_ROUTINE bool	_Thread_Is_life_terminating (Thread_Life_state life_state)

RTEMS_INLINE_ROUTINE bool	_Thread_Is_life_change_allowed (Thread_Life_state life_state)

RTEMS_INLINE_ROUTINE bool	_Thread_Is_life_changing (Thread_Life_state life_state)

RTEMS_INLINE_ROUTINE bool	_Thread_Is_joinable (const Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE void	_Thread_Resource_count_increment (Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE void	_Thread_Resource_count_decrement (Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE const Scheduler_Control *	_Thread_Scheduler_get_home (const Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE Scheduler_Node *	_Thread_Scheduler_get_home_node (const Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE Scheduler_Node *	_Thread_Scheduler_get_node_by_index (const Thread_Control *the_thread, size_t scheduler_index)

RTEMS_INLINE_ROUTINE Priority_Control	_Thread_Get_priority (const Thread_Control *the_thread)
	Returns the priority of the thread. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_acquire_default_critical (Thread_Control the_thread, ISR_lock_Context lock_context)
	Acquires the thread wait default lock inside a critical section (interrupts disabled). More...

RTEMS_INLINE_ROUTINE Thread_Control *	_Thread_Wait_acquire_default_for_executing (ISR_lock_Context *lock_context)
	Acquires the thread wait default lock and returns the executing thread. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_acquire_default (Thread_Control the_thread, ISR_lock_Context lock_context)
	Acquires the thread wait default lock and disables interrupts. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_release_default_critical (Thread_Control the_thread, ISR_lock_Context lock_context)
	Releases the thread wait default lock inside a critical section (interrupts disabled). More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_release_default (Thread_Control the_thread, ISR_lock_Context lock_context)
	Releases the thread wait default lock and restores the previous interrupt status. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_acquire_critical (Thread_Control the_thread, Thread_queue_Context queue_context)
	Acquires the thread wait lock inside a critical section (interrupts disabled). More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_acquire (Thread_Control the_thread, Thread_queue_Context queue_context)
	Acquires the thread wait default lock and disables interrupts. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_release_critical (Thread_Control the_thread, Thread_queue_Context queue_context)
	Releases the thread wait lock inside a critical section (interrupts disabled). More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_release (Thread_Control the_thread, Thread_queue_Context queue_context)
	Releases the thread wait lock and restores the previous interrupt status. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_claim (Thread_Control the_thread, Thread_queue_Queue queue)
	Claims the thread wait queue. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_claim_finalize (Thread_Control the_thread, const Thread_queue_Operations operations)
	Finalizes the thread wait queue claim via registration of the corresponding thread queue operations. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_remove_request (Thread_Control the_thread, Thread_queue_Lock_context queue_lock_context)
	Removes a thread wait lock request. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_restore_default (Thread_Control *the_thread)
	Restores the default thread wait queue and operations. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_tranquilize (Thread_Control *the_thread)
	Tranquilizes the thread after a wait on a thread queue. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_cancel (Thread_Control the_thread, Thread_queue_Context queue_context)
	Cancels a thread wait on a thread queue. More...

RTEMS_INLINE_ROUTINE void	_Thread_Wait_flags_set (Thread_Control *the_thread, Thread_Wait_flags flags)

RTEMS_INLINE_ROUTINE Thread_Wait_flags	_Thread_Wait_flags_get (const Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE Thread_Wait_flags	_Thread_Wait_flags_get_acquire (const Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE bool	_Thread_Wait_flags_try_change_release (Thread_Control *the_thread, Thread_Wait_flags expected_flags, Thread_Wait_flags desired_flags)
	Tries to change the thread wait flags with release semantics in case of success. More...

RTEMS_INLINE_ROUTINE bool	_Thread_Wait_flags_try_change_acquire (Thread_Control *the_thread, Thread_Wait_flags expected_flags, Thread_Wait_flags desired_flags)
	Tries to change the thread wait flags with acquire semantics. More...

Objects_Id	_Thread_Wait_get_id (const Thread_Control *the_thread)
	Returns the object identifier of the object containing the current thread wait queue. More...

RTEMS_INLINE_ROUTINE Status_Control	_Thread_Wait_get_status (const Thread_Control *the_thread)

void	_Thread_Continue (Thread_Control *the_thread, Status_Control status)
	Cancels a blocking operation so that the thread can continue its execution. More...

void	_Thread_Timeout (Watchdog_Control *the_watchdog)
	General purpose thread wait timeout. More...

RTEMS_INLINE_ROUTINE void	_Thread_Timer_initialize (Thread_Timer_information timer, Per_CPU_Control cpu)

RTEMS_INLINE_ROUTINE void	_Thread_Add_timeout_ticks (Thread_Control the_thread, Per_CPU_Control cpu, Watchdog_Interval ticks)

RTEMS_INLINE_ROUTINE void	_Thread_Timer_insert_realtime (Thread_Control the_thread, Per_CPU_Control cpu, Watchdog_Service_routine_entry routine, uint64_t expire)

RTEMS_INLINE_ROUTINE void	_Thread_Timer_remove (Thread_Control *the_thread)

RTEMS_INLINE_ROUTINE void	_Thread_Remove_timer_and_unblock (Thread_Control the_thread, Thread_queue_Queue queue)

Status_Control	_Thread_Set_name (Thread_Control the_thread, const char name)

size_t	_Thread_Get_name (const Thread_Control the_thread, char buffer, size_t buffer_size)

RTEMS_INLINE_ROUTINE void	_Thread_Pin (Thread_Control *executing)

RTEMS_INLINE_ROUTINE void	_Thread_Unpin (Thread_Control executing, Per_CPU_Control cpu_self)

Variables
const Thread_Control_add_on	_Thread_Control_add_ons []
	Thread control add-ons. More...

const size_t	_Thread_Control_add_on_count
	Thread control add-on count. More...

const size_t	_Thread_Initial_thread_count
	Count of configured threads. More...

const size_t	_Thread_Maximum_name_size
	Maximum size of a thread name in characters (including the terminating '\0' character). More...

Thread_Information	_Thread_Information
	The internal thread objects information.

void *	rtems_ada_self

Objects_Id	_Thread_Global_constructor
	Object identifier of the global constructor thread. More...

Thread_Control *	_Thread_Allocated_fp

Detailed Description

Constants and Structures Related with Thread Dispatch.

This handler encapsulates functionality related to the management of threads. This includes the creation, deletion, and scheduling of threads.

The following variables are maintained as part of the per cpu data structure.

Idle thread pointer
Executing thread pointer
Heir thread pointer

Macro Definition Documentation

◆ _Thread_queue_Heads_size

#define _Thread_queue_Heads_size sizeof(Thread_queue_Heads)

Size of the thread queue heads of a particular application.

In SMP configurations, this value is provided via <rtems/confdefs.h>.

◆ RTEMS_SCORE_ROBUST_THREAD_DISPATCH

#define RTEMS_SCORE_ROBUST_THREAD_DISPATCH

Enables a robust thread dispatch.

On each change of the thread dispatch disable level from one to zero the interrupt status is checked. In case interrupts are disabled and SMP is enabled or the CPU port needs it, then the system terminates with the fatal internal error INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT.

◆ THREAD_API_FIRST

#define THREAD_API_FIRST THREAD_API_RTEMS

This macro defines the first API which has threads.

◆ THREAD_API_LAST

#define THREAD_API_LAST THREAD_API_POSIX

This macro defines the last API which has threads.

◆ THREAD_INFORMATION_DEFINE

#define THREAD_INFORMATION_DEFINE	(	name,
		api,
		cls,
		max
	)

Value:

static Objects_Control * \
name##_Local_table[ _Objects_Maximum_per_allocation( max ) ]; \
static Thread_Configured_control \
name##_Objects[ _Objects_Maximum_per_allocation( max ) ]; \
static Thread_queue_Configured_heads \
name##_Heads[ _Objects_Maximum_per_allocation( max ) ]; \
Thread_Information name##_Information = { \
  { \
    _Objects_Build_id( api, cls, 1, _Objects_Maximum_per_allocation( max ) ), \
    name##_Local_table, \
    0, \
    _Objects_Is_unlimited( max ) ? _Objects_Maximum_per_allocation( max ) : 0, \
    sizeof( Thread_Configured_control ), \
    OBJECTS_NO_STRING_NAME, \
    CHAIN_INITIALIZER_EMPTY( name##_Information.Objects.Inactive ), \
    NULL, \
    NULL, \
    &name##_Objects[ 0 ].Control.Object \
    OBJECTS_INFORMATION_MP( name##_Information.Objects, NULL ) \
  }, { \
    &name##_Heads[ 0 ] \
  } \
}

◆ THREAD_INFORMATION_DEFINE_ZERO

#define THREAD_INFORMATION_DEFINE_ZERO	(	name,
		api,
		cls
	)

Value:

Thread_Information name##_Information = { \
  { \
    _Objects_Build_id( api, cls, 1, 0 ), \
    NULL, \
    0, \
    0, \
    0, \
    0, \
    CHAIN_INITIALIZER_EMPTY( name##_Information.Objects.Inactive ), \
    NULL, \
    NULL, \
    NULL \
    OBJECTS_INFORMATION_MP( name##_Information.Objects, NULL ), \
  }, { \
    NULL \
  } \
}

◆ THREAD_STATUS_PROXY_BLOCKING

#define THREAD_STATUS_PROXY_BLOCKING 0x1111111

The following structure contains the information necessary to manage a thread which it is waiting for a resource.

◆ THREAD_WAIT_STATE_INTEND_TO_BLOCK

#define THREAD_WAIT_STATE_INTEND_TO_BLOCK 0x1U

Indicates that the thread begins with the blocking operation.

A blocking operation consists of an optional watchdog initialization and the setting of the appropriate thread blocking state with the corresponding scheduler block operation.

◆ THREAD_WAIT_STATE_READY_AGAIN

#define THREAD_WAIT_STATE_READY_AGAIN 0x4U

Indicates that a condition to end the thread wait occurred.

This could be a timeout, a signal, an event or a resource availability.

Typedef Documentation

◆ Thread_Action_handler

typedef void( * Thread_Action_handler) (Thread_Control *the_thread, Thread_Action *action, ISR_lock_Context *lock_context)

Thread action handler.

The thread action handler will be called with interrupts disabled and a corresponding lock acquired, e.g. _Thread_State_acquire(). The handler must release the corresponding lock, e.g. _Thread_State_release(). So, the corresponding lock may be used to protect private data used by the particular action.

Since the action is passed to the handler additional data may be accessed via RTEMS_CONTAINER_OF().

Parameters

[in]	the_thread	The thread performing the action.
[in]	action	The thread action.
[in]	lock_context	The lock context to use for the lock release.

◆ Thread_Configured_control

typedef struct Thread_Configured_control Thread_Configured_control

The configured thread control block.

This type is defined in <rtems/confdefs.h> and depends on the application configuration.

◆ Thread_CPU_budget_algorithm_callout

typedef void(* Thread_CPU_budget_algorithm_callout) (Thread_Control *)

This defines thes the entry point for the thread specific timeslice budget management algorithm.

◆ Thread_Entry_numeric_type

typedef CPU_Uint32ptr Thread_Entry_numeric_type

Type of the numeric argument of a thread entry function with at least one numeric argument.

This numeric argument type designates an unsigned integer type with the property that any valid pointer to void can be converted to this type and then converted back to a pointer to void. The result will compare equal to the original pointer.

◆ Thread_queue_Configured_heads

typedef Thread_queue_Heads Thread_queue_Configured_heads

The configured thread queue heads.

In SMP configurations, this type is defined in <rtems/confdefs.h> and depends on the application configuration.

◆ Thread_Wait_flags

typedef unsigned int Thread_Wait_flags

This type is able to contain several flags used to control the wait class and state of a thread.

The mutually exclusive wait class flags are

The mutually exclusive wait state flags are

Enumeration Type Documentation

◆ Thread_APIs

enum Thread_APIs

The following record defines the control block used to manage each thread.

Note: It is critical that proxies and threads have identical memory images for the shared part.

Enumerator
THREAD_API_RTEMS	This value is for the Classic RTEMS API.
THREAD_API_POSIX	This value is for the POSIX API.

◆ Thread_CPU_budget_algorithms

enum Thread_CPU_budget_algorithms

The following lists the algorithms used to manage the thread cpu budget.

Reset Timeslice: At each context switch, reset the time quantum. Exhaust Timeslice: Only reset the quantum once it is consumed. Callout: Execute routine when budget is consumed.

◆ Thread_Life_state

enum Thread_Life_state

Thread life states.

The thread life states are orthogonal to the thread states used for synchronization primitives and blocking operations. They reflect the state changes triggered with thread restart and delete requests.

The individual state values must be a power of two to allow use of bit operations to manipulate and evaluate the thread life state.

Function Documentation

◆ _Thread_Clear_state()

States_Control _Thread_Clear_state	(	Thread_Control *	the_thread,
		States_Control	state
	)

Clears the specified thread state.

In case the previous state is a non-ready state and the next state is the ready state, then the thread is unblocked by the scheduler.

Parameters

[in]	the_thread	The thread.
[in]	state	The state to clear. It must not be zero.

Returns: The previous state.

◆ _Thread_Close()

void _Thread_Close	(	Thread_Control *	the_thread,
		Thread_Control *	executing,
		Thread_Close_context *	context
	)

Closes the thread.

Closes the thread object and starts the thread termination sequence. In case the executing thread is not terminated, then this function waits until the terminating thread reached the zombie state.

◆ _Thread_Continue()

void _Thread_Continue	(	Thread_Control *	the_thread,
		Status_Control	status
	)

Cancels a blocking operation so that the thread can continue its execution.

In case this function actually cancelled the blocking operation, then the thread wait return code is set to the specified status.

A specialization of this function is _Thread_Timeout().

Parameters

[in]	the_thread	The thread.
[in]	status	The thread wait status.

◆ _Thread_Create_idle()

void _Thread_Create_idle ( void )

Create idle thread.

This routine creates the idle thread.

Warning: No thread should be created before this one.

◆ _Thread_Deallocate_fp()

RTEMS_INLINE_ROUTINE void _Thread_Deallocate_fp ( void )

This routine is invoked when the currently loaded floating point context is now longer associated with an active thread.

◆ _Thread_Dispatch()

void _Thread_Dispatch ( void )

Performs a thread dispatch if necessary.

This routine is responsible for transferring control of the processor from the executing thread to the heir thread. Once the heir is running an attempt is made to run the pending post-switch thread actions.

As part of this process, it is responsible for the following actions

update timing information of the executing thread,
save the context of the executing thread,
invokation of the thread switch user extensions,
restore the context of the heir thread, and
run of pending post-switch thread actions of the resulting executing thread.

On entry the thread dispatch level must be equal to zero.

◆ _Thread_Dispatch_direct()

void _Thread_Dispatch_direct ( Per_CPU_Control * cpu_self )

Directly do a thread dispatch.

Must be called with a thread dispatch disable level of one, otherwise the INTERNAL_ERROR_BAD_THREAD_DISPATCH_DISABLE_LEVEL will occur. This function is useful for operations which synchronously block, e.g. self restart, self deletion, yield, sleep.

Parameters

[in] cpu_self The current processor.

See also: _Thread_Dispatch().

◆ _Thread_Dispatch_disable()

RTEMS_INLINE_ROUTINE Per_CPU_Control* _Thread_Dispatch_disable ( void )

Disables thread dispatching.

Returns: The current processor.

◆ _Thread_Dispatch_disable_critical()

RTEMS_INLINE_ROUTINE Per_CPU_Control* _Thread_Dispatch_disable_critical ( const ISR_lock_Context * lock_context )

Disables thread dispatching inside a critical section (interrupts disabled).

Parameters

[in] lock_context The lock context of the corresponding _ISR_lock_ISR_disable() that started the critical section.

Returns: The current processor.

◆ _Thread_Dispatch_disable_with_CPU()

RTEMS_INLINE_ROUTINE Per_CPU_Control* _Thread_Dispatch_disable_with_CPU	(	Per_CPU_Control *	cpu_self,
		const ISR_lock_Context *	lock_context
	)

Disables thread dispatching inside a critical section (interrupts disabled) with the current processor.

Parameters

[in]	cpu_self	The current processor.
[in]	lock_context	The lock context of the corresponding _ISR_lock_ISR_disable() that started the critical section.

Returns: The current processor.

◆ _Thread_Dispatch_enable()

void _Thread_Dispatch_enable ( Per_CPU_Control * cpu_self )

Enables thread dispatching.

May perform a thread dispatch if necessary as a side-effect.

Parameters

[in] cpu_self The current processor.

◆ _Thread_Dispatch_get_disable_level()

RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_get_disable_level ( void )

Gets thread dispatch disable level.

Returns: The value of the thread dispatch level.

◆ _Thread_Dispatch_initialization()

RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization ( void )

Thread dispatch initialization.

This routine initializes the thread dispatching subsystem.

◆ _Thread_Dispatch_is_enabled()

RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_is_enabled ( void )

Indicates if the executing thread is inside a thread dispatch critical section.

Return values

true	Thread dispatching is enabled.
false	The executing thread is inside a thread dispatch critical section and dispatching is not allowed.

◆ _Thread_Dispatch_request()

RTEMS_INLINE_ROUTINE void _Thread_Dispatch_request	(	Per_CPU_Control *	cpu_self,
		Per_CPU_Control *	cpu_target
	)

Requests a thread dispatch on the target processor.

Parameters

[in]	cpu_self	The current processor.
[in]	cpu_target	The target processor to request a thread dispatch.

◆ _Thread_Dispatch_unnest()

RTEMS_INLINE_ROUTINE void _Thread_Dispatch_unnest ( Per_CPU_Control * cpu_self )

Unnests thread dispatching.

Parameters

[in] cpu_self The current processor.

◆ _Thread_Do_dispatch()

void _Thread_Do_dispatch	(	Per_CPU_Control *	cpu_self,
		ISR_Level	level
	)

Performs a thread dispatch on the current processor.

On entry the thread dispatch disable level must be equal to one and interrupts must be disabled.

This function assumes that a thread dispatch is necessary.

Parameters

[in]	cpu_self	The current processor.
[in]	level	The previous interrupt level.

See also: _Thread_Dispatch().

◆ _Thread_Get()

Thread_Control* _Thread_Get	(	Objects_Id	id,
		ISR_lock_Context *	lock_context
	)

Gets a thread by its identifier.

See also: _Objects_Get().

◆ _Thread_Get_heir_and_make_it_executing()

RTEMS_INLINE_ROUTINE Thread_Control* _Thread_Get_heir_and_make_it_executing ( Per_CPU_Control * cpu_self )

Gets the heir of the processor and makes it executing.

Must be called with interrupts disabled. The thread dispatch necessary indicator is cleared as a side-effect.

Returns: The heir thread.

See also: _Thread_Dispatch(), _Thread_Start_multitasking() and _Thread_Dispatch_update_heir().

◆ _Thread_Get_priority()

RTEMS_INLINE_ROUTINE Priority_Control _Thread_Get_priority ( const Thread_Control * the_thread )

Returns the priority of the thread.

Returns the user API and thread wait information relevant thread priority. This includes temporary thread priority adjustments due to locking protocols, a job release or the POSIX sporadic server for example.

Returns: The priority of the thread.

◆ _Thread_Handler()

void _Thread_Handler ( void )

Wrapper function for all threads.

This routine is the wrapper function for all threads. It is the starting point for all threads. The user provided thread entry point is invoked by this routine. Operations which must be performed immediately before and after the user's thread executes are found here.

Note: On entry, it is assumed all interrupts are blocked and that this routine needs to set the initial isr level. This may or may not actually be needed by the context switch routine and as a result interrupts may already be at there proper level. Either way, setting the initial isr level properly here is safe.

◆ _Thread_Handler_initialization()

void _Thread_Handler_initialization ( void )

Initialize thread handler.

This routine performs the initialization necessary for this handler.

◆ _Thread_Initialize()

bool _Thread_Initialize	(	Thread_Information *	information,
		Thread_Control *	the_thread,
		const struct _Scheduler_Control *	scheduler,
		void *	stack_area,
		size_t	stack_size,
		bool	is_fp,
		Priority_Control	priority,
		bool	is_preemptible,
		Thread_CPU_budget_algorithms	budget_algorithm,
		Thread_CPU_budget_algorithm_callout	budget_callout,
		uint32_t	isr_level,
		Objects_Name	name
	)

Initialize thread.

This routine initializes the specified the thread. It allocates all memory associated with this thread. It completes by adding the thread to the local object table so operations on this thread id are allowed.

Note: If stack_area is NULL, it is allocated from the workspace.; If the stack is allocated from the workspace, then it is guaranteed to be of at least minimum size.

◆ _Thread_Is_allocated_fp()

RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control * the_thread )

This function returns true if the floating point context of the_thread is currently loaded in the floating point unit, and false otherwise.

◆ _Thread_Is_context_switch_necessary()

RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary ( void )

This function returns true if dispatching is disabled, and false otherwise.

◆ _Thread_Is_executing()

RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control * the_thread )

This function returns true if the_thread is the currently executing thread, and false otherwise.

◆ _Thread_Is_heir()

RTEMS_INLINE_ROUTINE bool _Thread_Is_heir ( const Thread_Control * the_thread )

This function returns true if the_thread is the heir thread, and false otherwise.

◆ _Thread_Is_null()

RTEMS_INLINE_ROUTINE bool _Thread_Is_null ( const Thread_Control * the_thread )

This function returns true if the_thread is NULL and false otherwise.

◆ _Thread_Is_proxy_blocking()

RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code )

Is proxy blocking.

status which indicates that a proxy is blocking, and false otherwise.

◆ _Thread_Kill_zombies()

void _Thread_Kill_zombies ( void )

Kills all zombie threads in the system.

Threads change into the zombie state as the last step in the thread termination sequence right before a context switch to the heir thread is initiated. Since the thread stack is still in use during this phase we have to postpone the thread stack reclamation until this point. On SMP configurations we may have to busy wait for context switch completion here.

◆ _Thread_Load_environment()

void _Thread_Load_environment ( Thread_Control * the_thread )

Initializes enviroment for a thread.

This routine initializes the context of the_thread to its appropriate starting state.

Parameters

[in] the_thread is the pointer to the thread control block.

◆ _Thread_Priority_add()

void _Thread_Priority_add	(	Thread_Control *	the_thread,
		Priority_Node *	priority_node,
		Thread_queue_Context *	queue_context
	)

Adds the specified thread priority node to the corresponding thread priority aggregation.

The caller must be the owner of the thread wait lock.

Parameters

the_thread	The thread.
priority_node	The thread priority node to add.
queue_context	The thread queue context to return an updated set of threads for _Thread_Priority_update(). The thread queue context must be initialized via _Thread_queue_Context_clear_priority_updates() before a call of this function.

See also: _Thread_Wait_acquire().

◆ _Thread_Priority_change()

RTEMS_INLINE_ROUTINE void _Thread_Priority_change	(	Thread_Control *	the_thread,
		Priority_Node *	priority_node,
		Priority_Control	new_priority,
		bool	prepend_it,
		Thread_queue_Context *	queue_context
	)

Changes the thread priority value of the specified thread priority node in the corresponding thread priority aggregation.

The caller must be the owner of the thread wait lock.

Parameters

the_thread	The thread.
priority_node	The thread priority node to change.
new_priority	The new thread priority value of the thread priority node to change.
prepend_it	In case this is true, then the thread is prepended to its priority group in its home scheduler instance, otherwise it is appended.
queue_context	The thread queue context to return an updated set of threads for _Thread_Priority_update(). The thread queue context must be initialized via _Thread_queue_Context_clear_priority_updates() before a call of this function.

See also: _Thread_Wait_acquire().

◆ _Thread_Priority_changed()

void _Thread_Priority_changed	(	Thread_Control *	the_thread,
		Priority_Node *	priority_node,
		bool	prepend_it,
		Thread_queue_Context *	queue_context
	)

Propagates a thread priority value change in the specified thread priority node to the corresponding thread priority aggregation.

The caller must be the owner of the thread wait lock.

Parameters

the_thread	The thread.
priority_node	The thread priority node to change.
prepend_it	In case this is true, then the thread is prepended to its priority group in its home scheduler instance, otherwise it is appended.
queue_context	The thread queue context to return an updated set of threads for _Thread_Priority_update(). The thread queue context must be initialized via _Thread_queue_Context_clear_priority_updates() before a call of this function.

See also: _Thread_Wait_acquire().

◆ _Thread_Priority_perform_actions()

void _Thread_Priority_perform_actions	(	Thread_Control *	start_of_path,
		Thread_queue_Context *	queue_context
	)

Performs the priority actions specified by the thread queue context along the thread queue path.

The caller must be the owner of the thread wait lock.

Parameters

start_of_path	The start thread of the thread queue path.
queue_context	The thread queue context specifying the thread queue path and initial thread priority actions.

See also: _Thread_queue_Path_acquire_critical().

◆ _Thread_Priority_remove()

void _Thread_Priority_remove	(	Thread_Control *	the_thread,
		Priority_Node *	priority_node,
		Thread_queue_Context *	queue_context
	)

Removes the specified thread priority node from the corresponding thread priority aggregation.

The caller must be the owner of the thread wait lock.

Parameters

the_thread	The thread.
priority_node	The thread priority node to remove.
queue_context	The thread queue context to return an updated set of threads for _Thread_Priority_update(). The thread queue context must be initialized via _Thread_queue_Context_clear_priority_updates() before a call of this function.

See also: _Thread_Wait_acquire().

◆ _Thread_Priority_replace()

void _Thread_Priority_replace	(	Thread_Control *	the_thread,
		Priority_Node *	victim_node,
		Priority_Node *	replacement_node
	)

Replaces the victim priority node with the replacement priority node in the corresponding thread priority aggregation.

The caller must be the owner of the thread wait lock.

Parameters

the_thread	The thread.
victim_node	The victim thread priority node.
replacement_node	The replacement thread priority node.

See also: _Thread_Wait_acquire().

◆ _Thread_Priority_update()

void _Thread_Priority_update ( Thread_queue_Context * queue_context )

Adds a priority node to the corresponding thread priority aggregation.

The caller must be the owner of the thread wait lock.

Parameters

the_thread	The thread.
priority_node	The thread priority node to add.
queue_context	The thread queue context to return an updated set of threads for _Thread_Priority_update(). The thread queue context must be initialized via _Thread_queue_Context_clear_priority_updates() before a call of this function.

See also: _Thread_Priority_add(), _Thread_Priority_change(), _Thread_Priority_changed() and _Thread_Priority_remove().

◆ _Thread_Set_state()

States_Control _Thread_Set_state	(	Thread_Control *	the_thread,
		States_Control	state
	)

Sets the specified thread state.

In case the previous state is the ready state, then the thread is blocked by the scheduler.

Parameters

[in]	the_thread	The thread.
[in]	state	The state to set. It must not be zero.

Returns: The previous state.

◆ _Thread_Stack_Allocate()

size_t _Thread_Stack_Allocate	(	Thread_Control *	the_thread,
		size_t	stack_size
	)

Allocate the requested stack space for the thread.

Allocate the requested stack space for the thread. Set the Start.stack field to the address of the stack.

Parameters

[in]	the_thread	is the thread where the stack space is requested
[in]	stack_size	is the stack space is requested

Return values

actual	size allocated after any adjustment
zero	if the allocation failed

◆ _Thread_Stack_Free()

void _Thread_Stack_Free ( Thread_Control * the_thread )

Deallocate thread stack.

Deallocate the Thread's stack.

◆ _Thread_Start()

bool _Thread_Start	(	Thread_Control *	the_thread,
		const Thread_Entry_information *	entry,
		ISR_lock_Context *	lock_context
	)

Initializes thread and executes it.

This routine initializes the executable information for a thread and makes it ready to execute. After this routine executes, the thread competes with all other threads for CPU time.

Parameters

the_thread	The thread to be started.
entry	The thread entry information.

◆ _Thread_Start_multitasking()

void _Thread_Start_multitasking ( void )

Start thread multitasking.

This routine initiates multitasking. It is invoked only as part of initialization and its invocation is the last act of the non-multitasking part of the system initialization.

◆ _Thread_Timeout()

void _Thread_Timeout ( Watchdog_Control * the_watchdog )

General purpose thread wait timeout.

Parameters

[in] the_watchdog The thread timer watchdog.

◆ _Thread_Unblock()

RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control * the_thread )

This routine clears any blocking state for the_thread. It performs any necessary scheduling operations including the selection of a new heir thread.

◆ _Thread_Wait_acquire()

RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire	(	Thread_Control *	the_thread,
		Thread_queue_Context *	queue_context
	)

Acquires the thread wait default lock and disables interrupts.

Parameters

[in]	the_thread	The thread.
[in]	queue_context	The thread queue context for the corresponding _Thread_Wait_release().

◆ _Thread_Wait_acquire_critical()

RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire_critical	(	Thread_Control *	the_thread,
		Thread_queue_Context *	queue_context
	)

Acquires the thread wait lock inside a critical section (interrupts disabled).

Parameters

[in]	the_thread	The thread.
[in]	queue_context	The thread queue context for the corresponding _Thread_Wait_release_critical().

◆ _Thread_Wait_acquire_default()

RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire_default	(	Thread_Control *	the_thread,
		ISR_lock_Context *	lock_context
	)

Acquires the thread wait default lock and disables interrupts.

Parameters

[in]	the_thread	The thread.
[in]	lock_context	The lock context used for the corresponding lock release.

See also: _Thread_Wait_release_default().

◆ _Thread_Wait_acquire_default_critical()

RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire_default_critical	(	Thread_Control *	the_thread,
		ISR_lock_Context *	lock_context
	)

Acquires the thread wait default lock inside a critical section (interrupts disabled).

Parameters

[in]	the_thread	The thread.
[in]	lock_context	The lock context used for the corresponding lock release.

See also: _Thread_Wait_release_default_critical().

◆ _Thread_Wait_acquire_default_for_executing()

RTEMS_INLINE_ROUTINE Thread_Control* _Thread_Wait_acquire_default_for_executing ( ISR_lock_Context * lock_context )

Acquires the thread wait default lock and returns the executing thread.

Parameters

[in] lock_context The lock context used for the corresponding lock release.

Returns: The executing thread.

See also: _Thread_Wait_release_default().

◆ _Thread_Wait_cancel()

RTEMS_INLINE_ROUTINE void _Thread_Wait_cancel	(	Thread_Control *	the_thread,
		Thread_queue_Context *	queue_context
	)

Cancels a thread wait on a thread queue.

Parameters

[in]	the_thread	The thread.
[in]	queue_context	The thread queue context used for corresponding _Thread_Wait_acquire().

◆ _Thread_Wait_claim()

RTEMS_INLINE_ROUTINE void _Thread_Wait_claim	(	Thread_Control *	the_thread,
		Thread_queue_Queue *	queue
	)

Claims the thread wait queue.

The caller must not be the owner of the default thread wait lock. The caller must be the owner of the corresponding thread queue lock. The registration of the corresponding thread queue operations is deferred and done after the deadlock detection. This is crucial to support timeouts on SMP configurations.

Parameters

[in]	the_thread	The thread.
[in]	queue	The new thread queue.

See also: _Thread_Wait_claim_finalize() and _Thread_Wait_restore_default().

◆ _Thread_Wait_claim_finalize()

RTEMS_INLINE_ROUTINE void _Thread_Wait_claim_finalize	(	Thread_Control *	the_thread,
		const Thread_queue_Operations *	operations
	)

Finalizes the thread wait queue claim via registration of the corresponding thread queue operations.

Parameters

[in]	the_thread	The thread.
[in]	operations	The corresponding thread queue operations.

◆ _Thread_Wait_flags_try_change_acquire()

RTEMS_INLINE_ROUTINE bool _Thread_Wait_flags_try_change_acquire	(	Thread_Control *	the_thread,
		Thread_Wait_flags	expected_flags,
		Thread_Wait_flags	desired_flags
	)

Tries to change the thread wait flags with acquire semantics.

In case the wait flags are equal to the expected wait flags, then the wait flags are set to the desired wait flags.

Parameters

[in]	the_thread	The thread.
[in]	expected_flags	The expected wait flags.
[in]	desired_flags	The desired wait flags.

Return values

true	The wait flags were equal to the expected wait flags.
false	Otherwise.

◆ _Thread_Wait_flags_try_change_release()

RTEMS_INLINE_ROUTINE bool _Thread_Wait_flags_try_change_release	(	Thread_Control *	the_thread,
		Thread_Wait_flags	expected_flags,
		Thread_Wait_flags	desired_flags
	)

Tries to change the thread wait flags with release semantics in case of success.

Must be called inside a critical section (interrupts disabled).

In case the wait flags are equal to the expected wait flags, then the wait flags are set to the desired wait flags.

Parameters

[in]	the_thread	The thread.
[in]	expected_flags	The expected wait flags.
[in]	desired_flags	The desired wait flags.

Return values

true	The wait flags were equal to the expected wait flags.
false	Otherwise.

◆ _Thread_Wait_get_id()

Objects_Id _Thread_Wait_get_id ( const Thread_Control * the_thread )

Returns the object identifier of the object containing the current thread wait queue.

This function may be used for debug and system information purposes. The caller must be the owner of the thread lock.

Return values

0	The thread waits on no thread queue currently, the thread wait queue is not contained in an object, or the current thread state provides insufficient information, e.g. the thread is in the middle of a blocking operation.
other	The object identifier of the object containing the thread wait queue.

◆ _Thread_Wait_release()

RTEMS_INLINE_ROUTINE void _Thread_Wait_release	(	Thread_Control *	the_thread,
		Thread_queue_Context *	queue_context
	)

Releases the thread wait lock and restores the previous interrupt status.

Parameters

[in]	the_thread	The thread.
[in]	queue_context	The thread queue context used for corresponding _Thread_Wait_acquire().

◆ _Thread_Wait_release_critical()

RTEMS_INLINE_ROUTINE void _Thread_Wait_release_critical	(	Thread_Control *	the_thread,
		Thread_queue_Context *	queue_context
	)

Releases the thread wait lock inside a critical section (interrupts disabled).

The previous interrupt status is not restored.

Parameters

[in]	the_thread	The thread.
[in]	queue_context	The thread queue context used for corresponding _Thread_Wait_acquire_critical().

◆ _Thread_Wait_release_default()

RTEMS_INLINE_ROUTINE void _Thread_Wait_release_default	(	Thread_Control *	the_thread,
		ISR_lock_Context *	lock_context
	)

Releases the thread wait default lock and restores the previous interrupt status.

Parameters

[in]	the_thread	The thread.
[in]	lock_context	The lock context used for the corresponding lock acquire.

◆ _Thread_Wait_release_default_critical()

RTEMS_INLINE_ROUTINE void _Thread_Wait_release_default_critical	(	Thread_Control *	the_thread,
		ISR_lock_Context *	lock_context
	)

Releases the thread wait default lock inside a critical section (interrupts disabled).

The previous interrupt status is not restored.

Parameters

[in]	the_thread	The thread.
[in]	lock_context	The lock context used for the corresponding lock acquire.

◆ _Thread_Wait_remove_request()

RTEMS_INLINE_ROUTINE void _Thread_Wait_remove_request	(	Thread_Control *	the_thread,
		Thread_queue_Lock_context *	queue_lock_context
	)

Removes a thread wait lock request.

On SMP configurations, removes a thread wait lock request.

On other configurations, this function does nothing.

Parameters

[in]	the_thread	The thread.
[in]	queue_lock_context	The thread queue lock context used for corresponding _Thread_Wait_acquire().

◆ _Thread_Wait_restore_default()

RTEMS_INLINE_ROUTINE void _Thread_Wait_restore_default ( Thread_Control * the_thread )

Restores the default thread wait queue and operations.

The caller must be the owner of the current thread wait queue lock.

On SMP configurations, the pending requests are updated to use the stale thread queue operations.

Parameters

[in] the_thread The thread.

See also: _Thread_Wait_claim().

◆ _Thread_Wait_tranquilize()

RTEMS_INLINE_ROUTINE void _Thread_Wait_tranquilize ( Thread_Control * the_thread )

Tranquilizes the thread after a wait on a thread queue.

After the violent blocking procedure this function makes the thread calm and peaceful again so that it can carry out its normal work.

On SMP configurations, ensures that all pending thread wait lock requests completed before the thread is able to begin a new thread wait procedure.

On other configurations, this function does nothing.

It must be called after a _Thread_Wait_claim() exactly once

after the corresponding thread queue lock was released, and
the default wait state is restored or some other processor is about to do this.

Parameters

[in] the_thread The thread.

Variable Documentation

◆ _Thread_Allocated_fp

Thread_Control* _Thread_Allocated_fp

The following points to the thread whose floating point context is currently loaded.

◆ _Thread_Control_add_on_count

const size_t _Thread_Control_add_on_count

Thread control add-on count.

Count of entries in _Thread_Control_add_ons.

This value is provided via <rtems/confdefs.h>.

◆ _Thread_Control_add_ons

const Thread_Control_add_on _Thread_Control_add_ons[]

Thread control add-ons.

The thread control block contains fields that point to application configuration dependent memory areas, like the scheduler information, the API control blocks, the user extension context table, and the Newlib re-entrancy support. Account for these areas in the configuration and avoid extra workspace allocations for these areas.

This array is provided via <rtems/confdefs.h>.

See also: _Thread_Control_add_on_count.

◆ _Thread_Global_constructor

Objects_Id _Thread_Global_constructor

Object identifier of the global constructor thread.

This variable is set by _RTEMS_tasks_Initialize_user_tasks_body() or _POSIX_Threads_Initialize_user_threads_body().

It is consumed by _Thread_Handler().

◆ _Thread_Initial_thread_count

const size_t _Thread_Initial_thread_count

Count of configured threads.

This value is provided via <rtems/confdefs.h>.

◆ _Thread_Maximum_name_size

const size_t _Thread_Maximum_name_size

Maximum size of a thread name in characters (including the terminating '\0' character).

This value is provided via <rtems/confdefs.h>.

◆ rtems_ada_self

void* rtems_ada_self

Self for the GNU Ada Run-Time

Files

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ _Thread_queue_Heads_size

◆ RTEMS_SCORE_ROBUST_THREAD_DISPATCH

◆ THREAD_API_FIRST

◆ THREAD_API_LAST

◆ THREAD_INFORMATION_DEFINE

◆ THREAD_INFORMATION_DEFINE_ZERO

◆ THREAD_STATUS_PROXY_BLOCKING

◆ THREAD_WAIT_STATE_INTEND_TO_BLOCK

◆ THREAD_WAIT_STATE_READY_AGAIN

Typedef Documentation

◆ Thread_Action_handler

◆ Thread_Configured_control

◆ Thread_CPU_budget_algorithm_callout

◆ Thread_Entry_numeric_type

◆ Thread_queue_Configured_heads

◆ Thread_Wait_flags

Enumeration Type Documentation

◆ Thread_APIs

◆ Thread_CPU_budget_algorithms

◆ Thread_Life_state

Function Documentation

◆ _Thread_Clear_state()

◆ _Thread_Close()

◆ _Thread_Continue()

◆ _Thread_Create_idle()

◆ _Thread_Deallocate_fp()

◆ _Thread_Dispatch()

◆ _Thread_Dispatch_direct()

◆ _Thread_Dispatch_disable()

◆ _Thread_Dispatch_disable_critical()

◆ _Thread_Dispatch_disable_with_CPU()

◆ _Thread_Dispatch_enable()

◆ _Thread_Dispatch_get_disable_level()

◆ _Thread_Dispatch_initialization()

◆ _Thread_Dispatch_is_enabled()

◆ _Thread_Dispatch_request()

◆ _Thread_Dispatch_unnest()

◆ _Thread_Do_dispatch()

◆ _Thread_Get()

◆ _Thread_Get_heir_and_make_it_executing()

◆ _Thread_Get_priority()

◆ _Thread_Handler()

◆ _Thread_Handler_initialization()

◆ _Thread_Initialize()

◆ _Thread_Is_allocated_fp()

◆ _Thread_Is_context_switch_necessary()

◆ _Thread_Is_executing()

◆ _Thread_Is_heir()

◆ _Thread_Is_null()

◆ _Thread_Is_proxy_blocking()

◆ _Thread_Kill_zombies()

◆ _Thread_Load_environment()

◆ _Thread_Priority_add()

◆ _Thread_Priority_change()

◆ _Thread_Priority_changed()

◆ _Thread_Priority_perform_actions()

◆ _Thread_Priority_remove()

◆ _Thread_Priority_replace()

◆ _Thread_Priority_update()

◆ _Thread_Set_state()

◆ _Thread_Stack_Allocate()

◆ _Thread_Stack_Free()

◆ _Thread_Start()

◆ _Thread_Start_multitasking()

◆ _Thread_Timeout()

◆ _Thread_Unblock()

◆ _Thread_Wait_acquire()

◆ _Thread_Wait_acquire_critical()

◆ _Thread_Wait_acquire_default()

◆ _Thread_Wait_acquire_default_critical()

◆ _Thread_Wait_acquire_default_for_executing()