mirror of
https://github.com/sheumann/hush.git
synced 2024-12-21 23:29:34 +00:00
ntpd: better selection of initial sync; fewer gettimeofday calls
Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
This commit is contained in:
Denys Vlasenko
parent
185e691ec1
commit
0b002812a8
@ -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) */
|
||||
|
||||
Loading…
Reference in New Issue
Block a user