Merge tag 'trace-fixes-v3.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / kernel / trace / ftrace.c
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_CONTROL)
66
67 #ifdef CONFIG_DYNAMIC_FTRACE
68 #define INIT_OPS_HASH(opsname)  \
69         .func_hash              = &opsname.local_hash,                  \
70         .local_hash.regex_lock  = __MUTEX_INITIALIZER(opsname.local_hash.regex_lock),
71 #define ASSIGN_OPS_HASH(opsname, val) \
72         .func_hash              = val, \
73         .local_hash.regex_lock  = __MUTEX_INITIALIZER(opsname.local_hash.regex_lock),
74 #else
75 #define INIT_OPS_HASH(opsname)
76 #define ASSIGN_OPS_HASH(opsname, val)
77 #endif
78
79 static struct ftrace_ops ftrace_list_end __read_mostly = {
80         .func           = ftrace_stub,
81         .flags          = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_STUB,
82         INIT_OPS_HASH(ftrace_list_end)
83 };
84
85 /* ftrace_enabled is a method to turn ftrace on or off */
86 int ftrace_enabled __read_mostly;
87 static int last_ftrace_enabled;
88
89 /* Current function tracing op */
90 struct ftrace_ops *function_trace_op __read_mostly = &ftrace_list_end;
91 /* What to set function_trace_op to */
92 static struct ftrace_ops *set_function_trace_op;
93
94 /* List for set_ftrace_pid's pids. */
95 LIST_HEAD(ftrace_pids);
96 struct ftrace_pid {
97         struct list_head list;
98         struct pid *pid;
99 };
100
101 /*
102  * ftrace_disabled is set when an anomaly is discovered.
103  * ftrace_disabled is much stronger than ftrace_enabled.
104  */
105 static int ftrace_disabled __read_mostly;
106
107 static DEFINE_MUTEX(ftrace_lock);
108
109 static struct ftrace_ops *ftrace_control_list __read_mostly = &ftrace_list_end;
110 static struct ftrace_ops *ftrace_ops_list __read_mostly = &ftrace_list_end;
111 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
112 ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub;
113 static struct ftrace_ops global_ops;
114 static struct ftrace_ops control_ops;
115
116 static void ftrace_ops_recurs_func(unsigned long ip, unsigned long parent_ip,
117                                    struct ftrace_ops *op, struct pt_regs *regs);
118
119 #if ARCH_SUPPORTS_FTRACE_OPS
120 static void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
121                                  struct ftrace_ops *op, struct pt_regs *regs);
122 #else
123 /* See comment below, where ftrace_ops_list_func is defined */
124 static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip);
125 #define ftrace_ops_list_func ((ftrace_func_t)ftrace_ops_no_ops)
126 #endif
127
128 /*
129  * Traverse the ftrace_global_list, invoking all entries.  The reason that we
130  * can use rcu_dereference_raw_notrace() is that elements removed from this list
131  * are simply leaked, so there is no need to interact with a grace-period
132  * mechanism.  The rcu_dereference_raw_notrace() calls are needed to handle
133  * concurrent insertions into the ftrace_global_list.
134  *
135  * Silly Alpha and silly pointer-speculation compiler optimizations!
136  */
137 #define do_for_each_ftrace_op(op, list)                 \
138         op = rcu_dereference_raw_notrace(list);                 \
139         do
140
141 /*
142  * Optimized for just a single item in the list (as that is the normal case).
143  */
144 #define while_for_each_ftrace_op(op)                            \
145         while (likely(op = rcu_dereference_raw_notrace((op)->next)) &&  \
146                unlikely((op) != &ftrace_list_end))
147
148 static inline void ftrace_ops_init(struct ftrace_ops *ops)
149 {
150 #ifdef CONFIG_DYNAMIC_FTRACE
151         if (!(ops->flags & FTRACE_OPS_FL_INITIALIZED)) {
152                 mutex_init(&ops->local_hash.regex_lock);
153                 ops->func_hash = &ops->local_hash;
154                 ops->flags |= FTRACE_OPS_FL_INITIALIZED;
155         }
156 #endif
157 }
158
159 /**
160  * ftrace_nr_registered_ops - return number of ops registered
161  *
162  * Returns the number of ftrace_ops registered and tracing functions
163  */
164 int ftrace_nr_registered_ops(void)
165 {
166         struct ftrace_ops *ops;
167         int cnt = 0;
168
169         mutex_lock(&ftrace_lock);
170
171         for (ops = ftrace_ops_list;
172              ops != &ftrace_list_end; ops = ops->next)
173                 cnt++;
174
175         mutex_unlock(&ftrace_lock);
176
177         return cnt;
178 }
179
180 static void ftrace_pid_func(unsigned long ip, unsigned long parent_ip,
181                             struct ftrace_ops *op, struct pt_regs *regs)
182 {
183         if (!test_tsk_trace_trace(current))
184                 return;
185
186         ftrace_pid_function(ip, parent_ip, op, regs);
187 }
188
189 static void set_ftrace_pid_function(ftrace_func_t func)
190 {
191         /* do not set ftrace_pid_function to itself! */
192         if (func != ftrace_pid_func)
193                 ftrace_pid_function = func;
194 }
195
196 /**
197  * clear_ftrace_function - reset the ftrace function
198  *
199  * This NULLs the ftrace function and in essence stops
200  * tracing.  There may be lag
201  */
202 void clear_ftrace_function(void)
203 {
204         ftrace_trace_function = ftrace_stub;
205         ftrace_pid_function = ftrace_stub;
206 }
207
208 static void control_ops_disable_all(struct ftrace_ops *ops)
209 {
210         int cpu;
211
212         for_each_possible_cpu(cpu)
213                 *per_cpu_ptr(ops->disabled, cpu) = 1;
214 }
215
216 static int control_ops_alloc(struct ftrace_ops *ops)
217 {
218         int __percpu *disabled;
219
220         disabled = alloc_percpu(int);
221         if (!disabled)
222                 return -ENOMEM;
223
224         ops->disabled = disabled;
225         control_ops_disable_all(ops);
226         return 0;
227 }
228
229 static void ftrace_sync(struct work_struct *work)
230 {
231         /*
232          * This function is just a stub to implement a hard force
233          * of synchronize_sched(). This requires synchronizing
234          * tasks even in userspace and idle.
235          *
236          * Yes, function tracing is rude.
237          */
238 }
239
240 static void ftrace_sync_ipi(void *data)
241 {
242         /* Probably not needed, but do it anyway */
243         smp_rmb();
244 }
245
246 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
247 static void update_function_graph_func(void);
248 #else
249 static inline void update_function_graph_func(void) { }
250 #endif
251
252 static void update_ftrace_function(void)
253 {
254         ftrace_func_t func;
255
256         /*
257          * Prepare the ftrace_ops that the arch callback will use.
258          * If there's only one ftrace_ops registered, the ftrace_ops_list
259          * will point to the ops we want.
260          */
261         set_function_trace_op = ftrace_ops_list;
262
263         /* If there's no ftrace_ops registered, just call the stub function */
264         if (ftrace_ops_list == &ftrace_list_end) {
265                 func = ftrace_stub;
266
267         /*
268          * If we are at the end of the list and this ops is
269          * recursion safe and not dynamic and the arch supports passing ops,
270          * then have the mcount trampoline call the function directly.
271          */
272         } else if (ftrace_ops_list->next == &ftrace_list_end) {
273                 func = ftrace_ops_get_func(ftrace_ops_list);
274
275         } else {
276                 /* Just use the default ftrace_ops */
277                 set_function_trace_op = &ftrace_list_end;
278                 func = ftrace_ops_list_func;
279         }
280
281         update_function_graph_func();
282
283         /* If there's no change, then do nothing more here */
284         if (ftrace_trace_function == func)
285                 return;
286
287         /*
288          * If we are using the list function, it doesn't care
289          * about the function_trace_ops.
290          */
291         if (func == ftrace_ops_list_func) {
292                 ftrace_trace_function = func;
293                 /*
294                  * Don't even bother setting function_trace_ops,
295                  * it would be racy to do so anyway.
296                  */
297                 return;
298         }
299
300 #ifndef CONFIG_DYNAMIC_FTRACE
301         /*
302          * For static tracing, we need to be a bit more careful.
303          * The function change takes affect immediately. Thus,
304          * we need to coorditate the setting of the function_trace_ops
305          * with the setting of the ftrace_trace_function.
306          *
307          * Set the function to the list ops, which will call the
308          * function we want, albeit indirectly, but it handles the
309          * ftrace_ops and doesn't depend on function_trace_op.
310          */
311         ftrace_trace_function = ftrace_ops_list_func;
312         /*
313          * Make sure all CPUs see this. Yes this is slow, but static
314          * tracing is slow and nasty to have enabled.
315          */
316         schedule_on_each_cpu(ftrace_sync);
317         /* Now all cpus are using the list ops. */
318         function_trace_op = set_function_trace_op;
319         /* Make sure the function_trace_op is visible on all CPUs */
320         smp_wmb();
321         /* Nasty way to force a rmb on all cpus */
322         smp_call_function(ftrace_sync_ipi, NULL, 1);
323         /* OK, we are all set to update the ftrace_trace_function now! */
324 #endif /* !CONFIG_DYNAMIC_FTRACE */
325
326         ftrace_trace_function = func;
327 }
328
329 int using_ftrace_ops_list_func(void)
330 {
331         return ftrace_trace_function == ftrace_ops_list_func;
332 }
333
334 static void add_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
335 {
336         ops->next = *list;
337         /*
338          * We are entering ops into the list but another
339          * CPU might be walking that list. We need to make sure
340          * the ops->next pointer is valid before another CPU sees
341          * the ops pointer included into the list.
342          */
343         rcu_assign_pointer(*list, ops);
344 }
345
346 static int remove_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
347 {
348         struct ftrace_ops **p;
349
350         /*
351          * If we are removing the last function, then simply point
352          * to the ftrace_stub.
353          */
354         if (*list == ops && ops->next == &ftrace_list_end) {
355                 *list = &ftrace_list_end;
356                 return 0;
357         }
358
359         for (p = list; *p != &ftrace_list_end; p = &(*p)->next)
360                 if (*p == ops)
361                         break;
362
363         if (*p != ops)
364                 return -1;
365
366         *p = (*p)->next;
367         return 0;
368 }
369
370 static void add_ftrace_list_ops(struct ftrace_ops **list,
371                                 struct ftrace_ops *main_ops,
372                                 struct ftrace_ops *ops)
373 {
374         int first = *list == &ftrace_list_end;
375         add_ftrace_ops(list, ops);
376         if (first)
377                 add_ftrace_ops(&ftrace_ops_list, main_ops);
378 }
379
380 static int remove_ftrace_list_ops(struct ftrace_ops **list,
381                                   struct ftrace_ops *main_ops,
382                                   struct ftrace_ops *ops)
383 {
384         int ret = remove_ftrace_ops(list, ops);
385         if (!ret && *list == &ftrace_list_end)
386                 ret = remove_ftrace_ops(&ftrace_ops_list, main_ops);
387         return ret;
388 }
389
390 static int __register_ftrace_function(struct ftrace_ops *ops)
391 {
392         if (ops->flags & FTRACE_OPS_FL_DELETED)
393                 return -EINVAL;
394
395         if (WARN_ON(ops->flags & FTRACE_OPS_FL_ENABLED))
396                 return -EBUSY;
397
398 #ifndef CONFIG_DYNAMIC_FTRACE_WITH_REGS
399         /*
400          * If the ftrace_ops specifies SAVE_REGS, then it only can be used
401          * if the arch supports it, or SAVE_REGS_IF_SUPPORTED is also set.
402          * Setting SAVE_REGS_IF_SUPPORTED makes SAVE_REGS irrelevant.
403          */
404         if (ops->flags & FTRACE_OPS_FL_SAVE_REGS &&
405             !(ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED))
406                 return -EINVAL;
407
408         if (ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED)
409                 ops->flags |= FTRACE_OPS_FL_SAVE_REGS;
410 #endif
411
412         if (!core_kernel_data((unsigned long)ops))
413                 ops->flags |= FTRACE_OPS_FL_DYNAMIC;
414
415         if (ops->flags & FTRACE_OPS_FL_CONTROL) {
416                 if (control_ops_alloc(ops))
417                         return -ENOMEM;
418                 add_ftrace_list_ops(&ftrace_control_list, &control_ops, ops);
419         } else
420                 add_ftrace_ops(&ftrace_ops_list, ops);
421
422         if (ftrace_enabled)
423                 update_ftrace_function();
424
425         return 0;
426 }
427
428 static int __unregister_ftrace_function(struct ftrace_ops *ops)
429 {
430         int ret;
431
432         if (WARN_ON(!(ops->flags & FTRACE_OPS_FL_ENABLED)))
433                 return -EBUSY;
434
435         if (ops->flags & FTRACE_OPS_FL_CONTROL) {
436                 ret = remove_ftrace_list_ops(&ftrace_control_list,
437                                              &control_ops, ops);
438         } else
439                 ret = remove_ftrace_ops(&ftrace_ops_list, ops);
440
441         if (ret < 0)
442                 return ret;
443
444         if (ftrace_enabled)
445                 update_ftrace_function();
446
447         return 0;
448 }
449
450 static void ftrace_update_pid_func(void)
451 {
452         /* Only do something if we are tracing something */
453         if (ftrace_trace_function == ftrace_stub)
454                 return;
455
456         update_ftrace_function();
457 }
458
459 #ifdef CONFIG_FUNCTION_PROFILER
460 struct ftrace_profile {
461         struct hlist_node               node;
462         unsigned long                   ip;
463         unsigned long                   counter;
464 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
465         unsigned long long              time;
466         unsigned long long              time_squared;
467 #endif
468 };
469
470 struct ftrace_profile_page {
471         struct ftrace_profile_page      *next;
472         unsigned long                   index;
473         struct ftrace_profile           records[];
474 };
475
476 struct ftrace_profile_stat {
477         atomic_t                        disabled;
478         struct hlist_head               *hash;
479         struct ftrace_profile_page      *pages;
480         struct ftrace_profile_page      *start;
481         struct tracer_stat              stat;
482 };
483
484 #define PROFILE_RECORDS_SIZE                                            \
485         (PAGE_SIZE - offsetof(struct ftrace_profile_page, records))
486
487 #define PROFILES_PER_PAGE                                       \
488         (PROFILE_RECORDS_SIZE / sizeof(struct ftrace_profile))
489
490 static int ftrace_profile_enabled __read_mostly;
491
492 /* ftrace_profile_lock - synchronize the enable and disable of the profiler */
493 static DEFINE_MUTEX(ftrace_profile_lock);
494
495 static DEFINE_PER_CPU(struct ftrace_profile_stat, ftrace_profile_stats);
496
497 #define FTRACE_PROFILE_HASH_BITS 10
498 #define FTRACE_PROFILE_HASH_SIZE (1 << FTRACE_PROFILE_HASH_BITS)
499
500 static void *
501 function_stat_next(void *v, int idx)
502 {
503         struct ftrace_profile *rec = v;
504         struct ftrace_profile_page *pg;
505
506         pg = (struct ftrace_profile_page *)((unsigned long)rec & PAGE_MASK);
507
508  again:
509         if (idx != 0)
510                 rec++;
511
512         if ((void *)rec >= (void *)&pg->records[pg->index]) {
513                 pg = pg->next;
514                 if (!pg)
515                         return NULL;
516                 rec = &pg->records[0];
517                 if (!rec->counter)
518                         goto again;
519         }
520
521         return rec;
522 }
523
524 static void *function_stat_start(struct tracer_stat *trace)
525 {
526         struct ftrace_profile_stat *stat =
527                 container_of(trace, struct ftrace_profile_stat, stat);
528
529         if (!stat || !stat->start)
530                 return NULL;
531
532         return function_stat_next(&stat->start->records[0], 0);
533 }
534
535 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
536 /* function graph compares on total time */
537 static int function_stat_cmp(void *p1, void *p2)
538 {
539         struct ftrace_profile *a = p1;
540         struct ftrace_profile *b = p2;
541
542         if (a->time < b->time)
543                 return -1;
544         if (a->time > b->time)
545                 return 1;
546         else
547                 return 0;
548 }
549 #else
550 /* not function graph compares against hits */
551 static int function_stat_cmp(void *p1, void *p2)
552 {
553         struct ftrace_profile *a = p1;
554         struct ftrace_profile *b = p2;
555
556         if (a->counter < b->counter)
557                 return -1;
558         if (a->counter > b->counter)
559                 return 1;
560         else
561                 return 0;
562 }
563 #endif
564
565 static int function_stat_headers(struct seq_file *m)
566 {
567 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
568         seq_printf(m, "  Function                               "
569                    "Hit    Time            Avg             s^2\n"
570                       "  --------                               "
571                    "---    ----            ---             ---\n");
572 #else
573         seq_printf(m, "  Function                               Hit\n"
574                       "  --------                               ---\n");
575 #endif
576         return 0;
577 }
578
579 static int function_stat_show(struct seq_file *m, void *v)
580 {
581         struct ftrace_profile *rec = v;
582         char str[KSYM_SYMBOL_LEN];
583         int ret = 0;
584 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
585         static struct trace_seq s;
586         unsigned long long avg;
587         unsigned long long stddev;
588 #endif
589         mutex_lock(&ftrace_profile_lock);
590
591         /* we raced with function_profile_reset() */
592         if (unlikely(rec->counter == 0)) {
593                 ret = -EBUSY;
594                 goto out;
595         }
596
597         kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
598         seq_printf(m, "  %-30.30s  %10lu", str, rec->counter);
599
600 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
601         seq_printf(m, "    ");
602         avg = rec->time;
603         do_div(avg, rec->counter);
604
605         /* Sample standard deviation (s^2) */
606         if (rec->counter <= 1)
607                 stddev = 0;
608         else {
609                 /*
610                  * Apply Welford's method:
611                  * s^2 = 1 / (n * (n-1)) * (n * \Sum (x_i)^2 - (\Sum x_i)^2)
612                  */
613                 stddev = rec->counter * rec->time_squared -
614                          rec->time * rec->time;
615
616                 /*
617                  * Divide only 1000 for ns^2 -> us^2 conversion.
618                  * trace_print_graph_duration will divide 1000 again.
619                  */
620                 do_div(stddev, rec->counter * (rec->counter - 1) * 1000);
621         }
622
623         trace_seq_init(&s);
624         trace_print_graph_duration(rec->time, &s);
625         trace_seq_puts(&s, "    ");
626         trace_print_graph_duration(avg, &s);
627         trace_seq_puts(&s, "    ");
628         trace_print_graph_duration(stddev, &s);
629         trace_print_seq(m, &s);
630 #endif
631         seq_putc(m, '\n');
632 out:
633         mutex_unlock(&ftrace_profile_lock);
634
635         return ret;
636 }
637
638 static void ftrace_profile_reset(struct ftrace_profile_stat *stat)
639 {
640         struct ftrace_profile_page *pg;
641
642         pg = stat->pages = stat->start;
643
644         while (pg) {
645                 memset(pg->records, 0, PROFILE_RECORDS_SIZE);
646                 pg->index = 0;
647                 pg = pg->next;
648         }
649
650         memset(stat->hash, 0,
651                FTRACE_PROFILE_HASH_SIZE * sizeof(struct hlist_head));
652 }
653
654 int ftrace_profile_pages_init(struct ftrace_profile_stat *stat)
655 {
656         struct ftrace_profile_page *pg;
657         int functions;
658         int pages;
659         int i;
660
661         /* If we already allocated, do nothing */
662         if (stat->pages)
663                 return 0;
664
665         stat->pages = (void *)get_zeroed_page(GFP_KERNEL);
666         if (!stat->pages)
667                 return -ENOMEM;
668
669 #ifdef CONFIG_DYNAMIC_FTRACE
670         functions = ftrace_update_tot_cnt;
671 #else
672         /*
673          * We do not know the number of functions that exist because
674          * dynamic tracing is what counts them. With past experience
675          * we have around 20K functions. That should be more than enough.
676          * It is highly unlikely we will execute every function in
677          * the kernel.
678          */
679         functions = 20000;
680 #endif
681
682         pg = stat->start = stat->pages;
683
684         pages = DIV_ROUND_UP(functions, PROFILES_PER_PAGE);
685
686         for (i = 1; i < pages; i++) {
687                 pg->next = (void *)get_zeroed_page(GFP_KERNEL);
688                 if (!pg->next)
689                         goto out_free;
690                 pg = pg->next;
691         }
692
693         return 0;
694
695  out_free:
696         pg = stat->start;
697         while (pg) {
698                 unsigned long tmp = (unsigned long)pg;
699
700                 pg = pg->next;
701                 free_page(tmp);
702         }
703
704         stat->pages = NULL;
705         stat->start = NULL;
706
707         return -ENOMEM;
708 }
709
710 static int ftrace_profile_init_cpu(int cpu)
711 {
712         struct ftrace_profile_stat *stat;
713         int size;
714
715         stat = &per_cpu(ftrace_profile_stats, cpu);
716
717         if (stat->hash) {
718                 /* If the profile is already created, simply reset it */
719                 ftrace_profile_reset(stat);
720                 return 0;
721         }
722
723         /*
724          * We are profiling all functions, but usually only a few thousand
725          * functions are hit. We'll make a hash of 1024 items.
726          */
727         size = FTRACE_PROFILE_HASH_SIZE;
728
729         stat->hash = kzalloc(sizeof(struct hlist_head) * size, GFP_KERNEL);
730
731         if (!stat->hash)
732                 return -ENOMEM;
733
734         /* Preallocate the function profiling pages */
735         if (ftrace_profile_pages_init(stat) < 0) {
736                 kfree(stat->hash);
737                 stat->hash = NULL;
738                 return -ENOMEM;
739         }
740
741         return 0;
742 }
743
744 static int ftrace_profile_init(void)
745 {
746         int cpu;
747         int ret = 0;
748
749         for_each_possible_cpu(cpu) {
750                 ret = ftrace_profile_init_cpu(cpu);
751                 if (ret)
752                         break;
753         }
754
755         return ret;
756 }
757
758 /* interrupts must be disabled */
759 static struct ftrace_profile *
760 ftrace_find_profiled_func(struct ftrace_profile_stat *stat, unsigned long ip)
761 {
762         struct ftrace_profile *rec;
763         struct hlist_head *hhd;
764         unsigned long key;
765
766         key = hash_long(ip, FTRACE_PROFILE_HASH_BITS);
767         hhd = &stat->hash[key];
768
769         if (hlist_empty(hhd))
770                 return NULL;
771
772         hlist_for_each_entry_rcu_notrace(rec, hhd, node) {
773                 if (rec->ip == ip)
774                         return rec;
775         }
776
777         return NULL;
778 }
779
780 static void ftrace_add_profile(struct ftrace_profile_stat *stat,
781                                struct ftrace_profile *rec)
782 {
783         unsigned long key;
784
785         key = hash_long(rec->ip, FTRACE_PROFILE_HASH_BITS);
786         hlist_add_head_rcu(&rec->node, &stat->hash[key]);
787 }
788
789 /*
790  * The memory is already allocated, this simply finds a new record to use.
791  */
792 static struct ftrace_profile *
793 ftrace_profile_alloc(struct ftrace_profile_stat *stat, unsigned long ip)
794 {
795         struct ftrace_profile *rec = NULL;
796
797         /* prevent recursion (from NMIs) */
798         if (atomic_inc_return(&stat->disabled) != 1)
799                 goto out;
800
801         /*
802          * Try to find the function again since an NMI
803          * could have added it
804          */
805         rec = ftrace_find_profiled_func(stat, ip);
806         if (rec)
807                 goto out;
808
809         if (stat->pages->index == PROFILES_PER_PAGE) {
810                 if (!stat->pages->next)
811                         goto out;
812                 stat->pages = stat->pages->next;
813         }
814
815         rec = &stat->pages->records[stat->pages->index++];
816         rec->ip = ip;
817         ftrace_add_profile(stat, rec);
818
819  out:
820         atomic_dec(&stat->disabled);
821
822         return rec;
823 }
824
825 static void
826 function_profile_call(unsigned long ip, unsigned long parent_ip,
827                       struct ftrace_ops *ops, struct pt_regs *regs)
828 {
829         struct ftrace_profile_stat *stat;
830         struct ftrace_profile *rec;
831         unsigned long flags;
832
833         if (!ftrace_profile_enabled)
834                 return;
835
836         local_irq_save(flags);
837
838         stat = this_cpu_ptr(&ftrace_profile_stats);
839         if (!stat->hash || !ftrace_profile_enabled)
840                 goto out;
841
842         rec = ftrace_find_profiled_func(stat, ip);
843         if (!rec) {
844                 rec = ftrace_profile_alloc(stat, ip);
845                 if (!rec)
846                         goto out;
847         }
848
849         rec->counter++;
850  out:
851         local_irq_restore(flags);
852 }
853
854 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
855 static int profile_graph_entry(struct ftrace_graph_ent *trace)
856 {
857         function_profile_call(trace->func, 0, NULL, NULL);
858         return 1;
859 }
860
861 static void profile_graph_return(struct ftrace_graph_ret *trace)
862 {
863         struct ftrace_profile_stat *stat;
864         unsigned long long calltime;
865         struct ftrace_profile *rec;
866         unsigned long flags;
867
868         local_irq_save(flags);
869         stat = this_cpu_ptr(&ftrace_profile_stats);
870         if (!stat->hash || !ftrace_profile_enabled)
871                 goto out;
872
873         /* If the calltime was zero'd ignore it */
874         if (!trace->calltime)
875                 goto out;
876
877         calltime = trace->rettime - trace->calltime;
878
879         if (!(trace_flags & TRACE_ITER_GRAPH_TIME)) {
880                 int index;
881
882                 index = trace->depth;
883
884                 /* Append this call time to the parent time to subtract */
885                 if (index)
886                         current->ret_stack[index - 1].subtime += calltime;
887
888                 if (current->ret_stack[index].subtime < calltime)
889                         calltime -= current->ret_stack[index].subtime;
890                 else
891                         calltime = 0;
892         }
893
894         rec = ftrace_find_profiled_func(stat, trace->func);
895         if (rec) {
896                 rec->time += calltime;
897                 rec->time_squared += calltime * calltime;
898         }
899
900  out:
901         local_irq_restore(flags);
902 }
903
904 static int register_ftrace_profiler(void)
905 {
906         return register_ftrace_graph(&profile_graph_return,
907                                      &profile_graph_entry);
908 }
909
910 static void unregister_ftrace_profiler(void)
911 {
912         unregister_ftrace_graph();
913 }
914 #else
915 static struct ftrace_ops ftrace_profile_ops __read_mostly = {
916         .func           = function_profile_call,
917         .flags          = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,
918         INIT_OPS_HASH(ftrace_profile_ops)
919 };
920
921 static int register_ftrace_profiler(void)
922 {
923         return register_ftrace_function(&ftrace_profile_ops);
924 }
925
926 static void unregister_ftrace_profiler(void)
927 {
928         unregister_ftrace_function(&ftrace_profile_ops);
929 }
930 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
931
932 static ssize_t
933 ftrace_profile_write(struct file *filp, const char __user *ubuf,
934                      size_t cnt, loff_t *ppos)
935 {
936         unsigned long val;
937         int ret;
938
939         ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
940         if (ret)
941                 return ret;
942
943         val = !!val;
944
945         mutex_lock(&ftrace_profile_lock);
946         if (ftrace_profile_enabled ^ val) {
947                 if (val) {
948                         ret = ftrace_profile_init();
949                         if (ret < 0) {
950                                 cnt = ret;
951                                 goto out;
952                         }
953
954                         ret = register_ftrace_profiler();
955                         if (ret < 0) {
956                                 cnt = ret;
957                                 goto out;
958                         }
959                         ftrace_profile_enabled = 1;
960                 } else {
961                         ftrace_profile_enabled = 0;
962                         /*
963                          * unregister_ftrace_profiler calls stop_machine
964                          * so this acts like an synchronize_sched.
965                          */
966                         unregister_ftrace_profiler();
967                 }
968         }
969  out:
970         mutex_unlock(&ftrace_profile_lock);
971
972         *ppos += cnt;
973
974         return cnt;
975 }
976
977 static ssize_t
978 ftrace_profile_read(struct file *filp, char __user *ubuf,
979                      size_t cnt, loff_t *ppos)
980 {
981         char buf[64];           /* big enough to hold a number */
982         int r;
983
984         r = sprintf(buf, "%u\n", ftrace_profile_enabled);
985         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
986 }
987
988 static const struct file_operations ftrace_profile_fops = {
989         .open           = tracing_open_generic,
990         .read           = ftrace_profile_read,
991         .write          = ftrace_profile_write,
992         .llseek         = default_llseek,
993 };
994
995 /* used to initialize the real stat files */
996 static struct tracer_stat function_stats __initdata = {
997         .name           = "functions",
998         .stat_start     = function_stat_start,
999         .stat_next      = function_stat_next,
1000         .stat_cmp       = function_stat_cmp,
1001         .stat_headers   = function_stat_headers,
1002         .stat_show      = function_stat_show
1003 };
1004
1005 static __init void ftrace_profile_debugfs(struct dentry *d_tracer)
1006 {
1007         struct ftrace_profile_stat *stat;
1008         struct dentry *entry;
1009         char *name;
1010         int ret;
1011         int cpu;
1012
1013         for_each_possible_cpu(cpu) {
1014                 stat = &per_cpu(ftrace_profile_stats, cpu);
1015
1016                 /* allocate enough for function name + cpu number */
1017                 name = kmalloc(32, GFP_KERNEL);
1018                 if (!name) {
1019                         /*
1020                          * The files created are permanent, if something happens
1021                          * we still do not free memory.
1022                          */
1023                         WARN(1,
1024                              "Could not allocate stat file for cpu %d\n",
1025                              cpu);
1026                         return;
1027                 }
1028                 stat->stat = function_stats;
1029                 snprintf(name, 32, "function%d", cpu);
1030                 stat->stat.name = name;
1031                 ret = register_stat_tracer(&stat->stat);
1032                 if (ret) {
1033                         WARN(1,
1034                              "Could not register function stat for cpu %d\n",
1035                              cpu);
1036                         kfree(name);
1037                         return;
1038                 }
1039         }
1040
1041         entry = debugfs_create_file("function_profile_enabled", 0644,
1042                                     d_tracer, NULL, &ftrace_profile_fops);
1043         if (!entry)
1044                 pr_warning("Could not create debugfs "
1045                            "'function_profile_enabled' entry\n");
1046 }
1047
1048 #else /* CONFIG_FUNCTION_PROFILER */
1049 static __init void ftrace_profile_debugfs(struct dentry *d_tracer)
1050 {
1051 }
1052 #endif /* CONFIG_FUNCTION_PROFILER */
1053
1054 static struct pid * const ftrace_swapper_pid = &init_struct_pid;
1055
1056 #ifdef CONFIG_DYNAMIC_FTRACE
1057
1058 static struct ftrace_ops *removed_ops;
1059
1060 /*
1061  * Set when doing a global update, like enabling all recs or disabling them.
1062  * It is not set when just updating a single ftrace_ops.
1063  */
1064 static bool update_all_ops;
1065
1066 #ifndef CONFIG_FTRACE_MCOUNT_RECORD
1067 # error Dynamic ftrace depends on MCOUNT_RECORD
1068 #endif
1069
1070 static struct hlist_head ftrace_func_hash[FTRACE_FUNC_HASHSIZE] __read_mostly;
1071
1072 struct ftrace_func_probe {
1073         struct hlist_node       node;
1074         struct ftrace_probe_ops *ops;
1075         unsigned long           flags;
1076         unsigned long           ip;
1077         void                    *data;
1078         struct list_head        free_list;
1079 };
1080
1081 struct ftrace_func_entry {
1082         struct hlist_node hlist;
1083         unsigned long ip;
1084 };
1085
1086 struct ftrace_hash {
1087         unsigned long           size_bits;
1088         struct hlist_head       *buckets;
1089         unsigned long           count;
1090         struct rcu_head         rcu;
1091 };
1092
1093 /*
1094  * We make these constant because no one should touch them,
1095  * but they are used as the default "empty hash", to avoid allocating
1096  * it all the time. These are in a read only section such that if
1097  * anyone does try to modify it, it will cause an exception.
1098  */
1099 static const struct hlist_head empty_buckets[1];
1100 static const struct ftrace_hash empty_hash = {
1101         .buckets = (struct hlist_head *)empty_buckets,
1102 };
1103 #define EMPTY_HASH      ((struct ftrace_hash *)&empty_hash)
1104
1105 static struct ftrace_ops global_ops = {
1106         .func                           = ftrace_stub,
1107         .local_hash.notrace_hash        = EMPTY_HASH,
1108         .local_hash.filter_hash         = EMPTY_HASH,
1109         INIT_OPS_HASH(global_ops)
1110         .flags                          = FTRACE_OPS_FL_RECURSION_SAFE |
1111                                           FTRACE_OPS_FL_INITIALIZED,
1112 };
1113
1114 struct ftrace_page {
1115         struct ftrace_page      *next;
1116         struct dyn_ftrace       *records;
1117         int                     index;
1118         int                     size;
1119 };
1120
1121 #define ENTRY_SIZE sizeof(struct dyn_ftrace)
1122 #define ENTRIES_PER_PAGE (PAGE_SIZE / ENTRY_SIZE)
1123
1124 /* estimate from running different kernels */
1125 #define NR_TO_INIT              10000
1126
1127 static struct ftrace_page       *ftrace_pages_start;
1128 static struct ftrace_page       *ftrace_pages;
1129
1130 static bool __always_inline ftrace_hash_empty(struct ftrace_hash *hash)
1131 {
1132         return !hash || !hash->count;
1133 }
1134
1135 static struct ftrace_func_entry *
1136 ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip)
1137 {
1138         unsigned long key;
1139         struct ftrace_func_entry *entry;
1140         struct hlist_head *hhd;
1141
1142         if (ftrace_hash_empty(hash))
1143                 return NULL;
1144
1145         if (hash->size_bits > 0)
1146                 key = hash_long(ip, hash->size_bits);
1147         else
1148                 key = 0;
1149
1150         hhd = &hash->buckets[key];
1151
1152         hlist_for_each_entry_rcu_notrace(entry, hhd, hlist) {
1153                 if (entry->ip == ip)
1154                         return entry;
1155         }
1156         return NULL;
1157 }
1158
1159 static void __add_hash_entry(struct ftrace_hash *hash,
1160                              struct ftrace_func_entry *entry)
1161 {
1162         struct hlist_head *hhd;
1163         unsigned long key;
1164
1165         if (hash->size_bits)
1166                 key = hash_long(entry->ip, hash->size_bits);
1167         else
1168                 key = 0;
1169
1170         hhd = &hash->buckets[key];
1171         hlist_add_head(&entry->hlist, hhd);
1172         hash->count++;
1173 }
1174
1175 static int add_hash_entry(struct ftrace_hash *hash, unsigned long ip)
1176 {
1177         struct ftrace_func_entry *entry;
1178
1179         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
1180         if (!entry)
1181                 return -ENOMEM;
1182
1183         entry->ip = ip;
1184         __add_hash_entry(hash, entry);
1185
1186         return 0;
1187 }
1188
1189 static void
1190 free_hash_entry(struct ftrace_hash *hash,
1191                   struct ftrace_func_entry *entry)
1192 {
1193         hlist_del(&entry->hlist);
1194         kfree(entry);
1195         hash->count--;
1196 }
1197
1198 static void
1199 remove_hash_entry(struct ftrace_hash *hash,
1200                   struct ftrace_func_entry *entry)
1201 {
1202         hlist_del(&entry->hlist);
1203         hash->count--;
1204 }
1205
1206 static void ftrace_hash_clear(struct ftrace_hash *hash)
1207 {
1208         struct hlist_head *hhd;
1209         struct hlist_node *tn;
1210         struct ftrace_func_entry *entry;
1211         int size = 1 << hash->size_bits;
1212         int i;
1213
1214         if (!hash->count)
1215                 return;
1216
1217         for (i = 0; i < size; i++) {
1218                 hhd = &hash->buckets[i];
1219                 hlist_for_each_entry_safe(entry, tn, hhd, hlist)
1220                         free_hash_entry(hash, entry);
1221         }
1222         FTRACE_WARN_ON(hash->count);
1223 }
1224
1225 static void free_ftrace_hash(struct ftrace_hash *hash)
1226 {
1227         if (!hash || hash == EMPTY_HASH)
1228                 return;
1229         ftrace_hash_clear(hash);
1230         kfree(hash->buckets);
1231         kfree(hash);
1232 }
1233
1234 static void __free_ftrace_hash_rcu(struct rcu_head *rcu)
1235 {
1236         struct ftrace_hash *hash;
1237
1238         hash = container_of(rcu, struct ftrace_hash, rcu);
1239         free_ftrace_hash(hash);
1240 }
1241
1242 static void free_ftrace_hash_rcu(struct ftrace_hash *hash)
1243 {
1244         if (!hash || hash == EMPTY_HASH)
1245                 return;
1246         call_rcu_sched(&hash->rcu, __free_ftrace_hash_rcu);
1247 }
1248
1249 void ftrace_free_filter(struct ftrace_ops *ops)
1250 {
1251         ftrace_ops_init(ops);
1252         free_ftrace_hash(ops->func_hash->filter_hash);
1253         free_ftrace_hash(ops->func_hash->notrace_hash);
1254 }
1255
1256 static struct ftrace_hash *alloc_ftrace_hash(int size_bits)
1257 {
1258         struct ftrace_hash *hash;
1259         int size;
1260
1261         hash = kzalloc(sizeof(*hash), GFP_KERNEL);
1262         if (!hash)
1263                 return NULL;
1264
1265         size = 1 << size_bits;
1266         hash->buckets = kcalloc(size, sizeof(*hash->buckets), GFP_KERNEL);
1267
1268         if (!hash->buckets) {
1269                 kfree(hash);
1270                 return NULL;
1271         }
1272
1273         hash->size_bits = size_bits;
1274
1275         return hash;
1276 }
1277
1278 static struct ftrace_hash *
1279 alloc_and_copy_ftrace_hash(int size_bits, struct ftrace_hash *hash)
1280 {
1281         struct ftrace_func_entry *entry;
1282         struct ftrace_hash *new_hash;
1283         int size;
1284         int ret;
1285         int i;
1286
1287         new_hash = alloc_ftrace_hash(size_bits);
1288         if (!new_hash)
1289                 return NULL;
1290
1291         /* Empty hash? */
1292         if (ftrace_hash_empty(hash))
1293                 return new_hash;
1294
1295         size = 1 << hash->size_bits;
1296         for (i = 0; i < size; i++) {
1297                 hlist_for_each_entry(entry, &hash->buckets[i], hlist) {
1298                         ret = add_hash_entry(new_hash, entry->ip);
1299                         if (ret < 0)
1300                                 goto free_hash;
1301                 }
1302         }
1303
1304         FTRACE_WARN_ON(new_hash->count != hash->count);
1305
1306         return new_hash;
1307
1308  free_hash:
1309         free_ftrace_hash(new_hash);
1310         return NULL;
1311 }
1312
1313 static void
1314 ftrace_hash_rec_disable_modify(struct ftrace_ops *ops, int filter_hash);
1315 static void
1316 ftrace_hash_rec_enable_modify(struct ftrace_ops *ops, int filter_hash);
1317
1318 static int
1319 ftrace_hash_move(struct ftrace_ops *ops, int enable,
1320                  struct ftrace_hash **dst, struct ftrace_hash *src)
1321 {
1322         struct ftrace_func_entry *entry;
1323         struct hlist_node *tn;
1324         struct hlist_head *hhd;
1325         struct ftrace_hash *new_hash;
1326         int size = src->count;
1327         int bits = 0;
1328         int i;
1329
1330         /*
1331          * If the new source is empty, just free dst and assign it
1332          * the empty_hash.
1333          */
1334         if (!src->count) {
1335                 new_hash = EMPTY_HASH;
1336                 goto update;
1337         }
1338
1339         /*
1340          * Make the hash size about 1/2 the # found
1341          */
1342         for (size /= 2; size; size >>= 1)
1343                 bits++;
1344
1345         /* Don't allocate too much */
1346         if (bits > FTRACE_HASH_MAX_BITS)
1347                 bits = FTRACE_HASH_MAX_BITS;
1348
1349         new_hash = alloc_ftrace_hash(bits);
1350         if (!new_hash)
1351                 return -ENOMEM;
1352
1353         size = 1 << src->size_bits;
1354         for (i = 0; i < size; i++) {
1355                 hhd = &src->buckets[i];
1356                 hlist_for_each_entry_safe(entry, tn, hhd, hlist) {
1357                         remove_hash_entry(src, entry);
1358                         __add_hash_entry(new_hash, entry);
1359                 }
1360         }
1361
1362 update:
1363         /*
1364          * Remove the current set, update the hash and add
1365          * them back.
1366          */
1367         ftrace_hash_rec_disable_modify(ops, enable);
1368
1369         rcu_assign_pointer(*dst, new_hash);
1370
1371         ftrace_hash_rec_enable_modify(ops, enable);
1372
1373         return 0;
1374 }
1375
1376 static bool hash_contains_ip(unsigned long ip,
1377                              struct ftrace_ops_hash *hash)
1378 {
1379         /*
1380          * The function record is a match if it exists in the filter
1381          * hash and not in the notrace hash. Note, an emty hash is
1382          * considered a match for the filter hash, but an empty
1383          * notrace hash is considered not in the notrace hash.
1384          */
1385         return (ftrace_hash_empty(hash->filter_hash) ||
1386                 ftrace_lookup_ip(hash->filter_hash, ip)) &&
1387                 (ftrace_hash_empty(hash->notrace_hash) ||
1388                  !ftrace_lookup_ip(hash->notrace_hash, ip));
1389 }
1390
1391 /*
1392  * Test the hashes for this ops to see if we want to call
1393  * the ops->func or not.
1394  *
1395  * It's a match if the ip is in the ops->filter_hash or
1396  * the filter_hash does not exist or is empty,
1397  *  AND
1398  * the ip is not in the ops->notrace_hash.
1399  *
1400  * This needs to be called with preemption disabled as
1401  * the hashes are freed with call_rcu_sched().
1402  */
1403 static int
1404 ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
1405 {
1406         struct ftrace_ops_hash hash;
1407         int ret;
1408
1409 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
1410         /*
1411          * There's a small race when adding ops that the ftrace handler
1412          * that wants regs, may be called without them. We can not
1413          * allow that handler to be called if regs is NULL.
1414          */
1415         if (regs == NULL && (ops->flags & FTRACE_OPS_FL_SAVE_REGS))
1416                 return 0;
1417 #endif
1418
1419         hash.filter_hash = rcu_dereference_raw_notrace(ops->func_hash->filter_hash);
1420         hash.notrace_hash = rcu_dereference_raw_notrace(ops->func_hash->notrace_hash);
1421
1422         if (hash_contains_ip(ip, &hash))
1423                 ret = 1;
1424         else
1425                 ret = 0;
1426
1427         return ret;
1428 }
1429
1430 /*
1431  * This is a double for. Do not use 'break' to break out of the loop,
1432  * you must use a goto.
1433  */
1434 #define do_for_each_ftrace_rec(pg, rec)                                 \
1435         for (pg = ftrace_pages_start; pg; pg = pg->next) {              \
1436                 int _____i;                                             \
1437                 for (_____i = 0; _____i < pg->index; _____i++) {        \
1438                         rec = &pg->records[_____i];
1439
1440 #define while_for_each_ftrace_rec()             \
1441                 }                               \
1442         }
1443
1444
1445 static int ftrace_cmp_recs(const void *a, const void *b)
1446 {
1447         const struct dyn_ftrace *key = a;
1448         const struct dyn_ftrace *rec = b;
1449
1450         if (key->flags < rec->ip)
1451                 return -1;
1452         if (key->ip >= rec->ip + MCOUNT_INSN_SIZE)
1453                 return 1;
1454         return 0;
1455 }
1456
1457 static unsigned long ftrace_location_range(unsigned long start, unsigned long end)
1458 {
1459         struct ftrace_page *pg;
1460         struct dyn_ftrace *rec;
1461         struct dyn_ftrace key;
1462
1463         key.ip = start;
1464         key.flags = end;        /* overload flags, as it is unsigned long */
1465
1466         for (pg = ftrace_pages_start; pg; pg = pg->next) {
1467                 if (end < pg->records[0].ip ||
1468                     start >= (pg->records[pg->index - 1].ip + MCOUNT_INSN_SIZE))
1469                         continue;
1470                 rec = bsearch(&key, pg->records, pg->index,
1471                               sizeof(struct dyn_ftrace),
1472                               ftrace_cmp_recs);
1473                 if (rec)
1474                         return rec->ip;
1475         }
1476
1477         return 0;
1478 }
1479
1480 /**
1481  * ftrace_location - return true if the ip giving is a traced location
1482  * @ip: the instruction pointer to check
1483  *
1484  * Returns rec->ip if @ip given is a pointer to a ftrace location.
1485  * That is, the instruction that is either a NOP or call to
1486  * the function tracer. It checks the ftrace internal tables to
1487  * determine if the address belongs or not.
1488  */
1489 unsigned long ftrace_location(unsigned long ip)
1490 {
1491         return ftrace_location_range(ip, ip);
1492 }
1493
1494 /**
1495  * ftrace_text_reserved - return true if range contains an ftrace location
1496  * @start: start of range to search
1497  * @end: end of range to search (inclusive). @end points to the last byte to check.
1498  *
1499  * Returns 1 if @start and @end contains a ftrace location.
1500  * That is, the instruction that is either a NOP or call to
1501  * the function tracer. It checks the ftrace internal tables to
1502  * determine if the address belongs or not.
1503  */
1504 int ftrace_text_reserved(const void *start, const void *end)
1505 {
1506         unsigned long ret;
1507
1508         ret = ftrace_location_range((unsigned long)start,
1509                                     (unsigned long)end);
1510
1511         return (int)!!ret;
1512 }
1513
1514 /* Test if ops registered to this rec needs regs */
1515 static bool test_rec_ops_needs_regs(struct dyn_ftrace *rec)
1516 {
1517         struct ftrace_ops *ops;
1518         bool keep_regs = false;
1519
1520         for (ops = ftrace_ops_list;
1521              ops != &ftrace_list_end; ops = ops->next) {
1522                 /* pass rec in as regs to have non-NULL val */
1523                 if (ftrace_ops_test(ops, rec->ip, rec)) {
1524                         if (ops->flags & FTRACE_OPS_FL_SAVE_REGS) {
1525                                 keep_regs = true;
1526                                 break;
1527                         }
1528                 }
1529         }
1530
1531         return  keep_regs;
1532 }
1533
1534 static void __ftrace_hash_rec_update(struct ftrace_ops *ops,
1535                                      int filter_hash,
1536                                      bool inc)
1537 {
1538         struct ftrace_hash *hash;
1539         struct ftrace_hash *other_hash;
1540         struct ftrace_page *pg;
1541         struct dyn_ftrace *rec;
1542         int count = 0;
1543         int all = 0;
1544
1545         /* Only update if the ops has been registered */
1546         if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
1547                 return;
1548
1549         /*
1550          * In the filter_hash case:
1551          *   If the count is zero, we update all records.
1552          *   Otherwise we just update the items in the hash.
1553          *
1554          * In the notrace_hash case:
1555          *   We enable the update in the hash.
1556          *   As disabling notrace means enabling the tracing,
1557          *   and enabling notrace means disabling, the inc variable
1558          *   gets inversed.
1559          */
1560         if (filter_hash) {
1561                 hash = ops->func_hash->filter_hash;
1562                 other_hash = ops->func_hash->notrace_hash;
1563                 if (ftrace_hash_empty(hash))
1564                         all = 1;
1565         } else {
1566                 inc = !inc;
1567                 hash = ops->func_hash->notrace_hash;
1568                 other_hash = ops->func_hash->filter_hash;
1569                 /*
1570                  * If the notrace hash has no items,
1571                  * then there's nothing to do.
1572                  */
1573                 if (ftrace_hash_empty(hash))
1574                         return;
1575         }
1576
1577         do_for_each_ftrace_rec(pg, rec) {
1578                 int in_other_hash = 0;
1579                 int in_hash = 0;
1580                 int match = 0;
1581
1582                 if (all) {
1583                         /*
1584                          * Only the filter_hash affects all records.
1585                          * Update if the record is not in the notrace hash.
1586                          */
1587                         if (!other_hash || !ftrace_lookup_ip(other_hash, rec->ip))
1588                                 match = 1;
1589                 } else {
1590                         in_hash = !!ftrace_lookup_ip(hash, rec->ip);
1591                         in_other_hash = !!ftrace_lookup_ip(other_hash, rec->ip);
1592
1593                         /*
1594                          * If filter_hash is set, we want to match all functions
1595                          * that are in the hash but not in the other hash.
1596                          *
1597                          * If filter_hash is not set, then we are decrementing.
1598                          * That means we match anything that is in the hash
1599                          * and also in the other_hash. That is, we need to turn
1600                          * off functions in the other hash because they are disabled
1601                          * by this hash.
1602                          */
1603                         if (filter_hash && in_hash && !in_other_hash)
1604                                 match = 1;
1605                         else if (!filter_hash && in_hash &&
1606                                  (in_other_hash || ftrace_hash_empty(other_hash)))
1607                                 match = 1;
1608                 }
1609                 if (!match)
1610                         continue;
1611
1612                 if (inc) {
1613                         rec->flags++;
1614                         if (FTRACE_WARN_ON(ftrace_rec_count(rec) == FTRACE_REF_MAX))
1615                                 return;
1616
1617                         /*
1618                          * If there's only a single callback registered to a
1619                          * function, and the ops has a trampoline registered
1620                          * for it, then we can call it directly.
1621                          */
1622                         if (ftrace_rec_count(rec) == 1 && ops->trampoline)
1623                                 rec->flags |= FTRACE_FL_TRAMP;
1624                         else
1625                                 /*
1626                                  * If we are adding another function callback
1627                                  * to this function, and the previous had a
1628                                  * custom trampoline in use, then we need to go
1629                                  * back to the default trampoline.
1630                                  */
1631                                 rec->flags &= ~FTRACE_FL_TRAMP;
1632
1633                         /*
1634                          * If any ops wants regs saved for this function
1635                          * then all ops will get saved regs.
1636                          */
1637                         if (ops->flags & FTRACE_OPS_FL_SAVE_REGS)
1638                                 rec->flags |= FTRACE_FL_REGS;
1639                 } else {
1640                         if (FTRACE_WARN_ON(ftrace_rec_count(rec) == 0))
1641                                 return;
1642                         rec->flags--;
1643
1644                         /*
1645                          * If the rec had REGS enabled and the ops that is
1646                          * being removed had REGS set, then see if there is
1647                          * still any ops for this record that wants regs.
1648                          * If not, we can stop recording them.
1649                          */
1650                         if (ftrace_rec_count(rec) > 0 &&
1651                             rec->flags & FTRACE_FL_REGS &&
1652                             ops->flags & FTRACE_OPS_FL_SAVE_REGS) {
1653                                 if (!test_rec_ops_needs_regs(rec))
1654                                         rec->flags &= ~FTRACE_FL_REGS;
1655                         }
1656
1657                         /*
1658                          * If the rec had TRAMP enabled, then it needs to
1659                          * be cleared. As TRAMP can only be enabled iff
1660                          * there is only a single ops attached to it.
1661                          * In otherwords, always disable it on decrementing.
1662                          * In the future, we may set it if rec count is
1663                          * decremented to one, and the ops that is left
1664                          * has a trampoline.
1665                          */
1666                         rec->flags &= ~FTRACE_FL_TRAMP;
1667
1668                         /*
1669                          * flags will be cleared in ftrace_check_record()
1670                          * if rec count is zero.
1671                          */
1672                 }
1673                 count++;
1674                 /* Shortcut, if we handled all records, we are done. */
1675                 if (!all && count == hash->count)
1676                         return;
1677         } while_for_each_ftrace_rec();
1678 }
1679
1680 static void ftrace_hash_rec_disable(struct ftrace_ops *ops,
1681                                     int filter_hash)
1682 {
1683         __ftrace_hash_rec_update(ops, filter_hash, 0);
1684 }
1685
1686 static void ftrace_hash_rec_enable(struct ftrace_ops *ops,
1687                                    int filter_hash)
1688 {
1689         __ftrace_hash_rec_update(ops, filter_hash, 1);
1690 }
1691
1692 static void ftrace_hash_rec_update_modify(struct ftrace_ops *ops,
1693                                           int filter_hash, int inc)
1694 {
1695         struct ftrace_ops *op;
1696
1697         __ftrace_hash_rec_update(ops, filter_hash, inc);
1698
1699         if (ops->func_hash != &global_ops.local_hash)
1700                 return;
1701
1702         /*
1703          * If the ops shares the global_ops hash, then we need to update
1704          * all ops that are enabled and use this hash.
1705          */
1706         do_for_each_ftrace_op(op, ftrace_ops_list) {
1707                 /* Already done */
1708                 if (op == ops)
1709                         continue;
1710                 if (op->func_hash == &global_ops.local_hash)
1711                         __ftrace_hash_rec_update(op, filter_hash, inc);
1712         } while_for_each_ftrace_op(op);
1713 }
1714
1715 static void ftrace_hash_rec_disable_modify(struct ftrace_ops *ops,
1716                                            int filter_hash)
1717 {
1718         ftrace_hash_rec_update_modify(ops, filter_hash, 0);
1719 }
1720
1721 static void ftrace_hash_rec_enable_modify(struct ftrace_ops *ops,
1722                                           int filter_hash)
1723 {
1724         ftrace_hash_rec_update_modify(ops, filter_hash, 1);
1725 }
1726
1727 static void print_ip_ins(const char *fmt, unsigned char *p)
1728 {
1729         int i;
1730
1731         printk(KERN_CONT "%s", fmt);
1732
1733         for (i = 0; i < MCOUNT_INSN_SIZE; i++)
1734                 printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
1735 }
1736
1737 /**
1738  * ftrace_bug - report and shutdown function tracer
1739  * @failed: The failed type (EFAULT, EINVAL, EPERM)
1740  * @ip: The address that failed
1741  *
1742  * The arch code that enables or disables the function tracing
1743  * can call ftrace_bug() when it has detected a problem in
1744  * modifying the code. @failed should be one of either:
1745  * EFAULT - if the problem happens on reading the @ip address
1746  * EINVAL - if what is read at @ip is not what was expected
1747  * EPERM - if the problem happens on writting to the @ip address
1748  */
1749 void ftrace_bug(int failed, unsigned long ip)
1750 {
1751         switch (failed) {
1752         case -EFAULT:
1753                 FTRACE_WARN_ON_ONCE(1);
1754                 pr_info("ftrace faulted on modifying ");
1755                 print_ip_sym(ip);
1756                 break;
1757         case -EINVAL:
1758                 FTRACE_WARN_ON_ONCE(1);
1759                 pr_info("ftrace failed to modify ");
1760                 print_ip_sym(ip);
1761                 print_ip_ins(" actual: ", (unsigned char *)ip);
1762                 printk(KERN_CONT "\n");
1763                 break;
1764         case -EPERM:
1765                 FTRACE_WARN_ON_ONCE(1);
1766                 pr_info("ftrace faulted on writing ");
1767                 print_ip_sym(ip);
1768                 break;
1769         default:
1770                 FTRACE_WARN_ON_ONCE(1);
1771                 pr_info("ftrace faulted on unknown error ");
1772                 print_ip_sym(ip);
1773         }
1774 }
1775
1776 static int ftrace_check_record(struct dyn_ftrace *rec, int enable, int update)
1777 {
1778         unsigned long flag = 0UL;
1779
1780         /*
1781          * If we are updating calls:
1782          *
1783          *   If the record has a ref count, then we need to enable it
1784          *   because someone is using it.
1785          *
1786          *   Otherwise we make sure its disabled.
1787          *
1788          * If we are disabling calls, then disable all records that
1789          * are enabled.
1790          */
1791         if (enable && ftrace_rec_count(rec))
1792                 flag = FTRACE_FL_ENABLED;
1793
1794         /*
1795          * If enabling and the REGS flag does not match the REGS_EN, or
1796          * the TRAMP flag doesn't match the TRAMP_EN, then do not ignore
1797          * this record. Set flags to fail the compare against ENABLED.
1798          */
1799         if (flag) {
1800                 if (!(rec->flags & FTRACE_FL_REGS) != 
1801                     !(rec->flags & FTRACE_FL_REGS_EN))
1802                         flag |= FTRACE_FL_REGS;
1803
1804                 if (!(rec->flags & FTRACE_FL_TRAMP) != 
1805                     !(rec->flags & FTRACE_FL_TRAMP_EN))
1806                         flag |= FTRACE_FL_TRAMP;
1807         }
1808
1809         /* If the state of this record hasn't changed, then do nothing */
1810         if ((rec->flags & FTRACE_FL_ENABLED) == flag)
1811                 return FTRACE_UPDATE_IGNORE;
1812
1813         if (flag) {
1814                 /* Save off if rec is being enabled (for return value) */
1815                 flag ^= rec->flags & FTRACE_FL_ENABLED;
1816
1817                 if (update) {
1818                         rec->flags |= FTRACE_FL_ENABLED;
1819                         if (flag & FTRACE_FL_REGS) {
1820                                 if (rec->flags & FTRACE_FL_REGS)
1821                                         rec->flags |= FTRACE_FL_REGS_EN;
1822                                 else
1823                                         rec->flags &= ~FTRACE_FL_REGS_EN;
1824                         }
1825                         if (flag & FTRACE_FL_TRAMP) {
1826                                 if (rec->flags & FTRACE_FL_TRAMP)
1827                                         rec->flags |= FTRACE_FL_TRAMP_EN;
1828                                 else
1829                                         rec->flags &= ~FTRACE_FL_TRAMP_EN;
1830                         }
1831                 }
1832
1833                 /*
1834                  * If this record is being updated from a nop, then
1835                  *   return UPDATE_MAKE_CALL.
1836                  * Otherwise,
1837                  *   return UPDATE_MODIFY_CALL to tell the caller to convert
1838                  *   from the save regs, to a non-save regs function or
1839                  *   vice versa, or from a trampoline call.
1840                  */
1841                 if (flag & FTRACE_FL_ENABLED)
1842                         return FTRACE_UPDATE_MAKE_CALL;
1843
1844                 return FTRACE_UPDATE_MODIFY_CALL;
1845         }
1846
1847         if (update) {
1848                 /* If there's no more users, clear all flags */
1849                 if (!ftrace_rec_count(rec))
1850                         rec->flags = 0;
1851                 else
1852                         /* Just disable the record (keep REGS state) */
1853                         rec->flags &= ~FTRACE_FL_ENABLED;
1854         }
1855
1856         return FTRACE_UPDATE_MAKE_NOP;
1857 }
1858
1859 /**
1860  * ftrace_update_record, set a record that now is tracing or not
1861  * @rec: the record to update
1862  * @enable: set to 1 if the record is tracing, zero to force disable
1863  *
1864  * The records that represent all functions that can be traced need
1865  * to be updated when tracing has been enabled.
1866  */
1867 int ftrace_update_record(struct dyn_ftrace *rec, int enable)
1868 {
1869         return ftrace_check_record(rec, enable, 1);
1870 }
1871
1872 /**
1873  * ftrace_test_record, check if the record has been enabled or not
1874  * @rec: the record to test
1875  * @enable: set to 1 to check if enabled, 0 if it is disabled
1876  *
1877  * The arch code may need to test if a record is already set to
1878  * tracing to determine how to modify the function code that it
1879  * represents.
1880  */
1881 int ftrace_test_record(struct dyn_ftrace *rec, int enable)
1882 {
1883         return ftrace_check_record(rec, enable, 0);
1884 }
1885
1886 static struct ftrace_ops *
1887 ftrace_find_tramp_ops_any(struct dyn_ftrace *rec)
1888 {
1889         struct ftrace_ops *op;
1890         unsigned long ip = rec->ip;
1891
1892         do_for_each_ftrace_op(op, ftrace_ops_list) {
1893
1894                 if (!op->trampoline)
1895                         continue;
1896
1897                 if (hash_contains_ip(ip, op->func_hash))
1898                         return op;
1899         } while_for_each_ftrace_op(op);
1900
1901         return NULL;
1902 }
1903
1904 static struct ftrace_ops *
1905 ftrace_find_tramp_ops_curr(struct dyn_ftrace *rec)
1906 {
1907         struct ftrace_ops *op;
1908         unsigned long ip = rec->ip;
1909
1910         /*
1911          * Need to check removed ops first.
1912          * If they are being removed, and this rec has a tramp,
1913          * and this rec is in the ops list, then it would be the
1914          * one with the tramp.
1915          */
1916         if (removed_ops) {
1917                 if (hash_contains_ip(ip, &removed_ops->old_hash))
1918                         return removed_ops;
1919         }
1920
1921         /*
1922          * Need to find the current trampoline for a rec.
1923          * Now, a trampoline is only attached to a rec if there
1924          * was a single 'ops' attached to it. But this can be called
1925          * when we are adding another op to the rec or removing the
1926          * current one. Thus, if the op is being added, we can
1927          * ignore it because it hasn't attached itself to the rec
1928          * yet.
1929          *
1930          * If an ops is being modified (hooking to different functions)
1931          * then we don't care about the new functions that are being
1932          * added, just the old ones (that are probably being removed).
1933          *
1934          * If we are adding an ops to a function that already is using
1935          * a trampoline, it needs to be removed (trampolines are only
1936          * for single ops connected), then an ops that is not being
1937          * modified also needs to be checked.
1938          */
1939         do_for_each_ftrace_op(op, ftrace_ops_list) {
1940
1941                 if (!op->trampoline)
1942                         continue;
1943
1944                 /*
1945                  * If the ops is being added, it hasn't gotten to
1946                  * the point to be removed from this tree yet.
1947                  */
1948                 if (op->flags & FTRACE_OPS_FL_ADDING)
1949                         continue;
1950
1951
1952                 /*
1953                  * If the ops is being modified and is in the old
1954                  * hash, then it is probably being removed from this
1955                  * function.
1956                  */
1957                 if ((op->flags & FTRACE_OPS_FL_MODIFYING) &&
1958                     hash_contains_ip(ip, &op->old_hash))
1959                         return op;
1960                 /*
1961                  * If the ops is not being added or modified, and it's
1962                  * in its normal filter hash, then this must be the one
1963                  * we want!
1964                  */
1965                 if (!(op->flags & FTRACE_OPS_FL_MODIFYING) &&
1966                     hash_contains_ip(ip, op->func_hash))
1967                         return op;
1968
1969         } while_for_each_ftrace_op(op);
1970
1971         return NULL;
1972 }
1973
1974 static struct ftrace_ops *
1975 ftrace_find_tramp_ops_new(struct dyn_ftrace *rec)
1976 {
1977         struct ftrace_ops *op;
1978         unsigned long ip = rec->ip;
1979
1980         do_for_each_ftrace_op(op, ftrace_ops_list) {
1981                 /* pass rec in as regs to have non-NULL val */
1982                 if (hash_contains_ip(ip, op->func_hash))
1983                         return op;
1984         } while_for_each_ftrace_op(op);
1985
1986         return NULL;
1987 }
1988
1989 /**
1990  * ftrace_get_addr_new - Get the call address to set to
1991  * @rec:  The ftrace record descriptor
1992  *
1993  * If the record has the FTRACE_FL_REGS set, that means that it
1994  * wants to convert to a callback that saves all regs. If FTRACE_FL_REGS
1995  * is not not set, then it wants to convert to the normal callback.
1996  *
1997  * Returns the address of the trampoline to set to
1998  */
1999 unsigned long ftrace_get_addr_new(struct dyn_ftrace *rec)
2000 {
2001         struct ftrace_ops *ops;
2002
2003         /* Trampolines take precedence over regs */
2004         if (rec->flags & FTRACE_FL_TRAMP) {
2005                 ops = ftrace_find_tramp_ops_new(rec);
2006                 if (FTRACE_WARN_ON(!ops || !ops->trampoline)) {
2007                         pr_warn("Bad trampoline accounting at: %p (%pS) (%lx)\n",
2008                                 (void *)rec->ip, (void *)rec->ip, rec->flags);
2009                         /* Ftrace is shutting down, return anything */
2010                         return (unsigned long)FTRACE_ADDR;
2011                 }
2012                 return ops->trampoline;
2013         }
2014
2015         if (rec->flags & FTRACE_FL_REGS)
2016                 return (unsigned long)FTRACE_REGS_ADDR;
2017         else
2018                 return (unsigned long)FTRACE_ADDR;
2019 }
2020
2021 /**
2022  * ftrace_get_addr_curr - Get the call address that is already there
2023  * @rec:  The ftrace record descriptor
2024  *
2025  * The FTRACE_FL_REGS_EN is set when the record already points to
2026  * a function that saves all the regs. Basically the '_EN' version
2027  * represents the current state of the function.
2028  *
2029  * Returns the address of the trampoline that is currently being called
2030  */
2031 unsigned long ftrace_get_addr_curr(struct dyn_ftrace *rec)
2032 {
2033         struct ftrace_ops *ops;
2034
2035         /* Trampolines take precedence over regs */
2036         if (rec->flags & FTRACE_FL_TRAMP_EN) {
2037                 ops = ftrace_find_tramp_ops_curr(rec);
2038                 if (FTRACE_WARN_ON(!ops)) {
2039                         pr_warning("Bad trampoline accounting at: %p (%pS)\n",
2040                                     (void *)rec->ip, (void *)rec->ip);
2041                         /* Ftrace is shutting down, return anything */
2042                         return (unsigned long)FTRACE_ADDR;
2043                 }
2044                 return ops->trampoline;
2045         }
2046
2047         if (rec->flags & FTRACE_FL_REGS_EN)
2048                 return (unsigned long)FTRACE_REGS_ADDR;
2049         else
2050                 return (unsigned long)FTRACE_ADDR;
2051 }
2052
2053 static int
2054 __ftrace_replace_code(struct dyn_ftrace *rec, int enable)
2055 {
2056         unsigned long ftrace_old_addr;
2057         unsigned long ftrace_addr;
2058         int ret;
2059
2060         ftrace_addr = ftrace_get_addr_new(rec);
2061
2062         /* This needs to be done before we call ftrace_update_record */
2063         ftrace_old_addr = ftrace_get_addr_curr(rec);
2064
2065         ret = ftrace_update_record(rec, enable);
2066
2067         switch (ret) {
2068         case FTRACE_UPDATE_IGNORE:
2069                 return 0;
2070
2071         case FTRACE_UPDATE_MAKE_CALL:
2072                 return ftrace_make_call(rec, ftrace_addr);
2073
2074         case FTRACE_UPDATE_MAKE_NOP:
2075                 return ftrace_make_nop(NULL, rec, ftrace_old_addr);
2076
2077         case FTRACE_UPDATE_MODIFY_CALL:
2078                 return ftrace_modify_call(rec, ftrace_old_addr, ftrace_addr);
2079         }
2080
2081         return -1; /* unknow ftrace bug */
2082 }
2083
2084 void __weak ftrace_replace_code(int enable)
2085 {
2086         struct dyn_ftrace *rec;
2087         struct ftrace_page *pg;
2088         int failed;
2089
2090         if (unlikely(ftrace_disabled))
2091                 return;
2092
2093         do_for_each_ftrace_rec(pg, rec) {
2094                 failed = __ftrace_replace_code(rec, enable);
2095                 if (failed) {
2096                         ftrace_bug(failed, rec->ip);
2097                         /* Stop processing */
2098                         return;
2099                 }
2100         } while_for_each_ftrace_rec();
2101 }
2102
2103 struct ftrace_rec_iter {
2104         struct ftrace_page      *pg;
2105         int                     index;
2106 };
2107
2108 /**
2109  * ftrace_rec_iter_start, start up iterating over traced functions
2110  *
2111  * Returns an iterator handle that is used to iterate over all
2112  * the records that represent address locations where functions
2113  * are traced.
2114  *
2115  * May return NULL if no records are available.
2116  */
2117 struct ftrace_rec_iter *ftrace_rec_iter_start(void)
2118 {
2119         /*
2120          * We only use a single iterator.
2121          * Protected by the ftrace_lock mutex.
2122          */
2123         static struct ftrace_rec_iter ftrace_rec_iter;
2124         struct ftrace_rec_iter *iter = &ftrace_rec_iter;
2125
2126         iter->pg = ftrace_pages_start;
2127         iter->index = 0;
2128
2129         /* Could have empty pages */
2130         while (iter->pg && !iter->pg->index)
2131                 iter->pg = iter->pg->next;
2132
2133         if (!iter->pg)
2134                 return NULL;
2135
2136         return iter;
2137 }
2138
2139 /**
2140  * ftrace_rec_iter_next, get the next record to process.
2141  * @iter: The handle to the iterator.
2142  *
2143  * Returns the next iterator after the given iterator @iter.
2144  */
2145 struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter)
2146 {
2147         iter->index++;
2148
2149         if (iter->index >= iter->pg->index) {
2150                 iter->pg = iter->pg->next;
2151                 iter->index = 0;
2152
2153                 /* Could have empty pages */
2154                 while (iter->pg && !iter->pg->index)
2155                         iter->pg = iter->pg->next;
2156         }
2157
2158         if (!iter->pg)
2159                 return NULL;
2160
2161         return iter;
2162 }
2163
2164 /**
2165  * ftrace_rec_iter_record, get the record at the iterator location
2166  * @iter: The current iterator location
2167  *
2168  * Returns the record that the current @iter is at.
2169  */
2170 struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter)
2171 {
2172         return &iter->pg->records[iter->index];
2173 }
2174
2175 static int
2176 ftrace_code_disable(struct module *mod, struct dyn_ftrace *rec)
2177 {
2178         unsigned long ip;
2179         int ret;
2180
2181         ip = rec->ip;
2182
2183         if (unlikely(ftrace_disabled))
2184                 return 0;
2185
2186         ret = ftrace_make_nop(mod, rec, MCOUNT_ADDR);
2187         if (ret) {
2188                 ftrace_bug(ret, ip);
2189                 return 0;
2190         }
2191         return 1;
2192 }
2193
2194 /*
2195  * archs can override this function if they must do something
2196  * before the modifying code is performed.
2197  */
2198 int __weak ftrace_arch_code_modify_prepare(void)
2199 {
2200         return 0;
2201 }
2202
2203 /*
2204  * archs can override this function if they must do something
2205  * after the modifying code is performed.
2206  */
2207 int __weak ftrace_arch_code_modify_post_process(void)
2208 {
2209         return 0;
2210 }
2211
2212 void ftrace_modify_all_code(int command)
2213 {
2214         int update = command & FTRACE_UPDATE_TRACE_FUNC;
2215         int err = 0;
2216
2217         /*
2218          * If the ftrace_caller calls a ftrace_ops func directly,
2219          * we need to make sure that it only traces functions it
2220          * expects to trace. When doing the switch of functions,
2221          * we need to update to the ftrace_ops_list_func first
2222          * before the transition between old and new calls are set,
2223          * as the ftrace_ops_list_func will check the ops hashes
2224          * to make sure the ops are having the right functions
2225          * traced.
2226          */
2227         if (update) {
2228                 err = ftrace_update_ftrace_func(ftrace_ops_list_func);
2229                 if (FTRACE_WARN_ON(err))
2230                         return;
2231         }
2232
2233         if (command & FTRACE_UPDATE_CALLS)
2234                 ftrace_replace_code(1);
2235         else if (command & FTRACE_DISABLE_CALLS)
2236                 ftrace_replace_code(0);
2237
2238         if (update && ftrace_trace_function != ftrace_ops_list_func) {
2239                 function_trace_op = set_function_trace_op;
2240                 smp_wmb();
2241                 /* If irqs are disabled, we are in stop machine */
2242                 if (!irqs_disabled())
2243                         smp_call_function(ftrace_sync_ipi, NULL, 1);
2244                 err = ftrace_update_ftrace_func(ftrace_trace_function);
2245                 if (FTRACE_WARN_ON(err))
2246                         return;
2247         }
2248
2249         if (command & FTRACE_START_FUNC_RET)
2250                 err = ftrace_enable_ftrace_graph_caller();
2251         else if (command & FTRACE_STOP_FUNC_RET)
2252                 err = ftrace_disable_ftrace_graph_caller();
2253         FTRACE_WARN_ON(err);
2254 }
2255
2256 static int __ftrace_modify_code(void *data)
2257 {
2258         int *command = data;
2259
2260         ftrace_modify_all_code(*command);
2261
2262         return 0;
2263 }
2264
2265 /**
2266  * ftrace_run_stop_machine, go back to the stop machine method
2267  * @command: The command to tell ftrace what to do
2268  *
2269  * If an arch needs to fall back to the stop machine method, the
2270  * it can call this function.
2271  */
2272 void ftrace_run_stop_machine(int command)
2273 {
2274         stop_machine(__ftrace_modify_code, &command, NULL);
2275 }
2276
2277 /**
2278  * arch_ftrace_update_code, modify the code to trace or not trace
2279  * @command: The command that needs to be done
2280  *
2281  * Archs can override this function if it does not need to
2282  * run stop_machine() to modify code.
2283  */
2284 void __weak arch_ftrace_update_code(int command)
2285 {
2286         ftrace_run_stop_machine(command);
2287 }
2288
2289 static void ftrace_run_update_code(int command)
2290 {
2291         int ret;
2292
2293         ret = ftrace_arch_code_modify_prepare();
2294         FTRACE_WARN_ON(ret);
2295         if (ret)
2296                 return;
2297
2298         /*
2299          * By default we use stop_machine() to modify the code.
2300          * But archs can do what ever they want as long as it
2301          * is safe. The stop_machine() is the safest, but also
2302          * produces the most overhead.
2303          */
2304         arch_ftrace_update_code(command);
2305
2306         ret = ftrace_arch_code_modify_post_process();
2307         FTRACE_WARN_ON(ret);
2308 }
2309
2310 static void ftrace_run_modify_code(struct ftrace_ops *ops, int command,
2311                                    struct ftrace_hash *old_hash)
2312 {
2313         ops->flags |= FTRACE_OPS_FL_MODIFYING;
2314         ops->old_hash.filter_hash = old_hash;
2315         ftrace_run_update_code(command);
2316         ops->old_hash.filter_hash = NULL;
2317         ops->flags &= ~FTRACE_OPS_FL_MODIFYING;
2318 }
2319
2320 static ftrace_func_t saved_ftrace_func;
2321 static int ftrace_start_up;
2322
2323 static void control_ops_free(struct ftrace_ops *ops)
2324 {
2325         free_percpu(ops->disabled);
2326 }
2327
2328 static void ftrace_startup_enable(int command)
2329 {
2330         if (saved_ftrace_func != ftrace_trace_function) {
2331                 saved_ftrace_func = ftrace_trace_function;
2332                 command |= FTRACE_UPDATE_TRACE_FUNC;
2333         }
2334
2335         if (!command || !ftrace_enabled)
2336                 return;
2337
2338         ftrace_run_update_code(command);
2339 }
2340
2341 static void ftrace_startup_all(int command)
2342 {
2343         update_all_ops = true;
2344         ftrace_startup_enable(command);
2345         update_all_ops = false;
2346 }
2347
2348 static int ftrace_startup(struct ftrace_ops *ops, int command)
2349 {
2350         int ret;
2351
2352         if (unlikely(ftrace_disabled))
2353                 return -ENODEV;
2354
2355         ret = __register_ftrace_function(ops);
2356         if (ret)
2357                 return ret;
2358
2359         ftrace_start_up++;
2360         command |= FTRACE_UPDATE_CALLS;
2361
2362         /*
2363          * Note that ftrace probes uses this to start up
2364          * and modify functions it will probe. But we still
2365          * set the ADDING flag for modification, as probes
2366          * do not have trampolines. If they add them in the
2367          * future, then the probes will need to distinguish
2368          * between adding and updating probes.
2369          */
2370         ops->flags |= FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_ADDING;
2371
2372         ftrace_hash_rec_enable(ops, 1);
2373
2374         ftrace_startup_enable(command);
2375
2376         ops->flags &= ~FTRACE_OPS_FL_ADDING;
2377
2378         return 0;
2379 }
2380
2381 static int ftrace_shutdown(struct ftrace_ops *ops, int command)
2382 {
2383         int ret;
2384
2385         if (unlikely(ftrace_disabled))
2386                 return -ENODEV;
2387
2388         ret = __unregister_ftrace_function(ops);
2389         if (ret)
2390                 return ret;
2391
2392         ftrace_start_up--;
2393         /*
2394          * Just warn in case of unbalance, no need to kill ftrace, it's not
2395          * critical but the ftrace_call callers may be never nopped again after
2396          * further ftrace uses.
2397          */
2398         WARN_ON_ONCE(ftrace_start_up < 0);
2399
2400         ftrace_hash_rec_disable(ops, 1);
2401
2402         ops->flags &= ~FTRACE_OPS_FL_ENABLED;
2403
2404         command |= FTRACE_UPDATE_CALLS;
2405
2406         if (saved_ftrace_func != ftrace_trace_function) {
2407                 saved_ftrace_func = ftrace_trace_function;
2408                 command |= FTRACE_UPDATE_TRACE_FUNC;
2409         }
2410
2411         if (!command || !ftrace_enabled) {
2412                 /*
2413                  * If these are control ops, they still need their
2414                  * per_cpu field freed. Since, function tracing is
2415                  * not currently active, we can just free them
2416                  * without synchronizing all CPUs.
2417                  */
2418                 if (ops->flags & FTRACE_OPS_FL_CONTROL)
2419                         control_ops_free(ops);
2420                 return 0;
2421         }
2422
2423         /*
2424          * If the ops uses a trampoline, then it needs to be
2425          * tested first on update.
2426          */
2427         ops->flags |= FTRACE_OPS_FL_REMOVING;
2428         removed_ops = ops;
2429
2430         /* The trampoline logic checks the old hashes */
2431         ops->old_hash.filter_hash = ops->func_hash->filter_hash;
2432         ops->old_hash.notrace_hash = ops->func_hash->notrace_hash;
2433
2434         ftrace_run_update_code(command);
2435
2436         /*
2437          * If there's no more ops registered with ftrace, run a
2438          * sanity check to make sure all rec flags are cleared.
2439          */
2440         if (ftrace_ops_list == &ftrace_list_end) {
2441                 struct ftrace_page *pg;
2442                 struct dyn_ftrace *rec;
2443
2444                 do_for_each_ftrace_rec(pg, rec) {
2445                         if (FTRACE_WARN_ON_ONCE(rec->flags))
2446                                 pr_warn("  %pS flags:%lx\n",
2447                                         (void *)rec->ip, rec->flags);
2448                 } while_for_each_ftrace_rec();
2449         }
2450
2451         ops->old_hash.filter_hash = NULL;
2452         ops->old_hash.notrace_hash = NULL;
2453
2454         removed_ops = NULL;
2455         ops->flags &= ~FTRACE_OPS_FL_REMOVING;
2456
2457         /*
2458          * Dynamic ops may be freed, we must make sure that all
2459          * callers are done before leaving this function.
2460          * The same goes for freeing the per_cpu data of the control
2461          * ops.
2462          *
2463          * Again, normal synchronize_sched() is not good enough.
2464          * We need to do a hard force of sched synchronization.
2465          * This is because we use preempt_disable() to do RCU, but
2466          * the function tracers can be called where RCU is not watching
2467          * (like before user_exit()). We can not rely on the RCU
2468          * infrastructure to do the synchronization, thus we must do it
2469          * ourselves.
2470          */
2471         if (ops->flags & (FTRACE_OPS_FL_DYNAMIC | FTRACE_OPS_FL_CONTROL)) {
2472                 schedule_on_each_cpu(ftrace_sync);
2473
2474                 if (ops->flags & FTRACE_OPS_FL_CONTROL)
2475                         control_ops_free(ops);
2476         }
2477
2478         return 0;
2479 }
2480
2481 static void ftrace_startup_sysctl(void)
2482 {
2483         if (unlikely(ftrace_disabled))
2484                 return;
2485
2486         /* Force update next time */
2487         saved_ftrace_func = NULL;
2488         /* ftrace_start_up is true if we want ftrace running */
2489         if (ftrace_start_up)
2490                 ftrace_run_update_code(FTRACE_UPDATE_CALLS);
2491 }
2492
2493 static void ftrace_shutdown_sysctl(void)
2494 {
2495         if (unlikely(ftrace_disabled))
2496                 return;
2497
2498         /* ftrace_start_up is true if ftrace is running */
2499         if (ftrace_start_up)
2500                 ftrace_run_update_code(FTRACE_DISABLE_CALLS);
2501 }
2502
2503 static cycle_t          ftrace_update_time;
2504 unsigned long           ftrace_update_tot_cnt;
2505
2506 static inline int ops_traces_mod(struct ftrace_ops *ops)
2507 {
2508         /*
2509          * Filter_hash being empty will default to trace module.
2510          * But notrace hash requires a test of individual module functions.
2511          */
2512         return ftrace_hash_empty(ops->func_hash->filter_hash) &&
2513                 ftrace_hash_empty(ops->func_hash->notrace_hash);
2514 }
2515
2516 /*
2517  * Check if the current ops references the record.
2518  *
2519  * If the ops traces all functions, then it was already accounted for.
2520  * If the ops does not trace the current record function, skip it.
2521  * If the ops ignores the function via notrace filter, skip it.
2522  */
2523 static inline bool
2524 ops_references_rec(struct ftrace_ops *ops, struct dyn_ftrace *rec)
2525 {
2526         /* If ops isn't enabled, ignore it */
2527         if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
2528                 return 0;
2529
2530         /* If ops traces all mods, we already accounted for it */
2531         if (ops_traces_mod(ops))
2532                 return 0;
2533
2534         /* The function must be in the filter */
2535         if (!ftrace_hash_empty(ops->func_hash->filter_hash) &&
2536             !ftrace_lookup_ip(ops->func_hash->filter_hash, rec->ip))
2537                 return 0;
2538
2539         /* If in notrace hash, we ignore it too */
2540         if (ftrace_lookup_ip(ops->func_hash->notrace_hash, rec->ip))
2541                 return 0;
2542
2543         return 1;
2544 }
2545
2546 static int referenced_filters(struct dyn_ftrace *rec)
2547 {
2548         struct ftrace_ops *ops;
2549         int cnt = 0;
2550
2551         for (ops = ftrace_ops_list; ops != &ftrace_list_end; ops = ops->next) {
2552                 if (ops_references_rec(ops, rec))
2553                     cnt++;
2554         }
2555
2556         return cnt;
2557 }
2558
2559 static int ftrace_update_code(struct module *mod, struct ftrace_page *new_pgs)
2560 {
2561         struct ftrace_page *pg;
2562         struct dyn_ftrace *p;
2563         cycle_t start, stop;
2564         unsigned long update_cnt = 0;
2565         unsigned long ref = 0;
2566         bool test = false;
2567         int i;
2568
2569         /*
2570          * When adding a module, we need to check if tracers are
2571          * currently enabled and if they are set to trace all functions.
2572          * If they are, we need to enable the module functions as well
2573          * as update the reference counts for those function records.
2574          */
2575         if (mod) {
2576                 struct ftrace_ops *ops;
2577
2578                 for (ops = ftrace_ops_list;
2579                      ops != &ftrace_list_end; ops = ops->next) {
2580                         if (ops->flags & FTRACE_OPS_FL_ENABLED) {
2581                                 if (ops_traces_mod(ops))
2582                                         ref++;
2583                                 else
2584                                         test = true;
2585                         }
2586                 }
2587         }
2588
2589         start = ftrace_now(raw_smp_processor_id());
2590
2591         for (pg = new_pgs; pg; pg = pg->next) {
2592
2593                 for (i = 0; i < pg->index; i++) {
2594                         int cnt = ref;
2595
2596                         /* If something went wrong, bail without enabling anything */
2597                         if (unlikely(ftrace_disabled))
2598                                 return -1;
2599
2600                         p = &pg->records[i];
2601                         if (test)
2602                                 cnt += referenced_filters(p);
2603                         p->flags = cnt;
2604
2605                         /*
2606                          * Do the initial record conversion from mcount jump
2607                          * to the NOP instructions.
2608                          */
2609                         if (!ftrace_code_disable(mod, p))
2610                                 break;
2611
2612                         update_cnt++;
2613
2614                         /*
2615                          * If the tracing is enabled, go ahead and enable the record.
2616                          *
2617                          * The reason not to enable the record immediatelly is the
2618                          * inherent check of ftrace_make_nop/ftrace_make_call for
2619                          * correct previous instructions.  Making first the NOP
2620                          * conversion puts the module to the correct state, thus
2621                          * passing the ftrace_make_call check.
2622                          */
2623                         if (ftrace_start_up && cnt) {
2624                                 int failed = __ftrace_replace_code(p, 1);
2625                                 if (failed)
2626                                         ftrace_bug(failed, p->ip);
2627                         }
2628                 }
2629         }
2630
2631         stop = ftrace_now(raw_smp_processor_id());
2632         ftrace_update_time = stop - start;
2633         ftrace_update_tot_cnt += update_cnt;
2634
2635         return 0;
2636 }
2637
2638 static int ftrace_allocate_records(struct ftrace_page *pg, int count)
2639 {
2640         int order;
2641         int cnt;
2642
2643         if (WARN_ON(!count))
2644                 return -EINVAL;
2645
2646         order = get_count_order(DIV_ROUND_UP(count, ENTRIES_PER_PAGE));
2647
2648         /*
2649          * We want to fill as much as possible. No more than a page
2650          * may be empty.
2651          */
2652         while ((PAGE_SIZE << order) / ENTRY_SIZE >= count + ENTRIES_PER_PAGE)
2653                 order--;
2654
2655  again:
2656         pg->records = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, order);
2657
2658         if (!pg->records) {
2659                 /* if we can't allocate this size, try something smaller */
2660                 if (!order)
2661                         return -ENOMEM;
2662                 order >>= 1;
2663                 goto again;
2664         }
2665
2666         cnt = (PAGE_SIZE << order) / ENTRY_SIZE;
2667         pg->size = cnt;
2668
2669         if (cnt > count)
2670                 cnt = count;
2671
2672         return cnt;
2673 }
2674
2675 static struct ftrace_page *
2676 ftrace_allocate_pages(unsigned long num_to_init)
2677 {
2678         struct ftrace_page *start_pg;
2679         struct ftrace_page *pg;
2680         int order;
2681         int cnt;
2682
2683         if (!num_to_init)
2684                 return 0;
2685
2686         start_pg = pg = kzalloc(sizeof(*pg), GFP_KERNEL);
2687         if (!pg)
2688                 return NULL;
2689
2690         /*
2691          * Try to allocate as much as possible in one continues
2692          * location that fills in all of the space. We want to
2693          * waste as little space as possible.
2694          */
2695         for (;;) {
2696                 cnt = ftrace_allocate_records(pg, num_to_init);
2697                 if (cnt < 0)
2698                         goto free_pages;
2699
2700                 num_to_init -= cnt;
2701                 if (!num_to_init)
2702                         break;
2703
2704                 pg->next = kzalloc(sizeof(*pg), GFP_KERNEL);
2705                 if (!pg->next)
2706                         goto free_pages;
2707
2708                 pg = pg->next;
2709         }
2710
2711         return start_pg;
2712
2713  free_pages:
2714         pg = start_pg;
2715         while (pg) {
2716                 order = get_count_order(pg->size / ENTRIES_PER_PAGE);
2717                 free_pages((unsigned long)pg->records, order);
2718                 start_pg = pg->next;
2719                 kfree(pg);
2720                 pg = start_pg;
2721         }
2722         pr_info("ftrace: FAILED to allocate memory for functions\n");
2723         return NULL;
2724 }
2725
2726 #define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
2727
2728 struct ftrace_iterator {
2729         loff_t                          pos;
2730         loff_t                          func_pos;
2731         struct ftrace_page              *pg;
2732         struct dyn_ftrace               *func;
2733         struct ftrace_func_probe        *probe;
2734         struct trace_parser             parser;
2735         struct ftrace_hash              *hash;
2736         struct ftrace_ops               *ops;
2737         int                             hidx;
2738         int                             idx;
2739         unsigned                        flags;
2740 };
2741
2742 static void *
2743 t_hash_next(struct seq_file *m, loff_t *pos)
2744 {
2745         struct ftrace_iterator *iter = m->private;
2746         struct hlist_node *hnd = NULL;
2747         struct hlist_head *hhd;
2748
2749         (*pos)++;
2750         iter->pos = *pos;
2751
2752         if (iter->probe)
2753                 hnd = &iter->probe->node;
2754  retry:
2755         if (iter->hidx >= FTRACE_FUNC_HASHSIZE)
2756                 return NULL;
2757
2758         hhd = &ftrace_func_hash[iter->hidx];
2759
2760         if (hlist_empty(hhd)) {
2761                 iter->hidx++;
2762                 hnd = NULL;
2763                 goto retry;
2764         }
2765
2766         if (!hnd)
2767                 hnd = hhd->first;
2768         else {
2769                 hnd = hnd->next;
2770                 if (!hnd) {
2771                         iter->hidx++;
2772                         goto retry;
2773                 }
2774         }
2775
2776         if (WARN_ON_ONCE(!hnd))
2777                 return NULL;
2778
2779         iter->probe = hlist_entry(hnd, struct ftrace_func_probe, node);
2780
2781         return iter;
2782 }
2783
2784 static void *t_hash_start(struct seq_file *m, loff_t *pos)
2785 {
2786         struct ftrace_iterator *iter = m->private;
2787         void *p = NULL;
2788         loff_t l;
2789
2790         if (!(iter->flags & FTRACE_ITER_DO_HASH))
2791                 return NULL;
2792
2793         if (iter->func_pos > *pos)
2794                 return NULL;
2795
2796         iter->hidx = 0;
2797         for (l = 0; l <= (*pos - iter->func_pos); ) {
2798                 p = t_hash_next(m, &l);
2799                 if (!p)
2800                         break;
2801         }
2802         if (!p)
2803                 return NULL;
2804
2805         /* Only set this if we have an item */
2806         iter->flags |= FTRACE_ITER_HASH;
2807
2808         return iter;
2809 }
2810
2811 static int
2812 t_hash_show(struct seq_file *m, struct ftrace_iterator *iter)
2813 {
2814         struct ftrace_func_probe *rec;
2815
2816         rec = iter->probe;
2817         if (WARN_ON_ONCE(!rec))
2818                 return -EIO;
2819
2820         if (rec->ops->print)
2821                 return rec->ops->print(m, rec->ip, rec->ops, rec->data);
2822
2823         seq_printf(m, "%ps:%ps", (void *)rec->ip, (void *)rec->ops->func);
2824
2825         if (rec->data)
2826                 seq_printf(m, ":%p", rec->data);
2827         seq_putc(m, '\n');
2828
2829         return 0;
2830 }
2831
2832 static void *
2833 t_next(struct seq_file *m, void *v, loff_t *pos)
2834 {
2835         struct ftrace_iterator *iter = m->private;
2836         struct ftrace_ops *ops = iter->ops;
2837         struct dyn_ftrace *rec = NULL;
2838
2839         if (unlikely(ftrace_disabled))
2840                 return NULL;
2841
2842         if (iter->flags & FTRACE_ITER_HASH)
2843                 return t_hash_next(m, pos);
2844
2845         (*pos)++;
2846         iter->pos = iter->func_pos = *pos;
2847
2848         if (iter->flags & FTRACE_ITER_PRINTALL)
2849                 return t_hash_start(m, pos);
2850
2851  retry:
2852         if (iter->idx >= iter->pg->index) {
2853                 if (iter->pg->next) {
2854                         iter->pg = iter->pg->next;
2855                         iter->idx = 0;
2856                         goto retry;
2857                 }
2858         } else {
2859                 rec = &iter->pg->records[iter->idx++];
2860                 if (((iter->flags & FTRACE_ITER_FILTER) &&
2861                      !(ftrace_lookup_ip(ops->func_hash->filter_hash, rec->ip))) ||
2862
2863                     ((iter->flags & FTRACE_ITER_NOTRACE) &&
2864                      !ftrace_lookup_ip(ops->func_hash->notrace_hash, rec->ip)) ||
2865
2866                     ((iter->flags & FTRACE_ITER_ENABLED) &&
2867                      !(rec->flags & FTRACE_FL_ENABLED))) {
2868
2869                         rec = NULL;
2870                         goto retry;
2871                 }
2872         }
2873
2874         if (!rec)
2875                 return t_hash_start(m, pos);
2876
2877         iter->func = rec;
2878
2879         return iter;
2880 }
2881
2882 static void reset_iter_read(struct ftrace_iterator *iter)
2883 {
2884         iter->pos = 0;
2885         iter->func_pos = 0;
2886         iter->flags &= ~(FTRACE_ITER_PRINTALL | FTRACE_ITER_HASH);
2887 }
2888
2889 static void *t_start(struct seq_file *m, loff_t *pos)
2890 {
2891         struct ftrace_iterator *iter = m->private;
2892         struct ftrace_ops *ops = iter->ops;
2893         void *p = NULL;
2894         loff_t l;
2895
2896         mutex_lock(&ftrace_lock);
2897
2898         if (unlikely(ftrace_disabled))
2899                 return NULL;
2900
2901         /*
2902          * If an lseek was done, then reset and start from beginning.
2903          */
2904         if (*pos < iter->pos)
2905                 reset_iter_read(iter);
2906
2907         /*
2908          * For set_ftrace_filter reading, if we have the filter
2909          * off, we can short cut and just print out that all
2910          * functions are enabled.
2911          */
2912         if ((iter->flags & FTRACE_ITER_FILTER &&
2913              ftrace_hash_empty(ops->func_hash->filter_hash)) ||
2914             (iter->flags & FTRACE_ITER_NOTRACE &&
2915              ftrace_hash_empty(ops->func_hash->notrace_hash))) {
2916                 if (*pos > 0)
2917                         return t_hash_start(m, pos);
2918                 iter->flags |= FTRACE_ITER_PRINTALL;
2919                 /* reset in case of seek/pread */
2920                 iter->flags &= ~FTRACE_ITER_HASH;
2921                 return iter;
2922         }
2923
2924         if (iter->flags & FTRACE_ITER_HASH)
2925                 return t_hash_start(m, pos);
2926
2927         /*
2928          * Unfortunately, we need to restart at ftrace_pages_start
2929          * every time we let go of the ftrace_mutex. This is because
2930          * those pointers can change without the lock.
2931          */
2932         iter->pg = ftrace_pages_start;
2933         iter->idx = 0;
2934         for (l = 0; l <= *pos; ) {
2935                 p = t_next(m, p, &l);
2936                 if (!p)
2937                         break;
2938         }
2939
2940         if (!p)
2941                 return t_hash_start(m, pos);
2942
2943         return iter;
2944 }
2945
2946 static void t_stop(struct seq_file *m, void *p)
2947 {
2948         mutex_unlock(&ftrace_lock);
2949 }
2950
2951 static int t_show(struct seq_file *m, void *v)
2952 {
2953         struct ftrace_iterator *iter = m->private;
2954         struct dyn_ftrace *rec;
2955
2956         if (iter->flags & FTRACE_ITER_HASH)
2957                 return t_hash_show(m, iter);
2958
2959         if (iter->flags & FTRACE_ITER_PRINTALL) {
2960                 if (iter->flags & FTRACE_ITER_NOTRACE)
2961                         seq_printf(m, "#### no functions disabled ####\n");
2962                 else
2963                         seq_printf(m, "#### all functions enabled ####\n");
2964                 return 0;
2965         }
2966
2967         rec = iter->func;
2968
2969         if (!rec)
2970                 return 0;
2971
2972         seq_printf(m, "%ps", (void *)rec->ip);
2973         if (iter->flags & FTRACE_ITER_ENABLED) {
2974                 seq_printf(m, " (%ld)%s",
2975                            ftrace_rec_count(rec),
2976                            rec->flags & FTRACE_FL_REGS ? " R" : "  ");
2977                 if (rec->flags & FTRACE_FL_TRAMP_EN) {
2978                         struct ftrace_ops *ops;
2979
2980                         ops = ftrace_find_tramp_ops_any(rec);
2981                         if (ops)
2982                                 seq_printf(m, "\ttramp: %pS",
2983                                            (void *)ops->trampoline);
2984                         else
2985                                 seq_printf(m, "\ttramp: ERROR!");
2986                 }
2987         }       
2988
2989         seq_printf(m, "\n");
2990
2991         return 0;
2992 }
2993
2994 static const struct seq_operations show_ftrace_seq_ops = {
2995         .start = t_start,
2996         .next = t_next,
2997         .stop = t_stop,
2998         .show = t_show,
2999 };
3000
3001 static int
3002 ftrace_avail_open(struct inode *inode, struct file *file)
3003 {
3004         struct ftrace_iterator *iter;
3005
3006         if (unlikely(ftrace_disabled))
3007                 return -ENODEV;
3008
3009         iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
3010         if (iter) {
3011                 iter->pg = ftrace_pages_start;
3012                 iter->ops = &global_ops;
3013         }
3014
3015         return iter ? 0 : -ENOMEM;
3016 }
3017
3018 static int
3019 ftrace_enabled_open(struct inode *inode, struct file *file)
3020 {
3021         struct ftrace_iterator *iter;
3022
3023         if (unlikely(ftrace_disabled))
3024                 return -ENODEV;
3025
3026         iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
3027         if (iter) {
3028                 iter->pg = ftrace_pages_start;
3029                 iter->flags = FTRACE_ITER_ENABLED;
3030                 iter->ops = &global_ops;
3031         }
3032
3033         return iter ? 0 : -ENOMEM;
3034 }
3035
3036 /**
3037  * ftrace_regex_open - initialize function tracer filter files
3038  * @ops: The ftrace_ops that hold the hash filters
3039  * @flag: The type of filter to process
3040  * @inode: The inode, usually passed in to your open routine
3041  * @file: The file, usually passed in to your open routine
3042  *
3043  * ftrace_regex_open() initializes the filter files for the
3044  * @ops. Depending on @flag it may process the filter hash or
3045  * the notrace hash of @ops. With this called from the open
3046  * routine, you can use ftrace_filter_write() for the write
3047  * routine if @flag has FTRACE_ITER_FILTER set, or
3048  * ftrace_notrace_write() if @flag has FTRACE_ITER_NOTRACE set.
3049  * tracing_lseek() should be used as the lseek routine, and
3050  * release must call ftrace_regex_release().
3051  */
3052 int
3053 ftrace_regex_open(struct ftrace_ops *ops, int flag,
3054                   struct inode *inode, struct file *file)
3055 {
3056         struct ftrace_iterator *iter;
3057         struct ftrace_hash *hash;
3058         int ret = 0;
3059
3060         ftrace_ops_init(ops);
3061
3062         if (unlikely(ftrace_disabled))
3063                 return -ENODEV;
3064
3065         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
3066         if (!iter)
3067                 return -ENOMEM;
3068
3069         if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX)) {
3070                 kfree(iter);
3071                 return -ENOMEM;
3072         }
3073
3074         iter->ops = ops;
3075         iter->flags = flag;
3076
3077         mutex_lock(&ops->func_hash->regex_lock);
3078
3079         if (flag & FTRACE_ITER_NOTRACE)
3080                 hash = ops->func_hash->notrace_hash;
3081         else
3082                 hash = ops->func_hash->filter_hash;
3083
3084         if (file->f_mode & FMODE_WRITE) {
3085                 const int size_bits = FTRACE_HASH_DEFAULT_BITS;
3086
3087                 if (file->f_flags & O_TRUNC)
3088                         iter->hash = alloc_ftrace_hash(size_bits);
3089                 else
3090                         iter->hash = alloc_and_copy_ftrace_hash(size_bits, hash);
3091
3092                 if (!iter->hash) {
3093                         trace_parser_put(&iter->parser);
3094                         kfree(iter);
3095                         ret = -ENOMEM;
3096                         goto out_unlock;
3097                 }
3098         }
3099
3100         if (file->f_mode & FMODE_READ) {
3101                 iter->pg = ftrace_pages_start;
3102
3103                 ret = seq_open(file, &show_ftrace_seq_ops);
3104                 if (!ret) {
3105                         struct seq_file *m = file->private_data;
3106                         m->private = iter;
3107                 } else {
3108                         /* Failed */
3109                         free_ftrace_hash(iter->hash);
3110                         trace_parser_put(&iter->parser);
3111                         kfree(iter);
3112                 }
3113         } else
3114                 file->private_data = iter;
3115
3116  out_unlock:
3117         mutex_unlock(&ops->func_hash->regex_lock);
3118
3119         return ret;
3120 }
3121
3122 static int
3123 ftrace_filter_open(struct inode *inode, struct file *file)
3124 {
3125         struct ftrace_ops *ops = inode->i_private;
3126
3127         return ftrace_regex_open(ops,
3128                         FTRACE_ITER_FILTER | FTRACE_ITER_DO_HASH,
3129                         inode, file);
3130 }
3131
3132 static int
3133 ftrace_notrace_open(struct inode *inode, struct file *file)
3134 {
3135         struct ftrace_ops *ops = inode->i_private;
3136
3137         return ftrace_regex_open(ops, FTRACE_ITER_NOTRACE,
3138                                  inode, file);
3139 }
3140
3141 static int ftrace_match(char *str, char *regex, int len, int type)
3142 {
3143         int matched = 0;
3144         int slen;
3145
3146         switch (type) {
3147         case MATCH_FULL:
3148                 if (strcmp(str, regex) == 0)
3149                         matched = 1;
3150                 break;
3151         case MATCH_FRONT_ONLY:
3152                 if (strncmp(str, regex, len) == 0)
3153                         matched = 1;
3154                 break;
3155         case MATCH_MIDDLE_ONLY:
3156                 if (strstr(str, regex))
3157                         matched = 1;
3158                 break;
3159         case MATCH_END_ONLY:
3160                 slen = strlen(str);
3161                 if (slen >= len && memcmp(str + slen - len, regex, len) == 0)
3162                         matched = 1;
3163                 break;
3164         }
3165
3166         return matched;
3167 }
3168
3169 static int
3170 enter_record(struct ftrace_hash *hash, struct dyn_ftrace *rec, int not)
3171 {
3172         struct ftrace_func_entry *entry;
3173         int ret = 0;
3174
3175         entry = ftrace_lookup_ip(hash, rec->ip);
3176         if (not) {
3177                 /* Do nothing if it doesn't exist */
3178                 if (!entry)
3179                         return 0;
3180
3181                 free_hash_entry(hash, entry);
3182         } else {
3183                 /* Do nothing if it exists */
3184                 if (entry)
3185                         return 0;
3186
3187                 ret = add_hash_entry(hash, rec->ip);
3188         }
3189         return ret;
3190 }
3191
3192 static int
3193 ftrace_match_record(struct dyn_ftrace *rec, char *mod,
3194                     char *regex, int len, int type)
3195 {
3196         char str[KSYM_SYMBOL_LEN];
3197         char *modname;
3198
3199         kallsyms_lookup(rec->ip, NULL, NULL, &modname, str);
3200
3201         if (mod) {
3202                 /* module lookup requires matching the module */
3203                 if (!modname || strcmp(modname, mod))
3204                         return 0;
3205
3206                 /* blank search means to match all funcs in the mod */
3207                 if (!len)
3208                         return 1;
3209         }
3210
3211         return ftrace_match(str, regex, len, type);
3212 }
3213
3214 static int
3215 match_records(struct ftrace_hash *hash, char *buff,
3216               int len, char *mod, int not)
3217 {
3218         unsigned search_len = 0;
3219         struct ftrace_page *pg;
3220         struct dyn_ftrace *rec;
3221         int type = MATCH_FULL;
3222         char *search = buff;
3223         int found = 0;
3224         int ret;
3225
3226         if (len) {
3227                 type = filter_parse_regex(buff, len, &search, &not);
3228                 search_len = strlen(search);
3229         }
3230
3231         mutex_lock(&ftrace_lock);
3232
3233         if (unlikely(ftrace_disabled))
3234                 goto out_unlock;
3235
3236         do_for_each_ftrace_rec(pg, rec) {
3237                 if (ftrace_match_record(rec, mod, search, search_len, type)) {
3238                         ret = enter_record(hash, rec, not);
3239                         if (ret < 0) {
3240                                 found = ret;
3241                                 goto out_unlock;
3242                         }
3243                         found = 1;
3244                 }
3245         } while_for_each_ftrace_rec();
3246  out_unlock:
3247         mutex_unlock(&ftrace_lock);
3248
3249         return found;
3250 }
3251
3252 static int
3253 ftrace_match_records(struct ftrace_hash *hash, char *buff, int len)
3254 {
3255         return match_records(hash, buff, len, NULL, 0);
3256 }
3257
3258 static int
3259 ftrace_match_module_records(struct ftrace_hash *hash, char *buff, char *mod)
3260 {
3261         int not = 0;
3262
3263         /* blank or '*' mean the same */
3264         if (strcmp(buff, "*") == 0)
3265                 buff[0] = 0;
3266
3267         /* handle the case of 'dont filter this module' */
3268         if (strcmp(buff, "!") == 0 || strcmp(buff, "!*") == 0) {
3269                 buff[0] = 0;
3270                 not = 1;
3271         }
3272
3273         return match_records(hash, buff, strlen(buff), mod, not);
3274 }
3275
3276 /*
3277  * We register the module command as a template to show others how
3278  * to register the a command as well.
3279  */
3280
3281 static int
3282 ftrace_mod_callback(struct ftrace_hash *hash,
3283                     char *func, char *cmd, char *param, int enable)
3284 {
3285         char *mod;
3286         int ret = -EINVAL;
3287
3288         /*
3289          * cmd == 'mod' because we only registered this func
3290          * for the 'mod' ftrace_func_command.
3291          * But if you register one func with multiple commands,
3292          * you can tell which command was used by the cmd
3293          * parameter.
3294          */
3295
3296         /* we must have a module name */
3297         if (!param)
3298                 return ret;
3299
3300         mod = strsep(&param, ":");
3301         if (!strlen(mod))
3302                 return ret;
3303
3304         ret = ftrace_match_module_records(hash, func, mod);
3305         if (!ret)
3306                 ret = -EINVAL;
3307         if (ret < 0)
3308                 return ret;
3309
3310         return 0;
3311 }
3312
3313 static struct ftrace_func_command ftrace_mod_cmd = {
3314         .name                   = "mod",
3315         .func                   = ftrace_mod_callback,
3316 };
3317
3318 static int __init ftrace_mod_cmd_init(void)
3319 {
3320         return register_ftrace_command(&ftrace_mod_cmd);
3321 }
3322 core_initcall(ftrace_mod_cmd_init);
3323
3324 static void function_trace_probe_call(unsigned long ip, unsigned long parent_ip,
3325                                       struct ftrace_ops *op, struct pt_regs *pt_regs)
3326 {
3327         struct ftrace_func_probe *entry;
3328         struct hlist_head *hhd;
3329         unsigned long key;
3330
3331         key = hash_long(ip, FTRACE_HASH_BITS);
3332
3333         hhd = &ftrace_func_hash[key];
3334
3335         if (hlist_empty(hhd))
3336                 return;
3337
3338         /*
3339          * Disable preemption for these calls to prevent a RCU grace
3340          * period. This syncs the hash iteration and freeing of items
3341          * on the hash. rcu_read_lock is too dangerous here.
3342          */
3343         preempt_disable_notrace();
3344         hlist_for_each_entry_rcu_notrace(entry, hhd, node) {
3345                 if (entry->ip == ip)
3346                         entry->ops->func(ip, parent_ip, &entry->data);
3347         }
3348         preempt_enable_notrace();
3349 }
3350
3351 static struct ftrace_ops trace_probe_ops __read_mostly =
3352 {
3353         .func           = function_trace_probe_call,
3354         .flags          = FTRACE_OPS_FL_INITIALIZED,
3355         INIT_OPS_HASH(trace_probe_ops)
3356 };
3357
3358 static int ftrace_probe_registered;
3359
3360 static void __enable_ftrace_function_probe(struct ftrace_hash *old_hash)
3361 {
3362         int ret;
3363         int i;
3364
3365         if (ftrace_probe_registered) {
3366                 /* still need to update the function call sites */
3367                 if (ftrace_enabled)
3368                         ftrace_run_modify_code(&trace_probe_ops, FTRACE_UPDATE_CALLS,
<