shaba/systemd-stable
1
1
Fork 0
mirror of https://github.com/systemd/systemd-stable.git synced 2025-01-10 01:17:44 +03:00
Code

Merge pull request #8644 from yuwata/rfe-1589

Browse Source 
timesync: expose NTP response on DBus
This commit is contained in:
Lennart Poettering 2018-05-03 17:23:40 +02:00 committed by GitHub
commit d0821d8839
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 1006 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
man/rules/meson.build
View File

@ -706,7 +706,7 @@ manpages = [
['systemd.unit', '5', [], ''],
['sysusers.d', '5', [], 'ENABLE_SYSUSERS'],
['telinit', '8', [], ''],
['timedatectl', '1', [], 'ENABLE_TIMEDATED'],
['timedatectl', '1', [], 'ENABLE_TIMEDATECTL'],
['timesyncd.conf', '5', ['timesyncd.conf.d'], 'ENABLE_TIMESYNCD'],
['tmpfiles.d', '5', [], ''],
['udev', '7', [], ''],

4
man/systemd-timesyncd.service.xml
View File

@ -70,6 +70,10 @@
<para><citerefentry><refentrytitle>timedatectl</refentrytitle><manvolnum>1</manvolnum></citerefentry>'s
<command>set-ntp</command> command may be used to enable and
start, or disable and stop this service.</para>
<para><citerefentry><refentrytitle>timedatectl</refentrytitle><manvolnum>1</manvolnum></citerefentry>'s
<command>timesync-status</command> or <command>show-timesync</command> command can be used to show the
current status of this service.</para>
</refsect1>
<refsect1>

92
man/timedatectl.xml
View File

@ -10,7 +10,7 @@
Copyright 2012 Lennart Poettering
-->
<refentry id="timedatectl" conditional='ENABLE_TIMEDATED'
<refentry id="timedatectl" conditional='ENABLE_TIMEDATECTL'
xmlns:xi="http://www.w3.org/2001/XInclude">
<refentryinfo>
@ -53,6 +53,11 @@
<citerefentry><refentrytitle>systemd-firstboot</refentrytitle><manvolnum>1</manvolnum></citerefentry>
to initialize the system time zone for mounted (but not booted)
system images.</para>
<para><command>timedatectl</command> may be used to show the current status of
<citerefentry><refentrytitle>systemd-timesyncd.service</refentrytitle><manvolnum>8</manvolnum></citerefentry>.
</para>
</refsect1>
<refsect1>
@ -78,6 +83,43 @@
clock.</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--monitor</option></term>
<listitem><para>If <command>timesync-status</command> is invoked and this option is passed,
then <command>timedatectl</command> monitors the status of
<citerefentry><refentrytitle>systemd-timesyncd.service</refentrytitle><manvolnum>8</manvolnum></citerefentry>
and updates the outputs. Use Ctrl-C to terminate the monitoring.</para></listitem>
</varlistentry>
<varlistentry>
<term><option>-a</option></term>
<term><option>-all</option></term>
<listitem><para>When showing properties of
<citerefentry><refentrytitle>systemd-timesyncd.service</refentrytitle><manvolnum>8</manvolnum></citerefentry>,
show all properties regardless of whether they are set or not.</para></listitem>
</varlistentry>
<varlistentry>
<term><option>-p</option></term>
<term><option>--property=</option></term>
<listitem><para>When showing properties of
<citerefentry><refentrytitle>systemd-timesyncd.service</refentrytitle><manvolnum>8</manvolnum></citerefentry>,
limit display to certain properties as specified as argument. If not specified, all set properties are shown.
The argument should be a property name, such as <literal>ServerName</literal>. If specified more than once,
all properties with the specified names are shown.</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--value</option></term>
<listitem>
<para>When printing properties with <command>show-timesync</command>, only print the value, and skip the
property name and <literal>=</literal>.</para></listitem>
</varlistentry>
<xi:include href="user-system-options.xml" xpointer="host" />
<xi:include href="user-system-options.xml" xpointer="machine" />
@ -165,6 +207,35 @@
</variablelist>
<refsect2><title>systemd-timesyncd Commands</title>
<para>The following commands are specific to
<citerefentry><refentrytitle>systemd-timesyncd.service</refentrytitle><manvolnum>8</manvolnum></citerefentry>.
</para>
<variablelist>
<varlistentry>
<term><command>timesync-status</command></term>
<listitem><para>Show current status of
<citerefentry><refentrytitle>systemd-timesyncd.service</refentrytitle><manvolnum>8</manvolnum></citerefentry>.
If <option>--monitor</option> is specified, then this will monitor the status updates.</para></listitem>
</varlistentry>
<varlistentry>
<term><command>show-timesync</command></term>
<listitem><para>Show properties of the manager of
<citerefentry><refentrytitle>systemd-timesyncd.service</refentrytitle><manvolnum>8</manvolnum></citerefentry>.
By default, empty properties are suppressed. Use <option>--all</option> to show those too. To select specific
properties to show, use <option>--property=</option>. This command is intended to be used whenever
computer-parsable output is required. Use <option>timesync-status</option> if you are looking for formatted
human-readable output.</para></listitem>
</varlistentry>
</variablelist>
</refsect2>
</refsect1>
<refsect1>
@ -208,6 +279,25 @@ Password: ********
└─595 /usr/lib/systemd/systemd-timesyncd
…</programlisting>
</para>
<para>Show current status of
<citerefentry><refentrytitle>systemd-timesyncd.service</refentrytitle><manvolnum>8</manvolnum></citerefentry>:
<programlisting>$ timedatectl timesync-status
Server: 216.239.38.15 (time4.google.com)
Poll interval: 1min 4s (min: 32s; max 34min 8s)
Leap: normal
Version: 4
Stratum: 1
Reference: GPS
Precision: 1us (-20)
Root distance: 335us (max: 5s)
Offset: +316us
Delay: 349us
Jitter: 0
Packet count: 1
Frequency: -8.802ppm</programlisting>
</para>
</refsect1>
<refsect1>

10
meson.build
View File

@ -1237,6 +1237,13 @@ foreach term : ['utmp',
m4_defines += have ? ['-D' + name] : []
endforeach
if get_option('timedated') or get_option('timesyncd')
conf.set10('ENABLE_TIMEDATECTL', true)
m4_defines += ['-DENABLE_TIMEDATECTL']
else
conf.set10('ENABLE_TIMEDATECTL', false)
endif
want_tests = get_option('tests')
install_tests = get_option('install-tests')
slow_tests = get_option('slow-tests')
@ -1863,12 +1870,15 @@ if conf.get('ENABLE_TIMEDATED') == 1
install_rpath : rootlibexecdir,
install : true,
install_dir : rootlibexecdir)
endif
if conf.get('ENABLE_TIMEDATECTL') == 1
exe = executable('timedatectl',
'src/timedate/timedatectl.c',
include_directories : includes,
install_rpath : rootlibexecdir,
link_with : [libshared],
dependencies : [libm],
install : true)
public_programs += [exe]
endif

474
src/timedate/timedatectl.c
View File

@ -8,6 +8,7 @@
#include <getopt.h>
#include <locale.h>
#include <math.h>
#include <stdbool.h>
#include <stdlib.h>
@ -15,9 +16,12 @@
#include "bus-error.h"
#include "bus-util.h"
#include "in-addr-util.h"
#include "pager.h"
#include "parse-util.h"
#include "spawn-polkit-agent.h"
#include "sparse-endian.h"
#include "string-table.h"
#include "strv.h"
#include "terminal-util.h"
#include "util.h"
@ -28,6 +32,10 @@ static bool arg_ask_password = true;
static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
static char *arg_host = NULL;
static bool arg_adjust_system_clock = false;
static bool arg_monitor = false;
static char **arg_property = NULL;
static bool arg_value = false;
static bool arg_all = false;
typedef struct StatusInfo {
usec_t time;
@ -272,6 +280,405 @@ static int list_timezones(int argc, char **argv, void *userdata) {
return 0;
}
typedef struct NTPStatusInfo {
const char *server_name;
char *server_address;
usec_t poll_interval, poll_max, poll_min;
usec_t root_distance_max;
uint32_t leap, version, mode, stratum;
int32_t precision;
usec_t root_delay, root_dispersion;
union {
char str[5];
uint32_t val;
} reference;
usec_t origin, recv, trans, dest;
bool spike;
uint64_t packet_count;
usec_t jitter;
int64_t freq;
} NTPStatusInfo;
static void ntp_status_info_clear(NTPStatusInfo *p) {
p->server_address = mfree(p->server_address);
}
static const char * const ntp_leap_table[4] = {
[0] = "normal",
[1] = "last minute of the day has 61 seconds",
[2] = "last minute of the day has 59 seconds",
[3] = "not synchronized",
};
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits"
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(ntp_leap, uint32_t);
#pragma GCC diagnostic pop
static void print_ntp_status_info(NTPStatusInfo *i) {
char ts[FORMAT_TIMESPAN_MAX], tmin[FORMAT_TIMESPAN_MAX], tmax[FORMAT_TIMESPAN_MAX];
usec_t delay, t14, t23, offset, root_distance;
bool offset_sign;
assert(i);
/*
* "Timestamp Name ID When Generated
* ------------------------------------------------------------
* Originate Timestamp T1 time request sent by client
* Receive Timestamp T2 time request received by server
* Transmit Timestamp T3 time reply sent by server
* Destination Timestamp T4 time reply received by client
*
* The round-trip delay, d, and system clock offset, t, are defined as:
* d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
*/
printf(" Server: %s (%s)\n",
i->server_address, i->server_name);
printf("Poll interval: %s (min: %s; max %s)\n",
format_timespan(ts, sizeof(ts), i->poll_interval, 0),
format_timespan(tmin, sizeof(tmin), i->poll_min, 0),
format_timespan(tmax, sizeof(tmax), i->poll_max, 0));
if (i->packet_count == 0) {
printf(" Packet count: 0\n");
return;
}
if (i->dest < i->origin || i->trans < i->recv || i->dest - i->origin < i->trans - i->recv) {
log_error("Invalid NTP response");
return;
}
delay = (i->dest - i->origin) - (i->trans - i->recv);
t14 = i->origin + i->dest;
t23 = i->recv + i->trans;
offset_sign = t14 < t23;
offset = (offset_sign ? t23 - t14 : t14 - t23) / 2;
root_distance = i->root_delay / 2 + i->root_dispersion;
printf(" Leap: %s\n"
" Version: %" PRIu32 "\n"
" Stratum: %" PRIu32 "\n",
ntp_leap_to_string(i->leap),
i->version,
i->stratum);
if (i->stratum <= 1)
printf(" Reference: %s\n", i->reference.str);
else
printf(" Reference: %" PRIX32 "\n", be32toh(i->reference.val));
printf(" Precision: %s (%" PRIi32 ")\n",
format_timespan(ts, sizeof(ts), DIV_ROUND_UP((nsec_t) (exp2(i->precision) * NSEC_PER_SEC), NSEC_PER_USEC), 0),
i->precision);
printf("Root distance: %s (max: %s)\n",
format_timespan(ts, sizeof(ts), root_distance, 0),
format_timespan(tmax, sizeof(tmax), i->root_distance_max, 0));
printf(" Offset: %s%s\n",
offset_sign ? "+" : "-",
format_timespan(ts, sizeof(ts), offset, 0));
printf(" Delay: %s\n",
format_timespan(ts, sizeof(ts), delay, 0));
printf(" Jitter: %s\n",
format_timespan(ts, sizeof(ts), i->jitter, 0));
printf(" Packet count: %" PRIu64 "\n", i->packet_count);
if (!i->spike)
printf(" Frequency: %+.3fppm\n",
(double) i->freq / 0x10000);
}
static int map_server_address(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
char **p = (char **) userdata;
const void *d;
int family, r;
size_t sz;
assert(p);
r = sd_bus_message_enter_container(m, 'r', "iay");
if (r < 0)
return r;
r = sd_bus_message_read(m, "i", &family);
if (r < 0)
return r;
r = sd_bus_message_read_array(m, 'y', &d, &sz);
if (r < 0)
return r;
r = sd_bus_message_exit_container(m);
if (r < 0)
return r;
if (sz == 0 && family == AF_UNSPEC) {
*p = mfree(*p);
return 0;
}
if (!IN_SET(family, AF_INET, AF_INET6)) {
log_error("Unknown address family %i", family);
return -EINVAL;
}
if (sz != FAMILY_ADDRESS_SIZE(family)) {
log_error("Invalid address size");
return -EINVAL;
}
r = in_addr_to_string(family, d, p);
if (r < 0)
return r;
return 0;
}
static int map_ntp_message(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
NTPStatusInfo *p = userdata;
const void *d;
size_t sz;
int32_t b;
int r;
assert(p);
r = sd_bus_message_enter_container(m, 'r', "uuuuittayttttbtt");
if (r < 0)
return r;
r = sd_bus_message_read(m, "uuuuitt",
&p->leap, &p->version, &p->mode, &p->stratum, &p->precision,
&p->root_delay, &p->root_dispersion);
if (r < 0)
return r;
r = sd_bus_message_read_array(m, 'y', &d, &sz);
if (r < 0)
return r;
r = sd_bus_message_read(m, "ttttbtt",
&p->origin, &p->recv, &p->trans, &p->dest,
&b, &p->packet_count, &p->jitter);
if (r < 0)
return r;
r = sd_bus_message_exit_container(m);
if (r < 0)
return r;
if (sz != 4)
return -EINVAL;
memcpy(p->reference.str, d, sz);
p->spike = !!b;
return 0;
}
static int show_timesync_status_once(sd_bus *bus) {
static const struct bus_properties_map map_timesync[] = {
{ "ServerName", "s", NULL, offsetof(NTPStatusInfo, server_name) },
{ "ServerAddress", "(iay)", map_server_address, offsetof(NTPStatusInfo, server_address) },
{ "PollIntervalUSec", "t", NULL, offsetof(NTPStatusInfo, poll_interval) },
{ "PollIntervalMinUSec", "t", NULL, offsetof(NTPStatusInfo, poll_min) },
{ "PollIntervalMaxUSec", "t", NULL, offsetof(NTPStatusInfo, poll_max) },
{ "RootDistanceMaxUSec", "t", NULL, offsetof(NTPStatusInfo, root_distance_max) },
{ "NTPMessage", "(uuuuittayttttbtt)", map_ntp_message, 0 },
{ "Frequency", "x", NULL, offsetof(NTPStatusInfo, freq) },
{}
};
_cleanup_(ntp_status_info_clear) NTPStatusInfo info = {};
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
int r;
assert(bus);
r = bus_map_all_properties(bus,
"org.freedesktop.timesync1",
"/org/freedesktop/timesync1",
map_timesync,
BUS_MAP_BOOLEAN_AS_BOOL,
&error,
&m,
&info);
if (r < 0)
return log_error_errno(r, "Failed to query server: %s", bus_error_message(&error, r));
if (arg_monitor && !terminal_is_dumb())
fputs(ANSI_HOME_CLEAR, stdout);
print_ntp_status_info(&info);
return 0;
}
static int on_properties_changed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
const char *name;
int r;
assert(m);
r = sd_bus_message_read(m, "s", &name);
if (r < 0)
return log_error_errno(r, "Failed to read interface name: %m");
if (!streq_ptr(name, "org.freedesktop.timesync1.Manager"))
return 0;
return show_timesync_status_once(sd_bus_message_get_bus(m));
}
static int show_timesync_status(int argc, char **argv, void *userdata) {
_cleanup_(sd_event_unrefp) sd_event *event = NULL;
sd_bus *bus = userdata;
int r;
assert(bus);
r = show_timesync_status_once(bus);
if (r < 0)
return r;
if (!arg_monitor)
return 0;
r = sd_event_default(&event);
if (r < 0)
return log_error_errno(r, "Failed to get event loop: %m");
r = sd_bus_match_signal(bus,
NULL,
"org.freedesktop.timesync1",
"/org/freedesktop/timesync1",
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
on_properties_changed, NULL);
if (r < 0)
return log_error_errno(r, "Failed to request match for PropertiesChanged signal: %m");
r = sd_bus_attach_event(bus, event, SD_EVENT_PRIORITY_NORMAL);
if (r < 0)
return log_error_errno(r, "Failed to attach bus to event loop: %m");
r = sd_event_loop(event);
if (r < 0)
return log_error_errno(r, "Failed to run event loop: %m");
return 0;
}
#define property(name, fmt, ...) \
do { \
if (value) \
printf(fmt "\n", __VA_ARGS__); \
else \
printf("%s=" fmt "\n", name, __VA_ARGS__); \
} while (0)
static int print_timesync_property(const char *name, sd_bus_message *m, bool value, bool all) {
char type;
const char *contents;
int r;
assert(name);
assert(m);
r = sd_bus_message_peek_type(m, &type, &contents);
if (r < 0)
return r;
switch (type) {
case SD_BUS_TYPE_STRUCT:
if (streq(name, "NTPMessage")) {
_cleanup_(ntp_status_info_clear) NTPStatusInfo i = {};
char ts[FORMAT_TIMESPAN_MAX], stamp[FORMAT_TIMESTAMP_MAX];
r = map_ntp_message(NULL, NULL, m, NULL, &i);
if (r < 0)
return r;
if (i.packet_count == 0)
return 1;
if (!value) {
fputs(name, stdout);
fputc('=', stdout);
}
printf("{ Leap=%u, Version=%u, Mode=%u, Stratum=%u, Precision=%i,",
i.leap, i.version, i.mode, i.stratum, i.precision);
printf(" RootDelay=%s,",
format_timespan(ts, sizeof(ts), i.root_delay, 0));
printf(" RootDispersion=%s,",
format_timespan(ts, sizeof(ts), i.root_dispersion, 0));
if (i.stratum == 1)
printf(" Reference=%s,", i.reference.str);
else
printf(" Reference=%" PRIX32 ",", be32toh(i.reference.val));
printf(" OriginateTimestamp=%s,",
format_timestamp(stamp, sizeof(stamp), i.origin));
printf(" ReceiveTimestamp=%s,",
format_timestamp(stamp, sizeof(stamp), i.recv));
printf(" TransmitTimestamp=%s,",
format_timestamp(stamp, sizeof(stamp), i.trans));
printf(" DestinationTimestamp=%s,",
format_timestamp(stamp, sizeof(stamp), i.dest));
printf(" Ignored=%s PacketCount=%" PRIu64 ",",
yes_no(i.spike), i.packet_count);
printf(" Jitter=%s }\n",
format_timespan(ts, sizeof(ts), i.jitter, 0));
return 1;
} else if (streq(name, "ServerAddress")) {
_cleanup_free_ char *str = NULL;
r = map_server_address(NULL, NULL, m, NULL, &str);
if (r < 0)
return r;
if (arg_all || !isempty(str))
property(name, "%s", str);
return 1;
}
break;
}
return 0;
}
static int show_timesync(int argc, char **argv, void *userdata) {
sd_bus *bus = userdata;
int r;
assert(bus);
r = bus_print_all_properties(bus,
"org.freedesktop.timesync1",
"/org/freedesktop/timesync1",
print_timesync_property,
arg_property,
arg_value,
arg_all,
NULL);
if (r < 0)
return bus_log_parse_error(r);
return 0;
}
static int help(void) {
printf("%s [OPTIONS...] COMMAND ...\n\n"
"Query or change system time and date settings.\n\n"
@ -281,15 +688,24 @@ static int help(void) {
" --no-ask-password Do not prompt for password\n"
" -H --host=[USER@]HOST Operate on remote host\n"
" -M --machine=CONTAINER Operate on local container\n"
" --adjust-system-clock Adjust system clock when changing local RTC mode\n\n"
" --adjust-system-clock Adjust system clock when changing local RTC mode\n"
" --monitor Monitor status of systemd-timesyncd\n"
" -p --property=NAME Show only properties by this name\n"
" -a --all Show all properties, including empty ones\n"
" --value When showing properties, only print the value\n"
"\n"
"Commands:\n"
" status Show current time settings\n"
" set-time TIME Set system time\n"
" set-timezone ZONE Set system time zone\n"
" list-timezones Show known time zones\n"
" set-local-rtc BOOL Control whether RTC is in local time\n"
" set-ntp BOOL Enable or disable network time synchronization\n",
program_invocation_short_name);
" set-ntp BOOL Enable or disable network time synchronization\n"
"\n"
"systemd-timesyncd Commands:\n"
" timesync-status Show status of systemd-timesyncd\n"
" show-timesync Show properties of systemd-timesyncd\n"
, program_invocation_short_name);
return 0;
}
@ -304,7 +720,9 @@ static int parse_argv(int argc, char *argv[]) {
ARG_VERSION = 0x100,
ARG_NO_PAGER,
ARG_ADJUST_SYSTEM_CLOCK,
ARG_NO_ASK_PASSWORD
ARG_NO_ASK_PASSWORD,
ARG_MONITOR,
ARG_VALUE,
};
static const struct option options[] = {
@ -315,15 +733,19 @@ static int parse_argv(int argc, char *argv[]) {
{ "machine", required_argument, NULL, 'M' },
{ "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD },
{ "adjust-system-clock", no_argument, NULL, ARG_ADJUST_SYSTEM_CLOCK },
{ "monitor", no_argument, NULL, ARG_MONITOR },
{ "property", required_argument, NULL, 'p' },
{ "all", no_argument, NULL, 'a' },
{ "value", no_argument, NULL, ARG_VALUE },
{}
};
int c;
int c, r;
assert(argc >= 0);
assert(argv);
while ((c = getopt_long(argc, argv, "hH:M:", options, NULL)) >= 0)
while ((c = getopt_long(argc, argv, "hH:M:p:a", options, NULL)) >= 0)
switch (c) {
@ -355,6 +777,30 @@ static int parse_argv(int argc, char *argv[]) {
arg_no_pager = true;
break;
case ARG_MONITOR:
arg_monitor = true;
break;
case 'p': {
r = strv_extend(&arg_property, optarg);
if (r < 0)
return log_oom();
/* If the user asked for a particular
* property, show it to him, even if it is
* empty. */
arg_all = true;
break;
}
case 'a':
arg_all = true;
break;
case ARG_VALUE:
arg_value = true;
break;
case '?':
return -EINVAL;
@ -368,13 +814,15 @@ static int parse_argv(int argc, char *argv[]) {
static int timedatectl_main(sd_bus *bus, int argc, char *argv[]) {
static const Verb verbs[] = {
{ "status", VERB_ANY, 1, VERB_DEFAULT, show_status },
{ "set-time", 2, 2, 0, set_time },
{ "set-timezone", 2, 2, 0, set_timezone },
{ "list-timezones", VERB_ANY, 1, 0, list_timezones },
{ "set-local-rtc", 2, 2, 0, set_local_rtc },
{ "set-ntp", 2, 2, 0, set_ntp },
{ "help", VERB_ANY, VERB_ANY, 0, verb_help }, /* Not documented, but supported since it is created. */
{ "status", VERB_ANY, 1, VERB_DEFAULT, show_status },
{ "set-time", 2, 2, 0, set_time },
{ "set-timezone", 2, 2, 0, set_timezone },
{ "list-timezones", VERB_ANY, 1, 0, list_timezones },
{ "set-local-rtc", 2, 2, 0, set_local_rtc },
{ "set-ntp", 2, 2, 0, set_ntp },
{ "timesync-status", VERB_ANY, 1, 0, show_timesync_status },
{ "show-timesync", VERB_ANY, 1, 0, show_timesync },
{ "help", VERB_ANY, VERB_ANY, 0, verb_help }, /* Not documented, but supported since it is created. */
{}
};

7
src/timesync/meson.build
View File

@ -4,10 +4,13 @@
systemd_timesyncd_sources = files('''
timesyncd.c
timesyncd-bus.c
timesyncd-bus.h
timesyncd-conf.c
timesyncd-conf.h
timesyncd-manager.c
timesyncd-manager.h
timesyncd-ntp-message.h
timesyncd-server.c
timesyncd-server.h
'''.split())
@ -27,6 +30,10 @@ if conf.get('ENABLE_TIMESYNCD') == 1
configuration : substs)
install_data(timesyncd_conf,
install_dir : pkgsysconfdir)
install_data('org.freedesktop.timesync1.conf',
install_dir : dbuspolicydir)
install_data('org.freedesktop.timesync1.service',
install_dir : dbussystemservicedir)
endif
############################################################

42
src/timesync/org.freedesktop.timesync1.conf Normal file
View File

@ -0,0 +1,42 @@
<?xml version="1.0"?> <!--*-nxml-*-->
<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
<!--
This file is part of systemd.
systemd is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
-->
<busconfig>
<policy user="systemd-timesync">
<allow own="org.freedesktop.timesync1"/>
<allow send_destination="org.freedesktop.timesync1"/>
<allow receive_sender="org.freedesktop.timesync1"/>
</policy>
<policy context="default">
<deny send_destination="org.freedesktop.timesync1"/>
<allow send_destination="org.freedesktop.timesync1"
send_interface="org.freedesktop.DBus.Introspectable"/>
<allow send_destination="org.freedesktop.timesync1"
send_interface="org.freedesktop.DBus.Peer"/>
<allow send_destination="org.freedesktop.timesync1"
send_interface="org.freedesktop.DBus.Properties"
send_member="Get"/>
<allow send_destination="org.freedesktop.timesync1"
send_interface="org.freedesktop.DBus.Properties"
send_member="GetAll"/>
<allow receive_sender="org.freedesktop.timesync1"/>
</policy>
</busconfig>

14
src/timesync/org.freedesktop.timesync1.service Normal file
View File

@ -0,0 +1,14 @@
# SPDX-License-Identifier: LGPL-2.1+
#
# This file is part of systemd.
#
# systemd is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation; either version 2.1 of the License, or
# (at your option) any later version.
[D-BUS Service]
Name=org.freedesktop.timesync1
Exec=/bin/false
User=root
SystemdService=dbus-org.freedesktop.timesync1.service

291
src/timesync/timesyncd-bus.c Normal file
View File

@ -0,0 +1,291 @@
/* SPDX-License-Identifier: LGPL-2.1+ */
#include "sd-bus.h"
#include "alloc-util.h"
#include "bus-internal.h"
#include "bus-protocol.h"
#include "bus-util.h"
#include "in-addr-util.h"
#include "log.h"
#include "macro.h"
#include "time-util.h"
#include "timesyncd-bus.h"
static int property_get_servers(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
ServerName *p, **s = userdata;
int r;
assert(s);
assert(bus);
assert(reply);
r = sd_bus_message_open_container(reply, 'a', "s");
if (r < 0)
return r;
LIST_FOREACH(names, p, *s) {
r = sd_bus_message_append(reply, "s", p->string);
if (r < 0)
return r;
}
return sd_bus_message_close_container(reply);
}
static int property_get_current_server_name(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
ServerName **s = userdata;
assert(s);
assert(bus);
assert(reply);
return sd_bus_message_append(reply, "s", *s ? (*s)->string : "");
}
static int property_get_current_server_address(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
ServerAddress *a;
int r;
assert(bus);
assert(reply);
assert(userdata);
a = *(ServerAddress **) userdata;
if (!a)
return sd_bus_message_append(reply, "(iay)", AF_UNSPEC, 0);
r = sd_bus_message_open_container(reply, 'r', "iay");
if (r < 0)
return r;
r = sd_bus_message_append(reply, "i", a->sockaddr.sa.sa_family);
if (r < 0)
return r;
r = sd_bus_message_append_array(reply, 'y', &a->sockaddr.in.sin_addr, FAMILY_ADDRESS_SIZE(a->sockaddr.sa.sa_family));
if (r < 0)
return r;
return sd_bus_message_close_container(reply);
}
static usec_t ntp_ts_short_to_usec(const struct ntp_ts_short *ts) {
return be16toh(ts->sec) * USEC_PER_SEC + (be16toh(ts->frac) * USEC_PER_SEC) / (usec_t) 0x10000ULL;
}
static usec_t ntp_ts_to_usec(const struct ntp_ts *ts) {
return (be32toh(ts->sec) - OFFSET_1900_1970) * USEC_PER_SEC + (be32toh(ts->frac) * USEC_PER_SEC) / (usec_t) 0x100000000ULL;
}
static int property_get_ntp_message(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
Manager *m = userdata;
int r;
assert(m);
assert(reply);
r = sd_bus_message_open_container(reply, 'r', "uuuuittayttttbtt");
if (r < 0)
return r;
r = sd_bus_message_append(reply, "uuuuitt",
NTP_FIELD_LEAP(m->ntpmsg.field),
NTP_FIELD_VERSION(m->ntpmsg.field),
NTP_FIELD_MODE(m->ntpmsg.field),
m->ntpmsg.stratum,
m->ntpmsg.precision,
ntp_ts_short_to_usec(&m->ntpmsg.root_delay),
ntp_ts_short_to_usec(&m->ntpmsg.root_dispersion));
if (r < 0)
return r;
r = sd_bus_message_append_array(reply, 'y', m->ntpmsg.refid, 4);
if (r < 0)
return r;
r = sd_bus_message_append(reply, "ttttbtt",
timespec_load(&m->origin_time),
ntp_ts_to_usec(&m->ntpmsg.recv_time),
ntp_ts_to_usec(&m->ntpmsg.trans_time),
timespec_load(&m->dest_time),
m->spike,
m->packet_count,
(usec_t) (m->samples_jitter * USEC_PER_SEC));
if (r < 0)
return r;
return sd_bus_message_close_container(reply);
}
static const sd_bus_vtable manager_vtable[] = {
SD_BUS_VTABLE_START(0),
SD_BUS_PROPERTY("LinkNTPServers", "as", property_get_servers, offsetof(Manager, link_servers), 0),
SD_BUS_PROPERTY("SystemNTPServers", "as", property_get_servers, offsetof(Manager, system_servers), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("FallbackNTPServers", "as", property_get_servers, offsetof(Manager, fallback_servers), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("ServerName", "s", property_get_current_server_name, offsetof(Manager, current_server_name), 0),
SD_BUS_PROPERTY("ServerAddress", "(iay)", property_get_current_server_address, offsetof(Manager, current_server_address), 0),
SD_BUS_PROPERTY("RootDistanceMaxUSec", "t", bus_property_get_usec, offsetof(Manager, max_root_distance_usec), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("PollIntervalMinUSec", "t", bus_property_get_usec, offsetof(Manager, poll_interval_min_usec), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("PollIntervalMaxUSec", "t", bus_property_get_usec, offsetof(Manager, poll_interval_max_usec), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("PollIntervalUSec", "t", bus_property_get_usec, offsetof(Manager, poll_interval_usec), 0),
SD_BUS_PROPERTY("NTPMessage", "(uuuuittayttttbtt)", property_get_ntp_message, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("Frequency", "x", NULL, offsetof(Manager, drift_freq), 0),
SD_BUS_VTABLE_END
};
static int reload_dbus_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
const sd_bus_error *e;
int r;
assert(m);
e = sd_bus_message_get_error(m);
if (e) {
log_error_errno(sd_bus_error_get_errno(e), "Failed to reload DBus configuration: %s", e->message);
return 1;
}
/* Here, use the default request name handler to avoid an infinite loop of reloading and requesting. */
r = sd_bus_request_name_async(sd_bus_message_get_bus(m), NULL, "org.freedesktop.timesync1", 0, NULL, NULL);
if (r < 0)
log_error_errno(r, "Failed to request name: %m");
return 1;
}
static int request_name_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
uint32_t ret;
int r;
assert(m);
if (sd_bus_message_is_method_error(m, NULL)) {
const sd_bus_error *e = sd_bus_message_get_error(m);
if (!sd_bus_error_has_name(e, SD_BUS_ERROR_ACCESS_DENIED)) {
log_debug_errno(sd_bus_error_get_errno(e),
"Unable to request name, failing connection: %s",
e->message);
bus_enter_closing(sd_bus_message_get_bus(m));
return 1;
}
log_debug_errno(sd_bus_error_get_errno(e),
"Unable to request name, retry after reloading DBus configuration: %s",
e->message);
/* If systemd-timesyncd.service enables DynamicUser= and dbus.service
* started before the dynamic user is realized, then the DBus policy
* about timesyncd has not been enabled yet. So, let's try to reload
* DBus configuration, and after that request name again. Note that it
* seems that no privileges are necessary to call the following method. */
r = sd_bus_call_method_async(
sd_bus_message_get_bus(m),
NULL,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"ReloadConfig",
reload_dbus_handler,
NULL, NULL);
if (r < 0) {
log_error_errno(r, "Failed to reload DBus configuration: %m");
bus_enter_closing(sd_bus_message_get_bus(m));
}
return 1;
}
r = sd_bus_message_read(m, "u", &ret);
if (r < 0)
return r;
switch (ret) {
case BUS_NAME_ALREADY_OWNER:
log_debug("Already owner of requested service name, ignoring.");
return 1;
case BUS_NAME_IN_QUEUE:
log_debug("In queue for requested service name.");
return 1;
case BUS_NAME_PRIMARY_OWNER:
log_debug("Successfully acquired requested service name.");
return 1;
case BUS_NAME_EXISTS:
log_debug("Requested service name already owned, failing connection.");
bus_enter_closing(sd_bus_message_get_bus(m));
return 1;
}
log_debug("Unexpected response from RequestName(), failing connection.");
bus_enter_closing(sd_bus_message_get_bus(m));
return 1;
}
int manager_connect_bus(Manager *m) {
int r;
assert(m);
if (m->bus)
return 0;
r = bus_open_system_watch_bind_with_description(&m->bus, "bus-api-timesync");
if (r < 0)
return log_error_errno(r, "Failed to connect to bus: %m");
r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/timesync1", "org.freedesktop.timesync1.Manager", manager_vtable, m);
if (r < 0)
return log_error_errno(r, "Failed to add manager object vtable: %m");
r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.timesync1", 0, request_name_handler, NULL);
if (r < 0)
return log_error_errno(r, "Failed to request name: %m");
r = sd_bus_attach_event(m->bus, m->event, 0);
if (r < 0)
return log_error_errno(r, "Failed to attach bus to event loop: %m");
return 0;
}

6
src/timesync/timesyncd-bus.h Normal file
View File

@ -0,0 +1,6 @@
/* SPDX-License-Identifier: LGPL-2.1+ */
#pragma once
#include "timesyncd-manager.h"
int manager_connect_bus(Manager *m);

62
src/timesync/timesyncd-manager.c
View File

@ -28,7 +28,6 @@
#include "network-util.h"
#include "ratelimit.h"
#include "socket-util.h"
#include "sparse-endian.h"
#include "string-util.h"
#include "strv.h"
#include "time-util.h"
@ -50,59 +49,18 @@
*/
#define NTP_MAX_ADJUST 0.4
/* NTP protocol, packet header */
#define NTP_LEAP_PLUSSEC 1
#define NTP_LEAP_MINUSSEC 2
#define NTP_LEAP_NOTINSYNC 3
#define NTP_MODE_CLIENT 3
#define NTP_MODE_SERVER 4
#define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
#define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
#define NTP_FIELD_MODE(f) ((f) & 7)
#define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
/* Default of maximum acceptable root distance in microseconds. */
#define NTP_MAX_ROOT_DISTANCE (5 * USEC_PER_SEC)
/* Maximum number of missed replies before selecting another source. */
#define NTP_MAX_MISSED_REPLIES 2
/*
* "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
* in seconds relative to 0h on 1 January 1900."
*/
#define OFFSET_1900_1970 UINT64_C(2208988800)
#define RETRY_USEC (30*USEC_PER_SEC)
#define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
#define RATELIMIT_BURST 10
#define TIMEOUT_USEC (10*USEC_PER_SEC)
struct ntp_ts {
be32_t sec;
be32_t frac;
} _packed_;
struct ntp_ts_short {
be16_t sec;
be16_t frac;
} _packed_;
struct ntp_msg {
uint8_t field;
uint8_t stratum;
int8_t poll;
int8_t precision;
struct ntp_ts_short root_delay;
struct ntp_ts_short root_dispersion;
char refid[4];
struct ntp_ts reference_time;
struct ntp_ts origin_time;
struct ntp_ts recv_time;
struct ntp_ts trans_time;
} _packed_;
static int manager_arm_timer(Manager *m, usec_t next);
static int manager_clock_watch_setup(Manager *m);
static int manager_listen_setup(Manager *m);
@ -357,18 +315,18 @@ static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
(void) touch("/var/lib/systemd/timesync/clock");
(void) touch("/run/systemd/timesync/synchronized");
m->drift_ppm = tmx.freq / 65536;
m->drift_freq = tmx.freq;
log_debug(" status : %04i %s\n"
" time now : %"PRI_TIME".%03"PRI_USEC"\n"
" constant : %"PRI_TIMEX"\n"
" offset : %+.3f sec\n"
" freq offset : %+"PRI_TIMEX" (%i ppm)\n",
" freq offset : %+"PRI_TIMEX" (%+"PRI_TIMEX" ppm)\n",
tmx.status, tmx.status & STA_UNSYNC ? "unsync" : "sync",
tmx.time.tv_sec, tmx.time.tv_usec / NSEC_PER_MSEC,
tmx.constant,
(double)tmx.offset / NSEC_PER_SEC,
tmx.freq, m->drift_ppm);
tmx.freq, tmx.freq / 65536);
return 0;
}
@ -652,10 +610,18 @@ static int manager_receive_response(sd_event_source *source, int fd, uint32_t re
log_error_errno(r, "Failed to call clock_adjtime(): %m");
}
log_debug("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
/* Save NTP response */
m->ntpmsg = ntpmsg;
m->origin_time = m->trans_time;
m->dest_time = *recv_time;
m->spike = spike;
log_debug("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+"PRI_TIMEX"ppm%s",
m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_freq / 65536,
spike ? " (ignored)" : "");
(void) sd_bus_emit_properties_changed(m->bus, "/org/freedesktop/timesync1", "org.freedesktop.timesync1.Manager", "NTPMessage", NULL);
if (!m->good) {
_cleanup_free_ char *pretty = NULL;
@ -986,6 +952,8 @@ void manager_free(Manager *m) {
sd_resolve_unref(m->resolve);
sd_event_unref(m->event);
sd_bus_unref(m->bus);
free(m);
}

12
src/timesync/timesyncd-manager.h
View File

@ -7,6 +7,9 @@
Copyright 2014 Kay Sievers, Lennart Poettering
***/
#include <sys/timex.h>
#include "sd-bus.h"
#include "sd-event.h"
#include "sd-network.h"
#include "sd-resolve.h"
@ -14,6 +17,7 @@
#include "list.h"
#include "ratelimit.h"
#include "time-util.h"
#include "timesyncd-ntp-message.h"
typedef struct Manager Manager;
@ -27,6 +31,7 @@ typedef struct Manager Manager;
#define NTP_POLL_INTERVAL_MAX_USEC (2048 * USEC_PER_SEC)
struct Manager {
sd_bus *bus;
sd_event *event;
sd_resolve *resolve;
@ -79,7 +84,7 @@ struct Manager {
/* last change */
bool jumped;
bool sync;
int drift_ppm;
long drift_freq;
/* watch for time changes */
sd_event_source *event_clock_watch;
@ -90,6 +95,11 @@ struct Manager {
/* RTC runs in local time, leave it alone */
bool rtc_local_time;
/* NTP response */
struct ntp_msg ntpmsg;
struct timespec origin_time, dest_time;
bool spike;
};
int manager_new(Manager **ret);

45
src/timesync/timesyncd-ntp-message.h Normal file
View File

@ -0,0 +1,45 @@
/* SPDX-License-Identifier: LGPL-2.1+ */
#pragma once
#include "sparse-endian.h"
/* NTP protocol, packet header */
#define NTP_LEAP_PLUSSEC 1
#define NTP_LEAP_MINUSSEC 2
#define NTP_LEAP_NOTINSYNC 3
#define NTP_MODE_CLIENT 3
#define NTP_MODE_SERVER 4
#define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
#define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
#define NTP_FIELD_MODE(f) ((f) & 7)
#define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
/*
* "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
* in seconds relative to 0h on 1 January 1900."
*/
#define OFFSET_1900_1970 UINT64_C(2208988800)
struct ntp_ts {
be32_t sec;
be32_t frac;
} _packed_;
struct ntp_ts_short {
be16_t sec;
be16_t frac;
} _packed_;
struct ntp_msg {
uint8_t field;
uint8_t stratum;
int8_t poll;
int8_t precision;
struct ntp_ts_short root_delay;
struct ntp_ts_short root_dispersion;
char refid[4];
struct ntp_ts reference_time;
struct ntp_ts origin_time;
struct ntp_ts recv_time;
struct ntp_ts trans_time;
} _packed_;

7
src/timesync/timesyncd.c
View File

@ -16,6 +16,7 @@
#include "network-util.h"
#include "process-util.h"
#include "signal-util.h"
#include "timesyncd-bus.h"
#include "timesyncd-conf.h"
#include "timesyncd-manager.h"
#include "user-util.h"
@ -133,6 +134,12 @@ int main(int argc, char *argv[]) {
goto finish;
}
r = manager_connect_bus(m);
if (r < 0) {
log_error_errno(r, "Could not connect to bus: %m");
goto finish;
}
if (clock_is_localtime(NULL) > 0) {
log_info("The system is configured to read the RTC time in the local time zone. "
"This mode cannot be fully supported. All system time to RTC updates are disabled.");

1
units/systemd-timesyncd.service.in
View File

@ -45,3 +45,4 @@ StateDirectory=systemd/timesync
[Install]
WantedBy=sysinit.target
Alias=dbus-org.freedesktop.timesync1.service