projects/linux·blob master · refs

1567 lines · 34.3 KiB

1// SPDX-License-Identifier: GPL-2.0
2/* Include in trace.c */
3
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>
9
10static inline int trace_valid_entry(struct trace_entry *entry)
11{
12 switch (entry->type) {
13 case TRACE_FN:
14 case TRACE_CTX:
15 case TRACE_WAKE:
16 case TRACE_STACK:
17 case TRACE_PRINT:
18 case TRACE_BRANCH:
19 case TRACE_GRAPH_ENT:
20 case TRACE_GRAPH_RETADDR_ENT:
21 case TRACE_GRAPH_RET:
22 return 1;
23 }
24 return 0;
25}
26
27static int trace_test_buffer_cpu(struct array_buffer *buf, int cpu)
28{
29 struct ring_buffer_event *event;
30 struct trace_entry *entry;
31 unsigned int loops = 0;
32
33 while ((event = ring_buffer_consume(buf->buffer, cpu, NULL, NULL))) {
34 entry = ring_buffer_event_data(event);
35
36 /*
37 * The ring buffer is a size of trace_buf_size, if
38 * we loop more than the size, there's something wrong
39 * with the ring buffer.
40 */
41 if (loops++ > trace_buf_size) {
42 printk(KERN_CONT ".. bad ring buffer ");
43 goto failed;
44 }
45 if (!trace_valid_entry(entry)) {
46 printk(KERN_CONT ".. invalid entry %d ",
47 entry->type);
48 goto failed;
49 }
50 }
51 return 0;
52
53 failed:
54 /* disable tracing */
55 tracing_disabled = 1;
56 printk(KERN_CONT ".. corrupted trace buffer .. ");
57 return -1;
58}
59
60/*
61 * Test the trace buffer to see if all the elements
62 * are still sane.
63 */
64static int __maybe_unused trace_test_buffer(struct array_buffer *buf, unsigned long *count)
65{
66 unsigned long flags, cnt = 0;
67 int cpu, ret = 0;
68
69 /* Don't allow flipping of max traces now */
70 local_irq_save(flags);
71 arch_spin_lock(&buf->tr->max_lock);
72
73 cnt = ring_buffer_entries(buf->buffer);
74
75 /*
76 * The trace_test_buffer_cpu runs a while loop to consume all data.
77 * If the calling tracer is broken, and is constantly filling
78 * the buffer, this will run forever, and hard lock the box.
79 * We disable the ring buffer while we do this test to prevent
80 * a hard lock up.
81 */
82 tracing_off();
83 for_each_possible_cpu(cpu) {
84 ret = trace_test_buffer_cpu(buf, cpu);
85 if (ret)
86 break;
87 }
88 tracing_on();
89 arch_spin_unlock(&buf->tr->max_lock);
90 local_irq_restore(flags);
91
92 if (count)
93 *count = cnt;
94
95 return ret;
96}
97
98static inline void warn_failed_init_tracer(struct tracer *trace, int init_ret)
99{
100 printk(KERN_WARNING "Failed to init %s tracer, init returned %d\n",
101 trace->name, init_ret);
102}
103#ifdef CONFIG_FUNCTION_TRACER
104
105#ifdef CONFIG_DYNAMIC_FTRACE
106
107static int trace_selftest_test_probe1_cnt;
108static void trace_selftest_test_probe1_func(unsigned long ip,
109 unsigned long pip,
110 struct ftrace_ops *op,
111 struct ftrace_regs *fregs)
112{
113 trace_selftest_test_probe1_cnt++;
114}
115
116static int trace_selftest_test_probe2_cnt;
117static void trace_selftest_test_probe2_func(unsigned long ip,
118 unsigned long pip,
119 struct ftrace_ops *op,
120 struct ftrace_regs *fregs)
121{
122 trace_selftest_test_probe2_cnt++;
123}
124
125static int trace_selftest_test_probe3_cnt;
126static void trace_selftest_test_probe3_func(unsigned long ip,
127 unsigned long pip,
128 struct ftrace_ops *op,
129 struct ftrace_regs *fregs)
130{
131 trace_selftest_test_probe3_cnt++;
132}
133
134static int trace_selftest_test_global_cnt;
135static void trace_selftest_test_global_func(unsigned long ip,
136 unsigned long pip,
137 struct ftrace_ops *op,
138 struct ftrace_regs *fregs)
139{
140 trace_selftest_test_global_cnt++;
141}
142
143static int trace_selftest_test_dyn_cnt;
144static void trace_selftest_test_dyn_func(unsigned long ip,
145 unsigned long pip,
146 struct ftrace_ops *op,
147 struct ftrace_regs *fregs)
148{
149 trace_selftest_test_dyn_cnt++;
150}
151
152static struct ftrace_ops test_probe1 = {
153 .func = trace_selftest_test_probe1_func,
154};
155
156static struct ftrace_ops test_probe2 = {
157 .func = trace_selftest_test_probe2_func,
158};
159
160static struct ftrace_ops test_probe3 = {
161 .func = trace_selftest_test_probe3_func,
162};
163
164static 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
174static 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
183static 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_obj(*dyn_ops);
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_free;
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 /* Remove trace function from probe 3 */
292 func1_name = "!" __stringify(DYN_FTRACE_TEST_NAME);
293 len1 = strlen(func1_name);
294
295 ftrace_set_filter(&test_probe3, func1_name, len1, 0);
296
297 DYN_FTRACE_TEST_NAME();
298
299 print_counts();
300
301 if (trace_selftest_test_probe1_cnt != 3)
302 goto out_free;
303 if (trace_selftest_test_probe2_cnt != 2)
304 goto out_free;
305 if (trace_selftest_test_probe3_cnt != 4)
306 goto out_free;
307 if (cnt > 1) {
308 if (trace_selftest_test_global_cnt == 0)
309 goto out_free;
310 }
311 if (trace_selftest_test_dyn_cnt == 0)
312 goto out_free;
313
314 DYN_FTRACE_TEST_NAME2();
315
316 print_counts();
317
318 if (trace_selftest_test_probe1_cnt != 3)
319 goto out_free;
320 if (trace_selftest_test_probe2_cnt != 3)
321 goto out_free;
322 if (trace_selftest_test_probe3_cnt != 5)
323 goto out_free;
324
325 ret = 0;
326 out_free:
327 unregister_ftrace_function(dyn_ops);
328 kfree(dyn_ops);
329
330 out:
331 /* Purposely unregister in the same order */
332 unregister_ftrace_function(&test_probe1);
333 unregister_ftrace_function(&test_probe2);
334 unregister_ftrace_function(&test_probe3);
335 if (cnt > 1)
336 unregister_ftrace_function(tr->ops);
337 ftrace_reset_array_ops(tr);
338
339 /* Make sure everything is off */
340 reset_counts();
341 DYN_FTRACE_TEST_NAME();
342 DYN_FTRACE_TEST_NAME();
343
344 if (trace_selftest_test_probe1_cnt ||
345 trace_selftest_test_probe2_cnt ||
346 trace_selftest_test_probe3_cnt ||
347 trace_selftest_test_global_cnt ||
348 trace_selftest_test_dyn_cnt)
349 ret = -1;
350
351 ftrace_enabled = save_ftrace_enabled;
352
353 return ret;
354}
355
356/* Test dynamic code modification and ftrace filters */
357static int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
358 struct trace_array *tr,
359 int (*func)(void))
360{
361 int save_ftrace_enabled = ftrace_enabled;
362 unsigned long count;
363 char *func_name;
364 int ret;
365
366 /* The ftrace test PASSED */
367 printk(KERN_CONT "PASSED\n");
368 pr_info("Testing dynamic ftrace: ");
369
370 /* enable tracing, and record the filter function */
371 ftrace_enabled = 1;
372
373 /* passed in by parameter to fool gcc from optimizing */
374 func();
375
376 /*
377 * Some archs *cough*PowerPC*cough* add characters to the
378 * start of the function names. We simply put a '*' to
379 * accommodate them.
380 */
381 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
382
383 /* filter only on our function */
384 ftrace_set_global_filter(func_name, strlen(func_name), 1);
385
386 /* enable tracing */
387 ret = tracer_init(trace, tr);
388 if (ret) {
389 warn_failed_init_tracer(trace, ret);
390 goto out;
391 }
392
393 /* Sleep for a 1/10 of a second */
394 msleep(100);
395
396 /* we should have nothing in the buffer */
397 ret = trace_test_buffer(&tr->array_buffer, &count);
398 if (ret)
399 goto out;
400
401 if (count) {
402 ret = -1;
403 printk(KERN_CONT ".. filter did not filter .. ");
404 goto out;
405 }
406
407 /* call our function again */
408 func();
409
410 /* sleep again */
411 msleep(100);
412
413 /* stop the tracing. */
414 tracing_stop();
415 ftrace_enabled = 0;
416
417 /* check the trace buffer */
418 ret = trace_test_buffer(&tr->array_buffer, &count);
419
420 ftrace_enabled = 1;
421 tracing_start();
422
423 /* we should only have one item */
424 if (!ret && count != 1) {
425 trace->reset(tr);
426 printk(KERN_CONT ".. filter failed count=%ld ..", count);
427 ret = -1;
428 goto out;
429 }
430
431 /* Test the ops with global tracing running */
432 ret = trace_selftest_ops(tr, 1);
433 trace->reset(tr);
434
435 out:
436 ftrace_enabled = save_ftrace_enabled;
437
438 /* Enable tracing on all functions again */
439 ftrace_set_global_filter(NULL, 0, 1);
440
441 /* Test the ops with global tracing off */
442 if (!ret)
443 ret = trace_selftest_ops(tr, 2);
444
445 return ret;
446}
447
448static int trace_selftest_recursion_cnt;
449static void trace_selftest_test_recursion_func(unsigned long ip,
450 unsigned long pip,
451 struct ftrace_ops *op,
452 struct ftrace_regs *fregs)
453{
454 /*
455 * This function is registered without the recursion safe flag.
456 * The ftrace infrastructure should provide the recursion
457 * protection. If not, this will crash the kernel!
458 */
459 if (trace_selftest_recursion_cnt++ > 10)
460 return;
461 DYN_FTRACE_TEST_NAME();
462}
463
464static void trace_selftest_test_recursion_safe_func(unsigned long ip,
465 unsigned long pip,
466 struct ftrace_ops *op,
467 struct ftrace_regs *fregs)
468{
469 /*
470 * We said we would provide our own recursion. By calling
471 * this function again, we should recurse back into this function
472 * and count again. But this only happens if the arch supports
473 * all of ftrace features and nothing else is using the function
474 * tracing utility.
475 */
476 if (trace_selftest_recursion_cnt++)
477 return;
478 DYN_FTRACE_TEST_NAME();
479}
480
481static struct ftrace_ops test_rec_probe = {
482 .func = trace_selftest_test_recursion_func,
483 .flags = FTRACE_OPS_FL_RECURSION,
484};
485
486static struct ftrace_ops test_recsafe_probe = {
487 .func = trace_selftest_test_recursion_safe_func,
488};
489
490static int
491trace_selftest_function_recursion(void)
492{
493 int save_ftrace_enabled = ftrace_enabled;
494 char *func_name;
495 int len;
496 int ret;
497
498 /* The previous test PASSED */
499 pr_cont("PASSED\n");
500 pr_info("Testing ftrace recursion: ");
501
502
503 /* enable tracing, and record the filter function */
504 ftrace_enabled = 1;
505
506 /* Handle PPC64 '.' name */
507 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
508 len = strlen(func_name);
509
510 ret = ftrace_set_filter(&test_rec_probe, func_name, len, 1);
511 if (ret) {
512 pr_cont("*Could not set filter* ");
513 goto out;
514 }
515
516 ret = register_ftrace_function(&test_rec_probe);
517 if (ret) {
518 pr_cont("*could not register callback* ");
519 goto out;
520 }
521
522 DYN_FTRACE_TEST_NAME();
523
524 unregister_ftrace_function(&test_rec_probe);
525
526 ret = -1;
527 /*
528 * Recursion allows for transitions between context,
529 * and may call the callback twice.
530 */
531 if (trace_selftest_recursion_cnt != 1 &&
532 trace_selftest_recursion_cnt != 2) {
533 pr_cont("*callback not called once (or twice) (%d)* ",
534 trace_selftest_recursion_cnt);
535 goto out;
536 }
537
538 trace_selftest_recursion_cnt = 1;
539
540 pr_cont("PASSED\n");
541 pr_info("Testing ftrace recursion safe: ");
542
543 ret = ftrace_set_filter(&test_recsafe_probe, func_name, len, 1);
544 if (ret) {
545 pr_cont("*Could not set filter* ");
546 goto out;
547 }
548
549 ret = register_ftrace_function(&test_recsafe_probe);
550 if (ret) {
551 pr_cont("*could not register callback* ");
552 goto out;
553 }
554
555 DYN_FTRACE_TEST_NAME();
556
557 unregister_ftrace_function(&test_recsafe_probe);
558
559 ret = -1;
560 if (trace_selftest_recursion_cnt != 2) {
561 pr_cont("*callback not called expected 2 times (%d)* ",
562 trace_selftest_recursion_cnt);
563 goto out;
564 }
565
566 ret = 0;
567out:
568 ftrace_enabled = save_ftrace_enabled;
569
570 return ret;
571}
572#else
573# define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; })
574# define trace_selftest_function_recursion() ({ 0; })
575#endif /* CONFIG_DYNAMIC_FTRACE */
576
577static enum {
578 TRACE_SELFTEST_REGS_START,
579 TRACE_SELFTEST_REGS_FOUND,
580 TRACE_SELFTEST_REGS_NOT_FOUND,
581} trace_selftest_regs_stat;
582
583static void trace_selftest_test_regs_func(unsigned long ip,
584 unsigned long pip,
585 struct ftrace_ops *op,
586 struct ftrace_regs *fregs)
587{
588 struct pt_regs *regs = ftrace_get_regs(fregs);
589
590 if (regs)
591 trace_selftest_regs_stat = TRACE_SELFTEST_REGS_FOUND;
592 else
593 trace_selftest_regs_stat = TRACE_SELFTEST_REGS_NOT_FOUND;
594}
595
596static struct ftrace_ops test_regs_probe = {
597 .func = trace_selftest_test_regs_func,
598 .flags = FTRACE_OPS_FL_SAVE_REGS,
599};
600
601static int
602trace_selftest_function_regs(void)
603{
604 int save_ftrace_enabled = ftrace_enabled;
605 char *func_name;
606 int len;
607 int ret;
608 int supported = 0;
609
610#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
611 supported = 1;
612#endif
613
614 /* The previous test PASSED */
615 pr_cont("PASSED\n");
616 pr_info("Testing ftrace regs%s: ",
617 !supported ? "(no arch support)" : "");
618
619 /* enable tracing, and record the filter function */
620 ftrace_enabled = 1;
621
622 /* Handle PPC64 '.' name */
623 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
624 len = strlen(func_name);
625
626 ret = ftrace_set_filter(&test_regs_probe, func_name, len, 1);
627 /*
628 * If DYNAMIC_FTRACE is not set, then we just trace all functions.
629 * This test really doesn't care.
630 */
631 if (ret && ret != -ENODEV) {
632 pr_cont("*Could not set filter* ");
633 goto out;
634 }
635
636 ret = register_ftrace_function(&test_regs_probe);
637 /*
638 * Now if the arch does not support passing regs, then this should
639 * have failed.
640 */
641 if (!supported) {
642 if (!ret) {
643 pr_cont("*registered save-regs without arch support* ");
644 goto out;
645 }
646 test_regs_probe.flags |= FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED;
647 ret = register_ftrace_function(&test_regs_probe);
648 }
649 if (ret) {
650 pr_cont("*could not register callback* ");
651 goto out;
652 }
653
654
655 DYN_FTRACE_TEST_NAME();
656
657 unregister_ftrace_function(&test_regs_probe);
658
659 ret = -1;
660
661 switch (trace_selftest_regs_stat) {
662 case TRACE_SELFTEST_REGS_START:
663 pr_cont("*callback never called* ");
664 goto out;
665
666 case TRACE_SELFTEST_REGS_FOUND:
667 if (supported)
668 break;
669 pr_cont("*callback received regs without arch support* ");
670 goto out;
671
672 case TRACE_SELFTEST_REGS_NOT_FOUND:
673 if (!supported)
674 break;
675 pr_cont("*callback received NULL regs* ");
676 goto out;
677 }
678
679 ret = 0;
680out:
681 ftrace_enabled = save_ftrace_enabled;
682
683 return ret;
684}
685
686/*
687 * Simple verification test of ftrace function tracer.
688 * Enable ftrace, sleep 1/10 second, and then read the trace
689 * buffer to see if all is in order.
690 */
691__init int
692trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
693{
694 int save_ftrace_enabled = ftrace_enabled;
695 unsigned long count;
696 int ret;
697
698#ifdef CONFIG_DYNAMIC_FTRACE
699 if (ftrace_filter_param) {
700 printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
701 return 0;
702 }
703#endif
704
705 /* make sure msleep has been recorded */
706 msleep(1);
707
708 /* start the tracing */
709 ftrace_enabled = 1;
710
711 ret = tracer_init(trace, tr);
712 if (ret) {
713 warn_failed_init_tracer(trace, ret);
714 goto out;
715 }
716
717 /* Sleep for a 1/10 of a second */
718 msleep(100);
719 /* stop the tracing. */
720 tracing_stop();
721 ftrace_enabled = 0;
722
723 /* check the trace buffer */
724 ret = trace_test_buffer(&tr->array_buffer, &count);
725
726 ftrace_enabled = 1;
727 trace->reset(tr);
728 tracing_start();
729
730 if (!ret && !count) {
731 printk(KERN_CONT ".. no entries found ..");
732 ret = -1;
733 goto out;
734 }
735
736 ret = trace_selftest_startup_dynamic_tracing(trace, tr,
737 DYN_FTRACE_TEST_NAME);
738 if (ret)
739 goto out;
740
741 ret = trace_selftest_function_recursion();
742 if (ret)
743 goto out;
744
745 ret = trace_selftest_function_regs();
746 out:
747 ftrace_enabled = save_ftrace_enabled;
748
749 /* kill ftrace totally if we failed */
750 if (ret)
751 ftrace_kill();
752
753 return ret;
754}
755#endif /* CONFIG_FUNCTION_TRACER */
756
757
758#ifdef CONFIG_FUNCTION_GRAPH_TRACER
759
760#ifdef CONFIG_DYNAMIC_FTRACE
761
762#define CHAR_NUMBER 123
763#define SHORT_NUMBER 12345
764#define WORD_NUMBER 1234567890
765#define LONG_NUMBER 1234567890123456789LL
766#define ERRSTR_BUFLEN 128
767
768struct fgraph_fixture {
769 struct fgraph_ops gops;
770 int store_size;
771 const char *store_type_name;
772 char error_str_buf[ERRSTR_BUFLEN];
773 char *error_str;
774};
775
776static __init int store_entry(struct ftrace_graph_ent *trace,
777 struct fgraph_ops *gops,
778 struct ftrace_regs *fregs)
779{
780 struct fgraph_fixture *fixture = container_of(gops, struct fgraph_fixture, gops);
781 const char *type = fixture->store_type_name;
782 int size = fixture->store_size;
783 void *p;
784
785 p = fgraph_reserve_data(gops->idx, size);
786 if (!p) {
787 snprintf(fixture->error_str_buf, ERRSTR_BUFLEN,
788 "Failed to reserve %s\n", type);
789 return 0;
790 }
791
792 switch (size) {
793 case 1:
794 *(char *)p = CHAR_NUMBER;
795 break;
796 case 2:
797 *(short *)p = SHORT_NUMBER;
798 break;
799 case 4:
800 *(int *)p = WORD_NUMBER;
801 break;
802 case 8:
803 *(long long *)p = LONG_NUMBER;
804 break;
805 }
806
807 return 1;
808}
809
810static __init void store_return(struct ftrace_graph_ret *trace,
811 struct fgraph_ops *gops,
812 struct ftrace_regs *fregs)
813{
814 struct fgraph_fixture *fixture = container_of(gops, struct fgraph_fixture, gops);
815 const char *type = fixture->store_type_name;
816 long long expect = 0;
817 long long found = -1;
818 int size;
819 char *p;
820
821 p = fgraph_retrieve_data(gops->idx, &size);
822 if (!p) {
823 snprintf(fixture->error_str_buf, ERRSTR_BUFLEN,
824 "Failed to retrieve %s\n", type);
825 return;
826 }
827 if (fixture->store_size > size) {
828 snprintf(fixture->error_str_buf, ERRSTR_BUFLEN,
829 "Retrieved size %d is smaller than expected %d\n",
830 size, (int)fixture->store_size);
831 return;
832 }
833
834 switch (fixture->store_size) {
835 case 1:
836 expect = CHAR_NUMBER;
837 found = *(char *)p;
838 break;
839 case 2:
840 expect = SHORT_NUMBER;
841 found = *(short *)p;
842 break;
843 case 4:
844 expect = WORD_NUMBER;
845 found = *(int *)p;
846 break;
847 case 8:
848 expect = LONG_NUMBER;
849 found = *(long long *)p;
850 break;
851 }
852
853 if (found != expect) {
854 snprintf(fixture->error_str_buf, ERRSTR_BUFLEN,
855 "%s returned not %lld but %lld\n", type, expect, found);
856 return;
857 }
858 fixture->error_str = NULL;
859}
860
861static int __init init_fgraph_fixture(struct fgraph_fixture *fixture)
862{
863 char *func_name;
864 int len;
865
866 snprintf(fixture->error_str_buf, ERRSTR_BUFLEN,
867 "Failed to execute storage %s\n", fixture->store_type_name);
868 fixture->error_str = fixture->error_str_buf;
869
870 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
871 len = strlen(func_name);
872
873 return ftrace_set_filter(&fixture->gops.ops, func_name, len, 1);
874}
875
876/* Test fgraph storage for each size */
877static int __init test_graph_storage_single(struct fgraph_fixture *fixture)
878{
879 int size = fixture->store_size;
880 int ret;
881
882 pr_cont("PASSED\n");
883 pr_info("Testing fgraph storage of %d byte%s: ", size, str_plural(size));
884
885 ret = init_fgraph_fixture(fixture);
886 if (ret && ret != -ENODEV) {
887 pr_cont("*Could not set filter* ");
888 return -1;
889 }
890
891 ret = register_ftrace_graph(&fixture->gops);
892 if (ret) {
893 pr_warn("Failed to init store_bytes fgraph tracing\n");
894 return -1;
895 }
896
897 DYN_FTRACE_TEST_NAME();
898
899 unregister_ftrace_graph(&fixture->gops);
900
901 if (fixture->error_str) {
902 pr_cont("*** %s ***", fixture->error_str);
903 return -1;
904 }
905
906 return 0;
907}
908
909static struct fgraph_fixture store_bytes[4] __initdata = {
910 [0] = {
911 .gops = {
912 .entryfunc = store_entry,
913 .retfunc = store_return,
914 },
915 .store_size = 1,
916 .store_type_name = "byte",
917 },
918 [1] = {
919 .gops = {
920 .entryfunc = store_entry,
921 .retfunc = store_return,
922 },
923 .store_size = 2,
924 .store_type_name = "short",
925 },
926 [2] = {
927 .gops = {
928 .entryfunc = store_entry,
929 .retfunc = store_return,
930 },
931 .store_size = 4,
932 .store_type_name = "word",
933 },
934 [3] = {
935 .gops = {
936 .entryfunc = store_entry,
937 .retfunc = store_return,
938 },
939 .store_size = 8,
940 .store_type_name = "long long",
941 },
942};
943
944static __init int test_graph_storage_multi(void)
945{
946 struct fgraph_fixture *fixture;
947 bool printed = false;
948 int i, j, ret;
949
950 pr_cont("PASSED\n");
951 pr_info("Testing multiple fgraph storage on a function: ");
952
953 for (i = 0; i < ARRAY_SIZE(store_bytes); i++) {
954 fixture = &store_bytes[i];
955 ret = init_fgraph_fixture(fixture);
956 if (ret && ret != -ENODEV) {
957 pr_cont("*Could not set filter* ");
958 printed = true;
959 goto out2;
960 }
961 }
962
963 for (j = 0; j < ARRAY_SIZE(store_bytes); j++) {
964 fixture = &store_bytes[j];
965 ret = register_ftrace_graph(&fixture->gops);
966 if (ret) {
967 pr_warn("Failed to init store_bytes fgraph tracing\n");
968 printed = true;
969 goto out1;
970 }
971 }
972
973 DYN_FTRACE_TEST_NAME();
974out1:
975 while (--j >= 0) {
976 fixture = &store_bytes[j];
977 unregister_ftrace_graph(&fixture->gops);
978
979 if (fixture->error_str && !printed) {
980 pr_cont("*** %s ***", fixture->error_str);
981 printed = true;
982 }
983 }
984out2:
985 while (--i >= 0) {
986 fixture = &store_bytes[i];
987 ftrace_free_filter(&fixture->gops.ops);
988
989 if (fixture->error_str && !printed) {
990 pr_cont("*** %s ***", fixture->error_str);
991 printed = true;
992 }
993 }
994 return printed ? -1 : 0;
995}
996
997/* Test the storage passed across function_graph entry and return */
998static __init int test_graph_storage(void)
999{
1000 int ret;
1001
1002 ret = test_graph_storage_single(&store_bytes[0]);
1003 if (ret)
1004 return ret;
1005 ret = test_graph_storage_single(&store_bytes[1]);
1006 if (ret)
1007 return ret;
1008 ret = test_graph_storage_single(&store_bytes[2]);
1009 if (ret)
1010 return ret;
1011 ret = test_graph_storage_single(&store_bytes[3]);
1012 if (ret)
1013 return ret;
1014 ret = test_graph_storage_multi();
1015 if (ret)
1016 return ret;
1017 return 0;
1018}
1019#else
1020static inline int test_graph_storage(void) { return 0; }
1021#endif /* CONFIG_DYNAMIC_FTRACE */
1022
1023/* Maximum number of functions to trace before diagnosing a hang */
1024#define GRAPH_MAX_FUNC_TEST 100000000
1025
1026static unsigned int graph_hang_thresh;
1027
1028/* Wrap the real function entry probe to avoid possible hanging */
1029static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace,
1030 struct fgraph_ops *gops,
1031 struct ftrace_regs *fregs)
1032{
1033 /* This is harmlessly racy, we want to approximately detect a hang */
1034 if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) {
1035 ftrace_graph_stop();
1036 printk(KERN_WARNING "BUG: Function graph tracer hang!\n");
1037 if (ftrace_dump_on_oops_enabled()) {
1038 ftrace_dump(DUMP_ALL);
1039 /* ftrace_dump() disables tracing */
1040 tracing_on();
1041 }
1042 return 0;
1043 }
1044
1045 return trace_graph_entry(trace, gops, fregs);
1046}
1047
1048static struct fgraph_ops fgraph_ops __initdata = {
1049 .entryfunc = &trace_graph_entry_watchdog,
1050 .retfunc = &trace_graph_return,
1051};
1052
1053#ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
1054static struct ftrace_ops direct;
1055#endif
1056
1057/*
1058 * Pretty much the same than for the function tracer from which the selftest
1059 * has been borrowed.
1060 */
1061__init int
1062trace_selftest_startup_function_graph(struct tracer *trace,
1063 struct trace_array *tr)
1064{
1065 int ret;
1066 unsigned long count;
1067 char *func_name __maybe_unused;
1068
1069#ifdef CONFIG_DYNAMIC_FTRACE
1070 if (ftrace_filter_param) {
1071 printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
1072 return 0;
1073 }
1074#endif
1075
1076 /*
1077 * Simulate the init() callback but we attach a watchdog callback
1078 * to detect and recover from possible hangs
1079 */
1080 tracing_reset_online_cpus(&tr->array_buffer);
1081 fgraph_ops.private = tr;
1082 ret = register_ftrace_graph(&fgraph_ops);
1083 if (ret) {
1084 warn_failed_init_tracer(trace, ret);
1085 goto out;
1086 }
1087 tracing_start_cmdline_record();
1088
1089 /* Sleep for a 1/10 of a second */
1090 msleep(100);
1091
1092 /* Have we just recovered from a hang? */
1093 if (graph_hang_thresh > GRAPH_MAX_FUNC_TEST) {
1094 disable_tracing_selftest("recovering from a hang");
1095 ret = -1;
1096 goto out;
1097 }
1098
1099 tracing_stop();
1100
1101 /* check the trace buffer */
1102 ret = trace_test_buffer(&tr->array_buffer, &count);
1103
1104 /* Need to also simulate the tr->reset to remove this fgraph_ops */
1105 tracing_stop_cmdline_record();
1106 unregister_ftrace_graph(&fgraph_ops);
1107
1108 tracing_start();
1109
1110 if (!ret && !count) {
1111 printk(KERN_CONT ".. no entries found ..");
1112 ret = -1;
1113 goto out;
1114 }
1115
1116#ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
1117 /*
1118 * These tests can take some time to run. Make sure on non PREEMPT
1119 * kernels, we do not trigger the softlockup detector.
1120 */
1121 cond_resched();
1122
1123 tracing_reset_online_cpus(&tr->array_buffer);
1124 fgraph_ops.private = tr;
1125
1126 /*
1127 * Some archs *cough*PowerPC*cough* add characters to the
1128 * start of the function names. We simply put a '*' to
1129 * accommodate them.
1130 */
1131 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
1132 ftrace_set_global_filter(func_name, strlen(func_name), 1);
1133
1134 /*
1135 * Register direct function together with graph tracer
1136 * and make sure we get graph trace.
1137 */
1138 ftrace_set_filter_ip(&direct, (unsigned long)DYN_FTRACE_TEST_NAME, 0, 0);
1139 ret = register_ftrace_direct(&direct,
1140 (unsigned long)ftrace_stub_direct_tramp);
1141 if (ret)
1142 goto out;
1143
1144 cond_resched();
1145
1146 ret = register_ftrace_graph(&fgraph_ops);
1147 if (ret) {
1148 warn_failed_init_tracer(trace, ret);
1149 goto out;
1150 }
1151
1152 DYN_FTRACE_TEST_NAME();
1153
1154 count = 0;
1155
1156 tracing_stop();
1157 /* check the trace buffer */
1158 ret = trace_test_buffer(&tr->array_buffer, &count);
1159
1160 unregister_ftrace_graph(&fgraph_ops);
1161
1162 ret = unregister_ftrace_direct(&direct,
1163 (unsigned long)ftrace_stub_direct_tramp,
1164 true);
1165 if (ret)
1166 goto out;
1167
1168 cond_resched();
1169
1170 tracing_start();
1171
1172 if (!ret && !count) {
1173 ret = -1;
1174 goto out;
1175 }
1176
1177 /* Enable tracing on all functions again */
1178 ftrace_set_global_filter(NULL, 0, 1);
1179#endif
1180
1181 ret = test_graph_storage();
1182
1183 /* Don't test dynamic tracing, the function tracer already did */
1184out:
1185 /* Stop it if we failed */
1186 if (ret)
1187 ftrace_graph_stop();
1188
1189 return ret;
1190}
1191#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
1192
1193
1194#ifdef CONFIG_IRQSOFF_TRACER
1195int
1196trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
1197{
1198 unsigned long save_max = tr->max_latency;
1199 unsigned long count;
1200 int ret;
1201
1202 /* start the tracing */
1203 ret = tracer_init(trace, tr);
1204 if (ret) {
1205 warn_failed_init_tracer(trace, ret);
1206 return ret;
1207 }
1208
1209 /* reset the max latency */
1210 tr->max_latency = 0;
1211 /* disable interrupts for a bit */
1212 local_irq_disable();
1213 udelay(100);
1214 local_irq_enable();
1215
1216 /*
1217 * Stop the tracer to avoid a warning subsequent
1218 * to buffer flipping failure because tracing_stop()
1219 * disables the tr and max buffers, making flipping impossible
1220 * in case of parallels max irqs off latencies.
1221 */
1222 trace->stop(tr);
1223 /* stop the tracing. */
1224 tracing_stop();
1225 /* check both trace buffers */
1226 ret = trace_test_buffer(&tr->array_buffer, NULL);
1227 if (!ret)
1228 ret = trace_test_buffer(&tr->snapshot_buffer, &count);
1229 trace->reset(tr);
1230 tracing_start();
1231
1232 if (!ret && !count) {
1233 printk(KERN_CONT ".. no entries found ..");
1234 ret = -1;
1235 }
1236
1237 tr->max_latency = save_max;
1238
1239 return ret;
1240}
1241#endif /* CONFIG_IRQSOFF_TRACER */
1242
1243#ifdef CONFIG_PREEMPT_TRACER
1244int
1245trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
1246{
1247 unsigned long save_max = tr->max_latency;
1248 unsigned long count;
1249 int ret;
1250
1251 /*
1252 * Now that the big kernel lock is no longer preemptible,
1253 * and this is called with the BKL held, it will always
1254 * fail. If preemption is already disabled, simply
1255 * pass the test. When the BKL is removed, or becomes
1256 * preemptible again, we will once again test this,
1257 * so keep it in.
1258 */
1259 if (preempt_count()) {
1260 printk(KERN_CONT "can not test ... force ");
1261 return 0;
1262 }
1263
1264 /* start the tracing */
1265 ret = tracer_init(trace, tr);
1266 if (ret) {
1267 warn_failed_init_tracer(trace, ret);
1268 return ret;
1269 }
1270
1271 /* reset the max latency */
1272 tr->max_latency = 0;
1273 /* disable preemption for a bit */
1274 preempt_disable();
1275 udelay(100);
1276 preempt_enable();
1277
1278 /*
1279 * Stop the tracer to avoid a warning subsequent
1280 * to buffer flipping failure because tracing_stop()
1281 * disables the tr and max buffers, making flipping impossible
1282 * in case of parallels max preempt off latencies.
1283 */
1284 trace->stop(tr);
1285 /* stop the tracing. */
1286 tracing_stop();
1287 /* check both trace buffers */
1288 ret = trace_test_buffer(&tr->array_buffer, NULL);
1289 if (!ret)
1290 ret = trace_test_buffer(&tr->snapshot_buffer, &count);
1291 trace->reset(tr);
1292 tracing_start();
1293
1294 if (!ret && !count) {
1295 printk(KERN_CONT ".. no entries found ..");
1296 ret = -1;
1297 }
1298
1299 tr->max_latency = save_max;
1300
1301 return ret;
1302}
1303#endif /* CONFIG_PREEMPT_TRACER */
1304
1305#if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
1306int
1307trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr)
1308{
1309 unsigned long save_max = tr->max_latency;
1310 unsigned long count;
1311 int ret;
1312
1313 /*
1314 * Now that the big kernel lock is no longer preemptible,
1315 * and this is called with the BKL held, it will always
1316 * fail. If preemption is already disabled, simply
1317 * pass the test. When the BKL is removed, or becomes
1318 * preemptible again, we will once again test this,
1319 * so keep it in.
1320 */
1321 if (preempt_count()) {
1322 printk(KERN_CONT "can not test ... force ");
1323 return 0;
1324 }
1325
1326 /* start the tracing */
1327 ret = tracer_init(trace, tr);
1328 if (ret) {
1329 warn_failed_init_tracer(trace, ret);
1330 goto out_no_start;
1331 }
1332
1333 /* reset the max latency */
1334 tr->max_latency = 0;
1335
1336 /* disable preemption and interrupts for a bit */
1337 preempt_disable();
1338 local_irq_disable();
1339 udelay(100);
1340 preempt_enable();
1341 /* reverse the order of preempt vs irqs */
1342 local_irq_enable();
1343
1344 /*
1345 * Stop the tracer to avoid a warning subsequent
1346 * to buffer flipping failure because tracing_stop()
1347 * disables the tr and max buffers, making flipping impossible
1348 * in case of parallels max irqs/preempt off latencies.
1349 */
1350 trace->stop(tr);
1351 /* stop the tracing. */
1352 tracing_stop();
1353 /* check both trace buffers */
1354 ret = trace_test_buffer(&tr->array_buffer, NULL);
1355 if (ret)
1356 goto out;
1357
1358 ret = trace_test_buffer(&tr->snapshot_buffer, &count);
1359 if (ret)
1360 goto out;
1361
1362 if (!ret && !count) {
1363 printk(KERN_CONT ".. no entries found ..");
1364 ret = -1;
1365 goto out;
1366 }
1367
1368 /* do the test by disabling interrupts first this time */
1369 tr->max_latency = 0;
1370 tracing_start();
1371 trace->start(tr);
1372
1373 preempt_disable();
1374 local_irq_disable();
1375 udelay(100);
1376 preempt_enable();
1377 /* reverse the order of preempt vs irqs */
1378 local_irq_enable();
1379
1380 trace->stop(tr);
1381 /* stop the tracing. */
1382 tracing_stop();
1383 /* check both trace buffers */
1384 ret = trace_test_buffer(&tr->array_buffer, NULL);
1385 if (ret)
1386 goto out;
1387
1388 ret = trace_test_buffer(&tr->snapshot_buffer, &count);
1389
1390 if (!ret && !count) {
1391 printk(KERN_CONT ".. no entries found ..");
1392 ret = -1;
1393 goto out;
1394 }
1395
1396out:
1397 tracing_start();
1398out_no_start:
1399 trace->reset(tr);
1400 tr->max_latency = save_max;
1401
1402 return ret;
1403}
1404#endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */
1405
1406#ifdef CONFIG_NOP_TRACER
1407int
1408trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
1409{
1410 /* What could possibly go wrong? */
1411 return 0;
1412}
1413#endif
1414
1415#ifdef CONFIG_SCHED_TRACER
1416
1417struct wakeup_test_data {
1418 struct completion is_ready;
1419 int go;
1420};
1421
1422static int trace_wakeup_test_thread(void *data)
1423{
1424 /* Make this a -deadline thread */
1425 static const struct sched_attr attr = {
1426 .sched_policy = SCHED_DEADLINE,
1427 .sched_runtime = 100000ULL,
1428 .sched_deadline = 10000000ULL,
1429 .sched_period = 10000000ULL
1430 };
1431 struct wakeup_test_data *x = data;
1432
1433 sched_setattr(current, &attr);
1434
1435 /* Make it know we have a new prio */
1436 complete(&x->is_ready);
1437
1438 /* now go to sleep and let the test wake us up */
1439 set_current_state(TASK_INTERRUPTIBLE);
1440 while (!x->go) {
1441 schedule();
1442 set_current_state(TASK_INTERRUPTIBLE);
1443 }
1444
1445 complete(&x->is_ready);
1446
1447 set_current_state(TASK_INTERRUPTIBLE);
1448
1449 /* we are awake, now wait to disappear */
1450 while (!kthread_should_stop()) {
1451 schedule();
1452 set_current_state(TASK_INTERRUPTIBLE);
1453 }
1454
1455 __set_current_state(TASK_RUNNING);
1456
1457 return 0;
1458}
1459int
1460trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
1461{
1462 unsigned long save_max = tr->max_latency;
1463 struct task_struct *p;
1464 struct wakeup_test_data data;
1465 unsigned long count;
1466 int ret;
1467
1468 memset(&data, 0, sizeof(data));
1469
1470 init_completion(&data.is_ready);
1471
1472 /* create a -deadline thread */
1473 p = kthread_run(trace_wakeup_test_thread, &data, "ftrace-test");
1474 if (IS_ERR(p)) {
1475 printk(KERN_CONT "Failed to create ftrace wakeup test thread ");
1476 return -1;
1477 }
1478
1479 /* make sure the thread is running at -deadline policy */
1480 wait_for_completion(&data.is_ready);
1481
1482 /* start the tracing */
1483 ret = tracer_init(trace, tr);
1484 if (ret) {
1485 warn_failed_init_tracer(trace, ret);
1486 return ret;
1487 }
1488
1489 /* reset the max latency */
1490 tr->max_latency = 0;
1491
1492 while (task_is_runnable(p)) {
1493 /*
1494 * Sleep to make sure the -deadline thread is asleep too.
1495 * On virtual machines we can't rely on timings,
1496 * but we want to make sure this test still works.
1497 */
1498 msleep(100);
1499 }
1500
1501 init_completion(&data.is_ready);
1502
1503 data.go = 1;
1504 /* memory barrier is in the wake_up_process() */
1505
1506 wake_up_process(p);
1507
1508 /* Wait for the task to wake up */
1509 wait_for_completion(&data.is_ready);
1510
1511 /* stop the tracing. */
1512 tracing_stop();
1513 /* check both trace buffers */
1514 ret = trace_test_buffer(&tr->array_buffer, NULL);
1515 if (!ret)
1516 ret = trace_test_buffer(&tr->snapshot_buffer, &count);
1517
1518
1519 trace->reset(tr);
1520 tracing_start();
1521
1522 tr->max_latency = save_max;
1523
1524 /* kill the thread */
1525 kthread_stop(p);
1526
1527 if (!ret && !count) {
1528 printk(KERN_CONT ".. no entries found ..");
1529 ret = -1;
1530 }
1531
1532 return ret;
1533}
1534#endif /* CONFIG_SCHED_TRACER */
1535
1536#ifdef CONFIG_BRANCH_TRACER
1537int
1538trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
1539{
1540 unsigned long count;
1541 int ret;
1542
1543 /* start the tracing */
1544 ret = tracer_init(trace, tr);
1545 if (ret) {
1546 warn_failed_init_tracer(trace, ret);
1547 return ret;
1548 }
1549
1550 /* Sleep for a 1/10 of a second */
1551 msleep(100);
1552 /* stop the tracing. */
1553 tracing_stop();
1554 /* check the trace buffer */
1555 ret = trace_test_buffer(&tr->array_buffer, &count);
1556 trace->reset(tr);
1557 tracing_start();
1558
1559 if (!ret && !count) {
1560 printk(KERN_CONT ".. no entries found ..");
1561 ret = -1;
1562 }
1563
1564 return ret;
1565}
1566#endif /* CONFIG_BRANCH_TRACER */
1567