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