2 * systemd service to wait until kernel realtime clock is synchronized
4 * You should have received a copy of the GNU General Public License
5 * along with this program; if not, write to the Free Software
6 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
16 #include <sys/inotify.h>
17 #include <sys/timerfd.h>
18 #include <sys/timex.h>
25 #include "main-func.h"
27 #include "signal-util.h"
28 #include "time-util.h"
30 typedef struct ClockState
{
31 int timerfd_fd
; /* non-negative is descriptor from timerfd_create */
32 int adjtime_state
; /* return value from last adjtimex(2) call */
33 sd_event_source
*timerfd_event_source
; /* non-null is the active io event source */
35 sd_event_source
*inotify_event_source
;
37 int run_systemd_timesync_wd
;
41 static void clock_state_release_timerfd(ClockState
*sp
) {
42 sp
->timerfd_event_source
= sd_event_source_unref(sp
->timerfd_event_source
);
43 sp
->timerfd_fd
= safe_close(sp
->timerfd_fd
);
46 static void clock_state_release(ClockState
*sp
) {
47 clock_state_release_timerfd(sp
);
48 sp
->inotify_event_source
= sd_event_source_unref(sp
->inotify_event_source
);
49 sp
->inotify_fd
= safe_close(sp
->inotify_fd
);
52 static int clock_state_update(ClockState
*sp
, sd_event
*event
);
54 static int update_notify_run_systemd_timesync(ClockState
*sp
) {
55 sp
->run_systemd_timesync_wd
= inotify_add_watch(sp
->inotify_fd
, "/run/systemd/timesync", IN_CREATE
|IN_DELETE_SELF
);
56 return sp
->run_systemd_timesync_wd
;
59 static int timerfd_handler(sd_event_source
*s
,
63 ClockState
*sp
= userdata
;
65 return clock_state_update(sp
, sd_event_source_get_event(s
));
68 static void process_inotify_event(sd_event
*event
, ClockState
*sp
, struct inotify_event
*e
) {
69 if (e
->wd
== sp
->run_systemd_wd
) {
70 /* Only thing we care about is seeing if we can start watching /run/systemd/timesync. */
71 if (sp
->run_systemd_timesync_wd
< 0)
72 update_notify_run_systemd_timesync(sp
);
73 } else if (e
->wd
== sp
->run_systemd_timesync_wd
) {
74 if (e
->mask
& IN_DELETE_SELF
) {
75 /* Somebody removed /run/systemd/timesync. */
76 (void) inotify_rm_watch(sp
->inotify_fd
, sp
->run_systemd_timesync_wd
);
77 sp
->run_systemd_timesync_wd
= -1;
79 /* Somebody might have created /run/systemd/timesync/synchronized. */
80 clock_state_update(sp
, event
);
84 static int inotify_handler(sd_event_source
*s
,
88 sd_event
*event
= sd_event_source_get_event(s
);
89 ClockState
*sp
= userdata
;
90 union inotify_event_buffer buffer
;
91 struct inotify_event
*e
;
94 l
= read(fd
, &buffer
, sizeof(buffer
));
96 if (IN_SET(errno
, EAGAIN
, EINTR
))
99 return log_warning_errno(errno
, "Lost access to inotify: %m");
101 FOREACH_INOTIFY_EVENT(e
, buffer
, l
)
102 process_inotify_event(event
, sp
, e
);
107 static int clock_state_update(
111 char buf
[MAX((size_t)FORMAT_TIMESTAMP_MAX
, STRLEN("unrepresentable"))];
112 struct timex tx
= {};
117 clock_state_release_timerfd(sp
);
119 /* The kernel supports cancelling timers whenever its realtime clock is "set" (which can happen in a variety of
120 * ways, generally adjustments of at least 500 ms). The way this module works is we set up a timerfd that will
121 * wake when the clock is set, and when that happens we read the clock synchronization state from the return
122 * value of adjtimex(2), which supports the NTP time adjustment protocol.
124 * The kernel determines whether the clock is synchronized using driver-specific tests, based on time
125 * information passed by an application, generally through adjtimex(2). If the application asserts the clock is
126 * synchronized, but does not also do something that "sets the clock", the timer will not be cancelled and
127 * synchronization will not be detected.
129 * Similarly, this service will never complete if the application sets the time without also providing
130 * information that adjtimex(2) can use to determine that the clock is synchronized. This generally doesn't
131 * happen, but can if the system has a hardware clock that is accurate enough that the adjustment is too small
134 * Both these failure-to-detect situations are covered by having the presence/creation of
135 * /run/systemd/timesync/synchronized, which is considered sufficient to indicate a synchronized clock even if
136 * the kernel has not been updated.
138 * For timesyncd the initial setting of the time uses settimeofday(2), which sets the clock but does not mark
139 * it synchronized. When an NTP source is selected it sets the clock again with clock_adjtime(2) which marks it
140 * synchronized and also touches /run/systemd/timesync/synchronized which covers the case when the clock wasn't
143 r
= time_change_fd();
145 log_error_errno(r
, "Failed to create timerfd: %m");
152 log_error_errno(errno
, "Failed to read adjtimex state: %m");
155 sp
->adjtime_state
= r
;
157 if (tx
.status
& STA_NANO
)
158 tx
.time
.tv_usec
/= 1000;
159 t
= timeval_load(&tx
.time
);
160 ts
= format_timestamp_us_utc(buf
, sizeof(buf
), t
);
162 strcpy(buf
, "unrepresentable");
163 log_info("adjtime state %d status %x time %s", sp
->adjtime_state
, tx
.status
, ts
);
165 sp
->has_watchfile
= access("/run/systemd/timesync/synchronized", F_OK
) >= 0;
166 if (sp
->has_watchfile
)
167 /* Presence of watch file overrides adjtime_state */
169 else if (sp
->adjtime_state
== TIME_ERROR
) {
170 /* Not synchronized. Do a one-shot wait on the descriptor and inform the caller we need to keep
172 r
= sd_event_add_io(event
, &sp
->timerfd_event_source
, sp
->timerfd_fd
,
173 EPOLLIN
, timerfd_handler
, sp
);
175 log_error_errno(r
, "Failed to create time change monitor source: %m");
180 /* Synchronized; we can exit. */
185 (void) sd_event_exit(event
, r
);
189 static int run(int argc
, char * argv
[]) {
190 _cleanup_(sd_event_unrefp
) sd_event
*event
;
191 _cleanup_(clock_state_release
) ClockState state
= {
194 .run_systemd_wd
= -1,
195 .run_systemd_timesync_wd
= -1,
199 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGTERM
, SIGINT
, -1) >= 0);
201 r
= sd_event_default(&event
);
203 return log_error_errno(r
, "Failed to allocate event loop: %m");
205 r
= sd_event_add_signal(event
, NULL
, SIGTERM
, NULL
, NULL
);
207 return log_error_errno(r
, "Failed to create sigterm event source: %m");
209 r
= sd_event_add_signal(event
, NULL
, SIGINT
, NULL
, NULL
);
211 return log_error_errno(r
, "Failed to create sigint event source: %m");
213 r
= sd_event_set_watchdog(event
, true);
215 return log_error_errno(r
, "Failed to create watchdog event source: %m");
217 r
= inotify_init1(IN_NONBLOCK
|IN_CLOEXEC
);
219 return log_error_errno(errno
, "Failed to create inotify descriptor: %m");
221 state
.inotify_fd
= r
;
223 r
= sd_event_add_io(event
, &state
.inotify_event_source
, state
.inotify_fd
,
224 EPOLLIN
, inotify_handler
, &state
);
226 return log_error_errno(r
, "Failed to create notify event source: %m");
228 r
= inotify_add_watch(state
.inotify_fd
, "/run/systemd/", IN_CREATE
);
230 return log_error_errno(errno
, "Failed to watch /run/systemd/: %m");
232 state
.run_systemd_wd
= r
;
234 (void) update_notify_run_systemd_timesync(&state
);
236 r
= clock_state_update(&state
, event
);
238 r
= sd_event_loop(event
);
240 log_error_errno(r
, "Failed in event loop: %m");
243 if (state
.has_watchfile
)
244 log_debug("Exit enabled by: /run/systemd/timesync/synchonized");
246 if (state
.adjtime_state
== TIME_ERROR
)
247 log_info("Exit without adjtimex synchronized.");
252 DEFINE_MAIN_FUNCTION(run
);