perf tools: change machine__findnew_thread() to set thread pid

Add a new parameter for 'pid' to machine__findnew_thread().
Change callers to pass 'pid' when it is known.

Note that callers sometimes want to find the main thread
which has the memory maps.  The main thread has tid == pid
so the usage in that case is:

	machine__findnew_thread(machine, pid, pid)

whereas the usage to find the specific thread is:

	machine__findnew_thread(machine, pid, tid)

Signed-off-by: Adrian Hunter <adrian.hunter@intel.com>
Acked-by: David Ahern <dsahern@gmail.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/r/1377591794-30553-2-git-send-email-adrian.hunter@intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index 1d8de2e4a40740bf38297ed5163ef1cc679f7c01..0d4ae1dd7b60e6128293ca16a4a82e35123a0215 100644 (file)
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -198,7 +198,7 @@ static int perf_event__inject_buildid(struct perf_tool *tool,
 
        cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
-       thread = machine__findnew_thread(machine, event->ip.pid);
+       thread = machine__findnew_thread(machine, event->ip.pid, event->ip.pid);
        if (thread == NULL) {
                pr_err("problem processing %d event, skipping it.\n",
                       event->header.type);

diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index b49f5c58e152df8d57806c94a91daa43ff96a5a1..c32477837cb0eb227cd8c28801779c1af31434e9 100644 (file)
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -305,7 +305,8 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
                                struct perf_evsel *evsel,
                                struct machine *machine)
 {
-       struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
+       struct thread *thread = machine__findnew_thread(machine, event->ip.pid,
+                                                       event->ip.pid);
 
        if (thread == NULL) {
                pr_debug("problem processing %d event, skipping it.\n",

diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index 6cd4de59be21e4c057c210e39d440d890db60ebf..47b35407c2f21705e65be4c0eab75ae89dcd3811 100644 (file)
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -815,7 +815,7 @@ static int process_sample_event(struct perf_tool *tool,
        if (skip_sample(kvm, sample))
                return 0;
 
-       thread = machine__findnew_thread(machine, sample->tid);
+       thread = machine__findnew_thread(machine, sample->pid, sample->tid);
        if (thread == NULL) {
                pr_debug("problem processing %d event, skipping it.\n",
                        event->header.type);

diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index 76543a4a7a306fc3aa60c44f5ce33383e9fba081..ee33ba2f05dd8b2f1f9c90f1820e0eab93b86f8b 100644 (file)
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -805,7 +805,8 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
                                struct perf_evsel *evsel,
                                struct machine *machine)
 {
-       struct thread *thread = machine__findnew_thread(machine, sample->tid);
+       struct thread *thread = machine__findnew_thread(machine, sample->pid,
+                                                       sample->tid);
 
        if (thread == NULL) {
                pr_debug("problem processing %d event, skipping it.\n",

diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index f809cc7fb7d935dc942a81d25283b290104f50b3..d8c51b2f263f7475da99a28df87cad3d1f6bb4d2 100644 (file)
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -724,8 +724,10 @@ static int replay_fork_event(struct perf_sched *sched,
 {
        struct thread *child, *parent;
 
-       child = machine__findnew_thread(machine, event->fork.tid);
-       parent = machine__findnew_thread(machine, event->fork.ptid);
+       child = machine__findnew_thread(machine, event->fork.pid,
+                                       event->fork.tid);
+       parent = machine__findnew_thread(machine, event->fork.ppid,
+                                        event->fork.ptid);
 
        if (child == NULL || parent == NULL) {
                pr_debug("thread does not exist on fork event: child %p, parent %p\n",
@@ -934,8 +936,8 @@ static int latency_switch_event(struct perf_sched *sched,
                return -1;
        }
 
-       sched_out = machine__findnew_thread(machine, prev_pid);
-       sched_in = machine__findnew_thread(machine, next_pid);
+       sched_out = machine__findnew_thread(machine, 0, prev_pid);
+       sched_in = machine__findnew_thread(machine, 0, next_pid);
 
        out_events = thread_atoms_search(&sched->atom_root, sched_out, &sched->cmp_pid);
        if (!out_events) {
@@ -978,7 +980,7 @@ static int latency_runtime_event(struct perf_sched *sched,
 {
        const u32 pid      = perf_evsel__intval(evsel, sample, "pid");
        const u64 runtime  = perf_evsel__intval(evsel, sample, "runtime");
-       struct thread *thread = machine__findnew_thread(machine, pid);
+       struct thread *thread = machine__findnew_thread(machine, 0, pid);
        struct work_atoms *atoms = thread_atoms_search(&sched->atom_root, thread, &sched->cmp_pid);
        u64 timestamp = sample->time;
        int cpu = sample->cpu;
@@ -1016,7 +1018,7 @@ static int latency_wakeup_event(struct perf_sched *sched,
        if (!success)
                return 0;
 
-       wakee = machine__findnew_thread(machine, pid);
+       wakee = machine__findnew_thread(machine, 0, pid);
        atoms = thread_atoms_search(&sched->atom_root, wakee, &sched->cmp_pid);
        if (!atoms) {
                if (thread_atoms_insert(sched, wakee))
@@ -1070,7 +1072,7 @@ static int latency_migrate_task_event(struct perf_sched *sched,
        if (sched->profile_cpu == -1)
                return 0;
 
-       migrant = machine__findnew_thread(machine, pid);
+       migrant = machine__findnew_thread(machine, 0, pid);
        atoms = thread_atoms_search(&sched->atom_root, migrant, &sched->cmp_pid);
        if (!atoms) {
                if (thread_atoms_insert(sched, migrant))
@@ -1289,8 +1291,8 @@ static int map_switch_event(struct perf_sched *sched, struct perf_evsel *evsel,
                return -1;
        }
 
-       sched_out = machine__findnew_thread(machine, prev_pid);
-       sched_in = machine__findnew_thread(machine, next_pid);
+       sched_out = machine__findnew_thread(machine, 0, prev_pid);
+       sched_in = machine__findnew_thread(machine, 0, next_pid);
 
        sched->curr_thread[this_cpu] = sched_in;
 

diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index 2ad9d5b6fb3caa4c858cd768eb24cd181af7659a..d82712f169b34f6e323f35fb72fbe605c8576c78 100644 (file)
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -501,7 +501,8 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
                                struct machine *machine)
 {
        struct addr_location al;
-       struct thread *thread = machine__findnew_thread(machine, event->ip.tid);
+       struct thread *thread = machine__findnew_thread(machine, event->ip.pid,
+                                                       event->ip.tid);
 
        if (thread == NULL) {
                pr_debug("problem processing %d event, skipping it.\n",

diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index b72afc73f9a7a5309bed5fb508e83197cb699929..88387c565687a961a35e55a22b6b8c29fc08d82b 100644 (file)
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -521,7 +521,8 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
        if (sc->filtered)
                return 0;
 
-       thread = machine__findnew_thread(&trace->host, sample->tid);
+       thread = machine__findnew_thread(&trace->host, sample->pid,
+                                        sample->tid);
        ttrace = thread__trace(thread, trace->output);
        if (ttrace == NULL)
                return -1;
@@ -572,7 +573,8 @@ static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
        if (sc->filtered)
                return 0;
 
-       thread = machine__findnew_thread(&trace->host, sample->tid);
+       thread = machine__findnew_thread(&trace->host, sample->pid,
+                                        sample->tid);
        ttrace = thread__trace(thread, trace->output);
        if (ttrace == NULL)
                return -1;
@@ -628,7 +630,9 @@ static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evs
 {
         u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
        double runtime_ms = (double)runtime / NSEC_PER_MSEC;
-       struct thread *thread = machine__findnew_thread(&trace->host, sample->tid);
+       struct thread *thread = machine__findnew_thread(&trace->host,
+                                                       sample->pid,
+                                                       sample->tid);
        struct thread_trace *ttrace = thread__trace(thread, trace->output);
 
        if (ttrace == NULL)

diff --git a/tools/perf/tests/code-reading.c b/tools/perf/tests/code-reading.c
index df9afd9cab4c7e300b0df69ed98ca8d0d8fb2a48..6fb781d5586cd1d264bc223375f081e0b0ed0c82 100644 (file)
--- a/tools/perf/tests/code-reading.c
+++ b/tools/perf/tests/code-reading.c
@@ -257,7 +257,7 @@ static int process_sample_event(struct machine *machine,
                return -1;
        }
 
-       thread = machine__findnew_thread(machine, sample.pid);
+       thread = machine__findnew_thread(machine, sample.pid, sample.pid);
        if (!thread) {
                pr_debug("machine__findnew_thread failed\n");
                return -1;
@@ -446,7 +446,7 @@ static int do_test_code_reading(bool try_kcore)
                goto out_err;
        }
 
-       thread = machine__findnew_thread(machine, pid);
+       thread = machine__findnew_thread(machine, pid, pid);
        if (!thread) {
                pr_debug("machine__findnew_thread failed\n");
                goto out_err;

diff --git a/tools/perf/tests/hists_link.c b/tools/perf/tests/hists_link.c
index 50bfb01183eace93ece9f9c73b7154608c506f1a..87f9f7280c4012ede9825c66abbce22628f4e394 100644 (file)
--- a/tools/perf/tests/hists_link.c
+++ b/tools/perf/tests/hists_link.c
@@ -88,7 +88,8 @@ static struct machine *setup_fake_machine(struct machines *machines)
        for (i = 0; i < ARRAY_SIZE(fake_threads); i++) {
                struct thread *thread;
 
-               thread = machine__findnew_thread(machine, fake_threads[i].pid);
+               thread = machine__findnew_thread(machine, fake_threads[i].pid,
+                                                fake_threads[i].pid);
                if (thread == NULL)
                        goto out;
 

diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index 5295625c0c009af43e980a1182e6748959df0734..0f9d27a6bc8f8b331008aabfe12ec2860849cc74 100644 (file)
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -24,7 +24,8 @@ int build_id__mark_dso_hit(struct perf_tool *tool __maybe_unused,
 {
        struct addr_location al;
        u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-       struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
+       struct thread *thread = machine__findnew_thread(machine, event->ip.pid,
+                                                       event->ip.pid);
 
        if (thread == NULL) {
                pr_err("problem processing %d event, skipping it.\n",
@@ -47,7 +48,9 @@ static int perf_event__exit_del_thread(struct perf_tool *tool __maybe_unused,
                                       __maybe_unused,
                                       struct machine *machine)
 {
-       struct thread *thread = machine__findnew_thread(machine, event->fork.tid);
+       struct thread *thread = machine__findnew_thread(machine,
+                                                       event->fork.pid,
+                                                       event->fork.tid);
 
        dump_printf("(%d:%d):(%d:%d)\n", event->fork.pid, event->fork.tid,
                    event->fork.ppid, event->fork.ptid);

diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 49713ae4655182d14da39e210390879ecb10dd32..61cecf9caff1b88a1d401070345387b7417fdc5c 100644 (file)
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -686,7 +686,8 @@ int perf_event__preprocess_sample(const union perf_event *event,
                                  struct perf_sample *sample)
 {
        u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-       struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
+       struct thread *thread = machine__findnew_thread(machine, event->ip.pid,
+                                                       event->ip.pid);
 
        if (thread == NULL)
                return -1;

diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 59486c18062640eac9942920ffa5f9bb1815596b..1dca61f0512d672abb257cf093cf4539835c30eb 100644 (file)
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -32,7 +32,8 @@ int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
                return -ENOMEM;
 
        if (pid != HOST_KERNEL_ID) {
-               struct thread *thread = machine__findnew_thread(machine, pid);
+               struct thread *thread = machine__findnew_thread(machine, 0,
+                                                               pid);
                char comm[64];
 
                if (thread == NULL)
@@ -302,9 +303,10 @@ static struct thread *__machine__findnew_thread(struct machine *machine,
        return th;
 }
 
-struct thread *machine__findnew_thread(struct machine *machine, pid_t tid)
+struct thread *machine__findnew_thread(struct machine *machine, pid_t pid,
+                                      pid_t tid)
 {
-       return __machine__findnew_thread(machine, 0, tid, true);
+       return __machine__findnew_thread(machine, pid, tid, true);
 }
 
 struct thread *machine__find_thread(struct machine *machine, pid_t tid)
@@ -314,7 +316,9 @@ struct thread *machine__find_thread(struct machine *machine, pid_t tid)
 
 int machine__process_comm_event(struct machine *machine, union perf_event *event)
 {
-       struct thread *thread = machine__findnew_thread(machine, event->comm.tid);
+       struct thread *thread = machine__findnew_thread(machine,
+                                                       event->comm.pid,
+                                                       event->comm.tid);
 
        if (dump_trace)
                perf_event__fprintf_comm(event, stdout);
@@ -1012,7 +1016,8 @@ int machine__process_mmap_event(struct machine *machine, union perf_event *event
                return 0;
        }
 
-       thread = machine__findnew_thread(machine, event->mmap.pid);
+       thread = machine__findnew_thread(machine, event->mmap.pid,
+                                        event->mmap.pid);
        if (thread == NULL)
                goto out_problem;
 
@@ -1051,13 +1056,16 @@ static void machine__remove_thread(struct machine *machine, struct thread *th)
 int machine__process_fork_event(struct machine *machine, union perf_event *event)
 {
        struct thread *thread = machine__find_thread(machine, event->fork.tid);
-       struct thread *parent = machine__findnew_thread(machine, event->fork.ptid);
+       struct thread *parent = machine__findnew_thread(machine,
+                                                       event->fork.ppid,
+                                                       event->fork.ptid);
 
        /* if a thread currently exists for the thread id remove it */
        if (thread != NULL)
                machine__remove_thread(machine, thread);
 
-       thread = machine__findnew_thread(machine, event->fork.tid);
+       thread = machine__findnew_thread(machine, event->fork.pid,
+                                        event->fork.tid);
        if (dump_trace)
                perf_event__fprintf_task(event, stdout);
 

diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index 603ffba999d9bfa46d1345faefc6a8e1ba07782f..0df925ba6a44e5ca97235b90cadd7a672429c49a 100644 (file)
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -106,7 +106,8 @@ static inline bool machine__is_host(struct machine *machine)
        return machine ? machine->pid == HOST_KERNEL_ID : false;
 }
 
-struct thread *machine__findnew_thread(struct machine *machine, pid_t tid);
+struct thread *machine__findnew_thread(struct machine *machine, pid_t pid,
+                                      pid_t tid);
 
 size_t machine__fprintf(struct machine *machine, FILE *fp);
 

diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index de16a77368591054b01951b7b94720be353e88af..57b6f38f246a904686c977ae650fa3ad899a5586 100644 (file)
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -1099,7 +1099,7 @@ void perf_event_header__bswap(struct perf_event_header *self)
 
 struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
 {
-       return machine__findnew_thread(&session->machines.host, pid);
+       return machine__findnew_thread(&session->machines.host, 0, pid);
 }
 
 static struct thread *perf_session__register_idle_thread(struct perf_session *self)