Ticket #1347: pr1347-cvs.diff

cpukit/rtems/include/rtems/rtems/timer.h

@@ -58 +58 @@
 /**
  *  @defgroup ClassicTimer Classic API Timer
  *
- *  This encapsulates functionality which XXX
+ *  This encapsulates functionality related to the Classic API Timer
+ *  Manager.  This manager provides functionality which allows the
+ *  application to schedule the execution of methods at a specified
+ *  time in the future.  These methods may be scheduled based upon
+ *  interval or wall time and may be executed in either the clock tick
+ *  ISR or in a special dedicated timer server task.
  */
 /**@{*/
 
@@ -126 +131 @@
 RTEMS_TIMER_EXTERN Thread_Control *_Timer_Server;
 
 /**
- *  This chain contains the list of interval timers that are
- *  executed in the context of the Timer Server.
- *
- *  @note This is extern'ed because they do not have to be in the
- *        minimum footprint.  It is only really required when
- *        task-based timers are used.  Since task-based timers can
- *        not be started until the server is initiated, this structure
- *        does not have to be initialized until then.  This is declared
- *        in the same file as _Timer_Server_body.
- */
-extern Chain_Control _Timer_Ticks_chain;
-
-/**
- *  This chain contains the list of time of day timers that are
- *  executed in the context of the Timer Server.
- *
- *  @note This is extern'ed because they do not have to be in the
- *        minimum footprint.  It is only really required when
- *        task-based timers are used.  Since task-based timers can
- *        not be started until the server is initiated, this structure
- *        does not have to be initialized until then.  This is declared
- *        in the same file as _Timer_Server_body.
- */
-extern Chain_Control _Timer_Seconds_chain;
-
-/**
  *  The following records define the control block used to manage
  *  each timer.
  */
@@ -174 +153 @@
 );
 
 /**
- *  @brief _Timer_Server_body
- *
- *  This is the server for task based timers.  This task executes whenever
- *  a task-based timer should fire.  It services both "after" and "when"
- *  timers.  It is not created automatically but must be created explicitly
- *  by the application before task-based timers may be initiated.
- */
-Thread _Timer_Server_body(
-  uint32_t   ignored
-);
-
-/**
  *  @brief rtems_timer_create
  *
  *  This routine implements the rtems_timer_create directive.  The
@@ -353 +320 @@
 );
 
 /**
- *  Macros and routines that expose the mechanisms required to service
- *  the Timer Server timer.  These stop the timer, synchronize it with
- *  the current time, and restart it.
- */
-extern Watchdog_Control _Timer_Seconds_timer;
-
-/**
- *  This method is used to temporarily disable updates to the 
- *  Ticks Timer Chain managed by the Timer Server.
+ *  This type defines the method used to schedule the insertion of task
+ *  based timers.
  */
-#define _Timer_Server_stop_ticks_timer() \
-      _Watchdog_Remove( &_Timer_Server->Timer )
-
-/**
- *  This method is used to temporarily disable updates to the 
- *  Seconds Timer Chain managed by the Timer Server.
- */
-#define _Timer_Server_stop_seconds_timer() \
-      _Watchdog_Remove( &_Timer_Seconds_timer );
-
-/**
- *  This is a helper function which processes the ticks chain when
- *  needed.  It advances time for the ticks chain which results in
- *  timers firing.
- */
-void _Timer_Server_process_ticks_chain(void);
-
-/**
- *  This is a helper function which processes the seconds chain when
- *  needed.  It advances time for the seconds chain which results in
- *  timers firing.
- */
-void _Timer_Server_process_seconds_chain(void);
-
-/**
- *  This method resets a timer and places it on the Ticks chain.  It
- *  is assumed that the timer has already been canceled.
- */
-#define _Timer_Server_reset_ticks_timer() \
-   do { \
-      if ( !_Chain_Is_empty( &_Timer_Ticks_chain ) ) { \
-        _Watchdog_Insert_ticks( &_Timer_Server->Timer, \
-           ((Watchdog_Control *)_Timer_Ticks_chain.first)->delta_interval ); \
-      } \
-   } while (0)
+typedef void (*Timer_Server_schedule_operation_t)(
+  Timer_Control     *the_timer
+);
 
 /**
- *  This method resets a timer and places it on the Seconds chain.  It
- *  is assumed that the timer has already been canceled.
+ *  This variable will point to the schedule operation method once the
+ *  timer server is initialized.
  */
