kernel/trace/trace_sched_wakeup.c

   1 /*
   2  * trace task wakeup timings
   3  *
   4  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
   5  * Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>
   6  *
   7  * Based on code from the latency_tracer, that is:
   8  *
   9  *  Copyright (C) 2004-2006 Ingo Molnar
  10  *  Copyright (C) 2004 Nadia Yvette Chambers
  11  */
  12 #include <linux/module.h>
  13 #include <linux/kallsyms.h>
  14 #include <linux/uaccess.h>
  15 #include <linux/ftrace.h>
  16 #include <linux/sched/rt.h>
  17 #include <linux/sched/deadline.h>
  18 #include <trace/events/sched.h>
  19 #include "trace.h"
  20
  21 static struct trace_array       *wakeup_trace;
  22 static int __read_mostly        tracer_enabled;
  23
  24 static struct task_struct       *wakeup_task;
  25 static int                      wakeup_cpu;
  26 static int                      wakeup_current_cpu;
  27 static unsigned                 wakeup_prio = -1;
  28 static int                      wakeup_rt;
  29 static int                      wakeup_dl;
  30 static int                      tracing_dl = 0;
  31
  32 static arch_spinlock_t wakeup_lock =
  33         (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
  34
  35 static void wakeup_reset(struct trace_array *tr);
  36 static void __wakeup_reset(struct trace_array *tr);
  37
  38 static int save_flags;
  39
  40 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
  41 static int wakeup_display_graph(struct trace_array *tr, int set);
  42 # define is_graph(tr) ((tr)->trace_flags & TRACE_ITER_DISPLAY_GRAPH)
  43 #else
  44 static inline int wakeup_display_graph(struct trace_array *tr, int set)
  45 {
  46         return 0;
  47 }
  48 # define is_graph(tr) false
  49 #endif
  50
  51
  52 #ifdef CONFIG_FUNCTION_TRACER
  53
  54 static int wakeup_graph_entry(struct ftrace_graph_ent *trace);
  55 static void wakeup_graph_return(struct ftrace_graph_ret *trace);
  56
  57 static bool function_enabled;
  58
  59 /*
  60  * Prologue for the wakeup function tracers.
  61  *
  62  * Returns 1 if it is OK to continue, and preemption
  63  *            is disabled and data->disabled is incremented.
  64  *         0 if the trace is to be ignored, and preemption
  65  *            is not disabled and data->disabled is
  66  *            kept the same.
  67  *
  68  * Note, this function is also used outside this ifdef but
  69  *  inside the #ifdef of the function graph tracer below.
  70  *  This is OK, since the function graph tracer is
  71  *  dependent on the function tracer.
  72  */
  73 static int
  74 func_prolog_preempt_disable(struct trace_array *tr,
  75                             struct trace_array_cpu **data,
  76                             int *pc)
  77 {
  78         long disabled;
  79         int cpu;
  80
  81         if (likely(!wakeup_task))
  82                 return 0;
  83
  84         *pc = preempt_count();
  85         preempt_disable_notrace();
  86
  87         cpu = raw_smp_processor_id();
  88         if (cpu != wakeup_current_cpu)
  89                 goto out_enable;
  90
  91         *data = per_cpu_ptr(tr->trace_buffer.data, cpu);
  92         disabled = atomic_inc_return(&(*data)->disabled);
  93         if (unlikely(disabled != 1))
  94                 goto out;
  95
  96         return 1;
  97
  98 out:
  99         atomic_dec(&(*data)->disabled);
 100
 101 out_enable:
 102         preempt_enable_notrace();
 103         return 0;
 104 }
 105
 106 /*
 107  * wakeup uses its own tracer function to keep the overhead down:
 108  */
 109 static void
 110 wakeup_tracer_call(unsigned long ip, unsigned long parent_ip,
 111                    struct ftrace_ops *op, struct pt_regs *pt_regs)
 112 {
 113         struct trace_array *tr = wakeup_trace;
 114         struct trace_array_cpu *data;
 115         unsigned long flags;
 116         int pc;
 117
 118         if (!func_prolog_preempt_disable(tr, &data, &pc))
 119                 return;
 120
 121         local_irq_save(flags);
 122         trace_function(tr, ip, parent_ip, flags, pc);
 123         local_irq_restore(flags);
 124
 125         atomic_dec(&data->disabled);
 126         preempt_enable_notrace();
 127 }
 128
 129 static int register_wakeup_function(struct trace_array *tr, int graph, int set)
 130 {
 131         int ret;
 132
 133         /* 'set' is set if TRACE_ITER_FUNCTION is about to be set */
 134         if (function_enabled || (!set && !(tr->trace_flags & TRACE_ITER_FUNCTION)))
 135                 return 0;
 136
 137         if (graph)
 138                 ret = register_ftrace_graph(&wakeup_graph_return,
 139                                             &wakeup_graph_entry);
 140         else
 141                 ret = register_ftrace_function(tr->ops);
 142
 143         if (!ret)
 144                 function_enabled = true;
 145
 146         return ret;
 147 }
 148
 149 static void unregister_wakeup_function(struct trace_array *tr, int graph)
 150 {
 151         if (!function_enabled)
 152                 return;
 153
 154         if (graph)
 155                 unregister_ftrace_graph();
 156         else
 157                 unregister_ftrace_function(tr->ops);
 158
 159         function_enabled = false;
 160 }
 161
 162 static int wakeup_function_set(struct trace_array *tr, u32 mask, int set)
 163 {
 164         if (!(mask & TRACE_ITER_FUNCTION))
 165                 return 0;
 166
 167         if (set)
 168                 register_wakeup_function(tr, is_graph(tr), 1);
 169         else
 170                 unregister_wakeup_function(tr, is_graph(tr));
 171         return 1;
 172 }
 173 #else
 174 static int register_wakeup_function(struct trace_array *tr, int graph, int set)
 175 {
 176         return 0;
 177 }
 178 static void unregister_wakeup_function(struct trace_array *tr, int graph) { }
 179 static int wakeup_function_set(struct trace_array *tr, u32 mask, int set)
 180 {
 181         return 0;
 182 }
 183 #endif /* CONFIG_FUNCTION_TRACER */
 184
 185 static int wakeup_flag_changed(struct trace_array *tr, u32 mask, int set)
 186 {
 187         struct tracer *tracer = tr->current_trace;
 188
 189         if (wakeup_function_set(tr, mask, set))
 190                 return 0;
 191
 192 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 193         if (mask & TRACE_ITER_DISPLAY_GRAPH)
 194                 return wakeup_display_graph(tr, set);
 195 #endif
 196
 197         return trace_keep_overwrite(tracer, mask, set);
 198 }
 199
 200 static int start_func_tracer(struct trace_array *tr, int graph)
 201 {
 202         int ret;
 203
 204         ret = register_wakeup_function(tr, graph, 0);
 205
 206         if (!ret && tracing_is_enabled())
 207                 tracer_enabled = 1;
 208         else
 209                 tracer_enabled = 0;
 210
 211         return ret;
 212 }
 213
 214 static void stop_func_tracer(struct trace_array *tr, int graph)
 215 {
 216         tracer_enabled = 0;
 217
 218         unregister_wakeup_function(tr, graph);
 219 }
 220
 221 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 222 static int wakeup_display_graph(struct trace_array *tr, int set)
 223 {
 224         if (!(is_graph(tr) ^ set))
 225                 return 0;
 226
 227         stop_func_tracer(tr, !set);
 228
 229         wakeup_reset(wakeup_trace);
 230         tr->max_latency = 0;
 231
 232         return start_func_tracer(tr, set);
 233 }
 234
 235 static int wakeup_graph_entry(struct ftrace_graph_ent *trace)
 236 {
 237         struct trace_array *tr = wakeup_trace;
 238         struct trace_array_cpu *data;
 239         unsigned long flags;
 240         int pc, ret = 0;
 241
 242         if (!func_prolog_preempt_disable(tr, &data, &pc))
 243                 return 0;
 244
 245         local_save_flags(flags);
 246         ret = __trace_graph_entry(tr, trace, flags, pc);
 247         atomic_dec(&data->disabled);
 248         preempt_enable_notrace();
 249
 250         return ret;
 251 }
 252
 253 static void wakeup_graph_return(struct ftrace_graph_ret *trace)
 254 {
 255         struct trace_array *tr = wakeup_trace;
 256         struct trace_array_cpu *data;
 257         unsigned long flags;
 258         int pc;
 259
 260         if (!func_prolog_preempt_disable(tr, &data, &pc))
 261                 return;
 262
 263         local_save_flags(flags);
 264         __trace_graph_return(tr, trace, flags, pc);
 265         atomic_dec(&data->disabled);
 266
 267         preempt_enable_notrace();
 268         return;
 269 }
 270
 271 static void wakeup_trace_open(struct trace_iterator *iter)
 272 {
 273         if (is_graph(iter->tr))
 274                 graph_trace_open(iter);
 275 }
 276
 277 static void wakeup_trace_close(struct trace_iterator *iter)
 278 {
 279         if (iter->private)
 280                 graph_trace_close(iter);
 281 }
 282
 283 #define GRAPH_TRACER_FLAGS (TRACE_GRAPH_PRINT_PROC | \
 284                             TRACE_GRAPH_PRINT_ABS_TIME | \
 285                             TRACE_GRAPH_PRINT_DURATION)
 286
 287 static enum print_line_t wakeup_print_line(struct trace_iterator *iter)
 288 {
 289         /*
 290          * In graph mode call the graph tracer output function,
 291          * otherwise go with the TRACE_FN event handler
 292          */
 293         if (is_graph(iter->tr))
 294                 return print_graph_function_flags(iter, GRAPH_TRACER_FLAGS);
 295
 296         return TRACE_TYPE_UNHANDLED;
 297 }
 298
 299 static void wakeup_print_header(struct seq_file *s)
 300 {
 301         if (is_graph(wakeup_trace))
 302                 print_graph_headers_flags(s, GRAPH_TRACER_FLAGS);
 303         else
 304                 trace_default_header(s);
 305 }
 306
 307 static void
 308 __trace_function(struct trace_array *tr,
 309                  unsigned long ip, unsigned long parent_ip,
 310                  unsigned long flags, int pc)
 311 {
 312         if (is_graph(tr))
 313                 trace_graph_function(tr, ip, parent_ip, flags, pc);
 314         else
 315                 trace_function(tr, ip, parent_ip, flags, pc);
 316 }
 317 #else
 318 #define __trace_function trace_function
 319
 320 static enum print_line_t wakeup_print_line(struct trace_iterator *iter)
 321 {
 322         return TRACE_TYPE_UNHANDLED;
 323 }
 324
 325 static void wakeup_trace_open(struct trace_iterator *iter) { }
 326 static void wakeup_trace_close(struct trace_iterator *iter) { }
 327
 328 #ifdef CONFIG_FUNCTION_TRACER
 329 static int wakeup_graph_entry(struct ftrace_graph_ent *trace)
 330 {
 331         return -1;
 332 }
 333 static void wakeup_graph_return(struct ftrace_graph_ret *trace) { }
 334 static void wakeup_print_header(struct seq_file *s)
 335 {
 336         trace_default_header(s);
 337 }
 338 #else
 339 static void wakeup_print_header(struct seq_file *s)
 340 {
 341         trace_latency_header(s);
 342 }
 343 #endif /* CONFIG_FUNCTION_TRACER */
 344 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 345
 346 /*
 347  * Should this new latency be reported/recorded?
 348  */
 349 static bool report_latency(struct trace_array *tr, cycle_t delta)
 350 {
 351         if (tracing_thresh) {
 352                 if (delta < tracing_thresh)
 353                         return false;
 354         } else {
 355                 if (delta <= tr->max_latency)
 356                         return false;
 357         }
 358         return true;
 359 }
 360
 361 static void
 362 probe_wakeup_migrate_task(void *ignore, struct task_struct *task, int cpu)
 363 {
 364         if (task != wakeup_task)
 365                 return;
 366
 367         wakeup_current_cpu = cpu;
 368 }
 369
 370 static void
 371 tracing_sched_switch_trace(struct trace_array *tr,
 372                            struct task_struct *prev,
 373                            struct task_struct *next,
 374                            unsigned long flags, int pc)
 375 {
 376         struct trace_event_call *call = &event_context_switch;
 377         struct ring_buffer *buffer = tr->trace_buffer.buffer;
 378         struct ring_buffer_event *event;
 379         struct ctx_switch_entry *entry;
 380
 381         event = trace_buffer_lock_reserve(buffer, TRACE_CTX,
 382                                           sizeof(*entry), flags, pc);
 383         if (!event)
 384                 return;
 385         entry   = ring_buffer_event_data(event);
 386         entry->prev_pid                 = prev->pid;
 387         entry->prev_prio                = prev->prio;
 388         entry->prev_state               = prev->state;
 389         entry->next_pid                 = next->pid;
 390         entry->next_prio                = next->prio;
 391         entry->next_state               = next->state;
 392         entry->next_cpu = task_cpu(next);
 393
 394         if (!call_filter_check_discard(call, entry, buffer, event))
 395                 trace_buffer_unlock_commit(tr, buffer, event, flags, pc);
 396 }
 397
 398 static void
 399 tracing_sched_wakeup_trace(struct trace_array *tr,
 400                            struct task_struct *wakee,
 401                            struct task_struct *curr,
 402                            unsigned long flags, int pc)
 403 {
 404         struct trace_event_call *call = &event_wakeup;
 405         struct ring_buffer_event *event;
 406         struct ctx_switch_entry *entry;
 407         struct ring_buffer *buffer = tr->trace_buffer.buffer;
 408
 409         event = trace_buffer_lock_reserve(buffer, TRACE_WAKE,
 410                                           sizeof(*entry), flags, pc);
 411         if (!event)
 412                 return;
 413         entry   = ring_buffer_event_data(event);
 414         entry->prev_pid                 = curr->pid;
 415         entry->prev_prio                = curr->prio;
 416         entry->prev_state               = curr->state;
 417         entry->next_pid                 = wakee->pid;
 418         entry->next_prio                = wakee->prio;
 419         entry->next_state               = wakee->state;
 420         entry->next_cpu                 = task_cpu(wakee);
 421
 422         if (!call_filter_check_discard(call, entry, buffer, event))
 423                 trace_buffer_unlock_commit(tr, buffer, event, flags, pc);
 424 }
 425
 426 static void notrace
 427 probe_wakeup_sched_switch(void *ignore, bool preempt,
 428                           struct task_struct *prev, struct task_struct *next)
 429 {
 430         struct trace_array_cpu *data;
 431         cycle_t T0, T1, delta;
 432         unsigned long flags;
 433         long disabled;
 434         int cpu;
 435         int pc;
 436
 437         tracing_record_cmdline(prev);
 438
 439         if (unlikely(!tracer_enabled))
 440                 return;
 441
 442         /*
 443          * When we start a new trace, we set wakeup_task to NULL
 444          * and then set tracer_enabled = 1. We want to make sure
 445          * that another CPU does not see the tracer_enabled = 1
 446          * and the wakeup_task with an older task, that might
 447          * actually be the same as next.
 448          */
 449         smp_rmb();
 450
 451         if (next != wakeup_task)
 452                 return;
 453
 454         pc = preempt_count();
 455
 456         /* disable local data, not wakeup_cpu data */
 457         cpu = raw_smp_processor_id();
 458         disabled = atomic_inc_return(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
 459         if (likely(disabled != 1))
 460                 goto out;
 461
 462         local_irq_save(flags);
 463         arch_spin_lock(&wakeup_lock);
 464
 465         /* We could race with grabbing wakeup_lock */
 466         if (unlikely(!tracer_enabled || next != wakeup_task))
 467                 goto out_unlock;
 468
 469         /* The task we are waiting for is waking up */
 470         data = per_cpu_ptr(wakeup_trace->trace_buffer.data, wakeup_cpu);
 471
 472         __trace_function(wakeup_trace, CALLER_ADDR0, CALLER_ADDR1, flags, pc);
 473         tracing_sched_switch_trace(wakeup_trace, prev, next, flags, pc);
 474
 475         T0 = data->preempt_timestamp;
 476         T1 = ftrace_now(cpu);
 477         delta = T1-T0;
 478
 479         if (!report_latency(wakeup_trace, delta))
 480                 goto out_unlock;
 481
 482         if (likely(!is_tracing_stopped())) {
 483                 wakeup_trace->max_latency = delta;
 484                 update_max_tr(wakeup_trace, wakeup_task, wakeup_cpu);
 485         }
 486
 487 out_unlock:
 488         __wakeup_reset(wakeup_trace);
 489         arch_spin_unlock(&wakeup_lock);
 490         local_irq_restore(flags);
 491 out:
 492         atomic_dec(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
 493 }
 494
 495 static void __wakeup_reset(struct trace_array *tr)
 496 {
 497         wakeup_cpu = -1;
 498         wakeup_prio = -1;
 499         tracing_dl = 0;
 500
 501         if (wakeup_task)
 502                 put_task_struct(wakeup_task);
 503
 504         wakeup_task = NULL;
 505 }
 506
 507 static void wakeup_reset(struct trace_array *tr)
 508 {
 509         unsigned long flags;
 510
 511         tracing_reset_online_cpus(&tr->trace_buffer);
 512
 513         local_irq_save(flags);
 514         arch_spin_lock(&wakeup_lock);
 515         __wakeup_reset(tr);
 516         arch_spin_unlock(&wakeup_lock);
 517         local_irq_restore(flags);
 518 }
 519
 520 static void
 521 probe_wakeup(void *ignore, struct task_struct *p)
 522 {
 523         struct trace_array_cpu *data;
 524         int cpu = smp_processor_id();
 525         unsigned long flags;
 526         long disabled;
 527         int pc;
 528
 529         if (likely(!tracer_enabled))
 530                 return;
 531
 532         tracing_record_cmdline(p);
 533         tracing_record_cmdline(current);
 534
 535         /*
 536          * Semantic is like this:
 537          *  - wakeup tracer handles all tasks in the system, independently
 538          *    from their scheduling class;
 539          *  - wakeup_rt tracer handles tasks belonging to sched_dl and
 540          *    sched_rt class;
 541          *  - wakeup_dl handles tasks belonging to sched_dl class only.
 542          */
 543         if (tracing_dl || (wakeup_dl && !dl_task(p)) ||
 544             (wakeup_rt && !dl_task(p) && !rt_task(p)) ||
 545             (!dl_task(p) && (p->prio >= wakeup_prio || p->prio >= current->prio)))
 546                 return;
 547
 548         pc = preempt_count();
 549         disabled = atomic_inc_return(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
 550         if (unlikely(disabled != 1))
 551                 goto out;
 552
 553         /* interrupts should be off from try_to_wake_up */
 554         arch_spin_lock(&wakeup_lock);
 555
 556         /* check for races. */
 557         if (!tracer_enabled || tracing_dl ||
 558             (!dl_task(p) && p->prio >= wakeup_prio))
 559                 goto out_locked;
 560
 561         /* reset the trace */
 562         __wakeup_reset(wakeup_trace);
 563
 564         wakeup_cpu = task_cpu(p);
 565         wakeup_current_cpu = wakeup_cpu;
 566         wakeup_prio = p->prio;
 567
 568         /*
 569          * Once you start tracing a -deadline task, don't bother tracing
 570          * another task until the first one wakes up.
 571          */
 572         if (dl_task(p))
 573                 tracing_dl = 1;
 574         else
 575                 tracing_dl = 0;
 576
 577         wakeup_task = p;
 578         get_task_struct(wakeup_task);
 579
 580         local_save_flags(flags);
 581
 582         data = per_cpu_ptr(wakeup_trace->trace_buffer.data, wakeup_cpu);
 583         data->preempt_timestamp = ftrace_now(cpu);
 584         tracing_sched_wakeup_trace(wakeup_trace, p, current, flags, pc);
 585
 586         /*
 587          * We must be careful in using CALLER_ADDR2. But since wake_up
 588          * is not called by an assembly function  (where as schedule is)
 589          * it should be safe to use it here.
 590          */
 591         __trace_function(wakeup_trace, CALLER_ADDR1, CALLER_ADDR2, flags, pc);
 592
 593 out_locked:
 594         arch_spin_unlock(&wakeup_lock);
 595 out:
 596         atomic_dec(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
 597 }
 598
 599 static void start_wakeup_tracer(struct trace_array *tr)
 600 {
 601         int ret;
 602
 603         ret = register_trace_sched_wakeup(probe_wakeup, NULL);
 604         if (ret) {
 605                 pr_info("wakeup trace: Couldn't activate tracepoint"
 606                         " probe to kernel_sched_wakeup\n");
 607                 return;
 608         }
 609
 610         ret = register_trace_sched_wakeup_new(probe_wakeup, NULL);
 611         if (ret) {
 612                 pr_info("wakeup trace: Couldn't activate tracepoint"
 613                         " probe to kernel_sched_wakeup_new\n");
 614                 goto fail_deprobe;
 615         }
 616
 617         ret = register_trace_sched_switch(probe_wakeup_sched_switch, NULL);
 618         if (ret) {
 619                 pr_info("sched trace: Couldn't activate tracepoint"
 620                         " probe to kernel_sched_switch\n");
 621                 goto fail_deprobe_wake_new;
 622         }
 623
 624         ret = register_trace_sched_migrate_task(probe_wakeup_migrate_task, NULL);
 625         if (ret) {
 626                 pr_info("wakeup trace: Couldn't activate tracepoint"
 627                         " probe to kernel_sched_migrate_task\n");
 628                 return;
 629         }
 630
 631         wakeup_reset(tr);
 632
 633         /*
 634          * Don't let the tracer_enabled = 1 show up before
 635          * the wakeup_task is reset. This may be overkill since
 636          * wakeup_reset does a spin_unlock after setting the
 637          * wakeup_task to NULL, but I want to be safe.
 638          * This is a slow path anyway.
 639          */
 640         smp_wmb();
 641
 642         if (start_func_tracer(tr, is_graph(tr)))
 643                 printk(KERN_ERR "failed to start wakeup tracer\n");
 644
 645         return;
 646 fail_deprobe_wake_new:
 647         unregister_trace_sched_wakeup_new(probe_wakeup, NULL);
 648 fail_deprobe:
 649         unregister_trace_sched_wakeup(probe_wakeup, NULL);
 650 }
 651
 652 static void stop_wakeup_tracer(struct trace_array *tr)
 653 {
 654         tracer_enabled = 0;
 655         stop_func_tracer(tr, is_graph(tr));
 656         unregister_trace_sched_switch(probe_wakeup_sched_switch, NULL);
 657         unregister_trace_sched_wakeup_new(probe_wakeup, NULL);
 658         unregister_trace_sched_wakeup(probe_wakeup, NULL);
 659         unregister_trace_sched_migrate_task(probe_wakeup_migrate_task, NULL);
 660 }
 661
 662 static bool wakeup_busy;
 663
 664 static int __wakeup_tracer_init(struct trace_array *tr)
 665 {
 666         save_flags = tr->trace_flags;
 667
 668         /* non overwrite screws up the latency tracers */
 669         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, 1);
 670         set_tracer_flag(tr, TRACE_ITER_LATENCY_FMT, 1);
 671
 672         tr->max_latency = 0;
 673         wakeup_trace = tr;
 674         ftrace_init_array_ops(tr, wakeup_tracer_call);
 675         start_wakeup_tracer(tr);
 676
 677         wakeup_busy = true;
 678         return 0;
 679 }
 680
 681 static int wakeup_tracer_init(struct trace_array *tr)
 682 {
 683         if (wakeup_busy)
 684                 return -EBUSY;
 685
 686         wakeup_dl = 0;
 687         wakeup_rt = 0;
 688         return __wakeup_tracer_init(tr);
 689 }
 690
 691 static int wakeup_rt_tracer_init(struct trace_array *tr)
 692 {
 693         if (wakeup_busy)
 694                 return -EBUSY;
 695
 696         wakeup_dl = 0;
 697         wakeup_rt = 1;
 698         return __wakeup_tracer_init(tr);
 699 }
 700
 701 static int wakeup_dl_tracer_init(struct trace_array *tr)
 702 {
 703         if (wakeup_busy)
 704                 return -EBUSY;
 705
 706         wakeup_dl = 1;
 707         wakeup_rt = 0;
 708         return __wakeup_tracer_init(tr);
 709 }
 710
 711 static void wakeup_tracer_reset(struct trace_array *tr)
 712 {
 713         int lat_flag = save_flags & TRACE_ITER_LATENCY_FMT;
 714         int overwrite_flag = save_flags & TRACE_ITER_OVERWRITE;
 715
 716         stop_wakeup_tracer(tr);
 717         /* make sure we put back any tasks we are tracing */
 718         wakeup_reset(tr);
 719
 720         set_tracer_flag(tr, TRACE_ITER_LATENCY_FMT, lat_flag);
 721         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, overwrite_flag);
 722         ftrace_reset_array_ops(tr);
 723         wakeup_busy = false;
 724 }
 725
 726 static void wakeup_tracer_start(struct trace_array *tr)
 727 {
 728         wakeup_reset(tr);
 729         tracer_enabled = 1;
 730 }
 731
 732 static void wakeup_tracer_stop(struct trace_array *tr)
 733 {
 734         tracer_enabled = 0;
 735 }
 736
 737 static struct tracer wakeup_tracer __read_mostly =
 738 {
 739         .name           = "wakeup",
 740         .init           = wakeup_tracer_init,
 741         .reset          = wakeup_tracer_reset,
 742         .start          = wakeup_tracer_start,
 743         .stop           = wakeup_tracer_stop,
 744         .print_max      = true,
 745         .print_header   = wakeup_print_header,
 746         .print_line     = wakeup_print_line,
 747         .flag_changed   = wakeup_flag_changed,
 748 #ifdef CONFIG_FTRACE_SELFTEST
 749         .selftest    = trace_selftest_startup_wakeup,
 750 #endif
 751         .open           = wakeup_trace_open,
 752         .close          = wakeup_trace_close,
 753         .allow_instances = true,
 754         .use_max_tr     = true,
 755 };
 756
 757 static struct tracer wakeup_rt_tracer __read_mostly =
 758 {
 759         .name           = "wakeup_rt",
 760         .init           = wakeup_rt_tracer_init,
 761         .reset          = wakeup_tracer_reset,
 762         .start          = wakeup_tracer_start,
 763         .stop           = wakeup_tracer_stop,
 764         .print_max      = true,
 765         .print_header   = wakeup_print_header,
 766         .print_line     = wakeup_print_line,
 767         .flag_changed   = wakeup_flag_changed,
 768 #ifdef CONFIG_FTRACE_SELFTEST
 769         .selftest    = trace_selftest_startup_wakeup,
 770 #endif
 771         .open           = wakeup_trace_open,
 772         .close          = wakeup_trace_close,
 773         .allow_instances = true,
 774         .use_max_tr     = true,
 775 };
 776
 777 static struct tracer wakeup_dl_tracer __read_mostly =
 778 {
 779         .name           = "wakeup_dl",
 780         .init           = wakeup_dl_tracer_init,
 781         .reset          = wakeup_tracer_reset,
 782         .start          = wakeup_tracer_start,
 783         .stop           = wakeup_tracer_stop,
 784         .print_max      = true,
 785         .print_header   = wakeup_print_header,
 786         .print_line     = wakeup_print_line,
 787         .flag_changed   = wakeup_flag_changed,
 788 #ifdef CONFIG_FTRACE_SELFTEST
 789         .selftest    = trace_selftest_startup_wakeup,
 790 #endif
 791         .open           = wakeup_trace_open,
 792         .close          = wakeup_trace_close,
 793         .use_max_tr     = true,
 794 };
 795
 796 __init static int init_wakeup_tracer(void)
 797 {
 798         int ret;
 799
 800         ret = register_tracer(&wakeup_tracer);
 801         if (ret)
 802                 return ret;
 803
 804         ret = register_tracer(&wakeup_rt_tracer);
 805         if (ret)
 806                 return ret;
 807
 808         ret = register_tracer(&wakeup_dl_tracer);
 809         if (ret)
 810                 return ret;
 811
 812         return 0;
 813 }
 814 core_initcall(init_wakeup_tracer);