Rename {dual,triple}_timestamp_get to {dual,triple}_timestamp_now

Those functions take a pointer to a timestamp and return a timestamp pointer,
so the reader would be justified to think that those are just getters. Rename
them to avoid confusion.

diff --git a/src/basic/time-util.c b/src/basic/time-util.c
index 695b998b57844f55cbbdcb69d94fd40df999bae4..f9014dc560bd4895fcbae0269af878a7de71574e 100644 (file)
--- a/src/basic/time-util.c
+++ b/src/basic/time-util.c
@@ -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);

diff --git a/src/basic/time-util.h b/src/basic/time-util.h
index 73ba8b9544dfd1c15ff0871e585613ea38799d05..ed4c1aabd489f1674cc1ac99d9cd6cf2fe645ef8 100644 (file)
--- a/src/basic/time-util.h
+++ b/src/basic/time-util.h
@@ -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);
 

diff --git a/src/core/execute.c b/src/core/execute.c
index e63137440a6e6390795a6fa73ea05c49be7039ce..1e48e88ee8c01a5463f1e002d54898b80a1073cf 100644 (file)
--- a/src/core/execute.c
+++ b/src/core/execute.c
@@ -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;

diff --git a/src/core/main.c b/src/core/main.c
index cfa29f3a58655534a91f404e7a5c0133e3039338..2ac59dabf5a23bd9490b5e48a2843ed9e23d25a1 100644 (file)
--- a/src/core/main.c
+++ b/src/core/main.c
@@ -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. */

diff --git a/src/core/manager.c b/src/core/manager.c
index 6b9ce2d2ec475ad251f5d01587caf37bc6a9ebbe..10f2e8e00eda5c1d27fa5dbe3ac0ab5be7637ea3 100644 (file)
--- a/src/core/manager.c
+++ b/src/core/manager.c
@@ -1947,7 +1947,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;
 }
 
@@ -1971,11 +1971,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;
 
@@ -1997,10 +1997,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) {
@@ -3890,7 +3890,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);
 

diff --git a/src/core/service.c b/src/core/service.c
index d3e8d458544ec0325c76f25a80e2ff6074985795..b9eb40c5559c1c17928bb50eb17207b8ddec1d63 100644 (file)
--- a/src/core/service.c
+++ b/src/core/service.c
@@ -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);
 }
 

diff --git a/src/core/timer.c b/src/core/timer.c
index 97233a88f69e0155c770c79da0d7fe506fc10ebe..3c41a250b03f99a5db21299044139b29bc3c9bc3 100644 (file)
--- a/src/core/timer.c
+++ b/src/core/timer.c
@@ -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);

diff --git a/src/core/unit-serialize.c b/src/core/unit-serialize.c
index 0ffcceaf53d7deb54d92c5645e96eb271b6a5011..3bb63d15d61149b49f5627aeb1715cf32bff14f0 100644 (file)
--- a/src/core/unit-serialize.c
+++ b/src/core/unit-serialize.c
@@ -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

diff --git a/src/core/unit.c b/src/core/unit.c
index 4bff7ced084dc2bc33850e8e31b687d4bce07662..e865c393a3bf581cf50de6227cd2f57b68f3c6ca 100644 (file)
--- a/src/core/unit.c
+++ b/src/core/unit.c
@@ -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;

diff --git a/src/libsystemd-network/icmp6-util-unix.c b/src/libsystemd-network/icmp6-util-unix.c
index 95e050083bf2b91076811c1ddd7cab6618675134..01edb854df3fb1a6d3aa4526c84882433adb0f77 100644 (file)
--- a/src/libsystemd-network/icmp6-util-unix.c
+++ b/src/libsystemd-network/icmp6-util-unix.c
@@ -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;

diff --git a/src/libsystemd-network/icmp6-util.c b/src/libsystemd-network/icmp6-util.c
index a0521f05622d4c2115a035fbce761ae3ad033af2..25fd70b1b1bc083b23f1198f4fab6a7779149a92 100644 (file)
--- a/src/libsystemd-network/icmp6-util.c
+++ b/src/libsystemd-network/icmp6-util.c
@@ -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)

