#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) */
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;
};
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 */
#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
{
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
#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.
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;
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 */
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;
* 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;
}
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++) {
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;
}
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);
}
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
*/
return 0;
}
-static int
+static void
send_query_to_peer(peer_t *p)
{
/* Why do we need to bind()?
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];
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;
}
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;
}
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;
return 1;
}
static peer_t*
-select_and_cluster(double t)
+select_and_cluster(void)
{
llist_t *item;
int i, j;
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)) {
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);
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++;
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;
}
#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;
* 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 */
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" */
} 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;
}
*/
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:
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);
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;
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;
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++) {
}
}
- 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
}
#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;
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);
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;
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);
}
}
}
}
- 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;
}
if (pfd[j].revents /* & (POLLIN|POLLERR)*/) {
nfds--;
recv_and_process_peer_pkt(idx2peer[j]);
+ gettime1900d(); /* sets G.cur_time */
}
}
} /* while (!bb_got_signal) */
projects / platform / upstream / busybox.git / commitdiff