kernel/trace/trace_sched_switch.c

   1 /*
   2  * trace context switch
   3  *
   4  * Copyright (C) 2007 Steven Rostedt <srostedt@redhat.com>
   5  *
   6  */
   7 #include <linux/module.h>
   8 #include <linux/fs.h>
   9 #include <linux/debugfs.h>
  10 #include <linux/kallsyms.h>
  11 #include <linux/uaccess.h>
  12 #include <linux/marker.h>
  13 #include <linux/ftrace.h>
  14
  15 #include "trace.h"
  16
  17 static struct trace_array       *ctx_trace;
  18 static int __read_mostly        tracer_enabled;
  19
  20 static void
  21 ctx_switch_func(void *__rq, struct task_struct *prev, struct task_struct *next)
  22 {
  23         struct trace_array *tr = ctx_trace;
  24         struct trace_array_cpu *data;
  25         unsigned long flags;
  26         long disabled;
  27         int cpu;
  28
  29         if (!tracer_enabled)
  30                 return;
  31
  32         local_irq_save(flags);
  33         cpu = raw_smp_processor_id();
  34         data = tr->data[cpu];
  35         disabled = atomic_inc_return(&data->disabled);
  36
  37         if (likely(disabled == 1)) {
  38                 tracing_sched_switch_trace(tr, data, prev, next, flags);
  39                 ftrace_all_fair_tasks(__rq, tr, data);
  40         }
  41
  42         atomic_dec(&data->disabled);
  43         local_irq_restore(flags);
  44 }
  45
  46 static void
  47 wakeup_func(void *__rq, struct task_struct *wakee, struct task_struct *curr)
  48 {
  49         struct trace_array *tr = ctx_trace;
  50         struct trace_array_cpu *data;
  51         unsigned long flags;
  52         long disabled;
  53         int cpu;
  54
  55         if (!tracer_enabled)
  56                 return;
  57
  58         local_irq_save(flags);
  59         cpu = raw_smp_processor_id();
  60         data = tr->data[cpu];
  61         disabled = atomic_inc_return(&data->disabled);
  62
  63         if (likely(disabled == 1)) {
  64                 tracing_sched_wakeup_trace(tr, data, wakee, curr, flags);
  65                 ftrace_all_fair_tasks(__rq, tr, data);
  66         }
  67
  68         atomic_dec(&data->disabled);
  69         local_irq_restore(flags);
  70 }
  71
  72 void
  73 ftrace_ctx_switch(void *__rq, struct task_struct *prev,
  74                   struct task_struct *next)
  75 {
  76         tracing_record_cmdline(prev);
  77
  78         /*
  79          * If tracer_switch_func only points to the local
  80          * switch func, it still needs the ptr passed to it.
  81          */
  82         ctx_switch_func(__rq, prev, next);
  83
  84         /*
  85          * Chain to the wakeup tracer (this is a NOP if disabled):
  86          */
  87         wakeup_sched_switch(prev, next);
  88 }
  89
  90 void
  91 ftrace_wake_up_task(void *__rq, struct task_struct *wakee,
  92                     struct task_struct *curr)
  93 {
  94         tracing_record_cmdline(curr);
  95
  96         wakeup_func(__rq, wakee, curr);
  97
  98         /*
  99          * Chain to the wakeup tracer (this is a NOP if disabled):
 100          */
 101         wakeup_sched_wakeup(wakee, curr);
 102 }
 103
 104 static void sched_switch_reset(struct trace_array *tr)
 105 {
 106         int cpu;
 107
 108         tr->time_start = ftrace_now(tr->cpu);
 109
 110         for_each_online_cpu(cpu)
 111                 tracing_reset(tr->data[cpu]);
 112 }
 113
 114 static void start_sched_trace(struct trace_array *tr)
 115 {
 116         sched_switch_reset(tr);
 117         tracer_enabled = 1;
 118 }
 119
 120 static void stop_sched_trace(struct trace_array *tr)
 121 {
 122         tracer_enabled = 0;
 123 }
 124
 125 static void sched_switch_trace_init(struct trace_array *tr)
 126 {
 127         ctx_trace = tr;
 128
 129         if (tr->ctrl)
 130                 start_sched_trace(tr);
 131 }
 132
 133 static void sched_switch_trace_reset(struct trace_array *tr)
 134 {
 135         if (tr->ctrl)
 136                 stop_sched_trace(tr);
 137 }
 138
 139 static void sched_switch_trace_ctrl_update(struct trace_array *tr)
 140 {
 141         /* When starting a new trace, reset the buffers */
 142         if (tr->ctrl)
 143                 start_sched_trace(tr);
 144         else
 145                 stop_sched_trace(tr);
 146 }
 147
 148 static struct tracer sched_switch_trace __read_mostly =
 149 {
 150         .name           = "sched_switch",
 151         .init           = sched_switch_trace_init,
 152         .reset          = sched_switch_trace_reset,
 153         .ctrl_update    = sched_switch_trace_ctrl_update,
 154 #ifdef CONFIG_FTRACE_SELFTEST
 155         .selftest    = trace_selftest_startup_sched_switch,
 156 #endif
 157 };
 158
 159 __init static int init_sched_switch_trace(void)
 160 {
 161         return register_tracer(&sched_switch_trace);
 162 }
 163 device_initcall(init_sched_switch_trace);