kernel/trace/trace_irqsoff.c

   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/uaccess.h>
  14 #include <linux/module.h>
  15 #include <linux/ftrace.h>
  16
  17 #include "trace.h"
  18
  19 static struct trace_array               *irqsoff_trace __read_mostly;
  20 static int                              tracer_enabled __read_mostly;
  21
  22 static DEFINE_PER_CPU(int, tracing_cpu);
  23
  24 static DEFINE_RAW_SPINLOCK(max_trace_lock);
  25
  26 enum {
  27         TRACER_IRQS_OFF         = (1 << 1),
  28         TRACER_PREEMPT_OFF      = (1 << 2),
  29 };
  30
  31 static int trace_type __read_mostly;
  32
  33 static int save_flags;
  34
  35 static void stop_irqsoff_tracer(struct trace_array *tr, int graph);
  36 static int start_irqsoff_tracer(struct trace_array *tr, int graph);
  37
  38 #ifdef CONFIG_PREEMPT_TRACER
  39 static inline int
  40 preempt_trace(void)
  41 {
  42         return ((trace_type & TRACER_PREEMPT_OFF) && preempt_count());
  43 }
  44 #else
  45 # define preempt_trace() (0)
  46 #endif
  47
  48 #ifdef CONFIG_IRQSOFF_TRACER
  49 static inline int
  50 irq_trace(void)
  51 {
  52         return ((trace_type & TRACER_IRQS_OFF) &&
  53                 irqs_disabled());
  54 }
  55 #else
  56 # define irq_trace() (0)
  57 #endif
  58
  59 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
  60 static int irqsoff_display_graph(struct trace_array *tr, int set);
  61 # define is_graph(tr) ((tr)->trace_flags & TRACE_ITER_DISPLAY_GRAPH)
  62 #else
  63 static inline int irqsoff_display_graph(struct trace_array *tr, int set)
  64 {
  65         return -EINVAL;
  66 }
  67 # define is_graph(tr) false
  68 #endif
  69
  70 /*
  71  * Sequence count - we record it when starting a measurement and
  72  * skip the latency if the sequence has changed - some other section
  73  * did a maximum and could disturb our measurement with serial console
  74  * printouts, etc. Truly coinciding maximum latencies should be rare
  75  * and what happens together happens separately as well, so this doesn't
  76  * decrease the validity of the maximum found:
  77  */
  78 static __cacheline_aligned_in_smp       unsigned long max_sequence;
  79
  80 #ifdef CONFIG_FUNCTION_TRACER
  81 /*
  82  * Prologue for the preempt and irqs off function tracers.
  83  *
  84  * Returns 1 if it is OK to continue, and data->disabled is
  85  *            incremented.
  86  *         0 if the trace is to be ignored, and data->disabled
  87  *            is kept the same.
  88  *
  89  * Note, this function is also used outside this ifdef but
  90  *  inside the #ifdef of the function graph tracer below.
  91  *  This is OK, since the function graph tracer is
  92  *  dependent on the function tracer.
  93  */
  94 static int func_prolog_dec(struct trace_array *tr,
  95                            struct trace_array_cpu **data,
  96                            unsigned long *flags)
  97 {
  98         long disabled;
  99         int cpu;
 100
 101         /*
 102          * Does not matter if we preempt. We test the flags
 103          * afterward, to see if irqs are disabled or not.
 104          * If we preempt and get a false positive, the flags
 105          * test will fail.
 106          */
 107         cpu = raw_smp_processor_id();
 108         if (likely(!per_cpu(tracing_cpu, cpu)))
 109                 return 0;
 110
 111         local_save_flags(*flags);
 112         /*
 113          * Slight chance to get a false positive on tracing_cpu,
 114          * although I'm starting to think there isn't a chance.
 115          * Leave this for now just to be paranoid.
 116          */
 117         if (!irqs_disabled_flags(*flags) && !preempt_count())
 118                 return 0;
 119
 120         *data = per_cpu_ptr(tr->trace_buffer.data, cpu);
 121         disabled = atomic_inc_return(&(*data)->disabled);
 122
 123         if (likely(disabled == 1))
 124                 return 1;
 125
 126         atomic_dec(&(*data)->disabled);
 127
 128         return 0;
 129 }
 130
 131 /*
 132  * irqsoff uses its own tracer function to keep the overhead down:
 133  */
 134 static void
 135 irqsoff_tracer_call(unsigned long ip, unsigned long parent_ip,
 136                     struct ftrace_ops *op, struct pt_regs *pt_regs)
 137 {
 138         struct trace_array *tr = irqsoff_trace;
 139         struct trace_array_cpu *data;
 140         unsigned long flags;
 141
 142         if (!func_prolog_dec(tr, &data, &flags))
 143                 return;
 144
 145         trace_function(tr, ip, parent_ip, flags, preempt_count());
 146
 147         atomic_dec(&data->disabled);
 148 }
 149 #endif /* CONFIG_FUNCTION_TRACER */
 150
 151 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 152 static int irqsoff_display_graph(struct trace_array *tr, int set)
 153 {
 154         int cpu;
 155
 156         if (!(is_graph(tr) ^ set))
 157                 return 0;
 158
 159         stop_irqsoff_tracer(irqsoff_trace, !set);
 160
 161         for_each_possible_cpu(cpu)
 162                 per_cpu(tracing_cpu, cpu) = 0;
 163
 164         tr->max_latency = 0;
 165         tracing_reset_online_cpus(&irqsoff_trace->trace_buffer);
 166
 167         return start_irqsoff_tracer(irqsoff_trace, set);
 168 }
 169
 170 static int irqsoff_graph_entry(struct ftrace_graph_ent *trace)
 171 {
 172         struct trace_array *tr = irqsoff_trace;
 173         struct trace_array_cpu *data;
 174         unsigned long flags;
 175         int ret;
 176         int pc;
 177
 178         if (ftrace_graph_ignore_func(trace))
 179                 return 0;
 180         /*
 181          * Do not trace a function if it's filtered by set_graph_notrace.
 182          * Make the index of ret stack negative to indicate that it should
 183          * ignore further functions.  But it needs its own ret stack entry
 184          * to recover the original index in order to continue tracing after
 185          * returning from the function.
 186          */
 187         if (ftrace_graph_notrace_addr(trace->func))
 188                 return 1;
 189
 190         if (!func_prolog_dec(tr, &data, &flags))
 191                 return 0;
 192
 193         pc = preempt_count();
 194         ret = __trace_graph_entry(tr, trace, flags, pc);
 195         atomic_dec(&data->disabled);
 196
 197         return ret;
 198 }
 199
 200 static void irqsoff_graph_return(struct ftrace_graph_ret *trace)
 201 {
 202         struct trace_array *tr = irqsoff_trace;
 203         struct trace_array_cpu *data;
 204         unsigned long flags;
 205         int pc;
 206
 207         ftrace_graph_addr_finish(trace);
 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(iter->tr))
 220                 graph_trace_open(iter);
 221         else
 222                 iter->private = NULL;
 223 }
 224
 225 static void irqsoff_trace_close(struct trace_iterator *iter)
 226 {
 227         if (iter->private)
 228                 graph_trace_close(iter);
 229 }
 230
 231 #define GRAPH_TRACER_FLAGS (TRACE_GRAPH_PRINT_CPU | \
 232                             TRACE_GRAPH_PRINT_PROC | \
 233                             TRACE_GRAPH_PRINT_ABS_TIME | \
 234                             TRACE_GRAPH_PRINT_DURATION)
 235
 236 static enum print_line_t irqsoff_print_line(struct trace_iterator *iter)
 237 {
 238         /*
 239          * In graph mode call the graph tracer output function,
 240          * otherwise go with the TRACE_FN event handler
 241          */
 242         if (is_graph(iter->tr))
 243                 return print_graph_function_flags(iter, GRAPH_TRACER_FLAGS);
 244
 245         return TRACE_TYPE_UNHANDLED;
 246 }
 247
 248 static void irqsoff_print_header(struct seq_file *s)
 249 {
 250         struct trace_array *tr = irqsoff_trace;
 251
 252         if (is_graph(tr))
 253                 print_graph_headers_flags(s, GRAPH_TRACER_FLAGS);
 254         else
 255                 trace_default_header(s);
 256 }
 257
 258 static void
 259 __trace_function(struct trace_array *tr,
 260                  unsigned long ip, unsigned long parent_ip,
 261                  unsigned long flags, int pc)
 262 {
 263         if (is_graph(tr))
 264                 trace_graph_function(tr, ip, parent_ip, flags, pc);
 265         else
 266                 trace_function(tr, ip, parent_ip, flags, pc);
 267 }
 268
 269 #else
 270 #define __trace_function trace_function
 271
 272 #ifdef CONFIG_FUNCTION_TRACER
 273 static int irqsoff_graph_entry(struct ftrace_graph_ent *trace)
 274 {
 275         return -1;
 276 }
 277 #endif
 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_trace_open(struct trace_iterator *iter) { }
 285 static void irqsoff_trace_close(struct trace_iterator *iter) { }
 286
 287 #ifdef CONFIG_FUNCTION_TRACER
 288 static void irqsoff_graph_return(struct ftrace_graph_ret *trace) { }
 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 bool report_latency(struct trace_array *tr, u64 delta)
 305 {
 306         if (tracing_thresh) {
 307                 if (delta < tracing_thresh)
 308                         return false;
 309         } else {
 310                 if (delta <= tr->max_latency)
 311                         return false;
 312         }
 313         return true;
 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         u64 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(tr, 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(tr, 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                 tr->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 __visible 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 __visible 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 #ifdef CONFIG_FUNCTION_TRACER
 533 static bool function_enabled;
 534
 535 static int register_irqsoff_function(struct trace_array *tr, int graph, int set)
 536 {
 537         int ret;
 538
 539         /* 'set' is set if TRACE_ITER_FUNCTION is about to be set */
 540         if (function_enabled || (!set && !(tr->trace_flags & TRACE_ITER_FUNCTION)))
 541                 return 0;
 542
 543         if (graph)
 544                 ret = register_ftrace_graph(&irqsoff_graph_return,
 545                                             &irqsoff_graph_entry);
 546         else
 547                 ret = register_ftrace_function(tr->ops);
 548
 549         if (!ret)
 550                 function_enabled = true;
 551
 552         return ret;
 553 }
 554
 555 static void unregister_irqsoff_function(struct trace_array *tr, int graph)
 556 {
 557         if (!function_enabled)
 558                 return;
 559
 560         if (graph)
 561                 unregister_ftrace_graph();
 562         else
 563                 unregister_ftrace_function(tr->ops);
 564
 565         function_enabled = false;
 566 }
 567
 568 static int irqsoff_function_set(struct trace_array *tr, u32 mask, int set)
 569 {
 570         if (!(mask & TRACE_ITER_FUNCTION))
 571                 return 0;
 572
 573         if (set)
 574                 register_irqsoff_function(tr, is_graph(tr), 1);
 575         else
 576                 unregister_irqsoff_function(tr, is_graph(tr));
 577         return 1;
 578 }
 579 #else
 580 static int register_irqsoff_function(struct trace_array *tr, int graph, int set)
 581 {
 582         return 0;
 583 }
 584 static void unregister_irqsoff_function(struct trace_array *tr, int graph) { }
 585 static inline int irqsoff_function_set(struct trace_array *tr, u32 mask, int set)
 586 {
 587         return 0;
 588 }
 589 #endif /* CONFIG_FUNCTION_TRACER */
 590
 591 static int irqsoff_flag_changed(struct trace_array *tr, u32 mask, int set)
 592 {
 593         struct tracer *tracer = tr->current_trace;
 594
 595         if (irqsoff_function_set(tr, mask, set))
 596                 return 0;
 597
 598 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 599         if (mask & TRACE_ITER_DISPLAY_GRAPH)
 600                 return irqsoff_display_graph(tr, set);
 601 #endif
 602
 603         return trace_keep_overwrite(tracer, mask, set);
 604 }
 605
 606 static int start_irqsoff_tracer(struct trace_array *tr, int graph)
 607 {
 608         int ret;
 609
 610         ret = register_irqsoff_function(tr, graph, 0);
 611
 612         if (!ret && tracing_is_enabled())
 613                 tracer_enabled = 1;
 614         else
 615                 tracer_enabled = 0;
 616
 617         return ret;
 618 }
 619
 620 static void stop_irqsoff_tracer(struct trace_array *tr, int graph)
 621 {
 622         tracer_enabled = 0;
 623
 624         unregister_irqsoff_function(tr, graph);
 625 }
 626
 627 static bool irqsoff_busy;
 628
 629 static int __irqsoff_tracer_init(struct trace_array *tr)
 630 {
 631         if (irqsoff_busy)
 632                 return -EBUSY;
 633
 634         save_flags = tr->trace_flags;
 635
 636         /* non overwrite screws up the latency tracers */
 637         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, 1);
 638         set_tracer_flag(tr, TRACE_ITER_LATENCY_FMT, 1);
 639
 640         tr->max_latency = 0;
 641         irqsoff_trace = tr;
 642         /* make sure that the tracer is visible */
 643         smp_wmb();
 644
 645         ftrace_init_array_ops(tr, irqsoff_tracer_call);
 646
 647         /* Only toplevel instance supports graph tracing */
 648         if (start_irqsoff_tracer(tr, (tr->flags & TRACE_ARRAY_FL_GLOBAL &&
 649                                       is_graph(tr))))
 650                 printk(KERN_ERR "failed to start irqsoff tracer\n");
 651
 652         irqsoff_busy = true;
 653         return 0;
 654 }
 655
 656 static void irqsoff_tracer_reset(struct trace_array *tr)
 657 {
 658         int lat_flag = save_flags & TRACE_ITER_LATENCY_FMT;
 659         int overwrite_flag = save_flags & TRACE_ITER_OVERWRITE;
 660
 661         stop_irqsoff_tracer(tr, is_graph(tr));
 662
 663         set_tracer_flag(tr, TRACE_ITER_LATENCY_FMT, lat_flag);
 664         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, overwrite_flag);
 665         ftrace_reset_array_ops(tr);
 666
 667         irqsoff_busy = false;
 668 }
 669
 670 static void irqsoff_tracer_start(struct trace_array *tr)
 671 {
 672         tracer_enabled = 1;
 673 }
 674
 675 static void irqsoff_tracer_stop(struct trace_array *tr)
 676 {
 677         tracer_enabled = 0;
 678 }
 679
 680 #ifdef CONFIG_IRQSOFF_TRACER
 681 static int irqsoff_tracer_init(struct trace_array *tr)
 682 {
 683         trace_type = TRACER_IRQS_OFF;
 684
 685         return __irqsoff_tracer_init(tr);
 686 }
 687 static struct tracer irqsoff_tracer __read_mostly =
 688 {
 689         .name           = "irqsoff",
 690         .init           = irqsoff_tracer_init,
 691         .reset          = irqsoff_tracer_reset,
 692         .start          = irqsoff_tracer_start,
 693         .stop           = irqsoff_tracer_stop,
 694         .print_max      = true,
 695         .print_header   = irqsoff_print_header,
 696         .print_line     = irqsoff_print_line,
 697         .flag_changed   = irqsoff_flag_changed,
 698 #ifdef CONFIG_FTRACE_SELFTEST
 699         .selftest    = trace_selftest_startup_irqsoff,
 700 #endif
 701         .open           = irqsoff_trace_open,
 702         .close          = irqsoff_trace_close,
 703         .allow_instances = true,
 704         .use_max_tr     = true,
 705 };
 706 # define register_irqsoff(trace) register_tracer(&trace)
 707 #else
 708 # define register_irqsoff(trace) do { } while (0)
 709 #endif
 710
 711 #ifdef CONFIG_PREEMPT_TRACER
 712 static int preemptoff_tracer_init(struct trace_array *tr)
 713 {
 714         trace_type = TRACER_PREEMPT_OFF;
 715
 716         return __irqsoff_tracer_init(tr);
 717 }
 718
 719 static struct tracer preemptoff_tracer __read_mostly =
 720 {
 721         .name           = "preemptoff",
 722         .init           = preemptoff_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         .flag_changed   = irqsoff_flag_changed,
 730 #ifdef CONFIG_FTRACE_SELFTEST
 731         .selftest    = trace_selftest_startup_preemptoff,
 732 #endif
 733         .open           = irqsoff_trace_open,
 734         .close          = irqsoff_trace_close,
 735         .allow_instances = true,
 736         .use_max_tr     = true,
 737 };
 738 # define register_preemptoff(trace) register_tracer(&trace)
 739 #else
 740 # define register_preemptoff(trace) do { } while (0)
 741 #endif
 742
 743 #if defined(CONFIG_IRQSOFF_TRACER) && \
 744         defined(CONFIG_PREEMPT_TRACER)
 745
 746 static int preemptirqsoff_tracer_init(struct trace_array *tr)
 747 {
 748         trace_type = TRACER_IRQS_OFF | TRACER_PREEMPT_OFF;
 749
 750         return __irqsoff_tracer_init(tr);
 751 }
 752
 753 static struct tracer preemptirqsoff_tracer __read_mostly =
 754 {
 755         .name           = "preemptirqsoff",
 756         .init           = preemptirqsoff_tracer_init,
 757         .reset          = irqsoff_tracer_reset,
 758         .start          = irqsoff_tracer_start,
 759         .stop           = irqsoff_tracer_stop,
 760         .print_max      = true,
 761         .print_header   = irqsoff_print_header,
 762         .print_line     = irqsoff_print_line,
 763         .flag_changed   = irqsoff_flag_changed,
 764 #ifdef CONFIG_FTRACE_SELFTEST
 765         .selftest    = trace_selftest_startup_preemptirqsoff,
 766 #endif
 767         .open           = irqsoff_trace_open,
 768         .close          = irqsoff_trace_close,
 769         .allow_instances = true,
 770         .use_max_tr     = true,
 771 };
 772
 773 # define register_preemptirqsoff(trace) register_tracer(&trace)
 774 #else
 775 # define register_preemptirqsoff(trace) do { } while (0)
 776 #endif
 777
 778 __init static int init_irqsoff_tracer(void)
 779 {
 780         register_irqsoff(irqsoff_tracer);
 781         register_preemptoff(preemptoff_tracer);
 782         register_preemptirqsoff(preemptirqsoff_tracer);
 783
 784         return 0;
 785 }
 786 core_initcall(init_irqsoff_tracer);