perf tools: Add ARM Statistical Profiling Extensions (SPE) support (ffd3d18c) · Commits · 戴 / test

tools/perf/arch/arm/util/auxtrace.c

+71 −6

Original line number	Original line	Diff line number	Diff line
	@@ -22,6 +22,42 @@
	#include "../../util/evlist.h"		#include "../../util/evlist.h"
	#include "../../util/pmu.h"		#include "../../util/pmu.h"
	#include "cs-etm.h"		#include "cs-etm.h"
			#include "arm-spe.h"

			static struct perf_pmu *find_all_arm_spe_pmus(int nr_spes, int *err)
			{
			struct perf_pmu **arm_spe_pmus = NULL;
			int ret, i, nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
			/* arm_spe_xxxxxxxxx\0 */
			char arm_spe_pmu_name[sizeof(ARM_SPE_PMU_NAME) + 10];

			arm_spe_pmus = zalloc(sizeof(struct perf_pmu ) nr_cpus);
			if (!arm_spe_pmus) {
			pr_err("spes alloc failed\n");
			*err = -ENOMEM;
			return NULL;
			}

			for (i = 0; i < nr_cpus; i++) {
			ret = sprintf(arm_spe_pmu_name, "%s%d", ARM_SPE_PMU_NAME, i);
			if (ret < 0) {
			pr_err("sprintf failed\n");
			*err = -ENOMEM;
			return NULL;
			}

			arm_spe_pmus[*nr_spes] = perf_pmu__find(arm_spe_pmu_name);
			if (arm_spe_pmus[*nr_spes]) {
			pr_debug2("%s %d: arm_spe_pmu %d type %d name %s\n",
			__func__, __LINE__, *nr_spes,
			arm_spe_pmus[*nr_spes]->type,
			arm_spe_pmus[*nr_spes]->name);
			(*nr_spes)++;
			}
			}

			return arm_spe_pmus;
			}

	struct auxtrace_record		struct auxtrace_record
	auxtrace_record__init(struct perf_evlist evlist, int *err)		auxtrace_record__init(struct perf_evlist evlist, int *err)
	@@ -29,22 +65,51 @@ struct auxtrace_record
	struct perf_pmu *cs_etm_pmu;		struct perf_pmu *cs_etm_pmu;
	struct perf_evsel *evsel;		struct perf_evsel *evsel;
	bool found_etm = false;		bool found_etm = false;
			bool found_spe = false;
			static struct perf_pmu **arm_spe_pmus = NULL;
			static int nr_spes = 0;
			int i;

			if (!evlist)
			return NULL;

	cs_etm_pmu = perf_pmu__find(CORESIGHT_ETM_PMU_NAME);		cs_etm_pmu = perf_pmu__find(CORESIGHT_ETM_PMU_NAME);

	if (evlist) {		if (!arm_spe_pmus)
			arm_spe_pmus = find_all_arm_spe_pmus(&nr_spes, err);

	evlist__for_each_entry(evlist, evsel) {		evlist__for_each_entry(evlist, evsel) {
	if (cs_etm_pmu &&		if (cs_etm_pmu &&
	evsel->attr.type == cs_etm_pmu->type)		evsel->attr.type == cs_etm_pmu->type)
	found_etm = true;		found_etm = true;

			if (!nr_spes)
			continue;

			for (i = 0; i < nr_spes; i++) {
			if (evsel->attr.type == arm_spe_pmus[i]->type) {
			found_spe = true;
			break;
			}
	}		}
	}		}

			if (found_etm && found_spe) {
			pr_err("Concurrent ARM Coresight ETM and SPE operation not currently supported\n");
			*err = -EOPNOTSUPP;
			return NULL;
			}

	if (found_etm)		if (found_etm)
	return cs_etm_record_init(err);		return cs_etm_record_init(err);

			#if defined(__aarch64__)
			if (found_spe)
			return arm_spe_recording_init(err, arm_spe_pmus[i]);
			#endif

	/*		/*
	* Clear 'err' even if we haven't found a cs_etm event - that way perf		* Clear 'err' even if we haven't found an event - that way perf
	* record can still be used even if tracers aren't present. The NULL		* record can still be used even if tracers aren't present. The NULL
	* return value will take care of telling the infrastructure HW tracing		* return value will take care of telling the infrastructure HW tracing
	* isn't available.		* isn't available.

tools/perf/arch/arm/util/pmu.c

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -20,6 +20,7 @@
	#include <linux/perf_event.h>		#include <linux/perf_event.h>

	#include "cs-etm.h"		#include "cs-etm.h"
			#include "arm-spe.h"
	#include "../../util/pmu.h"		#include "../../util/pmu.h"

	struct perf_event_attr		struct perf_event_attr
	@@ -30,7 +31,12 @@ struct perf_event_attr
	/* add ETM default config here */		/* add ETM default config here */
	pmu->selectable = true;		pmu->selectable = true;
	pmu->set_drv_config = cs_etm_set_drv_config;		pmu->set_drv_config = cs_etm_set_drv_config;
			#if defined(__aarch64__)
			} else if (strstarts(pmu->name, ARM_SPE_PMU_NAME)) {
			return arm_spe_pmu_default_config(pmu);
			#endif
	}		}

	#endif		#endif
	return NULL;		return NULL;
	}		}

