Merge tag 'perf-core-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core

Pull perf/core improvements and fixes from Arnaldo Carvalho de Melo:

 * Convert the trace builtins to use the growing evsel/evlist
   tracepoint infrastructure, removing several open coded constructs
   like switch like series of strcmp to dispatch events, etc.
   Basically what had already been showcased in 'perf sched'.

 * Add evsel constructor for tracepoints, that uses libtraceevent
   just to parse the /format events file, use it in a new 'perf test'
   to make sure the libtraceevent format parsing regressions can
   be more readily caught.

 * Some strange errors were happening in some builds, but not on the
   next, reported by several people, problem was some parser related
   files, generated during the build, didn't had proper make deps,
   fix from Eric Sandeen.

 * Fix some compiling errors on 32-bit, from Feng Tang.

 * Don't use sscanf extension %as, not available on bionic, reimplementation
   by Irina Tirdea.

 * Fix bfd.h/libbfd detection with recent binutils, from Markus Trippelsdorf.

 * Introduce struct and cache information about the environment where a
   perf.data file was captured, from Namhyung Kim.

 * Fix several error paths in libtraceevent, from Namhyung Kim.

   Print event causing perf_event_open() to fail in 'perf record',
   from Stephane Eranian.

 * New 'kvm' analysis tool, from Xiao Guangrong.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

10 files changed, 538 insertions, 190 deletions

diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 1506ba0453f1..00936ad29ff2 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -10,6 +10,7 @@
 #include <byteswap.h>
 #include <linux/bitops.h>
 #include "asm/bug.h"
+#include "debugfs.h"
 #include "event-parse.h"
 #include "evsel.h"
 #include "evlist.h"
@@ -69,6 +70,72 @@ struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx)
         return evsel;
 }
 
+static struct event_format *event_format__new(const char *sys, const char *name)
+{
+        int fd, n;
+        char *filename;
+        void *bf = NULL, *nbf;
+        size_t size = 0, alloc_size = 0;
+        struct event_format *format = NULL;
+
+        if (asprintf(&filename, "%s/%s/%s/format", tracing_events_path, sys, name) < 0)
+                goto out;
+
+        fd = open(filename, O_RDONLY);
+        if (fd < 0)
+                goto out_free_filename;
+
+        do {
+                if (size == alloc_size) {
+                        alloc_size += BUFSIZ;
+                        nbf = realloc(bf, alloc_size);
+                        if (nbf == NULL)
+                                goto out_free_bf;
+                        bf = nbf;
+                }
+
+                n = read(fd, bf + size, BUFSIZ);
+                if (n < 0)
+                        goto out_free_bf;
+                size += n;
+        } while (n > 0);
+
+        pevent_parse_format(&format, bf, size, sys);
+
+out_free_bf:
+        free(bf);
+        close(fd);
+out_free_filename:
+        free(filename);
+out:
+        return format;
+}
+
+struct perf_evsel *perf_evsel__newtp(const char *sys, const char *name, int idx)
+{
+        struct perf_evsel *evsel = zalloc(sizeof(*evsel));
+
+        if (evsel != NULL) {
+                struct perf_event_attr attr = {
+                        .type = PERF_TYPE_TRACEPOINT,
+                };
+
+                evsel->tp_format = event_format__new(sys, name);
+                if (evsel->tp_format == NULL)
+                        goto out_free;
+
+                attr.config = evsel->tp_format->id;
+                perf_evsel__init(evsel, &attr, idx);
+                evsel->name = evsel->tp_format->name;
+        }
+
+        return evsel;
+
+out_free:
+        free(evsel);
+        return NULL;
+}
+
 const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX] = {
         "cycles",
         "instructions",
@@ -495,6 +562,10 @@ void perf_evsel__delete(struct perf_evsel *evsel)
         perf_evsel__exit(evsel);
         close_cgroup(evsel->cgrp);
         free(evsel->group_name);
+        if (evsel->tp_format && evsel->name == evsel->tp_format->name) {
+                evsel->name = NULL;
+                pevent_free_format(evsel->tp_format);
+        }
         free(evsel->name);
         free(evsel);
 }
@@ -1002,14 +1073,19 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type,
         return 0;
 }
 
+struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name)
+{
+        return pevent_find_field(evsel->tp_format, name);
+}
+
 char *perf_evsel__strval(struct perf_evsel *evsel, struct perf_sample *sample,
                          const char *name)
 {
-        struct format_field *field = pevent_find_field(evsel->tp_format, name);
+        struct format_field *field = perf_evsel__field(evsel, name);
         int offset;
 
-        if (!field)
-                return NULL;
+        if (!field)
+                return NULL;
 
         offset = field->offset;
 
@@ -1024,11 +1100,11 @@ char *perf_evsel__strval(struct perf_evsel *evsel, struct perf_sample *sample,
 u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
                        const char *name)
 {
-        struct format_field *field = pevent_find_field(evsel->tp_format, name);
+        struct format_field *field = perf_evsel__field(evsel, name);
         u64 val;
 
-        if (!field)
-                return 0;
+        if (!field)
+                return 0;
 
         val = pevent_read_number(evsel->tp_format->pevent,
                                  sample->raw_data + field->offset, field->size);
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 93876bad2e52..bb445d1cbc7b 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -81,6 +81,7 @@ struct perf_evlist;
 struct perf_record_opts;
 
 struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx);
+struct perf_evsel *perf_evsel__newtp(const char *sys, const char *name, int idx);
 void perf_evsel__init(struct perf_evsel *evsel,
                       struct perf_event_attr *attr, int idx);
 void perf_evsel__exit(struct perf_evsel *evsel);
@@ -128,6 +129,10 @@ char *perf_evsel__strval(struct perf_evsel *evsel, struct perf_sample *sample,
 u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
                        const char *name);
 
+struct format_field;
+
+struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name);
+
 #define perf_evsel__match(evsel, t, c)          \
         (evsel->attr.type == PERF_TYPE_##t &&   \
          evsel->attr.config == PERF_COUNT_##c)
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index acbf6336199e..6aae3290358e 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -22,6 +22,7 @@
 #include "cpumap.h"
 #include "pmu.h"
 #include "vdso.h"
+#include "strbuf.h"
 
 static bool no_buildid_cache = false;
 
@@ -1102,118 +1103,80 @@ static int write_branch_stack(int fd __maybe_unused,
         return 0;
 }
 
-static void print_hostname(struct perf_header *ph, int fd, FILE *fp)
+static void print_hostname(struct perf_header *ph, int fd __maybe_unused,
+                           FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# hostname : %s\n", str);
-        free(str);
+        fprintf(fp, "# hostname : %s\n", ph->env.hostname);
 }
 
-static void print_osrelease(struct perf_header *ph, int fd, FILE *fp)
+static void print_osrelease(struct perf_header *ph, int fd __maybe_unused,
+                            FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# os release : %s\n", str);
-        free(str);
+        fprintf(fp, "# os release : %s\n", ph->env.os_release);
 }
 
-static void print_arch(struct perf_header *ph, int fd, FILE *fp)
+static void print_arch(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# arch : %s\n", str);
-        free(str);
+        fprintf(fp, "# arch : %s\n", ph->env.arch);
 }
 
-static void print_cpudesc(struct perf_header *ph, int fd, FILE *fp)
+static void print_cpudesc(struct perf_header *ph, int fd __maybe_unused,
+                          FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# cpudesc : %s\n", str);
-        free(str);
+        fprintf(fp, "# cpudesc : %s\n", ph->env.cpu_desc);
 }
 
-static void print_nrcpus(struct perf_header *ph, int fd, FILE *fp)
+static void print_nrcpus(struct perf_header *ph, int fd __maybe_unused,
+                         FILE *fp)
 {
-        ssize_t ret;
-        u32 nr;
-
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                nr = -1; /* interpreted as error */
-
-        if (ph->needs_swap)
-                nr = bswap_32(nr);
-
-        fprintf(fp, "# nrcpus online : %u\n", nr);
-
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                nr = -1; /* interpreted as error */
-
-        if (ph->needs_swap)
-                nr = bswap_32(nr);
-
-        fprintf(fp, "# nrcpus avail : %u\n", nr);
+        fprintf(fp, "# nrcpus online : %u\n", ph->env.nr_cpus_online);
+        fprintf(fp, "# nrcpus avail : %u\n", ph->env.nr_cpus_avail);
 }
 
-static void print_version(struct perf_header *ph, int fd, FILE *fp)
+static void print_version(struct perf_header *ph, int fd __maybe_unused,
+                          FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# perf version : %s\n", str);
-        free(str);
+        fprintf(fp, "# perf version : %s\n", ph->env.version);
 }
 
-static void print_cmdline(struct perf_header *ph, int fd, FILE *fp)
+static void print_cmdline(struct perf_header *ph, int fd __maybe_unused,
+                          FILE *fp)
 {
-        ssize_t ret;
+        int nr, i;
         char *str;
-        u32 nr, i;
-
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                return;
 
-        if (ph->needs_swap)
-                nr = bswap_32(nr);
+        nr = ph->env.nr_cmdline;
+        str = ph->env.cmdline;
 
         fprintf(fp, "# cmdline : ");
 
         for (i = 0; i < nr; i++) {
-                str = do_read_string(fd, ph);
                 fprintf(fp, "%s ", str);
-                free(str);
+                str += strlen(str) + 1;
         }
         fputc('\n', fp);
 }
 
-static void print_cpu_topology(struct perf_header *ph, int fd, FILE *fp)
+static void print_cpu_topology(struct perf_header *ph, int fd __maybe_unused,
+                               FILE *fp)
 {
-        ssize_t ret;
-        u32 nr, i;
+        int nr, i;
         char *str;
 
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                return;
-
-        if (ph->needs_swap)
-                nr = bswap_32(nr);
+        nr = ph->env.nr_sibling_cores;
+        str = ph->env.sibling_cores;
 
         for (i = 0; i < nr; i++) {
-                str = do_read_string(fd, ph);
                 fprintf(fp, "# sibling cores   : %s\n", str);
-                free(str);
+                str += strlen(str) + 1;
         }
 
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                return;
-
-        if (ph->needs_swap)
-                nr = bswap_32(nr);
+        nr = ph->env.nr_sibling_threads;
+        str = ph->env.sibling_threads;
 
         for (i = 0; i < nr; i++) {
-                str = do_read_string(fd, ph);
                 fprintf(fp, "# sibling threads : %s\n", str);
-                free(str);
+                str += strlen(str) + 1;
         }
 }
 
@@ -1374,126 +1337,89 @@ static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
         free_event_desc(events);
 }
 
