From 70ed5922019d3967aac53ebb58676b094a8aab20 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Jan=20R=C4=99korajski?= Date: Sun, 9 Nov 2014 19:25:29 +0100 Subject: [PATCH] - linux 3.17 fixes from upstream - rel 2 --- linux-3.17.patch | 242 +++++++++++++++++++++++++++++++++++++++++++++ lttng-modules.spec | 4 +- 2 files changed, 245 insertions(+), 1 deletion(-) create mode 100644 linux-3.17.patch diff --git a/linux-3.17.patch b/linux-3.17.patch new file mode 100644 index 0000000..cb1baf0 --- /dev/null +++ b/linux-3.17.patch @@ -0,0 +1,242 @@ +commit 458c2022e992c057bd21d02e4c77bcc7d4d6cd6c +Author: Mathieu Desnoyers +Date: Thu Aug 21 11:15:50 2014 -0400 + + Update kvm instrumentation: compile on 3.17-rc1 + + Signed-off-by: Mathieu Desnoyers + +diff --git a/instrumentation/events/lttng-module/arch/x86/kvm/trace.h b/instrumentation/events/lttng-module/arch/x86/kvm/trace.h +index 2354884..3c299c5 100644 +--- a/instrumentation/events/lttng-module/arch/x86/kvm/trace.h ++++ b/instrumentation/events/lttng-module/arch/x86/kvm/trace.h +@@ -724,7 +724,7 @@ TRACE_EVENT(kvm_emulate_insn, + tp_memcpy(insn, + vcpu->arch.emulate_ctxt.decode.fetch.data, + 15) +-#else ++#elif (LINUX_VERSION_CODE < KERNEL_VERSION(3,17,0)) + tp_assign(rip, vcpu->arch.emulate_ctxt.fetch.start) + tp_assign(csbase, kvm_x86_ops->get_segment_base(vcpu, VCPU_SREG_CS)) + tp_assign(len, vcpu->arch.emulate_ctxt._eip +@@ -732,6 +732,16 @@ TRACE_EVENT(kvm_emulate_insn, + tp_memcpy(insn, + vcpu->arch.emulate_ctxt.fetch.data, + 15) ++#else ++ tp_assign(rip, vcpu->arch.emulate_ctxt._eip - ++ (vcpu->arch.emulate_ctxt.fetch.ptr - ++ vcpu->arch.emulate_ctxt.fetch.data)) ++ tp_assign(csbase, kvm_x86_ops->get_segment_base(vcpu, VCPU_SREG_CS)) ++ tp_assign(len, vcpu->arch.emulate_ctxt.fetch.ptr - ++ vcpu->arch.emulate_ctxt.fetch.data) ++ tp_memcpy(insn, ++ vcpu->arch.emulate_ctxt.fetch.data, ++ 15) + #endif + tp_assign(flags, kei_decode_mode(vcpu->arch.emulate_ctxt.mode)) + tp_assign(failed, failed) +commit b07252070edd244987bf160c1ee488d4796bb3a3 +Author: Mathieu Desnoyers +Date: Sun Jul 13 13:20:57 2014 -0400 + + Use 3.17 ktime_get_mono_fast_ns() new API + + The new ktime_get_mono_fast_ns() API introduced in kernel 3.17 allows + tracing NMI handlers. + + Signed-off-by: Mathieu Desnoyers + Cc: Thomas Gleixner + +diff --git a/Makefile b/Makefile +index aa4835d..eeffdfe 100644 +--- a/Makefile ++++ b/Makefile +@@ -35,7 +35,7 @@ lttng-tracer-objs := lttng-events.o lttng-abi.o \ + lttng-context-vtid.o lttng-context-ppid.o \ + lttng-context-vppid.o lttng-calibrate.o \ + lttng-context-hostname.o wrapper/random.o \ +- probes/lttng.o ++ probes/lttng.o wrapper/trace-clock.o + + obj-m += lttng-statedump.o + lttng-statedump-objs := lttng-statedump-impl.o wrapper/irqdesc.o \ +diff --git a/wrapper/trace-clock.c b/wrapper/trace-clock.c +new file mode 100644 +index 0000000..1b7a217 +--- /dev/null ++++ b/wrapper/trace-clock.c +@@ -0,0 +1,29 @@ ++/* ++ * wrapper/trace-clock.c ++ * ++ * Contains LTTng trace clock mapping to LTTng trace clock or mainline monotonic ++ * clock. This wrapper depends on CONFIG_HIGH_RES_TIMERS=y. ++ * ++ * Copyright (C) 2011-2012 Mathieu Desnoyers ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; only ++ * version 2.1 of the License. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "trace-clock.h" ++ ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)) ++DEFINE_PER_CPU(local_t, lttng_last_tsc); ++EXPORT_PER_CPU_SYMBOL(lttng_last_tsc); ++#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0)) */ +diff --git a/wrapper/trace-clock.h b/wrapper/trace-clock.h +index 9c0c806..b145b82 100644 +--- a/wrapper/trace-clock.h ++++ b/wrapper/trace-clock.h +@@ -32,7 +32,9 @@ + #include + #include + #include ++#include + #include ++#include + #include "../lttng-kernel-version.h" + #include "random.h" + +@@ -40,6 +42,88 @@ + #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)) ++ ++DECLARE_PER_CPU(local_t, lttng_last_tsc); ++ ++#if (BITS_PER_LONG == 32) ++/* ++ * Fixup "src_now" using the 32 LSB from "last". We need to handle overflow and ++ * underflow of the 32nd bit. "last" can be above, below or equal to the 32 LSB ++ * of "src_now". ++ */ ++static inline u64 trace_clock_fixup(u64 src_now, u32 last) ++{ ++ u64 now; ++ ++ now = src_now & 0xFFFFFFFF00000000ULL; ++ now |= (u64) last; ++ /* Detect overflow or underflow between now and last. */ ++ if ((src_now & 0x80000000U) && !(last & 0x80000000U)) { ++ /* ++ * If 32nd bit transitions from 1 to 0, and we move forward in ++ * time from "now" to "last", then we have an overflow. ++ */ ++ if (((s32) now - (s32) last) < 0) ++ now += 0x0000000100000000ULL; ++ } else if (!(src_now & 0x80000000U) && (last & 0x80000000U)) { ++ /* ++ * If 32nd bit transitions from 0 to 1, and we move backward in ++ * time from "now" to "last", then we have an underflow. ++ */ ++ if (((s32) now - (s32) last) > 0) ++ now -= 0x0000000100000000ULL; ++ } ++ return now; ++} ++#else /* #if (BITS_PER_LONG == 32) */ ++/* ++ * The fixup is pretty easy on 64-bit architectures: "last" is a 64-bit ++ * value, so we can use last directly as current time. ++ */ ++static inline u64 trace_clock_fixup(u64 src_now, u64 last) ++{ ++ return last; ++} ++#endif /* #else #if (BITS_PER_LONG == 32) */ ++ ++/* ++ * Always called with preemption disabled. Can be interrupted. ++ */ ++static inline u64 trace_clock_monotonic_wrapper(void) ++{ ++ u64 now; ++ unsigned long last, result; ++ local_t *last_tsc; ++ ++ /* Use fast nmi-safe monotonic clock provided by the Linux kernel. */ ++ last_tsc = &__get_cpu_var(lttng_last_tsc); ++ last = local_read(last_tsc); ++ /* ++ * Read "last" before "now". It is not strictly required, but it ensures ++ * that an interrupt coming in won't artificially trigger a case where ++ * "now" < "last". This kind of situation should only happen if the ++ * mono_fast time source goes slightly backwards. ++ */ ++ barrier(); ++ now = ktime_get_mono_fast_ns(); ++ if (((long) now - (long) last) < 0) ++ now = trace_clock_fixup(now, last); ++ result = local_cmpxchg(last_tsc, last, (unsigned long) now); ++ if (result == last) { ++ /* Update done. */ ++ return now; ++ } else { ++ /* ++ * Update not done, due to concurrent update. We can use ++ * "result", since it has been sampled concurrently with our ++ * time read, so it should not be far from "now". ++ */ ++ return trace_clock_fixup(now, result); ++ } ++} ++ ++#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)) */ + static inline u64 trace_clock_monotonic_wrapper(void) + { + ktime_t ktime; +@@ -54,6 +138,7 @@ static inline u64 trace_clock_monotonic_wrapper(void) + ktime = ktime_get(); + return ktime_to_ns(ktime); + } ++#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)) */ + + static inline u32 trace_clock_read32(void) + { +@@ -75,23 +160,19 @@ static inline int trace_clock_uuid(char *uuid) + return wrapper_get_bootid(uuid); + } + ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)) + static inline int get_trace_clock(void) + { +- /* +- * LTTng: Using mainline kernel monotonic clock. NMIs will not be +- * traced, and expect significant performance degradation compared to +- * the LTTng trace clocks. Integration of the LTTng 0.x trace clocks +- * into LTTng 2.0 is planned in a near future. +- */ +- printk(KERN_WARNING "LTTng: Using mainline kernel monotonic clock.\n"); +- printk(KERN_WARNING " * NMIs will not be traced,\n"); +- printk(KERN_WARNING " * expect significant performance degradation compared to the\n"); +- printk(KERN_WARNING " LTTng trace clocks.\n"); +- printk(KERN_WARNING "Integration of the LTTng 0.x trace clocks into LTTng 2.0 is planned\n"); +- printk(KERN_WARNING "in a near future.\n"); +- ++ printk(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"); + return 0; + } ++#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)) */ + + static inline void put_trace_clock(void) + { diff --git a/lttng-modules.spec b/lttng-modules.spec index 6abde17..4034ca8 100644 --- a/lttng-modules.spec +++ b/lttng-modules.spec @@ -20,7 +20,7 @@ exit 1 %define kpkg %(echo %{_build_kernels} | tr , '\\n' | while read n ; do echo %%undefine alt_kernel ; [ -z "$n" ] || echo %%define alt_kernel $n ; echo %%kernel_pkg ; done) %define bkpkg %(echo %{_build_kernels} | tr , '\\n' | while read n ; do echo %%undefine alt_kernel ; [ -z "$n" ] || echo %%define alt_kernel $n ; echo %%build_kernel_pkg ; done) -%define rel 1 +%define rel 2 %define pname lttng-modules Summary: LTTng 2.x kernel modules Summary(pl.UTF-8): Moduły jądra LTTng 2.x @@ -32,6 +32,7 @@ Group: Base/Kernel Source0: http://lttng.org/files/lttng-modules/%{pname}-%{version}.tar.bz2 # Source0-md5: 2d99bb7311ba92e82e3b675f0b8dee7d Patch0: build.patch +Patch1: linux-3.17.patch URL: http://lttng.org/ %if %{with dist_kernel} BuildRequires: kernel%{_alt_kernel}-module-build >= 3:2.6.38 @@ -103,6 +104,7 @@ p=`pwd`\ %prep %setup -q -n %{pname}-%{version} %patch0 -p1 +%patch1 -p1 %build %{expand:%bkpkg} -- 2.43.0