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