-#define _Timer_Server_reset_seconds_timer() \
-   do { \
-      if ( !_Chain_Is_empty( &_Timer_Seconds_chain ) ) { \
-        _Watchdog_Insert_seconds( &_Timer_Seconds_timer, \
-          ((Watchdog_Control *)_Timer_Seconds_chain.first)->delta_interval ); \
-      } \
-   } while (0)
+RTEMS_TIMER_EXTERN Timer_Server_schedule_operation_t
+  _Timer_Server_schedule_operation;
 
 #ifndef __RTEMS_APPLICATION__
 #include <rtems/rtems/timer.inl>

cpukit/rtems/src/rtemstimer.c

@@ -62 +62 @@
    */
 
   _Timer_Server = NULL;
+  _Timer_Server_schedule_operation = NULL;
 }

cpukit/rtems/src/timerreset.c

@@ -56 +56 @@
           _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
           break;
         case TIMER_INTERVAL_ON_TASK:
-          _Timer_Server_stop_ticks_timer();
+          if ( !_Timer_Server_schedule_operation ) {
+            _Thread_Enable_dispatch();
+            return RTEMS_INCORRECT_STATE;
+          }
           _Watchdog_Remove( &the_timer->Ticker );
-          _Timer_Server_process_ticks_chain();
-          _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
-          _Timer_Server_reset_ticks_timer();
+          (*_Timer_Server_schedule_operation)( the_timer );
           break;
         case TIMER_TIME_OF_DAY:
         case TIMER_TIME_OF_DAY_ON_TASK:

cpukit/rtems/src/timerserver.c

@@ -1 @@
-/*
+/**
+ *  @file timerserver.c
+ *
  *  Timer Manager - rtems_timer_initiate_server directive along with
- *      the Timer Server Body and support routines
+ *  the Timer Server Body and support routines
  *
- *  COPYRIGHT (c) 1989-2008.
+ *  @note Data specific to the Timer Server is declared in this
+ *        file as the Timer Server so it does not have to be in the
+ *        minimum footprint.  It is only really required when
+ *        task-based timers are used.  Since task-based timers can
+ *        not be started until the server is initiated, this structure
+ *        does not have to be initialized until then.
+ */
+
+/*  COPYRIGHT (c) 1989-2008.
  *  On-Line Applications Research Corporation (OAR).
  *
  *  The license and distribution terms for this file may be
@@ -29 +39 @@
 #include <rtems/rtems/support.h>
 #include <rtems/score/thread.h>
 
-/*
- *  The following chains contain the list of interval timers that are
+/**
+ *  This chain contains the list of interval timers that are
  *  executed in the context of the Timer Server.
- *
- *  NOTE: These are prototyped in rtems/timer/timer.h but since we
- *        do not actually use them until after the Timer Server is
- *        initiated, we can actually declare them here and avoid forcing
- *        them into the minimum footprint.
  */
-
 Chain_Control _Timer_Ticks_chain;
+
+/**
+ *  This chain contains the list of time of day timers that are
+ *  executed in the context of the Timer Server.
+ */
 Chain_Control _Timer_Seconds_chain;
 
-/*
- *  These variables keep track of the last time the Timer Server actually
- *  processed the chain.
+/**
+ *  This chain holds the set of timers to be inserted when the
+ *  server runs again.
  */
+Chain_Control _Timer_To_be_inserted;
 
-Watchdog_Interval _Timer_Server_seconds_last_time;
+/**
+ *  This variables keeps track of the last time the Timer Server actually
+ *  processed the ticks chain.
+ */
 Watchdog_Interval _Timer_Server_ticks_last_time;
 
-/*
- *  The timer used to control when the Timer Server wakes up to service
- *  "when" timers.
+/**
+ *  This variable keeps track of the last time the Timer Server actually
+ *  processed the seconds chain.
  */
+Watchdog_Interval _Timer_Server_seconds_last_time;
 
+/**
+ *  This is the timer used to control when the Timer Server wakes up to
+ *  service "when" timers.
+ *
+ *  @note The timer in the Timer Server TCB is used for ticks timer.
+ */
 Watchdog_Control _Timer_Seconds_timer;
 
