xref: /openbmc/linux/kernel/trace/trace_selftest.c (revision aaa746ad)
1 // SPDX-License-Identifier: GPL-2.0
2 /* Include in trace.c */
3 
4 #include <uapi/linux/sched/types.h>
5 #include <linux/stringify.h>
6 #include <linux/kthread.h>
7 #include <linux/delay.h>
8 #include <linux/slab.h>
9 
10 static inline int trace_valid_entry(struct trace_entry *entry)
11 {
12 	switch (entry->type) {
13 	case TRACE_FN:
14 	case TRACE_CTX:
15 	case TRACE_WAKE:
16 	case TRACE_STACK:
17 	case TRACE_PRINT:
18 	case TRACE_BRANCH:
19 	case TRACE_GRAPH_ENT:
20 	case TRACE_GRAPH_RET:
21 		return 1;
22 	}
23 	return 0;
24 }
25 
26 static int trace_test_buffer_cpu(struct array_buffer *buf, int cpu)
27 {
28 	struct ring_buffer_event *event;
29 	struct trace_entry *entry;
30 	unsigned int loops = 0;
31 
32 	while ((event = ring_buffer_consume(buf->buffer, cpu, NULL, NULL))) {
33 		entry = ring_buffer_event_data(event);
34 
35 		/*
36 		 * The ring buffer is a size of trace_buf_size, if
37 		 * we loop more than the size, there's something wrong
38 		 * with the ring buffer.
39 		 */
40 		if (loops++ > trace_buf_size) {
41 			printk(KERN_CONT ".. bad ring buffer ");
42 			goto failed;
43 		}
44 		if (!trace_valid_entry(entry)) {
45 			printk(KERN_CONT ".. invalid entry %d ",
46 				entry->type);
47 			goto failed;
48 		}
49 	}
50 	return 0;
51 
52  failed:
53 	/* disable tracing */
54 	tracing_disabled = 1;
55 	printk(KERN_CONT ".. corrupted trace buffer .. ");
56 	return -1;
57 }
58 
59 /*
60  * Test the trace buffer to see if all the elements
61  * are still sane.
62  */
63 static int __maybe_unused trace_test_buffer(struct array_buffer *buf, unsigned long *count)
64 {
65 	unsigned long flags, cnt = 0;
66 	int cpu, ret = 0;
67 
68 	/* Don't allow flipping of max traces now */
69 	local_irq_save(flags);
70 	arch_spin_lock(&buf->tr->max_lock);
71 
72 	cnt = ring_buffer_entries(buf->buffer);
73 
74 	/*
75 	 * The trace_test_buffer_cpu runs a while loop to consume all data.
76 	 * If the calling tracer is broken, and is constantly filling
77 	 * the buffer, this will run forever, and hard lock the box.
78 	 * We disable the ring buffer while we do this test to prevent
79 	 * a hard lock up.
80 	 */
81 	tracing_off();
82 	for_each_possible_cpu(cpu) {
83 		ret = trace_test_buffer_cpu(buf, cpu);
84 		if (ret)
85 			break;
86 	}
87 	tracing_on();
88 	arch_spin_unlock(&buf->tr->max_lock);
89 	local_irq_restore(flags);
90 
91 	if (count)
92 		*count = cnt;
93 
94 	return ret;
95 }
96 
97 static inline void warn_failed_init_tracer(struct tracer *trace, int init_ret)
98 {
99 	printk(KERN_WARNING "Failed to init %s tracer, init returned %d\n",
100 		trace->name, init_ret);
101 }
102 #ifdef CONFIG_FUNCTION_TRACER
103 
104 #ifdef CONFIG_DYNAMIC_FTRACE
105 
106 static int trace_selftest_test_probe1_cnt;
107 static void trace_selftest_test_probe1_func(unsigned long ip,
108 					    unsigned long pip,
109 					    struct ftrace_ops *op,
110 					    struct ftrace_regs *fregs)
111 {
112 	trace_selftest_test_probe1_cnt++;
113 }
114 
115 static int trace_selftest_test_probe2_cnt;
116 static void trace_selftest_test_probe2_func(unsigned long ip,
117 					    unsigned long pip,
118 					    struct ftrace_ops *op,
119 					    struct ftrace_regs *fregs)
120 {
121 	trace_selftest_test_probe2_cnt++;
122 }
123 
124 static int trace_selftest_test_probe3_cnt;
125 static void trace_selftest_test_probe3_func(unsigned long ip,
126 					    unsigned long pip,
127 					    struct ftrace_ops *op,
128 					    struct ftrace_regs *fregs)
129 {
130 	trace_selftest_test_probe3_cnt++;
131 }
132 
133 static int trace_selftest_test_global_cnt;
134 static void trace_selftest_test_global_func(unsigned long ip,
135 					    unsigned long pip,
136 					    struct ftrace_ops *op,
137 					    struct ftrace_regs *fregs)
138 {
139 	trace_selftest_test_global_cnt++;
140 }
141 
142 static int trace_selftest_test_dyn_cnt;
143 static void trace_selftest_test_dyn_func(unsigned long ip,
144 					 unsigned long pip,
145 					 struct ftrace_ops *op,
146 					 struct ftrace_regs *fregs)
147 {
148 	trace_selftest_test_dyn_cnt++;
149 }
150 
151 static struct ftrace_ops test_probe1 = {
152 	.func			= trace_selftest_test_probe1_func,
153 };
154 
155 static struct ftrace_ops test_probe2 = {
156 	.func			= trace_selftest_test_probe2_func,
157 };
158 
159 static struct ftrace_ops test_probe3 = {
160 	.func			= trace_selftest_test_probe3_func,
161 };
162 
163 static void print_counts(void)
164 {
165 	printk("(%d %d %d %d %d) ",
166 	       trace_selftest_test_probe1_cnt,
167 	       trace_selftest_test_probe2_cnt,
168 	       trace_selftest_test_probe3_cnt,
169 	       trace_selftest_test_global_cnt,
170 	       trace_selftest_test_dyn_cnt);
171 }
172 
173 static void reset_counts(void)
174 {
175 	trace_selftest_test_probe1_cnt = 0;
176 	trace_selftest_test_probe2_cnt = 0;
177 	trace_selftest_test_probe3_cnt = 0;
178 	trace_selftest_test_global_cnt = 0;
179 	trace_selftest_test_dyn_cnt = 0;
180 }
181 
182 static int trace_selftest_ops(struct trace_array *tr, int cnt)
183 {
184 	int save_ftrace_enabled = ftrace_enabled;
185 	struct ftrace_ops *dyn_ops;
186 	char *func1_name;
187 	char *func2_name;
188 	int len1;
189 	int len2;
190 	int ret = -1;
191 
192 	printk(KERN_CONT "PASSED\n");
193 	pr_info("Testing dynamic ftrace ops #%d: ", cnt);
194 
195 	ftrace_enabled = 1;
196 	reset_counts();
197 
198 	/* Handle PPC64 '.' name */
199 	func1_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
200 	func2_name = "*" __stringify(DYN_FTRACE_TEST_NAME2);
201 	len1 = strlen(func1_name);
202 	len2 = strlen(func2_name);
203 
204 	/*
205 	 * Probe 1 will trace function 1.
206 	 * Probe 2 will trace function 2.
207 	 * Probe 3 will trace functions 1 and 2.
208 	 */
209 	ftrace_set_filter(&test_probe1, func1_name, len1, 1);
210 	ftrace_set_filter(&test_probe2, func2_name, len2, 1);
211 	ftrace_set_filter(&test_probe3, func1_name, len1, 1);
212 	ftrace_set_filter(&test_probe3, func2_name, len2, 0);
213 
214 	register_ftrace_function(&test_probe1);
215 	register_ftrace_function(&test_probe2);
216 	register_ftrace_function(&test_probe3);
217 	/* First time we are running with main function */
218 	if (cnt > 1) {
219 		ftrace_init_array_ops(tr, trace_selftest_test_global_func);
220 		register_ftrace_function(tr->ops);
221 	}
222 
223 	DYN_FTRACE_TEST_NAME();
224 
225 	print_counts();
226 
227 	if (trace_selftest_test_probe1_cnt != 1)
228 		goto out;
229 	if (trace_selftest_test_probe2_cnt != 0)
230 		goto out;
231 	if (trace_selftest_test_probe3_cnt != 1)
232 		goto out;
233 	if (cnt > 1) {
234 		if (trace_selftest_test_global_cnt == 0)
235 			goto out;
236 	}
237 
238 	DYN_FTRACE_TEST_NAME2();
239 
240 	print_counts();
241 
242 	if (trace_selftest_test_probe1_cnt != 1)
243 		goto out;
244 	if (trace_selftest_test_probe2_cnt != 1)
245 		goto out;
246 	if (trace_selftest_test_probe3_cnt != 2)
247 		goto out;
248 
249 	/* Add a dynamic probe */
250 	dyn_ops = kzalloc(sizeof(*dyn_ops), GFP_KERNEL);
251 	if (!dyn_ops) {
252 		printk("MEMORY ERROR ");
253 		goto out;
254 	}
255 
256 	dyn_ops->func = trace_selftest_test_dyn_func;
257 
258 	register_ftrace_function(dyn_ops);
259 
260 	trace_selftest_test_global_cnt = 0;
261 
262 	DYN_FTRACE_TEST_NAME();
263 
264 	print_counts();
265 
266 	if (trace_selftest_test_probe1_cnt != 2)
267 		goto out_free;
268 	if (trace_selftest_test_probe2_cnt != 1)
269 		goto out_free;
270 	if (trace_selftest_test_probe3_cnt != 3)
271 		goto out_free;
272 	if (cnt > 1) {
273 		if (trace_selftest_test_global_cnt == 0)
274 			goto out_free;
275 	}
276 	if (trace_selftest_test_dyn_cnt == 0)
277 		goto out_free;
278 
279 	DYN_FTRACE_TEST_NAME2();
280 
281 	print_counts();
282 
283 	if (trace_selftest_test_probe1_cnt != 2)
284 		goto out_free;
285 	if (trace_selftest_test_probe2_cnt != 2)
286 		goto out_free;
287 	if (trace_selftest_test_probe3_cnt != 4)
288 		goto out_free;
289 
290 	/* Remove trace function from probe 3 */
291 	func1_name = "!" __stringify(DYN_FTRACE_TEST_NAME);
292 	len1 = strlen(func1_name);
293 
294 	ftrace_set_filter(&test_probe3, func1_name, len1, 0);
295 
296 	DYN_FTRACE_TEST_NAME();
297 
298 	print_counts();
299 
300 	if (trace_selftest_test_probe1_cnt != 3)
301 		goto out_free;
302 	if (trace_selftest_test_probe2_cnt != 2)
303 		goto out_free;
304 	if (trace_selftest_test_probe3_cnt != 4)
305 		goto out_free;
306 	if (cnt > 1) {
307 		if (trace_selftest_test_global_cnt == 0)
308 			goto out_free;
309 	}
310 	if (trace_selftest_test_dyn_cnt == 0)
311 		goto out_free;
312 
313 	DYN_FTRACE_TEST_NAME2();
314 
315 	print_counts();
316 
317 	if (trace_selftest_test_probe1_cnt != 3)
318 		goto out_free;
319 	if (trace_selftest_test_probe2_cnt != 3)
320 		goto out_free;
321 	if (trace_selftest_test_probe3_cnt != 5)
322 		goto out_free;
323 
324 	ret = 0;
325  out_free:
326 	unregister_ftrace_function(dyn_ops);
327 	kfree(dyn_ops);
328 
329  out:
330 	/* Purposely unregister in the same order */
331 	unregister_ftrace_function(&test_probe1);
332 	unregister_ftrace_function(&test_probe2);
333 	unregister_ftrace_function(&test_probe3);
334 	if (cnt > 1)
335 		unregister_ftrace_function(tr->ops);
336 	ftrace_reset_array_ops(tr);
337 
338 	/* Make sure everything is off */
339 	reset_counts();
340 	DYN_FTRACE_TEST_NAME();
341 	DYN_FTRACE_TEST_NAME();
342 
343 	if (trace_selftest_test_probe1_cnt ||
344 	    trace_selftest_test_probe2_cnt ||
345 	    trace_selftest_test_probe3_cnt ||
346 	    trace_selftest_test_global_cnt ||
347 	    trace_selftest_test_dyn_cnt)
348 		ret = -1;
349 
350 	ftrace_enabled = save_ftrace_enabled;
351 
352 	return ret;
353 }
354 
355 /* Test dynamic code modification and ftrace filters */
356 static int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
357 						  struct trace_array *tr,
358 						  int (*func)(void))
359 {
360 	int save_ftrace_enabled = ftrace_enabled;
361 	unsigned long count;
362 	char *func_name;
363 	int ret;
364 
365 	/* The ftrace test PASSED */
366 	printk(KERN_CONT "PASSED\n");
367 	pr_info("Testing dynamic ftrace: ");
368 
369 	/* enable tracing, and record the filter function */
370 	ftrace_enabled = 1;
371 
372 	/* passed in by parameter to fool gcc from optimizing */
373 	func();
374 
375 	/*
376 	 * Some archs *cough*PowerPC*cough* add characters to the
377 	 * start of the function names. We simply put a '*' to
378 	 * accommodate them.
379 	 */
380 	func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
381 
382 	/* filter only on our function */
383 	ftrace_set_global_filter(func_name, strlen(func_name), 1);
384 
385 	/* enable tracing */
386 	ret = tracer_init(trace, tr);
387 	if (ret) {
388 		warn_failed_init_tracer(trace, ret);
389 		goto out;
390 	}
391 
392 	/* Sleep for a 1/10 of a second */
393 	msleep(100);
394 
395 	/* we should have nothing in the buffer */
396 	ret = trace_test_buffer(&tr->array_buffer, &count);
397 	if (ret)
398 		goto out;
399 
400 	if (count) {
401 		ret = -1;
402 		printk(KERN_CONT ".. filter did not filter .. ");
403 		goto out;
404 	}
405 
406 	/* call our function again */
407 	func();
408 
409 	/* sleep again */
410 	msleep(100);
411 
412 	/* stop the tracing. */
413 	tracing_stop();
414 	ftrace_enabled = 0;
415 
416 	/* check the trace buffer */
417 	ret = trace_test_buffer(&tr->array_buffer, &count);
418 
419 	ftrace_enabled = 1;
420 	tracing_start();
421 
422 	/* we should only have one item */
423 	if (!ret && count != 1) {
424 		trace->reset(tr);
425 		printk(KERN_CONT ".. filter failed count=%ld ..", count);
426 		ret = -1;
427 		goto out;
428 	}
429 
430 	/* Test the ops with global tracing running */
431 	ret = trace_selftest_ops(tr, 1);
432 	trace->reset(tr);
433 
434  out:
435 	ftrace_enabled = save_ftrace_enabled;
436 
437 	/* Enable tracing on all functions again */
438 	ftrace_set_global_filter(NULL, 0, 1);
439 
440 	/* Test the ops with global tracing off */
441 	if (!ret)
442 		ret = trace_selftest_ops(tr, 2);
443 
444 	return ret;
445 }
446 
447 static int trace_selftest_recursion_cnt;
448 static void trace_selftest_test_recursion_func(unsigned long ip,
449 					       unsigned long pip,
450 					       struct ftrace_ops *op,
451 					       struct ftrace_regs *fregs)
452 {
453 	/*
454 	 * This function is registered without the recursion safe flag.
455 	 * The ftrace infrastructure should provide the recursion
456 	 * protection. If not, this will crash the kernel!
457 	 */
458 	if (trace_selftest_recursion_cnt++ > 10)
459 		return;
460 	DYN_FTRACE_TEST_NAME();
461 }
462 
463 static void trace_selftest_test_recursion_safe_func(unsigned long ip,
464 						    unsigned long pip,
465 						    struct ftrace_ops *op,
466 						    struct ftrace_regs *fregs)
467 {
468 	/*
469 	 * We said we would provide our own recursion. By calling
470 	 * this function again, we should recurse back into this function
471 	 * and count again. But this only happens if the arch supports
472 	 * all of ftrace features and nothing else is using the function
473 	 * tracing utility.
474 	 */
475 	if (trace_selftest_recursion_cnt++)
476 		return;
477 	DYN_FTRACE_TEST_NAME();
478 }
479 
480 static struct ftrace_ops test_rec_probe = {
481 	.func			= trace_selftest_test_recursion_func,
482 	.flags			= FTRACE_OPS_FL_RECURSION,
483 };
484 
485 static struct ftrace_ops test_recsafe_probe = {
486 	.func			= trace_selftest_test_recursion_safe_func,
487 };
488 
489 static int
490 trace_selftest_function_recursion(void)
491 {
492 	int save_ftrace_enabled = ftrace_enabled;
493 	char *func_name;
494 	int len;
495 	int ret;
496 
497 	/* The previous test PASSED */
498 	pr_cont("PASSED\n");
499 	pr_info("Testing ftrace recursion: ");
500 
501 
502 	/* enable tracing, and record the filter function */
503 	ftrace_enabled = 1;
504 
505 	/* Handle PPC64 '.' name */
506 	func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
507 	len = strlen(func_name);
508 
509 	ret = ftrace_set_filter(&test_rec_probe, func_name, len, 1);
510 	if (ret) {
511 		pr_cont("*Could not set filter* ");
512 		goto out;
513 	}
514 
515 	ret = register_ftrace_function(&test_rec_probe);
516 	if (ret) {
517 		pr_cont("*could not register callback* ");
518 		goto out;
519 	}
520 
521 	DYN_FTRACE_TEST_NAME();
522 
523 	unregister_ftrace_function(&test_rec_probe);
524 
525 	ret = -1;
526 	/*
527 	 * Recursion allows for transitions between context,
528 	 * and may call the callback twice.
529 	 */
530 	if (trace_selftest_recursion_cnt != 1 &&
531 	    trace_selftest_recursion_cnt != 2) {
532 		pr_cont("*callback not called once (or twice) (%d)* ",
533 			trace_selftest_recursion_cnt);
534 		goto out;
535 	}
536 
537 	trace_selftest_recursion_cnt = 1;
538 
539 	pr_cont("PASSED\n");
540 	pr_info("Testing ftrace recursion safe: ");
541 
542 	ret = ftrace_set_filter(&test_recsafe_probe, func_name, len, 1);
543 	if (ret) {
544 		pr_cont("*Could not set filter* ");
545 		goto out;
546 	}
547 
548 	ret = register_ftrace_function(&test_recsafe_probe);
549 	if (ret) {
550 		pr_cont("*could not register callback* ");
551 		goto out;
552 	}
553 
554 	DYN_FTRACE_TEST_NAME();
555 
556 	unregister_ftrace_function(&test_recsafe_probe);
557 
558 	ret = -1;
559 	if (trace_selftest_recursion_cnt != 2) {
560 		pr_cont("*callback not called expected 2 times (%d)* ",
561 			trace_selftest_recursion_cnt);
562 		goto out;
563 	}
564 
565 	ret = 0;
566 out:
567 	ftrace_enabled = save_ftrace_enabled;
568 
569 	return ret;
570 }
571 #else
572 # define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; })
573 # define trace_selftest_function_recursion() ({ 0; })
574 #endif /* CONFIG_DYNAMIC_FTRACE */
575 
576 static enum {
577 	TRACE_SELFTEST_REGS_START,
578 	TRACE_SELFTEST_REGS_FOUND,
579 	TRACE_SELFTEST_REGS_NOT_FOUND,
580 } trace_selftest_regs_stat;
581 
582 static void trace_selftest_test_regs_func(unsigned long ip,
583 					  unsigned long pip,
584 					  struct ftrace_ops *op,
585 					  struct ftrace_regs *fregs)
586 {
587 	struct pt_regs *regs = ftrace_get_regs(fregs);
588 
589 	if (regs)
590 		trace_selftest_regs_stat = TRACE_SELFTEST_REGS_FOUND;
591 	else
592 		trace_selftest_regs_stat = TRACE_SELFTEST_REGS_NOT_FOUND;
593 }
594 
595 static struct ftrace_ops test_regs_probe = {
596 	.func		= trace_selftest_test_regs_func,
597 	.flags		= FTRACE_OPS_FL_SAVE_REGS,
598 };
599 
600 static int
601 trace_selftest_function_regs(void)
602 {
603 	int save_ftrace_enabled = ftrace_enabled;
604 	char *func_name;
605 	int len;
606 	int ret;
607 	int supported = 0;
608 
609 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
610 	supported = 1;
611 #endif
612 
613 	/* The previous test PASSED */
614 	pr_cont("PASSED\n");
615 	pr_info("Testing ftrace regs%s: ",
616 		!supported ? "(no arch support)" : "");
617 
618 	/* enable tracing, and record the filter function */
619 	ftrace_enabled = 1;
620 
621 	/* Handle PPC64 '.' name */
622 	func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
623 	len = strlen(func_name);
624 
625 	ret = ftrace_set_filter(&test_regs_probe, func_name, len, 1);
626 	/*
627 	 * If DYNAMIC_FTRACE is not set, then we just trace all functions.
628 	 * This test really doesn't care.
629 	 */
630 	if (ret && ret != -ENODEV) {
631 		pr_cont("*Could not set filter* ");
632 		goto out;
633 	}
634 
635 	ret = register_ftrace_function(&test_regs_probe);
636 	/*
637 	 * Now if the arch does not support passing regs, then this should
638 	 * have failed.
639 	 */
640 	if (!supported) {
641 		if (!ret) {
642 			pr_cont("*registered save-regs without arch support* ");
643 			goto out;
644 		}
645 		test_regs_probe.flags |= FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED;
646 		ret = register_ftrace_function(&test_regs_probe);
647 	}
648 	if (ret) {
649 		pr_cont("*could not register callback* ");
650 		goto out;
651 	}
652 
653 
654 	DYN_FTRACE_TEST_NAME();
655 
656 	unregister_ftrace_function(&test_regs_probe);
657 
658 	ret = -1;
659 
660 	switch (trace_selftest_regs_stat) {
661 	case TRACE_SELFTEST_REGS_START:
662 		pr_cont("*callback never called* ");
663 		goto out;
664 
665 	case TRACE_SELFTEST_REGS_FOUND:
666 		if (supported)
667 			break;
668 		pr_cont("*callback received regs without arch support* ");
669 		goto out;
670 
671 	case TRACE_SELFTEST_REGS_NOT_FOUND:
672 		if (!supported)
673 			break;
674 		pr_cont("*callback received NULL regs* ");
675 		goto out;
676 	}
677 
678 	ret = 0;
679 out:
680 	ftrace_enabled = save_ftrace_enabled;
681 
682 	return ret;
683 }
684 
685 /*
686  * Simple verification test of ftrace function tracer.
687  * Enable ftrace, sleep 1/10 second, and then read the trace
688  * buffer to see if all is in order.
689  */
690 __init int
691 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
692 {
693 	int save_ftrace_enabled = ftrace_enabled;
694 	unsigned long count;
695 	int ret;
696 
697 #ifdef CONFIG_DYNAMIC_FTRACE
698 	if (ftrace_filter_param) {
699 		printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
700 		return 0;
701 	}
702 #endif
703 
704 	/* make sure msleep has been recorded */
705 	msleep(1);
706 
707 	/* start the tracing */
708 	ftrace_enabled = 1;
709 
710 	ret = tracer_init(trace, tr);
711 	if (ret) {
712 		warn_failed_init_tracer(trace, ret);
713 		goto out;
714 	}
715 
716 	/* Sleep for a 1/10 of a second */
717 	msleep(100);
718 	/* stop the tracing. */
719 	tracing_stop();
720 	ftrace_enabled = 0;
721 
722 	/* check the trace buffer */
723 	ret = trace_test_buffer(&tr->array_buffer, &count);
724 
725 	ftrace_enabled = 1;
726 	trace->reset(tr);
727 	tracing_start();
728 
729 	if (!ret && !count) {
730 		printk(KERN_CONT ".. no entries found ..");
731 		ret = -1;
732 		goto out;
733 	}
734 
735 	ret = trace_selftest_startup_dynamic_tracing(trace, tr,
736 						     DYN_FTRACE_TEST_NAME);
737 	if (ret)
738 		goto out;
739 
740 	ret = trace_selftest_function_recursion();
741 	if (ret)
742 		goto out;
743 
744 	ret = trace_selftest_function_regs();
745  out:
746 	ftrace_enabled = save_ftrace_enabled;
747 
748 	/* kill ftrace totally if we failed */
749 	if (ret)
750 		ftrace_kill();
751 
752 	return ret;
753 }
754 #endif /* CONFIG_FUNCTION_TRACER */
755 
756 
757 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
758 
759 /* Maximum number of functions to trace before diagnosing a hang */
760 #define GRAPH_MAX_FUNC_TEST	100000000
761 
762 static unsigned int graph_hang_thresh;
763 
764 /* Wrap the real function entry probe to avoid possible hanging */
765 static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace)
766 {
767 	/* This is harmlessly racy, we want to approximately detect a hang */
768 	if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) {
769 		ftrace_graph_stop();
770 		printk(KERN_WARNING "BUG: Function graph tracer hang!\n");
771 		if (ftrace_dump_on_oops) {
772 			ftrace_dump(DUMP_ALL);
773 			/* ftrace_dump() disables tracing */
774 			tracing_on();
775 		}
776 		return 0;
777 	}
778 
779 	return trace_graph_entry(trace);
780 }
781 
782 static struct fgraph_ops fgraph_ops __initdata  = {
783 	.entryfunc		= &trace_graph_entry_watchdog,
784 	.retfunc		= &trace_graph_return,
785 };
786 
787 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
788 #ifndef CALL_DEPTH_ACCOUNT
789 #define CALL_DEPTH_ACCOUNT ""
790 #endif
791 
792 noinline __noclone static void trace_direct_tramp(void)
793 {
794 	asm(CALL_DEPTH_ACCOUNT);
795 }
796 #endif
797 
798 /*
799  * Pretty much the same than for the function tracer from which the selftest
800  * has been borrowed.
801  */
802 __init int
803 trace_selftest_startup_function_graph(struct tracer *trace,
804 					struct trace_array *tr)
805 {
806 	int ret;
807 	unsigned long count;
808 	char *func_name __maybe_unused;
809 
810 #ifdef CONFIG_DYNAMIC_FTRACE
811 	if (ftrace_filter_param) {
812 		printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
813 		return 0;
814 	}
815 #endif
816 
817 	/*
818 	 * Simulate the init() callback but we attach a watchdog callback
819 	 * to detect and recover from possible hangs
820 	 */
821 	tracing_reset_online_cpus(&tr->array_buffer);
822 	set_graph_array(tr);
823 	ret = register_ftrace_graph(&fgraph_ops);
824 	if (ret) {
825 		warn_failed_init_tracer(trace, ret);
826 		goto out;
827 	}
828 	tracing_start_cmdline_record();
829 
830 	/* Sleep for a 1/10 of a second */
831 	msleep(100);
832 
833 	/* Have we just recovered from a hang? */
834 	if (graph_hang_thresh > GRAPH_MAX_FUNC_TEST) {
835 		disable_tracing_selftest("recovering from a hang");
836 		ret = -1;
837 		goto out;
838 	}
839 
840 	tracing_stop();
841 
842 	/* check the trace buffer */
843 	ret = trace_test_buffer(&tr->array_buffer, &count);
844 
845 	/* Need to also simulate the tr->reset to remove this fgraph_ops */
846 	tracing_stop_cmdline_record();
847 	unregister_ftrace_graph(&fgraph_ops);
848 
849 	tracing_start();
850 
851 	if (!ret && !count) {
852 		printk(KERN_CONT ".. no entries found ..");
853 		ret = -1;
854 		goto out;
855 	}
856 
857 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
858 	tracing_reset_online_cpus(&tr->array_buffer);
859 	set_graph_array(tr);
860 
861 	/*
862 	 * Some archs *cough*PowerPC*cough* add characters to the
863 	 * start of the function names. We simply put a '*' to
864 	 * accommodate them.
865 	 */
866 	func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
867 	ftrace_set_global_filter(func_name, strlen(func_name), 1);
868 
869 	/*
870 	 * Register direct function together with graph tracer
871 	 * and make sure we get graph trace.
872 	 */
873 	ret = register_ftrace_direct((unsigned long) DYN_FTRACE_TEST_NAME,
874 				     (unsigned long) trace_direct_tramp);
875 	if (ret)
876 		goto out;
877 
878 	ret = register_ftrace_graph(&fgraph_ops);
879 	if (ret) {
880 		warn_failed_init_tracer(trace, ret);
881 		goto out;
882 	}
883 
884 	DYN_FTRACE_TEST_NAME();
885 
886 	count = 0;
887 
888 	tracing_stop();
889 	/* check the trace buffer */
890 	ret = trace_test_buffer(&tr->array_buffer, &count);
891 
892 	unregister_ftrace_graph(&fgraph_ops);
893 
894 	ret = unregister_ftrace_direct((unsigned long) DYN_FTRACE_TEST_NAME,
895 				       (unsigned long) trace_direct_tramp);
896 	if (ret)
897 		goto out;
898 
899 	tracing_start();
900 
901 	if (!ret && !count) {
902 		ret = -1;
903 		goto out;
904 	}
905 
906 	/* Enable tracing on all functions again */
907 	ftrace_set_global_filter(NULL, 0, 1);
908 #endif
909 
910 	/* Don't test dynamic tracing, the function tracer already did */
911 out:
912 	/* Stop it if we failed */
913 	if (ret)
914 		ftrace_graph_stop();
915 
916 	return ret;
917 }
918 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
919 
920 
921 #ifdef CONFIG_IRQSOFF_TRACER
922 int
923 trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
924 {
925 	unsigned long save_max = tr->max_latency;
926 	unsigned long count;
927 	int ret;
928 
929 	/* start the tracing */
930 	ret = tracer_init(trace, tr);
931 	if (ret) {
932 		warn_failed_init_tracer(trace, ret);
933 		return ret;
934 	}
935 
936 	/* reset the max latency */
937 	tr->max_latency = 0;
938 	/* disable interrupts for a bit */
939 	local_irq_disable();
940 	udelay(100);
941 	local_irq_enable();
942 
943 	/*
944 	 * Stop the tracer to avoid a warning subsequent
945 	 * to buffer flipping failure because tracing_stop()
946 	 * disables the tr and max buffers, making flipping impossible
947 	 * in case of parallels max irqs off latencies.
948 	 */
949 	trace->stop(tr);
950 	/* stop the tracing. */
951 	tracing_stop();
952 	/* check both trace buffers */
953 	ret = trace_test_buffer(&tr->array_buffer, NULL);
954 	if (!ret)
955 		ret = trace_test_buffer(&tr->max_buffer, &count);
956 	trace->reset(tr);
957 	tracing_start();
958 
959 	if (!ret && !count) {
960 		printk(KERN_CONT ".. no entries found ..");
961 		ret = -1;
962 	}
963 
964 	tr->max_latency = save_max;
965 
966 	return ret;
967 }
968 #endif /* CONFIG_IRQSOFF_TRACER */
969 
970 #ifdef CONFIG_PREEMPT_TRACER
971 int
972 trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
973 {
974 	unsigned long save_max = tr->max_latency;
975 	unsigned long count;
976 	int ret;
977 
978 	/*
979 	 * Now that the big kernel lock is no longer preemptible,
980 	 * and this is called with the BKL held, it will always
981 	 * fail. If preemption is already disabled, simply
982 	 * pass the test. When the BKL is removed, or becomes
983 	 * preemptible again, we will once again test this,
984 	 * so keep it in.
985 	 */
986 	if (preempt_count()) {
987 		printk(KERN_CONT "can not test ... force ");
988 		return 0;
989 	}
990 
991 	/* start the tracing */
992 	ret = tracer_init(trace, tr);
993 	if (ret) {
994 		warn_failed_init_tracer(trace, ret);
995 		return ret;
996 	}
997 
998 	/* reset the max latency */
999 	tr->max_latency = 0;
1000 	/* disable preemption for a bit */
1001 	preempt_disable();
1002 	udelay(100);
1003 	preempt_enable();
1004 
1005 	/*
1006 	 * Stop the tracer to avoid a warning subsequent
1007 	 * to buffer flipping failure because tracing_stop()
1008 	 * disables the tr and max buffers, making flipping impossible
1009 	 * in case of parallels max preempt off latencies.
1010 	 */
1011 	trace->stop(tr);
1012 	/* stop the tracing. */
1013 	tracing_stop();
1014 	/* check both trace buffers */
1015 	ret = trace_test_buffer(&tr->array_buffer, NULL);
1016 	if (!ret)
1017 		ret = trace_test_buffer(&tr->max_buffer, &count);
1018 	trace->reset(tr);
1019 	tracing_start();
1020 
1021 	if (!ret && !count) {
1022 		printk(KERN_CONT ".. no entries found ..");
1023 		ret = -1;
1024 	}
1025 
1026 	tr->max_latency = save_max;
1027 
1028 	return ret;
1029 }
1030 #endif /* CONFIG_PREEMPT_TRACER */
1031 
1032 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
1033 int
1034 trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr)
1035 {
1036 	unsigned long save_max = tr->max_latency;
1037 	unsigned long count;
1038 	int ret;
1039 
1040 	/*
1041 	 * Now that the big kernel lock is no longer preemptible,
1042 	 * and this is called with the BKL held, it will always
1043 	 * fail. If preemption is already disabled, simply
1044 	 * pass the test. When the BKL is removed, or becomes
1045 	 * preemptible again, we will once again test this,
1046 	 * so keep it in.
1047 	 */
1048 	if (preempt_count()) {
1049 		printk(KERN_CONT "can not test ... force ");
1050 		return 0;
1051 	}
1052 
1053 	/* start the tracing */
1054 	ret = tracer_init(trace, tr);
1055 	if (ret) {
1056 		warn_failed_init_tracer(trace, ret);
1057 		goto out_no_start;
1058 	}
1059 
1060 	/* reset the max latency */
1061 	tr->max_latency = 0;
1062 
1063 	/* disable preemption and interrupts for a bit */
1064 	preempt_disable();
1065 	local_irq_disable();
1066 	udelay(100);
1067 	preempt_enable();
1068 	/* reverse the order of preempt vs irqs */
1069 	local_irq_enable();
1070 
1071 	/*
1072 	 * Stop the tracer to avoid a warning subsequent
1073 	 * to buffer flipping failure because tracing_stop()
1074 	 * disables the tr and max buffers, making flipping impossible
1075 	 * in case of parallels max irqs/preempt off latencies.
1076 	 */
1077 	trace->stop(tr);
1078 	/* stop the tracing. */
1079 	tracing_stop();
1080 	/* check both trace buffers */
1081 	ret = trace_test_buffer(&tr->array_buffer, NULL);
1082 	if (ret)
1083 		goto out;
1084 
1085 	ret = trace_test_buffer(&tr->max_buffer, &count);
1086 	if (ret)
1087 		goto out;
1088 
1089 	if (!ret && !count) {
1090 		printk(KERN_CONT ".. no entries found ..");
1091 		ret = -1;
1092 		goto out;
1093 	}
1094 
1095 	/* do the test by disabling interrupts first this time */
1096 	tr->max_latency = 0;
1097 	tracing_start();
1098 	trace->start(tr);
1099 
1100 	preempt_disable();
1101 	local_irq_disable();
1102 	udelay(100);
1103 	preempt_enable();
1104 	/* reverse the order of preempt vs irqs */
1105 	local_irq_enable();
1106 
1107 	trace->stop(tr);
1108 	/* stop the tracing. */
1109 	tracing_stop();
1110 	/* check both trace buffers */
1111 	ret = trace_test_buffer(&tr->array_buffer, NULL);
1112 	if (ret)
1113 		goto out;
1114 
1115 	ret = trace_test_buffer(&tr->max_buffer, &count);
1116 
1117 	if (!ret && !count) {
1118 		printk(KERN_CONT ".. no entries found ..");
1119 		ret = -1;
1120 		goto out;
1121 	}
1122 
1123 out:
1124 	tracing_start();
1125 out_no_start:
1126 	trace->reset(tr);
1127 	tr->max_latency = save_max;
1128 
1129 	return ret;
1130 }
1131 #endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */
1132 
1133 #ifdef CONFIG_NOP_TRACER
1134 int
1135 trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
1136 {
1137 	/* What could possibly go wrong? */
1138 	return 0;
1139 }
1140 #endif
1141 
1142 #ifdef CONFIG_SCHED_TRACER
1143 
1144 struct wakeup_test_data {
1145 	struct completion	is_ready;
1146 	int			go;
1147 };
1148 
1149 static int trace_wakeup_test_thread(void *data)
1150 {
1151 	/* Make this a -deadline thread */
1152 	static const struct sched_attr attr = {
1153 		.sched_policy = SCHED_DEADLINE,
1154 		.sched_runtime = 100000ULL,
1155 		.sched_deadline = 10000000ULL,
1156 		.sched_period = 10000000ULL
1157 	};
1158 	struct wakeup_test_data *x = data;
1159 
1160 	sched_setattr(current, &attr);
1161 
1162 	/* Make it know we have a new prio */
1163 	complete(&x->is_ready);
1164 
1165 	/* now go to sleep and let the test wake us up */
1166 	set_current_state(TASK_INTERRUPTIBLE);
1167 	while (!x->go) {
1168 		schedule();
1169 		set_current_state(TASK_INTERRUPTIBLE);
1170 	}
1171 
1172 	complete(&x->is_ready);
1173 
1174 	set_current_state(TASK_INTERRUPTIBLE);
1175 
1176 	/* we are awake, now wait to disappear */
1177 	while (!kthread_should_stop()) {
1178 		schedule();
1179 		set_current_state(TASK_INTERRUPTIBLE);
1180 	}
1181 
1182 	__set_current_state(TASK_RUNNING);
1183 
1184 	return 0;
1185 }
1186 int
1187 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
1188 {
1189 	unsigned long save_max = tr->max_latency;
1190 	struct task_struct *p;
1191 	struct wakeup_test_data data;
1192 	unsigned long count;
1193 	int ret;
1194 
1195 	memset(&data, 0, sizeof(data));
1196 
1197 	init_completion(&data.is_ready);
1198 
1199 	/* create a -deadline thread */
1200 	p = kthread_run(trace_wakeup_test_thread, &data, "ftrace-test");
1201 	if (IS_ERR(p)) {
1202 		printk(KERN_CONT "Failed to create ftrace wakeup test thread ");
1203 		return -1;
1204 	}
1205 
1206 	/* make sure the thread is running at -deadline policy */
1207 	wait_for_completion(&data.is_ready);
1208 
1209 	/* start the tracing */
1210 	ret = tracer_init(trace, tr);
1211 	if (ret) {
1212 		warn_failed_init_tracer(trace, ret);
1213 		return ret;
1214 	}
1215 
1216 	/* reset the max latency */
1217 	tr->max_latency = 0;
1218 
1219 	while (p->on_rq) {
1220 		/*
1221 		 * Sleep to make sure the -deadline thread is asleep too.
1222 		 * On virtual machines we can't rely on timings,
1223 		 * but we want to make sure this test still works.
1224 		 */
1225 		msleep(100);
1226 	}
1227 
1228 	init_completion(&data.is_ready);
1229 
1230 	data.go = 1;
1231 	/* memory barrier is in the wake_up_process() */
1232 
1233 	wake_up_process(p);
1234 
1235 	/* Wait for the task to wake up */
1236 	wait_for_completion(&data.is_ready);
1237 
1238 	/* stop the tracing. */
1239 	tracing_stop();
1240 	/* check both trace buffers */
1241 	ret = trace_test_buffer(&tr->array_buffer, NULL);
1242 	if (!ret)
1243 		ret = trace_test_buffer(&tr->max_buffer, &count);
1244 
1245 
1246 	trace->reset(tr);
1247 	tracing_start();
1248 
1249 	tr->max_latency = save_max;
1250 
1251 	/* kill the thread */
1252 	kthread_stop(p);
1253 
1254 	if (!ret && !count) {
1255 		printk(KERN_CONT ".. no entries found ..");
1256 		ret = -1;
1257 	}
1258 
1259 	return ret;
1260 }
1261 #endif /* CONFIG_SCHED_TRACER */
1262 
1263 #ifdef CONFIG_BRANCH_TRACER
1264 int
1265 trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
1266 {
1267 	unsigned long count;
1268 	int ret;
1269 
1270 	/* start the tracing */
1271 	ret = tracer_init(trace, tr);
1272 	if (ret) {
1273 		warn_failed_init_tracer(trace, ret);
1274 		return ret;
1275 	}
1276 
1277 	/* Sleep for a 1/10 of a second */
1278 	msleep(100);
1279 	/* stop the tracing. */
1280 	tracing_stop();
1281 	/* check the trace buffer */
1282 	ret = trace_test_buffer(&tr->array_buffer, &count);
1283 	trace->reset(tr);
1284 	tracing_start();
1285 
1286 	if (!ret && !count) {
1287 		printk(KERN_CONT ".. no entries found ..");
1288 		ret = -1;
1289 	}
1290 
1291 	return ret;
1292 }
1293 #endif /* CONFIG_BRANCH_TRACER */
1294 
1295