d->connections = connections;
d->connection = connection;
- _dbus_get_current_time (&d->connection_tv_sec,
- &d->connection_tv_usec);
+ _dbus_get_monotonic_time (&d->connection_tv_sec,
+ &d->connection_tv_usec);
_dbus_assert (connection_data_slot >= 0);
DBusList *link;
int auth_timeout;
- _dbus_get_current_time (&tv_sec, &tv_usec);
+ _dbus_get_monotonic_time (&tv_sec, &tv_usec);
auth_timeout = bus_context_get_auth_timeout (connections->context);
link = _dbus_list_get_first_link (&connections->incomplete);
cprd->pending = pending;
cprd->connections = connections;
- _dbus_get_current_time (&pending->expire_item.added_tv_sec,
- &pending->expire_item.added_tv_usec);
+ _dbus_get_monotonic_time (&pending->expire_item.added_tv_sec,
+ &pending->expire_item.added_tv_usec);
_dbus_verbose ("Added pending reply %p, replier %p receiver %p serial %u\n",
pending,
}
static int
-do_expiration_with_current_time (BusExpireList *list,
- long tv_sec,
- long tv_usec)
+do_expiration_with_monotonic_time (BusExpireList *list,
+ long tv_sec,
+ long tv_usec)
{
DBusList *link;
int next_interval, min_wait_time, items_to_expire;
{
long tv_sec, tv_usec;
- _dbus_get_current_time (&tv_sec, &tv_usec);
+ _dbus_get_monotonic_time (&tv_sec, &tv_usec);
- next_interval = do_expiration_with_current_time (list, tv_sec, tv_usec);
+ next_interval = do_expiration_with_monotonic_time (list, tv_sec, tv_usec);
}
bus_expire_timeout_set_interval (list->timeout, next_interval);
test_expire_func, NULL);
_dbus_assert (list != NULL);
- _dbus_get_current_time (&tv_sec, &tv_usec);
+ _dbus_get_monotonic_time (&tv_sec, &tv_usec);
tv_sec_not_expired = tv_sec;
tv_usec_not_expired = tv_usec;
_dbus_assert_not_reached ("out of memory");
next_interval =
- do_expiration_with_current_time (list, tv_sec_not_expired,
- tv_usec_not_expired);
+ do_expiration_with_monotonic_time (list, tv_sec_not_expired,
+ tv_usec_not_expired);
_dbus_assert (item->expire_count == 0);
_dbus_verbose ("next_interval = %d\n", next_interval);
_dbus_assert (next_interval == 1);
next_interval =
- do_expiration_with_current_time (list, tv_sec_expired,
- tv_usec_expired);
+ do_expiration_with_monotonic_time (list, tv_sec_expired,
+ tv_usec_expired);
_dbus_assert (item->expire_count == 1);
_dbus_verbose ("next_interval = %d\n", next_interval);
_dbus_assert (next_interval == -1);
next_interval =
- do_expiration_with_current_time (list, tv_sec_past,
- tv_usec_past);
+ do_expiration_with_monotonic_time (list, tv_sec_past,
+ tv_usec_past);
_dbus_assert (item->expire_count == 1);
_dbus_verbose ("next_interval = %d\n", next_interval);
_dbus_assert (next_interval == 1000 + EXPIRE_AFTER);
* below
*/
timeout = _dbus_pending_call_get_timeout_unlocked (pending);
- _dbus_get_current_time (&start_tv_sec, &start_tv_usec);
+ _dbus_get_monotonic_time (&start_tv_sec, &start_tv_usec);
if (timeout)
{
timeout_milliseconds = dbus_timeout_get_interval (timeout);
return;
}
- _dbus_get_current_time (&tv_sec, &tv_usec);
+ _dbus_get_monotonic_time (&tv_sec, &tv_usec);
elapsed_milliseconds = (tv_sec - start_tv_sec) * 1000 +
(tv_usec - start_tv_usec) / 1000;
{
long now;
- _dbus_get_current_time (&now, NULL);
+ /* don't use monotonic time because the UUID may be saved to disk, e.g.
+ * it may persist across reboots
+ */
+ _dbus_get_real_time (&now, NULL);
uuid->as_uint32s[DBUS_UUID_LENGTH_WORDS - 1] = DBUS_UINT32_TO_BE (now);
goto out;
}
- _dbus_get_current_time (×tamp, NULL);
+ _dbus_get_real_time (×tamp, NULL);
keys[n_keys-1].id = id;
keys[n_keys-1].creation_time = timestamp;
retval = FALSE;
have_lock = FALSE;
- _dbus_get_current_time (&now, NULL);
+ _dbus_get_real_time (&now, NULL);
if (add_new)
{
int i;
long tv_sec, tv_usec;
- _dbus_get_current_time (&tv_sec, &tv_usec);
+ _dbus_get_real_time (&tv_sec, &tv_usec);
i = 0;
while (i < keyring->n_keys)
return NULL;
cb->timeout = timeout;
- _dbus_get_current_time (&cb->last_tv_sec,
- &cb->last_tv_usec);
+ _dbus_get_monotonic_time (&cb->last_tv_sec,
+ &cb->last_tv_usec);
return cb;
}
unsigned long tv_sec;
unsigned long tv_usec;
- _dbus_get_current_time (&tv_sec, &tv_usec);
+ _dbus_get_monotonic_time (&tv_sec, &tv_usec);
link = _dbus_list_get_first_link (&loop->timeouts);
while (link != NULL)
unsigned long tv_sec;
unsigned long tv_usec;
- _dbus_get_current_time (&tv_sec, &tv_usec);
+ _dbus_get_monotonic_time (&tv_sec, &tv_usec);
/* It'd be nice to avoid this O(n) thingy here */
link = _dbus_list_get_first_link (&loop->timeouts);
* available, to avoid problems when the system time changes.
*
* @param tv_sec return location for number of seconds
- * @param tv_usec return location for number of microseconds (thousandths)
+ * @param tv_usec return location for number of microseconds
*/
void
-_dbus_get_current_time (long *tv_sec,
- long *tv_usec)
+_dbus_get_monotonic_time (long *tv_sec,
+ long *tv_usec)
{
#ifdef HAVE_MONOTONIC_CLOCK
struct timespec ts;
}
/**
+ * Get current time, as in gettimeofday(). Never uses the monotonic
+ * clock.
+ *
+ * @param tv_sec return location for number of seconds
+ * @param tv_usec return location for number of microseconds
+ */
+void
+_dbus_get_real_time (long *tv_sec,
+ long *tv_usec)
+{
+ struct timeval t;
+
+ gettimeofday (&t, NULL);
+
+ if (tv_sec)
+ *tv_sec = t.tv_sec;
+ if (tv_usec)
+ *tv_usec = t.tv_usec;
+}
+
+/**
* Creates a directory; succeeds if the directory
* is created or already existed.
*
/**
- * Get current time, as in gettimeofday().
+ * Get current time, as in gettimeofday(). Never uses the monotonic
+ * clock.
*
* @param tv_sec return location for number of seconds
* @param tv_usec return location for number of microseconds
*/
void
-_dbus_get_current_time (long *tv_sec,
- long *tv_usec)
+_dbus_get_real_time (long *tv_sec,
+ long *tv_usec)
{
FILETIME ft;
dbus_uint64_t time64;
*tv_usec = time64 % 1000000;
}
+/**
+ * Get current time, as in gettimeofday(). Use the monotonic clock if
+ * available, to avoid problems when the system time changes.
+ *
+ * @param tv_sec return location for number of seconds
+ * @param tv_usec return location for number of microseconds
+ */
+void
+_dbus_get_monotonic_time (long *tv_sec,
+ long *tv_usec)
+{
+ /* no implementation yet, fall back to wall-clock time */
+ _dbus_get_real_time (tv_sec, tv_usec);
+}
/**
* signal (SIGPIPE, SIG_IGN);
_dbus_verbose ("Falling back to pseudorandom for %d bytes\n",
n_bytes);
- _dbus_get_current_time (NULL, &tv_usec);
+ _dbus_get_real_time (NULL, &tv_usec);
srand (tv_usec);
i = 0;
void _dbus_sleep_milliseconds (int milliseconds);
-void _dbus_get_current_time (long *tv_sec,
- long *tv_usec);
+void _dbus_get_real_time (long *tv_sec,
+ long *tv_usec);
+
+void _dbus_get_monotonic_time (long *tv_sec,
+ long *tv_usec);
/**
* directory interface
fprintf (stderr, "could not open/read /dev/urandom, using current time for seed\n");
- _dbus_get_current_time (NULL, &tv_usec);
+ _dbus_get_monotonic_time (NULL, &tv_usec);
seed = tv_usec;
}
{
long delta;
- _dbus_get_current_time (&start_tv_sec, &start_tv_usec);
+ _dbus_get_monotonic_time (&start_tv_sec, &start_tv_usec);
_run_iteration (conn);
- _dbus_get_current_time (&end_tv_sec, &end_tv_usec);
+ _dbus_get_monotonic_time (&end_tv_sec, &end_tv_usec);
/* we just care about seconds */
delta = end_tv_sec - start_tv_sec;
{
long delta;
- _dbus_get_current_time (&start_tv_sec, &start_tv_usec);
+ _dbus_get_monotonic_time (&start_tv_sec, &start_tv_usec);
_run_iteration (conn);
- _dbus_get_current_time (&end_tv_sec, &end_tv_usec);
+ _dbus_get_monotonic_time (&end_tv_sec, &end_tv_usec);
/* we just care about seconds */
delta = end_tv_sec - start_tv_sec;