1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright IBM Corp. 2019 4 * Author(s): Thomas Richter <tmricht@linux.ibm.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License (version 2 only) 8 * as published by the Free Software Foundation. 9 * 10 * Architecture specific trace_event function. Save event's bc000 raw data 11 * to file. File name is aux.ctr.## where ## stands for the CPU number the 12 * sample was taken from. 13 */ 14 15#include <unistd.h> 16#include <stdio.h> 17#include <string.h> 18#include <inttypes.h> 19 20#include <sys/stat.h> 21#include <linux/compiler.h> 22#include <asm/byteorder.h> 23 24#include "debug.h" 25#include "session.h" 26#include "evlist.h" 27#include "color.h" 28#include "sample-raw.h" 29#include "s390-cpumcf-kernel.h" 30#include "util/pmu.h" 31#include "util/sample.h" 32 33static size_t ctrset_size(struct cf_ctrset_entry *set) 34{ 35 return sizeof(*set) + set->ctr * sizeof(u64); 36} 37 38static bool ctrset_valid(struct cf_ctrset_entry *set) 39{ 40 return set->def == S390_CPUMCF_DIAG_DEF; 41} 42 43/* CPU Measurement Counter Facility raw data is a byte stream. It is 8 byte 44 * aligned and might have trailing padding bytes. 45 * Display the raw data on screen. 46 */ 47static bool s390_cpumcfdg_testctr(struct perf_sample *sample) 48{ 49 size_t len = sample->raw_size, offset = 0; 50 unsigned char *buf = sample->raw_data; 51 struct cf_trailer_entry *te; 52 struct cf_ctrset_entry *cep, ce; 53 54 while (offset < len) { 55 cep = (struct cf_ctrset_entry *)(buf + offset); 56 ce.def = be16_to_cpu(cep->def); 57 ce.set = be16_to_cpu(cep->set); 58 ce.ctr = be16_to_cpu(cep->ctr); 59 ce.res1 = be16_to_cpu(cep->res1); 60 61 if (!ctrset_valid(&ce) || offset + ctrset_size(&ce) > len) { 62 /* Raw data for counter sets are always multiple of 8 63 * bytes. Prepending a 4 bytes size field to the 64 * raw data block in the sample causes the perf tool 65 * to append 4 padding bytes to make the raw data part 66 * of the sample a multiple of eight bytes again. 67 * 68 * If the last entry (trailer) is 4 bytes off the raw 69 * area data end, all is good. 70 */ 71 if (len - offset - sizeof(*te) == 4) 72 break; 73 pr_err("Invalid counter set entry at %zd\n", offset); 74 return false; 75 } 76 offset += ctrset_size(&ce); 77 } 78 return true; 79} 80 81/* Dump event bc000 on screen, already tested on correctness. */ 82static void s390_cpumcfdg_dumptrail(const char *color, size_t offset, 83 struct cf_trailer_entry *tep) 84{ 85 struct cf_trailer_entry te; 86 87 te.flags = be64_to_cpu(tep->flags); 88 te.cfvn = be16_to_cpu(tep->cfvn); 89 te.csvn = be16_to_cpu(tep->csvn); 90 te.cpu_speed = be32_to_cpu(tep->cpu_speed); 91 te.timestamp = be64_to_cpu(tep->timestamp); 92 te.progusage1 = be64_to_cpu(tep->progusage1); 93 te.progusage2 = be64_to_cpu(tep->progusage2); 94 te.progusage3 = be64_to_cpu(tep->progusage3); 95 te.tod_base = be64_to_cpu(tep->tod_base); 96 te.mach_type = be16_to_cpu(tep->mach_type); 97 te.res1 = be16_to_cpu(tep->res1); 98 te.res2 = be32_to_cpu(tep->res2); 99 100 color_fprintf(stdout, color, " [%#08zx] Trailer:%c%c%c%c%c" 101 " Cfvn:%d Csvn:%d Speed:%d TOD:%#llx\n", 102 offset, te.clock_base ? 'T' : ' ', 103 te.speed ? 'S' : ' ', te.mtda ? 'M' : ' ', 104 te.caca ? 'C' : ' ', te.lcda ? 'L' : ' ', 105 te.cfvn, te.csvn, te.cpu_speed, te.timestamp); 106 color_fprintf(stdout, color, "\t\t1:%lx 2:%lx 3:%lx TOD-Base:%#llx" 107 " Type:%x\n\n", 108 te.progusage1, te.progusage2, te.progusage3, 109 te.tod_base, te.mach_type); 110} 111 112/* Return starting number of a counter set */ 113static int get_counterset_start(int setnr) 114{ 115 switch (setnr) { 116 case CPUMF_CTR_SET_BASIC: /* Basic counter set */ 117 return 0; 118 case CPUMF_CTR_SET_USER: /* Problem state counter set */ 119 return 32; 120 case CPUMF_CTR_SET_CRYPTO: /* Crypto counter set */ 121 return 64; 122 case CPUMF_CTR_SET_EXT: /* Extended counter set */ 123 return 128; 124 case CPUMF_CTR_SET_MT_DIAG: /* Diagnostic counter set */ 125 return 448; 126 case PERF_EVENT_PAI_NNPA_ALL: /* PAI NNPA counter set */ 127 case PERF_EVENT_PAI_CRYPTO_ALL: /* PAI CRYPTO counter set */ 128 return setnr; 129 default: 130 return -1; 131 } 132} 133 134struct get_counter_name_data { 135 int wanted; 136 char *result; 137}; 138 139static int get_counter_name_callback(void *vdata, struct pmu_event_info *info) 140{ 141 struct get_counter_name_data *data = vdata; 142 int rc, event_nr; 143 const char *event_str; 144 145 if (info->str == NULL) 146 return 0; 147 148 event_str = strstr(info->str, "event="); 149 if (!event_str) 150 return 0; 151 152 rc = sscanf(event_str, "event=%x", &event_nr); 153 if (rc == 1 && event_nr == data->wanted) { 154 data->result = strdup(info->name); 155 return 1; /* Terminate the search. */ 156 } 157 return 0; 158} 159 160/* Scan the PMU and extract the logical name of a counter from the event. Input 161 * is the counter set and counter number with in the set. Construct the event 162 * number and use this as key. If they match return the name of this counter. 163 * If no match is found a NULL pointer is returned. 164 */ 165static char *get_counter_name(int set, int nr, struct perf_pmu *pmu) 166{ 167 struct get_counter_name_data data = { 168 .wanted = get_counterset_start(set) + nr, 169 .result = NULL, 170 }; 171 172 if (!pmu) 173 return NULL; 174 175 perf_pmu__for_each_event(pmu, /*skip_duplicate_pmus=*/ true, 176 &data, get_counter_name_callback); 177 return data.result; 178} 179 180static void s390_cpumcfdg_dump(struct perf_pmu *pmu, struct perf_sample *sample) 181{ 182 size_t i, len = sample->raw_size, offset = 0; 183 unsigned char *buf = sample->raw_data; 184 const char *color = PERF_COLOR_BLUE; 185 struct cf_ctrset_entry *cep, ce; 186 u64 *p; 187 188 while (offset < len) { 189 cep = (struct cf_ctrset_entry *)(buf + offset); 190 191 ce.def = be16_to_cpu(cep->def); 192 ce.set = be16_to_cpu(cep->set); 193 ce.ctr = be16_to_cpu(cep->ctr); 194 ce.res1 = be16_to_cpu(cep->res1); 195 196 if (!ctrset_valid(&ce)) { /* Print trailer */ 197 s390_cpumcfdg_dumptrail(color, offset, 198 (struct cf_trailer_entry *)cep); 199 return; 200 } 201 202 color_fprintf(stdout, color, " [%#08zx] Counterset:%d" 203 " Counters:%d\n", offset, ce.set, ce.ctr); 204 for (i = 0, p = (u64 *)(cep + 1); i < ce.ctr; ++i, ++p) { 205 char *ev_name = get_counter_name(ce.set, i, pmu); 206 207 color_fprintf(stdout, color, 208 "\tCounter:%03d %s Value:%#018lx\n", i, 209 ev_name ?: "<unknown>", be64_to_cpu(*p)); 210 free(ev_name); 211 } 212 offset += ctrset_size(&ce); 213 } 214} 215 216#pragma GCC diagnostic push 217#pragma GCC diagnostic ignored "-Wpacked" 218#pragma GCC diagnostic ignored "-Wattributes" 219/* 220 * Check for consistency of PAI_CRYPTO/PAI_NNPA raw data. 221 */ 222struct pai_data { /* Event number and value */ 223 u16 event_nr; 224 u64 event_val; 225} __packed; 226 227#pragma GCC diagnostic pop 228 229/* 230 * Test for valid raw data. At least one PAI event should be in the raw 231 * data section. 232 */ 233static bool s390_pai_all_test(struct perf_sample *sample) 234{ 235 size_t len = sample->raw_size; 236 237 if (len < 0xa) 238 return false; 239 return true; 240} 241 242static void s390_pai_all_dump(struct evsel *evsel, struct perf_sample *sample) 243{ 244 size_t len = sample->raw_size, offset = 0; 245 unsigned char *p = sample->raw_data; 246 const char *color = PERF_COLOR_BLUE; 247 struct pai_data pai_data; 248 char *ev_name; 249 250 while (offset < len) { 251 memcpy(&pai_data.event_nr, p, sizeof(pai_data.event_nr)); 252 pai_data.event_nr = be16_to_cpu(pai_data.event_nr); 253 p += sizeof(pai_data.event_nr); 254 offset += sizeof(pai_data.event_nr); 255 256 memcpy(&pai_data.event_val, p, sizeof(pai_data.event_val)); 257 pai_data.event_val = be64_to_cpu(pai_data.event_val); 258 p += sizeof(pai_data.event_val); 259 offset += sizeof(pai_data.event_val); 260 261 ev_name = get_counter_name(evsel->core.attr.config, 262 pai_data.event_nr, evsel->pmu); 263 color_fprintf(stdout, color, "\tCounter:%03d %s Value:%#018lx\n", 264 pai_data.event_nr, ev_name ?: "<unknown>", 265 pai_data.event_val); 266 free(ev_name); 267 268 if (offset + 0xa > len) 269 break; 270 } 271 color_fprintf(stdout, color, "\n"); 272} 273 274/* S390 specific trace event function. Check for PERF_RECORD_SAMPLE events 275 * and if the event was triggered by a 276 * - counter set diagnostic event 277 * - processor activity assist (PAI) crypto counter event 278 * - processor activity assist (PAI) neural network processor assist (NNPA) 279 * counter event 280 * display its raw data. 281 * The function is only invoked when the dump flag -D is set. 282 * 283 * Function evlist__s390_sample_raw() is defined as call back after it has 284 * been verified that the perf.data file was created on s390 platform. 285 */ 286void evlist__s390_sample_raw(struct evlist *evlist, union perf_event *event, 287 struct perf_sample *sample) 288{ 289 const char *pai_name; 290 struct evsel *evsel; 291 292 if (event->header.type != PERF_RECORD_SAMPLE) 293 return; 294 295 evsel = evlist__event2evsel(evlist, event); 296 if (!evsel) 297 return; 298 299 /* Check for raw data in sample */ 300 if (!sample->raw_size || !sample->raw_data) 301 return; 302 303 /* Display raw data on screen */ 304 if (evsel->core.attr.config == PERF_EVENT_CPUM_CF_DIAG) { 305 if (!evsel->pmu) 306 evsel->pmu = perf_pmus__find("cpum_cf"); 307 if (!s390_cpumcfdg_testctr(sample)) 308 pr_err("Invalid counter set data encountered\n"); 309 else 310 s390_cpumcfdg_dump(evsel->pmu, sample); 311 return; 312 } 313 314 switch (evsel->core.attr.config) { 315 case PERF_EVENT_PAI_NNPA_ALL: 316 pai_name = "NNPA_ALL"; 317 break; 318 case PERF_EVENT_PAI_CRYPTO_ALL: 319 pai_name = "CRYPTO_ALL"; 320 break; 321 default: 322 return; 323 } 324 325 if (!s390_pai_all_test(sample)) { 326 pr_err("Invalid %s raw data encountered\n", pai_name); 327 } else { 328 if (!evsel->pmu) 329 evsel->pmu = perf_pmus__find_by_type(evsel->core.attr.type); 330 s390_pai_all_dump(evsel, sample); 331 } 332} 333