-/*PAGE
+/**
+ *  This method is used to temporarily disable updates to the 
+ *  Ticks Timer Chain managed by the Timer Server.
+ */
+#define _Timer_Server_stop_ticks_timer() \
+      _Watchdog_Remove( &_Timer_Server->Timer )
+
+/**
+ *  This method is used to temporarily disable updates to the 
+ *  Seconds Timer Chain managed by the Timer Server.
+ */
+#define _Timer_Server_stop_seconds_timer() \
+      _Watchdog_Remove( &_Timer_Seconds_timer );
+
+/**
+ *  This method resets a timer and places it on the Ticks chain.  It
+ *  is assumed that the timer has already been canceled.
+ */
+#define _Timer_Server_reset_ticks_timer() \
+   do { \
+      if ( !_Chain_Is_empty( &_Timer_Ticks_chain ) ) { \
+        _Watchdog_Insert_ticks( &_Timer_Server->Timer, \
+           ((Watchdog_Control *)_Timer_Ticks_chain.first)->delta_interval ); \
+      } \
+   } while (0)
+
+/**
+ *  This method resets a timer and places it on the Seconds chain.  It
+ *  is assumed that the timer has already been canceled.
+ */
+#define _Timer_Server_reset_seconds_timer() \
+   do { \
+      if ( !_Chain_Is_empty( &_Timer_Seconds_chain ) ) { \
+        _Watchdog_Insert_seconds( &_Timer_Seconds_timer, \
+          ((Watchdog_Control *)_Timer_Seconds_chain.first)->delta_interval ); \
+      } \
+   } while (0)
+
+/**
+ *  @brief _Timer_Server_process_insertions
  *
- *  _Timer_Server_body
+ *  This method processes the set of timers scheduled for insertion
+ *  onto one of the Timer Server chains.
+ *
+ *  @note It is only to be called from the Timer Server task.
+ */
+static void _Timer_Server_process_insertions(void)
+{
+  Timer_Control *the_timer;
+
+  while ( 1 ) {
+    the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
+    if ( the_timer == NULL )
+      break;
+
+    if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
+      _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
+    } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
+      _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );
+    }
+  }
+}
+
+/**
+ *  @brief _Timer_Server_process_ticks_chain
+ *
+ *  This routine is responsible for adjusting the list of task-based
+ *  interval timers to reflect the passage of time.
+ *
+ *  @param[in] to_fire will contain the set of timers that are to be fired.
+ *
+ *  @note It is only to be called from the Timer Server task.
+ */
+static void _Timer_Server_process_ticks_chain(
+  Chain_Control *to_fire
+)
+{
+  Watchdog_Interval snapshot;
+  Watchdog_Interval ticks;
+
+  snapshot = _Watchdog_Ticks_since_boot;
+  if ( snapshot >= _Timer_Server_ticks_last_time )
+     ticks = snapshot - _Timer_Server_ticks_last_time;
+  else
+     ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
+
+  _Timer_Server_ticks_last_time = snapshot;
+  _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
+}
+
+/**
+ *  @brief _Timer_Server_process_seconds_chain
+ *
+ *  This routine is responsible for adjusting the list of task-based
+ *  time of day timers to reflect the passage of time.
+ *
+ *  @param[in] to_fire will contain the set of timers that are to be fired.
+ *
+ *  @note It is only to be called from the Timer Server task.
+ */
+static void _Timer_Server_process_seconds_chain(
+  Chain_Control *to_fire
+)
+{
+  Watchdog_Interval snapshot;
+  Watchdog_Interval ticks;
+
+  /*
+   *  Process the seconds chain.  Start by checking that the Time
+   *  of Day (TOD) has not been set backwards.  If it has then
+   *  we want to adjust the _Timer_Seconds_chain to indicate this.
+   */
+  snapshot =  _TOD_Seconds_since_epoch;
+  if ( snapshot > _Timer_Server_seconds_last_time ) {
+    /*
+     *  This path is for normal forward movement and cases where the
+     *  TOD has been set forward.
+     */
+    ticks = snapshot - _Timer_Server_seconds_last_time;
+    _Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire );
+
+  } else if ( snapshot < _Timer_Server_seconds_last_time ) {
+     /*
+      *  The current TOD is before the last TOD which indicates that
+      *  TOD has been set backwards.
+      */
+     ticks = _Timer_Server_seconds_last_time - snapshot;
+     _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks );
+  }
+  _Timer_Server_seconds_last_time = snapshot;
+}
+
+/**
+ *  @brief _Timer_Server_body
  *
  *  This is the server for task based timers.  This task executes whenever
  *  a task-based timer should fire.  It services both "after" and "when"
  *  timers.  It is not created automatically but must be created explicitly
  *  by the application before task-based timers may be initiated.
  *
- *  Input parameters:
- *    Ignored - the task argument is ignored
- *
- *  Output parameters:  NONE
+ *  @param[in] ignored is the the task argument that is ignored
  */
