Merge tag 'v3.12-rc4' into next

Merge with mainline to bring in changes to input subsystem that were
committed through other trees.

1 files changed, 65 insertions, 22 deletions

diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 5cd13d768cec..9b393e7dca6f 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -11,6 +11,7 @@
 static const char *perf_event__names[] = {
         [0]                                     = "TOTAL",
         [PERF_RECORD_MMAP]                      = "MMAP",
+        [PERF_RECORD_MMAP2]                     = "MMAP2",
         [PERF_RECORD_LOST]                      = "LOST",
         [PERF_RECORD_COMM]                      = "COMM",
         [PERF_RECORD_EXIT]                      = "EXIT",
@@ -186,7 +187,7 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                 return -1;
         }
 
-        event->header.type = PERF_RECORD_MMAP;
+        event->header.type = PERF_RECORD_MMAP2;
         /*
          * Just like the kernel, see __perf_event_mmap in kernel/perf_event.c
          */
@@ -197,7 +198,9 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                 char prot[5];
                 char execname[PATH_MAX];
                 char anonstr[] = "//anon";
+                unsigned int ino;
                 size_t size;
+                ssize_t n;
 
                 if (fgets(bf, sizeof(bf), fp) == NULL)
                         break;
@@ -206,9 +209,16 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                 strcpy(execname, "");
 
                 /* 00400000-0040c000 r-xp 00000000 fd:01 41038  /bin/cat */
-                sscanf(bf, "%"PRIx64"-%"PRIx64" %s %"PRIx64" %*x:%*x %*u %s\n",
-                       &event->mmap.start, &event->mmap.len, prot,
-                       &event->mmap.pgoff, execname);
+                n = sscanf(bf, "%"PRIx64"-%"PRIx64" %s %"PRIx64" %x:%x %u %s\n",
+                       &event->mmap2.start, &event->mmap2.len, prot,
+                       &event->mmap2.pgoff, &event->mmap2.maj,
+                       &event->mmap2.min,
+                       &ino, execname);
+
+                event->mmap2.ino = (u64)ino;
+
+                if (n != 8)
+                        continue;
 
                 if (prot[2] != 'x')
                         continue;
@@ -217,15 +227,15 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                         strcpy(execname, anonstr);
 
                 size = strlen(execname) + 1;
-                memcpy(event->mmap.filename, execname, size);
+                memcpy(event->mmap2.filename, execname, size);
                 size = PERF_ALIGN(size, sizeof(u64));
-                event->mmap.len -= event->mmap.start;
-                event->mmap.header.size = (sizeof(event->mmap) -
-                                           (sizeof(event->mmap.filename) - size));
-                memset(event->mmap.filename + size, 0, machine->id_hdr_size);
-                event->mmap.header.size += machine->id_hdr_size;
-                event->mmap.pid = tgid;
-                event->mmap.tid = pid;
+                event->mmap2.len -= event->mmap.start;
+                event->mmap2.header.size = (sizeof(event->mmap2) -
+                                        (sizeof(event->mmap2.filename) - size));
+                memset(event->mmap2.filename + size, 0, machine->id_hdr_size);
+                event->mmap2.header.size += machine->id_hdr_size;
+                event->mmap2.pid = tgid;
+                event->mmap2.tid = pid;
 
                 if (process(tool, event, &synth_sample, machine) != 0) {
                         rc = -1;
@@ -527,6 +537,17 @@ size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp)
                        event->mmap.len, event->mmap.pgoff, event->mmap.filename);
 }
 