diff --git a/src/libsystemd-network/sd-dhcp-lease.c b/src/libsystemd-network/sd-dhcp-lease.c
index a6e78dd0719740ed8c9414cff7a80ba282b8dc2e..4925fa8f1935b81da404a31b1358a1c0b703c963 100644 (file)
--- a/src/libsystemd-network/sd-dhcp-lease.c
+++ b/src/libsystemd-network/sd-dhcp-lease.c
@@ -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) {

diff --git a/src/libsystemd-network/sd-dhcp-server.c b/src/libsystemd-network/sd-dhcp-server.c
index 45c0f14d2cf9ca982eb4ad41b51ada15abefedca..ce576c24eb5ebb6f63d316a69586a24e4578ebbb 100644 (file)
--- a/src/libsystemd-network/sd-dhcp-server.c
+++ b/src/libsystemd-network/sd-dhcp-server.c
@@ -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) {

diff --git a/src/libsystemd-network/sd-dhcp6-lease.c b/src/libsystemd-network/sd-dhcp6-lease.c
index bbd005bb6352f7e46e215f87e5249e5a6018c25d..674248b83da258b74860c6a8e71e25fdc8067694 100644 (file)
--- a/src/libsystemd-network/sd-dhcp6-lease.c
+++ b/src/libsystemd-network/sd-dhcp6-lease.c
@@ -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) {

diff --git a/src/libsystemd-network/sd-lldp-rx.c b/src/libsystemd-network/sd-lldp-rx.c
index 7e2ffd4eabec547ac1c13f0564e52a2065af4bbd..2fc9a55323ef45fc69a38fcd5cda5783ea3ed6be 100644 (file)
--- a/src/libsystemd-network/sd-lldp-rx.c
+++ b/src/libsystemd-network/sd-lldp-rx.c
@@ -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;

diff --git a/src/libsystemd/sd-event/sd-event.c b/src/libsystemd/sd-event/sd-event.c
index aba458185b8378e5de0b47dadcf59383f23d964d..288798a0dccefcb7ce225096987ae41f1b89b283 100644 (file)
--- a/src/libsystemd/sd-event/sd-event.c
+++ b/src/libsystemd/sd-event/sd-event.c
@@ -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++) {
 

diff --git a/src/libsystemd/sd-journal/journal-file.c b/src/libsystemd/sd-journal/journal-file.c
index 4b74d06997a1610c5234890f2047eecee466e30b..f72498c2e71bc1ba9455acfb459aa2dd38d919f6 100644 (file)
--- a/src/libsystemd/sd-journal/journal-file.c
+++ b/src/libsystemd/sd-journal/journal-file.c
@@ -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;
         }
 

diff --git a/src/libsystemd/sd-journal/test-journal-append.c b/src/libsystemd/sd-journal/test-journal-append.c
index 90a7ccb00f109482a37f1d10ca010452c37587e5..24b98c8b4adcb6514f6229205f03eec332c6e87a 100644 (file)
--- a/src/libsystemd/sd-journal/test-journal-append.c
+++ b/src/libsystemd/sd-journal/test-journal-append.c
@@ -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,

diff --git a/src/libsystemd/sd-journal/test-journal-interleaving.c b/src/libsystemd/sd-journal/test-journal-interleaving.c
index fe97a9e4a691c6c0e1ef416ed51cb1d6f07dc101..eff908bde03c5847e4b596a032d9353bef9c0533 100644 (file)
--- a/src/libsystemd/sd-journal/test-journal-interleaving.c
+++ b/src/libsystemd/sd-journal/test-journal-interleaving.c
@@ -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;

diff --git a/src/libsystemd/sd-journal/test-journal-stream.c b/src/libsystemd/sd-journal/test-journal-stream.c
index 1dbfdcd60732eab048a9e2dbd5a58cd8db8af2f2..3a370ef3119d4c1c1c02f161f8f4b2e4b4a1e63f 100644 (file)
--- a/src/libsystemd/sd-journal/test-journal-stream.c
+++ b/src/libsystemd/sd-journal/test-journal-stream.c
@@ -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;