-
 Thread _Timer_Server_body(
   uint32_t   ignored
 )
 {
+  Chain_Control to_fire;
+
+  _Chain_Initialize_empty( &to_fire );
+
   /*
    *  Initialize the "last time" markers to indicate the timer that
    *  the server was initiated.
    */
-
   _Timer_Server_ticks_last_time   = _Watchdog_Ticks_since_boot;
   _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
 
+  /*
+   *  Insert the timers that were inserted before we got to run.
+   *  This should be done with dispatching disabled.
+   */
   _Thread_Disable_dispatch();
+    _Timer_Server_process_insertions();
+  _Thread_Enable_dispatch();
+
   while(1) {
 
     /*
      *  Block until there is something to do.
      */
-
+    _Thread_Disable_dispatch();
       _Thread_Set_state( _Timer_Server, STATES_DELAYING );
       _Timer_Server_reset_ticks_timer();
       _Timer_Server_reset_seconds_timer();
     _Thread_Enable_dispatch();
 
+    /********************************************************************
+     ********************************************************************
+     ****                TIMER SERVER BLOCKS HERE                    ****
+     ********************************************************************
+     ********************************************************************/
+
+    /*
+     *  Disable dispatching while processing the timers since we want
+     *  the removal of the timers from the chain to be atomic.
+     *
+     *  NOTE: Dispatching is disabled for interrupt based TSRs.
+     *        Dispatching is enabled for task based TSRs so they
+     *          can temporarily malloc memory or block.
+     *        _ISR_Nest_level is 0 for task-based TSRs and non-zero
+     *          for the others.
+     */
+    _Thread_Disable_dispatch();
+
     /*
      *  At this point, at least one of the timers this task relies
      *  upon has fired.  Stop them both while we process any outstanding
      *  timers.  Before we block, we will restart them.
      */
+    _Timer_Server_stop_ticks_timer();
+    _Timer_Server_stop_seconds_timer();
 
-      _Timer_Server_stop_ticks_timer();
-      _Timer_Server_stop_seconds_timer();
+    /*
+     *  Remove all the timers that need to fire so we can invoke them
+     *  outside the critical section.
+     */
+    _Timer_Server_process_ticks_chain( &to_fire );
+    _Timer_Server_process_seconds_chain( &to_fire );
 
     /*
-     *  Disable dispatching while processing the timers since we want
-     *  to mimic the environment that non-task-based TSRs execute in.
-     *  This ensures that the primary difference is that _ISR_Nest_level
-     *  is 0 for task-based timers and non-zero for the others.
+     *  Insert the timers that have been requested to be inserted.
      */
+    _Timer_Server_process_insertions();
 
-    _Thread_Disable_dispatch();
-      _Timer_Server_process_ticks_chain();
-      _Timer_Server_process_seconds_chain();
+    /*
+     * Enable dispatching to process the set that are ready "to fire."
+     */
+    _Thread_Enable_dispatch();
+
+    /*
+     *  Now we actually invoke the TSR for all the timers that fired.
+     *  This is done with dispatching
+     */
+    while (1) {
+      Watchdog_Control *watch;
+      ISR_Level         level;
+
+      _ISR_Disable( level );
+      watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire );
+      if ( watch == NULL ) {
+        _ISR_Enable( level );
+        break;
+      }
+
+      watch->state = WATCHDOG_INACTIVE;
+      _ISR_Enable( level );
+
+      (*watch->routine)( watch->id, watch->user_data );
+    }
   }
 
   return 0;   /* unreached - only to remove warnings */
 }
 
-/*PAGE
+/**
+ *  This method schedules the insertion of timers on the proper list.  It
+ *  wakes up the Timer Server task to process the insertion.
+ *
+ *  @param[in] the_timer is the timer to insert
  *
- *  rtems_timer_initiate_server
+ *  @note It is highly likely the executing task will be preempted after
+ *        the directive invoking this is executed.
+ */
+static void _Timer_Server_schedule_operation_method(
+  Timer_Control     *the_timer
+)
+{
+  _Chain_Append( &_Timer_To_be_inserted, &the_timer->Object.Node );
+  _Watchdog_Remove( &_Timer_Server->Timer );
+  _Thread_Delay_ended( _Timer_Server->Object.id, NULL );
+}
+
+/**
+ *  @brief rtems_timer_initiate_server
  *
  *  This directive creates and starts the server for task-based timers.
  *  It must be invoked before any task-based timers can be initiated.
  *
- *  Input parameters:
- *    priority         - timer server priority
- *    stack_size       - stack size in bytes
- *    attribute_set    - timer server attributes
- *
- *  Output parameters:
- *    RTEMS_SUCCESSFUL - if successful
- *    error code       - if unsuccessful
+ *  @param[in] priority is the timer server priority
+ *  @param[in] stack_size is the stack size in bytes
+ *  @param[in] attribute_set is the timer server attributes
+ *
+ *  @return This method returns RTEMS_SUCCESSFUL if successful and an 
+ *          error code otherwise.
  */
