Merge branch 'next' into for-linus

Prepare input updates for 3.16.

1 files changed, 44 insertions, 51 deletions

diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index c872991e0f65..27c2a5efe450 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -327,9 +327,10 @@ struct thread *machine__findnew_thread(struct machine *machine, pid_t pid,
         return __machine__findnew_thread(machine, pid, tid, true);
 }
 
-struct thread *machine__find_thread(struct machine *machine, pid_t tid)
+struct thread *machine__find_thread(struct machine *machine, pid_t pid,
+                                    pid_t tid)
 {
-        return __machine__findnew_thread(machine, 0, tid, false);
+        return __machine__findnew_thread(machine, pid, tid, false);
 }
 
 int machine__process_comm_event(struct machine *machine, union perf_event *event,
@@ -716,7 +717,7 @@ static char *get_kernel_version(const char *root_dir)
 }
 
 static int map_groups__set_modules_path_dir(struct map_groups *mg,
-                                const char *dir_name)
+                                const char *dir_name, int depth)
 {
         struct dirent *dent;
         DIR *dir = opendir(dir_name);
@@ -741,7 +742,15 @@ static int map_groups__set_modules_path_dir(struct map_groups *mg,
                             !strcmp(dent->d_name, ".."))
                                 continue;
 
-                        ret = map_groups__set_modules_path_dir(mg, path);
+                        /* Do not follow top-level source and build symlinks */
+                        if (depth == 0) {
+                                if (!strcmp(dent->d_name, "source") ||
+                                    !strcmp(dent->d_name, "build"))
+                                        continue;
+                        }
+
+                        ret = map_groups__set_modules_path_dir(mg, path,
+                                                               depth + 1);
                         if (ret < 0)
                                 goto out;
                 } else {
@@ -785,11 +794,11 @@ static int machine__set_modules_path(struct machine *machine)
         if (!version)
                 return -1;
 
-        snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
+        snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s",
                  machine->root_dir, version);
         free(version);
 
-        return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
+        return map_groups__set_modules_path_dir(&machine->kmaps, modules_path, 0);
 }
 
 static int machine__create_module(void *arg, const char *name, u64 start)
@@ -1026,7 +1035,7 @@ int machine__process_mmap2_event(struct machine *machine,
         }
 
         thread = machine__findnew_thread(machine, event->mmap2.pid,
-                                        event->mmap2.pid);
+                                        event->mmap2.tid);
         if (thread == NULL)
                 goto out_problem;
 
@@ -1074,7 +1083,7 @@ int machine__process_mmap_event(struct machine *machine, union perf_event *event
         }
 
         thread = machine__findnew_thread(machine, event->mmap.pid,
-                                         event->mmap.pid);
+                                         event->mmap.tid);
         if (thread == NULL)
                 goto out_problem;
 