diff --git a/src/libsystemd/sd-journal/test-journal-verify.c b/src/libsystemd/sd-journal/test-journal-verify.c
index d05312c88f304f73355d1fc8dea5565fec726a30..edce44049a26779f5e78915ad8df4488bc22d6b4 100644 (file)
--- a/src/libsystemd/sd-journal/test-journal-verify.c
+++ b/src/libsystemd/sd-journal/test-journal-verify.c
@@ -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(

diff --git a/src/libsystemd/sd-journal/test-journal.c b/src/libsystemd/sd-journal/test-journal.c
index badf6cdb450139be1b0575e43b28a1e551563e2f..96f2b6719e593f4c0e1c3c6e859af8e6eeaf3c04 100644 (file)
--- a/src/libsystemd/sd-journal/test-journal.c
+++ b/src/libsystemd/sd-journal/test-journal.c
@@ -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);

diff --git a/src/login/logind-device.c b/src/login/logind-device.c
index f6050345260c63b83fb4fb06527eb4625f39175f..376cd0d42fd8b46c0a6198b6e28da3d2b8daaf06 100644 (file)
--- a/src/login/logind-device.c
+++ b/src/login/logind-device.c
@@ -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;
 }

diff --git a/src/login/logind-inhibit.c b/src/login/logind-inhibit.c
index 62c38f2f1233af38cd7d0c056db9663758242dad..af7879f5616d7d86a70524e4017fe3c0b3446e45 100644 (file)
--- a/src/login/logind-inhibit.c
+++ b/src/login/logind-inhibit.c
@@ -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),

diff --git a/src/login/logind-session.c b/src/login/logind-session.c
index fa62c60a9f29bb0d775c075842a89ad681381b8b..3f5decd8d9bd1a62b5ba77e9492378d49e612584 100644 (file)
--- a/src/login/logind-session.c
+++ b/src/login/logind-session.c
@@ -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);
 

diff --git a/src/login/logind-user.c b/src/login/logind-user.c
index 7a6056086aefba448b03ef2110ec262a7d2b5f8a..641050f8ba58218c7e1ea42053959bbe246df092 100644 (file)
--- a/src/login/logind-user.c
+++ b/src/login/logind-user.c
@@ -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;
         }

diff --git a/src/machine/machine.c b/src/machine/machine.c
index ae64b430cfc864a74d8922213d46aab346d3cf8f..44ff5c190bb479d2b4179bebc28bdb52f59e2959 100644 (file)
--- a/src/machine/machine.c
+++ b/src/machine/machine.c
@@ -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;
 

diff --git a/src/shared/boot-timestamps.c b/src/shared/boot-timestamps.c
index 8786e89c0eeda16bd3e90a87a300733c0bd1baa6..e49bd8f1f2ca7e2e20348559e7fcf56b793acf01 100644 (file)
--- a/src/shared/boot-timestamps.c
+++ b/src/shared/boot-timestamps.c
@@ -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;
         }
 

diff --git a/src/systemctl/systemctl-list-units.c b/src/systemctl/systemctl-list-units.c
index 34abc3cc9b3a31c6bf3b4adb337b6098b8c0ee3c..e48cf45333ba8f51a1abf43a8b13b4b23b68e8ea 100644 (file)
--- a/src/systemctl/systemctl-list-units.c
+++ b/src/systemctl/systemctl-list-units.c
@@ -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);

diff --git a/src/systemctl/systemctl-show.c b/src/systemctl/systemctl-show.c
index 1667ba4004dda4211caa866e51bc6c73baea742a..94f037615b15d15725ee6d5dbf7f5eeccebc38c6 100644 (file)
--- a/src/systemctl/systemctl-show.c
+++ b/src/systemctl/systemctl-show.c
@@ -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))

diff --git a/src/timesync/timesyncd-manager.c b/src/timesync/timesyncd-manager.c
index 82fe668bf9cd47bd62d0f23e2ee184f596fc97cd..1317bc0f76421176cff647c1e5b901290da58d13 100644 (file)
--- a/src/timesync/timesyncd-manager.c
+++ b/src/timesync/timesyncd-manager.c
@@ -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. */