locking: Convert __raw_spin* functions to arch_spin*
[linux-2.6.git] / kernel / trace / trace_selftest.c
1 /* Include in trace.c */
2
3 #include <linux/stringify.h>
4 #include <linux/kthread.h>
5 #include <linux/delay.h>
6
7 static inline int trace_valid_entry(struct trace_entry *entry)
8 {
9         switch (entry->type) {
10         case TRACE_FN:
11         case TRACE_CTX:
12         case TRACE_WAKE:
13         case TRACE_STACK:
14         case TRACE_PRINT:
15         case TRACE_SPECIAL:
16         case TRACE_BRANCH:
17         case TRACE_GRAPH_ENT:
18         case TRACE_GRAPH_RET:
19         case TRACE_HW_BRANCHES:
20         case TRACE_KSYM:
21                 return 1;
22         }
23         return 0;
24 }
25
26 static int trace_test_buffer_cpu(struct trace_array *tr, 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(tr->buffer, cpu, 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  */
63 static int trace_test_buffer(struct trace_array *tr, 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(&ftrace_max_lock);
71
72         cnt = ring_buffer_entries(tr->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(tr, cpu);
84                 if (ret)
85                         break;
86         }
87         tracing_on();
88         arch_spin_unlock(&ftrace_max_lock);
89         local_irq_restore(flags);
90
91         if (count)
92                 *count = cnt;
93
94         return ret;
95 }
96
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 /* Test dynamic code modification and ftrace filters */
107 int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
108                                            struct trace_array *tr,
109                                            int (*func)(void))
110 {
111         int save_ftrace_enabled = ftrace_enabled;
112         int save_tracer_enabled = tracer_enabled;
113         unsigned long count;
114         char *func_name;
115         int ret;
116
117         /* The ftrace test PASSED */
118         printk(KERN_CONT "PASSED\n");
119         pr_info("Testing dynamic ftrace: ");
120
121         /* enable tracing, and record the filter function */
122         ftrace_enabled = 1;
123         tracer_enabled = 1;
124
125         /* passed in by parameter to fool gcc from optimizing */
126         func();
127
128         /*
129          * Some archs *cough*PowerPC*cough* add characters to the
130          * start of the function names. We simply put a '*' to
131          * accommodate them.
132          */
133         func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
134
135         /* filter only on our function */
136         ftrace_set_filter(func_name, strlen(func_name), 1);
137
138         /* enable tracing */
139         ret = tracer_init(trace, tr);
140         if (ret) {
141                 warn_failed_init_tracer(trace, ret);
142                 goto out;
143         }
144
145         /* Sleep for a 1/10 of a second */
146         msleep(100);
147
148         /* we should have nothing in the buffer */
149         ret = trace_test_buffer(tr, &count);
150         if (ret)
151                 goto out;
152
153         if (count) {
154                 ret = -1;
155                 printk(KERN_CONT ".. filter did not filter .. ");
156                 goto out;
157         }
158
159         /* call our function again */
160         func();
161
162         /* sleep again */
163         msleep(100);
164
165         /* stop the tracing. */
166         tracing_stop();
167         ftrace_enabled = 0;
168
169         /* check the trace buffer */
170         ret = trace_test_buffer(tr, &count);
171         trace->reset(tr);
172         tracing_start();
173
174         /* we should only have one item */
175         if (!ret && count != 1) {
176                 printk(KERN_CONT ".. filter failed count=%ld ..", count);
177                 ret = -1;
178                 goto out;
179         }
180
181  out:
182         ftrace_enabled = save_ftrace_enabled;
183         tracer_enabled = save_tracer_enabled;
184
185         /* Enable tracing on all functions again */
186         ftrace_set_filter(NULL, 0, 1);
187
188         return ret;
189 }
190 #else
191 # define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; })
192 #endif /* CONFIG_DYNAMIC_FTRACE */
193
194 /*
195  * Simple verification test of ftrace function tracer.
196  * Enable ftrace, sleep 1/10 second, and then read the trace
197  * buffer to see if all is in order.
198  */
199 int
200 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
201 {
202         int save_ftrace_enabled = ftrace_enabled;
203         int save_tracer_enabled = tracer_enabled;
204         unsigned long count;
205         int ret;
206
207         /* make sure msleep has been recorded */
208         msleep(1);
209
210         /* start the tracing */
211         ftrace_enabled = 1;
212         tracer_enabled = 1;
213
214         ret = tracer_init(trace, tr);
215         if (ret) {
216                 warn_failed_init_tracer(trace, ret);
217                 goto out;
218         }
219
220         /* Sleep for a 1/10 of a second */
221         msleep(100);
222         /* stop the tracing. */
223         tracing_stop();
224         ftrace_enabled = 0;
225
226         /* check the trace buffer */
227         ret = trace_test_buffer(tr, &count);
228         trace->reset(tr);
229         tracing_start();
230
231         if (!ret && !count) {
232                 printk(KERN_CONT ".. no entries found ..");
233                 ret = -1;
234                 goto out;
235         }
236
237         ret = trace_selftest_startup_dynamic_tracing(trace, tr,
238                                                      DYN_FTRACE_TEST_NAME);
239
240  out:
241         ftrace_enabled = save_ftrace_enabled;
242         tracer_enabled = save_tracer_enabled;
243
244         /* kill ftrace totally if we failed */
245         if (ret)
246                 ftrace_kill();
247
248         return ret;
249 }
250 #endif /* CONFIG_FUNCTION_TRACER */
251
252
253 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
254
255 /* Maximum number of functions to trace before diagnosing a hang */
256 #define GRAPH_MAX_FUNC_TEST     100000000
257
258 static void __ftrace_dump(bool disable_tracing);
259 static unsigned int graph_hang_thresh;
260
261 /* Wrap the real function entry probe to avoid possible hanging */
262 static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace)
263 {
264         /* This is harmlessly racy, we want to approximately detect a hang */
265         if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) {
266                 ftrace_graph_stop();
267                 printk(KERN_WARNING "BUG: Function graph tracer hang!\n");
268                 if (ftrace_dump_on_oops)
269                         __ftrace_dump(false);
270                 return 0;
271         }
272
273         return trace_graph_entry(trace);
274 }
275
276 /*
277  * Pretty much the same than for the function tracer from which the selftest
278  * has been borrowed.
279  */
280 int
281 trace_selftest_startup_function_graph(struct tracer *trace,
282                                         struct trace_array *tr)
283 {
284         int ret;
285         unsigned long count;
286
287         /*
288          * Simulate the init() callback but we attach a watchdog callback
289          * to detect and recover from possible hangs
290          */
291         tracing_reset_online_cpus(tr);
292         set_graph_array(tr);
293         ret = register_ftrace_graph(&trace_graph_return,
294                                     &trace_graph_entry_watchdog);
295         if (ret) {
296                 warn_failed_init_tracer(trace, ret);
297                 goto out;
298         }
299         tracing_start_cmdline_record();
300
301         /* Sleep for a 1/10 of a second */
302         msleep(100);
303
304         /* Have we just recovered from a hang? */
305         if (graph_hang_thresh > GRAPH_MAX_FUNC_TEST) {
306                 tracing_selftest_disabled = true;
307                 ret = -1;
308                 goto out;
309         }
310
311         tracing_stop();
312
313         /* check the trace buffer */
314         ret = trace_test_buffer(tr, &count);
315
316         trace->reset(tr);
317         tracing_start();
318
319         if (!ret && !count) {
320                 printk(KERN_CONT ".. no entries found ..");
321                 ret = -1;
322                 goto out;
323         }
324
325         /* Don't test dynamic tracing, the function tracer already did */
326
327 out:
328         /* Stop it if we failed */
329         if (ret)
330                 ftrace_graph_stop();
331
332         return ret;
333 }
334 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
335
336
337 #ifdef CONFIG_IRQSOFF_TRACER
338 int
339 trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
340 {
341         unsigned long save_max = tracing_max_latency;
342         unsigned long count;
343         int ret;
344
345         /* start the tracing */
346         ret = tracer_init(trace, tr);
347         if (ret) {
348                 warn_failed_init_tracer(trace, ret);
349                 return ret;
350         }
351
352         /* reset the max latency */
353         tracing_max_latency = 0;
354         /* disable interrupts for a bit */
355         local_irq_disable();
356         udelay(100);
357         local_irq_enable();
358
359         /*
360          * Stop the tracer to avoid a warning subsequent
361          * to buffer flipping failure because tracing_stop()
362          * disables the tr and max buffers, making flipping impossible
363          * in case of parallels max irqs off latencies.
364          */
365         trace->stop(tr);
366         /* stop the tracing. */
367         tracing_stop();
368         /* check both trace buffers */
369         ret = trace_test_buffer(tr, NULL);
370         if (!ret)
371                 ret = trace_test_buffer(&max_tr, &count);
372         trace->reset(tr);
373         tracing_start();
374
375         if (!ret && !count) {
376                 printk(KERN_CONT ".. no entries found ..");
377                 ret = -1;
378         }
379
380         tracing_max_latency = save_max;
381
382         return ret;
383 }
384 #endif /* CONFIG_IRQSOFF_TRACER */
385
386 #ifdef CONFIG_PREEMPT_TRACER
387 int
388 trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
389 {
390         unsigned long save_max = tracing_max_latency;
391         unsigned long count;
392         int ret;
393
394         /*
395          * Now that the big kernel lock is no longer preemptable,
396          * and this is called with the BKL held, it will always
397          * fail. If preemption is already disabled, simply
398          * pass the test. When the BKL is removed, or becomes
399          * preemptible again, we will once again test this,
400          * so keep it in.
401          */
402         if (preempt_count()) {
403                 printk(KERN_CONT "can not test ... force ");
404                 return 0;
405         }
406
407         /* start the tracing */
408         ret = tracer_init(trace, tr);
409         if (ret) {
410                 warn_failed_init_tracer(trace, ret);
411                 return ret;
412         }
413
414         /* reset the max latency */
415         tracing_max_latency = 0;
416         /* disable preemption for a bit */
417         preempt_disable();
418         udelay(100);
419         preempt_enable();
420
421         /*
422          * Stop the tracer to avoid a warning subsequent
423          * to buffer flipping failure because tracing_stop()
424          * disables the tr and max buffers, making flipping impossible
425          * in case of parallels max preempt off latencies.
426          */
427         trace->stop(tr);
428         /* stop the tracing. */
429         tracing_stop();
430         /* check both trace buffers */
431         ret = trace_test_buffer(tr, NULL);
432         if (!ret)
433                 ret = trace_test_buffer(&max_tr, &count);
434         trace->reset(tr);
435         tracing_start();
436
437         if (!ret && !count) {
438                 printk(KERN_CONT ".. no entries found ..");
439                 ret = -1;
440         }
441
442         tracing_max_latency = save_max;
443
444         return ret;
445 }
446 #endif /* CONFIG_PREEMPT_TRACER */
447
448 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
449 int
450 trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr)
451 {
452         unsigned long save_max = tracing_max_latency;
453         unsigned long count;
454         int ret;
455
456         /*
457          * Now that the big kernel lock is no longer preemptable,
458          * and this is called with the BKL held, it will always
459          * fail. If preemption is already disabled, simply
460          * pass the test. When the BKL is removed, or becomes
461          * preemptible again, we will once again test this,
462          * so keep it in.
463          */
464         if (preempt_count()) {
465                 printk(KERN_CONT "can not test ... force ");
466                 return 0;
467         }
468
469         /* start the tracing */
470         ret = tracer_init(trace, tr);
471         if (ret) {
472                 warn_failed_init_tracer(trace, ret);
473                 goto out_no_start;
474         }
475
476         /* reset the max latency */
477         tracing_max_latency = 0;
478
479         /* disable preemption and interrupts for a bit */
480         preempt_disable();
481         local_irq_disable();
482         udelay(100);
483         preempt_enable();
484         /* reverse the order of preempt vs irqs */
485         local_irq_enable();
486
487         /*
488          * Stop the tracer to avoid a warning subsequent
489          * to buffer flipping failure because tracing_stop()
490          * disables the tr and max buffers, making flipping impossible
491          * in case of parallels max irqs/preempt off latencies.
492          */
493         trace->stop(tr);
494         /* stop the tracing. */
495         tracing_stop();
496         /* check both trace buffers */
497         ret = trace_test_buffer(tr, NULL);
498         if (ret)
499                 goto out;
500
501         ret = trace_test_buffer(&max_tr, &count);
502         if (ret)
503                 goto out;
504
505         if (!ret && !count) {
506                 printk(KERN_CONT ".. no entries found ..");
507                 ret = -1;
508                 goto out;
509         }
510
511         /* do the test by disabling interrupts first this time */
512         tracing_max_latency = 0;
513         tracing_start();
514         trace->start(tr);
515
516         preempt_disable();
517         local_irq_disable();
518         udelay(100);
519         preempt_enable();
520         /* reverse the order of preempt vs irqs */
521         local_irq_enable();
522
523         trace->stop(tr);
524         /* stop the tracing. */
525         tracing_stop();
526         /* check both trace buffers */
527         ret = trace_test_buffer(tr, NULL);
528         if (ret)
529                 goto out;
530
531         ret = trace_test_buffer(&max_tr, &count);
532
533         if (!ret && !count) {
534                 printk(KERN_CONT ".. no entries found ..");
535                 ret = -1;
536                 goto out;
537         }
538
539 out:
540         tracing_start();
541 out_no_start:
542         trace->reset(tr);
543         tracing_max_latency = save_max;
544
545         return ret;
546 }
547 #endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */
548
549 #ifdef CONFIG_NOP_TRACER
550 int
551 trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
552 {
553         /* What could possibly go wrong? */
554         return 0;
555 }
556 #endif
557
558 #ifdef CONFIG_SCHED_TRACER
559 static int trace_wakeup_test_thread(void *data)
560 {
561         /* Make this a RT thread, doesn't need to be too high */
562         struct sched_param param = { .sched_priority = 5 };
563         struct completion *x = data;
564
565         sched_setscheduler(current, SCHED_FIFO, &param);
566
567         /* Make it know we have a new prio */
568         complete(x);
569
570         /* now go to sleep and let the test wake us up */
571         set_current_state(TASK_INTERRUPTIBLE);
572         schedule();
573
574         /* we are awake, now wait to disappear */
575         while (!kthread_should_stop()) {
576                 /*
577                  * This is an RT task, do short sleeps to let
578                  * others run.
579                  */
580                 msleep(100);
581         }
582
583         return 0;
584 }
585
586 int
587 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
588 {
589         unsigned long save_max = tracing_max_latency;
590         struct task_struct *p;
591         struct completion isrt;
592         unsigned long count;
593         int ret;
594
595         init_completion(&isrt);
596
597         /* create a high prio thread */
598         p = kthread_run(trace_wakeup_test_thread, &isrt, "ftrace-test");
599         if (IS_ERR(p)) {
600                 printk(KERN_CONT "Failed to create ftrace wakeup test thread ");
601                 return -1;
602         }
603
604         /* make sure the thread is running at an RT prio */
605         wait_for_completion(&isrt);
606
607         /* start the tracing */
608         ret = tracer_init(trace, tr);
609         if (ret) {
610                 warn_failed_init_tracer(trace, ret);
611                 return ret;
612         }
613
614         /* reset the max latency */
615         tracing_max_latency = 0;
616
617         /* sleep to let the RT thread sleep too */
618         msleep(100);
619
620         /*
621          * Yes this is slightly racy. It is possible that for some
622          * strange reason that the RT thread we created, did not
623          * call schedule for 100ms after doing the completion,
624          * and we do a wakeup on a task that already is awake.
625          * But that is extremely unlikely, and the worst thing that
626          * happens in such a case, is that we disable tracing.
627          * Honestly, if this race does happen something is horrible
628          * wrong with the system.
629          */
630
631         wake_up_process(p);
632
633         /* give a little time to let the thread wake up */
634         msleep(100);
635
636         /* stop the tracing. */
637         tracing_stop();
638         /* check both trace buffers */
639         ret = trace_test_buffer(tr, NULL);
640         if (!ret)
641                 ret = trace_test_buffer(&max_tr, &count);
642
643
644         trace->reset(tr);
645         tracing_start();
646
647         tracing_max_latency = save_max;
648
649         /* kill the thread */
650         kthread_stop(p);
651
652         if (!ret && !count) {
653                 printk(KERN_CONT ".. no entries found ..");
654                 ret = -1;
655         }
656
657         return ret;
658 }
659 #endif /* CONFIG_SCHED_TRACER */
660
661 #ifdef CONFIG_CONTEXT_SWITCH_TRACER
662 int
663 trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr)
664 {
665         unsigned long count;
666         int ret;
667
668         /* start the tracing */
669         ret = tracer_init(trace, tr);
670         if (ret) {
671                 warn_failed_init_tracer(trace, ret);
672                 return ret;
673         }
674
675         /* Sleep for a 1/10 of a second */
676         msleep(100);
677         /* stop the tracing. */
678         tracing_stop();
679         /* check the trace buffer */
680         ret = trace_test_buffer(tr, &count);
681         trace->reset(tr);
682         tracing_start();
683
684         if (!ret && !count) {
685                 printk(KERN_CONT ".. no entries found ..");
686                 ret = -1;
687         }
688
689         return ret;
690 }
691 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */
692
693 #ifdef CONFIG_SYSPROF_TRACER
694 int
695 trace_selftest_startup_sysprof(struct tracer *trace, struct trace_array *tr)
696 {
697         unsigned long count;
698         int ret;
699
700         /* start the tracing */
701         ret = tracer_init(trace, tr);
702         if (ret) {
703                 warn_failed_init_tracer(trace, ret);
704                 return ret;
705         }
706
707         /* Sleep for a 1/10 of a second */
708         msleep(100);
709         /* stop the tracing. */
710         tracing_stop();
711         /* check the trace buffer */
712         ret = trace_test_buffer(tr, &count);
713         trace->reset(tr);
714         tracing_start();
715
716         if (!ret && !count) {
717                 printk(KERN_CONT ".. no entries found ..");
718                 ret = -1;
719         }
720
721         return ret;
722 }
723 #endif /* CONFIG_SYSPROF_TRACER */
724
725 #ifdef CONFIG_BRANCH_TRACER
726 int
727 trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
728 {
729         unsigned long count;
730         int ret;
731
732         /* start the tracing */
733         ret = tracer_init(trace, tr);
734         if (ret) {
735                 warn_failed_init_tracer(trace, ret);
736                 return ret;
737         }
738
739         /* Sleep for a 1/10 of a second */
740         msleep(100);
741         /* stop the tracing. */
742         tracing_stop();
743         /* check the trace buffer */
744         ret = trace_test_buffer(tr, &count);
745         trace->reset(tr);
746         tracing_start();
747
748         if (!ret && !count) {
749                 printk(KERN_CONT ".. no entries found ..");
750                 ret = -1;
751         }
752
753         return ret;
754 }
755 #endif /* CONFIG_BRANCH_TRACER */
756
757 #ifdef CONFIG_HW_BRANCH_TRACER
758 int
759 trace_selftest_startup_hw_branches(struct tracer *trace,
760                                    struct trace_array *tr)
761 {
762         struct trace_iterator *iter;
763         struct tracer tracer;
764         unsigned long count;
765         int ret;
766
767         if (!trace->open) {
768                 printk(KERN_CONT "missing open function...");
769                 return -1;
770         }
771
772         ret = tracer_init(trace, tr);
773         if (ret) {
774                 warn_failed_init_tracer(trace, ret);
775                 return ret;
776         }
777
778         /*
779          * The hw-branch tracer needs to collect the trace from the various
780          * cpu trace buffers - before tracing is stopped.
781          */
782         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
783         if (!iter)
784                 return -ENOMEM;
785
786         memcpy(&tracer, trace, sizeof(tracer));
787
788         iter->trace = &tracer;
789         iter->tr = tr;
790         iter->pos = -1;
791         mutex_init(&iter->mutex);
792
793         trace->open(iter);
794
795         mutex_destroy(&iter->mutex);
796         kfree(iter);
797
798         tracing_stop();
799
800         ret = trace_test_buffer(tr, &count);
801         trace->reset(tr);
802         tracing_start();
803
804         if (!ret && !count) {
805                 printk(KERN_CONT "no entries found..");
806                 ret = -1;
807         }
808
809         return ret;
810 }
811 #endif /* CONFIG_HW_BRANCH_TRACER */
812
813 #ifdef CONFIG_KSYM_TRACER
814 static int ksym_selftest_dummy;
815
816 int
817 trace_selftest_startup_ksym(struct tracer *trace, struct trace_array *tr)
818 {
819         unsigned long count;
820         int ret;
821
822         /* start the tracing */
823         ret = tracer_init(trace, tr);
824         if (ret) {
825                 warn_failed_init_tracer(trace, ret);
826                 return ret;
827         }
828
829         ksym_selftest_dummy = 0;
830         /* Register the read-write tracing request */
831
832         ret = process_new_ksym_entry("ksym_selftest_dummy",
833                                      HW_BREAKPOINT_R | HW_BREAKPOINT_W,
834                                         (unsigned long)(&ksym_selftest_dummy));
835
836         if (ret < 0) {
837                 printk(KERN_CONT "ksym_trace read-write startup test failed\n");
838                 goto ret_path;
839         }
840         /* Perform a read and a write operation over the dummy variable to
841          * trigger the tracer
842          */
843         if (ksym_selftest_dummy == 0)
844                 ksym_selftest_dummy++;
845
846         /* stop the tracing. */
847         tracing_stop();
848         /* check the trace buffer */
849         ret = trace_test_buffer(tr, &count);
850         trace->reset(tr);
851         tracing_start();
852
853         /* read & write operations - one each is performed on the dummy variable
854          * triggering two entries in the trace buffer
855          */
856         if (!ret && count != 2) {
857                 printk(KERN_CONT "Ksym tracer startup test failed");
858                 ret = -1;
859         }
860
861 ret_path:
862         return ret;
863 }
864 #endif /* CONFIG_KSYM_TRACER */
865