From ac7d5ef06a6d6e8d84abbd1f0b82162725f98326 Mon Sep 17 00:00:00 2001 From: Joel Sherrill Date: Thu, 11 May 1995 17:39:37 +0000 Subject: Initial revision --- cpukit/rtems/include/rtems.h | 79 +++++ cpukit/rtems/include/rtems/rtems/asr.h | 177 +++++++++++ cpukit/rtems/include/rtems/rtems/attr.h | 188 ++++++++++++ cpukit/rtems/include/rtems/rtems/clock.h | 102 ++++++ cpukit/rtems/include/rtems/rtems/dpmem.h | 210 +++++++++++++ cpukit/rtems/include/rtems/rtems/event.h | 158 ++++++++++ cpukit/rtems/include/rtems/rtems/eventmp.h | 147 +++++++++ cpukit/rtems/include/rtems/rtems/eventset.h | 142 +++++++++ cpukit/rtems/include/rtems/rtems/intr.h | 125 ++++++++ cpukit/rtems/include/rtems/rtems/message.h | 461 ++++++++++++++++++++++++++++ cpukit/rtems/include/rtems/rtems/modes.h | 183 +++++++++++ cpukit/rtems/include/rtems/rtems/mp.h | 67 ++++ cpukit/rtems/include/rtems/rtems/msgmp.h | 175 +++++++++++ cpukit/rtems/include/rtems/rtems/options.h | 79 +++++ cpukit/rtems/include/rtems/rtems/part.h | 290 +++++++++++++++++ cpukit/rtems/include/rtems/rtems/partmp.h | 160 ++++++++++ cpukit/rtems/include/rtems/rtems/ratemon.h | 285 +++++++++++++++++ cpukit/rtems/include/rtems/rtems/region.h | 311 +++++++++++++++++++ cpukit/rtems/include/rtems/rtems/regionmp.h | 165 ++++++++++ cpukit/rtems/include/rtems/rtems/sem.h | 238 ++++++++++++++ cpukit/rtems/include/rtems/rtems/semmp.h | 163 ++++++++++ cpukit/rtems/include/rtems/rtems/signal.h | 72 +++++ cpukit/rtems/include/rtems/rtems/signalmp.h | 147 +++++++++ cpukit/rtems/include/rtems/rtems/status.h | 109 +++++++ cpukit/rtems/include/rtems/rtems/taskmp.h | 167 ++++++++++ cpukit/rtems/include/rtems/rtems/tasks.h | 315 +++++++++++++++++++ cpukit/rtems/include/rtems/rtems/timer.h | 292 ++++++++++++++++++ 27 files changed, 5007 insertions(+) create mode 100644 cpukit/rtems/include/rtems.h create mode 100644 cpukit/rtems/include/rtems/rtems/asr.h create mode 100644 cpukit/rtems/include/rtems/rtems/attr.h create mode 100644 cpukit/rtems/include/rtems/rtems/clock.h create mode 100644 cpukit/rtems/include/rtems/rtems/dpmem.h create mode 100644 cpukit/rtems/include/rtems/rtems/event.h create mode 100644 cpukit/rtems/include/rtems/rtems/eventmp.h create mode 100644 cpukit/rtems/include/rtems/rtems/eventset.h create mode 100644 cpukit/rtems/include/rtems/rtems/intr.h create mode 100644 cpukit/rtems/include/rtems/rtems/message.h create mode 100644 cpukit/rtems/include/rtems/rtems/modes.h create mode 100644 cpukit/rtems/include/rtems/rtems/mp.h create mode 100644 cpukit/rtems/include/rtems/rtems/msgmp.h create mode 100644 cpukit/rtems/include/rtems/rtems/options.h create mode 100644 cpukit/rtems/include/rtems/rtems/part.h create mode 100644 cpukit/rtems/include/rtems/rtems/partmp.h create mode 100644 cpukit/rtems/include/rtems/rtems/ratemon.h create mode 100644 cpukit/rtems/include/rtems/rtems/region.h create mode 100644 cpukit/rtems/include/rtems/rtems/regionmp.h create mode 100644 cpukit/rtems/include/rtems/rtems/sem.h create mode 100644 cpukit/rtems/include/rtems/rtems/semmp.h create mode 100644 cpukit/rtems/include/rtems/rtems/signal.h create mode 100644 cpukit/rtems/include/rtems/rtems/signalmp.h create mode 100644 cpukit/rtems/include/rtems/rtems/status.h create mode 100644 cpukit/rtems/include/rtems/rtems/taskmp.h create mode 100644 cpukit/rtems/include/rtems/rtems/tasks.h create mode 100644 cpukit/rtems/include/rtems/rtems/timer.h (limited to 'cpukit/rtems/include') diff --git a/cpukit/rtems/include/rtems.h b/cpukit/rtems/include/rtems.h new file mode 100644 index 0000000000..d0ab705f57 --- /dev/null +++ b/cpukit/rtems/include/rtems.h @@ -0,0 +1,79 @@ +/* rtems.h + * + * This include file contains information about RTEMS executive that + * is required by the application and is CPU independent. It includes + * two (2) CPU dependent files to tailor its data structures for a + * particular processor. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_RTEMS_GENERIC_h +#define __RTEMS_RTEMS_GENERIC_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * RTEMS basic type definitions + */ + +typedef unsigned8 rtems_unsigned8; /* unsigned 8-bit value */ +typedef unsigned16 rtems_unsigned16; /* unsigned 16-bit value */ +typedef unsigned32 rtems_unsigned32; /* unsigned 32-bit value */ +typedef unsigned64 rtems_unsigned64; /* unsigned 64-bit value */ + +typedef signed8 rtems_signed8; /* signed 8-bit value */ +typedef signed16 rtems_signed16; /* signed 16-bit value */ +typedef signed32 rtems_signed32; /* signed 32-bit value */ +typedef signed64 rtems_signed64; /* signed 64-bit value */ + +typedef single_precision rtems_single; /* single precision float */ +typedef double_precision rtems_double; /* double precision float */ + +typedef boolean rtems_boolean; + +typedef Objects_Name rtems_name; +typedef Objects_Id rtems_id; + +typedef Context_Control rtems_context; +typedef Context_Control_fp rtems_context_fp; +typedef CPU_Interrupt_frame rtems_interrupt_frame; + +#define RTEMS_HAS_HARDWARE_FP CPU_HARDWARE_FP + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/asr.h b/cpukit/rtems/include/rtems/rtems/asr.h new file mode 100644 index 0000000000..44d03f2802 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/asr.h @@ -0,0 +1,177 @@ +/* asr.h + * + * This include file contains all the constants and structures associated + * with the Asynchronous Signal Handler. This Handler provides the low-level + * support required by the Signal Manager. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_ASR_h +#define __RTEMS_ASR_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + * + * The following type defines the control block used to manage + * each signal set. + */ + +typedef unsigned32 rtems_signal_set; + +/* + * Return type for ASR Handler + */ + +typedef void rtems_asr; + +/* + * The following type corresponds to the applications asynchronous + * signal processing routine. + */ + +typedef rtems_asr ( *rtems_asr_entry )( + rtems_signal_set + ); + +/* + * + * The following defines the control structure used to manage + * signals. Each thread has a copy of this record. + */ + +typedef struct { + rtems_asr_entry handler; /* address of RTEMS_ASR */ + rtems_mode mode_set; /* RTEMS_ASR mode */ + rtems_signal_set signals_posted; /* signal set */ + rtems_signal_set signals_pending; /* pending signal set */ + unsigned32 nest_level; /* nest level of RTEMS_ASR */ +} ASR_Information; + +/* + * The following constants define the individual signals which may + * be used to compose a signal set. + */ + +#define RTEMS_SIGNAL_0 0x00000001 +#define RTEMS_SIGNAL_1 0x00000002 +#define RTEMS_SIGNAL_2 0x00000004 +#define RTEMS_SIGNAL_3 0x00000008 +#define RTEMS_SIGNAL_4 0x00000010 +#define RTEMS_SIGNAL_5 0x00000020 +#define RTEMS_SIGNAL_6 0x00000040 +#define RTEMS_SIGNAL_7 0x00000080 +#define RTEMS_SIGNAL_8 0x00000100 +#define RTEMS_SIGNAL_9 0x00000200 +#define RTEMS_SIGNAL_10 0x00000400 +#define RTEMS_SIGNAL_11 0x00000800 +#define RTEMS_SIGNAL_12 0x00001000 +#define RTEMS_SIGNAL_13 0x00002000 +#define RTEMS_SIGNAL_14 0x00004000 +#define RTEMS_SIGNAL_15 0x00008000 +#define RTEMS_SIGNAL_16 0x00010000 +#define RTEMS_SIGNAL_17 0x00020000 +#define RTEMS_SIGNAL_18 0x00040000 +#define RTEMS_SIGNAL_19 0x00080000 +#define RTEMS_SIGNAL_20 0x00100000 +#define RTEMS_SIGNAL_21 0x00200000 +#define RTEMS_SIGNAL_22 0x00400000 +#define RTEMS_SIGNAL_23 0x00800000 +#define RTEMS_SIGNAL_24 0x01000000 +#define RTEMS_SIGNAL_25 0x02000000 +#define RTEMS_SIGNAL_26 0x04000000 +#define RTEMS_SIGNAL_27 0x08000000 +#define RTEMS_SIGNAL_28 0x10000000 +#define RTEMS_SIGNAL_29 0x20000000 +#define RTEMS_SIGNAL_30 0x40000000 +#define RTEMS_SIGNAL_31 0x80000000 + +/* + * _ASR_Initialize + * + * DESCRIPTION: + * + * This routine initializes the given RTEMS_ASR information record. + */ + +STATIC INLINE void _ASR_Initialize ( + ASR_Information *information +); + +/* + * _ASR_Swap_signals + * + * DESCRIPTION: + * + * This routine atomically swaps the pending and posted signal + * sets. This is done when the thread alters its mode in such a + * way that the RTEMS_ASR disable/enable flag changes. + */ + +STATIC INLINE void _ASR_Swap_signals ( + ASR_Information *information +); + +/* + * _ASR_Is_null_handler + * + * DESCRIPTION: + * + * This function returns TRUE if the given asr_handler is NULL and + * FALSE otherwise. + */ + +STATIC INLINE boolean _ASR_Is_null_handler ( + rtems_asr_entry asr_handler +); + +/* + * _ASR_Are_signals_pending + * + * DESCRIPTION: + * + * This function returns TRUE if there are signals pending in the + * given RTEMS_ASR information record and FALSE otherwise. + */ + +STATIC INLINE boolean _ASR_Are_signals_pending ( + ASR_Information *information +); + +/* + * _ASR_Post_signals + * + * DESCRIPTION: + * + * This routine posts the given signals into the signal_set + * passed in. The result is returned to the user in signal_set. + * + * NOTE: This must be implemented as a macro. + */ + +STATIC INLINE void _ASR_Post_signals( + rtems_signal_set signals, + rtems_signal_set *signal_set +); + +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/attr.h b/cpukit/rtems/include/rtems/rtems/attr.h new file mode 100644 index 0000000000..1c59c98dcd --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/attr.h @@ -0,0 +1,188 @@ +/* attr.h + * + * This include file contains all information about the Object Attributes + * Handler. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_ATTRIBUTES_h +#define __RTEMS_ATTRIBUTES_h + +#ifdef __cplusplus +extern "C" { +#endif + +/* types */ + +typedef unsigned32 rtems_attribute; + +/* constants */ + +#define RTEMS_DEFAULT_ATTRIBUTES 0x00000000 + +#define RTEMS_NO_FLOATING_POINT 0x00000000 /* don't use FP HW */ +#define RTEMS_FLOATING_POINT 0x00000001 /* utilize coprocessor */ + +#define RTEMS_LOCAL 0x00000000 /* local resource */ +#define RTEMS_GLOBAL 0x00000002 /* global resource */ + +#define RTEMS_FIFO 0x00000000 /* process RTEMS_FIFO */ +#define RTEMS_PRIORITY 0x00000004 /* process by priority */ + +#define RTEMS_NO_LIMIT 0x00000000 /* unlimited Q entries */ +#define RTEMS_LIMIT 0x00000008 /* limit Q entries */ + +#define RTEMS_COUNTING_SEMAPHORE 0x00000000 +#define RTEMS_BINARY_SEMAPHORE 0x00000010 + +#define RTEMS_NO_INHERIT_PRIORITY 0x00000000 +#define RTEMS_INHERIT_PRIORITY 0x00000020 + +#if ( CPU_HARDWARE_FP == TRUE ) +#define ATTRIBUTES_NOT_SUPPORTED 0 +#else +#define ATTRIBUTES_NOT_SUPPORTED RTEMS_FLOATING_POINT +#endif + +#if ( CPU_ALL_TASKS_ARE_FP == TRUE ) +#define ATTRIBUTES_REQUIRED RTEMS_FLOATING_POINT +#else +#define ATTRIBUTES_REQUIRED 0 +#endif + +/* + * _Attributes_Handler_initialization + * + * DESCRIPTION: + * + * This routine performs initialization for this handler. + * + * NOTE: There is no initialization required in C. Conditional compilation + * takes care of this in C. + */ + +#define _Attributes_Handler_initialization() + +/* + * _Attributes_Set + * + * DESCRIPTION: + * + * This function sets the requested new_attributes in the attribute_set + * passed in. The result is returned to the user. + */ + +STATIC INLINE rtems_attribute _Attributes_Set ( + rtems_attribute new_attributes, + rtems_attribute attribute_set +); + +/* + * _Attributes_Clear + * + * DESCRIPTION: + * + * This function clears the requested new_attributes in the attribute_set + * passed in. The result is returned to the user. + */ + +STATIC INLINE rtems_attribute _Attributes_Clear ( + rtems_attribute attribute_set, + rtems_attribute mask +); + +/* + * _Attributes_Is_floating_point + * + * DESCRIPTION: + * + * This function returns TRUE if the floating point attribute is + * enabled in the attribute_set and FALSE otherwise. + */ + +STATIC INLINE boolean _Attributes_Is_floating_point( + rtems_attribute attribute_set +); + +/* + * _Attributes_Is_global + * + * DESCRIPTION: + * + * This function returns TRUE if the global object attribute is + * enabled in the attribute_set and FALSE otherwise. + */ + +STATIC INLINE boolean _Attributes_Is_global( + rtems_attribute attribute_set +); + +/* + * _Attributes_Is_priority + * + * DESCRIPTION: + * + * This function returns TRUE if the priority attribute is + * enabled in the attribute_set and FALSE otherwise. + */ + +STATIC INLINE boolean _Attributes_Is_priority( + rtems_attribute attribute_set +); + +/* + * _Attributes_Is_limit + * + * DESCRIPTION: + * + * This function returns TRUE if the limited attribute is + * enabled in the attribute_set and FALSE otherwise. + */ + +STATIC INLINE boolean _Attributes_Is_limit( + rtems_attribute attribute_set +); + +/* + * _Attributes_Is_binary_semaphore + * + * DESCRIPTION: + * + * This function returns TRUE if the binary semaphore attribute is + * enabled in the attribute_set and FALSE otherwise. + */ + +STATIC INLINE boolean _Attributes_Is_binary_semaphore( + rtems_attribute attribute_set +); + +/* + * _Attributes_Is_inherit_priority + * + * DESCRIPTION: + * + * This function returns TRUE if the priority inheritance attribute + * is enabled in the attribute_set and FALSE otherwise. + */ + +STATIC INLINE boolean _Attributes_Is_inherit_priority( + rtems_attribute attribute_set +); + +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/clock.h b/cpukit/rtems/include/rtems/rtems/clock.h new file mode 100644 index 0000000000..e849ab4f40 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/clock.h @@ -0,0 +1,102 @@ +/* clock.h + * + * This include file contains all the constants and structures associated + * with the Clock Manager. This manager provides facilities to set, obtain, + * and continually update the current date and time. + * + * This manager provides directives to: + * + * + set the current date and time + * + obtain the current date and time + * + announce a clock tick + * + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_CLOCK_h +#define __RTEMS_CLOCK_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + * List of things which can be returned by the rtems_clock_get directive. + */ + +typedef enum { + RTEMS_CLOCK_GET_TOD, + RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH, + RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, + RTEMS_CLOCK_GET_TICKS_PER_SECOND, + RTEMS_CLOCK_GET_TIME_VALUE +} rtems_clock_get_options; + +/* + * Standard flavor style to return TOD in for a rtems_clock_get option. + */ + +typedef struct { + unsigned32 seconds; + unsigned32 microseconds; +} rtems_clock_time_value; + +/* + * rtems_clock_get + * + * DESCRIPTION: + * + * This routine implements the rtems_clock_get directive. It returns + * one of the following: + * + current time of day + * + seconds since epoch + * + ticks since boot + * + ticks per second + */ + +rtems_status_code rtems_clock_get( + rtems_clock_get_options option, + void *time_buffer +); + +/* + * rtems_clock_set + * + * DESCRIPTION: + * + * This routine implements the rtems_clock_set directive. It sets + * the current time of day to that in the time_buffer record. + */ + +rtems_status_code rtems_clock_set( + rtems_time_of_day *time_buffer +); + +/* + * rtems_clock_tick + * + * DESCRIPTION: + * + * This routine implements the rtems_clock_tick directive. It is invoked + * to inform RTEMS of the occurrence of a clock tick. + */ + +rtems_status_code rtems_clock_tick( void ); + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/dpmem.h b/cpukit/rtems/include/rtems/rtems/dpmem.h new file mode 100644 index 0000000000..669eb394d8 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/dpmem.h @@ -0,0 +1,210 @@ +/* dpmem.h + * + * This include file contains all the constants and structures associated + * with the Dual Ported Memory Manager. This manager provides a mechanism + * for converting addresses between internal and external representations + * for multiple dual-ported memory areas. + * + * Directives provided are: + * + * + create a port + * + get ID of a port + * + delete a port + * + convert external to internal address + * + convert internal to external address + * + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_DUAL_PORTED_MEMORY_h +#define __RTEMS_DUAL_PORTED_MEMORY_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + * The following structure defines the port control block. Each port + * has a control block associated with it. This control block contains + * all information required to support the port related operations. + */ + +typedef struct { + Objects_Control Object; + void *internal_base; /* base internal address */ + void *external_base; /* base external address */ + unsigned32 length; /* length of dual-ported area */ +} Dual_ported_memory_Control; + +/* + * The following define the internal Dual Ported Memory information. + */ + +EXTERN Objects_Information _Dual_ported_memory_Information; + +/* + * _Dual_ported_memory_Manager_initialization + * + * DESCRIPTION: + * + * This routine performs the initialization necessary for this manager. + */ + +void _Dual_ported_memory_Manager_initialization( + unsigned32 maximum_ports +); + +/* + * rtems_port_create + * + * DESCRIPTION: + * + * This routine implements the rtems_port_create directive. The port + * will have the name name. The port maps onto an area of dual ported + * memory of length bytes which has internal_start and external_start + * as the internal and external starting addresses, respectively. + * It returns the id of the created port in ID. + */ + +rtems_status_code rtems_port_create( + Objects_Name name, + void *internal_start, + void *external_start, + unsigned32 length, + Objects_Id *id +); + +/* + * rtems_port_ident + * + * DESCRIPTION: + * + * This routine implements the rtems_port_ident directive. This directive + * returns the port ID associated with name. If more than one port is + * named name, then the port to which the ID belongs is arbitrary. + */ + +rtems_status_code rtems_port_ident( + Objects_Name name, + Objects_Id *id +); + +/* + * rtems_port_delete + * + * DESCRIPTION: + * + * This routine implements the rtems_port_delete directive. It deletes + * the port associated with ID. + */ + +rtems_status_code rtems_port_delete( + Objects_Id id +); + +/* + * rtems_port_external_to_internal + * + * DESCRIPTION: + * + * This routine implements the rtems_port_external_to_internal directive. + * It returns the internal port address which maps to the provided + * external port address for the specified port ID. + */ + +rtems_status_code rtems_port_external_to_internal( + Objects_Id id, + void *external, + void **internal +); + +/* + * rtems_port_internal_to_external + * + * DESCRIPTION: + * + * This routine implements the Port_internal_to_external directive. + * It returns the external port address which maps to the provided + * internal port address for the specified port ID. + */ + +rtems_status_code rtems_port_internal_to_external( + Objects_Id id, + void *internal, + void **external +); + +/* + * _Dual_ported_memory_Allocate + * + * DESCRIPTION: + * + * This routine allocates a port control block from the inactive chain + * of free port control blocks. + */ + +STATIC INLINE Dual_ported_memory_Control + *_Dual_ported_memory_Allocate ( void ); + +/* + * _Dual_ported_memory_Free + * + * DESCRIPTION: + * + * This routine frees a port control block to the inactive chain + * of free port control blocks. + */ + +STATIC INLINE void _Dual_ported_memory_Free ( + Dual_ported_memory_Control *the_port +); + +/* + * _Dual_ported_memory_Get + * + * DESCRIPTION: + * + * This function maps port IDs to port control blocks. If ID + * corresponds to a local port, then it returns the_port control + * pointer which maps to ID and location is set to OBJECTS_LOCAL. + * Global ports are not supported, thus if ID does not map to a + * local port, location is set to OBJECTS_ERROR and the_port is + * undefined. + */ + +STATIC INLINE Dual_ported_memory_Control *_Dual_ported_memory_Get ( + Objects_Id id, + Objects_Locations *location +); + +/* + * _Dual_ported_memory_Is_null + * + * DESCRIPTION: + * + * This function returns TRUE if the_port is NULL and FALSE otherwise. + */ + +STATIC INLINE boolean _Dual_ported_memory_Is_null( + Dual_ported_memory_Control *the_port +); + +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/event.h b/cpukit/rtems/include/rtems/rtems/event.h new file mode 100644 index 0000000000..aeb71b2abd --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/event.h @@ -0,0 +1,158 @@ +/* event.h + * + * This include file contains the information pertaining to the Event + * Manager. This manager provides a high performance method of communication + * and synchronization. + * + * Directives provided are: + * + * + send an event set to a task + * + receive event condition + * + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_EVENT_h +#define __RTEMS_EVENT_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include + +/* + * This constant is passed as the event_in to the + * rtems_event_receive directive to determine which events are pending. + */ + +#define EVENT_CURRENT 0 + +/* + * _Event_Manager_initialization + * + * DESCRIPTION: + * + * This routine performs the initialization necessary for this manager. + */ + +STATIC INLINE void _Event_Manager_initialization( void ); + +/* + * rtems_event_send + * + * DESCRIPTION: + * + * This routine implements the rtems_event_send directive. It sends + * event_in to the task specified by ID. If the task is blocked + * waiting to receive events and the posting of event_in satisfies + * the task's event condition, then it is unblocked. + */ + +rtems_status_code rtems_event_send ( + Objects_Id id, + rtems_event_set event_in +); + +/* + * rtems_event_receive + * + * DESCRIPTION: + * + * This routine implements the rtems_event_receive directive. This + * directive is invoked when the calling task wishes to receive + * the event_in event condition. One of the fields in the option_set + * parameter determines whether the receive request is satisfied if + * any or all of the events are pending. If the event condition + * is not satisfied immediately, then the task may block with an + * optional timeout of TICKS clock ticks or return immediately. + * This determination is based on another field in the option_set + * parameter. This directive returns the events received in the + * event_out parameter. + */ + +rtems_status_code rtems_event_receive ( + rtems_event_set event_in, + rtems_option option_set, + rtems_interval ticks, + rtems_event_set *event_out +); + +/* + * _Event_Seize + * + * DESCRIPTION: + * + * This routine determines if the event condition event_in is + * satisfied. If so or if the no_wait option is enabled in option_set, + * then the procedure returns immediately. If neither of these + * conditions is true, then the calling task is blocked with an + * optional timeout of ticks clock ticks. + */ + +void _Event_Seize ( + rtems_event_set event_in, + rtems_option option_set, + rtems_interval ticks +); + +/* + * _Event_Surrender + * + * DESCRIPTION: + * + * This routine determines if the event condition of the_thread + * has been satisfied. If so, it unblocks the_thread. + */ + +void _Event_Surrender ( + Thread_Control *the_thread +); + +/* + * _Event_Timeout + * + * DESCRIPTION: + * + * This routine is invoked when a task's event receive request + * has not been satisfied after the specified timeout interval. + * The task represented by ID will be unblocked and its status + * code will be set in it's control block to indicate that a timeout + * has occurred. + */ + +void _Event_Timeout ( + Objects_Id id, + void *ignored +); + +/* + * The following defines the synchronization flag used by the + * Event Manager to insure that signals sent to the currently + * executing thread are received properly. + */ + +EXTERN boolean _Event_Sync; /* event manager sync flag */ + +#include +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/eventmp.h b/cpukit/rtems/include/rtems/rtems/eventmp.h new file mode 100644 index 0000000000..9df2ef1e22 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/eventmp.h @@ -0,0 +1,147 @@ +/* eventmp.h + * + * This include file contains all the constants and structures associated + * with the Multiprocessing Support in the Event Manager. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_EVENT_MP_h +#define __RTEMS_EVENT_MP_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include + +/* + * The following enumerated type defines the list of + * remote event operations. + */ + +typedef enum { + EVENT_MP_SEND_REQUEST = 0, + EVENT_MP_SEND_RESPONSE = 1, +} Event_MP_Remote_operations; + +/* + * The following data structure defines the packet used to perform + * remote event operations. + */ + +typedef struct { + rtems_packet_prefix Prefix; + Event_MP_Remote_operations operation; + rtems_event_set event_in; +} Event_MP_Packet; + +/* + * _Event_MP_Send_process_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * process operation can be performed on another node. + * + * This routine is not needed since there are no process + * packets to be sent by this manager. + */ + +/* + * _Event_MP_Send_request_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive operation can be initiated on another node. + */ + +rtems_status_code _Event_MP_Send_request_packet ( + Event_MP_Remote_operations operation, + Objects_Id event_id, + rtems_event_set event_in +); + +/* + * _Event_MP_Send_response_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive can be performed on another node. + */ + +void _Event_MP_Send_response_packet ( + Event_MP_Remote_operations operation, + Thread_Control *the_thread +); + +/* + * + * _Event_MP_Process_packet + * + * DESCRIPTION: + * + * This routine performs the actions specific to this package for + * the request from another node. + */ + +void _Event_MP_Process_packet ( + rtems_packet_prefix *the_packet_prefix +); + +/* + * _Event_MP_Send_object_was_deleted + * + * DESCRIPTION: + * + * This routine is invoked indirectly by the thread queue + * when a proxy has been removed from the thread queue and + * the remote node must be informed of this. + * + * This routine is not needed since there are no objects + * deleted by this manager. + */ + +/* + * _Event_MP_Send_extract_proxy + * + * DESCRIPTION: + * + * This routine is invoked when a task is deleted and it + * has a proxy which must be removed from a thread queue and + * the remote node must be informed of this. + * + * This routine is not needed since there are no objects + * deleted by this manager. + */ + +/* + * _Event_MP_Get_packet + * + * DESCRIPTION: + * + * This function is used to obtain a event mp packet. + */ + +Event_MP_Packet *_Event_MP_Get_packet ( void ); + +#ifdef __cplusplus +} +#endif + +#endif +/* end of file */ diff --git a/cpukit/rtems/include/rtems/rtems/eventset.h b/cpukit/rtems/include/rtems/rtems/eventset.h new file mode 100644 index 0000000000..a25dabe58b --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/eventset.h @@ -0,0 +1,142 @@ +/* eventset.h + * + * This include file contains the information pertaining to the + * Event Sets Handler. This handler provides methods for the manipulation + * of event sets which will be sent and received by tasks. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_EVENT_SET_h +#define __RTEMS_EVENT_SET_h + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The following defines the type used to control event sets. + */ + +typedef unsigned32 rtems_event_set; + +/* + * The following constants define the individual events which may + * be used to compose an event set. + */ + +#define RTEMS_PENDING_EVENTS 0 /* receive pending events */ +#define RTEMS_ALL_EVENTS 0xFFFFFFFF + +#define RTEMS_EVENT_0 0x00000001 +#define RTEMS_EVENT_1 0x00000002 +#define RTEMS_EVENT_2 0x00000004 +#define RTEMS_EVENT_3 0x00000008 +#define RTEMS_EVENT_4 0x00000010 +#define RTEMS_EVENT_5 0x00000020 +#define RTEMS_EVENT_6 0x00000040 +#define RTEMS_EVENT_7 0x00000080 +#define RTEMS_EVENT_8 0x00000100 +#define RTEMS_EVENT_9 0x00000200 +#define RTEMS_EVENT_10 0x00000400 +#define RTEMS_EVENT_11 0x00000800 +#define RTEMS_EVENT_12 0x00001000 +#define RTEMS_EVENT_13 0x00002000 +#define RTEMS_EVENT_14 0x00004000 +#define RTEMS_EVENT_15 0x00008000 +#define RTEMS_EVENT_16 0x00010000 +#define RTEMS_EVENT_17 0x00020000 +#define RTEMS_EVENT_18 0x00040000 +#define RTEMS_EVENT_19 0x00080000 +#define RTEMS_EVENT_20 0x00100000 +#define RTEMS_EVENT_21 0x00200000 +#define RTEMS_EVENT_22 0x00400000 +#define RTEMS_EVENT_23 0x00800000 +#define RTEMS_EVENT_24 0x01000000 +#define RTEMS_EVENT_25 0x02000000 +#define RTEMS_EVENT_26 0x04000000 +#define RTEMS_EVENT_27 0x08000000 +#define RTEMS_EVENT_28 0x10000000 +#define RTEMS_EVENT_29 0x20000000 +#define RTEMS_EVENT_30 0x40000000 +#define RTEMS_EVENT_31 0x80000000 + + +/* + * The following constant is the value of an event set which + * has no events pending. + */ + +#define EVENT_SETS_NONE_PENDING 0 + +/* + * _Event_sets_Is_empty + * + * DESCRIPTION: + * + * This function returns TRUE if on events are posted in the event_set, + * and FALSE otherwise. + */ + +STATIC INLINE boolean _Event_sets_Is_empty( + rtems_event_set the_event_set +); + +/* + * _Event_sets_Post + * + * DESCRIPTION: + * + * This routine posts the given new_events into the event_set + * passed in. The result is returned to the user in event_set. + */ + +STATIC INLINE void _Event_sets_Post( + rtems_event_set the_new_events, + rtems_event_set *the_event_set +); + +/* + * _Event_sets_Get + * + * DESCRIPTION: + * + * This function returns the events in event_condition which are + * set in event_set. + */ + +STATIC INLINE rtems_event_set _Event_sets_Get( + rtems_event_set the_event_set, + rtems_event_set the_event_condition +); + +/* + * _Event_sets_Clear + * + * DESCRIPTION: + * + * This function removes the events in mask from the event_set + * passed in. The result is returned to the user in event_set. + */ + +STATIC INLINE rtems_event_set _Event_sets_Clear( + rtems_event_set the_event_set, + rtems_event_set the_mask +); + +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/intr.h b/cpukit/rtems/include/rtems/rtems/intr.h new file mode 100644 index 0000000000..3669af1ccc --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/intr.h @@ -0,0 +1,125 @@ +/* intr.h + * + * This include file contains all the constants and structures associated + * with the Interrupt Manager. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_INTERRUPT_h +#define __RTEMS_INTERRUPT_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + * Interrupt level type + */ + +typedef ISR_Level rtems_interrupt_level; + +/* + * _Interrupt_Manager_initialization + * + * DESCRIPTION: + * + * This routine initializes the interrupt manager. + * + */ + +void _Interrupt_Manager_initialization( void ); + +/* + * rtems_interrupt_catch + * + * DESCRIPTION: + * + * This routine implements the rtems_interrupt_catch directive. This + * directive installs new_isr_handler as the RTEMS interrupt service + * routine for vector. The previous RTEMS interrupt service + * routine is returned in old_isr_handler. + */ + +rtems_status_code rtems_interrupt_catch( + rtems_isr_entry new_isr_handler, + rtems_vector_number vector, + rtems_isr_entry *old_isr_handler +); + +/* + * rtems_interrupt_disable + * + * DESCRIPTION: + * + * This routine disables all maskable interrupts and returns the + * previous level in _isr_cookie. + */ + +#define rtems_interrupt_disable( _isr_cookie ) \ + _ISR_Disable(_isr_cookie) + +/* + * rtems_interrupt_enable + * + * DESCRIPTION: + * + * This routine enables maskable interrupts to the level indicated + * _isr_cookie. + */ + +#define rtems_interrupt_enable( _isr_cookie ) \ + _ISR_Enable(_isr_cookie) + +/* + * rtems_interrupt_flash + * + * DESCRIPTION: + * + * This routine temporarily enables maskable interrupts to the + * level in _isr_cookie before redisabling them. + */ + +#define rtems_interrupt_flash( _isr_cookie ) \ + _ISR_Flash(_isr_cookie) + +/* + * rtems_interrupt_cause + * + * DESCRIPTION: + * + * This routine generates an interrupt. + * + * NOTE: No implementation. + */ + +#define rtems_interrupt_cause( _interrupt_to_cause ) + +/* + * rtems_interrupt_cause + * + * DESCRIPTION: + * + * This routine clears the specified interrupt. + * + * NOTE: No implementation. + */ + +#define rtems_interrupt_clear( _interrupt_to_clear ) + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/message.h b/cpukit/rtems/include/rtems/rtems/message.h new file mode 100644 index 0000000000..aefcea3c36 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/message.h @@ -0,0 +1,461 @@ +/* message.h + * + * This include file contains all the constants and structures associated + * with the Message Queue Manager. This manager provides a mechanism for + * communication and synchronization between tasks using messages. + * + * Directives provided are: + * + * + create a queue + * + get ID of a queue + * + delete a queue + * + put a message at the rear of a queue + * + put a message at the front of a queue + * + broadcast N messages to a queue + * + receive message from a queue + * + flush all messages on a queue + * + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_MESSAGE_QUEUE_h +#define __RTEMS_MESSAGE_QUEUE_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +/* + * The following defines the data types needed to manipulate + * the contents of message buffers. + */ + +typedef struct { + unsigned32 field1; + unsigned32 field2; + unsigned32 field3; + unsigned32 field4; +} Message_queue_Buffer; + +/* + * The following records define the organization of a message + * buffer. + */ + +typedef struct { + Chain_Node Node; + Message_queue_Buffer Contents; +} Message_queue_Buffer_control; + +/* + * The following records define the control block used to manage + * each message queue. + */ + +typedef struct { + Objects_Control Object; + Thread_queue_Control Wait_queue; + rtems_attribute attribute_set; + unsigned32 maximum_pending_messages; + unsigned32 number_of_pending_messages; + Chain_Control Pending_messages; +} Message_queue_Control; + +/* + * The following defines the information control block used to + * manage this class of objects. + */ + +EXTERN Objects_Information _Message_queue_Information; + +/* + * The following defines the data structures used to + * manage the pool of inactive message buffers. + */ + +EXTERN Chain_Control _Message_queue_Inactive_messages; + +/* + * The following enumerated type details the modes in which a message + * may be submitted to a message queue. The message may be posted + * in a send or urgent fashion. + */ + +typedef enum { + MESSAGE_QUEUE_SEND_REQUEST = 0, + MESSAGE_QUEUE_URGENT_REQUEST = 1 +} Message_queue_Submit_types; + +/* + * _Message_queue_Manager_initialization + * + * DESCRIPTION: + * + * This routine performs the initialization necessary for this manager. + */ + +void _Message_queue_Manager_initialization( + unsigned32 maximum_message_queues, + unsigned32 maximum_messages +); + +/* + * rtems_message_queue_create + * + * DESCRIPTION: + * + * This routine implements the rtems_message_queue_create directive. The + * message queue will have the name name. If the attribute_set indicates + * that the message queue is to be limited in the number of messages + * that can be outstanding, then count indicates the maximum number of + * messages that will be held. It returns the id of the created + * message queue in ID. + */ + +rtems_status_code rtems_message_queue_create( + Objects_Name name, + unsigned32 count, + rtems_attribute attribute_set, + Objects_Id *id +); + +/* + * rtems_message_queue_ident + * + * DESCRIPTION: + * + * This routine implements the rtems_message_queue_ident directive. + * This directive returns the message queue ID associated with NAME. + * If more than one message queue is named name, then the message + * queue to which the ID belongs is arbitrary. node indicates the + * extent of the search for the ID of the message queue named name. + * The search can be limited to a particular node or allowed to + * encompass all nodes. + */ + +rtems_status_code rtems_message_queue_ident( + Objects_Name name, + unsigned32 node, + Objects_Id *id +); + +/* + * rtems_message_queue_delete + * + * DESCRIPTION: + * + * This routine implements the rtems_message_queue_delete directive. The + * message queue indicated by ID is deleted. + */ + +rtems_status_code rtems_message_queue_delete( + Objects_Id id +); + +/* + * rtems_message_queue_send + * + * DESCRIPTION: + * + * This routine implements the rtems_message_queue_send directive. + * This directive sends the message buffer to the message queue + * indicated by ID. If one or more tasks is blocked waiting + * to receive a message from this message queue, then one will + * receive the message. The task selected to receive the + * message is based on the task queue discipline algorithm in + * use by this particular message queue. If no tasks are waiting, + * then the message buffer will be placed at the rear of the + * chain of pending messages for this message queue. + */ + +rtems_status_code rtems_message_queue_send( + Objects_Id id, + void *buffer +); + +/* + * rtems_message_queue_urgent + * + * DESCRIPTION: + * + * This routine implements the rtems_message_queue_send directive. + * This directive sends the message buffer to the message queue + * indicated by ID. If one or more tasks is blocked waiting + * to receive a message from this message queue, then one will + * receive the message. The task selected to receive the + * message is based on the task queue discipline algorithm in + * use by this particular message queue. If no tasks are waiting, + * then the message buffer will be placed at the rear of the + * chain of pending messages for this message queue. + */ + +rtems_status_code rtems_message_queue_urgent( + Objects_Id id, + void *buffer +); + +/* + * rtems_message_queue_broadcast + * + * DESCRIPTION: + * + * This routine implements the rtems_message_queue_send directive. + * This directive sends the message buffer to the message queue + * indicated by ID. If one or more tasks is blocked waiting + * to receive a message from this message queue, then one will + * receive the message. The task selected to receive the + * message is based on the task queue discipline algorithm in + * use by this particular message queue. If no tasks are waiting, + * then the message buffer will be placed at the rear of the + * chain of pending messages for this message queue. + */ + +rtems_status_code rtems_message_queue_broadcast( + Objects_Id id, + void *buffer, + unsigned32 *count +); + +/* + * rtems_message_queue_receive + * + * DESCRIPTION: + * + * This routine implements the rtems_message_queue_receive directive. + * This directive is invoked when the calling task wishes to receive + * a message from the message queue indicated by ID. The received + * message is to be placed in buffer. If no messages are outstanding + * and the option_set indicates that the task is willing to block, + * then the task will be blocked until a message arrives or until, + * optionally, timeout clock ticks have passed. + */ + +rtems_status_code rtems_message_queue_receive( + Objects_Id id, + void *buffer, + unsigned32 option_set, + rtems_interval timeout +); + +/* + * rtems_message_queue_flush + * + * DESCRIPTION: + * + * This routine implements the rtems_message_queue_flush directive. + * This directive takes all outstanding messages for the message + * queue indicated by ID and returns them to the inactive message + * chain. The number of messages flushed is returned in COUNT. + */ + +rtems_status_code rtems_message_queue_flush( + Objects_Id id, + unsigned32 *count +); + +/* + * _Message_queue_Copy_buffer + * + * DESCRIPTION: + * + * This routine copies the contents of the source message buffer + * to the destination message buffer. + */ + +STATIC INLINE void _Message_queue_Copy_buffer ( + Message_queue_Buffer *source, + Message_queue_Buffer *destination +); + +/* + * _Message_queue_Seize + * + * DESCRIPTION: + * + * This routine attempts to receive a message from the_message_queue. + * If a message is available or if the RTEMS_NO_WAIT option is enabled in + * option_set, then the routine returns. Otherwise, the calling task + * is blocked until a message is available. If a message is returned + * to the task, then buffer will contain its contents. + */ + +boolean _Message_queue_Seize( + Message_queue_Control *the_message_queue, + unsigned32 option_set, + Message_queue_Buffer *buffer +); + +/* + * _Message_queue_Flush_support + * + * DESCRIPTION: + * + * This routine flushes all outstanding messages and returns + * them to the inactive message chain. + */ + +unsigned32 _Message_queue_Flush_support( + Message_queue_Control *the_message_queue +); + +/* + * _Message_queue_Submit + * + * DESCRIPTION: + * + * This routine provides the common foundation for the + * rtems_message_queue_send and rtems_message_queue_urgent directives. + */ + +rtems_status_code _Message_queue_Submit( + Objects_Id id, + Message_queue_Buffer *buffer, + Message_queue_Submit_types submit_type +); + +/* + * _Message_queue_Allocate_message_buffer + * + * DESCRIPTION: + * + * This function allocates a message buffer from the inactive + * message buffer chain. + */ + +STATIC INLINE Message_queue_Buffer_control * + _Message_queue_Allocate_message_buffer ( void ); + +/* + * _Message_queue_Free_message_buffer + * + * DESCRIPTION: + * + * This routine frees a message buffer to the inactive + * message buffer chain. + */ + +STATIC INLINE void _Message_queue_Free_message_buffer ( + Message_queue_Buffer_control *the_message +); + +/* + * _Message_queue_Get_pending_message + * + * DESCRIPTION: + * + * This function removes the first message from the_message_queue + * and returns a pointer to it. + */ + +STATIC INLINE + Message_queue_Buffer_control *_Message_queue_Get_pending_message ( + Message_queue_Control *the_message_queue +); + +/* + * _Message_queue_Append + * + * DESCRIPTION: + * + * This routine places the_message at the rear of the outstanding + * messages on the_message_queue. + */ + +STATIC INLINE void _Message_queue_Append ( + Message_queue_Control *the_message_queue, + Message_queue_Buffer_control *the_message +); + +/* + * _Message_queue_Prepend + * + * DESCRIPTION: + * + * This routine places the_message at the rear of the outstanding + * messages on the_message_queue. + */ + +STATIC INLINE void _Message_queue_Prepend ( + Message_queue_Control *the_message_queue, + Message_queue_Buffer_control *the_message +); + +/* + * _Message_queue_Is_null + * + * DESCRIPTION: + * + * This function places the_message at the rear of the outstanding + * messages on the_message_queue. + */ + +STATIC INLINE boolean _Message_queue_Is_null ( + Message_queue_Control *the_message_queue +); + +/* + * _Message_queue_Allocate + * + * DESCRIPTION: + * + * This function allocates a message queue control block from + * the inactive chain of free message queue control blocks. + */ + +STATIC INLINE Message_queue_Control *_Message_queue_Allocate ( void ); + +/* + * _Message_queue_Free + * + * DESCRIPTION: + * + * This routine allocates a message queue control block from + * the inactive chain of free message queue control blocks. + */ + +STATIC INLINE void _Message_queue_Free ( + Message_queue_Control *the_message_queue +); + +/* + * _Message_queue_Get + * + * DESCRIPTION: + * + * This function maps message queue IDs to message queue control + * blocks. If ID corresponds to a local message queue, then it + * returns the_message_queue control pointer which maps to ID + * and location is set to OBJECTS_LOCAL. If the message queue ID is + * global and resides on a remote node, then location is set + * to OBJECTS_REMOTE, and the_message_queue is undefined. + * Otherwise, location is set to OBJECTS_ERROR and + * the_message_queue is undefined. + */ + +STATIC INLINE Message_queue_Control *_Message_queue_Get ( + Objects_Id id, + Objects_Locations *location +); + +#include +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/modes.h b/cpukit/rtems/include/rtems/rtems/modes.h new file mode 100644 index 0000000000..9e714591ab --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/modes.h @@ -0,0 +1,183 @@ +/* modes.h + * + * This include file contains all constants and structures associated + * with the RTEMS thread and RTEMS_ASR modes. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_MODES_h +#define __RTEMS_MODES_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + * The following type defines the control block used to manage + * each a mode set. + */ + +typedef unsigned32 rtems_mode; + +/* + * The following constants define the individual modes and masks + * which may be used to compose a mode set and to alter modes. + */ + +#define RTEMS_ALL_MODE_MASKS 0x0000ffff + +#define RTEMS_DEFAULT_MODES 0x00000000 +#define RTEMS_CURRENT_MODE 0 + +#define RTEMS_PREEMPT_MASK 0x00000100 /* preemption bit */ +#define RTEMS_TIMESLICE_MASK 0x00000200 /* timeslice bit */ +#define RTEMS_ASR_MASK 0x00000400 /* RTEMS_ASR enable bit */ +#define RTEMS_INTERRUPT_MASK CPU_MODES_INTERRUPT_MASK + +#define RTEMS_PREEMPT 0x00000000 /* enable preemption */ +#define RTEMS_NO_PREEMPT 0x00000100 /* disable preemption */ + +#define RTEMS_NO_TIMESLICE 0x00000000 /* disable timeslicing */ +#define RTEMS_TIMESLICE 0x00000200 /* enable timeslicing */ + +#define RTEMS_ASR 0x00000000 /* enable RTEMS_ASR */ +#define RTEMS_NO_ASR 0x00000400 /* disable RTEMS_ASR */ + +/* + * The number of bits for interrupt levels is CPU dependent. + * RTEMS supports 0 to 256 levels in bits 0-7 of the mode. + */ + +/* + * RTEMS_INTERRUPT_LEVEL + * + * DESCRIPTION: + * + * This function returns the processor dependent interrupt + * level which corresponds to the requested interrupt level. + * + * NOTE: RTEMS supports 256 interrupt levels using the least + * significant eight bits of MODES.CONTROL. On any + * particular CPU, fewer than 256 levels may be supported. + */ + +STATIC INLINE unsigned32 RTEMS_INTERRUPT_LEVEL ( + rtems_mode mode_set +); + +/* + * _Modes_Mask_changed + * + * DESCRIPTION: + * + * This function returns TRUE if any of the mode flags in mask + * are set in mode_set, and FALSE otherwise. + */ + +STATIC INLINE boolean _Modes_Mask_changed ( + rtems_mode mode_set, + rtems_mode masks +); + +/* + * _Modes_Is_asr_disabled + * + * DESCRIPTION: + * + * This function returns TRUE if mode_set indicates that Asynchronous + * Signal Processing is disabled, and FALSE otherwise. + */ + +STATIC INLINE boolean _Modes_Is_asr_disabled ( + rtems_mode mode_set +); + +/* + * _Modes_Is_preempt + * + * DESCRIPTION: + * + * This function returns TRUE if mode_set indicates that preemption + * is enabled, and FALSE otherwise. + */ + +STATIC INLINE boolean _Modes_Is_preempt ( + rtems_mode mode_set +); + +/* + * _Modes_Is_timeslice + * + * DESCRIPTION: + * + * This function returns TRUE if mode_set indicates that timeslicing + * is enabled, and FALSE otherwise. + */ + +STATIC INLINE boolean _Modes_Is_timeslice ( + rtems_mode mode_set +); + +/* + * _Modes_Get_interrupt_level + * + * DESCRIPTION: + * + * This function returns the interrupt level portion of the mode_set. + */ + +STATIC INLINE ISR_Level _Modes_Get_interrupt_level ( + rtems_mode mode_set +); + +/* + * _Modes_Set_interrupt_level + * + * DESCRIPTION: + * + * This routine sets the current interrupt level to that specified + * in the mode_set. + */ + +STATIC INLINE void _Modes_Set_interrupt_level ( + rtems_mode mode_set +); + +/* + * _Modes_Change + * + * DESCRIPTION: + * + * This routine changes the modes in old_mode_set indicated by + * mask to the requested values in new_mode_set. The resulting + * mode set is returned in out_mode_set and the modes that changed + * is returned in changed. + */ + +STATIC INLINE void _Modes_Change ( + rtems_mode old_mode_set, + rtems_mode new_mode_set, + rtems_mode mask, + rtems_mode *out_mode_set, + rtems_mode *changed +); + +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/mp.h b/cpukit/rtems/include/rtems/rtems/mp.h new file mode 100644 index 0000000000..96147d3b44 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/mp.h @@ -0,0 +1,67 @@ +/* mp.h + * + * This include file contains all the constants and structures associated + * with the Multiprocessing Manager. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_MP_h +#define __RTEMS_MP_h + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * + * _Multiprocessing_Manager_initialization + * + * DESCRIPTION: + * + * This routine performs the initialization necessary for this manager. + */ + +void _Multiprocessing_Manager_initialization ( void ); + +/* + * + * rtems_multiprocessing_announce + * + * DESCRIPTION: + * + * This routine implements the MULTIPROCESSING_ANNOUNCE directive. + * It is invoked by the MPCI layer to indicate that an MPCI packet + * has been received. + */ + +void rtems_multiprocessing_announce ( void ); + +/* + * + * _Multiprocessing_Receive_server + * + * DESCRIPTION: + * + * This routine is a server thread which processes remote requests + * from other nodes. + */ + +Thread _Multiprocessing_Receive_server ( + Thread_Argument ignored +); + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/msgmp.h b/cpukit/rtems/include/rtems/rtems/msgmp.h new file mode 100644 index 0000000000..486bf00002 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/msgmp.h @@ -0,0 +1,175 @@ +/* msgmp.h + * + * This include file contains all the constants and structures associated + * with the Multiprocessing Support in the Message Manager. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_MESSAGE_QUEUE_MP_h +#define __RTEMS_MESSAGE_QUEUE_MP_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include +#include + +/* + * The following enumerated type defines the list of + * remote message queue operations. + */ + +typedef enum { + MESSAGE_QUEUE_MP_ANNOUNCE_CREATE = 0, + MESSAGE_QUEUE_MP_ANNOUNCE_DELETE = 1, + MESSAGE_QUEUE_MP_EXTRACT_PROXY = 2, + MESSAGE_QUEUE_MP_RECEIVE_REQUEST = 3, + MESSAGE_QUEUE_MP_RECEIVE_RESPONSE = 4, + MESSAGE_QUEUE_MP_SEND_REQUEST = 5, + MESSAGE_QUEUE_MP_SEND_RESPONSE = 6, + MESSAGE_QUEUE_MP_URGENT_REQUEST = 7, + MESSAGE_QUEUE_MP_URGENT_RESPONSE = 8, + MESSAGE_QUEUE_MP_BROADCAST_REQUEST = 9, + MESSAGE_QUEUE_MP_BROADCAST_RESPONSE = 10, + MESSAGE_QUEUE_MP_FLUSH_REQUEST = 11, + MESSAGE_QUEUE_MP_FLUSH_RESPONSE = 12 +} Message_queue_MP_Remote_operations; + +/* + * The following data structure defines the packet used to perform + * remote message queue operations. + */ + +typedef struct { + rtems_packet_prefix Prefix; + Message_queue_MP_Remote_operations operation; + Objects_Name name; + rtems_option option_set; + Objects_Id proxy_id; + unsigned32 count; + unsigned32 pad0; + unsigned32 pad1; + unsigned32 pad2; + Message_queue_Buffer Buffer; +} Message_queue_MP_Packet; + +/* + * _Message_queue_MP_Send_process_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * process operation can be performed on another node. + */ + +void _Message_queue_MP_Send_process_packet ( + Message_queue_MP_Remote_operations operation, + Objects_Id message_queue_id, + Objects_Name name, + Objects_Id proxy_id +); + +/* + * _Message_queue_MP_Send_request_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive operation can be initiated on another node. + */ + +rtems_status_code _Message_queue_MP_Send_request_packet ( + Message_queue_MP_Remote_operations operation, + Objects_Id message_queue_id, + Message_queue_Buffer *buffer, + rtems_option option_set, + rtems_interval timeout +); + +/* + * _Message_queue_MP_Send_response_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive can be performed on another node. + */ + +void _Message_queue_MP_Send_response_packet ( + Message_queue_MP_Remote_operations operation, + Objects_Id message_queue_id, + Thread_Control *the_thread +); + +/* + * + * _Message_queue_MP_Process_packet + * + * DESCRIPTION: + * + * This routine performs the actions specific to this package for + * the request from another node. + */ + +void _Message_queue_MP_Process_packet ( + rtems_packet_prefix *the_packet_prefix +); + +/* + * _Message_queue_MP_Send_object_was_deleted + * + * DESCRIPTION: + * + * This routine is invoked indirectly by the thread queue + * when a proxy has been removed from the thread queue and + * the remote node must be informed of this. + */ + +void _Message_queue_MP_Send_object_was_deleted ( + Thread_Control *the_proxy +); + +/* + * _Message_queue_MP_Send_extract_proxy + * + * DESCRIPTION: + * + * This routine is invoked when a task is deleted and it + * has a proxy which must be removed from a thread queue and + * the remote node must be informed of this. + */ + +void _Message_queue_MP_Send_extract_proxy ( + Thread_Control *the_thread +); + +/* + * _Message_queue_MP_Get_packet + * + * DESCRIPTION: + * + * This function is used to obtain a message queue mp packet. + */ + +Message_queue_MP_Packet *_Message_queue_MP_Get_packet ( void ); + +#ifdef __cplusplus +} +#endif + +#endif +/* end of file */ diff --git a/cpukit/rtems/include/rtems/rtems/options.h b/cpukit/rtems/include/rtems/rtems/options.h new file mode 100644 index 0000000000..b318aad8c9 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/options.h @@ -0,0 +1,79 @@ +/* options.h + * + * This include file contains information which defines the + * options available on many directives. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_OPTIONS_h +#define __RTEMS_OPTIONS_h + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The following type defines the control block used to manage + * option sets. + */ + +typedef unsigned32 rtems_option; + +/* + * The following constants define the individual options which may + * be used to compose an option set. + */ + +#define RTEMS_DEFAULT_OPTIONS 0x00000000 + +#define RTEMS_WAIT 0x00000000 /* wait on resource */ +#define RTEMS_NO_WAIT 0x00000001 /* do not wait on resource */ + +#define RTEMS_EVENT_ALL 0x00000000 /* wait for all events */ +#define RTEMS_EVENT_ANY 0x00000002 /* wait on any event */ + +/* + * _Options_Is_no_wait + * + * DESCRIPTION: + * + * This function returns TRUE if the RTEMS_NO_WAIT option is enabled in + * option_set, and FALSE otherwise. + * + */ + +STATIC INLINE boolean _Options_Is_no_wait ( + rtems_option option_set +); + +/* + * _Options_Is_any + * + * DESCRIPTION: + * + * This function returns TRUE if the RTEMS_EVENT_ANY option is enabled in + * OPTION_SET, and FALSE otherwise. + * + */ + +STATIC INLINE boolean _Options_Is_any ( + rtems_option option_set +); + +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/part.h b/cpukit/rtems/include/rtems/rtems/part.h new file mode 100644 index 0000000000..e639029dc8 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/part.h @@ -0,0 +1,290 @@ +/* partition.h + * + * This include file contains all the constants and structures associated + * with the Partition Manager. This manager provides facilities to + * dynamically allocate memory in fixed-sized units which are returned + * as buffers. + * + * Directives provided are: + * + * + create a partition + * + get an ID of a partition + * + delete a partition + * + get a buffer from a partition + * + return a buffer to a partition + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_PARTITION_h +#define __RTEMS_PARTITION_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +/* + * The following defines the control block used to manage each partition. + */ + +typedef struct { + Objects_Control Object; + void *starting_address; /* physical address */ + unsigned32 length; /* in bytes */ + unsigned32 buffer_size; /* in bytes */ + rtems_attribute attribute_set; /* attributes */ + unsigned32 number_of_used_blocks; /* or allocated buffers */ + Chain_Control Memory; /* buffer chain */ +} Partition_Control; + +/* + * The following defines the information control block used to + * manage this class of objects. + */ + +EXTERN Objects_Information _Partition_Information; + +/* + * _Partition_Manager_initialization + * + * DESCRIPTION: + * + * This routine performs the initialization necessary for this manager. + */ + +void _Partition_Manager_initialization( + unsigned32 maximum_partitions +); + +/* + * rtems_partition_create + * + * DESCRIPTION: + * + * This routine implements the rtems_partition_create directive. The + * partition will have the name name. The memory area managed by + * the partition is of length bytes and starts at starting_address. + * The memory area will be divided into as many buffers of + * buffer_size bytes as possible. The attribute_set determines if + * the partition is global or local. It returns the id of the + * created partition in ID. + */ + +rtems_status_code rtems_partition_create( + Objects_Name name, + void *starting_address, + unsigned32 length, + unsigned32 buffer_size, + rtems_attribute attribute_set, + Objects_Id *id +); + +/* + * rtems_partition_ident + * + * DESCRIPTION: + * + * This routine implements the rtems_partition_ident directive. + * This directive returns the partition ID associated with name. + * If more than one partition is named name, then the partition + * to which the ID belongs is arbitrary. node indicates the + * extent of the search for the ID of the partition named name. + * The search can be limited to a particular node or allowed to + * encompass all nodes. + */ + +rtems_status_code rtems_partition_ident( + Objects_Name name, + unsigned32 node, + Objects_Id *id +); + +/* + * rtems_partition_delete + * + * DESCRIPTION: + * + * This routine implements the rtems_partition_delete directive. The + * partition indicated by ID is deleted. + */ + +rtems_status_code rtems_partition_delete( + Objects_Id id +); + +/* + * rtems_partition_get_buffer + * + * DESCRIPTION: + * + * This routine implements the rtems_partition_get_buffer directive. It + * attempts to allocate a buffer from the partition associated with ID. + * If a buffer is allocated, its address is returned in buffer. + */ + +rtems_status_code rtems_partition_get_buffer( + Objects_Id id, + void **buffer +); + +/* + * rtems_partition_return_buffer + * + * DESCRIPTION: + * + * This routine implements the rtems_partition_return_buffer directive. It + * frees the buffer to the partition associated with ID. The buffer must + * have been previously allocated from the same partition. + */ + +rtems_status_code rtems_partition_return_buffer( + Objects_Id id, + void *buffer +); + +/* + * _Partition_Allocate_buffer + * + * DESCRIPTION: + * + * This function attempts to allocate a buffer from the_partition. + * If successful, it returns the address of the allocated buffer. + * Otherwise, it returns NULL. + */ + +STATIC INLINE void *_Partition_Allocate_buffer ( + Partition_Control *the_partition +); + +/* + * _Partition_Free_buffer + * + * DESCRIPTION: + * + * This routine frees the_buffer to the_partition. + */ + +STATIC INLINE void _Partition_Free_buffer ( + Partition_Control *the_partition, + Chain_Node *the_buffer +); + +/* + * _Partition_Is_buffer_on_boundary + * + * DESCRIPTION: + * + * This function returns TRUE if the_buffer is on a valid buffer + * boundary for the_partition, and FALSE otherwise. + */ + +STATIC INLINE boolean _Partition_Is_buffer_on_boundary ( + void *the_buffer, + Partition_Control *the_partition +); + +/* + * _Partition_Is_buffer_valid + * + * DESCRIPTION: + * + * This function returns TRUE if the_buffer is a valid buffer from + * the_partition, otherwise FALSE is returned. + */ + +STATIC INLINE boolean _Partition_Is_buffer_valid ( + Chain_Node *the_buffer, + Partition_Control *the_partition +); + +/* + * _Partition_Is_buffer_size_aligned + * + * DESCRIPTION: + * + * This function returns TRUE if the use of the specified buffer_size + * will result in the allocation of buffers whose first byte is + * properly aligned, and FALSE otherwise. + */ + +STATIC INLINE boolean _Partition_Is_buffer_size_aligned ( + unsigned32 buffer_size +); + +/* + * _Partition_Allocate + * + * DESCRIPTION: + * + * This function allocates a partition control block from + * the inactive chain of free partition control blocks. + */ + +STATIC INLINE Partition_Control *_Partition_Allocate ( void ); + +/* + * _Partition_Free + * + * DESCRIPTION: + * + * This routine frees a partition control block to the + * inactive chain of free partition control blocks. + */ + +STATIC INLINE void _Partition_Free ( + Partition_Control *the_partition +); + +/* + * _Partition_Get + * + * DESCRIPTION: + * + * This function maps partition IDs to partition control blocks. + * If ID corresponds to a local partition, then it returns + * the_partition control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. If the partition ID is global and + * resides on a remote node, then location is set to OBJECTS_REMOTE, + * and the_partition is undefined. Otherwise, location is set + * to OBJECTS_ERROR and the_partition is undefined. + */ + +STATIC INLINE Partition_Control *_Partition_Get ( + Objects_Id id, + Objects_Locations *location +); + +/* + * _Partition_Is_null + * + * DESCRIPTION: + * + * This function returns TRUE if the_partition is NULL + * and FALSE otherwise. + */ + +STATIC INLINE boolean _Partition_Is_null ( + Partition_Control *the_partition +); + +#include +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/partmp.h b/cpukit/rtems/include/rtems/rtems/partmp.h new file mode 100644 index 0000000000..deacaf7bd1 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/partmp.h @@ -0,0 +1,160 @@ +/* partmp.h + * + * This include file contains all the constants and structures associated + * with the Multiprocessing Support in the Partition Manager. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_PARTITION_MP_h +#define __RTEMS_PARTITION_MP_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include + +/* + * The following enumerated type defines the list of + * remote partition operations. + */ + +typedef enum { + PARTITION_MP_ANNOUNCE_CREATE = 0, + PARTITION_MP_ANNOUNCE_DELETE = 1, + PARTITION_MP_EXTRACT_PROXY = 2, + PARTITION_MP_GET_BUFFER_REQUEST = 3, + PARTITION_MP_GET_BUFFER_RESPONSE = 4, + PARTITION_MP_RETURN_BUFFER_REQUEST = 5, + PARTITION_MP_RETURN_BUFFER_RESPONSE = 6, +} Partition_MP_Remote_operations; + +/* + * The following data structure defines the packet used to perform + * remote partition operations. + */ + +typedef struct { + rtems_packet_prefix Prefix; + Partition_MP_Remote_operations operation; + Objects_Name name; + void *buffer; + Objects_Id proxy_id; +} Partition_MP_Packet; + +/* + * _Partition_MP_Send_process_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * process operation can be performed on another node. + */ + +void _Partition_MP_Send_process_packet ( + Partition_MP_Remote_operations operation, + Objects_Id partition_id, + Objects_Name name, + Objects_Id proxy_id +); + +/* + * _Partition_MP_Send_request_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive operation can be initiated on another node. + */ + +rtems_status_code _Partition_MP_Send_request_packet ( + Partition_MP_Remote_operations operation, + Objects_Id partition_id, + void *buffer +); + +/* + * _Partition_MP_Send_response_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive can be performed on another node. + */ + +void _Partition_MP_Send_response_packet ( + Partition_MP_Remote_operations operation, + Objects_Id partition_id, + Thread_Control *the_thread +); + +/* + * + * _Partition_MP_Process_packet + * + * DESCRIPTION: + * + * This routine performs the actions specific to this package for + * the request from another node. + */ + +void _Partition_MP_Process_packet ( + rtems_packet_prefix *the_packet_prefix +); + +/* + * _Partition_MP_Send_object_was_deleted + * + * DESCRIPTION: + * + * This routine is invoked indirectly by the thread queue + * when a proxy has been removed from the thread queue and + * the remote node must be informed of this. + * + * This routine is not needed by the Partition since a partition + * cannot be deleted when buffers are in use. + */ + +/* + * _Partition_MP_Send_extract_proxy + * + * DESCRIPTION: + * + * This routine is invoked when a task is deleted and it + * has a proxy which must be removed from a thread queue and + * the remote node must be informed of this. + */ + +void _Partition_MP_Send_extract_proxy ( + Thread_Control *the_thread +); + +/* + * _Partition_MP_Get_packet + * + * DESCRIPTION: + * + * This function is used to obtain a partition mp packet. + */ + +Partition_MP_Packet *_Partition_MP_Get_packet ( void ); + +#ifdef __cplusplus +} +#endif + +#endif +/* end of file */ diff --git a/cpukit/rtems/include/rtems/rtems/ratemon.h b/cpukit/rtems/include/rtems/rtems/ratemon.h new file mode 100644 index 0000000000..86acfb9a38 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/ratemon.h @@ -0,0 +1,285 @@ +/* ratemon.h + * + * This include file contains all the constants, structures, and + * prototypes associated with the Rate Monotonic Manager. This manager + * provides facilities to implement tasks which execute in a periodic fashion. + * + * Directives provided are: + * + * + create a rate monotonic timer + * + cancel a period + * + delete a rate monotonic timer + * + conclude current and start the next period + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_RATE_MONOTONIC_h +#define __RTEMS_RATE_MONOTONIC_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +/* + * The following enumerated type defines the states in which a + * period may be. + */ + +typedef enum { + RATE_MONOTONIC_INACTIVE, /* off chain, never initialized */ + RATE_MONOTONIC_ACTIVE, /* on chain, running continuously */ + RATE_MONOTONIC_EXPIRED /* off chain, will be reset by next rm_period */ +} Rate_Monotonic_Period_states; + +/* + * The following constant is the interval passed to the rate_monontonic_period + * directive to obtain status information. + */ + +#define RTEMS_PERIOD_STATUS RTEMS_NO_TIMEOUT + +/* + * The following structure defines the control block used to manage + * each period. + */ + +typedef struct { + Objects_Control Object; + Watchdog_Control Timer; + Rate_Monotonic_Period_states state; + Thread_Control *owner; +} Rate_monotonic_Control; + +EXTERN Objects_Information _Rate_monotonic_Information; + +/* + * _Rate_monotonic_Manager_initialization + * + * DESCRIPTION: + * + * This routine performs the initialization necessary for this manager. + */ + +void _Rate_monotonic_Manager_initialization( + unsigned32 maximum_periods +); + +/* + * rtems_rate_monotonic_create + * + * DESCRIPTION: + * + * This routine implements the rate_monotonic_create directive. The + * period will have the name name. It returns the id of the + * created period in ID. + */ + +rtems_status_code rtems_rate_monotonic_create( + Objects_Name name, + Objects_Id *id +); + +/* + * rtems_rate_monotonic_ident + * + * DESCRIPTION: + * + * This routine implements the rtems_rate_monotonic_ident directive. + * This directive returns the period ID associated with name. + * If more than one period is named name, then the period + * to which the ID belongs is arbitrary. + */ + +rtems_status_code rtems_rate_monotonic_ident( + Objects_Name name, + Objects_Id *id +); + +/* + * rtems_rate_monotonic_cancel + * + * DESCRIPTION: + * + * This routine implements the rtems_rate_monotonic_cancel directive. This + * directive stops the period associated with ID from continuing to + * run. + */ + +rtems_status_code rtems_rate_monotonic_cancel( + Objects_Id id +); + +/* + * rtems_rate_monotonic_delete + * + * DESCRIPTION: + * + * This routine implements the rtems_rate_monotonic_delete directive. The + * period indicated by ID is deleted. + */ + +rtems_status_code rtems_rate_monotonic_delete( + Objects_Id id +); + +/* + * rtems_rate_monotonic_period + * + * DESCRIPTION: + * + * This routine implements the rtems_rate_monotonic_period directive. When + * length is non-zero, this directive initiates the period associated with + * ID from continuing for a period of length. If length is zero, then + * result is set to indicate the current state of the period. + */ + +rtems_status_code rtems_rate_monotonic_period( + Objects_Id id, + rtems_interval length +); + +/* + * _Rate_monotonic_Allocate + * + * DESCRIPTION: + * + * This function allocates a period control block from + * the inactive chain of free period control blocks. + */ + +STATIC INLINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void ); + +/* + * _Rate_monotonic_Free + * + * DESCRIPTION: + * + * This routine allocates a period control block from + * the inactive chain of free period control blocks. + */ + +STATIC INLINE void _Rate_monotonic_Free ( + Rate_monotonic_Control *the_period +); + +/* + * _Rate_monotonic_Get + * + * DESCRIPTION: + * + * This function maps period IDs to period control blocks. + * If ID corresponds to a local period, then it returns + * the_period control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. Otherwise, location is set + * to OBJECTS_ERROR and the_period is undefined. + */ + +STATIC INLINE Rate_monotonic_Control *_Rate_monotonic_Get ( + Objects_Id id, + Objects_Locations *location +); + +/* + * _Rate_monotonic_Set_state + * + * DESCRIPTION: + * + * This function blocks the calling task so that it is waiting for + * a period to expire. It returns TRUE if the task was successfully + * blocked, and FALSE otherwise. + */ + +boolean _Rate_monotonic_Set_state( + Rate_monotonic_Control *the_period +); + +/* + * _Rate_monotonic_Timeout + * + * DESCRIPTION: + * + * This routine is invoked when the period represented + * by ID expires. If the task which owns this period is blocked + * waiting for the period to expire, then it is readied and the + * period is restarted. If the owning task is not waiting for the + * period to expire, then the period is placed in the EXPIRED + * state and not restarted. + */ + +void _Rate_monotonic_Timeout ( + Objects_Id id, + void *ignored +); + +/* + * _Rate_monotonic_Is_active + * + * DESCRIPTION: + * + * This function returns TRUE if the_period is in the ACTIVE state, + * and FALSE otherwise. + */ + +STATIC INLINE boolean _Rate_monotonic_Is_active ( + Rate_monotonic_Control *the_period +); + +/* + * _Rate_monotonic_Is_inactive + * + * DESCRIPTION: + * + * This function returns TRUE if the_period is in the ACTIVE state, + * and FALSE otherwise. + */ + +STATIC INLINE boolean _Rate_monotonic_Is_inactive ( + Rate_monotonic_Control *the_period +); + +/* + * _Rate_monotonic_Is_expired + * + * DESCRIPTION: + * + * This function returns TRUE if the_period is in the EXPIRED state, + * and FALSE otherwise. + */ + +STATIC INLINE boolean _Rate_monotonic_Is_expired ( + Rate_monotonic_Control *the_period +); + +/* + * _Rate_monotonic_Is_null + * + * DESCRIPTION: + * + * This function returns TRUE if the_period is NULL and FALSE otherwise. + */ + +STATIC INLINE boolean _Rate_monotonic_Is_null ( + Rate_monotonic_Control *the_period +); + +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/region.h b/cpukit/rtems/include/rtems/rtems/region.h new file mode 100644 index 0000000000..c31e193c33 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/region.h @@ -0,0 +1,311 @@ +/* region.h + * + * This include file contains all the constants and structures associated + * with the Region Manager. This manager provides facilities to dynamically + * allocate memory in variable sized units which are returned as segments. + * + * Directives provided are: + * + * + create a region + * + get an ID of a region + * + delete a region + * + get a segment from a region + * + return a segment to a region + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_REGION_h +#define __RTEMS_REGION_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include + +/* + * The following records define the control block used to manage + * each region. + */ + +typedef struct { + Objects_Control Object; + Thread_queue_Control Wait_queue; /* waiting threads */ + void *starting_address; /* physical start addr */ + unsigned32 length; /* physical length(bytes) */ + unsigned32 page_size; /* in bytes */ + unsigned32 maximum_segment_size; /* in bytes */ + rtems_attribute attribute_set; + unsigned32 number_of_used_blocks; /* blocks allocated */ + Heap_Control Memory; +} Region_Control; + +/* + * The following defines the information control block used to + * manage this class of objects. + */ + +EXTERN Objects_Information _Region_Information; + +/* + * _Region_Manager_initialization + * + * DESCRIPTION: + * + * This routine performs the initialization necessary for this manager. + */ + +void _Region_Manager_initialization( + unsigned32 maximum_regions +); + +/* + * rtems_region_create + * + * DESCRIPTION: + * + * This routine implements the rtems_region_create directive. The + * region will have the name name. The memory area managed by + * the region is of length bytes and starts at starting_address. + * The memory area will be divided into as many allocatable units of + * page_size bytes as possible. The attribute_set determines which + * thread queue discipline is used by the region. It returns the + * id of the created region in ID. + */ + +rtems_status_code rtems_region_create( + Objects_Name name, + void *starting_address, + unsigned32 length, + unsigned32 page_size, + rtems_attribute attribute_set, + Objects_Id *id +); + +/* + * rtems_region_extend + * + * DESCRIPTION: + * + * This routine implements the rtems_region_extend directive. The + * region will have the name name. The memory area managed by + * the region will be attempted to be grown by length bytes using + * the memory starting at starting_address. + */ + +rtems_status_code rtems_region_extend( + Objects_Id id, + void *starting_address, + unsigned32 length +); + +/* + * rtems_region_ident + * + * DESCRIPTION: + * + * This routine implements the rtems_region_ident directive. + * This directive returns the region ID associated with name. + * If more than one region is named name, then the region + * to which the ID belongs is arbitrary. + */ + +rtems_status_code rtems_region_ident( + Objects_Name name, + Objects_Id *id +); + +/* + * rtems_region_delete + * + * DESCRIPTION: + * + * This routine implements the rtems_region_delete directive. The + * region indicated by ID is deleted. + */ + +rtems_status_code rtems_region_delete( + Objects_Id id +); + +/* + * rtems_region_get_segment + * + * DESCRIPTION: + * + * This routine implements the rtems_region_get_segment directive. It + * attempts to allocate a segment from the region associated with ID. + * If a segment of the requested size can be allocated, its address + * is returned in segment. If no segment is available, then the task + * may return immediately or block waiting for a segment with an optional + * timeout of timeout clock ticks. Whether the task blocks or returns + * immediately is based on the no_wait option in the option_set. + */ + +rtems_status_code rtems_region_get_segment( + Objects_Id id, + unsigned32 size, + rtems_option option_set, + rtems_interval timeout, + void **segment +); + +/* + * rtems_region_get_segment_size + * + * DESCRIPTION: + * + * This routine implements the rtems_region_get_segment_size directive. It + * returns the size in bytes of the specified user memory area. + */ + +rtems_status_code rtems_region_get_segment_size( + Objects_Id id, + void *segment, + unsigned32 *size +); + +/* + * rtems_region_return_segment + * + * DESCRIPTION: + * + * This routine implements the rtems_region_return_segment directive. It + * frees the segment to the region associated with ID. The segment must + * have been previously allocated from the same region. If freeing the + * segment results in enough memory being available to satisfy the + * rtems_region_get_segment of the first blocked task, then that task and as + * many subsequent tasks as possible will be unblocked with their requests + * satisfied. + */ + +rtems_status_code rtems_region_return_segment( + Objects_Id id, + void *segment +); + +/* + * _Region_Allocate + * + * DESCRIPTION: + * + * This function allocates a region control block from + * the inactive chain of free region control blocks. + */ + +STATIC INLINE Region_Control *_Region_Allocate( void ); + +/* + * _Region_Free + * + * DESCRIPTION: + * + * This routine frees a region control block to the + * inactive chain of free region control blocks. + */ + +STATIC INLINE void _Region_Free ( + Region_Control *the_region +); + +/* + * _Region_Get + * + * DESCRIPTION: + * + * This function maps region IDs to region control blocks. + * If ID corresponds to a local region, then it returns + * the_region control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. Otherwise, location is set + * to OBJECTS_ERROR and the_region is undefined. + */ + +STATIC INLINE Region_Control *_Region_Get ( + Objects_Id id, + Objects_Locations *location +); + +/* + * _Region_Allocate_segment + * + * DESCRIPTION: + * + * This function attempts to allocate a segment from the_region. + * If successful, it returns the address of the allocated segment. + * Otherwise, it returns NULL. + */ + +STATIC INLINE void *_Region_Allocate_segment ( + Region_Control *the_region, + unsigned32 size +); + +/* + * _Region_Free_segment + * + * DESCRIPTION: + * + * This function frees the_segment to the_region. + */ + +STATIC INLINE boolean _Region_Free_segment ( + Region_Control *the_region, + void *the_segment +); + +/* + * _Region_Is_null + * + * DESCRIPTION: + * + * This function returns TRUE if the_region is NULL and FALSE otherwise. + */ + +STATIC INLINE boolean _Region_Is_null ( + Region_Control *the_region +); + +#include +#include + +/* + * _Region_Debug_Walk + * + * DESCRIPTION: + * + * This routine is invoked to verify the integrity of a heap associated + * with the_region. + */ + +#ifdef RTEMS_DEBUG + +#define _Region_Debug_Walk( _the_region, _source ) \ + do { \ + if ( _Debug_Is_enabled( RTEMS_DEBUG_REGION ) ) \ + _Heap_Walk( &(_the_region)->Memory, _source, FALSE ); \ + } while ( 0 ) + +#else + +#define _Region_Debug_Walk( _the_region, _source ) + +#endif + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/regionmp.h b/cpukit/rtems/include/rtems/rtems/regionmp.h new file mode 100644 index 0000000000..2810656078 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/regionmp.h @@ -0,0 +1,165 @@ +/* regionmp.h + * + * This include file contains all the constants and structures associated + * with the Multiprocessing Support in the Region Manager. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_REGION_MP_h +#define __RTEMS_REGION_MP_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include + +/* + * The following enumerated type defines the list of + * remote region operations. + */ + +typedef enum { + REGION_MP_ANNOUNCE_CREATE = 0, + REGION_MP_ANNOUNCE_DELETE = 1, + REGION_MP_EXTRACT_PROXY = 2, + REGION_MP_GET_SEGMENT_REQUEST = 3, + REGION_MP_GET_SEGMENT_RESPONSE = 4, + REGION_MP_RETURN_SEGMENT_REQUEST = 5, + REGION_MP_RETURN_SEGMENT_RESPONSE = 6, +} Region_MP_Remote_operations; + +/* + * The following data structure defines the packet used to perform + * remote region operations. + */ + +typedef struct { + rtems_packet_prefix Prefix; + Region_MP_Remote_operations operation; + Objects_Name name; + rtems_option option_set; + unsigned32 size; + Objects_Id proxy_id; + void *segment; +} Region_MP_Packet; + +/* + * _Region_MP_Send_process_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * process operation can be performed on another node. + */ + +void _Region_MP_Send_process_packet ( + Region_MP_Remote_operations operation, + Objects_Id region_id, + Objects_Name name, + Objects_Id proxy_id +); + +/* + * _Region_MP_Send_request_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive operation can be initiated on another node. + */ + +rtems_status_code _Region_MP_Send_request_packet ( + Region_MP_Remote_operations operation, + Objects_Id region_id, + void *segment, + unsigned32 size, + rtems_option option_set, + rtems_interval timeout +); + +/* + * _Region_MP_Send_response_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive can be performed on another node. + */ + +void _Region_MP_Send_response_packet ( + Region_MP_Remote_operations operation, + Objects_Id region_id, + Thread_Control *the_thread +); + +/* + * + * _Region_MP_Process_packet + * + * DESCRIPTION: + * + * This routine performs the actions specific to this package for + * the request from another node. + */ + +void _Region_MP_Process_packet ( + rtems_packet_prefix *the_packet_prefix +); + +/* + * _Region_MP_Send_object_was_deleted + * + * DESCRIPTION: + * + * This routine is invoked indirectly by the thread queue + * when a proxy has been removed from the thread queue and + * the remote node must be informed of this. + * + * This routine is not needed by the Region since a region + * cannot be deleted when segments are in use. + */ + +/* + * _Region_MP_Send_extract_proxy + * + * DESCRIPTION: + * + * This routine is invoked when a task is deleted and it + * has a proxy which must be removed from a thread queue and + * the remote node must be informed of this. + */ + +void _Region_MP_Send_extract_proxy ( + Thread_Control *the_thread +); + +/* + * _Region_MP_Get_packet + * + * DESCRIPTION: + * + * This function is used to obtain a region mp packet. + */ + +Region_MP_Packet *_Region_MP_Get_packet ( void ); + +#ifdef __cplusplus +} +#endif + +#endif +/* end of file */ diff --git a/cpukit/rtems/include/rtems/rtems/sem.h b/cpukit/rtems/include/rtems/rtems/sem.h new file mode 100644 index 0000000000..66f5ab82b8 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/sem.h @@ -0,0 +1,238 @@ +/* semaphore.h + * + * This include file contains all the constants and structures associated + * with the Semaphore Manager. This manager utilizes standard Dijkstra + * counting semaphores to provide synchronization and mutual exclusion + * capabilities. + * + * Directives provided are: + * + * + create a semaphore + * + get an ID of a semaphore + * + delete a semaphore + * + acquire a semaphore + * + release a semaphore + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_SEMAPHORE_h +#define __RTEMS_SEMAPHORE_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +/* + * The following defines the control block used to manage each semaphore. + */ + +typedef struct { + Objects_Control Object; + Thread_queue_Control Wait_queue; + rtems_attribute attribute_set; + unsigned32 count; + unsigned32 nest_count; + Thread_Control *holder; + Objects_Id holder_id; +} Semaphore_Control; + +/* + * The following defines the information control block used to manage + * this class of objects. + */ + +EXTERN Objects_Information _Semaphore_Information; + +/* + * _Semaphore_Manager_initialization + * + * DESCRIPTION: + * + * This routine performs the initialization necessary for this manager. + */ + +void _Semaphore_Manager_initialization( + unsigned32 maximum_semaphores +); + +/* + * rtems_semaphore_create + * + * DESCRIPTION: + * + * This routine implements the rtems_semaphore_create directive. The + * semaphore will have the name name. The starting count for + * the semaphore is count. The attribute_set determines if + * the semaphore is global or local and the thread queue + * discipline. It returns the id of the created semaphore in ID. + */ + +rtems_status_code rtems_semaphore_create( + Objects_Name name, + unsigned32 count, + rtems_attribute attribute_set, + Objects_Id *id +); + +/* + * rtems_semaphore_ident + * + * DESCRIPTION: + * + * This routine implements the rtems_semaphore_ident directive. + * This directive returns the semaphore ID associated with name. + * If more than one semaphore is named name, then the semaphore + * to which the ID belongs is arbitrary. node indicates the + * extent of the search for the ID of the semaphore named name. + * The search can be limited to a particular node or allowed to + * encompass all nodes. + */ + +rtems_status_code rtems_semaphore_ident( + Objects_Name name, + unsigned32 node, + Objects_Id *id +); + +/* + * rtems_semaphore_delete + * + * DESCRIPTION: + * + * This routine implements the rtems_semaphore_delete directive. The + * semaphore indicated by ID is deleted. + */ + +rtems_status_code rtems_semaphore_delete( + Objects_Id id +); + +/* + * rtems_semaphore_obtain + * + * DESCRIPTION: + * + * This routine implements the rtems_semaphore_obtain directive. It + * attempts to obtain a unit from the semaphore associated with ID. + * If a unit can be allocated, the calling task will return immediately. + * If no unit is available, then the task may return immediately or + * block waiting for a unit with an optional timeout of timeout + * clock ticks. Whether the task blocks or returns immediately + * is based on the RTEMS_NO_WAIT option in the option_set. + */ + +rtems_status_code rtems_semaphore_obtain( + Objects_Id id, + unsigned32 option_set, + rtems_interval timeout +); + +/* + * rtems_semaphore_release + * + * DESCRIPTION: + * + * This routine implements the rtems_semaphore_release directive. It + * frees a unit to the semaphore associated with ID. If a task was + * blocked waiting for a unit from this semaphore, then that task will + * be readied and the unit given to that task. Otherwise, the unit + * will be returned to the semaphore. + */ + +rtems_status_code rtems_semaphore_release( + Objects_Id id +); + +/* + * _Semaphore_Seize + * + * DESCRIPTION: + * + * This routine attempts to receive a unit from the_semaphore. + * If a unit is available or if the RTEMS_NO_WAIT option is enabled in + * option_set, then the routine returns. Otherwise, the calling task + * is blocked until a unit becomes available. + */ + +boolean _Semaphore_Seize( + Semaphore_Control *the_semaphore, + unsigned32 option_set +); + +/* + * _Semaphore_Allocate + * + * DESCRIPTION: + * + * This function allocates a semaphore control block from + * the inactive chain of free semaphore control blocks. + */ + +STATIC INLINE Semaphore_Control *_Semaphore_Allocate( void ); + +/* + * _Semaphore_Free + * + * DESCRIPTION: + * + * This routine frees a semaphore control block to the + * inactive chain of free semaphore control blocks. + */ + +STATIC INLINE void _Semaphore_Free ( + Semaphore_Control *the_semaphore +); + +/* + * _Semaphore_Get + * + * DESCRIPTION: + * + * This function maps semaphore IDs to semaphore control blocks. + * If ID corresponds to a local semaphore, then it returns + * the_semaphore control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. if the semaphore ID is global and + * resides on a remote node, then location is set to OBJECTS_REMOTE, + * and the_semaphore is undefined. Otherwise, location is set + * to OBJECTS_ERROR and the_semaphore is undefined. + */ + +STATIC INLINE Semaphore_Control *_Semaphore_Get ( + Objects_Id id, + Objects_Locations *location +); + +/* + * _Semaphore_Is_null + * + * DESCRIPTION: + * + * This function returns TRUE if the_semaphore is NULL and FALSE otherwise. + */ + +STATIC INLINE boolean _Semaphore_Is_null ( + Semaphore_Control *the_semaphore +); + +#include +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/semmp.h b/cpukit/rtems/include/rtems/rtems/semmp.h new file mode 100644 index 0000000000..2d0554c8cc --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/semmp.h @@ -0,0 +1,163 @@ +/* semmp.h + * + * This include file contains all the constants and structures associated + * with the Multiprocessing Support in the Semaphore Manager. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_SEMAPHORE_MP_h +#define __RTEMS_SEMAPHORE_MP_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include +#include + +/* + * The following enumerated type defines the list of + * remote semaphore operations. + */ + +typedef enum { + SEMAPHORE_MP_ANNOUNCE_CREATE = 0, + SEMAPHORE_MP_ANNOUNCE_DELETE = 1, + SEMAPHORE_MP_EXTRACT_PROXY = 2, + SEMAPHORE_MP_OBTAIN_REQUEST = 3, + SEMAPHORE_MP_OBTAIN_RESPONSE = 4, + SEMAPHORE_MP_RELEASE_REQUEST = 5, + SEMAPHORE_MP_RELEASE_RESPONSE = 6, +} Semaphore_MP_Remote_operations; + +/* + * The following data structure defines the packet used to perform + * remote semaphore operations. + */ + +typedef struct { + rtems_packet_prefix Prefix; + Semaphore_MP_Remote_operations operation; + Objects_Name name; + rtems_option option_set; + Objects_Id proxy_id; +} Semaphore_MP_Packet; + +/* + * _Semaphore_MP_Send_process_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * process operation can be performed on another node. + */ + +void _Semaphore_MP_Send_process_packet ( + Semaphore_MP_Remote_operations operation, + Objects_Id semaphore_id, + Objects_Name name, + Objects_Id proxy_id +); + +/* + * _Semaphore_MP_Send_request_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive operation can be initiated on another node. + */ + +rtems_status_code _Semaphore_MP_Send_request_packet ( + Semaphore_MP_Remote_operations operation, + Objects_Id semaphore_id, + rtems_option option_set, + rtems_interval timeout +); + +/* + * _Semaphore_MP_Send_response_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive can be performed on another node. + */ + +void _Semaphore_MP_Send_response_packet ( + Semaphore_MP_Remote_operations operation, + Objects_Id semaphore_id, + Thread_Control *the_thread +); + +/* + * + * _Semaphore_MP_Process_packet + * + * DESCRIPTION: + * + * This routine performs the actions specific to this package for + * the request from another node. + */ + +void _Semaphore_MP_Process_packet ( + rtems_packet_prefix *the_packet_prefix +); + +/* + * _Semaphore_MP_Send_object_was_deleted + * + * DESCRIPTION: + * + * This routine is invoked indirectly by the thread queue + * when a proxy has been removed from the thread queue and + * the remote node must be informed of this. + */ + +void _Semaphore_MP_Send_object_was_deleted ( + Thread_Control *the_proxy +); + +/* + * _Semaphore_MP_Send_extract_proxy + * + * DESCRIPTION: + * + * This routine is invoked when a task is deleted and it + * has a proxy which must be removed from a thread queue and + * the remote node must be informed of this. + */ + +void _Semaphore_MP_Send_extract_proxy ( + Thread_Control *the_thread +); + +/* + * _Semaphore_MP_Get_packet + * + * DESCRIPTION: + * + * This function is used to obtain a semaphore mp packet. + */ + +Semaphore_MP_Packet *_Semaphore_MP_Get_packet ( void ); + +#ifdef __cplusplus +} +#endif + +#endif +/* end of file */ diff --git a/cpukit/rtems/include/rtems/rtems/signal.h b/cpukit/rtems/include/rtems/rtems/signal.h new file mode 100644 index 0000000000..2466a8f931 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/signal.h @@ -0,0 +1,72 @@ +/* signal.h + * + * This include file contains all the constants and structures associated + * with the Signal Manager. This manager provides capabilities required + * for asynchronous communication between tasks via signal sets. + * + * Directives provided are: + * + * + establish an asynchronous signal routine + * + send a signal set to a task + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_SIGNAL_h +#define __RTEMS_SIGNAL_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include + +/* + * rtems_signal_catch + * + * DESCRIPTION: + * + * This routine implements the rtems_signal_catch directive. This directive + * is used to establish asr_handler as the Asynchronous Signal Routine + * (RTEMS_ASR) for the calling task. The asr_handler will execute with a + * mode of mode_set. + */ + +rtems_status_code rtems_signal_catch( + rtems_asr_entry asr_handler, + rtems_mode mode_set +); + +/* + * rtems_signal_send + * + * DESCRIPTION: + * + * This routine implements the rtems_signal_send directive. This directive + * sends the signal_set to the task specified by ID. + */ + +rtems_status_code rtems_signal_send( + Objects_Id id, + rtems_signal_set signal_set +); + +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/signalmp.h b/cpukit/rtems/include/rtems/rtems/signalmp.h new file mode 100644 index 0000000000..36a2d81594 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/signalmp.h @@ -0,0 +1,147 @@ +/* signalmp.h + * + * This include file contains all the constants and structures associated + * with the Multiprocessing Support in the Signal Manager. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_SIGNAL_MP_h +#define __RTEMS_SIGNAL_MP_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include + +/* + * The following enumerated type defines the list of + * remote signal operations. + */ + +typedef enum { + SIGNAL_MP_SEND_REQUEST = 0, + SIGNAL_MP_SEND_RESPONSE = 1, +} Signal_MP_Remote_operations; + +/* + * The following data structure defines the packet used to perform + * remote signal operations. + */ + +typedef struct { + rtems_packet_prefix Prefix; + Signal_MP_Remote_operations operation; + rtems_signal_set signal_in; +} Signal_MP_Packet; + +/* + * _Signal_MP_Send_process_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * process operation can be performed on another node. + * + * This routine is not needed since there are no process + * packets to be sent by this manager. + */ + +/* + * _Signal_MP_Send_request_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive operation can be initiated on another node. + */ + +rtems_status_code _Signal_MP_Send_request_packet ( + Signal_MP_Remote_operations operation, + Objects_Id task_id, + rtems_signal_set signal_in +); + +/* + * _Signal_MP_Send_response_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive can be performed on another node. + */ + +void _Signal_MP_Send_response_packet ( + Signal_MP_Remote_operations operation, + Thread_Control *the_thread +); + +/* + * + * _Signal_MP_Process_packet + * + * DESCRIPTION: + * + * This routine performs the actions specific to this package for + * the request from another node. + */ + +void _Signal_MP_Process_packet ( + rtems_packet_prefix *the_packet_prefix +); + +/* + * _Signal_MP_Send_object_was_deleted + * + * DESCRIPTION: + * + * This routine is invoked indirectly by the thread queue + * when a proxy has been removed from the thread queue and + * the remote node must be informed of this. + * + * This routine is not needed since there are no objects + * deleted by this manager. + */ + +/* + * _Signal_MP_Send_extract_proxy + * + * DESCRIPTION: + * + * This routine is invoked when a task is deleted and it + * has a proxy which must be removed from a thread queue and + * the remote node must be informed of this. + * + * This routine is not needed since there are no objects + * deleted by this manager. + */ + +/* + * _Signal_MP_Get_packet + * + * DESCRIPTION: + * + * This function is used to obtain a signal mp packet. + */ + +Signal_MP_Packet *_Signal_MP_Get_packet ( void ); + +#ifdef __cplusplus +} +#endif + +#endif +/* end of file */ diff --git a/cpukit/rtems/include/rtems/rtems/status.h b/cpukit/rtems/include/rtems/rtems/status.h new file mode 100644 index 0000000000..42b8754780 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/status.h @@ -0,0 +1,109 @@ +/* status.h + * + * This include file contains the status codes returned from the + * executive directives. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_STATUS_h +#define __RTEMS_STATUS_h + +#ifdef __cplusplus +extern "C" { +#endif + +/* types */ + +/* enumerated constants */ + +typedef enum { + RTEMS_SUCCESSFUL = 0, /* successful completion */ + RTEMS_TASK_EXITTED = 1, /* returned from a thread */ + RTEMS_MP_NOT_CONFIGURED = 2, /* multiprocessing not configured */ + RTEMS_INVALID_NAME = 3, /* invalid object name */ + RTEMS_INVALID_ID = 4, /* invalid object id */ + RTEMS_TOO_MANY = 5, /* too many */ + RTEMS_TIMEOUT = 6, /* timed out waiting */ + RTEMS_OBJECT_WAS_DELETED = 7, /* object deleted while waiting */ + RTEMS_INVALID_SIZE = 8, /* specified size was invalid */ + RTEMS_INVALID_ADDRESS = 9, /* address specified is invalid */ + RTEMS_INVALID_NUMBER = 10, /* number was invalid */ + RTEMS_NOT_DEFINED = 11, /* item has not been initialized */ + RTEMS_RESOURCE_IN_USE = 12, /* resources still outstanding */ + RTEMS_UNSATISFIED = 13, /* request not satisfied */ + RTEMS_INCORRECT_STATE = 14, /* thread is in wrong state */ + RTEMS_ALREADY_SUSPENDED = 15, /* thread already in state */ + RTEMS_ILLEGAL_ON_SELF = 16, /* illegal on calling thread */ + RTEMS_ILLEGAL_ON_REMOTE_OBJECT = 17, /* illegal for remote object */ + RTEMS_CALLED_FROM_ISR = 18, /* called from wrong environment */ + RTEMS_INVALID_PRIORITY = 19, /* invalid thread priority */ + RTEMS_INVALID_CLOCK = 20, /* invalid date/time */ + RTEMS_INVALID_NODE = 21, /* invalid node id */ + RTEMS_NOT_CONFIGURED = 22, /* directive not configured */ + RTEMS_NOT_OWNER_OF_RESOURCE = 23, /* not owner of resource */ + RTEMS_NOT_IMPLEMENTED = 24, /* directive not implemented */ + RTEMS_INTERNAL_ERROR = 25, /* RTEMS inconsistency detected */ + RTEMS_PROXY_BLOCKING = 26, /* internal multiprocessing only */ + RTEMS_NO_MEMORY = 27 /* could not get enough memory */ +} rtems_status_code; + +#define RTEMS_STATUS_CODES_FIRST RTEMS_SUCCESSFUL +#define RTEMS_STATUS_CODES_LAST RTEMS_NO_MEMORY + +/* + * rtems_is_status_successful + * + * DESCRIPTION: + * + * This function returns TRUE if the status code is equal to RTEMS_SUCCESSFUL, + * and FALSE otherwise. + */ + +STATIC INLINE boolean rtems_is_status_successful ( + rtems_status_code code +); + +/* + * rtems_are_statuses_equal + * + * DESCRIPTION: + * + * This function returns TRUE if the status code1 is equal to code2, + * and FALSE otherwise. + */ + +STATIC INLINE boolean rtems_are_statuses_equal ( + rtems_status_code code1, + rtems_status_code code2 +); + +/* + * _Status_Is_proxy_blocking + * + * DESCRIPTION: + * + * This function returns TRUE if the status code is equal to the + * status which indicates that a proxy is blocking, and FALSE otherwise. + */ + +STATIC INLINE boolean _Status_Is_proxy_blocking ( + rtems_status_code code +); + +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/taskmp.h b/cpukit/rtems/include/rtems/rtems/taskmp.h new file mode 100644 index 0000000000..57ab50c630 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/taskmp.h @@ -0,0 +1,167 @@ +/* taskmp.h + * + * This include file contains all the constants and structures associated + * with the multiprocessing support in the task manager. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_RTEMS_TASKS_MP_h +#define __RTEMS_RTEMS_TASKS_MP_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include +#include + +/* + * The following enumerated type defines the list of + * remote task operations. + */ + +typedef enum { + RTEMS_TASKS_MP_ANNOUNCE_CREATE = 0, + RTEMS_TASKS_MP_ANNOUNCE_DELETE = 1, + RTEMS_TASKS_MP_SUSPEND_REQUEST = 2, + RTEMS_TASKS_MP_SUSPEND_RESPONSE = 3, + RTEMS_TASKS_MP_RESUME_REQUEST = 4, + RTEMS_TASKS_MP_RESUME_RESPONSE = 5, + RTEMS_TASKS_MP_SET_PRIORITY_REQUEST = 6, + RTEMS_TASKS_MP_SET_PRIORITY_RESPONSE = 7, + RTEMS_TASKS_MP_GET_NOTE_REQUEST = 8, + RTEMS_TASKS_MP_GET_NOTE_RESPONSE = 9, + RTEMS_TASKS_MP_SET_NOTE_REQUEST = 10, + RTEMS_TASKS_MP_SET_NOTE_RESPONSE = 11, +} RTEMS_tasks_MP_Remote_operations; + +/* + * The following data structure defines the packet used to perform + * remote task operations. + */ + +typedef struct { + rtems_packet_prefix Prefix; + RTEMS_tasks_MP_Remote_operations operation; + Objects_Name name; + rtems_task_priority the_priority; + unsigned32 notepad; + unsigned32 note; +} RTEMS_tasks_MP_Packet; + +/* + * _RTEMS_tasks_MP_Send_process_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * process operation can be performed on another node. + */ + +void _RTEMS_tasks_MP_Send_process_packet ( + RTEMS_tasks_MP_Remote_operations operation, + Objects_Id task_id, + Objects_Name name +); + +/* + * _RTEMS_tasks_MP_Send_request_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive operation can be initiated on another node. + */ + +rtems_status_code _RTEMS_tasks_MP_Send_request_packet ( + RTEMS_tasks_MP_Remote_operations operation, + Objects_Id task_id, + rtems_task_priority the_priority, + unsigned32 notepad, + unsigned32 note +); + +/* + * _RTEMS_tasks_MP_Send_response_packet + * + * DESCRIPTION: + * + * This routine performs a remote procedure call so that a + * directive can be performed on another node. + */ + +void _RTEMS_tasks_MP_Send_response_packet ( + RTEMS_tasks_MP_Remote_operations operation, + Thread_Control *the_thread +); + +/* + * + * _RTEMS_tasks_MP_Process_packet + * + * DESCRIPTION: + * + * This routine performs the actions specific to this package for + * the request from another node. + */ + +void _RTEMS_tasks_MP_Process_packet ( + rtems_packet_prefix *the_packet_prefix +); + +/* + * _RTEMS_tasks_MP_Send_object_was_deleted + * + * DESCRIPTION: + * + * This routine is invoked indirectly by the thread queue + * when a proxy has been removed from the thread queue and + * the remote node must be informed of this. + * + * This routine is not needed by RTEMS_tasks since a task + * cannot be deleted when segments are in use. + */ + +/* + * _RTEMS_tasks_MP_Send_extract_proxy + * + * DESCRIPTION: + * + * This routine is invoked when a task is deleted and it + * has a proxy which must be removed from a thread queue and + * the remote node must be informed of this. + * + * This routine is not needed since there are no objects + * deleted by this manager. + * + */ + +/* + * _RTEMS_tasks_MP_Get_packet + * + * DESCRIPTION: + * + * This function is used to obtain a task mp packet. + */ + +RTEMS_tasks_MP_Packet *_RTEMS_tasks_MP_Get_packet ( void ); + +#ifdef __cplusplus +} +#endif + +#endif +/* end of file */ diff --git a/cpukit/rtems/include/rtems/rtems/tasks.h b/cpukit/rtems/include/rtems/rtems/tasks.h new file mode 100644 index 0000000000..d92913548e --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/tasks.h @@ -0,0 +1,315 @@ +/* tasks.h + * + * This include file contains all constants and structures associated + * with RTEMS tasks. This manager provides a comprehensive set of directives + * to create, delete, and administer tasks. + * + * Directives provided are: + * + * + create a task + * + get an ID of a task + * + start a task + * + restart a task + * + delete a task + * + suspend a task + * + resume a task + * + set a task's priority + * + change the current task's mode + * + get a task notepad entry + * + set a task notepad entry + * + wake up after interval + * + wake up when specified + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_RTEMS_TASKS_h +#define __RTEMS_RTEMS_TASKS_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * Constant to be used as the ID of current task + */ + +#define RTEMS_SELF OBJECTS_ID_OF_SELF + +/* + * This constant is passed to the rtems_task_wake_after directive as the + * interval when a task wishes to yield the CPU. + */ + +#define RTEMS_YIELD_PROCESSOR RTEMS_NO_TIMEOUT + +/* + * rtems_task_create + * + * DESCRIPTION: + * + * This routine implements the rtems_task_create directive. The task + * will have the name name. The attribute_set can be used to indicate + * that the task will be globally accessible or utilize floating point. + * The task's stack will be stack_size bytes. The task will begin + * execution with initial_priority and initial_modes. It returns the + * id of the created task in ID. + */ + +rtems_status_code rtems_task_create( + Objects_Name name, + rtems_task_priority initial_priority, + unsigned32 stack_size, + rtems_mode initial_modes, + rtems_attribute attribute_set, + Objects_Id *id +); + +/* + * rtems_task_ident + * + * DESCRIPTION: + * + * This routine implements the rtems_task_ident directive. + * This directive returns the task ID associated with name. + * If more than one task is named name, then the task to + * which the ID belongs is arbitrary. node indicates the + * extent of the search for the ID of the task named name. + * The search can be limited to a particular node or allowed to + * encompass all nodes. + */ + +rtems_status_code rtems_task_ident( + Objects_Name name, + unsigned32 node, + Objects_Id *id +); + +/* + * rtems_task_delete + * + * DESCRIPTION: + * + * This routine implements the rtems_task_delete directive. The + * task indicated by ID is deleted. + */ + +rtems_status_code rtems_task_delete( + Objects_Id id +); + +/* + * rtems_task_get_note + * + * DESCRIPTION: + * + * This routine implements the rtems_task_get_note directive. The + * value of the indicated notepad for the task associated with ID + * is returned in note. + */ + +rtems_status_code rtems_task_get_note( + Objects_Id id, + unsigned32 notepad, + unsigned32 *note +); + +/* + * rtems_task_set_note + * + * DESCRIPTION: + * + * This routine implements the rtems_task_set_note directive. The + * value of the indicated notepad for the task associated with ID + * is returned in note. + */ + +rtems_status_code rtems_task_set_note( + Objects_Id id, + unsigned32 notepad, + unsigned32 note +); + +/* + * rtems_task_mode + * + * DESCRIPTION: + * + * This routine implements the rtems_task_mode directive. The current + * values of the modes indicated by mask of the calling task are changed + * to that indicated in mode_set. The former mode of the task is + * returned in mode_set. + */ + +rtems_status_code rtems_task_mode( + rtems_mode mode_set, + rtems_mode mask, + rtems_mode *previous_mode_set +); + +/* + * rtems_task_restart + * + * DESCRIPTION: + * + * This routine implements the rtems_task_restart directive. The + * task associated with ID is restarted at its initial entry + * point with the new argument. + */ + +rtems_status_code rtems_task_restart( + Objects_Id id, + unsigned32 arg +); + +/* + * rtems_task_suspend + * + * DESCRIPTION: + * + * This routine implements the rtems_task_suspend directive. The + * SUSPENDED state is set for task associated with ID. + */ + +rtems_status_code rtems_task_suspend( + Objects_Id id +); + +/* + * rtems_task_resume + * + * DESCRIPTION: + * + * This routine implements the rtems_task_resume Directive. The + * SUSPENDED state is cleared for task associated with ID. + */ + +rtems_status_code rtems_task_resume( + Objects_Id id +); + +/* + * rtems_task_set_priority + * + * DESCRIPTION: + * + * This routine implements the rtems_task_set_priority directive. The + * current priority of the task associated with ID is set to + * new_priority. The former priority of that task is returned + * in old_priority. + */ + +rtems_status_code rtems_task_set_priority( + Objects_Id id, + rtems_task_priority new_priority, + rtems_task_priority *old_priority +); + +/* + * rtems_task_start + * + * DESCRIPTION: + * + * This routine implements the rtems_task_start directive. The + * starting execution point of the task associated with ID is + * set to entry_point with the initial argument. + */ + +rtems_status_code rtems_task_start( + Objects_Id id, + rtems_task_entry entry_point, + unsigned32 argument +); + +/* + * rtems_task_wake_when + * + * DESCRIPTION: + * + * This routine implements the rtems_task_wake_when directive. The + * calling task is blocked until the current time of day is + * equal to that indicated by time_buffer. + */ + +rtems_status_code rtems_task_wake_when( + rtems_time_of_day *time_buffer +); + +/* + * rtems_task_wake_after + * + * DESCRIPTION: + * + * This routine implements the rtems_task_wake_after directive. The + * calling task is blocked until the indicated number of clock + * ticks have occurred. + */ + +rtems_status_code rtems_task_wake_after( + rtems_interval ticks +); + +/* + * _RTEMS_tasks_Allocate + * + * DESCRIPTION: + * + * This function allocates a task control block from + * the inactive chain of free task control blocks. + */ + +STATIC INLINE Thread_Control *_RTEMS_tasks_Allocate( void ); + +/* + * _RTEMS_tasks_Free + * + * DESCRIPTION: + * + * This routine frees a task control block to the + * inactive chain of free task control blocks. + + */ + +STATIC INLINE void _RTEMS_tasks_Free ( + Thread_Control *the_task +); + +/* + * _RTEMS_tasks_Cancel_wait + * + * DESCRIPTION: + * + * This routine unblocks the_thread and cancels any timers + * which the_thread has active. + */ + +STATIC INLINE void _RTEMS_tasks_Cancel_wait( + Thread_Control *the_thread +); + +#include +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ diff --git a/cpukit/rtems/include/rtems/rtems/timer.h b/cpukit/rtems/include/rtems/rtems/timer.h new file mode 100644 index 0000000000..f6ccb5f4a1 --- /dev/null +++ b/cpukit/rtems/include/rtems/rtems/timer.h @@ -0,0 +1,292 @@ +/* timer.h + * + * This include file contains all the constants, structures, and + * prototypes associated with the Timer Manager. This manager provides + * facilities to configure, initiate, cancel, and delete timers which will + * fire at specified intervals of time. + * + * Directives provided are: + * + * + create a timer + * + get an ID of a timer + * + delete a timer + * + set a timer to fire after a number of ticks have passed + * + set a timer to fire when a specified date and time has been reached + * + reset a timer + * + cancel a time + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * All rights assigned to U.S. Government, 1994. + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + */ + +#ifndef __RTEMS_TIMER_h +#define __RTEMS_TIMER_h + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +/* + * The following enumerated type details the classes to which a timer + * may belong. + */ + +typedef enum { + TIMER_INTERVAL, + TIMER_TIME_OF_DAY, + TIMER_DORMANT +} Timer_Classes; + +/* + * The following defines the type of a Timer Service Routine. + */ + +typedef rtems_timer_service_routine_entry Timer_Service; + +/* + * The following defines the information control block used to manage + * this class of objects. + */ + +EXTERN Objects_Information _Timer_Information; + +/* + * The following records define the control block used to manage + * each timer. + */ + +typedef struct { + Objects_Control Object; + Watchdog_Control Ticker; + Timer_Classes the_class; +} Timer_Control; + +/* + * _Timer_Manager_initialization + * + * DESCRIPTION: + * + * This routine performs the initialization necessary for this manager. + */ + +void _Timer_Manager_initialization( + unsigned32 maximum_timers +); + +/* + * rtems_timer_create + * + * DESCRIPTION: + * + * This routine implements the rtems_timer_create directive. The + * timer will have the name name. It returns the id of the + * created timer in ID. + */ + +rtems_status_code rtems_timer_create( + Objects_Name name, + Objects_Id *id +); + +/* + * rtems_timer_ident + * + * DESCRIPTION: + * + * This routine implements the rtems_timer_ident directive. + * This directive returns the timer ID associated with name. + * If more than one timer is named name, then the timer + * to which the ID belongs is arbitrary. + */ + +rtems_status_code rtems_timer_ident( + Objects_Name name, + Objects_Id *id +); + +/* + * rtems_timer_cancel + * + * DESCRIPTION: + * + * This routine implements the rtems_timer_cancel directive. It is used + * to stop the timer associated with ID from firing. + */ + +rtems_status_code rtems_timer_cancel( + Objects_Id id +); + +/* + * rtems_timer_delete + * + * DESCRIPTION: + * + * This routine implements the rtems_timer_delete directive. The + * timer indicated by ID is deleted. + */ + +rtems_status_code rtems_timer_delete( + Objects_Id id +); + +/* + * rtems_timer_fire_after + * + * DESCRIPTION: + * + * This routine implements the rtems_timer_fire_after directive. It + * initiates the timer associated with ID to fire in ticks clock + * ticks. When the timer fires, the routine will be invoked. + */ + +rtems_status_code rtems_timer_fire_after( + Objects_Id id, + rtems_interval ticks, + Timer_Service routine, + void *user_data +); + +/* + * rtems_timer_fire_when + * + * DESCRIPTION: + * + * This routine implements the rtems_timer_fire_when directive. It + * initiates the timer associated with ID to fire at wall_time + * When the timer fires, the routine will be invoked. + */ + +rtems_status_code rtems_timer_fire_when( + Objects_Id id, + rtems_time_of_day *wall_time, + Timer_Service routine, + void *user_data +); + +/* + * rtems_timer_reset + * + * DESCRIPTION: + * + * This routine implements the rtems_timer_reset directive. It is used + * to reinitialize the interval timer associated with ID just as if + * rtems_timer_fire_after were re-invoked with the same arguments that + * were used to initiate this timer. + */ + +rtems_status_code rtems_timer_reset( + Objects_Id id +); + +/* + * _Timer_Allocate + * + * DESCRIPTION: + * + * This function allocates a timer control block from + * the inactive chain of free timer control blocks. + */ + +STATIC INLINE Timer_Control *_Timer_Allocate( void ); + +/* + * _Timer_Free + * + * DESCRIPTION: + * + * This routine frees a timer control block to the + * inactive chain of free timer control blocks. + */ + +STATIC INLINE void _Timer_Free ( + Timer_Control *the_timer +); + +/* + * _Timer_Get + * + * DESCRIPTION: + * + * This function maps timer IDs to timer control blocks. + * If ID corresponds to a local timer, then it returns + * the timer control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. Otherwise, location is set + * to OBJECTS_ERROR and the returned value is undefined. + */ + +STATIC INLINE Timer_Control *_Timer_Get ( + Objects_Id id, + Objects_Locations *location +); + +/* + * _Timer_Is_interval_class + * + * DESCRIPTION: + * + * This function returns TRUE if the class is that of an INTERVAL + * timer, and FALSE otherwise. + */ + +STATIC INLINE boolean _Timer_Is_interval_class ( + Timer_Classes the_class +); + +/* + * _Timer_Is_time_of_day_class + * + * DESCRIPTION: + * + * This function returns TRUE if the class is that of an INTERVAL + * timer, and FALSE otherwise. + */ + +STATIC INLINE boolean _Timer_Is_timer_of_day_class ( + Timer_Classes the_class +); + +/* + * _Timer_Is_dormant_class + * + * DESCRIPTION: + * + * This function returns TRUE if the class is that of a DORMANT + * timer, and FALSE otherwise. + */ + +STATIC INLINE boolean _Timer_Is_dormant_class ( + Timer_Classes the_class +); + +/* + * _Timer_Is_null + * + * DESCRIPTION: + * + * This function returns TRUE if the_timer is NULL and FALSE otherwise. + */ + +STATIC INLINE boolean _Timer_Is_null ( + Timer_Control *the_timer +); + +#include + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ -- cgit v1.2.3