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