Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Infrastructure for profiling code inserted by 'gcc -pg'.
4 : : *
5 : : * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
6 : : * Copyright (C) 2004-2008 Ingo Molnar <mingo@redhat.com>
7 : : *
8 : : * Originally ported from the -rt patch by:
9 : : * Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com>
10 : : *
11 : : * Based on code in the latency_tracer, that is:
12 : : *
13 : : * Copyright (C) 2004-2006 Ingo Molnar
14 : : * Copyright (C) 2004 Nadia Yvette Chambers
15 : : */
16 : :
17 : : #include <linux/stop_machine.h>
18 : : #include <linux/clocksource.h>
19 : : #include <linux/sched/task.h>
20 : : #include <linux/kallsyms.h>
21 : : #include <linux/security.h>
22 : : #include <linux/seq_file.h>
23 : : #include <linux/tracefs.h>
24 : : #include <linux/hardirq.h>
25 : : #include <linux/kthread.h>
26 : : #include <linux/uaccess.h>
27 : : #include <linux/bsearch.h>
28 : : #include <linux/module.h>
29 : : #include <linux/ftrace.h>
30 : : #include <linux/sysctl.h>
31 : : #include <linux/slab.h>
32 : : #include <linux/ctype.h>
33 : : #include <linux/sort.h>
34 : : #include <linux/list.h>
35 : : #include <linux/hash.h>
36 : : #include <linux/rcupdate.h>
37 : : #include <linux/kprobes.h>
38 : :
39 : : #include <trace/events/sched.h>
40 : :
41 : : #include <asm/sections.h>
42 : : #include <asm/setup.h>
43 : :
44 : : #include "ftrace_internal.h"
45 : : #include "trace_output.h"
46 : : #include "trace_stat.h"
47 : :
48 : : #define FTRACE_WARN_ON(cond) \
49 : : ({ \
50 : : int ___r = cond; \
51 : : if (WARN_ON(___r)) \
52 : : ftrace_kill(); \
53 : : ___r; \
54 : : })
55 : :
56 : : #define FTRACE_WARN_ON_ONCE(cond) \
57 : : ({ \
58 : : int ___r = cond; \
59 : : if (WARN_ON_ONCE(___r)) \
60 : : ftrace_kill(); \
61 : : ___r; \
62 : : })
63 : :
64 : : /* hash bits for specific function selection */
65 : : #define FTRACE_HASH_BITS 7
66 : : #define FTRACE_FUNC_HASHSIZE (1 << FTRACE_HASH_BITS)
67 : : #define FTRACE_HASH_DEFAULT_BITS 10
68 : : #define FTRACE_HASH_MAX_BITS 12
69 : :
70 : : #ifdef CONFIG_DYNAMIC_FTRACE
71 : : #define INIT_OPS_HASH(opsname) \
72 : : .func_hash = &opsname.local_hash, \
73 : : .local_hash.regex_lock = __MUTEX_INITIALIZER(opsname.local_hash.regex_lock),
74 : : #else
75 : : #define INIT_OPS_HASH(opsname)
76 : : #endif
77 : :
78 : : enum {
79 : : FTRACE_MODIFY_ENABLE_FL = (1 << 0),
80 : : FTRACE_MODIFY_MAY_SLEEP_FL = (1 << 1),
81 : : };
82 : :
83 : : struct ftrace_ops ftrace_list_end __read_mostly = {
84 : : .func = ftrace_stub,
85 : : .flags = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_STUB,
86 : : INIT_OPS_HASH(ftrace_list_end)
87 : : };
88 : :
89 : : /* ftrace_enabled is a method to turn ftrace on or off */
90 : : int ftrace_enabled __read_mostly;
91 : : static int last_ftrace_enabled;
92 : :
93 : : /* Current function tracing op */
94 : : struct ftrace_ops *function_trace_op __read_mostly = &ftrace_list_end;
95 : : /* What to set function_trace_op to */
96 : : static struct ftrace_ops *set_function_trace_op;
97 : :
98 : : static bool ftrace_pids_enabled(struct ftrace_ops *ops)
99 : : {
100 : : struct trace_array *tr;
101 : :
102 : 0 : if (!(ops->flags & FTRACE_OPS_FL_PID) || !ops->private)
103 : : return false;
104 : :
105 : : tr = ops->private;
106 : :
107 : 0 : return tr->function_pids != NULL;
108 : : }
109 : :
110 : : static void ftrace_update_trampoline(struct ftrace_ops *ops);
111 : :
112 : : /*
113 : : * ftrace_disabled is set when an anomaly is discovered.
114 : : * ftrace_disabled is much stronger than ftrace_enabled.
115 : : */
116 : : static int ftrace_disabled __read_mostly;
117 : :
118 : : DEFINE_MUTEX(ftrace_lock);
119 : :
120 : : struct ftrace_ops __rcu *ftrace_ops_list __read_mostly = &ftrace_list_end;
121 : : ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
122 : : struct ftrace_ops global_ops;
123 : :
124 : : #if ARCH_SUPPORTS_FTRACE_OPS
125 : : static void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
126 : : struct ftrace_ops *op, struct pt_regs *regs);
127 : : #else
128 : : /* See comment below, where ftrace_ops_list_func is defined */
129 : : static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip);
130 : : #define ftrace_ops_list_func ((ftrace_func_t)ftrace_ops_no_ops)
131 : : #endif
132 : :
133 : 0 : static inline void ftrace_ops_init(struct ftrace_ops *ops)
134 : : {
135 : : #ifdef CONFIG_DYNAMIC_FTRACE
136 : 0 : if (!(ops->flags & FTRACE_OPS_FL_INITIALIZED)) {
137 : 0 : mutex_init(&ops->local_hash.regex_lock);
138 : 0 : ops->func_hash = &ops->local_hash;
139 : 0 : ops->flags |= FTRACE_OPS_FL_INITIALIZED;
140 : : }
141 : : #endif
142 : 0 : }
143 : :
144 : 0 : static void ftrace_pid_func(unsigned long ip, unsigned long parent_ip,
145 : : struct ftrace_ops *op, struct pt_regs *regs)
146 : : {
147 : 0 : struct trace_array *tr = op->private;
148 : :
149 : 0 : if (tr && this_cpu_read(tr->trace_buffer.data->ftrace_ignore_pid))
150 : 0 : return;
151 : :
152 : 0 : op->saved_func(ip, parent_ip, op, regs);
153 : : }
154 : :
155 : 0 : static void ftrace_sync(struct work_struct *work)
156 : : {
157 : : /*
158 : : * This function is just a stub to implement a hard force
159 : : * of synchronize_rcu(). This requires synchronizing
160 : : * tasks even in userspace and idle.
161 : : *
162 : : * Yes, function tracing is rude.
163 : : */
164 : 0 : }
165 : :
166 : 0 : static void ftrace_sync_ipi(void *data)
167 : : {
168 : : /* Probably not needed, but do it anyway */
169 : 0 : smp_rmb();
170 : 0 : }
171 : :
172 : : static ftrace_func_t ftrace_ops_get_list_func(struct ftrace_ops *ops)
173 : : {
174 : : /*
175 : : * If this is a dynamic, RCU, or per CPU ops, or we force list func,
176 : : * then it needs to call the list anyway.
177 : : */
178 : 0 : if (ops->flags & (FTRACE_OPS_FL_DYNAMIC | FTRACE_OPS_FL_RCU) ||
179 : : FTRACE_FORCE_LIST_FUNC)
180 : : return ftrace_ops_list_func;
181 : :
182 : : return ftrace_ops_get_func(ops);
183 : : }
184 : :
185 : 0 : static void update_ftrace_function(void)
186 : : {
187 : : ftrace_func_t func;
188 : :
189 : : /*
190 : : * Prepare the ftrace_ops that the arch callback will use.
191 : : * If there's only one ftrace_ops registered, the ftrace_ops_list
192 : : * will point to the ops we want.
193 : : */
194 : 0 : set_function_trace_op = rcu_dereference_protected(ftrace_ops_list,
195 : : lockdep_is_held(&ftrace_lock));
196 : :
197 : : /* If there's no ftrace_ops registered, just call the stub function */
198 : 0 : if (set_function_trace_op == &ftrace_list_end) {
199 : : func = ftrace_stub;
200 : :
201 : : /*
202 : : * If we are at the end of the list and this ops is
203 : : * recursion safe and not dynamic and the arch supports passing ops,
204 : : * then have the mcount trampoline call the function directly.
205 : : */
206 : 0 : } else if (rcu_dereference_protected(ftrace_ops_list->next,
207 : : lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
208 : : func = ftrace_ops_get_list_func(ftrace_ops_list);
209 : :
210 : : } else {
211 : : /* Just use the default ftrace_ops */
212 : 0 : set_function_trace_op = &ftrace_list_end;
213 : : func = ftrace_ops_list_func;
214 : : }
215 : :
216 : 0 : update_function_graph_func();
217 : :
218 : : /* If there's no change, then do nothing more here */
219 : 0 : if (ftrace_trace_function == func)
220 : : return;
221 : :
222 : : /*
223 : : * If we are using the list function, it doesn't care
224 : : * about the function_trace_ops.
225 : : */
226 : 0 : if (func == ftrace_ops_list_func) {
227 : 0 : ftrace_trace_function = func;
228 : : /*
229 : : * Don't even bother setting function_trace_ops,
230 : : * it would be racy to do so anyway.
231 : : */
232 : 0 : return;
233 : : }
234 : :
235 : : #ifndef CONFIG_DYNAMIC_FTRACE
236 : : /*
237 : : * For static tracing, we need to be a bit more careful.
238 : : * The function change takes affect immediately. Thus,
239 : : * we need to coorditate the setting of the function_trace_ops
240 : : * with the setting of the ftrace_trace_function.
241 : : *
242 : : * Set the function to the list ops, which will call the
243 : : * function we want, albeit indirectly, but it handles the
244 : : * ftrace_ops and doesn't depend on function_trace_op.
245 : : */
246 : : ftrace_trace_function = ftrace_ops_list_func;
247 : : /*
248 : : * Make sure all CPUs see this. Yes this is slow, but static
249 : : * tracing is slow and nasty to have enabled.
250 : : */
251 : : schedule_on_each_cpu(ftrace_sync);
252 : : /* Now all cpus are using the list ops. */
253 : : function_trace_op = set_function_trace_op;
254 : : /* Make sure the function_trace_op is visible on all CPUs */
255 : : smp_wmb();
256 : : /* Nasty way to force a rmb on all cpus */
257 : : smp_call_function(ftrace_sync_ipi, NULL, 1);
258 : : /* OK, we are all set to update the ftrace_trace_function now! */
259 : : #endif /* !CONFIG_DYNAMIC_FTRACE */
260 : :
261 : 0 : ftrace_trace_function = func;
262 : : }
263 : :
264 : : static void add_ftrace_ops(struct ftrace_ops __rcu **list,
265 : : struct ftrace_ops *ops)
266 : : {
267 : 0 : rcu_assign_pointer(ops->next, *list);
268 : :
269 : : /*
270 : : * We are entering ops into the list but another
271 : : * CPU might be walking that list. We need to make sure
272 : : * the ops->next pointer is valid before another CPU sees
273 : : * the ops pointer included into the list.
274 : : */
275 : 0 : rcu_assign_pointer(*list, ops);
276 : : }
277 : :
278 : : static int remove_ftrace_ops(struct ftrace_ops __rcu **list,
279 : : struct ftrace_ops *ops)
280 : : {
281 : : struct ftrace_ops **p;
282 : :
283 : : /*
284 : : * If we are removing the last function, then simply point
285 : : * to the ftrace_stub.
286 : : */
287 : 0 : if (rcu_dereference_protected(*list,
288 : 0 : lockdep_is_held(&ftrace_lock)) == ops &&
289 : 0 : rcu_dereference_protected(ops->next,
290 : : lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
291 : 0 : *list = &ftrace_list_end;
292 : : return 0;
293 : : }
294 : :
295 : 0 : for (p = list; *p != &ftrace_list_end; p = &(*p)->next)
296 : 0 : if (*p == ops)
297 : : break;
298 : :
299 : 0 : if (*p != ops)
300 : : return -1;
301 : :
302 : 0 : *p = (*p)->next;
303 : : return 0;
304 : : }
305 : :
306 : : static void ftrace_update_trampoline(struct ftrace_ops *ops);
307 : :
308 : 0 : int __register_ftrace_function(struct ftrace_ops *ops)
309 : : {
310 : 0 : if (ops->flags & FTRACE_OPS_FL_DELETED)
311 : : return -EINVAL;
312 : :
313 : 0 : if (WARN_ON(ops->flags & FTRACE_OPS_FL_ENABLED))
314 : : return -EBUSY;
315 : :
316 : : #ifndef CONFIG_DYNAMIC_FTRACE_WITH_REGS
317 : : /*
318 : : * If the ftrace_ops specifies SAVE_REGS, then it only can be used
319 : : * if the arch supports it, or SAVE_REGS_IF_SUPPORTED is also set.
320 : : * Setting SAVE_REGS_IF_SUPPORTED makes SAVE_REGS irrelevant.
321 : : */
322 : : if (ops->flags & FTRACE_OPS_FL_SAVE_REGS &&
323 : : !(ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED))
324 : : return -EINVAL;
325 : :
326 : : if (ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED)
327 : : ops->flags |= FTRACE_OPS_FL_SAVE_REGS;
328 : : #endif
329 : :
330 : 0 : if (!core_kernel_data((unsigned long)ops))
331 : 0 : ops->flags |= FTRACE_OPS_FL_DYNAMIC;
332 : :
333 : : add_ftrace_ops(&ftrace_ops_list, ops);
334 : :
335 : : /* Always save the function, and reset at unregistering */
336 : 0 : ops->saved_func = ops->func;
337 : :
338 : 0 : if (ftrace_pids_enabled(ops))
339 : 0 : ops->func = ftrace_pid_func;
340 : :
341 : : ftrace_update_trampoline(ops);
342 : :
343 : 0 : if (ftrace_enabled)
344 : 0 : update_ftrace_function();
345 : :
346 : : return 0;
347 : : }
348 : :
349 : 0 : int __unregister_ftrace_function(struct ftrace_ops *ops)
350 : : {
351 : : int ret;
352 : :
353 : 0 : if (WARN_ON(!(ops->flags & FTRACE_OPS_FL_ENABLED)))
354 : : return -EBUSY;
355 : :
356 : : ret = remove_ftrace_ops(&ftrace_ops_list, ops);
357 : :
358 : 0 : if (ret < 0)
359 : : return ret;
360 : :
361 : 0 : if (ftrace_enabled)
362 : 0 : update_ftrace_function();
363 : :
364 : 0 : ops->func = ops->saved_func;
365 : :
366 : 0 : return 0;
367 : : }
368 : :
369 : 0 : static void ftrace_update_pid_func(void)
370 : : {
371 : : struct ftrace_ops *op;
372 : :
373 : : /* Only do something if we are tracing something */
374 : 0 : if (ftrace_trace_function == ftrace_stub)
375 : 0 : return;
376 : :
377 : 0 : do_for_each_ftrace_op(op, ftrace_ops_list) {
378 : 0 : if (op->flags & FTRACE_OPS_FL_PID) {
379 : 0 : op->func = ftrace_pids_enabled(op) ?
380 : 0 : ftrace_pid_func : op->saved_func;
381 : : ftrace_update_trampoline(op);
382 : : }
383 : 0 : } while_for_each_ftrace_op(op);
384 : :
385 : 0 : update_ftrace_function();
386 : : }
387 : :
388 : : #ifdef CONFIG_FUNCTION_PROFILER
389 : : struct ftrace_profile {
390 : : struct hlist_node node;
391 : : unsigned long ip;
392 : : unsigned long counter;
393 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
394 : : unsigned long long time;
395 : : unsigned long long time_squared;
396 : : #endif
397 : : };
398 : :
399 : : struct ftrace_profile_page {
400 : : struct ftrace_profile_page *next;
401 : : unsigned long index;
402 : : struct ftrace_profile records[];
403 : : };
404 : :
405 : : struct ftrace_profile_stat {
406 : : atomic_t disabled;
407 : : struct hlist_head *hash;
408 : : struct ftrace_profile_page *pages;
409 : : struct ftrace_profile_page *start;
410 : : struct tracer_stat stat;
411 : : };
412 : :
413 : : #define PROFILE_RECORDS_SIZE \
414 : : (PAGE_SIZE - offsetof(struct ftrace_profile_page, records))
415 : :
416 : : #define PROFILES_PER_PAGE \
417 : : (PROFILE_RECORDS_SIZE / sizeof(struct ftrace_profile))
418 : :
419 : : static int ftrace_profile_enabled __read_mostly;
420 : :
421 : : /* ftrace_profile_lock - synchronize the enable and disable of the profiler */
422 : : static DEFINE_MUTEX(ftrace_profile_lock);
423 : :
424 : : static DEFINE_PER_CPU(struct ftrace_profile_stat, ftrace_profile_stats);
425 : :
426 : : #define FTRACE_PROFILE_HASH_BITS 10
427 : : #define FTRACE_PROFILE_HASH_SIZE (1 << FTRACE_PROFILE_HASH_BITS)
428 : :
429 : : static void *
430 : 0 : function_stat_next(void *v, int idx)
431 : : {
432 : : struct ftrace_profile *rec = v;
433 : : struct ftrace_profile_page *pg;
434 : :
435 : 0 : pg = (struct ftrace_profile_page *)((unsigned long)rec & PAGE_MASK);
436 : :
437 : : again:
438 : 0 : if (idx != 0)
439 : 0 : rec++;
440 : :
441 : 0 : if ((void *)rec >= (void *)&pg->records[pg->index]) {
442 : 0 : pg = pg->next;
443 : 0 : if (!pg)
444 : : return NULL;
445 : 0 : rec = &pg->records[0];
446 : 0 : if (!rec->counter)
447 : : goto again;
448 : : }
449 : :
450 : 0 : return rec;
451 : : }
452 : :
453 : 0 : static void *function_stat_start(struct tracer_stat *trace)
454 : : {
455 : : struct ftrace_profile_stat *stat =
456 : 0 : container_of(trace, struct ftrace_profile_stat, stat);
457 : :
458 : 0 : if (!stat || !stat->start)
459 : : return NULL;
460 : :
461 : 0 : return function_stat_next(&stat->start->records[0], 0);
462 : : }
463 : :
464 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
465 : : /* function graph compares on total time */
466 : 0 : static int function_stat_cmp(void *p1, void *p2)
467 : : {
468 : : struct ftrace_profile *a = p1;
469 : : struct ftrace_profile *b = p2;
470 : :
471 : 0 : if (a->time < b->time)
472 : : return -1;
473 : 0 : if (a->time > b->time)
474 : : return 1;
475 : : else
476 : 0 : return 0;
477 : : }
478 : : #else
479 : : /* not function graph compares against hits */
480 : : static int function_stat_cmp(void *p1, void *p2)
481 : : {
482 : : struct ftrace_profile *a = p1;
483 : : struct ftrace_profile *b = p2;
484 : :
485 : : if (a->counter < b->counter)
486 : : return -1;
487 : : if (a->counter > b->counter)
488 : : return 1;
489 : : else
490 : : return 0;
491 : : }
492 : : #endif
493 : :
494 : 0 : static int function_stat_headers(struct seq_file *m)
495 : : {
496 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
497 : 0 : seq_puts(m, " Function "
498 : : "Hit Time Avg s^2\n"
499 : : " -------- "
500 : : "--- ---- --- ---\n");
501 : : #else
502 : : seq_puts(m, " Function Hit\n"
503 : : " -------- ---\n");
504 : : #endif
505 : 0 : return 0;
506 : : }
507 : :
508 : 0 : static int function_stat_show(struct seq_file *m, void *v)
509 : : {
510 : : struct ftrace_profile *rec = v;
511 : : char str[KSYM_SYMBOL_LEN];
512 : : int ret = 0;
513 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
514 : : static struct trace_seq s;
515 : : unsigned long long avg;
516 : : unsigned long long stddev;
517 : : #endif
518 : 0 : mutex_lock(&ftrace_profile_lock);
519 : :
520 : : /* we raced with function_profile_reset() */
521 : 0 : if (unlikely(rec->counter == 0)) {
522 : : ret = -EBUSY;
523 : : goto out;
524 : : }
525 : :
526 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
527 : 0 : avg = div64_ul(rec->time, rec->counter);
528 : 0 : if (tracing_thresh && (avg < tracing_thresh))
529 : : goto out;
530 : : #endif
531 : :
532 : 0 : kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
533 : 0 : seq_printf(m, " %-30.30s %10lu", str, rec->counter);
534 : :
535 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
536 : 0 : seq_puts(m, " ");
537 : :
538 : : /* Sample standard deviation (s^2) */
539 : 0 : if (rec->counter <= 1)
540 : : stddev = 0;
541 : : else {
542 : : /*
543 : : * Apply Welford's method:
544 : : * s^2 = 1 / (n * (n-1)) * (n * \Sum (x_i)^2 - (\Sum x_i)^2)
545 : : */
546 : 0 : stddev = rec->counter * rec->time_squared -
547 : 0 : rec->time * rec->time;
548 : :
549 : : /*
550 : : * Divide only 1000 for ns^2 -> us^2 conversion.
551 : : * trace_print_graph_duration will divide 1000 again.
552 : : */
553 : 0 : stddev = div64_ul(stddev,
554 : : rec->counter * (rec->counter - 1) * 1000);
555 : : }
556 : :
557 : : trace_seq_init(&s);
558 : 0 : trace_print_graph_duration(rec->time, &s);
559 : 0 : trace_seq_puts(&s, " ");
560 : 0 : trace_print_graph_duration(avg, &s);
561 : 0 : trace_seq_puts(&s, " ");
562 : 0 : trace_print_graph_duration(stddev, &s);
563 : 0 : trace_print_seq(m, &s);
564 : : #endif
565 : 0 : seq_putc(m, '\n');
566 : : out:
567 : 0 : mutex_unlock(&ftrace_profile_lock);
568 : :
569 : 0 : return ret;
570 : : }
571 : :
572 : 0 : static void ftrace_profile_reset(struct ftrace_profile_stat *stat)
573 : : {
574 : : struct ftrace_profile_page *pg;
575 : :
576 : 0 : pg = stat->pages = stat->start;
577 : :
578 : 0 : while (pg) {
579 : 0 : memset(pg->records, 0, PROFILE_RECORDS_SIZE);
580 : 0 : pg->index = 0;
581 : 0 : pg = pg->next;
582 : : }
583 : :
584 : 0 : memset(stat->hash, 0,
585 : : FTRACE_PROFILE_HASH_SIZE * sizeof(struct hlist_head));
586 : 0 : }
587 : :
588 : 0 : int ftrace_profile_pages_init(struct ftrace_profile_stat *stat)
589 : : {
590 : : struct ftrace_profile_page *pg;
591 : : int functions;
592 : : int pages;
593 : : int i;
594 : :
595 : : /* If we already allocated, do nothing */
596 : 0 : if (stat->pages)
597 : : return 0;
598 : :
599 : 0 : stat->pages = (void *)get_zeroed_page(GFP_KERNEL);
600 : 0 : if (!stat->pages)
601 : : return -ENOMEM;
602 : :
603 : : #ifdef CONFIG_DYNAMIC_FTRACE
604 : 0 : functions = ftrace_update_tot_cnt;
605 : : #else
606 : : /*
607 : : * We do not know the number of functions that exist because
608 : : * dynamic tracing is what counts them. With past experience
609 : : * we have around 20K functions. That should be more than enough.
610 : : * It is highly unlikely we will execute every function in
611 : : * the kernel.
612 : : */
613 : : functions = 20000;
614 : : #endif
615 : :
616 : 0 : pg = stat->start = stat->pages;
617 : :
618 : 0 : pages = DIV_ROUND_UP(functions, PROFILES_PER_PAGE);
619 : :
620 : 0 : for (i = 1; i < pages; i++) {
621 : 0 : pg->next = (void *)get_zeroed_page(GFP_KERNEL);
622 : 0 : if (!pg->next)
623 : : goto out_free;
624 : : pg = pg->next;
625 : : }
626 : :
627 : : return 0;
628 : :
629 : : out_free:
630 : 0 : pg = stat->start;
631 : 0 : while (pg) {
632 : 0 : unsigned long tmp = (unsigned long)pg;
633 : :
634 : 0 : pg = pg->next;
635 : 0 : free_page(tmp);
636 : : }
637 : :
638 : 0 : stat->pages = NULL;
639 : 0 : stat->start = NULL;
640 : :
641 : 0 : return -ENOMEM;
642 : : }
643 : :
644 : 0 : static int ftrace_profile_init_cpu(int cpu)
645 : : {
646 : : struct ftrace_profile_stat *stat;
647 : : int size;
648 : :
649 : 0 : stat = &per_cpu(ftrace_profile_stats, cpu);
650 : :
651 : 0 : if (stat->hash) {
652 : : /* If the profile is already created, simply reset it */
653 : 0 : ftrace_profile_reset(stat);
654 : 0 : return 0;
655 : : }
656 : :
657 : : /*
658 : : * We are profiling all functions, but usually only a few thousand
659 : : * functions are hit. We'll make a hash of 1024 items.
660 : : */
661 : : size = FTRACE_PROFILE_HASH_SIZE;
662 : :
663 : 0 : stat->hash = kcalloc(size, sizeof(struct hlist_head), GFP_KERNEL);
664 : :
665 : 0 : if (!stat->hash)
666 : : return -ENOMEM;
667 : :
668 : : /* Preallocate the function profiling pages */
669 : 0 : if (ftrace_profile_pages_init(stat) < 0) {
670 : 0 : kfree(stat->hash);
671 : 0 : stat->hash = NULL;
672 : 0 : return -ENOMEM;
673 : : }
674 : :
675 : : return 0;
676 : : }
677 : :
678 : 0 : static int ftrace_profile_init(void)
679 : : {
680 : : int cpu;
681 : : int ret = 0;
682 : :
683 : 0 : for_each_possible_cpu(cpu) {
684 : 0 : ret = ftrace_profile_init_cpu(cpu);
685 : 0 : if (ret)
686 : : break;
687 : : }
688 : :
689 : 0 : return ret;
690 : : }
691 : :
692 : : /* interrupts must be disabled */
693 : : static struct ftrace_profile *
694 : 0 : ftrace_find_profiled_func(struct ftrace_profile_stat *stat, unsigned long ip)
695 : : {
696 : : struct ftrace_profile *rec;
697 : : struct hlist_head *hhd;
698 : : unsigned long key;
699 : :
700 : : key = hash_long(ip, FTRACE_PROFILE_HASH_BITS);
701 : 0 : hhd = &stat->hash[key];
702 : :
703 : 0 : if (hlist_empty(hhd))
704 : : return NULL;
705 : :
706 : 0 : hlist_for_each_entry_rcu_notrace(rec, hhd, node) {
707 : 0 : if (rec->ip == ip)
708 : 0 : return rec;
709 : : }
710 : :
711 : : return NULL;
712 : : }
713 : :
714 : : static void ftrace_add_profile(struct ftrace_profile_stat *stat,
715 : : struct ftrace_profile *rec)
716 : : {
717 : : unsigned long key;
718 : :
719 : : key = hash_long(rec->ip, FTRACE_PROFILE_HASH_BITS);
720 : 0 : hlist_add_head_rcu(&rec->node, &stat->hash[key]);
721 : : }
722 : :
723 : : /*
724 : : * The memory is already allocated, this simply finds a new record to use.
725 : : */
726 : : static struct ftrace_profile *
727 : 0 : ftrace_profile_alloc(struct ftrace_profile_stat *stat, unsigned long ip)
728 : : {
729 : : struct ftrace_profile *rec = NULL;
730 : :
731 : : /* prevent recursion (from NMIs) */
732 : 0 : if (atomic_inc_return(&stat->disabled) != 1)
733 : : goto out;
734 : :
735 : : /*
736 : : * Try to find the function again since an NMI
737 : : * could have added it
738 : : */
739 : 0 : rec = ftrace_find_profiled_func(stat, ip);
740 : 0 : if (rec)
741 : : goto out;
742 : :
743 : 0 : if (stat->pages->index == PROFILES_PER_PAGE) {
744 : 0 : if (!stat->pages->next)
745 : : goto out;
746 : 0 : stat->pages = stat->pages->next;
747 : : }
748 : :
749 : 0 : rec = &stat->pages->records[stat->pages->index++];
750 : 0 : rec->ip = ip;
751 : : ftrace_add_profile(stat, rec);
752 : :
753 : : out:
754 : : atomic_dec(&stat->disabled);
755 : :
756 : 0 : return rec;
757 : : }
758 : :
759 : : static void
760 : 0 : function_profile_call(unsigned long ip, unsigned long parent_ip,
761 : : struct ftrace_ops *ops, struct pt_regs *regs)
762 : : {
763 : : struct ftrace_profile_stat *stat;
764 : : struct ftrace_profile *rec;
765 : : unsigned long flags;
766 : :
767 : 0 : if (!ftrace_profile_enabled)
768 : 0 : return;
769 : :
770 : 0 : local_irq_save(flags);
771 : :
772 : 0 : stat = this_cpu_ptr(&ftrace_profile_stats);
773 : 0 : if (!stat->hash || !ftrace_profile_enabled)
774 : : goto out;
775 : :
776 : 0 : rec = ftrace_find_profiled_func(stat, ip);
777 : 0 : if (!rec) {
778 : 0 : rec = ftrace_profile_alloc(stat, ip);
779 : 0 : if (!rec)
780 : : goto out;
781 : : }
782 : :
783 : 0 : rec->counter++;
784 : : out:
785 : 0 : local_irq_restore(flags);
786 : : }
787 : :
788 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
789 : : static bool fgraph_graph_time = true;
790 : :
791 : 0 : void ftrace_graph_graph_time_control(bool enable)
792 : : {
793 : 0 : fgraph_graph_time = enable;
794 : 0 : }
795 : :
796 : 0 : static int profile_graph_entry(struct ftrace_graph_ent *trace)
797 : : {
798 : : struct ftrace_ret_stack *ret_stack;
799 : :
800 : 0 : function_profile_call(trace->func, 0, NULL, NULL);
801 : :
802 : : /* If function graph is shutting down, ret_stack can be NULL */
803 : 0 : if (!current->ret_stack)
804 : : return 0;
805 : :
806 : 0 : ret_stack = ftrace_graph_get_ret_stack(current, 0);
807 : 0 : if (ret_stack)
808 : 0 : ret_stack->subtime = 0;
809 : :
810 : : return 1;
811 : : }
812 : :
813 : 0 : static void profile_graph_return(struct ftrace_graph_ret *trace)
814 : : {
815 : : struct ftrace_ret_stack *ret_stack;
816 : : struct ftrace_profile_stat *stat;
817 : : unsigned long long calltime;
818 : : struct ftrace_profile *rec;
819 : : unsigned long flags;
820 : :
821 : 0 : local_irq_save(flags);
822 : 0 : stat = this_cpu_ptr(&ftrace_profile_stats);
823 : 0 : if (!stat->hash || !ftrace_profile_enabled)
824 : : goto out;
825 : :
826 : : /* If the calltime was zero'd ignore it */
827 : 0 : if (!trace->calltime)
828 : : goto out;
829 : :
830 : 0 : calltime = trace->rettime - trace->calltime;
831 : :
832 : 0 : if (!fgraph_graph_time) {
833 : :
834 : : /* Append this call time to the parent time to subtract */
835 : 0 : ret_stack = ftrace_graph_get_ret_stack(current, 1);
836 : 0 : if (ret_stack)
837 : 0 : ret_stack->subtime += calltime;
838 : :
839 : 0 : ret_stack = ftrace_graph_get_ret_stack(current, 0);
840 : 0 : if (ret_stack && ret_stack->subtime < calltime)
841 : 0 : calltime -= ret_stack->subtime;
842 : : else
843 : : calltime = 0;
844 : : }
845 : :
846 : 0 : rec = ftrace_find_profiled_func(stat, trace->func);
847 : 0 : if (rec) {
848 : 0 : rec->time += calltime;
849 : 0 : rec->time_squared += calltime * calltime;
850 : : }
851 : :
852 : : out:
853 : 0 : local_irq_restore(flags);
854 : 0 : }
855 : :
856 : : static struct fgraph_ops fprofiler_ops = {
857 : : .entryfunc = &profile_graph_entry,
858 : : .retfunc = &profile_graph_return,
859 : : };
860 : :
861 : : static int register_ftrace_profiler(void)
862 : : {
863 : 0 : return register_ftrace_graph(&fprofiler_ops);
864 : : }
865 : :
866 : : static void unregister_ftrace_profiler(void)
867 : : {
868 : 0 : unregister_ftrace_graph(&fprofiler_ops);
869 : : }
870 : : #else
871 : : static struct ftrace_ops ftrace_profile_ops __read_mostly = {
872 : : .func = function_profile_call,
873 : : .flags = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,
874 : : INIT_OPS_HASH(ftrace_profile_ops)
875 : : };
876 : :
877 : : static int register_ftrace_profiler(void)
878 : : {
879 : : return register_ftrace_function(&ftrace_profile_ops);
880 : : }
881 : :
882 : : static void unregister_ftrace_profiler(void)
883 : : {
884 : : unregister_ftrace_function(&ftrace_profile_ops);
885 : : }
886 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
887 : :
888 : : static ssize_t
889 : 0 : ftrace_profile_write(struct file *filp, const char __user *ubuf,
890 : : size_t cnt, loff_t *ppos)
891 : : {
892 : : unsigned long val;
893 : : int ret;
894 : :
895 : 0 : ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
896 : 0 : if (ret)
897 : : return ret;
898 : :
899 : 0 : val = !!val;
900 : :
901 : 0 : mutex_lock(&ftrace_profile_lock);
902 : 0 : if (ftrace_profile_enabled ^ val) {
903 : 0 : if (val) {
904 : 0 : ret = ftrace_profile_init();
905 : 0 : if (ret < 0) {
906 : 0 : cnt = ret;
907 : 0 : goto out;
908 : : }
909 : :
910 : : ret = register_ftrace_profiler();
911 : 0 : if (ret < 0) {
912 : 0 : cnt = ret;
913 : 0 : goto out;
914 : : }
915 : 0 : ftrace_profile_enabled = 1;
916 : : } else {
917 : 0 : ftrace_profile_enabled = 0;
918 : : /*
919 : : * unregister_ftrace_profiler calls stop_machine
920 : : * so this acts like an synchronize_rcu.
921 : : */
922 : : unregister_ftrace_profiler();
923 : : }
924 : : }
925 : : out:
926 : 0 : mutex_unlock(&ftrace_profile_lock);
927 : :
928 : 0 : *ppos += cnt;
929 : :
930 : 0 : return cnt;
931 : : }
932 : :
933 : : static ssize_t
934 : 0 : ftrace_profile_read(struct file *filp, char __user *ubuf,
935 : : size_t cnt, loff_t *ppos)
936 : : {
937 : : char buf[64]; /* big enough to hold a number */
938 : : int r;
939 : :
940 : 0 : r = sprintf(buf, "%u\n", ftrace_profile_enabled);
941 : 0 : return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
942 : : }
943 : :
944 : : static const struct file_operations ftrace_profile_fops = {
945 : : .open = tracing_open_generic,
946 : : .read = ftrace_profile_read,
947 : : .write = ftrace_profile_write,
948 : : .llseek = default_llseek,
949 : : };
950 : :
951 : : /* used to initialize the real stat files */
952 : : static struct tracer_stat function_stats __initdata = {
953 : : .name = "functions",
954 : : .stat_start = function_stat_start,
955 : : .stat_next = function_stat_next,
956 : : .stat_cmp = function_stat_cmp,
957 : : .stat_headers = function_stat_headers,
958 : : .stat_show = function_stat_show
959 : : };
960 : :
961 : 3 : static __init void ftrace_profile_tracefs(struct dentry *d_tracer)
962 : : {
963 : : struct ftrace_profile_stat *stat;
964 : : struct dentry *entry;
965 : : char *name;
966 : : int ret;
967 : : int cpu;
968 : :
969 : 3 : for_each_possible_cpu(cpu) {
970 : 3 : stat = &per_cpu(ftrace_profile_stats, cpu);
971 : :
972 : 3 : name = kasprintf(GFP_KERNEL, "function%d", cpu);
973 : 3 : if (!name) {
974 : : /*
975 : : * The files created are permanent, if something happens
976 : : * we still do not free memory.
977 : : */
978 : 0 : WARN(1,
979 : : "Could not allocate stat file for cpu %d\n",
980 : : cpu);
981 : 0 : return;
982 : : }
983 : 3 : stat->stat = function_stats;
984 : 3 : stat->stat.name = name;
985 : 3 : ret = register_stat_tracer(&stat->stat);
986 : 3 : if (ret) {
987 : 0 : WARN(1,
988 : : "Could not register function stat for cpu %d\n",
989 : : cpu);
990 : 0 : kfree(name);
991 : 0 : return;
992 : : }
993 : : }
994 : :
995 : 3 : entry = tracefs_create_file("function_profile_enabled", 0644,
996 : : d_tracer, NULL, &ftrace_profile_fops);
997 : 3 : if (!entry)
998 : 0 : pr_warn("Could not create tracefs 'function_profile_enabled' entry\n");
999 : : }
1000 : :
1001 : : #else /* CONFIG_FUNCTION_PROFILER */
1002 : : static __init void ftrace_profile_tracefs(struct dentry *d_tracer)
1003 : : {
1004 : : }
1005 : : #endif /* CONFIG_FUNCTION_PROFILER */
1006 : :
1007 : : #ifdef CONFIG_DYNAMIC_FTRACE
1008 : :
1009 : : static struct ftrace_ops *removed_ops;
1010 : :
1011 : : /*
1012 : : * Set when doing a global update, like enabling all recs or disabling them.
1013 : : * It is not set when just updating a single ftrace_ops.
1014 : : */
1015 : : static bool update_all_ops;
1016 : :
1017 : : #ifndef CONFIG_FTRACE_MCOUNT_RECORD
1018 : : # error Dynamic ftrace depends on MCOUNT_RECORD
1019 : : #endif
1020 : :
1021 : : struct ftrace_func_entry {
1022 : : struct hlist_node hlist;
1023 : : unsigned long ip;
1024 : : };
1025 : :
1026 : : struct ftrace_func_probe {
1027 : : struct ftrace_probe_ops *probe_ops;
1028 : : struct ftrace_ops ops;
1029 : : struct trace_array *tr;
1030 : : struct list_head list;
1031 : : void *data;
1032 : : int ref;
1033 : : };
1034 : :
1035 : : /*
1036 : : * We make these constant because no one should touch them,
1037 : : * but they are used as the default "empty hash", to avoid allocating
1038 : : * it all the time. These are in a read only section such that if
1039 : : * anyone does try to modify it, it will cause an exception.
1040 : : */
1041 : : static const struct hlist_head empty_buckets[1];
1042 : : static const struct ftrace_hash empty_hash = {
1043 : : .buckets = (struct hlist_head *)empty_buckets,
1044 : : };
1045 : : #define EMPTY_HASH ((struct ftrace_hash *)&empty_hash)
1046 : :
1047 : : struct ftrace_ops global_ops = {
1048 : : .func = ftrace_stub,
1049 : : .local_hash.notrace_hash = EMPTY_HASH,
1050 : : .local_hash.filter_hash = EMPTY_HASH,
1051 : : INIT_OPS_HASH(global_ops)
1052 : : .flags = FTRACE_OPS_FL_RECURSION_SAFE |
1053 : : FTRACE_OPS_FL_INITIALIZED |
1054 : : FTRACE_OPS_FL_PID,
1055 : : };
1056 : :
1057 : : /*
1058 : : * Used by the stack undwinder to know about dynamic ftrace trampolines.
1059 : : */
1060 : 0 : struct ftrace_ops *ftrace_ops_trampoline(unsigned long addr)
1061 : : {
1062 : : struct ftrace_ops *op = NULL;
1063 : :
1064 : : /*
1065 : : * Some of the ops may be dynamically allocated,
1066 : : * they are freed after a synchronize_rcu().
1067 : : */
1068 : 0 : preempt_disable_notrace();
1069 : :
1070 : 0 : do_for_each_ftrace_op(op, ftrace_ops_list) {
1071 : : /*
1072 : : * This is to check for dynamically allocated trampolines.
1073 : : * Trampolines that are in kernel text will have
1074 : : * core_kernel_text() return true.
1075 : : */
1076 : 0 : if (op->trampoline && op->trampoline_size)
1077 : 0 : if (addr >= op->trampoline &&
1078 : 0 : addr < op->trampoline + op->trampoline_size) {
1079 : 0 : preempt_enable_notrace();
1080 : 0 : return op;
1081 : : }
1082 : 0 : } while_for_each_ftrace_op(op);
1083 : 0 : preempt_enable_notrace();
1084 : :
1085 : 0 : return NULL;
1086 : : }
1087 : :
1088 : : /*
1089 : : * This is used by __kernel_text_address() to return true if the
1090 : : * address is on a dynamically allocated trampoline that would
1091 : : * not return true for either core_kernel_text() or
1092 : : * is_module_text_address().
1093 : : */
1094 : 0 : bool is_ftrace_trampoline(unsigned long addr)
1095 : : {
1096 : 0 : return ftrace_ops_trampoline(addr) != NULL;
1097 : : }
1098 : :
1099 : : struct ftrace_page {
1100 : : struct ftrace_page *next;
1101 : : struct dyn_ftrace *records;
1102 : : int index;
1103 : : int size;
1104 : : };
1105 : :
1106 : : #define ENTRY_SIZE sizeof(struct dyn_ftrace)
1107 : : #define ENTRIES_PER_PAGE (PAGE_SIZE / ENTRY_SIZE)
1108 : :
1109 : : /* estimate from running different kernels */
1110 : : #define NR_TO_INIT 10000
1111 : :
1112 : : static struct ftrace_page *ftrace_pages_start;
1113 : : static struct ftrace_page *ftrace_pages;
1114 : :
1115 : : static __always_inline unsigned long
1116 : : ftrace_hash_key(struct ftrace_hash *hash, unsigned long ip)
1117 : : {
1118 : 0 : if (hash->size_bits > 0)
1119 : 0 : return hash_long(ip, hash->size_bits);
1120 : :
1121 : : return 0;
1122 : : }
1123 : :
1124 : : /* Only use this function if ftrace_hash_empty() has already been tested */
1125 : : static __always_inline struct ftrace_func_entry *
1126 : : __ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip)
1127 : : {
1128 : : unsigned long key;
1129 : : struct ftrace_func_entry *entry;
1130 : : struct hlist_head *hhd;
1131 : :
1132 : : key = ftrace_hash_key(hash, ip);
1133 : 0 : hhd = &hash->buckets[key];
1134 : :
1135 : 0 : hlist_for_each_entry_rcu_notrace(entry, hhd, hlist) {
1136 : 0 : if (entry->ip == ip)
1137 : 0 : return entry;
1138 : : }
1139 : : return NULL;
1140 : : }
1141 : :
1142 : : /**
1143 : : * ftrace_lookup_ip - Test to see if an ip exists in an ftrace_hash
1144 : : * @hash: The hash to look at
1145 : : * @ip: The instruction pointer to test
1146 : : *
1147 : : * Search a given @hash to see if a given instruction pointer (@ip)
1148 : : * exists in it.
1149 : : *
1150 : : * Returns the entry that holds the @ip if found. NULL otherwise.
1151 : : */
1152 : : struct ftrace_func_entry *
1153 : 3 : ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip)
1154 : : {
1155 : 3 : if (ftrace_hash_empty(hash))
1156 : : return NULL;
1157 : :
1158 : 0 : return __ftrace_lookup_ip(hash, ip);
1159 : : }
1160 : :
1161 : 0 : static void __add_hash_entry(struct ftrace_hash *hash,
1162 : : struct ftrace_func_entry *entry)
1163 : : {
1164 : : struct hlist_head *hhd;
1165 : : unsigned long key;
1166 : :
1167 : 0 : key = ftrace_hash_key(hash, entry->ip);
1168 : 0 : hhd = &hash->buckets[key];
1169 : 0 : hlist_add_head(&entry->hlist, hhd);
1170 : 0 : hash->count++;
1171 : 0 : }
1172 : :
1173 : 0 : static int add_hash_entry(struct ftrace_hash *hash, unsigned long ip)
1174 : : {
1175 : : struct ftrace_func_entry *entry;
1176 : :
1177 : : entry = kmalloc(sizeof(*entry), GFP_KERNEL);
1178 : 0 : if (!entry)
1179 : : return -ENOMEM;
1180 : :
1181 : 0 : entry->ip = ip;
1182 : 0 : __add_hash_entry(hash, entry);
1183 : :
1184 : 0 : return 0;
1185 : : }
1186 : :
1187 : : static void
1188 : 0 : free_hash_entry(struct ftrace_hash *hash,
1189 : : struct ftrace_func_entry *entry)
1190 : : {
1191 : : hlist_del(&entry->hlist);
1192 : 0 : kfree(entry);
1193 : 0 : hash->count--;
1194 : 0 : }
1195 : :
1196 : : static void
1197 : : remove_hash_entry(struct ftrace_hash *hash,
1198 : : struct ftrace_func_entry *entry)
1199 : : {
1200 : : hlist_del_rcu(&entry->hlist);
1201 : 0 : hash->count--;
1202 : : }
1203 : :
1204 : 0 : static void ftrace_hash_clear(struct ftrace_hash *hash)
1205 : : {
1206 : : struct hlist_head *hhd;
1207 : : struct hlist_node *tn;
1208 : : struct ftrace_func_entry *entry;
1209 : 0 : int size = 1 << hash->size_bits;
1210 : : int i;
1211 : :
1212 : 0 : if (!hash->count)
1213 : 0 : return;
1214 : :
1215 : 0 : for (i = 0; i < size; i++) {
1216 : 0 : hhd = &hash->buckets[i];
1217 : 0 : hlist_for_each_entry_safe(entry, tn, hhd, hlist)
1218 : 0 : free_hash_entry(hash, entry);
1219 : : }
1220 : 0 : FTRACE_WARN_ON(hash->count);
1221 : : }
1222 : :
1223 : 0 : static void free_ftrace_mod(struct ftrace_mod_load *ftrace_mod)
1224 : : {
1225 : : list_del(&ftrace_mod->list);
1226 : 0 : kfree(ftrace_mod->module);
1227 : 0 : kfree(ftrace_mod->func);
1228 : 0 : kfree(ftrace_mod);
1229 : 0 : }
1230 : :
1231 : 0 : static void clear_ftrace_mod_list(struct list_head *head)
1232 : : {
1233 : : struct ftrace_mod_load *p, *n;
1234 : :
1235 : : /* stack tracer isn't supported yet */
1236 : 0 : if (!head)
1237 : 0 : return;
1238 : :
1239 : 0 : mutex_lock(&ftrace_lock);
1240 : 0 : list_for_each_entry_safe(p, n, head, list)
1241 : 0 : free_ftrace_mod(p);
1242 : 0 : mutex_unlock(&ftrace_lock);
1243 : : }
1244 : :
1245 : 0 : static void free_ftrace_hash(struct ftrace_hash *hash)
1246 : : {
1247 : 0 : if (!hash || hash == EMPTY_HASH)
1248 : 0 : return;
1249 : 0 : ftrace_hash_clear(hash);
1250 : 0 : kfree(hash->buckets);
1251 : 0 : kfree(hash);
1252 : : }
1253 : :
1254 : 0 : static void __free_ftrace_hash_rcu(struct rcu_head *rcu)
1255 : : {
1256 : : struct ftrace_hash *hash;
1257 : :
1258 : 0 : hash = container_of(rcu, struct ftrace_hash, rcu);
1259 : 0 : free_ftrace_hash(hash);
1260 : 0 : }
1261 : :
1262 : : static void free_ftrace_hash_rcu(struct ftrace_hash *hash)
1263 : : {
1264 : 0 : if (!hash || hash == EMPTY_HASH)
1265 : : return;
1266 : 0 : call_rcu(&hash->rcu, __free_ftrace_hash_rcu);
1267 : : }
1268 : :
1269 : 0 : void ftrace_free_filter(struct ftrace_ops *ops)
1270 : : {
1271 : 0 : ftrace_ops_init(ops);
1272 : 0 : free_ftrace_hash(ops->func_hash->filter_hash);
1273 : 0 : free_ftrace_hash(ops->func_hash->notrace_hash);
1274 : 0 : }
1275 : :
1276 : 0 : static struct ftrace_hash *alloc_ftrace_hash(int size_bits)
1277 : : {
1278 : : struct ftrace_hash *hash;
1279 : : int size;
1280 : :
1281 : 0 : hash = kzalloc(sizeof(*hash), GFP_KERNEL);
1282 : 0 : if (!hash)
1283 : : return NULL;
1284 : :
1285 : 0 : size = 1 << size_bits;
1286 : 0 : hash->buckets = kcalloc(size, sizeof(*hash->buckets), GFP_KERNEL);
1287 : :
1288 : 0 : if (!hash->buckets) {
1289 : 0 : kfree(hash);
1290 : 0 : return NULL;
1291 : : }
1292 : :
1293 : 0 : hash->size_bits = size_bits;
1294 : :
1295 : 0 : return hash;
1296 : : }
1297 : :
1298 : :
1299 : 0 : static int ftrace_add_mod(struct trace_array *tr,
1300 : : const char *func, const char *module,
1301 : : int enable)
1302 : : {
1303 : : struct ftrace_mod_load *ftrace_mod;
1304 : 0 : struct list_head *mod_head = enable ? &tr->mod_trace : &tr->mod_notrace;
1305 : :
1306 : 0 : ftrace_mod = kzalloc(sizeof(*ftrace_mod), GFP_KERNEL);
1307 : 0 : if (!ftrace_mod)
1308 : : return -ENOMEM;
1309 : :
1310 : 0 : ftrace_mod->func = kstrdup(func, GFP_KERNEL);
1311 : 0 : ftrace_mod->module = kstrdup(module, GFP_KERNEL);
1312 : 0 : ftrace_mod->enable = enable;
1313 : :
1314 : 0 : if (!ftrace_mod->func || !ftrace_mod->module)
1315 : : goto out_free;
1316 : :
1317 : 0 : list_add(&ftrace_mod->list, mod_head);
1318 : :
1319 : 0 : return 0;
1320 : :
1321 : : out_free:
1322 : 0 : free_ftrace_mod(ftrace_mod);
1323 : :
1324 : 0 : return -ENOMEM;
1325 : : }
1326 : :
1327 : : static struct ftrace_hash *
1328 : 0 : alloc_and_copy_ftrace_hash(int size_bits, struct ftrace_hash *hash)
1329 : : {
1330 : : struct ftrace_func_entry *entry;
1331 : : struct ftrace_hash *new_hash;
1332 : : int size;
1333 : : int ret;
1334 : : int i;
1335 : :
1336 : 0 : new_hash = alloc_ftrace_hash(size_bits);
1337 : 0 : if (!new_hash)
1338 : : return NULL;
1339 : :
1340 : 0 : if (hash)
1341 : 0 : new_hash->flags = hash->flags;
1342 : :
1343 : : /* Empty hash? */
1344 : 0 : if (ftrace_hash_empty(hash))
1345 : : return new_hash;
1346 : :
1347 : 0 : size = 1 << hash->size_bits;
1348 : 0 : for (i = 0; i < size; i++) {
1349 : 0 : hlist_for_each_entry(entry, &hash->buckets[i], hlist) {
1350 : 0 : ret = add_hash_entry(new_hash, entry->ip);
1351 : 0 : if (ret < 0)
1352 : : goto free_hash;
1353 : : }
1354 : : }
1355 : :
1356 : 0 : FTRACE_WARN_ON(new_hash->count != hash->count);
1357 : :
1358 : 0 : return new_hash;
1359 : :
1360 : : free_hash:
1361 : 0 : free_ftrace_hash(new_hash);
1362 : 0 : return NULL;
1363 : : }
1364 : :
1365 : : static void
1366 : : ftrace_hash_rec_disable_modify(struct ftrace_ops *ops, int filter_hash);
1367 : : static void
1368 : : ftrace_hash_rec_enable_modify(struct ftrace_ops *ops, int filter_hash);
1369 : :
1370 : : static int ftrace_hash_ipmodify_update(struct ftrace_ops *ops,
1371 : : struct ftrace_hash *new_hash);
1372 : :
1373 : : static struct ftrace_hash *
1374 : 0 : __ftrace_hash_move(struct ftrace_hash *src)
1375 : : {
1376 : : struct ftrace_func_entry *entry;
1377 : : struct hlist_node *tn;
1378 : : struct hlist_head *hhd;
1379 : : struct ftrace_hash *new_hash;
1380 : 0 : int size = src->count;
1381 : : int bits = 0;
1382 : : int i;
1383 : :
1384 : : /*
1385 : : * If the new source is empty, just return the empty_hash.
1386 : : */
1387 : 0 : if (ftrace_hash_empty(src))
1388 : : return EMPTY_HASH;
1389 : :
1390 : : /*
1391 : : * Make the hash size about 1/2 the # found
1392 : : */
1393 : 0 : for (size /= 2; size; size >>= 1)
1394 : 0 : bits++;
1395 : :
1396 : : /* Don't allocate too much */
1397 : 0 : if (bits > FTRACE_HASH_MAX_BITS)
1398 : : bits = FTRACE_HASH_MAX_BITS;
1399 : :
1400 : 0 : new_hash = alloc_ftrace_hash(bits);
1401 : 0 : if (!new_hash)
1402 : : return NULL;
1403 : :
1404 : 0 : new_hash->flags = src->flags;
1405 : :
1406 : 0 : size = 1 << src->size_bits;
1407 : 0 : for (i = 0; i < size; i++) {
1408 : 0 : hhd = &src->buckets[i];
1409 : 0 : hlist_for_each_entry_safe(entry, tn, hhd, hlist) {
1410 : : remove_hash_entry(src, entry);
1411 : 0 : __add_hash_entry(new_hash, entry);
1412 : : }
1413 : : }
1414 : :
1415 : : return new_hash;
1416 : : }
1417 : :
1418 : : static int
1419 : 0 : ftrace_hash_move(struct ftrace_ops *ops, int enable,
1420 : : struct ftrace_hash **dst, struct ftrace_hash *src)
1421 : : {
1422 : : struct ftrace_hash *new_hash;
1423 : : int ret;
1424 : :
1425 : : /* Reject setting notrace hash on IPMODIFY ftrace_ops */
1426 : 0 : if (ops->flags & FTRACE_OPS_FL_IPMODIFY && !enable)
1427 : : return -EINVAL;
1428 : :
1429 : 0 : new_hash = __ftrace_hash_move(src);
1430 : 0 : if (!new_hash)
1431 : : return -ENOMEM;
1432 : :
1433 : : /* Make sure this can be applied if it is IPMODIFY ftrace_ops */
1434 : 0 : if (enable) {
1435 : : /* IPMODIFY should be updated only when filter_hash updating */
1436 : 0 : ret = ftrace_hash_ipmodify_update(ops, new_hash);
1437 : 0 : if (ret < 0) {
1438 : 0 : free_ftrace_hash(new_hash);
1439 : 0 : return ret;
1440 : : }
1441 : : }
1442 : :
1443 : : /*
1444 : : * Remove the current set, update the hash and add
1445 : : * them back.
1446 : : */
1447 : : ftrace_hash_rec_disable_modify(ops, enable);
1448 : :
1449 : 0 : rcu_assign_pointer(*dst, new_hash);
1450 : :
1451 : : ftrace_hash_rec_enable_modify(ops, enable);
1452 : :
1453 : 0 : return 0;
1454 : : }
1455 : :
1456 : 0 : static bool hash_contains_ip(unsigned long ip,
1457 : : struct ftrace_ops_hash *hash)
1458 : : {
1459 : : /*
1460 : : * The function record is a match if it exists in the filter
1461 : : * hash and not in the notrace hash. Note, an emty hash is
1462 : : * considered a match for the filter hash, but an empty
1463 : : * notrace hash is considered not in the notrace hash.
1464 : : */
1465 : 0 : return (ftrace_hash_empty(hash->filter_hash) ||
1466 : 0 : __ftrace_lookup_ip(hash->filter_hash, ip)) &&
1467 : 0 : (ftrace_hash_empty(hash->notrace_hash) ||
1468 : : !__ftrace_lookup_ip(hash->notrace_hash, ip));
1469 : : }
1470 : :
1471 : : /*
1472 : : * Test the hashes for this ops to see if we want to call
1473 : : * the ops->func or not.
1474 : : *
1475 : : * It's a match if the ip is in the ops->filter_hash or
1476 : : * the filter_hash does not exist or is empty,
1477 : : * AND
1478 : : * the ip is not in the ops->notrace_hash.
1479 : : *
1480 : : * This needs to be called with preemption disabled as
1481 : : * the hashes are freed with call_rcu().
1482 : : */
1483 : : int
1484 : 0 : ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
1485 : : {
1486 : : struct ftrace_ops_hash hash;
1487 : : int ret;
1488 : :
1489 : : #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
1490 : : /*
1491 : : * There's a small race when adding ops that the ftrace handler
1492 : : * that wants regs, may be called without them. We can not
1493 : : * allow that handler to be called if regs is NULL.
1494 : : */
1495 : 0 : if (regs == NULL && (ops->flags & FTRACE_OPS_FL_SAVE_REGS))
1496 : : return 0;
1497 : : #endif
1498 : :
1499 : 0 : rcu_assign_pointer(hash.filter_hash, ops->func_hash->filter_hash);
1500 : 0 : rcu_assign_pointer(hash.notrace_hash, ops->func_hash->notrace_hash);
1501 : :
1502 : 0 : if (hash_contains_ip(ip, &hash))
1503 : : ret = 1;
1504 : : else
1505 : : ret = 0;
1506 : :
1507 : 0 : return ret;
1508 : : }
1509 : :
1510 : : /*
1511 : : * This is a double for. Do not use 'break' to break out of the loop,
1512 : : * you must use a goto.
1513 : : */
1514 : : #define do_for_each_ftrace_rec(pg, rec) \
1515 : : for (pg = ftrace_pages_start; pg; pg = pg->next) { \
1516 : : int _____i; \
1517 : : for (_____i = 0; _____i < pg->index; _____i++) { \
1518 : : rec = &pg->records[_____i];
1519 : :
1520 : : #define while_for_each_ftrace_rec() \
1521 : : } \
1522 : : }
1523 : :
1524 : :
1525 : 3 : static int ftrace_cmp_recs(const void *a, const void *b)
1526 : : {
1527 : : const struct dyn_ftrace *key = a;
1528 : : const struct dyn_ftrace *rec = b;
1529 : :
1530 : 3 : if (key->flags < rec->ip)
1531 : : return -1;
1532 : 3 : if (key->ip >= rec->ip + MCOUNT_INSN_SIZE)
1533 : : return 1;
1534 : 3 : return 0;
1535 : : }
1536 : :
1537 : : /**
1538 : : * ftrace_location_range - return the first address of a traced location
1539 : : * if it touches the given ip range
1540 : : * @start: start of range to search.
1541 : : * @end: end of range to search (inclusive). @end points to the last byte
1542 : : * to check.
1543 : : *
1544 : : * Returns rec->ip if the related ftrace location is a least partly within
1545 : : * the given address range. That is, the first address of the instruction
1546 : : * that is either a NOP or call to the function tracer. It checks the ftrace
1547 : : * internal tables to determine if the address belongs or not.
1548 : : */
1549 : 0 : unsigned long ftrace_location_range(unsigned long start, unsigned long end)
1550 : : {
1551 : : struct ftrace_page *pg;
1552 : : struct dyn_ftrace *rec;
1553 : : struct dyn_ftrace key;
1554 : :
1555 : 0 : key.ip = start;
1556 : 0 : key.flags = end; /* overload flags, as it is unsigned long */
1557 : :
1558 : 0 : for (pg = ftrace_pages_start; pg; pg = pg->next) {
1559 : 0 : if (end < pg->records[0].ip ||
1560 : 0 : start >= (pg->records[pg->index - 1].ip + MCOUNT_INSN_SIZE))
1561 : 0 : continue;
1562 : 0 : rec = bsearch(&key, pg->records, pg->index,
1563 : : sizeof(struct dyn_ftrace),
1564 : : ftrace_cmp_recs);
1565 : 0 : if (rec)
1566 : 0 : return rec->ip;
1567 : : }
1568 : :
1569 : : return 0;
1570 : : }
1571 : :
1572 : : /**
1573 : : * ftrace_location - return true if the ip giving is a traced location
1574 : : * @ip: the instruction pointer to check
1575 : : *
1576 : : * Returns rec->ip if @ip given is a pointer to a ftrace location.
1577 : : * That is, the instruction that is either a NOP or call to
1578 : : * the function tracer. It checks the ftrace internal tables to
1579 : : * determine if the address belongs or not.
1580 : : */
1581 : 0 : unsigned long ftrace_location(unsigned long ip)
1582 : : {
1583 : 0 : return ftrace_location_range(ip, ip);
1584 : : }
1585 : :
1586 : : /**
1587 : : * ftrace_text_reserved - return true if range contains an ftrace location
1588 : : * @start: start of range to search
1589 : : * @end: end of range to search (inclusive). @end points to the last byte to check.
1590 : : *
1591 : : * Returns 1 if @start and @end contains a ftrace location.
1592 : : * That is, the instruction that is either a NOP or call to
1593 : : * the function tracer. It checks the ftrace internal tables to
1594 : : * determine if the address belongs or not.
1595 : : */
1596 : 0 : int ftrace_text_reserved(const void *start, const void *end)
1597 : : {
1598 : : unsigned long ret;
1599 : :
1600 : 0 : ret = ftrace_location_range((unsigned long)start,
1601 : : (unsigned long)end);
1602 : :
1603 : 0 : return (int)!!ret;
1604 : : }
1605 : :
1606 : : /* Test if ops registered to this rec needs regs */
1607 : 0 : static bool test_rec_ops_needs_regs(struct dyn_ftrace *rec)
1608 : : {
1609 : : struct ftrace_ops *ops;
1610 : : bool keep_regs = false;
1611 : :
1612 : 0 : for (ops = ftrace_ops_list;
1613 : 0 : ops != &ftrace_list_end; ops = ops->next) {
1614 : : /* pass rec in as regs to have non-NULL val */
1615 : 0 : if (ftrace_ops_test(ops, rec->ip, rec)) {
1616 : 0 : if (ops->flags & FTRACE_OPS_FL_SAVE_REGS) {
1617 : : keep_regs = true;
1618 : : break;
1619 : : }
1620 : : }
1621 : : }
1622 : :
1623 : 0 : return keep_regs;
1624 : : }
1625 : :
1626 : : static struct ftrace_ops *
1627 : : ftrace_find_tramp_ops_any(struct dyn_ftrace *rec);
1628 : : static struct ftrace_ops *
1629 : : ftrace_find_tramp_ops_next(struct dyn_ftrace *rec, struct ftrace_ops *ops);
1630 : :
1631 : 0 : static bool __ftrace_hash_rec_update(struct ftrace_ops *ops,
1632 : : int filter_hash,
1633 : : bool inc)
1634 : : {
1635 : : struct ftrace_hash *hash;
1636 : : struct ftrace_hash *other_hash;
1637 : : struct ftrace_page *pg;
1638 : : struct dyn_ftrace *rec;
1639 : : bool update = false;
1640 : : int count = 0;
1641 : : int all = false;
1642 : :
1643 : : /* Only update if the ops has been registered */
1644 : 0 : if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
1645 : : return false;
1646 : :
1647 : : /*
1648 : : * In the filter_hash case:
1649 : : * If the count is zero, we update all records.
1650 : : * Otherwise we just update the items in the hash.
1651 : : *
1652 : : * In the notrace_hash case:
1653 : : * We enable the update in the hash.
1654 : : * As disabling notrace means enabling the tracing,
1655 : : * and enabling notrace means disabling, the inc variable
1656 : : * gets inversed.
1657 : : */
1658 : 0 : if (filter_hash) {
1659 : 0 : hash = ops->func_hash->filter_hash;
1660 : 0 : other_hash = ops->func_hash->notrace_hash;
1661 : 0 : if (ftrace_hash_empty(hash))
1662 : : all = true;
1663 : : } else {
1664 : 0 : inc = !inc;
1665 : 0 : hash = ops->func_hash->notrace_hash;
1666 : 0 : other_hash = ops->func_hash->filter_hash;
1667 : : /*
1668 : : * If the notrace hash has no items,
1669 : : * then there's nothing to do.
1670 : : */
1671 : 0 : if (ftrace_hash_empty(hash))
1672 : : return false;
1673 : : }
1674 : :
1675 : 0 : do_for_each_ftrace_rec(pg, rec) {
1676 : : int in_other_hash = 0;
1677 : : int in_hash = 0;
1678 : : int match = 0;
1679 : :
1680 : 0 : if (rec->flags & FTRACE_FL_DISABLED)
1681 : 0 : continue;
1682 : :
1683 : 0 : if (all) {
1684 : : /*
1685 : : * Only the filter_hash affects all records.
1686 : : * Update if the record is not in the notrace hash.
1687 : : */
1688 : 0 : if (!other_hash || !ftrace_lookup_ip(other_hash, rec->ip))
1689 : : match = 1;
1690 : : } else {
1691 : 0 : in_hash = !!ftrace_lookup_ip(hash, rec->ip);
1692 : 0 : in_other_hash = !!ftrace_lookup_ip(other_hash, rec->ip);
1693 : :
1694 : : /*
1695 : : * If filter_hash is set, we want to match all functions
1696 : : * that are in the hash but not in the other hash.
1697 : : *
1698 : : * If filter_hash is not set, then we are decrementing.
1699 : : * That means we match anything that is in the hash
1700 : : * and also in the other_hash. That is, we need to turn
1701 : : * off functions in the other hash because they are disabled
1702 : : * by this hash.
1703 : : */
1704 : 0 : if (filter_hash && in_hash && !in_other_hash)
1705 : : match = 1;
1706 : 0 : else if (!filter_hash && in_hash &&
1707 : 0 : (in_other_hash || ftrace_hash_empty(other_hash)))
1708 : : match = 1;
1709 : : }
1710 : 0 : if (!match)
1711 : 0 : continue;
1712 : :
1713 : 0 : if (inc) {
1714 : 0 : rec->flags++;
1715 : 0 : if (FTRACE_WARN_ON(ftrace_rec_count(rec) == FTRACE_REF_MAX))
1716 : : return false;
1717 : :
1718 : : /*
1719 : : * If there's only a single callback registered to a
1720 : : * function, and the ops has a trampoline registered
1721 : : * for it, then we can call it directly.
1722 : : */
1723 : 0 : if (ftrace_rec_count(rec) == 1 && ops->trampoline)
1724 : 0 : rec->flags |= FTRACE_FL_TRAMP;
1725 : : else
1726 : : /*
1727 : : * If we are adding another function callback
1728 : : * to this function, and the previous had a
1729 : : * custom trampoline in use, then we need to go
1730 : : * back to the default trampoline.
1731 : : */
1732 : 0 : rec->flags &= ~FTRACE_FL_TRAMP;
1733 : :
1734 : : /*
1735 : : * If any ops wants regs saved for this function
1736 : : * then all ops will get saved regs.
1737 : : */
1738 : 0 : if (ops->flags & FTRACE_OPS_FL_SAVE_REGS)
1739 : 0 : rec->flags |= FTRACE_FL_REGS;
1740 : : } else {
1741 : 0 : if (FTRACE_WARN_ON(ftrace_rec_count(rec) == 0))
1742 : : return false;
1743 : 0 : rec->flags--;
1744 : :
1745 : : /*
1746 : : * If the rec had REGS enabled and the ops that is
1747 : : * being removed had REGS set, then see if there is
1748 : : * still any ops for this record that wants regs.
1749 : : * If not, we can stop recording them.
1750 : : */
1751 : 0 : if (ftrace_rec_count(rec) > 0 &&
1752 : 0 : rec->flags & FTRACE_FL_REGS &&
1753 : 0 : ops->flags & FTRACE_OPS_FL_SAVE_REGS) {
1754 : 0 : if (!test_rec_ops_needs_regs(rec))
1755 : 0 : rec->flags &= ~FTRACE_FL_REGS;
1756 : : }
1757 : :
1758 : : /*
1759 : : * The TRAMP needs to be set only if rec count
1760 : : * is decremented to one, and the ops that is
1761 : : * left has a trampoline. As TRAMP can only be
1762 : : * enabled if there is only a single ops attached
1763 : : * to it.
1764 : : */
1765 : 0 : if (ftrace_rec_count(rec) == 1 &&
1766 : 0 : ftrace_find_tramp_ops_any(rec))
1767 : 0 : rec->flags |= FTRACE_FL_TRAMP;
1768 : : else
1769 : 0 : rec->flags &= ~FTRACE_FL_TRAMP;
1770 : :
1771 : : /*
1772 : : * flags will be cleared in ftrace_check_record()
1773 : : * if rec count is zero.
1774 : : */
1775 : : }
1776 : 0 : count++;
1777 : :
1778 : : /* Must match FTRACE_UPDATE_CALLS in ftrace_modify_all_code() */
1779 : 0 : update |= ftrace_test_record(rec, true) != FTRACE_UPDATE_IGNORE;
1780 : :
1781 : : /* Shortcut, if we handled all records, we are done. */
1782 : 0 : if (!all && count == hash->count)
1783 : 0 : return update;
1784 : : } while_for_each_ftrace_rec();
1785 : :
1786 : 0 : return update;
1787 : : }
1788 : :
1789 : : static bool ftrace_hash_rec_disable(struct ftrace_ops *ops,
1790 : : int filter_hash)
1791 : : {
1792 : 0 : return __ftrace_hash_rec_update(ops, filter_hash, 0);
1793 : : }
1794 : :
1795 : : static bool ftrace_hash_rec_enable(struct ftrace_ops *ops,
1796 : : int filter_hash)
1797 : : {
1798 : 0 : return __ftrace_hash_rec_update(ops, filter_hash, 1);
1799 : : }
1800 : :
1801 : 0 : static void ftrace_hash_rec_update_modify(struct ftrace_ops *ops,
1802 : : int filter_hash, int inc)
1803 : : {
1804 : : struct ftrace_ops *op;
1805 : :
1806 : 0 : __ftrace_hash_rec_update(ops, filter_hash, inc);
1807 : :
1808 : 0 : if (ops->func_hash != &global_ops.local_hash)
1809 : 0 : return;
1810 : :
1811 : : /*
1812 : : * If the ops shares the global_ops hash, then we need to update
1813 : : * all ops that are enabled and use this hash.
1814 : : */
1815 : 0 : do_for_each_ftrace_op(op, ftrace_ops_list) {
1816 : : /* Already done */
1817 : 0 : if (op == ops)
1818 : 0 : continue;
1819 : 0 : if (op->func_hash == &global_ops.local_hash)
1820 : 0 : __ftrace_hash_rec_update(op, filter_hash, inc);
1821 : 0 : } while_for_each_ftrace_op(op);
1822 : : }
1823 : :
1824 : : static void ftrace_hash_rec_disable_modify(struct ftrace_ops *ops,
1825 : : int filter_hash)
1826 : : {
1827 : 0 : ftrace_hash_rec_update_modify(ops, filter_hash, 0);
1828 : : }
1829 : :
1830 : : static void ftrace_hash_rec_enable_modify(struct ftrace_ops *ops,
1831 : : int filter_hash)
1832 : : {
1833 : 0 : ftrace_hash_rec_update_modify(ops, filter_hash, 1);
1834 : : }
1835 : :
1836 : : /*
1837 : : * Try to update IPMODIFY flag on each ftrace_rec. Return 0 if it is OK
1838 : : * or no-needed to update, -EBUSY if it detects a conflict of the flag
1839 : : * on a ftrace_rec, and -EINVAL if the new_hash tries to trace all recs.
1840 : : * Note that old_hash and new_hash has below meanings
1841 : : * - If the hash is NULL, it hits all recs (if IPMODIFY is set, this is rejected)
1842 : : * - If the hash is EMPTY_HASH, it hits nothing
1843 : : * - Anything else hits the recs which match the hash entries.
1844 : : */
1845 : 0 : static int __ftrace_hash_update_ipmodify(struct ftrace_ops *ops,
1846 : : struct ftrace_hash *old_hash,
1847 : : struct ftrace_hash *new_hash)
1848 : : {
1849 : : struct ftrace_page *pg;
1850 : : struct dyn_ftrace *rec, *end = NULL;
1851 : : int in_old, in_new;
1852 : :
1853 : : /* Only update if the ops has been registered */
1854 : 0 : if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
1855 : : return 0;
1856 : :
1857 : 0 : if (!(ops->flags & FTRACE_OPS_FL_IPMODIFY))
1858 : : return 0;
1859 : :
1860 : : /*
1861 : : * Since the IPMODIFY is a very address sensitive action, we do not
1862 : : * allow ftrace_ops to set all functions to new hash.
1863 : : */
1864 : 0 : if (!new_hash || !old_hash)
1865 : : return -EINVAL;
1866 : :
1867 : : /* Update rec->flags */
1868 : 0 : do_for_each_ftrace_rec(pg, rec) {
1869 : :
1870 : 0 : if (rec->flags & FTRACE_FL_DISABLED)
1871 : 0 : continue;
1872 : :
1873 : : /* We need to update only differences of filter_hash */
1874 : 0 : in_old = !!ftrace_lookup_ip(old_hash, rec->ip);
1875 : 0 : in_new = !!ftrace_lookup_ip(new_hash, rec->ip);
1876 : 0 : if (in_old == in_new)
1877 : 0 : continue;
1878 : :
1879 : 0 : if (in_new) {
1880 : : /* New entries must ensure no others are using it */
1881 : 0 : if (rec->flags & FTRACE_FL_IPMODIFY)
1882 : : goto rollback;
1883 : 0 : rec->flags |= FTRACE_FL_IPMODIFY;
1884 : : } else /* Removed entry */
1885 : 0 : rec->flags &= ~FTRACE_FL_IPMODIFY;
1886 : : } while_for_each_ftrace_rec();
1887 : :
1888 : : return 0;
1889 : :
1890 : : rollback:
1891 : 0 : end = rec;
1892 : :
1893 : : /* Roll back what we did above */
1894 : 0 : do_for_each_ftrace_rec(pg, rec) {
1895 : :
1896 : 0 : if (rec->flags & FTRACE_FL_DISABLED)
1897 : 0 : continue;
1898 : :
1899 : 0 : if (rec == end)
1900 : : goto err_out;
1901 : :
1902 : 0 : in_old = !!ftrace_lookup_ip(old_hash, rec->ip);
1903 : 0 : in_new = !!ftrace_lookup_ip(new_hash, rec->ip);
1904 : 0 : if (in_old == in_new)
1905 : 0 : continue;
1906 : :
1907 : 0 : if (in_new)
1908 : 0 : rec->flags &= ~FTRACE_FL_IPMODIFY;
1909 : : else
1910 : 0 : rec->flags |= FTRACE_FL_IPMODIFY;
1911 : : } while_for_each_ftrace_rec();
1912 : :
1913 : : err_out:
1914 : : return -EBUSY;
1915 : : }
1916 : :
1917 : 0 : static int ftrace_hash_ipmodify_enable(struct ftrace_ops *ops)
1918 : : {
1919 : 0 : struct ftrace_hash *hash = ops->func_hash->filter_hash;
1920 : :
1921 : 0 : if (ftrace_hash_empty(hash))
1922 : : hash = NULL;
1923 : :
1924 : 0 : return __ftrace_hash_update_ipmodify(ops, EMPTY_HASH, hash);
1925 : : }
1926 : :
1927 : : /* Disabling always succeeds */
1928 : 0 : static void ftrace_hash_ipmodify_disable(struct ftrace_ops *ops)
1929 : : {
1930 : 0 : struct ftrace_hash *hash = ops->func_hash->filter_hash;
1931 : :
1932 : 0 : if (ftrace_hash_empty(hash))
1933 : : hash = NULL;
1934 : :
1935 : 0 : __ftrace_hash_update_ipmodify(ops, hash, EMPTY_HASH);
1936 : 0 : }
1937 : :
1938 : 0 : static int ftrace_hash_ipmodify_update(struct ftrace_ops *ops,
1939 : : struct ftrace_hash *new_hash)
1940 : : {
1941 : 0 : struct ftrace_hash *old_hash = ops->func_hash->filter_hash;
1942 : :
1943 : 0 : if (ftrace_hash_empty(old_hash))
1944 : : old_hash = NULL;
1945 : :
1946 : 0 : if (ftrace_hash_empty(new_hash))
1947 : : new_hash = NULL;
1948 : :
1949 : 0 : return __ftrace_hash_update_ipmodify(ops, old_hash, new_hash);
1950 : : }
1951 : :
1952 : 0 : static void print_ip_ins(const char *fmt, const unsigned char *p)
1953 : : {
1954 : : int i;
1955 : :
1956 : 0 : printk(KERN_CONT "%s", fmt);
1957 : :
1958 : 0 : for (i = 0; i < MCOUNT_INSN_SIZE; i++)
1959 : 0 : printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
1960 : 0 : }
1961 : :
1962 : : enum ftrace_bug_type ftrace_bug_type;
1963 : : const void *ftrace_expected;
1964 : :
1965 : 0 : static void print_bug_type(void)
1966 : : {
1967 : 0 : switch (ftrace_bug_type) {
1968 : : case FTRACE_BUG_UNKNOWN:
1969 : : break;
1970 : : case FTRACE_BUG_INIT:
1971 : 0 : pr_info("Initializing ftrace call sites\n");
1972 : 0 : break;
1973 : : case FTRACE_BUG_NOP:
1974 : 0 : pr_info("Setting ftrace call site to NOP\n");
1975 : 0 : break;
1976 : : case FTRACE_BUG_CALL:
1977 : 0 : pr_info("Setting ftrace call site to call ftrace function\n");
1978 : 0 : break;
1979 : : case FTRACE_BUG_UPDATE:
1980 : 0 : pr_info("Updating ftrace call site to call a different ftrace function\n");
1981 : 0 : break;
1982 : : }
1983 : 0 : }
1984 : :
1985 : : /**
1986 : : * ftrace_bug - report and shutdown function tracer
1987 : : * @failed: The failed type (EFAULT, EINVAL, EPERM)
1988 : : * @rec: The record that failed
1989 : : *
1990 : : * The arch code that enables or disables the function tracing
1991 : : * can call ftrace_bug() when it has detected a problem in
1992 : : * modifying the code. @failed should be one of either:
1993 : : * EFAULT - if the problem happens on reading the @ip address
1994 : : * EINVAL - if what is read at @ip is not what was expected
1995 : : * EPERM - if the problem happens on writing to the @ip address
1996 : : */
1997 : 0 : void ftrace_bug(int failed, struct dyn_ftrace *rec)
1998 : : {
1999 : 0 : unsigned long ip = rec ? rec->ip : 0;
2000 : :
2001 : 0 : switch (failed) {
2002 : : case -EFAULT:
2003 : 0 : FTRACE_WARN_ON_ONCE(1);
2004 : 0 : pr_info("ftrace faulted on modifying ");
2005 : : print_ip_sym(ip);
2006 : : break;
2007 : : case -EINVAL:
2008 : 0 : FTRACE_WARN_ON_ONCE(1);
2009 : 0 : pr_info("ftrace failed to modify ");
2010 : : print_ip_sym(ip);
2011 : 0 : print_ip_ins(" actual: ", (unsigned char *)ip);
2012 : 0 : pr_cont("\n");
2013 : 0 : if (ftrace_expected) {
2014 : 0 : print_ip_ins(" expected: ", ftrace_expected);
2015 : 0 : pr_cont("\n");
2016 : : }
2017 : : break;
2018 : : case -EPERM:
2019 : 0 : FTRACE_WARN_ON_ONCE(1);
2020 : 0 : pr_info("ftrace faulted on writing ");
2021 : : print_ip_sym(ip);
2022 : : break;
2023 : : default:
2024 : 0 : FTRACE_WARN_ON_ONCE(1);
2025 : 0 : pr_info("ftrace faulted on unknown error ");
2026 : : print_ip_sym(ip);
2027 : : }
2028 : 0 : print_bug_type();
2029 : 0 : if (rec) {
2030 : : struct ftrace_ops *ops = NULL;
2031 : :
2032 : 0 : pr_info("ftrace record flags: %lx\n", rec->flags);
2033 : 0 : pr_cont(" (%ld)%s", ftrace_rec_count(rec),
2034 : : rec->flags & FTRACE_FL_REGS ? " R" : " ");
2035 : 0 : if (rec->flags & FTRACE_FL_TRAMP_EN) {
2036 : 0 : ops = ftrace_find_tramp_ops_any(rec);
2037 : 0 : if (ops) {
2038 : : do {
2039 : 0 : pr_cont("\ttramp: %pS (%pS)",
2040 : : (void *)ops->trampoline,
2041 : : (void *)ops->func);
2042 : 0 : ops = ftrace_find_tramp_ops_next(rec, ops);
2043 : 0 : } while (ops);
2044 : : } else
2045 : 0 : pr_cont("\ttramp: ERROR!");
2046 : :
2047 : : }
2048 : 0 : ip = ftrace_get_addr_curr(rec);
2049 : 0 : pr_cont("\n expected tramp: %lx\n", ip);
2050 : : }
2051 : 0 : }
2052 : :
2053 : 0 : static int ftrace_check_record(struct dyn_ftrace *rec, bool enable, bool update)
2054 : : {
2055 : : unsigned long flag = 0UL;
2056 : :
2057 : 0 : ftrace_bug_type = FTRACE_BUG_UNKNOWN;
2058 : :
2059 : 0 : if (rec->flags & FTRACE_FL_DISABLED)
2060 : : return FTRACE_UPDATE_IGNORE;
2061 : :
2062 : : /*
2063 : : * If we are updating calls:
2064 : : *
2065 : : * If the record has a ref count, then we need to enable it
2066 : : * because someone is using it.
2067 : : *
2068 : : * Otherwise we make sure its disabled.
2069 : : *
2070 : : * If we are disabling calls, then disable all records that
2071 : : * are enabled.
2072 : : */
2073 : 0 : if (enable && ftrace_rec_count(rec))
2074 : : flag = FTRACE_FL_ENABLED;
2075 : :
2076 : : /*
2077 : : * If enabling and the REGS flag does not match the REGS_EN, or
2078 : : * the TRAMP flag doesn't match the TRAMP_EN, then do not ignore
2079 : : * this record. Set flags to fail the compare against ENABLED.
2080 : : */
2081 : 0 : if (flag) {
2082 : 0 : if (!(rec->flags & FTRACE_FL_REGS) !=
2083 : 0 : !(rec->flags & FTRACE_FL_REGS_EN))
2084 : 0 : flag |= FTRACE_FL_REGS;
2085 : :
2086 : 0 : if (!(rec->flags & FTRACE_FL_TRAMP) !=
2087 : 0 : !(rec->flags & FTRACE_FL_TRAMP_EN))
2088 : 0 : flag |= FTRACE_FL_TRAMP;
2089 : : }
2090 : :
2091 : : /* If the state of this record hasn't changed, then do nothing */
2092 : 0 : if ((rec->flags & FTRACE_FL_ENABLED) == flag)
2093 : : return FTRACE_UPDATE_IGNORE;
2094 : :
2095 : 0 : if (flag) {
2096 : : /* Save off if rec is being enabled (for return value) */
2097 : 0 : flag ^= rec->flags & FTRACE_FL_ENABLED;
2098 : :
2099 : 0 : if (update) {
2100 : 0 : rec->flags |= FTRACE_FL_ENABLED;
2101 : 0 : if (flag & FTRACE_FL_REGS) {
2102 : 0 : if (rec->flags & FTRACE_FL_REGS)
2103 : 0 : rec->flags |= FTRACE_FL_REGS_EN;
2104 : : else
2105 : 0 : rec->flags &= ~FTRACE_FL_REGS_EN;
2106 : : }
2107 : 0 : if (flag & FTRACE_FL_TRAMP) {
2108 : 0 : if (rec->flags & FTRACE_FL_TRAMP)
2109 : 0 : rec->flags |= FTRACE_FL_TRAMP_EN;
2110 : : else
2111 : 0 : rec->flags &= ~FTRACE_FL_TRAMP_EN;
2112 : : }
2113 : : }
2114 : :
2115 : : /*
2116 : : * If this record is being updated from a nop, then
2117 : : * return UPDATE_MAKE_CALL.
2118 : : * Otherwise,
2119 : : * return UPDATE_MODIFY_CALL to tell the caller to convert
2120 : : * from the save regs, to a non-save regs function or
2121 : : * vice versa, or from a trampoline call.
2122 : : */
2123 : 0 : if (flag & FTRACE_FL_ENABLED) {
2124 : 0 : ftrace_bug_type = FTRACE_BUG_CALL;
2125 : 0 : return FTRACE_UPDATE_MAKE_CALL;
2126 : : }
2127 : :
2128 : 0 : ftrace_bug_type = FTRACE_BUG_UPDATE;
2129 : 0 : return FTRACE_UPDATE_MODIFY_CALL;
2130 : : }
2131 : :
2132 : 0 : if (update) {
2133 : : /* If there's no more users, clear all flags */
2134 : 0 : if (!ftrace_rec_count(rec))
2135 : 0 : rec->flags = 0;
2136 : : else
2137 : : /*
2138 : : * Just disable the record, but keep the ops TRAMP
2139 : : * and REGS states. The _EN flags must be disabled though.
2140 : : */
2141 : 0 : rec->flags &= ~(FTRACE_FL_ENABLED | FTRACE_FL_TRAMP_EN |
2142 : : FTRACE_FL_REGS_EN);
2143 : : }
2144 : :
2145 : 0 : ftrace_bug_type = FTRACE_BUG_NOP;
2146 : 0 : return FTRACE_UPDATE_MAKE_NOP;
2147 : : }
2148 : :
2149 : : /**
2150 : : * ftrace_update_record, set a record that now is tracing or not
2151 : : * @rec: the record to update
2152 : : * @enable: set to true if the record is tracing, false to force disable
2153 : : *
2154 : : * The records that represent all functions that can be traced need
2155 : : * to be updated when tracing has been enabled.
2156 : : */
2157 : 0 : int ftrace_update_record(struct dyn_ftrace *rec, bool enable)
2158 : : {
2159 : 0 : return ftrace_check_record(rec, enable, true);
2160 : : }
2161 : :
2162 : : /**
2163 : : * ftrace_test_record, check if the record has been enabled or not
2164 : : * @rec: the record to test
2165 : : * @enable: set to true to check if enabled, false if it is disabled
2166 : : *
2167 : : * The arch code may need to test if a record is already set to
2168 : : * tracing to determine how to modify the function code that it
2169 : : * represents.
2170 : : */
2171 : 0 : int ftrace_test_record(struct dyn_ftrace *rec, bool enable)
2172 : : {
2173 : 0 : return ftrace_check_record(rec, enable, false);
2174 : : }
2175 : :
2176 : : static struct ftrace_ops *
2177 : 0 : ftrace_find_tramp_ops_any(struct dyn_ftrace *rec)
2178 : : {
2179 : : struct ftrace_ops *op;
2180 : 0 : unsigned long ip = rec->ip;
2181 : :
2182 : 0 : do_for_each_ftrace_op(op, ftrace_ops_list) {
2183 : :
2184 : 0 : if (!op->trampoline)
2185 : 0 : continue;
2186 : :
2187 : 0 : if (hash_contains_ip(ip, op->func_hash))
2188 : 0 : return op;
2189 : 0 : } while_for_each_ftrace_op(op);
2190 : :
2191 : : return NULL;
2192 : : }
2193 : :
2194 : : static struct ftrace_ops *
2195 : 0 : ftrace_find_tramp_ops_next(struct dyn_ftrace *rec,
2196 : : struct ftrace_ops *op)
2197 : : {
2198 : 0 : unsigned long ip = rec->ip;
2199 : :
2200 : 0 : while_for_each_ftrace_op(op) {
2201 : :
2202 : 0 : if (!op->trampoline)
2203 : 0 : continue;
2204 : :
2205 : 0 : if (hash_contains_ip(ip, op->func_hash))
2206 : 0 : return op;
2207 : : }
2208 : :
2209 : : return NULL;
2210 : : }
2211 : :
2212 : : static struct ftrace_ops *
2213 : 0 : ftrace_find_tramp_ops_curr(struct dyn_ftrace *rec)
2214 : : {
2215 : : struct ftrace_ops *op;
2216 : 0 : unsigned long ip = rec->ip;
2217 : :
2218 : : /*
2219 : : * Need to check removed ops first.
2220 : : * If they are being removed, and this rec has a tramp,
2221 : : * and this rec is in the ops list, then it would be the
2222 : : * one with the tramp.
2223 : : */
2224 : 0 : if (removed_ops) {
2225 : 0 : if (hash_contains_ip(ip, &removed_ops->old_hash))
2226 : 0 : return removed_ops;
2227 : : }
2228 : :
2229 : : /*
2230 : : * Need to find the current trampoline for a rec.
2231 : : * Now, a trampoline is only attached to a rec if there
2232 : : * was a single 'ops' attached to it. But this can be called
2233 : : * when we are adding another op to the rec or removing the
2234 : : * current one. Thus, if the op is being added, we can
2235 : : * ignore it because it hasn't attached itself to the rec
2236 : : * yet.
2237 : : *
2238 : : * If an ops is being modified (hooking to different functions)
2239 : : * then we don't care about the new functions that are being
2240 : : * added, just the old ones (that are probably being removed).
2241 : : *
2242 : : * If we are adding an ops to a function that already is using
2243 : : * a trampoline, it needs to be removed (trampolines are only
2244 : : * for single ops connected), then an ops that is not being
2245 : : * modified also needs to be checked.
2246 : : */
2247 : 0 : do_for_each_ftrace_op(op, ftrace_ops_list) {
2248 : :
2249 : 0 : if (!op->trampoline)
2250 : 0 : continue;
2251 : :
2252 : : /*
2253 : : * If the ops is being added, it hasn't gotten to
2254 : : * the point to be removed from this tree yet.
2255 : : */
2256 : 0 : if (op->flags & FTRACE_OPS_FL_ADDING)
2257 : 0 : continue;
2258 : :
2259 : :
2260 : : /*
2261 : : * If the ops is being modified and is in the old
2262 : : * hash, then it is probably being removed from this
2263 : : * function.
2264 : : */
2265 : 0 : if ((op->flags & FTRACE_OPS_FL_MODIFYING) &&
2266 : 0 : hash_contains_ip(ip, &op->old_hash))
2267 : 0 : return op;
2268 : : /*
2269 : : * If the ops is not being added or modified, and it's
2270 : : * in its normal filter hash, then this must be the one
2271 : : * we want!
2272 : : */
2273 : 0 : if (!(op->flags & FTRACE_OPS_FL_MODIFYING) &&
2274 : 0 : hash_contains_ip(ip, op->func_hash))
2275 : 0 : return op;
2276 : :
2277 : 0 : } while_for_each_ftrace_op(op);
2278 : :
2279 : : return NULL;
2280 : : }
2281 : :
2282 : : static struct ftrace_ops *
2283 : 0 : ftrace_find_tramp_ops_new(struct dyn_ftrace *rec)
2284 : : {
2285 : : struct ftrace_ops *op;
2286 : 0 : unsigned long ip = rec->ip;
2287 : :
2288 : 0 : do_for_each_ftrace_op(op, ftrace_ops_list) {
2289 : : /* pass rec in as regs to have non-NULL val */
2290 : 0 : if (hash_contains_ip(ip, op->func_hash))
2291 : 0 : return op;
2292 : 0 : } while_for_each_ftrace_op(op);
2293 : :
2294 : : return NULL;
2295 : : }
2296 : :
2297 : : /**
2298 : : * ftrace_get_addr_new - Get the call address to set to
2299 : : * @rec: The ftrace record descriptor
2300 : : *
2301 : : * If the record has the FTRACE_FL_REGS set, that means that it
2302 : : * wants to convert to a callback that saves all regs. If FTRACE_FL_REGS
2303 : : * is not not set, then it wants to convert to the normal callback.
2304 : : *
2305 : : * Returns the address of the trampoline to set to
2306 : : */
2307 : 0 : unsigned long ftrace_get_addr_new(struct dyn_ftrace *rec)
2308 : : {
2309 : : struct ftrace_ops *ops;
2310 : :
2311 : : /* Trampolines take precedence over regs */
2312 : 0 : if (rec->flags & FTRACE_FL_TRAMP) {
2313 : 0 : ops = ftrace_find_tramp_ops_new(rec);
2314 : 0 : if (FTRACE_WARN_ON(!ops || !ops->trampoline)) {
2315 : 0 : pr_warn("Bad trampoline accounting at: %p (%pS) (%lx)\n",
2316 : : (void *)rec->ip, (void *)rec->ip, rec->flags);
2317 : : /* Ftrace is shutting down, return anything */
2318 : 0 : return (unsigned long)FTRACE_ADDR;
2319 : : }
2320 : 0 : return ops->trampoline;
2321 : : }
2322 : :
2323 : 0 : if (rec->flags & FTRACE_FL_REGS)
2324 : 0 : return (unsigned long)FTRACE_REGS_ADDR;
2325 : : else
2326 : 0 : return (unsigned long)FTRACE_ADDR;
2327 : : }
2328 : :
2329 : : /**
2330 : : * ftrace_get_addr_curr - Get the call address that is already there
2331 : : * @rec: The ftrace record descriptor
2332 : : *
2333 : : * The FTRACE_FL_REGS_EN is set when the record already points to
2334 : : * a function that saves all the regs. Basically the '_EN' version
2335 : : * represents the current state of the function.
2336 : : *
2337 : : * Returns the address of the trampoline that is currently being called
2338 : : */
2339 : 0 : unsigned long ftrace_get_addr_curr(struct dyn_ftrace *rec)
2340 : : {
2341 : : struct ftrace_ops *ops;
2342 : :
2343 : : /* Trampolines take precedence over regs */
2344 : 0 : if (rec->flags & FTRACE_FL_TRAMP_EN) {
2345 : 0 : ops = ftrace_find_tramp_ops_curr(rec);
2346 : 0 : if (FTRACE_WARN_ON(!ops)) {
2347 : 0 : pr_warn("Bad trampoline accounting at: %p (%pS)\n",
2348 : : (void *)rec->ip, (void *)rec->ip);
2349 : : /* Ftrace is shutting down, return anything */
2350 : 0 : return (unsigned long)FTRACE_ADDR;
2351 : : }
2352 : 0 : return ops->trampoline;
2353 : : }
2354 : :
2355 : 0 : if (rec->flags & FTRACE_FL_REGS_EN)
2356 : 0 : return (unsigned long)FTRACE_REGS_ADDR;
2357 : : else
2358 : 0 : return (unsigned long)FTRACE_ADDR;
2359 : : }
2360 : :
2361 : : static int
2362 : 0 : __ftrace_replace_code(struct dyn_ftrace *rec, bool enable)
2363 : : {
2364 : : unsigned long ftrace_old_addr;
2365 : : unsigned long ftrace_addr;
2366 : : int ret;
2367 : :
2368 : 0 : ftrace_addr = ftrace_get_addr_new(rec);
2369 : :
2370 : : /* This needs to be done before we call ftrace_update_record */
2371 : 0 : ftrace_old_addr = ftrace_get_addr_curr(rec);
2372 : :
2373 : : ret = ftrace_update_record(rec, enable);
2374 : :
2375 : 0 : ftrace_bug_type = FTRACE_BUG_UNKNOWN;
2376 : :
2377 : 0 : switch (ret) {
2378 : : case FTRACE_UPDATE_IGNORE:
2379 : : return 0;
2380 : :
2381 : : case FTRACE_UPDATE_MAKE_CALL:
2382 : 0 : ftrace_bug_type = FTRACE_BUG_CALL;
2383 : 0 : return ftrace_make_call(rec, ftrace_addr);
2384 : :
2385 : : case FTRACE_UPDATE_MAKE_NOP:
2386 : 0 : ftrace_bug_type = FTRACE_BUG_NOP;
2387 : 0 : return ftrace_make_nop(NULL, rec, ftrace_old_addr);
2388 : :
2389 : : case FTRACE_UPDATE_MODIFY_CALL:
2390 : 0 : ftrace_bug_type = FTRACE_BUG_UPDATE;
2391 : 0 : return ftrace_modify_call(rec, ftrace_old_addr, ftrace_addr);
2392 : : }
2393 : :
2394 : 0 : return -1; /* unknown ftrace bug */
2395 : : }
2396 : :
2397 : 0 : void __weak ftrace_replace_code(int mod_flags)
2398 : : {
2399 : : struct dyn_ftrace *rec;
2400 : : struct ftrace_page *pg;
2401 : 0 : bool enable = mod_flags & FTRACE_MODIFY_ENABLE_FL;
2402 : 0 : int schedulable = mod_flags & FTRACE_MODIFY_MAY_SLEEP_FL;
2403 : : int failed;
2404 : :
2405 : 0 : if (unlikely(ftrace_disabled))
2406 : : return;
2407 : :
2408 : 0 : do_for_each_ftrace_rec(pg, rec) {
2409 : :
2410 : 0 : if (rec->flags & FTRACE_FL_DISABLED)
2411 : 0 : continue;
2412 : :
2413 : 0 : failed = __ftrace_replace_code(rec, enable);
2414 : 0 : if (failed) {
2415 : 0 : ftrace_bug(failed, rec);
2416 : : /* Stop processing */
2417 : 0 : return;
2418 : : }
2419 : 0 : if (schedulable)
2420 : 0 : cond_resched();
2421 : : } while_for_each_ftrace_rec();
2422 : : }
2423 : :
2424 : : struct ftrace_rec_iter {
2425 : : struct ftrace_page *pg;
2426 : : int index;
2427 : : };
2428 : :
2429 : : /**
2430 : : * ftrace_rec_iter_start, start up iterating over traced functions
2431 : : *
2432 : : * Returns an iterator handle that is used to iterate over all
2433 : : * the records that represent address locations where functions
2434 : : * are traced.
2435 : : *
2436 : : * May return NULL if no records are available.
2437 : : */
2438 : 0 : struct ftrace_rec_iter *ftrace_rec_iter_start(void)
2439 : : {
2440 : : /*
2441 : : * We only use a single iterator.
2442 : : * Protected by the ftrace_lock mutex.
2443 : : */
2444 : : static struct ftrace_rec_iter ftrace_rec_iter;
2445 : : struct ftrace_rec_iter *iter = &ftrace_rec_iter;
2446 : :
2447 : 0 : iter->pg = ftrace_pages_start;
2448 : 0 : iter->index = 0;
2449 : :
2450 : : /* Could have empty pages */
2451 : 0 : while (iter->pg && !iter->pg->index)
2452 : 0 : iter->pg = iter->pg->next;
2453 : :
2454 : 0 : if (!iter->pg)
2455 : : return NULL;
2456 : :
2457 : 0 : return iter;
2458 : : }
2459 : :
2460 : : /**
2461 : : * ftrace_rec_iter_next, get the next record to process.
2462 : : * @iter: The handle to the iterator.
2463 : : *
2464 : : * Returns the next iterator after the given iterator @iter.
2465 : : */
2466 : 0 : struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter)
2467 : : {
2468 : 0 : iter->index++;
2469 : :
2470 : 0 : if (iter->index >= iter->pg->index) {
2471 : 0 : iter->pg = iter->pg->next;
2472 : 0 : iter->index = 0;
2473 : :
2474 : : /* Could have empty pages */
2475 : 0 : while (iter->pg && !iter->pg->index)
2476 : 0 : iter->pg = iter->pg->next;
2477 : : }
2478 : :
2479 : 0 : if (!iter->pg)
2480 : : return NULL;
2481 : :
2482 : 0 : return iter;
2483 : : }
2484 : :
2485 : : /**
2486 : : * ftrace_rec_iter_record, get the record at the iterator location
2487 : : * @iter: The current iterator location
2488 : : *
2489 : : * Returns the record that the current @iter is at.
2490 : : */
2491 : 0 : struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter)
2492 : : {
2493 : 0 : return &iter->pg->records[iter->index];
2494 : : }
2495 : :
2496 : : static int
2497 : 3 : ftrace_code_disable(struct module *mod, struct dyn_ftrace *rec)
2498 : : {
2499 : : int ret;
2500 : :
2501 : 3 : if (unlikely(ftrace_disabled))
2502 : : return 0;
2503 : :
2504 : 3 : ret = ftrace_make_nop(mod, rec, MCOUNT_ADDR);
2505 : 3 : if (ret) {
2506 : 0 : ftrace_bug_type = FTRACE_BUG_INIT;
2507 : 0 : ftrace_bug(ret, rec);
2508 : 0 : return 0;
2509 : : }
2510 : : return 1;
2511 : : }
2512 : :
2513 : : /*
2514 : : * archs can override this function if they must do something
2515 : : * before the modifying code is performed.
2516 : : */
2517 : 0 : int __weak ftrace_arch_code_modify_prepare(void)
2518 : : {
2519 : 0 : return 0;
2520 : : }
2521 : :
2522 : : /*
2523 : : * archs can override this function if they must do something
2524 : : * after the modifying code is performed.
2525 : : */
2526 : 0 : int __weak ftrace_arch_code_modify_post_process(void)
2527 : : {
2528 : 0 : return 0;
2529 : : }
2530 : :
2531 : 0 : void ftrace_modify_all_code(int command)
2532 : : {
2533 : 0 : int update = command & FTRACE_UPDATE_TRACE_FUNC;
2534 : : int mod_flags = 0;
2535 : : int err = 0;
2536 : :
2537 : 0 : if (command & FTRACE_MAY_SLEEP)
2538 : : mod_flags = FTRACE_MODIFY_MAY_SLEEP_FL;
2539 : :
2540 : : /*
2541 : : * If the ftrace_caller calls a ftrace_ops func directly,
2542 : : * we need to make sure that it only traces functions it
2543 : : * expects to trace. When doing the switch of functions,
2544 : : * we need to update to the ftrace_ops_list_func first
2545 : : * before the transition between old and new calls are set,
2546 : : * as the ftrace_ops_list_func will check the ops hashes
2547 : : * to make sure the ops are having the right functions
2548 : : * traced.
2549 : : */
2550 : 0 : if (update) {
2551 : 0 : err = ftrace_update_ftrace_func(ftrace_ops_list_func);
2552 : 0 : if (FTRACE_WARN_ON(err))
2553 : : return;
2554 : : }
2555 : :
2556 : 0 : if (command & FTRACE_UPDATE_CALLS)
2557 : 0 : ftrace_replace_code(mod_flags | FTRACE_MODIFY_ENABLE_FL);
2558 : 0 : else if (command & FTRACE_DISABLE_CALLS)
2559 : 0 : ftrace_replace_code(mod_flags);
2560 : :
2561 : 0 : if (update && ftrace_trace_function != ftrace_ops_list_func) {
2562 : 0 : function_trace_op = set_function_trace_op;
2563 : 0 : smp_wmb();
2564 : : /* If irqs are disabled, we are in stop machine */
2565 : 0 : if (!irqs_disabled())
2566 : 0 : smp_call_function(ftrace_sync_ipi, NULL, 1);
2567 : 0 : err = ftrace_update_ftrace_func(ftrace_trace_function);
2568 : 0 : if (FTRACE_WARN_ON(err))
2569 : : return;
2570 : : }
2571 : :
2572 : 0 : if (command & FTRACE_START_FUNC_RET)
2573 : 0 : err = ftrace_enable_ftrace_graph_caller();
2574 : 0 : else if (command & FTRACE_STOP_FUNC_RET)
2575 : 0 : err = ftrace_disable_ftrace_graph_caller();
2576 : 0 : FTRACE_WARN_ON(err);
2577 : : }
2578 : :
2579 : 0 : static int __ftrace_modify_code(void *data)
2580 : : {
2581 : : int *command = data;
2582 : :
2583 : 0 : ftrace_modify_all_code(*command);
2584 : :
2585 : 0 : return 0;
2586 : : }
2587 : :
2588 : : /**
2589 : : * ftrace_run_stop_machine, go back to the stop machine method
2590 : : * @command: The command to tell ftrace what to do
2591 : : *
2592 : : * If an arch needs to fall back to the stop machine method, the
2593 : : * it can call this function.
2594 : : */
2595 : 0 : void ftrace_run_stop_machine(int command)
2596 : : {
2597 : 0 : stop_machine(__ftrace_modify_code, &command, NULL);
2598 : 0 : }
2599 : :
2600 : : /**
2601 : : * arch_ftrace_update_code, modify the code to trace or not trace
2602 : : * @command: The command that needs to be done
2603 : : *
2604 : : * Archs can override this function if it does not need to
2605 : : * run stop_machine() to modify code.
2606 : : */
2607 : 0 : void __weak arch_ftrace_update_code(int command)
2608 : : {
2609 : : ftrace_run_stop_machine(command);
2610 : 0 : }
2611 : :
2612 : 0 : static void ftrace_run_update_code(int command)
2613 : : {
2614 : : int ret;
2615 : :
2616 : 0 : ret = ftrace_arch_code_modify_prepare();
2617 : 0 : FTRACE_WARN_ON(ret);
2618 : 0 : if (ret)
2619 : 0 : return;
2620 : :
2621 : : /*
2622 : : * By default we use stop_machine() to modify the code.
2623 : : * But archs can do what ever they want as long as it
2624 : : * is safe. The stop_machine() is the safest, but also
2625 : : * produces the most overhead.
2626 : : */
2627 : 0 : arch_ftrace_update_code(command);
2628 : :
2629 : 0 : ret = ftrace_arch_code_modify_post_process();
2630 : 0 : FTRACE_WARN_ON(ret);
2631 : : }
2632 : :
2633 : : static void ftrace_run_modify_code(struct ftrace_ops *ops, int command,
2634 : : struct ftrace_ops_hash *old_hash)
2635 : : {
2636 : 0 : ops->flags |= FTRACE_OPS_FL_MODIFYING;
2637 : 0 : ops->old_hash.filter_hash = old_hash->filter_hash;
2638 : 0 : ops->old_hash.notrace_hash = old_hash->notrace_hash;
2639 : 0 : ftrace_run_update_code(command);
2640 : 0 : ops->old_hash.filter_hash = NULL;
2641 : 0 : ops->old_hash.notrace_hash = NULL;
2642 : 0 : ops->flags &= ~FTRACE_OPS_FL_MODIFYING;
2643 : : }
2644 : :
2645 : : static ftrace_func_t saved_ftrace_func;
2646 : : static int ftrace_start_up;
2647 : :
2648 : 0 : void __weak arch_ftrace_trampoline_free(struct ftrace_ops *ops)
2649 : : {
2650 : 0 : }
2651 : :
2652 : 0 : static void ftrace_startup_enable(int command)
2653 : : {
2654 : 0 : if (saved_ftrace_func != ftrace_trace_function) {
2655 : 0 : saved_ftrace_func = ftrace_trace_function;
2656 : 0 : command |= FTRACE_UPDATE_TRACE_FUNC;
2657 : : }
2658 : :
2659 : 0 : if (!command || !ftrace_enabled)
2660 : 0 : return;
2661 : :
2662 : 0 : ftrace_run_update_code(command);
2663 : : }
2664 : :
2665 : : static void ftrace_startup_all(int command)
2666 : : {
2667 : 0 : update_all_ops = true;
2668 : 0 : ftrace_startup_enable(command);
2669 : 0 : update_all_ops = false;
2670 : : }
2671 : :
2672 : 0 : int ftrace_startup(struct ftrace_ops *ops, int command)
2673 : : {
2674 : : int ret;
2675 : :
2676 : 0 : if (unlikely(ftrace_disabled))
2677 : : return -ENODEV;
2678 : :
2679 : 0 : ret = __register_ftrace_function(ops);
2680 : 0 : if (ret)
2681 : : return ret;
2682 : :
2683 : 0 : ftrace_start_up++;
2684 : :
2685 : : /*
2686 : : * Note that ftrace probes uses this to start up
2687 : : * and modify functions it will probe. But we still
2688 : : * set the ADDING flag for modification, as probes
2689 : : * do not have trampolines. If they add them in the
2690 : : * future, then the probes will need to distinguish
2691 : : * between adding and updating probes.
2692 : : */
2693 : 0 : ops->flags |= FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_ADDING;
2694 : :
2695 : 0 : ret = ftrace_hash_ipmodify_enable(ops);
2696 : 0 : if (ret < 0) {
2697 : : /* Rollback registration process */
2698 : 0 : __unregister_ftrace_function(ops);
2699 : 0 : ftrace_start_up--;
2700 : 0 : ops->flags &= ~FTRACE_OPS_FL_ENABLED;
2701 : 0 : return ret;
2702 : : }
2703 : :
2704 : 0 : if (ftrace_hash_rec_enable(ops, 1))
2705 : 0 : command |= FTRACE_UPDATE_CALLS;
2706 : :
2707 : 0 : ftrace_startup_enable(command);
2708 : :
2709 : 0 : ops->flags &= ~FTRACE_OPS_FL_ADDING;
2710 : :
2711 : 0 : return 0;
2712 : : }
2713 : :
2714 : 0 : int ftrace_shutdown(struct ftrace_ops *ops, int command)
2715 : : {
2716 : : int ret;
2717 : :
2718 : 0 : if (unlikely(ftrace_disabled))
2719 : : return -ENODEV;
2720 : :
2721 : 0 : ret = __unregister_ftrace_function(ops);
2722 : 0 : if (ret)
2723 : : return ret;
2724 : :
2725 : 0 : ftrace_start_up--;
2726 : : /*
2727 : : * Just warn in case of unbalance, no need to kill ftrace, it's not
2728 : : * critical but the ftrace_call callers may be never nopped again after
2729 : : * further ftrace uses.
2730 : : */
2731 : 0 : WARN_ON_ONCE(ftrace_start_up < 0);
2732 : :
2733 : : /* Disabling ipmodify never fails */
2734 : 0 : ftrace_hash_ipmodify_disable(ops);
2735 : :
2736 : 0 : if (ftrace_hash_rec_disable(ops, 1))
2737 : 0 : command |= FTRACE_UPDATE_CALLS;
2738 : :
2739 : 0 : ops->flags &= ~FTRACE_OPS_FL_ENABLED;
2740 : :
2741 : 0 : if (saved_ftrace_func != ftrace_trace_function) {
2742 : 0 : saved_ftrace_func = ftrace_trace_function;
2743 : 0 : command |= FTRACE_UPDATE_TRACE_FUNC;
2744 : : }
2745 : :
2746 : 0 : if (!command || !ftrace_enabled) {
2747 : : /*
2748 : : * If these are dynamic or per_cpu ops, they still
2749 : : * need their data freed. Since, function tracing is
2750 : : * not currently active, we can just free them
2751 : : * without synchronizing all CPUs.
2752 : : */
2753 : 0 : if (ops->flags & FTRACE_OPS_FL_DYNAMIC)
2754 : : goto free_ops;
2755 : :
2756 : : return 0;
2757 : : }
2758 : :
2759 : : /*
2760 : : * If the ops uses a trampoline, then it needs to be
2761 : : * tested first on update.
2762 : : */
2763 : 0 : ops->flags |= FTRACE_OPS_FL_REMOVING;
2764 : 0 : removed_ops = ops;
2765 : :
2766 : : /* The trampoline logic checks the old hashes */
2767 : 0 : ops->old_hash.filter_hash = ops->func_hash->filter_hash;
2768 : 0 : ops->old_hash.notrace_hash = ops->func_hash->notrace_hash;
2769 : :
2770 : 0 : ftrace_run_update_code(command);
2771 : :
2772 : : /*
2773 : : * If there's no more ops registered with ftrace, run a
2774 : : * sanity check to make sure all rec flags are cleared.
2775 : : */
2776 : 0 : if (rcu_dereference_protected(ftrace_ops_list,
2777 : : lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
2778 : : struct ftrace_page *pg;
2779 : : struct dyn_ftrace *rec;
2780 : :
2781 : 0 : do_for_each_ftrace_rec(pg, rec) {
2782 : 0 : if (FTRACE_WARN_ON_ONCE(rec->flags & ~FTRACE_FL_DISABLED))
2783 : 0 : pr_warn(" %pS flags:%lx\n",
2784 : : (void *)rec->ip, rec->flags);
2785 : : } while_for_each_ftrace_rec();
2786 : : }
2787 : :
2788 : 0 : ops->old_hash.filter_hash = NULL;
2789 : 0 : ops->old_hash.notrace_hash = NULL;
2790 : :
2791 : 0 : removed_ops = NULL;
2792 : 0 : ops->flags &= ~FTRACE_OPS_FL_REMOVING;
2793 : :
2794 : : /*
2795 : : * Dynamic ops may be freed, we must make sure that all
2796 : : * callers are done before leaving this function.
2797 : : * The same goes for freeing the per_cpu data of the per_cpu
2798 : : * ops.
2799 : : */
2800 : 0 : if (ops->flags & FTRACE_OPS_FL_DYNAMIC) {
2801 : : /*
2802 : : * We need to do a hard force of sched synchronization.
2803 : : * This is because we use preempt_disable() to do RCU, but
2804 : : * the function tracers can be called where RCU is not watching
2805 : : * (like before user_exit()). We can not rely on the RCU
2806 : : * infrastructure to do the synchronization, thus we must do it
2807 : : * ourselves.
2808 : : */
2809 : 0 : schedule_on_each_cpu(ftrace_sync);
2810 : :
2811 : : /*
2812 : : * When the kernel is preeptive, tasks can be preempted
2813 : : * while on a ftrace trampoline. Just scheduling a task on
2814 : : * a CPU is not good enough to flush them. Calling
2815 : : * synchornize_rcu_tasks() will wait for those tasks to
2816 : : * execute and either schedule voluntarily or enter user space.
2817 : : */
2818 : : if (IS_ENABLED(CONFIG_PREEMPTION))
2819 : : synchronize_rcu_tasks();
2820 : :
2821 : : free_ops:
2822 : 0 : arch_ftrace_trampoline_free(ops);
2823 : : }
2824 : :
2825 : : return 0;
2826 : : }
2827 : :
2828 : 0 : static void ftrace_startup_sysctl(void)
2829 : : {
2830 : : int command;
2831 : :
2832 : 0 : if (unlikely(ftrace_disabled))
2833 : 0 : return;
2834 : :
2835 : : /* Force update next time */
2836 : 0 : saved_ftrace_func = NULL;
2837 : : /* ftrace_start_up is true if we want ftrace running */
2838 : 0 : if (ftrace_start_up) {
2839 : : command = FTRACE_UPDATE_CALLS;
2840 : 0 : if (ftrace_graph_active)
2841 : : command |= FTRACE_START_FUNC_RET;
2842 : 0 : ftrace_startup_enable(command);
2843 : : }
2844 : : }
2845 : :
2846 : 0 : static void ftrace_shutdown_sysctl(void)
2847 : : {
2848 : : int command;
2849 : :
2850 : 0 : if (unlikely(ftrace_disabled))
2851 : 0 : return;
2852 : :
2853 : : /* ftrace_start_up is true if ftrace is running */
2854 : 0 : if (ftrace_start_up) {
2855 : : command = FTRACE_DISABLE_CALLS;
2856 : 0 : if (ftrace_graph_active)
2857 : : command |= FTRACE_STOP_FUNC_RET;
2858 : 0 : ftrace_run_update_code(command);
2859 : : }
2860 : : }
2861 : :
2862 : : static u64 ftrace_update_time;
2863 : : unsigned long ftrace_update_tot_cnt;
2864 : :
2865 : 0 : static inline int ops_traces_mod(struct ftrace_ops *ops)
2866 : : {
2867 : : /*
2868 : : * Filter_hash being empty will default to trace module.
2869 : : * But notrace hash requires a test of individual module functions.
2870 : : */
2871 : 0 : return ftrace_hash_empty(ops->func_hash->filter_hash) &&
2872 : 0 : ftrace_hash_empty(ops->func_hash->notrace_hash);
2873 : : }
2874 : :
2875 : : /*
2876 : : * Check if the current ops references the record.
2877 : : *
2878 : : * If the ops traces all functions, then it was already accounted for.
2879 : : * If the ops does not trace the current record function, skip it.
2880 : : * If the ops ignores the function via notrace filter, skip it.
2881 : : */
2882 : : static inline bool
2883 : 0 : ops_references_rec(struct ftrace_ops *ops, struct dyn_ftrace *rec)
2884 : : {
2885 : : /* If ops isn't enabled, ignore it */
2886 : 0 : if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
2887 : : return false;
2888 : :
2889 : : /* If ops traces all then it includes this function */
2890 : 0 : if (ops_traces_mod(ops))
2891 : : return true;
2892 : :
2893 : : /* The function must be in the filter */
2894 : 0 : if (!ftrace_hash_empty(ops->func_hash->filter_hash) &&
2895 : 0 : !__ftrace_lookup_ip(ops->func_hash->filter_hash, rec->ip))
2896 : : return false;
2897 : :
2898 : : /* If in notrace hash, we ignore it too */
2899 : 0 : if (ftrace_lookup_ip(ops->func_hash->notrace_hash, rec->ip))
2900 : : return false;
2901 : :
2902 : 0 : return true;
2903 : : }
2904 : :
2905 : 3 : static int ftrace_update_code(struct module *mod, struct ftrace_page *new_pgs)
2906 : : {
2907 : : struct ftrace_page *pg;
2908 : : struct dyn_ftrace *p;
2909 : : u64 start, stop;
2910 : : unsigned long update_cnt = 0;
2911 : : unsigned long rec_flags = 0;
2912 : : int i;
2913 : :
2914 : 3 : start = ftrace_now(raw_smp_processor_id());
2915 : :
2916 : : /*
2917 : : * When a module is loaded, this function is called to convert
2918 : : * the calls to mcount in its text to nops, and also to create
2919 : : * an entry in the ftrace data. Now, if ftrace is activated
2920 : : * after this call, but before the module sets its text to
2921 : : * read-only, the modification of enabling ftrace can fail if
2922 : : * the read-only is done while ftrace is converting the calls.
2923 : : * To prevent this, the module's records are set as disabled
2924 : : * and will be enabled after the call to set the module's text
2925 : : * to read-only.
2926 : : */
2927 : 3 : if (mod)
2928 : : rec_flags |= FTRACE_FL_DISABLED;
2929 : :
2930 : 3 : for (pg = new_pgs; pg; pg = pg->next) {
2931 : :
2932 : 3 : for (i = 0; i < pg->index; i++) {
2933 : :
2934 : : /* If something went wrong, bail without enabling anything */
2935 : 3 : if (unlikely(ftrace_disabled))
2936 : : return -1;
2937 : :
2938 : 3 : p = &pg->records[i];
2939 : 3 : p->flags = rec_flags;
2940 : :
2941 : : /*
2942 : : * Do the initial record conversion from mcount jump
2943 : : * to the NOP instructions.
2944 : : */
2945 : 3 : if (!__is_defined(CC_USING_NOP_MCOUNT) &&
2946 : 3 : !ftrace_code_disable(mod, p))
2947 : : break;
2948 : :
2949 : 3 : update_cnt++;
2950 : : }
2951 : : }
2952 : :
2953 : 3 : stop = ftrace_now(raw_smp_processor_id());
2954 : 3 : ftrace_update_time = stop - start;
2955 : 3 : ftrace_update_tot_cnt += update_cnt;
2956 : :
2957 : 3 : return 0;
2958 : : }
2959 : :
2960 : 3 : static int ftrace_allocate_records(struct ftrace_page *pg, int count)
2961 : : {
2962 : : int order;
2963 : : int cnt;
2964 : :
2965 : 3 : if (WARN_ON(!count))
2966 : : return -EINVAL;
2967 : :
2968 : 3 : order = get_count_order(DIV_ROUND_UP(count, ENTRIES_PER_PAGE));
2969 : :
2970 : : /*
2971 : : * We want to fill as much as possible. No more than a page
2972 : : * may be empty.
2973 : : */
2974 : 3 : while ((PAGE_SIZE << order) / ENTRY_SIZE >= count + ENTRIES_PER_PAGE)
2975 : 3 : order--;
2976 : :
2977 : : again:
2978 : 3 : pg->records = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, order);
2979 : :
2980 : 3 : if (!pg->records) {
2981 : : /* if we can't allocate this size, try something smaller */
2982 : 0 : if (!order)
2983 : : return -ENOMEM;
2984 : 0 : order >>= 1;
2985 : 0 : goto again;
2986 : : }
2987 : :
2988 : 3 : cnt = (PAGE_SIZE << order) / ENTRY_SIZE;
2989 : 3 : pg->size = cnt;
2990 : :
2991 : 3 : if (cnt > count)
2992 : : cnt = count;
2993 : :
2994 : 3 : return cnt;
2995 : : }
2996 : :
2997 : : static struct ftrace_page *
2998 : 3 : ftrace_allocate_pages(unsigned long num_to_init)
2999 : : {
3000 : : struct ftrace_page *start_pg;
3001 : : struct ftrace_page *pg;
3002 : : int order;
3003 : : int cnt;
3004 : :
3005 : 3 : if (!num_to_init)
3006 : : return NULL;
3007 : :
3008 : 3 : start_pg = pg = kzalloc(sizeof(*pg), GFP_KERNEL);
3009 : 3 : if (!pg)
3010 : : return NULL;
3011 : :
3012 : : /*
3013 : : * Try to allocate as much as possible in one continues
3014 : : * location that fills in all of the space. We want to
3015 : : * waste as little space as possible.
3016 : : */
3017 : : for (;;) {
3018 : 3 : cnt = ftrace_allocate_records(pg, num_to_init);
3019 : 3 : if (cnt < 0)
3020 : : goto free_pages;
3021 : :
3022 : 3 : num_to_init -= cnt;
3023 : 3 : if (!num_to_init)
3024 : : break;
3025 : :
3026 : 3 : pg->next = kzalloc(sizeof(*pg), GFP_KERNEL);
3027 : 3 : if (!pg->next)
3028 : : goto free_pages;
3029 : :
3030 : : pg = pg->next;
3031 : : }
3032 : :
3033 : : return start_pg;
3034 : :
3035 : : free_pages:
3036 : : pg = start_pg;
3037 : 0 : while (pg) {
3038 : 0 : order = get_count_order(pg->size / ENTRIES_PER_PAGE);
3039 : 0 : free_pages((unsigned long)pg->records, order);
3040 : 0 : start_pg = pg->next;
3041 : 0 : kfree(pg);
3042 : : pg = start_pg;
3043 : : }
3044 : 0 : pr_info("ftrace: FAILED to allocate memory for functions\n");
3045 : 0 : return NULL;
3046 : : }
3047 : :
3048 : : #define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
3049 : :
3050 : : struct ftrace_iterator {
3051 : : loff_t pos;
3052 : : loff_t func_pos;
3053 : : loff_t mod_pos;
3054 : : struct ftrace_page *pg;
3055 : : struct dyn_ftrace *func;
3056 : : struct ftrace_func_probe *probe;
3057 : : struct ftrace_func_entry *probe_entry;
3058 : : struct trace_parser parser;
3059 : : struct ftrace_hash *hash;
3060 : : struct ftrace_ops *ops;
3061 : : struct trace_array *tr;
3062 : : struct list_head *mod_list;
3063 : : int pidx;
3064 : : int idx;
3065 : : unsigned flags;
3066 : : };
3067 : :
3068 : : static void *
3069 : 0 : t_probe_next(struct seq_file *m, loff_t *pos)
3070 : : {
3071 : 0 : struct ftrace_iterator *iter = m->private;
3072 : 0 : struct trace_array *tr = iter->ops->private;
3073 : : struct list_head *func_probes;
3074 : : struct ftrace_hash *hash;
3075 : : struct list_head *next;
3076 : : struct hlist_node *hnd = NULL;
3077 : : struct hlist_head *hhd;
3078 : : int size;
3079 : :
3080 : 0 : (*pos)++;
3081 : 0 : iter->pos = *pos;
3082 : :
3083 : 0 : if (!tr)
3084 : : return NULL;
3085 : :
3086 : 0 : func_probes = &tr->func_probes;
3087 : 0 : if (list_empty(func_probes))
3088 : : return NULL;
3089 : :
3090 : 0 : if (!iter->probe) {
3091 : 0 : next = func_probes->next;
3092 : 0 : iter->probe = list_entry(next, struct ftrace_func_probe, list);
3093 : : }
3094 : :
3095 : 0 : if (iter->probe_entry)
3096 : 0 : hnd = &iter->probe_entry->hlist;
3097 : :
3098 : 0 : hash = iter->probe->ops.func_hash->filter_hash;
3099 : :
3100 : : /*
3101 : : * A probe being registered may temporarily have an empty hash
3102 : : * and it's at the end of the func_probes list.
3103 : : */
3104 : 0 : if (!hash || hash == EMPTY_HASH)
3105 : : return NULL;
3106 : :
3107 : 0 : size = 1 << hash->size_bits;
3108 : :
3109 : : retry:
3110 : 0 : if (iter->pidx >= size) {
3111 : 0 : if (iter->probe->list.next == func_probes)
3112 : : return NULL;
3113 : : next = iter->probe->list.next;
3114 : 0 : iter->probe = list_entry(next, struct ftrace_func_probe, list);
3115 : 0 : hash = iter->probe->ops.func_hash->filter_hash;
3116 : 0 : size = 1 << hash->size_bits;
3117 : 0 : iter->pidx = 0;
3118 : : }
3119 : :
3120 : 0 : hhd = &hash->buckets[iter->pidx];
3121 : :
3122 : 0 : if (hlist_empty(hhd)) {
3123 : 0 : iter->pidx++;
3124 : : hnd = NULL;
3125 : 0 : goto retry;
3126 : : }
3127 : :
3128 : 0 : if (!hnd)
3129 : 0 : hnd = hhd->first;
3130 : : else {
3131 : 0 : hnd = hnd->next;
3132 : 0 : if (!hnd) {
3133 : 0 : iter->pidx++;
3134 : 0 : goto retry;
3135 : : }
3136 : : }
3137 : :
3138 : 0 : if (WARN_ON_ONCE(!hnd))
3139 : : return NULL;
3140 : :
3141 : 0 : iter->probe_entry = hlist_entry(hnd, struct ftrace_func_entry, hlist);
3142 : :
3143 : 0 : return iter;
3144 : : }
3145 : :
3146 : 0 : static void *t_probe_start(struct seq_file *m, loff_t *pos)
3147 : : {
3148 : 0 : struct ftrace_iterator *iter = m->private;
3149 : : void *p = NULL;
3150 : : loff_t l;
3151 : :
3152 : 0 : if (!(iter->flags & FTRACE_ITER_DO_PROBES))
3153 : : return NULL;
3154 : :
3155 : 0 : if (iter->mod_pos > *pos)
3156 : : return NULL;
3157 : :
3158 : 0 : iter->probe = NULL;
3159 : 0 : iter->probe_entry = NULL;
3160 : 0 : iter->pidx = 0;
3161 : 0 : for (l = 0; l <= (*pos - iter->mod_pos); ) {
3162 : 0 : p = t_probe_next(m, &l);
3163 : 0 : if (!p)
3164 : : break;
3165 : : }
3166 : 0 : if (!p)
3167 : : return NULL;
3168 : :
3169 : : /* Only set this if we have an item */
3170 : 0 : iter->flags |= FTRACE_ITER_PROBE;
3171 : :
3172 : 0 : return iter;
3173 : : }
3174 : :
3175 : : static int
3176 : 0 : t_probe_show(struct seq_file *m, struct ftrace_iterator *iter)
3177 : : {
3178 : : struct ftrace_func_entry *probe_entry;
3179 : : struct ftrace_probe_ops *probe_ops;
3180 : : struct ftrace_func_probe *probe;
3181 : :
3182 : 0 : probe = iter->probe;
3183 : 0 : probe_entry = iter->probe_entry;
3184 : :
3185 : 0 : if (WARN_ON_ONCE(!probe || !probe_entry))
3186 : : return -EIO;
3187 : :
3188 : 0 : probe_ops = probe->probe_ops;
3189 : :
3190 : 0 : if (probe_ops->print)
3191 : 0 : return probe_ops->print(m, probe_entry->ip, probe_ops, probe->data);
3192 : :
3193 : 0 : seq_printf(m, "%ps:%ps\n", (void *)probe_entry->ip,
3194 : 0 : (void *)probe_ops->func);
3195 : :
3196 : 0 : return 0;
3197 : : }
3198 : :
3199 : : static void *
3200 : 0 : t_mod_next(struct seq_file *m, loff_t *pos)
3201 : : {
3202 : 0 : struct ftrace_iterator *iter = m->private;
3203 : 0 : struct trace_array *tr = iter->tr;
3204 : :
3205 : 0 : (*pos)++;
3206 : 0 : iter->pos = *pos;
3207 : :
3208 : 0 : iter->mod_list = iter->mod_list->next;
3209 : :
3210 : 0 : if (iter->mod_list == &tr->mod_trace ||
3211 : 0 : iter->mod_list == &tr->mod_notrace) {
3212 : 0 : iter->flags &= ~FTRACE_ITER_MOD;
3213 : 0 : return NULL;
3214 : : }
3215 : :
3216 : 0 : iter->mod_pos = *pos;
3217 : :
3218 : 0 : return iter;
3219 : : }
3220 : :
3221 : 0 : static void *t_mod_start(struct seq_file *m, loff_t *pos)
3222 : : {
3223 : 0 : struct ftrace_iterator *iter = m->private;
3224 : : void *p = NULL;
3225 : : loff_t l;
3226 : :
3227 : 0 : if (iter->func_pos > *pos)
3228 : : return NULL;
3229 : :
3230 : 0 : iter->mod_pos = iter->func_pos;
3231 : :
3232 : : /* probes are only available if tr is set */
3233 : 0 : if (!iter->tr)
3234 : : return NULL;
3235 : :
3236 : 0 : for (l = 0; l <= (*pos - iter->func_pos); ) {
3237 : 0 : p = t_mod_next(m, &l);
3238 : 0 : if (!p)
3239 : : break;
3240 : : }
3241 : 0 : if (!p) {
3242 : 0 : iter->flags &= ~FTRACE_ITER_MOD;
3243 : 0 : return t_probe_start(m, pos);
3244 : : }
3245 : :
3246 : : /* Only set this if we have an item */
3247 : 0 : iter->flags |= FTRACE_ITER_MOD;
3248 : :
3249 : 0 : return iter;
3250 : : }
3251 : :
3252 : : static int
3253 : 0 : t_mod_show(struct seq_file *m, struct ftrace_iterator *iter)
3254 : : {
3255 : : struct ftrace_mod_load *ftrace_mod;
3256 : 0 : struct trace_array *tr = iter->tr;
3257 : :
3258 : 0 : if (WARN_ON_ONCE(!iter->mod_list) ||
3259 : 0 : iter->mod_list == &tr->mod_trace ||
3260 : 0 : iter->mod_list == &tr->mod_notrace)
3261 : : return -EIO;
3262 : :
3263 : : ftrace_mod = list_entry(iter->mod_list, struct ftrace_mod_load, list);
3264 : :
3265 : 0 : if (ftrace_mod->func)
3266 : 0 : seq_printf(m, "%s", ftrace_mod->func);
3267 : : else
3268 : 0 : seq_putc(m, '*');
3269 : :
3270 : 0 : seq_printf(m, ":mod:%s\n", ftrace_mod->module);
3271 : :
3272 : 0 : return 0;
3273 : : }
3274 : :
3275 : : static void *
3276 : 0 : t_func_next(struct seq_file *m, loff_t *pos)
3277 : : {
3278 : 0 : struct ftrace_iterator *iter = m->private;
3279 : : struct dyn_ftrace *rec = NULL;
3280 : :
3281 : 0 : (*pos)++;
3282 : :
3283 : : retry:
3284 : 0 : if (iter->idx >= iter->pg->index) {
3285 : 0 : if (iter->pg->next) {
3286 : 0 : iter->pg = iter->pg->next;
3287 : 0 : iter->idx = 0;
3288 : 0 : goto retry;
3289 : : }
3290 : : } else {
3291 : 0 : rec = &iter->pg->records[iter->idx++];
3292 : 0 : if (((iter->flags & (FTRACE_ITER_FILTER | FTRACE_ITER_NOTRACE)) &&
3293 : 0 : !ftrace_lookup_ip(iter->hash, rec->ip)) ||
3294 : :
3295 : 0 : ((iter->flags & FTRACE_ITER_ENABLED) &&
3296 : 0 : !(rec->flags & FTRACE_FL_ENABLED))) {
3297 : :
3298 : : rec = NULL;
3299 : : goto retry;
3300 : : }
3301 : : }
3302 : :
3303 : 0 : if (!rec)
3304 : : return NULL;
3305 : :
3306 : 0 : iter->pos = iter->func_pos = *pos;
3307 : 0 : iter->func = rec;
3308 : :
3309 : 0 : return iter;
3310 : : }
3311 : :
3312 : : static void *
3313 : 0 : t_next(struct seq_file *m, void *v, loff_t *pos)
3314 : : {
3315 : 0 : struct ftrace_iterator *iter = m->private;
3316 : 0 : loff_t l = *pos; /* t_probe_start() must use original pos */
3317 : : void *ret;
3318 : :
3319 : 0 : if (unlikely(ftrace_disabled))
3320 : : return NULL;
3321 : :
3322 : 0 : if (iter->flags & FTRACE_ITER_PROBE)
3323 : 0 : return t_probe_next(m, pos);
3324 : :
3325 : 0 : if (iter->flags & FTRACE_ITER_MOD)
3326 : 0 : return t_mod_next(m, pos);
3327 : :
3328 : 0 : if (iter->flags & FTRACE_ITER_PRINTALL) {
3329 : : /* next must increment pos, and t_probe_start does not */
3330 : 0 : (*pos)++;
3331 : 0 : return t_mod_start(m, &l);
3332 : : }
3333 : :
3334 : 0 : ret = t_func_next(m, pos);
3335 : :
3336 : 0 : if (!ret)
3337 : 0 : return t_mod_start(m, &l);
3338 : :
3339 : : return ret;
3340 : : }
3341 : :
3342 : : static void reset_iter_read(struct ftrace_iterator *iter)
3343 : : {
3344 : 0 : iter->pos = 0;
3345 : 0 : iter->func_pos = 0;
3346 : 0 : iter->flags &= ~(FTRACE_ITER_PRINTALL | FTRACE_ITER_PROBE | FTRACE_ITER_MOD);
3347 : : }
3348 : :
3349 : 0 : static void *t_start(struct seq_file *m, loff_t *pos)
3350 : : {
3351 : 0 : struct ftrace_iterator *iter = m->private;
3352 : : void *p = NULL;
3353 : : loff_t l;
3354 : :
3355 : 0 : mutex_lock(&ftrace_lock);
3356 : :
3357 : 0 : if (unlikely(ftrace_disabled))
3358 : : return NULL;
3359 : :
3360 : : /*
3361 : : * If an lseek was done, then reset and start from beginning.
3362 : : */
3363 : 0 : if (*pos < iter->pos)
3364 : : reset_iter_read(iter);
3365 : :
3366 : : /*
3367 : : * For set_ftrace_filter reading, if we have the filter
3368 : : * off, we can short cut and just print out that all
3369 : : * functions are enabled.
3370 : : */
3371 : 0 : if ((iter->flags & (FTRACE_ITER_FILTER | FTRACE_ITER_NOTRACE)) &&
3372 : 0 : ftrace_hash_empty(iter->hash)) {
3373 : 0 : iter->func_pos = 1; /* Account for the message */
3374 : 0 : if (*pos > 0)
3375 : 0 : return t_mod_start(m, pos);
3376 : 0 : iter->flags |= FTRACE_ITER_PRINTALL;
3377 : : /* reset in case of seek/pread */
3378 : 0 : iter->flags &= ~FTRACE_ITER_PROBE;
3379 : 0 : return iter;
3380 : : }
3381 : :
3382 : 0 : if (iter->flags & FTRACE_ITER_MOD)
3383 : 0 : return t_mod_start(m, pos);
3384 : :
3385 : : /*
3386 : : * Unfortunately, we need to restart at ftrace_pages_start
3387 : : * every time we let go of the ftrace_mutex. This is because
3388 : : * those pointers can change without the lock.
3389 : : */
3390 : 0 : iter->pg = ftrace_pages_start;
3391 : 0 : iter->idx = 0;
3392 : 0 : for (l = 0; l <= *pos; ) {
3393 : 0 : p = t_func_next(m, &l);
3394 : 0 : if (!p)
3395 : : break;
3396 : : }
3397 : :
3398 : 0 : if (!p)
3399 : 0 : return t_mod_start(m, pos);
3400 : :
3401 : : return iter;
3402 : : }
3403 : :
3404 : 0 : static void t_stop(struct seq_file *m, void *p)
3405 : : {
3406 : 0 : mutex_unlock(&ftrace_lock);
3407 : 0 : }
3408 : :
3409 : : void * __weak
3410 : 0 : arch_ftrace_trampoline_func(struct ftrace_ops *ops, struct dyn_ftrace *rec)
3411 : : {
3412 : 0 : return NULL;
3413 : : }
3414 : :
3415 : 0 : static void add_trampoline_func(struct seq_file *m, struct ftrace_ops *ops,
3416 : : struct dyn_ftrace *rec)
3417 : : {
3418 : : void *ptr;
3419 : :
3420 : 0 : ptr = arch_ftrace_trampoline_func(ops, rec);
3421 : 0 : if (ptr)
3422 : 0 : seq_printf(m, " ->%pS", ptr);
3423 : 0 : }
3424 : :
3425 : 0 : static int t_show(struct seq_file *m, void *v)
3426 : : {
3427 : 0 : struct ftrace_iterator *iter = m->private;
3428 : : struct dyn_ftrace *rec;
3429 : :
3430 : 0 : if (iter->flags & FTRACE_ITER_PROBE)
3431 : 0 : return t_probe_show(m, iter);
3432 : :
3433 : 0 : if (iter->flags & FTRACE_ITER_MOD)
3434 : 0 : return t_mod_show(m, iter);
3435 : :
3436 : 0 : if (iter->flags & FTRACE_ITER_PRINTALL) {
3437 : 0 : if (iter->flags & FTRACE_ITER_NOTRACE)
3438 : 0 : seq_puts(m, "#### no functions disabled ####\n");
3439 : : else
3440 : 0 : seq_puts(m, "#### all functions enabled ####\n");
3441 : : return 0;
3442 : : }
3443 : :
3444 : 0 : rec = iter->func;
3445 : :
3446 : 0 : if (!rec)
3447 : : return 0;
3448 : :
3449 : 0 : seq_printf(m, "%ps", (void *)rec->ip);
3450 : 0 : if (iter->flags & FTRACE_ITER_ENABLED) {
3451 : : struct ftrace_ops *ops;
3452 : :
3453 : 0 : seq_printf(m, " (%ld)%s%s",
3454 : 0 : ftrace_rec_count(rec),
3455 : 0 : rec->flags & FTRACE_FL_REGS ? " R" : " ",
3456 : 0 : rec->flags & FTRACE_FL_IPMODIFY ? " I" : " ");
3457 : 0 : if (rec->flags & FTRACE_FL_TRAMP_EN) {
3458 : 0 : ops = ftrace_find_tramp_ops_any(rec);
3459 : 0 : if (ops) {
3460 : : do {
3461 : 0 : seq_printf(m, "\ttramp: %pS (%pS)",
3462 : 0 : (void *)ops->trampoline,
3463 : 0 : (void *)ops->func);
3464 : 0 : add_trampoline_func(m, ops, rec);
3465 : 0 : ops = ftrace_find_tramp_ops_next(rec, ops);
3466 : 0 : } while (ops);
3467 : : } else
3468 : 0 : seq_puts(m, "\ttramp: ERROR!");
3469 : : } else {
3470 : 0 : add_trampoline_func(m, NULL, rec);
3471 : : }
3472 : : }
3473 : :
3474 : 0 : seq_putc(m, '\n');
3475 : :
3476 : 0 : return 0;
3477 : : }
3478 : :
3479 : : static const struct seq_operations show_ftrace_seq_ops = {
3480 : : .start = t_start,
3481 : : .next = t_next,
3482 : : .stop = t_stop,
3483 : : .show = t_show,
3484 : : };
3485 : :
3486 : : static int
3487 : 0 : ftrace_avail_open(struct inode *inode, struct file *file)
3488 : : {
3489 : : struct ftrace_iterator *iter;
3490 : : int ret;
3491 : :
3492 : 0 : ret = security_locked_down(LOCKDOWN_TRACEFS);
3493 : 0 : if (ret)
3494 : : return ret;
3495 : :
3496 : 0 : if (unlikely(ftrace_disabled))
3497 : : return -ENODEV;
3498 : :
3499 : 0 : iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
3500 : 0 : if (!iter)
3501 : : return -ENOMEM;
3502 : :
3503 : 0 : iter->pg = ftrace_pages_start;
3504 : 0 : iter->ops = &global_ops;
3505 : :
3506 : 0 : return 0;
3507 : : }
3508 : :
3509 : : static int
3510 : 0 : ftrace_enabled_open(struct inode *inode, struct file *file)
3511 : : {
3512 : : struct ftrace_iterator *iter;
3513 : :
3514 : : /*
3515 : : * This shows us what functions are currently being
3516 : : * traced and by what. Not sure if we want lockdown
3517 : : * to hide such critical information for an admin.
3518 : : * Although, perhaps it can show information we don't
3519 : : * want people to see, but if something is tracing
3520 : : * something, we probably want to know about it.
3521 : : */
3522 : :
3523 : 0 : iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
3524 : 0 : if (!iter)
3525 : : return -ENOMEM;
3526 : :
3527 : 0 : iter->pg = ftrace_pages_start;
3528 : 0 : iter->flags = FTRACE_ITER_ENABLED;
3529 : 0 : iter->ops = &global_ops;
3530 : :
3531 : 0 : return 0;
3532 : : }
3533 : :
3534 : : /**
3535 : : * ftrace_regex_open - initialize function tracer filter files
3536 : : * @ops: The ftrace_ops that hold the hash filters
3537 : : * @flag: The type of filter to process
3538 : : * @inode: The inode, usually passed in to your open routine
3539 : : * @file: The file, usually passed in to your open routine
3540 : : *
3541 : : * ftrace_regex_open() initializes the filter files for the
3542 : : * @ops. Depending on @flag it may process the filter hash or
3543 : : * the notrace hash of @ops. With this called from the open
3544 : : * routine, you can use ftrace_filter_write() for the write
3545 : : * routine if @flag has FTRACE_ITER_FILTER set, or
3546 : : * ftrace_notrace_write() if @flag has FTRACE_ITER_NOTRACE set.
3547 : : * tracing_lseek() should be used as the lseek routine, and
3548 : : * release must call ftrace_regex_release().
3549 : : */
3550 : : int
3551 : 0 : ftrace_regex_open(struct ftrace_ops *ops, int flag,
3552 : : struct inode *inode, struct file *file)
3553 : : {
3554 : : struct ftrace_iterator *iter;
3555 : : struct ftrace_hash *hash;
3556 : : struct list_head *mod_head;
3557 : 0 : struct trace_array *tr = ops->private;
3558 : : int ret = -ENOMEM;
3559 : :
3560 : 0 : ftrace_ops_init(ops);
3561 : :
3562 : 0 : if (unlikely(ftrace_disabled))
3563 : : return -ENODEV;
3564 : :
3565 : 0 : if (tracing_check_open_get_tr(tr))
3566 : : return -ENODEV;
3567 : :
3568 : 0 : iter = kzalloc(sizeof(*iter), GFP_KERNEL);
3569 : 0 : if (!iter)
3570 : : goto out;
3571 : :
3572 : 0 : if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX))
3573 : : goto out;
3574 : :
3575 : 0 : iter->ops = ops;
3576 : 0 : iter->flags = flag;
3577 : 0 : iter->tr = tr;
3578 : :
3579 : 0 : mutex_lock(&ops->func_hash->regex_lock);
3580 : :
3581 : 0 : if (flag & FTRACE_ITER_NOTRACE) {
3582 : 0 : hash = ops->func_hash->notrace_hash;
3583 : 0 : mod_head = tr ? &tr->mod_notrace : NULL;
3584 : : } else {
3585 : 0 : hash = ops->func_hash->filter_hash;
3586 : 0 : mod_head = tr ? &tr->mod_trace : NULL;
3587 : : }
3588 : :
3589 : 0 : iter->mod_list = mod_head;
3590 : :
3591 : 0 : if (file->f_mode & FMODE_WRITE) {
3592 : : const int size_bits = FTRACE_HASH_DEFAULT_BITS;
3593 : :
3594 : 0 : if (file->f_flags & O_TRUNC) {
3595 : 0 : iter->hash = alloc_ftrace_hash(size_bits);
3596 : 0 : clear_ftrace_mod_list(mod_head);
3597 : : } else {
3598 : 0 : iter->hash = alloc_and_copy_ftrace_hash(size_bits, hash);
3599 : : }
3600 : :
3601 : 0 : if (!iter->hash) {
3602 : 0 : trace_parser_put(&iter->parser);
3603 : 0 : goto out_unlock;
3604 : : }
3605 : : } else
3606 : 0 : iter->hash = hash;
3607 : :
3608 : : ret = 0;
3609 : :
3610 : 0 : if (file->f_mode & FMODE_READ) {
3611 : 0 : iter->pg = ftrace_pages_start;
3612 : :
3613 : 0 : ret = seq_open(file, &show_ftrace_seq_ops);
3614 : 0 : if (!ret) {
3615 : 0 : struct seq_file *m = file->private_data;
3616 : 0 : m->private = iter;
3617 : : } else {
3618 : : /* Failed */
3619 : 0 : free_ftrace_hash(iter->hash);
3620 : 0 : trace_parser_put(&iter->parser);
3621 : : }
3622 : : } else
3623 : 0 : file->private_data = iter;
3624 : :
3625 : : out_unlock:
3626 : 0 : mutex_unlock(&ops->func_hash->regex_lock);
3627 : :
3628 : : out:
3629 : 0 : if (ret) {
3630 : 0 : kfree(iter);
3631 : 0 : if (tr)
3632 : 0 : trace_array_put(tr);
3633 : : }
3634 : :
3635 : 0 : return ret;
3636 : : }
3637 : :
3638 : : static int
3639 : 0 : ftrace_filter_open(struct inode *inode, struct file *file)
3640 : : {
3641 : 0 : struct ftrace_ops *ops = inode->i_private;
3642 : :
3643 : : /* Checks for tracefs lockdown */
3644 : 0 : return ftrace_regex_open(ops,
3645 : : FTRACE_ITER_FILTER | FTRACE_ITER_DO_PROBES,
3646 : : inode, file);
3647 : : }
3648 : :
3649 : : static int
3650 : 0 : ftrace_notrace_open(struct inode *inode, struct file *file)
3651 : : {
3652 : 0 : struct ftrace_ops *ops = inode->i_private;
3653 : :
3654 : : /* Checks for tracefs lockdown */
3655 : 0 : return ftrace_regex_open(ops, FTRACE_ITER_NOTRACE,
3656 : : inode, file);
3657 : : }
3658 : :
3659 : : /* Type for quick search ftrace basic regexes (globs) from filter_parse_regex */
3660 : : struct ftrace_glob {
3661 : : char *search;
3662 : : unsigned len;
3663 : : int type;
3664 : : };
3665 : :
3666 : : /*
3667 : : * If symbols in an architecture don't correspond exactly to the user-visible
3668 : : * name of what they represent, it is possible to define this function to
3669 : : * perform the necessary adjustments.
3670 : : */
3671 : 0 : char * __weak arch_ftrace_match_adjust(char *str, const char *search)
3672 : : {
3673 : 0 : return str;
3674 : : }
3675 : :
3676 : 0 : static int ftrace_match(char *str, struct ftrace_glob *g)
3677 : : {
3678 : : int matched = 0;
3679 : : int slen;
3680 : :
3681 : 0 : str = arch_ftrace_match_adjust(str, g->search);
3682 : :
3683 : 0 : switch (g->type) {
3684 : : case MATCH_FULL:
3685 : 0 : if (strcmp(str, g->search) == 0)
3686 : : matched = 1;
3687 : : break;
3688 : : case MATCH_FRONT_ONLY:
3689 : 0 : if (strncmp(str, g->search, g->len) == 0)
3690 : : matched = 1;
3691 : : break;
3692 : : case MATCH_MIDDLE_ONLY:
3693 : 0 : if (strstr(str, g->search))
3694 : : matched = 1;
3695 : : break;
3696 : : case MATCH_END_ONLY:
3697 : 0 : slen = strlen(str);
3698 : 0 : if (slen >= g->len &&
3699 : 0 : memcmp(str + slen - g->len, g->search, g->len) == 0)
3700 : : matched = 1;
3701 : : break;
3702 : : case MATCH_GLOB:
3703 : 0 : if (glob_match(g->search, str))
3704 : : matched = 1;
3705 : : break;
3706 : : }
3707 : :
3708 : 0 : return matched;
3709 : : }
3710 : :
3711 : : static int
3712 : 0 : enter_record(struct ftrace_hash *hash, struct dyn_ftrace *rec, int clear_filter)
3713 : : {
3714 : : struct ftrace_func_entry *entry;
3715 : : int ret = 0;
3716 : :
3717 : 0 : entry = ftrace_lookup_ip(hash, rec->ip);
3718 : 0 : if (clear_filter) {
3719 : : /* Do nothing if it doesn't exist */
3720 : 0 : if (!entry)
3721 : : return 0;
3722 : :
3723 : 0 : free_hash_entry(hash, entry);
3724 : : } else {
3725 : : /* Do nothing if it exists */
3726 : 0 : if (entry)
3727 : : return 0;
3728 : :
3729 : 0 : ret = add_hash_entry(hash, rec->ip);
3730 : : }
3731 : 0 : return ret;
3732 : : }
3733 : :
3734 : : static int
3735 : 0 : add_rec_by_index(struct ftrace_hash *hash, struct ftrace_glob *func_g,
3736 : : int clear_filter)
3737 : : {
3738 : 0 : long index = simple_strtoul(func_g->search, NULL, 0);
3739 : : struct ftrace_page *pg;
3740 : : struct dyn_ftrace *rec;
3741 : :
3742 : : /* The index starts at 1 */
3743 : 0 : if (--index < 0)
3744 : : return 0;
3745 : :
3746 : 0 : do_for_each_ftrace_rec(pg, rec) {
3747 : 0 : if (pg->index <= index) {
3748 : 0 : index -= pg->index;
3749 : : /* this is a double loop, break goes to the next page */
3750 : 0 : break;
3751 : : }
3752 : 0 : rec = &pg->records[index];
3753 : 0 : enter_record(hash, rec, clear_filter);
3754 : 0 : return 1;
3755 : : } while_for_each_ftrace_rec();
3756 : : return 0;
3757 : : }
3758 : :
3759 : : static int
3760 : 0 : ftrace_match_record(struct dyn_ftrace *rec, struct ftrace_glob *func_g,
3761 : : struct ftrace_glob *mod_g, int exclude_mod)
3762 : : {
3763 : : char str[KSYM_SYMBOL_LEN];
3764 : : char *modname;
3765 : :
3766 : 0 : kallsyms_lookup(rec->ip, NULL, NULL, &modname, str);
3767 : :
3768 : 0 : if (mod_g) {
3769 : 0 : int mod_matches = (modname) ? ftrace_match(modname, mod_g) : 0;
3770 : :
3771 : : /* blank module name to match all modules */
3772 : 0 : if (!mod_g->len) {
3773 : : /* blank module globbing: modname xor exclude_mod */
3774 : 0 : if (!exclude_mod != !modname)
3775 : : goto func_match;
3776 : : return 0;
3777 : : }
3778 : :
3779 : : /*
3780 : : * exclude_mod is set to trace everything but the given
3781 : : * module. If it is set and the module matches, then
3782 : : * return 0. If it is not set, and the module doesn't match
3783 : : * also return 0. Otherwise, check the function to see if
3784 : : * that matches.
3785 : : */
3786 : 0 : if (!mod_matches == !exclude_mod)
3787 : : return 0;
3788 : : func_match:
3789 : : /* blank search means to match all funcs in the mod */
3790 : 0 : if (!func_g->len)
3791 : : return 1;
3792 : : }
3793 : :
3794 : 0 : return ftrace_match(str, func_g);
3795 : : }
3796 : :
3797 : : static int
3798 : 0 : match_records(struct ftrace_hash *hash, char *func, int len, char *mod)
3799 : : {
3800 : : struct ftrace_page *pg;
3801 : : struct dyn_ftrace *rec;
3802 : 0 : struct ftrace_glob func_g = { .type = MATCH_FULL };
3803 : 0 : struct ftrace_glob mod_g = { .type = MATCH_FULL };
3804 : 0 : struct ftrace_glob *mod_match = (mod) ? &mod_g : NULL;
3805 : 0 : int exclude_mod = 0;
3806 : : int found = 0;
3807 : : int ret;
3808 : 0 : int clear_filter = 0;
3809 : :
3810 : 0 : if (func) {
3811 : 0 : func_g.type = filter_parse_regex(func, len, &func_g.search,
3812 : : &clear_filter);
3813 : 0 : func_g.len = strlen(func_g.search);
3814 : : }
3815 : :
3816 : 0 : if (mod) {
3817 : 0 : mod_g.type = filter_parse_regex(mod, strlen(mod),
3818 : : &mod_g.search, &exclude_mod);
3819 : 0 : mod_g.len = strlen(mod_g.search);
3820 : : }
3821 : :
3822 : 0 : mutex_lock(&ftrace_lock);
3823 : :
3824 : 0 : if (unlikely(ftrace_disabled))
3825 : : goto out_unlock;
3826 : :
3827 : 0 : if (func_g.type == MATCH_INDEX) {
3828 : 0 : found = add_rec_by_index(hash, &func_g, clear_filter);
3829 : 0 : goto out_unlock;
3830 : : }
3831 : :
3832 : 0 : do_for_each_ftrace_rec(pg, rec) {
3833 : :
3834 : 0 : if (rec->flags & FTRACE_FL_DISABLED)
3835 : 0 : continue;
3836 : :
3837 : 0 : if (ftrace_match_record(rec, &func_g, mod_match, exclude_mod)) {
3838 : 0 : ret = enter_record(hash, rec, clear_filter);
3839 : 0 : if (ret < 0) {
3840 : 0 : found = ret;
3841 : 0 : goto out_unlock;
3842 : : }
3843 : : found = 1;
3844 : : }
3845 : : } while_for_each_ftrace_rec();
3846 : : out_unlock:
3847 : 0 : mutex_unlock(&ftrace_lock);
3848 : :
3849 : 0 : return found;
3850 : : }
3851 : :
3852 : : static int
3853 : : ftrace_match_records(struct ftrace_hash *hash, char *buff, int len)
3854 : : {
3855 : 0 : return match_records(hash, buff, len, NULL);
3856 : : }
3857 : :
3858 : 0 : static void ftrace_ops_update_code(struct ftrace_ops *ops,
3859 : : struct ftrace_ops_hash *old_hash)
3860 : : {
3861 : : struct ftrace_ops *op;
3862 : :
3863 : 0 : if (!ftrace_enabled)
3864 : : return;
3865 : :
3866 : 0 : if (ops->flags & FTRACE_OPS_FL_ENABLED) {
3867 : : ftrace_run_modify_code(ops, FTRACE_UPDATE_CALLS, old_hash);
3868 : : return;
3869 : : }
3870 : :
3871 : : /*
3872 : : * If this is the shared global_ops filter, then we need to
3873 : : * check if there is another ops that shares it, is enabled.
3874 : : * If so, we still need to run the modify code.
3875 : : */
3876 : 0 : if (ops->func_hash != &global_ops.local_hash)
3877 : : return;
3878 : :
3879 : 0 : do_for_each_ftrace_op(op, ftrace_ops_list) {
3880 : 0 : if (op->func_hash == &global_ops.local_hash &&
3881 : 0 : op->flags & FTRACE_OPS_FL_ENABLED) {
3882 : : ftrace_run_modify_code(op, FTRACE_UPDATE_CALLS, old_hash);
3883 : : /* Only need to do this once */
3884 : : return;
3885 : : }
3886 : 0 : } while_for_each_ftrace_op(op);
3887 : : }
3888 : :
3889 : 0 : static int ftrace_hash_move_and_update_ops(struct ftrace_ops *ops,
3890 : : struct ftrace_hash **orig_hash,
3891 : : struct ftrace_hash *hash,
3892 : : int enable)
3893 : : {
3894 : : struct ftrace_ops_hash old_hash_ops;
3895 : : struct ftrace_hash *old_hash;
3896 : : int ret;
3897 : :
3898 : 0 : old_hash = *orig_hash;
3899 : 0 : old_hash_ops.filter_hash = ops->func_hash->filter_hash;
3900 : 0 : old_hash_ops.notrace_hash = ops->func_hash->notrace_hash;
3901 : 0 : ret = ftrace_hash_move(ops, enable, orig_hash, hash);
3902 : 0 : if (!ret) {
3903 : 0 : ftrace_ops_update_code(ops, &old_hash_ops);
3904 : : free_ftrace_hash_rcu(old_hash);
3905 : : }
3906 : 0 : return ret;
3907 : : }
3908 : :
3909 : 0 : static bool module_exists(const char *module)
3910 : : {
3911 : : /* All modules have the symbol __this_module */
3912 : : static const char this_mod[] = "__this_module";
3913 : : char modname[MAX_PARAM_PREFIX_LEN + sizeof(this_mod) + 2];
3914 : : unsigned long val;
3915 : : int n;
3916 : :
3917 : 0 : n = snprintf(modname, sizeof(modname), "%s:%s", module, this_mod);
3918 : :
3919 : 0 : if (n > sizeof(modname) - 1)
3920 : : return false;
3921 : :
3922 : 0 : val = module_kallsyms_lookup_name(modname);
3923 : 0 : return val != 0;
3924 : : }
3925 : :
3926 : 0 : static int cache_mod(struct trace_array *tr,
3927 : : const char *func, char *module, int enable)
3928 : : {
3929 : : struct ftrace_mod_load *ftrace_mod, *n;
3930 : 0 : struct list_head *head = enable ? &tr->mod_trace : &tr->mod_notrace;
3931 : : int ret;
3932 : :
3933 : 0 : mutex_lock(&ftrace_lock);
3934 : :
3935 : : /* We do not cache inverse filters */
3936 : 0 : if (func[0] == '!') {
3937 : 0 : func++;
3938 : : ret = -EINVAL;
3939 : :
3940 : : /* Look to remove this hash */
3941 : 0 : list_for_each_entry_safe(ftrace_mod, n, head, list) {
3942 : 0 : if (strcmp(ftrace_mod->module, module) != 0)
3943 : 0 : continue;
3944 : :
3945 : : /* no func matches all */
3946 : 0 : if (strcmp(func, "*") == 0 ||
3947 : 0 : (ftrace_mod->func &&
3948 : 0 : strcmp(ftrace_mod->func, func) == 0)) {
3949 : : ret = 0;
3950 : 0 : free_ftrace_mod(ftrace_mod);
3951 : 0 : continue;
3952 : : }
3953 : : }
3954 : : goto out;
3955 : : }
3956 : :
3957 : : ret = -EINVAL;
3958 : : /* We only care about modules that have not been loaded yet */
3959 : 0 : if (module_exists(module))
3960 : : goto out;
3961 : :
3962 : : /* Save this string off, and execute it when the module is loaded */
3963 : 0 : ret = ftrace_add_mod(tr, func, module, enable);
3964 : : out:
3965 : 0 : mutex_unlock(&ftrace_lock);
3966 : :
3967 : 0 : return ret;
3968 : : }
3969 : :
3970 : : static int
3971 : : ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len,
3972 : : int reset, int enable);
3973 : :
3974 : : #ifdef CONFIG_MODULES
3975 : 0 : static void process_mod_list(struct list_head *head, struct ftrace_ops *ops,
3976 : : char *mod, bool enable)
3977 : : {
3978 : : struct ftrace_mod_load *ftrace_mod, *n;
3979 : : struct ftrace_hash **orig_hash, *new_hash;
3980 : 0 : LIST_HEAD(process_mods);
3981 : : char *func;
3982 : : int ret;
3983 : :
3984 : 0 : mutex_lock(&ops->func_hash->regex_lock);
3985 : :
3986 : 0 : if (enable)
3987 : 0 : orig_hash = &ops->func_hash->filter_hash;
3988 : : else
3989 : 0 : orig_hash = &ops->func_hash->notrace_hash;
3990 : :
3991 : 0 : new_hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS,
3992 : : *orig_hash);
3993 : 0 : if (!new_hash)
3994 : : goto out; /* warn? */
3995 : :
3996 : 0 : mutex_lock(&ftrace_lock);
3997 : :
3998 : 0 : list_for_each_entry_safe(ftrace_mod, n, head, list) {
3999 : :
4000 : 0 : if (strcmp(ftrace_mod->module, mod) != 0)
4001 : 0 : continue;
4002 : :
4003 : 0 : if (ftrace_mod->func)
4004 : 0 : func = kstrdup(ftrace_mod->func, GFP_KERNEL);
4005 : : else
4006 : 0 : func = kstrdup("*", GFP_KERNEL);
4007 : :
4008 : 0 : if (!func) /* warn? */
4009 : 0 : continue;
4010 : :
4011 : : list_del(&ftrace_mod->list);
4012 : : list_add(&ftrace_mod->list, &process_mods);
4013 : :
4014 : : /* Use the newly allocated func, as it may be "*" */
4015 : 0 : kfree(ftrace_mod->func);
4016 : 0 : ftrace_mod->func = func;
4017 : : }
4018 : :
4019 : 0 : mutex_unlock(&ftrace_lock);
4020 : :
4021 : 0 : list_for_each_entry_safe(ftrace_mod, n, &process_mods, list) {
4022 : :
4023 : 0 : func = ftrace_mod->func;
4024 : :
4025 : : /* Grabs ftrace_lock, which is why we have this extra step */
4026 : 0 : match_records(new_hash, func, strlen(func), mod);
4027 : 0 : free_ftrace_mod(ftrace_mod);
4028 : : }
4029 : :
4030 : 0 : if (enable && list_empty(head))
4031 : 0 : new_hash->flags &= ~FTRACE_HASH_FL_MOD;
4032 : :
4033 : 0 : mutex_lock(&ftrace_lock);
4034 : :
4035 : 0 : ret = ftrace_hash_move_and_update_ops(ops, orig_hash,
4036 : : new_hash, enable);
4037 : 0 : mutex_unlock(&ftrace_lock);
4038 : :
4039 : : out:
4040 : 0 : mutex_unlock(&ops->func_hash->regex_lock);
4041 : :
4042 : 0 : free_ftrace_hash(new_hash);
4043 : 0 : }
4044 : :
4045 : 3 : static void process_cached_mods(const char *mod_name)
4046 : : {
4047 : : struct trace_array *tr;
4048 : : char *mod;
4049 : :
4050 : 3 : mod = kstrdup(mod_name, GFP_KERNEL);
4051 : 3 : if (!mod)
4052 : 3 : return;
4053 : :
4054 : 3 : mutex_lock(&trace_types_lock);
4055 : 3 : list_for_each_entry(tr, &ftrace_trace_arrays, list) {
4056 : 3 : if (!list_empty(&tr->mod_trace))
4057 : 0 : process_mod_list(&tr->mod_trace, tr->ops, mod, true);
4058 : 3 : if (!list_empty(&tr->mod_notrace))
4059 : 0 : process_mod_list(&tr->mod_notrace, tr->ops, mod, false);
4060 : : }
4061 : 3 : mutex_unlock(&trace_types_lock);
4062 : :
4063 : 3 : kfree(mod);
4064 : : }
4065 : : #endif
4066 : :
4067 : : /*
4068 : : * We register the module command as a template to show others how
4069 : : * to register the a command as well.
4070 : : */
4071 : :
4072 : : static int
4073 : 0 : ftrace_mod_callback(struct trace_array *tr, struct ftrace_hash *hash,
4074 : : char *func_orig, char *cmd, char *module, int enable)
4075 : : {
4076 : : char *func;
4077 : : int ret;
4078 : :
4079 : : /* match_records() modifies func, and we need the original */
4080 : 0 : func = kstrdup(func_orig, GFP_KERNEL);
4081 : 0 : if (!func)
4082 : : return -ENOMEM;
4083 : :
4084 : : /*
4085 : : * cmd == 'mod' because we only registered this func
4086 : : * for the 'mod' ftrace_func_command.
4087 : : * But if you register one func with multiple commands,
4088 : : * you can tell which command was used by the cmd
4089 : : * parameter.
4090 : : */
4091 : 0 : ret = match_records(hash, func, strlen(func), module);
4092 : 0 : kfree(func);
4093 : :
4094 : 0 : if (!ret)
4095 : 0 : return cache_mod(tr, func_orig, module, enable);
4096 : 0 : if (ret < 0)
4097 : 0 : return ret;
4098 : : return 0;
4099 : : }
4100 : :
4101 : : static struct ftrace_func_command ftrace_mod_cmd = {
4102 : : .name = "mod",
4103 : : .func = ftrace_mod_callback,
4104 : : };
4105 : :
4106 : 3 : static int __init ftrace_mod_cmd_init(void)
4107 : : {
4108 : 3 : return register_ftrace_command(&ftrace_mod_cmd);
4109 : : }
4110 : : core_initcall(ftrace_mod_cmd_init);
4111 : :
4112 : 0 : static void function_trace_probe_call(unsigned long ip, unsigned long parent_ip,
4113 : : struct ftrace_ops *op, struct pt_regs *pt_regs)
4114 : : {
4115 : : struct ftrace_probe_ops *probe_ops;
4116 : : struct ftrace_func_probe *probe;
4117 : :
4118 : : probe = container_of(op, struct ftrace_func_probe, ops);
4119 : 0 : probe_ops = probe->probe_ops;
4120 : :
4121 : : /*
4122 : : * Disable preemption for these calls to prevent a RCU grace
4123 : : * period. This syncs the hash iteration and freeing of items
4124 : : * on the hash. rcu_read_lock is too dangerous here.
4125 : : */
4126 : 0 : preempt_disable_notrace();
4127 : 0 : probe_ops->func(ip, parent_ip, probe->tr, probe_ops, probe->data);
4128 : 0 : preempt_enable_notrace();
4129 : 0 : }
4130 : :
4131 : : struct ftrace_func_map {
4132 : : struct ftrace_func_entry entry;
4133 : : void *data;
4134 : : };
4135 : :
4136 : : struct ftrace_func_mapper {
4137 : : struct ftrace_hash hash;
4138 : : };
4139 : :
4140 : : /**
4141 : : * allocate_ftrace_func_mapper - allocate a new ftrace_func_mapper
4142 : : *
4143 : : * Returns a ftrace_func_mapper descriptor that can be used to map ips to data.
4144 : : */
4145 : 0 : struct ftrace_func_mapper *allocate_ftrace_func_mapper(void)
4146 : : {
4147 : : struct ftrace_hash *hash;
4148 : :
4149 : : /*
4150 : : * The mapper is simply a ftrace_hash, but since the entries
4151 : : * in the hash are not ftrace_func_entry type, we define it
4152 : : * as a separate structure.
4153 : : */
4154 : 0 : hash = alloc_ftrace_hash(FTRACE_HASH_DEFAULT_BITS);
4155 : 0 : return (struct ftrace_func_mapper *)hash;
4156 : : }
4157 : :
4158 : : /**
4159 : : * ftrace_func_mapper_find_ip - Find some data mapped to an ip
4160 : : * @mapper: The mapper that has the ip maps
4161 : : * @ip: the instruction pointer to find the data for
4162 : : *
4163 : : * Returns the data mapped to @ip if found otherwise NULL. The return
4164 : : * is actually the address of the mapper data pointer. The address is
4165 : : * returned for use cases where the data is no bigger than a long, and
4166 : : * the user can use the data pointer as its data instead of having to
4167 : : * allocate more memory for the reference.
4168 : : */
4169 : 0 : void **ftrace_func_mapper_find_ip(struct ftrace_func_mapper *mapper,
4170 : : unsigned long ip)
4171 : : {
4172 : : struct ftrace_func_entry *entry;
4173 : : struct ftrace_func_map *map;
4174 : :
4175 : 0 : entry = ftrace_lookup_ip(&mapper->hash, ip);
4176 : 0 : if (!entry)
4177 : : return NULL;
4178 : :
4179 : : map = (struct ftrace_func_map *)entry;
4180 : 0 : return &map->data;
4181 : : }
4182 : :
4183 : : /**
4184 : : * ftrace_func_mapper_add_ip - Map some data to an ip
4185 : : * @mapper: The mapper that has the ip maps
4186 : : * @ip: The instruction pointer address to map @data to
4187 : : * @data: The data to map to @ip
4188 : : *
4189 : : * Returns 0 on succes otherwise an error.
4190 : : */
4191 : 0 : int ftrace_func_mapper_add_ip(struct ftrace_func_mapper *mapper,
4192 : : unsigned long ip, void *data)
4193 : : {
4194 : : struct ftrace_func_entry *entry;
4195 : : struct ftrace_func_map *map;
4196 : :
4197 : 0 : entry = ftrace_lookup_ip(&mapper->hash, ip);
4198 : 0 : if (entry)
4199 : : return -EBUSY;
4200 : :
4201 : : map = kmalloc(sizeof(*map), GFP_KERNEL);
4202 : 0 : if (!map)
4203 : : return -ENOMEM;
4204 : :
4205 : 0 : map->entry.ip = ip;
4206 : 0 : map->data = data;
4207 : :
4208 : 0 : __add_hash_entry(&mapper->hash, &map->entry);
4209 : :
4210 : 0 : return 0;
4211 : : }
4212 : :
4213 : : /**
4214 : : * ftrace_func_mapper_remove_ip - Remove an ip from the mapping
4215 : : * @mapper: The mapper that has the ip maps
4216 : : * @ip: The instruction pointer address to remove the data from
4217 : : *
4218 : : * Returns the data if it is found, otherwise NULL.
4219 : : * Note, if the data pointer is used as the data itself, (see
4220 : : * ftrace_func_mapper_find_ip(), then the return value may be meaningless,
4221 : : * if the data pointer was set to zero.
4222 : : */
4223 : 0 : void *ftrace_func_mapper_remove_ip(struct ftrace_func_mapper *mapper,
4224 : : unsigned long ip)
4225 : : {
4226 : : struct ftrace_func_entry *entry;
4227 : : struct ftrace_func_map *map;
4228 : : void *data;
4229 : :
4230 : 0 : entry = ftrace_lookup_ip(&mapper->hash, ip);
4231 : 0 : if (!entry)
4232 : : return NULL;
4233 : :
4234 : : map = (struct ftrace_func_map *)entry;
4235 : 0 : data = map->data;
4236 : :
4237 : : remove_hash_entry(&mapper->hash, entry);
4238 : 0 : kfree(entry);
4239 : :
4240 : 0 : return data;
4241 : : }
4242 : :
4243 : : /**
4244 : : * free_ftrace_func_mapper - free a mapping of ips and data
4245 : : * @mapper: The mapper that has the ip maps
4246 : : * @free_func: A function to be called on each data item.
4247 : : *
4248 : : * This is used to free the function mapper. The @free_func is optional
4249 : : * and can be used if the data needs to be freed as well.
4250 : : */
4251 : 0 : void free_ftrace_func_mapper(struct ftrace_func_mapper *mapper,
4252 : : ftrace_mapper_func free_func)
4253 : : {
4254 : : struct ftrace_func_entry *entry;
4255 : : struct ftrace_func_map *map;
4256 : : struct hlist_head *hhd;
4257 : : int size, i;
4258 : :
4259 : 0 : if (!mapper)
4260 : 0 : return;
4261 : :
4262 : 0 : if (free_func && mapper->hash.count) {
4263 : 0 : size = 1 << mapper->hash.size_bits;
4264 : 0 : for (i = 0; i < size; i++) {
4265 : 0 : hhd = &mapper->hash.buckets[i];
4266 : 0 : hlist_for_each_entry(entry, hhd, hlist) {
4267 : : map = (struct ftrace_func_map *)entry;
4268 : 0 : free_func(map);
4269 : : }
4270 : : }
4271 : : }
4272 : 0 : free_ftrace_hash(&mapper->hash);
4273 : : }
4274 : :
4275 : 0 : static void release_probe(struct ftrace_func_probe *probe)
4276 : : {
4277 : : struct ftrace_probe_ops *probe_ops;
4278 : :
4279 : 0 : mutex_lock(&ftrace_lock);
4280 : :
4281 : 0 : WARN_ON(probe->ref <= 0);
4282 : :
4283 : : /* Subtract the ref that was used to protect this instance */
4284 : 0 : probe->ref--;
4285 : :
4286 : 0 : if (!probe->ref) {
4287 : 0 : probe_ops = probe->probe_ops;
4288 : : /*
4289 : : * Sending zero as ip tells probe_ops to free
4290 : : * the probe->data itself
4291 : : */
4292 : 0 : if (probe_ops->free)
4293 : 0 : probe_ops->free(probe_ops, probe->tr, 0, probe->data);
4294 : : list_del(&probe->list);
4295 : 0 : kfree(probe);
4296 : : }
4297 : 0 : mutex_unlock(&ftrace_lock);
4298 : 0 : }
4299 : :
4300 : : static void acquire_probe_locked(struct ftrace_func_probe *probe)
4301 : : {
4302 : : /*
4303 : : * Add one ref to keep it from being freed when releasing the
4304 : : * ftrace_lock mutex.
4305 : : */
4306 : 0 : probe->ref++;
4307 : : }
4308 : :
4309 : : int
4310 : 0 : register_ftrace_function_probe(char *glob, struct trace_array *tr,
4311 : : struct ftrace_probe_ops *probe_ops,
4312 : : void *data)
4313 : : {
4314 : : struct ftrace_func_entry *entry;
4315 : : struct ftrace_func_probe *probe;
4316 : : struct ftrace_hash **orig_hash;
4317 : : struct ftrace_hash *old_hash;
4318 : : struct ftrace_hash *hash;
4319 : : int count = 0;
4320 : : int size;
4321 : : int ret;
4322 : : int i;
4323 : :
4324 : 0 : if (WARN_ON(!tr))
4325 : : return -EINVAL;
4326 : :
4327 : : /* We do not support '!' for function probes */
4328 : 0 : if (WARN_ON(glob[0] == '!'))
4329 : : return -EINVAL;
4330 : :
4331 : :
4332 : 0 : mutex_lock(&ftrace_lock);
4333 : : /* Check if the probe_ops is already registered */
4334 : 0 : list_for_each_entry(probe, &tr->func_probes, list) {
4335 : 0 : if (probe->probe_ops == probe_ops)
4336 : : break;
4337 : : }
4338 : 0 : if (&probe->list == &tr->func_probes) {
4339 : 0 : probe = kzalloc(sizeof(*probe), GFP_KERNEL);
4340 : 0 : if (!probe) {
4341 : 0 : mutex_unlock(&ftrace_lock);
4342 : 0 : return -ENOMEM;
4343 : : }
4344 : 0 : probe->probe_ops = probe_ops;
4345 : 0 : probe->ops.func = function_trace_probe_call;
4346 : 0 : probe->tr = tr;
4347 : 0 : ftrace_ops_init(&probe->ops);
4348 : 0 : list_add(&probe->list, &tr->func_probes);
4349 : : }
4350 : :
4351 : : acquire_probe_locked(probe);
4352 : :
4353 : 0 : mutex_unlock(&ftrace_lock);
4354 : :
4355 : : /*
4356 : : * Note, there's a small window here that the func_hash->filter_hash
4357 : : * may be NULL or empty. Need to be carefule when reading the loop.
4358 : : */
4359 : 0 : mutex_lock(&probe->ops.func_hash->regex_lock);
4360 : :
4361 : 0 : orig_hash = &probe->ops.func_hash->filter_hash;
4362 : 0 : old_hash = *orig_hash;
4363 : 0 : hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, old_hash);
4364 : :
4365 : 0 : if (!hash) {
4366 : : ret = -ENOMEM;
4367 : : goto out;
4368 : : }
4369 : :
4370 : 0 : ret = ftrace_match_records(hash, glob, strlen(glob));
4371 : :
4372 : : /* Nothing found? */
4373 : 0 : if (!ret)
4374 : : ret = -EINVAL;
4375 : :
4376 : 0 : if (ret < 0)
4377 : : goto out;
4378 : :
4379 : 0 : size = 1 << hash->size_bits;
4380 : 0 : for (i = 0; i < size; i++) {
4381 : 0 : hlist_for_each_entry(entry, &hash->buckets[i], hlist) {
4382 : 0 : if (ftrace_lookup_ip(old_hash, entry->ip))
4383 : 0 : continue;
4384 : : /*
4385 : : * The caller might want to do something special
4386 : : * for each function we find. We call the callback
4387 : : * to give the caller an opportunity to do so.
4388 : : */
4389 : 0 : if (probe_ops->init) {
4390 : 0 : ret = probe_ops->init(probe_ops, tr,
4391 : : entry->ip, data,
4392 : : &probe->data);
4393 : 0 : if (ret < 0) {
4394 : 0 : if (probe_ops->free && count)
4395 : 0 : probe_ops->free(probe_ops, tr,
4396 : : 0, probe->data);
4397 : 0 : probe->data = NULL;
4398 : 0 : goto out;
4399 : : }
4400 : : }
4401 : 0 : count++;
4402 : : }
4403 : : }
4404 : :
4405 : 0 : mutex_lock(&ftrace_lock);
4406 : :
4407 : 0 : if (!count) {
4408 : : /* Nothing was added? */
4409 : : ret = -EINVAL;
4410 : : goto out_unlock;
4411 : : }
4412 : :
4413 : 0 : ret = ftrace_hash_move_and_update_ops(&probe->ops, orig_hash,
4414 : : hash, 1);
4415 : 0 : if (ret < 0)
4416 : : goto err_unlock;
4417 : :
4418 : : /* One ref for each new function traced */
4419 : 0 : probe->ref += count;
4420 : :
4421 : 0 : if (!(probe->ops.flags & FTRACE_OPS_FL_ENABLED))
4422 : 0 : ret = ftrace_startup(&probe->ops, 0);
4423 : :
4424 : : out_unlock:
4425 : 0 : mutex_unlock(&ftrace_lock);
4426 : :
4427 : 0 : if (!ret)
4428 : 0 : ret = count;
4429 : : out:
4430 : 0 : mutex_unlock(&probe->ops.func_hash->regex_lock);
4431 : 0 : free_ftrace_hash(hash);
4432 : :
4433 : 0 : release_probe(probe);
4434 : :
4435 : 0 : return ret;
4436 : :
4437 : : err_unlock:
4438 : 0 : if (!probe_ops->free || !count)
4439 : : goto out_unlock;
4440 : :
4441 : : /* Failed to do the move, need to call the free functions */
4442 : 0 : for (i = 0; i < size; i++) {
4443 : 0 : hlist_for_each_entry(entry, &hash->buckets[i], hlist) {
4444 : 0 : if (ftrace_lookup_ip(old_hash, entry->ip))
4445 : 0 : continue;
4446 : 0 : probe_ops->free(probe_ops, tr, entry->ip, probe->data);
4447 : : }
4448 : : }
4449 : : goto out_unlock;
4450 : : }
4451 : :
4452 : : int
4453 : 0 : unregister_ftrace_function_probe_func(char *glob, struct trace_array *tr,
4454 : : struct ftrace_probe_ops *probe_ops)
4455 : : {
4456 : : struct ftrace_ops_hash old_hash_ops;
4457 : : struct ftrace_func_entry *entry;
4458 : : struct ftrace_func_probe *probe;
4459 : : struct ftrace_glob func_g;
4460 : : struct ftrace_hash **orig_hash;
4461 : : struct ftrace_hash *old_hash;
4462 : : struct ftrace_hash *hash = NULL;
4463 : : struct hlist_node *tmp;
4464 : : struct hlist_head hhd;
4465 : : char str[KSYM_SYMBOL_LEN];
4466 : : int count = 0;
4467 : : int i, ret = -ENODEV;
4468 : : int size;
4469 : :
4470 : 0 : if (!glob || !strlen(glob) || !strcmp(glob, "*"))
4471 : 0 : func_g.search = NULL;
4472 : : else {
4473 : : int not;
4474 : :
4475 : 0 : func_g.type = filter_parse_regex(glob, strlen(glob),
4476 : : &func_g.search, ¬);
4477 : 0 : func_g.len = strlen(func_g.search);
4478 : :
4479 : : /* we do not support '!' for function probes */
4480 : 0 : if (WARN_ON(not))
4481 : 0 : return -EINVAL;
4482 : : }
4483 : :
4484 : 0 : mutex_lock(&ftrace_lock);
4485 : : /* Check if the probe_ops is already registered */
4486 : 0 : list_for_each_entry(probe, &tr->func_probes, list) {
4487 : 0 : if (probe->probe_ops == probe_ops)
4488 : : break;
4489 : : }
4490 : 0 : if (&probe->list == &tr->func_probes)
4491 : : goto err_unlock_ftrace;
4492 : :
4493 : : ret = -EINVAL;
4494 : 0 : if (!(probe->ops.flags & FTRACE_OPS_FL_INITIALIZED))
4495 : : goto err_unlock_ftrace;
4496 : :
4497 : : acquire_probe_locked(probe);
4498 : :
4499 : 0 : mutex_unlock(&ftrace_lock);
4500 : :
4501 : 0 : mutex_lock(&probe->ops.func_hash->regex_lock);
4502 : :
4503 : 0 : orig_hash = &probe->ops.func_hash->filter_hash;
4504 : 0 : old_hash = *orig_hash;
4505 : :
4506 : 0 : if (ftrace_hash_empty(old_hash))
4507 : : goto out_unlock;
4508 : :
4509 : : old_hash_ops.filter_hash = old_hash;
4510 : : /* Probes only have filters */
4511 : : old_hash_ops.notrace_hash = NULL;
4512 : :
4513 : : ret = -ENOMEM;
4514 : 0 : hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, old_hash);
4515 : 0 : if (!hash)
4516 : : goto out_unlock;
4517 : :
4518 : 0 : INIT_HLIST_HEAD(&hhd);
4519 : :
4520 : 0 : size = 1 << hash->size_bits;
4521 : 0 : for (i = 0; i < size; i++) {
4522 : 0 : hlist_for_each_entry_safe(entry, tmp, &hash->buckets[i], hlist) {
4523 : :
4524 : 0 : if (func_g.search) {
4525 : 0 : kallsyms_lookup(entry->ip, NULL, NULL,
4526 : : NULL, str);
4527 : 0 : if (!ftrace_match(str, &func_g))
4528 : 0 : continue;
4529 : : }
4530 : 0 : count++;
4531 : : remove_hash_entry(hash, entry);
4532 : 0 : hlist_add_head(&entry->hlist, &hhd);
4533 : : }
4534 : : }
4535 : :
4536 : : /* Nothing found? */
4537 : 0 : if (!count) {
4538 : : ret = -EINVAL;
4539 : : goto out_unlock;
4540 : : }
4541 : :
4542 : 0 : mutex_lock(&ftrace_lock);
4543 : :
4544 : 0 : WARN_ON(probe->ref < count);
4545 : :
4546 : 0 : probe->ref -= count;
4547 : :
4548 : 0 : if (ftrace_hash_empty(hash))
4549 : 0 : ftrace_shutdown(&probe->ops, 0);
4550 : :
4551 : 0 : ret = ftrace_hash_move_and_update_ops(&probe->ops, orig_hash,
4552 : : hash, 1);
4553 : :
4554 : : /* still need to update the function call sites */
4555 : 0 : if (ftrace_enabled && !ftrace_hash_empty(hash))
4556 : : ftrace_run_modify_code(&probe->ops, FTRACE_UPDATE_CALLS,
4557 : : &old_hash_ops);
4558 : 0 : synchronize_rcu();
4559 : :
4560 : 0 : hlist_for_each_entry_safe(entry, tmp, &hhd, hlist) {
4561 : : hlist_del(&entry->hlist);
4562 : 0 : if (probe_ops->free)
4563 : 0 : probe_ops->free(probe_ops, tr, entry->ip, probe->data);
4564 : 0 : kfree(entry);
4565 : : }
4566 : 0 : mutex_unlock(&ftrace_lock);
4567 : :
4568 : : out_unlock:
4569 : 0 : mutex_unlock(&probe->ops.func_hash->regex_lock);
4570 : 0 : free_ftrace_hash(hash);
4571 : :
4572 : 0 : release_probe(probe);
4573 : :
4574 : 0 : return ret;
4575 : :
4576 : : err_unlock_ftrace:
4577 : 0 : mutex_unlock(&ftrace_lock);
4578 : 0 : return ret;
4579 : : }
4580 : :
4581 : 0 : void clear_ftrace_function_probes(struct trace_array *tr)
4582 : : {
4583 : : struct ftrace_func_probe *probe, *n;
4584 : :
4585 : 0 : list_for_each_entry_safe(probe, n, &tr->func_probes, list)
4586 : 0 : unregister_ftrace_function_probe_func(NULL, tr, probe->probe_ops);
4587 : 0 : }
4588 : :
4589 : : static LIST_HEAD(ftrace_commands);
4590 : : static DEFINE_MUTEX(ftrace_cmd_mutex);
4591 : :
4592 : : /*
4593 : : * Currently we only register ftrace commands from __init, so mark this
4594 : : * __init too.
4595 : : */
4596 : 3 : __init int register_ftrace_command(struct ftrace_func_command *cmd)
4597 : : {
4598 : : struct ftrace_func_command *p;
4599 : : int ret = 0;
4600 : :
4601 : 3 : mutex_lock(&ftrace_cmd_mutex);
4602 : 3 : list_for_each_entry(p, &ftrace_commands, list) {
4603 : 3 : if (strcmp(cmd->name, p->name) == 0) {
4604 : : ret = -EBUSY;
4605 : : goto out_unlock;
4606 : : }
4607 : : }
4608 : 3 : list_add(&cmd->list, &ftrace_commands);
4609 : : out_unlock:
4610 : 3 : mutex_unlock(&ftrace_cmd_mutex);
4611 : :
4612 : 3 : return ret;
4613 : : }
4614 : :
4615 : : /*
4616 : : * Currently we only unregister ftrace commands from __init, so mark
4617 : : * this __init too.
4618 : : */
4619 : 0 : __init int unregister_ftrace_command(struct ftrace_func_command *cmd)
4620 : : {
4621 : : struct ftrace_func_command *p, *n;
4622 : : int ret = -ENODEV;
4623 : :
4624 : 0 : mutex_lock(&ftrace_cmd_mutex);
4625 : 0 : list_for_each_entry_safe(p, n, &ftrace_commands, list) {
4626 : 0 : if (strcmp(cmd->name, p->name) == 0) {
4627 : : ret = 0;
4628 : 0 : list_del_init(&p->list);
4629 : : goto out_unlock;
4630 : : }
4631 : : }
4632 : : out_unlock:
4633 : 0 : mutex_unlock(&ftrace_cmd_mutex);
4634 : :
4635 : 0 : return ret;
4636 : : }
4637 : :
4638 : 0 : static int ftrace_process_regex(struct ftrace_iterator *iter,
4639 : : char *buff, int len, int enable)
4640 : : {
4641 : 0 : struct ftrace_hash *hash = iter->hash;
4642 : 0 : struct trace_array *tr = iter->ops->private;
4643 : 0 : char *func, *command, *next = buff;
4644 : : struct ftrace_func_command *p;
4645 : : int ret = -EINVAL;
4646 : :
4647 : 0 : func = strsep(&next, ":");
4648 : :
4649 : 0 : if (!next) {
4650 : : ret = ftrace_match_records(hash, func, len);
4651 : 0 : if (!ret)
4652 : : ret = -EINVAL;
4653 : 0 : if (ret < 0)
4654 : 0 : return ret;
4655 : : return 0;
4656 : : }
4657 : :
4658 : : /* command found */
4659 : :
4660 : 0 : command = strsep(&next, ":");
4661 : :
4662 : 0 : mutex_lock(&ftrace_cmd_mutex);
4663 : 0 : list_for_each_entry(p, &ftrace_commands, list) {
4664 : 0 : if (strcmp(p->name, command) == 0) {
4665 : 0 : ret = p->func(tr, hash, func, command, next, enable);
4666 : 0 : goto out_unlock;
4667 : : }
4668 : : }
4669 : : out_unlock:
4670 : 0 : mutex_unlock(&ftrace_cmd_mutex);
4671 : :
4672 : 0 : return ret;
4673 : : }
4674 : :
4675 : : static ssize_t
4676 : 0 : ftrace_regex_write(struct file *file, const char __user *ubuf,
4677 : : size_t cnt, loff_t *ppos, int enable)
4678 : : {
4679 : : struct ftrace_iterator *iter;
4680 : : struct trace_parser *parser;
4681 : : ssize_t ret, read;
4682 : :
4683 : 0 : if (!cnt)
4684 : : return 0;
4685 : :
4686 : 0 : if (file->f_mode & FMODE_READ) {
4687 : 0 : struct seq_file *m = file->private_data;
4688 : 0 : iter = m->private;
4689 : : } else
4690 : 0 : iter = file->private_data;
4691 : :
4692 : 0 : if (unlikely(ftrace_disabled))
4693 : : return -ENODEV;
4694 : :
4695 : : /* iter->hash is a local copy, so we don't need regex_lock */
4696 : :
4697 : 0 : parser = &iter->parser;
4698 : 0 : read = trace_get_user(parser, ubuf, cnt, ppos);
4699 : :
4700 : 0 : if (read >= 0 && trace_parser_loaded(parser) &&
4701 : : !trace_parser_cont(parser)) {
4702 : 0 : ret = ftrace_process_regex(iter, parser->buffer,
4703 : : parser->idx, enable);
4704 : : trace_parser_clear(parser);
4705 : 0 : if (ret < 0)
4706 : : goto out;
4707 : : }
4708 : :
4709 : : ret = read;
4710 : : out:
4711 : 0 : return ret;
4712 : : }
4713 : :
4714 : : ssize_t
4715 : 0 : ftrace_filter_write(struct file *file, const char __user *ubuf,
4716 : : size_t cnt, loff_t *ppos)
4717 : : {
4718 : 0 : return ftrace_regex_write(file, ubuf, cnt, ppos, 1);
4719 : : }
4720 : :
4721 : : ssize_t
4722 : 0 : ftrace_notrace_write(struct file *file, const char __user *ubuf,
4723 : : size_t cnt, loff_t *ppos)
4724 : : {
4725 : 0 : return ftrace_regex_write(file, ubuf, cnt, ppos, 0);
4726 : : }
4727 : :
4728 : : static int
4729 : 0 : ftrace_match_addr(struct ftrace_hash *hash, unsigned long ip, int remove)
4730 : : {
4731 : : struct ftrace_func_entry *entry;
4732 : :
4733 : 0 : if (!ftrace_location(ip))
4734 : : return -EINVAL;
4735 : :
4736 : 0 : if (remove) {
4737 : 0 : entry = ftrace_lookup_ip(hash, ip);
4738 : 0 : if (!entry)
4739 : : return -ENOENT;
4740 : 0 : free_hash_entry(hash, entry);
4741 : 0 : return 0;
4742 : : }
4743 : :
4744 : 0 : return add_hash_entry(hash, ip);
4745 : : }
4746 : :
4747 : : static int
4748 : 0 : ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len,
4749 : : unsigned long ip, int remove, int reset, int enable)
4750 : : {
4751 : : struct ftrace_hash **orig_hash;
4752 : : struct ftrace_hash *hash;
4753 : : int ret;
4754 : :
4755 : 0 : if (unlikely(ftrace_disabled))
4756 : : return -ENODEV;
4757 : :
4758 : 0 : mutex_lock(&ops->func_hash->regex_lock);
4759 : :
4760 : 0 : if (enable)
4761 : 0 : orig_hash = &ops->func_hash->filter_hash;
4762 : : else
4763 : 0 : orig_hash = &ops->func_hash->notrace_hash;
4764 : :
4765 : 0 : if (reset)
4766 : 0 : hash = alloc_ftrace_hash(FTRACE_HASH_DEFAULT_BITS);
4767 : : else
4768 : 0 : hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash);
4769 : :
4770 : 0 : if (!hash) {
4771 : : ret = -ENOMEM;
4772 : : goto out_regex_unlock;
4773 : : }
4774 : :
4775 : 0 : if (buf && !ftrace_match_records(hash, buf, len)) {
4776 : : ret = -EINVAL;
4777 : : goto out_regex_unlock;
4778 : : }
4779 : 0 : if (ip) {
4780 : 0 : ret = ftrace_match_addr(hash, ip, remove);
4781 : 0 : if (ret < 0)
4782 : : goto out_regex_unlock;
4783 : : }
4784 : :
4785 : 0 : mutex_lock(&ftrace_lock);
4786 : 0 : ret = ftrace_hash_move_and_update_ops(ops, orig_hash, hash, enable);
4787 : 0 : mutex_unlock(&ftrace_lock);
4788 : :
4789 : : out_regex_unlock:
4790 : 0 : mutex_unlock(&ops->func_hash->regex_lock);
4791 : :
4792 : 0 : free_ftrace_hash(hash);
4793 : 0 : return ret;
4794 : : }
4795 : :
4796 : : static int
4797 : : ftrace_set_addr(struct ftrace_ops *ops, unsigned long ip, int remove,
4798 : : int reset, int enable)
4799 : : {
4800 : 0 : return ftrace_set_hash(ops, NULL, 0, ip, remove, reset, enable);
4801 : : }
4802 : :
4803 : : /**
4804 : : * ftrace_set_filter_ip - set a function to filter on in ftrace by address
4805 : : * @ops - the ops to set the filter with
4806 : : * @ip - the address to add to or remove from the filter.
4807 : : * @remove - non zero to remove the ip from the filter
4808 : : * @reset - non zero to reset all filters before applying this filter.
4809 : : *
4810 : : * Filters denote which functions should be enabled when tracing is enabled
4811 : : * If @ip is NULL, it failes to update filter.
4812 : : */
4813 : 0 : int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,
4814 : : int remove, int reset)
4815 : : {
4816 : 0 : ftrace_ops_init(ops);
4817 : 0 : return ftrace_set_addr(ops, ip, remove, reset, 1);
4818 : : }
4819 : : EXPORT_SYMBOL_GPL(ftrace_set_filter_ip);
4820 : :
4821 : : /**
4822 : : * ftrace_ops_set_global_filter - setup ops to use global filters
4823 : : * @ops - the ops which will use the global filters
4824 : : *
4825 : : * ftrace users who need global function trace filtering should call this.
4826 : : * It can set the global filter only if ops were not initialized before.
4827 : : */
4828 : 0 : void ftrace_ops_set_global_filter(struct ftrace_ops *ops)
4829 : : {
4830 : 0 : if (ops->flags & FTRACE_OPS_FL_INITIALIZED)
4831 : 0 : return;
4832 : :
4833 : 0 : ftrace_ops_init(ops);
4834 : 0 : ops->func_hash = &global_ops.local_hash;
4835 : : }
4836 : : EXPORT_SYMBOL_GPL(ftrace_ops_set_global_filter);
4837 : :
4838 : : static int
4839 : : ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len,
4840 : : int reset, int enable)
4841 : : {
4842 : 0 : return ftrace_set_hash(ops, buf, len, 0, 0, reset, enable);
4843 : : }
4844 : :
4845 : : /**
4846 : : * ftrace_set_filter - set a function to filter on in ftrace
4847 : : * @ops - the ops to set the filter with
4848 : : * @buf - the string that holds the function filter text.
4849 : : * @len - the length of the string.
4850 : : * @reset - non zero to reset all filters before applying this filter.
4851 : : *
4852 : : * Filters denote which functions should be enabled when tracing is enabled.
4853 : : * If @buf is NULL and reset is set, all functions will be enabled for tracing.
4854 : : */
4855 : 0 : int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
4856 : : int len, int reset)
4857 : : {
4858 : 0 : ftrace_ops_init(ops);
4859 : 0 : return ftrace_set_regex(ops, buf, len, reset, 1);
4860 : : }
4861 : : EXPORT_SYMBOL_GPL(ftrace_set_filter);
4862 : :
4863 : : /**
4864 : : * ftrace_set_notrace - set a function to not trace in ftrace
4865 : : * @ops - the ops to set the notrace filter with
4866 : : * @buf - the string that holds the function notrace text.
4867 : : * @len - the length of the string.
4868 : : * @reset - non zero to reset all filters before applying this filter.
4869 : : *
4870 : : * Notrace Filters denote which functions should not be enabled when tracing
4871 : : * is enabled. If @buf is NULL and reset is set, all functions will be enabled
4872 : : * for tracing.
4873 : : */
4874 : 0 : int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
4875 : : int len, int reset)
4876 : : {
4877 : 0 : ftrace_ops_init(ops);
4878 : 0 : return ftrace_set_regex(ops, buf, len, reset, 0);
4879 : : }
4880 : : EXPORT_SYMBOL_GPL(ftrace_set_notrace);
4881 : : /**
4882 : : * ftrace_set_global_filter - set a function to filter on with global tracers
4883 : : * @buf - the string that holds the function filter text.
4884 : : * @len - the length of the string.
4885 : : * @reset - non zero to reset all filters before applying this filter.
4886 : : *
4887 : : * Filters denote which functions should be enabled when tracing is enabled.
4888 : : * If @buf is NULL and reset is set, all functions will be enabled for tracing.
4889 : : */
4890 : 0 : void ftrace_set_global_filter(unsigned char *buf, int len, int reset)
4891 : : {
4892 : : ftrace_set_regex(&global_ops, buf, len, reset, 1);
4893 : 0 : }
4894 : : EXPORT_SYMBOL_GPL(ftrace_set_global_filter);
4895 : :
4896 : : /**
4897 : : * ftrace_set_global_notrace - set a function to not trace with global tracers
4898 : : * @buf - the string that holds the function notrace text.
4899 : : * @len - the length of the string.
4900 : : * @reset - non zero to reset all filters before applying this filter.
4901 : : *
4902 : : * Notrace Filters denote which functions should not be enabled when tracing
4903 : : * is enabled. If @buf is NULL and reset is set, all functions will be enabled
4904 : : * for tracing.
4905 : : */
4906 : 0 : void ftrace_set_global_notrace(unsigned char *buf, int len, int reset)
4907 : : {
4908 : : ftrace_set_regex(&global_ops, buf, len, reset, 0);
4909 : 0 : }
4910 : : EXPORT_SYMBOL_GPL(ftrace_set_global_notrace);
4911 : :
4912 : : /*
4913 : : * command line interface to allow users to set filters on boot up.
4914 : : */
4915 : : #define FTRACE_FILTER_SIZE COMMAND_LINE_SIZE
4916 : : static char ftrace_notrace_buf[FTRACE_FILTER_SIZE] __initdata;
4917 : : static char ftrace_filter_buf[FTRACE_FILTER_SIZE] __initdata;
4918 : :
4919 : : /* Used by function selftest to not test if filter is set */
4920 : : bool ftrace_filter_param __initdata;
4921 : :
4922 : 0 : static int __init set_ftrace_notrace(char *str)
4923 : : {
4924 : 0 : ftrace_filter_param = true;
4925 : 0 : strlcpy(ftrace_notrace_buf, str, FTRACE_FILTER_SIZE);
4926 : 0 : return 1;
4927 : : }
4928 : : __setup("ftrace_notrace=", set_ftrace_notrace);
4929 : :
4930 : 0 : static int __init set_ftrace_filter(char *str)
4931 : : {
4932 : 0 : ftrace_filter_param = true;
4933 : 0 : strlcpy(ftrace_filter_buf, str, FTRACE_FILTER_SIZE);
4934 : 0 : return 1;
4935 : : }
4936 : : __setup("ftrace_filter=", set_ftrace_filter);
4937 : :
4938 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
4939 : : static char ftrace_graph_buf[FTRACE_FILTER_SIZE] __initdata;
4940 : : static char ftrace_graph_notrace_buf[FTRACE_FILTER_SIZE] __initdata;
4941 : : static int ftrace_graph_set_hash(struct ftrace_hash *hash, char *buffer);
4942 : :
4943 : 0 : static int __init set_graph_function(char *str)
4944 : : {
4945 : 0 : strlcpy(ftrace_graph_buf, str, FTRACE_FILTER_SIZE);
4946 : 0 : return 1;
4947 : : }
4948 : : __setup("ftrace_graph_filter=", set_graph_function);
4949 : :
4950 : 0 : static int __init set_graph_notrace_function(char *str)
4951 : : {
4952 : 0 : strlcpy(ftrace_graph_notrace_buf, str, FTRACE_FILTER_SIZE);
4953 : 0 : return 1;
4954 : : }
4955 : : __setup("ftrace_graph_notrace=", set_graph_notrace_function);
4956 : :
4957 : 0 : static int __init set_graph_max_depth_function(char *str)
4958 : : {
4959 : 0 : if (!str)
4960 : : return 0;
4961 : 0 : fgraph_max_depth = simple_strtoul(str, NULL, 0);
4962 : 0 : return 1;
4963 : : }
4964 : : __setup("ftrace_graph_max_depth=", set_graph_max_depth_function);
4965 : :
4966 : 0 : static void __init set_ftrace_early_graph(char *buf, int enable)
4967 : : {
4968 : : int ret;
4969 : : char *func;
4970 : : struct ftrace_hash *hash;
4971 : :
4972 : 0 : hash = alloc_ftrace_hash(FTRACE_HASH_DEFAULT_BITS);
4973 : 0 : if (WARN_ON(!hash))
4974 : 0 : return;
4975 : :
4976 : 0 : while (buf) {
4977 : 0 : func = strsep(&buf, ",");
4978 : : /* we allow only one expression at a time */
4979 : 0 : ret = ftrace_graph_set_hash(hash, func);
4980 : 0 : if (ret)
4981 : 0 : printk(KERN_DEBUG "ftrace: function %s not "
4982 : : "traceable\n", func);
4983 : : }
4984 : :
4985 : 0 : if (enable)
4986 : 0 : ftrace_graph_hash = hash;
4987 : : else
4988 : 0 : ftrace_graph_notrace_hash = hash;
4989 : : }
4990 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
4991 : :
4992 : : void __init
4993 : 0 : ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable)
4994 : : {
4995 : : char *func;
4996 : :
4997 : 0 : ftrace_ops_init(ops);
4998 : :
4999 : 0 : while (buf) {
5000 : 0 : func = strsep(&buf, ",");
5001 : 0 : ftrace_set_regex(ops, func, strlen(func), 0, enable);
5002 : : }
5003 : 0 : }
5004 : :
5005 : 3 : static void __init set_ftrace_early_filters(void)
5006 : : {
5007 : 3 : if (ftrace_filter_buf[0])
5008 : 0 : ftrace_set_early_filter(&global_ops, ftrace_filter_buf, 1);
5009 : 3 : if (ftrace_notrace_buf[0])
5010 : 0 : ftrace_set_early_filter(&global_ops, ftrace_notrace_buf, 0);
5011 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
5012 : 3 : if (ftrace_graph_buf[0])
5013 : 0 : set_ftrace_early_graph(ftrace_graph_buf, 1);
5014 : 3 : if (ftrace_graph_notrace_buf[0])
5015 : 0 : set_ftrace_early_graph(ftrace_graph_notrace_buf, 0);
5016 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
5017 : 3 : }
5018 : :
5019 : 0 : int ftrace_regex_release(struct inode *inode, struct file *file)
5020 : : {
5021 : 0 : struct seq_file *m = (struct seq_file *)file->private_data;
5022 : : struct ftrace_iterator *iter;
5023 : : struct ftrace_hash **orig_hash;
5024 : : struct trace_parser *parser;
5025 : : int filter_hash;
5026 : : int ret;
5027 : :
5028 : 0 : if (file->f_mode & FMODE_READ) {
5029 : 0 : iter = m->private;
5030 : 0 : seq_release(inode, file);
5031 : : } else
5032 : : iter = file->private_data;
5033 : :
5034 : 0 : parser = &iter->parser;
5035 : 0 : if (trace_parser_loaded(parser)) {
5036 : 0 : ftrace_match_records(iter->hash, parser->buffer, parser->idx);
5037 : : }
5038 : :
5039 : 0 : trace_parser_put(parser);
5040 : :
5041 : 0 : mutex_lock(&iter->ops->func_hash->regex_lock);
5042 : :
5043 : 0 : if (file->f_mode & FMODE_WRITE) {
5044 : 0 : filter_hash = !!(iter->flags & FTRACE_ITER_FILTER);
5045 : :
5046 : 0 : if (filter_hash) {
5047 : 0 : orig_hash = &iter->ops->func_hash->filter_hash;
5048 : 0 : if (iter->tr && !list_empty(&iter->tr->mod_trace))
5049 : 0 : iter->hash->flags |= FTRACE_HASH_FL_MOD;
5050 : : } else
5051 : 0 : orig_hash = &iter->ops->func_hash->notrace_hash;
5052 : :
5053 : 0 : mutex_lock(&ftrace_lock);
5054 : 0 : ret = ftrace_hash_move_and_update_ops(iter->ops, orig_hash,
5055 : : iter->hash, filter_hash);
5056 : 0 : mutex_unlock(&ftrace_lock);
5057 : : } else {
5058 : : /* For read only, the hash is the ops hash */
5059 : 0 : iter->hash = NULL;
5060 : : }
5061 : :
5062 : 0 : mutex_unlock(&iter->ops->func_hash->regex_lock);
5063 : 0 : free_ftrace_hash(iter->hash);
5064 : 0 : if (iter->tr)
5065 : 0 : trace_array_put(iter->tr);
5066 : 0 : kfree(iter);
5067 : :
5068 : 0 : return 0;
5069 : : }
5070 : :
5071 : : static const struct file_operations ftrace_avail_fops = {
5072 : : .open = ftrace_avail_open,
5073 : : .read = seq_read,
5074 : : .llseek = seq_lseek,
5075 : : .release = seq_release_private,
5076 : : };
5077 : :
5078 : : static const struct file_operations ftrace_enabled_fops = {
5079 : : .open = ftrace_enabled_open,
5080 : : .read = seq_read,
5081 : : .llseek = seq_lseek,
5082 : : .release = seq_release_private,
5083 : : };
5084 : :
5085 : : static const struct file_operations ftrace_filter_fops = {
5086 : : .open = ftrace_filter_open,
5087 : : .read = seq_read,
5088 : : .write = ftrace_filter_write,
5089 : : .llseek = tracing_lseek,
5090 : : .release = ftrace_regex_release,
5091 : : };
5092 : :
5093 : : static const struct file_operations ftrace_notrace_fops = {
5094 : : .open = ftrace_notrace_open,
5095 : : .read = seq_read,
5096 : : .write = ftrace_notrace_write,
5097 : : .llseek = tracing_lseek,
5098 : : .release = ftrace_regex_release,
5099 : : };
5100 : :
5101 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
5102 : :
5103 : : static DEFINE_MUTEX(graph_lock);
5104 : :
5105 : : struct ftrace_hash __rcu *ftrace_graph_hash = EMPTY_HASH;
5106 : : struct ftrace_hash __rcu *ftrace_graph_notrace_hash = EMPTY_HASH;
5107 : :
5108 : : enum graph_filter_type {
5109 : : GRAPH_FILTER_NOTRACE = 0,
5110 : : GRAPH_FILTER_FUNCTION,
5111 : : };
5112 : :
5113 : : #define FTRACE_GRAPH_EMPTY ((void *)1)
5114 : :
5115 : : struct ftrace_graph_data {
5116 : : struct ftrace_hash *hash;
5117 : : struct ftrace_func_entry *entry;
5118 : : int idx; /* for hash table iteration */
5119 : : enum graph_filter_type type;
5120 : : struct ftrace_hash *new_hash;
5121 : : const struct seq_operations *seq_ops;
5122 : : struct trace_parser parser;
5123 : : };
5124 : :
5125 : : static void *
5126 : 0 : __g_next(struct seq_file *m, loff_t *pos)
5127 : : {
5128 : 0 : struct ftrace_graph_data *fgd = m->private;
5129 : 0 : struct ftrace_func_entry *entry = fgd->entry;
5130 : : struct hlist_head *head;
5131 : 0 : int i, idx = fgd->idx;
5132 : :
5133 : 0 : if (*pos >= fgd->hash->count)
5134 : : return NULL;
5135 : :
5136 : 0 : if (entry) {
5137 : 0 : hlist_for_each_entry_continue(entry, hlist) {
5138 : 0 : fgd->entry = entry;
5139 : 0 : return entry;
5140 : : }
5141 : :
5142 : 0 : idx++;
5143 : : }
5144 : :
5145 : 0 : for (i = idx; i < 1 << fgd->hash->size_bits; i++) {
5146 : 0 : head = &fgd->hash->buckets[i];
5147 : 0 : hlist_for_each_entry(entry, head, hlist) {
5148 : 0 : fgd->entry = entry;
5149 : 0 : fgd->idx = i;
5150 : 0 : return entry;
5151 : : }
5152 : : }
5153 : : return NULL;
5154 : : }
5155 : :
5156 : : static void *
5157 : 0 : g_next(struct seq_file *m, void *v, loff_t *pos)
5158 : : {
5159 : 0 : (*pos)++;
5160 : 0 : return __g_next(m, pos);
5161 : : }
5162 : :
5163 : 0 : static void *g_start(struct seq_file *m, loff_t *pos)
5164 : : {
5165 : 0 : struct ftrace_graph_data *fgd = m->private;
5166 : :
5167 : 0 : mutex_lock(&graph_lock);
5168 : :
5169 : 0 : if (fgd->type == GRAPH_FILTER_FUNCTION)
5170 : 0 : fgd->hash = rcu_dereference_protected(ftrace_graph_hash,
5171 : : lockdep_is_held(&graph_lock));
5172 : : else
5173 : 0 : fgd->hash = rcu_dereference_protected(ftrace_graph_notrace_hash,
5174 : : lockdep_is_held(&graph_lock));
5175 : :
5176 : : /* Nothing, tell g_show to print all functions are enabled */
5177 : 0 : if (ftrace_hash_empty(fgd->hash) && !*pos)
5178 : : return FTRACE_GRAPH_EMPTY;
5179 : :
5180 : 0 : fgd->idx = 0;
5181 : 0 : fgd->entry = NULL;
5182 : 0 : return __g_next(m, pos);
5183 : : }
5184 : :
5185 : 0 : static void g_stop(struct seq_file *m, void *p)
5186 : : {
5187 : 0 : mutex_unlock(&graph_lock);
5188 : 0 : }
5189 : :
5190 : 0 : static int g_show(struct seq_file *m, void *v)
5191 : : {
5192 : : struct ftrace_func_entry *entry = v;
5193 : :
5194 : 0 : if (!entry)
5195 : : return 0;
5196 : :
5197 : 0 : if (entry == FTRACE_GRAPH_EMPTY) {
5198 : 0 : struct ftrace_graph_data *fgd = m->private;
5199 : :
5200 : 0 : if (fgd->type == GRAPH_FILTER_FUNCTION)
5201 : 0 : seq_puts(m, "#### all functions enabled ####\n");
5202 : : else
5203 : 0 : seq_puts(m, "#### no functions disabled ####\n");
5204 : : return 0;
5205 : : }
5206 : :
5207 : 0 : seq_printf(m, "%ps\n", (void *)entry->ip);
5208 : :
5209 : 0 : return 0;
5210 : : }
5211 : :
5212 : : static const struct seq_operations ftrace_graph_seq_ops = {
5213 : : .start = g_start,
5214 : : .next = g_next,
5215 : : .stop = g_stop,
5216 : : .show = g_show,
5217 : : };
5218 : :
5219 : : static int
5220 : 0 : __ftrace_graph_open(struct inode *inode, struct file *file,
5221 : : struct ftrace_graph_data *fgd)
5222 : : {
5223 : : int ret;
5224 : : struct ftrace_hash *new_hash = NULL;
5225 : :
5226 : 0 : ret = security_locked_down(LOCKDOWN_TRACEFS);
5227 : 0 : if (ret)
5228 : : return ret;
5229 : :
5230 : 0 : if (file->f_mode & FMODE_WRITE) {
5231 : : const int size_bits = FTRACE_HASH_DEFAULT_BITS;
5232 : :
5233 : 0 : if (trace_parser_get_init(&fgd->parser, FTRACE_BUFF_MAX))
5234 : : return -ENOMEM;
5235 : :
5236 : 0 : if (file->f_flags & O_TRUNC)
5237 : 0 : new_hash = alloc_ftrace_hash(size_bits);
5238 : : else
5239 : 0 : new_hash = alloc_and_copy_ftrace_hash(size_bits,
5240 : : fgd->hash);
5241 : 0 : if (!new_hash) {
5242 : : ret = -ENOMEM;
5243 : : goto out;
5244 : : }
5245 : : }
5246 : :
5247 : 0 : if (file->f_mode & FMODE_READ) {
5248 : 0 : ret = seq_open(file, &ftrace_graph_seq_ops);
5249 : 0 : if (!ret) {
5250 : 0 : struct seq_file *m = file->private_data;
5251 : 0 : m->private = fgd;
5252 : : } else {
5253 : : /* Failed */
5254 : 0 : free_ftrace_hash(new_hash);
5255 : : new_hash = NULL;
5256 : : }
5257 : : } else
5258 : 0 : file->private_data = fgd;
5259 : :
5260 : : out:
5261 : 0 : if (ret < 0 && file->f_mode & FMODE_WRITE)
5262 : 0 : trace_parser_put(&fgd->parser);
5263 : :
5264 : 0 : fgd->new_hash = new_hash;
5265 : :
5266 : : /*
5267 : : * All uses of fgd->hash must be taken with the graph_lock
5268 : : * held. The graph_lock is going to be released, so force
5269 : : * fgd->hash to be reinitialized when it is taken again.
5270 : : */
5271 : 0 : fgd->hash = NULL;
5272 : :
5273 : 0 : return ret;
5274 : : }
5275 : :
5276 : : static int
5277 : 0 : ftrace_graph_open(struct inode *inode, struct file *file)
5278 : : {
5279 : : struct ftrace_graph_data *fgd;
5280 : : int ret;
5281 : :
5282 : 0 : if (unlikely(ftrace_disabled))
5283 : : return -ENODEV;
5284 : :
5285 : : fgd = kmalloc(sizeof(*fgd), GFP_KERNEL);
5286 : 0 : if (fgd == NULL)
5287 : : return -ENOMEM;
5288 : :
5289 : 0 : mutex_lock(&graph_lock);
5290 : :
5291 : 0 : fgd->hash = rcu_dereference_protected(ftrace_graph_hash,
5292 : : lockdep_is_held(&graph_lock));
5293 : 0 : fgd->type = GRAPH_FILTER_FUNCTION;
5294 : 0 : fgd->seq_ops = &ftrace_graph_seq_ops;
5295 : :
5296 : 0 : ret = __ftrace_graph_open(inode, file, fgd);
5297 : 0 : if (ret < 0)
5298 : 0 : kfree(fgd);
5299 : :
5300 : 0 : mutex_unlock(&graph_lock);
5301 : 0 : return ret;
5302 : : }
5303 : :
5304 : : static int
5305 : 0 : ftrace_graph_notrace_open(struct inode *inode, struct file *file)
5306 : : {
5307 : : struct ftrace_graph_data *fgd;
5308 : : int ret;
5309 : :
5310 : 0 : if (unlikely(ftrace_disabled))
5311 : : return -ENODEV;
5312 : :
5313 : : fgd = kmalloc(sizeof(*fgd), GFP_KERNEL);
5314 : 0 : if (fgd == NULL)
5315 : : return -ENOMEM;
5316 : :
5317 : 0 : mutex_lock(&graph_lock);
5318 : :
5319 : 0 : fgd->hash = rcu_dereference_protected(ftrace_graph_notrace_hash,
5320 : : lockdep_is_held(&graph_lock));
5321 : 0 : fgd->type = GRAPH_FILTER_NOTRACE;
5322 : 0 : fgd->seq_ops = &ftrace_graph_seq_ops;
5323 : :
5324 : 0 : ret = __ftrace_graph_open(inode, file, fgd);
5325 : 0 : if (ret < 0)
5326 : 0 : kfree(fgd);
5327 : :
5328 : 0 : mutex_unlock(&graph_lock);
5329 : 0 : return ret;
5330 : : }
5331 : :
5332 : : static int
5333 : 0 : ftrace_graph_release(struct inode *inode, struct file *file)
5334 : : {
5335 : : struct ftrace_graph_data *fgd;
5336 : : struct ftrace_hash *old_hash, *new_hash;
5337 : : struct trace_parser *parser;
5338 : : int ret = 0;
5339 : :
5340 : 0 : if (file->f_mode & FMODE_READ) {
5341 : 0 : struct seq_file *m = file->private_data;
5342 : :
5343 : 0 : fgd = m->private;
5344 : 0 : seq_release(inode, file);
5345 : : } else {
5346 : 0 : fgd = file->private_data;
5347 : : }
5348 : :
5349 : :
5350 : 0 : if (file->f_mode & FMODE_WRITE) {
5351 : :
5352 : 0 : parser = &fgd->parser;
5353 : :
5354 : 0 : if (trace_parser_loaded((parser))) {
5355 : 0 : ret = ftrace_graph_set_hash(fgd->new_hash,
5356 : : parser->buffer);
5357 : : }
5358 : :
5359 : 0 : trace_parser_put(parser);
5360 : :
5361 : 0 : new_hash = __ftrace_hash_move(fgd->new_hash);
5362 : 0 : if (!new_hash) {
5363 : : ret = -ENOMEM;
5364 : : goto out;
5365 : : }
5366 : :
5367 : 0 : mutex_lock(&graph_lock);
5368 : :
5369 : 0 : if (fgd->type == GRAPH_FILTER_FUNCTION) {
5370 : 0 : old_hash = rcu_dereference_protected(ftrace_graph_hash,
5371 : : lockdep_is_held(&graph_lock));
5372 : 0 : rcu_assign_pointer(ftrace_graph_hash, new_hash);
5373 : : } else {
5374 : 0 : old_hash = rcu_dereference_protected(ftrace_graph_notrace_hash,
5375 : : lockdep_is_held(&graph_lock));
5376 : 0 : rcu_assign_pointer(ftrace_graph_notrace_hash, new_hash);
5377 : : }
5378 : :
5379 : 0 : mutex_unlock(&graph_lock);
5380 : :
5381 : : /*
5382 : : * We need to do a hard force of sched synchronization.
5383 : : * This is because we use preempt_disable() to do RCU, but
5384 : : * the function tracers can be called where RCU is not watching
5385 : : * (like before user_exit()). We can not rely on the RCU
5386 : : * infrastructure to do the synchronization, thus we must do it
5387 : : * ourselves.
5388 : : */
5389 : 0 : schedule_on_each_cpu(ftrace_sync);
5390 : :
5391 : 0 : free_ftrace_hash(old_hash);
5392 : : }
5393 : :
5394 : : out:
5395 : 0 : free_ftrace_hash(fgd->new_hash);
5396 : 0 : kfree(fgd);
5397 : :
5398 : 0 : return ret;
5399 : : }
5400 : :
5401 : : static int
5402 : 0 : ftrace_graph_set_hash(struct ftrace_hash *hash, char *buffer)
5403 : : {
5404 : : struct ftrace_glob func_g;
5405 : : struct dyn_ftrace *rec;
5406 : : struct ftrace_page *pg;
5407 : : struct ftrace_func_entry *entry;
5408 : : int fail = 1;
5409 : : int not;
5410 : :
5411 : : /* decode regex */
5412 : 0 : func_g.type = filter_parse_regex(buffer, strlen(buffer),
5413 : : &func_g.search, ¬);
5414 : :
5415 : 0 : func_g.len = strlen(func_g.search);
5416 : :
5417 : 0 : mutex_lock(&ftrace_lock);
5418 : :
5419 : 0 : if (unlikely(ftrace_disabled)) {
5420 : 0 : mutex_unlock(&ftrace_lock);
5421 : 0 : return -ENODEV;
5422 : : }
5423 : :
5424 : 0 : do_for_each_ftrace_rec(pg, rec) {
5425 : :
5426 : 0 : if (rec->flags & FTRACE_FL_DISABLED)
5427 : 0 : continue;
5428 : :
5429 : 0 : if (ftrace_match_record(rec, &func_g, NULL, 0)) {
5430 : 0 : entry = ftrace_lookup_ip(hash, rec->ip);
5431 : :
5432 : 0 : if (!not) {
5433 : : fail = 0;
5434 : :
5435 : 0 : if (entry)
5436 : 0 : continue;
5437 : 0 : if (add_hash_entry(hash, rec->ip) < 0)
5438 : : goto out;
5439 : : } else {
5440 : 0 : if (entry) {
5441 : 0 : free_hash_entry(hash, entry);
5442 : : fail = 0;
5443 : : }
5444 : : }
5445 : : }
5446 : : } while_for_each_ftrace_rec();
5447 : : out:
5448 : 0 : mutex_unlock(&ftrace_lock);
5449 : :
5450 : 0 : if (fail)
5451 : : return -EINVAL;
5452 : :
5453 : 0 : return 0;
5454 : : }
5455 : :
5456 : : static ssize_t
5457 : 0 : ftrace_graph_write(struct file *file, const char __user *ubuf,
5458 : : size_t cnt, loff_t *ppos)
5459 : : {
5460 : : ssize_t read, ret = 0;
5461 : 0 : struct ftrace_graph_data *fgd = file->private_data;
5462 : : struct trace_parser *parser;
5463 : :
5464 : 0 : if (!cnt)
5465 : : return 0;
5466 : :
5467 : : /* Read mode uses seq functions */
5468 : 0 : if (file->f_mode & FMODE_READ) {
5469 : : struct seq_file *m = file->private_data;
5470 : 0 : fgd = m->private;
5471 : : }
5472 : :
5473 : 0 : parser = &fgd->parser;
5474 : :
5475 : 0 : read = trace_get_user(parser, ubuf, cnt, ppos);
5476 : :
5477 : 0 : if (read >= 0 && trace_parser_loaded(parser) &&
5478 : : !trace_parser_cont(parser)) {
5479 : :
5480 : 0 : ret = ftrace_graph_set_hash(fgd->new_hash,
5481 : : parser->buffer);
5482 : : trace_parser_clear(parser);
5483 : : }
5484 : :
5485 : 0 : if (!ret)
5486 : : ret = read;
5487 : :
5488 : 0 : return ret;
5489 : : }
5490 : :
5491 : : static const struct file_operations ftrace_graph_fops = {
5492 : : .open = ftrace_graph_open,
5493 : : .read = seq_read,
5494 : : .write = ftrace_graph_write,
5495 : : .llseek = tracing_lseek,
5496 : : .release = ftrace_graph_release,
5497 : : };
5498 : :
5499 : : static const struct file_operations ftrace_graph_notrace_fops = {
5500 : : .open = ftrace_graph_notrace_open,
5501 : : .read = seq_read,
5502 : : .write = ftrace_graph_write,
5503 : : .llseek = tracing_lseek,
5504 : : .release = ftrace_graph_release,
5505 : : };
5506 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
5507 : :
5508 : 3 : void ftrace_create_filter_files(struct ftrace_ops *ops,
5509 : : struct dentry *parent)
5510 : : {
5511 : :
5512 : 3 : trace_create_file("set_ftrace_filter", 0644, parent,
5513 : : ops, &ftrace_filter_fops);
5514 : :
5515 : 3 : trace_create_file("set_ftrace_notrace", 0644, parent,
5516 : : ops, &ftrace_notrace_fops);
5517 : 3 : }
5518 : :
5519 : : /*
5520 : : * The name "destroy_filter_files" is really a misnomer. Although
5521 : : * in the future, it may actually delete the files, but this is
5522 : : * really intended to make sure the ops passed in are disabled
5523 : : * and that when this function returns, the caller is free to
5524 : : * free the ops.
5525 : : *
5526 : : * The "destroy" name is only to match the "create" name that this
5527 : : * should be paired with.
5528 : : */
5529 : 0 : void ftrace_destroy_filter_files(struct ftrace_ops *ops)
5530 : : {
5531 : 0 : mutex_lock(&ftrace_lock);
5532 : 0 : if (ops->flags & FTRACE_OPS_FL_ENABLED)
5533 : 0 : ftrace_shutdown(ops, 0);
5534 : 0 : ops->flags |= FTRACE_OPS_FL_DELETED;
5535 : 0 : ftrace_free_filter(ops);
5536 : 0 : mutex_unlock(&ftrace_lock);
5537 : 0 : }
5538 : :
5539 : 3 : static __init int ftrace_init_dyn_tracefs(struct dentry *d_tracer)
5540 : : {
5541 : :
5542 : 3 : trace_create_file("available_filter_functions", 0444,
5543 : : d_tracer, NULL, &ftrace_avail_fops);
5544 : :
5545 : 3 : trace_create_file("enabled_functions", 0444,
5546 : : d_tracer, NULL, &ftrace_enabled_fops);
5547 : :
5548 : 3 : ftrace_create_filter_files(&global_ops, d_tracer);
5549 : :
5550 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
5551 : 3 : trace_create_file("set_graph_function", 0644, d_tracer,
5552 : : NULL,
5553 : : &ftrace_graph_fops);
5554 : 3 : trace_create_file("set_graph_notrace", 0644, d_tracer,
5555 : : NULL,
5556 : : &ftrace_graph_notrace_fops);
5557 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
5558 : :
5559 : 3 : return 0;
5560 : : }
5561 : :
5562 : 3 : static int ftrace_cmp_ips(const void *a, const void *b)
5563 : : {
5564 : : const unsigned long *ipa = a;
5565 : : const unsigned long *ipb = b;
5566 : :
5567 : 3 : if (*ipa > *ipb)
5568 : : return 1;
5569 : 3 : if (*ipa < *ipb)
5570 : : return -1;
5571 : 0 : return 0;
5572 : : }
5573 : :
5574 : 3 : static int ftrace_process_locs(struct module *mod,
5575 : : unsigned long *start,
5576 : : unsigned long *end)
5577 : : {
5578 : : struct ftrace_page *start_pg;
5579 : : struct ftrace_page *pg;
5580 : : struct dyn_ftrace *rec;
5581 : : unsigned long count;
5582 : : unsigned long *p;
5583 : : unsigned long addr;
5584 : : unsigned long flags = 0; /* Shut up gcc */
5585 : : int ret = -ENOMEM;
5586 : :
5587 : 3 : count = end - start;
5588 : :
5589 : 3 : if (!count)
5590 : : return 0;
5591 : :
5592 : 3 : sort(start, count, sizeof(*start),
5593 : : ftrace_cmp_ips, NULL);
5594 : :
5595 : 3 : start_pg = ftrace_allocate_pages(count);
5596 : 3 : if (!start_pg)
5597 : : return -ENOMEM;
5598 : :
5599 : 3 : mutex_lock(&ftrace_lock);
5600 : :
5601 : : /*
5602 : : * Core and each module needs their own pages, as
5603 : : * modules will free them when they are removed.
5604 : : * Force a new page to be allocated for modules.
5605 : : */
5606 : 3 : if (!mod) {
5607 : 3 : WARN_ON(ftrace_pages || ftrace_pages_start);
5608 : : /* First initialization */
5609 : 3 : ftrace_pages = ftrace_pages_start = start_pg;
5610 : : } else {
5611 : 3 : if (!ftrace_pages)
5612 : : goto out;
5613 : :
5614 : 3 : if (WARN_ON(ftrace_pages->next)) {
5615 : : /* Hmm, we have free pages? */
5616 : 0 : while (ftrace_pages->next)
5617 : 0 : ftrace_pages = ftrace_pages->next;
5618 : : }
5619 : :
5620 : 3 : ftrace_pages->next = start_pg;
5621 : : }
5622 : :
5623 : : p = start;
5624 : : pg = start_pg;
5625 : 3 : while (p < end) {
5626 : 3 : addr = ftrace_call_adjust(*p++);
5627 : : /*
5628 : : * Some architecture linkers will pad between
5629 : : * the different mcount_loc sections of different
5630 : : * object files to satisfy alignments.
5631 : : * Skip any NULL pointers.
5632 : : */
5633 : 3 : if (!addr)
5634 : 0 : continue;
5635 : :
5636 : 3 : if (pg->index == pg->size) {
5637 : : /* We should have allocated enough */
5638 : 3 : if (WARN_ON(!pg->next))
5639 : : break;
5640 : 3 : pg = pg->next;
5641 : : }
5642 : :
5643 : 3 : rec = &pg->records[pg->index++];
5644 : 3 : rec->ip = addr;
5645 : : }
5646 : :
5647 : : /* We should have used all pages */
5648 : 3 : WARN_ON(pg->next);
5649 : :
5650 : : /* Assign the last page to ftrace_pages */
5651 : 3 : ftrace_pages = pg;
5652 : :
5653 : : /*
5654 : : * We only need to disable interrupts on start up
5655 : : * because we are modifying code that an interrupt
5656 : : * may execute, and the modification is not atomic.
5657 : : * But for modules, nothing runs the code we modify
5658 : : * until we are finished with it, and there's no
5659 : : * reason to cause large interrupt latencies while we do it.
5660 : : */
5661 : 3 : if (!mod)
5662 : 3 : local_irq_save(flags);
5663 : 3 : ftrace_update_code(mod, start_pg);
5664 : 3 : if (!mod)
5665 : 3 : local_irq_restore(flags);
5666 : : ret = 0;
5667 : : out:
5668 : 3 : mutex_unlock(&ftrace_lock);
5669 : :
5670 : 3 : return ret;
5671 : : }
5672 : :
5673 : : struct ftrace_mod_func {
5674 : : struct list_head list;
5675 : : char *name;
5676 : : unsigned long ip;
5677 : : unsigned int size;
5678 : : };
5679 : :
5680 : : struct ftrace_mod_map {
5681 : : struct rcu_head rcu;
5682 : : struct list_head list;
5683 : : struct module *mod;
5684 : : unsigned long start_addr;
5685 : : unsigned long end_addr;
5686 : : struct list_head funcs;
5687 : : unsigned int num_funcs;
5688 : : };
5689 : :
5690 : : #ifdef CONFIG_MODULES
5691 : :
5692 : : #define next_to_ftrace_page(p) container_of(p, struct ftrace_page, next)
5693 : :
5694 : : static LIST_HEAD(ftrace_mod_maps);
5695 : :
5696 : 0 : static int referenced_filters(struct dyn_ftrace *rec)
5697 : : {
5698 : : struct ftrace_ops *ops;
5699 : : int cnt = 0;
5700 : :
5701 : 0 : for (ops = ftrace_ops_list; ops != &ftrace_list_end; ops = ops->next) {
5702 : 0 : if (ops_references_rec(ops, rec)) {
5703 : 0 : cnt++;
5704 : 0 : if (ops->flags & FTRACE_OPS_FL_SAVE_REGS)
5705 : 0 : rec->flags |= FTRACE_FL_REGS;
5706 : : }
5707 : : }
5708 : :
5709 : 0 : return cnt;
5710 : : }
5711 : :
5712 : : static void
5713 : 0 : clear_mod_from_hash(struct ftrace_page *pg, struct ftrace_hash *hash)
5714 : : {
5715 : : struct ftrace_func_entry *entry;
5716 : : struct dyn_ftrace *rec;
5717 : : int i;
5718 : :
5719 : 0 : if (ftrace_hash_empty(hash))
5720 : 0 : return;
5721 : :
5722 : 0 : for (i = 0; i < pg->index; i++) {
5723 : 0 : rec = &pg->records[i];
5724 : 0 : entry = __ftrace_lookup_ip(hash, rec->ip);
5725 : : /*
5726 : : * Do not allow this rec to match again.
5727 : : * Yeah, it may waste some memory, but will be removed
5728 : : * if/when the hash is modified again.
5729 : : */
5730 : 0 : if (entry)
5731 : 0 : entry->ip = 0;
5732 : : }
5733 : : }
5734 : :
5735 : : /* Clear any records from hashs */
5736 : 0 : static void clear_mod_from_hashes(struct ftrace_page *pg)
5737 : : {
5738 : : struct trace_array *tr;
5739 : :
5740 : 0 : mutex_lock(&trace_types_lock);
5741 : 0 : list_for_each_entry(tr, &ftrace_trace_arrays, list) {
5742 : 0 : if (!tr->ops || !tr->ops->func_hash)
5743 : 0 : continue;
5744 : 0 : mutex_lock(&tr->ops->func_hash->regex_lock);
5745 : 0 : clear_mod_from_hash(pg, tr->ops->func_hash->filter_hash);
5746 : 0 : clear_mod_from_hash(pg, tr->ops->func_hash->notrace_hash);
5747 : 0 : mutex_unlock(&tr->ops->func_hash->regex_lock);
5748 : : }
5749 : 0 : mutex_unlock(&trace_types_lock);
5750 : 0 : }
5751 : :
5752 : 0 : static void ftrace_free_mod_map(struct rcu_head *rcu)
5753 : : {
5754 : : struct ftrace_mod_map *mod_map = container_of(rcu, struct ftrace_mod_map, rcu);
5755 : : struct ftrace_mod_func *mod_func;
5756 : : struct ftrace_mod_func *n;
5757 : :
5758 : : /* All the contents of mod_map are now not visible to readers */
5759 : 0 : list_for_each_entry_safe(mod_func, n, &mod_map->funcs, list) {
5760 : 0 : kfree(mod_func->name);
5761 : : list_del(&mod_func->list);
5762 : 0 : kfree(mod_func);
5763 : : }
5764 : :
5765 : 0 : kfree(mod_map);
5766 : 0 : }
5767 : :
5768 : 0 : void ftrace_release_mod(struct module *mod)
5769 : : {
5770 : : struct ftrace_mod_map *mod_map;
5771 : : struct ftrace_mod_map *n;
5772 : : struct dyn_ftrace *rec;
5773 : : struct ftrace_page **last_pg;
5774 : : struct ftrace_page *tmp_page = NULL;
5775 : : struct ftrace_page *pg;
5776 : : int order;
5777 : :
5778 : 0 : mutex_lock(&ftrace_lock);
5779 : :
5780 : 0 : if (ftrace_disabled)
5781 : : goto out_unlock;
5782 : :
5783 : 0 : list_for_each_entry_safe(mod_map, n, &ftrace_mod_maps, list) {
5784 : 0 : if (mod_map->mod == mod) {
5785 : : list_del_rcu(&mod_map->list);
5786 : 0 : call_rcu(&mod_map->rcu, ftrace_free_mod_map);
5787 : 0 : break;
5788 : : }
5789 : : }
5790 : :
5791 : : /*
5792 : : * Each module has its own ftrace_pages, remove
5793 : : * them from the list.
5794 : : */
5795 : : last_pg = &ftrace_pages_start;
5796 : 0 : for (pg = ftrace_pages_start; pg; pg = *last_pg) {
5797 : 0 : rec = &pg->records[0];
5798 : 0 : if (within_module_core(rec->ip, mod) ||
5799 : : within_module_init(rec->ip, mod)) {
5800 : : /*
5801 : : * As core pages are first, the first
5802 : : * page should never be a module page.
5803 : : */
5804 : 0 : if (WARN_ON(pg == ftrace_pages_start))
5805 : : goto out_unlock;
5806 : :
5807 : : /* Check if we are deleting the last page */
5808 : 0 : if (pg == ftrace_pages)
5809 : 0 : ftrace_pages = next_to_ftrace_page(last_pg);
5810 : :
5811 : 0 : ftrace_update_tot_cnt -= pg->index;
5812 : 0 : *last_pg = pg->next;
5813 : :
5814 : 0 : pg->next = tmp_page;
5815 : 0 : tmp_page = pg;
5816 : : } else
5817 : 0 : last_pg = &pg->next;
5818 : : }
5819 : : out_unlock:
5820 : 0 : mutex_unlock(&ftrace_lock);
5821 : :
5822 : 0 : for (pg = tmp_page; pg; pg = tmp_page) {
5823 : :
5824 : : /* Needs to be called outside of ftrace_lock */
5825 : 0 : clear_mod_from_hashes(pg);
5826 : :
5827 : 0 : order = get_count_order(pg->size / ENTRIES_PER_PAGE);
5828 : 0 : free_pages((unsigned long)pg->records, order);
5829 : 0 : tmp_page = pg->next;
5830 : 0 : kfree(pg);
5831 : : }
5832 : 0 : }
5833 : :
5834 : 3 : void ftrace_module_enable(struct module *mod)
5835 : : {
5836 : : struct dyn_ftrace *rec;
5837 : : struct ftrace_page *pg;
5838 : :
5839 : 3 : mutex_lock(&ftrace_lock);
5840 : :
5841 : 3 : if (ftrace_disabled)
5842 : : goto out_unlock;
5843 : :
5844 : : /*
5845 : : * If the tracing is enabled, go ahead and enable the record.
5846 : : *
5847 : : * The reason not to enable the record immediately is the
5848 : : * inherent check of ftrace_make_nop/ftrace_make_call for
5849 : : * correct previous instructions. Making first the NOP
5850 : : * conversion puts the module to the correct state, thus
5851 : : * passing the ftrace_make_call check.
5852 : : *
5853 : : * We also delay this to after the module code already set the
5854 : : * text to read-only, as we now need to set it back to read-write
5855 : : * so that we can modify the text.
5856 : : */
5857 : 3 : if (ftrace_start_up)
5858 : 0 : ftrace_arch_code_modify_prepare();
5859 : :
5860 : 3 : do_for_each_ftrace_rec(pg, rec) {
5861 : : int cnt;
5862 : : /*
5863 : : * do_for_each_ftrace_rec() is a double loop.
5864 : : * module text shares the pg. If a record is
5865 : : * not part of this module, then skip this pg,
5866 : : * which the "break" will do.
5867 : : */
5868 : 3 : if (!within_module_core(rec->ip, mod) &&
5869 : : !within_module_init(rec->ip, mod))
5870 : : break;
5871 : :
5872 : : cnt = 0;
5873 : :
5874 : : /*
5875 : : * When adding a module, we need to check if tracers are
5876 : : * currently enabled and if they are, and can trace this record,
5877 : : * we need to enable the module functions as well as update the
5878 : : * reference counts for those function records.
5879 : : */
5880 : 3 : if (ftrace_start_up)
5881 : 0 : cnt += referenced_filters(rec);
5882 : :
5883 : 3 : rec->flags &= ~FTRACE_FL_DISABLED;
5884 : 3 : rec->flags += cnt;
5885 : :
5886 : 3 : if (ftrace_start_up && cnt) {
5887 : 0 : int failed = __ftrace_replace_code(rec, 1);
5888 : 0 : if (failed) {
5889 : 0 : ftrace_bug(failed, rec);
5890 : 0 : goto out_loop;
5891 : : }
5892 : : }
5893 : :
5894 : : } while_for_each_ftrace_rec();
5895 : :
5896 : : out_loop:
5897 : 3 : if (ftrace_start_up)
5898 : 0 : ftrace_arch_code_modify_post_process();
5899 : :
5900 : : out_unlock:
5901 : 3 : mutex_unlock(&ftrace_lock);
5902 : :
5903 : 3 : process_cached_mods(mod->name);
5904 : 3 : }
5905 : :
5906 : 3 : void ftrace_module_init(struct module *mod)
5907 : : {
5908 : 3 : if (ftrace_disabled || !mod->num_ftrace_callsites)
5909 : 3 : return;
5910 : :
5911 : 3 : ftrace_process_locs(mod, mod->ftrace_callsites,
5912 : 3 : mod->ftrace_callsites + mod->num_ftrace_callsites);
5913 : : }
5914 : :
5915 : 0 : static void save_ftrace_mod_rec(struct ftrace_mod_map *mod_map,
5916 : : struct dyn_ftrace *rec)
5917 : : {
5918 : : struct ftrace_mod_func *mod_func;
5919 : : unsigned long symsize;
5920 : : unsigned long offset;
5921 : : char str[KSYM_SYMBOL_LEN];
5922 : : char *modname;
5923 : : const char *ret;
5924 : :
5925 : 0 : ret = kallsyms_lookup(rec->ip, &symsize, &offset, &modname, str);
5926 : 0 : if (!ret)
5927 : 0 : return;
5928 : :
5929 : : mod_func = kmalloc(sizeof(*mod_func), GFP_KERNEL);
5930 : 0 : if (!mod_func)
5931 : : return;
5932 : :
5933 : 0 : mod_func->name = kstrdup(str, GFP_KERNEL);
5934 : 0 : if (!mod_func->name) {
5935 : 0 : kfree(mod_func);
5936 : 0 : return;
5937 : : }
5938 : :
5939 : 0 : mod_func->ip = rec->ip - offset;
5940 : 0 : mod_func->size = symsize;
5941 : :
5942 : 0 : mod_map->num_funcs++;
5943 : :
5944 : 0 : list_add_rcu(&mod_func->list, &mod_map->funcs);
5945 : : }
5946 : :
5947 : : static struct ftrace_mod_map *
5948 : 0 : allocate_ftrace_mod_map(struct module *mod,
5949 : : unsigned long start, unsigned long end)
5950 : : {
5951 : : struct ftrace_mod_map *mod_map;
5952 : :
5953 : : mod_map = kmalloc(sizeof(*mod_map), GFP_KERNEL);
5954 : 0 : if (!mod_map)
5955 : : return NULL;
5956 : :
5957 : 0 : mod_map->mod = mod;
5958 : 0 : mod_map->start_addr = start;
5959 : 0 : mod_map->end_addr = end;
5960 : 0 : mod_map->num_funcs = 0;
5961 : :
5962 : 0 : INIT_LIST_HEAD_RCU(&mod_map->funcs);
5963 : :
5964 : 0 : list_add_rcu(&mod_map->list, &ftrace_mod_maps);
5965 : :
5966 : 0 : return mod_map;
5967 : : }
5968 : :
5969 : : static const char *
5970 : 0 : ftrace_func_address_lookup(struct ftrace_mod_map *mod_map,
5971 : : unsigned long addr, unsigned long *size,
5972 : : unsigned long *off, char *sym)
5973 : : {
5974 : : struct ftrace_mod_func *found_func = NULL;
5975 : : struct ftrace_mod_func *mod_func;
5976 : :
5977 : 0 : list_for_each_entry_rcu(mod_func, &mod_map->funcs, list) {
5978 : 0 : if (addr >= mod_func->ip &&
5979 : 0 : addr < mod_func->ip + mod_func->size) {
5980 : 0 : found_func = mod_func;
5981 : 0 : break;
5982 : : }
5983 : : }
5984 : :
5985 : 0 : if (found_func) {
5986 : 0 : if (size)
5987 : 0 : *size = found_func->size;
5988 : 0 : if (off)
5989 : 0 : *off = addr - found_func->ip;
5990 : 0 : if (sym)
5991 : 0 : strlcpy(sym, found_func->name, KSYM_NAME_LEN);
5992 : :
5993 : 0 : return found_func->name;
5994 : : }
5995 : :
5996 : : return NULL;
5997 : : }
5998 : :
5999 : : const char *
6000 : 0 : ftrace_mod_address_lookup(unsigned long addr, unsigned long *size,
6001 : : unsigned long *off, char **modname, char *sym)
6002 : : {
6003 : : struct ftrace_mod_map *mod_map;
6004 : : const char *ret = NULL;
6005 : :
6006 : : /* mod_map is freed via call_rcu() */
6007 : 0 : preempt_disable();
6008 : 0 : list_for_each_entry_rcu(mod_map, &ftrace_mod_maps, list) {
6009 : 0 : ret = ftrace_func_address_lookup(mod_map, addr, size, off, sym);
6010 : 0 : if (ret) {
6011 : 0 : if (modname)
6012 : 0 : *modname = mod_map->mod->name;
6013 : : break;
6014 : : }
6015 : : }
6016 : 0 : preempt_enable();
6017 : :
6018 : 0 : return ret;
6019 : : }
6020 : :
6021 : 0 : int ftrace_mod_get_kallsym(unsigned int symnum, unsigned long *value,
6022 : : char *type, char *name,
6023 : : char *module_name, int *exported)
6024 : : {
6025 : : struct ftrace_mod_map *mod_map;
6026 : : struct ftrace_mod_func *mod_func;
6027 : :
6028 : 0 : preempt_disable();
6029 : 0 : list_for_each_entry_rcu(mod_map, &ftrace_mod_maps, list) {
6030 : :
6031 : 0 : if (symnum >= mod_map->num_funcs) {
6032 : 0 : symnum -= mod_map->num_funcs;
6033 : 0 : continue;
6034 : : }
6035 : :
6036 : 0 : list_for_each_entry_rcu(mod_func, &mod_map->funcs, list) {
6037 : 0 : if (symnum > 1) {
6038 : 0 : symnum--;
6039 : 0 : continue;
6040 : : }
6041 : :
6042 : 0 : *value = mod_func->ip;
6043 : 0 : *type = 'T';
6044 : 0 : strlcpy(name, mod_func->name, KSYM_NAME_LEN);
6045 : 0 : strlcpy(module_name, mod_map->mod->name, MODULE_NAME_LEN);
6046 : 0 : *exported = 1;
6047 : 0 : preempt_enable();
6048 : 0 : return 0;
6049 : : }
6050 : 0 : WARN_ON(1);
6051 : 0 : break;
6052 : : }
6053 : 0 : preempt_enable();
6054 : 0 : return -ERANGE;
6055 : : }
6056 : :
6057 : : #else
6058 : : static void save_ftrace_mod_rec(struct ftrace_mod_map *mod_map,
6059 : : struct dyn_ftrace *rec) { }
6060 : : static inline struct ftrace_mod_map *
6061 : : allocate_ftrace_mod_map(struct module *mod,
6062 : : unsigned long start, unsigned long end)
6063 : : {
6064 : : return NULL;
6065 : : }
6066 : : #endif /* CONFIG_MODULES */
6067 : :
6068 : : struct ftrace_init_func {
6069 : : struct list_head list;
6070 : : unsigned long ip;
6071 : : };
6072 : :
6073 : : /* Clear any init ips from hashes */
6074 : : static void
6075 : : clear_func_from_hash(struct ftrace_init_func *func, struct ftrace_hash *hash)
6076 : : {
6077 : : struct ftrace_func_entry *entry;
6078 : :
6079 : 3 : entry = ftrace_lookup_ip(hash, func->ip);
6080 : : /*
6081 : : * Do not allow this rec to match again.
6082 : : * Yeah, it may waste some memory, but will be removed
6083 : : * if/when the hash is modified again.
6084 : : */
6085 : 3 : if (entry)
6086 : 0 : entry->ip = 0;
6087 : : }
6088 : :
6089 : : static void
6090 : 3 : clear_func_from_hashes(struct ftrace_init_func *func)
6091 : : {
6092 : : struct trace_array *tr;
6093 : :
6094 : 3 : mutex_lock(&trace_types_lock);
6095 : 3 : list_for_each_entry(tr, &ftrace_trace_arrays, list) {
6096 : 3 : if (!tr->ops || !tr->ops->func_hash)
6097 : 0 : continue;
6098 : 3 : mutex_lock(&tr->ops->func_hash->regex_lock);
6099 : 3 : clear_func_from_hash(func, tr->ops->func_hash->filter_hash);
6100 : 3 : clear_func_from_hash(func, tr->ops->func_hash->notrace_hash);
6101 : 3 : mutex_unlock(&tr->ops->func_hash->regex_lock);
6102 : : }
6103 : 3 : mutex_unlock(&trace_types_lock);
6104 : 3 : }
6105 : :
6106 : 3 : static void add_to_clear_hash_list(struct list_head *clear_list,
6107 : : struct dyn_ftrace *rec)
6108 : : {
6109 : : struct ftrace_init_func *func;
6110 : :
6111 : : func = kmalloc(sizeof(*func), GFP_KERNEL);
6112 : 3 : if (!func) {
6113 : 0 : WARN_ONCE(1, "alloc failure, ftrace filter could be stale\n");
6114 : 3 : return;
6115 : : }
6116 : :
6117 : 3 : func->ip = rec->ip;
6118 : 3 : list_add(&func->list, clear_list);
6119 : : }
6120 : :
6121 : 3 : void ftrace_free_mem(struct module *mod, void *start_ptr, void *end_ptr)
6122 : : {
6123 : 3 : unsigned long start = (unsigned long)(start_ptr);
6124 : 3 : unsigned long end = (unsigned long)(end_ptr);
6125 : : struct ftrace_page **last_pg = &ftrace_pages_start;
6126 : : struct ftrace_page *pg;
6127 : : struct dyn_ftrace *rec;
6128 : : struct dyn_ftrace key;
6129 : : struct ftrace_mod_map *mod_map = NULL;
6130 : : struct ftrace_init_func *func, *func_next;
6131 : : struct list_head clear_hash;
6132 : : int order;
6133 : :
6134 : : INIT_LIST_HEAD(&clear_hash);
6135 : :
6136 : 3 : key.ip = start;
6137 : 3 : key.flags = end; /* overload flags, as it is unsigned long */
6138 : :
6139 : 3 : mutex_lock(&ftrace_lock);
6140 : :
6141 : : /*
6142 : : * If we are freeing module init memory, then check if
6143 : : * any tracer is active. If so, we need to save a mapping of
6144 : : * the module functions being freed with the address.
6145 : : */
6146 : 3 : if (mod && ftrace_ops_list != &ftrace_list_end)
6147 : 0 : mod_map = allocate_ftrace_mod_map(mod, start, end);
6148 : :
6149 : 3 : for (pg = ftrace_pages_start; pg; last_pg = &pg->next, pg = *last_pg) {
6150 : 3 : if (end < pg->records[0].ip ||
6151 : 3 : start >= (pg->records[pg->index - 1].ip + MCOUNT_INSN_SIZE))
6152 : 3 : continue;
6153 : : again:
6154 : 3 : rec = bsearch(&key, pg->records, pg->index,
6155 : : sizeof(struct dyn_ftrace),
6156 : : ftrace_cmp_recs);
6157 : 3 : if (!rec)
6158 : 3 : continue;
6159 : :
6160 : : /* rec will be cleared from hashes after ftrace_lock unlock */
6161 : 3 : add_to_clear_hash_list(&clear_hash, rec);
6162 : :
6163 : 3 : if (mod_map)
6164 : 0 : save_ftrace_mod_rec(mod_map, rec);
6165 : :
6166 : 3 : pg->index--;
6167 : 3 : ftrace_update_tot_cnt--;
6168 : 3 : if (!pg->index) {
6169 : 3 : *last_pg = pg->next;
6170 : 3 : order = get_count_order(pg->size / ENTRIES_PER_PAGE);
6171 : 3 : free_pages((unsigned long)pg->records, order);
6172 : 3 : kfree(pg);
6173 : : pg = container_of(last_pg, struct ftrace_page, next);
6174 : 3 : if (!(*last_pg))
6175 : 3 : ftrace_pages = pg;
6176 : 3 : continue;
6177 : : }
6178 : 3 : memmove(rec, rec + 1,
6179 : 3 : (pg->index - (rec - pg->records)) * sizeof(*rec));
6180 : : /* More than one function may be in this block */
6181 : 3 : goto again;
6182 : : }
6183 : 3 : mutex_unlock(&ftrace_lock);
6184 : :
6185 : 3 : list_for_each_entry_safe(func, func_next, &clear_hash, list) {
6186 : 3 : clear_func_from_hashes(func);
6187 : 3 : kfree(func);
6188 : : }
6189 : 3 : }
6190 : :
6191 : 3 : void __init ftrace_free_init_mem(void)
6192 : : {
6193 : : void *start = (void *)(&__init_begin);
6194 : : void *end = (void *)(&__init_end);
6195 : :
6196 : 3 : ftrace_free_mem(NULL, start, end);
6197 : 3 : }
6198 : :
6199 : 3 : void __init ftrace_init(void)
6200 : : {
6201 : : extern unsigned long __start_mcount_loc[];
6202 : : extern unsigned long __stop_mcount_loc[];
6203 : : unsigned long count, flags;
6204 : : int ret;
6205 : :
6206 : 3 : local_irq_save(flags);
6207 : 3 : ret = ftrace_dyn_arch_init();
6208 : 3 : local_irq_restore(flags);
6209 : 3 : if (ret)
6210 : : goto failed;
6211 : :
6212 : 3 : count = __stop_mcount_loc - __start_mcount_loc;
6213 : 3 : if (!count) {
6214 : 0 : pr_info("ftrace: No functions to be traced?\n");
6215 : 0 : goto failed;
6216 : : }
6217 : :
6218 : 3 : pr_info("ftrace: allocating %ld entries in %ld pages\n",
6219 : : count, count / ENTRIES_PER_PAGE + 1);
6220 : :
6221 : 3 : last_ftrace_enabled = ftrace_enabled = 1;
6222 : :
6223 : 3 : ret = ftrace_process_locs(NULL,
6224 : : __start_mcount_loc,
6225 : : __stop_mcount_loc);
6226 : :
6227 : 3 : set_ftrace_early_filters();
6228 : :
6229 : 3 : return;
6230 : : failed:
6231 : 0 : ftrace_disabled = 1;
6232 : : }
6233 : :
6234 : : /* Do nothing if arch does not support this */
6235 : 0 : void __weak arch_ftrace_update_trampoline(struct ftrace_ops *ops)
6236 : : {
6237 : 0 : }
6238 : :
6239 : : static void ftrace_update_trampoline(struct ftrace_ops *ops)
6240 : : {
6241 : 0 : arch_ftrace_update_trampoline(ops);
6242 : : }
6243 : :
6244 : 0 : void ftrace_init_trace_array(struct trace_array *tr)
6245 : : {
6246 : 3 : INIT_LIST_HEAD(&tr->func_probes);
6247 : 3 : INIT_LIST_HEAD(&tr->mod_trace);
6248 : 3 : INIT_LIST_HEAD(&tr->mod_notrace);
6249 : 0 : }
6250 : : #else
6251 : :
6252 : : struct ftrace_ops global_ops = {
6253 : : .func = ftrace_stub,
6254 : : .flags = FTRACE_OPS_FL_RECURSION_SAFE |
6255 : : FTRACE_OPS_FL_INITIALIZED |
6256 : : FTRACE_OPS_FL_PID,
6257 : : };
6258 : :
6259 : : static int __init ftrace_nodyn_init(void)
6260 : : {
6261 : : ftrace_enabled = 1;
6262 : : return 0;
6263 : : }
6264 : : core_initcall(ftrace_nodyn_init);
6265 : :
6266 : : static inline int ftrace_init_dyn_tracefs(struct dentry *d_tracer) { return 0; }
6267 : : static inline void ftrace_startup_enable(int command) { }
6268 : : static inline void ftrace_startup_all(int command) { }
6269 : :
6270 : : # define ftrace_startup_sysctl() do { } while (0)
6271 : : # define ftrace_shutdown_sysctl() do { } while (0)
6272 : :
6273 : : static void ftrace_update_trampoline(struct ftrace_ops *ops)
6274 : : {
6275 : : }
6276 : :
6277 : : #endif /* CONFIG_DYNAMIC_FTRACE */
6278 : :
6279 : 3 : __init void ftrace_init_global_array_ops(struct trace_array *tr)
6280 : : {
6281 : 3 : tr->ops = &global_ops;
6282 : 3 : tr->ops->private = tr;
6283 : : ftrace_init_trace_array(tr);
6284 : 3 : }
6285 : :
6286 : 0 : void ftrace_init_array_ops(struct trace_array *tr, ftrace_func_t func)
6287 : : {
6288 : : /* If we filter on pids, update to use the pid function */
6289 : 0 : if (tr->flags & TRACE_ARRAY_FL_GLOBAL) {
6290 : 0 : if (WARN_ON(tr->ops->func != ftrace_stub))
6291 : 0 : printk("ftrace ops had %pS for function\n",
6292 : 0 : tr->ops->func);
6293 : : }
6294 : 0 : tr->ops->func = func;
6295 : 0 : tr->ops->private = tr;
6296 : 0 : }
6297 : :
6298 : 0 : void ftrace_reset_array_ops(struct trace_array *tr)
6299 : : {
6300 : 0 : tr->ops->func = ftrace_stub;
6301 : 0 : }
6302 : :
6303 : : static nokprobe_inline void
6304 : : __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
6305 : : struct ftrace_ops *ignored, struct pt_regs *regs)
6306 : : {
6307 : : struct ftrace_ops *op;
6308 : : int bit;
6309 : :
6310 : : bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
6311 : 0 : if (bit < 0)
6312 : : return;
6313 : :
6314 : : /*
6315 : : * Some of the ops may be dynamically allocated,
6316 : : * they must be freed after a synchronize_rcu().
6317 : : */
6318 : 0 : preempt_disable_notrace();
6319 : :
6320 : 0 : do_for_each_ftrace_op(op, ftrace_ops_list) {
6321 : : /* Stub functions don't need to be called nor tested */
6322 : 0 : if (op->flags & FTRACE_OPS_FL_STUB)
6323 : 0 : continue;
6324 : : /*
6325 : : * Check the following for each ops before calling their func:
6326 : : * if RCU flag is set, then rcu_is_watching() must be true
6327 : : * if PER_CPU is set, then ftrace_function_local_disable()
6328 : : * must be false
6329 : : * Otherwise test if the ip matches the ops filter
6330 : : *
6331 : : * If any of the above fails then the op->func() is not executed.
6332 : : */
6333 : 0 : if ((!(op->flags & FTRACE_OPS_FL_RCU) || rcu_is_watching()) &&
6334 : 0 : ftrace_ops_test(op, ip, regs)) {
6335 : 0 : if (FTRACE_WARN_ON(!op->func)) {
6336 : 0 : pr_warn("op=%p %pS\n", op, op);
6337 : : goto out;
6338 : : }
6339 : 0 : op->func(ip, parent_ip, op, regs);
6340 : : }
6341 : 0 : } while_for_each_ftrace_op(op);
6342 : : out:
6343 : 0 : preempt_enable_notrace();
6344 : : trace_clear_recursion(bit);
6345 : : }
6346 : :
6347 : : /*
6348 : : * Some archs only support passing ip and parent_ip. Even though
6349 : : * the list function ignores the op parameter, we do not want any
6350 : : * C side effects, where a function is called without the caller
6351 : : * sending a third parameter.
6352 : : * Archs are to support both the regs and ftrace_ops at the same time.
6353 : : * If they support ftrace_ops, it is assumed they support regs.
6354 : : * If call backs want to use regs, they must either check for regs
6355 : : * being NULL, or CONFIG_DYNAMIC_FTRACE_WITH_REGS.
6356 : : * Note, CONFIG_DYNAMIC_FTRACE_WITH_REGS expects a full regs to be saved.
6357 : : * An architecture can pass partial regs with ftrace_ops and still
6358 : : * set the ARCH_SUPPORTS_FTRACE_OPS.
6359 : : */
6360 : : #if ARCH_SUPPORTS_FTRACE_OPS
6361 : 0 : static void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
6362 : : struct ftrace_ops *op, struct pt_regs *regs)
6363 : : {
6364 : : __ftrace_ops_list_func(ip, parent_ip, NULL, regs);
6365 : 0 : }
6366 : : NOKPROBE_SYMBOL(ftrace_ops_list_func);
6367 : : #else
6368 : : static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip)
6369 : : {
6370 : : __ftrace_ops_list_func(ip, parent_ip, NULL, NULL);
6371 : : }
6372 : : NOKPROBE_SYMBOL(ftrace_ops_no_ops);
6373 : : #endif
6374 : :
6375 : : /*
6376 : : * If there's only one function registered but it does not support
6377 : : * recursion, needs RCU protection and/or requires per cpu handling, then
6378 : : * this function will be called by the mcount trampoline.
6379 : : */
6380 : 0 : static void ftrace_ops_assist_func(unsigned long ip, unsigned long parent_ip,
6381 : : struct ftrace_ops *op, struct pt_regs *regs)
6382 : : {
6383 : : int bit;
6384 : :
6385 : 0 : if ((op->flags & FTRACE_OPS_FL_RCU) && !rcu_is_watching())
6386 : : return;
6387 : :
6388 : : bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
6389 : 0 : if (bit < 0)
6390 : : return;
6391 : :
6392 : 0 : preempt_disable_notrace();
6393 : :
6394 : 0 : op->func(ip, parent_ip, op, regs);
6395 : :
6396 : 0 : preempt_enable_notrace();
6397 : : trace_clear_recursion(bit);
6398 : : }
6399 : : NOKPROBE_SYMBOL(ftrace_ops_assist_func);
6400 : :
6401 : : /**
6402 : : * ftrace_ops_get_func - get the function a trampoline should call
6403 : : * @ops: the ops to get the function for
6404 : : *
6405 : : * Normally the mcount trampoline will call the ops->func, but there
6406 : : * are times that it should not. For example, if the ops does not
6407 : : * have its own recursion protection, then it should call the
6408 : : * ftrace_ops_assist_func() instead.
6409 : : *
6410 : : * Returns the function that the trampoline should call for @ops.
6411 : : */
6412 : 0 : ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops)
6413 : : {
6414 : : /*
6415 : : * If the function does not handle recursion, needs to be RCU safe,
6416 : : * or does per cpu logic, then we need to call the assist handler.
6417 : : */
6418 : 0 : if (!(ops->flags & FTRACE_OPS_FL_RECURSION_SAFE) ||
6419 : : ops->flags & FTRACE_OPS_FL_RCU)
6420 : : return ftrace_ops_assist_func;
6421 : :
6422 : 0 : return ops->func;
6423 : : }
6424 : :
6425 : : static void
6426 : 0 : ftrace_filter_pid_sched_switch_probe(void *data, bool preempt,
6427 : : struct task_struct *prev, struct task_struct *next)
6428 : : {
6429 : : struct trace_array *tr = data;
6430 : : struct trace_pid_list *pid_list;
6431 : :
6432 : 0 : pid_list = rcu_dereference_sched(tr->function_pids);
6433 : :
6434 : 0 : this_cpu_write(tr->trace_buffer.data->ftrace_ignore_pid,
6435 : : trace_ignore_this_task(pid_list, next));
6436 : 0 : }
6437 : :
6438 : : static void
6439 : 0 : ftrace_pid_follow_sched_process_fork(void *data,
6440 : : struct task_struct *self,
6441 : : struct task_struct *task)
6442 : : {
6443 : : struct trace_pid_list *pid_list;
6444 : : struct trace_array *tr = data;
6445 : :
6446 : 0 : pid_list = rcu_dereference_sched(tr->function_pids);
6447 : 0 : trace_filter_add_remove_task(pid_list, self, task);
6448 : 0 : }
6449 : :
6450 : : static void
6451 : 0 : ftrace_pid_follow_sched_process_exit(void *data, struct task_struct *task)
6452 : : {
6453 : : struct trace_pid_list *pid_list;
6454 : : struct trace_array *tr = data;
6455 : :
6456 : 0 : pid_list = rcu_dereference_sched(tr->function_pids);
6457 : 0 : trace_filter_add_remove_task(pid_list, NULL, task);
6458 : 0 : }
6459 : :
6460 : 0 : void ftrace_pid_follow_fork(struct trace_array *tr, bool enable)
6461 : : {
6462 : 0 : if (enable) {
6463 : : register_trace_sched_process_fork(ftrace_pid_follow_sched_process_fork,
6464 : : tr);
6465 : : register_trace_sched_process_free(ftrace_pid_follow_sched_process_exit,
6466 : : tr);
6467 : : } else {
6468 : : unregister_trace_sched_process_fork(ftrace_pid_follow_sched_process_fork,
6469 : : tr);
6470 : : unregister_trace_sched_process_free(ftrace_pid_follow_sched_process_exit,
6471 : : tr);
6472 : : }
6473 : 0 : }
6474 : :
6475 : 0 : static void clear_ftrace_pids(struct trace_array *tr)
6476 : : {
6477 : : struct trace_pid_list *pid_list;
6478 : : int cpu;
6479 : :
6480 : 0 : pid_list = rcu_dereference_protected(tr->function_pids,
6481 : : lockdep_is_held(&ftrace_lock));
6482 : 0 : if (!pid_list)
6483 : 0 : return;
6484 : :
6485 : : unregister_trace_sched_switch(ftrace_filter_pid_sched_switch_probe, tr);
6486 : :
6487 : 0 : for_each_possible_cpu(cpu)
6488 : 0 : per_cpu_ptr(tr->trace_buffer.data, cpu)->ftrace_ignore_pid = false;
6489 : :
6490 : : rcu_assign_pointer(tr->function_pids, NULL);
6491 : :
6492 : : /* Wait till all users are no longer using pid filtering */
6493 : 0 : synchronize_rcu();
6494 : :
6495 : 0 : trace_free_pid_list(pid_list);
6496 : : }
6497 : :
6498 : 0 : void ftrace_clear_pids(struct trace_array *tr)
6499 : : {
6500 : 0 : mutex_lock(&ftrace_lock);
6501 : :
6502 : 0 : clear_ftrace_pids(tr);
6503 : :
6504 : 0 : mutex_unlock(&ftrace_lock);
6505 : 0 : }
6506 : :
6507 : 0 : static void ftrace_pid_reset(struct trace_array *tr)
6508 : : {
6509 : 0 : mutex_lock(&ftrace_lock);
6510 : 0 : clear_ftrace_pids(tr);
6511 : :
6512 : 0 : ftrace_update_pid_func();
6513 : : ftrace_startup_all(0);
6514 : :
6515 : 0 : mutex_unlock(&ftrace_lock);
6516 : 0 : }
6517 : :
6518 : : /* Greater than any max PID */
6519 : : #define FTRACE_NO_PIDS (void *)(PID_MAX_LIMIT + 1)
6520 : :
6521 : 0 : static void *fpid_start(struct seq_file *m, loff_t *pos)
6522 : : __acquires(RCU)
6523 : : {
6524 : : struct trace_pid_list *pid_list;
6525 : 0 : struct trace_array *tr = m->private;
6526 : :
6527 : 0 : mutex_lock(&ftrace_lock);
6528 : : rcu_read_lock_sched();
6529 : :
6530 : 0 : pid_list = rcu_dereference_sched(tr->function_pids);
6531 : :
6532 : 0 : if (!pid_list)
6533 : 0 : return !(*pos) ? FTRACE_NO_PIDS : NULL;
6534 : :
6535 : 0 : return trace_pid_start(pid_list, pos);
6536 : : }
6537 : :
6538 : 0 : static void *fpid_next(struct seq_file *m, void *v, loff_t *pos)
6539 : : {
6540 : 0 : struct trace_array *tr = m->private;
6541 : 0 : struct trace_pid_list *pid_list = rcu_dereference_sched(tr->function_pids);
6542 : :
6543 : 0 : if (v == FTRACE_NO_PIDS) {
6544 : 0 : (*pos)++;
6545 : 0 : return NULL;
6546 : : }
6547 : 0 : return trace_pid_next(pid_list, v, pos);
6548 : : }
6549 : :
6550 : 0 : static void fpid_stop(struct seq_file *m, void *p)
6551 : : __releases(RCU)
6552 : : {
6553 : : rcu_read_unlock_sched();
6554 : 0 : mutex_unlock(&ftrace_lock);
6555 : 0 : }
6556 : :
6557 : 0 : static int fpid_show(struct seq_file *m, void *v)
6558 : : {
6559 : 0 : if (v == FTRACE_NO_PIDS) {
6560 : 0 : seq_puts(m, "no pid\n");
6561 : 0 : return 0;
6562 : : }
6563 : :
6564 : 0 : return trace_pid_show(m, v);
6565 : : }
6566 : :
6567 : : static const struct seq_operations ftrace_pid_sops = {
6568 : : .start = fpid_start,
6569 : : .next = fpid_next,
6570 : : .stop = fpid_stop,
6571 : : .show = fpid_show,
6572 : : };
6573 : :
6574 : : static int
6575 : 0 : ftrace_pid_open(struct inode *inode, struct file *file)
6576 : : {
6577 : 0 : struct trace_array *tr = inode->i_private;
6578 : : struct seq_file *m;
6579 : : int ret = 0;
6580 : :
6581 : 0 : ret = tracing_check_open_get_tr(tr);
6582 : 0 : if (ret)
6583 : : return ret;
6584 : :
6585 : 0 : if ((file->f_mode & FMODE_WRITE) &&
6586 : 0 : (file->f_flags & O_TRUNC))
6587 : 0 : ftrace_pid_reset(tr);
6588 : :
6589 : 0 : ret = seq_open(file, &ftrace_pid_sops);
6590 : 0 : if (ret < 0) {
6591 : 0 : trace_array_put(tr);
6592 : : } else {
6593 : 0 : m = file->private_data;
6594 : : /* copy tr over to seq ops */
6595 : 0 : m->private = tr;
6596 : : }
6597 : :
6598 : 0 : return ret;
6599 : : }
6600 : :
6601 : 0 : static void ignore_task_cpu(void *data)
6602 : : {
6603 : : struct trace_array *tr = data;
6604 : : struct trace_pid_list *pid_list;
6605 : :
6606 : : /*
6607 : : * This function is called by on_each_cpu() while the
6608 : : * event_mutex is held.
6609 : : */
6610 : 0 : pid_list = rcu_dereference_protected(tr->function_pids,
6611 : : mutex_is_locked(&ftrace_lock));
6612 : :
6613 : 0 : this_cpu_write(tr->trace_buffer.data->ftrace_ignore_pid,
6614 : : trace_ignore_this_task(pid_list, current));
6615 : 0 : }
6616 : :
6617 : : static ssize_t
6618 : 0 : ftrace_pid_write(struct file *filp, const char __user *ubuf,
6619 : : size_t cnt, loff_t *ppos)
6620 : : {
6621 : 0 : struct seq_file *m = filp->private_data;
6622 : 0 : struct trace_array *tr = m->private;
6623 : : struct trace_pid_list *filtered_pids = NULL;
6624 : : struct trace_pid_list *pid_list;
6625 : : ssize_t ret;
6626 : :
6627 : 0 : if (!cnt)
6628 : : return 0;
6629 : :
6630 : 0 : mutex_lock(&ftrace_lock);
6631 : :
6632 : 0 : filtered_pids = rcu_dereference_protected(tr->function_pids,
6633 : : lockdep_is_held(&ftrace_lock));
6634 : :
6635 : 0 : ret = trace_pid_write(filtered_pids, &pid_list, ubuf, cnt);
6636 : 0 : if (ret < 0)
6637 : : goto out;
6638 : :
6639 : 0 : rcu_assign_pointer(tr->function_pids, pid_list);
6640 : :
6641 : 0 : if (filtered_pids) {
6642 : 0 : synchronize_rcu();
6643 : 0 : trace_free_pid_list(filtered_pids);
6644 : 0 : } else if (pid_list) {
6645 : : /* Register a probe to set whether to ignore the tracing of a task */
6646 : : register_trace_sched_switch(ftrace_filter_pid_sched_switch_probe, tr);
6647 : : }
6648 : :
6649 : : /*
6650 : : * Ignoring of pids is done at task switch. But we have to
6651 : : * check for those tasks that are currently running.
6652 : : * Always do this in case a pid was appended or removed.
6653 : : */
6654 : 0 : on_each_cpu(ignore_task_cpu, tr, 1);
6655 : :
6656 : 0 : ftrace_update_pid_func();
6657 : : ftrace_startup_all(0);
6658 : : out:
6659 : 0 : mutex_unlock(&ftrace_lock);
6660 : :
6661 : 0 : if (ret > 0)
6662 : 0 : *ppos += ret;
6663 : :
6664 : 0 : return ret;
6665 : : }
6666 : :
6667 : : static int
6668 : 0 : ftrace_pid_release(struct inode *inode, struct file *file)
6669 : : {
6670 : 0 : struct trace_array *tr = inode->i_private;
6671 : :
6672 : 0 : trace_array_put(tr);
6673 : :
6674 : 0 : return seq_release(inode, file);
6675 : : }
6676 : :
6677 : : static const struct file_operations ftrace_pid_fops = {
6678 : : .open = ftrace_pid_open,
6679 : : .write = ftrace_pid_write,
6680 : : .read = seq_read,
6681 : : .llseek = tracing_lseek,
6682 : : .release = ftrace_pid_release,
6683 : : };
6684 : :
6685 : 3 : void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d_tracer)
6686 : : {
6687 : 3 : trace_create_file("set_ftrace_pid", 0644, d_tracer,
6688 : : tr, &ftrace_pid_fops);
6689 : 3 : }
6690 : :
6691 : 3 : void __init ftrace_init_tracefs_toplevel(struct trace_array *tr,
6692 : : struct dentry *d_tracer)
6693 : : {
6694 : : /* Only the top level directory has the dyn_tracefs and profile */
6695 : 3 : WARN_ON(!(tr->flags & TRACE_ARRAY_FL_GLOBAL));
6696 : :
6697 : 3 : ftrace_init_dyn_tracefs(d_tracer);
6698 : 3 : ftrace_profile_tracefs(d_tracer);
6699 : 3 : }
6700 : :
6701 : : /**
6702 : : * ftrace_kill - kill ftrace
6703 : : *
6704 : : * This function should be used by panic code. It stops ftrace
6705 : : * but in a not so nice way. If you need to simply kill ftrace
6706 : : * from a non-atomic section, use ftrace_kill.
6707 : : */
6708 : 0 : void ftrace_kill(void)
6709 : : {
6710 : 0 : ftrace_disabled = 1;
6711 : 0 : ftrace_enabled = 0;
6712 : 0 : ftrace_trace_function = ftrace_stub;
6713 : 0 : }
6714 : :
6715 : : /**
6716 : : * Test if ftrace is dead or not.
6717 : : */
6718 : 0 : int ftrace_is_dead(void)
6719 : : {
6720 : 0 : return ftrace_disabled;
6721 : : }
6722 : :
6723 : : /**
6724 : : * register_ftrace_function - register a function for profiling
6725 : : * @ops - ops structure that holds the function for profiling.
6726 : : *
6727 : : * Register a function to be called by all functions in the
6728 : : * kernel.
6729 : : *
6730 : : * Note: @ops->func and all the functions it calls must be labeled
6731 : : * with "notrace", otherwise it will go into a
6732 : : * recursive loop.
6733 : : */
6734 : 0 : int register_ftrace_function(struct ftrace_ops *ops)
6735 : : {
6736 : : int ret = -1;
6737 : :
6738 : 0 : ftrace_ops_init(ops);
6739 : :
6740 : 0 : mutex_lock(&ftrace_lock);
6741 : :
6742 : 0 : ret = ftrace_startup(ops, 0);
6743 : :
6744 : 0 : mutex_unlock(&ftrace_lock);
6745 : :
6746 : 0 : return ret;
6747 : : }
6748 : : EXPORT_SYMBOL_GPL(register_ftrace_function);
6749 : :
6750 : : /**
6751 : : * unregister_ftrace_function - unregister a function for profiling.
6752 : : * @ops - ops structure that holds the function to unregister
6753 : : *
6754 : : * Unregister a function that was added to be called by ftrace profiling.
6755 : : */
6756 : 0 : int unregister_ftrace_function(struct ftrace_ops *ops)
6757 : : {
6758 : : int ret;
6759 : :
6760 : 0 : mutex_lock(&ftrace_lock);
6761 : 0 : ret = ftrace_shutdown(ops, 0);
6762 : 0 : mutex_unlock(&ftrace_lock);
6763 : :
6764 : 0 : return ret;
6765 : : }
6766 : : EXPORT_SYMBOL_GPL(unregister_ftrace_function);
6767 : :
6768 : : int
6769 : 0 : ftrace_enable_sysctl(struct ctl_table *table, int write,
6770 : : void __user *buffer, size_t *lenp,
6771 : : loff_t *ppos)
6772 : : {
6773 : : int ret = -ENODEV;
6774 : :
6775 : 0 : mutex_lock(&ftrace_lock);
6776 : :
6777 : 0 : if (unlikely(ftrace_disabled))
6778 : : goto out;
6779 : :
6780 : 0 : ret = proc_dointvec(table, write, buffer, lenp, ppos);
6781 : :
6782 : 0 : if (ret || !write || (last_ftrace_enabled == !!ftrace_enabled))
6783 : : goto out;
6784 : :
6785 : 0 : last_ftrace_enabled = !!ftrace_enabled;
6786 : :
6787 : 0 : if (ftrace_enabled) {
6788 : :
6789 : : /* we are starting ftrace again */
6790 : 0 : if (rcu_dereference_protected(ftrace_ops_list,
6791 : : lockdep_is_held(&ftrace_lock)) != &ftrace_list_end)
6792 : 0 : update_ftrace_function();
6793 : :
6794 : 0 : ftrace_startup_sysctl();
6795 : :
6796 : : } else {
6797 : : /* stopping ftrace calls (just send to ftrace_stub) */
6798 : 0 : ftrace_trace_function = ftrace_stub;
6799 : :
6800 : 0 : ftrace_shutdown_sysctl();
6801 : : }
6802 : :
6803 : : out:
6804 : 0 : mutex_unlock(&ftrace_lock);
6805 : 0 : return ret;
6806 : : }
|
