URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/trunk/rtos/rtems/c/src/exec/score/include/rtems
- from Rev 30 to Rev 173
- ↔ Reverse comparison
Rev 30 → Rev 173
/Makefile.am
0,0 → 1,24
## |
## $Id: Makefile.am,v 1.2 2001-09-27 11:59:32 chris Exp $ |
## |
|
AUTOMAKE_OPTIONS = foreign 1.4 |
|
H_FILES = debug.h system.h |
|
noinst_HEADERS = $(H_FILES) |
|
PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems \ |
$(noinst_HEADERS:%=$(PROJECT_INCLUDE)/rtems/%) |
|
$(PROJECT_INCLUDE)/rtems: |
@$(mkinstalldirs) $@ |
$(PROJECT_INCLUDE)/rtems/%.h: %.h |
$(INSTALL_DATA) $< $@ |
|
all-local: $(PREINSTALL_FILES) |
|
SUBDIRS = score |
|
include $(top_srcdir)/../../../automake/subdirs.am |
include $(top_srcdir)/../../../automake/local.am |
/system.h
0,0 → 1,200
/* system.h |
* |
* This include file contains information that is included in every |
* function in the executive. This must be the first include file |
* included in all internal RTEMS files. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: system.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_SYSTEM_h |
#define __RTEMS_SYSTEM_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* |
* The target options include file defines all target dependent |
* parameters for this build of RTEMS. It must be included |
* first so the basic macro definitions are in place. |
*/ |
|
#include <rtems/score/targopts.h> |
|
/* |
* The following insures that all data is declared in the space |
* of the initialization routine for either the Initialization Manager |
* or the initialization file for the appropriate API. It is |
* referenced as "external" in every other file. |
*/ |
|
#ifdef SCORE_INIT |
#undef SCORE_EXTERN |
#define SCORE_EXTERN |
#else |
#undef SCORE_EXTERN |
#define SCORE_EXTERN extern |
#endif |
|
#ifdef SAPI_INIT |
#undef SAPI_EXTERN |
#define SAPI_EXTERN |
#else |
#undef SAPI_EXTERN |
#define SAPI_EXTERN extern |
#endif |
|
#ifdef RTEMS_API_INIT |
#undef RTEMS_EXTERN |
#define RTEMS_EXTERN |
#else |
#undef RTEMS_EXTERN |
#define RTEMS_EXTERN extern |
#endif |
|
#ifdef POSIX_API_INIT |
#undef POSIX_EXTERN |
#define POSIX_EXTERN |
#else |
#undef POSIX_EXTERN |
#define POSIX_EXTERN extern |
#endif |
|
#ifdef ITRON_API_INIT |
#undef ITRON_EXTERN |
#define ITRON_EXTERN |
#else |
#undef ITRON_EXTERN |
#define ITRON_EXTERN extern |
#endif |
|
/* |
* The following (in conjunction with compiler arguments) are used |
* to choose between the use of static inline functions and macro |
* functions. The static inline implementation allows better |
* type checking with no cost in code size or execution speed. |
*/ |
|
#ifdef USE_INLINES |
# ifdef __GNUC__ |
# define RTEMS_INLINE_ROUTINE static __inline__ |
# else |
# define RTEMS_INLINE_ROUTINE static inline |
# endif |
#else |
# define RTEMS_INLINE_ROUTINE |
#endif |
|
/* |
* Include a base set of files. |
*/ |
|
/* |
* XXX: Eventually proc_ptr needs to disappear!!! |
*/ |
|
typedef void * proc_ptr; |
|
/* |
* Define NULL |
*/ |
|
#ifndef NULL |
#define NULL 0 /* NULL value */ |
#endif |
|
/* |
* Boolean constants |
*/ |
|
#if !defined( TRUE ) || (TRUE != 1) |
#undef TRUE |
#define TRUE (1) |
#endif |
|
#if !defined( FALSE ) || (FALSE != 0) |
#undef FALSE |
#define FALSE (0) |
#endif |
|
#include <rtems/score/cpu.h> /* processor specific information */ |
|
#define stringify( _x ) # _x |
|
#define RTEMS_offsetof(type, field) \ |
((unsigned32) &(((type *) 0)->field)) |
|
/* |
* The following is the extern for the RTEMS version string. |
* The contents of this string are CPU specific. |
*/ |
|
extern const char _RTEMS_version[]; /* RTEMS version string */ |
extern const char _Copyright_Notice[]; /* RTEMS copyright string */ |
|
/* |
* The following defines the CPU dependent information table. |
*/ |
|
SCORE_EXTERN rtems_cpu_table _CPU_Table; /* CPU dependent info */ |
|
/* |
* Macros to access CPU Table fields required by ALL ports. |
* |
* NOTE: Similar macros to access port specific fields in in the |
* appropriate cpu.h file. |
*/ |
|
#define rtems_cpu_configuration_get_table() \ |
(&_CPU_Table) |
|
#define rtems_cpu_configuration_get_pretasking_hook() \ |
(_CPU_Table.pretasking_hook) |
|
#define rtems_cpu_configuration_get_predriver_hook() \ |
(_CPU_Table.predriver_hook) |
|
#define rtems_cpu_configuration_get_postdriver_hook() \ |
(_CPU_Table.postdriver_hook) |
|
#define rtems_cpu_configuration_get_idle_task() \ |
(_CPU_Table.idle_task) |
|
#define rtems_cpu_configuration_get_do_zero_of_workspace() \ |
(_CPU_Table.do_zero_of_workspace) |
|
#define rtems_cpu_configuration_get_idle_task_stack_size() \ |
(_CPU_Table.idle_task_stack_size) |
|
#define rtems_cpu_configuration_get_interrupt_stack_size() \ |
(_CPU_Table.interrupt_stack_size) |
|
#define rtems_cpu_configuration_get_extra_mpci_receive_server_stack() \ |
(_CPU_Table.extra_mpci_receive_server_stack) |
|
#define rtems_cpu_configuration_get_stack_allocate_hook() \ |
(_CPU_Table.stack_allocate_hook) |
|
#define rtems_cpu_configuration_get_stack_free_hook() \ |
(_CPU_Table.stack_free_hook) |
|
/* |
* XXX weird RTEMS stuff that probably should be somewhere else. |
*/ |
|
#define RTEMS_MAXIMUM_NAME_LENGTH sizeof(rtems_name) |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/apiext.h
0,0 → 1,101
/* apiext.h |
* |
* This is the API Extensions Handler. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: apiext.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
|
#ifndef __API_EXTENSIONS_h |
#define __API_EXTENSIONS_h |
|
#include <rtems/score/chain.h> |
#include <rtems/score/thread.h> |
|
/* |
* The control structure which defines the points at which an API |
* can add an extension to the system initialization thread. |
*/ |
|
typedef void (*API_extensions_Predriver_hook)(void); |
typedef void (*API_extensions_Postdriver_hook)(void); |
typedef void (*API_extensions_Postswitch_hook)( |
Thread_Control * |
); |
|
|
typedef struct { |
Chain_Node Node; |
API_extensions_Predriver_hook predriver_hook; |
API_extensions_Postdriver_hook postdriver_hook; |
API_extensions_Postswitch_hook postswitch_hook; |
} API_extensions_Control; |
|
/* |
* This is the list of API extensions to the system initialization. |
*/ |
|
SCORE_EXTERN Chain_Control _API_extensions_List; |
|
/* |
* _API_extensions_Initialization |
* |
* DESCRIPTION: |
* |
* This routine initializes the API extension handler. |
* |
*/ |
|
void _API_extensions_Initialization( void ); |
|
/* |
* _API_extensions_Add |
* |
* DESCRIPTION: |
* |
* XXX |
*/ |
|
void _API_extensions_Add( |
API_extensions_Control *the_extension |
); |
|
/* |
* _API_extensions_Run_predriver |
* |
* DESCRIPTION: |
* |
* XXX |
*/ |
|
void _API_extensions_Run_predriver( void ); |
|
/* |
* _API_extensions_Run_postdriver |
* |
* DESCRIPTION: |
* |
* XXX |
*/ |
|
void _API_extensions_Run_postdriver( void ); |
|
/* |
* _API_extensions_Run_postswitch |
* |
* DESCRIPTION: |
* |
* XXX |
*/ |
|
void _API_extensions_Run_postswitch( void ); |
|
#endif |
/* end of include file */ |
/score/mppkt.h
0,0 → 1,100
/* mppkt.h |
* |
* This package is the specification for the Packet Handler. |
* This handler defines the basic packet and provides |
* mechanisms to utilize packets based on this prefix. |
* Packets are the fundamental basis for messages passed between |
* nodes in an MP system. |
* |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: mppkt.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __MP_PACKET_h |
#define __MP_PACKET_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/object.h> |
#include <rtems/score/priority.h> |
#include <rtems/score/watchdog.h> |
|
/* |
* The following enumerated type defines the packet classes. |
* |
* NOTE: In general, each class corresponds to a manager |
* which supports global operations. Each manager |
* defines the set of supported operations. |
*/ |
|
typedef enum { |
MP_PACKET_MPCI_INTERNAL = 0, |
MP_PACKET_TASKS = 1, |
MP_PACKET_MESSAGE_QUEUE = 2, |
MP_PACKET_SEMAPHORE = 3, |
MP_PACKET_PARTITION = 4, |
MP_PACKET_REGION = 5, |
MP_PACKET_EVENT = 6, |
MP_PACKET_SIGNAL = 7 |
} MP_packet_Classes; |
|
#define MP_PACKET_CLASSES_FIRST MP_PACKET_MPCI_INTERNAL |
#define MP_PACKET_CLASSES_LAST MP_PACKET_SIGNAL |
|
/* |
* The following record contains the prefix for every packet |
* passed between nodes in an MP system. |
* |
* NOTE: This structure is padded to insure that anything |
* following it is on a 16 byte boundary. This is |
* the most stringent structure alignment rule |
* encountered yet (i960CA). |
*/ |
|
typedef struct { |
MP_packet_Classes the_class; |
Objects_Id id; |
Objects_Id source_tid; |
Priority_Control source_priority; |
unsigned32 return_code; |
unsigned32 length; |
unsigned32 to_convert; |
Watchdog_Interval timeout; |
} MP_packet_Prefix; |
|
/* |
* An MPCI must support packets of at least this size. |
*/ |
|
#define MP_PACKET_MINIMUM_PACKET_SIZE 64 |
|
/* |
* The following constant defines the number of unsigned32's |
* in a packet which must be converted to native format in a |
* heterogeneous system. In packets longer than |
* MP_PACKET_MINIMUN_HETERO_CONVERSION unsigned32's, some of the "extra" data |
* may a user message buffer which is not automatically endian swapped. |
*/ |
|
#define MP_PACKET_MINIMUN_HETERO_CONVERSION \ |
( sizeof( MP_packet_Prefix ) / sizeof( unsigned32 ) ) |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/mppkt.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/wkspace.h
0,0 → 1,70
/* wkspace.h |
* |
* This include file contains information related to the |
* RAM Workspace. This Handler provides mechanisms which can be used to |
* define, initialize and manipulate the workspace. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: wkspace.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __WORKSPACE_h |
#define __WORKSPACE_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/heap.h> |
#include <rtems/score/interr.h> |
|
/* |
* The following is used to manage the Workspace. |
* |
*/ |
|
SCORE_EXTERN Heap_Control _Workspace_Area; /* executive heap header */ |
|
/* |
* _Workspace_Handler_initialization |
* |
* DESCRIPTION: |
* |
* This routine performs the initialization necessary for this handler. |
*/ |
|
void _Workspace_Handler_initialization( |
void *starting_address, |
unsigned32 size |
); |
|
/* |
* _Workspace_Allocate_or_fatal_error |
* |
* DESCRIPTION: |
* |
* This routine returns the address of a block of memory of size |
* bytes. If a block of the appropriate size cannot be allocated |
* from the workspace, then the internal error handler is invoked. |
*/ |
|
void *_Workspace_Allocate_or_fatal_error( |
unsigned32 size |
); |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/wkspace.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/coresem.h
0,0 → 1,157
/* core_sem.h |
* |
* This include file contains all the constants and structures associated |
* with the Counting Semaphore Handler. A counting semaphore is the |
* standard Dijkstra binary semaphore used to provide synchronization |
* and mutual exclusion capabilities. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: coresem.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_CORE_COUNTING_SEMAPHORE_h |
#define __RTEMS_CORE_COUNTING_SEMAPHORE_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/thread.h> |
#include <rtems/score/threadq.h> |
#include <rtems/score/priority.h> |
#include <rtems/score/watchdog.h> |
|
/* |
* The following type defines the callout which the API provides |
* to support global/multiprocessor operations on semaphores. |
*/ |
|
typedef void ( *CORE_semaphore_API_mp_support_callout )( |
Thread_Control *, |
Objects_Id |
); |
|
/* |
* Blocking disciplines for a semaphore. |
*/ |
|
typedef enum { |
CORE_SEMAPHORE_DISCIPLINES_FIFO, |
CORE_SEMAPHORE_DISCIPLINES_PRIORITY |
} CORE_semaphore_Disciplines; |
|
/* |
* Core Semaphore handler return statuses. |
*/ |
|
typedef enum { |
CORE_SEMAPHORE_STATUS_SUCCESSFUL, |
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT, |
CORE_SEMAPHORE_WAS_DELETED, |
CORE_SEMAPHORE_TIMEOUT, |
CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED |
} CORE_semaphore_Status; |
|
/* |
* The following defines the control block used to manage the |
* attributes of each semaphore. |
*/ |
|
typedef struct { |
unsigned32 maximum_count; |
CORE_semaphore_Disciplines discipline; |
} CORE_semaphore_Attributes; |
|
/* |
* The following defines the control block used to manage each |
* counting semaphore. |
*/ |
|
typedef struct { |
Thread_queue_Control Wait_queue; |
CORE_semaphore_Attributes Attributes; |
unsigned32 count; |
} CORE_semaphore_Control; |
|
/* |
* _CORE_semaphore_Initialize |
* |
* DESCRIPTION: |
* |
* This routine initializes the semaphore based on the parameters passed. |
*/ |
|
void _CORE_semaphore_Initialize( |
CORE_semaphore_Control *the_semaphore, |
Objects_Classes the_class, |
CORE_semaphore_Attributes *the_semaphore_attributes, |
unsigned32 initial_value, |
Thread_queue_Extract_callout proxy_extract_callout |
); |
|
/* |
* _CORE_semaphore_Seize |
* |
* DESCRIPTION: |
* |
* This routine attempts to receive a unit from the_semaphore. |
* If a unit is available or if the wait flag is FALSE, then the routine |
* returns. Otherwise, the calling task is blocked until a unit becomes |
* available. |
*/ |
|
void _CORE_semaphore_Seize( |
CORE_semaphore_Control *the_semaphore, |
Objects_Id id, |
boolean wait, |
Watchdog_Interval timeout |
); |
|
/* |
* _CORE_semaphore_Surrender |
* |
* DESCRIPTION: |
* |
* This routine frees a unit to the semaphore. 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. |
*/ |
|
CORE_semaphore_Status _CORE_semaphore_Surrender( |
CORE_semaphore_Control *the_semaphore, |
Objects_Id id, |
CORE_semaphore_API_mp_support_callout api_semaphore_mp_support |
); |
|
/* |
* _CORE_semaphore_Flush |
* |
* DESCRIPTION: |
* |
* This routine assists in the deletion of a semaphore by flushing the |
* associated wait queue. |
*/ |
|
void _CORE_semaphore_Flush( |
CORE_semaphore_Control *the_semaphore, |
Thread_queue_Flush_callout remote_extract_callout, |
unsigned32 status |
); |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/coresem.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
|
/score/isr.h
0,0 → 1,230
/* isr.h |
* |
* This include file contains all the constants and structures associated |
* with the management of processor interrupt levels. This handler |
* supports interrupt critical sections, vectoring of user interrupt |
* handlers, nesting of interrupts, and manipulating interrupt levels. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: isr.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __ISR_h |
#define __ISR_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* |
* The following type defines the control block used to manage |
* the interrupt level portion of the status register. |
*/ |
|
typedef unsigned32 ISR_Level; |
|
/* |
* The following type defines the type used to manage the vectors. |
*/ |
|
typedef unsigned32 ISR_Vector_number; |
|
/* |
* Return type for ISR Handler |
*/ |
|
typedef void ISR_Handler; |
|
/* |
* Pointer to an ISR Handler |
*/ |
|
#if (CPU_ISR_PASSES_FRAME_POINTER == 1) |
typedef ISR_Handler ( *ISR_Handler_entry )( |
ISR_Vector_number, |
CPU_Interrupt_frame * |
); |
#else |
typedef ISR_Handler ( *ISR_Handler_entry )( |
ISR_Vector_number |
); |
#endif |
/* |
* This constant promotes out the number of vectors truly supported by |
* the current CPU being used. This is usually the number of distinct vectors |
* the cpu can vector. |
*/ |
|
#define ISR_NUMBER_OF_VECTORS CPU_INTERRUPT_NUMBER_OF_VECTORS |
|
/* |
* This constant promotes out the highest valid interrupt vector number. |
*/ |
|
#define ISR_INTERRUPT_MAXIMUM_VECTOR_NUMBER CPU_INTERRUPT_MAXIMUM_VECTOR_NUMBER |
|
/* |
* The following is TRUE if signals have been sent to the currently |
* executing thread by an ISR handler. |
*/ |
|
SCORE_EXTERN boolean _ISR_Signals_to_thread_executing; |
|
/* |
* The following contains the interrupt service routine nest level. |
* When this variable is zero, a thread is executing. |
*/ |
|
SCORE_EXTERN volatile unsigned32 _ISR_Nest_level; |
|
/* |
* The following declares the Vector Table. Application |
* interrupt service routines are vectored by the ISR Handler via this table. |
*/ |
|
SCORE_EXTERN ISR_Handler_entry _ISR_Vector_table[ ISR_NUMBER_OF_VECTORS ]; |
|
/* |
* _ISR_Handler_initialization |
* |
* DESCRIPTION: |
* |
* This routine performs the initialization necessary for this handler. |
*/ |
|
void _ISR_Handler_initialization ( void ); |
|
/* |
* _ISR_Disable |
* |
* DESCRIPTION: |
* |
* This routine disables all interrupts so that a critical section |
* of code can be executing without being interrupted. Upon return, |
* the argument _level will contain the previous interrupt mask level. |
*/ |
|
#define _ISR_Disable( _level ) \ |
_CPU_ISR_Disable( _level ) |
|
/* |
* _ISR_Enable |
* |
* DESCRIPTION: |
* |
* This routine enables interrupts to the previous interrupt mask |
* LEVEL. It is used at the end of a critical section of code to |
* enable interrupts so they can be processed again. |
*/ |
|
#define _ISR_Enable( _level ) \ |
_CPU_ISR_Enable( _level ) |
|
/* |
* _ISR_Flash |
* |
* DESCRIPTION: |
* |
* This routine temporarily enables interrupts to the previous |
* interrupt mask level and then disables all interrupts so that |
* the caller can continue into the second part of a critical |
* section. This routine is used to temporarily enable interrupts |
* during a long critical section. It is used in long sections of |
* critical code when a point is reached at which interrupts can |
* be temporarily enabled. Deciding where to flash interrupts |
* in a long critical section is often difficult and the point |
* must be selected with care to insure that the critical section |
* properly protects itself. |
*/ |
|
#define _ISR_Flash( _level ) \ |
_CPU_ISR_Flash( _level ) |
|
/* |
* _ISR_Install_vector |
* |
* DESCRIPTION: |
* |
* This routine installs new_handler as the interrupt service routine |
* for the specified vector. The previous interrupt service routine is |
* returned as old_handler. |
*/ |
|
#define _ISR_Install_vector( _vector, _new_handler, _old_handler ) \ |
_CPU_ISR_install_vector( _vector, _new_handler, _old_handler ) |
|
/* |
* _ISR_Get_level |
* |
* DESCRIPTION: |
* |
* This routine returns the current interrupt level. |
*/ |
|
#define _ISR_Get_level() \ |
_CPU_ISR_Get_level() |
|
/* |
* _ISR_Set_level |
* |
* DESCRIPTION: |
* |
* This routine sets the current interrupt level to that specified |
* by new_level. The new interrupt level is effective when the |
* routine exits. |
*/ |
|
#define _ISR_Set_level( _new_level ) \ |
_CPU_ISR_Set_level( _new_level ) |
|
/* |
* _ISR_Handler |
* |
* DESCRIPTION: |
* |
* This routine is the interrupt dispatcher. ALL interrupts |
* are vectored to this routine so that minimal context can be saved |
* and setup performed before the application's high-level language |
* interrupt service routine is invoked. After the application's |
* interrupt service routine returns control to this routine, it |
* will determine if a thread dispatch is necessary. If so, it will |
* insure that the necessary thread scheduling operations are |
* performed when the outermost interrupt service routine exits. |
* |
* NOTE: Implemented in assembly language. |
*/ |
|
void _ISR_Handler( void ); |
|
/* |
* _ISR_Dispatch |
* |
* DESCRIPTION: |
* |
* This routine provides a wrapper so that the routine |
* _Thread_Dispatch can be invoked when a reschedule is necessary |
* at the end of the outermost interrupt service routine. This |
* wrapper is necessary to establish the processor context needed |
* by _Thread_Dispatch and to save the processor context which is |
* corrupted by _Thread_Dispatch. This context typically consists |
* of registers which are not preserved across routine invocations. |
* |
* NOTE: Implemented in assembly language. |
*/ |
|
void _ISR_Dispatch( void ); |
|
#include <rtems/score/isr.inl> |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/userext.h
0,0 → 1,210
/* userext.h |
* |
* This include file contains all information about user extensions. This |
* Handler provides mechanisms which can be used to initialize and manipulate |
* all user extensions. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: userext.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __USER_EXTENSIONS_h |
#define __USER_EXTENSIONS_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/interr.h> |
#include <rtems/score/chain.h> |
#include <rtems/score/thread.h> |
|
/* |
* The following records defines the User Extension Table. |
* This table defines the application dependent routines which |
* are invoked at critical points in the life of each thread and |
* the system as a whole. |
*/ |
|
typedef void User_extensions_routine; |
|
typedef boolean ( *User_extensions_thread_create_extension )( |
Thread_Control *, |
Thread_Control * |
); |
|
typedef User_extensions_routine ( *User_extensions_thread_delete_extension )( |
Thread_Control *, |
Thread_Control * |
); |
|
typedef User_extensions_routine ( *User_extensions_thread_start_extension )( |
Thread_Control *, |
Thread_Control * |
); |
|
typedef User_extensions_routine ( *User_extensions_thread_restart_extension )( |
Thread_Control *, |
Thread_Control * |
); |
|
typedef User_extensions_routine ( *User_extensions_thread_switch_extension )( |
Thread_Control *, |
Thread_Control * |
); |
|
typedef User_extensions_routine ( |
*User_extensions_thread_post_switch_extension )( |
Thread_Control * |
); |
|
typedef User_extensions_routine ( *User_extensions_thread_begin_extension )( |
Thread_Control * |
); |
|
typedef User_extensions_routine ( *User_extensions_thread_exitted_extension )( |
Thread_Control * |
); |
|
typedef User_extensions_routine ( *User_extensions_fatal_extension )( |
Internal_errors_Source /* the_source */, |
boolean /* is_internal */, |
unsigned32 /* the_error */ |
); |
|
|
typedef struct { |
User_extensions_thread_create_extension thread_create; |
User_extensions_thread_start_extension thread_start; |
User_extensions_thread_restart_extension thread_restart; |
User_extensions_thread_delete_extension thread_delete; |
User_extensions_thread_switch_extension thread_switch; |
User_extensions_thread_begin_extension thread_begin; |
User_extensions_thread_exitted_extension thread_exitted; |
User_extensions_fatal_extension fatal; |
} User_extensions_Table; |
|
/* |
* The following is used to manage each user extension set. |
*/ |
|
typedef struct { |
Chain_Node Node; |
User_extensions_Table Callouts; |
} User_extensions_Control; |
|
/* |
* The following is used to manage the list of active extensions. |
*/ |
|
SCORE_EXTERN Chain_Control _User_extensions_List; |
|
/* |
* _User_extensions_Thread_create |
* |
* DESCRIPTION: |
* |
* This routine is used to invoke the user extension for |
* the thread creation operate. |
*/ |
|
boolean _User_extensions_Thread_create ( |
Thread_Control *the_thread |
); |
|
/* |
* _User_extensions_Thread_delete |
* |
* DESCRIPTION: |
* |
* This routine is used to invoke the user extension for |
* the thread deletion operation. |
*/ |
|
void _User_extensions_Thread_delete ( |
Thread_Control *the_thread |
); |
|
/* |
* _User_extensions_Thread_start |
* |
* DESCRIPTION: |
* |
* This routine is used to invoke the user extension for |
* the thread start operation. |
*/ |
|
void _User_extensions_Thread_start ( |
Thread_Control *the_thread |
); |
|
/* |
* _User_extensions_Thread_restart |
* |
* DESCRIPTION: |
* |
* This routine is used to invoke the user extension for |
* the thread restart operation. |
*/ |
|
void _User_extensions_Thread_restart ( |
Thread_Control *the_thread |
); |
|
/* |
* _User_extensions_Thread_begin |
* |
* DESCRIPTION: |
* |
* This routine is used to invoke the user extension which |
* is invoked when a thread begins. |
*/ |
|
void _User_extensions_Thread_begin ( |
Thread_Control *executing |
); |
|
/* |
* _User_extensions_Thread_exitted |
* |
* DESCRIPTION: |
* |
* This routine is used to invoke the user extension which |
* is invoked when a thread exits. |
*/ |
|
void _User_extensions_Thread_exitted ( |
Thread_Control *executing |
); |
|
/* |
* _User_extensions_Fatal |
* |
* DESCRIPTION: |
* |
* This routine is used to invoke the user extension invoked |
* when a fatal error occurs. |
*/ |
|
void _User_extensions_Fatal ( |
Internal_errors_Source the_source, |
boolean is_internal, |
unsigned32 the_error |
); |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/userext.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/coremsg.h
0,0 → 1,301
/* coremsg.h |
* |
* This include file contains all the constants and structures associated |
* with the Message queue Handler. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: coremsg.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_CORE_MESSAGE_QUEUE_h |
#define __RTEMS_CORE_MESSAGE_QUEUE_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <limits.h> |
#include <rtems/score/thread.h> |
#include <rtems/score/threadq.h> |
#include <rtems/score/priority.h> |
#include <rtems/score/watchdog.h> |
|
/* |
* The following type defines the callout which the API provides |
* to support global/multiprocessor operations on message_queues. |
*/ |
|
typedef void ( *CORE_message_queue_API_mp_support_callout )( |
Thread_Control *, |
Objects_Id |
); |
|
/* |
* The following defines the data types needed to manipulate |
* the contents of message buffers. |
* |
* NOTE: The buffer field is normally longer than a single unsigned32. |
* but since messages are variable length we just make a ptr to 1. |
*/ |
|
typedef struct { |
unsigned32 size; |
unsigned32 buffer[1]; |
} CORE_message_queue_Buffer; |
|
/* |
* The following records define the organization of a message |
* buffer. |
*/ |
|
typedef struct { |
Chain_Node Node; |
int priority; |
CORE_message_queue_Buffer Contents; |
} CORE_message_queue_Buffer_control; |
|
/* |
* Blocking disciplines for a message_queue. |
*/ |
|
typedef enum { |
CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO, |
CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY |
} CORE_message_queue_Disciplines; |
|
/* |
* 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. |
* |
* NOTE: All other values are message priorities. Numerically smaller |
* priorities indicate higher priority messages. |
* |
*/ |
|
#define CORE_MESSAGE_QUEUE_SEND_REQUEST INT_MAX |
#define CORE_MESSAGE_QUEUE_URGENT_REQUEST INT_MIN |
|
typedef int CORE_message_queue_Submit_types; |
|
/* |
* Core Message queue handler return statuses. |
*/ |
|
typedef enum { |
CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL, |
CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE, |
CORE_MESSAGE_QUEUE_STATUS_TOO_MANY, |
CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED, |
CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT, |
CORE_MESSAGE_QUEUE_STATUS_WAS_DELETED, |
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT |
} CORE_message_queue_Status; |
|
/* |
* The following defines the control block used to manage the |
* attributes of each message queue. |
*/ |
|
typedef struct { |
CORE_message_queue_Disciplines discipline; |
} CORE_message_queue_Attributes; |
|
/* |
* The following defines the type for a Notification handler. A notification |
* handler is invoked when the message queue makes a 0->1 transition on |
* pending messages. |
*/ |
|
typedef void (*CORE_message_queue_Notify_Handler)( void * ); |
|
/* |
* The following defines the control block used to manage each |
* counting message_queue. |
*/ |
|
typedef struct { |
Thread_queue_Control Wait_queue; |
CORE_message_queue_Attributes Attributes; |
unsigned32 maximum_pending_messages; |
unsigned32 number_of_pending_messages; |
unsigned32 maximum_message_size; |
Chain_Control Pending_messages; |
CORE_message_queue_Buffer *message_buffers; |
CORE_message_queue_Notify_Handler notify_handler; |
void *notify_argument; |
Chain_Control Inactive_messages; |
} CORE_message_queue_Control; |
|
/* |
* _CORE_message_queue_Initialize |
* |
* DESCRIPTION: |
* |
* This routine initializes the message_queue based on the parameters passed. |
*/ |
|
boolean _CORE_message_queue_Initialize( |
CORE_message_queue_Control *the_message_queue, |
Objects_Classes the_class, |
CORE_message_queue_Attributes *the_message_queue_attributes, |
unsigned32 maximum_pending_messages, |
unsigned32 maximum_message_size, |
Thread_queue_Extract_callout proxy_extract_callout |
); |
|
/* |
* _CORE_message_queue_Close |
* |
* DESCRIPTION: |
* |
* This function closes a message by returning all allocated space and |
* flushing the message_queue's task wait queue. |
*/ |
|
void _CORE_message_queue_Close( |
CORE_message_queue_Control *the_message_queue, |
Thread_queue_Flush_callout remote_extract_callout, |
unsigned32 status |
); |
|
/* |
* _CORE_message_queue_Flush |
* |
* DESCRIPTION: |
* |
* This function flushes the message_queue's pending message queue. The |
* number of messages flushed from the queue is returned. |
* |
*/ |
|
unsigned32 _CORE_message_queue_Flush( |
CORE_message_queue_Control *the_message_queue |
); |
|
/* |
* _CORE_message_queue_Flush_support |
* |
* DESCRIPTION: |
* |
* This routine flushes all outstanding messages and returns |
* them to the inactive message chain. |
*/ |
|
unsigned32 _CORE_message_queue_Flush_support( |
CORE_message_queue_Control *the_message_queue |
); |
|
/* |
* _CORE_message_queue_Flush_waiting_threads |
* |
* DESCRIPTION: |
* |
* This function flushes the threads which are blocked on this |
* message_queue's pending message queue. They are unblocked whether |
* blocked sending or receiving. |
*/ |
|
void _CORE_message_queue_Flush_waiting_threads( |
CORE_message_queue_Control *the_message_queue |
); |
|
/* |
* _CORE_message_queue_Broadcast |
* |
* DESCRIPTION: |
* |
* This function sends a message for every thread waiting on the queue and |
* returns the number of threads made ready by the message. |
* |
*/ |
|
CORE_message_queue_Status _CORE_message_queue_Broadcast( |
CORE_message_queue_Control *the_message_queue, |
void *buffer, |
unsigned32 size, |
Objects_Id id, |
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, |
unsigned32 *count |
); |
|
/* |
* _CORE_message_queue_Submit |
* |
* DESCRIPTION: |
* |
* This routine implements the send and urgent message functions. It |
* processes a message that is to be submitted to the designated |
* message queue. The message will either be processed as a |
* send message which it will be inserted at the rear of the queue |
* or it will be processed as an urgent message which will be inserted |
* at the front of the queue. |
* |
*/ |
|
void _CORE_message_queue_Submit( |
CORE_message_queue_Control *the_message_queue, |
void *buffer, |
unsigned32 size, |
Objects_Id id, |
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, |
CORE_message_queue_Submit_types submit_type, |
boolean wait, |
Watchdog_Interval timeout |
); |
|
/* |
* _CORE_message_queue_Seize |
* |
* DESCRIPTION: |
* |
* This kernel routine dequeues a message, copies the message buffer to |
* a given destination buffer, and frees the message buffer to the |
* inactive message pool. The thread will be blocked if wait is TRUE, |
* otherwise an error will be given to the thread if no messages are available. |
* |
* NOTE: Returns message priority via return are in TCB. |
*/ |
|
void _CORE_message_queue_Seize( |
CORE_message_queue_Control *the_message_queue, |
Objects_Id id, |
void *buffer, |
unsigned32 *size, |
boolean wait, |
Watchdog_Interval timeout |
); |
|
/* |
* _CORE_message_queue_Insert_message |
* |
* DESCRIPTION: |
* |
* This kernel routine inserts the specified message into the |
* message queue. It is assumed that the message has been filled |
* in before this routine is called. |
*/ |
|
void _CORE_message_queue_Insert_message( |
CORE_message_queue_Control *the_message_queue, |
CORE_message_queue_Buffer_control *the_message, |
CORE_message_queue_Submit_types submit_type |
); |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/coremsg.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
|
/score/watchdog.h
0,0 → 1,193
/* watchdog.h |
* |
* This include file contains all the constants and structures associated |
* with watchdog timers. This Handler provides mechanisms which can be |
* used to initialize and manipulate watchdog timers. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: watchdog.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __WATCHDOG_h |
#define __WATCHDOG_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/object.h> |
|
/* |
* The following type defines the control block used to manage |
* intervals. |
*/ |
|
typedef unsigned32 Watchdog_Interval; |
|
/* |
* The following types define a pointer to a watchdog service routine. |
*/ |
|
typedef void Watchdog_Service_routine; |
|
typedef Watchdog_Service_routine ( *Watchdog_Service_routine_entry )( |
Objects_Id, |
void * |
); |
|
/* |
* Constant for indefinite wait. (actually an illegal interval) |
*/ |
|
#define WATCHDOG_NO_TIMEOUT 0 |
|
/* |
* The following enumerated type lists the states in which a |
* watchdog timer may be at any given time. |
*/ |
|
typedef enum { |
WATCHDOG_INACTIVE, /* off all chains */ |
WATCHDOG_BEING_INSERTED, /* off all chains, searching for insertion point */ |
WATCHDOG_ACTIVE, /* on chain, allowed to fire */ |
WATCHDOG_REMOVE_IT /* on chain, remove without firing if expires */ |
} Watchdog_States; |
|
/* |
* The following enumerated type details the manner in which |
* a watchdog chain may be adjusted by the Watchdog_Adjust |
* routine. The direction indicates a movement FORWARD |
* or BACKWARD in time. |
*/ |
|
typedef enum { |
WATCHDOG_FORWARD, /* adjust delta value forward */ |
WATCHDOG_BACKWARD /* adjust delta value backward */ |
} Watchdog_Adjust_directions; |
|
/* |
* The following record defines the control block used |
* to manage each watchdog timer. |
*/ |
|
typedef struct { |
Chain_Node Node; |
Watchdog_States state; |
Watchdog_Interval initial; |
Watchdog_Interval delta_interval; |
Watchdog_Interval start_time; |
Watchdog_Interval stop_time; |
Watchdog_Service_routine_entry routine; |
Objects_Id id; |
void *user_data; |
} Watchdog_Control; |
|
/* |
* The following are used for synchronization purposes |
* during an insert on a watchdog delta chain. |
*/ |
|
SCORE_EXTERN volatile unsigned32 _Watchdog_Sync_level; |
SCORE_EXTERN volatile unsigned32 _Watchdog_Sync_count; |
|
/* |
* The following contains the number of ticks since the |
* system was booted. |
*/ |
|
SCORE_EXTERN Watchdog_Interval _Watchdog_Ticks_since_boot; |
|
/* |
* The following defines the watchdog chains which are managed |
* on ticks and second boundaries. |
*/ |
|
SCORE_EXTERN Chain_Control _Watchdog_Ticks_chain; |
SCORE_EXTERN Chain_Control _Watchdog_Seconds_chain; |
|
/* |
* _Watchdog_Handler_initialization |
* |
* DESCRIPTION: |
* |
* This routine initializes the watchdog handler. The watchdog |
* synchronization flag is initialized and the watchdog chains are |
* initialized and emptied. |
*/ |
|
void _Watchdog_Handler_initialization( void ); |
|
/* |
* _Watchdog_Remove |
* |
* DESCRIPTION: |
* |
* This routine removes THE_WATCHDOG from the watchdog chain on which |
* it resides and returns the state THE_WATCHDOG timer was in. |
*/ |
|
Watchdog_States _Watchdog_Remove ( |
Watchdog_Control *the_watchdog |
); |
|
/* |
* _Watchdog_Adjust |
* |
* DESCRIPTION: |
* |
* This routine adjusts the HEADER watchdog chain in the forward |
* or backward DIRECTION for UNITS ticks. |
*/ |
|
void _Watchdog_Adjust ( |
Chain_Control *header, |
Watchdog_Adjust_directions direction, |
Watchdog_Interval units |
); |
|
/* |
* _Watchdog_Insert |
* |
* DESCRIPTION: |
* |
* This routine inserts THE_WATCHDOG into the HEADER watchdog chain |
* for a time of UNITS. The INSERT_MODE indicates whether |
* THE_WATCHDOG is to be activated automatically or later, explicitly |
* by the caller. |
* |
*/ |
|
void _Watchdog_Insert ( |
Chain_Control *header, |
Watchdog_Control *the_watchdog |
); |
|
/* |
* _Watchdog_Tickle |
* |
* DESCRIPTION: |
* |
* This routine is invoked at appropriate intervals to update |
* the HEADER watchdog chain. |
*/ |
|
void _Watchdog_Tickle ( |
Chain_Control *header |
); |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/watchdog.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/states.h
0,0 → 1,83
/* states.h |
* |
* This include file contains thread execution state information. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: states.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_STATES_h |
#define __RTEMS_STATES_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* |
* The following type defines the control block used to manage a |
* thread's state. |
*/ |
|
typedef unsigned32 States_Control; |
|
/* |
* The following constants define the individual states which may be |
* be used to compose and manipulate a thread's state. |
*/ |
|
#define STATES_ALL_SET 0xfffff /* all states */ |
#define STATES_READY 0x00000 /* ready to run */ |
#define STATES_DORMANT 0x00001 /* created not started */ |
#define STATES_SUSPENDED 0x00002 /* waiting for resume */ |
#define STATES_TRANSIENT 0x00004 /* in transition */ |
#define STATES_DELAYING 0x00008 /* wait for timeout */ |
#define STATES_WAITING_FOR_TIME 0x00010 /* wait for TOD */ |
#define STATES_WAITING_FOR_BUFFER 0x00020 |
#define STATES_WAITING_FOR_SEGMENT 0x00040 |
#define STATES_WAITING_FOR_MESSAGE 0x00080 |
#define STATES_WAITING_FOR_EVENT 0x00100 |
#define STATES_WAITING_FOR_SEMAPHORE 0x00200 |
#define STATES_WAITING_FOR_MUTEX 0x00400 |
#define STATES_WAITING_FOR_CONDITION_VARIABLE 0x00800 |
#define STATES_WAITING_FOR_JOIN_AT_EXIT 0x01000 |
#define STATES_WAITING_FOR_RPC_REPLY 0x02000 |
#define STATES_WAITING_FOR_PERIOD 0x04000 |
#define STATES_WAITING_FOR_SIGNAL 0x08000 |
#define STATES_INTERRUPTIBLE_BY_SIGNAL 0x10000 |
|
#define STATES_LOCALLY_BLOCKED ( STATES_WAITING_FOR_BUFFER | \ |
STATES_WAITING_FOR_SEGMENT | \ |
STATES_WAITING_FOR_MESSAGE | \ |
STATES_WAITING_FOR_SEMAPHORE | \ |
STATES_WAITING_FOR_MUTEX | \ |
STATES_WAITING_FOR_CONDITION_VARIABLE | \ |
STATES_WAITING_FOR_JOIN_AT_EXIT | \ |
STATES_WAITING_FOR_SIGNAL ) |
|
#define STATES_WAITING_ON_THREAD_QUEUE \ |
( STATES_LOCALLY_BLOCKED | \ |
STATES_WAITING_FOR_RPC_REPLY ) |
|
#define STATES_BLOCKED ( STATES_DELAYING | \ |
STATES_WAITING_FOR_TIME | \ |
STATES_WAITING_FOR_PERIOD | \ |
STATES_WAITING_FOR_EVENT | \ |
STATES_WAITING_ON_THREAD_QUEUE | \ |
STATES_INTERRUPTIBLE_BY_SIGNAL ) |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/states.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/objectmp.h
0,0 → 1,151
/* objectmp.h |
* |
* This include file contains all the constants and structures associated |
* with the manipulation of Global RTEMS Objects. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: objectmp.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_OBJECTS_MP_h |
#define __RTEMS_OBJECTS_MP_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* |
* This defines the Global Object Control Block used to manage |
* objects resident on other nodes. |
*/ |
|
typedef struct { |
Objects_Control Object; |
unsigned32 name; /* XXX broken but works */ |
/* XXX If any API is MP with variable length names .. BOOM!!!! */ |
} Objects_MP_Control; |
|
/* |
* _Objects_MP_Handler_initialization |
* |
* DESCRIPTION: |
* |
* This routine intializes the inactive global object chain |
* based on the maximum number of global objects configured. |
*/ |
|
void _Objects_MP_Handler_initialization ( |
unsigned32 node, |
unsigned32 maximum_nodes, |
unsigned32 maximum_global_objects |
); |
|
/*PAGE |
* |
* _Objects_MP_Open |
* |
* DESCRIPTION: |
* |
* This routine place the specified global object in the |
* specified information table. |
*/ |
|
void _Objects_MP_Open ( |
Objects_Information *information, |
Objects_MP_Control *the_global_object, |
unsigned32 the_name, /* XXX -- wrong for variable */ |
Objects_Id the_id |
); |
|
/* |
* _Objects_MP_Allocate_and_open |
* |
* DESCRIPTION: |
* |
* This routine allocates a global object control block |
* and places it in the specified information table. If the |
* allocation fails, then is_fatal_error determines the |
* error processing actions taken. |
*/ |
|
boolean _Objects_MP_Allocate_and_open ( |
Objects_Information *information, |
unsigned32 the_name, /* XXX -- wrong for variable length */ |
Objects_Id the_id, |
boolean is_fatal_error |
); |
|
/* |
* _Objects_MP_Close |
* |
* DESCRIPTION: |
* |
* This routine removes a global object from the specified |
* information table and deallocates the global object control block. |
*/ |
|
void _Objects_MP_Close ( |
Objects_Information *information, |
Objects_Id the_id |
); |
|
/* |
* _Objects_MP_Global_name_search |
* |
* DESCRIPTION: |
* |
* This routine looks for the object with the_name in the global |
* object tables indicated by information. It returns the ID of the |
* object with that name if one is found. |
*/ |
|
Objects_Name_to_id_errors _Objects_MP_Global_name_search ( |
Objects_Information *information, |
Objects_Name the_name, |
unsigned32 nodes_to_search, |
Objects_Id *the_id |
); |
|
/* |
* _Objects_MP_Is_remote |
* |
* DESCRIPTION: |
* |
* This function searches the Global Object Table managed |
* by information for the object indicated by ID. If the object |
* is found, then location is set to objects_remote, otherwise |
* location is set to objects_error. In both cases, the_object |
* is undefined. |
*/ |
|
void _Objects_MP_Is_remote ( |
Objects_Information *information, |
Objects_Id the_id, |
Objects_Locations *location, |
Objects_Control **the_object |
); |
|
/* |
* The following chain header is used to manage the set of |
* inactive global object control blocks. |
*/ |
|
SCORE_EXTERN unsigned32 _Objects_MP_Maximum_global_objects; |
SCORE_EXTERN Chain_Control _Objects_MP_Inactive_global_objects; |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/objectmp.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/interr.h
0,0 → 1,96
/* interr.h |
* |
* This include file contains constants and prototypes related |
* to the Internal Error Handler. |
* |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: interr.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_INTERNAL_ERROR_h |
#define __RTEMS_INTERNAL_ERROR_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* |
* This type lists the possible sources from which an error |
* can be reported. |
*/ |
|
typedef enum { |
INTERNAL_ERROR_CORE, |
INTERNAL_ERROR_RTEMS_API, |
INTERNAL_ERROR_POSIX_API, |
INTERNAL_ERROR_ITRON_API |
} Internal_errors_Source; |
|
/* |
* A list of errors which are generated internally by the executive core. |
*/ |
|
typedef enum { |
INTERNAL_ERROR_NO_CONFIGURATION_TABLE, |
INTERNAL_ERROR_NO_CPU_TABLE, |
INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS, |
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE, |
INTERNAL_ERROR_WORKSPACE_ALLOCATION, |
INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL, |
INTERNAL_ERROR_THREAD_EXITTED, |
INTERNAL_ERROR_INCONSISTENT_MP_INFORMATION, |
INTERNAL_ERROR_INVALID_NODE, |
INTERNAL_ERROR_NO_MPCI, |
INTERNAL_ERROR_BAD_PACKET, |
INTERNAL_ERROR_OUT_OF_PACKETS, |
INTERNAL_ERROR_OUT_OF_GLOBAL_OBJECTS, |
INTERNAL_ERROR_OUT_OF_PROXIES, |
INTERNAL_ERROR_INVALID_GLOBAL_ID, |
INTERNAL_ERROR_BAD_STACK_HOOK, |
INTERNAL_ERROR_BAD_ATTRIBUTES |
} Internal_errors_Core_list; |
|
/* |
* This type holds the fatal error information. |
*/ |
|
typedef struct { |
Internal_errors_Source the_source; |
boolean is_internal; |
unsigned32 the_error; |
} Internal_errors_Information; |
|
/* |
* When a fatal error occurs, the error information is stored here. |
*/ |
|
SCORE_EXTERN Internal_errors_Information Internal_errors_What_happened; |
|
/* |
* _Internal_error_Occurred |
* |
* DESCRIPTION: |
* |
* This routine is invoked when the application or the executive itself |
* determines that a fatal error has occurred. |
*/ |
|
void volatile _Internal_error_Occurred( |
Internal_errors_Source the_source, |
boolean is_internal, |
unsigned32 the_error |
); |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/threadmp.h
0,0 → 1,88
/* threadmp.h |
* |
* This include file contains the specification for all routines |
* and data specific to the multiprocessing portion of the thread package. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: threadmp.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_THREAD_MP_h |
#define __RTEMS_THREAD_MP_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* |
* _Thread_MP_Handler_initialization |
* |
* DESCRIPTION: |
* |
* This routine initializes the multiprocessing portion of the Thread Handler. |
*/ |
|
void _Thread_MP_Handler_initialization ( |
unsigned32 maximum_proxies |
); |
|
/* |
* _Thread_MP_Allocate_proxy |
* |
* DESCRIPTION: |
* |
* This allocates a proxy control block from |
* the inactive chain of free proxy control blocks. |
* |
* NOTE: This function returns a thread control pointer |
* because proxies are substitutes for remote threads. |
*/ |
|
Thread_Control *_Thread_MP_Allocate_proxy ( |
States_Control the_state |
); |
|
/* |
* _Thread_MP_Find_proxy |
* |
* DESCRIPTION: |
* |
* This function removes the proxy control block for the specified |
* id from the active chain of proxy control blocks. |
*/ |
|
Thread_Control *_Thread_MP_Find_proxy ( |
Objects_Id the_id |
); |
|
/* |
* The following is used to determine when the multiprocessing receive |
* thread is executing so that a proxy can be allocated instead of |
* blocking the multiprocessing receive thread. |
*/ |
|
SCORE_EXTERN Thread_Control *_Thread_MP_Receive; |
|
/* |
* The following chains are used to manage proxies. |
*/ |
|
SCORE_EXTERN Chain_Control _Thread_MP_Active_proxies; |
SCORE_EXTERN Chain_Control _Thread_MP_Inactive_proxies; |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/threadmp.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/stack.h
0,0 → 1,49
/* stack.h |
* |
* This include file contains all information about the thread |
* Stack Handler. This Handler provides mechanisms which can be used to |
* initialize and utilize stacks. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: stack.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __STACK_h |
#define __STACK_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* |
* The following constant defines the minimum stack size which every |
* thread must exceed. |
*/ |
|
#define STACK_MINIMUM_SIZE CPU_STACK_MINIMUM_SIZE |
|
/* |
* The following defines the control block used to manage each stack. |
*/ |
|
typedef struct { |
unsigned32 size; /* stack size */ |
void *area; /* low memory addr of stack */ |
} Stack_Control; |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/stack.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/object.h
0,0 → 1,476
/* object.h |
* |
* This include file contains all the constants and structures associated |
* with the Object Handler. This Handler provides mechanisms which |
* can be used to initialize and manipulate all objects which have |
* ids. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: object.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __OBJECTS_h |
#define __OBJECTS_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/chain.h> |
|
/* |
* Mask to enable unlimited objects |
* |
* XXX - needs to be moved to the API some-where |
*/ |
|
#define OBJECTS_UNLIMITED_OBJECTS 0x80000000 |
|
/* |
* The following type defines the control block used to manage |
* object names. |
*/ |
|
typedef void * Objects_Name; |
|
/* |
* Space for object names is allocated in multiples of this. |
* |
* NOTE: Must be a power of 2. Matches the name manipulation routines. |
*/ |
|
#define OBJECTS_NAME_ALIGNMENT sizeof( unsigned32 ) |
|
/* |
* Functions which compare names are prototyped like this. |
*/ |
|
typedef boolean (*Objects_Name_comparators)( |
void * /* name_1 */, |
void * /* name_2 */, |
unsigned32 /* length */ |
); |
|
/* |
* The following type defines the control block used to manage |
* object IDs. The format is as follows (0=LSB): |
* |
* Bits 0 .. 15 = index |
* Bits 16 .. 25 = node |
* Bits 26 .. 31 = class |
*/ |
|
typedef unsigned32 Objects_Id; |
|
#define OBJECTS_INDEX_START_BIT 0 |
#define OBJECTS_NODE_START_BIT 16 |
#define OBJECTS_CLASS_START_BIT 26 |
|
#define OBJECTS_INDEX_MASK 0x0000ffff |
#define OBJECTS_NODE_MASK 0x03ff0000 |
#define OBJECTS_CLASS_MASK 0xfc000000 |
|
#define OBJECTS_INDEX_VALID_BITS 0x0000ffff |
#define OBJECTS_NODE_VALID_BITS 0x000003ff |
#define OBJECTS_CLASS_VALID_BITS 0x000000cf |
|
/* |
* This enumerated type is used in the class field of the object ID. |
*/ |
|
typedef enum { |
OBJECTS_NO_CLASS = 0, |
OBJECTS_INTERNAL_THREADS = 1, |
OBJECTS_RTEMS_TASKS = 2, |
OBJECTS_POSIX_THREADS = 3, |
OBJECTS_ITRON_TASKS = 4, |
OBJECTS_RTEMS_TIMERS = 5, |
OBJECTS_RTEMS_SEMAPHORES = 6, |
OBJECTS_RTEMS_MESSAGE_QUEUES = 7, |
OBJECTS_RTEMS_PARTITIONS = 8, |
OBJECTS_RTEMS_REGIONS = 9, |
OBJECTS_RTEMS_PORTS = 10, |
OBJECTS_RTEMS_PERIODS = 11, |
OBJECTS_RTEMS_EXTENSIONS = 12, |
OBJECTS_POSIX_KEYS = 13, |
OBJECTS_POSIX_INTERRUPTS = 14, |
OBJECTS_POSIX_MESSAGE_QUEUES = 15, |
OBJECTS_POSIX_MUTEXES = 16, |
OBJECTS_POSIX_SEMAPHORES = 17, |
OBJECTS_POSIX_CONDITION_VARIABLES = 18, |
OBJECTS_ITRON_EVENTFLAGS = 19, |
OBJECTS_ITRON_MAILBOXES = 20, |
OBJECTS_ITRON_MESSAGE_BUFFERS = 21, |
OBJECTS_ITRON_PORTS = 22, |
OBJECTS_ITRON_SEMAPHORES = 23, |
OBJECTS_ITRON_VARIABLE_MEMORY_POOLS = 24, |
OBJECTS_ITRON_FIXED_MEMORY_POOLS = 25 |
} Objects_Classes; |
|
#define OBJECTS_CLASSES_FIRST OBJECTS_NO_CLASS |
#define OBJECTS_CLASSES_LAST OBJECTS_ITRON_FIXED_MEMORY_POOLS |
#define OBJECTS_CLASSES_FIRST_THREAD_CLASS OBJECTS_INTERNAL_THREADS |
#define OBJECTS_CLASSES_LAST_THREAD_CLASS OBJECTS_ITRON_TASKS |
|
/* |
* This enumerated type lists the locations which may be returned |
* by _Objects_Get. These codes indicate the success of locating |
* an object with the specified ID. |
*/ |
|
typedef enum { |
OBJECTS_LOCAL = 0, /* object is local */ |
OBJECTS_REMOTE = 1, /* object is remote */ |
OBJECTS_ERROR = 2 /* id was invalid */ |
} Objects_Locations; |
|
/* |
* The following defines the Object Control Block used to manage |
* each object local to this node. |
*/ |
|
typedef struct { |
Chain_Node Node; |
Objects_Id id; |
Objects_Name name; |
} Objects_Control; |
|
/* |
* The following defines the structure for the information used to |
* manage each class of objects. |
*/ |
|
typedef struct { |
Objects_Classes the_class; /* Class of this object */ |
Objects_Id minimum_id; /* minimum valid id of this type */ |
Objects_Id maximum_id; /* maximum valid id of this type */ |
unsigned32 maximum; /* maximum number of objects */ |
boolean auto_extend; /* TRUE if unlimited objects */ |
unsigned32 allocation_size; /* number of objects in a block */ |
unsigned32 size; /* size of the objects */ |
Objects_Control **local_table; |
Objects_Name *name_table; |
Chain_Control *global_table; /* pointer to global table */ |
Chain_Control Inactive; /* chain of inactive ctl blocks */ |
unsigned32 inactive; /* number of objects on the InActive list */ |
unsigned32 *inactive_per_block; /* used to release a block */ |
void **object_blocks; /* the object memory to remove */ |
boolean is_string; /* TRUE if names are strings */ |
unsigned32 name_length; /* maximum length of names */ |
boolean is_thread; /* TRUE if these are threads */ |
/* irregardless of API */ |
} Objects_Information; |
|
/* |
* The following defines the data storage which contains the |
* node number of the local node. |
*/ |
|
SCORE_EXTERN unsigned32 _Objects_Local_node; |
SCORE_EXTERN unsigned32 _Objects_Maximum_nodes; |
|
/* |
* The following is the list of information blocks for each object |
* class. From the ID, we can go to one of these information blocks, |
* and obtain a pointer to the appropriate object control block. |
*/ |
|
SCORE_EXTERN Objects_Information |
*_Objects_Information_table[OBJECTS_CLASSES_LAST + 1]; |
|
/* |
* The following defines the constant which may be used |
* with _Objects_Get to manipulate the calling task. |
* |
*/ |
|
#define OBJECTS_ID_OF_SELF ((Objects_Id) 0) |
|
/* |
* The following define the constants which may be used in name searches. |
*/ |
|
#define OBJECTS_SEARCH_ALL_NODES 0 |
#define OBJECTS_SEARCH_OTHER_NODES 0x7FFFFFFE |
#define OBJECTS_SEARCH_LOCAL_NODE 0x7FFFFFFF |
#define OBJECTS_WHO_AM_I 0 |
|
/* |
* Parameters and return id's for _Objects_Get_next |
*/ |
|
#define OBJECTS_ID_INITIAL_INDEX (0) |
#define OBJECTS_ID_FINAL_INDEX (0xffff) |
|
#define OBJECTS_ID_INITIAL(_class, _node) \ |
_Objects_Build_id( (_class), (_node), OBJECTS_ID_INITIAL_INDEX ) |
|
#define OBJECTS_ID_FINAL ((Objects_Id)~0) |
|
/* |
* _Objects_Handler_initialization |
* |
* DESCRIPTION: |
* |
* This function performs the initialization necessary for this handler. |
* |
*/ |
|
void _Objects_Handler_initialization( |
unsigned32 node, |
unsigned32 maximum_nodes, |
unsigned32 maximum_global_objects |
); |
|
/* |
* _Objects_Extend_information |
* |
* DESCRIPTION: |
* |
* This function extends an object class information record. |
*/ |
|
void _Objects_Extend_information( |
Objects_Information *information |
); |
|
/* |
* _Objects_Shrink_information |
* |
* DESCRIPTION: |
* |
* This function shrink an object class information record. |
*/ |
|
void _Objects_Shrink_information( |
Objects_Information *information |
); |
|
/* |
* _Objects_Initialize_information |
* |
* DESCRIPTION: |
* |
* This function initializes an object class information record. |
* SUPPORTS_GLOBAL is TRUE if the object class supports global |
* objects, and FALSE otherwise. Maximum indicates the number |
* of objects required in this class and size indicates the size |
* in bytes of each control block for this object class. The |
* name length and string designator are also set. In addition, |
* the class may be a task, therefore this information is also included. |
*/ |
|
void _Objects_Initialize_information ( |
Objects_Information *information, |
Objects_Classes the_class, |
boolean supports_global, |
unsigned32 maximum, |
unsigned32 size, |
boolean is_string, |
unsigned32 maximum_name_length, |
boolean is_task |
); |
|
/*PAGE |
* |
* _Objects_Allocate |
* |
* DESCRIPTION: |
* |
* This function allocates a object control block from |
* the inactive chain of free object control blocks. |
*/ |
|
Objects_Control *_Objects_Allocate( |
Objects_Information *information |
); |
|
/* |
* _Objects_Allocate_by_index |
* |
* DESCRIPTION: |
* |
* This function allocates the object control block |
* specified by the index from the inactive chain of |
* free object control blocks. |
*/ |
|
Objects_Control *_Objects_Allocate_by_index( |
Objects_Information *information, |
unsigned32 index, |
unsigned32 sizeof_control |
); |
|
/*PAGE |
* |
* _Objects_Free |
* |
* DESCRIPTION: |
* |
* This function frees a object control block to the |
* inactive chain of free object control blocks. |
*/ |
|
void _Objects_Free( |
Objects_Information *information, |
Objects_Control *the_object |
); |
|
/* |
* _Objects_Clear_name |
* |
* DESCRIPTION: |
* |
* XXX |
*/ |
|
void _Objects_Clear_name( |
void *name, |
unsigned32 length |
); |
|
/* |
* _Objects_Copy_name_string |
* |
* DESCRIPTION: |
* |
* XXX |
*/ |
|
void _Objects_Copy_name_string( |
void *source, |
void *destination |
); |
|
/* |
* _Objects_Copy_name_raw |
* |
* DESCRIPTION: |
* |
* XXX |
*/ |
|
void _Objects_Copy_name_raw( |
void *source, |
void *destination, |
unsigned32 length |
); |
|
/* |
* _Objects_Compare_name_string |
* |
* DESCRIPTION: |
* |
* XXX |
*/ |
|
boolean _Objects_Compare_name_string( |
void *name_1, |
void *name_2, |
unsigned32 length |
); |
|
/* |
* _Objects_Compare_name_raw |
* |
* DESCRIPTION: |
* |
* XXX |
*/ |
|
boolean _Objects_Compare_name_raw( |
void *name_1, |
void *name_2, |
unsigned32 length |
); |
/* |
* _Objects_Name_to_id |
* |
* DESCRIPTION: |
* |
* This function implements the common portion of the object |
* identification directives. This directive returns the object |
* id associated with name. If more than one object of this class |
* is named name, then the object to which the id belongs is |
* arbitrary. Node indicates the extent of the search for the |
* id of the object named name. If the object class supports global |
* objects, then the search can be limited to a particular node |
* or allowed to encompass all nodes. |
* |
*/ |
|
typedef enum { |
OBJECTS_SUCCESSFUL, |
OBJECTS_INVALID_NAME, |
OBJECTS_INVALID_NODE |
} Objects_Name_to_id_errors; |
|
#define OBJECTS_NAME_ERRORS_FIRST OBJECTS_SUCCESSFUL |
#define OBJECTS_NAME_ERRORS_LAST OBJECTS_INVALID_NODE |
|
Objects_Name_to_id_errors _Objects_Name_to_id( |
Objects_Information *information, |
Objects_Name name, |
unsigned32 node, |
Objects_Id *id |
); |
|
/* |
* _Objects_Get |
* |
* DESCRIPTION: |
* |
* This function maps object ids to object control blocks. |
* If id corresponds to a local object, then it returns |
* the_object control pointer which maps to id and location |
* is set to OBJECTS_LOCAL. If the object class supports global |
* objects and the object id is global and resides on a remote |
* node, then location is set to OBJECTS_REMOTE, and the_object |
* is undefined. Otherwise, location is set to OBJECTS_ERROR |
* and the_object is undefined. |
* |
*/ |
|
Objects_Control *_Objects_Get ( |
Objects_Information *information, |
Objects_Id id, |
Objects_Locations *location |
); |
|
/* |
* _Objects_Get_next |
* |
* DESCRIPTION: |
* |
* Like _Objects_Get, but is used to find "next" open object. |
* |
*/ |
|
Objects_Control *_Objects_Get_next( |
Objects_Information *information, |
Objects_Id id, |
Objects_Locations *location_p, |
Objects_Id *next_id_p |
); |
|
/* |
* Pieces of object.inl are promoted out to the user |
*/ |
|
#include <rtems/score/object.inl> |
#if defined(RTEMS_MULTIPROCESSING) |
#include <rtems/score/objectmp.h> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/thread.h
0,0 → 1,762
/* thread.h |
* |
* This include file contains all constants and structures associated |
* with the thread control block. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: thread.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __THREAD_h |
#define __THREAD_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/context.h> |
#include <rtems/score/cpu.h> |
#if defined(RTEMS_MULTIPROCESSING) |
#include <rtems/score/mppkt.h> |
#endif |
#include <rtems/score/object.h> |
#include <rtems/score/priority.h> |
#include <rtems/score/stack.h> |
#include <rtems/score/states.h> |
#include <rtems/score/tod.h> |
#include <rtems/score/tqdata.h> |
#include <rtems/score/watchdog.h> |
|
/* |
* The following defines the "return type" of a thread. |
* |
* NOTE: This cannot always be right. Some APIs have void |
* tasks/threads, others return pointers, others may |
* return a numeric value. Hopefully a pointer is |
* always at least as big as an unsigned32. :) |
*/ |
|
typedef void *Thread; |
|
/* |
* The following defines the ways in which the entry point for a |
* thread can be invoked. Basically, it can be passed any |
* combination/permutation of a pointer and an unsigned32 value. |
* |
* NOTE: For now, we are ignoring the return type. |
*/ |
|
typedef enum { |
THREAD_START_NUMERIC, |
THREAD_START_POINTER, |
THREAD_START_BOTH_POINTER_FIRST, |
THREAD_START_BOTH_NUMERIC_FIRST |
} Thread_Start_types; |
|
typedef Thread ( *Thread_Entry )(); /* basic type */ |
|
typedef Thread ( *Thread_Entry_numeric )( unsigned32 ); |
typedef Thread ( *Thread_Entry_pointer )( void * ); |
typedef Thread ( *Thread_Entry_both_pointer_first )( void *, unsigned32 ); |
typedef Thread ( *Thread_Entry_both_numeric_first )( unsigned32, void * ); |
|
/* |
* The following lists the algorithms used to manage the thread cpu budget. |
* |
* Reset Timeslice: At each context switch, reset the time quantum. |
* Exhaust Timeslice: Only reset the quantum once it is consumed. |
* Callout: Execute routine when budget is consumed. |
*/ |
|
typedef enum { |
THREAD_CPU_BUDGET_ALGORITHM_NONE, |
THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE, |
THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE, |
THREAD_CPU_BUDGET_ALGORITHM_CALLOUT |
} Thread_CPU_budget_algorithms; |
|
typedef struct Thread_Control_struct Thread_Control; |
|
typedef void (*Thread_CPU_budget_algorithm_callout )( Thread_Control * ); |
|
/* |
* Per task variable structure |
*/ |
|
struct rtems_task_variable_tt; |
|
struct rtems_task_variable_tt { |
struct rtems_task_variable_tt *next; |
void **ptr; |
void *gval; |
void *tval; |
void (*dtor)(void *); |
}; |
|
typedef struct rtems_task_variable_tt rtems_task_variable_t; |
|
/* |
* The following structure contains the information which defines |
* the starting state of a thread. |
*/ |
|
typedef struct { |
Thread_Entry entry_point; /* starting thread address */ |
Thread_Start_types prototype; /* how task is invoked */ |
void *pointer_argument; /* pointer argument */ |
unsigned32 numeric_argument; /* numeric argument */ |
/* initial execution modes */ |
boolean is_preemptible; |
Thread_CPU_budget_algorithms budget_algorithm; |
Thread_CPU_budget_algorithm_callout budget_callout; |
unsigned32 isr_level; |
Priority_Control initial_priority; /* initial priority */ |
boolean core_allocated_stack; |
Stack_Control Initial_stack; /* stack information */ |
void *fp_context; /* initial FP context area address */ |
void *stack; /* initial stack area address */ |
} Thread_Start_information; |
|
/* |
* The following structure contains the information necessary to manage |
* a thread which it is waiting for a resource. |
*/ |
|
#define THREAD_STATUS_PROXY_BLOCKING 0x1111111 |
|
typedef struct { |
Objects_Id id; /* waiting on this object */ |
unsigned32 count; /* "generic" fields to be used */ |
void *return_argument; /* when blocking */ |
void *return_argument_1; |
unsigned32 option; |
|
/* |
* NOTE: The following assumes that all API return codes can be |
* treated as an unsigned32. |
*/ |
unsigned32 return_code; /* status for thread awakened */ |
|
Chain_Control Block2n; /* 2 - n priority blocked chain */ |
Thread_queue_Control *queue; /* pointer to thread queue */ |
} Thread_Wait_information; |
|
/* |
* The following defines the control block used to manage |
* each thread proxy. |
* |
* NOTE: It is critical that proxies and threads have identical |
* memory images for the shared part. |
*/ |
|
typedef struct { |
Objects_Control Object; |
States_Control current_state; |
Priority_Control current_priority; |
Priority_Control real_priority; |
unsigned32 resource_count; |
Thread_Wait_information Wait; |
Watchdog_Control Timer; |
#if defined(RTEMS_MULTIPROCESSING) |
MP_packet_Prefix *receive_packet; |
#endif |
/****************** end of common block ********************/ |
Chain_Node Active; |
} Thread_Proxy_control; |
|
|
/* |
* The following record defines the control block used |
* to manage each thread. |
* |
* NOTE: It is critical that proxies and threads have identical |
* memory images for the shared part. |
*/ |
|
typedef enum { |
THREAD_API_RTEMS, |
THREAD_API_POSIX, |
THREAD_API_ITRON |
} Thread_APIs; |
|
#define THREAD_API_FIRST THREAD_API_RTEMS |
#define THREAD_API_LAST THREAD_API_ITRON |
|
struct Thread_Control_struct { |
Objects_Control Object; |
States_Control current_state; |
Priority_Control current_priority; |
Priority_Control real_priority; |
unsigned32 resource_count; |
Thread_Wait_information Wait; |
Watchdog_Control Timer; |
#if defined(RTEMS_MULTIPROCESSING) |
MP_packet_Prefix *receive_packet; |
#endif |
/****************** end of common block ********************/ |
unsigned32 suspend_count; |
boolean is_global; |
boolean do_post_task_switch_extension; |
|
boolean is_preemptible; |
void *rtems_ada_self; |
unsigned32 cpu_time_budget; |
Thread_CPU_budget_algorithms budget_algorithm; |
Thread_CPU_budget_algorithm_callout budget_callout; |
|
unsigned32 ticks_executed; |
Chain_Control *ready; |
Priority_Information Priority_map; |
Thread_Start_information Start; |
Context_Control Registers; |
void *fp_context; |
void *API_Extensions[ THREAD_API_LAST + 1 ]; |
void **extensions; |
rtems_task_variable_t *task_variables; |
}; |
|
/* |
* Self for the GNU Ada Run-Time |
*/ |
|
SCORE_EXTERN void *rtems_ada_self; |
|
/* |
* The following defines the information control block used to |
* manage this class of objects. |
*/ |
|
SCORE_EXTERN Objects_Information _Thread_Internal_information; |
|
/* |
* The following define the thread control pointers used to access |
* and manipulate the idle thread. |
*/ |
|
SCORE_EXTERN Thread_Control *_Thread_Idle; |
|
/* |
* The following context area contains the context of the "thread" |
* which invoked the start multitasking routine. This context is |
* restored as the last action of the stop multitasking routine. Thus |
* control of the processor can be returned to the environment |
* which initiated the system. |
*/ |
|
SCORE_EXTERN Context_Control _Thread_BSP_context; |
|
/* |
* The following declares the dispatch critical section nesting |
* counter which is used to prevent context switches at inopportune |
* moments. |
*/ |
|
SCORE_EXTERN volatile unsigned32 _Thread_Dispatch_disable_level; |
|
/* |
* If this is non-zero, then the post-task switch extension |
* is run regardless of the state of the per thread flag. |
*/ |
|
SCORE_EXTERN unsigned32 _Thread_Do_post_task_switch_extension; |
|
/* |
* The following holds how many user extensions are in the system. This |
* is used to determine how many user extension data areas to allocate |
* per thread. |
*/ |
|
SCORE_EXTERN unsigned32 _Thread_Maximum_extensions; |
|
/* |
* The following is used to manage the length of a timeslice quantum. |
*/ |
|
SCORE_EXTERN unsigned32 _Thread_Ticks_per_timeslice; |
|
/* |
* The following points to the array of FIFOs used to manage the |
* set of ready threads. |
*/ |
|
SCORE_EXTERN Chain_Control *_Thread_Ready_chain; |
|
/* |
* The following points to the thread which is currently executing. |
* This thread is implicitly manipulated by numerous directives. |
*/ |
|
SCORE_EXTERN Thread_Control *_Thread_Executing; |
|
/* |
* The following points to the highest priority ready thread |
* in the system. Unless the current thread is not preemptibl, |
* then this thread will be context switched to when the next |
* dispatch occurs. |
*/ |
|
SCORE_EXTERN Thread_Control *_Thread_Heir; |
|
/* |
* The following points to the thread whose floating point |
* context is currently loaded. |
*/ |
|
SCORE_EXTERN Thread_Control *_Thread_Allocated_fp; |
|
/* |
* _Thread_Handler_initialization |
* |
* DESCRIPTION: |
* |
* This routine performs the initialization necessary for this handler. |
*/ |
|
void _Thread_Handler_initialization ( |
unsigned32 ticks_per_timeslice, |
unsigned32 maximum_extensions, |
unsigned32 maximum_proxies |
); |
|
/* |
* _Thread_Create_idle |
* |
* DESCRIPTION: |
* |
* This routine creates the idle thread. |
* |
* WARNING!! No thread should be created before this one. |
*/ |
|
void _Thread_Create_idle( void ); |
|
/* |
* _Thread_Start_multitasking |
* |
* DESCRIPTION: |
* |
* This routine initiates multitasking. It is invoked only as |
* part of initialization and its invocation is the last act of |
* the non-multitasking part of the system initialization. |
*/ |
|
void _Thread_Start_multitasking( void ); |
|
/* |
* _Thread_Dispatch |
* |
* DESCRIPTION: |
* |
* This routine is responsible for transferring control of the |
* processor from the executing thread to the heir thread. As part |
* of this process, it is responsible for the following actions: |
* |
* + saving the context of the executing thread |
* + restoring the context of the heir thread |
* + dispatching any signals for the resulting executing thread |
*/ |
|
void _Thread_Dispatch( void ); |
|
/* |
* _Thread_Stack_Allocate |
* |
* DESCRIPTION: |
* |
* Allocate the requested stack space for the thread. |
* return the actual size allocated after any adjustment |
* or return zero if the allocation failed. |
* Set the Start.stack field to the address of the stack |
* |
* NOTES: NONE |
* |
*/ |
|
unsigned32 _Thread_Stack_Allocate( |
Thread_Control *the_thread, |
unsigned32 stack_size |
); |
|
/* |
* _Thread_Stack_Free |
* |
* DESCRIPTION: |
* |
* Deallocate the Thread's stack. |
* NOTES: NONE |
* |
*/ |
|
void _Thread_Stack_Free( |
Thread_Control *the_thread |
); |
|
/* |
* _Thread_Initialize |
* |
* DESCRIPTION: |
* |
* This routine initializes the specified the thread. It allocates |
* all memory associated with this thread. It completes by adding |
* the thread to the local object table so operations on this |
* thread id are allowed. |
* |
* NOTES: |
* |
* If stack_area is NULL, it is allocated from the workspace. |
* |
* If the stack is allocated from the workspace, then it is guaranteed to be |
* of at least minimum size. |
*/ |
|
boolean _Thread_Initialize( |
Objects_Information *information, |
Thread_Control *the_thread, |
void *stack_area, |
unsigned32 stack_size, |
boolean is_fp, |
Priority_Control priority, |
boolean is_preemptible, |
Thread_CPU_budget_algorithms budget_algorithm, |
Thread_CPU_budget_algorithm_callout budget_callout, |
unsigned32 isr_level, |
Objects_Name name |
); |
|
/* |
* _Thread_Start |
* |
* DESCRIPTION: |
* |
* This routine initializes the executable information for a thread |
* and makes it ready to execute. After this routine executes, the |
* thread competes with all other threads for CPU time. |
*/ |
|
boolean _Thread_Start( |
Thread_Control *the_thread, |
Thread_Start_types the_prototype, |
void *entry_point, |
void *pointer_argument, |
unsigned32 numeric_argument |
); |
|
/* |
* _Thread_Restart |
* |
* DESCRIPTION: |
* |
* This support routine restarts the specified task in a way that the |
* next time this thread executes, it will begin execution at its |
* original starting point. |
*/ |
|
/* XXX multiple task arg profiles */ |
|
boolean _Thread_Restart( |
Thread_Control *the_thread, |
void *pointer_argument, |
unsigned32 numeric_argument |
); |
|
/* |
* _Thread_Reset |
* |
* DESCRIPTION: |
* |
* This routine resets a thread to its initial state but does |
* not restart it. |
*/ |
|
void _Thread_Reset( |
Thread_Control *the_thread, |
void *pointer_argument, |
unsigned32 numeric_argument |
); |
|
/* |
* _Thread_Close |
* |
* DESCRIPTION: |
* |
* This routine frees all memory associated with the specified |
* thread and removes it from the local object table so no further |
* operations on this thread are allowed. |
*/ |
|
void _Thread_Close( |
Objects_Information *information, |
Thread_Control *the_thread |
); |
|
/* |
* _Thread_Ready |
* |
* DESCRIPTION: |
* |
* This routine removes any set states for the_thread. It performs |
* any necessary scheduling operations including the selection of |
* a new heir thread. |
*/ |
|
void _Thread_Ready( |
Thread_Control *the_thread |
); |
|
/* |
* _Thread_Clear_state |
* |
* DESCRIPTION: |
* |
* This routine clears the indicated STATES for the_thread. It performs |
* any necessary scheduling operations including the selection of |
* a new heir thread. |
*/ |
|
void _Thread_Clear_state( |
Thread_Control *the_thread, |
States_Control state |
); |
|
/* |
* _Thread_Set_state |
* |
* DESCRIPTION: |
* |
* This routine sets the indicated states for the_thread. It performs |
* any necessary scheduling operations including the selection of |
* a new heir thread. |
* |
*/ |
|
void _Thread_Set_state( |
Thread_Control *the_thread, |
States_Control state |
); |
|
/* |
* _Thread_Set_transient |
* |
* DESCRIPTION: |
* |
* This routine sets the TRANSIENT state for the_thread. It performs |
* any necessary scheduling operations including the selection of |
* a new heir thread. |
*/ |
|
void _Thread_Set_transient( |
Thread_Control *the_thread |
); |
|
/* |
* _Thread_Reset_timeslice |
* |
* DESCRIPTION: |
* |
* This routine is invoked upon expiration of the currently |
* executing thread's timeslice. If no other thread's are ready |
* at the priority of the currently executing thread, then the |
* executing thread's timeslice is reset. Otherwise, the |
* currently executing thread is placed at the rear of the |
* FIFO for this priority and a new heir is selected. |
*/ |
|
void _Thread_Reset_timeslice( void ); |
|
/* |
* _Thread_Tickle_timeslice |
* |
* DESCRIPTION: |
* |
* This routine is invoked as part of processing each clock tick. |
* It is responsible for determining if the current thread allows |
* timeslicing and, if so, when its timeslice expires. |
*/ |
|
void _Thread_Tickle_timeslice( void ); |
|
/* |
* _Thread_Yield_processor |
* |
* DESCRIPTION: |
* |
* This routine is invoked when a thread wishes to voluntarily |
* transfer control of the processor to another thread of equal |
* or greater priority. |
*/ |
|
void _Thread_Yield_processor( void ); |
|
/* |
* _Thread_Rotate_Ready_Queue |
* |
* DESCRIPTION: |
* |
* This routine is invoked to rotate the ready queue for the |
* given priority. It can be used to yeild the processor |
* by rotating the executing threads ready queue. |
*/ |
|
void _Thread_Rotate_Ready_Queue( |
Priority_Control priority |
); |
|
/* |
* _Thread_Load_environment |
* |
* DESCRIPTION: |
* |
* This routine initializes the context of the_thread to its |
* appropriate starting state. |
*/ |
|
void _Thread_Load_environment( |
Thread_Control *the_thread |
); |
|
/* |
* _Thread_Handler |
* |
* DESCRIPTION: |
* |
* This routine is the wrapper function for all threads. It is |
* the starting point for all threads. The user provided thread |
* entry point is invoked by this routine. Operations |
* which must be performed immediately before and after the user's |
* thread executes are found here. |
*/ |
|
void _Thread_Handler( void ); |
|
/* |
* _Thread_Delay_ended |
* |
* DESCRIPTION: |
* |
* This routine is invoked when a thread must be unblocked at the |
* end of a time based delay (i.e. wake after or wake when). |
*/ |
|
void _Thread_Delay_ended( |
Objects_Id id, |
void *ignored |
); |
|
/* |
* _Thread_Change_priority |
* |
* DESCRIPTION: |
* |
* This routine changes the current priority of the_thread to |
* new_priority. It performs any necessary scheduling operations |
* including the selection of a new heir thread. |
*/ |
|
void _Thread_Change_priority ( |
Thread_Control *the_thread, |
Priority_Control new_priority, |
boolean prepend_it |
); |
|
/* |
* _Thread_Set_priority |
* |
* DESCRIPTION: |
* |
* This routine updates the priority related fields in the_thread |
* control block to indicate the current priority is now new_priority. |
*/ |
|
void _Thread_Set_priority( |
Thread_Control *the_thread, |
Priority_Control new_priority |
); |
|
/* |
* _Thread_Suspend |
* |
* DESCRIPTION: |
* |
* This routine updates the related suspend fields in the_thread |
* control block to indicate the current nested level. |
*/ |
|
void _Thread_Suspend( |
Thread_Control *the_thread |
); |
|
/* |
* _Thread_Resume |
* |
* DESCRIPTION: |
* |
* This routine updates the related suspend fields in the_thread |
* control block to indicate the current nested level. A force |
* parameter of TRUE will force a resume and clear the suspend count. |
*/ |
|
void _Thread_Resume( |
Thread_Control *the_thread, |
boolean force |
); |
|
/* |
* _Thread_Evaluate_mode |
* |
* DESCRIPTION: |
* |
* This routine evaluates the current scheduling information for the |
* system and determines if a context switch is required. This |
* is usually called after changing an execution mode such as preemptability |
* for a thread. |
*/ |
|
boolean _Thread_Evaluate_mode( void ); |
|
/* |
* _Thread_Get |
* |
* NOTE: If we are not using static inlines, this must be a real |
* subroutine call. |
*/ |
|
#ifndef USE_INLINES |
Thread_Control *_Thread_Get ( |
Objects_Id id, |
Objects_Locations *location |
); |
#endif |
|
/* |
* _Thread_Idle_body |
* |
* DESCRIPTION: |
* |
* This routine is the body of the system idle thread. |
*/ |
|
#if (CPU_PROVIDES_IDLE_THREAD_BODY == FALSE) |
Thread _Thread_Idle_body( |
unsigned32 ignored |
); |
#endif |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/thread.inl> |
#endif |
#if defined(RTEMS_MULTIPROCESSING) |
#include <rtems/score/threadmp.h> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/coremutex.h
0,0 → 1,201
/* mutex.h |
* |
* This include file contains all the constants and structures associated |
* with the Mutex Handler. A mutex is an enhanced version of the standard |
* Dijkstra binary semaphore used to provide synchronization and mutual |
* exclusion capabilities. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: coremutex.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_CORE_MUTEX_h |
#define __RTEMS_CORE_MUTEX_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/thread.h> |
#include <rtems/score/threadq.h> |
#include <rtems/score/priority.h> |
#include <rtems/score/watchdog.h> |
|
/* |
* The following type defines the callout which the API provides |
* to support global/multiprocessor operations on mutexes. |
*/ |
|
typedef void ( *CORE_mutex_API_mp_support_callout )( |
Thread_Control *, |
Objects_Id |
); |
|
/* |
* Blocking disciplines for a mutex. |
*/ |
|
typedef enum { |
CORE_MUTEX_DISCIPLINES_FIFO, |
CORE_MUTEX_DISCIPLINES_PRIORITY, |
CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT, |
CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING |
} CORE_mutex_Disciplines; |
|
/* |
* Mutex handler return statuses. |
*/ |
|
typedef enum { |
CORE_MUTEX_STATUS_SUCCESSFUL, |
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT, |
CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED, |
CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE, |
CORE_MUTEX_WAS_DELETED, |
CORE_MUTEX_TIMEOUT, |
CORE_MUTEX_STATUS_CEILING_VIOLATED |
} CORE_mutex_Status; |
|
/* |
* Mutex lock nesting behavior |
* |
* CORE_MUTEX_NESTING_ACQUIRES: |
* This sequence has no blocking or errors: |
* lock(m) |
* lock(m) |
* unlock(m) |
* unlock(m) |
* |
* CORE_MUTEX_NESTING_IS_ERROR |
* This sequence returns an error at the indicated point: |
* lock(m) |
* lock(m) - already locked error |
* unlock(m) |
* |
* CORE_MUTEX_NESTING_BLOCKS |
* This sequence performs as indicated: |
* lock(m) |
* lock(m) - deadlocks or timeouts |
* unlock(m) - releases |
*/ |
|
typedef enum { |
CORE_MUTEX_NESTING_ACQUIRES, |
CORE_MUTEX_NESTING_IS_ERROR, |
CORE_MUTEX_NESTING_BLOCKS |
} CORE_mutex_Nesting_behaviors; |
|
/* |
* Locked and unlocked values |
*/ |
|
#define CORE_MUTEX_UNLOCKED 1 |
#define CORE_MUTEX_LOCKED 0 |
|
/* |
* The following defines the control block used to manage the |
* attributes of each mutex. |
*/ |
|
typedef struct { |
CORE_mutex_Nesting_behaviors lock_nesting_behavior; |
boolean only_owner_release; |
CORE_mutex_Disciplines discipline; |
Priority_Control priority_ceiling; |
} CORE_mutex_Attributes; |
|
/* |
* The following defines the control block used to manage each mutex. |
*/ |
|
typedef struct { |
Thread_queue_Control Wait_queue; |
CORE_mutex_Attributes Attributes; |
unsigned32 lock; |
unsigned32 nest_count; |
Thread_Control *holder; |
Objects_Id holder_id; |
} CORE_mutex_Control; |
|
/* |
* _CORE_mutex_Initialize |
* |
* DESCRIPTION: |
* |
* This routine initializes the mutex based on the parameters passed. |
*/ |
|
void _CORE_mutex_Initialize( |
CORE_mutex_Control *the_mutex, |
Objects_Classes the_class, |
CORE_mutex_Attributes *the_mutex_attributes, |
unsigned32 initial_lock, |
Thread_queue_Extract_callout proxy_extract_callout |
); |
|
/* |
* _CORE_mutex_Seize |
* |
* DESCRIPTION: |
* |
* This routine attempts to receive a unit from the_mutex. |
* If a unit is available or if the wait flag is FALSE, then the routine |
* returns. Otherwise, the calling task is blocked until a unit becomes |
* available. |
*/ |
|
void _CORE_mutex_Seize( |
CORE_mutex_Control *the_mutex, |
Objects_Id id, |
boolean wait, |
Watchdog_Interval timeout |
); |
|
/* |
* _CORE_mutex_Surrender |
* |
* DESCRIPTION: |
* |
* This routine frees a unit to the mutex. If a task was blocked waiting for |
* a unit from this mutex, then that task will be readied and the unit |
* given to that task. Otherwise, the unit will be returned to the mutex. |
*/ |
|
CORE_mutex_Status _CORE_mutex_Surrender( |
CORE_mutex_Control *the_mutex, |
Objects_Id id, |
CORE_mutex_API_mp_support_callout api_mutex_mp_support |
); |
|
/* |
* _CORE_mutex_Flush |
* |
* DESCRIPTION: |
* |
* This routine assists in the deletion of a mutex by flushing the associated |
* wait queue. |
*/ |
|
void _CORE_mutex_Flush( |
CORE_mutex_Control *the_mutex, |
Thread_queue_Flush_callout remote_extract_callout, |
unsigned32 status |
); |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/coremutex.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
|
/score/heap.h
0,0 → 1,225
/* heap.h |
* |
* This include file contains the information pertaining to the Heap |
* Handler. A heap is a doubly linked list of variable size |
* blocks which are allocated using the first fit method. Garbage |
* collection is performed each time a block is returned to the heap by |
* coalescing neighbor blocks. Control information for both allocated |
* and unallocated blocks is contained in the heap space. A heap header |
* contains control information for the heap. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: heap.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_HEAP_h |
#define __RTEMS_HEAP_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* |
* Status codes for heap_extend |
*/ |
|
typedef enum { |
HEAP_EXTEND_SUCCESSFUL, |
HEAP_EXTEND_ERROR, |
HEAP_EXTEND_NOT_IMPLEMENTED |
} Heap_Extend_status; |
|
/* |
* Constants used in the size/used field of each heap block to |
* indicate when a block is free or in use. |
*/ |
|
#define HEAP_BLOCK_USED 1 /* indicates block is in use */ |
#define HEAP_BLOCK_FREE 0 /* indicates block is free */ |
|
/* |
* The size/used field value for the dummy front and back flags. |
*/ |
|
#define HEAP_DUMMY_FLAG (0 + HEAP_BLOCK_USED) |
|
/* |
* The following constants reflect various requirements of the |
* heap data structures which impact the management of a heap. |
* |
* NOTE: Because free block overhead is greater than used block |
* overhead AND a portion of the allocated space is from |
* the extra free block overhead, the absolute lower bound |
* of the minimum fragment size is equal to the size of |
* the free block overhead. |
*/ |
|
#define HEAP_OVERHEAD \ |
(sizeof( unsigned32 ) * 2) /* size dummy first and last blocks */ |
#define HEAP_BLOCK_USED_OVERHEAD \ |
(sizeof( void * ) * 2) /* num bytes overhead in used block */ |
#define HEAP_MINIMUM_SIZE \ |
(HEAP_OVERHEAD + sizeof (Heap_Block)) |
/* min number of bytes the user may */ |
/* specify for the heap size */ |
|
/* |
* The following defines the data structure used to manage |
* individual blocks in a heap. When the block is allocated, the |
* next and previous fields are not used by the Heap Handler |
* and thus the address returned for the block starts at |
* the address of the next field. |
* |
* NOTE: The next and previous pointers are only valid when the |
* block is free. Caution must be exercised to insure that |
* allocated blocks are large enough to contain them and |
* that they are not accidentally overwritten when the |
* block is actually allocated. |
*/ |
|
typedef struct Heap_Block_struct Heap_Block; |
|
struct Heap_Block_struct { |
unsigned32 back_flag; /* size and status of prev block */ |
unsigned32 front_flag; /* size and status of block */ |
Heap_Block *next; /* pointer to next block */ |
Heap_Block *previous; /* pointer to previous block */ |
}; |
|
/* |
* The following defines the control block used to manage each heap. |
* |
* NOTE: |
* |
* This structure is layed out such that it can be used a a dummy |
* first and last block on the free block chain. The extra padding |
* insures the dummy last block is the correct size. |
* |
* The first Heap_Block starts at first while the second starts at |
* final. This is effectively the same trick as is used in the Chain |
* Handler. |
*/ |
|
typedef struct { |
Heap_Block *start; /* first valid block address in heap */ |
Heap_Block *final; /* last valid block address in heap */ |
|
Heap_Block *first; /* pointer to first block in heap */ |
Heap_Block *permanent_null; /* always NULL pointer */ |
Heap_Block *last; /* pointer to last block in heap */ |
unsigned32 page_size; /* allocation unit */ |
unsigned32 reserved; |
} Heap_Control; |
|
/* |
* _Heap_Initialize |
* |
* DESCRIPTION: |
* |
* This routine initializes the_heap record to manage the |
* contiguous heap of size bytes which starts at starting_address. |
* Blocks of memory are allocated from the heap in multiples of |
* page_size byte units. |
*/ |
|
unsigned32 _Heap_Initialize( |
Heap_Control *the_heap, |
void *starting_address, |
unsigned32 size, |
unsigned32 page_size |
); |
|
/* |
* _Heap_Extend |
* |
* DESCRIPTION: |
* |
* This routine grows the_heap memory area using the size bytes which |
* begin at starting_address. |
*/ |
|
Heap_Extend_status _Heap_Extend( |
Heap_Control *the_heap, |
void *starting_address, |
unsigned32 size, |
unsigned32 *amount_extended |
); |
|
/* |
* _Heap_Allocate |
* |
* DESCRIPTION: |
* |
* DESCRIPTION: |
* |
* This function attempts to allocate a block of size bytes from |
* the_heap. If insufficient memory is free in the_heap to allocate |
* a block of the requested size, then NULL is returned. |
*/ |
|
void *_Heap_Allocate( |
Heap_Control *the_heap, |
unsigned32 size |
); |
|
/* |
* _Heap_Size_of_user_area |
* |
* DESCRIPTION: |
* |
* This kernel routine sets size to the size of the given heap block. |
* It returns TRUE if the starting_address is in the heap, and FALSE |
* otherwise. |
*/ |
|
boolean _Heap_Size_of_user_area( |
Heap_Control *the_heap, |
void *starting_address, |
unsigned32 *size |
); |
|
/* |
* _Heap_Free |
* |
* DESCRIPTION: |
* |
* This routine returns the block of memory which begins |
* at starting_address to the_heap. Any coalescing which is |
* possible with the freeing of this routine is performed. |
*/ |
|
boolean _Heap_Free( |
Heap_Control *the_heap, |
void *start_address |
); |
|
/* |
* _Heap_Walk |
* |
* DESCRIPTION: |
* |
* This routine walks the heap to verify its integrity. |
*/ |
|
void _Heap_Walk( |
Heap_Control *the_heap, |
int source, |
boolean do_dump |
); |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/heap.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/tqdata.h
0,0 → 1,89
/* tqdata.h |
* |
* This include file contains all the constants and structures |
* needed to declare a thread queue. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: tqdata.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __THREAD_QUEUE_DATA_h |
#define __THREAD_QUEUE_DATA_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/chain.h> |
#include <rtems/score/priority.h> |
#include <rtems/score/states.h> |
|
/* |
* The following enumerated type details all of the disciplines |
* supported by the Thread Queue Handler. |
*/ |
|
typedef enum { |
THREAD_QUEUE_DISCIPLINE_FIFO, /* FIFO queue discipline */ |
THREAD_QUEUE_DISCIPLINE_PRIORITY /* PRIORITY queue discipline */ |
} Thread_queue_Disciplines; |
|
/* |
* The following enumerated types indicate what happened while the thread |
* queue was in the synchronization window. |
*/ |
|
typedef enum { |
THREAD_QUEUE_SYNCHRONIZED, |
THREAD_QUEUE_NOTHING_HAPPENED, |
THREAD_QUEUE_TIMEOUT, |
THREAD_QUEUE_SATISFIED |
} Thread_queue_States; |
|
/* |
* The following constants are used to manage the priority queues. |
* |
* There are four chains used to maintain a priority -- each chain |
* manages a distinct set of task priorities. The number of chains |
* is determined by TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS. |
* The following set must be consistent. |
* |
* The set below configures 4 headers -- each contains 64 priorities. |
* Header x manages priority range (x*64) through ((x*64)+63). If |
* the priority is more than half way through the priority range it |
* is in, then the search is performed from the rear of the chain. |
* This halves the search time to find the insertion point. |
*/ |
|
#define TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS 4 |
#define TASK_QUEUE_DATA_PRIORITIES_PER_HEADER 64 |
#define TASK_QUEUE_DATA_REVERSE_SEARCH_MASK 0x20 |
|
typedef struct { |
union { |
Chain_Control Fifo; /* FIFO discipline list */ |
Chain_Control Priority[TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS]; |
/* priority discipline list */ |
} Queues; |
Thread_queue_States sync_state; /* alloc/dealloc critical section */ |
Thread_queue_Disciplines discipline; /* queue discipline */ |
States_Control state; /* state of threads on Thread_q */ |
unsigned32 timeout_status; |
} Thread_queue_Control; |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/tqdata.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/sysstate.h
0,0 → 1,66
/* sysstates.h |
* |
* This include file contains information regarding the system state. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: sysstate.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_SYSTEM_STATE_h |
#define __RTEMS_SYSTEM_STATE_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* types */ |
|
/* enumerated constants */ |
|
/* |
* The following type defines the possible system states. |
*/ |
|
typedef enum { |
SYSTEM_STATE_BEFORE_INITIALIZATION, /* start -> end of 1st init part */ |
SYSTEM_STATE_BEFORE_MULTITASKING, /* end of 1st -> beginning of 2nd */ |
SYSTEM_STATE_BEGIN_MULTITASKING, /* just before multitasking starts */ |
SYSTEM_STATE_UP, /* normal operation */ |
SYSTEM_STATE_SHUTDOWN, /* shutdown */ |
SYSTEM_STATE_FAILED /* fatal error occurred */ |
} System_state_Codes; |
|
#define SYSTEM_STATE_CODES_FIRST SYSTEM_STATE_BEFORE_INITIALIZATION |
#define SYSTEM_STATE_CODES_LAST SYSTEM_STATE_FAILED |
|
/* |
* The following variable indicates whether or not this is |
* an multiprocessing system. |
*/ |
|
SCORE_EXTERN boolean _System_state_Is_multiprocessing; |
|
/* |
* The following variable contains the current system state. |
*/ |
|
SCORE_EXTERN System_state_Codes _System_state_Current; |
|
/* |
* Make it possible for the application to get the system state information. |
*/ |
|
#include <rtems/score/sysstate.inl> |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/copyrt.h
0,0 → 1,40
/* copyrt.h |
* |
* This include file contains the copyright notice for RTEMS |
* which is included in every binary copy of the executive. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: copyrt.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_COPYRIGHT_h |
#define __RTEMS_COPYRIGHT_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#ifdef SCORE_INIT |
|
const char _Copyright_Notice[] = |
"COPYRIGHT (c) 1989-1999.\n\ |
On-Line Applications Research Corporation (OAR).\n"; |
|
#else |
|
extern const char _Copyright_Notice[]; |
|
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/priority.h
0,0 → 1,96
/* priority.h |
* |
* This include file contains all thread priority manipulation routines. |
* This Handler provides mechanisms which can be used to |
* initialize and manipulate thread priorities. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: priority.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __PRIORITY_h |
#define __PRIORITY_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* |
* The following type defines the control block used to manage |
* thread priorities. |
* |
* NOTE: Priority 0 is reserved for internal threads only. |
*/ |
|
typedef unsigned32 Priority_Control; |
|
#define PRIORITY_MINIMUM 0 /* highest thread priority */ |
#define PRIORITY_MAXIMUM 255 /* lowest thread priority */ |
|
/* |
* The following record defines the information associated with |
* each thread to manage its interaction with the priority bit maps. |
*/ |
|
typedef struct { |
Priority_Bit_map_control *minor; /* addr of minor bit map slot */ |
Priority_Bit_map_control ready_major; /* priority bit map ready mask */ |
Priority_Bit_map_control ready_minor; /* priority bit map ready mask */ |
Priority_Bit_map_control block_major; /* priority bit map block mask */ |
Priority_Bit_map_control block_minor; /* priority bit map block mask */ |
} Priority_Information; |
|
/* |
* The following data items are the priority bit map. |
* Each of the sixteen bits used in the _Priority_Major_bit_map is |
* associated with one of the sixteen entries in the _Priority_Bit_map. |
* Each bit in the _Priority_Bit_map indicates whether or not there are |
* threads ready at a particular priority. The mapping of |
* individual priority levels to particular bits is processor |
* dependent as is the value of each bit used to indicate that |
* threads are ready at that priority. |
*/ |
|
SCORE_EXTERN volatile Priority_Bit_map_control _Priority_Major_bit_map; |
SCORE_EXTERN Priority_Bit_map_control |
_Priority_Bit_map[16] CPU_STRUCTURE_ALIGNMENT; |
|
/* |
* The definition of the Priority_Bit_map_control type is CPU dependent. |
* |
*/ |
|
/* |
* Priority Bitfield Manipulation Routines |
* |
* NOTE: |
* |
* These may simply be pass throughs to CPU dependent routines. |
*/ |
|
#if ( CPU_USE_GENERIC_BITFIELD_CODE == FALSE ) |
|
#define _Priority_Mask( _bit_number ) \ |
_CPU_Priority_Mask( _bit_number ) |
|
#define _Priority_Bits_index( _priority ) \ |
_CPU_Priority_bits_index( _priority ) |
|
#endif |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/priority.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/chain.h
0,0 → 1,167
/* chain.h |
* |
* This include file contains all the constants and structures associated |
* with the Doubly Linked Chain Handler. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: chain.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_CHAIN_h |
#define __RTEMS_CHAIN_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/address.h> |
|
/* |
* This is used to manage each element (node) which is placed |
* on a chain. |
* |
* NOTE: Typically, a more complicated structure will use the |
* chain package. The more complicated structure will |
* include a chain node as the first element in its |
* control structure. It will then call the chain package |
* with a pointer to that node element. The node pointer |
* and the higher level structure start at the same address |
* so the user can cast the pointers back and forth. |
* |
*/ |
|
typedef struct Chain_Node_struct Chain_Node; |
|
struct Chain_Node_struct { |
Chain_Node *next; |
Chain_Node *previous; |
}; |
|
/* |
* This is used to manage a chain. A chain consists of a doubly |
* linked list of zero or more nodes. |
* |
* NOTE: This implementation does not require special checks for |
* manipulating the first and last elements on the chain. |
* To accomplish this the chain control structure is |
* treated as two overlapping chain nodes. The permanent |
* head of the chain overlays a node structure on the |
* first and permanent_null fields. The permanent tail |
* of the chain overlays a node structure on the |
* permanent_null and last elements of the structure. |
* |
*/ |
|
typedef struct { |
Chain_Node *first; |
Chain_Node *permanent_null; |
Chain_Node *last; |
} Chain_Control; |
|
/* |
* _Chain_Initialize |
* |
* DESCRIPTION: |
* |
* This routine initializes the_chain structure to manage the |
* contiguous array of number_nodes nodes which starts at |
* starting_address. Each node is of node_size bytes. |
* |
*/ |
|
void _Chain_Initialize( |
Chain_Control *the_chain, |
void *starting_address, |
unsigned32 number_nodes, |
unsigned32 node_size |
); |
|
/* |
* _Chain_Get_first_unprotected |
*/ |
|
#ifndef USE_INLINES |
Chain_Node *_Chain_Get_first_unprotected( |
Chain_Control *the_chain |
); |
#endif |
|
/* |
* _Chain_Extract |
* |
* DESCRIPTION: |
* |
* This routine extracts the_node from the chain on which it resides. |
* It disables interrupts to insure the atomicity of the |
* extract operation. |
* |
*/ |
|
void _Chain_Extract( |
Chain_Node *the_node |
); |
|
/* |
* _Chain_Get |
* |
* DESCRIPTION: |
* |
* This function removes the first node from the_chain and returns |
* a pointer to that node. If the_chain is empty, then NULL is returned. |
* It disables interrupts to insure the atomicity of the |
* get operation. |
* |
*/ |
|
Chain_Node *_Chain_Get( |
Chain_Control *the_chain |
); |
|
/* |
* _Chain_Insert |
* |
* DESCRIPTION: |
* |
* This routine inserts the_node on a chain immediately following |
* after_node. It disables interrupts to insure the atomicity |
* of the extract operation. |
* |
*/ |
|
void _Chain_Insert( |
Chain_Node *after_node, |
Chain_Node *the_node |
); |
|
/* |
* _Chain_Append |
* |
* DESCRIPTION: |
* |
* This routine appends the_node onto the end of the_chain. |
* It disables interrupts to insure the atomicity of the |
* append operation. |
* |
*/ |
|
void _Chain_Append( |
Chain_Control *the_chain, |
Chain_Node *the_node |
); |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/chain.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/bitfield.h
0,0 → 1,97
/* bitfield.h |
* |
* This include file contains all bit field manipulation routines. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: bitfield.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_BITFIELD_h |
#define __RTEMS_BITFIELD_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* |
* _Bitfield_Find_first_bit |
* |
* DESCRIPTION: |
* |
* This routine returns the bit_number of the first bit set |
* in the specified value. The correspondence between bit_number |
* and actual bit position is processor dependent. The search for |
* the first bit set may run from most to least significant bit |
* or vice-versa. |
* |
* NOTE: |
* |
* This routine is used when the executing thread is removed |
* from the ready state and, as a result, its performance has a |
* significant impact on the performance of the executive as a whole. |
*/ |
|
#if ( CPU_USE_GENERIC_BITFIELD_DATA == TRUE ) |
|
#ifndef SCORE_INIT |
extern const unsigned char __log2table[256]; |
#else |
const unsigned char __log2table[256] = { |
7, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, |
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
}; |
#endif |
|
#endif |
|
#if ( CPU_USE_GENERIC_BITFIELD_CODE == FALSE ) |
|
#define _Bitfield_Find_first_bit( _value, _bit_number ) \ |
_CPU_Bitfield_Find_first_bit( _value, _bit_number ) |
|
#else |
|
/* |
* The following must be a macro because if a CPU specific version |
* is used it will most likely use inline assembly. |
*/ |
|
#define _Bitfield_Find_first_bit( _value, _bit_number ) \ |
{ \ |
register unsigned32 __value = (unsigned32) (_value); \ |
register const unsigned char *__p = __log2table; \ |
\ |
if ( __value < 0x100 ) \ |
(_bit_number) = __p[ __value ] + 8; \ |
else \ |
(_bit_number) = __p[ __value >> 8 ]; \ |
} |
|
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/Makefile.am
0,0 → 1,95
## |
## $Id: Makefile.am,v 1.2 2001-09-27 11:59:32 chris Exp $ |
## |
|
AUTOMAKE_OPTIONS = foreign 1.4 |
|
include $(RTEMS_ROOT)/make/custom/@RTEMS_BSP@.cfg |
include $(RTEMS_ROOT)/make/leaf.cfg |
|
# We only build multiprocessing related files if HAS_MP was defined |
MP_H_FILES = mpci.h mppkt.h objectmp.h threadmp.h |
|
# H_FILES that get installed in the rtems/score subdirectoy |
STD_H_FILES = address.h apiext.h bitfield.h chain.h context.h copyrt.h \ |
coremsg.h coremutex.h coresem.h heap.h interr.h isr.h object.h \ |
priority.h stack.h states.h sysstate.h thread.h threadq.h tod.h tqdata.h \ |
userext.h watchdog.h wkspace.h |
TARGOPTS = targopts.h |
|
if HAS_MP |
H_FILES = $(STD_H_FILES) $(TARGOPTS) $(MP_H_FILES) |
else |
H_FILES = $(STD_H_FILES) $(TARGOPTS) |
endif |
|
PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score \ |
$(H_FILES:%=$(PROJECT_INCLUDE)/rtems/score/%) |
|
$(PROJECT_INCLUDE)/rtems/score: |
@$(mkinstalldirs) $@ |
|
$(PROJECT_INCLUDE)/rtems/score/%.h: %.h |
$(INSTALL_DATA) $< $@ |
|
CLEANFILES += $(TARGOPTS) |
|
# Until RTEMS_CPU is removed from all the make configuration files, |
# this will need to be here to transform hppa1.1 into hppa1_1 to |
# make it a valid cpp symbol. At some point in the near future, |
# targopts.h should not define RTEMS_CPU. As best I can tell, |
# gcc cpp predefines eliminate the need for RTEMS_CPU_MODEL |
# on some families but not on others. For example, the i386 |
# family does not give us enough information from the predefines. |
RTEMS_CPU_DEFINED = $(subst .,_,$(RTEMS_CPU)) |
|
# make the target dependent options file |
$(TARGOPTS): |
@echo "/* target board dependent options file */" >$@ |
@echo "/* automatically generated -- DO NOT EDIT!! */" >>$@ |
@echo >>$@ |
@echo "#ifndef __TARGET_OPTIONS_h" >>$@ |
@echo "#define __TARGET_OPTIONS_h" >>$@ |
@echo >>$@ |
@echo "#ifdef $(RTEMS_CPU_DEFINED)" >>$@ |
@echo "#undef $(RTEMS_CPU_DEFINED)" >>$@ |
@echo "#endif" >>$@ |
@echo "#define $(RTEMS_CPU_DEFINED) 1" >>$@ |
@echo >>$@ |
@echo "#ifdef $(RTEMS_CPU_MODEL)" >>$@ |
@echo "#undef $(RTEMS_CPU_MODEL)" >>$@ |
@echo "#endif" >>$@ |
@echo "#define $(RTEMS_CPU_MODEL) 1" >>$@ |
@echo >>$@ |
@echo "#ifdef @RTEMS_BSP@" >>$@ |
@echo "#undef @RTEMS_BSP@" >>$@ |
@echo "#endif" >>$@ |
@echo "#define @RTEMS_BSP@ 1" >>$@ |
@echo >>$@ |
@$(make-target-options) |
@if test "$(RTEMS_USE_MACROS)" = "yes"; then \ |
echo "#define USE_MACROS 1" >>$@; \ |
else \ |
echo "#define USE_INLINES 1" >>$@; \ |
fi |
@if test "$(HAS_MP)" = "yes"; then \ |
echo "#define RTEMS_MULTIPROCESSING 1" >>$@; \ |
fi |
@if test "$(HAS_POSIX_API)" = "yes"; then \ |
echo "#define RTEMS_POSIX_API 1" >>$@; \ |
fi |
@if test "$(HAS_ITRON_API)" = "yes"; then \ |
echo "#define RTEMS_ITRON_API 1" >>$@; \ |
fi |
@if test "$(RTEMS_USE_NEWLIB)" = "yes"; then \ |
echo "#define RTEMS_NEWLIB 1" >>$@; \ |
echo "#define MALLOC_PROVIDED 1" >>$@; \ |
fi |
@echo >>$@ |
@echo "#endif" >>$@ |
|
all-local: $(PREINSTALL_FILES) |
|
EXTRA_DIST = $(STD_H_FILES) $(MP_H_FILES) |
|
include $(top_srcdir)/../../../automake/local.am |
/score/context.h
0,0 → 1,133
/* context.h |
* |
* This include file contains all information about a context. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: context.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_CONTEXT_h |
#define __RTEMS_CONTEXT_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/cpu.h> |
|
/* |
* The following constant defines the number of bytes required |
* to store a full floating point context. |
*/ |
|
#define CONTEXT_FP_SIZE CPU_CONTEXT_FP_SIZE |
|
/* |
* The following variable is set to TRUE when a reschedule operation |
* has determined that the processor should be taken away from the |
* currently executing thread and given to the heir thread. |
*/ |
|
SCORE_EXTERN volatile boolean _Context_Switch_necessary; |
|
/* |
* _Context_Initialize |
* |
* DESCRIPTION: |
* |
* This routine initializes THE_CONTEXT such that the stack |
* pointer, interrupt level, and entry point are correct for the |
* thread's initial state. |
*/ |
|
#define \ |
_Context_Initialize( _the_context, _stack, _size, _isr, _entry, _is_fp ) \ |
_CPU_Context_Initialize( _the_context, _stack, _size, _isr, _entry, _is_fp ) |
|
/* |
* _Context_Switch |
* |
* DESCRIPTION: |
* |
* This routine saves the current context into the EXECUTING |
* context record and restores the context specified by HEIR. |
*/ |
|
#define _Context_Switch( _executing, _heir ) \ |
_CPU_Context_switch( _executing, _heir ) |
|
/* |
* _Context_Restart_self |
* |
* DESCRIPTION: |
* |
* This routine restarts the calling thread by restoring its initial |
* stack pointer and returning to the thread's entry point. |
*/ |
|
#define _Context_Restart_self( _the_context ) \ |
_CPU_Context_Restart_self( _the_context ) |
|
/* |
* _Context_Fp_start |
* |
* DESCRIPTION: |
* |
* This function returns the starting address of the floating |
* point context save area. It is assumed that the are reserved |
* for the floating point save area is large enough. |
*/ |
|
#define _Context_Fp_start( _base, _offset ) \ |
_CPU_Context_Fp_start( (_base), (_offset) ) |
|
/* |
* _Context_Initialize_fp |
* |
* DESCRIPTION: |
* |
* This routine initializes the floating point context save |
* area to contain an initial known state. |
*/ |
|
#define _Context_Initialize_fp( _fp_area ) \ |
_CPU_Context_Initialize_fp( _fp_area ) |
|
/* |
* _Context_Restore_fp |
* |
* DESCRIPTION: |
* |
* This routine restores the floating point context contained |
* in the FP_CONTEXT area. It is assumed that the current |
* floating point context has been saved by a previous invocation |
* of SAVE_FP. |
*/ |
|
#define _Context_Restore_fp( _fp ) \ |
_CPU_Context_restore_fp( _fp ) |
|
/* |
* _Context_Save_fp |
* |
* DESCRIPTION: |
* |
* This routine saves the current floating point context |
* in the FP_CONTEXT area. |
*/ |
|
#define _Context_Save_fp( _fp ) \ |
_CPU_Context_save_fp( _fp ) |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/address.h
0,0 → 1,30
/* address.h |
* |
* This include file contains the information required to manipulate |
* physical addresses. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: address.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_ADDRESSES_h |
#define __RTEMS_ADDRESSES_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/address.inl> |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/tod.h
0,0 → 1,276
/* tod.h |
* |
* This include file contains all the constants and structures associated |
* with the Time of Day Handler. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: tod.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __TIME_OF_DAY_h |
#define __TIME_OF_DAY_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/object.h> |
#include <rtems/score/watchdog.h> |
|
/* |
* The following constants are related to the time of day. |
*/ |
|
#define TOD_SECONDS_PER_MINUTE 60 |
#define TOD_MINUTES_PER_HOUR 60 |
#define TOD_MONTHS_PER_YEAR 12 |
#define TOD_DAYS_PER_YEAR 365 |
#define TOD_HOURS_PER_DAY 24 |
#define TOD_SECONDS_PER_DAY (TOD_SECONDS_PER_MINUTE * \ |
TOD_MINUTES_PER_HOUR * \ |
TOD_HOURS_PER_DAY) |
|
#define TOD_SECONDS_PER_NON_LEAP_YEAR (365 * TOD_SECONDS_PER_DAY) |
|
#define TOD_MILLISECONDS_PER_SECOND 1000 |
#define TOD_MICROSECONDS_PER_SECOND 1000000 |
#define TOD_NANOSECONDS_PER_SECOND 1000000000 |
#define TOD_NANOSECONDS_PER_MICROSECOND 1000 |
|
/* |
* The following constant define the earliest year to which an |
* time of day can be initialized. This is considered the |
* epoch. |
*/ |
|
#define TOD_BASE_YEAR 1988 |
|
/* |
* The following record defines the time of control block. This |
* control block is used to maintain the current time of day. |
*/ |
|
typedef struct { /* RTEID style time/date */ |
unsigned32 year; /* year, A.D. */ |
unsigned32 month; /* month, 1 -> 12 */ |
unsigned32 day; /* day, 1 -> 31 */ |
unsigned32 hour; /* hour, 0 -> 23 */ |
unsigned32 minute; /* minute, 0 -> 59 */ |
unsigned32 second; /* second, 0 -> 59 */ |
unsigned32 ticks; /* elapsed ticks between secs */ |
} TOD_Control; |
|
/* |
* The following is TRUE if the application has set the current |
* time of day, and FALSE otherwise. |
*/ |
|
SCORE_EXTERN boolean _TOD_Is_set; |
|
/* |
* The following contains the current time of day. |
*/ |
|
SCORE_EXTERN TOD_Control _TOD_Current; |
|
/* |
* The following contains the number of seconds from 00:00:00 |
* January 1, TOD_BASE_YEAR until the current time of day. |
*/ |
|
SCORE_EXTERN Watchdog_Interval _TOD_Seconds_since_epoch; |
|
/* |
* The following contains the number of microseconds per tick. |
*/ |
|
SCORE_EXTERN unsigned32 _TOD_Microseconds_per_tick; |
|
/* |
* The following contains the number of clock ticks per second. |
* |
* NOTE: |
* |
* If one second is NOT evenly divisible by the number of microseconds |
* per clock tick, this value will contain only the integer portion |
* of the division. This means that the interval between clock ticks |
* can be a source of error in the current time of day. |
*/ |
|
SCORE_EXTERN unsigned32 _TOD_Ticks_per_second; |
|
/* |
* This is the control structure for the watchdog timer which |
* fires to service the seconds chain. |
*/ |
|
SCORE_EXTERN Watchdog_Control _TOD_Seconds_watchdog; |
|
#ifdef SCORE_INIT |
|
/* |
* The following array contains the number of days in all months. |
* The first dimension should be 1 for leap years, and 0 otherwise. |
* The second dimension should range from 1 to 12 for January to |
* February, respectively. |
*/ |
|
const unsigned32 _TOD_Days_per_month[ 2 ][ 13 ] = { |
{ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, |
{ 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } |
}; |
|
/* |
* The following array contains the number of days in all months |
* up to the month indicated by the index of the second dimension. |
* The first dimension should be 1 for leap years, and 0 otherwise. |
*/ |
|
const unsigned16 _TOD_Days_to_date[2][13] = { |
{ 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }, |
{ 0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 } |
}; |
|
/* |
* The following array contains the number of days in the years |
* since the last leap year. The index should be 0 for leap |
* years, and the number of years since the beginning of a leap |
* year otherwise. |
*/ |
|
const unsigned16 _TOD_Days_since_last_leap_year[4] = { 0, 366, 731, 1096 }; |
|
#else |
|
extern const unsigned16 _TOD_Days_to_date[2][13]; /* Julian days */ |
extern const unsigned16 _TOD_Days_since_last_leap_year[4]; |
extern const unsigned32 _TOD_Days_per_month[2][13]; |
|
#endif |
|
/* |
* _TOD_Handler_initialization |
* |
* DESCRIPTION: |
* |
* This routine performs the initialization necessary for this handler. |
*/ |
|
void _TOD_Handler_initialization( |
unsigned32 microseconds_per_tick |
); |
|
/* |
* _TOD_Set |
* |
* DESCRIPTION: |
* |
* This routine sets the current time of day to THE_TOD and |
* the equivalent SECONDS_SINCE_EPOCH. |
*/ |
|
void _TOD_Set( |
TOD_Control *the_tod, |
Watchdog_Interval seconds_since_epoch |
); |
|
/* |
* _TOD_Validate |
* |
* DESCRIPTION: |
* |
* This function returns TRUE if THE_TOD contains |
* a valid time of day, and FALSE otherwise. |
*/ |
|
boolean _TOD_Validate( |
TOD_Control *the_tod |
); |
|
/* |
* _TOD_To_seconds |
* |
* DESCRIPTION: |
* |
* This function returns the number seconds between the epoch and THE_TOD. |
*/ |
|
Watchdog_Interval _TOD_To_seconds( |
TOD_Control *the_tod |
); |
|
/* |
* _TOD_Tickle |
* |
* DESCRIPTION: |
* |
* This routine is scheduled as a watchdog function and is invoked at |
* each second boundary. It updates the current time of day to indicate |
* that a second has passed and processes the seconds watchdog chain. |
*/ |
|
void _TOD_Tickle( |
Objects_Id id, |
void *ignored |
); |
|
/* |
* TOD_MILLISECONDS_TO_MICROSECONDS |
* |
* DESCRIPTION: |
* |
* This routine converts an interval expressed in milliseconds to microseconds. |
* |
* NOTE: |
* |
* This must be a macro so it can be used in "static" tables. |
*/ |
|
#define TOD_MILLISECONDS_TO_MICROSECONDS(_ms) ((_ms) * 1000) |
|
/* |
* TOD_MICROSECONDS_TO_TICKS |
* |
* DESCRIPTION: |
* |
* This routine converts an interval expressed in microseconds to ticks. |
* |
* NOTE: |
* |
* This must be a macro so it can be used in "static" tables. |
*/ |
|
#define TOD_MICROSECONDS_TO_TICKS(_us) \ |
((_us) / _TOD_Microseconds_per_tick) |
|
/* |
* TOD_MILLISECONDS_TO_TICKS |
* |
* DESCRIPTION: |
* |
* This routine converts an interval expressed in milliseconds to ticks. |
* |
* NOTE: |
* |
* This must be a macro so it can be used in "static" tables. |
*/ |
|
#define TOD_MILLISECONDS_TO_TICKS(_ms) \ |
(TOD_MILLISECONDS_TO_MICROSECONDS(_ms) / _TOD_Microseconds_per_tick) |
|
#ifndef __RTEMS_APPLICATION__ |
#include <rtems/score/tod.inl> |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/mpci.h
0,0 → 1,411
/* mpci.h |
* |
* This include file contains all the constants and structures associated |
* with the MPCI layer. It provides mechanisms to utilize packets. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: mpci.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __MPCI_h |
#define __MPCI_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/mppkt.h> |
#include <rtems/score/states.h> |
#include <rtems/score/thread.h> |
#include <rtems/score/threadq.h> |
#include <rtems/score/tqdata.h> |
#include <rtems/score/watchdog.h> |
#include <rtems/score/coresem.h> |
|
/* |
* The following constants define the stack size requirements for |
* the system threads. |
*/ |
|
#define MPCI_RECEIVE_SERVER_STACK_SIZE \ |
( STACK_MINIMUM_SIZE + \ |
CPU_MPCI_RECEIVE_SERVER_EXTRA_STACK + \ |
_CPU_Table.extra_mpci_receive_server_stack \ |
) |
|
/* |
* The following defines the node number used when a broadcast is desired. |
*/ |
|
#define MPCI_ALL_NODES 0 |
|
/* |
* For packets associated with requests that don't already have a timeout, |
* use the one specified by this MPCI driver. The value specified by |
* the MPCI driver sets an upper limit on how long a remote request |
* should take to complete. |
*/ |
|
#define MPCI_DEFAULT_TIMEOUT 0xFFFFFFFF |
|
/* |
* The following records define the Multiprocessor Communications |
* Interface (MPCI) Table. This table defines the user-provided |
* MPCI which is a required part of a multiprocessor system. |
* |
* For non-blocking local operations that become remote operations, |
* we need a timeout. This is a per-driver timeout: default_timeout |
*/ |
|
typedef void MPCI_Entry; |
|
typedef MPCI_Entry ( *MPCI_initialization_entry )( void ); |
|
typedef MPCI_Entry ( *MPCI_get_packet_entry )( |
MP_packet_Prefix ** |
); |
|
typedef MPCI_Entry ( *MPCI_return_packet_entry )( |
MP_packet_Prefix * |
); |
|
typedef MPCI_Entry ( *MPCI_send_entry )( |
unsigned32, |
MP_packet_Prefix * |
); |
|
typedef MPCI_Entry ( *MPCI_receive_entry )( |
MP_packet_Prefix ** |
); |
|
typedef struct { |
unsigned32 default_timeout; /* in ticks */ |
unsigned32 maximum_packet_size; |
MPCI_initialization_entry initialization; |
MPCI_get_packet_entry get_packet; |
MPCI_return_packet_entry return_packet; |
MPCI_send_entry send_packet; |
MPCI_receive_entry receive_packet; |
} MPCI_Control; |
|
/* |
* The following defines the type for packet processing routines |
* invoked by the MPCI Receive server. |
*/ |
|
typedef void (*MPCI_Packet_processor)( MP_packet_Prefix * ); |
|
/* |
* The following enumerated type defines the list of |
* internal MP operations. |
*/ |
|
typedef enum { |
MPCI_PACKETS_SYSTEM_VERIFY = 0 |
} MPCI_Internal_Remote_operations; |
|
/* |
* The following data structure defines the packet used to perform |
* remote event operations. |
*/ |
|
typedef struct { |
MP_packet_Prefix Prefix; |
MPCI_Internal_Remote_operations operation; |
unsigned32 maximum_nodes; |
unsigned32 maximum_global_objects; |
} MPCI_Internal_packet; |
|
/* |
* This is the core semaphore which the MPCI Receive Server blocks on. |
*/ |
|
SCORE_EXTERN CORE_semaphore_Control _MPCI_Semaphore; |
/* |
* The following thread queue is used to maintain a list of tasks |
* which currently have outstanding remote requests. |
*/ |
|
SCORE_EXTERN Thread_queue_Control _MPCI_Remote_blocked_threads; |
|
/* |
* The following define the internal pointers to the user's |
* configuration information. |
*/ |
|
SCORE_EXTERN MPCI_Control *_MPCI_table; |
|
/* |
* The following points to the MPCI Receive Server. |
*/ |
|
SCORE_EXTERN Thread_Control *_MPCI_Receive_server_tcb; |
|
/* |
* The following table contains the process packet routines provided |
* by each object that supports MP operations. |
*/ |
|
SCORE_EXTERN MPCI_Packet_processor |
_MPCI_Packet_processors[MP_PACKET_CLASSES_LAST+1]; |
|
/* |
* _MPCI_Handler_initialization |
* |
* DESCRIPTION: |
* |
* This routine performs the initialization necessary for this handler. |
*/ |
|
void _MPCI_Handler_initialization( |
MPCI_Control *users_mpci_table, |
unsigned32 timeout_status |
); |
|
/* |
* _MPCI_Create_server |
* |
* DESCRIPTION: |
* |
* This routine creates the packet receive server used in MP systems. |
*/ |
|
void _MPCI_Create_server( void ); |
|
/* |
* _MPCI_Initialization |
* |
* DESCRIPTION: |
* |
* This routine initializes the MPCI driver by |
* invoking the user provided MPCI initialization callout. |
*/ |
|
void _MPCI_Initialization ( void ); |
|
/* |
* _MPCI_Register_packet_processor |
* |
* DESCRIPTION: |
* |
* This routine registers the MPCI packet processor for the |
* designated object class. |
*/ |
|
void _MPCI_Register_packet_processor( |
MP_packet_Classes the_class, |
MPCI_Packet_processor the_packet_processor |
|
); |
|
/* |
* _MPCI_Get_packet |
* |
* DESCRIPTION: |
* |
* This function obtains a packet by invoking the user provided |
* MPCI get packet callout. |
*/ |
|
MP_packet_Prefix *_MPCI_Get_packet ( void ); |
|
/* |
* _MPCI_Return_packet |
* |
* DESCRIPTION: |
* |
* This routine returns a packet by invoking the user provided |
* MPCI return packet callout. |
*/ |
|
void _MPCI_Return_packet ( |
MP_packet_Prefix *the_packet |
); |
|
/* |
* _MPCI_Send_process_packet |
* |
* DESCRIPTION: |
* |
* This routine sends a process packet by invoking the user provided |
* MPCI send callout. |
*/ |
|
void _MPCI_Send_process_packet ( |
unsigned32 destination, |
MP_packet_Prefix *the_packet |
); |
|
/* |
* _MPCI_Send_request_packet |
* |
* DESCRIPTION: |
* |
* This routine sends a request packet by invoking the user provided |
* MPCI send callout. |
*/ |
|
unsigned32 _MPCI_Send_request_packet ( |
unsigned32 destination, |
MP_packet_Prefix *the_packet, |
States_Control extra_state |
); |
|
/* |
* _MPCI_Send_response_packet |
* |
* DESCRIPTION: |
* |
* This routine sends a response packet by invoking the user provided |
* MPCI send callout. |
*/ |
|
void _MPCI_Send_response_packet ( |
unsigned32 destination, |
MP_packet_Prefix *the_packet |
); |
|
/* |
* _MPCI_Receive_packet |
* |
* DESCRIPTION: |
* |
* This routine receives a packet by invoking the user provided |
* MPCI receive callout. |
*/ |
|
MP_packet_Prefix *_MPCI_Receive_packet ( void ); |
|
/* |
* _MPCI_Process_response |
* |
* DESCRIPTION: |
* |
* This routine obtains a packet by invoking the user provided |
* MPCI get packet callout. |
*/ |
|
Thread_Control *_MPCI_Process_response ( |
MP_packet_Prefix *the_packet |
); |
|
/*PAGE |
* |
* _MPCI_Receive_server |
* |
*/ |
|
Thread _MPCI_Receive_server( |
unsigned32 ignored |
); |
|
/*PAGE |
* |
* _MPCI_Announce |
* |
* DESCRIPTION: |
* |
* XXX |
*/ |
|
void _MPCI_Announce ( void ); |
|
/* |
* _MPCI_Internal_packets_Send_process_packet |
* |
* DESCRIPTION: |
* |
* This routine performs a remote procedure call so that a |
* process operation can be performed on another node. |
*/ |
|
void _MPCI_Internal_packets_Send_process_packet ( |
MPCI_Internal_Remote_operations operation |
); |
|
/* |
* _MPCI_Internal_packets_Send_request_packet |
* |
* DESCRIPTION: |
* |
* This routine performs a remote procedure call so that a |
* directive operation can be initiated on another node. |
* |
* This routine is not needed since there are no request |
* packets to be sent by this manager. |
*/ |
|
/* |
* _MPCI_Internal_packets_Send_response_packet |
* |
* DESCRIPTION: |
* |
* This routine performs a remote procedure call so that a |
* directive can be performed on another node. |
* |
* This routine is not needed since there are no response |
* packets to be sent by this manager. |
*/ |
|
/* |
* |
* _MPCI_Internal_packets_Process_packet |
* |
* DESCRIPTION: |
* |
* This routine performs the actions specific to this package for |
* the request from another node. |
*/ |
|
void _MPCI_Internal_packets_Process_packet ( |
MP_packet_Prefix *the_packet_prefix |
); |
|
/* |
* _MPCI_Internal_packets_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. |
*/ |
|
/* |
* _MPCI_Internal_packets_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. |
*/ |
|
/* |
* _MPCI_Internal_packets_Get_packet |
* |
* DESCRIPTION: |
* |
* This routine is used to obtain a internal threads mp packet. |
*/ |
|
MPCI_Internal_packet *_MPCI_Internal_packets_Get_packet ( void ); |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/score/threadq.h
0,0 → 1,300
/* threadq.h |
* |
* This include file contains all the constants and structures associated |
* with the manipulation of objects. |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: threadq.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __THREAD_QUEUE_h |
#define __THREAD_QUEUE_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
#include <rtems/score/tqdata.h> |
|
#include <rtems/score/object.h> |
#include <rtems/score/thread.h> |
#include <rtems/score/watchdog.h> |
|
/* |
* Constant for indefinite wait. |
*/ |
|
#define THREAD_QUEUE_WAIT_FOREVER WATCHDOG_NO_TIMEOUT |
|
/* |
* The following type defines the callout used when a remote task |
* is extracted from a local thread queue. |
*/ |
|
typedef void ( *Thread_queue_Flush_callout )( |
Thread_Control * |
); |
|
/* |
* The following type defines the callout used when a local task |
* is extracted from a remote thread queue (i.e. it's proxy must |
* extracted from the remote queue). |
*/ |
|
typedef void ( *Thread_queue_Extract_callout )( |
Thread_Control * |
); |
|
SCORE_EXTERN Thread_queue_Extract_callout |
_Thread_queue_Extract_table[ OBJECTS_CLASSES_LAST + 1 ]; |
|
/* |
* _Thread_queue_Dequeue |
* |
* DESCRIPTION: |
* |
* This function returns a pointer to a thread waiting on |
* the_thread_queue. The selection of this thread is based on |
* the discipline of the_thread_queue. If no threads are waiting |
* on the_thread_queue, then NULL is returned. |
*/ |
|
Thread_Control *_Thread_queue_Dequeue( |
Thread_queue_Control *the_thread_queue |
); |
|
/* |
* _Thread_queue_Enqueue |
* |
* DESCRIPTION: |
* |
* This routine enqueues the currently executing thread on |
* the_thread_queue with an optional timeout. |
*/ |
|
void _Thread_queue_Enqueue( |
Thread_queue_Control *the_thread_queue, |
Watchdog_Interval timeout |
); |
|
/* |
* _Thread_queue_Extract |
* |
* DESCRIPTION: |
* |
* This routine removes the_thread from the_thread_queue |
* and cancels any timeouts associated with this blocking. |
*/ |
|
void _Thread_queue_Extract( |
Thread_queue_Control *the_thread_queue, |
Thread_Control *the_thread |
); |
|
/* |
* _Thread_queue_Extract_with_proxy |
* |
* DESCRIPTION: |
* |
* This routine extracts the_thread from the_thread_queue |
* and insures that if there is a proxy for this task on |
* another node, it is also dealt with. |
*/ |
|
boolean _Thread_queue_Extract_with_proxy( |
Thread_Control *the_thread |
); |
|
/* |
* _Thread_queue_First |
* |
* DESCRIPTION: |
* |
* This function returns a pointer to the "first" thread |
* on the_thread_queue. The "first" thread is selected |
* based on the discipline of the_thread_queue. |
*/ |
|
Thread_Control *_Thread_queue_First( |
Thread_queue_Control *the_thread_queue |
); |
|
/* |
* _Thread_queue_Flush |
* |
* DESCRIPTION: |
* |
* This routine unblocks all threads blocked on the_thread_queue |
* and cancels any associated timeouts. |
*/ |
|
void _Thread_queue_Flush( |
Thread_queue_Control *the_thread_queue, |
Thread_queue_Flush_callout remote_extract_callout, |
unsigned32 status |
); |
|
/* |
* _Thread_queue_Initialize |
* |
* DESCRIPTION: |
* |
* This routine initializes the_thread_queue based on the |
* discipline indicated in attribute_set. The state set on |
* threads which block on the_thread_queue is state. |
*/ |
|
void _Thread_queue_Initialize( |
Thread_queue_Control *the_thread_queue, |
Objects_Classes the_class, |
Thread_queue_Disciplines the_discipline, |
States_Control state, |
Thread_queue_Extract_callout proxy_extract_callout, |
unsigned32 timeout_status |
); |
|
/* |
* _Thread_queue_Dequeue_priority |
* |
* DESCRIPTION: |
* |
* This function returns a pointer to the highest priority |
* thread waiting on the_thread_queue. If no threads are waiting |
* on the_thread_queue, then NULL is returned. |
*/ |
|
Thread_Control *_Thread_queue_Dequeue_priority( |
Thread_queue_Control *the_thread_queue |
); |
|
/* |
* _Thread_queue_Enqueue_priority |
* |
* DESCRIPTION: |
* |
* This routine enqueues the currently executing thread on |
* the_thread_queue with an optional timeout using the |
* priority discipline. |
*/ |
|
void _Thread_queue_Enqueue_priority( |
Thread_queue_Control *the_thread_queue, |
Thread_Control *the_thread, |
Watchdog_Interval timeout |
); |
|
/* |
* _Thread_queue_Extract_priority |
* |
* DESCRIPTION: |
* |
* This routine removes the_thread from the_thread_queue |
* and cancels any timeouts associated with this blocking. |
*/ |
|
void _Thread_queue_Extract_priority( |
Thread_queue_Control *the_thread_queue, |
Thread_Control *the_thread |
); |
|
/* |
* _Thread_queue_First_priority |
* |
* DESCRIPTION: |
* |
* This function returns a pointer to the "first" thread |
* on the_thread_queue. The "first" thread is the highest |
* priority thread waiting on the_thread_queue. |
*/ |
|
Thread_Control *_Thread_queue_First_priority( |
Thread_queue_Control *the_thread_queue |
); |
|
/* |
* _Thread_queue_Dequeue_FIFO |
* |
* DESCRIPTION: |
* |
* This function returns a pointer to the thread which has |
* been waiting the longest on the_thread_queue. If no |
* threads are waiting on the_thread_queue, then NULL is returned. |
*/ |
|
Thread_Control *_Thread_queue_Dequeue_fifo( |
Thread_queue_Control *the_thread_queue |
); |
|
/* |
* _Thread_queue_Enqueue_FIFO |
* |
* DESCRIPTION: |
* |
* This routine enqueues the currently executing thread on |
* the_thread_queue with an optional timeout using the |
* FIFO discipline. |
*/ |
|
void _Thread_queue_Enqueue_fifo( |
Thread_queue_Control *the_thread_queue, |
Thread_Control *the_thread, |
Watchdog_Interval timeout |
); |
|
/* |
* _Thread_queue_Extract_FIFO |
* |
* DESCRIPTION: |
* |
* This routine removes the_thread from the_thread_queue |
* and cancels any timeouts associated with this blocking. |
*/ |
|
void _Thread_queue_Extract_fifo( |
Thread_queue_Control *the_thread_queue, |
Thread_Control *the_thread |
); |
|
/* |
* _Thread_queue_First_FIFO |
* |
* DESCRIPTION: |
* |
* This function returns a pointer to the "first" thread |
* on the_thread_queue. The first thread is the thread |
* which has been waiting longest on the_thread_queue. |
*/ |
|
Thread_Control *_Thread_queue_First_fifo( |
Thread_queue_Control *the_thread_queue |
); |
|
/* |
* _Thread_queue_timeout |
* |
* DESCRIPTION: |
* |
* This routine is invoked when a task's request has not |
* been satisfied after the timeout interval specified to |
* enqueue. 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 _Thread_queue_Timeout ( |
Objects_Id id, |
void *ignored |
); |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |
/debug.h
0,0 → 1,97
/* debug.h |
* |
* This include file contains the information pertaining to the debug |
* support within RTEMS. It is currently cast in the form of a |
* Manager since it is externally accessible. |
* |
* |
* COPYRIGHT (c) 1989-1999. |
* On-Line Applications Research Corporation (OAR). |
* |
* The license and distribution terms for this file may be |
* found in the file LICENSE in this distribution or at |
* http://www.OARcorp.com/rtems/license.html. |
* |
* $Id: debug.h,v 1.2 2001-09-27 11:59:32 chris Exp $ |
*/ |
|
#ifndef __RTEMS_DEBUG_h |
#define __RTEMS_DEBUG_h |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
/* |
* The following type is used to manage the debug mask. |
*/ |
|
typedef unsigned32 rtems_debug_control; |
|
/* |
* These constants represent various classes of debugging. |
*/ |
|
#define RTEMS_DEBUG_ALL_MASK 0xffffffff |
#define RTEMS_DEBUG_REGION 0x00000001 |
|
/* |
* This variable contains the current debug level. |
*/ |
|
SCORE_EXTERN rtems_debug_control _Debug_Level; |
|
/* |
* _Debug_Manager_initialization |
* |
* DESCRIPTION: |
* |
* This routine performs the initialization necessary for this manager. |
*/ |
|
void _Debug_Manager_initialization( void ); |
|
/* |
* rtems_debug_enable |
* |
* DESCRIPTION: |
* |
* This routine enables the specified types of debug checks. |
*/ |
|
void rtems_debug_enable ( |
rtems_debug_control to_be_enabled |
); |
|
/* |
* rtems_debug_disable |
* |
* DESCRIPTION: |
* |
* This routine disables the specified types of debug checks. |
*/ |
|
void rtems_debug_disable ( |
rtems_debug_control to_be_disabled |
); |
|
/* |
* |
* _Debug_Is_enabled |
* |
* DESCRIPTION: |
* |
* This routine returns TRUE if the requested debug level is |
* enabled, and FALSE otherwise. |
*/ |
|
boolean _Debug_Is_enabled( |
rtems_debug_control level |
); |
|
#ifdef __cplusplus |
} |
#endif |
|
#endif |
/* end of include file */ |