1 files changed, 215 insertions, 103 deletions

diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index cf1fe01b7e89..70ffa41518f3 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -1,4 +1,5 @@
 #include <linux/kernel.h>
+#include <traceevent/event-parse.h>
 
 #include <byteswap.h>
 #include <unistd.h>
@@ -12,7 +13,6 @@
 #include "sort.h"
 #include "util.h"
 #include "cpumap.h"
-#include "event-parse.h"
 #include "perf_regs.h"
 #include "vdso.h"
 
@@ -24,7 +24,7 @@ static int perf_session__open(struct perf_session *self, bool force)
                 self->fd_pipe = true;
                 self->fd = STDIN_FILENO;
 
-                if (perf_session__read_header(self, self->fd) < 0)
+                if (perf_session__read_header(self) < 0)
                         pr_err("incompatible file format (rerun with -v to learn more)");
 
                 return 0;
@@ -56,7 +56,7 @@ static int perf_session__open(struct perf_session *self, bool force)
                 goto out_close;
         }
 
-        if (perf_session__read_header(self, self->fd) < 0) {
+        if (perf_session__read_header(self) < 0) {
                 pr_err("incompatible file format (rerun with -v to learn more)");
                 goto out_close;
         }
@@ -71,6 +71,11 @@ static int perf_session__open(struct perf_session *self, bool force)
                 goto out_close;
         }
 
+        if (!perf_evlist__valid_read_format(self->evlist)) {
+                pr_err("non matching read_format");
+                goto out_close;
+        }
+
         self->size = input_stat.st_size;
         return 0;
 
@@ -193,7 +198,9 @@ void perf_session__delete(struct perf_session *self)
         vdso__exit();
 }
 
