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. | |
62 | */ | |
63 | u64 notrace trace_clock_jiffies(void) | |
64 | { | |
65 | u64 jiffy = jiffies - INITIAL_JIFFIES; | |
66 | ||
67 | /* Return nsecs */ | |
68 | return (u64)jiffies_to_usecs(jiffy) * 1000ULL; | |
69 | } | |
14131f2f IM |
70 | |
71 | /* | |
72 | * trace_clock_global(): special globally coherent trace clock | |
73 | * | |
74 | * It has higher overhead than the other trace clocks but is still | |
75 | * an order of magnitude faster than GTOD derived hardware clocks. | |
76 | * | |
77 | * Used by plugins that need globally coherent timestamps. | |
78 | */ | |
79 | ||
6ca6cca3 SR |
80 | /* keep prev_time and lock in the same cacheline. */ |
81 | static struct { | |
82 | u64 prev_time; | |
445c8951 | 83 | arch_spinlock_t lock; |
6ca6cca3 SR |
84 | } trace_clock_struct ____cacheline_aligned_in_smp = |
85 | { | |
edc35bd7 | 86 | .lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED, |
6ca6cca3 | 87 | }; |
14131f2f IM |
88 | |
89 | u64 notrace trace_clock_global(void) | |
90 | { | |
91 | unsigned long flags; | |
92 | int this_cpu; | |
93 | u64 now; | |
94 | ||
e36673ec | 95 | local_irq_save(flags); |
14131f2f IM |
96 | |
97 | this_cpu = raw_smp_processor_id(); | |
5e67b51e | 98 | now = sched_clock_cpu(this_cpu); |
14131f2f IM |
99 | /* |
100 | * If in an NMI context then dont risk lockups and return the | |
101 | * cpu_clock() time: | |
102 | */ | |
103 | if (unlikely(in_nmi())) | |
104 | goto out; | |
105 | ||
0199c4e6 | 106 | arch_spin_lock(&trace_clock_struct.lock); |
14131f2f IM |
107 | |
108 | /* | |
109 | * TODO: if this happens often then maybe we should reset | |
6ca6cca3 | 110 | * my_scd->clock to prev_time+1, to make sure |
14131f2f IM |
111 | * we start ticking with the local clock from now on? |
112 | */ | |
6ca6cca3 SR |
113 | if ((s64)(now - trace_clock_struct.prev_time) < 0) |
114 | now = trace_clock_struct.prev_time + 1; | |
14131f2f | 115 | |
6ca6cca3 | 116 | trace_clock_struct.prev_time = now; |
14131f2f | 117 | |
0199c4e6 | 118 | arch_spin_unlock(&trace_clock_struct.lock); |
14131f2f IM |
119 | |
120 | out: | |
e36673ec | 121 | local_irq_restore(flags); |
14131f2f IM |
122 | |
123 | return now; | |
124 | } | |
6249687f SR |
125 | |
126 | static atomic64_t trace_counter; | |
127 | ||
128 | /* | |
129 | * trace_clock_counter(): simply an atomic counter. | |
130 | * Use the trace_counter "counter" for cases where you do not care | |
131 | * about timings, but are interested in strict ordering. | |
132 | */ | |
133 | u64 notrace trace_clock_counter(void) | |
134 | { | |
135 | return atomic64_add_return(1, &trace_counter); | |
136 | } |