-static void print_total_mem(struct perf_header *h __maybe_unused, int fd,
+static void print_total_mem(struct perf_header *ph, int fd __maybe_unused,
                             FILE *fp)
 {
-        uint64_t mem;
-        ssize_t ret;
-
-        ret = read(fd, &mem, sizeof(mem));
-        if (ret != sizeof(mem))
-                goto error;
-
-        if (h->needs_swap)
-                mem = bswap_64(mem);
-
-        fprintf(fp, "# total memory : %"PRIu64" kB\n", mem);
-        return;
-error:
-        fprintf(fp, "# total memory : unknown\n");
+        fprintf(fp, "# total memory : %Lu kB\n", ph->env.total_mem);
 }
 
-static void print_numa_topology(struct perf_header *h __maybe_unused, int fd,
+static void print_numa_topology(struct perf_header *ph, int fd __maybe_unused,
                                 FILE *fp)
 {
-        ssize_t ret;
         u32 nr, c, i;
-        char *str;
+        char *str, *tmp;
         uint64_t mem_total, mem_free;
 
         /* nr nodes */
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                goto error;
-
-        if (h->needs_swap)
-                nr = bswap_32(nr);
+        nr = ph->env.nr_numa_nodes;
+        str = ph->env.numa_nodes;
 
         for (i = 0; i < nr; i++) {
-
                 /* node number */
-                ret = read(fd, &c, sizeof(c));
-                if (ret != (ssize_t)sizeof(c))
+                c = strtoul(str, &tmp, 0);
+                if (*tmp != ':')
                         goto error;
 
-                if (h->needs_swap)
-                        c = bswap_32(c);
-
-                ret = read(fd, &mem_total, sizeof(u64));
-                if (ret != sizeof(u64))
+                str = tmp + 1;
+                mem_total = strtoull(str, &tmp, 0);
+                if (*tmp != ':')
                         goto error;
 
-                ret = read(fd, &mem_free, sizeof(u64));
-                if (ret != sizeof(u64))
+                str = tmp + 1;
+                mem_free = strtoull(str, &tmp, 0);
+                if (*tmp != ':')
                         goto error;
 
-                if (h->needs_swap) {
-                        mem_total = bswap_64(mem_total);
-                        mem_free = bswap_64(mem_free);
-                }
-
                 fprintf(fp, "# node%u meminfo  : total = %"PRIu64" kB,"
                             " free = %"PRIu64" kB\n",
-                        c,
-                        mem_total,
-                        mem_free);
+                        c, mem_total, mem_free);
 
-                str = do_read_string(fd, h);
+                str = tmp + 1;
                 fprintf(fp, "# node%u cpu list : %s\n", c, str);
-                free(str);
         }
         return;
 error:
         fprintf(fp, "# numa topology : not available\n");
 }
 
-static void print_cpuid(struct perf_header *ph, int fd, FILE *fp)
+static void print_cpuid(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# cpuid : %s\n", str);
-        free(str);
+        fprintf(fp, "# cpuid : %s\n", ph->env.cpuid);
 }
 
 static void print_branch_stack(struct perf_header *ph __maybe_unused,
-                               int fd __maybe_unused,
-                               FILE *fp)
+                               int fd __maybe_unused, FILE *fp)
 {
         fprintf(fp, "# contains samples with branch stack\n");
 }
 
