shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-12-22 17:35:35 +03:00
Code

Merge pull request #29995 from keszybz/voidify-timestamp-getters

Browse Source 
Rename and voidify timestamp getters
This commit is contained in:
Lennart Poettering 2023-11-13 14:41:42 +01:00 committed by GitHub
commit 1a292659f2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
38 changed files with 59 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
meson.build
View File

@ -1230,7 +1230,7 @@ libcryptsetup = get_option('libcryptsetup')
libcryptsetup_plugins = get_option('libcryptsetup-plugins')
if libcryptsetup_plugins.enabled()
if libcryptsetup.disabled()
error('libcryptsetup-plugins can not be requested without libcryptsetup')
error('libcryptsetup-plugins cannot be requested without libcryptsetup')
endif
libcryptsetup = libcryptsetup_plugins
endif

4
src/basic/time-util.c
View File

@ -64,7 +64,7 @@ nsec_t now_nsec(clockid_t clock_id) {
return timespec_load_nsec(&ts);
}
dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
dual_timestamp* dual_timestamp_now(dual_timestamp *ts) {
assert(ts);
ts->realtime = now(CLOCK_REALTIME);
@ -73,7 +73,7 @@ dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
return ts;
}
triple_timestamp* triple_timestamp_get(triple_timestamp *ts) {
triple_timestamp* triple_timestamp_now(triple_timestamp *ts) {
assert(ts);
ts->realtime = now(CLOCK_REALTIME);

4
src/basic/time-util.h
View File

@ -79,12 +79,12 @@ nsec_t now_nsec(clockid_t clock);
usec_t map_clock_usec(usec_t from, clockid_t from_clock, clockid_t to_clock);
dual_timestamp* dual_timestamp_get(dual_timestamp *ts);
dual_timestamp* dual_timestamp_now(dual_timestamp *ts);
dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u);
dual_timestamp* dual_timestamp_from_monotonic(dual_timestamp *ts, usec_t u);
dual_timestamp* dual_timestamp_from_boottime(dual_timestamp *ts, usec_t u);
triple_timestamp* triple_timestamp_get(triple_timestamp *ts);
triple_timestamp* triple_timestamp_now(triple_timestamp *ts);
triple_timestamp* triple_timestamp_from_realtime(triple_timestamp *ts, usec_t u);
triple_timestamp* triple_timestamp_from_boottime(triple_timestamp *ts, usec_t u);

4
src/core/execute.c
View File

@ -1797,7 +1797,7 @@ void exec_status_start(ExecStatus *s, pid_t pid) {
.pid = pid,
};
dual_timestamp_get(&s->start_timestamp);
dual_timestamp_now(&s->start_timestamp);
}
void exec_status_exit(ExecStatus *s, const ExecContext *context, pid_t pid, int code, int status) {
@ -1808,7 +1808,7 @@ void exec_status_exit(ExecStatus *s, const ExecContext *context, pid_t pid, int
.pid = pid,
};
dual_timestamp_get(&s->exit_timestamp);
dual_timestamp_now(&s->exit_timestamp);
s->code = code;
s->status = status;

6
src/core/main.c
View File

@ -2687,7 +2687,7 @@ static int initialize_security(
assert(security_finish_timestamp);
assert(ret_error_message);
dual_timestamp_get(security_start_timestamp);
dual_timestamp_now(security_start_timestamp);
r = mac_selinux_setup(loaded_policy);
if (r < 0) {
@ -2713,7 +2713,7 @@ static int initialize_security(
return r;
}
dual_timestamp_get(security_finish_timestamp);
dual_timestamp_now(security_finish_timestamp);
return 0;
}
@ -2819,7 +2819,7 @@ int main(int argc, char *argv[]) {
/* Take timestamps early on */
dual_timestamp_from_monotonic(&kernel_timestamp, 0);
dual_timestamp_get(&userspace_timestamp);
dual_timestamp_now(&userspace_timestamp);
/* Figure out whether we need to do initialize the system, or if we already did that because we are
* reexecuting. */

12
src/core/manager.c
View File

@ -1948,7 +1948,7 @@ static void manager_ready(Manager *m) {
Manager* manager_reloading_start(Manager *m) {
m->n_reloading++;
dual_timestamp_get(m->timestamps + MANAGER_TIMESTAMP_UNITS_LOAD);
dual_timestamp_now(m->timestamps + MANAGER_TIMESTAMP_UNITS_LOAD);
return m;
}
@ -1972,11 +1972,11 @@ int manager_startup(Manager *m, FILE *serialization, FDSet *fds, const char *roo
if (r < 0)
return r;
dual_timestamp_get(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_GENERATORS_START));
dual_timestamp_now(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_GENERATORS_START));
r = manager_run_environment_generators(m);
if (r >= 0)
r = manager_run_generators(m);
dual_timestamp_get(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_GENERATORS_FINISH));
dual_timestamp_now(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_GENERATORS_FINISH));
if (r < 0)
return r;
@ -1998,10 +1998,10 @@ int manager_startup(Manager *m, FILE *serialization, FDSet *fds, const char *roo
reloading = manager_reloading_start(m);
/* First, enumerate what we can from all config files */
dual_timestamp_get(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_UNITS_LOAD_START));
dual_timestamp_now(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_UNITS_LOAD_START));
manager_enumerate_perpetual(m);
manager_enumerate(m);
dual_timestamp_get(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_UNITS_LOAD_FINISH));
dual_timestamp_now(m->timestamps + manager_timestamp_initrd_mangle(MANAGER_TIMESTAMP_UNITS_LOAD_FINISH));
/* Second, deserialize if there is something to deserialize */
if (serialization) {
@ -3891,7 +3891,7 @@ void manager_check_finished(Manager *m) {
/* This is no longer the first boot */
manager_set_first_boot(m, false);
dual_timestamp_get(m->timestamps + MANAGER_TIMESTAMP_FINISH);
dual_timestamp_now(m->timestamps + MANAGER_TIMESTAMP_FINISH);
manager_notify_finished(m);

2
src/core/service.c
View File

@ -378,7 +378,7 @@ static void service_extend_timeout(Service *s, usec_t extend_timeout_usec) {
static void service_reset_watchdog(Service *s) {
assert(s);
dual_timestamp_get(&s->watchdog_timestamp);
dual_timestamp_now(&s->watchdog_timestamp);
service_start_watchdog(s);
}

4
src/core/timer.c
View File

@ -382,7 +382,7 @@ static void timer_enter_waiting(Timer *t, bool time_change) {
goto fail;
}
triple_timestamp_get(&ts);
triple_timestamp_now(&ts);
t->next_elapse_monotonic_or_boottime = t->next_elapse_realtime = 0;
LIST_FOREACH(value, v, t->values) {
@ -618,7 +618,7 @@ static void timer_enter_running(Timer *t) {
goto fail;
}
dual_timestamp_get(&t->last_trigger);
dual_timestamp_now(&t->last_trigger);
ACTIVATION_DETAILS_TIMER(details)->last_trigger = t->last_trigger;
job_set_activation_details(job, details);

2
src/core/unit-serialize.c
View File

@ -526,7 +526,7 @@ int unit_deserialize_state(Unit *u, FILE *f, FDSet *fds) {
* reboots. */
if (!dual_timestamp_is_set(&u->state_change_timestamp))
dual_timestamp_get(&u->state_change_timestamp);
dual_timestamp_now(&u->state_change_timestamp);
/* Let's make sure that everything that is deserialized also gets any potential new cgroup settings
* applied after we are done. For that we invalidate anything already realized, so that we can

11
src/core/unit.c
View File

@ -1779,7 +1779,7 @@ static bool unit_test_condition(Unit *u) {
assert(u);
dual_timestamp_get(&u->condition_timestamp);
dual_timestamp_now(&u->condition_timestamp);
r = manager_get_effective_environment(u->manager, &env);
if (r < 0) {
@ -1803,7 +1803,7 @@ static bool unit_test_assert(Unit *u) {
assert(u);
dual_timestamp_get(&u->assert_timestamp);
dual_timestamp_now(&u->assert_timestamp);
r = manager_get_effective_environment(u->manager, &env);
if (r < 0) {
@ -2740,7 +2740,7 @@ void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_su
/* Update timestamps for state changes */
if (!MANAGER_IS_RELOADING(m)) {
dual_timestamp_get(&u->state_change_timestamp);
dual_timestamp_now(&u->state_change_timestamp);
if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
u->inactive_exit_timestamp = u->state_change_timestamp;
@ -5079,10 +5079,7 @@ bool unit_type_supported(UnitType t) {
static int8_t cache[_UNIT_TYPE_MAX] = {}; /* -1: disabled, 1: enabled: 0: don't know */
int r;
if (_unlikely_(t < 0))
return false;
if (_unlikely_(t >= _UNIT_TYPE_MAX))
return false;
assert(t >= 0 && t < _UNIT_TYPE_MAX);
if (cache[t] == 0) {
char *e;

6
src/cryptsetup/cryptsetup-tokens/cryptsetup-token-systemd-fido2.c
View File

@ -45,7 +45,7 @@ _public_ int cryptsetup_token_open_pin(
r = crypt_normalize_pin(pin, pin_size, &pin_string);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Can not normalize PIN: %m");
return crypt_log_debug_errno(cd, r, "Cannot normalize PIN: %m");
return acquire_luks2_key(cd, json, (const char *)usrptr, pin_string, password, password_len);
}
@ -104,11 +104,11 @@ _public_ void cryptsetup_token_dump(
r = crypt_dump_buffer_to_hex_string(cid, cid_size, &cid_str);
if (r < 0)
return (void) crypt_log_debug_errno(cd, r, "Can not dump " TOKEN_NAME " content: %m");
return (void) crypt_log_debug_errno(cd, r, "Cannot dump " TOKEN_NAME " content: %m");
r = crypt_dump_buffer_to_hex_string(salt, salt_size, &salt_str);
if (r < 0)
return (void) crypt_log_debug_errno(cd, r, "Can not dump " TOKEN_NAME " content: %m");
return (void) crypt_log_debug_errno(cd, r, "Cannot dump " TOKEN_NAME " content: %m");
if (required & FIDO2ENROLL_PIN)
client_pin_req_str = "true";

2
src/cryptsetup/cryptsetup-tokens/cryptsetup-token-systemd-pkcs11.c
View File

@ -95,7 +95,7 @@ _public_ void cryptsetup_token_dump(
r = crypt_dump_buffer_to_hex_string(pkcs11_key, pkcs11_key_size, &key_str);
if (r < 0)
return (void) crypt_log_debug_errno(cd, r, "Can not dump " TOKEN_NAME " content: %m");
return (void) crypt_log_debug_errno(cd, r, "Cannot dump " TOKEN_NAME " content: %m");
crypt_log(cd, "\tpkcs11-uri: %s\n", pkcs11_uri);
crypt_log(cd, "\tpkcs11-key: %s\n", key_str);

8
src/cryptsetup/cryptsetup-tokens/cryptsetup-token-systemd-tpm2.c
View File

@ -68,7 +68,7 @@ _public_ int cryptsetup_token_open_pin(
r = crypt_normalize_pin(pin, pin_size, &pin_string);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Can not normalize PIN: %m");
return crypt_log_debug_errno(cd, r, "Cannot normalize PIN: %m");
if (usrptr)
params = *(systemd_tpm2_plugin_params *)usrptr;
@ -222,15 +222,15 @@ _public_ void cryptsetup_token_dump(
r = crypt_dump_buffer_to_hex_string(blob, blob_size, &blob_str);
if (r < 0)
return (void) crypt_log_debug_errno(cd, r, "Can not dump " TOKEN_NAME " content: %m");
return (void) crypt_log_debug_errno(cd, r, "Cannot dump " TOKEN_NAME " content: %m");
r = crypt_dump_buffer_to_hex_string(pubkey, pubkey_size, &pubkey_str);
if (r < 0)
return (void) crypt_log_debug_errno(cd, r, "Can not dump " TOKEN_NAME " content: %m");
return (void) crypt_log_debug_errno(cd, r, "Cannot dump " TOKEN_NAME " content: %m");
r = crypt_dump_buffer_to_hex_string(policy_hash, policy_hash_size, &policy_hash_str);
if (r < 0)
return (void) crypt_log_debug_errno(cd, r, "Can not dump " TOKEN_NAME " content: %m");
return (void) crypt_log_debug_errno(cd, r, "Cannot dump " TOKEN_NAME " content: %m");
crypt_log(cd, "\ttpm2-hash-pcrs: %s\n", strna(hash_pcrs_str));
crypt_log(cd, "\ttpm2-pcr-bank: %s\n", strna(tpm2_hash_alg_to_string(pcr_bank)));

2
src/cryptsetup/cryptsetup-tokens/luks2-pkcs11.c
View File

@ -217,7 +217,7 @@ int acquire_luks2_key(
base64_encoded_size = base64mem(decrypted_key, decrypted_key_size, &base64_encoded);
if (base64_encoded_size < 0)
return crypt_log_error_errno(cd, (int) base64_encoded_size, "Can not base64 encode key: %m");
return crypt_log_error_errno(cd, (int) base64_encoded_size, "Cannot base64 encode key: %m");
*ret_password = TAKE_PTR(base64_encoded);
*ret_password_size = base64_encoded_size;

2
src/libsystemd-network/icmp6-util-unix.c
View File

@ -44,7 +44,7 @@ int icmp6_receive(
assert_se(read (fd, iov_base, iov_len) == (ssize_t) iov_len);
if (ret_timestamp)
triple_timestamp_get(ret_timestamp);
triple_timestamp_now(ret_timestamp);
if (ret_sender)
*ret_sender = dummy_link_local;

2
src/libsystemd-network/icmp6-util.c
View File

@ -214,7 +214,7 @@ int icmp6_receive(
if (triple_timestamp_is_set(&t))
*ret_timestamp = t;
else
triple_timestamp_get(ret_timestamp);
triple_timestamp_now(ret_timestamp);
}
if (ret_sender)

2
src/libsystemd-network/sd-dhcp-lease.c
View File

@ -39,7 +39,7 @@ void dhcp_lease_set_timestamp(sd_dhcp_lease *lease, const triple_timestamp *time
if (timestamp && triple_timestamp_is_set(timestamp))
lease->timestamp = *timestamp;
else
triple_timestamp_get(&lease->timestamp);
triple_timestamp_now(&lease->timestamp);
}
int sd_dhcp_lease_get_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret) {

2
src/libsystemd-network/sd-dhcp-server.c
View File

@ -903,7 +903,7 @@ static void request_set_timestamp(DHCPRequest *req, const triple_timestamp *time
if (timestamp && triple_timestamp_is_set(timestamp))
req->timestamp = *timestamp;
else
triple_timestamp_get(&req->timestamp);
triple_timestamp_now(&req->timestamp);
}
static int request_get_lifetime_timestamp(DHCPRequest *req, clockid_t clock, usec_t *ret) {

2
src/libsystemd-network/sd-dhcp6-lease.c
View File

@ -20,7 +20,7 @@ static void dhcp6_lease_set_timestamp(sd_dhcp6_lease *lease, const triple_timest
if (timestamp && triple_timestamp_is_set(timestamp))
lease->timestamp = *timestamp;
else
triple_timestamp_get(&lease->timestamp);
triple_timestamp_now(&lease->timestamp);
}
int sd_dhcp6_lease_get_timestamp(sd_dhcp6_lease *lease, clockid_t clock, uint64_t *ret) {

2
src/libsystemd-network/sd-lldp-rx.c
View File

@ -229,7 +229,7 @@ static int lldp_rx_receive_datagram(sd_event_source *s, int fd, uint32_t revents
if (ioctl(fd, SIOCGSTAMPNS, &ts) >= 0)
triple_timestamp_from_realtime(&n->timestamp, timespec_load(&ts));
else
triple_timestamp_get(&n->timestamp);
triple_timestamp_now(&n->timestamp);
(void) lldp_rx_handle_datagram(lldp_rx, n);
return 0;

2
src/libsystemd/sd-event/sd-event.c
View File

@ -4612,7 +4612,7 @@ static int process_epoll(sd_event *e, usec_t timeout, int64_t threshold, int64_t
/* Set timestamp only when this is called first time. */
if (threshold == INT64_MAX)
triple_timestamp_get(&e->timestamp);
triple_timestamp_now(&e->timestamp);
for (size_t i = 0; i < m; i++) {

2
src/libsystemd/sd-journal/journal-file.c
View File

@ -2530,7 +2530,7 @@ int journal_file_append_entry(
"Invalid monotomic timestamp %" PRIu64 ", refusing entry.",
ts->monotonic);
} else {
dual_timestamp_get(&_ts);
dual_timestamp_now(&_ts);
ts = &_ts;
}

2
src/libsystemd/sd-journal/test-journal-append.c
View File

@ -27,7 +27,7 @@ static int journal_append_message(JournalFile *mj, const char *message) {
assert(mj);
assert(message);
dual_timestamp_get(&ts);
dual_timestamp_now(&ts);
iovec = IOVEC_MAKE_STRING(message);
return journal_file_append_entry(
mj,

2
src/libsystemd/sd-journal/test-journal-interleaving.c
View File

@ -64,7 +64,7 @@ static void append_number(JournalFile *f, int n, const sd_id128_t *boot_id, uint
struct iovec iovec[2];
size_t n_iov = 0;
dual_timestamp_get(&ts);
dual_timestamp_now(&ts);
if (ts.monotonic <= previous_ts.monotonic)
ts.monotonic = previous_ts.monotonic + 1;

2
src/libsystemd/sd-journal/test-journal-stream.c
View File

@ -85,7 +85,7 @@ static void run_test(void) {
dual_timestamp ts;
struct iovec iovec[2];
dual_timestamp_get(&ts);
dual_timestamp_now(&ts);
if (ts.monotonic <= previous_ts.monotonic)
ts.monotonic = previous_ts.monotonic + 1;

2
src/libsystemd/sd-journal/test-journal-verify.c
View File

@ -108,7 +108,7 @@ static int run_test(const char *verification_key, ssize_t max_iterations) {
struct iovec iovec;
struct dual_timestamp ts;
dual_timestamp_get(&ts);
dual_timestamp_now(&ts);
assert_se(asprintf(&test, "RANDOM=%li", random() % RANDOM_RANGE));
iovec = IOVEC_MAKE_STRING(test);
assert_se(journal_file_append_entry(

4
src/libsystemd/sd-journal/test-journal.c
View File

@ -41,7 +41,7 @@ static void test_non_empty_one(void) {
assert_se(journal_file_open(-1, "test.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f) == 0);
assert_se(dual_timestamp_get(&ts));
assert_se(dual_timestamp_now(&ts));
assert_se(sd_id128_randomize(&fake_boot_id) == 0);
iovec = IOVEC_MAKE_STRING(test);
@ -196,7 +196,7 @@ static bool check_compressed(uint64_t compress_threshold, uint64_t data_size) {
assert_se(journal_file_open(-1, "test.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, compress_threshold, NULL, m, NULL, &f) == 0);
dual_timestamp_get(&ts);
dual_timestamp_now(&ts);
iovec = IOVEC_MAKE(data, data_size);
assert_se(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL) == 0);

2
src/locale/localed.c
View File

@ -192,7 +192,7 @@ static int locale_gen_process_locale(char *new_locale[static _VARIABLE_LC_MAX],
log_error_errno(r, "Failed to enable invalid locale %s for generation.", new_locale[p]);
return sd_bus_error_setf(error,
SD_BUS_ERROR_INVALID_ARGS,
"Can not enable locale generation for invalid locale: %s",
"Cannot enable locale generation for invalid locale: %s",
new_locale[p]);
}
if (r < 0) {

2
src/login/logind-device.c
View File

@ -27,7 +27,7 @@ Device* device_new(Manager *m, const char *sysfs, bool master) {
d->manager = m;
d->master = master;
dual_timestamp_get(&d->timestamp);
dual_timestamp_now(&d->timestamp);
return d;
}

2
src/login/logind-inhibit.c
View File

@ -176,7 +176,7 @@ int inhibitor_start(Inhibitor *i) {
if (i->started)
return 0;
dual_timestamp_get(&i->since);
dual_timestamp_now(&i->since);
log_debug("Inhibitor %s (%s) pid="PID_FMT" uid="UID_FMT" mode=%s started.",
strna(i->who), strna(i->why),

4
src/login/logind-session.c
View File

@ -794,7 +794,7 @@ int session_start(Session *s, sd_bus_message *properties, sd_bus_error *error) {
LOG_MESSAGE("New session %s of user %s.", s->id, s->user->user_record->user_name));
if (!dual_timestamp_is_set(&s->timestamp))
dual_timestamp_get(&s->timestamp);
dual_timestamp_now(&s->timestamp);
if (s->seat)
seat_read_active_vt(s->seat);
@ -1088,7 +1088,7 @@ int session_set_idle_hint(Session *s, bool b) {
return 0;
s->idle_hint = b;
dual_timestamp_get(&s->idle_hint_timestamp);
dual_timestamp_now(&s->idle_hint_timestamp);
session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);

2
src/login/logind-user.c
View File

@ -460,7 +460,7 @@ int user_start(User *u) {
if (!u->started) {
if (!dual_timestamp_is_set(&u->timestamp))
dual_timestamp_get(&u->timestamp);
dual_timestamp_now(&u->timestamp);
user_send_signal(u, true);
u->started = true;
}

2
src/machine/machine.c
View File

@ -470,7 +470,7 @@ int machine_start(Machine *m, sd_bus_message *properties, sd_bus_error *error) {
LOG_MESSAGE("New machine %s.", m->name));
if (!dual_timestamp_is_set(&m->timestamp))
dual_timestamp_get(&m->timestamp);
dual_timestamp_now(&m->timestamp);
m->started = true;

2
src/resolve/resolved-dnstls-openssl.c
View File

@ -327,7 +327,7 @@ ssize_t dnstls_stream_writev(DnsStream *stream, const struct iovec *iov, size_t
if (iovcnt == 1)
return dnstls_stream_write(stream, iov[0].iov_base, iov[0].iov_len);
/* As of now, OpenSSL can not accumulate multiple writes, so join into a
/* As of now, OpenSSL cannot accumulate multiple writes, so join into a
single buffer. Suboptimal, but better than multiple SSL_write calls. */
count = iovec_total_size(iov, iovcnt);
buf = new(char, count);

2
src/shared/boot-timestamps.c
View File

@ -15,7 +15,7 @@ int boot_timestamps(const dual_timestamp *n, dual_timestamp *firmware, dual_time
assert(loader);
if (!n) {
dual_timestamp_get(&_n);
dual_timestamp_now(&_n);
n = &_n;
}

2
src/systemctl/systemctl-list-units.c
View File

@ -769,7 +769,7 @@ int verb_list_timers(int argc, char *argv[], void *userdata) {
if (n < 0)
return n;
dual_timestamp_get(&nw);
dual_timestamp_now(&nw);
FOREACH_ARRAY(u, unit_infos, n) {
r = add_timer_info(bus, u, &nw, &timers, &n_timers);

2
src/systemctl/systemctl-show.c
View File

@ -484,7 +484,7 @@ static void print_status_info(
dual_timestamp nw, next = {i->next_elapse_real, i->next_elapse_monotonic};
usec_t next_elapse;
dual_timestamp_get(&nw);
dual_timestamp_now(&nw);
next_elapse = calc_next_elapse(&nw, &next);
if (timestamp_is_set(next_elapse))

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

@ -566,7 +566,7 @@ static int manager_receive_response(sd_event_source *source, int fd, uint32_t re
m->poll_interval_usec / USEC_PER_SEC);
/* Get current monotonic/realtime clocks immediately before adjusting the latter */
triple_timestamp_get(&dts);
triple_timestamp_now(&dts);
if (!spike) {
/* Fix up our idea of the time. */