From 97f3d71c1129f2851d4d829bfc15b1e12e02ff3c Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Tue, 23 Mar 2021 12:01:43 -0400 Subject: [PATCH] clock override: use getter API from LTTng-UST MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Currently, the lttng session daemon reimplements its own copy of struct lttng_trace_clock, which is pretty bad as ABI go. Use getter functions for each of the clock callback instead. This refactoring needs to be introduced with a matching commit to implement the new ABI in LTTng-UST. Move the implementation of the clock frequency, uuid, name and description default callbacks (for monotonic clock) to lttng-ust. Signed-off-by: Mathieu Desnoyers Signed-off-by: Jérémie Galarneau Change-Id: If2e671bacacc55d3fb27b6b4d4fc8c16aaffd059 --- src/bin/lttng-sessiond/ust-clock.h | 153 ++++++++--------------------- 1 file changed, 43 insertions(+), 110 deletions(-) diff --git a/src/bin/lttng-sessiond/ust-clock.h b/src/bin/lttng-sessiond/ust-clock.h index ee53a99a1..91cbbe628 100644 --- a/src/bin/lttng-sessiond/ust-clock.h +++ b/src/bin/lttng-sessiond/ust-clock.h @@ -20,150 +20,83 @@ #include -/* TRACE CLOCK */ - -struct lttng_trace_clock { - uint64_t (*read64)(void); - uint64_t (*freq)(void); - int (*uuid)(char *uuid); - const char *(*name)(void); - const char *(*description)(void); -}; - -extern struct lttng_trace_clock *lttng_trace_clock; - -void lttng_ust_clock_init(void); - -/* - * Currently using the kernel MONOTONIC clock, waiting for kernel-side - * LTTng to implement mmap'd trace clock. - */ - -/* Choosing correct trace clock */ - static __inline__ -uint64_t trace_clock_read64_monotonic(void) +uint64_t trace_clock_read64(void) { - struct timespec ts; + uint64_t clock_value = 0; + lttng_ust_clock_read64_function read64_cb; - if (lttng_clock_gettime(CLOCK_MONOTONIC, &ts)) { - /* TODO Report error cleanly up the chain. */ - PERROR("clock_gettime CLOCK_MONOTONIC"); - ts.tv_sec = 0; - ts.tv_nsec = 0; + if (lttng_ust_trace_clock_get_read64_cb(&read64_cb)) { + goto end; } - return ((uint64_t) ts.tv_sec * 1000000000ULL) + ts.tv_nsec; -} -static __inline__ -uint64_t trace_clock_freq_monotonic(void) -{ - return 1000000000ULL; + clock_value = read64_cb(); +end: + return clock_value; } static __inline__ -int trace_clock_uuid_monotonic(char *uuid) +uint64_t trace_clock_freq(void) { - int ret = 0; - size_t len; - FILE *fp; - - /* - * boot_id needs to be read once before being used concurrently - * to deal with a Linux kernel race. A fix is proposed for - * upstream, but the work-around is needed for older kernels. - */ - fp = fopen("/proc/sys/kernel/random/boot_id", "r"); - if (!fp) { - return -ENOENT; - } - len = fread(uuid, 1, LTTNG_UST_UUID_STR_LEN - 1, fp); - if (len < LTTNG_UST_UUID_STR_LEN - 1) { - ret = -EINVAL; + uint64_t frequency = 0; + lttng_ust_clock_freq_function get_freq_cb; + + if (lttng_ust_trace_clock_get_freq_cb(&get_freq_cb)) { goto end; } - uuid[LTTNG_UST_UUID_STR_LEN - 1] = '\0'; -end: - fclose(fp); - return ret; -} - -static __inline__ -const char *trace_clock_name_monotonic(void) -{ - return "monotonic"; -} -static __inline__ -const char *trace_clock_description_monotonic(void) -{ - return "Monotonic Clock"; + frequency = get_freq_cb(); +end: + return frequency; } static __inline__ -uint64_t trace_clock_read64(void) +int trace_clock_uuid(char *uuid) { - struct lttng_trace_clock *ltc = CMM_LOAD_SHARED(lttng_trace_clock); + int ret; + lttng_ust_clock_uuid_function get_uuid_cb; - if (caa_likely(!ltc)) { - return trace_clock_read64_monotonic(); - } else { - cmm_read_barrier_depends(); /* load ltc before content */ - return ltc->read64(); + if (lttng_ust_trace_clock_get_uuid_cb(&get_uuid_cb)) { + ret = -EINVAL; + goto end; } -} -static __inline__ -uint64_t trace_clock_freq(void) -{ - struct lttng_trace_clock *ltc = CMM_LOAD_SHARED(lttng_trace_clock); - - if (!ltc) { - return trace_clock_freq_monotonic(); - } else { - cmm_read_barrier_depends(); /* load ltc before content */ - return ltc->freq(); - } -} + ret = get_uuid_cb(uuid); +end: + return ret; -static __inline__ -int trace_clock_uuid(char *uuid) -{ - struct lttng_trace_clock *ltc = CMM_LOAD_SHARED(lttng_trace_clock); - - cmm_read_barrier_depends(); /* load ltc before content */ - /* Use default UUID cb when NULL */ - if (!ltc || !ltc->uuid) { - return trace_clock_uuid_monotonic(uuid); - } else { - return ltc->uuid(uuid); - } } static __inline__ const char *trace_clock_name(void) { - struct lttng_trace_clock *ltc = CMM_LOAD_SHARED(lttng_trace_clock); + const char *name; + lttng_ust_clock_name_function get_name_cb; - if (!ltc) { - return trace_clock_name_monotonic(); - } else { - cmm_read_barrier_depends(); /* load ltc before content */ - return ltc->name(); + if (lttng_ust_trace_clock_get_name_cb(&get_name_cb)) { + name = NULL; + goto end; } + + name = get_name_cb(); +end: + return name; } static __inline__ const char *trace_clock_description(void) { - struct lttng_trace_clock *ltc = CMM_LOAD_SHARED(lttng_trace_clock); + const char *description; + lttng_ust_clock_description_function get_description_cb; - if (!ltc) { - return trace_clock_description_monotonic(); - } else { - cmm_read_barrier_depends(); /* load ltc before content */ - return ltc->description(); + if (lttng_ust_trace_clock_get_description_cb(&get_description_cb)) { + description = NULL; + goto end; } + + description = get_description_cb(); +end: + return description; } #endif /* _UST_CLOCK_H */ -- 2.34.1