Commit | Line | Data |
---|---|---|
1a59d1b8 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
97e1c18e | 2 | /* |
de7b2973 | 3 | * Copyright (C) 2008-2014 Mathieu Desnoyers |
97e1c18e MD |
4 | */ |
5 | #include <linux/module.h> | |
6 | #include <linux/mutex.h> | |
7 | #include <linux/types.h> | |
8 | #include <linux/jhash.h> | |
9 | #include <linux/list.h> | |
10 | #include <linux/rcupdate.h> | |
11 | #include <linux/tracepoint.h> | |
12 | #include <linux/err.h> | |
13 | #include <linux/slab.h> | |
3f07c014 | 14 | #include <linux/sched/signal.h> |
29930025 | 15 | #include <linux/sched/task.h> |
c5905afb | 16 | #include <linux/static_key.h> |
97e1c18e | 17 | |
9c0be3f6 MD |
18 | extern tracepoint_ptr_t __start___tracepoints_ptrs[]; |
19 | extern tracepoint_ptr_t __stop___tracepoints_ptrs[]; | |
97e1c18e | 20 | |
e6753f23 JFG |
21 | DEFINE_SRCU(tracepoint_srcu); |
22 | EXPORT_SYMBOL_GPL(tracepoint_srcu); | |
23 | ||
97e1c18e MD |
24 | /* Set to 1 to enable tracepoint debug output */ |
25 | static const int tracepoint_debug; | |
26 | ||
de7b2973 | 27 | #ifdef CONFIG_MODULES |
97e1c18e | 28 | /* |
de7b2973 | 29 | * Tracepoint module list mutex protects the local module list. |
97e1c18e | 30 | */ |
de7b2973 | 31 | static DEFINE_MUTEX(tracepoint_module_list_mutex); |
97e1c18e | 32 | |
de7b2973 | 33 | /* Local list of struct tp_module */ |
b75ef8b4 MD |
34 | static LIST_HEAD(tracepoint_module_list); |
35 | #endif /* CONFIG_MODULES */ | |
36 | ||
97e1c18e | 37 | /* |
de7b2973 MD |
38 | * tracepoints_mutex protects the builtin and module tracepoints. |
39 | * tracepoints_mutex nests inside tracepoint_module_list_mutex. | |
97e1c18e | 40 | */ |
de7b2973 | 41 | static DEFINE_MUTEX(tracepoints_mutex); |
97e1c18e | 42 | |
f8a79d5c SRV |
43 | static struct rcu_head *early_probes; |
44 | static bool ok_to_free_tracepoints; | |
45 | ||
97e1c18e MD |
46 | /* |
47 | * Note about RCU : | |
fd589a8f | 48 | * It is used to delay the free of multiple probes array until a quiescent |
97e1c18e | 49 | * state is reached. |
97e1c18e | 50 | */ |
19dba33c | 51 | struct tp_probes { |
0dea6d52 | 52 | struct rcu_head rcu; |
38516ab5 | 53 | struct tracepoint_func probes[0]; |
19dba33c | 54 | }; |
97e1c18e | 55 | |
19dba33c | 56 | static inline void *allocate_probes(int count) |
97e1c18e | 57 | { |
f0553dcb GS |
58 | struct tp_probes *p = kmalloc(struct_size(p, probes, count), |
59 | GFP_KERNEL); | |
19dba33c | 60 | return p == NULL ? NULL : p->probes; |
97e1c18e MD |
61 | } |
62 | ||
e6753f23 | 63 | static void srcu_free_old_probes(struct rcu_head *head) |
97e1c18e | 64 | { |
0dea6d52 | 65 | kfree(container_of(head, struct tp_probes, rcu)); |
19dba33c LJ |
66 | } |
67 | ||
e6753f23 JFG |
68 | static void rcu_free_old_probes(struct rcu_head *head) |
69 | { | |
70 | call_srcu(&tracepoint_srcu, head, srcu_free_old_probes); | |
71 | } | |
72 | ||
f8a79d5c SRV |
73 | static __init int release_early_probes(void) |
74 | { | |
75 | struct rcu_head *tmp; | |
76 | ||
77 | ok_to_free_tracepoints = true; | |
78 | ||
79 | while (early_probes) { | |
80 | tmp = early_probes; | |
81 | early_probes = tmp->next; | |
74401729 | 82 | call_rcu(tmp, rcu_free_old_probes); |
f8a79d5c SRV |
83 | } |
84 | ||
85 | return 0; | |
86 | } | |
87 | ||
88 | /* SRCU is initialized at core_initcall */ | |
89 | postcore_initcall(release_early_probes); | |
90 | ||
38516ab5 | 91 | static inline void release_probes(struct tracepoint_func *old) |
19dba33c LJ |
92 | { |
93 | if (old) { | |
94 | struct tp_probes *tp_probes = container_of(old, | |
95 | struct tp_probes, probes[0]); | |
f8a79d5c SRV |
96 | |
97 | /* | |
98 | * We can't free probes if SRCU is not initialized yet. | |
99 | * Postpone the freeing till after SRCU is initialized. | |
100 | */ | |
101 | if (unlikely(!ok_to_free_tracepoints)) { | |
102 | tp_probes->rcu.next = early_probes; | |
103 | early_probes = &tp_probes->rcu; | |
104 | return; | |
105 | } | |
106 | ||
e6753f23 JFG |
107 | /* |
108 | * Tracepoint probes are protected by both sched RCU and SRCU, | |
109 | * by calling the SRCU callback in the sched RCU callback we | |
110 | * cover both cases. So let us chain the SRCU and sched RCU | |
111 | * callbacks to wait for both grace periods. | |
112 | */ | |
74401729 | 113 | call_rcu(&tp_probes->rcu, rcu_free_old_probes); |
19dba33c | 114 | } |
97e1c18e MD |
115 | } |
116 | ||
de7b2973 | 117 | static void debug_print_probes(struct tracepoint_func *funcs) |
97e1c18e MD |
118 | { |
119 | int i; | |
120 | ||
de7b2973 | 121 | if (!tracepoint_debug || !funcs) |
97e1c18e MD |
122 | return; |
123 | ||
de7b2973 MD |
124 | for (i = 0; funcs[i].func; i++) |
125 | printk(KERN_DEBUG "Probe %d : %p\n", i, funcs[i].func); | |
97e1c18e MD |
126 | } |
127 | ||
7904b5c4 SRRH |
128 | static struct tracepoint_func * |
129 | func_add(struct tracepoint_func **funcs, struct tracepoint_func *tp_func, | |
130 | int prio) | |
97e1c18e | 131 | { |
38516ab5 | 132 | struct tracepoint_func *old, *new; |
7904b5c4 SRRH |
133 | int nr_probes = 0; |
134 | int pos = -1; | |
97e1c18e | 135 | |
de7b2973 | 136 | if (WARN_ON(!tp_func->func)) |
4c69e6ea | 137 | return ERR_PTR(-EINVAL); |
97e1c18e | 138 | |
de7b2973 MD |
139 | debug_print_probes(*funcs); |
140 | old = *funcs; | |
97e1c18e MD |
141 | if (old) { |
142 | /* (N -> N+1), (N != 0, 1) probes */ | |
7904b5c4 SRRH |
143 | for (nr_probes = 0; old[nr_probes].func; nr_probes++) { |
144 | /* Insert before probes of lower priority */ | |
145 | if (pos < 0 && old[nr_probes].prio < prio) | |
146 | pos = nr_probes; | |
de7b2973 MD |
147 | if (old[nr_probes].func == tp_func->func && |
148 | old[nr_probes].data == tp_func->data) | |
97e1c18e | 149 | return ERR_PTR(-EEXIST); |
7904b5c4 | 150 | } |
97e1c18e MD |
151 | } |
152 | /* + 2 : one for new probe, one for NULL func */ | |
19dba33c | 153 | new = allocate_probes(nr_probes + 2); |
97e1c18e MD |
154 | if (new == NULL) |
155 | return ERR_PTR(-ENOMEM); | |
7904b5c4 SRRH |
156 | if (old) { |
157 | if (pos < 0) { | |
158 | pos = nr_probes; | |
159 | memcpy(new, old, nr_probes * sizeof(struct tracepoint_func)); | |
160 | } else { | |
161 | /* Copy higher priority probes ahead of the new probe */ | |
162 | memcpy(new, old, pos * sizeof(struct tracepoint_func)); | |
163 | /* Copy the rest after it. */ | |
164 | memcpy(new + pos + 1, old + pos, | |
165 | (nr_probes - pos) * sizeof(struct tracepoint_func)); | |
166 | } | |
167 | } else | |
168 | pos = 0; | |
169 | new[pos] = *tp_func; | |
38516ab5 | 170 | new[nr_probes + 1].func = NULL; |
de7b2973 MD |
171 | *funcs = new; |
172 | debug_print_probes(*funcs); | |
97e1c18e MD |
173 | return old; |
174 | } | |
175 | ||
de7b2973 MD |
176 | static void *func_remove(struct tracepoint_func **funcs, |
177 | struct tracepoint_func *tp_func) | |
97e1c18e MD |
178 | { |
179 | int nr_probes = 0, nr_del = 0, i; | |
38516ab5 | 180 | struct tracepoint_func *old, *new; |
97e1c18e | 181 | |
de7b2973 | 182 | old = *funcs; |
97e1c18e | 183 | |
f66af459 | 184 | if (!old) |
19dba33c | 185 | return ERR_PTR(-ENOENT); |
f66af459 | 186 | |
de7b2973 | 187 | debug_print_probes(*funcs); |
97e1c18e | 188 | /* (N -> M), (N > 1, M >= 0) probes */ |
de7b2973 | 189 | if (tp_func->func) { |
4c69e6ea | 190 | for (nr_probes = 0; old[nr_probes].func; nr_probes++) { |
de7b2973 MD |
191 | if (old[nr_probes].func == tp_func->func && |
192 | old[nr_probes].data == tp_func->data) | |
4c69e6ea S |
193 | nr_del++; |
194 | } | |
97e1c18e MD |
195 | } |
196 | ||
4c69e6ea S |
197 | /* |
198 | * If probe is NULL, then nr_probes = nr_del = 0, and then the | |
199 | * entire entry will be removed. | |
200 | */ | |
97e1c18e MD |
201 | if (nr_probes - nr_del == 0) { |
202 | /* N -> 0, (N > 1) */ | |
de7b2973 MD |
203 | *funcs = NULL; |
204 | debug_print_probes(*funcs); | |
97e1c18e MD |
205 | return old; |
206 | } else { | |
207 | int j = 0; | |
208 | /* N -> M, (N > 1, M > 0) */ | |
209 | /* + 1 for NULL */ | |
19dba33c | 210 | new = allocate_probes(nr_probes - nr_del + 1); |
97e1c18e MD |
211 | if (new == NULL) |
212 | return ERR_PTR(-ENOMEM); | |
38516ab5 | 213 | for (i = 0; old[i].func; i++) |
de7b2973 MD |
214 | if (old[i].func != tp_func->func |
215 | || old[i].data != tp_func->data) | |
97e1c18e | 216 | new[j++] = old[i]; |
38516ab5 | 217 | new[nr_probes - nr_del].func = NULL; |
de7b2973 | 218 | *funcs = new; |
97e1c18e | 219 | } |
de7b2973 | 220 | debug_print_probes(*funcs); |
97e1c18e MD |
221 | return old; |
222 | } | |
223 | ||
d25e37d8 SRV |
224 | static void tracepoint_update_call(struct tracepoint *tp, struct tracepoint_func *tp_funcs) |
225 | { | |
226 | void *func = tp->iterator; | |
227 | ||
228 | /* Synthetic events do not have static call sites */ | |
229 | if (!tp->static_call_key) | |
230 | return; | |
231 | ||
232 | if (!tp_funcs[1].func) | |
233 | func = tp_funcs[0].func; | |
234 | ||
235 | __static_call_update(tp->static_call_key, tp->static_call_tramp, func); | |
236 | } | |
237 | ||
97e1c18e | 238 | /* |
de7b2973 | 239 | * Add the probe function to a tracepoint. |
97e1c18e | 240 | */ |
de7b2973 | 241 | static int tracepoint_add_func(struct tracepoint *tp, |
7904b5c4 | 242 | struct tracepoint_func *func, int prio) |
97e1c18e | 243 | { |
de7b2973 | 244 | struct tracepoint_func *old, *tp_funcs; |
8cf868af | 245 | int ret; |
97e1c18e | 246 | |
8cf868af SRRH |
247 | if (tp->regfunc && !static_key_enabled(&tp->key)) { |
248 | ret = tp->regfunc(); | |
249 | if (ret < 0) | |
250 | return ret; | |
251 | } | |
97e1c18e | 252 | |
b725dfea MD |
253 | tp_funcs = rcu_dereference_protected(tp->funcs, |
254 | lockdep_is_held(&tracepoints_mutex)); | |
7904b5c4 | 255 | old = func_add(&tp_funcs, func, prio); |
de7b2973 | 256 | if (IS_ERR(old)) { |
d66a270b | 257 | WARN_ON_ONCE(PTR_ERR(old) != -ENOMEM); |
de7b2973 MD |
258 | return PTR_ERR(old); |
259 | } | |
97419875 | 260 | |
97e1c18e | 261 | /* |
243d1a79 PM |
262 | * rcu_assign_pointer has as smp_store_release() which makes sure |
263 | * that the new probe callbacks array is consistent before setting | |
264 | * a pointer to it. This array is referenced by __DO_TRACE from | |
265 | * include/linux/tracepoint.h using rcu_dereference_sched(). | |
97e1c18e | 266 | */ |
de7b2973 | 267 | rcu_assign_pointer(tp->funcs, tp_funcs); |
d25e37d8 SRV |
268 | tracepoint_update_call(tp, tp_funcs); |
269 | static_key_enable(&tp->key); | |
270 | ||
8058bd0f | 271 | release_probes(old); |
de7b2973 | 272 | return 0; |
97e1c18e MD |
273 | } |
274 | ||
275 | /* | |
de7b2973 | 276 | * Remove a probe function from a tracepoint. |
97e1c18e MD |
277 | * Note: only waiting an RCU period after setting elem->call to the empty |
278 | * function insures that the original callback is not used anymore. This insured | |
279 | * by preempt_disable around the call site. | |
280 | */ | |
de7b2973 MD |
281 | static int tracepoint_remove_func(struct tracepoint *tp, |
282 | struct tracepoint_func *func) | |
97e1c18e | 283 | { |
de7b2973 | 284 | struct tracepoint_func *old, *tp_funcs; |
97e1c18e | 285 | |
b725dfea MD |
286 | tp_funcs = rcu_dereference_protected(tp->funcs, |
287 | lockdep_is_held(&tracepoints_mutex)); | |
de7b2973 MD |
288 | old = func_remove(&tp_funcs, func); |
289 | if (IS_ERR(old)) { | |
d66a270b | 290 | WARN_ON_ONCE(PTR_ERR(old) != -ENOMEM); |
de7b2973 | 291 | return PTR_ERR(old); |
97e1c18e | 292 | } |
b75ef8b4 | 293 | |
de7b2973 MD |
294 | if (!tp_funcs) { |
295 | /* Removed last function */ | |
296 | if (tp->unregfunc && static_key_enabled(&tp->key)) | |
297 | tp->unregfunc(); | |
b75ef8b4 | 298 | |
d25e37d8 SRV |
299 | static_key_disable(&tp->key); |
300 | } else { | |
301 | tracepoint_update_call(tp, tp_funcs); | |
127cafbb | 302 | } |
d25e37d8 | 303 | |
de7b2973 | 304 | rcu_assign_pointer(tp->funcs, tp_funcs); |
8058bd0f | 305 | release_probes(old); |
de7b2973 | 306 | return 0; |
127cafbb LJ |
307 | } |
308 | ||
97e1c18e | 309 | /** |
f39e2391 | 310 | * tracepoint_probe_register_prio - Connect a probe to a tracepoint with priority |
de7b2973 | 311 | * @tp: tracepoint |
97e1c18e | 312 | * @probe: probe handler |
cac92ba7 | 313 | * @data: tracepoint data |
7904b5c4 | 314 | * @prio: priority of this function over other registered functions |
97e1c18e | 315 | * |
de7b2973 MD |
316 | * Returns 0 if ok, error value on error. |
317 | * Note: if @tp is within a module, the caller is responsible for | |
318 | * unregistering the probe before the module is gone. This can be | |
319 | * performed either with a tracepoint module going notifier, or from | |
320 | * within module exit functions. | |
97e1c18e | 321 | */ |
7904b5c4 SRRH |
322 | int tracepoint_probe_register_prio(struct tracepoint *tp, void *probe, |
323 | void *data, int prio) | |
97e1c18e | 324 | { |
de7b2973 MD |
325 | struct tracepoint_func tp_func; |
326 | int ret; | |
97e1c18e MD |
327 | |
328 | mutex_lock(&tracepoints_mutex); | |
de7b2973 MD |
329 | tp_func.func = probe; |
330 | tp_func.data = data; | |
7904b5c4 SRRH |
331 | tp_func.prio = prio; |
332 | ret = tracepoint_add_func(tp, &tp_func, prio); | |
b75ef8b4 | 333 | mutex_unlock(&tracepoints_mutex); |
b196e2b9 | 334 | return ret; |
97e1c18e | 335 | } |
7904b5c4 SRRH |
336 | EXPORT_SYMBOL_GPL(tracepoint_probe_register_prio); |
337 | ||
338 | /** | |
339 | * tracepoint_probe_register - Connect a probe to a tracepoint | |
340 | * @tp: tracepoint | |
341 | * @probe: probe handler | |
342 | * @data: tracepoint data | |
7904b5c4 SRRH |
343 | * |
344 | * Returns 0 if ok, error value on error. | |
345 | * Note: if @tp is within a module, the caller is responsible for | |
346 | * unregistering the probe before the module is gone. This can be | |
347 | * performed either with a tracepoint module going notifier, or from | |
348 | * within module exit functions. | |
349 | */ | |
350 | int tracepoint_probe_register(struct tracepoint *tp, void *probe, void *data) | |
351 | { | |
352 | return tracepoint_probe_register_prio(tp, probe, data, TRACEPOINT_DEFAULT_PRIO); | |
353 | } | |
97e1c18e MD |
354 | EXPORT_SYMBOL_GPL(tracepoint_probe_register); |
355 | ||
356 | /** | |
357 | * tracepoint_probe_unregister - Disconnect a probe from a tracepoint | |
de7b2973 | 358 | * @tp: tracepoint |
97e1c18e | 359 | * @probe: probe function pointer |
cac92ba7 | 360 | * @data: tracepoint data |
97e1c18e | 361 | * |
de7b2973 | 362 | * Returns 0 if ok, error value on error. |
97e1c18e | 363 | */ |
de7b2973 | 364 | int tracepoint_probe_unregister(struct tracepoint *tp, void *probe, void *data) |
97e1c18e | 365 | { |
de7b2973 MD |
366 | struct tracepoint_func tp_func; |
367 | int ret; | |
97e1c18e MD |
368 | |
369 | mutex_lock(&tracepoints_mutex); | |
de7b2973 MD |
370 | tp_func.func = probe; |
371 | tp_func.data = data; | |
372 | ret = tracepoint_remove_func(tp, &tp_func); | |
b75ef8b4 | 373 | mutex_unlock(&tracepoints_mutex); |
de7b2973 | 374 | return ret; |
97e1c18e MD |
375 | } |
376 | EXPORT_SYMBOL_GPL(tracepoint_probe_unregister); | |
377 | ||
9c0be3f6 MD |
378 | static void for_each_tracepoint_range( |
379 | tracepoint_ptr_t *begin, tracepoint_ptr_t *end, | |
46e0c9be AB |
380 | void (*fct)(struct tracepoint *tp, void *priv), |
381 | void *priv) | |
382 | { | |
9c0be3f6 MD |
383 | tracepoint_ptr_t *iter; |
384 | ||
46e0c9be AB |
385 | if (!begin) |
386 | return; | |
9c0be3f6 MD |
387 | for (iter = begin; iter < end; iter++) |
388 | fct(tracepoint_ptr_deref(iter), priv); | |
46e0c9be AB |
389 | } |
390 | ||
227a8375 | 391 | #ifdef CONFIG_MODULES |
45ab2813 SRRH |
392 | bool trace_module_has_bad_taint(struct module *mod) |
393 | { | |
66cc69e3 MD |
394 | return mod->taints & ~((1 << TAINT_OOT_MODULE) | (1 << TAINT_CRAP) | |
395 | (1 << TAINT_UNSIGNED_MODULE)); | |
45ab2813 SRRH |
396 | } |
397 | ||
de7b2973 MD |
398 | static BLOCKING_NOTIFIER_HEAD(tracepoint_notify_list); |
399 | ||
400 | /** | |
401 | * register_tracepoint_notifier - register tracepoint coming/going notifier | |
402 | * @nb: notifier block | |
403 | * | |
404 | * Notifiers registered with this function are called on module | |
405 | * coming/going with the tracepoint_module_list_mutex held. | |
406 | * The notifier block callback should expect a "struct tp_module" data | |
407 | * pointer. | |
408 | */ | |
409 | int register_tracepoint_module_notifier(struct notifier_block *nb) | |
410 | { | |
411 | struct tp_module *tp_mod; | |
412 | int ret; | |
413 | ||
414 | mutex_lock(&tracepoint_module_list_mutex); | |
415 | ret = blocking_notifier_chain_register(&tracepoint_notify_list, nb); | |
416 | if (ret) | |
417 | goto end; | |
418 | list_for_each_entry(tp_mod, &tracepoint_module_list, list) | |
419 | (void) nb->notifier_call(nb, MODULE_STATE_COMING, tp_mod); | |
420 | end: | |
421 | mutex_unlock(&tracepoint_module_list_mutex); | |
422 | return ret; | |
423 | } | |
424 | EXPORT_SYMBOL_GPL(register_tracepoint_module_notifier); | |
425 | ||
426 | /** | |
427 | * unregister_tracepoint_notifier - unregister tracepoint coming/going notifier | |
428 | * @nb: notifier block | |
429 | * | |
430 | * The notifier block callback should expect a "struct tp_module" data | |
431 | * pointer. | |
432 | */ | |
433 | int unregister_tracepoint_module_notifier(struct notifier_block *nb) | |
434 | { | |
435 | struct tp_module *tp_mod; | |
436 | int ret; | |
437 | ||
438 | mutex_lock(&tracepoint_module_list_mutex); | |
439 | ret = blocking_notifier_chain_unregister(&tracepoint_notify_list, nb); | |
440 | if (ret) | |
441 | goto end; | |
442 | list_for_each_entry(tp_mod, &tracepoint_module_list, list) | |
443 | (void) nb->notifier_call(nb, MODULE_STATE_GOING, tp_mod); | |
444 | end: | |
445 | mutex_unlock(&tracepoint_module_list_mutex); | |
446 | return ret; | |
447 | ||
448 | } | |
449 | EXPORT_SYMBOL_GPL(unregister_tracepoint_module_notifier); | |
450 | ||
451 | /* | |
452 | * Ensure the tracer unregistered the module's probes before the module | |
453 | * teardown is performed. Prevents leaks of probe and data pointers. | |
454 | */ | |
46e0c9be | 455 | static void tp_module_going_check_quiescent(struct tracepoint *tp, void *priv) |
de7b2973 | 456 | { |
46e0c9be | 457 | WARN_ON_ONCE(tp->funcs); |
de7b2973 MD |
458 | } |
459 | ||
b75ef8b4 MD |
460 | static int tracepoint_module_coming(struct module *mod) |
461 | { | |
0dea6d52 | 462 | struct tp_module *tp_mod; |
b75ef8b4 MD |
463 | int ret = 0; |
464 | ||
7dec935a SRRH |
465 | if (!mod->num_tracepoints) |
466 | return 0; | |
467 | ||
b75ef8b4 | 468 | /* |
c10076c4 SR |
469 | * We skip modules that taint the kernel, especially those with different |
470 | * module headers (for forced load), to make sure we don't cause a crash. | |
66cc69e3 | 471 | * Staging, out-of-tree, and unsigned GPL modules are fine. |
b75ef8b4 | 472 | */ |
45ab2813 | 473 | if (trace_module_has_bad_taint(mod)) |
b75ef8b4 | 474 | return 0; |
de7b2973 | 475 | mutex_lock(&tracepoint_module_list_mutex); |
b75ef8b4 MD |
476 | tp_mod = kmalloc(sizeof(struct tp_module), GFP_KERNEL); |
477 | if (!tp_mod) { | |
478 | ret = -ENOMEM; | |
479 | goto end; | |
480 | } | |
eb7d035c | 481 | tp_mod->mod = mod; |
0dea6d52 | 482 | list_add_tail(&tp_mod->list, &tracepoint_module_list); |
de7b2973 MD |
483 | blocking_notifier_call_chain(&tracepoint_notify_list, |
484 | MODULE_STATE_COMING, tp_mod); | |
b75ef8b4 | 485 | end: |
de7b2973 | 486 | mutex_unlock(&tracepoint_module_list_mutex); |
b75ef8b4 MD |
487 | return ret; |
488 | } | |
489 | ||
de7b2973 | 490 | static void tracepoint_module_going(struct module *mod) |
b75ef8b4 | 491 | { |
de7b2973 | 492 | struct tp_module *tp_mod; |
b75ef8b4 | 493 | |
7dec935a | 494 | if (!mod->num_tracepoints) |
de7b2973 | 495 | return; |
7dec935a | 496 | |
de7b2973 MD |
497 | mutex_lock(&tracepoint_module_list_mutex); |
498 | list_for_each_entry(tp_mod, &tracepoint_module_list, list) { | |
eb7d035c | 499 | if (tp_mod->mod == mod) { |
de7b2973 MD |
500 | blocking_notifier_call_chain(&tracepoint_notify_list, |
501 | MODULE_STATE_GOING, tp_mod); | |
502 | list_del(&tp_mod->list); | |
503 | kfree(tp_mod); | |
504 | /* | |
505 | * Called the going notifier before checking for | |
506 | * quiescence. | |
507 | */ | |
46e0c9be AB |
508 | for_each_tracepoint_range(mod->tracepoints_ptrs, |
509 | mod->tracepoints_ptrs + mod->num_tracepoints, | |
510 | tp_module_going_check_quiescent, NULL); | |
b75ef8b4 MD |
511 | break; |
512 | } | |
513 | } | |
514 | /* | |
515 | * In the case of modules that were tainted at "coming", we'll simply | |
516 | * walk through the list without finding it. We cannot use the "tainted" | |
517 | * flag on "going", in case a module taints the kernel only after being | |
518 | * loaded. | |
519 | */ | |
de7b2973 | 520 | mutex_unlock(&tracepoint_module_list_mutex); |
b75ef8b4 | 521 | } |
227a8375 | 522 | |
de7b2973 MD |
523 | static int tracepoint_module_notify(struct notifier_block *self, |
524 | unsigned long val, void *data) | |
32f85742 MD |
525 | { |
526 | struct module *mod = data; | |
b75ef8b4 | 527 | int ret = 0; |
32f85742 MD |
528 | |
529 | switch (val) { | |
530 | case MODULE_STATE_COMING: | |
b75ef8b4 MD |
531 | ret = tracepoint_module_coming(mod); |
532 | break; | |
533 | case MODULE_STATE_LIVE: | |
534 | break; | |
32f85742 | 535 | case MODULE_STATE_GOING: |
de7b2973 MD |
536 | tracepoint_module_going(mod); |
537 | break; | |
538 | case MODULE_STATE_UNFORMED: | |
32f85742 MD |
539 | break; |
540 | } | |
0340a6b7 | 541 | return notifier_from_errno(ret); |
32f85742 MD |
542 | } |
543 | ||
de7b2973 | 544 | static struct notifier_block tracepoint_module_nb = { |
32f85742 MD |
545 | .notifier_call = tracepoint_module_notify, |
546 | .priority = 0, | |
547 | }; | |
548 | ||
de7b2973 | 549 | static __init int init_tracepoints(void) |
32f85742 | 550 | { |
de7b2973 MD |
551 | int ret; |
552 | ||
553 | ret = register_module_notifier(&tracepoint_module_nb); | |
eb7d035c | 554 | if (ret) |
a395d6a7 | 555 | pr_warn("Failed to register tracepoint module enter notifier\n"); |
eb7d035c | 556 | |
de7b2973 | 557 | return ret; |
32f85742 MD |
558 | } |
559 | __initcall(init_tracepoints); | |
227a8375 | 560 | #endif /* CONFIG_MODULES */ |
a871bd33 | 561 | |
de7b2973 MD |
562 | /** |
563 | * for_each_kernel_tracepoint - iteration on all kernel tracepoints | |
564 | * @fct: callback | |
565 | * @priv: private data | |
566 | */ | |
567 | void for_each_kernel_tracepoint(void (*fct)(struct tracepoint *tp, void *priv), | |
568 | void *priv) | |
569 | { | |
570 | for_each_tracepoint_range(__start___tracepoints_ptrs, | |
571 | __stop___tracepoints_ptrs, fct, priv); | |
572 | } | |
573 | EXPORT_SYMBOL_GPL(for_each_kernel_tracepoint); | |
574 | ||
3d27d8cb | 575 | #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS |
60d970c2 | 576 | |
97419875 | 577 | /* NB: reg/unreg are called while guarded with the tracepoints_mutex */ |
a871bd33 JB |
578 | static int sys_tracepoint_refcount; |
579 | ||
8cf868af | 580 | int syscall_regfunc(void) |
a871bd33 | 581 | { |
8063e41d | 582 | struct task_struct *p, *t; |
a871bd33 | 583 | |
a871bd33 | 584 | if (!sys_tracepoint_refcount) { |
8063e41d ON |
585 | read_lock(&tasklist_lock); |
586 | for_each_process_thread(p, t) { | |
ea73c79e | 587 | set_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT); |
8063e41d ON |
588 | } |
589 | read_unlock(&tasklist_lock); | |
a871bd33 JB |
590 | } |
591 | sys_tracepoint_refcount++; | |
8cf868af SRRH |
592 | |
593 | return 0; | |
a871bd33 JB |
594 | } |
595 | ||
596 | void syscall_unregfunc(void) | |
597 | { | |
8063e41d | 598 | struct task_struct *p, *t; |
a871bd33 | 599 | |
a871bd33 JB |
600 | sys_tracepoint_refcount--; |
601 | if (!sys_tracepoint_refcount) { | |
8063e41d ON |
602 | read_lock(&tasklist_lock); |
603 | for_each_process_thread(p, t) { | |
66700001 | 604 | clear_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT); |
8063e41d ON |
605 | } |
606 | read_unlock(&tasklist_lock); | |
a871bd33 | 607 | } |
a871bd33 | 608 | } |
60d970c2 | 609 | #endif |