-static void print_pmu_mappings(struct perf_header *ph, int fd, FILE *fp)
+static void print_pmu_mappings(struct perf_header *ph, int fd __maybe_unused,
+                               FILE *fp)
 {
         const char *delimiter = "# pmu mappings: ";
-        char *name;
-        int ret;
+        char *str, *tmp;
         u32 pmu_num;
         u32 type;
 
-        ret = read(fd, &pmu_num, sizeof(pmu_num));
-        if (ret != sizeof(pmu_num))
-                goto error;
-
-        if (ph->needs_swap)
-                pmu_num = bswap_32(pmu_num);
-
+        pmu_num = ph->env.nr_pmu_mappings;
         if (!pmu_num) {
                 fprintf(fp, "# pmu mappings: not available\n");
                 return;
         }
 
+        str = ph->env.pmu_mappings;
+
         while (pmu_num) {
-                if (read(fd, &type, sizeof(type)) != sizeof(type))
-                        break;
-                if (ph->needs_swap)
-                        type = bswap_32(type);
+                type = strtoul(str, &tmp, 0);
+                if (*tmp != ':')
+                        goto error;
+
+                str = tmp + 1;
+                fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type);
 
-                name = do_read_string(fd, ph);
-                if (!name)
-                        break;
-                pmu_num--;
-                fprintf(fp, "%s%s = %" PRIu32, delimiter, name, type);
-                free(name);
                 delimiter = ", ";
+                str += strlen(str) + 1;
+                pmu_num--;
         }
 
         fprintf(fp, "\n");
@@ -1654,18 +1580,16 @@ out:
         return err;
 }
 
