1 /* Include in trace.c */
3 #include <linux/stringify.h>
4 #include <linux/kthread.h>
5 #include <linux/delay.h>
6 #include <linux/slab.h>
8 static inline int trace_valid_entry(struct trace_entry *entry)
10 switch (entry->type) {
24 static int trace_test_buffer_cpu(struct trace_buffer *buf, int cpu)
26 struct ring_buffer_event *event;
27 struct trace_entry *entry;
28 unsigned int loops = 0;
30 while ((event = ring_buffer_consume(buf->buffer, cpu, NULL, NULL))) {
31 entry = ring_buffer_event_data(event);
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.
38 if (loops++ > trace_buf_size) {
39 printk(KERN_CONT ".. bad ring buffer ");
42 if (!trace_valid_entry(entry)) {
43 printk(KERN_CONT ".. invalid entry %d ",
53 printk(KERN_CONT ".. corrupted trace buffer .. ");
58 * Test the trace buffer to see if all the elements
61 static int trace_test_buffer(struct trace_buffer *buf, unsigned long *count)
63 unsigned long flags, cnt = 0;
66 /* Don't allow flipping of max traces now */
67 local_irq_save(flags);
68 arch_spin_lock(&buf->tr->max_lock);
70 cnt = ring_buffer_entries(buf->buffer);
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
80 for_each_possible_cpu(cpu) {
81 ret = trace_test_buffer_cpu(buf, cpu);
86 arch_spin_unlock(&buf->tr->max_lock);
87 local_irq_restore(flags);
95 static inline void warn_failed_init_tracer(struct tracer *trace, int init_ret)
97 printk(KERN_WARNING "Failed to init %s tracer, init returned %d\n",
98 trace->name, init_ret);
100 #ifdef CONFIG_FUNCTION_TRACER
102 #ifdef CONFIG_DYNAMIC_FTRACE
104 static int trace_selftest_test_probe1_cnt;
105 static void trace_selftest_test_probe1_func(unsigned long ip,
107 struct ftrace_ops *op,
108 struct pt_regs *pt_regs)
110 trace_selftest_test_probe1_cnt++;
113 static int trace_selftest_test_probe2_cnt;
114 static void trace_selftest_test_probe2_func(unsigned long ip,
116 struct ftrace_ops *op,
117 struct pt_regs *pt_regs)
119 trace_selftest_test_probe2_cnt++;
122 static int trace_selftest_test_probe3_cnt;
123 static void trace_selftest_test_probe3_func(unsigned long ip,
125 struct ftrace_ops *op,
126 struct pt_regs *pt_regs)
128 trace_selftest_test_probe3_cnt++;
131 static int trace_selftest_test_global_cnt;
132 static void trace_selftest_test_global_func(unsigned long ip,
134 struct ftrace_ops *op,
135 struct pt_regs *pt_regs)
137 trace_selftest_test_global_cnt++;
140 static int trace_selftest_test_dyn_cnt;
141 static void trace_selftest_test_dyn_func(unsigned long ip,
143 struct ftrace_ops *op,
144 struct pt_regs *pt_regs)
146 trace_selftest_test_dyn_cnt++;
149 static struct ftrace_ops test_probe1 = {
150 .func = trace_selftest_test_probe1_func,
151 .flags = FTRACE_OPS_FL_RECURSION_SAFE,
154 static struct ftrace_ops test_probe2 = {
155 .func = trace_selftest_test_probe2_func,
156 .flags = FTRACE_OPS_FL_RECURSION_SAFE,
159 static struct ftrace_ops test_probe3 = {
160 .func = trace_selftest_test_probe3_func,
161 .flags = FTRACE_OPS_FL_RECURSION_SAFE,
164 static void print_counts(void)
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);
174 static void reset_counts(void)
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;
183 static int trace_selftest_ops(struct trace_array *tr, int cnt)
185 int save_ftrace_enabled = ftrace_enabled;
186 struct ftrace_ops *dyn_ops;
193 printk(KERN_CONT "PASSED\n");
194 pr_info("Testing dynamic ftrace ops #%d: ", cnt);
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);
206 * Probe 1 will trace function 1.
207 * Probe 2 will trace function 2.
208 * Probe 3 will trace functions 1 and 2.
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);
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 */
220 ftrace_init_array_ops(tr, trace_selftest_test_global_func);
221 register_ftrace_function(tr->ops);
224 DYN_FTRACE_TEST_NAME();
228 if (trace_selftest_test_probe1_cnt != 1)
230 if (trace_selftest_test_probe2_cnt != 0)
232 if (trace_selftest_test_probe3_cnt != 1)
235 if (trace_selftest_test_global_cnt == 0)
239 DYN_FTRACE_TEST_NAME2();
243 if (trace_selftest_test_probe1_cnt != 1)
245 if (trace_selftest_test_probe2_cnt != 1)
247 if (trace_selftest_test_probe3_cnt != 2)
250 /* Add a dynamic probe */
251 dyn_ops = kzalloc(sizeof(*dyn_ops), GFP_KERNEL);
253 printk("MEMORY ERROR ");
257 dyn_ops->func = trace_selftest_test_dyn_func;
259 register_ftrace_function(dyn_ops);
261 trace_selftest_test_global_cnt = 0;
263 DYN_FTRACE_TEST_NAME();
267 if (trace_selftest_test_probe1_cnt != 2)
269 if (trace_selftest_test_probe2_cnt != 1)
271 if (trace_selftest_test_probe3_cnt != 3)
274 if (trace_selftest_test_global_cnt == 0)
277 if (trace_selftest_test_dyn_cnt == 0)
280 DYN_FTRACE_TEST_NAME2();
284 if (trace_selftest_test_probe1_cnt != 2)
286 if (trace_selftest_test_probe2_cnt != 2)
288 if (trace_selftest_test_probe3_cnt != 4)
293 unregister_ftrace_function(dyn_ops);
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);
302 unregister_ftrace_function(tr->ops);
303 ftrace_reset_array_ops(tr);
305 /* Make sure everything is off */
307 DYN_FTRACE_TEST_NAME();
308 DYN_FTRACE_TEST_NAME();
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)
317 ftrace_enabled = save_ftrace_enabled;
322 /* Test dynamic code modification and ftrace filters */
323 static int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
324 struct trace_array *tr,
327 int save_ftrace_enabled = ftrace_enabled;
332 /* The ftrace test PASSED */
333 printk(KERN_CONT "PASSED\n");
334 pr_info("Testing dynamic ftrace: ");
336 /* enable tracing, and record the filter function */
339 /* passed in by parameter to fool gcc from optimizing */
343 * Some archs *cough*PowerPC*cough* add characters to the
344 * start of the function names. We simply put a '*' to
347 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
349 /* filter only on our function */
350 ftrace_set_global_filter(func_name, strlen(func_name), 1);
353 ret = tracer_init(trace, tr);
355 warn_failed_init_tracer(trace, ret);
359 /* Sleep for a 1/10 of a second */
362 /* we should have nothing in the buffer */
363 ret = trace_test_buffer(&tr->trace_buffer, &count);
369 printk(KERN_CONT ".. filter did not filter .. ");
373 /* call our function again */
379 /* stop the tracing. */
383 /* check the trace buffer */
384 ret = trace_test_buffer(&tr->trace_buffer, &count);
389 /* we should only have one item */
390 if (!ret && count != 1) {
392 printk(KERN_CONT ".. filter failed count=%ld ..", count);
397 /* Test the ops with global tracing running */
398 ret = trace_selftest_ops(tr, 1);
402 ftrace_enabled = save_ftrace_enabled;
404 /* Enable tracing on all functions again */
405 ftrace_set_global_filter(NULL, 0, 1);
407 /* Test the ops with global tracing off */
409 ret = trace_selftest_ops(tr, 2);
414 static int trace_selftest_recursion_cnt;
415 static void trace_selftest_test_recursion_func(unsigned long ip,
417 struct ftrace_ops *op,
418 struct pt_regs *pt_regs)
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!
425 if (trace_selftest_recursion_cnt++ > 10)
427 DYN_FTRACE_TEST_NAME();
430 static void trace_selftest_test_recursion_safe_func(unsigned long ip,
432 struct ftrace_ops *op,
433 struct pt_regs *pt_regs)
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
442 if (trace_selftest_recursion_cnt++)
444 DYN_FTRACE_TEST_NAME();
447 static struct ftrace_ops test_rec_probe = {
448 .func = trace_selftest_test_recursion_func,
451 static struct ftrace_ops test_recsafe_probe = {
452 .func = trace_selftest_test_recursion_safe_func,
453 .flags = FTRACE_OPS_FL_RECURSION_SAFE,
457 trace_selftest_function_recursion(void)
459 int save_ftrace_enabled = ftrace_enabled;
464 /* The previous test PASSED */
466 pr_info("Testing ftrace recursion: ");
469 /* enable tracing, and record the filter function */
472 /* Handle PPC64 '.' name */
473 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
474 len = strlen(func_name);
476 ret = ftrace_set_filter(&test_rec_probe, func_name, len, 1);
478 pr_cont("*Could not set filter* ");
482 ret = register_ftrace_function(&test_rec_probe);
484 pr_cont("*could not register callback* ");
488 DYN_FTRACE_TEST_NAME();
490 unregister_ftrace_function(&test_rec_probe);
493 if (trace_selftest_recursion_cnt != 1) {
494 pr_cont("*callback not called once (%d)* ",
495 trace_selftest_recursion_cnt);
499 trace_selftest_recursion_cnt = 1;
502 pr_info("Testing ftrace recursion safe: ");
504 ret = ftrace_set_filter(&test_recsafe_probe, func_name, len, 1);
506 pr_cont("*Could not set filter* ");
510 ret = register_ftrace_function(&test_recsafe_probe);
512 pr_cont("*could not register callback* ");
516 DYN_FTRACE_TEST_NAME();
518 unregister_ftrace_function(&test_recsafe_probe);
521 if (trace_selftest_recursion_cnt != 2) {
522 pr_cont("*callback not called expected 2 times (%d)* ",
523 trace_selftest_recursion_cnt);
529 ftrace_enabled = save_ftrace_enabled;
534 # define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; })
535 # define trace_selftest_function_recursion() ({ 0; })
536 #endif /* CONFIG_DYNAMIC_FTRACE */
539 TRACE_SELFTEST_REGS_START,
540 TRACE_SELFTEST_REGS_FOUND,
541 TRACE_SELFTEST_REGS_NOT_FOUND,
542 } trace_selftest_regs_stat;
544 static void trace_selftest_test_regs_func(unsigned long ip,
546 struct ftrace_ops *op,
547 struct pt_regs *pt_regs)
550 trace_selftest_regs_stat = TRACE_SELFTEST_REGS_FOUND;
552 trace_selftest_regs_stat = TRACE_SELFTEST_REGS_NOT_FOUND;
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,
561 trace_selftest_function_regs(void)
563 int save_ftrace_enabled = ftrace_enabled;
569 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
573 /* The previous test PASSED */
575 pr_info("Testing ftrace regs%s: ",
576 !supported ? "(no arch support)" : "");
578 /* enable tracing, and record the filter function */
581 /* Handle PPC64 '.' name */
582 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
583 len = strlen(func_name);
585 ret = ftrace_set_filter(&test_regs_probe, func_name, len, 1);
587 * If DYNAMIC_FTRACE is not set, then we just trace all functions.
588 * This test really doesn't care.
590 if (ret && ret != -ENODEV) {
591 pr_cont("*Could not set filter* ");
595 ret = register_ftrace_function(&test_regs_probe);
597 * Now if the arch does not support passing regs, then this should
602 pr_cont("*registered save-regs without arch support* ");
605 test_regs_probe.flags |= FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED;
606 ret = register_ftrace_function(&test_regs_probe);
609 pr_cont("*could not register callback* ");
614 DYN_FTRACE_TEST_NAME();
616 unregister_ftrace_function(&test_regs_probe);
620 switch (trace_selftest_regs_stat) {
621 case TRACE_SELFTEST_REGS_START:
622 pr_cont("*callback never called* ");
625 case TRACE_SELFTEST_REGS_FOUND:
628 pr_cont("*callback received regs without arch support* ");
631 case TRACE_SELFTEST_REGS_NOT_FOUND:
634 pr_cont("*callback received NULL regs* ");
640 ftrace_enabled = save_ftrace_enabled;
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.
651 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
653 int save_ftrace_enabled = ftrace_enabled;
657 #ifdef CONFIG_DYNAMIC_FTRACE
658 if (ftrace_filter_param) {
659 printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
664 /* make sure msleep has been recorded */
667 /* start the tracing */
670 ret = tracer_init(trace, tr);
672 warn_failed_init_tracer(trace, ret);
676 /* Sleep for a 1/10 of a second */
678 /* stop the tracing. */
682 /* check the trace buffer */
683 ret = trace_test_buffer(&tr->trace_buffer, &count);
689 if (!ret && !count) {
690 printk(KERN_CONT ".. no entries found ..");
695 ret = trace_selftest_startup_dynamic_tracing(trace, tr,
696 DYN_FTRACE_TEST_NAME);
700 ret = trace_selftest_function_recursion();
704 ret = trace_selftest_function_regs();
706 ftrace_enabled = save_ftrace_enabled;
708 /* kill ftrace totally if we failed */
714 #endif /* CONFIG_FUNCTION_TRACER */
717 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
719 /* Maximum number of functions to trace before diagnosing a hang */
720 #define GRAPH_MAX_FUNC_TEST 100000000
722 static unsigned int graph_hang_thresh;
724 /* Wrap the real function entry probe to avoid possible hanging */
725 static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace)
727 /* This is harmlessly racy, we want to approximately detect a hang */
728 if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) {
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 */
739 return trace_graph_entry(trace);
743 * Pretty much the same than for the function tracer from which the selftest
747 trace_selftest_startup_function_graph(struct tracer *trace,
748 struct trace_array *tr)
753 #ifdef CONFIG_DYNAMIC_FTRACE
754 if (ftrace_filter_param) {
755 printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
761 * Simulate the init() callback but we attach a watchdog callback
762 * to detect and recover from possible hangs
764 tracing_reset_online_cpus(&tr->trace_buffer);
766 ret = register_ftrace_graph(&trace_graph_return,
767 &trace_graph_entry_watchdog);
769 warn_failed_init_tracer(trace, ret);
772 tracing_start_cmdline_record();
774 /* Sleep for a 1/10 of a second */
777 /* Have we just recovered from a hang? */
778 if (graph_hang_thresh > GRAPH_MAX_FUNC_TEST) {
779 tracing_selftest_disabled = true;
786 /* check the trace buffer */
787 ret = trace_test_buffer(&tr->trace_buffer, &count);
792 if (!ret && !count) {
793 printk(KERN_CONT ".. no entries found ..");
798 /* Don't test dynamic tracing, the function tracer already did */
801 /* Stop it if we failed */
807 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
810 #ifdef CONFIG_IRQSOFF_TRACER
812 trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
814 unsigned long save_max = tr->max_latency;
818 /* start the tracing */
819 ret = tracer_init(trace, tr);
821 warn_failed_init_tracer(trace, ret);
825 /* reset the max latency */
827 /* disable interrupts for a bit */
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.
839 /* stop the tracing. */
841 /* check both trace buffers */
842 ret = trace_test_buffer(&tr->trace_buffer, NULL);
844 ret = trace_test_buffer(&tr->max_buffer, &count);
848 if (!ret && !count) {
849 printk(KERN_CONT ".. no entries found ..");
853 tr->max_latency = save_max;
857 #endif /* CONFIG_IRQSOFF_TRACER */
859 #ifdef CONFIG_PREEMPT_TRACER
861 trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
863 unsigned long save_max = tr->max_latency;
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,
875 if (preempt_count()) {
876 printk(KERN_CONT "can not test ... force ");
880 /* start the tracing */
881 ret = tracer_init(trace, tr);
883 warn_failed_init_tracer(trace, ret);
887 /* reset the max latency */
889 /* disable preemption for a bit */
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.
901 /* stop the tracing. */
903 /* check both trace buffers */
904 ret = trace_test_buffer(&tr->trace_buffer, NULL);
906 ret = trace_test_buffer(&tr->max_buffer, &count);
910 if (!ret && !count) {
911 printk(KERN_CONT ".. no entries found ..");
915 tr->max_latency = save_max;
919 #endif /* CONFIG_PREEMPT_TRACER */
921 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
923 trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr)
925 unsigned long save_max = tr->max_latency;
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,
937 if (preempt_count()) {
938 printk(KERN_CONT "can not test ... force ");
942 /* start the tracing */
943 ret = tracer_init(trace, tr);
945 warn_failed_init_tracer(trace, ret);
949 /* reset the max latency */
952 /* disable preemption and interrupts for a bit */
957 /* reverse the order of preempt vs irqs */
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.
967 /* stop the tracing. */
969 /* check both trace buffers */
970 ret = trace_test_buffer(&tr->trace_buffer, NULL);
974 ret = trace_test_buffer(&tr->max_buffer, &count);
978 if (!ret && !count) {
979 printk(KERN_CONT ".. no entries found ..");
984 /* do the test by disabling interrupts first this time */
993 /* reverse the order of preempt vs irqs */
997 /* stop the tracing. */
999 /* check both trace buffers */
1000 ret = trace_test_buffer(&tr->trace_buffer, NULL);
1004 ret = trace_test_buffer(&tr->max_buffer, &count);
1006 if (!ret && !count) {
1007 printk(KERN_CONT ".. no entries found ..");
1016 tr->max_latency = save_max;
1020 #endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */
1022 #ifdef CONFIG_NOP_TRACER
1024 trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
1026 /* What could possibly go wrong? */
1031 #ifdef CONFIG_SCHED_TRACER
1033 struct wakeup_test_data {
1034 struct completion is_ready;
1038 static int trace_wakeup_test_thread(void *data)
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
1047 struct wakeup_test_data *x = data;
1049 sched_setattr(current, &attr);
1051 /* Make it know we have a new prio */
1052 complete(&x->is_ready);
1054 /* now go to sleep and let the test wake us up */
1055 set_current_state(TASK_INTERRUPTIBLE);
1058 set_current_state(TASK_INTERRUPTIBLE);
1061 complete(&x->is_ready);
1063 set_current_state(TASK_INTERRUPTIBLE);
1065 /* we are awake, now wait to disappear */
1066 while (!kthread_should_stop()) {
1068 set_current_state(TASK_INTERRUPTIBLE);
1071 __set_current_state(TASK_RUNNING);
1076 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
1078 unsigned long save_max = tr->max_latency;
1079 struct task_struct *p;
1080 struct wakeup_test_data data;
1081 unsigned long count;
1084 memset(&data, 0, sizeof(data));
1086 init_completion(&data.is_ready);
1088 /* create a -deadline thread */
1089 p = kthread_run(trace_wakeup_test_thread, &data, "ftrace-test");
1091 printk(KERN_CONT "Failed to create ftrace wakeup test thread ");
1095 /* make sure the thread is running at -deadline policy */
1096 wait_for_completion(&data.is_ready);
1098 /* start the tracing */
1099 ret = tracer_init(trace, tr);
1101 warn_failed_init_tracer(trace, ret);
1105 /* reset the max latency */
1106 tr->max_latency = 0;
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.
1117 init_completion(&data.is_ready);
1120 /* memory barrier is in the wake_up_process() */
1124 /* Wait for the task to wake up */
1125 wait_for_completion(&data.is_ready);
1127 /* stop the tracing. */
1129 /* check both trace buffers */
1130 ret = trace_test_buffer(&tr->trace_buffer, NULL);
1132 ret = trace_test_buffer(&tr->max_buffer, &count);
1138 tr->max_latency = save_max;
1140 /* kill the thread */
1143 if (!ret && !count) {
1144 printk(KERN_CONT ".. no entries found ..");
1150 #endif /* CONFIG_SCHED_TRACER */
1152 #ifdef CONFIG_CONTEXT_SWITCH_TRACER
1154 trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr)
1156 unsigned long count;
1159 /* start the tracing */
1160 ret = tracer_init(trace, tr);
1162 warn_failed_init_tracer(trace, ret);
1166 /* Sleep for a 1/10 of a second */
1168 /* stop the tracing. */
1170 /* check the trace buffer */
1171 ret = trace_test_buffer(&tr->trace_buffer, &count);
1175 if (!ret && !count) {
1176 printk(KERN_CONT ".. no entries found ..");
1182 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */
1184 #ifdef CONFIG_BRANCH_TRACER
1186 trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
1188 unsigned long count;
1191 /* start the tracing */
1192 ret = tracer_init(trace, tr);
1194 warn_failed_init_tracer(trace, ret);
1198 /* Sleep for a 1/10 of a second */
1200 /* stop the tracing. */
1202 /* check the trace buffer */
1203 ret = trace_test_buffer(&tr->trace_buffer, &count);
1207 if (!ret && !count) {
1208 printk(KERN_CONT ".. no entries found ..");
1214 #endif /* CONFIG_BRANCH_TRACER */