Index: cpukit/score/include/rtems/debug.h
===================================================================
--- cpukit/score/include/rtems/debug.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/debug.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,98 @@
+/*  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, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_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.
+ */
+
+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 */
Index: cpukit/score/include/rtems/score/address.h
===================================================================
--- cpukit/score/include/rtems/score/address.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/address.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,122 @@
+/*  address.h
+ *
+ *  This include file contains the information required to manipulate
+ *  physical addresses.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_ADDRESSES_h
+#define __RTEMS_ADDRESSES_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *  _Addresses_Add_offset
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to add an offset to a base address.
+ *  It returns the resulting address.  This address is typically
+ *  converted to an access type before being used further.
+ */
+
+STATIC INLINE void *_Addresses_Add_offset (
+  void       *base,
+  unsigned32  offset
+);
+
+/*
+ *  _Addresses_Subtract_offset
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to subtract an offset from a base
+ *  address.  It returns the resulting address.  This address is
+ *  typically converted to an access type before being used further.
+ */
+
+STATIC INLINE void *_Addresses_Subtract_offset(
+  void       *base,
+  unsigned32  offset
+);
+
+/*
+ *  _Addresses_Add
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to add two addresses.  It returns the
+ *  resulting address.  This address is typically converted to an
+ *  access type before being used further.
+ */
+
+STATIC INLINE void *_Addresses_Add (
+  void *left,
+  void *right
+);
+
+/*
+ *  _Addresses_Subtract
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to subtract two addresses.  It returns the
+ *  resulting offset.
+ */
+
+STATIC INLINE unsigned32 _Addresses_Subtract (
+  void *left,
+  void *right
+);
+
+/*
+ *  _Addresses_Is_aligned
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the given address is correctly
+ *  aligned for this processor and FALSE otherwise.  Proper alignment
+ *  is based on correctness and efficiency.
+ */
+
+STATIC INLINE boolean _Addresses_Is_aligned (
+  void *address
+);
+
+/*
+ *  _Addresses_Is_in_range
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the given address is within the
+ *  memory range specified and FALSE otherwise.  base is the address
+ *  of the first byte in the memory range and limit is the address
+ *  of the last byte in the memory range.  The base address is
+ *  assumed to be lower than the limit address.
+ */
+
+STATIC INLINE boolean _Addresses_Is_in_range (
+  void *address,
+  void *base,
+  void *limit
+);
+
+#include <rtems/address.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/bitfield.h
===================================================================
--- cpukit/score/include/rtems/score/bitfield.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/bitfield.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,49 @@
+/*  bitfield.h
+ *
+ *  This include file contains all bit field manipulation routines.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_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.
+ */
+
+#define _Bitfield_Find_first_bit( _value, _bit_number ) \
+        _CPU_Bitfield_Find_first_bit( _value, _bit_number )
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/chain.h
===================================================================
--- cpukit/score/include/rtems/score/chain.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/chain.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,432 @@
+/*  chain.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Doubly Linked Chain Handler.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_CHAIN_h
+#define __RTEMS_CHAIN_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/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_Initialize_empty
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine initializes the specified chain to contain zero nodes.
+ *
+ */
+
+STATIC INLINE void _Chain_Initialize_empty(
+  Chain_Control *the_chain
+);
+
+/*
+ *  _Chain_Are_nodes_equal
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if LEFT and RIGHT are equal,
+ *  and FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Chain_Are_nodes_equal(
+  Chain_Node *left,
+  Chain_Node *right
+);
+
+/*
+ *  _Chain_Extract_unprotected
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine extracts the_node from the chain on which it resides.
+ *  It does NOT disable interrupts to insure the atomicity of the
+ *  extract operation.
+ *
+ */
+
+STATIC INLINE void _Chain_Extract_unprotected(
+  Chain_Node *the_node
+);
+
+/*
+ *  _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_unprotected
+ *
+ *  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 does NOT disable interrupts to insure the atomicity of the
+ *  get operation.
+ *
+ */
+
+STATIC INLINE Chain_Node *_Chain_Get_unprotected(
+  Chain_Control *the_chain
+);
+
+/*
+ *  _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_Get_first_unprotected
+ *
+ *  DESCRIPTION:
+ *
+ *  This function removes the first node from the_chain and returns
+ *  a pointer to that node.  It does NOT disable interrupts to insure
+ *  the atomicity of the get operation.
+ *
+ */
+
+STATIC INLINE Chain_Node *_Chain_Get_first_unprotected(
+  Chain_Control *the_chain
+);
+
+/*
+ *  _Chain_Insert_unprotected
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine inserts the_node on a chain immediately following
+ *  after_node.  It does NOT disable interrupts to insure the atomicity
+ *  of the extract operation.
+ *
+ */
+
+STATIC INLINE void _Chain_Insert_unprotected(
+  Chain_Node *after_node,
+  Chain_Node *the_node
+);
+
+/*
+ *  _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_unprotected
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine appends the_node onto the end of the_chain.
+ *  It does NOT disable interrupts to insure the atomicity of the
+ *  append operation.
+ *
+ */
+
+STATIC INLINE void _Chain_Append_unprotected(
+  Chain_Control *the_chain,
+  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
+);
+
+/*
+ *  _Chain_Prepend_unprotected
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine prepends the_node onto the front of the_chain.
+ *  It does NOT disable interrupts to insure the atomicity of the
+ *  prepend operation.
+ *
+ */
+
+STATIC INLINE void _Chain_Prepend_unprotected(
+  Chain_Control *the_chain,
+  Chain_Node    *the_node
+);
+
+/*
+ *  _Chain_Prepend
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine prepends the_node onto the front of the_chain.
+ *  It disables interrupts to insure the atomicity of the
+ *  prepend operation.
+ *
+ */
+
+STATIC INLINE void _Chain_Prepend(
+  Chain_Control *the_chain,
+  Chain_Node    *the_node
+);
+
+/*
+ *  _Chain_Head
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns a pointer to the first node on the chain.
+ *
+ */
+
+STATIC INLINE Chain_Node *_Chain_Head(
+  Chain_Control *the_chain
+);
+
+/*
+ *  _Chain_Tail
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns a pointer to the last node on the chain.
+ *
+ */
+
+STATIC INLINE Chain_Node *_Chain_Tail(
+  Chain_Control *the_chain
+);
+
+/*
+ *  _Chain_Is_head
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_node is the head of the_chain and
+ *  FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Chain_Is_head(
+  Chain_Control *the_chain,
+  Chain_Node    *the_node
+);
+
+/*
+ *  _Chain_Is_tail
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_node is the tail of the_chain and
+ *  FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Chain_Is_tail(
+  Chain_Control *the_chain,
+  Chain_Node    *the_node
+);
+
+/*
+ *  _Chain_Is_first
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_node is the first node on a chain and
+ *  FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Chain_Is_first(
+  Chain_Node *the_node
+);
+
+/*
+ *  _Chain_Is_last
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_node is the last node on a chain and
+ *  FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Chain_Is_last(
+  Chain_Node *the_node
+);
+
+/*
+ *  _Chain_Is_empty
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if there a no nodes on the_chain and
+ *  FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Chain_Is_empty(
+  Chain_Control *the_chain
+);
+
+/*
+ *  _Chain_Has_only_one_node
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if there is only one node on the_chain and
+ *  FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Chain_Has_only_one_node(
+  Chain_Control *the_chain
+);
+
+/*
+ *  _Chain_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_chain is NULL and FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Chain_Is_null(
+  Chain_Control *the_chain
+);
+
+/*
+ *  _Chain_Is_null_node
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_node is NULL and FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Chain_Is_null_node(
+  Chain_Node *the_node
+);
+
+#include <rtems/chain.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/context.h
===================================================================
--- cpukit/score/include/rtems/score/context.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/context.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,133 @@
+/*  context.h
+ *
+ *  This include file contains all information about a context.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_CONTEXT_h
+#define __RTEMS_CONTEXT_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/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.
+ */
+
+EXTERN 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 ) \
+   _CPU_Context_Initialize( _the_context, _stack, _size, _isr, _entry )
+
+/*
+ *  _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 */
Index: cpukit/score/include/rtems/score/copyrt.h
===================================================================
--- cpukit/score/include/rtems/score/copyrt.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/copyrt.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,42 @@
+/*  copyrt.h
+ *
+ *  This include file contains the copyright notice for RTEMS
+ *  which is included in every binary copy of the executive.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_COPYRIGHT_h
+#define __RTEMS_COPYRIGHT_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef INIT
+
+const char _Copyright_Notice[] =
+"COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.\n\
+On-Line Applications Research Corporation (OAR).\n\
+All rights assigned to U.S. Government, 1994.\n";
+
+#else
+
+extern const char _Copyright_Notice[];
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/heap.h
===================================================================
--- cpukit/score/include/rtems/score/heap.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/heap.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,396 @@
+/*  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, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_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
+);
+
+/*
+ *  _Heap_Head
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the head of the specified heap.
+ */
+
+STATIC INLINE Heap_Block *_Heap_Head (
+  Heap_Control *the_heap
+);
+
+/*
+ *  _Heap_Tail
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the tail of the specified heap.
+ */
+
+STATIC INLINE Heap_Block *_Heap_Tail (
+  Heap_Control *the_heap
+);
+
+/*
+ *  _Heap_Previous_block
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the address of the block which physically
+ *  precedes the_block in memory.
+ */
+
+STATIC INLINE Heap_Block *_Heap_Previous_block (
+  Heap_Block *the_block
+);
+
+/*
+ *  _Heap_Next_block
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the address of the block which physically
+ *  follows the_block in memory.
+ */
+
+STATIC INLINE Heap_Block *_Heap_Next_block (
+  Heap_Block *the_block
+);
+
+/*
+ *  _Heap_Block_at
+ *
+ *  DESCRIPTION:
+ *
+ *  This function calculates and returns a block's location (address)
+ *  in the heap based upad a base address and an offset.
+ */
+
+STATIC INLINE Heap_Block *_Heap_Block_at(
+  void       *base,
+  unsigned32  offset
+);
+
+/*
+ *  _Heap_Is_previous_block_free
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the previous block of the_block
+ *  is free, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Heap_Is_previous_block_free (
+  Heap_Block *the_block
+);
+
+/*
+ *  _Heap_Is_block_free
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the block is free, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Heap_Is_block_free (
+  Heap_Block *the_block
+);
+
+/*
+ *  _Heap_Is_block_used
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the block is currently allocated,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Heap_Is_block_used (
+  Heap_Block *the_block
+);
+
+/*
+ *  _Heap_Block_size
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the size of the_block in bytes.
+ */
+
+STATIC INLINE unsigned32 _Heap_Block_size (
+  Heap_Block *the_block
+);
+
+/*
+ *  _Heap_Start_of_user_area
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the starting address of the portion of the block
+ *  which the user may access.
+ */
+
+STATIC INLINE void *_Heap_Start_of_user_area (
+  Heap_Block *the_block
+);
+
+/*
+ *  _Heap_Is_block_in
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_block is within the memory area
+ *  managed by the_heap, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Heap_Is_block_in (
+  Heap_Control *the_heap,
+  Heap_Block   *the_block
+);
+
+
+/*
+ *  _Heap_Is_page_size_valid
+ *
+ *  DESCRIPTION:
+ *
+ *  This function validates a specified heap page size.  If the page size
+ *  is 0 or if lies outside a page size alignment boundary it is invalid
+ *  and FALSE is returned.  Otherwise, the page size is valid and TRUE is
+ *  returned.
+ */
+
+STATIC INLINE boolean _Heap_Is_page_size_valid(
+  unsigned32 page_size
+);
+
+/*
+ *  _Heap_Build_flag
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the block flag composed of size and in_use_flag.
+ *  The flag returned is suitable for use as a back or front flag in a
+ *  heap block.
+ */
+
+STATIC INLINE unsigned32 _Heap_Build_flag (
+  unsigned32 size,
+  unsigned32 in_use_flag
+);
+
+#include <rtems/heap.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/isr.h
===================================================================
--- cpukit/score/include/rtems/score/isr.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/isr.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,239 @@
+/*  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, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_ISR_h
+#define __RTEMS_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 control block used to manage
+ *  the vectors.
+ */
+
+typedef unsigned32 rtems_vector_number;
+
+/*
+ *  Return type for ISR Handler
+ */
+
+typedef void rtems_isr;
+
+/*
+ *  Pointer to an ISR Handler
+ */
+
+typedef rtems_isr ( *rtems_isr_entry )(
+                 rtems_vector_number
+             );
+/*
+ *  The following is TRUE if signals have been sent to the currently
+ *  executing thread by an ISR handler.
+ */
+
+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.
+ */
+
+EXTERN unsigned32 _ISR_Nest_level;
+
+/*
+ *  The following declares the RTEMS Vector Table.  Application
+ *  interrupt service routines are vectored by RTEMS via this table.
+ */
+
+EXTERN rtems_isr_entry _ISR_Vector_table[CPU_INTERRUPT_NUMBER_OF_VECTORS];
+
+/*
+ *  _ISR_Handler_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this handler.
+ */
+
+STATIC INLINE 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_Is_in_progress
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the processor is currently servicing
+ *  and interrupt and FALSE otherwise.   A return value of TRUE indicates
+ *  that the caller is an interrupt service routine, NOT a thread.  The
+ *  directives available to an interrupt service routine are restricted.
+ */
+
+STATIC INLINE boolean _ISR_Is_in_progress( void );
+
+/*
+ *  _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_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_Is_vector_number_valid
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the vector is a valid vector number
+ *  for this processor and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _ISR_Is_vector_number_valid (
+  rtems_vector_number   vector
+);
+
+/*
+ *  _ISR_Is_valid_user_handler
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if handler is the entry point of a valid
+ *  use interrupt service routine and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _ISR_Is_valid_user_handler (
+  void *handler
+);
+
+/*
+ *  _ISR_Handler
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is the RTEMS 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/isr.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/mpci.h
===================================================================
--- cpukit/score/include/rtems/score/mpci.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/mpci.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,171 @@
+/*  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, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_MPCI_h
+#define __RTEMS_MPCI_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/mppkt.h>
+#include <rtems/states.h>
+#include <rtems/status.h>
+#include <rtems/thread.h>
+#include <rtems/threadq.h>
+#include <rtems/tqdata.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  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
+
+/*
+ *  _MPCI_Handler_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this handler.
+ */
+
+void _MPCI_Handler_initialization ( void );
+
+/*
+ *  _MPCI_Initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine initializes the MPCI driver by
+ *  invoking the user provided MPCI initialization callout.
+ */
+
+void _MPCI_Initialization ( void );
+
+/*
+ *  _MPCI_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function obtains a packet by invoking the user provided
+ *  MPCI get packet callout.
+ */
+
+rtems_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 (
+  rtems_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,
+  rtems_packet_prefix *the_packet
+);
+
+/*
+ *  _MPCI_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine sends a request packet by invoking the user provided
+ *  MPCI send callout.
+ */
+
+rtems_status_code _MPCI_Send_request_packet (
+  unsigned32         destination,
+  rtems_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,
+  rtems_packet_prefix *the_packet
+);
+
+/*
+ *  _MPCI_Receive_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine receives a packet by invoking the user provided
+ *  MPCI receive callout.
+ */
+
+rtems_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 (
+  rtems_packet_prefix *the_packet
+);
+
+/*
+ *  The following thread queue is used to maintain a list of tasks
+ *  which currently have outstanding remote requests.
+ */
+
+EXTERN Thread_queue_Control _MPCI_Remote_blocked_threads;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/mppkt.h
===================================================================
--- cpukit/score/include/rtems/score/mppkt.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/mppkt.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,123 @@
+/*  mppkt.h
+ *
+ *  This package is the specification for the Packet Handler.
+ *  This handler defines the basic RTEMS packet and provides
+ *  mechanisms to utilize packets based on this prefix.
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_MP_PACKET_h
+#define __RTEMS_MP_PACKET_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+#include <rtems/priority.h>
+#include <rtems/watchdog.h>
+
+/*
+ * The following enumerated type defines the packet classes
+ *  supported by RTEMS.
+ *
+ *  NOTE:  In general, each class corresponds to a manager
+ *         which supports global operations.  Each manager
+ *         defines the set of supported operations.
+ */
+
+typedef enum {
+  RTEMS_MP_PACKET_INTERNAL_THREADS = 0,
+  RTEMS_MP_PACKET_TASKS      = 1,
+  RTEMS_MP_PACKET_MESSAGE_QUEUE    = 2,
+  RTEMS_MP_PACKET_SEMAPHORE        = 3,
+  RTEMS_MP_PACKET_PARTITION        = 4,
+  RTEMS_MP_PACKET_REGION           = 5,
+  RTEMS_MP_PACKET_EVENT            = 6,
+  RTEMS_MP_PACKET_SIGNAL           = 7
+}   rtems_mp_packet_classes;
+
+#define MP_PACKET_CLASSES_FIRST  RTEMS_MP_PACKET_INTERNAL_THREADS
+#define MP_PACKET_CLASSES_LAST   RTEMS_MP_PACKET_SIGNAL
+
+/*
+ *  The following record contains the prefix for every packet
+ *  passed between RTEMS nodes.
+ *
+ *  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
+ *        the RTEMS project has encountered yet (i960CA).
+ */
+
+typedef struct {
+  rtems_mp_packet_classes the_class;
+  Objects_Id              id;
+  Objects_Id              source_tid;
+  rtems_task_priority     source_priority;
+  rtems_status_code       return_code;
+  unsigned32              length;
+  unsigned32              to_convert;
+  rtems_interval          timeout;
+}   rtems_packet_prefix;
+
+/*
+ *  An MPCI must support packets of at least this size.
+ */
+
+#define RTEMS_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
+ *  RTEMS_MINIMUN_HETERO_CONVERSION unsigned32's, some of the "extra" data
+ *  may a user message buffer which is not automatically endian swapped.
+ */
+
+#define RTEMS_MINIMUN_HETERO_CONVERSION  ( sizeof( rtems_packet_prefix ) / 4 )
+
+/*
+ *  _Mp_packet_Is_valid_packet_class
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the the_packet_class is valid,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Mp_packet_Is_valid_packet_class (
+  rtems_mp_packet_classes the_packet_class
+);
+
+/*
+ *  _Mp_packet_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the the_packet_class is null,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Mp_packet_Is_null (
+  rtems_packet_prefix   *the_packet
+);
+
+#include <rtems/mppkt.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/object.h
===================================================================
--- cpukit/score/include/rtems/score/object.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/object.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,380 @@
+/*  object.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the RTEMS Object Handler.  This Handler provides mechanisms which
+ *  can be used to initialize and manipulate all RTEMS objects.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_OBJECTS_h
+#define __RTEMS_OBJECTS_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/chain.h>
+
+/*
+ *  The following type defines the control block used to manage
+ *  object names.
+ */
+
+typedef unsigned32 Objects_Name;
+
+/*
+ *  The following type defines the control block used to manage
+ *  object IDs.
+ */
+
+typedef unsigned32 Objects_Id;
+
+/*
+ *  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_Control;
+
+/*
+ *  The following defines the structure for the information used to
+ *  manage each class of objects.
+ */
+
+typedef struct {
+  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 */
+  Objects_Control **local_table;     /* table of local object pointers */
+  Objects_Name     *name_table;      /* table of local object names */
+  Chain_Control    *global_table;    /* pointer to global table */
+  Chain_Control     Inactive;        /* chain of inactive ctl blocks */
+}   Objects_Information;
+
+/*
+ *  The following defines the data storage which contains the
+ *  node number of the local node.
+ */
+
+EXTERN unsigned32  _Objects_Local_node;
+
+/*
+ *  The following defines the constant which may be used
+ *  with _Objects_Get to manipulate the calling task.
+ *
+ */
+
+#define OBJECTS_ID_OF_SELF 0
+
+/*
+ *  The following define the constants which may be used in name searches.
+ */
+
+#define RTEMS_SEARCH_ALL_NODES   0
+#define RTEMS_SEARCH_OTHER_NODES 0x7FFFFFFE
+#define RTEMS_SEARCH_LOCAL_NODE  0x7FFFFFFF
+#define RTEMS_WHO_AM_I           0
+
+/*
+ *  _Objects_Handler_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This function performs the initialization necessary for this handler.
+ *
+ */
+
+void _Objects_Handler_initialization(
+  unsigned32 node,
+  unsigned32 maximum_global_objects
+);
+
+/*
+ *  _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.
+ *
+ */
+
+void _Objects_Initialize_information (
+  Objects_Information *information,
+  boolean              supports_global,
+  unsigned32           maximum,
+  unsigned32           size
+);
+
+/*
+ *  _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.
+ *
+ */
+
+rtems_status_code _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_Is_name_valid
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the name is valid, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Objects_Is_name_valid (
+  Objects_Name name
+);
+
+/*
+ *  rtems_build_name
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns an object name composed of the four characters
+ *  C1, C2, C3, and C4.
+ *
+ *  NOTE:
+ *
+ *  This must be implemented as a macro for use in Configuration Tables.
+ *
+ */
+
+#define rtems_build_name( _C1, _C2, _C3, _C4 ) \
+  ( (_C1) << 24 | (_C2) << 16 | (_C3) << 8 | (_C4) )
+
+/*
+ *  rtems_name_to_characters
+ *
+ *  DESCRIPTION:
+ *
+ *  This function breaks the object name into the four component
+ *  characters C1, C2, C3, and C4.
+ *
+ */
+
+STATIC INLINE void rtems_name_to_characters(
+  Objects_Name  name,
+  char         *c1,
+  char         *c2,
+  char         *c3,
+  char         *c4
+);
+
+/*
+ *  _Objects_Build_id
+ *
+ *  DESCRIPTION:
+ *
+ *  This function builds an object's id from the processor node and index
+ *  values specified.
+ *
+ */
+
+STATIC INLINE Objects_Id _Objects_Build_id(
+  unsigned32 node,
+  unsigned32 index
+);
+
+/*
+ *  rtems_get_node
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the node portion of the ID.
+ *
+ */
+
+STATIC INLINE unsigned32 rtems_get_node(
+  Objects_Id id
+);
+
+/*
+ *  rtems_get_index
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the index portion of the ID.
+ *
+ */
+
+STATIC INLINE unsigned32 rtems_get_index(
+  Objects_Id id
+);
+
+/*
+ *  _Objects_Is_local_node
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the node is of the local object, and
+ *  FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Objects_Is_local_node(
+  unsigned32 node
+);
+
+/*
+ *  _Objects_Is_local_id
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the id is of a local object, and
+ *  FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Objects_Is_local_id(
+  Objects_Id id
+);
+
+/*
+ *  _Objects_Are_ids_equal
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if left and right are equal,
+ *  and FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Objects_Are_ids_equal(
+  Objects_Id left,
+  Objects_Id right
+);
+
+/*
+ *  _Objects_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a object control block from
+ *  the inactive chain of free object control blocks.
+ *
+ */
+
+STATIC INLINE Objects_Control *_Objects_Allocate(
+  Objects_Information *information
+);
+
+/*
+ *  _Objects_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This function frees a object control block to the
+ *  inactive chain of free object control blocks.
+ *
+ */
+
+STATIC INLINE void _Objects_Free(
+  Objects_Information *information,
+  Objects_Control     *the_object
+);
+
+/*
+ *  _Objects_Open
+ *
+ *  DESCRIPTION:
+ *
+ *  This function places the_object control pointer and object name
+ *  in the Local Pointer and Local Name Tables, respectively.
+ *
+ */
+
+STATIC INLINE void _Objects_Open(
+  Objects_Information *information,
+  Objects_Control     *the_object,
+  Objects_Name         name
+);
+
+/*
+ *  _Objects_Close
+ *
+ *  DESCRIPTION:
+ *
+ *  This function removes the_object control pointer and object name
+ *  in the Local Pointer and Local Name Tables.
+ *
+ */
+
+STATIC INLINE void _Objects_Close(
+  Objects_Information *information,
+  Objects_Control     *the_object
+);
+
+#include <rtems/object.inl>
+#include <rtems/objectmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/objectmp.h
===================================================================
--- cpukit/score/include/rtems/score/objectmp.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/objectmp.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,165 @@
+/*  objectmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the manipulation of Global RTEMS Objects.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_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;
+  Objects_Name    name;
+}   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 maximum_global_objects
+);
+
+/*
+ *  _Objects_MP_Allocate_global_object
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a Global Object control block.
+ */
+
+STATIC INLINE Objects_MP_Control *_Objects_MP_Allocate_global_object (
+  void
+);
+
+/*
+ *  _Objects_MP_Free_global_object
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine deallocates a Global Object control block.
+ */
+
+STATIC INLINE void _Objects_MP_Free_global_object (
+  Objects_MP_Control *the_object
+);
+
+/*
+ *  _Objects_MP_Is_null_global_object
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns whether the global object is NULL or not.
+ */
+
+STATIC INLINE boolean _Objects_MP_Is_null_global_object (
+  Objects_MP_Control *the_object
+);
+
+/*
+ *  _Objects_MP_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_Open (
+  Objects_Information *information,
+  Objects_Name         the_name,
+  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.
+ */
+
+rtems_status_code _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.
+ */
+
+EXTERN Chain_Control  _Objects_MP_Inactive_global_objects;
+
+#include <rtems/objectmp.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/priority.h
===================================================================
--- cpukit/score/include/rtems/score/priority.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/priority.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,195 @@
+/*  priority.h
+ *
+ *  This include file contains all thread priority manipulation routines.
+ *  This Handler provides mechanisms which can be used to
+ *  initialize and manipulate RTEMS priorities.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_PRIORITY_h
+#define __RTEMS_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 rtems_task_priority;
+
+#define RTEMS_MINIMUM_PRIORITY      1         /* highest thread priority */
+#define RTEMS_MAXIMUM_PRIORITY      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.
+ */
+
+EXTERN volatile Priority_Bit_map_control _Priority_Major_bit_map;
+EXTERN Priority_Bit_map_control _Priority_Bit_map[16] CPU_STRUCTURE_ALIGNMENT;
+
+/*
+ *  The following constants are useful when manipulating priority.
+ */
+
+#define RTEMS_CURRENT_PRIORITY      0         /* obtain current priority */
+
+/*
+ *  The definition of the Priority_Bit_map_control type is CPU dependent.
+ *
+ */
+
+/*
+ *  _Priority_Handler_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this handler.
+ */
+
+STATIC INLINE void _Priority_Handler_initialization( void );
+
+/*
+ *  _Priority_Is_valid
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_priority if valid for a
+ *  user task, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Priority_Is_valid (
+  rtems_task_priority the_priority
+);
+
+/*
+ *  _Priority_Major
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the major portion of the_priority.
+ */
+
+STATIC INLINE unsigned32 _Priority_Major (
+  rtems_task_priority the_priority
+);
+
+/*
+ *  _Priority_Minor
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the minor portion of the_priority.
+ */
+
+STATIC INLINE unsigned32 _Priority_Minor (
+  rtems_task_priority the_priority
+);
+
+/*
+ *  _Priority_Add_to_bit_map
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine uses the_priority_map to update the priority
+ *  bit maps to indicate that a thread has been readied.
+ */
+
+STATIC INLINE void _Priority_Add_to_bit_map (
+  Priority_Information *the_priority_map
+);
+
+/*
+ *  _Priority_Remove_from_bit_map
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine uses the_priority_map to update the priority
+ *  bit maps to indicate that a thread has been removed from the
+ *  ready state.
+ */
+
+STATIC INLINE void _Priority_Remove_from_bit_map (
+  Priority_Information *the_priority_map
+);
+
+/*
+ *  _Priority_Get_highest
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the priority of the highest priority
+ *  ready thread.
+ */
+
+STATIC INLINE rtems_task_priority _Priority_Get_highest( void );
+
+/*
+ *  _Priority_Initialize_information
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine initializes the_priority_map so that it
+ *  contains the information necessary to manage a thread
+ *  at new_priority.
+ */
+
+STATIC INLINE void _Priority_Initialize_information(
+  Priority_Information *the_priority_map,
+  rtems_task_priority      new_priority
+);
+
+/*
+ *  _Priority_Is_group_empty
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the priority GROUP is empty, and
+ *  FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Priority_Is_group_empty (
+  rtems_task_priority      the_priority
+);
+
+#include <rtems/priority.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/stack.h
===================================================================
--- cpukit/score/include/rtems/score/stack.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/stack.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,95 @@
+/*  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, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_STACK_h
+#define __RTEMS_STACK_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *  The following constant defines the minimum stack size which every
+ *  thread must exceed.
+ */
+
+#define RTEMS_MINIMUM_STACK_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;
+
+/*
+ *  _Stack_Initialize
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine initializes the_stack record to indicate that
+ *  size bytes of memory starting at starting_address have been
+ *  reserved for a stack.
+ */
+
+STATIC INLINE void _Stack_Initialize (
+  Stack_Control    *the_stack,
+  void             *starting_address,
+  unsigned32        size
+);
+
+/*
+ *  _Stack_Is_enough
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if size bytes is enough memory for
+ *  a valid stack area on this processor, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Stack_Is_enough (
+  unsigned32 size
+);
+
+/*
+ *  _Stack_Adjust_size
+ *
+ *  DESCRIPTION:
+ *
+ *  This function increases the stack size to insure that the thread
+ *  has the desired amount of stack space after the initial stack
+ *  pointer is determined based on alignment restrictions.
+ *
+ *  NOTE:
+ *
+ *  The amount of adjustment for alignment is CPU dependent.
+ */
+
+STATIC INLINE unsigned32 _Stack_Adjust_size (
+  unsigned32 size
+);
+
+#include <rtems/stack.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/states.h
===================================================================
--- cpukit/score/include/rtems/score/states.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/states.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,337 @@
+/*  states.h
+ *
+ *  This include file contains all RTEMS state information.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_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               0xffff  /* all states */
+#define STATES_READY                 0x0000  /* ready to run */
+#define STATES_DORMANT               0x0001  /* created but not started */
+#define STATES_SUSPENDED             0x0002  /* waiting to be resumed */
+#define STATES_TRANSIENT             0x0004  /* thread in transition */
+#define STATES_DELAYING              0x0008  /* wait for timeout */
+#define STATES_WAITING_FOR_BUFFER    0x0010  /* wait for partition buffer */
+#define STATES_WAITING_FOR_SEGMENT   0x0020  /* wait for region segment */
+#define STATES_WAITING_FOR_MESSAGE   0x0040  /* wait for message */
+#define STATES_WAITING_FOR_EVENT     0x0080  /* wait for event */
+#define STATES_WAITING_FOR_SEMAPHORE 0x0100  /* wait for semaphore */
+#define STATES_WAITING_FOR_TIME      0x0200  /* wait for specific TOD */
+#define STATES_WAITING_FOR_RPC_REPLY 0x0400  /* wait for rpc reply */
+#define STATES_WAITING_FOR_PERIOD    0x0800  /* rate monotonic delay */
+
+#define STATES_LOCALLY_BLOCKED ( STATES_WAITING_FOR_BUFFER      | \
+                                 STATES_WAITING_FOR_SEGMENT     | \
+                                 STATES_WAITING_FOR_MESSAGE     | \
+                                 STATES_WAITING_FOR_SEMAPHORE   )
+
+#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_Set
+ *
+ *  DESCRIPTION:
+ *
+ *  This function sets the given states_to_set into the current_state
+ *  passed in.  The result is returned to the user in current_state.
+ */
+
+STATIC INLINE States_Control _States_Set (
+  States_Control states_to_set,
+  States_Control current_state
+);
+
+/*
+ *  _States_Clear
+ *
+ *  DESCRIPTION:
+ *
+ *  This function clears the given states_to_clear into the current_state
+ *  passed in.  The result is returned to the user in current_state.
+ */
+
+STATIC INLINE States_Control _States_Clear (
+  States_Control states_to_clear,
+  States_Control current_state
+);
+
+/*
+ *  _States_Is_ready
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_states indicates that the
+ *  state is READY, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_ready (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_only_dormant
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the DORMANT state is the ONLY state
+ *  set in the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_only_dormant (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_dormant
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the DORMANT state is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_dormant (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_suspended
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the SUSPENDED state is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_suspended (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_Transient
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the TRANSIENT state is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_transient (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_delaying
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the DELAYING state is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_delaying (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_waiting_for_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the WAITING_FOR_BUFFER state is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_waiting_for_buffer (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_waiting_for_segment
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the WAITING_FOR_SEGMENT state is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_waiting_for_segment (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_waiting_for_message
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the WAITING_FOR_MESSAGE state is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_waiting_for_message (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_waiting_for_event
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the WAITING_FOR_EVENT state is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_waiting_for_event (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_waiting_for_semaphore
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the WAITING_FOR_SEMAPHORE state
+ *  is set in the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_waiting_for_semaphore (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_waiting_for_time
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the WAITING_FOR_TIME state is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_waiting_for_time (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_waiting_for_rpc_reply
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the WAITING_FOR_TIME state is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_waiting_for_rpc_reply (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_waiting_for_period
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the WAITING_FOR_PERIOD state is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_waiting_for_period (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_locally_blocked
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if one of the states which indicates
+ *  that a task is blocked waiting for a local resource is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_locally_blocked (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_waiting_on_thread_queue
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if one of the states which indicates
+ *  that a task is blocked waiting for a local resource is set in
+ *  the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_waiting_on_thread_queue (
+  States_Control the_states
+);
+
+/*
+ *  _States_Is_blocked
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if one of the states which indicates
+ *  that a task is blocked is set in the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Is_blocked (
+  States_Control the_states
+);
+
+/*
+ *  _States_Are_set
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if any of the states in the mask
+ *  are set in the_states, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _States_Are_set (
+  States_Control the_states,
+  States_Control mask
+);
+
+#include <rtems/states.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/sysstate.h
===================================================================
--- cpukit/score/include/rtems/score/sysstate.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/sysstate.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,143 @@
+/*  sysstates.h
+ *
+ *  This include file contains information regarding the system state.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_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,      /* beginning of 2nd -> end of SYSI */
+  SYSTEM_STATE_UP,                      /* normal operation */
+  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 contains the current system state.
+ */
+
+EXTERN System_state_Codes _System_state_Current;
+
+/*
+ *  _System_state_Set
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine sets the current system state to that specified by
+ *  the called.
+ */
+
+STATIC INLINE void _System_state_Set (
+  System_state_Codes state
+);
+
+/*
+ *  _System_state_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the current system state.
+ */
+
+STATIC INLINE System_state_Codes _System_state_Get ( void );
+
+/*
+ *  _System_state_Is_before_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the state is equal to the
+ *  "before initialization" state, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _System_state_Is_before_initialization (
+  System_state_Codes state
+);
+
+/*
+ *  _System_state_Is_before_multitasking
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the state is equal to the
+ *  "before multitasking" state, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _System_state_Is_before_multitasking (
+  System_state_Codes state
+);
+
+/*
+ *  _System_state_Is_begin_multitasking
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the state is equal to the
+ *  "begin multitasking" state, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _System_state_Is_begin_multitasking (
+  System_state_Codes state
+);
+
+/*
+ *  _System_state_Is_up
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the state is equal to the
+ *  "up" state, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _System_state_Is_up (
+  System_state_Codes state
+);
+
+/*
+ *  _System_state_Is_failed
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the state is equal to the
+ *  "failed" state, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _System_state_Is_failed (
+  System_state_Codes state
+);
+
+#include <rtems/sysstate.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/thread.h
===================================================================
--- cpukit/score/include/rtems/score/thread.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/thread.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,721 @@
+/*  thread.h
+ *
+ *  This include file contains all constants and structures associated
+ *  with the thread control block.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_THREAD_h
+#define __RTEMS_THREAD_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/asr.h>
+#include <rtems/attr.h>
+#include <rtems/context.h>
+#include <rtems/cpu.h>
+#include <rtems/eventset.h>
+#include <rtems/modes.h>
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/priority.h>
+#include <rtems/stack.h>
+#include <rtems/states.h>
+#include <rtems/tod.h>
+#include <rtems/tqdata.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  Notepads constants (indices into notepad array)
+ */
+
+#define RTEMS_NOTEPAD_FIRST 0             /* lowest numbered notepad */
+#define RTEMS_NOTEPAD_0    0              /* notepad location 0  */
+#define RTEMS_NOTEPAD_1    1              /* notepad location 1  */
+#define RTEMS_NOTEPAD_2    2              /* notepad location 2  */
+#define RTEMS_NOTEPAD_3    3              /* notepad location 3  */
+#define RTEMS_NOTEPAD_4    4              /* notepad location 4  */
+#define RTEMS_NOTEPAD_5    5              /* notepad location 5  */
+#define RTEMS_NOTEPAD_6    6              /* notepad location 6  */
+#define RTEMS_NOTEPAD_7    7              /* notepad location 7  */
+#define RTEMS_NOTEPAD_8    8              /* notepad location 8  */
+#define RTEMS_NOTEPAD_9    9              /* notepad location 9  */
+#define RTEMS_NOTEPAD_10   10             /* notepad location 10 */
+#define RTEMS_NOTEPAD_11   11             /* notepad location 11 */
+#define RTEMS_NOTEPAD_12   12             /* notepad location 12 */
+#define RTEMS_NOTEPAD_13   13             /* notepad location 13 */
+#define RTEMS_NOTEPAD_14   14             /* notepad location 14 */
+#define RTEMS_NOTEPAD_15   15             /* notepad location 15 */
+#define RTEMS_NOTEPAD_LAST RTEMS_NOTEPAD_15     /* highest numbered notepad */
+
+/*
+ *  The following defines the "return type" of an RTEMS thread.
+ *
+ *  NOTE:  Keep both types for internal threads.
+ */
+
+typedef void rtems_task;
+typedef void Thread;
+
+/*
+ *  The following defines the argument to an RTEMS thread.
+ */
+
+typedef unsigned32 rtems_task_argument;
+typedef unsigned32 Thread_Argument;
+
+/*
+ *  The following defines the type for the entry point of an RTEMS thread.
+ */
+
+typedef rtems_task ( *rtems_task_entry )(
+                      rtems_task_argument
+                   );
+
+typedef Thread ( *Thread_Entry )(
+                      Thread_Argument
+                   );
+
+/*
+ *  The following structure contains the information which defines
+ *  the starting state of a thread.
+ */
+
+typedef struct {
+  Thread_Entry         entry_point;      /* starting thread address         */
+  unsigned32           initial_argument; /* initial argument                */
+  rtems_mode           initial_modes;    /* initial mode                    */
+  rtems_task_priority  initial_priority; /* initial priority                */
+  void                *fp_context;       /* initial FP context area address */
+  Stack_Control        Initial_stack;    /* stack information               */
+}   Thread_Start_information;
+
+/*
+ *  The following structure contains the information necessary to manage
+ *  a thread which it is  waiting for a resource.
+ */
+
+typedef struct {
+  Objects_Id            id;              /* waiting on this object       */
+  rtems_option          option_set;      /* wait mode                    */
+  union {
+    unsigned32          segment_size;    /* size of segment requested    */
+    rtems_event_set     event_condition;
+  } Extra;
+  void                 *return_argument; /* address of user return param */
+  rtems_status_code     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;
+  Objects_Name             name;
+  States_Control           current_state;
+  rtems_task_priority         current_priority;
+  rtems_task_priority         real_priority;
+  unsigned32               resource_count;
+  Thread_Wait_information  Wait;
+  Watchdog_Control         Timer;
+  rtems_packet_prefix        *receive_packet;
+     /****************** 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 struct {
+  Objects_Control           Object;
+  Objects_Name              name;
+  States_Control            current_state;
+  rtems_task_priority          current_priority;
+  rtems_task_priority          real_priority;
+  unsigned32                resource_count;
+  Thread_Wait_information   Wait;
+  Watchdog_Control          Timer;
+  rtems_packet_prefix         *receive_packet;
+     /****************** end of common block ********************/
+  Chain_Control            *ready;
+  Priority_Information      Priority_map;
+  rtems_event_set        pending_events;
+  rtems_event_set        events_out;
+  Thread_Start_information  Start;
+  ASR_Information           Signal;
+  rtems_mode             current_modes;
+  rtems_attribute        attribute_set;
+  Context_Control           Registers;
+  void                     *fp_context;
+  unsigned32                Notepads[ 16 ];
+  void                     *extension;
+}   Thread_Control;
+
+/*
+ *  External API name for Thread_Control
+ */
+
+typedef Thread_Control rtems_tcb;
+
+/*
+ *  The following declares the dispatch critical section nesting
+ *  counter which is used to prevent context switches at inopportune
+ *  moments.
+ */
+
+EXTERN unsigned32 _Thread_Dispatch_disable_level;
+
+/*
+ *  The following data items are used to manage timeslicing.
+ */
+
+EXTERN unsigned32 _Thread_Ticks_remaining_in_timeslice;
+EXTERN unsigned32 _Thread_Ticks_per_timeslice;
+
+/*
+ *  The following points to the array of FIFOs used to manage the
+ *  set of ready threads.
+ */
+
+EXTERN Chain_Control *_Thread_Ready_chain;
+
+/*
+ *  The following points to the thread which is currently executing.
+ *  This thread is implicitly manipulated by numerous directives.
+ */
+
+EXTERN Thread_Control *_Thread_Executing;
+
+/*
+ *  The following points to the highest priority ready thread
+ *  in the system.  Unless the current thread is RTEMS_NO_PREEMPT,
+ *  then this thread will be context switched to when the next
+ *  dispatch occurs.
+ */
+
+EXTERN Thread_Control *_Thread_Heir;
+
+/*
+ *  The following points to the thread whose floating point
+ *  context is currently loaded.
+ */
+
+EXTERN Thread_Control *_Thread_Allocated_fp;
+
+/*
+ *  The following defines the information control block used to
+ *  manage this class of objects.
+ */
+
+EXTERN Objects_Information _Thread_Information;
+
+/*
+ *  The following context area contains the context of the "thread"
+ *  which invoked rtems_initialize_executive.  This context is restored
+ *  as the last action of the rtems_shutdown_executive directive.  Thus
+ *  control of the processor can be returned to the environment
+ *  which initiated RTEMS.
+ */
+
+EXTERN Context_Control _Thread_BSP_context;
+
+/*
+ *  _Thread_Handler_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this handler.
+ */
+
+void _Thread_Handler_initialization (
+  unsigned32 maximum_tasks,
+  unsigned32 ticks_per_timeslice,
+  unsigned32 maximum_proxies
+);
+
+/*
+ *  _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 rtems_initialize_executive directive.
+ */
+
+void _Thread_Start_multitasking (
+  Thread_Control *system_thread,
+  Thread_Control *idle_thread
+);
+
+/*
+ *  _Thread_Stop_multitasking
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine halts multitasking and returns control to
+ *  the "thread" which initially invoked the rtems_initialize_executive
+ *  directive.
+ */
+
+STATIC INLINE void _Thread_Stop_multitasking( void );
+
+/*
+ *  _Thread_Dispatch_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine initializes the thread dispatching subsystem.
+ */
+
+STATIC INLINE void _Thread_Dispatch_initialization( 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_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
+ *  RTEMS_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_Is_executing
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_thread is the currently executing
+ *  thread, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Thread_Is_executing (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Thread_Is_heir
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_thread is the heir
+ *  thread, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Thread_Is_executing (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Thread_Is_executing_also_the_heir
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the currently executing thread
+ *  is also the heir thread, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Thread_Is_executing_also_the_heir( void );
+
+/*
+ *  _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 delay such as the rtems_task_wake_after and rtems_task_wake_when
+ *  directives.
+ */
+
+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,
+  rtems_task_priority  new_priority
+);
+
+/*
+ *  _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,
+  rtems_task_priority  new_priority
+);
+
+/*
+ *  _Thread_Change_mode
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine changes the current values of the modes
+ *  indicated by mask of the calling thread are changed to that
+ *  indicated in mode_set.  The former mode of the thread is
+ *  returned in mode_set.  If the changes in the current mode
+ *  indicate that a thread dispatch operation may be necessary,
+ *  then need_dispatch is TRUE, otherwise it is FALSE.
+ */
+
+boolean _Thread_Change_mode(
+  rtems_mode  new_mode_set,
+  rtems_mode  mask,
+  rtems_mode *old_mode_set
+);
+
+/*
+ *  _Thread_Resume
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine clears the SUSPENDED state for the_thread.  It performs
+ *  any necessary scheduling operations including the selection of
+ *  a new heir thread.
+ */
+
+STATIC INLINE void _Thread_Resume (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Thread_Unblock
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine clears any blocking state for the_thread.  It performs
+ *  any necessary scheduling operations including the selection of
+ *  a new heir thread.
+ */
+
+STATIC INLINE void _Thread_Unblock (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Thread_Restart_self
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine resets the current context of the calling thread
+ *  to that of its initial state.
+ */
+
+STATIC INLINE void _Thread_Restart_self( void );
+
+/*
+ *  _Thread_Calculate_heir
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns a pointer to the highest priority
+ *  ready thread.
+ */
+
+STATIC INLINE void _Thread_Calculate_heir( void );
+
+/*
+ *  _Thread_Is_allocated_fp
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the floating point context of
+ *  the_thread is currently loaded in the floating point unit, and
+ *  FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Thread_Is_allocated_fp (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Thread_Deallocate_fp
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when the currently loaded floating
+ *  point context is now longer associated with an active thread.
+ */
+
+STATIC INLINE void _Thread_Deallocate_fp( void );
+
+/*
+ *  _Thread_Disable_dispatch
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine prevents dispatching.
+ */
+
+STATIC INLINE void _Thread_Disable_dispatch( void );
+
+/*
+ *  _Thread_Enable_dispatch
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine allows dispatching to occur again.  If this is
+ *  the outer most dispatching critical section, then a dispatching
+ *  operation will be performed and, if necessary, control of the
+ *  processor will be transferred to the heir thread.
+ */
+
+#if ( CPU_INLINE_ENABLE_DISPATCH == TRUE )
+
+STATIC INLINE void _Thread_Enable_dispatch();
+
+#endif
+
+#if ( CPU_INLINE_ENABLE_DISPATCH == FALSE )
+
+void _Thread_Enable_dispatch( void );
+
+#endif
+
+/*
+ *  _Thread_Unnest_dispatch
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine allows dispatching to occur again.  However,
+ *  no dispatching operation is performed even if this is the outer
+ *  most dispatching critical section.
+ */
+
+STATIC INLINE void _Thread_Unnest_dispatch( void );
+
+/*
+ *  _Thread_Is_dispatching_enabled
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if dispatching is disabled, and FALSE
+ *  otherwise.
+ */
+
+STATIC INLINE boolean _Thread_Is_dispatching_enabled( void );
+
+/*
+ *  _Thread_Is_context_switch_necessary
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if dispatching is disabled, and FALSE
+ *  otherwise.
+ */
+
+STATIC INLINE boolean _Thread_Is_context_switch_necessary( void );
+
+/*
+ *  _Thread_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_thread is NULL and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Thread_Is_null (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Thread_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps thread IDs to thread control
+ *  blocks.  If ID corresponds to a local thread, then it
+ *  returns the_thread control pointer which maps to ID
+ *  and location is set to OBJECTS_LOCAL.  If the thread ID is
+ *  global and resides on a remote node, then location is set
+ *  to OBJECTS_REMOTE, and the_thread is undefined.
+ *  Otherwise, location is set to OBJECTS_ERROR and
+ *  the_thread is undefined.
+ */
+
+STATIC INLINE Thread_Control *_Thread_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+#include <rtems/thread.inl>
+#include <rtems/threadmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/threadmp.h
===================================================================
--- cpukit/score/include/rtems/score/threadmp.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/threadmp.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,134 @@
+/*  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, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_THREAD_MP_h
+#define __RTEMS_THREAD_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *  _Thread_MP_Handler_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This package is the specification for the Thread Handler's
+ *  multiprocessing specific support routines.
+ */
+
+void _Thread_MP_Handler_initialization (
+  unsigned32 maximum_proxies
+);
+
+/*
+ *  _Thread_MP_Is_receive
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns true if the thread in question is the
+ *  multiprocessing receive thread.
+ */
+
+STATIC INLINE boolean _Thread_MP_Is_receive (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _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_Free_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a proxy control block to the
+ *  inactive chain of free proxy control blocks.
+ */
+
+STATIC INLINE void _Thread_MP_Free_proxy (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _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
+);
+
+/*
+ *  _Thread_MP_Block
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine blocks the MP Receive server thread.
+ */
+
+void _Thread_MP_Block( void );
+
+/*
+ *  _Thread_MP_Ready
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine readies the MP Receive server thread.
+ */
+
+void _Thread_MP_Ready( void );
+
+/*
+ *  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.
+ */
+
+EXTERN Thread_Control *_Thread_MP_Receive;
+
+/*
+ * The following chains are used to manage proxies.
+ */
+
+EXTERN Chain_Control _Thread_MP_Active_proxies;
+EXTERN Chain_Control _Thread_MP_Inactive_proxies;
+
+#include <rtems/threadmp.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/threadq.h
===================================================================
--- cpukit/score/include/rtems/score/threadq.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/threadq.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,264 @@
+/*  threadq.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the manipulation of objects.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_THREAD_QUEUE_h
+#define __RTEMS_THREAD_QUEUE_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/tqdata.h>
+
+#include <rtems/object.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  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 *
+             );
+
+/*
+ *  _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,
+  rtems_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_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
+);
+
+/*
+ *  _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,
+  rtems_attribute    attribute_set,
+  States_Control        state
+);
+
+/*
+ *  _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,
+  rtems_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
+ *  RTEMS_FIFO discipline.
+ */
+
+void _Thread_queue_Enqueue_fifo(
+  Thread_queue_Control *the_thread_queue,
+  Thread_Control       *the_thread,
+  rtems_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 */
Index: cpukit/score/include/rtems/score/tod.h
===================================================================
--- cpukit/score/include/rtems/score/tod.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/tod.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,300 @@
+/*  tod.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Time of Day Handler.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_TIME_OF_DAY_h
+#define __RTEMS_TIME_OF_DAY_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+#include <rtems/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_MICROSECONDS_PER_SECOND 1000000
+#define TOD_MILLISECONDS_PER_SECOND 1000
+
+/*
+ *  The following constant define the earliest year to which an
+ *  RTEMS 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 */
+}   rtems_time_of_day;
+
+/*
+ *  The following contains the current time of day.
+ */
+
+EXTERN rtems_time_of_day _TOD_Current;
+
+/*
+ *  The following contains the number of seconds from 00:00:00
+ *  January 1, TOD_BASE_YEAR until the current time of day.
+ */
+
+EXTERN rtems_interval _TOD_Seconds_since_epoch;
+
+/*
+ *  The following contains the number of ticks since the
+ *  system was booted.
+ */
+
+EXTERN rtems_interval _TOD_Ticks_since_boot;
+
+/*
+ *  The following contains the number of microseconds per tick.
+ */
+
+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.
+ */
+
+EXTERN unsigned32 _TOD_Ticks_per_second;
+
+/*
+ *  This is the control structure for the watchdog timer which
+ *  fires to service the seconds chain.
+ */
+
+EXTERN Watchdog_Control _TOD_Seconds_watchdog;
+
+#ifdef 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, 761, 1126 };
+
+#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(
+  rtems_time_of_day       *the_tod,
+  rtems_interval  seconds_since_epoch
+);
+
+/*
+ *  _TOD_Validate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns STATUS.RTEMS_SUCCESSFUL if THE_TOD contains
+ *  a valid time of day, and FALSE otherwise.
+ */
+
+rtems_status_code _TOD_Validate(
+  rtems_time_of_day *the_tod
+);
+
+/*
+ *  _TOD_To_seconds
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the number seconds between the epoch and THE_TOD.
+ */
+
+rtems_interval _TOD_To_seconds(
+  rtems_time_of_day *the_tod
+);
+
+/*
+ *  _TOD_Is_set
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the application has set the current
+ *  time of day, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _TOD_Is_set( void );
+
+/*
+ *  _TOD_Tickle_ticks
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine increments the ticks field of the current time of
+ *  day at each clock tick.
+ */
+
+STATIC INLINE void _TOD_Tickle_ticks( void );
+
+/*
+ *  _TOD_Deactivate
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine deactivates updating of the current time of day.
+ */
+
+STATIC INLINE void _TOD_Deactivate( void );
+
+/*
+ *  _TOD_Activate
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine deactivates updating of the current time of day.
+ */
+
+STATIC INLINE void _TOD_Activate(
+  rtems_interval ticks
+);
+
+/*
+ *  _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
+);
+
+/*
+ *  RTEMS_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 RTEMS_MILLISECONDS_TO_MICROSECONDS(_ms) ((_ms) * 1000)
+
+/*
+ *  RTEMS_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 RTEMS_MILLISECONDS_TO_TICKS(_ms) \
+    (RTEMS_MILLISECONDS_TO_MICROSECONDS(_ms) / _TOD_Microseconds_per_tick)
+
+#include <rtems/tod.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/tqdata.h
===================================================================
--- cpukit/score/include/rtems/score/tqdata.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/tqdata.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,90 @@
+/*  tqdata.h
+ *
+ *  This include file contains all the constants and structures
+ *  needed to declare a thread queue.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_THREAD_QUEUE_DATA_h
+#define __RTEMS_THREAD_QUEUE_DATA_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/chain.h>
+#include <rtems/priority.h>
+#include <rtems/states.h>
+
+/*
+ *  The following enumerated type details all of the disciplines
+ *  supported by the Thread Queue Handler.
+ */
+
+typedef enum {
+  THREAD_QUEUE_DATA_FIFO_DISCIPLINE,     /* RTEMS_FIFO queue discipline */
+  THREAD_QUEUE_DATA_PRIORITY_DISCIPLINE, /* RTEMS_PRIORITY queue discipline */
+}   Thread_queue_Disciplines;
+
+/*
+ *  The following record defines the control block used
+ *  to manage each thread.
+ */
+
+#define TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS 4   /* # of pri groups */
+
+typedef struct {
+  union {
+    Chain_Control Fifo;                /* FIFO discipline list           */
+    Chain_Control Priority[TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS];
+                                       /* priority discipline list       */
+  } Queues;
+  boolean                  sync;       /* alloc/dealloc critical section */
+  Thread_queue_Disciplines discipline; /* queue discipline               */
+  States_Control           state;      /* state of threads on Thread_q   */
+}   Thread_queue_Control;
+
+/*
+ *  _Thread_queue_Header_number
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the index of the priority chain on which
+ *  a thread of the_priority should be placed.
+ */
+
+STATIC INLINE unsigned32 _Thread_queue_Header_number (
+  rtems_task_priority the_priority
+);
+
+/*
+ *  _Thread_queue_Is_reverse_search
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_priority indicates that the
+ *  enqueue search should start at the front of this priority
+ *  group chain, and FALSE if the search should start at the rear.
+ */
+
+STATIC INLINE boolean _Thread_queue_Is_reverse_search (
+  rtems_task_priority the_priority
+);
+
+#include <rtems/tqdata.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/userext.h
===================================================================
--- cpukit/score/include/rtems/score/userext.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/userext.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,213 @@
+/*  userext.h
+ *
+ *  This include file contains all information about user extensions.  This
+ *  Handler provides mechanisms which can be used to initialize and manipulate
+ *  all RTEMS user extensions.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_USER_EXTENSIONS_h
+#define __RTEMS_USER_EXTENSIONS_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/config.h>
+#include <rtems/thread.h>
+
+/*
+ *  The following is used to manage each user extension set.
+ */
+
+typedef struct {
+  Chain_Node                     Node;
+  rtems_extensions_table  Callouts;
+}   User_extensions_Control;
+
+/*
+ *  The following contains the static extension set which may be
+ *  configured by the application.
+ */
+
+EXTERN User_extensions_Control _User_extensions_Initial;
+
+/*
+ *  The following is used to manage the list of active extensions.
+ */
+
+EXTERN Chain_Control _User_extensions_List;
+
+
+/*
+ *  _User_extensions_Handler_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this handler.
+ */
+
+STATIC INLINE void _User_extensions_Handler_initialization (
+    rtems_extensions_table *initial_extensions
+);
+
+/*
+ *  _User_extensions_Add_set
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is used to add a user extension set to the active list.
+ */
+
+STATIC INLINE void _User_extensions_Add_set (
+  User_extensions_Control       *the_extension,
+  rtems_extensions_table *extension_table
+);
+
+/*
+ *  _User_extensions_Remove_set
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is used to remove a user extension set from the active list.
+ */
+
+STATIC INLINE void _User_extensions_Remove_set (
+  User_extensions_Control  *the_extension
+);
+
+/*
+ *  _User_extensions_Task_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is used to invoke the user extension for
+ *  the rtems_task_create directive.
+ */
+
+STATIC INLINE void _User_extensions_Task_create (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _User_extensions_Task_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is used to invoke the user extension for
+ *  the rtems_task_delete directive.
+ */
+
+STATIC INLINE void _User_extensions_Task_delete (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _User_extensions_Task_start
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is used to invoke the user extension for
+ *  the rtems_task_start directive.
+ */
+
+STATIC INLINE void _User_extensions_Task_start (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _User_extensions_Task_restart
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is used to invoke the user extension for
+ *  the rtems_task_restart directive.
+ */
+
+STATIC INLINE void _User_extensions_Task_restart (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _User_extensions_Task_switch
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is used to invoke the user extension which
+ *  is invoked when a context switch occurs.
+ */
+
+STATIC INLINE void _User_extensions_Task_switch (
+  Thread_Control *executing,
+  Thread_Control *heir
+);
+
+/*
+ *  _User_extensions_Task_begin
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is used to invoke the user extension which
+ *  is invoked when a task begins.
+ */
+
+STATIC INLINE void _User_extensions_Task_begin (
+  Thread_Control *executing
+);
+
+/*
+ *  _User_extensions_Task_exitted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is used to invoke the user extension which
+ *  is invoked when a task exits.
+ */
+
+STATIC INLINE void _User_extensions_Task_exitted (
+  Thread_Control *executing
+);
+
+/*
+ *  _User_extensions_Task_exitted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is used to invoke the user extension which
+ *  is invoked when a task exits.
+ */
+
+STATIC INLINE void _User_extensions_Task_exitted (
+  Thread_Control *executing
+);
+
+/*
+ *  _User_extensions_Fatal
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is used to invoke the user extension for
+ *  the rtems_fatal_error_occurred directive.
+ */
+
+STATIC INLINE void _User_extensions_Fatal (
+  unsigned32 the_error
+);
+
+#include <rtems/userext.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/watchdog.h
===================================================================
--- cpukit/score/include/rtems/score/watchdog.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/watchdog.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,471 @@
+/*  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, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_WATCHDOG_h
+#define __RTEMS_WATCHDOG_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+
+/*
+ *  The following type defines the control block used to manage
+ *  intervals.
+ */
+
+typedef unsigned32 rtems_interval;
+
+/*
+ *  The following types define a pointer to a watchdog/timer service routine.
+ */
+
+typedef void rtems_timer_service_routine;
+
+typedef rtems_timer_service_routine ( *rtems_timer_service_routine_entry )(
+                 Objects_Id,
+                 void *
+             );
+
+/*
+ *  Constant for indefinite wait.  (actually an illegal interval)
+ */
+
+#define RTEMS_NO_TIMEOUT  0
+
+/*
+ *  The following enumerated type details the modes in which the
+ *  Watchdog_Insert routine may operate.  The watchdog may be
+ *  activated automatically at insert time or later, explicitly
+ *  by the caller.
+ */
+
+typedef enum {
+  WATCHDOG_ACTIVATE_NOW, /* activate watchdog as part of insertion */
+  WATCHDOG_NO_ACTIVATE   /* watchdog will be explicitly activated */
+} Watchdog_Insert_modes;
+
+/*
+ *  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_ACTIVE,       /* on chain, allowed to fire */
+  WATCHDOG_REINSERT,     /* on chain, reset without firing if expires */
+  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;
+  rtems_interval initial;
+  rtems_interval delta_interval;
+  rtems_timer_service_routine_entry  routine;
+  Objects_Id        id;
+  void             *user_data;
+}   Watchdog_Control;
+
+/*
+ *  The following type is used for synchronization purposes
+ *  during an insert on a watchdog delta chain.
+ *
+ *  NOTE:  Watchdog_Pointer is only used to insure that
+ *         Watchdog_Synchronization_pointer is a pointer
+ *         which is volatile rather than a pointer to a
+ *         volatile block of memory.
+ */
+
+typedef Watchdog_Control          *Watchdog_Pointer;
+typedef volatile Watchdog_Pointer  Watchdog_Synchronization_pointer;
+
+/*
+ *  The following defines the watchdog chains which are managed
+ *  on ticks and second boundaries.
+ */
+
+EXTERN Chain_Control _Watchdog_Ticks_chain;
+EXTERN Chain_Control _Watchdog_Seconds_chain;
+
+/*
+ *  The following defines the synchronization variable used to
+ *  allow interrupts to be enabled while inserting a watchdog
+ *  on a watchdog chain.
+ */
+
+EXTERN Watchdog_Synchronization_pointer _Watchdog_Sync;
+
+/*
+ *  _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_Initialize
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine initializes the specified watchdog.  The watchdog is
+ *  made inactive, the watchdog id and handler routine are set to the
+ *  specified values.
+ */
+
+STATIC INLINE void _Watchdog_Initialize(
+   Watchdog_Control *the_watchdog,
+   rtems_timer_service_routine_entry  routine,
+   Objects_Id        id,
+   void             *user_data
+);
+
+/*
+ *  _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_Is_active
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine returns TRUE if the watchdog timer is in the ACTIVE
+ *  state, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Watchdog_Is_active(
+  Watchdog_Control *the_watchdog
+);
+
+/*
+ *
+ *  _Watchdog_Activate
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine activates THE_WATCHDOG timer which is already
+ *  on a watchdog chain.
+ */
+
+STATIC INLINE void _Watchdog_Activate(
+  Watchdog_Control *the_watchdog
+);
+
+/*
+ *
+ *  _Watchdog_Deactivate
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine deactivates THE_WATCHDOG timer which will remain
+ *  on a watchdog chain.
+ */
+
+STATIC INLINE void _Watchdog_Deactivate(
+  Watchdog_Control *the_watchdog
+);
+
+/*
+ *
+ *  _Watchdog_Tickle_ticks
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked at each clock tick to update the ticks
+ *  watchdog chain.
+ */
+
+STATIC INLINE void _Watchdog_Tickle_ticks( void );
+
+/*
+ *
+ *  _Watchdog_Tickle_seconds
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked at each clock tick to update the seconds
+ *  watchdog chain.
+ */
+
+STATIC INLINE void _Watchdog_Tickle_seconds( void );
+
+/*
+ *
+ *  _Watchdog_Insert_ticks
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine inserts THE_WATCHDOG into the ticks watchdog chain
+ *  for a time of UNITS ticks.  The INSERT_MODE indicates whether
+ *  THE_WATCHDOG is to be activated automatically or later, explicitly
+ *  by the caller.
+ */
+
+STATIC INLINE void _Watchdog_Insert_ticks(
+  Watchdog_Control      *the_watchdog,
+  rtems_interval      units,
+  Watchdog_Insert_modes  insert_mode
+);
+
+/*
+ *
+ *  _Watchdog_Insert_seconds
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine inserts THE_WATCHDOG into the seconds watchdog chain
+ *  for a time of UNITS seconds.  The INSERT_MODE indicates whether
+ *  THE_WATCHDOG is to be activated automatically or later, explicitly
+ *  by the caller.
+ */
+
+STATIC INLINE void _Watchdog_Insert_seconds(
+  Watchdog_Control      *the_watchdog,
+  rtems_interval      units,
+  Watchdog_Insert_modes  insert_mode
+);
+
+/*
+ *
+ *  _Watchdog_Adjust_seconds
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine adjusts the seconds watchdog chain in the forward
+ *  or backward DIRECTION for UNITS seconds.  This is invoked when the
+ *  current time of day is changed.
+ */
+
+STATIC INLINE void _Watchdog_Adjust_seconds(
+  Watchdog_Adjust_directions direction,
+  rtems_interval          units
+);
+
+/*
+ *
+ *  _Watchdog_Adjust_ticks
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine adjusts the ticks watchdog chain in the forward
+ *  or backward DIRECTION for UNITS ticks.
+ */
+
+STATIC INLINE void _Watchdog_Adjust_ticks(
+  Watchdog_Adjust_directions direction,
+  rtems_interval          units
+);
+
+/*
+ *
+ *  _Watchdog_Reset
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine resets THE_WATCHDOG timer to its state at INSERT
+ *  time.  This routine is valid only on interval watchdog timers
+ *  and is used to make an interval watchdog timer fire "every" so
+ *  many ticks.
+ */
+
+STATIC INLINE void _Watchdog_Reset(
+  Watchdog_Control *the_watchdog
+);
+
+/*
+ *
+ *  _Watchdog_Next
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine returns a pointer to the watchdog timer following
+ *  THE_WATCHDOG on the watchdog chain.
+ */
+
+STATIC INLINE Watchdog_Control *_Watchdog_Next(
+  Watchdog_Control *the_watchdog
+);
+
+/*
+ *
+ *  _Watchdog_Previous
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine returns a pointer to the watchdog timer preceding
+ *  THE_WATCHDOG on the watchdog chain.
+ */
+
+STATIC INLINE Watchdog_Control *_Watchdog_Previous(
+  Watchdog_Control *the_watchdog
+);
+
+/*
+ *
+ *  _Watchdog_First
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine returns a pointer to the first watchdog timer
+ *  on the watchdog chain HEADER.
+ */
+
+STATIC INLINE Watchdog_Control *_Watchdog_First(
+  Chain_Control *header
+);
+
+/*
+ *
+ *  _Watchdog_Last
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine returns a pointer to the last watchdog timer
+ *  on the watchdog chain HEADER.
+ */
+STATIC INLINE Watchdog_Control *_Watchdog_Last(
+  Chain_Control *header
+);
+
+/*
+ *
+ *  _Watchdog_Get_sync
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine returns the current synchronization timer.  This
+ *  routine is used so that interrupts can be enabled while a
+ *  watchdog timer is being inserted into a watchdog chain.
+ */
+
+STATIC INLINE Watchdog_Control *_Watchdog_Get_sync( void );
+
+/*
+ *
+ *  _Watchdog_Set_sync
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine sets the current synchronization timer.  This
+ *  routine is used so that interrupts can be enabled while a
+ *  watchdog timer is being inserted into a watchdog chain.
+ */
+
+STATIC INLINE void _Watchdog_Set_sync(
+  Watchdog_Control *the_watchdog
+);
+
+/*
+ *
+ *  _Watchdog_Clear_sync
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine will set the watchdog synchronization flag to a
+ *  NULL address indicating synchronization is unnecessary.
+ */
+
+STATIC INLINE void _Watchdog_Clear_sync( void );
+
+/*
+ *  _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,
+  rtems_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_Insert_modes  insert_mode
+);
+
+/*
+ *  _Watchdog_Tickle
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked at appropriate intervals to update
+ *  the HEADER watchdog chain.
+ */
+
+void _Watchdog_Tickle (
+  Chain_Control *header
+);
+
+#include <rtems/watchdog.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/score/wkspace.h
===================================================================
--- cpukit/score/include/rtems/score/wkspace.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/score/wkspace.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,99 @@
+/*  wkspace.h
+ *
+ *  This include file contains information related to the RTEMS
+ *  RAM Workspace.  This Handler provides mechanisms which can be used to
+ *  define, initialize and manipulate the RTEMS workspace.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_WORKSPACE_h
+#define __RTEMS_WORKSPACE_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/heap.h>
+#include <rtems/fatal.h>
+#include <rtems/status.h>
+
+/*
+ *  The following is used to manage the RTEMS Workspace.
+ *
+ */
+
+EXTERN Heap_Control _Workspace_Area;  /* executive heap header */
+
+/*
+ *  _Workspace_Handler_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this handler.
+ */
+
+STATIC INLINE void _Workspace_Handler_initialization(
+  void       *starting_address,
+  unsigned32  size
+);
+
+/*
+ *  _Workspace_Allocate
+ *
+ *  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 NULL is returned.
+ */
+
+STATIC INLINE void *_Workspace_Allocate(
+  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 rtems_fatal_error_occurred directive
+ *  is invoked.
+ */
+
+STATIC INLINE void *_Workspace_Allocate_or_fatal_error(
+  unsigned32   size
+);
+
+/*
+ *  _Workspace_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This function frees the specified block of memory.  If the block
+ *  belongs to the Workspace and can be successfully freed, then
+ *  TRUE is returned.  Otherwise FALSE is returned.
+ */
+
+STATIC INLINE boolean _Workspace_Free(
+  void *block
+);
+
+#include <rtems/wkspace.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
Index: cpukit/score/include/rtems/system.h
===================================================================
--- cpukit/score/include/rtems/system.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
+++ cpukit/score/include/rtems/system.h	(revision ac7d5ef06a6d6e8d84abbd1f0b82162725f98326)
@@ -0,0 +1,132 @@
+/*  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, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_SYSTEM_h
+#define __RTEMS_SYSTEM_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *  The following define the CPU Family and Model within the family
+ *
+ *  NOTE: The string "REPLACE_THIS_WITH_USE_INLINE_OR_MACROS" is replaced
+ *        with either "USE_INLINES" or "USE_MACROS" based upon the
+ *        whether this target configuration uses the inline or
+ *        macro implementations of the inlined RTEMS routines.
+ */
+ 
+
+#define REPLACE_THIS_WITH_USE_INLINE_OR_MACROS
+
+/*
+ *  The following insures that all data is declared in the space
+ *  of the Initialization Manager.  It is referenced as "external"
+ *  in every other file.
+ */
+
+#ifdef INIT
+#undef EXTERN
+#define EXTERN
+#else
+#undef EXTERN
+#define 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
+#define STATIC static
+#define INLINE __inline__
+#else
+/*
+#error Only the GNU C compiler is currently supported!!!
+*/
+#define STATIC
+#define INLINE
+#endif
+
+/*
+ *  Include a base set of files.
+ */
+
+/*
+ * XXX: Eventually proc_ptr needs to disappear!!!
+ */
+
+typedef void * proc_ptr;
+
+#include <rtems/cpu.h>             /* processor specific information */
+#include <rtems/status.h>          /* RTEMS status codes */
+
+/*
+ *  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
+
+#define stringify( _x ) # _x
+
+/*
+ *  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 jump table of entry points into RTEMS directives.
+ */
+
+#define NUMBER_OF_ENTRY_POINTS  79
+extern const void * _Entry_points[ NUMBER_OF_ENTRY_POINTS + 1 ];
+
+/*
+ *  The following defines the CPU dependent information table.
+ */
+
+EXTERN rtems_cpu_table _CPU_Table;               /* CPU dependent info */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */
