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