sched: always return non-zero timeout ID

Timeout ID of zero can be now safely used to indicate that the timer is
not running. Remove the extra timer_running variables that were
necessary to track that.

ntp_core.c

@@ -71,8 +71,6 @@ struct NCR_Instance_Record {
                                    (client/server or symmetric active peer) */
   OperatingMode opmode;         /* Whether we are sampling this source
                                    or not and in what way */
-  int timer_running;            /* Boolean indicating whether we have a timeout
-                                   pending to transmit to the source */
   SCH_TimeoutID timeout_id;     /* Scheduler's timeout ID, if we are
                                    running on a timer. */
   int tx_suspended;             /* Boolean indicating we can't transmit yet */
@@ -353,12 +351,11 @@ restart_timeout(NCR_Instance inst, double delay)
 {
   /* Check if we can transmit */
   if (inst->tx_suspended) {
-    assert(!inst->timer_running);
+    assert(!inst->timeout_id);
     return;
   }
 
   /* Stop old timer if running */
-  if (inst->timer_running)
   SCH_RemoveTimeout(inst->timeout_id);
 
   /* Start new timer for transmission */
@@ -366,7 +363,6 @@ restart_timeout(NCR_Instance inst, double delay)
                                            SAMPLING_RANDOMNESS,
                                            SCH_NtpSamplingClass,
                                            transmit_timeout, (void *)inst);
-  inst->timer_running = 1;
 }
 
 /* ================================================== */
@@ -374,7 +370,7 @@ restart_timeout(NCR_Instance inst, double delay)
 static void
 start_initial_timeout(NCR_Instance inst)
 {
-  if (!inst->timer_running) {
+  if (!inst->timeout_id) {
     /* This will be the first transmission after mode change */
 
     /* Mark source active */
@@ -401,10 +397,9 @@ static void
 take_offline(NCR_Instance inst)
 {
   inst->opmode = MD_OFFLINE;
-  if (inst->timer_running) {
+
   SCH_RemoveTimeout(inst->timeout_id);
-    inst->timer_running = 0;
+  inst->timeout_id = 0;
-  }
 
   /* Mark source unreachable */
   SRC_ResetReachability(inst->source);
@@ -491,7 +486,6 @@ NCR_GetInstance(NTP_Remote_Address *remote_addr, NTP_Source_Type type, SourcePar
                                          &result->remote_addr.ip_addr,
                                          params->min_samples, params->max_samples);
 
-  result->timer_running = 0;
   result->timeout_id = 0;
   result->tx_suspended = 1;
   result->opmode = params->online ? MD_ONLINE : MD_OFFLINE;
@@ -562,7 +556,7 @@ NCR_ResetInstance(NCR_Instance instance)
     instance->local_poll = instance->minpoll;
 
     /* The timer was set with a longer poll interval, restart it */
-    if (instance->timer_running)
+    if (instance->timeout_id)
       restart_timeout(instance, get_transmit_delay(instance, 0, 0.0));
   }
 }
@@ -911,7 +905,7 @@ transmit_timeout(void *arg)
   NCR_Instance inst = (NCR_Instance) arg;
   int sent;
 
-  inst->timer_running = 0;
+  inst->timeout_id = 0;
 
   switch (inst->opmode) {
     case MD_BURST_WAS_ONLINE:
@@ -1421,7 +1415,7 @@ receive_packet(NTP_Packet *message, struct timeval *now, double now_err, NCR_Ins
     }
 
     /* Get rid of old timeout and start a new one */
-    assert(inst->timer_running);
+    assert(inst->timeout_id);
     restart_timeout(inst, delay_time);
   }
 

reference.c

@@ -106,7 +106,6 @@ static REF_LeapMode leap_mode;
 static int leap_in_progress;
 
 /* Timer for the leap second handler */
-static int leap_timer_running;
 static SCH_TimeoutID leap_timeout_id;
 
 /* Name of a system timezone containing leap seconds occuring at midnight */
@@ -234,7 +233,7 @@ REF_Initialise(void)
 
   enable_local_stratum = CNF_AllowLocalReference(&local_stratum);
 
-  leap_timer_running = 0;
+  leap_timeout_id = 0;
   leap_in_progress = 0;
   leap_mode = CNF_GetLeapSecMode();
   /* Switch to step mode if the system driver doesn't support leap */
@@ -264,7 +263,7 @@ REF_Initialise(void)
     fb_drifts = MallocArray(struct fb_drift, fb_drift_max - fb_drift_min + 1);
     memset(fb_drifts, 0, sizeof (struct fb_drift) * (fb_drift_max - fb_drift_min + 1));
     next_fb_drift = 0;
-    fb_drift_timeout_id = -1;
+    fb_drift_timeout_id = 0;
   }
 
   last_ref_update.tv_sec = 0;
@@ -428,10 +427,8 @@ update_fb_drifts(double freq_ppm, double update_interval)
     next_fb_drift = 0;
   }
 
