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