-
-
 rtems_status_code rtems_timer_initiate_server(
   uint32_t             priority,
   uint32_t             stack_size,
@@ -151 +365 @@
   bool                tmpInitialized;
 
   /*
-   *  Make sure the requested priority is valid.  The if is 
+   *  Make sure the requested priority is valid.  The if is
    *  structured so we check it is invalid before looking for
    *  a specific invalid value as the default.
    */
-
   _priority = priority;
   if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
     if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
@@ -166 +379 @@
   /*
    *  Just to make sure this is only called once.
    */
-
   _Thread_Disable_dispatch();
     tmpInitialized  = initialized;
     initialized = true;
@@ -176 +388 @@
     return RTEMS_INCORRECT_STATE;
 
   /*
+   *  Initialize the set of timers to be inserted by the server.
+   */
+  _Chain_Initialize_empty( &_Timer_To_be_inserted );
+
+  /*
    *  Create the Timer Server with the name the name of "TIME".  The attribute
    *  RTEMS_SYSTEM_TASK allows us to set a priority to 0 which will makes it
    *  higher than any other task in the system.  It can be viewed as a low
@@ -189 +406 @@
    *  Otherwise, the priority ceiling for the mutex used to protect the
    *  GNAT run-time is violated.
    */
-
   status = rtems_task_create(
     _Objects_Build_name('T','I','M','E'),           /* "TIME" */
     _priority,            /* create with priority 1 since 0 is illegal */
@@ -217 +433 @@
    *  NOTE: Setting the pointer to the Timer Server TCB to a value other than
    *        NULL indicates that task-based timer support is initialized.
    */
-
   _Timer_Server = (Thread_Control *)_Objects_Get_local_object(
     &_RTEMS_tasks_Information,
     _Objects_Get_index(id)
@@ -226 +441 @@
   /*
    *  Initialize the timer lists that the server will manage.
    */
-
   _Chain_Initialize_empty( &_Timer_Ticks_chain );
   _Chain_Initialize_empty( &_Timer_Seconds_chain );
 
@@ -234 +448 @@
    *  Initialize the timers that will be used to control when the
    *  Timer Server wakes up and services the task-based timers.
    */
-
   _Watchdog_Initialize( &_Timer_Server->Timer, _Thread_Delay_ended, id, NULL );
   _Watchdog_Initialize( &_Timer_Seconds_timer, _Thread_Delay_ended, id, NULL );
+
   /*
-   *  Start the timer server
+   *  Initialize the pointer to the timer reset method so applications
+   *  that do not use the Timer Server do not have to pull it in.
    */
+  _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;
 
+  /*
+   *  Start the timer server
+   */
   status = rtems_task_start(
     id,                                    /* the id from create */
     (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */
@@ -259 +478 @@
 
   return status;
 }
-
-/*PAGE
- *
- *  _Timer_Server_process_ticks_chain
- *
- *  This routine is responsible for adjusting the list of task-based
- *  interval timers to reflect the passage of time.
- *
- *  Input parameters:   NONE
- *
- *  Output parameters:  NONE
- */
-
-void _Timer_Server_process_ticks_chain(void)
-{
-  Watchdog_Interval snapshot;
-  Watchdog_Interval ticks;
-
-  snapshot = _Watchdog_Ticks_since_boot;
-  if ( snapshot >= _Timer_Server_ticks_last_time )
-     ticks = snapshot - _Timer_Server_ticks_last_time;
-  else
-     ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
-
-  _Timer_Server_ticks_last_time = snapshot;
-  _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks );
-}
-
-/*PAGE
- *
- *  _Timer_Server_process_seconds_chain
- *
- *  This routine is responsible for adjusting the list of task-based
- *  time of day timers to reflect the passage of time.
- *
- *  Input parameters:   NONE
- *
- *  Output parameters:  NONE
- */
-
-void _Timer_Server_process_seconds_chain(void)
-{
-  Watchdog_Interval snapshot;
-  Watchdog_Interval ticks;
-
-  /*
-   *  Process the seconds chain.  Start by checking that the Time
-   *  of Day (TOD) has not been set backwards.  If it has then
-   *  we want to adjust the _Timer_Seconds_chain to indicate this.
-   */
-
-  snapshot =  _TOD_Seconds_since_epoch;
-  if ( snapshot > _Timer_Server_seconds_last_time ) {
-    /*
-     *  This path is for normal forward movement and cases where the
-     *  TOD has been set forward.
-     */
-
-    ticks = snapshot - _Timer_Server_seconds_last_time;
-    _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_FORWARD, ticks );
-
-  } else if ( snapshot < _Timer_Server_seconds_last_time ) {
-     /*
-      *  The current TOD is before the last TOD which indicates that
-      *  TOD has been set backwards.
-      */
-
-     ticks = _Timer_Server_seconds_last_time - snapshot;
-     _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks );
-  }
-  _Timer_Server_seconds_last_time = snapshot;
-}

cpukit/rtems/src/timerserverfireafter.c

@@ -92 +92 @@
         the_timer->Ticker.initial = ticks;
       _ISR_Enable( level );
 
-      _Timer_Server_stop_ticks_timer();
-      _Timer_Server_process_ticks_chain();
-      _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
-       _Timer_Server_reset_ticks_timer();
+      /*
+       * _Timer_Server_schedule_operation != NULL because we checked that
+       * _Timer_Server was != NULL above.  Both are set at the same time.
+       */
+
+      (*_Timer_Server_schedule_operation)( the_timer );
 
       _Thread_Enable_dispatch();
       return RTEMS_SUCCESSFUL;

cpukit/rtems/src/timerserverfirewhen.c

@@ -79 +79 @@
       _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
       the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch;
 
-      _Timer_Server_stop_seconds_timer();
-      _Timer_Server_process_seconds_chain();
-      _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );
-       _Timer_Server_reset_seconds_timer();
+      /*
+       * _Timer_Server_schedule_operation != NULL because we checked that
+       * _Timer_Server was != NULL above.  Both are set at the same time.
+       */
+
+      (*_Timer_Server_schedule_operation)( the_timer );
 
       _Thread_Enable_dispatch();
       return RTEMS_SUCCESSFUL;