-  if (fb_drift_timeout_id != -1) {
   SCH_RemoveTimeout(fb_drift_timeout_id);
-    fb_drift_timeout_id = -1;
+  fb_drift_timeout_id = 0;
-  }
 
   if (update_interval < 1.0 || update_interval > last_ref_update_interval * 4.0)
     return;
@@ -464,7 +461,7 @@ fb_drift_timeout(void *arg)
 {
   assert(next_fb_drift >= fb_drift_min && next_fb_drift <= fb_drift_max);
 
-  fb_drift_timeout_id = -1;
+  fb_drift_timeout_id = 0;
 
   DEBUG_LOG(LOGF_Reference, "Fallback drift %d active: %f ppm",
             next_fb_drift, fb_drifts[next_fb_drift - fb_drift_min].freq);
@@ -481,7 +478,7 @@ schedule_fb_drift(struct timeval *now)
   double unsynchronised;
   struct timeval when;
 
-  if (fb_drift_timeout_id != -1)
+  if (fb_drift_timeout_id)
     return; /* already scheduled */
 
   UTI_DiffTimevalsToDouble(&unsynchronised, now, &last_ref_update);
@@ -686,7 +683,7 @@ get_tz_leap(time_t when)
 static void
 leap_end_timeout(void *arg)
 {
-  leap_timer_running = 0;
+  leap_timeout_id = 0;
   leap_in_progress = 0;
   our_leap_sec = 0;
 
@@ -738,11 +735,9 @@ set_leap_timeout(time_t now)
   struct timeval when;
 
   /* Stop old timer if there is one */
-  if (leap_timer_running) {
   SCH_RemoveTimeout(leap_timeout_id);
-    leap_timer_running = 0;
+  leap_timeout_id = 0;
   leap_in_progress = 0;
-  }
 
   if (!our_leap_sec)
     return;
@@ -760,7 +755,6 @@ set_leap_timeout(time_t now)
   }
 
   leap_timeout_id = SCH_AddTimeout(&when, leap_start_timeout, NULL);
-  leap_timer_running = 1;
 }
 
 /* ================================================== */

rtc_linux.c

@@ -72,8 +72,7 @@ static int fd = -1;
 
 static int measurement_period = LOWEST_MEASUREMENT_PERIOD;
 
-static int timeout_running = 0;
+static SCH_TimeoutID timeout_id = 0;
-static SCH_TimeoutID timeout_id;
 
 static int skip_interrupts;
 
@@ -581,10 +580,8 @@ RTC_Linux_Initialise(void)
 void
 RTC_Linux_Finalise(void)
 {
-  if (timeout_running) {
   SCH_RemoveTimeout(timeout_id);
-    timeout_running = 0;
+  timeout_id = 0;
-  }
 
   /* Remove input file handler */
   if (fd >= 0) {
@@ -630,7 +627,7 @@ switch_interrupts(int onoff)
 static void
 measurement_timeout(void *any)
 {
-  timeout_running = 0;
+  timeout_id = 0;
   switch_interrupts(1);
 }
 
@@ -894,7 +891,6 @@ turn_off_interrupt:
 
         switch_interrupts(0);
     
-        timeout_running = 1;
         timeout_id = SCH_AddTimeoutByDelay((double) measurement_period, measurement_timeout, NULL);
       }
 
@@ -907,7 +903,6 @@ turn_off_interrupt:
 
         switch_interrupts(0);
     
-        timeout_running = 1;
         timeout_id = SCH_AddTimeoutByDelay((double) measurement_period, measurement_timeout, NULL);
       }
       
@@ -916,7 +911,6 @@ turn_off_interrupt:
     case OM_NORMAL:
       switch_interrupts(0);
     
-      timeout_running = 1;
       timeout_id = SCH_AddTimeoutByDelay((double) measurement_period, measurement_timeout, NULL);
 
       break;
@@ -936,9 +930,8 @@ RTC_Linux_TimeInit(void (*after_hook)(void *), void *anything)
   after_init_hook_arg = anything;
 
   operating_mode = OM_INITIAL;
-  timeout_running = 0;
+  timeout_id = 0;
   switch_interrupts(1);
-
 }
 
 /* ================================================== */
@@ -946,7 +939,6 @@ RTC_Linux_TimeInit(void (*after_hook)(void *), void *anything)
 void
 RTC_Linux_StartMeasurements(void)
 {
-  timeout_running = 0;
   measurement_timeout(NULL);
 }
 
@@ -1126,10 +1118,8 @@ RTC_Linux_Trim(void)
     coef_ref_time = now.tv_sec;
 
     /* And start rapid sampling, interrupts on now */
-    if (timeout_running) {
     SCH_RemoveTimeout(timeout_id);
-      timeout_running = 0;
+    timeout_id = 0;
-    }
     switch_interrupts(1);
   }
 

sched.c

