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_array *tr, int cpu)
26 struct ring_buffer_event *event;
27 struct trace_entry *entry;
28 unsigned int loops = 0;
30 while ((event = ring_buffer_consume(tr->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_array *tr, 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(&ftrace_max_lock);
70 cnt = ring_buffer_entries(tr->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(tr, cpu);
86 arch_spin_unlock(&ftrace_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 struct ftrace_ops test_global = {
165 .func = trace_selftest_test_global_func,
166 .flags = FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_RECURSION_SAFE,
169 static void print_counts(void)
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);
179 static void reset_counts(void)
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;
188 static int trace_selftest_ops(int cnt)
190 int save_ftrace_enabled = ftrace_enabled;
191 struct ftrace_ops *dyn_ops;
198 printk(KERN_CONT "PASSED\n");
199 pr_info("Testing dynamic ftrace ops #%d: ", cnt);
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);
211 * Probe 1 will trace function 1.
212 * Probe 2 will trace function 2.
213 * Probe 3 will trace functions 1 and 2.
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);
220 register_ftrace_function(&test_probe1);
221 register_ftrace_function(&test_probe2);
222 register_ftrace_function(&test_probe3);
223 register_ftrace_function(&test_global);
225 DYN_FTRACE_TEST_NAME();
229 if (trace_selftest_test_probe1_cnt != 1)
231 if (trace_selftest_test_probe2_cnt != 0)
233 if (trace_selftest_test_probe3_cnt != 1)
235 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)
272 if (trace_selftest_test_global_cnt == 0)
274 if (trace_selftest_test_dyn_cnt == 0)
277 DYN_FTRACE_TEST_NAME2();
281 if (trace_selftest_test_probe1_cnt != 2)
283 if (trace_selftest_test_probe2_cnt != 2)
285 if (trace_selftest_test_probe3_cnt != 4)
290 unregister_ftrace_function(dyn_ops);
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);
300 /* Make sure everything is off */
302 DYN_FTRACE_TEST_NAME();
303 DYN_FTRACE_TEST_NAME();
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)
312 ftrace_enabled = save_ftrace_enabled;
317 /* Test dynamic code modification and ftrace filters */
318 int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
319 struct trace_array *tr,
322 int save_ftrace_enabled = ftrace_enabled;
327 /* The ftrace test PASSED */
328 printk(KERN_CONT "PASSED\n");
329 pr_info("Testing dynamic ftrace: ");
331 /* enable tracing, and record the filter function */
334 /* passed in by parameter to fool gcc from optimizing */
338 * Some archs *cough*PowerPC*cough* add characters to the
339 * start of the function names. We simply put a '*' to
342 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
344 /* filter only on our function */
345 ftrace_set_global_filter(func_name, strlen(func_name), 1);
348 ret = tracer_init(trace, tr);
350 warn_failed_init_tracer(trace, ret);
354 /* Sleep for a 1/10 of a second */
357 /* we should have nothing in the buffer */
358 ret = trace_test_buffer(tr, &count);
364 printk(KERN_CONT ".. filter did not filter .. ");
368 /* call our function again */
374 /* stop the tracing. */
378 /* check the trace buffer */
379 ret = trace_test_buffer(tr, &count);
382 /* we should only have one item */
383 if (!ret && count != 1) {
385 printk(KERN_CONT ".. filter failed count=%ld ..", count);
390 /* Test the ops with global tracing running */
391 ret = trace_selftest_ops(1);
395 ftrace_enabled = save_ftrace_enabled;
397 /* Enable tracing on all functions again */
398 ftrace_set_global_filter(NULL, 0, 1);
400 /* Test the ops with global tracing off */
402 ret = trace_selftest_ops(2);
407 static int trace_selftest_recursion_cnt;
408 static void trace_selftest_test_recursion_func(unsigned long ip,
410 struct ftrace_ops *op,
411 struct pt_regs *pt_regs)
414 * This function is registered without the recursion safe flag.
415 * The ftrace infrastructure should provide the recursion
416 * protection. If not, this will crash the kernel!
418 trace_selftest_recursion_cnt++;
419 DYN_FTRACE_TEST_NAME();
422 static void trace_selftest_test_recursion_safe_func(unsigned long ip,
424 struct ftrace_ops *op,
425 struct pt_regs *pt_regs)
428 * We said we would provide our own recursion. By calling
429 * this function again, we should recurse back into this function
430 * and count again. But this only happens if the arch supports
431 * all of ftrace features and nothing else is using the function
434 if (trace_selftest_recursion_cnt++)
436 DYN_FTRACE_TEST_NAME();
439 static struct ftrace_ops test_rec_probe = {
440 .func = trace_selftest_test_recursion_func,
443 static struct ftrace_ops test_recsafe_probe = {
444 .func = trace_selftest_test_recursion_safe_func,
445 .flags = FTRACE_OPS_FL_RECURSION_SAFE,
449 trace_selftest_function_recursion(void)
451 int save_ftrace_enabled = ftrace_enabled;
457 /* The previous test PASSED */
459 pr_info("Testing ftrace recursion: ");
462 /* enable tracing, and record the filter function */
465 /* Handle PPC64 '.' name */
466 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
467 len = strlen(func_name);
469 ret = ftrace_set_filter(&test_rec_probe, func_name, len, 1);
471 pr_cont("*Could not set filter* ");
475 ret = register_ftrace_function(&test_rec_probe);
477 pr_cont("*could not register callback* ");
481 DYN_FTRACE_TEST_NAME();
483 unregister_ftrace_function(&test_rec_probe);
486 if (trace_selftest_recursion_cnt != 1) {
487 pr_cont("*callback not called once (%d)* ",
488 trace_selftest_recursion_cnt);
492 trace_selftest_recursion_cnt = 1;
495 pr_info("Testing ftrace recursion safe: ");
497 ret = ftrace_set_filter(&test_recsafe_probe, func_name, len, 1);
499 pr_cont("*Could not set filter* ");
503 ret = register_ftrace_function(&test_recsafe_probe);
505 pr_cont("*could not register callback* ");
509 DYN_FTRACE_TEST_NAME();
511 unregister_ftrace_function(&test_recsafe_probe);
514 * If arch supports all ftrace features, and no other task
515 * was on the list, we should be fine.
517 if (!ftrace_nr_registered_ops() && !FTRACE_FORCE_LIST_FUNC)
518 cnt = 2; /* Should have recursed */
523 if (trace_selftest_recursion_cnt != cnt) {
524 pr_cont("*callback not called expected %d times (%d)* ",
525 cnt, trace_selftest_recursion_cnt);
531 ftrace_enabled = save_ftrace_enabled;
536 # define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; })
537 # define trace_selftest_function_recursion() ({ 0; })
538 #endif /* CONFIG_DYNAMIC_FTRACE */
541 TRACE_SELFTEST_REGS_START,
542 TRACE_SELFTEST_REGS_FOUND,
543 TRACE_SELFTEST_REGS_NOT_FOUND,
544 } trace_selftest_regs_stat;
546 static void trace_selftest_test_regs_func(unsigned long ip,
548 struct ftrace_ops *op,
549 struct pt_regs *pt_regs)
552 trace_selftest_regs_stat = TRACE_SELFTEST_REGS_FOUND;
554 trace_selftest_regs_stat = TRACE_SELFTEST_REGS_NOT_FOUND;
557 static struct ftrace_ops test_regs_probe = {
558 .func = trace_selftest_test_regs_func,
559 .flags = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_SAVE_REGS,
563 trace_selftest_function_regs(void)
565 int save_ftrace_enabled = ftrace_enabled;
571 #ifdef ARCH_SUPPORTS_FTRACE_SAVE_REGS
575 /* The previous test PASSED */
577 pr_info("Testing ftrace regs%s: ",
578 !supported ? "(no arch support)" : "");
580 /* enable tracing, and record the filter function */
583 /* Handle PPC64 '.' name */
584 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
585 len = strlen(func_name);
587 ret = ftrace_set_filter(&test_regs_probe, func_name, len, 1);
589 * If DYNAMIC_FTRACE is not set, then we just trace all functions.
590 * This test really doesn't care.
592 if (ret && ret != -ENODEV) {
593 pr_cont("*Could not set filter* ");
597 ret = register_ftrace_function(&test_regs_probe);
599 * Now if the arch does not support passing regs, then this should
604 pr_cont("*registered save-regs without arch support* ");
607 test_regs_probe.flags |= FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED;
608 ret = register_ftrace_function(&test_regs_probe);
611 pr_cont("*could not register callback* ");
616 DYN_FTRACE_TEST_NAME();
618 unregister_ftrace_function(&test_regs_probe);
622 switch (trace_selftest_regs_stat) {
623 case TRACE_SELFTEST_REGS_START:
624 pr_cont("*callback never called* ");
627 case TRACE_SELFTEST_REGS_FOUND:
630 pr_cont("*callback received regs without arch support* ");
633 case TRACE_SELFTEST_REGS_NOT_FOUND:
636 pr_cont("*callback received NULL regs* ");
642 ftrace_enabled = save_ftrace_enabled;
648 * Simple verification test of ftrace function tracer.
649 * Enable ftrace, sleep 1/10 second, and then read the trace
650 * buffer to see if all is in order.
653 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
655 int save_ftrace_enabled = ftrace_enabled;
659 /* make sure msleep has been recorded */
662 /* start the tracing */
665 ret = tracer_init(trace, tr);
667 warn_failed_init_tracer(trace, ret);
671 /* Sleep for a 1/10 of a second */
673 /* stop the tracing. */
677 /* check the trace buffer */
678 ret = trace_test_buffer(tr, &count);
682 if (!ret && !count) {
683 printk(KERN_CONT ".. no entries found ..");
688 ret = trace_selftest_startup_dynamic_tracing(trace, tr,
689 DYN_FTRACE_TEST_NAME);
693 ret = trace_selftest_function_recursion();
697 ret = trace_selftest_function_regs();
699 ftrace_enabled = save_ftrace_enabled;
701 /* kill ftrace totally if we failed */
707 #endif /* CONFIG_FUNCTION_TRACER */
710 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
712 /* Maximum number of functions to trace before diagnosing a hang */
713 #define GRAPH_MAX_FUNC_TEST 100000000
716 __ftrace_dump(bool disable_tracing, enum ftrace_dump_mode oops_dump_mode);
717 static unsigned int graph_hang_thresh;
719 /* Wrap the real function entry probe to avoid possible hanging */
720 static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace)
722 /* This is harmlessly racy, we want to approximately detect a hang */
723 if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) {
725 printk(KERN_WARNING "BUG: Function graph tracer hang!\n");
726 if (ftrace_dump_on_oops)
727 __ftrace_dump(false, DUMP_ALL);
731 return trace_graph_entry(trace);
735 * Pretty much the same than for the function tracer from which the selftest
739 trace_selftest_startup_function_graph(struct tracer *trace,
740 struct trace_array *tr)
746 * Simulate the init() callback but we attach a watchdog callback
747 * to detect and recover from possible hangs
749 tracing_reset_online_cpus(tr);
751 ret = register_ftrace_graph(&trace_graph_return,
752 &trace_graph_entry_watchdog);
754 warn_failed_init_tracer(trace, ret);
757 tracing_start_cmdline_record();
759 /* Sleep for a 1/10 of a second */
762 /* Have we just recovered from a hang? */
763 if (graph_hang_thresh > GRAPH_MAX_FUNC_TEST) {
764 tracing_selftest_disabled = true;
771 /* check the trace buffer */
772 ret = trace_test_buffer(tr, &count);
777 if (!ret && !count) {
778 printk(KERN_CONT ".. no entries found ..");
783 /* Don't test dynamic tracing, the function tracer already did */
786 /* Stop it if we failed */
792 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
795 #ifdef CONFIG_IRQSOFF_TRACER
797 trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
799 unsigned long save_max = tracing_max_latency;
803 /* start the tracing */
804 ret = tracer_init(trace, tr);
806 warn_failed_init_tracer(trace, ret);
810 /* reset the max latency */
811 tracing_max_latency = 0;
812 /* disable interrupts for a bit */
818 * Stop the tracer to avoid a warning subsequent
819 * to buffer flipping failure because tracing_stop()
820 * disables the tr and max buffers, making flipping impossible
821 * in case of parallels max irqs off latencies.
824 /* stop the tracing. */
826 /* check both trace buffers */
827 ret = trace_test_buffer(tr, NULL);
829 ret = trace_test_buffer(&max_tr, &count);
833 if (!ret && !count) {
834 printk(KERN_CONT ".. no entries found ..");
838 tracing_max_latency = save_max;
842 #endif /* CONFIG_IRQSOFF_TRACER */
844 #ifdef CONFIG_PREEMPT_TRACER
846 trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
848 unsigned long save_max = tracing_max_latency;
853 * Now that the big kernel lock is no longer preemptable,
854 * and this is called with the BKL held, it will always
855 * fail. If preemption is already disabled, simply
856 * pass the test. When the BKL is removed, or becomes
857 * preemptible again, we will once again test this,
860 if (preempt_count()) {
861 printk(KERN_CONT "can not test ... force ");
865 /* start the tracing */
866 ret = tracer_init(trace, tr);
868 warn_failed_init_tracer(trace, ret);
872 /* reset the max latency */
873 tracing_max_latency = 0;
874 /* disable preemption for a bit */
880 * Stop the tracer to avoid a warning subsequent
881 * to buffer flipping failure because tracing_stop()
882 * disables the tr and max buffers, making flipping impossible
883 * in case of parallels max preempt off latencies.
886 /* stop the tracing. */
888 /* check both trace buffers */
889 ret = trace_test_buffer(tr, NULL);
891 ret = trace_test_buffer(&max_tr, &count);
895 if (!ret && !count) {
896 printk(KERN_CONT ".. no entries found ..");
900 tracing_max_latency = save_max;
904 #endif /* CONFIG_PREEMPT_TRACER */
906 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
908 trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr)
910 unsigned long save_max = tracing_max_latency;
915 * Now that the big kernel lock is no longer preemptable,
916 * and this is called with the BKL held, it will always
917 * fail. If preemption is already disabled, simply
918 * pass the test. When the BKL is removed, or becomes
919 * preemptible again, we will once again test this,
922 if (preempt_count()) {
923 printk(KERN_CONT "can not test ... force ");
927 /* start the tracing */
928 ret = tracer_init(trace, tr);
930 warn_failed_init_tracer(trace, ret);
934 /* reset the max latency */
935 tracing_max_latency = 0;
937 /* disable preemption and interrupts for a bit */
942 /* reverse the order of preempt vs irqs */
946 * Stop the tracer to avoid a warning subsequent
947 * to buffer flipping failure because tracing_stop()
948 * disables the tr and max buffers, making flipping impossible
949 * in case of parallels max irqs/preempt off latencies.
952 /* stop the tracing. */
954 /* check both trace buffers */
955 ret = trace_test_buffer(tr, NULL);
959 ret = trace_test_buffer(&max_tr, &count);
963 if (!ret && !count) {
964 printk(KERN_CONT ".. no entries found ..");
969 /* do the test by disabling interrupts first this time */
970 tracing_max_latency = 0;
978 /* reverse the order of preempt vs irqs */
982 /* stop the tracing. */
984 /* check both trace buffers */
985 ret = trace_test_buffer(tr, NULL);
989 ret = trace_test_buffer(&max_tr, &count);
991 if (!ret && !count) {
992 printk(KERN_CONT ".. no entries found ..");
1001 tracing_max_latency = save_max;
1005 #endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */
1007 #ifdef CONFIG_NOP_TRACER
1009 trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
1011 /* What could possibly go wrong? */
1016 #ifdef CONFIG_SCHED_TRACER
1017 static int trace_wakeup_test_thread(void *data)
1019 /* Make this a RT thread, doesn't need to be too high */
1020 static const struct sched_param param = { .sched_priority = 5 };
1021 struct completion *x = data;
1023 sched_setscheduler(current, SCHED_FIFO, ¶m);
1025 /* Make it know we have a new prio */
1028 /* now go to sleep and let the test wake us up */
1029 set_current_state(TASK_INTERRUPTIBLE);
1034 /* we are awake, now wait to disappear */
1035 while (!kthread_should_stop()) {
1037 * This is an RT task, do short sleeps to let
1047 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
1049 unsigned long save_max = tracing_max_latency;
1050 struct task_struct *p;
1051 struct completion isrt;
1052 unsigned long count;
1055 init_completion(&isrt);
1057 /* create a high prio thread */
1058 p = kthread_run(trace_wakeup_test_thread, &isrt, "ftrace-test");
1060 printk(KERN_CONT "Failed to create ftrace wakeup test thread ");
1064 /* make sure the thread is running at an RT prio */
1065 wait_for_completion(&isrt);
1067 /* start the tracing */
1068 ret = tracer_init(trace, tr);
1070 warn_failed_init_tracer(trace, ret);
1074 /* reset the max latency */
1075 tracing_max_latency = 0;
1079 * Sleep to make sure the RT thread is asleep too.
1080 * On virtual machines we can't rely on timings,
1081 * but we want to make sure this test still works.
1086 init_completion(&isrt);
1090 /* Wait for the task to wake up */
1091 wait_for_completion(&isrt);
1093 /* stop the tracing. */
1095 /* check both trace buffers */
1096 ret = trace_test_buffer(tr, NULL);
1097 printk("ret = %d\n", ret);
1099 ret = trace_test_buffer(&max_tr, &count);
1105 tracing_max_latency = save_max;
1107 /* kill the thread */
1110 if (!ret && !count) {
1111 printk(KERN_CONT ".. no entries found ..");
1117 #endif /* CONFIG_SCHED_TRACER */
1119 #ifdef CONFIG_CONTEXT_SWITCH_TRACER
1121 trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr)
1123 unsigned long count;
1126 /* start the tracing */
1127 ret = tracer_init(trace, tr);
1129 warn_failed_init_tracer(trace, ret);
1133 /* Sleep for a 1/10 of a second */
1135 /* stop the tracing. */
1137 /* check the trace buffer */
1138 ret = trace_test_buffer(tr, &count);
1142 if (!ret && !count) {
1143 printk(KERN_CONT ".. no entries found ..");
1149 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */
1151 #ifdef CONFIG_BRANCH_TRACER
1153 trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
1155 unsigned long count;
1158 /* start the tracing */
1159 ret = tracer_init(trace, tr);
1161 warn_failed_init_tracer(trace, ret);
1165 /* Sleep for a 1/10 of a second */
1167 /* stop the tracing. */
1169 /* check the trace buffer */
1170 ret = trace_test_buffer(tr, &count);
1174 if (!ret && !count) {
1175 printk(KERN_CONT ".. no entries found ..");
1181 #endif /* CONFIG_BRANCH_TRACER */