1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2014 Kay Sievers
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
23 * "Simple Network Time Protocol Version 4 (SNTPv4) is a subset of the
24 * Network Time Protocol (NTP) used to synchronize computer clocks in
25 * the Internet. SNTPv4 can be used when the ultimate performance of
26 * a full NTP implementation based on RFC 1305 is neither needed nor
29 * "Unlike most NTP clients, SNTP clients normally operate with only a
30 * single server at a time."
32 * http://tools.ietf.org/html/rfc4330
42 #include <arpa/inet.h>
43 #include <netinet/in.h>
44 #include <netinet/ip.h>
45 #include <sys/timerfd.h>
46 #include <sys/timex.h>
47 #include <sys/socket.h>
51 #include "sparse-endian.h"
54 #include "timedate-sntp.h"
56 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
59 #define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
62 /* Maximum delta in seconds which the system clock is gradually adjusted
63 * to approach the network time. Deltas larger that this are set by letting
64 * the system time jump. The maximum for adjtime is 500ms.
66 #define NTP_MAX_ADJUST 0.2
69 * "Define the required accuracy of the system clock, then calculate the
70 * maximum timeout. Use the longest maximum timeout possible given the system
71 * constraints to minimize time server aggregate load."
73 * "A client MUST NOT under any conditions use a poll interval less
76 #define NTP_POLL_INTERVAL_MIN_SEC 16
77 #define NTP_POLL_INTERVAL_MAX_SEC 2048
78 #define NTP_ACCURACY_SEC 0.1
80 #define NTP_LEAP_PLUSSEC 1
81 #define NTP_LEAP_MINUSSEC 2
82 #define NTP_LEAP_NOTINSYNC 3
83 #define NTP_MODE_CLIENT 3
84 #define NTP_MODE_SERVER 4
85 #define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
86 #define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
87 #define NTP_FIELD_MODE(f) ((f) & 7)
88 #define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
91 * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
92 * in seconds relative to 0h on 1 January 1900."
94 #define OFFSET_1900_1970 2208988800UL
101 struct ntp_ts_short {
111 struct ntp_ts_short root_delay;
112 struct ntp_ts_short root_dispersion;
114 struct ntp_ts reference_time;
115 struct ntp_ts origin_time;
116 struct ntp_ts recv_time;
117 struct ntp_ts trans_time;
121 void (*report)(usec_t poll, double offset, double delay, double jitter, bool spike);
124 sd_event_source *event_receive;
126 struct sockaddr_in server_addr;
128 uint64_t packet_count;
130 /* last sent packet */
131 struct timespec trans_time_mon;
132 struct timespec trans_time;
133 usec_t retry_interval;
137 sd_event_source *event_timer;
138 usec_t poll_interval_usec;
146 unsigned int samples_idx;
147 double samples_jitter;
152 /* watch for time changes */
153 sd_event_source *event_clock_watch;
157 static int sntp_arm_timer(SNTPContext *sntp, usec_t next);
158 static int sntp_clock_watch_setup(SNTPContext *sntp);
160 static double ntp_ts_to_d(const struct ntp_ts *ts) {
161 return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
164 static double tv_to_d(const struct timeval *tv) {
165 return tv->tv_sec + (1.0e-6 * tv->tv_usec);
168 static double ts_to_d(const struct timespec *ts) {
169 return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
172 static void d_to_tv(double d, struct timeval *tv) {
173 tv->tv_sec = (long)d;
174 tv->tv_usec = (d - tv->tv_sec) * 1000 * 1000;
176 /* the kernel expects -0.3s as {-1, 7000.000} */
177 if (tv->tv_usec < 0) {
179 tv->tv_usec += 1000 * 1000;
183 static double square(double d) {
187 static int sntp_send_request(SNTPContext *sntp) {
188 struct ntp_msg ntpmsg = {};
189 struct sockaddr_in addr = {};
194 * "The client initializes the NTP message header, sends the request
195 * to the server, and strips the time of day from the Transmit
196 * Timestamp field of the reply. For this purpose, all the NTP
197 * header fields are set to 0, except the Mode, VN, and optional
198 * Transmit Timestamp fields."
200 ntpmsg.field = NTP_FIELD(0, 4, NTP_MODE_CLIENT);
203 * Set transmit timestamp, remember it; the server will send that back
204 * as the origin timestamp and we have an indication that this is the
205 * matching answer to our request.
207 * The actual value does not matter, We do not care about the correct
208 * NTP UINT_MAX fraction, we just pass the plain nanosecond value.
210 clock_gettime(CLOCK_MONOTONIC, &sntp->trans_time_mon);
211 clock_gettime(CLOCK_REALTIME, &sntp->trans_time);
212 ntpmsg.trans_time.sec = htobe32(sntp->trans_time.tv_sec + OFFSET_1900_1970);
213 ntpmsg.trans_time.frac = htobe32(sntp->trans_time.tv_nsec);
215 addr.sin_family = AF_INET;
216 addr.sin_port = htobe16(123);
217 addr.sin_addr.s_addr = inet_addr(sntp->server);
218 len = sendto(sntp->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &addr, sizeof(addr));
219 if (len == sizeof(ntpmsg)) {
220 sntp->pending = true;
221 log_debug("Sent NTP request to: %s", sntp->server);
223 log_debug("Sending NTP request to %s failed: %m", sntp->server);
225 /* re-arm timer with incresing timeout, in case the packets never arrive back */
226 if (sntp->retry_interval > 0) {
227 if (sntp->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
228 sntp->retry_interval *= 2;
230 sntp->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
231 r = sntp_arm_timer(sntp, sntp->retry_interval);
238 static int sntp_timer(sd_event_source *source, usec_t usec, void *userdata) {
239 SNTPContext *sntp = userdata;
243 sntp_send_request(sntp);
247 static int sntp_arm_timer(SNTPContext *sntp, usec_t next) {
252 assert(sntp->event_receive);
255 sntp->event_timer = sd_event_source_unref(sntp->event_timer);
259 if (sntp->event_timer) {
260 r = sd_event_source_set_time(sntp->event_timer, now(CLOCK_MONOTONIC) + next);
264 return sd_event_source_set_enabled(sntp->event_timer, SD_EVENT_ONESHOT);
267 e = sd_event_source_get_event(sntp->event_receive);
268 r = sd_event_add_monotonic(e, &sntp->event_timer, now(CLOCK_MONOTONIC) + next, 0, sntp_timer, sntp);
275 static int sntp_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
276 SNTPContext *sntp = userdata;
279 assert(sntp->event_receive);
282 sntp_clock_watch_setup(sntp);
284 /* skip our own jumps */
286 sntp->jumped = false;
291 log_info("System time changed, resyncing.");
292 sntp->poll_resync = true;
293 sntp_send_request(sntp);
298 /* wake up when the system time changes underneath us */
299 static int sntp_clock_watch_setup(SNTPContext *sntp) {
300 struct itimerspec its = { .it_value.tv_sec = TIME_T_MAX };
301 _cleanup_close_ int fd = -1;
303 sd_event_source *source;
307 assert(sntp->event_receive);
309 fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
311 log_error("Failed to create timerfd: %m");
315 if (timerfd_settime(fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
316 log_error("Failed to set up timerfd: %m");
320 e = sd_event_source_get_event(sntp->event_receive);
321 r = sd_event_add_io(e, &source, fd, EPOLLIN, sntp_clock_watch, sntp);
323 log_error("Failed to create clock watch event source: %s", strerror(-r));
327 sd_event_source_unref(sntp->event_clock_watch);
328 sntp->event_clock_watch = source;
330 if (sntp->clock_watch_fd >= 0)
331 close(sntp->clock_watch_fd);
332 sntp->clock_watch_fd = fd;
338 static int sntp_adjust_clock(SNTPContext *sntp, double offset, int leap_sec) {
339 struct timex tmx = {};
343 * For small deltas, tell the kernel to gradually adjust the system
344 * clock to the NTP time, larger deltas are just directly set.
346 * Clear STA_UNSYNC, it will enable the kernel's 11-minute mode, which
347 * syncs the system time periodically to the hardware clock.
349 if (offset < NTP_MAX_ADJUST && offset > -NTP_MAX_ADJUST) {
350 tmx.modes |= ADJ_STATUS | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
351 tmx.status = STA_PLL;
352 tmx.offset = offset * 1000 * 1000;
353 tmx.constant = log2i(sntp->poll_interval_usec / USEC_PER_SEC) - 6;
356 log_debug(" adjust (slew): %+f sec\n", (double)tmx.offset / USEC_PER_SEC);
358 tmx.modes = ADJ_SETOFFSET;
359 d_to_tv(offset, &tmx.time);
362 log_debug(" adjust (jump): %+f sec\n", tv_to_d(&tmx.time));
367 tmx.status |= STA_INS;
370 tmx.status |= STA_DEL;
374 r = clock_adjtime(CLOCK_REALTIME, &tmx);
378 log_debug(" status : %04i %s\n"
379 " time now : %li.%06li\n"
381 " offset : %+f sec\n"
382 " freq offset : %+li (%+.3f ppm)\n",
383 tmx.status, tmx.status & STA_UNSYNC ? "" : "sync",
384 tmx.time.tv_sec, tmx.time.tv_usec,
386 (double)tmx.offset / USEC_PER_SEC,
387 tmx.freq, (double)tmx.freq / 65536);
392 static bool sntp_sample_spike_detection(SNTPContext *sntp, double offset, double delay) {
393 unsigned int i, idx_cur, idx_new, idx_min;
397 /* store the current data in our samples array */
398 idx_cur = sntp->samples_idx;
399 idx_new = (idx_cur + 1) % ELEMENTSOF(sntp->samples);
400 sntp->samples_idx = idx_new;
401 sntp->samples[idx_new].offset = offset;
402 sntp->samples[idx_new].delay = delay;
404 sntp->packet_count++;
405 jitter = sntp->samples_jitter;
407 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
408 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(sntp->samples); i++)
409 if (sntp->samples[i].delay > 0 && sntp->samples[i].delay < sntp->samples[idx_min].delay)
413 for (i = 0; i < ELEMENTSOF(sntp->samples); i++)
414 j += square(sntp->samples[i].offset - sntp->samples[idx_min].offset);
415 sntp->samples_jitter = sqrt(j / (ELEMENTSOF(sntp->samples) - 1));
417 /* ignore samples when resyncing */
418 if (sntp->poll_resync)
421 /* always accept offset if we are farther off than the round-trip delay */
422 if (fabs(offset) > delay)
425 /* we need a few samples before looking at them */
426 if (sntp->packet_count < 4)
429 /* do not accept anything worse than the maximum possible error of the best sample */
430 if (fabs(offset) > sntp->samples[idx_min].delay)
433 /* compare the difference between the current offset to the previous offset and jitter */
434 return fabs(offset - sntp->samples[idx_cur].offset) > 3 * jitter;
437 static void sntp_adjust_poll(SNTPContext *sntp, double offset, bool spike) {
438 if (sntp->poll_resync) {
439 sntp->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
440 sntp->poll_resync = false;
444 /* set to minimal poll interval */
445 if (fabs(offset) > NTP_ACCURACY_SEC) {
446 sntp->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
450 /* increase polling interval */
451 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
452 if (sntp->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
453 sntp->poll_interval_usec *= 2;
457 /* decrease polling interval */
458 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
459 if (sntp->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
460 sntp->poll_interval_usec /= 2;
465 static int sntp_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
466 SNTPContext *sntp = userdata;
467 unsigned char buf[sizeof(struct ntp_msg)];
470 .iov_len = sizeof(buf),
473 struct cmsghdr cmsghdr;
474 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
476 struct sockaddr_in server_addr;
477 struct msghdr msghdr = {
480 .msg_control = &control,
481 .msg_controllen = sizeof(control),
482 .msg_name = &server_addr,
483 .msg_namelen = sizeof(server_addr),
485 struct cmsghdr *cmsg;
486 struct timespec now_ts;
487 struct timeval *recv_time;
489 struct ntp_msg *ntpmsg;
490 double origin, receive, trans, dest;
491 double delay, offset;
496 if (revents & (EPOLLHUP|EPOLLERR)) {
497 log_debug("Server connection returned error, closing.");
498 sntp_server_disconnect(sntp);
502 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
504 log_debug("Error receiving message, disconnecting");
508 if (iov.iov_len < sizeof(struct ntp_msg)) {
509 log_debug("Invalid response from server, disconnecting");
513 if (sntp->server_addr.sin_addr.s_addr != server_addr.sin_addr.s_addr) {
514 log_debug("Response from unknown server, disconnecting");
519 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
520 if (cmsg->cmsg_level != SOL_SOCKET)
523 switch (cmsg->cmsg_type) {
525 recv_time = (struct timeval *) CMSG_DATA(cmsg);
530 log_debug("Invalid packet timestamp, disconnecting");
534 ntpmsg = iov.iov_base;
535 if (!sntp->pending) {
536 log_debug("Unexpected reply, ignoring");
540 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
541 if (be32toh(ntpmsg->origin_time.sec) != sntp->trans_time.tv_sec + OFFSET_1900_1970||
542 be32toh(ntpmsg->origin_time.frac) != sntp->trans_time.tv_nsec) {
543 log_debug("Invalid reply, not our transmit time, ignoring");
547 if (NTP_FIELD_LEAP(ntpmsg->field) == NTP_LEAP_NOTINSYNC) {
548 log_debug("Server is not synchronized, disconnecting");
552 if (NTP_FIELD_VERSION(ntpmsg->field) != 4) {
553 log_debug("Response NTPv%d, disconnecting", NTP_FIELD_VERSION(ntpmsg->field));
557 if (NTP_FIELD_MODE(ntpmsg->field) != NTP_MODE_SERVER) {
558 log_debug("Unsupported mode %d, disconnecting", NTP_FIELD_MODE(ntpmsg->field));
563 sntp->pending = false;
564 sntp->retry_interval = 0;
566 /* announce leap seconds */
567 if (NTP_FIELD_LEAP(ntpmsg->field) & NTP_LEAP_PLUSSEC)
569 else if (NTP_FIELD_LEAP(ntpmsg->field) & NTP_LEAP_MINUSSEC)
575 * "Timestamp Name ID When Generated
576 * ------------------------------------------------------------
577 * Originate Timestamp T1 time request sent by client
578 * Receive Timestamp T2 time request received by server
579 * Transmit Timestamp T3 time reply sent by server
580 * Destination Timestamp T4 time reply received by client
582 * The roundtrip delay d and system clock offset t are defined as:
583 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
585 clock_gettime(CLOCK_MONOTONIC, &now_ts);
586 origin = tv_to_d(recv_time) - (ts_to_d(&now_ts) - ts_to_d(&sntp->trans_time_mon)) + OFFSET_1900_1970;
587 receive = ntp_ts_to_d(&ntpmsg->recv_time);
588 trans = ntp_ts_to_d(&ntpmsg->trans_time);
589 dest = tv_to_d(recv_time) + OFFSET_1900_1970;
591 offset = ((receive - origin) + (trans - dest)) / 2;
592 delay = (dest - origin) - (trans - receive);
594 spike = sntp_sample_spike_detection(sntp, offset, delay);
596 sntp_adjust_poll(sntp, offset, spike);
598 log_debug("NTP response:\n"
603 " precision : %f sec (%d)\n"
604 " reference : %.4s\n"
609 " offset : %+f sec\n"
611 " packet count : %"PRIu64"\n"
613 " poll interval: %llu\n",
614 NTP_FIELD_LEAP(ntpmsg->field),
615 NTP_FIELD_VERSION(ntpmsg->field),
616 NTP_FIELD_MODE(ntpmsg->field),
618 exp2(ntpmsg->precision), ntpmsg->precision,
619 ntpmsg->stratum == 1 ? ntpmsg->refid : "n/a",
620 origin - OFFSET_1900_1970,
621 receive - OFFSET_1900_1970,
622 trans - OFFSET_1900_1970,
623 dest - OFFSET_1900_1970,
626 sntp->samples_jitter, spike ? " spike" : "",
627 sntp->poll_interval_usec / USEC_PER_SEC);
630 sntp->report(sntp->poll_interval_usec, offset, delay, sntp->samples_jitter, spike);
633 r = sntp_adjust_clock(sntp, offset, leap_sec);
635 log_error("Failed to call clock_adjtime(): %m");
638 r = sntp_arm_timer(sntp, sntp->poll_interval_usec);
645 int sntp_server_connect(SNTPContext *sntp, const char *server) {
646 _cleanup_free_ char *s = NULL;
650 assert(sntp->server_socket >= 0);
660 zero(sntp->server_addr);
661 sntp->server_addr.sin_family = AF_INET;
662 sntp->server_addr.sin_addr.s_addr = inet_addr(server);
664 sntp->poll_interval_usec = 2 * NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
666 return sntp_send_request(sntp);
669 void sntp_server_disconnect(SNTPContext *sntp) {
673 sntp->event_timer = sd_event_source_unref(sntp->event_timer);
675 sntp->event_clock_watch = sd_event_source_unref(sntp->event_clock_watch);
676 if (sntp->clock_watch_fd > 0)
677 close(sntp->clock_watch_fd);
678 sntp->clock_watch_fd = -1;
680 sntp->event_receive = sd_event_source_unref(sntp->event_receive);
681 if (sntp->server_socket > 0)
682 close(sntp->server_socket);
683 sntp->server_socket = -1;
685 zero(sntp->server_addr);
690 static int sntp_listen_setup(SNTPContext *sntp, sd_event *e) {
691 _cleanup_close_ int fd = -1;
692 struct sockaddr_in addr;
694 const int tos = IPTOS_LOWDELAY;
697 fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
702 addr.sin_family = AF_INET;
703 r = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
707 r = setsockopt(fd, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on));
711 r = setsockopt(fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
715 r = sd_event_add_io(e, &sntp->event_receive, fd, EPOLLIN, sntp_receive_response, sntp);
719 sntp->server_socket = fd;
725 void sntp_report_register(SNTPContext *sntp, void (*report)(usec_t poll_usec, double offset, double delay, double jitter, bool spike)) {
726 sntp->report = report;
729 int sntp_new(SNTPContext **sntp, sd_event *e) {
730 _cleanup_free_ SNTPContext *c;
733 c = new0(SNTPContext, 1);
737 r = sntp_listen_setup(c, e);
741 r = sntp_clock_watch_setup(c);
751 SNTPContext *sntp_unref(SNTPContext *sntp) {
752 sntp_server_disconnect(sntp);