lael-labs/linux

MAINTAINERS+1−1

 M:	Peter Zijlstra <peterz@infradead.org>
 M:	Ingo Molnar <mingo@redhat.com>
 M:	Arnaldo Carvalho de Melo <acme@kernel.org>
+M:	Namhyung Kim <namhyung@kernel.org>
 R:	Mark Rutland <mark.rutland@arm.com>
 R:	Alexander Shishkin <alexander.shishkin@linux.intel.com>
 R:	Jiri Olsa <jolsa@kernel.org>
-R:	Namhyung Kim <namhyung@kernel.org>
 R:	Ian Rogers <irogers@google.com>
 R:	Adrian Hunter <adrian.hunter@intel.com>
 L:	linux-perf-users@vger.kernel.org

tools/build/Makefile.feature+1−0

@@ -32,6 +32,7 @@ FEATURE_TESTS_BASIC := \ · 31 unmodified lines
32	backtrace \	32	backtrace \
33	dwarf \	33	dwarf \
34	dwarf_getlocations \	34	dwarf_getlocations \
		35	dwarf_getcfi \
35	eventfd \	36	eventfd \
36	fortify-source \	37	fortify-source \
37	get_current_dir_name \	38	get_current_dir_name \

tools/build/feature/Makefile+4−0

          test-bionic.bin                        \
          test-dwarf.bin                         \
          test-dwarf_getlocations.bin            \
+         test-dwarf_getcfi.bin                  \
          test-eventfd.bin                       \
          test-fortify-source.bin                \
          test-get_current_dir_name.bin          \
 $(OUTPUT)test-dwarf_getlocations.bin:
 	$(BUILD) $(DWARFLIBS)
+$(OUTPUT)test-dwarf_getcfi.bin:
+	$(BUILD) $(DWARFLIBS)
 $(OUTPUT)test-libelf-getphdrnum.bin:
 	$(BUILD) -lelf

tools/build/feature/test-dwarf_getcfi.c+9−0

@@ -0,0 +1,9 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	#include <stdio.h>
	3	#include <elfutils/libdw.h>
	4
	5	int main(void)
	6	{
	7	Dwarf *dwarf = NULL;
	8	return dwarf_getcfi(dwarf) == NULL;
	9	}

tools/build/feature/test-libopencsd.c+2−2

@@ -4,9 +4,9 @@ · 3 unmodified lines
4	/*	4	/*
5	* Check OpenCSD library version is sufficient to provide required features	5	* Check OpenCSD library version is sufficient to provide required features
6	*/	6	*/
7	#define OCSD_MIN_VER ((1 << 16) \| (1 << 8) \| (1))	7	#define OCSD_MIN_VER ((1 << 16) \| (2 << 8) \| (1))
8	#if !defined(OCSD_VER_NUM) \|\| (OCSD_VER_NUM < OCSD_MIN_VER)	8	#if !defined(OCSD_VER_NUM) \|\| (OCSD_VER_NUM < OCSD_MIN_VER)
9	#error "OpenCSD >= 1.1.1 is required"	9	#error "OpenCSD >= 1.2.1 is required"
10	#endif	10	#endif
11		11
12	int main(void)	12	int main(void)

tools/include/uapi/linux/perf_event.h+13−0

 	PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT	= 18, /* save privilege mode */
+	PERF_SAMPLE_BRANCH_COUNTERS_SHIFT	= 19, /* save occurrences of events on a branch */
 	PERF_SAMPLE_BRANCH_MAX_SHIFT		/* non-ABI */
 };
 	PERF_SAMPLE_BRANCH_PRIV_SAVE	= 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT,
+	PERF_SAMPLE_BRANCH_COUNTERS	= 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT,
 	PERF_SAMPLE_BRANCH_MAX		= 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT,
 };
 	 *	{ u64                   nr;
 	 *	  { u64	hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX
 	 *        { u64 from, to, flags } lbr[nr];
+	 *        #
+	 *        # The format of the counters is decided by the
+	 *        # "branch_counter_nr" and "branch_counter_width",
+	 *        # which are defined in the ABI.
+	 *        #
+	 *        { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS
 	 *      } && PERF_SAMPLE_BRANCH_STACK
 	 *
 	 * 	{ u64			abi; # enum perf_sample_regs_abi
 		reserved:31;
 };
+/* Size of used info bits in struct perf_branch_entry */
+#define PERF_BRANCH_ENTRY_INFO_BITS_MAX		33
 union perf_sample_weight {
 	__u64		full;
 #if defined(__LITTLE_ENDIAN_BITFIELD)

tools/lib/api/fs/fs.c+29−51

@@ -16,6 +16,7 @@ · 15 unmodified lines
16	#include <sys/mount.h>	16	#include <sys/mount.h>
17		17
18	#include "fs.h"	18	#include "fs.h"
		19	#include "../io.h"
19	#include "debug-internal.h"	20	#include "debug-internal.h"
20		21
21	#define _STR(x) #x	22	#define _STR(x) #x
@@ -344,53 +345,24 @@ int filename__read_ull(const char filename, unsigned long long value) · 322 unmodified lines
344	return filename__read_ull_base(filename, value, 0);	345	return filename__read_ull_base(filename, value, 0);
345	}	346	}
346		347
347	#define STRERR_BUFSIZE 128 /* For the buffer size of strerror_r */
348
349	int filename__read_str(const char filename, char buf, size_t sizep)	348	int filename__read_str(const char filename, char buf, size_t sizep)
350	{	349	{
351	size_t size = 0, alloc_size = 0;	350	struct io io;
352	void bf = NULL, nbf;	351	char bf[128];
353	int fd, n, err = 0;	352	int err;
354	char sbuf[STRERR_BUFSIZE];
355		353
356	fd = open(filename, O_RDONLY);	354	io.fd = open(filename, O_RDONLY);
357	if (fd < 0)	355	if (io.fd < 0)
358	return -errno;	356	return -errno;
359		357	io__init(&io, io.fd, bf, sizeof(bf));
360	do {	358	*buf = NULL;
361	if (size == alloc_size) {	359	err = io__getdelim(&io, buf, sizep, /delim=/-1);
362	alloc_size += BUFSIZ;	360	if (err < 0) {
363	nbf = realloc(bf, alloc_size);	361	free(*buf);
364	if (!nbf) {	362	*buf = NULL;
365	err = -ENOMEM;
366	break;
367	}
368
369	bf = nbf;
370	}
371
372	n = read(fd, bf + size, alloc_size - size);
373	if (n < 0) {
374	if (size) {
375	pr_warn("read failed %d: %s\n", errno,
376	strerror_r(errno, sbuf, sizeof(sbuf)));
377	err = 0;
378	} else
379	err = -errno;
380
381	break;
382	}
383
384	size += n;
385	} while (n > 0);
386
387	if (!err) {
388	*sizep = size;
389	*buf = bf;
390	} else	363	} else
391	free(bf);	364	err = 0;
392		365	close(io.fd);
393	close(fd);
394	return err;	366	return err;
395	}	367	}
396		368
@@ -475,15 +447,22 @@ int sysfs__read_str(const char entry, char buf, size_t sizep) · 78 unmodified lines
475		447
476	int sysfs__read_bool(const char entry, bool value)	448	int sysfs__read_bool(const char entry, bool value)
477	{	449	{
478	char *buf;	450	struct io io;
479	size_t size;	451	char bf[16];
480	int ret;	452	int ret = 0;
		453	char path[PATH_MAX];
		454	const char *sysfs = sysfs__mountpoint();
		455
		456	if (!sysfs)
		457	return -1;
481		458
482	ret = sysfs__read_str(entry, &buf, &size);	459	snprintf(path, sizeof(path), "%s/%s", sysfs, entry);
483	if (ret < 0)	460	io.fd = open(path, O_RDONLY);
484	return ret;	461	if (io.fd < 0)
		462	return -errno;
485		463
486	switch (buf[0]) {	464	io__init(&io, io.fd, bf, sizeof(bf));
		465	switch (io__get_char(&io)) {
487	case '1':	466	case '1':
488	case 'y':	467	case 'y':
489	case 'Y':	468	case 'Y':
@@ -497,8 +476,7 @@ int sysfs__read_bool(const char entry, bool value) · 7 unmodified lines
497	default:	476	default:
498	ret = -1;	477	ret = -1;
499	}	478	}
500		479	close(io.fd);
501	free(buf);
502		480
503	return ret;	481	return ret;
504	}	482	}

tools/lib/api/io.h+9−3

 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <linux/types.h>
 struct io {
 	/* File descriptor being read/ */
 	}
 }
-/* Read up to and including the first newline following the pattern of getline. */
+/* Read up to and including the first delim. */
-static inline ssize_t io__getline(struct io *io, char **line_out, size_t *line_len_out)
+static inline ssize_t io__getdelim(struct io *io, char **line_out, size_t *line_len_out, int delim)
 {
 	char buf[128];
 	int buf_pos = 0;
 	/* TODO: reuse previously allocated memory. */
 	free(*line_out);
-	while (ch != '\n') {
+	while (ch != delim) {
 		ch = io__get_char(io);
 		if (ch < 0)
 	return -ENOMEM;
 }
+static inline ssize_t io__getline(struct io *io, char **line_out, size_t *line_len_out)
+{
+	return io__getdelim(io, line_out, line_len_out, /*delim=*/'\n');
+}
 #endif /* __API_IO__ */

tools/lib/perf/Documentation/examples/sampling.c+1−1

@@ -39,7 +39,7 @@ int main(int argc, char **argv) · 38 unmodified lines
39		39
40	libperf_init(libperf_print);	40	libperf_init(libperf_print);
41		41
42	cpus = perf_cpu_map__new(NULL);	42	cpus = perf_cpu_map__new_online_cpus();
43	if (!cpus) {	43	if (!cpus) {
44	fprintf(stderr, "failed to create cpus\n");	44	fprintf(stderr, "failed to create cpus\n");
45	return -1;	45	return -1;

tools/lib/perf/Documentation/libperf-sampling.txt+1−1

@@ -97,7 +97,7 @@ In this case we will monitor all the available CPUs: · 96 unmodified lines
97		97
98	[source,c]	98	[source,c]
99	--	99	--
100	42 cpus = perf_cpu_map__new(NULL);	100	42 cpus = perf_cpu_map__new_online_cpus();
101	43 if (!cpus) {	101	43 if (!cpus) {
102	44 fprintf(stderr, "failed to create cpus\n");	102	44 fprintf(stderr, "failed to create cpus\n");
103	45 return -1;	103	45 return -1;

tools/lib/perf/Documentation/libperf.txt+2−2

@@ -37,7 +37,7 @@ SYNOPSIS · 36 unmodified lines
37		37
38	struct perf_cpu_map;	38	struct perf_cpu_map;
39		39
40	struct perf_cpu_map *perf_cpu_map__dummy_new(void);	40	struct perf_cpu_map *perf_cpu_map__new_any_cpu(void);
41	struct perf_cpu_map perf_cpu_map__new(const char cpu_list);	41	struct perf_cpu_map perf_cpu_map__new(const char cpu_list);
42	struct perf_cpu_map perf_cpu_map__read(FILE file);	42	struct perf_cpu_map perf_cpu_map__read(FILE file);
43	struct perf_cpu_map perf_cpu_map__get(struct perf_cpu_map map);	43	struct perf_cpu_map perf_cpu_map__get(struct perf_cpu_map map);
@@ -46,7 +46,7 @@ SYNOPSIS · 2 unmodified lines
46	void perf_cpu_map__put(struct perf_cpu_map *map);	46	void perf_cpu_map__put(struct perf_cpu_map *map);
47	int perf_cpu_map__cpu(const struct perf_cpu_map *cpus, int idx);	47	int perf_cpu_map__cpu(const struct perf_cpu_map *cpus, int idx);
48	int perf_cpu_map__nr(const struct perf_cpu_map *cpus);	48	int perf_cpu_map__nr(const struct perf_cpu_map *cpus);
49	bool perf_cpu_map__empty(const struct perf_cpu_map *map);	49	bool perf_cpu_map__has_any_cpu_or_is_empty(const struct perf_cpu_map *map);
50	int perf_cpu_map__max(struct perf_cpu_map *map);	50	int perf_cpu_map__max(struct perf_cpu_map *map);
51	bool perf_cpu_map__has(const struct perf_cpu_map *map, int cpu);	51	bool perf_cpu_map__has(const struct perf_cpu_map *map, int cpu);
52		52

tools/lib/perf/cpumap.c+38−27

 #include <unistd.h>
 #include <ctype.h>
 #include <limits.h>
+#include "internal.h"
 void perf_cpu_map__set_nr(struct perf_cpu_map *map, int nr_cpus)
 {
 	return result;
 }
-struct perf_cpu_map *perf_cpu_map__dummy_new(void)
+struct perf_cpu_map *perf_cpu_map__new_any_cpu(void)
 {
 	struct perf_cpu_map *cpus = perf_cpu_map__alloc(1);
 	}
 }
-static struct perf_cpu_map *cpu_map__default_new(void)
+static struct perf_cpu_map *cpu_map__new_sysconf(void)
 {
 	struct perf_cpu_map *cpus;
-	int nr_cpus;
+	int nr_cpus, nr_cpus_conf;
 	nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
 	if (nr_cpus < 0)
 		return NULL;
+	nr_cpus_conf = sysconf(_SC_NPROCESSORS_CONF);
+	if (nr_cpus != nr_cpus_conf) {
+		pr_warning("Number of online CPUs (%d) differs from the number configured (%d) the CPU map will only cover the first %d CPUs.",
+			nr_cpus, nr_cpus_conf, nr_cpus);
+	}
 	cpus = perf_cpu_map__alloc(nr_cpus);
 	if (cpus != NULL) {
 		int i;
 	return cpus;
 }
-struct perf_cpu_map *perf_cpu_map__default_new(void)
+static struct perf_cpu_map *cpu_map__new_sysfs_online(void)
 {
-	return cpu_map__default_new();
+	struct perf_cpu_map *cpus = NULL;
+	FILE *onlnf;
+	onlnf = fopen("/sys/devices/system/cpu/online", "r");
+	if (onlnf) {
+		cpus = perf_cpu_map__read(onlnf);
+		fclose(onlnf);
+	}
+	return cpus;
+}
+struct perf_cpu_map *perf_cpu_map__new_online_cpus(void)
+{
+	struct perf_cpu_map *cpus = cpu_map__new_sysfs_online();
+	if (cpus)
+		return cpus;
+	return cpu_map__new_sysconf();
 }
 	if (nr_cpus > 0)
 		cpus = cpu_map__trim_new(nr_cpus, tmp_cpus);
-	else
-		cpus = cpu_map__default_new();
 out_free_tmp:
 	free(tmp_cpus);
 	return cpus;
 }
-static struct perf_cpu_map *cpu_map__read_all_cpu_map(void)
-{
-	struct perf_cpu_map *cpus = NULL;
-	FILE *onlnf;
-	onlnf = fopen("/sys/devices/system/cpu/online", "r");
-	if (!onlnf)
-		return cpu_map__default_new();
-	cpus = perf_cpu_map__read(onlnf);
-	fclose(onlnf);
-	return cpus;
-}
 struct perf_cpu_map *perf_cpu_map__new(const char *cpu_list)
 {
 	struct perf_cpu_map *cpus = NULL;
 	int max_entries = 0;
 	if (!cpu_list)
-		return cpu_map__read_all_cpu_map();
+		return perf_cpu_map__new_online_cpus();
 	/*
 	 * must handle the case of empty cpumap to cover
 	if (nr_cpus > 0)
 		cpus = cpu_map__trim_new(nr_cpus, tmp_cpus);
-	else if (*cpu_list != '\0')
+	else if (*cpu_list != '\0') {
-		cpus = cpu_map__default_new();
+		pr_warning("Unexpected characters at end of cpu list ('%s'), using online CPUs.",
-	else
+			   cpu_list);
-		cpus = perf_cpu_map__dummy_new();
+		cpus = perf_cpu_map__new_online_cpus();
+	} else
+		cpus = perf_cpu_map__new_any_cpu();
 invalid:
 	free(tmp_cpus);
 out:
 	return cpus ? __perf_cpu_map__nr(cpus) : 1;
 }
-bool perf_cpu_map__empty(const struct perf_cpu_map *map)
+bool perf_cpu_map__has_any_cpu_or_is_empty(const struct perf_cpu_map *map)
 {
 	return map ? __perf_cpu_map__cpu(map, 0).cpu == -1 : true;
 }

tools/lib/perf/evlist.c+3−3

@@ -39,7 +39,7 @@ static void __perf_evlist__propagate_maps(struct perf_evlist *evlist, · 38 unmodified lines
39	if (evsel->system_wide) {	39	if (evsel->system_wide) {
40	/* System wide: set the cpu map of the evsel to all online CPUs. */	40	/* System wide: set the cpu map of the evsel to all online CPUs. */
41	perf_cpu_map__put(evsel->cpus);	41	perf_cpu_map__put(evsel->cpus);
42	evsel->cpus = perf_cpu_map__new(NULL);	42	evsel->cpus = perf_cpu_map__new_online_cpus();
43	} else if (evlist->has_user_cpus && evsel->is_pmu_core) {	43	} else if (evlist->has_user_cpus && evsel->is_pmu_core) {
44	/*	44	/*
45	* User requested CPUs on a core PMU, ensure the requested CPUs	45	* User requested CPUs on a core PMU, ensure the requested CPUs
@@ -619,7 +619,7 @@ static int perf_evlist__nr_mmaps(struct perf_evlist *evlist) · 573 unmodified lines
619		619
620	/* One for each CPU */	620	/* One for each CPU */
621	nr_mmaps = perf_cpu_map__nr(evlist->all_cpus);	621	nr_mmaps = perf_cpu_map__nr(evlist->all_cpus);
622	if (perf_cpu_map__empty(evlist->all_cpus)) {	622	if (perf_cpu_map__has_any_cpu_or_is_empty(evlist->all_cpus)) {
623	/* Plus one for each thread */	623	/* Plus one for each thread */
624	nr_mmaps += perf_thread_map__nr(evlist->threads);	624	nr_mmaps += perf_thread_map__nr(evlist->threads);
625	/* Minus the per-thread CPU (-1) */	625	/* Minus the per-thread CPU (-1) */
@@ -653,7 +653,7 @@ int perf_evlist__mmap_ops(struct perf_evlist *evlist, · 27 unmodified lines
653	if (evlist->pollfd.entries == NULL && perf_evlist__alloc_pollfd(evlist) < 0)	653	if (evlist->pollfd.entries == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
654	return -ENOMEM;	654	return -ENOMEM;
655		655
656	if (perf_cpu_map__empty(cpus))	656	if (perf_cpu_map__has_any_cpu_or_is_empty(cpus))
657	return mmap_per_thread(evlist, ops, mp);	657	return mmap_per_thread(evlist, ops, mp);
658		658
659	return mmap_per_cpu(evlist, ops, mp);	659	return mmap_per_cpu(evlist, ops, mp);

tools/lib/perf/evsel.c+1−1

@@ -120,7 +120,7 @@ int perf_evsel__open(struct perf_evsel evsel, struct perf_cpu_map cpus, · 119 unmodified lines
120	static struct perf_cpu_map *empty_cpu_map;	120	static struct perf_cpu_map *empty_cpu_map;
121		121
122	if (empty_cpu_map == NULL) {	122	if (empty_cpu_map == NULL) {
123	empty_cpu_map = perf_cpu_map__dummy_new();	123	empty_cpu_map = perf_cpu_map__new_any_cpu();
124	if (empty_cpu_map == NULL)	124	if (empty_cpu_map == NULL)
125	return -ENOMEM;	125	return -ENOMEM;
126	}	126	}

tools/lib/perf/include/internal/mmap.h+2−1

@@ -33,7 +33,8 @@ struct perf_mmap { · 32 unmodified lines
33	bool overwrite;	33	bool overwrite;
34	u64 flush;	34	u64 flush;
35	libperf_unmap_cb_t unmap_cb;	35	libperf_unmap_cb_t unmap_cb;
36	char event_copy[PERF_SAMPLE_MAX_SIZE] __aligned(8);	36	void *event_copy;
		37	size_t event_copy_sz;
37	struct perf_mmap *next;	38	struct perf_mmap *next;
38	};	39	};
39		40

tools/lib/perf/include/perf/cpumap.h+35−5

@@ -19,10 +19,23 @@ struct perf_cache { · 18 unmodified lines
19	struct perf_cpu_map;	19	struct perf_cpu_map;
20		20
21	/**	21	/**
22	* perf_cpu_map__dummy_new - a map with a singular "any CPU"/dummy -1 value.	22	* perf_cpu_map__new_any_cpu - a map with a singular "any CPU"/dummy -1 value.
		23	*/
		24	LIBPERF_API struct perf_cpu_map *perf_cpu_map__new_any_cpu(void);
		25	/**
		26	* perf_cpu_map__new_online_cpus - a map read from
		27	* /sys/devices/system/cpu/online if
		28	* available. If reading wasn't possible a map
		29	* is created using the online processors
		30	* assuming the first 'n' processors are all
		31	* online.
		32	*/
		33	LIBPERF_API struct perf_cpu_map *perf_cpu_map__new_online_cpus(void);
		34	/**
		35	* perf_cpu_map__new - create a map from the given cpu_list such as "0-7". If no
		36	* cpu_list argument is provided then
		37	* perf_cpu_map__new_online_cpus is returned.
23	*/	38	*/
24	LIBPERF_API struct perf_cpu_map *perf_cpu_map__dummy_new(void);
25	LIBPERF_API struct perf_cpu_map *perf_cpu_map__default_new(void);
26	LIBPERF_API struct perf_cpu_map perf_cpu_map__new(const char cpu_list);	39	LIBPERF_API struct perf_cpu_map perf_cpu_map__new(const char cpu_list);
27	LIBPERF_API struct perf_cpu_map perf_cpu_map__read(FILE file);	40	LIBPERF_API struct perf_cpu_map perf_cpu_map__read(FILE file);
28	LIBPERF_API struct perf_cpu_map perf_cpu_map__get(struct perf_cpu_map map);	41	LIBPERF_API struct perf_cpu_map perf_cpu_map__get(struct perf_cpu_map map);
@@ -31,12 +44,23 @@ LIBPERF_API struct perf_cpu_map perf_cpu_map__merge(struct perf_cpu_map orig, · 2 unmodified lines
31	LIBPERF_API struct perf_cpu_map perf_cpu_map__intersect(struct perf_cpu_map orig,	44	LIBPERF_API struct perf_cpu_map perf_cpu_map__intersect(struct perf_cpu_map orig,
32	struct perf_cpu_map *other);	45	struct perf_cpu_map *other);
33	LIBPERF_API void perf_cpu_map__put(struct perf_cpu_map *map);	46	LIBPERF_API void perf_cpu_map__put(struct perf_cpu_map *map);
		47	/**
		48	* perf_cpu_map__cpu - get the CPU value at the given index. Returns -1 if index
		49	* is invalid.
		50	*/
34	LIBPERF_API struct perf_cpu perf_cpu_map__cpu(const struct perf_cpu_map *cpus, int idx);	51	LIBPERF_API struct perf_cpu perf_cpu_map__cpu(const struct perf_cpu_map *cpus, int idx);
		52	/**
		53	* perf_cpu_map__nr - for an empty map returns 1, as perf_cpu_map__cpu returns a
		54	* cpu of -1 for an invalid index, this makes an empty map
		55	* look like it contains the "any CPU"/dummy value. Otherwise
		56	* the result is the number CPUs in the map plus one if the
		57	* "any CPU"/dummy value is present.
		58	*/
35	LIBPERF_API int perf_cpu_map__nr(const struct perf_cpu_map *cpus);	59	LIBPERF_API int perf_cpu_map__nr(const struct perf_cpu_map *cpus);
36	/**	60	/**
37	* perf_cpu_map__empty - is map either empty or the "any CPU"/dummy value.	61	* perf_cpu_map__has_any_cpu_or_is_empty - is map either empty or has the "any CPU"/dummy value.
38	*/	62	*/
39	LIBPERF_API bool perf_cpu_map__empty(const struct perf_cpu_map *map);	63	LIBPERF_API bool perf_cpu_map__has_any_cpu_or_is_empty(const struct perf_cpu_map *map);
40	LIBPERF_API struct perf_cpu perf_cpu_map__max(const struct perf_cpu_map *map);	64	LIBPERF_API struct perf_cpu perf_cpu_map__max(const struct perf_cpu_map *map);
41	LIBPERF_API bool perf_cpu_map__has(const struct perf_cpu_map *map, struct perf_cpu cpu);	65	LIBPERF_API bool perf_cpu_map__has(const struct perf_cpu_map *map, struct perf_cpu cpu);
42	LIBPERF_API bool perf_cpu_map__equal(const struct perf_cpu_map *lhs,	66	LIBPERF_API bool perf_cpu_map__equal(const struct perf_cpu_map *lhs,
@@ -51,6 +75,12 @@ LIBPERF_API bool perf_cpu_map__has_any_cpu(const struct perf_cpu_map *map); · 8 unmodified lines
51	(idx) < perf_cpu_map__nr(cpus); \	75	(idx) < perf_cpu_map__nr(cpus); \
52	(idx)++, (cpu) = perf_cpu_map__cpu(cpus, idx))	76	(idx)++, (cpu) = perf_cpu_map__cpu(cpus, idx))
53		77
		78	#define perf_cpu_map__for_each_cpu_skip_any(_cpu, idx, cpus) \
		79	for ((idx) = 0, (_cpu) = perf_cpu_map__cpu(cpus, idx); \
		80	(idx) < perf_cpu_map__nr(cpus); \
		81	(idx)++, (_cpu) = perf_cpu_map__cpu(cpus, idx)) \
		82	if ((_cpu).cpu != -1)
		83
54	#define perf_cpu_map__for_each_idx(idx, cpus) \	84	#define perf_cpu_map__for_each_idx(idx, cpus) \
55	for ((idx) = 0; (idx) < perf_cpu_map__nr(cpus); (idx)++)	85	for ((idx) = 0; (idx) < perf_cpu_map__nr(cpus); (idx)++)
56		86

tools/lib/perf/libperf.map+3−3

@@ -1,15 +1,15 @@
1	LIBPERF_0.0.1 {	1	LIBPERF_0.0.1 {
2	global:	2	global:
3	libperf_init;	3	libperf_init;
4	perf_cpu_map__dummy_new;	4	perf_cpu_map__new_any_cpu;
5	perf_cpu_map__default_new;	5	perf_cpu_map__new_online_cpus;
6	perf_cpu_map__get;	6	perf_cpu_map__get;
7	perf_cpu_map__put;	7	perf_cpu_map__put;
8	perf_cpu_map__new;	8	perf_cpu_map__new;
9	perf_cpu_map__read;	9	perf_cpu_map__read;
10	perf_cpu_map__nr;	10	perf_cpu_map__nr;
11	perf_cpu_map__cpu;	11	perf_cpu_map__cpu;
12	perf_cpu_map__empty;	12	perf_cpu_map__has_any_cpu_or_is_empty;
13	perf_cpu_map__max;	13	perf_cpu_map__max;
14	perf_cpu_map__has;	14	perf_cpu_map__has;
15	perf_thread_map__new_array;	15	perf_thread_map__new_array;

tools/lib/perf/mmap.c+17−3

 void perf_mmap__init(struct perf_mmap *map, struct perf_mmap *prev,
 		     bool overwrite, libperf_unmap_cb_t unmap_cb)
 {
+	/* Assume fields were zero initialized. */
 	map->fd = -1;
 	map->overwrite = overwrite;
 	map->unmap_cb  = unmap_cb;
 void perf_mmap__munmap(struct perf_mmap *map)
 {
-	if (map && map->base != NULL) {
+	if (!map)
+		return;
+	zfree(&map->event_copy);
+	map->event_copy_sz = 0;
+	if (map->base) {
 		munmap(map->base, perf_mmap__mmap_len(map));
 		map->base = NULL;
 		map->fd = -1;
 		refcount_set(&map->refcnt, 0);
 	}
-	if (map && map->unmap_cb)
+	if (map->unmap_cb)
 		map->unmap_cb(map);
 }
 		 */
 		if ((*startp & map->mask) + size != ((*startp + size) & map->mask)) {
 			unsigned int offset = *startp;
-			unsigned int len = min(sizeof(*event), size), cpy;
+			unsigned int len = size, cpy;
 			void *dst = map->event_copy;
+			if (size > map->event_copy_sz) {
+				dst = realloc(map->event_copy, size);
+				if (!dst)
+					return NULL;
+				map->event_copy = dst;
+				map->event_copy_sz = size;
+			}
 			do {
 				cpy = min(map->mask + 1 - (offset & map->mask), len);
 				memcpy(dst, &data[offset & map->mask], cpy);

tools/lib/perf/tests/test-cpumap.c+2−2

@@ -21,7 +21,7 @@ int test_cpumap(int argc, char **argv) · 20 unmodified lines
21		21
22	libperf_init(libperf_print);	22	libperf_init(libperf_print);
23		23
24	cpus = perf_cpu_map__dummy_new();	24	cpus = perf_cpu_map__new_any_cpu();
25	if (!cpus)	25	if (!cpus)
26	return -1;	26	return -1;
27		27
@@ -29,7 +29,7 @@ int test_cpumap(int argc, char **argv) · 1 unmodified line
29	perf_cpu_map__put(cpus);	29	perf_cpu_map__put(cpus);
30	perf_cpu_map__put(cpus);	30	perf_cpu_map__put(cpus);
31		31
32	cpus = perf_cpu_map__default_new();	32	cpus = perf_cpu_map__new_online_cpus();
33	if (!cpus)	33	if (!cpus)
34	return -1;	34	return -1;
35		35

tools/lib/perf/tests/test-evlist.c+3−3

@@ -46,7 +46,7 @@ static int test_stat_cpu(void) · 45 unmodified lines
46	};	46	};
47	int err, idx;	47	int err, idx;
48		48
49	cpus = perf_cpu_map__new(NULL);	49	cpus = perf_cpu_map__new_online_cpus();
50	__T("failed to create cpus", cpus);	50	__T("failed to create cpus", cpus);
51		51
52	evlist = perf_evlist__new();	52	evlist = perf_evlist__new();
@@ -261,7 +261,7 @@ static int test_mmap_thread(void) · 208 unmodified lines
261	threads = perf_thread_map__new_dummy();	261	threads = perf_thread_map__new_dummy();
262	__T("failed to create threads", threads);	262	__T("failed to create threads", threads);
263		263
264	cpus = perf_cpu_map__dummy_new();	264	cpus = perf_cpu_map__new_any_cpu();
265	__T("failed to create cpus", cpus);	265	__T("failed to create cpus", cpus);
266		266
267	perf_thread_map__set_pid(threads, 0, pid);	267	perf_thread_map__set_pid(threads, 0, pid);
@@ -350,7 +350,7 @@ static int test_mmap_cpus(void) · 82 unmodified lines
350		350
351	attr.config = id;	351	attr.config = id;
352		352
353	cpus = perf_cpu_map__new(NULL);	353	cpus = perf_cpu_map__new_online_cpus();
354	__T("failed to create cpus", cpus);	354	__T("failed to create cpus", cpus);
355		355
356	evlist = perf_evlist__new();	356	evlist = perf_evlist__new();

tools/lib/perf/tests/test-evsel.c+1−1

@@ -27,7 +27,7 @@ static int test_stat_cpu(void) · 26 unmodified lines
27	};	27	};
28	int err, idx;	28	int err, idx;
29		29
30	cpus = perf_cpu_map__new(NULL);	30	cpus = perf_cpu_map__new_online_cpus();
31	__T("failed to create cpus", cpus);	31	__T("failed to create cpus", cpus);
32		32
33	evsel = perf_evsel__new(&attr);	33	evsel = perf_evsel__new(&attr);

tools/lib/subcmd/help.c+14−4

@@ -52,11 +52,21 @@ void uniq(struct cmdnames *cmds) · 51 unmodified lines
52	if (!cmds->cnt)	52	if (!cmds->cnt)
53	return;	53	return;
54		54
55	for (i = j = 1; i < cmds->cnt; i++)	55	for (i = 1; i < cmds->cnt; i++) {
56	if (strcmp(cmds->names[i]->name, cmds->names[i-1]->name))	56	if (!strcmp(cmds->names[i]->name, cmds->names[i-1]->name))
57	cmds->names[j++] = cmds->names[i];	57	zfree(&cmds->names[i - 1]);
58		58	}
		59	for (i = 0, j = 0; i < cmds->cnt; i++) {
		60	if (cmds->names[i]) {
		61	if (i == j)
		62	j++;
		63	else
		64	cmds->names[j++] = cmds->names[i];
		65	}
		66	}
59	cmds->cnt = j;	67	cmds->cnt = j;
		68	while (j < i)
		69	cmds->names[j++] = NULL;
60	}	70	}
61		71
62	void exclude_cmds(struct cmdnames cmds, struct cmdnames excludes)	72	void exclude_cmds(struct cmdnames cmds, struct cmdnames excludes)

tools/perf/.gitignore+4−0

 pmu-events/pmu-events.c
 pmu-events/jevents
 pmu-events/metric_test.log
+tests/shell/*.shellcheck_log
+tests/shell/coresight/*.shellcheck_log
+tests/shell/lib/*.shellcheck_log
 feature/
 libapi/
 libbpf/
 libtraceevent_plugins/
 fixdep
 Documentation/doc.dep
+python_ext_build/

tools/perf/Documentation/itrace.txt+1−0

@@ -25,6 +25,7 @@ · 24 unmodified lines
25	q quicker (less detailed) decoding	25	q quicker (less detailed) decoding
26	A approximate IPC	26	A approximate IPC
27	Z prefer to ignore timestamps (so-called "timeless" decoding)	27	Z prefer to ignore timestamps (so-called "timeless" decoding)
		28	T use the timestamp trace as kernel time
28		29
29	The default is all events i.e. the same as --itrace=iybxwpe,	30	The default is all events i.e. the same as --itrace=iybxwpe,
30	except for perf script where it is --itrace=ce	31	except for perf script where it is --itrace=ce

tools/perf/Documentation/perf-annotate.txt+11−0

@@ -155,6 +155,17 @@ include::itrace.txt[] · 154 unmodified lines
155	stdio or stdio2 (Default: 0). Note that this is about selection of	155	stdio or stdio2 (Default: 0). Note that this is about selection of
156	functions to display, not about lines within the function.	156	functions to display, not about lines within the function.
157		157
		158	--data-type[=TYPE_NAME]::
		159	Display data type annotation instead of code. It infers data type of
		160	samples (if they are memory accessing instructions) using DWARF debug
		161	information. It can take an optional argument of data type name. In
		162	that case it'd show annotation for the type only, otherwise it'd show
		163	all data types it finds.
		164
		165	--type-stat::
		166	Show stats for the data type annotation.
		167
		168
158	SEE ALSO	169	SEE ALSO
159	--------	170	--------
160	linkperf:perf-record[1], linkperf:perf-report[1]	171	linkperf:perf-record[1], linkperf:perf-report[1]

tools/perf/Documentation/perf-config.txt+2−2

 		addr2line binary to use for file names and line numbers.
 	annotate.objdump::
-		objdump binary to use for disassembly and annotations.
+		objdump binary to use for disassembly and annotations,
+		including in the 'perf test' command.
 	annotate.disassembler_style::
 		Use this to change the default disassembler style to some other value
 		Defines new record session for daemon. The value is record's
 		command line without the 'record' keyword.
 SEE ALSO
 --------
 linkperf:perf[1]

tools/perf/Documentation/perf-list.txt+7−5

@@ -81,11 +81,13 @@ For Intel systems precise event sampling is implemented with PEBS · 80 unmodified lines
81	which supports up to precise-level 2, and precise level 3 for	81	which supports up to precise-level 2, and precise level 3 for
82	some special cases	82	some special cases
83		83
84	On AMD systems it is implemented using IBS (up to precise-level 2).	84	On AMD systems it is implemented using IBS OP (up to precise-level 2).
85	The precise modifier works with event types 0x76 (cpu-cycles, CPU	85	Unlike Intel PEBS which provides levels of precision, AMD core pmu is
86	clocks not halted) and 0xC1 (micro-ops retired). Both events map to	86	inherently non-precise and IBS is inherently precise. (i.e. ibs_op//,
87	IBS execution sampling (IBS op) with the IBS Op Counter Control bit	87	ibs_op//p, ibs_op//pp and ibs_op//ppp are all same). The precise modifier
88	(IbsOpCntCtl) set respectively (see the	88	works with event types 0x76 (cpu-cycles, CPU clocks not halted) and 0xC1
		89	(micro-ops retired). Both events map to IBS execution sampling (IBS op)
		90	with the IBS Op Counter Control bit (IbsOpCntCtl) set respectively (see the
89	Core Complex (CCX) -> Processor x86 Core -> Instruction Based Sampling (IBS)	91	Core Complex (CCX) -> Processor x86 Core -> Instruction Based Sampling (IBS)
90	section of the [AMD Processor Programming Reference (PPR)] relevant to the	92	section of the [AMD Processor Programming Reference (PPR)] relevant to the
91	family, model and stepping of the processor being used).	93	family, model and stepping of the processor being used).

tools/perf/Documentation/perf-lock.txt+1−1

@@ -119,7 +119,7 @@ INFO OPTIONS · 118 unmodified lines
119		119
120		120
121	CONTENTION OPTIONS	121	CONTENTION OPTIONS
122	--------------	122	------------------
123		123
124	-k::	124	-k::
125	--key=<value>::	125	--key=<value>::

tools/perf/Documentation/perf-record.txt+4−0

 		     4th-Gen Xeon+ server), the save branch type is unconditionally enabled
 		     when the taken branch stack sampling is enabled.
 	- priv: save privilege state during sampling in case binary is not available later
+	- counter: save occurrences of the event since the last branch entry. Currently, the
+		   feature is only supported by a newer CPU, e.g., Intel Sierra Forest and
+		   later platforms. An error out is expected if it's used on the unsupported
+		   kernel or CPUs.
 +
 The option requires at least one branch type among any, any_call, any_ret, ind_call, cond.

tools/perf/Documentation/perf-report.txt+3−0

 	- retire_lat: On X86, this reports pipeline stall of this instruction compared
 	  to the previous instruction in cycles. And currently supported only on X86
 	- simd: Flags describing a SIMD operation. "e" for empty Arm SVE predicate. "p" for partial Arm SVE predicate
+	- type: Data type of sample memory access.
+	- typeoff: Offset in the data type of sample memory access.
+	- symoff: Offset in the symbol.
 	By default, comm, dso and symbol keys are used.
 	(i.e. --sort comm,dso,symbol)

tools/perf/Documentation/perf-stat.txt+28−24

@@ -422,7 +422,34 @@ See perf list output for the possible metrics and metricgroups. · 421 unmodified lines
422		422
423	-A::	423	-A::
424	--no-aggr::	424	--no-aggr::
425	Do not aggregate counts across all monitored CPUs.	425	--no-merge::
		426	Do not aggregate/merge counts across monitored CPUs or PMUs.
		427
		428	When multiple events are created from a single event specification,
		429	stat will, by default, aggregate the event counts and show the result
		430	in a single row. This option disables that behavior and shows the
		431	individual events and counts.
		432
		433	Multiple events are created from a single event specification when:
		434
		435	1. PID monitoring isn't requested and the system has more than one
		436	CPU. For example, a system with 8 SMT threads will have one event
		437	opened on each thread and aggregation is performed across them.
		438
		439	2. Prefix or glob wildcard matching is used for the PMU name. For
		440	example, multiple memory controller PMUs may exist typically with a
		441	suffix of _0, _1, etc. By default the event counts will all be
		442	combined if the PMU is specified without the suffix such as
		443	uncore_imc rather than uncore_imc_0.
		444
		445	3. Aliases, which are listed immediately after the Kernel PMU events
		446	by perf list, are used.
		447
		448	--hybrid-merge::
		449	Merge core event counts from all core PMUs. In hybrid or big.LITTLE
		450	systems by default each core PMU will report its count
		451	separately. This option forces core PMU counts to be combined to give
		452	a behavior closer to having a single CPU type in the system.
426		453
427	--topdown::	454	--topdown::
428	Print top-down metrics supported by the CPU. This allows to determine	455	Print top-down metrics supported by the CPU. This allows to determine
@@ -475,29 +502,6 @@ highlight 'tma_frontend_bound'. This metric may be drilled into with · 46 unmodified lines
475		502
476	Error out if the input is higher than the supported max level.	503	Error out if the input is higher than the supported max level.
477		504
478	--no-merge::
479	Do not merge results from same PMUs.
480
481	When multiple events are created from a single event specification,
482	stat will, by default, aggregate the event counts and show the result
483	in a single row. This option disables that behavior and shows
484	the individual events and counts.
485
486	Multiple events are created from a single event specification when:
487	1. Prefix or glob matching is used for the PMU name.
488	2. Aliases, which are listed immediately after the Kernel PMU events
489	by perf list, are used.
490
491	--hybrid-merge::
492	Merge the hybrid event counts from all PMUs.
493
494	For hybrid events, by default, the stat aggregates and reports the event
495	counts per PMU. But sometimes, it's also useful to aggregate event counts
496	from all PMUs. This option enables that behavior and reports the counts
497	without PMUs.
498
499	For non-hybrid events, it should be no effect.
500
501	--smi-cost::	505	--smi-cost::
502	Measure SMI cost if msr/aperf/ and msr/smi/ events are supported.	506	Measure SMI cost if msr/aperf/ and msr/smi/ events are supported.
503		507

tools/perf/Documentation/perf.txt+3−0

@@ -64,6 +64,9 @@ OPTIONS · 63 unmodified lines
64	perf-event-open - Print perf_event_open() arguments and	64	perf-event-open - Print perf_event_open() arguments and
65	return value	65	return value
66		66
		67	--debug-file::
		68	Write debug output to a specified file.
		69
67	DESCRIPTION	70	DESCRIPTION
68	-----------	71	-----------
69	Performance counters for Linux are a new kernel-based subsystem	72	Performance counters for Linux are a new kernel-based subsystem

tools/perf/Makefile.config+9−4

       else
         CFLAGS += -DHAVE_DWARF_GETLOCATIONS_SUPPORT
       endif # dwarf_getlocations
+      ifneq ($(feature-dwarf_getcfi), 1)
+        msg := $(warning Old libdw.h, finding variables at given 'perf probe' point will not work, install elfutils-devel/libdw-dev >= 0.142);
+      else
+        CFLAGS += -DHAVE_DWARF_CFI_SUPPORT
+      endif # dwarf_getcfi
     endif # Dwarf support
   endif # libelf support
 endif # NO_LIBELF
 endif
 ifeq ($(BUILD_BPF_SKEL),1)
-  ifeq ($(filter -DHAVE_LIBBPF_SUPPORT, $(CFLAGS)),)
+  ifeq ($(filter -DHAVE_LIBELF_SUPPORT, $(CFLAGS)),)
-    dummy := $(warning Warning: Disabled BPF skeletons as libbpf is required)
-    BUILD_BPF_SKEL := 0
-  else ifeq ($(filter -DHAVE_LIBELF_SUPPORT, $(CFLAGS)),)
     dummy := $(warning Warning: Disabled BPF skeletons as libelf is required by bpftool)
     BUILD_BPF_SKEL := 0
   else ifeq ($(filter -DHAVE_ZLIB_SUPPORT, $(CFLAGS)),)
     dummy := $(warning Warning: Disabled BPF skeletons as zlib is required by bpftool)
     BUILD_BPF_SKEL := 0
+  else ifeq ($(filter -DHAVE_LIBBPF_SUPPORT, $(CFLAGS)),)
+    dummy := $(warning Warning: Disabled BPF skeletons as libbpf is required)
+    BUILD_BPF_SKEL := 0
   else ifeq ($(call get-executable,$(CLANG)),)
     dummy := $(warning Warning: Disabled BPF skeletons as clang ($(CLANG)) is missing)
     BUILD_BPF_SKEL := 0

tools/perf/Makefile.perf+11−2

 #	x86 instruction decoder - new instructions test
 #
 # Define GEN_VMLINUX_H to generate vmlinux.h from the BTF.
+#
+# Define NO_SHELLCHECK if you do not want to run shellcheck during build
 # As per kernel Makefile, avoid funny character set dependencies
 unexport LC_ALL
   force_fixdep := $(config)
 endif
+# Runs shellcheck on perf test shell scripts
+ifeq ($(NO_SHELLCHECK),1)
+  SHELLCHECK :=
+else
+  SHELLCHECK := $(shell which shellcheck 2> /dev/null)
+endif
 export srctree OUTPUT RM CC CXX LD AR CFLAGS CXXFLAGS V BISON FLEX AWK
-export HOSTCC HOSTLD HOSTAR HOSTCFLAGS
+export HOSTCC HOSTLD HOSTAR HOSTCFLAGS SHELLCHECK
 include $(srctree)/tools/build/Makefile.include
 clean:: $(LIBAPI)-clean $(LIBBPF)-clean $(LIBSUBCMD)-clean $(LIBSYMBOL)-clean $(LIBPERF)-clean arm64-sysreg-defs-clean fixdep-clean python-clean bpf-skel-clean tests-coresight-targets-clean
 	$(call QUIET_CLEAN, core-objs)  $(RM) $(LIBPERF_A) $(OUTPUT)perf-archive $(OUTPUT)perf-iostat $(LANG_BINDINGS)
-	$(Q)find $(or $(OUTPUT),.) -name '*.o' -delete -o -name '\.*.cmd' -delete -o -name '\.*.d' -delete
+	$(Q)find $(or $(OUTPUT),.) -name '*.o' -delete -o -name '\.*.cmd' -delete -o -name '\.*.d' -delete -o -name '*.shellcheck_log' -delete
 	$(Q)$(RM) $(OUTPUT).config-detected
 	$(call QUIET_CLEAN, core-progs) $(RM) $(ALL_PROGRAMS) perf perf-read-vdso32 perf-read-vdsox32 $(OUTPUT)$(LIBJVMTI).so
 	$(call QUIET_CLEAN, core-gen)   $(RM)  *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope* $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)FEATURE-DUMP $(OUTPUT)util/*-bison* $(OUTPUT)util/*-flex* \

tools/perf/arch/arm/util/cs-etm.c+8−8

@@ -199,7 +199,7 @@ static int cs_etm_validate_config(struct auxtrace_record *itr, · 198 unmodified lines
199	{	199	{
200	int i, err = -EINVAL;	200	int i, err = -EINVAL;
201	struct perf_cpu_map *event_cpus = evsel->evlist->core.user_requested_cpus;	201	struct perf_cpu_map *event_cpus = evsel->evlist->core.user_requested_cpus;
202	struct perf_cpu_map *online_cpus = perf_cpu_map__new(NULL);	202	struct perf_cpu_map *online_cpus = perf_cpu_map__new_online_cpus();
203		203
204	/* Set option of each CPU we have */	204	/* Set option of each CPU we have */
205	for (i = 0; i < cpu__max_cpu().cpu; i++) {	205	for (i = 0; i < cpu__max_cpu().cpu; i++) {
@@ -211,7 +211,7 @@ static int cs_etm_validate_config(struct auxtrace_record *itr, · 5 unmodified lines
211	* program can run on any CPUs in this case, thus don't skip	211	* program can run on any CPUs in this case, thus don't skip
212	* validation.	212	* validation.
213	*/	213	*/
214	if (!perf_cpu_map__empty(event_cpus) &&	214	if (!perf_cpu_map__has_any_cpu_or_is_empty(event_cpus) &&
215	!perf_cpu_map__has(event_cpus, cpu))	215	!perf_cpu_map__has(event_cpus, cpu))
216	continue;	216	continue;
217		217
@@ -435,7 +435,7 @@ static int cs_etm_recording_options(struct auxtrace_record *itr, · 217 unmodified lines
435	* Also the case of per-cpu mmaps, need the contextID in order to be notified	435	* Also the case of per-cpu mmaps, need the contextID in order to be notified
436	* when a context switch happened.	436	* when a context switch happened.
437	*/	437	*/
438	if (!perf_cpu_map__empty(cpus)) {	438	if (!perf_cpu_map__has_any_cpu_or_is_empty(cpus)) {
439	evsel__set_config_if_unset(cs_etm_pmu, cs_etm_evsel,	439	evsel__set_config_if_unset(cs_etm_pmu, cs_etm_evsel,
440	"timestamp", 1);	440	"timestamp", 1);
441	evsel__set_config_if_unset(cs_etm_pmu, cs_etm_evsel,	441	evsel__set_config_if_unset(cs_etm_pmu, cs_etm_evsel,
@@ -461,7 +461,7 @@ static int cs_etm_recording_options(struct auxtrace_record *itr, · 19 unmodified lines
461	evsel->core.attr.sample_period = 1;	461	evsel->core.attr.sample_period = 1;
462		462
463	/* In per-cpu case, always need the time of mmap events etc */	463	/* In per-cpu case, always need the time of mmap events etc */
464	if (!perf_cpu_map__empty(cpus))	464	if (!perf_cpu_map__has_any_cpu_or_is_empty(cpus))
465	evsel__set_sample_bit(evsel, TIME);	465	evsel__set_sample_bit(evsel, TIME);
466		466
467	err = cs_etm_validate_config(itr, cs_etm_evsel);	467	err = cs_etm_validate_config(itr, cs_etm_evsel);
@@ -536,10 +536,10 @@ cs_etm_info_priv_size(struct auxtrace_record *itr __maybe_unused, · 68 unmodified lines
536	int i;	536	int i;
537	int etmv3 = 0, etmv4 = 0, ete = 0;	537	int etmv3 = 0, etmv4 = 0, ete = 0;
538	struct perf_cpu_map *event_cpus = evlist->core.user_requested_cpus;	538	struct perf_cpu_map *event_cpus = evlist->core.user_requested_cpus;
539	struct perf_cpu_map *online_cpus = perf_cpu_map__new(NULL);	539	struct perf_cpu_map *online_cpus = perf_cpu_map__new_online_cpus();
540		540
541	/* cpu map is not empty, we have specific CPUs to work with */	541	/* cpu map is not empty, we have specific CPUs to work with */
542	if (!perf_cpu_map__empty(event_cpus)) {	542	if (!perf_cpu_map__has_any_cpu_or_is_empty(event_cpus)) {
543	for (i = 0; i < cpu__max_cpu().cpu; i++) {	543	for (i = 0; i < cpu__max_cpu().cpu; i++) {
544	struct perf_cpu cpu = { .cpu = i, };	544	struct perf_cpu cpu = { .cpu = i, };
545		545
@@ -802,7 +802,7 @@ static int cs_etm_info_fill(struct auxtrace_record *itr, · 256 unmodified lines
802	u64 nr_cpu, type;	802	u64 nr_cpu, type;
803	struct perf_cpu_map *cpu_map;	803	struct perf_cpu_map *cpu_map;
804	struct perf_cpu_map *event_cpus = session->evlist->core.user_requested_cpus;	804	struct perf_cpu_map *event_cpus = session->evlist->core.user_requested_cpus;
805	struct perf_cpu_map *online_cpus = perf_cpu_map__new(NULL);	805	struct perf_cpu_map *online_cpus = perf_cpu_map__new_online_cpus();
806	struct cs_etm_recording *ptr =	806	struct cs_etm_recording *ptr =
807	container_of(itr, struct cs_etm_recording, itr);	807	container_of(itr, struct cs_etm_recording, itr);
808	struct perf_pmu *cs_etm_pmu = ptr->cs_etm_pmu;	808	struct perf_pmu *cs_etm_pmu = ptr->cs_etm_pmu;
@@ -814,7 +814,7 @@ static int cs_etm_info_fill(struct auxtrace_record *itr, · 5 unmodified lines
814	return -EINVAL;	814	return -EINVAL;
815		815
816	/* If the cpu_map is empty all online CPUs are involved */	816	/* If the cpu_map is empty all online CPUs are involved */
817	if (perf_cpu_map__empty(event_cpus)) {	817	if (perf_cpu_map__has_any_cpu_or_is_empty(event_cpus)) {
818	cpu_map = online_cpus;	818	cpu_map = online_cpus;
819	} else {	819	} else {
820	/* Make sure all specified CPUs are online */	820	/* Make sure all specified CPUs are online */

tools/perf/arch/arm64/util/arm-spe.c+2−2

@@ -232,7 +232,7 @@ static int arm_spe_recording_options(struct auxtrace_record *itr, · 231 unmodified lines
232	* In the case of per-cpu mmaps, sample CPU for AUX event;	232	* In the case of per-cpu mmaps, sample CPU for AUX event;
233	* also enable the timestamp tracing for samples correlation.	233	* also enable the timestamp tracing for samples correlation.
234	*/	234	*/
235	if (!perf_cpu_map__empty(cpus)) {	235	if (!perf_cpu_map__has_any_cpu_or_is_empty(cpus)) {
236	evsel__set_sample_bit(arm_spe_evsel, CPU);	236	evsel__set_sample_bit(arm_spe_evsel, CPU);
237	evsel__set_config_if_unset(arm_spe_pmu, arm_spe_evsel,	237	evsel__set_config_if_unset(arm_spe_pmu, arm_spe_evsel,
238	"ts_enable", 1);	238	"ts_enable", 1);
@@ -265,7 +265,7 @@ static int arm_spe_recording_options(struct auxtrace_record *itr, · 26 unmodified lines
265	tracking_evsel->core.attr.sample_period = 1;	265	tracking_evsel->core.attr.sample_period = 1;
266		266
267	/* In per-cpu case, always need the time of mmap events etc */	267	/* In per-cpu case, always need the time of mmap events etc */
268	if (!perf_cpu_map__empty(cpus)) {	268	if (!perf_cpu_map__has_any_cpu_or_is_empty(cpus)) {
269	evsel__set_sample_bit(tracking_evsel, TIME);	269	evsel__set_sample_bit(tracking_evsel, TIME);
270	evsel__set_sample_bit(tracking_evsel, CPU);	270	evsel__set_sample_bit(tracking_evsel, CPU);
271		271

tools/perf/arch/arm64/util/header.c+1−1

@@ -57,7 +57,7 @@ static int _get_cpuid(char buf, size_t sz, struct perf_cpu_map cpus) · 56 unmodified lines
57		57
58	int get_cpuid(char *buf, size_t sz)	58	int get_cpuid(char *buf, size_t sz)
59	{	59	{
60	struct perf_cpu_map *cpus = perf_cpu_map__new(NULL);	60	struct perf_cpu_map *cpus = perf_cpu_map__new_online_cpus();
61	int ret;	61	int ret;
62		62
63	if (!cpus)	63	if (!cpus)

tools/perf/arch/loongarch/annotate/instructions.c+3−3

@@ -61,10 +61,10 @@ static int loongarch_jump__parse(struct arch arch, struct ins_operands ops, st · 60 unmodified lines
61	const char *c = strchr(ops->raw, '#');	61	const char *c = strchr(ops->raw, '#');
62	u64 start, end;	62	u64 start, end;
63		63
64	ops->raw_comment = strchr(ops->raw, arch->objdump.comment_char);	64	ops->jump.raw_comment = strchr(ops->raw, arch->objdump.comment_char);
65	ops->raw_func_start = strchr(ops->raw, '<');	65	ops->jump.raw_func_start = strchr(ops->raw, '<');
66		66
67	if (ops->raw_func_start && c > ops->raw_func_start)	67	if (ops->jump.raw_func_start && c > ops->jump.raw_func_start)
68	c = NULL;	68	c = NULL;
69		69
70	if (c++ != NULL)	70	if (c++ != NULL)

tools/perf/arch/x86/tests/hybrid.c+30−7

 	evsel = evsel__next(evsel);
 	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 	TEST_ASSERT_VAL("wrong hybrid type", test_hybrid_type(evsel, PERF_TYPE_RAW));
-	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
+	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_INSTRUCTIONS));
 	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 	return TEST_OK;
 }
 	evsel = evsel__next(evsel);
 	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 	TEST_ASSERT_VAL("wrong hybrid type", test_hybrid_type(evsel, PERF_TYPE_RAW));
-	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
+	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_INSTRUCTIONS));
 	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 	return TEST_OK;
 }
+static int test__hybrid_hw_group_event_2(struct evlist *evlist)
+{
+	struct evsel *evsel, *leader;
+	evsel = leader = evlist__first(evlist);
+	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
+	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
+	TEST_ASSERT_VAL("wrong hybrid type", test_hybrid_type(evsel, PERF_TYPE_RAW));
+	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
+	evsel = evsel__next(evsel);
+	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
+	TEST_ASSERT_VAL("wrong config", evsel->core.attr.config == 0x3c);
+	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
+	return TEST_OK;
+}
 struct evlist_test {
 	const char *name;
 	bool (*valid)(void);
 static const struct evlist_test test__hybrid_events[] = {
 	{
-		.name  = "cpu_core/cpu-cycles/",
+		.name  = "cpu_core/cycles/",
 		.check = test__hybrid_hw_event_with_pmu,
 		/* 0 */
 	},
 	{
-		.name  = "{cpu_core/cpu-cycles/,cpu_core/instructions/}",
+		.name  = "{cpu_core/cycles/,cpu_core/branches/}",
 		.check = test__hybrid_hw_group_event,
 		/* 1 */
 	},
 	{
-		.name  = "{cpu-clock,cpu_core/cpu-cycles/}",
+		.name  = "{cpu-clock,cpu_core/cycles/}",
 		.check = test__hybrid_sw_hw_group_event,
 		/* 2 */
 	},
 	{
-		.name  = "{cpu_core/cpu-cycles/,cpu-clock}",
+		.name  = "{cpu_core/cycles/,cpu-clock}",
 		.check = test__hybrid_hw_sw_group_event,
 		/* 3 */
 	},
 	{
-		.name  = "{cpu_core/cpu-cycles/k,cpu_core/instructions/u}",
+		.name  = "{cpu_core/cycles/k,cpu_core/branches/u}",
 		.check = test__hybrid_group_modifier1,
 		/* 4 */
 	},
 		.check = test__hybrid_cache_event,
 		/* 8 */
 	},
+	{
+		.name  = "{cpu_core/cycles/,cpu_core/cpu-cycles/}",
+		.check = test__hybrid_hw_group_event_2,
+		/* 9 */
+	},
 };
 static int test_event(const struct evlist_test *e)

tools/perf/arch/x86/util/dwarf-regs.c+38−0

@@ -113,3 +113,41 @@ int regs_query_register_offset(const char *name) · 112 unmodified lines
113	return roff->offset;	113	return roff->offset;
114	return -EINVAL;	114	return -EINVAL;
115	}	115	}
		116
		117	struct dwarf_regs_idx {
		118	const char *name;
		119	int idx;
		120	};
		121
		122	static const struct dwarf_regs_idx x86_regidx_table[] = {
		123	{ "rax", 0 }, { "eax", 0 }, { "ax", 0 }, { "al", 0 },
		124	{ "rdx", 1 }, { "edx", 1 }, { "dx", 1 }, { "dl", 1 },
		125	{ "rcx", 2 }, { "ecx", 2 }, { "cx", 2 }, { "cl", 2 },
		126	{ "rbx", 3 }, { "edx", 3 }, { "bx", 3 }, { "bl", 3 },
		127	{ "rsi", 4 }, { "esi", 4 }, { "si", 4 }, { "sil", 4 },
		128	{ "rdi", 5 }, { "edi", 5 }, { "di", 5 }, { "dil", 5 },
		129	{ "rbp", 6 }, { "ebp", 6 }, { "bp", 6 }, { "bpl", 6 },
		130	{ "rsp", 7 }, { "esp", 7 }, { "sp", 7 }, { "spl", 7 },
		131	{ "r8", 8 }, { "r8d", 8 }, { "r8w", 8 }, { "r8b", 8 },
		132	{ "r9", 9 }, { "r9d", 9 }, { "r9w", 9 }, { "r9b", 9 },
		133	{ "r10", 10 }, { "r10d", 10 }, { "r10w", 10 }, { "r10b", 10 },
		134	{ "r11", 11 }, { "r11d", 11 }, { "r11w", 11 }, { "r11b", 11 },
		135	{ "r12", 12 }, { "r12d", 12 }, { "r12w", 12 }, { "r12b", 12 },
		136	{ "r13", 13 }, { "r13d", 13 }, { "r13w", 13 }, { "r13b", 13 },
		137	{ "r14", 14 }, { "r14d", 14 }, { "r14w", 14 }, { "r14b", 14 },
		138	{ "r15", 15 }, { "r15d", 15 }, { "r15w", 15 }, { "r15b", 15 },
		139	{ "rip", DWARF_REG_PC },
		140	};
		141
		142	int get_arch_regnum(const char *name)
		143	{
		144	unsigned int i;
		145
		146	if (*name != '%')
		147	return -EINVAL;
		148
		149	for (i = 0; i < ARRAY_SIZE(x86_regidx_table); i++)
		150	if (!strcmp(x86_regidx_table[i].name, name + 1))
		151	return x86_regidx_table[i].idx;
		152	return -ENOENT;
		153	}

tools/perf/arch/x86/util/event.c+58−45

 #if defined(__x86_64__)
-int perf_event__synthesize_extra_kmaps(struct perf_tool *tool,
+struct perf_event__synthesize_extra_kmaps_cb_args {
-				       perf_event__handler_t process,
+	struct perf_tool *tool;
-				       struct machine *machine)
+	perf_event__handler_t process;
+	struct machine *machine;
+	union perf_event *event;
+};
+static int perf_event__synthesize_extra_kmaps_cb(struct map *map, void *data)
 {
-	int rc = 0;
+	struct perf_event__synthesize_extra_kmaps_cb_args *args = data;
-	struct map_rb_node *pos;
+	union perf_event *event = args->event;
-	struct maps *kmaps = machine__kernel_maps(machine);
+	struct kmap *kmap;
-	union perf_event *event = zalloc(sizeof(event->mmap) +
+	size_t size;
-					 machine->id_hdr_size);
-	if (!event) {
+	if (!__map__is_extra_kernel_map(map))
-		pr_debug("Not enough memory synthesizing mmap event "
+		return 0;
-			 "for extra kernel maps\n");
-		return -1;
-	}
-	maps__for_each_entry(kmaps, pos) {
+	kmap = map__kmap(map);
-		struct kmap *kmap;
-		size_t size;
-		struct map *map = pos->map;
-		if (!__map__is_extra_kernel_map(map))
+	size = sizeof(event->mmap) - sizeof(event->mmap.filename) +
-			continue;
+		      PERF_ALIGN(strlen(kmap->name) + 1, sizeof(u64)) +
+		      args->machine->id_hdr_size;
-		kmap = map__kmap(map);
+	memset(event, 0, size);
-		size = sizeof(event->mmap) - sizeof(event->mmap.filename) +
+	event->mmap.header.type = PERF_RECORD_MMAP;
-		       PERF_ALIGN(strlen(kmap->name) + 1, sizeof(u64)) +
-		       machine->id_hdr_size;
-		memset(event, 0, size);
+	/*
+	 * kernel uses 0 for user space maps, see kernel/perf_event.c
+	 * __perf_event_mmap
+	 */
+	if (machine__is_host(args->machine))
+		event->header.misc = PERF_RECORD_MISC_KERNEL;
+	else
+		event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
-		event->mmap.header.type = PERF_RECORD_MMAP;
+	event->mmap.header.size = size;
-		/*
+	event->mmap.start = map__start(map);
-		 * kernel uses 0 for user space maps, see kernel/perf_event.c
+	event->mmap.len   = map__size(map);
-		 * __perf_event_mmap
+	event->mmap.pgoff = map__pgoff(map);
-		 */
+	event->mmap.pid   = args->machine->pid;
-		if (machine__is_host(machine))
-			event->header.misc = PERF_RECORD_MISC_KERNEL;
-		else
-			event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
-		event->mmap.header.size = size;
+	strlcpy(event->mmap.filename, kmap->name, PATH_MAX);
-		event->mmap.start = map__start(map);
+	if (perf_tool__process_synth_event(args->tool, event, args->machine, args->process) != 0)
-		event->mmap.len   = map__size(map);
+		return -1;
-		event->mmap.pgoff = map__pgoff(map);
-		event->mmap.pid   = machine->pid;
-		strlcpy(event->mmap.filename, kmap->name, PATH_MAX);
+	return 0;
+}
-		if (perf_tool__process_synth_event(tool, event, machine,
+int perf_event__synthesize_extra_kmaps(struct perf_tool *tool,
-						   process) != 0) {
+				       perf_event__handler_t process,
-			rc = -1;
+				       struct machine *machine)
-			break;
+{
-		}
+	int rc;
+	struct maps *kmaps = machine__kernel_maps(machine);
+	struct perf_event__synthesize_extra_kmaps_cb_args args = {
+		.tool = tool,
+		.process = process,
+		.machine = machine,
+		.event = zalloc(sizeof(args.event->mmap) + machine->id_hdr_size),
+	};
+	if (!args.event) {
+		pr_debug("Not enough memory synthesizing mmap event "
+			 "for extra kernel maps\n");
+		return -1;
 	}
-	free(event);
+	rc = maps__for_each_map(kmaps, perf_event__synthesize_extra_kmaps_cb, &args);
+	free(args.event);
 	return rc;
 }

tools/perf/arch/x86/util/intel-bts.c+2−2

@@ -143,7 +143,7 @@ static int intel_bts_recording_options(struct auxtrace_record *itr, · 142 unmodified lines
143	if (!opts->full_auxtrace)	143	if (!opts->full_auxtrace)
144	return 0;	144	return 0;
145		145
146	if (opts->full_auxtrace && !perf_cpu_map__empty(cpus)) {	146	if (opts->full_auxtrace && !perf_cpu_map__has_any_cpu_or_is_empty(cpus)) {
147	pr_err(INTEL_BTS_PMU_NAME " does not support per-cpu recording\n");	147	pr_err(INTEL_BTS_PMU_NAME " does not support per-cpu recording\n");
148	return -EINVAL;	148	return -EINVAL;
149	}	149	}
@@ -224,7 +224,7 @@ static int intel_bts_recording_options(struct auxtrace_record *itr, · 74 unmodified lines
224	* In the case of per-cpu mmaps, we need the CPU on the	224	* In the case of per-cpu mmaps, we need the CPU on the
225	* AUX event.	225	* AUX event.
226	*/	226	*/
227	if (!perf_cpu_map__empty(cpus))	227	if (!perf_cpu_map__has_any_cpu_or_is_empty(cpus))
228	evsel__set_sample_bit(intel_bts_evsel, CPU);	228	evsel__set_sample_bit(intel_bts_evsel, CPU);
229	}	229	}
230		230

tools/perf/arch/x86/util/intel-pt.c+5−5

tools/perf/bench/epoll-ctl.c+1−1

@@ -330,7 +330,7 @@ int bench_epoll_ctl(int argc, const char **argv) · 329 unmodified lines
330	act.sa_sigaction = toggle_done;	330	act.sa_sigaction = toggle_done;
331	sigaction(SIGINT, &act, NULL);	331	sigaction(SIGINT, &act, NULL);
332		332
333	cpu = perf_cpu_map__new(NULL);	333	cpu = perf_cpu_map__new_online_cpus();
334	if (!cpu)	334	if (!cpu)
335	goto errmem;	335	goto errmem;
336		336

tools/perf/bench/epoll-wait.c+1−1

@@ -444,7 +444,7 @@ int bench_epoll_wait(int argc, const char **argv) · 443 unmodified lines
444	act.sa_sigaction = toggle_done;	444	act.sa_sigaction = toggle_done;
445	sigaction(SIGINT, &act, NULL);	445	sigaction(SIGINT, &act, NULL);
446		446
447	cpu = perf_cpu_map__new(NULL);	447	cpu = perf_cpu_map__new_online_cpus();
448	if (!cpu)	448	if (!cpu)
449	goto errmem;	449	goto errmem;
450		450

tools/perf/bench/futex-hash.c+1−1

@@ -138,7 +138,7 @@ int bench_futex_hash(int argc, const char **argv) · 137 unmodified lines
138	exit(EXIT_FAILURE);	138	exit(EXIT_FAILURE);
139	}	139	}
140		140
141	cpu = perf_cpu_map__new(NULL);	141	cpu = perf_cpu_map__new_online_cpus();
142	if (!cpu)	142	if (!cpu)
143	goto errmem;	143	goto errmem;
144		144

tools/perf/bench/futex-lock-pi.c+1−1

@@ -172,7 +172,7 @@ int bench_futex_lock_pi(int argc, const char **argv) · 171 unmodified lines
172	if (argc)	172	if (argc)
173	goto err;	173	goto err;
174		174
175	cpu = perf_cpu_map__new(NULL);	175	cpu = perf_cpu_map__new_online_cpus();
176	if (!cpu)	176	if (!cpu)
177	err(EXIT_FAILURE, "calloc");	177	err(EXIT_FAILURE, "calloc");
178		178

tools/perf/bench/futex-requeue.c+1−1

@@ -174,7 +174,7 @@ int bench_futex_requeue(int argc, const char **argv) · 173 unmodified lines
174	if (argc)	174	if (argc)
175	goto err;	175	goto err;
176		176
177	cpu = perf_cpu_map__new(NULL);	177	cpu = perf_cpu_map__new_online_cpus();
178	if (!cpu)	178	if (!cpu)
179	err(EXIT_FAILURE, "cpu_map__new");	179	err(EXIT_FAILURE, "cpu_map__new");
180		180

tools/perf/bench/futex-wake-parallel.c+1−1

@@ -264,7 +264,7 @@ int bench_futex_wake_parallel(int argc, const char **argv) · 263 unmodified lines
264	err(EXIT_FAILURE, "mlockall");	264	err(EXIT_FAILURE, "mlockall");
265	}	265	}
266		266
267	cpu = perf_cpu_map__new(NULL);	267	cpu = perf_cpu_map__new_online_cpus();
268	if (!cpu)	268	if (!cpu)
269	err(EXIT_FAILURE, "calloc");	269	err(EXIT_FAILURE, "calloc");
270		270

tools/perf/bench/futex-wake.c+1−1

@@ -149,7 +149,7 @@ int bench_futex_wake(int argc, const char **argv) · 148 unmodified lines
149	exit(EXIT_FAILURE);	149	exit(EXIT_FAILURE);
150	}	150	}
151		151
152	cpu = perf_cpu_map__new(NULL);	152	cpu = perf_cpu_map__new_online_cpus();
153	if (!cpu)	153	if (!cpu)
154	err(EXIT_FAILURE, "calloc");	154	err(EXIT_FAILURE, "calloc");
155		155

tools/perf/bench/sched-seccomp-notify.c+1−1

@@ -32,7 +32,7 @@ static bool sync_mode; · 31 unmodified lines
32	static const struct option options[] = {	32	static const struct option options[] = {
33	OPT_U64('l', "loop", &loops, "Specify number of loops"),	33	OPT_U64('l', "loop", &loops, "Specify number of loops"),
34	OPT_BOOLEAN('s', "sync-mode", &sync_mode,	34	OPT_BOOLEAN('s', "sync-mode", &sync_mode,
35	"Enable the synchronious mode for seccomp notifications"),	35	"Enable the synchronous mode for seccomp notifications"),
36	OPT_END()	36	OPT_END()
37	};	37	};
38		38

tools/perf/builtin-annotate.c+272−28

@@ -20,6 +20,7 @@ · 19 unmodified lines
20	#include "util/evlist.h"	20	#include "util/evlist.h"
21	#include "util/evsel.h"	21	#include "util/evsel.h"
22	#include "util/annotate.h"	22	#include "util/annotate.h"
		23	#include "util/annotate-data.h"
23	#include "util/event.h"	24	#include "util/event.h"
24	#include <subcmd/parse-options.h>	25	#include <subcmd/parse-options.h>
25	#include "util/parse-events.h"	26	#include "util/parse-events.h"
@@ -45,7 +46,6 @@ · 19 unmodified lines
45	struct perf_annotate {	46	struct perf_annotate {
46	struct perf_tool tool;	47	struct perf_tool tool;
47	struct perf_session *session;	48	struct perf_session *session;
48	struct annotation_options opts;
49	#ifdef HAVE_SLANG_SUPPORT	49	#ifdef HAVE_SLANG_SUPPORT
50	bool use_tui;	50	bool use_tui;
51	#endif	51	#endif
@@ -56,9 +56,13 @@ struct perf_annotate { · 4 unmodified lines
56	bool skip_missing;	56	bool skip_missing;
57	bool has_br_stack;	57	bool has_br_stack;
58	bool group_set;	58	bool group_set;
		59	bool data_type;
		60	bool type_stat;
		61	bool insn_stat;
59	float min_percent;	62	float min_percent;
60	const char *sym_hist_filter;	63	const char *sym_hist_filter;
61	const char *cpu_list;	64	const char *cpu_list;
		65	const char *target_data_type;
62	DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);	66	DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
63	};	67	};
64		68
@@ -94,6 +98,7 @@ static void process_basic_block(struct addr_map_symbol *start, · 29 unmodified lines
94	struct annotation *notes = sym ? symbol__annotation(sym) : NULL;	98	struct annotation *notes = sym ? symbol__annotation(sym) : NULL;
95	struct block_range_iter iter;	99	struct block_range_iter iter;
96	struct block_range *entry;	100	struct block_range *entry;
		101	struct annotated_branch *branch;
97		102
98	/*	103	/*
99	* Sanity; NULL isn't executable and the CPU cannot execute backwards	104	* Sanity; NULL isn't executable and the CPU cannot execute backwards
@@ -105,6 +110,8 @@ static void process_basic_block(struct addr_map_symbol *start, · 5 unmodified lines
105	if (!block_range_iter__valid(&iter))	110	if (!block_range_iter__valid(&iter))
106	return;	111	return;
107		112
		113	branch = annotation__get_branch(notes);
		114
108	/*	115	/*
109	* First block in range is a branch target.	116	* First block in range is a branch target.
110	*/	117	*/
@@ -118,8 +125,8 @@ static void process_basic_block(struct addr_map_symbol *start, · 7 unmodified lines
118	entry->coverage++;	125	entry->coverage++;
119	entry->sym = sym;	126	entry->sym = sym;
120		127
121	if (notes)	128	if (branch)
122	notes->max_coverage = max(notes->max_coverage, entry->coverage);	129	branch->max_coverage = max(branch->max_coverage, entry->coverage);
123		130
124	} while (block_range_iter__next(&iter));	131	} while (block_range_iter__next(&iter));
125		132
@@ -315,9 +322,153 @@ static int hist_entry__tty_annotate(struct hist_entry *he, · 189 unmodified lines
315	struct perf_annotate *ann)	322	struct perf_annotate *ann)
316	{	323	{
317	if (!ann->use_stdio2)	324	if (!ann->use_stdio2)
318	return symbol__tty_annotate(&he->ms, evsel, &ann->opts);	325	return symbol__tty_annotate(&he->ms, evsel);
		326
		327	return symbol__tty_annotate2(&he->ms, evsel);
		328	}
		329
		330	static void print_annotated_data_header(struct hist_entry he, struct evsel evsel)
		331	{
		332	struct dso *dso = map__dso(he->ms.map);
		333	int nr_members = 1;
		334	int nr_samples = he->stat.nr_events;
		335
		336	if (evsel__is_group_event(evsel)) {
		337	struct hist_entry *pair;
		338
		339	list_for_each_entry(pair, &he->pairs.head, pairs.node)
		340	nr_samples += pair->stat.nr_events;
		341	}
		342
		343	printf("Annotate type: '%s' in %s (%d samples):\n",
		344	he->mem_type->self.type_name, dso->name, nr_samples);
		345
		346	if (evsel__is_group_event(evsel)) {
		347	struct evsel *pos;
		348	int i = 0;
		349
		350	for_each_group_evsel(pos, evsel)
		351	printf(" event[%d] = %s\n", i++, pos->name);
		352
		353	nr_members = evsel->core.nr_members;
		354	}
		355
		356	printf("============================================================================\n");
		357	printf("%s %10s %10s %s\n", 11 nr_members, "samples", "offset", "size", "field");
		358	}
		359
		360	static void print_annotated_data_type(struct annotated_data_type *mem_type,
		361	struct annotated_member *member,
		362	struct evsel *evsel, int indent)
		363	{
		364	struct annotated_member *child;
		365	struct type_hist *h = mem_type->histograms[evsel->core.idx];
		366	int i, nr_events = 1, samples = 0;
		367
		368	for (i = 0; i < member->size; i++)
		369	samples += h->addr[member->offset + i].nr_samples;
		370	printf(" %10d", samples);
319		371
320	return symbol__tty_annotate2(&he->ms, evsel, &ann->opts);	372	if (evsel__is_group_event(evsel)) {
		373	struct evsel *pos;
		374
		375	for_each_group_member(pos, evsel) {
		376	h = mem_type->histograms[pos->core.idx];
		377
		378	samples = 0;
		379	for (i = 0; i < member->size; i++)
		380	samples += h->addr[member->offset + i].nr_samples;
		381	printf(" %10d", samples);
		382	}
		383	nr_events = evsel->core.nr_members;
		384	}
		385
		386	printf(" %10d %10d %*s%s\t%s",
		387	member->offset, member->size, indent, "", member->type_name,
		388	member->var_name ?: "");
		389
		390	if (!list_empty(&member->children))
		391	printf(" {\n");
		392
		393	list_for_each_entry(child, &member->children, node)
		394	print_annotated_data_type(mem_type, child, evsel, indent + 4);
		395
		396	if (!list_empty(&member->children))
		397	printf("%s}", 11 nr_events + 24 + indent, "");
		398	printf(";\n");
		399	}
		400
		401	static void print_annotate_data_stat(struct annotated_data_stat *s)
		402	{
		403	#define PRINT_STAT(fld) if (s->fld) printf("%10d : %s\n", s->fld, #fld)
		404
		405	int bad = s->no_sym +
		406	s->no_insn +
		407	s->no_insn_ops +
		408	s->no_mem_ops +
		409	s->no_reg +
		410	s->no_dbginfo +
		411	s->no_cuinfo +
		412	s->no_var +
		413	s->no_typeinfo +
		414	s->invalid_size +
		415	s->bad_offset;
		416	int ok = s->total - bad;
		417
		418	printf("Annotate data type stats:\n");
		419	printf("total %d, ok %d (%.1f%%), bad %d (%.1f%%)\n",
		420	s->total, ok, 100.0 * ok / (s->total ?: 1), bad, 100.0 * bad / (s->total ?: 1));
		421	printf("-----------------------------------------------------------\n");
		422	PRINT_STAT(no_sym);
		423	PRINT_STAT(no_insn);
		424	PRINT_STAT(no_insn_ops);
		425	PRINT_STAT(no_mem_ops);
		426	PRINT_STAT(no_reg);
		427	PRINT_STAT(no_dbginfo);
		428	PRINT_STAT(no_cuinfo);
		429	PRINT_STAT(no_var);
		430	PRINT_STAT(no_typeinfo);
		431	PRINT_STAT(invalid_size);
		432	PRINT_STAT(bad_offset);
		433	printf("\n");
		434
		435	#undef PRINT_STAT
		436	}
		437
		438	static void print_annotate_item_stat(struct list_head head, const char title)
		439	{
		440	struct annotated_item_stat istat, pos, *iter;
		441	int total_good, total_bad, total;
		442	int sum1, sum2;
		443	LIST_HEAD(tmp);
		444
		445	/* sort the list by count */
		446	list_splice_init(head, &tmp);
		447	total_good = total_bad = 0;
		448
		449	list_for_each_entry_safe(istat, pos, &tmp, list) {
		450	total_good += istat->good;
		451	total_bad += istat->bad;
		452	sum1 = istat->good + istat->bad;
		453
		454	list_for_each_entry(iter, head, list) {
		455	sum2 = iter->good + iter->bad;
		456	if (sum1 > sum2)
		457	break;
		458	}
		459	list_move_tail(&istat->list, &iter->list);
		460	}
		461	total = total_good + total_bad;
		462
		463	printf("Annotate %s stats\n", title);
		464	printf("total %d, ok %d (%.1f%%), bad %d (%.1f%%)\n\n", total,
		465	total_good, 100.0 * total_good / (total ?: 1),
		466	total_bad, 100.0 * total_bad / (total ?: 1));
		467	printf(" %-10s: %5s %5s\n", "Name", "Good", "Bad");
		468	printf("-----------------------------------------------------------\n");
		469	list_for_each_entry(istat, head, list)
		470	printf(" %-10s: %5d %5d\n", istat->name, istat->good, istat->bad);
		471	printf("\n");
321	}	472	}
322		473
323	static void hists__find_annotations(struct hists *hists,	474	static void hists__find_annotations(struct hists *hists,
@@ -327,6 +478,11 @@ static void hists__find_annotations(struct hists *hists, · 3 unmodified lines
327	struct rb_node nd = rb_first_cached(&hists->entries), next;	478	struct rb_node nd = rb_first_cached(&hists->entries), next;
328	int key = K_RIGHT;	479	int key = K_RIGHT;
329		480
		481	if (ann->type_stat)
		482	print_annotate_data_stat(&ann_data_stat);
		483	if (ann->insn_stat)
		484	print_annotate_item_stat(&ann_insn_stat, "Instruction");
		485
330	while (nd) {	486	while (nd) {
331	struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);	487	struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
332	struct annotation *notes;	488	struct annotation *notes;
@@ -359,11 +515,38 @@ find_next: · 26 unmodified lines
359	continue;	515	continue;
360	}	516	}
361		517
		518	if (ann->data_type) {
		519	/* skip unknown type */
		520	if (he->mem_type->histograms == NULL)
		521	goto find_next;
		522
		523	if (ann->target_data_type) {
		524	const char *type_name = he->mem_type->self.type_name;
		525
		526	/* skip 'struct ' prefix in the type name */
		527	if (strncmp(ann->target_data_type, "struct ", 7) &&
		528	!strncmp(type_name, "struct ", 7))
		529	type_name += 7;
		530
		531	/* skip 'union ' prefix in the type name */
		532	if (strncmp(ann->target_data_type, "union ", 6) &&
		533	!strncmp(type_name, "union ", 6))
		534	type_name += 6;
		535
		536	if (strcmp(ann->target_data_type, type_name))
		537	goto find_next;
		538	}
		539
		540	print_annotated_data_header(he, evsel);
		541	print_annotated_data_type(he->mem_type, &he->mem_type->self, evsel, 0);
		542	printf("\n");
		543	goto find_next;
		544	}
		545
362	if (use_browser == 2) {	546	if (use_browser == 2) {
363	int ret;	547	int ret;
364	int (annotate)(struct hist_entry he,	548	int (annotate)(struct hist_entry he,
365	struct evsel *evsel,	549	struct evsel *evsel,
366	struct annotation_options *options,
367	struct hist_browser_timer *hbt);	550	struct hist_browser_timer *hbt);
368		551
369	annotate = dlsym(perf_gtk_handle,	552	annotate = dlsym(perf_gtk_handle,
@@ -373,14 +556,14 @@ find_next: · 3 unmodified lines
373	return;	556	return;
374	}	557	}
375		558
376	ret = annotate(he, evsel, &ann->opts, NULL);	559	ret = annotate(he, evsel, NULL);
377	if (!ret \|\| !ann->skip_missing)	560	if (!ret \|\| !ann->skip_missing)
378	return;	561	return;
379		562
380	/* skip missing symbols */	563	/* skip missing symbols */
381	nd = rb_next(nd);	564	nd = rb_next(nd);
382	} else if (use_browser == 1) {	565	} else if (use_browser == 1) {
383	key = hist_entry__tui_annotate(he, evsel, NULL, &ann->opts);	566	key = hist_entry__tui_annotate(he, evsel, NULL);
384		567
385	switch (key) {	568	switch (key) {
386	case -1:	569	case -1:
@@ -422,9 +605,9 @@ static int __cmd_annotate(struct perf_annotate *ann) · 35 unmodified lines
422	goto out;	605	goto out;
423	}	606	}
424		607
425	if (!ann->opts.objdump_path) {	608	if (!annotate_opts.objdump_path) {
426	ret = perf_env__lookup_objdump(&session->header.env,	609	ret = perf_env__lookup_objdump(&session->header.env,
427	&ann->opts.objdump_path);	610	&annotate_opts.objdump_path);
428	if (ret)	611	if (ret)
429	goto out;	612	goto out;
430	}	613	}
@@ -457,8 +640,20 @@ static int __cmd_annotate(struct perf_annotate *ann) · 26 unmodified lines
457	evsel__reset_sample_bit(pos, CALLCHAIN);	640	evsel__reset_sample_bit(pos, CALLCHAIN);
458	evsel__output_resort(pos, NULL);	641	evsel__output_resort(pos, NULL);
459		642
460	if (symbol_conf.event_group && !evsel__is_group_leader(pos))	643	/*
		644	* An event group needs to display other events too.
		645	* Let's delay printing until other events are processed.
		646	*/
		647	if (symbol_conf.event_group) {
		648	if (!evsel__is_group_leader(pos)) {
		649	struct hists *leader_hists;
		650
		651	leader_hists = evsel__hists(evsel__leader(pos));
		652	hists__match(leader_hists, hists);
		653	hists__link(leader_hists, hists);
		654	}
461	continue;	655	continue;
		656	}
462		657
463	hists__find_annotations(hists, pos, ann);	658	hists__find_annotations(hists, pos, ann);
464	}	659	}
@@ -469,6 +664,20 @@ static int __cmd_annotate(struct perf_annotate *ann) · 4 unmodified lines
469	goto out;	664	goto out;
470	}	665	}
471		666
		667	/* Display group events together */
		668	evlist__for_each_entry(session->evlist, pos) {
		669	struct hists *hists = evsel__hists(pos);
		670	u32 nr_samples = hists->stats.nr_samples;
		671
		672	if (nr_samples == 0)
		673	continue;
		674
		675	if (!symbol_conf.event_group \|\| !evsel__is_group_leader(pos))
		676	continue;
		677
		678	hists__find_annotations(hists, pos, ann);
		679	}
		680
472	if (use_browser == 2) {	681	if (use_browser == 2) {
473	void (*show_annotations)(void);	682	void (*show_annotations)(void);
474		683
@@ -495,6 +704,17 @@ static int parse_percent_limit(const struct option opt, const char str, · 20 unmodified lines
495	return 0;	704	return 0;
496	}	705	}
497		706
		707	static int parse_data_type(const struct option opt, const char str, int unset)
		708	{
		709	struct perf_annotate *ann = opt->value;
		710
		711	ann->data_type = !unset;
		712	if (str)
		713	ann->target_data_type = strdup(str);
		714
		715	return 0;
		716	}
		717
498	static const char * const annotate_usage[] = {	718	static const char * const annotate_usage[] = {
499	"perf annotate [<options>]",	719	"perf annotate [<options>]",
500	NULL	720	NULL
@@ -558,9 +778,9 @@ int cmd_annotate(int argc, const char **argv) · 57 unmodified lines
558	"file", "vmlinux pathname"),	778	"file", "vmlinux pathname"),
559	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,	779	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
560	"load module symbols - WARNING: use only with -k and LIVE kernel"),	780	"load module symbols - WARNING: use only with -k and LIVE kernel"),
561	OPT_BOOLEAN('l', "print-line", &annotate.opts.print_lines,	781	OPT_BOOLEAN('l', "print-line", &annotate_opts.print_lines,
562	"print matching source lines (may be slow)"),	782	"print matching source lines (may be slow)"),
563	OPT_BOOLEAN('P', "full-paths", &annotate.opts.full_path,	783	OPT_BOOLEAN('P', "full-paths", &annotate_opts.full_path,
564	"Don't shorten the displayed pathnames"),	784	"Don't shorten the displayed pathnames"),
565	OPT_BOOLEAN(0, "skip-missing", &annotate.skip_missing,	785	OPT_BOOLEAN(0, "skip-missing", &annotate.skip_missing,
566	"Skip symbols that cannot be annotated"),	786	"Skip symbols that cannot be annotated"),
@@ -571,15 +791,15 @@ int cmd_annotate(int argc, const char **argv) · 4 unmodified lines
571	OPT_CALLBACK(0, "symfs", NULL, "directory",	791	OPT_CALLBACK(0, "symfs", NULL, "directory",
572	"Look for files with symbols relative to this directory",	792	"Look for files with symbols relative to this directory",
573	symbol__config_symfs),	793	symbol__config_symfs),
574	OPT_BOOLEAN(0, "source", &annotate.opts.annotate_src,	794	OPT_BOOLEAN(0, "source", &annotate_opts.annotate_src,
575	"Interleave source code with assembly code (default)"),	795	"Interleave source code with assembly code (default)"),
576	OPT_BOOLEAN(0, "asm-raw", &annotate.opts.show_asm_raw,	796	OPT_BOOLEAN(0, "asm-raw", &annotate_opts.show_asm_raw,
577	"Display raw encoding of assembly instructions (default)"),	797	"Display raw encoding of assembly instructions (default)"),
578	OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",	798	OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
579	"Specify disassembler style (e.g. -M intel for intel syntax)"),	799	"Specify disassembler style (e.g. -M intel for intel syntax)"),
580	OPT_STRING(0, "prefix", &annotate.opts.prefix, "prefix",	800	OPT_STRING(0, "prefix", &annotate_opts.prefix, "prefix",
581	"Add prefix to source file path names in programs (with --prefix-strip)"),	801	"Add prefix to source file path names in programs (with --prefix-strip)"),
582	OPT_STRING(0, "prefix-strip", &annotate.opts.prefix_strip, "N",	802	OPT_STRING(0, "prefix-strip", &annotate_opts.prefix_strip, "N",
583	"Strip first N entries of source file path name in programs (with --prefix)"),	803	"Strip first N entries of source file path name in programs (with --prefix)"),
584	OPT_STRING(0, "objdump", &objdump_path, "path",	804	OPT_STRING(0, "objdump", &objdump_path, "path",
585	"objdump binary to use for disassembly and annotations"),	805	"objdump binary to use for disassembly and annotations"),
@@ -598,7 +818,7 @@ int cmd_annotate(int argc, const char **argv) · 12 unmodified lines
598	OPT_CALLBACK_DEFAULT(0, "stdio-color", NULL, "mode",	818	OPT_CALLBACK_DEFAULT(0, "stdio-color", NULL, "mode",
599	"'always' (default), 'never' or 'auto' only applicable to --stdio mode",	819	"'always' (default), 'never' or 'auto' only applicable to --stdio mode",
600	stdio__config_color, "always"),	820	stdio__config_color, "always"),
601	OPT_CALLBACK(0, "percent-type", &annotate.opts, "local-period",	821	OPT_CALLBACK(0, "percent-type", &annotate_opts, "local-period",
602	"Set percent type local/global-period/hits",	822	"Set percent type local/global-period/hits",
603	annotate_parse_percent_type),	823	annotate_parse_percent_type),
604	OPT_CALLBACK(0, "percent-limit", &annotate, "percent",	824	OPT_CALLBACK(0, "percent-limit", &annotate, "percent",
@@ -606,7 +826,13 @@ int cmd_annotate(int argc, const char **argv) · 1 unmodified line
606	OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",	826	OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
607	"Instruction Tracing options\n" ITRACE_HELP,	827	"Instruction Tracing options\n" ITRACE_HELP,
608	itrace_parse_synth_opts),	828	itrace_parse_synth_opts),
609		829	OPT_CALLBACK_OPTARG(0, "data-type", &annotate, NULL, "name",
		830	"Show data type annotate for the memory accesses",
		831	parse_data_type),
		832	OPT_BOOLEAN(0, "type-stat", &annotate.type_stat,
		833	"Show stats for the data type annotation"),
		834	OPT_BOOLEAN(0, "insn-stat", &annotate.insn_stat,
		835	"Show instruction stats for the data type annotation"),
610	OPT_END()	836	OPT_END()
611	};	837	};
612	int ret;	838	int ret;
@@ -614,13 +840,13 @@ int cmd_annotate(int argc, const char **argv) · 1 unmodified line
614	set_option_flag(options, 0, "show-total-period", PARSE_OPT_EXCLUSIVE);	840	set_option_flag(options, 0, "show-total-period", PARSE_OPT_EXCLUSIVE);
615	set_option_flag(options, 0, "show-nr-samples", PARSE_OPT_EXCLUSIVE);	841	set_option_flag(options, 0, "show-nr-samples", PARSE_OPT_EXCLUSIVE);
616		842
617	annotation_options__init(&annotate.opts);	843	annotation_options__init();
618		844
619	ret = hists__init();	845	ret = hists__init();
620	if (ret < 0)	846	if (ret < 0)
621	return ret;	847	return ret;
622		848
623	annotation_config__init(&annotate.opts);	849	annotation_config__init();
624		850
625	argc = parse_options(argc, argv, options, annotate_usage, 0);	851	argc = parse_options(argc, argv, options, annotate_usage, 0);
626	if (argc) {	852	if (argc) {
@@ -635,13 +861,13 @@ int cmd_annotate(int argc, const char **argv) · 8 unmodified lines
635	}	861	}
636		862
637	if (disassembler_style) {	863	if (disassembler_style) {
638	annotate.opts.disassembler_style = strdup(disassembler_style);	864	annotate_opts.disassembler_style = strdup(disassembler_style);
639	if (!annotate.opts.disassembler_style)	865	if (!annotate_opts.disassembler_style)
640	return -ENOMEM;	866	return -ENOMEM;
641	}	867	}
642	if (objdump_path) {	868	if (objdump_path) {
643	annotate.opts.objdump_path = strdup(objdump_path);	869	annotate_opts.objdump_path = strdup(objdump_path);
644	if (!annotate.opts.objdump_path)	870	if (!annotate_opts.objdump_path)
645	return -ENOMEM;	871	return -ENOMEM;
646	}	872	}
647	if (addr2line_path) {	873	if (addr2line_path) {
@@ -650,7 +876,7 @@ int cmd_annotate(int argc, const char **argv) · 2 unmodified lines
650	return -ENOMEM;	876	return -ENOMEM;
651	}	877	}
652		878
653	if (annotate_check_args(&annotate.opts) < 0)	879	if (annotate_check_args() < 0)
654	return -EINVAL;	880	return -EINVAL;
655		881
656	#ifdef HAVE_GTK2_SUPPORT	882	#ifdef HAVE_GTK2_SUPPORT
@@ -660,6 +886,13 @@ int cmd_annotate(int argc, const char **argv) · 3 unmodified lines
660	}	886	}
661	#endif	887	#endif
662		888
		889	#ifndef HAVE_DWARF_GETLOCATIONS_SUPPORT
		890	if (annotate.data_type) {
		891	pr_err("Error: Data type profiling is disabled due to missing DWARF support\n");
		892	return -ENOTSUP;
		893	}
		894	#endif
		895
663	ret = symbol__validate_sym_arguments();	896	ret = symbol__validate_sym_arguments();
664	if (ret)	897	if (ret)
665	return ret;	898	return ret;
@@ -702,6 +935,14 @@ int cmd_annotate(int argc, const char **argv) · 36 unmodified lines
702	use_browser = 2;	935	use_browser = 2;
703	#endif	936	#endif
704		937
		938	/* FIXME: only support stdio for now */
		939	if (annotate.data_type) {
		940	use_browser = 0;
		941	annotate_opts.annotate_src = false;
		942	symbol_conf.annotate_data_member = true;
		943	symbol_conf.annotate_data_sample = true;
		944	}
		945
705	setup_browser(true);	946	setup_browser(true);
706		947
707	/*	948	/*
@@ -709,7 +950,10 @@ int cmd_annotate(int argc, const char **argv) · 1 unmodified line
709	* symbol, we do not care about the processes in annotate,	950	* symbol, we do not care about the processes in annotate,
710	* set sort order to avoid repeated output.	951	* set sort order to avoid repeated output.
711	*/	952	*/
712	sort_order = "dso,symbol";	953	if (annotate.data_type)
		954	sort_order = "dso,type";
		955	else
		956	sort_order = "dso,symbol";
713		957
714	/*	958	/*
715	* Set SORT_MODE__BRANCH so that annotate display IPC/Cycle	959	* Set SORT_MODE__BRANCH so that annotate display IPC/Cycle
@@ -731,7 +975,7 @@ out_delete: · 15 unmodified lines
731	#ifndef NDEBUG	975	#ifndef NDEBUG
732	perf_session__delete(annotate.session);	976	perf_session__delete(annotate.session);
733	#endif	977	#endif
734	annotation_options__exit(&annotate.opts);	978	annotation_options__exit();
735		979
736	return ret;	980	return ret;
737	}	981	}

tools/perf/builtin-c2c.c+1−1

@@ -2320,7 +2320,7 @@ static int setup_nodes(struct perf_session *session) · 2319 unmodified lines
2320	nodes[node] = set;	2320	nodes[node] = set;
2321		2321
2322	/* empty node, skip */	2322	/* empty node, skip */
2323	if (perf_cpu_map__empty(map))	2323	if (perf_cpu_map__has_any_cpu_or_is_empty(map))
2324	continue;	2324	continue;
2325		2325
2326	perf_cpu_map__for_each_cpu(cpu, idx, map) {	2326	perf_cpu_map__for_each_cpu(cpu, idx, map) {

tools/perf/builtin-ftrace.c+1−1

@@ -333,7 +333,7 @@ static int set_tracing_func_irqinfo(struct perf_ftrace *ftrace) · 332 unmodified lines
333		333
334	static int reset_tracing_cpu(void)	334	static int reset_tracing_cpu(void)
335	{	335	{
336	struct perf_cpu_map *cpumap = perf_cpu_map__new(NULL);	336	struct perf_cpu_map *cpumap = perf_cpu_map__new_online_cpus();
337	int ret;	337	int ret;
338		338
339	ret = set_tracing_cpumask(cpumap);	339	ret = set_tracing_cpumask(cpumap);

tools/perf/builtin-inject.c+6−0

 		"perf inject [<options>]",
 		NULL
 	};
+	if (!inject.itrace_synth_opts.set) {
+		/* Disable eager loading of kernel symbols that adds overhead to perf inject. */
+		symbol_conf.lazy_load_kernel_maps = true;
+	}
 #ifndef HAVE_JITDUMP
 	set_option_nobuild(options, 'j', "jit", "NO_LIBELF=1", true);
 #endif

tools/perf/builtin-lock.c+3−1

 		else
 			ev_name = strdup(contention_tracepoints[j].name);
-		if (!ev_name)
+		if (!ev_name) {
+			free(rec_argv);
 			return -ENOMEM;
+		}
 		rec_argv[i++] = "-e";
 		rec_argv[i++] = ev_name;

tools/perf/builtin-record.c+45−48

 static int record__aio_enabled(struct record *rec);
 static int record__comp_enabled(struct record *rec);
-static size_t zstd_compress(struct perf_session *session, struct mmap *map,
+static ssize_t zstd_compress(struct perf_session *session, struct mmap *map,
 			    void *dst, size_t dst_size, void *src, size_t src_size);
 #ifdef HAVE_AIO_SUPPORT
 	 */
 	if (record__comp_enabled(aio->rec)) {
-		size = zstd_compress(aio->rec->session, NULL, aio->data + aio->size,
+		ssize_t compressed = zstd_compress(aio->rec->session, NULL, aio->data + aio->size,
-				     mmap__mmap_len(map) - aio->size,
+						   mmap__mmap_len(map) - aio->size,
-				     buf, size);
+						   buf, size);
+		if (compressed < 0)
+			return (int)compressed;
+		size = compressed;
 	} else {
 		memcpy(aio->data + aio->size, buf, size);
 	}
 	struct record *rec = to;
 	if (record__comp_enabled(rec)) {
-		size = zstd_compress(rec->session, map, map->data, mmap__mmap_len(map), bf, size);
+		ssize_t compressed = zstd_compress(rec->session, map, map->data,
+						   mmap__mmap_len(map), bf, size);
+		if (compressed < 0)
+			return (int)compressed;
+		size = compressed;
 		bf   = map->data;
 	}
 	evlist__for_each_entry(evlist, pos) {
 try_again:
 		if (evsel__open(pos, pos->core.cpus, pos->core.threads) < 0) {
-			if (evsel__fallback(pos, errno, msg, sizeof(msg))) {
+			if (evsel__fallback(pos, &opts->target, errno, msg, sizeof(msg))) {
 				if (verbose > 0)
 					ui__warning("%s\n", msg);
 				goto try_again;
 	return size;
 }
-static size_t zstd_compress(struct perf_session *session, struct mmap *map,
+static ssize_t zstd_compress(struct perf_session *session, struct mmap *map,
 			    void *dst, size_t dst_size, void *src, size_t src_size)
 {
-	size_t compressed;
+	ssize_t compressed;
 	size_t max_record_size = PERF_SAMPLE_MAX_SIZE - sizeof(struct perf_record_compressed) - 1;
 	struct zstd_data *zstd_data = &session->zstd_data;
 	compressed = zstd_compress_stream_to_records(zstd_data, dst, dst_size, src, src_size,
 						     max_record_size, process_comp_header);
+	if (compressed < 0)
+		return compressed;
 	if (map && map->file) {
 		thread->bytes_transferred += src_size;
 static void record__read_lost_samples(struct record *rec)
 {
 	struct perf_session *session = rec->session;
-	struct perf_record_lost_samples *lost;
+	struct perf_record_lost_samples *lost = NULL;
 	struct evsel *evsel;
 	/* there was an error during record__open */
 	if (session->evlist == NULL)
 		return;
-	lost = zalloc(PERF_SAMPLE_MAX_SIZE);
-	if (lost == NULL) {
-		pr_debug("Memory allocation failed\n");
-		return;
-	}
-	lost->header.type = PERF_RECORD_LOST_SAMPLES;
 	evlist__for_each_entry(session->evlist, evsel) {
 		struct xyarray *xy = evsel->core.sample_id;
 		u64 lost_count;
 				}
 				if (count.lost) {
+					if (!lost) {
+						lost = zalloc(sizeof(*lost) +
+							      session->machines.host.id_hdr_size);
+						if (!lost) {
+							pr_debug("Memory allocation failed\n");
+							return;
+						}
+						lost->header.type = PERF_RECORD_LOST_SAMPLES;
+					}
 					__record__save_lost_samples(rec, evsel, lost,
 								    x, y, count.lost, 0);
 				}
 		}
 		lost_count = perf_bpf_filter__lost_count(evsel);
-		if (lost_count)
+		if (lost_count) {
+			if (!lost) {
+				lost = zalloc(sizeof(*lost) +
+					      session->machines.host.id_hdr_size);
+				if (!lost) {
+					pr_debug("Memory allocation failed\n");
+					return;
+				}
+				lost->header.type = PERF_RECORD_LOST_SAMPLES;
+			}
 			__record__save_lost_samples(rec, evsel, lost, 0, 0, lost_count,
 						    PERF_RECORD_MISC_LOST_SAMPLES_BPF);
+		}
 	}
 out:
 	free(lost);
 	}
 }
-static void record__uniquify_name(struct record *rec)
-{
-	struct evsel *pos;
-	struct evlist *evlist = rec->evlist;
-	char *new_name;
-	int ret;
-	if (perf_pmus__num_core_pmus() == 1)
-		return;
-	evlist__for_each_entry(evlist, pos) {
-		if (!evsel__is_hybrid(pos))
-			continue;
-		if (strchr(pos->name, '/'))
-			continue;
-		ret = asprintf(&new_name, "%s/%s/",
-			       pos->pmu_name, pos->name);
-		if (ret) {
-			free(pos->name);
-			pos->name = new_name;
-		}
-	}
-}
 static int record__terminate_thread(struct record_thread *thread_data)
 {
 	int err;
 	if (data->is_pipe && rec->evlist->core.nr_entries == 1)
 		rec->opts.sample_id = true;
-	record__uniquify_name(rec);
+	evlist__uniquify_name(rec->evlist);
 	/* Debug message used by test scripts */
 	pr_debug3("perf record opening and mmapping events\n");
 	if (cpu_map__is_dummy(cpus))
 		return 0;
-	perf_cpu_map__for_each_cpu(cpu, idx, cpus) {
+	perf_cpu_map__for_each_cpu_skip_any(cpu, idx, cpus) {
-		if (cpu.cpu == -1)
-			continue;
 		/* Return ENODEV is input cpu is greater than max cpu */
 		if ((unsigned long)cpu.cpu > mask->nbits)
 			return -ENODEV;
 # undef set_nobuild
 #endif
+	/* Disable eager loading of kernel symbols that adds overhead to perf record. */
+	symbol_conf.lazy_load_kernel_maps = true;
 	rec->opts.affinity = PERF_AFFINITY_SYS;
 	rec->evlist = evlist__new();

tools/perf/builtin-report.c+74−39

@@ -96,9 +96,9 @@ struct report { · 95 unmodified lines
96	bool stitch_lbr;	96	bool stitch_lbr;
97	bool disable_order;	97	bool disable_order;
98	bool skip_empty;	98	bool skip_empty;
		99	bool data_type;
99	int max_stack;	100	int max_stack;
100	struct perf_read_values show_threads_values;	101	struct perf_read_values show_threads_values;
101	struct annotation_options annotation_opts;
102	const char *pretty_printing_style;	102	const char *pretty_printing_style;
103	const char *cpu_list;	103	const char *cpu_list;
104	const char *symbol_filter_str;	104	const char *symbol_filter_str;
@@ -171,7 +171,7 @@ static int hist_iter__report_callback(struct hist_entry_iter *iter, · 66 unmodified lines
171	struct mem_info *mi;	171	struct mem_info *mi;
172	struct branch_info *bi;	172	struct branch_info *bi;
173		173
174	if (!ui__has_annotation() && !rep->symbol_ipc)	174	if (!ui__has_annotation() && !rep->symbol_ipc && !rep->data_type)
175	return 0;	175	return 0;
176		176
177	if (sort__mode == SORT_MODE__BRANCH) {	177	if (sort__mode == SORT_MODE__BRANCH) {
@@ -541,8 +541,7 @@ static int evlist__tui_block_hists_browse(struct evlist evlist, struct report · 363 unmodified lines
541	evlist__for_each_entry(evlist, pos) {	541	evlist__for_each_entry(evlist, pos) {
542	ret = report__browse_block_hists(&rep->block_reports[i++].hist,	542	ret = report__browse_block_hists(&rep->block_reports[i++].hist,
543	rep->min_percent, pos,	543	rep->min_percent, pos,
544	&rep->session->header.env,	544	&rep->session->header.env);
545	&rep->annotation_opts);
546	if (ret != 0)	545	if (ret != 0)
547	return ret;	546	return ret;
548	}	547	}
@@ -574,8 +573,7 @@ static int evlist__tty_browse_hists(struct evlist evlist, struct report rep, c · 25 unmodified lines
574		573
575	if (rep->total_cycles_mode) {	574	if (rep->total_cycles_mode) {
576	report__browse_block_hists(&rep->block_reports[i++].hist,	575	report__browse_block_hists(&rep->block_reports[i++].hist,
577	rep->min_percent, pos,	576	rep->min_percent, pos, NULL);
578	NULL, NULL);
579	continue;	577	continue;
580	}	578	}
581		579
@@ -670,7 +668,7 @@ static int report__browse_hists(struct report *rep) · 88 unmodified lines
670	}	668	}
671		669
672	ret = evlist__tui_browse_hists(evlist, help, NULL, rep->min_percent,	670	ret = evlist__tui_browse_hists(evlist, help, NULL, rep->min_percent,
673	&session->header.env, true, &rep->annotation_opts);	671	&session->header.env, true);
674	/*	672	/*
675	* Usually "ret" is the last pressed key, and we only	673	* Usually "ret" is the last pressed key, and we only
676	* care if the key notifies us to switch data file.	674	* care if the key notifies us to switch data file.
@@ -745,7 +743,7 @@ static int hists__resort_cb(struct hist_entry he, void arg) · 68 unmodified lines
745	if (rep->symbol_ipc && sym && !sym->annotate2) {	743	if (rep->symbol_ipc && sym && !sym->annotate2) {
746	struct evsel *evsel = hists_to_evsel(he->hists);	744	struct evsel *evsel = hists_to_evsel(he->hists);
747		745
748	symbol__annotate2(&he->ms, evsel, &rep->annotation_opts, NULL);	746	symbol__annotate2(&he->ms, evsel, NULL);
749	}	747	}
750		748
751	return 0;	749	return 0;
@@ -859,27 +857,47 @@ static struct task tasks_list(struct task task, struct machine *machine) · 107 unmodified lines
859	return tasks_list(parent_task, machine);	857	return tasks_list(parent_task, machine);
860	}	858	}
861		859
862	static size_t maps__fprintf_task(struct maps maps, int indent, FILE fp)	860	struct maps__fprintf_task_args {
		861	int indent;
		862	FILE *fp;
		863	size_t printed;
		864	};
		865
		866	static int maps__fprintf_task_cb(struct map map, void data)
863	{	867	{
864	size_t printed = 0;	868	struct maps__fprintf_task_args *args = data;
865	struct map_rb_node *rb_node;	869	const struct dso *dso = map__dso(map);
		870	u32 prot = map__prot(map);
		871	int ret;
866		872
867	maps__for_each_entry(maps, rb_node) {	873	ret = fprintf(args->fp,
868	struct map *map = rb_node->map;	874	"%*s %" PRIx64 "-%" PRIx64 " %c%c%c%c %08" PRIx64 " %" PRIu64 " %s\n",
869	const struct dso *dso = map__dso(map);	875	args->indent, "", map__start(map), map__end(map),
870	u32 prot = map__prot(map);	876	prot & PROT_READ ? 'r' : '-',
		877	prot & PROT_WRITE ? 'w' : '-',
		878	prot & PROT_EXEC ? 'x' : '-',
		879	map__flags(map) ? 's' : 'p',
		880	map__pgoff(map),
		881	dso->id.ino, dso->name);
871		882
872	printed += fprintf(fp, "%*s %" PRIx64 "-%" PRIx64 " %c%c%c%c %08" PRIx64 " %" PRIu64 " %s\n",	883	if (ret < 0)
873	indent, "", map__start(map), map__end(map),	884	return ret;
874	prot & PROT_READ ? 'r' : '-',	885
875	prot & PROT_WRITE ? 'w' : '-',	886	args->printed += ret;
876	prot & PROT_EXEC ? 'x' : '-',	887	return 0;
877	map__flags(map) ? 's' : 'p',	888	}
878	map__pgoff(map),	889
879	dso->id.ino, dso->name);	890	static size_t maps__fprintf_task(struct maps maps, int indent, FILE fp)
880	}	891	{
		892	struct maps__fprintf_task_args args = {
		893	.indent = indent,
		894	.fp = fp,
		895	.printed = 0,
		896	};
881		897
882	return printed;	898	maps__for_each_map(maps, maps__fprintf_task_cb, &args);
		899
		900	return args.printed;
883	}	901	}
884		902
885	static void task__print_level(struct task task, FILE fp, int level)	903	static void task__print_level(struct task task, FILE fp, int level)
@@ -1341,15 +1359,15 @@ int cmd_report(int argc, const char **argv) · 455 unmodified lines
1341	"list of cpus to profile"),	1359	"list of cpus to profile"),
1342	OPT_BOOLEAN('I', "show-info", &report.show_full_info,	1360	OPT_BOOLEAN('I', "show-info", &report.show_full_info,
1343	"Display extended information about perf.data file"),	1361	"Display extended information about perf.data file"),
1344	OPT_BOOLEAN(0, "source", &report.annotation_opts.annotate_src,	1362	OPT_BOOLEAN(0, "source", &annotate_opts.annotate_src,
1345	"Interleave source code with assembly code (default)"),	1363	"Interleave source code with assembly code (default)"),
1346	OPT_BOOLEAN(0, "asm-raw", &report.annotation_opts.show_asm_raw,	1364	OPT_BOOLEAN(0, "asm-raw", &annotate_opts.show_asm_raw,
1347	"Display raw encoding of assembly instructions (default)"),	1365	"Display raw encoding of assembly instructions (default)"),
1348	OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",	1366	OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
1349	"Specify disassembler style (e.g. -M intel for intel syntax)"),	1367	"Specify disassembler style (e.g. -M intel for intel syntax)"),
1350	OPT_STRING(0, "prefix", &report.annotation_opts.prefix, "prefix",	1368	OPT_STRING(0, "prefix", &annotate_opts.prefix, "prefix",
1351	"Add prefix to source file path names in programs (with --prefix-strip)"),	1369	"Add prefix to source file path names in programs (with --prefix-strip)"),
1352	OPT_STRING(0, "prefix-strip", &report.annotation_opts.prefix_strip, "N",	1370	OPT_STRING(0, "prefix-strip", &annotate_opts.prefix_strip, "N",
1353	"Strip first N entries of source file path name in programs (with --prefix)"),	1371	"Strip first N entries of source file path name in programs (with --prefix)"),
1354	OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,	1372	OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
1355	"Show a column with the sum of periods"),	1373	"Show a column with the sum of periods"),
@@ -1401,7 +1419,7 @@ int cmd_report(int argc, const char **argv) · 45 unmodified lines
1401	"Time span of interest (start,stop)"),	1419	"Time span of interest (start,stop)"),
1402	OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,	1420	OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
1403	"Show inline function"),	1421	"Show inline function"),
1404	OPT_CALLBACK(0, "percent-type", &report.annotation_opts, "local-period",	1422	OPT_CALLBACK(0, "percent-type", &annotate_opts, "local-period",
1405	"Set percent type local/global-period/hits",	1423	"Set percent type local/global-period/hits",
1406	annotate_parse_percent_type),	1424	annotate_parse_percent_type),
1407	OPT_BOOLEAN(0, "ns", &symbol_conf.nanosecs, "Show times in nanosecs"),	1425	OPT_BOOLEAN(0, "ns", &symbol_conf.nanosecs, "Show times in nanosecs"),
@@ -1426,7 +1444,14 @@ int cmd_report(int argc, const char **argv) · 18 unmodified lines
1426	if (ret < 0)	1444	if (ret < 0)
1427	goto exit;	1445	goto exit;
1428		1446
1429	annotation_options__init(&report.annotation_opts);	1447	/*
		1448	* tasks_mode require access to exited threads to list those that are in
		1449	* the data file. Off-cpu events are synthesized after other events and
		1450	* reference exited threads.
		1451	*/
		1452	symbol_conf.keep_exited_threads = true;
		1453
		1454	annotation_options__init();
1430		1455
1431	ret = perf_config(report__config, &report);	1456	ret = perf_config(report__config, &report);
1432	if (ret)	1457	if (ret)
@@ -1445,13 +1470,13 @@ int cmd_report(int argc, const char **argv) · 12 unmodified lines
1445	}	1470	}
1446		1471
1447	if (disassembler_style) {	1472	if (disassembler_style) {
1448	report.annotation_opts.disassembler_style = strdup(disassembler_style);	1473	annotate_opts.disassembler_style = strdup(disassembler_style);
1449	if (!report.annotation_opts.disassembler_style)	1474	if (!annotate_opts.disassembler_style)
1450	return -ENOMEM;	1475	return -ENOMEM;
1451	}	1476	}
1452	if (objdump_path) {	1477	if (objdump_path) {
1453	report.annotation_opts.objdump_path = strdup(objdump_path);	1478	annotate_opts.objdump_path = strdup(objdump_path);
1454	if (!report.annotation_opts.objdump_path)	1479	if (!annotate_opts.objdump_path)
1455	return -ENOMEM;	1480	return -ENOMEM;
1456	}	1481	}
1457	if (addr2line_path) {	1482	if (addr2line_path) {
@@ -1460,7 +1485,7 @@ int cmd_report(int argc, const char **argv) · 2 unmodified lines
1460	return -ENOMEM;	1485	return -ENOMEM;
1461	}	1486	}
1462		1487
1463	if (annotate_check_args(&report.annotation_opts) < 0) {	1488	if (annotate_check_args() < 0) {
1464	ret = -EINVAL;	1489	ret = -EINVAL;
1465	goto exit;	1490	goto exit;
1466	}	1491	}
@@ -1615,6 +1640,16 @@ repeat: · 148 unmodified lines
1615	sort_order = NULL;	1640	sort_order = NULL;
1616	}	1641	}
1617		1642
		1643	if (sort_order && strstr(sort_order, "type")) {
		1644	report.data_type = true;
		1645	annotate_opts.annotate_src = false;
		1646
		1647	#ifndef HAVE_DWARF_GETLOCATIONS_SUPPORT
		1648	pr_err("Error: Data type profiling is disabled due to missing DWARF support\n");
		1649	goto error;
		1650	#endif
		1651	}
		1652
1618	if (strcmp(input_name, "-") != 0)	1653	if (strcmp(input_name, "-") != 0)
1619	setup_browser(true);	1654	setup_browser(true);
1620	else	1655	else
@@ -1673,7 +1708,7 @@ repeat: · 52 unmodified lines
1673	* so don't allocate extra space that won't be used in the stdio	1708	* so don't allocate extra space that won't be used in the stdio
1674	* implementation.	1709	* implementation.
1675	*/	1710	*/
1676	if (ui__has_annotation() \|\| report.symbol_ipc \|\|	1711	if (ui__has_annotation() \|\| report.symbol_ipc \|\| report.data_type \|\|
1677	report.total_cycles_mode) {	1712	report.total_cycles_mode) {
1678	ret = symbol__annotation_init();	1713	ret = symbol__annotation_init();
1679	if (ret < 0)	1714	if (ret < 0)
@@ -1692,7 +1727,7 @@ repeat: · 12 unmodified lines
1692	*/	1727	*/
1693	symbol_conf.priv_size += sizeof(u32);	1728	symbol_conf.priv_size += sizeof(u32);
1694	}	1729	}
1695	annotation_config__init(&report.annotation_opts);	1730	annotation_config__init();
1696	}	1731	}
1697		1732
1698	if (symbol__init(&session->header.env) < 0)	1733	if (symbol__init(&session->header.env) < 0)
@@ -1746,7 +1781,7 @@ error: · 47 unmodified lines
1746	zstd_fini(&(session->zstd_data));	1781	zstd_fini(&(session->zstd_data));
1747	perf_session__delete(session);	1782	perf_session__delete(session);
1748	exit:	1783	exit:
1749	annotation_options__exit(&report.annotation_opts);	1784	annotation_options__exit();
1750	free(sort_order_help);	1785	free(sort_order_help);
1751	free(field_order_help);	1786	free(field_order_help);
1752	return ret;	1787	return ret;

tools/perf/builtin-stat.c+19−14

 		if ((evsel__leader(counter) != counter) ||
 		    !(counter->core.leader->nr_members > 1))
 			return COUNTER_SKIP;
-	} else if (evsel__fallback(counter, errno, msg, sizeof(msg))) {
+	} else if (evsel__fallback(counter, &target, errno, msg, sizeof(msg))) {
 		if (verbose > 0)
 			ui__warning("%s\n", msg);
 		return COUNTER_RETRY;
 	OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
 		    "list of cpus to monitor in system-wide"),
 	OPT_SET_UINT('A', "no-aggr", &stat_config.aggr_mode,
-		    "disable CPU count aggregation", AGGR_NONE),
+		    "disable aggregation across CPUs or PMUs", AGGR_NONE),
-	OPT_BOOLEAN(0, "no-merge", &stat_config.no_merge, "Do not merge identical named events"),
+	OPT_SET_UINT(0, "no-merge", &stat_config.aggr_mode,
+		    "disable aggregation the same as -A or -no-aggr", AGGR_NONE),
 	OPT_BOOLEAN(0, "hybrid-merge", &stat_config.hybrid_merge,
 		    "Merge identical named hybrid events"),
 	OPT_STRING('x', "field-separator", &stat_config.csv_sep, "separator",
 	OPT_BOOLEAN(0, "metric-no-merge", &stat_config.metric_no_merge,
 		       "don't try to share events between metrics in a group"),
 	OPT_BOOLEAN(0, "metric-no-threshold", &stat_config.metric_no_threshold,
-		       "don't try to share events between metrics in a group  "),
+		       "disable adding events for the metric threshold calculation"),
 	OPT_BOOLEAN(0, "topdown", &topdown_run,
 			"measure top-down statistics"),
 	OPT_UINTEGER(0, "td-level", &stat_config.topdown_level,
 	 * be the first online CPU in the cache domain else use the
 	 * first online CPU of the cache domain as the ID.
 	 */
-	if (perf_cpu_map__empty(cpu_map))
+	if (perf_cpu_map__has_any_cpu_or_is_empty(cpu_map))
 		id = cpu.cpu;
 	else
 		id = perf_cpu_map__cpu(cpu_map, 0).cpu;
 	 * taking the highest cpu number to be the size of
 	 * the aggregation translate cpumap.
 	 */
-	if (!perf_cpu_map__empty(evsel_list->core.user_requested_cpus))
+	if (!perf_cpu_map__has_any_cpu_or_is_empty(evsel_list->core.user_requested_cpus))
 		nr = perf_cpu_map__max(evsel_list->core.user_requested_cpus).cpu;
 	else
 		nr = 0;
 	perf_event__read_stat_config(&stat_config, &event->stat_config);
-	if (perf_cpu_map__empty(st->cpus)) {
+	if (perf_cpu_map__has_any_cpu_or_is_empty(st->cpus)) {
 		if (st->aggr_mode != AGGR_UNSET)
 			pr_warning("warning: processing task data, aggregation mode not set\n");
 	} else if (st->aggr_mode != AGGR_UNSET) {
 	 */
 	if (metrics) {
 		const char *pmu = parse_events_option_args.pmu_filter ?: "all";
+		int ret = metricgroup__parse_groups(evsel_list, pmu, metrics,
+						stat_config.metric_no_group,
+						stat_config.metric_no_merge,
+						stat_config.metric_no_threshold,
+						stat_config.user_requested_cpu_list,
+						stat_config.system_wide,
+						&stat_config.metric_events);
-		metricgroup__parse_groups(evsel_list, pmu, metrics,
-					stat_config.metric_no_group,
-					stat_config.metric_no_merge,
-					stat_config.metric_no_threshold,
-					stat_config.user_requested_cpu_list,
-					stat_config.system_wide,
-					&stat_config.metric_events);
 		zfree(&metrics);
+		if (ret) {
+			status = ret;
+			goto out;
+		}
 	}
 	if (add_default_attributes())

tools/perf/builtin-top.c+26−26

 		return err;
 	}
-	err = symbol__annotate(&he->ms, evsel, &top->annotation_opts, NULL);
+	err = symbol__annotate(&he->ms, evsel, NULL);
 	if (err == 0) {
 		top->sym_filter_entry = he;
 	} else {
 		goto out_unlock;
 	printf("Showing %s for %s\n", evsel__name(top->sym_evsel), symbol->name);
-	printf("  Events  Pcnt (>=%d%%)\n", top->annotation_opts.min_pcnt);
+	printf("  Events  Pcnt (>=%d%%)\n", annotate_opts.min_pcnt);
-	more = symbol__annotate_printf(&he->ms, top->sym_evsel, &top->annotation_opts);
+	more = symbol__annotate_printf(&he->ms, top->sym_evsel);
 	if (top->evlist->enabled) {
 		if (top->zero)
 	fprintf(stdout, "\t[f]     profile display filter (count).    \t(%d)\n", top->count_filter);
-	fprintf(stdout, "\t[F]     annotate display filter (percent). \t(%d%%)\n", top->annotation_opts.min_pcnt);
+	fprintf(stdout, "\t[F]     annotate display filter (percent). \t(%d%%)\n", annotate_opts.min_pcnt);
 	fprintf(stdout, "\t[s]     annotate symbol.                   \t(%s)\n", name?: "NULL");
 	fprintf(stdout, "\t[S]     stop annotation.\n");
 			prompt_integer(&top->count_filter, "Enter display event count filter");
 			break;
 		case 'F':
-			prompt_percent(&top->annotation_opts.min_pcnt,
+			prompt_percent(&annotate_opts.min_pcnt,
 				       "Enter details display event filter (percent)");
 			break;
 		case 'K':
 	}
 	ret = evlist__tui_browse_hists(top->evlist, help, &hbt, top->min_percent,
-				       &top->session->header.env, !top->record_opts.overwrite,
+				       &top->session->header.env, !top->record_opts.overwrite);
-				       &top->annotation_opts);
 	if (ret == K_RELOAD) {
 		top->zero = true;
 		goto repeat;
 	evlist__for_each_entry(evlist, counter) {
 try_again:
-		if (evsel__open(counter, top->evlist->core.user_requested_cpus,
+		if (evsel__open(counter, counter->core.cpus,
-				     top->evlist->core.threads) < 0) {
+				counter->core.threads) < 0) {
 			/*
 			 * Specially handle overwrite fall back.
 			    perf_top_overwrite_fallback(top, counter))
 				goto try_again;
-			if (evsel__fallback(counter, errno, msg, sizeof(msg))) {
+			if (evsel__fallback(counter, &opts->target, errno, msg, sizeof(msg))) {
 				if (verbose > 0)
 					ui__warning("%s\n", msg);
 				goto try_again;
 	pthread_t thread, thread_process;
 	int ret;
-	if (!top->annotation_opts.objdump_path) {
+	if (!annotate_opts.objdump_path) {
 		ret = perf_env__lookup_objdump(&top->session->header.env,
-					       &top->annotation_opts.objdump_path);
+					       &annotate_opts.objdump_path);
 		if (ret)
 			return ret;
 	}
 		}
 	}
+	evlist__uniquify_name(top->evlist);
 	ret = perf_top__start_counters(top);
 	if (ret)
 		return ret;
 		   "only consider symbols in these comms"),
 	OPT_STRING(0, "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
 		   "only consider these symbols"),
-	OPT_BOOLEAN(0, "source", &top.annotation_opts.annotate_src,
+	OPT_BOOLEAN(0, "source", &annotate_opts.annotate_src,
 		    "Interleave source code with assembly code (default)"),
-	OPT_BOOLEAN(0, "asm-raw", &top.annotation_opts.show_asm_raw,
+	OPT_BOOLEAN(0, "asm-raw", &annotate_opts.show_asm_raw,
 		    "Display raw encoding of assembly instructions (default)"),
 	OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
 		    "Enable kernel symbol demangling"),
 		   "addr2line binary to use for line numbers"),
 	OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
 		   "Specify disassembler style (e.g. -M intel for intel syntax)"),
-	OPT_STRING(0, "prefix", &top.annotation_opts.prefix, "prefix",
+	OPT_STRING(0, "prefix", &annotate_opts.prefix, "prefix",
 		    "Add prefix to source file path names in programs (with --prefix-strip)"),
-	OPT_STRING(0, "prefix-strip", &top.annotation_opts.prefix_strip, "N",
+	OPT_STRING(0, "prefix-strip", &annotate_opts.prefix_strip, "N",
 		    "Strip first N entries of source file path name in programs (with --prefix)"),
 	OPT_STRING('u', "uid", &target->uid_str, "user", "user to profile"),
 	OPT_CALLBACK(0, "percent-limit", &top, "percent",
 	if (status < 0)
 		return status;
-	annotation_options__init(&top.annotation_opts);
+	annotation_options__init();
-	top.annotation_opts.min_pcnt = 5;
+	annotate_opts.min_pcnt = 5;
-	top.annotation_opts.context  = 4;
+	annotate_opts.context  = 4;
 	top.evlist = evlist__new();
 	if (top.evlist == NULL)
 		usage_with_options(top_usage, options);
 	if (disassembler_style) {
-		top.annotation_opts.disassembler_style = strdup(disassembler_style);
+		annotate_opts.disassembler_style = strdup(disassembler_style);
-		if (!top.annotation_opts.disassembler_style)
+		if (!annotate_opts.disassembler_style)
 			return -ENOMEM;
 	}
 	if (objdump_path) {
-		top.annotation_opts.objdump_path = strdup(objdump_path);
+		annotate_opts.objdump_path = strdup(objdump_path);
-		if (!top.annotation_opts.objdump_path)
+		if (!annotate_opts.objdump_path)
 			return -ENOMEM;
 	}
 	if (addr2line_path) {
 	if (status)
 		goto out_delete_evlist;
-	if (annotate_check_args(&top.annotation_opts) < 0)
+	if (annotate_check_args() < 0)
 		goto out_delete_evlist;
 	if (!top.evlist->core.nr_entries) {
 	if (status < 0)
 		goto out_delete_evlist;
-	annotation_config__init(&top.annotation_opts);
+	annotation_config__init();
 	symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
 	status = symbol__init(NULL);
 out_delete_evlist:
 	evlist__delete(top.evlist);
 	perf_session__delete(top.session);
-	annotation_options__exit(&top.annotation_opts);
+	annotation_options__exit();
 	return status;
 }

tools/perf/builtin-trace.c+2−4

 static const char *errno_to_name(struct evsel *evsel, int err)
 {
 	struct perf_env *env = evsel__env(evsel);
-	const char *arch_name = perf_env__arch(env);
-	return arch_syscalls__strerrno(arch_name, err);
+	return perf_env__arch_strerrno(env, err);
 }
 static int trace__sys_exit(struct trace *trace, struct evsel *evsel,
 			printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
 			if (trace->errno_summary && stats->nr_failures) {
-				const char *arch_name = perf_env__arch(trace->host->env);
 				int e;
 				for (e = 0; e < stats->max_errno; ++e) {
 					if (stats->errnos[e] != 0)
-						fprintf(fp, "\t\t\t\t%s: %d\n", arch_syscalls__strerrno(arch_name, e + 1), stats->errnos[e]);
+						fprintf(fp, "\t\t\t\t%s: %d\n", perf_env__arch_strerrno(trace->host->env, e + 1), stats->errnos[e]);
 				}
 			}
 		}

tools/perf/perf-archive.sh+80−6

@@ -4,8 +4,73 @@ · 3 unmodified lines
4	# Arnaldo Carvalho de Melo <acme@redhat.com>	4	# Arnaldo Carvalho de Melo <acme@redhat.com>
5		5
6	PERF_DATA=perf.data	6	PERF_DATA=perf.data
7	if [ $# -ne 0 ] ; then	7	PERF_SYMBOLS=perf.symbols
8	PERF_DATA=$1	8	PERF_ALL=perf.all
		9	ALL=0
		10	UNPACK=0
		11
		12	while [ $# -gt 0 ] ; do
		13	if [ $1 == "--all" ]; then
		14	ALL=1
		15	shift
		16	elif [ $1 == "--unpack" ]; then
		17	UNPACK=1
		18	shift
		19	else
		20	PERF_DATA=$1
		21	UNPACK_TAR=$1
		22	shift
		23	fi
		24	done
		25
		26	if [ $UNPACK -eq 1 ]; then
		27	if [ ! -z "$UNPACK_TAR" ]; then # tar given as an argument
		28	if [ ! -e "$UNPACK_TAR" ]; then
		29	echo "Provided file $UNPACK_TAR does not exist"
		30	exit 1
		31	fi
		32	TARGET="$UNPACK_TAR"
		33	else # search for perf tar in the current directory
		34	TARGET=`find . -regex "\./perf.*\.tar\.bz2"`
		35	TARGET_NUM=`echo -n "$TARGET" \| grep -c '^'`
		36
		37	if [ -z "$TARGET" -o $TARGET_NUM -gt 1 ]; then
		38	echo -e "Error: $TARGET_NUM files found for unpacking:\n$TARGET"
		39	echo "Provide the requested file as an argument"
		40	exit 1
		41	else
		42	echo "Found target file for unpacking: $TARGET"
		43	fi
		44	fi
		45
		46	if [[ "$TARGET" =~ (\./)?$PERF_ALL.*.tar.bz2 ]]; then # perf tar generated by --all option
		47	TAR_CONTENTS=`tar tvf "$TARGET" \| tr -s " " \| cut -d " " -f 6`
		48	VALID_TAR=`echo "$TAR_CONTENTS" \| grep "$PERF_SYMBOLS.tar.bz2" \| wc -l` # check if it contains a sub-tar perf.symbols
		49	if [ $VALID_TAR -ne 1 ]; then
		50	echo "Error: $TARGET file is not valid (contains zero or multiple sub-tar files with debug symbols)"
		51	exit 1
		52	fi
		53
		54	INTERSECT=`comm -12 <(ls) <(echo "$TAR_CONTENTS") \| tr "\n" " "` # check for overwriting
		55	if [ ! -z "$INTERSECT" ]; then # prompt if file(s) already exist in the current directory
		56	echo "File(s) ${INTERSECT::-1} already exist in the current directory."
		57	while true; do
		58	read -p 'Do you wish to overwrite them? ' yn
		59	case $yn in
		60	[Yy]* ) break;;
		61	[Nn]* ) exit 1;;
		62	* ) echo "Please answer yes or no.";;
		63	esac
		64	done
		65	fi
		66
		67	# unzip the perf.data file in the current working directory and debug symbols in ~/.debug directory
		68	tar xvf $TARGET && tar xvf $PERF_SYMBOLS.tar.bz2 -C ~/.debug
		69
		70	else # perf tar generated by perf archive (contains only debug symbols)
		71	tar xvf $TARGET -C ~/.debug
		72	fi
		73	exit 0
9	fi	74	fi
10		75
11	#	76	#
@@ -39,9 +104,18 @@ while read build_id ; do · 27 unmodified lines
39	echo ${filename#$PERF_BUILDID_LINKDIR} >> $MANIFEST	104	echo ${filename#$PERF_BUILDID_LINKDIR} >> $MANIFEST
40	done	105	done
41		106
42	tar cjf $PERF_DATA.tar.bz2 -C $PERF_BUILDID_DIR -T $MANIFEST	107	if [ $ALL -eq 1 ]; then # pack perf.data file together with tar containing debug symbols
43	rm $MANIFEST $BUILDIDS \|\| true	108	HOSTNAME=$(hostname)
		109	DATE=$(date '+%Y%m%d-%H%M%S')
		110	tar cjf $PERF_SYMBOLS.tar.bz2 -C $PERF_BUILDID_DIR -T $MANIFEST
		111	tar cjf $PERF_ALL-$HOSTNAME-$DATE.tar.bz2 $PERF_DATA $PERF_SYMBOLS.tar.bz2
		112	rm $PERF_SYMBOLS.tar.bz2 $MANIFEST $BUILDIDS \|\| true
		113	else # pack only the debug symbols
		114	tar cjf $PERF_DATA.tar.bz2 -C $PERF_BUILDID_DIR -T $MANIFEST
		115	rm $MANIFEST $BUILDIDS \|\| true
		116	fi
		117
44	echo -e "Now please run:\n"	118	echo -e "Now please run:\n"
45	echo -e "$ tar xvf $PERF_DATA.tar.bz2 -C ~/.debug\n"	119	echo -e "$ perf archive --unpack\n"
46	echo "wherever you need to run 'perf report' on."	120	echo "or unpack the tar manually wherever you need to run 'perf report' on."
47	exit 0	121	exit 0

tools/perf/perf.c+30−0

@@ -39,6 +39,7 @@ · 38 unmodified lines
39	#include <linux/zalloc.h>	39	#include <linux/zalloc.h>
40		40
41	static int use_pager = -1;	41	static int use_pager = -1;
		42	static FILE *debug_fp = NULL;
42		43
43	struct cmd_struct {	44	struct cmd_struct {
44	const char *cmd;	45	const char *cmd;
@@ -162,6 +163,19 @@ static void commit_pager_choice(void) · 117 unmodified lines
162	}	163	}
163	}	164	}
164		165
		166	static int set_debug_file(const char *path)
		167	{
		168	debug_fp = fopen(path, "w");
		169	if (!debug_fp) {
		170	fprintf(stderr, "Open debug file '%s' failed: %s\n",
		171	path, strerror(errno));
		172	return -1;
		173	}
		174
		175	debug_set_file(debug_fp);
		176	return 0;
		177	}
		178
165	struct option options[] = {	179	struct option options[] = {
166	OPT_ARGUMENT("help", "help"),	180	OPT_ARGUMENT("help", "help"),
167	OPT_ARGUMENT("version", "version"),	181	OPT_ARGUMENT("version", "version"),
@@ -174,6 +188,7 @@ struct option options[] = { · 6 unmodified lines
174	OPT_ARGUMENT("list-cmds", "list-cmds"),	188	OPT_ARGUMENT("list-cmds", "list-cmds"),
175	OPT_ARGUMENT("list-opts", "list-opts"),	189	OPT_ARGUMENT("list-opts", "list-opts"),
176	OPT_ARGUMENT("debug", "debug"),	190	OPT_ARGUMENT("debug", "debug"),
		191	OPT_ARGUMENT("debug-file", "debug-file"),
177	OPT_END()	192	OPT_END()
178	};	193	};
179		194
@@ -287,6 +302,18 @@ static int handle_options(const char **argv, int argc, int *envchanged) · 107 unmodified lines
287		302
288	(*argv)++;	303	(*argv)++;
289	(*argc)--;	304	(*argc)--;
		305	} else if (!strcmp(cmd, "--debug-file")) {
		306	if (*argc < 2) {
		307	fprintf(stderr, "No path given for --debug-file.\n");
		308	usage(perf_usage_string);
		309	}
		310
		311	if (set_debug_file((*argv)[1]))
		312	usage(perf_usage_string);
		313
		314	(*argv)++;
		315	(*argc)--;
		316
290	} else {	317	} else {
291	fprintf(stderr, "Unknown option: %s\n", cmd);	318	fprintf(stderr, "Unknown option: %s\n", cmd);
292	usage(perf_usage_string);	319	usage(perf_usage_string);
@@ -547,5 +574,8 @@ int main(int argc, const char **argv) · 254 unmodified lines
547	fprintf(stderr, "Failed to run command '%s': %s\n",	574	fprintf(stderr, "Failed to run command '%s': %s\n",
548	cmd, str_error_r(errno, sbuf, sizeof(sbuf)));	575	cmd, str_error_r(errno, sbuf, sizeof(sbuf)));
549	out:	576	out:
		577	if (debug_fp)
		578	fclose(debug_fp);
		579
550	return 1;	580	return 1;
551	}	581	}

tools/perf/pmu-events/arch/arm64/ampere/ampereone/core-imp-def.json+1−1

@@ -110,7 +110,7 @@ · 109 unmodified lines
110	{	110	{
111	"PublicDescription": "Flushes due to memory hazards",	111	"PublicDescription": "Flushes due to memory hazards",
112	"EventCode": "0x121",	112	"EventCode": "0x121",
113	"EventName": "BPU_FLUSH_MEM_FAULT",	113	"EventName": "GPC_FLUSH_MEM_FAULT",
114	"BriefDescription": "Flushes due to memory hazards"	114	"BriefDescription": "Flushes due to memory hazards"
115	},	115	},
116	{	116	{

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/branch.json+125−0

@@ -0,0 +1,125 @@
	1	[
	2	{
	3	"ArchStdEvent": "BR_IMMED_SPEC"
	4	},
	5	{
	6	"ArchStdEvent": "BR_RETURN_SPEC"
	7	},
	8	{
	9	"ArchStdEvent": "BR_INDIRECT_SPEC"
	10	},
	11	{
	12	"ArchStdEvent": "BR_MIS_PRED"
	13	},
	14	{
	15	"ArchStdEvent": "BR_PRED"
	16	},
	17	{
	18	"PublicDescription": "Instruction architecturally executed, branch not taken",
	19	"EventCode": "0x8107",
	20	"EventName": "BR_SKIP_RETIRED",
	21	"BriefDescription": "Instruction architecturally executed, branch not taken"
	22	},
	23	{
	24	"PublicDescription": "Instruction architecturally executed, immediate branch taken",
	25	"EventCode": "0x8108",
	26	"EventName": "BR_IMMED_TAKEN_RETIRED",
	27	"BriefDescription": "Instruction architecturally executed, immediate branch taken"
	28	},
	29	{
	30	"PublicDescription": "Instruction architecturally executed, indirect branch excluding return retired",
	31	"EventCode": "0x810c",
	32	"EventName": "BR_INDNR_TAKEN_RETIRED",
	33	"BriefDescription": "Instruction architecturally executed, indirect branch excluding return retired"
	34	},
	35	{
	36	"PublicDescription": "Instruction architecturally executed, predicted immediate branch",
	37	"EventCode": "0x8110",
	38	"EventName": "BR_IMMED_PRED_RETIRED",
	39	"BriefDescription": "Instruction architecturally executed, predicted immediate branch"
	40	},
	41	{
	42	"PublicDescription": "Instruction architecturally executed, mispredicted immediate branch",
	43	"EventCode": "0x8111",
	44	"EventName": "BR_IMMED_MIS_PRED_RETIRED",
	45	"BriefDescription": "Instruction architecturally executed, mispredicted immediate branch"
	46	},
	47	{
	48	"PublicDescription": "Instruction architecturally executed, predicted indirect branch",
	49	"EventCode": "0x8112",
	50	"EventName": "BR_IND_PRED_RETIRED",
	51	"BriefDescription": "Instruction architecturally executed, predicted indirect branch"
	52	},
	53	{
	54	"PublicDescription": "Instruction architecturally executed, mispredicted indirect branch",
	55	"EventCode": "0x8113",
	56	"EventName": "BR_IND_MIS_PRED_RETIRED",
	57	"BriefDescription": "Instruction architecturally executed, mispredicted indirect branch"
	58	},
	59	{
	60	"PublicDescription": "Instruction architecturally executed, predicted procedure return",
	61	"EventCode": "0x8114",
	62	"EventName": "BR_RETURN_PRED_RETIRED",
	63	"BriefDescription": "Instruction architecturally executed, predicted procedure return"
	64	},
	65	{
	66	"PublicDescription": "Instruction architecturally executed, mispredicted procedure return",
	67	"EventCode": "0x8115",
	68	"EventName": "BR_RETURN_MIS_PRED_RETIRED",
	69	"BriefDescription": "Instruction architecturally executed, mispredicted procedure return"
	70	},
	71	{
	72	"PublicDescription": "Instruction architecturally executed, predicted indirect branch excluding return",
	73	"EventCode": "0x8116",
	74	"EventName": "BR_INDNR_PRED_RETIRED",
	75	"BriefDescription": "Instruction architecturally executed, predicted indirect branch excluding return"
	76	},
	77	{
	78	"PublicDescription": "Instruction architecturally executed, mispredicted indirect branch excluding return",
	79	"EventCode": "0x8117",
	80	"EventName": "BR_INDNR_MIS_PRED_RETIRED",
	81	"BriefDescription": "Instruction architecturally executed, mispredicted indirect branch excluding return"
	82	},
	83	{
	84	"PublicDescription": "Instruction architecturally executed, predicted branch, taken",
	85	"EventCode": "0x8118",
	86	"EventName": "BR_TAKEN_PRED_RETIRED",
	87	"BriefDescription": "Instruction architecturally executed, predicted branch, taken"
	88	},
	89	{
	90	"PublicDescription": "Instruction architecturally executed, mispredicted branch, taken",
	91	"EventCode": "0x8119",
	92	"EventName": "BR_TAKEN_MIS_PRED_RETIRED",
	93	"BriefDescription": "Instruction architecturally executed, mispredicted branch, taken"
	94	},
	95	{
	96	"PublicDescription": "Instruction architecturally executed, predicted branch, not taken",
	97	"EventCode": "0x811a",
	98	"EventName": "BR_SKIP_PRED_RETIRED",
	99	"BriefDescription": "Instruction architecturally executed, predicted branch, not taken"
	100	},
	101	{
	102	"PublicDescription": "Instruction architecturally executed, mispredicted branch, not taken",
	103	"EventCode": "0x811b",
	104	"EventName": "BR_SKIP_MIS_PRED_RETIRED",
	105	"BriefDescription": "Instruction architecturally executed, mispredicted branch, not taken"
	106	},
	107	{
	108	"PublicDescription": "Instruction architecturally executed, predicted branch",
	109	"EventCode": "0x811c",
	110	"EventName": "BR_PRED_RETIRED",
	111	"BriefDescription": "Instruction architecturally executed, predicted branch"
	112	},
	113	{
	114	"PublicDescription": "Instruction architecturally executed, indirect branch",
	115	"EventCode": "0x811d",
	116	"EventName": "BR_IND_RETIRED",
	117	"BriefDescription": "Instruction architecturally executed, indirect branch"
	118	},
	119	{
	120	"PublicDescription": "Branch Record captured.",
	121	"EventCode": "0x811f",
	122	"EventName": "BRB_FILTRATE",
	123	"BriefDescription": "Branch Record captured."
	124	}
	125	]

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/bus.json+20−0

@@ -0,0 +1,20 @@
	1	[
	2	{
	3	"ArchStdEvent": "CPU_CYCLES"
	4	},
	5	{
	6	"ArchStdEvent": "BUS_CYCLES"
	7	},
	8	{
	9	"ArchStdEvent": "BUS_ACCESS_RD"
	10	},
	11	{
	12	"ArchStdEvent": "BUS_ACCESS_WR"
	13	},
	14	{
	15	"ArchStdEvent": "BUS_ACCESS"
	16	},
	17	{
	18	"ArchStdEvent": "CNT_CYCLES"
	19	}
	20	]

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/cache.json+206−0

@@ -0,0 +1,206 @@
	1	[
	2	{
	3	"ArchStdEvent": "L1D_CACHE_RD"
	4	},
	5	{
	6	"ArchStdEvent": "L1D_CACHE_WR"
	7	},
	8	{
	9	"ArchStdEvent": "L1D_CACHE_REFILL_RD"
	10	},
	11	{
	12	"ArchStdEvent": "L1D_CACHE_INVAL"
	13	},
	14	{
	15	"ArchStdEvent": "L1D_TLB_REFILL_RD"
	16	},
	17	{
	18	"ArchStdEvent": "L1D_TLB_REFILL_WR"
	19	},
	20	{
	21	"ArchStdEvent": "L2D_CACHE_RD"
	22	},
	23	{
	24	"ArchStdEvent": "L2D_CACHE_WR"
	25	},
	26	{
	27	"ArchStdEvent": "L2D_CACHE_REFILL_RD"
	28	},
	29	{
	30	"ArchStdEvent": "L2D_CACHE_REFILL_WR"
	31	},
	32	{
	33	"ArchStdEvent": "L2D_CACHE_WB_VICTIM"
	34	},
	35	{
	36	"ArchStdEvent": "L2D_CACHE_WB_CLEAN"
	37	},
	38	{
	39	"ArchStdEvent": "L2D_CACHE_INVAL"
	40	},
	41	{
	42	"ArchStdEvent": "L1I_CACHE_REFILL"
	43	},
	44	{
	45	"ArchStdEvent": "L1I_TLB_REFILL"
	46	},
	47	{
	48	"ArchStdEvent": "L1D_CACHE_REFILL"
	49	},
	50	{
	51	"ArchStdEvent": "L1D_CACHE"
	52	},
	53	{
	54	"ArchStdEvent": "L1D_TLB_REFILL"
	55	},
	56	{
	57	"ArchStdEvent": "L1I_CACHE"
	58	},
	59	{
	60	"ArchStdEvent": "L2D_CACHE"
	61	},
	62	{
	63	"ArchStdEvent": "L2D_CACHE_REFILL"
	64	},
	65	{
	66	"ArchStdEvent": "L2D_CACHE_WB"
	67	},
	68	{
	69	"ArchStdEvent": "L1D_TLB"
	70	},
	71	{
	72	"ArchStdEvent": "L1I_TLB"
	73	},
	74	{
	75	"ArchStdEvent": "L2D_TLB_REFILL"
	76	},
	77	{
	78	"ArchStdEvent": "L2I_TLB_REFILL"
	79	},
	80	{
	81	"ArchStdEvent": "L2D_TLB"
	82	},
	83	{
	84	"ArchStdEvent": "L2I_TLB"
	85	},
	86	{
	87	"ArchStdEvent": "DTLB_WALK"
	88	},
	89	{
	90	"ArchStdEvent": "ITLB_WALK"
	91	},
	92	{
	93	"ArchStdEvent": "L1D_CACHE_REFILL_WR"
	94	},
	95	{
	96	"ArchStdEvent": "L1D_CACHE_LMISS_RD"
	97	},
	98	{
	99	"ArchStdEvent": "L1I_CACHE_LMISS"
	100	},
	101	{
	102	"ArchStdEvent": "L2D_CACHE_LMISS_RD"
	103	},
	104	{
	105	"PublicDescription": "Level 1 data or unified cache demand access",
	106	"EventCode": "0x8140",
	107	"EventName": "L1D_CACHE_RW",
	108	"BriefDescription": "Level 1 data or unified cache demand access"
	109	},
	110	{
	111	"PublicDescription": "Level 1 data or unified cache preload or prefetch",
	112	"EventCode": "0x8142",
	113	"EventName": "L1D_CACHE_PRFM",
	114	"BriefDescription": "Level 1 data or unified cache preload or prefetch"
	115	},
	116	{
	117	"PublicDescription": "Level 1 data or unified cache refill, preload or prefetch",
	118	"EventCode": "0x8146",
	119	"EventName": "L1D_CACHE_REFILL_PRFM",
	120	"BriefDescription": "Level 1 data or unified cache refill, preload or prefetch"
	121	},
	122	{
	123	"ArchStdEvent": "L1D_TLB_RD"
	124	},
	125	{
	126	"ArchStdEvent": "L1D_TLB_WR"
	127	},
	128	{
	129	"ArchStdEvent": "L2D_TLB_REFILL_RD"
	130	},
	131	{
	132	"ArchStdEvent": "L2D_TLB_REFILL_WR"
	133	},
	134	{
	135	"ArchStdEvent": "L2D_TLB_RD"
	136	},
	137	{
	138	"ArchStdEvent": "L2D_TLB_WR"
	139	},
	140	{
	141	"PublicDescription": "L1D TLB miss",
	142	"EventCode": "0xD600",
	143	"EventName": "L1D_TLB_MISS",
	144	"BriefDescription": "L1D TLB miss"
	145	},
	146	{
	147	"PublicDescription": "Level 1 prefetcher, load prefetch requests generated",
	148	"EventCode": "0xd606",
	149	"EventName": "L1_PREFETCH_LD_GEN",
	150	"BriefDescription": "Level 1 prefetcher, load prefetch requests generated"
	151	},
	152	{
	153	"PublicDescription": "Level 1 prefetcher, load prefetch fills into the level 1 cache",
	154	"EventCode": "0xd607",
	155	"EventName": "L1_PREFETCH_LD_FILL",
	156	"BriefDescription": "Level 1 prefetcher, load prefetch fills into the level 1 cache"
	157	},
	158	{
	159	"PublicDescription": "Level 1 prefetcher, load prefetch to level 2 generated",
	160	"EventCode": "0xd608",
	161	"EventName": "L1_PREFETCH_L2_REQ",
	162	"BriefDescription": "Level 1 prefetcher, load prefetch to level 2 generated"
	163	},
	164	{
	165	"PublicDescription": "L1 prefetcher, distance was reset",
	166	"EventCode": "0xd609",
	167	"EventName": "L1_PREFETCH_DIST_RST",
	168	"BriefDescription": "L1 prefetcher, distance was reset"
	169	},
	170	{
	171	"PublicDescription": "L1 prefetcher, distance was increased",
	172	"EventCode": "0xd60a",
	173	"EventName": "L1_PREFETCH_DIST_INC",
	174	"BriefDescription": "L1 prefetcher, distance was increased"
	175	},
	176	{
	177	"PublicDescription": "Level 1 prefetcher, table entry is trained",
	178	"EventCode": "0xd60b",
	179	"EventName": "L1_PREFETCH_ENTRY_TRAINED",
	180	"BriefDescription": "Level 1 prefetcher, table entry is trained"
	181	},
	182	{
	183	"PublicDescription": "L1 data cache refill - Read or Write",
	184	"EventCode": "0xd60e",
	185	"EventName": "L1D_CACHE_REFILL_RW",
	186	"BriefDescription": "L1 data cache refill - Read or Write"
	187	},
	188	{
	189	"PublicDescription": "Level 2 cache refill from instruction-side miss, including IMMU refills",
	190	"EventCode": "0xD701",
	191	"EventName": "L2C_INST_REFILL",
	192	"BriefDescription": "Level 2 cache refill from instruction-side miss, including IMMU refills"
	193	},
	194	{
	195	"PublicDescription": "Level 2 cache refill from data-side miss, including DMMU refills",
	196	"EventCode": "0xD702",
	197	"EventName": "L2C_DATA_REFILL",
	198	"BriefDescription": "Level 2 cache refill from data-side miss, including DMMU refills"
	199	},
	200	{
	201	"PublicDescription": "Level 2 cache prefetcher, load prefetch requests generated",
	202	"EventCode": "0xD703",
	203	"EventName": "L2_PREFETCH_REQ",
	204	"BriefDescription": "Level 2 cache prefetcher, load prefetch requests generated"
	205	}
	206	]

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/core-imp-def.json+464−0

@@ -0,0 +1,464 @@
	1	[
	2	{
	3	"PublicDescription": "Level 2 prefetch requests, refilled to L2 cache",
	4	"EventCode": "0x10A",
	5	"EventName": "L2_PREFETCH_REFILL",
	6	"BriefDescription": "Level 2 prefetch requests, refilled to L2 cache"
	7	},
	8	{
	9	"PublicDescription": "Level 2 prefetch requests, late",
	10	"EventCode": "0x10B",
	11	"EventName": "L2_PREFETCH_UPGRADE",
	12	"BriefDescription": "Level 2 prefetch requests, late"
	13	},
	14	{
	15	"PublicDescription": "Predictable branch speculatively executed that hit any level of BTB",
	16	"EventCode": "0x110",
	17	"EventName": "BPU_HIT_BTB",
	18	"BriefDescription": "Predictable branch speculatively executed that hit any level of BTB"
	19	},
	20	{
	21	"PublicDescription": "Predictable conditional branch speculatively executed that hit any level of BTB",
	22	"EventCode": "0x111",
	23	"EventName": "BPU_CONDITIONAL_BRANCH_HIT_BTB",
	24	"BriefDescription": "Predictable conditional branch speculatively executed that hit any level of BTB"
	25	},
	26	{
	27	"PublicDescription": "Predictable taken branch speculatively executed that hit any level of BTB that access the indirect predictor",
	28	"EventCode": "0x112",
	29	"EventName": "BPU_HIT_INDIRECT_PREDICTOR",
	30	"BriefDescription": "Predictable taken branch speculatively executed that hit any level of BTB that access the indirect predictor"
	31	},
	32	{
	33	"PublicDescription": "Predictable taken branch speculatively executed that hit any level of BTB that access the return predictor",
	34	"EventCode": "0x113",
	35	"EventName": "BPU_HIT_RSB",
	36	"BriefDescription": "Predictable taken branch speculatively executed that hit any level of BTB that access the return predictor"
	37	},
	38	{
	39	"PublicDescription": "Predictable unconditional branch speculatively executed that did not hit any level of BTB",
	40	"EventCode": "0x114",
	41	"EventName": "BPU_UNCONDITIONAL_BRANCH_MISS_BTB",
	42	"BriefDescription": "Predictable unconditional branch speculatively executed that did not hit any level of BTB"
	43	},
	44	{
	45	"PublicDescription": "Predictable branch speculatively executed, unpredicted",
	46	"EventCode": "0x115",
	47	"EventName": "BPU_BRANCH_NO_HIT",
	48	"BriefDescription": "Predictable branch speculatively executed, unpredicted"
	49	},
	50	{
	51	"PublicDescription": "Predictable branch speculatively executed that hit any level of BTB that mispredict",
	52	"EventCode": "0x116",
	53	"EventName": "BPU_HIT_BTB_AND_MISPREDICT",
	54	"BriefDescription": "Predictable branch speculatively executed that hit any level of BTB that mispredict"
	55	},
	56	{
	57	"PublicDescription": "Predictable conditional branch speculatively executed that hit any level of BTB that (direction) mispredict",
	58	"EventCode": "0x117",
	59	"EventName": "BPU_CONDITIONAL_BRANCH_HIT_BTB_AND_MISPREDICT",
	60	"BriefDescription": "Predictable conditional branch speculatively executed that hit any level of BTB that (direction) mispredict"
	61	},
	62	{
	63	"PublicDescription": "Predictable taken branch speculatively executed that hit any level of BTB that access the indirect predictor that mispredict",
	64	"EventCode": "0x118",
	65	"EventName": "BPU_INDIRECT_BRANCH_HIT_BTB_AND_MISPREDICT",
	66	"BriefDescription": "Predictable taken branch speculatively executed that hit any level of BTB that access the indirect predictor that mispredict"
	67	},
	68	{
	69	"PublicDescription": "Predictable taken branch speculatively executed that hit any level of BTB that access the return predictor that mispredict",
	70	"EventCode": "0x119",
	71	"EventName": "BPU_HIT_RSB_AND_MISPREDICT",
	72	"BriefDescription": "Predictable taken branch speculatively executed that hit any level of BTB that access the return predictor that mispredict"
	73	},
	74	{
	75	"PublicDescription": "Predictable taken branch speculatively executed that hit any level of BTB that access the overflow/underflow return predictor that mispredict",
	76	"EventCode": "0x11a",
	77	"EventName": "BPU_MISS_RSB_AND_MISPREDICT",
	78	"BriefDescription": "Predictable taken branch speculatively executed that hit any level of BTB that access the overflow/underflow return predictor that mispredict"
	79	},
	80	{
	81	"PublicDescription": "Predictable branch speculatively executed, unpredicted, that mispredict",
	82	"EventCode": "0x11b",
	83	"EventName": "BPU_NO_PREDICTION_MISPREDICT",
	84	"BriefDescription": "Predictable branch speculatively executed, unpredicted, that mispredict"
	85	},
	86	{
	87	"PublicDescription": "Preditable branch update the BTB region buffer entry",
	88	"EventCode": "0x11c",
	89	"EventName": "BPU_BTB_UPDATE",
	90	"BriefDescription": "Preditable branch update the BTB region buffer entry"
	91	},
	92	{
	93	"PublicDescription": "Count predict pipe stalls due to speculative return address predictor full",
	94	"EventCode": "0x11d",
	95	"EventName": "BPU_RSB_FULL_STALL",
	96	"BriefDescription": "Count predict pipe stalls due to speculative return address predictor full"
	97	},
	98	{
	99	"PublicDescription": "Macro-ops speculatively decoded",
	100	"EventCode": "0x11f",
	101	"EventName": "ICF_INST_SPEC_DECODE",
	102	"BriefDescription": "Macro-ops speculatively decoded"
	103	},
	104	{
	105	"PublicDescription": "Flushes",
	106	"EventCode": "0x120",
	107	"EventName": "GPC_FLUSH",
	108	"BriefDescription": "Flushes"
	109	},
	110	{
	111	"PublicDescription": "Flushes due to memory hazards",
	112	"EventCode": "0x121",
	113	"EventName": "GPC_FLUSH_MEM_FAULT",
	114	"BriefDescription": "Flushes due to memory hazards"
	115	},
	116	{
	117	"PublicDescription": "ETM extout bit 0",
	118	"EventCode": "0x141",
	119	"EventName": "MSC_ETM_EXTOUT0",
	120	"BriefDescription": "ETM extout bit 0"
	121	},
	122	{
	123	"PublicDescription": "ETM extout bit 1",
	124	"EventCode": "0x142",
	125	"EventName": "MSC_ETM_EXTOUT1",
	126	"BriefDescription": "ETM extout bit 1"
	127	},
	128	{
	129	"PublicDescription": "ETM extout bit 2",
	130	"EventCode": "0x143",
	131	"EventName": "MSC_ETM_EXTOUT2",
	132	"BriefDescription": "ETM extout bit 2"
	133	},
	134	{
	135	"PublicDescription": "ETM extout bit 3",
	136	"EventCode": "0x144",
	137	"EventName": "MSC_ETM_EXTOUT3",
	138	"BriefDescription": "ETM extout bit 3"
	139	},
	140	{
	141	"PublicDescription": "Bus request sn",
	142	"EventCode": "0x156",
	143	"EventName": "L2C_SNOOP",
	144	"BriefDescription": "Bus request sn"
	145	},
	146	{
	147	"PublicDescription": "L2 TXDAT LCRD blocked",
	148	"EventCode": "0x169",
	149	"EventName": "L2C_DAT_CRD_STALL",
	150	"BriefDescription": "L2 TXDAT LCRD blocked"
	151	},
	152	{
	153	"PublicDescription": "L2 TXRSP LCRD blocked",
	154	"EventCode": "0x16a",
	155	"EventName": "L2C_RSP_CRD_STALL",
	156	"BriefDescription": "L2 TXRSP LCRD blocked"
	157	},
	158	{
	159	"PublicDescription": "L2 TXREQ LCRD blocked",
	160	"EventCode": "0x16b",
	161	"EventName": "L2C_REQ_CRD_STALL",
	162	"BriefDescription": "L2 TXREQ LCRD blocked"
	163	},
	164	{
	165	"PublicDescription": "Early mispredict",
	166	"EventCode": "0xD100",
	167	"EventName": "ICF_EARLY_MIS_PRED",
	168	"BriefDescription": "Early mispredict"
	169	},
	170	{
	171	"PublicDescription": "FEQ full cycles",
	172	"EventCode": "0xD101",
	173	"EventName": "ICF_FEQ_FULL",
	174	"BriefDescription": "FEQ full cycles"
	175	},
	176	{
	177	"PublicDescription": "Instruction FIFO Full",
	178	"EventCode": "0xD102",
	179	"EventName": "ICF_INST_FIFO_FULL",
	180	"BriefDescription": "Instruction FIFO Full"
	181	},
	182	{
	183	"PublicDescription": "L1I TLB miss",
	184	"EventCode": "0xD103",
	185	"EventName": "L1I_TLB_MISS",
	186	"BriefDescription": "L1I TLB miss"
	187	},
	188	{
	189	"PublicDescription": "ICF sent 0 instructions to IDR this cycle",
	190	"EventCode": "0xD104",
	191	"EventName": "ICF_STALL",
	192	"BriefDescription": "ICF sent 0 instructions to IDR this cycle"
	193	},
	194	{
	195	"PublicDescription": "PC FIFO Full",
	196	"EventCode": "0xD105",
	197	"EventName": "ICF_PC_FIFO_FULL",
	198	"BriefDescription": "PC FIFO Full"
	199	},
	200	{
	201	"PublicDescription": "Stall due to BOB ID",
	202	"EventCode": "0xD200",
	203	"EventName": "IDR_STALL_BOB_ID",
	204	"BriefDescription": "Stall due to BOB ID"
	205	},
	206	{
	207	"PublicDescription": "Dispatch stall due to LOB entries",
	208	"EventCode": "0xD201",
	209	"EventName": "IDR_STALL_LOB_ID",
	210	"BriefDescription": "Dispatch stall due to LOB entries"
	211	},
	212	{
	213	"PublicDescription": "Dispatch stall due to SOB entries",
	214	"EventCode": "0xD202",
	215	"EventName": "IDR_STALL_SOB_ID",
	216	"BriefDescription": "Dispatch stall due to SOB entries"
	217	},
	218	{
	219	"PublicDescription": "Dispatch stall due to IXU scheduler entries",
	220	"EventCode": "0xD203",
	221	"EventName": "IDR_STALL_IXU_SCHED",
	222	"BriefDescription": "Dispatch stall due to IXU scheduler entries"
	223	},
	224	{
	225	"PublicDescription": "Dispatch stall due to FSU scheduler entries",
	226	"EventCode": "0xD204",
	227	"EventName": "IDR_STALL_FSU_SCHED",
	228	"BriefDescription": "Dispatch stall due to FSU scheduler entries"
	229	},
	230	{
	231	"PublicDescription": "Dispatch stall due to ROB entries",
	232	"EventCode": "0xD205",
	233	"EventName": "IDR_STALL_ROB_ID",
	234	"BriefDescription": "Dispatch stall due to ROB entries"
	235	},
	236	{
	237	"PublicDescription": "Dispatch stall due to flush",
	238	"EventCode": "0xD206",
	239	"EventName": "IDR_STALL_FLUSH",
	240	"BriefDescription": "Dispatch stall due to flush"
	241	},
	242	{
	243	"PublicDescription": "Dispatch stall due to WFI",
	244	"EventCode": "0xD207",
	245	"EventName": "IDR_STALL_WFI",
	246	"BriefDescription": "Dispatch stall due to WFI"
	247	},
	248	{
	249	"PublicDescription": "Number of SWOB drains triggered by timeout",
	250	"EventCode": "0xD208",
	251	"EventName": "IDR_STALL_SWOB_TIMEOUT",
	252	"BriefDescription": "Number of SWOB drains triggered by timeout"
	253	},
	254	{
	255	"PublicDescription": "Number of SWOB drains triggered by system register or special-purpose register read-after-write or specific special-purpose register writes that cause SWOB drain",
	256	"EventCode": "0xD209",
	257	"EventName": "IDR_STALL_SWOB_RAW",
	258	"BriefDescription": "Number of SWOB drains triggered by system register or special-purpose register read-after-write or specific special-purpose register writes that cause SWOB drain"
	259	},
	260	{
	261	"PublicDescription": "Number of SWOB drains triggered by system register write when SWOB full",
	262	"EventCode": "0xD20A",
	263	"EventName": "IDR_STALL_SWOB_FULL",
	264	"BriefDescription": "Number of SWOB drains triggered by system register write when SWOB full"
	265	},
	266	{
	267	"PublicDescription": "Dispatch stall due to L1 instruction cache miss",
	268	"EventCode": "0xD20B",
	269	"EventName": "STALL_FRONTEND_CACHE",
	270	"BriefDescription": "Dispatch stall due to L1 instruction cache miss"
	271	},
	272	{
	273	"PublicDescription": "Dispatch stall due to L1 data cache miss",
	274	"EventCode": "0xD20D",
	275	"EventName": "STALL_BACKEND_CACHE",
	276	"BriefDescription": "Dispatch stall due to L1 data cache miss"
	277	},
	278	{
	279	"PublicDescription": "Dispatch stall due to lack of any core resource",
	280	"EventCode": "0xD20F",
	281	"EventName": "STALL_BACKEND_RESOURCE",
	282	"BriefDescription": "Dispatch stall due to lack of any core resource"
	283	},
	284	{
	285	"PublicDescription": "Instructions issued by the scheduler",
	286	"EventCode": "0xD300",
	287	"EventName": "IXU_NUM_UOPS_ISSUED",
	288	"BriefDescription": "Instructions issued by the scheduler"
	289	},
	290	{
	291	"PublicDescription": "Any uop issued was canceled for any reason",
	292	"EventCode": "0xD301",
	293	"EventName": "IXU_ISSUE_CANCEL",
	294	"BriefDescription": "Any uop issued was canceled for any reason"
	295	},
	296	{
	297	"PublicDescription": "A load wakeup to the scheduler has been canceled",
	298	"EventCode": "0xD302",
	299	"EventName": "IXU_LOAD_CANCEL",
	300	"BriefDescription": "A load wakeup to the scheduler has been canceled"
	301	},
	302	{
	303	"PublicDescription": "The scheduler had to cancel one slow Uop due to resource conflict",
	304	"EventCode": "0xD303",
	305	"EventName": "IXU_SLOW_CANCEL",
	306	"BriefDescription": "The scheduler had to cancel one slow Uop due to resource conflict"
	307	},
	308	{
	309	"PublicDescription": "Uops issued by the scheduler on IXA",
	310	"EventCode": "0xD304",
	311	"EventName": "IXU_IXA_ISSUED",
	312	"BriefDescription": "Uops issued by the scheduler on IXA"
	313	},
	314	{
	315	"PublicDescription": "Uops issued by the scheduler on IXA Par 0",
	316	"EventCode": "0xD305",
	317	"EventName": "IXU_IXA_PAR0_ISSUED",
	318	"BriefDescription": "Uops issued by the scheduler on IXA Par 0"
	319	},
	320	{
	321	"PublicDescription": "Uops issued by the scheduler on IXA Par 1",
	322	"EventCode": "0xD306",
	323	"EventName": "IXU_IXA_PAR1_ISSUED",
	324	"BriefDescription": "Uops issued by the scheduler on IXA Par 1"
	325	},
	326	{
	327	"PublicDescription": "Uops issued by the scheduler on IXB",
	328	"EventCode": "0xD307",
	329	"EventName": "IXU_IXB_ISSUED",
	330	"BriefDescription": "Uops issued by the scheduler on IXB"
	331	},
	332	{
	333	"PublicDescription": "Uops issued by the scheduler on IXB Par 0",
	334	"EventCode": "0xD308",
	335	"EventName": "IXU_IXB_PAR0_ISSUED",
	336	"BriefDescription": "Uops issued by the scheduler on IXB Par 0"
	337	},
	338	{
	339	"PublicDescription": "Uops issued by the scheduler on IXB Par 1",
	340	"EventCode": "0xD309",
	341	"EventName": "IXU_IXB_PAR1_ISSUED",
	342	"BriefDescription": "Uops issued by the scheduler on IXB Par 1"
	343	},
	344	{
	345	"PublicDescription": "Uops issued by the scheduler on IXC",
	346	"EventCode": "0xD30A",
	347	"EventName": "IXU_IXC_ISSUED",
	348	"BriefDescription": "Uops issued by the scheduler on IXC"
	349	},
	350	{
	351	"PublicDescription": "Uops issued by the scheduler on IXC Par 0",
	352	"EventCode": "0xD30B",
	353	"EventName": "IXU_IXC_PAR0_ISSUED",
	354	"BriefDescription": "Uops issued by the scheduler on IXC Par 0"
	355	},
	356	{
	357	"PublicDescription": "Uops issued by the scheduler on IXC Par 1",
	358	"EventCode": "0xD30C",
	359	"EventName": "IXU_IXC_PAR1_ISSUED",
	360	"BriefDescription": "Uops issued by the scheduler on IXC Par 1"
	361	},
	362	{
	363	"PublicDescription": "Uops issued by the scheduler on IXD",
	364	"EventCode": "0xD30D",
	365	"EventName": "IXU_IXD_ISSUED",
	366	"BriefDescription": "Uops issued by the scheduler on IXD"
	367	},
	368	{
	369	"PublicDescription": "Uops issued by the scheduler on IXD Par 0",
	370	"EventCode": "0xD30E",
	371	"EventName": "IXU_IXD_PAR0_ISSUED",
	372	"BriefDescription": "Uops issued by the scheduler on IXD Par 0"
	373	},
	374	{
	375	"PublicDescription": "Uops issued by the scheduler on IXD Par 1",
	376	"EventCode": "0xD30F",
	377	"EventName": "IXU_IXD_PAR1_ISSUED",
	378	"BriefDescription": "Uops issued by the scheduler on IXD Par 1"
	379	},
	380	{
	381	"PublicDescription": "Uops issued by the FSU scheduler",
	382	"EventCode": "0xD400",
	383	"EventName": "FSU_ISSUED",
	384	"BriefDescription": "Uops issued by the FSU scheduler"
	385	},
	386	{
	387	"PublicDescription": "Uops issued by the scheduler on FSX",
	388	"EventCode": "0xD401",
	389	"EventName": "FSU_FSX_ISSUED",
	390	"BriefDescription": "Uops issued by the scheduler on FSX"
	391	},
	392	{
	393	"PublicDescription": "Uops issued by the scheduler on FSY",
	394	"EventCode": "0xD402",
	395	"EventName": "FSU_FSY_ISSUED",
	396	"BriefDescription": "Uops issued by the scheduler on FSY"
	397	},
	398	{
	399	"PublicDescription": "Uops issued by the scheduler on FSZ",
	400	"EventCode": "0xD403",
	401	"EventName": "FSU_FSZ_ISSUED",
	402	"BriefDescription": "Uops issued by the scheduler on FSZ"
	403	},
	404	{
	405	"PublicDescription": "Uops canceled (load cancels)",
	406	"EventCode": "0xD404",
	407	"EventName": "FSU_CANCEL",
	408	"BriefDescription": "Uops canceled (load cancels)"
	409	},
	410	{
	411	"PublicDescription": "Count scheduler stalls due to divide/sqrt",
	412	"EventCode": "0xD405",
	413	"EventName": "FSU_DIV_SQRT_STALL",
	414	"BriefDescription": "Count scheduler stalls due to divide/sqrt"
	415	},
	416	{
	417	"PublicDescription": "Number of SWOB drains",
	418	"EventCode": "0xD500",
	419	"EventName": "GPC_SWOB_DRAIN",
	420	"BriefDescription": "Number of SWOB drains"
	421	},
	422	{
	423	"PublicDescription": "GPC detected a Breakpoint instruction match",
	424	"EventCode": "0xD501",
	425	"EventName": "BREAKPOINT_MATCH",
	426	"BriefDescription": "GPC detected a Breakpoint instruction match"
	427	},
	428	{
	429	"PublicDescription": "Core progress monitor triggered",
	430	"EventCode": "0xd502",
	431	"EventName": "GPC_CPM_TRIGGER",
	432	"BriefDescription": "Core progress monitor triggered"
	433	},
	434	{
	435	"PublicDescription": "Fill buffer full",
	436	"EventCode": "0xD601",
	437	"EventName": "OFB_FULL",
	438	"BriefDescription": "Fill buffer full"
	439	},
	440	{
	441	"PublicDescription": "Load satisified from store forwarded data",
	442	"EventCode": "0xD605",
	443	"EventName": "LD_FROM_ST_FWD",
	444	"BriefDescription": "Load satisified from store forwarded data"
	445	},
	446	{
	447	"PublicDescription": "Store retirement pipe stall",
	448	"EventCode": "0xD60C",
	449	"EventName": "LSU_ST_RETIRE_STALL",
	450	"BriefDescription": "Store retirement pipe stall"
	451	},
	452	{
	453	"PublicDescription": "LSU detected a Watchpoint data match",
	454	"EventCode": "0xD60D",
	455	"EventName": "WATCHPOINT_MATCH",
	456	"BriefDescription": "LSU detected a Watchpoint data match"
	457	},
	458	{
	459	"PublicDescription": "Counts cycles that MSC is telling GPC to stall commit due to ETM ISTALL feature",
	460	"EventCode": "0xda00",
	461	"EventName": "MSC_ETM_COMMIT_STALL",
	462	"BriefDescription": "Counts cycles that MSC is telling GPC to stall commit due to ETM ISTALL feature"
	463	}
	464	]

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/exception.json+47−0

@@ -0,0 +1,47 @@
	1	[
	2	{
	3	"ArchStdEvent": "EXC_UNDEF"
	4	},
	5	{
	6	"ArchStdEvent": "EXC_SVC"
	7	},
	8	{
	9	"ArchStdEvent": "EXC_PABORT"
	10	},
	11	{
	12	"ArchStdEvent": "EXC_DABORT"
	13	},
	14	{
	15	"ArchStdEvent": "EXC_IRQ"
	16	},
	17	{
	18	"ArchStdEvent": "EXC_FIQ"
	19	},
	20	{
	21	"ArchStdEvent": "EXC_HVC"
	22	},
	23	{
	24	"ArchStdEvent": "EXC_TRAP_PABORT"
	25	},
	26	{
	27	"ArchStdEvent": "EXC_TRAP_DABORT"
	28	},
	29	{
	30	"ArchStdEvent": "EXC_TRAP_OTHER"
	31	},
	32	{
	33	"ArchStdEvent": "EXC_TRAP_IRQ"
	34	},
	35	{
	36	"ArchStdEvent": "EXC_TRAP_FIQ"
	37	},
	38	{
	39	"ArchStdEvent": "EXC_TAKEN"
	40	},
	41	{
	42	"ArchStdEvent": "EXC_RETURN"
	43	},
	44	{
	45	"ArchStdEvent": "EXC_SMC"
	46	}
	47	]

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/instruction.json+128−0

@@ -0,0 +1,128 @@
	1	[
	2	{
	3	"ArchStdEvent": "SW_INCR"
	4	},
	5	{
	6	"ArchStdEvent": "ST_RETIRED"
	7	},
	8	{
	9	"ArchStdEvent": "LD_SPEC"
	10	},
	11	{
	12	"ArchStdEvent": "ST_SPEC"
	13	},
	14	{
	15	"ArchStdEvent": "LDST_SPEC"
	16	},
	17	{
	18	"ArchStdEvent": "DP_SPEC"
	19	},
	20	{
	21	"ArchStdEvent": "ASE_SPEC"
	22	},
	23	{
	24	"ArchStdEvent": "VFP_SPEC"
	25	},
	26	{
	27	"ArchStdEvent": "PC_WRITE_SPEC"
	28	},
	29	{
	30	"ArchStdEvent": "BR_IMMED_RETIRED"
	31	},
	32	{
	33	"ArchStdEvent": "BR_RETURN_RETIRED"
	34	},
	35	{
	36	"ArchStdEvent": "CRYPTO_SPEC"
	37	},
	38	{
	39	"ArchStdEvent": "ISB_SPEC"
	40	},
	41	{
	42	"ArchStdEvent": "DSB_SPEC"
	43	},
	44	{
	45	"ArchStdEvent": "DMB_SPEC"
	46	},
	47	{
	48	"ArchStdEvent": "RC_LD_SPEC"
	49	},
	50	{
	51	"ArchStdEvent": "RC_ST_SPEC"
	52	},
	53	{
	54	"ArchStdEvent": "INST_RETIRED"
	55	},
	56	{
	57	"ArchStdEvent": "CID_WRITE_RETIRED"
	58	},
	59	{
	60	"ArchStdEvent": "PC_WRITE_RETIRED"
	61	},
	62	{
	63	"ArchStdEvent": "INST_SPEC"
	64	},
	65	{
	66	"ArchStdEvent": "TTBR_WRITE_RETIRED"
	67	},
	68	{
	69	"ArchStdEvent": "BR_RETIRED"
	70	},
	71	{
	72	"ArchStdEvent": "BR_MIS_PRED_RETIRED"
	73	},
	74	{
	75	"ArchStdEvent": "OP_RETIRED"
	76	},
	77	{
	78	"ArchStdEvent": "OP_SPEC"
	79	},
	80	{
	81	"PublicDescription": "Operation speculatively executed - ASE Scalar",
	82	"EventCode": "0xd210",
	83	"EventName": "ASE_SCALAR_SPEC",
	84	"BriefDescription": "Operation speculatively executed - ASE Scalar"
	85	},
	86	{
	87	"PublicDescription": "Operation speculatively executed - ASE Vector",
	88	"EventCode": "0xd211",
	89	"EventName": "ASE_VECTOR_SPEC",
	90	"BriefDescription": "Operation speculatively executed - ASE Vector"
	91	},
	92	{
	93	"PublicDescription": "Barrier speculatively executed, CSDB",
	94	"EventCode": "0x7f",
	95	"EventName": "CSDB_SPEC",
	96	"BriefDescription": "Barrier speculatively executed, CSDB"
	97	},
	98	{
	99	"PublicDescription": "Prefetch sent to L2.",
	100	"EventCode": "0xd106",
	101	"EventName": "ICF_PREFETCH_DISPATCH",
	102	"BriefDescription": "Prefetch sent to L2."
	103	},
	104	{
	105	"PublicDescription": "Prefetch response received but was dropped since we don't support inflight upgrades.",
	106	"EventCode": "0xd107",
	107	"EventName": "ICF_PREFETCH_DROPPED_NO_UPGRADE",
	108	"BriefDescription": "Prefetch response received but was dropped since we don't support inflight upgrades."
	109	},
	110	{
	111	"PublicDescription": "Prefetch request missed TLB.",
	112	"EventCode": "0xd108",
	113	"EventName": "ICF_PREFETCH_DROPPED_TLB_MISS",
	114	"BriefDescription": "Prefetch request missed TLB."
	115	},
	116	{
	117	"PublicDescription": "Prefetch request dropped since duplicate was found in TLB.",
	118	"EventCode": "0xd109",
	119	"EventName": "ICF_PREFETCH_DROPPED_DUPLICATE",
	120	"BriefDescription": "Prefetch request dropped since duplicate was found in TLB."
	121	},
	122	{
	123	"PublicDescription": "Prefetch request dropped since it was found in cache.",
	124	"EventCode": "0xd10a",
	125	"EventName": "ICF_PREFETCH_DROPPED_CACHE_HIT",
	126	"BriefDescription": "Prefetch request dropped since it was found in cache."
	127	}
	128	]

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/intrinsic.json+14−0

@@ -0,0 +1,14 @@
	1	[
	2	{
	3	"ArchStdEvent": "LDREX_SPEC"
	4	},
	5	{
	6	"ArchStdEvent": "STREX_PASS_SPEC"
	7	},
	8	{
	9	"ArchStdEvent": "STREX_FAIL_SPEC"
	10	},
	11	{
	12	"ArchStdEvent": "STREX_SPEC"
	13	}
	14	]

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/memory.json+41−0

@@ -0,0 +1,41 @@
	1	[
	2	{
	3	"ArchStdEvent": "LD_RETIRED"
	4	},
	5	{
	6	"ArchStdEvent": "MEM_ACCESS_RD"
	7	},
	8	{
	9	"ArchStdEvent": "MEM_ACCESS_WR"
	10	},
	11	{
	12	"ArchStdEvent": "LD_ALIGN_LAT"
	13	},
	14	{
	15	"ArchStdEvent": "ST_ALIGN_LAT"
	16	},
	17	{
	18	"ArchStdEvent": "MEM_ACCESS"
	19	},
	20	{
	21	"ArchStdEvent": "MEMORY_ERROR"
	22	},
	23	{
	24	"ArchStdEvent": "LDST_ALIGN_LAT"
	25	},
	26	{
	27	"ArchStdEvent": "MEM_ACCESS_CHECKED"
	28	},
	29	{
	30	"ArchStdEvent": "MEM_ACCESS_CHECKED_RD"
	31	},
	32	{
	33	"ArchStdEvent": "MEM_ACCESS_CHECKED_WR"
	34	},
	35	{
	36	"PublicDescription": "Flushes due to memory hazards",
	37	"EventCode": "0x121",
	38	"EventName": "BPU_FLUSH_MEM_FAULT",
	39	"BriefDescription": "Flushes due to memory hazards"
	40	}
	41	]

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/metrics.json+442−0

@@ -0,0 +1,442 @@
	1	[
	2	{
	3	"MetricName": "branch_miss_pred_rate",
	4	"MetricExpr": "BR_MIS_PRED / BR_PRED",
	5	"BriefDescription": "Branch predictor misprediction rate. May not count branches that are never resolved because they are in the misprediction shadow of an earlier branch",
	6	"MetricGroup": "branch",
	7	"ScaleUnit": "100%"
	8	},
	9	{
	10	"MetricName": "bus_utilization",
	11	"MetricExpr": "BUS_ACCESS / (BUS_CYCLES * 1)",
	12	"BriefDescription": "Core-to-uncore bus utilization",
	13	"MetricGroup": "Bus",
	14	"ScaleUnit": "100percent of bus cycles"
	15	},
	16	{
	17	"MetricName": "l1d_cache_miss_ratio",
	18	"MetricExpr": "L1D_CACHE_REFILL / L1D_CACHE",
	19	"BriefDescription": "This metric measures the ratio of level 1 data cache accesses missed to the total number of level 1 data cache accesses. This gives an indication of the effectiveness of the level 1 data cache.",
	20	"MetricGroup": "Miss_Ratio;L1D_Cache_Effectiveness",
	21	"ScaleUnit": "1per cache access"
	22	},
	23	{
	24	"MetricName": "l1i_cache_miss_ratio",
	25	"MetricExpr": "L1I_CACHE_REFILL / L1I_CACHE",
	26	"BriefDescription": "This metric measures the ratio of level 1 instruction cache accesses missed to the total number of level 1 instruction cache accesses. This gives an indication of the effectiveness of the level 1 instruction cache.",
	27	"MetricGroup": "Miss_Ratio;L1I_Cache_Effectiveness",
	28	"ScaleUnit": "1per cache access"
	29	},
	30	{
	31	"MetricName": "Miss_Ratio;l1d_cache_read_miss",
	32	"MetricExpr": "L1D_CACHE_LMISS_RD / L1D_CACHE_RD",
	33	"BriefDescription": "L1D cache read miss rate",
	34	"MetricGroup": "Cache",
	35	"ScaleUnit": "1per cache read access"
	36	},
	37	{
	38	"MetricName": "l2_cache_miss_ratio",
	39	"MetricExpr": "L2D_CACHE_REFILL / L2D_CACHE",
	40	"BriefDescription": "This metric measures the ratio of level 2 cache accesses missed to the total number of level 2 cache accesses. This gives an indication of the effectiveness of the level 2 cache, which is a unified cache that stores both data and instruction. Note that cache accesses in this cache are either data memory access or instruction fetch as this is a unified cache.",
	41	"MetricGroup": "Miss_Ratio;L2_Cache_Effectiveness",
	42	"ScaleUnit": "1per cache access"
	43	},
	44	{
	45	"MetricName": "l1i_cache_read_miss_rate",
	46	"MetricExpr": "L1I_CACHE_LMISS / L1I_CACHE",
	47	"BriefDescription": "L1I cache read miss rate",
	48	"MetricGroup": "Cache",
	49	"ScaleUnit": "1per cache access"
	50	},
	51	{
	52	"MetricName": "l2d_cache_read_miss_rate",
	53	"MetricExpr": "L2D_CACHE_LMISS_RD / L2D_CACHE_RD",
	54	"BriefDescription": "L2 cache read miss rate",
	55	"MetricGroup": "Cache",
	56	"ScaleUnit": "1per cache read access"
	57	},
	58	{
	59	"MetricName": "l1d_cache_miss_mpki",
	60	"MetricExpr": "(L1D_CACHE_LMISS_RD * 1e3) / INST_RETIRED",
	61	"BriefDescription": "Misses per thousand instructions (data)",
	62	"MetricGroup": "Cache",
	63	"ScaleUnit": "1MPKI"
	64	},
	65	{
	66	"MetricName": "l1i_cache_miss_mpki",
	67	"MetricExpr": "(L1I_CACHE_LMISS * 1e3) / INST_RETIRED",
	68	"BriefDescription": "Misses per thousand instructions (instruction)",
	69	"MetricGroup": "Cache",
	70	"ScaleUnit": "1MPKI"
	71	},
	72	{
	73	"MetricName": "simd_percentage",
	74	"MetricExpr": "ASE_SPEC / INST_SPEC",
	75	"BriefDescription": "This metric measures advanced SIMD operations as a percentage of total operations speculatively executed.",
	76	"MetricGroup": "Operation_Mix",
	77	"ScaleUnit": "100percent of operations"
	78	},
	79	{
	80	"MetricName": "crypto_percentage",
	81	"MetricExpr": "CRYPTO_SPEC / INST_SPEC",
	82	"BriefDescription": "This metric measures crypto operations as a percentage of operations speculatively executed.",
	83	"MetricGroup": "Operation_Mix",
	84	"ScaleUnit": "100percent of operations"
	85	},
	86	{
	87	"MetricName": "gflops",
	88	"MetricExpr": "VFP_SPEC / (duration_time * 1e9)",
	89	"BriefDescription": "Giga-floating point operations per second",
	90	"MetricGroup": "InstructionMix"
	91	},
	92	{
	93	"MetricName": "integer_dp_percentage",
	94	"MetricExpr": "DP_SPEC / INST_SPEC",
	95	"BriefDescription": "This metric measures scalar integer operations as a percentage of operations speculatively executed.",
	96	"MetricGroup": "Operation_Mix",
	97	"ScaleUnit": "100percent of operations"
	98	},
	99	{
	100	"MetricName": "ipc",
	101	"MetricExpr": "INST_RETIRED / CPU_CYCLES",
	102	"BriefDescription": "This metric measures the number of instructions retired per cycle.",
	103	"MetricGroup": "General",
	104	"ScaleUnit": "1per cycle"
	105	},
	106	{
	107	"MetricName": "load_percentage",
	108	"MetricExpr": "LD_SPEC / INST_SPEC",
	109	"BriefDescription": "This metric measures load operations as a percentage of operations speculatively executed.",
	110	"MetricGroup": "Operation_Mix",
	111	"ScaleUnit": "100percent of operations"
	112	},
	113	{
	114	"MetricName": "load_store_spec_rate",
	115	"MetricExpr": "LDST_SPEC / INST_SPEC",
	116	"BriefDescription": "The rate of load or store instructions speculatively executed to overall instructions speclatively executed",
	117	"MetricGroup": "Operation_Mix",
	118	"ScaleUnit": "100percent of operations"
	119	},
	120	{
	121	"MetricName": "retired_mips",
	122	"MetricExpr": "INST_RETIRED / (duration_time * 1e6)",
	123	"BriefDescription": "Millions of instructions per second",
	124	"MetricGroup": "InstructionMix"
	125	},
	126	{
	127	"MetricName": "spec_utilization_mips",
	128	"MetricExpr": "INST_SPEC / (duration_time * 1e6)",
	129	"BriefDescription": "Millions of instructions per second",
	130	"MetricGroup": "PEutilization"
	131	},
	132	{
	133	"MetricName": "pc_write_spec_rate",
	134	"MetricExpr": "PC_WRITE_SPEC / INST_SPEC",
	135	"BriefDescription": "The rate of software change of the PC speculatively executed to overall instructions speclatively executed",
	136	"MetricGroup": "Operation_Mix",
	137	"ScaleUnit": "100percent of operations"
	138	},
	139	{
	140	"MetricName": "store_percentage",
	141	"MetricExpr": "ST_SPEC / INST_SPEC",
	142	"BriefDescription": "This metric measures store operations as a percentage of operations speculatively executed.",
	143	"MetricGroup": "Operation_Mix",
	144	"ScaleUnit": "100percent of operations"
	145	},
	146	{
	147	"MetricName": "scalar_fp_percentage",
	148	"MetricExpr": "VFP_SPEC / INST_SPEC",
	149	"BriefDescription": "This metric measures scalar floating point operations as a percentage of operations speculatively executed.",
	150	"MetricGroup": "Operation_Mix",
	151	"ScaleUnit": "100percent of operations"
	152	},
	153	{
	154	"MetricName": "retired_rate",
	155	"MetricExpr": "OP_RETIRED / OP_SPEC",
	156	"BriefDescription": "Of all the micro-operations issued, what percentage are retired(committed)",
	157	"MetricGroup": "General",
	158	"ScaleUnit": "100%"
	159	},
	160	{
	161	"MetricName": "wasted",
	162	"MetricExpr": "1 - (OP_RETIRED / (CPU_CYCLES * #slots))",
	163	"BriefDescription": "Of all the micro-operations issued, what proportion are lost",
	164	"MetricGroup": "General",
	165	"ScaleUnit": "100%"
	166	},
	167	{
	168	"MetricName": "wasted_rate",
	169	"MetricExpr": "1 - OP_RETIRED / OP_SPEC",
	170	"BriefDescription": "Of all the micro-operations issued, what percentage are not retired(committed)",
	171	"MetricGroup": "General",
	172	"ScaleUnit": "100%"
	173	},
	174	{
	175	"MetricName": "stall_backend_cache_rate",
	176	"MetricExpr": "STALL_BACKEND_CACHE / CPU_CYCLES",
	177	"BriefDescription": "Proportion of cycles stalled and no operations issued to backend and cache miss",
	178	"MetricGroup": "Stall",
	179	"ScaleUnit": "100percent of cycles"
	180	},
	181	{
	182	"MetricName": "stall_backend_resource_rate",
	183	"MetricExpr": "STALL_BACKEND_RESOURCE / CPU_CYCLES",
	184	"BriefDescription": "Proportion of cycles stalled and no operations issued to backend and resource full",
	185	"MetricGroup": "Stall",
	186	"ScaleUnit": "100percent of cycles"
	187	},
	188	{
	189	"MetricName": "stall_backend_tlb_rate",
	190	"MetricExpr": "STALL_BACKEND_TLB / CPU_CYCLES",
	191	"BriefDescription": "Proportion of cycles stalled and no operations issued to backend and TLB miss",
	192	"MetricGroup": "Stall",
	193	"ScaleUnit": "100percent of cycles"
	194	},
	195	{
	196	"MetricName": "stall_frontend_cache_rate",
	197	"MetricExpr": "STALL_FRONTEND_CACHE / CPU_CYCLES",
	198	"BriefDescription": "Proportion of cycles stalled and no ops delivered from frontend and cache miss",
	199	"MetricGroup": "Stall",
	200	"ScaleUnit": "100percent of cycles"
	201	},
	202	{
	203	"MetricName": "stall_frontend_tlb_rate",
	204	"MetricExpr": "STALL_FRONTEND_TLB / CPU_CYCLES",
	205	"BriefDescription": "Proportion of cycles stalled and no ops delivered from frontend and TLB miss",
	206	"MetricGroup": "Stall",
	207	"ScaleUnit": "100percent of cycles"
	208	},
	209	{
	210	"MetricName": "dtlb_walk_ratio",
	211	"MetricExpr": "DTLB_WALK / L1D_TLB",
	212	"BriefDescription": "This metric measures the ratio of data TLB Walks to the total number of data TLB accesses. This gives an indication of the effectiveness of the data TLB accesses.",
	213	"MetricGroup": "Miss_Ratio;DTLB_Effectiveness",
	214	"ScaleUnit": "1per TLB access"
	215	},
	216	{
	217	"MetricName": "itlb_walk_ratio",
	218	"MetricExpr": "ITLB_WALK / L1I_TLB",
	219	"BriefDescription": "This metric measures the ratio of instruction TLB Walks to the total number of instruction TLB accesses. This gives an indication of the effectiveness of the instruction TLB accesses.",
	220	"MetricGroup": "Miss_Ratio;ITLB_Effectiveness",
	221	"ScaleUnit": "1per TLB access"
	222	},
	223	{
	224	"ArchStdEvent": "backend_bound"
	225	},
	226	{
	227	"ArchStdEvent": "frontend_bound",
	228	"MetricExpr": "100 - (retired_fraction + slots_lost_misspeculation_fraction + backend_bound)"
	229	},
	230	{
	231	"MetricName": "slots_lost_misspeculation_fraction",
	232	"MetricExpr": "(OP_SPEC - OP_RETIRED) / (CPU_CYCLES * #slots)",
	233	"BriefDescription": "Fraction of slots lost due to misspeculation",
	234	"DefaultMetricgroupName": "TopdownL1",
	235	"MetricGroup": "Default;TopdownL1",
	236	"ScaleUnit": "100percent of slots"
	237	},
	238	{
	239	"MetricName": "retired_fraction",
	240	"MetricExpr": "OP_RETIRED / (CPU_CYCLES * #slots)",
	241	"BriefDescription": "Fraction of slots retiring, useful work",
	242	"DefaultMetricgroupName": "TopdownL1",
	243	"MetricGroup": "Default;TopdownL1",
	244	"ScaleUnit": "100percent of slots"
	245	},
	246	{
	247	"MetricName": "backend_core",
	248	"MetricExpr": "(backend_bound / 100) - backend_memory",
	249	"BriefDescription": "Fraction of slots the CPU was stalled due to backend non-memory subsystem issues",
	250	"MetricGroup": "TopdownL2",
	251	"ScaleUnit": "100%"
	252	},
	253	{
	254	"MetricName": "backend_memory",
	255	"MetricExpr": "(STALL_BACKEND_TLB + STALL_BACKEND_CACHE) / CPU_CYCLES",
	256	"BriefDescription": "Fraction of slots the CPU was stalled due to backend memory subsystem issues (cache/tlb miss)",
	257	"MetricGroup": "TopdownL2",
	258	"ScaleUnit": "100%"
	259	},
	260	{
	261	"MetricName": "branch_mispredict",
	262	"MetricExpr": "(BR_MIS_PRED_RETIRED / GPC_FLUSH) * slots_lost_misspeculation_fraction",
	263	"BriefDescription": "Fraction of slots lost due to branch misprediciton",
	264	"MetricGroup": "TopdownL2",
	265	"ScaleUnit": "1percent of slots"
	266	},
	267	{
	268	"MetricName": "frontend_bandwidth",
	269	"MetricExpr": "frontend_bound - frontend_latency",
	270	"BriefDescription": "Fraction of slots the CPU did not dispatch at full bandwidth - able to dispatch partial slots only (1, 2, or 3 uops)",
	271	"MetricGroup": "TopdownL2",
	272	"ScaleUnit": "1percent of slots"
	273	},
	274	{
	275	"MetricName": "frontend_latency",
	276	"MetricExpr": "(STALL_FRONTEND - ((STALL_SLOT_FRONTEND - ((frontend_bound / 100) * CPU_CYCLES * #slots)) / #slots)) / CPU_CYCLES",
	277	"BriefDescription": "Fraction of slots the CPU was stalled due to frontend latency issues (cache/tlb miss); nothing to dispatch",
	278	"MetricGroup": "TopdownL2",
	279	"ScaleUnit": "100percent of slots"
	280	},
	281	{
	282	"MetricName": "other_miss_pred",
	283	"MetricExpr": "slots_lost_misspeculation_fraction - branch_mispredict",
	284	"BriefDescription": "Fraction of slots lost due to other/non-branch misprediction misspeculation",
	285	"MetricGroup": "TopdownL2",
	286	"ScaleUnit": "1percent of slots"
	287	},
	288	{
	289	"MetricName": "pipe_utilization",
	290	"MetricExpr": "100 * ((IXU_NUM_UOPS_ISSUED + FSU_ISSUED) / (CPU_CYCLES * 6))",
	291	"BriefDescription": "Fraction of execute slots utilized",
	292	"MetricGroup": "TopdownL2",
	293	"ScaleUnit": "1percent of slots"
	294	},
	295	{
	296	"MetricName": "d_cache_l2_miss_rate",
	297	"MetricExpr": "STALL_BACKEND_MEM / CPU_CYCLES",
	298	"BriefDescription": "Fraction of cycles the CPU was stalled due to data L2 cache miss",
	299	"MetricGroup": "TopdownL3",
	300	"ScaleUnit": "100percent of cycles"
	301	},
	302	{
	303	"MetricName": "d_cache_miss_rate",
	304	"MetricExpr": "STALL_BACKEND_CACHE / CPU_CYCLES",
	305	"BriefDescription": "Fraction of cycles the CPU was stalled due to data cache miss",
	306	"MetricGroup": "TopdownL3",
	307	"ScaleUnit": "100percent of cycles"
	308	},
	309	{
	310	"MetricName": "d_tlb_miss_rate",
	311	"MetricExpr": "STALL_BACKEND_TLB / CPU_CYCLES",
	312	"BriefDescription": "Fraction of cycles the CPU was stalled due to data TLB miss",
	313	"MetricGroup": "TopdownL3",
	314	"ScaleUnit": "100percent of cycles"
	315	},
	316	{
	317	"MetricName": "fsu_pipe_utilization",
	318	"MetricExpr": "FSU_ISSUED / (CPU_CYCLES * 2)",
	319	"BriefDescription": "Fraction of FSU execute slots utilized",
	320	"MetricGroup": "TopdownL3",
	321	"ScaleUnit": "100percent of slots"
	322	},
	323	{
	324	"MetricName": "i_cache_miss_rate",
	325	"MetricExpr": "STALL_FRONTEND_CACHE / CPU_CYCLES",
	326	"BriefDescription": "Fraction of cycles the CPU was stalled due to instruction cache miss",
	327	"MetricGroup": "TopdownL3",
	328	"ScaleUnit": "100percent of slots"
	329	},
	330	{
	331	"MetricName": "i_tlb_miss_rate",
	332	"MetricExpr": "STALL_FRONTEND_TLB / CPU_CYCLES",
	333	"BriefDescription": "Fraction of cycles the CPU was stalled due to instruction TLB miss",
	334	"MetricGroup": "TopdownL3",
	335	"ScaleUnit": "100percent of slots"
	336	},
	337	{
	338	"MetricName": "ixu_pipe_utilization",
	339	"MetricExpr": "IXU_NUM_UOPS_ISSUED / (CPU_CYCLES * #slots)",
	340	"BriefDescription": "Fraction of IXU execute slots utilized",
	341	"MetricGroup": "TopdownL3",
	342	"ScaleUnit": "100percent of slots"
	343	},
	344	{
	345	"MetricName": "stall_recovery_rate",
	346	"MetricExpr": "IDR_STALL_FLUSH / CPU_CYCLES",
	347	"BriefDescription": "Fraction of cycles the CPU was stalled due to flush recovery",
	348	"MetricGroup": "TopdownL3",
	349	"ScaleUnit": "100percent of slots"
	350	},
	351	{
	352	"MetricName": "stall_fsu_sched_rate",
	353	"MetricExpr": "IDR_STALL_FSU_SCHED / CPU_CYCLES",
	354	"BriefDescription": "Fraction of cycles the CPU was stalled and FSU was full",
	355	"MetricGroup": "TopdownL4",
	356	"ScaleUnit": "100percent of cycles"
	357	},
	358	{
	359	"MetricName": "stall_ixu_sched_rate",
	360	"MetricExpr": "IDR_STALL_IXU_SCHED / CPU_CYCLES",
	361	"BriefDescription": "Fraction of cycles the CPU was stalled and IXU was full",
	362	"MetricGroup": "TopdownL4",
	363	"ScaleUnit": "100percent of cycles"
	364	},
	365	{
	366	"MetricName": "stall_lob_id_rate",
	367	"MetricExpr": "IDR_STALL_LOB_ID / CPU_CYCLES",
	368	"BriefDescription": "Fraction of cycles the CPU was stalled and LOB was full",
	369	"MetricGroup": "TopdownL4",
	370	"ScaleUnit": "100percent of cycles"
	371	},
	372	{
	373	"MetricName": "stall_rob_id_rate",
	374	"MetricExpr": "IDR_STALL_ROB_ID / CPU_CYCLES",
	375	"BriefDescription": "Fraction of cycles the CPU was stalled and ROB was full",
	376	"MetricGroup": "TopdownL4",
	377	"ScaleUnit": "100percent of cycles"
	378	},
	379	{
	380	"MetricName": "stall_sob_id_rate",
	381	"MetricExpr": "IDR_STALL_SOB_ID / CPU_CYCLES",
	382	"BriefDescription": "Fraction of cycles the CPU was stalled and SOB was full",
	383	"MetricGroup": "TopdownL4",
	384	"ScaleUnit": "100percent of cycles"
	385	},
	386	{
	387	"MetricName": "l1d_cache_access_demand",
	388	"MetricExpr": "L1D_CACHE_RW / L1D_CACHE",
	389	"BriefDescription": "L1D cache access - demand",
	390	"MetricGroup": "Cache",
	391	"ScaleUnit": "100percent of cache acceses"
	392	},
	393	{
	394	"MetricName": "l1d_cache_access_prefetces",
	395	"MetricExpr": "L1D_CACHE_PRFM / L1D_CACHE",
	396	"BriefDescription": "L1D cache access - prefetch",
	397	"MetricGroup": "Cache",
	398	"ScaleUnit": "100percent of cache acceses"
	399	},
	400	{
	401	"MetricName": "l1d_cache_demand_misses",
	402	"MetricExpr": "L1D_CACHE_REFILL_RW / L1D_CACHE",
	403	"BriefDescription": "L1D cache demand misses",
	404	"MetricGroup": "Cache",
	405	"ScaleUnit": "100percent of cache acceses"
	406	},
	407	{
	408	"MetricName": "l1d_cache_demand_misses_read",
	409	"MetricExpr": "L1D_CACHE_REFILL_RD / L1D_CACHE",
	410	"BriefDescription": "L1D cache demand misses - read",
	411	"MetricGroup": "Cache",
	412	"ScaleUnit": "100percent of cache acceses"
	413	},
	414	{
	415	"MetricName": "l1d_cache_demand_misses_write",
	416	"MetricExpr": "L1D_CACHE_REFILL_WR / L1D_CACHE",
	417	"BriefDescription": "L1D cache demand misses - write",
	418	"MetricGroup": "Cache",
	419	"ScaleUnit": "100percent of cache acceses"
	420	},
	421	{
	422	"MetricName": "l1d_cache_prefetch_misses",
	423	"MetricExpr": "L1D_CACHE_REFILL_PRFM / L1D_CACHE",
	424	"BriefDescription": "L1D cache prefetch misses",
	425	"MetricGroup": "Cache",
	426	"ScaleUnit": "100percent of cache acceses"
	427	},
	428	{
	429	"MetricName": "ase_scalar_mix",
	430	"MetricExpr": "ASE_SCALAR_SPEC / OP_SPEC",
	431	"BriefDescription": "Proportion of advanced SIMD data processing operations (excluding DP_SPEC/LD_SPEC) scalar operations",
	432	"MetricGroup": "Instructions",
	433	"ScaleUnit": "100percent of cache acceses"
	434	},
	435	{
	436	"MetricName": "ase_vector_mix",
	437	"MetricExpr": "ASE_VECTOR_SPEC / OP_SPEC",
	438	"BriefDescription": "Proportion of advanced SIMD data processing operations (excluding DP_SPEC/LD_SPEC) vector operations",
	439	"MetricGroup": "Instructions",
	440	"ScaleUnit": "100percent of cache acceses"
	441	}
	442	]

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/mmu.json+170−0

@@ -0,0 +1,170 @@
	1	[
	2	{
	3	"PublicDescription": "Level 2 data translation buffer allocation",
	4	"EventCode": "0xD800",
	5	"EventName": "MMU_D_OTB_ALLOC",
	6	"BriefDescription": "Level 2 data translation buffer allocation"
	7	},
	8	{
	9	"PublicDescription": "Data TLB translation cache hit on S1L2 walk cache entry",
	10	"EventCode": "0xd801",
	11	"EventName": "MMU_D_TRANS_CACHE_HIT_S1L2_WALK",
	12	"BriefDescription": "Data TLB translation cache hit on S1L2 walk cache entry"
	13	},
	14	{
	15	"PublicDescription": "Data TLB translation cache hit on S1L1 walk cache entry",
	16	"EventCode": "0xd802",
	17	"EventName": "MMU_D_TRANS_CACHE_HIT_S1L1_WALK",
	18	"BriefDescription": "Data TLB translation cache hit on S1L1 walk cache entry"
	19	},
	20	{
	21	"PublicDescription": "Data TLB translation cache hit on S1L0 walk cache entry",
	22	"EventCode": "0xd803",
	23	"EventName": "MMU_D_TRANS_CACHE_HIT_S1L0_WALK",
	24	"BriefDescription": "Data TLB translation cache hit on S1L0 walk cache entry"
	25	},
	26	{
	27	"PublicDescription": "Data TLB translation cache hit on S2L2 walk cache entry",
	28	"EventCode": "0xd804",
	29	"EventName": "MMU_D_TRANS_CACHE_HIT_S2L2_WALK",
	30	"BriefDescription": "Data TLB translation cache hit on S2L2 walk cache entry"
	31	},
	32	{
	33	"PublicDescrition": "Data TLB translation cache hit on S2L1 walk cache entry",
	34	"EventCode": "0xd805",
	35	"EventName": "MMU_D_TRANS_CACHE_HIT_S2L1_WALK",
	36	"BriefDescription": "Data TLB translation cache hit on S2L1 walk cache entry"
	37	},
	38	{
	39	"PublicDescrition": "Data TLB translation cache hit on S2L0 walk cache entry",
	40	"EventCode": "0xd806",
	41	"EventName": "MMU_D_TRANS_CACHE_HIT_S2L0_WALK",
	42	"BriefDescription": "Data TLB translation cache hit on S2L0 walk cache entry"
	43	},
	44	{
	45	"PublicDescrition": "Data-side S1 page walk cache lookup",
	46	"EventCode": "0xd807",
	47	"EventName": "MMU_D_S1_WALK_CACHE_LOOKUP",
	48	"BriefDescription": "Data-side S1 page walk cache lookup"
	49	},
	50	{
	51	"PublicDescrition": "Data-side S1 page walk cache refill",
	52	"EventCode": "0xd808",
	53	"EventName": "MMU_D_S1_WALK_CACHE_REFILL",
	54	"BriefDescription": "Data-side S1 page walk cache refill"
	55	},
	56	{
	57	"PublicDescrition": "Data-side S2 page walk cache lookup",
	58	"EventCode": "0xd809",
	59	"EventName": "MMU_D_S2_WALK_CACHE_LOOKUP",
	60	"BriefDescription": "Data-side S2 page walk cache lookup"
	61	},
	62	{
	63	"PublicDescrition": "Data-side S2 page walk cache refill",
	64	"EventCode": "0xd80a",
	65	"EventName": "MMU_D_S2_WALK_CACHE_REFILL",
	66	"BriefDescription": "Data-side S2 page walk cache refill"
	67	},
	68	{
	69	"PublicDescription": "Data-side S1 table walk fault",
	70	"EventCode": "0xD80B",
	71	"EventName": "MMU_D_S1_WALK_FAULT",
	72	"BriefDescription": "Data-side S1 table walk fault"
	73	},
	74	{
	75	"PublicDescription": "Data-side S2 table walk fault",
	76	"EventCode": "0xD80C",
	77	"EventName": "MMU_D_S2_WALK_FAULT",
	78	"BriefDescription": "Data-side S2 table walk fault"
	79	},
	80	{
	81	"PublicDescription": "Data-side table walk steps or descriptor fetches",
	82	"EventCode": "0xD80D",
	83	"EventName": "MMU_D_WALK_STEPS",
	84	"BriefDescription": "Data-side table walk steps or descriptor fetches"
	85	},
	86	{
	87	"PublicDescription": "Level 2 instruction translation buffer allocation",
	88	"EventCode": "0xD900",
	89	"EventName": "MMU_I_OTB_ALLOC",
	90	"BriefDescription": "Level 2 instruction translation buffer allocation"
	91	},
	92	{
	93	"PublicDescrition": "Instruction TLB translation cache hit on S1L2 walk cache entry",
	94	"EventCode": "0xd901",
	95	"EventName": "MMU_I_TRANS_CACHE_HIT_S1L2_WALK",
	96	"BriefDescription": "Instruction TLB translation cache hit on S1L2 walk cache entry"
	97	},
	98	{
	99	"PublicDescrition": "Instruction TLB translation cache hit on S1L1 walk cache entry",
	100	"EventCode": "0xd902",
	101	"EventName": "MMU_I_TRANS_CACHE_HIT_S1L1_WALK",
	102	"BriefDescription": "Instruction TLB translation cache hit on S1L1 walk cache entry"
	103	},
	104	{
	105	"PublicDescrition": "Instruction TLB translation cache hit on S1L0 walk cache entry",
	106	"EventCode": "0xd903",
	107	"EventName": "MMU_I_TRANS_CACHE_HIT_S1L0_WALK",
	108	"BriefDescription": "Instruction TLB translation cache hit on S1L0 walk cache entry"
	109	},
	110	{
	111	"PublicDescrition": "Instruction TLB translation cache hit on S2L2 walk cache entry",
	112	"EventCode": "0xd904",
	113	"EventName": "MMU_I_TRANS_CACHE_HIT_S2L2_WALK",
	114	"BriefDescription": "Instruction TLB translation cache hit on S2L2 walk cache entry"
	115	},
	116	{
	117	"PublicDescrition": "Instruction TLB translation cache hit on S2L1 walk cache entry",
	118	"EventCode": "0xd905",
	119	"EventName": "MMU_I_TRANS_CACHE_HIT_S2L1_WALK",
	120	"BriefDescription": "Instruction TLB translation cache hit on S2L1 walk cache entry"
	121	},
	122	{
	123	"PublicDescrition": "Instruction TLB translation cache hit on S2L0 walk cache entry",
	124	"EventCode": "0xd906",
	125	"EventName": "MMU_I_TRANS_CACHE_HIT_S2L0_WALK",
	126	"BriefDescription": "Instruction TLB translation cache hit on S2L0 walk cache entry"
	127	},
	128	{
	129	"PublicDescrition": "Instruction-side S1 page walk cache lookup",
	130	"EventCode": "0xd907",
	131	"EventName": "MMU_I_S1_WALK_CACHE_LOOKUP",
	132	"BriefDescription": "Instruction-side S1 page walk cache lookup"
	133	},
	134	{
	135	"PublicDescrition": "Instruction-side S1 page walk cache refill",
	136	"EventCode": "0xd908",
	137	"EventName": "MMU_I_S1_WALK_CACHE_REFILL",
	138	"BriefDescription": "Instruction-side S1 page walk cache refill"
	139	},
	140	{
	141	"PublicDescrition": "Instruction-side S2 page walk cache lookup",
	142	"EventCode": "0xd909",
	143	"EventName": "MMU_I_S2_WALK_CACHE_LOOKUP",
	144	"BriefDescription": "Instruction-side S2 page walk cache lookup"
	145	},
	146	{
	147	"PublicDescrition": "Instruction-side S2 page walk cache refill",
	148	"EventCode": "0xd90a",
	149	"EventName": "MMU_I_S2_WALK_CACHE_REFILL",
	150	"BriefDescription": "Instruction-side S2 page walk cache refill"
	151	},
	152	{
	153	"PublicDescription": "Instruction-side S1 table walk fault",
	154	"EventCode": "0xD90B",
	155	"EventName": "MMU_I_S1_WALK_FAULT",
	156	"BriefDescription": "Instruction-side S1 table walk fault"
	157	},
	158	{
	159	"PublicDescription": "Instruction-side S2 table walk fault",
	160	"EventCode": "0xD90C",
	161	"EventName": "MMU_I_S2_WALK_FAULT",
	162	"BriefDescription": "Instruction-side S2 table walk fault"
	163	},
	164	{
	165	"PublicDescription": "Instruction-side table walk steps or descriptor fetches",
	166	"EventCode": "0xD90D",
	167	"EventName": "MMU_I_WALK_STEPS",
	168	"BriefDescription": "Instruction-side table walk steps or descriptor fetches"
	169	}
	170	]

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/pipeline.json+41−0

@@ -0,0 +1,41 @@
	1	[
	2	{
	3	"ArchStdEvent": "STALL_FRONTEND",
	4	"Errata": "Errata AC03_CPU_29",
	5	"BriefDescription": "Impacted by errata, use metrics instead -"
	6	},
	7	{
	8	"ArchStdEvent": "STALL_BACKEND"
	9	},
	10	{
	11	"ArchStdEvent": "STALL",
	12	"Errata": "Errata AC03_CPU_29",
	13	"BriefDescription": "Impacted by errata, use metrics instead -"
	14	},
	15	{
	16	"ArchStdEvent": "STALL_SLOT_BACKEND"
	17	},
	18	{
	19	"ArchStdEvent": "STALL_SLOT_FRONTEND",
	20	"Errata": "Errata AC03_CPU_29",
	21	"BriefDescription": "Impacted by errata, use metrics instead -"
	22	},
	23	{
	24	"ArchStdEvent": "STALL_SLOT"
	25	},
	26	{
	27	"ArchStdEvent": "STALL_BACKEND_MEM"
	28	},
	29	{
	30	"PublicDescription": "Frontend stall cycles, TLB",
	31	"EventCode": "0x815c",
	32	"EventName": "STALL_FRONTEND_TLB",
	33	"BriefDescription": "Frontend stall cycles, TLB"
	34	},
	35	{
	36	"PublicDescription": "Backend stall cycles, TLB",
	37	"EventCode": "0x8167",
	38	"EventName": "STALL_BACKEND_TLB",
	39	"BriefDescription": "Backend stall cycles, TLB"
	40	}
	41	]

tools/perf/pmu-events/arch/arm64/ampere/ampereonex/spe.json+14−0

@@ -0,0 +1,14 @@
	1	[
	2	{
	3	"ArchStdEvent": "SAMPLE_POP"
	4	},
	5	{
	6	"ArchStdEvent": "SAMPLE_FEED"
	7	},
	8	{
	9	"ArchStdEvent": "SAMPLE_FILTRATE"
	10	},
	11	{
	12	"ArchStdEvent": "SAMPLE_COLLISION"
	13	}
	14	]

tools/perf/pmu-events/arch/arm64/arm/cmn/sys/cmn.json+1−1

@@ -107,7 +107,7 @@ · 106 unmodified lines
107	"EventName": "hnf_qos_hh_retry",	107	"EventName": "hnf_qos_hh_retry",
108	"EventidCode": "0xe",	108	"EventidCode": "0xe",
109	"NodeType": "0x5",	109	"NodeType": "0x5",
110	"BriefDescription": "Counts number of times a HighHigh priority request is protocolretried at the HN‑F.",	110	"BriefDescription": "Counts number of times a HighHigh priority request is protocolretried at the HN-F.",
111	"Unit": "arm_cmn",	111	"Unit": "arm_cmn",
112	"Compat": "(434\|436\|43c\|43a).*"	112	"Compat": "(434\|436\|43c\|43a).*"
113	},	113	},

tools/perf/pmu-events/arch/arm64/mapfile.csv+1−0

@@ -42,3 +42,4 @@ · 41 unmodified lines
42	0x00000000480fd010,v1,hisilicon/hip08,core	42	0x00000000480fd010,v1,hisilicon/hip08,core
43	0x00000000500f0000,v1,ampere/emag,core	43	0x00000000500f0000,v1,ampere/emag,core
44	0x00000000c00fac30,v1,ampere/ampereone,core	44	0x00000000c00fac30,v1,ampere/ampereone,core
		45	0x00000000c00fac40,v1,ampere/ampereonex,core

tools/perf/pmu-events/arch/powerpc/mapfile.csv+1−2

 #
 # Multiple PVRs could map to a single JSON file.
 #
-# Power8 entries
 0x004[bcd][[:xdigit:]]{4},1,power8,core
+0x0066[[:xdigit:]]{4},1,power8,core
 0x004e[[:xdigit:]]{4},1,power9,core
 0x0080[[:xdigit:]]{4},1,power10,core

tools/perf/pmu-events/arch/powerpc/power10/datasource.json+14−4

     "EventName": "PM_INST_FROM_L2MISS",
     "BriefDescription": "The processor's instruction cache was reloaded from a source beyond the local core's L2 due to a demand miss."
   },
+  {
+    "EventCode": "0x0003C0000000C040",
+    "EventName": "PM_DATA_FROM_L2MISS_DSRC",
+    "BriefDescription": "The processor's L1 data cache was reloaded from a source beyond the local core's L2 due to a demand miss."
+  },
   {
     "EventCode": "0x000380000010C040",
     "EventName": "PM_INST_FROM_L2MISS_ALL",
   },
   {
     "EventCode": "0x000780000000C040",
-    "EventName": "PM_INST_FROM_L3MISS",
+    "EventName": "PM_INST_FROM_L3MISS_DSRC",
     "BriefDescription": "The processor's instruction cache was reloaded from beyond the local core's L3 due to a demand miss."
   },
+  {
+    "EventCode": "0x0007C0000000C040",
+    "EventName": "PM_DATA_FROM_L3MISS_DSRC",
+    "BriefDescription": "The processor's L1 data cache was reloaded from beyond the local core's L3 due to a demand miss."
+  },
   {
     "EventCode": "0x000780000010C040",
     "EventName": "PM_INST_FROM_L3MISS_ALL",
   },
   {
     "EventCode": "0x0003C0000000C142",
-    "EventName": "PM_MRK_DATA_FROM_L2MISS",
+    "EventName": "PM_MRK_DATA_FROM_L2MISS_DSRC",
     "BriefDescription": "The processor's L1 data cache was reloaded from a source beyond the local core's L2 due to a demand miss for a marked instruction."
   },
   {
   },
   {
     "EventCode": "0x000780000000C142",
-    "EventName": "PM_MRK_INST_FROM_L3MISS",
+    "EventName": "PM_MRK_INST_FROM_L3MISS_DSRC",
     "BriefDescription": "The processor's instruction cache was reloaded from beyond the local core's L3 due to a demand miss for a marked instruction."
   },
   {
     "EventCode": "0x0007C0000000C142",
-    "EventName": "PM_MRK_DATA_FROM_L3MISS",
+    "EventName": "PM_MRK_DATA_FROM_L3MISS_DSRC",
     "BriefDescription": "The processor's L1 data cache was reloaded from beyond the local core's L3 due to a demand miss for a marked instruction."
   },
   {

tools/perf/pmu-events/arch/riscv/mapfile.csv+2−0

@@ -15,3 +15,5 @@ · 14 unmodified lines
15	#	15	#
16	#MVENDORID-MARCHID-MIMPID,Version,Filename,EventType	16	#MVENDORID-MARCHID-MIMPID,Version,Filename,EventType
17	0x489-0x8000000000000007-0x[[:xdigit:]]+,v1,sifive/u74,core	17	0x489-0x8000000000000007-0x[[:xdigit:]]+,v1,sifive/u74,core
		18	0x5b7-0x0-0x0,v1,thead/c900-legacy,core
		19	0x67e-0x80000000db0000[89]0-0x[[:xdigit:]]+,v1,starfive/dubhe-80,core

tools/perf/pmu-events/arch/riscv/starfive/dubhe-80/common.json+172−0

@@ -0,0 +1,172 @@
	1	[
	2	{
	3	"EventName": "ACCESS_MMU_STLB",
	4	"EventCode": "0x1",
	5	"BriefDescription": "access MMU STLB"
	6	},
	7	{
	8	"EventName": "MISS_MMU_STLB",
	9	"EventCode": "0x2",
	10	"BriefDescription": "miss MMU STLB"
	11	},
	12	{
	13	"EventName": "ACCESS_MMU_PTE_C",
	14	"EventCode": "0x3",
	15	"BriefDescription": "access MMU PTE-Cache"
	16	},
	17	{
	18	"EventName": "MISS_MMU_PTE_C",
	19	"EventCode": "0x4",
	20	"BriefDescription": "miss MMU PTE-Cache"
	21	},
	22	{
	23	"EventName": "ROB_FLUSH",
	24	"EventCode": "0x5",
	25	"BriefDescription": "ROB flush (all kinds of exceptions)"
	26	},
	27	{
	28	"EventName": "BTB_PREDICTION_MISS",
	29	"EventCode": "0x6",
	30	"BriefDescription": "BTB prediction miss"
	31	},
	32	{
	33	"EventName": "ITLB_MISS",
	34	"EventCode": "0x7",
	35	"BriefDescription": "ITLB miss"
	36	},
	37	{
	38	"EventName": "SYNC_DEL_FETCH_G",
	39	"EventCode": "0x8",
	40	"BriefDescription": "SYNC delivery a fetch-group"
	41	},
	42	{
	43	"EventName": "ICACHE_MISS",
	44	"EventCode": "0x9",
	45	"BriefDescription": "ICache miss"
	46	},
	47	{
	48	"EventName": "BPU_BR_RETIRE",
	49	"EventCode": "0xA",
	50	"BriefDescription": "condition branch instruction retire"
	51	},
	52	{
	53	"EventName": "BPU_BR_MISS",
	54	"EventCode": "0xB",
	55	"BriefDescription": "condition branch instruction miss"
	56	},
	57	{
	58	"EventName": "RET_INS_RETIRE",
	59	"EventCode": "0xC",
	60	"BriefDescription": "return instruction retire"
	61	},
	62	{
	63	"EventName": "RET_INS_MISS",
	64	"EventCode": "0xD",
	65	"BriefDescription": "return instruction miss"
	66	},
	67	{
	68	"EventName": "INDIRECT_JR_MISS",
	69	"EventCode": "0xE",
	70	"BriefDescription": "indirect JR instruction miss (inlcude without target)"
	71	},
	72	{
	73	"EventName": "IBUF_VAL_ID_NORDY",
	74	"EventCode": "0xF",
	75	"BriefDescription": "IBUF valid while ID not ready"
	76	},
	77	{
	78	"EventName": "IBUF_NOVAL_ID_RDY",
	79	"EventCode": "0x10",
	80	"BriefDescription": "IBUF not valid while ID ready"
	81	},
	82	{
	83	"EventName": "REN_INT_PHY_REG_NORDY",
	84	"EventCode": "0x11",
	85	"BriefDescription": "REN integer physical register file is not ready"
	86	},
	87	{
	88	"EventName": "REN_FP_PHY_REG_NORDY",
	89	"EventCode": "0x12",
	90	"BriefDescription": "REN floating point physical register file is not ready"
	91	},
	92	{
	93	"EventName": "REN_CP_NORDY",
	94	"EventCode": "0x13",
	95	"BriefDescription": "REN checkpoint is not ready"
	96	},
	97	{
	98	"EventName": "DEC_VAL_ROB_NORDY",
	99	"EventCode": "0x14",
	100	"BriefDescription": "DEC is valid and ROB is not ready"
	101	},
	102	{
	103	"EventName": "OOD_FLUSH_LS_DEP",
	104	"EventCode": "0x15",
	105	"BriefDescription": "out of order flush due to load/store dependency"
	106	},
	107	{
	108	"EventName": "BRU_RET_IJR_INS",
	109	"EventCode": "0x16",
	110	"BriefDescription": "BRU retire an IJR instruction"
	111	},
	112	{
	113	"EventName": "ACCESS_DTLB",
	114	"EventCode": "0x17",
	115	"BriefDescription": "access DTLB"
	116	},
	117	{
	118	"EventName": "MISS_DTLB",
	119	"EventCode": "0x18",
	120	"BriefDescription": "miss DTLB"
	121	},
	122	{
	123	"EventName": "LOAD_INS_DCACHE",
	124	"EventCode": "0x19",
	125	"BriefDescription": "load instruction access DCache"
	126	},
	127	{
	128	"EventName": "LOAD_INS_MISS_DCACHE",
	129	"EventCode": "0x1A",
	130	"BriefDescription": "load instruction miss DCache"
	131	},
	132	{
	133	"EventName": "STORE_INS_DCACHE",
	134	"EventCode": "0x1B",
	135	"BriefDescription": "store/amo instruction access DCache"
	136	},
	137	{
	138	"EventName": "STORE_INS_MISS_DCACHE",
	139	"EventCode": "0x1C",
	140	"BriefDescription": "store/amo instruction miss DCache"
	141	},
	142	{
	143	"EventName": "LOAD_SCACHE",
	144	"EventCode": "0x1D",
	145	"BriefDescription": "load access SCache"
	146	},
	147	{
	148	"EventName": "STORE_SCACHE",
	149	"EventCode": "0x1E",
	150	"BriefDescription": "store access SCache"
	151	},
	152	{
	153	"EventName": "LOAD_MISS_SCACHE",
	154	"EventCode": "0x1F",
	155	"BriefDescription": "load miss SCache"
	156	},
	157	{
	158	"EventName": "STORE_MISS_SCACHE",
	159	"EventCode": "0x20",
	160	"BriefDescription": "store miss SCache"
	161	},
	162	{
	163	"EventName": "L2C_PF_REQ",
	164	"EventCode": "0x21",
	165	"BriefDescription": "L2C data-prefetcher request"
	166	},
	167	{
	168	"EventName": "L2C_PF_HIT",
	169	"EventCode": "0x22",
	170	"BriefDescription": "L2C data-prefetcher hit"
	171	}
	172	]

tools/perf/pmu-events/arch/riscv/starfive/dubhe-80/firmware.json+68−0

@@ -0,0 +1,68 @@
	1	[
	2	{
	3	"ArchStdEvent": "FW_MISALIGNED_LOAD"
	4	},
	5	{
	6	"ArchStdEvent": "FW_MISALIGNED_STORE"
	7	},
	8	{
	9	"ArchStdEvent": "FW_ACCESS_LOAD"
	10	},
	11	{
	12	"ArchStdEvent": "FW_ACCESS_STORE"
	13	},
	14	{
	15	"ArchStdEvent": "FW_ILLEGAL_INSN"
	16	},
	17	{
	18	"ArchStdEvent": "FW_SET_TIMER"
	19	},
	20	{
	21	"ArchStdEvent": "FW_IPI_SENT"
	22	},
	23	{
	24	"ArchStdEvent": "FW_IPI_RECEIVED"
	25	},
	26	{
	27	"ArchStdEvent": "FW_FENCE_I_SENT"
	28	},
	29	{
	30	"ArchStdEvent": "FW_FENCE_I_RECEIVED"
	31	},
	32	{
	33	"ArchStdEvent": "FW_SFENCE_VMA_SENT"
	34	},
	35	{
	36	"ArchStdEvent": "FW_SFENCE_VMA_RECEIVED"
	37	},
	38	{
	39	"ArchStdEvent": "FW_SFENCE_VMA_RECEIVED"
	40	},
	41	{
	42	"ArchStdEvent": "FW_SFENCE_VMA_ASID_RECEIVED"
	43	},
	44	{
	45	"ArchStdEvent": "FW_HFENCE_GVMA_SENT"
	46	},
	47	{
	48	"ArchStdEvent": "FW_HFENCE_GVMA_RECEIVED"
	49	},
	50	{
	51	"ArchStdEvent": "FW_HFENCE_GVMA_VMID_SENT"
	52	},
	53	{
	54	"ArchStdEvent": "FW_HFENCE_GVMA_VMID_RECEIVED"
	55	},
	56	{
	57	"ArchStdEvent": "FW_HFENCE_VVMA_SENT"
	58	},
	59	{
	60	"ArchStdEvent": "FW_HFENCE_VVMA_RECEIVED"
	61	},
	62	{
	63	"ArchStdEvent": "FW_HFENCE_VVMA_ASID_SENT"
	64	},
	65	{
	66	"ArchStdEvent": "FW_HFENCE_VVMA_ASID_RECEIVED"
	67	}
	68	]

tools/perf/pmu-events/arch/riscv/thead/c900-legacy/cache.json+67−0

@@ -0,0 +1,67 @@
	1	[
	2	{
	3	"EventName": "L1_ICACHE_ACCESS",
	4	"EventCode": "0x00000001",
	5	"BriefDescription": "L1 instruction cache access"
	6	},
	7	{
	8	"EventName": "L1_ICACHE_MISS",
	9	"EventCode": "0x00000002",
	10	"BriefDescription": "L1 instruction cache miss"
	11	},
	12	{
	13	"EventName": "ITLB_MISS",
	14	"EventCode": "0x00000003",
	15	"BriefDescription": "I-UTLB miss"
	16	},
	17	{
	18	"EventName": "DTLB_MISS",
	19	"EventCode": "0x00000004",
	20	"BriefDescription": "D-UTLB miss"
	21	},
	22	{
	23	"EventName": "JTLB_MISS",
	24	"EventCode": "0x00000005",
	25	"BriefDescription": "JTLB miss"
	26	},
	27	{
	28	"EventName": "L1_DCACHE_READ_ACCESS",
	29	"EventCode": "0x0000000c",
	30	"BriefDescription": "L1 data cache read access"
	31	},
	32	{
	33	"EventName": "L1_DCACHE_READ_MISS",
	34	"EventCode": "0x0000000d",
	35	"BriefDescription": "L1 data cache read miss"
	36	},
	37	{
	38	"EventName": "L1_DCACHE_WRITE_ACCESS",
	39	"EventCode": "0x0000000e",
	40	"BriefDescription": "L1 data cache write access"
	41	},
	42	{
	43	"EventName": "L1_DCACHE_WRITE_MISS",
	44	"EventCode": "0x0000000f",
	45	"BriefDescription": "L1 data cache write miss"
	46	},
	47	{
	48	"EventName": "LL_CACHE_READ_ACCESS",
	49	"EventCode": "0x00000010",
	50	"BriefDescription": "LL Cache read access"
	51	},
	52	{
	53	"EventName": "LL_CACHE_READ_MISS",
	54	"EventCode": "0x00000011",
	55	"BriefDescription": "LL Cache read miss"
	56	},
	57	{
	58	"EventName": "LL_CACHE_WRITE_ACCESS",
	59	"EventCode": "0x00000012",
	60	"BriefDescription": "LL Cache write access"
	61	},
	62	{
	63	"EventName": "LL_CACHE_WRITE_MISS",
	64	"EventCode": "0x00000013",
	65	"BriefDescription": "LL Cache write miss"
	66	}
	67	]

tools/perf/pmu-events/arch/riscv/thead/c900-legacy/firmware.json+68−0

@@ -0,0 +1,68 @@
	1	[
	2	{
	3	"ArchStdEvent": "FW_MISALIGNED_LOAD"
	4	},
	5	{
	6	"ArchStdEvent": "FW_MISALIGNED_STORE"
	7	},
	8	{
	9	"ArchStdEvent": "FW_ACCESS_LOAD"
	10	},
	11	{
	12	"ArchStdEvent": "FW_ACCESS_STORE"
	13	},
	14	{
	15	"ArchStdEvent": "FW_ILLEGAL_INSN"
	16	},
	17	{
	18	"ArchStdEvent": "FW_SET_TIMER"
	19	},
	20	{
	21	"ArchStdEvent": "FW_IPI_SENT"
	22	},
	23	{
	24	"ArchStdEvent": "FW_IPI_RECEIVED"
	25	},
	26	{
	27	"ArchStdEvent": "FW_FENCE_I_SENT"
	28	},
	29	{
	30	"ArchStdEvent": "FW_FENCE_I_RECEIVED"
	31	},
	32	{
	33	"ArchStdEvent": "FW_SFENCE_VMA_SENT"
	34	},
	35	{
	36	"ArchStdEvent": "FW_SFENCE_VMA_RECEIVED"
	37	},
	38	{
	39	"ArchStdEvent": "FW_SFENCE_VMA_RECEIVED"
	40	},
	41	{
	42	"ArchStdEvent": "FW_SFENCE_VMA_ASID_RECEIVED"
	43	},
	44	{
	45	"ArchStdEvent": "FW_HFENCE_GVMA_SENT"
	46	},
	47	{
	48	"ArchStdEvent": "FW_HFENCE_GVMA_RECEIVED"
	49	},
	50	{
	51	"ArchStdEvent": "FW_HFENCE_GVMA_VMID_SENT"
	52	},
	53	{
	54	"ArchStdEvent": "FW_HFENCE_GVMA_VMID_RECEIVED"
	55	},
	56	{
	57	"ArchStdEvent": "FW_HFENCE_VVMA_SENT"
	58	},
	59	{
	60	"ArchStdEvent": "FW_HFENCE_VVMA_RECEIVED"
	61	},
	62	{
	63	"ArchStdEvent": "FW_HFENCE_VVMA_ASID_SENT"
	64	},
	65	{
	66	"ArchStdEvent": "FW_HFENCE_VVMA_ASID_RECEIVED"
	67	}
	68	]

tools/perf/pmu-events/arch/riscv/thead/c900-legacy/instruction.json+72−0

@@ -0,0 +1,72 @@
	1	[
	2	{
	3	"EventName": "INST_BRANCH_MISPREDICT",
	4	"EventCode": "0x00000006",
	5	"BriefDescription": "Mispredicted branch instructions"
	6	},
	7	{
	8	"EventName": "INST_BRANCH",
	9	"EventCode": "0x00000007",
	10	"BriefDescription": "Retired branch instructions"
	11	},
	12	{
	13	"EventName": "INST_JMP_MISPREDICT",
	14	"EventCode": "0x00000008",
	15	"BriefDescription": "Indirect branch mispredict"
	16	},
	17	{
	18	"EventName": "INST_JMP",
	19	"EventCode": "0x00000009",
	20	"BriefDescription": "Retired jmp instructions"
	21	},
	22	{
	23	"EventName": "INST_STORE",
	24	"EventCode": "0x0000000b",
	25	"BriefDescription": "Retired store instructions"
	26	},
	27	{
	28	"EventName": "INST_ALU",
	29	"EventCode": "0x0000001d",
	30	"BriefDescription": "Retired ALU instructions"
	31	},
	32	{
	33	"EventName": "INST_LDST",
	34	"EventCode": "0x0000001e",
	35	"BriefDescription": "Retired Load/Store instructions"
	36	},
	37	{
	38	"EventName": "INST_VECTOR",
	39	"EventCode": "0x0000001f",
	40	"BriefDescription": "Retired Vector instructions"
	41	},
	42	{
	43	"EventName": "INST_CSR",
	44	"EventCode": "0x00000020",
	45	"BriefDescription": "Retired CSR instructions"
	46	},
	47	{
	48	"EventName": "INST_SYNC",
	49	"EventCode": "0x00000021",
	50	"BriefDescription": "Retired sync instructions (AMO/LR/SC instructions)"
	51	},
	52	{
	53	"EventName": "INST_UNALIGNED_ACCESS",
	54	"EventCode": "0x00000022",
	55	"BriefDescription": "Retired Store/Load instructions with unaligned memory access"
	56	},
	57	{
	58	"EventName": "INST_ECALL",
	59	"EventCode": "0x00000025",
	60	"BriefDescription": "Retired ecall instructions"
	61	},
	62	{
	63	"EventName": "INST_LONG_JP",
	64	"EventCode": "0x00000026",
	65	"BriefDescription": "Retired long jump instructions"
	66	},
	67	{
	68	"EventName": "INST_FP",
	69	"EventCode": "0x0000002a",
	70	"BriefDescription": "Retired FPU instructions"
	71	}
	72	]

tools/perf/pmu-events/arch/riscv/thead/c900-legacy/microarch.json+80−0

@@ -0,0 +1,80 @@
	1	[
	2	{
	3	"EventName": "LSU_SPEC_FAIL",
	4	"EventCode": "0x0000000a",
	5	"BriefDescription": "LSU speculation fail"
	6	},
	7	{
	8	"EventName": "IDU_RF_PIPE_FAIL",
	9	"EventCode": "0x00000014",
	10	"BriefDescription": "Instruction decode unit launch pipeline failed in RF state"
	11	},
	12	{
	13	"EventName": "IDU_RF_REG_FAIL",
	14	"EventCode": "0x00000015",
	15	"BriefDescription": "Instruction decode unit launch register file fail in RF state"
	16	},
	17	{
	18	"EventName": "IDU_RF_INSTRUCTION",
	19	"EventCode": "0x00000016",
	20	"BriefDescription": "retired instruction count of Instruction decode unit in RF (Register File) stage"
	21	},
	22	{
	23	"EventName": "LSU_4K_STALL",
	24	"EventCode": "0x00000017",
	25	"BriefDescription": "LSU stall times for long distance data access (Over 4K)",
	26	"PublicDescription": "This stall occurs when translate virtual address with page offset over 4k"
	27	},
	28	{
	29	"EventName": "LSU_OTHER_STALL",
	30	"EventCode": "0x00000018",
	31	"BriefDescription": "LSU stall times for other reasons (except the 4k stall)"
	32	},
	33	{
	34	"EventName": "LSU_SQ_OTHER_DIS",
	35	"EventCode": "0x00000019",
	36	"BriefDescription": "LSU store queue discard others"
	37	},
	38	{
	39	"EventName": "LSU_SQ_DATA_DISCARD",
	40	"EventCode": "0x0000001a",
	41	"BriefDescription": "LSU store queue discard data (uops)"
	42	},
	43	{
	44	"EventName": "BRANCH_DIRECTION_MISPREDICTION",
	45	"EventCode": "0x0000001b",
	46	"BriefDescription": "Branch misprediction in BTB"
	47	},
	48	{
	49	"EventName": "BRANCH_DIRECTION_PREDICTION",
	50	"EventCode": "0x0000001c",
	51	"BriefDescription": "All branch prediction in BTB",
	52	"PublicDescription": "This event including both successful prediction and failed prediction in BTB"
	53	},
	54	{
	55	"EventName": "INTERRUPT_ACK_COUNT",
	56	"EventCode": "0x00000023",
	57	"BriefDescription": "acknowledged interrupt count"
	58	},
	59	{
	60	"EventName": "INTERRUPT_OFF_CYCLE",
	61	"EventCode": "0x00000024",
	62	"BriefDescription": "PLIC arbitration time when the interrupt is not responded",
	63	"PublicDescription": "The arbitration time is recorded while meeting any of the following:\n- CPU is M-mode and MIE == 0\n- CPU is S-mode and delegation and SIE == 0\n"
	64	},
	65	{
	66	"EventName": "IFU_STALLED_CYCLE",
	67	"EventCode": "0x00000027",
	68	"BriefDescription": "Number of stall cycles of the instruction fetch unit (IFU)."
	69	},
	70	{
	71	"EventName": "IDU_STALLED_CYCLE",
	72	"EventCode": "0x00000028",
	73	"BriefDescription": "hpcp_backend_stall Number of stall cycles of the instruction decoding unit (IDU) and next-level pipeline unit."
	74	},
	75	{
	76	"EventName": "SYNC_STALL",
	77	"EventCode": "0x00000029",
	78	"BriefDescription": "Sync instruction stall cycle fence/fence.i/sync/sfence"
	79	}
	80	]

tools/perf/pmu-events/arch/x86/alderlake/adl-metrics.json+8−7

         "MetricName": "C9_Pkg_Residency",
         "ScaleUnit": "100%"
     },
-    {
-        "BriefDescription": "Uncore frequency per die [GHZ]",
-        "MetricExpr": "tma_info_system_socket_clks / #num_dies / duration_time / 1e9",
-        "MetricGroup": "SoC",
-        "MetricName": "UNCORE_FREQ"
-    },
     {
         "BriefDescription": "Percentage of cycles spent in System Management Interrupts.",
         "MetricExpr": "((msr@aperf@ - cycles) / msr@aperf@ if msr@smi@ > 0 else 0)",
         "ScaleUnit": "100%",
         "Unit": "cpu_atom"
     },
+    {
+        "BriefDescription": "Uncore frequency per die [GHZ]",
+        "MetricExpr": "tma_info_system_socket_clks / #num_dies / duration_time / 1e9",
+        "MetricGroup": "SoC",
+        "MetricName": "UNCORE_FREQ",
+        "Unit": "cpu_core"
+    },
     {
         "BriefDescription": "This metric represents Core fraction of cycles CPU dispatched uops on execution ports for ALU operations.",
         "MetricExpr": "(cpu_core@UOPS_DISPATCHED.PORT_0@ + cpu_core@UOPS_DISPATCHED.PORT_1@ + cpu_core@UOPS_DISPATCHED.PORT_5_11@ + cpu_core@UOPS_DISPATCHED.PORT_6@) / (5 * tma_info_core_core_clks)",
     },
     {
         "BriefDescription": "Average number of parallel data read requests to external memory",
-        "MetricExpr": "UNC_ARB_DAT_OCCUPANCY.RD / cpu_core@UNC_ARB_DAT_OCCUPANCY.RD\\,cmask\\=1@",
+        "MetricExpr": "UNC_ARB_DAT_OCCUPANCY.RD / UNC_ARB_DAT_OCCUPANCY.RD@cmask\\=1@",
         "MetricGroup": "Mem;MemoryBW;SoC",
         "MetricName": "tma_info_system_mem_parallel_reads",
         "PublicDescription": "Average number of parallel data read requests to external memory. Accounts for demand loads and L1/L2 prefetches",

tools/perf/pmu-events/arch/x86/amdzen4/memory-controller.json+101−0

@@ -0,0 +1,101 @@
	1	[
	2	{
	3	"EventName": "umc_mem_clk",
	4	"PublicDescription": "Number of memory clock cycles.",
	5	"EventCode": "0x00",
	6	"PerPkg": "1",
	7	"Unit": "UMCPMC"
	8	},
	9	{
	10	"EventName": "umc_act_cmd.all",
	11	"PublicDescription": "Number of ACTIVATE commands sent.",
	12	"EventCode": "0x05",
	13	"PerPkg": "1",
	14	"Unit": "UMCPMC"
	15	},
	16	{
	17	"EventName": "umc_act_cmd.rd",
	18	"PublicDescription": "Number of ACTIVATE commands sent for reads.",
	19	"EventCode": "0x05",
	20	"RdWrMask": "0x1",
	21	"PerPkg": "1",
	22	"Unit": "UMCPMC"
	23	},
	24	{
	25	"EventName": "umc_act_cmd.wr",
	26	"PublicDescription": "Number of ACTIVATE commands sent for writes.",
	27	"EventCode": "0x05",
	28	"RdWrMask": "0x2",
	29	"PerPkg": "1",
	30	"Unit": "UMCPMC"
	31	},
	32	{
	33	"EventName": "umc_pchg_cmd.all",
	34	"PublicDescription": "Number of PRECHARGE commands sent.",
	35	"EventCode": "0x06",
	36	"PerPkg": "1",
	37	"Unit": "UMCPMC"
	38	},
	39	{
	40	"EventName": "umc_pchg_cmd.rd",
	41	"PublicDescription": "Number of PRECHARGE commands sent for reads.",
	42	"EventCode": "0x06",
	43	"RdWrMask": "0x1",
	44	"PerPkg": "1",
	45	"Unit": "UMCPMC"
	46	},
	47	{
	48	"EventName": "umc_pchg_cmd.wr",
	49	"PublicDescription": "Number of PRECHARGE commands sent for writes.",
	50	"EventCode": "0x06",
	51	"RdWrMask": "0x2",
	52	"PerPkg": "1",
	53	"Unit": "UMCPMC"
	54	},
	55	{
	56	"EventName": "umc_cas_cmd.all",
	57	"PublicDescription": "Number of CAS commands sent.",
	58	"EventCode": "0x0a",
	59	"PerPkg": "1",
	60	"Unit": "UMCPMC"
	61	},
	62	{
	63	"EventName": "umc_cas_cmd.rd",
	64	"PublicDescription": "Number of CAS commands sent for reads.",
	65	"EventCode": "0x0a",
	66	"RdWrMask": "0x1",
	67	"PerPkg": "1",
	68	"Unit": "UMCPMC"
	69	},
	70	{
	71	"EventName": "umc_cas_cmd.wr",
	72	"PublicDescription": "Number of CAS commands sent for writes.",
	73	"EventCode": "0x0a",
	74	"RdWrMask": "0x2",
	75	"PerPkg": "1",
	76	"Unit": "UMCPMC"
	77	},
	78	{
	79	"EventName": "umc_data_slot_clks.all",
	80	"PublicDescription": "Number of clocks used by the data bus.",
	81	"EventCode": "0x14",
	82	"PerPkg": "1",
	83	"Unit": "UMCPMC"
	84	},
	85	{
	86	"EventName": "umc_data_slot_clks.rd",
	87	"PublicDescription": "Number of clocks used by the data bus for reads.",
	88	"EventCode": "0x14",
	89	"RdWrMask": "0x1",
	90	"PerPkg": "1",
	91	"Unit": "UMCPMC"
	92	},
	93	{
	94	"EventName": "umc_data_slot_clks.wr",
	95	"PublicDescription": "Number of clocks used by the data bus for writes.",
	96	"EventCode": "0x14",
	97	"RdWrMask": "0x2",
	98	"PerPkg": "1",
	99	"Unit": "UMCPMC"
	100	}
	101	]

tools/perf/pmu-events/arch/x86/amdzen4/recommended.json+84−0

@@ -330,5 +330,89 @@ · 329 unmodified lines
330	"MetricGroup": "data_fabric",	330	"MetricGroup": "data_fabric",
331	"PerPkg": "1",	331	"PerPkg": "1",
332	"ScaleUnit": "6.103515625e-5MiB"	332	"ScaleUnit": "6.103515625e-5MiB"
		333	},
		334	{
		335	"MetricName": "umc_data_bus_utilization",
		336	"BriefDescription": "Memory controller data bus utilization.",
		337	"MetricExpr": "d_ratio(umc_data_slot_clks.all / 2, umc_mem_clk)",
		338	"MetricGroup": "memory_controller",
		339	"PerPkg": "1",
		340	"ScaleUnit": "100%"
		341	},
		342	{
		343	"MetricName": "umc_cas_cmd_rate",
		344	"BriefDescription": "Memory controller CAS command rate.",
		345	"MetricExpr": "d_ratio(umc_cas_cmd.all * 1000, umc_mem_clk)",
		346	"MetricGroup": "memory_controller",
		347	"PerPkg": "1"
		348	},
		349	{
		350	"MetricName": "umc_cas_cmd_read_ratio",
		351	"BriefDescription": "Ratio of memory controller CAS commands for reads.",
		352	"MetricExpr": "d_ratio(umc_cas_cmd.rd, umc_cas_cmd.all)",
		353	"MetricGroup": "memory_controller",
		354	"PerPkg": "1",
		355	"ScaleUnit": "100%"
		356	},
		357	{
		358	"MetricName": "umc_cas_cmd_write_ratio",
		359	"BriefDescription": "Ratio of memory controller CAS commands for writes.",
		360	"MetricExpr": "d_ratio(umc_cas_cmd.wr, umc_cas_cmd.all)",
		361	"MetricGroup": "memory_controller",
		362	"PerPkg": "1",
		363	"ScaleUnit": "100%"
		364	},
		365	{
		366	"MetricName": "umc_mem_read_bandwidth",
		367	"BriefDescription": "Estimated memory read bandwidth.",
		368	"MetricExpr": "(umc_cas_cmd.rd * 64) / 1e6 / duration_time",
		369	"MetricGroup": "memory_controller",
		370	"PerPkg": "1",
		371	"ScaleUnit": "1MB/s"
		372	},
		373	{
		374	"MetricName": "umc_mem_write_bandwidth",
		375	"BriefDescription": "Estimated memory write bandwidth.",
		376	"MetricExpr": "(umc_cas_cmd.wr * 64) / 1e6 / duration_time",
		377	"MetricGroup": "memory_controller",
		378	"PerPkg": "1",
		379	"ScaleUnit": "1MB/s"
		380	},
		381	{
		382	"MetricName": "umc_mem_bandwidth",
		383	"BriefDescription": "Estimated combined memory bandwidth.",
		384	"MetricExpr": "(umc_cas_cmd.all * 64) / 1e6 / duration_time",
		385	"MetricGroup": "memory_controller",
		386	"PerPkg": "1",
		387	"ScaleUnit": "1MB/s"
		388	},
		389	{
		390	"MetricName": "umc_cas_cmd_read_ratio",
		391	"BriefDescription": "Ratio of memory controller CAS commands for reads.",
		392	"MetricExpr": "d_ratio(umc_cas_cmd.rd, umc_cas_cmd.all)",
		393	"MetricGroup": "memory_controller",
		394	"PerPkg": "1",
		395	"ScaleUnit": "100%"
		396	},
		397	{
		398	"MetricName": "umc_cas_cmd_rate",
		399	"BriefDescription": "Memory controller CAS command rate.",
		400	"MetricExpr": "d_ratio(umc_cas_cmd.all * 1000, umc_mem_clk)",
		401	"MetricGroup": "memory_controller",
		402	"PerPkg": "1"
		403	},
		404	{
		405	"MetricName": "umc_activate_cmd_rate",
		406	"BriefDescription": "Memory controller ACTIVATE command rate.",
		407	"MetricExpr": "d_ratio(umc_act_cmd.all * 1000, umc_mem_clk)",
		408	"MetricGroup": "memory_controller",
		409	"PerPkg": "1"
		410	},
		411	{
		412	"MetricName": "umc_precharge_cmd_rate",
		413	"BriefDescription": "Memory controller PRECHARGE command rate.",
		414	"MetricExpr": "d_ratio(umc_pchg_cmd.all * 1000, umc_mem_clk)",
		415	"MetricGroup": "memory_controller",
		416	"PerPkg": "1"
333	}	417	}
334	]	418	]

tools/perf/pmu-events/arch/x86/cascadelakex/clx-metrics.json+6−0

         "MetricName": "uncore_frequency",
         "ScaleUnit": "1GHz"
     },
+    {
+        "BriefDescription": "Intel(R) Ultra Path Interconnect (UPI) data receive bandwidth (MB/sec)",
+        "MetricExpr": "UNC_UPI_RxL_FLITS.ALL_DATA * 7.111111111111111 / 1e6 / duration_time",
+        "MetricName": "upi_data_receive_bw",
+        "ScaleUnit": "1MB/s"
+    },
     {
         "BriefDescription": "Intel(R) Ultra Path Interconnect (UPI) data transmit bandwidth (MB/sec)",
         "MetricExpr": "UNC_UPI_TxL_FLITS.ALL_DATA * 7.111111111111111 / 1e6 / duration_time",

tools/perf/pmu-events/arch/x86/emeraldrapids/floating-point.json+24−3

         "UMask": "0x10"
     },
     {
-        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_0",
+        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_0 [This event is alias to FP_ARITH_DISPATCHED.V0]",
         "EventCode": "0xb3",
         "EventName": "FP_ARITH_DISPATCHED.PORT_0",
         "SampleAfterValue": "2000003",
         "UMask": "0x1"
     },
     {
-        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_1",
+        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_1 [This event is alias to FP_ARITH_DISPATCHED.V1]",
         "EventCode": "0xb3",
         "EventName": "FP_ARITH_DISPATCHED.PORT_1",
         "SampleAfterValue": "2000003",
         "UMask": "0x2"
     },
     {
-        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_5",
+        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_5 [This event is alias to FP_ARITH_DISPATCHED.V2]",
         "EventCode": "0xb3",
         "EventName": "FP_ARITH_DISPATCHED.PORT_5",
         "SampleAfterValue": "2000003",
         "UMask": "0x4"
     },
+    {
+        "BriefDescription": "FP_ARITH_DISPATCHED.V0 [This event is alias to FP_ARITH_DISPATCHED.PORT_0]",
+        "EventCode": "0xb3",
+        "EventName": "FP_ARITH_DISPATCHED.V0",
+        "SampleAfterValue": "2000003",
+        "UMask": "0x1"
+    },
+    {
+        "BriefDescription": "FP_ARITH_DISPATCHED.V1 [This event is alias to FP_ARITH_DISPATCHED.PORT_1]",
+        "EventCode": "0xb3",
+        "EventName": "FP_ARITH_DISPATCHED.V1",
+        "SampleAfterValue": "2000003",
+        "UMask": "0x2"
+    },
+    {
+        "BriefDescription": "FP_ARITH_DISPATCHED.V2 [This event is alias to FP_ARITH_DISPATCHED.PORT_5]",
+        "EventCode": "0xb3",
+        "EventName": "FP_ARITH_DISPATCHED.V2",
+        "SampleAfterValue": "2000003",
+        "UMask": "0x4"
+    },
     {
         "BriefDescription": "Counts number of SSE/AVX computational 128-bit packed double precision floating-point instructions retired; some instructions will count twice as noted below.  Each count represents 2 computation operations, one for each element.  Applies to SSE* and AVX* packed double precision floating-point instructions: ADD SUB HADD HSUB SUBADD MUL DIV MIN MAX SQRT DPP FM(N)ADD/SUB.  DPP and FM(N)ADD/SUB instructions count twice as they perform 2 calculations per element.",
         "EventCode": "0xc7",

tools/perf/pmu-events/arch/x86/emeraldrapids/pipeline.json+1−17

@@ -1,20 +1,4 @@
1	[	1	[
2	{
3	"BriefDescription": "AMX retired arithmetic BF16 operations.",
4	"EventCode": "0xce",
5	"EventName": "AMX_OPS_RETIRED.BF16",
6	"PublicDescription": "Number of AMX-based retired arithmetic bfloat16 (BF16) floating-point operations. Counts TDPBF16PS FP instructions. SW to use operation multiplier of 4",
7	"SampleAfterValue": "1000003",
8	"UMask": "0x2"
9	},
10	{
11	"BriefDescription": "AMX retired arithmetic integer 8-bit operations.",
12	"EventCode": "0xce",
13	"EventName": "AMX_OPS_RETIRED.INT8",
14	"PublicDescription": "Number of AMX-based retired arithmetic integer operations of 8-bit width source operands. Counts TDPB[SS,UU,US,SU]D instructions. SW should use operation multiplier of 8.",
15	"SampleAfterValue": "1000003",
16	"UMask": "0x1"
17	},
18	{	2	{
19	"BriefDescription": "This event is deprecated. Refer to new event ARITH.DIV_ACTIVE",	3	"BriefDescription": "This event is deprecated. Refer to new event ARITH.DIV_ACTIVE",
20	"CounterMask": "1",	4	"CounterMask": "1",
@@ -505,7 +489,7 @@ · 484 unmodified lines
505	"UMask": "0x1"	489	"UMask": "0x1"
506	},	490	},
507	{	491	{
508	"BriefDescription": "INT_MISC.UNKNOWN_BRANCH_CYCLES",	492	"BriefDescription": "Bubble cycles of BAClear (Unknown Branch).",
509	"EventCode": "0xad",	493	"EventCode": "0xad",
510	"EventName": "INT_MISC.UNKNOWN_BRANCH_CYCLES",	494	"EventName": "INT_MISC.UNKNOWN_BRANCH_CYCLES",
511	"MSRIndex": "0x3F7",	495	"MSRIndex": "0x3F7",

tools/perf/pmu-events/arch/x86/emeraldrapids/uncore-interconnect.json+4−4

@@ -4825,11 +4825,11 @@ · 4824 unmodified lines
4825	"Unit": "M3UPI"	4825	"Unit": "M3UPI"
4826	},	4826	},
4827	{	4827	{
4828	"BriefDescription": "Number of allocations into the CRS Egress used to queue up requests destined to the mesh (AD Bouncable)",	4828	"BriefDescription": "Number of allocations into the CRS Egress used to queue up requests destined to the mesh (AD Bounceable)",
4829	"EventCode": "0x47",	4829	"EventCode": "0x47",
4830	"EventName": "UNC_MDF_CRS_TxR_INSERTS.AD_BNC",	4830	"EventName": "UNC_MDF_CRS_TxR_INSERTS.AD_BNC",
4831	"PerPkg": "1",	4831	"PerPkg": "1",
4832	"PublicDescription": "AD Bouncable : Number of allocations into the CRS Egress",	4832	"PublicDescription": "AD Bounceable : Number of allocations into the CRS Egress",
4833	"UMask": "0x1",	4833	"UMask": "0x1",
4834	"Unit": "MDF"	4834	"Unit": "MDF"
4835	},	4835	},
@@ -4861,11 +4861,11 @@ · 25 unmodified lines
4861	"Unit": "MDF"	4861	"Unit": "MDF"
4862	},	4862	},
4863	{	4863	{
4864	"BriefDescription": "Number of allocations into the CRS Egress used to queue up requests destined to the mesh (BL Bouncable)",	4864	"BriefDescription": "Number of allocations into the CRS Egress used to queue up requests destined to the mesh (BL Bounceable)",
4865	"EventCode": "0x47",	4865	"EventCode": "0x47",
4866	"EventName": "UNC_MDF_CRS_TxR_INSERTS.BL_BNC",	4866	"EventName": "UNC_MDF_CRS_TxR_INSERTS.BL_BNC",
4867	"PerPkg": "1",	4867	"PerPkg": "1",
4868	"PublicDescription": "BL Bouncable : Number of allocations into the CRS Egress",	4868	"PublicDescription": "BL Bounceable : Number of allocations into the CRS Egress",
4869	"UMask": "0x4",	4869	"UMask": "0x4",
4870	"Unit": "MDF"	4870	"Unit": "MDF"
4871	},	4871	},

tools/perf/pmu-events/arch/x86/emeraldrapids/uncore-io.json+30−0

@@ -1185,6 +1185,36 @@ · 1184 unmodified lines
1185	"UMask": "0x70ff010",	1185	"UMask": "0x70ff010",
1186	"Unit": "IIO"	1186	"Unit": "IIO"
1187	},	1187	},
		1188	{
		1189	"BriefDescription": ": IOTLB Hits to a 1G Page",
		1190	"EventCode": "0x40",
		1191	"EventName": "UNC_IIO_IOMMU0.1G_HITS",
		1192	"PerPkg": "1",
		1193	"PortMask": "0x0000",
		1194	"PublicDescription": ": IOTLB Hits to a 1G Page : Counts if a transaction to a 1G page, on its first lookup, hits the IOTLB.",
		1195	"UMask": "0x10",
		1196	"Unit": "IIO"
		1197	},
		1198	{
		1199	"BriefDescription": ": IOTLB Hits to a 2M Page",
		1200	"EventCode": "0x40",
		1201	"EventName": "UNC_IIO_IOMMU0.2M_HITS",
		1202	"PerPkg": "1",
		1203	"PortMask": "0x0000",
		1204	"PublicDescription": ": IOTLB Hits to a 2M Page : Counts if a transaction to a 2M page, on its first lookup, hits the IOTLB.",
		1205	"UMask": "0x8",
		1206	"Unit": "IIO"
		1207	},
		1208	{
		1209	"BriefDescription": ": IOTLB Hits to a 4K Page",
		1210	"EventCode": "0x40",
		1211	"EventName": "UNC_IIO_IOMMU0.4K_HITS",
		1212	"PerPkg": "1",
		1213	"PortMask": "0x0000",
		1214	"PublicDescription": ": IOTLB Hits to a 4K Page : Counts if a transaction to a 4K page, on its first lookup, hits the IOTLB.",
		1215	"UMask": "0x4",
		1216	"Unit": "IIO"
		1217	},
1188	{	1218	{
1189	"BriefDescription": ": Context cache hits",	1219	"BriefDescription": ": Context cache hits",
1190	"EventCode": "0x40",	1220	"EventCode": "0x40",

tools/perf/pmu-events/arch/x86/icelakex/icx-metrics.json+6−0

         "MetricName": "uncore_frequency",
         "ScaleUnit": "1GHz"
     },
+    {
+        "BriefDescription": "Intel(R) Ultra Path Interconnect (UPI) data receive bandwidth (MB/sec)",
+        "MetricExpr": "UNC_UPI_RxL_FLITS.ALL_DATA * 7.111111111111111 / 1e6 / duration_time",
+        "MetricName": "upi_data_receive_bw",
+        "ScaleUnit": "1MB/s"
+    },
     {
         "BriefDescription": "Intel(R) Ultra Path Interconnect (UPI) data transmit bandwidth (MB/sec)",
         "MetricExpr": "UNC_UPI_TxL_FLITS.ALL_DATA * 7.111111111111111 / 1e6 / duration_time",

tools/perf/pmu-events/arch/x86/icelakex/other.json+1−1

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	"BriefDescription": "Core cycles where the core was running in a manner where Turbo may be clipped to the AVX512 turbo schedule.",	19	"BriefDescription": "Core cycles where the core was running in a manner where Turbo may be clipped to the AVX512 turbo schedule.",
20	"EventCode": "0x28",	20	"EventCode": "0x28",
21	"EventName": "CORE_POWER.LVL2_TURBO_LICENSE",	21	"EventName": "CORE_POWER.LVL2_TURBO_LICENSE",
22	"PublicDescription": "Core cycles where the core was running with power-delivery for license level 2 (introduced in Skylake Server microarchtecture). This includes high current AVX 512-bit instructions.",	22	"PublicDescription": "Core cycles where the core was running with power-delivery for license level 2 (introduced in Skylake Server microarchitecture). This includes high current AVX 512-bit instructions.",
23	"SampleAfterValue": "200003",	23	"SampleAfterValue": "200003",
24	"UMask": "0x20"	24	"UMask": "0x20"
25	},	25	},

tools/perf/pmu-events/arch/x86/icelakex/pipeline.json+1−1

@@ -519,7 +519,7 @@ · 518 unmodified lines
519	"BriefDescription": "Cycles when Reservation Station (RS) is empty for the thread",	519	"BriefDescription": "Cycles when Reservation Station (RS) is empty for the thread",
520	"EventCode": "0x5e",	520	"EventCode": "0x5e",
521	"EventName": "RS_EVENTS.EMPTY_CYCLES",	521	"EventName": "RS_EVENTS.EMPTY_CYCLES",
522	"PublicDescription": "Counts cycles during which the reservation station (RS) is empty for this logical processor. This is usually caused when the front-end pipeline runs into stravation periods (e.g. branch mispredictions or i-cache misses)",	522	"PublicDescription": "Counts cycles during which the reservation station (RS) is empty for this logical processor. This is usually caused when the front-end pipeline runs into starvation periods (e.g. branch mispredictions or i-cache misses)",
523	"SampleAfterValue": "1000003",	523	"SampleAfterValue": "1000003",
524	"UMask": "0x1"	524	"UMask": "0x1"
525	},	525	},

tools/perf/pmu-events/arch/x86/icelakex/uncore-interconnect.json+3−3

@@ -38,7 +38,7 @@ · 37 unmodified lines
38	"EventCode": "0x10",	38	"EventCode": "0x10",
39	"EventName": "UNC_I_COHERENT_OPS.CLFLUSH",	39	"EventName": "UNC_I_COHERENT_OPS.CLFLUSH",
40	"PerPkg": "1",	40	"PerPkg": "1",
41	"PublicDescription": "Coherent Ops : CLFlush : Counts the number of coherency related operations servied by the IRP",	41	"PublicDescription": "Coherent Ops : CLFlush : Counts the number of coherency related operations serviced by the IRP",
42	"UMask": "0x80",	42	"UMask": "0x80",
43	"Unit": "IRP"	43	"Unit": "IRP"
44	},	44	},
@@ -65,7 +65,7 @@ · 20 unmodified lines
65	"EventCode": "0x10",	65	"EventCode": "0x10",
66	"EventName": "UNC_I_COHERENT_OPS.WBMTOI",	66	"EventName": "UNC_I_COHERENT_OPS.WBMTOI",
67	"PerPkg": "1",	67	"PerPkg": "1",
68	"PublicDescription": "Coherent Ops : WbMtoI : Counts the number of coherency related operations servied by the IRP",	68	"PublicDescription": "Coherent Ops : WbMtoI : Counts the number of coherency related operations serviced by the IRP",
69	"UMask": "0x40",	69	"UMask": "0x40",
70	"Unit": "IRP"	70	"Unit": "IRP"
71	},	71	},
@@ -454,7 +454,7 @@ · 382 unmodified lines
454	"EventCode": "0x11",	454	"EventCode": "0x11",
455	"EventName": "UNC_I_TRANSACTIONS.WRITES",	455	"EventName": "UNC_I_TRANSACTIONS.WRITES",
456	"PerPkg": "1",	456	"PerPkg": "1",
457	"PublicDescription": "Inbound Transaction Count : Writes : Counts the number of Inbound transactions from the IRP to the Uncore. This can be filtered based on request type in addition to the source queue. Note the special filtering equation. We do OR-reduction on the request type. If the SOURCE bit is set, then we also do AND qualification based on the source portID. : Trackes only write requests. Each write request should have a prefetch, so there is no need to explicitly track these requests. For writes that are tickled and have to retry, the counter will be incremented for each retry.",	457	"PublicDescription": "Inbound Transaction Count : Writes : Counts the number of Inbound transactions from the IRP to the Uncore. This can be filtered based on request type in addition to the source queue. Note the special filtering equation. We do OR-reduction on the request type. If the SOURCE bit is set, then we also do AND qualification based on the source portID. : Tracks only write requests. Each write request should have a prefetch, so there is no need to explicitly track these requests. For writes that are tickled and have to retry, the counter will be incremented for each retry.",
458	"UMask": "0x2",	458	"UMask": "0x2",
459	"Unit": "IRP"	459	"Unit": "IRP"
460	},	460	},

tools/perf/pmu-events/arch/x86/mapfile.csv+3−3

tools/perf/pmu-events/arch/x86/rocketlake/rkl-metrics.json+1−1

@@ -985,7 +985,7 @@ · 984 unmodified lines
985	},	985	},
986	{	986	{
987	"BriefDescription": "Average number of parallel data read requests to external memory",	987	"BriefDescription": "Average number of parallel data read requests to external memory",
988	"MetricExpr": "UNC_ARB_DAT_OCCUPANCY.RD / cpu@UNC_ARB_DAT_OCCUPANCY.RD\\,cmask\\=1@",	988	"MetricExpr": "UNC_ARB_DAT_OCCUPANCY.RD / UNC_ARB_DAT_OCCUPANCY.RD@cmask\\=1@",
989	"MetricGroup": "Mem;MemoryBW;SoC",	989	"MetricGroup": "Mem;MemoryBW;SoC",
990	"MetricName": "tma_info_system_mem_parallel_reads",	990	"MetricName": "tma_info_system_mem_parallel_reads",
991	"PublicDescription": "Average number of parallel data read requests to external memory. Accounts for demand loads and L1/L2 prefetches"	991	"PublicDescription": "Average number of parallel data read requests to external memory. Accounts for demand loads and L1/L2 prefetches"

tools/perf/pmu-events/arch/x86/sapphirerapids/floating-point.json+24−3

         "UMask": "0x10"
     },
     {
-        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_0",
+        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_0 [This event is alias to FP_ARITH_DISPATCHED.V0]",
         "EventCode": "0xb3",
         "EventName": "FP_ARITH_DISPATCHED.PORT_0",
         "SampleAfterValue": "2000003",
         "UMask": "0x1"
     },
     {
-        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_1",
+        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_1 [This event is alias to FP_ARITH_DISPATCHED.V1]",
         "EventCode": "0xb3",
         "EventName": "FP_ARITH_DISPATCHED.PORT_1",
         "SampleAfterValue": "2000003",
         "UMask": "0x2"
     },
     {
-        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_5",
+        "BriefDescription": "FP_ARITH_DISPATCHED.PORT_5 [This event is alias to FP_ARITH_DISPATCHED.V2]",
         "EventCode": "0xb3",
         "EventName": "FP_ARITH_DISPATCHED.PORT_5",
         "SampleAfterValue": "2000003",
         "UMask": "0x4"
     },
+    {
+        "BriefDescription": "FP_ARITH_DISPATCHED.V0 [This event is alias to FP_ARITH_DISPATCHED.PORT_0]",
+        "EventCode": "0xb3",
+        "EventName": "FP_ARITH_DISPATCHED.V0",
+        "SampleAfterValue": "2000003",
+        "UMask": "0x1"
+    },
+    {
+        "BriefDescription": "FP_ARITH_DISPATCHED.V1 [This event is alias to FP_ARITH_DISPATCHED.PORT_1]",
+        "EventCode": "0xb3",
+        "EventName": "FP_ARITH_DISPATCHED.V1",
+        "SampleAfterValue": "2000003",
+        "UMask": "0x2"
+    },
+    {
+        "BriefDescription": "FP_ARITH_DISPATCHED.V2 [This event is alias to FP_ARITH_DISPATCHED.PORT_5]",
+        "EventCode": "0xb3",
+        "EventName": "FP_ARITH_DISPATCHED.V2",
+        "SampleAfterValue": "2000003",
+        "UMask": "0x4"
+    },
     {
         "BriefDescription": "Counts number of SSE/AVX computational 128-bit packed double precision floating-point instructions retired; some instructions will count twice as noted below.  Each count represents 2 computation operations, one for each element.  Applies to SSE* and AVX* packed double precision floating-point instructions: ADD SUB HADD HSUB SUBADD MUL DIV MIN MAX SQRT DPP FM(N)ADD/SUB.  DPP and FM(N)ADD/SUB instructions count twice as they perform 2 calculations per element.",
         "EventCode": "0xc7",

tools/perf/pmu-events/arch/x86/sapphirerapids/pipeline.json+1−1

@@ -505,7 +505,7 @@ · 504 unmodified lines
505	"UMask": "0x1"	505	"UMask": "0x1"
506	},	506	},
507	{	507	{
508	"BriefDescription": "INT_MISC.UNKNOWN_BRANCH_CYCLES",	508	"BriefDescription": "Bubble cycles of BAClear (Unknown Branch).",
509	"EventCode": "0xad",	509	"EventCode": "0xad",
510	"EventName": "INT_MISC.UNKNOWN_BRANCH_CYCLES",	510	"EventName": "INT_MISC.UNKNOWN_BRANCH_CYCLES",
511	"MSRIndex": "0x3F7",	511	"MSRIndex": "0x3F7",

tools/perf/pmu-events/arch/x86/sapphirerapids/spr-metrics.json+6−0

         "MetricName": "uncore_frequency",
         "ScaleUnit": "1GHz"
     },
+    {
+        "BriefDescription": "Intel(R) Ultra Path Interconnect (UPI) data receive bandwidth (MB/sec)",
+        "MetricExpr": "UNC_UPI_RxL_FLITS.ALL_DATA * 7.111111111111111 / 1e6 / duration_time",
+        "MetricName": "upi_data_receive_bw",
+        "ScaleUnit": "1MB/s"
+    },
     {
         "BriefDescription": "Intel(R) Ultra Path Interconnect (UPI) data transmit bandwidth (MB/sec)",
         "MetricExpr": "UNC_UPI_TxL_FLITS.ALL_DATA * 7.111111111111111 / 1e6 / duration_time",

tools/perf/pmu-events/arch/x86/sapphirerapids/uncore-interconnect.json+4−4

@@ -4825,11 +4825,11 @@ · 4824 unmodified lines
4825	"Unit": "M3UPI"	4825	"Unit": "M3UPI"
4826	},	4826	},
4827	{	4827	{
4828	"BriefDescription": "Number of allocations into the CRS Egress used to queue up requests destined to the mesh (AD Bouncable)",	4828	"BriefDescription": "Number of allocations into the CRS Egress used to queue up requests destined to the mesh (AD Bounceable)",
4829	"EventCode": "0x47",	4829	"EventCode": "0x47",
4830	"EventName": "UNC_MDF_CRS_TxR_INSERTS.AD_BNC",	4830	"EventName": "UNC_MDF_CRS_TxR_INSERTS.AD_BNC",
4831	"PerPkg": "1",	4831	"PerPkg": "1",
4832	"PublicDescription": "AD Bouncable : Number of allocations into the CRS Egress",	4832	"PublicDescription": "AD Bounceable : Number of allocations into the CRS Egress",
4833	"UMask": "0x1",	4833	"UMask": "0x1",
4834	"Unit": "MDF"	4834	"Unit": "MDF"
4835	},	4835	},
@@ -4861,11 +4861,11 @@ · 25 unmodified lines
4861	"Unit": "MDF"	4861	"Unit": "MDF"
4862	},	4862	},
4863	{	4863	{
4864	"BriefDescription": "Number of allocations into the CRS Egress used to queue up requests destined to the mesh (BL Bouncable)",	4864	"BriefDescription": "Number of allocations into the CRS Egress used to queue up requests destined to the mesh (BL Bounceable)",
4865	"EventCode": "0x47",	4865	"EventCode": "0x47",
4866	"EventName": "UNC_MDF_CRS_TxR_INSERTS.BL_BNC",	4866	"EventName": "UNC_MDF_CRS_TxR_INSERTS.BL_BNC",
4867	"PerPkg": "1",	4867	"PerPkg": "1",
4868	"PublicDescription": "BL Bouncable : Number of allocations into the CRS Egress",	4868	"PublicDescription": "BL Bounceable : Number of allocations into the CRS Egress",
4869	"UMask": "0x4",	4869	"UMask": "0x4",
4870	"Unit": "MDF"	4870	"Unit": "MDF"
4871	},	4871	},

tools/perf/pmu-events/arch/x86/sapphirerapids/uncore-io.json+30−0

@@ -1249,6 +1249,36 @@ · 1248 unmodified lines
1249	"UMask": "0x70ff010",	1249	"UMask": "0x70ff010",
1250	"Unit": "IIO"	1250	"Unit": "IIO"
1251	},	1251	},
		1252	{
		1253	"BriefDescription": ": IOTLB Hits to a 1G Page",
		1254	"EventCode": "0x40",
		1255	"EventName": "UNC_IIO_IOMMU0.1G_HITS",
		1256	"PerPkg": "1",
		1257	"PortMask": "0x0000",
		1258	"PublicDescription": ": IOTLB Hits to a 1G Page : Counts if a transaction to a 1G page, on its first lookup, hits the IOTLB.",
		1259	"UMask": "0x10",
		1260	"Unit": "IIO"
		1261	},
		1262	{
		1263	"BriefDescription": ": IOTLB Hits to a 2M Page",
		1264	"EventCode": "0x40",
		1265	"EventName": "UNC_IIO_IOMMU0.2M_HITS",
		1266	"PerPkg": "1",
		1267	"PortMask": "0x0000",
		1268	"PublicDescription": ": IOTLB Hits to a 2M Page : Counts if a transaction to a 2M page, on its first lookup, hits the IOTLB.",
		1269	"UMask": "0x8",
		1270	"Unit": "IIO"
		1271	},
		1272	{
		1273	"BriefDescription": ": IOTLB Hits to a 4K Page",
		1274	"EventCode": "0x40",
		1275	"EventName": "UNC_IIO_IOMMU0.4K_HITS",
		1276	"PerPkg": "1",
		1277	"PortMask": "0x0000",
		1278	"PublicDescription": ": IOTLB Hits to a 4K Page : Counts if a transaction to a 4K page, on its first lookup, hits the IOTLB.",
		1279	"UMask": "0x4",
		1280	"Unit": "IIO"
		1281	},
1252	{	1282	{
1253	"BriefDescription": ": Context cache hits",	1283	"BriefDescription": ": Context cache hits",
1254	"EventCode": "0x40",	1284	"EventCode": "0x40",

tools/perf/pmu-events/arch/x86/skylakex/skx-metrics.json+6−0

         "MetricName": "uncore_frequency",
         "ScaleUnit": "1GHz"
     },
+    {
+        "BriefDescription": "Intel(R) Ultra Path Interconnect (UPI) data receive bandwidth (MB/sec)",
+        "MetricExpr": "UNC_UPI_RxL_FLITS.ALL_DATA * 7.111111111111111 / 1e6 / duration_time",
+        "MetricName": "upi_data_receive_bw",
+        "ScaleUnit": "1MB/s"
+    },
     {
         "BriefDescription": "Intel(R) Ultra Path Interconnect (UPI) data transmit bandwidth (MB/sec)",
         "MetricExpr": "UNC_UPI_TxL_FLITS.ALL_DATA * 7.111111111111111 / 1e6 / duration_time",

tools/perf/pmu-events/jevents.py+3−1

   """Return the length of s a C string
   This doesn't handle all escape characters properly. It first assumes
-  all \ are for escaping, it then adjusts as it will have over counted
+  all \\ are for escaping, it then adjusts as it will have over counted
   \\. The code uses \000 rather than \0 as a terminator as an adjacent
   number would be folded into a string of \0 (ie. "\0" + "5" doesn't
   equal a terminator followed by the number 5 but the escape of
           'imx8_ddr': 'imx8_ddr',
           'L3PMC': 'amd_l3',
           'DFPMC': 'amd_df',
+          'UMCPMC': 'amd_umc',
           'cpu_core': 'cpu_core',
           'cpu_atom': 'cpu_atom',
           'ali_drw': 'ali_drw',
         ('SampleAfterValue', 'period='),
         ('UMask', 'umask='),
         ('NodeType', 'type='),
+        ('RdWrMask', 'rdwrmask='),
     ]
     for key, value in event_fields:
       if key in jd and jd[key] != '0':

tools/perf/scripts/python/arm-cs-trace-disasm.py+16−14

 # Initialize global dicts and regular expression
 disasm_cache = dict()
 cpu_data = dict()
-disasm_re = re.compile("^\s*([0-9a-fA-F]+):")
+disasm_re = re.compile(r"^\s*([0-9a-fA-F]+):")
-disasm_func_re = re.compile("^\s*([0-9a-fA-F]+)\s.*:")
+disasm_func_re = re.compile(r"^\s*([0-9a-fA-F]+)\s.*:")
 cache_size = 64*1024
 glb_source_file_name	= None
 	dso_end = get_optional(param_dict, "dso_map_end")
 	symbol = get_optional(param_dict, "symbol")
+	cpu = sample["cpu"]
+	ip = sample["ip"]
+	addr = sample["addr"]
+	# Initialize CPU data if it's empty, and directly return back
+	# if this is the first tracing event for this CPU.
+	if (cpu_data.get(str(cpu) + 'addr') == None):
+		cpu_data[str(cpu) + 'addr'] = addr
+		return
 	if (options.verbose == True):
 		print("Event type: %s" % name)
 		print_sample(sample)
 	if (name[0:8] != "branches"):
 		return
-	cpu = sample["cpu"]
-	ip = sample["ip"]
-	addr = sample["addr"]
-	# Initialize CPU data if it's empty, and directly return back
-	# if this is the first tracing event for this CPU.
-	if (cpu_data.get(str(cpu) + 'addr') == None):
-		cpu_data[str(cpu) + 'addr'] = addr
-		return
 	# The format for packet is:
 	#
 	#		  +------------+------------+------------+
 	if (options.objdump_name != None):
 		# It doesn't need to decrease virtual memory offset for disassembly
-		# for kernel dso, so in this case we set vm_start to zero.
+		# for kernel dso and executable file dso, so in this case we set
-		if (dso == "[kernel.kallsyms]"):
+		# vm_start to zero.
+		if (dso == "[kernel.kallsyms]" or dso_start == 0x400000):
 			dso_vm_start = 0
 		else:
 			dso_vm_start = int(dso_start)

tools/perf/scripts/python/compaction-times.py+1−1

@@ -260,7 +260,7 @@ def pr_help(): · 259 unmodified lines
260		260
261	comm_re = None	261	comm_re = None
262	pid_re = None	262	pid_re = None
263	pid_regex = "^(\d)-(\d)$\|^(\d*)$"	263	pid_regex = r"^(\d)-(\d)$\|^(\d*)$"
264		264
265	opt_proc = popt.DISP_DFL	265	opt_proc = popt.DISP_DFL
266	opt_disp = topt.DISP_ALL	266	opt_disp = topt.DISP_ALL

tools/perf/scripts/python/exported-sql-viewer.py+2−2

@@ -677,8 +677,8 @@ class CallGraphModelBase(TreeModel): · 676 unmodified lines
677	# sqlite supports GLOB (text only) which uses * and ? and is case sensitive	677	# sqlite supports GLOB (text only) which uses * and ? and is case sensitive
678	if not self.glb.dbref.is_sqlite3:	678	if not self.glb.dbref.is_sqlite3:
679	# Escape % and _	679	# Escape % and _
680	s = value.replace("%", "\%")	680	s = value.replace("%", "\\%")
681	s = s.replace("_", "\_")	681	s = s.replace("_", "\\_")
682	# Translate * and ? into SQL LIKE pattern characters % and _	682	# Translate * and ? into SQL LIKE pattern characters % and _
683	trans = string.maketrans("*?", "%_")	683	trans = string.maketrans("*?", "%_")
684	match = " LIKE '" + str(s).translate(trans) + "'"	684	match = " LIKE '" + str(s).translate(trans) + "'"

tools/perf/tests/Build+14−0

@@ -77,3 +77,17 @@ CFLAGS_python-use.o += -DPYTHONPATH="BUILD_STR($(OUTPUT)python)" -DPYTHON="BUI · 76 unmodified lines
77	CFLAGS_dwarf-unwind.o += -fno-optimize-sibling-calls	77	CFLAGS_dwarf-unwind.o += -fno-optimize-sibling-calls
78		78
79	perf-y += workloads/	79	perf-y += workloads/
		80
		81	ifdef SHELLCHECK
		82	SHELL_TESTS := $(shell find tests/shell -executable -type f -name '*.sh')
		83	TEST_LOGS := $(SHELL_TESTS:tests/shell/%=shell/%.shellcheck_log)
		84	else
		85	SHELL_TESTS :=
		86	TEST_LOGS :=
		87	endif
		88
		89	$(OUTPUT)%.shellcheck_log: %
		90	$(call rule_mkdir)
		91	$(Q)$(call echo-cmd,test)shellcheck -a -S warning "$<" > $@ \|\| (cat $@ && rm $@ && false)
		92
		93	perf-y += $(TEST_LOGS)

tools/perf/tests/attr.c+1−1

@@ -188,7 +188,7 @@ static int test__attr(struct test_suite *test __maybe_unused, int subtest __mayb · 187 unmodified lines
188	if (perf_pmus__num_core_pmus() > 1) {	188	if (perf_pmus__num_core_pmus() > 1) {
189	/*	189	/*
190	* TODO: Attribute tests hard code the PMU type. If there are >1	190	* TODO: Attribute tests hard code the PMU type. If there are >1
191	* core PMU then each PMU will have a different type whic	191	* core PMU then each PMU will have a different type which
192	* requires additional support.	192	* requires additional support.
193	*/	193	*/
194	pr_debug("Skip test on hybrid systems");	194	pr_debug("Skip test on hybrid systems");

tools/perf/tests/attr/base-record+1−1

@@ -6,7 +6,7 @@ flags=0\|8 · 5 unmodified lines
6	cpu=*	6	cpu=*
7	type=0\|1	7	type=0\|1
8	size=136	8	size=136
9	config=0	9	config=0\|1
10	sample_period=*	10	sample_period=*
11	sample_type=263	11	sample_type=263
12	read_format=0\|4\|20	12	read_format=0\|4\|20

tools/perf/tests/attr/test-record-user-regs-no-sve-aarch64+1−1

@@ -6,4 +6,4 @@ args = --no-bpf-event --user-regs=vg kill >/dev/null 2>&1 · 5 unmodified lines
6	ret = 129	6	ret = 129
7	test_ret = true	7	test_ret = true
8	arch = aarch64	8	arch = aarch64
9	auxv = auxv["AT_HWCAP"] & 0x200000 == 0	9	auxv = auxv["AT_HWCAP"] & 0x400000 == 0

tools/perf/tests/attr/test-record-user-regs-sve-aarch64+1−1

@@ -6,7 +6,7 @@ args = --no-bpf-event --user-regs=vg kill >/dev/null 2>&1 · 5 unmodified lines
6	ret = 1	6	ret = 1
7	test_ret = true	7	test_ret = true
8	arch = aarch64	8	arch = aarch64
9	auxv = auxv["AT_HWCAP"] & 0x200000 == 0x200000	9	auxv = auxv["AT_HWCAP"] & 0x400000 == 0x400000
10	kernel_since = 6.1	10	kernel_since = 6.1
11		11
12	[event:base-record]	12	[event:base-record]

tools/perf/tests/builtin-test.c+15−2

 #include <sys/wait.h>
 #include <sys/stat.h>
 #include "builtin.h"
+#include "config.h"
 #include "hist.h"
 #include "intlist.h"
 #include "tests.h"
 static bool dont_fork;
 const char *dso_to_test;
+const char *test_objdump_path = "objdump";
 /*
  * List of architecture specific tests. Not a weak symbol as the array length is
 	&suite__pmu,
 	&suite__pmu_events,
 	&suite__dso_data,
-	&suite__dso_data_cache,
-	&suite__dso_data_reopen,
 	&suite__perf_evsel__roundtrip_name_test,
 #ifdef HAVE_LIBTRACEEVENT
 	&suite__perf_evsel__tp_sched_test,
 	return -1;
 }
+static int perf_test__config(const char *var, const char *value,
+			     void *data __maybe_unused)
+{
+	if (!strcmp(var, "annotate.objdump"))
+		test_objdump_path = value;
+	return 0;
+}
 int cmd_test(int argc, const char **argv)
 {
 	const char *test_usage[] = {
 		    "Do not fork for testcase"),
 	OPT_STRING('w', "workload", &workload, "work", "workload to run for testing"),
 	OPT_STRING(0, "dso", &dso_to_test, "dso", "dso to test"),
+	OPT_STRING(0, "objdump", &test_objdump_path, "path",
+		   "objdump binary to use for disassembly and annotations"),
 	OPT_END()
 	};
 	const char * const test_subcommands[] = { "list", NULL };
         if (ret < 0)
                 return ret;
+	perf_config(perf_test__config, NULL);
 	/* Unbuffered output */
 	setvbuf(stdout, NULL, _IONBF, 0);

tools/perf/tests/code-reading.c+25−55

 	int ret;
 	fmt = "%s -z -d --start-address=0x%"PRIx64" --stop-address=0x%"PRIx64" %s";
-	ret = snprintf(cmd, sizeof(cmd), fmt, "objdump", addr, addr + len,
+	ret = snprintf(cmd, sizeof(cmd), fmt, test_objdump_path, addr, addr + len,
 		       filename);
 	if (ret <= 0 || (size_t)ret >= sizeof(cmd))
 		return -1;
 	}
 }
-#ifdef __s390x__
-#include "header.h" // for get_cpuid()
-#endif
-static const char *do_determine_event(bool excl_kernel)
-{
-	const char *event = excl_kernel ? "cycles:u" : "cycles";
-#ifdef __s390x__
-	char cpuid[128], model[16], model_c[16], cpum_cf_v[16];
-	unsigned int family;
-	int ret, cpum_cf_a;
-	if (get_cpuid(cpuid, sizeof(cpuid)))
-		goto out_clocks;
-	ret = sscanf(cpuid, "%*[^,],%u,%[^,],%[^,],%[^,],%x", &family, model_c,
-		     model, cpum_cf_v, &cpum_cf_a);
-	if (ret != 5)		 /* Not available */
-		goto out_clocks;
-	if (excl_kernel && (cpum_cf_a & 4))
-		return event;
-	if (!excl_kernel && (cpum_cf_a & 2))
-		return event;
-	/* Fall through: missing authorization */
-out_clocks:
-	event = excl_kernel ? "cpu-clock:u" : "cpu-clock";
-#endif
-	return event;
-}
 static void do_something(void)
 {
 	fs_something();
 	int err = -1, ret;
 	pid_t pid;
 	struct map *map;
-	bool have_vmlinux, have_kcore, excl_kernel = false;
+	bool have_vmlinux, have_kcore;
 	struct dso *dso;
+	const char *events[] = { "cycles", "cycles:u", "cpu-clock", "cpu-clock:u", NULL };
+	int evidx = 0;
 	pid = getpid();
 	/* No point getting kernel events if there is no kernel object */
 	if (!have_vmlinux && !have_kcore)
-		excl_kernel = true;
+		evidx++;
 	threads = thread_map__new_by_tid(pid);
 	if (!threads) {
 		goto out_put;
 	}
-	cpus = perf_cpu_map__new(NULL);
+	cpus = perf_cpu_map__new_online_cpus();
 	if (!cpus) {
 		pr_debug("perf_cpu_map__new failed\n");
 		goto out_put;
 	}
-	while (1) {
+	while (events[evidx]) {
 		const char *str;
 		evlist = evlist__new();
 		perf_evlist__set_maps(&evlist->core, cpus, threads);
-		str = do_determine_event(excl_kernel);
+		str = events[evidx];
 		pr_debug("Parsing event '%s'\n", str);
 		ret = parse_event(evlist, str);
 		if (ret < 0) {
 		ret = evlist__open(evlist);
 		if (ret < 0) {
-			if (!excl_kernel) {
+			evidx++;
-				excl_kernel = true;
-				/*
-				 * Both cpus and threads are now owned by evlist
-				 * and will be freed by following perf_evlist__set_maps
-				 * call. Getting reference to keep them alive.
-				 */
-				perf_cpu_map__get(cpus);
-				perf_thread_map__get(threads);
-				perf_evlist__set_maps(&evlist->core, NULL, NULL);
-				evlist__delete(evlist);
-				evlist = NULL;
-				continue;
-			}
-			if (verbose > 0) {
+			if (events[evidx] == NULL && verbose > 0) {
 				char errbuf[512];
 				evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
 				pr_debug("perf_evlist__open() failed!\n%s\n", errbuf);
 			}
-			goto out_put;
+			/*
+			 * Both cpus and threads are now owned by evlist
+			 * and will be freed by following perf_evlist__set_maps
+			 * call. Getting reference to keep them alive.
+			 */
+			perf_cpu_map__get(cpus);
+			perf_thread_map__get(threads);
+			perf_evlist__set_maps(&evlist->core, NULL, NULL);
+			evlist__delete(evlist);
+			evlist = NULL;
+			continue;
 		}
 		break;
 	}
+	if (events[evidx] == NULL)
+		goto out_put;
 	ret = evlist__mmap(evlist, UINT_MAX);
 	if (ret < 0) {
 		pr_debug("evlist__mmap failed\n");
 		err = TEST_CODE_READING_NO_KERNEL_OBJ;
 	else if (!have_vmlinux && !try_kcore)
 		err = TEST_CODE_READING_NO_VMLINUX;
-	else if (excl_kernel)
+	else if (strstr(events[evidx], ":u"))
 		err = TEST_CODE_READING_NO_ACCESS;
 	else
 		err = TEST_CODE_READING_OK;

tools/perf/tests/cpumap.c+1−1

@@ -213,7 +213,7 @@ static int test__cpu_map_intersect(struct test_suite *test __maybe_unused, · 212 unmodified lines
213		213
214	static int test__cpu_map_equal(struct test_suite *test __maybe_unused, int subtest __maybe_unused)	214	static int test__cpu_map_equal(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
215	{	215	{
216	struct perf_cpu_map *any = perf_cpu_map__dummy_new();	216	struct perf_cpu_map *any = perf_cpu_map__new_any_cpu();
217	struct perf_cpu_map *one = perf_cpu_map__new("1");	217	struct perf_cpu_map *one = perf_cpu_map__new("1");
218	struct perf_cpu_map *two = perf_cpu_map__new("2");	218	struct perf_cpu_map *two = perf_cpu_map__new("2");
219	struct perf_cpu_map *empty = perf_cpu_map__intersect(one, two);	219	struct perf_cpu_map *empty = perf_cpu_map__intersect(one, two);

tools/perf/tests/dso-data.c+12−3

@@ -394,6 +394,15 @@ static int test__dso_data_reopen(struct test_suite *test __maybe_unused, int sub · 393 unmodified lines
394	return 0;	394	return 0;
395	}	395	}
396		396
397	DEFINE_SUITE("DSO data read", dso_data);	397
398	DEFINE_SUITE("DSO data cache", dso_data_cache);	398	static struct test_case tests__dso_data[] = {
399	DEFINE_SUITE("DSO data reopen", dso_data_reopen);	399	TEST_CASE("read", dso_data),
		400	TEST_CASE("cache", dso_data_cache),
		401	TEST_CASE("reopen", dso_data_reopen),
		402	{ .name = NULL, }
		403	};
		404
		405	struct test_suite suite__dso_data = {
		406	.desc = "DSO data tests",
		407	.test_cases = tests__dso_data,
		408	};

tools/perf/tests/keep-tracking.c+1−1

@@ -81,7 +81,7 @@ static int test__keep_tracking(struct test_suite *test __maybe_unused, int subte · 80 unmodified lines
81	threads = thread_map__new(-1, getpid(), UINT_MAX);	81	threads = thread_map__new(-1, getpid(), UINT_MAX);
82	CHECK_NOT_NULL__(threads);	82	CHECK_NOT_NULL__(threads);
83		83
84	cpus = perf_cpu_map__new(NULL);	84	cpus = perf_cpu_map__new_online_cpus();
85	CHECK_NOT_NULL__(cpus);	85	CHECK_NOT_NULL__(cpus);
86		86
87	evlist = evlist__new();	87	evlist = evlist__new();

tools/perf/tests/make+1−1

@@ -183,7 +183,7 @@ run += make_install_prefix_slash · 182 unmodified lines
183	# run += make_install_pdf	183	# run += make_install_pdf
184	run += make_minimal	184	run += make_minimal
185		185
186	old_libbpf := $(shell echo '\#include <bpf/libbpf.h>' \| $(CC) -E -dM -x c -\| egrep -q "define[[:space:]]+LIBBPF_MAJOR_VERSION[[:space:]]+0{1}")	186	old_libbpf := $(shell echo '\#include <bpf/libbpf.h>' \| $(CC) -E -dM -x c -\| grep -q -E "define[[:space:]]+LIBBPF_MAJOR_VERSION[[:space:]]+0{1}")
187		187
188	ifneq ($(old_libbpf),)	188	ifneq ($(old_libbpf),)
189	run += make_libbpf_dynamic	189	run += make_libbpf_dynamic

tools/perf/tests/maps.c+38−23

@@ -14,44 +14,59 @@ struct map_def { · 13 unmodified lines
14	u64 end;	14	u64 end;
15	};	15	};
16		16
		17	struct check_maps_cb_args {
		18	struct map_def *merged;
		19	unsigned int i;
		20	};
		21
		22	static int check_maps_cb(struct map map, void data)
		23	{
		24	struct check_maps_cb_args *args = data;
		25	struct map_def *merged = &args->merged[args->i];
		26
		27	if (map__start(map) != merged->start \|\|
		28	map__end(map) != merged->end \|\|
		29	strcmp(map__dso(map)->name, merged->name) \|\|
		30	refcount_read(map__refcnt(map)) != 1) {
		31	return 1;
		32	}
		33	args->i++;
		34	return 0;
		35	}
		36
		37	static int failed_cb(struct map map, void data __maybe_unused)
		38	{
		39	pr_debug("\tstart: %" PRIu64 " end: %" PRIu64 " name: '%s' refcnt: %d\n",
		40	map__start(map),
		41	map__end(map),
		42	map__dso(map)->name,
		43	refcount_read(map__refcnt(map)));
		44
		45	return 0;
		46	}
		47
17	static int check_maps(struct map_def merged, unsigned int size, struct maps maps)	48	static int check_maps(struct map_def merged, unsigned int size, struct maps maps)
18	{	49	{
19	struct map_rb_node *rb_node;
20	unsigned int i = 0;
21	bool failed = false;	50	bool failed = false;
22		51
23	if (maps__nr_maps(maps) != size) {	52	if (maps__nr_maps(maps) != size) {
24	pr_debug("Expected %d maps, got %d", size, maps__nr_maps(maps));	53	pr_debug("Expected %d maps, got %d", size, maps__nr_maps(maps));
25	failed = true;	54	failed = true;
26	} else {	55	} else {
27	maps__for_each_entry(maps, rb_node) {	56	struct check_maps_cb_args args = {
28	struct map *map = rb_node->map;	57	.merged = merged,
29		58	.i = 0,
30	if (map__start(map) != merged[i].start \|\|	59	};
31	map__end(map) != merged[i].end \|\|	60	failed = maps__for_each_map(maps, check_maps_cb, &args);
32	strcmp(map__dso(map)->name, merged[i].name) \|\|
33	refcount_read(map__refcnt(map)) != 1) {
34	failed = true;
35	}
36	i++;
37	}
38	}	61	}
39	if (failed) {	62	if (failed) {
40	pr_debug("Expected:\n");	63	pr_debug("Expected:\n");
41	for (i = 0; i < size; i++) {	64	for (unsigned int i = 0; i < size; i++) {
42	pr_debug("\tstart: %" PRIu64 " end: %" PRIu64 " name: '%s' refcnt: 1\n",	65	pr_debug("\tstart: %" PRIu64 " end: %" PRIu64 " name: '%s' refcnt: 1\n",
43	merged[i].start, merged[i].end, merged[i].name);	66	merged[i].start, merged[i].end, merged[i].name);
44	}	67	}
45	pr_debug("Got:\n");	68	pr_debug("Got:\n");
46	maps__for_each_entry(maps, rb_node) {	69	maps__for_each_map(maps, failed_cb, NULL);
47	struct map *map = rb_node->map;
48
49	pr_debug("\tstart: %" PRIu64 " end: %" PRIu64 " name: '%s' refcnt: %d\n",
50	map__start(map),
51	map__end(map),
52	map__dso(map)->name,
53	refcount_read(map__refcnt(map)));
54	}
55	}	70	}
56	return failed ? TEST_FAIL : TEST_OK;	71	return failed ? TEST_FAIL : TEST_OK;
57	}	72	}

tools/perf/tests/mmap-basic.c+1−1

@@ -52,7 +52,7 @@ static int test__basic_mmap(struct test_suite *test __maybe_unused, int subtest · 51 unmodified lines
52	return -1;	52	return -1;
53	}	53	}
54		54
55	cpus = perf_cpu_map__new(NULL);	55	cpus = perf_cpu_map__new_online_cpus();
56	if (cpus == NULL) {	56	if (cpus == NULL) {
57	pr_debug("perf_cpu_map__new\n");	57	pr_debug("perf_cpu_map__new\n");
58	goto out_free_threads;	58	goto out_free_threads;

tools/perf/tests/openat-syscall-all-cpus.c+1−1

@@ -37,7 +37,7 @@ static int test__openat_syscall_event_on_all_cpus(struct test_suite *test __mayb · 36 unmodified lines
37	return -1;	37	return -1;
38	}	38	}
39		39
40	cpus = perf_cpu_map__new(NULL);	40	cpus = perf_cpu_map__new_online_cpus();
41	if (cpus == NULL) {	41	if (cpus == NULL) {
42	pr_debug("perf_cpu_map__new\n");	42	pr_debug("perf_cpu_map__new\n");
43	goto out_thread_map_delete;	43	goto out_thread_map_delete;

tools/perf/tests/parse-events.c+187−73

@@ -162,6 +162,22 @@ static int test__checkevent_numeric(struct evlist *evlist) · 161 unmodified lines
162	return TEST_OK;	162	return TEST_OK;
163	}	163	}
164		164
		165
		166	static int assert_hw(struct perf_evsel evsel, enum perf_hw_id id, const char name)
		167	{
		168	struct perf_pmu *pmu;
		169
		170	if (evsel->attr.type == PERF_TYPE_HARDWARE) {
		171	TEST_ASSERT_VAL("wrong config", test_perf_config(evsel, id));
		172	return 0;
		173	}
		174	pmu = perf_pmus__find_by_type(evsel->attr.type);
		175
		176	TEST_ASSERT_VAL("unexpected PMU type", pmu);
		177	TEST_ASSERT_VAL("PMU missing event", perf_pmu__have_event(pmu, name));
		178	return 0;
		179	}
		180
165	static int test__checkevent_symbolic_name(struct evlist *evlist)	181	static int test__checkevent_symbolic_name(struct evlist *evlist)
166	{	182	{
167	struct perf_evsel *evsel;	183	struct perf_evsel *evsel;
@@ -169,10 +185,12 @@ static int test__checkevent_symbolic_name(struct evlist *evlist) · 1 unmodified line
169	TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries);	185	TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries);
170		186
171	perf_evlist__for_each_evsel(&evlist->core, evsel) {	187	perf_evlist__for_each_evsel(&evlist->core, evsel) {
172	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);	188	int ret = assert_hw(evsel, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
173	TEST_ASSERT_VAL("wrong config",	189
174	test_perf_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));	190	if (ret)
		191	return ret;
175	}	192	}
		193
176	return TEST_OK;	194	return TEST_OK;
177	}	195	}
178		196
@@ -183,8 +201,10 @@ static int test__checkevent_symbolic_name_config(struct evlist *evlist) · 4 unmodified lines
183	TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries);	201	TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries);
184		202
185	perf_evlist__for_each_evsel(&evlist->core, evsel) {	203	perf_evlist__for_each_evsel(&evlist->core, evsel) {
186	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);	204	int ret = assert_hw(evsel, PERF_COUNT_HW_CPU_CYCLES, "cycles");
187	TEST_ASSERT_VAL("wrong config", test_perf_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	205
		206	if (ret)
		207	return ret;
188	/*	208	/*
189	* The period value gets configured within evlist__config,	209	* The period value gets configured within evlist__config,
190	* while this test executes only parse events method.	210	* while this test executes only parse events method.
@@ -861,10 +881,14 @@ static int test__group1(struct evlist *evlist) · 670 unmodified lines
861	evlist__nr_groups(evlist) == num_core_entries());	881	evlist__nr_groups(evlist) == num_core_entries());
862		882
863	for (int i = 0; i < num_core_entries(); i++) {	883	for (int i = 0; i < num_core_entries(); i++) {
		884	int ret;
		885
864	/* instructions:k */	886	/* instructions:k */
865	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));	887	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
866	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	888	ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
867	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));	889	if (ret)
		890	return ret;
		891
868	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);	892	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
869	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	893	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
870	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	894	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -878,8 +902,10 @@ static int test__group1(struct evlist *evlist) · 7 unmodified lines
878		902
879	/* cycles:upp */	903	/* cycles:upp */
880	evsel = evsel__next(evsel);	904	evsel = evsel__next(evsel);
881	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	905	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
882	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	906	if (ret)
		907	return ret;
		908
883	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	909	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
884	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);	910	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
885	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	911	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -907,6 +933,8 @@ static int test__group2(struct evlist *evlist) · 21 unmodified lines
907	TEST_ASSERT_VAL("wrong number of groups", 1 == evlist__nr_groups(evlist));	933	TEST_ASSERT_VAL("wrong number of groups", 1 == evlist__nr_groups(evlist));
908		934
909	evlist__for_each_entry(evlist, evsel) {	935	evlist__for_each_entry(evlist, evsel) {
		936	int ret;
		937
910	if (evsel->core.attr.type == PERF_TYPE_SOFTWARE) {	938	if (evsel->core.attr.type == PERF_TYPE_SOFTWARE) {
911	/* faults + :ku modifier */	939	/* faults + :ku modifier */
912	leader = evsel;	940	leader = evsel;
@@ -939,8 +967,10 @@ static int test__group2(struct evlist *evlist) · 26 unmodified lines
939	continue;	967	continue;
940	}	968	}
941	/* cycles:k */	969	/* cycles:k */
942	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	970	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
943	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	971	if (ret)
		972	return ret;
		973
944	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);	974	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
945	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	975	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
946	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	976	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -957,6 +987,7 @@ static int test__group2(struct evlist *evlist) · 10 unmodified lines
957	static int test__group3(struct evlist *evlist __maybe_unused)	987	static int test__group3(struct evlist *evlist __maybe_unused)
958	{	988	{
959	struct evsel evsel, group1_leader = NULL, *group2_leader = NULL;	989	struct evsel evsel, group1_leader = NULL, *group2_leader = NULL;
		990	int ret;
960		991
961	TEST_ASSERT_VAL("wrong number of entries",	992	TEST_ASSERT_VAL("wrong number of entries",
962	evlist->core.nr_entries == (3 * perf_pmus__num_core_pmus() + 2));	993	evlist->core.nr_entries == (3 * perf_pmus__num_core_pmus() + 2));
@@ -1045,8 +1076,10 @@ static int test__group3(struct evlist *evlist __maybe_unused) · 82 unmodified lines
1045	continue;	1076	continue;
1046	}	1077	}
1047	/* instructions:u */	1078	/* instructions:u */
1048	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1079	ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
1049	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));	1080	if (ret)
		1081	return ret;
		1082
1050	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1083	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1051	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);	1084	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1052	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	1085	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1070,10 +1103,14 @@ static int test__group4(struct evlist *evlist __maybe_unused) · 17 unmodified lines
1070	num_core_entries() == evlist__nr_groups(evlist));	1103	num_core_entries() == evlist__nr_groups(evlist));
1071		1104
1072	for (int i = 0; i < num_core_entries(); i++) {	1105	for (int i = 0; i < num_core_entries(); i++) {
		1106	int ret;
		1107
1073	/* cycles:u + p */	1108	/* cycles:u + p */
1074	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));	1109	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1075	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1110	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
1076	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	1111	if (ret)
		1112	return ret;
		1113
1077	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1114	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1078	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);	1115	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1079	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	1116	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1089,8 +1126,10 @@ static int test__group4(struct evlist *evlist __maybe_unused) · 9 unmodified lines
1089		1126
1090	/* instructions:kp + p */	1127	/* instructions:kp + p */
1091	evsel = evsel__next(evsel);	1128	evsel = evsel__next(evsel);
1092	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1129	ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
1093	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));	1130	if (ret)
		1131	return ret;
		1132
1094	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);	1133	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
1095	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1134	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1096	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	1135	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1108,6 +1147,7 @@ static int test__group4(struct evlist *evlist __maybe_unused) · 11 unmodified lines
1108	static int test__group5(struct evlist *evlist __maybe_unused)	1147	static int test__group5(struct evlist *evlist __maybe_unused)
1109	{	1148	{
1110	struct evsel evsel = NULL, leader;	1149	struct evsel evsel = NULL, leader;
		1150	int ret;
1111		1151
1112	TEST_ASSERT_VAL("wrong number of entries",	1152	TEST_ASSERT_VAL("wrong number of entries",
1113	evlist->core.nr_entries == (5 * num_core_entries()));	1153	evlist->core.nr_entries == (5 * num_core_entries()));
@@ -1117,8 +1157,10 @@ static int test__group5(struct evlist *evlist __maybe_unused) · 3 unmodified lines
1117	for (int i = 0; i < num_core_entries(); i++) {	1157	for (int i = 0; i < num_core_entries(); i++) {
1118	/* cycles + G */	1158	/* cycles + G */
1119	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));	1159	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1120	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1160	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
1121	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	1161	if (ret)
		1162	return ret;
		1163
1122	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1164	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1123	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1165	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1124	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1166	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1133,8 +1175,10 @@ static int test__group5(struct evlist *evlist __maybe_unused) · 8 unmodified lines
1133		1175
1134	/* instructions + G */	1176	/* instructions + G */
1135	evsel = evsel__next(evsel);	1177	evsel = evsel__next(evsel);
1136	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1178	ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
1137	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));	1179	if (ret)
		1180	return ret;
		1181
1138	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1182	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1139	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1183	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1140	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1184	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1148,8 +1192,10 @@ static int test__group5(struct evlist *evlist __maybe_unused) · 7 unmodified lines
1148	for (int i = 0; i < num_core_entries(); i++) {	1192	for (int i = 0; i < num_core_entries(); i++) {
1149	/* cycles:G */	1193	/* cycles:G */
1150	evsel = leader = evsel__next(evsel);	1194	evsel = leader = evsel__next(evsel);
1151	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1195	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
1152	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	1196	if (ret)
		1197	return ret;
		1198
1153	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1199	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1154	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1200	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1155	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1201	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1164,8 +1210,10 @@ static int test__group5(struct evlist *evlist __maybe_unused) · 8 unmodified lines
1164		1210
1165	/* instructions:G */	1211	/* instructions:G */
1166	evsel = evsel__next(evsel);	1212	evsel = evsel__next(evsel);
1167	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1213	ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
1168	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));	1214	if (ret)
		1215	return ret;
		1216
1169	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1217	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1170	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1218	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1171	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1219	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1178,8 +1226,10 @@ static int test__group5(struct evlist *evlist __maybe_unused) · 6 unmodified lines
1178	for (int i = 0; i < num_core_entries(); i++) {	1226	for (int i = 0; i < num_core_entries(); i++) {
1179	/* cycles */	1227	/* cycles */
1180	evsel = evsel__next(evsel);	1228	evsel = evsel__next(evsel);
1181	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1229	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
1182	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	1230	if (ret)
		1231	return ret;
		1232
1183	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1233	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1184	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1234	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1185	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1235	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1201,10 +1251,14 @@ static int test__group_gh1(struct evlist *evlist) · 15 unmodified lines
1201	evlist__nr_groups(evlist) == num_core_entries());	1251	evlist__nr_groups(evlist) == num_core_entries());
1202		1252
1203	for (int i = 0; i < num_core_entries(); i++) {	1253	for (int i = 0; i < num_core_entries(); i++) {
		1254	int ret;
		1255
1204	/* cycles + :H group modifier */	1256	/* cycles + :H group modifier */
1205	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));	1257	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1206	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1258	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
1207	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	1259	if (ret)
		1260	return ret;
		1261
1208	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1262	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1209	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1263	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1210	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1264	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1218,8 +1272,10 @@ static int test__group_gh1(struct evlist *evlist) · 7 unmodified lines
1218		1272
1219	/* cache-misses:G + :H group modifier */	1273	/* cache-misses:G + :H group modifier */
1220	evsel = evsel__next(evsel);	1274	evsel = evsel__next(evsel);
1221	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1275	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
1222	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));	1276	if (ret)
		1277	return ret;
		1278
1223	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1279	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1224	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1280	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1225	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1281	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1242,10 +1298,14 @@ static int test__group_gh2(struct evlist *evlist) · 16 unmodified lines
1242	evlist__nr_groups(evlist) == num_core_entries());	1298	evlist__nr_groups(evlist) == num_core_entries());
1243		1299
1244	for (int i = 0; i < num_core_entries(); i++) {	1300	for (int i = 0; i < num_core_entries(); i++) {
		1301	int ret;
		1302
1245	/* cycles + :G group modifier */	1303	/* cycles + :G group modifier */
1246	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));	1304	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1247	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1305	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
1248	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	1306	if (ret)
		1307	return ret;
		1308
1249	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1309	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1250	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1310	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1251	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1311	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1259,8 +1319,10 @@ static int test__group_gh2(struct evlist *evlist) · 7 unmodified lines
1259		1319
1260	/* cache-misses:H + :G group modifier */	1320	/* cache-misses:H + :G group modifier */
1261	evsel = evsel__next(evsel);	1321	evsel = evsel__next(evsel);
1262	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1322	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
1263	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));	1323	if (ret)
		1324	return ret;
		1325
1264	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1326	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1265	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1327	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1266	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1328	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1283,10 +1345,14 @@ static int test__group_gh3(struct evlist *evlist) · 16 unmodified lines
1283	evlist__nr_groups(evlist) == num_core_entries());	1345	evlist__nr_groups(evlist) == num_core_entries());
1284		1346
1285	for (int i = 0; i < num_core_entries(); i++) {	1347	for (int i = 0; i < num_core_entries(); i++) {
		1348	int ret;
		1349
1286	/* cycles:G + :u group modifier */	1350	/* cycles:G + :u group modifier */
1287	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));	1351	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1288	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1352	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
1289	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	1353	if (ret)
		1354	return ret;
		1355
1290	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1356	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1291	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);	1357	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1292	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	1358	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1300,8 +1366,10 @@ static int test__group_gh3(struct evlist *evlist) · 7 unmodified lines
1300		1366
1301	/* cache-misses:H + :u group modifier */	1367	/* cache-misses:H + :u group modifier */
1302	evsel = evsel__next(evsel);	1368	evsel = evsel__next(evsel);
1303	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1369	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
1304	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));	1370	if (ret)
		1371	return ret;
		1372
1305	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1373	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1306	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);	1374	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1307	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	1375	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1324,10 +1392,14 @@ static int test__group_gh4(struct evlist *evlist) · 16 unmodified lines
1324	evlist__nr_groups(evlist) == num_core_entries());	1392	evlist__nr_groups(evlist) == num_core_entries());
1325		1393
1326	for (int i = 0; i < num_core_entries(); i++) {	1394	for (int i = 0; i < num_core_entries(); i++) {
		1395	int ret;
		1396
1327	/* cycles:G + :uG group modifier */	1397	/* cycles:G + :uG group modifier */
1328	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));	1398	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1329	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1399	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
1330	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	1400	if (ret)
		1401	return ret;
		1402
1331	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1403	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1332	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);	1404	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1333	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	1405	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1341,8 +1413,10 @@ static int test__group_gh4(struct evlist *evlist) · 7 unmodified lines
1341		1413
1342	/* cache-misses:H + :uG group modifier */	1414	/* cache-misses:H + :uG group modifier */
1343	evsel = evsel__next(evsel);	1415	evsel = evsel__next(evsel);
1344	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1416	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
1345	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));	1417	if (ret)
		1418	return ret;
		1419
1346	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1420	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1347	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);	1421	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1348	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	1422	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1363,10 +1437,14 @@ static int test__leader_sample1(struct evlist *evlist) · 14 unmodified lines
1363	evlist->core.nr_entries == (3 * num_core_entries()));	1437	evlist->core.nr_entries == (3 * num_core_entries()));
1364		1438
1365	for (int i = 0; i < num_core_entries(); i++) {	1439	for (int i = 0; i < num_core_entries(); i++) {
		1440	int ret;
		1441
1366	/* cycles - sampling group leader */	1442	/* cycles - sampling group leader */
1367	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));	1443	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1368	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1444	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
1369	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	1445	if (ret)
		1446	return ret;
		1447
1370	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1448	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1371	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1449	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1372	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1450	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1379,8 +1457,10 @@ static int test__leader_sample1(struct evlist *evlist) · 6 unmodified lines
1379		1457
1380	/* cache-misses - not sampling */	1458	/* cache-misses - not sampling */
1381	evsel = evsel__next(evsel);	1459	evsel = evsel__next(evsel);
1382	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1460	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
1383	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));	1461	if (ret)
		1462	return ret;
		1463
1384	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1464	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1385	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1465	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1386	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1466	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1392,8 +1472,10 @@ static int test__leader_sample1(struct evlist *evlist) · 5 unmodified lines
1392		1472
1393	/* branch-misses - not sampling */	1473	/* branch-misses - not sampling */
1394	evsel = evsel__next(evsel);	1474	evsel = evsel__next(evsel);
1395	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1475	ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses");
1396	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));	1476	if (ret)
		1477	return ret;
		1478
1397	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1479	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1398	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);	1480	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1399	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);	1481	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1415,10 +1497,14 @@ static int test__leader_sample2(struct evlist *evlist __maybe_unused) · 15 unmodified lines
1415	evlist->core.nr_entries == (2 * num_core_entries()));	1497	evlist->core.nr_entries == (2 * num_core_entries()));
1416		1498
1417	for (int i = 0; i < num_core_entries(); i++) {	1499	for (int i = 0; i < num_core_entries(); i++) {
		1500	int ret;
		1501
1418	/* instructions - sampling group leader */	1502	/* instructions - sampling group leader */
1419	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));	1503	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1420	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1504	ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
1421	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));	1505	if (ret)
		1506	return ret;
		1507
1422	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1508	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1423	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);	1509	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1424	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	1510	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1431,8 +1517,10 @@ static int test__leader_sample2(struct evlist *evlist __maybe_unused) · 6 unmodified lines
1431		1517
1432	/* branch-misses - not sampling */	1518	/* branch-misses - not sampling */
1433	evsel = evsel__next(evsel);	1519	evsel = evsel__next(evsel);
1434	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1520	ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses");
1435	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));	1521	if (ret)
		1522	return ret;
		1523
1436	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);	1524	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1437	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);	1525	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1438	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);	1526	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1472,10 +1560,14 @@ static int test__pinned_group(struct evlist *evlist) · 33 unmodified lines
1472	evlist->core.nr_entries == (3 * num_core_entries()));	1560	evlist->core.nr_entries == (3 * num_core_entries()));
1473		1561
1474	for (int i = 0; i < num_core_entries(); i++) {	1562	for (int i = 0; i < num_core_entries(); i++) {
		1563	int ret;
		1564
1475	/* cycles - group leader */	1565	/* cycles - group leader */
1476	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));	1566	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1477	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1567	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
1478	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	1568	if (ret)
		1569	return ret;
		1570
1479	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);	1571	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1480	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));	1572	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1481	/* TODO: The group modifier is not copied to the split group leader. */	1573	/* TODO: The group modifier is not copied to the split group leader. */
@@ -1484,13 +1576,18 @@ static int test__pinned_group(struct evlist *evlist) · 2 unmodified lines
1484		1576
1485	/* cache-misses - can not be pinned, but will go on with the leader */	1577	/* cache-misses - can not be pinned, but will go on with the leader */
1486	evsel = evsel__next(evsel);	1578	evsel = evsel__next(evsel);
1487	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1579	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
1488	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));	1580	if (ret)
		1581	return ret;
		1582
1489	TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);	1583	TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
1490		1584
1491	/* branch-misses - ditto */	1585	/* branch-misses - ditto */
1492	evsel = evsel__next(evsel);	1586	evsel = evsel__next(evsel);
1493	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));	1587	ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses");
		1588	if (ret)
		1589	return ret;
		1590
1494	TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);	1591	TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
1495	}	1592	}
1496	return TEST_OK;	1593	return TEST_OK;
@@ -1517,10 +1614,14 @@ static int test__exclusive_group(struct evlist *evlist) · 20 unmodified lines
1517	evlist->core.nr_entries == 3 * num_core_entries());	1614	evlist->core.nr_entries == 3 * num_core_entries());
1518		1615
1519	for (int i = 0; i < num_core_entries(); i++) {	1616	for (int i = 0; i < num_core_entries(); i++) {
		1617	int ret;
		1618
1520	/* cycles - group leader */	1619	/* cycles - group leader */
1521	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));	1620	evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1522	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1621	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
1523	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));	1622	if (ret)
		1623	return ret;
		1624
1524	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);	1625	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1525	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));	1626	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1526	/* TODO: The group modifier is not copied to the split group leader. */	1627	/* TODO: The group modifier is not copied to the split group leader. */
@@ -1529,13 +1630,18 @@ static int test__exclusive_group(struct evlist *evlist) · 2 unmodified lines
1529		1630
1530	/* cache-misses - can not be pinned, but will go on with the leader */	1631	/* cache-misses - can not be pinned, but will go on with the leader */
1531	evsel = evsel__next(evsel);	1632	evsel = evsel__next(evsel);
1532	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);	1633	ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
1533	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));	1634	if (ret)
		1635	return ret;
		1636
1534	TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);	1637	TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
1535		1638
1536	/* branch-misses - ditto */	1639	/* branch-misses - ditto */
1537	evsel = evsel__next(evsel);	1640	evsel = evsel__next(evsel);
1538	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));	1641	ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses");
		1642	if (ret)
		1643	return ret;
		1644
1539	TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);	1645	TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
1540	}	1646	}
1541	return TEST_OK;	1647	return TEST_OK;
@@ -1677,9 +1783,11 @@ static int test__checkevent_raw_pmu(struct evlist *evlist) · 135 unmodified lines
1677	static int test__sym_event_slash(struct evlist *evlist)	1783	static int test__sym_event_slash(struct evlist *evlist)
1678	{	1784	{
1679	struct evsel *evsel = evlist__first(evlist);	1785	struct evsel *evsel = evlist__first(evlist);
		1786	int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
		1787
		1788	if (ret)
		1789	return ret;
1680		1790
1681	TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1682	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1683	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);	1791	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1684	return TEST_OK;	1792	return TEST_OK;
1685	}	1793	}
@@ -1687,9 +1795,11 @@ static int test__sym_event_slash(struct evlist *evlist) · 1 unmodified line
1687	static int test__sym_event_dc(struct evlist *evlist)	1795	static int test__sym_event_dc(struct evlist *evlist)
1688	{	1796	{
1689	struct evsel *evsel = evlist__first(evlist);	1797	struct evsel *evsel = evlist__first(evlist);
		1798	int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
		1799
		1800	if (ret)
		1801	return ret;
1690		1802
1691	TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1692	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1693	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);	1803	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
1694	return TEST_OK;	1804	return TEST_OK;
1695	}	1805	}
@@ -1697,9 +1807,11 @@ static int test__sym_event_dc(struct evlist *evlist) · 1 unmodified line
1697	static int test__term_equal_term(struct evlist *evlist)	1807	static int test__term_equal_term(struct evlist *evlist)
1698	{	1808	{
1699	struct evsel *evsel = evlist__first(evlist);	1809	struct evsel *evsel = evlist__first(evlist);
		1810	int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
		1811
		1812	if (ret)
		1813	return ret;
1700		1814
1701	TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1702	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1703	TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "name") == 0);	1815	TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "name") == 0);
1704	return TEST_OK;	1816	return TEST_OK;
1705	}	1817	}
@@ -1707,9 +1819,11 @@ static int test__term_equal_term(struct evlist *evlist) · 1 unmodified line
1707	static int test__term_equal_legacy(struct evlist *evlist)	1819	static int test__term_equal_legacy(struct evlist *evlist)
1708	{	1820	{
1709	struct evsel *evsel = evlist__first(evlist);	1821	struct evsel *evsel = evlist__first(evlist);
		1822	int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
		1823
		1824	if (ret)
		1825	return ret;
1710		1826
1711	TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1712	TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1713	TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "l1d") == 0);	1827	TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "l1d") == 0);
1714	return TEST_OK;	1828	return TEST_OK;
1715	}	1829	}
@@ -2549,7 +2663,7 @@ static int test__pmu_events(struct test_suite *test __maybe_unused, int subtest · 833 unmodified lines
2549	if (strchr(ent->d_name, '.'))	2663	if (strchr(ent->d_name, '.'))
2550	continue;	2664	continue;
2551		2665
2552	/* exclude parametrized ones (name contains '?') */	2666	/* exclude parameterized ones (name contains '?') */
2553	n = snprintf(pmu_event, sizeof(pmu_event), "%s%s", path, ent->d_name);	2667	n = snprintf(pmu_event, sizeof(pmu_event), "%s%s", path, ent->d_name);
2554	if (n >= PATH_MAX) {	2668	if (n >= PATH_MAX) {
2555	pr_err("pmu event name crossed PATH_MAX(%d) size\n", PATH_MAX);	2669	pr_err("pmu event name crossed PATH_MAX(%d) size\n", PATH_MAX);
@@ -2578,7 +2692,7 @@ static int test__pmu_events(struct test_suite *test __maybe_unused, int subtest · 22 unmodified lines
2578	fclose(file);	2692	fclose(file);
2579		2693
2580	if (is_event_parameterized == 1) {	2694	if (is_event_parameterized == 1) {
2581	pr_debug("skipping parametrized PMU event: %s which contains ?\n", pmu_event);	2695	pr_debug("skipping parameterized PMU event: %s which contains ?\n", pmu_event);
2582	continue;	2696	continue;
2583	}	2697	}
2584		2698

tools/perf/tests/perf-time-to-tsc.c+1−1

@@ -93,7 +93,7 @@ static int test__perf_time_to_tsc(struct test_suite *test __maybe_unused, int su · 92 unmodified lines
93	threads = thread_map__new(-1, getpid(), UINT_MAX);	93	threads = thread_map__new(-1, getpid(), UINT_MAX);
94	CHECK_NOT_NULL__(threads);	94	CHECK_NOT_NULL__(threads);
95		95
96	cpus = perf_cpu_map__new(NULL);	96	cpus = perf_cpu_map__new_online_cpus();
97	CHECK_NOT_NULL__(cpus);	97	CHECK_NOT_NULL__(cpus);
98		98
99	evlist = evlist__new();	99	evlist = evlist__new();

tools/perf/tests/shell/coresight/memcpy_thread/memcpy_thread.c+0−1

@@ -42,7 +42,6 @@ static pthread_t new_thr(void (fn) (void arg), void arg) · 41 unmodified lines
42	int main(int argc, char **argv)	42	int main(int argc, char **argv)
43	{	43	{
44	unsigned long i, len, size, thr;	44	unsigned long i, len, size, thr;
45	pthread_t threads[256];
46	struct args args[256];	45	struct args args[256];
47	long long v;	46	long long v;
48		47

tools/perf/tests/shell/coresight/thread_loop/thread_loop.c+0−1

@@ -57,7 +57,6 @@ static pthread_t new_thr(void (fn) (void arg), void arg) · 56 unmodified lines
57	int main(int argc, char **argv)	57	int main(int argc, char **argv)
58	{	58	{
59	unsigned int i, len, thr;	59	unsigned int i, len, thr;
60	pthread_t threads[256];
61	struct args args[256];	60	struct args args[256];
62		61
63	if (argc < 3) {	62	if (argc < 3) {

tools/perf/tests/shell/coresight/unroll_loop_thread/unroll_loop_thread.c+0−1

@@ -51,7 +51,6 @@ static pthread_t new_thr(void (fn) (void arg), void arg) · 50 unmodified lines
51	int main(int argc, char **argv)	51	int main(int argc, char **argv)
52	{	52	{
53	unsigned int i, thr;	53	unsigned int i, thr;
54	pthread_t threads[256];
55	struct args args[256];	54	struct args args[256];
56		55
57	if (argc < 2) {	56	if (argc < 2) {

tools/perf/tests/shell/diff.sh+108−0

@@ -0,0 +1,108 @@
	1	#!/bin/sh
	2	# perf diff tests
	3	# SPDX-License-Identifier: GPL-2.0
	4
	5	set -e
	6
	7	err=0
	8	perfdata1=$(mktemp /tmp/__perf_test.perf.data.XXXXX)
	9	perfdata2=$(mktemp /tmp/__perf_test.perf.data.XXXXX)
	10	perfdata3=$(mktemp /tmp/__perf_test.perf.data.XXXXX)
	11	testprog="perf test -w thloop"
	12
	13	shelldir=$(dirname "$0")
	14	# shellcheck source=lib/perf_has_symbol.sh
	15	. "${shelldir}"/lib/perf_has_symbol.sh
	16
	17	testsym="test_loop"
	18
	19	skip_test_missing_symbol ${testsym}
	20
	21	cleanup() {
	22	rm -rf "${perfdata1}"
	23	rm -rf "${perfdata1}".old
	24	rm -rf "${perfdata2}"
	25	rm -rf "${perfdata2}".old
	26	rm -rf "${perfdata3}"
	27	rm -rf "${perfdata3}".old
	28
	29	trap - EXIT TERM INT
	30	}
	31
	32	trap_cleanup() {
	33	cleanup
	34	exit 1
	35	}
	36	trap trap_cleanup EXIT TERM INT
	37
	38	make_data() {
	39	file="$1"
	40	if ! perf record -o "${file}" ${testprog} 2> /dev/null
	41	then
	42	echo "Workload record [Failed record]"
	43	echo 1
	44	return
	45	fi
	46	if ! perf report -i "${file}" -q \| grep -q "${testsym}"
	47	then
	48	echo "Workload record [Failed missing output]"
	49	echo 1
	50	return
	51	fi
	52	echo 0
	53	}
	54
	55	test_two_files() {
	56	echo "Basic two file diff test"
	57	err=$(make_data "${perfdata1}")
	58	if [ $err != 0 ]
	59	then
	60	return
	61	fi
	62	err=$(make_data "${perfdata2}")
	63	if [ $err != 0 ]
	64	then
	65	return
	66	fi
	67
	68	if ! perf diff "${perfdata1}" "${perfdata2}" \| grep -q "${testsym}"
	69	then
	70	echo "Basic two file diff test [Failed diff]"
	71	err=1
	72	return
	73	fi
	74	echo "Basic two file diff test [Success]"
	75	}
	76
	77	test_three_files() {
	78	echo "Basic three file diff test"
	79	err=$(make_data "${perfdata1}")
	80	if [ $err != 0 ]
	81	then
	82	return
	83	fi
	84	err=$(make_data "${perfdata2}")
	85	if [ $err != 0 ]
	86	then
	87	return
	88	fi
	89	err=$(make_data "${perfdata3}")
	90	if [ $err != 0 ]
	91	then
	92	return
	93	fi
	94
	95	if ! perf diff "${perfdata1}" "${perfdata2}" "${perfdata3}" \| grep -q "${testsym}"
	96	then
	97	echo "Basic three file diff test [Failed diff]"
	98	err=1
	99	return
	100	fi
	101	echo "Basic three file diff test [Success]"
	102	}
	103
	104	test_two_files
	105	test_three_files
	106
	107	cleanup
	108	exit $err

tools/perf/tests/shell/lib/perf_has_symbol.sh+21−0

@@ -0,0 +1,21 @@
	1	#!/bin/sh
	2	# SPDX-License-Identifier: GPL-2.0
	3
	4	perf_has_symbol()
	5	{
	6	if perf test -vv "Symbols" 2>&1 \| grep "[[:space:]]$1$"; then
	7	echo "perf does have symbol '$1'"
	8	return 0
	9	fi
	10	echo "perf does not have symbol '$1'"
	11	return 1
	12	}
	13
	14	skip_test_missing_symbol()
	15	{
	16	if ! perf_has_symbol "$1" ; then
	17	echo "perf is missing symbols - skipping test"
	18	exit 2
	19	fi
	20	return 0
	21	}

tools/perf/tests/shell/lib/setup_python.sh+16−0

@@ -0,0 +1,16 @@
	1	#!/bin/sh
	2	# SPDX-License-Identifier: GPL-2.0
	3
	4	if [ "x$PYTHON" = "x" ]
	5	then
	6	python3 --version >/dev/null 2>&1 && PYTHON=python3
	7	fi
	8	if [ "x$PYTHON" = "x" ]
	9	then
	10	python --version >/dev/null 2>&1 && PYTHON=python
	11	fi
	12	if [ "x$PYTHON" = "x" ]
	13	then
	14	echo Skipping test, python not detected please set environment variable PYTHON.
	15	exit 2
	16	fi

tools/perf/tests/shell/list.sh+19−0

@@ -0,0 +1,19 @@
	1	#!/bin/sh
	2	# perf list tests
	3	# SPDX-License-Identifier: GPL-2.0
	4
	5	set -e
	6	err=0
	7
	8	shelldir=$(dirname "$0")
	9	# shellcheck source=lib/setup_python.sh
	10	. "${shelldir}"/lib/setup_python.sh
	11
	12	test_list_json() {
	13	echo "Json output test"
	14	perf list -j \| $PYTHON -m json.tool
	15	echo "Json output test [Success]"
	16	}
	17
	18	test_list_json
	19	exit $err

tools/perf/tests/shell/pipe_test.sh+8−1

 # perf pipe recording and injection test
 # SPDX-License-Identifier: GPL-2.0
+shelldir=$(dirname "$0")
+# shellcheck source=lib/perf_has_symbol.sh
+. "${shelldir}"/lib/perf_has_symbol.sh
+sym="noploop"
+skip_test_missing_symbol ${sym}
 data=$(mktemp /tmp/perf.data.XXXXXX)
 prog="perf test -w noploop"
 task="perf"
-sym="noploop"
 if ! perf record -e task-clock:u -o - ${prog} | perf report -i - --task | grep ${task}; then
 	echo "cannot find the test file in the perf report"

tools/perf/tests/shell/record+probe_libc_inet_pton.sh+4−1

 		;;
 	ppc64|ppc64le)
 		eventattr='max-stack=4'
-		echo "gaih_inet.*\+0x[[:xdigit:]]+[[:space:]]\($libc\)$" >> $expected
+		# Add gaih_inet to expected backtrace only if it is part of libc.
+		if nm $libc | grep -F -q gaih_inet.; then
+			echo "gaih_inet.*\+0x[[:xdigit:]]+[[:space:]]\($libc\)$" >> $expected
+		fi
 		echo "getaddrinfo\+0x[[:xdigit:]]+[[:space:]]\($libc\)$" >> $expected
 		echo ".*(\+0x[[:xdigit:]]+|\[unknown\])[[:space:]]\(.*/bin/ping.*\)$" >> $expected
 		;;

tools/perf/tests/shell/record.sh+37−1

@@ -8,10 +8,19 @@ shelldir=$(dirname "$0") · 7 unmodified lines
8	# shellcheck source=lib/waiting.sh	8	# shellcheck source=lib/waiting.sh
9	. "${shelldir}"/lib/waiting.sh	9	. "${shelldir}"/lib/waiting.sh
10		10
		11	# shellcheck source=lib/perf_has_symbol.sh
		12	. "${shelldir}"/lib/perf_has_symbol.sh
		13
		14	testsym="test_loop"
		15
		16	skip_test_missing_symbol ${testsym}
		17
11	err=0	18	err=0
12	perfdata=$(mktemp /tmp/__perf_test.perf.data.XXXXX)	19	perfdata=$(mktemp /tmp/__perf_test.perf.data.XXXXX)
13	testprog="perf test -w thloop"	20	testprog="perf test -w thloop"
14	testsym="test_loop"	21	cpu_pmu_dir="/sys/bus/event_source/devices/cpu*"
		22	br_cntr_file="/caps/branch_counter_nr"
		23	br_cntr_output="branch stack counters"
15		24
16	cleanup() {	25	cleanup() {
17	rm -rf "${perfdata}"	26	rm -rf "${perfdata}"
@@ -155,10 +164,37 @@ test_workload() { · 137 unmodified lines
155	echo "Basic target workload test [Success]"	164	echo "Basic target workload test [Success]"
156	}	165	}
157		166
		167	test_branch_counter() {
		168	echo "Basic branch counter test"
		169	# Check if the branch counter feature is supported
		170	for dir in $cpu_pmu_dir
		171	do
		172	if [ ! -e "$dir$br_cntr_file" ]
		173	then
		174	echo "branch counter feature not supported on all core PMUs ($dir) [Skipped]"
		175	return
		176	fi
		177	done
		178	if ! perf record -o "${perfdata}" -j any,counter ${testprog} 2> /dev/null
		179	then
		180	echo "Basic branch counter test [Failed record]"
		181	err=1
		182	return
		183	fi
		184	if ! perf report -i "${perfdata}" -D -q \| grep -q "$br_cntr_output"
		185	then
		186	echo "Basic branch record test [Failed missing output]"
		187	err=1
		188	return
		189	fi
		190	echo "Basic branch counter test [Success]"
		191	}
		192
158	test_per_thread	193	test_per_thread
159	test_register_capture	194	test_register_capture
160	test_system_wide	195	test_system_wide
161	test_workload	196	test_workload
		197	test_branch_counter
162		198
163	cleanup	199	cleanup
164	exit $err	200	exit $err

tools/perf/tests/shell/record_offcpu.sh+2−2

@@ -77,9 +77,9 @@ test_offcpu_child() { · 76 unmodified lines
77	err=1	77	err=1
78	return	78	return
79	fi	79	fi
80	# each process waits for read and write, so it should be more than 800 events	80	# each process waits at least for poll, so it should be more than 400 events
81	if ! perf report -i ${perfdata} -s comm -q -n -t ';' --percent-limit=90 \| \	81	if ! perf report -i ${perfdata} -s comm -q -n -t ';' --percent-limit=90 \| \
82	awk -F ";" '{ if (NF > 3 && int($3) < 800) exit 1; }'	82	awk -F ";" '{ if (NF > 3 && int($3) < 400) exit 1; }'
83	then	83	then
84	echo "Child task off-cpu test [Failed invalid output]"	84	echo "Child task off-cpu test [Failed invalid output]"
85	err=1	85	err=1

tools/perf/tests/shell/script.sh+66−0

@@ -0,0 +1,66 @@
	1	#!/bin/sh
	2	# perf script tests
	3	# SPDX-License-Identifier: GPL-2.0
	4
	5	set -e
	6
	7	temp_dir=$(mktemp -d /tmp/perf-test-script.XXXXXXXXXX)
	8
	9	perfdatafile="${temp_dir}/perf.data"
	10	db_test="${temp_dir}/db_test.py"
	11
	12	err=0
	13
	14	cleanup()
	15	{
	16	trap - EXIT TERM INT
	17	sane=$(echo "${temp_dir}" \| cut -b 1-21)
	18	if [ "${sane}" = "/tmp/perf-test-script" ] ; then
	19	echo "--- Cleaning up ---"
	20	rm -f "${temp_dir}/"*
	21	rmdir "${temp_dir}"
	22	fi
	23	}
	24
	25	trap_cleanup()
	26	{
	27	cleanup
	28	exit 1
	29	}
	30
	31	trap trap_cleanup EXIT TERM INT
	32
	33
	34	test_db()
	35	{
	36	echo "DB test"
	37
	38	# Check if python script is supported
	39	libpython=$(perf version --build-options \| grep python \| grep -cv OFF)
	40	if [ "${libpython}" != "1" ] ; then
	41	echo "SKIP: python scripting is not supported"
	42	err=2
	43	return
	44	fi
	45
	46	cat << "_end_of_file_" > "${db_test}"
	47	perf_db_export_mode = True
	48	perf_db_export_calls = False
	49	perf_db_export_callchains = True
	50
	51	def sample_table(*args):
	52	print(f'sample_table({args})')
	53
	54	def call_path_table(*args):
	55	print(f'call_path_table({args}')
	56	_end_of_file_
	57	perf record -g -o "${perfdatafile}" true
	58	perf script -i "${perfdatafile}" -s "${db_test}"
	59	echo "DB test [Success]"
	60	}
	61
	62	test_db
	63
	64	cleanup
	65
	66	exit $err

tools/perf/tests/shell/stat+json_output.sh+3−13

@@ -8,20 +8,10 @@ set -e · 7 unmodified lines
8		8
9	skip_test=0	9	skip_test=0
10		10
		11	shelldir=$(dirname "$0")
		12	# shellcheck source=lib/setup_python.sh
		13	. "${shelldir}"/lib/setup_python.sh
11	pythonchecker=$(dirname $0)/lib/perf_json_output_lint.py	14	pythonchecker=$(dirname $0)/lib/perf_json_output_lint.py
12	if [ "x$PYTHON" == "x" ]
13	then
14	if which python3 > /dev/null
15	then
16	PYTHON=python3
17	elif which python > /dev/null
18	then
19	PYTHON=python
20	else
21	echo Skipping test, python not detected please set environment variable PYTHON.
22	exit 2
23	fi
24	fi
25		15
26	stat_output=$(mktemp /tmp/__perf_test.stat_output.json.XXXXX)	16	stat_output=$(mktemp /tmp/__perf_test.stat_output.json.XXXXX)
27		17

tools/perf/tests/shell/stat_all_pmu.sh+1−1

@@ -4,7 +4,7 @@ · 3 unmodified lines
4		4
5	set -e	5	set -e
6		6
7	# Test all PMU events; however exclude parametrized ones (name contains '?')	7	# Test all PMU events; however exclude parameterized ones (name contains '?')
8	for p in $(perf list --raw-dump pmu \| sed 's/[[:graph:]]\+?[[:graph:]]\+[[:space:]]//g'); do	8	for p in $(perf list --raw-dump pmu \| sed 's/[[:graph:]]\+?[[:graph:]]\+[[:space:]]//g'); do
9	echo "Testing $p"	9	echo "Testing $p"
10	result=$(perf stat -e "$p" true 2>&1)	10	result=$(perf stat -e "$p" true 2>&1)

tools/perf/tests/shell/stat_metrics_values.sh+4−10

@@ -1,16 +1,10 @@
1	#!/bin/bash	1	#!/bin/bash
2	# perf metrics value validation	2	# perf metrics value validation
3	# SPDX-License-Identifier: GPL-2.0	3	# SPDX-License-Identifier: GPL-2.0
4	if [ "x$PYTHON" == "x" ]	4
5	then	5	shelldir=$(dirname "$0")
6	if which python3 > /dev/null	6	# shellcheck source=lib/setup_python.sh
7	then	7	. "${shelldir}"/lib/setup_python.sh
8	PYTHON=python3
9	else
10	echo Skipping test, python3 not detected please set environment variable PYTHON.
11	exit 2
12	fi
13	fi
14		8
15	grep -q GenuineIntel /proc/cpuinfo \|\| { echo Skipping non-Intel; exit 2; }	9	grep -q GenuineIntel /proc/cpuinfo \|\| { echo Skipping non-Intel; exit 2; }
16		10

tools/perf/tests/shell/test_arm_callgraph_fp.sh+6−0

 # Check Arm64 callgraphs are complete in fp mode
 # SPDX-License-Identifier: GPL-2.0
+shelldir=$(dirname "$0")
+# shellcheck source=lib/perf_has_symbol.sh
+. "${shelldir}"/lib/perf_has_symbol.sh
 lscpu | grep -q "aarch64" || exit 2
+skip_test_missing_symbol leafloop
 PERF_DATA=$(mktemp /tmp/__perf_test.perf.data.XXXXX)
 TEST_PROGRAM="perf test -w leafloop"

tools/perf/tests/shell/test_brstack.sh+6−0

 # SPDX-License-Identifier: GPL-2.0
 # German Gomez <german.gomez@arm.com>, 2022
+shelldir=$(dirname "$0")
+# shellcheck source=lib/perf_has_symbol.sh
+. "${shelldir}"/lib/perf_has_symbol.sh
 # skip the test if the hardware doesn't support branch stack sampling
 # and if the architecture doesn't support filter types: any,save_type,u
 if ! perf record -o- --no-buildid --branch-filter any,save_type,u -- true > /dev/null 2>&1 ; then
 	exit 2
 fi
+skip_test_missing_symbol brstack_bench
 TMPDIR=$(mktemp -d /tmp/__perf_test.program.XXXXX)
 TESTPROG="perf test -w brstack"

tools/perf/tests/shell/test_data_symbol.sh+14−2

 # SPDX-License-Identifier: GPL-2.0
 # Leo Yan <leo.yan@linaro.org>, 2022
+shelldir=$(dirname "$0")
+# shellcheck source=lib/waiting.sh
+. "${shelldir}"/lib/waiting.sh
+# shellcheck source=lib/perf_has_symbol.sh
+. "${shelldir}"/lib/perf_has_symbol.sh
 skip_if_no_mem_event() {
 	perf mem record -e list 2>&1 | grep -E -q 'available' && return 0
 	return 2
 skip_if_no_mem_event || exit 2
+skip_test_missing_symbol buf1
 TEST_PROGRAM="perf test -w datasym"
 PERF_DATA=$(mktemp /tmp/__perf_test.perf.data.XXXXX)
+ERR_FILE=$(mktemp /tmp/__perf_test.stderr.XXXXX)
 check_result() {
 	# The memory report format is as below:
 # specific CPU and test in per-CPU mode.
 is_amd=$(grep -E -c 'vendor_id.*AuthenticAMD' /proc/cpuinfo)
 if (($is_amd >= 1)); then
-	perf mem record -o ${PERF_DATA} -C 0 -- taskset -c 0 $TEST_PROGRAM &
+	perf mem record -vvv -o ${PERF_DATA} -C 0 -- taskset -c 0 $TEST_PROGRAM 2>"${ERR_FILE}" &
 else
-	perf mem record --all-user -o ${PERF_DATA} -- $TEST_PROGRAM &
+	perf mem record -vvv --all-user -o ${PERF_DATA} -- $TEST_PROGRAM 2>"${ERR_FILE}" &
 fi
 PERFPID=$!
+wait_for_perf_to_start ${PERFPID} "${ERR_FILE}"
 sleep 1
 kill $PERFPID

tools/perf/tests/shell/test_perf_data_converter_json.sh+3−10

 err=0
-if [ "$PYTHON" = "" ] ; then
+shelldir=$(dirname "$0")
-	if which python3 > /dev/null ; then
+# shellcheck source=lib/setup_python.sh
-		PYTHON=python3
+. "${shelldir}"/lib/setup_python.sh
-	elif which python > /dev/null ; then
-		PYTHON=python
-	else
-		echo Skipping test, python not detected please set environment variable PYTHON.
-		exit 2
-	fi
-fi
 perfdata=$(mktemp /tmp/__perf_test.perf.data.XXXXX)
 result=$(mktemp /tmp/__perf_test.output.json.XXXXX)

tools/perf/tests/sigtrap.c+84−22

@@ -57,36 +57,79 @@ static struct perf_event_attr make_event_attr(void) · 56 unmodified lines
57	#ifdef HAVE_BPF_SKEL	57	#ifdef HAVE_BPF_SKEL
58	#include <bpf/btf.h>	58	#include <bpf/btf.h>
59		59
60	static bool attr_has_sigtrap(void)	60	static struct btf *btf;
		61
		62	static bool btf__available(void)
61	{	63	{
62	bool ret = false;	64	if (btf == NULL)
63	struct btf *btf;	65	btf = btf__load_vmlinux_btf();
64	const struct btf_type *t;	66
		67	return btf != NULL;
		68	}
		69
		70	static void btf__exit(void)
		71	{
		72	btf__free(btf);
		73	btf = NULL;
		74	}
		75
		76	static const struct btf_member __btf_type__find_member_by_name(int type_id, const char member_name)
		77	{
		78	const struct btf_type *t = btf__type_by_id(btf, type_id);
65	const struct btf_member *m;	79	const struct btf_member *m;
66	const char *name;	80	int i;
67	int i, id;	81
		82	for (i = 0, m = btf_members(t); i < btf_vlen(t); i++, m++) {
		83	const char *current_member_name = btf__name_by_offset(btf, m->name_off);
		84	if (!strcmp(current_member_name, member_name))
		85	return m;
		86	}
68		87
69	btf = btf__load_vmlinux_btf();	88	return NULL;
70	if (btf == NULL) {	89	}
		90
		91	static bool attr_has_sigtrap(void)
		92	{
		93	int id;
		94
		95	if (!btf__available()) {
71	/* should be an old kernel */	96	/* should be an old kernel */
72	return false;	97	return false;
73	}	98	}
74		99
75	id = btf__find_by_name_kind(btf, "perf_event_attr", BTF_KIND_STRUCT);	100	id = btf__find_by_name_kind(btf, "perf_event_attr", BTF_KIND_STRUCT);
76	if (id < 0)	101	if (id < 0)
77	goto out;	102	return false;
78		103
79	t = btf__type_by_id(btf, id);	104	return __btf_type__find_member_by_name(id, "sigtrap") != NULL;
80	for (i = 0, m = btf_members(t); i < btf_vlen(t); i++, m++) {	105	}
81	name = btf__name_by_offset(btf, m->name_off);	106
82	if (!strcmp(name, "sigtrap")) {	107	static bool kernel_with_sleepable_spinlocks(void)
83	ret = true;	108	{
84	break;	109	const struct btf_member *member;
85	}	110	const struct btf_type *type;
86	}	111	const char *type_name;
87	out:	112	int id;
88	btf__free(btf);	113
89	return ret;	114	if (!btf__available())
		115	return false;
		116
		117	id = btf__find_by_name_kind(btf, "spinlock", BTF_KIND_STRUCT);
		118	if (id < 0)
		119	return false;
		120
		121	// Only RT has a "lock" member for "struct spinlock"
		122	member = __btf_type__find_member_by_name(id, "lock");
		123	if (member == NULL)
		124	return false;
		125
		126	// But check its type as well
		127	type = btf__type_by_id(btf, member->type);
		128	if (!type \|\| !btf_is_struct(type))
		129	return false;
		130
		131	type_name = btf__name_by_offset(btf, type->name_off);
		132	return type_name && !strcmp(type_name, "rt_mutex_base");
90	}	133	}
91	#else /* !HAVE_BPF_SKEL */	134	#else /* !HAVE_BPF_SKEL */
92	static bool attr_has_sigtrap(void)	135	static bool attr_has_sigtrap(void)
@@ -109,6 +152,15 @@ static bool attr_has_sigtrap(void) · 16 unmodified lines
109		152
110	return ret;	153	return ret;
111	}	154	}
		155
		156	static bool kernel_with_sleepable_spinlocks(void)
		157	{
		158	return false;
		159	}
		160
		161	static void btf__exit(void)
		162	{
		163	}
112	#endif /* HAVE_BPF_SKEL */	164	#endif /* HAVE_BPF_SKEL */
113		165
114	static void	166	static void
@@ -147,7 +199,7 @@ static int run_test_threads(pthread_t threads, pthread_barrier_t barrier) · 32 unmodified lines
147		199
148	static int run_stress_test(int fd, pthread_t threads, pthread_barrier_t barrier)	200	static int run_stress_test(int fd, pthread_t threads, pthread_barrier_t barrier)
149	{	201	{
150	int ret;	202	int ret, expected_sigtraps;
151		203
152	ctx.iterate_on = 3000;	204	ctx.iterate_on = 3000;
153		205
@@ -156,7 +208,16 @@ static int run_stress_test(int fd, pthread_t threads, pthread_barrier_t barrie · 2 unmodified lines
156	ret = run_test_threads(threads, barrier);	208	ret = run_test_threads(threads, barrier);
157	TEST_ASSERT_EQUAL("disable failed", ioctl(fd, PERF_EVENT_IOC_DISABLE, 0), 0);	209	TEST_ASSERT_EQUAL("disable failed", ioctl(fd, PERF_EVENT_IOC_DISABLE, 0), 0);
158		210
159	TEST_ASSERT_EQUAL("unexpected sigtraps", ctx.signal_count, NUM_THREADS * ctx.iterate_on);	211	expected_sigtraps = NUM_THREADS * ctx.iterate_on;
		212
		213	if (ctx.signal_count < expected_sigtraps && kernel_with_sleepable_spinlocks()) {
		214	pr_debug("Expected %d sigtraps, got %d, running on a kernel with sleepable spinlocks.\n",
		215	expected_sigtraps, ctx.signal_count);
		216	pr_debug("See https://lore.kernel.org/all/e368f2c848d77fbc8d259f44e2055fe469c219cf.camel@gmx.de/\n");
		217	return TEST_SKIP;
		218	} else
		219	TEST_ASSERT_EQUAL("unexpected sigtraps", ctx.signal_count, expected_sigtraps);
		220
160	TEST_ASSERT_EQUAL("missing signals or incorrectly delivered", ctx.tids_want_signal, 0);	221	TEST_ASSERT_EQUAL("missing signals or incorrectly delivered", ctx.tids_want_signal, 0);
161	TEST_ASSERT_VAL("unexpected si_addr", ctx.first_siginfo.si_addr == &ctx.iterate_on);	222	TEST_ASSERT_VAL("unexpected si_addr", ctx.first_siginfo.si_addr == &ctx.iterate_on);
162	#if 0 /* FIXME: enable when libc's signal.h has si_perf_{type,data} */	223	#if 0 /* FIXME: enable when libc's signal.h has si_perf_{type,data} */
@@ -221,6 +282,7 @@ out_restore_sigaction: · 58 unmodified lines
221	sigaction(SIGTRAP, &oldact, NULL);	282	sigaction(SIGTRAP, &oldact, NULL);
222	out:	283	out:
223	pthread_barrier_destroy(&barrier);	284	pthread_barrier_destroy(&barrier);
		285	btf__exit();
224	return ret;	286	return ret;
225	}	287	}
226		288

tools/perf/tests/sw-clock.c+1−1

@@ -62,7 +62,7 @@ static int __test__sw_clock_freq(enum perf_sw_ids clock_id) · 61 unmodified lines
62	}	62	}
63	evlist__add(evlist, evsel);	63	evlist__add(evlist, evsel);
64		64
65	cpus = perf_cpu_map__dummy_new();	65	cpus = perf_cpu_map__new_any_cpu();
66	threads = thread_map__new_by_tid(getpid());	66	threads = thread_map__new_by_tid(getpid());
67	if (!cpus \|\| !threads) {	67	if (!cpus \|\| !threads) {
68	err = -ENOMEM;	68	err = -ENOMEM;

tools/perf/tests/switch-tracking.c+1−1

@@ -351,7 +351,7 @@ static int test__switch_tracking(struct test_suite *test __maybe_unused, int sub · 350 unmodified lines
351	goto out_err;	351	goto out_err;
352	}	352	}
353		353
354	cpus = perf_cpu_map__new(NULL);	354	cpus = perf_cpu_map__new_online_cpus();
355	if (!cpus) {	355	if (!cpus) {
356	pr_debug("perf_cpu_map__new failed!\n");	356	pr_debug("perf_cpu_map__new failed!\n");
357	goto out_err;	357	goto out_err;

tools/perf/tests/task-exit.c+1−1

@@ -70,7 +70,7 @@ static int test__task_exit(struct test_suite *test __maybe_unused, int subtest _ · 69 unmodified lines
70	* evlist__prepare_workload we'll fill in the only thread	70	* evlist__prepare_workload we'll fill in the only thread
71	* we're monitoring, the one forked there.	71	* we're monitoring, the one forked there.
72	*/	72	*/
73	cpus = perf_cpu_map__dummy_new();	73	cpus = perf_cpu_map__new_any_cpu();
74	threads = thread_map__new_by_tid(-1);	74	threads = thread_map__new_by_tid(-1);
75	if (!cpus \|\| !threads) {	75	if (!cpus \|\| !threads) {
76	err = -ENOMEM;	76	err = -ENOMEM;

tools/perf/tests/tests.h+1−0

@@ -207,5 +207,6 @@ DECLARE_WORKLOAD(brstack); · 206 unmodified lines
207	DECLARE_WORKLOAD(datasym);	207	DECLARE_WORKLOAD(datasym);
208		208
209	extern const char *dso_to_test;	209	extern const char *dso_to_test;
		210	extern const char *test_objdump_path;
210		211
211	#endif /* TESTS_H */	212	#endif /* TESTS_H */

tools/perf/tests/topology.c+1−1

@@ -215,7 +215,7 @@ static int test__session_topology(struct test_suite *test __maybe_unused, int su · 214 unmodified lines
215	if (session_write_header(path))	215	if (session_write_header(path))
216	goto free_path;	216	goto free_path;
217		217
218	map = perf_cpu_map__new(NULL);	218	map = perf_cpu_map__new_online_cpus();
219	if (map == NULL) {	219	if (map == NULL) {
220	pr_debug("failed to get system cpumap\n");	220	pr_debug("failed to get system cpumap\n");
221	goto free_path;	221	goto free_path;

tools/perf/tests/vmlinux-kallsyms.c+98−83

@@ -112,18 +112,92 @@ static bool is_ignored_symbol(const char *name, char type) · 111 unmodified lines
112	return false;	112	return false;
113	}	113	}
114		114
		115	struct test__vmlinux_matches_kallsyms_cb_args {
		116	struct machine kallsyms;
		117	struct map *vmlinux_map;
		118	bool header_printed;
		119	};
		120
		121	static int test__vmlinux_matches_kallsyms_cb1(struct map map, void data)
		122	{
		123	struct test__vmlinux_matches_kallsyms_cb_args *args = data;
		124	struct dso *dso = map__dso(map);
		125	/*
		126	* If it is the kernel, kallsyms is always "[kernel.kallsyms]", while
		127	* the kernel will have the path for the vmlinux file being used, so use
		128	* the short name, less descriptive but the same ("[kernel]" in both
		129	* cases.
		130	*/
		131	struct map *pair = maps__find_by_name(args->kallsyms.kmaps,
		132	(dso->kernel ? dso->short_name : dso->name));
		133
		134	if (pair)
		135	map__set_priv(pair, 1);
		136	else {
		137	if (!args->header_printed) {
		138	pr_info("WARN: Maps only in vmlinux:\n");
		139	args->header_printed = true;
		140	}
		141	map__fprintf(map, stderr);
		142	}
		143	return 0;
		144	}
		145
		146	static int test__vmlinux_matches_kallsyms_cb2(struct map map, void data)
		147	{
		148	struct test__vmlinux_matches_kallsyms_cb_args *args = data;
		149	struct map *pair;
		150	u64 mem_start = map__unmap_ip(args->vmlinux_map, map__start(map));
		151	u64 mem_end = map__unmap_ip(args->vmlinux_map, map__end(map));
		152
		153	pair = maps__find(args->kallsyms.kmaps, mem_start);
		154	if (pair == NULL \|\| map__priv(pair))
		155	return 0;
		156
		157	if (map__start(pair) == mem_start) {
		158	struct dso *dso = map__dso(map);
		159
		160	if (!args->header_printed) {
		161	pr_info("WARN: Maps in vmlinux with a different name in kallsyms:\n");
		162	args->header_printed = true;
		163	}
		164
		165	pr_info("WARN: %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s in kallsyms as",
		166	map__start(map), map__end(map), map__pgoff(map), dso->name);
		167	if (mem_end != map__end(pair))
		168	pr_info(":\nWARN: *%" PRIx64 "-%" PRIx64 " %" PRIx64,
		169	map__start(pair), map__end(pair), map__pgoff(pair));
		170	pr_info(" %s\n", dso->name);
		171	map__set_priv(pair, 1);
		172	}
		173	return 0;
		174	}
		175
		176	static int test__vmlinux_matches_kallsyms_cb3(struct map map, void data)
		177	{
		178	struct test__vmlinux_matches_kallsyms_cb_args *args = data;
		179
		180	if (!map__priv(map)) {
		181	if (!args->header_printed) {
		182	pr_info("WARN: Maps only in kallsyms:\n");
		183	args->header_printed = true;
		184	}
		185	map__fprintf(map, stderr);
		186	}
		187	return 0;
		188	}
		189
115	static int test__vmlinux_matches_kallsyms(struct test_suite *test __maybe_unused,	190	static int test__vmlinux_matches_kallsyms(struct test_suite *test __maybe_unused,
116	int subtest __maybe_unused)	191	int subtest __maybe_unused)
117	{	192	{
118	int err = TEST_FAIL;	193	int err = TEST_FAIL;
119	struct rb_node *nd;	194	struct rb_node *nd;
120	struct symbol *sym;	195	struct symbol *sym;
121	struct map kallsyms_map, vmlinux_map;	196	struct map *kallsyms_map;
122	struct map_rb_node *rb_node;	197	struct machine vmlinux;
123	struct machine kallsyms, vmlinux;
124	struct maps *maps;	198	struct maps *maps;
125	u64 mem_start, mem_end;	199	u64 mem_start, mem_end;
126	bool header_printed;	200	struct test__vmlinux_matches_kallsyms_cb_args args;
127		201
128	/*	202	/*
129	* Step 1:	203	* Step 1:
@@ -131,7 +205,7 @@ static int test__vmlinux_matches_kallsyms(struct test_suite *test __maybe_unused · 1 unmodified line
131	* Init the machines that will hold kernel, modules obtained from	205	* Init the machines that will hold kernel, modules obtained from
132	* both vmlinux + .ko files and from /proc/kallsyms split by modules.	206	* both vmlinux + .ko files and from /proc/kallsyms split by modules.
133	*/	207	*/
134	machine__init(&kallsyms, "", HOST_KERNEL_ID);	208	machine__init(&args.kallsyms, "", HOST_KERNEL_ID);
135	machine__init(&vmlinux, "", HOST_KERNEL_ID);	209	machine__init(&vmlinux, "", HOST_KERNEL_ID);
136		210
137	maps = machine__kernel_maps(&vmlinux);	211	maps = machine__kernel_maps(&vmlinux);
@@ -143,7 +217,7 @@ static int test__vmlinux_matches_kallsyms(struct test_suite *test __maybe_unused · 5 unmodified lines
143	* load /proc/kallsyms. Also create the modules maps from /proc/modules	217	* load /proc/kallsyms. Also create the modules maps from /proc/modules
144	* and find the .ko files that match them in /lib/modules/`uname -r`/.	218	* and find the .ko files that match them in /lib/modules/`uname -r`/.
145	*/	219	*/
146	if (machine__create_kernel_maps(&kallsyms) < 0) {	220	if (machine__create_kernel_maps(&args.kallsyms) < 0) {
147	pr_debug("machine__create_kernel_maps failed");	221	pr_debug("machine__create_kernel_maps failed");
148	err = TEST_SKIP;	222	err = TEST_SKIP;
149	goto out;	223	goto out;
@@ -160,7 +234,7 @@ static int test__vmlinux_matches_kallsyms(struct test_suite *test __maybe_unused · 10 unmodified lines
160	* be compacted against the list of modules found in the "vmlinux"	234	* be compacted against the list of modules found in the "vmlinux"
161	* code and with the one got from /proc/modules from the "kallsyms" code.	235	* code and with the one got from /proc/modules from the "kallsyms" code.
162	*/	236	*/
163	if (machine__load_kallsyms(&kallsyms, "/proc/kallsyms") <= 0) {	237	if (machine__load_kallsyms(&args.kallsyms, "/proc/kallsyms") <= 0) {
164	pr_debug("machine__load_kallsyms failed");	238	pr_debug("machine__load_kallsyms failed");
165	err = TEST_SKIP;	239	err = TEST_SKIP;
166	goto out;	240	goto out;
@@ -174,7 +248,7 @@ static int test__vmlinux_matches_kallsyms(struct test_suite *test __maybe_unused · 7 unmodified lines
174	* to see if the running kernel was relocated by checking if it has the	248	* to see if the running kernel was relocated by checking if it has the
175	* same value in the vmlinux file we load.	249	* same value in the vmlinux file we load.
176	*/	250	*/
177	kallsyms_map = machine__kernel_map(&kallsyms);	251	kallsyms_map = machine__kernel_map(&args.kallsyms);
178		252
179	/*	253	/*
180	* Step 5:	254	* Step 5:
@@ -186,7 +260,7 @@ static int test__vmlinux_matches_kallsyms(struct test_suite *test __maybe_unused · 5 unmodified lines
186	goto out;	260	goto out;
187	}	261	}
188		262
189	vmlinux_map = machine__kernel_map(&vmlinux);	263	args.vmlinux_map = machine__kernel_map(&vmlinux);
190		264
191	/*	265	/*
192	* Step 6:	266	* Step 6:
@@ -213,7 +287,7 @@ static int test__vmlinux_matches_kallsyms(struct test_suite *test __maybe_unused · 20 unmodified lines
213	* in the kallsyms dso. For the ones that are in both, check its names and	287	* in the kallsyms dso. For the ones that are in both, check its names and
214	* end addresses too.	288	* end addresses too.
215	*/	289	*/
216	map__for_each_symbol(vmlinux_map, sym, nd) {	290	map__for_each_symbol(args.vmlinux_map, sym, nd) {
217	struct symbol pair, first_pair;	291	struct symbol pair, first_pair;
218		292
219	sym = rb_entry(nd, struct symbol, rb_node);	293	sym = rb_entry(nd, struct symbol, rb_node);
@@ -221,10 +295,10 @@ static int test__vmlinux_matches_kallsyms(struct test_suite *test __maybe_unused · 1 unmodified line
221	if (sym->start == sym->end)	295	if (sym->start == sym->end)
222	continue;	296	continue;
223		297
224	mem_start = map__unmap_ip(vmlinux_map, sym->start);	298	mem_start = map__unmap_ip(args.vmlinux_map, sym->start);
225	mem_end = map__unmap_ip(vmlinux_map, sym->end);	299	mem_end = map__unmap_ip(args.vmlinux_map, sym->end);
226		300
227	first_pair = machine__find_kernel_symbol(&kallsyms, mem_start, NULL);	301	first_pair = machine__find_kernel_symbol(&args.kallsyms, mem_start, NULL);
228	pair = first_pair;	302	pair = first_pair;
229		303
230	if (pair && UM(pair->start) == mem_start) {	304	if (pair && UM(pair->start) == mem_start) {
@@ -253,7 +327,8 @@ next_pair: · 22 unmodified lines
253	*/	327	*/
254	continue;	328	continue;
255	} else {	329	} else {
256	pair = machine__find_kernel_symbol_by_name(&kallsyms, sym->name, NULL);	330	pair = machine__find_kernel_symbol_by_name(&args.kallsyms,
		331	sym->name, NULL);
257	if (pair) {	332	if (pair) {
258	if (UM(pair->start) == mem_start)	333	if (UM(pair->start) == mem_start)
259	goto next_pair;	334	goto next_pair;
@@ -267,7 +342,7 @@ next_pair: · 7 unmodified lines
267		342
268	continue;	343	continue;
269	}	344	}
270	} else if (mem_start == map__end(kallsyms.vmlinux_map)) {	345	} else if (mem_start == map__end(args.kallsyms.vmlinux_map)) {
271	/*	346	/*
272	* Ignore aliases to _etext, i.e. to the end of the kernel text area,	347	* Ignore aliases to _etext, i.e. to the end of the kernel text area,
273	* such as __indirect_thunk_end.	348	* such as __indirect_thunk_end.
@@ -289,78 +364,18 @@ next_pair: · 15 unmodified lines
289	if (verbose <= 0)	364	if (verbose <= 0)
290	goto out;	365	goto out;
291		366
292	header_printed = false;	367	args.header_printed = false;
293		368	maps__for_each_map(maps, test__vmlinux_matches_kallsyms_cb1, &args);
294	maps__for_each_entry(maps, rb_node) {
295	struct map *map = rb_node->map;
296	struct dso *dso = map__dso(map);
297	/*
298	* If it is the kernel, kallsyms is always "[kernel.kallsyms]", while
299	* the kernel will have the path for the vmlinux file being used,
300	* so use the short name, less descriptive but the same ("[kernel]" in
301	* both cases.
302	*/
303	struct map *pair = maps__find_by_name(kallsyms.kmaps, (dso->kernel ?
304	dso->short_name :
305	dso->name));
306	if (pair) {
307	map__set_priv(pair, 1);
308	} else {
309	if (!header_printed) {
310	pr_info("WARN: Maps only in vmlinux:\n");
311	header_printed = true;
312	}
313	map__fprintf(map, stderr);
314	}
315	}
316
317	header_printed = false;
318
319	maps__for_each_entry(maps, rb_node) {
320	struct map pair, map = rb_node->map;
321
322	mem_start = map__unmap_ip(vmlinux_map, map__start(map));
323	mem_end = map__unmap_ip(vmlinux_map, map__end(map));
324		369
325	pair = maps__find(kallsyms.kmaps, mem_start);	370	args.header_printed = false;
326	if (pair == NULL \|\| map__priv(pair))	371	maps__for_each_map(maps, test__vmlinux_matches_kallsyms_cb2, &args);
327	continue;
328
329	if (map__start(pair) == mem_start) {
330	struct dso *dso = map__dso(map);
331
332	if (!header_printed) {
333	pr_info("WARN: Maps in vmlinux with a different name in kallsyms:\n");
334	header_printed = true;
335	}
336
337	pr_info("WARN: %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s in kallsyms as",
338	map__start(map), map__end(map), map__pgoff(map), dso->name);
339	if (mem_end != map__end(pair))
340	pr_info(":\nWARN: *%" PRIx64 "-%" PRIx64 " %" PRIx64,
341	map__start(pair), map__end(pair), map__pgoff(pair));
342	pr_info(" %s\n", dso->name);
343	map__set_priv(pair, 1);
344	}
345	}
346
347	header_printed = false;
348
349	maps = machine__kernel_maps(&kallsyms);
350		372
351	maps__for_each_entry(maps, rb_node) {	373	args.header_printed = false;
352	struct map *map = rb_node->map;	374	maps = machine__kernel_maps(&args.kallsyms);
		375	maps__for_each_map(maps, test__vmlinux_matches_kallsyms_cb3, &args);
353		376
354	if (!map__priv(map)) {
355	if (!header_printed) {
356	pr_info("WARN: Maps only in kallsyms:\n");
357	header_printed = true;
358	}
359	map__fprintf(map, stderr);
360	}
361	}
362	out:	377	out:
363	machine__exit(&kallsyms);	378	machine__exit(&args.kallsyms);
364	machine__exit(&vmlinux);	379	machine__exit(&vmlinux);
365	return err;	380	return err;
366	}	381	}

tools/perf/tests/workloads/thloop.c+1−3

 #include "../tests.h"
 static volatile sig_atomic_t done;
-static volatile unsigned count;
 /* We want to check this symbol in perf report */
 noinline void test_loop(void);
 noinline void test_loop(void)
 {
-	while (!done)
+	while (!done);
-		__atomic_fetch_add(&count, 1, __ATOMIC_RELAXED);
 }
 static void *thfunc(void *arg)

tools/perf/trace/beauty/arch_errno_names.sh+6−4

 	archlist="$1"
 	default="$2"
-	printf 'const char *arch_syscalls__strerrno(const char *arch, int err)\n'
+	printf 'arch_syscalls__strerrno_t *arch_syscalls__strerrno_function(const char *arch)\n'
 	printf '{\n'
 	for arch in $archlist; do
 		printf '\tif (!strcmp(arch, "%s"))\n' $(arch_string "$arch")
-		printf '\t\treturn errno_to_name__%s(err);\n' $(arch_string "$arch")
+		printf '\t\treturn errno_to_name__%s;\n' $(arch_string "$arch")
 	done
-	printf '\treturn errno_to_name__%s(err);\n' $(arch_string "$default")
+	printf '\treturn errno_to_name__%s;\n' $(arch_string "$default")
 	printf '}\n'
 }
 # Create list of architectures that have a specific errno.h.
 archlist=""
-for arch in $(find $toolsdir/arch -maxdepth 1 -mindepth 1 -type d -printf "%f\n" | sort -r); do
+for f in $toolsdir/arch/*/include/uapi/asm/errno.h; do
+	d=${f%/include/uapi/asm/errno.h}
+	arch="${d##*/}"
 	test -f $toolsdir/arch/$arch/include/uapi/asm/errno.h && archlist="$archlist $arch"
 done

tools/perf/trace/beauty/beauty.h+0−2

@@ -251,6 +251,4 @@ size_t open__scnprintf_flags(unsigned long flags, char *bf, size_t size, bool sh · 250 unmodified lines
251	void syscall_arg__set_ret_scnprintf(struct syscall_arg *arg,	251	void syscall_arg__set_ret_scnprintf(struct syscall_arg *arg,
252	size_t (ret_scnprintf)(char bf, size_t size, struct syscall_arg *arg));	252	size_t (ret_scnprintf)(char bf, size_t size, struct syscall_arg *arg));
253		253
254	const char arch_syscalls__strerrno(const char arch, int err);
255
256	#endif /* _PERF_TRACE_BEAUTY_H */	254	#endif /* _PERF_TRACE_BEAUTY_H */

tools/perf/trace/beauty/prctl_option.sh+2−2

@@ -4,9 +4,9 @@ · 3 unmodified lines
4	[ $# -eq 1 ] && header_dir=$1 \|\| header_dir=tools/include/uapi/linux/	4	[ $# -eq 1 ] && header_dir=$1 \|\| header_dir=tools/include/uapi/linux/
5		5
6	printf "static const char *prctl_options[] = {\n"	6	printf "static const char *prctl_options[] = {\n"
7	regex='^#define[[:space:]]{1}PR_(\w+)[[:space:]]([[:xdigit:]]+)([[:space:]]\/.*)?$'	7	regex='^#define[[:space:]]{1}PR_(\w+)[[:space:]]([[:xdigit:]]+)([[:space:]]/.*)?$'
8	grep -E $regex ${header_dir}/prctl.h \| grep -v PR_SET_PTRACER \| \	8	grep -E $regex ${header_dir}/prctl.h \| grep -v PR_SET_PTRACER \| \
9	sed -r "s/$regex/\2 \1/g" \| \	9	sed -E "s%$regex%\2 \1%g" \| \
10	sort -n \| xargs printf "\t[%s] = \"%s\",\n"	10	sort -n \| xargs printf "\t[%s] = \"%s\",\n"
11	printf "};\n"	11	printf "};\n"
12		12

tools/perf/trace/beauty/socket.sh+2−2

@@ -18,10 +18,10 @@ grep -E $ipproto_regex ${uapi_header_dir}/in.h \| \ · 17 unmodified lines
18	printf "};\n\n"	18	printf "};\n\n"
19		19
20	printf "static const char *socket_level[] = {\n"	20	printf "static const char *socket_level[] = {\n"
21	socket_level_regex='^#define[[:space:]]+SOL_(\w+)[[:space:]]+([[:digit:]]+)([[:space:]]+\/.*)?'	21	socket_level_regex='^#define[[:space:]]+SOL_(\w+)[[:space:]]+([[:digit:]]+)([[:space:]]+/.*)?'
22		22
23	grep -E $socket_level_regex ${beauty_header_dir}/socket.h \| \	23	grep -E $socket_level_regex ${beauty_header_dir}/socket.h \| \
24	sed -r "s/$socket_level_regex/\2 \1/g" \| \	24	sed -E "s%$socket_level_regex%\2 \1%g" \| \
25	sort -n \| xargs printf "\t[%s] = \"%s\",\n"	25	sort -n \| xargs printf "\t[%s] = \"%s\",\n"
26	printf "};\n\n"	26	printf "};\n\n"
27		27

tools/perf/ui/browsers/annotate.c+48−56

 	struct rb_node		   *curr_hot;
 	struct annotation_line	   *selection;
 	struct arch		   *arch;
-	struct annotation_options  *opts;
 	bool			    searching_backwards;
 	char			    search_bf[128];
 };
 	return symbol__annotation(ms->sym);
 }
-static bool disasm_line__filter(struct ui_browser *browser, void *entry)
+static bool disasm_line__filter(struct ui_browser *browser __maybe_unused, void *entry)
 {
-	struct annotation *notes = browser__annotation(browser);
 	struct annotation_line *al = list_entry(entry, struct annotation_line, node);
-	return annotation_line__filter(al, notes);
+	return annotation_line__filter(al);
 }
 static int ui_browser__jumps_percent_color(struct ui_browser *browser, int nr, bool current)
 	struct annotation_write_ops ops = {
 		.first_line		 = row == 0,
 		.current_entry		 = is_current_entry,
-		.change_color		 = (!notes->options->hide_src_code &&
+		.change_color		 = (!annotate_opts.hide_src_code &&
 					    (!is_current_entry ||
 					     (browser->use_navkeypressed &&
 					      !browser->navkeypressed))),
 	if (!browser->navkeypressed)
 		ops.width += 1;
-	annotation_line__write(al, notes, &ops, ab->opts);
+	annotation_line__write(al, notes, &ops);
 	if (ops.current_entry)
 		ab->selection = al;
 	while (pos && pos->al.offset == -1) {
 		pos = list_prev_entry(pos, al.node);
-		if (!ab->opts->hide_src_code)
+		if (!annotate_opts.hide_src_code)
 			diff++;
 	}
 	 *  name right after the '<' token and probably treating this like a
 	 *  'call' instruction.
 	 */
-	target = notes->offsets[cursor->ops.target.offset];
+	target = notes->src->offsets[cursor->ops.target.offset];
 	if (target == NULL) {
 		ui_helpline__printf("WARN: jump target inconsistency, press 'o', notes->offsets[%#x] = NULL\n",
 				    cursor->ops.target.offset);
 		return;
 	}
-	if (notes->options->hide_src_code) {
+	if (annotate_opts.hide_src_code) {
 		from = cursor->al.idx_asm;
 		to = target->idx_asm;
 	} else {
 	int ret = ui_browser__list_head_refresh(browser);
 	int pcnt_width = annotation__pcnt_width(notes);
-	if (notes->options->jump_arrows)
+	if (annotate_opts.jump_arrows)
 		annotate_browser__draw_current_jump(browser);
 	ui_browser__set_color(browser, HE_COLORSET_NORMAL);
 		parent = *p;
 		l = rb_entry(parent, struct annotation_line, rb_node);
-		if (disasm__cmp(al, l, browser->opts->percent_type) < 0)
+		if (disasm__cmp(al, l, annotate_opts.percent_type) < 0)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 static void annotate_browser__set_top(struct annotate_browser *browser,
 				      struct annotation_line *pos, u32 idx)
 {
-	struct annotation *notes = browser__annotation(&browser->b);
 	unsigned back;
 	ui_browser__refresh_dimensions(&browser->b);
 	while (browser->b.top_idx != 0 && back != 0) {
 		pos = list_entry(pos->node.prev, struct annotation_line, node);
-		if (annotation_line__filter(pos, notes))
+		if (annotation_line__filter(pos))
 			continue;
 		--browser->b.top_idx;
 static void annotate_browser__set_rb_top(struct annotate_browser *browser,
 					 struct rb_node *nd)
 {
-	struct annotation *notes = browser__annotation(&browser->b);
 	struct annotation_line * pos = rb_entry(nd, struct annotation_line, rb_node);
 	u32 idx = pos->idx;
-	if (notes->options->hide_src_code)
+	if (annotate_opts.hide_src_code)
 		idx = pos->idx_asm;
 	annotate_browser__set_top(browser, pos, idx);
 	browser->curr_hot = nd;
 			double percent;
 			percent = annotation_data__percent(&pos->al.data[i],
-							   browser->opts->percent_type);
+							   annotate_opts.percent_type);
 			if (max_percent < percent)
 				max_percent = percent;
 		}
-		if (max_percent < 0.01 && pos->al.ipc == 0) {
+		if (max_percent < 0.01 && (!pos->al.cycles || pos->al.cycles->ipc == 0)) {
 			RB_CLEAR_NODE(&pos->al.rb_node);
 			continue;
 		}
 	browser->b.seek(&browser->b, offset, SEEK_CUR);
 	al = list_entry(browser->b.top, struct annotation_line, node);
-	if (notes->options->hide_src_code) {
+	if (annotate_opts.hide_src_code) {
 		if (al->idx_asm < offset)
 			offset = al->idx;
-		browser->b.nr_entries = notes->nr_entries;
+		browser->b.nr_entries = notes->src->nr_entries;
-		notes->options->hide_src_code = false;
+		annotate_opts.hide_src_code = false;
 		browser->b.seek(&browser->b, -offset, SEEK_CUR);
 		browser->b.top_idx = al->idx - offset;
 		browser->b.index = al->idx;
 		if (al->idx_asm < offset)
 			offset = al->idx_asm;
-		browser->b.nr_entries = notes->nr_asm_entries;
+		browser->b.nr_entries = notes->src->nr_asm_entries;
-		notes->options->hide_src_code = true;
+		annotate_opts.hide_src_code = true;
 		browser->b.seek(&browser->b, -offset, SEEK_CUR);
 		browser->b.top_idx = al->idx_asm - offset;
 		browser->b.index = al->idx_asm;
 {
 	struct annotation *notes = browser__annotation(browser);
 	ui_browser__reset_index(browser);
-	browser->nr_entries = notes->nr_asm_entries;
+	browser->nr_entries = notes->src->nr_asm_entries;
 }
 static int sym_title(struct symbol *sym, struct map *map, char *title,
 	target_ms.map = ms->map;
 	target_ms.sym = dl->ops.target.sym;
 	annotation__unlock(notes);
-	symbol__tui_annotate(&target_ms, evsel, hbt, browser->opts);
+	symbol__tui_annotate(&target_ms, evsel, hbt);
-	sym_title(ms->sym, ms->map, title, sizeof(title), browser->opts->percent_type);
+	sym_title(ms->sym, ms->map, title, sizeof(title), annotate_opts.percent_type);
 	ui_browser__show_title(&browser->b, title);
 	return true;
 }
 	list_for_each_entry(pos, &notes->src->source, al.node) {
 		if (pos->al.offset == offset)
 			return pos;
-		if (!annotation_line__filter(&pos->al, notes))
+		if (!annotation_line__filter(&pos->al))
 			++*idx;
 	}
 	*idx = browser->b.index;
 	list_for_each_entry_continue(al, &notes->src->source, node) {
-		if (annotation_line__filter(al, notes))
+		if (annotation_line__filter(al))
 			continue;
 		++*idx;
 	*idx = browser->b.index;
 	list_for_each_entry_continue_reverse(al, &notes->src->source, node) {
-		if (annotation_line__filter(al, notes))
+		if (annotation_line__filter(al))
 			continue;
 		--*idx;
 static int annotate_browser__show(struct ui_browser *browser, char *title, const char *help)
 {
-	struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
 	struct map_symbol *ms = browser->priv;
 	struct symbol *sym = ms->sym;
 	char symbol_dso[SYM_TITLE_MAX_SIZE];
 	if (ui_browser__show(browser, title, help) < 0)
 		return -1;
-	sym_title(sym, ms->map, symbol_dso, sizeof(symbol_dso), ab->opts->percent_type);
+	sym_title(sym, ms->map, symbol_dso, sizeof(symbol_dso), annotate_opts.percent_type);
 	ui_browser__gotorc_title(browser, 0, 0);
 	ui_browser__set_color(browser, HE_COLORSET_ROOT);
 			annotate_browser__show(&browser->b, title, help);
 			continue;
 		case 'k':
-			notes->options->show_linenr = !notes->options->show_linenr;
+			annotate_opts.show_linenr = !annotate_opts.show_linenr;
 			continue;
 		case 'l':
 			annotate_browser__show_full_location (&browser->b);
 				ui_helpline__puts(help);
 			continue;
 		case 'o':
-			notes->options->use_offset = !notes->options->use_offset;
+			annotate_opts.use_offset = !annotate_opts.use_offset;
 			annotation__update_column_widths(notes);
 			continue;
 		case 'O':
-			if (++notes->options->offset_level > ANNOTATION__MAX_OFFSET_LEVEL)
+			if (++annotate_opts.offset_level > ANNOTATION__MAX_OFFSET_LEVEL)
-				notes->options->offset_level = ANNOTATION__MIN_OFFSET_LEVEL;
+				annotate_opts.offset_level = ANNOTATION__MIN_OFFSET_LEVEL;
 			continue;
 		case 'j':
-			notes->options->jump_arrows = !notes->options->jump_arrows;
+			annotate_opts.jump_arrows = !annotate_opts.jump_arrows;
 			continue;
 		case 'J':
-			notes->options->show_nr_jumps = !notes->options->show_nr_jumps;
+			annotate_opts.show_nr_jumps = !annotate_opts.show_nr_jumps;
 			annotation__update_column_widths(notes);
 			continue;
 		case '/':
 					   browser->b.height,
 					   browser->b.index,
 					   browser->b.top_idx,
-					   notes->nr_asm_entries);
+					   notes->src->nr_asm_entries);
 		}
 			continue;
 		case K_ENTER:
 			continue;
 		}
 		case 'P':
-			map_symbol__annotation_dump(ms, evsel, browser->opts);
+			map_symbol__annotation_dump(ms, evsel);
 			continue;
 		case 't':
 			if (symbol_conf.show_total_period) {
 			annotation__update_column_widths(notes);
 			continue;
 		case 'c':
-			if (notes->options->show_minmax_cycle)
+			if (annotate_opts.show_minmax_cycle)
-				notes->options->show_minmax_cycle = false;
+				annotate_opts.show_minmax_cycle = false;
 			else
-				notes->options->show_minmax_cycle = true;
+				annotate_opts.show_minmax_cycle = true;
 			annotation__update_column_widths(notes);
 			continue;
 		case 'p':
 		case 'b':
-			switch_percent_type(browser->opts, key == 'b');
+			switch_percent_type(&annotate_opts, key == 'b');
 			hists__scnprintf_title(hists, title, sizeof(title));
 			annotate_browser__show(&browser->b, title, help);
 			continue;
 }
 int map_symbol__tui_annotate(struct map_symbol *ms, struct evsel *evsel,
-			     struct hist_browser_timer *hbt,
+			     struct hist_browser_timer *hbt)
-			     struct annotation_options *opts)
 {
-	return symbol__tui_annotate(ms, evsel, hbt, opts);
+	return symbol__tui_annotate(ms, evsel, hbt);
 }
 int hist_entry__tui_annotate(struct hist_entry *he, struct evsel *evsel,
-			     struct hist_browser_timer *hbt,
+			     struct hist_browser_timer *hbt)
-			     struct annotation_options *opts)
 {
 	/* reset abort key so that it can get Ctrl-C as a key */
 	SLang_reset_tty();
 	SLang_init_tty(0, 0, 0);
+	SLtty_set_suspend_state(true);
-	return map_symbol__tui_annotate(&he->ms, evsel, hbt, opts);
+	return map_symbol__tui_annotate(&he->ms, evsel, hbt);
 }
 int symbol__tui_annotate(struct map_symbol *ms, struct evsel *evsel,
-			 struct hist_browser_timer *hbt,
+			 struct hist_browser_timer *hbt)
-			 struct annotation_options *opts)
 {
 	struct symbol *sym = ms->sym;
 	struct annotation *notes = symbol__annotation(sym);
 			.priv	 = ms,
 			.use_navkeypressed = true,
 		},
-		.opts = opts,
 	};
 	struct dso *dso;
 	int ret = -1, err;
 		return -1;
 	if (not_annotated) {
-		err = symbol__annotate2(ms, evsel, opts, &browser.arch);
+		err = symbol__annotate2(ms, evsel, &browser.arch);
 		if (err) {
 			char msg[BUFSIZ];
 			dso->annotate_warned = true;
 	ui_helpline__push("Press ESC to exit");
-	browser.b.width = notes->max_line_len;
+	browser.b.width = notes->src->max_line_len;
-	browser.b.nr_entries = notes->nr_entries;
+	browser.b.nr_entries = notes->src->nr_entries;
 	browser.b.entries = &notes->src->source,
 	browser.b.width += 18; /* Percentage */
-	if (notes->options->hide_src_code)
+	if (annotate_opts.hide_src_code)
 		ui_browser__init_asm_mode(&browser.b);
 	ret = annotate_browser__run(&browser, evsel, hbt);
 out_free_offsets:
 	if(not_annotated)
-		zfree(&notes->offsets);
+		zfree(&notes->src->offsets);
 	return ret;
 }

tools/perf/ui/browsers/hists.c+14−22

 static struct hist_browser *
 perf_evsel_browser__new(struct evsel *evsel,
 			struct hist_browser_timer *hbt,
-			struct perf_env *env,
+			struct perf_env *env)
-			struct annotation_options *annotation_opts)
 {
 	struct hist_browser *browser = hist_browser__new(evsel__hists(evsel));
 		browser->hbt   = hbt;
 		browser->env   = env;
 		browser->title = hists_browser__scnprintf_title;
-		browser->annotation_opts = annotation_opts;
 	}
 	return browser;
 }
 	struct hist_entry *he;
 	int err;
-	if (!browser->annotation_opts->objdump_path &&
+	if (!annotate_opts.objdump_path &&
-	    perf_env__lookup_objdump(browser->env, &browser->annotation_opts->objdump_path))
+	    perf_env__lookup_objdump(browser->env, &annotate_opts.objdump_path))
 		return 0;
 	notes = symbol__annotation(act->ms.sym);
 	else
 		evsel = hists_to_evsel(browser->hists);
-	err = map_symbol__tui_annotate(&act->ms, evsel, browser->hbt,
+	err = map_symbol__tui_annotate(&act->ms, evsel, browser->hbt);
-				       browser->annotation_opts);
 	he = hist_browser__selected_entry(browser);
 	/*
 	 * offer option to annotate the other branch source or target
 static int evsel__hists_browse(struct evsel *evsel, int nr_events, const char *helpline,
 			       bool left_exits, struct hist_browser_timer *hbt, float min_pcnt,
-			       struct perf_env *env, bool warn_lost_event,
+			       struct perf_env *env, bool warn_lost_event)
-			       struct annotation_options *annotation_opts)
 {
 	struct hists *hists = evsel__hists(evsel);
-	struct hist_browser *browser = perf_evsel_browser__new(evsel, hbt, env, annotation_opts);
+	struct hist_browser *browser = perf_evsel_browser__new(evsel, hbt, env);
 	struct branch_info *bi = NULL;
 #define MAX_OPTIONS  16
 	char *options[MAX_OPTIONS];
 	/* reset abort key so that it can get Ctrl-C as a key */
 	SLang_reset_tty();
 	SLang_init_tty(0, 0, 0);
+	SLtty_set_suspend_state(true);
 	if (min_pcnt)
 		browser->min_pcnt = min_pcnt;
 struct evsel_menu {
 	struct ui_browser b;
 	struct evsel *selection;
-	struct annotation_options *annotation_opts;
 	bool lost_events, lost_events_warned;
 	float min_pcnt;
 	struct perf_env *env;
 				hbt->timer(hbt->arg);
 			key = evsel__hists_browse(pos, nr_events, help, true, hbt,
 						  menu->min_pcnt, menu->env,
-						  warn_lost_event,
+						  warn_lost_event);
-						  menu->annotation_opts);
 			ui_browser__show_title(&menu->b, title);
 			switch (key) {
 			case K_TAB:
 static int __evlist__tui_browse_hists(struct evlist *evlist, int nr_entries, const char *help,
 				      struct hist_browser_timer *hbt, float min_pcnt, struct perf_env *env,
-				      bool warn_lost_event, struct annotation_options *annotation_opts)
+				      bool warn_lost_event)
 {
 	struct evsel *pos;
 	struct evsel_menu menu = {
 		},
 		.min_pcnt = min_pcnt,
 		.env = env,
-		.annotation_opts = annotation_opts,
 	};
 	ui_helpline__push("Press ESC to exit");
 }
 int evlist__tui_browse_hists(struct evlist *evlist, const char *help, struct hist_browser_timer *hbt,
-			     float min_pcnt, struct perf_env *env, bool warn_lost_event,
+			     float min_pcnt, struct perf_env *env, bool warn_lost_event)
-			     struct annotation_options *annotation_opts)
 {
 	int nr_entries = evlist->core.nr_entries;
 		struct evsel *first = evlist__first(evlist);
 		return evsel__hists_browse(first, nr_entries, help, false, hbt, min_pcnt,
-					   env, warn_lost_event, annotation_opts);
+					   env, warn_lost_event);
 	}
 	}
 	}
 	return __evlist__tui_browse_hists(evlist, nr_entries, help, hbt, min_pcnt, env,
-					  warn_lost_event, annotation_opts);
+					  warn_lost_event);
 }
 static int block_hists_browser__title(struct hist_browser *browser, char *bf,
 }
 int block_hists_tui_browse(struct block_hist *bh, struct evsel *evsel,
-			   float min_percent, struct perf_env *env,
+			   float min_percent, struct perf_env *env)
-			   struct annotation_options *annotation_opts)
 {
 	struct hists *hists = &bh->block_hists;
 	struct hist_browser *browser;
 	browser->title = block_hists_browser__title;
 	browser->min_pcnt = min_percent;
 	browser->env = env;
-	browser->annotation_opts = annotation_opts;
 	/* reset abort key so that it can get Ctrl-C as a key */
 	SLang_reset_tty();
 	SLang_init_tty(0, 0, 0);
+	SLtty_set_suspend_state(true);
 	memset(&action, 0, sizeof(action));

tools/perf/ui/browsers/hists.h+0−2

 #include "ui/browser.h"
-struct annotation_options;
 struct evsel;
 struct hist_browser {
 	struct hist_browser_timer *hbt;
 	struct pstack	    *pstack;
 	struct perf_env	    *env;
-	struct annotation_options *annotation_opts;
 	struct evsel	    *block_evsel;
 	int		     print_seq;
 	bool		     show_dso;

tools/perf/ui/browsers/scripts.c+1−0

@@ -166,6 +166,7 @@ void run_script(char *cmd) · 165 unmodified lines
166	printf("\033[c\033[H\033[J");	166	printf("\033[c\033[H\033[J");
167	fflush(stdout);	167	fflush(stdout);
168	SLang_init_tty(0, 0, 0);	168	SLang_init_tty(0, 0, 0);
		169	SLtty_set_suspend_state(true);
169	SLsmg_refresh();	170	SLsmg_refresh();
170	}	171	}
171		172

tools/perf/ui/gtk/annotate.c+2−4

 }
 static int symbol__gtk_annotate(struct map_symbol *ms, struct evsel *evsel,
-				struct annotation_options *options,
 				struct hist_browser_timer *hbt)
 {
 	struct dso *dso = map__dso(ms->map);
 	if (dso->annotate_warned)
 		return -1;
-	err = symbol__annotate(ms, evsel, options, NULL);
+	err = symbol__annotate(ms, evsel, NULL);
 	if (err) {
 		char msg[BUFSIZ];
 		dso->annotate_warned = true;
 int hist_entry__gtk_annotate(struct hist_entry *he,
 			     struct evsel *evsel,
-			     struct annotation_options *options,
 			     struct hist_browser_timer *hbt)
 {
-	return symbol__gtk_annotate(&he->ms, evsel, options, hbt);
+	return symbol__gtk_annotate(&he->ms, evsel, hbt);
 }
 void perf_gtk__show_annotations(void)

tools/perf/ui/gtk/gtk.h+0−2

 struct evlist;
 struct hist_entry;
 struct hist_browser_timer;
-struct annotation_options;
 int evlist__gtk_browse_hists(struct evlist *evlist, const char *help,
 			     struct hist_browser_timer *hbt, float min_pcnt);
 int hist_entry__gtk_annotate(struct hist_entry *he,
 			     struct evsel *evsel,
-			     struct annotation_options *options,
 			     struct hist_browser_timer *hbt);
 void perf_gtk__show_annotations(void);

tools/perf/ui/tui/setup.c+22−0

 #include <signal.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <termios.h>
 #include <unistd.h>
 #include <linux/kernel.h>
 #ifdef HAVE_BACKTRACE_SUPPORT
 #include <execinfo.h>
 #endif
+#include "../../util/color.h"
 #include "../../util/debug.h"
 #include "../browser.h"
 #include "../helpline.h"
 	exit(0);
 }
+static void ui__sigcont(int sig)
+{
+	static struct termios tty;
+	if (sig == SIGTSTP) {
+		while (tcgetattr(SLang_TT_Read_FD, &tty) == -1 && errno == EINTR)
+			;
+		while (write(SLang_TT_Read_FD, PERF_COLOR_RESET, sizeof(PERF_COLOR_RESET) - 1) == -1 && errno == EINTR)
+			;
+		raise(SIGSTOP);
+	} else {
+		while (tcsetattr(SLang_TT_Read_FD, TCSADRAIN, &tty) == -1 && errno == EINTR)
+			;
+		raise(SIGWINCH);
+	}
+}
 int ui__init(void)
 {
 	int err;
 	err = SLang_init_tty(-1, 0, 0);
 	if (err < 0)
 		goto out;
+	SLtty_set_suspend_state(true);
 	err = SLkp_init();
 	if (err < 0) {
 	signal(SIGINT, ui__signal);
 	signal(SIGQUIT, ui__signal);
 	signal(SIGTERM, ui__signal);
+	signal(SIGTSTP, ui__sigcont);
+	signal(SIGCONT, ui__sigcont);
 	perf_error__register(&perf_tui_eops);

tools/perf/util/Build+2−0

@@ -195,6 +195,8 @@ endif · 194 unmodified lines
195	perf-$(CONFIG_DWARF) += probe-finder.o	195	perf-$(CONFIG_DWARF) += probe-finder.o
196	perf-$(CONFIG_DWARF) += dwarf-aux.o	196	perf-$(CONFIG_DWARF) += dwarf-aux.o
197	perf-$(CONFIG_DWARF) += dwarf-regs.o	197	perf-$(CONFIG_DWARF) += dwarf-regs.o
		198	perf-$(CONFIG_DWARF) += debuginfo.o
		199	perf-$(CONFIG_DWARF) += annotate-data.o
198		200
199	perf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o	201	perf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
200	perf-$(CONFIG_LOCAL_LIBUNWIND) += unwind-libunwind-local.o	202	perf-$(CONFIG_LOCAL_LIBUNWIND) += unwind-libunwind-local.o

tools/perf/util/annotate-data.c+405−0

@@ -0,0 +1,405 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Convert sample address to data type using DWARF debug info.
	4	*
	5	* Written by Namhyung Kim <namhyung@kernel.org>
	6	*/
	7
	8	#include <stdio.h>
	9	#include <stdlib.h>
	10	#include <inttypes.h>
	11
	12	#include "annotate-data.h"
	13	#include "debuginfo.h"
	14	#include "debug.h"
	15	#include "dso.h"
	16	#include "evsel.h"
	17	#include "evlist.h"
	18	#include "map.h"
	19	#include "map_symbol.h"
	20	#include "strbuf.h"
	21	#include "symbol.h"
	22	#include "symbol_conf.h"
	23
	24	/*
	25	* Compare type name and size to maintain them in a tree.
	26	* I'm not sure if DWARF would have information of a single type in many
	27	* different places (compilation units). If not, it could compare the
	28	* offset of the type entry in the .debug_info section.
	29	*/
	30	static int data_type_cmp(const void _key, const struct rb_node node)
	31	{
	32	const struct annotated_data_type *key = _key;
	33	struct annotated_data_type *type;
	34
	35	type = rb_entry(node, struct annotated_data_type, node);
	36
	37	if (key->self.size != type->self.size)
	38	return key->self.size - type->self.size;
	39	return strcmp(key->self.type_name, type->self.type_name);
	40	}
	41
	42	static bool data_type_less(struct rb_node node_a, const struct rb_node node_b)
	43	{
	44	struct annotated_data_type a, b;
	45
	46	a = rb_entry(node_a, struct annotated_data_type, node);
	47	b = rb_entry(node_b, struct annotated_data_type, node);
	48
	49	if (a->self.size != b->self.size)
	50	return a->self.size < b->self.size;
	51	return strcmp(a->self.type_name, b->self.type_name) < 0;
	52	}
	53
	54	/* Recursively add new members for struct/union */
	55	static int __add_member_cb(Dwarf_Die die, void arg)
	56	{
	57	struct annotated_member *parent = arg;
	58	struct annotated_member *member;
	59	Dwarf_Die member_type, die_mem;
	60	Dwarf_Word size, loc;
	61	Dwarf_Attribute attr;
	62	struct strbuf sb;
	63	int tag;
	64
	65	if (dwarf_tag(die) != DW_TAG_member)
	66	return DIE_FIND_CB_SIBLING;
	67
	68	member = zalloc(sizeof(*member));
	69	if (member == NULL)
	70	return DIE_FIND_CB_END;
	71
	72	strbuf_init(&sb, 32);
	73	die_get_typename(die, &sb);
	74
	75	die_get_real_type(die, &member_type);
	76	if (dwarf_aggregate_size(&member_type, &size) < 0)
	77	size = 0;
	78
	79	if (!dwarf_attr_integrate(die, DW_AT_data_member_location, &attr))
	80	loc = 0;
	81	else
	82	dwarf_formudata(&attr, &loc);
	83
	84	member->type_name = strbuf_detach(&sb, NULL);
	85	/* member->var_name can be NULL */
	86	if (dwarf_diename(die))
	87	member->var_name = strdup(dwarf_diename(die));
	88	member->size = size;
	89	member->offset = loc + parent->offset;
	90	INIT_LIST_HEAD(&member->children);
	91	list_add_tail(&member->node, &parent->children);
	92
	93	tag = dwarf_tag(&member_type);
	94	switch (tag) {
	95	case DW_TAG_structure_type:
	96	case DW_TAG_union_type:
	97	die_find_child(&member_type, __add_member_cb, member, &die_mem);
	98	break;
	99	default:
	100	break;
	101	}
	102	return DIE_FIND_CB_SIBLING;
	103	}
	104
	105	static void add_member_types(struct annotated_data_type parent, Dwarf_Die type)
	106	{
	107	Dwarf_Die die_mem;
	108
	109	die_find_child(type, __add_member_cb, &parent->self, &die_mem);
	110	}
	111
	112	static void delete_members(struct annotated_member *member)
	113	{
	114	struct annotated_member child, tmp;
	115
	116	list_for_each_entry_safe(child, tmp, &member->children, node) {
	117	list_del(&child->node);
	118	delete_members(child);
	119	free(child->type_name);
	120	free(child->var_name);
	121	free(child);
	122	}
	123	}
	124
	125	static struct annotated_data_type dso__findnew_data_type(struct dso dso,
	126	Dwarf_Die *type_die)
	127	{
	128	struct annotated_data_type *result = NULL;
	129	struct annotated_data_type key;
	130	struct rb_node *node;
	131	struct strbuf sb;
	132	char *type_name;
	133	Dwarf_Word size;
	134
	135	strbuf_init(&sb, 32);
	136	if (die_get_typename_from_type(type_die, &sb) < 0)
	137	strbuf_add(&sb, "(unknown type)", 14);
	138	type_name = strbuf_detach(&sb, NULL);
	139	dwarf_aggregate_size(type_die, &size);
	140
	141	/* Check existing nodes in dso->data_types tree */
	142	key.self.type_name = type_name;
	143	key.self.size = size;
	144	node = rb_find(&key, &dso->data_types, data_type_cmp);
	145	if (node) {
	146	result = rb_entry(node, struct annotated_data_type, node);
	147	free(type_name);
	148	return result;
	149	}
	150
	151	/* If not, add a new one */
	152	result = zalloc(sizeof(*result));
	153	if (result == NULL) {
	154	free(type_name);
	155	return NULL;
	156	}
	157
	158	result->self.type_name = type_name;
	159	result->self.size = size;
	160	INIT_LIST_HEAD(&result->self.children);
	161
	162	if (symbol_conf.annotate_data_member)
	163	add_member_types(result, type_die);
	164
	165	rb_add(&result->node, &dso->data_types, data_type_less);
	166	return result;
	167	}
	168
	169	static bool find_cu_die(struct debuginfo di, u64 pc, Dwarf_Die cu_die)
	170	{
	171	Dwarf_Off off, next_off;
	172	size_t header_size;
	173
	174	if (dwarf_addrdie(di->dbg, pc, cu_die) != NULL)
	175	return cu_die;
	176
	177	/*
	178	* There are some kernels don't have full aranges and contain only a few
	179	* aranges entries. Fallback to iterate all CU entries in .debug_info
	180	* in case it's missing.
	181	*/
	182	off = 0;
	183	while (dwarf_nextcu(di->dbg, off, &next_off, &header_size,
	184	NULL, NULL, NULL) == 0) {
	185	if (dwarf_offdie(di->dbg, off + header_size, cu_die) &&
	186	dwarf_haspc(cu_die, pc))
	187	return true;
	188
	189	off = next_off;
	190	}
	191	return false;
	192	}
	193
	194	/* The type info will be saved in @type_die */
	195	static int check_variable(Dwarf_Die var_die, Dwarf_Die type_die, int offset)
	196	{
	197	Dwarf_Word size;
	198
	199	/* Get the type of the variable */
	200	if (die_get_real_type(var_die, type_die) == NULL) {
	201	pr_debug("variable has no type\n");
	202	ann_data_stat.no_typeinfo++;
	203	return -1;
	204	}
	205
	206	/*
	207	* It expects a pointer type for a memory access.
	208	* Convert to a real type it points to.
	209	*/
	210	if (dwarf_tag(type_die) != DW_TAG_pointer_type \|\|
	211	die_get_real_type(type_die, type_die) == NULL) {
	212	pr_debug("no pointer or no type\n");
	213	ann_data_stat.no_typeinfo++;
	214	return -1;
	215	}
	216
	217	/* Get the size of the actual type */
	218	if (dwarf_aggregate_size(type_die, &size) < 0) {
	219	pr_debug("type size is unknown\n");
	220	ann_data_stat.invalid_size++;
	221	return -1;
	222	}
	223
	224	/* Minimal sanity check */
	225	if ((unsigned)offset >= size) {
	226	pr_debug("offset: %d is bigger than size: %" PRIu64 "\n", offset, size);
	227	ann_data_stat.bad_offset++;
	228	return -1;
	229	}
	230
	231	return 0;
	232	}
	233
	234	/* The result will be saved in @type_die */
	235	static int find_data_type_die(struct debuginfo *di, u64 pc,
	236	int reg, int offset, Dwarf_Die *type_die)
	237	{
	238	Dwarf_Die cu_die, var_die;
	239	Dwarf_Die *scopes = NULL;
	240	int ret = -1;
	241	int i, nr_scopes;
	242
	243	/* Get a compile_unit for this address */
	244	if (!find_cu_die(di, pc, &cu_die)) {
	245	pr_debug("cannot find CU for address %" PRIx64 "\n", pc);
	246	ann_data_stat.no_cuinfo++;
	247	return -1;
	248	}
	249
	250	/* Get a list of nested scopes - i.e. (inlined) functions and blocks. */
	251	nr_scopes = die_get_scopes(&cu_die, pc, &scopes);
	252
	253	/* Search from the inner-most scope to the outer */
	254	for (i = nr_scopes - 1; i >= 0; i--) {
	255	/* Look up variables/parameters in this scope */
	256	if (!die_find_variable_by_reg(&scopes[i], pc, reg, &var_die))
	257	continue;
	258
	259	/* Found a variable, see if it's correct */
	260	ret = check_variable(&var_die, type_die, offset);
	261	goto out;
	262	}
	263	if (ret < 0)
	264	ann_data_stat.no_var++;
	265
	266	out:
	267	free(scopes);
	268	return ret;
	269	}
	270
	271	/**
	272	* find_data_type - Return a data type at the location
	273	* @ms: map and symbol at the location
	274	* @ip: instruction address of the memory access
	275	* @reg: register that holds the base address
	276	* @offset: offset from the base address
	277	*
	278	* This functions searches the debug information of the binary to get the data
	279	* type it accesses. The exact location is expressed by (ip, reg, offset).
	280	* It return %NULL if not found.
	281	*/
	282	struct annotated_data_type find_data_type(struct map_symbol ms, u64 ip,
	283	int reg, int offset)
	284	{
	285	struct annotated_data_type *result = NULL;
	286	struct dso *dso = map__dso(ms->map);
	287	struct debuginfo *di;
	288	Dwarf_Die type_die;
	289	u64 pc;
	290
	291	di = debuginfo__new(dso->long_name);
	292	if (di == NULL) {
	293	pr_debug("cannot get the debug info\n");
	294	return NULL;
	295	}
	296
	297	/*
	298	* IP is a relative instruction address from the start of the map, as
	299	* it can be randomized/relocated, it needs to translate to PC which is
	300	* a file address for DWARF processing.
	301	*/
	302	pc = map__rip_2objdump(ms->map, ip);
	303	if (find_data_type_die(di, pc, reg, offset, &type_die) < 0)
	304	goto out;
	305
	306	result = dso__findnew_data_type(dso, &type_die);
	307
	308	out:
	309	debuginfo__delete(di);
	310	return result;
	311	}
	312
	313	static int alloc_data_type_histograms(struct annotated_data_type *adt, int nr_entries)
	314	{
	315	int i;
	316	size_t sz = sizeof(struct type_hist);
	317
	318	sz += sizeof(struct type_hist_entry) * adt->self.size;
	319
	320	/* Allocate a table of pointers for each event */
	321	adt->nr_histograms = nr_entries;
	322	adt->histograms = calloc(nr_entries, sizeof(*adt->histograms));
	323	if (adt->histograms == NULL)
	324	return -ENOMEM;
	325
	326	/*
	327	* Each histogram is allocated for the whole size of the type.
	328	* TODO: Probably we can move the histogram to members.
	329	*/
	330	for (i = 0; i < nr_entries; i++) {
	331	adt->histograms[i] = zalloc(sz);
	332	if (adt->histograms[i] == NULL)
	333	goto err;
	334	}
	335	return 0;
	336
	337	err:
	338	while (--i >= 0)
	339	free(adt->histograms[i]);
	340	free(adt->histograms);
	341	return -ENOMEM;
	342	}
	343
	344	static void delete_data_type_histograms(struct annotated_data_type *adt)
	345	{
	346	for (int i = 0; i < adt->nr_histograms; i++)
	347	free(adt->histograms[i]);
	348	free(adt->histograms);
	349	}
	350
	351	void annotated_data_type__tree_delete(struct rb_root *root)
	352	{
	353	struct annotated_data_type *pos;
	354
	355	while (!RB_EMPTY_ROOT(root)) {
	356	struct rb_node *node = rb_first(root);
	357
	358	rb_erase(node, root);
	359	pos = rb_entry(node, struct annotated_data_type, node);
	360	delete_members(&pos->self);
	361	delete_data_type_histograms(pos);
	362	free(pos->self.type_name);
	363	free(pos);
	364	}
	365	}
	366
	367	/**
	368	* annotated_data_type__update_samples - Update histogram
	369	* @adt: Data type to update
	370	* @evsel: Event to update
	371	* @offset: Offset in the type
	372	* @nr_samples: Number of samples at this offset
	373	* @period: Event count at this offset
	374	*
	375	* This function updates type histogram at @ofs for @evsel. Samples are
	376	* aggregated before calling this function so it can be called with more
	377	* than one samples at a certain offset.
	378	*/
	379	int annotated_data_type__update_samples(struct annotated_data_type *adt,
	380	struct evsel *evsel, int offset,
	381	int nr_samples, u64 period)
	382	{
	383	struct type_hist *h;
	384
	385	if (adt == NULL)
	386	return 0;
	387
	388	if (adt->histograms == NULL) {
	389	int nr = evsel->evlist->core.nr_entries;
	390
	391	if (alloc_data_type_histograms(adt, nr) < 0)
	392	return -1;
	393	}
	394
	395	if (offset < 0 \|\| offset >= adt->self.size)
	396	return -1;
	397
	398	h = adt->histograms[evsel->core.idx];
	399
	400	h->nr_samples += nr_samples;
	401	h->addr[offset].nr_samples += nr_samples;
	402	h->period += period;
	403	h->addr[offset].period += period;
	404	return 0;
	405	}

tools/perf/util/annotate-data.h+143−0

@@ -0,0 +1,143 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _PERF_ANNOTATE_DATA_H
	3	#define _PERF_ANNOTATE_DATA_H
	4
	5	#include <errno.h>
	6	#include <linux/compiler.h>
	7	#include <linux/rbtree.h>
	8	#include <linux/types.h>
	9
	10	struct evsel;
	11	struct map_symbol;
	12
	13	/**
	14	* struct annotated_member - Type of member field
	15	* @node: List entry in the parent list
	16	* @children: List head for child nodes
	17	* @type_name: Name of the member type
	18	* @var_name: Name of the member variable
	19	* @offset: Offset from the outer data type
	20	* @size: Size of the member field
	21	*
	22	* This represents a member type in a data type.
	23	*/
	24	struct annotated_member {
	25	struct list_head node;
	26	struct list_head children;
	27	char *type_name;
	28	char *var_name;
	29	int offset;
	30	int size;
	31	};
	32
	33	/**
	34	* struct type_hist_entry - Histogram entry per offset
	35	* @nr_samples: Number of samples
	36	* @period: Count of event
	37	*/
	38	struct type_hist_entry {
	39	int nr_samples;
	40	u64 period;
	41	};
	42
	43	/**
	44	* struct type_hist - Type histogram for each event
	45	* @nr_samples: Total number of samples in this data type
	46	* @period: Total count of the event in this data type
	47	* @offset: Array of histogram entry
	48	*/
	49	struct type_hist {
	50	u64 nr_samples;
	51	u64 period;
	52	struct type_hist_entry addr[];
	53	};
	54
	55	/**
	56	* struct annotated_data_type - Data type to profile
	57	* @node: RB-tree node for dso->type_tree
	58	* @self: Actual type information
	59	* @nr_histogram: Number of histogram entries
	60	* @histograms: An array of pointers to histograms
	61	*
	62	* This represents a data type accessed by samples in the profile data.
	63	*/
	64	struct annotated_data_type {
	65	struct rb_node node;
	66	struct annotated_member self;
	67	int nr_histograms;
	68	struct type_hist **histograms;
	69	};
	70
	71	extern struct annotated_data_type unknown_type;
	72
	73	/**
	74	* struct annotated_data_stat - Debug statistics
	75	* @total: Total number of entry
	76	* @no_sym: No symbol or map found
	77	* @no_insn: Failed to get disasm line
	78	* @no_insn_ops: The instruction has no operands
	79	* @no_mem_ops: The instruction has no memory operands
	80	* @no_reg: Failed to extract a register from the operand
	81	* @no_dbginfo: The binary has no debug information
	82	* @no_cuinfo: Failed to find a compile_unit
	83	* @no_var: Failed to find a matching variable
	84	* @no_typeinfo: Failed to get a type info for the variable
	85	* @invalid_size: Failed to get a size info of the type
	86	* @bad_offset: The access offset is out of the type
	87	*/
	88	struct annotated_data_stat {
	89	int total;
	90	int no_sym;
	91	int no_insn;
	92	int no_insn_ops;
	93	int no_mem_ops;
	94	int no_reg;
	95	int no_dbginfo;
	96	int no_cuinfo;
	97	int no_var;
	98	int no_typeinfo;
	99	int invalid_size;
	100	int bad_offset;
	101	};
	102	extern struct annotated_data_stat ann_data_stat;
	103
	104	#ifdef HAVE_DWARF_SUPPORT
	105
	106	/* Returns data type at the location (ip, reg, offset) */
	107	struct annotated_data_type find_data_type(struct map_symbol ms, u64 ip,
	108	int reg, int offset);
	109
	110	/* Update type access histogram at the given offset */
	111	int annotated_data_type__update_samples(struct annotated_data_type *adt,
	112	struct evsel *evsel, int offset,
	113	int nr_samples, u64 period);
	114
	115	/* Release all data type information in the tree */
	116	void annotated_data_type__tree_delete(struct rb_root *root);
	117
	118	#else /* HAVE_DWARF_SUPPORT */
	119
	120	static inline struct annotated_data_type *
	121	find_data_type(struct map_symbol *ms __maybe_unused, u64 ip __maybe_unused,
	122	int reg __maybe_unused, int offset __maybe_unused)
	123	{
	124	return NULL;
	125	}
	126
	127	static inline int
	128	annotated_data_type__update_samples(struct annotated_data_type *adt __maybe_unused,
	129	struct evsel *evsel __maybe_unused,
	130	int offset __maybe_unused,
	131	int nr_samples __maybe_unused,
	132	u64 period __maybe_unused)
	133	{
	134	return -1;
	135	}
	136
	137	static inline void annotated_data_type__tree_delete(struct rb_root *root __maybe_unused)
	138	{
	139	}
	140
	141	#endif /* HAVE_DWARF_SUPPORT */
	142
	143	#endif /* _PERF_ANNOTATE_DATA_H */

tools/perf/util/annotate.c+522−165

@@ -25,12 +25,14 @@ · 24 unmodified lines
25	#include "units.h"	25	#include "units.h"
26	#include "debug.h"	26	#include "debug.h"
27	#include "annotate.h"	27	#include "annotate.h"
		28	#include "annotate-data.h"
28	#include "evsel.h"	29	#include "evsel.h"
29	#include "evlist.h"	30	#include "evlist.h"
30	#include "bpf-event.h"	31	#include "bpf-event.h"
31	#include "bpf-utils.h"	32	#include "bpf-utils.h"
32	#include "block-range.h"	33	#include "block-range.h"
33	#include "string2.h"	34	#include "string2.h"
		35	#include "dwarf-regs.h"
34	#include "util/event.h"	36	#include "util/event.h"
35	#include "util/sharded_mutex.h"	37	#include "util/sharded_mutex.h"
36	#include "arch/common.h"	38	#include "arch/common.h"
@@ -57,6 +59,9 @@ · 20 unmodified lines
57		59
58	#include <linux/ctype.h>	60	#include <linux/ctype.h>
59		61
		62	/* global annotation options */
		63	struct annotation_options annotate_opts;
		64
60	static regex_t file_lineno;	65	static regex_t file_lineno;
61		66
62	static struct ins_ops ins__find(struct arch arch, const char *name);	67	static struct ins_ops ins__find(struct arch arch, const char *name);
@@ -85,6 +90,8 @@ struct arch { · 22 unmodified lines
85	struct {	90	struct {
86	char comment_char;	91	char comment_char;
87	char skip_functions_char;	92	char skip_functions_char;
		93	char register_char;
		94	char memory_ref_char;
88	} objdump;	95	} objdump;
89	};	96	};
90		97
@@ -96,6 +103,10 @@ static struct ins_ops nop_ops; · 5 unmodified lines
96	static struct ins_ops lock_ops;	103	static struct ins_ops lock_ops;
97	static struct ins_ops ret_ops;	104	static struct ins_ops ret_ops;
98		105
		106	/* Data type collection debug statistics */
		107	struct annotated_data_stat ann_data_stat;
		108	LIST_HEAD(ann_insn_stat);
		109
99	static int arch__grow_instructions(struct arch *arch)	110	static int arch__grow_instructions(struct arch *arch)
100	{	111	{
101	struct ins *new_instructions;	112	struct ins *new_instructions;
@@ -188,6 +199,8 @@ static struct arch architectures[] = { · 86 unmodified lines
188	.insn_suffix = "bwlq",	199	.insn_suffix = "bwlq",
189	.objdump = {	200	.objdump = {
190	.comment_char = '#',	201	.comment_char = '#',
		202	.register_char = '%',
		203	.memory_ref_char = '(',
191	},	204	},
192	},	205	},
193	{	206	{
@@ -340,10 +353,10 @@ bool ins__is_call(const struct ins *ins) · 146 unmodified lines
340	*/	353	*/
341	static inline const char validate_comma(const char c, struct ins_operands *ops)	354	static inline const char validate_comma(const char c, struct ins_operands *ops)
342	{	355	{
343	if (ops->raw_comment && c > ops->raw_comment)	356	if (ops->jump.raw_comment && c > ops->jump.raw_comment)
344	return NULL;	357	return NULL;
345		358
346	if (ops->raw_func_start && c > ops->raw_func_start)	359	if (ops->jump.raw_func_start && c > ops->jump.raw_func_start)
347	return NULL;	360	return NULL;
348		361
349	return c;	362	return c;
@@ -359,8 +372,8 @@ static int jump__parse(struct arch arch, struct ins_operands ops, struct map_s · 9 unmodified lines
359	const char *c = strchr(ops->raw, ',');	372	const char *c = strchr(ops->raw, ',');
360	u64 start, end;	373	u64 start, end;
361		374
362	ops->raw_comment = strchr(ops->raw, arch->objdump.comment_char);	375	ops->jump.raw_comment = strchr(ops->raw, arch->objdump.comment_char);
363	ops->raw_func_start = strchr(ops->raw, '<');	376	ops->jump.raw_func_start = strchr(ops->raw, '<');
364		377
365	c = validate_comma(c, ops);	378	c = validate_comma(c, ops);
366		379
@@ -462,7 +475,16 @@ static int jump__scnprintf(struct ins ins, char bf, size_t size, · 95 unmodified lines
462	ops->target.offset);	475	ops->target.offset);
463	}	476	}
464		477
		478	static void jump__delete(struct ins_operands *ops __maybe_unused)
		479	{
		480	/*
		481	* The ops->jump.raw_comment and ops->jump.raw_func_start belong to the
		482	* raw string, don't free them.
		483	*/
		484	}
		485
465	static struct ins_ops jump_ops = {	486	static struct ins_ops jump_ops = {
		487	.free = jump__delete,
466	.parse = jump__parse,	488	.parse = jump__parse,
467	.scnprintf = jump__scnprintf,	489	.scnprintf = jump__scnprintf,
468	};	490	};
@@ -557,6 +579,34 @@ static struct ins_ops lock_ops = { · 88 unmodified lines
557	.scnprintf = lock__scnprintf,	579	.scnprintf = lock__scnprintf,
558	};	580	};
559		581
		582	/*
		583	* Check if the operand has more than one registers like x86 SIB addressing:
		584	* 0x1234(%rax, %rbx, 8)
		585	*
		586	* But it doesn't care segment selectors like %gs:0x5678(%rcx), so just check
		587	* the input string after 'memory_ref_char' if exists.
		588	*/
		589	static bool check_multi_regs(struct arch arch, const char op)
		590	{
		591	int count = 0;
		592
		593	if (arch->objdump.register_char == 0)
		594	return false;
		595
		596	if (arch->objdump.memory_ref_char) {
		597	op = strchr(op, arch->objdump.memory_ref_char);
		598	if (op == NULL)
		599	return false;
		600	}
		601
		602	while ((op = strchr(op, arch->objdump.register_char)) != NULL) {
		603	count++;
		604	op++;
		605	}
		606
		607	return count > 1;
		608	}
		609
560	static int mov__parse(struct arch arch, struct ins_operands ops, struct map_symbol *ms __maybe_unused)	610	static int mov__parse(struct arch arch, struct ins_operands ops, struct map_symbol *ms __maybe_unused)
561	{	611	{
562	char s = strchr(ops->raw, ','), target, *comment, prev;	612	char s = strchr(ops->raw, ','), target, *comment, prev;
@@ -584,6 +634,8 @@ static int mov__parse(struct arch arch, struct ins_operands ops, struct map_sy · 21 unmodified lines
584	if (ops->source.raw == NULL)	634	if (ops->source.raw == NULL)
585	return -1;	635	return -1;
586		636
		637	ops->source.multi_regs = check_multi_regs(arch, ops->source.raw);
		638
587	target = skip_spaces(++s);	639	target = skip_spaces(++s);
588	comment = strchr(s, arch->objdump.comment_char);	640	comment = strchr(s, arch->objdump.comment_char);
589		641
@@ -604,6 +656,8 @@ static int mov__parse(struct arch arch, struct ins_operands ops, struct map_sy · 14 unmodified lines
604	if (ops->target.raw == NULL)	656	if (ops->target.raw == NULL)
605	goto out_free_source;	657	goto out_free_source;
606		658
		659	ops->target.multi_regs = check_multi_regs(arch, ops->target.raw);
		660
607	if (comment == NULL)	661	if (comment == NULL)
608	return 0;	662	return 0;
609		663
@@ -795,6 +849,11 @@ static struct arch arch__find(const char name) · 185 unmodified lines
795	return bsearch(name, architectures, nmemb, sizeof(struct arch), arch__key_cmp);	849	return bsearch(name, architectures, nmemb, sizeof(struct arch), arch__key_cmp);
796	}	850	}
797		851
		852	bool arch__is(struct arch arch, const char name)
		853	{
		854	return !strcmp(arch->name, name);
		855	}
		856
798	static struct annotated_source *annotated_source__new(void)	857	static struct annotated_source *annotated_source__new(void)
799	{	858	{
800	struct annotated_source src = zalloc(sizeof(src));	859	struct annotated_source src = zalloc(sizeof(src));
@@ -810,7 +869,6 @@ static __maybe_unused void annotated_source__delete(struct annotated_source *src · 9 unmodified lines
810	if (src == NULL)	869	if (src == NULL)
811	return;	870	return;
812	zfree(&src->histograms);	871	zfree(&src->histograms);
813	zfree(&src->cycles_hist);
814	free(src);	872	free(src);
815	}	873	}
816		874
@@ -845,18 +903,6 @@ static int annotated_source__alloc_histograms(struct annotated_source *src, · 28 unmodified lines
845	return src->histograms ? 0 : -1;	903	return src->histograms ? 0 : -1;
846	}	904	}
847		905
848	/* The cycles histogram is lazily allocated. */
849	static int symbol__alloc_hist_cycles(struct symbol *sym)
850	{
851	struct annotation *notes = symbol__annotation(sym);
852	const size_t size = symbol__size(sym);
853
854	notes->src->cycles_hist = calloc(size, sizeof(struct cyc_hist));
855	if (notes->src->cycles_hist == NULL)
856	return -1;
857	return 0;
858	}
859
860	void symbol__annotate_zero_histograms(struct symbol *sym)	906	void symbol__annotate_zero_histograms(struct symbol *sym)
861	{	907	{
862	struct annotation *notes = symbol__annotation(sym);	908	struct annotation *notes = symbol__annotation(sym);
@@ -865,9 +911,10 @@ void symbol__annotate_zero_histograms(struct symbol *sym) · 2 unmodified lines
865	if (notes->src != NULL) {	911	if (notes->src != NULL) {
866	memset(notes->src->histograms, 0,	912	memset(notes->src->histograms, 0,
867	notes->src->nr_histograms * notes->src->sizeof_sym_hist);	913	notes->src->nr_histograms * notes->src->sizeof_sym_hist);
868	if (notes->src->cycles_hist)	914	}
869	memset(notes->src->cycles_hist, 0,	915	if (notes->branch && notes->branch->cycles_hist) {
870	symbol__size(sym) * sizeof(struct cyc_hist));	916	memset(notes->branch->cycles_hist, 0,
		917	symbol__size(sym) * sizeof(struct cyc_hist));
871	}	918	}
872	annotation__unlock(notes);	919	annotation__unlock(notes);
873	}	920	}
@@ -958,23 +1005,33 @@ static int __symbol__inc_addr_samples(struct map_symbol *ms, · 84 unmodified lines
958	return 0;	1005	return 0;
959	}	1006	}
960		1007
		1008	struct annotated_branch annotation__get_branch(struct annotation notes)
		1009	{
		1010	if (notes == NULL)
		1011	return NULL;
		1012
		1013	if (notes->branch == NULL)
		1014	notes->branch = zalloc(sizeof(*notes->branch));
		1015
		1016	return notes->branch;
		1017	}
		1018
961	static struct cyc_hist symbol__cycles_hist(struct symbol sym)	1019	static struct cyc_hist symbol__cycles_hist(struct symbol sym)
962	{	1020	{
963	struct annotation *notes = symbol__annotation(sym);	1021	struct annotation *notes = symbol__annotation(sym);
		1022	struct annotated_branch *branch;
964		1023
965	if (notes->src == NULL) {	1024	branch = annotation__get_branch(notes);
966	notes->src = annotated_source__new();	1025	if (branch == NULL)
967	if (notes->src == NULL)	1026	return NULL;
968	return NULL;	1027
969	goto alloc_cycles_hist;	1028	if (branch->cycles_hist == NULL) {
970	}	1029	const size_t size = symbol__size(sym);
971		1030
972	if (!notes->src->cycles_hist) {	1031	branch->cycles_hist = calloc(size, sizeof(struct cyc_hist));
973	alloc_cycles_hist:
974	symbol__alloc_hist_cycles(sym);
975	}	1032	}
976		1033
977	return notes->src->cycles_hist;	1034	return branch->cycles_hist;
978	}	1035	}
979		1036
980	struct annotated_source symbol__hists(struct symbol sym, int nr_hists)	1037	struct annotated_source symbol__hists(struct symbol sym, int nr_hists)
@@ -1077,12 +1134,20 @@ static unsigned annotation__count_insn(struct annotation *notes, u64 start, u64 · 96 unmodified lines
1077	u64 offset;	1134	u64 offset;
1078		1135
1079	for (offset = start; offset <= end; offset++) {	1136	for (offset = start; offset <= end; offset++) {
1080	if (notes->offsets[offset])	1137	if (notes->src->offsets[offset])
1081	n_insn++;	1138	n_insn++;
1082	}	1139	}
1083	return n_insn;	1140	return n_insn;
1084	}	1141	}
1085		1142
		1143	static void annotated_branch__delete(struct annotated_branch *branch)
		1144	{
		1145	if (branch) {
		1146	zfree(&branch->cycles_hist);
		1147	free(branch);
		1148	}
		1149	}
		1150
1086	static void annotation__count_and_fill(struct annotation notes, u64 start, u64 end, struct cyc_hist ch)	1151	static void annotation__count_and_fill(struct annotation notes, u64 start, u64 end, struct cyc_hist ch)
1087	{	1152	{
1088	unsigned n_insn;	1153	unsigned n_insn;
@@ -1091,6 +1156,7 @@ static void annotation__count_and_fill(struct annotation *notes, u64 start, u64 · 2 unmodified lines
1091		1156
1092	n_insn = annotation__count_insn(notes, start, end);	1157	n_insn = annotation__count_insn(notes, start, end);
1093	if (n_insn && ch->num && ch->cycles) {	1158	if (n_insn && ch->num && ch->cycles) {
		1159	struct annotated_branch *branch;
1094	float ipc = n_insn / ((double)ch->cycles / (double)ch->num);	1160	float ipc = n_insn / ((double)ch->cycles / (double)ch->num);
1095		1161
1096	/* Hide data when there are too many overlaps. */	1162	/* Hide data when there are too many overlaps. */
@@ -1098,54 +1164,76 @@ static void annotation__count_and_fill(struct annotation *notes, u64 start, u64 · 1 unmodified line
1098	return;	1164	return;
1099		1165
1100	for (offset = start; offset <= end; offset++) {	1166	for (offset = start; offset <= end; offset++) {
1101	struct annotation_line *al = notes->offsets[offset];	1167	struct annotation_line *al = notes->src->offsets[offset];
1102		1168
1103	if (al && al->ipc == 0.0) {	1169	if (al && al->cycles && al->cycles->ipc == 0.0) {
1104	al->ipc = ipc;	1170	al->cycles->ipc = ipc;
1105	cover_insn++;	1171	cover_insn++;
1106	}	1172	}
1107	}	1173	}
1108		1174
1109	if (cover_insn) {	1175	branch = annotation__get_branch(notes);
1110	notes->hit_cycles += ch->cycles;	1176	if (cover_insn && branch) {
1111	notes->hit_insn += n_insn * ch->num;	1177	branch->hit_cycles += ch->cycles;
1112	notes->cover_insn += cover_insn;	1178	branch->hit_insn += n_insn * ch->num;
		1179	branch->cover_insn += cover_insn;
1113	}	1180	}
1114	}	1181	}
1115	}	1182	}
1116		1183
1117	void annotation__compute_ipc(struct annotation *notes, size_t size)	1184	static int annotation__compute_ipc(struct annotation *notes, size_t size)
1118	{	1185	{
		1186	int err = 0;
1119	s64 offset;	1187	s64 offset;
1120		1188
1121	if (!notes->src \|\| !notes->src->cycles_hist)	1189	if (!notes->branch \|\| !notes->branch->cycles_hist)
1122	return;	1190	return 0;
1123		1191
1124	notes->total_insn = annotation__count_insn(notes, 0, size - 1);	1192	notes->branch->total_insn = annotation__count_insn(notes, 0, size - 1);
1125	notes->hit_cycles = 0;	1193	notes->branch->hit_cycles = 0;
1126	notes->hit_insn = 0;	1194	notes->branch->hit_insn = 0;
1127	notes->cover_insn = 0;	1195	notes->branch->cover_insn = 0;
1128		1196
1129	annotation__lock(notes);	1197	annotation__lock(notes);
1130	for (offset = size - 1; offset >= 0; --offset) {	1198	for (offset = size - 1; offset >= 0; --offset) {
1131	struct cyc_hist *ch;	1199	struct cyc_hist *ch;
1132		1200
1133	ch = &notes->src->cycles_hist[offset];	1201	ch = &notes->branch->cycles_hist[offset];
1134	if (ch && ch->cycles) {	1202	if (ch && ch->cycles) {
1135	struct annotation_line *al;	1203	struct annotation_line *al;
1136		1204
		1205	al = notes->src->offsets[offset];
		1206	if (al && al->cycles == NULL) {
		1207	al->cycles = zalloc(sizeof(*al->cycles));
		1208	if (al->cycles == NULL) {
		1209	err = ENOMEM;
		1210	break;
		1211	}
		1212	}
1137	if (ch->have_start)	1213	if (ch->have_start)
1138	annotation__count_and_fill(notes, ch->start, offset, ch);	1214	annotation__count_and_fill(notes, ch->start, offset, ch);
1139	al = notes->offsets[offset];
1140	if (al && ch->num_aggr) {	1215	if (al && ch->num_aggr) {
1141	al->cycles = ch->cycles_aggr / ch->num_aggr;	1216	al->cycles->avg = ch->cycles_aggr / ch->num_aggr;
1142	al->cycles_max = ch->cycles_max;	1217	al->cycles->max = ch->cycles_max;
1143	al->cycles_min = ch->cycles_min;	1218	al->cycles->min = ch->cycles_min;
		1219	}
		1220	}
		1221	}
		1222
		1223	if (err) {
		1224	while (++offset < (s64)size) {
		1225	struct cyc_hist *ch = &notes->branch->cycles_hist[offset];
		1226
		1227	if (ch && ch->cycles) {
		1228	struct annotation_line *al = notes->src->offsets[offset];
		1229	if (al)
		1230	zfree(&al->cycles);
1144	}	1231	}
1145	notes->have_cycles = true;
1146	}	1232	}
1147	}	1233	}
		1234
1148	annotation__unlock(notes);	1235	annotation__unlock(notes);
		1236	return 0;
1149	}	1237	}
1150		1238
1151	int addr_map_symbol__inc_samples(struct addr_map_symbol ams, struct perf_sample sample,	1239	int addr_map_symbol__inc_samples(struct addr_map_symbol ams, struct perf_sample sample,
@@ -1225,6 +1313,7 @@ static void annotation_line__exit(struct annotation_line *al) · 73 unmodified lines
1225	{	1313	{
1226	zfree_srcline(&al->path);	1314	zfree_srcline(&al->path);
1227	zfree(&al->line);	1315	zfree(&al->line);
		1316	zfree(&al->cycles);
1228	}	1317	}
1229		1318
1230	static size_t disasm_line_size(int nr)	1319	static size_t disasm_line_size(int nr)
@@ -1299,6 +1388,7 @@ int disasm_line__scnprintf(struct disasm_line dl, char bf, size_t size, bool r · 68 unmodified lines
1299	void annotation__exit(struct annotation *notes)	1388	void annotation__exit(struct annotation *notes)
1300	{	1389	{
1301	annotated_source__delete(notes->src);	1390	annotated_source__delete(notes->src);
		1391	annotated_branch__delete(notes->branch);
1302	}	1392	}
1303		1393
1304	static struct sharded_mutex *sharded_mutex;	1394	static struct sharded_mutex *sharded_mutex;
@@ -1817,7 +1907,6 @@ static int symbol__disassemble_bpf(struct symbol *sym, · 512 unmodified lines
1817	struct annotate_args *args)	1907	struct annotate_args *args)
1818	{	1908	{
1819	struct annotation *notes = symbol__annotation(sym);	1909	struct annotation *notes = symbol__annotation(sym);
1820	struct annotation_options *opts = args->options;
1821	struct bpf_prog_linfo *prog_linfo = NULL;	1910	struct bpf_prog_linfo *prog_linfo = NULL;
1822	struct bpf_prog_info_node *info_node;	1911	struct bpf_prog_info_node *info_node;
1823	int len = sym->end - sym->start;	1912	int len = sym->end - sym->start;
@@ -1927,7 +2016,7 @@ static int symbol__disassemble_bpf(struct symbol *sym, · 103 unmodified lines
1927	prev_buf_size = buf_size;	2016	prev_buf_size = buf_size;
1928	fflush(s);	2017	fflush(s);
1929		2018
1930	if (!opts->hide_src_code && srcline) {	2019	if (!annotate_opts.hide_src_code && srcline) {
1931	args->offset = -1;	2020	args->offset = -1;
1932	args->line = strdup(srcline);	2021	args->line = strdup(srcline);
1933	args->line_nr = 0;	2022	args->line_nr = 0;
@@ -2050,7 +2139,7 @@ static char expand_tabs(char line, char *storage, size_t storage_len) · 116 unmodified lines
2050		2139
2051	static int symbol__disassemble(struct symbol sym, struct annotate_args args)	2140	static int symbol__disassemble(struct symbol sym, struct annotate_args args)
2052	{	2141	{
2053	struct annotation_options *opts = args->options;	2142	struct annotation_options *opts = &annotate_opts;
2054	struct map *map = args->ms.map;	2143	struct map *map = args->ms.map;
2055	struct dso *dso = map__dso(map);	2144	struct dso *dso = map__dso(map);
2056	char *command;	2145	char *command;
@@ -2113,12 +2202,13 @@ static int symbol__disassemble(struct symbol sym, struct annotate_args args) · 56 unmodified lines
2113	err = asprintf(&command,	2202	err = asprintf(&command,
2114	"%s %s%s --start-address=0x%016" PRIx64	2203	"%s %s%s --start-address=0x%016" PRIx64
2115	" --stop-address=0x%016" PRIx64	2204	" --stop-address=0x%016" PRIx64
2116	" -l -d %s %s %s %c%s%c %s%s -C \"$1\"",	2205	" %s -d %s %s %s %c%s%c %s%s -C \"$1\"",
2117	opts->objdump_path ?: "objdump",	2206	opts->objdump_path ?: "objdump",
2118	opts->disassembler_style ? "-M " : "",	2207	opts->disassembler_style ? "-M " : "",
2119	opts->disassembler_style ?: "",	2208	opts->disassembler_style ?: "",
2120	map__rip_2objdump(map, sym->start),	2209	map__rip_2objdump(map, sym->start),
2121	map__rip_2objdump(map, sym->end),	2210	map__rip_2objdump(map, sym->end),
		2211	opts->show_linenr ? "-l" : "",
2122	opts->show_asm_raw ? "" : "--no-show-raw-insn",	2212	opts->show_asm_raw ? "" : "--no-show-raw-insn",
2123	opts->annotate_src ? "-S" : "",	2213	opts->annotate_src ? "-S" : "",
2124	opts->prefix ? "--prefix " : "",	2214	opts->prefix ? "--prefix " : "",
@@ -2299,15 +2389,8 @@ void symbol__calc_percent(struct symbol sym, struct evsel evsel) · 174 unmodified lines
2299	annotation__calc_percent(notes, evsel, symbol__size(sym));	2389	annotation__calc_percent(notes, evsel, symbol__size(sym));
2300	}	2390	}
2301		2391
2302	int symbol__annotate(struct map_symbol ms, struct evsel evsel,	2392	static int evsel__get_arch(struct evsel evsel, struct arch *parch)
2303	struct annotation_options options, struct arch *parch)
2304	{	2393	{
2305	struct symbol *sym = ms->sym;
2306	struct annotation *notes = symbol__annotation(sym);
2307	struct annotate_args args = {
2308	.evsel = evsel,
2309	.options = options,
2310	};
2311	struct perf_env *env = evsel__env(evsel);	2394	struct perf_env *env = evsel__env(evsel);
2312	const char *arch_name = perf_env__arch(env);	2395	const char *arch_name = perf_env__arch(env);
2313	struct arch *arch;	2396	struct arch *arch;
@@ -2316,25 +2399,45 @@ int symbol__annotate(struct map_symbol ms, struct evsel evsel, · 2 unmodified lines
2316	if (!arch_name)	2399	if (!arch_name)
2317	return errno;	2400	return errno;
2318		2401
2319	args.arch = arch = arch__find(arch_name);	2402	*parch = arch = arch__find(arch_name);
2320	if (arch == NULL) {	2403	if (arch == NULL) {
2321	pr_err("%s: unsupported arch %s\n", __func__, arch_name);	2404	pr_err("%s: unsupported arch %s\n", __func__, arch_name);
2322	return ENOTSUP;	2405	return ENOTSUP;
2323	}	2406	}
2324		2407
2325	if (parch)
2326	*parch = arch;
2327
2328	if (arch->init) {	2408	if (arch->init) {
2329	err = arch->init(arch, env ? env->cpuid : NULL);	2409	err = arch->init(arch, env ? env->cpuid : NULL);
2330	if (err) {	2410	if (err) {
2331	pr_err("%s: failed to initialize %s arch priv area\n", __func__, arch->name);	2411	pr_err("%s: failed to initialize %s arch priv area\n",
		2412	__func__, arch->name);
2332	return err;	2413	return err;
2333	}	2414	}
2334	}	2415	}
		2416	return 0;
		2417	}
2335		2418
		2419	int symbol__annotate(struct map_symbol ms, struct evsel evsel,
		2420	struct arch **parch)
		2421	{
		2422	struct symbol *sym = ms->sym;
		2423	struct annotation *notes = symbol__annotation(sym);
		2424	struct annotate_args args = {
		2425	.evsel = evsel,
		2426	.options = &annotate_opts,
		2427	};
		2428	struct arch *arch = NULL;
		2429	int err;
		2430
		2431	err = evsel__get_arch(evsel, &arch);
		2432	if (err < 0)
		2433	return err;
		2434
		2435	if (parch)
		2436	*parch = arch;
		2437
		2438	args.arch = arch;
2336	args.ms = *ms;	2439	args.ms = *ms;
2337	if (notes->options && notes->options->full_addr)	2440	if (annotate_opts.full_addr)
2338	notes->start = map__objdump_2mem(ms->map, ms->sym->start);	2441	notes->start = map__objdump_2mem(ms->map, ms->sym->start);
2339	else	2442	else
2340	notes->start = map__rip_2objdump(ms->map, ms->sym->start);	2443	notes->start = map__rip_2objdump(ms->map, ms->sym->start);
@@ -2342,12 +2445,12 @@ int symbol__annotate(struct map_symbol ms, struct evsel evsel, · 1 unmodified line
2342	return symbol__disassemble(sym, &args);	2445	return symbol__disassemble(sym, &args);
2343	}	2446	}
2344		2447
2345	static void insert_source_line(struct rb_root root, struct annotation_line al,	2448	static void insert_source_line(struct rb_root root, struct annotation_line al)
2346	struct annotation_options *opts)
2347	{	2449	{
2348	struct annotation_line *iter;	2450	struct annotation_line *iter;
2349	struct rb_node **p = &root->rb_node;	2451	struct rb_node **p = &root->rb_node;
2350	struct rb_node *parent = NULL;	2452	struct rb_node *parent = NULL;
		2453	unsigned int percent_type = annotate_opts.percent_type;
2351	int i, ret;	2454	int i, ret;
2352		2455
2353	while (*p != NULL) {	2456	while (*p != NULL) {
@@ -2358,7 +2461,7 @@ static void insert_source_line(struct rb_root root, struct annotation_line al, · 4 unmodified lines
2358	if (ret == 0) {	2461	if (ret == 0) {
2359	for (i = 0; i < al->data_nr; i++) {	2462	for (i = 0; i < al->data_nr; i++) {
2360	iter->data[i].percent_sum += annotation_data__percent(&al->data[i],	2463	iter->data[i].percent_sum += annotation_data__percent(&al->data[i],
2361	opts->percent_type);	2464	percent_type);
2362	}	2465	}
2363	return;	2466	return;
2364	}	2467	}
@@ -2371,7 +2474,7 @@ static void insert_source_line(struct rb_root root, struct annotation_line al, · 6 unmodified lines
2371		2474
2372	for (i = 0; i < al->data_nr; i++) {	2475	for (i = 0; i < al->data_nr; i++) {
2373	al->data[i].percent_sum = annotation_data__percent(&al->data[i],	2476	al->data[i].percent_sum = annotation_data__percent(&al->data[i],
2374	opts->percent_type);	2477	percent_type);
2375	}	2478	}
2376		2479
2377	rb_link_node(&al->rb_node, parent, p);	2480	rb_link_node(&al->rb_node, parent, p);
@@ -2493,8 +2596,7 @@ static int annotated_source__addr_fmt_width(struct list_head *lines, u64 start) · 115 unmodified lines
2493	return 0;	2596	return 0;
2494	}	2597	}
2495		2598
2496	int symbol__annotate_printf(struct map_symbol ms, struct evsel evsel,	2599	int symbol__annotate_printf(struct map_symbol ms, struct evsel evsel)
2497	struct annotation_options *opts)
2498	{	2600	{
2499	struct map *map = ms->map;	2601	struct map *map = ms->map;
2500	struct symbol *sym = ms->sym;	2602	struct symbol *sym = ms->sym;
@@ -2505,6 +2607,7 @@ int symbol__annotate_printf(struct map_symbol ms, struct evsel evsel, · 4 unmodified lines
2505	struct annotation *notes = symbol__annotation(sym);	2607	struct annotation *notes = symbol__annotation(sym);
2506	struct sym_hist *h = annotation__histogram(notes, evsel->core.idx);	2608	struct sym_hist *h = annotation__histogram(notes, evsel->core.idx);
2507	struct annotation_line pos, queue = NULL;	2609	struct annotation_line pos, queue = NULL;
		2610	struct annotation_options *opts = &annotate_opts;
2508	u64 start = map__rip_2objdump(map, sym->start);	2611	u64 start = map__rip_2objdump(map, sym->start);
2509	int printed = 2, queue_len = 0, addr_fmt_width;	2612	int printed = 2, queue_len = 0, addr_fmt_width;
2510	int more = 0;	2613	int more = 0;
@@ -2633,8 +2736,7 @@ static void FILE__write_graph(void *fp, int graph) · 122 unmodified lines
2633	fputs(s, fp);	2736	fputs(s, fp);
2634	}	2737	}
2635		2738
2636	static int symbol__annotate_fprintf2(struct symbol sym, FILE fp,	2739	static int symbol__annotate_fprintf2(struct symbol sym, FILE fp)
2637	struct annotation_options *opts)
2638	{	2740	{
2639	struct annotation *notes = symbol__annotation(sym);	2741	struct annotation *notes = symbol__annotation(sym);
2640	struct annotation_write_ops wops = {	2742	struct annotation_write_ops wops = {
@@ -2649,9 +2751,9 @@ static int symbol__annotate_fprintf2(struct symbol sym, FILE fp, · 8 unmodified lines
2649	struct annotation_line *al;	2751	struct annotation_line *al;
2650		2752
2651	list_for_each_entry(al, &notes->src->source, node) {	2753	list_for_each_entry(al, &notes->src->source, node) {
2652	if (annotation_line__filter(al, notes))	2754	if (annotation_line__filter(al))
2653	continue;	2755	continue;
2654	annotation_line__write(al, notes, &wops, opts);	2756	annotation_line__write(al, notes, &wops);
2655	fputc('\n', fp);	2757	fputc('\n', fp);
2656	wops.first_line = false;	2758	wops.first_line = false;
2657	}	2759	}
@@ -2659,8 +2761,7 @@ static int symbol__annotate_fprintf2(struct symbol sym, FILE fp, · 1 unmodified line
2659	return 0;	2761	return 0;
2660	}	2762	}
2661		2763
2662	int map_symbol__annotation_dump(struct map_symbol ms, struct evsel evsel,	2764	int map_symbol__annotation_dump(struct map_symbol ms, struct evsel evsel)
2663	struct annotation_options *opts)
2664	{	2765	{
2665	const char *ev_name = evsel__name(evsel);	2766	const char *ev_name = evsel__name(evsel);
2666	char buf[1024];	2767	char buf[1024];
@@ -2682,7 +2783,7 @@ int map_symbol__annotation_dump(struct map_symbol ms, struct evsel evsel, · 15 unmodified lines
2682		2783
2683	fprintf(fp, "%s() %s\nEvent: %s\n\n",	2784	fprintf(fp, "%s() %s\nEvent: %s\n\n",
2684	ms->sym->name, map__dso(ms->map)->long_name, ev_name);	2785	ms->sym->name, map__dso(ms->map)->long_name, ev_name);
2685	symbol__annotate_fprintf2(ms->sym, fp, opts);	2786	symbol__annotate_fprintf2(ms->sym, fp);
2686		2787
2687	fclose(fp);	2788	fclose(fp);
2688	err = 0;	2789	err = 0;
@@ -2769,7 +2870,7 @@ void annotation__mark_jump_targets(struct annotation notes, struct symbol sym) · 80 unmodified lines
2769	return;	2870	return;
2770		2871
2771	for (offset = 0; offset < size; ++offset) {	2872	for (offset = 0; offset < size; ++offset) {
2772	struct annotation_line *al = notes->offsets[offset];	2873	struct annotation_line *al = notes->src->offsets[offset];
2773	struct disasm_line *dl;	2874	struct disasm_line *dl;
2774		2875
2775	dl = disasm_line(al);	2876	dl = disasm_line(al);
@@ -2777,7 +2878,7 @@ void annotation__mark_jump_targets(struct annotation notes, struct symbol sym) · 1 unmodified line
2777	if (!disasm_line__is_valid_local_jump(dl, sym))	2878	if (!disasm_line__is_valid_local_jump(dl, sym))
2778	continue;	2879	continue;
2779		2880
2780	al = notes->offsets[dl->ops.target.offset];	2881	al = notes->src->offsets[dl->ops.target.offset];
2781		2882
2782	/*	2883	/*
2783	* FIXME: Oops, no jump target? Buggy disassembler? Or do we	2884	* FIXME: Oops, no jump target? Buggy disassembler? Or do we
@@ -2794,19 +2895,20 @@ void annotation__mark_jump_targets(struct annotation notes, struct symbol sym) · 10 unmodified lines
2794	void annotation__set_offsets(struct annotation *notes, s64 size)	2895	void annotation__set_offsets(struct annotation *notes, s64 size)
2795	{	2896	{
2796	struct annotation_line *al;	2897	struct annotation_line *al;
		2898	struct annotated_source *src = notes->src;
2797		2899
2798	notes->max_line_len = 0;	2900	src->max_line_len = 0;
2799	notes->nr_entries = 0;	2901	src->nr_entries = 0;
2800	notes->nr_asm_entries = 0;	2902	src->nr_asm_entries = 0;
2801		2903
2802	list_for_each_entry(al, &notes->src->source, node) {	2904	list_for_each_entry(al, &src->source, node) {
2803	size_t line_len = strlen(al->line);	2905	size_t line_len = strlen(al->line);
2804		2906
2805	if (notes->max_line_len < line_len)	2907	if (src->max_line_len < line_len)
2806	notes->max_line_len = line_len;	2908	src->max_line_len = line_len;
2807	al->idx = notes->nr_entries++;	2909	al->idx = src->nr_entries++;
2808	if (al->offset != -1) {	2910	if (al->offset != -1) {
2809	al->idx_asm = notes->nr_asm_entries++;	2911	al->idx_asm = src->nr_asm_entries++;
2810	/*	2912	/*
2811	* FIXME: short term bandaid to cope with assembly	2913	* FIXME: short term bandaid to cope with assembly
2812	* routines that comes with labels in the same column	2914	* routines that comes with labels in the same column
@@ -2815,7 +2917,7 @@ void annotation__set_offsets(struct annotation *notes, s64 size) · 2 unmodified lines
2815	* E.g. copy_user_generic_unrolled	2917	* E.g. copy_user_generic_unrolled
2816	*/	2918	*/
2817	if (al->offset < size)	2919	if (al->offset < size)
2818	notes->offsets[al->offset] = al;	2920	notes->src->offsets[al->offset] = al;
2819	} else	2921	} else
2820	al->idx_asm = -1;	2922	al->idx_asm = -1;
2821	}	2923	}
@@ -2858,24 +2960,24 @@ void annotation__init_column_widths(struct annotation notes, struct symbol sym · 36 unmodified lines
2858		2960
2859	void annotation__update_column_widths(struct annotation *notes)	2961	void annotation__update_column_widths(struct annotation *notes)
2860	{	2962	{
2861	if (notes->options->use_offset)	2963	if (annotate_opts.use_offset)
2862	notes->widths.target = notes->widths.min_addr;	2964	notes->widths.target = notes->widths.min_addr;
2863	else if (notes->options->full_addr)	2965	else if (annotate_opts.full_addr)
2864	notes->widths.target = BITS_PER_LONG / 4;	2966	notes->widths.target = BITS_PER_LONG / 4;
2865	else	2967	else
2866	notes->widths.target = notes->widths.max_addr;	2968	notes->widths.target = notes->widths.max_addr;
2867		2969
2868	notes->widths.addr = notes->widths.target;	2970	notes->widths.addr = notes->widths.target;
2869		2971
2870	if (notes->options->show_nr_jumps)	2972	if (annotate_opts.show_nr_jumps)
2871	notes->widths.addr += notes->widths.jumps + 1;	2973	notes->widths.addr += notes->widths.jumps + 1;
2872	}	2974	}
2873		2975
2874	void annotation__toggle_full_addr(struct annotation notes, struct map_symbol ms)	2976	void annotation__toggle_full_addr(struct annotation notes, struct map_symbol ms)
2875	{	2977	{
2876	notes->options->full_addr = !notes->options->full_addr;	2978	annotate_opts.full_addr = !annotate_opts.full_addr;
2877		2979
2878	if (notes->options->full_addr)	2980	if (annotate_opts.full_addr)
2879	notes->start = map__objdump_2mem(ms->map, ms->sym->start);	2981	notes->start = map__objdump_2mem(ms->map, ms->sym->start);
2880	else	2982	else
2881	notes->start = map__rip_2objdump(ms->map, ms->sym->start);	2983	notes->start = map__rip_2objdump(ms->map, ms->sym->start);
@@ -2884,8 +2986,7 @@ void annotation__toggle_full_addr(struct annotation notes, struct map_symbol m · 2 unmodified lines
2884	}	2986	}
2885		2987
2886	static void annotation__calc_lines(struct annotation notes, struct map map,	2988	static void annotation__calc_lines(struct annotation notes, struct map map,
2887	struct rb_root *root,	2989	struct rb_root *root)
2888	struct annotation_options *opts)
2889	{	2990	{
2890	struct annotation_line *al;	2991	struct annotation_line *al;
2891	struct rb_root tmp_root = RB_ROOT;	2992	struct rb_root tmp_root = RB_ROOT;
@@ -2898,7 +2999,7 @@ static void annotation__calc_lines(struct annotation notes, struct map map, · 6 unmodified lines
2898	double percent;	2999	double percent;
2899		3000
2900	percent = annotation_data__percent(&al->data[i],	3001	percent = annotation_data__percent(&al->data[i],
2901	opts->percent_type);	3002	annotate_opts.percent_type);
2902		3003
2903	if (percent > percent_max)	3004	if (percent > percent_max)
2904	percent_max = percent;	3005	percent_max = percent;
@@ -2909,22 +3010,20 @@ static void annotation__calc_lines(struct annotation notes, struct map map, · 4 unmodified lines
2909		3010
2910	al->path = get_srcline(map__dso(map), notes->start + al->offset, NULL,	3011	al->path = get_srcline(map__dso(map), notes->start + al->offset, NULL,
2911	false, true, notes->start + al->offset);	3012	false, true, notes->start + al->offset);
2912	insert_source_line(&tmp_root, al, opts);	3013	insert_source_line(&tmp_root, al);
2913	}	3014	}
2914		3015
2915	resort_source_line(root, &tmp_root);	3016	resort_source_line(root, &tmp_root);
2916	}	3017	}
2917		3018
2918	static void symbol__calc_lines(struct map_symbol ms, struct rb_root root,	3019	static void symbol__calc_lines(struct map_symbol ms, struct rb_root root)
2919	struct annotation_options *opts)
2920	{	3020	{
2921	struct annotation *notes = symbol__annotation(ms->sym);	3021	struct annotation *notes = symbol__annotation(ms->sym);
2922		3022
2923	annotation__calc_lines(notes, ms->map, root, opts);	3023	annotation__calc_lines(notes, ms->map, root);
2924	}	3024	}
2925		3025
2926	int symbol__tty_annotate2(struct map_symbol ms, struct evsel evsel,	3026	int symbol__tty_annotate2(struct map_symbol ms, struct evsel evsel)
2927	struct annotation_options *opts)
2928	{	3027	{
2929	struct dso *dso = map__dso(ms->map);	3028	struct dso *dso = map__dso(ms->map);
2930	struct symbol *sym = ms->sym;	3029	struct symbol *sym = ms->sym;
@@ -2933,7 +3032,7 @@ int symbol__tty_annotate2(struct map_symbol ms, struct evsel evsel, · 2 unmodified lines
2933	char buf[1024];	3032	char buf[1024];
2934	int err;	3033	int err;
2935		3034
2936	err = symbol__annotate2(ms, evsel, opts, NULL);	3035	err = symbol__annotate2(ms, evsel, NULL);
2937	if (err) {	3036	if (err) {
2938	char msg[BUFSIZ];	3037	char msg[BUFSIZ];
2939		3038
@@ -2943,31 +3042,31 @@ int symbol__tty_annotate2(struct map_symbol ms, struct evsel evsel, · 3 unmodified lines
2943	return -1;	3042	return -1;
2944	}	3043	}
2945		3044
2946	if (opts->print_lines) {	3045	if (annotate_opts.print_lines) {
2947	srcline_full_filename = opts->full_path;	3046	srcline_full_filename = annotate_opts.full_path;
2948	symbol__calc_lines(ms, &source_line, opts);	3047	symbol__calc_lines(ms, &source_line);
2949	print_summary(&source_line, dso->long_name);	3048	print_summary(&source_line, dso->long_name);
2950	}	3049	}
2951		3050
2952	hists__scnprintf_title(hists, buf, sizeof(buf));	3051	hists__scnprintf_title(hists, buf, sizeof(buf));
2953	fprintf(stdout, "%s, [percent: %s]\n%s() %s\n",	3052	fprintf(stdout, "%s, [percent: %s]\n%s() %s\n",
2954	buf, percent_type_str(opts->percent_type), sym->name, dso->long_name);	3053	buf, percent_type_str(annotate_opts.percent_type), sym->name,
2955	symbol__annotate_fprintf2(sym, stdout, opts);	3054	dso->long_name);
		3055	symbol__annotate_fprintf2(sym, stdout);
2956		3056
2957	annotated_source__purge(symbol__annotation(sym)->src);	3057	annotated_source__purge(symbol__annotation(sym)->src);
2958		3058
2959	return 0;	3059	return 0;
2960	}	3060	}
2961		3061
2962	int symbol__tty_annotate(struct map_symbol ms, struct evsel evsel,	3062	int symbol__tty_annotate(struct map_symbol ms, struct evsel evsel)
2963	struct annotation_options *opts)
2964	{	3063	{
2965	struct dso *dso = map__dso(ms->map);	3064	struct dso *dso = map__dso(ms->map);
2966	struct symbol *sym = ms->sym;	3065	struct symbol *sym = ms->sym;
2967	struct rb_root source_line = RB_ROOT;	3066	struct rb_root source_line = RB_ROOT;
2968	int err;	3067	int err;
2969		3068
2970	err = symbol__annotate(ms, evsel, opts, NULL);	3069	err = symbol__annotate(ms, evsel, NULL);
2971	if (err) {	3070	if (err) {
2972	char msg[BUFSIZ];	3071	char msg[BUFSIZ];
2973		3072
@@ -2979,13 +3078,13 @@ int symbol__tty_annotate(struct map_symbol ms, struct evsel evsel, · 5 unmodified lines
2979		3078
2980	symbol__calc_percent(sym, evsel);	3079	symbol__calc_percent(sym, evsel);
2981		3080
2982	if (opts->print_lines) {	3081	if (annotate_opts.print_lines) {
2983	srcline_full_filename = opts->full_path;	3082	srcline_full_filename = annotate_opts.full_path;
2984	symbol__calc_lines(ms, &source_line, opts);	3083	symbol__calc_lines(ms, &source_line);
2985	print_summary(&source_line, dso->long_name);	3084	print_summary(&source_line, dso->long_name);
2986	}	3085	}
2987		3086
2988	symbol__annotate_printf(ms, evsel, opts);	3087	symbol__annotate_printf(ms, evsel);
2989		3088
2990	annotated_source__purge(symbol__annotation(sym)->src);	3089	annotated_source__purge(symbol__annotation(sym)->src);
2991		3090
@@ -3046,19 +3145,20 @@ call_like: · 54 unmodified lines
3046	obj__printf(obj, " ");	3145	obj__printf(obj, " ");
3047	}	3146	}
3048		3147
3049	disasm_line__scnprintf(dl, bf, size, !notes->options->use_offset, notes->widths.max_ins_name);	3148	disasm_line__scnprintf(dl, bf, size, !annotate_opts.use_offset, notes->widths.max_ins_name);
3050	}	3149	}
3051		3150
3052	static void ipc_coverage_string(char bf, int size, struct annotation notes)	3151	static void ipc_coverage_string(char bf, int size, struct annotation notes)
3053	{	3152	{
3054	double ipc = 0.0, coverage = 0.0;	3153	double ipc = 0.0, coverage = 0.0;
		3154	struct annotated_branch *branch = annotation__get_branch(notes);
3055		3155
3056	if (notes->hit_cycles)	3156	if (branch && branch->hit_cycles)
3057	ipc = notes->hit_insn / ((double)notes->hit_cycles);	3157	ipc = branch->hit_insn / ((double)branch->hit_cycles);
3058		3158
3059	if (notes->total_insn) {	3159	if (branch && branch->total_insn) {
3060	coverage = notes->cover_insn * 100.0 /	3160	coverage = branch->cover_insn * 100.0 /
3061	((double)notes->total_insn);	3161	((double)branch->total_insn);
3062	}	3162	}
3063		3163
3064	scnprintf(bf, size, "(Average IPC: %.2f, IPC Coverage: %.1f%%)",	3164	scnprintf(bf, size, "(Average IPC: %.2f, IPC Coverage: %.1f%%)",
@@ -3083,8 +3183,8 @@ static void __annotation_line__write(struct annotation_line *al, struct annotati · 18 unmodified lines
3083	int printed;	3183	int printed;
3084		3184
3085	if (first_line && (al->offset == -1 \|\| percent_max == 0.0)) {	3185	if (first_line && (al->offset == -1 \|\| percent_max == 0.0)) {
3086	if (notes->have_cycles) {	3186	if (notes->branch && al->cycles) {
3087	if (al->ipc == 0.0 && al->cycles == 0)	3187	if (al->cycles->ipc == 0.0 && al->cycles->avg == 0)
3088	show_title = true;	3188	show_title = true;
3089	} else	3189	} else
3090	show_title = true;	3190	show_title = true;
@@ -3120,18 +3220,18 @@ static void __annotation_line__write(struct annotation_line *al, struct annotati · 29 unmodified lines
3120	}	3220	}
3121	}	3221	}
3122		3222
3123	if (notes->have_cycles) {	3223	if (notes->branch) {
3124	if (al->ipc)	3224	if (al->cycles && al->cycles->ipc)
3125	obj__printf(obj, "%*.2f ", ANNOTATION__IPC_WIDTH - 1, al->ipc);	3225	obj__printf(obj, "%*.2f ", ANNOTATION__IPC_WIDTH - 1, al->cycles->ipc);
3126	else if (!show_title)	3226	else if (!show_title)
3127	obj__printf(obj, "%*s", ANNOTATION__IPC_WIDTH, " ");	3227	obj__printf(obj, "%*s", ANNOTATION__IPC_WIDTH, " ");
3128	else	3228	else
3129	obj__printf(obj, "%*s ", ANNOTATION__IPC_WIDTH - 1, "IPC");	3229	obj__printf(obj, "%*s ", ANNOTATION__IPC_WIDTH - 1, "IPC");
3130		3230
3131	if (!notes->options->show_minmax_cycle) {	3231	if (!annotate_opts.show_minmax_cycle) {
3132	if (al->cycles)	3232	if (al->cycles && al->cycles->avg)
3133	obj__printf(obj, "%*" PRIu64 " ",	3233	obj__printf(obj, "%*" PRIu64 " ",
3134	ANNOTATION__CYCLES_WIDTH - 1, al->cycles);	3234	ANNOTATION__CYCLES_WIDTH - 1, al->cycles->avg);
3135	else if (!show_title)	3235	else if (!show_title)
3136	obj__printf(obj, "%*s",	3236	obj__printf(obj, "%*s",
3137	ANNOTATION__CYCLES_WIDTH, " ");	3237	ANNOTATION__CYCLES_WIDTH, " ");
@@ -3145,8 +3245,8 @@ static void __annotation_line__write(struct annotation_line *al, struct annotati · 7 unmodified lines
3145		3245
3146	scnprintf(str, sizeof(str),	3246	scnprintf(str, sizeof(str),
3147	"%" PRIu64 "(%" PRIu64 "/%" PRIu64 ")",	3247	"%" PRIu64 "(%" PRIu64 "/%" PRIu64 ")",
3148	al->cycles, al->cycles_min,	3248	al->cycles->avg, al->cycles->min,
3149	al->cycles_max);	3249	al->cycles->max);
3150		3250
3151	obj__printf(obj, "%*s ",	3251	obj__printf(obj, "%*s ",
3152	ANNOTATION__MINMAX_CYCLES_WIDTH - 1,	3252	ANNOTATION__MINMAX_CYCLES_WIDTH - 1,
@@ -3172,7 +3272,7 @@ static void __annotation_line__write(struct annotation_line *al, struct annotati · 19 unmodified lines
3172	if (!*al->line)	3272	if (!*al->line)
3173	obj__printf(obj, "%-*s", width - pcnt_width - cycles_width, " ");	3273	obj__printf(obj, "%-*s", width - pcnt_width - cycles_width, " ");
3174	else if (al->offset == -1) {	3274	else if (al->offset == -1) {
3175	if (al->line_nr && notes->options->show_linenr)	3275	if (al->line_nr && annotate_opts.show_linenr)
3176	printed = scnprintf(bf, sizeof(bf), "%-*d ", notes->widths.addr + 1, al->line_nr);	3276	printed = scnprintf(bf, sizeof(bf), "%-*d ", notes->widths.addr + 1, al->line_nr);
3177	else	3277	else
3178	printed = scnprintf(bf, sizeof(bf), "%-*s ", notes->widths.addr, " ");	3278	printed = scnprintf(bf, sizeof(bf), "%-*s ", notes->widths.addr, " ");
@@ -3182,15 +3282,15 @@ static void __annotation_line__write(struct annotation_line *al, struct annotati · 3 unmodified lines
3182	u64 addr = al->offset;	3282	u64 addr = al->offset;
3183	int color = -1;	3283	int color = -1;
3184		3284
3185	if (!notes->options->use_offset)	3285	if (!annotate_opts.use_offset)
3186	addr += notes->start;	3286	addr += notes->start;
3187		3287
3188	if (!notes->options->use_offset) {	3288	if (!annotate_opts.use_offset) {
3189	printed = scnprintf(bf, sizeof(bf), "%" PRIx64 ": ", addr);	3289	printed = scnprintf(bf, sizeof(bf), "%" PRIx64 ": ", addr);
3190	} else {	3290	} else {
3191	if (al->jump_sources &&	3291	if (al->jump_sources &&
3192	notes->options->offset_level >= ANNOTATION__OFFSET_JUMP_TARGETS) {	3292	annotate_opts.offset_level >= ANNOTATION__OFFSET_JUMP_TARGETS) {
3193	if (notes->options->show_nr_jumps) {	3293	if (annotate_opts.show_nr_jumps) {
3194	int prev;	3294	int prev;
3195	printed = scnprintf(bf, sizeof(bf), "%*d ",	3295	printed = scnprintf(bf, sizeof(bf), "%*d ",
3196	notes->widths.jumps,	3296	notes->widths.jumps,
@@ -3204,9 +3304,9 @@ print_addr: · 7 unmodified lines
3204	printed = scnprintf(bf, sizeof(bf), "%*" PRIx64 ": ",	3304	printed = scnprintf(bf, sizeof(bf), "%*" PRIx64 ": ",
3205	notes->widths.target, addr);	3305	notes->widths.target, addr);
3206	} else if (ins__is_call(&disasm_line(al)->ins) &&	3306	} else if (ins__is_call(&disasm_line(al)->ins) &&
3207	notes->options->offset_level >= ANNOTATION__OFFSET_CALL) {	3307	annotate_opts.offset_level >= ANNOTATION__OFFSET_CALL) {
3208	goto print_addr;	3308	goto print_addr;
3209	} else if (notes->options->offset_level == ANNOTATION__MAX_OFFSET_LEVEL) {	3309	} else if (annotate_opts.offset_level == ANNOTATION__MAX_OFFSET_LEVEL) {
3210	goto print_addr;	3310	goto print_addr;
3211	} else {	3311	} else {
3212	printed = scnprintf(bf, sizeof(bf), "%-*s ",	3312	printed = scnprintf(bf, sizeof(bf), "%-*s ",
@@ -3228,43 +3328,44 @@ print_addr: · 15 unmodified lines
3228	}	3328	}
3229		3329
3230	void annotation_line__write(struct annotation_line al, struct annotation notes,	3330	void annotation_line__write(struct annotation_line al, struct annotation notes,
3231	struct annotation_write_ops *wops,	3331	struct annotation_write_ops *wops)
3232	struct annotation_options *opts)
3233	{	3332	{
3234	__annotation_line__write(al, notes, wops->first_line, wops->current_entry,	3333	__annotation_line__write(al, notes, wops->first_line, wops->current_entry,
3235	wops->change_color, wops->width, wops->obj,	3334	wops->change_color, wops->width, wops->obj,
3236	opts->percent_type,	3335	annotate_opts.percent_type,
3237	wops->set_color, wops->set_percent_color,	3336	wops->set_color, wops->set_percent_color,
3238	wops->set_jumps_percent_color, wops->printf,	3337	wops->set_jumps_percent_color, wops->printf,
3239	wops->write_graph);	3338	wops->write_graph);
3240	}	3339	}
3241		3340
3242	int symbol__annotate2(struct map_symbol ms, struct evsel evsel,	3341	int symbol__annotate2(struct map_symbol ms, struct evsel evsel,
3243	struct annotation_options options, struct arch *parch)	3342	struct arch **parch)
3244	{	3343	{
3245	struct symbol *sym = ms->sym;	3344	struct symbol *sym = ms->sym;
3246	struct annotation *notes = symbol__annotation(sym);	3345	struct annotation *notes = symbol__annotation(sym);
3247	size_t size = symbol__size(sym);	3346	size_t size = symbol__size(sym);
3248	int nr_pcnt = 1, err;	3347	int nr_pcnt = 1, err;
3249		3348
3250	notes->offsets = zalloc(size * sizeof(struct annotation_line *));	3349	notes->src->offsets = zalloc(size * sizeof(struct annotation_line *));
3251	if (notes->offsets == NULL)	3350	if (notes->src->offsets == NULL)
3252	return ENOMEM;	3351	return ENOMEM;
3253		3352
3254	if (evsel__is_group_event(evsel))	3353	if (evsel__is_group_event(evsel))
3255	nr_pcnt = evsel->core.nr_members;	3354	nr_pcnt = evsel->core.nr_members;
3256		3355
3257	err = symbol__annotate(ms, evsel, options, parch);	3356	err = symbol__annotate(ms, evsel, parch);
3258	if (err)	3357	if (err)
3259	goto out_free_offsets;	3358	goto out_free_offsets;
3260		3359
3261	notes->options = options;
3262
3263	symbol__calc_percent(sym, evsel);	3360	symbol__calc_percent(sym, evsel);
3264		3361
3265	annotation__set_offsets(notes, size);	3362	annotation__set_offsets(notes, size);
3266	annotation__mark_jump_targets(notes, sym);	3363	annotation__mark_jump_targets(notes, sym);
3267	annotation__compute_ipc(notes, size);	3364
		3365	err = annotation__compute_ipc(notes, size);
		3366	if (err)
		3367	goto out_free_offsets;
		3368
3268	annotation__init_column_widths(notes, sym);	3369	annotation__init_column_widths(notes, sym);
3269	notes->nr_events = nr_pcnt;	3370	notes->nr_events = nr_pcnt;
3270		3371
@@ -3274,7 +3375,7 @@ int symbol__annotate2(struct map_symbol ms, struct evsel evsel, · 3 unmodified lines
3274	return 0;	3375	return 0;
3275		3376
3276	out_free_offsets:	3377	out_free_offsets:
3277	zfree(&notes->offsets);	3378	zfree(&notes->src->offsets);
3278	return err;	3379	return err;
3279	}	3380	}
3280		3381
@@ -3337,8 +3438,10 @@ static int annotation__config(const char var, const char value, void *data) · 56 unmodified lines
3337	return 0;	3438	return 0;
3338	}	3439	}
3339		3440
3340	void annotation_options__init(struct annotation_options *opt)	3441	void annotation_options__init(void)
3341	{	3442	{
		3443	struct annotation_options *opt = &annotate_opts;
		3444
3342	memset(opt, 0, sizeof(*opt));	3445	memset(opt, 0, sizeof(*opt));
3343		3446
3344	/* Default values. */	3447	/* Default values. */
@@ -3349,16 +3452,15 @@ void annotation_options__init(struct annotation_options *opt) · 4 unmodified lines
3349	opt->percent_type = PERCENT_PERIOD_LOCAL;	3452	opt->percent_type = PERCENT_PERIOD_LOCAL;
3350	}	3453	}
3351		3454
3352		3455	void annotation_options__exit(void)
3353	void annotation_options__exit(struct annotation_options *opt)
3354	{	3456	{
3355	zfree(&opt->disassembler_style);	3457	zfree(&annotate_opts.disassembler_style);
3356	zfree(&opt->objdump_path);	3458	zfree(&annotate_opts.objdump_path);
3357	}	3459	}
3358		3460
3359	void annotation_config__init(struct annotation_options *opt)	3461	void annotation_config__init(void)
3360	{	3462	{
3361	perf_config(annotation__config, opt);	3463	perf_config(annotation__config, &annotate_opts);
3362	}	3464	}
3363		3465
3364	static unsigned int parse_percent_type(char str1, char str2)	3466	static unsigned int parse_percent_type(char str1, char str2)
@@ -3382,10 +3484,9 @@ static unsigned int parse_percent_type(char str1, char str2) · 17 unmodified lines
3382	return type;	3484	return type;
3383	}	3485	}
3384		3486
3385	int annotate_parse_percent_type(const struct option opt, const char _str,	3487	int annotate_parse_percent_type(const struct option opt __maybe_unused, const char _str,
3386	int unset __maybe_unused)	3488	int unset __maybe_unused)
3387	{	3489	{
3388	struct annotation_options *opts = opt->value;
3389	unsigned int type;	3490	unsigned int type;
3390	char str1, str2;	3491	char str1, str2;
3391	int err = -1;	3492	int err = -1;
@@ -3404,7 +3505,7 @@ int annotate_parse_percent_type(const struct option opt, const char _str, · 12 unmodified lines
3404	if (type == (unsigned int) -1)	3505	if (type == (unsigned int) -1)
3405	type = parse_percent_type(str2, str1);	3506	type = parse_percent_type(str2, str1);
3406	if (type != (unsigned int) -1) {	3507	if (type != (unsigned int) -1) {
3407	opts->percent_type = type;	3508	annotate_opts.percent_type = type;
3408	err = 0;	3509	err = 0;
3409	}	3510	}
3410		3511
@@ -3413,11 +3514,267 @@ out: · 2 unmodified lines
3413	return err;	3514	return err;
3414	}	3515	}
3415		3516
3416	int annotate_check_args(struct annotation_options *args)	3517	int annotate_check_args(void)
3417	{	3518	{
		3519	struct annotation_options *args = &annotate_opts;
		3520
3418	if (args->prefix_strip && !args->prefix) {	3521	if (args->prefix_strip && !args->prefix) {
3419	pr_err("--prefix-strip requires --prefix\n");	3522	pr_err("--prefix-strip requires --prefix\n");
3420	return -1;	3523	return -1;
3421	}	3524	}
3422	return 0;	3525	return 0;
3423	}	3526	}
		3527
		3528	/*
		3529	* Get register number and access offset from the given instruction.
		3530	* It assumes AT&T x86 asm format like OFFSET(REG). Maybe it needs
		3531	* to revisit the format when it handles different architecture.
		3532	* Fills @reg and @offset when return 0.
		3533	*/
		3534	static int extract_reg_offset(struct arch arch, const char str,
		3535	struct annotated_op_loc *op_loc)
		3536	{
		3537	char *p;
		3538	char *regname;
		3539
		3540	if (arch->objdump.register_char == 0)
		3541	return -1;
		3542
		3543	/*
		3544	* It should start from offset, but it's possible to skip 0
		3545	* in the asm. So 0(%rax) should be same as (%rax).
		3546	*
		3547	* However, it also start with a segment select register like
		3548	* %gs:0x18(%rbx). In that case it should skip the part.
		3549	*/
		3550	if (*str == arch->objdump.register_char) {
		3551	while (str && !isdigit(str) &&
		3552	*str != arch->objdump.memory_ref_char)
		3553	str++;
		3554	}
		3555
		3556	op_loc->offset = strtol(str, &p, 0);
		3557
		3558	p = strchr(p, arch->objdump.register_char);
		3559	if (p == NULL)
		3560	return -1;
		3561
		3562	regname = strdup(p);
		3563	if (regname == NULL)
		3564	return -1;
		3565
		3566	op_loc->reg = get_dwarf_regnum(regname, 0);
		3567	free(regname);
		3568	return 0;
		3569	}
		3570
		3571	/**
		3572	* annotate_get_insn_location - Get location of instruction
		3573	* @arch: the architecture info
		3574	* @dl: the target instruction
		3575	* @loc: a buffer to save the data
		3576	*
		3577	* Get detailed location info (register and offset) in the instruction.
		3578	* It needs both source and target operand and whether it accesses a
		3579	* memory location. The offset field is meaningful only when the
		3580	* corresponding mem flag is set.
		3581	*
		3582	* Some examples on x86:
		3583	*
		3584	* mov (%rax), %rcx # src_reg = rax, src_mem = 1, src_offset = 0
		3585	* # dst_reg = rcx, dst_mem = 0
		3586	*
		3587	* mov 0x18, %r8 # src_reg = -1, dst_reg = r8
		3588	*/
		3589	int annotate_get_insn_location(struct arch arch, struct disasm_line dl,
		3590	struct annotated_insn_loc *loc)
		3591	{
		3592	struct ins_operands *ops;
		3593	struct annotated_op_loc *op_loc;
		3594	int i;
		3595
		3596	if (!strcmp(dl->ins.name, "lock"))
		3597	ops = dl->ops.locked.ops;
		3598	else
		3599	ops = &dl->ops;
		3600
		3601	if (ops == NULL)
		3602	return -1;
		3603
		3604	memset(loc, 0, sizeof(*loc));
		3605
		3606	for_each_insn_op_loc(loc, i, op_loc) {
		3607	const char *insn_str = ops->source.raw;
		3608
		3609	if (i == INSN_OP_TARGET)
		3610	insn_str = ops->target.raw;
		3611
		3612	/* Invalidate the register by default */
		3613	op_loc->reg = -1;
		3614
		3615	if (insn_str == NULL)
		3616	continue;
		3617
		3618	if (strchr(insn_str, arch->objdump.memory_ref_char)) {
		3619	op_loc->mem_ref = true;
		3620	extract_reg_offset(arch, insn_str, op_loc);
		3621	} else {
		3622	char *s = strdup(insn_str);
		3623
		3624	if (s) {
		3625	op_loc->reg = get_dwarf_regnum(s, 0);
		3626	free(s);
		3627	}
		3628	}
		3629	}
		3630
		3631	return 0;
		3632	}
		3633
		3634	static void symbol__ensure_annotate(struct map_symbol ms, struct evsel evsel)
		3635	{
		3636	struct disasm_line dl, tmp_dl;
		3637	struct annotation *notes;
		3638
		3639	notes = symbol__annotation(ms->sym);
		3640	if (!list_empty(&notes->src->source))
		3641	return;
		3642
		3643	if (symbol__annotate(ms, evsel, NULL) < 0)
		3644	return;
		3645
		3646	/* remove non-insn disasm lines for simplicity */
		3647	list_for_each_entry_safe(dl, tmp_dl, &notes->src->source, al.node) {
		3648	if (dl->al.offset == -1) {
		3649	list_del(&dl->al.node);
		3650	free(dl);
		3651	}
		3652	}
		3653	}
		3654
		3655	static struct disasm_line find_disasm_line(struct symbol sym, u64 ip)
		3656	{
		3657	struct disasm_line *dl;
		3658	struct annotation *notes;
		3659
		3660	notes = symbol__annotation(sym);
		3661
		3662	list_for_each_entry(dl, &notes->src->source, al.node) {
		3663	if (sym->start + dl->al.offset == ip)
		3664	return dl;
		3665	}
		3666	return NULL;
		3667	}
		3668
		3669	static struct annotated_item_stat annotate_data_stat(struct list_head head,
		3670	const char *name)
		3671	{
		3672	struct annotated_item_stat *istat;
		3673
		3674	list_for_each_entry(istat, head, list) {
		3675	if (!strcmp(istat->name, name))
		3676	return istat;
		3677	}
		3678
		3679	istat = zalloc(sizeof(*istat));
		3680	if (istat == NULL)
		3681	return NULL;
		3682
		3683	istat->name = strdup(name);
		3684	if (istat->name == NULL) {
		3685	free(istat);
		3686	return NULL;
		3687	}
		3688
		3689	list_add_tail(&istat->list, head);
		3690	return istat;
		3691	}
		3692
		3693	/**
		3694	* hist_entry__get_data_type - find data type for given hist entry
		3695	* @he: hist entry
		3696	*
		3697	* This function first annotates the instruction at @he->ip and extracts
		3698	* register and offset info from it. Then it searches the DWARF debug
		3699	* info to get a variable and type information using the address, register,
		3700	* and offset.
		3701	*/
		3702	struct annotated_data_type hist_entry__get_data_type(struct hist_entry he)
		3703	{
		3704	struct map_symbol *ms = &he->ms;
		3705	struct evsel *evsel = hists_to_evsel(he->hists);
		3706	struct arch *arch;
		3707	struct disasm_line *dl;
		3708	struct annotated_insn_loc loc;
		3709	struct annotated_op_loc *op_loc;
		3710	struct annotated_data_type *mem_type;
		3711	struct annotated_item_stat *istat;
		3712	u64 ip = he->ip;
		3713	int i;
		3714
		3715	ann_data_stat.total++;
		3716
		3717	if (ms->map == NULL \|\| ms->sym == NULL) {
		3718	ann_data_stat.no_sym++;
		3719	return NULL;
		3720	}
		3721
		3722	if (!symbol_conf.init_annotation) {
		3723	ann_data_stat.no_sym++;
		3724	return NULL;
		3725	}
		3726
		3727	if (evsel__get_arch(evsel, &arch) < 0) {
		3728	ann_data_stat.no_insn++;
		3729	return NULL;
		3730	}
		3731
		3732	/* Make sure it runs objdump to get disasm of the function */
		3733	symbol__ensure_annotate(ms, evsel);
		3734
		3735	/*
		3736	* Get a disasm to extract the location from the insn.
		3737	* This is too slow...
		3738	*/
		3739	dl = find_disasm_line(ms->sym, ip);
		3740	if (dl == NULL) {
		3741	ann_data_stat.no_insn++;
		3742	return NULL;
		3743	}
		3744
		3745	istat = annotate_data_stat(&ann_insn_stat, dl->ins.name);
		3746	if (istat == NULL) {
		3747	ann_data_stat.no_insn++;
		3748	return NULL;
		3749	}
		3750
		3751	if (annotate_get_insn_location(arch, dl, &loc) < 0) {
		3752	ann_data_stat.no_insn_ops++;
		3753	istat->bad++;
		3754	return NULL;
		3755	}
		3756
		3757	for_each_insn_op_loc(&loc, i, op_loc) {
		3758	if (!op_loc->mem_ref)
		3759	continue;
		3760
		3761	mem_type = find_data_type(ms, ip, op_loc->reg, op_loc->offset);
		3762	if (mem_type)
		3763	istat->good++;
		3764	else
		3765	istat->bad++;
		3766
		3767	if (symbol_conf.annotate_data_sample) {
		3768	annotated_data_type__update_samples(mem_type, evsel,
		3769	op_loc->offset,
		3770	he->stat.nr_events,
		3771	he->stat.period);
		3772	}
		3773	he->mem_type_off = op_loc->offset;
		3774	return mem_type;
		3775	}
		3776
		3777	ann_data_stat.no_mem_ops++;
		3778	istat->bad++;
		3779	return NULL;
		3780	}

tools/perf/util/annotate.h+100−44

 struct perf_sample;
 struct evsel;
 struct symbol;
+struct annotated_data_type;
 struct ins {
 	const char     *name;
 struct ins_operands {
 	char	*raw;
-	char	*raw_comment;
-	char	*raw_func_start;
 	struct {
 		char	*raw;
 		char	*name;
 		s64	offset;
 		bool	offset_avail;
 		bool	outside;
+		bool	multi_regs;
 	} target;
 	union {
 		struct {
 			char	*raw;
 			char	*name;
 			u64	addr;
+			bool	multi_regs;
 		} source;
 		struct {
 			struct ins	    ins;
 			struct ins_operands *ops;
 		} locked;
+		struct {
+			char	*raw_comment;
+			char	*raw_func_start;
+		} jump;
 	};
 };
 struct arch;
+bool arch__is(struct arch *arch, const char *name);
 struct ins_ops {
 	void (*free)(struct ins_operands *ops);
 	int (*parse)(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms);
 	unsigned int percent_type;
 };
+extern struct annotation_options annotate_opts;
 enum {
 	ANNOTATION__OFFSET_JUMP_TARGETS = 1,
 	ANNOTATION__OFFSET_CALL,
 	struct sym_hist_entry	 he;
 };
+struct cycles_info {
+	float			 ipc;
+	u64			 avg;
+	u64			 max;
+	u64			 min;
+};
 struct annotation_line {
 	struct list_head	 node;
 	struct rb_node		 rb_node;
 	char			*line;
 	int			 line_nr;
 	char			*fileloc;
-	int			 jump_sources;
-	float			 ipc;
-	u64			 cycles;
-	u64			 cycles_max;
-	u64			 cycles_min;
 	char			*path;
+	struct cycles_info	*cycles;
+	int			 jump_sources;
 	u32			 idx;
 	int			 idx_asm;
 	int			 data_nr;
 };
 void annotation_line__write(struct annotation_line *al, struct annotation *notes,
-			    struct annotation_write_ops *ops,
+			    struct annotation_write_ops *ops);
-			    struct annotation_options *opts);
 int __annotation__scnprintf_samples_period(struct annotation *notes,
 					   char *bf, size_t size,
  * returns.
  */
 struct annotated_source {
-	struct list_head   source;
+	struct list_head	source;
-	int    		   nr_histograms;
+	size_t			sizeof_sym_hist;
-	size_t		   sizeof_sym_hist;
+	struct sym_hist		*histograms;
-	struct cyc_hist	   *cycles_hist;
+	struct annotation_line	**offsets;
-	struct sym_hist	   *histograms;
+	int    			nr_histograms;
+	int			nr_entries;
+	int			nr_asm_entries;
+	u16			max_line_len;
 };
-struct LOCKABLE annotation {
+struct annotated_branch {
-	u64			max_coverage;
-	u64			start;
 	u64			hit_cycles;
 	u64			hit_insn;
 	unsigned int		total_insn;
 	unsigned int		cover_insn;
-	struct annotation_options *options;
+	struct cyc_hist		*cycles_hist;
-	struct annotation_line	**offsets;
+	u64			max_coverage;
+};
+struct LOCKABLE annotation {
+	u64			start;
 	int			nr_events;
 	int			max_jump_sources;
-	int			nr_entries;
-	int			nr_asm_entries;
-	u16			max_line_len;
 	struct {
 		u8		addr;
 		u8		jumps;
 		u8		max_addr;
 		u8		max_ins_name;
 	} widths;
-	bool			have_cycles;
 	struct annotated_source *src;
+	struct annotated_branch *branch;
 };
 static inline void annotation__init(struct annotation *notes __maybe_unused)
 static inline int annotation__cycles_width(struct annotation *notes)
 {
-	if (notes->have_cycles && notes->options->show_minmax_cycle)
+	if (notes->branch && annotate_opts.show_minmax_cycle)
 		return ANNOTATION__IPC_WIDTH + ANNOTATION__MINMAX_CYCLES_WIDTH;
-	return notes->have_cycles ? ANNOTATION__IPC_WIDTH + ANNOTATION__CYCLES_WIDTH : 0;
+	return notes->branch ? ANNOTATION__IPC_WIDTH + ANNOTATION__CYCLES_WIDTH : 0;
 }
 static inline int annotation__pcnt_width(struct annotation *notes)
 	return (symbol_conf.show_total_period ? 12 : 7) * notes->nr_events;
 }
-static inline bool annotation_line__filter(struct annotation_line *al, struct annotation *notes)
+static inline bool annotation_line__filter(struct annotation_line *al)
 {
-	return notes->options->hide_src_code && al->offset == -1;
+	return annotate_opts.hide_src_code && al->offset == -1;
 }
 void annotation__set_offsets(struct annotation *notes, s64 size);
-void annotation__compute_ipc(struct annotation *notes, size_t size);
 void annotation__mark_jump_targets(struct annotation *notes, struct symbol *sym);
 void annotation__update_column_widths(struct annotation *notes);
 void annotation__init_column_widths(struct annotation *notes, struct symbol *sym);
 int addr_map_symbol__inc_samples(struct addr_map_symbol *ams, struct perf_sample *sample,
 				 struct evsel *evsel);
+struct annotated_branch *annotation__get_branch(struct annotation *notes);
 int addr_map_symbol__account_cycles(struct addr_map_symbol *ams,
 				    struct addr_map_symbol *start,
 				    unsigned cycles);
 int symbol__annotate(struct map_symbol *ms,
 		     struct evsel *evsel,
-		     struct annotation_options *options,
 		     struct arch **parch);
 int symbol__annotate2(struct map_symbol *ms,
 		      struct evsel *evsel,
-		      struct annotation_options *options,
 		      struct arch **parch);
 enum symbol_disassemble_errno {
 int symbol__strerror_disassemble(struct map_symbol *ms, int errnum, char *buf, size_t buflen);
-int symbol__annotate_printf(struct map_symbol *ms, struct evsel *evsel,
+int symbol__annotate_printf(struct map_symbol *ms, struct evsel *evsel);
-			    struct annotation_options *options);
 void symbol__annotate_zero_histogram(struct symbol *sym, int evidx);
 void symbol__annotate_decay_histogram(struct symbol *sym, int evidx);
 void annotated_source__purge(struct annotated_source *as);
-int map_symbol__annotation_dump(struct map_symbol *ms, struct evsel *evsel,
+int map_symbol__annotation_dump(struct map_symbol *ms, struct evsel *evsel);
-				struct annotation_options *opts);
 bool ui__has_annotation(void);
-int symbol__tty_annotate(struct map_symbol *ms, struct evsel *evsel, struct annotation_options *opts);
+int symbol__tty_annotate(struct map_symbol *ms, struct evsel *evsel);
-int symbol__tty_annotate2(struct map_symbol *ms, struct evsel *evsel, struct annotation_options *opts);
+int symbol__tty_annotate2(struct map_symbol *ms, struct evsel *evsel);
 #ifdef HAVE_SLANG_SUPPORT
 int symbol__tui_annotate(struct map_symbol *ms, struct evsel *evsel,
-			 struct hist_browser_timer *hbt,
+			 struct hist_browser_timer *hbt);
-			 struct annotation_options *opts);
 #else
 static inline int symbol__tui_annotate(struct map_symbol *ms __maybe_unused,
 				struct evsel *evsel  __maybe_unused,
-				struct hist_browser_timer *hbt __maybe_unused,
+				struct hist_browser_timer *hbt __maybe_unused)
-				struct annotation_options *opts __maybe_unused)
 {
 	return 0;
 }
 #endif
-void annotation_options__init(struct annotation_options *opt);
+void annotation_options__init(void);
-void annotation_options__exit(struct annotation_options *opt);
+void annotation_options__exit(void);
-void annotation_config__init(struct annotation_options *opt);
+void annotation_config__init(void);
 int annotate_parse_percent_type(const struct option *opt, const char *_str,
 				int unset);
-int annotate_check_args(struct annotation_options *args);
+int annotate_check_args(void);
+/**
+ * struct annotated_op_loc - Location info of instruction operand
+ * @reg: Register in the operand
+ * @offset: Memory access offset in the operand
+ * @mem_ref: Whether the operand accesses memory
+ */
+struct annotated_op_loc {
+	int reg;
+	int offset;
+	bool mem_ref;
+};
+enum annotated_insn_ops {
+	INSN_OP_SOURCE = 0,
+	INSN_OP_TARGET = 1,
+	INSN_OP_MAX,
+};
+/**
+ * struct annotated_insn_loc - Location info of instruction
+ * @ops: Array of location info for source and target operands
+ */
+struct annotated_insn_loc {
+	struct annotated_op_loc ops[INSN_OP_MAX];
+};
+#define for_each_insn_op_loc(insn_loc, i, op_loc)			\
+	for (i = INSN_OP_SOURCE, op_loc = &(insn_loc)->ops[i];		\
+	     i < INSN_OP_MAX;						\
+	     i++, op_loc++)
+/* Get detailed location info in the instruction */
+int annotate_get_insn_location(struct arch *arch, struct disasm_line *dl,
+			       struct annotated_insn_loc *loc);
+/* Returns a data type from the sample instruction (if any) */
+struct annotated_data_type *hist_entry__get_data_type(struct hist_entry *he);
+struct annotated_item_stat {
+	struct list_head list;
+	char *name;
+	int good;
+	int bad;
+};
+extern struct list_head ann_insn_stat;
 #endif	/* __PERF_ANNOTATE_H */

tools/perf/util/auxtrace.c+5−2

 				   struct evlist *evlist,
 				   struct evsel *evsel, int idx)
 {
-	bool per_cpu = !perf_cpu_map__empty(evlist->core.user_requested_cpus);
+	bool per_cpu = !perf_cpu_map__has_any_cpu_or_is_empty(evlist->core.user_requested_cpus);
 	mp->mmap_needed = evsel->needs_auxtrace_mmap;
 static int evlist__enable_event_idx(struct evlist *evlist, struct evsel *evsel, int idx)
 {
-	bool per_cpu_mmaps = !perf_cpu_map__empty(evlist->core.user_requested_cpus);
+	bool per_cpu_mmaps = !perf_cpu_map__has_any_cpu_or_is_empty(evlist->core.user_requested_cpus);
 	if (per_cpu_mmaps) {
 		struct perf_cpu evlist_cpu = perf_cpu_map__cpu(evlist->core.all_cpus, idx);
 		case 'Z':
 			synth_opts->timeless_decoding = true;
 			break;
+		case 'T':
+			synth_opts->use_timestamp = true;
+			break;
 		case ' ':
 		case ',':
 			break;

tools/perf/util/auxtrace.h+3−0

  * @remote_access: whether to synthesize remote access events
  * @mem: whether to synthesize memory events
  * @timeless_decoding: prefer "timeless" decoding i.e. ignore timestamps
+ * @use_timestamp: use the timestamp trace as kernel time
  * @vm_time_correlation: perform VM Time Correlation
  * @vm_tm_corr_dry_run: VM Time Correlation dry-run
  * @vm_tm_corr_args:  VM Time Correlation implementation-specific arguments
 	bool			remote_access;
 	bool			mem;
 	bool			timeless_decoding;
+	bool			use_timestamp;
 	bool			vm_time_correlation;
 	bool			vm_tm_corr_dry_run;
 	char			*vm_tm_corr_args;
 "				q:			quicker (less detailed) decoding\n" \
 "				A:			approximate IPC\n" \
 "				Z:			prefer to ignore timestamps (so-called \"timeless\" decoding)\n" \
+"				T:			use the timestamp trace as kernel time\n" \
 "				PERIOD[ns|us|ms|i|t]:   specify period to sample stream\n" \
 "				concatenate multiple options. Default is iybxwpe or cewp\n"

tools/perf/util/block-info.c+4−6

 	al.sym = he->ms.sym;
 	notes = symbol__annotation(he->ms.sym);
-	if (!notes || !notes->src || !notes->src->cycles_hist)
+	if (!notes || !notes->branch || !notes->branch->cycles_hist)
 		return 0;
-	ch = notes->src->cycles_hist;
+	ch = notes->branch->cycles_hist;
 	for (unsigned int i = 0; i < symbol__size(he->ms.sym); i++) {
 		if (ch[i].num_aggr) {
 			struct block_info *bi;
 }
 int report__browse_block_hists(struct block_hist *bh, float min_percent,
-			       struct evsel *evsel, struct perf_env *env,
+			       struct evsel *evsel, struct perf_env *env)
-			       struct annotation_options *annotation_opts)
 {
 	int ret;
 		return 0;
 	case 1:
 		symbol_conf.report_individual_block = true;
-		ret = block_hists_tui_browse(bh, evsel, min_percent,
+		ret = block_hists_tui_browse(bh, evsel, min_percent, env);
-					     env, annotation_opts);
 		return ret;
 	default:
 		return -1;

tools/perf/util/block-info.h+1−2

@@ -78,8 +78,7 @@ struct block_report block_info__create_report(struct evlist evlist, · 77 unmodified lines
78	void block_info__free_report(struct block_report *reps, int nr_reps);	78	void block_info__free_report(struct block_report *reps, int nr_reps);
79		79
80	int report__browse_block_hists(struct block_hist *bh, float min_percent,	80	int report__browse_block_hists(struct block_hist *bh, float min_percent,
81	struct evsel evsel, struct perf_env env,	81	struct evsel evsel, struct perf_env env);
82	struct annotation_options *annotation_opts);
83		82
84	float block_info__total_cycles_percent(struct hist_entry *he);	83	float block_info__total_cycles_percent(struct hist_entry *he);
85		84

tools/perf/util/block-range.c+6−1

 double block_range__coverage(struct block_range *br)
 {
 	struct symbol *sym;
+	struct annotated_branch *branch;
 	if (!br) {
 		if (block_ranges.blocks)
 	if (!sym)
 		return -1;
-	return (double)br->coverage / symbol__annotation(sym)->max_coverage;
+	branch = symbol__annotation(sym)->branch;
+	if (!branch)
+		return -1;
+	return (double)br->coverage / branch->max_coverage;
 }

tools/perf/util/bpf-event.c+7−4

 	int err;
 	int fd;
+	if (opts->no_bpf_event)
+		return 0;
 	event = malloc(sizeof(event->bpf) + KSYM_NAME_LEN + machine->id_hdr_size);
 	if (!event)
 		return -1;
 	return evlist__add_sb_event(evlist, &attr, bpf_event__sb_cb, env);
 }
-void bpf_event__print_bpf_prog_info(struct bpf_prog_info *info,
+void __bpf_event__print_bpf_prog_info(struct bpf_prog_info *info,
-				    struct perf_env *env,
+				      struct perf_env *env,
-				    FILE *fp)
+				      FILE *fp)
 {
 	__u32 *prog_lens = (__u32 *)(uintptr_t)(info->jited_func_lens);
 	__u64 *prog_addrs = (__u64 *)(uintptr_t)(info->jited_ksyms);
 	if (info->btf_id) {
 		struct btf_node *node;
-		node = perf_env__find_btf(env, info->btf_id);
+		node = __perf_env__find_btf(env, info->btf_id);
 		if (node)
 			btf = btf__new((__u8 *)(node->data),
 				       node->data_size);

tools/perf/util/bpf-event.h+6−6

@@ -33,9 +33,9 @@ struct btf_node { · 32 unmodified lines
33	int machine__process_bpf(struct machine machine, union perf_event event,	33	int machine__process_bpf(struct machine machine, union perf_event event,
34	struct perf_sample *sample);	34	struct perf_sample *sample);
35	int evlist__add_bpf_sb_event(struct evlist evlist, struct perf_env env);	35	int evlist__add_bpf_sb_event(struct evlist evlist, struct perf_env env);
36	void bpf_event__print_bpf_prog_info(struct bpf_prog_info *info,	36	void __bpf_event__print_bpf_prog_info(struct bpf_prog_info *info,
37	struct perf_env *env,	37	struct perf_env *env,
38	FILE *fp);	38	FILE *fp);
39	#else	39	#else
40	static inline int machine__process_bpf(struct machine *machine __maybe_unused,	40	static inline int machine__process_bpf(struct machine *machine __maybe_unused,
41	union perf_event *event __maybe_unused,	41	union perf_event *event __maybe_unused,
@@ -50,9 +50,9 @@ static inline int evlist__add_bpf_sb_event(struct evlist *evlist __maybe_unused, · 8 unmodified lines
50	return 0;	50	return 0;
51	}	51	}
52		52
53	static inline void bpf_event__print_bpf_prog_info(struct bpf_prog_info *info __maybe_unused,	53	static inline void __bpf_event__print_bpf_prog_info(struct bpf_prog_info *info __maybe_unused,
54	struct perf_env *env __maybe_unused,	54	struct perf_env *env __maybe_unused,
55	FILE *fp __maybe_unused)	55	FILE *fp __maybe_unused)
56	{	56	{
57		57
58	}	58	}

tools/perf/util/bpf_counter.c+1−1

@@ -455,7 +455,7 @@ static int bperf__load(struct evsel evsel, struct target target) · 454 unmodified lines
455	return -1;	455	return -1;
456		456
457	if (!all_cpu_map) {	457	if (!all_cpu_map) {
458	all_cpu_map = perf_cpu_map__new(NULL);	458	all_cpu_map = perf_cpu_map__new_online_cpus();
459	if (!all_cpu_map)	459	if (!all_cpu_map)
460	return -1;	460	return -1;
461	}	461	}

tools/perf/util/bpf_lock_contention.c+1−1

@@ -318,7 +318,7 @@ int lock_contention_read(struct lock_contention *con) · 317 unmodified lines
318	}	318	}
319		319
320	/* make sure it loads the kernel map */	320	/* make sure it loads the kernel map */
321	map__load(maps__first(machine->kmaps)->map);	321	maps__load_first(machine->kmaps);
322		322
323	prev_key = NULL;	323	prev_key = NULL;
324	while (!bpf_map_get_next_key(fd, prev_key, &key)) {	324	while (!bpf_map_get_next_key(fd, prev_key, &key)) {

tools/perf/util/compress.h+5−2

 #define PERF_COMPRESS_H
 #include <stdbool.h>
+#include <stddef.h>
+#include <sys/types.h>
 #ifdef HAVE_ZSTD_SUPPORT
 #include <zstd.h>
 #endif
 #ifdef HAVE_ZSTD_SUPPORT
 	ZSTD_CStream	*cstream;
 	ZSTD_DStream	*dstream;
+	int comp_level;
 #endif
 };
 int zstd_init(struct zstd_data *data, int level);
 int zstd_fini(struct zstd_data *data);
-size_t zstd_compress_stream_to_records(struct zstd_data *data, void *dst, size_t dst_size,
+ssize_t zstd_compress_stream_to_records(struct zstd_data *data, void *dst, size_t dst_size,
 				       void *src, size_t src_size, size_t max_record_size,
 				       size_t process_header(void *record, size_t increment));
 }
 static inline
-size_t zstd_compress_stream_to_records(struct zstd_data *data __maybe_unused,
+ssize_t zstd_compress_stream_to_records(struct zstd_data *data __maybe_unused,
 				       void *dst __maybe_unused, size_t dst_size __maybe_unused,
 				       void *src __maybe_unused, size_t src_size __maybe_unused,
 				       size_t max_record_size __maybe_unused,

tools/perf/util/cpumap.c+1−1

@@ -672,7 +672,7 @@ struct perf_cpu_map cpu_map__online(void) / thread unsafe */ · 671 unmodified lines
672	static struct perf_cpu_map *online;	672	static struct perf_cpu_map *online;
673		673
674	if (!online)	674	if (!online)
675	online = perf_cpu_map__new(NULL); /* from /sys/devices/system/cpu/online */	675	online = perf_cpu_map__new_online_cpus(); /* from /sys/devices/system/cpu/online */
676		676
677	return online;	677	return online;
678	}	678	}

tools/perf/util/cputopo.c+1−1

@@ -267,7 +267,7 @@ struct cpu_topology *cpu_topology__new(void) · 266 unmodified lines
267	ncpus = cpu__max_present_cpu().cpu;	267	ncpus = cpu__max_present_cpu().cpu;
268		268
269	/* build online CPU map */	269	/* build online CPU map */
270	map = perf_cpu_map__new(NULL);	270	map = perf_cpu_map__new_online_cpus();
271	if (map == NULL) {	271	if (map == NULL) {
272	pr_debug("failed to get system cpumap\n");	272	pr_debug("failed to get system cpumap\n");
273	return NULL;	273	return NULL;

tools/perf/util/cs-etm.c+18−3

@@ -3346,12 +3346,27 @@ int cs_etm__process_auxtrace_info_full(union perf_event *event, · 3345 unmodified lines
3346	etm->metadata = metadata;	3346	etm->metadata = metadata;
3347	etm->auxtrace_type = auxtrace_info->type;	3347	etm->auxtrace_type = auxtrace_info->type;
3348		3348
3349	/* Use virtual timestamps if all ETMs report ts_source = 1 */	3349	if (etm->synth_opts.use_timestamp)
3350	etm->has_virtual_ts = cs_etm__has_virtual_ts(metadata, num_cpu);	3350	/*
		3351	* Prior to Armv8.4, Arm CPUs don't support FEAT_TRF feature,
		3352	* therefore the decoder cannot know if the timestamp trace is
		3353	* same with the kernel time.
		3354	*
		3355	* If a user has knowledge for the working platform and can
		3356	* specify itrace option 'T' to tell decoder to forcely use the
		3357	* traced timestamp as the kernel time.
		3358	*/
		3359	etm->has_virtual_ts = true;
		3360	else
		3361	/* Use virtual timestamps if all ETMs report ts_source = 1 */
		3362	etm->has_virtual_ts = cs_etm__has_virtual_ts(metadata, num_cpu);
3351		3363
3352	if (!etm->has_virtual_ts)	3364	if (!etm->has_virtual_ts)
3353	ui__warning("Virtual timestamps are not enabled, or not supported by the traced system.\n"	3365	ui__warning("Virtual timestamps are not enabled, or not supported by the traced system.\n"
3354	"The time field of the samples will not be set accurately.\n\n");	3366	"The time field of the samples will not be set accurately.\n"
		3367	"For Arm CPUs prior to Armv8.4 or without support FEAT_TRF,\n"
		3368	"you can specify the itrace option 'T' for timestamp decoding\n"
		3369	"if the Coresight timestamp on the platform is same with the kernel time.\n\n");
3355		3370
3356	etm->auxtrace.process_event = cs_etm__process_event;	3371	etm->auxtrace.process_event = cs_etm__process_event;
3357	etm->auxtrace.process_auxtrace_event = cs_etm__process_auxtrace_event;	3372	etm->auxtrace.process_auxtrace_event = cs_etm__process_auxtrace_event;

tools/perf/util/db-export.c+2−2

@@ -253,8 +253,8 @@ static struct call_path call_path_from_sample(struct db_export dbe, · 252 unmodified lines
253	*/	253	*/
254	addr_location__init(&al);	254	addr_location__init(&al);
255	al.sym = node->ms.sym;	255	al.sym = node->ms.sym;
256	al.map = node->ms.map;	256	al.map = map__get(node->ms.map);
257	al.maps = thread__maps(thread);	257	al.maps = maps__get(thread__maps(thread));
258	al.addr = node->ip;	258	al.addr = node->ip;
259		259
260	if (al.map && !al.sym)	260	if (al.map && !al.sym)

tools/perf/util/debug.c+15−7

 int debug_ordered_events;
 static int redirect_to_stderr;
 int debug_data_convert;
-static FILE *debug_file;
+static FILE *_debug_file;
 bool debug_display_time;
+FILE *debug_file(void)
+{
+	if (!_debug_file) {
+		pr_warning_once("debug_file not set");
+		debug_set_file(stderr);
+	}
+	return _debug_file;
+}
 void debug_set_file(FILE *file)
 {
-	debug_file = file;
+	_debug_file = file;
 }
 void debug_set_display_time(bool set)
 		if (use_browser >= 1 && !redirect_to_stderr) {
 			ui_helpline__vshow(fmt, args);
 		} else {
-			ret = fprintf_time(debug_file);
+			ret = fprintf_time(debug_file());
-			ret += vfprintf(debug_file, fmt, args);
+			ret += vfprintf(debug_file(), fmt, args);
 		}
 	}
 	nsecs -= secs  * NSEC_PER_SEC;
 	usecs  = nsecs / NSEC_PER_USEC;
-	ret = fprintf(stderr, "[%13" PRIu64 ".%06" PRIu64 "] ",
+	ret = fprintf(debug_file(), "[%13" PRIu64 ".%06" PRIu64 "] ", secs, usecs);
-		      secs, usecs);
+	ret += vfprintf(debug_file(), fmt, args);
-	ret += vfprintf(stderr, fmt, args);
 	return ret;
 }

tools/perf/util/debug.h+1−0

@@ -77,6 +77,7 @@ int eprintf_time(int level, int var, u64 t, const char *fmt, ...) __printf(4, 5) · 76 unmodified lines
77	int veprintf(int level, int var, const char *fmt, va_list args);	77	int veprintf(int level, int var, const char *fmt, va_list args);
78		78
79	int perf_debug_option(const char *str);	79	int perf_debug_option(const char *str);
		80	FILE *debug_file(void);
80	void debug_set_file(FILE *file);	81	void debug_set_file(FILE *file);
81	void debug_set_display_time(bool set);	82	void debug_set_display_time(bool set);
82	void perf_debug_setup(void);	83	void perf_debug_setup(void);

tools/perf/util/debuginfo.c+205−0

@@ -0,0 +1,205 @@
	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* DWARF debug information handling code. Copied from probe-finder.c.
	4	*
	5	* Written by Masami Hiramatsu <mhiramat@redhat.com>
	6	*/
	7
	8	#include <errno.h>
	9	#include <fcntl.h>
	10	#include <stdio.h>
	11	#include <stdlib.h>
	12	#include <string.h>
	13	#include <unistd.h>
	14	#include <linux/zalloc.h>
	15
	16	#include "build-id.h"
	17	#include "dso.h"
	18	#include "debug.h"
	19	#include "debuginfo.h"
	20	#include "symbol.h"
	21
	22	#ifdef HAVE_DEBUGINFOD_SUPPORT
	23	#include <elfutils/debuginfod.h>
	24	#endif
	25
	26	/* Dwarf FL wrappers */
	27	static char debuginfo_path; / Currently dummy */
	28
	29	static const Dwfl_Callbacks offline_callbacks = {
	30	.find_debuginfo = dwfl_standard_find_debuginfo,
	31	.debuginfo_path = &debuginfo_path,
	32
	33	.section_address = dwfl_offline_section_address,
	34
	35	/* We use this table for core files too. */
	36	.find_elf = dwfl_build_id_find_elf,
	37	};
	38
	39	/* Get a Dwarf from offline image */
	40	static int debuginfo__init_offline_dwarf(struct debuginfo *dbg,
	41	const char *path)
	42	{
	43	GElf_Addr dummy;
	44	int fd;
	45
	46	fd = open(path, O_RDONLY);
	47	if (fd < 0)
	48	return fd;
	49
	50	dbg->dwfl = dwfl_begin(&offline_callbacks);
	51	if (!dbg->dwfl)
	52	goto error;
	53
	54	dwfl_report_begin(dbg->dwfl);
	55	dbg->mod = dwfl_report_offline(dbg->dwfl, "", "", fd);
	56	if (!dbg->mod)
	57	goto error;
	58
	59	dbg->dbg = dwfl_module_getdwarf(dbg->mod, &dbg->bias);
	60	if (!dbg->dbg)
	61	goto error;
	62
	63	dwfl_module_build_id(dbg->mod, &dbg->build_id, &dummy);
	64
	65	dwfl_report_end(dbg->dwfl, NULL, NULL);
	66
	67	return 0;
	68	error:
	69	if (dbg->dwfl)
	70	dwfl_end(dbg->dwfl);
	71	else
	72	close(fd);
	73	memset(dbg, 0, sizeof(*dbg));
	74
	75	return -ENOENT;
	76	}
	77
	78	static struct debuginfo __debuginfo__new(const char path)
	79	{
	80	struct debuginfo dbg = zalloc(sizeof(dbg));
	81	if (!dbg)
	82	return NULL;
	83
	84	if (debuginfo__init_offline_dwarf(dbg, path) < 0)
	85	zfree(&dbg);
	86	if (dbg)
	87	pr_debug("Open Debuginfo file: %s\n", path);
	88	return dbg;
	89	}
	90
	91	enum dso_binary_type distro_dwarf_types[] = {
	92	DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
	93	DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
	94	DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
	95	DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
	96	DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO,
	97	DSO_BINARY_TYPE__NOT_FOUND,
	98	};
	99
	100	struct debuginfo debuginfo__new(const char path)
	101	{
	102	enum dso_binary_type *type;
	103	char buf[PATH_MAX], nil = '\0';
	104	struct dso *dso;
	105	struct debuginfo *dinfo = NULL;
	106	struct build_id bid;
	107
	108	/* Try to open distro debuginfo files */
	109	dso = dso__new(path);
	110	if (!dso)
	111	goto out;
	112
	113	/* Set the build id for DSO_BINARY_TYPE__BUILDID_DEBUGINFO */
	114	if (is_regular_file(path) && filename__read_build_id(path, &bid) > 0)
	115	dso__set_build_id(dso, &bid);
	116
	117	for (type = distro_dwarf_types;
	118	!dinfo && *type != DSO_BINARY_TYPE__NOT_FOUND;
	119	type++) {
	120	if (dso__read_binary_type_filename(dso, *type, &nil,
	121	buf, PATH_MAX) < 0)
	122	continue;
	123	dinfo = __debuginfo__new(buf);
	124	}
	125	dso__put(dso);
	126
	127	out:
	128	/* if failed to open all distro debuginfo, open given binary */
	129	return dinfo ? : __debuginfo__new(path);
	130	}
	131
	132	void debuginfo__delete(struct debuginfo *dbg)
	133	{
	134	if (dbg) {
	135	if (dbg->dwfl)
	136	dwfl_end(dbg->dwfl);
	137	free(dbg);
	138	}
	139	}
	140
	141	/* For the kernel module, we need a special code to get a DIE */
	142	int debuginfo__get_text_offset(struct debuginfo dbg, Dwarf_Addr offs,
	143	bool adjust_offset)
	144	{
	145	int n, i;
	146	Elf32_Word shndx;
	147	Elf_Scn *scn;
	148	Elf *elf;
	149	GElf_Shdr mem, *shdr;
	150	const char *p;
	151
	152	elf = dwfl_module_getelf(dbg->mod, &dbg->bias);
	153	if (!elf)
	154	return -EINVAL;
	155
	156	/* Get the number of relocations */
	157	n = dwfl_module_relocations(dbg->mod);
	158	if (n < 0)
	159	return -ENOENT;
	160	/* Search the relocation related .text section */
	161	for (i = 0; i < n; i++) {
	162	p = dwfl_module_relocation_info(dbg->mod, i, &shndx);
	163	if (strcmp(p, ".text") == 0) {
	164	/* OK, get the section header */
	165	scn = elf_getscn(elf, shndx);
	166	if (!scn)
	167	return -ENOENT;
	168	shdr = gelf_getshdr(scn, &mem);
	169	if (!shdr)
	170	return -ENOENT;
	171	*offs = shdr->sh_addr;
	172	if (adjust_offset)
	173	*offs -= shdr->sh_offset;
	174	}
	175	}
	176	return 0;
	177	}
	178
	179	#ifdef HAVE_DEBUGINFOD_SUPPORT
	180	int get_source_from_debuginfod(const char *raw_path,
	181	const char sbuild_id, char *new_path)
	182	{
	183	debuginfod_client *c = debuginfod_begin();
	184	const char *p = raw_path;
	185	int fd;
	186
	187	if (!c)
	188	return -ENOMEM;
	189
	190	fd = debuginfod_find_source(c, (const unsigned char *)sbuild_id,
	191	0, p, new_path);
	192	pr_debug("Search %s from debuginfod -> %d\n", p, fd);
	193	if (fd >= 0)
	194	close(fd);
	195	debuginfod_end(c);
	196	if (fd < 0) {
	197	pr_debug("Failed to find %s in debuginfod (%s)\n",
	198	raw_path, sbuild_id);
	199	return -ENOENT;
	200	}
	201	pr_debug("Got a source %s\n", *new_path);
	202
	203	return 0;
	204	}
	205	#endif /* HAVE_DEBUGINFOD_SUPPORT */

tools/perf/util/debuginfo.h+64−0

@@ -0,0 +1,64 @@
	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
	2	#ifndef _PERF_DEBUGINFO_H
	3	#define _PERF_DEBUGINFO_H
	4
	5	#include <errno.h>
	6	#include <linux/compiler.h>
	7
	8	#ifdef HAVE_DWARF_SUPPORT
	9
	10	#include "dwarf-aux.h"
	11
	12	/* debug information structure */
	13	struct debuginfo {
	14	Dwarf *dbg;
	15	Dwfl_Module *mod;
	16	Dwfl *dwfl;
	17	Dwarf_Addr bias;
	18	const unsigned char *build_id;
	19	};
	20
	21	/* This also tries to open distro debuginfo */
	22	struct debuginfo debuginfo__new(const char path);
	23	void debuginfo__delete(struct debuginfo *dbg);
	24
	25	int debuginfo__get_text_offset(struct debuginfo dbg, Dwarf_Addr offs,
	26	bool adjust_offset);
	27
	28	#else /* HAVE_DWARF_SUPPORT */
	29
	30	/* dummy debug information structure */
	31	struct debuginfo {
	32	};
	33
	34	static inline struct debuginfo debuginfo__new(const char path __maybe_unused)
	35	{
	36	return NULL;
	37	}
	38
	39	static inline void debuginfo__delete(struct debuginfo *dbg __maybe_unused)
	40	{
	41	}
	42
	43	static inline int debuginfo__get_text_offset(struct debuginfo *dbg __maybe_unused,
	44	Dwarf_Addr *offs __maybe_unused,
	45	bool adjust_offset __maybe_unused)
	46	{
	47	return -EINVAL;
	48	}
	49
	50	#endif /* HAVE_DWARF_SUPPORT */
	51
	52	#ifdef HAVE_DEBUGINFOD_SUPPORT
	53	int get_source_from_debuginfod(const char raw_path, const char sbuild_id,
	54	char **new_path);
	55	#else /* HAVE_DEBUGINFOD_SUPPORT */
	56	static inline int get_source_from_debuginfod(const char *raw_path __maybe_unused,
	57	const char *sbuild_id __maybe_unused,
	58	char **new_path __maybe_unused)
	59	{
	60	return -ENOTSUP;
	61	}
	62	#endif /* HAVE_DEBUGINFOD_SUPPORT */
	63
	64	#endif /* _PERF_DEBUGINFO_H */

tools/perf/util/dso.c+4−0

 #include "debug.h"
 #include "string2.h"
 #include "vdso.h"
+#include "annotate-data.h"
 static const char * const debuglink_paths[] = {
 	"%.0s%s",
 		dso->data.cache = RB_ROOT;
 		dso->inlined_nodes = RB_ROOT_CACHED;
 		dso->srclines = RB_ROOT_CACHED;
+		dso->data_types = RB_ROOT;
 		dso->data.fd = -1;
 		dso->data.status = DSO_DATA_STATUS_UNKNOWN;
 		dso->symtab_type = DSO_BINARY_TYPE__NOT_FOUND;
 	symbols__delete(&dso->symbols);
 	dso->symbol_names_len = 0;
 	zfree(&dso->symbol_names);
+	annotated_data_type__tree_delete(&dso->data_types);
 	if (dso->short_name_allocated) {
 		zfree((char **)&dso->short_name);
 		dso->short_name_allocated = false;

tools/perf/util/dso.h+2−0

@@ -154,6 +154,8 @@ struct dso { · 153 unmodified lines
154	size_t symbol_names_len;	154	size_t symbol_names_len;
155	struct rb_root_cached inlined_nodes;	155	struct rb_root_cached inlined_nodes;
156	struct rb_root_cached srclines;	156	struct rb_root_cached srclines;
		157	struct rb_root data_types;
		158
157	struct {	159	struct {
158	u64 addr;	160	u64 addr;
159	struct symbol *symbol;	161	struct symbol *symbol;

tools/perf/util/dwarf-aux.c+232−17

@@ -1051,32 +1051,28 @@ Dwarf_Die die_find_member(Dwarf_Die st_die, const char *name, · 1050 unmodified lines
1051	}	1051	}
1052		1052
1053	/**	1053	/**
1054	* die_get_typename - Get the name of given variable DIE	1054	* die_get_typename_from_type - Get the name of given type DIE
1055	* @vr_die: a variable DIE	1055	* @type_die: a type DIE
1056	* @buf: a strbuf for result type name	1056	* @buf: a strbuf for result type name
1057	*	1057	*
1058	* Get the name of @vr_die and stores it to @buf. Return 0 if succeeded.	1058	* Get the name of @type_die and stores it to @buf. Return 0 if succeeded.
1059	* and Return -ENOENT if failed to find type name.	1059	* and Return -ENOENT if failed to find type name.
1060	* Note that the result will stores typedef name if possible, and stores	1060	* Note that the result will stores typedef name if possible, and stores
1061	* "*(function_type)" if the type is a function pointer.	1061	* "*(function_type)" if the type is a function pointer.
1062	*/	1062	*/
1063	int die_get_typename(Dwarf_Die vr_die, struct strbuf buf)	1063	int die_get_typename_from_type(Dwarf_Die type_die, struct strbuf buf)
1064	{	1064	{
1065	Dwarf_Die type;
1066	int tag, ret;	1065	int tag, ret;
1067	const char *tmp = "";	1066	const char *tmp = "";
1068		1067
1069	if (__die_get_real_type(vr_die, &type) == NULL)	1068	tag = dwarf_tag(type_die);
1070	return -ENOENT;
1071
1072	tag = dwarf_tag(&type);
1073	if (tag == DW_TAG_array_type \|\| tag == DW_TAG_pointer_type)	1069	if (tag == DW_TAG_array_type \|\| tag == DW_TAG_pointer_type)
1074	tmp = "*";	1070	tmp = "*";
1075	else if (tag == DW_TAG_subroutine_type) {	1071	else if (tag == DW_TAG_subroutine_type) {
1076	/* Function pointer */	1072	/* Function pointer */
1077	return strbuf_add(buf, "(function_type)", 15);	1073	return strbuf_add(buf, "(function_type)", 15);
1078	} else {	1074	} else {
1079	const char *name = dwarf_diename(&type);	1075	const char *name = dwarf_diename(type_die);
1080		1076
1081	if (tag == DW_TAG_union_type)	1077	if (tag == DW_TAG_union_type)
1082	tmp = "union ";	1078	tmp = "union ";
@@ -1089,8 +1085,35 @@ int die_get_typename(Dwarf_Die vr_die, struct strbuf buf) · 6 unmodified lines
1089	/* Write a base name */	1085	/* Write a base name */
1090	return strbuf_addf(buf, "%s%s", tmp, name ?: "");	1086	return strbuf_addf(buf, "%s%s", tmp, name ?: "");
1091	}	1087	}
1092	ret = die_get_typename(&type, buf);	1088	ret = die_get_typename(type_die, buf);
1093	return ret ? ret : strbuf_addstr(buf, tmp);	1089	if (ret < 0) {
		1090	/* void pointer has no type attribute */
		1091	if (tag == DW_TAG_pointer_type && ret == -ENOENT)
		1092	return strbuf_addf(buf, "void*");
		1093
		1094	return ret;
		1095	}
		1096	return strbuf_addstr(buf, tmp);
		1097	}
		1098
		1099	/**
		1100	* die_get_typename - Get the name of given variable DIE
		1101	* @vr_die: a variable DIE
		1102	* @buf: a strbuf for result type name
		1103	*
		1104	* Get the name of @vr_die and stores it to @buf. Return 0 if succeeded.
		1105	* and Return -ENOENT if failed to find type name.
		1106	* Note that the result will stores typedef name if possible, and stores
		1107	* "*(function_type)" if the type is a function pointer.
		1108	*/
		1109	int die_get_typename(Dwarf_Die vr_die, struct strbuf buf)
		1110	{
		1111	Dwarf_Die type;
		1112
		1113	if (__die_get_real_type(vr_die, &type) == NULL)
		1114	return -ENOENT;
		1115
		1116	return die_get_typename_from_type(&type, buf);
1094	}	1117	}
1095		1118
1096	/**	1119	/**
@@ -1238,12 +1261,151 @@ int die_get_var_range(Dwarf_Die sp_die, Dwarf_Die vr_die, struct strbuf *buf) · 141 unmodified lines
1238	out:	1261	out:
1239	return ret;	1262	return ret;
1240	}	1263	}
1241	#else	1264
1242	int die_get_var_range(Dwarf_Die *sp_die __maybe_unused,	1265	/* Interval parameters for __die_find_var_reg_cb() */
1243	Dwarf_Die *vr_die __maybe_unused,	1266	struct find_var_data {
1244	struct strbuf *buf __maybe_unused)	1267	/* Target instruction address */
		1268	Dwarf_Addr pc;
		1269	/* Target memory address (for global data) */
		1270	Dwarf_Addr addr;
		1271	/* Target register */
		1272	unsigned reg;
		1273	/* Access offset, set for global data */
		1274	int offset;
		1275	};
		1276
		1277	/* Max number of registers DW_OP_regN supports */
		1278	#define DWARF_OP_DIRECT_REGS 32
		1279
		1280	/* Only checks direct child DIEs in the given scope. */
		1281	static int __die_find_var_reg_cb(Dwarf_Die die_mem, void arg)
		1282	{
		1283	struct find_var_data *data = arg;
		1284	int tag = dwarf_tag(die_mem);
		1285	ptrdiff_t off = 0;
		1286	Dwarf_Attribute attr;
		1287	Dwarf_Addr base, start, end;
		1288	Dwarf_Op *ops;
		1289	size_t nops;
		1290
		1291	if (tag != DW_TAG_variable && tag != DW_TAG_formal_parameter)
		1292	return DIE_FIND_CB_SIBLING;
		1293
		1294	if (dwarf_attr(die_mem, DW_AT_location, &attr) == NULL)
		1295	return DIE_FIND_CB_SIBLING;
		1296
		1297	while ((off = dwarf_getlocations(&attr, off, &base, &start, &end, &ops, &nops)) > 0) {
		1298	/* Assuming the location list is sorted by address */
		1299	if (end < data->pc)
		1300	continue;
		1301	if (start > data->pc)
		1302	break;
		1303
		1304	/* Only match with a simple case */
		1305	if (data->reg < DWARF_OP_DIRECT_REGS) {
		1306	if (ops->atom == (DW_OP_reg0 + data->reg) && nops == 1)
		1307	return DIE_FIND_CB_END;
		1308	} else {
		1309	if (ops->atom == DW_OP_regx && ops->number == data->reg &&
		1310	nops == 1)
		1311	return DIE_FIND_CB_END;
		1312	}
		1313	}
		1314	return DIE_FIND_CB_SIBLING;
		1315	}
		1316
		1317	/**
		1318	* die_find_variable_by_reg - Find a variable saved in a register
		1319	* @sc_die: a scope DIE
		1320	* @pc: the program address to find
		1321	* @reg: the register number to find
		1322	* @die_mem: a buffer to save the resulting DIE
		1323	*
		1324	* Find the variable DIE accessed by the given register.
		1325	*/
		1326	Dwarf_Die die_find_variable_by_reg(Dwarf_Die sc_die, Dwarf_Addr pc, int reg,
		1327	Dwarf_Die *die_mem)
		1328	{
		1329	struct find_var_data data = {
		1330	.pc = pc,
		1331	.reg = reg,
		1332	};
		1333	return die_find_child(sc_die, __die_find_var_reg_cb, &data, die_mem);
		1334	}
		1335
		1336	/* Only checks direct child DIEs in the given scope */
		1337	static int __die_find_var_addr_cb(Dwarf_Die die_mem, void arg)
		1338	{
		1339	struct find_var_data *data = arg;
		1340	int tag = dwarf_tag(die_mem);
		1341	ptrdiff_t off = 0;
		1342	Dwarf_Attribute attr;
		1343	Dwarf_Addr base, start, end;
		1344	Dwarf_Word size;
		1345	Dwarf_Die type_die;
		1346	Dwarf_Op *ops;
		1347	size_t nops;
		1348
		1349	if (tag != DW_TAG_variable)
		1350	return DIE_FIND_CB_SIBLING;
		1351
		1352	if (dwarf_attr(die_mem, DW_AT_location, &attr) == NULL)
		1353	return DIE_FIND_CB_SIBLING;
		1354
		1355	while ((off = dwarf_getlocations(&attr, off, &base, &start, &end, &ops, &nops)) > 0) {
		1356	if (ops->atom != DW_OP_addr)
		1357	continue;
		1358
		1359	if (data->addr < ops->number)
		1360	continue;
		1361
		1362	if (data->addr == ops->number) {
		1363	/* Update offset relative to the start of the variable */
		1364	data->offset = 0;
		1365	return DIE_FIND_CB_END;
		1366	}
		1367
		1368	if (die_get_real_type(die_mem, &type_die) == NULL)
		1369	continue;
		1370
		1371	if (dwarf_aggregate_size(&type_die, &size) < 0)
		1372	continue;
		1373
		1374	if (data->addr >= ops->number + size)
		1375	continue;
		1376
		1377	/* Update offset relative to the start of the variable */
		1378	data->offset = data->addr - ops->number;
		1379	return DIE_FIND_CB_END;
		1380	}
		1381	return DIE_FIND_CB_SIBLING;
		1382	}
		1383
		1384	/**
		1385	* die_find_variable_by_addr - Find variable located at given address
		1386	* @sc_die: a scope DIE
		1387	* @pc: the program address to find
		1388	* @addr: the data address to find
		1389	* @die_mem: a buffer to save the resulting DIE
		1390	* @offset: the offset in the resulting type
		1391	*
		1392	* Find the variable DIE located at the given address (in PC-relative mode).
		1393	* This is usually for global variables.
		1394	*/
		1395	Dwarf_Die die_find_variable_by_addr(Dwarf_Die sc_die, Dwarf_Addr pc,
		1396	Dwarf_Addr addr, Dwarf_Die *die_mem,
		1397	int *offset)
1245	{	1398	{
1246	return -ENOTSUP;	1399	struct find_var_data data = {
		1400	.pc = pc,
		1401	.addr = addr,
		1402	};
		1403	Dwarf_Die *result;
		1404
		1405	result = die_find_child(sc_die, __die_find_var_addr_cb, &data, die_mem);
		1406	if (result)
		1407	*offset = data.offset;
		1408	return result;
1247	}	1409	}
1248	#endif	1410	#endif
1249		1411
@@ -1425,3 +1587,56 @@ void die_skip_prologue(Dwarf_Die sp_die, Dwarf_Die cu_die, · 175 unmodified lines
1425		1587
1426	*entrypc = postprologue_addr;	1588	*entrypc = postprologue_addr;
1427	}	1589	}
		1590
		1591	/* Internal parameters for __die_find_scope_cb() */
		1592	struct find_scope_data {
		1593	/* Target instruction address */
		1594	Dwarf_Addr pc;
		1595	/* Number of scopes found [output] */
		1596	int nr;
		1597	/* Array of scopes found, 0 for the outermost one. [output] */
		1598	Dwarf_Die *scopes;
		1599	};
		1600
		1601	static int __die_find_scope_cb(Dwarf_Die die_mem, void arg)
		1602	{
		1603	struct find_scope_data *data = arg;
		1604
		1605	if (dwarf_haspc(die_mem, data->pc)) {
		1606	Dwarf_Die *tmp;
		1607
		1608	tmp = realloc(data->scopes, (data->nr + 1) * sizeof(*tmp));
		1609	if (tmp == NULL)
		1610	return DIE_FIND_CB_END;
		1611
		1612	memcpy(tmp + data->nr, die_mem, sizeof(*die_mem));
		1613	data->scopes = tmp;
		1614	data->nr++;
		1615	return DIE_FIND_CB_CHILD;
		1616	}
		1617	return DIE_FIND_CB_SIBLING;
		1618	}
		1619
		1620	/**
		1621	* die_get_scopes - Return a list of scopes including the address
		1622	* @cu_die: a compile unit DIE
		1623	* @pc: the address to find
		1624	* @scopes: the array of DIEs for scopes (result)
		1625	*
		1626	* This function does the same as the dwarf_getscopes() but doesn't follow
		1627	* the origins of inlined functions. It returns the number of scopes saved
		1628	* in the @scopes argument. The outer scope will be saved first (index 0) and
		1629	* the last one is the innermost scope at the @pc.
		1630	*/
		1631	int die_get_scopes(Dwarf_Die cu_die, Dwarf_Addr pc, Dwarf_Die *scopes)
		1632	{
		1633	struct find_scope_data data = {
		1634	.pc = pc,
		1635	};
		1636	Dwarf_Die die_mem;
		1637
		1638	die_find_child(cu_die, __die_find_scope_cb, &data, &die_mem);
		1639
		1640	*scopes = data.scopes;
		1641	return data.nr;
		1642	}

tools/perf/util/dwarf-aux.h+49−2

@@ -116,12 +116,14 @@ Dwarf_Die die_find_variable_at(Dwarf_Die sp_die, const char *name, · 115 unmodified lines
116	Dwarf_Die die_find_member(Dwarf_Die st_die, const char *name,	116	Dwarf_Die die_find_member(Dwarf_Die st_die, const char *name,
117	Dwarf_Die *die_mem);	117	Dwarf_Die *die_mem);
118		118
		119	/* Get the name of given type DIE */
		120	int die_get_typename_from_type(Dwarf_Die type_die, struct strbuf buf);
		121
119	/* Get the name of given variable DIE */	122	/* Get the name of given variable DIE */
120	int die_get_typename(Dwarf_Die vr_die, struct strbuf buf);	123	int die_get_typename(Dwarf_Die vr_die, struct strbuf buf);
121		124
122	/* Get the name and type of given variable DIE, stored as "type\tname" */	125	/* Get the name and type of given variable DIE, stored as "type\tname" */
123	int die_get_varname(Dwarf_Die vr_die, struct strbuf buf);	126	int die_get_varname(Dwarf_Die vr_die, struct strbuf buf);
124	int die_get_var_range(Dwarf_Die sp_die, Dwarf_Die vr_die, struct strbuf *buf);
125		127
126	/* Check if target program is compiled with optimization */	128	/* Check if target program is compiled with optimization */
127	bool die_is_optimized_target(Dwarf_Die *cu_die);	129	bool die_is_optimized_target(Dwarf_Die *cu_die);
@@ -130,4 +132,49 @@ bool die_is_optimized_target(Dwarf_Die *cu_die); · 2 unmodified lines
130	void die_skip_prologue(Dwarf_Die sp_die, Dwarf_Die cu_die,	132	void die_skip_prologue(Dwarf_Die sp_die, Dwarf_Die cu_die,
131	Dwarf_Addr *entrypc);	133	Dwarf_Addr *entrypc);
132		134
133	#endif	135	/* Get the list of including scopes */
		136	int die_get_scopes(Dwarf_Die cu_die, Dwarf_Addr pc, Dwarf_Die *scopes);
		137
		138	#ifdef HAVE_DWARF_GETLOCATIONS_SUPPORT
		139
		140	/* Get byte offset range of given variable DIE */
		141	int die_get_var_range(Dwarf_Die sp_die, Dwarf_Die vr_die, struct strbuf *buf);
		142
		143	/* Find a variable saved in the 'reg' at given address */
		144	Dwarf_Die die_find_variable_by_reg(Dwarf_Die sc_die, Dwarf_Addr pc, int reg,
		145	Dwarf_Die *die_mem);
		146
		147	/* Find a (global) variable located in the 'addr' */
		148	Dwarf_Die die_find_variable_by_addr(Dwarf_Die sc_die, Dwarf_Addr pc,
		149	Dwarf_Addr addr, Dwarf_Die *die_mem,
		150	int *offset);
		151
		152	#else /* HAVE_DWARF_GETLOCATIONS_SUPPORT */
		153
		154	static inline int die_get_var_range(Dwarf_Die *sp_die __maybe_unused,
		155	Dwarf_Die *vr_die __maybe_unused,
		156	struct strbuf *buf __maybe_unused)
		157	{
		158	return -ENOTSUP;
		159	}
		160
		161	static inline Dwarf_Die die_find_variable_by_reg(Dwarf_Die sc_die __maybe_unused,
		162	Dwarf_Addr pc __maybe_unused,
		163	int reg __maybe_unused,
		164	Dwarf_Die *die_mem __maybe_unused)
		165	{
		166	return NULL;
		167	}
		168
		169	static inline Dwarf_Die die_find_variable_by_addr(Dwarf_Die sc_die __maybe_unused,
		170	Dwarf_Addr pc __maybe_unused,
		171	Dwarf_Addr addr __maybe_unused,
		172	Dwarf_Die *die_mem __maybe_unused,
		173	int *offset __maybe_unused)
		174	{
		175	return NULL;
		176	}
		177
		178	#endif /* HAVE_DWARF_GETLOCATIONS_SUPPORT */
		179
		180	#endif /* _DWARF_AUX_H */

tools/perf/util/dwarf-regs.c+34−0

@@ -5,9 +5,12 @@ · 4 unmodified lines
5	* Written by: Masami Hiramatsu <mhiramat@kernel.org>	5	* Written by: Masami Hiramatsu <mhiramat@kernel.org>
6	*/	6	*/
7		7
		8	#include <stdlib.h>
		9	#include <string.h>
8	#include <debug.h>	10	#include <debug.h>
9	#include <dwarf-regs.h>	11	#include <dwarf-regs.h>
10	#include <elf.h>	12	#include <elf.h>
		13	#include <errno.h>
11	#include <linux/kernel.h>	14	#include <linux/kernel.h>
12		15
13	#ifndef EM_AARCH64	16	#ifndef EM_AARCH64
@@ -68,3 +71,34 @@ const char *get_dwarf_regstr(unsigned int n, unsigned int machine) · 54 unmodified lines
68	}	71	}
69	return NULL;	72	return NULL;
70	}	73	}
		74
		75	__weak int get_arch_regnum(const char *name __maybe_unused)
		76	{
		77	return -ENOTSUP;
		78	}
		79
		80	/* Return DWARF register number from architecture register name */
		81	int get_dwarf_regnum(const char *name, unsigned int machine)
		82	{
		83	char *regname = strdup(name);
		84	int reg = -1;
		85	char *p;
		86
		87	if (regname == NULL)
		88	return -EINVAL;
		89
		90	/* For convenience, remove trailing characters */
		91	p = strpbrk(regname, " ,)");
		92	if (p)
		93	*p = '\0';
		94
		95	switch (machine) {
		96	case EM_NONE: /* Generic arch - use host arch */
		97	reg = get_arch_regnum(regname);
		98	break;
		99	default:
		100	pr_err("ELF MACHINE %x is not supported.\n", machine);
		101	}
		102	free(regname);
		103	return reg;
		104	}

tools/perf/util/env.c+64−18

 #include "debug.h"
 #include "env.h"
 #include "util/header.h"
+#include "linux/compiler.h"
 #include <linux/ctype.h>
 #include <linux/zalloc.h>
 #include "cgroup.h"
 #include <string.h>
 #include "pmus.h"
 #include "strbuf.h"
+#include "trace/beauty/beauty.h"
 struct perf_env perf_env;
 void perf_env__insert_bpf_prog_info(struct perf_env *env,
 				    struct bpf_prog_info_node *info_node)
+{
+	down_write(&env->bpf_progs.lock);
+	__perf_env__insert_bpf_prog_info(env, info_node);
+	up_write(&env->bpf_progs.lock);
+}
+void __perf_env__insert_bpf_prog_info(struct perf_env *env, struct bpf_prog_info_node *info_node)
 {
 	__u32 prog_id = info_node->info_linear->info.id;
 	struct bpf_prog_info_node *node;
 	struct rb_node *parent = NULL;
 	struct rb_node **p;
-	down_write(&env->bpf_progs.lock);
 	p = &env->bpf_progs.infos.rb_node;
 	while (*p != NULL) {
 			p = &(*p)->rb_right;
 		} else {
 			pr_debug("duplicated bpf prog info %u\n", prog_id);
-			goto out;
+			return;
 		}
 	}
 	rb_link_node(&info_node->rb_node, parent, p);
 	rb_insert_color(&info_node->rb_node, &env->bpf_progs.infos);
 	env->bpf_progs.infos_cnt++;
-out:
-	up_write(&env->bpf_progs.lock);
 }
 struct bpf_prog_info_node *perf_env__find_bpf_prog_info(struct perf_env *env,
 }
 bool perf_env__insert_btf(struct perf_env *env, struct btf_node *btf_node)
+{
+	bool ret;
+	down_write(&env->bpf_progs.lock);
+	ret = __perf_env__insert_btf(env, btf_node);
+	up_write(&env->bpf_progs.lock);
+	return ret;
+}
+bool __perf_env__insert_btf(struct perf_env *env, struct btf_node *btf_node)
 {
 	struct rb_node *parent = NULL;
 	__u32 btf_id = btf_node->id;
 	struct btf_node *node;
 	struct rb_node **p;
-	bool ret = true;
-	down_write(&env->bpf_progs.lock);
 	p = &env->bpf_progs.btfs.rb_node;
 	while (*p != NULL) {
 			p = &(*p)->rb_right;
 		} else {
 			pr_debug("duplicated btf %u\n", btf_id);
-			ret = false;
+			return false;
-			goto out;
 		}
 	}
 	rb_link_node(&btf_node->rb_node, parent, p);
 	rb_insert_color(&btf_node->rb_node, &env->bpf_progs.btfs);
 	env->bpf_progs.btfs_cnt++;
-out:
+	return true;
-	up_write(&env->bpf_progs.lock);
-	return ret;
 }
 struct btf_node *perf_env__find_btf(struct perf_env *env, __u32 btf_id)
+{
+	struct btf_node *res;
+	down_read(&env->bpf_progs.lock);
+	res = __perf_env__find_btf(env, btf_id);
+	up_read(&env->bpf_progs.lock);
+	return res;
+}
+struct btf_node *__perf_env__find_btf(struct perf_env *env, __u32 btf_id)
 {
 	struct btf_node *node = NULL;
 	struct rb_node *n;
-	down_read(&env->bpf_progs.lock);
 	n = env->bpf_progs.btfs.rb_node;
 	while (n) {
 		else if (btf_id > node->id)
 			n = n->rb_right;
 		else
-			goto out;
+			return node;
 	}
-	node = NULL;
+	return NULL;
-out:
-	up_read(&env->bpf_progs.lock);
-	return node;
 }
 /* purge data in bpf_progs.infos tree */
 	return normalize_arch(arch_name);
 }
+const char *perf_env__arch_strerrno(struct perf_env *env __maybe_unused, int err __maybe_unused)
+{
+#if defined(HAVE_SYSCALL_TABLE_SUPPORT) && defined(HAVE_LIBTRACEEVENT)
+	if (env->arch_strerrno == NULL)
+		env->arch_strerrno = arch_syscalls__strerrno_function(perf_env__arch(env));
+	return env->arch_strerrno ? env->arch_strerrno(err) : "no arch specific strerrno function";
+#else
+	return "!(HAVE_SYSCALL_TABLE_SUPPORT && HAVE_LIBTRACEEVENT)";
+#endif
+}
 const char *perf_env__cpuid(struct perf_env *env)
 {
 	int status;
 	return cpu.cpu >= 0 && cpu.cpu < env->nr_numa_map ? env->numa_map[cpu.cpu] : -1;
 }
+bool perf_env__has_pmu_mapping(struct perf_env *env, const char *pmu_name)
+{
+	char *pmu_mapping = env->pmu_mappings, *colon;
+	for (int i = 0; i < env->nr_pmu_mappings; ++i) {
+		if (strtoul(pmu_mapping, &colon, 0) == ULONG_MAX || *colon != ':')
+			goto out_error;
+		pmu_mapping = colon + 1;
+		if (strcmp(pmu_mapping, pmu_name) == 0)
+			return true;
+		pmu_mapping += strlen(pmu_mapping) + 1;
+	}
+out_error:
+	return false;
+}
 char *perf_env__find_pmu_cap(struct perf_env *env, const char *pmu_name,
 			     const char *cap)
 {

tools/perf/util/env.h+17−0

 struct pmu_caps {
 	int		nr_caps;
 	unsigned int    max_branches;
+	unsigned int	br_cntr_nr;
+	unsigned int	br_cntr_width;
 	char            **caps;
 	char            *pmu_name;
 };
+typedef const char *(arch_syscalls__strerrno_t)(int err);
+arch_syscalls__strerrno_t *arch_syscalls__strerrno_function(const char *arch);
 struct perf_env {
 	char			*hostname;
 	char			*os_release;
 	unsigned long long	total_mem;
 	unsigned int		msr_pmu_type;
 	unsigned int		max_branches;
+	unsigned int		br_cntr_nr;
+	unsigned int		br_cntr_width;
 	int			kernel_is_64_bit;
 	int			nr_cmdline;
 		 */
 		bool	enabled;
 	} clock;
+	arch_syscalls__strerrno_t *arch_strerrno;
 };
 enum perf_compress_type {
 void cpu_cache_level__free(struct cpu_cache_level *cache);
 const char *perf_env__arch(struct perf_env *env);
+const char *perf_env__arch_strerrno(struct perf_env *env, int err);
 const char *perf_env__cpuid(struct perf_env *env);
 const char *perf_env__raw_arch(struct perf_env *env);
 int perf_env__nr_cpus_avail(struct perf_env *env);
 void perf_env__init(struct perf_env *env);
+void __perf_env__insert_bpf_prog_info(struct perf_env *env,
+				      struct bpf_prog_info_node *info_node);
 void perf_env__insert_bpf_prog_info(struct perf_env *env,
 				    struct bpf_prog_info_node *info_node);
 struct bpf_prog_info_node *perf_env__find_bpf_prog_info(struct perf_env *env,
 							__u32 prog_id);
 bool perf_env__insert_btf(struct perf_env *env, struct btf_node *btf_node);
+bool __perf_env__insert_btf(struct perf_env *env, struct btf_node *btf_node);
 struct btf_node *perf_env__find_btf(struct perf_env *env, __u32 btf_id);
+struct btf_node *__perf_env__find_btf(struct perf_env *env, __u32 btf_id);
 int perf_env__numa_node(struct perf_env *env, struct perf_cpu cpu);
 char *perf_env__find_pmu_cap(struct perf_env *env, const char *pmu_name,
 			     const char *cap);
+bool perf_env__has_pmu_mapping(struct perf_env *env, const char *pmu_name);
 #endif /* __PERF_ENV_H */

tools/perf/util/event.c+2−2

@@ -617,13 +617,13 @@ struct map thread__find_map(struct thread thread, u8 cpumode, u64 addr, · 616 unmodified lines
617	if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {	617	if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {
618	al->level = 'k';	618	al->level = 'k';
619	maps = machine__kernel_maps(machine);	619	maps = machine__kernel_maps(machine);
620	load_map = true;	620	load_map = !symbol_conf.lazy_load_kernel_maps;
621	} else if (cpumode == PERF_RECORD_MISC_USER && perf_host) {	621	} else if (cpumode == PERF_RECORD_MISC_USER && perf_host) {
622	al->level = '.';	622	al->level = '.';
623	} else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {	623	} else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {
624	al->level = 'g';	624	al->level = 'g';
625	maps = machine__kernel_maps(machine);	625	maps = machine__kernel_maps(machine);
626	load_map = true;	626	load_map = !symbol_conf.lazy_load_kernel_maps;
627	} else if (cpumode == PERF_RECORD_MISC_GUEST_USER && perf_guest) {	627	} else if (cpumode == PERF_RECORD_MISC_GUEST_USER && perf_guest) {
628	al->level = 'u';	628	al->level = 'u';
629	} else {	629	} else {

tools/perf/util/evlist.c+32−2

@@ -1056,7 +1056,7 @@ int evlist__create_maps(struct evlist evlist, struct target target) · 1055 unmodified lines
1056	return -1;	1056	return -1;
1057		1057
1058	if (target__uses_dummy_map(target))	1058	if (target__uses_dummy_map(target))
1059	cpus = perf_cpu_map__dummy_new();	1059	cpus = perf_cpu_map__new_any_cpu();
1060	else	1060	else
1061	cpus = perf_cpu_map__new(target->cpu_list);	1061	cpus = perf_cpu_map__new(target->cpu_list);
1062		1062
@@ -1352,7 +1352,7 @@ static int evlist__create_syswide_maps(struct evlist *evlist) · 289 unmodified lines
1352	* error, and we may not want to do that fallback to a	1352	* error, and we may not want to do that fallback to a
1353	* default cpu identity map :-\	1353	* default cpu identity map :-\
1354	*/	1354	*/
1355	cpus = perf_cpu_map__new(NULL);	1355	cpus = perf_cpu_map__new_online_cpus();
1356	if (!cpus)	1356	if (!cpus)
1357	goto out;	1357	goto out;
1358		1358
@@ -2518,3 +2518,33 @@ void evlist__warn_user_requested_cpus(struct evlist evlist, const char cpu_lis · 1159 unmodified lines
2518	}	2518	}
2519	perf_cpu_map__put(user_requested_cpus);	2519	perf_cpu_map__put(user_requested_cpus);
2520	}	2520	}
		2521
		2522	void evlist__uniquify_name(struct evlist *evlist)
		2523	{
		2524	char new_name, empty_attributes[2] = ":", attributes;
		2525	struct evsel *pos;
		2526
		2527	if (perf_pmus__num_core_pmus() == 1)
		2528	return;
		2529
		2530	evlist__for_each_entry(evlist, pos) {
		2531	if (!evsel__is_hybrid(pos))
		2532	continue;
		2533
		2534	if (strchr(pos->name, '/'))
		2535	continue;
		2536
		2537	attributes = strchr(pos->name, ':');
		2538	if (attributes)
		2539	*attributes = '\0';
		2540	else
		2541	attributes = empty_attributes;
		2542
		2543	if (asprintf(&new_name, "%s/%s/%s", pos->pmu_name, pos->name, attributes + 1)) {
		2544	free(pos->name);
		2545	pos->name = new_name;
		2546	} else {
		2547	*attributes = ':';
		2548	}
		2549	}
		2550	}

tools/perf/util/evlist.h+1−0

@@ -442,5 +442,6 @@ struct evsel evlist__find_evsel(struct evlist evlist, int idx); · 441 unmodified lines
442	int evlist__scnprintf_evsels(struct evlist evlist, size_t size, char bf);	442	int evlist__scnprintf_evsels(struct evlist evlist, size_t size, char bf);
443	void evlist__check_mem_load_aux(struct evlist *evlist);	443	void evlist__check_mem_load_aux(struct evlist *evlist);
444	void evlist__warn_user_requested_cpus(struct evlist evlist, const char cpu_list);	444	void evlist__warn_user_requested_cpus(struct evlist evlist, const char cpu_list);
		445	void evlist__uniquify_name(struct evlist *evlist);
445		446
446	#endif /* __PERF_EVLIST_H */	447	#endif /* __PERF_EVLIST_H */

tools/perf/util/evsel.c+45−10

 	if (cpus == NULL) {
 		if (empty_cpu_map == NULL) {
-			empty_cpu_map = perf_cpu_map__dummy_new();
+			empty_cpu_map = perf_cpu_map__new_any_cpu();
 			if (empty_cpu_map == NULL)
 				return -ENOMEM;
 		}
 static void evsel__disable_missing_features(struct evsel *evsel)
 {
+	if (perf_missing_features.branch_counters)
+		evsel->core.attr.branch_sample_type &= ~PERF_SAMPLE_BRANCH_COUNTERS;
 	if (perf_missing_features.read_lost)
 		evsel->core.attr.read_format &= ~PERF_FORMAT_LOST;
 	if (perf_missing_features.weight_struct) {
 	 * Must probe features in the order they were added to the
 	 * perf_event_attr interface.
 	 */
-	if (!perf_missing_features.read_lost &&
+	if (!perf_missing_features.branch_counters &&
+	    (evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_COUNTERS)) {
+		perf_missing_features.branch_counters = true;
+		pr_debug2("switching off branch counters support\n");
+		return true;
+	} else if (!perf_missing_features.read_lost &&
 	    (evsel->core.attr.read_format & PERF_FORMAT_LOST)) {
 		perf_missing_features.read_lost = true;
 		pr_debug2("switching off PERF_FORMAT_LOST support\n");
 	return new_val;
 }
+static inline bool evsel__has_branch_counters(const struct evsel *evsel)
+{
+	struct evsel *cur, *leader = evsel__leader(evsel);
+	/* The branch counters feature only supports group */
+	if (!leader || !evsel->evlist)
+		return false;
+	evlist__for_each_entry(evsel->evlist, cur) {
+		if ((leader == evsel__leader(cur)) &&
+		    (cur->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_COUNTERS))
+			return true;
+	}
+	return false;
+}
 int evsel__parse_sample(struct evsel *evsel, union perf_event *event,
 			struct perf_sample *data)
 {
 		OVERFLOW_CHECK(array, sz, max_size);
 		array = (void *)array + sz;
+		if (evsel__has_branch_counters(evsel)) {
+			OVERFLOW_CHECK_u64(array);
+			data->branch_stack_cntr = (u64 *)array;
+			sz = data->branch_stack->nr * sizeof(u64);
+			OVERFLOW_CHECK(array, sz, max_size);
+			array = (void *)array + sz;
+		}
 	}
 	if (type & PERF_SAMPLE_REGS_USER) {
 #endif
-bool evsel__fallback(struct evsel *evsel, int err, char *msg, size_t msgsize)
+bool evsel__fallback(struct evsel *evsel, struct target *target, int err,
+		     char *msg, size_t msgsize)
 {
 	int paranoid;
 	    evsel->core.attr.type   == PERF_TYPE_HARDWARE &&
 	    evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES) {
 		/*
-		 * If it's cycles then fall back to hrtimer based
+		 * If it's cycles then fall back to hrtimer based cpu-clock sw
-		 * cpu-clock-tick sw counter, which is always available even if
+		 * counter, which is always available even if no PMU support.
-		 * no PMU support.
 		 *
 		 * PPC returns ENXIO until 2.6.37 (behavior changed with commit
 		 * b0a873e).
 		 */
-		scnprintf(msg, msgsize, "%s",
-"The cycles event is not supported, trying to fall back to cpu-clock-ticks");
 		evsel->core.attr.type   = PERF_TYPE_SOFTWARE;
-		evsel->core.attr.config = PERF_COUNT_SW_CPU_CLOCK;
+		evsel->core.attr.config = target__has_cpu(target)
+			? PERF_COUNT_SW_CPU_CLOCK
+			: PERF_COUNT_SW_TASK_CLOCK;
+		scnprintf(msg, msgsize,
+			"The cycles event is not supported, trying to fall back to %s",
+			target__has_cpu(target) ? "cpu-clock" : "task-clock");
 		zfree(&evsel->name);
 		return true;

tools/perf/util/evsel.h+3−1

 	bool code_page_size;
 	bool weight_struct;
 	bool read_lost;
+	bool branch_counters;
 };
 extern struct perf_missing_features perf_missing_features;
 	       evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK);
 }
-bool evsel__fallback(struct evsel *evsel, int err, char *msg, size_t msgsize);
+bool evsel__fallback(struct evsel *evsel, struct target *target, int err,
+		     char *msg, size_t msgsize);
 int evsel__open_strerror(struct evsel *evsel, struct target *target,
 			 int err, char *msg, size_t size);

tools/perf/util/genelf.c+3−3

@@ -293,9 +293,9 @@ jit_write_elf(int fd, uint64_t load_addr, const char *sym, · 292 unmodified lines
293	*/	293	*/
294	phdr = elf_newphdr(e, 1);	294	phdr = elf_newphdr(e, 1);
295	phdr[0].p_type = PT_LOAD;	295	phdr[0].p_type = PT_LOAD;
296	phdr[0].p_offset = 0;	296	phdr[0].p_offset = GEN_ELF_TEXT_OFFSET;
297	phdr[0].p_vaddr = 0;	297	phdr[0].p_vaddr = GEN_ELF_TEXT_OFFSET;
298	phdr[0].p_paddr = 0;	298	phdr[0].p_paddr = GEN_ELF_TEXT_OFFSET;
299	phdr[0].p_filesz = csize;	299	phdr[0].p_filesz = csize;
300	phdr[0].p_memsz = csize;	300	phdr[0].p_memsz = csize;
301	phdr[0].p_flags = PF_X \| PF_R;	301	phdr[0].p_flags = PF_X \| PF_R;

tools/perf/util/header.c+33−10

 			nodes = new_nodes;
 			size += 4;
 		}
-		ret = memory_node__read(&nodes[cnt++], idx);
+		ret = memory_node__read(&nodes[cnt], idx);
+		if (!ret)
+			cnt += 1;
 	}
 out:
 	closedir(dir);
 		node = rb_entry(next, struct bpf_prog_info_node, rb_node);
 		next = rb_next(&node->rb_node);
-		bpf_event__print_bpf_prog_info(&node->info_linear->info,
+		__bpf_event__print_bpf_prog_info(&node->info_linear->info,
-					       env, fp);
+						 env, fp);
 	}
 	up_read(&env->bpf_progs.lock);
 		__print_pmu_caps(fp, pmu_caps->nr_caps, pmu_caps->caps,
 				 pmu_caps->pmu_name);
 	}
+	if (strcmp(perf_env__arch(&ff->ph->env), "x86") == 0 &&
+	    perf_env__has_pmu_mapping(&ff->ph->env, "ibs_op")) {
+		char *max_precise = perf_env__find_pmu_cap(&ff->ph->env, "cpu", "max_precise");
+		if (max_precise != NULL && atoi(max_precise) == 0)
+			fprintf(fp, "# AMD systems uses ibs_op// PMU for some precise events, e.g.: cycles:p, see the 'perf list' man page for further details.\n");
+	}
 }
 static void print_pmu_mappings(struct feat_fd *ff, FILE *fp)
 		/* after reading from file, translate offset to address */
 		bpil_offs_to_addr(info_linear);
 		info_node->info_linear = info_linear;
-		perf_env__insert_bpf_prog_info(env, info_node);
+		__perf_env__insert_bpf_prog_info(env, info_node);
 	}
 	up_write(&env->bpf_progs.lock);
 		if (__do_read(ff, node->data, data_size))
 			goto out;
-		perf_env__insert_btf(env, node);
+		__perf_env__insert_btf(env, node);
 		node = NULL;
 	}
 }
 static int __process_pmu_caps(struct feat_fd *ff, int *nr_caps,
-			      char ***caps, unsigned int *max_branches)
+			      char ***caps, unsigned int *max_branches,
+			      unsigned int *br_cntr_nr,
+			      unsigned int *br_cntr_width)
 {
 	char *name, *value, *ptr;
 	u32 nr_pmu_caps, i;
 		if (!strcmp(name, "branches"))
 			*max_branches = atoi(value);
+		if (!strcmp(name, "branch_counter_nr"))
+			*br_cntr_nr = atoi(value);
+		if (!strcmp(name, "branch_counter_width"))
+			*br_cntr_width = atoi(value);
 		free(value);
 		free(name);
 	}
 {
 	int ret = __process_pmu_caps(ff, &ff->ph->env.nr_cpu_pmu_caps,
 				     &ff->ph->env.cpu_pmu_caps,
-				     &ff->ph->env.max_branches);
+				     &ff->ph->env.max_branches,
+				     &ff->ph->env.br_cntr_nr,
+				     &ff->ph->env.br_cntr_width);
 	if (!ret && !ff->ph->env.cpu_pmu_caps)
 		pr_debug("cpu pmu capabilities not available\n");
 	for (i = 0; i < nr_pmu; i++) {
 		ret = __process_pmu_caps(ff, &pmu_caps[i].nr_caps,
 					 &pmu_caps[i].caps,
-					 &pmu_caps[i].max_branches);
+					 &pmu_caps[i].max_branches,
+					 &pmu_caps[i].br_cntr_nr,
+					 &pmu_caps[i].br_cntr_width);
 		if (ret)
 			goto err;
 		ret += fprintf(fp, "... ");
 		map = cpu_map__new_data(&ev->cpus.cpus);
-		if (map)
+		if (map) {
 			ret += cpu_map__fprintf(map, fp);
-		else
+			perf_cpu_map__put(map);
+		} else
 			ret += fprintf(fp, "failed to get cpus\n");
 		break;
 	default:

tools/perf/util/hisi-ptt.c+1−0

@@ -123,6 +123,7 @@ static int hisi_ptt_process_auxtrace_event(struct perf_session *session, · 122 unmodified lines
123	if (dump_trace)	123	if (dump_trace)
124	hisi_ptt_dump_event(ptt, data, size);	124	hisi_ptt_dump_event(ptt, data, size);
125		125
		126	free(data);
126	return 0;	127	return 0;
127	}	128	}
128		129

tools/perf/util/hist.h+11−17

 	HISTC_ADDR_TO,
 	HISTC_ADDR,
 	HISTC_SIMD,
+	HISTC_TYPE,
+	HISTC_TYPE_OFFSET,
+	HISTC_SYMBOL_OFFSET,
 	HISTC_NR_COLS, /* Last entry */
 };
 	int refresh;
 };
-struct annotation_options;
 struct res_sample;
 enum rstype {
 void attr_to_script(char *buf, struct perf_event_attr *attr);
 int map_symbol__tui_annotate(struct map_symbol *ms, struct evsel *evsel,
-			     struct hist_browser_timer *hbt,
+			     struct hist_browser_timer *hbt);
-			     struct annotation_options *annotation_opts);
 int hist_entry__tui_annotate(struct hist_entry *he, struct evsel *evsel,
-			     struct hist_browser_timer *hbt,
+			     struct hist_browser_timer *hbt);
-			     struct annotation_options *annotation_opts);
 int evlist__tui_browse_hists(struct evlist *evlist, const char *help, struct hist_browser_timer *hbt,
-			     float min_pcnt, struct perf_env *env, bool warn_lost_event,
+			     float min_pcnt, struct perf_env *env, bool warn_lost_event);
-			     struct annotation_options *annotation_options);
 int script_browse(const char *script_opt, struct evsel *evsel);
 void res_sample_init(void);
 int block_hists_tui_browse(struct block_hist *bh, struct evsel *evsel,
-			   float min_percent, struct perf_env *env,
+			   float min_percent, struct perf_env *env);
-			   struct annotation_options *annotation_opts);
 #else
 static inline
 int evlist__tui_browse_hists(struct evlist *evlist __maybe_unused,
 			     struct hist_browser_timer *hbt __maybe_unused,
 			     float min_pcnt __maybe_unused,
 			     struct perf_env *env __maybe_unused,
-			     bool warn_lost_event __maybe_unused,
+			     bool warn_lost_event __maybe_unused)
-			     struct annotation_options *annotation_options __maybe_unused)
 {
 	return 0;
 }
 static inline int map_symbol__tui_annotate(struct map_symbol *ms __maybe_unused,
 					   struct evsel *evsel __maybe_unused,
-					   struct hist_browser_timer *hbt __maybe_unused,
+					   struct hist_browser_timer *hbt __maybe_unused)
-					   struct annotation_options *annotation_options __maybe_unused)
 {
 	return 0;
 }
 static inline int hist_entry__tui_annotate(struct hist_entry *he __maybe_unused,
 					   struct evsel *evsel __maybe_unused,
-					   struct hist_browser_timer *hbt __maybe_unused,
+					   struct hist_browser_timer *hbt __maybe_unused)
-					   struct annotation_options *annotation_opts __maybe_unused)
 {
 	return 0;
 }
 static inline int block_hists_tui_browse(struct block_hist *bh __maybe_unused,
 					 struct evsel *evsel __maybe_unused,
 					 float min_percent __maybe_unused,
-					 struct perf_env *env __maybe_unused,
+					 struct perf_env *env __maybe_unused)
-					 struct annotation_options *annotation_opts __maybe_unused)
 {
 	return 0;
 }

tools/perf/util/include/dwarf-regs.h+19−0

@@ -2,6 +2,9 @@ · 1 unmodified line
2	#ifndef _PERF_DWARF_REGS_H_	2	#ifndef _PERF_DWARF_REGS_H_
3	#define _PERF_DWARF_REGS_H_	3	#define _PERF_DWARF_REGS_H_
4		4
		5	#define DWARF_REG_PC 0xd3af9c /* random number */
		6	#define DWARF_REG_FB 0xd3affb /* random number */
		7
5	#ifdef HAVE_DWARF_SUPPORT	8	#ifdef HAVE_DWARF_SUPPORT
6	const char *get_arch_regstr(unsigned int n);	9	const char *get_arch_regstr(unsigned int n);
7	/*	10	/*
@@ -10,6 +13,22 @@ const char *get_arch_regstr(unsigned int n); · 2 unmodified lines
10	* machine: ELF machine signature (EM_*)	13	* machine: ELF machine signature (EM_*)
11	*/	14	*/
12	const char *get_dwarf_regstr(unsigned int n, unsigned int machine);	15	const char *get_dwarf_regstr(unsigned int n, unsigned int machine);
		16
		17	int get_arch_regnum(const char *name);
		18	/*
		19	* get_dwarf_regnum - Returns DWARF regnum from register name
		20	* name: architecture register name
		21	* machine: ELF machine signature (EM_*)
		22	*/
		23	int get_dwarf_regnum(const char *name, unsigned int machine);
		24
		25	#else /* HAVE_DWARF_SUPPORT */
		26
		27	static inline int get_dwarf_regnum(const char *name __maybe_unused,
		28	unsigned int machine __maybe_unused)
		29	{
		30	return -1;
		31	}
13	#endif	32	#endif
14		33
15	#ifdef HAVE_ARCH_REGS_QUERY_REGISTER_OFFSET	34	#ifdef HAVE_ARCH_REGS_QUERY_REGISTER_OFFSET

tools/perf/util/machine.c+41−34

@@ -453,7 +453,7 @@ static struct thread findnew_guest_code(struct machine machine, · 452 unmodified lines
453	* Guest code can be found in hypervisor process at the same address	453	* Guest code can be found in hypervisor process at the same address
454	* so copy host maps.	454	* so copy host maps.
455	*/	455	*/
456	err = maps__clone(thread, thread__maps(host_thread));	456	err = maps__copy_from(thread__maps(thread), thread__maps(host_thread));
457	thread__put(host_thread);	457	thread__put(host_thread);
458	if (err)	458	if (err)
459	goto out_err;	459	goto out_err;
@@ -1285,33 +1285,46 @@ static u64 find_entry_trampoline(struct dso *dso) · 825 unmodified lines
1285	#define X86_64_CPU_ENTRY_AREA_SIZE 0x2c000	1285	#define X86_64_CPU_ENTRY_AREA_SIZE 0x2c000
1286	#define X86_64_ENTRY_TRAMPOLINE 0x6000	1286	#define X86_64_ENTRY_TRAMPOLINE 0x6000
1287		1287
		1288	struct machine__map_x86_64_entry_trampolines_args {
		1289	struct maps *kmaps;
		1290	bool found;
		1291	};
		1292
		1293	static int machine__map_x86_64_entry_trampolines_cb(struct map map, void data)
		1294	{
		1295	struct machine__map_x86_64_entry_trampolines_args *args = data;
		1296	struct map *dest_map;
		1297	struct kmap *kmap = __map__kmap(map);
		1298
		1299	if (!kmap \|\| !is_entry_trampoline(kmap->name))
		1300	return 0;
		1301
		1302	dest_map = maps__find(args->kmaps, map__pgoff(map));
		1303	if (dest_map != map)
		1304	map__set_pgoff(map, map__map_ip(dest_map, map__pgoff(map)));
		1305
		1306	args->found = true;
		1307	return 0;
		1308	}
		1309
1288	/* Map x86_64 PTI entry trampolines */	1310	/* Map x86_64 PTI entry trampolines */
1289	int machine__map_x86_64_entry_trampolines(struct machine *machine,	1311	int machine__map_x86_64_entry_trampolines(struct machine *machine,
1290	struct dso *kernel)	1312	struct dso *kernel)
1291	{	1313	{
1292	struct maps *kmaps = machine__kernel_maps(machine);	1314	struct machine__map_x86_64_entry_trampolines_args args = {
		1315	.kmaps = machine__kernel_maps(machine),
		1316	.found = false,
		1317	};
1293	int nr_cpus_avail, cpu;	1318	int nr_cpus_avail, cpu;
1294	bool found = false;
1295	struct map_rb_node *rb_node;
1296	u64 pgoff;	1319	u64 pgoff;
1297		1320
1298	/*	1321	/*
1299	* In the vmlinux case, pgoff is a virtual address which must now be	1322	* In the vmlinux case, pgoff is a virtual address which must now be
1300	* mapped to a vmlinux offset.	1323	* mapped to a vmlinux offset.
1301	*/	1324	*/
1302	maps__for_each_entry(kmaps, rb_node) {	1325	maps__for_each_map(args.kmaps, machine__map_x86_64_entry_trampolines_cb, &args);
1303	struct map dest_map, map = rb_node->map;
1304	struct kmap *kmap = __map__kmap(map);
1305
1306	if (!kmap \|\| !is_entry_trampoline(kmap->name))
1307	continue;
1308		1326
1309	dest_map = maps__find(kmaps, map__pgoff(map));	1327	if (args.found \|\| machine->trampolines_mapped)
1310	if (dest_map != map)
1311	map__set_pgoff(map, map__map_ip(dest_map, map__pgoff(map)));
1312	found = true;
1313	}
1314	if (found \|\| machine->trampolines_mapped)
1315	return 0;	1328	return 0;
1316		1329
1317	pgoff = find_entry_trampoline(kernel);	1330	pgoff = find_entry_trampoline(kernel);
@@ -1359,8 +1372,7 @@ __machine__create_kernel_maps(struct machine machine, struct dso kernel) · 41 unmodified lines
1359	if (machine->vmlinux_map == NULL)	1372	if (machine->vmlinux_map == NULL)
1360	return -ENOMEM;	1373	return -ENOMEM;
1361		1374
1362	map__set_map_ip(machine->vmlinux_map, identity__map_ip);	1375	map__set_mapping_type(machine->vmlinux_map, MAPPING_TYPE__IDENTITY);
1363	map__set_unmap_ip(machine->vmlinux_map, identity__map_ip);
1364	return maps__insert(machine__kernel_maps(machine), machine->vmlinux_map);	1376	return maps__insert(machine__kernel_maps(machine), machine->vmlinux_map);
1365	}	1377	}
1366		1378
@@ -1750,12 +1762,11 @@ int machine__create_kernel_maps(struct machine *machine) · 383 unmodified lines
1750		1762
1751	if (end == ~0ULL) {	1763	if (end == ~0ULL) {
1752	/* update end address of the kernel map using adjacent module address */	1764	/* update end address of the kernel map using adjacent module address */
1753	struct map_rb_node *rb_node = maps__find_node(machine__kernel_maps(machine),	1765	struct map *next = maps__find_next_entry(machine__kernel_maps(machine),
1754	machine__kernel_map(machine));	1766	machine__kernel_map(machine));
1755	struct map_rb_node *next = map_rb_node__next(rb_node);
1756		1767
1757	if (next)	1768	if (next)
1758	machine__set_kernel_mmap(machine, start, map__start(next->map));	1769	machine__set_kernel_mmap(machine, start, map__start(next));
1759	}	1770	}
1760		1771
1761	out_put:	1772	out_put:
@@ -2157,9 +2168,13 @@ int machine__process_exit_event(struct machine machine, union perf_event event · 395 unmodified lines
2157	if (dump_trace)	2168	if (dump_trace)
2158	perf_event__fprintf_task(event, stdout);	2169	perf_event__fprintf_task(event, stdout);
2159		2170
2160	if (thread != NULL)	2171	if (thread != NULL) {
2161	thread__put(thread);	2172	if (symbol_conf.keep_exited_threads)
2162		2173	thread__set_exited(thread, /exited=/true);
		2174	else
		2175	machine__remove_thread(machine, thread);
		2176	}
		2177	thread__put(thread);
2163	return 0;	2178	return 0;
2164	}	2179	}
2165		2180
@@ -3395,16 +3410,8 @@ int machine__for_each_dso(struct machine machine, machine__dso_t fn, void priv · 1229 unmodified lines
3395	int machine__for_each_kernel_map(struct machine machine, machine__map_t fn, void priv)	3410	int machine__for_each_kernel_map(struct machine machine, machine__map_t fn, void priv)
3396	{	3411	{
3397	struct maps *maps = machine__kernel_maps(machine);	3412	struct maps *maps = machine__kernel_maps(machine);
3398	struct map_rb_node *pos;
3399	int err = 0;
3400		3413
3401	maps__for_each_entry(maps, pos) {	3414	return maps__for_each_map(maps, fn, priv);
3402	err = fn(pos->map, priv);
3403	if (err != 0) {
3404	break;
3405	}
3406	}
3407	return err;
3408	}	3415	}
3409		3416
3410	bool machine__is_lock_function(struct machine *machine, u64 addr)	3417	bool machine__is_lock_function(struct machine *machine, u64 addr)

tools/perf/util/map.c+2−18

 	map__set_pgoff(map, pgoff);
 	map__set_reloc(map, 0);
 	map__set_dso(map, dso__get(dso));
-	map__set_map_ip(map, map__dso_map_ip);
+	map__set_mapping_type(map, MAPPING_TYPE__DSO);
-	map__set_unmap_ip(map, map__dso_unmap_ip);
 	map__set_erange_warned(map, false);
 	refcount_set(map__refcnt(map), 1);
 }
 		map__init(result, start, start + len, pgoff, dso);
 		if (anon || no_dso) {
-			map->map_ip = map->unmap_ip = identity__map_ip;
+			map->mapping_type = MAPPING_TYPE__IDENTITY;
 			/*
 			 * Set memory without DSO as loaded. All map__find_*
 	}
 	return kmap->kmaps;
 }
-u64 map__dso_map_ip(const struct map *map, u64 ip)
-{
-	return ip - map__start(map) + map__pgoff(map);
-}
-u64 map__dso_unmap_ip(const struct map *map, u64 ip)
-{
-	return ip + map__start(map) - map__pgoff(map);
-}
-u64 identity__map_ip(const struct map *map __maybe_unused, u64 ip)
-{
-	return ip;
-}

tools/perf/util/map.h+43−40

 struct maps;
 struct machine;
+enum mapping_type {
+	/* map__map_ip/map__unmap_ip are given as offsets in the DSO. */
+	MAPPING_TYPE__DSO,
+	/* map__map_ip/map__unmap_ip are just the given ip value. */
+	MAPPING_TYPE__IDENTITY,
+};
 DECLARE_RC_STRUCT(map) {
 	u64			start;
 	u64			end;
-	bool			erange_warned:1;
-	bool			priv:1;
-	u32			prot;
 	u64			pgoff;
 	u64			reloc;
-	/* ip -> dso rip */
-	u64			(*map_ip)(const struct map *, u64);
-	/* dso rip -> ip */
-	u64			(*unmap_ip)(const struct map *, u64);
 	struct dso		*dso;
 	refcount_t		refcnt;
+	u32			prot;
 	u32			flags;
+	enum mapping_type	mapping_type:8;
+	bool			erange_warned;
+	bool			priv;
 };
 struct kmap;
 struct kmap *map__kmap(struct map *map);
 struct maps *map__kmaps(struct map *map);
-/* ip -> dso rip */
-u64 map__dso_map_ip(const struct map *map, u64 ip);
-/* dso rip -> ip */
-u64 map__dso_unmap_ip(const struct map *map, u64 ip);
-/* Returns ip */
-u64 identity__map_ip(const struct map *map __maybe_unused, u64 ip);
 static inline struct dso *map__dso(const struct map *map)
 {
 	return RC_CHK_ACCESS(map)->dso;
 }
-static inline u64 map__map_ip(const struct map *map, u64 ip)
-{
-	return RC_CHK_ACCESS(map)->map_ip(map, ip);
-}
-static inline u64 map__unmap_ip(const struct map *map, u64 ip)
-{
-	return RC_CHK_ACCESS(map)->unmap_ip(map, ip);
-}
-static inline void *map__map_ip_ptr(struct map *map)
-{
-	return RC_CHK_ACCESS(map)->map_ip;
-}
-static inline void* map__unmap_ip_ptr(struct map *map)
-{
-	return RC_CHK_ACCESS(map)->unmap_ip;
-}
 static inline u64 map__start(const struct map *map)
 {
 	return RC_CHK_ACCESS(map)->start;
 	return map__end(map) - map__start(map);
 }
+/* ip -> dso rip */
+static inline u64 map__dso_map_ip(const struct map *map, u64 ip)
+{
+	return ip - map__start(map) + map__pgoff(map);
+}
+/* dso rip -> ip */
+static inline u64 map__dso_unmap_ip(const struct map *map, u64 rip)
+{
+	return rip + map__start(map) - map__pgoff(map);
+}
+static inline u64 map__map_ip(const struct map *map, u64 ip_or_rip)
+{
+	if ((RC_CHK_ACCESS(map)->mapping_type) == MAPPING_TYPE__DSO)
+		return map__dso_map_ip(map, ip_or_rip);
+	else
+		return ip_or_rip;
+}
+static inline u64 map__unmap_ip(const struct map *map, u64 ip_or_rip)
+{
+	if ((RC_CHK_ACCESS(map)->mapping_type) == MAPPING_TYPE__DSO)
+		return map__dso_unmap_ip(map, ip_or_rip);
+	else
+		return ip_or_rip;
+}
 /* rip/ip <-> addr suitable for passing to `objdump --start-address=` */
 u64 map__rip_2objdump(struct map *map, u64 rip);
 	RC_CHK_ACCESS(map)->dso = dso;
 }
-static inline void map__set_map_ip(struct map *map, u64 (*map_ip)(const struct map *map, u64 ip))
+static inline void map__set_mapping_type(struct map *map, enum mapping_type type)
 {
-	RC_CHK_ACCESS(map)->map_ip = map_ip;
+	RC_CHK_ACCESS(map)->mapping_type = type;
 }
-static inline void map__set_unmap_ip(struct map *map, u64 (*unmap_ip)(const struct map *map, u64 rip))
+static inline enum mapping_type map__mapping_type(struct map *map)
 {
-	RC_CHK_ACCESS(map)->unmap_ip = unmap_ip;
+	return RC_CHK_ACCESS(map)->mapping_type;
 }
 #endif /* __PERF_MAP_H */

tools/perf/util/maps.c+445−83

@@ -10,6 +10,68 @@ · 9 unmodified lines
10	#include "ui/ui.h"	10	#include "ui/ui.h"
11	#include "unwind.h"	11	#include "unwind.h"
12		12
		13	struct map_rb_node {
		14	struct rb_node rb_node;
		15	struct map *map;
		16	};
		17
		18	#define maps__for_each_entry(maps, map) \
		19	for (map = maps__first(maps); map; map = map_rb_node__next(map))
		20
		21	#define maps__for_each_entry_safe(maps, map, next) \
		22	for (map = maps__first(maps), next = map_rb_node__next(map); map; \
		23	map = next, next = map_rb_node__next(map))
		24
		25	static struct rb_root maps__entries(struct maps maps)
		26	{
		27	return &RC_CHK_ACCESS(maps)->entries;
		28	}
		29
		30	static struct rw_semaphore maps__lock(struct maps maps)
		31	{
		32	return &RC_CHK_ACCESS(maps)->lock;
		33	}
		34
		35	static struct map *maps__maps_by_name(struct maps maps)
		36	{
		37	return RC_CHK_ACCESS(maps)->maps_by_name;
		38	}
		39
		40	static struct map_rb_node maps__first(struct maps maps)
		41	{
		42	struct rb_node *first = rb_first(maps__entries(maps));
		43
		44	if (first)
		45	return rb_entry(first, struct map_rb_node, rb_node);
		46	return NULL;
		47	}
		48
		49	static struct map_rb_node map_rb_node__next(struct map_rb_node node)
		50	{
		51	struct rb_node *next;
		52
		53	if (!node)
		54	return NULL;
		55
		56	next = rb_next(&node->rb_node);
		57
		58	if (!next)
		59	return NULL;
		60
		61	return rb_entry(next, struct map_rb_node, rb_node);
		62	}
		63
		64	static struct map_rb_node maps__find_node(struct maps maps, struct map *map)
		65	{
		66	struct map_rb_node *rb_node;
		67
		68	maps__for_each_entry(maps, rb_node) {
		69	if (rb_node->RC_CHK_ACCESS(map) == RC_CHK_ACCESS(map))
		70	return rb_node;
		71	}
		72	return NULL;
		73	}
		74
13	static void maps__init(struct maps maps, struct machine machine)	75	static void maps__init(struct maps maps, struct machine machine)
14	{	76	{
15	refcount_set(maps__refcnt(maps), 1);	77	refcount_set(maps__refcnt(maps), 1);
@@ -196,6 +258,41 @@ void maps__put(struct maps *maps) · 180 unmodified lines
196	RC_CHK_PUT(maps);	258	RC_CHK_PUT(maps);
197	}	259	}
198		260
		261	int maps__for_each_map(struct maps maps, int (cb)(struct map map, void data), void *data)
		262	{
		263	struct map_rb_node *pos;
		264	int ret = 0;
		265
		266	down_read(maps__lock(maps));
		267	maps__for_each_entry(maps, pos) {
		268	ret = cb(pos->map, data);
		269	if (ret)
		270	break;
		271	}
		272	up_read(maps__lock(maps));
		273	return ret;
		274	}
		275
		276	void maps__remove_maps(struct maps maps, bool (cb)(struct map map, void data), void *data)
		277	{
		278	struct map_rb_node pos, next;
		279	unsigned int start_nr_maps;
		280
		281	down_write(maps__lock(maps));
		282
		283	start_nr_maps = maps__nr_maps(maps);
		284	maps__for_each_entry_safe(maps, pos, next) {
		285	if (cb(pos->map, data)) {
		286	__maps__remove(maps, pos);
		287	--RC_CHK_ACCESS(maps)->nr_maps;
		288	}
		289	}
		290	if (maps__maps_by_name(maps) && start_nr_maps != maps__nr_maps(maps))
		291	__maps__free_maps_by_name(maps);
		292
		293	up_write(maps__lock(maps));
		294	}
		295
199	struct symbol maps__find_symbol(struct maps maps, u64 addr, struct map **mapp)	296	struct symbol maps__find_symbol(struct maps maps, u64 addr, struct map **mapp)
200	{	297	{
201	struct map *map = maps__find(maps, addr);	298	struct map *map = maps__find(maps, addr);
@@ -210,31 +307,40 @@ struct symbol maps__find_symbol(struct maps maps, u64 addr, struct map **mapp) · 8 unmodified lines
210	return NULL;	307	return NULL;
211	}	308	}
212		309
213	struct symbol maps__find_symbol_by_name(struct maps maps, const char name, struct map *mapp)	310	struct maps__find_symbol_by_name_args {
214	{	311	struct map **mapp;
		312	const char *name;
215	struct symbol *sym;	313	struct symbol *sym;
216	struct map_rb_node *pos;	314	};
217		315
218	down_read(maps__lock(maps));	316	static int maps__find_symbol_by_name_cb(struct map map, void data)
		317	{
		318	struct maps__find_symbol_by_name_args *args = data;
219		319
220	maps__for_each_entry(maps, pos) {	320	args->sym = map__find_symbol_by_name(map, args->name);
221	sym = map__find_symbol_by_name(pos->map, name);	321	if (!args->sym)
		322	return 0;
222		323
223	if (sym == NULL)	324	if (!map__contains_symbol(map, args->sym)) {
224	continue;	325	args->sym = NULL;
225	if (!map__contains_symbol(pos->map, sym)) {	326	return 0;
226	sym = NULL;
227	continue;
228	}
229	if (mapp != NULL)
230	*mapp = pos->map;
231	goto out;
232	}	327	}
233		328
234	sym = NULL;	329	if (args->mapp != NULL)
235	out:	330	*args->mapp = map__get(map);
236	up_read(maps__lock(maps));	331	return 1;
237	return sym;	332	}
		333
		334	struct symbol maps__find_symbol_by_name(struct maps maps, const char name, struct map *mapp)
		335	{
		336	struct maps__find_symbol_by_name_args args = {
		337	.mapp = mapp,
		338	.name = name,
		339	.sym = NULL,
		340	};
		341
		342	maps__for_each_map(maps, maps__find_symbol_by_name_cb, &args);
		343	return args.sym;
238	}	344	}
239		345
240	int maps__find_ams(struct maps maps, struct addr_map_symbol ams)	346	int maps__find_ams(struct maps maps, struct addr_map_symbol ams)
@@ -253,41 +359,46 @@ int maps__find_ams(struct maps maps, struct addr_map_symbol ams) · 12 unmodified lines
253	return ams->ms.sym ? 0 : -1;	359	return ams->ms.sym ? 0 : -1;
254	}	360	}
255		361
256	size_t maps__fprintf(struct maps maps, FILE fp)	362	struct maps__fprintf_args {
257	{	363	FILE *fp;
258	size_t printed = 0;	364	size_t printed;
259	struct map_rb_node *pos;	365	};
260		366
261	down_read(maps__lock(maps));	367	static int maps__fprintf_cb(struct map map, void data)
		368	{
		369	struct maps__fprintf_args *args = data;
262		370
263	maps__for_each_entry(maps, pos) {	371	args->printed += fprintf(args->fp, "Map:");
264	printed += fprintf(fp, "Map:");	372	args->printed += map__fprintf(map, args->fp);
265	printed += map__fprintf(pos->map, fp);	373	if (verbose > 2) {
266	if (verbose > 2) {	374	args->printed += dso__fprintf(map__dso(map), args->fp);
267	printed += dso__fprintf(map__dso(pos->map), fp);	375	args->printed += fprintf(args->fp, "--\n");
268	printed += fprintf(fp, "--\n");
269	}
270	}	376	}
		377	return 0;
		378	}
271		379
272	up_read(maps__lock(maps));	380	size_t maps__fprintf(struct maps maps, FILE fp)
		381	{
		382	struct maps__fprintf_args args = {
		383	.fp = fp,
		384	.printed = 0,
		385	};
		386
		387	maps__for_each_map(maps, maps__fprintf_cb, &args);
273		388
274	return printed;	389	return args.printed;
275	}	390	}
276		391
277	int maps__fixup_overlappings(struct maps maps, struct map map, FILE *fp)	392	/*
		393	* Find first map where end > map->start.
		394	* Same as find_vma() in kernel.
		395	*/
		396	static struct rb_node first_ending_after(struct maps maps, const struct map *map)
278	{	397	{
279	struct rb_root *root;	398	struct rb_root *root;
280	struct rb_node next, first;	399	struct rb_node next, first;
281	int err = 0;
282
283	down_write(maps__lock(maps));
284		400
285	root = maps__entries(maps);	401	root = maps__entries(maps);
286
287	/*
288	* Find first map where end > map->start.
289	* Same as find_vma() in kernel.
290	*/
291	next = root->rb_node;	402	next = root->rb_node;
292	first = NULL;	403	first = NULL;
293	while (next) {	404	while (next) {
@@ -301,8 +412,23 @@ int maps__fixup_overlappings(struct maps maps, struct map map, FILE *fp) · 7 unmodified lines
301	} else	412	} else
302	next = next->rb_right;	413	next = next->rb_right;
303	}	414	}
		415	return first;
		416	}
304		417
305	next = first;	418	/*
		419	* Adds new to maps, if new overlaps existing entries then the existing maps are
		420	* adjusted or removed so that new fits without overlapping any entries.
		421	*/
		422	int maps__fixup_overlap_and_insert(struct maps maps, struct map new)
		423	{
		424
		425	struct rb_node *next;
		426	int err = 0;
		427	FILE *fp = debug_file();
		428
		429	down_write(maps__lock(maps));
		430
		431	next = first_ending_after(maps, new);
306	while (next && !err) {	432	while (next && !err) {
307	struct map_rb_node *pos = rb_entry(next, struct map_rb_node, rb_node);	433	struct map_rb_node *pos = rb_entry(next, struct map_rb_node, rb_node);
308	next = rb_next(&pos->rb_node);	434	next = rb_next(&pos->rb_node);
@@ -311,27 +437,27 @@ int maps__fixup_overlappings(struct maps maps, struct map map, FILE *fp) · 2 unmodified lines
311	* Stop if current map starts after map->end.	437	* Stop if current map starts after map->end.
312	* Maps are ordered by start: next will not overlap for sure.	438	* Maps are ordered by start: next will not overlap for sure.
313	*/	439	*/
314	if (map__start(pos->map) >= map__end(map))	440	if (map__start(pos->map) >= map__end(new))
315	break;	441	break;
316		442
317	if (verbose >= 2) {	443	if (verbose >= 2) {
318		444
319	if (use_browser) {	445	if (use_browser) {
320	pr_debug("overlapping maps in %s (disable tui for more info)\n",	446	pr_debug("overlapping maps in %s (disable tui for more info)\n",
321	map__dso(map)->name);	447	map__dso(new)->name);
322	} else {	448	} else {
323	fputs("overlapping maps:\n", fp);	449	pr_debug("overlapping maps:\n");
324	map__fprintf(map, fp);	450	map__fprintf(new, fp);
325	map__fprintf(pos->map, fp);	451	map__fprintf(pos->map, fp);
326	}	452	}
327	}	453	}
328		454
329	rb_erase_init(&pos->rb_node, root);	455	rb_erase_init(&pos->rb_node, maps__entries(maps));
330	/*	456	/*
331	* Now check if we need to create new maps for areas not	457	* Now check if we need to create new maps for areas not
332	* overlapped by the new map:	458	* overlapped by the new map:
333	*/	459	*/
334	if (map__start(map) > map__start(pos->map)) {	460	if (map__start(new) > map__start(pos->map)) {
335	struct map *before = map__clone(pos->map);	461	struct map *before = map__clone(pos->map);
336		462
337	if (before == NULL) {	463	if (before == NULL) {
@@ -339,7 +465,7 @@ int maps__fixup_overlappings(struct maps maps, struct map map, FILE *fp) · 1 unmodified line
339	goto put_map;	465	goto put_map;
340	}	466	}
341		467
342	map__set_end(before, map__start(map));	468	map__set_end(before, map__start(new));
343	err = __maps__insert(maps, before);	469	err = __maps__insert(maps, before);
344	if (err) {	470	if (err) {
345	map__put(before);	471	map__put(before);
@@ -351,7 +477,7 @@ int maps__fixup_overlappings(struct maps maps, struct map map, FILE *fp) · 5 unmodified lines
351	map__put(before);	477	map__put(before);
352	}	478	}
353		479
354	if (map__end(map) < map__end(pos->map)) {	480	if (map__end(new) < map__end(pos->map)) {
355	struct map *after = map__clone(pos->map);	481	struct map *after = map__clone(pos->map);
356		482
357	if (after == NULL) {	483	if (after == NULL) {
@@ -359,10 +485,10 @@ int maps__fixup_overlappings(struct maps maps, struct map map, FILE *fp) · 1 unmodified line
359	goto put_map;	485	goto put_map;
360	}	486	}
361		487
362	map__set_start(after, map__end(map));	488	map__set_start(after, map__end(new));
363	map__add_pgoff(after, map__end(map) - map__start(pos->map));	489	map__add_pgoff(after, map__end(new) - map__start(pos->map));
364	assert(map__map_ip(pos->map, map__end(map)) ==	490	assert(map__map_ip(pos->map, map__end(new)) ==
365	map__map_ip(after, map__end(map)));	491	map__map_ip(after, map__end(new)));
366	err = __maps__insert(maps, after);	492	err = __maps__insert(maps, after);
367	if (err) {	493	if (err) {
368	map__put(after);	494	map__put(after);
@@ -376,16 +502,14 @@ put_map: · 7 unmodified lines
376	map__put(pos->map);	502	map__put(pos->map);
377	free(pos);	503	free(pos);
378	}	504	}
		505	/* Add the map. */
		506	err = __maps__insert(maps, new);
379	up_write(maps__lock(maps));	507	up_write(maps__lock(maps));
380	return err;	508	return err;
381	}	509	}
382		510
383	/*	511	int maps__copy_from(struct maps maps, struct maps parent)
384	* XXX This should not really _copy_ te maps, but refcount them.
385	*/
386	int maps__clone(struct thread thread, struct maps parent)
387	{	512	{
388	struct maps *maps = thread__maps(thread);
389	int err;	513	int err;
390	struct map_rb_node *rb_node;	514	struct map_rb_node *rb_node;
391		515
@@ -416,17 +540,6 @@ out_unlock: · 24 unmodified lines
416	return err;	540	return err;
417	}	541	}
418		542
419	struct map_rb_node maps__find_node(struct maps maps, struct map *map)
420	{
421	struct map_rb_node *rb_node;
422
423	maps__for_each_entry(maps, rb_node) {
424	if (rb_node->RC_CHK_ACCESS(map) == RC_CHK_ACCESS(map))
425	return rb_node;
426	}
427	return NULL;
428	}
429
430	struct map maps__find(struct maps maps, u64 ip)	543	struct map maps__find(struct maps maps, u64 ip)
431	{	544	{
432	struct rb_node *p;	545	struct rb_node *p;
@@ -452,26 +565,275 @@ out: · 19 unmodified lines
452	return m ? m->map : NULL;	565	return m ? m->map : NULL;
453	}	566	}
454		567
455	struct map_rb_node maps__first(struct maps maps)	568	static int map__strcmp(const void a, const void b)
456	{	569	{
457	struct rb_node *first = rb_first(maps__entries(maps));	570	const struct map map_a = (const struct map **)a;
		571	const struct map map_b = (const struct map **)b;
		572	const struct dso *dso_a = map__dso(map_a);
		573	const struct dso *dso_b = map__dso(map_b);
		574	int ret = strcmp(dso_a->short_name, dso_b->short_name);
458		575
459	if (first)	576	if (ret == 0 && map_a != map_b) {
460	return rb_entry(first, struct map_rb_node, rb_node);	577	/*
461	return NULL;	578	* Ensure distinct but name equal maps have an order in part to
		579	* aid reference counting.
		580	*/
		581	ret = (int)map__start(map_a) - (int)map__start(map_b);
		582	if (ret == 0)
		583	ret = (int)((intptr_t)map_a - (intptr_t)map_b);
		584	}
		585
		586	return ret;
462	}	587	}
463		588
464	struct map_rb_node map_rb_node__next(struct map_rb_node node)	589	static int map__strcmp_name(const void name, const void b)
465	{	590	{
466	struct rb_node *next;	591	const struct dso dso = map__dso((const struct map **)b);
467		592
468	if (!node)	593	return strcmp(name, dso->short_name);
469	return NULL;	594	}
470		595
471	next = rb_next(&node->rb_node);	596	void __maps__sort_by_name(struct maps *maps)
		597	{
		598	qsort(maps__maps_by_name(maps), maps__nr_maps(maps), sizeof(struct map *), map__strcmp);
		599	}
472		600
473	if (!next)	601	static int map__groups__sort_by_name_from_rbtree(struct maps *maps)
		602	{
		603	struct map_rb_node *rb_node;
		604	struct map **maps_by_name = realloc(maps__maps_by_name(maps),
		605	maps__nr_maps(maps) * sizeof(struct map *));
		606	int i = 0;
		607
		608	if (maps_by_name == NULL)
		609	return -1;
		610
		611	up_read(maps__lock(maps));
		612	down_write(maps__lock(maps));
		613
		614	RC_CHK_ACCESS(maps)->maps_by_name = maps_by_name;
		615	RC_CHK_ACCESS(maps)->nr_maps_allocated = maps__nr_maps(maps);
		616
		617	maps__for_each_entry(maps, rb_node)
		618	maps_by_name[i++] = map__get(rb_node->map);
		619
		620	__maps__sort_by_name(maps);
		621
		622	up_write(maps__lock(maps));
		623	down_read(maps__lock(maps));
		624
		625	return 0;
		626	}
		627
		628	static struct map __maps__find_by_name(struct maps maps, const char *name)
		629	{
		630	struct map **mapp;
		631
		632	if (maps__maps_by_name(maps) == NULL &&
		633	map__groups__sort_by_name_from_rbtree(maps))
474	return NULL;	634	return NULL;
475		635
476	return rb_entry(next, struct map_rb_node, rb_node);	636	mapp = bsearch(name, maps__maps_by_name(maps), maps__nr_maps(maps),
		637	sizeof(*mapp), map__strcmp_name);
		638	if (mapp)
		639	return *mapp;
		640	return NULL;
		641	}
		642
		643	struct map maps__find_by_name(struct maps maps, const char *name)
		644	{
		645	struct map_rb_node *rb_node;
		646	struct map *map;
		647
		648	down_read(maps__lock(maps));
		649
		650
		651	if (RC_CHK_ACCESS(maps)->last_search_by_name) {
		652	const struct dso *dso = map__dso(RC_CHK_ACCESS(maps)->last_search_by_name);
		653
		654	if (strcmp(dso->short_name, name) == 0) {
		655	map = RC_CHK_ACCESS(maps)->last_search_by_name;
		656	goto out_unlock;
		657	}
		658	}
		659	/*
		660	* If we have maps->maps_by_name, then the name isn't in the rbtree,
		661	* as maps->maps_by_name mirrors the rbtree when lookups by name are
		662	* made.
		663	*/
		664	map = __maps__find_by_name(maps, name);
		665	if (map \|\| maps__maps_by_name(maps) != NULL)
		666	goto out_unlock;
		667
		668	/* Fallback to traversing the rbtree... */
		669	maps__for_each_entry(maps, rb_node) {
		670	struct dso *dso;
		671
		672	map = rb_node->map;
		673	dso = map__dso(map);
		674	if (strcmp(dso->short_name, name) == 0) {
		675	RC_CHK_ACCESS(maps)->last_search_by_name = map;
		676	goto out_unlock;
		677	}
		678	}
		679	map = NULL;
		680
		681	out_unlock:
		682	up_read(maps__lock(maps));
		683	return map;
		684	}
		685
		686	struct map maps__find_next_entry(struct maps maps, struct map *map)
		687	{
		688	struct map_rb_node *rb_node = maps__find_node(maps, map);
		689	struct map_rb_node *next = map_rb_node__next(rb_node);
		690
		691	if (next)
		692	return next->map;
		693
		694	return NULL;
		695	}
		696
		697	void maps__fixup_end(struct maps *maps)
		698	{
		699	struct map_rb_node prev = NULL, curr;
		700
		701	down_write(maps__lock(maps));
		702
		703	maps__for_each_entry(maps, curr) {
		704	if (prev && (!map__end(prev->map) \|\| map__end(prev->map) > map__start(curr->map)))
		705	map__set_end(prev->map, map__start(curr->map));
		706
		707	prev = curr;
		708	}
		709
		710	/*
		711	* We still haven't the actual symbols, so guess the
		712	* last map final address.
		713	*/
		714	if (curr && !map__end(curr->map))
		715	map__set_end(curr->map, ~0ULL);
		716
		717	up_write(maps__lock(maps));
		718	}
		719
		720	/*
		721	* Merges map into maps by splitting the new map within the existing map
		722	* regions.
		723	*/
		724	int maps__merge_in(struct maps kmaps, struct map new_map)
		725	{
		726	struct map_rb_node *rb_node;
		727	struct rb_node *first;
		728	bool overlaps;
		729	LIST_HEAD(merged);
		730	int err = 0;
		731
		732	down_read(maps__lock(kmaps));
		733	first = first_ending_after(kmaps, new_map);
		734	rb_node = first ? rb_entry(first, struct map_rb_node, rb_node) : NULL;
		735	overlaps = rb_node && map__start(rb_node->map) < map__end(new_map);
		736	up_read(maps__lock(kmaps));
		737
		738	if (!overlaps)
		739	return maps__insert(kmaps, new_map);
		740
		741	maps__for_each_entry(kmaps, rb_node) {
		742	struct map *old_map = rb_node->map;
		743
		744	/* no overload with this one */
		745	if (map__end(new_map) < map__start(old_map) \|\|
		746	map__start(new_map) >= map__end(old_map))
		747	continue;
		748
		749	if (map__start(new_map) < map__start(old_map)) {
		750	/*
		751	* \|new......
		752	* \|old....
		753	*/
		754	if (map__end(new_map) < map__end(old_map)) {
		755	/*
		756	* \|new......\| -> \|new..\|
		757	* \|old....\| -> \|old....\|
		758	*/
		759	map__set_end(new_map, map__start(old_map));
		760	} else {
		761	/*
		762	* \|new.............\| -> \|new..\| \|new..\|
		763	* \|old....\| -> \|old....\|
		764	*/
		765	struct map_list_node *m = map_list_node__new();
		766
		767	if (!m) {
		768	err = -ENOMEM;
		769	goto out;
		770	}
		771
		772	m->map = map__clone(new_map);
		773	if (!m->map) {
		774	free(m);
		775	err = -ENOMEM;
		776	goto out;
		777	}
		778
		779	map__set_end(m->map, map__start(old_map));
		780	list_add_tail(&m->node, &merged);
		781	map__add_pgoff(new_map, map__end(old_map) - map__start(new_map));
		782	map__set_start(new_map, map__end(old_map));
		783	}
		784	} else {
		785	/*
		786	* \|new......
		787	* \|old....
		788	*/
		789	if (map__end(new_map) < map__end(old_map)) {
		790	/*
		791	* \|new..\| -> x
		792	* \|old.........\| -> \|old.........\|
		793	*/
		794	map__put(new_map);
		795	new_map = NULL;
		796	break;
		797	} else {
		798	/*
		799	* \|new......\| -> \|new...\|
		800	* \|old....\| -> \|old....\|
		801	*/
		802	map__add_pgoff(new_map, map__end(old_map) - map__start(new_map));
		803	map__set_start(new_map, map__end(old_map));
		804	}
		805	}
		806	}
		807
		808	out:
		809	while (!list_empty(&merged)) {
		810	struct map_list_node *old_node;
		811
		812	old_node = list_entry(merged.next, struct map_list_node, node);
		813	list_del_init(&old_node->node);
		814	if (!err)
		815	err = maps__insert(kmaps, old_node->map);
		816	map__put(old_node->map);
		817	free(old_node);
		818	}
		819
		820	if (new_map) {
		821	if (!err)
		822	err = maps__insert(kmaps, new_map);
		823	map__put(new_map);
		824	}
		825	return err;
		826	}
		827
		828	void maps__load_first(struct maps *maps)
		829	{
		830	struct map_rb_node *first;
		831
		832	down_read(maps__lock(maps));
		833
		834	first = maps__first(maps);
		835	if (first)
		836	map__load(first->map);
		837
		838	up_read(maps__lock(maps));
477	}	839	}

tools/perf/util/maps.h+19−29

 struct machine;
 struct map;
 struct maps;
-struct thread;
-struct map_rb_node {
+struct map_list_node {
-	struct rb_node rb_node;
+	struct list_head node;
 	struct map *map;
 };
-struct map_rb_node *maps__first(struct maps *maps);
+static inline struct map_list_node *map_list_node__new(void)
-struct map_rb_node *map_rb_node__next(struct map_rb_node *node);
+{
-struct map_rb_node *maps__find_node(struct maps *maps, struct map *map);
+	return malloc(sizeof(struct map_list_node));
-struct map *maps__find(struct maps *maps, u64 addr);
+}
-#define maps__for_each_entry(maps, map) \
-	for (map = maps__first(maps); map; map = map_rb_node__next(map))
-#define maps__for_each_entry_safe(maps, map, next) \
+struct map *maps__find(struct maps *maps, u64 addr);
-	for (map = maps__first(maps), next = map_rb_node__next(map); map; \
-	     map = next, next = map_rb_node__next(map))
 DECLARE_RC_STRUCT(maps) {
 	struct rb_root      entries;
 struct maps *maps__new(struct machine *machine);
 bool maps__empty(struct maps *maps);
-int maps__clone(struct thread *thread, struct maps *parent);
+int maps__copy_from(struct maps *maps, struct maps *parent);
 struct maps *maps__get(struct maps *maps);
 void maps__put(struct maps *maps);
 #define maps__zput(map) __maps__zput(&map)
-static inline struct rb_root *maps__entries(struct maps *maps)
+/* Iterate over map calling cb for each entry. */
-{
+int maps__for_each_map(struct maps *maps, int (*cb)(struct map *map, void *data), void *data);
-	return &RC_CHK_ACCESS(maps)->entries;
+/* Iterate over map removing an entry if cb returns true. */
-}
+void maps__remove_maps(struct maps *maps, bool (*cb)(struct map *map, void *data), void *data);
 static inline struct machine *maps__machine(struct maps *maps)
 {
 	return RC_CHK_ACCESS(maps)->machine;
 }
-static inline struct rw_semaphore *maps__lock(struct maps *maps)
-{
-	return &RC_CHK_ACCESS(maps)->lock;
-}
-static inline struct map **maps__maps_by_name(struct maps *maps)
-{
-	return RC_CHK_ACCESS(maps)->maps_by_name;
-}
 static inline unsigned int maps__nr_maps(const struct maps *maps)
 {
 	return RC_CHK_ACCESS(maps)->nr_maps;
 int maps__find_ams(struct maps *maps, struct addr_map_symbol *ams);
-int maps__fixup_overlappings(struct maps *maps, struct map *map, FILE *fp);
+int maps__fixup_overlap_and_insert(struct maps *maps, struct map *new);
 struct map *maps__find_by_name(struct maps *maps, const char *name);
+struct map *maps__find_next_entry(struct maps *maps, struct map *map);
 int maps__merge_in(struct maps *kmaps, struct map *new_map);
 void __maps__sort_by_name(struct maps *maps);
+void maps__fixup_end(struct maps *maps);
+void maps__load_first(struct maps *maps);
 #endif // __PERF_MAPS_H

tools/perf/util/mem-events.c+14−11

 	return -1;
 }
-static bool perf_mem_event__supported(const char *mnt, char *sysfs_name)
+static bool perf_mem_event__supported(const char *mnt, struct perf_pmu *pmu,
+				      struct perf_mem_event *e)
 {
+	char sysfs_name[100];
 	char path[PATH_MAX];
 	struct stat st;
+	scnprintf(sysfs_name, sizeof(sysfs_name), e->sysfs_name, pmu->name);
 	scnprintf(path, PATH_MAX, "%s/devices/%s", mnt, sysfs_name);
 	return !stat(path, &st);
 }
 	for (j = 0; j < PERF_MEM_EVENTS__MAX; j++) {
 		struct perf_mem_event *e = perf_mem_events__ptr(j);
-		char sysfs_name[100];
 		struct perf_pmu *pmu = NULL;
 		/*
 		 * of core PMU.
 		 */
 		while ((pmu = perf_pmus__scan(pmu)) != NULL) {
-			scnprintf(sysfs_name, sizeof(sysfs_name), e->sysfs_name, pmu->name);
+			e->supported |= perf_mem_event__supported(mnt, pmu, e);
-			e->supported |= perf_mem_event__supported(mnt, sysfs_name);
+			if (e->supported) {
+				found = true;
+				break;
+			}
 		}
-		if (e->supported)
-			found = true;
 	}
 	return found ? 0 : -ENOENT;
 						    int idx)
 {
 	const char *mnt = sysfs__mount();
-	char sysfs_name[100];
 	struct perf_pmu *pmu = NULL;
 	while ((pmu = perf_pmus__scan(pmu)) != NULL) {
-		scnprintf(sysfs_name, sizeof(sysfs_name), e->sysfs_name,
+		if (!perf_mem_event__supported(mnt, pmu, e)) {
-			  pmu->name);
-		if (!perf_mem_event__supported(mnt, sysfs_name)) {
 			pr_err("failed: event '%s' not supported\n",
 			       perf_mem_events__name(idx, pmu->name));
 		}
 int perf_mem_events__record_args(const char **rec_argv, int *argv_nr,
 				 char **rec_tmp, int *tmp_nr)
 {
+	const char *mnt = sysfs__mount();
 	int i = *argv_nr, k = 0;
 	struct perf_mem_event *e;
 			while ((pmu = perf_pmus__scan(pmu)) != NULL) {
 				const char *s = perf_mem_events__name(j, pmu->name);
+				if (!perf_mem_event__supported(mnt, pmu, e))
+					continue;
 				rec_argv[i++] = "-e";
 				if (s) {
 					char *copy = strdup(s);

tools/perf/util/mmap.c+2−3

 	map->core.flush = mp->flush;
-	map->comp_level = mp->comp_level;
 #ifndef PYTHON_PERF
-	if (zstd_init(&map->zstd_data, map->comp_level)) {
+	if (zstd_init(&map->zstd_data, mp->comp_level)) {
 		pr_debug2("failed to init mmap compressor, error %d\n", errno);
 		return -1;
 	}
 #endif
-	if (map->comp_level && !perf_mmap__aio_enabled(map)) {
+	if (mp->comp_level && !perf_mmap__aio_enabled(map)) {
 		map->data = mmap(NULL, mmap__mmap_len(map), PROT_READ|PROT_WRITE,
 				 MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
 		if (map->data == MAP_FAILED) {

tools/perf/util/mmap.h+0−1

@@ -39,7 +39,6 @@ struct mmap { · 38 unmodified lines
39	#endif	39	#endif
40	struct mmap_cpu_mask affinity_mask;	40	struct mmap_cpu_mask affinity_mask;
41	void *data;	41	void *data;
42	int comp_level;
43	struct perf_data_file *file;	42	struct perf_data_file *file;
44	struct zstd_data zstd_data;	43	struct zstd_data zstd_data;
45	};	44	};

tools/perf/util/parse-branch-options.c+1−0

@@ -36,6 +36,7 @@ static const struct branch_mode branch_modes[] = { · 35 unmodified lines
36	BRANCH_OPT("stack", PERF_SAMPLE_BRANCH_CALL_STACK),	36	BRANCH_OPT("stack", PERF_SAMPLE_BRANCH_CALL_STACK),
37	BRANCH_OPT("hw_index", PERF_SAMPLE_BRANCH_HW_INDEX),	37	BRANCH_OPT("hw_index", PERF_SAMPLE_BRANCH_HW_INDEX),
38	BRANCH_OPT("priv", PERF_SAMPLE_BRANCH_PRIV_SAVE),	38	BRANCH_OPT("priv", PERF_SAMPLE_BRANCH_PRIV_SAVE),
		39	BRANCH_OPT("counter", PERF_SAMPLE_BRANCH_COUNTERS),
39	BRANCH_END	40	BRANCH_END
40	};	41	};
41		42

tools/perf/util/parse-events.c+38−14

 			   struct parse_events_error *err)
 {
 	if (term->type_term == PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE) {
-		const struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
+		struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
 		if (!pmu) {
 			char *err_str;
 							   err_str, /*help=*/NULL);
 			return -EINVAL;
 		}
-		if (perf_pmu__supports_legacy_cache(pmu)) {
+		/*
+		 * Rewrite the PMU event to a legacy cache one unless the PMU
+		 * doesn't support legacy cache events or the event is present
+		 * within the PMU.
+		 */
+		if (perf_pmu__supports_legacy_cache(pmu) &&
+		    !perf_pmu__have_event(pmu, term->config)) {
 			attr->type = PERF_TYPE_HW_CACHE;
 			return parse_events__decode_legacy_cache(term->config, pmu->type,
 								 &attr->config);
-		} else
+		} else {
 			term->type_term = PARSE_EVENTS__TERM_TYPE_USER;
+			term->no_value = true;
+		}
 	}
 	if (term->type_term == PARSE_EVENTS__TERM_TYPE_HARDWARE) {
-		const struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
+		struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
 		if (!pmu) {
 			char *err_str;
 							   err_str, /*help=*/NULL);
 			return -EINVAL;
 		}
-		attr->type = PERF_TYPE_HARDWARE;
+		/*
-		attr->config = term->val.num;
+		 * If the PMU has a sysfs or json event prefer it over
-		if (perf_pmus__supports_extended_type())
+		 * legacy. ARM requires this.
-			attr->config |= (__u64)pmu->type << PERF_PMU_TYPE_SHIFT;
+		 */
+		if (perf_pmu__have_event(pmu, term->config)) {
+			term->type_term = PARSE_EVENTS__TERM_TYPE_USER;
+			term->no_value = true;
+		} else {
+			attr->type = PERF_TYPE_HARDWARE;
+			attr->config = term->val.num;
+			if (perf_pmus__supports_extended_type())
+				attr->config |= (__u64)pmu->type << PERF_PMU_TYPE_SHIFT;
+		}
 		return 0;
 	}
 	if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER ||
 	YYLTYPE *loc = loc_;
 	LIST_HEAD(config_terms);
 	struct parse_events_terms parsed_terms;
+	bool alias_rewrote_terms = false;
 	pmu = parse_state->fake_pmu ?: perf_pmus__find(name);
 		return evsel ? 0 : -ENOMEM;
 	}
-	if (!parse_state->fake_pmu && perf_pmu__check_alias(pmu, &parsed_terms, &info, err)) {
+	/* Configure attr/terms with a known PMU, this will set hardcoded terms. */
+	if (config_attr(&attr, &parsed_terms, parse_state->error, config_term_pmu)) {
+		parse_events_terms__exit(&parsed_terms);
+		return -EINVAL;
+	}
+	/* Look for event names in the terms and rewrite into format based terms. */
+	if (!parse_state->fake_pmu && perf_pmu__check_alias(pmu, &parsed_terms,
+							    &info, &alias_rewrote_terms, err)) {
 		parse_events_terms__exit(&parsed_terms);
 		return -EINVAL;
 	}
 		strbuf_release(&sb);
 	}
-	/*
+	/* Configure attr/terms again if an alias was expanded. */
-	 * Configure hardcoded terms first, no need to check
+	if (alias_rewrote_terms &&
-	 * return value when called with fail == 0 ;)
+	    config_attr(&attr, &parsed_terms, parse_state->error, config_term_pmu)) {
-	 */
-	if (config_attr(&attr, &parsed_terms, parse_state->error, config_term_pmu)) {
 		parse_events_terms__exit(&parsed_terms);
 		return -EINVAL;
 	}

tools/perf/util/perf_api_probe.c+2−2

@@ -64,7 +64,7 @@ static bool perf_probe_api(setup_probe_fn_t fn) · 63 unmodified lines
64	struct perf_cpu cpu;	64	struct perf_cpu cpu;
65	int ret, i = 0;	65	int ret, i = 0;
66		66
67	cpus = perf_cpu_map__new(NULL);	67	cpus = perf_cpu_map__new_online_cpus();
68	if (!cpus)	68	if (!cpus)
69	return false;	69	return false;
70	cpu = perf_cpu_map__cpu(cpus, 0);	70	cpu = perf_cpu_map__cpu(cpus, 0);
@@ -140,7 +140,7 @@ bool perf_can_record_cpu_wide(void) · 69 unmodified lines
140	struct perf_cpu cpu;	140	struct perf_cpu cpu;
141	int fd;	141	int fd;
142		142
143	cpus = perf_cpu_map__new(NULL);	143	cpus = perf_cpu_map__new_online_cpus();
144	if (!cpus)	144	if (!cpus)
145	return false;	145	return false;
146		146

tools/perf/util/perf_event_attr_fprintf.c+1−0

@@ -55,6 +55,7 @@ static void __p_branch_sample_type(char *buf, size_t size, u64 value) · 54 unmodified lines
55	bit_name(COND), bit_name(CALL_STACK), bit_name(IND_JUMP),	55	bit_name(COND), bit_name(CALL_STACK), bit_name(IND_JUMP),
56	bit_name(CALL), bit_name(NO_FLAGS), bit_name(NO_CYCLES),	56	bit_name(CALL), bit_name(NO_FLAGS), bit_name(NO_CYCLES),
57	bit_name(TYPE_SAVE), bit_name(HW_INDEX), bit_name(PRIV_SAVE),	57	bit_name(TYPE_SAVE), bit_name(HW_INDEX), bit_name(PRIV_SAVE),
		58	bit_name(COUNTERS),
58	{ .name = NULL, }	59	{ .name = NULL, }
59	};	60	};
60	#undef bit_name	61	#undef bit_name

tools/perf/util/pmu.c+6−2

@@ -1494,12 +1494,14 @@ static int check_info_data(struct perf_pmu *pmu, · 1493 unmodified lines
1494	* defined for the alias	1494	* defined for the alias
1495	*/	1495	*/
1496	int perf_pmu__check_alias(struct perf_pmu pmu, struct parse_events_terms head_terms,	1496	int perf_pmu__check_alias(struct perf_pmu pmu, struct parse_events_terms head_terms,
1497	struct perf_pmu_info info, struct parse_events_error err)	1497	struct perf_pmu_info info, bool rewrote_terms,
		1498	struct parse_events_error *err)
1498	{	1499	{
1499	struct parse_events_term term, h;	1500	struct parse_events_term term, h;
1500	struct perf_pmu_alias *alias;	1501	struct perf_pmu_alias *alias;
1501	int ret;	1502	int ret;
1502		1503
		1504	*rewrote_terms = false;
1503	info->per_pkg = false;	1505	info->per_pkg = false;
1504		1506
1505	/*	1507	/*
@@ -1521,7 +1523,7 @@ int perf_pmu__check_alias(struct perf_pmu pmu, struct parse_events_terms head_ · 15 unmodified lines
1521	NULL);	1523	NULL);
1522	return ret;	1524	return ret;
1523	}	1525	}
1524		1526	*rewrote_terms = true;
1525	ret = check_info_data(pmu, alias, info, err, term->err_term);	1527	ret = check_info_data(pmu, alias, info, err, term->err_term);
1526	if (ret)	1528	if (ret)
1527	return ret;	1529	return ret;
@@ -1615,6 +1617,8 @@ bool perf_pmu__auto_merge_stats(const struct perf_pmu *pmu) · 87 unmodified lines
1615		1617
1616	bool perf_pmu__have_event(struct perf_pmu pmu, const char name)	1618	bool perf_pmu__have_event(struct perf_pmu pmu, const char name)
1617	{	1619	{
		1620	if (!name)
		1621	return false;
1618	if (perf_pmu__find_alias(pmu, name, /load=/ true) != NULL)	1622	if (perf_pmu__find_alias(pmu, name, /load=/ true) != NULL)
1619	return true;	1623	return true;
1620	if (pmu->cpu_aliases_added \|\| !pmu->events_table)	1624	if (pmu->cpu_aliases_added \|\| !pmu->events_table)

tools/perf/util/pmu.h+2−1

@@ -201,7 +201,8 @@ int perf_pmu__config_terms(const struct perf_pmu *pmu, · 200 unmodified lines
201	__u64 perf_pmu__format_bits(struct perf_pmu pmu, const char name);	201	__u64 perf_pmu__format_bits(struct perf_pmu pmu, const char name);
202	int perf_pmu__format_type(struct perf_pmu pmu, const char name);	202	int perf_pmu__format_type(struct perf_pmu pmu, const char name);
203	int perf_pmu__check_alias(struct perf_pmu pmu, struct parse_events_terms head_terms,	203	int perf_pmu__check_alias(struct perf_pmu pmu, struct parse_events_terms head_terms,
204	struct perf_pmu_info info, struct parse_events_error err);	204	struct perf_pmu_info info, bool rewrote_terms,
		205	struct parse_events_error *err);
205	int perf_pmu__find_event(struct perf_pmu pmu, const char event, void *state, pmu_event_callback cb);	206	int perf_pmu__find_event(struct perf_pmu pmu, const char event, void *state, pmu_event_callback cb);
206		207
207	int perf_pmu__format_parse(struct perf_pmu *pmu, int dirfd, bool eager_load);	208	int perf_pmu__format_parse(struct perf_pmu *pmu, int dirfd, bool eager_load);

tools/perf/util/probe-event.c+26−14

 	return 0;
 }
+struct kernel_get_module_map_cb_args {
+	const char *module;
+	struct map *result;
+};
+static int kernel_get_module_map_cb(struct map *map, void *data)
+{
+	struct kernel_get_module_map_cb_args *args = data;
+	struct dso *dso = map__dso(map);
+	const char *short_name = dso->short_name; /* short_name is "[module]" */
+	u16 short_name_len =  dso->short_name_len;
+	if (strncmp(short_name + 1, args->module, short_name_len - 2) == 0 &&
+	    args->module[short_name_len - 2] == '\0') {
+		args->result = map__get(map);
+		return 1;
+	}
+	return 0;
+}
 static struct map *kernel_get_module_map(const char *module)
 {
-	struct maps *maps = machine__kernel_maps(host_machine);
+	struct kernel_get_module_map_cb_args args = {
-	struct map_rb_node *pos;
+		.module = module,
+		.result = NULL,
+	};
 	/* A file path -- this is an offline module */
 	if (module && strchr(module, '/'))
 		return map__get(map);
 	}
-	maps__for_each_entry(maps, pos) {
+	maps__for_each_map(machine__kernel_maps(host_machine), kernel_get_module_map_cb, &args);
-		/* short_name is "[module]" */
-		struct dso *dso = map__dso(pos->map);
-		const char *short_name = dso->short_name;
-		u16 short_name_len =  dso->short_name_len;
-		if (strncmp(short_name + 1, module,
+	return args.result;
-			    short_name_len - 2) == 0 &&
-		    module[short_name_len - 2] == '\0') {
-			return map__get(pos->map);
-		}
-	}
-	return NULL;
 }
 struct map *get_target_map(const char *target, struct nsinfo *nsi, bool user)

tools/perf/util/probe-finder.c+5−196

@@ -23,6 +23,7 @@ · 22 unmodified lines
23	#include "event.h"	23	#include "event.h"
24	#include "dso.h"	24	#include "dso.h"
25	#include "debug.h"	25	#include "debug.h"
		26	#include "debuginfo.h"
26	#include "intlist.h"	27	#include "intlist.h"
27	#include "strbuf.h"	28	#include "strbuf.h"
28	#include "strlist.h"	29	#include "strlist.h"
@@ -31,128 +32,9 @@ · 2 unmodified lines
31	#include "probe-file.h"	32	#include "probe-file.h"
32	#include "string2.h"	33	#include "string2.h"
33		34
34	#ifdef HAVE_DEBUGINFOD_SUPPORT
35	#include <elfutils/debuginfod.h>
36	#endif
37
38	/* Kprobe tracer basic type is up to u64 */	35	/* Kprobe tracer basic type is up to u64 */
39	#define MAX_BASIC_TYPE_BITS 64	36	#define MAX_BASIC_TYPE_BITS 64
40		37
41	/* Dwarf FL wrappers */
42	static char debuginfo_path; / Currently dummy */
43
44	static const Dwfl_Callbacks offline_callbacks = {
45	.find_debuginfo = dwfl_standard_find_debuginfo,
46	.debuginfo_path = &debuginfo_path,
47
48	.section_address = dwfl_offline_section_address,
49
50	/* We use this table for core files too. */
51	.find_elf = dwfl_build_id_find_elf,
52	};
53
54	/* Get a Dwarf from offline image */
55	static int debuginfo__init_offline_dwarf(struct debuginfo *dbg,
56	const char *path)
57	{
58	GElf_Addr dummy;
59	int fd;
60
61	fd = open(path, O_RDONLY);
62	if (fd < 0)
63	return fd;
64
65	dbg->dwfl = dwfl_begin(&offline_callbacks);
66	if (!dbg->dwfl)
67	goto error;
68
69	dwfl_report_begin(dbg->dwfl);
70	dbg->mod = dwfl_report_offline(dbg->dwfl, "", "", fd);
71	if (!dbg->mod)
72	goto error;
73
74	dbg->dbg = dwfl_module_getdwarf(dbg->mod, &dbg->bias);
75	if (!dbg->dbg)
76	goto error;
77
78	dwfl_module_build_id(dbg->mod, &dbg->build_id, &dummy);
79
80	dwfl_report_end(dbg->dwfl, NULL, NULL);
81
82	return 0;
83	error:
84	if (dbg->dwfl)
85	dwfl_end(dbg->dwfl);
86	else
87	close(fd);
88	memset(dbg, 0, sizeof(*dbg));
89
90	return -ENOENT;
91	}
92
93	static struct debuginfo __debuginfo__new(const char path)
94	{
95	struct debuginfo dbg = zalloc(sizeof(dbg));
96	if (!dbg)
97	return NULL;
98
99	if (debuginfo__init_offline_dwarf(dbg, path) < 0)
100	zfree(&dbg);
101	if (dbg)
102	pr_debug("Open Debuginfo file: %s\n", path);
103	return dbg;
104	}
105
106	enum dso_binary_type distro_dwarf_types[] = {
107	DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
108	DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
109	DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
110	DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
111	DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO,
112	DSO_BINARY_TYPE__NOT_FOUND,
113	};
114
115	struct debuginfo debuginfo__new(const char path)
116	{
117	enum dso_binary_type *type;
118	char buf[PATH_MAX], nil = '\0';
119	struct dso *dso;
120	struct debuginfo *dinfo = NULL;
121	struct build_id bid;
122
123	/* Try to open distro debuginfo files */
124	dso = dso__new(path);
125	if (!dso)
126	goto out;
127
128	/* Set the build id for DSO_BINARY_TYPE__BUILDID_DEBUGINFO */
129	if (is_regular_file(path) && filename__read_build_id(path, &bid) > 0)
130	dso__set_build_id(dso, &bid);
131
132	for (type = distro_dwarf_types;
133	!dinfo && *type != DSO_BINARY_TYPE__NOT_FOUND;
134	type++) {
135	if (dso__read_binary_type_filename(dso, *type, &nil,
136	buf, PATH_MAX) < 0)
137	continue;
138	dinfo = __debuginfo__new(buf);
139	}
140	dso__put(dso);
141
142	out:
143	/* if failed to open all distro debuginfo, open given binary */
144	return dinfo ? : __debuginfo__new(path);
145	}
146
147	void debuginfo__delete(struct debuginfo *dbg)
148	{
149	if (dbg) {
150	if (dbg->dwfl)
151	dwfl_end(dbg->dwfl);
152	free(dbg);
153	}
154	}
155
156	/*	38	/*
157	* Probe finder related functions	39	* Probe finder related functions
158	*/	40	*/
@@ -722,7 +604,7 @@ static int call_probe_finder(Dwarf_Die sc_die, struct probe_finder pf) · 563 unmodified lines
722	ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);	604	ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
723	if (ret <= 0 \|\| nops == 0) {	605	if (ret <= 0 \|\| nops == 0) {
724	pf->fb_ops = NULL;	606	pf->fb_ops = NULL;
725	#if _ELFUTILS_PREREQ(0, 142)	607	#ifdef HAVE_DWARF_CFI_SUPPORT
726	} else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&	608	} else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
727	(pf->cfi_eh != NULL \|\| pf->cfi_dbg != NULL)) {	609	(pf->cfi_eh != NULL \|\| pf->cfi_dbg != NULL)) {
728	if ((dwarf_cfi_addrframe(pf->cfi_eh, pf->addr, &frame) != 0 &&	610	if ((dwarf_cfi_addrframe(pf->cfi_eh, pf->addr, &frame) != 0 &&
@@ -733,7 +615,7 @@ static int call_probe_finder(Dwarf_Die sc_die, struct probe_finder pf) · 4 unmodified lines
733	free(frame);	615	free(frame);
734	return -ENOENT;	616	return -ENOENT;
735	}	617	}
736	#endif	618	#endif /* HAVE_DWARF_CFI_SUPPORT */
737	}	619	}
738		620
739	/* Call finder's callback handler */	621	/* Call finder's callback handler */
@@ -1258,7 +1140,7 @@ static int debuginfo__find_probes(struct debuginfo *dbg, · 518 unmodified lines
1258		1140
1259	pf->machine = ehdr.e_machine;	1141	pf->machine = ehdr.e_machine;
1260		1142
1261	#if _ELFUTILS_PREREQ(0, 142)	1143	#ifdef HAVE_DWARF_CFI_SUPPORT
1262	do {	1144	do {
1263	GElf_Shdr shdr;	1145	GElf_Shdr shdr;
1264		1146
@@ -1268,7 +1150,7 @@ static int debuginfo__find_probes(struct debuginfo *dbg, · 3 unmodified lines
1268		1150
1269	pf->cfi_dbg = dwarf_getcfi(dbg->dbg);	1151	pf->cfi_dbg = dwarf_getcfi(dbg->dbg);
1270	} while (0);	1152	} while (0);
1271	#endif	1153	#endif /* HAVE_DWARF_CFI_SUPPORT */
1272		1154
1273	ret = debuginfo__find_probe_location(dbg, pf);	1155	ret = debuginfo__find_probe_location(dbg, pf);
1274	return ret;	1156	return ret;
@@ -1677,44 +1559,6 @@ int debuginfo__find_available_vars_at(struct debuginfo *dbg, · 402 unmodified lines
1677	return (ret < 0) ? ret : af.nvls;	1559	return (ret < 0) ? ret : af.nvls;
1678	}	1560	}
1679		1561
1680	/* For the kernel module, we need a special code to get a DIE */
1681	int debuginfo__get_text_offset(struct debuginfo dbg, Dwarf_Addr offs,
1682	bool adjust_offset)
1683	{
1684	int n, i;
1685	Elf32_Word shndx;
1686	Elf_Scn *scn;
1687	Elf *elf;
1688	GElf_Shdr mem, *shdr;
1689	const char *p;
1690
1691	elf = dwfl_module_getelf(dbg->mod, &dbg->bias);
1692	if (!elf)
1693	return -EINVAL;
1694
1695	/* Get the number of relocations */
1696	n = dwfl_module_relocations(dbg->mod);
1697	if (n < 0)
1698	return -ENOENT;
1699	/* Search the relocation related .text section */
1700	for (i = 0; i < n; i++) {
1701	p = dwfl_module_relocation_info(dbg->mod, i, &shndx);
1702	if (strcmp(p, ".text") == 0) {
1703	/* OK, get the section header */
1704	scn = elf_getscn(elf, shndx);
1705	if (!scn)
1706	return -ENOENT;
1707	shdr = gelf_getshdr(scn, &mem);
1708	if (!shdr)
1709	return -ENOENT;
1710	*offs = shdr->sh_addr;
1711	if (adjust_offset)
1712	*offs -= shdr->sh_offset;
1713	}
1714	}
1715	return 0;
1716	}
1717
1718	/* Reverse search */	1562	/* Reverse search */
1719	int debuginfo__find_probe_point(struct debuginfo *dbg, u64 addr,	1563	int debuginfo__find_probe_point(struct debuginfo *dbg, u64 addr,
1720	struct perf_probe_point *ppt)	1564	struct perf_probe_point *ppt)
@@ -2009,41 +1853,6 @@ found: · 288 unmodified lines
2009	return (ret < 0) ? ret : lf.found;	1853	return (ret < 0) ? ret : lf.found;
2010	}	1854	}
2011		1855
2012	#ifdef HAVE_DEBUGINFOD_SUPPORT
2013	/* debuginfod doesn't require the comp_dir but buildid is required */
2014	static int get_source_from_debuginfod(const char *raw_path,
2015	const char sbuild_id, char *new_path)
2016	{
2017	debuginfod_client *c = debuginfod_begin();
2018	const char *p = raw_path;
2019	int fd;
2020
2021	if (!c)
2022	return -ENOMEM;
2023
2024	fd = debuginfod_find_source(c, (const unsigned char *)sbuild_id,
2025	0, p, new_path);
2026	pr_debug("Search %s from debuginfod -> %d\n", p, fd);
2027	if (fd >= 0)
2028	close(fd);
2029	debuginfod_end(c);
2030	if (fd < 0) {
2031	pr_debug("Failed to find %s in debuginfod (%s)\n",
2032	raw_path, sbuild_id);
2033	return -ENOENT;
2034	}
2035	pr_debug("Got a source %s\n", *new_path);
2036
2037	return 0;
2038	}
2039	#else
2040	static inline int get_source_from_debuginfod(const char *raw_path __maybe_unused,
2041	const char *sbuild_id __maybe_unused,
2042	char **new_path __maybe_unused)
2043	{
2044	return -ENOTSUP;
2045	}
2046	#endif
2047	/*	1856	/*
2048	* Find a src file from a DWARF tag path. Prepend optional source path prefix	1857	* Find a src file from a DWARF tag path. Prepend optional source path prefix
2049	* and chop off leading directories that do not exist. Result is passed back as	1858	* and chop off leading directories that do not exist. Result is passed back as

tools/perf/util/probe-finder.h+1−18

@@ -24,21 +24,7 @@ static inline int is_c_varname(const char *name) · 23 unmodified lines
24	#ifdef HAVE_DWARF_SUPPORT	24	#ifdef HAVE_DWARF_SUPPORT
25		25
26	#include "dwarf-aux.h"	26	#include "dwarf-aux.h"
27		27	#include "debuginfo.h"
28	/* TODO: export debuginfo data structure even if no dwarf support */
29
30	/* debug information structure */
31	struct debuginfo {
32	Dwarf *dbg;
33	Dwfl_Module *mod;
34	Dwfl *dwfl;
35	Dwarf_Addr bias;
36	const unsigned char *build_id;
37	};
38
39	/* This also tries to open distro debuginfo */
40	struct debuginfo debuginfo__new(const char path);
41	void debuginfo__delete(struct debuginfo *dbg);
42		28
43	/* Find probe_trace_events specified by perf_probe_event from debuginfo */	29	/* Find probe_trace_events specified by perf_probe_event from debuginfo */
44	int debuginfo__find_trace_events(struct debuginfo *dbg,	30	int debuginfo__find_trace_events(struct debuginfo *dbg,
@@ -49,9 +35,6 @@ int debuginfo__find_trace_events(struct debuginfo *dbg, · 4 unmodified lines
49	int debuginfo__find_probe_point(struct debuginfo *dbg, u64 addr,	35	int debuginfo__find_probe_point(struct debuginfo *dbg, u64 addr,
50	struct perf_probe_point *ppt);	36	struct perf_probe_point *ppt);
51		37
52	int debuginfo__get_text_offset(struct debuginfo dbg, Dwarf_Addr offs,
53	bool adjust_offset);
54
55	/* Find a line range */	38	/* Find a line range */
56	int debuginfo__find_line_range(struct debuginfo dbg, struct line_range lr);	39	int debuginfo__find_line_range(struct debuginfo dbg, struct line_range lr);
57		40

tools/perf/util/record.c+2−2

@@ -237,8 +237,8 @@ bool evlist__can_select_event(struct evlist evlist, const char str) · 236 unmodified lines
237		237
238	evsel = evlist__last(temp_evlist);	238	evsel = evlist__last(temp_evlist);
239		239
240	if (!evlist \|\| perf_cpu_map__empty(evlist->core.user_requested_cpus)) {	240	if (!evlist \|\| perf_cpu_map__has_any_cpu_or_is_empty(evlist->core.user_requested_cpus)) {
241	struct perf_cpu_map *cpus = perf_cpu_map__new(NULL);	241	struct perf_cpu_map *cpus = perf_cpu_map__new_online_cpus();
242		242
243	if (cpus)	243	if (cpus)
244	cpu = perf_cpu_map__cpu(cpus, 0);	244	cpu = perf_cpu_map__cpu(cpus, 0);

tools/perf/util/s390-cpumcf-kernel.h+2−0

@@ -12,6 +12,8 @@ · 11 unmodified lines
12	#define S390_CPUMCF_DIAG_DEF 0xfeef /* Counter diagnostic entry ID */	12	#define S390_CPUMCF_DIAG_DEF 0xfeef /* Counter diagnostic entry ID */
13	#define PERF_EVENT_CPUM_CF_DIAG 0xBC000 /* Event: Counter sets */	13	#define PERF_EVENT_CPUM_CF_DIAG 0xBC000 /* Event: Counter sets */
14	#define PERF_EVENT_CPUM_SF_DIAG 0xBD000 /* Event: Combined-sampling */	14	#define PERF_EVENT_CPUM_SF_DIAG 0xBD000 /* Event: Combined-sampling */
		15	#define PERF_EVENT_PAI_CRYPTO_ALL 0x1000 /* Event: CRYPTO_ALL */
		16	#define PERF_EVENT_PAI_NNPA_ALL 0x1800 /* Event: NNPA_ALL */
15		17
16	struct cf_ctrset_entry { /* CPU-M CF counter set entry (8 byte) */	18	struct cf_ctrset_entry { /* CPU-M CF counter set entry (8 byte) */
17	unsigned int def:16; /* 0-15 Data Entry Format */	19	unsigned int def:16; /* 0-15 Data Entry Format */

tools/perf/util/s390-sample-raw.c+104−10

@@ -51,8 +51,6 @@ static bool s390_cpumcfdg_testctr(struct perf_sample *sample) · 50 unmodified lines
51	struct cf_trailer_entry *te;	51	struct cf_trailer_entry *te;
52	struct cf_ctrset_entry *cep, ce;	52	struct cf_ctrset_entry *cep, ce;
53		53
54	if (!len)
55	return false;
56	while (offset < len) {	54	while (offset < len) {
57	cep = (struct cf_ctrset_entry *)(buf + offset);	55	cep = (struct cf_ctrset_entry *)(buf + offset);
58	ce.def = be16_to_cpu(cep->def);	56	ce.def = be16_to_cpu(cep->def);
@@ -125,6 +123,9 @@ static int get_counterset_start(int setnr) · 66 unmodified lines
125	return 128;	123	return 128;
126	case CPUMF_CTR_SET_MT_DIAG: /* Diagnostic counter set */	124	case CPUMF_CTR_SET_MT_DIAG: /* Diagnostic counter set */
127	return 448;	125	return 448;
		126	case PERF_EVENT_PAI_NNPA_ALL: /* PAI NNPA counter set */
		127	case PERF_EVENT_PAI_CRYPTO_ALL: /* PAI CRYPTO counter set */
		128	return setnr;
128	default:	129	default:
129	return -1;	130	return -1;
130	}	131	}
@@ -212,27 +213,120 @@ static void s390_cpumcfdg_dump(struct perf_pmu pmu, struct perf_sample sample) · 81 unmodified lines
212	}	213	}
213	}	214	}
214		215
		216	#pragma GCC diagnostic push
		217	#pragma GCC diagnostic ignored "-Wpacked"
		218	#pragma GCC diagnostic ignored "-Wattributes"
		219	/*
		220	* Check for consistency of PAI_CRYPTO/PAI_NNPA raw data.
		221	*/
		222	struct pai_data { /* Event number and value */
		223	u16 event_nr;
		224	u64 event_val;
		225	} __packed;
		226
		227	#pragma GCC diagnostic pop
		228
		229	/*
		230	* Test for valid raw data. At least one PAI event should be in the raw
		231	* data section.
		232	*/
		233	static bool s390_pai_all_test(struct perf_sample *sample)
		234	{
		235	size_t len = sample->raw_size;
		236
		237	if (len < 0xa)
		238	return false;
		239	return true;
		240	}
		241
		242	static void s390_pai_all_dump(struct evsel evsel, struct perf_sample sample)
		243	{
		244	size_t len = sample->raw_size, offset = 0;
		245	unsigned char *p = sample->raw_data;
		246	const char *color = PERF_COLOR_BLUE;
		247	struct pai_data pai_data;
		248	char *ev_name;
		249
		250	while (offset < len) {
		251	memcpy(&pai_data.event_nr, p, sizeof(pai_data.event_nr));
		252	pai_data.event_nr = be16_to_cpu(pai_data.event_nr);
		253	p += sizeof(pai_data.event_nr);
		254	offset += sizeof(pai_data.event_nr);
		255
		256	memcpy(&pai_data.event_val, p, sizeof(pai_data.event_val));
		257	pai_data.event_val = be64_to_cpu(pai_data.event_val);
		258	p += sizeof(pai_data.event_val);
		259	offset += sizeof(pai_data.event_val);
		260
		261	ev_name = get_counter_name(evsel->core.attr.config,
		262	pai_data.event_nr, evsel->pmu);
		263	color_fprintf(stdout, color, "\tCounter:%03d %s Value:%#018lx\n",
		264	pai_data.event_nr, ev_name ?: "<unknown>",
		265	pai_data.event_val);
		266	free(ev_name);
		267
		268	if (offset + 0xa > len)
		269	break;
		270	}
		271	color_fprintf(stdout, color, "\n");
		272	}
		273
215	/* S390 specific trace event function. Check for PERF_RECORD_SAMPLE events	274	/* S390 specific trace event function. Check for PERF_RECORD_SAMPLE events
216	* and if the event was triggered by a counter set diagnostic event display	275	* and if the event was triggered by a
217	* its raw data.	276	* - counter set diagnostic event
		277	* - processor activity assist (PAI) crypto counter event
		278	* - processor activity assist (PAI) neural network processor assist (NNPA)
		279	* counter event
		280	* display its raw data.
218	* The function is only invoked when the dump flag -D is set.	281	* The function is only invoked when the dump flag -D is set.
		282	*
		283	* Function evlist__s390_sample_raw() is defined as call back after it has
		284	* been verified that the perf.data file was created on s390 platform.
219	*/	285	*/
220	void evlist__s390_sample_raw(struct evlist evlist, union perf_event event, struct perf_sample *sample)	286	void evlist__s390_sample_raw(struct evlist evlist, union perf_event event,
		287	struct perf_sample *sample)
221	{	288	{
		289	const char *pai_name;
222	struct evsel *evsel;	290	struct evsel *evsel;
223		291
224	if (event->header.type != PERF_RECORD_SAMPLE)	292	if (event->header.type != PERF_RECORD_SAMPLE)
225	return;	293	return;
226		294
227	evsel = evlist__event2evsel(evlist, event);	295	evsel = evlist__event2evsel(evlist, event);
228	if (evsel == NULL \|\|	296	if (!evsel)
229	evsel->core.attr.config != PERF_EVENT_CPUM_CF_DIAG)	297	return;
		298
		299	/* Check for raw data in sample */
		300	if (!sample->raw_size \|\| !sample->raw_data)
230	return;	301	return;
231		302
232	/* Display raw data on screen */	303	/* Display raw data on screen */
233	if (!s390_cpumcfdg_testctr(sample)) {	304	if (evsel->core.attr.config == PERF_EVENT_CPUM_CF_DIAG) {
234	pr_err("Invalid counter set data encountered\n");	305	if (!evsel->pmu)
		306	evsel->pmu = perf_pmus__find("cpum_cf");
		307	if (!s390_cpumcfdg_testctr(sample))
		308	pr_err("Invalid counter set data encountered\n");
		309	else
		310	s390_cpumcfdg_dump(evsel->pmu, sample);
		311	return;
		312	}
		313
		314	switch (evsel->core.attr.config) {
		315	case PERF_EVENT_PAI_NNPA_ALL:
		316	pai_name = "NNPA_ALL";
		317	break;
		318	case PERF_EVENT_PAI_CRYPTO_ALL:
		319	pai_name = "CRYPTO_ALL";
		320	break;
		321	default:
235	return;	322	return;
236	}	323	}
237	s390_cpumcfdg_dump(evsel->pmu, sample);	324
		325	if (!s390_pai_all_test(sample)) {
		326	pr_err("Invalid %s raw data encountered\n", pai_name);
		327	} else {
		328	if (!evsel->pmu)
		329	evsel->pmu = perf_pmus__find_by_type(evsel->core.attr.type);
		330	s390_pai_all_dump(evsel, sample);
		331	}
238	}	332	}

tools/perf/util/sample.h+1−0

@@ -113,6 +113,7 @@ struct perf_sample { · 112 unmodified lines
113	void *raw_data;	113	void *raw_data;
114	struct ip_callchain *callchain;	114	struct ip_callchain *callchain;
115	struct branch_stack *branch_stack;	115	struct branch_stack *branch_stack;
		116	u64 *branch_stack_cntr;
116	struct regs_dump user_regs;	117	struct regs_dump user_regs;
117	struct regs_dump intr_regs;	118	struct regs_dump intr_regs;
118	struct stack_dump user_stack;	119	struct stack_dump user_stack;

tools/perf/util/scripting-engines/trace-event-perl.c+3−0

@@ -490,6 +490,9 @@ static int perl_start_script(const char script, int argc, const char *argv, · 489 unmodified lines
490	scripting_context->session = session;	490	scripting_context->session = session;
491		491
492	command_line = malloc((argc + 2) * sizeof(const char *));	492	command_line = malloc((argc + 2) * sizeof(const char *));
		493	if (!command_line)
		494	return -ENOMEM;
		495
493	command_line[0] = "";	496	command_line[0] = "";
494	command_line[1] = script;	497	command_line[1] = script;
495	for (i = 2; i < argc + 2; i++)	498	for (i = 2; i < argc + 2; i++)

tools/perf/util/scripting-engines/trace-event-python.c+15−2

 	if (is_array) {
 		list = PyList_New(field->arraylen);
+		if (!list)
+			Py_FatalError("couldn't create Python list");
 		item_size = field->size / field->arraylen;
 		n_items = field->arraylen;
 	} else {
 	}
 }
-static void set_regs_in_dict(PyObject *dict,
+static int set_regs_in_dict(PyObject *dict,
 			     struct perf_sample *sample,
 			     struct evsel *evsel)
 {
 	 */
 	int size = __sw_hweight64(attr->sample_regs_intr) * 28;
 	char *bf = malloc(size);
+	if (!bf)
+		return -1;
 	regs_map(&sample->intr_regs, attr->sample_regs_intr, arch, bf, size);
 	pydict_set_item_string_decref(dict, "uregs",
 			_PyUnicode_FromString(bf));
 	free(bf);
+	return 0;
 }
 static void set_sym_in_dict(PyObject *dict, struct addr_location *al,
 			PyLong_FromUnsignedLongLong(sample->cyc_cnt));
 	}
-	set_regs_in_dict(dict, sample, evsel);
+	if (set_regs_in_dict(dict, sample, evsel))
+		Py_FatalError("Failed to setting regs in dict");
 	return dict;
 }
 	scripting_context->session = session;
 #if PY_MAJOR_VERSION < 3
 	command_line = malloc((argc + 1) * sizeof(const char *));
+	if (!command_line)
+		return -1;
 	command_line[0] = script;
 	for (i = 1; i < argc + 1; i++)
 		command_line[i] = argv[i - 1];
 	PyImport_AppendInittab(name, initperf_trace_context);
 #else
 	command_line = malloc((argc + 1) * sizeof(wchar_t *));
+	if (!command_line)
+		return -1;
 	command_line[0] = Py_DecodeLocale(script, NULL);
 	for (i = 1; i < argc + 1; i++)
 		command_line[i] = Py_DecodeLocale(argv[i - 1], NULL);

tools/perf/util/session.c+18−2

 		return -1;
 	}
+	if (perf_header__has_feat(&session->header, HEADER_AUXTRACE)) {
+		/* Auxiliary events may reference exited threads, hold onto dead ones. */
+		symbol_conf.keep_exited_threads = true;
+	}
 	if (perf_data__is_pipe(data))
 		return 0;
 		       i, callchain->ips[i]);
 }
-static void branch_stack__printf(struct perf_sample *sample, bool callstack)
+static void branch_stack__printf(struct perf_sample *sample,
+				 struct evsel *evsel)
 {
 	struct branch_entry *entries = perf_sample__branch_entries(sample);
+	bool callstack = evsel__has_branch_callstack(evsel);
+	u64 *branch_stack_cntr = sample->branch_stack_cntr;
+	struct perf_env *env = evsel__env(evsel);
 	uint64_t i;
 	if (!callstack) {
 			}
 		}
 	}
+	if (branch_stack_cntr) {
+		printf("... branch stack counters: nr:%" PRIu64 " (counter width: %u max counter nr:%u)\n",
+			sample->branch_stack->nr, env->br_cntr_width, env->br_cntr_nr);
+		for (i = 0; i < sample->branch_stack->nr; i++)
+			printf("..... %2"PRIu64": %016" PRIx64 "\n", i, branch_stack_cntr[i]);
+	}
 }
 static void regs_dump__printf(u64 mask, u64 *regs, const char *arch)
 		callchain__printf(evsel, sample);
 	if (evsel__has_br_stack(evsel))
-		branch_stack__printf(sample, evsel__has_branch_callstack(evsel));
+		branch_stack__printf(sample, evsel);
 	if (sample_type & PERF_SAMPLE_REGS_USER)
 		regs_user__printf(sample, arch);

tools/perf/util/sort.c+207−9

@@ -24,6 +24,7 @@ · 23 unmodified lines
24	#include "strbuf.h"	24	#include "strbuf.h"
25	#include "mem-events.h"	25	#include "mem-events.h"
26	#include "annotate.h"	26	#include "annotate.h"
		27	#include "annotate-data.h"
27	#include "event.h"	28	#include "event.h"
28	#include "time-utils.h"	29	#include "time-utils.h"
29	#include "cgroup.h"	30	#include "cgroup.h"
@@ -418,6 +419,52 @@ struct sort_entry sort_sym = { · 388 unmodified lines
418	.se_width_idx = HISTC_SYMBOL,	419	.se_width_idx = HISTC_SYMBOL,
419	};	420	};
420		421
		422	/* --sort symoff */
		423
		424	static int64_t
		425	sort__symoff_cmp(struct hist_entry left, struct hist_entry right)
		426	{
		427	int64_t ret;
		428
		429	ret = sort__sym_cmp(left, right);
		430	if (ret)
		431	return ret;
		432
		433	return left->ip - right->ip;
		434	}
		435
		436	static int64_t
		437	sort__symoff_sort(struct hist_entry left, struct hist_entry right)
		438	{
		439	int64_t ret;
		440
		441	ret = sort__sym_sort(left, right);
		442	if (ret)
		443	return ret;
		444
		445	return left->ip - right->ip;
		446	}
		447
		448	static int
		449	hist_entry__symoff_snprintf(struct hist_entry he, char bf, size_t size, unsigned int width)
		450	{
		451	struct symbol *sym = he->ms.sym;
		452
		453	if (sym == NULL)
		454	return repsep_snprintf(bf, size, "[%c] %-#.*llx", he->level, width - 4, he->ip);
		455
		456	return repsep_snprintf(bf, size, "[%c] %s+0x%llx", he->level, sym->name, he->ip - sym->start);
		457	}
		458
		459	struct sort_entry sort_sym_offset = {
		460	.se_header = "Symbol Offset",
		461	.se_cmp = sort__symoff_cmp,
		462	.se_sort = sort__symoff_sort,
		463	.se_snprintf = hist_entry__symoff_snprintf,
		464	.se_filter = hist_entry__sym_filter,
		465	.se_width_idx = HISTC_SYMBOL_OFFSET,
		466	};
		467
421	/* --sort srcline */	468	/* --sort srcline */
422		469
423	char hist_entry__srcline(struct hist_entry he)	470	char hist_entry__srcline(struct hist_entry he)
@@ -583,21 +630,21 @@ static int hist_entry__sym_ipc_snprintf(struct hist_entry he, char bf, · 159 unmodified lines
583	{	630	{
584		631
585	struct symbol *sym = he->ms.sym;	632	struct symbol *sym = he->ms.sym;
586	struct annotation *notes;	633	struct annotated_branch *branch;
587	double ipc = 0.0, coverage = 0.0;	634	double ipc = 0.0, coverage = 0.0;
588	char tmp[64];	635	char tmp[64];
589		636
590	if (!sym)	637	if (!sym)
591	return repsep_snprintf(bf, size, "%-*s", width, "-");	638	return repsep_snprintf(bf, size, "%-*s", width, "-");
592		639
593	notes = symbol__annotation(sym);	640	branch = symbol__annotation(sym)->branch;
594		641
595	if (notes->hit_cycles)	642	if (branch && branch->hit_cycles)
596	ipc = notes->hit_insn / ((double)notes->hit_cycles);	643	ipc = branch->hit_insn / ((double)branch->hit_cycles);
597		644
598	if (notes->total_insn) {	645	if (branch && branch->total_insn) {
599	coverage = notes->cover_insn * 100.0 /	646	coverage = branch->cover_insn * 100.0 /
600	((double)notes->total_insn);	647	((double)branch->total_insn);
601	}	648	}
602		649
603	snprintf(tmp, sizeof(tmp), "%-5.2f [%5.1f%%]", ipc, coverage);	650	snprintf(tmp, sizeof(tmp), "%-5.2f [%5.1f%%]", ipc, coverage);
@@ -2094,7 +2141,7 @@ struct sort_entry sort_dso_size = { · 1490 unmodified lines
2094	.se_width_idx = HISTC_DSO_SIZE,	2141	.se_width_idx = HISTC_DSO_SIZE,
2095	};	2142	};
2096		2143
2097	/* --sort dso_size */	2144	/* --sort addr */
2098		2145
2099	static int64_t	2146	static int64_t
2100	sort__addr_cmp(struct hist_entry left, struct hist_entry right)	2147	sort__addr_cmp(struct hist_entry left, struct hist_entry right)
@@ -2131,6 +2178,152 @@ struct sort_entry sort_addr = { · 30 unmodified lines
2131	.se_width_idx = HISTC_ADDR,	2178	.se_width_idx = HISTC_ADDR,
2132	};	2179	};
2133		2180
		2181	/* --sort type */
		2182
		2183	struct annotated_data_type unknown_type = {
		2184	.self = {
		2185	.type_name = (char *)"(unknown)",
		2186	.children = LIST_HEAD_INIT(unknown_type.self.children),
		2187	},
		2188	};
		2189
		2190	static int64_t
		2191	sort__type_cmp(struct hist_entry left, struct hist_entry right)
		2192	{
		2193	return sort__addr_cmp(left, right);
		2194	}
		2195
		2196	static void sort__type_init(struct hist_entry *he)
		2197	{
		2198	if (he->mem_type)
		2199	return;
		2200
		2201	he->mem_type = hist_entry__get_data_type(he);
		2202	if (he->mem_type == NULL) {
		2203	he->mem_type = &unknown_type;
		2204	he->mem_type_off = 0;
		2205	}
		2206	}
		2207
		2208	static int64_t
		2209	sort__type_collapse(struct hist_entry left, struct hist_entry right)
		2210	{
		2211	struct annotated_data_type *left_type = left->mem_type;
		2212	struct annotated_data_type *right_type = right->mem_type;
		2213
		2214	if (!left_type) {
		2215	sort__type_init(left);
		2216	left_type = left->mem_type;
		2217	}
		2218
		2219	if (!right_type) {
		2220	sort__type_init(right);
		2221	right_type = right->mem_type;
		2222	}
		2223
		2224	return strcmp(left_type->self.type_name, right_type->self.type_name);
		2225	}
		2226
		2227	static int64_t
		2228	sort__type_sort(struct hist_entry left, struct hist_entry right)
		2229	{
		2230	return sort__type_collapse(left, right);
		2231	}
		2232
		2233	static int hist_entry__type_snprintf(struct hist_entry he, char bf,
		2234	size_t size, unsigned int width)
		2235	{
		2236	return repsep_snprintf(bf, size, "%-*s", width, he->mem_type->self.type_name);
		2237	}
		2238
		2239	struct sort_entry sort_type = {
		2240	.se_header = "Data Type",
		2241	.se_cmp = sort__type_cmp,
		2242	.se_collapse = sort__type_collapse,
		2243	.se_sort = sort__type_sort,
		2244	.se_init = sort__type_init,
		2245	.se_snprintf = hist_entry__type_snprintf,
		2246	.se_width_idx = HISTC_TYPE,
		2247	};
		2248
		2249	/* --sort typeoff */
		2250
		2251	static int64_t
		2252	sort__typeoff_sort(struct hist_entry left, struct hist_entry right)
		2253	{
		2254	struct annotated_data_type *left_type = left->mem_type;
		2255	struct annotated_data_type *right_type = right->mem_type;
		2256	int64_t ret;
		2257
		2258	if (!left_type) {
		2259	sort__type_init(left);
		2260	left_type = left->mem_type;
		2261	}
		2262
		2263	if (!right_type) {
		2264	sort__type_init(right);
		2265	right_type = right->mem_type;
		2266	}
		2267
		2268	ret = strcmp(left_type->self.type_name, right_type->self.type_name);
		2269	if (ret)
		2270	return ret;
		2271	return left->mem_type_off - right->mem_type_off;
		2272	}
		2273
		2274	static void fill_member_name(char buf, size_t sz, struct annotated_member m,
		2275	int offset, bool first)
		2276	{
		2277	struct annotated_member *child;
		2278
		2279	if (list_empty(&m->children))
		2280	return;
		2281
		2282	list_for_each_entry(child, &m->children, node) {
		2283	if (child->offset <= offset && offset < child->offset + child->size) {
		2284	int len = 0;
		2285
		2286	/* It can have anonymous struct/union members */
		2287	if (child->var_name) {
		2288	len = scnprintf(buf, sz, "%s%s",
		2289	first ? "" : ".", child->var_name);
		2290	first = false;
		2291	}
		2292
		2293	fill_member_name(buf + len, sz - len, child, offset, first);
		2294	return;
		2295	}
		2296	}
		2297	}
		2298
		2299	static int hist_entry__typeoff_snprintf(struct hist_entry he, char bf,
		2300	size_t size, unsigned int width __maybe_unused)
		2301	{
		2302	struct annotated_data_type *he_type = he->mem_type;
		2303	char buf[4096];
		2304
		2305	buf[0] = '\0';
		2306	if (list_empty(&he_type->self.children))
		2307	snprintf(buf, sizeof(buf), "no field");
		2308	else
		2309	fill_member_name(buf, sizeof(buf), &he_type->self,
		2310	he->mem_type_off, true);
		2311	buf[4095] = '\0';
		2312
		2313	return repsep_snprintf(bf, size, "%s %+d (%s)", he_type->self.type_name,
		2314	he->mem_type_off, buf);
		2315	}
		2316
		2317	struct sort_entry sort_type_offset = {
		2318	.se_header = "Data Type Offset",
		2319	.se_cmp = sort__type_cmp,
		2320	.se_collapse = sort__typeoff_sort,
		2321	.se_sort = sort__typeoff_sort,
		2322	.se_init = sort__type_init,
		2323	.se_snprintf = hist_entry__typeoff_snprintf,
		2324	.se_width_idx = HISTC_TYPE_OFFSET,
		2325	};
		2326
2134		2327
2135	struct sort_dimension {	2328	struct sort_dimension {
2136	const char *name;	2329	const char *name;
@@ -2185,7 +2378,10 @@ static struct sort_dimension common_sort_dimensions[] = { · 48 unmodified lines
2185	DIM(SORT_ADDR, "addr", sort_addr),	2378	DIM(SORT_ADDR, "addr", sort_addr),
2186	DIM(SORT_LOCAL_RETIRE_LAT, "local_retire_lat", sort_local_p_stage_cyc),	2379	DIM(SORT_LOCAL_RETIRE_LAT, "local_retire_lat", sort_local_p_stage_cyc),
2187	DIM(SORT_GLOBAL_RETIRE_LAT, "retire_lat", sort_global_p_stage_cyc),	2380	DIM(SORT_GLOBAL_RETIRE_LAT, "retire_lat", sort_global_p_stage_cyc),
2188	DIM(SORT_SIMD, "simd", sort_simd)	2381	DIM(SORT_SIMD, "simd", sort_simd),
		2382	DIM(SORT_ANNOTATE_DATA_TYPE, "type", sort_type),
		2383	DIM(SORT_ANNOTATE_DATA_TYPE_OFFSET, "typeoff", sort_type_offset),
		2384	DIM(SORT_SYM_OFFSET, "symoff", sort_sym_offset),
2189	};	2385	};
2190		2386
2191	#undef DIM	2387	#undef DIM
@@ -3205,6 +3401,8 @@ int sort_dimension__add(struct perf_hpp_list list, const char tok, · 1013 unmodified lines
3205	list->thread = 1;	3401	list->thread = 1;
3206	} else if (sd->entry == &sort_comm) {	3402	} else if (sd->entry == &sort_comm) {
3207	list->comm = 1;	3403	list->comm = 1;
		3404	} else if (sd->entry == &sort_type_offset) {
		3405	symbol_conf.annotate_data_member = true;
3208	}	3406	}
3209		3407
3210	return __sort_dimension__add(sd, list, level);	3408	return __sort_dimension__add(sd, list, level);

tools/perf/util/sort.h+7−0

 struct option;
 struct thread;
+struct annotated_data_type;
 extern regex_t parent_regex;
 extern const char *sort_order;
 extern struct sort_entry sort_sym_from;
 extern struct sort_entry sort_sym_to;
 extern struct sort_entry sort_srcline;
+extern struct sort_entry sort_type;
 extern const char default_mem_sort_order[];
 extern bool chk_double_cl;
 	u64			p_stage_cyc;
 	u8			cpumode;
 	u8			depth;
+	int			mem_type_off;
 	struct simd_flags	simd_flags;
 	/* We are added by hists__add_dummy_entry. */
 	struct perf_hpp_list	*hpp_list;
 	struct hist_entry	*parent_he;
 	struct hist_entry_ops	*ops;
+	struct annotated_data_type *mem_type;
 	union {
 		/* this is for hierarchical entry structure */
 		struct {
 	SORT_LOCAL_RETIRE_LAT,
 	SORT_GLOBAL_RETIRE_LAT,
 	SORT_SIMD,
+	SORT_ANNOTATE_DATA_TYPE,
+	SORT_ANNOTATE_DATA_TYPE_OFFSET,
+	SORT_SYM_OFFSET,
 	/* branch stack specific sort keys */
 	__SORT_BRANCH_STACK,

tools/perf/util/stat-display.c+1−1

@@ -898,7 +898,7 @@ static bool hybrid_uniquify(struct evsel evsel, struct perf_stat_config config · 897 unmodified lines
898		898
899	static void uniquify_counter(struct perf_stat_config config, struct evsel counter)	899	static void uniquify_counter(struct perf_stat_config config, struct evsel counter)
900	{	900	{
901	if (config->no_merge \|\| hybrid_uniquify(counter, config))	901	if (config->aggr_mode == AGGR_NONE \|\| hybrid_uniquify(counter, config))
902	uniquify_event_name(counter);	902	uniquify_event_name(counter);
903	}	903	}
904		904

tools/perf/util/stat-shadow.c+1−1

@@ -264,7 +264,7 @@ static void print_ll_miss(struct perf_stat_config *config, · 263 unmodified lines
264	static const double color_ratios[3] = {20.0, 10.0, 5.0};	264	static const double color_ratios[3] = {20.0, 10.0, 5.0};
265		265
266	print_ratio(config, evsel, aggr_idx, misses, out, STAT_LL_CACHE, color_ratios,	266	print_ratio(config, evsel, aggr_idx, misses, out, STAT_LL_CACHE, color_ratios,
267	"of all L1-icache accesses");	267	"of all LL-cache accesses");
268	}	268	}
269		269
270	static void print_dtlb_miss(struct perf_stat_config *config,	270	static void print_dtlb_miss(struct perf_stat_config *config,

tools/perf/util/stat.c+2−2

@@ -315,7 +315,7 @@ static int check_per_pkg(struct evsel counter, struct perf_counts_values vals, · 314 unmodified lines
315	if (!counter->per_pkg)	315	if (!counter->per_pkg)
316	return 0;	316	return 0;
317		317
318	if (perf_cpu_map__empty(cpus))	318	if (perf_cpu_map__has_any_cpu_or_is_empty(cpus))
319	return 0;	319	return 0;
320		320
321	if (!mask) {	321	if (!mask) {
@@ -592,7 +592,7 @@ void perf_stat_merge_counters(struct perf_stat_config config, struct evlist ev · 270 unmodified lines
592	{	592	{
593	struct evsel *evsel;	593	struct evsel *evsel;
594		594
595	if (config->no_merge)	595	if (config->aggr_mode == AGGR_NONE)
596	return;	596	return;
597		597
598	evlist__for_each_entry(evlist, evsel)	598	evlist__for_each_entry(evlist, evsel)

tools/perf/util/stat.h+0−1

@@ -76,7 +76,6 @@ struct perf_stat_config { · 75 unmodified lines
76	bool null_run;	76	bool null_run;
77	bool ru_display;	77	bool ru_display;
78	bool big_num;	78	bool big_num;
79	bool no_merge;
80	bool hybrid_merge;	79	bool hybrid_merge;
81	bool walltime_run_table;	80	bool walltime_run_table;
82	bool all_kernel;	81	bool all_kernel;

tools/perf/util/symbol-elf.c+2−4

 			map__set_start(map, shdr->sh_addr + ref_reloc(kmap));
 			map__set_end(map, map__start(map) + shdr->sh_size);
 			map__set_pgoff(map, shdr->sh_offset);
-			map__set_map_ip(map, map__dso_map_ip);
+			map__set_mapping_type(map, MAPPING_TYPE__DSO);
-			map__set_unmap_ip(map, map__dso_unmap_ip);
 			/* Ensure maps are correctly ordered */
 			if (kmaps) {
 				int err;
 			map__set_end(curr_map, map__start(curr_map) + shdr->sh_size);
 			map__set_pgoff(curr_map, shdr->sh_offset);
 		} else {
-			map__set_map_ip(curr_map, identity__map_ip);
+			map__set_mapping_type(curr_map, MAPPING_TYPE__IDENTITY);
-			map__set_unmap_ip(curr_map, identity__map_ip);
 		}
 		curr_dso->symtab_type = dso->symtab_type;
 		if (maps__insert(kmaps, curr_map))

tools/perf/util/symbol-minimal.c+6−4

 				goto out_free;
 			ret = read_build_id(buf, buf_size, bid, need_swap);
-			if (ret == 0)
+			if (ret == 0) {
 				ret = bid->size;
-			break;
+				break;
+			}
 		}
 	} else {
 		Elf64_Ehdr ehdr;
 				goto out_free;
 			ret = read_build_id(buf, buf_size, bid, need_swap);
-			if (ret == 0)
+			if (ret == 0) {
 				ret = bid->size;
-			break;
+				break;
+			}
 		}
 	}
 out_free:

tools/perf/util/symbol.c+29−277

@@ -48,11 +48,6 @@ static bool symbol__is_idle(const char *name); · 47 unmodified lines
48	int vmlinux_path__nr_entries;	48	int vmlinux_path__nr_entries;
49	char **vmlinux_path;	49	char **vmlinux_path;
50		50
51	struct map_list_node {
52	struct list_head node;
53	struct map *map;
54	};
55
56	struct symbol_conf symbol_conf = {	51	struct symbol_conf symbol_conf = {
57	.nanosecs = false,	52	.nanosecs = false,
58	.use_modules = true,	53	.use_modules = true,
@@ -90,11 +85,6 @@ static enum dso_binary_type binary_type_symtab[] = { · 31 unmodified lines
90		85
91	#define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab)	86	#define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab)
92		87
93	static struct map_list_node *map_list_node__new(void)
94	{
95	return malloc(sizeof(struct map_list_node));
96	}
97
98	static bool symbol_type__filter(char symbol_type)	88	static bool symbol_type__filter(char symbol_type)
99	{	89	{
100	symbol_type = toupper(symbol_type);	90	symbol_type = toupper(symbol_type);
@@ -270,29 +260,6 @@ void symbols__fixup_end(struct rb_root_cached *symbols, bool is_kallsyms) · 169 unmodified lines
270	curr->end = roundup(curr->start, 4096) + 4096;	260	curr->end = roundup(curr->start, 4096) + 4096;
271	}	261	}
272		262
273	void maps__fixup_end(struct maps *maps)
274	{
275	struct map_rb_node prev = NULL, curr;
276
277	down_write(maps__lock(maps));
278
279	maps__for_each_entry(maps, curr) {
280	if (prev != NULL && !map__end(prev->map))
281	map__set_end(prev->map, map__start(curr->map));
282
283	prev = curr;
284	}
285
286	/*
287	* We still haven't the actual symbols, so guess the
288	* last map final address.
289	*/
290	if (curr && !map__end(curr->map))
291	map__set_end(curr->map, ~0ULL);
292
293	up_write(maps__lock(maps));
294	}
295
296	struct symbol symbol__new(u64 start, u64 len, u8 binding, u8 type, const char name)	263	struct symbol symbol__new(u64 start, u64 len, u8 binding, u8 type, const char name)
297	{	264	{
298	size_t namelen = strlen(name) + 1;	265	size_t namelen = strlen(name) + 1;
@@ -956,8 +923,7 @@ static int maps__split_kallsyms(struct maps kmaps, struct dso dso, u64 delta, · 657 unmodified lines
956	return -1;	923	return -1;
957	}	924	}
958		925
959	map__set_map_ip(curr_map, identity__map_ip);	926	map__set_mapping_type(curr_map, MAPPING_TYPE__IDENTITY);
960	map__set_unmap_ip(curr_map, identity__map_ip);
961	if (maps__insert(kmaps, curr_map)) {	927	if (maps__insert(kmaps, curr_map)) {
962	dso__put(ndso);	928	dso__put(ndso);
963	return -1;	929	return -1;
@@ -1148,33 +1114,35 @@ out_delete_from: · 184 unmodified lines
1148	return ret;	1114	return ret;
1149	}	1115	}
1150		1116
		1117	static int do_validate_kcore_modules_cb(struct map old_map, void data)
		1118	{
		1119	struct rb_root *modules = data;
		1120	struct module_info *mi;
		1121	struct dso *dso;
		1122
		1123	if (!__map__is_kmodule(old_map))
		1124	return 0;
		1125
		1126	dso = map__dso(old_map);
		1127	/* Module must be in memory at the same address */
		1128	mi = find_module(dso->short_name, modules);
		1129	if (!mi \|\| mi->start != map__start(old_map))
		1130	return -EINVAL;
		1131
		1132	return 0;
		1133	}
		1134
1151	static int do_validate_kcore_modules(const char filename, struct maps kmaps)	1135	static int do_validate_kcore_modules(const char filename, struct maps kmaps)
1152	{	1136	{
1153	struct rb_root modules = RB_ROOT;	1137	struct rb_root modules = RB_ROOT;
1154	struct map_rb_node *old_node;
1155	int err;	1138	int err;
1156		1139
1157	err = read_proc_modules(filename, &modules);	1140	err = read_proc_modules(filename, &modules);
1158	if (err)	1141	if (err)
1159	return err;	1142	return err;
1160		1143
1161	maps__for_each_entry(kmaps, old_node) {	1144	err = maps__for_each_map(kmaps, do_validate_kcore_modules_cb, &modules);
1162	struct map *old_map = old_node->map;
1163	struct module_info *mi;
1164	struct dso *dso;
1165		1145
1166	if (!__map__is_kmodule(old_map)) {
1167	continue;
1168	}
1169	dso = map__dso(old_map);
1170	/* Module must be in memory at the same address */
1171	mi = find_module(dso->short_name, &modules);
1172	if (!mi \|\| mi->start != map__start(old_map)) {
1173	err = -EINVAL;
1174	goto out;
1175	}
1176	}
1177	out:
1178	delete_modules(&modules);	1146	delete_modules(&modules);
1179	return err;	1147	return err;
1180	}	1148	}
@@ -1271,101 +1239,15 @@ static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data) · 90 unmodified lines
1271	return 0;	1239	return 0;
1272	}	1240	}
1273		1241
1274	/*	1242	static bool remove_old_maps(struct map map, void data)
1275	* Merges map into maps by splitting the new map within the existing map
1276	* regions.
1277	*/
1278	int maps__merge_in(struct maps kmaps, struct map new_map)
1279	{	1243	{
1280	struct map_rb_node *rb_node;	1244	const struct map *map_to_save = data;
1281	LIST_HEAD(merged);
1282	int err = 0;
1283
1284	maps__for_each_entry(kmaps, rb_node) {
1285	struct map *old_map = rb_node->map;
1286
1287	/* no overload with this one */
1288	if (map__end(new_map) < map__start(old_map) \|\|
1289	map__start(new_map) >= map__end(old_map))
1290	continue;
1291
1292	if (map__start(new_map) < map__start(old_map)) {
1293	/*
1294	* \|new......
1295	* \|old....
1296	*/
1297	if (map__end(new_map) < map__end(old_map)) {
1298	/*
1299	* \|new......\| -> \|new..\|
1300	* \|old....\| -> \|old....\|
1301	*/
1302	map__set_end(new_map, map__start(old_map));
1303	} else {
1304	/*
1305	* \|new.............\| -> \|new..\| \|new..\|
1306	* \|old....\| -> \|old....\|
1307	*/
1308	struct map_list_node *m = map_list_node__new();
1309
1310	if (!m) {
1311	err = -ENOMEM;
1312	goto out;
1313	}
1314
1315	m->map = map__clone(new_map);
1316	if (!m->map) {
1317	free(m);
1318	err = -ENOMEM;
1319	goto out;
1320	}
1321
1322	map__set_end(m->map, map__start(old_map));
1323	list_add_tail(&m->node, &merged);
1324	map__add_pgoff(new_map, map__end(old_map) - map__start(new_map));
1325	map__set_start(new_map, map__end(old_map));
1326	}
1327	} else {
1328	/*
1329	* \|new......
1330	* \|old....
1331	*/
1332	if (map__end(new_map) < map__end(old_map)) {
1333	/*
1334	* \|new..\| -> x
1335	* \|old.........\| -> \|old.........\|
1336	*/
1337	map__put(new_map);
1338	new_map = NULL;
1339	break;
1340	} else {
1341	/*
1342	* \|new......\| -> \|new...\|
1343	* \|old....\| -> \|old....\|
1344	*/
1345	map__add_pgoff(new_map, map__end(old_map) - map__start(new_map));
1346	map__set_start(new_map, map__end(old_map));
1347	}
1348	}
1349	}
1350
1351	out:
1352	while (!list_empty(&merged)) {
1353	struct map_list_node *old_node;
1354
1355	old_node = list_entry(merged.next, struct map_list_node, node);
1356	list_del_init(&old_node->node);
1357	if (!err)
1358	err = maps__insert(kmaps, old_node->map);
1359	map__put(old_node->map);
1360	free(old_node);
1361	}
1362		1245
1363	if (new_map) {	1246	/*
1364	if (!err)	1247	* We need to preserve eBPF maps even if they are covered by kcore,
1365	err = maps__insert(kmaps, new_map);	1248	* because we need to access eBPF dso for source data.
1366	map__put(new_map);	1249	*/
1367	}	1250	return !RC_CHK_EQUAL(map, map_to_save) && !__map__is_bpf_prog(map);
1368	return err;
1369	}	1251	}
1370		1252
1371	static int dso__load_kcore(struct dso dso, struct map map,	1253	static int dso__load_kcore(struct dso dso, struct map map,
@@ -1374,7 +1256,6 @@ static int dso__load_kcore(struct dso dso, struct map map, · 2 unmodified lines
1374	struct maps *kmaps = map__kmaps(map);	1256	struct maps *kmaps = map__kmaps(map);
1375	struct kcore_mapfn_data md;	1257	struct kcore_mapfn_data md;
1376	struct map *replacement_map = NULL;	1258	struct map *replacement_map = NULL;
1377	struct map_rb_node old_node, next;
1378	struct machine *machine;	1259	struct machine *machine;
1379	bool is_64_bit;	1260	bool is_64_bit;
1380	int err, fd;	1261	int err, fd;
@@ -1421,17 +1302,7 @@ static int dso__load_kcore(struct dso dso, struct map map, · 40 unmodified lines
1421	}	1302	}
1422		1303
1423	/* Remove old maps */	1304	/* Remove old maps */
1424	maps__for_each_entry_safe(kmaps, old_node, next) {	1305	maps__remove_maps(kmaps, remove_old_maps, map);
1425	struct map *old_map = old_node->map;
1426
1427	/*
1428	* We need to preserve eBPF maps even if they are
1429	* covered by kcore, because we need to access
1430	* eBPF dso for source data.
1431	*/
1432	if (old_map != map && !__map__is_bpf_prog(old_map))
1433	maps__remove(kmaps, old_map);
1434	}
1435	machine->trampolines_mapped = false;	1306	machine->trampolines_mapped = false;
1436		1307
1437	/* Find the kernel map using the '_stext' symbol */	1308	/* Find the kernel map using the '_stext' symbol */
@@ -1475,8 +1346,7 @@ static int dso__load_kcore(struct dso dso, struct map map, · 37 unmodified lines
1475	map__set_start(map, map__start(new_map));	1346	map__set_start(map, map__start(new_map));
1476	map__set_end(map, map__end(new_map));	1347	map__set_end(map, map__end(new_map));
1477	map__set_pgoff(map, map__pgoff(new_map));	1348	map__set_pgoff(map, map__pgoff(new_map));
1478	map__set_map_ip(map, map__map_ip_ptr(new_map));	1349	map__set_mapping_type(map, map__mapping_type(new_map));
1479	map__set_unmap_ip(map, map__unmap_ip_ptr(new_map));
1480	/* Ensure maps are correctly ordered */	1350	/* Ensure maps are correctly ordered */
1481	map_ref = map__get(map);	1351	map_ref = map__get(map);
1482	maps__remove(kmaps, map_ref);	1352	maps__remove(kmaps, map_ref);
@@ -2067,124 +1937,6 @@ out: · 584 unmodified lines
2067	return ret;	1937	return ret;
2068	}	1938	}
2069		1939
2070	static int map__strcmp(const void a, const void b)
2071	{
2072	const struct map map_a = (const struct map **)a;
2073	const struct map map_b = (const struct map **)b;
2074	const struct dso *dso_a = map__dso(map_a);
2075	const struct dso *dso_b = map__dso(map_b);
2076	int ret = strcmp(dso_a->short_name, dso_b->short_name);
2077
2078	if (ret == 0 && map_a != map_b) {
2079	/*
2080	* Ensure distinct but name equal maps have an order in part to
2081	* aid reference counting.
2082	*/
2083	ret = (int)map__start(map_a) - (int)map__start(map_b);
2084	if (ret == 0)
2085	ret = (int)((intptr_t)map_a - (intptr_t)map_b);
2086	}
2087
2088	return ret;
2089	}
2090
2091	static int map__strcmp_name(const void name, const void b)
2092	{
2093	const struct dso dso = map__dso((const struct map **)b);
2094
2095	return strcmp(name, dso->short_name);
2096	}
2097
2098	void __maps__sort_by_name(struct maps *maps)
2099	{
2100	qsort(maps__maps_by_name(maps), maps__nr_maps(maps), sizeof(struct map *), map__strcmp);
2101	}
2102
2103	static int map__groups__sort_by_name_from_rbtree(struct maps *maps)
2104	{
2105	struct map_rb_node *rb_node;
2106	struct map **maps_by_name = realloc(maps__maps_by_name(maps),
2107	maps__nr_maps(maps) * sizeof(struct map *));
2108	int i = 0;
2109
2110	if (maps_by_name == NULL)
2111	return -1;
2112
2113	up_read(maps__lock(maps));
2114	down_write(maps__lock(maps));
2115
2116	RC_CHK_ACCESS(maps)->maps_by_name = maps_by_name;
2117	RC_CHK_ACCESS(maps)->nr_maps_allocated = maps__nr_maps(maps);
2118
2119	maps__for_each_entry(maps, rb_node)
2120	maps_by_name[i++] = map__get(rb_node->map);
2121
2122	__maps__sort_by_name(maps);
2123
2124	up_write(maps__lock(maps));
2125	down_read(maps__lock(maps));
2126
2127	return 0;
2128	}
2129
2130	static struct map __maps__find_by_name(struct maps maps, const char *name)
2131	{
2132	struct map **mapp;
2133
2134	if (maps__maps_by_name(maps) == NULL &&
2135	map__groups__sort_by_name_from_rbtree(maps))
2136	return NULL;
2137
2138	mapp = bsearch(name, maps__maps_by_name(maps), maps__nr_maps(maps),
2139	sizeof(*mapp), map__strcmp_name);
2140	if (mapp)
2141	return *mapp;
2142	return NULL;
2143	}
2144
2145	struct map maps__find_by_name(struct maps maps, const char *name)
2146	{
2147	struct map_rb_node *rb_node;
2148	struct map *map;
2149
2150	down_read(maps__lock(maps));
2151
2152
2153	if (RC_CHK_ACCESS(maps)->last_search_by_name) {
2154	const struct dso *dso = map__dso(RC_CHK_ACCESS(maps)->last_search_by_name);
2155
2156	if (strcmp(dso->short_name, name) == 0) {
2157	map = RC_CHK_ACCESS(maps)->last_search_by_name;
2158	goto out_unlock;
2159	}
2160	}
2161	/*
2162	* If we have maps->maps_by_name, then the name isn't in the rbtree,
2163	* as maps->maps_by_name mirrors the rbtree when lookups by name are
2164	* made.
2165	*/
2166	map = __maps__find_by_name(maps, name);
2167	if (map \|\| maps__maps_by_name(maps) != NULL)
2168	goto out_unlock;
2169
2170	/* Fallback to traversing the rbtree... */
2171	maps__for_each_entry(maps, rb_node) {
2172	struct dso *dso;
2173
2174	map = rb_node->map;
2175	dso = map__dso(map);
2176	if (strcmp(dso->short_name, name) == 0) {
2177	RC_CHK_ACCESS(maps)->last_search_by_name = map;
2178	goto out_unlock;
2179	}
2180	}
2181	map = NULL;
2182
2183	out_unlock:
2184	up_read(maps__lock(maps));
2185	return map;
2186	}
2187
2188	int dso__load_vmlinux(struct dso dso, struct map map,	1940	int dso__load_vmlinux(struct dso dso, struct map map,
2189	const char *vmlinux, bool vmlinux_allocated)	1941	const char *vmlinux, bool vmlinux_allocated)
2190	{	1942	{

tools/perf/util/symbol.h+0−1

@@ -189,7 +189,6 @@ void __symbols__insert(struct rb_root_cached symbols, struct symbol sym, · 188 unmodified lines
189	void symbols__insert(struct rb_root_cached symbols, struct symbol sym);	189	void symbols__insert(struct rb_root_cached symbols, struct symbol sym);
190	void symbols__fixup_duplicate(struct rb_root_cached *symbols);	190	void symbols__fixup_duplicate(struct rb_root_cached *symbols);
191	void symbols__fixup_end(struct rb_root_cached *symbols, bool is_kallsyms);	191	void symbols__fixup_end(struct rb_root_cached *symbols, bool is_kallsyms);
192	void maps__fixup_end(struct maps *maps);
193		192
194	typedef int (mapfn_t)(u64 start, u64 len, u64 pgoff, void data);	193	typedef int (mapfn_t)(u64 start, u64 len, u64 pgoff, void data);
195	int file__read_maps(int fd, bool exe, mapfn_t mapfn, void *data,	194	int file__read_maps(int fd, bool exe, mapfn_t mapfn, void *data,

tools/perf/util/symbol_conf.h+5−1

 			inline_name,
 			disable_add2line_warn,
 			buildid_mmap2,
-			guest_code;
+			guest_code,
+			lazy_load_kernel_maps,
+			keep_exited_threads,
+			annotate_data_member,
+			annotate_data_sample;
 	const char	*vmlinux_name,
 			*kallsyms_name,
 			*source_prefix,

tools/perf/util/synthetic-events.c+67−51

 }
 #endif
+struct perf_event__synthesize_modules_maps_cb_args {
+	struct perf_tool *tool;
+	perf_event__handler_t process;
+	struct machine *machine;
+	union perf_event *event;
+};
+static int perf_event__synthesize_modules_maps_cb(struct map *map, void *data)
+{
+	struct perf_event__synthesize_modules_maps_cb_args *args = data;
+	union perf_event *event = args->event;
+	struct dso *dso;
+	size_t size;
+	if (!__map__is_kmodule(map))
+		return 0;
+	dso = map__dso(map);
+	if (symbol_conf.buildid_mmap2) {
+		size = PERF_ALIGN(dso->long_name_len + 1, sizeof(u64));
+		event->mmap2.header.type = PERF_RECORD_MMAP2;
+		event->mmap2.header.size = (sizeof(event->mmap2) -
+					(sizeof(event->mmap2.filename) - size));
+		memset(event->mmap2.filename + size, 0, args->machine->id_hdr_size);
+		event->mmap2.header.size += args->machine->id_hdr_size;
+		event->mmap2.start = map__start(map);
+		event->mmap2.len   = map__size(map);
+		event->mmap2.pid   = args->machine->pid;
+		memcpy(event->mmap2.filename, dso->long_name, dso->long_name_len + 1);
+		perf_record_mmap2__read_build_id(&event->mmap2, args->machine, false);
+	} else {
+		size = PERF_ALIGN(dso->long_name_len + 1, sizeof(u64));
+		event->mmap.header.type = PERF_RECORD_MMAP;
+		event->mmap.header.size = (sizeof(event->mmap) -
+					(sizeof(event->mmap.filename) - size));
+		memset(event->mmap.filename + size, 0, args->machine->id_hdr_size);
+		event->mmap.header.size += args->machine->id_hdr_size;
+		event->mmap.start = map__start(map);
+		event->mmap.len   = map__size(map);
+		event->mmap.pid   = args->machine->pid;
+		memcpy(event->mmap.filename, dso->long_name, dso->long_name_len + 1);
+	}
+	if (perf_tool__process_synth_event(args->tool, event, args->machine, args->process) != 0)
+		return -1;
+	return 0;
+}
 int perf_event__synthesize_modules(struct perf_tool *tool, perf_event__handler_t process,
 				   struct machine *machine)
 {
-	int rc = 0;
+	int rc;
-	struct map_rb_node *pos;
 	struct maps *maps = machine__kernel_maps(machine);
-	union perf_event *event;
+	struct perf_event__synthesize_modules_maps_cb_args args = {
-	size_t size = symbol_conf.buildid_mmap2 ?
+		.tool = tool,
-			sizeof(event->mmap2) : sizeof(event->mmap);
+		.process = process,
+		.machine = machine,
+	};
+	size_t size = symbol_conf.buildid_mmap2
+		? sizeof(args.event->mmap2)
+		: sizeof(args.event->mmap);
-	event = zalloc(size + machine->id_hdr_size);
+	args.event = zalloc(size + machine->id_hdr_size);
-	if (event == NULL) {
+	if (args.event == NULL) {
 		pr_debug("Not enough memory synthesizing mmap event "
 			 "for kernel modules\n");
 		return -1;
 	 * __perf_event_mmap
 	 */
 	if (machine__is_host(machine))
-		event->header.misc = PERF_RECORD_MISC_KERNEL;
+		args.event->header.misc = PERF_RECORD_MISC_KERNEL;
 	else
-		event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
+		args.event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
-	maps__for_each_entry(maps, pos) {
-		struct map *map = pos->map;
-		struct dso *dso;
-		if (!__map__is_kmodule(map))
+	rc = maps__for_each_map(maps, perf_event__synthesize_modules_maps_cb, &args);
-			continue;
-		dso = map__dso(map);
+	free(args.event);
-		if (symbol_conf.buildid_mmap2) {
-			size = PERF_ALIGN(dso->long_name_len + 1, sizeof(u64));
-			event->mmap2.header.type = PERF_RECORD_MMAP2;
-			event->mmap2.header.size = (sizeof(event->mmap2) -
-						(sizeof(event->mmap2.filename) - size));
-			memset(event->mmap2.filename + size, 0, machine->id_hdr_size);
-			event->mmap2.header.size += machine->id_hdr_size;
-			event->mmap2.start = map__start(map);
-			event->mmap2.len   = map__size(map);
-			event->mmap2.pid   = machine->pid;
-			memcpy(event->mmap2.filename, dso->long_name, dso->long_name_len + 1);
-			perf_record_mmap2__read_build_id(&event->mmap2, machine, false);
-		} else {
-			size = PERF_ALIGN(dso->long_name_len + 1, sizeof(u64));
-			event->mmap.header.type = PERF_RECORD_MMAP;
-			event->mmap.header.size = (sizeof(event->mmap) -
-						(sizeof(event->mmap.filename) - size));
-			memset(event->mmap.filename + size, 0, machine->id_hdr_size);
-			event->mmap.header.size += machine->id_hdr_size;
-			event->mmap.start = map__start(map);
-			event->mmap.len   = map__size(map);
-			event->mmap.pid   = machine->pid;
-			memcpy(event->mmap.filename, dso->long_name, dso->long_name_len + 1);
-		}
-		if (perf_tool__process_synth_event(tool, event, machine, process) != 0) {
-			rc = -1;
-			break;
-		}
-	}
-	free(event);
 	return rc;
 }

tools/perf/util/thread.c+20−22

 	if (ret)
 		return ret;
-	maps__fixup_overlappings(thread__maps(thread), map, stderr);
+	return maps__fixup_overlap_and_insert(thread__maps(thread), map);
-	return maps__insert(thread__maps(thread), map);
 }
-static int __thread__prepare_access(struct thread *thread)
+struct thread__prepare_access_maps_cb_args {
+	int err;
+	struct maps *maps;
+};
+static int thread__prepare_access_maps_cb(struct map *map, void *data)
 {
 	bool initialized = false;
-	int err = 0;
+	struct thread__prepare_access_maps_cb_args *args = data;
-	struct maps *maps = thread__maps(thread);
-	struct map_rb_node *rb_node;
-	down_read(maps__lock(maps));
-	maps__for_each_entry(maps, rb_node) {
-		err = unwind__prepare_access(thread__maps(thread), rb_node->map, &initialized);
-		if (err || initialized)
-			break;
-	}
-	up_read(maps__lock(maps));
+	args->err = unwind__prepare_access(args->maps, map, &initialized);
-	return err;
+	return (args->err || initialized) ? 1 : 0;
 }
 static int thread__prepare_access(struct thread *thread)
 {
-	int err = 0;
+	struct thread__prepare_access_maps_cb_args args = {
+		.err = 0,
+	};
-	if (dwarf_callchain_users)
+	if (dwarf_callchain_users) {
-		err = __thread__prepare_access(thread);
+		args.maps = thread__maps(thread);
+		maps__for_each_map(thread__maps(thread), thread__prepare_access_maps_cb, &args);
+	}
-	return err;
+	return args.err;
 }
 static int thread__clone_maps(struct thread *thread, struct thread *parent, bool do_maps_clone)
 	if (thread__pid(thread) == thread__pid(parent))
 		return thread__prepare_access(thread);
-	if (thread__maps(thread) == thread__maps(parent)) {
+	if (RC_CHK_EQUAL(thread__maps(thread), thread__maps(parent))) {
 		pr_debug("broken map groups on thread %d/%d parent %d/%d\n",
 			 thread__pid(thread), thread__tid(thread),
 			 thread__pid(parent), thread__tid(parent));
 		return 0;
 	}
 	/* But this one is new process, copy maps. */
-	return do_maps_clone ? maps__clone(thread, thread__maps(parent)) : 0;
+	return do_maps_clone ? maps__copy_from(thread__maps(thread), thread__maps(parent)) : 0;
 }
 int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp, bool do_maps_clone)

tools/perf/util/thread.h+14−0

 };
 DECLARE_RC_STRUCT(thread) {
+	/** @maps: mmaps associated with this thread. */
 	struct maps		*maps;
 	pid_t			pid_; /* Not all tools update this */
+	/** @tid: thread ID number unique to a machine. */
 	pid_t			tid;
+	/** @ppid: parent process of the process this thread belongs to. */
 	pid_t			ppid;
 	int			cpu;
 	int			guest_cpu; /* For QEMU thread */
 	refcount_t		refcnt;
+	/**
+	 * @exited: Has the thread had an exit event. Such threads are usually
+	 * removed from the machine's threads but some events/tools require
+	 * access to dead threads.
+	 */
+	bool			exited;
 	bool			comm_set;
 	int			comm_len;
 	struct list_head	namespaces_list;
 	return &RC_CHK_ACCESS(thread)->refcnt;
 }
+static inline void thread__set_exited(struct thread *thread, bool exited)
+{
+	RC_CHK_ACCESS(thread)->exited = exited;
+}
 static inline bool thread__comm_set(const struct thread *thread)
 {
 	return RC_CHK_ACCESS(thread)->comm_set;

tools/perf/util/top.c+4−5

 	struct record_opts *opts = &top->record_opts;
 	struct target *target = &opts->target;
 	size_t ret = 0;
+	int nr_cpus;
 	if (top->samples) {
 		samples_per_sec = top->samples / top->delay_secs;
 	else
 		ret += SNPRINTF(bf + ret, size - ret, " (all");
+	nr_cpus = perf_cpu_map__nr(top->evlist->core.user_requested_cpus);
 	if (target->cpu_list)
 		ret += SNPRINTF(bf + ret, size - ret, ", CPU%s: %s)",
-				perf_cpu_map__nr(top->evlist->core.user_requested_cpus) > 1
+				nr_cpus > 1 ? "s" : "",
-				? "s" : "",
 				target->cpu_list);
 	else {
 		if (target->tid)
 			ret += SNPRINTF(bf + ret, size - ret, ")");
 		else
 			ret += SNPRINTF(bf + ret, size - ret, ", %d CPU%s)",
-					perf_cpu_map__nr(top->evlist->core.user_requested_cpus),
+					nr_cpus, nr_cpus > 1 ? "s" : "");
-					perf_cpu_map__nr(top->evlist->core.user_requested_cpus) > 1
-					? "s" : "");
 	}
 	perf_top__reset_sample_counters(top);

tools/perf/util/top.h+0−1

@@ -21,7 +21,6 @@ struct perf_top { · 20 unmodified lines
21	struct perf_tool tool;	21	struct perf_tool tool;
22	struct evlist evlist, sb_evlist;	22	struct evlist evlist, sb_evlist;
23	struct record_opts record_opts;	23	struct record_opts record_opts;
24	struct annotation_options annotation_opts;
25	struct evswitch evswitch;	24	struct evswitch evswitch;
26	/*	25	/*
27	* Symbols will be added here in perf_event__process_sample and will	26	* Symbols will be added here in perf_event__process_sample and will

tools/perf/util/unwind-libdw.c+17−4

 {
 	Dwfl_Module *mod;
 	struct dso *dso = NULL;
+	Dwarf_Addr base;
 	/*
 	 * Some callers will use al->sym, so we can't just use the
 	 * cheaper thread__find_map() here.
 	if (!dso)
 		return 0;
+	/*
+	 * The generated JIT DSO files only map the code segment without
+	 * ELF headers.  Since JIT codes used to be packed in a memory
+	 * segment, calculating the base address using pgoff falls into
+	 * a different code in another DSO.  So just use the map->start
+	 * directly to pick the correct one.
+	 */
+	if (!strncmp(dso->long_name, "/tmp/jitted-", 12))
+		base = map__start(al->map);
+	else
+		base = map__start(al->map) - map__pgoff(al->map);
 	mod = dwfl_addrmodule(ui->dwfl, ip);
 	if (mod) {
 		Dwarf_Addr s;
 		dwfl_module_info(mod, NULL, &s, NULL, NULL, NULL, NULL, NULL);
-		if (s != map__start(al->map) - map__pgoff(al->map))
+		if (s != base)
-			mod = 0;
+			mod = NULL;
 	}
 	if (!mod) {
 		__symbol__join_symfs(filename, sizeof(filename), dso->long_name);
 		mod = dwfl_report_elf(ui->dwfl, dso->short_name, filename, -1,
-				      map__start(al->map) - map__pgoff(al->map), false);
+				      base, false);
 	}
 	if (!mod) {
 		char filename[PATH_MAX];
 		if (dso__build_id_filename(dso, filename, sizeof(filename), false))
 			mod = dwfl_report_elf(ui->dwfl, dso->short_name, filename, -1,
-					      map__start(al->map) - map__pgoff(al->map), false);
+					      base, false);
 	}
 	if (mod) {

tools/perf/util/unwind-libunwind-local.c+24−10

 	return 0;
 }
+struct read_unwind_spec_eh_frame_maps_cb_args {
+	struct dso *dso;
+	u64 base_addr;
+};
+static int read_unwind_spec_eh_frame_maps_cb(struct map *map, void *data)
+{
+	struct read_unwind_spec_eh_frame_maps_cb_args *args = data;
+	if (map__dso(map) == args->dso && map__start(map) - map__pgoff(map) < args->base_addr)
+		args->base_addr = map__start(map) - map__pgoff(map);
+	return 0;
+}
 static int read_unwind_spec_eh_frame(struct dso *dso, struct unwind_info *ui,
 				     u64 *table_data, u64 *segbase,
 				     u64 *fde_count)
 {
-	struct map_rb_node *map_node;
+	struct read_unwind_spec_eh_frame_maps_cb_args args = {
-	u64 base_addr = UINT64_MAX;
+		.dso = dso,
+		.base_addr = UINT64_MAX,
+	};
 	int ret, fd;
 	if (dso->data.eh_frame_hdr_offset == 0) {
 			return -EINVAL;
 	}
-	maps__for_each_entry(thread__maps(ui->thread), map_node) {
+	maps__for_each_map(thread__maps(ui->thread), read_unwind_spec_eh_frame_maps_cb, &args);
-		struct map *map = map_node->map;
-		u64 start = map__start(map);
-		if (map__dso(map) == dso && start < base_addr)
+	args.base_addr -= dso->data.elf_base_addr;
-			base_addr = start;
-	}
-	base_addr -= dso->data.elf_base_addr;
 	/* Address of .eh_frame_hdr */
-	*segbase = base_addr + dso->data.eh_frame_hdr_addr;
+	*segbase = args.base_addr + dso->data.eh_frame_hdr_addr;
 	ret = unwind_spec_ehframe(dso, ui->machine, dso->data.eh_frame_hdr_offset,
 				   table_data, fde_count);
 	if (ret)

tools/perf/util/vdso.c+23−12

@@ -140,23 +140,34 @@ static struct dso __machine__addnew_vdso(struct machine machine, const char *s · 139 unmodified lines
140	return dso;	140	return dso;
141	}	141	}
142		142
		143	struct machine__thread_dso_type_maps_cb_args {
		144	struct machine *machine;
		145	enum dso_type dso_type;
		146	};
		147
		148	static int machine__thread_dso_type_maps_cb(struct map map, void data)
		149	{
		150	struct machine__thread_dso_type_maps_cb_args *args = data;
		151	struct dso *dso = map__dso(map);
		152
		153	if (!dso \|\| dso->long_name[0] != '/')
		154	return 0;
		155
		156	args->dso_type = dso__type(dso, args->machine);
		157	return (args->dso_type != DSO__TYPE_UNKNOWN) ? 1 : 0;
		158	}
		159
143	static enum dso_type machine__thread_dso_type(struct machine *machine,	160	static enum dso_type machine__thread_dso_type(struct machine *machine,
144	struct thread *thread)	161	struct thread *thread)
145	{	162	{
146	enum dso_type dso_type = DSO__TYPE_UNKNOWN;	163	struct machine__thread_dso_type_maps_cb_args args = {
147	struct map_rb_node *rb_node;	164	.machine = machine,
148		165	.dso_type = DSO__TYPE_UNKNOWN,
149	maps__for_each_entry(thread__maps(thread), rb_node) {	166	};
150	struct dso *dso = map__dso(rb_node->map);
151		167
152	if (!dso \|\| dso->long_name[0] != '/')	168	maps__for_each_map(thread__maps(thread), machine__thread_dso_type_maps_cb, &args);
153	continue;
154	dso_type = dso__type(dso, machine);
155	if (dso_type != DSO__TYPE_UNKNOWN)
156	break;
157	}
158		169
159	return dso_type;	170	return args.dso_type;
160	}	171	}
161		172
162	#if BITS_PER_LONG == 64	173	#if BITS_PER_LONG == 64

tools/perf/util/zstd.c+33−30

@@ -7,35 +7,9 @@ · 6 unmodified lines
7		7
8	int zstd_init(struct zstd_data *data, int level)	8	int zstd_init(struct zstd_data *data, int level)
9	{	9	{
10	size_t ret;	10	data->comp_level = level;
11		11	data->dstream = NULL;
12	data->dstream = ZSTD_createDStream();	12	data->cstream = NULL;
13	if (data->dstream == NULL) {
14	pr_err("Couldn't create decompression stream.\n");
15	return -1;
16	}
17
18	ret = ZSTD_initDStream(data->dstream);
19	if (ZSTD_isError(ret)) {
20	pr_err("Failed to initialize decompression stream: %s\n", ZSTD_getErrorName(ret));
21	return -1;
22	}
23
24	if (!level)
25	return 0;
26
27	data->cstream = ZSTD_createCStream();
28	if (data->cstream == NULL) {
29	pr_err("Couldn't create compression stream.\n");
30	return -1;
31	}
32
33	ret = ZSTD_initCStream(data->cstream, level);
34	if (ZSTD_isError(ret)) {
35	pr_err("Failed to initialize compression stream: %s\n", ZSTD_getErrorName(ret));
36	return -1;
37	}
38
39	return 0;	13	return 0;
40	}	14	}
41		15
@@ -54,7 +28,7 @@ int zstd_fini(struct zstd_data *data) · 12 unmodified lines
54	return 0;	28	return 0;
55	}	29	}
56		30
57	size_t zstd_compress_stream_to_records(struct zstd_data data, void dst, size_t dst_size,	31	ssize_t zstd_compress_stream_to_records(struct zstd_data data, void dst, size_t dst_size,
58	void *src, size_t src_size, size_t max_record_size,	32	void *src, size_t src_size, size_t max_record_size,
59	size_t process_header(void *record, size_t increment))	33	size_t process_header(void *record, size_t increment))
60	{	34	{
@@ -63,6 +37,21 @@ size_t zstd_compress_stream_to_records(struct zstd_data data, void dst, size_t · 2 unmodified lines
63	ZSTD_outBuffer output;	37	ZSTD_outBuffer output;
64	void *record;	38	void *record;
65		39
		40	if (!data->cstream) {
		41	data->cstream = ZSTD_createCStream();
		42	if (data->cstream == NULL) {
		43	pr_err("Couldn't create compression stream.\n");
		44	return -1;
		45	}
		46
		47	ret = ZSTD_initCStream(data->cstream, data->comp_level);
		48	if (ZSTD_isError(ret)) {
		49	pr_err("Failed to initialize compression stream: %s\n",
		50	ZSTD_getErrorName(ret));
		51	return -1;
		52	}
		53	}
		54
66	while (input.pos < input.size) {	55	while (input.pos < input.size) {
67	record = dst;	56	record = dst;
68	size = process_header(record, 0);	57	size = process_header(record, 0);
@@ -96,6 +85,20 @@ size_t zstd_decompress_stream(struct zstd_data data, void src, size_t src_size · 27 unmodified lines
96	ZSTD_inBuffer input = { src, src_size, 0 };	85	ZSTD_inBuffer input = { src, src_size, 0 };
97	ZSTD_outBuffer output = { dst, dst_size, 0 };	86	ZSTD_outBuffer output = { dst, dst_size, 0 };
98		87
		88	if (!data->dstream) {
		89	data->dstream = ZSTD_createDStream();
		90	if (data->dstream == NULL) {
		91	pr_err("Couldn't create decompression stream.\n");
		92	return 0;
		93	}
		94
		95	ret = ZSTD_initDStream(data->dstream);
		96	if (ZSTD_isError(ret)) {
		97	pr_err("Failed to initialize decompression stream: %s\n",
		98	ZSTD_getErrorName(ret));
		99	return 0;
		100	}
		101	}
99	while (input.pos < input.size) {	102	while (input.pos < input.size) {
100	ret = ZSTD_decompressStream(data->dstream, &output, &input);	103	ret = ZSTD_decompressStream(data->dstream, &output, &input);
101	if (ZSTD_isError(ret)) {	104	if (ZSTD_isError(ret)) {

@@ -369,7 +369,7 @@ static int intel_pt_info_fill(struct auxtrace_record *itr, · 368 unmodified lines
369	ui__warning("Intel Processor Trace: TSC not available\n");	369	ui__warning("Intel Processor Trace: TSC not available\n");
370	}	370	}
371		371
372	per_cpu_mmaps = !perf_cpu_map__empty(session->evlist->core.user_requested_cpus);	372	per_cpu_mmaps = !perf_cpu_map__has_any_cpu_or_is_empty(session->evlist->core.user_requested_cpus);
373		373
374	auxtrace_info->type = PERF_AUXTRACE_INTEL_PT;	374	auxtrace_info->type = PERF_AUXTRACE_INTEL_PT;
375	auxtrace_info->priv[INTEL_PT_PMU_TYPE] = intel_pt_pmu->type;	375	auxtrace_info->priv[INTEL_PT_PMU_TYPE] = intel_pt_pmu->type;
@@ -774,7 +774,7 @@ static int intel_pt_recording_options(struct auxtrace_record *itr, · 398 unmodified lines
774	* Per-cpu recording needs sched_switch events to distinguish different	774	* Per-cpu recording needs sched_switch events to distinguish different
775	* threads.	775	* threads.
776	*/	776	*/
777	if (have_timing_info && !perf_cpu_map__empty(cpus) &&	777	if (have_timing_info && !perf_cpu_map__has_any_cpu_or_is_empty(cpus) &&
778	!record_opts__no_switch_events(opts)) {	778	!record_opts__no_switch_events(opts)) {
779	if (perf_can_record_switch_events()) {	779	if (perf_can_record_switch_events()) {
780	bool cpu_wide = !target__none(&opts->target) &&	780	bool cpu_wide = !target__none(&opts->target) &&
@@ -832,7 +832,7 @@ static int intel_pt_recording_options(struct auxtrace_record *itr, · 51 unmodified lines
832	* In the case of per-cpu mmaps, we need the CPU on the	832	* In the case of per-cpu mmaps, we need the CPU on the
833	* AUX event.	833	* AUX event.
834	*/	834	*/
835	if (!perf_cpu_map__empty(cpus))	835	if (!perf_cpu_map__has_any_cpu_or_is_empty(cpus))
836	evsel__set_sample_bit(intel_pt_evsel, CPU);	836	evsel__set_sample_bit(intel_pt_evsel, CPU);
837	}	837	}
838		838
@@ -858,7 +858,7 @@ static int intel_pt_recording_options(struct auxtrace_record *itr, · 19 unmodified lines
858	tracking_evsel->immediate = true;	858	tracking_evsel->immediate = true;
859		859
860	/* In per-cpu case, always need the time of mmap events etc */	860	/* In per-cpu case, always need the time of mmap events etc */
861	if (!perf_cpu_map__empty(cpus)) {	861	if (!perf_cpu_map__has_any_cpu_or_is_empty(cpus)) {
862	evsel__set_sample_bit(tracking_evsel, TIME);	862	evsel__set_sample_bit(tracking_evsel, TIME);
863	/* And the CPU for switch events */	863	/* And the CPU for switch events */
864	evsel__set_sample_bit(tracking_evsel, CPU);	864	evsel__set_sample_bit(tracking_evsel, CPU);
@@ -870,7 +870,7 @@ static int intel_pt_recording_options(struct auxtrace_record *itr, · 5 unmodified lines
870	* Warn the user when we do not have enough information to decode i.e.	870	* Warn the user when we do not have enough information to decode i.e.
871	* per-cpu with no sched_switch (except workload-only).	871	* per-cpu with no sched_switch (except workload-only).
872	*/	872	*/
873	if (!ptr->have_sched_switch && !perf_cpu_map__empty(cpus) &&	873	if (!ptr->have_sched_switch && !perf_cpu_map__has_any_cpu_or_is_empty(cpus) &&
874	!target__none(&opts->target) &&	874	!target__none(&opts->target) &&
875	!intel_pt_evsel->core.attr.exclude_user)	875	!intel_pt_evsel->core.attr.exclude_user)
876	ui__warning("Intel Processor Trace decoding will not be possible except for kernel tracing!\n");	876	ui__warning("Intel Processor Trace decoding will not be possible except for kernel tracing!\n");

@@ -7,7 +7,7 @@ GenuineIntel-6-56,v11,broadwellde,core · 6 unmodified lines
7	GenuineIntel-6-4F,v22,broadwellx,core	7	GenuineIntel-6-4F,v22,broadwellx,core
8	GenuineIntel-6-55-[56789ABCDEF],v1.20,cascadelakex,core	8	GenuineIntel-6-55-[56789ABCDEF],v1.20,cascadelakex,core
9	GenuineIntel-6-9[6C],v1.04,elkhartlake,core	9	GenuineIntel-6-9[6C],v1.04,elkhartlake,core
10	GenuineIntel-6-CF,v1.01,emeraldrapids,core	10	GenuineIntel-6-CF,v1.02,emeraldrapids,core
11	GenuineIntel-6-5[CF],v13,goldmont,core	11	GenuineIntel-6-5[CF],v13,goldmont,core
12	GenuineIntel-6-7A,v1.01,goldmontplus,core	12	GenuineIntel-6-7A,v1.01,goldmontplus,core
13	GenuineIntel-6-B6,v1.00,grandridge,core	13	GenuineIntel-6-B6,v1.00,grandridge,core
@@ -15,7 +15,7 @@ GenuineIntel-6-A[DE],v1.01,graniterapids,core · 1 unmodified line
15	GenuineIntel-6-(3C\|45\|46),v33,haswell,core	15	GenuineIntel-6-(3C\|45\|46),v33,haswell,core
16	GenuineIntel-6-3F,v28,haswellx,core	16	GenuineIntel-6-3F,v28,haswellx,core
17	GenuineIntel-6-7[DE],v1.19,icelake,core	17	GenuineIntel-6-7[DE],v1.19,icelake,core
18	GenuineIntel-6-6[AC],v1.21,icelakex,core	18	GenuineIntel-6-6[AC],v1.23,icelakex,core
19	GenuineIntel-6-3A,v24,ivybridge,core	19	GenuineIntel-6-3A,v24,ivybridge,core
20	GenuineIntel-6-3E,v24,ivytown,core	20	GenuineIntel-6-3E,v24,ivytown,core
21	GenuineIntel-6-2D,v24,jaketown,core	21	GenuineIntel-6-2D,v24,jaketown,core
@@ -26,7 +26,7 @@ GenuineIntel-6-1[AEF],v4,nehalemep,core · 4 unmodified lines
26	GenuineIntel-6-2E,v4,nehalemex,core	26	GenuineIntel-6-2E,v4,nehalemex,core
27	GenuineIntel-6-A7,v1.01,rocketlake,core	27	GenuineIntel-6-A7,v1.01,rocketlake,core
28	GenuineIntel-6-2A,v19,sandybridge,core	28	GenuineIntel-6-2A,v19,sandybridge,core
29	GenuineIntel-6-8F,v1.16,sapphirerapids,core	29	GenuineIntel-6-8F,v1.17,sapphirerapids,core
30	GenuineIntel-6-AF,v1.00,sierraforest,core	30	GenuineIntel-6-AF,v1.00,sierraforest,core
31	GenuineIntel-6-(37\|4A\|4C\|4D\|5A),v15,silvermont,core	31	GenuineIntel-6-(37\|4A\|4C\|4D\|5A),v15,silvermont,core
32	GenuineIntel-6-(4E\|5E\|8E\|9E\|A5\|A6),v57,skylake,core	32	GenuineIntel-6-(4E\|5E\|8E\|9E\|A5\|A6),v57,skylake,core