path: root/cpukit/include/rtems/rtems/tasks.h

/* SPDX-License-Identifier: BSD-2-Clause */

/**
 * @file
 *
 * @brief This header file defines the main parts of the Tasks Manager API.
 */

/*
 * Copyright (C) 2013, 2021 embedded brains GmbH (http://www.embedded-brains.de)
 * Copyright (C) 1988, 2017 On-Line Applications Research Corporation (OAR)
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * This file is part of the RTEMS quality process and was automatically
 * generated.  If you find something that needs to be fixed or
 * worded better please post a report or patch to an RTEMS mailing list
 * or raise a bug report:
 *
 * https://www.rtems.org/bugs.html
 *
 * For information on updating and regenerating please refer to the How-To
 * section in the Software Requirements Engineering chapter of the
 * RTEMS Software Engineering manual.  The manual is provided as a part of
 * a release.  For development sources please refer to the online
 * documentation at:
 *
 * https://docs.rtems.org
 */

/* Generated from spec:/rtems/task/if/header */

#ifndef _RTEMS_RTEMS_TASKS_H
#define _RTEMS_RTEMS_TASKS_H

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <sys/cpuset.h>
#include <rtems/rtems/attr.h>
#include <rtems/rtems/modes.h>
#include <rtems/rtems/status.h>
#include <rtems/rtems/types.h>
#include <rtems/score/basedefs.h>
#include <rtems/score/context.h>
#include <rtems/score/cpu.h>
#include <rtems/score/object.h>
#include <rtems/score/smp.h>
#include <rtems/score/stack.h>
#include <rtems/score/watchdogticks.h>

