Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull perf updates from Ingo Molnar:
 "A number of fixes:

   - Fix segfault on perf trace -i perf.data, from Namhyung Kim.

   - Fix segfault with --no-mmap-pages, from David Ahern.

   - Don't force a refresh during progress update in the TUI, greatly
     reducing startup costs, fix from Patrick Palka.

   - Fix sw clock event period test wrt not checking if using >
     max_sample_freq.

   - Handle throttle events in 'object code reading' test, fix from
     Adrian Hunter.

   - Prevent condition that all sort keys are elided, fix from Namhyung
     Kim.

   - Round mmap pages to power 2, from David Ahern.

  And a number of late arrival changes:

   - Add summary only option to 'perf trace', suppressing the decoding
     of events, from David Ahern

   - 'perf trace --summary' formatting simplifications, from Pekka
     Enberg.

   - Beautify fifth argument of mmap() as fd, in 'perf trace', from
     Namhyung Kim.

   - Add direct access to dynamic arrays in libtraceevent, from Steven
     Rostedt.

   - Synthesize non-exec MMAP records when --data used, allowing the
     resolution of data addresses to symbols (global variables, etc), by
     Arnaldo Carvalho de Melo.

   - Code cleanups by David Ahern and Adrian Hunter"

* 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (23 commits)
  tools lib traceevent: Add direct access to dynamic arrays
  perf target: Shorten perf_target__ to target__
  perf tests: Handle throttle events in 'object code reading' test
  perf evlist: Refactor mmap_pages parsing
  perf evlist: Round mmap pages to power 2 - v2
  perf record: Fix segfault with --no-mmap-pages
  perf trace: Add summary only option
  perf trace: Simplify '--summary' output
  perf trace: Change syscall summary duration order
  perf tests: Compensate lower sample freq with longer test loop
  perf trace: Fix segfault on perf trace -i perf.data
  perf trace: Separate tp syscall field caching into init routine to be reused
  perf trace: Beautify fifth argument of mmap() as fd
  perf tests: Use lower sample_freq in sw clock event period test
  perf tests: Check return of perf_evlist__open sw clock event period test
  perf record: Move existing write_output into helper function
  perf record: Use correct return type for write()
  perf tools: Prevent condition that all sort keys are elided
  perf machine: Simplify synthesize_threads method
  perf machine: Introduce synthesize_threads method out of open coded equivalent
  ...

1 files changed, 30 insertions, 20 deletions

diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index ec9ae1114ed4..6e3a846aed0e 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;
@@ -188,10 +189,6 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
         }
 
         event->header.type = PERF_RECORD_MMAP;
-        /*
-         * Just like the kernel, see __perf_event_mmap in kernel/perf_event.c
-         */
-        event->header.misc = PERF_RECORD_MISC_USER;
 
         while (1) {
                 char bf[BUFSIZ];
@@ -215,9 +212,17 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
 
                 if (n != 5)
                         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);
@@ -304,20 +309,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;
@@ -334,7 +340,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;
                 }
@@ -356,10 +363,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;
                         }
@@ -374,7 +381,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;
@@ -404,7 +411,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;
@@ -528,19 +535,22 @@ int perf_event__process_lost(struct perf_tool *tool __maybe_unused,
 
 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);
 }