X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=wrapper%2Ftrace-clock.h;h=496fec4360c7f654c18f454acae564ba43adabe7;hb=7a2087510e950efcac414b347f9b826a003d7bd1;hp=1b2821a19a8b7fde4a315721944d0d66405062bb;hpb=e6b06d7d6346a5e3cfcdd214d171af067bca0f34;p=lttng-modules.git diff --git a/wrapper/trace-clock.h b/wrapper/trace-clock.h index 1b2821a1..496fec43 100644 --- a/wrapper/trace-clock.h +++ b/wrapper/trace-clock.h @@ -35,15 +35,32 @@ #include #include #include -#include "../lttng-kernel-version.h" -#include "percpu-defs.h" -#include "random.h" +#include +#include +#include +#include -#if LTTNG_KERNEL_RANGE(3,10,0, 3,10,14) || LTTNG_KERNEL_RANGE(3,11,0, 3,11,3) +#if ((LTTNG_KERNEL_RANGE(3,10,0, 3,10,14) && !LTTNG_RHEL_KERNEL_RANGE(3,10,0,123,0,0, 3,10,14,0,0,0)) \ + || LTTNG_KERNEL_RANGE(3,11,0, 3,11,3)) #error "Linux kernels 3.10 and 3.11 introduce a deadlock in the timekeeping subsystem. Fixed by commit 7bd36014460f793c19e7d6c94dab67b0afcfcb7f \"timekeeping: Fix HRTICK related deadlock from ntp lock changes\" in Linux." #endif -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)) +extern struct lttng_trace_clock *lttng_trace_clock; + +/* + * Upstream Linux commit 27727df240c7 ("Avoid taking lock in NMI path with + * CONFIG_DEBUG_TIMEKEEPING") introduces a buggy ktime_get_mono_fast_ns(). + * This is fixed by patch "timekeeping: Fix __ktime_get_fast_ns() regression". + */ +#if (LTTNG_KERNEL_RANGE(4,8,0, 4,8,2) \ + || LTTNG_KERNEL_RANGE(4,7,4, 4,7,8) \ + || LTTNG_KERNEL_RANGE(4,4,20, 4,4,25) \ + || LTTNG_KERNEL_RANGE(4,1,32, 4,1,35)) +#define LTTNG_CLOCK_NMI_SAFE_BROKEN +#endif + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0) \ + && !defined(LTTNG_CLOCK_NMI_SAFE_BROKEN)) DECLARE_PER_CPU(local_t, lttng_last_tsc); @@ -89,7 +106,7 @@ static inline u64 trace_clock_fixup(u64 src_now, u64 last) #endif /* #else #if (BITS_PER_LONG == 32) */ /* - * Always called with preemption disabled. Can be interrupted. + * Sometimes called with preemption enabled. Can be interrupted. */ static inline u64 trace_clock_monotonic_wrapper(void) { @@ -98,6 +115,7 @@ static inline u64 trace_clock_monotonic_wrapper(void) local_t *last_tsc; /* Use fast nmi-safe monotonic clock provided by the Linux kernel. */ + preempt_disable(); last_tsc = lttng_this_cpu_ptr(<tng_last_tsc); last = local_read(last_tsc); /* @@ -111,6 +129,7 @@ static inline u64 trace_clock_monotonic_wrapper(void) if (((long) now - (long) last) < 0) now = trace_clock_fixup(now, last); result = local_cmpxchg(last_tsc, last, (unsigned long) now); + preempt_enable(); if (result == last) { /* Update done. */ return now; @@ -141,31 +160,41 @@ static inline u64 trace_clock_monotonic_wrapper(void) } #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)) */ -static inline u64 trace_clock_read64(void) +static inline u64 trace_clock_read64_monotonic(void) { return (u64) trace_clock_monotonic_wrapper(); } -static inline u64 trace_clock_freq(void) +static inline u64 trace_clock_freq_monotonic(void) { return (u64) NSEC_PER_SEC; } -static inline int trace_clock_uuid(char *uuid) +static inline int trace_clock_uuid_monotonic(char *uuid) { return wrapper_get_bootid(uuid); } +static inline const char *trace_clock_name_monotonic(void) +{ + return "monotonic"; +} + +static inline const char *trace_clock_description_monotonic(void) +{ + return "Monotonic Clock"; +} + #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)) static inline int get_trace_clock(void) { - printk(KERN_WARNING "LTTng: Using mainline kernel monotonic fast clock, which is NMI-safe.\n"); + printk_once(KERN_WARNING "LTTng: Using mainline kernel monotonic fast clock, which is NMI-safe.\n"); return 0; } #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)) */ static inline int get_trace_clock(void) { - printk(KERN_WARNING "LTTng: Using mainline kernel monotonic clock. NMIs will not be traced.\n"); + printk_once(KERN_WARNING "LTTng: Using mainline kernel monotonic clock. NMIs will not be traced.\n"); return 0; } #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)) */ @@ -174,6 +203,67 @@ static inline void put_trace_clock(void) { } +static inline u64 trace_clock_read64(void) +{ + struct lttng_trace_clock *ltc = ACCESS_ONCE(lttng_trace_clock); + + if (likely(!ltc)) { + return trace_clock_read64_monotonic(); + } else { + read_barrier_depends(); /* load ltc before content */ + return ltc->read64(); + } +} + +static inline u64 trace_clock_freq(void) +{ + struct lttng_trace_clock *ltc = ACCESS_ONCE(lttng_trace_clock); + + if (!ltc) { + return trace_clock_freq_monotonic(); + } else { + read_barrier_depends(); /* load ltc before content */ + return ltc->freq(); + } +} + +static inline int trace_clock_uuid(char *uuid) +{ + struct lttng_trace_clock *ltc = ACCESS_ONCE(lttng_trace_clock); + + 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 = ACCESS_ONCE(lttng_trace_clock); + + if (!ltc) { + return trace_clock_name_monotonic(); + } else { + read_barrier_depends(); /* load ltc before content */ + return ltc->name(); + } +} + +static inline const char *trace_clock_description(void) +{ + struct lttng_trace_clock *ltc = ACCESS_ONCE(lttng_trace_clock); + + if (!ltc) { + return trace_clock_description_monotonic(); + } else { + read_barrier_depends(); /* load ltc before content */ + return ltc->description(); + } +} + #endif /* CONFIG_HAVE_TRACE_CLOCK */ #endif /* _LTTNG_TRACE_CLOCK_H */