perf tools: Resolve machine earlier and pass it to perf_event_ops

Reducing the exposure of perf_session further, so that we can use the
classes in cases where no perf.data file is created.

Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-stua66dcscsezzrcdugvbmvd@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

1 files changed, 35 insertions, 35 deletions

diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index b11d6283fedf..6a771f822e5d 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -724,21 +724,21 @@ struct trace_migrate_task_event {
 
 struct trace_sched_handler {
         void (*switch_event)(struct trace_switch_event *,
-                             struct perf_session *,
+                             struct machine *,
                              struct event *,
                              int cpu,
                              u64 timestamp,
                              struct thread *thread);
 
         void (*runtime_event)(struct trace_runtime_event *,
-                              struct perf_session *,
+                              struct machine *,
                               struct event *,
                               int cpu,
                               u64 timestamp,
                               struct thread *thread);
 
         void (*wakeup_event)(struct trace_wakeup_event *,
-                             struct perf_session *,
+                             struct machine *,
                              struct event *,
                              int cpu,
                              u64 timestamp,
@@ -751,7 +751,7 @@ struct trace_sched_handler {
                            struct thread *thread);
 
         void (*migrate_task_event)(struct trace_migrate_task_event *,
-                           struct perf_session *session,
+                           struct machine *machine,
                            struct event *,
                            int cpu,
                            u64 timestamp,
@@ -761,7 +761,7 @@ struct trace_sched_handler {
 
 static void
 replay_wakeup_event(struct trace_wakeup_event *wakeup_event,
-                    struct perf_session *session __used,
+                    struct machine *machine __used,
                     struct event *event,
                     int cpu __used,
                     u64 timestamp __used,
@@ -788,7 +788,7 @@ static u64 cpu_last_switched[MAX_CPUS];
 
 static void
 replay_switch_event(struct trace_switch_event *switch_event,
-                    struct perf_session *session __used,
+                    struct machine *machine __used,
                     struct event *event,
                     int cpu,
                     u64 timestamp,
@@ -1022,7 +1022,7 @@ add_sched_in_event(struct work_atoms *atoms, u64 timestamp)
 
 static void
 latency_switch_event(struct trace_switch_event *switch_event,
-                     struct perf_session *session,
+                     struct machine *machine,
                      struct event *event __used,
                      int cpu,
                      u64 timestamp,
@@ -1046,8 +1046,8 @@ latency_switch_event(struct trace_switch_event *switch_event,
                 die("hm, delta: %" PRIu64 " < 0 ?\n", delta);
 
 
-        sched_out = perf_session__findnew(session, switch_event->prev_pid);
-        sched_in = perf_session__findnew(session, switch_event->next_pid);
+        sched_out = machine__findnew_thread(machine, switch_event->prev_pid);
+        sched_in = machine__findnew_thread(machine, switch_event->next_pid);
 
         out_events = thread_atoms_search(&atom_root, sched_out, &cmp_pid);
         if (!out_events) {
@@ -1075,13 +1075,13 @@ latency_switch_event(struct trace_switch_event *switch_event,
 
 static void
 latency_runtime_event(struct trace_runtime_event *runtime_event,
-                     struct perf_session *session,
+                     struct machine *machine,
                      struct event *event __used,
                      int cpu,
                      u64 timestamp,
                      struct thread *this_thread __used)
 {
-        struct thread *thread = perf_session__findnew(session, runtime_event->pid);
+        struct thread *thread = machine__findnew_thread(machine, runtime_event->pid);
         struct work_atoms *atoms = thread_atoms_search(&atom_root, thread, &cmp_pid);
 
         BUG_ON(cpu >= MAX_CPUS || cpu < 0);
@@ -1098,7 +1098,7 @@ latency_runtime_event(struct trace_runtime_event *runtime_event,
 
 static void
 latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
-                     struct perf_session *session,
+                     struct machine *machine,
                      struct event *__event __used,
                      int cpu __used,
                      u64 timestamp,
@@ -1112,7 +1112,7 @@ latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
         if (!wakeup_event->success)
                 return;
 
-        wakee = perf_session__findnew(session, wakeup_event->pid);
+        wakee = machine__findnew_thread(machine, wakeup_event->pid);
         atoms = thread_atoms_search(&atom_root, wakee, &cmp_pid);
         if (!atoms) {
                 thread_atoms_insert(wakee);
@@ -1146,7 +1146,7 @@ latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
 
 static void
 latency_migrate_task_event(struct trace_migrate_task_event *migrate_task_event,
-                     struct perf_session *session,
+                     struct machine *machine,
                      struct event *__event __used,
                      int cpu __used,
                      u64 timestamp,
@@ -1162,7 +1162,7 @@ latency_migrate_task_event(struct trace_migrate_task_event *migrate_task_event,
         if (profile_cpu == -1)
                 return;
 
-        migrant = perf_session__findnew(session, migrate_task_event->pid);
+        migrant = machine__findnew_thread(machine, migrate_task_event->pid);
         atoms = thread_atoms_search(&atom_root, migrant, &cmp_pid);
         if (!atoms) {
                 thread_atoms_insert(migrant);
@@ -1357,7 +1357,7 @@ static void sort_lat(void)
 static struct trace_sched_handler *trace_handler;
 
 static void
-process_sched_wakeup_event(void *data, struct perf_session *session,
+process_sched_wakeup_event(void *data, struct machine *machine,
                            struct event *event,
                            int cpu __used,
                            u64 timestamp __used,
@@ -1374,7 +1374,7 @@ process_sched_wakeup_event(void *data, struct perf_session *session,
         FILL_FIELD(wakeup_event, cpu, event, data);
 
         if (trace_handler->wakeup_event)
-                trace_handler->wakeup_event(&wakeup_event, session, event,
+                trace_handler->wakeup_event(&wakeup_event, machine, event,
                                             cpu, timestamp, thread);
 }
 
@@ -1393,7 +1393,7 @@ static char next_shortname2 = '0';
 
 static void
 map_switch_event(struct trace_switch_event *switch_event,
-                 struct perf_session *session,
+                 struct machine *machine,
                  struct event *event __used,
                  int this_cpu,
                  u64 timestamp,
@@ -1421,8 +1421,8 @@ map_switch_event(struct trace_switch_event *switch_event,
                 die("hm, delta: %" PRIu64 " < 0 ?\n", delta);
 
 
-        sched_out = perf_session__findnew(session, switch_event->prev_pid);
-        sched_in = perf_session__findnew(session, switch_event->next_pid);
+        sched_out = machine__findnew_thread(machine, switch_event->prev_pid);
+        sched_in = machine__findnew_thread(machine, switch_event->next_pid);
 
         curr_thread[this_cpu] = sched_in;
 
@@ -1472,7 +1472,7 @@ map_switch_event(struct trace_switch_event *switch_event,
 
 
 static void
-process_sched_switch_event(void *data, struct perf_session *session,
+process_sched_switch_event(void *data, struct machine *machine,
                            struct event *event,
                            int this_cpu,
                            u64 timestamp __used,
@@ -1499,14 +1499,14 @@ process_sched_switch_event(void *data, struct perf_session *session,
                         nr_context_switch_bugs++;
         }
         if (trace_handler->switch_event)
-                trace_handler->switch_event(&switch_event, session, event,
+                trace_handler->switch_event(&switch_event, machine, event,
                                             this_cpu, timestamp, thread);
 
         curr_pid[this_cpu] = switch_event.next_pid;
 }
 
 static void
-process_sched_runtime_event(void *data, struct perf_session *session,
+process_sched_runtime_event(void *data, struct machine *machine,
                            struct event *event,
                            int cpu __used,
                            u64 timestamp __used,
@@ -1520,7 +1520,7 @@ process_sched_runtime_event(void *data, struct perf_session *session,
         FILL_FIELD(runtime_event, vruntime, event, data);
 
         if (trace_handler->runtime_event)
-                trace_handler->runtime_event(&runtime_event, session, event, cpu, timestamp, thread);
+                trace_handler->runtime_event(&runtime_event, machine, event, cpu, timestamp, thread);
 }
 
 static void
@@ -1555,7 +1555,7 @@ process_sched_exit_event(struct event *event,
 }
 
 static void
-process_sched_migrate_task_event(void *data, struct perf_session *session,
+process_sched_migrate_task_event(void *data, struct machine *machine,
                            struct event *event,
                            int cpu __used,
                            u64 timestamp __used,
@@ -1571,12 +1571,12 @@ process_sched_migrate_task_event(void *data, struct perf_session *session,
         FILL_FIELD(migrate_task_event, cpu, event, data);
 
         if (trace_handler->migrate_task_event)
-                trace_handler->migrate_task_event(&migrate_task_event, session,
+                trace_handler->migrate_task_event(&migrate_task_event, machine,
                                                  event, cpu, timestamp, thread);
 }
 
 static void process_raw_event(union perf_event *raw_event __used,
-                              struct perf_session *session, void *data, int cpu,
+                              struct machine *machine, void *data, int cpu,
                               u64 timestamp, struct thread *thread)
 {
         struct event *event;
@@ -1587,33 +1587,33 @@ static void process_raw_event(union perf_event *raw_event __used,
         event = trace_find_event(type);
 
         if (!strcmp(event->name, "sched_switch"))
-                process_sched_switch_event(data, session, event, cpu, timestamp, thread);
+                process_sched_switch_event(data, machine, event, cpu, timestamp, thread);
         if (!strcmp(event->name, "sched_stat_runtime"))
-                process_sched_runtime_event(data, session, event, cpu, timestamp, thread);
+                process_sched_runtime_event(data, machine, event, cpu, timestamp, thread);
         if (!strcmp(event->name, "sched_wakeup"))
-                process_sched_wakeup_event(data, session, event, cpu, timestamp, thread);
+                process_sched_wakeup_event(data, machine, event, cpu, timestamp, thread);
         if (!strcmp(event->name, "sched_wakeup_new"))
-                process_sched_wakeup_event(data, session, event, cpu, timestamp, thread);
+                process_sched_wakeup_event(data, machine, event, cpu, timestamp, thread);
         if (!strcmp(event->name, "sched_process_fork"))
                 process_sched_fork_event(data, event, cpu, timestamp, thread);
         if (!strcmp(event->name, "sched_process_exit"))
                 process_sched_exit_event(event, cpu, timestamp, thread);
         if (!strcmp(event->name, "sched_migrate_task"))
-                process_sched_migrate_task_event(data, session, event, cpu, timestamp, thread);
+                process_sched_migrate_task_event(data, machine, event, cpu, timestamp, thread);
 }
 
 static int process_sample_event(struct perf_event_ops *ops __used,
                                 union perf_event *event,
                                 struct perf_sample *sample,
                                 struct perf_evsel *evsel,
-                                struct perf_session *session)
+                                struct machine *machine)
 {
         struct thread *thread;
 
         if (!(evsel->attr.sample_type & PERF_SAMPLE_RAW))
                 return 0;
 
-        thread = perf_session__findnew(session, sample->pid);
+        thread = machine__findnew_thread(machine, sample->pid);
         if (thread == NULL) {
                 pr_debug("problem processing %d event, skipping it.\n",
                          event->header.type);
@@ -1625,7 +1625,7 @@ static int process_sample_event(struct perf_event_ops *ops __used,
         if (profile_cpu != -1 && profile_cpu != (int)sample->cpu)
                 return 0;
 
-        process_raw_event(event, session, sample->raw_data, sample->cpu,
+        process_raw_event(event, machine, sample->raw_data, sample->cpu,
                           sample->time, thread);
 
         return 0;