@@ -278,6 +278,18 @@ release_tqe(TimerQueueEntry *node)
 
 /* ================================================== */
 
+static SCH_TimeoutID
+get_new_tqe_id(void)
+{
+  next_tqe_id++;
+  if (!next_tqe_id)
+    next_tqe_id++;
+
+  return next_tqe_id;
+}
+
+/* ================================================== */
+
 SCH_TimeoutID
 SCH_AddTimeout(struct timeval *tv, SCH_TimeoutHandler handler, SCH_ArbitraryArgument arg)
 {
@@ -288,7 +300,7 @@ SCH_AddTimeout(struct timeval *tv, SCH_TimeoutHandler handler, SCH_ArbitraryArgu
 
   new_tqe = allocate_tqe();
 
-  new_tqe->id = next_tqe_id++;
+  new_tqe->id = get_new_tqe_id();
   new_tqe->handler = handler;
   new_tqe->arg = arg;
   new_tqe->tv = *tv;
@@ -397,7 +409,7 @@ SCH_AddTimeoutInClass(double min_delay, double separation, double randomness,
   /* We have located the insertion point */
   new_tqe = allocate_tqe();
 
-  new_tqe->id = next_tqe_id++;
+  new_tqe->id = get_new_tqe_id();
   new_tqe->handler = handler;
   new_tqe->arg = arg;
   UTI_AddDoubleToTimeval(&now, new_min_delay, &new_tqe->tv);
@@ -421,6 +433,9 @@ SCH_RemoveTimeout(SCH_TimeoutID id)
 
   assert(initialised);
 
+  if (!id)
+    return;
+
   for (ptr = timer_queue.next; ptr != &timer_queue; ptr = ptr->next) {
 
     if (ptr->id == id) {

sched.h

@@ -29,6 +29,7 @@
 
 #include "sysincl.h"
 
+/* Type for timeout IDs, valid IDs are always greater than zero */
 typedef unsigned long SCH_TimeoutID;
 
 typedef enum {

sys_generic.c

@@ -76,9 +76,8 @@ static struct timeval slew_start;
 #define MIN_SLEW_TIMEOUT 1.0
 #define MAX_SLEW_TIMEOUT 1.0e4
 
-/* Scheduler timeout ID and flag if the timer is currently running */
+/* Scheduler timeout ID for ending of the currently running slew */
 static SCH_TimeoutID slew_timeout_id;
-static int slew_timer_running;
 
 /* Suggested offset correction rate (correction time * offset) */
 static double correction_rate;
@@ -173,7 +172,6 @@ update_slew(void)
   double old_slew_freq, total_freq, corr_freq, duration;
 
   /* Remove currently running timeout */
-  if (slew_timer_running)
   SCH_RemoveTimeout(slew_timeout_id);
 
   LCL_ReadRawTime(&now);
@@ -245,9 +243,7 @@ update_slew(void)
   /* Restart timer for the next update */
   UTI_AddDoubleToTimeval(&now, duration, &end_of_slew);
   slew_timeout_id = SCH_AddTimeout(&end_of_slew, handle_end_of_slew, NULL);
-
   slew_start = now;
-  slew_timer_running = 1;
 
   DEBUG_LOG(LOGF_SysGeneric, "slew offset=%e corr_rate=%e base_freq=%f total_freq=%f slew_freq=%e duration=%f slew_error=%e",
       offset_register, correction_rate, base_freq, total_freq, slew_freq,
@@ -259,7 +255,7 @@ update_slew(void)
 static void
 handle_end_of_slew(void *anything)
 {
-  slew_timer_running = 0;
+  slew_timeout_id = 0;
   update_slew();
 }
 
@@ -410,10 +406,9 @@ SYS_Generic_Finalise(void)
 
   /* Must *NOT* leave a slew running - clock could drift way off
      if the daemon is not restarted */
-  if (slew_timer_running) {
+
   SCH_RemoveTimeout(slew_timeout_id);
-    slew_timer_running = 0;
+  slew_timeout_id = 0;
-  }
 
   (*drv_set_freq)(clamp_freq(base_freq));
 

sys_macosx.c

@@ -294,7 +294,6 @@ get_offset_correction(struct timeval *raw,
 
 /* Cancel systematic drift */
 
-static int drift_removal_running = 0;
 static SCH_TimeoutID drift_removal_id;
 
 /* ================================================== */
@@ -414,7 +413,6 @@ SYS_MacOSX_Initialise(void)
 
 
   drift_removal_id = SCH_AddTimeoutByDelay(drift_removal_interval, drift_removal_timeout, NULL);
-  drift_removal_running = 1;
 }
 
 /* ================================================== */
@@ -422,9 +420,7 @@ SYS_MacOSX_Initialise(void)
 void
 SYS_MacOSX_Finalise(void)
 {
-  if (drift_removal_running) {
   SCH_RemoveTimeout(drift_removal_id);
-  }
 
   clock_finalise();
 }