perf/core improvements and fixes:

User visible:
 
 - Force period term to overload global settings, i.e. previously this
   command line:
 
  $ perf record -e 'cpu/instructions,period=20000/',cycles -c 1000 sleep 1
 
   would result in both events having a period equal to 1000, with the fix we
   get something saner:
 
  $ perf evlist -v | grep period
  cpu/instructions,period=20000/: ... { sample_period, sample_freq }: 20000, ...
  cycles: ... { sample_period, sample_freq }: 1000 ...
  $
 
  (Jiri Olsa)
 
 Infrastructure:
 
 - Use the dummy software event with freq=0 in the twatch.py python
   binding example, to avoid disabling nohz (Arnaldo Carvalho de Melo)
 
 - Add some missing constants to the python binding (Arnaldo Carvalho de Melo)
 
 - Fix mismatched declarations for elf_getphdrnum, that happens
   only in the corner case where this function is not found on
   the system  (Arnaldo Carvalho de Melo).
 
 - Adding build test for having ending double slash (Jiri Olsa)
 
 - Introduce callgraph_set for callgraph option (Kan Liang)
 
 Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJVuk2cAAoJENZQFvNTUqpA15IQAIwfXkfs6we+5+VOXp35bKrl
 EiXVTBZPo1IW+duas0exur8nEmdYV9VMuZE8t5WpldOsARxJKjnKyB+muFCDMKqA
 3yeBXPATawxRKjqIsPVucksFXGHf19v6Nsh2plqY+qqFynKxm7DibcMxIIFMeqY0
 VwdUzHEojIMQ2pzHA7Ef2eSdzSgAUqO06+O9BBB+udizcCAonF5KZh4tw5n2795E
 gz0rvnYVC8q7EU2oSKEWwWyj2Ti07iaC0b/adg6jY9OU0Mnlx0K3MkREmq6KQjoz
 GrayIknp0CoatLPbpuPf9jz3si7lL/WErl3F3Qeg1lfzAPdGDakmfufQmgyHhEfF
 in0qAYxYKMnsgRblTWynOMUWISfdKlhjsofXFv3hXOB2iWbulHLU7WdS8ieyuiGq
 N0jcYEII4+/qk+Wi/XbiCujOmaZdvG+slSmx9JgZwXhj4kRiBkUYeNk/JCdNhzgX
 u6fse5lBQRI+YDmNXe+QQxUTpL+jpx2OnmpD8v2Yx4YvvLN/SU47Y9VYw9YWmkDq
 NySRFn/bBc/zlrT6EnYI7ENpydLIovS+Wa8WSmzQFCDGcbWl2TSKjcVAB1aqhhsk
 IAMnzv5/0ybcx8WiYcGqd6Z4gh+WuUenzHGKE3sSmSqbbRRS1WvBYeyeZaU1IGkW
 8lrAASPd8X3YP76aP8ww
 =XBSW
 -----END PGP SIGNATURE-----

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:

User visible changes:

  - Force period term to overload global settings, i.e. previously this
    command line:

     $ perf record -e 'cpu/instructions,period=20000/',cycles -c 1000 sleep 1

    would result in both events having a period equal to 1000, with the fix we
    get something saner:

     $ perf evlist -v | grep period
     cpu/instructions,period=20000/: ... { sample_period, sample_freq }: 20000, ...
     cycles: ... { sample_period, sample_freq }: 1000 ...
     $

   (Jiri Olsa)

Infrastructure changes:

  - Use the dummy software event with freq=0 in the twatch.py python
    binding example, to avoid disabling nohz. (Arnaldo Carvalho de Melo)

  - Add some missing constants to the python binding. (Arnaldo Carvalho de Melo)

  - Fix mismatched declarations for elf_getphdrnum, that happens
    only in the corner case where this function is not found on
    the system.  (Arnaldo Carvalho de Melo)

  - Add build test for having ending double slash. (Jiri Olsa)

  - Introduce callgraph_set for callgraph option. (Kan Liang)

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>

tools/perf/Documentation/perf-record.txt

