Branch data Line data Source code
1 : : /*
2 : : * Infrastructure for profiling code inserted by 'gcc -pg'.
3 : : *
4 : : * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
5 : : * Copyright (C) 2004-2008 Ingo Molnar <mingo@redhat.com>
6 : : *
7 : : * Originally ported from the -rt patch by:
8 : : * Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com>
9 : : *
10 : : * Based on code in the latency_tracer, that is:
11 : : *
12 : : * Copyright (C) 2004-2006 Ingo Molnar
13 : : * Copyright (C) 2004 Nadia Yvette Chambers
14 : : */
15 : :
16 : : #include <linux/stop_machine.h>
17 : : #include <linux/clocksource.h>
18 : : #include <linux/kallsyms.h>
19 : : #include <linux/seq_file.h>
20 : : #include <linux/suspend.h>
21 : : #include <linux/debugfs.h>
22 : : #include <linux/hardirq.h>
23 : : #include <linux/kthread.h>
24 : : #include <linux/uaccess.h>
25 : : #include <linux/bsearch.h>
26 : : #include <linux/module.h>
27 : : #include <linux/ftrace.h>
28 : : #include <linux/sysctl.h>
29 : : #include <linux/slab.h>
30 : : #include <linux/ctype.h>
31 : : #include <linux/sort.h>
32 : : #include <linux/list.h>
33 : : #include <linux/hash.h>
34 : : #include <linux/rcupdate.h>
35 : :
36 : : #include <trace/events/sched.h>
37 : :
38 : : #include <asm/setup.h>
39 : :
40 : : #include "trace_output.h"
41 : : #include "trace_stat.h"
42 : :
43 : : #define FTRACE_WARN_ON(cond) \
44 : : ({ \
45 : : int ___r = cond; \
46 : : if (WARN_ON(___r)) \
47 : : ftrace_kill(); \
48 : : ___r; \
49 : : })
50 : :
51 : : #define FTRACE_WARN_ON_ONCE(cond) \
52 : : ({ \
53 : : int ___r = cond; \
54 : : if (WARN_ON_ONCE(___r)) \
55 : : ftrace_kill(); \
56 : : ___r; \
57 : : })
58 : :
59 : : /* hash bits for specific function selection */
60 : : #define FTRACE_HASH_BITS 7
61 : : #define FTRACE_FUNC_HASHSIZE (1 << FTRACE_HASH_BITS)
62 : : #define FTRACE_HASH_DEFAULT_BITS 10
63 : : #define FTRACE_HASH_MAX_BITS 12
64 : :
65 : : #define FL_GLOBAL_CONTROL_MASK (FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_CONTROL)
66 : :
67 : : #ifdef CONFIG_DYNAMIC_FTRACE
68 : : #define INIT_REGEX_LOCK(opsname) \
69 : : .regex_lock = __MUTEX_INITIALIZER(opsname.regex_lock),
70 : : #else
71 : : #define INIT_REGEX_LOCK(opsname)
72 : : #endif
73 : :
74 : : static struct ftrace_ops ftrace_list_end __read_mostly = {
75 : : .func = ftrace_stub,
76 : : .flags = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_STUB,
77 : : };
78 : :
79 : : /* ftrace_enabled is a method to turn ftrace on or off */
80 : : int ftrace_enabled __read_mostly;
81 : : static int last_ftrace_enabled;
82 : :
83 : : /* Quick disabling of function tracer. */
84 : : int function_trace_stop __read_mostly;
85 : :
86 : : /* Current function tracing op */
87 : : struct ftrace_ops *function_trace_op __read_mostly = &ftrace_list_end;
88 : :
89 : : /* List for set_ftrace_pid's pids. */
90 : : LIST_HEAD(ftrace_pids);
91 : : struct ftrace_pid {
92 : : struct list_head list;
93 : : struct pid *pid;
94 : : };
95 : :
96 : : /*
97 : : * ftrace_disabled is set when an anomaly is discovered.
98 : : * ftrace_disabled is much stronger than ftrace_enabled.
99 : : */
100 : : static int ftrace_disabled __read_mostly;
101 : :
102 : : static DEFINE_MUTEX(ftrace_lock);
103 : :
104 : : static struct ftrace_ops *ftrace_global_list __read_mostly = &ftrace_list_end;
105 : : static struct ftrace_ops *ftrace_control_list __read_mostly = &ftrace_list_end;
106 : : static struct ftrace_ops *ftrace_ops_list __read_mostly = &ftrace_list_end;
107 : : ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
108 : : ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub;
109 : : static struct ftrace_ops global_ops;
110 : : static struct ftrace_ops control_ops;
111 : :
112 : : #if ARCH_SUPPORTS_FTRACE_OPS
113 : : static void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
114 : : struct ftrace_ops *op, struct pt_regs *regs);
115 : : #else
116 : : /* See comment below, where ftrace_ops_list_func is defined */
117 : : static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip);
118 : : #define ftrace_ops_list_func ((ftrace_func_t)ftrace_ops_no_ops)
119 : : #endif
120 : :
121 : : /*
122 : : * Traverse the ftrace_global_list, invoking all entries. The reason that we
123 : : * can use rcu_dereference_raw_notrace() is that elements removed from this list
124 : : * are simply leaked, so there is no need to interact with a grace-period
125 : : * mechanism. The rcu_dereference_raw_notrace() calls are needed to handle
126 : : * concurrent insertions into the ftrace_global_list.
127 : : *
128 : : * Silly Alpha and silly pointer-speculation compiler optimizations!
129 : : */
130 : : #define do_for_each_ftrace_op(op, list) \
131 : : op = rcu_dereference_raw_notrace(list); \
132 : : do
133 : :
134 : : /*
135 : : * Optimized for just a single item in the list (as that is the normal case).
136 : : */
137 : : #define while_for_each_ftrace_op(op) \
138 : : while (likely(op = rcu_dereference_raw_notrace((op)->next)) && \
139 : : unlikely((op) != &ftrace_list_end))
140 : :
141 : : static inline void ftrace_ops_init(struct ftrace_ops *ops)
142 : : {
143 : : #ifdef CONFIG_DYNAMIC_FTRACE
144 [ # # ][ # # ]: 0 : if (!(ops->flags & FTRACE_OPS_FL_INITIALIZED)) {
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
145 : 0 : mutex_init(&ops->regex_lock);
146 : 0 : ops->flags |= FTRACE_OPS_FL_INITIALIZED;
147 : : }
148 : : #endif
149 : : }
150 : :
151 : : /**
152 : : * ftrace_nr_registered_ops - return number of ops registered
153 : : *
154 : : * Returns the number of ftrace_ops registered and tracing functions
155 : : */
156 : 0 : int ftrace_nr_registered_ops(void)
157 : : {
158 : : struct ftrace_ops *ops;
159 : : int cnt = 0;
160 : :
161 : 0 : mutex_lock(&ftrace_lock);
162 : :
163 [ # # ]: 0 : for (ops = ftrace_ops_list;
164 : 0 : ops != &ftrace_list_end; ops = ops->next)
165 : 0 : cnt++;
166 : :
167 : 0 : mutex_unlock(&ftrace_lock);
168 : :
169 : 0 : return cnt;
170 : : }
171 : :
172 : : static void
173 : 0 : ftrace_global_list_func(unsigned long ip, unsigned long parent_ip,
174 : : struct ftrace_ops *op, struct pt_regs *regs)
175 : : {
176 : : int bit;
177 : :
178 : : bit = trace_test_and_set_recursion(TRACE_GLOBAL_START, TRACE_GLOBAL_MAX);
179 [ # # ]: 0 : if (bit < 0)
180 : 0 : return;
181 : :
182 : 0 : do_for_each_ftrace_op(op, ftrace_global_list) {
183 : 0 : op->func(ip, parent_ip, op, regs);
184 [ # # ][ # # ]: 0 : } while_for_each_ftrace_op(op);
185 : :
186 : : trace_clear_recursion(bit);
187 : : }
188 : :
189 : 0 : static void ftrace_pid_func(unsigned long ip, unsigned long parent_ip,
190 : : struct ftrace_ops *op, struct pt_regs *regs)
191 : : {
192 [ # # ]: 0 : if (!test_tsk_trace_trace(current))
193 : 0 : return;
194 : :
195 : 0 : ftrace_pid_function(ip, parent_ip, op, regs);
196 : : }
197 : :
198 : : static void set_ftrace_pid_function(ftrace_func_t func)
199 : : {
200 : : /* do not set ftrace_pid_function to itself! */
201 [ # # ]: 0 : if (func != ftrace_pid_func)
202 : 0 : ftrace_pid_function = func;
203 : : }
204 : :
205 : : /**
206 : : * clear_ftrace_function - reset the ftrace function
207 : : *
208 : : * This NULLs the ftrace function and in essence stops
209 : : * tracing. There may be lag
210 : : */
211 : 0 : void clear_ftrace_function(void)
212 : : {
213 : 0 : ftrace_trace_function = ftrace_stub;
214 : 0 : ftrace_pid_function = ftrace_stub;
215 : 0 : }
216 : :
217 : 0 : static void control_ops_disable_all(struct ftrace_ops *ops)
218 : : {
219 : : int cpu;
220 : :
221 [ # # ]: 0 : for_each_possible_cpu(cpu)
222 : 0 : *per_cpu_ptr(ops->disabled, cpu) = 1;
223 : 0 : }
224 : :
225 : 0 : static int control_ops_alloc(struct ftrace_ops *ops)
226 : : {
227 : : int __percpu *disabled;
228 : :
229 : 0 : disabled = alloc_percpu(int);
230 [ # # ]: 0 : if (!disabled)
231 : : return -ENOMEM;
232 : :
233 : 0 : ops->disabled = disabled;
234 : 0 : control_ops_disable_all(ops);
235 : 0 : return 0;
236 : : }
237 : :
238 : : static void control_ops_free(struct ftrace_ops *ops)
239 : : {
240 : 0 : free_percpu(ops->disabled);
241 : : }
242 : :
243 : 0 : static void update_global_ops(void)
244 : : {
245 : : ftrace_func_t func;
246 : :
247 : : /*
248 : : * If there's only one function registered, then call that
249 : : * function directly. Otherwise, we need to iterate over the
250 : : * registered callers.
251 : : */
252 [ # # ][ # # ]: 0 : if (ftrace_global_list == &ftrace_list_end ||
253 : 0 : ftrace_global_list->next == &ftrace_list_end) {
254 : 0 : func = ftrace_global_list->func;
255 : : /*
256 : : * As we are calling the function directly.
257 : : * If it does not have recursion protection,
258 : : * the function_trace_op needs to be updated
259 : : * accordingly.
260 : : */
261 [ # # ]: 0 : if (ftrace_global_list->flags & FTRACE_OPS_FL_RECURSION_SAFE)
262 : 0 : global_ops.flags |= FTRACE_OPS_FL_RECURSION_SAFE;
263 : : else
264 : 0 : global_ops.flags &= ~FTRACE_OPS_FL_RECURSION_SAFE;
265 : : } else {
266 : : func = ftrace_global_list_func;
267 : : /* The list has its own recursion protection. */
268 : 0 : global_ops.flags |= FTRACE_OPS_FL_RECURSION_SAFE;
269 : : }
270 : :
271 : :
272 : : /* If we filter on pids, update to use the pid function */
273 [ # # ]: 0 : if (!list_empty(&ftrace_pids)) {
274 : : set_ftrace_pid_function(func);
275 : : func = ftrace_pid_func;
276 : : }
277 : :
278 : 0 : global_ops.func = func;
279 : 0 : }
280 : :
281 : 0 : static void update_ftrace_function(void)
282 : : {
283 : : ftrace_func_t func;
284 : :
285 : 0 : update_global_ops();
286 : :
287 : : /*
288 : : * If we are at the end of the list and this ops is
289 : : * recursion safe and not dynamic and the arch supports passing ops,
290 : : * then have the mcount trampoline call the function directly.
291 : : */
292 [ # # ]: 0 : if (ftrace_ops_list == &ftrace_list_end ||
293 : : (ftrace_ops_list->next == &ftrace_list_end &&
294 : : !(ftrace_ops_list->flags & FTRACE_OPS_FL_DYNAMIC) &&
295 : : (ftrace_ops_list->flags & FTRACE_OPS_FL_RECURSION_SAFE) &&
296 : : !FTRACE_FORCE_LIST_FUNC)) {
297 : : /* Set the ftrace_ops that the arch callback uses */
298 [ # # ]: 0 : if (ftrace_ops_list == &global_ops)
299 : 0 : function_trace_op = ftrace_global_list;
300 : : else
301 : 0 : function_trace_op = ftrace_ops_list;
302 : 0 : func = ftrace_ops_list->func;
303 : : } else {
304 : : /* Just use the default ftrace_ops */
305 : 0 : function_trace_op = &ftrace_list_end;
306 : : func = ftrace_ops_list_func;
307 : : }
308 : :
309 : 0 : ftrace_trace_function = func;
310 : 0 : }
311 : :
312 : : static void add_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
313 : : {
314 : 0 : ops->next = *list;
315 : : /*
316 : : * We are entering ops into the list but another
317 : : * CPU might be walking that list. We need to make sure
318 : : * the ops->next pointer is valid before another CPU sees
319 : : * the ops pointer included into the list.
320 : : */
321 : 0 : rcu_assign_pointer(*list, ops);
322 : : }
323 : :
324 : : static int remove_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
325 : : {
326 : : struct ftrace_ops **p;
327 : :
328 : : /*
329 : : * If we are removing the last function, then simply point
330 : : * to the ftrace_stub.
331 : : */
332 [ # # ][ # # ]: 0 : if (*list == ops && ops->next == &ftrace_list_end) {
[ # # ][ # # ]
[ # # ][ # # ]
333 : 0 : *list = &ftrace_list_end;
334 : : return 0;
335 : : }
336 : :
337 [ # # ][ # # ]: 0 : for (p = list; *p != &ftrace_list_end; p = &(*p)->next)
[ # # ]
338 [ # # ][ # # ]: 0 : if (*p == ops)
[ # # ]
339 : : break;
340 : :
341 [ # # ][ # # ]: 0 : if (*p != ops)
[ # # ]
342 : : return -1;
343 : :
344 : 0 : *p = (*p)->next;
345 : : return 0;
346 : : }
347 : :
348 : : static void add_ftrace_list_ops(struct ftrace_ops **list,
349 : : struct ftrace_ops *main_ops,
350 : : struct ftrace_ops *ops)
351 : : {
352 : 0 : int first = *list == &ftrace_list_end;
353 : : add_ftrace_ops(list, ops);
354 [ # # # # ]: 0 : if (first)
355 : : add_ftrace_ops(&ftrace_ops_list, main_ops);
356 : : }
357 : :
358 : 0 : static int remove_ftrace_list_ops(struct ftrace_ops **list,
359 : : struct ftrace_ops *main_ops,
360 : : struct ftrace_ops *ops)
361 : : {
362 : : int ret = remove_ftrace_ops(list, ops);
363 [ # # ][ # # ]: 0 : if (!ret && *list == &ftrace_list_end)
364 : : ret = remove_ftrace_ops(&ftrace_ops_list, main_ops);
365 : 0 : return ret;
366 : : }
367 : :
368 : 0 : static int __register_ftrace_function(struct ftrace_ops *ops)
369 : : {
370 [ # # ][ # # ]: 0 : if (FTRACE_WARN_ON(ops == &global_ops))
[ # # ]
371 : : return -EINVAL;
372 : :
373 [ # # ][ # # ]: 0 : if (WARN_ON(ops->flags & FTRACE_OPS_FL_ENABLED))
374 : : return -EBUSY;
375 : :
376 : : /* We don't support both control and global flags set. */
377 [ # # ]: 0 : if ((ops->flags & FL_GLOBAL_CONTROL_MASK) == FL_GLOBAL_CONTROL_MASK)
378 : : return -EINVAL;
379 : :
380 : : #ifndef CONFIG_DYNAMIC_FTRACE_WITH_REGS
381 : : /*
382 : : * If the ftrace_ops specifies SAVE_REGS, then it only can be used
383 : : * if the arch supports it, or SAVE_REGS_IF_SUPPORTED is also set.
384 : : * Setting SAVE_REGS_IF_SUPPORTED makes SAVE_REGS irrelevant.
385 : : */
386 [ # # ]: 0 : if (ops->flags & FTRACE_OPS_FL_SAVE_REGS &&
387 : : !(ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED))
388 : : return -EINVAL;
389 : :
390 [ # # ]: 0 : if (ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED)
391 : 0 : ops->flags |= FTRACE_OPS_FL_SAVE_REGS;
392 : : #endif
393 : :
394 [ # # ]: 0 : if (!core_kernel_data((unsigned long)ops))
395 : 0 : ops->flags |= FTRACE_OPS_FL_DYNAMIC;
396 : :
397 [ # # ]: 0 : if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
398 : : add_ftrace_list_ops(&ftrace_global_list, &global_ops, ops);
399 : 0 : ops->flags |= FTRACE_OPS_FL_ENABLED;
400 [ # # ]: 0 : } else if (ops->flags & FTRACE_OPS_FL_CONTROL) {
401 [ # # ]: 0 : if (control_ops_alloc(ops))
402 : : return -ENOMEM;
403 : : add_ftrace_list_ops(&ftrace_control_list, &control_ops, ops);
404 : : } else
405 : : add_ftrace_ops(&ftrace_ops_list, ops);
406 : :
407 [ # # ]: 0 : if (ftrace_enabled)
408 : 0 : update_ftrace_function();
409 : :
410 : : return 0;
411 : : }
412 : :
413 : 0 : static void ftrace_sync(struct work_struct *work)
414 : : {
415 : : /*
416 : : * This function is just a stub to implement a hard force
417 : : * of synchronize_sched(). This requires synchronizing
418 : : * tasks even in userspace and idle.
419 : : *
420 : : * Yes, function tracing is rude.
421 : : */
422 : 0 : }
423 : :
424 : 0 : static int __unregister_ftrace_function(struct ftrace_ops *ops)
425 : : {
426 : : int ret;
427 : :
428 [ # # ][ # # ]: 0 : if (WARN_ON(!(ops->flags & FTRACE_OPS_FL_ENABLED)))
429 : : return -EBUSY;
430 : :
431 [ # # ][ # # ]: 0 : if (FTRACE_WARN_ON(ops == &global_ops))
[ # # ]
432 : : return -EINVAL;
433 : :
434 [ # # ]: 0 : if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
435 : 0 : ret = remove_ftrace_list_ops(&ftrace_global_list,
436 : : &global_ops, ops);
437 [ # # ]: 0 : if (!ret)
438 : 0 : ops->flags &= ~FTRACE_OPS_FL_ENABLED;
439 [ # # ]: 0 : } else if (ops->flags & FTRACE_OPS_FL_CONTROL) {
440 : 0 : ret = remove_ftrace_list_ops(&ftrace_control_list,
441 : : &control_ops, ops);
442 [ # # ]: 0 : if (!ret) {
443 : : /*
444 : : * The ftrace_ops is now removed from the list,
445 : : * so there'll be no new users. We must ensure
446 : : * all current users are done before we free
447 : : * the control data.
448 : : * Note synchronize_sched() is not enough, as we
449 : : * use preempt_disable() to do RCU, but the function
450 : : * tracer can be called where RCU is not active
451 : : * (before user_exit()).
452 : : */
453 : 0 : schedule_on_each_cpu(ftrace_sync);
454 : : control_ops_free(ops);
455 : : }
456 : : } else
457 : : ret = remove_ftrace_ops(&ftrace_ops_list, ops);
458 : :
459 [ # # ]: 0 : if (ret < 0)
460 : : return ret;
461 : :
462 [ # # ]: 0 : if (ftrace_enabled)
463 : 0 : update_ftrace_function();
464 : :
465 : : /*
466 : : * Dynamic ops may be freed, we must make sure that all
467 : : * callers are done before leaving this function.
468 : : *
469 : : * Again, normal synchronize_sched() is not good enough.
470 : : * We need to do a hard force of sched synchronization.
471 : : */
472 [ # # ]: 0 : if (ops->flags & FTRACE_OPS_FL_DYNAMIC)
473 : 0 : schedule_on_each_cpu(ftrace_sync);
474 : :
475 : :
476 : : return 0;
477 : : }
478 : :
479 : : static void ftrace_update_pid_func(void)
480 : : {
481 : : /* Only do something if we are tracing something */
482 [ # # ][ # # ]: 0 : if (ftrace_trace_function == ftrace_stub)
483 : : return;
484 : :
485 : 0 : update_ftrace_function();
486 : : }
487 : :
488 : : #ifdef CONFIG_FUNCTION_PROFILER
489 : : struct ftrace_profile {
490 : : struct hlist_node node;
491 : : unsigned long ip;
492 : : unsigned long counter;
493 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
494 : : unsigned long long time;
495 : : unsigned long long time_squared;
496 : : #endif
497 : : };
498 : :
499 : : struct ftrace_profile_page {
500 : : struct ftrace_profile_page *next;
501 : : unsigned long index;
502 : : struct ftrace_profile records[];
503 : : };
504 : :
505 : : struct ftrace_profile_stat {
506 : : atomic_t disabled;
507 : : struct hlist_head *hash;
508 : : struct ftrace_profile_page *pages;
509 : : struct ftrace_profile_page *start;
510 : : struct tracer_stat stat;
511 : : };
512 : :
513 : : #define PROFILE_RECORDS_SIZE \
514 : : (PAGE_SIZE - offsetof(struct ftrace_profile_page, records))
515 : :
516 : : #define PROFILES_PER_PAGE \
517 : : (PROFILE_RECORDS_SIZE / sizeof(struct ftrace_profile))
518 : :
519 : : static int ftrace_profile_enabled __read_mostly;
520 : :
521 : : /* ftrace_profile_lock - synchronize the enable and disable of the profiler */
522 : : static DEFINE_MUTEX(ftrace_profile_lock);
523 : :
524 : : static DEFINE_PER_CPU(struct ftrace_profile_stat, ftrace_profile_stats);
525 : :
526 : : #define FTRACE_PROFILE_HASH_BITS 10
527 : : #define FTRACE_PROFILE_HASH_SIZE (1 << FTRACE_PROFILE_HASH_BITS)
528 : :
529 : : static void *
530 : : function_stat_next(void *v, int idx)
531 : : {
532 : : struct ftrace_profile *rec = v;
533 : : struct ftrace_profile_page *pg;
534 : :
535 : : pg = (struct ftrace_profile_page *)((unsigned long)rec & PAGE_MASK);
536 : :
537 : : again:
538 : : if (idx != 0)
539 : : rec++;
540 : :
541 : : if ((void *)rec >= (void *)&pg->records[pg->index]) {
542 : : pg = pg->next;
543 : : if (!pg)
544 : : return NULL;
545 : : rec = &pg->records[0];
546 : : if (!rec->counter)
547 : : goto again;
548 : : }
549 : :
550 : : return rec;
551 : : }
552 : :
553 : : static void *function_stat_start(struct tracer_stat *trace)
554 : : {
555 : : struct ftrace_profile_stat *stat =
556 : : container_of(trace, struct ftrace_profile_stat, stat);
557 : :
558 : : if (!stat || !stat->start)
559 : : return NULL;
560 : :
561 : : return function_stat_next(&stat->start->records[0], 0);
562 : : }
563 : :
564 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
565 : : /* function graph compares on total time */
566 : : static int function_stat_cmp(void *p1, void *p2)
567 : : {
568 : : struct ftrace_profile *a = p1;
569 : : struct ftrace_profile *b = p2;
570 : :
571 : : if (a->time < b->time)
572 : : return -1;
573 : : if (a->time > b->time)
574 : : return 1;
575 : : else
576 : : return 0;
577 : : }
578 : : #else
579 : : /* not function graph compares against hits */
580 : : static int function_stat_cmp(void *p1, void *p2)
581 : : {
582 : : struct ftrace_profile *a = p1;
583 : : struct ftrace_profile *b = p2;
584 : :
585 : : if (a->counter < b->counter)
586 : : return -1;
587 : : if (a->counter > b->counter)
588 : : return 1;
589 : : else
590 : : return 0;
591 : : }
592 : : #endif
593 : :
594 : : static int function_stat_headers(struct seq_file *m)
595 : : {
596 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
597 : : seq_printf(m, " Function "
598 : : "Hit Time Avg s^2\n"
599 : : " -------- "
600 : : "--- ---- --- ---\n");
601 : : #else
602 : : seq_printf(m, " Function Hit\n"
603 : : " -------- ---\n");
604 : : #endif
605 : : return 0;
606 : : }
607 : :
608 : : static int function_stat_show(struct seq_file *m, void *v)
609 : : {
610 : : struct ftrace_profile *rec = v;
611 : : char str[KSYM_SYMBOL_LEN];
612 : : int ret = 0;
613 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
614 : : static struct trace_seq s;
615 : : unsigned long long avg;
616 : : unsigned long long stddev;
617 : : #endif
618 : : mutex_lock(&ftrace_profile_lock);
619 : :
620 : : /* we raced with function_profile_reset() */
621 : : if (unlikely(rec->counter == 0)) {
622 : : ret = -EBUSY;
623 : : goto out;
624 : : }
625 : :
626 : : kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
627 : : seq_printf(m, " %-30.30s %10lu", str, rec->counter);
628 : :
629 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
630 : : seq_printf(m, " ");
631 : : avg = rec->time;
632 : : do_div(avg, rec->counter);
633 : :
634 : : /* Sample standard deviation (s^2) */
635 : : if (rec->counter <= 1)
636 : : stddev = 0;
637 : : else {
638 : : /*
639 : : * Apply Welford's method:
640 : : * s^2 = 1 / (n * (n-1)) * (n * \Sum (x_i)^2 - (\Sum x_i)^2)
641 : : */
642 : : stddev = rec->counter * rec->time_squared -
643 : : rec->time * rec->time;
644 : :
645 : : /*
646 : : * Divide only 1000 for ns^2 -> us^2 conversion.
647 : : * trace_print_graph_duration will divide 1000 again.
648 : : */
649 : : do_div(stddev, rec->counter * (rec->counter - 1) * 1000);
650 : : }
651 : :
652 : : trace_seq_init(&s);
653 : : trace_print_graph_duration(rec->time, &s);
654 : : trace_seq_puts(&s, " ");
655 : : trace_print_graph_duration(avg, &s);
656 : : trace_seq_puts(&s, " ");
657 : : trace_print_graph_duration(stddev, &s);
658 : : trace_print_seq(m, &s);
659 : : #endif
660 : : seq_putc(m, '\n');
661 : : out:
662 : : mutex_unlock(&ftrace_profile_lock);
663 : :
664 : : return ret;
665 : : }
666 : :
667 : : static void ftrace_profile_reset(struct ftrace_profile_stat *stat)
668 : : {
669 : : struct ftrace_profile_page *pg;
670 : :
671 : : pg = stat->pages = stat->start;
672 : :
673 : : while (pg) {
674 : : memset(pg->records, 0, PROFILE_RECORDS_SIZE);
675 : : pg->index = 0;
676 : : pg = pg->next;
677 : : }
678 : :
679 : : memset(stat->hash, 0,
680 : : FTRACE_PROFILE_HASH_SIZE * sizeof(struct hlist_head));
681 : : }
682 : :
683 : : int ftrace_profile_pages_init(struct ftrace_profile_stat *stat)
684 : : {
685 : : struct ftrace_profile_page *pg;
686 : : int functions;
687 : : int pages;
688 : : int i;
689 : :
690 : : /* If we already allocated, do nothing */
691 : : if (stat->pages)
692 : : return 0;
693 : :
694 : : stat->pages = (void *)get_zeroed_page(GFP_KERNEL);
695 : : if (!stat->pages)
696 : : return -ENOMEM;
697 : :
698 : : #ifdef CONFIG_DYNAMIC_FTRACE
699 : : functions = ftrace_update_tot_cnt;
700 : : #else
701 : : /*
702 : : * We do not know the number of functions that exist because
703 : : * dynamic tracing is what counts them. With past experience
704 : : * we have around 20K functions. That should be more than enough.
705 : : * It is highly unlikely we will execute every function in
706 : : * the kernel.
707 : : */
708 : : functions = 20000;
709 : : #endif
710 : :
711 : : pg = stat->start = stat->pages;
712 : :
713 : : pages = DIV_ROUND_UP(functions, PROFILES_PER_PAGE);
714 : :
715 : : for (i = 1; i < pages; i++) {
716 : : pg->next = (void *)get_zeroed_page(GFP_KERNEL);
717 : : if (!pg->next)
718 : : goto out_free;
719 : : pg = pg->next;
720 : : }
721 : :
722 : : return 0;
723 : :
724 : : out_free:
725 : : pg = stat->start;
726 : : while (pg) {
727 : : unsigned long tmp = (unsigned long)pg;
728 : :
729 : : pg = pg->next;
730 : : free_page(tmp);
731 : : }
732 : :
733 : : stat->pages = NULL;
734 : : stat->start = NULL;
735 : :
736 : : return -ENOMEM;
737 : : }
738 : :
739 : : static int ftrace_profile_init_cpu(int cpu)
740 : : {
741 : : struct ftrace_profile_stat *stat;
742 : : int size;
743 : :
744 : : stat = &per_cpu(ftrace_profile_stats, cpu);
745 : :
746 : : if (stat->hash) {
747 : : /* If the profile is already created, simply reset it */
748 : : ftrace_profile_reset(stat);
749 : : return 0;
750 : : }
751 : :
752 : : /*
753 : : * We are profiling all functions, but usually only a few thousand
754 : : * functions are hit. We'll make a hash of 1024 items.
755 : : */
756 : : size = FTRACE_PROFILE_HASH_SIZE;
757 : :
758 : : stat->hash = kzalloc(sizeof(struct hlist_head) * size, GFP_KERNEL);
759 : :
760 : : if (!stat->hash)
761 : : return -ENOMEM;
762 : :
763 : : /* Preallocate the function profiling pages */
764 : : if (ftrace_profile_pages_init(stat) < 0) {
765 : : kfree(stat->hash);
766 : : stat->hash = NULL;
767 : : return -ENOMEM;
768 : : }
769 : :
770 : : return 0;
771 : : }
772 : :
773 : : static int ftrace_profile_init(void)
774 : : {
775 : : int cpu;
776 : : int ret = 0;
777 : :
778 : : for_each_possible_cpu(cpu) {
779 : : ret = ftrace_profile_init_cpu(cpu);
780 : : if (ret)
781 : : break;
782 : : }
783 : :
784 : : return ret;
785 : : }
786 : :
787 : : /* interrupts must be disabled */
788 : : static struct ftrace_profile *
789 : : ftrace_find_profiled_func(struct ftrace_profile_stat *stat, unsigned long ip)
790 : : {
791 : : struct ftrace_profile *rec;
792 : : struct hlist_head *hhd;
793 : : unsigned long key;
794 : :
795 : : key = hash_long(ip, FTRACE_PROFILE_HASH_BITS);
796 : : hhd = &stat->hash[key];
797 : :
798 : : if (hlist_empty(hhd))
799 : : return NULL;
800 : :
801 : : hlist_for_each_entry_rcu_notrace(rec, hhd, node) {
802 : : if (rec->ip == ip)
803 : : return rec;
804 : : }
805 : :
806 : : return NULL;
807 : : }
808 : :
809 : : static void ftrace_add_profile(struct ftrace_profile_stat *stat,
810 : : struct ftrace_profile *rec)
811 : : {
812 : : unsigned long key;
813 : :
814 : : key = hash_long(rec->ip, FTRACE_PROFILE_HASH_BITS);
815 : : hlist_add_head_rcu(&rec->node, &stat->hash[key]);
816 : : }
817 : :
818 : : /*
819 : : * The memory is already allocated, this simply finds a new record to use.
820 : : */
821 : : static struct ftrace_profile *
822 : : ftrace_profile_alloc(struct ftrace_profile_stat *stat, unsigned long ip)
823 : : {
824 : : struct ftrace_profile *rec = NULL;
825 : :
826 : : /* prevent recursion (from NMIs) */
827 : : if (atomic_inc_return(&stat->disabled) != 1)
828 : : goto out;
829 : :
830 : : /*
831 : : * Try to find the function again since an NMI
832 : : * could have added it
833 : : */
834 : : rec = ftrace_find_profiled_func(stat, ip);
835 : : if (rec)
836 : : goto out;
837 : :
838 : : if (stat->pages->index == PROFILES_PER_PAGE) {
839 : : if (!stat->pages->next)
840 : : goto out;
841 : : stat->pages = stat->pages->next;
842 : : }
843 : :
844 : : rec = &stat->pages->records[stat->pages->index++];
845 : : rec->ip = ip;
846 : : ftrace_add_profile(stat, rec);
847 : :
848 : : out:
849 : : atomic_dec(&stat->disabled);
850 : :
851 : : return rec;
852 : : }
853 : :
854 : : static void
855 : : function_profile_call(unsigned long ip, unsigned long parent_ip,
856 : : struct ftrace_ops *ops, struct pt_regs *regs)
857 : : {
858 : : struct ftrace_profile_stat *stat;
859 : : struct ftrace_profile *rec;
860 : : unsigned long flags;
861 : :
862 : : if (!ftrace_profile_enabled)
863 : : return;
864 : :
865 : : local_irq_save(flags);
866 : :
867 : : stat = &__get_cpu_var(ftrace_profile_stats);
868 : : if (!stat->hash || !ftrace_profile_enabled)
869 : : goto out;
870 : :
871 : : rec = ftrace_find_profiled_func(stat, ip);
872 : : if (!rec) {
873 : : rec = ftrace_profile_alloc(stat, ip);
874 : : if (!rec)
875 : : goto out;
876 : : }
877 : :
878 : : rec->counter++;
879 : : out:
880 : : local_irq_restore(flags);
881 : : }
882 : :
883 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
884 : : static int profile_graph_entry(struct ftrace_graph_ent *trace)
885 : : {
886 : : function_profile_call(trace->func, 0, NULL, NULL);
887 : : return 1;
888 : : }
889 : :
890 : : static void profile_graph_return(struct ftrace_graph_ret *trace)
891 : : {
892 : : struct ftrace_profile_stat *stat;
893 : : unsigned long long calltime;
894 : : struct ftrace_profile *rec;
895 : : unsigned long flags;
896 : :
897 : : local_irq_save(flags);
898 : : stat = &__get_cpu_var(ftrace_profile_stats);
899 : : if (!stat->hash || !ftrace_profile_enabled)
900 : : goto out;
901 : :
902 : : /* If the calltime was zero'd ignore it */
903 : : if (!trace->calltime)
904 : : goto out;
905 : :
906 : : calltime = trace->rettime - trace->calltime;
907 : :
908 : : if (!(trace_flags & TRACE_ITER_GRAPH_TIME)) {
909 : : int index;
910 : :
911 : : index = trace->depth;
912 : :
913 : : /* Append this call time to the parent time to subtract */
914 : : if (index)
915 : : current->ret_stack[index - 1].subtime += calltime;
916 : :
917 : : if (current->ret_stack[index].subtime < calltime)
918 : : calltime -= current->ret_stack[index].subtime;
919 : : else
920 : : calltime = 0;
921 : : }
922 : :
923 : : rec = ftrace_find_profiled_func(stat, trace->func);
924 : : if (rec) {
925 : : rec->time += calltime;
926 : : rec->time_squared += calltime * calltime;
927 : : }
928 : :
929 : : out:
930 : : local_irq_restore(flags);
931 : : }
932 : :
933 : : static int register_ftrace_profiler(void)
934 : : {
935 : : return register_ftrace_graph(&profile_graph_return,
936 : : &profile_graph_entry);
937 : : }
938 : :
939 : : static void unregister_ftrace_profiler(void)
940 : : {
941 : : unregister_ftrace_graph();
942 : : }
943 : : #else
944 : : static struct ftrace_ops ftrace_profile_ops __read_mostly = {
945 : : .func = function_profile_call,
946 : : .flags = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,
947 : : INIT_REGEX_LOCK(ftrace_profile_ops)
948 : : };
949 : :
950 : : static int register_ftrace_profiler(void)
951 : : {
952 : : return register_ftrace_function(&ftrace_profile_ops);
953 : : }
954 : :
955 : : static void unregister_ftrace_profiler(void)
956 : : {
957 : : unregister_ftrace_function(&ftrace_profile_ops);
958 : : }
959 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
960 : :
961 : : static ssize_t
962 : : ftrace_profile_write(struct file *filp, const char __user *ubuf,
963 : : size_t cnt, loff_t *ppos)
964 : : {
965 : : unsigned long val;
966 : : int ret;
967 : :
968 : : ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
969 : : if (ret)
970 : : return ret;
971 : :
972 : : val = !!val;
973 : :
974 : : mutex_lock(&ftrace_profile_lock);
975 : : if (ftrace_profile_enabled ^ val) {
976 : : if (val) {
977 : : ret = ftrace_profile_init();
978 : : if (ret < 0) {
979 : : cnt = ret;
980 : : goto out;
981 : : }
982 : :
983 : : ret = register_ftrace_profiler();
984 : : if (ret < 0) {
985 : : cnt = ret;
986 : : goto out;
987 : : }
988 : : ftrace_profile_enabled = 1;
989 : : } else {
990 : : ftrace_profile_enabled = 0;
991 : : /*
992 : : * unregister_ftrace_profiler calls stop_machine
993 : : * so this acts like an synchronize_sched.
994 : : */
995 : : unregister_ftrace_profiler();
996 : : }
997 : : }
998 : : out:
999 : : mutex_unlock(&ftrace_profile_lock);
1000 : :
1001 : : *ppos += cnt;
1002 : :
1003 : : return cnt;
1004 : : }
1005 : :
1006 : : static ssize_t
1007 : : ftrace_profile_read(struct file *filp, char __user *ubuf,
1008 : : size_t cnt, loff_t *ppos)
1009 : : {
1010 : : char buf[64]; /* big enough to hold a number */
1011 : : int r;
1012 : :
1013 : : r = sprintf(buf, "%u\n", ftrace_profile_enabled);
1014 : : return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
1015 : : }
1016 : :
1017 : : static const struct file_operations ftrace_profile_fops = {
1018 : : .open = tracing_open_generic,
1019 : : .read = ftrace_profile_read,
1020 : : .write = ftrace_profile_write,
1021 : : .llseek = default_llseek,
1022 : : };
1023 : :
1024 : : /* used to initialize the real stat files */
1025 : : static struct tracer_stat function_stats __initdata = {
1026 : : .name = "functions",
1027 : : .stat_start = function_stat_start,
1028 : : .stat_next = function_stat_next,
1029 : : .stat_cmp = function_stat_cmp,
1030 : : .stat_headers = function_stat_headers,
1031 : : .stat_show = function_stat_show
1032 : : };
1033 : :
1034 : : static __init void ftrace_profile_debugfs(struct dentry *d_tracer)
1035 : : {
1036 : : struct ftrace_profile_stat *stat;
1037 : : struct dentry *entry;
1038 : : char *name;
1039 : : int ret;
1040 : : int cpu;
1041 : :
1042 : : for_each_possible_cpu(cpu) {
1043 : : stat = &per_cpu(ftrace_profile_stats, cpu);
1044 : :
1045 : : /* allocate enough for function name + cpu number */
1046 : : name = kmalloc(32, GFP_KERNEL);
1047 : : if (!name) {
1048 : : /*
1049 : : * The files created are permanent, if something happens
1050 : : * we still do not free memory.
1051 : : */
1052 : : WARN(1,
1053 : : "Could not allocate stat file for cpu %d\n",
1054 : : cpu);
1055 : : return;
1056 : : }
1057 : : stat->stat = function_stats;
1058 : : snprintf(name, 32, "function%d", cpu);
1059 : : stat->stat.name = name;
1060 : : ret = register_stat_tracer(&stat->stat);
1061 : : if (ret) {
1062 : : WARN(1,
1063 : : "Could not register function stat for cpu %d\n",
1064 : : cpu);
1065 : : kfree(name);
1066 : : return;
1067 : : }
1068 : : }
1069 : :
1070 : : entry = debugfs_create_file("function_profile_enabled", 0644,
1071 : : d_tracer, NULL, &ftrace_profile_fops);
1072 : : if (!entry)
1073 : : pr_warning("Could not create debugfs "
1074 : : "'function_profile_enabled' entry\n");
1075 : : }
1076 : :
1077 : : #else /* CONFIG_FUNCTION_PROFILER */
1078 : : static __init void ftrace_profile_debugfs(struct dentry *d_tracer)
1079 : : {
1080 : : }
1081 : : #endif /* CONFIG_FUNCTION_PROFILER */
1082 : :
1083 : : static struct pid * const ftrace_swapper_pid = &init_struct_pid;
1084 : :
1085 : : loff_t
1086 : 0 : ftrace_filter_lseek(struct file *file, loff_t offset, int whence)
1087 : : {
1088 : : loff_t ret;
1089 : :
1090 [ # # ]: 0 : if (file->f_mode & FMODE_READ)
1091 : 0 : ret = seq_lseek(file, offset, whence);
1092 : : else
1093 : 0 : file->f_pos = ret = 1;
1094 : :
1095 : 0 : return ret;
1096 : : }
1097 : :
1098 : : #ifdef CONFIG_DYNAMIC_FTRACE
1099 : :
1100 : : #ifndef CONFIG_FTRACE_MCOUNT_RECORD
1101 : : # error Dynamic ftrace depends on MCOUNT_RECORD
1102 : : #endif
1103 : :
1104 : : static struct hlist_head ftrace_func_hash[FTRACE_FUNC_HASHSIZE] __read_mostly;
1105 : :
1106 : : struct ftrace_func_probe {
1107 : : struct hlist_node node;
1108 : : struct ftrace_probe_ops *ops;
1109 : : unsigned long flags;
1110 : : unsigned long ip;
1111 : : void *data;
1112 : : struct list_head free_list;
1113 : : };
1114 : :
1115 : : struct ftrace_func_entry {
1116 : : struct hlist_node hlist;
1117 : : unsigned long ip;
1118 : : };
1119 : :
1120 : : struct ftrace_hash {
1121 : : unsigned long size_bits;
1122 : : struct hlist_head *buckets;
1123 : : unsigned long count;
1124 : : struct rcu_head rcu;
1125 : : };
1126 : :
1127 : : /*
1128 : : * We make these constant because no one should touch them,
1129 : : * but they are used as the default "empty hash", to avoid allocating
1130 : : * it all the time. These are in a read only section such that if
1131 : : * anyone does try to modify it, it will cause an exception.
1132 : : */
1133 : : static const struct hlist_head empty_buckets[1];
1134 : : static const struct ftrace_hash empty_hash = {
1135 : : .buckets = (struct hlist_head *)empty_buckets,
1136 : : };
1137 : : #define EMPTY_HASH ((struct ftrace_hash *)&empty_hash)
1138 : :
1139 : : static struct ftrace_ops global_ops = {
1140 : : .func = ftrace_stub,
1141 : : .notrace_hash = EMPTY_HASH,
1142 : : .filter_hash = EMPTY_HASH,
1143 : : .flags = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,
1144 : : INIT_REGEX_LOCK(global_ops)
1145 : : };
1146 : :
1147 : : struct ftrace_page {
1148 : : struct ftrace_page *next;
1149 : : struct dyn_ftrace *records;
1150 : : int index;
1151 : : int size;
1152 : : };
1153 : :
1154 : : static struct ftrace_page *ftrace_new_pgs;
1155 : :
1156 : : #define ENTRY_SIZE sizeof(struct dyn_ftrace)
1157 : : #define ENTRIES_PER_PAGE (PAGE_SIZE / ENTRY_SIZE)
1158 : :
1159 : : /* estimate from running different kernels */
1160 : : #define NR_TO_INIT 10000
1161 : :
1162 : : static struct ftrace_page *ftrace_pages_start;
1163 : : static struct ftrace_page *ftrace_pages;
1164 : :
1165 : 0 : static bool ftrace_hash_empty(struct ftrace_hash *hash)
1166 : : {
1167 [ # # ][ # # ]: 0 : return !hash || !hash->count;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1168 : : }
1169 : :
1170 : : static struct ftrace_func_entry *
1171 : 0 : ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip)
1172 : : {
1173 : : unsigned long key;
1174 : : struct ftrace_func_entry *entry;
1175 : : struct hlist_head *hhd;
1176 : :
1177 [ # # ]: 0 : if (ftrace_hash_empty(hash))
1178 : : return NULL;
1179 : :
1180 [ # # ]: 0 : if (hash->size_bits > 0)
1181 : : key = hash_long(ip, hash->size_bits);
1182 : : else
1183 : : key = 0;
1184 : :
1185 : 0 : hhd = &hash->buckets[key];
1186 : :
1187 [ # # ][ # # ]: 0 : hlist_for_each_entry_rcu_notrace(entry, hhd, hlist) {
[ # # ]
1188 [ # # ]: 0 : if (entry->ip == ip)
1189 : : return entry;
1190 : : }
1191 : : return NULL;
1192 : : }
1193 : :
1194 : 0 : static void __add_hash_entry(struct ftrace_hash *hash,
1195 : : struct ftrace_func_entry *entry)
1196 : : {
1197 : : struct hlist_head *hhd;
1198 : : unsigned long key;
1199 : :
1200 [ # # ]: 0 : if (hash->size_bits)
1201 : 0 : key = hash_long(entry->ip, hash->size_bits);
1202 : : else
1203 : : key = 0;
1204 : :
1205 : 0 : hhd = &hash->buckets[key];
1206 : 0 : hlist_add_head(&entry->hlist, hhd);
1207 : 0 : hash->count++;
1208 : 0 : }
1209 : :
1210 : 0 : static int add_hash_entry(struct ftrace_hash *hash, unsigned long ip)
1211 : : {
1212 : : struct ftrace_func_entry *entry;
1213 : :
1214 : : entry = kmalloc(sizeof(*entry), GFP_KERNEL);
1215 [ # # ]: 0 : if (!entry)
1216 : : return -ENOMEM;
1217 : :
1218 : 0 : entry->ip = ip;
1219 : 0 : __add_hash_entry(hash, entry);
1220 : :
1221 : 0 : return 0;
1222 : : }
1223 : :
1224 : : static void
1225 : 0 : free_hash_entry(struct ftrace_hash *hash,
1226 : : struct ftrace_func_entry *entry)
1227 : : {
1228 : : hlist_del(&entry->hlist);
1229 : 0 : kfree(entry);
1230 : 0 : hash->count--;
1231 : 0 : }
1232 : :
1233 : : static void
1234 : : remove_hash_entry(struct ftrace_hash *hash,
1235 : : struct ftrace_func_entry *entry)
1236 : : {
1237 : : hlist_del(&entry->hlist);
1238 : 0 : hash->count--;
1239 : : }
1240 : :
1241 : 0 : static void ftrace_hash_clear(struct ftrace_hash *hash)
1242 : : {
1243 : : struct hlist_head *hhd;
1244 : : struct hlist_node *tn;
1245 : : struct ftrace_func_entry *entry;
1246 : 0 : int size = 1 << hash->size_bits;
1247 : : int i;
1248 : :
1249 [ # # ]: 0 : if (!hash->count)
1250 : 0 : return;
1251 : :
1252 [ # # ]: 0 : for (i = 0; i < size; i++) {
1253 : 0 : hhd = &hash->buckets[i];
1254 [ # # ]: 0 : hlist_for_each_entry_safe(entry, tn, hhd, hlist)
[ # # # # ]
1255 : 0 : free_hash_entry(hash, entry);
1256 : : }
1257 [ # # ][ # # ]: 0 : FTRACE_WARN_ON(hash->count);
1258 : : }
1259 : :
1260 : 0 : static void free_ftrace_hash(struct ftrace_hash *hash)
1261 : : {
1262 [ # # ][ # # ]: 0 : if (!hash || hash == EMPTY_HASH)
1263 : 0 : return;
1264 : 0 : ftrace_hash_clear(hash);
1265 : 0 : kfree(hash->buckets);
1266 : 0 : kfree(hash);
1267 : : }
1268 : :
1269 : 0 : static void __free_ftrace_hash_rcu(struct rcu_head *rcu)
1270 : : {
1271 : : struct ftrace_hash *hash;
1272 : :
1273 : 0 : hash = container_of(rcu, struct ftrace_hash, rcu);
1274 : 0 : free_ftrace_hash(hash);
1275 : 0 : }
1276 : :
1277 : : static void free_ftrace_hash_rcu(struct ftrace_hash *hash)
1278 : : {
1279 [ # # ]: 0 : if (!hash || hash == EMPTY_HASH)
[ # # # # ]
[ # # ]
1280 : : return;
1281 : 0 : call_rcu_sched(&hash->rcu, __free_ftrace_hash_rcu);
1282 : : }
1283 : :
1284 : 0 : void ftrace_free_filter(struct ftrace_ops *ops)
1285 : : {
1286 : : ftrace_ops_init(ops);
1287 : 0 : free_ftrace_hash(ops->filter_hash);
1288 : 0 : free_ftrace_hash(ops->notrace_hash);
1289 : 0 : }
1290 : :
1291 : 0 : static struct ftrace_hash *alloc_ftrace_hash(int size_bits)
1292 : : {
1293 : : struct ftrace_hash *hash;
1294 : : int size;
1295 : :
1296 : : hash = kzalloc(sizeof(*hash), GFP_KERNEL);
1297 [ # # ]: 0 : if (!hash)
1298 : : return NULL;
1299 : :
1300 : 0 : size = 1 << size_bits;
1301 : 0 : hash->buckets = kcalloc(size, sizeof(*hash->buckets), GFP_KERNEL);
1302 : :
1303 [ # # ]: 0 : if (!hash->buckets) {
1304 : 0 : kfree(hash);
1305 : 0 : return NULL;
1306 : : }
1307 : :
1308 : 0 : hash->size_bits = size_bits;
1309 : :
1310 : 0 : return hash;
1311 : : }
1312 : :
1313 : : static struct ftrace_hash *
1314 : 0 : alloc_and_copy_ftrace_hash(int size_bits, struct ftrace_hash *hash)
1315 : : {
1316 : : struct ftrace_func_entry *entry;
1317 : : struct ftrace_hash *new_hash;
1318 : : int size;
1319 : : int ret;
1320 : : int i;
1321 : :
1322 : 0 : new_hash = alloc_ftrace_hash(size_bits);
1323 [ # # ]: 0 : if (!new_hash)
1324 : : return NULL;
1325 : :
1326 : : /* Empty hash? */
1327 [ # # ]: 0 : if (ftrace_hash_empty(hash))
1328 : : return new_hash;
1329 : :
1330 : 0 : size = 1 << hash->size_bits;
1331 [ # # ]: 0 : for (i = 0; i < size; i++) {
1332 [ # # ][ # # ]: 0 : hlist_for_each_entry(entry, &hash->buckets[i], hlist) {
[ # # ]
1333 : 0 : ret = add_hash_entry(new_hash, entry->ip);
1334 [ # # ]: 0 : if (ret < 0)
1335 : : goto free_hash;
1336 : : }
1337 : : }
1338 : :
1339 [ # # ][ # # ]: 0 : FTRACE_WARN_ON(new_hash->count != hash->count);
1340 : :
1341 : 0 : return new_hash;
1342 : :
1343 : : free_hash:
1344 : 0 : free_ftrace_hash(new_hash);
1345 : 0 : return NULL;
1346 : : }
1347 : :
1348 : : static void
1349 : : ftrace_hash_rec_disable(struct ftrace_ops *ops, int filter_hash);
1350 : : static void
1351 : : ftrace_hash_rec_enable(struct ftrace_ops *ops, int filter_hash);
1352 : :
1353 : : static int
1354 : 0 : ftrace_hash_move(struct ftrace_ops *ops, int enable,
1355 : : struct ftrace_hash **dst, struct ftrace_hash *src)
1356 : : {
1357 : : struct ftrace_func_entry *entry;
1358 : : struct hlist_node *tn;
1359 : : struct hlist_head *hhd;
1360 : : struct ftrace_hash *old_hash;
1361 : : struct ftrace_hash *new_hash;
1362 : 0 : int size = src->count;
1363 : : int bits = 0;
1364 : : int ret;
1365 : : int i;
1366 : :
1367 : : /*
1368 : : * Remove the current set, update the hash and add
1369 : : * them back.
1370 : : */
1371 : : ftrace_hash_rec_disable(ops, enable);
1372 : :
1373 : : /*
1374 : : * If the new source is empty, just free dst and assign it
1375 : : * the empty_hash.
1376 : : */
1377 [ # # ]: 0 : if (!src->count) {
1378 : 0 : free_ftrace_hash_rcu(*dst);
1379 : 0 : rcu_assign_pointer(*dst, EMPTY_HASH);
1380 : : /* still need to update the function records */
1381 : : ret = 0;
1382 : 0 : goto out;
1383 : : }
1384 : :
1385 : : /*
1386 : : * Make the hash size about 1/2 the # found
1387 : : */
1388 [ # # ]: 0 : for (size /= 2; size; size >>= 1)
1389 : 0 : bits++;
1390 : :
1391 : : /* Don't allocate too much */
1392 [ # # ]: 0 : if (bits > FTRACE_HASH_MAX_BITS)
1393 : : bits = FTRACE_HASH_MAX_BITS;
1394 : :
1395 : : ret = -ENOMEM;
1396 : 0 : new_hash = alloc_ftrace_hash(bits);
1397 [ # # ]: 0 : if (!new_hash)
1398 : : goto out;
1399 : :
1400 : 0 : size = 1 << src->size_bits;
1401 [ # # ]: 0 : for (i = 0; i < size; i++) {
1402 : 0 : hhd = &src->buckets[i];
1403 [ # # ][ # # ]: 0 : hlist_for_each_entry_safe(entry, tn, hhd, hlist) {
[ # # ]
1404 : : remove_hash_entry(src, entry);
1405 : 0 : __add_hash_entry(new_hash, entry);
1406 : : }
1407 : : }
1408 : :
1409 : 0 : old_hash = *dst;
1410 : 0 : rcu_assign_pointer(*dst, new_hash);
1411 : : free_ftrace_hash_rcu(old_hash);
1412 : :
1413 : : ret = 0;
1414 : : out:
1415 : : /*
1416 : : * Enable regardless of ret:
1417 : : * On success, we enable the new hash.
1418 : : * On failure, we re-enable the original hash.
1419 : : */
1420 : : ftrace_hash_rec_enable(ops, enable);
1421 : :
1422 : 0 : return ret;
1423 : : }
1424 : :
1425 : : /*
1426 : : * Test the hashes for this ops to see if we want to call
1427 : : * the ops->func or not.
1428 : : *
1429 : : * It's a match if the ip is in the ops->filter_hash or
1430 : : * the filter_hash does not exist or is empty,
1431 : : * AND
1432 : : * the ip is not in the ops->notrace_hash.
1433 : : *
1434 : : * This needs to be called with preemption disabled as
1435 : : * the hashes are freed with call_rcu_sched().
1436 : : */
1437 : : static int
1438 : 0 : ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
1439 : : {
1440 : : struct ftrace_hash *filter_hash;
1441 : : struct ftrace_hash *notrace_hash;
1442 : : int ret;
1443 : :
1444 : : #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
1445 : : /*
1446 : : * There's a small race when adding ops that the ftrace handler
1447 : : * that wants regs, may be called without them. We can not
1448 : : * allow that handler to be called if regs is NULL.
1449 : : */
1450 : : if (regs == NULL && (ops->flags & FTRACE_OPS_FL_SAVE_REGS))
1451 : : return 0;
1452 : : #endif
1453 : :
1454 : 0 : filter_hash = rcu_dereference_raw_notrace(ops->filter_hash);
1455 : 0 : notrace_hash = rcu_dereference_raw_notrace(ops->notrace_hash);
1456 : :
1457 [ # # # # ]: 0 : if ((ftrace_hash_empty(filter_hash) ||
1458 [ # # ]: 0 : ftrace_lookup_ip(filter_hash, ip)) &&
1459 [ # # ]: 0 : (ftrace_hash_empty(notrace_hash) ||
1460 : 0 : !ftrace_lookup_ip(notrace_hash, ip)))
1461 : : ret = 1;
1462 : : else
1463 : : ret = 0;
1464 : :
1465 : 0 : return ret;
1466 : : }
1467 : :
1468 : : /*
1469 : : * This is a double for. Do not use 'break' to break out of the loop,
1470 : : * you must use a goto.
1471 : : */
1472 : : #define do_for_each_ftrace_rec(pg, rec) \
1473 : : for (pg = ftrace_pages_start; pg; pg = pg->next) { \
1474 : : int _____i; \
1475 : : for (_____i = 0; _____i < pg->index; _____i++) { \
1476 : : rec = &pg->records[_____i];
1477 : :
1478 : : #define while_for_each_ftrace_rec() \
1479 : : } \
1480 : : }
1481 : :
1482 : :
1483 : 0 : static int ftrace_cmp_recs(const void *a, const void *b)
1484 : : {
1485 : : const struct dyn_ftrace *key = a;
1486 : : const struct dyn_ftrace *rec = b;
1487 : :
1488 [ # # ]: 0 : if (key->flags < rec->ip)
1489 : : return -1;
1490 [ # # ]: 0 : if (key->ip >= rec->ip + MCOUNT_INSN_SIZE)
1491 : : return 1;
1492 : 0 : return 0;
1493 : : }
1494 : :
1495 : 0 : static unsigned long ftrace_location_range(unsigned long start, unsigned long end)
1496 : : {
1497 : : struct ftrace_page *pg;
1498 : : struct dyn_ftrace *rec;
1499 : : struct dyn_ftrace key;
1500 : :
1501 : 0 : key.ip = start;
1502 : 0 : key.flags = end; /* overload flags, as it is unsigned long */
1503 : :
1504 [ # # ]: 0 : for (pg = ftrace_pages_start; pg; pg = pg->next) {
1505 [ # # ][ # # ]: 0 : if (end < pg->records[0].ip ||
1506 : 0 : start >= (pg->records[pg->index - 1].ip + MCOUNT_INSN_SIZE))
1507 : 0 : continue;
1508 : 0 : rec = bsearch(&key, pg->records, pg->index,
1509 : : sizeof(struct dyn_ftrace),
1510 : : ftrace_cmp_recs);
1511 [ # # ]: 0 : if (rec)
1512 : 0 : return rec->ip;
1513 : : }
1514 : :
1515 : : return 0;
1516 : : }
1517 : :
1518 : : /**
1519 : : * ftrace_location - return true if the ip giving is a traced location
1520 : : * @ip: the instruction pointer to check
1521 : : *
1522 : : * Returns rec->ip if @ip given is a pointer to a ftrace location.
1523 : : * That is, the instruction that is either a NOP or call to
1524 : : * the function tracer. It checks the ftrace internal tables to
1525 : : * determine if the address belongs or not.
1526 : : */
1527 : 0 : unsigned long ftrace_location(unsigned long ip)
1528 : : {
1529 : 0 : return ftrace_location_range(ip, ip);
1530 : : }
1531 : :
1532 : : /**
1533 : : * ftrace_text_reserved - return true if range contains an ftrace location
1534 : : * @start: start of range to search
1535 : : * @end: end of range to search (inclusive). @end points to the last byte to check.
1536 : : *
1537 : : * Returns 1 if @start and @end contains a ftrace location.
1538 : : * That is, the instruction that is either a NOP or call to
1539 : : * the function tracer. It checks the ftrace internal tables to
1540 : : * determine if the address belongs or not.
1541 : : */
1542 : 0 : int ftrace_text_reserved(void *start, void *end)
1543 : : {
1544 : : unsigned long ret;
1545 : :
1546 : 0 : ret = ftrace_location_range((unsigned long)start,
1547 : : (unsigned long)end);
1548 : :
1549 : 0 : return (int)!!ret;
1550 : : }
1551 : :
1552 : 0 : static void __ftrace_hash_rec_update(struct ftrace_ops *ops,
1553 : : int filter_hash,
1554 : : bool inc)
1555 : : {
1556 : : struct ftrace_hash *hash;
1557 : : struct ftrace_hash *other_hash;
1558 : : struct ftrace_page *pg;
1559 : : struct dyn_ftrace *rec;
1560 : : int count = 0;
1561 : : int all = 0;
1562 : :
1563 : : /* Only update if the ops has been registered */
1564 [ # # ]: 0 : if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
1565 : : return;
1566 : :
1567 : : /*
1568 : : * In the filter_hash case:
1569 : : * If the count is zero, we update all records.
1570 : : * Otherwise we just update the items in the hash.
1571 : : *
1572 : : * In the notrace_hash case:
1573 : : * We enable the update in the hash.
1574 : : * As disabling notrace means enabling the tracing,
1575 : : * and enabling notrace means disabling, the inc variable
1576 : : * gets inversed.
1577 : : */
1578 [ # # ]: 0 : if (filter_hash) {
1579 : 0 : hash = ops->filter_hash;
1580 : 0 : other_hash = ops->notrace_hash;
1581 [ # # ]: 0 : if (ftrace_hash_empty(hash))
1582 : : all = 1;
1583 : : } else {
1584 : 0 : inc = !inc;
1585 : 0 : hash = ops->notrace_hash;
1586 : 0 : other_hash = ops->filter_hash;
1587 : : /*
1588 : : * If the notrace hash has no items,
1589 : : * then there's nothing to do.
1590 : : */
1591 [ # # ]: 0 : if (ftrace_hash_empty(hash))
1592 : : return;
1593 : : }
1594 : :
1595 [ # # ][ # # ]: 0 : do_for_each_ftrace_rec(pg, rec) {
1596 : : int in_other_hash = 0;
1597 : : int in_hash = 0;
1598 : : int match = 0;
1599 : :
1600 [ # # ]: 0 : if (all) {
1601 : : /*
1602 : : * Only the filter_hash affects all records.
1603 : : * Update if the record is not in the notrace hash.
1604 : : */
1605 [ # # ][ # # ]: 0 : if (!other_hash || !ftrace_lookup_ip(other_hash, rec->ip))
1606 : : match = 1;
1607 : : } else {
1608 : 0 : in_hash = !!ftrace_lookup_ip(hash, rec->ip);
1609 : 0 : in_other_hash = !!ftrace_lookup_ip(other_hash, rec->ip);
1610 : :
1611 : : /*
1612 : : *
1613 : : */
1614 [ # # ][ # # ]: 0 : if (filter_hash && in_hash && !in_other_hash)
1615 : : match = 1;
1616 [ # # ][ # # ]: 0 : else if (!filter_hash && in_hash &&
1617 [ # # ]: 0 : (in_other_hash || ftrace_hash_empty(other_hash)))
1618 : : match = 1;
1619 : : }
1620 [ # # ]: 0 : if (!match)
1621 : 0 : continue;
1622 : :
1623 [ # # ]: 0 : if (inc) {
1624 : 0 : rec->flags++;
1625 [ # # ][ # # ]: 0 : if (FTRACE_WARN_ON((rec->flags & ~FTRACE_FL_MASK) == FTRACE_REF_MAX))
[ # # ]
1626 : : return;
1627 : : /*
1628 : : * If any ops wants regs saved for this function
1629 : : * then all ops will get saved regs.
1630 : : */
1631 [ # # ]: 0 : if (ops->flags & FTRACE_OPS_FL_SAVE_REGS)
1632 : 0 : rec->flags |= FTRACE_FL_REGS;
1633 : : } else {
1634 [ # # ][ # # ]: 0 : if (FTRACE_WARN_ON((rec->flags & ~FTRACE_FL_MASK) == 0))
[ # # ]
1635 : : return;
1636 : 0 : rec->flags--;
1637 : : }
1638 : 0 : count++;
1639 : : /* Shortcut, if we handled all records, we are done. */
1640 [ # # ][ # # ]: 0 : if (!all && count == hash->count)
1641 : : return;
1642 : : } while_for_each_ftrace_rec();
1643 : : }
1644 : :
1645 : : static void ftrace_hash_rec_disable(struct ftrace_ops *ops,
1646 : : int filter_hash)
1647 : : {
1648 : 0 : __ftrace_hash_rec_update(ops, filter_hash, 0);
1649 : : }
1650 : :
1651 : : static void ftrace_hash_rec_enable(struct ftrace_ops *ops,
1652 : : int filter_hash)
1653 : : {
1654 : 0 : __ftrace_hash_rec_update(ops, filter_hash, 1);
1655 : : }
1656 : :
1657 : 0 : static void print_ip_ins(const char *fmt, unsigned char *p)
1658 : : {
1659 : : int i;
1660 : :
1661 : 0 : printk(KERN_CONT "%s", fmt);
1662 : :
1663 [ # # ]: 0 : for (i = 0; i < MCOUNT_INSN_SIZE; i++)
1664 [ # # ]: 0 : printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
1665 : 0 : }
1666 : :
1667 : : /**
1668 : : * ftrace_bug - report and shutdown function tracer
1669 : : * @failed: The failed type (EFAULT, EINVAL, EPERM)
1670 : : * @ip: The address that failed
1671 : : *
1672 : : * The arch code that enables or disables the function tracing
1673 : : * can call ftrace_bug() when it has detected a problem in
1674 : : * modifying the code. @failed should be one of either:
1675 : : * EFAULT - if the problem happens on reading the @ip address
1676 : : * EINVAL - if what is read at @ip is not what was expected
1677 : : * EPERM - if the problem happens on writting to the @ip address
1678 : : */
1679 : 0 : void ftrace_bug(int failed, unsigned long ip)
1680 : : {
1681 [ # # # # ]: 0 : switch (failed) {
1682 : : case -EFAULT:
1683 [ # # ][ # # ]: 0 : FTRACE_WARN_ON_ONCE(1);
1684 : 0 : pr_info("ftrace faulted on modifying ");
1685 : : print_ip_sym(ip);
1686 : : break;
1687 : : case -EINVAL:
1688 [ # # ][ # # ]: 0 : FTRACE_WARN_ON_ONCE(1);
1689 : 0 : pr_info("ftrace failed to modify ");
1690 : : print_ip_sym(ip);
1691 : 0 : print_ip_ins(" actual: ", (unsigned char *)ip);
1692 : 0 : printk(KERN_CONT "\n");
1693 : 0 : break;
1694 : : case -EPERM:
1695 [ # # ][ # # ]: 0 : FTRACE_WARN_ON_ONCE(1);
1696 : 0 : pr_info("ftrace faulted on writing ");
1697 : : print_ip_sym(ip);
1698 : : break;
1699 : : default:
1700 [ # # ][ # # ]: 0 : FTRACE_WARN_ON_ONCE(1);
1701 : 0 : pr_info("ftrace faulted on unknown error ");
1702 : : print_ip_sym(ip);
1703 : : }
1704 : 0 : }
1705 : :
1706 : 0 : static int ftrace_check_record(struct dyn_ftrace *rec, int enable, int update)
1707 : : {
1708 : : unsigned long flag = 0UL;
1709 : :
1710 : : /*
1711 : : * If we are updating calls:
1712 : : *
1713 : : * If the record has a ref count, then we need to enable it
1714 : : * because someone is using it.
1715 : : *
1716 : : * Otherwise we make sure its disabled.
1717 : : *
1718 : : * If we are disabling calls, then disable all records that
1719 : : * are enabled.
1720 : : */
1721 [ # # ][ # # ]: 0 : if (enable && (rec->flags & ~FTRACE_FL_MASK))
1722 : : flag = FTRACE_FL_ENABLED;
1723 : :
1724 : : /*
1725 : : * If enabling and the REGS flag does not match the REGS_EN, then
1726 : : * do not ignore this record. Set flags to fail the compare against
1727 : : * ENABLED.
1728 : : */
1729 [ # # ][ # # ]: 0 : if (flag &&
1730 : 0 : (!(rec->flags & FTRACE_FL_REGS) != !(rec->flags & FTRACE_FL_REGS_EN)))
1731 : 0 : flag |= FTRACE_FL_REGS;
1732 : :
1733 : : /* If the state of this record hasn't changed, then do nothing */
1734 [ # # ]: 0 : if ((rec->flags & FTRACE_FL_ENABLED) == flag)
1735 : : return FTRACE_UPDATE_IGNORE;
1736 : :
1737 [ # # ]: 0 : if (flag) {
1738 : : /* Save off if rec is being enabled (for return value) */
1739 : 0 : flag ^= rec->flags & FTRACE_FL_ENABLED;
1740 : :
1741 [ # # ]: 0 : if (update) {
1742 : 0 : rec->flags |= FTRACE_FL_ENABLED;
1743 [ # # ]: 0 : if (flag & FTRACE_FL_REGS) {
1744 [ # # ]: 0 : if (rec->flags & FTRACE_FL_REGS)
1745 : 0 : rec->flags |= FTRACE_FL_REGS_EN;
1746 : : else
1747 : 0 : rec->flags &= ~FTRACE_FL_REGS_EN;
1748 : : }
1749 : : }
1750 : :
1751 : : /*
1752 : : * If this record is being updated from a nop, then
1753 : : * return UPDATE_MAKE_CALL.
1754 : : * Otherwise, if the EN flag is set, then return
1755 : : * UPDATE_MODIFY_CALL_REGS to tell the caller to convert
1756 : : * from the non-save regs, to a save regs function.
1757 : : * Otherwise,
1758 : : * return UPDATE_MODIFY_CALL to tell the caller to convert
1759 : : * from the save regs, to a non-save regs function.
1760 : : */
1761 [ # # ]: 0 : if (flag & FTRACE_FL_ENABLED)
1762 : : return FTRACE_UPDATE_MAKE_CALL;
1763 [ # # ]: 0 : else if (rec->flags & FTRACE_FL_REGS_EN)
1764 : : return FTRACE_UPDATE_MODIFY_CALL_REGS;
1765 : : else
1766 : : return FTRACE_UPDATE_MODIFY_CALL;
1767 : : }
1768 : :
1769 [ # # ]: 0 : if (update) {
1770 : : /* If there's no more users, clear all flags */
1771 [ # # ]: 0 : if (!(rec->flags & ~FTRACE_FL_MASK))
1772 : 0 : rec->flags = 0;
1773 : : else
1774 : : /* Just disable the record (keep REGS state) */
1775 : 0 : rec->flags &= ~FTRACE_FL_ENABLED;
1776 : : }
1777 : :
1778 : : return FTRACE_UPDATE_MAKE_NOP;
1779 : : }
1780 : :
1781 : : /**
1782 : : * ftrace_update_record, set a record that now is tracing or not
1783 : : * @rec: the record to update
1784 : : * @enable: set to 1 if the record is tracing, zero to force disable
1785 : : *
1786 : : * The records that represent all functions that can be traced need
1787 : : * to be updated when tracing has been enabled.
1788 : : */
1789 : 0 : int ftrace_update_record(struct dyn_ftrace *rec, int enable)
1790 : : {
1791 : 0 : return ftrace_check_record(rec, enable, 1);
1792 : : }
1793 : :
1794 : : /**
1795 : : * ftrace_test_record, check if the record has been enabled or not
1796 : : * @rec: the record to test
1797 : : * @enable: set to 1 to check if enabled, 0 if it is disabled
1798 : : *
1799 : : * The arch code may need to test if a record is already set to
1800 : : * tracing to determine how to modify the function code that it
1801 : : * represents.
1802 : : */
1803 : 0 : int ftrace_test_record(struct dyn_ftrace *rec, int enable)
1804 : : {
1805 : 0 : return ftrace_check_record(rec, enable, 0);
1806 : : }
1807 : :
1808 : : static int
1809 : 0 : __ftrace_replace_code(struct dyn_ftrace *rec, int enable)
1810 : : {
1811 : : unsigned long ftrace_old_addr;
1812 : : unsigned long ftrace_addr;
1813 : : int ret;
1814 : :
1815 : : ret = ftrace_update_record(rec, enable);
1816 : :
1817 [ # # ]: 0 : if (rec->flags & FTRACE_FL_REGS)
1818 : 0 : ftrace_addr = (unsigned long)FTRACE_REGS_ADDR;
1819 : : else
1820 : 0 : ftrace_addr = (unsigned long)FTRACE_ADDR;
1821 : :
1822 [ # # # # : 0 : switch (ret) {
# ]
1823 : : case FTRACE_UPDATE_IGNORE:
1824 : : return 0;
1825 : :
1826 : : case FTRACE_UPDATE_MAKE_CALL:
1827 : 0 : return ftrace_make_call(rec, ftrace_addr);
1828 : :
1829 : : case FTRACE_UPDATE_MAKE_NOP:
1830 : 0 : return ftrace_make_nop(NULL, rec, ftrace_addr);
1831 : :
1832 : : case FTRACE_UPDATE_MODIFY_CALL_REGS:
1833 : : case FTRACE_UPDATE_MODIFY_CALL:
1834 : : if (rec->flags & FTRACE_FL_REGS)
1835 : : ftrace_old_addr = (unsigned long)FTRACE_ADDR;
1836 : : else
1837 : : ftrace_old_addr = (unsigned long)FTRACE_REGS_ADDR;
1838 : :
1839 : 0 : return ftrace_modify_call(rec, ftrace_old_addr, ftrace_addr);
1840 : : }
1841 : :
1842 : 0 : return -1; /* unknow ftrace bug */
1843 : : }
1844 : :
1845 : 0 : void __weak ftrace_replace_code(int enable)
1846 : : {
1847 : : struct dyn_ftrace *rec;
1848 : : struct ftrace_page *pg;
1849 : : int failed;
1850 : :
1851 [ # # ]: 0 : if (unlikely(ftrace_disabled))
1852 : : return;
1853 : :
1854 [ # # ][ # # ]: 0 : do_for_each_ftrace_rec(pg, rec) {
1855 : 0 : failed = __ftrace_replace_code(rec, enable);
1856 [ # # ]: 0 : if (failed) {
1857 : 0 : ftrace_bug(failed, rec->ip);
1858 : : /* Stop processing */
1859 : 0 : return;
1860 : : }
1861 : : } while_for_each_ftrace_rec();
1862 : : }
1863 : :
1864 : : struct ftrace_rec_iter {
1865 : : struct ftrace_page *pg;
1866 : : int index;
1867 : : };
1868 : :
1869 : : /**
1870 : : * ftrace_rec_iter_start, start up iterating over traced functions
1871 : : *
1872 : : * Returns an iterator handle that is used to iterate over all
1873 : : * the records that represent address locations where functions
1874 : : * are traced.
1875 : : *
1876 : : * May return NULL if no records are available.
1877 : : */
1878 : 0 : struct ftrace_rec_iter *ftrace_rec_iter_start(void)
1879 : : {
1880 : : /*
1881 : : * We only use a single iterator.
1882 : : * Protected by the ftrace_lock mutex.
1883 : : */
1884 : : static struct ftrace_rec_iter ftrace_rec_iter;
1885 : : struct ftrace_rec_iter *iter = &ftrace_rec_iter;
1886 : :
1887 : 0 : iter->pg = ftrace_pages_start;
1888 : 0 : iter->index = 0;
1889 : :
1890 : : /* Could have empty pages */
1891 [ # # ][ # # ]: 0 : while (iter->pg && !iter->pg->index)
1892 : 0 : iter->pg = iter->pg->next;
1893 : :
1894 [ # # ]: 0 : if (!iter->pg)
1895 : : return NULL;
1896 : :
1897 : 0 : return iter;
1898 : : }
1899 : :
1900 : : /**
1901 : : * ftrace_rec_iter_next, get the next record to process.
1902 : : * @iter: The handle to the iterator.
1903 : : *
1904 : : * Returns the next iterator after the given iterator @iter.
1905 : : */
1906 : 0 : struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter)
1907 : : {
1908 : 0 : iter->index++;
1909 : :
1910 [ # # ]: 0 : if (iter->index >= iter->pg->index) {
1911 : 0 : iter->pg = iter->pg->next;
1912 : 0 : iter->index = 0;
1913 : :
1914 : : /* Could have empty pages */
1915 [ # # ][ # # ]: 0 : while (iter->pg && !iter->pg->index)
1916 : 0 : iter->pg = iter->pg->next;
1917 : : }
1918 : :
1919 [ # # ]: 0 : if (!iter->pg)
1920 : : return NULL;
1921 : :
1922 : 0 : return iter;
1923 : : }
1924 : :
1925 : : /**
1926 : : * ftrace_rec_iter_record, get the record at the iterator location
1927 : : * @iter: The current iterator location
1928 : : *
1929 : : * Returns the record that the current @iter is at.
1930 : : */
1931 : 0 : struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter)
1932 : : {
1933 : 0 : return &iter->pg->records[iter->index];
1934 : : }
1935 : :
1936 : : static int
1937 : 0 : ftrace_code_disable(struct module *mod, struct dyn_ftrace *rec)
1938 : : {
1939 : : unsigned long ip;
1940 : : int ret;
1941 : :
1942 : 0 : ip = rec->ip;
1943 : :
1944 [ # # ]: 0 : if (unlikely(ftrace_disabled))
1945 : : return 0;
1946 : :
1947 : 0 : ret = ftrace_make_nop(mod, rec, MCOUNT_ADDR);
1948 [ # # ]: 0 : if (ret) {
1949 : 0 : ftrace_bug(ret, ip);
1950 : 0 : return 0;
1951 : : }
1952 : : return 1;
1953 : : }
1954 : :
1955 : : /*
1956 : : * archs can override this function if they must do something
1957 : : * before the modifying code is performed.
1958 : : */
1959 : 0 : int __weak ftrace_arch_code_modify_prepare(void)
1960 : : {
1961 : 0 : return 0;
1962 : : }
1963 : :
1964 : : /*
1965 : : * archs can override this function if they must do something
1966 : : * after the modifying code is performed.
1967 : : */
1968 : 0 : int __weak ftrace_arch_code_modify_post_process(void)
1969 : : {
1970 : 0 : return 0;
1971 : : }
1972 : :
1973 : 0 : void ftrace_modify_all_code(int command)
1974 : : {
1975 : 0 : int update = command & FTRACE_UPDATE_TRACE_FUNC;
1976 : :
1977 : : /*
1978 : : * If the ftrace_caller calls a ftrace_ops func directly,
1979 : : * we need to make sure that it only traces functions it
1980 : : * expects to trace. When doing the switch of functions,
1981 : : * we need to update to the ftrace_ops_list_func first
1982 : : * before the transition between old and new calls are set,
1983 : : * as the ftrace_ops_list_func will check the ops hashes
1984 : : * to make sure the ops are having the right functions
1985 : : * traced.
1986 : : */
1987 [ # # ]: 0 : if (update)
1988 : 0 : ftrace_update_ftrace_func(ftrace_ops_list_func);
1989 : :
1990 [ # # ]: 0 : if (command & FTRACE_UPDATE_CALLS)
1991 : 0 : ftrace_replace_code(1);
1992 [ # # ]: 0 : else if (command & FTRACE_DISABLE_CALLS)
1993 : 0 : ftrace_replace_code(0);
1994 : :
1995 [ # # ][ # # ]: 0 : if (update && ftrace_trace_function != ftrace_ops_list_func)
1996 : 0 : ftrace_update_ftrace_func(ftrace_trace_function);
1997 : :
1998 : : if (command & FTRACE_START_FUNC_RET)
1999 : : ftrace_enable_ftrace_graph_caller();
2000 : : else if (command & FTRACE_STOP_FUNC_RET)
2001 : : ftrace_disable_ftrace_graph_caller();
2002 : 0 : }
2003 : :
2004 : 0 : static int __ftrace_modify_code(void *data)
2005 : : {
2006 : : int *command = data;
2007 : :
2008 : 0 : ftrace_modify_all_code(*command);
2009 : :
2010 : 0 : return 0;
2011 : : }
2012 : :
2013 : : /**
2014 : : * ftrace_run_stop_machine, go back to the stop machine method
2015 : : * @command: The command to tell ftrace what to do
2016 : : *
2017 : : * If an arch needs to fall back to the stop machine method, the
2018 : : * it can call this function.
2019 : : */
2020 : 0 : void ftrace_run_stop_machine(int command)
2021 : : {
2022 : 0 : stop_machine(__ftrace_modify_code, &command, NULL);
2023 : 0 : }
2024 : :
2025 : : /**
2026 : : * arch_ftrace_update_code, modify the code to trace or not trace
2027 : : * @command: The command that needs to be done
2028 : : *
2029 : : * Archs can override this function if it does not need to
2030 : : * run stop_machine() to modify code.
2031 : : */
2032 : 0 : void __weak arch_ftrace_update_code(int command)
2033 : : {
2034 : : ftrace_run_stop_machine(command);
2035 : 0 : }
2036 : :
2037 : 0 : static void ftrace_run_update_code(int command)
2038 : : {
2039 : : int ret;
2040 : :
2041 : 0 : ret = ftrace_arch_code_modify_prepare();
2042 [ # # ][ # # ]: 0 : FTRACE_WARN_ON(ret);
2043 [ # # ]: 0 : if (ret)
2044 : 0 : return;
2045 : : /*
2046 : : * Do not call function tracer while we update the code.
2047 : : * We are in stop machine.
2048 : : */
2049 : 0 : function_trace_stop++;
2050 : :
2051 : : /*
2052 : : * By default we use stop_machine() to modify the code.
2053 : : * But archs can do what ever they want as long as it
2054 : : * is safe. The stop_machine() is the safest, but also
2055 : : * produces the most overhead.
2056 : : */
2057 : 0 : arch_ftrace_update_code(command);
2058 : :
2059 : 0 : function_trace_stop--;
2060 : :
2061 : 0 : ret = ftrace_arch_code_modify_post_process();
2062 [ # # ][ # # ]: 0 : FTRACE_WARN_ON(ret);
2063 : : }
2064 : :
2065 : : static ftrace_func_t saved_ftrace_func;
2066 : : static int ftrace_start_up;
2067 : : static int global_start_up;
2068 : :
2069 : 0 : static void ftrace_startup_enable(int command)
2070 : : {
2071 [ # # ]: 0 : if (saved_ftrace_func != ftrace_trace_function) {
2072 : 0 : saved_ftrace_func = ftrace_trace_function;
2073 : 0 : command |= FTRACE_UPDATE_TRACE_FUNC;
2074 : : }
2075 : :
2076 [ # # ][ # # ]: 0 : if (!command || !ftrace_enabled)
2077 : 0 : return;
2078 : :
2079 : 0 : ftrace_run_update_code(command);
2080 : : }
2081 : :
2082 : 0 : static int ftrace_startup(struct ftrace_ops *ops, int command)
2083 : : {
2084 : : bool hash_enable = true;
2085 : : int ret;
2086 : :
2087 [ # # ]: 0 : if (unlikely(ftrace_disabled))
2088 : : return -ENODEV;
2089 : :
2090 : 0 : ret = __register_ftrace_function(ops);
2091 [ # # ]: 0 : if (ret)
2092 : : return ret;
2093 : :
2094 : 0 : ftrace_start_up++;
2095 : 0 : command |= FTRACE_UPDATE_CALLS;
2096 : :
2097 : : /* ops marked global share the filter hashes */
2098 [ # # ]: 0 : if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
2099 : : ops = &global_ops;
2100 : : /* Don't update hash if global is already set */
2101 [ # # ]: 0 : if (global_start_up)
2102 : : hash_enable = false;
2103 : 0 : global_start_up++;
2104 : : }
2105 : :
2106 : 0 : ops->flags |= FTRACE_OPS_FL_ENABLED;
2107 [ # # ]: 0 : if (hash_enable)
2108 : : ftrace_hash_rec_enable(ops, 1);
2109 : :
2110 : 0 : ftrace_startup_enable(command);
2111 : :
2112 : 0 : return 0;
2113 : : }
2114 : :
2115 : 0 : static int ftrace_shutdown(struct ftrace_ops *ops, int command)
2116 : : {
2117 : : bool hash_disable = true;
2118 : : int ret;
2119 : :
2120 [ # # ]: 0 : if (unlikely(ftrace_disabled))
2121 : : return -ENODEV;
2122 : :
2123 : 0 : ret = __unregister_ftrace_function(ops);
2124 [ # # ]: 0 : if (ret)
2125 : : return ret;
2126 : :
2127 : 0 : ftrace_start_up--;
2128 : : /*
2129 : : * Just warn in case of unbalance, no need to kill ftrace, it's not
2130 : : * critical but the ftrace_call callers may be never nopped again after
2131 : : * further ftrace uses.
2132 : : */
2133 [ # # ][ # # ]: 0 : WARN_ON_ONCE(ftrace_start_up < 0);
[ # # ]
2134 : :
2135 [ # # ]: 0 : if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
2136 : : ops = &global_ops;
2137 : 0 : global_start_up--;
2138 [ # # ][ # # ]: 0 : WARN_ON_ONCE(global_start_up < 0);
[ # # ]
2139 : : /* Don't update hash if global still has users */
2140 [ # # ]: 0 : if (global_start_up) {
2141 [ # # ][ # # ]: 0 : WARN_ON_ONCE(!ftrace_start_up);
[ # # ]
2142 : : hash_disable = false;
2143 : : }
2144 : : }
2145 : :
2146 [ # # ]: 0 : if (hash_disable)
2147 : : ftrace_hash_rec_disable(ops, 1);
2148 : :
2149 [ # # ][ # # ]: 0 : if (ops != &global_ops || !global_start_up)
2150 : 0 : ops->flags &= ~FTRACE_OPS_FL_ENABLED;
2151 : :
2152 : 0 : command |= FTRACE_UPDATE_CALLS;
2153 : :
2154 [ # # ]: 0 : if (saved_ftrace_func != ftrace_trace_function) {
2155 : 0 : saved_ftrace_func = ftrace_trace_function;
2156 : 0 : command |= FTRACE_UPDATE_TRACE_FUNC;
2157 : : }
2158 : :
2159 [ # # ]: 0 : if (!command || !ftrace_enabled)
2160 : : return 0;
2161 : :
2162 : 0 : ftrace_run_update_code(command);
2163 : 0 : return 0;
2164 : : }
2165 : :
2166 : 0 : static void ftrace_startup_sysctl(void)
2167 : : {
2168 [ # # ]: 0 : if (unlikely(ftrace_disabled))
2169 : 0 : return;
2170 : :
2171 : : /* Force update next time */
2172 : 0 : saved_ftrace_func = NULL;
2173 : : /* ftrace_start_up is true if we want ftrace running */
2174 [ # # ]: 0 : if (ftrace_start_up)
2175 : 0 : ftrace_run_update_code(FTRACE_UPDATE_CALLS);
2176 : : }
2177 : :
2178 : 0 : static void ftrace_shutdown_sysctl(void)
2179 : : {
2180 [ # # ]: 0 : if (unlikely(ftrace_disabled))
2181 : 0 : return;
2182 : :
2183 : : /* ftrace_start_up is true if ftrace is running */
2184 [ # # ]: 0 : if (ftrace_start_up)
2185 : 0 : ftrace_run_update_code(FTRACE_DISABLE_CALLS);
2186 : : }
2187 : :
2188 : : static cycle_t ftrace_update_time;
2189 : : static unsigned long ftrace_update_cnt;
2190 : : unsigned long ftrace_update_tot_cnt;
2191 : :
2192 : : static inline int ops_traces_mod(struct ftrace_ops *ops)
2193 : : {
2194 : : /*
2195 : : * Filter_hash being empty will default to trace module.
2196 : : * But notrace hash requires a test of individual module functions.
2197 : : */
2198 [ # # # # ]: 0 : return ftrace_hash_empty(ops->filter_hash) &&
[ # # # # ]
2199 : 0 : ftrace_hash_empty(ops->notrace_hash);
2200 : : }
2201 : :
2202 : : /*
2203 : : * Check if the current ops references the record.
2204 : : *
2205 : : * If the ops traces all functions, then it was already accounted for.
2206 : : * If the ops does not trace the current record function, skip it.
2207 : : * If the ops ignores the function via notrace filter, skip it.
2208 : : */
2209 : : static inline bool
2210 : 0 : ops_references_rec(struct ftrace_ops *ops, struct dyn_ftrace *rec)
2211 : : {
2212 : : /* If ops isn't enabled, ignore it */
2213 [ # # ]: 0 : if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
2214 : : return 0;
2215 : :
2216 : : /* If ops traces all mods, we already accounted for it */
2217 [ # # ]: 0 : if (ops_traces_mod(ops))
2218 : : return 0;
2219 : :
2220 : : /* The function must be in the filter */
2221 [ # # # # ]: 0 : if (!ftrace_hash_empty(ops->filter_hash) &&
2222 : 0 : !ftrace_lookup_ip(ops->filter_hash, rec->ip))
2223 : : return 0;
2224 : :
2225 : : /* If in notrace hash, we ignore it too */
2226 [ # # ]: 0 : if (ftrace_lookup_ip(ops->notrace_hash, rec->ip))
2227 : : return 0;
2228 : :
2229 : : return 1;
2230 : : }
2231 : :
2232 : 0 : static int referenced_filters(struct dyn_ftrace *rec)
2233 : : {
2234 : : struct ftrace_ops *ops;
2235 : : int cnt = 0;
2236 : :
2237 [ # # ]: 0 : for (ops = ftrace_ops_list; ops != &ftrace_list_end; ops = ops->next) {
2238 [ # # ]: 0 : if (ops_references_rec(ops, rec))
2239 : 0 : cnt++;
2240 : : }
2241 : :
2242 : 0 : return cnt;
2243 : : }
2244 : :
2245 : 0 : static int ftrace_update_code(struct module *mod)
2246 : : {
2247 : : struct ftrace_page *pg;
2248 : : struct dyn_ftrace *p;
2249 : : cycle_t start, stop;
2250 : : unsigned long ref = 0;
2251 : : bool test = false;
2252 : : int i;
2253 : :
2254 : : /*
2255 : : * When adding a module, we need to check if tracers are
2256 : : * currently enabled and if they are set to trace all functions.
2257 : : * If they are, we need to enable the module functions as well
2258 : : * as update the reference counts for those function records.
2259 : : */
2260 [ # # ]: 0 : if (mod) {
2261 : 0 : struct ftrace_ops *ops;
2262 : :
2263 [ # # ]: 0 : for (ops = ftrace_ops_list;
2264 : 0 : ops != &ftrace_list_end; ops = ops->next) {
2265 [ # # ]: 0 : if (ops->flags & FTRACE_OPS_FL_ENABLED) {
2266 [ # # ]: 0 : if (ops_traces_mod(ops))
2267 : 0 : ref++;
2268 : : else
2269 : : test = true;
2270 : : }
2271 : : }
2272 : : }
2273 : :
2274 : 0 : start = ftrace_now(raw_smp_processor_id());
2275 : 0 : ftrace_update_cnt = 0;
2276 : :
2277 [ # # ]: 0 : for (pg = ftrace_new_pgs; pg; pg = pg->next) {
2278 : :
2279 [ # # ]: 0 : for (i = 0; i < pg->index; i++) {
2280 : 0 : int cnt = ref;
2281 : :
2282 : : /* If something went wrong, bail without enabling anything */
2283 [ # # ]: 0 : if (unlikely(ftrace_disabled))
2284 : : return -1;
2285 : :
2286 : 0 : p = &pg->records[i];
2287 [ # # ]: 0 : if (test)
2288 : 0 : cnt += referenced_filters(p);
2289 : 0 : p->flags = cnt;
2290 : :
2291 : : /*
2292 : : * Do the initial record conversion from mcount jump
2293 : : * to the NOP instructions.
2294 : : */
2295 [ # # ]: 0 : if (!ftrace_code_disable(mod, p))
2296 : : break;
2297 : :
2298 : 0 : ftrace_update_cnt++;
2299 : :
2300 : : /*
2301 : : * If the tracing is enabled, go ahead and enable the record.
2302 : : *
2303 : : * The reason not to enable the record immediatelly is the
2304 : : * inherent check of ftrace_make_nop/ftrace_make_call for
2305 : : * correct previous instructions. Making first the NOP
2306 : : * conversion puts the module to the correct state, thus
2307 : : * passing the ftrace_make_call check.
2308 : : */
2309 [ # # ][ # # ]: 0 : if (ftrace_start_up && cnt) {
2310 : 0 : int failed = __ftrace_replace_code(p, 1);
2311 [ # # ]: 0 : if (failed)
2312 : 0 : ftrace_bug(failed, p->ip);
2313 : : }
2314 : : }
2315 : : }
2316 : :
2317 : 0 : ftrace_new_pgs = NULL;
2318 : :
2319 : 0 : stop = ftrace_now(raw_smp_processor_id());
2320 : 0 : ftrace_update_time = stop - start;
2321 : 0 : ftrace_update_tot_cnt += ftrace_update_cnt;
2322 : :
2323 : 0 : return 0;
2324 : : }
2325 : :
2326 : 0 : static int ftrace_allocate_records(struct ftrace_page *pg, int count)
2327 : : {
2328 : : int order;
2329 : : int cnt;
2330 : :
2331 [ # # ][ # # ]: 0 : if (WARN_ON(!count))
2332 : : return -EINVAL;
2333 : :
2334 : 0 : order = get_count_order(DIV_ROUND_UP(count, ENTRIES_PER_PAGE));
2335 : :
2336 : : /*
2337 : : * We want to fill as much as possible. No more than a page
2338 : : * may be empty.
2339 : : */
2340 [ # # ]: 0 : while ((PAGE_SIZE << order) / ENTRY_SIZE >= count + ENTRIES_PER_PAGE)
2341 : 0 : order--;
2342 : :
2343 : : again:
2344 : 0 : pg->records = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, order);
2345 : :
2346 [ # # ]: 0 : if (!pg->records) {
2347 : : /* if we can't allocate this size, try something smaller */
2348 [ # # ]: 0 : if (!order)
2349 : : return -ENOMEM;
2350 : 0 : order >>= 1;
2351 : : goto again;
2352 : : }
2353 : :
2354 : 0 : cnt = (PAGE_SIZE << order) / ENTRY_SIZE;
2355 : 0 : pg->size = cnt;
2356 : :
2357 [ # # ]: 0 : if (cnt > count)
2358 : : cnt = count;
2359 : :
2360 : : return cnt;
2361 : : }
2362 : :
2363 : : static struct ftrace_page *
2364 : 0 : ftrace_allocate_pages(unsigned long num_to_init)
2365 : : {
2366 : : struct ftrace_page *start_pg;
2367 : : struct ftrace_page *pg;
2368 : : int order;
2369 : : int cnt;
2370 : :
2371 [ # # ]: 0 : if (!num_to_init)
2372 : : return 0;
2373 : :
2374 : : start_pg = pg = kzalloc(sizeof(*pg), GFP_KERNEL);
2375 [ # # ]: 0 : if (!pg)
2376 : : return NULL;
2377 : :
2378 : : /*
2379 : : * Try to allocate as much as possible in one continues
2380 : : * location that fills in all of the space. We want to
2381 : : * waste as little space as possible.
2382 : : */
2383 : : for (;;) {
2384 : 0 : cnt = ftrace_allocate_records(pg, num_to_init);
2385 [ # # ]: 0 : if (cnt < 0)
2386 : : goto free_pages;
2387 : :
2388 : 0 : num_to_init -= cnt;
2389 [ # # ]: 0 : if (!num_to_init)
2390 : : break;
2391 : :
2392 : 0 : pg->next = kzalloc(sizeof(*pg), GFP_KERNEL);
2393 [ # # ]: 0 : if (!pg->next)
2394 : : goto free_pages;
2395 : :
2396 : : pg = pg->next;
2397 : : }
2398 : :
2399 : : return start_pg;
2400 : :
2401 : : free_pages:
2402 [ # # ]: 0 : while (start_pg) {
2403 : 0 : order = get_count_order(pg->size / ENTRIES_PER_PAGE);
2404 : 0 : free_pages((unsigned long)pg->records, order);
2405 : 0 : start_pg = pg->next;
2406 : 0 : kfree(pg);
2407 : : pg = start_pg;
2408 : : }
2409 : 0 : pr_info("ftrace: FAILED to allocate memory for functions\n");
2410 : 0 : return NULL;
2411 : : }
2412 : :
2413 : 0 : static int __init ftrace_dyn_table_alloc(unsigned long num_to_init)
2414 : : {
2415 : : int cnt;
2416 : :
2417 [ # # ]: 0 : if (!num_to_init) {
2418 : 0 : pr_info("ftrace: No functions to be traced?\n");
2419 : 0 : return -1;
2420 : : }
2421 : :
2422 : 0 : cnt = num_to_init / ENTRIES_PER_PAGE;
2423 : 0 : pr_info("ftrace: allocating %ld entries in %d pages\n",
2424 : : num_to_init, cnt + 1);
2425 : :
2426 : 0 : return 0;
2427 : : }
2428 : :
2429 : : #define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
2430 : :
2431 : : struct ftrace_iterator {
2432 : : loff_t pos;
2433 : : loff_t func_pos;
2434 : : struct ftrace_page *pg;
2435 : : struct dyn_ftrace *func;
2436 : : struct ftrace_func_probe *probe;
2437 : : struct trace_parser parser;
2438 : : struct ftrace_hash *hash;
2439 : : struct ftrace_ops *ops;
2440 : : int hidx;
2441 : : int idx;
2442 : : unsigned flags;
2443 : : };
2444 : :
2445 : : static void *
2446 : 0 : t_hash_next(struct seq_file *m, loff_t *pos)
2447 : : {
2448 : 0 : struct ftrace_iterator *iter = m->private;
2449 : : struct hlist_node *hnd = NULL;
2450 : : struct hlist_head *hhd;
2451 : :
2452 : 0 : (*pos)++;
2453 : 0 : iter->pos = *pos;
2454 : :
2455 [ # # ]: 0 : if (iter->probe)
2456 : 0 : hnd = &iter->probe->node;
2457 : : retry:
2458 [ # # ]: 0 : if (iter->hidx >= FTRACE_FUNC_HASHSIZE)
2459 : : return NULL;
2460 : :
2461 : 0 : hhd = &ftrace_func_hash[iter->hidx];
2462 : :
2463 [ # # ]: 0 : if (hlist_empty(hhd)) {
2464 : 0 : iter->hidx++;
2465 : : hnd = NULL;
2466 : : goto retry;
2467 : : }
2468 : :
2469 [ # # ]: 0 : if (!hnd)
2470 : : hnd = hhd->first;
2471 : : else {
2472 : 0 : hnd = hnd->next;
2473 [ # # ]: 0 : if (!hnd) {
2474 : 0 : iter->hidx++;
2475 : : goto retry;
2476 : : }
2477 : : }
2478 : :
2479 [ # # ][ # # ]: 0 : if (WARN_ON_ONCE(!hnd))
[ # # ][ # # ]
2480 : : return NULL;
2481 : :
2482 : 0 : iter->probe = hlist_entry(hnd, struct ftrace_func_probe, node);
2483 : :
2484 : : return iter;
2485 : : }
2486 : :
2487 : 0 : static void *t_hash_start(struct seq_file *m, loff_t *pos)
2488 : : {
2489 : 0 : struct ftrace_iterator *iter = m->private;
2490 : : void *p = NULL;
2491 : : loff_t l;
2492 : :
2493 [ # # ]: 0 : if (!(iter->flags & FTRACE_ITER_DO_HASH))
2494 : : return NULL;
2495 : :
2496 [ # # ]: 0 : if (iter->func_pos > *pos)
2497 : : return NULL;
2498 : :
2499 : 0 : iter->hidx = 0;
2500 [ # # ]: 0 : for (l = 0; l <= (*pos - iter->func_pos); ) {
2501 : 0 : p = t_hash_next(m, &l);
2502 [ # # ]: 0 : if (!p)
2503 : : break;
2504 : : }
2505 [ # # ]: 0 : if (!p)
2506 : : return NULL;
2507 : :
2508 : : /* Only set this if we have an item */
2509 : 0 : iter->flags |= FTRACE_ITER_HASH;
2510 : :
2511 : 0 : return iter;
2512 : : }
2513 : :
2514 : : static int
2515 : 0 : t_hash_show(struct seq_file *m, struct ftrace_iterator *iter)
2516 : : {
2517 : : struct ftrace_func_probe *rec;
2518 : :
2519 : 0 : rec = iter->probe;
2520 [ # # ][ # # ]: 0 : if (WARN_ON_ONCE(!rec))
[ # # ][ # # ]
2521 : : return -EIO;
2522 : :
2523 [ # # ]: 0 : if (rec->ops->print)
2524 : 0 : return rec->ops->print(m, rec->ip, rec->ops, rec->data);
2525 : :
2526 : 0 : seq_printf(m, "%ps:%ps", (void *)rec->ip, (void *)rec->ops->func);
2527 : :
2528 [ # # ]: 0 : if (rec->data)
2529 : 0 : seq_printf(m, ":%p", rec->data);
2530 : 0 : seq_putc(m, '\n');
2531 : :
2532 : : return 0;
2533 : : }
2534 : :
2535 : : static void *
2536 : 0 : t_next(struct seq_file *m, void *v, loff_t *pos)
2537 : : {
2538 : 0 : struct ftrace_iterator *iter = m->private;
2539 : 0 : struct ftrace_ops *ops = iter->ops;
2540 : : struct dyn_ftrace *rec = NULL;
2541 : :
2542 [ # # ]: 0 : if (unlikely(ftrace_disabled))
2543 : : return NULL;
2544 : :
2545 [ # # ]: 0 : if (iter->flags & FTRACE_ITER_HASH)
2546 : 0 : return t_hash_next(m, pos);
2547 : :
2548 : 0 : (*pos)++;
2549 : 0 : iter->pos = iter->func_pos = *pos;
2550 : :
2551 [ # # ]: 0 : if (iter->flags & FTRACE_ITER_PRINTALL)
2552 : 0 : return t_hash_start(m, pos);
2553 : :
2554 : : retry:
2555 [ # # ]: 0 : if (iter->idx >= iter->pg->index) {
2556 [ # # ]: 0 : if (iter->pg->next) {
2557 : 0 : iter->pg = iter->pg->next;
2558 : 0 : iter->idx = 0;
2559 : 0 : goto retry;
2560 : : }
2561 : : } else {
2562 : 0 : rec = &iter->pg->records[iter->idx++];
2563 [ # # # # ]: 0 : if (((iter->flags & FTRACE_ITER_FILTER) &&
2564 [ # # ]: 0 : !(ftrace_lookup_ip(ops->filter_hash, rec->ip))) ||
2565 : :
2566 [ # # ]: 0 : ((iter->flags & FTRACE_ITER_NOTRACE) &&
2567 [ # # ]: 0 : !ftrace_lookup_ip(ops->notrace_hash, rec->ip)) ||
2568 : :
2569 [ # # ]: 0 : ((iter->flags & FTRACE_ITER_ENABLED) &&
2570 : 0 : !(rec->flags & FTRACE_FL_ENABLED))) {
2571 : :
2572 : : rec = NULL;
2573 : : goto retry;
2574 : : }
2575 : : }
2576 : :
2577 [ # # ]: 0 : if (!rec)
2578 : 0 : return t_hash_start(m, pos);
2579 : :
2580 : 0 : iter->func = rec;
2581 : :
2582 : 0 : return iter;
2583 : : }
2584 : :
2585 : : static void reset_iter_read(struct ftrace_iterator *iter)
2586 : : {
2587 : 0 : iter->pos = 0;
2588 : 0 : iter->func_pos = 0;
2589 : 0 : iter->flags &= ~(FTRACE_ITER_PRINTALL | FTRACE_ITER_HASH);
2590 : : }
2591 : :
2592 : 0 : static void *t_start(struct seq_file *m, loff_t *pos)
2593 : : {
2594 : 0 : struct ftrace_iterator *iter = m->private;
2595 : 0 : struct ftrace_ops *ops = iter->ops;
2596 : : void *p = NULL;
2597 : : loff_t l;
2598 : :
2599 : 0 : mutex_lock(&ftrace_lock);
2600 : :
2601 [ # # ]: 0 : if (unlikely(ftrace_disabled))
2602 : : return NULL;
2603 : :
2604 : : /*
2605 : : * If an lseek was done, then reset and start from beginning.
2606 : : */
2607 [ # # ]: 0 : if (*pos < iter->pos)
2608 : : reset_iter_read(iter);
2609 : :
2610 : : /*
2611 : : * For set_ftrace_filter reading, if we have the filter
2612 : : * off, we can short cut and just print out that all
2613 : : * functions are enabled.
2614 : : */
2615 [ # # ][ # # ]: 0 : if (iter->flags & FTRACE_ITER_FILTER &&
2616 : 0 : ftrace_hash_empty(ops->filter_hash)) {
2617 [ # # ]: 0 : if (*pos > 0)
2618 : 0 : return t_hash_start(m, pos);
2619 : 0 : iter->flags |= FTRACE_ITER_PRINTALL;
2620 : : /* reset in case of seek/pread */
2621 : 0 : iter->flags &= ~FTRACE_ITER_HASH;
2622 : 0 : return iter;
2623 : : }
2624 : :
2625 [ # # ]: 0 : if (iter->flags & FTRACE_ITER_HASH)
2626 : 0 : return t_hash_start(m, pos);
2627 : :
2628 : : /*
2629 : : * Unfortunately, we need to restart at ftrace_pages_start
2630 : : * every time we let go of the ftrace_mutex. This is because
2631 : : * those pointers can change without the lock.
2632 : : */
2633 : 0 : iter->pg = ftrace_pages_start;
2634 : 0 : iter->idx = 0;
2635 [ # # ]: 0 : for (l = 0; l <= *pos; ) {
2636 : 0 : p = t_next(m, p, &l);
2637 [ # # ]: 0 : if (!p)
2638 : : break;
2639 : : }
2640 : :
2641 [ # # ]: 0 : if (!p)
2642 : 0 : return t_hash_start(m, pos);
2643 : :
2644 : : return iter;
2645 : : }
2646 : :
2647 : 0 : static void t_stop(struct seq_file *m, void *p)
2648 : : {
2649 : 0 : mutex_unlock(&ftrace_lock);
2650 : 0 : }
2651 : :
2652 : 0 : static int t_show(struct seq_file *m, void *v)
2653 : : {
2654 : 0 : struct ftrace_iterator *iter = m->private;
2655 : : struct dyn_ftrace *rec;
2656 : :
2657 [ # # ]: 0 : if (iter->flags & FTRACE_ITER_HASH)
2658 : 0 : return t_hash_show(m, iter);
2659 : :
2660 [ # # ]: 0 : if (iter->flags & FTRACE_ITER_PRINTALL) {
2661 : 0 : seq_printf(m, "#### all functions enabled ####\n");
2662 : 0 : return 0;
2663 : : }
2664 : :
2665 : 0 : rec = iter->func;
2666 : :
2667 [ # # ]: 0 : if (!rec)
2668 : : return 0;
2669 : :
2670 : 0 : seq_printf(m, "%ps", (void *)rec->ip);
2671 [ # # ]: 0 : if (iter->flags & FTRACE_ITER_ENABLED)
2672 [ # # ]: 0 : seq_printf(m, " (%ld)%s",
2673 : 0 : rec->flags & ~FTRACE_FL_MASK,
2674 : 0 : rec->flags & FTRACE_FL_REGS ? " R" : "");
2675 : 0 : seq_printf(m, "\n");
2676 : :
2677 : 0 : return 0;
2678 : : }
2679 : :
2680 : : static const struct seq_operations show_ftrace_seq_ops = {
2681 : : .start = t_start,
2682 : : .next = t_next,
2683 : : .stop = t_stop,
2684 : : .show = t_show,
2685 : : };
2686 : :
2687 : : static int
2688 : 0 : ftrace_avail_open(struct inode *inode, struct file *file)
2689 : : {
2690 : : struct ftrace_iterator *iter;
2691 : :
2692 [ # # ]: 0 : if (unlikely(ftrace_disabled))
2693 : : return -ENODEV;
2694 : :
2695 : 0 : iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
2696 [ # # ]: 0 : if (iter) {
2697 : 0 : iter->pg = ftrace_pages_start;
2698 : 0 : iter->ops = &global_ops;
2699 : : }
2700 : :
2701 [ # # ]: 0 : return iter ? 0 : -ENOMEM;
2702 : : }
2703 : :
2704 : : static int
2705 : 0 : ftrace_enabled_open(struct inode *inode, struct file *file)
2706 : : {
2707 : : struct ftrace_iterator *iter;
2708 : :
2709 [ # # ]: 0 : if (unlikely(ftrace_disabled))
2710 : : return -ENODEV;
2711 : :
2712 : 0 : iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
2713 [ # # ]: 0 : if (iter) {
2714 : 0 : iter->pg = ftrace_pages_start;
2715 : 0 : iter->flags = FTRACE_ITER_ENABLED;
2716 : 0 : iter->ops = &global_ops;
2717 : : }
2718 : :
2719 [ # # ]: 0 : return iter ? 0 : -ENOMEM;
2720 : : }
2721 : :
2722 : 0 : static void ftrace_filter_reset(struct ftrace_hash *hash)
2723 : : {
2724 : 0 : mutex_lock(&ftrace_lock);
2725 : 0 : ftrace_hash_clear(hash);
2726 : 0 : mutex_unlock(&ftrace_lock);
2727 : 0 : }
2728 : :
2729 : : /**
2730 : : * ftrace_regex_open - initialize function tracer filter files
2731 : : * @ops: The ftrace_ops that hold the hash filters
2732 : : * @flag: The type of filter to process
2733 : : * @inode: The inode, usually passed in to your open routine
2734 : : * @file: The file, usually passed in to your open routine
2735 : : *
2736 : : * ftrace_regex_open() initializes the filter files for the
2737 : : * @ops. Depending on @flag it may process the filter hash or
2738 : : * the notrace hash of @ops. With this called from the open
2739 : : * routine, you can use ftrace_filter_write() for the write
2740 : : * routine if @flag has FTRACE_ITER_FILTER set, or
2741 : : * ftrace_notrace_write() if @flag has FTRACE_ITER_NOTRACE set.
2742 : : * ftrace_filter_lseek() should be used as the lseek routine, and
2743 : : * release must call ftrace_regex_release().
2744 : : */
2745 : : int
2746 : 0 : ftrace_regex_open(struct ftrace_ops *ops, int flag,
2747 : : struct inode *inode, struct file *file)
2748 : : {
2749 : : struct ftrace_iterator *iter;
2750 : : struct ftrace_hash *hash;
2751 : : int ret = 0;
2752 : :
2753 : : ftrace_ops_init(ops);
2754 : :
2755 [ # # ]: 0 : if (unlikely(ftrace_disabled))
2756 : : return -ENODEV;
2757 : :
2758 : : iter = kzalloc(sizeof(*iter), GFP_KERNEL);
2759 [ # # ]: 0 : if (!iter)
2760 : : return -ENOMEM;
2761 : :
2762 [ # # ]: 0 : if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX)) {
2763 : 0 : kfree(iter);
2764 : 0 : return -ENOMEM;
2765 : : }
2766 : :
2767 : 0 : iter->ops = ops;
2768 : 0 : iter->flags = flag;
2769 : :
2770 : 0 : mutex_lock(&ops->regex_lock);
2771 : :
2772 [ # # ]: 0 : if (flag & FTRACE_ITER_NOTRACE)
2773 : 0 : hash = ops->notrace_hash;
2774 : : else
2775 : 0 : hash = ops->filter_hash;
2776 : :
2777 [ # # ]: 0 : if (file->f_mode & FMODE_WRITE) {
2778 : 0 : iter->hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, hash);
2779 [ # # ]: 0 : if (!iter->hash) {
2780 : 0 : trace_parser_put(&iter->parser);
2781 : 0 : kfree(iter);
2782 : : ret = -ENOMEM;
2783 : 0 : goto out_unlock;
2784 : : }
2785 : : }
2786 : :
2787 [ # # ][ # # ]: 0 : if ((file->f_mode & FMODE_WRITE) &&
2788 : 0 : (file->f_flags & O_TRUNC))
2789 : 0 : ftrace_filter_reset(iter->hash);
2790 : :
2791 [ # # ]: 0 : if (file->f_mode & FMODE_READ) {
2792 : 0 : iter->pg = ftrace_pages_start;
2793 : :
2794 : 0 : ret = seq_open(file, &show_ftrace_seq_ops);
2795 [ # # ]: 0 : if (!ret) {
2796 : 0 : struct seq_file *m = file->private_data;
2797 : 0 : m->private = iter;
2798 : : } else {
2799 : : /* Failed */
2800 : 0 : free_ftrace_hash(iter->hash);
2801 : 0 : trace_parser_put(&iter->parser);
2802 : 0 : kfree(iter);
2803 : : }
2804 : : } else
2805 : 0 : file->private_data = iter;
2806 : :
2807 : : out_unlock:
2808 : 0 : mutex_unlock(&ops->regex_lock);
2809 : :
2810 : 0 : return ret;
2811 : : }
2812 : :
2813 : : static int
2814 : 0 : ftrace_filter_open(struct inode *inode, struct file *file)
2815 : : {
2816 : 0 : return ftrace_regex_open(&global_ops,
2817 : : FTRACE_ITER_FILTER | FTRACE_ITER_DO_HASH,
2818 : : inode, file);
2819 : : }
2820 : :
2821 : : static int
2822 : 0 : ftrace_notrace_open(struct inode *inode, struct file *file)
2823 : : {
2824 : 0 : return ftrace_regex_open(&global_ops, FTRACE_ITER_NOTRACE,
2825 : : inode, file);
2826 : : }
2827 : :
2828 : 0 : static int ftrace_match(char *str, char *regex, int len, int type)
2829 : : {
2830 : : int matched = 0;
2831 : : int slen;
2832 : :
2833 [ # # # # : 0 : switch (type) {
# ]
2834 : : case MATCH_FULL:
2835 [ # # ]: 0 : if (strcmp(str, regex) == 0)
2836 : : matched = 1;
2837 : : break;
2838 : : case MATCH_FRONT_ONLY:
2839 [ # # ]: 0 : if (strncmp(str, regex, len) == 0)
2840 : : matched = 1;
2841 : : break;
2842 : : case MATCH_MIDDLE_ONLY:
2843 [ # # ]: 0 : if (strstr(str, regex))
2844 : : matched = 1;
2845 : : break;
2846 : : case MATCH_END_ONLY:
2847 : 0 : slen = strlen(str);
2848 [ # # ][ # # ]: 0 : if (slen >= len && memcmp(str + slen - len, regex, len) == 0)
2849 : : matched = 1;
2850 : : break;
2851 : : }
2852 : :
2853 : 0 : return matched;
2854 : : }
2855 : :
2856 : : static int
2857 : 0 : enter_record(struct ftrace_hash *hash, struct dyn_ftrace *rec, int not)
2858 : : {
2859 : : struct ftrace_func_entry *entry;
2860 : : int ret = 0;
2861 : :
2862 : 0 : entry = ftrace_lookup_ip(hash, rec->ip);
2863 [ # # ]: 0 : if (not) {
2864 : : /* Do nothing if it doesn't exist */
2865 [ # # ]: 0 : if (!entry)
2866 : : return 0;
2867 : :
2868 : 0 : free_hash_entry(hash, entry);
2869 : : } else {
2870 : : /* Do nothing if it exists */
2871 [ # # ]: 0 : if (entry)
2872 : : return 0;
2873 : :
2874 : 0 : ret = add_hash_entry(hash, rec->ip);
2875 : : }
2876 : : return ret;
2877 : : }
2878 : :
2879 : : static int
2880 : 0 : ftrace_match_record(struct dyn_ftrace *rec, char *mod,
2881 : : char *regex, int len, int type)
2882 : : {
2883 : : char str[KSYM_SYMBOL_LEN];
2884 : : char *modname;
2885 : :
2886 : 0 : kallsyms_lookup(rec->ip, NULL, NULL, &modname, str);
2887 : :
2888 [ # # ]: 0 : if (mod) {
2889 : : /* module lookup requires matching the module */
2890 [ # # ][ # # ]: 0 : if (!modname || strcmp(modname, mod))
2891 : : return 0;
2892 : :
2893 : : /* blank search means to match all funcs in the mod */
2894 [ # # ]: 0 : if (!len)
2895 : : return 1;
2896 : : }
2897 : :
2898 : 0 : return ftrace_match(str, regex, len, type);
2899 : : }
2900 : :
2901 : : static int
2902 : 0 : match_records(struct ftrace_hash *hash, char *buff,
2903 : : int len, char *mod, int not)
2904 : : {
2905 : : unsigned search_len = 0;
2906 : : struct ftrace_page *pg;
2907 : 0 : struct dyn_ftrace *rec;
2908 : : int type = MATCH_FULL;
2909 : 0 : char *search = buff;
2910 : : int found = 0;
2911 : : int ret;
2912 : :
2913 [ # # ]: 0 : if (len) {
2914 : 0 : type = filter_parse_regex(buff, len, &search, ¬);
2915 : 0 : search_len = strlen(search);
2916 : : }
2917 : :
2918 : 0 : mutex_lock(&ftrace_lock);
2919 : :
2920 [ # # ]: 0 : if (unlikely(ftrace_disabled))
2921 : : goto out_unlock;
2922 : :
2923 [ # # ][ # # ]: 0 : do_for_each_ftrace_rec(pg, rec) {
2924 [ # # ]: 0 : if (ftrace_match_record(rec, mod, search, search_len, type)) {
2925 : 0 : ret = enter_record(hash, rec, not);
2926 [ # # ]: 0 : if (ret < 0) {
2927 : : found = ret;
2928 : : goto out_unlock;
2929 : : }
2930 : : found = 1;
2931 : : }
2932 : : } while_for_each_ftrace_rec();
2933 : : out_unlock:
2934 : 0 : mutex_unlock(&ftrace_lock);
2935 : :
2936 : 0 : return found;
2937 : : }
2938 : :
2939 : : static int
2940 : : ftrace_match_records(struct ftrace_hash *hash, char *buff, int len)
2941 : : {
2942 : 0 : return match_records(hash, buff, len, NULL, 0);
2943 : : }
2944 : :
2945 : : static int
2946 : 0 : ftrace_match_module_records(struct ftrace_hash *hash, char *buff, char *mod)
2947 : : {
2948 : : int not = 0;
2949 : :
2950 : : /* blank or '*' mean the same */
2951 [ # # ]: 0 : if (strcmp(buff, "*") == 0)
2952 : 0 : buff[0] = 0;
2953 : :
2954 : : /* handle the case of 'dont filter this module' */
2955 [ # # ][ # # ]: 0 : if (strcmp(buff, "!") == 0 || strcmp(buff, "!*") == 0) {
2956 : 0 : buff[0] = 0;
2957 : : not = 1;
2958 : : }
2959 : :
2960 : 0 : return match_records(hash, buff, strlen(buff), mod, not);
2961 : : }
2962 : :
2963 : : /*
2964 : : * We register the module command as a template to show others how
2965 : : * to register the a command as well.
2966 : : */
2967 : :
2968 : : static int
2969 : 0 : ftrace_mod_callback(struct ftrace_hash *hash,
2970 : : char *func, char *cmd, char *param, int enable)
2971 : : {
2972 : : char *mod;
2973 : : int ret = -EINVAL;
2974 : :
2975 : : /*
2976 : : * cmd == 'mod' because we only registered this func
2977 : : * for the 'mod' ftrace_func_command.
2978 : : * But if you register one func with multiple commands,
2979 : : * you can tell which command was used by the cmd
2980 : : * parameter.
2981 : : */
2982 : :
2983 : : /* we must have a module name */
2984 [ # # ]: 0 : if (!param)
2985 : : return ret;
2986 : :
2987 : 0 : mod = strsep(¶m, ":");
2988 [ # # ]: 0 : if (!strlen(mod))
2989 : : return ret;
2990 : :
2991 : 0 : ret = ftrace_match_module_records(hash, func, mod);
2992 [ # # ]: 0 : if (!ret)
2993 : : ret = -EINVAL;
2994 [ # # ]: 0 : if (ret < 0)
2995 : 0 : return ret;
2996 : :
2997 : : return 0;
2998 : : }
2999 : :
3000 : : static struct ftrace_func_command ftrace_mod_cmd = {
3001 : : .name = "mod",
3002 : : .func = ftrace_mod_callback,
3003 : : };
3004 : :
3005 : 0 : static int __init ftrace_mod_cmd_init(void)
3006 : : {
3007 : 0 : return register_ftrace_command(&ftrace_mod_cmd);
3008 : : }
3009 : : core_initcall(ftrace_mod_cmd_init);
3010 : :
3011 : 0 : static void function_trace_probe_call(unsigned long ip, unsigned long parent_ip,
3012 : : struct ftrace_ops *op, struct pt_regs *pt_regs)
3013 : : {
3014 : : struct ftrace_func_probe *entry;
3015 : : struct hlist_head *hhd;
3016 : : unsigned long key;
3017 : :
3018 : : key = hash_long(ip, FTRACE_HASH_BITS);
3019 : :
3020 : 0 : hhd = &ftrace_func_hash[key];
3021 : :
3022 [ # # ]: 0 : if (hlist_empty(hhd))
3023 : 0 : return;
3024 : :
3025 : : /*
3026 : : * Disable preemption for these calls to prevent a RCU grace
3027 : : * period. This syncs the hash iteration and freeing of items
3028 : : * on the hash. rcu_read_lock is too dangerous here.
3029 : : */
3030 : 0 : preempt_disable_notrace();
3031 [ # # ][ # # ]: 0 : hlist_for_each_entry_rcu_notrace(entry, hhd, node) {
[ # # ]
3032 [ # # ]: 0 : if (entry->ip == ip)
3033 : 0 : entry->ops->func(ip, parent_ip, &entry->data);
3034 : : }
3035 : 0 : preempt_enable_notrace();
3036 : : }
3037 : :
3038 : : static struct ftrace_ops trace_probe_ops __read_mostly =
3039 : : {
3040 : : .func = function_trace_probe_call,
3041 : : .flags = FTRACE_OPS_FL_INITIALIZED,
3042 : : INIT_REGEX_LOCK(trace_probe_ops)
3043 : : };
3044 : :
3045 : : static int ftrace_probe_registered;
3046 : :
3047 : 0 : static void __enable_ftrace_function_probe(void)
3048 : : {
3049 : : int ret;
3050 : : int i;
3051 : :
3052 [ # # ]: 0 : if (ftrace_probe_registered) {
3053 : : /* still need to update the function call sites */
3054 [ # # ]: 0 : if (ftrace_enabled)
3055 : 0 : ftrace_run_update_code(FTRACE_UPDATE_CALLS);
3056 : : return;
3057 : : }
3058 : :
3059 [ # # ]: 0 : for (i = 0; i < FTRACE_FUNC_HASHSIZE; i++) {
3060 : 0 : struct hlist_head *hhd = &ftrace_func_hash[i];
3061 [ # # ]: 0 : if (hhd->first)
3062 : : break;
3063 : : }
3064 : : /* Nothing registered? */
3065 [ # # ]: 0 : if (i == FTRACE_FUNC_HASHSIZE)
3066 : : return;
3067 : :
3068 : 0 : ret = ftrace_startup(&trace_probe_ops, 0);
3069 : :
3070 : 0 : ftrace_probe_registered = 1;
3071 : : }
3072 : :
3073 : 0 : static void __disable_ftrace_function_probe(void)
3074 : : {
3075 : : int i;
3076 : :
3077 [ # # ]: 0 : if (!ftrace_probe_registered)
3078 : : return;
3079 : :
3080 [ # # ]: 0 : for (i = 0; i < FTRACE_FUNC_HASHSIZE; i++) {
3081 : 0 : struct hlist_head *hhd = &ftrace_func_hash[i];
3082 [ # # ]: 0 : if (hhd->first)
3083 : : return;
3084 : : }
3085 : :
3086 : : /* no more funcs left */
3087 : 0 : ftrace_shutdown(&trace_probe_ops, 0);
3088 : :
3089 : 0 : ftrace_probe_registered = 0;
3090 : : }
3091 : :
3092 : :
3093 : 0 : static void ftrace_free_entry(struct ftrace_func_probe *entry)
3094 : : {
3095 [ # # ]: 0 : if (entry->ops->free)
3096 : 0 : entry->ops->free(entry->ops, entry->ip, &entry->data);
3097 : 0 : kfree(entry);
3098 : 0 : }
3099 : :
3100 : : int
3101 : 0 : register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
3102 : : void *data)
3103 : : {
3104 : : struct ftrace_func_probe *entry;
3105 : : struct ftrace_hash **orig_hash = &trace_probe_ops.filter_hash;
3106 : : struct ftrace_hash *hash;
3107 : : struct ftrace_page *pg;
3108 : 0 : struct dyn_ftrace *rec;
3109 : : int type, len, not;
3110 : : unsigned long key;
3111 : : int count = 0;
3112 : : char *search;
3113 : : int ret;
3114 : :
3115 : 0 : type = filter_parse_regex(glob, strlen(glob), &search, ¬);
3116 : 0 : len = strlen(search);
3117 : :
3118 : : /* we do not support '!' for function probes */
3119 [ # # ][ # # ]: 0 : if (WARN_ON(not))
3120 : : return -EINVAL;
3121 : :
3122 : 0 : mutex_lock(&trace_probe_ops.regex_lock);
3123 : :
3124 : 0 : hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash);
3125 [ # # ]: 0 : if (!hash) {
3126 : : count = -ENOMEM;
3127 : : goto out;
3128 : : }
3129 : :
3130 [ # # ]: 0 : if (unlikely(ftrace_disabled)) {
3131 : : count = -ENODEV;
3132 : : goto out;
3133 : : }
3134 : :
3135 : 0 : mutex_lock(&ftrace_lock);
3136 : :
3137 [ # # ][ # # ]: 0 : do_for_each_ftrace_rec(pg, rec) {
3138 : :
3139 [ # # ]: 0 : if (!ftrace_match_record(rec, NULL, search, len, type))
3140 : 0 : continue;
3141 : :
3142 : : entry = kmalloc(sizeof(*entry), GFP_KERNEL);
3143 [ # # ]: 0 : if (!entry) {
3144 : : /* If we did not process any, then return error */
3145 [ # # ]: 0 : if (!count)
3146 : : count = -ENOMEM;
3147 : : goto out_unlock;
3148 : : }
3149 : :
3150 : 0 : count++;
3151 : :
3152 : 0 : entry->data = data;
3153 : :
3154 : : /*
3155 : : * The caller might want to do something special
3156 : : * for each function we find. We call the callback
3157 : : * to give the caller an opportunity to do so.
3158 : : */
3159 [ # # ]: 0 : if (ops->init) {
3160 [ # # ]: 0 : if (ops->init(ops, rec->ip, &entry->data) < 0) {
3161 : : /* caller does not like this func */
3162 : 0 : kfree(entry);
3163 : 0 : continue;
3164 : : }
3165 : : }
3166 : :
3167 : 0 : ret = enter_record(hash, rec, 0);
3168 [ # # ]: 0 : if (ret < 0) {
3169 : 0 : kfree(entry);
3170 : : count = ret;
3171 : 0 : goto out_unlock;
3172 : : }
3173 : :
3174 : 0 : entry->ops = ops;
3175 : 0 : entry->ip = rec->ip;
3176 : :
3177 : : key = hash_long(entry->ip, FTRACE_HASH_BITS);
3178 : 0 : hlist_add_head_rcu(&entry->node, &ftrace_func_hash[key]);
3179 : :
3180 : : } while_for_each_ftrace_rec();
3181 : :
3182 : 0 : ret = ftrace_hash_move(&trace_probe_ops, 1, orig_hash, hash);
3183 [ # # ]: 0 : if (ret < 0)
3184 : : count = ret;
3185 : :
3186 : 0 : __enable_ftrace_function_probe();
3187 : :
3188 : : out_unlock:
3189 : 0 : mutex_unlock(&ftrace_lock);
3190 : : out:
3191 : 0 : mutex_unlock(&trace_probe_ops.regex_lock);
3192 : 0 : free_ftrace_hash(hash);
3193 : :
3194 : 0 : return count;
3195 : : }
3196 : :
3197 : : enum {
3198 : : PROBE_TEST_FUNC = 1,
3199 : : PROBE_TEST_DATA = 2
3200 : : };
3201 : :
3202 : : static void
3203 : 0 : __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
3204 : : void *data, int flags)
3205 : : {
3206 : : struct ftrace_func_entry *rec_entry;
3207 : : struct ftrace_func_probe *entry;
3208 : : struct ftrace_func_probe *p;
3209 : : struct ftrace_hash **orig_hash = &trace_probe_ops.filter_hash;
3210 : : struct list_head free_list;
3211 : : struct ftrace_hash *hash;
3212 : : struct hlist_node *tmp;
3213 : : char str[KSYM_SYMBOL_LEN];
3214 : : int type = MATCH_FULL;
3215 : : int i, len = 0;
3216 : : char *search;
3217 : :
3218 [ # # ][ # # ]: 0 : if (glob && (strcmp(glob, "*") == 0 || !strlen(glob)))
[ # # ]
3219 : : glob = NULL;
3220 [ # # ]: 0 : else if (glob) {
3221 : : int not;
3222 : :
3223 : 0 : type = filter_parse_regex(glob, strlen(glob), &search, ¬);
3224 : 0 : len = strlen(search);
3225 : :
3226 : : /* we do not support '!' for function probes */
3227 [ # # ][ # # ]: 0 : if (WARN_ON(not))
3228 : 0 : return;
3229 : : }
3230 : :
3231 : 0 : mutex_lock(&trace_probe_ops.regex_lock);
3232 : :
3233 : 0 : hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash);
3234 [ # # ]: 0 : if (!hash)
3235 : : /* Hmm, should report this somehow */
3236 : : goto out_unlock;
3237 : :
3238 : : INIT_LIST_HEAD(&free_list);
3239 : :
3240 [ # # ]: 0 : for (i = 0; i < FTRACE_FUNC_HASHSIZE; i++) {
3241 : 0 : struct hlist_head *hhd = &ftrace_func_hash[i];
3242 : :
3243 [ # # ][ # # ]: 0 : hlist_for_each_entry_safe(entry, tmp, hhd, node) {
[ # # ]
3244 : :
3245 : : /* break up if statements for readability */
3246 [ # # ][ # # ]: 0 : if ((flags & PROBE_TEST_FUNC) && entry->ops != ops)
3247 : 0 : continue;
3248 : :
3249 [ # # ][ # # ]: 0 : if ((flags & PROBE_TEST_DATA) && entry->data != data)
3250 : 0 : continue;
3251 : :
3252 : : /* do this last, since it is the most expensive */
3253 [ # # ]: 0 : if (glob) {
3254 : 0 : kallsyms_lookup(entry->ip, NULL, NULL,
3255 : : NULL, str);
3256 [ # # ]: 0 : if (!ftrace_match(str, glob, len, type))
3257 : 0 : continue;
3258 : : }
3259 : :
3260 : 0 : rec_entry = ftrace_lookup_ip(hash, entry->ip);
3261 : : /* It is possible more than one entry had this ip */
3262 [ # # ]: 0 : if (rec_entry)
3263 : 0 : free_hash_entry(hash, rec_entry);
3264 : :
3265 : : hlist_del_rcu(&entry->node);
3266 : 0 : list_add(&entry->free_list, &free_list);
3267 : : }
3268 : : }
3269 : 0 : mutex_lock(&ftrace_lock);
3270 : 0 : __disable_ftrace_function_probe();
3271 : : /*
3272 : : * Remove after the disable is called. Otherwise, if the last
3273 : : * probe is removed, a null hash means *all enabled*.
3274 : : */
3275 : 0 : ftrace_hash_move(&trace_probe_ops, 1, orig_hash, hash);
3276 : 0 : synchronize_sched();
3277 [ # # ]: 0 : list_for_each_entry_safe(entry, p, &free_list, free_list) {
3278 : : list_del(&entry->free_list);
3279 : 0 : ftrace_free_entry(entry);
3280 : : }
3281 : 0 : mutex_unlock(&ftrace_lock);
3282 : :
3283 : : out_unlock:
3284 : 0 : mutex_unlock(&trace_probe_ops.regex_lock);
3285 : 0 : free_ftrace_hash(hash);
3286 : : }
3287 : :
3288 : : void
3289 : 0 : unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
3290 : : void *data)
3291 : : {
3292 : 0 : __unregister_ftrace_function_probe(glob, ops, data,
3293 : : PROBE_TEST_FUNC | PROBE_TEST_DATA);
3294 : 0 : }
3295 : :
3296 : : void
3297 : 0 : unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops)
3298 : : {
3299 : 0 : __unregister_ftrace_function_probe(glob, ops, NULL, PROBE_TEST_FUNC);
3300 : 0 : }
3301 : :
3302 : 0 : void unregister_ftrace_function_probe_all(char *glob)
3303 : : {
3304 : 0 : __unregister_ftrace_function_probe(glob, NULL, NULL, 0);
3305 : 0 : }
3306 : :
3307 : : static LIST_HEAD(ftrace_commands);
3308 : : static DEFINE_MUTEX(ftrace_cmd_mutex);
3309 : :
3310 : : /*
3311 : : * Currently we only register ftrace commands from __init, so mark this
3312 : : * __init too.
3313 : : */
3314 : 0 : __init int register_ftrace_command(struct ftrace_func_command *cmd)
3315 : : {
3316 : : struct ftrace_func_command *p;
3317 : : int ret = 0;
3318 : :
3319 : 0 : mutex_lock(&ftrace_cmd_mutex);
3320 [ # # ]: 0 : list_for_each_entry(p, &ftrace_commands, list) {
3321 [ # # ]: 0 : if (strcmp(cmd->name, p->name) == 0) {
3322 : : ret = -EBUSY;
3323 : : goto out_unlock;
3324 : : }
3325 : : }
3326 : 0 : list_add(&cmd->list, &ftrace_commands);
3327 : : out_unlock:
3328 : 0 : mutex_unlock(&ftrace_cmd_mutex);
3329 : :
3330 : 0 : return ret;
3331 : : }
3332 : :
3333 : : /*
3334 : : * Currently we only unregister ftrace commands from __init, so mark
3335 : : * this __init too.
3336 : : */
3337 : 0 : __init int unregister_ftrace_command(struct ftrace_func_command *cmd)
3338 : : {
3339 : : struct ftrace_func_command *p, *n;
3340 : : int ret = -ENODEV;
3341 : :
3342 : 0 : mutex_lock(&ftrace_cmd_mutex);
3343 [ # # ]: 0 : list_for_each_entry_safe(p, n, &ftrace_commands, list) {
3344 [ # # ]: 0 : if (strcmp(cmd->name, p->name) == 0) {
3345 : : ret = 0;
3346 : : list_del_init(&p->list);
3347 : : goto out_unlock;
3348 : : }
3349 : : }
3350 : : out_unlock:
3351 : 0 : mutex_unlock(&ftrace_cmd_mutex);
3352 : :
3353 : 0 : return ret;
3354 : : }
3355 : :
3356 : 0 : static int ftrace_process_regex(struct ftrace_hash *hash,
3357 : : char *buff, int len, int enable)
3358 : : {
3359 : 0 : char *func, *command, *next = buff;
3360 : : struct ftrace_func_command *p;
3361 : : int ret = -EINVAL;
3362 : :
3363 : 0 : func = strsep(&next, ":");
3364 : :
3365 [ # # ]: 0 : if (!next) {
3366 : : ret = ftrace_match_records(hash, func, len);
3367 [ # # ]: 0 : if (!ret)
3368 : : ret = -EINVAL;
3369 [ # # ]: 0 : if (ret < 0)
3370 : 0 : return ret;
3371 : : return 0;
3372 : : }
3373 : :
3374 : : /* command found */
3375 : :
3376 : 0 : command = strsep(&next, ":");
3377 : :
3378 : 0 : mutex_lock(&ftrace_cmd_mutex);
3379 [ # # ]: 0 : list_for_each_entry(p, &ftrace_commands, list) {
3380 [ # # ]: 0 : if (strcmp(p->name, command) == 0) {
3381 : 0 : ret = p->func(hash, func, command, next, enable);
3382 : 0 : goto out_unlock;
3383 : : }
3384 : : }
3385 : : out_unlock:
3386 : 0 : mutex_unlock(&ftrace_cmd_mutex);
3387 : :
3388 : 0 : return ret;
3389 : : }
3390 : :
3391 : : static ssize_t
3392 : 0 : ftrace_regex_write(struct file *file, const char __user *ubuf,
3393 : : size_t cnt, loff_t *ppos, int enable)
3394 : : {
3395 : : struct ftrace_iterator *iter;
3396 : 0 : struct trace_parser *parser;
3397 : : ssize_t ret, read;
3398 : :
3399 [ # # ]: 0 : if (!cnt)
3400 : : return 0;
3401 : :
3402 [ # # ]: 0 : if (file->f_mode & FMODE_READ) {
3403 : 0 : struct seq_file *m = file->private_data;
3404 : 0 : iter = m->private;
3405 : : } else
3406 : 0 : iter = file->private_data;
3407 : :
3408 [ # # ]: 0 : if (unlikely(ftrace_disabled))
3409 : : return -ENODEV;
3410 : :
3411 : : /* iter->hash is a local copy, so we don't need regex_lock */
3412 : :
3413 : 0 : parser = &iter->parser;
3414 : 0 : read = trace_get_user(parser, ubuf, cnt, ppos);
3415 : :
3416 [ # # ][ # # ]: 0 : if (read >= 0 && trace_parser_loaded(parser) &&
[ # # ]
3417 : : !trace_parser_cont(parser)) {
3418 : 0 : ret = ftrace_process_regex(iter->hash, parser->buffer,
3419 : : parser->idx, enable);
3420 : : trace_parser_clear(parser);
3421 [ # # ]: 0 : if (ret < 0)
3422 : : goto out;
3423 : : }
3424 : :
3425 : : ret = read;
3426 : : out:
3427 : : return ret;
3428 : : }
3429 : :
3430 : : ssize_t
3431 : 0 : ftrace_filter_write(struct file *file, const char __user *ubuf,
3432 : : size_t cnt, loff_t *ppos)
3433 : : {
3434 : 0 : return ftrace_regex_write(file, ubuf, cnt, ppos, 1);
3435 : : }
3436 : :
3437 : : ssize_t
3438 : 0 : ftrace_notrace_write(struct file *file, const char __user *ubuf,
3439 : : size_t cnt, loff_t *ppos)
3440 : : {
3441 : 0 : return ftrace_regex_write(file, ubuf, cnt, ppos, 0);
3442 : : }
3443 : :
3444 : : static int
3445 : 0 : ftrace_match_addr(struct ftrace_hash *hash, unsigned long ip, int remove)
3446 : : {
3447 : : struct ftrace_func_entry *entry;
3448 : :
3449 [ # # ]: 0 : if (!ftrace_location(ip))
3450 : : return -EINVAL;
3451 : :
3452 [ # # ]: 0 : if (remove) {
3453 : 0 : entry = ftrace_lookup_ip(hash, ip);
3454 [ # # ]: 0 : if (!entry)
3455 : : return -ENOENT;
3456 : 0 : free_hash_entry(hash, entry);
3457 : 0 : return 0;
3458 : : }
3459 : :
3460 : 0 : return add_hash_entry(hash, ip);
3461 : : }
3462 : :
3463 : 0 : static void ftrace_ops_update_code(struct ftrace_ops *ops)
3464 : : {
3465 [ # # ][ # # ]: 0 : if (ops->flags & FTRACE_OPS_FL_ENABLED && ftrace_enabled)
3466 : 0 : ftrace_run_update_code(FTRACE_UPDATE_CALLS);
3467 : 0 : }
3468 : :
3469 : : static int
3470 : 0 : ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len,
3471 : : unsigned long ip, int remove, int reset, int enable)
3472 : : {
3473 : : struct ftrace_hash **orig_hash;
3474 : : struct ftrace_hash *hash;
3475 : : int ret;
3476 : :
3477 : : /* All global ops uses the global ops filters */
3478 [ # # ]: 0 : if (ops->flags & FTRACE_OPS_FL_GLOBAL)
3479 : : ops = &global_ops;
3480 : :
3481 [ # # ]: 0 : if (unlikely(ftrace_disabled))
3482 : : return -ENODEV;
3483 : :
3484 : 0 : mutex_lock(&ops->regex_lock);
3485 : :
3486 [ # # ]: 0 : if (enable)
3487 : 0 : orig_hash = &ops->filter_hash;
3488 : : else
3489 : 0 : orig_hash = &ops->notrace_hash;
3490 : :
3491 : 0 : hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash);
3492 [ # # ]: 0 : if (!hash) {
3493 : : ret = -ENOMEM;
3494 : : goto out_regex_unlock;
3495 : : }
3496 : :
3497 [ # # ]: 0 : if (reset)
3498 : 0 : ftrace_filter_reset(hash);
3499 [ # # # # ]: 0 : if (buf && !ftrace_match_records(hash, buf, len)) {
3500 : : ret = -EINVAL;
3501 : : goto out_regex_unlock;
3502 : : }
3503 [ # # ]: 0 : if (ip) {
3504 : 0 : ret = ftrace_match_addr(hash, ip, remove);
3505 [ # # ]: 0 : if (ret < 0)
3506 : : goto out_regex_unlock;
3507 : : }
3508 : :
3509 : 0 : mutex_lock(&ftrace_lock);
3510 : 0 : ret = ftrace_hash_move(ops, enable, orig_hash, hash);
3511 [ # # ]: 0 : if (!ret)
3512 : 0 : ftrace_ops_update_code(ops);
3513 : :
3514 : 0 : mutex_unlock(&ftrace_lock);
3515 : :
3516 : : out_regex_unlock:
3517 : 0 : mutex_unlock(&ops->regex_lock);
3518 : :
3519 : 0 : free_ftrace_hash(hash);
3520 : 0 : return ret;
3521 : : }
3522 : :
3523 : : static int
3524 : : ftrace_set_addr(struct ftrace_ops *ops, unsigned long ip, int remove,
3525 : : int reset, int enable)
3526 : : {
3527 : 0 : return ftrace_set_hash(ops, 0, 0, ip, remove, reset, enable);
3528 : : }
3529 : :
3530 : : /**
3531 : : * ftrace_set_filter_ip - set a function to filter on in ftrace by address
3532 : : * @ops - the ops to set the filter with
3533 : : * @ip - the address to add to or remove from the filter.
3534 : : * @remove - non zero to remove the ip from the filter
3535 : : * @reset - non zero to reset all filters before applying this filter.
3536 : : *
3537 : : * Filters denote which functions should be enabled when tracing is enabled
3538 : : * If @ip is NULL, it failes to update filter.
3539 : : */
3540 : 0 : int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,
3541 : : int remove, int reset)
3542 : : {
3543 : : ftrace_ops_init(ops);
3544 : 0 : return ftrace_set_addr(ops, ip, remove, reset, 1);
3545 : : }
3546 : : EXPORT_SYMBOL_GPL(ftrace_set_filter_ip);
3547 : :
3548 : : static int
3549 : : ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len,
3550 : : int reset, int enable)
3551 : : {
3552 : 0 : return ftrace_set_hash(ops, buf, len, 0, 0, reset, enable);
3553 : : }
3554 : :
3555 : : /**
3556 : : * ftrace_set_filter - set a function to filter on in ftrace
3557 : : * @ops - the ops to set the filter with
3558 : : * @buf - the string that holds the function filter text.
3559 : : * @len - the length of the string.
3560 : : * @reset - non zero to reset all filters before applying this filter.
3561 : : *
3562 : : * Filters denote which functions should be enabled when tracing is enabled.
3563 : : * If @buf is NULL and reset is set, all functions will be enabled for tracing.
3564 : : */
3565 : 0 : int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
3566 : : int len, int reset)
3567 : : {
3568 : : ftrace_ops_init(ops);
3569 : 0 : return ftrace_set_regex(ops, buf, len, reset, 1);
3570 : : }
3571 : : EXPORT_SYMBOL_GPL(ftrace_set_filter);
3572 : :
3573 : : /**
3574 : : * ftrace_set_notrace - set a function to not trace in ftrace
3575 : : * @ops - the ops to set the notrace filter with
3576 : : * @buf - the string that holds the function notrace text.
3577 : : * @len - the length of the string.
3578 : : * @reset - non zero to reset all filters before applying this filter.
3579 : : *
3580 : : * Notrace Filters denote which functions should not be enabled when tracing
3581 : : * is enabled. If @buf is NULL and reset is set, all functions will be enabled
3582 : : * for tracing.
3583 : : */
3584 : 0 : int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
3585 : : int len, int reset)
3586 : : {
3587 : : ftrace_ops_init(ops);
3588 : 0 : return ftrace_set_regex(ops, buf, len, reset, 0);
3589 : : }
3590 : : EXPORT_SYMBOL_GPL(ftrace_set_notrace);
3591 : : /**
3592 : : * ftrace_set_filter - set a function to filter on in ftrace
3593 : : * @ops - the ops to set the filter with
3594 : : * @buf - the string that holds the function filter text.
3595 : : * @len - the length of the string.
3596 : : * @reset - non zero to reset all filters before applying this filter.
3597 : : *
3598 : : * Filters denote which functions should be enabled when tracing is enabled.
3599 : : * If @buf is NULL and reset is set, all functions will be enabled for tracing.
3600 : : */
3601 : 0 : void ftrace_set_global_filter(unsigned char *buf, int len, int reset)
3602 : : {
3603 : : ftrace_set_regex(&global_ops, buf, len, reset, 1);
3604 : 0 : }
3605 : : EXPORT_SYMBOL_GPL(ftrace_set_global_filter);
3606 : :
3607 : : /**
3608 : : * ftrace_set_notrace - set a function to not trace in ftrace
3609 : : * @ops - the ops to set the notrace filter with
3610 : : * @buf - the string that holds the function notrace text.
3611 : : * @len - the length of the string.
3612 : : * @reset - non zero to reset all filters before applying this filter.
3613 : : *
3614 : : * Notrace Filters denote which functions should not be enabled when tracing
3615 : : * is enabled. If @buf is NULL and reset is set, all functions will be enabled
3616 : : * for tracing.
3617 : : */
3618 : 0 : void ftrace_set_global_notrace(unsigned char *buf, int len, int reset)
3619 : : {
3620 : : ftrace_set_regex(&global_ops, buf, len, reset, 0);
3621 : 0 : }
3622 : : EXPORT_SYMBOL_GPL(ftrace_set_global_notrace);
3623 : :
3624 : : /*
3625 : : * command line interface to allow users to set filters on boot up.
3626 : : */
3627 : : #define FTRACE_FILTER_SIZE COMMAND_LINE_SIZE
3628 : : static char ftrace_notrace_buf[FTRACE_FILTER_SIZE] __initdata;
3629 : : static char ftrace_filter_buf[FTRACE_FILTER_SIZE] __initdata;
3630 : :
3631 : : /* Used by function selftest to not test if filter is set */
3632 : : bool ftrace_filter_param __initdata;
3633 : :
3634 : 0 : static int __init set_ftrace_notrace(char *str)
3635 : : {
3636 : 0 : ftrace_filter_param = true;
3637 : 0 : strlcpy(ftrace_notrace_buf, str, FTRACE_FILTER_SIZE);
3638 : 0 : return 1;
3639 : : }
3640 : : __setup("ftrace_notrace=", set_ftrace_notrace);
3641 : :
3642 : 0 : static int __init set_ftrace_filter(char *str)
3643 : : {
3644 : 0 : ftrace_filter_param = true;
3645 : 0 : strlcpy(ftrace_filter_buf, str, FTRACE_FILTER_SIZE);
3646 : 0 : return 1;
3647 : : }
3648 : : __setup("ftrace_filter=", set_ftrace_filter);
3649 : :
3650 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
3651 : : static char ftrace_graph_buf[FTRACE_FILTER_SIZE] __initdata;
3652 : : static int ftrace_set_func(unsigned long *array, int *idx, int size, char *buffer);
3653 : :
3654 : : static int __init set_graph_function(char *str)
3655 : : {
3656 : : strlcpy(ftrace_graph_buf, str, FTRACE_FILTER_SIZE);
3657 : : return 1;
3658 : : }
3659 : : __setup("ftrace_graph_filter=", set_graph_function);
3660 : :
3661 : : static void __init set_ftrace_early_graph(char *buf)
3662 : : {
3663 : : int ret;
3664 : : char *func;
3665 : :
3666 : : while (buf) {
3667 : : func = strsep(&buf, ",");
3668 : : /* we allow only one expression at a time */
3669 : : ret = ftrace_set_func(ftrace_graph_funcs, &ftrace_graph_count,
3670 : : FTRACE_GRAPH_MAX_FUNCS, func);
3671 : : if (ret)
3672 : : printk(KERN_DEBUG "ftrace: function %s not "
3673 : : "traceable\n", func);
3674 : : }
3675 : : }
3676 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
3677 : :
3678 : : void __init
3679 : 0 : ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable)
3680 : : {
3681 : : char *func;
3682 : :
3683 : : ftrace_ops_init(ops);
3684 : :
3685 [ # # ]: 0 : while (buf) {
3686 : 0 : func = strsep(&buf, ",");
3687 : 0 : ftrace_set_regex(ops, func, strlen(func), 0, enable);
3688 : : }
3689 : 0 : }
3690 : :
3691 : 0 : static void __init set_ftrace_early_filters(void)
3692 : : {
3693 [ # # ]: 0 : if (ftrace_filter_buf[0])
3694 : 0 : ftrace_set_early_filter(&global_ops, ftrace_filter_buf, 1);
3695 [ # # ]: 0 : if (ftrace_notrace_buf[0])
3696 : 0 : ftrace_set_early_filter(&global_ops, ftrace_notrace_buf, 0);
3697 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
3698 : : if (ftrace_graph_buf[0])
3699 : : set_ftrace_early_graph(ftrace_graph_buf);
3700 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
3701 : 0 : }
3702 : :
3703 : 0 : int ftrace_regex_release(struct inode *inode, struct file *file)
3704 : : {
3705 : 0 : struct seq_file *m = (struct seq_file *)file->private_data;
3706 : : struct ftrace_iterator *iter;
3707 : : struct ftrace_hash **orig_hash;
3708 : 0 : struct trace_parser *parser;
3709 : : int filter_hash;
3710 : : int ret;
3711 : :
3712 [ # # ]: 0 : if (file->f_mode & FMODE_READ) {
3713 : 0 : iter = m->private;
3714 : 0 : seq_release(inode, file);
3715 : : } else
3716 : : iter = file->private_data;
3717 : :
3718 : 0 : parser = &iter->parser;
3719 [ # # ]: 0 : if (trace_parser_loaded(parser)) {
3720 : 0 : parser->buffer[parser->idx] = 0;
3721 : 0 : ftrace_match_records(iter->hash, parser->buffer, parser->idx);
3722 : : }
3723 : :
3724 : 0 : trace_parser_put(parser);
3725 : :
3726 : 0 : mutex_lock(&iter->ops->regex_lock);
3727 : :
3728 [ # # ]: 0 : if (file->f_mode & FMODE_WRITE) {
3729 : 0 : filter_hash = !!(iter->flags & FTRACE_ITER_FILTER);
3730 : :
3731 [ # # ]: 0 : if (filter_hash)
3732 : 0 : orig_hash = &iter->ops->filter_hash;
3733 : : else
3734 : 0 : orig_hash = &iter->ops->notrace_hash;
3735 : :
3736 : 0 : mutex_lock(&ftrace_lock);
3737 : 0 : ret = ftrace_hash_move(iter->ops, filter_hash,
3738 : : orig_hash, iter->hash);
3739 [ # # ]: 0 : if (!ret)
3740 : 0 : ftrace_ops_update_code(iter->ops);
3741 : :
3742 : 0 : mutex_unlock(&ftrace_lock);
3743 : : }
3744 : :
3745 : 0 : mutex_unlock(&iter->ops->regex_lock);
3746 : 0 : free_ftrace_hash(iter->hash);
3747 : 0 : kfree(iter);
3748 : :
3749 : 0 : return 0;
3750 : : }
3751 : :
3752 : : static const struct file_operations ftrace_avail_fops = {
3753 : : .open = ftrace_avail_open,
3754 : : .read = seq_read,
3755 : : .llseek = seq_lseek,
3756 : : .release = seq_release_private,
3757 : : };
3758 : :
3759 : : static const struct file_operations ftrace_enabled_fops = {
3760 : : .open = ftrace_enabled_open,
3761 : : .read = seq_read,
3762 : : .llseek = seq_lseek,
3763 : : .release = seq_release_private,
3764 : : };
3765 : :
3766 : : static const struct file_operations ftrace_filter_fops = {
3767 : : .open = ftrace_filter_open,
3768 : : .read = seq_read,
3769 : : .write = ftrace_filter_write,
3770 : : .llseek = ftrace_filter_lseek,
3771 : : .release = ftrace_regex_release,
3772 : : };
3773 : :
3774 : : static const struct file_operations ftrace_notrace_fops = {
3775 : : .open = ftrace_notrace_open,
3776 : : .read = seq_read,
3777 : : .write = ftrace_notrace_write,
3778 : : .llseek = ftrace_filter_lseek,
3779 : : .release = ftrace_regex_release,
3780 : : };
3781 : :
3782 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
3783 : :
3784 : : static DEFINE_MUTEX(graph_lock);
3785 : :
3786 : : int ftrace_graph_count;
3787 : : int ftrace_graph_notrace_count;
3788 : : unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS] __read_mostly;
3789 : : unsigned long ftrace_graph_notrace_funcs[FTRACE_GRAPH_MAX_FUNCS] __read_mostly;
3790 : :
3791 : : struct ftrace_graph_data {
3792 : : unsigned long *table;
3793 : : size_t size;
3794 : : int *count;
3795 : : const struct seq_operations *seq_ops;
3796 : : };
3797 : :
3798 : : static void *
3799 : : __g_next(struct seq_file *m, loff_t *pos)
3800 : : {
3801 : : struct ftrace_graph_data *fgd = m->private;
3802 : :
3803 : : if (*pos >= *fgd->count)
3804 : : return NULL;
3805 : : return &fgd->table[*pos];
3806 : : }
3807 : :
3808 : : static void *
3809 : : g_next(struct seq_file *m, void *v, loff_t *pos)
3810 : : {
3811 : : (*pos)++;
3812 : : return __g_next(m, pos);
3813 : : }
3814 : :
3815 : : static void *g_start(struct seq_file *m, loff_t *pos)
3816 : : {
3817 : : struct ftrace_graph_data *fgd = m->private;
3818 : :
3819 : : mutex_lock(&graph_lock);
3820 : :
3821 : : /* Nothing, tell g_show to print all functions are enabled */
3822 : : if (!*fgd->count && !*pos)
3823 : : return (void *)1;
3824 : :
3825 : : return __g_next(m, pos);
3826 : : }
3827 : :
3828 : : static void g_stop(struct seq_file *m, void *p)
3829 : : {
3830 : : mutex_unlock(&graph_lock);
3831 : : }
3832 : :
3833 : : static int g_show(struct seq_file *m, void *v)
3834 : : {
3835 : : unsigned long *ptr = v;
3836 : :
3837 : : if (!ptr)
3838 : : return 0;
3839 : :
3840 : : if (ptr == (unsigned long *)1) {
3841 : : seq_printf(m, "#### all functions enabled ####\n");
3842 : : return 0;
3843 : : }
3844 : :
3845 : : seq_printf(m, "%ps\n", (void *)*ptr);
3846 : :
3847 : : return 0;
3848 : : }
3849 : :
3850 : : static const struct seq_operations ftrace_graph_seq_ops = {
3851 : : .start = g_start,
3852 : : .next = g_next,
3853 : : .stop = g_stop,
3854 : : .show = g_show,
3855 : : };
3856 : :
3857 : : static int
3858 : : __ftrace_graph_open(struct inode *inode, struct file *file,
3859 : : struct ftrace_graph_data *fgd)
3860 : : {
3861 : : int ret = 0;
3862 : :
3863 : : mutex_lock(&graph_lock);
3864 : : if ((file->f_mode & FMODE_WRITE) &&
3865 : : (file->f_flags & O_TRUNC)) {
3866 : : *fgd->count = 0;
3867 : : memset(fgd->table, 0, fgd->size * sizeof(*fgd->table));
3868 : : }
3869 : : mutex_unlock(&graph_lock);
3870 : :
3871 : : if (file->f_mode & FMODE_READ) {
3872 : : ret = seq_open(file, fgd->seq_ops);
3873 : : if (!ret) {
3874 : : struct seq_file *m = file->private_data;
3875 : : m->private = fgd;
3876 : : }
3877 : : } else
3878 : : file->private_data = fgd;
3879 : :
3880 : : return ret;
3881 : : }
3882 : :
3883 : : static int
3884 : : ftrace_graph_open(struct inode *inode, struct file *file)
3885 : : {
3886 : : struct ftrace_graph_data *fgd;
3887 : :
3888 : : if (unlikely(ftrace_disabled))
3889 : : return -ENODEV;
3890 : :
3891 : : fgd = kmalloc(sizeof(*fgd), GFP_KERNEL);
3892 : : if (fgd == NULL)
3893 : : return -ENOMEM;
3894 : :
3895 : : fgd->table = ftrace_graph_funcs;
3896 : : fgd->size = FTRACE_GRAPH_MAX_FUNCS;
3897 : : fgd->count = &ftrace_graph_count;
3898 : : fgd->seq_ops = &ftrace_graph_seq_ops;
3899 : :
3900 : : return __ftrace_graph_open(inode, file, fgd);
3901 : : }
3902 : :
3903 : : static int
3904 : : ftrace_graph_notrace_open(struct inode *inode, struct file *file)
3905 : : {
3906 : : struct ftrace_graph_data *fgd;
3907 : :
3908 : : if (unlikely(ftrace_disabled))
3909 : : return -ENODEV;
3910 : :
3911 : : fgd = kmalloc(sizeof(*fgd), GFP_KERNEL);
3912 : : if (fgd == NULL)
3913 : : return -ENOMEM;
3914 : :
3915 : : fgd->table = ftrace_graph_notrace_funcs;
3916 : : fgd->size = FTRACE_GRAPH_MAX_FUNCS;
3917 : : fgd->count = &ftrace_graph_notrace_count;
3918 : : fgd->seq_ops = &ftrace_graph_seq_ops;
3919 : :
3920 : : return __ftrace_graph_open(inode, file, fgd);
3921 : : }
3922 : :
3923 : : static int
3924 : : ftrace_graph_release(struct inode *inode, struct file *file)
3925 : : {
3926 : : if (file->f_mode & FMODE_READ) {
3927 : : struct seq_file *m = file->private_data;
3928 : :
3929 : : kfree(m->private);
3930 : : seq_release(inode, file);
3931 : : } else {
3932 : : kfree(file->private_data);
3933 : : }
3934 : :
3935 : : return 0;
3936 : : }
3937 : :
3938 : : static int
3939 : : ftrace_set_func(unsigned long *array, int *idx, int size, char *buffer)
3940 : : {
3941 : : struct dyn_ftrace *rec;
3942 : : struct ftrace_page *pg;
3943 : : int search_len;
3944 : : int fail = 1;
3945 : : int type, not;
3946 : : char *search;
3947 : : bool exists;
3948 : : int i;
3949 : :
3950 : : /* decode regex */
3951 : : type = filter_parse_regex(buffer, strlen(buffer), &search, ¬);
3952 : : if (!not && *idx >= size)
3953 : : return -EBUSY;
3954 : :
3955 : : search_len = strlen(search);
3956 : :
3957 : : mutex_lock(&ftrace_lock);
3958 : :
3959 : : if (unlikely(ftrace_disabled)) {
3960 : : mutex_unlock(&ftrace_lock);
3961 : : return -ENODEV;
3962 : : }
3963 : :
3964 : : do_for_each_ftrace_rec(pg, rec) {
3965 : :
3966 : : if (ftrace_match_record(rec, NULL, search, search_len, type)) {
3967 : : /* if it is in the array */
3968 : : exists = false;
3969 : : for (i = 0; i < *idx; i++) {
3970 : : if (array[i] == rec->ip) {
3971 : : exists = true;
3972 : : break;
3973 : : }
3974 : : }
3975 : :
3976 : : if (!not) {
3977 : : fail = 0;
3978 : : if (!exists) {
3979 : : array[(*idx)++] = rec->ip;
3980 : : if (*idx >= size)
3981 : : goto out;
3982 : : }
3983 : : } else {
3984 : : if (exists) {
3985 : : array[i] = array[--(*idx)];
3986 : : array[*idx] = 0;
3987 : : fail = 0;
3988 : : }
3989 : : }
3990 : : }
3991 : : } while_for_each_ftrace_rec();
3992 : : out:
3993 : : mutex_unlock(&ftrace_lock);
3994 : :
3995 : : if (fail)
3996 : : return -EINVAL;
3997 : :
3998 : : return 0;
3999 : : }
4000 : :
4001 : : static ssize_t
4002 : : ftrace_graph_write(struct file *file, const char __user *ubuf,
4003 : : size_t cnt, loff_t *ppos)
4004 : : {
4005 : : struct trace_parser parser;
4006 : : ssize_t read, ret = 0;
4007 : : struct ftrace_graph_data *fgd = file->private_data;
4008 : :
4009 : : if (!cnt)
4010 : : return 0;
4011 : :
4012 : : if (trace_parser_get_init(&parser, FTRACE_BUFF_MAX))
4013 : : return -ENOMEM;
4014 : :
4015 : : read = trace_get_user(&parser, ubuf, cnt, ppos);
4016 : :
4017 : : if (read >= 0 && trace_parser_loaded((&parser))) {
4018 : : parser.buffer[parser.idx] = 0;
4019 : :
4020 : : mutex_lock(&graph_lock);
4021 : :
4022 : : /* we allow only one expression at a time */
4023 : : ret = ftrace_set_func(fgd->table, fgd->count, fgd->size,
4024 : : parser.buffer);
4025 : :
4026 : : mutex_unlock(&graph_lock);
4027 : : }
4028 : :
4029 : : if (!ret)
4030 : : ret = read;
4031 : :
4032 : : trace_parser_put(&parser);
4033 : :
4034 : : return ret;
4035 : : }
4036 : :
4037 : : static const struct file_operations ftrace_graph_fops = {
4038 : : .open = ftrace_graph_open,
4039 : : .read = seq_read,
4040 : : .write = ftrace_graph_write,
4041 : : .llseek = ftrace_filter_lseek,
4042 : : .release = ftrace_graph_release,
4043 : : };
4044 : :
4045 : : static const struct file_operations ftrace_graph_notrace_fops = {
4046 : : .open = ftrace_graph_notrace_open,
4047 : : .read = seq_read,
4048 : : .write = ftrace_graph_write,
4049 : : .llseek = ftrace_filter_lseek,
4050 : : .release = ftrace_graph_release,
4051 : : };
4052 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
4053 : :
4054 : 0 : static __init int ftrace_init_dyn_debugfs(struct dentry *d_tracer)
4055 : : {
4056 : :
4057 : 0 : trace_create_file("available_filter_functions", 0444,
4058 : : d_tracer, NULL, &ftrace_avail_fops);
4059 : :
4060 : 0 : trace_create_file("enabled_functions", 0444,
4061 : : d_tracer, NULL, &ftrace_enabled_fops);
4062 : :
4063 : 0 : trace_create_file("set_ftrace_filter", 0644, d_tracer,
4064 : : NULL, &ftrace_filter_fops);
4065 : :
4066 : 0 : trace_create_file("set_ftrace_notrace", 0644, d_tracer,
4067 : : NULL, &ftrace_notrace_fops);
4068 : :
4069 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
4070 : : trace_create_file("set_graph_function", 0444, d_tracer,
4071 : : NULL,
4072 : : &ftrace_graph_fops);
4073 : : trace_create_file("set_graph_notrace", 0444, d_tracer,
4074 : : NULL,
4075 : : &ftrace_graph_notrace_fops);
4076 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
4077 : :
4078 : 0 : return 0;
4079 : : }
4080 : :
4081 : 0 : static int ftrace_cmp_ips(const void *a, const void *b)
4082 : : {
4083 : : const unsigned long *ipa = a;
4084 : : const unsigned long *ipb = b;
4085 : :
4086 [ # # ]: 0 : if (*ipa > *ipb)
4087 : : return 1;
4088 [ # # ]: 0 : if (*ipa < *ipb)
4089 : : return -1;
4090 : 0 : return 0;
4091 : : }
4092 : :
4093 : 0 : static void ftrace_swap_ips(void *a, void *b, int size)
4094 : : {
4095 : : unsigned long *ipa = a;
4096 : : unsigned long *ipb = b;
4097 : : unsigned long t;
4098 : :
4099 : 0 : t = *ipa;
4100 : 0 : *ipa = *ipb;
4101 : 0 : *ipb = t;
4102 : 0 : }
4103 : :
4104 : 0 : static int ftrace_process_locs(struct module *mod,
4105 : : unsigned long *start,
4106 : : unsigned long *end)
4107 : : {
4108 : : struct ftrace_page *start_pg;
4109 : : struct ftrace_page *pg;
4110 : : struct dyn_ftrace *rec;
4111 : : unsigned long count;
4112 : : unsigned long *p;
4113 : : unsigned long addr;
4114 : : unsigned long flags = 0; /* Shut up gcc */
4115 : : int ret = -ENOMEM;
4116 : :
4117 : 0 : count = end - start;
4118 : :
4119 [ # # ]: 0 : if (!count)
4120 : : return 0;
4121 : :
4122 : 0 : sort(start, count, sizeof(*start),
4123 : : ftrace_cmp_ips, ftrace_swap_ips);
4124 : :
4125 : 0 : start_pg = ftrace_allocate_pages(count);
4126 [ # # ]: 0 : if (!start_pg)
4127 : : return -ENOMEM;
4128 : :
4129 : 0 : mutex_lock(&ftrace_lock);
4130 : :
4131 : : /*
4132 : : * Core and each module needs their own pages, as
4133 : : * modules will free them when they are removed.
4134 : : * Force a new page to be allocated for modules.
4135 : : */
4136 [ # # ]: 0 : if (!mod) {
4137 [ # # ][ # # ]: 0 : WARN_ON(ftrace_pages || ftrace_pages_start);
[ # # ]
4138 : : /* First initialization */
4139 : 0 : ftrace_pages = ftrace_pages_start = start_pg;
4140 : : } else {
4141 [ # # ]: 0 : if (!ftrace_pages)
4142 : : goto out;
4143 : :
4144 [ # # ][ # # ]: 0 : if (WARN_ON(ftrace_pages->next)) {
4145 : : /* Hmm, we have free pages? */
4146 [ # # ]: 0 : while (ftrace_pages->next)
4147 : 0 : ftrace_pages = ftrace_pages->next;
4148 : : }
4149 : :
4150 : 0 : ftrace_pages->next = start_pg;
4151 : : }
4152 : :
4153 : : p = start;
4154 : : pg = start_pg;
4155 [ # # ]: 0 : while (p < end) {
4156 : 0 : addr = ftrace_call_adjust(*p++);
4157 : : /*
4158 : : * Some architecture linkers will pad between
4159 : : * the different mcount_loc sections of different
4160 : : * object files to satisfy alignments.
4161 : : * Skip any NULL pointers.
4162 : : */
4163 [ # # ]: 0 : if (!addr)
4164 : 0 : continue;
4165 : :
4166 [ # # ]: 0 : if (pg->index == pg->size) {
4167 : : /* We should have allocated enough */
4168 [ # # ][ # # ]: 0 : if (WARN_ON(!pg->next))
4169 : : break;
4170 : 0 : pg = pg->next;
4171 : : }
4172 : :
4173 : 0 : rec = &pg->records[pg->index++];
4174 : 0 : rec->ip = addr;
4175 : : }
4176 : :
4177 : : /* We should have used all pages */
4178 [ # # ]: 0 : WARN_ON(pg->next);
4179 : :
4180 : : /* Assign the last page to ftrace_pages */
4181 : 0 : ftrace_pages = pg;
4182 : :
4183 : : /* These new locations need to be initialized */
4184 : 0 : ftrace_new_pgs = start_pg;
4185 : :
4186 : : /*
4187 : : * We only need to disable interrupts on start up
4188 : : * because we are modifying code that an interrupt
4189 : : * may execute, and the modification is not atomic.
4190 : : * But for modules, nothing runs the code we modify
4191 : : * until we are finished with it, and there's no
4192 : : * reason to cause large interrupt latencies while we do it.
4193 : : */
4194 [ # # ]: 0 : if (!mod)
4195 : : local_irq_save(flags);
4196 : 0 : ftrace_update_code(mod);
4197 [ # # ]: 0 : if (!mod)
4198 [ # # ]: 0 : local_irq_restore(flags);
4199 : : ret = 0;
4200 : : out:
4201 : 0 : mutex_unlock(&ftrace_lock);
4202 : :
4203 : 0 : return ret;
4204 : : }
4205 : :
4206 : : #ifdef CONFIG_MODULES
4207 : :
4208 : : #define next_to_ftrace_page(p) container_of(p, struct ftrace_page, next)
4209 : :
4210 : 0 : void ftrace_release_mod(struct module *mod)
4211 : : {
4212 : : struct dyn_ftrace *rec;
4213 : : struct ftrace_page **last_pg;
4214 : : struct ftrace_page *pg;
4215 : : int order;
4216 : :
4217 : 0 : mutex_lock(&ftrace_lock);
4218 : :
4219 [ # # ]: 0 : if (ftrace_disabled)
4220 : : goto out_unlock;
4221 : :
4222 : : /*
4223 : : * Each module has its own ftrace_pages, remove
4224 : : * them from the list.
4225 : : */
4226 : : last_pg = &ftrace_pages_start;
4227 [ # # ]: 0 : for (pg = ftrace_pages_start; pg; pg = *last_pg) {
4228 : 0 : rec = &pg->records[0];
4229 [ # # ]: 0 : if (within_module_core(rec->ip, mod)) {
4230 : : /*
4231 : : * As core pages are first, the first
4232 : : * page should never be a module page.
4233 : : */
4234 [ # # ][ # # ]: 0 : if (WARN_ON(pg == ftrace_pages_start))
4235 : : goto out_unlock;
4236 : :
4237 : : /* Check if we are deleting the last page */
4238 [ # # ]: 0 : if (pg == ftrace_pages)
4239 : 0 : ftrace_pages = next_to_ftrace_page(last_pg);
4240 : :
4241 : 0 : *last_pg = pg->next;
4242 : 0 : order = get_count_order(pg->size / ENTRIES_PER_PAGE);
4243 : 0 : free_pages((unsigned long)pg->records, order);
4244 : 0 : kfree(pg);
4245 : : } else
4246 : 0 : last_pg = &pg->next;
4247 : : }
4248 : : out_unlock:
4249 : 0 : mutex_unlock(&ftrace_lock);
4250 : 0 : }
4251 : :
4252 : : static void ftrace_init_module(struct module *mod,
4253 : : unsigned long *start, unsigned long *end)
4254 : : {
4255 [ # # ][ # # ]: 0 : if (ftrace_disabled || start == end)
4256 : : return;
4257 : 0 : ftrace_process_locs(mod, start, end);
4258 : : }
4259 : :
4260 : 0 : static int ftrace_module_notify_enter(struct notifier_block *self,
4261 : : unsigned long val, void *data)
4262 : : {
4263 : : struct module *mod = data;
4264 : :
4265 [ # # ]: 0 : if (val == MODULE_STATE_COMING)
4266 : 0 : ftrace_init_module(mod, mod->ftrace_callsites,
4267 : 0 : mod->ftrace_callsites +
4268 : 0 : mod->num_ftrace_callsites);
4269 : 0 : return 0;
4270 : : }
4271 : :
4272 : 0 : static int ftrace_module_notify_exit(struct notifier_block *self,
4273 : : unsigned long val, void *data)
4274 : : {
4275 : : struct module *mod = data;
4276 : :
4277 [ # # ]: 0 : if (val == MODULE_STATE_GOING)
4278 : 0 : ftrace_release_mod(mod);
4279 : :
4280 : 0 : return 0;
4281 : : }
4282 : : #else
4283 : : static int ftrace_module_notify_enter(struct notifier_block *self,
4284 : : unsigned long val, void *data)
4285 : : {
4286 : : return 0;
4287 : : }
4288 : : static int ftrace_module_notify_exit(struct notifier_block *self,
4289 : : unsigned long val, void *data)
4290 : : {
4291 : : return 0;
4292 : : }
4293 : : #endif /* CONFIG_MODULES */
4294 : :
4295 : : struct notifier_block ftrace_module_enter_nb = {
4296 : : .notifier_call = ftrace_module_notify_enter,
4297 : : .priority = INT_MAX, /* Run before anything that can use kprobes */
4298 : : };
4299 : :
4300 : : struct notifier_block ftrace_module_exit_nb = {
4301 : : .notifier_call = ftrace_module_notify_exit,
4302 : : .priority = INT_MIN, /* Run after anything that can remove kprobes */
4303 : : };
4304 : :
4305 : : extern unsigned long __start_mcount_loc[];
4306 : : extern unsigned long __stop_mcount_loc[];
4307 : :
4308 : 0 : void __init ftrace_init(void)
4309 : : {
4310 : : unsigned long count, addr, flags;
4311 : : int ret;
4312 : :
4313 : : /* Keep the ftrace pointer to the stub */
4314 : 0 : addr = (unsigned long)ftrace_stub;
4315 : :
4316 : : local_irq_save(flags);
4317 : 0 : ftrace_dyn_arch_init(&addr);
4318 [ # # ]: 0 : local_irq_restore(flags);
4319 : :
4320 : : /* ftrace_dyn_arch_init places the return code in addr */
4321 [ # # ]: 0 : if (addr)
4322 : : goto failed;
4323 : :
4324 : 0 : count = __stop_mcount_loc - __start_mcount_loc;
4325 : :
4326 : 0 : ret = ftrace_dyn_table_alloc(count);
4327 [ # # ]: 0 : if (ret)
4328 : : goto failed;
4329 : :
4330 : 0 : last_ftrace_enabled = ftrace_enabled = 1;
4331 : :
4332 : 0 : ret = ftrace_process_locs(NULL,
4333 : : __start_mcount_loc,
4334 : : __stop_mcount_loc);
4335 : :
4336 : 0 : ret = register_module_notifier(&ftrace_module_enter_nb);
4337 [ # # ]: 0 : if (ret)
4338 : 0 : pr_warning("Failed to register trace ftrace module enter notifier\n");
4339 : :
4340 : 0 : ret = register_module_notifier(&ftrace_module_exit_nb);
4341 [ # # ]: 0 : if (ret)
4342 : 0 : pr_warning("Failed to register trace ftrace module exit notifier\n");
4343 : :
4344 : 0 : set_ftrace_early_filters();
4345 : :
4346 : 0 : return;
4347 : : failed:
4348 : 0 : ftrace_disabled = 1;
4349 : : }
4350 : :
4351 : : #else
4352 : :
4353 : : static struct ftrace_ops global_ops = {
4354 : : .func = ftrace_stub,
4355 : : .flags = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,
4356 : : INIT_REGEX_LOCK(global_ops)
4357 : : };
4358 : :
4359 : : static int __init ftrace_nodyn_init(void)
4360 : : {
4361 : : ftrace_enabled = 1;
4362 : : return 0;
4363 : : }
4364 : : core_initcall(ftrace_nodyn_init);
4365 : :
4366 : : static inline int ftrace_init_dyn_debugfs(struct dentry *d_tracer) { return 0; }
4367 : : static inline void ftrace_startup_enable(int command) { }
4368 : : /* Keep as macros so we do not need to define the commands */
4369 : : # define ftrace_startup(ops, command) \
4370 : : ({ \
4371 : : int ___ret = __register_ftrace_function(ops); \
4372 : : if (!___ret) \
4373 : : (ops)->flags |= FTRACE_OPS_FL_ENABLED; \
4374 : : ___ret; \
4375 : : })
4376 : : # define ftrace_shutdown(ops, command) __unregister_ftrace_function(ops)
4377 : :
4378 : : # define ftrace_startup_sysctl() do { } while (0)
4379 : : # define ftrace_shutdown_sysctl() do { } while (0)
4380 : :
4381 : : static inline int
4382 : : ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
4383 : : {
4384 : : return 1;
4385 : : }
4386 : :
4387 : : #endif /* CONFIG_DYNAMIC_FTRACE */
4388 : :
4389 : : static void
4390 : 0 : ftrace_ops_control_func(unsigned long ip, unsigned long parent_ip,
4391 : 0 : struct ftrace_ops *op, struct pt_regs *regs)
4392 : : {
4393 [ # # ]: 0 : if (unlikely(trace_recursion_test(TRACE_CONTROL_BIT)))
4394 : 0 : return;
4395 : :
4396 : : /*
4397 : : * Some of the ops may be dynamically allocated,
4398 : : * they must be freed after a synchronize_sched().
4399 : : */
4400 : 0 : preempt_disable_notrace();
4401 : 0 : trace_recursion_set(TRACE_CONTROL_BIT);
4402 : :
4403 : : /*
4404 : : * Control funcs (perf) uses RCU. Only trace if
4405 : : * RCU is currently active.
4406 : : */
4407 [ # # ]: 0 : if (!rcu_is_watching())
4408 : : goto out;
4409 : :
4410 : 0 : do_for_each_ftrace_op(op, ftrace_control_list) {
4411 [ # # ][ # # ]: 0 : if (!(op->flags & FTRACE_OPS_FL_STUB) &&
4412 [ # # ]: 0 : !ftrace_function_local_disabled(op) &&
4413 : 0 : ftrace_ops_test(op, ip, regs))
4414 : 0 : op->func(ip, parent_ip, op, regs);
4415 [ # # ][ # # ]: 0 : } while_for_each_ftrace_op(op);
4416 : : out:
4417 : 0 : trace_recursion_clear(TRACE_CONTROL_BIT);
4418 : 0 : preempt_enable_notrace();
4419 : : }
4420 : :
4421 : : static struct ftrace_ops control_ops = {
4422 : : .func = ftrace_ops_control_func,
4423 : : .flags = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,
4424 : : INIT_REGEX_LOCK(control_ops)
4425 : : };
4426 : :
4427 : : static inline void
4428 : : __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
4429 : : struct ftrace_ops *ignored, struct pt_regs *regs)
4430 : : {
4431 : 0 : struct ftrace_ops *op;
4432 : : int bit;
4433 : :
4434 [ # # ]: 0 : if (function_trace_stop)
4435 : : return;
4436 : :
4437 : : bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
4438 [ # # ]: 0 : if (bit < 0)
4439 : : return;
4440 : :
4441 : : /*
4442 : : * Some of the ops may be dynamically allocated,
4443 : : * they must be freed after a synchronize_sched().
4444 : : */
4445 : 0 : preempt_disable_notrace();
4446 : 0 : do_for_each_ftrace_op(op, ftrace_ops_list) {
4447 [ # # ]: 0 : if (ftrace_ops_test(op, ip, regs))
4448 : 0 : op->func(ip, parent_ip, op, regs);
4449 [ # # ][ # # ]: 0 : } while_for_each_ftrace_op(op);
4450 : 0 : preempt_enable_notrace();
4451 : : trace_clear_recursion(bit);
4452 : : }
4453 : :
4454 : : /*
4455 : : * Some archs only support passing ip and parent_ip. Even though
4456 : : * the list function ignores the op parameter, we do not want any
4457 : : * C side effects, where a function is called without the caller
4458 : : * sending a third parameter.
4459 : : * Archs are to support both the regs and ftrace_ops at the same time.
4460 : : * If they support ftrace_ops, it is assumed they support regs.
4461 : : * If call backs want to use regs, they must either check for regs
4462 : : * being NULL, or CONFIG_DYNAMIC_FTRACE_WITH_REGS.
4463 : : * Note, CONFIG_DYNAMIC_FTRACE_WITH_REGS expects a full regs to be saved.
4464 : : * An architecture can pass partial regs with ftrace_ops and still
4465 : : * set the ARCH_SUPPORT_FTARCE_OPS.
4466 : : */
4467 : : #if ARCH_SUPPORTS_FTRACE_OPS
4468 : : static void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
4469 : : struct ftrace_ops *op, struct pt_regs *regs)
4470 : : {
4471 : : __ftrace_ops_list_func(ip, parent_ip, NULL, regs);
4472 : : }
4473 : : #else
4474 : 0 : static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip)
4475 : : {
4476 : : __ftrace_ops_list_func(ip, parent_ip, NULL, NULL);
4477 : 0 : }
4478 : : #endif
4479 : :
4480 : 0 : static void clear_ftrace_swapper(void)
4481 : : {
4482 : : struct task_struct *p;
4483 : : int cpu;
4484 : :
4485 : 0 : get_online_cpus();
4486 [ # # ]: 0 : for_each_online_cpu(cpu) {
4487 : 0 : p = idle_task(cpu);
4488 : : clear_tsk_trace_trace(p);
4489 : : }
4490 : 0 : put_online_cpus();
4491 : 0 : }
4492 : :
4493 : 0 : static void set_ftrace_swapper(void)
4494 : : {
4495 : : struct task_struct *p;
4496 : : int cpu;
4497 : :
4498 : 0 : get_online_cpus();
4499 [ # # ]: 0 : for_each_online_cpu(cpu) {
4500 : 0 : p = idle_task(cpu);
4501 : : set_tsk_trace_trace(p);
4502 : : }
4503 : 0 : put_online_cpus();
4504 : 0 : }
4505 : :
4506 : 0 : static void clear_ftrace_pid(struct pid *pid)
4507 : : {
4508 : : struct task_struct *p;
4509 : :
4510 : : rcu_read_lock();
4511 [ # # ][ # # ]: 0 : do_each_pid_task(pid, PIDTYPE_PID, p) {
[ # # ]
4512 : : clear_tsk_trace_trace(p);
4513 : : } while_each_pid_task(pid, PIDTYPE_PID, p);
4514 : : rcu_read_unlock();
4515 : :
4516 : 0 : put_pid(pid);
4517 : 0 : }
4518 : :
4519 : 0 : static void set_ftrace_pid(struct pid *pid)
4520 : : {
4521 : : struct task_struct *p;
4522 : :
4523 : : rcu_read_lock();
4524 [ # # ][ # # ]: 0 : do_each_pid_task(pid, PIDTYPE_PID, p) {
[ # # ]
4525 : : set_tsk_trace_trace(p);
4526 : : } while_each_pid_task(pid, PIDTYPE_PID, p);
4527 : : rcu_read_unlock();
4528 : 0 : }
4529 : :
4530 : : static void clear_ftrace_pid_task(struct pid *pid)
4531 : : {
4532 [ # # ]: 0 : if (pid == ftrace_swapper_pid)
4533 : 0 : clear_ftrace_swapper();
4534 : : else
4535 : 0 : clear_ftrace_pid(pid);
4536 : : }
4537 : :
4538 : : static void set_ftrace_pid_task(struct pid *pid)
4539 : : {
4540 [ # # ]: 0 : if (pid == ftrace_swapper_pid)
4541 : 0 : set_ftrace_swapper();
4542 : : else
4543 : 0 : set_ftrace_pid(pid);
4544 : : }
4545 : :
4546 : 0 : static int ftrace_pid_add(int p)
4547 : : {
4548 : : struct pid *pid;
4549 : : struct ftrace_pid *fpid;
4550 : : int ret = -EINVAL;
4551 : :
4552 : 0 : mutex_lock(&ftrace_lock);
4553 : :
4554 [ # # ]: 0 : if (!p)
4555 : : pid = ftrace_swapper_pid;
4556 : : else
4557 : 0 : pid = find_get_pid(p);
4558 : :
4559 [ # # ]: 0 : if (!pid)
4560 : : goto out;
4561 : :
4562 : : ret = 0;
4563 : :
4564 [ # # ]: 0 : list_for_each_entry(fpid, &ftrace_pids, list)
4565 [ # # ]: 0 : if (fpid->pid == pid)
4566 : : goto out_put;
4567 : :
4568 : : ret = -ENOMEM;
4569 : :
4570 : : fpid = kmalloc(sizeof(*fpid), GFP_KERNEL);
4571 [ # # ]: 0 : if (!fpid)
4572 : : goto out_put;
4573 : :
4574 : 0 : list_add(&fpid->list, &ftrace_pids);
4575 : 0 : fpid->pid = pid;
4576 : :
4577 : : set_ftrace_pid_task(pid);
4578 : :
4579 : : ftrace_update_pid_func();
4580 : 0 : ftrace_startup_enable(0);
4581 : :
4582 : 0 : mutex_unlock(&ftrace_lock);
4583 : 0 : return 0;
4584 : :
4585 : : out_put:
4586 [ # # ]: 0 : if (pid != ftrace_swapper_pid)
4587 : 0 : put_pid(pid);
4588 : :
4589 : : out:
4590 : 0 : mutex_unlock(&ftrace_lock);
4591 : 0 : return ret;
4592 : : }
4593 : :
4594 : 0 : static void ftrace_pid_reset(void)
4595 : : {
4596 : : struct ftrace_pid *fpid, *safe;
4597 : :
4598 : 0 : mutex_lock(&ftrace_lock);
4599 [ # # ]: 0 : list_for_each_entry_safe(fpid, safe, &ftrace_pids, list) {
4600 : 0 : struct pid *pid = fpid->pid;
4601 : :
4602 : : clear_ftrace_pid_task(pid);
4603 : :
4604 : : list_del(&fpid->list);
4605 : 0 : kfree(fpid);
4606 : : }
4607 : :
4608 : : ftrace_update_pid_func();
4609 : 0 : ftrace_startup_enable(0);
4610 : :
4611 : 0 : mutex_unlock(&ftrace_lock);
4612 : 0 : }
4613 : :
4614 : 0 : static void *fpid_start(struct seq_file *m, loff_t *pos)
4615 : : {
4616 : 0 : mutex_lock(&ftrace_lock);
4617 : :
4618 [ # # ][ # # ]: 0 : if (list_empty(&ftrace_pids) && (!*pos))
4619 : : return (void *) 1;
4620 : :
4621 : 0 : return seq_list_start(&ftrace_pids, *pos);
4622 : : }
4623 : :
4624 : 0 : static void *fpid_next(struct seq_file *m, void *v, loff_t *pos)
4625 : : {
4626 [ # # ]: 0 : if (v == (void *)1)
4627 : : return NULL;
4628 : :
4629 : 0 : return seq_list_next(v, &ftrace_pids, pos);
4630 : : }
4631 : :
4632 : 0 : static void fpid_stop(struct seq_file *m, void *p)
4633 : : {
4634 : 0 : mutex_unlock(&ftrace_lock);
4635 : 0 : }
4636 : :
4637 : 0 : static int fpid_show(struct seq_file *m, void *v)
4638 : : {
4639 : : const struct ftrace_pid *fpid = list_entry(v, struct ftrace_pid, list);
4640 : :
4641 [ # # ]: 0 : if (v == (void *)1) {
4642 : 0 : seq_printf(m, "no pid\n");
4643 : 0 : return 0;
4644 : : }
4645 : :
4646 [ # # ]: 0 : if (fpid->pid == ftrace_swapper_pid)
4647 : 0 : seq_printf(m, "swapper tasks\n");
4648 : : else
4649 : 0 : seq_printf(m, "%u\n", pid_vnr(fpid->pid));
4650 : :
4651 : : return 0;
4652 : : }
4653 : :
4654 : : static const struct seq_operations ftrace_pid_sops = {
4655 : : .start = fpid_start,
4656 : : .next = fpid_next,
4657 : : .stop = fpid_stop,
4658 : : .show = fpid_show,
4659 : : };
4660 : :
4661 : : static int
4662 : 0 : ftrace_pid_open(struct inode *inode, struct file *file)
4663 : : {
4664 : : int ret = 0;
4665 : :
4666 [ # # ][ # # ]: 0 : if ((file->f_mode & FMODE_WRITE) &&
4667 : 0 : (file->f_flags & O_TRUNC))
4668 : 0 : ftrace_pid_reset();
4669 : :
4670 [ # # ]: 0 : if (file->f_mode & FMODE_READ)
4671 : 0 : ret = seq_open(file, &ftrace_pid_sops);
4672 : :
4673 : 0 : return ret;
4674 : : }
4675 : :
4676 : : static ssize_t
4677 : 0 : ftrace_pid_write(struct file *filp, const char __user *ubuf,
4678 : : size_t cnt, loff_t *ppos)
4679 : : {
4680 : : char buf[64], *tmp;
4681 : : long val;
4682 : : int ret;
4683 : :
4684 [ # # ]: 0 : if (cnt >= sizeof(buf))
4685 : : return -EINVAL;
4686 : :
4687 [ # # ]: 0 : if (copy_from_user(&buf, ubuf, cnt))
4688 : : return -EFAULT;
4689 : :
4690 : 0 : buf[cnt] = 0;
4691 : :
4692 : : /*
4693 : : * Allow "echo > set_ftrace_pid" or "echo -n '' > set_ftrace_pid"
4694 : : * to clean the filter quietly.
4695 : : */
4696 : : tmp = strstrip(buf);
4697 [ # # ]: 0 : if (strlen(tmp) == 0)
4698 : : return 1;
4699 : :
4700 : : ret = kstrtol(tmp, 10, &val);
4701 [ # # ]: 0 : if (ret < 0)
4702 : : return ret;
4703 : :
4704 : 0 : ret = ftrace_pid_add(val);
4705 : :
4706 [ # # ]: 0 : return ret ? ret : cnt;
4707 : : }
4708 : :
4709 : : static int
4710 : 0 : ftrace_pid_release(struct inode *inode, struct file *file)
4711 : : {
4712 [ # # ]: 0 : if (file->f_mode & FMODE_READ)
4713 : 0 : seq_release(inode, file);
4714 : :
4715 : 0 : return 0;
4716 : : }
4717 : :
4718 : : static const struct file_operations ftrace_pid_fops = {
4719 : : .open = ftrace_pid_open,
4720 : : .write = ftrace_pid_write,
4721 : : .read = seq_read,
4722 : : .llseek = ftrace_filter_lseek,
4723 : : .release = ftrace_pid_release,
4724 : : };
4725 : :
4726 : 0 : static __init int ftrace_init_debugfs(void)
4727 : : {
4728 : : struct dentry *d_tracer;
4729 : :
4730 : 0 : d_tracer = tracing_init_dentry();
4731 [ # # ]: 0 : if (!d_tracer)
4732 : : return 0;
4733 : :
4734 : 0 : ftrace_init_dyn_debugfs(d_tracer);
4735 : :
4736 : 0 : trace_create_file("set_ftrace_pid", 0644, d_tracer,
4737 : : NULL, &ftrace_pid_fops);
4738 : :
4739 : : ftrace_profile_debugfs(d_tracer);
4740 : :
4741 : 0 : return 0;
4742 : : }
4743 : : fs_initcall(ftrace_init_debugfs);
4744 : :
4745 : : /**
4746 : : * ftrace_kill - kill ftrace
4747 : : *
4748 : : * This function should be used by panic code. It stops ftrace
4749 : : * but in a not so nice way. If you need to simply kill ftrace
4750 : : * from a non-atomic section, use ftrace_kill.
4751 : : */
4752 : 0 : void ftrace_kill(void)
4753 : : {
4754 : 0 : ftrace_disabled = 1;
4755 : 0 : ftrace_enabled = 0;
4756 : : clear_ftrace_function();
4757 : 0 : }
4758 : :
4759 : : /**
4760 : : * Test if ftrace is dead or not.
4761 : : */
4762 : 0 : int ftrace_is_dead(void)
4763 : : {
4764 : 0 : return ftrace_disabled;
4765 : : }
4766 : :
4767 : : /**
4768 : : * register_ftrace_function - register a function for profiling
4769 : : * @ops - ops structure that holds the function for profiling.
4770 : : *
4771 : : * Register a function to be called by all functions in the
4772 : : * kernel.
4773 : : *
4774 : : * Note: @ops->func and all the functions it calls must be labeled
4775 : : * with "notrace", otherwise it will go into a
4776 : : * recursive loop.
4777 : : */
4778 : 0 : int register_ftrace_function(struct ftrace_ops *ops)
4779 : : {
4780 : : int ret = -1;
4781 : :
4782 : : ftrace_ops_init(ops);
4783 : :
4784 : 0 : mutex_lock(&ftrace_lock);
4785 : :
4786 : 0 : ret = ftrace_startup(ops, 0);
4787 : :
4788 : 0 : mutex_unlock(&ftrace_lock);
4789 : :
4790 : 0 : return ret;
4791 : : }
4792 : : EXPORT_SYMBOL_GPL(register_ftrace_function);
4793 : :
4794 : : /**
4795 : : * unregister_ftrace_function - unregister a function for profiling.
4796 : : * @ops - ops structure that holds the function to unregister
4797 : : *
4798 : : * Unregister a function that was added to be called by ftrace profiling.
4799 : : */
4800 : 0 : int unregister_ftrace_function(struct ftrace_ops *ops)
4801 : : {
4802 : : int ret;
4803 : :
4804 : 0 : mutex_lock(&ftrace_lock);
4805 : 0 : ret = ftrace_shutdown(ops, 0);
4806 : 0 : mutex_unlock(&ftrace_lock);
4807 : :
4808 : 0 : return ret;
4809 : : }
4810 : : EXPORT_SYMBOL_GPL(unregister_ftrace_function);
4811 : :
4812 : : int
4813 : 0 : ftrace_enable_sysctl(struct ctl_table *table, int write,
4814 : : void __user *buffer, size_t *lenp,
4815 : : loff_t *ppos)
4816 : : {
4817 : : int ret = -ENODEV;
4818 : :
4819 : 2 : mutex_lock(&ftrace_lock);
4820 : :
4821 [ + - ]: 2 : if (unlikely(ftrace_disabled))
4822 : : goto out;
4823 : :
4824 : 2 : ret = proc_dointvec(table, write, buffer, lenp, ppos);
4825 : :
4826 [ - + ][ # # ]: 2 : if (ret || !write || (last_ftrace_enabled == !!ftrace_enabled))
4827 : : goto out;
4828 : :
4829 : 0 : last_ftrace_enabled = !!ftrace_enabled;
4830 : :
4831 [ # # ]: 0 : if (ftrace_enabled) {
4832 : :
4833 : 0 : ftrace_startup_sysctl();
4834 : :
4835 : : /* we are starting ftrace again */
4836 [ # # ]: 0 : if (ftrace_ops_list != &ftrace_list_end)
4837 : 0 : update_ftrace_function();
4838 : :
4839 : : } else {
4840 : : /* stopping ftrace calls (just send to ftrace_stub) */
4841 : 0 : ftrace_trace_function = ftrace_stub;
4842 : :
4843 : 0 : ftrace_shutdown_sysctl();
4844 : : }
4845 : :
4846 : : out:
4847 : 2 : mutex_unlock(&ftrace_lock);
4848 : 2 : return ret;
4849 : : }
4850 : :
4851 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
4852 : :
4853 : : static int ftrace_graph_active;
4854 : : static struct notifier_block ftrace_suspend_notifier;
4855 : :
4856 : : int ftrace_graph_entry_stub(struct ftrace_graph_ent *trace)
4857 : : {
4858 : : return 0;
4859 : : }
4860 : :
4861 : : /* The callbacks that hook a function */
4862 : : trace_func_graph_ret_t ftrace_graph_return =
4863 : : (trace_func_graph_ret_t)ftrace_stub;
4864 : : trace_func_graph_ent_t ftrace_graph_entry = ftrace_graph_entry_stub;
4865 : :
4866 : : /* Try to assign a return stack array on FTRACE_RETSTACK_ALLOC_SIZE tasks. */
4867 : : static int alloc_retstack_tasklist(struct ftrace_ret_stack **ret_stack_list)
4868 : : {
4869 : : int i;
4870 : : int ret = 0;
4871 : : unsigned long flags;
4872 : : int start = 0, end = FTRACE_RETSTACK_ALLOC_SIZE;
4873 : : struct task_struct *g, *t;
4874 : :
4875 : : for (i = 0; i < FTRACE_RETSTACK_ALLOC_SIZE; i++) {
4876 : : ret_stack_list[i] = kmalloc(FTRACE_RETFUNC_DEPTH
4877 : : * sizeof(struct ftrace_ret_stack),
4878 : : GFP_KERNEL);
4879 : : if (!ret_stack_list[i]) {
4880 : : start = 0;
4881 : : end = i;
4882 : : ret = -ENOMEM;
4883 : : goto free;
4884 : : }
4885 : : }
4886 : :
4887 : : read_lock_irqsave(&tasklist_lock, flags);
4888 : : do_each_thread(g, t) {
4889 : : if (start == end) {
4890 : : ret = -EAGAIN;
4891 : : goto unlock;
4892 : : }
4893 : :
4894 : : if (t->ret_stack == NULL) {
4895 : : atomic_set(&t->tracing_graph_pause, 0);
4896 : : atomic_set(&t->trace_overrun, 0);
4897 : : t->curr_ret_stack = -1;
4898 : : /* Make sure the tasks see the -1 first: */
4899 : : smp_wmb();
4900 : : t->ret_stack = ret_stack_list[start++];
4901 : : }
4902 : : } while_each_thread(g, t);
4903 : :
4904 : : unlock:
4905 : : read_unlock_irqrestore(&tasklist_lock, flags);
4906 : : free:
4907 : : for (i = start; i < end; i++)
4908 : : kfree(ret_stack_list[i]);
4909 : : return ret;
4910 : : }
4911 : :
4912 : : static void
4913 : : ftrace_graph_probe_sched_switch(void *ignore,
4914 : : struct task_struct *prev, struct task_struct *next)
4915 : : {
4916 : : unsigned long long timestamp;
4917 : : int index;
4918 : :
4919 : : /*
4920 : : * Does the user want to count the time a function was asleep.
4921 : : * If so, do not update the time stamps.
4922 : : */
4923 : : if (trace_flags & TRACE_ITER_SLEEP_TIME)
4924 : : return;
4925 : :
4926 : : timestamp = trace_clock_local();
4927 : :
4928 : : prev->ftrace_timestamp = timestamp;
4929 : :
4930 : : /* only process tasks that we timestamped */
4931 : : if (!next->ftrace_timestamp)
4932 : : return;
4933 : :
4934 : : /*
4935 : : * Update all the counters in next to make up for the
4936 : : * time next was sleeping.
4937 : : */
4938 : : timestamp -= next->ftrace_timestamp;
4939 : :
4940 : : for (index = next->curr_ret_stack; index >= 0; index--)
4941 : : next->ret_stack[index].calltime += timestamp;
4942 : : }
4943 : :
4944 : : /* Allocate a return stack for each task */
4945 : : static int start_graph_tracing(void)
4946 : : {
4947 : : struct ftrace_ret_stack **ret_stack_list;
4948 : : int ret, cpu;
4949 : :
4950 : : ret_stack_list = kmalloc(FTRACE_RETSTACK_ALLOC_SIZE *
4951 : : sizeof(struct ftrace_ret_stack *),
4952 : : GFP_KERNEL);
4953 : :
4954 : : if (!ret_stack_list)
4955 : : return -ENOMEM;
4956 : :
4957 : : /* The cpu_boot init_task->ret_stack will never be freed */
4958 : : for_each_online_cpu(cpu) {
4959 : : if (!idle_task(cpu)->ret_stack)
4960 : : ftrace_graph_init_idle_task(idle_task(cpu), cpu);
4961 : : }
4962 : :
4963 : : do {
4964 : : ret = alloc_retstack_tasklist(ret_stack_list);
4965 : : } while (ret == -EAGAIN);
4966 : :
4967 : : if (!ret) {
4968 : : ret = register_trace_sched_switch(ftrace_graph_probe_sched_switch, NULL);
4969 : : if (ret)
4970 : : pr_info("ftrace_graph: Couldn't activate tracepoint"
4971 : : " probe to kernel_sched_switch\n");
4972 : : }
4973 : :
4974 : : kfree(ret_stack_list);
4975 : : return ret;
4976 : : }
4977 : :
4978 : : /*
4979 : : * Hibernation protection.
4980 : : * The state of the current task is too much unstable during
4981 : : * suspend/restore to disk. We want to protect against that.
4982 : : */
4983 : : static int
4984 : : ftrace_suspend_notifier_call(struct notifier_block *bl, unsigned long state,
4985 : : void *unused)
4986 : : {
4987 : : switch (state) {
4988 : : case PM_HIBERNATION_PREPARE:
4989 : : pause_graph_tracing();
4990 : : break;
4991 : :
4992 : : case PM_POST_HIBERNATION:
4993 : : unpause_graph_tracing();
4994 : : break;
4995 : : }
4996 : : return NOTIFY_DONE;
4997 : : }
4998 : :
4999 : : /* Just a place holder for function graph */
5000 : : static struct ftrace_ops fgraph_ops __read_mostly = {
5001 : : .func = ftrace_stub,
5002 : : .flags = FTRACE_OPS_FL_STUB | FTRACE_OPS_FL_GLOBAL |
5003 : : FTRACE_OPS_FL_RECURSION_SAFE,
5004 : : };
5005 : :
5006 : : int register_ftrace_graph(trace_func_graph_ret_t retfunc,
5007 : : trace_func_graph_ent_t entryfunc)
5008 : : {
5009 : : int ret = 0;
5010 : :
5011 : : mutex_lock(&ftrace_lock);
5012 : :
5013 : : /* we currently allow only one tracer registered at a time */
5014 : : if (ftrace_graph_active) {
5015 : : ret = -EBUSY;
5016 : : goto out;
5017 : : }
5018 : :
5019 : : ftrace_suspend_notifier.notifier_call = ftrace_suspend_notifier_call;
5020 : : register_pm_notifier(&ftrace_suspend_notifier);
5021 : :
5022 : : ftrace_graph_active++;
5023 : : ret = start_graph_tracing();
5024 : : if (ret) {
5025 : : ftrace_graph_active--;
5026 : : goto out;
5027 : : }
5028 : :
5029 : : ftrace_graph_return = retfunc;
5030 : : ftrace_graph_entry = entryfunc;
5031 : :
5032 : : ret = ftrace_startup(&fgraph_ops, FTRACE_START_FUNC_RET);
5033 : :
5034 : : out:
5035 : : mutex_unlock(&ftrace_lock);
5036 : : return ret;
5037 : : }
5038 : :
5039 : : void unregister_ftrace_graph(void)
5040 : : {
5041 : : mutex_lock(&ftrace_lock);
5042 : :
5043 : : if (unlikely(!ftrace_graph_active))
5044 : : goto out;
5045 : :
5046 : : ftrace_graph_active--;
5047 : : ftrace_graph_return = (trace_func_graph_ret_t)ftrace_stub;
5048 : : ftrace_graph_entry = ftrace_graph_entry_stub;
5049 : : ftrace_shutdown(&fgraph_ops, FTRACE_STOP_FUNC_RET);
5050 : : unregister_pm_notifier(&ftrace_suspend_notifier);
5051 : : unregister_trace_sched_switch(ftrace_graph_probe_sched_switch, NULL);
5052 : :
5053 : : out:
5054 : : mutex_unlock(&ftrace_lock);
5055 : : }
5056 : :
5057 : : static DEFINE_PER_CPU(struct ftrace_ret_stack *, idle_ret_stack);
5058 : :
5059 : : static void
5060 : : graph_init_task(struct task_struct *t, struct ftrace_ret_stack *ret_stack)
5061 : : {
5062 : : atomic_set(&t->tracing_graph_pause, 0);
5063 : : atomic_set(&t->trace_overrun, 0);
5064 : : t->ftrace_timestamp = 0;
5065 : : /* make curr_ret_stack visible before we add the ret_stack */
5066 : : smp_wmb();
5067 : : t->ret_stack = ret_stack;
5068 : : }
5069 : :
5070 : : /*
5071 : : * Allocate a return stack for the idle task. May be the first
5072 : : * time through, or it may be done by CPU hotplug online.
5073 : : */
5074 : : void ftrace_graph_init_idle_task(struct task_struct *t, int cpu)
5075 : : {
5076 : : t->curr_ret_stack = -1;
5077 : : /*
5078 : : * The idle task has no parent, it either has its own
5079 : : * stack or no stack at all.
5080 : : */
5081 : : if (t->ret_stack)
5082 : : WARN_ON(t->ret_stack != per_cpu(idle_ret_stack, cpu));
5083 : :
5084 : : if (ftrace_graph_active) {
5085 : : struct ftrace_ret_stack *ret_stack;
5086 : :
5087 : : ret_stack = per_cpu(idle_ret_stack, cpu);
5088 : : if (!ret_stack) {
5089 : : ret_stack = kmalloc(FTRACE_RETFUNC_DEPTH
5090 : : * sizeof(struct ftrace_ret_stack),
5091 : : GFP_KERNEL);
5092 : : if (!ret_stack)
5093 : : return;
5094 : : per_cpu(idle_ret_stack, cpu) = ret_stack;
5095 : : }
5096 : : graph_init_task(t, ret_stack);
5097 : : }
5098 : : }
5099 : :
5100 : : /* Allocate a return stack for newly created task */
5101 : : void ftrace_graph_init_task(struct task_struct *t)
5102 : : {
5103 : : /* Make sure we do not use the parent ret_stack */
5104 : : t->ret_stack = NULL;
5105 : : t->curr_ret_stack = -1;
5106 : :
5107 : : if (ftrace_graph_active) {
5108 : : struct ftrace_ret_stack *ret_stack;
5109 : :
5110 : : ret_stack = kmalloc(FTRACE_RETFUNC_DEPTH
5111 : : * sizeof(struct ftrace_ret_stack),
5112 : : GFP_KERNEL);
5113 : : if (!ret_stack)
5114 : : return;
5115 : : graph_init_task(t, ret_stack);
5116 : : }
5117 : : }
5118 : :
5119 : : void ftrace_graph_exit_task(struct task_struct *t)
5120 : : {
5121 : : struct ftrace_ret_stack *ret_stack = t->ret_stack;
5122 : :
5123 : : t->ret_stack = NULL;
5124 : : /* NULL must become visible to IRQs before we free it: */
5125 : : barrier();
5126 : :
5127 : : kfree(ret_stack);
5128 : : }
5129 : :
5130 : : void ftrace_graph_stop(void)
5131 : : {
5132 : : ftrace_stop();
5133 : : }
5134 : : #endif
|
