Merge tag 'clang-lto-v5.12-rc1-part2' of git://git.kernel.org/pub/scm/linux/kernel...

[linux-2.6-microblaze.git] / kernel / trace / trace_sched_wakeup.c

diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index c018106..e5778d1 100644 (file)
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -67,7 +67,7 @@ static bool function_enabled;
 static int
 func_prolog_preempt_disable(struct trace_array *tr,
                            struct trace_array_cpu **data,
-                           int *pc)
+                           unsigned int *trace_ctx)
 {
        long disabled;
        int cpu;
@@ -75,7 +75,7 @@ func_prolog_preempt_disable(struct trace_array *tr,
        if (likely(!wakeup_task))
                return 0;
 
-       *pc = preempt_count();
+       *trace_ctx = tracing_gen_ctx();
        preempt_disable_notrace();
 
        cpu = raw_smp_processor_id();
@@ -116,8 +116,8 @@ static int wakeup_graph_entry(struct ftrace_graph_ent *trace)
 {
        struct trace_array *tr = wakeup_trace;
        struct trace_array_cpu *data;
-       unsigned long flags;
-       int pc, ret = 0;
+       unsigned int trace_ctx;
+       int ret = 0;
 
        if (ftrace_graph_ignore_func(trace))
                return 0;
@@ -131,11 +131,10 @@ static int wakeup_graph_entry(struct ftrace_graph_ent *trace)
        if (ftrace_graph_notrace_addr(trace->func))
                return 1;
 
-       if (!func_prolog_preempt_disable(tr, &data, &pc))
+       if (!func_prolog_preempt_disable(tr, &data, &trace_ctx))
                return 0;
 
-       local_save_flags(flags);
-       ret = __trace_graph_entry(tr, trace, flags, pc);
+       ret = __trace_graph_entry(tr, trace, trace_ctx);
        atomic_dec(&data->disabled);
        preempt_enable_notrace();
 
@@ -146,16 +145,14 @@ static void wakeup_graph_return(struct ftrace_graph_ret *trace)
 {
        struct trace_array *tr = wakeup_trace;
        struct trace_array_cpu *data;
-       unsigned long flags;
-       int pc;
+       unsigned int trace_ctx;
 
        ftrace_graph_addr_finish(trace);
 
-       if (!func_prolog_preempt_disable(tr, &data, &pc))
+       if (!func_prolog_preempt_disable(tr, &data, &trace_ctx))
                return;
 
-       local_save_flags(flags);
-       __trace_graph_return(tr, trace, flags, pc);
+       __trace_graph_return(tr, trace, trace_ctx);
        atomic_dec(&data->disabled);
 
        preempt_enable_notrace();
@@ -217,13 +214,13 @@ wakeup_tracer_call(unsigned long ip, unsigned long parent_ip,
        struct trace_array *tr = wakeup_trace;
        struct trace_array_cpu *data;
        unsigned long flags;
-       int pc;
+       unsigned int trace_ctx;
 
-       if (!func_prolog_preempt_disable(tr, &data, &pc))
+       if (!func_prolog_preempt_disable(tr, &data, &trace_ctx))
                return;
 
        local_irq_save(flags);
-       trace_function(tr, ip, parent_ip, flags, pc);
+       trace_function(tr, ip, parent_ip, trace_ctx);
        local_irq_restore(flags);
 
        atomic_dec(&data->disabled);
@@ -303,12 +300,12 @@ static void wakeup_print_header(struct seq_file *s)
 static void
 __trace_function(struct trace_array *tr,
                 unsigned long ip, unsigned long parent_ip,
-                unsigned long flags, int pc)
+                unsigned int trace_ctx)
 {
        if (is_graph(tr))
-               trace_graph_function(tr, ip, parent_ip, flags, pc);
+               trace_graph_function(tr, ip, parent_ip, trace_ctx);
        else
-               trace_function(tr, ip, parent_ip, flags, pc);
+               trace_function(tr, ip, parent_ip, trace_ctx);
 }
 
 static int wakeup_flag_changed(struct trace_array *tr, u32 mask, int set)
@@ -375,7 +372,7 @@ static void
 tracing_sched_switch_trace(struct trace_array *tr,
                           struct task_struct *prev,
                           struct task_struct *next,
-                          unsigned long flags, int pc)
+                          unsigned int trace_ctx)
 {
        struct trace_event_call *call = &event_context_switch;
        struct trace_buffer *buffer = tr->array_buffer.buffer;
@@ -383,7 +380,7 @@ tracing_sched_switch_trace(struct trace_array *tr,
        struct ctx_switch_entry *entry;
 
        event = trace_buffer_lock_reserve(buffer, TRACE_CTX,
-                                         sizeof(*entry), flags, pc);
+                                         sizeof(*entry), trace_ctx);
        if (!event)
                return;
        entry   = ring_buffer_event_data(event);
@@ -396,14 +393,14 @@ tracing_sched_switch_trace(struct trace_array *tr,
        entry->next_cpu = task_cpu(next);
 
        if (!call_filter_check_discard(call, entry, buffer, event))
-               trace_buffer_unlock_commit(tr, buffer, event, flags, pc);
+               trace_buffer_unlock_commit(tr, buffer, event, trace_ctx);
 }
 
 static void
 tracing_sched_wakeup_trace(struct trace_array *tr,
                           struct task_struct *wakee,
                           struct task_struct *curr,
-                          unsigned long flags, int pc)
+                          unsigned int trace_ctx)
 {
        struct trace_event_call *call = &event_wakeup;
        struct ring_buffer_event *event;
@@ -411,7 +408,7 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
        struct trace_buffer *buffer = tr->array_buffer.buffer;
 
        event = trace_buffer_lock_reserve(buffer, TRACE_WAKE,
-                                         sizeof(*entry), flags, pc);
+                                         sizeof(*entry), trace_ctx);
        if (!event)
                return;
        entry   = ring_buffer_event_data(event);
@@ -424,7 +421,7 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
        entry->next_cpu                 = task_cpu(wakee);
 
        if (!call_filter_check_discard(call, entry, buffer, event))
-               trace_buffer_unlock_commit(tr, buffer, event, flags, pc);
+               trace_buffer_unlock_commit(tr, buffer, event, trace_ctx);
 }
 
 static void notrace
@@ -436,7 +433,7 @@ probe_wakeup_sched_switch(void *ignore, bool preempt,
        unsigned long flags;
        long disabled;
        int cpu;
-       int pc;
+       unsigned int trace_ctx;
 
        tracing_record_cmdline(prev);
 
@@ -455,8 +452,6 @@ probe_wakeup_sched_switch(void *ignore, bool preempt,
        if (next != wakeup_task)
                return;
 
-       pc = preempt_count();
-
        /* disable local data, not wakeup_cpu data */
        cpu = raw_smp_processor_id();
        disabled = atomic_inc_return(&per_cpu_ptr(wakeup_trace->array_buffer.data, cpu)->disabled);
@@ -464,6 +459,8 @@ probe_wakeup_sched_switch(void *ignore, bool preempt,
                goto out;
 
        local_irq_save(flags);
+       trace_ctx = tracing_gen_ctx_flags(flags);
+
        arch_spin_lock(&wakeup_lock);
 
        /* We could race with grabbing wakeup_lock */
@@ -473,9 +470,9 @@ probe_wakeup_sched_switch(void *ignore, bool preempt,
        /* The task we are waiting for is waking up */
        data = per_cpu_ptr(wakeup_trace->array_buffer.data, wakeup_cpu);
 
-       __trace_function(wakeup_trace, CALLER_ADDR0, CALLER_ADDR1, flags, pc);
-       tracing_sched_switch_trace(wakeup_trace, prev, next, flags, pc);
-       __trace_stack(wakeup_trace, flags, 0, pc);
+       __trace_function(wakeup_trace, CALLER_ADDR0, CALLER_ADDR1, trace_ctx);
+       tracing_sched_switch_trace(wakeup_trace, prev, next, trace_ctx);
+       __trace_stack(wakeup_trace, trace_ctx, 0);
 
        T0 = data->preempt_timestamp;
        T1 = ftrace_now(cpu);
@@ -527,9 +524,8 @@ probe_wakeup(void *ignore, struct task_struct *p)
 {
        struct trace_array_cpu *data;
        int cpu = smp_processor_id();
-       unsigned long flags;
        long disabled;
-       int pc;
+       unsigned int trace_ctx;
 
        if (likely(!tracer_enabled))
                return;
@@ -550,11 +546,12 @@ probe_wakeup(void *ignore, struct task_struct *p)
            (!dl_task(p) && (p->prio >= wakeup_prio || p->prio >= current->prio)))
                return;
 
-       pc = preempt_count();
        disabled = atomic_inc_return(&per_cpu_ptr(wakeup_trace->array_buffer.data, cpu)->disabled);
        if (unlikely(disabled != 1))
                goto out;
 
+       trace_ctx = tracing_gen_ctx();
+
        /* interrupts should be off from try_to_wake_up */
        arch_spin_lock(&wakeup_lock);
 
@@ -581,19 +578,17 @@ probe_wakeup(void *ignore, struct task_struct *p)
 
        wakeup_task = get_task_struct(p);
 
-       local_save_flags(flags);
-
        data = per_cpu_ptr(wakeup_trace->array_buffer.data, wakeup_cpu);
        data->preempt_timestamp = ftrace_now(cpu);
-       tracing_sched_wakeup_trace(wakeup_trace, p, current, flags, pc);
-       __trace_stack(wakeup_trace, flags, 0, pc);
+       tracing_sched_wakeup_trace(wakeup_trace, p, current, trace_ctx);
+       __trace_stack(wakeup_trace, trace_ctx, 0);
 
        /*
         * We must be careful in using CALLER_ADDR2. But since wake_up
         * is not called by an assembly function  (where as schedule is)
         * it should be safe to use it here.
         */
-       __trace_function(wakeup_trace, CALLER_ADDR1, CALLER_ADDR2, flags, pc);
+       __trace_function(wakeup_trace, CALLER_ADDR1, CALLER_ADDR2, trace_ctx);
 
 out_locked:
        arch_spin_unlock(&wakeup_lock);