forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
236 lines
5.5 KiB
236 lines
5.5 KiB
// 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) { |
|
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/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 { |
|
pr_err("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)); |
|
|
|
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; |
|
break; |
|
case ARM_SPE_COUNTER: |
|
break; |
|
case ARM_SPE_CONTEXT: |
|
break; |
|
case ARM_SPE_OP_TYPE: |
|
if (idx == SPE_OP_PKT_HDR_CLASS_LD_ST_ATOMIC) { |
|
if (payload & 0x1) |
|
decoder->record.op = ARM_SPE_ST; |
|
else |
|
decoder->record.op = ARM_SPE_LD; |
|
} |
|
break; |
|
case ARM_SPE_EVENTS: |
|
if (payload & BIT(EV_L1D_REFILL)) |
|
decoder->record.type |= ARM_SPE_L1D_MISS; |
|
|
|
if (payload & BIT(EV_L1D_ACCESS)) |
|
decoder->record.type |= ARM_SPE_L1D_ACCESS; |
|
|
|
if (payload & BIT(EV_TLB_WALK)) |
|
decoder->record.type |= ARM_SPE_TLB_MISS; |
|
|
|
if (payload & BIT(EV_TLB_ACCESS)) |
|
decoder->record.type |= ARM_SPE_TLB_ACCESS; |
|
|
|
if (payload & BIT(EV_LLC_MISS)) |
|
decoder->record.type |= ARM_SPE_LLC_MISS; |
|
|
|
if (payload & BIT(EV_LLC_ACCESS)) |
|
decoder->record.type |= ARM_SPE_LLC_ACCESS; |
|
|
|
if (payload & BIT(EV_REMOTE_ACCESS)) |
|
decoder->record.type |= ARM_SPE_REMOTE_ACCESS; |
|
|
|
if (payload & BIT(EV_MISPRED)) |
|
decoder->record.type |= ARM_SPE_BRANCH_MISS; |
|
|
|
break; |
|
case ARM_SPE_DATA_SOURCE: |
|
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); |
|
}
|
|
|