@@ -46,7 +46,7 @@ OPTIONS
           /sys/bus/event_sources/devices/<pmu>/format/*
 
 	  There are also some params which are not defined in .../<pmu>/format/*.
-	  These params can be used to set event defaults.
+	  These params can be used to overload default config values per event.
 	  Here is a list of the params.
 	  - 'period': Set event sampling period
 

tools/perf/builtin-record.c

@@ -762,12 +762,14 @@ static void callchain_debug(void)
 			 callchain_param.dump_size);
 }
 
-int record_parse_callchain_opt(const struct option *opt __maybe_unused,
+int record_parse_callchain_opt(const struct option *opt,
 			       const char *arg,
 			       int unset)
 {
 	int ret;
+	struct record_opts *record = (struct record_opts *)opt->value;
 
+	record->callgraph_set = true;
 	callchain_param.enabled = !unset;
 
 	/* --no-call-graph */
@@ -784,10 +786,13 @@ int record_parse_callchain_opt(const struct option *opt __maybe_unused,
 	return ret;
 }
 
-int record_callchain_opt(const struct option *opt __maybe_unused,
+int record_callchain_opt(const struct option *opt,
 			 const char *arg __maybe_unused,
 			 int unset __maybe_unused)
 {
+	struct record_opts *record = (struct record_opts *)opt->value;
+
+	record->callgraph_set = true;
 	callchain_param.enabled = true;
 
 	if (callchain_param.record_mode == CALLCHAIN_NONE)

tools/perf/builtin-trace.c

@@ -1489,7 +1489,7 @@ static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
 	if (trace->host == NULL)
 		return -ENOMEM;
 
-	if (trace_event__register_resolver(trace->host) < 0)
+	if (trace_event__register_resolver(trace->host, machine__resolve_kernel_addr) < 0)
 		return -errno;
 
 	err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,

tools/perf/perf.h

@@ -52,6 +52,7 @@ struct record_opts {
 	bool	     sample_weight;
 	bool	     sample_time;
 	bool	     sample_time_set;
+	bool	     callgraph_set;
 	bool	     period;
 	bool	     sample_intr_regs;
 	bool	     running_time;

tools/perf/python/twatch.py

@@ -18,10 +18,20 @@ import perf
 def main():
 	cpus = perf.cpu_map()
 	threads = perf.thread_map()
-	evsel = perf.evsel(task = 1, comm = 1, mmap = 0,
+	evsel = perf.evsel(type	  = perf.TYPE_SOFTWARE,
+			   config = perf.COUNT_SW_DUMMY,
+			   task = 1, comm = 1, mmap = 0, freq = 0,
 			   wakeup_events = 1, watermark = 1,
 			   sample_id_all = 1,
 			   sample_type = perf.SAMPLE_PERIOD | perf.SAMPLE_TID | perf.SAMPLE_CPU)
+
+	"""What we want are just the PERF_RECORD_ lifetime events for threads,
+	 using the default, PERF_TYPE_HARDWARE + PERF_COUNT_HW_CYCLES & freq=1
+	 (the default), makes perf reenable irq_vectors:local_timer_entry, when
+	 disabling nohz, not good for some use cases where all we want is to get
+	 threads comes and goes... So use (perf.TYPE_SOFTWARE, perf_COUNT_SW_DUMMY,
+	 freq=0) instead."""
+
 	evsel.open(cpus = cpus, threads = threads);
 	evlist = perf.evlist(cpus, threads)
 	evlist.add(evsel)

tools/perf/tests/make

@@ -58,7 +58,8 @@ make_install_man    := install-man
 make_install_html   := install-html
 make_install_info   := install-info
 make_install_pdf    := install-pdf
-make_install_prefix := install prefix=/tmp/krava
+make_install_prefix       := install prefix=/tmp/krava
+make_install_prefix_slash := install prefix=/tmp/krava/
 make_static         := LDFLAGS=-static
 
 # all the NO_* variable combined
@@ -101,6 +102,7 @@ run += make_util_pmu_bison_o
 run += make_install
 run += make_install_bin
 run += make_install_prefix
+run += make_install_prefix_slash
 # FIXME 'install-*' commented out till they're fixed
 # run += make_install_doc
 # run += make_install_man
@@ -175,11 +177,14 @@ test_make_install_O     := $(call test_dest_files,$(installed_files_all))
 test_make_install_bin   := $(call test_dest_files,$(installed_files_bin))
 test_make_install_bin_O := $(call test_dest_files,$(installed_files_bin))
 
-# We prefix all installed files for make_install_prefix
+# We prefix all installed files for make_install_prefix(_slash)
 # with '/tmp/krava' to match installed/prefix-ed files.
 installed_files_all_prefix := $(addprefix /tmp/krava/,$(installed_files_all))
-test_make_install_prefix   := $(call test_dest_files,$(installed_files_all_prefix))
+test_make_install_prefix   :=  $(call test_dest_files,$(installed_files_all_prefix))
-test_make_install_prefix_O := $(call test_dest_files,$(installed_files_all_prefix))
+test_make_install_prefix_O :=  $(call test_dest_files,$(installed_files_all_prefix))
+
+test_make_install_prefix_slash   := $(test_make_install_prefix)
+test_make_install_prefix_slash_O := $(test_make_install_prefix_O)
 
 # FIXME nothing gets installed
 test_make_install_man    := test -f $$TMP_DEST/share/man/man1/perf.1

tools/perf/tests/parse-events.c

@@ -82,8 +82,12 @@ static int test__checkevent_symbolic_name_config(struct perf_evlist *evlist)
 	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
 	TEST_ASSERT_VAL("wrong config",
 			PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+	/*
+	 * The period value gets configured within perf_evlist__config,
+	 * while this test executes only parse events method.
+	 */
 	TEST_ASSERT_VAL("wrong period",
-			100000 == evsel->attr.sample_period);
+			0 == evsel->attr.sample_period);
 	TEST_ASSERT_VAL("wrong config1",
 			0 == evsel->attr.config1);
 	TEST_ASSERT_VAL("wrong config2",
@@ -406,7 +410,11 @@ static int test__checkevent_pmu(struct perf_evlist *evlist)
 	TEST_ASSERT_VAL("wrong config",    10 == evsel->attr.config);
 	TEST_ASSERT_VAL("wrong config1",    1 == evsel->attr.config1);
 	TEST_ASSERT_VAL("wrong config2",    3 == evsel->attr.config2);
-	TEST_ASSERT_VAL("wrong period",  1000 == evsel->attr.sample_period);
+	/*
+	 * The period value gets configured within perf_evlist__config,
+	 * while this test executes only parse events method.
+	 */
+	TEST_ASSERT_VAL("wrong period",     0 == evsel->attr.sample_period);
 
 	return 0;
 }

tools/perf/util/evsel.c

@@ -207,6 +207,7 @@ void perf_evsel__init(struct perf_evsel *evsel,
 	evsel->unit	   = "";
 	evsel->scale	   = 1.0;
 	INIT_LIST_HEAD(&evsel->node);
+	INIT_LIST_HEAD(&evsel->config_terms);
 	perf_evsel__object.init(evsel);
 	evsel->sample_size = __perf_evsel__sample_size(attr->sample_type);
 	perf_evsel__calc_id_pos(evsel);
@@ -586,6 +587,21 @@ perf_evsel__config_callgraph(struct perf_evsel *evsel,
 	}
 }
 
+static void apply_config_terms(struct perf_event_attr *attr __maybe_unused,
+			       struct list_head *config_terms)
+{
+	struct perf_evsel_config_term *term;
+
+	list_for_each_entry(term, config_terms, list) {
+		switch (term->type) {
+		case PERF_EVSEL__CONFIG_TERM_PERIOD:
+			attr->sample_period = term->val.period;
+		default:
+			break;
+		}
+	}
+}
+
 /*
  * The enable_on_exec/disabled value strategy:
  *
@@ -777,6 +793,12 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
 		attr->use_clockid = 1;
 		attr->clockid = opts->clockid;
 	}
+
+	/*
+	 * Apply event specific term settings,
+	 * it overloads any global configuration.
+	 */
+	apply_config_terms(attr, &evsel->config_terms);
 }
 
 static int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
@@ -900,6 +922,16 @@ static void perf_evsel__free_id(struct perf_evsel *evsel)
 	zfree(&evsel->id);
 }
 
+static void perf_evsel__free_config_terms(struct perf_evsel *evsel)
+{
+	struct perf_evsel_config_term *term, *h;
+
+	list_for_each_entry_safe(term, h, &evsel->config_terms, list) {
+		list_del(&term->list);
+		free(term);
+	}
+}
+
 void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
 {
 	int cpu, thread;
@@ -919,6 +951,7 @@ void perf_evsel__exit(struct perf_evsel *evsel)
 	assert(list_empty(&evsel->node));
 	perf_evsel__free_fd(evsel);
 	perf_evsel__free_id(evsel);
+	perf_evsel__free_config_terms(evsel);
 	close_cgroup(evsel->cgrp);
 	cpu_map__put(evsel->cpus);
 	thread_map__put(evsel->threads);

tools/perf/util/evsel.h

@@ -31,6 +31,25 @@ struct perf_sample_id {
 
 struct cgroup_sel;
 
+/*
+ * The 'struct perf_evsel_config_term' is used to pass event
+ * specific configuration data to perf_evsel__config routine.
+ * It is allocated within event parsing and attached to
+ * perf_evsel::config_terms list head.
+*/
+enum {
+	PERF_EVSEL__CONFIG_TERM_PERIOD,
+	PERF_EVSEL__CONFIG_TERM_MAX,
+};
+
+struct perf_evsel_config_term {
+	struct list_head	list;
+	int	type;
+	union {
+		u64	period;
+	} val;
+};
+
 /** struct perf_evsel - event selector
  *
  * @name - Can be set to retain the original event name passed by the user,
@@ -87,6 +106,7 @@ struct perf_evsel {
 	struct perf_evsel	*leader;
 	char			*group_name;
 	bool			cmdline_group_boundary;
+	struct list_head	config_terms;
 };
 
 union u64_swap {

tools/perf/util/parse-events.c

@@ -276,7 +276,8 @@ const char *event_type(int type)
 static struct perf_evsel *
 __add_event(struct list_head *list, int *idx,
 	    struct perf_event_attr *attr,
-	    char *name, struct cpu_map *cpus)
+	    char *name, struct cpu_map *cpus,
+	    struct list_head *config_terms)
 {
 	struct perf_evsel *evsel;
 
@@ -291,14 +292,19 @@ __add_event(struct list_head *list, int *idx,
 
 	if (name)
 		evsel->name = strdup(name);
+
+	if (config_terms)
+		list_splice(config_terms, &evsel->config_terms);
+
 	list_add_tail(&evsel->node, list);
 	return evsel;
 }
 
 static int add_event(struct list_head *list, int *idx,
-		     struct perf_event_attr *attr, char *name)
+		     struct perf_event_attr *attr, char *name,
+		     struct list_head *config_terms)
 {
-	return __add_event(list, idx, attr, name, NULL) ? 0 : -ENOMEM;
+	return __add_event(list, idx, attr, name, NULL, config_terms) ? 0 : -ENOMEM;
 }
 
 static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
@@ -377,7 +383,7 @@ int parse_events_add_cache(struct list_head *list, int *idx,
 	memset(&attr, 0, sizeof(attr));
 	attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
 	attr.type = PERF_TYPE_HW_CACHE;
-	return add_event(list, idx, &attr, name);
+	return add_event(list, idx, &attr, name, NULL);
 }
 
 static int add_tracepoint(struct list_head *list, int *idx,
@@ -539,7 +545,7 @@ int parse_events_add_breakpoint(struct list_head *list, int *idx,
 	attr.type = PERF_TYPE_BREAKPOINT;
 	attr.sample_period = 1;
 
-	return add_event(list, idx, &attr, NULL);
+	return add_event(list, idx, &attr, NULL, NULL);
 }
 
 static int check_type_val(struct parse_events_term *term,
@@ -590,7 +596,6 @@ do {									   \
 		break;
 	case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
 		CHECK_TYPE_VAL(NUM);
-		attr->sample_period = term->val.num;
 		break;
 	case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
 		/*
@@ -622,22 +627,58 @@ static int config_attr(struct perf_event_attr *attr,
 	return 0;
 }
 
+static int get_config_terms(struct list_head *head_config,
+			    struct list_head *head_terms __maybe_unused)
+{
+#define ADD_CONFIG_TERM(__type, __name, __val)			\
+do {								\
+	struct perf_evsel_config_term *__t;			\
+								\
+	__t = zalloc(sizeof(*__t));				\
+	if (!__t)						\
+		return -ENOMEM;					\
+								\
+	INIT_LIST_HEAD(&__t->list);				\
+	__t->type       = PERF_EVSEL__CONFIG_TERM_ ## __type;	\
+	__t->val.__name = __val;				\
+	list_add_tail(&__t->list, head_terms);			\
+} while (0)
+
+	struct parse_events_term *term;
+
+	list_for_each_entry(term, head_config, list) {
+		switch (term->type_term) {
+		case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
+			ADD_CONFIG_TERM(PERIOD, period, term->val.num);
+		default:
+			break;
+		}
+	}
+#undef ADD_EVSEL_CONFIG
+	return 0;
+}
+
 int parse_events_add_numeric(struct parse_events_evlist *data,
 			     struct list_head *list,
 			     u32 type, u64 config,
 			     struct list_head *head_config)
 {
 	struct perf_event_attr attr;
+	LIST_HEAD(config_terms);
 
 	memset(&attr, 0, sizeof(attr));
 	attr.type = type;
 	attr.config = config;
 
-	if (head_config &&
+	if (head_config) {
-	    config_attr(&attr, head_config, data->error))
+		if (config_attr(&attr, head_config, data->error))
-		return -EINVAL;
+			return -EINVAL;
 
-	return add_event(list, &data->idx, &attr, NULL);
+		if (get_config_terms(head_config, &config_terms))
+			return -ENOMEM;
+	}
+
+	return add_event(list, &data->idx, &attr, NULL, &config_terms);
 }
 
 static int parse_events__is_name_term(struct parse_events_term *term)
@@ -664,6 +705,7 @@ int parse_events_add_pmu(struct parse_events_evlist *data,
 	struct perf_pmu_info info;
 	struct perf_pmu *pmu;
 	struct perf_evsel *evsel;
+	LIST_HEAD(config_terms);
 
 	pmu = perf_pmu__find(name);
 	if (!pmu)
@@ -678,7 +720,7 @@ int parse_events_add_pmu(struct parse_events_evlist *data,
 
 	if (!head_config) {
 		attr.type = pmu->type;
-		evsel = __add_event(list, &data->idx, &attr, NULL, pmu->cpus);
+		evsel = __add_event(list, &data->idx, &attr, NULL, pmu->cpus, NULL);
 		return evsel ? 0 : -ENOMEM;
 	}
 
@@ -692,11 +734,15 @@ int parse_events_add_pmu(struct parse_events_evlist *data,
 	if (config_attr(&attr, head_config, data->error))
 		return -EINVAL;
 
+	if (get_config_terms(head_config, &config_terms))
+		return -ENOMEM;
+
 	if (perf_pmu__config(pmu, &attr, head_config, data->error))
 		return -EINVAL;
 
 	evsel = __add_event(list, &data->idx, &attr,
-			    pmu_event_name(head_config), pmu->cpus);
+			    pmu_event_name(head_config), pmu->cpus,
+			    &config_terms);
 	if (evsel) {
 		evsel->unit = info.unit;
 		evsel->scale = info.scale;

tools/perf/util/python.c

@@ -941,76 +941,84 @@ static int pyrf_evlist__setup_types(void)
 	return PyType_Ready(&pyrf_evlist__type);
 }
 
+#define PERF_CONST(name) { #name, PERF_##name }
+
 static struct {
 	const char *name;
 	int	    value;
 } perf__constants[] = {
-	{ "TYPE_HARDWARE",   PERF_TYPE_HARDWARE },
+	PERF_CONST(TYPE_HARDWARE),
-	{ "TYPE_SOFTWARE",   PERF_TYPE_SOFTWARE },
+	PERF_CONST(TYPE_SOFTWARE),
-	{ "TYPE_TRACEPOINT", PERF_TYPE_TRACEPOINT },
+	PERF_CONST(TYPE_TRACEPOINT),
-	{ "TYPE_HW_CACHE",   PERF_TYPE_HW_CACHE },
+	PERF_CONST(TYPE_HW_CACHE),
-	{ "TYPE_RAW",	     PERF_TYPE_RAW },
+	PERF_CONST(TYPE_RAW),
-	{ "TYPE_BREAKPOINT", PERF_TYPE_BREAKPOINT },
+	PERF_CONST(TYPE_BREAKPOINT),
 
-	{ "COUNT_HW_CPU_CYCLES",	  PERF_COUNT_HW_CPU_CYCLES },
+	PERF_CONST(COUNT_HW_CPU_CYCLES),
-	{ "COUNT_HW_INSTRUCTIONS",	  PERF_COUNT_HW_INSTRUCTIONS },
+	PERF_CONST(COUNT_HW_INSTRUCTIONS),
-	{ "COUNT_HW_CACHE_REFERENCES",	  PERF_COUNT_HW_CACHE_REFERENCES },
+	PERF_CONST(COUNT_HW_CACHE_REFERENCES),
-	{ "COUNT_HW_CACHE_MISSES",	  PERF_COUNT_HW_CACHE_MISSES },
+	PERF_CONST(COUNT_HW_CACHE_MISSES),
-	{ "COUNT_HW_BRANCH_INSTRUCTIONS", PERF_COUNT_HW_BRANCH_INSTRUCTIONS },
+	PERF_CONST(COUNT_HW_BRANCH_INSTRUCTIONS),
-	{ "COUNT_HW_BRANCH_MISSES",	  PERF_COUNT_HW_BRANCH_MISSES },
+	PERF_CONST(COUNT_HW_BRANCH_MISSES),
-	{ "COUNT_HW_BUS_CYCLES",	  PERF_COUNT_HW_BUS_CYCLES },
+	PERF_CONST(COUNT_HW_BUS_CYCLES),
-	{ "COUNT_HW_CACHE_L1D",		  PERF_COUNT_HW_CACHE_L1D },
+	PERF_CONST(COUNT_HW_CACHE_L1D),
-	{ "COUNT_HW_CACHE_L1I",		  PERF_COUNT_HW_CACHE_L1I },
+	PERF_CONST(COUNT_HW_CACHE_L1I),
-	{ "COUNT_HW_CACHE_LL",	  	  PERF_COUNT_HW_CACHE_LL },
+	PERF_CONST(COUNT_HW_CACHE_LL),
-	{ "COUNT_HW_CACHE_DTLB",	  PERF_COUNT_HW_CACHE_DTLB },
+	PERF_CONST(COUNT_HW_CACHE_DTLB),
-	{ "COUNT_HW_CACHE_ITLB",	  PERF_COUNT_HW_CACHE_ITLB },
+	PERF_CONST(COUNT_HW_CACHE_ITLB),
-	{ "COUNT_HW_CACHE_BPU",		  PERF_COUNT_HW_CACHE_BPU },
+	PERF_CONST(COUNT_HW_CACHE_BPU),
-	{ "COUNT_HW_CACHE_OP_READ",	  PERF_COUNT_HW_CACHE_OP_READ },
+	PERF_CONST(COUNT_HW_CACHE_OP_READ),
-	{ "COUNT_HW_CACHE_OP_WRITE",	  PERF_COUNT_HW_CACHE_OP_WRITE },
+	PERF_CONST(COUNT_HW_CACHE_OP_WRITE),
-	{ "COUNT_HW_CACHE_OP_PREFETCH",	  PERF_COUNT_HW_CACHE_OP_PREFETCH },
+	PERF_CONST(COUNT_HW_CACHE_OP_PREFETCH),
-	{ "COUNT_HW_CACHE_RESULT_ACCESS", PERF_COUNT_HW_CACHE_RESULT_ACCESS },
+	PERF_CONST(COUNT_HW_CACHE_RESULT_ACCESS),
-	{ "COUNT_HW_CACHE_RESULT_MISS",   PERF_COUNT_HW_CACHE_RESULT_MISS },
+	PERF_CONST(COUNT_HW_CACHE_RESULT_MISS),
 
-	{ "COUNT_HW_STALLED_CYCLES_FRONTEND",	  PERF_COUNT_HW_STALLED_CYCLES_FRONTEND },
+	PERF_CONST(COUNT_HW_STALLED_CYCLES_FRONTEND),
-	{ "COUNT_HW_STALLED_CYCLES_BACKEND",	  PERF_COUNT_HW_STALLED_CYCLES_BACKEND },
+	PERF_CONST(COUNT_HW_STALLED_CYCLES_BACKEND),
 
-	{ "COUNT_SW_CPU_CLOCK",	       PERF_COUNT_SW_CPU_CLOCK },
+	PERF_CONST(COUNT_SW_CPU_CLOCK),
-	{ "COUNT_SW_TASK_CLOCK",       PERF_COUNT_SW_TASK_CLOCK },
+	PERF_CONST(COUNT_SW_TASK_CLOCK),
-	{ "COUNT_SW_PAGE_FAULTS",      PERF_COUNT_SW_PAGE_FAULTS },
+	PERF_CONST(COUNT_SW_PAGE_FAULTS),
-	{ "COUNT_SW_CONTEXT_SWITCHES", PERF_COUNT_SW_CONTEXT_SWITCHES },
+	PERF_CONST(COUNT_SW_CONTEXT_SWITCHES),
-	{ "COUNT_SW_CPU_MIGRATIONS",   PERF_COUNT_SW_CPU_MIGRATIONS },
+	PERF_CONST(COUNT_SW_CPU_MIGRATIONS),
-	{ "COUNT_SW_PAGE_FAULTS_MIN",  PERF_COUNT_SW_PAGE_FAULTS_MIN },
+	PERF_CONST(COUNT_SW_PAGE_FAULTS_MIN),
-	{ "COUNT_SW_PAGE_FAULTS_MAJ",  PERF_COUNT_SW_PAGE_FAULTS_MAJ },
+	PERF_CONST(COUNT_SW_PAGE_FAULTS_MAJ),
-	{ "COUNT_SW_ALIGNMENT_FAULTS", PERF_COUNT_SW_ALIGNMENT_FAULTS },
+	PERF_CONST(COUNT_SW_ALIGNMENT_FAULTS),
-	{ "COUNT_SW_EMULATION_FAULTS", PERF_COUNT_SW_EMULATION_FAULTS },
+	PERF_CONST(COUNT_SW_EMULATION_FAULTS),
-	{ "COUNT_SW_DUMMY",            PERF_COUNT_SW_DUMMY },
+	PERF_CONST(COUNT_SW_DUMMY),
 
-	{ "SAMPLE_IP",	      PERF_SAMPLE_IP },
+	PERF_CONST(SAMPLE_IP),
-	{ "SAMPLE_TID",	      PERF_SAMPLE_TID },
+	PERF_CONST(SAMPLE_TID),
-	{ "SAMPLE_TIME",      PERF_SAMPLE_TIME },
+	PERF_CONST(SAMPLE_TIME),
-	{ "SAMPLE_ADDR",      PERF_SAMPLE_ADDR },
+	PERF_CONST(SAMPLE_ADDR),
-	{ "SAMPLE_READ",      PERF_SAMPLE_READ },
+	PERF_CONST(SAMPLE_READ),
-	{ "SAMPLE_CALLCHAIN", PERF_SAMPLE_CALLCHAIN },
+	PERF_CONST(SAMPLE_CALLCHAIN),
-	{ "SAMPLE_ID",	      PERF_SAMPLE_ID },
+	PERF_CONST(SAMPLE_ID),
-	{ "SAMPLE_CPU",	      PERF_SAMPLE_CPU },
+	PERF_CONST(SAMPLE_CPU),
-	{ "SAMPLE_PERIOD",    PERF_SAMPLE_PERIOD },
+	PERF_CONST(SAMPLE_PERIOD),
-	{ "SAMPLE_STREAM_ID", PERF_SAMPLE_STREAM_ID },
+	PERF_CONST(SAMPLE_STREAM_ID),
-	{ "SAMPLE_RAW",	      PERF_SAMPLE_RAW },
+	PERF_CONST(SAMPLE_RAW),
 
-	{ "FORMAT_TOTAL_TIME_ENABLED", PERF_FORMAT_TOTAL_TIME_ENABLED },
+	PERF_CONST(FORMAT_TOTAL_TIME_ENABLED),
-	{ "FORMAT_TOTAL_TIME_RUNNING", PERF_FORMAT_TOTAL_TIME_RUNNING },
+	PERF_CONST(FORMAT_TOTAL_TIME_RUNNING),
-	{ "FORMAT_ID",		       PERF_FORMAT_ID },
+	PERF_CONST(FORMAT_ID),
-	{ "FORMAT_GROUP",	       PERF_FORMAT_GROUP },
+	PERF_CONST(FORMAT_GROUP),
 
-	{ "RECORD_MMAP",       PERF_RECORD_MMAP },
+	PERF_CONST(RECORD_MMAP),
-	{ "RECORD_LOST",       PERF_RECORD_LOST },
+	PERF_CONST(RECORD_LOST),
-	{ "RECORD_COMM",       PERF_RECORD_COMM },
+	PERF_CONST(RECORD_COMM),
-	{ "RECORD_EXIT",       PERF_RECORD_EXIT },
+	PERF_CONST(RECORD_EXIT),
-	{ "RECORD_THROTTLE",   PERF_RECORD_THROTTLE },
+	PERF_CONST(RECORD_THROTTLE),
-	{ "RECORD_UNTHROTTLE", PERF_RECORD_UNTHROTTLE },
+	PERF_CONST(RECORD_UNTHROTTLE),
-	{ "RECORD_FORK",       PERF_RECORD_FORK },
+	PERF_CONST(RECORD_FORK),
-	{ "RECORD_READ",       PERF_RECORD_READ },
+	PERF_CONST(RECORD_READ),
-	{ "RECORD_SAMPLE",     PERF_RECORD_SAMPLE },
+	PERF_CONST(RECORD_SAMPLE),
+	PERF_CONST(RECORD_MMAP2),
+	PERF_CONST(RECORD_AUX),
+	PERF_CONST(RECORD_ITRACE_START),
+	PERF_CONST(RECORD_LOST_SAMPLES),
+	PERF_CONST(RECORD_SWITCH),
+	PERF_CONST(RECORD_SWITCH_CPU_WIDE),
 	{ .name = NULL, },
 };
 

tools/perf/util/session.c

@@ -170,7 +170,7 @@ static void perf_session__delete_threads(struct perf_session *session)
 	machine__delete_threads(&session->machines.host);
 }
 
-static void perf_session_env__delete(struct perf_session_env *env)
+static void perf_session_env__exit(struct perf_session_env *env)
 {
 	zfree(&env->hostname);
 	zfree(&env->os_release);
@@ -193,7 +193,7 @@ void perf_session__delete(struct perf_session *session)
 	auxtrace_index__free(&session->auxtrace_index);
 	perf_session__destroy_kernel_maps(session);
 	perf_session__delete_threads(session);
-	perf_session_env__delete(&session->header.env);
+	perf_session_env__exit(&session->header.env);
 	machines__exit(&session->machines);
 	if (session->file)
 		perf_data_file__close(session->file);

tools/perf/util/symbol-elf.c

@@ -38,7 +38,7 @@ static inline char *bfd_demangle(void __maybe_unused *v,
 #endif
 
 #ifndef HAVE_ELF_GETPHDRNUM_SUPPORT
-static int elf_getphdrnum(Elf *elf, size_t *dst)
+int elf_getphdrnum(Elf *elf, size_t *dst)
 {
 	GElf_Ehdr gehdr;
 	GElf_Ehdr *ehdr;

tools/perf/util/trace-event.c

@@ -50,14 +50,13 @@ static int trace_event__init2(void)
 	return 0;
 }
 
-int trace_event__register_resolver(struct machine *machine)
+int trace_event__register_resolver(struct machine *machine,
+				   pevent_func_resolver_t *func)
 {
 	if (!tevent_initialized && trace_event__init2())
 		return -1;
 
-	return pevent_set_function_resolver(tevent.pevent,
+	return pevent_set_function_resolver(tevent.pevent, func, machine);
-					    machine__resolve_kernel_addr,
-					    machine);
 }
 
 void trace_event__cleanup(struct trace_event *t)

tools/perf/util/trace-event.h

@@ -18,7 +18,8 @@ struct trace_event {
 
 int trace_event__init(struct trace_event *t);
 void trace_event__cleanup(struct trace_event *t);
-int trace_event__register_resolver(struct machine *machine);
+int trace_event__register_resolver(struct machine *machine,
+				   pevent_func_resolver_t *func);
 struct event_format*
 trace_event__tp_format(const char *sys, const char *name);