1 /* Include in trace.c */
3 #include <linux/stringify.h>
4 #include <linux/kthread.h>
5 #include <linux/delay.h>
7 static inline int trace_valid_entry(struct trace_entry *entry)
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))) {
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 __raw_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 __raw_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 /* Test dynamic code modification and ftrace filters */
105 int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
106 struct trace_array *tr,
109 int save_ftrace_enabled = ftrace_enabled;
110 int save_tracer_enabled = tracer_enabled;
115 /* The ftrace test PASSED */
116 printk(KERN_CONT "PASSED\n");
117 pr_info("Testing dynamic ftrace: ");
119 /* enable tracing, and record the filter function */
123 /* passed in by parameter to fool gcc from optimizing */
127 * Some archs *cough*PowerPC*cough* add characters to the
128 * start of the function names. We simply put a '*' to
131 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
133 /* filter only on our function */
134 ftrace_set_filter(func_name, strlen(func_name), 1);
137 ret = tracer_init(trace, tr);
139 warn_failed_init_tracer(trace, ret);
143 /* Sleep for a 1/10 of a second */
146 /* we should have nothing in the buffer */
147 ret = trace_test_buffer(tr, &count);
153 printk(KERN_CONT ".. filter did not filter .. ");
157 /* call our function again */
163 /* stop the tracing. */
167 /* check the trace buffer */
168 ret = trace_test_buffer(tr, &count);
172 /* we should only have one item */
173 if (!ret && count != 1) {
174 printk(KERN_CONT ".. filter failed count=%ld ..", count);
180 ftrace_enabled = save_ftrace_enabled;
181 tracer_enabled = save_tracer_enabled;
183 /* Enable tracing on all functions again */
184 ftrace_set_filter(NULL, 0, 1);
189 # define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; })
190 #endif /* CONFIG_DYNAMIC_FTRACE */
192 * Simple verification test of ftrace function tracer.
193 * Enable ftrace, sleep 1/10 second, and then read the trace
194 * buffer to see if all is in order.
197 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
199 int save_ftrace_enabled = ftrace_enabled;
200 int save_tracer_enabled = tracer_enabled;
204 /* make sure msleep has been recorded */
207 /* start the tracing */
211 ret = tracer_init(trace, tr);
213 warn_failed_init_tracer(trace, ret);
217 /* Sleep for a 1/10 of a second */
219 /* stop the tracing. */
223 /* check the trace buffer */
224 ret = trace_test_buffer(tr, &count);
228 if (!ret && !count) {
229 printk(KERN_CONT ".. no entries found ..");
234 ret = trace_selftest_startup_dynamic_tracing(trace, tr,
235 DYN_FTRACE_TEST_NAME);
238 ftrace_enabled = save_ftrace_enabled;
239 tracer_enabled = save_tracer_enabled;
241 /* kill ftrace totally if we failed */
247 #endif /* CONFIG_FUNCTION_TRACER */
250 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
252 * Pretty much the same than for the function tracer from which the selftest
256 trace_selftest_startup_function_graph(struct tracer *trace,
257 struct trace_array *tr)
262 ret = tracer_init(trace, tr);
264 warn_failed_init_tracer(trace, ret);
268 /* Sleep for a 1/10 of a second */
273 /* check the trace buffer */
274 ret = trace_test_buffer(tr, &count);
279 if (!ret && !count) {
280 printk(KERN_CONT ".. no entries found ..");
285 /* Don't test dynamic tracing, the function tracer already did */
288 /* Stop it if we failed */
294 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
297 #ifdef CONFIG_IRQSOFF_TRACER
299 trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
301 unsigned long save_max = tracing_max_latency;
305 /* start the tracing */
306 ret = tracer_init(trace, tr);
308 warn_failed_init_tracer(trace, ret);
312 /* reset the max latency */
313 tracing_max_latency = 0;
314 /* disable interrupts for a bit */
318 /* stop the tracing. */
320 /* check both trace buffers */
321 ret = trace_test_buffer(tr, NULL);
323 ret = trace_test_buffer(&max_tr, &count);
327 if (!ret && !count) {
328 printk(KERN_CONT ".. no entries found ..");
332 tracing_max_latency = save_max;
336 #endif /* CONFIG_IRQSOFF_TRACER */
338 #ifdef CONFIG_PREEMPT_TRACER
340 trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
342 unsigned long save_max = tracing_max_latency;
347 * Now that the big kernel lock is no longer preemptable,
348 * and this is called with the BKL held, it will always
349 * fail. If preemption is already disabled, simply
350 * pass the test. When the BKL is removed, or becomes
351 * preemptible again, we will once again test this,
354 if (preempt_count()) {
355 printk(KERN_CONT "can not test ... force ");
359 /* start the tracing */
360 ret = tracer_init(trace, tr);
362 warn_failed_init_tracer(trace, ret);
366 /* reset the max latency */
367 tracing_max_latency = 0;
368 /* disable preemption for a bit */
372 /* stop the tracing. */
374 /* check both trace buffers */
375 ret = trace_test_buffer(tr, NULL);
377 ret = trace_test_buffer(&max_tr, &count);
381 if (!ret && !count) {
382 printk(KERN_CONT ".. no entries found ..");
386 tracing_max_latency = save_max;
390 #endif /* CONFIG_PREEMPT_TRACER */
392 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
394 trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr)
396 unsigned long save_max = tracing_max_latency;
401 * Now that the big kernel lock is no longer preemptable,
402 * and this is called with the BKL held, it will always
403 * fail. If preemption is already disabled, simply
404 * pass the test. When the BKL is removed, or becomes
405 * preemptible again, we will once again test this,
408 if (preempt_count()) {
409 printk(KERN_CONT "can not test ... force ");
413 /* start the tracing */
414 ret = tracer_init(trace, tr);
416 warn_failed_init_tracer(trace, ret);
420 /* reset the max latency */
421 tracing_max_latency = 0;
423 /* disable preemption and interrupts for a bit */
428 /* reverse the order of preempt vs irqs */
431 /* stop the tracing. */
433 /* check both trace buffers */
434 ret = trace_test_buffer(tr, NULL);
440 ret = trace_test_buffer(&max_tr, &count);
446 if (!ret && !count) {
447 printk(KERN_CONT ".. no entries found ..");
453 /* do the test by disabling interrupts first this time */
454 tracing_max_latency = 0;
460 /* reverse the order of preempt vs irqs */
463 /* stop the tracing. */
465 /* check both trace buffers */
466 ret = trace_test_buffer(tr, NULL);
470 ret = trace_test_buffer(&max_tr, &count);
472 if (!ret && !count) {
473 printk(KERN_CONT ".. no entries found ..");
481 tracing_max_latency = save_max;
485 #endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */
487 #ifdef CONFIG_NOP_TRACER
489 trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
491 /* What could possibly go wrong? */
496 #ifdef CONFIG_SCHED_TRACER
497 static int trace_wakeup_test_thread(void *data)
499 /* Make this a RT thread, doesn't need to be too high */
500 struct sched_param param = { .sched_priority = 5 };
501 struct completion *x = data;
503 sched_setscheduler(current, SCHED_FIFO, ¶m);
505 /* Make it know we have a new prio */
508 /* now go to sleep and let the test wake us up */
509 set_current_state(TASK_INTERRUPTIBLE);
512 /* we are awake, now wait to disappear */
513 while (!kthread_should_stop()) {
515 * This is an RT task, do short sleeps to let
525 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
527 unsigned long save_max = tracing_max_latency;
528 struct task_struct *p;
529 struct completion isrt;
533 init_completion(&isrt);
535 /* create a high prio thread */
536 p = kthread_run(trace_wakeup_test_thread, &isrt, "ftrace-test");
538 printk(KERN_CONT "Failed to create ftrace wakeup test thread ");
542 /* make sure the thread is running at an RT prio */
543 wait_for_completion(&isrt);
545 /* start the tracing */
546 ret = tracer_init(trace, tr);
548 warn_failed_init_tracer(trace, ret);
552 /* reset the max latency */
553 tracing_max_latency = 0;
555 /* sleep to let the RT thread sleep too */
559 * Yes this is slightly racy. It is possible that for some
560 * strange reason that the RT thread we created, did not
561 * call schedule for 100ms after doing the completion,
562 * and we do a wakeup on a task that already is awake.
563 * But that is extremely unlikely, and the worst thing that
564 * happens in such a case, is that we disable tracing.
565 * Honestly, if this race does happen something is horrible
566 * wrong with the system.
571 /* give a little time to let the thread wake up */
574 /* stop the tracing. */
576 /* check both trace buffers */
577 ret = trace_test_buffer(tr, NULL);
579 ret = trace_test_buffer(&max_tr, &count);
585 tracing_max_latency = save_max;
587 /* kill the thread */
590 if (!ret && !count) {
591 printk(KERN_CONT ".. no entries found ..");
597 #endif /* CONFIG_SCHED_TRACER */
599 #ifdef CONFIG_CONTEXT_SWITCH_TRACER
601 trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr)
606 /* start the tracing */
607 ret = tracer_init(trace, tr);
609 warn_failed_init_tracer(trace, ret);
613 /* Sleep for a 1/10 of a second */
615 /* stop the tracing. */
617 /* check the trace buffer */
618 ret = trace_test_buffer(tr, &count);
622 if (!ret && !count) {
623 printk(KERN_CONT ".. no entries found ..");
629 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */
631 #ifdef CONFIG_SYSPROF_TRACER
633 trace_selftest_startup_sysprof(struct tracer *trace, struct trace_array *tr)
638 /* start the tracing */
639 ret = tracer_init(trace, tr);
641 warn_failed_init_tracer(trace, ret);
645 /* Sleep for a 1/10 of a second */
647 /* stop the tracing. */
649 /* check the trace buffer */
650 ret = trace_test_buffer(tr, &count);
654 if (!ret && !count) {
655 printk(KERN_CONT ".. no entries found ..");
661 #endif /* CONFIG_SYSPROF_TRACER */
663 #ifdef CONFIG_BRANCH_TRACER
665 trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
670 /* start the tracing */
671 ret = tracer_init(trace, tr);
673 warn_failed_init_tracer(trace, ret);
677 /* Sleep for a 1/10 of a second */
679 /* stop the tracing. */
681 /* check the trace buffer */
682 ret = trace_test_buffer(tr, &count);
686 if (!ret && !count) {
687 printk(KERN_CONT ".. no entries found ..");
693 #endif /* CONFIG_BRANCH_TRACER */