Merge branch 'linus' into tracing/mmiotrace-mergefixups

[linux-2.6] / kernel / trace / trace_irqsoff.c

diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index 2dfebb67fdfbd6f790c22603782c03b87d441f7c..761f3ec66c501c857d67dcd305156c064518631f 100644 (file)
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -33,7 +33,7 @@ enum {
 static int trace_type __read_mostly;
 
 #ifdef CONFIG_PREEMPT_TRACER
-static inline int notrace
+static inline int
 preempt_trace(void)
 {
        return ((trace_type & TRACER_PREEMPT_OFF) && preempt_count());
@@ -43,7 +43,7 @@ preempt_trace(void)
 #endif
 
 #ifdef CONFIG_IRQSOFF_TRACER
-static inline int notrace
+static inline int
 irq_trace(void)
 {
        return ((trace_type & TRACER_IRQS_OFF) &&
@@ -67,7 +67,7 @@ static __cacheline_aligned_in_smp     unsigned long max_sequence;
 /*
  * irqsoff uses its own tracer function to keep the overhead down:
  */
-static void notrace
+static void
 irqsoff_tracer_call(unsigned long ip, unsigned long parent_ip)
 {
        struct trace_array *tr = irqsoff_trace;
@@ -95,7 +95,7 @@ irqsoff_tracer_call(unsigned long ip, unsigned long parent_ip)
        disabled = atomic_inc_return(&data->disabled);
 
        if (likely(disabled == 1))
-               ftrace(tr, data, ip, parent_ip, flags);
+               trace_function(tr, data, ip, parent_ip, flags);
 
        atomic_dec(&data->disabled);
 }
@@ -109,7 +109,7 @@ static struct ftrace_ops trace_ops __read_mostly =
 /*
  * Should this new latency be reported/recorded?
  */
-static int notrace report_latency(cycle_t delta)
+static int report_latency(cycle_t delta)
 {
        if (tracing_thresh) {
                if (delta < tracing_thresh)
@@ -121,7 +121,7 @@ static int notrace report_latency(cycle_t delta)
        return 1;
 }
 
-static void notrace
+static void
 check_critical_timing(struct trace_array *tr,
                      struct trace_array_cpu *data,
                      unsigned long parent_ip,
@@ -136,7 +136,7 @@ check_critical_timing(struct trace_array *tr,
         * as long as possible:
         */
        T0 = data->preempt_timestamp;
-       T1 = now(cpu);
+       T1 = ftrace_now(cpu);
        delta = T1-T0;
 
        local_save_flags(flags);
@@ -150,7 +150,7 @@ check_critical_timing(struct trace_array *tr,
        if (!report_latency(delta))
                goto out_unlock;
 
-       ftrace(tr, data, CALLER_ADDR0, parent_ip, flags);
+       trace_function(tr, data, CALLER_ADDR0, parent_ip, flags);
 
        latency = nsecs_to_usecs(delta);
 
@@ -165,18 +165,20 @@ check_critical_timing(struct trace_array *tr,
 
        update_max_tr_single(tr, current, cpu);
 
-       if (tracing_thresh) {
-               printk(KERN_INFO "(%16s-%-5d|#%d):"
-                       " %lu us critical section violates %lu us threshold.\n",
-                               current->comm, current->pid,
-                               raw_smp_processor_id(),
-                               latency, nsecs_to_usecs(tracing_thresh));
-       } else {
-               printk(KERN_INFO "(%16s-%-5d|#%d):"
-                      " new %lu us maximum-latency critical section.\n",
-                               current->comm, current->pid,
-                               raw_smp_processor_id(),
-                               latency);
+       if (!runqueue_is_locked()) {
+               if (tracing_thresh) {
+                       printk(KERN_INFO "(%16s-%-5d|#%d): %lu us critical"
+                              " section violates %lu us threshold.\n",
+                              current->comm, current->pid,
+                              raw_smp_processor_id(),
+                              latency, nsecs_to_usecs(tracing_thresh));
+               } else {
+                       printk(KERN_INFO "(%16s-%-5d|#%d): new %lu us"
+                              " maximum-latency critical section.\n",
+                              current->comm, current->pid,
+                              raw_smp_processor_id(),
+                              latency);
+               }
        }
 
        max_sequence++;
@@ -186,12 +188,12 @@ out_unlock:
 
 out:
        data->critical_sequence = max_sequence;
-       data->preempt_timestamp = now(cpu);
+       data->preempt_timestamp = ftrace_now(cpu);
        tracing_reset(data);
-       ftrace(tr, data, CALLER_ADDR0, parent_ip, flags);
+       trace_function(tr, data, CALLER_ADDR0, parent_ip, flags);
 }
 
-static inline void notrace
+static inline void
 start_critical_timing(unsigned long ip, unsigned long parent_ip)
 {
        int cpu;
@@ -202,33 +204,33 @@ start_critical_timing(unsigned long ip, unsigned long parent_ip)
        if (likely(!tracer_enabled))
                return;
 
-       if (__get_cpu_var(tracing_cpu))
+       cpu = raw_smp_processor_id();
+
+       if (per_cpu(tracing_cpu, cpu))
                return;
 
-       cpu = raw_smp_processor_id();
        data = tr->data[cpu];
 
-       if (unlikely(!data) || unlikely(!head_page(data)) ||
-           atomic_read(&data->disabled))
+       if (unlikely(!data) || atomic_read(&data->disabled))
                return;
 
        atomic_inc(&data->disabled);
 
        data->critical_sequence = max_sequence;
-       data->preempt_timestamp = now(cpu);
+       data->preempt_timestamp = ftrace_now(cpu);
        data->critical_start = parent_ip ? : ip;
        tracing_reset(data);
 
        local_save_flags(flags);
 
-       ftrace(tr, data, ip, parent_ip, flags);
+       trace_function(tr, data, ip, parent_ip, flags);
 
-       __get_cpu_var(tracing_cpu) = 1;
+       per_cpu(tracing_cpu, cpu) = 1;
 
        atomic_dec(&data->disabled);
 }
 
-static inline void notrace
+static inline void
 stop_critical_timing(unsigned long ip, unsigned long parent_ip)
 {
        int cpu;
@@ -236,16 +238,16 @@ stop_critical_timing(unsigned long ip, unsigned long parent_ip)
        struct trace_array_cpu *data;
        unsigned long flags;
 
+       cpu = raw_smp_processor_id();
        /* Always clear the tracing cpu on stopping the trace */
-       if (unlikely(__get_cpu_var(tracing_cpu)))
-               __get_cpu_var(tracing_cpu) = 0;
+       if (unlikely(per_cpu(tracing_cpu, cpu)))
+               per_cpu(tracing_cpu, cpu) = 0;
        else
                return;
 
        if (!tracer_enabled)
                return;
 
-       cpu = raw_smp_processor_id();
        data = tr->data[cpu];
 
        if (unlikely(!data) || unlikely(!head_page(data)) ||
@@ -253,21 +255,22 @@ stop_critical_timing(unsigned long ip, unsigned long parent_ip)
                return;
 
        atomic_inc(&data->disabled);
+
        local_save_flags(flags);
-       ftrace(tr, data, ip, parent_ip, flags);
+       trace_function(tr, data, ip, parent_ip, flags);
        check_critical_timing(tr, data, parent_ip ? : ip, cpu);
        data->critical_start = 0;
        atomic_dec(&data->disabled);
 }
 
 /* start and stop critical timings used to for stoppage (in idle) */
-void notrace start_critical_timings(void)
+void start_critical_timings(void)
 {
        if (preempt_trace() || irq_trace())
                start_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
 }
 
-void notrace stop_critical_timings(void)
+void stop_critical_timings(void)
 {
        if (preempt_trace() || irq_trace())
                stop_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
@@ -275,13 +278,13 @@ void notrace stop_critical_timings(void)
 
 #ifdef CONFIG_IRQSOFF_TRACER
 #ifdef CONFIG_PROVE_LOCKING
-void notrace time_hardirqs_on(unsigned long a0, unsigned long a1)
+void time_hardirqs_on(unsigned long a0, unsigned long a1)
 {
        if (!preempt_trace() && irq_trace())
                stop_critical_timing(a0, a1);
 }
 
-void notrace time_hardirqs_off(unsigned long a0, unsigned long a1)
+void time_hardirqs_off(unsigned long a0, unsigned long a1)
 {
        if (!preempt_trace() && irq_trace())
                start_critical_timing(a0, a1);
@@ -316,28 +319,28 @@ inline void print_irqtrace_events(struct task_struct *curr)
 /*
  * We are only interested in hardirq on/off events:
  */
-void notrace trace_hardirqs_on(void)
+void trace_hardirqs_on(void)
 {
        if (!preempt_trace() && irq_trace())
                stop_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
 }
 EXPORT_SYMBOL(trace_hardirqs_on);
 
-void notrace trace_hardirqs_off(void)
+void trace_hardirqs_off(void)
 {
        if (!preempt_trace() && irq_trace())
                start_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
 }
 EXPORT_SYMBOL(trace_hardirqs_off);
 
-void notrace trace_hardirqs_on_caller(unsigned long caller_addr)
+void trace_hardirqs_on_caller(unsigned long caller_addr)
 {
        if (!preempt_trace() && irq_trace())
                stop_critical_timing(CALLER_ADDR0, caller_addr);
 }
 EXPORT_SYMBOL(trace_hardirqs_on_caller);
 
-void notrace trace_hardirqs_off_caller(unsigned long caller_addr)
+void trace_hardirqs_off_caller(unsigned long caller_addr)
 {
        if (!preempt_trace() && irq_trace())
                start_critical_timing(CALLER_ADDR0, caller_addr);
@@ -348,12 +351,12 @@ EXPORT_SYMBOL(trace_hardirqs_off_caller);
 #endif /*  CONFIG_IRQSOFF_TRACER */
 
 #ifdef CONFIG_PREEMPT_TRACER
-void notrace trace_preempt_on(unsigned long a0, unsigned long a1)
+void trace_preempt_on(unsigned long a0, unsigned long a1)
 {
        stop_critical_timing(a0, a1);
 }
 
-void notrace trace_preempt_off(unsigned long a0, unsigned long a1)
+void trace_preempt_off(unsigned long a0, unsigned long a1)
 {
        start_critical_timing(a0, a1);
 }
@@ -374,7 +377,7 @@ static void stop_irqsoff_tracer(struct trace_array *tr)
 static void __irqsoff_tracer_init(struct trace_array *tr)
 {
        irqsoff_trace = tr;
-       /* make sure that the tracer is visibel */
+       /* make sure that the tracer is visible */
        smp_wmb();
 
        if (tr->ctrl)
@@ -395,14 +398,14 @@ static void irqsoff_tracer_ctrl_update(struct trace_array *tr)
                stop_irqsoff_tracer(tr);
 }
 
-static void notrace irqsoff_tracer_open(struct trace_iterator *iter)
+static void irqsoff_tracer_open(struct trace_iterator *iter)
 {
        /* stop the trace while dumping */
        if (iter->tr->ctrl)
                stop_irqsoff_tracer(iter->tr);
 }
 
-static void notrace irqsoff_tracer_close(struct trace_iterator *iter)
+static void irqsoff_tracer_close(struct trace_iterator *iter)
 {
        if (iter->tr->ctrl)
                start_irqsoff_tracer(iter->tr);