1 // SPDX-License-Identifier: GPL-2.0
2 /* Include in trace.c */
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>
10 static inline int trace_valid_entry(struct trace_entry *entry)
12 switch (entry->type) {
26 static int trace_test_buffer_cpu(struct array_buffer *buf, int cpu)
28 struct ring_buffer_event *event;
29 struct trace_entry *entry;
30 unsigned int loops = 0;
32 while ((event = ring_buffer_consume(buf->buffer, cpu, NULL, NULL))) {
33 entry = ring_buffer_event_data(event);
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.
40 if (loops++ > trace_buf_size) {
41 printk(KERN_CONT ".. bad ring buffer ");
44 if (!trace_valid_entry(entry)) {
45 printk(KERN_CONT ".. invalid entry %d ",
55 printk(KERN_CONT ".. corrupted trace buffer .. ");
60 * Test the trace buffer to see if all the elements
63 static int __maybe_unused trace_test_buffer(struct array_buffer *buf, unsigned long *count)
65 unsigned long flags, cnt = 0;
68 /* Don't allow flipping of max traces now */
69 local_irq_save(flags);
70 arch_spin_lock(&buf->tr->max_lock);
72 cnt = ring_buffer_entries(buf->buffer);
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
82 for_each_possible_cpu(cpu) {
83 ret = trace_test_buffer_cpu(buf, cpu);
88 arch_spin_unlock(&buf->tr->max_lock);
89 local_irq_restore(flags);
97 static inline void warn_failed_init_tracer(struct tracer *trace, int init_ret)
99 printk(KERN_WARNING "Failed to init %s tracer, init returned %d\n",
100 trace->name, init_ret);
102 #ifdef CONFIG_FUNCTION_TRACER
104 #ifdef CONFIG_DYNAMIC_FTRACE
106 static int trace_selftest_test_probe1_cnt;
107 static void trace_selftest_test_probe1_func(unsigned long ip,
109 struct ftrace_ops *op,
110 struct ftrace_regs *fregs)
112 trace_selftest_test_probe1_cnt++;
115 static int trace_selftest_test_probe2_cnt;
116 static void trace_selftest_test_probe2_func(unsigned long ip,
118 struct ftrace_ops *op,
119 struct ftrace_regs *fregs)
121 trace_selftest_test_probe2_cnt++;
124 static int trace_selftest_test_probe3_cnt;
125 static void trace_selftest_test_probe3_func(unsigned long ip,
127 struct ftrace_ops *op,
128 struct ftrace_regs *fregs)
130 trace_selftest_test_probe3_cnt++;
133 static int trace_selftest_test_global_cnt;
134 static void trace_selftest_test_global_func(unsigned long ip,
136 struct ftrace_ops *op,
137 struct ftrace_regs *fregs)
139 trace_selftest_test_global_cnt++;
142 static int trace_selftest_test_dyn_cnt;
143 static void trace_selftest_test_dyn_func(unsigned long ip,
145 struct ftrace_ops *op,
146 struct ftrace_regs *fregs)
148 trace_selftest_test_dyn_cnt++;
151 static struct ftrace_ops test_probe1 = {
152 .func = trace_selftest_test_probe1_func,
155 static struct ftrace_ops test_probe2 = {
156 .func = trace_selftest_test_probe2_func,
159 static struct ftrace_ops test_probe3 = {
160 .func = trace_selftest_test_probe3_func,
163 static void print_counts(void)
165 printk("(%d %d %d %d %d) ",
166 trace_selftest_test_probe1_cnt,
167 trace_selftest_test_probe2_cnt,
168 trace_selftest_test_probe3_cnt,
169 trace_selftest_test_global_cnt,
170 trace_selftest_test_dyn_cnt);
173 static void reset_counts(void)
175 trace_selftest_test_probe1_cnt = 0;
176 trace_selftest_test_probe2_cnt = 0;
177 trace_selftest_test_probe3_cnt = 0;
178 trace_selftest_test_global_cnt = 0;
179 trace_selftest_test_dyn_cnt = 0;
182 static int trace_selftest_ops(struct trace_array *tr, int cnt)
184 int save_ftrace_enabled = ftrace_enabled;
185 struct ftrace_ops *dyn_ops;
192 printk(KERN_CONT "PASSED\n");
193 pr_info("Testing dynamic ftrace ops #%d: ", cnt);
198 /* Handle PPC64 '.' name */
199 func1_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
200 func2_name = "*" __stringify(DYN_FTRACE_TEST_NAME2);
201 len1 = strlen(func1_name);
202 len2 = strlen(func2_name);
205 * Probe 1 will trace function 1.
206 * Probe 2 will trace function 2.
207 * Probe 3 will trace functions 1 and 2.
209 ftrace_set_filter(&test_probe1, func1_name, len1, 1);
210 ftrace_set_filter(&test_probe2, func2_name, len2, 1);
211 ftrace_set_filter(&test_probe3, func1_name, len1, 1);
212 ftrace_set_filter(&test_probe3, func2_name, len2, 0);
214 register_ftrace_function(&test_probe1);
215 register_ftrace_function(&test_probe2);
216 register_ftrace_function(&test_probe3);
217 /* First time we are running with main function */
219 ftrace_init_array_ops(tr, trace_selftest_test_global_func);
220 register_ftrace_function(tr->ops);
223 DYN_FTRACE_TEST_NAME();
227 if (trace_selftest_test_probe1_cnt != 1)
229 if (trace_selftest_test_probe2_cnt != 0)
231 if (trace_selftest_test_probe3_cnt != 1)
234 if (trace_selftest_test_global_cnt == 0)
238 DYN_FTRACE_TEST_NAME2();
242 if (trace_selftest_test_probe1_cnt != 1)
244 if (trace_selftest_test_probe2_cnt != 1)
246 if (trace_selftest_test_probe3_cnt != 2)
249 /* Add a dynamic probe */
250 dyn_ops = kzalloc(sizeof(*dyn_ops), GFP_KERNEL);
252 printk("MEMORY ERROR ");
256 dyn_ops->func = trace_selftest_test_dyn_func;
258 register_ftrace_function(dyn_ops);
260 trace_selftest_test_global_cnt = 0;
262 DYN_FTRACE_TEST_NAME();
266 if (trace_selftest_test_probe1_cnt != 2)
268 if (trace_selftest_test_probe2_cnt != 1)
270 if (trace_selftest_test_probe3_cnt != 3)
273 if (trace_selftest_test_global_cnt == 0)
276 if (trace_selftest_test_dyn_cnt == 0)
279 DYN_FTRACE_TEST_NAME2();
283 if (trace_selftest_test_probe1_cnt != 2)
285 if (trace_selftest_test_probe2_cnt != 2)
287 if (trace_selftest_test_probe3_cnt != 4)
290 /* Remove trace function from probe 3 */
291 func1_name = "!" __stringify(DYN_FTRACE_TEST_NAME);
292 len1 = strlen(func1_name);
294 ftrace_set_filter(&test_probe3, func1_name, len1, 0);
296 DYN_FTRACE_TEST_NAME();
300 if (trace_selftest_test_probe1_cnt != 3)
302 if (trace_selftest_test_probe2_cnt != 2)
304 if (trace_selftest_test_probe3_cnt != 4)
307 if (trace_selftest_test_global_cnt == 0)
310 if (trace_selftest_test_dyn_cnt == 0)
313 DYN_FTRACE_TEST_NAME2();
317 if (trace_selftest_test_probe1_cnt != 3)
319 if (trace_selftest_test_probe2_cnt != 3)
321 if (trace_selftest_test_probe3_cnt != 5)
326 unregister_ftrace_function(dyn_ops);
330 /* Purposely unregister in the same order */
331 unregister_ftrace_function(&test_probe1);
332 unregister_ftrace_function(&test_probe2);
333 unregister_ftrace_function(&test_probe3);
335 unregister_ftrace_function(tr->ops);
336 ftrace_reset_array_ops(tr);
338 /* Make sure everything is off */
340 DYN_FTRACE_TEST_NAME();
341 DYN_FTRACE_TEST_NAME();
343 if (trace_selftest_test_probe1_cnt ||
344 trace_selftest_test_probe2_cnt ||
345 trace_selftest_test_probe3_cnt ||
346 trace_selftest_test_global_cnt ||
347 trace_selftest_test_dyn_cnt)
350 ftrace_enabled = save_ftrace_enabled;
355 /* Test dynamic code modification and ftrace filters */
356 static int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
357 struct trace_array *tr,
360 int save_ftrace_enabled = ftrace_enabled;
365 /* The ftrace test PASSED */
366 printk(KERN_CONT "PASSED\n");
367 pr_info("Testing dynamic ftrace: ");
369 /* enable tracing, and record the filter function */
372 /* passed in by parameter to fool gcc from optimizing */
376 * Some archs *cough*PowerPC*cough* add characters to the
377 * start of the function names. We simply put a '*' to
380 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
382 /* filter only on our function */
383 ftrace_set_global_filter(func_name, strlen(func_name), 1);
386 ret = tracer_init(trace, tr);
388 warn_failed_init_tracer(trace, ret);
392 /* Sleep for a 1/10 of a second */
395 /* we should have nothing in the buffer */
396 ret = trace_test_buffer(&tr->array_buffer, &count);
402 printk(KERN_CONT ".. filter did not filter .. ");
406 /* call our function again */
412 /* stop the tracing. */
416 /* check the trace buffer */
417 ret = trace_test_buffer(&tr->array_buffer, &count);
422 /* we should only have one item */
423 if (!ret && count != 1) {
425 printk(KERN_CONT ".. filter failed count=%ld ..", count);
430 /* Test the ops with global tracing running */
431 ret = trace_selftest_ops(tr, 1);
435 ftrace_enabled = save_ftrace_enabled;
437 /* Enable tracing on all functions again */
438 ftrace_set_global_filter(NULL, 0, 1);
440 /* Test the ops with global tracing off */
442 ret = trace_selftest_ops(tr, 2);
447 static int trace_selftest_recursion_cnt;
448 static void trace_selftest_test_recursion_func(unsigned long ip,
450 struct ftrace_ops *op,
451 struct ftrace_regs *fregs)
454 * This function is registered without the recursion safe flag.
455 * The ftrace infrastructure should provide the recursion
456 * protection. If not, this will crash the kernel!
458 if (trace_selftest_recursion_cnt++ > 10)
460 DYN_FTRACE_TEST_NAME();
463 static void trace_selftest_test_recursion_safe_func(unsigned long ip,
465 struct ftrace_ops *op,
466 struct ftrace_regs *fregs)
469 * We said we would provide our own recursion. By calling
470 * this function again, we should recurse back into this function
471 * and count again. But this only happens if the arch supports
472 * all of ftrace features and nothing else is using the function
475 if (trace_selftest_recursion_cnt++)
477 DYN_FTRACE_TEST_NAME();
480 static struct ftrace_ops test_rec_probe = {
481 .func = trace_selftest_test_recursion_func,
482 .flags = FTRACE_OPS_FL_RECURSION,
485 static struct ftrace_ops test_recsafe_probe = {
486 .func = trace_selftest_test_recursion_safe_func,
490 trace_selftest_function_recursion(void)
492 int save_ftrace_enabled = ftrace_enabled;
497 /* The previous test PASSED */
499 pr_info("Testing ftrace recursion: ");
502 /* enable tracing, and record the filter function */
505 /* Handle PPC64 '.' name */
506 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
507 len = strlen(func_name);
509 ret = ftrace_set_filter(&test_rec_probe, func_name, len, 1);
511 pr_cont("*Could not set filter* ");
515 ret = register_ftrace_function(&test_rec_probe);
517 pr_cont("*could not register callback* ");
521 DYN_FTRACE_TEST_NAME();
523 unregister_ftrace_function(&test_rec_probe);
527 * Recursion allows for transitions between context,
528 * and may call the callback twice.
530 if (trace_selftest_recursion_cnt != 1 &&
531 trace_selftest_recursion_cnt != 2) {
532 pr_cont("*callback not called once (or twice) (%d)* ",
533 trace_selftest_recursion_cnt);
537 trace_selftest_recursion_cnt = 1;
540 pr_info("Testing ftrace recursion safe: ");
542 ret = ftrace_set_filter(&test_recsafe_probe, func_name, len, 1);
544 pr_cont("*Could not set filter* ");
548 ret = register_ftrace_function(&test_recsafe_probe);
550 pr_cont("*could not register callback* ");
554 DYN_FTRACE_TEST_NAME();
556 unregister_ftrace_function(&test_recsafe_probe);
559 if (trace_selftest_recursion_cnt != 2) {
560 pr_cont("*callback not called expected 2 times (%d)* ",
561 trace_selftest_recursion_cnt);
567 ftrace_enabled = save_ftrace_enabled;
572 # define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; })
573 # define trace_selftest_function_recursion() ({ 0; })
574 #endif /* CONFIG_DYNAMIC_FTRACE */
577 TRACE_SELFTEST_REGS_START,
578 TRACE_SELFTEST_REGS_FOUND,
579 TRACE_SELFTEST_REGS_NOT_FOUND,
580 } trace_selftest_regs_stat;
582 static void trace_selftest_test_regs_func(unsigned long ip,
584 struct ftrace_ops *op,
585 struct ftrace_regs *fregs)
587 struct pt_regs *regs = ftrace_get_regs(fregs);
590 trace_selftest_regs_stat = TRACE_SELFTEST_REGS_FOUND;
592 trace_selftest_regs_stat = TRACE_SELFTEST_REGS_NOT_FOUND;
595 static struct ftrace_ops test_regs_probe = {
596 .func = trace_selftest_test_regs_func,
597 .flags = FTRACE_OPS_FL_SAVE_REGS,
601 trace_selftest_function_regs(void)
603 int save_ftrace_enabled = ftrace_enabled;
609 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
613 /* The previous test PASSED */
615 pr_info("Testing ftrace regs%s: ",
616 !supported ? "(no arch support)" : "");
618 /* enable tracing, and record the filter function */
621 /* Handle PPC64 '.' name */
622 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
623 len = strlen(func_name);
625 ret = ftrace_set_filter(&test_regs_probe, func_name, len, 1);
627 * If DYNAMIC_FTRACE is not set, then we just trace all functions.
628 * This test really doesn't care.
630 if (ret && ret != -ENODEV) {
631 pr_cont("*Could not set filter* ");
635 ret = register_ftrace_function(&test_regs_probe);
637 * Now if the arch does not support passing regs, then this should
642 pr_cont("*registered save-regs without arch support* ");
645 test_regs_probe.flags |= FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED;
646 ret = register_ftrace_function(&test_regs_probe);
649 pr_cont("*could not register callback* ");
654 DYN_FTRACE_TEST_NAME();
656 unregister_ftrace_function(&test_regs_probe);
660 switch (trace_selftest_regs_stat) {
661 case TRACE_SELFTEST_REGS_START:
662 pr_cont("*callback never called* ");
665 case TRACE_SELFTEST_REGS_FOUND:
668 pr_cont("*callback received regs without arch support* ");
671 case TRACE_SELFTEST_REGS_NOT_FOUND:
674 pr_cont("*callback received NULL regs* ");
680 ftrace_enabled = save_ftrace_enabled;
686 * Simple verification test of ftrace function tracer.
687 * Enable ftrace, sleep 1/10 second, and then read the trace
688 * buffer to see if all is in order.
691 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
693 int save_ftrace_enabled = ftrace_enabled;
697 #ifdef CONFIG_DYNAMIC_FTRACE
698 if (ftrace_filter_param) {
699 printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
704 /* make sure msleep has been recorded */
707 /* start the tracing */
710 ret = tracer_init(trace, tr);
712 warn_failed_init_tracer(trace, ret);
716 /* Sleep for a 1/10 of a second */
718 /* stop the tracing. */
722 /* check the trace buffer */
723 ret = trace_test_buffer(&tr->array_buffer, &count);
729 if (!ret && !count) {
730 printk(KERN_CONT ".. no entries found ..");
735 ret = trace_selftest_startup_dynamic_tracing(trace, tr,
736 DYN_FTRACE_TEST_NAME);
740 ret = trace_selftest_function_recursion();
744 ret = trace_selftest_function_regs();
746 ftrace_enabled = save_ftrace_enabled;
748 /* kill ftrace totally if we failed */
754 #endif /* CONFIG_FUNCTION_TRACER */
757 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
759 /* Maximum number of functions to trace before diagnosing a hang */
760 #define GRAPH_MAX_FUNC_TEST 100000000
762 static unsigned int graph_hang_thresh;
764 /* Wrap the real function entry probe to avoid possible hanging */
765 static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace)
767 /* This is harmlessly racy, we want to approximately detect a hang */
768 if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) {
770 printk(KERN_WARNING "BUG: Function graph tracer hang!\n");
771 if (ftrace_dump_on_oops) {
772 ftrace_dump(DUMP_ALL);
773 /* ftrace_dump() disables tracing */
779 return trace_graph_entry(trace);
782 static struct fgraph_ops fgraph_ops __initdata = {
783 .entryfunc = &trace_graph_entry_watchdog,
784 .retfunc = &trace_graph_return,
787 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
788 #ifndef CALL_DEPTH_ACCOUNT
789 #define CALL_DEPTH_ACCOUNT ""
792 noinline __noclone static void trace_direct_tramp(void)
794 asm(CALL_DEPTH_ACCOUNT);
799 * Pretty much the same than for the function tracer from which the selftest
803 trace_selftest_startup_function_graph(struct tracer *trace,
804 struct trace_array *tr)
808 char *func_name __maybe_unused;
810 #ifdef CONFIG_DYNAMIC_FTRACE
811 if (ftrace_filter_param) {
812 printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
818 * Simulate the init() callback but we attach a watchdog callback
819 * to detect and recover from possible hangs
821 tracing_reset_online_cpus(&tr->array_buffer);
823 ret = register_ftrace_graph(&fgraph_ops);
825 warn_failed_init_tracer(trace, ret);
828 tracing_start_cmdline_record();
830 /* Sleep for a 1/10 of a second */
833 /* Have we just recovered from a hang? */
834 if (graph_hang_thresh > GRAPH_MAX_FUNC_TEST) {
835 disable_tracing_selftest("recovering from a hang");
842 /* check the trace buffer */
843 ret = trace_test_buffer(&tr->array_buffer, &count);
845 /* Need to also simulate the tr->reset to remove this fgraph_ops */
846 tracing_stop_cmdline_record();
847 unregister_ftrace_graph(&fgraph_ops);
851 if (!ret && !count) {
852 printk(KERN_CONT ".. no entries found ..");
857 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
858 tracing_reset_online_cpus(&tr->array_buffer);
862 * Some archs *cough*PowerPC*cough* add characters to the
863 * start of the function names. We simply put a '*' to
866 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
867 ftrace_set_global_filter(func_name, strlen(func_name), 1);
870 * Register direct function together with graph tracer
871 * and make sure we get graph trace.
873 ret = register_ftrace_direct((unsigned long) DYN_FTRACE_TEST_NAME,
874 (unsigned long) trace_direct_tramp);
878 ret = register_ftrace_graph(&fgraph_ops);
880 warn_failed_init_tracer(trace, ret);
884 DYN_FTRACE_TEST_NAME();
889 /* check the trace buffer */
890 ret = trace_test_buffer(&tr->array_buffer, &count);
892 unregister_ftrace_graph(&fgraph_ops);
894 ret = unregister_ftrace_direct((unsigned long) DYN_FTRACE_TEST_NAME,
895 (unsigned long) trace_direct_tramp);
901 if (!ret && !count) {
906 /* Enable tracing on all functions again */
907 ftrace_set_global_filter(NULL, 0, 1);
910 /* Don't test dynamic tracing, the function tracer already did */
912 /* Stop it if we failed */
918 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
921 #ifdef CONFIG_IRQSOFF_TRACER
923 trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
925 unsigned long save_max = tr->max_latency;
929 /* start the tracing */
930 ret = tracer_init(trace, tr);
932 warn_failed_init_tracer(trace, ret);
936 /* reset the max latency */
938 /* disable interrupts for a bit */
944 * Stop the tracer to avoid a warning subsequent
945 * to buffer flipping failure because tracing_stop()
946 * disables the tr and max buffers, making flipping impossible
947 * in case of parallels max irqs off latencies.
950 /* stop the tracing. */
952 /* check both trace buffers */
953 ret = trace_test_buffer(&tr->array_buffer, NULL);
955 ret = trace_test_buffer(&tr->max_buffer, &count);
959 if (!ret && !count) {
960 printk(KERN_CONT ".. no entries found ..");
964 tr->max_latency = save_max;
968 #endif /* CONFIG_IRQSOFF_TRACER */
970 #ifdef CONFIG_PREEMPT_TRACER
972 trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
974 unsigned long save_max = tr->max_latency;
979 * Now that the big kernel lock is no longer preemptible,
980 * and this is called with the BKL held, it will always
981 * fail. If preemption is already disabled, simply
982 * pass the test. When the BKL is removed, or becomes
983 * preemptible again, we will once again test this,
986 if (preempt_count()) {
987 printk(KERN_CONT "can not test ... force ");
991 /* start the tracing */
992 ret = tracer_init(trace, tr);
994 warn_failed_init_tracer(trace, ret);
998 /* reset the max latency */
1000 /* disable preemption for a bit */
1006 * Stop the tracer to avoid a warning subsequent
1007 * to buffer flipping failure because tracing_stop()
1008 * disables the tr and max buffers, making flipping impossible
1009 * in case of parallels max preempt off latencies.
1012 /* stop the tracing. */
1014 /* check both trace buffers */
1015 ret = trace_test_buffer(&tr->array_buffer, NULL);
1017 ret = trace_test_buffer(&tr->max_buffer, &count);
1021 if (!ret && !count) {
1022 printk(KERN_CONT ".. no entries found ..");
1026 tr->max_latency = save_max;
1030 #endif /* CONFIG_PREEMPT_TRACER */
1032 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
1034 trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr)
1036 unsigned long save_max = tr->max_latency;
1037 unsigned long count;
1041 * Now that the big kernel lock is no longer preemptible,
1042 * and this is called with the BKL held, it will always
1043 * fail. If preemption is already disabled, simply
1044 * pass the test. When the BKL is removed, or becomes
1045 * preemptible again, we will once again test this,
1048 if (preempt_count()) {
1049 printk(KERN_CONT "can not test ... force ");
1053 /* start the tracing */
1054 ret = tracer_init(trace, tr);
1056 warn_failed_init_tracer(trace, ret);
1060 /* reset the max latency */
1061 tr->max_latency = 0;
1063 /* disable preemption and interrupts for a bit */
1065 local_irq_disable();
1068 /* reverse the order of preempt vs irqs */
1072 * Stop the tracer to avoid a warning subsequent
1073 * to buffer flipping failure because tracing_stop()
1074 * disables the tr and max buffers, making flipping impossible
1075 * in case of parallels max irqs/preempt off latencies.
1078 /* stop the tracing. */
1080 /* check both trace buffers */
1081 ret = trace_test_buffer(&tr->array_buffer, NULL);
1085 ret = trace_test_buffer(&tr->max_buffer, &count);
1089 if (!ret && !count) {
1090 printk(KERN_CONT ".. no entries found ..");
1095 /* do the test by disabling interrupts first this time */
1096 tr->max_latency = 0;
1101 local_irq_disable();
1104 /* reverse the order of preempt vs irqs */
1108 /* stop the tracing. */
1110 /* check both trace buffers */
1111 ret = trace_test_buffer(&tr->array_buffer, NULL);
1115 ret = trace_test_buffer(&tr->max_buffer, &count);
1117 if (!ret && !count) {
1118 printk(KERN_CONT ".. no entries found ..");
1127 tr->max_latency = save_max;
1131 #endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */
1133 #ifdef CONFIG_NOP_TRACER
1135 trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
1137 /* What could possibly go wrong? */
1142 #ifdef CONFIG_SCHED_TRACER
1144 struct wakeup_test_data {
1145 struct completion is_ready;
1149 static int trace_wakeup_test_thread(void *data)
1151 /* Make this a -deadline thread */
1152 static const struct sched_attr attr = {
1153 .sched_policy = SCHED_DEADLINE,
1154 .sched_runtime = 100000ULL,
1155 .sched_deadline = 10000000ULL,
1156 .sched_period = 10000000ULL
1158 struct wakeup_test_data *x = data;
1160 sched_setattr(current, &attr);
1162 /* Make it know we have a new prio */
1163 complete(&x->is_ready);
1165 /* now go to sleep and let the test wake us up */
1166 set_current_state(TASK_INTERRUPTIBLE);
1169 set_current_state(TASK_INTERRUPTIBLE);
1172 complete(&x->is_ready);
1174 set_current_state(TASK_INTERRUPTIBLE);
1176 /* we are awake, now wait to disappear */
1177 while (!kthread_should_stop()) {
1179 set_current_state(TASK_INTERRUPTIBLE);
1182 __set_current_state(TASK_RUNNING);
1187 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
1189 unsigned long save_max = tr->max_latency;
1190 struct task_struct *p;
1191 struct wakeup_test_data data;
1192 unsigned long count;
1195 memset(&data, 0, sizeof(data));
1197 init_completion(&data.is_ready);
1199 /* create a -deadline thread */
1200 p = kthread_run(trace_wakeup_test_thread, &data, "ftrace-test");
1202 printk(KERN_CONT "Failed to create ftrace wakeup test thread ");
1206 /* make sure the thread is running at -deadline policy */
1207 wait_for_completion(&data.is_ready);
1209 /* start the tracing */
1210 ret = tracer_init(trace, tr);
1212 warn_failed_init_tracer(trace, ret);
1216 /* reset the max latency */
1217 tr->max_latency = 0;
1221 * Sleep to make sure the -deadline thread is asleep too.
1222 * On virtual machines we can't rely on timings,
1223 * but we want to make sure this test still works.
1228 init_completion(&data.is_ready);
1231 /* memory barrier is in the wake_up_process() */
1235 /* Wait for the task to wake up */
1236 wait_for_completion(&data.is_ready);
1238 /* stop the tracing. */
1240 /* check both trace buffers */
1241 ret = trace_test_buffer(&tr->array_buffer, NULL);
1243 ret = trace_test_buffer(&tr->max_buffer, &count);
1249 tr->max_latency = save_max;
1251 /* kill the thread */
1254 if (!ret && !count) {
1255 printk(KERN_CONT ".. no entries found ..");
1261 #endif /* CONFIG_SCHED_TRACER */
1263 #ifdef CONFIG_BRANCH_TRACER
1265 trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
1267 unsigned long count;
1270 /* start the tracing */
1271 ret = tracer_init(trace, tr);
1273 warn_failed_init_tracer(trace, ret);
1277 /* Sleep for a 1/10 of a second */
1279 /* stop the tracing. */
1281 /* check the trace buffer */
1282 ret = trace_test_buffer(&tr->array_buffer, &count);
1286 if (!ret && !count) {
1287 printk(KERN_CONT ".. no entries found ..");
1293 #endif /* CONFIG_BRANCH_TRACER */