Changeset 3657cde in rtems


Ignore:
Timestamp:
Apr 16, 2019, 10:40:38 AM (2 months ago)
Author:
Andreas Dachsberger <andreas.dachsberger@…>
Branches:
master
Children:
8f89dc62
Parents:
5bb6ac9
git-author:
Andreas Dachsberger <andreas.dachsberger@…> (04/16/19 10:40:38)
git-committer:
Sebastian Huber <sebastian.huber@…> (05/13/19 05:42:05)
Message:

doxygen: score: adjust doc in threadimpl.h to doxygen guidelines

Update #3706.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • cpukit/include/rtems/score/threadimpl.h

    r5bb6ac9 r3657cde  
    11/**
    22 * @file
     3 *
     4 * @ingroup RTEMSScoreThread
    35 *
    46 * @brief Inlined Routines from the Thread Handler
     
    4446/**
    4547 * @addtogroup RTEMSScoreThread
    46  */
    47 /**@{**/
     48 *
     49 * @{
     50 */
    4851
    4952/**
     
    8386typedef bool ( *Thread_Visitor )( Thread_Control *the_thread, void *arg );
    8487
     88/**
     89 * @brief Calls the visitor with all threads and the given argument until
     90 *      it is done.
     91 *
     92 * @param visitor Function that gets a thread and @a arg as parameters and
     93 *      returns if it is done.
     94 * @param arg Parameter for @a visitor
     95 */
    8596void _Thread_Iterate(
    8697  Thread_Visitor  visitor,
     
    8899);
    89100
     101/**
     102 * @brief Initializes the thread information
     103 *
     104 * @param[out] information Information to initialize.
     105 */
    90106void _Thread_Initialize_information( Thread_Information *information );
    91107
    92108/**
    93  *  @brief Initialize thread handler.
    94  *
    95  *  This routine performs the initialization necessary for this handler.
     109 * @brief Initializes thread handler.
     110 *
     111 * This routine performs the initialization necessary for this handler.
    96112 */
    97113void _Thread_Handler_initialization(void);
    98114
    99115/**
    100  *  @brief Create idle thread.
    101  *
    102  *  This routine creates the idle thread.
    103  *
    104  *  @warning No thread should be created before this one.
     116 * @brief Creates idle thread.
     117 *
     118 * This routine creates the idle thread.
     119 *
     120 * @warning No thread should be created before this one.
    105121 */
    106122void _Thread_Create_idle(void);
    107123
    108124/**
    109  *  @brief Start thread multitasking.
    110  *
    111  *  This routine initiates multitasking.  It is invoked only as
    112  *  part of initialization and its invocation is the last act of
    113  *  the non-multitasking part of the system initialization.
     125 * @brief Starts thread multitasking.
     126 *
     127 * This routine initiates multitasking.  It is invoked only as
     128 * part of initialization and its invocation is the last act of
     129 * the non-multitasking part of the system initialization.
    114130 */
    115131void _Thread_Start_multitasking( void ) RTEMS_NO_RETURN;
    116132
    117133/**
    118  *  @brief Allocate the requested stack space for the thread.
    119  *
    120  *  Allocate the requested stack space for the thread.
    121  *  Set the Start.stack field to the address of the stack.
    122  *
    123  *  @param[in] the_thread is the thread where the stack space is requested
    124  *  @param[in] stack_size is the stack space is requested
    125  *
    126  *  @retval actual size allocated after any adjustment
    127  *  @retval zero if the allocation failed
     134 * @brief Allocates the requested stack space for the thread.
     135 *
     136 * Allocate the requested stack space for the thread.
     137 * Set the Start.stack field to the address of the stack.
     138 *
     139 * @param[out] the_thread The thread where the stack space is requested.
     140 * @param stack_size The stack space that is requested.
     141 *
     142 * @retval actual Size allocated after any adjustment.
     143 * @retval zero The allocation failed.
    128144 */
    129145size_t _Thread_Stack_Allocate(
     
    133149
    134150/**
    135  *  @brief Deallocate thread stack.
    136  *
    137  *  Deallocate the Thread's stack.
     151 * @brief Deallocates thread stack.
     152 *
     153 * Deallocate the Thread's stack.
     154 *
     155 * @param[out] the_thread The thread to deallocate the stack of.
    138156 */
    139157void _Thread_Stack_Free(
     
    142160
    143161/**
    144  *  @brief Initialize thread.
    145  *
    146  *  This routine initializes the specified the thread.  It allocates
    147  *  all memory associated with this thread.  It completes by adding
    148  *  the thread to the local object table so operations on this
    149  *  thread id are allowed.
    150  *
    151  *  @note If stack_area is NULL, it is allocated from the workspace.
    152  *
    153  *  @note If the stack is allocated from the workspace, then it is
    154  *        guaranteed to be of at least minimum size.
     162 * @brief Initializes thread.
     163 *
     164 * This routine initializes the specified the thread.  It allocates
     165 * all memory associated with this thread.  It completes by adding
     166 * the thread to the local object table so operations on this
     167 * thread id are allowed.
     168 *
     169 * @note If stack_area is NULL, it is allocated from the workspace.
     170 *
     171 * @note If the stack is allocated from the workspace, then it is
     172 *       guaranteed to be of at least minimum size.
     173 *
     174 * @param information The thread information.
     175 * @param[out] the_thread The thread to initialize.
     176 * @param scheduler The scheduler control instance for the thread.
     177 * @param stack_area The starting address of the thread area.
     178 * @param stack_size The size of the thread area in bytes.
     179 * @param is_fp Indicates whether the thread needs a floating point area.
     180 * @param priority The new thread's priority.
     181 * @param is_preemptible Indicates whether the new thread is preemptible.
     182 * @param budget_algorithm The thread's budget algorithm.
     183 * @param budget_callout The thread's initial budget callout.
     184 * @param isr_level The thread's initial isr level.
     185 * @param name Name of the object for the thread.
     186 *
     187 * @retval true The thread initialization was successful.
     188 * @retval false The thread initialization failed.
    155189 */
    156190bool _Thread_Initialize(
     
    170204
    171205/**
    172  *  @brief Initializes thread and executes it.
    173  *
    174  *  This routine initializes the executable information for a thread
    175  *  and makes it ready to execute.  After this routine executes, the
    176  *  thread competes with all other threads for CPU time.
    177  *
    178  *  @param the_thread The thread to be started.
    179  *  @param entry The thread entry information.
     206 * @brief Initializes thread and executes it.
     207 *
     208 * This routine initializes the executable information for a thread
     209 * and makes it ready to execute.  After this routine executes, the
     210 * thread competes with all other threads for CPU time.
     211 *
     212 * @param the_thread The thread to be started.
     213 * @param entry The thread entry information.
    180214 */
    181215bool _Thread_Start(
     
    185219);
    186220
     221/**
     222 * @brief Restarts the currently executing thread.
     223 *
     224 * @param[in, out] executing The currently executing thread.
     225 * @param entry The start entry information for @a executing.
     226 * @param lock_context The lock context.
     227 */
    187228void _Thread_Restart_self(
    188229  Thread_Control                 *executing,
     
    191232) RTEMS_NO_RETURN;
    192233
     234/**
     235 * @brief Restarts the thread.
     236 *
     237 * @param[in, out] the_thread The thread to restart.
     238 * @param entry The start entry information for @a the_thread.
     239 * @param lock_context The lock context.
     240 *
     241 * @retval true The operation was successful.
     242 * @retval false The operation failed.
     243 */
    193244bool _Thread_Restart_other(
    194245  Thread_Control                 *the_thread,
     
    197248);
    198249
     250/**
     251 * @brief Yields the currently executing thread.
     252 *
     253 * @param[in, out] executing The thread that performs a yield.
     254 */
    199255void _Thread_Yield( Thread_Control *executing );
    200256
     257/**
     258 * @brief Changes the currently executing thread to a new state with the sets.
     259 *
     260 * @param clear States to clear.
     261 * @param set States to set.
     262 * @param ignore States to ignore.
     263 *
     264 * @return The previous state the thread was in.
     265 */
    201266Thread_Life_state _Thread_Change_life(
    202267  Thread_Life_state clear,
     
    205270);
    206271
     272/**
     273 * @brief Set the thread to life protected.
     274 *
     275 * Calls _Thread_Change_life with the given state AND THREAD_LIFE_PROTECTED to
     276 * set and THREAD_LIFE_PROTECTED to clear.
     277 *
     278 * @param state The states to set.
     279 *
     280 * @return The previous state the thread was in.
     281 */
    207282Thread_Life_state _Thread_Set_life_protection( Thread_Life_state state );
    208283
     
    218293void _Thread_Kill_zombies( void );
    219294
     295/**
     296 * @brief Exits the currently executing thread.
     297 *
     298 * @param[in, out] executing The currently executing thread.
     299 * @param set The states to set.
     300 * @param[out] exit_value Contains the exit value of the thread.
     301 */
    220302void _Thread_Exit(
    221303  Thread_Control    *executing,
     
    224306);
    225307
     308/**
     309 * @brief Joins the currently executing thread with the given thread to wait
     310 *      for.
     311 *
     312 * @param[in, out] the_thread The thread to wait for.
     313 * @param waiting_for_join The states control for the join.
     314 * @param[in, out] executing The currently executing thread.
     315 * @param queue_context The thread queue context.
     316 */
    226317void _Thread_Join(
    227318  Thread_Control       *the_thread,
     
    231322);
    232323
     324/**
     325 * @brief Cancels the thread.
     326 *
     327 * @param[in, out] the_thread The thread to cancel.
     328 * @param executing The currently executing thread.
     329 * @param exit_value The exit value for the thread.
     330 */
    233331void _Thread_Cancel(
    234332  Thread_Control *the_thread,
     
    248346 * case the executing thread is not terminated, then this function waits until
    249347 * the terminating thread reached the zombie state.
     348 *
     349 * @param the_thread The thread to close.
     350 * @param executing The currently executing thread.
     351 * @param[in, out] context The thread close context.
    250352 */
    251353void _Thread_Close(
     
    255357);
    256358
     359/**
     360 * @brief Checks if the thread is ready.
     361 *
     362 * @param the_thread The thread to check if it is ready.
     363 *
     364 * @retval true The thread is currently in the ready state.
     365 * @retval false The thread is currently not ready.
     366 */
    257367RTEMS_INLINE_ROUTINE bool _Thread_Is_ready( const Thread_Control *the_thread )
    258368{
     
    260370}
    261371
     372/**
     373 * @brief Clears the specified thread state without locking the lock context.
     374 *
     375 * In the case the previous state is a non-ready state and the next state is
     376 * the ready state, then the thread is unblocked by the scheduler.
     377 *
     378 * @param[in, out] the_thread The thread.
     379 * @param state The state to clear.  It must not be zero.
     380 *
     381 * @return The thread's previous state.
     382 */
    262383States_Control _Thread_Clear_state_locked(
    263384  Thread_Control *the_thread,
     
    268389 * @brief Clears the specified thread state.
    269390 *
    270  * In case the previous state is a non-ready state and the next state is the
    271  * ready state, then the thread is unblocked by the scheduler.
    272  *
    273  * @param[in] the_thread The thread.
    274  * @param[in] state The state to clear.  It must not be zero.
     391 * In the case the previous state is a non-ready state and the next state is
     392 * the ready state, then the thread is unblocked by the scheduler.
     393 *
     394 * @param[in, out] the_thread The thread.
     395 * @param state The state to clear.  It must not be zero.
    275396 *
    276397 * @return The previous state.
     
    281402);
    282403
     404/**
     405 * @brief Sets the specified thread state without locking the lock context.
     406 *
     407 * In the case the previous state is the ready state, then the thread is blocked
     408 * by the scheduler.
     409 *
     410 * @param[in, out] the_thread The thread.
     411 * @param state The state to set.  It must not be zero.
     412 *
     413 * @return The previous state.
     414 */
    283415States_Control _Thread_Set_state_locked(
    284416  Thread_Control *the_thread,
     
    289421 * @brief Sets the specified thread state.
    290422 *
    291  * In case the previous state is the ready state, then the thread is blocked by
    292  * the scheduler.
    293  *
    294  * @param[in] the_thread The thread.
    295  * @param[in] state The state to set.  It must not be zero.
     423 * In the case the previous state is the ready state, then the thread is blocked
     424 * by the scheduler.
     425 *
     426 * @param[in, out] the_thread The thread.
     427 * @param state The state to set.  It must not be zero.
    296428 *
    297429 * @return The previous state.
     
    303435
    304436/**
    305  *  @brief Initializes enviroment for a thread.
    306  *
    307  *  This routine initializes the context of @a the_thread to its
    308  *  appropriate starting state.
    309  *
    310  *  @param[in] the_thread is the pointer to the thread control block.
     437 * @brief Initializes enviroment for a thread.
     438 *
     439 * This routine initializes the context of @a the_thread to its
     440 * appropriate starting state.
     441 *
     442 * @param[in, out] the_thread The pointer to the thread control block.
    311443 */
    312444void _Thread_Load_environment(
     
    314446);
    315447
     448/**
     449 * @brief Calls the start kinds idle entry of the thread.
     450 *
     451 * @param executing The currently executing thread.
     452 */
    316453void _Thread_Entry_adaptor_idle( Thread_Control *executing );
    317454
     455/**
     456 * @brief Calls the start kinds numeric entry of the thread.
     457 *
     458 * @param executing The currently executing thread.
     459 */
    318460void _Thread_Entry_adaptor_numeric( Thread_Control *executing );
    319461
     462/**
     463 * @brief Calls the start kinds pointer entry of the thread.
     464 *
     465 * Stores the return value in the Wait.return_argument of the thread.
     466 *
     467 * @param executing The currently executing thread.
     468 */
    320469void _Thread_Entry_adaptor_pointer( Thread_Control *executing );
    321470
    322471/**
    323  *  @brief Wrapper function for all threads.
    324  *
    325  *  This routine is the wrapper function for all threads.  It is
    326  *  the starting point for all threads.  The user provided thread
    327  *  entry point is invoked by this routine.  Operations
    328  *  which must be performed immediately before and after the user's
    329  *  thread executes are found here.
    330  *
    331  *  @note On entry, it is assumed all interrupts are blocked and that this
    332  *  routine needs to set the initial isr level.  This may or may not
    333  *  actually be needed by the context switch routine and as a result
    334  *  interrupts may already be at there proper level.  Either way,
    335  *  setting the initial isr level properly here is safe.
     472 * @brief Wrapper function for all threads.
     473 *
     474 * This routine is the wrapper function for all threads.  It is
     475 * the starting point for all threads.  The user provided thread
     476 * entry point is invoked by this routine.  Operations
     477 * which must be performed immediately before and after the user's
     478 * thread executes are found here.
     479 *
     480 * @note On entry, it is assumed all interrupts are blocked and that this
     481 * routine needs to set the initial isr level.  This may or may not
     482 * actually be needed by the context switch routine and as a result
     483 * interrupts may already be at there proper level.  Either way,
     484 * setting the initial isr level properly here is safe.
    336485 */
    337486void _Thread_Handler( void );
    338487
     488/**
     489 * @brief Acquires the lock context in a critical section.
     490 *
     491 * @param the_thread The thread to acquire the lock context.
     492 * @param lock_context The lock context.
     493 */
    339494RTEMS_INLINE_ROUTINE void _Thread_State_acquire_critical(
    340495  Thread_Control   *the_thread,
     
    345500}
    346501
     502/**
     503 * @brief Disables interrupts and acquires the lock_context.
     504 *
     505 * @param the_thread The thread to acquire the lock context.
     506 * @param lock_context The lock context.
     507 */
    347508RTEMS_INLINE_ROUTINE void _Thread_State_acquire(
    348509  Thread_Control   *the_thread,
     
    354515}
    355516
     517/**
     518 * @brief Disables interrupts and acquires the lock context for the currently
     519 *      executing thread.
     520 *
     521 * @param lock_context The lock context.
     522 *
     523 * @return The currently executing thread.
     524 */
    356525RTEMS_INLINE_ROUTINE Thread_Control *_Thread_State_acquire_for_executing(
    357526  ISR_lock_Context *lock_context
     
    367536}
    368537
     538/**
     539 * @brief Release the lock context in a critical section.
     540 *
     541 * @param the_thread The thread to release the lock context.
     542 * @param lock_context The lock context.
     543 */
    369544RTEMS_INLINE_ROUTINE void _Thread_State_release_critical(
    370545  Thread_Control   *the_thread,
     
    375550}
    376551
     552/**
     553 * @brief Releases the lock context and enables interrupts.
     554 *
     555 * @param[in, out] the_thread The thread to release the lock context.
     556 * @param[out] lock_context The lock context.
     557 */
    377558RTEMS_INLINE_ROUTINE void _Thread_State_release(
    378559  Thread_Control   *the_thread,
     
    384565}
    385566
     567/**
     568 * @brief Checks if the thread is owner of the lock of the join queue.
     569 *
     570 * @param the_thread The thread for the verification.
     571 *
     572 * @retval true The thread is owner of the lock of the join queue.
     573 * @retval false The thread is not owner of the lock of the join queue.
     574 */
    386575#if defined(RTEMS_DEBUG)
    387576RTEMS_INLINE_ROUTINE bool _Thread_State_is_owner(
     
    459648 *
    460649 * @param the_thread The thread.
    461  * @param priority_node The thread priority node to change.
     650 * @param[out] priority_node The thread priority node to change.
    462651 * @param prepend_it In case this is true, then the thread is prepended to
    463652 *   its priority group in its home scheduler instance, otherwise it is
     
    484673 *
    485674 * @param the_thread The thread.
    486  * @param priority_node The thread priority node to change.
     675 * @param[out] priority_node The thread priority node to change.
    487676 * @param new_priority The new thread priority value of the thread priority
    488677 *   node to change.
     
    533722
    534723/**
    535  * @brief Adds a priority node to the corresponding thread priority
    536  * aggregation.
    537  *
    538  * The caller must be the owner of the thread wait lock.
    539  *
    540  * @param the_thread The thread.
    541  * @param priority_node The thread priority node to add.
     724 * @brief Updates the priority of all threads in the set
     725 *
    542726 * @param queue_context The thread queue context to return an updated set of
    543727 *   threads for _Thread_Priority_update().  The thread queue context must be
     
    550734void _Thread_Priority_update( Thread_queue_Context *queue_context );
    551735
     736/**
     737 * @brief Updates the priority of the thread and changes it sticky level.
     738 *
     739 * @param the_thread The thread.
     740 * @param sticky_level_change The new value for the sticky level.
     741 */
    552742#if defined(RTEMS_SMP)
    553743void _Thread_Priority_and_sticky_update(
     
    558748
    559749/**
    560  * @brief Returns true if the left thread priority is less than the right
    561  * thread priority in the intuitive sense of priority and false otherwise.
     750 * @brief Checks if the left thread priority is less than the right thread
     751 *      priority in the intuitive sense of priority.
     752 *
     753 * @param left The left thread priority.
     754 * @param right The right thread priority.
     755 *
     756 * @retval true The left priority is less in the intuitive sense.
     757 * @retval false The left priority is greater or equal in the intuitive sense.
    562758 */
    563759RTEMS_INLINE_ROUTINE bool _Thread_Priority_less_than(
     
    572768 * @brief Returns the highest priority of the left and right thread priorities
    573769 * in the intuitive sense of priority.
     770 *
     771 * @param left The left thread priority.
     772 * @param right The right thread priority.
     773 *
     774 * @return The highest priority in the intuitive sense of priority.
    574775 */
    575776RTEMS_INLINE_ROUTINE Priority_Control _Thread_Priority_highest(
     
    581782}
    582783
     784/**
     785 * @brief Gets object information for the object id.
     786 *
     787 * @param id The id of the object information.
     788 *
     789 * @retval pointer The object information for this id.
     790 * @retval NULL The object id is not valid.
     791 */
    583792RTEMS_INLINE_ROUTINE Objects_Information *_Thread_Get_objects_information(
    584793  Objects_Id id
     
    606815 *
    607816 * @see _Objects_Get().
     817 *
     818 * @param id The id of the thread.
     819 * @param lock_context The lock context.
    608820 */
    609821Thread_Control *_Thread_Get(
     
    612824);
    613825
     826/**
     827 * @brief Gets the cpu of the thread's scheduler.
     828 *
     829 * @param thread The thread.
     830 *
     831 * @return The cpu of the thread's scheduler.
     832 */
    614833RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Get_CPU(
    615834  const Thread_Control *thread
     
    625844}
    626845
     846/**
     847 * @brief Sets the cpu of the thread's scheduler.
     848 *
     849 * @param[out] thread The thread.
     850 * @param cpu The cpu to set.
     851 */
    627852RTEMS_INLINE_ROUTINE void _Thread_Set_CPU(
    628853  Thread_Control *thread,
     
    639864
    640865/**
     866 * @brief Checks if the thread is the currently executing thread.
     867 *
    641868 * This function returns true if the_thread is the currently executing
    642869 * thread, and false otherwise.
    643  */
    644 
     870 *
     871 * @param the_thread The thread to verify if it is the currently executing thread.
     872 *
     873 * @retval true @a the_thread is the currently executing one.
     874 * @retval false @a the_thread is not the currently executing one.
     875 */
    645876RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
    646877  const Thread_Control *the_thread
     
    652883#if defined(RTEMS_SMP)
    653884/**
    654  * @brief Returns @a true in case the thread executes currently on some
    655  * processor in the system, otherwise @a false.
     885 * @brief Checks if the thread executes currently on some processor in the
     886 * system.
    656887 *
    657888 * Do not confuse this with _Thread_Is_executing() which checks only the
    658889 * current processor.
     890 *
     891 * @param the_thread The thread for the verification.
     892 *
     893 * @retval true @a the_thread is the currently executing one.
     894 * @retval false @a the_thread is not the currently executing one.
    659895 */
    660896RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_on_a_processor(
     
    667903
    668904/**
     905 * @brief Checks if the thread is the heir.
     906 *
    669907 * This function returns true if the_thread is the heir
    670908 * thread, and false otherwise.
    671  */
    672 
     909 *
     910 * @param the_thread The thread for the verification.
     911 *
     912 * @retval true @a the_thread is the heir.
     913 * @retval false @a the_thread is not the heir.
     914 */
    673915RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
    674916  const Thread_Control *the_thread
     
    679921
    680922/**
     923 * @brief Unblocks the thread.
     924 *
    681925 * This routine clears any blocking state for the_thread.  It performs
    682926 * any necessary scheduling operations including the selection of
    683927 * a new heir thread.
    684  */
    685 
     928 *
     929 * @param[in, out] the_thread The thread to unblock.
     930 */
    686931RTEMS_INLINE_ROUTINE void _Thread_Unblock (
    687932  Thread_Control *the_thread
     
    692937
    693938/**
     939 * @brief Checks if the floating point context of the thread is currently
     940 *      loaded in the floating point unit.
     941 *
    694942 * This function returns true if the floating point context of
    695943 * the_thread is currently loaded in the floating point unit, and
    696944 * false otherwise.
    697  */
    698 
     945 *
     946 * @param the_thread The thread for the verification.
     947 *
     948 * @retval true The floating point context of @a the_thread is currently
     949 *      loaded in the floating point unit.
     950 * @retval false The floating point context of @a the_thread is currently not
     951 *      loaded in the floating point unit.
     952 */
    699953#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
    700954RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
     
    707961
    708962/*
    709  *  If the CPU has hardware floating point, then we must address saving
    710  *  and restoring it as part of the context switch.
    711  *
    712  *  The second conditional compilation section selects the algorithm used
    713  *  to context switch between floating point tasks.  The deferred algorithm
    714  *  can be significantly better in a system with few floating point tasks
    715  *  because it reduces the total number of save and restore FP context
    716  *  operations.  However, this algorithm can not be used on all CPUs due
    717  *  to unpredictable use of FP registers by some compilers for integer
    718  *  operations.
    719  */
    720 
     963 * If the CPU has hardware floating point, then we must address saving
     964 * and restoring it as part of the context switch.
     965 *
     966 * The second conditional compilation section selects the algorithm used
     967 * to context switch between floating point tasks.  The deferred algorithm
     968 * can be significantly better in a system with few floating point tasks
     969 * because it reduces the total number of save and restore FP context
     970 * operations.  However, this algorithm can not be used on all CPUs due
     971 * to unpredictable use of FP registers by some compilers for integer
     972 * operations.
     973 */
     974
     975/**
     976 * @brief Saves the executing thread's floating point area.
     977 *
     978 * @param executing The currently executing thread.
     979 */
    721980RTEMS_INLINE_ROUTINE void _Thread_Save_fp( Thread_Control *executing )
    722981{
     
    729988}
    730989
     990/**
     991 * @brief Restores the executing thread's floating point area.
     992 *
     993 * @param executing The currently executing thread.
     994 */
    731995RTEMS_INLINE_ROUTINE void _Thread_Restore_fp( Thread_Control *executing )
    732996{
     
    7481012
    7491013/**
     1014 * @brief Deallocates the currently loaded floating point context.
     1015 *
    7501016 * This routine is invoked when the currently loaded floating
    7511017 * point context is now longer associated with an active thread.
    7521018 */
    753 
    7541019#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
    7551020RTEMS_INLINE_ROUTINE void _Thread_Deallocate_fp( void )
     
    7601025
    7611026/**
     1027 * @brief Checks if dispatching is disabled.
     1028 *
    7621029 * This function returns true if dispatching is disabled, and false
    7631030 * otherwise.
    764  */
    765 
     1031 *
     1032 * @retval true Dispatching is disabled.
     1033 * @retval false Dispatching is enabled.
     1034 */
    7661035RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
    7671036{
     
    7701039
    7711040/**
    772  * This function returns true if the_thread is NULL and false otherwise.
    773  */
    774 
     1041 * @brief Checks if the thread is NULL.
     1042 *
     1043 * @param the_thread The thread for the verification.
     1044 *
     1045 * @retval true The thread is @c NULL.
     1046 * @retval false The thread is not @c NULL.
     1047 */
    7751048RTEMS_INLINE_ROUTINE bool _Thread_Is_null (
    7761049  const Thread_Control *the_thread
     
    7811054
    7821055/**
    783  * @brief Is proxy blocking.
     1056 * @brief Checks if proxy is blocking.
    7841057 *
    7851058 * status which indicates that a proxy is blocking, and false otherwise.
     1059 *
     1060 * @param code The code for the verification.
     1061 *
     1062 * @retval true Status indicates that a proxy is blocking.
     1063 * @retval false Status indicates that a proxy is not blocking.
    7861064 */
    7871065RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking (
     
    7921070}
    7931071
     1072/**
     1073 * @brief Gets the maximum number of internal threads.
     1074 *
     1075 * @return The maximum number of internal threads.
     1076 */
    7941077RTEMS_INLINE_ROUTINE uint32_t _Thread_Get_maximum_internal_threads(void)
    7951078{
     
    8081091}
    8091092
     1093/**
     1094 * @brief Allocates an internal thread and returns it.
     1095 *
     1096 * @retval pointer Pointer to the allocated Thread_Control.
     1097 * @retval NULL The operation failed.
     1098 */
    8101099RTEMS_INLINE_ROUTINE Thread_Control *_Thread_Internal_allocate( void )
    8111100{
     
    8191108 * Must be called with interrupts disabled.  The thread dispatch necessary
    8201109 * indicator is cleared as a side-effect.
     1110 *
     1111 * @param[in, out] cpu_self The processor to get the heir of.
    8211112 *
    8221113 * @return The heir thread.
     
    8381129}
    8391130
     1131/**
     1132 * @brief Updates the cpu time used of the thread.
     1133 *
     1134 * @param[in, out] the_thread The thread to add additional cpu time that is
     1135 *      used.
     1136 * @param cpu The cpu.
     1137 */
    8401138RTEMS_INLINE_ROUTINE void _Thread_Update_CPU_time_used(
    8411139  Thread_Control  *the_thread,
     
    8521150}
    8531151
     1152/**
     1153 * @brief Updates the used cpu time for the heir and dispatches a new heir.
     1154 *
     1155 * @param[in, out] cpu_self The current processor.
     1156 * @param[in, out] cpu_for_heir The processor to do a dispatch on.
     1157 * @param heir The new heir for @a cpu_for_heir.
     1158 */
    8541159#if defined( RTEMS_SMP )
    8551160RTEMS_INLINE_ROUTINE void _Thread_Dispatch_update_heir(
     
    8671172#endif
    8681173
     1174/**
     1175 * @brief Gets the used cpu time of the thread and stores it in the given
     1176 *      Timestamp_Control.
     1177 *
     1178 * @param the_thread The thread to get the used cpu time of.
     1179 * @param[out] cpu_time_used Stores the used cpu time of @a the_thread.
     1180 */
    8691181void _Thread_Get_CPU_time_used(
    8701182  Thread_Control    *the_thread,
     
    8721184);
    8731185
     1186/**
     1187 * @brief Initializes the control chain of the action control.
     1188 *
     1189 * @param[out] action_control The action control to initialize.
     1190 */
    8741191RTEMS_INLINE_ROUTINE void _Thread_Action_control_initialize(
    8751192  Thread_Action_control *action_control
     
    8791196}
    8801197
     1198/**
     1199 * @brief Initializes the Thread action.
     1200 *
     1201 * @param[out] action The Thread_Action to initialize.
     1202 */
    8811203RTEMS_INLINE_ROUTINE void _Thread_Action_initialize(
    8821204  Thread_Action *action
     
    8861208}
    8871209
     1210/**
     1211 * @brief Adds a post switch action to the thread with the given handler.
     1212 *
     1213 * @param[in, out] the_thread The thread.
     1214 * @param[in,  out] action The action to add.
     1215 * @param handler The handler for the action.
     1216 */
    8881217RTEMS_INLINE_ROUTINE void _Thread_Add_post_switch_action(
    8891218  Thread_Control        *the_thread,
     
    9081237}
    9091238
     1239/**
     1240 * @brief Checks if the thread life state is restarting.
     1241 *
     1242 * @param life_state The thread life state for the verification.
     1243 *
     1244 * @retval true @a life_state is restarting.
     1245 * @retval false @a life_state is not restarting.
     1246 */
    9101247RTEMS_INLINE_ROUTINE bool _Thread_Is_life_restarting(
    9111248  Thread_Life_state life_state
     
    9151252}
    9161253
     1254/**
     1255 * @brief Checks if the thread life state is terminating.
     1256 *
     1257 * @param life_state The thread life state for the verification.
     1258 *
     1259 * @retval true @a life_state is terminating.
     1260 * @retval false @a life_state is not terminating.
     1261 */
    9171262RTEMS_INLINE_ROUTINE bool _Thread_Is_life_terminating(
    9181263  Thread_Life_state life_state
     
    9221267}
    9231268
     1269/**
     1270 * @brief Checks if the thread life state allos life change.
     1271 *
     1272 * @param life_state The thread life state for the verification.
     1273 *
     1274 * @retval true @a life_state allows life change.
     1275 * @retval false @a life_state does not allow life change.
     1276 */
    9241277RTEMS_INLINE_ROUTINE bool _Thread_Is_life_change_allowed(
    9251278  Thread_Life_state life_state
     
    9301283}
    9311284
     1285/**
     1286 * @brief Checks if the thread life state is life changing.
     1287 *
     1288 * @param life_state The thread life state for the verification.
     1289 *
     1290 * @retval true @a life_state is life changing.
     1291 * @retval false @a life_state is not life changing.
     1292 */
    9321293RTEMS_INLINE_ROUTINE bool _Thread_Is_life_changing(
    9331294  Thread_Life_state life_state
     
    9381299}
    9391300
     1301/**
     1302 * @brief Checks if the thread is joinable.
     1303 *
     1304 * @param the_thread The thread for the verification.
     1305 *
     1306 * @retval true @a life_state is joinable.
     1307 * @retval false @a life_state is not joinable.
     1308 */
    9401309RTEMS_INLINE_ROUTINE bool _Thread_Is_joinable(
    9411310  const Thread_Control *the_thread
     
    9461315}
    9471316
     1317/**
     1318 * @brief Increments the thread's resource count.
     1319 *
     1320 * @param[in, out] the_thread The thread to increase the resource count of.
     1321 */
    9481322RTEMS_INLINE_ROUTINE void _Thread_Resource_count_increment(
    9491323  Thread_Control *the_thread
     
    9571331}
    9581332
     1333/**
     1334 * @brief Decrements the thread's resource count.
     1335 *
     1336 * @param[in, out] the_thread The thread to decrement the resource count of.
     1337 */
    9591338RTEMS_INLINE_ROUTINE void _Thread_Resource_count_decrement(
    9601339  Thread_Control *the_thread
     
    9701349#if defined(RTEMS_SCORE_THREAD_ENABLE_RESOURCE_COUNT)
    9711350/**
    972  * @brief Returns true if the thread owns resources, and false otherwise.
     1351 * @brief Checks if the thread owns resources.
    9731352 *
    9741353 * Resources are accounted with the Thread_Control::resource_count resource
    9751354 * counter.  This counter is used by mutex objects for example.
    9761355 *
    977  * @param[in] the_thread The thread.
     1356 * @param the_thread The thread.
     1357 *
     1358 * @retval true The thread owns resources.
     1359 * @retval false The thread does not own resources.
    9781360 */
    9791361RTEMS_INLINE_ROUTINE bool _Thread_Owns_resources(
     
    9861368
    9871369#if defined(RTEMS_SMP)
     1370/**
     1371 * @brief Cancels the thread's need for help.
     1372 *
     1373 * @param the_thread The thread to cancel the help request of.
     1374 * @param cpu The cpu to get the lock context of in order to
     1375 *      cancel the help request.
     1376 */
    9881377RTEMS_INLINE_ROUTINE void _Thread_Scheduler_cancel_need_for_help(
    9891378  Thread_Control  *the_thread,
     
    10041393#endif
    10051394
     1395/**
     1396 * @brief Gets the home scheduler of the thread.
     1397 *
     1398 * @param the_thread The thread to get the home scheduler of.
     1399 *
     1400 * @return The thread's home scheduler.
     1401 */
    10061402RTEMS_INLINE_ROUTINE const Scheduler_Control *_Thread_Scheduler_get_home(
    10071403  const Thread_Control *the_thread
     
    10161412}
    10171413
     1414/**
     1415 * @brief Gets the scheduler's home node.
     1416 *
     1417 * @param the_thread The thread to get the home node of.
     1418 *
     1419 * @return The thread's home node.
     1420 */
    10181421RTEMS_INLINE_ROUTINE Scheduler_Node *_Thread_Scheduler_get_home_node(
    10191422  const Thread_Control *the_thread
     
    10301433}
    10311434
     1435/**
     1436 * @brief Gets the thread's scheduler node by index.
     1437 *
     1438 * @param the_thread The thread of which to get a scheduler node.
     1439 * @param scheduler_index The index of the desired scheduler node.
     1440 *
     1441 * @return The scheduler node with the specified index.
     1442 */
    10321443RTEMS_INLINE_ROUTINE Scheduler_Node *_Thread_Scheduler_get_node_by_index(
    10331444  const Thread_Control *the_thread,
     
    10471458
    10481459#if defined(RTEMS_SMP)
     1460/**
     1461 * @brief Acquires the lock context in a critical section.
     1462 *
     1463 * @param the_thread The thread to acquire the lock context.
     1464 * @param lock_context The lock context.
     1465 */
    10491466RTEMS_INLINE_ROUTINE void _Thread_Scheduler_acquire_critical(
    10501467  Thread_Control   *the_thread,
     
    10551472}
    10561473
     1474/**
     1475 * @brief Releases the lock context in a critical section.
     1476 *
     1477 * @param the_thread The thread to release the lock context.
     1478 * @param lock_context The lock context.
     1479 */
    10571480RTEMS_INLINE_ROUTINE void _Thread_Scheduler_release_critical(
    10581481  Thread_Control   *the_thread,
     
    10631486}
    10641487
     1488/**
     1489 * @brief Process the thread's scheduler requests.
     1490 *
     1491 * @param[in, out] the_thread The thread for the operation.
     1492 */
    10651493void _Thread_Scheduler_process_requests( Thread_Control *the_thread );
    10661494
     1495/**
     1496 * @brief Add a scheduler request to the thread.
     1497 *
     1498 * @param[in, out] the_thread The thread to add a scheduler request to.
     1499 * @param[in, out] scheduler_node The scheduler node for the request.
     1500 * @param request The request to add.
     1501 */
    10671502RTEMS_INLINE_ROUTINE void _Thread_Scheduler_add_request(
    10681503  Thread_Control         *the_thread,
     
    11011536}
    11021537
     1538/**
     1539 * @brief Adds a wait node to the thread and adds a corresponding
     1540 *      request to the thread.
     1541 *
     1542 * @param[in, out] the_thread The thread to add the wait node to.
     1543 * @param scheduler_node The scheduler node which provides the wait node.
     1544 */
    11031545RTEMS_INLINE_ROUTINE void _Thread_Scheduler_add_wait_node(
    11041546  Thread_Control *the_thread,
     
    11171559}
    11181560
     1561/**
     1562 * @brief Remove a wait node from the thread and add a corresponding request to
     1563 *      it.
     1564 *
     1565 * @param the_thread The thread to add the request to remove a wait node.
     1566 * @param scheduler_node The scheduler node to remove a wait node from.
     1567 */
    11191568RTEMS_INLINE_ROUTINE void _Thread_Scheduler_remove_wait_node(
    11201569  Thread_Control *the_thread,
     
    11381587 * protocols, a job release or the POSIX sporadic server for example.
    11391588 *
     1589 * @param the_thread The thread of which to get the priority.
     1590 *
    11401591 * @return The priority of the thread.
    11411592 */
     
    11541605 * (interrupts disabled).
    11551606 *
    1156  * @param[in] the_thread The thread.
    1157  * @param[in] lock_context The lock context used for the corresponding lock
     1607 * @param[in, out] the_thread The thread.
     1608 * @param lock_context The lock context used for the corresponding lock
    11581609 *   release.
    11591610 *
     
    11721623 * thread.
    11731624 *
    1174  * @param[in] lock_context The lock context used for the corresponding lock
     1625 * @param lock_context The lock context used for the corresponding lock
    11751626 *   release.
    11761627 *
     
    11951646 * @brief Acquires the thread wait default lock and disables interrupts.
    11961647 *
    1197  * @param[in] the_thread The thread.
    1198  * @param[in] lock_context The lock context used for the corresponding lock
     1648 * @param[in, out] the_thread The thread.
     1649 * @param[out] lock_context The lock context used for the corresponding lock
    11991650 *   release.
    12001651 *
     
    12161667 * The previous interrupt status is not restored.
    12171668 *
    1218  * @param[in] the_thread The thread.
    1219  * @param[in] lock_context The lock context used for the corresponding lock
     1669 * @param[in, out] the_thread The thread.
     1670 * @param lock_context The lock context used for the corresponding lock
    12201671 *   acquire.
    12211672 */
     
    12321683 * interrupt status.
    12331684 *
    1234  * @param[in] the_thread The thread.
    1235  * @param[in] lock_context The lock context used for the corresponding lock
     1685 * @param[in, out] the_thread The thread.
     1686 * @param[out] lock_context The lock context used for the corresponding lock
    12361687 *   acquire.
    12371688 */
     
    12491700  RTEMS_CONTAINER_OF( node, Thread_queue_Context, Lock_context.Wait.Gate.Node )
    12501701
     1702/**
     1703 * @brief Removes the first pending wait lock request.
     1704 *
     1705 * @param the_thread The thread to remove the request from.
     1706 * @param queue_lock_context The queue lock context.
     1707 */
    12511708RTEMS_INLINE_ROUTINE void _Thread_Wait_remove_request_locked(
    12521709  Thread_Control            *the_thread,
     
    12641721}
    12651722
     1723/**
     1724 * @brief Acquires the wait queue inside a critical section.
     1725 *
     1726 * @param queue The queue that acquires.
     1727 * @param queue_lock_context The queue lock context.
     1728 */
    12661729RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire_queue_critical(
    12671730  Thread_queue_Queue        *queue,
     
    12761739}
    12771740
     1741/**
     1742 * @brief Releases the wait queue inside a critical section.
     1743 *
     1744 * @param queue The queue that releases.
     1745 * @param queue_lock_context The queue lock context.
     1746 */
    12781747RTEMS_INLINE_ROUTINE void _Thread_Wait_release_queue_critical(
    12791748  Thread_queue_Queue        *queue,
     
    12921761 * disabled).
    12931762 *
    1294  * @param[in] the_thread The thread.
    1295  * @param[in] queue_context The thread queue context for the corresponding
     1763 * @param[in, out] the_thread The thread.
     1764 * @param[in, out] queue_context The thread queue context for the corresponding
    12961765 *   _Thread_Wait_release_critical().
    12971766 */
     
    13481817 * @brief Acquires the thread wait default lock and disables interrupts.
    13491818 *
    1350  * @param[in] the_thread The thread.
    1351  * @param[in] queue_context The thread queue context for the corresponding
     1819 * @param[in, out] the_thread The thread.
     1820 * @param[in, out] queue_context The thread queue context for the corresponding
    13521821 *   _Thread_Wait_release().
    13531822 */
     
    13671836 * The previous interrupt status is not restored.
    13681837 *
    1369  * @param[in] the_thread The thread.
    1370  * @param[in] queue_context The thread queue context used for corresponding
     1838 * @param[in, out] the_thread The thread.
     1839 * @param[in, out] queue_context The thread queue context used for corresponding
    13711840 *   _Thread_Wait_acquire_critical().
    13721841 */
     
    14091878 * status.
    14101879 *
    1411  * @param[in] the_thread The thread.
    1412  * @param[in] queue_context The thread queue context used for corresponding
     1880 * @param[in, out] the_thread The thread.
     1881 * @param[in, out] queue_context The thread queue context used for corresponding
    14131882 *   _Thread_Wait_acquire().
    14141883 */
     
    14311900 * SMP configurations.
    14321901 *
    1433  * @param[in] the_thread The thread.
    1434  * @param[in] queue The new thread queue.
     1902 * @param[in, out] the_thread The thread.
     1903 * @param[in, out] queue The new thread queue.
    14351904 *
    14361905 * @see _Thread_Wait_claim_finalize() and _Thread_Wait_restore_default().
     
    14621931 * corresponding thread queue operations.
    14631932 *
    1464  * @param[in] the_thread The thread.
    1465  * @param[in] operations The corresponding thread queue operations.
     1933 * @param[in, out] the_thread The thread.
     1934 * @param operations The corresponding thread queue operations.
    14661935 */
    14671936RTEMS_INLINE_ROUTINE void _Thread_Wait_claim_finalize(
     
    14801949 * On other configurations, this function does nothing.
    14811950 *
    1482  * @param[in] the_thread The thread.
    1483  * @param[in] queue_lock_context The thread queue lock context used for
     1951 * @param[in, out] the_thread The thread.
     1952 * @param[in, out] queue_lock_context The thread queue lock context used for
    14841953 *   corresponding _Thread_Wait_acquire().
    14851954 */
     
    15091978 * thread queue operations.
    15101979 *
    1511  * @param[in] the_thread The thread.
     1980 * @param[in, out] the_thread The thread.
    15121981 *
    15131982 * @see _Thread_Wait_claim().
     
    15702039 *    this.
    15712040 *
    1572  * @param[in] the_thread The thread.
     2041 * @param the_thread The thread.
    15732042 */
    15742043RTEMS_INLINE_ROUTINE void _Thread_Wait_tranquilize(
     
    15862055 * @brief Cancels a thread wait on a thread queue.
    15872056 *
    1588  * @param[in] the_thread The thread.
    1589  * @param[in] queue_context The thread queue context used for corresponding
     2057 * @param[in, out] the_thread The thread.
     2058 * @param queue_context The thread queue context used for corresponding
    15902059 *   _Thread_Wait_acquire().
    15912060 */
     
    16742143#define THREAD_WAIT_CLASS_PERIOD 0x800U
    16752144
     2145/**
     2146 * @brief Sets the thread's wait flags.
     2147 *
     2148 * @param[in, out] the_thread The thread to set the wait flags of.
     2149 * @param flags The flags to set.
     2150 */
    16762151RTEMS_INLINE_ROUTINE void _Thread_Wait_flags_set(
    16772152  Thread_Control    *the_thread,
     
    16862161}
    16872162
     2163/**
     2164 * @brief Gets the thread's wait flags according to the ATOMIC_ORDER_RELAXED.
     2165 *
     2166 * @param the_thread The thread to get the wait flags of.
     2167 *
     2168 * @return The thread's wait flags.
     2169 */
    16882170RTEMS_INLINE_ROUTINE Thread_Wait_flags _Thread_Wait_flags_get(
    16892171  const Thread_Control *the_thread
     
    16972179}
    16982180
     2181/**
     2182 * @brief Gets the thread's wait flags according to the ATOMIC_ORDER_ACQUIRE.
     2183 *
     2184 * @param the_thread The thread to get the wait flags of.
     2185 *
     2186 * @return The thread's wait flags.
     2187 */
    16992188RTEMS_INLINE_ROUTINE Thread_Wait_flags _Thread_Wait_flags_get_acquire(
    17002189  const Thread_Control *the_thread
     
    17172206 * flags are set to the desired wait flags.
    17182207 *
    1719  * @param[in] the_thread The thread.
    1720  * @param[in] expected_flags The expected wait flags.
    1721  * @param[in] desired_flags The desired wait flags.
     2208 * @param the_thread The thread.
     2209 * @param expected_flags The expected wait flags.
     2210 * @param desired_flags The desired wait flags.
    17222211 *
    17232212 * @retval true The wait flags were equal to the expected wait flags.
    1724  * @retval false Otherwise.
     2213 * @retval false The wait flags were not equal to the expected wait flags.
    17252214 */
    17262215RTEMS_INLINE_ROUTINE bool _Thread_Wait_flags_try_change_release(
     
    17572246 * flags are set to the desired wait flags.
    17582247 *
    1759  * @param[in] the_thread The thread.
    1760  * @param[in] expected_flags The expected wait flags.
    1761  * @param[in] desired_flags The desired wait flags.
     2248 * @param the_thread The thread.
     2249 * @param expected_flags The expected wait flags.
     2250 * @param desired_flags The desired wait flags.
    17622251 *
    17632252 * @retval true The wait flags were equal to the expected wait flags.
    1764  * @retval false Otherwise.
     2253 * @retval false The wait flags were not equal to the expected wait flags.
    17652254 */
    17662255RTEMS_INLINE_ROUTINE bool _Thread_Wait_flags_try_change_acquire(
     
    18022291 * caller must be the owner of the thread lock.
    18032292 *
     2293 * @param the_thread The thread.
     2294 *
    18042295 * @retval 0 The thread waits on no thread queue currently, the thread wait
    18052296 *   queue is not contained in an object, or the current thread state provides
     
    18112302Objects_Id _Thread_Wait_get_id( const Thread_Control *the_thread );
    18122303
     2304/**
     2305 * @brief Get the status of the wait return code of the thread.
     2306 *
     2307 * @param the_thread The thread to get the status of the wait return code of.
     2308 */
    18132309RTEMS_INLINE_ROUTINE Status_Control _Thread_Wait_get_status(
    18142310  const Thread_Control *the_thread
     
    18272323 * A specialization of this function is _Thread_Timeout().
    18282324 *
    1829  * @param[in] the_thread The thread.
    1830  * @param[in] status The thread wait status.
     2325 * @param[in, out] the_thread The thread.
     2326 * @param status The thread wait status.
    18312327 */
    18322328void _Thread_Continue( Thread_Control *the_thread, Status_Control status );
     
    18352331 * @brief General purpose thread wait timeout.
    18362332 *
    1837  * @param[in] the_watchdog The thread timer watchdog.
     2333 * @param the_watchdog The thread timer watchdog.
    18382334 */
    18392335void _Thread_Timeout( Watchdog_Control *the_watchdog );
    18402336
     2337/**
     2338 * @brief Initializes the thread timer.
     2339 *
     2340 * @param [in, out] timer The timer to initialize.
     2341 * @param cpu The cpu for the operation.
     2342 */
    18412343RTEMS_INLINE_ROUTINE void _Thread_Timer_initialize(
    18422344  Thread_Timer_information *timer,
     
    18492351}
    18502352
     2353/**
     2354 * @brief Adds timeout ticks to the thread.
     2355 *
     2356 * @param[in, out] the_thread The thread to add the timeout ticks to.
     2357 * @param cpu The cpu for the operation.
     2358 * @param ticks The ticks to add to the timeout ticks.
     2359 */
    18512360RTEMS_INLINE_ROUTINE void _Thread_Add_timeout_ticks(
    18522361  Thread_Control    *the_thread,
     
    18672376}
    18682377
     2378/**
     2379 * @brief Inserts the cpu's watchdog realtime into the thread's timer.
     2380 *
     2381 * @param[in, out] the_thread for the operation.
     2382 * @param cpu The cpu to get the watchdog header from.
     2383 * @param routine The watchdog routine for the thread.
     2384 * @param expire Expiration for the watchdog.
     2385 */
    18692386RTEMS_INLINE_ROUTINE void _Thread_Timer_insert_realtime(
    18702387  Thread_Control                 *the_thread,
     
    18872404}
    18882405
     2406/**
     2407 * @brief Remove the watchdog timer from the thread.
     2408 *
     2409 * @param[in, out] the_thread The thread to remove the watchdog from.
     2410 */
    18892411RTEMS_INLINE_ROUTINE void _Thread_Timer_remove( Thread_Control *the_thread )
    18902412{
     
    19062428}
    19072429
     2430/**
     2431 * @brief Remove the watchdog timer from the thread and unblock if necessary.
     2432 *
     2433 * @param[in, out] the_thread The thread to remove the watchdog from and unblock
     2434 *      if necessary.
     2435 * @param queue The thread queue.
     2436 */
    19082437RTEMS_INLINE_ROUTINE void _Thread_Remove_timer_and_unblock(
    19092438  Thread_Control     *the_thread,
     
    19262455}
    19272456
     2457/**
     2458 * @brief Sets the name of the thread.
     2459 *
     2460 * @param[out] the_thread  The thread to change the name of.
     2461 * @param name The new name for the thread.
     2462 *
     2463 * @retval STATUS_SUCCESSFUL The operation succeeded.
     2464 * @retval STATUS_RESULT_TOO_LARGE The name was too long.
     2465 */
    19282466Status_Control _Thread_Set_name(
    19292467  Thread_Control *the_thread,
     
    19312469);
    19322470
     2471/**
     2472 * @brief Gets the name of the thread.
     2473 *
     2474 * @param the_thread The thread to get the name of.
     2475 * @param[out] buffer Contains the thread's name.
     2476 * @param buffer_size The size of @a buffer.
     2477 *
     2478 * @return The number of bytes copied to @a buffer.
     2479 */
    19332480size_t _Thread_Get_name(
    19342481  const Thread_Control *the_thread,
     
    19422489#define THREAD_PIN_PREEMPTION 1
    19432490
     2491/**
     2492 * @brief Unpins the thread.
     2493 *
     2494 * @param executing The currently executing thread.
     2495 * @param cpu_self The cpu for the operation.
     2496 */
    19442497void _Thread_Do_unpin(
    19452498  Thread_Control  *executing,
     
    19482501#endif
    19492502
     2503/**
     2504 * @brief Pin the executing thread.
     2505 *
     2506 * @param executing The currently executing thread.
     2507 */
    19502508RTEMS_INLINE_ROUTINE void _Thread_Pin( Thread_Control *executing )
    19512509{
     
    19592517}
    19602518
     2519/**
     2520 * @brief Unpins the thread.
     2521 *
     2522 * @param executing The currently executing thread.
     2523 * @param cpu_self The cpu for the operation.
     2524 */
    19612525RTEMS_INLINE_ROUTINE void _Thread_Unpin(
    19622526  Thread_Control  *executing,
Note: See TracChangeset for help on using the changeset viewer.