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/>.
29 #include <arpa/inet.h>
30 #include <netinet/in.h>
31 #include <netinet/ip.h>
32 #include <sys/timerfd.h>
33 #include <sys/timex.h>
34 #include <sys/socket.h>
38 #include "sparse-endian.h"
41 #include "sd-daemon.h"
43 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
46 #define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
49 /* expected accuracy of time synchronization; used to adjust the poll interval */
50 #define NTP_ACCURACY_SEC 0.2
53 * "A client MUST NOT under any conditions use a poll interval less
56 #define NTP_POLL_INTERVAL_MIN_SEC 32
57 #define NTP_POLL_INTERVAL_MAX_SEC 2048
60 * Maximum delta in seconds which the system clock is gradually adjusted
61 * (slew) to approach the network time. Deltas larger that this are set by
62 * letting the system time jump. The kernel's limit for adjtime is 0.5s.
64 #define NTP_MAX_ADJUST 0.4
66 /* NTP protocol, packet header */
67 #define NTP_LEAP_PLUSSEC 1
68 #define NTP_LEAP_MINUSSEC 2
69 #define NTP_LEAP_NOTINSYNC 3
70 #define NTP_MODE_CLIENT 3
71 #define NTP_MODE_SERVER 4
72 #define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
73 #define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
74 #define NTP_FIELD_MODE(f) ((f) & 7)
75 #define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
78 * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
79 * in seconds relative to 0h on 1 January 1900."
81 #define OFFSET_1900_1970 2208988800UL
98 struct ntp_ts_short root_delay;
99 struct ntp_ts_short root_dispersion;
101 struct ntp_ts reference_time;
102 struct ntp_ts origin_time;
103 struct ntp_ts recv_time;
104 struct ntp_ts trans_time;
107 typedef struct Manager Manager;
112 sd_event_source *event_receive;
114 struct sockaddr_in server_addr;
116 uint64_t packet_count;
118 /* last sent packet */
119 struct timespec trans_time_mon;
120 struct timespec trans_time;
121 usec_t retry_interval;
125 sd_event_source *event_timer;
126 usec_t poll_interval_usec;
134 unsigned int samples_idx;
135 double samples_jitter;
141 /* watch for time changes */
142 sd_event_source *event_clock_watch;
146 static void manager_free(Manager *m);
147 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
148 #define _cleanup_manager_free_ _cleanup_(manager_freep)
150 static int sntp_arm_timer(Manager *m, usec_t next);
151 static int sntp_clock_watch_setup(Manager *m);
152 static void sntp_server_disconnect(Manager *m);
154 static double ntp_ts_to_d(const struct ntp_ts *ts) {
155 return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
158 static double ts_to_d(const struct timespec *ts) {
159 return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
162 static double tv_to_d(const struct timeval *tv) {
163 return tv->tv_sec + (1.0e-6 * tv->tv_usec);
166 static double square(double d) {
170 static int sntp_send_request(Manager *m) {
171 struct ntp_msg ntpmsg = {};
172 struct sockaddr_in addr = {};
177 * "The client initializes the NTP message header, sends the request
178 * to the server, and strips the time of day from the Transmit
179 * Timestamp field of the reply. For this purpose, all the NTP
180 * header fields are set to 0, except the Mode, VN, and optional
181 * Transmit Timestamp fields."
183 ntpmsg.field = NTP_FIELD(0, 4, NTP_MODE_CLIENT);
186 * Set transmit timestamp, remember it; the server will send that back
187 * as the origin timestamp and we have an indication that this is the
188 * matching answer to our request.
190 * The actual value does not matter, We do not care about the correct
191 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
193 clock_gettime(CLOCK_MONOTONIC, &m->trans_time_mon);
194 clock_gettime(CLOCK_REALTIME, &m->trans_time);
195 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
196 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
198 addr.sin_family = AF_INET;
199 addr.sin_port = htobe16(123);
200 addr.sin_addr.s_addr = inet_addr(m->server);
201 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &addr, sizeof(addr));
202 if (len == sizeof(ntpmsg)) {
204 log_debug("Sent NTP request to: %s", m->server);
206 log_debug("Sending NTP request to %s failed: %m", m->server);
208 /* re-arm timer with incresing timeout, in case the packets never arrive back */
209 if (m->retry_interval > 0) {
210 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
211 m->retry_interval *= 2;
213 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
214 r = sntp_arm_timer(m, m->retry_interval);
221 static int sntp_timer(sd_event_source *source, usec_t usec, void *userdata) {
222 Manager *m = userdata;
226 sntp_send_request(m);
230 static int sntp_arm_timer(Manager *m, usec_t next) {
234 assert(m->event_receive);
237 m->event_timer = sd_event_source_unref(m->event_timer);
241 if (m->event_timer) {
242 r = sd_event_source_set_time(m->event_timer, now(CLOCK_MONOTONIC) + next);
246 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
249 r = sd_event_add_time(
253 now(CLOCK_MONOTONIC) + next, 0,
261 static int sntp_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
262 Manager *m = userdata;
265 assert(m->event_receive);
268 sntp_clock_watch_setup(m);
270 /* skip our own jumps */
277 log_info("System time changed. Resyncing.");
278 m->poll_resync = true;
279 sntp_send_request(m);
284 /* wake up when the system time changes underneath us */
285 static int sntp_clock_watch_setup(Manager *m) {
286 struct itimerspec its = { .it_value.tv_sec = TIME_T_MAX };
287 _cleanup_close_ int fd = -1;
288 sd_event_source *source;
292 assert(m->event_receive);
294 fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
296 log_error("Failed to create timerfd: %m");
300 if (timerfd_settime(fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
301 log_error("Failed to set up timerfd: %m");
305 r = sd_event_add_io(m->event, &source, fd, EPOLLIN, sntp_clock_watch, m);
307 log_error("Failed to create clock watch event source: %s", strerror(-r));
311 sd_event_source_unref(m->event_clock_watch);
312 m->event_clock_watch = source;
314 if (m->clock_watch_fd >= 0)
315 close(m->clock_watch_fd);
316 m->clock_watch_fd = fd;
322 static int sntp_adjust_clock(Manager *m, double offset, int leap_sec) {
323 struct timex tmx = {};
327 * For small deltas, tell the kernel to gradually adjust the system
328 * clock to the NTP time, larger deltas are just directly set.
330 * Clear STA_UNSYNC, it will enable the kernel's 11-minute mode, which
331 * syncs the system time periodically to the hardware clock.
333 if (fabs(offset) < NTP_MAX_ADJUST) {
334 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
335 tmx.status = STA_PLL;
336 tmx.offset = offset * NSEC_PER_SEC;
337 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
340 log_debug(" adjust (slew): %+.3f sec\n", offset);
342 tmx.modes = ADJ_SETOFFSET | ADJ_NANO;
344 /* ADJ_NANO uses nanoseconds in the microseconds field */
345 tmx.time.tv_sec = (long)offset;
346 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
348 /* the kernel expects -0.3s as {-1, 7000.000.000} */
349 if (tmx.time.tv_usec < 0) {
350 tmx.time.tv_sec -= 1;
351 tmx.time.tv_usec += NSEC_PER_SEC;
355 log_debug(" adjust (jump): %+.3f sec\n", offset);
360 tmx.status |= STA_INS;
363 tmx.status |= STA_DEL;
367 r = clock_adjtime(CLOCK_REALTIME, &tmx);
371 m->drift_ppm = tmx.freq / 65536;
373 log_debug(" status : %04i %s\n"
374 " time now : %li.%03lli\n"
376 " offset : %+.3f sec\n"
377 " freq offset : %+li (%i ppm)\n",
378 tmx.status, tmx.status & STA_UNSYNC ? "" : "sync",
379 tmx.time.tv_sec, tmx.time.tv_usec / NSEC_PER_MSEC,
381 (double)tmx.offset / NSEC_PER_SEC,
382 tmx.freq, m->drift_ppm);
387 static bool sntp_sample_spike_detection(Manager *m, double offset, double delay) {
388 unsigned int i, idx_cur, idx_new, idx_min;
394 /* ignore initial sample */
395 if (m->packet_count == 1)
398 /* store the current data in our samples array */
399 idx_cur = m->samples_idx;
400 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
401 m->samples_idx = idx_new;
402 m->samples[idx_new].offset = offset;
403 m->samples[idx_new].delay = delay;
405 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
406 jitter = m->samples_jitter;
407 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
408 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
412 for (i = 0; i < ELEMENTSOF(m->samples); i++)
413 j += square(m->samples[i].offset - m->samples[idx_min].offset);
414 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
416 /* ignore samples when resyncing */
420 /* always accept offset if we are farther off than the round-trip delay */
421 if (fabs(offset) > delay)
424 /* we need a few samples before looking at them */
425 if (m->packet_count < 4)
428 /* do not accept anything worse than the maximum possible error of the best sample */
429 if (fabs(offset) > m->samples[idx_min].delay)
432 /* compare the difference between the current offset to the previous offset and jitter */
433 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
436 static void sntp_adjust_poll(Manager *m, double offset, bool spike) {
437 if (m->poll_resync) {
438 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
439 m->poll_resync = false;
443 /* set to minimal poll interval */
444 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
445 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
449 /* increase polling interval */
450 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
451 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
452 m->poll_interval_usec *= 2;
456 /* decrease polling interval */
457 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
458 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
459 m->poll_interval_usec /= 2;
464 static int sntp_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
465 Manager *m = userdata;
466 unsigned char buf[sizeof(struct ntp_msg)];
469 .iov_len = sizeof(buf),
472 struct cmsghdr cmsghdr;
473 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
475 struct sockaddr_in server_addr;
476 struct msghdr msghdr = {
479 .msg_control = &control,
480 .msg_controllen = sizeof(control),
481 .msg_name = &server_addr,
482 .msg_namelen = sizeof(server_addr),
484 struct cmsghdr *cmsg;
485 struct timespec now_ts;
486 struct timeval *recv_time;
488 struct ntp_msg *ntpmsg;
489 double origin, receive, trans, dest;
490 double delay, offset;
495 if (revents & (EPOLLHUP|EPOLLERR)) {
496 log_debug("Server connection returned error. Closing.");
497 sntp_server_disconnect(m);
501 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
503 log_debug("Error receiving message. Disconnecting.");
507 if (iov.iov_len < sizeof(struct ntp_msg)) {
508 log_debug("Invalid response from server. Disconnecting.");
512 if (m->server_addr.sin_addr.s_addr != server_addr.sin_addr.s_addr) {
513 log_debug("Response from unknown server. Disconnecting.");
518 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
519 if (cmsg->cmsg_level != SOL_SOCKET)
522 switch (cmsg->cmsg_type) {
524 recv_time = (struct timeval *) CMSG_DATA(cmsg);
529 log_debug("Invalid packet timestamp. Disconnecting.");
533 ntpmsg = iov.iov_base;
535 log_debug("Unexpected reply. Ignoring.");
539 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
540 if (be32toh(ntpmsg->origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
541 be32toh(ntpmsg->origin_time.frac) != m->trans_time.tv_nsec) {
542 log_debug("Invalid reply; not our transmit time. Ignoring.");
546 if (NTP_FIELD_LEAP(ntpmsg->field) == NTP_LEAP_NOTINSYNC) {
547 log_debug("Server is not synchronized. Disconnecting.");
551 if (NTP_FIELD_VERSION(ntpmsg->field) != 4) {
552 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg->field));
556 if (NTP_FIELD_MODE(ntpmsg->field) != NTP_MODE_SERVER) {
557 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg->field));
563 m->retry_interval = 0;
565 /* announce leap seconds */
566 if (NTP_FIELD_LEAP(ntpmsg->field) & NTP_LEAP_PLUSSEC)
568 else if (NTP_FIELD_LEAP(ntpmsg->field) & NTP_LEAP_MINUSSEC)
574 * "Timestamp Name ID When Generated
575 * ------------------------------------------------------------
576 * Originate Timestamp T1 time request sent by client
577 * Receive Timestamp T2 time request received by server
578 * Transmit Timestamp T3 time reply sent by server
579 * Destination Timestamp T4 time reply received by client
581 * The round-trip delay, d, and system clock offset, t, are defined as:
582 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
584 clock_gettime(CLOCK_MONOTONIC, &now_ts);
585 origin = tv_to_d(recv_time) - (ts_to_d(&now_ts) - ts_to_d(&m->trans_time_mon)) + OFFSET_1900_1970;
586 receive = ntp_ts_to_d(&ntpmsg->recv_time);
587 trans = ntp_ts_to_d(&ntpmsg->trans_time);
588 dest = tv_to_d(recv_time) + OFFSET_1900_1970;
590 offset = ((receive - origin) + (trans - dest)) / 2;
591 delay = (dest - origin) - (trans - receive);
593 spike = sntp_sample_spike_detection(m, offset, delay);
595 sntp_adjust_poll(m, offset, spike);
597 log_debug("NTP response:\n"
602 " precision : %.6f sec (%d)\n"
603 " reference : %.4s\n"
608 " offset : %+.3f sec\n"
609 " delay : %+.3f sec\n"
610 " packet count : %"PRIu64"\n"
612 " poll interval: %llu\n",
613 NTP_FIELD_LEAP(ntpmsg->field),
614 NTP_FIELD_VERSION(ntpmsg->field),
615 NTP_FIELD_MODE(ntpmsg->field),
617 exp2(ntpmsg->precision), ntpmsg->precision,
618 ntpmsg->stratum == 1 ? ntpmsg->refid : "n/a",
619 origin - OFFSET_1900_1970,
620 receive - OFFSET_1900_1970,
621 trans - OFFSET_1900_1970,
622 dest - OFFSET_1900_1970,
625 m->samples_jitter, spike ? " spike" : "",
626 m->poll_interval_usec / USEC_PER_SEC);
629 r = sntp_adjust_clock(m, offset, leap_sec);
631 log_error("Failed to call clock_adjtime(): %m");
634 log_info("%s: interval/delta/delay/jitter/drift %llus/%+.3fs/%.3fs/%.3fs/%uppm%s",
635 m->server, m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
636 spike ? " (ignored)" : "");
637 r = sntp_arm_timer(m, m->poll_interval_usec);
644 static int sntp_server_connect(Manager *m, const char *server) {
645 _cleanup_free_ char *s = NULL;
649 assert(m->server_socket >= 0);
659 zero(m->server_addr);
660 m->server_addr.sin_family = AF_INET;
661 m->server_addr.sin_addr.s_addr = inet_addr(server);
663 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
665 return sntp_send_request(m);
668 static void sntp_server_disconnect(Manager *m) {
672 m->event_timer = sd_event_source_unref(m->event_timer);
674 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
675 if (m->clock_watch_fd > 0)
676 close(m->clock_watch_fd);
677 m->clock_watch_fd = -1;
679 m->event_receive = sd_event_source_unref(m->event_receive);
680 if (m->server_socket > 0)
681 close(m->server_socket);
682 m->server_socket = -1;
684 zero(m->server_addr);
689 static int sntp_listen_setup(Manager *m) {
690 _cleanup_close_ int fd = -1;
691 struct sockaddr_in addr;
693 const int tos = IPTOS_LOWDELAY;
696 fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
701 addr.sin_family = AF_INET;
702 r = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
706 r = setsockopt(fd, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on));
710 r = setsockopt(fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
714 r = sd_event_add_io(m->event, &m->event_receive, fd, EPOLLIN, sntp_receive_response, m);
718 m->server_socket = fd;
724 static int manager_new(Manager **ret) {
725 _cleanup_manager_free_ Manager *m = NULL;
728 m = new0(Manager, 1);
732 r = sd_event_default(&m->event);
736 r = sntp_listen_setup(m);
740 r = sntp_clock_watch_setup(m);
750 static void manager_free(Manager *m) {
755 sd_event_unref(m->event);
759 int main(int argc, char *argv[]) {
760 _cleanup_manager_free_ Manager *m = NULL;
764 log_set_target(LOG_TARGET_AUTO);
765 log_parse_environment();
772 server = "216.239.32.15"; /* time1.google.com */
774 sd_notify(false, "READY=1");
776 r = sntp_server_connect(m, server);
780 sd_notifyf(false, "STATUS=Using Time Server: %s", server);
782 r = sd_event_loop(m->event);
787 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;