~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/trace/trace_irqsoff.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * trace irqs off critical timings
  3  *
  4  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
  5  * Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>
  6  *
  7  * From code in the latency_tracer, that is:
  8  *
  9  *  Copyright (C) 2004-2006 Ingo Molnar
 10  *  Copyright (C) 2004 Nadia Yvette Chambers
 11  */
 12 #include <linux/kallsyms.h>
 13 #include <linux/debugfs.h>
 14 #include <linux/uaccess.h>
 15 #include <linux/module.h>
 16 #include <linux/ftrace.h>
 17 #include <linux/fs.h>
 18 
 19 #include "trace.h"
 20 
 21 static struct trace_array               *irqsoff_trace __read_mostly;
 22 static int                              tracer_enabled __read_mostly;
 23 
 24 static DEFINE_PER_CPU(int, tracing_cpu);
 25 
 26 static DEFINE_RAW_SPINLOCK(max_trace_lock);
 27 
 28 enum {
 29         TRACER_IRQS_OFF         = (1 << 1),
 30         TRACER_PREEMPT_OFF      = (1 << 2),
 31 };
 32 
 33 static int trace_type __read_mostly;
 34 
 35 static int save_flags;
 36 static bool function_enabled;
 37 
 38 static void stop_irqsoff_tracer(struct trace_array *tr, int graph);
 39 static int start_irqsoff_tracer(struct trace_array *tr, int graph);
 40 
 41 #ifdef CONFIG_PREEMPT_TRACER
 42 static inline int
 43 preempt_trace(void)
 44 {
 45         return ((trace_type & TRACER_PREEMPT_OFF) && preempt_count());
 46 }
 47 #else
 48 # define preempt_trace() (0)
 49 #endif
 50 
 51 #ifdef CONFIG_IRQSOFF_TRACER
 52 static inline int
 53 irq_trace(void)
 54 {
 55         return ((trace_type & TRACER_IRQS_OFF) &&
 56                 irqs_disabled());
 57 }
 58 #else
 59 # define irq_trace() (0)
 60 #endif
 61 
 62 #define TRACE_DISPLAY_GRAPH     1
 63 
 64 static struct tracer_opt trace_opts[] = {
 65 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 66         /* display latency trace as call graph */
 67         { TRACER_OPT(display-graph, TRACE_DISPLAY_GRAPH) },
 68 #endif
 69         { } /* Empty entry */
 70 };
 71 
 72 static struct tracer_flags tracer_flags = {
 73         .val  = 0,
 74         .opts = trace_opts,
 75 };
 76 
 77 #define is_graph() (tracer_flags.val & TRACE_DISPLAY_GRAPH)
 78 
 79 /*
 80  * Sequence count - we record it when starting a measurement and
 81  * skip the latency if the sequence has changed - some other section
 82  * did a maximum and could disturb our measurement with serial console
 83  * printouts, etc. Truly coinciding maximum latencies should be rare
 84  * and what happens together happens separately as well, so this doesn't
 85  * decrease the validity of the maximum found:
 86  */
 87 static __cacheline_aligned_in_smp       unsigned long max_sequence;
 88 
 89 #ifdef CONFIG_FUNCTION_TRACER
 90 /*
 91  * Prologue for the preempt and irqs off function tracers.
 92  *
 93  * Returns 1 if it is OK to continue, and data->disabled is
 94  *            incremented.
 95  *         0 if the trace is to be ignored, and data->disabled
 96  *            is kept the same.
 97  *
 98  * Note, this function is also used outside this ifdef but
 99  *  inside the #ifdef of the function graph tracer below.
100  *  This is OK, since the function graph tracer is
101  *  dependent on the function tracer.
102  */
103 static int func_prolog_dec(struct trace_array *tr,
104                            struct trace_array_cpu **data,
105                            unsigned long *flags)
106 {
107         long disabled;
108         int cpu;
109 
110         /*
111          * Does not matter if we preempt. We test the flags
112          * afterward, to see if irqs are disabled or not.
113          * If we preempt and get a false positive, the flags
114          * test will fail.
115          */
116         cpu = raw_smp_processor_id();
117         if (likely(!per_cpu(tracing_cpu, cpu)))
118                 return 0;
119 
120         local_save_flags(*flags);
121         /* slight chance to get a false positive on tracing_cpu */
122         if (!irqs_disabled_flags(*flags))
123                 return 0;
124 
125         *data = per_cpu_ptr(tr->trace_buffer.data, cpu);
126         disabled = atomic_inc_return(&(*data)->disabled);
127 
128         if (likely(disabled == 1))
129                 return 1;
130 
131         atomic_dec(&(*data)->disabled);
132 
133         return 0;
134 }
135 
136 /*
137  * irqsoff uses its own tracer function to keep the overhead down:
138  */
139 static void
140 irqsoff_tracer_call(unsigned long ip, unsigned long parent_ip,
141                     struct ftrace_ops *op, struct pt_regs *pt_regs)
142 {
143         struct trace_array *tr = irqsoff_trace;
144         struct trace_array_cpu *data;
145         unsigned long flags;
146 
147         if (!func_prolog_dec(tr, &data, &flags))
148                 return;
149 
150         trace_function(tr, ip, parent_ip, flags, preempt_count());
151 
152         atomic_dec(&data->disabled);
153 }
154 
155 static struct ftrace_ops trace_ops __read_mostly =
156 {
157         .func = irqsoff_tracer_call,
158         .flags = FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_RECURSION_SAFE,
159 };
160 #endif /* CONFIG_FUNCTION_TRACER */
161 
162 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
163 static int irqsoff_set_flag(u32 old_flags, u32 bit, int set)
164 {
165         int cpu;
166 
167         if (!(bit & TRACE_DISPLAY_GRAPH))
168                 return -EINVAL;
169 
170         if (!(is_graph() ^ set))
171                 return 0;
172 
173         stop_irqsoff_tracer(irqsoff_trace, !set);
174 
175         for_each_possible_cpu(cpu)
176                 per_cpu(tracing_cpu, cpu) = 0;
177 
178         tracing_max_latency = 0;
179         tracing_reset_online_cpus(&irqsoff_trace->trace_buffer);
180 
181         return start_irqsoff_tracer(irqsoff_trace, set);
182 }
183 
184 static int irqsoff_graph_entry(struct ftrace_graph_ent *trace)
185 {
186         struct trace_array *tr = irqsoff_trace;
187         struct trace_array_cpu *data;
188         unsigned long flags;
189         int ret;
190         int pc;
191 
192         if (!func_prolog_dec(tr, &data, &flags))
193                 return 0;
194 
195         pc = preempt_count();
196         ret = __trace_graph_entry(tr, trace, flags, pc);
197         atomic_dec(&data->disabled);
198 
199         return ret;
200 }
201 
202 static void irqsoff_graph_return(struct ftrace_graph_ret *trace)
203 {
204         struct trace_array *tr = irqsoff_trace;
205         struct trace_array_cpu *data;
206         unsigned long flags;
207         int pc;
208 
209         if (!func_prolog_dec(tr, &data, &flags))
210                 return;
211 
212         pc = preempt_count();
213         __trace_graph_return(tr, trace, flags, pc);
214         atomic_dec(&data->disabled);
215 }
216 
217 static void irqsoff_trace_open(struct trace_iterator *iter)
218 {
219         if (is_graph())
220                 graph_trace_open(iter);
221 
222 }
223 
224 static void irqsoff_trace_close(struct trace_iterator *iter)
225 {
226         if (iter->private)
227                 graph_trace_close(iter);
228 }
229 
230 #define GRAPH_TRACER_FLAGS (TRACE_GRAPH_PRINT_CPU | \
231                             TRACE_GRAPH_PRINT_PROC | \
232                             TRACE_GRAPH_PRINT_ABS_TIME | \
233                             TRACE_GRAPH_PRINT_DURATION)
234 
235 static enum print_line_t irqsoff_print_line(struct trace_iterator *iter)
236 {
237         /*
238          * In graph mode call the graph tracer output function,
239          * otherwise go with the TRACE_FN event handler
240          */
241         if (is_graph())
242                 return print_graph_function_flags(iter, GRAPH_TRACER_FLAGS);
243 
244         return TRACE_TYPE_UNHANDLED;
245 }
246 
247 static void irqsoff_print_header(struct seq_file *s)
248 {
249         if (is_graph())
250                 print_graph_headers_flags(s, GRAPH_TRACER_FLAGS);
251         else
252                 trace_default_header(s);
253 }
254 
255 static void
256 __trace_function(struct trace_array *tr,
257                  unsigned long ip, unsigned long parent_ip,
258                  unsigned long flags, int pc)
259 {
260         if (is_graph())
261                 trace_graph_function(tr, ip, parent_ip, flags, pc);
262         else
263                 trace_function(tr, ip, parent_ip, flags, pc);
264 }
265 
266 #else
267 #define __trace_function trace_function
268 
269 static int irqsoff_set_flag(u32 old_flags, u32 bit, int set)
270 {
271         return -EINVAL;
272 }
273 
274 static int irqsoff_graph_entry(struct ftrace_graph_ent *trace)
275 {
276         return -1;
277 }
278 
279 static enum print_line_t irqsoff_print_line(struct trace_iterator *iter)
280 {
281         return TRACE_TYPE_UNHANDLED;
282 }
283 
284 static void irqsoff_graph_return(struct ftrace_graph_ret *trace) { }
285 static void irqsoff_trace_open(struct trace_iterator *iter) { }
286 static void irqsoff_trace_close(struct trace_iterator *iter) { }
287 
288 #ifdef CONFIG_FUNCTION_TRACER
289 static void irqsoff_print_header(struct seq_file *s)
290 {
291         trace_default_header(s);
292 }
293 #else
294 static void irqsoff_print_header(struct seq_file *s)
295 {
296         trace_latency_header(s);
297 }
298 #endif /* CONFIG_FUNCTION_TRACER */
299 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
300 
301 /*
302  * Should this new latency be reported/recorded?
303  */
304 static int report_latency(cycle_t delta)
305 {
306         if (tracing_thresh) {
307                 if (delta < tracing_thresh)
308                         return 0;
309         } else {
310                 if (delta <= tracing_max_latency)
311                         return 0;
312         }
313         return 1;
314 }
315 
316 static void
317 check_critical_timing(struct trace_array *tr,
318                       struct trace_array_cpu *data,
319                       unsigned long parent_ip,
320                       int cpu)
321 {
322         cycle_t T0, T1, delta;
323         unsigned long flags;
324         int pc;
325 
326         T0 = data->preempt_timestamp;
327         T1 = ftrace_now(cpu);
328         delta = T1-T0;
329 
330         local_save_flags(flags);
331 
332         pc = preempt_count();
333 
334         if (!report_latency(delta))
335                 goto out;
336 
337         raw_spin_lock_irqsave(&max_trace_lock, flags);
338 
339         /* check if we are still the max latency */
340         if (!report_latency(delta))
341                 goto out_unlock;
342 
343         __trace_function(tr, CALLER_ADDR0, parent_ip, flags, pc);
344         /* Skip 5 functions to get to the irq/preempt enable function */
345         __trace_stack(tr, flags, 5, pc);
346 
347         if (data->critical_sequence != max_sequence)
348                 goto out_unlock;
349 
350         data->critical_end = parent_ip;
351 
352         if (likely(!is_tracing_stopped())) {
353                 tracing_max_latency = delta;
354                 update_max_tr_single(tr, current, cpu);
355         }
356 
357         max_sequence++;
358 
359 out_unlock:
360         raw_spin_unlock_irqrestore(&max_trace_lock, flags);
361 
362 out:
363         data->critical_sequence = max_sequence;
364         data->preempt_timestamp = ftrace_now(cpu);
365         __trace_function(tr, CALLER_ADDR0, parent_ip, flags, pc);
366 }
367 
368 static inline void
369 start_critical_timing(unsigned long ip, unsigned long parent_ip)
370 {
371         int cpu;
372         struct trace_array *tr = irqsoff_trace;
373         struct trace_array_cpu *data;
374         unsigned long flags;
375 
376         if (!tracer_enabled || !tracing_is_enabled())
377                 return;
378 
379         cpu = raw_smp_processor_id();
380 
381         if (per_cpu(tracing_cpu, cpu))
382                 return;
383 
384         data = per_cpu_ptr(tr->trace_buffer.data, cpu);
385 
386         if (unlikely(!data) || atomic_read(&data->disabled))
387                 return;
388 
389         atomic_inc(&data->disabled);
390 
391         data->critical_sequence = max_sequence;
392         data->preempt_timestamp = ftrace_now(cpu);
393         data->critical_start = parent_ip ? : ip;
394 
395         local_save_flags(flags);
396 
397         __trace_function(tr, ip, parent_ip, flags, preempt_count());
398 
399         per_cpu(tracing_cpu, cpu) = 1;
400 
401         atomic_dec(&data->disabled);
402 }
403 
404 static inline void
405 stop_critical_timing(unsigned long ip, unsigned long parent_ip)
406 {
407         int cpu;
408         struct trace_array *tr = irqsoff_trace;
409         struct trace_array_cpu *data;
410         unsigned long flags;
411 
412         cpu = raw_smp_processor_id();
413         /* Always clear the tracing cpu on stopping the trace */
414         if (unlikely(per_cpu(tracing_cpu, cpu)))
415                 per_cpu(tracing_cpu, cpu) = 0;
416         else
417                 return;
418 
419         if (!tracer_enabled || !tracing_is_enabled())
420                 return;
421 
422         data = per_cpu_ptr(tr->trace_buffer.data, cpu);
423 
424         if (unlikely(!data) ||
425             !data->critical_start || atomic_read(&data->disabled))
426                 return;
427 
428         atomic_inc(&data->disabled);
429 
430         local_save_flags(flags);
431         __trace_function(tr, ip, parent_ip, flags, preempt_count());
432         check_critical_timing(tr, data, parent_ip ? : ip, cpu);
433         data->critical_start = 0;
434         atomic_dec(&data->disabled);
435 }
436 
437 /* start and stop critical timings used to for stoppage (in idle) */
438 void start_critical_timings(void)
439 {
440         if (preempt_trace() || irq_trace())
441                 start_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
442 }
443 EXPORT_SYMBOL_GPL(start_critical_timings);
444 
445 void stop_critical_timings(void)
446 {
447         if (preempt_trace() || irq_trace())
448                 stop_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
449 }
450 EXPORT_SYMBOL_GPL(stop_critical_timings);
451 
452 #ifdef CONFIG_IRQSOFF_TRACER
453 #ifdef CONFIG_PROVE_LOCKING
454 void time_hardirqs_on(unsigned long a0, unsigned long a1)
455 {
456         if (!preempt_trace() && irq_trace())
457                 stop_critical_timing(a0, a1);
458 }
459 
460 void time_hardirqs_off(unsigned long a0, unsigned long a1)
461 {
462         if (!preempt_trace() && irq_trace())
463                 start_critical_timing(a0, a1);
464 }
465 
466 #else /* !CONFIG_PROVE_LOCKING */
467 
468 /*
469  * Stubs:
470  */
471 
472 void trace_softirqs_on(unsigned long ip)
473 {
474 }
475 
476 void trace_softirqs_off(unsigned long ip)
477 {
478 }
479 
480 inline void print_irqtrace_events(struct task_struct *curr)
481 {
482 }
483 
484 /*
485  * We are only interested in hardirq on/off events:
486  */
487 void trace_hardirqs_on(void)
488 {
489         if (!preempt_trace() && irq_trace())
490                 stop_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
491 }
492 EXPORT_SYMBOL(trace_hardirqs_on);
493 
494 void trace_hardirqs_off(void)
495 {
496         if (!preempt_trace() && irq_trace())
497                 start_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
498 }
499 EXPORT_SYMBOL(trace_hardirqs_off);
500 
501 void trace_hardirqs_on_caller(unsigned long caller_addr)
502 {
503         if (!preempt_trace() && irq_trace())
504                 stop_critical_timing(CALLER_ADDR0, caller_addr);
505 }
506 EXPORT_SYMBOL(trace_hardirqs_on_caller);
507 
508 void trace_hardirqs_off_caller(unsigned long caller_addr)
509 {
510         if (!preempt_trace() && irq_trace())
511                 start_critical_timing(CALLER_ADDR0, caller_addr);
512 }
513 EXPORT_SYMBOL(trace_hardirqs_off_caller);
514 
515 #endif /* CONFIG_PROVE_LOCKING */
516 #endif /*  CONFIG_IRQSOFF_TRACER */
517 
518 #ifdef CONFIG_PREEMPT_TRACER
519 void trace_preempt_on(unsigned long a0, unsigned long a1)
520 {
521         if (preempt_trace() && !irq_trace())
522                 stop_critical_timing(a0, a1);
523 }
524 
525 void trace_preempt_off(unsigned long a0, unsigned long a1)
526 {
527         if (preempt_trace() && !irq_trace())
528                 start_critical_timing(a0, a1);
529 }
530 #endif /* CONFIG_PREEMPT_TRACER */
531 
532 static int register_irqsoff_function(int graph, int set)
533 {
534         int ret;
535 
536         /* 'set' is set if TRACE_ITER_FUNCTION is about to be set */
537         if (function_enabled || (!set && !(trace_flags & TRACE_ITER_FUNCTION)))
538                 return 0;
539 
540         if (graph)
541                 ret = register_ftrace_graph(&irqsoff_graph_return,
542                                             &irqsoff_graph_entry);
543         else
544                 ret = register_ftrace_function(&trace_ops);
545 
546         if (!ret)
547                 function_enabled = true;
548 
549         return ret;
550 }
551 
552 static void unregister_irqsoff_function(int graph)
553 {
554         if (!function_enabled)
555                 return;
556 
557         if (graph)
558                 unregister_ftrace_graph();
559         else
560                 unregister_ftrace_function(&trace_ops);
561 
562         function_enabled = false;
563 }
564 
565 static void irqsoff_function_set(int set)
566 {
567         if (set)
568                 register_irqsoff_function(is_graph(), 1);
569         else
570                 unregister_irqsoff_function(is_graph());
571 }
572 
573 static int irqsoff_flag_changed(struct tracer *tracer, u32 mask, int set)
574 {
575         if (mask & TRACE_ITER_FUNCTION)
576                 irqsoff_function_set(set);
577 
578         return trace_keep_overwrite(tracer, mask, set);
579 }
580 
581 static int start_irqsoff_tracer(struct trace_array *tr, int graph)
582 {
583         int ret;
584 
585         ret = register_irqsoff_function(graph, 0);
586 
587         if (!ret && tracing_is_enabled())
588                 tracer_enabled = 1;
589         else
590                 tracer_enabled = 0;
591 
592         return ret;
593 }
594 
595 static void stop_irqsoff_tracer(struct trace_array *tr, int graph)
596 {
597         tracer_enabled = 0;
598 
599         unregister_irqsoff_function(graph);
600 }
601 
602 static void __irqsoff_tracer_init(struct trace_array *tr)
603 {
604         save_flags = trace_flags;
605 
606         /* non overwrite screws up the latency tracers */
607         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, 1);
608         set_tracer_flag(tr, TRACE_ITER_LATENCY_FMT, 1);
609 
610         tracing_max_latency = 0;
611         irqsoff_trace = tr;
612         /* make sure that the tracer is visible */
613         smp_wmb();
614         tracing_reset_online_cpus(&tr->trace_buffer);
615 
616         if (start_irqsoff_tracer(tr, is_graph()))
617                 printk(KERN_ERR "failed to start irqsoff tracer\n");
618 }
619 
620 static void irqsoff_tracer_reset(struct trace_array *tr)
621 {
622         int lat_flag = save_flags & TRACE_ITER_LATENCY_FMT;
623         int overwrite_flag = save_flags & TRACE_ITER_OVERWRITE;
624 
625         stop_irqsoff_tracer(tr, is_graph());
626 
627         set_tracer_flag(tr, TRACE_ITER_LATENCY_FMT, lat_flag);
628         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, overwrite_flag);
629 }
630 
631 static void irqsoff_tracer_start(struct trace_array *tr)
632 {
633         tracer_enabled = 1;
634 }
635 
636 static void irqsoff_tracer_stop(struct trace_array *tr)
637 {
638         tracer_enabled = 0;
639 }
640 
641 #ifdef CONFIG_IRQSOFF_TRACER
642 static int irqsoff_tracer_init(struct trace_array *tr)
643 {
644         trace_type = TRACER_IRQS_OFF;
645 
646         __irqsoff_tracer_init(tr);
647         return 0;
648 }
649 static struct tracer irqsoff_tracer __read_mostly =
650 {
651         .name           = "irqsoff",
652         .init           = irqsoff_tracer_init,
653         .reset          = irqsoff_tracer_reset,
654         .start          = irqsoff_tracer_start,
655         .stop           = irqsoff_tracer_stop,
656         .print_max      = true,
657         .print_header   = irqsoff_print_header,
658         .print_line     = irqsoff_print_line,
659         .flags          = &tracer_flags,
660         .set_flag       = irqsoff_set_flag,
661         .flag_changed   = irqsoff_flag_changed,
662 #ifdef CONFIG_FTRACE_SELFTEST
663         .selftest    = trace_selftest_startup_irqsoff,
664 #endif
665         .open           = irqsoff_trace_open,
666         .close          = irqsoff_trace_close,
667         .use_max_tr     = true,
668 };
669 # define register_irqsoff(trace) register_tracer(&trace)
670 #else
671 # define register_irqsoff(trace) do { } while (0)
672 #endif
673 
674 #ifdef CONFIG_PREEMPT_TRACER
675 static int preemptoff_tracer_init(struct trace_array *tr)
676 {
677         trace_type = TRACER_PREEMPT_OFF;
678 
679         __irqsoff_tracer_init(tr);
680         return 0;
681 }
682 
683 static struct tracer preemptoff_tracer __read_mostly =
684 {
685         .name           = "preemptoff",
686         .init           = preemptoff_tracer_init,
687         .reset          = irqsoff_tracer_reset,
688         .start          = irqsoff_tracer_start,
689         .stop           = irqsoff_tracer_stop,
690         .print_max      = true,
691         .print_header   = irqsoff_print_header,
692         .print_line     = irqsoff_print_line,
693         .flags          = &tracer_flags,
694         .set_flag       = irqsoff_set_flag,
695         .flag_changed   = irqsoff_flag_changed,
696 #ifdef CONFIG_FTRACE_SELFTEST
697         .selftest    = trace_selftest_startup_preemptoff,
698 #endif
699         .open           = irqsoff_trace_open,
700         .close          = irqsoff_trace_close,
701         .use_max_tr     = true,
702 };
703 # define register_preemptoff(trace) register_tracer(&trace)
704 #else
705 # define register_preemptoff(trace) do { } while (0)
706 #endif
707 
708 #if defined(CONFIG_IRQSOFF_TRACER) && \
709         defined(CONFIG_PREEMPT_TRACER)
710 
711 static int preemptirqsoff_tracer_init(struct trace_array *tr)
712 {
713         trace_type = TRACER_IRQS_OFF | TRACER_PREEMPT_OFF;
714 
715         __irqsoff_tracer_init(tr);
716         return 0;
717 }
718 
719 static struct tracer preemptirqsoff_tracer __read_mostly =
720 {
721         .name           = "preemptirqsoff",
722         .init           = preemptirqsoff_tracer_init,
723         .reset          = irqsoff_tracer_reset,
724         .start          = irqsoff_tracer_start,
725         .stop           = irqsoff_tracer_stop,
726         .print_max      = true,
727         .print_header   = irqsoff_print_header,
728         .print_line     = irqsoff_print_line,
729         .flags          = &tracer_flags,
730         .set_flag       = irqsoff_set_flag,
731         .flag_changed   = irqsoff_flag_changed,
732 #ifdef CONFIG_FTRACE_SELFTEST
733         .selftest    = trace_selftest_startup_preemptirqsoff,
734 #endif
735         .open           = irqsoff_trace_open,
736         .close          = irqsoff_trace_close,
737         .use_max_tr     = true,
738 };
739 
740 # define register_preemptirqsoff(trace) register_tracer(&trace)
741 #else
742 # define register_preemptirqsoff(trace) do { } while (0)
743 #endif
744 
745 __init static int init_irqsoff_tracer(void)
746 {
747         register_irqsoff(irqsoff_tracer);
748         register_preemptoff(preemptoff_tracer);
749         register_preemptirqsoff(preemptirqsoff_tracer);
750 
751         return 0;
752 }
753 core_initcall(init_irqsoff_tracer);
754 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp