1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/module.h>
19#include <linux/mutex.h>
20#include <linux/types.h>
21#include <linux/jhash.h>
22#include <linux/list.h>
23#include <linux/rcupdate.h>
24#include <linux/tracepoint.h>
25#include <linux/err.h>
26#include <linux/slab.h>
27#include <linux/sched/signal.h>
28#include <linux/sched/task.h>
29#include <linux/static_key.h>
30
31extern struct tracepoint * const __start___tracepoints_ptrs[];
32extern struct tracepoint * const __stop___tracepoints_ptrs[];
33
34
35static const int tracepoint_debug;
36
37#ifdef CONFIG_MODULES
38
39
40
41static DEFINE_MUTEX(tracepoint_module_list_mutex);
42
43
44static LIST_HEAD(tracepoint_module_list);
45#endif
46
47
48
49
50
51static DEFINE_MUTEX(tracepoints_mutex);
52
53
54
55
56
57
58struct tp_probes {
59 struct rcu_head rcu;
60 struct tracepoint_func probes[0];
61};
62
63static inline void *allocate_probes(int count)
64{
65 struct tp_probes *p = kmalloc(count * sizeof(struct tracepoint_func)
66 + sizeof(struct tp_probes), GFP_KERNEL);
67 return p == NULL ? NULL : p->probes;
68}
69
70static void rcu_free_old_probes(struct rcu_head *head)
71{
72 kfree(container_of(head, struct tp_probes, rcu));
73}
74
75static inline void release_probes(struct tracepoint_func *old)
76{
77 if (old) {
78 struct tp_probes *tp_probes = container_of(old,
79 struct tp_probes, probes[0]);
80 call_rcu_sched(&tp_probes->rcu, rcu_free_old_probes);
81 }
82}
83
84static void debug_print_probes(struct tracepoint_func *funcs)
85{
86 int i;
87
88 if (!tracepoint_debug || !funcs)
89 return;
90
91 for (i = 0; funcs[i].func; i++)
92 printk(KERN_DEBUG "Probe %d : %p\n", i, funcs[i].func);
93}
94
95static struct tracepoint_func *
96func_add(struct tracepoint_func **funcs, struct tracepoint_func *tp_func,
97 int prio)
98{
99 struct tracepoint_func *old, *new;
100 int nr_probes = 0;
101 int pos = -1;
102
103 if (WARN_ON(!tp_func->func))
104 return ERR_PTR(-EINVAL);
105
106 debug_print_probes(*funcs);
107 old = *funcs;
108 if (old) {
109
110 for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
111
112 if (pos < 0 && old[nr_probes].prio < prio)
113 pos = nr_probes;
114 if (old[nr_probes].func == tp_func->func &&
115 old[nr_probes].data == tp_func->data)
116 return ERR_PTR(-EEXIST);
117 }
118 }
119
120 new = allocate_probes(nr_probes + 2);
121 if (new == NULL)
122 return ERR_PTR(-ENOMEM);
123 if (old) {
124 if (pos < 0) {
125 pos = nr_probes;
126 memcpy(new, old, nr_probes * sizeof(struct tracepoint_func));
127 } else {
128
129 memcpy(new, old, pos * sizeof(struct tracepoint_func));
130
131 memcpy(new + pos + 1, old + pos,
132 (nr_probes - pos) * sizeof(struct tracepoint_func));
133 }
134 } else
135 pos = 0;
136 new[pos] = *tp_func;
137 new[nr_probes + 1].func = NULL;
138 *funcs = new;
139 debug_print_probes(*funcs);
140 return old;
141}
142
143static void *func_remove(struct tracepoint_func **funcs,
144 struct tracepoint_func *tp_func)
145{
146 int nr_probes = 0, nr_del = 0, i;
147 struct tracepoint_func *old, *new;
148
149 old = *funcs;
150
151 if (!old)
152 return ERR_PTR(-ENOENT);
153
154 debug_print_probes(*funcs);
155
156 if (tp_func->func) {
157 for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
158 if (old[nr_probes].func == tp_func->func &&
159 old[nr_probes].data == tp_func->data)
160 nr_del++;
161 }
162 }
163
164
165
166
167
168 if (nr_probes - nr_del == 0) {
169
170 *funcs = NULL;
171 debug_print_probes(*funcs);
172 return old;
173 } else {
174 int j = 0;
175
176
177 new = allocate_probes(nr_probes - nr_del + 1);
178 if (new == NULL)
179 return ERR_PTR(-ENOMEM);
180 for (i = 0; old[i].func; i++)
181 if (old[i].func != tp_func->func
182 || old[i].data != tp_func->data)
183 new[j++] = old[i];
184 new[nr_probes - nr_del].func = NULL;
185 *funcs = new;
186 }
187 debug_print_probes(*funcs);
188 return old;
189}
190
191
192
193
194static int tracepoint_add_func(struct tracepoint *tp,
195 struct tracepoint_func *func, int prio)
196{
197 struct tracepoint_func *old, *tp_funcs;
198 int ret;
199
200 if (tp->regfunc && !static_key_enabled(&tp->key)) {
201 ret = tp->regfunc();
202 if (ret < 0)
203 return ret;
204 }
205
206 tp_funcs = rcu_dereference_protected(tp->funcs,
207 lockdep_is_held(&tracepoints_mutex));
208 old = func_add(&tp_funcs, func, prio);
209 if (IS_ERR(old)) {
210 WARN_ON_ONCE(PTR_ERR(old) != -ENOMEM);
211 return PTR_ERR(old);
212 }
213
214
215
216
217
218
219
220 rcu_assign_pointer(tp->funcs, tp_funcs);
221 if (!static_key_enabled(&tp->key))
222 static_key_slow_inc(&tp->key);
223 release_probes(old);
224 return 0;
225}
226
227
228
229
230
231
232
233static int tracepoint_remove_func(struct tracepoint *tp,
234 struct tracepoint_func *func)
235{
236 struct tracepoint_func *old, *tp_funcs;
237
238 tp_funcs = rcu_dereference_protected(tp->funcs,
239 lockdep_is_held(&tracepoints_mutex));
240 old = func_remove(&tp_funcs, func);
241 if (IS_ERR(old)) {
242 WARN_ON_ONCE(PTR_ERR(old) != -ENOMEM);
243 return PTR_ERR(old);
244 }
245
246 if (!tp_funcs) {
247
248 if (tp->unregfunc && static_key_enabled(&tp->key))
249 tp->unregfunc();
250
251 if (static_key_enabled(&tp->key))
252 static_key_slow_dec(&tp->key);
253 }
254 rcu_assign_pointer(tp->funcs, tp_funcs);
255 release_probes(old);
256 return 0;
257}
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272int tracepoint_probe_register_prio(struct tracepoint *tp, void *probe,
273 void *data, int prio)
274{
275 struct tracepoint_func tp_func;
276 int ret;
277
278 mutex_lock(&tracepoints_mutex);
279 tp_func.func = probe;
280 tp_func.data = data;
281 tp_func.prio = prio;
282 ret = tracepoint_add_func(tp, &tp_func, prio);
283 mutex_unlock(&tracepoints_mutex);
284 return ret;
285}
286EXPORT_SYMBOL_GPL(tracepoint_probe_register_prio);
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301int tracepoint_probe_register(struct tracepoint *tp, void *probe, void *data)
302{
303 return tracepoint_probe_register_prio(tp, probe, data, TRACEPOINT_DEFAULT_PRIO);
304}
305EXPORT_SYMBOL_GPL(tracepoint_probe_register);
306
307
308
309
310
311
312
313
314
315int tracepoint_probe_unregister(struct tracepoint *tp, void *probe, void *data)
316{
317 struct tracepoint_func tp_func;
318 int ret;
319
320 mutex_lock(&tracepoints_mutex);
321 tp_func.func = probe;
322 tp_func.data = data;
323 ret = tracepoint_remove_func(tp, &tp_func);
324 mutex_unlock(&tracepoints_mutex);
325 return ret;
326}
327EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
328
329#ifdef CONFIG_MODULES
330bool trace_module_has_bad_taint(struct module *mod)
331{
332 return mod->taints & ~((1 << TAINT_OOT_MODULE) | (1 << TAINT_CRAP) |
333 (1 << TAINT_UNSIGNED_MODULE));
334}
335
336static BLOCKING_NOTIFIER_HEAD(tracepoint_notify_list);
337
338
339
340
341
342
343
344
345
346
347int register_tracepoint_module_notifier(struct notifier_block *nb)
348{
349 struct tp_module *tp_mod;
350 int ret;
351
352 mutex_lock(&tracepoint_module_list_mutex);
353 ret = blocking_notifier_chain_register(&tracepoint_notify_list, nb);
354 if (ret)
355 goto end;
356 list_for_each_entry(tp_mod, &tracepoint_module_list, list)
357 (void) nb->notifier_call(nb, MODULE_STATE_COMING, tp_mod);
358end:
359 mutex_unlock(&tracepoint_module_list_mutex);
360 return ret;
361}
362EXPORT_SYMBOL_GPL(register_tracepoint_module_notifier);
363
364
365
366
367
368
369
370
371int unregister_tracepoint_module_notifier(struct notifier_block *nb)
372{
373 struct tp_module *tp_mod;
374 int ret;
375
376 mutex_lock(&tracepoint_module_list_mutex);
377 ret = blocking_notifier_chain_unregister(&tracepoint_notify_list, nb);
378 if (ret)
379 goto end;
380 list_for_each_entry(tp_mod, &tracepoint_module_list, list)
381 (void) nb->notifier_call(nb, MODULE_STATE_GOING, tp_mod);
382end:
383 mutex_unlock(&tracepoint_module_list_mutex);
384 return ret;
385
386}
387EXPORT_SYMBOL_GPL(unregister_tracepoint_module_notifier);
388
389
390
391
392
393static void tp_module_going_check_quiescent(struct tracepoint * const *begin,
394 struct tracepoint * const *end)
395{
396 struct tracepoint * const *iter;
397
398 if (!begin)
399 return;
400 for (iter = begin; iter < end; iter++)
401 WARN_ON_ONCE((*iter)->funcs);
402}
403
404static int tracepoint_module_coming(struct module *mod)
405{
406 struct tp_module *tp_mod;
407 int ret = 0;
408
409 if (!mod->num_tracepoints)
410 return 0;
411
412
413
414
415
416
417 if (trace_module_has_bad_taint(mod))
418 return 0;
419 mutex_lock(&tracepoint_module_list_mutex);
420 tp_mod = kmalloc(sizeof(struct tp_module), GFP_KERNEL);
421 if (!tp_mod) {
422 ret = -ENOMEM;
423 goto end;
424 }
425 tp_mod->mod = mod;
426 list_add_tail(&tp_mod->list, &tracepoint_module_list);
427 blocking_notifier_call_chain(&tracepoint_notify_list,
428 MODULE_STATE_COMING, tp_mod);
429end:
430 mutex_unlock(&tracepoint_module_list_mutex);
431 return ret;
432}
433
434static void tracepoint_module_going(struct module *mod)
435{
436 struct tp_module *tp_mod;
437
438 if (!mod->num_tracepoints)
439 return;
440
441 mutex_lock(&tracepoint_module_list_mutex);
442 list_for_each_entry(tp_mod, &tracepoint_module_list, list) {
443 if (tp_mod->mod == mod) {
444 blocking_notifier_call_chain(&tracepoint_notify_list,
445 MODULE_STATE_GOING, tp_mod);
446 list_del(&tp_mod->list);
447 kfree(tp_mod);
448
449
450
451
452 tp_module_going_check_quiescent(mod->tracepoints_ptrs,
453 mod->tracepoints_ptrs + mod->num_tracepoints);
454 break;
455 }
456 }
457
458
459
460
461
462
463 mutex_unlock(&tracepoint_module_list_mutex);
464}
465
466static int tracepoint_module_notify(struct notifier_block *self,
467 unsigned long val, void *data)
468{
469 struct module *mod = data;
470 int ret = 0;
471
472 switch (val) {
473 case MODULE_STATE_COMING:
474 ret = tracepoint_module_coming(mod);
475 break;
476 case MODULE_STATE_LIVE:
477 break;
478 case MODULE_STATE_GOING:
479 tracepoint_module_going(mod);
480 break;
481 case MODULE_STATE_UNFORMED:
482 break;
483 }
484 return ret;
485}
486
487static struct notifier_block tracepoint_module_nb = {
488 .notifier_call = tracepoint_module_notify,
489 .priority = 0,
490};
491
492static __init int init_tracepoints(void)
493{
494 int ret;
495
496 ret = register_module_notifier(&tracepoint_module_nb);
497 if (ret)
498 pr_warn("Failed to register tracepoint module enter notifier\n");
499
500 return ret;
501}
502__initcall(init_tracepoints);
503#endif
504
505static void for_each_tracepoint_range(struct tracepoint * const *begin,
506 struct tracepoint * const *end,
507 void (*fct)(struct tracepoint *tp, void *priv),
508 void *priv)
509{
510 struct tracepoint * const *iter;
511
512 if (!begin)
513 return;
514 for (iter = begin; iter < end; iter++)
515 fct(*iter, priv);
516}
517
518
519
520
521
522
523void for_each_kernel_tracepoint(void (*fct)(struct tracepoint *tp, void *priv),
524 void *priv)
525{
526 for_each_tracepoint_range(__start___tracepoints_ptrs,
527 __stop___tracepoints_ptrs, fct, priv);
528}
529EXPORT_SYMBOL_GPL(for_each_kernel_tracepoint);
530
531#ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
532
533
534static int sys_tracepoint_refcount;
535
536int syscall_regfunc(void)
537{
538 struct task_struct *p, *t;
539
540 if (!sys_tracepoint_refcount) {
541 read_lock(&tasklist_lock);
542 for_each_process_thread(p, t) {
543 set_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
544 }
545 read_unlock(&tasklist_lock);
546 }
547 sys_tracepoint_refcount++;
548
549 return 0;
550}
551
552void syscall_unregfunc(void)
553{
554 struct task_struct *p, *t;
555
556 sys_tracepoint_refcount--;
557 if (!sys_tracepoint_refcount) {
558 read_lock(&tasklist_lock);
559 for_each_process_thread(p, t) {
560 clear_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
561 }
562 read_unlock(&tasklist_lock);
563 }
564}
565#endif
566