xref: /openbmc/linux/tools/perf/util/s390-cpumsf.c (revision 37b9c7bb)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright IBM Corp. 2018
4  * Auxtrace support for s390 CPU-Measurement Sampling Facility
5  *
6  * Author(s):  Thomas Richter <tmricht@linux.ibm.com>
7  *
8  * Auxiliary traces are collected during 'perf record' using rbd000 event.
9  * Several PERF_RECORD_XXX are generated during recording:
10  *
11  * PERF_RECORD_AUX:
12  *	Records that new data landed in the AUX buffer part.
13  * PERF_RECORD_AUXTRACE:
14  *	Defines auxtrace data. Followed by the actual data. The contents of
15  *	the auxtrace data is dependent on the event and the CPU.
16  *	This record is generated by perf record command. For details
17  *	see Documentation/perf.data-file-format.txt.
18  * PERF_RECORD_AUXTRACE_INFO:
19  *	Defines a table of contains for PERF_RECORD_AUXTRACE records. This
20  *	record is generated during 'perf record' command. Each record contains
21  *	up to 256 entries describing offset and size of the AUXTRACE data in the
22  *	perf.data file.
23  * PERF_RECORD_AUXTRACE_ERROR:
24  *	Indicates an error during AUXTRACE collection such as buffer overflow.
25  * PERF_RECORD_FINISHED_ROUND:
26  *	Perf events are not necessarily in time stamp order, as they can be
27  *	collected in parallel on different CPUs. If the events should be
28  *	processed in time order they need to be sorted first.
29  *	Perf report guarantees that there is no reordering over a
30  *	PERF_RECORD_FINISHED_ROUND boundary event. All perf records with a
31  *	time stamp lower than this record are processed (and displayed) before
32  *	the succeeding perf record are processed.
33  *
34  * These records are evaluated during perf report command.
35  *
36  * 1. PERF_RECORD_AUXTRACE_INFO is used to set up the infrastructure for
37  * auxiliary trace data processing. See s390_cpumsf_process_auxtrace_info()
38  * below.
39  * Auxiliary trace data is collected per CPU. To merge the data into the report
40  * an auxtrace_queue is created for each CPU. It is assumed that the auxtrace
41  * data is in ascending order.
42  *
43  * Each queue has a double linked list of auxtrace_buffers. This list contains
44  * the offset and size of a CPU's auxtrace data. During auxtrace processing
45  * the data portion is mmap()'ed.
46  *
47  * To sort the queues in chronological order, all queue access is controlled
48  * by the auxtrace_heap. This is basicly a stack, each stack element has two
49  * entries, the queue number and a time stamp. However the stack is sorted by
50  * the time stamps. The highest time stamp is at the bottom the lowest
51  * (nearest) time stamp is at the top. That sort order is maintained at all
52  * times!
53  *
54  * After the auxtrace infrastructure has been setup, the auxtrace queues are
55  * filled with data (offset/size pairs) and the auxtrace_heap is populated.
56  *
57  * 2. PERF_RECORD_XXX processing triggers access to the auxtrace_queues.
58  * Each record is handled by s390_cpumsf_process_event(). The time stamp of
59  * the perf record is compared with the time stamp located on the auxtrace_heap
60  * top element. If that time stamp is lower than the time stamp from the
61  * record sample, the auxtrace queues will be processed. As auxtrace queues
62  * control many auxtrace_buffers and each buffer can be quite large, the
63  * auxtrace buffer might be processed only partially. In this case the
64  * position in the auxtrace_buffer of that queue is remembered and the time
65  * stamp of the last processed entry of the auxtrace_buffer replaces the
66  * current auxtrace_heap top.
67  *
68  * 3. Auxtrace_queues might run of out data and are feeded by the
69  * PERF_RECORD_AUXTRACE handling, see s390_cpumsf_process_auxtrace_event().
70  *
71  * Event Generation
72  * Each sampling-data entry in the auxilary trace data generates a perf sample.
73  * This sample is filled
74  * with data from the auxtrace such as PID/TID, instruction address, CPU state,
75  * etc. This sample is processed with perf_session__deliver_synth_event() to
76  * be included into the GUI.
77  *
78  * 4. PERF_RECORD_FINISHED_ROUND event is used to process all the remaining
79  * auxiliary traces entries until the time stamp of this record is reached
80  * auxtrace_heap top. This is triggered by ordered_event->deliver().
81  *
82  *
83  * Perf event processing.
84  * Event processing of PERF_RECORD_XXX entries relies on time stamp entries.
85  * This is the function call sequence:
86  *
87  * __cmd_report()
88  * |
89  * perf_session__process_events()
90  * |
91  * __perf_session__process_events()
92  * |
93  * perf_session__process_event()
94  * |  This functions splits the PERF_RECORD_XXX records.
95  * |  - Those generated by perf record command (type number equal or higher
96  * |    than PERF_RECORD_USER_TYPE_START) are handled by
97  * |    perf_session__process_user_event(see below)
98  * |  - Those generated by the kernel are handled by
99  * |    evlist__parse_sample_timestamp()
100  * |
101  * evlist__parse_sample_timestamp()
102  * |  Extract time stamp from sample data.
103  * |
104  * perf_session__queue_event()
105  * |  If timestamp is positive the sample is entered into an ordered_event
106  * |  list, sort order is the timestamp. The event processing is deferred until
107  * |  later (see perf_session__process_user_event()).
108  * |  Other timestamps (0 or -1) are handled immediately by
109  * |  perf_session__deliver_event(). These are events generated at start up
110  * |  of command perf record. They create PERF_RECORD_COMM and PERF_RECORD_MMAP*
111  * |  records. They are needed to create a list of running processes and its
112  * |  memory mappings and layout. They are needed at the beginning to enable
113  * |  command perf report to create process trees and memory mappings.
114  * |
115  * perf_session__deliver_event()
116  * |  Delivers a PERF_RECORD_XXX entry for handling.
117  * |
118  * auxtrace__process_event()
119  * |  The timestamp of the PERF_RECORD_XXX entry is taken to correlate with
120  * |  time stamps from the auxiliary trace buffers. This enables
121  * |  synchronization between auxiliary trace data and the events on the
122  * |  perf.data file.
123  * |
124  * machine__deliver_event()
125  * |  Handles the PERF_RECORD_XXX event. This depends on the record type.
126  *    It might update the process tree, update a process memory map or enter
127  *    a sample with IP and call back chain data into GUI data pool.
128  *
129  *
130  * Deferred processing determined by perf_session__process_user_event() is
131  * finally processed when a PERF_RECORD_FINISHED_ROUND is encountered. These
132  * are generated during command perf record.
133  * The timestamp of PERF_RECORD_FINISHED_ROUND event is taken to process all
134  * PERF_RECORD_XXX entries stored in the ordered_event list. This list was
135  * built up while reading the perf.data file.
136  * Each event is now processed by calling perf_session__deliver_event().
137  * This enables time synchronization between the data in the perf.data file and
138  * the data in the auxiliary trace buffers.
139  */
140 
141 #include <endian.h>
142 #include <errno.h>
143 #include <byteswap.h>
144 #include <inttypes.h>
145 #include <linux/kernel.h>
146 #include <linux/types.h>
147 #include <linux/bitops.h>
148 #include <linux/log2.h>
149 #include <linux/zalloc.h>
150 
151 #include <sys/stat.h>
152 #include <sys/types.h>
153 
154 #include "color.h"
155 #include "evsel.h"
156 #include "evlist.h"
157 #include "machine.h"
158 #include "session.h"
159 #include "tool.h"
160 #include "debug.h"
161 #include "auxtrace.h"
162 #include "s390-cpumsf.h"
163 #include "s390-cpumsf-kernel.h"
164 #include "s390-cpumcf-kernel.h"
165 #include "config.h"
166 
167 struct s390_cpumsf {
168 	struct auxtrace		auxtrace;
169 	struct auxtrace_queues	queues;
170 	struct auxtrace_heap	heap;
171 	struct perf_session	*session;
172 	struct machine		*machine;
173 	u32			auxtrace_type;
174 	u32			pmu_type;
175 	u16			machine_type;
176 	bool			data_queued;
177 	bool			use_logfile;
178 	char			*logdir;
179 };
180 
181 struct s390_cpumsf_queue {
182 	struct s390_cpumsf	*sf;
183 	unsigned int		queue_nr;
184 	struct auxtrace_buffer	*buffer;
185 	int			cpu;
186 	FILE			*logfile;
187 	FILE			*logfile_ctr;
188 };
189 
190 /* Check if the raw data should be dumped to file. If this is the case and
191  * the file to dump to has not been opened for writing, do so.
192  *
193  * Return 0 on success and greater zero on error so processing continues.
194  */
195 static int s390_cpumcf_dumpctr(struct s390_cpumsf *sf,
196 			       struct perf_sample *sample)
197 {
198 	struct s390_cpumsf_queue *sfq;
199 	struct auxtrace_queue *q;
200 	int rc = 0;
201 
202 	if (!sf->use_logfile || sf->queues.nr_queues <= sample->cpu)
203 		return rc;
204 
205 	q = &sf->queues.queue_array[sample->cpu];
206 	sfq = q->priv;
207 	if (!sfq)		/* Queue not yet allocated */
208 		return rc;
209 
210 	if (!sfq->logfile_ctr) {
211 		char *name;
212 
213 		rc = (sf->logdir)
214 			? asprintf(&name, "%s/aux.ctr.%02x",
215 				 sf->logdir, sample->cpu)
216 			: asprintf(&name, "aux.ctr.%02x", sample->cpu);
217 		if (rc > 0)
218 			sfq->logfile_ctr = fopen(name, "w");
219 		if (sfq->logfile_ctr == NULL) {
220 			pr_err("Failed to open counter set log file %s, "
221 			       "continue...\n", name);
222 			rc = 1;
223 		}
224 		free(name);
225 	}
226 
227 	if (sfq->logfile_ctr) {
228 		/* See comment above for -4 */
229 		size_t n = fwrite(sample->raw_data, sample->raw_size - 4, 1,
230 				  sfq->logfile_ctr);
231 		if (n != 1) {
232 			pr_err("Failed to write counter set data\n");
233 			rc = 1;
234 		}
235 	}
236 	return rc;
237 }
238 
239 /* Display s390 CPU measurement facility basic-sampling data entry
240  * Data written on s390 in big endian byte order and contains bit
241  * fields across byte boundaries.
242  */
243 static bool s390_cpumsf_basic_show(const char *color, size_t pos,
244 				   struct hws_basic_entry *basicp)
245 {
246 	struct hws_basic_entry *basic = basicp;
247 #if __BYTE_ORDER == __LITTLE_ENDIAN
248 	struct hws_basic_entry local;
249 	unsigned long long word = be64toh(*(unsigned long long *)basicp);
250 
251 	memset(&local, 0, sizeof(local));
252 	local.def = be16toh(basicp->def);
253 	local.prim_asn = word & 0xffff;
254 	local.CL = word >> 30 & 0x3;
255 	local.I = word >> 32 & 0x1;
256 	local.AS = word >> 33 & 0x3;
257 	local.P = word >> 35 & 0x1;
258 	local.W = word >> 36 & 0x1;
259 	local.T = word >> 37 & 0x1;
260 	local.U = word >> 40 & 0xf;
261 	local.ia = be64toh(basicp->ia);
262 	local.gpp = be64toh(basicp->gpp);
263 	local.hpp = be64toh(basicp->hpp);
264 	basic = &local;
265 #endif
266 	if (basic->def != 1) {
267 		pr_err("Invalid AUX trace basic entry [%#08zx]\n", pos);
268 		return false;
269 	}
270 	color_fprintf(stdout, color, "    [%#08zx] Basic   Def:%04x Inst:%#04x"
271 		      " %c%c%c%c AS:%d ASN:%#04x IA:%#018llx\n"
272 		      "\t\tCL:%d HPP:%#018llx GPP:%#018llx\n",
273 		      pos, basic->def, basic->U,
274 		      basic->T ? 'T' : ' ',
275 		      basic->W ? 'W' : ' ',
276 		      basic->P ? 'P' : ' ',
277 		      basic->I ? 'I' : ' ',
278 		      basic->AS, basic->prim_asn, basic->ia, basic->CL,
279 		      basic->hpp, basic->gpp);
280 	return true;
281 }
282 
283 /* Display s390 CPU measurement facility diagnostic-sampling data entry.
284  * Data written on s390 in big endian byte order and contains bit
285  * fields across byte boundaries.
286  */
287 static bool s390_cpumsf_diag_show(const char *color, size_t pos,
288 				  struct hws_diag_entry *diagp)
289 {
290 	struct hws_diag_entry *diag = diagp;
291 #if __BYTE_ORDER == __LITTLE_ENDIAN
292 	struct hws_diag_entry local;
293 	unsigned long long word = be64toh(*(unsigned long long *)diagp);
294 
295 	local.def = be16toh(diagp->def);
296 	local.I = word >> 32 & 0x1;
297 	diag = &local;
298 #endif
299 	if (diag->def < S390_CPUMSF_DIAG_DEF_FIRST) {
300 		pr_err("Invalid AUX trace diagnostic entry [%#08zx]\n", pos);
301 		return false;
302 	}
303 	color_fprintf(stdout, color, "    [%#08zx] Diag    Def:%04x %c\n",
304 		      pos, diag->def, diag->I ? 'I' : ' ');
305 	return true;
306 }
307 
308 /* Return TOD timestamp contained in an trailer entry */
309 static unsigned long long trailer_timestamp(struct hws_trailer_entry *te,
310 					    int idx)
311 {
312 	/* te->t set: TOD in STCKE format, bytes 8-15
313 	 * to->t not set: TOD in STCK format, bytes 0-7
314 	 */
315 	unsigned long long ts;
316 
317 	memcpy(&ts, &te->timestamp[idx], sizeof(ts));
318 	return be64toh(ts);
319 }
320 
321 /* Display s390 CPU measurement facility trailer entry */
322 static bool s390_cpumsf_trailer_show(const char *color, size_t pos,
323 				     struct hws_trailer_entry *te)
324 {
325 #if __BYTE_ORDER == __LITTLE_ENDIAN
326 	struct hws_trailer_entry local;
327 	const unsigned long long flags = be64toh(te->flags);
328 
329 	memset(&local, 0, sizeof(local));
330 	local.f = flags >> 63 & 0x1;
331 	local.a = flags >> 62 & 0x1;
332 	local.t = flags >> 61 & 0x1;
333 	local.bsdes = be16toh((flags >> 16 & 0xffff));
334 	local.dsdes = be16toh((flags & 0xffff));
335 	memcpy(&local.timestamp, te->timestamp, sizeof(te->timestamp));
336 	local.overflow = be64toh(te->overflow);
337 	local.clock_base = be64toh(te->progusage[0]) >> 63 & 1;
338 	local.progusage2 = be64toh(te->progusage2);
339 	te = &local;
340 #endif
341 	if (te->bsdes != sizeof(struct hws_basic_entry)) {
342 		pr_err("Invalid AUX trace trailer entry [%#08zx]\n", pos);
343 		return false;
344 	}
345 	color_fprintf(stdout, color, "    [%#08zx] Trailer %c%c%c bsdes:%d"
346 		      " dsdes:%d Overflow:%lld Time:%#llx\n"
347 		      "\t\tC:%d TOD:%#lx\n",
348 		      pos,
349 		      te->f ? 'F' : ' ',
350 		      te->a ? 'A' : ' ',
351 		      te->t ? 'T' : ' ',
352 		      te->bsdes, te->dsdes, te->overflow,
353 		      trailer_timestamp(te, te->clock_base),
354 		      te->clock_base, te->progusage2);
355 	return true;
356 }
357 
358 /* Test a sample data block. It must be 4KB or a multiple thereof in size and
359  * 4KB page aligned. Each sample data page has a trailer entry at the
360  * end which contains the sample entry data sizes.
361  *
362  * Return true if the sample data block passes the checks and set the
363  * basic set entry size and diagnostic set entry size.
364  *
365  * Return false on failure.
366  *
367  * Note: Old hardware does not set the basic or diagnostic entry sizes
368  * in the trailer entry. Use the type number instead.
369  */
370 static bool s390_cpumsf_validate(int machine_type,
371 				 unsigned char *buf, size_t len,
372 				 unsigned short *bsdes,
373 				 unsigned short *dsdes)
374 {
375 	struct hws_basic_entry *basic = (struct hws_basic_entry *)buf;
376 	struct hws_trailer_entry *te;
377 
378 	*dsdes = *bsdes = 0;
379 	if (len & (S390_CPUMSF_PAGESZ - 1))	/* Illegal size */
380 		return false;
381 	if (be16toh(basic->def) != 1)	/* No basic set entry, must be first */
382 		return false;
383 	/* Check for trailer entry at end of SDB */
384 	te = (struct hws_trailer_entry *)(buf + S390_CPUMSF_PAGESZ
385 					      - sizeof(*te));
386 	*bsdes = be16toh(te->bsdes);
387 	*dsdes = be16toh(te->dsdes);
388 	if (!te->bsdes && !te->dsdes) {
389 		/* Very old hardware, use CPUID */
390 		switch (machine_type) {
391 		case 2097:
392 		case 2098:
393 			*dsdes = 64;
394 			*bsdes = 32;
395 			break;
396 		case 2817:
397 		case 2818:
398 			*dsdes = 74;
399 			*bsdes = 32;
400 			break;
401 		case 2827:
402 		case 2828:
403 			*dsdes = 85;
404 			*bsdes = 32;
405 			break;
406 		case 2964:
407 		case 2965:
408 			*dsdes = 112;
409 			*bsdes = 32;
410 			break;
411 		default:
412 			/* Illegal trailer entry */
413 			return false;
414 		}
415 	}
416 	return true;
417 }
418 
419 /* Return true if there is room for another entry */
420 static bool s390_cpumsf_reached_trailer(size_t entry_sz, size_t pos)
421 {
422 	size_t payload = S390_CPUMSF_PAGESZ - sizeof(struct hws_trailer_entry);
423 
424 	if (payload - (pos & (S390_CPUMSF_PAGESZ - 1)) < entry_sz)
425 		return false;
426 	return true;
427 }
428 
429 /* Dump an auxiliary buffer. These buffers are multiple of
430  * 4KB SDB pages.
431  */
432 static void s390_cpumsf_dump(struct s390_cpumsf *sf,
433 			     unsigned char *buf, size_t len)
434 {
435 	const char *color = PERF_COLOR_BLUE;
436 	struct hws_basic_entry *basic;
437 	struct hws_diag_entry *diag;
438 	unsigned short bsdes, dsdes;
439 	size_t pos = 0;
440 
441 	color_fprintf(stdout, color,
442 		      ". ... s390 AUX data: size %zu bytes\n",
443 		      len);
444 
445 	if (!s390_cpumsf_validate(sf->machine_type, buf, len, &bsdes,
446 				  &dsdes)) {
447 		pr_err("Invalid AUX trace data block size:%zu"
448 		       " (type:%d bsdes:%hd dsdes:%hd)\n",
449 		       len, sf->machine_type, bsdes, dsdes);
450 		return;
451 	}
452 
453 	/* s390 kernel always returns 4KB blocks fully occupied,
454 	 * no partially filled SDBs.
455 	 */
456 	while (pos < len) {
457 		/* Handle Basic entry */
458 		basic = (struct hws_basic_entry *)(buf + pos);
459 		if (s390_cpumsf_basic_show(color, pos, basic))
460 			pos += bsdes;
461 		else
462 			return;
463 
464 		/* Handle Diagnostic entry */
465 		diag = (struct hws_diag_entry *)(buf + pos);
466 		if (s390_cpumsf_diag_show(color, pos, diag))
467 			pos += dsdes;
468 		else
469 			return;
470 
471 		/* Check for trailer entry */
472 		if (!s390_cpumsf_reached_trailer(bsdes + dsdes, pos)) {
473 			/* Show trailer entry */
474 			struct hws_trailer_entry te;
475 
476 			pos = (pos + S390_CPUMSF_PAGESZ)
477 			       & ~(S390_CPUMSF_PAGESZ - 1);
478 			pos -= sizeof(te);
479 			memcpy(&te, buf + pos, sizeof(te));
480 			/* Set descriptor sizes in case of old hardware
481 			 * where these values are not set.
482 			 */
483 			te.bsdes = bsdes;
484 			te.dsdes = dsdes;
485 			if (s390_cpumsf_trailer_show(color, pos, &te))
486 				pos += sizeof(te);
487 			else
488 				return;
489 		}
490 	}
491 }
492 
493 static void s390_cpumsf_dump_event(struct s390_cpumsf *sf, unsigned char *buf,
494 				   size_t len)
495 {
496 	printf(".\n");
497 	s390_cpumsf_dump(sf, buf, len);
498 }
499 
500 #define	S390_LPP_PID_MASK	0xffffffff
501 
502 static bool s390_cpumsf_make_event(size_t pos,
503 				   struct hws_basic_entry *basic,
504 				   struct s390_cpumsf_queue *sfq)
505 {
506 	struct perf_sample sample = {
507 				.ip = basic->ia,
508 				.pid = basic->hpp & S390_LPP_PID_MASK,
509 				.tid = basic->hpp & S390_LPP_PID_MASK,
510 				.cpumode = PERF_RECORD_MISC_CPUMODE_UNKNOWN,
511 				.cpu = sfq->cpu,
512 				.period = 1
513 			    };
514 	union perf_event event;
515 
516 	memset(&event, 0, sizeof(event));
517 	if (basic->CL == 1)	/* Native LPAR mode */
518 		sample.cpumode = basic->P ? PERF_RECORD_MISC_USER
519 					  : PERF_RECORD_MISC_KERNEL;
520 	else if (basic->CL == 2)	/* Guest kernel/user space */
521 		sample.cpumode = basic->P ? PERF_RECORD_MISC_GUEST_USER
522 					  : PERF_RECORD_MISC_GUEST_KERNEL;
523 	else if (basic->gpp || basic->prim_asn != 0xffff)
524 		/* Use heuristics on old hardware */
525 		sample.cpumode = basic->P ? PERF_RECORD_MISC_GUEST_USER
526 					  : PERF_RECORD_MISC_GUEST_KERNEL;
527 	else
528 		sample.cpumode = basic->P ? PERF_RECORD_MISC_USER
529 					  : PERF_RECORD_MISC_KERNEL;
530 
531 	event.sample.header.type = PERF_RECORD_SAMPLE;
532 	event.sample.header.misc = sample.cpumode;
533 	event.sample.header.size = sizeof(struct perf_event_header);
534 
535 	pr_debug4("%s pos:%#zx ip:%#" PRIx64 " P:%d CL:%d pid:%d.%d cpumode:%d cpu:%d\n",
536 		 __func__, pos, sample.ip, basic->P, basic->CL, sample.pid,
537 		 sample.tid, sample.cpumode, sample.cpu);
538 	if (perf_session__deliver_synth_event(sfq->sf->session, &event,
539 					      &sample)) {
540 		pr_err("s390 Auxiliary Trace: failed to deliver event\n");
541 		return false;
542 	}
543 	return true;
544 }
545 
546 static unsigned long long get_trailer_time(const unsigned char *buf)
547 {
548 	struct hws_trailer_entry *te;
549 	unsigned long long aux_time, progusage2;
550 	bool clock_base;
551 
552 	te = (struct hws_trailer_entry *)(buf + S390_CPUMSF_PAGESZ
553 					      - sizeof(*te));
554 
555 #if __BYTE_ORDER == __LITTLE_ENDIAN
556 	clock_base = be64toh(te->progusage[0]) >> 63 & 0x1;
557 	progusage2 = be64toh(te->progusage[1]);
558 #else
559 	clock_base = te->clock_base;
560 	progusage2 = te->progusage2;
561 #endif
562 	if (!clock_base)	/* TOD_CLOCK_BASE value missing */
563 		return 0;
564 
565 	/* Correct calculation to convert time stamp in trailer entry to
566 	 * nano seconds (taken from arch/s390 function tod_to_ns()).
567 	 * TOD_CLOCK_BASE is stored in trailer entry member progusage2.
568 	 */
569 	aux_time = trailer_timestamp(te, clock_base) - progusage2;
570 	aux_time = (aux_time >> 9) * 125 + (((aux_time & 0x1ff) * 125) >> 9);
571 	return aux_time;
572 }
573 
574 /* Process the data samples of a single queue. The first parameter is a
575  * pointer to the queue, the second parameter is the time stamp. This
576  * is the time stamp:
577  * - of the event that triggered this processing.
578  * - or the time stamp when the last proccesing of this queue stopped.
579  *   In this case it stopped at a 4KB page boundary and record the
580  *   position on where to continue processing on the next invocation
581  *   (see buffer->use_data and buffer->use_size).
582  *
583  * When this function returns the second parameter is updated to
584  * reflect the time stamp of the last processed auxiliary data entry
585  * (taken from the trailer entry of that page). The caller uses this
586  * returned time stamp to record the last processed entry in this
587  * queue.
588  *
589  * The function returns:
590  * 0:  Processing successful. The second parameter returns the
591  *     time stamp from the trailer entry until which position
592  *     processing took place. Subsequent calls resume from this
593  *     position.
594  * <0: An error occurred during processing. The second parameter
595  *     returns the maximum time stamp.
596  * >0: Done on this queue. The second parameter returns the
597  *     maximum time stamp.
598  */
599 static int s390_cpumsf_samples(struct s390_cpumsf_queue *sfq, u64 *ts)
600 {
601 	struct s390_cpumsf *sf = sfq->sf;
602 	unsigned char *buf = sfq->buffer->use_data;
603 	size_t len = sfq->buffer->use_size;
604 	struct hws_basic_entry *basic;
605 	unsigned short bsdes, dsdes;
606 	size_t pos = 0;
607 	int err = 1;
608 	u64 aux_ts;
609 
610 	if (!s390_cpumsf_validate(sf->machine_type, buf, len, &bsdes,
611 				  &dsdes)) {
612 		*ts = ~0ULL;
613 		return -1;
614 	}
615 
616 	/* Get trailer entry time stamp and check if entries in
617 	 * this auxiliary page are ready for processing. If the
618 	 * time stamp of the first entry is too high, whole buffer
619 	 * can be skipped. In this case return time stamp.
620 	 */
621 	aux_ts = get_trailer_time(buf);
622 	if (!aux_ts) {
623 		pr_err("[%#08" PRIx64 "] Invalid AUX trailer entry TOD clock base\n",
624 		       (s64)sfq->buffer->data_offset);
625 		aux_ts = ~0ULL;
626 		goto out;
627 	}
628 	if (aux_ts > *ts) {
629 		*ts = aux_ts;
630 		return 0;
631 	}
632 
633 	while (pos < len) {
634 		/* Handle Basic entry */
635 		basic = (struct hws_basic_entry *)(buf + pos);
636 		if (s390_cpumsf_make_event(pos, basic, sfq))
637 			pos += bsdes;
638 		else {
639 			err = -EBADF;
640 			goto out;
641 		}
642 
643 		pos += dsdes;	/* Skip diagnositic entry */
644 
645 		/* Check for trailer entry */
646 		if (!s390_cpumsf_reached_trailer(bsdes + dsdes, pos)) {
647 			pos = (pos + S390_CPUMSF_PAGESZ)
648 			       & ~(S390_CPUMSF_PAGESZ - 1);
649 			/* Check existence of next page */
650 			if (pos >= len)
651 				break;
652 			aux_ts = get_trailer_time(buf + pos);
653 			if (!aux_ts) {
654 				aux_ts = ~0ULL;
655 				goto out;
656 			}
657 			if (aux_ts > *ts) {
658 				*ts = aux_ts;
659 				sfq->buffer->use_data += pos;
660 				sfq->buffer->use_size -= pos;
661 				return 0;
662 			}
663 		}
664 	}
665 out:
666 	*ts = aux_ts;
667 	sfq->buffer->use_size = 0;
668 	sfq->buffer->use_data = NULL;
669 	return err;	/* Buffer completely scanned or error */
670 }
671 
672 /* Run the s390 auxiliary trace decoder.
673  * Select the queue buffer to operate on, the caller already selected
674  * the proper queue, depending on second parameter 'ts'.
675  * This is the time stamp until which the auxiliary entries should
676  * be processed. This value is updated by called functions and
677  * returned to the caller.
678  *
679  * Resume processing in the current buffer. If there is no buffer
680  * get a new buffer from the queue and setup start position for
681  * processing.
682  * When a buffer is completely processed remove it from the queue
683  * before returning.
684  *
685  * This function returns
686  * 1: When the queue is empty. Second parameter will be set to
687  *    maximum time stamp.
688  * 0: Normal processing done.
689  * <0: Error during queue buffer setup. This causes the caller
690  *     to stop processing completely.
691  */
692 static int s390_cpumsf_run_decoder(struct s390_cpumsf_queue *sfq,
693 				   u64 *ts)
694 {
695 
696 	struct auxtrace_buffer *buffer;
697 	struct auxtrace_queue *queue;
698 	int err;
699 
700 	queue = &sfq->sf->queues.queue_array[sfq->queue_nr];
701 
702 	/* Get buffer and last position in buffer to resume
703 	 * decoding the auxiliary entries. One buffer might be large
704 	 * and decoding might stop in between. This depends on the time
705 	 * stamp of the trailer entry in each page of the auxiliary
706 	 * data and the time stamp of the event triggering the decoding.
707 	 */
708 	if (sfq->buffer == NULL) {
709 		sfq->buffer = buffer = auxtrace_buffer__next(queue,
710 							     sfq->buffer);
711 		if (!buffer) {
712 			*ts = ~0ULL;
713 			return 1;	/* Processing done on this queue */
714 		}
715 		/* Start with a new buffer on this queue */
716 		if (buffer->data) {
717 			buffer->use_size = buffer->size;
718 			buffer->use_data = buffer->data;
719 		}
720 		if (sfq->logfile) {	/* Write into log file */
721 			size_t rc = fwrite(buffer->data, buffer->size, 1,
722 					   sfq->logfile);
723 			if (rc != 1)
724 				pr_err("Failed to write auxiliary data\n");
725 		}
726 	} else
727 		buffer = sfq->buffer;
728 
729 	if (!buffer->data) {
730 		int fd = perf_data__fd(sfq->sf->session->data);
731 
732 		buffer->data = auxtrace_buffer__get_data(buffer, fd);
733 		if (!buffer->data)
734 			return -ENOMEM;
735 		buffer->use_size = buffer->size;
736 		buffer->use_data = buffer->data;
737 
738 		if (sfq->logfile) {	/* Write into log file */
739 			size_t rc = fwrite(buffer->data, buffer->size, 1,
740 					   sfq->logfile);
741 			if (rc != 1)
742 				pr_err("Failed to write auxiliary data\n");
743 		}
744 	}
745 	pr_debug4("%s queue_nr:%d buffer:%" PRId64 " offset:%#" PRIx64 " size:%#zx rest:%#zx\n",
746 		  __func__, sfq->queue_nr, buffer->buffer_nr, buffer->offset,
747 		  buffer->size, buffer->use_size);
748 	err = s390_cpumsf_samples(sfq, ts);
749 
750 	/* If non-zero, there is either an error (err < 0) or the buffer is
751 	 * completely done (err > 0). The error is unrecoverable, usually
752 	 * some descriptors could not be read successfully, so continue with
753 	 * the next buffer.
754 	 * In both cases the parameter 'ts' has been updated.
755 	 */
756 	if (err) {
757 		sfq->buffer = NULL;
758 		list_del_init(&buffer->list);
759 		auxtrace_buffer__free(buffer);
760 		if (err > 0)		/* Buffer done, no error */
761 			err = 0;
762 	}
763 	return err;
764 }
765 
766 static struct s390_cpumsf_queue *
767 s390_cpumsf_alloc_queue(struct s390_cpumsf *sf, unsigned int queue_nr)
768 {
769 	struct s390_cpumsf_queue *sfq;
770 
771 	sfq = zalloc(sizeof(struct s390_cpumsf_queue));
772 	if (sfq == NULL)
773 		return NULL;
774 
775 	sfq->sf = sf;
776 	sfq->queue_nr = queue_nr;
777 	sfq->cpu = -1;
778 	if (sf->use_logfile) {
779 		char *name;
780 		int rc;
781 
782 		rc = (sf->logdir)
783 			? asprintf(&name, "%s/aux.smp.%02x",
784 				 sf->logdir, queue_nr)
785 			: asprintf(&name, "aux.smp.%02x", queue_nr);
786 		if (rc > 0)
787 			sfq->logfile = fopen(name, "w");
788 		if (sfq->logfile == NULL) {
789 			pr_err("Failed to open auxiliary log file %s,"
790 			       "continue...\n", name);
791 			sf->use_logfile = false;
792 		}
793 		free(name);
794 	}
795 	return sfq;
796 }
797 
798 static int s390_cpumsf_setup_queue(struct s390_cpumsf *sf,
799 				   struct auxtrace_queue *queue,
800 				   unsigned int queue_nr, u64 ts)
801 {
802 	struct s390_cpumsf_queue *sfq = queue->priv;
803 
804 	if (list_empty(&queue->head))
805 		return 0;
806 
807 	if (sfq == NULL) {
808 		sfq = s390_cpumsf_alloc_queue(sf, queue_nr);
809 		if (!sfq)
810 			return -ENOMEM;
811 		queue->priv = sfq;
812 
813 		if (queue->cpu != -1)
814 			sfq->cpu = queue->cpu;
815 	}
816 	return auxtrace_heap__add(&sf->heap, queue_nr, ts);
817 }
818 
819 static int s390_cpumsf_setup_queues(struct s390_cpumsf *sf, u64 ts)
820 {
821 	unsigned int i;
822 	int ret = 0;
823 
824 	for (i = 0; i < sf->queues.nr_queues; i++) {
825 		ret = s390_cpumsf_setup_queue(sf, &sf->queues.queue_array[i],
826 					      i, ts);
827 		if (ret)
828 			break;
829 	}
830 	return ret;
831 }
832 
833 static int s390_cpumsf_update_queues(struct s390_cpumsf *sf, u64 ts)
834 {
835 	if (!sf->queues.new_data)
836 		return 0;
837 
838 	sf->queues.new_data = false;
839 	return s390_cpumsf_setup_queues(sf, ts);
840 }
841 
842 static int s390_cpumsf_process_queues(struct s390_cpumsf *sf, u64 timestamp)
843 {
844 	unsigned int queue_nr;
845 	u64 ts;
846 	int ret;
847 
848 	while (1) {
849 		struct auxtrace_queue *queue;
850 		struct s390_cpumsf_queue *sfq;
851 
852 		if (!sf->heap.heap_cnt)
853 			return 0;
854 
855 		if (sf->heap.heap_array[0].ordinal >= timestamp)
856 			return 0;
857 
858 		queue_nr = sf->heap.heap_array[0].queue_nr;
859 		queue = &sf->queues.queue_array[queue_nr];
860 		sfq = queue->priv;
861 
862 		auxtrace_heap__pop(&sf->heap);
863 		if (sf->heap.heap_cnt) {
864 			ts = sf->heap.heap_array[0].ordinal + 1;
865 			if (ts > timestamp)
866 				ts = timestamp;
867 		} else {
868 			ts = timestamp;
869 		}
870 
871 		ret = s390_cpumsf_run_decoder(sfq, &ts);
872 		if (ret < 0) {
873 			auxtrace_heap__add(&sf->heap, queue_nr, ts);
874 			return ret;
875 		}
876 		if (!ret) {
877 			ret = auxtrace_heap__add(&sf->heap, queue_nr, ts);
878 			if (ret < 0)
879 				return ret;
880 		}
881 	}
882 	return 0;
883 }
884 
885 static int s390_cpumsf_synth_error(struct s390_cpumsf *sf, int code, int cpu,
886 				   pid_t pid, pid_t tid, u64 ip, u64 timestamp)
887 {
888 	char msg[MAX_AUXTRACE_ERROR_MSG];
889 	union perf_event event;
890 	int err;
891 
892 	strncpy(msg, "Lost Auxiliary Trace Buffer", sizeof(msg) - 1);
893 	auxtrace_synth_error(&event.auxtrace_error, PERF_AUXTRACE_ERROR_ITRACE,
894 			     code, cpu, pid, tid, ip, msg, timestamp);
895 
896 	err = perf_session__deliver_synth_event(sf->session, &event, NULL);
897 	if (err)
898 		pr_err("s390 Auxiliary Trace: failed to deliver error event,"
899 			"error %d\n", err);
900 	return err;
901 }
902 
903 static int s390_cpumsf_lost(struct s390_cpumsf *sf, struct perf_sample *sample)
904 {
905 	return s390_cpumsf_synth_error(sf, 1, sample->cpu,
906 				       sample->pid, sample->tid, 0,
907 				       sample->time);
908 }
909 
910 static int
911 s390_cpumsf_process_event(struct perf_session *session,
912 			  union perf_event *event,
913 			  struct perf_sample *sample,
914 			  struct perf_tool *tool)
915 {
916 	struct s390_cpumsf *sf = container_of(session->auxtrace,
917 					      struct s390_cpumsf,
918 					      auxtrace);
919 	u64 timestamp = sample->time;
920 	struct evsel *ev_bc000;
921 
922 	int err = 0;
923 
924 	if (dump_trace)
925 		return 0;
926 
927 	if (!tool->ordered_events) {
928 		pr_err("s390 Auxiliary Trace requires ordered events\n");
929 		return -EINVAL;
930 	}
931 
932 	if (event->header.type == PERF_RECORD_SAMPLE &&
933 	    sample->raw_size) {
934 		/* Handle event with raw data */
935 		ev_bc000 = evlist__event2evsel(session->evlist, event);
936 		if (ev_bc000 &&
937 		    ev_bc000->core.attr.config == PERF_EVENT_CPUM_CF_DIAG)
938 			err = s390_cpumcf_dumpctr(sf, sample);
939 		return err;
940 	}
941 
942 	if (event->header.type == PERF_RECORD_AUX &&
943 	    event->aux.flags & PERF_AUX_FLAG_TRUNCATED)
944 		return s390_cpumsf_lost(sf, sample);
945 
946 	if (timestamp) {
947 		err = s390_cpumsf_update_queues(sf, timestamp);
948 		if (!err)
949 			err = s390_cpumsf_process_queues(sf, timestamp);
950 	}
951 	return err;
952 }
953 
954 struct s390_cpumsf_synth {
955 	struct perf_tool cpumsf_tool;
956 	struct perf_session *session;
957 };
958 
959 static int
960 s390_cpumsf_process_auxtrace_event(struct perf_session *session,
961 				   union perf_event *event __maybe_unused,
962 				   struct perf_tool *tool __maybe_unused)
963 {
964 	struct s390_cpumsf *sf = container_of(session->auxtrace,
965 					      struct s390_cpumsf,
966 					      auxtrace);
967 
968 	int fd = perf_data__fd(session->data);
969 	struct auxtrace_buffer *buffer;
970 	off_t data_offset;
971 	int err;
972 
973 	if (sf->data_queued)
974 		return 0;
975 
976 	if (perf_data__is_pipe(session->data)) {
977 		data_offset = 0;
978 	} else {
979 		data_offset = lseek(fd, 0, SEEK_CUR);
980 		if (data_offset == -1)
981 			return -errno;
982 	}
983 
984 	err = auxtrace_queues__add_event(&sf->queues, session, event,
985 					 data_offset, &buffer);
986 	if (err)
987 		return err;
988 
989 	/* Dump here after copying piped trace out of the pipe */
990 	if (dump_trace) {
991 		if (auxtrace_buffer__get_data(buffer, fd)) {
992 			s390_cpumsf_dump_event(sf, buffer->data,
993 					       buffer->size);
994 			auxtrace_buffer__put_data(buffer);
995 		}
996 	}
997 	return 0;
998 }
999 
1000 static void s390_cpumsf_free_events(struct perf_session *session __maybe_unused)
1001 {
1002 }
1003 
1004 static int s390_cpumsf_flush(struct perf_session *session __maybe_unused,
1005 			     struct perf_tool *tool __maybe_unused)
1006 {
1007 	return 0;
1008 }
1009 
1010 static void s390_cpumsf_free_queues(struct perf_session *session)
1011 {
1012 	struct s390_cpumsf *sf = container_of(session->auxtrace,
1013 					      struct s390_cpumsf,
1014 					      auxtrace);
1015 	struct auxtrace_queues *queues = &sf->queues;
1016 	unsigned int i;
1017 
1018 	for (i = 0; i < queues->nr_queues; i++) {
1019 		struct s390_cpumsf_queue *sfq = (struct s390_cpumsf_queue *)
1020 						queues->queue_array[i].priv;
1021 
1022 		if (sfq != NULL) {
1023 			if (sfq->logfile) {
1024 				fclose(sfq->logfile);
1025 				sfq->logfile = NULL;
1026 			}
1027 			if (sfq->logfile_ctr) {
1028 				fclose(sfq->logfile_ctr);
1029 				sfq->logfile_ctr = NULL;
1030 			}
1031 		}
1032 		zfree(&queues->queue_array[i].priv);
1033 	}
1034 	auxtrace_queues__free(queues);
1035 }
1036 
1037 static void s390_cpumsf_free(struct perf_session *session)
1038 {
1039 	struct s390_cpumsf *sf = container_of(session->auxtrace,
1040 					      struct s390_cpumsf,
1041 					      auxtrace);
1042 
1043 	auxtrace_heap__free(&sf->heap);
1044 	s390_cpumsf_free_queues(session);
1045 	session->auxtrace = NULL;
1046 	zfree(&sf->logdir);
1047 	free(sf);
1048 }
1049 
1050 static bool
1051 s390_cpumsf_evsel_is_auxtrace(struct perf_session *session __maybe_unused,
1052 			      struct evsel *evsel)
1053 {
1054 	return evsel->core.attr.type == PERF_TYPE_RAW &&
1055 	       evsel->core.attr.config == PERF_EVENT_CPUM_SF_DIAG;
1056 }
1057 
1058 static int s390_cpumsf_get_type(const char *cpuid)
1059 {
1060 	int ret, family = 0;
1061 
1062 	ret = sscanf(cpuid, "%*[^,],%u", &family);
1063 	return (ret == 1) ? family : 0;
1064 }
1065 
1066 /* Check itrace options set on perf report command.
1067  * Return true, if none are set or all options specified can be
1068  * handled on s390 (currently only option 'd' for logging.
1069  * Return false otherwise.
1070  */
1071 static bool check_auxtrace_itrace(struct itrace_synth_opts *itops)
1072 {
1073 	bool ison = false;
1074 
1075 	if (!itops || !itops->set)
1076 		return true;
1077 	ison = itops->inject || itops->instructions || itops->branches ||
1078 		itops->transactions || itops->ptwrites ||
1079 		itops->pwr_events || itops->errors ||
1080 		itops->dont_decode || itops->calls || itops->returns ||
1081 		itops->callchain || itops->thread_stack ||
1082 		itops->last_branch || itops->add_callchain ||
1083 		itops->add_last_branch;
1084 	if (!ison)
1085 		return true;
1086 	pr_err("Unsupported --itrace options specified\n");
1087 	return false;
1088 }
1089 
1090 /* Check for AUXTRACE dump directory if it is needed.
1091  * On failure print an error message but continue.
1092  * Return 0 on wrong keyword in config file and 1 otherwise.
1093  */
1094 static int s390_cpumsf__config(const char *var, const char *value, void *cb)
1095 {
1096 	struct s390_cpumsf *sf = cb;
1097 	struct stat stbuf;
1098 	int rc;
1099 
1100 	if (strcmp(var, "auxtrace.dumpdir"))
1101 		return 0;
1102 	sf->logdir = strdup(value);
1103 	if (sf->logdir == NULL) {
1104 		pr_err("Failed to find auxtrace log directory %s,"
1105 		       " continue with current directory...\n", value);
1106 		return 1;
1107 	}
1108 	rc = stat(sf->logdir, &stbuf);
1109 	if (rc == -1 || !S_ISDIR(stbuf.st_mode)) {
1110 		pr_err("Missing auxtrace log directory %s,"
1111 		       " continue with current directory...\n", value);
1112 		zfree(&sf->logdir);
1113 	}
1114 	return 1;
1115 }
1116 
1117 int s390_cpumsf_process_auxtrace_info(union perf_event *event,
1118 				      struct perf_session *session)
1119 {
1120 	struct perf_record_auxtrace_info *auxtrace_info = &event->auxtrace_info;
1121 	struct s390_cpumsf *sf;
1122 	int err;
1123 
1124 	if (auxtrace_info->header.size < sizeof(struct perf_record_auxtrace_info))
1125 		return -EINVAL;
1126 
1127 	sf = zalloc(sizeof(struct s390_cpumsf));
1128 	if (sf == NULL)
1129 		return -ENOMEM;
1130 
1131 	if (!check_auxtrace_itrace(session->itrace_synth_opts)) {
1132 		err = -EINVAL;
1133 		goto err_free;
1134 	}
1135 	sf->use_logfile = session->itrace_synth_opts->log;
1136 	if (sf->use_logfile)
1137 		perf_config(s390_cpumsf__config, sf);
1138 
1139 	err = auxtrace_queues__init(&sf->queues);
1140 	if (err)
1141 		goto err_free;
1142 
1143 	sf->session = session;
1144 	sf->machine = &session->machines.host; /* No kvm support */
1145 	sf->auxtrace_type = auxtrace_info->type;
1146 	sf->pmu_type = PERF_TYPE_RAW;
1147 	sf->machine_type = s390_cpumsf_get_type(session->evlist->env->cpuid);
1148 
1149 	sf->auxtrace.process_event = s390_cpumsf_process_event;
1150 	sf->auxtrace.process_auxtrace_event = s390_cpumsf_process_auxtrace_event;
1151 	sf->auxtrace.flush_events = s390_cpumsf_flush;
1152 	sf->auxtrace.free_events = s390_cpumsf_free_events;
1153 	sf->auxtrace.free = s390_cpumsf_free;
1154 	sf->auxtrace.evsel_is_auxtrace = s390_cpumsf_evsel_is_auxtrace;
1155 	session->auxtrace = &sf->auxtrace;
1156 
1157 	if (dump_trace)
1158 		return 0;
1159 
1160 	err = auxtrace_queues__process_index(&sf->queues, session);
1161 	if (err)
1162 		goto err_free_queues;
1163 
1164 	if (sf->queues.populated)
1165 		sf->data_queued = true;
1166 
1167 	return 0;
1168 
1169 err_free_queues:
1170 	auxtrace_queues__free(&sf->queues);
1171 	session->auxtrace = NULL;
1172 err_free:
1173 	zfree(&sf->logdir);
1174 	free(sf);
1175 	return err;
1176 }
1177