#ifdef __cplusplus
extern "C" {
#endif

/* Generated from spec:/rtems/scheduler/if/group */

/**
 * @defgroup RTEMSAPIClassicScheduler Scheduler Manager
 *
 * @ingroup RTEMSAPIClassic
 *
 * @brief The scheduling concepts relate to the allocation of processing time
 *   for tasks.
 *
 * The concept of scheduling in real-time systems dictates the ability to
 * provide an immediate response to specific external events, particularly the
 * necessity of scheduling tasks to run within a specified time limit after the
 * occurrence of an event. For example, software embedded in life-support
 * systems used to monitor hospital patients must take instant action if a
 * change in the patient’s status is detected.
 *
 * The component of RTEMS responsible for providing this capability is
 * appropriately called the scheduler. The scheduler’s sole purpose is to
 * allocate the all important resource of processor time to the various tasks
 * competing for attention.
 */

/* Generated from spec:/rtems/task/if/group */

/**
 * @defgroup RTEMSAPIClassicTasks Task Manager
 *
 * @ingroup RTEMSAPIClassic
 *
 * @brief The Task Manager provides a comprehensive set of directives to
 *   create, delete, and administer tasks.
 */

/* Generated from spec:/rtems/scheduler/if/add-processor */

/**
 * @ingroup RTEMSAPIClassicScheduler
 *
 * @brief Adds the processor to the set of processors owned by the scheduler
 *   instance.
 *
 * @param scheduler_id is the scheduler instance identifier.
 *
 * @param cpu_index is the index of the processor to add.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INCORRECT_STATE The processor was configured to be used by
 *   the application, however, it was not online.
 *
 * @retval ::RTEMS_INVALID_ID There was no scheduler associated with the
 *   identifier specified by ``scheduler_id``.
 *
 * @retval ::RTEMS_NOT_CONFIGURED The processor was not configured to be used
 *   by the application.
 *
 * @retval ::RTEMS_RESOURCE_IN_USE The processor was already assigned to a
 *   scheduler instance.
 *
 * @par Notes
 * This directive shall be called from task context.  It obtains and releases
 * the objects allocator lock.
 */
rtems_status_code rtems_scheduler_add_processor(
  rtems_id scheduler_id,
  uint32_t cpu_index
);

/* Generated from spec:/rtems/scheduler/if/get-maximum-priority */

/**
 * @ingroup RTEMSAPIClassicScheduler
 *
 * @brief Gets the maximum task priority of the scheduler instance.
 *
 * @param scheduler_id is the scheduler instance identifier.
 *
 * @param[out] priority is the pointer to a task priority variable.  The
 *   maximum priority of the scheduler instance will be stored in this
 *   variable, if the operation is successful.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INVALID_ADDRESS The ``priority`` parameter was NULL.
 *
 * @retval ::RTEMS_INVALID_ID There was no scheduler associated with the
 *   identifier specified by ``scheduler_id``.
 */
rtems_status_code rtems_scheduler_get_maximum_priority(
  rtems_id             scheduler_id,
  rtems_task_priority *priority
);

/* Generated from spec:/rtems/scheduler/if/get-processor */

/**
 * @ingroup RTEMSAPIClassicScheduler
 *
 * @brief Returns the index of the current processor.
 *
 * In uniprocessor configurations, this macro evaluates to a compile time
 * constant of zero.
 *
 * In SMP configurations, an architecture-specific method is used to obtain the
 * index of the current processor in the system.  The set of processor indices
 * is the range of integers starting with zero up to
 * rtems_scheduler_get_processor_maximum() minus one.
 *
 * @return The index of the current processor is returned.
 *
 * @par Notes
 * Outside of sections with disabled thread dispatching the current processor
 * index may change after every instruction since the thread may migrate from
 * one processor to another.  Sections with disabled interrupts are sections
 * with thread dispatching disabled.
 */
#define rtems_scheduler_get_processor() _SMP_Get_current_processor()

/* Generated from spec:/rtems/scheduler/if/get-processor-maximum */

/**
 * @ingroup RTEMSAPIClassicScheduler
 *
 * @brief Returns the processor maximum supported by the system.
 *
 * In uniprocessor configurations, this macro evaluates to a compile time
 * constant of one.
 *
 * In SMP configurations, this macro returns the minimum of the processors
 * (physically or virtually) available by the platform and the configured
 * processor maximum.  Not all processors in the range from processor index
 * zero to the last processor index (which is the processor maximum minus one)
 * may be configured to be used by a scheduler or may be online (online
 * processors have a scheduler assigned).
 *
 * @return The processor maximum supported by the system is returned.
 */
#define rtems_scheduler_get_processor_maximum() _SMP_Get_processor_maximum()

/* Generated from spec:/rtems/scheduler/if/get-processor-set */

/**
 * @ingroup RTEMSAPIClassicScheduler
 *
 * @brief Gets the set of processors owned by the scheduler.
 *
 * @param scheduler_id is the scheduler identifier.
 *
 * @param cpusetsize is the size of the referenced processor set variable in
 *   bytes.  This value shall be positive.
 *
 * @param[out] cpuset is the pointer to a processor set variable.  When the
 *   directive call is successful, the processor set of the scheduler will be
 *   stored in this variable.  A set bit in the processor set means that the
 *   corresponding processor is owned by the scheduler, otherwise the bit is
 *   cleared.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INVALID_ADDRESS The ``cpuset`` parameter was NULL.
 *
 * @retval ::RTEMS_INVALID_ID There was no scheduler associated with the
 *   identifier specified by ``scheduler_id``.
 *
 * @retval ::RTEMS_INVALID_NUMBER The provided processor set was too small for
 *   the set of processors owned by the scheduler.
 */
rtems_status_code rtems_scheduler_get_processor_set(
  rtems_id   scheduler_id,
  size_t     cpusetsize,
  cpu_set_t *cpuset
);

/* Generated from spec:/rtems/scheduler/if/ident */

/**
 * @ingroup RTEMSAPIClassicScheduler
 *
 * @brief Identifies a scheduler by the object name.
 *
 * @param name is the scheduler name to look up.
 *
 * @param[out] id is the pointer to an object identifier variable.  When the
 *   directive call is successful, the identifier of the scheduler instance
 *   will be stored in this variable.
 *
 * This directive obtains a scheduler identifier associated with the scheduler
 * name specified in ``name``.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INVALID_ADDRESS The ``id`` parameter was NULL.
 *
 * @retval ::RTEMS_INVALID_NAME The scheduler name was invalid.
 *
 * @par Notes
 * @parblock
 * The scheduler name is determined by the scheduler configuration.
 *
 * The scheduler identifier is used with other scheduler related directives to
 * access the scheduler.
 * @endparblock
 *
 * @par Constraints
 * @parblock
 * The following constraints apply to this directive:
 *
 * * The directive may be called from within any runtime context.
 *
 * * The directive will not cause the calling task to be preempted.
 * @endparblock
 */
rtems_status_code rtems_scheduler_ident( rtems_name name, rtems_id *id );

/* Generated from spec:/rtems/scheduler/if/ident-by-processor */

/**
 * @ingroup RTEMSAPIClassicScheduler
 *
 * @brief Identifies a scheduler instance by a processor index.
 *
 * @param cpu_index is the processor index to identify the scheduler instance.
 *
 * @param[out] id is the pointer to an object identifier variable.  When the
 *   directive call is successful, the identifier of the scheduler instance
 *   will be stored in this variable.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INCORRECT_STATE The processor index was valid, however, the
 *   corresponding processor was not owned by a scheduler instance.
 *
 * @retval ::RTEMS_INVALID_ADDRESS The ``id`` parameter was NULL.
 *
 * @retval ::RTEMS_INVALID_NAME The processor index was invalid.
 */
rtems_status_code rtems_scheduler_ident_by_processor(
  uint32_t  cpu_index,
  rtems_id *id
);

/* Generated from spec:/rtems/scheduler/if/ident-by-processor-set */

/**
 * @ingroup RTEMSAPIClassicScheduler
 *
 * @brief Identifies a scheduler by a processor set.
 *
 * @param cpusetsize is the size of the referenced processor set variable in
 *   bytes.  This value shall be positive.
 *
 * @param cpuset is the pointer to a processor set variable.  The referenced
 *   processor set will be used to identify the scheduler.
 *
 * @param[out] id is the pointer to an object identifier variable.  When the
 *   directive call is successful, the identifier of the scheduler will be
 *   stored in this variable.
 *
 * The scheduler is selected according to the highest numbered online processor
 * in the specified processor set.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INCORRECT_STATE The processor set was valid, however, the
 *   highest numbered online processor in the processor set was not owned by a
 *   scheduler.
 *
 * @retval ::RTEMS_INVALID_ADDRESS The ``id`` parameter was NULL.
 *
 * @retval ::RTEMS_INVALID_NAME The processor set contained no online
 *   processor.
 *
 * @retval ::RTEMS_INVALID_SIZE The processor set size was invalid.
 */
rtems_status_code rtems_scheduler_ident_by_processor_set(
  size_t           cpusetsize,
  const cpu_set_t *cpuset,
  rtems_id        *id
);

/* Generated from spec:/rtems/scheduler/if/map-priority-from-posix */

/**
 * @ingroup RTEMSAPIClassicScheduler
 *
 * @brief Maps a POSIX thread priority to the corresponding Classic API task
 *   priority.
 *
 * @param scheduler_id is the scheduler identifier.
 *
 * @param posix_priority is the POSIX thread priority to map.
 *
 * @param[out] priority is the pointer to a Classic API task priority variable.
 *   When the directive call is successful, the Classic API task priority value
 *   corresponding to the specified POSIX thread priority value will be stored
 *   in this variable.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INVALID_ADDRESS The ``priority`` parameter was NULL.
 *
 * @retval ::RTEMS_INVALID_ID There was no scheduler associated with the
 *   identifier specified by ``scheduler_id``.
 *
 * @retval ::RTEMS_INVALID_PRIORITY The POSIX thread priority was invalid.
 */
rtems_status_code rtems_scheduler_map_priority_from_posix(
  rtems_id             scheduler_id,
  int                  posix_priority,
  rtems_task_priority *priority
);

/* Generated from spec:/rtems/scheduler/if/map-priority-to-posix */

/**
 * @ingroup RTEMSAPIClassicScheduler
 *
 * @brief Maps a Classic API task priority to the corresponding POSIX thread
 *   priority.
 *
 * @param scheduler_id is the scheduler instance identifier.
 *
 * @param priority is the Classic API task priority to map.
 *
 * @param[out] posix_priority is the pointer to a POSIX thread priority
 *   variable.  When the directive call is successful, the POSIX thread
 *   priority value corresponding to the specified Classic API task priority
 *   value will be stored in this variable.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INVALID_ADDRESS The ``posix_priority`` parameter was NULL.
 *
 * @retval ::RTEMS_INVALID_ID There was no scheduler associated with the
 *   identifier specified by ``scheduler_id``.
 *
 * @retval ::RTEMS_INVALID_PRIORITY The Classic API task priority was invalid.
 */
rtems_status_code rtems_scheduler_map_priority_to_posix(
  rtems_id            scheduler_id,
  rtems_task_priority priority,
  int                *posix_priority
);

/* Generated from spec:/rtems/scheduler/if/remove-processor */

/**
 * @ingroup RTEMSAPIClassicScheduler
 *
 * @brief Removes a processor from set of processors owned by the scheduler
 *   instance.
 *
 * @param scheduler_id is the scheduler instance identifier.
 *
 * @param cpu_index is the index of the processor to remove.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INVALID_ID There was no scheduler associated with the
 *   identifier specified by ``scheduler_id``.
 *
 * @retval ::RTEMS_INVALID_NUMBER The processor was not owned by the specified
 *   scheduler instance.
 *
 * @retval ::RTEMS_RESOURCE_IN_USE The set of processors owned by the specified
 *   scheduler instance would have been empty after the processor removal and
 *   there was at least one non-idle task that used this scheduler instance as
 *   its home scheduler instance.
 *
 * @par Notes
 * This directive shall be called from task context.  It obtains and releases
 * the objects allocator lock.  Removing a processor from a scheduler instance
 * is a complex operation that involves all tasks of the system.
 */
rtems_status_code rtems_scheduler_remove_processor(
  rtems_id scheduler_id,
  uint32_t cpu_index
);

/* Generated from spec:/rtems/task/if/argument */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief This type is used to represent task argument values.
 *
 * @par Notes
 * The type is an architecture-specific unsigned integer type which is large
 * enough to represent pointer values and 32-bit unsigned integers.
 */
typedef CPU_Uint32ptr rtems_task_argument;

/* Generated from spec:/rtems/task/if/config */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief This structure defines the configuration of a task constructed by
 *   rtems_task_construct().
 */
typedef struct {
  /**
   * @brief This member defines the name of the task.
   */
  rtems_name name;

  /**
   * @brief This member defines the initial priority of the task.
   */
  rtems_task_priority initial_priority;

  /**
   * @brief This member shall point to the task storage area begin.
   *
   * The task storage area will contain the task stack, the thread-local storage,
   * and the floating-point context on architectures with a separate
   * floating-point context.
   *
   * The task storage area begin address and size should be aligned by
   * #RTEMS_TASK_STORAGE_ALIGNMENT.  To avoid memory waste, use RTEMS_ALIGNED()
   * and #RTEMS_TASK_STORAGE_ALIGNMENT to enforce the recommended alignment of a
   * statically allocated task storage area.
   */
  void *storage_area;

  /**
   * @brief This member defines size of the task storage area in bytes.
   *
   * Use the RTEMS_TASK_STORAGE_SIZE() macro to determine the recommended task
   * storage area size.
   */
  size_t storage_size;

  /**
   * @brief This member defines the maximum thread-local storage size supported
   *   by the task storage area.
   *
   * Use RTEMS_ALIGN_UP() and #RTEMS_TASK_STORAGE_ALIGNMENT to adjust the size to
   * meet the minimum alignment requirement of a thread-local storage area used
   * to construct a task.
   *
   * If the value is less than the actual thread-local storage size, then the
   * task construction by rtems_task_construct() fails.
   *
   * If the is less than the task storage area size, then the task construction
   * by rtems_task_construct() fails.
   *
   * The actual thread-local storage size is determined when the application
   * executable is linked.  The ``rtems-exeinfo`` command line tool included in
   * the RTEMS Tools can be used to obtain the thread-local storage size and
   * alignment of an application executable.
   *
   * The application may configure the maximum thread-local storage size for all
   * threads explicitly through the #CONFIGURE_MAXIMUM_THREAD_LOCAL_STORAGE_SIZE
   * configuration option.
   */
  size_t maximum_thread_local_storage_size;

  /**
   * @brief This member defines the optional handler to free the task storage
   *   area.
   *
   * It is called on exactly two mutually exclusive occasions.  Firstly, when the
   * task construction aborts due to a failed task create extension, or secondly,
   * when the task is deleted.  It is called from task context under protection
   * of the object allocator lock.  It is allowed to call free() in this handler.
   * If handler is NULL, then no action will be performed.
   */
  void ( *storage_free )( void * );

  /**
   * @brief This member defines the initial modes of the task.
   */
  rtems_mode initial_modes;

  /**
   * @brief This member defines the attributes of the task.
   */
  rtems_attribute attributes;
} rtems_task_config;

/* Generated from spec:/rtems/task/if/configured-minimum-stack-size */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
#define RTEMS_CONFIGURED_MINIMUM_STACK_SIZE 0

/* Generated from spec:/rtems/task/if/construct */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief Constructs a task from the specified the task configuration.
 *
 * @param config is the task configuration.
 *
 * @param[out] id is the pointer to an object identifier variable.  When the
 *   directive call is successful, the identifier of the constructed task will
 *   be stored in this variable.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INVALID_ADDRESS The ``id`` parameter was NULL.
 *
 * @retval ::RTEMS_INVALID_NAME The task name was invalid.
 *
 * @retval ::RTEMS_INVALID_PRIORITY The initial task priority was invalid.
 *
 * @retval ::RTEMS_INVALID_SIZE The thread-local storage size is greater than
 *   the maximum thread-local storage size specified in the task configuration.
 *   The thread-local storage size is determined by the thread-local variables
 *   used by the application and #CONFIGURE_MAXIMUM_THREAD_LOCAL_STORAGE_SIZE.
 *
 * @retval ::RTEMS_INVALID_SIZE The task storage area was too small to provide
 *   a task stack of the configured minimum size, see
 *   #CONFIGURE_MINIMUM_TASK_STACK_SIZE. The task storage area contains the
 *   task stack, the thread-local storage, and the floating-point context on
 *   architectures with a separate floating-point context.
 *
 * @retval ::RTEMS_TOO_MANY There was no inactive task object available to
 *   construct a task.
 *
 * @retval ::RTEMS_TOO_MANY In multiprocessing configurations, there was no
 *   inactive global object available to construct a global task.
 *
 * @retval ::RTEMS_UNSATISFIED One of the task create extensions failed during
 *   the task construction.
 *
 * @retval ::RTEMS_UNSATISFIED In SMP configurations, the non-preemption mode
 *   was not supported.
 *
 * @retval ::RTEMS_UNSATISFIED In SMP configurations, the interrupt level mode
 *   was not supported.
 *
 * @par Notes
 * @parblock
 * In contrast to tasks created by rtems_task_create(), the tasks constructed
 * by this directive use a user-provided task storage area.  The task storage
 * area contains the task stack, the thread-local storage, and the
 * floating-point context on architectures with a separate floating-point
 * context.
 *
 * This directive is intended for applications which do not want to use the
 * RTEMS Workspace and instead statically allocate all operating system
 * resources.  It is not recommended to use rtems_task_create() and
 * rtems_task_construct() together in an application.  It is also not
 * recommended to use rtems_task_construct() for drivers or general purpose
 * libraries.  The reason for these recommendations is that the task
 * configuration needs settings which can be only given with a through
 * knowledge of the application resources.
 *
 * An application based solely on static allocation can avoid any runtime
 * memory allocators.  This can simplify the application architecture as well
 * as any analysis that may be required.
 *
 * The stack space estimate done by <rtems/confdefs.h> assumes that all tasks
 * are created by rtems_task_create().  The estimate can be adjusted to take
 * user-provided task storage areas into account through the
 * #CONFIGURE_MINIMUM_TASKS_WITH_USER_PROVIDED_STORAGE application
 * configuration option.
 *
 * The #CONFIGURE_MAXIMUM_TASKS should include tasks constructed by
 * rtems_task_construct().
 * @endparblock
 *
 * @par Constraints
 * @parblock
 * The following constraints apply to this directive:
 *
 * * The directive may be called from within device driver initialization
 *   context.
 *
 * * The directive may be called from within task context.
 *
 * * The directive may obtain and release the object allocator mutex.  This may
 *   cause the calling task to be preempted.
 *
 * * When the directive operates on a global object, the directive sends a
 *   message to remote nodes.  This may preempt the calling task.
 *
 * * The number of tasks available to the application is configured through the
 *   #CONFIGURE_MAXIMUM_TASKS application configuration option.
 *
 * * Where the object class corresponding to the directive is configured to use
 *   unlimited objects, the directive may allocate memory from the RTEMS
 *   Workspace.
 *
 * * The number of global objects available to the application is configured
 *   through the #CONFIGURE_MP_MAXIMUM_GLOBAL_OBJECTS application configuration
 *   option.
 * @endparblock
 */
rtems_status_code rtems_task_construct(
  const rtems_task_config *config,
  rtems_id                *id
);

/* Generated from spec:/rtems/task/if/create */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief Creates a task.
 *
 * @param name is the object name of the task.
 *
 * @param initial_priority is the initial task priority.
 *
 * @param stack_size is the task stack size in bytes.
 *
 * @param initial_modes is the initial mode set of the task.
 *
 * @param attribute_set is the attribute set of the task.
 *
 * @param[out] id is the pointer to an object identifier variable.  When the
 *   directive call is successful, the identifier of the created task will be
 *   stored in this variable.
 *
 * This directive creates a task which resides on the local node.  The task has
 * the user-defined object name specified in ``name``.  The assigned object
 * identifier is returned in ``id``.  This identifier is used to access the
 * task with other task related directives.
 *
 * The **initial priority** of the task is specified in ``initial_priority``.
 * The scheduler of the created task is the scheduler of the calling task at
 * some point during the task creation.  The initial task priority specified in
 * ``initial_priority`` shall be valid for this scheduler.
 *
 * The **stack size** of the task is specified in ``stack_size``.  If the
 * requested stack size is less than the configured minimum stack size, then
 * RTEMS will use the configured minimum as the stack size for this task.  The
 * configured minimum stack size is defined by the
 * #CONFIGURE_MINIMUM_TASK_STACK_SIZE application configuration option.  In
 * addition to being able to specify the task stack size as a integer, there
 * are two constants which may be specified:
 *
 * * The #RTEMS_MINIMUM_STACK_SIZE constant can be specified to use the
 *   **recommended minimum stack size** for the target processor.  This value
 *   is selected by the RTEMS maintainers conservatively to minimize the risk
 *   of blown stacks for most user applications.  Using this constant when
 *   specifying the task stack size, indicates that the stack size will be at
 *   least #RTEMS_MINIMUM_STACK_SIZE bytes in size.  If the user configured
 *   minimum stack size is larger than the recommended minimum, then it will be
 *   used.
 *
 * * The #RTEMS_CONFIGURED_MINIMUM_STACK_SIZE constant can be specified to use
 *   the minimum stack size that was configured by the application.  If not
 *   explicitly configured by the application, the default configured minimum
 *   stack size is the target processor dependent value
 *   #RTEMS_MINIMUM_STACK_SIZE.  Since this uses the configured minimum stack
 *   size value, you may get a stack size that is smaller or larger than the
 *   recommended minimum.  This can be used to provide large stacks for all
 *   tasks on complex applications or small stacks on applications that are
 *   trying to conserve memory.
 *
 * The **initial mode set** specified in ``initial_modes`` is built through a
 * *bitwise or* of the mode constants described below.  Not all combinations of
 * modes are allowed.  Some modes are mutually exclusive.  If mutually
 * exclusive modes are combined, the behaviour is undefined.  Default task
 * modes can be selected by using the #RTEMS_DEFAULT_MODES constant.  The task
 * mode set defines
 *
 * * the preemption mode of the task: #RTEMS_PREEMPT (default) or
 *   #RTEMS_NO_PREEMPT,
 *
 * * the timeslicing mode of the task: #RTEMS_TIMESLICE or #RTEMS_NO_TIMESLICE
 *   (default),
 *
 * * the ASR processing mode of the task: #RTEMS_ASR (default) or
 *   #RTEMS_NO_ASR,
 *
 * * the interrupt level of the task: RTEMS_INTERRUPT_LEVEL() with a default of
 *   ``RTEMS_INTERRUPT_LEVEL( 0 )`` which is associated with enabled
 *   interrupts.
 *
 * The **initial preemption mode** of the task is enabled or disabled.
 *
 * * An **enabled preemption** is the default and can be emphasized through the
 *   use of the #RTEMS_PREEMPT mode constant.
 *
 * * A **disabled preemption** is set by the #RTEMS_NO_PREEMPT mode constant.
 *
 * The **initial timeslicing mode** of the task is enabled or disabled.
 *
 * * A **disabled timeslicing** is the default and can be emphasized through
 *   the use of the #RTEMS_NO_TIMESLICE mode constant.
 *
 * * An **enabled timeslicing** is set by the #RTEMS_TIMESLICE mode constant.
 *
 * The **initial ASR processing mode** of the task is enabled or disabled.
 *
 * * An **enabled ASR processing** is the default and can be emphasized through
 *   the use of the #RTEMS_ASR mode constant.
 *
 * * A **disabled ASR processing** is set by the #RTEMS_NO_ASR mode constant.
 *
 * The **initial interrupt level mode** of the task is defined by
 * RTEMS_INTERRUPT_LEVEL().
 *
 * * Task execution with **interrupts enabled** the default and can be
 *   emphasized through the use of the RTEMS_INTERRUPT_LEVEL() mode macro with
 *   a value of zero (0) for the parameter.  An interrupt level of zero is
 *   associated with enabled interrupts on all target processors.
 *
 * * Task execution at a **non-zero interrupt level** can be specified by the
 *   RTEMS_INTERRUPT_LEVEL() mode macro with a non-zero value for the
 *   parameter.  The interrupt level portion of the task mode supports a
 *   maximum of 256 interrupt levels.  These levels are mapped onto the
 *   interrupt levels actually supported by the target processor in a processor
 *   dependent fashion.
 *
 * The **attribute set** specified in ``attribute_set`` is built through a
 * *bitwise or* of the attribute constants described below.  Not all
 * combinations of attributes are allowed.  Some attributes are mutually
 * exclusive.  If mutually exclusive attributes are combined, the behaviour is
 * undefined.  Attributes not mentioned below are not evaluated by this
 * directive and have no effect.  Default attributes can be selected by using
 * the #RTEMS_DEFAULT_ATTRIBUTES constant.  The attribute set defines
 *
 * * the scope of the task: #RTEMS_LOCAL (default) or #RTEMS_GLOBAL and
 *
 * * the floating-point unit use of the task: #RTEMS_FLOATING_POINT or
 *   #RTEMS_NO_FLOATING_POINT (default).
 *
 * The task has a local or global **scope** in a multiprocessing network (this
 * attribute does not refer to SMP systems).  The scope is selected by the
 * mutually exclusive #RTEMS_LOCAL and #RTEMS_GLOBAL attributes.
 *
 * * A **local scope** is the default and can be emphasized through the use of
 *   the #RTEMS_LOCAL attribute.  A local task can be only used by the node
 *   which created it.
 *
 * * A **global scope** is established if the #RTEMS_GLOBAL attribute is set.
 *   Setting the global attribute in a single node system has no effect.the
 *
 * The **use of the floating-point unit** is selected by the mutually exclusive
 * #RTEMS_FLOATING_POINT and #RTEMS_NO_FLOATING_POINT attributes.  On some
 * target processors, the use of the floating-point unit can be enabled or
 * disabled for each task.  Other target processors may have no hardware
 * floating-point unit or enable the use of the floating-point unit for all
 * tasks.  Consult the *RTEMS CPU Architecture Supplement* for the details.
 *
 * * A **disabled floating-point unit** is the default and can be emphasized
 *   through use of the #RTEMS_NO_FLOATING_POINT attribute.  For performance
 *   reasons, it is recommended that tasks not using the floating-point unit
 *   should specify this attribute.
 *
 * * An **enabled floating-point unit** is selected by the
 *   #RTEMS_FLOATING_POINT attribute.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INVALID_NAME The ``name`` parameter was invalid.
 *
 * @retval ::RTEMS_INVALID_ADDRESS The ``id`` parameter was NULL.
 *
 * @retval ::RTEMS_INVALID_PRIORITY The ``initial_priority`` was invalid.
 *
 * @retval ::RTEMS_TOO_MANY There was no inactive object available to create a
 *   task.  The number of tasks available to the application is configured
 *   through the #CONFIGURE_MAXIMUM_TASKS application configuration option.
 *
 * @retval ::RTEMS_TOO_MANY In multiprocessing configurations, there was no
 *   inactive global object available to create a global task.  The number of
 *   global objects available to the application is configured through the
 *   #CONFIGURE_MP_MAXIMUM_GLOBAL_OBJECTS application configuration option.
 *
 * @retval ::RTEMS_UNSATISFIED There was not enough memory to allocate the task
 *   storage area.  The task storage area contains the task stack, the
 *   thread-local storage, and the floating point context.
 *
 * @retval ::RTEMS_UNSATISFIED One of the task create extensions failed to
 *   create the task.
 *
 * @retval ::RTEMS_UNSATISFIED In SMP configurations, the non-preemption mode
 *   was not supported.
 *
 * @retval ::RTEMS_UNSATISFIED In SMP configurations, the interrupt level mode
 *   was not supported.
 *
 * @par Notes
 * @parblock
 * The task processor affinity is initialized to the set of online processors.
 *
 * When created, a task is placed in the dormant state and can only be made
 * ready to execute using the directive rtems_task_start().
 *
 * Application developers should consider the stack usage of the device drivers
 * when calculating the stack size required for tasks which utilize the driver.
 * The task stack size shall account for an target processor dependent
 * interrupt stack frame which may be placed on the stack of the interrupted
 * task while servicing an interrupt.  The stack checker may be used to monitor
 * the stack usage, see #CONFIGURE_STACK_CHECKER_ENABLED.
 *
 * For control and maintenance of the task, RTEMS allocates a TCB from the
 * local TCB free pool and initializes it.
 *
 * The TCB for a global task is allocated on the local node.  Task should not
 * be made global unless remote tasks must interact with the task.  This is to
 * avoid the system overhead incurred by the creation of a global task.  When a
 * global task is created, the task's name and identifier must be transmitted
 * to every node in the system for insertion in the local copy of the global
 * object table.
 * @endparblock
 *
 * @par Constraints
 * @parblock
 * The following constraints apply to this directive:
 *
 * * The directive may be called from within device driver initialization
 *   context.
 *
 * * The directive may be called from within task context.
 *
 * * The directive may obtain and release the object allocator mutex.  This may
 *   cause the calling task to be preempted.
 *
 * * When the directive operates on a global object, the directive sends a
 *   message to remote nodes.  This may preempt the calling task.
 *
 * * The number of tasks available to the application is configured through the
 *   #CONFIGURE_MAXIMUM_TASKS application configuration option.
 *
 * * Where the object class corresponding to the directive is configured to use
 *   unlimited objects, the directive may allocate memory from the RTEMS
 *   Workspace.
 *
 * * The number of global objects available to the application is configured
 *   through the #CONFIGURE_MP_MAXIMUM_GLOBAL_OBJECTS application configuration
 *   option.
 * @endparblock
 */
rtems_status_code rtems_task_create(
  rtems_name          name,
  rtems_task_priority initial_priority,
  size_t              stack_size,
  rtems_mode          initial_modes,
  rtems_attribute     attribute_set,
  rtems_id           *id
);

/* Generated from spec:/rtems/task/if/current-priority */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief This constant is passed to {set-priority:/name}() when the caller
 *   wants to obtain the current priority.
 */
#define RTEMS_CURRENT_PRIORITY 0

/* Generated from spec:/rtems/task/if/delete */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief Deletes the task.
 *
 * @param id is the task identifier.
 *
 * This directive deletes the task, either the calling task or another task, as
 * specified by ``id``.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INVALID_ID There was no task associated with the identifier
 *   specified by ``id``.
 *
 * @retval ::RTEMS_ILLEGAL_ON_REMOTE_OBJECT The task resided on a remote node.
 *
 * @par Notes
 * @parblock
 * RTEMS stops the execution of the task and reclaims the stack memory, any
 * allocated delay or timeout timers, the TCB, and, if the task is
 * #RTEMS_FLOATING_POINT, its floating point context area. RTEMS explicitly
 * does not reclaim the following resources: region segments, partition
 * buffers, semaphores, timers, or rate monotonic periods.
 *
 * A task is responsible for releasing its resources back to RTEMS before
 * deletion.  To insure proper deallocation of resources, a task should not be
 * deleted unless it is unable to execute or does not hold any RTEMS resources.
 * If a task holds RTEMS resources, the task should be allowed to deallocate
 * its resources before deletion.  A task can be directed to release its
 * resources and delete itself by restarting it with a special argument or by
 * sending it a message, an event, or a signal.
 *
 * Deletion of the current task (#RTEMS_SELF) will force RTEMS to select
 * another task to execute.
 *
 * The TCB for the deleted task is reclaimed by RTEMS.
 *
 * When a global task is deleted, the task identifier must be transmitted to
 * every node in the system for deletion from the local copy of the global
 * object table.
 *
 * The task must reside on the local node, even if the task was created with
 * the #RTEMS_GLOBAL attribute.
 * @endparblock
 *
 * @par Constraints
 * @parblock
 * The following constraints apply to this directive:
 *
 * * The directive may be called from within device driver initialization
 *   context.
 *
 * * The directive may be called from within task context.
 *
 * * The directive may obtain and release the object allocator mutex.  This may
 *   cause the calling task to be preempted.
 *
 * * When the directive operates on a global object, the directive sends a
 *   message to remote nodes.  This may preempt the calling task.
 *
 * * The calling task does not have to be the task that created the object.
 *   Any local task that knows the object identifier can delete the object.
 *
 * * Where the object class corresponding to the directive is configured to use
 *   unlimited objects, the directive may free memory to the RTEMS Workspace.
 * @endparblock
 */
rtems_status_code rtems_task_delete( rtems_id id );

/* Generated from spec:/rtems/task/if/task */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
typedef void rtems_task;

/* Generated from spec:/rtems/task/if/entry */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief This type defines the entry point of an RTEMS task.
 */
typedef rtems_task ( *rtems_task_entry )( rtems_task_argument );

/* Generated from spec:/rtems/task/if/exit */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
RTEMS_NO_RETURN void rtems_task_exit( void );

/* Generated from spec:/rtems/task/if/get-affinity */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param id %
 *
 * @param cpusetsize %
 *
 * @param cpuset %
 */
rtems_status_code rtems_task_get_affinity(
  rtems_id   id,
  size_t     cpusetsize,
  cpu_set_t *cpuset
);

/* Generated from spec:/rtems/task/if/get-priority */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param task_id %
 *
 * @param scheduler_id %
 *
 * @param priority %
 */
rtems_status_code rtems_task_get_priority(
  rtems_id             task_id,
  rtems_id             scheduler_id,
  rtems_task_priority *priority
);

/* Generated from spec:/rtems/task/if/get-scheduler */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param task_id %
 *
 * @param scheduler_id %
 */
rtems_status_code rtems_task_get_scheduler(
  rtems_id  task_id,
  rtems_id *scheduler_id
);

/* Generated from spec:/rtems/task/if/ident */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief Identifies a task by the object name.
 *
 * @param name is the object name to look up.
 *
 * @param node is the node or node set to search for a matching object.
 *
 * @param[out] id is the pointer to an object identifier variable.  When the
 *   directive call is successful, the object identifier of an object with the
 *   specified name will be stored in this variable.
 *
 * This directive obtains a task identifier associated with the task name
 * specified in ``name``.
 *
 * A task may obtain its own identifier by specifying #RTEMS_SELF for the name.
 *
 * The node to search is specified in ``node``.  It shall be
 *
 * * a valid node number,
 *
 * * the constant #RTEMS_SEARCH_ALL_NODES to search in all nodes,
 *
 * * the constant #RTEMS_SEARCH_LOCAL_NODE to search in the local node only, or
 *
 * * the constant #RTEMS_SEARCH_OTHER_NODES to search in all nodes except the
 *   local node.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_INVALID_ADDRESS The ``id`` parameter was NULL.
 *
 * @retval ::RTEMS_INVALID_NAME There was no object with the specified name on
 *   the specified nodes.
 *
 * @retval ::RTEMS_INVALID_NODE In multiprocessing configurations, the
 *   specified node was invalid.
 *
 * @par Notes
 * @parblock
 * If the task name is not unique, then the task identifier will match the
 * first task with that name in the search order.  However, this task
 * identifier is not guaranteed to correspond to the desired task.
 *
 * The objects are searched from lowest to the highest index.  If ``node`` is
 * #RTEMS_SEARCH_ALL_NODES, all nodes are searched with the local node being
 * searched first.  All other nodes are searched from lowest to the highest
 * node number.
 *
 * If node is a valid node number which does not represent the local node, then
 * only the tasks exported by the designated node are searched.
 *
 * This directive does not generate activity on remote nodes.  It accesses only
 * the local copy of the global object table.
 *
 * The task identifier is used with other task related directives to access the
 * task.
 * @endparblock
 *
 * @par Constraints
 * @parblock
 * The following constraints apply to this directive:
 *
 * * The directive may be called from within any runtime context.
 *
 * * The directive will not cause the calling task to be preempted.
 * @endparblock
 */
rtems_status_code rtems_task_ident(
  rtems_name name,
  uint32_t   node,
  rtems_id  *id
);

/* Generated from spec:/rtems/task/if/initialization-table */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
typedef struct {
  /**
   * @brief %
   *
   * %
   */
  rtems_name name;

  /**
   * @brief %
   *
   * %
   */
  size_t stack_size;

  /**
   * @brief %
   *
   * %
   */
  rtems_task_priority initial_priority;

  /**
   * @brief %
   *
   * %
   */
  rtems_attribute attribute_set;

  /**
   * @brief %
   *
   * %
   */
  rtems_task_entry entry_point;

  /**
   * @brief %
   *
   * %
   */
  rtems_mode mode_set;

  /**
   * @brief %
   *
   * %
   */
  rtems_task_argument argument;
} rtems_initialization_tasks_table;

/* Generated from spec:/rtems/task/if/is-suspended */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param id %
 */
rtems_status_code rtems_task_is_suspended( rtems_id id );

/* Generated from spec:/rtems/task/if/minimum-priority */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
#define RTEMS_MINIMUM_PRIORITY 1

/* Generated from spec:/rtems/task/if/minimum-stack-size */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
#define RTEMS_MINIMUM_STACK_SIZE STACK_MINIMUM_SIZE

/* Generated from spec:/rtems/task/if/mode */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief Gets and optionally sets the mode of the calling task.
 *
 * @param mode_set is the mode set to apply to the calling task.  When ``mask``
 *   is set to #RTEMS_CURRENT_MODE, the value of this parameter is ignored.
 *   Only modes requested by ``mask`` are applied to the calling task.
 *
 * @param mask is the mode mask which specifies which modes in ``mode_set`` are
 *   applied to the calling task.  When the value is #RTEMS_CURRENT_MODE, the
 *   mode of the calling task is not changed.
 *
 * @param previous_mode_set is the pointer to a mode variable.  When the
 *   directive call is successful, the mode of the task before any mode changes
 *   done by the directive call will be stored in this variable.
 *
 * This directive queries and optionally manipulates the execution mode of the
 * calling task.  A task's execution mode enables and disables preemption,
 * timeslicing, asynchronous signal processing, as well as specifying the
 * interrupt level.  To modify an execution mode, the mode class(es) to be
 * changed must be specified in the ``mask`` parameter and the desired mode(s)
 * must be specified in the ``mode_set`` parameter.
 *
 * A task can obtain its current execution mode, without modifying it, by
 * calling this directive with a ``mask`` value of #RTEMS_CURRENT_MODE.
 *
 * The **mode set** specified in ``mode_set`` is built through a *bitwise or*
 * of the mode constants described below.  Not all combinations of modes are
 * allowed.  Some modes are mutually exclusive.  If mutually exclusive modes
 * are combined, the behaviour is undefined.  Default task modes can be
 * selected by using the #RTEMS_DEFAULT_MODES constant.  The task mode set
 * defines
 *
 * * the preemption mode of the task: #RTEMS_PREEMPT (default) or
 *   #RTEMS_NO_PREEMPT,
 *
 * * the timeslicing mode of the task: #RTEMS_TIMESLICE or #RTEMS_NO_TIMESLICE
 *   (default),
 *
 * * the ASR processing mode of the task: #RTEMS_ASR (default) or
 *   #RTEMS_NO_ASR,
 *
 * * the interrupt level of the task: RTEMS_INTERRUPT_LEVEL() with a default of
 *   ``RTEMS_INTERRUPT_LEVEL( 0 )`` which is associated with enabled
 *   interrupts.
 *
 * The **mode mask** specified in ``mask`` is built through a *bitwise or* of
 * the mode mask constants described below.
 *
 * When the #RTEMS_PREEMPT_MASK is set in ``mask``, the **preemption mode** of
 * the calling task is
 *
 * * enabled by using the #RTEMS_PREEMPT mode constant in ``mode_set`` and
 *
 * * disabled by using the #RTEMS_NO_PREEMPT mode constant in ``mode_set``.
 *
 * When the #RTEMS_TIMESLICE_MASK is set in ``mask``, the **timeslicing mode**
 * of the calling task is
 *
 * * enabled by using the #RTEMS_TIMESLICE mode constant in ``mode_set`` and
 *
 * * disabled by using the #RTEMS_NO_TIMESLICE mode constant in ``mode_set``.
 *
 * Enabling timeslicing has no effect if preemption is disabled.  For a task to
 * be timesliced, that task must have both preemption and timeslicing enabled.
 *
 * When the #RTEMS_ASR_MASK is set in ``mask``, the **ASR processing mode** of
 * the calling task is
 *
 * * enabled by using the #RTEMS_ASR mode constant in ``mode_set`` and
 *
 * * disabled by using the #RTEMS_NO_ASR mode constant in ``mode_set``.
 *
 * When the #RTEMS_INTERRUPT_MASK is set in ``mask``, **interrupts** of the
 * calling task are
 *
 * * enabled by using the RTEMS_INTERRUPT_LEVEL() mode macro with a value of
 *   zero (0) in ``mode_set`` and
 *
 * * disabled up to the specified level by using the RTEMS_INTERRUPT_LEVEL()
 *   mode macro with a positive value in ``mode_set``.
 *
 * An interrupt level of zero is associated with enabled interrupts on all
 * target processors.  The interrupt level portion of the task mode supports a
 * maximum of 256 interrupt levels.  These levels are mapped onto the interrupt
 * levels actually supported by the target processor in a processor dependent
 * fashion.
 *
 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
 *
 * @retval ::RTEMS_NOT_IMPLEMENTED The #RTEMS_NO_PREEMPT was set in
 *   ``mode_set`` and setting the preemption mode was requested by
 *   #RTEMS_PREEMPT_MASK in ``mask`` and the system configuration had no
 *   implementation for this mode.
 *
 * @retval ::RTEMS_NOT_IMPLEMENTED The RTEMS_INTERRUPT_LEVEL() was set to a
 *   positive level in ``mode_set`` and setting the interrupt level was
 *   requested by #RTEMS_INTERRUPT_MASK in ``mask`` and the system
 *   configuration had no implementation for this mode.
 *
 * @par Constraints
 * @parblock
 * The following constraints apply to this directive:
 *
 * * The directive may be called from within task context.
 *
 * * When the directive enables preemption for the calling task, another task
 *   may preempt the calling task.
 * @endparblock
 */
rtems_status_code rtems_task_mode(
  rtems_mode  mode_set,
  rtems_mode  mask,
  rtems_mode *previous_mode_set
);

/* Generated from spec:/rtems/task/if/no-priority */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
#define RTEMS_NO_PRIORITY RTEMS_CURRENT_PRIORITY

/* Generated from spec:/rtems/task/if/restart */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param id %
 *
 * @param argument %
 */
rtems_status_code rtems_task_restart(
  rtems_id            id,
  rtems_task_argument argument
);

/* Generated from spec:/rtems/task/if/resume */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param id %
 */
rtems_status_code rtems_task_resume( rtems_id id );

/* Generated from spec:/rtems/task/if/self */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
rtems_id rtems_task_self( void );

/* Generated from spec:/rtems/task/if/self-define */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
#define RTEMS_SELF OBJECTS_ID_OF_SELF

/* Generated from spec:/rtems/task/if/set-affinity */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param id %
 *
 * @param cpusetsize %
 *
 * @param cpuset %
 */
rtems_status_code rtems_task_set_affinity(
  rtems_id         id,
  size_t           cpusetsize,
  const cpu_set_t *cpuset
);

/* Generated from spec:/rtems/task/if/set-priority */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param id %
 *
 * @param new_priority %
 *
 * @param old_priority %
 */
rtems_status_code rtems_task_set_priority(
  rtems_id             id,
  rtems_task_priority  new_priority,
  rtems_task_priority *old_priority
);

/* Generated from spec:/rtems/task/if/set-scheduler */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param task_id %
 *
 * @param scheduler_id %
 *
 * @param priority %
 */
rtems_status_code rtems_task_set_scheduler(
  rtems_id            task_id,
  rtems_id            scheduler_id,
  rtems_task_priority priority
);

/* Generated from spec:/rtems/task/if/start */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param id %
 *
 * @param entry_point %
 *
 * @param argument %
 */
rtems_status_code rtems_task_start(
  rtems_id            id,
  rtems_task_entry    entry_point,
  rtems_task_argument argument
);

/* Generated from spec:/rtems/task/if/storage-alignment */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief This constant defines the recommended alignment of a task storage
 *   area in bytes.
 *
 * @par Notes
 * Use it with RTEMS_ALIGNED() to define the alignment of a statically
 * allocated task storage area.
 */
#define RTEMS_TASK_STORAGE_ALIGNMENT CPU_STACK_ALIGNMENT

/* Generated from spec:/rtems/task/if/storage-size */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief Returns the recommended task storage area size for the specified size
 *   and task attributes.
 *
 * @param _size is the size dedicated to the task stack and thread-local
 *   storage in bytes.
 *
 * @param _attributes is the attribute set of the task using the storage area.
 *
 * @return The recommended task storage area size calculated from the input
 *   parameters is returned.
 */
#if CPU_ALL_TASKS_ARE_FP == TRUE
  #define RTEMS_TASK_STORAGE_SIZE( _size, _attributes ) \
    ( ( _size ) + CONTEXT_FP_SIZE )
#else
  #define RTEMS_TASK_STORAGE_SIZE( _size, _attributes ) \
    ( ( _size ) + \
      ( ( ( _attributes ) & RTEMS_FLOATING_POINT ) != 0 ? \
        CONTEXT_FP_SIZE : 0 ) )
#endif

/* Generated from spec:/rtems/task/if/suspend */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param id %
 */
rtems_status_code rtems_task_suspend( rtems_id id );

/* Generated from spec:/rtems/task/if/tcb */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
typedef struct _Thread_Control rtems_tcb;

/* Generated from spec:/rtems/task/if/visitor */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
typedef bool( *rtems_task_visitor )( rtems_tcb *, void * );

/* Generated from spec:/rtems/task/if/iterate */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param visitor %
 *
 * @param arg %
 */
void rtems_task_iterate( rtems_task_visitor visitor, void *arg );

/* Generated from spec:/rtems/task/if/wake-after */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param ticks %
 */
rtems_status_code rtems_task_wake_after( rtems_interval ticks );

/* Generated from spec:/rtems/task/if/wake-when */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 *
 * @param time_buffer %
 */
rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer );

/* Generated from spec:/rtems/task/if/yield-processor */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
#define RTEMS_YIELD_PROCESSOR WATCHDOG_NO_TIMEOUT

/* Generated from spec:/score/if/maximum-priority */

/**
 * @brief Returns the maximum priority of the scheduler with index zero.
 */
rtems_task_priority _RTEMS_Maximum_priority( void );

/* Generated from spec:/rtems/task/if/maximum-priority */

/**
 * @ingroup RTEMSAPIClassicTasks
 *
 * @brief %
 */
#define RTEMS_MAXIMUM_PRIORITY _RTEMS_Maximum_priority()

#ifdef __cplusplus
}
#endif

#endif /* _RTEMS_RTEMS_TASKS_H */