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