breeze/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-01-12 00:42:35 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
linux/tools/perf/util/arm-spe-decoder/arm-spe-decoder.c
Leo Yan b70aa41078 perf arm_spe: Expose SIMD information in other operations 
The other operations contain SME data processing, ASE (Advanced SIMD)
and floating-point operations. Expose these info in the records.

Signed-off-by: Leo Yan <leo.yan@arm.com>
Reviewed-by: Ian Rogers <irogers@google.com>
Reviewed-by: James Clark <james.clark@linaro.org>
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
2025-11-18 20:31:30 -08:00

302 lines
8.4 KiB
C
Raw Permalink Blame History

// SPDX-License-Identifier: GPL-2.0
/*
* arm_spe_decoder.c: ARM SPE support
*/
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <errno.h>
#include <inttypes.h>
#include <stdbool.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <linux/bitops.h>
#include <linux/compiler.h>
#include <linux/zalloc.h>
#include "../auxtrace.h"
#include "../debug.h"
#include "../util.h"
#include "arm-spe-decoder.h"
static u64 arm_spe_calc_ip(int index, u64 payload)
{
u64 ns, el, val;
/* Instruction virtual address or Branch target address */
if (index == SPE_ADDR_PKT_HDR_INDEX_INS ||
index == SPE_ADDR_PKT_HDR_INDEX_BRANCH ||
index == SPE_ADDR_PKT_HDR_INDEX_PREV_BRANCH) {
ns = SPE_ADDR_PKT_GET_NS(payload);
el = SPE_ADDR_PKT_GET_EL(payload);
/* Clean highest byte */
payload = SPE_ADDR_PKT_ADDR_GET_BYTES_0_6(payload);
/* Fill highest byte for EL1 or EL2 (VHE) mode */
if (ns && (el == SPE_ADDR_PKT_EL1 || el == SPE_ADDR_PKT_EL2))
payload |= 0xffULL << SPE_ADDR_PKT_ADDR_BYTE7_SHIFT;
/* Data access virtual address */
} else if (index == SPE_ADDR_PKT_HDR_INDEX_DATA_VIRT) {
/* Clean tags */
payload = SPE_ADDR_PKT_ADDR_GET_BYTES_0_6(payload);
/*
* Armv8 ARM (ARM DDI 0487F.c), chapter "D10.2.1 Address packet"
* defines the data virtual address payload format, the top byte
* (bits [63:56]) is assigned as top-byte tag; so we only can
* retrieve address value from bits [55:0].
*
* According to Documentation/arch/arm64/memory.rst, if detects the
* specific pattern in bits [55:52] of payload which falls in
* the kernel space, should fixup the top byte and this allows
* perf tool to parse DSO symbol for data address correctly.
*
* For this reason, if detects the bits [55:52] is 0xf, will
* fill 0xff into the top byte.
*/
val = SPE_ADDR_PKT_ADDR_GET_BYTE_6(payload);
if ((val & 0xf0ULL) == 0xf0ULL)
payload |= 0xffULL << SPE_ADDR_PKT_ADDR_BYTE7_SHIFT;
/* Data access physical address */
} else if (index == SPE_ADDR_PKT_HDR_INDEX_DATA_PHYS) {
/* Clean highest byte */
payload = SPE_ADDR_PKT_ADDR_GET_BYTES_0_6(payload);
} else {
static u32 seen_idx = 0;
if (!(seen_idx & BIT(index))) {
seen_idx |= BIT(index);
pr_warning("ignoring unsupported address packet index: 0x%x\n", index);
}
}
return payload;
}
struct arm_spe_decoder *arm_spe_decoder_new(struct arm_spe_params *params)
{
struct arm_spe_decoder *decoder;
if (!params->get_trace)
return NULL;
decoder = zalloc(sizeof(struct arm_spe_decoder));
if (!decoder)
return NULL;
decoder->get_trace = params->get_trace;
decoder->data = params->data;
return decoder;
}
void arm_spe_decoder_free(struct arm_spe_decoder *decoder)
{
free(decoder);
}
static int arm_spe_get_data(struct arm_spe_decoder *decoder)
{
struct arm_spe_buffer buffer = { .buf = 0, };
int ret;
pr_debug("Getting more data\n");
ret = decoder->get_trace(&buffer, decoder->data);
if (ret < 0)
return ret;
decoder->buf = buffer.buf;
decoder->len = buffer.len;
if (!decoder->len)
pr_debug("No more data\n");
return decoder->len;
}
static int arm_spe_get_next_packet(struct arm_spe_decoder *decoder)
{
int ret;
do {
if (!decoder->len) {
ret = arm_spe_get_data(decoder);
/* Failed to read out trace data */
if (ret <= 0)
return ret;
}
ret = arm_spe_get_packet(decoder->buf, decoder->len,
&decoder->packet);
if (ret <= 0) {
/* Move forward for 1 byte */
decoder->buf += 1;
decoder->len -= 1;
return -EBADMSG;
}
decoder->buf += ret;
decoder->len -= ret;
} while (decoder->packet.type == ARM_SPE_PAD);
return 1;
}
static int arm_spe_read_record(struct arm_spe_decoder *decoder)
{
int err;
int idx;
u64 payload, ip;
memset(&decoder->record, 0x0, sizeof(decoder->record));
decoder->record.context_id = (u64)-1;
while (1) {
err = arm_spe_get_next_packet(decoder);
if (err <= 0)
return err;
idx = decoder->packet.index;
payload = decoder->packet.payload;
switch (decoder->packet.type) {
case ARM_SPE_TIMESTAMP:
decoder->record.timestamp = payload;
return 1;
case ARM_SPE_END:
return 1;
case ARM_SPE_ADDRESS:
ip = arm_spe_calc_ip(idx, payload);
if (idx == SPE_ADDR_PKT_HDR_INDEX_INS)
decoder->record.from_ip = ip;
else if (idx == SPE_ADDR_PKT_HDR_INDEX_BRANCH)
decoder->record.to_ip = ip;
else if (idx == SPE_ADDR_PKT_HDR_INDEX_DATA_VIRT)
decoder->record.virt_addr = ip;
else if (idx == SPE_ADDR_PKT_HDR_INDEX_DATA_PHYS)
decoder->record.phys_addr = ip;
else if (idx == SPE_ADDR_PKT_HDR_INDEX_PREV_BRANCH)
decoder->record.prev_br_tgt = ip;
break;
case ARM_SPE_COUNTER:
if (idx == SPE_CNT_PKT_HDR_INDEX_TOTAL_LAT)
decoder->record.latency = payload;
break;
case ARM_SPE_CONTEXT:
decoder->record.context_id = payload;
break;
case ARM_SPE_OP_TYPE:
switch (idx) {
case SPE_OP_PKT_HDR_CLASS_LD_ST_ATOMIC:
decoder->record.op |= ARM_SPE_OP_LDST;
if (payload & SPE_OP_PKT_ST)
decoder->record.op |= ARM_SPE_OP_ST;
else
decoder->record.op |= ARM_SPE_OP_LD;
if (SPE_OP_PKT_LDST_SUBCLASS_GP_REG(payload)) {
decoder->record.op |= ARM_SPE_OP_GP_REG;
} else if (SPE_OP_PKT_LDST_SUBCLASS_SIMD_FP(payload)) {
decoder->record.op |= ARM_SPE_OP_SIMD_FP;
} else if (SPE_OP_PKT_LDST_SUBCLASS_UNSPEC_REG(payload)) {
decoder->record.op |= ARM_SPE_OP_UNSPEC_REG;
} else if (SPE_OP_PKT_LDST_SUBCLASS_NV_SYSREG(payload)) {
decoder->record.op |= ARM_SPE_OP_NV_SYSREG;
} else if (SPE_OP_PKT_LDST_SUBCLASS_MTE_TAG(payload)) {
decoder->record.op |= ARM_SPE_OP_MTE_TAG;
} else if (SPE_OP_PKT_LDST_SUBCLASS_EXTENDED(payload)) {
if (payload & SPE_OP_PKT_AR)
decoder->record.op |= ARM_SPE_OP_AR;
if (payload & SPE_OP_PKT_EXCL)
decoder->record.op |= ARM_SPE_OP_EXCL;
if (payload & SPE_OP_PKT_AT)
decoder->record.op |= ARM_SPE_OP_ATOMIC;
} else if (SPE_OP_PKT_LDST_SUBCLASS_SVE_SME_REG(payload)) {
decoder->record.op |= ARM_SPE_OP_SVE;
if (payload & SPE_OP_PKT_SVE_PRED)
decoder->record.op |= ARM_SPE_OP_PRED;
if (payload & SPE_OP_PKT_SVE_SG)
decoder->record.op |= ARM_SPE_OP_SG;
} else if (SPE_OP_PKT_LDST_SUBCLASS_MEMCPY(payload)) {
decoder->record.op |= ARM_SPE_OP_MEMCPY;
} else if (SPE_OP_PKT_LDST_SUBCLASS_MEMSET(payload)) {
decoder->record.op |= ARM_SPE_OP_MEMSET;
} else if (SPE_OP_PKT_LDST_SUBCLASS_GCS(payload)) {
decoder->record.op |= ARM_SPE_OP_GCS;
if (payload & SPE_OP_PKT_GCS_COMM)
decoder->record.op |= ARM_SPE_OP_COMM;
}
break;
case SPE_OP_PKT_HDR_CLASS_OTHER:
decoder->record.op |= ARM_SPE_OP_OTHER;
if (SPE_OP_PKT_OTHER_SUBCLASS_SVE(payload)) {
decoder->record.op |= ARM_SPE_OP_SVE | ARM_SPE_OP_DP;
if (payload & SPE_OP_PKT_OTHER_FP)
decoder->record.op |= ARM_SPE_OP_FP;
if (payload & SPE_OP_PKT_SVE_PRED)
decoder->record.op |= ARM_SPE_OP_PRED;
} else if (SPE_OP_PKT_OTHER_SUBCLASS_SME(payload)) {
decoder->record.op |= ARM_SPE_OP_SME;
if (payload & SPE_OP_PKT_OTHER_FP)
decoder->record.op |= ARM_SPE_OP_FP;
} else if (SPE_OP_PKT_OTHER_SUBCLASS_OTHER(payload)) {
if (payload & SPE_OP_PKT_OTHER_ASE)
decoder->record.op |= ARM_SPE_OP_ASE;
if (payload & SPE_OP_PKT_OTHER_FP)
decoder->record.op |= ARM_SPE_OP_FP;
if (payload & SPE_OP_PKT_COND)
decoder->record.op |= ARM_SPE_OP_COND;
}
break;
case SPE_OP_PKT_HDR_CLASS_BR_ERET:
decoder->record.op |= ARM_SPE_OP_BRANCH_ERET;
if (payload & SPE_OP_PKT_COND)
decoder->record.op |= ARM_SPE_OP_BR_COND;
if (payload & SPE_OP_PKT_INDIRECT_BRANCH)
decoder->record.op |= ARM_SPE_OP_BR_INDIRECT;
if (payload & SPE_OP_PKT_GCS)
decoder->record.op |= ARM_SPE_OP_BR_GCS;
if (SPE_OP_PKT_CR_BL(payload))
decoder->record.op |= ARM_SPE_OP_BR_CR_BL;
if (SPE_OP_PKT_CR_RET(payload))
decoder->record.op |= ARM_SPE_OP_BR_CR_RET;
if (SPE_OP_PKT_CR_NON_BL_RET(payload))
decoder->record.op |= ARM_SPE_OP_BR_CR_NON_BL_RET;
break;
default:
pr_err("Get packet error!\n");
return -1;
}
break;
case ARM_SPE_EVENTS:
decoder->record.type = payload;
break;
case ARM_SPE_DATA_SOURCE:
decoder->record.source = payload;
break;
case ARM_SPE_BAD:
break;
case ARM_SPE_PAD:
break;
default:
pr_err("Get packet error!\n");
return -1;
}
}
return 0;
}
int arm_spe_decode(struct arm_spe_decoder *decoder)
{
return arm_spe_read_record(decoder);
}
Reference in New Issue View Git Blame Copy Permalink