mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-24 17:59:32 +00:00
![Kim Phillips](/assets/img/avatar_default.png)
'perf record' and 'perf report --dump-raw-trace' supported in this release. Example usage: # perf record -e arm_spe/ts_enable=1,pa_enable=1/ dd if=/dev/zero of=/dev/null count=10000 # perf report --dump-raw-trace Note that the perf.data file is portable, so the report can be run on another architecture host if necessary. Output will contain raw SPE data and its textual representation, such as: 0x5c8 [0x30]: PERF_RECORD_AUXTRACE size: 0x200000 offset: 0 ref: 0x1891ad0e idx: 1 tid: 2227 cpu: 1 . . ... ARM SPE data: size 2097152 bytes . 00000000: 49 00 LD . 00000002: b2 c0 3b 29 0f 00 00 ff ff VA 0xffff00000f293bc0 . 0000000b: b3 c0 eb 24 fb 00 00 00 80 PA 0xfb24ebc0 ns=1 . 00000014: 9a 00 00 LAT 0 XLAT . 00000017: 42 16 EV RETIRED L1D-ACCESS TLB-ACCESS . 00000019: b0 00 c4 15 08 00 00 ff ff PC 0xff00000815c400 el3 ns=1 . 00000022: 98 00 00 LAT 0 TOT . 00000025: 71 36 6c 21 2c 09 00 00 00 TS 39395093558 . 0000002e: 49 00 LD . 00000030: b2 80 3c 29 0f 00 00 ff ff VA 0xffff00000f293c80 . 00000039: b3 80 ec 24 fb 00 00 00 80 PA 0xfb24ec80 ns=1 . 00000042: 9a 00 00 LAT 0 XLAT . 00000045: 42 16 EV RETIRED L1D-ACCESS TLB-ACCESS . 00000047: b0 f4 11 16 08 00 00 ff ff PC 0xff0000081611f4 el3 ns=1 . 00000050: 98 00 00 LAT 0 TOT . 00000053: 71 36 6c 21 2c 09 00 00 00 TS 39395093558 . 0000005c: 48 00 INSN-OTHER . 0000005e: 42 02 EV RETIRED . 00000060: b0 2c ef 7f 08 00 00 ff ff PC 0xff0000087fef2c el3 ns=1 . 00000069: 98 00 00 LAT 0 TOT . 0000006c: 71 d1 6f 21 2c 09 00 00 00 TS 39395094481 ... Other release notes: - applies to acme's perf/{core,urgent} branches, likely elsewhere - Report is self-contained within the tool. Record requires enabling the kernel SPE driver by setting CONFIG_ARM_SPE_PMU. - The intel-bts implementation was used as a starting point; its min/default/max buffer sizes and power of 2 pages granularity need to be revisited for ARM SPE - Recording across multiple SPE clusters/domains not supported - Snapshot support (record -S), and conversion to native perf events (e.g., via 'perf inject --itrace'), are also not supported - Technically both cs-etm and spe can be used simultaneously, however disabled for simplicity in this release Signed-off-by: Kim Phillips <kim.phillips@arm.com> Reviewed-by: Dongjiu Geng <gengdongjiu@huawei.com> Acked-by: Adrian Hunter <adrian.hunter@intel.com> Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com> Cc: Andi Kleen <ak@linux.intel.com> Cc: Jiri Olsa <jolsa@kernel.org> Cc: linux-arm-kernel@lists.infradead.org Cc: Marc Zyngier <marc.zyngier@arm.com> Cc: Mark Rutland <mark.rutland@arm.com> Cc: Mathieu Poirier <mathieu.poirier@linaro.org> Cc: Pawel Moll <pawel.moll@arm.com> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Rob Herring <robh@kernel.org> Cc: Suzuki Poulouse <suzuki.poulose@arm.com> Cc: Thomas Gleixner <tglx@linutronix.de> Cc: Wang Nan <wangnan0@huawei.com> Cc: Will Deacon <will.deacon@arm.com> Link: http://lkml.kernel.org/r/20180114132850.0b127434b704a26bad13268f@arm.com Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
231 lines
5.3 KiB
C
231 lines
5.3 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Arm Statistical Profiling Extensions (SPE) support
|
|
* Copyright (c) 2017-2018, Arm Ltd.
|
|
*/
|
|
|
|
#include <endian.h>
|
|
#include <errno.h>
|
|
#include <byteswap.h>
|
|
#include <inttypes.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/types.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/log2.h>
|
|
|
|
#include "cpumap.h"
|
|
#include "color.h"
|
|
#include "evsel.h"
|
|
#include "evlist.h"
|
|
#include "machine.h"
|
|
#include "session.h"
|
|
#include "util.h"
|
|
#include "thread.h"
|
|
#include "debug.h"
|
|
#include "auxtrace.h"
|
|
#include "arm-spe.h"
|
|
#include "arm-spe-pkt-decoder.h"
|
|
|
|
struct arm_spe {
|
|
struct auxtrace auxtrace;
|
|
struct auxtrace_queues queues;
|
|
struct auxtrace_heap heap;
|
|
u32 auxtrace_type;
|
|
struct perf_session *session;
|
|
struct machine *machine;
|
|
u32 pmu_type;
|
|
};
|
|
|
|
struct arm_spe_queue {
|
|
struct arm_spe *spe;
|
|
unsigned int queue_nr;
|
|
struct auxtrace_buffer *buffer;
|
|
bool on_heap;
|
|
bool done;
|
|
pid_t pid;
|
|
pid_t tid;
|
|
int cpu;
|
|
};
|
|
|
|
static void arm_spe_dump(struct arm_spe *spe __maybe_unused,
|
|
unsigned char *buf, size_t len)
|
|
{
|
|
struct arm_spe_pkt packet;
|
|
size_t pos = 0;
|
|
int ret, pkt_len, i;
|
|
char desc[ARM_SPE_PKT_DESC_MAX];
|
|
const char *color = PERF_COLOR_BLUE;
|
|
|
|
color_fprintf(stdout, color,
|
|
". ... ARM SPE data: size %zu bytes\n",
|
|
len);
|
|
|
|
while (len) {
|
|
ret = arm_spe_get_packet(buf, len, &packet);
|
|
if (ret > 0)
|
|
pkt_len = ret;
|
|
else
|
|
pkt_len = 1;
|
|
printf(".");
|
|
color_fprintf(stdout, color, " %08x: ", pos);
|
|
for (i = 0; i < pkt_len; i++)
|
|
color_fprintf(stdout, color, " %02x", buf[i]);
|
|
for (; i < 16; i++)
|
|
color_fprintf(stdout, color, " ");
|
|
if (ret > 0) {
|
|
ret = arm_spe_pkt_desc(&packet, desc,
|
|
ARM_SPE_PKT_DESC_MAX);
|
|
if (ret > 0)
|
|
color_fprintf(stdout, color, " %s\n", desc);
|
|
} else {
|
|
color_fprintf(stdout, color, " Bad packet!\n");
|
|
}
|
|
pos += pkt_len;
|
|
buf += pkt_len;
|
|
len -= pkt_len;
|
|
}
|
|
}
|
|
|
|
static void arm_spe_dump_event(struct arm_spe *spe, unsigned char *buf,
|
|
size_t len)
|
|
{
|
|
printf(".\n");
|
|
arm_spe_dump(spe, buf, len);
|
|
}
|
|
|
|
static int arm_spe_process_event(struct perf_session *session __maybe_unused,
|
|
union perf_event *event __maybe_unused,
|
|
struct perf_sample *sample __maybe_unused,
|
|
struct perf_tool *tool __maybe_unused)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int arm_spe_process_auxtrace_event(struct perf_session *session,
|
|
union perf_event *event,
|
|
struct perf_tool *tool __maybe_unused)
|
|
{
|
|
struct arm_spe *spe = container_of(session->auxtrace, struct arm_spe,
|
|
auxtrace);
|
|
struct auxtrace_buffer *buffer;
|
|
off_t data_offset;
|
|
int fd = perf_data__fd(session->data);
|
|
int err;
|
|
|
|
if (perf_data__is_pipe(session->data)) {
|
|
data_offset = 0;
|
|
} else {
|
|
data_offset = lseek(fd, 0, SEEK_CUR);
|
|
if (data_offset == -1)
|
|
return -errno;
|
|
}
|
|
|
|
err = auxtrace_queues__add_event(&spe->queues, session, event,
|
|
data_offset, &buffer);
|
|
if (err)
|
|
return err;
|
|
|
|
/* Dump here now we have copied a piped trace out of the pipe */
|
|
if (dump_trace) {
|
|
if (auxtrace_buffer__get_data(buffer, fd)) {
|
|
arm_spe_dump_event(spe, buffer->data,
|
|
buffer->size);
|
|
auxtrace_buffer__put_data(buffer);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int arm_spe_flush(struct perf_session *session __maybe_unused,
|
|
struct perf_tool *tool __maybe_unused)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void arm_spe_free_queue(void *priv)
|
|
{
|
|
struct arm_spe_queue *speq = priv;
|
|
|
|
if (!speq)
|
|
return;
|
|
free(speq);
|
|
}
|
|
|
|
static void arm_spe_free_events(struct perf_session *session)
|
|
{
|
|
struct arm_spe *spe = container_of(session->auxtrace, struct arm_spe,
|
|
auxtrace);
|
|
struct auxtrace_queues *queues = &spe->queues;
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < queues->nr_queues; i++) {
|
|
arm_spe_free_queue(queues->queue_array[i].priv);
|
|
queues->queue_array[i].priv = NULL;
|
|
}
|
|
auxtrace_queues__free(queues);
|
|
}
|
|
|
|
static void arm_spe_free(struct perf_session *session)
|
|
{
|
|
struct arm_spe *spe = container_of(session->auxtrace, struct arm_spe,
|
|
auxtrace);
|
|
|
|
auxtrace_heap__free(&spe->heap);
|
|
arm_spe_free_events(session);
|
|
session->auxtrace = NULL;
|
|
free(spe);
|
|
}
|
|
|
|
static const char * const arm_spe_info_fmts[] = {
|
|
[ARM_SPE_PMU_TYPE] = " PMU Type %"PRId64"\n",
|
|
};
|
|
|
|
static void arm_spe_print_info(u64 *arr)
|
|
{
|
|
if (!dump_trace)
|
|
return;
|
|
|
|
fprintf(stdout, arm_spe_info_fmts[ARM_SPE_PMU_TYPE], arr[ARM_SPE_PMU_TYPE]);
|
|
}
|
|
|
|
int arm_spe_process_auxtrace_info(union perf_event *event,
|
|
struct perf_session *session)
|
|
{
|
|
struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info;
|
|
size_t min_sz = sizeof(u64) * ARM_SPE_PMU_TYPE;
|
|
struct arm_spe *spe;
|
|
int err;
|
|
|
|
if (auxtrace_info->header.size < sizeof(struct auxtrace_info_event) +
|
|
min_sz)
|
|
return -EINVAL;
|
|
|
|
spe = zalloc(sizeof(struct arm_spe));
|
|
if (!spe)
|
|
return -ENOMEM;
|
|
|
|
err = auxtrace_queues__init(&spe->queues);
|
|
if (err)
|
|
goto err_free;
|
|
|
|
spe->session = session;
|
|
spe->machine = &session->machines.host; /* No kvm support */
|
|
spe->auxtrace_type = auxtrace_info->type;
|
|
spe->pmu_type = auxtrace_info->priv[ARM_SPE_PMU_TYPE];
|
|
|
|
spe->auxtrace.process_event = arm_spe_process_event;
|
|
spe->auxtrace.process_auxtrace_event = arm_spe_process_auxtrace_event;
|
|
spe->auxtrace.flush_events = arm_spe_flush;
|
|
spe->auxtrace.free_events = arm_spe_free_events;
|
|
spe->auxtrace.free = arm_spe_free;
|
|
session->auxtrace = &spe->auxtrace;
|
|
|
|
arm_spe_print_info(&auxtrace_info->priv[0]);
|
|
|
|
return 0;
|
|
|
|
err_free:
|
|
free(spe);
|
|
return err;
|
|
}
|