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