~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/trace/trace_functions.c

Version: ~ [ linux-4.20-rc2 ] ~ [ linux-4.19.1 ] ~ [ linux-4.18.18 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.80 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.136 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.163 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.125 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.60 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.31.14 ] ~ [ linux-2.6.30.10 ] ~ [ linux-2.6.29.6 ] ~ [ linux-2.6.28.10 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * ring buffer based function tracer
  4  *
  5  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
  6  * Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>
  7  *
  8  * Based on code from the latency_tracer, that is:
  9  *
 10  *  Copyright (C) 2004-2006 Ingo Molnar
 11  *  Copyright (C) 2004 Nadia Yvette Chambers
 12  */
 13 #include <linux/ring_buffer.h>
 14 #include <linux/debugfs.h>
 15 #include <linux/uaccess.h>
 16 #include <linux/ftrace.h>
 17 #include <linux/slab.h>
 18 #include <linux/fs.h>
 19 
 20 #include "trace.h"
 21 
 22 static void tracing_start_function_trace(struct trace_array *tr);
 23 static void tracing_stop_function_trace(struct trace_array *tr);
 24 static void
 25 function_trace_call(unsigned long ip, unsigned long parent_ip,
 26                     struct ftrace_ops *op, struct pt_regs *pt_regs);
 27 static void
 28 function_stack_trace_call(unsigned long ip, unsigned long parent_ip,
 29                           struct ftrace_ops *op, struct pt_regs *pt_regs);
 30 static struct tracer_flags func_flags;
 31 
 32 /* Our option */
 33 enum {
 34         TRACE_FUNC_OPT_STACK    = 0x1,
 35 };
 36 
 37 static int allocate_ftrace_ops(struct trace_array *tr)
 38 {
 39         struct ftrace_ops *ops;
 40 
 41         ops = kzalloc(sizeof(*ops), GFP_KERNEL);
 42         if (!ops)
 43                 return -ENOMEM;
 44 
 45         /* Currently only the non stack verision is supported */
 46         ops->func = function_trace_call;
 47         ops->flags = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_PID;
 48 
 49         tr->ops = ops;
 50         ops->private = tr;
 51         return 0;
 52 }
 53 
 54 
 55 int ftrace_create_function_files(struct trace_array *tr,
 56                                  struct dentry *parent)
 57 {
 58         int ret;
 59 
 60         /*
 61          * The top level array uses the "global_ops", and the files are
 62          * created on boot up.
 63          */
 64         if (tr->flags & TRACE_ARRAY_FL_GLOBAL)
 65                 return 0;
 66 
 67         ret = allocate_ftrace_ops(tr);
 68         if (ret)
 69                 return ret;
 70 
 71         ftrace_create_filter_files(tr->ops, parent);
 72 
 73         return 0;
 74 }
 75 
 76 void ftrace_destroy_function_files(struct trace_array *tr)
 77 {
 78         ftrace_destroy_filter_files(tr->ops);
 79         kfree(tr->ops);
 80         tr->ops = NULL;
 81 }
 82 
 83 static int function_trace_init(struct trace_array *tr)
 84 {
 85         ftrace_func_t func;
 86 
 87         /*
 88          * Instance trace_arrays get their ops allocated
 89          * at instance creation. Unless it failed
 90          * the allocation.
 91          */
 92         if (!tr->ops)
 93                 return -ENOMEM;
 94 
 95         /* Currently only the global instance can do stack tracing */
 96         if (tr->flags & TRACE_ARRAY_FL_GLOBAL &&
 97             func_flags.val & TRACE_FUNC_OPT_STACK)
 98                 func = function_stack_trace_call;
 99         else
100                 func = function_trace_call;
101 
102         ftrace_init_array_ops(tr, func);
103 
104         tr->trace_buffer.cpu = get_cpu();
105         put_cpu();
106 
107         tracing_start_cmdline_record();
108         tracing_start_function_trace(tr);
109         return 0;
110 }
111 
112 static void function_trace_reset(struct trace_array *tr)
113 {
114         tracing_stop_function_trace(tr);
115         tracing_stop_cmdline_record();
116         ftrace_reset_array_ops(tr);
117 }
118 
119 static void function_trace_start(struct trace_array *tr)
120 {
121         tracing_reset_online_cpus(&tr->trace_buffer);
122 }
123 
124 static void
125 function_trace_call(unsigned long ip, unsigned long parent_ip,
126                     struct ftrace_ops *op, struct pt_regs *pt_regs)
127 {
128         struct trace_array *tr = op->private;
129         struct trace_array_cpu *data;
130         unsigned long flags;
131         int bit;
132         int cpu;
133         int pc;
134 
135         if (unlikely(!tr->function_enabled))
136                 return;
137 
138         pc = preempt_count();
139         preempt_disable_notrace();
140 
141         bit = trace_test_and_set_recursion(TRACE_FTRACE_START, TRACE_FTRACE_MAX);
142         if (bit < 0)
143                 goto out;
144 
145         cpu = smp_processor_id();
146         data = per_cpu_ptr(tr->trace_buffer.data, cpu);
147         if (!atomic_read(&data->disabled)) {
148                 local_save_flags(flags);
149                 trace_function(tr, ip, parent_ip, flags, pc);
150         }
151         trace_clear_recursion(bit);
152 
153  out:
154         preempt_enable_notrace();
155 }
156 
157 #ifdef CONFIG_UNWINDER_ORC
158 /*
159  * Skip 2:
160  *
161  *   function_stack_trace_call()
162  *   ftrace_call()
163  */
164 #define STACK_SKIP 2
165 #else
166 /*
167  * Skip 3:
168  *   __trace_stack()
169  *   function_stack_trace_call()
170  *   ftrace_call()
171  */
172 #define STACK_SKIP 3
173 #endif
174 
175 static void
176 function_stack_trace_call(unsigned long ip, unsigned long parent_ip,
177                           struct ftrace_ops *op, struct pt_regs *pt_regs)
178 {
179         struct trace_array *tr = op->private;
180         struct trace_array_cpu *data;
181         unsigned long flags;
182         long disabled;
183         int cpu;
184         int pc;
185 
186         if (unlikely(!tr->function_enabled))
187                 return;
188 
189         /*
190          * Need to use raw, since this must be called before the
191          * recursive protection is performed.
192          */
193         local_irq_save(flags);
194         cpu = raw_smp_processor_id();
195         data = per_cpu_ptr(tr->trace_buffer.data, cpu);
196         disabled = atomic_inc_return(&data->disabled);
197 
198         if (likely(disabled == 1)) {
199                 pc = preempt_count();
200                 trace_function(tr, ip, parent_ip, flags, pc);
201                 __trace_stack(tr, flags, STACK_SKIP, pc);
202         }
203 
204         atomic_dec(&data->disabled);
205         local_irq_restore(flags);
206 }
207 
208 static struct tracer_opt func_opts[] = {
209 #ifdef CONFIG_STACKTRACE
210         { TRACER_OPT(func_stack_trace, TRACE_FUNC_OPT_STACK) },
211 #endif
212         { } /* Always set a last empty entry */
213 };
214 
215 static struct tracer_flags func_flags = {
216         .val = 0, /* By default: all flags disabled */
217         .opts = func_opts
218 };
219 
220 static void tracing_start_function_trace(struct trace_array *tr)
221 {
222         tr->function_enabled = 0;
223         register_ftrace_function(tr->ops);
224         tr->function_enabled = 1;
225 }
226 
227 static void tracing_stop_function_trace(struct trace_array *tr)
228 {
229         tr->function_enabled = 0;
230         unregister_ftrace_function(tr->ops);
231 }
232 
233 static struct tracer function_trace;
234 
235 static int
236 func_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set)
237 {
238         switch (bit) {
239         case TRACE_FUNC_OPT_STACK:
240                 /* do nothing if already set */
241                 if (!!set == !!(func_flags.val & TRACE_FUNC_OPT_STACK))
242                         break;
243 
244                 /* We can change this flag when not running. */
245                 if (tr->current_trace != &function_trace)
246                         break;
247 
248                 unregister_ftrace_function(tr->ops);
249 
250                 if (set) {
251                         tr->ops->func = function_stack_trace_call;
252                         register_ftrace_function(tr->ops);
253                 } else {
254                         tr->ops->func = function_trace_call;
255                         register_ftrace_function(tr->ops);
256                 }
257 
258                 break;
259         default:
260                 return -EINVAL;
261         }
262 
263         return 0;
264 }
265 
266 static struct tracer function_trace __tracer_data =
267 {
268         .name           = "function",
269         .init           = function_trace_init,
270         .reset          = function_trace_reset,
271         .start          = function_trace_start,
272         .flags          = &func_flags,
273         .set_flag       = func_set_flag,
274         .allow_instances = true,
275 #ifdef CONFIG_FTRACE_SELFTEST
276         .selftest       = trace_selftest_startup_function,
277 #endif
278 };
279 
280 #ifdef CONFIG_DYNAMIC_FTRACE
281 static void update_traceon_count(struct ftrace_probe_ops *ops,
282                                  unsigned long ip,
283                                  struct trace_array *tr, bool on,
284                                  void *data)
285 {
286         struct ftrace_func_mapper *mapper = data;
287         long *count;
288         long old_count;
289 
290         /*
291          * Tracing gets disabled (or enabled) once per count.
292          * This function can be called at the same time on multiple CPUs.
293          * It is fine if both disable (or enable) tracing, as disabling
294          * (or enabling) the second time doesn't do anything as the
295          * state of the tracer is already disabled (or enabled).
296          * What needs to be synchronized in this case is that the count
297          * only gets decremented once, even if the tracer is disabled
298          * (or enabled) twice, as the second one is really a nop.
299          *
300          * The memory barriers guarantee that we only decrement the
301          * counter once. First the count is read to a local variable
302          * and a read barrier is used to make sure that it is loaded
303          * before checking if the tracer is in the state we want.
304          * If the tracer is not in the state we want, then the count
305          * is guaranteed to be the old count.
306          *
307          * Next the tracer is set to the state we want (disabled or enabled)
308          * then a write memory barrier is used to make sure that
309          * the new state is visible before changing the counter by
310          * one minus the old counter. This guarantees that another CPU
311          * executing this code will see the new state before seeing
312          * the new counter value, and would not do anything if the new
313          * counter is seen.
314          *
315          * Note, there is no synchronization between this and a user
316          * setting the tracing_on file. But we currently don't care
317          * about that.
318          */
319         count = (long *)ftrace_func_mapper_find_ip(mapper, ip);
320         old_count = *count;
321 
322         if (old_count <= 0)
323                 return;
324 
325         /* Make sure we see count before checking tracing state */
326         smp_rmb();
327 
328         if (on == !!tracer_tracing_is_on(tr))
329                 return;
330 
331         if (on)
332                 tracer_tracing_on(tr);
333         else
334                 tracer_tracing_off(tr);
335 
336         /* Make sure tracing state is visible before updating count */
337         smp_wmb();
338 
339         *count = old_count - 1;
340 }
341 
342 static void
343 ftrace_traceon_count(unsigned long ip, unsigned long parent_ip,
344                      struct trace_array *tr, struct ftrace_probe_ops *ops,
345                      void *data)
346 {
347         update_traceon_count(ops, ip, tr, 1, data);
348 }
349 
350 static void
351 ftrace_traceoff_count(unsigned long ip, unsigned long parent_ip,
352                       struct trace_array *tr, struct ftrace_probe_ops *ops,
353                       void *data)
354 {
355         update_traceon_count(ops, ip, tr, 0, data);
356 }
357 
358 static void
359 ftrace_traceon(unsigned long ip, unsigned long parent_ip,
360                struct trace_array *tr, struct ftrace_probe_ops *ops,
361                void *data)
362 {
363         if (tracer_tracing_is_on(tr))
364                 return;
365 
366         tracer_tracing_on(tr);
367 }
368 
369 static void
370 ftrace_traceoff(unsigned long ip, unsigned long parent_ip,
371                 struct trace_array *tr, struct ftrace_probe_ops *ops,
372                 void *data)
373 {
374         if (!tracer_tracing_is_on(tr))
375                 return;
376 
377         tracer_tracing_off(tr);
378 }
379 
380 #ifdef CONFIG_UNWINDER_ORC
381 /*
382  * Skip 3:
383  *
384  *   function_trace_probe_call()
385  *   ftrace_ops_assist_func()
386  *   ftrace_call()
387  */
388 #define FTRACE_STACK_SKIP 3
389 #else
390 /*
391  * Skip 5:
392  *
393  *   __trace_stack()
394  *   ftrace_stacktrace()
395  *   function_trace_probe_call()
396  *   ftrace_ops_assist_func()
397  *   ftrace_call()
398  */
399 #define FTRACE_STACK_SKIP 5
400 #endif
401 
402 static __always_inline void trace_stack(struct trace_array *tr)
403 {
404         unsigned long flags;
405         int pc;
406 
407         local_save_flags(flags);
408         pc = preempt_count();
409 
410         __trace_stack(tr, flags, FTRACE_STACK_SKIP, pc);
411 }
412 
413 static void
414 ftrace_stacktrace(unsigned long ip, unsigned long parent_ip,
415                   struct trace_array *tr, struct ftrace_probe_ops *ops,
416                   void *data)
417 {
418         trace_stack(tr);
419 }
420 
421 static void
422 ftrace_stacktrace_count(unsigned long ip, unsigned long parent_ip,
423                         struct trace_array *tr, struct ftrace_probe_ops *ops,
424                         void *data)
425 {
426         struct ftrace_func_mapper *mapper = data;
427         long *count;
428         long old_count;
429         long new_count;
430 
431         if (!tracing_is_on())
432                 return;
433 
434         /* unlimited? */
435         if (!mapper) {
436                 trace_stack(tr);
437                 return;
438         }
439 
440         count = (long *)ftrace_func_mapper_find_ip(mapper, ip);
441 
442         /*
443          * Stack traces should only execute the number of times the
444          * user specified in the counter.
445          */
446         do {
447                 old_count = *count;
448 
449                 if (!old_count)
450                         return;
451 
452                 new_count = old_count - 1;
453                 new_count = cmpxchg(count, old_count, new_count);
454                 if (new_count == old_count)
455                         trace_stack(tr);
456 
457                 if (!tracing_is_on())
458                         return;
459 
460         } while (new_count != old_count);
461 }
462 
463 static int update_count(struct ftrace_probe_ops *ops, unsigned long ip,
464                         void *data)
465 {
466         struct ftrace_func_mapper *mapper = data;
467         long *count = NULL;
468 
469         if (mapper)
470                 count = (long *)ftrace_func_mapper_find_ip(mapper, ip);
471 
472         if (count) {
473                 if (*count <= 0)
474                         return 0;
475                 (*count)--;
476         }
477 
478         return 1;
479 }
480 
481 static void
482 ftrace_dump_probe(unsigned long ip, unsigned long parent_ip,
483                   struct trace_array *tr, struct ftrace_probe_ops *ops,
484                   void *data)
485 {
486         if (update_count(ops, ip, data))
487                 ftrace_dump(DUMP_ALL);
488 }
489 
490 /* Only dump the current CPU buffer. */
491 static void
492 ftrace_cpudump_probe(unsigned long ip, unsigned long parent_ip,
493                      struct trace_array *tr, struct ftrace_probe_ops *ops,
494                      void *data)
495 {
496         if (update_count(ops, ip, data))
497                 ftrace_dump(DUMP_ORIG);
498 }
499 
500 static int
501 ftrace_probe_print(const char *name, struct seq_file *m,
502                    unsigned long ip, struct ftrace_probe_ops *ops,
503                    void *data)
504 {
505         struct ftrace_func_mapper *mapper = data;
506         long *count = NULL;
507 
508         seq_printf(m, "%ps:%s", (void *)ip, name);
509 
510         if (mapper)
511                 count = (long *)ftrace_func_mapper_find_ip(mapper, ip);
512 
513         if (count)
514                 seq_printf(m, ":count=%ld\n", *count);
515         else
516                 seq_puts(m, ":unlimited\n");
517 
518         return 0;
519 }
520 
521 static int
522 ftrace_traceon_print(struct seq_file *m, unsigned long ip,
523                      struct ftrace_probe_ops *ops,
524                      void *data)
525 {
526         return ftrace_probe_print("traceon", m, ip, ops, data);
527 }
528 
529 static int
530 ftrace_traceoff_print(struct seq_file *m, unsigned long ip,
531                          struct ftrace_probe_ops *ops, void *data)
532 {
533         return ftrace_probe_print("traceoff", m, ip, ops, data);
534 }
535 
536 static int
537 ftrace_stacktrace_print(struct seq_file *m, unsigned long ip,
538                         struct ftrace_probe_ops *ops, void *data)
539 {
540         return ftrace_probe_print("stacktrace", m, ip, ops, data);
541 }
542 
543 static int
544 ftrace_dump_print(struct seq_file *m, unsigned long ip,
545                         struct ftrace_probe_ops *ops, void *data)
546 {
547         return ftrace_probe_print("dump", m, ip, ops, data);
548 }
549 
550 static int
551 ftrace_cpudump_print(struct seq_file *m, unsigned long ip,
552                         struct ftrace_probe_ops *ops, void *data)
553 {
554         return ftrace_probe_print("cpudump", m, ip, ops, data);
555 }
556 
557 
558 static int
559 ftrace_count_init(struct ftrace_probe_ops *ops, struct trace_array *tr,
560                   unsigned long ip, void *init_data, void **data)
561 {
562         struct ftrace_func_mapper *mapper = *data;
563 
564         if (!mapper) {
565                 mapper = allocate_ftrace_func_mapper();
566                 if (!mapper)
567                         return -ENOMEM;
568                 *data = mapper;
569         }
570 
571         return ftrace_func_mapper_add_ip(mapper, ip, init_data);
572 }
573 
574 static void
575 ftrace_count_free(struct ftrace_probe_ops *ops, struct trace_array *tr,
576                   unsigned long ip, void *data)
577 {
578         struct ftrace_func_mapper *mapper = data;
579 
580         if (!ip) {
581                 free_ftrace_func_mapper(mapper, NULL);
582                 return;
583         }
584 
585         ftrace_func_mapper_remove_ip(mapper, ip);
586 }
587 
588 static struct ftrace_probe_ops traceon_count_probe_ops = {
589         .func                   = ftrace_traceon_count,
590         .print                  = ftrace_traceon_print,
591         .init                   = ftrace_count_init,
592         .free                   = ftrace_count_free,
593 };
594 
595 static struct ftrace_probe_ops traceoff_count_probe_ops = {
596         .func                   = ftrace_traceoff_count,
597         .print                  = ftrace_traceoff_print,
598         .init                   = ftrace_count_init,
599         .free                   = ftrace_count_free,
600 };
601 
602 static struct ftrace_probe_ops stacktrace_count_probe_ops = {
603         .func                   = ftrace_stacktrace_count,
604         .print                  = ftrace_stacktrace_print,
605         .init                   = ftrace_count_init,
606         .free                   = ftrace_count_free,
607 };
608 
609 static struct ftrace_probe_ops dump_probe_ops = {
610         .func                   = ftrace_dump_probe,
611         .print                  = ftrace_dump_print,
612         .init                   = ftrace_count_init,
613         .free                   = ftrace_count_free,
614 };
615 
616 static struct ftrace_probe_ops cpudump_probe_ops = {
617         .func                   = ftrace_cpudump_probe,
618         .print                  = ftrace_cpudump_print,
619 };
620 
621 static struct ftrace_probe_ops traceon_probe_ops = {
622         .func                   = ftrace_traceon,
623         .print                  = ftrace_traceon_print,
624 };
625 
626 static struct ftrace_probe_ops traceoff_probe_ops = {
627         .func                   = ftrace_traceoff,
628         .print                  = ftrace_traceoff_print,
629 };
630 
631 static struct ftrace_probe_ops stacktrace_probe_ops = {
632         .func                   = ftrace_stacktrace,
633         .print                  = ftrace_stacktrace_print,
634 };
635 
636 static int
637 ftrace_trace_probe_callback(struct trace_array *tr,
638                             struct ftrace_probe_ops *ops,
639                             struct ftrace_hash *hash, char *glob,
640                             char *cmd, char *param, int enable)
641 {
642         void *count = (void *)-1;
643         char *number;
644         int ret;
645 
646         /* hash funcs only work with set_ftrace_filter */
647         if (!enable)
648                 return -EINVAL;
649 
650         if (glob[0] == '!')
651                 return unregister_ftrace_function_probe_func(glob+1, tr, ops);
652 
653         if (!param)
654                 goto out_reg;
655 
656         number = strsep(&param, ":");
657 
658         if (!strlen(number))
659                 goto out_reg;
660 
661         /*
662          * We use the callback data field (which is a pointer)
663          * as our counter.
664          */
665         ret = kstrtoul(number, 0, (unsigned long *)&count);
666         if (ret)
667                 return ret;
668 
669  out_reg:
670         ret = register_ftrace_function_probe(glob, tr, ops, count);
671 
672         return ret < 0 ? ret : 0;
673 }
674 
675 static int
676 ftrace_trace_onoff_callback(struct trace_array *tr, struct ftrace_hash *hash,
677                             char *glob, char *cmd, char *param, int enable)
678 {
679         struct ftrace_probe_ops *ops;
680 
681         if (!tr)
682                 return -ENODEV;
683 
684         /* we register both traceon and traceoff to this callback */
685         if (strcmp(cmd, "traceon") == 0)
686                 ops = param ? &traceon_count_probe_ops : &traceon_probe_ops;
687         else
688                 ops = param ? &traceoff_count_probe_ops : &traceoff_probe_ops;
689 
690         return ftrace_trace_probe_callback(tr, ops, hash, glob, cmd,
691                                            param, enable);
692 }
693 
694 static int
695 ftrace_stacktrace_callback(struct trace_array *tr, struct ftrace_hash *hash,
696                            char *glob, char *cmd, char *param, int enable)
697 {
698         struct ftrace_probe_ops *ops;
699 
700         if (!tr)
701                 return -ENODEV;
702 
703         ops = param ? &stacktrace_count_probe_ops : &stacktrace_probe_ops;
704 
705         return ftrace_trace_probe_callback(tr, ops, hash, glob, cmd,
706                                            param, enable);
707 }
708 
709 static int
710 ftrace_dump_callback(struct trace_array *tr, struct ftrace_hash *hash,
711                            char *glob, char *cmd, char *param, int enable)
712 {
713         struct ftrace_probe_ops *ops;
714 
715         if (!tr)
716                 return -ENODEV;
717 
718         ops = &dump_probe_ops;
719 
720         /* Only dump once. */
721         return ftrace_trace_probe_callback(tr, ops, hash, glob, cmd,
722                                            "1", enable);
723 }
724 
725 static int
726 ftrace_cpudump_callback(struct trace_array *tr, struct ftrace_hash *hash,
727                            char *glob, char *cmd, char *param, int enable)
728 {
729         struct ftrace_probe_ops *ops;
730 
731         if (!tr)
732                 return -ENODEV;
733 
734         ops = &cpudump_probe_ops;
735 
736         /* Only dump once. */
737         return ftrace_trace_probe_callback(tr, ops, hash, glob, cmd,
738                                            "1", enable);
739 }
740 
741 static struct ftrace_func_command ftrace_traceon_cmd = {
742         .name                   = "traceon",
743         .func                   = ftrace_trace_onoff_callback,
744 };
745 
746 static struct ftrace_func_command ftrace_traceoff_cmd = {
747         .name                   = "traceoff",
748         .func                   = ftrace_trace_onoff_callback,
749 };
750 
751 static struct ftrace_func_command ftrace_stacktrace_cmd = {
752         .name                   = "stacktrace",
753         .func                   = ftrace_stacktrace_callback,
754 };
755 
756 static struct ftrace_func_command ftrace_dump_cmd = {
757         .name                   = "dump",
758         .func                   = ftrace_dump_callback,
759 };
760 
761 static struct ftrace_func_command ftrace_cpudump_cmd = {
762         .name                   = "cpudump",
763         .func                   = ftrace_cpudump_callback,
764 };
765 
766 static int __init init_func_cmd_traceon(void)
767 {
768         int ret;
769 
770         ret = register_ftrace_command(&ftrace_traceoff_cmd);
771         if (ret)
772                 return ret;
773 
774         ret = register_ftrace_command(&ftrace_traceon_cmd);
775         if (ret)
776                 goto out_free_traceoff;
777 
778         ret = register_ftrace_command(&ftrace_stacktrace_cmd);
779         if (ret)
780                 goto out_free_traceon;
781 
782         ret = register_ftrace_command(&ftrace_dump_cmd);
783         if (ret)
784                 goto out_free_stacktrace;
785 
786         ret = register_ftrace_command(&ftrace_cpudump_cmd);
787         if (ret)
788                 goto out_free_dump;
789 
790         return 0;
791 
792  out_free_dump:
793         unregister_ftrace_command(&ftrace_dump_cmd);
794  out_free_stacktrace:
795         unregister_ftrace_command(&ftrace_stacktrace_cmd);
796  out_free_traceon:
797         unregister_ftrace_command(&ftrace_traceon_cmd);
798  out_free_traceoff:
799         unregister_ftrace_command(&ftrace_traceoff_cmd);
800 
801         return ret;
802 }
803 #else
804 static inline int init_func_cmd_traceon(void)
805 {
806         return 0;
807 }
808 #endif /* CONFIG_DYNAMIC_FTRACE */
809 
810 __init int init_function_trace(void)
811 {
812         init_func_cmd_traceon();
813         return register_tracer(&function_trace);
814 }
815 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp