1 files changed, 66 insertions, 58 deletions

diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 9b393e7dca6f..bb788c109fe6 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -170,7 +170,8 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                                               union perf_event *event,
                                               pid_t pid, pid_t tgid,
                                               perf_event__handler_t process,
-                                              struct machine *machine)
+                                              struct machine *machine,
+                                              bool mmap_data)
 {
         char filename[PATH_MAX];
         FILE *fp;
@@ -187,18 +188,13 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                 return -1;
         }
 
-        event->header.type = PERF_RECORD_MMAP2;
-        /*
-         * Just like the kernel, see __perf_event_mmap in kernel/perf_event.c
-         */
-        event->header.misc = PERF_RECORD_MISC_USER;
+        event->header.type = PERF_RECORD_MMAP;
 
         while (1) {
                 char bf[BUFSIZ];
                 char prot[5];
                 char execname[PATH_MAX];
                 char anonstr[] = "//anon";
-                unsigned int ino;
                 size_t size;
                 ssize_t n;
 
@@ -209,33 +205,40 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                 strcpy(execname, "");
 
                 /* 00400000-0040c000 r-xp 00000000 fd:01 41038  /bin/cat */
-                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)
+                n = sscanf(bf, "%"PRIx64"-%"PRIx64" %s %"PRIx64" %*x:%*x %*u %s\n",
+                       &event->mmap.start, &event->mmap.len, prot,
+                       &event->mmap.pgoff,
+                       execname);
+                /*
+                 * Anon maps don't have the execname.
+                 */
+                if (n < 4)
                         continue;
+                /*
+                 * Just like the kernel, see __perf_event_mmap in kernel/perf_event.c
+                 */
+                event->header.misc = PERF_RECORD_MISC_USER;
 
-                if (prot[2] != 'x')
-                        continue;
+                if (prot[2] != 'x') {
+                        if (!mmap_data || prot[0] != 'r')
+                                continue;
+
+                        event->header.misc |= PERF_RECORD_MISC_MMAP_DATA;
+                }
 
                 if (!strcmp(execname, ""))
                         strcpy(execname, anonstr);
 
                 size = strlen(execname) + 1;
-                memcpy(event->mmap2.filename, execname, size);
+                memcpy(event->mmap.filename, execname, size);
                 size = PERF_ALIGN(size, sizeof(u64));
-                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;
+                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;
 
                 if (process(tool, event, &synth_sample, machine) != 0) {
                         rc = -1;
@@ -308,20 +311,21 @@ static int __event__synthesize_thread(union perf_event *comm_event,
                                       pid_t pid, int full,
                                           perf_event__handler_t process,
                                       struct perf_tool *tool,
-                                      struct machine *machine)
+                                      struct machine *machine, bool mmap_data)
 {
         pid_t tgid = perf_event__synthesize_comm(tool, comm_event, pid, full,
                                                  process, machine);
         if (tgid == -1)
                 return -1;
         return perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid,
-                                                  process, machine);
+                                                  process, machine, mmap_data);
 }
 
 int perf_event__synthesize_thread_map(struct perf_tool *tool,
                                       struct thread_map *threads,
                                       perf_event__handler_t process,
-                                      struct machine *machine)
+                                      struct machine *machine,
+                                      bool mmap_data)
 {
         union perf_event *comm_event, *mmap_event;
         int err = -1, thread, j;
@@ -338,7 +342,8 @@ int perf_event__synthesize_thread_map(struct perf_tool *tool,
         for (thread = 0; thread < threads->nr; ++thread) {
                 if (__event__synthesize_thread(comm_event, mmap_event,
                                                threads->map[thread], 0,
-                                               process, tool, machine)) {
+                                               process, tool, machine,
+                                               mmap_data)) {
                         err = -1;
                         break;
                 }
@@ -360,10 +365,10 @@ int perf_event__synthesize_thread_map(struct perf_tool *tool,
 
                         /* if not, generate events for it */
                         if (need_leader &&
-                            __event__synthesize_thread(comm_event,
-                                                      mmap_event,
-                                                      comm_event->comm.pid, 0,
-                                                      process, tool, machine)) {
+                            __event__synthesize_thread(comm_event, mmap_event,
+                                                       comm_event->comm.pid, 0,
+                                                       process, tool, machine,
+                                                       mmap_data)) {
                                 err = -1;
                                 break;
                         }
@@ -378,7 +383,7 @@ out:
 
 int perf_event__synthesize_threads(struct perf_tool *tool,
                                    perf_event__handler_t process,
-                                   struct machine *machine)
+                                   struct machine *machine, bool mmap_data)
 {
         DIR *proc;
         struct dirent dirent, *next;
@@ -408,7 +413,7 @@ int perf_event__synthesize_threads(struct perf_tool *tool,
                  * one thread couldn't be synthesized.
                  */
                 __event__synthesize_thread(comm_event, mmap_event, pid, 1,
-                                           process, tool, machine);
+                                           process, tool, machine, mmap_data);
         }
 
         err = 0;
@@ -516,52 +521,55 @@ size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp)
 
 int perf_event__process_comm(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
-                             struct perf_sample *sample __maybe_unused,
+                             struct perf_sample *sample,
                              struct machine *machine)
 {
-        return machine__process_comm_event(machine, event);
+        return machine__process_comm_event(machine, event, sample);
 }
 
 int perf_event__process_lost(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
-                             struct perf_sample *sample __maybe_unused,
+                             struct perf_sample *sample,
                              struct machine *machine)
 {
-        return machine__process_lost_event(machine, event);
+        return machine__process_lost_event(machine, event, sample);
 }
 
 size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp)
 {
-        return fprintf(fp, " %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64 "]: %s\n",
+        return fprintf(fp, " %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64 "]: %c %s\n",
                        event->mmap.pid, event->mmap.tid, event->mmap.start,
-                       event->mmap.len, event->mmap.pgoff, event->mmap.filename);
+                       event->mmap.len, event->mmap.pgoff,
+                       (event->header.misc & PERF_RECORD_MISC_MMAP_DATA) ? 'r' : 'x',
+                       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",
+                           " %02x:%02x %"PRIu64" %"PRIu64"]: %c %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->header.misc & PERF_RECORD_MISC_MMAP_DATA) ? 'r' : 'x',
                        event->mmap2.filename);
 }
 
 int perf_event__process_mmap(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
-                             struct perf_sample *sample __maybe_unused,
+                             struct perf_sample *sample,
                              struct machine *machine)
 {
-        return machine__process_mmap_event(machine, event);
+        return machine__process_mmap_event(machine, event, sample);
 }
 
 int perf_event__process_mmap2(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
-                             struct perf_sample *sample __maybe_unused,
+                             struct perf_sample *sample,
                              struct machine *machine)
 {
-        return machine__process_mmap2_event(machine, event);
+        return machine__process_mmap2_event(machine, event, sample);
 }
 
 size_t perf_event__fprintf_task(union perf_event *event, FILE *fp)
@@ -573,18 +581,18 @@ size_t perf_event__fprintf_task(union perf_event *event, FILE *fp)
 
 int perf_event__process_fork(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
-                             struct perf_sample *sample __maybe_unused,
+                             struct perf_sample *sample,
                              struct machine *machine)
 {
-        return machine__process_fork_event(machine, event);
+        return machine__process_fork_event(machine, event, sample);
 }
 
 int perf_event__process_exit(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
-                             struct perf_sample *sample __maybe_unused,
+                             struct perf_sample *sample,
                              struct machine *machine)
 {
-        return machine__process_exit_event(machine, event);
+        return machine__process_exit_event(machine, event, sample);
 }
 
 size_t perf_event__fprintf(union perf_event *event, FILE *fp)
@@ -615,21 +623,21 @@ size_t perf_event__fprintf(union perf_event *event, FILE *fp)
 
 int perf_event__process(struct perf_tool *tool __maybe_unused,
                         union perf_event *event,
-                        struct perf_sample *sample __maybe_unused,
+                        struct perf_sample *sample,
                         struct machine *machine)
 {
-        return machine__process_event(machine, event);
+        return machine__process_event(machine, event, sample);
 }
 
-void thread__find_addr_map(struct thread *self,
+void thread__find_addr_map(struct thread *thread,
                            struct machine *machine, u8 cpumode,
                            enum map_type type, u64 addr,
                            struct addr_location *al)
 {
-        struct map_groups *mg = &self->mg;
+        struct map_groups *mg = &thread->mg;
         bool load_map = false;
 
-        al->thread = self;
+        al->thread = thread;
         al->addr = addr;
         al->cpumode = cpumode;
         al->filtered = false;
@@ -725,10 +733,10 @@ int perf_event__preprocess_sample(const union perf_event *event,
                 return -1;
 
         if (symbol_conf.comm_list &&
-            !strlist__has_entry(symbol_conf.comm_list, thread->comm))
+            !strlist__has_entry(symbol_conf.comm_list, thread__comm_str(thread)))
                 goto out_filtered;
 
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->tid);
+        dump_printf(" ... thread: %s:%d\n", thread__comm_str(thread), thread->tid);
         /*
          * Have we already created the kernel maps for this machine?
          *