@@ -1114,7 +1123,9 @@ static void machine__remove_thread(struct machine *machine, struct thread *th)
 int machine__process_fork_event(struct machine *machine, union perf_event *event,
                                 struct perf_sample *sample)
 {
-        struct thread *thread = machine__find_thread(machine, event->fork.tid);
+        struct thread *thread = machine__find_thread(machine,
+                                                     event->fork.pid,
+                                                     event->fork.tid);
         struct thread *parent = machine__findnew_thread(machine,
                                                         event->fork.ppid,
                                                         event->fork.ptid);
@@ -1140,7 +1151,9 @@ int machine__process_fork_event(struct machine *machine, union perf_event *event
 int machine__process_exit_event(struct machine *machine, union perf_event *event,
                                 struct perf_sample *sample __maybe_unused)
 {
-        struct thread *thread = machine__find_thread(machine, event->fork.tid);
+        struct thread *thread = machine__find_thread(machine,
+                                                     event->fork.pid,
+                                                     event->fork.tid);
 
         if (dump_trace)
                 perf_event__fprintf_task(event, stdout);
@@ -1184,39 +1197,22 @@ static bool symbol__match_regex(struct symbol *sym, regex_t *regex)
         return 0;
 }
 
-static const u8 cpumodes[] = {
-        PERF_RECORD_MISC_USER,
-        PERF_RECORD_MISC_KERNEL,
-        PERF_RECORD_MISC_GUEST_USER,
-        PERF_RECORD_MISC_GUEST_KERNEL
-};
-#define NCPUMODES (sizeof(cpumodes)/sizeof(u8))
-
 static void ip__resolve_ams(struct machine *machine, struct thread *thread,
                             struct addr_map_symbol *ams,
                             u64 ip)
 {
         struct addr_location al;
-        size_t i;
-        u8 m;
 
         memset(&al, 0, sizeof(al));
+        /*
+         * We cannot use the header.misc hint to determine whether a
+         * branch stack address is user, kernel, guest, hypervisor.
+         * Branches may straddle the kernel/user/hypervisor boundaries.
+         * Thus, we have to try consecutively until we find a match
+         * or else, the symbol is unknown
+         */
+        thread__find_cpumode_addr_location(thread, machine, MAP__FUNCTION, ip, &al);
 
-        for (i = 0; i < NCPUMODES; i++) {
-                m = cpumodes[i];
-                /*
-                 * We cannot use the header.misc hint to determine whether a
-                 * branch stack address is user, kernel, guest, hypervisor.
-                 * Branches may straddle the kernel/user/hypervisor boundaries.
-                 * Thus, we have to try consecutively until we find a match
-                 * or else, the symbol is unknown
-                 */
-                thread__find_addr_location(thread, machine, m, MAP__FUNCTION,
-                                ip, &al);
-                if (al.sym)
-                        goto found;
-        }
-found:
         ams->addr = ip;
         ams->al_addr = al.addr;
         ams->sym = al.sym;
@@ -1238,37 +1234,35 @@ static void ip__resolve_data(struct machine *machine, struct thread *thread,
         ams->map = al.map;
 }
 
-struct mem_info *machine__resolve_mem(struct machine *machine,
-                                      struct thread *thr,
-                                      struct perf_sample *sample,
-                                      u8 cpumode)
+struct mem_info *sample__resolve_mem(struct perf_sample *sample,
+                                     struct addr_location *al)
 {
         struct mem_info *mi = zalloc(sizeof(*mi));
 
         if (!mi)
                 return NULL;
 
-        ip__resolve_ams(machine, thr, &mi->iaddr, sample->ip);
-        ip__resolve_data(machine, thr, cpumode, &mi->daddr, sample->addr);
+        ip__resolve_ams(al->machine, al->thread, &mi->iaddr, sample->ip);
+        ip__resolve_data(al->machine, al->thread, al->cpumode,
+                         &mi->daddr, sample->addr);
         mi->data_src.val = sample->data_src;
 
         return mi;
 }
 
-struct branch_info *machine__resolve_bstack(struct machine *machine,
-                                            struct thread *thr,
-                                            struct branch_stack *bs)
+struct branch_info *sample__resolve_bstack(struct perf_sample *sample,
+                                           struct addr_location *al)
 {
-        struct branch_info *bi;
         unsigned int i;
+        const struct branch_stack *bs = sample->branch_stack;
+        struct branch_info *bi = calloc(bs->nr, sizeof(struct branch_info));
 
-        bi = calloc(bs->nr, sizeof(struct branch_info));
         if (!bi)
                 return NULL;
 
         for (i = 0; i < bs->nr; i++) {
-                ip__resolve_ams(machine, thr, &bi[i].to, bs->entries[i].to);
-                ip__resolve_ams(machine, thr, &bi[i].from, bs->entries[i].from);
+                ip__resolve_ams(al->machine, al->thread, &bi[i].to, bs->entries[i].to);
+                ip__resolve_ams(al->machine, al->thread, &bi[i].from, bs->entries[i].from);
                 bi[i].flags = bs->entries[i].flags;
         }
         return bi;
@@ -1326,7 +1320,7 @@ static int machine__resolve_callchain_sample(struct machine *machine,
                         continue;
                 }
 
-                al.filtered = false;
+                al.filtered = 0;
                 thread__find_addr_location(thread, machine, cpumode,
                                            MAP__FUNCTION, ip, &al);
                 if (al.sym != NULL) {
@@ -1385,8 +1379,7 @@ int machine__resolve_callchain(struct machine *machine,
                 return 0;
 
         return unwind__get_entries(unwind_entry, &callchain_cursor, machine,
-                                   thread, evsel->attr.sample_regs_user,
-                                   sample, max_stack);
+                                   thread, sample, max_stack);
 
 }