ntpd: better selection of initial sync; fewer gettimeofday calls

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

1 files changed, 126 insertions, 126 deletions

diff --git a/networking/ntpd.c b/networking/ntpd.c
index 92e2723a5..520dcd16b 100644
--- a/networking/ntpd.c
+++ b/networking/ntpd.c
@@ -47,9 +47,10 @@
 
 
 #define RETRY_INTERVAL  5       /* on error, retry in N secs */
-#define QUERYTIME_MAX   15      /* wait for reply up to N secs */
+#define RESPONSE_INTERVAL 15    /* wait for reply up to N secs */
 
 #define FREQ_TOLERANCE  0.000015 /* % frequency tolerance (15 PPM) */
+#define BURSTPOLL       0
 #define MINPOLL         4       /* % minimum poll interval (6: 64 s) */
 #define MAXPOLL         12      /* % maximum poll interval (12: 1.1h, 17: 36.4h) (was 17) */
 #define MINDISP         0.01    /* % minimum dispersion (s) */
@@ -162,13 +163,13 @@ typedef struct {
         char             *p_dotted;
         /* when to send new query (if p_fd == -1)
          * or when receive times out (if p_fd >= 0): */
-        time_t           next_action_time;
         int              p_fd;
         int              datapoint_idx;
         uint32_t         lastpkt_refid;
         uint8_t          lastpkt_status;
         uint8_t          lastpkt_stratum;
-        uint8_t          p_reachable_bits;
+        uint8_t          reachable_bits;
+        double           next_action_time;
         double           p_xmttime;
         double           lastpkt_recv_time;
         double           lastpkt_delay;
@@ -196,6 +197,7 @@ enum {
 };
 
 struct globals {
+        double   cur_time;
         /* total round trip delay to currently selected reference clock */
         double   rootdelay;
         /* reference timestamp: time when the system clock was last set or corrected */
@@ -245,7 +247,8 @@ struct globals {
 #define G_precision_sec  (1.0 / (1 << (- G_precision_exp)))
         uint8_t  stratum;
         /* Bool. After set to 1, never goes back to 0: */
-        uint8_t  adjtimex_was_done;
+        smallint adjtimex_was_done;
+        smallint initial_poll_complete;
 
         uint8_t  discipline_state;      // doc calls it c.state
         uint8_t  poll_exp;              // s.poll
@@ -303,7 +306,8 @@ gettime1900d(void)
 {
         struct timeval tv;
         gettimeofday(&tv, NULL); /* never fails */
-        return (tv.tv_sec + 1.0e-6 * tv.tv_usec + OFFSET_1900_1970);
+        G.cur_time = tv.tv_sec + (1.0e-6 * tv.tv_usec) + OFFSET_1900_1970;
+        return G.cur_time;
 }
 
 static void
@@ -355,13 +359,13 @@ d_to_sfp(double d)
 #endif
 
 static double
-dispersion(const datapoint_t *dp, double t)
+dispersion(const datapoint_t *dp)
 {
-        return dp->d_dispersion + FREQ_TOLERANCE * (t - dp->d_recv_time);
+        return dp->d_dispersion + FREQ_TOLERANCE * (G.cur_time - dp->d_recv_time);
 }
 
 static double
-root_distance(peer_t *p, double t)
+root_distance(peer_t *p)
 {
         /* The root synchronization distance is the maximum error due to
          * all causes of the local clock relative to the primary server.
@@ -371,21 +375,21 @@ root_distance(peer_t *p, double t)
         return MAXD(MINDISP, p->lastpkt_rootdelay + p->lastpkt_delay) / 2
                 + p->lastpkt_rootdisp
                 + p->filter_dispersion
-                + FREQ_TOLERANCE * (t - p->lastpkt_recv_time)
+                + FREQ_TOLERANCE * (G.cur_time - p->lastpkt_recv_time)
                 + p->filter_jitter;
 }
 
 static void
 set_next(peer_t *p, unsigned t)
 {
-        p->next_action_time = time(NULL) + t;
+        p->next_action_time = G.cur_time + t;
 }
 
 /*
  * Peer clock filter and its helpers
  */
 static void
-filter_datapoints(peer_t *p, double t)
+filter_datapoints(peer_t *p)
 {
         int i, idx;
         int got_newest;
@@ -427,14 +431,14 @@ filter_datapoints(peer_t *p, double t)
                         bb_error_msg("datapoint[%d]: off:%f disp:%f(%f) age:%f%s",
                                 i,
                                 p->filter_datapoint[idx].d_offset,
-                                p->filter_datapoint[idx].d_dispersion, dispersion(&p->filter_datapoint[idx], t),
-                                t - p->filter_datapoint[idx].d_recv_time,
+                                p->filter_datapoint[idx].d_dispersion, dispersion(&p->filter_datapoint[idx]),
+                                G.cur_time - p->filter_datapoint[idx].d_recv_time,
                                 (minoff == p->filter_datapoint[idx].d_offset || maxoff == p->filter_datapoint[idx].d_offset)
                                         ? " (outlier by offset)" : ""
                         );
                 }
 
-                sum += dispersion(&p->filter_datapoint[idx], t) / (2 << i);
+                sum += dispersion(&p->filter_datapoint[idx]) / (2 << i);
 
                 if (minoff == p->filter_datapoint[idx].d_offset) {
                         minoff -= 1; /* so that we don't match it ever again */
@@ -443,7 +447,7 @@ filter_datapoints(peer_t *p, double t)
                         maxoff += 1;
                 } else {
                         oldest_off = p->filter_datapoint[idx].d_offset;
-                        oldest_age = t - p->filter_datapoint[idx].d_recv_time;
+                        oldest_age = G.cur_time - p->filter_datapoint[idx].d_recv_time;
                         if (!got_newest) {
                                 got_newest = 1;
                                 newest_off = oldest_off;
@@ -466,10 +470,13 @@ filter_datapoints(peer_t *p, double t)
          * and then we have this estimation, ~25% off from 0.7:
          * 0.1/32 + 0.2/32 + 0.3/16 + 0.4/8 + 0.5/4 + 0.6/2 = 0.503125
          */
-        x = newest_age / (oldest_age - newest_age); /* in above example, 100 / (600 - 100) */
-        if (x < 1) {
-                x = (newest_off - oldest_off) * x; /* 0.5 * 100/500 = 0.1 */
-                wavg += x;
+        x = oldest_age - newest_age;
+        if (x != 0) {
+                x = newest_age / x; /* in above example, 100 / (600 - 100) */
+                if (x < 1) { /* paranoia check */
+                        x = (newest_off - oldest_off) * x; /* 0.5 * 100/500 = 0.1 */
+                        wavg += x;
+                }
         }
         p->filter_offset = wavg;
 
@@ -499,7 +506,7 @@ filter_datapoints(peer_t *p, double t)
 }
 
 static void
-reset_peer_stats(peer_t *p, double t, double offset)
+reset_peer_stats(peer_t *p, double offset)
 {
         int i;
         for (i = 0; i < NUM_DATAPOINTS; i++) {
@@ -509,7 +516,7 @@ reset_peer_stats(peer_t *p, double t, double offset)
                                 p->filter_datapoint[i].d_offset -= offset;
                         }
                 } else {
-                        p->filter_datapoint[i].d_recv_time  = t;
+                        p->filter_datapoint[i].d_recv_time  = G.cur_time;
                         p->filter_datapoint[i].d_offset     = 0;
                         p->filter_datapoint[i].d_dispersion = MAXDISP;
                 }
@@ -517,11 +524,11 @@ reset_peer_stats(peer_t *p, double t, double offset)
         if (offset < 16 * STEP_THRESHOLD) {
                 p->lastpkt_recv_time -= offset;
         } else {
-                p->p_reachable_bits = 0;
-                p->lastpkt_recv_time = t;
+                p->reachable_bits = 0;
+                p->lastpkt_recv_time = G.cur_time;
         }
-        filter_datapoints(p, t); /* recalc p->filter_xxx */
-        p->next_action_time -= (time_t)offset;
+        filter_datapoints(p); /* recalc p->filter_xxx */
+        p->next_action_time -= offset;
         VERB5 bb_error_msg("%s->lastpkt_recv_time=%f", p->p_dotted, p->lastpkt_recv_time);
 }
 
@@ -535,8 +542,8 @@ add_peers(char *s)
         p->p_dotted = xmalloc_sockaddr2dotted_noport(&p->p_lsa->u.sa);
         p->p_fd = -1;
         p->p_xmt_msg.m_status = MODE_CLIENT | (NTP_VERSION << 3);
-        p->next_action_time = time(NULL); /* = set_next(p, 0); */
-        reset_peer_stats(p, gettime1900d(), 16 * STEP_THRESHOLD);
+        p->next_action_time = G.cur_time; /* = set_next(p, 0); */
+        reset_peer_stats(p, 16 * STEP_THRESHOLD);
         /* Speed up initial sync: with small offsets from peers,
          * 3 samples will sync
          */
@@ -567,7 +574,7 @@ do_sendto(int fd,
         return 0;
 }
 
-static int
+static void
 send_query_to_peer(peer_t *p)
 {
         /* Why do we need to bind()?
@@ -632,20 +639,19 @@ send_query_to_peer(peer_t *p)
                 close(p->p_fd);
                 p->p_fd = -1;
                 set_next(p, RETRY_INTERVAL);
-                return -1;
+                return;
         }
 
-        p->p_reachable_bits <<= 1;
+        p->reachable_bits <<= 1;
         VERB1 bb_error_msg("sent query to %s", p->p_dotted);
-        set_next(p, QUERYTIME_MAX);
-
-        return 0;
+        set_next(p, RESPONSE_INTERVAL);
 }
 
 
-static void
+static NOINLINE void
 step_time(double offset)
 {
+        llist_t *item;
         double dtime;
         struct timeval tv;
         char buf[80];
@@ -663,6 +669,17 @@ step_time(double offset)
         strftime(buf, sizeof(buf), "%a %b %e %H:%M:%S %Z %Y", localtime(&tval));
 
         bb_error_msg("setting clock to %s (offset %fs)", buf, offset);
+
+        /* Correct various fields which contain time-relative values: */
+
+        /* p->lastpkt_recv_time, p->next_action_time and such: */
+        for (item = G.ntp_peers; item != NULL; item = item->link) {
+                peer_t *pp = (peer_t *) item->data;
+                reset_peer_stats(pp, offset);
+        }
+        /* Globals: */
+        G.cur_time -= offset;
+        G.last_update_recv_time -= offset;
 }
 
 
@@ -700,7 +717,8 @@ compare_survivor_metric(const void *aa, const void *bb)
 static int
 fit(peer_t *p, double rd)
 {
-        if (p->p_reachable_bits == 0) {
+        if ((p->reachable_bits & (p->reachable_bits-1)) == 0) {
+                /* One or zero bits in reachable_bits */
                 VERB3 bb_error_msg("peer %s unfit for selection: unreachable", p->p_dotted);
                 return 0;
         }
@@ -712,7 +730,7 @@ fit(peer_t *p, double rd)
                 return 0;
         }
 #endif
-        /* rd is root_distance(p, t) */
+        /* rd is root_distance(p) */
         if (rd > MAXDIST + FREQ_TOLERANCE * (1 << G.poll_exp)) {
                 VERB3 bb_error_msg("peer %s unfit for selection: root distance too high", p->p_dotted);
                 return 0;
@@ -724,7 +742,7 @@ fit(peer_t *p, double rd)
         return 1;
 }
 static peer_t*
-select_and_cluster(double t)
+select_and_cluster(void)
 {
         llist_t    *item;
         int        i, j;
@@ -742,9 +760,9 @@ select_and_cluster(double t)
 
         num_points = 0;
         item = G.ntp_peers;
-        while (item != NULL) {
+        if (G.initial_poll_complete) while (item != NULL) {
                 peer_t *p = (peer_t *) item->data;
-                double rd = root_distance(p, t);
+                double rd = root_distance(p);
                 double offset = p->filter_offset;
 
                 if (!fit(p, rd)) {
@@ -775,7 +793,7 @@ select_and_cluster(double t)
         num_candidates = num_points / 3;
         if (num_candidates == 0) {
                 VERB3 bb_error_msg("no valid datapoints, no peer selected");
-                return NULL; /* never happers? */
+                return NULL;
         }
 //TODO: sorting does not seem to be done in reference code
         qsort(point, num_points, sizeof(point[0]), compare_point_edge);
@@ -856,7 +874,7 @@ select_and_cluster(double t)
                 p = point[i].p;
                 survivor[num_survivors].p = p;
 //TODO: save root_distance in point_t and reuse here?
-                survivor[num_survivors].metric = MAXDIST * p->lastpkt_stratum + root_distance(p, t);
+                survivor[num_survivors].metric = MAXDIST * p->lastpkt_stratum + root_distance(p);
                 VERB4 bb_error_msg("survivor[%d] metric:%f peer:%s",
                         num_survivors, survivor[num_survivors].metric, p->p_dotted);
                 num_survivors++;
@@ -952,7 +970,7 @@ select_and_cluster(double t)
         VERB3 bb_error_msg("selected peer %s filter_offset:%f age:%f",
                         survivor[0].p->p_dotted,
                         survivor[0].p->filter_offset,
-                        t - survivor[0].p->lastpkt_recv_time
+                        G.cur_time - survivor[0].p->lastpkt_recv_time
         );
         return survivor[0].p;
 }
@@ -981,8 +999,8 @@ set_new_values(int disc_state, double offset, double recv_time)
 #define STATE_FREQ      3       /* initial frequency */
 #define STATE_SYNC      4       /* clock synchronized (normal operation) */
 /* Return: -1: decrease poll interval, 0: leave as is, 1: increase */
-static int
-update_local_clock(peer_t *p, double t)
+static NOINLINE int
+update_local_clock(peer_t *p)
 {
         int rc;
         long old_tmx_offset;
@@ -1037,8 +1055,6 @@ update_local_clock(peer_t *p, double t)
          * offset exceeds the step threshold and when it does not.
          */
         if (abs_offset > STEP_THRESHOLD) {
-                llist_t *item;
-
                 switch (G.discipline_state) {
                 case STATE_SYNC:
                         /* The first outlyer: ignore it, switch to SPIK state */
@@ -1089,10 +1105,6 @@ update_local_clock(peer_t *p, double t)
                 G.polladj_count = 0;
                 G.poll_exp = MINPOLL;
                 G.stratum = MAXSTRAT;
-                for (item = G.ntp_peers; item != NULL; item = item->link) {
-                        peer_t *pp = (peer_t *) item->data;
-                        reset_peer_stats(pp, t, offset);
-                }
                 if (G.discipline_state == STATE_NSET) {
                         set_new_values(STATE_FREQ, /*offset:*/ 0, recv_time);
                         return 1; /* "ok to increase poll interval" */
@@ -1101,8 +1113,9 @@ update_local_clock(peer_t *p, double t)
 
         } else { /* abs_offset <= STEP_THRESHOLD */
 
-                if (G.poll_exp < MINPOLL) {
-                        VERB3 bb_error_msg("saw small offset %f, disabling burst mode", offset);
+                if (G.poll_exp < MINPOLL && G.initial_poll_complete) {
+                        VERB3 bb_error_msg("small offset:%f, disabling burst mode", offset);
+                        G.polladj_count = 0;
                         G.poll_exp = MINPOLL;
                 }
 
@@ -1128,7 +1141,7 @@ update_local_clock(peer_t *p, double t)
                          */
                         set_new_values(STATE_FREQ, offset, recv_time);
                         VERB3 bb_error_msg("transitioning to FREQ, datapoint ignored");
-                        return -1; /* "decrease poll interval" */
+                        return 0; /* "leave poll interval as is" */
 
 #if 0 /* this is dead code for now */
                 case STATE_FSET:
@@ -1180,12 +1193,12 @@ update_local_clock(peer_t *p, double t)
                 G.stratum = p->lastpkt_stratum + 1;
         }
 
-        G.reftime = t;
+        G.reftime = G.cur_time;
         G.ntp_status = p->lastpkt_status;
         G.refid = p->lastpkt_refid;
         G.rootdelay = p->lastpkt_rootdelay + p->lastpkt_delay;
         dtemp = p->filter_jitter; // SQRT(SQUARE(p->filter_jitter) + SQUARE(s.jitter));
-        dtemp += MAXD(p->filter_dispersion + FREQ_TOLERANCE * (t - p->lastpkt_recv_time) + abs_offset, MINDISP);
+        dtemp += MAXD(p->filter_dispersion + FREQ_TOLERANCE * (G.cur_time - p->lastpkt_recv_time) + abs_offset, MINDISP);
         G.rootdisp = p->lastpkt_rootdisp + dtemp;
         VERB3 bb_error_msg("updating leap/refid/reftime/rootdisp from peer %s", p->p_dotted);
 
@@ -1318,19 +1331,20 @@ retry_interval(void)
         return interval;
 }
 static unsigned
-poll_interval(int exponent) /* exp is always -1 or 0 */
+poll_interval(int exponent)
 {
         /* Want to send next packet at (1 << G.poll_exp) + small random value */
         unsigned interval, r;
-        exponent += G.poll_exp; /* G.poll_exp is always > 0 */
-        /* never true: if (exp < 0) exp = 0; */
+        exponent = G.poll_exp + exponent;
+        if (exponent < 0)
+                exponent = 0;
         interval = 1 << exponent;
         r = random();
         interval += ((r & (interval-1)) >> 4) + ((r >> 8) & 1); /* + 1/16 of interval, max */
         VERB3 bb_error_msg("chose poll interval:%u (poll_exp:%d exp:%d)", interval, G.poll_exp, exponent);
         return interval;
 }
-static void
+static NOINLINE void
 recv_and_process_peer_pkt(peer_t *p)
 {
         int         rc;
@@ -1410,12 +1424,12 @@ recv_and_process_peer_pkt(peer_t *p)
         T1 = p->p_xmttime;
         T2 = lfp_to_d(msg.m_rectime);
         T3 = lfp_to_d(msg.m_xmttime);
-        T4 = gettime1900d();
+        T4 = G.cur_time;
 
         p->lastpkt_recv_time = T4;
 
         VERB5 bb_error_msg("%s->lastpkt_recv_time=%f", p->p_dotted, p->lastpkt_recv_time);
-        p->datapoint_idx = p->p_reachable_bits ? (p->datapoint_idx + 1) % NUM_DATAPOINTS : 0;
+        p->datapoint_idx = p->reachable_bits ? (p->datapoint_idx + 1) % NUM_DATAPOINTS : 0;
         datapoint = &p->filter_datapoint[p->datapoint_idx];
         datapoint->d_recv_time = T4;
         datapoint->d_offset    = ((T2 - T1) + (T3 - T4)) / 2;
@@ -1429,7 +1443,7 @@ recv_and_process_peer_pkt(peer_t *p)
         if (p->lastpkt_delay < G_precision_sec)
                 p->lastpkt_delay = G_precision_sec;
         datapoint->d_dispersion = LOG2D(msg.m_precision_exp) + G_precision_sec;
-        if (!p->p_reachable_bits) {
+        if (!p->reachable_bits) {
                 /* 1st datapoint ever - replicate offset in every element */
                 int i;
                 for (i = 1; i < NUM_DATAPOINTS; i++) {
@@ -1437,20 +1451,20 @@ recv_and_process_peer_pkt(peer_t *p)
                 }
         }
 
-        p->p_reachable_bits |= 1;
+        p->reachable_bits |= 1;
         VERB1 {
                 bb_error_msg("reply from %s: reach 0x%02x offset %f delay %f",
                         p->p_dotted,
-                        p->p_reachable_bits,
+                        p->reachable_bits,
                         datapoint->d_offset, p->lastpkt_delay);
         }
 
         /* Muck with statictics and update the clock */
-        filter_datapoints(p, T4);
-        q = select_and_cluster(T4);
+        filter_datapoints(p);
+        q = select_and_cluster();
         rc = -1;
         if (q)
-                rc = update_local_clock(q, T4);
+                rc = update_local_clock(q);
 
         if (rc != 0) {
                 /* Adjust the poll interval by comparing the current offset
@@ -1524,12 +1538,11 @@ recv_and_process_peer_pkt(peer_t *p)
 }
 
 #if ENABLE_FEATURE_NTPD_SERVER
-static void
+static NOINLINE void
 recv_and_process_client_pkt(void /*int fd*/)
 {
         ssize_t          size;
         uint8_t          version;
-        double           rectime;
         len_and_sockaddr *to;
         struct sockaddr  *from;
         msg_t            msg;
@@ -1565,8 +1578,9 @@ recv_and_process_client_pkt(void /*int fd*/)
         msg.m_stratum = G.stratum;
         msg.m_ppoll = G.poll_exp;
         msg.m_precision_exp = G_precision_exp;
-        rectime = gettime1900d();
-        msg.m_xmttime = msg.m_rectime = d_to_lfp(rectime);
+        /* this time was obtained between poll() and recv() */
+        msg.m_rectime = d_to_lfp(G.cur_time);
+        msg.m_xmttime = d_to_lfp(gettime1900d()); /* this instant */
         msg.m_reftime = d_to_lfp(G.reftime);
         msg.m_orgtime = query_xmttime;
         msg.m_rootdelay = d_to_sfp(G.rootdelay);
@@ -1686,33 +1700,10 @@ static NOINLINE void ntp_init(char **argv)
                 bb_error_msg_and_die(bb_msg_you_must_be_root);
 
         /* Set some globals */
-#if 0
-        /* With constant b = 100, G.precision_exp is also constant -6.
-         * Uncomment this to verify.
-         */
-        {
-                int prec = 0;
-                int b;
-# if 0
-                struct timespec tp;
-                /* We can use sys_clock_getres but assuming 10ms tick should be fine */
-                clock_getres(CLOCK_REALTIME, &tp);
-                tp.tv_sec = 0;
-                tp.tv_nsec = 10000000;
-                b = 1000000000 / tp.tv_nsec;  /* convert to Hz */
-# else
-                b = 100; /* b = 1000000000/10000000 = 100 */
-# endif
-                while (b > 1)
-                        prec--, b >>= 1;
-                /*G.precision_exp = prec;*/
-                /*G.precision_sec = (1.0 / (1 << (- prec)));*/
-                bb_error_msg("G.precision_exp:%d sec:%f", prec, G_precision_sec); /* -6 */
-        }
-#endif
         G.stratum = MAXSTRAT;
-        G.poll_exp = 1; /* should use MINPOLL, but 1 speeds up initial sync */
-        G.reftime = G.last_update_recv_time = gettime1900d();
+        if (BURSTPOLL != 0)
+                G.poll_exp = BURSTPOLL; /* speeds up initial sync */
+        G.reftime = G.last_update_recv_time = gettime1900d(); /* sets G.cur_time too */
 
         /* Parse options */
         peers = NULL;
@@ -1752,61 +1743,66 @@ static NOINLINE void ntp_init(char **argv)
 int ntpd_main(int argc UNUSED_PARAM, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int ntpd_main(int argc UNUSED_PARAM, char **argv)
 {
-        struct globals g;
+#undef G
+        struct globals G;
         struct pollfd *pfd;
         peer_t **idx2peer;
+        unsigned cnt;
 
-        memset(&g, 0, sizeof(g));
-        SET_PTR_TO_GLOBALS(&g);
+        memset(&G, 0, sizeof(G));
+        SET_PTR_TO_GLOBALS(&G);
 
         ntp_init(argv);
 
-        {
-                /* if ENABLE_FEATURE_NTPD_SERVER, + 1 for listen_fd: */
-                unsigned cnt = g.peer_cnt + ENABLE_FEATURE_NTPD_SERVER;
-                idx2peer = xzalloc(sizeof(idx2peer[0]) * cnt);
-                pfd = xzalloc(sizeof(pfd[0]) * cnt);
-        }
+        /* If ENABLE_FEATURE_NTPD_SERVER, + 1 for listen_fd: */
+        cnt = G.peer_cnt + ENABLE_FEATURE_NTPD_SERVER;
+        idx2peer = xzalloc(sizeof(idx2peer[0]) * cnt);
+        pfd = xzalloc(sizeof(pfd[0]) * cnt);
+
+        /* Countdown: we never sync before we sent 5 packets to each peer
+         * NB: if some peer is not responding, we may end up sending
+         * fewer packets to it and more to other peers.
+         * NB2: sync usually happens using 5-1=4 packets, since last reply
+         * does not come back instantaneously.
+         */
+        cnt = G.peer_cnt * 5;
 
         while (!bb_got_signal) {
                 llist_t *item;
                 unsigned i, j;
-                unsigned sent_cnt, trial_cnt;
                 int nfds, timeout;
-                time_t cur_time, nextaction;
+                double nextaction;
 
                 /* Nothing between here and poll() blocks for any significant time */
 
-                cur_time = time(NULL);
-                nextaction = cur_time + 3600;
+                nextaction = G.cur_time + 3600;
 
                 i = 0;
 #if ENABLE_FEATURE_NTPD_SERVER
-                if (g.listen_fd != -1) {
-                        pfd[0].fd = g.listen_fd;
+                if (G.listen_fd != -1) {
+                        pfd[0].fd = G.listen_fd;
                         pfd[0].events = POLLIN;
                         i++;
                 }
 #endif
                 /* Pass over peer list, send requests, time out on receives */
-                sent_cnt = trial_cnt = 0;
-                for (item = g.ntp_peers; item != NULL; item = item->link) {
+                for (item = G.ntp_peers; item != NULL; item = item->link) {
                         peer_t *p = (peer_t *) item->data;
 
-                        /* Overflow-safe "if (p->next_action_time <= cur_time) ..." */
-                        if ((int)(cur_time - p->next_action_time) >= 0) {
+                        if (p->next_action_time <= G.cur_time) {
                                 if (p->p_fd == -1) {
                                         /* Time to send new req */
-                                        trial_cnt++;
-                                        if (send_query_to_peer(p) == 0)
-                                                sent_cnt++;
+                                        if (--cnt == 0) {
+                                                G.initial_poll_complete = 1;
+                                        }
+                                        send_query_to_peer(p);
                                 } else {
                                         /* Timed out waiting for reply */
                                         close(p->p_fd);
                                         p->p_fd = -1;
-                                        timeout = poll_interval(-1); /* try a bit faster */
+                                        timeout = poll_interval(-2); /* -2: try a bit sooner */
                                         bb_error_msg("timed out waiting for %s, reach 0x%02x, next query in %us",
-                                                        p->p_dotted, p->p_reachable_bits, timeout);
+                                                        p->p_dotted, p->reachable_bits, timeout);
                                         set_next(p, timeout);
                                 }
                         }
@@ -1823,23 +1819,26 @@ int ntpd_main(int argc UNUSED_PARAM, char **argv)
                         }
                 }
 
-                timeout = nextaction - cur_time;
-                if (timeout < 1)
-                        timeout = 1;
+                timeout = nextaction - G.cur_time;
+                if (timeout < 0)
+                        timeout = 0;
+                timeout++; /* (nextaction - G.cur_time) rounds down, compensating */
 
                 /* Here we may block */
                 VERB2 bb_error_msg("poll %us, sockets:%u", timeout, i);
                 nfds = poll(pfd, i, timeout * 1000);
+                gettime1900d(); /* sets G.cur_time */
                 if (nfds <= 0)
                         continue;
 
                 /* Process any received packets */
                 j = 0;
 #if ENABLE_FEATURE_NTPD_SERVER
-                if (g.listen_fd != -1) {
+                if (G.listen_fd != -1) {
                         if (pfd[0].revents /* & (POLLIN|POLLERR)*/) {
                                 nfds--;
-                                recv_and_process_client_pkt(/*g.listen_fd*/);
+                                recv_and_process_client_pkt(/*G.listen_fd*/);
+                                gettime1900d(); /* sets G.cur_time */
                         }
                         j = 1;
                 }
@@ -1848,6 +1847,7 @@ int ntpd_main(int argc UNUSED_PARAM, char **argv)
                         if (pfd[j].revents /* & (POLLIN|POLLERR)*/) {
                                 nfds--;
                                 recv_and_process_peer_pkt(idx2peer[j]);
+                                gettime1900d(); /* sets G.cur_time */
                         }
                 }
         } /* while (!bb_got_signal) */