-static int process_tracing_data(struct perf_file_section *section
-                                __maybe_unused,
-                              struct perf_header *ph __maybe_unused,
-                              int feat __maybe_unused, int fd, void *data)
+static int process_tracing_data(struct perf_file_section *section __maybe_unused,
+                                struct perf_header *ph __maybe_unused,
+                                int fd, void *data)
 {
         trace_report(fd, data, false);
         return 0;
 }
 
 static int process_build_id(struct perf_file_section *section,
-                            struct perf_header *ph,
-                            int feat __maybe_unused, int fd,
+                            struct perf_header *ph, int fd,
                             void *data __maybe_unused)
 {
         if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
@@ -1673,6 +1597,99 @@ static int process_build_id(struct perf_file_section *section,
         return 0;
 }
 
+static int process_hostname(struct perf_file_section *section __maybe_unused,
+                            struct perf_header *ph, int fd,
+                            void *data __maybe_unused)
+{
+        ph->env.hostname = do_read_string(fd, ph);
+        return ph->env.hostname ? 0 : -ENOMEM;
+}
+
+static int process_osrelease(struct perf_file_section *section __maybe_unused,
+                             struct perf_header *ph, int fd,
+                             void *data __maybe_unused)
+{
+        ph->env.os_release = do_read_string(fd, ph);
+        return ph->env.os_release ? 0 : -ENOMEM;
+}
+
+static int process_version(struct perf_file_section *section __maybe_unused,
+                           struct perf_header *ph, int fd,
+                           void *data __maybe_unused)
+{
+        ph->env.version = do_read_string(fd, ph);
+        return ph->env.version ? 0 : -ENOMEM;
+}
+
+static int process_arch(struct perf_file_section *section __maybe_unused,
+                        struct perf_header *ph, int fd,
+                        void *data __maybe_unused)
+{
+        ph->env.arch = do_read_string(fd, ph);
+        return ph->env.arch ? 0 : -ENOMEM;
+}
+
+static int process_nrcpus(struct perf_file_section *section __maybe_unused,
+                          struct perf_header *ph, int fd,
+                          void *data __maybe_unused)
+{
+        size_t ret;
+        u32 nr;
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                return -1;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_cpus_online = nr;
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                return -1;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_cpus_avail = nr;
+        return 0;
+}
+
+static int process_cpudesc(struct perf_file_section *section __maybe_unused,
+                           struct perf_header *ph, int fd,
+                           void *data __maybe_unused)
+{
+        ph->env.cpu_desc = do_read_string(fd, ph);
+        return ph->env.cpu_desc ? 0 : -ENOMEM;
+}
+
+static int process_cpuid(struct perf_file_section *section __maybe_unused,
+                         struct perf_header *ph,  int fd,
+                         void *data __maybe_unused)
+{
+        ph->env.cpuid = do_read_string(fd, ph);
+        return ph->env.cpuid ? 0 : -ENOMEM;
+}
+
+static int process_total_mem(struct perf_file_section *section __maybe_unused,
+                             struct perf_header *ph, int fd,
+                             void *data __maybe_unused)
+{
+        uint64_t mem;
+        size_t ret;
+
+        ret = read(fd, &mem, sizeof(mem));
+        if (ret != sizeof(mem))
+                return -1;
+
+        if (ph->needs_swap)
+                mem = bswap_64(mem);
+
+        ph->env.total_mem = mem;
+        return 0;
+}
+
 static struct perf_evsel *
 perf_evlist__find_by_index(struct perf_evlist *evlist, int idx)
 {
@@ -1687,7 +1704,8 @@ perf_evlist__find_by_index(struct perf_evlist *evlist, int idx)
 }
 
 static void
-perf_evlist__set_event_name(struct perf_evlist *evlist, struct perf_evsel *event)
+perf_evlist__set_event_name(struct perf_evlist *evlist,
+                            struct perf_evsel *event)
 {
         struct perf_evsel *evsel;
 
@@ -1706,15 +1724,16 @@ perf_evlist__set_event_name(struct perf_evlist *evlist, struct perf_evsel *event
 
 static int
 process_event_desc(struct perf_file_section *section __maybe_unused,
-                   struct perf_header *header, int feat __maybe_unused, int fd,
+                   struct perf_header *header, int fd,
                    void *data __maybe_unused)
 {
-        struct perf_session *session = container_of(header, struct perf_session, header);
+        struct perf_session *session;
         struct perf_evsel *evsel, *events = read_event_desc(header, fd);
 
         if (!events)
                 return 0;
 
+        session = container_of(header, struct perf_session, header);
         for (evsel = events; evsel->attr.size; evsel++)
                 perf_evlist__set_event_name(session->evlist, evsel);
 
@@ -1723,11 +1742,213 @@ process_event_desc(struct perf_file_section *section __maybe_unused,
         return 0;
 }
 
+static int process_cmdline(struct perf_file_section *section __maybe_unused,
+                           struct perf_header *ph, int fd,
+                           void *data __maybe_unused)
+{
+        size_t ret;
+        char *str;
+        u32 nr, i;
+        struct strbuf sb;
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                return -1;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_cmdline = nr;
+        strbuf_init(&sb, 128);
+
+        for (i = 0; i < nr; i++) {
+                str = do_read_string(fd, ph);
+                if (!str)
+                        goto error;
+
+                /* include a NULL character at the end */
+                strbuf_add(&sb, str, strlen(str) + 1);
+                free(str);
+        }
+        ph->env.cmdline = strbuf_detach(&sb, NULL);
+        return 0;
+
+error:
+        strbuf_release(&sb);
+        return -1;
+}
+
+static int process_cpu_topology(struct perf_file_section *section __maybe_unused,
+                                struct perf_header *ph, int fd,
+                                void *data __maybe_unused)
+{
+        size_t ret;
+        u32 nr, i;
+        char *str;
+        struct strbuf sb;
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                return -1;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_sibling_cores = nr;
+        strbuf_init(&sb, 128);
+
+        for (i = 0; i < nr; i++) {
+                str = do_read_string(fd, ph);
+                if (!str)
+                        goto error;
+
+                /* include a NULL character at the end */
+                strbuf_add(&sb, str, strlen(str) + 1);
+                free(str);
+        }
+        ph->env.sibling_cores = strbuf_detach(&sb, NULL);
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                return -1;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_sibling_threads = nr;
+
+        for (i = 0; i < nr; i++) {
+                str = do_read_string(fd, ph);
+                if (!str)
+                        goto error;
+
+                /* include a NULL character at the end */
+                strbuf_add(&sb, str, strlen(str) + 1);
+                free(str);
+        }
+        ph->env.sibling_threads = strbuf_detach(&sb, NULL);
+        return 0;
+
+error:
+        strbuf_release(&sb);
+        return -1;
+}
+
+static int process_numa_topology(struct perf_file_section *section __maybe_unused,
+                                 struct perf_header *ph, int fd,
+                                 void *data __maybe_unused)
+{
+        size_t ret;
+        u32 nr, node, i;
+        char *str;
+        uint64_t mem_total, mem_free;
+        struct strbuf sb;
+
+        /* nr nodes */
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                goto error;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_numa_nodes = nr;
+        strbuf_init(&sb, 256);
+
+        for (i = 0; i < nr; i++) {
+                /* node number */
+                ret = read(fd, &node, sizeof(node));
+                if (ret != sizeof(node))
+                        goto error;
+
+                ret = read(fd, &mem_total, sizeof(u64));
+                if (ret != sizeof(u64))
+                        goto error;
+
+                ret = read(fd, &mem_free, sizeof(u64));
+                if (ret != sizeof(u64))
+                        goto error;
+
+                if (ph->needs_swap) {
+                        node = bswap_32(node);
+                        mem_total = bswap_64(mem_total);
+                        mem_free = bswap_64(mem_free);
+                }
+
+                strbuf_addf(&sb, "%u:%"PRIu64":%"PRIu64":",
+                            node, mem_total, mem_free);
+
+                str = do_read_string(fd, ph);
+                if (!str)
+                        goto error;
+
+                /* include a NULL character at the end */
+                strbuf_add(&sb, str, strlen(str) + 1);
+                free(str);
+        }
+        ph->env.numa_nodes = strbuf_detach(&sb, NULL);
+        return 0;
+
+error:
+        strbuf_release(&sb);
+        return -1;
+}
+
+static int process_pmu_mappings(struct perf_file_section *section __maybe_unused,
+                                struct perf_header *ph, int fd,
+                                void *data __maybe_unused)
+{
+        size_t ret;
+        char *name;
+        u32 pmu_num;
+        u32 type;
+        struct strbuf sb;
+
+        ret = read(fd, &pmu_num, sizeof(pmu_num));
+        if (ret != sizeof(pmu_num))
+                return -1;
+
+        if (ph->needs_swap)
+                pmu_num = bswap_32(pmu_num);
+
+        if (!pmu_num) {
+                pr_debug("pmu mappings not available\n");
+                return 0;
+        }
+
+        ph->env.nr_pmu_mappings = pmu_num;
+        strbuf_init(&sb, 128);
+
+        while (pmu_num) {
+                if (read(fd, &type, sizeof(type)) != sizeof(type))
+                        goto error;
+                if (ph->needs_swap)
+                        type = bswap_32(type);
+
+                name = do_read_string(fd, ph);
+                if (!name)
+                        goto error;
+
+                strbuf_addf(&sb, "%u:%s", type, name);
+                /* include a NULL character at the end */
+                strbuf_add(&sb, "", 1);
+
+                free(name);
+                pmu_num--;
+        }
+        ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
+        return 0;
+
+error:
+        strbuf_release(&sb);
+        return -1;
+}
+
 struct feature_ops {
         int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
         void (*print)(struct perf_header *h, int fd, FILE *fp);
         int (*process)(struct perf_file_section *section,
-                       struct perf_header *h, int feat, int fd, void *data);
+                       struct perf_header *h, int fd, void *data);
         const char *name;
         bool full_only;
 };
@@ -1739,7 +1960,7 @@ struct feature_ops {
                 .process = process_##func }
 #define FEAT_OPF(n, func) \
         [n] = { .name = #n, .write = write_##func, .print = print_##func, \
-                .full_only = true }
+                .process = process_##func, .full_only = true }
 
 /* feature_ops not implemented: */
 #define print_tracing_data      NULL
@@ -1748,20 +1969,20 @@ struct feature_ops {
 static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
         FEAT_OPP(HEADER_TRACING_DATA,   tracing_data),
         FEAT_OPP(HEADER_BUILD_ID,       build_id),
-        FEAT_OPA(HEADER_HOSTNAME,       hostname),
-        FEAT_OPA(HEADER_OSRELEASE,      osrelease),
-        FEAT_OPA(HEADER_VERSION,        version),
-        FEAT_OPA(HEADER_ARCH,           arch),
-        FEAT_OPA(HEADER_NRCPUS,         nrcpus),
-        FEAT_OPA(HEADER_CPUDESC,        cpudesc),
-        FEAT_OPA(HEADER_CPUID,          cpuid),
-        FEAT_OPA(HEADER_TOTAL_MEM,      total_mem),
+        FEAT_OPP(HEADER_HOSTNAME,       hostname),
+        FEAT_OPP(HEADER_OSRELEASE,      osrelease),
+        FEAT_OPP(HEADER_VERSION,        version),
+        FEAT_OPP(HEADER_ARCH,           arch),
+        FEAT_OPP(HEADER_NRCPUS,         nrcpus),
+        FEAT_OPP(HEADER_CPUDESC,        cpudesc),
+        FEAT_OPP(HEADER_CPUID,          cpuid),
+        FEAT_OPP(HEADER_TOTAL_MEM,      total_mem),
         FEAT_OPP(HEADER_EVENT_DESC,     event_desc),
-        FEAT_OPA(HEADER_CMDLINE,        cmdline),
+        FEAT_OPP(HEADER_CMDLINE,        cmdline),
         FEAT_OPF(HEADER_CPU_TOPOLOGY,   cpu_topology),
         FEAT_OPF(HEADER_NUMA_TOPOLOGY,  numa_topology),
         FEAT_OPA(HEADER_BRANCH_STACK,   branch_stack),
-        FEAT_OPA(HEADER_PMU_MAPPINGS,   pmu_mappings),
+        FEAT_OPP(HEADER_PMU_MAPPINGS,   pmu_mappings),
 };
 
 struct header_print_data {
@@ -2241,7 +2462,7 @@ static int perf_file_section__process(struct perf_file_section *section,
         if (!feat_ops[feat].process)
                 return 0;
 
-        return feat_ops[feat].process(section, ph, feat, fd, data);
+        return feat_ops[feat].process(section, ph, fd, data);
 }
 
 static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 209dad4fee2b..99bdd3abce59 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -58,6 +58,29 @@ struct perf_header;
 int perf_file_header__read(struct perf_file_header *header,
                            struct perf_header *ph, int fd);
 
+struct perf_session_env {
+        char                    *hostname;
+        char                    *os_release;
+        char                    *version;
+        char                    *arch;
+        int                     nr_cpus_online;
+        int                     nr_cpus_avail;
+        char                    *cpu_desc;
+        char                    *cpuid;
+        unsigned long long      total_mem;
+
+        int                     nr_cmdline;
+        char                    *cmdline;
+        int                     nr_sibling_cores;
+        char                    *sibling_cores;
+        int                     nr_sibling_threads;
+        char                    *sibling_threads;
+        int                     nr_numa_nodes;
+        char                    *numa_nodes;
+        int                     nr_pmu_mappings;
+        char                    *pmu_mappings;
+};
+
 struct perf_header {
         int                     frozen;
         bool                    needs_swap;
@@ -67,6 +90,7 @@ struct perf_header {
         u64                     event_offset;
         u64                     event_size;
         DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
+        struct perf_session_env env;
 };
 
 struct perf_evlist;
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index b442ee49452b..ead5316b3f89 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -243,15 +243,14 @@ size_t map__fprintf(struct map *self, FILE *fp)
 
 size_t map__fprintf_dsoname(struct map *map, FILE *fp)
 {
-        const char *dsoname;
+        const char *dsoname = "[unknown]";
 
         if (map && map->dso && (map->dso->name || map->dso->long_name)) {
                 if (symbol_conf.show_kernel_path && map->dso->long_name)
                         dsoname = map->dso->long_name;
                 else if (map->dso->name)
                         dsoname = map->dso->name;
-        } else
-                dsoname = "[unknown]";
+        }
 
         return fprintf(fp, "%s", dsoname);
 }
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 4ce04c2281d3..49a256e6e0a2 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -1100,6 +1100,7 @@ static int parse_probe_trace_command(const char *cmd,
         struct probe_trace_point *tp = &tev->point;
         char pr;
         char *p;
+        char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
         int ret, i, argc;
         char **argv;
 
@@ -1116,14 +1117,27 @@ static int parse_probe_trace_command(const char *cmd,
         }
 
         /* Scan event and group name. */
-        ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]",
-                     &pr, (float *)(void *)&tev->group,
-                     (float *)(void *)&tev->event);
-        if (ret != 3) {
+        argv0_str = strdup(argv[0]);
+        if (argv0_str == NULL) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        fmt1_str = strtok_r(argv0_str, ":", &fmt);
+        fmt2_str = strtok_r(NULL, "/", &fmt);
+        fmt3_str = strtok_r(NULL, " \t", &fmt);
+        if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL
+            || fmt3_str == NULL) {
                 semantic_error("Failed to parse event name: %s\n", argv[0]);
                 ret = -EINVAL;
                 goto out;
         }
+        pr = fmt1_str[0];
+        tev->group = strdup(fmt2_str);
+        tev->event = strdup(fmt3_str);
+        if (tev->group == NULL || tev->event == NULL) {
+                ret = -ENOMEM;
+                goto out;
+        }
         pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
 
         tp->retprobe = (pr == 'r');
@@ -1135,10 +1149,17 @@ static int parse_probe_trace_command(const char *cmd,
                 p++;
         } else
                 p = argv[1];
-        ret = sscanf(p, "%a[^+]+%lu", (float *)(void *)&tp->symbol,
-                     &tp->offset);
-        if (ret == 1)
+        fmt1_str = strtok_r(p, "+", &fmt);
+        tp->symbol = strdup(fmt1_str);
+        if (tp->symbol == NULL) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        fmt2_str = strtok_r(NULL, "", &fmt);
+        if (fmt2_str == NULL)
                 tp->offset = 0;
+        else
+                tp->offset = strtoul(fmt2_str, NULL, 10);
 
         tev->nargs = argc - 2;
         tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
@@ -1162,6 +1183,7 @@ static int parse_probe_trace_command(const char *cmd,
         }
         ret = 0;
 out:
+        free(argv0_str);
         argv_free(argv);
         return ret;
 }
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index ffde3e4e34aa..f80605eb1855 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -282,7 +282,7 @@ static void perl_process_tracepoint(union perf_event *perf_event __maybe_unused,
 
         event = find_cache_event(evsel);
         if (!event)
-                die("ug! no event found for type %d", evsel->attr.config);
+                die("ug! no event found for type %" PRIu64, evsel->attr.config);
 
         pid = raw_field_value(event, "common_pid", data);
 
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 4ff45e30c726..b441b07172b7 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -34,6 +34,7 @@ static inline char *bfd_demangle(void __maybe_unused *v,
         return NULL;
 }
 #else
+#define PACKAGE 'perf'
 #include <bfd.h>
 #endif
 #endif
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 70c2c13ff679..f66610b7bacf 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -16,6 +16,8 @@ struct thread {
         bool                    comm_set;
         char                    *comm;
         int                     comm_len;
+
+        void                    *priv;
 };
 
 struct machine;
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index aa4c860a21d1..3aabcd687cd5 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -229,24 +229,22 @@ void parse_proc_kallsyms(struct pevent *pevent,
         char *next = NULL;
         char *addr_str;
         char *mod;
-        char ch;
+        char *fmt;
 
         line = strtok_r(file, "\n", &next);
         while (line) {
                 mod = NULL;
-                sscanf(line, "%as %c %as\t[%as",
-                       (float *)(void *)&addr_str, /* workaround gcc warning */
-                       &ch, (float *)(void *)&func, (float *)(void *)&mod);
+                addr_str = strtok_r(line, " ", &fmt);
                 addr = strtoull(addr_str, NULL, 16);
-                free(addr_str);
-
-                /* truncate the extra ']' */
+                /* skip character */
+                strtok_r(NULL, " ", &fmt);
+                func = strtok_r(NULL, "\t", &fmt);
+                mod = strtok_r(NULL, "]", &fmt);
+                /* truncate the extra '[' */
                 if (mod)
-                        mod[strlen(mod) - 1] = 0;
+                        mod = mod + 1;
 
                 pevent_register_function(pevent, func, addr, mod);
-                free(func);
-                free(mod);
 
                 line = strtok_r(NULL, "\n", &next);
         }