1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /* systemd service to wait until kernel realtime clock is synchronized */
9 #include <sys/inotify.h>
10 #include <sys/timerfd.h>
11 #include <sys/timex.h>
18 #include "main-func.h"
19 #include "signal-util.h"
20 #include "time-util.h"
22 typedef struct ClockState
{
23 int timerfd_fd
; /* non-negative is descriptor from timerfd_create */
24 int adjtime_state
; /* return value from last adjtimex(2) call */
25 sd_event_source
*timerfd_event_source
; /* non-null is the active io event source */
27 sd_event_source
*inotify_event_source
;
29 int run_systemd_timesync_wd
;
33 static void clock_state_release_timerfd(ClockState
*sp
) {
34 sp
->timerfd_event_source
= sd_event_source_unref(sp
->timerfd_event_source
);
35 sp
->timerfd_fd
= safe_close(sp
->timerfd_fd
);
38 static void clock_state_release(ClockState
*sp
) {
39 clock_state_release_timerfd(sp
);
40 sp
->inotify_event_source
= sd_event_source_unref(sp
->inotify_event_source
);
41 sp
->inotify_fd
= safe_close(sp
->inotify_fd
);
44 static int clock_state_update(ClockState
*sp
, sd_event
*event
);
46 static int update_notify_run_systemd_timesync(ClockState
*sp
) {
47 sp
->run_systemd_timesync_wd
= inotify_add_watch(sp
->inotify_fd
, "/run/systemd/timesync", IN_CREATE
|IN_DELETE_SELF
);
48 return sp
->run_systemd_timesync_wd
;
51 static int timerfd_handler(sd_event_source
*s
,
55 ClockState
*sp
= userdata
;
57 return clock_state_update(sp
, sd_event_source_get_event(s
));
60 static void process_inotify_event(sd_event
*event
, ClockState
*sp
, struct inotify_event
*e
) {
61 if (e
->wd
== sp
->run_systemd_wd
) {
62 /* Only thing we care about is seeing if we can start watching /run/systemd/timesync. */
63 if (sp
->run_systemd_timesync_wd
< 0)
64 update_notify_run_systemd_timesync(sp
);
65 } else if (e
->wd
== sp
->run_systemd_timesync_wd
) {
66 if (e
->mask
& IN_DELETE_SELF
) {
67 /* Somebody removed /run/systemd/timesync. */
68 (void) inotify_rm_watch(sp
->inotify_fd
, sp
->run_systemd_timesync_wd
);
69 sp
->run_systemd_timesync_wd
= -1;
71 /* Somebody might have created /run/systemd/timesync/synchronized. */
72 clock_state_update(sp
, event
);
76 static int inotify_handler(sd_event_source
*s
,
80 sd_event
*event
= sd_event_source_get_event(s
);
81 ClockState
*sp
= userdata
;
82 union inotify_event_buffer buffer
;
83 struct inotify_event
*e
;
86 l
= read(fd
, &buffer
, sizeof(buffer
));
88 if (IN_SET(errno
, EAGAIN
, EINTR
))
91 return log_warning_errno(errno
, "Lost access to inotify: %m");
93 FOREACH_INOTIFY_EVENT(e
, buffer
, l
)
94 process_inotify_event(event
, sp
, e
);
99 static int clock_state_update(
103 char buf
[MAX((size_t)FORMAT_TIMESTAMP_MAX
, STRLEN("unrepresentable"))];
104 struct timex tx
= {};
109 clock_state_release_timerfd(sp
);
111 /* The kernel supports cancelling timers whenever its realtime clock is "set" (which can happen in a variety of
112 * ways, generally adjustments of at least 500 ms). The way this module works is we set up a timerfd that will
113 * wake when the clock is set, and when that happens we read the clock synchronization state from the return
114 * value of adjtimex(2), which supports the NTP time adjustment protocol.
116 * The kernel determines whether the clock is synchronized using driver-specific tests, based on time
117 * information passed by an application, generally through adjtimex(2). If the application asserts the clock is
118 * synchronized, but does not also do something that "sets the clock", the timer will not be cancelled and
119 * synchronization will not be detected.
121 * Similarly, this service will never complete if the application sets the time without also providing
122 * information that adjtimex(2) can use to determine that the clock is synchronized. This generally doesn't
123 * happen, but can if the system has a hardware clock that is accurate enough that the adjustment is too small
126 * Both these failure-to-detect situations are covered by having the presence/creation of
127 * /run/systemd/timesync/synchronized, which is considered sufficient to indicate a synchronized clock even if
128 * the kernel has not been updated.
130 * For timesyncd the initial setting of the time uses settimeofday(2), which sets the clock but does not mark
131 * it synchronized. When an NTP source is selected it sets the clock again with clock_adjtime(2) which marks it
132 * synchronized and also touches /run/systemd/timesync/synchronized which covers the case when the clock wasn't
135 r
= time_change_fd();
137 log_error_errno(r
, "Failed to create timerfd: %m");
144 log_error_errno(errno
, "Failed to read adjtimex state: %m");
147 sp
->adjtime_state
= r
;
149 if (tx
.status
& STA_NANO
)
150 tx
.time
.tv_usec
/= 1000;
151 t
= timeval_load(&tx
.time
);
152 ts
= format_timestamp_style(buf
, sizeof(buf
), t
, TIMESTAMP_US_UTC
);
154 strcpy(buf
, "unrepresentable");
155 log_info("adjtime state %d status %x time %s", sp
->adjtime_state
, tx
.status
, ts
);
157 sp
->has_watchfile
= access("/run/systemd/timesync/synchronized", F_OK
) >= 0;
158 if (sp
->has_watchfile
)
159 /* Presence of watch file overrides adjtime_state */
161 else if (sp
->adjtime_state
== TIME_ERROR
) {
162 /* Not synchronized. Do a one-shot wait on the descriptor and inform the caller we need to keep
164 r
= sd_event_add_io(event
, &sp
->timerfd_event_source
, sp
->timerfd_fd
,
165 EPOLLIN
, timerfd_handler
, sp
);
167 log_error_errno(r
, "Failed to create time change monitor source: %m");
172 /* Synchronized; we can exit. */
177 (void) sd_event_exit(event
, r
);
181 static int run(int argc
, char * argv
[]) {
182 _cleanup_(sd_event_unrefp
) sd_event
*event
;
183 _cleanup_(clock_state_release
) ClockState state
= {
186 .run_systemd_wd
= -1,
187 .run_systemd_timesync_wd
= -1,
191 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGTERM
, SIGINT
, -1) >= 0);
193 r
= sd_event_default(&event
);
195 return log_error_errno(r
, "Failed to allocate event loop: %m");
197 r
= sd_event_add_signal(event
, NULL
, SIGTERM
, NULL
, NULL
);
199 return log_error_errno(r
, "Failed to create sigterm event source: %m");
201 r
= sd_event_add_signal(event
, NULL
, SIGINT
, NULL
, NULL
);
203 return log_error_errno(r
, "Failed to create sigint event source: %m");
205 r
= sd_event_set_watchdog(event
, true);
207 return log_error_errno(r
, "Failed to create watchdog event source: %m");
209 r
= inotify_init1(IN_NONBLOCK
|IN_CLOEXEC
);
211 return log_error_errno(errno
, "Failed to create inotify descriptor: %m");
213 state
.inotify_fd
= r
;
215 r
= sd_event_add_io(event
, &state
.inotify_event_source
, state
.inotify_fd
,
216 EPOLLIN
, inotify_handler
, &state
);
218 return log_error_errno(r
, "Failed to create notify event source: %m");
220 r
= inotify_add_watch_and_warn(state
.inotify_fd
, "/run/systemd/", IN_CREATE
);
224 state
.run_systemd_wd
= r
;
226 (void) update_notify_run_systemd_timesync(&state
);
228 r
= clock_state_update(&state
, event
);
230 r
= sd_event_loop(event
);
232 log_error_errno(r
, "Failed in event loop: %m");
235 if (state
.has_watchfile
)
236 log_debug("Exit enabled by: /run/systemd/timesync/synchronized");
238 if (state
.adjtime_state
== TIME_ERROR
)
239 log_info("Exit without adjtimex synchronized.");
244 DEFINE_MAIN_FUNCTION(run
);