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