cpukit/score/Makefile.am

@@ -173 +173 @@
 
 ## WATCHDOG_C_FILES
 libscore_a_SOURCES += src/watchdog.c src/watchdogadjust.c \
-    src/watchdoginsert.c src/watchdogremove.c src/watchdogtickle.c \
-    src/watchdogreport.c src/watchdogreportchain.c
+    src/watchdogadjusttochain.c src/watchdoginsert.c src/watchdogremove.c \
+    src/watchdogtickle.c src/watchdogreport.c src/watchdogreportchain.c
 
 ## USEREXT_C_FILES
 libscore_a_SOURCES += src/userextaddapiset.c src/userextaddset.c \

cpukit/score/include/rtems/score/watchdog.h

@@ -220 +220 @@
   Watchdog_Interval           units
 );
 
+/** @brief Watchdog Adjust to Chain
+ *
+ *  This routine adjusts the @a header watchdog chain in the forward
+ *  @a direction for @a units_arg ticks.
+ *
+ *  @param[in] header is the watchdog chain to adjust
+ *  @param[in] units is the number of units to adjust @a header
+ *  @param[in] to_fire is a pointer to an initialized Chain_Control to which
+ *             all watchdog instances that are to be fired will be placed.
+ *
+ *  @note This always adjusts forward.
+ */
+void _Watchdog_Adjust_to_chain(
+  Chain_Control               *header,
+  Watchdog_Interval            units_arg,
+  Chain_Control               *to_fire
+
+);
+
 /** @brief Watchdog Insert
  *
  *  This routine inserts @a the_watchdog into the @a header watchdog chain

new file cpukit/score/src/watchdogadjusttochain.c

@@ +1 @@
+/**
+ *  @file watchdogadjusttochain.c
+ *
+ *  This is used by the Timer Server task.
+ */
+
+/*  COPYRIGHT (c) 1989-2008.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id: watchdogreport.c,v 1.1 2008/11/26 16:33:30 joel Exp $
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <rtems/system.h>
+#include <rtems/score/isr.h>
+#include <rtems/score/watchdog.h>
+
+void _Watchdog_Adjust_to_chain(
+  Chain_Control               *header,
+  Watchdog_Interval            units_arg,
+  Chain_Control               *to_fire
+
+)
+{
+  Watchdog_Interval  units = units_arg;
+  ISR_Level          level;
+  Chain_Node        *node;
+
+  if ( !units ) {
+    return;
+  }
+  _ISR_Disable( level );
+
+  if ( !_Chain_Is_empty( header ) ) {
+    while ( units ) {
+      if ( units < _Watchdog_First( header )->delta_interval ) {
+        _Watchdog_First( header )->delta_interval -= units;
+        break;
+      } else {
+        units -= _Watchdog_First( header )->delta_interval;
+        _Watchdog_First( header )->delta_interval = 0;
+
+        do {
+          node = _Chain_Get_unprotected( header );
+          _Chain_Append_unprotected( to_fire, node );
+
+          _ISR_Flash( level );
+
+        } while ( !_Chain_Is_empty( header ) &&
+                  _Watchdog_First( header )->delta_interval == 0 );
+
+        if ( _Chain_Is_empty( header ) )
+          break;
+      }
+    }
+
+  }
+  _ISR_Enable( level );
+}
+

testsuites/sptests/Makefile.am

@@ -8 +8 @@
 SUBDIRS = sp01 sp02 sp03 sp04 sp05 sp06 sp07 sp08 sp09 sp11 sp12 sp13 sp14 \
     sp15 sp16 sp17 sp19 sp20 sp21 sp22 sp23 sp24 sp25 sp26 sp27 sp28 sp29 \
     sp30 sp31 sp32 sp33 sp34 sp35 sp37 sp38 sp39 sp40 sp41 sp42 sp43 sp44 \
-    spsize spfatal01 spfatal02 spfatal03 spfatal04 spfatal05 spfatal06 \
+    sp45 spsize spfatal01 spfatal02 spfatal03 spfatal04 spfatal05 spfatal06 \
     spfatal07 spfatal08 spfatal09 spfatal10 
 
 DIST_SUBDIRS = $(SUBDIRS) spfatal spfatal_support

testsuites/sptests/configure.ac

@@ -69 +69 @@
 sp42/Makefile
 sp43/Makefile
 sp44/Makefile
+sp45/Makefile
 spsize/Makefile
 spfatal/Makefile
 spfatal01/Makefile

testsuites/sptests/sp30/resume.c

@@ -29 +29 @@
 
   task_to_resume = Task_id[ rtems_object_id_get_index( timer_id ) ];
   status = rtems_task_resume( task_to_resume );
-  directive_failed_with_level( status, "rtems_task_resume", 1 );
+  directive_failed( status, "rtems_task_resume" );
 }

testsuites/sptests/sp30/task1.c

@@ -36 +36 @@
       Timer_id[ argument ],
       (task_number( tid ) - 1) * 5 * TICKS_PER_SECOND,
       Resume_task,
-      NULL
+      (void *) tid
     );
     directive_failed( status, "rtems_timer_server_fire_after failed" );
 

testsuites/sptests/sp31/delay.c

@@ -27 +27 @@
   rtems_status_code status;
 
   status = rtems_task_resume( Task_id[ 1 ] );
-  directive_failed_with_level( status, "rtems_task_resume of self", 1 );
+  directive_failed( status, "rtems_task_resume of self" );
 }

new file testsuites/sptests/sp45/.cvsignore

@@ +1 @@
+Makefile
+Makefile.in

new file testsuites/sptests/sp45/Makefile.am

@@ +1 @@
+##
+## $Id: Makefile.am,v 1.18 2006/07/11 05:00:28 ralf Exp $
+##
+
+MANAGERS = all
+
+rtems_tests_PROGRAMS = sp45.exe
+sp45_exe_SOURCES = init.c
+
+dist_rtems_tests_DATA = sp45.scn
+dist_rtems_tests_DATA += sp45.doc
+
+include $(RTEMS_ROOT)/make/custom/@RTEMS_BSP@.cfg
+include $(top_srcdir)/../automake/compile.am
+include $(top_srcdir)/../automake/leaf.am
+
+sp45_exe_LDADD = $(MANAGERS_NOT_WANTED:%=$(PROJECT_LIB)/no-%.rel)
+
+AM_CPPFLAGS += -I$(top_srcdir)/../support/include
+
+LINK_OBJS = $(sp45_exe_OBJECTS) $(sp45_exe_LDADD)
+LINK_LIBS = $(sp45_exe_LDLIBS)
+
+sp45.exe$(EXEEXT): $(sp45_exe_OBJECTS) $(sp45_exe_DEPENDENCIES)
+        @rm -f sp45.exe$(EXEEXT)
+        $(make-exe)
+
+include $(top_srcdir)/../automake/local.am

new file testsuites/sptests/sp45/init.c

@@ +1 @@
+/*
+ *  COPYRIGHT (c) 1989-2008.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id: init.c,v 1.6 2008/02/01 00:45:11 joel Exp $
+ */
+
+#include <tmacros.h>
+
+rtems_id   Timer_id[ 3 ];    /* array of timer ids */
+rtems_name Timer_name[ 3 ];  /* array of timer names */
+
+volatile int TSR_fired;
+volatile void *TSR_malloc_ptr;
+
+rtems_timer_service_routine Malloc_From_TSR(
+  rtems_id  ignored_id,
+  void     *ignored_address
+)
+{
+  rtems_status_code  status;
+
+  TSR_fired = 2;
+  puts( "TSR: calling malloc" );
+  TSR_malloc_ptr = malloc( 64 );
+
+  puts( "TSR: calling free" );
+  free( (void *) TSR_malloc_ptr );
+
+  puts( "TSR: delaying with rtems_task_wake_after" );
+  status = rtems_task_wake_after( TICKS_PER_SECOND / 2 );
+  directive_failed( status, "rtems_task_wake_after" );
+}
+
+rtems_task Init(
+  rtems_task_argument argument
+)
+{
+  rtems_status_code  status;
+
+  puts( "\n\n*** TEST 45 ***" );
+
+  status = rtems_timer_initiate_server(
+    RTEMS_TIMER_SERVER_DEFAULT_PRIORITY,
+    RTEMS_MINIMUM_STACK_SIZE,
+    RTEMS_DEFAULT_ATTRIBUTES
+  );
+  directive_failed( status, "rtems_timer_initiate_server" );
+
+  /*
+   * Initialize Timers
+   */
+
+  Timer_name[ 1 ] = rtems_build_name( 'T', 'M', '1', ' ' );
+  Timer_name[ 2 ] = rtems_build_name( 'T', 'M', '2', ' ' );
+
+  puts( "INIT - rtems_timer_create - creating timer 1" );
+  status = rtems_timer_create( Timer_name[ 1 ], &Timer_id[ 1 ] );
+  directive_failed( status, "rtems_timer_create" );
+  printf( "INIT - timer 1 has id (0x%x)\n", Timer_id[ 1 ] );
+
+  puts( "INIT - rtems_timer_create - creating timer 2" );
+  status = rtems_timer_create( Timer_name[ 2 ], &Timer_id[ 2 ] );
+  directive_failed( status, "rtems_timer_create" );
+  printf( "INIT - timer 2 has id (0x%x)\n", Timer_id[ 2 ] );
+
+  /*
+   *  Schedule malloc TSR for 1 second from now
+   */
+
+  TSR_fired = 0;
+  TSR_malloc_ptr = (void *) 0xa5a5a5;
+  puts( "TA1 - rtems_timer_server_fire_after - timer 1 in 1 seconds" );
+  status = rtems_timer_server_fire_after(
+    Timer_id[ 1 ],
+    1 * TICKS_PER_SECOND,
+    Malloc_From_TSR,
+    NULL
+  );
+  directive_failed( status, "rtems_timer_server_fire_after" );
+
+  puts( "TA1 - rtems_task_wake_after - 2 second" );
+  status = rtems_task_wake_after( 2 * TICKS_PER_SECOND );
+  directive_failed( status, "rtems_task_wake_after" );
+
+  if ( TSR_fired == 2 &&
+       (TSR_malloc_ptr && TSR_malloc_ptr != (void *)0xa5a5a5) )
+    puts( "TSR appears to have executed OK" );
+  else {
+    printf( "FAILURE ptr=%p TSR_fired=%d\n", TSR_malloc_ptr, TSR_fired );
+    rtems_test_exit( 0 );
+  }
+
+  /*
+   *  Delete timer and exit test
+   */
+  puts( "TA1 - timer_deleting - timer 1" );
+  status = rtems_timer_delete( Timer_id[ 1 ] );
+  directive_failed( status, "rtems_timer_delete" );
+
+
+  puts( "*** END OF TEST 45 *** " );
+  rtems_test_exit( 0 );
+}
+
+#define CONFIGURE_INIT
+/* configuration information */
+
+#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
+#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
+
+/* Two Tasks: Init and Timer Server */
+#define CONFIGURE_MAXIMUM_TASKS           2
+#define CONFIGURE_MAXIMUM_TIMERS          2
+#define CONFIGURE_INIT_TASK_STACK_SIZE    (RTEMS_MINIMUM_STACK_SIZE * 2)
+
+#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
+
+#define CONFIGURE_EXTRA_TASK_STACKS       (1 * RTEMS_MINIMUM_STACK_SIZE)
+
+#include <rtems/confdefs.h>
+

new file testsuites/sptests/sp45/sp45.doc

@@ +1 @@
+#
+#  $Id: sp31.doc,v 1.1.1.1 2002/01/02 16:18:27 joel Exp $
+#
+#  COPYRIGHT (c) 1989-2002.
+#  On-Line Applications Research Corporation (OAR).
+#
+#  The license and distribution terms for this file may be
+#  found in the file LICENSE in this distribution or at
+#  http://www.rtems.com/license/LICENSE.
+#
+
+
+This file describes the directives and concepts tested by this test set.
+
+test set name:  test44
+
+directives:
+
+concepts:
+
+allocating memory from a Timer Service Routine fired from a server
+delaying in a Timer Service Routine fired from a server