Commit | Line | Data |
---|---|---|
14131f2f IM |
1 | /* |
2 | * tracing clocks | |
3 | * | |
4 | * Copyright (C) 2009 Red Hat, Inc., Ingo Molnar <mingo@redhat.com> | |
5 | * | |
6 | * Implements 3 trace clock variants, with differing scalability/precision | |
7 | * tradeoffs: | |
8 | * | |
9 | * - local: CPU-local trace clock | |
10 | * - medium: scalable global clock with some jitter | |
11 | * - global: globally monotonic, serialized clock | |
12 | * | |
13 | * Tracer plugins will chose a default from these clocks. | |
14 | */ | |
15 | #include <linux/spinlock.h> | |
ae1f3038 | 16 | #include <linux/irqflags.h> |
14131f2f IM |
17 | #include <linux/hardirq.h> |
18 | #include <linux/module.h> | |
19 | #include <linux/percpu.h> | |
20 | #include <linux/sched.h> | |
21 | #include <linux/ktime.h> | |
b8b94265 | 22 | #include <linux/trace_clock.h> |
14131f2f IM |
23 | |
24 | /* | |
25 | * trace_clock_local(): the simplest and least coherent tracing clock. | |
26 | * | |
27 | * Useful for tracing that does not cross to other CPUs nor | |
28 | * does it go through idle events. | |
29 | */ | |
30 | u64 notrace trace_clock_local(void) | |
31 | { | |
6cc3c6e1 PZ |
32 | u64 clock; |
33 | ||
14131f2f IM |
34 | /* |
35 | * sched_clock() is an architecture implemented, fast, scalable, | |
36 | * lockless clock. It is not guaranteed to be coherent across | |
37 | * CPUs, nor across CPU idle events. | |
38 | */ | |
5168ae50 | 39 | preempt_disable_notrace(); |
6cc3c6e1 | 40 | clock = sched_clock(); |
5168ae50 | 41 | preempt_enable_notrace(); |
6cc3c6e1 PZ |
42 | |
43 | return clock; | |
14131f2f | 44 | } |
dc975e94 | 45 | EXPORT_SYMBOL_GPL(trace_clock_local); |
14131f2f IM |
46 | |
47 | /* | |
25985edc | 48 | * trace_clock(): 'between' trace clock. Not completely serialized, |
14131f2f IM |
49 | * but not completely incorrect when crossing CPUs either. |
50 | * | |
51 | * This is based on cpu_clock(), which will allow at most ~1 jiffy of | |
52 | * jitter between CPUs. So it's a pretty scalable clock, but there | |
53 | * can be offsets in the trace data. | |
54 | */ | |
55 | u64 notrace trace_clock(void) | |
56 | { | |
c676329a | 57 | return local_clock(); |
14131f2f IM |
58 | } |
59 | ||
8aacf017 SRRH |
60 | /* |
61 | * trace_jiffy_clock(): Simply use jiffies as a clock counter. | |
58d4e21e TL |
62 | * Note that this use of jiffies_64 is not completely safe on |
63 | * 32-bit systems. But the window is tiny, and the effect if | |
64 | * we are affected is that we will have an obviously bogus | |
65 | * timestamp on a trace event - i.e. not life threatening. | |
8aacf017 SRRH |
66 | */ |
67 | u64 notrace trace_clock_jiffies(void) | |
68 | { | |
58d4e21e | 69 | return jiffies_64_to_clock_t(jiffies_64 - INITIAL_JIFFIES); |
8aacf017 | 70 | } |
14131f2f IM |
71 | |
72 | /* | |
73 | * trace_clock_global(): special globally coherent trace clock | |
74 | * | |
75 | * It has higher overhead than the other trace clocks but is still | |
76 | * an order of magnitude faster than GTOD derived hardware clocks. | |
77 | * | |
78 | * Used by plugins that need globally coherent timestamps. | |
79 | */ | |
80 | ||
6ca6cca3 SR |
81 | /* keep prev_time and lock in the same cacheline. */ |
82 | static struct { | |
83 | u64 prev_time; | |
445c8951 | 84 | arch_spinlock_t lock; |
6ca6cca3 SR |
85 | } trace_clock_struct ____cacheline_aligned_in_smp = |
86 | { | |
edc35bd7 | 87 | .lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED, |
6ca6cca3 | 88 | }; |
14131f2f IM |
89 | |
90 | u64 notrace trace_clock_global(void) | |
91 | { | |
92 | unsigned long flags; | |
93 | int this_cpu; | |
94 | u64 now; | |
95 | ||
e36673ec | 96 | local_irq_save(flags); |
14131f2f IM |
97 | |
98 | this_cpu = raw_smp_processor_id(); | |
5e67b51e | 99 | now = sched_clock_cpu(this_cpu); |
14131f2f IM |
100 | /* |
101 | * If in an NMI context then dont risk lockups and return the | |
102 | * cpu_clock() time: | |
103 | */ | |
104 | if (unlikely(in_nmi())) | |
105 | goto out; | |
106 | ||
0199c4e6 | 107 | arch_spin_lock(&trace_clock_struct.lock); |
14131f2f IM |
108 | |
109 | /* | |
110 | * TODO: if this happens often then maybe we should reset | |
6ca6cca3 | 111 | * my_scd->clock to prev_time+1, to make sure |
14131f2f IM |
112 | * we start ticking with the local clock from now on? |
113 | */ | |
6ca6cca3 SR |
114 | if ((s64)(now - trace_clock_struct.prev_time) < 0) |
115 | now = trace_clock_struct.prev_time + 1; | |
14131f2f | 116 | |
6ca6cca3 | 117 | trace_clock_struct.prev_time = now; |
14131f2f | 118 | |
0199c4e6 | 119 | arch_spin_unlock(&trace_clock_struct.lock); |
14131f2f IM |
120 | |
121 | out: | |
e36673ec | 122 | local_irq_restore(flags); |
14131f2f IM |
123 | |
124 | return now; | |
125 | } | |
6249687f SR |
126 | |
127 | static atomic64_t trace_counter; | |
128 | ||
129 | /* | |
130 | * trace_clock_counter(): simply an atomic counter. | |
131 | * Use the trace_counter "counter" for cases where you do not care | |
132 | * about timings, but are interested in strict ordering. | |
133 | */ | |
134 | u64 notrace trace_clock_counter(void) | |
135 | { | |
136 | return atomic64_add_return(1, &trace_counter); | |
137 | } |