diff options
Diffstat (limited to 'shared/nm-glib-aux/nm-time-utils.c')
| -rw-r--r-- | shared/nm-glib-aux/nm-time-utils.c | 328 |
1 files changed, 0 insertions, 328 deletions
diff --git a/shared/nm-glib-aux/nm-time-utils.c b/shared/nm-glib-aux/nm-time-utils.c deleted file mode 100644 index df98176a12..0000000000 --- a/shared/nm-glib-aux/nm-time-utils.c +++ /dev/null @@ -1,328 +0,0 @@ -/* SPDX-License-Identifier: LGPL-2.1-or-later */ -/* - * Copyright (C) 2018 Red Hat, Inc. - */ - -#include "nm-glib-aux/nm-default-glib-i18n-lib.h" - -#include "nm-time-utils.h" - -#include "nm-logging-fwd.h" - -/*****************************************************************************/ - -typedef struct { - /* the offset to the native clock, in seconds. */ - gint64 offset_sec; - clockid_t clk_id; -} GlobalState; - -static const GlobalState *volatile p_global_state; - -static const GlobalState * -_t_init_global_state(void) -{ - static GlobalState global_state = {}; - static gsize init_once = 0; - const GlobalState *p; - clockid_t clk_id; - struct timespec tp; - gint64 offset_sec; - int r; - - clk_id = CLOCK_BOOTTIME; - r = clock_gettime(clk_id, &tp); - if (r == -1 && errno == EINVAL) { - clk_id = CLOCK_MONOTONIC; - r = clock_gettime(clk_id, &tp); - } - - /* The only failure we tolerate is that CLOCK_BOOTTIME is not supported. - * Other than that, we rely on kernel to not fail on this. */ - g_assert(r == 0); - g_assert(tp.tv_nsec >= 0 && tp.tv_nsec < NM_UTILS_NSEC_PER_SEC); - - /* Calculate an offset for the time stamp. - * - * We always want positive values, because then we can initialize - * a timestamp with 0 and be sure, that it will be less then any - * value nm_utils_get_monotonic_timestamp_*() might return. - * For this to be true also for nm_utils_get_monotonic_timestamp_sec() at - * early boot, we have to shift the timestamp to start counting at - * least from 1 second onward. - * - * Another advantage of shifting is, that this way we make use of the whole 31 bit - * range of signed int, before the time stamp for nm_utils_get_monotonic_timestamp_sec() - * wraps (~68 years). - **/ - offset_sec = (-((gint64) tp.tv_sec)) + 1; - - if (!g_once_init_enter(&init_once)) { - /* there was a race. We expect the pointer to be fully initialized now. */ - p = g_atomic_pointer_get(&p_global_state); - g_assert(p); - return p; - } - - global_state.offset_sec = offset_sec; - global_state.clk_id = clk_id; - p = &global_state; - g_atomic_pointer_set(&p_global_state, p); - g_once_init_leave(&init_once, 1); - - _nm_utils_monotonic_timestamp_initialized(&tp, p->offset_sec, p->clk_id == CLOCK_BOOTTIME); - - return p; -} - -#define _t_get_global_state() \ - ({ \ - const GlobalState *_p; \ - \ - _p = g_atomic_pointer_get(&p_global_state); \ - (G_LIKELY(_p) ? _p : _t_init_global_state()); \ - }) - -#define _t_clock_gettime_eval(p, tp) \ - ({ \ - struct timespec *const _tp = (tp); \ - const GlobalState *const _p2 = (p); \ - int _r; \ - \ - nm_assert(_tp); \ - \ - _r = clock_gettime(_p2->clk_id, _tp); \ - \ - nm_assert(_r == 0); \ - nm_assert(_tp->tv_nsec >= 0 && _tp->tv_nsec < NM_UTILS_NSEC_PER_SEC); \ - \ - _p2; \ - }) - -#define _t_clock_gettime(tp) _t_clock_gettime_eval(_t_get_global_state(), tp); - -/*****************************************************************************/ - -/** - * nm_utils_get_monotonic_timestamp_nsec: - * - * Returns: a monotonically increasing time stamp in nanoseconds, - * starting at an unspecified offset. See clock_gettime(), %CLOCK_BOOTTIME. - * - * The returned value will start counting at an undefined point - * in the past and will always be positive. - * - * All the nm_utils_get_monotonic_timestamp_*sec functions return the same - * timestamp but in different scales (nsec, usec, msec, sec). - **/ -gint64 -nm_utils_get_monotonic_timestamp_nsec(void) -{ - const GlobalState *p; - struct timespec tp; - - p = _t_clock_gettime(&tp); - - /* Although the result will always be positive, we return a signed - * integer, which makes it easier to calculate time differences (when - * you want to subtract signed values). - **/ - return (((gint64) tp.tv_sec) + p->offset_sec) * NM_UTILS_NSEC_PER_SEC + tp.tv_nsec; -} - -/** - * nm_utils_get_monotonic_timestamp_usec: - * - * Returns: a monotonically increasing time stamp in microseconds, - * starting at an unspecified offset. See clock_gettime(), %CLOCK_BOOTTIME. - * - * The returned value will start counting at an undefined point - * in the past and will always be positive. - * - * All the nm_utils_get_monotonic_timestamp_*sec functions return the same - * timestamp but in different scales (nsec, usec, msec, sec). - **/ -gint64 -nm_utils_get_monotonic_timestamp_usec(void) -{ - const GlobalState *p; - struct timespec tp; - - p = _t_clock_gettime(&tp); - - /* Although the result will always be positive, we return a signed - * integer, which makes it easier to calculate time differences (when - * you want to subtract signed values). - **/ - return (((gint64) tp.tv_sec) + p->offset_sec) * ((gint64) G_USEC_PER_SEC) - + (tp.tv_nsec / (NM_UTILS_NSEC_PER_SEC / G_USEC_PER_SEC)); -} - -/** - * nm_utils_get_monotonic_timestamp_msec: - * - * Returns: a monotonically increasing time stamp in milliseconds, - * starting at an unspecified offset. See clock_gettime(), %CLOCK_BOOTTIME. - * - * The returned value will start counting at an undefined point - * in the past and will always be positive. - * - * All the nm_utils_get_monotonic_timestamp_*sec functions return the same - * timestamp but in different scales (nsec, usec, msec, sec). - **/ -gint64 -nm_utils_get_monotonic_timestamp_msec(void) -{ - const GlobalState *p; - struct timespec tp; - - p = _t_clock_gettime(&tp); - - /* Although the result will always be positive, we return a signed - * integer, which makes it easier to calculate time differences (when - * you want to subtract signed values). - **/ - return (((gint64) tp.tv_sec) + p->offset_sec) * ((gint64) 1000) - + (tp.tv_nsec / (NM_UTILS_NSEC_PER_SEC / 1000)); -} - -/** - * nm_utils_get_monotonic_timestamp_sec: - * - * Returns: nm_utils_get_monotonic_timestamp_msec() in seconds (throwing - * away sub second parts). The returned value will always be positive. - * - * This value wraps after roughly 68 years which should be fine for any - * practical purpose. - * - * All the nm_utils_get_monotonic_timestamp_*sec functions return the same - * timestamp but in different scales (nsec, usec, msec, sec). - **/ -gint32 -nm_utils_get_monotonic_timestamp_sec(void) -{ - const GlobalState *p; - struct timespec tp; - - p = _t_clock_gettime(&tp); - - return (((gint64) tp.tv_sec) + p->offset_sec); -} - -/** - * nm_utils_monotonic_timestamp_as_boottime: - * @timestamp: the monotonic-timestamp that should be converted into CLOCK_BOOTTIME. - * @timestamp_nsec_per_tick: How many nanoseconds make one unit of @timestamp? E.g. if - * @timestamp is in unit seconds, pass %NM_UTILS_NSEC_PER_SEC; if @timestamp is - * in nanoseconds, pass 1; if @timestamp is in milliseconds, pass %NM_UTILS_NSEC_PER_SEC/1000. - * This must be a multiple of 10, and between 1 and %NM_UTILS_NSEC_PER_SEC. - * - * Returns: the monotonic-timestamp as CLOCK_BOOTTIME, as returned by clock_gettime(). - * The unit is the same as the passed in @timestamp based on @timestamp_nsec_per_tick. - * E.g. if you passed @timestamp in as seconds, it will return boottime in seconds. - * - * Note that valid monotonic-timestamps are always positive numbers (counting roughly since - * the application is running). However, it might make sense to calculate a timestamp from - * before the application was running, hence negative @timestamp is allowed. The result - * in that case might also be a negative timestamp (in CLOCK_BOOTTIME), which would indicate - * that the timestamp lies in the past before the machine was booted. - * - * On older kernels that don't support CLOCK_BOOTTIME, the returned time is instead CLOCK_MONOTONIC. - **/ -gint64 -nm_utils_monotonic_timestamp_as_boottime(gint64 timestamp, gint64 timestamp_nsec_per_tick) -{ - const GlobalState *p; - gint64 offset; - - /* only support nsec-per-tick being a multiple of 10. */ - g_return_val_if_fail(timestamp_nsec_per_tick == 1 - || (timestamp_nsec_per_tick > 0 - && timestamp_nsec_per_tick <= NM_UTILS_NSEC_PER_SEC - && timestamp_nsec_per_tick % 10 == 0), - -1); - - /* if the caller didn't yet ever fetch a monotonic-timestamp, he cannot pass any meaningful - * value (because he has no idea what these timestamps would be). That would be a bug. */ - nm_assert(g_atomic_pointer_get(&p_global_state)); - - p = _t_get_global_state(); - - nm_assert(p->offset_sec <= 0); - - /* calculate the offset of monotonic-timestamp to boottime. offset_s is <= 1. */ - offset = p->offset_sec * (NM_UTILS_NSEC_PER_SEC / timestamp_nsec_per_tick); - - nm_assert(offset <= 0 && offset > G_MININT64); - - /* check for overflow (note that offset is non-positive). */ - g_return_val_if_fail(timestamp < G_MAXINT64 + offset, G_MAXINT64); - - return timestamp - offset; -} - -/** - * nm_utils_monotonic_timestamp_from_boottime: - * @boottime: the timestamp from CLOCK_BOOTTIME (or CLOCK_MONOTONIC, if - * kernel does not support CLOCK_BOOTTIME and monotonic timestamps are based - * on CLOCK_MONOTONIC). - * @timestamp_nsec_per_tick: the scale in which @boottime is. If @boottime is in - * nano seconds, this should be 1. If it is in milli seconds, this should be - * %NM_UTILS_NSEC_PER_SEC/1000, etc. - * - * Returns: the same timestamp in monotonic timestamp scale. - * - * Note that commonly monotonic timestamps are positive. But they may not - * be positive in this case. That's when boottime is taken from a time before - * the monotonic timestamps started counting. So, that means a zero or negative - * value is still a valid timestamp. - * - * This is the inverse of nm_utils_monotonic_timestamp_as_boottime(). - */ -gint64 -nm_utils_monotonic_timestamp_from_boottime(guint64 boottime, gint64 timestamp_nsec_per_tick) -{ - const GlobalState *p; - gint64 offset; - - /* only support nsec-per-tick being a multiple of 10. */ - g_return_val_if_fail(timestamp_nsec_per_tick == 1 - || (timestamp_nsec_per_tick > 0 - && timestamp_nsec_per_tick <= NM_UTILS_NSEC_PER_SEC - && timestamp_nsec_per_tick % 10 == 0), - -1); - - p = _t_get_global_state(); - - nm_assert(p->offset_sec <= 0); - - /* calculate the offset of monotonic-timestamp to boottime. offset_s is <= 1. */ - offset = p->offset_sec * (NM_UTILS_NSEC_PER_SEC / timestamp_nsec_per_tick); - - nm_assert(offset <= 0 && offset > G_MININT64); - - /* check for overflow (note that offset is non-positive). */ - g_return_val_if_fail(boottime < G_MAXINT64, G_MAXINT64); - - return (gint64) boottime + offset; -} - -gint64 -nm_utils_clock_gettime_nsec(clockid_t clockid) -{ - struct timespec tp; - - if (clock_gettime(clockid, &tp) != 0) - return -NM_ERRNO_NATIVE(errno); - return nm_utils_timespec_to_nsec(&tp); -} - -gint64 -nm_utils_clock_gettime_msec(clockid_t clockid) -{ - struct timespec tp; - - if (clock_gettime(clockid, &tp) != 0) - return -NM_ERRNO_NATIVE(errno); - return nm_utils_timespec_to_msec(&tp); -} |