2
0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-24 21:24:00 +08:00
linux-next/tools/perf/util/s390-sample-raw.c
John Garry e126bef55f perf pmu: Add pmu_events_map__find() function to find the common PMU map for the system
Add a function to find the common PMU map for the system.

For arm64, a special variant is added. This is because arm64 supports
heterogeneous CPU systems. As such, it cannot be guaranteed that the
cpumap is same for all CPUs. So in case of heterogeneous systems, don't
return a cpumap.

Reviewed-by: Kajol Jain <kjain@linux.ibm.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Tested-by: Paul A. Clarke <pc@us.ibm.com>
Acked-by: Jiri Olsa <jolsa@redhat.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ian Rogers <irogers@google.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Leo Yan <leo.yan@linaro.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Mathieu Poirier <mathieu.poirier@linaro.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Shaokun Zhang <zhangshaokun@hisilicon.com>
Cc: Will Deacon <will@kernel.org>
Cc: linux-arm-kernel@lists.infradead.org
Cc: linuxarm@huawei.com
Link: https://lore.kernel.org/r/1617791570-165223-4-git-send-email-john.garry@huawei.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2021-04-08 14:24:14 -03:00

217 lines
6.4 KiB
C

// SPDX-License-Identifier: GPL-2.0
/*
* Copyright IBM Corp. 2019
* Author(s): Thomas Richter <tmricht@linux.ibm.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License (version 2 only)
* as published by the Free Software Foundation.
*
* Architecture specific trace_event function. Save event's bc000 raw data
* to file. File name is aux.ctr.## where ## stands for the CPU number the
* sample was taken from.
*/
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <sys/stat.h>
#include <linux/compiler.h>
#include <asm/byteorder.h>
#include "debug.h"
#include "session.h"
#include "evlist.h"
#include "color.h"
#include "sample-raw.h"
#include "s390-cpumcf-kernel.h"
#include "pmu-events/pmu-events.h"
static size_t ctrset_size(struct cf_ctrset_entry *set)
{
return sizeof(*set) + set->ctr * sizeof(u64);
}
static bool ctrset_valid(struct cf_ctrset_entry *set)
{
return set->def == S390_CPUMCF_DIAG_DEF;
}
/* CPU Measurement Counter Facility raw data is a byte stream. It is 8 byte
* aligned and might have trailing padding bytes.
* Display the raw data on screen.
*/
static bool s390_cpumcfdg_testctr(struct perf_sample *sample)
{
size_t len = sample->raw_size, offset = 0;
unsigned char *buf = sample->raw_data;
struct cf_trailer_entry *te;
struct cf_ctrset_entry *cep, ce;
if (!len)
return false;
while (offset < len) {
cep = (struct cf_ctrset_entry *)(buf + offset);
ce.def = be16_to_cpu(cep->def);
ce.set = be16_to_cpu(cep->set);
ce.ctr = be16_to_cpu(cep->ctr);
ce.res1 = be16_to_cpu(cep->res1);
if (!ctrset_valid(&ce) || offset + ctrset_size(&ce) > len) {
/* Raw data for counter sets are always multiple of 8
* bytes. Prepending a 4 bytes size field to the
* raw data block in the sample causes the perf tool
* to append 4 padding bytes to make the raw data part
* of the sample a multiple of eight bytes again.
*
* If the last entry (trailer) is 4 bytes off the raw
* area data end, all is good.
*/
if (len - offset - sizeof(*te) == 4)
break;
pr_err("Invalid counter set entry at %zd\n", offset);
return false;
}
offset += ctrset_size(&ce);
}
return true;
}
/* Dump event bc000 on screen, already tested on correctness. */
static void s390_cpumcfdg_dumptrail(const char *color, size_t offset,
struct cf_trailer_entry *tep)
{
struct cf_trailer_entry te;
te.flags = be64_to_cpu(tep->flags);
te.cfvn = be16_to_cpu(tep->cfvn);
te.csvn = be16_to_cpu(tep->csvn);
te.cpu_speed = be32_to_cpu(tep->cpu_speed);
te.timestamp = be64_to_cpu(tep->timestamp);
te.progusage1 = be64_to_cpu(tep->progusage1);
te.progusage2 = be64_to_cpu(tep->progusage2);
te.progusage3 = be64_to_cpu(tep->progusage3);
te.tod_base = be64_to_cpu(tep->tod_base);
te.mach_type = be16_to_cpu(tep->mach_type);
te.res1 = be16_to_cpu(tep->res1);
te.res2 = be32_to_cpu(tep->res2);
color_fprintf(stdout, color, " [%#08zx] Trailer:%c%c%c%c%c"
" Cfvn:%d Csvn:%d Speed:%d TOD:%#llx\n",
offset, te.clock_base ? 'T' : ' ',
te.speed ? 'S' : ' ', te.mtda ? 'M' : ' ',
te.caca ? 'C' : ' ', te.lcda ? 'L' : ' ',
te.cfvn, te.csvn, te.cpu_speed, te.timestamp);
color_fprintf(stdout, color, "\t\t1:%lx 2:%lx 3:%lx TOD-Base:%#llx"
" Type:%x\n\n",
te.progusage1, te.progusage2, te.progusage3,
te.tod_base, te.mach_type);
}
/* Return starting number of a counter set */
static int get_counterset_start(int setnr)
{
switch (setnr) {
case CPUMF_CTR_SET_BASIC: /* Basic counter set */
return 0;
case CPUMF_CTR_SET_USER: /* Problem state counter set */
return 32;
case CPUMF_CTR_SET_CRYPTO: /* Crypto counter set */
return 64;
case CPUMF_CTR_SET_EXT: /* Extended counter set */
return 128;
case CPUMF_CTR_SET_MT_DIAG: /* Diagnostic counter set */
return 448;
default:
return -1;
}
}
/* Scan the PMU table and extract the logical name of a counter from the
* PMU events table. Input is the counter set and counter number with in the
* set. Construct the event number and use this as key. If they match return
* the name of this counter.
* If no match is found a NULL pointer is returned.
*/
static const char *get_counter_name(int set, int nr, struct pmu_events_map *map)
{
int rc, event_nr, wanted = get_counterset_start(set) + nr;
if (map) {
struct pmu_event *evp = map->table;
for (; evp->name || evp->event || evp->desc; ++evp) {
if (evp->name == NULL || evp->event == NULL)
continue;
rc = sscanf(evp->event, "event=%x", &event_nr);
if (rc == 1 && event_nr == wanted)
return evp->name;
}
}
return NULL;
}
static void s390_cpumcfdg_dump(struct perf_sample *sample)
{
size_t i, len = sample->raw_size, offset = 0;
unsigned char *buf = sample->raw_data;
const char *color = PERF_COLOR_BLUE;
struct cf_ctrset_entry *cep, ce;
struct pmu_events_map *map;
u64 *p;
map = pmu_events_map__find();
while (offset < len) {
cep = (struct cf_ctrset_entry *)(buf + offset);
ce.def = be16_to_cpu(cep->def);
ce.set = be16_to_cpu(cep->set);
ce.ctr = be16_to_cpu(cep->ctr);
ce.res1 = be16_to_cpu(cep->res1);
if (!ctrset_valid(&ce)) { /* Print trailer */
s390_cpumcfdg_dumptrail(color, offset,
(struct cf_trailer_entry *)cep);
return;
}
color_fprintf(stdout, color, " [%#08zx] Counterset:%d"
" Counters:%d\n", offset, ce.set, ce.ctr);
for (i = 0, p = (u64 *)(cep + 1); i < ce.ctr; ++i, ++p) {
const char *ev_name = get_counter_name(ce.set, i, map);
color_fprintf(stdout, color,
"\tCounter:%03d %s Value:%#018lx\n", i,
ev_name ?: "<unknown>", be64_to_cpu(*p));
}
offset += ctrset_size(&ce);
}
}
/* S390 specific trace event function. Check for PERF_RECORD_SAMPLE events
* and if the event was triggered by a counter set diagnostic event display
* its raw data.
* The function is only invoked when the dump flag -D is set.
*/
void evlist__s390_sample_raw(struct evlist *evlist, union perf_event *event, struct perf_sample *sample)
{
struct evsel *ev_bc000;
if (event->header.type != PERF_RECORD_SAMPLE)
return;
ev_bc000 = evlist__event2evsel(evlist, event);
if (ev_bc000 == NULL ||
ev_bc000->core.attr.config != PERF_EVENT_CPUM_CF_DIAG)
return;
/* Display raw data on screen */
if (!s390_cpumcfdg_testctr(sample)) {
pr_err("Invalid counter set data encountered\n");
return;
}
s390_cpumcfdg_dump(sample);
}