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

Pull perf updates from Ingo Molnar:
 "Kernel side changes:

   - Improved kbprobes robustness

   - Intel PEBS support for PT hardware tracing

   - Other Intel PT improvements: high order pages memory footprint
     reduction and various related cleanups

   - Misc cleanups

  The perf tooling side has been very busy in this cycle, with over 300
  commits. This is an incomplete high-level summary of the many
  improvements done by over 30 developers:

   - Lots of updates to the following tools:

      'perf c2c'
      'perf config'
      'perf record'
      'perf report'
      'perf script'
      'perf test'
      'perf top'
      'perf trace'

   - Updates to libperf and libtraceevent, and a consolidation of the
     proliferation of x86 instruction decoder libraries.

   - Vendor event updates for Intel and PowerPC CPUs,

   - Updates to hardware tracing tooling for ARM and Intel CPUs,

   - ... and lots of other changes and cleanups - see the shortlog and
     Git log for details"

* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (322 commits)
  kprobes: Prohibit probing on BUG() and WARN() address
  perf/x86: Make more stuff static
  x86, perf: Fix the dependency of the x86 insn decoder selftest
  objtool: Ignore intentional differences for the x86 insn decoder
  objtool: Update sync-check.sh from perf's check-headers.sh
  perf build: Ignore intentional differences for the x86 insn decoder
  perf intel-pt: Use shared x86 insn decoder
  perf intel-pt: Remove inat.c from build dependency list
  perf: Update .gitignore file
  objtool: Move x86 insn decoder to a common location
  perf metricgroup: Support multiple events for metricgroup
  perf metricgroup: Scale the metric result
  perf pmu: Change convert_scale from static to global
  perf symbols: Move mem_info and branch_info out of symbol.h
  perf auxtrace: Uninline functions that touch perf_session
  perf tools: Remove needless evlist.h include directives
  perf tools: Remove needless evlist.h include directives
  perf tools: Remove needless thread_map.h include directives
  perf tools: Remove needless thread.h include directives
  perf tools: Remove needless map.h include directives
  ...

1 files changed, 74 insertions, 72 deletions

diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 352cf39d7c2f..7e17bf9f700a 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -40,8 +40,8 @@
  *   Jaswinder Singh Rajput <jaswinder@kernel.org>
  */
 
-#include "perf.h"
 #include "builtin.h"
+#include "perf.h"
 #include "util/cgroup.h"
 #include <subcmd/parse-options.h>
 #include "util/parse-events.h"
@@ -54,7 +54,6 @@
 #include "util/stat.h"
 #include "util/header.h"
 #include "util/cpumap.h"
-#include "util/thread.h"
 #include "util/thread_map.h"
 #include "util/counts.h"
 #include "util/group.h"
@@ -62,6 +61,8 @@
 #include "util/tool.h"
 #include "util/string2.h"
 #include "util/metricgroup.h"
+#include "util/target.h"
+#include "util/time-utils.h"
 #include "util/top.h"
 #include "asm/bug.h"
 
@@ -83,6 +84,7 @@
 #include <sys/resource.h>
 
 #include <linux/ctype.h>
+#include <perf/evlist.h>
 
 #define DEFAULT_SEPARATOR       " "
 #define FREEZE_ON_SMI_PATH      "devices/cpu/freeze_on_smi"
@@ -130,7 +132,7 @@ static const char *smi_cost_attrs = {
         "}"
 };
 
