git.oblomov.eu Git - linux-2.6/blob - kernel/trace/trace_irqsoff.c

   1 /*
   2  * trace irqs off criticall 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 William Lee Irwin III
  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_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 #ifdef CONFIG_PREEMPT_TRACER
  36 static inline int
  37 preempt_trace(void)
  38 {
  39         return ((trace_type & TRACER_PREEMPT_OFF) && preempt_count());
  40 }
  41 #else
  42 # define preempt_trace() (0)
  43 #endif
  44
  45 #ifdef CONFIG_IRQSOFF_TRACER
  46 static inline int
  47 irq_trace(void)
  48 {
  49         return ((trace_type & TRACER_IRQS_OFF) &&
  50                 irqs_disabled());
  51 }
  52 #else
  53 # define irq_trace() (0)
  54 #endif
  55
  56 /*
  57  * Sequence count - we record it when starting a measurement and
  58  * skip the latency if the sequence has changed - some other section
  59  * did a maximum and could disturb our measurement with serial console
  60  * printouts, etc. Truly coinciding maximum latencies should be rare
  61  * and what happens together happens separately as well, so this doesnt
  62  * decrease the validity of the maximum found:
  63  */
  64 static __cacheline_aligned_in_smp       unsigned long max_sequence;
  65
  66 #ifdef CONFIG_FTRACE
  67 /*
  68  * irqsoff uses its own tracer function to keep the overhead down:
  69  */
  70 static void
  71 irqsoff_tracer_call(unsigned long ip, unsigned long parent_ip)
  72 {
  73         struct trace_array *tr = irqsoff_trace;
  74         struct trace_array_cpu *data;
  75         unsigned long flags;
  76         long disabled;
  77         int cpu;
  78
  79         /*
  80          * Does not matter if we preempt. We test the flags
  81          * afterward, to see if irqs are disabled or not.
  82          * If we preempt and get a false positive, the flags
  83          * test will fail.
  84          */
  85         cpu = raw_smp_processor_id();
  86         if (likely(!per_cpu(tracing_cpu, cpu)))
  87                 return;
  88
  89         local_save_flags(flags);
  90         /* slight chance to get a false positive on tracing_cpu */
  91         if (!irqs_disabled_flags(flags))
  92                 return;
  93
  94         data = tr->data[cpu];
  95         disabled = atomic_inc_return(&data->disabled);
  96
  97         if (likely(disabled == 1))
  98                 trace_function(tr, data, ip, parent_ip, flags);
  99
 100         atomic_dec(&data->disabled);
 101 }
 102
 103 static struct ftrace_ops trace_ops __read_mostly =
 104 {
 105         .func = irqsoff_tracer_call,
 106 };
 107 #endif /* CONFIG_FTRACE */
 108
 109 /*
 110  * Should this new latency be reported/recorded?
 111  */
 112 static int report_latency(cycle_t delta)
 113 {
 114         if (tracing_thresh) {
 115                 if (delta < tracing_thresh)
 116                         return 0;
 117         } else {
 118                 if (delta <= tracing_max_latency)
 119                         return 0;
 120         }
 121         return 1;
 122 }
 123
 124 static void
 125 check_critical_timing(struct trace_array *tr,
 126                       struct trace_array_cpu *data,
 127                       unsigned long parent_ip,
 128                       int cpu)
 129 {
 130         unsigned long latency, t0, t1;
 131         cycle_t T0, T1, delta;
 132         unsigned long flags;
 133
 134         /*
 135          * usecs conversion is slow so we try to delay the conversion
 136          * as long as possible:
 137          */
 138         T0 = data->preempt_timestamp;
 139         T1 = ftrace_now(cpu);
 140         delta = T1-T0;
 141
 142         local_save_flags(flags);
 143
 144         if (!report_latency(delta))
 145                 goto out;
 146
 147         spin_lock_irqsave(&max_trace_lock, flags);
 148
 149         /* check if we are still the max latency */
 150         if (!report_latency(delta))
 151                 goto out_unlock;
 152
 153         trace_function(tr, data, CALLER_ADDR0, parent_ip, flags);
 154
 155         latency = nsecs_to_usecs(delta);
 156
 157         if (data->critical_sequence != max_sequence)
 158                 goto out_unlock;
 159
 160         tracing_max_latency = delta;
 161         t0 = nsecs_to_usecs(T0);
 162         t1 = nsecs_to_usecs(T1);
 163
 164         data->critical_end = parent_ip;
 165
 166         update_max_tr_single(tr, current, cpu);
 167
 168         max_sequence++;
 169
 170 out_unlock:
 171         spin_unlock_irqrestore(&max_trace_lock, flags);
 172
 173 out:
 174         data->critical_sequence = max_sequence;
 175         data->preempt_timestamp = ftrace_now(cpu);
 176         tracing_reset(data);
 177         trace_function(tr, data, CALLER_ADDR0, parent_ip, flags);
 178 }
 179
 180 static inline void
 181 start_critical_timing(unsigned long ip, unsigned long parent_ip)
 182 {
 183         int cpu;
 184         struct trace_array *tr = irqsoff_trace;
 185         struct trace_array_cpu *data;
 186         unsigned long flags;
 187
 188         if (likely(!tracer_enabled))
 189                 return;
 190
 191         cpu = raw_smp_processor_id();
 192
 193         if (per_cpu(tracing_cpu, cpu))
 194                 return;
 195
 196         data = tr->data[cpu];
 197
 198         if (unlikely(!data) || atomic_read(&data->disabled))
 199                 return;
 200
 201         atomic_inc(&data->disabled);
 202
 203         data->critical_sequence = max_sequence;
 204         data->preempt_timestamp = ftrace_now(cpu);
 205         data->critical_start = parent_ip ? : ip;
 206         tracing_reset(data);
 207
 208         local_save_flags(flags);
 209
 210         trace_function(tr, data, ip, parent_ip, flags);
 211
 212         per_cpu(tracing_cpu, cpu) = 1;
 213
 214         atomic_dec(&data->disabled);
 215 }
 216
 217 static inline void
 218 stop_critical_timing(unsigned long ip, unsigned long parent_ip)
 219 {
 220         int cpu;
 221         struct trace_array *tr = irqsoff_trace;
 222         struct trace_array_cpu *data;
 223         unsigned long flags;
 224
 225         cpu = raw_smp_processor_id();
 226         /* Always clear the tracing cpu on stopping the trace */
 227         if (unlikely(per_cpu(tracing_cpu, cpu)))
 228                 per_cpu(tracing_cpu, cpu) = 0;
 229         else
 230                 return;
 231
 232         if (!tracer_enabled)
 233                 return;
 234
 235         data = tr->data[cpu];
 236
 237         if (unlikely(!data) || unlikely(!head_page(data)) ||
 238             !data->critical_start || atomic_read(&data->disabled))
 239                 return;
 240
 241         atomic_inc(&data->disabled);
 242
 243         local_save_flags(flags);
 244         trace_function(tr, data, ip, parent_ip, flags);
 245         check_critical_timing(tr, data, parent_ip ? : ip, cpu);
 246         data->critical_start = 0;
 247         atomic_dec(&data->disabled);
 248 }
 249
 250 /* start and stop critical timings used to for stoppage (in idle) */
 251 void start_critical_timings(void)
 252 {
 253         if (preempt_trace() || irq_trace())
 254                 start_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
 255 }
 256 EXPORT_SYMBOL_GPL(start_critical_timings);
 257
 258 void stop_critical_timings(void)
 259 {
 260         if (preempt_trace() || irq_trace())
 261                 stop_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
 262 }
 263 EXPORT_SYMBOL_GPL(stop_critical_timings);
 264
 265 #ifdef CONFIG_IRQSOFF_TRACER
 266 #ifdef CONFIG_PROVE_LOCKING
 267 void time_hardirqs_on(unsigned long a0, unsigned long a1)
 268 {
 269         if (!preempt_trace() && irq_trace())
 270                 stop_critical_timing(a0, a1);
 271 }
 272
 273 void time_hardirqs_off(unsigned long a0, unsigned long a1)
 274 {
 275         if (!preempt_trace() && irq_trace())
 276                 start_critical_timing(a0, a1);
 277 }
 278
 279 #else /* !CONFIG_PROVE_LOCKING */
 280
 281 /*
 282  * Stubs:
 283  */
 284
 285 void early_boot_irqs_off(void)
 286 {
 287 }
 288
 289 void early_boot_irqs_on(void)
 290 {
 291 }
 292
 293 void trace_softirqs_on(unsigned long ip)
 294 {
 295 }
 296
 297 void trace_softirqs_off(unsigned long ip)
 298 {
 299 }
 300
 301 inline void print_irqtrace_events(struct task_struct *curr)
 302 {
 303 }
 304
 305 /*
 306  * We are only interested in hardirq on/off events:
 307  */
 308 void trace_hardirqs_on(void)
 309 {
 310         if (!preempt_trace() && irq_trace())
 311                 stop_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
 312 }
 313 EXPORT_SYMBOL(trace_hardirqs_on);
 314
 315 void trace_hardirqs_off(void)
 316 {
 317         if (!preempt_trace() && irq_trace())
 318                 start_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
 319 }
 320 EXPORT_SYMBOL(trace_hardirqs_off);
 321
 322 void trace_hardirqs_on_caller(unsigned long caller_addr)
 323 {
 324         if (!preempt_trace() && irq_trace())
 325                 stop_critical_timing(CALLER_ADDR0, caller_addr);
 326 }
 327 EXPORT_SYMBOL(trace_hardirqs_on_caller);
 328
 329 void trace_hardirqs_off_caller(unsigned long caller_addr)
 330 {
 331         if (!preempt_trace() && irq_trace())
 332                 start_critical_timing(CALLER_ADDR0, caller_addr);
 333 }
 334 EXPORT_SYMBOL(trace_hardirqs_off_caller);
 335
 336 #endif /* CONFIG_PROVE_LOCKING */
 337 #endif /*  CONFIG_IRQSOFF_TRACER */
 338
 339 #ifdef CONFIG_PREEMPT_TRACER
 340 void trace_preempt_on(unsigned long a0, unsigned long a1)
 341 {
 342         if (preempt_trace())
 343                 stop_critical_timing(a0, a1);
 344 }
 345
 346 void trace_preempt_off(unsigned long a0, unsigned long a1)
 347 {
 348         if (preempt_trace())
 349                 start_critical_timing(a0, a1);
 350 }
 351 #endif /* CONFIG_PREEMPT_TRACER */
 352
 353 static void start_irqsoff_tracer(struct trace_array *tr)
 354 {
 355         register_ftrace_function(&trace_ops);
 356         tracer_enabled = 1;
 357 }
 358
 359 static void stop_irqsoff_tracer(struct trace_array *tr)
 360 {
 361         tracer_enabled = 0;
 362         unregister_ftrace_function(&trace_ops);
 363 }
 364
 365 static void __irqsoff_tracer_init(struct trace_array *tr)
 366 {
 367         irqsoff_trace = tr;
 368         /* make sure that the tracer is visible */
 369         smp_wmb();
 370
 371         if (tr->ctrl)
 372                 start_irqsoff_tracer(tr);
 373 }
 374
 375 static void irqsoff_tracer_reset(struct trace_array *tr)
 376 {
 377         if (tr->ctrl)
 378                 stop_irqsoff_tracer(tr);
 379 }
 380
 381 static void irqsoff_tracer_ctrl_update(struct trace_array *tr)
 382 {
 383         if (tr->ctrl)
 384                 start_irqsoff_tracer(tr);
 385         else
 386                 stop_irqsoff_tracer(tr);
 387 }
 388
 389 static void irqsoff_tracer_open(struct trace_iterator *iter)
 390 {
 391         /* stop the trace while dumping */
 392         if (iter->tr->ctrl)
 393                 stop_irqsoff_tracer(iter->tr);
 394 }
 395
 396 static void irqsoff_tracer_close(struct trace_iterator *iter)
 397 {
 398         if (iter->tr->ctrl)
 399                 start_irqsoff_tracer(iter->tr);
 400 }
 401
 402 #ifdef CONFIG_IRQSOFF_TRACER
 403 static void irqsoff_tracer_init(struct trace_array *tr)
 404 {
 405         trace_type = TRACER_IRQS_OFF;
 406
 407         __irqsoff_tracer_init(tr);
 408 }
 409 static struct tracer irqsoff_tracer __read_mostly =
 410 {
 411         .name           = "irqsoff",
 412         .init           = irqsoff_tracer_init,
 413         .reset          = irqsoff_tracer_reset,
 414         .open           = irqsoff_tracer_open,
 415         .close          = irqsoff_tracer_close,
 416         .ctrl_update    = irqsoff_tracer_ctrl_update,
 417         .print_max      = 1,
 418 #ifdef CONFIG_FTRACE_SELFTEST
 419         .selftest    = trace_selftest_startup_irqsoff,
 420 #endif
 421 };
 422 # define register_irqsoff(trace) register_tracer(&trace)
 423 #else
 424 # define register_irqsoff(trace) do { } while (0)
 425 #endif
 426
 427 #ifdef CONFIG_PREEMPT_TRACER
 428 static void preemptoff_tracer_init(struct trace_array *tr)
 429 {
 430         trace_type = TRACER_PREEMPT_OFF;
 431
 432         __irqsoff_tracer_init(tr);
 433 }
 434
 435 static struct tracer preemptoff_tracer __read_mostly =
 436 {
 437         .name           = "preemptoff",
 438         .init           = preemptoff_tracer_init,
 439         .reset          = irqsoff_tracer_reset,
 440         .open           = irqsoff_tracer_open,
 441         .close          = irqsoff_tracer_close,
 442         .ctrl_update    = irqsoff_tracer_ctrl_update,
 443         .print_max      = 1,
 444 #ifdef CONFIG_FTRACE_SELFTEST
 445         .selftest    = trace_selftest_startup_preemptoff,
 446 #endif
 447 };
 448 # define register_preemptoff(trace) register_tracer(&trace)
 449 #else
 450 # define register_preemptoff(trace) do { } while (0)
 451 #endif
 452
 453 #if defined(CONFIG_IRQSOFF_TRACER) && \
 454         defined(CONFIG_PREEMPT_TRACER)
 455
 456 static void preemptirqsoff_tracer_init(struct trace_array *tr)
 457 {
 458         trace_type = TRACER_IRQS_OFF | TRACER_PREEMPT_OFF;
 459
 460         __irqsoff_tracer_init(tr);
 461 }
 462
 463 static struct tracer preemptirqsoff_tracer __read_mostly =
 464 {
 465         .name           = "preemptirqsoff",
 466         .init           = preemptirqsoff_tracer_init,
 467         .reset          = irqsoff_tracer_reset,
 468         .open           = irqsoff_tracer_open,
 469         .close          = irqsoff_tracer_close,
 470         .ctrl_update    = irqsoff_tracer_ctrl_update,
 471         .print_max      = 1,
 472 #ifdef CONFIG_FTRACE_SELFTEST
 473         .selftest    = trace_selftest_startup_preemptirqsoff,
 474 #endif
 475 };
 476
 477 # define register_preemptirqsoff(trace) register_tracer(&trace)
 478 #else
 479 # define register_preemptirqsoff(trace) do { } while (0)
 480 #endif
 481
 482 __init static int init_irqsoff_tracer(void)
 483 {
 484         register_irqsoff(irqsoff_tracer);
 485         register_preemptoff(preemptoff_tracer);
 486         register_preemptirqsoff(preemptirqsoff_tracer);
 487
 488         return 0;
 489 }
 490 device_initcall(init_irqsoff_tracer);