1 /* SPDX-License-Identifier: GPL-2.0 */ 1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _LINUX_TRACE_RECURSION_H 2 #ifndef _LINUX_TRACE_RECURSION_H
3 #define _LINUX_TRACE_RECURSION_H 3 #define _LINUX_TRACE_RECURSION_H
4 4
5 #include <linux/interrupt.h> 5 #include <linux/interrupt.h>
6 #include <linux/sched.h> 6 #include <linux/sched.h>
7 7
8 #ifdef CONFIG_TRACING 8 #ifdef CONFIG_TRACING
9 9
10 /* Only current can touch trace_recursion */ 10 /* Only current can touch trace_recursion */
11 11
12 /* 12 /*
13 * For function tracing recursion: 13 * For function tracing recursion:
14 * The order of these bits are important. 14 * The order of these bits are important.
15 * 15 *
16 * When function tracing occurs, the followin 16 * When function tracing occurs, the following steps are made:
17 * If arch does not support a ftrace feature 17 * If arch does not support a ftrace feature:
18 * call internal function (uses INTERNAL bi 18 * call internal function (uses INTERNAL bits) which calls...
19 * The function callback, which can use the 19 * The function callback, which can use the FTRACE bits to
20 * check for recursion. 20 * check for recursion.
21 */ 21 */
22 enum { 22 enum {
23 /* Function recursion bits */ 23 /* Function recursion bits */
24 TRACE_FTRACE_BIT, 24 TRACE_FTRACE_BIT,
25 TRACE_FTRACE_NMI_BIT, 25 TRACE_FTRACE_NMI_BIT,
26 TRACE_FTRACE_IRQ_BIT, 26 TRACE_FTRACE_IRQ_BIT,
27 TRACE_FTRACE_SIRQ_BIT, 27 TRACE_FTRACE_SIRQ_BIT,
28 TRACE_FTRACE_TRANSITION_BIT, 28 TRACE_FTRACE_TRANSITION_BIT,
29 29
30 /* Internal use recursion bits */ 30 /* Internal use recursion bits */
31 TRACE_INTERNAL_BIT, 31 TRACE_INTERNAL_BIT,
32 TRACE_INTERNAL_NMI_BIT, 32 TRACE_INTERNAL_NMI_BIT,
33 TRACE_INTERNAL_IRQ_BIT, 33 TRACE_INTERNAL_IRQ_BIT,
34 TRACE_INTERNAL_SIRQ_BIT, 34 TRACE_INTERNAL_SIRQ_BIT,
35 TRACE_INTERNAL_TRANSITION_BIT, 35 TRACE_INTERNAL_TRANSITION_BIT,
36 36
37 TRACE_BRANCH_BIT, 37 TRACE_BRANCH_BIT,
38 /* 38 /*
39 * Abuse of the trace_recursion. 39 * Abuse of the trace_recursion.
40 * As we need a way to maintain state if we ar 40 * As we need a way to maintain state if we are tracing the function
41 * graph in irq because we want to trace a par 41 * graph in irq because we want to trace a particular function that
42 * was called in irq context but we have irq t 42 * was called in irq context but we have irq tracing off. Since this
43 * can only be modified by current, we can reu 43 * can only be modified by current, we can reuse trace_recursion.
44 */ 44 */
45 TRACE_IRQ_BIT, 45 TRACE_IRQ_BIT,
46 46
47 /* Used to prevent recursion recording 47 /* Used to prevent recursion recording from recursing. */
48 TRACE_RECORD_RECURSION_BIT, 48 TRACE_RECORD_RECURSION_BIT,
49 }; 49 };
50 50
51 #define trace_recursion_set(bit) do { ( 51 #define trace_recursion_set(bit) do { (current)->trace_recursion |= (1<<(bit)); } while (0)
52 #define trace_recursion_clear(bit) do { ( 52 #define trace_recursion_clear(bit) do { (current)->trace_recursion &= ~(1<<(bit)); } while (0)
53 #define trace_recursion_test(bit) ((curr 53 #define trace_recursion_test(bit) ((current)->trace_recursion & (1<<(bit)))
54 54
55 #define TRACE_CONTEXT_BITS 4 55 #define TRACE_CONTEXT_BITS 4
56 56
57 #define TRACE_FTRACE_START TRACE_FTRACE_B 57 #define TRACE_FTRACE_START TRACE_FTRACE_BIT
58 58
59 #define TRACE_LIST_START TRACE_INTERNAL 59 #define TRACE_LIST_START TRACE_INTERNAL_BIT
60 60
61 #define TRACE_CONTEXT_MASK ((1 << (TRACE_ 61 #define TRACE_CONTEXT_MASK ((1 << (TRACE_LIST_START + TRACE_CONTEXT_BITS)) - 1)
62 62
63 /* 63 /*
64 * Used for setting context 64 * Used for setting context
65 * NMI = 0 65 * NMI = 0
66 * IRQ = 1 66 * IRQ = 1
67 * SOFTIRQ = 2 67 * SOFTIRQ = 2
68 * NORMAL = 3 68 * NORMAL = 3
69 */ 69 */
70 enum { 70 enum {
71 TRACE_CTX_NMI, 71 TRACE_CTX_NMI,
72 TRACE_CTX_IRQ, 72 TRACE_CTX_IRQ,
73 TRACE_CTX_SOFTIRQ, 73 TRACE_CTX_SOFTIRQ,
74 TRACE_CTX_NORMAL, 74 TRACE_CTX_NORMAL,
75 TRACE_CTX_TRANSITION, 75 TRACE_CTX_TRANSITION,
76 }; 76 };
77 77
78 static __always_inline int trace_get_context_b 78 static __always_inline int trace_get_context_bit(void)
79 { 79 {
80 unsigned char bit = interrupt_context_ 80 unsigned char bit = interrupt_context_level();
81 81
82 return TRACE_CTX_NORMAL - bit; 82 return TRACE_CTX_NORMAL - bit;
83 } 83 }
84 84
85 #ifdef CONFIG_FTRACE_RECORD_RECURSION 85 #ifdef CONFIG_FTRACE_RECORD_RECURSION
86 extern void ftrace_record_recursion(unsigned l 86 extern void ftrace_record_recursion(unsigned long ip, unsigned long parent_ip);
87 # define do_ftrace_record_recursion(ip, pip) 87 # define do_ftrace_record_recursion(ip, pip) \
88 do { 88 do { \
89 if (!trace_recursion_test(TRAC 89 if (!trace_recursion_test(TRACE_RECORD_RECURSION_BIT)) { \
90 trace_recursion_set(TR 90 trace_recursion_set(TRACE_RECORD_RECURSION_BIT); \
91 ftrace_record_recursio 91 ftrace_record_recursion(ip, pip); \
92 trace_recursion_clear( 92 trace_recursion_clear(TRACE_RECORD_RECURSION_BIT); \
93 } 93 } \
94 } while (0) 94 } while (0)
95 #else 95 #else
96 # define do_ftrace_record_recursion(ip, pip) 96 # define do_ftrace_record_recursion(ip, pip) do { } while (0)
97 #endif 97 #endif
98 98
99 #ifdef CONFIG_FTRACE_VALIDATE_RCU_IS_WATCHING 99 #ifdef CONFIG_FTRACE_VALIDATE_RCU_IS_WATCHING
100 # define trace_warn_on_no_rcu(ip) 100 # define trace_warn_on_no_rcu(ip) \
101 ({ 101 ({ \
102 bool __ret = !rcu_is_watching( 102 bool __ret = !rcu_is_watching(); \
103 if (__ret && !trace_recursion_ 103 if (__ret && !trace_recursion_test(TRACE_RECORD_RECURSION_BIT)) { \
104 trace_recursion_set(TR 104 trace_recursion_set(TRACE_RECORD_RECURSION_BIT); \
105 WARN_ONCE(true, "RCU n 105 WARN_ONCE(true, "RCU not on for: %pS\n", (void *)ip); \
106 trace_recursion_clear( 106 trace_recursion_clear(TRACE_RECORD_RECURSION_BIT); \
107 } 107 } \
108 __ret; 108 __ret; \
109 }) 109 })
110 #else 110 #else
111 # define trace_warn_on_no_rcu(ip) false 111 # define trace_warn_on_no_rcu(ip) false
112 #endif 112 #endif
113 113
114 /* 114 /*
115 * Preemption is promised to be disabled when 115 * Preemption is promised to be disabled when return bit >= 0.
116 */ 116 */
117 static __always_inline int trace_test_and_set_ 117 static __always_inline int trace_test_and_set_recursion(unsigned long ip, unsigned long pip,
118 118 int start)
119 { 119 {
120 unsigned int val = READ_ONCE(current-> 120 unsigned int val = READ_ONCE(current->trace_recursion);
121 int bit; 121 int bit;
122 122
123 if (trace_warn_on_no_rcu(ip)) 123 if (trace_warn_on_no_rcu(ip))
124 return -1; 124 return -1;
125 125
126 bit = trace_get_context_bit() + start; 126 bit = trace_get_context_bit() + start;
127 if (unlikely(val & (1 << bit))) { 127 if (unlikely(val & (1 << bit))) {
128 /* 128 /*
129 * If an interrupt occurs duri 129 * If an interrupt occurs during a trace, and another trace
130 * happens in that interrupt b 130 * happens in that interrupt but before the preempt_count is
131 * updated to reflect the new 131 * updated to reflect the new interrupt context, then this
132 * will think a recursion occu 132 * will think a recursion occurred, and the event will be dropped.
133 * Let a single instance happe 133 * Let a single instance happen via the TRANSITION_BIT to
134 * not drop those events. 134 * not drop those events.
135 */ 135 */
136 bit = TRACE_CTX_TRANSITION + s 136 bit = TRACE_CTX_TRANSITION + start;
137 if (val & (1 << bit)) { 137 if (val & (1 << bit)) {
138 do_ftrace_record_recur 138 do_ftrace_record_recursion(ip, pip);
139 return -1; 139 return -1;
140 } 140 }
141 } 141 }
142 142
143 val |= 1 << bit; 143 val |= 1 << bit;
144 current->trace_recursion = val; 144 current->trace_recursion = val;
145 barrier(); 145 barrier();
146 146
147 preempt_disable_notrace(); 147 preempt_disable_notrace();
148 148
149 return bit; 149 return bit;
150 } 150 }
151 151
152 /* 152 /*
153 * Preemption will be enabled (if it was previ 153 * Preemption will be enabled (if it was previously enabled).
154 */ 154 */
155 static __always_inline void trace_clear_recurs 155 static __always_inline void trace_clear_recursion(int bit)
156 { 156 {
157 preempt_enable_notrace(); 157 preempt_enable_notrace();
158 barrier(); 158 barrier();
159 trace_recursion_clear(bit); 159 trace_recursion_clear(bit);
160 } 160 }
161 161
162 /** 162 /**
163 * ftrace_test_recursion_trylock - tests for r 163 * ftrace_test_recursion_trylock - tests for recursion in same context
164 * 164 *
165 * Use this for ftrace callbacks. This will de 165 * Use this for ftrace callbacks. This will detect if the function
166 * tracing recursed in the same context (norma 166 * tracing recursed in the same context (normal vs interrupt),
167 * 167 *
168 * Returns: -1 if a recursion happened. 168 * Returns: -1 if a recursion happened.
169 * >= 0 if no recursion. 169 * >= 0 if no recursion.
170 */ 170 */
171 static __always_inline int ftrace_test_recursi 171 static __always_inline int ftrace_test_recursion_trylock(unsigned long ip,
172 172 unsigned long parent_ip)
173 { 173 {
174 return trace_test_and_set_recursion(ip 174 return trace_test_and_set_recursion(ip, parent_ip, TRACE_FTRACE_START);
175 } 175 }
176 176
177 /** 177 /**
178 * ftrace_test_recursion_unlock - called when 178 * ftrace_test_recursion_unlock - called when function callback is complete
179 * @bit: The return of a successful ftrace_tes 179 * @bit: The return of a successful ftrace_test_recursion_trylock()
180 * 180 *
181 * This is used at the end of a ftrace callbac 181 * This is used at the end of a ftrace callback.
182 */ 182 */
183 static __always_inline void ftrace_test_recurs 183 static __always_inline void ftrace_test_recursion_unlock(int bit)
184 { 184 {
185 trace_clear_recursion(bit); 185 trace_clear_recursion(bit);
186 } 186 }
187 187
188 #endif /* CONFIG_TRACING */ 188 #endif /* CONFIG_TRACING */
189 #endif /* _LINUX_TRACE_RECURSION_H */ 189 #endif /* _LINUX_TRACE_RECURSION_H */
190 190
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.