-static struct perf_evlist       *evsel_list;
+static struct evlist    *evsel_list;
 
 static struct target target = {
         .uid    = UINT_MAX,
@@ -164,8 +166,8 @@ struct perf_stat {
         u64                      bytes_written;
         struct perf_tool         tool;
         bool                     maps_allocated;
-        struct cpu_map          *cpus;
-        struct thread_map       *threads;
+        struct perf_cpu_map     *cpus;
+        struct perf_thread_map *threads;
         enum aggr_mode           aggr_mode;
 };
 
@@ -234,7 +236,7 @@ static int write_stat_round_event(u64 tm, u64 type)
 #define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
 
 static int
-perf_evsel__write_stat_event(struct perf_evsel *counter, u32 cpu, u32 thread,
+perf_evsel__write_stat_event(struct evsel *counter, u32 cpu, u32 thread,
                              struct perf_counts_values *count)
 {
         struct perf_sample_id *sid = SID(counter, cpu, thread);
@@ -243,7 +245,7 @@ perf_evsel__write_stat_event(struct perf_evsel *counter, u32 cpu, u32 thread,
                                            process_synthesized_event, NULL);
 }
 
-static int read_single_counter(struct perf_evsel *counter, int cpu,
+static int read_single_counter(struct evsel *counter, int cpu,
                                int thread, struct timespec *rs)
 {
         if (counter->tool_event == PERF_TOOL_DURATION_TIME) {
@@ -261,9 +263,9 @@ static int read_single_counter(struct perf_evsel *counter, int cpu,
  * Read out the results of a single counter:
  * do not aggregate counts across CPUs in system-wide mode
  */
-static int read_counter(struct perf_evsel *counter, struct timespec *rs)
+static int read_counter(struct evsel *counter, struct timespec *rs)
 {
-        int nthreads = thread_map__nr(evsel_list->threads);
+        int nthreads = perf_thread_map__nr(evsel_list->core.threads);
         int ncpus, cpu, thread;
 
         if (target__has_cpu(&target) && !target__has_per_thread(&target))
@@ -287,7 +289,7 @@ static int read_counter(struct perf_evsel *counter, struct timespec *rs)
                          * The leader's group read loads data into its group members
                          * (via perf_evsel__read_counter) and sets threir count->loaded.
                          */
-                        if (!count->loaded &&
+                        if (!perf_counts__is_loaded(counter->counts, cpu, thread) &&
                             read_single_counter(counter, cpu, thread, rs)) {
                                 counter->counts->scaled = -1;
                                 perf_counts(counter->counts, cpu, thread)->ena = 0;
@@ -295,7 +297,7 @@ static int read_counter(struct perf_evsel *counter, struct timespec *rs)
                                 return -1;
                         }
 
-                        count->loaded = false;
+                        perf_counts__set_loaded(counter->counts, cpu, thread, false);
 
                         if (STAT_RECORD) {
                                 if (perf_evsel__write_stat_event(counter, cpu, thread, count)) {
@@ -319,7 +321,7 @@ static int read_counter(struct perf_evsel *counter, struct timespec *rs)
 
 static void read_counters(struct timespec *rs)
 {
-        struct perf_evsel *counter;
+        struct evsel *counter;
         int ret;
 
         evlist__for_each_entry(evsel_list, counter) {
@@ -362,7 +364,7 @@ static void enable_counters(void)
          * - we have initial delay configured
          */
         if (!target__none(&target) || stat_config.initial_delay)
-                perf_evlist__enable(evsel_list);
+                evlist__enable(evsel_list);
 }
 
 static void disable_counters(void)
@@ -373,7 +375,7 @@ static void disable_counters(void)
          * from counting before reading their constituent counters.
          */
         if (!target__none(&target))
-                perf_evlist__disable(evsel_list);
+                evlist__disable(evsel_list);
 }
 
 static volatile int workload_exec_errno;
@@ -389,13 +391,13 @@ static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *inf
         workload_exec_errno = info->si_value.sival_int;
 }
 
-static bool perf_evsel__should_store_id(struct perf_evsel *counter)
+static bool perf_evsel__should_store_id(struct evsel *counter)
 {
-        return STAT_RECORD || counter->attr.read_format & PERF_FORMAT_ID;
+        return STAT_RECORD || counter->core.attr.read_format & PERF_FORMAT_ID;
 }
 
 static bool is_target_alive(struct target *_target,
-                            struct thread_map *threads)
+                            struct perf_thread_map *threads)
 {
         struct stat st;
         int i;
@@ -423,7 +425,7 @@ static int __run_perf_stat(int argc, const char **argv, int run_idx)
         int timeout = stat_config.timeout;
         char msg[BUFSIZ];
         unsigned long long t0, t1;
-        struct perf_evsel *counter;
+        struct evsel *counter;
         struct timespec ts;
         size_t l;
         int status = 0;
@@ -478,22 +480,22 @@ try_again:
                                 counter->supported = false;
 
                                 if ((counter->leader != counter) ||
-                                    !(counter->leader->nr_members > 1))
+                                    !(counter->leader->core.nr_members > 1))
                                         continue;
                         } else if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) {
                                 if (verbose > 0)
                                         ui__warning("%s\n", msg);
                                 goto try_again;
                         } else if (target__has_per_thread(&target) &&
-                                   evsel_list->threads &&
-                                   evsel_list->threads->err_thread != -1) {
+                                   evsel_list->core.threads &&
+                                   evsel_list->core.threads->err_thread != -1) {
                                 /*
                                  * For global --per-thread case, skip current
                                  * error thread.
                                  */
-                                if (!thread_map__remove(evsel_list->threads,
-                                                        evsel_list->threads->err_thread)) {
-                                        evsel_list->threads->err_thread = -1;
+                                if (!thread_map__remove(evsel_list->core.threads,
+                                                        evsel_list->core.threads->err_thread)) {
+                                        evsel_list->core.threads->err_thread = -1;
                                         goto try_again;
                                 }
                         }
@@ -579,7 +581,7 @@ try_again:
                 enable_counters();
                 while (!done) {
                         nanosleep(&ts, NULL);
-                        if (!is_target_alive(&target, evsel_list->threads))
+                        if (!is_target_alive(&target, evsel_list->core.threads))
                                 break;
                         if (timeout)
                                 break;
@@ -613,7 +615,7 @@ try_again:
          * later the evsel_list will be closed after.
          */
         if (!STAT_RECORD)
-                perf_evlist__close(evsel_list);
+                evlist__close(evsel_list);
 
         return WEXITSTATUS(status);
 }
@@ -803,24 +805,24 @@ static struct option stat_options[] = {
 };
 
 static int perf_stat__get_socket(struct perf_stat_config *config __maybe_unused,
-                                 struct cpu_map *map, int cpu)
+                                 struct perf_cpu_map *map, int cpu)
 {
         return cpu_map__get_socket(map, cpu, NULL);
 }
 
 static int perf_stat__get_die(struct perf_stat_config *config __maybe_unused,
-                              struct cpu_map *map, int cpu)
+                              struct perf_cpu_map *map, int cpu)
 {
         return cpu_map__get_die(map, cpu, NULL);
 }
 
 static int perf_stat__get_core(struct perf_stat_config *config __maybe_unused,
-                               struct cpu_map *map, int cpu)
+                               struct perf_cpu_map *map, int cpu)
 {
         return cpu_map__get_core(map, cpu, NULL);
 }
 
-static int cpu_map__get_max(struct cpu_map *map)
+static int cpu_map__get_max(struct perf_cpu_map *map)
 {
         int i, max = -1;
 
@@ -833,7 +835,7 @@ static int cpu_map__get_max(struct cpu_map *map)
 }
 
 static int perf_stat__get_aggr(struct perf_stat_config *config,
-                               aggr_get_id_t get_id, struct cpu_map *map, int idx)
+                               aggr_get_id_t get_id, struct perf_cpu_map *map, int idx)
 {
         int cpu;
 
@@ -849,26 +851,26 @@ static int perf_stat__get_aggr(struct perf_stat_config *config,
 }
 
 static int perf_stat__get_socket_cached(struct perf_stat_config *config,
-                                        struct cpu_map *map, int idx)
+                                        struct perf_cpu_map *map, int idx)
 {
         return perf_stat__get_aggr(config, perf_stat__get_socket, map, idx);
 }
 
 static int perf_stat__get_die_cached(struct perf_stat_config *config,
-                                        struct cpu_map *map, int idx)
+                                        struct perf_cpu_map *map, int idx)
 {
         return perf_stat__get_aggr(config, perf_stat__get_die, map, idx);
 }
 
 static int perf_stat__get_core_cached(struct perf_stat_config *config,
-                                      struct cpu_map *map, int idx)
+                                      struct perf_cpu_map *map, int idx)
 {
         return perf_stat__get_aggr(config, perf_stat__get_core, map, idx);
 }
 
 static bool term_percore_set(void)
 {
-        struct perf_evsel *counter;
+        struct evsel *counter;
 
         evlist__for_each_entry(evsel_list, counter) {
                 if (counter->percore)
@@ -884,21 +886,21 @@ static int perf_stat_init_aggr_mode(void)
 
         switch (stat_config.aggr_mode) {
         case AGGR_SOCKET:
-                if (cpu_map__build_socket_map(evsel_list->cpus, &stat_config.aggr_map)) {
+                if (cpu_map__build_socket_map(evsel_list->core.cpus, &stat_config.aggr_map)) {
                         perror("cannot build socket map");
                         return -1;
                 }
                 stat_config.aggr_get_id = perf_stat__get_socket_cached;
                 break;
         case AGGR_DIE:
-                if (cpu_map__build_die_map(evsel_list->cpus, &stat_config.aggr_map)) {
+                if (cpu_map__build_die_map(evsel_list->core.cpus, &stat_config.aggr_map)) {
                         perror("cannot build die map");
                         return -1;
                 }
                 stat_config.aggr_get_id = perf_stat__get_die_cached;
                 break;
         case AGGR_CORE:
-                if (cpu_map__build_core_map(evsel_list->cpus, &stat_config.aggr_map)) {
+                if (cpu_map__build_core_map(evsel_list->core.cpus, &stat_config.aggr_map)) {
                         perror("cannot build core map");
                         return -1;
                 }
@@ -906,7 +908,7 @@ static int perf_stat_init_aggr_mode(void)
                 break;
         case AGGR_NONE:
                 if (term_percore_set()) {
-                        if (cpu_map__build_core_map(evsel_list->cpus,
+                        if (cpu_map__build_core_map(evsel_list->core.cpus,
                                                     &stat_config.aggr_map)) {
                                 perror("cannot build core map");
                                 return -1;
@@ -926,20 +928,20 @@ static int perf_stat_init_aggr_mode(void)
          * taking the highest cpu number to be the size of
          * the aggregation translate cpumap.
          */
-        nr = cpu_map__get_max(evsel_list->cpus);
-        stat_config.cpus_aggr_map = cpu_map__empty_new(nr + 1);
+        nr = cpu_map__get_max(evsel_list->core.cpus);
+        stat_config.cpus_aggr_map = perf_cpu_map__empty_new(nr + 1);
         return stat_config.cpus_aggr_map ? 0 : -ENOMEM;
 }
 
 static void perf_stat__exit_aggr_mode(void)
 {
-        cpu_map__put(stat_config.aggr_map);
-        cpu_map__put(stat_config.cpus_aggr_map);
+        perf_cpu_map__put(stat_config.aggr_map);
+        perf_cpu_map__put(stat_config.cpus_aggr_map);
         stat_config.aggr_map = NULL;
         stat_config.cpus_aggr_map = NULL;
 }
 
-static inline int perf_env__get_cpu(struct perf_env *env, struct cpu_map *map, int idx)
+static inline int perf_env__get_cpu(struct perf_env *env, struct perf_cpu_map *map, int idx)
 {
         int cpu;
 
@@ -954,7 +956,7 @@ static inline int perf_env__get_cpu(struct perf_env *env, struct cpu_map *map, i
         return cpu;
 }
 
-static int perf_env__get_socket(struct cpu_map *map, int idx, void *data)
+static int perf_env__get_socket(struct perf_cpu_map *map, int idx, void *data)
 {
         struct perf_env *env = data;
         int cpu = perf_env__get_cpu(env, map, idx);
@@ -962,7 +964,7 @@ static int perf_env__get_socket(struct cpu_map *map, int idx, void *data)
         return cpu == -1 ? -1 : env->cpu[cpu].socket_id;
 }
 
-static int perf_env__get_die(struct cpu_map *map, int idx, void *data)
+static int perf_env__get_die(struct perf_cpu_map *map, int idx, void *data)
 {
         struct perf_env *env = data;
         int die_id = -1, cpu = perf_env__get_cpu(env, map, idx);
@@ -986,7 +988,7 @@ static int perf_env__get_die(struct cpu_map *map, int idx, void *data)
         return die_id;
 }
 
-static int perf_env__get_core(struct cpu_map *map, int idx, void *data)
+static int perf_env__get_core(struct perf_cpu_map *map, int idx, void *data)
 {
         struct perf_env *env = data;
         int core = -1, cpu = perf_env__get_cpu(env, map, idx);
@@ -1016,37 +1018,37 @@ static int perf_env__get_core(struct cpu_map *map, int idx, void *data)
         return core;
 }
 
-static int perf_env__build_socket_map(struct perf_env *env, struct cpu_map *cpus,
-                                      struct cpu_map **sockp)
+static int perf_env__build_socket_map(struct perf_env *env, struct perf_cpu_map *cpus,
+                                      struct perf_cpu_map **sockp)
 {
         return cpu_map__build_map(cpus, sockp, perf_env__get_socket, env);
 }
 
-static int perf_env__build_die_map(struct perf_env *env, struct cpu_map *cpus,
-                                   struct cpu_map **diep)
+static int perf_env__build_die_map(struct perf_env *env, struct perf_cpu_map *cpus,
+                                   struct perf_cpu_map **diep)
 {
         return cpu_map__build_map(cpus, diep, perf_env__get_die, env);
 }
 
-static int perf_env__build_core_map(struct perf_env *env, struct cpu_map *cpus,
-                                    struct cpu_map **corep)
+static int perf_env__build_core_map(struct perf_env *env, struct perf_cpu_map *cpus,
+                                    struct perf_cpu_map **corep)
 {
         return cpu_map__build_map(cpus, corep, perf_env__get_core, env);
 }
 
 static int perf_stat__get_socket_file(struct perf_stat_config *config __maybe_unused,
-                                      struct cpu_map *map, int idx)
+                                      struct perf_cpu_map *map, int idx)
 {
         return perf_env__get_socket(map, idx, &perf_stat.session->header.env);
 }
 static int perf_stat__get_die_file(struct perf_stat_config *config __maybe_unused,
-                                   struct cpu_map *map, int idx)
+                                   struct perf_cpu_map *map, int idx)
 {
         return perf_env__get_die(map, idx, &perf_stat.session->header.env);
 }
 
 static int perf_stat__get_core_file(struct perf_stat_config *config __maybe_unused,
-                                    struct cpu_map *map, int idx)
+                                    struct perf_cpu_map *map, int idx)
 {
         return perf_env__get_core(map, idx, &perf_stat.session->header.env);
 }
@@ -1057,21 +1059,21 @@ static int perf_stat_init_aggr_mode_file(struct perf_stat *st)
 
         switch (stat_config.aggr_mode) {
         case AGGR_SOCKET:
-                if (perf_env__build_socket_map(env, evsel_list->cpus, &stat_config.aggr_map)) {
+                if (perf_env__build_socket_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) {
                         perror("cannot build socket map");
                         return -1;
                 }
                 stat_config.aggr_get_id = perf_stat__get_socket_file;
                 break;
         case AGGR_DIE:
-                if (perf_env__build_die_map(env, evsel_list->cpus, &stat_config.aggr_map)) {
+                if (perf_env__build_die_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) {
                         perror("cannot build die map");
                         return -1;
                 }
                 stat_config.aggr_get_id = perf_stat__get_die_file;
                 break;
         case AGGR_CORE:
-                if (perf_env__build_core_map(env, evsel_list->cpus, &stat_config.aggr_map)) {
+                if (perf_env__build_core_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) {
                         perror("cannot build core map");
                         return -1;
                 }
@@ -1366,7 +1368,7 @@ static int add_default_attributes(void)
                 free(str);
         }
 
-        if (!evsel_list->nr_entries) {
+        if (!evsel_list->core.nr_entries) {
                 if (target__has_cpu(&target))
                         default_attrs0[0].config = PERF_COUNT_SW_CPU_CLOCK;
 
@@ -1461,8 +1463,8 @@ static int __cmd_record(int argc, const char **argv)
 static int process_stat_round_event(struct perf_session *session,
                                     union perf_event *event)
 {
-        struct stat_round_event *stat_round = &event->stat_round;
-        struct perf_evsel *counter;
+        struct perf_record_stat_round *stat_round = &event->stat_round;
+        struct evsel *counter;
         struct timespec tsh, *ts = NULL;
         const char **argv = session->header.env.cmdline_argv;
         int argc = session->header.env.nr_cmdline;
@@ -1492,7 +1494,7 @@ int process_stat_config_event(struct perf_session *session,
 
         perf_event__read_stat_config(&stat_config, &event->stat_config);
 
-        if (cpu_map__empty(st->cpus)) {
+        if (perf_cpu_map__empty(st->cpus)) {
                 if (st->aggr_mode != AGGR_UNSET)
                         pr_warning("warning: processing task data, aggregation mode not set\n");
                 return 0;
@@ -1517,7 +1519,7 @@ static int set_maps(struct perf_stat *st)
         if (WARN_ONCE(st->maps_allocated, "stats double allocation\n"))
                 return -EINVAL;
 
-        perf_evlist__set_maps(evsel_list, st->cpus, st->threads);
+        perf_evlist__set_maps(&evsel_list->core, st->cpus, st->threads);
 
         if (perf_evlist__alloc_stats(evsel_list, true))
                 return -ENOMEM;
@@ -1551,7 +1553,7 @@ int process_cpu_map_event(struct perf_session *session,
 {
         struct perf_tool *tool = session->tool;
         struct perf_stat *st = container_of(tool, struct perf_stat, tool);
-        struct cpu_map *cpus;
+        struct perf_cpu_map *cpus;
 
         if (st->cpus) {
                 pr_warning("Extra cpu map event, ignoring.\n");
@@ -1676,14 +1678,14 @@ static void setup_system_wide(int forks)
         if (!forks)
                 target.system_wide = true;
         else {
-                struct perf_evsel *counter;
+                struct evsel *counter;
 
                 evlist__for_each_entry(evsel_list, counter) {
                         if (!counter->system_wide)
                                 return;
                 }
 
-                if (evsel_list->nr_entries)
+                if (evsel_list->core.nr_entries)
                         target.system_wide = true;
         }
 }
@@ -1702,7 +1704,7 @@ int cmd_stat(int argc, const char **argv)
 
         setlocale(LC_ALL, "");
 
-        evsel_list = perf_evlist__new();
+        evsel_list = evlist__new();
         if (evsel_list == NULL)
                 return -ENOMEM;
 
@@ -1889,10 +1891,10 @@ int cmd_stat(int argc, const char **argv)
          * so we could print it out on output.
          */
         if (stat_config.aggr_mode == AGGR_THREAD) {
-                thread_map__read_comms(evsel_list->threads);
+                thread_map__read_comms(evsel_list->core.threads);
                 if (target.system_wide) {
                         if (runtime_stat_new(&stat_config,
-                                thread_map__nr(evsel_list->threads))) {
+                                perf_thread_map__nr(evsel_list->core.threads))) {
                                 goto out;
                         }
                 }
@@ -2003,7 +2005,7 @@ int cmd_stat(int argc, const char **argv)
                         perf_session__write_header(perf_stat.session, evsel_list, fd, true);
                 }
 
-                perf_evlist__close(evsel_list);
+                evlist__close(evsel_list);
                 perf_session__delete(perf_stat.session);
         }
 
@@ -2015,7 +2017,7 @@ out:
         if (smi_cost && smi_reset)
                 sysfs__write_int(FREEZE_ON_SMI_PATH, 0);
 
-        perf_evlist__delete(evsel_list);
+        evlist__delete(evsel_list);
 
         runtime_stat_delete(&stat_config);