-static int process_event_synth_tracing_data_stub(union perf_event *event
+static int process_event_synth_tracing_data_stub(struct perf_tool *tool
+                                                 __maybe_unused,
+                                                 union perf_event *event
                                                  __maybe_unused,
                                                  struct perf_session *session
                                                 __maybe_unused)
@@ -202,7 +209,8 @@ static int process_event_synth_tracing_data_stub(union perf_event *event
         return 0;
 }
 
-static int process_event_synth_attr_stub(union perf_event *event __maybe_unused,
+static int process_event_synth_attr_stub(struct perf_tool *tool __maybe_unused,
+                                         union perf_event *event __maybe_unused,
                                          struct perf_evlist **pevlist
                                          __maybe_unused)
 {
@@ -238,18 +246,11 @@ static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
         return 0;
 }
 
-static int process_event_type_stub(struct perf_tool *tool __maybe_unused,
-                                   union perf_event *event __maybe_unused)
-{
-        dump_printf(": unhandled!\n");
-        return 0;
-}
-
 static int process_finished_round(struct perf_tool *tool,
                                   union perf_event *event,
                                   struct perf_session *session);
 
-static void perf_tool__fill_defaults(struct perf_tool *tool)
+void perf_tool__fill_defaults(struct perf_tool *tool)
 {
         if (tool->sample == NULL)
                 tool->sample = process_event_sample_stub;
@@ -271,8 +272,6 @@ static void perf_tool__fill_defaults(struct perf_tool *tool)
                 tool->unthrottle = process_event_stub;
         if (tool->attr == NULL)
                 tool->attr = process_event_synth_attr_stub;
-        if (tool->event_type == NULL)
-                tool->event_type = process_event_type_stub;
         if (tool->tracing_data == NULL)
                 tool->tracing_data = process_event_synth_tracing_data_stub;
         if (tool->build_id == NULL)
@@ -352,6 +351,25 @@ static void perf_event__mmap_swap(union perf_event *event,
         }
 }
 
+static void perf_event__mmap2_swap(union perf_event *event,
+                                  bool sample_id_all)
+{
+        event->mmap2.pid   = bswap_32(event->mmap2.pid);
+        event->mmap2.tid   = bswap_32(event->mmap2.tid);
+        event->mmap2.start = bswap_64(event->mmap2.start);
+        event->mmap2.len   = bswap_64(event->mmap2.len);
+        event->mmap2.pgoff = bswap_64(event->mmap2.pgoff);
+        event->mmap2.maj   = bswap_32(event->mmap2.maj);
+        event->mmap2.min   = bswap_32(event->mmap2.min);
+        event->mmap2.ino   = bswap_64(event->mmap2.ino);
+
+        if (sample_id_all) {
+                void *data = &event->mmap2.filename;
+
+                data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
+                swap_sample_id_all(event, data);
+        }
+}
 static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
 {
         event->fork.pid  = bswap_32(event->fork.pid);
@@ -456,6 +474,7 @@ typedef void (*perf_event__swap_op)(union perf_event *event,
 
 static perf_event__swap_op perf_event__swap_ops[] = {
         [PERF_RECORD_MMAP]                = perf_event__mmap_swap,
+        [PERF_RECORD_MMAP2]               = perf_event__mmap2_swap,
         [PERF_RECORD_COMM]                = perf_event__comm_swap,
         [PERF_RECORD_FORK]                = perf_event__task_swap,
         [PERF_RECORD_EXIT]                = perf_event__task_swap,
@@ -496,7 +515,7 @@ static int perf_session_deliver_event(struct perf_session *session,
                                       u64 file_offset);
 
 static int flush_sample_queue(struct perf_session *s,
-                               struct perf_tool *tool)
+                       struct perf_tool *tool)
 {
         struct ordered_samples *os = &s->ordered_samples;
         struct list_head *head = &os->samples;
@@ -505,12 +524,16 @@ static int flush_sample_queue(struct perf_session *s,
         u64 limit = os->next_flush;
         u64 last_ts = os->last_sample ? os->last_sample->timestamp : 0ULL;
         unsigned idx = 0, progress_next = os->nr_samples / 16;
+        bool show_progress = limit == ULLONG_MAX;
         int ret;
 
         if (!tool->ordered_samples || !limit)
                 return 0;
 
         list_for_each_entry_safe(iter, tmp, head, list) {
+                if (session_done())
+                        return 0;
+
                 if (iter->timestamp > limit)
                         break;
 
@@ -527,7 +550,7 @@ static int flush_sample_queue(struct perf_session *s,
                 os->last_flush = iter->timestamp;
                 list_del(&iter->list);
                 list_add(&iter->list, &os->sample_cache);
-                if (++idx >= progress_next) {
+                if (show_progress && (++idx >= progress_next)) {
                         progress_next += os->nr_samples / 16;
                         ui_progress__update(idx, os->nr_samples,
                                             "Processing time ordered events...");
@@ -644,7 +667,7 @@ static void __queue_event(struct sample_queue *new, struct perf_session *s)
 
 #define MAX_SAMPLE_BUFFER       (64 * 1024 / sizeof(struct sample_queue))
 
-static int perf_session_queue_event(struct perf_session *s, union perf_event *event,
+int perf_session_queue_event(struct perf_session *s, union perf_event *event,
                                     struct perf_sample *sample, u64 file_offset)
 {
         struct ordered_samples *os = &s->ordered_samples;
@@ -740,7 +763,7 @@ static void perf_session__print_tstamp(struct perf_session *session,
                                        union perf_event *event,
                                        struct perf_sample *sample)
 {
-        u64 sample_type = perf_evlist__sample_type(session->evlist);
+        u64 sample_type = __perf_evlist__combined_sample_type(session->evlist);
 
         if (event->header.type != PERF_RECORD_SAMPLE &&
             !perf_evlist__sample_id_all(session->evlist)) {
@@ -755,6 +778,36 @@ static void perf_session__print_tstamp(struct perf_session *session,
                 printf("%" PRIu64 " ", sample->time);
 }
 
+static void sample_read__printf(struct perf_sample *sample, u64 read_format)
+{
+        printf("... sample_read:\n");
+
+        if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
+                printf("...... time enabled %016" PRIx64 "\n",
+                       sample->read.time_enabled);
+
+        if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
+                printf("...... time running %016" PRIx64 "\n",
+                       sample->read.time_running);
+
+        if (read_format & PERF_FORMAT_GROUP) {
+                u64 i;
+
+                printf(".... group nr %" PRIu64 "\n", sample->read.group.nr);
+
+                for (i = 0; i < sample->read.group.nr; i++) {
+                        struct sample_read_value *value;
+
+                        value = &sample->read.group.values[i];
+                        printf("..... id %016" PRIx64
+                               ", value %016" PRIx64 "\n",
+                               value->id, value->value);
+                }
+        } else
+                printf("..... id %016" PRIx64 ", value %016" PRIx64 "\n",
+                        sample->read.one.id, sample->read.one.value);
+}
+
 static void dump_event(struct perf_session *session, union perf_event *event,
                        u64 file_offset, struct perf_sample *sample)
 {
@@ -804,11 +857,15 @@ static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
 
         if (sample_type & PERF_SAMPLE_DATA_SRC)
                 printf(" . data_src: 0x%"PRIx64"\n", sample->data_src);
+
+        if (sample_type & PERF_SAMPLE_READ)
+                sample_read__printf(sample, evsel->attr.read_format);
 }
 
 static struct machine *
         perf_session__find_machine_for_cpumode(struct perf_session *session,
-                                               union perf_event *event)
+                                               union perf_event *event,
+                                               struct perf_sample *sample)
 {
         const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
@@ -817,10 +874,11 @@ static struct machine *
              (cpumode == PERF_RECORD_MISC_GUEST_USER))) {
                 u32 pid;
 
-                if (event->header.type == PERF_RECORD_MMAP)
+                if (event->header.type == PERF_RECORD_MMAP
+                    || event->header.type == PERF_RECORD_MMAP2)
                         pid = event->mmap.pid;
                 else
-                        pid = event->ip.pid;
+                        pid = sample->pid;
 
                 return perf_session__findnew_machine(session, pid);
         }
@@ -828,6 +886,75 @@ static struct machine *
         return &session->machines.host;
 }
 
+static int deliver_sample_value(struct perf_session *session,
+                                struct perf_tool *tool,
+                                union perf_event *event,
+                                struct perf_sample *sample,
+                                struct sample_read_value *v,
+                                struct machine *machine)
+{
+        struct perf_sample_id *sid;
+
+        sid = perf_evlist__id2sid(session->evlist, v->id);
+        if (sid) {
+                sample->id     = v->id;
+                sample->period = v->value - sid->period;
+                sid->period    = v->value;
+        }
+
+        if (!sid || sid->evsel == NULL) {
+                ++session->stats.nr_unknown_id;
+                return 0;
+        }
+
+        return tool->sample(tool, event, sample, sid->evsel, machine);
+}
+
+static int deliver_sample_group(struct perf_session *session,
+                                struct perf_tool *tool,
+                                union  perf_event *event,
+                                struct perf_sample *sample,
+                                struct machine *machine)
+{
+        int ret = -EINVAL;
+        u64 i;
+
+        for (i = 0; i < sample->read.group.nr; i++) {
+                ret = deliver_sample_value(session, tool, event, sample,
+                                           &sample->read.group.values[i],
+                                           machine);
+                if (ret)
+                        break;
+        }
+
+        return ret;
+}
+
+static int
+perf_session__deliver_sample(struct perf_session *session,
+                             struct perf_tool *tool,
+                             union  perf_event *event,
+                             struct perf_sample *sample,
+                             struct perf_evsel *evsel,
+                             struct machine *machine)
+{
+        /* We know evsel != NULL. */
+        u64 sample_type = evsel->attr.sample_type;
+        u64 read_format = evsel->attr.read_format;
+
+        /* Standard sample delievery. */
+        if (!(sample_type & PERF_SAMPLE_READ))
+                return tool->sample(tool, event, sample, evsel, machine);
+
+        /* For PERF_SAMPLE_READ we have either single or group mode. */
+        if (read_format & PERF_FORMAT_GROUP)
+                return deliver_sample_group(session, tool, event, sample,
+                                            machine);
+        else
+                return deliver_sample_value(session, tool, event, sample,
+                                            &sample->read.one, machine);
+}
+
 static int perf_session_deliver_event(struct perf_session *session,
                                       union perf_event *event,
                                       struct perf_sample *sample,
@@ -857,7 +984,8 @@ static int perf_session_deliver_event(struct perf_session *session,
                 hists__inc_nr_events(&evsel->hists, event->header.type);
         }
 
-        machine = perf_session__find_machine_for_cpumode(session, event);
+        machine = perf_session__find_machine_for_cpumode(session, event,
+                                                         sample);
 
         switch (event->header.type) {
         case PERF_RECORD_SAMPLE:
@@ -870,9 +998,12 @@ static int perf_session_deliver_event(struct perf_session *session,
                         ++session->stats.nr_unprocessable_samples;
                         return 0;
                 }
-                return tool->sample(tool, event, sample, evsel, machine);
+                return perf_session__deliver_sample(session, tool, event,
+                                                    sample, evsel, machine);
         case PERF_RECORD_MMAP:
                 return tool->mmap(tool, event, sample, machine);
+        case PERF_RECORD_MMAP2:
+                return tool->mmap2(tool, event, sample, machine);
         case PERF_RECORD_COMM:
                 return tool->comm(tool, event, sample, machine);
         case PERF_RECORD_FORK:
@@ -895,22 +1026,6 @@ static int perf_session_deliver_event(struct perf_session *session,
         }
 }
 
-static int perf_session__preprocess_sample(struct perf_session *session,
-                                           union perf_event *event, struct perf_sample *sample)
-{
-        if (event->header.type != PERF_RECORD_SAMPLE ||
-            !(perf_evlist__sample_type(session->evlist) & PERF_SAMPLE_CALLCHAIN))
-                return 0;
-
-        if (!ip_callchain__valid(sample->callchain, event)) {
-                pr_debug("call-chain problem with event, skipping it.\n");
-                ++session->stats.nr_invalid_chains;
-                session->stats.total_invalid_chains += sample->period;
-                return -EINVAL;
-        }
-        return 0;
-}
-
 static int perf_session__process_user_event(struct perf_session *session, union perf_event *event,
                                             struct perf_tool *tool, u64 file_offset)
 {
@@ -921,16 +1036,14 @@ static int perf_session__process_user_event(struct perf_session *session, union
         /* These events are processed right away */
         switch (event->header.type) {
         case PERF_RECORD_HEADER_ATTR:
-                err = tool->attr(event, &session->evlist);
+                err = tool->attr(tool, event, &session->evlist);
                 if (err == 0)
                         perf_session__set_id_hdr_size(session);
                 return err;
-        case PERF_RECORD_HEADER_EVENT_TYPE:
-                return tool->event_type(tool, event);
         case PERF_RECORD_HEADER_TRACING_DATA:
                 /* setup for reading amidst mmap */
                 lseek(session->fd, file_offset, SEEK_SET);
-                return tool->tracing_data(event, session);
+                return tool->tracing_data(tool, event, session);
         case PERF_RECORD_HEADER_BUILD_ID:
                 return tool->build_id(tool, event, session);
         case PERF_RECORD_FINISHED_ROUND:
@@ -975,10 +1088,6 @@ static int perf_session__process_event(struct perf_session *session,
         if (ret)
                 return ret;
 
-        /* Preprocess sample records - precheck callchains */
-        if (perf_session__preprocess_sample(session, event, &sample))
-                return 0;
-
         if (tool->ordered_samples) {
                 ret = perf_session_queue_event(session, event, &sample,
                                                file_offset);
@@ -999,7 +1108,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)
@@ -1054,7 +1163,6 @@ static void perf_session__warn_about_errors(const struct perf_session *session,
         }
 }
 
-#define session_done()  (*(volatile int *)(&session_done))
 volatile int session_done;
 
 static int __perf_session__process_pipe_events(struct perf_session *self,
@@ -1091,8 +1199,10 @@ more:
                 perf_event_header__bswap(&event->header);
 
         size = event->header.size;
-        if (size == 0)
-                size = 8;
+        if (size < sizeof(struct perf_event_header)) {
+                pr_err("bad event header size\n");
+                goto out_err;
+        }
 
         if (size > cur_size) {
                 void *new = realloc(buf, size);
@@ -1161,8 +1271,12 @@ fetch_mmaped_event(struct perf_session *session,
         if (session->header.needs_swap)
                 perf_event_header__bswap(&event->header);
 
-        if (head + event->header.size > mmap_size)
+        if (head + event->header.size > mmap_size) {
+                /* We're not fetching the event so swap back again */
+                if (session->header.needs_swap)
+                        perf_event_header__bswap(&event->header);
                 return NULL;
+        }
 
         return event;
 }
@@ -1242,7 +1356,7 @@ more:
 
         size = event->header.size;
 
-        if (size == 0 ||
+        if (size < sizeof(struct perf_event_header) ||
             perf_session__process_event(session, event, tool, file_pos) < 0) {
                 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
                        file_offset + head, event->header.size,
@@ -1260,10 +1374,13 @@ more:
                                     "Processing events...");
         }
 
+        err = 0;
+        if (session_done())
+                goto out_err;
+
         if (file_pos < file_size)
                 goto more;
 
-        err = 0;
         /* do the final flush for ordered samples */
         session->ordered_samples.next_flush = ULLONG_MAX;
         err = flush_sample_queue(session, tool);
@@ -1295,12 +1412,15 @@ int perf_session__process_events(struct perf_session *self,
 
 bool perf_session__has_traces(struct perf_session *session, const char *msg)
 {
-        if (!(perf_evlist__sample_type(session->evlist) & PERF_SAMPLE_RAW)) {
-                pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
-                return false;
+        struct perf_evsel *evsel;
+
+        list_for_each_entry(evsel, &session->evlist->entries, node) {
+                if (evsel->attr.type == PERF_TYPE_TRACEPOINT)
+                        return true;
         }
 
-        return true;
+        pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
+        return false;
 }
 
 int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
@@ -1383,13 +1503,18 @@ struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
 
 void perf_evsel__print_ip(struct perf_evsel *evsel, union perf_event *event,
                           struct perf_sample *sample, struct machine *machine,
-                          int print_sym, int print_dso, int print_symoffset)
+                          unsigned int print_opts, unsigned int stack_depth)
 {
         struct addr_location al;
         struct callchain_cursor_node *node;
-
-        if (perf_event__preprocess_sample(event, machine, &al, sample,
-                                          NULL) < 0) {
+        int print_ip = print_opts & PRINT_IP_OPT_IP;
+        int print_sym = print_opts & PRINT_IP_OPT_SYM;
+        int print_dso = print_opts & PRINT_IP_OPT_DSO;
+        int print_symoffset = print_opts & PRINT_IP_OPT_SYMOFFSET;
+        int print_oneline = print_opts & PRINT_IP_OPT_ONELINE;
+        char s = print_oneline ? ' ' : '\t';
+
+        if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
                 error("problem processing %d event, skipping it.\n",
                         event->header.type);
                 return;
@@ -1397,37 +1522,50 @@ void perf_evsel__print_ip(struct perf_evsel *evsel, union perf_event *event,
 
         if (symbol_conf.use_callchain && sample->callchain) {
 
-
                 if (machine__resolve_callchain(machine, evsel, al.thread,
-                                               sample, NULL) != 0) {
+                                               sample, NULL, NULL) != 0) {
                         if (verbose)
                                 error("Failed to resolve callchain. Skipping\n");
                         return;
                 }
                 callchain_cursor_commit(&callchain_cursor);
 
-                while (1) {
+                while (stack_depth) {
                         node = callchain_cursor_current(&callchain_cursor);
                         if (!node)
                                 break;
 
-                        printf("\t%16" PRIx64, node->ip);
+                        if (print_ip)
+                                printf("%c%16" PRIx64, s, node->ip);
+
                         if (print_sym) {
                                 printf(" ");
-                                symbol__fprintf_symname(node->sym, stdout);
+                                if (print_symoffset) {
+                                        al.addr = node->ip;
+                                        al.map  = node->map;
+                                        symbol__fprintf_symname_offs(node->sym, &al, stdout);
+                                } else
+                                        symbol__fprintf_symname(node->sym, stdout);
                         }
+
                         if (print_dso) {
                                 printf(" (");
                                 map__fprintf_dsoname(node->map, stdout);
                                 printf(")");
                         }
-                        printf("\n");
+
+                        if (!print_oneline)
+                                printf("\n");
 
                         callchain_cursor_advance(&callchain_cursor);
+
+                        stack_depth--;
                 }
 
         } else {
-                printf("%16" PRIx64, sample->ip);
+                if (print_ip)
+                        printf("%16" PRIx64, sample->ip);
+
                 if (print_sym) {
                         printf(" ");
                         if (print_symoffset)
@@ -1510,52 +1648,26 @@ int __perf_session__set_tracepoints_handlers(struct perf_session *session,
                                              const struct perf_evsel_str_handler *assocs,
                                              size_t nr_assocs)
 {
-        struct perf_evlist *evlist = session->evlist;
-        struct event_format *format;
         struct perf_evsel *evsel;
-        char *tracepoint, *name;
         size_t i;
         int err;
 
         for (i = 0; i < nr_assocs; i++) {
-                err = -ENOMEM;
-                tracepoint = strdup(assocs[i].name);
-                if (tracepoint == NULL)
-                        goto out;
-
-                err = -ENOENT;
-                name = strchr(tracepoint, ':');
-                if (name == NULL)
-                        goto out_free;
-
-                *name++ = '\0';
-                format = pevent_find_event_by_name(session->pevent,
-                                                   tracepoint, name);
-                if (format == NULL) {
-                        /*
-                         * Adding a handler for an event not in the session,
-                         * just ignore it.
-                         */
-                        goto next;
-                }
-
-                evsel = perf_evlist__find_tracepoint_by_id(evlist, format->id);
+                /*
+                 * Adding a handler for an event not in the session,
+                 * just ignore it.
+                 */
+                evsel = perf_evlist__find_tracepoint_by_name(session->evlist, assocs[i].name);
                 if (evsel == NULL)
-                        goto next;
+                        continue;
 
                 err = -EEXIST;
                 if (evsel->handler.func != NULL)
-                        goto out_free;
+                        goto out;
                 evsel->handler.func = assocs[i].handler;
-next:
-                free(tracepoint);
         }
 
         err = 0;
 out:
         return err;
-
-out_free:
-        free(tracepoint);
-        goto out;
 }