tools/perf/arch/arm64/util/Build

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -5,4 +5,5 @@ libperf-$(CONFIG_LOCAL_LIBUNWIND) += unwind-libunwind.o

	libperf-$(CONFIG_AUXTRACE) += ../../arm/util/pmu.o \		libperf-$(CONFIG_AUXTRACE) += ../../arm/util/pmu.o \
	../../arm/util/auxtrace.o \		../../arm/util/auxtrace.o \
	../../arm/util/cs-etm.o		../../arm/util/cs-etm.o \
			arm-spe.o

tools/perf/arch/arm64/util/arm-spe.c

0 → 100644

+225 −0

Original line number	Original line	Diff line number	Diff line
			// SPDX-License-Identifier: GPL-2.0
			/*
			* Arm Statistical Profiling Extensions (SPE) support
			* Copyright (c) 2017-2018, Arm Ltd.
			*/

			#include <linux/kernel.h>
			#include <linux/types.h>
			#include <linux/bitops.h>
			#include <linux/log2.h>
			#include <time.h>

			#include "../../util/cpumap.h"
			#include "../../util/evsel.h"
			#include "../../util/evlist.h"
			#include "../../util/session.h"
			#include "../../util/util.h"
			#include "../../util/pmu.h"
			#include "../../util/debug.h"
			#include "../../util/auxtrace.h"
			#include "../../util/arm-spe.h"

			#define KiB(x) ((x) * 1024)
			#define MiB(x) ((x) * 1024 * 1024)

			struct arm_spe_recording {
			struct auxtrace_record itr;
			struct perf_pmu *arm_spe_pmu;
			struct perf_evlist *evlist;
			};

			static size_t
			arm_spe_info_priv_size(struct auxtrace_record *itr __maybe_unused,
			struct perf_evlist *evlist __maybe_unused)
			{
			return ARM_SPE_AUXTRACE_PRIV_SIZE;
			}

			static int arm_spe_info_fill(struct auxtrace_record *itr,
			struct perf_session *session,
			struct auxtrace_info_event *auxtrace_info,
			size_t priv_size)
			{
			struct arm_spe_recording *sper =
			container_of(itr, struct arm_spe_recording, itr);
			struct perf_pmu *arm_spe_pmu = sper->arm_spe_pmu;

			if (priv_size != ARM_SPE_AUXTRACE_PRIV_SIZE)
			return -EINVAL;

			if (!session->evlist->nr_mmaps)
			return -EINVAL;

			auxtrace_info->type = PERF_AUXTRACE_ARM_SPE;
			auxtrace_info->priv[ARM_SPE_PMU_TYPE] = arm_spe_pmu->type;

			return 0;
			}

			static int arm_spe_recording_options(struct auxtrace_record *itr,
			struct perf_evlist *evlist,
			struct record_opts *opts)
			{
			struct arm_spe_recording *sper =
			container_of(itr, struct arm_spe_recording, itr);
			struct perf_pmu *arm_spe_pmu = sper->arm_spe_pmu;
			struct perf_evsel evsel, arm_spe_evsel = NULL;
			bool privileged = geteuid() == 0 \|\| perf_event_paranoid() < 0;
			struct perf_evsel *tracking_evsel;
			int err;

			sper->evlist = evlist;

			evlist__for_each_entry(evlist, evsel) {
			if (evsel->attr.type == arm_spe_pmu->type) {
			if (arm_spe_evsel) {
			pr_err("There may be only one " ARM_SPE_PMU_NAME "x event\n");
			return -EINVAL;
			}
			evsel->attr.freq = 0;
			evsel->attr.sample_period = 1;
			arm_spe_evsel = evsel;
			opts->full_auxtrace = true;
			}
			}

			if (!opts->full_auxtrace)
			return 0;

			/* We are in full trace mode but '-m,xyz' wasn't specified */
			if (opts->full_auxtrace && !opts->auxtrace_mmap_pages) {
			if (privileged) {
			opts->auxtrace_mmap_pages = MiB(4) / page_size;
			} else {
			opts->auxtrace_mmap_pages = KiB(128) / page_size;
			if (opts->mmap_pages == UINT_MAX)
			opts->mmap_pages = KiB(256) / page_size;
			}
			}

			/* Validate auxtrace_mmap_pages */
			if (opts->auxtrace_mmap_pages) {
			size_t sz = opts->auxtrace_mmap_pages * (size_t)page_size;
			size_t min_sz = KiB(8);

			if (sz < min_sz \|\| !is_power_of_2(sz)) {
			pr_err("Invalid mmap size for ARM SPE: must be at least %zuKiB and a power of 2\n",
			min_sz / 1024);
			return -EINVAL;
			}
			}


			/*
			* To obtain the auxtrace buffer file descriptor, the auxtrace event
			* must come first.
			*/
			perf_evlist__to_front(evlist, arm_spe_evsel);

			perf_evsel__set_sample_bit(arm_spe_evsel, CPU);
			perf_evsel__set_sample_bit(arm_spe_evsel, TIME);
			perf_evsel__set_sample_bit(arm_spe_evsel, TID);

			/* Add dummy event to keep tracking */
			err = parse_events(evlist, "dummy:u", NULL);
			if (err)
			return err;

			tracking_evsel = perf_evlist__last(evlist);
			perf_evlist__set_tracking_event(evlist, tracking_evsel);

			tracking_evsel->attr.freq = 0;
			tracking_evsel->attr.sample_period = 1;
			perf_evsel__set_sample_bit(tracking_evsel, TIME);
			perf_evsel__set_sample_bit(tracking_evsel, CPU);
			perf_evsel__reset_sample_bit(tracking_evsel, BRANCH_STACK);

			return 0;
			}

			static u64 arm_spe_reference(struct auxtrace_record *itr __maybe_unused)
			{
			struct timespec ts;

			clock_gettime(CLOCK_MONOTONIC_RAW, &ts);

			return ts.tv_sec ^ ts.tv_nsec;
			}

			static void arm_spe_recording_free(struct auxtrace_record *itr)
			{
			struct arm_spe_recording *sper =
			container_of(itr, struct arm_spe_recording, itr);

			free(sper);
			}

			static int arm_spe_read_finish(struct auxtrace_record *itr, int idx)
			{
			struct arm_spe_recording *sper =
			container_of(itr, struct arm_spe_recording, itr);
			struct perf_evsel *evsel;

			evlist__for_each_entry(sper->evlist, evsel) {
			if (evsel->attr.type == sper->arm_spe_pmu->type)
			return perf_evlist__enable_event_idx(sper->evlist,
			evsel, idx);
			}
			return -EINVAL;
			}

			struct auxtrace_record arm_spe_recording_init(int err,
			struct perf_pmu *arm_spe_pmu)
			{
			struct arm_spe_recording *sper;

			if (!arm_spe_pmu) {
			*err = -ENODEV;
			return NULL;
			}

			sper = zalloc(sizeof(struct arm_spe_recording));
			if (!sper) {
			*err = -ENOMEM;
			return NULL;
			}

			sper->arm_spe_pmu = arm_spe_pmu;
			sper->itr.recording_options = arm_spe_recording_options;
			sper->itr.info_priv_size = arm_spe_info_priv_size;
			sper->itr.info_fill = arm_spe_info_fill;
			sper->itr.free = arm_spe_recording_free;
			sper->itr.reference = arm_spe_reference;
			sper->itr.read_finish = arm_spe_read_finish;
			sper->itr.alignment = 0;

			return &sper->itr;
			}

			struct perf_event_attr
			arm_spe_pmu_default_config(struct perf_pmu arm_spe_pmu)
			{
			struct perf_event_attr *attr;

			attr = zalloc(sizeof(struct perf_event_attr));
			if (!attr) {
			pr_err("arm_spe default config cannot allocate a perf_event_attr\n");
			return NULL;
			}

			/*
			* If kernel driver doesn't advertise a minimum,
			* use max allowable by PMSIDR_EL1.INTERVAL
			*/
			if (perf_pmu__scan_file(arm_spe_pmu, "caps/min_interval", "%llu",
			&attr->sample_period) != 1) {
			pr_debug("arm_spe driver doesn't advertise a min. interval. Using 4096\n");
			attr->sample_period = 4096;
			}

			arm_spe_pmu->selectable = true;
			arm_spe_pmu->is_uncore = false;

			return attr;
			}

tools/perf/util/Build

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -86,6 +86,8 @@ libperf-$(CONFIG_AUXTRACE) += auxtrace.o
	libperf-$(CONFIG_AUXTRACE) += intel-pt-decoder/		libperf-$(CONFIG_AUXTRACE) += intel-pt-decoder/
	libperf-$(CONFIG_AUXTRACE) += intel-pt.o		libperf-$(CONFIG_AUXTRACE) += intel-pt.o
	libperf-$(CONFIG_AUXTRACE) += intel-bts.o		libperf-$(CONFIG_AUXTRACE) += intel-bts.o
			libperf-$(CONFIG_AUXTRACE) += arm-spe.o
			libperf-$(CONFIG_AUXTRACE) += arm-spe-pkt-decoder.o
	libperf-y += parse-branch-options.o		libperf-y += parse-branch-options.o
	libperf-y += dump-insn.o		libperf-y += dump-insn.o
	libperf-y += parse-regs-options.o		libperf-y += parse-regs-options.o

Admin message