+size_t perf_event__fprintf_mmap2(union perf_event *event, FILE *fp)
+{
+        return fprintf(fp, " %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64
+                           " %02x:%02x %"PRIu64" %"PRIu64"]: %s\n",
+                       event->mmap2.pid, event->mmap2.tid, event->mmap2.start,
+                       event->mmap2.len, event->mmap2.pgoff, event->mmap2.maj,
+                       event->mmap2.min, event->mmap2.ino,
+                       event->mmap2.ino_generation,
+                       event->mmap2.filename);
+}
+
 int perf_event__process_mmap(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
                              struct perf_sample *sample __maybe_unused,
@@ -535,6 +556,14 @@ int perf_event__process_mmap(struct perf_tool *tool __maybe_unused,
         return machine__process_mmap_event(machine, event);
 }
 
+int perf_event__process_mmap2(struct perf_tool *tool __maybe_unused,
+                             union perf_event *event,
+                             struct perf_sample *sample __maybe_unused,
+                             struct machine *machine)
+{
+        return machine__process_mmap2_event(machine, event);
+}
+
 size_t perf_event__fprintf_task(union perf_event *event, FILE *fp)
 {
         return fprintf(fp, "(%d:%d):(%d:%d)\n",
@@ -574,6 +603,9 @@ size_t perf_event__fprintf(union perf_event *event, FILE *fp)
         case PERF_RECORD_MMAP:
                 ret += perf_event__fprintf_mmap(event, fp);
                 break;
+        case PERF_RECORD_MMAP2:
+                ret += perf_event__fprintf_mmap2(event, fp);
+                break;
         default:
                 ret += fprintf(fp, "\n");
         }
@@ -595,6 +627,7 @@ void thread__find_addr_map(struct thread *self,
                            struct addr_location *al)
 {
         struct map_groups *mg = &self->mg;
+        bool load_map = false;
 
         al->thread = self;
         al->addr = addr;
@@ -609,11 +642,13 @@ void thread__find_addr_map(struct thread *self,
         if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {
                 al->level = 'k';
                 mg = &machine->kmaps;
+                load_map = true;
         } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) {
                 al->level = '.';
         } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {
                 al->level = 'g';
                 mg = &machine->kmaps;
+                load_map = true;
         } else {
                 /*
                  * 'u' means guest os user space.
@@ -654,18 +689,25 @@ try_again:
                         mg = &machine->kmaps;
                         goto try_again;
                 }
-        } else
+        } else {
+                /*
+                 * Kernel maps might be changed when loading symbols so loading
+                 * must be done prior to using kernel maps.
+                 */
+                if (load_map)
+                        map__load(al->map, machine->symbol_filter);
                 al->addr = al->map->map_ip(al->map, al->addr);
+        }
 }
 
 void thread__find_addr_location(struct thread *thread, struct machine *machine,
                                 u8 cpumode, enum map_type type, u64 addr,
-                                struct addr_location *al,
-                                symbol_filter_t filter)
+                                struct addr_location *al)
 {
         thread__find_addr_map(thread, machine, cpumode, type, addr, al);
         if (al->map != NULL)
-                al->sym = map__find_symbol(al->map, al->addr, filter);
+                al->sym = map__find_symbol(al->map, al->addr,
+                                           machine->symbol_filter);
         else
                 al->sym = NULL;
 }
@@ -673,11 +715,11 @@ void thread__find_addr_location(struct thread *thread, struct machine *machine,
 int perf_event__preprocess_sample(const union perf_event *event,
                                   struct machine *machine,
                                   struct addr_location *al,
-                                  struct perf_sample *sample,
-                                  symbol_filter_t filter)
+                                  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, sample->pid,
+                                                        sample->pid);
 
         if (thread == NULL)
                 return -1;
@@ -686,7 +728,7 @@ int perf_event__preprocess_sample(const union perf_event *event,
             !strlist__has_entry(symbol_conf.comm_list, thread->comm))
                 goto out_filtered;
 
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->tid);
         /*
          * Have we already created the kernel maps for this machine?
          *
@@ -699,7 +741,7 @@ int perf_event__preprocess_sample(const union perf_event *event,
                 machine__create_kernel_maps(machine);
 
         thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
-                              event->ip.ip, al);
+                              sample->ip, al);
         dump_printf(" ...... dso: %s\n",
                     al->map ? al->map->dso->long_name :
                         al->level == 'H' ? "[hypervisor]" : "<not found>");
@@ -717,7 +759,8 @@ int perf_event__preprocess_sample(const union perf_event *event,
                                                    dso->long_name)))))
                         goto out_filtered;
 
-                al->sym = map__find_symbol(al->map, al->addr, filter);
+                al->sym = map__find_symbol(al->map, al->addr,
+                                           machine->symbol_filter);
         }
 
         if (symbol_conf.sym_list &&