1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * intel_pt_pkt_decoder.c: Intel Processor Trace support
4  * Copyright (c) 2013-2014, Intel Corporation.
5  */
6 
7 #include <stdio.h>
8 #include <string.h>
9 #include <endian.h>
10 #include <byteswap.h>
11 #include <linux/compiler.h>
12 
13 #include "intel-pt-pkt-decoder.h"
14 
15 #define BIT(n)		(1 << (n))
16 
17 #define BIT63		((uint64_t)1 << 63)
18 
19 #define NR_FLAG		BIT63
20 
21 #if __BYTE_ORDER == __BIG_ENDIAN
22 #define le16_to_cpu bswap_16
23 #define le32_to_cpu bswap_32
24 #define le64_to_cpu bswap_64
25 #define memcpy_le64(d, s, n) do { \
26 	memcpy((d), (s), (n));    \
27 	*(d) = le64_to_cpu(*(d)); \
28 } while (0)
29 #else
30 #define le16_to_cpu
31 #define le32_to_cpu
32 #define le64_to_cpu
33 #define memcpy_le64 memcpy
34 #endif
35 
36 static const char * const packet_name[] = {
37 	[INTEL_PT_BAD]		= "Bad Packet!",
38 	[INTEL_PT_PAD]		= "PAD",
39 	[INTEL_PT_TNT]		= "TNT",
40 	[INTEL_PT_TIP_PGD]	= "TIP.PGD",
41 	[INTEL_PT_TIP_PGE]	= "TIP.PGE",
42 	[INTEL_PT_TSC]		= "TSC",
43 	[INTEL_PT_TMA]		= "TMA",
44 	[INTEL_PT_MODE_EXEC]	= "MODE.Exec",
45 	[INTEL_PT_MODE_TSX]	= "MODE.TSX",
46 	[INTEL_PT_MTC]		= "MTC",
47 	[INTEL_PT_TIP]		= "TIP",
48 	[INTEL_PT_FUP]		= "FUP",
49 	[INTEL_PT_CYC]		= "CYC",
50 	[INTEL_PT_VMCS]		= "VMCS",
51 	[INTEL_PT_PSB]		= "PSB",
52 	[INTEL_PT_PSBEND]	= "PSBEND",
53 	[INTEL_PT_CBR]		= "CBR",
54 	[INTEL_PT_TRACESTOP]	= "TraceSTOP",
55 	[INTEL_PT_PIP]		= "PIP",
56 	[INTEL_PT_OVF]		= "OVF",
57 	[INTEL_PT_MNT]		= "MNT",
58 	[INTEL_PT_PTWRITE]	= "PTWRITE",
59 	[INTEL_PT_PTWRITE_IP]	= "PTWRITE",
60 	[INTEL_PT_EXSTOP]	= "EXSTOP",
61 	[INTEL_PT_EXSTOP_IP]	= "EXSTOP",
62 	[INTEL_PT_MWAIT]	= "MWAIT",
63 	[INTEL_PT_PWRE]		= "PWRE",
64 	[INTEL_PT_PWRX]		= "PWRX",
65 	[INTEL_PT_BBP]		= "BBP",
66 	[INTEL_PT_BIP]		= "BIP",
67 	[INTEL_PT_BEP]		= "BEP",
68 	[INTEL_PT_BEP_IP]	= "BEP",
69 };
70 
71 const char *intel_pt_pkt_name(enum intel_pt_pkt_type type)
72 {
73 	return packet_name[type];
74 }
75 
76 static int intel_pt_get_long_tnt(const unsigned char *buf, size_t len,
77 				 struct intel_pt_pkt *packet)
78 {
79 	uint64_t payload;
80 	int count;
81 
82 	if (len < 8)
83 		return INTEL_PT_NEED_MORE_BYTES;
84 
85 	payload = le64_to_cpu(*(uint64_t *)buf);
86 
87 	for (count = 47; count; count--) {
88 		if (payload & BIT63)
89 			break;
90 		payload <<= 1;
91 	}
92 
93 	packet->type = INTEL_PT_TNT;
94 	packet->count = count;
95 	packet->payload = payload << 1;
96 	return 8;
97 }
98 
99 static int intel_pt_get_pip(const unsigned char *buf, size_t len,
100 			    struct intel_pt_pkt *packet)
101 {
102 	uint64_t payload = 0;
103 
104 	if (len < 8)
105 		return INTEL_PT_NEED_MORE_BYTES;
106 
107 	packet->type = INTEL_PT_PIP;
108 	memcpy_le64(&payload, buf + 2, 6);
109 	packet->payload = payload >> 1;
110 	if (payload & 1)
111 		packet->payload |= NR_FLAG;
112 
113 	return 8;
114 }
115 
116 static int intel_pt_get_tracestop(struct intel_pt_pkt *packet)
117 {
118 	packet->type = INTEL_PT_TRACESTOP;
119 	return 2;
120 }
121 
122 static int intel_pt_get_cbr(const unsigned char *buf, size_t len,
123 			    struct intel_pt_pkt *packet)
124 {
125 	if (len < 4)
126 		return INTEL_PT_NEED_MORE_BYTES;
127 	packet->type = INTEL_PT_CBR;
128 	packet->payload = le16_to_cpu(*(uint16_t *)(buf + 2));
129 	return 4;
130 }
131 
132 static int intel_pt_get_vmcs(const unsigned char *buf, size_t len,
133 			     struct intel_pt_pkt *packet)
134 {
135 	unsigned int count = (52 - 5) >> 3;
136 
137 	if (count < 1 || count > 7)
138 		return INTEL_PT_BAD_PACKET;
139 
140 	if (len < count + 2)
141 		return INTEL_PT_NEED_MORE_BYTES;
142 
143 	packet->type = INTEL_PT_VMCS;
144 	packet->count = count;
145 	memcpy_le64(&packet->payload, buf + 2, count);
146 
147 	return count + 2;
148 }
149 
150 static int intel_pt_get_ovf(struct intel_pt_pkt *packet)
151 {
152 	packet->type = INTEL_PT_OVF;
153 	return 2;
154 }
155 
156 static int intel_pt_get_psb(const unsigned char *buf, size_t len,
157 			    struct intel_pt_pkt *packet)
158 {
159 	int i;
160 
161 	if (len < 16)
162 		return INTEL_PT_NEED_MORE_BYTES;
163 
164 	for (i = 2; i < 16; i += 2) {
165 		if (buf[i] != 2 || buf[i + 1] != 0x82)
166 			return INTEL_PT_BAD_PACKET;
167 	}
168 
169 	packet->type = INTEL_PT_PSB;
170 	return 16;
171 }
172 
173 static int intel_pt_get_psbend(struct intel_pt_pkt *packet)
174 {
175 	packet->type = INTEL_PT_PSBEND;
176 	return 2;
177 }
178 
179 static int intel_pt_get_tma(const unsigned char *buf, size_t len,
180 			    struct intel_pt_pkt *packet)
181 {
182 	if (len < 7)
183 		return INTEL_PT_NEED_MORE_BYTES;
184 
185 	packet->type = INTEL_PT_TMA;
186 	packet->payload = buf[2] | (buf[3] << 8);
187 	packet->count = buf[5] | ((buf[6] & BIT(0)) << 8);
188 	return 7;
189 }
190 
191 static int intel_pt_get_pad(struct intel_pt_pkt *packet)
192 {
193 	packet->type = INTEL_PT_PAD;
194 	return 1;
195 }
196 
197 static int intel_pt_get_mnt(const unsigned char *buf, size_t len,
198 			    struct intel_pt_pkt *packet)
199 {
200 	if (len < 11)
201 		return INTEL_PT_NEED_MORE_BYTES;
202 	packet->type = INTEL_PT_MNT;
203 	memcpy_le64(&packet->payload, buf + 3, 8);
204 	return 11
205 ;
206 }
207 
208 static int intel_pt_get_3byte(const unsigned char *buf, size_t len,
209 			      struct intel_pt_pkt *packet)
210 {
211 	if (len < 3)
212 		return INTEL_PT_NEED_MORE_BYTES;
213 
214 	switch (buf[2]) {
215 	case 0x88: /* MNT */
216 		return intel_pt_get_mnt(buf, len, packet);
217 	default:
218 		return INTEL_PT_BAD_PACKET;
219 	}
220 }
221 
222 static int intel_pt_get_ptwrite(const unsigned char *buf, size_t len,
223 				struct intel_pt_pkt *packet)
224 {
225 	packet->count = (buf[1] >> 5) & 0x3;
226 	packet->type = buf[1] & BIT(7) ? INTEL_PT_PTWRITE_IP :
227 					 INTEL_PT_PTWRITE;
228 
229 	switch (packet->count) {
230 	case 0:
231 		if (len < 6)
232 			return INTEL_PT_NEED_MORE_BYTES;
233 		packet->payload = le32_to_cpu(*(uint32_t *)(buf + 2));
234 		return 6;
235 	case 1:
236 		if (len < 10)
237 			return INTEL_PT_NEED_MORE_BYTES;
238 		packet->payload = le64_to_cpu(*(uint64_t *)(buf + 2));
239 		return 10;
240 	default:
241 		return INTEL_PT_BAD_PACKET;
242 	}
243 }
244 
245 static int intel_pt_get_exstop(struct intel_pt_pkt *packet)
246 {
247 	packet->type = INTEL_PT_EXSTOP;
248 	return 2;
249 }
250 
251 static int intel_pt_get_exstop_ip(struct intel_pt_pkt *packet)
252 {
253 	packet->type = INTEL_PT_EXSTOP_IP;
254 	return 2;
255 }
256 
257 static int intel_pt_get_mwait(const unsigned char *buf, size_t len,
258 			      struct intel_pt_pkt *packet)
259 {
260 	if (len < 10)
261 		return INTEL_PT_NEED_MORE_BYTES;
262 	packet->type = INTEL_PT_MWAIT;
263 	packet->payload = le64_to_cpu(*(uint64_t *)(buf + 2));
264 	return 10;
265 }
266 
267 static int intel_pt_get_pwre(const unsigned char *buf, size_t len,
268 			     struct intel_pt_pkt *packet)
269 {
270 	if (len < 4)
271 		return INTEL_PT_NEED_MORE_BYTES;
272 	packet->type = INTEL_PT_PWRE;
273 	memcpy_le64(&packet->payload, buf + 2, 2);
274 	return 4;
275 }
276 
277 static int intel_pt_get_pwrx(const unsigned char *buf, size_t len,
278 			     struct intel_pt_pkt *packet)
279 {
280 	if (len < 7)
281 		return INTEL_PT_NEED_MORE_BYTES;
282 	packet->type = INTEL_PT_PWRX;
283 	memcpy_le64(&packet->payload, buf + 2, 5);
284 	return 7;
285 }
286 
287 static int intel_pt_get_bbp(const unsigned char *buf, size_t len,
288 			    struct intel_pt_pkt *packet)
289 {
290 	if (len < 3)
291 		return INTEL_PT_NEED_MORE_BYTES;
292 	packet->type = INTEL_PT_BBP;
293 	packet->count = buf[2] >> 7;
294 	packet->payload = buf[2] & 0x1f;
295 	return 3;
296 }
297 
298 static int intel_pt_get_bip_4(const unsigned char *buf, size_t len,
299 			      struct intel_pt_pkt *packet)
300 {
301 	if (len < 5)
302 		return INTEL_PT_NEED_MORE_BYTES;
303 	packet->type = INTEL_PT_BIP;
304 	packet->count = buf[0] >> 3;
305 	memcpy_le64(&packet->payload, buf + 1, 4);
306 	return 5;
307 }
308 
309 static int intel_pt_get_bip_8(const unsigned char *buf, size_t len,
310 			      struct intel_pt_pkt *packet)
311 {
312 	if (len < 9)
313 		return INTEL_PT_NEED_MORE_BYTES;
314 	packet->type = INTEL_PT_BIP;
315 	packet->count = buf[0] >> 3;
316 	memcpy_le64(&packet->payload, buf + 1, 8);
317 	return 9;
318 }
319 
320 static int intel_pt_get_bep(size_t len, struct intel_pt_pkt *packet)
321 {
322 	if (len < 2)
323 		return INTEL_PT_NEED_MORE_BYTES;
324 	packet->type = INTEL_PT_BEP;
325 	return 2;
326 }
327 
328 static int intel_pt_get_bep_ip(size_t len, struct intel_pt_pkt *packet)
329 {
330 	if (len < 2)
331 		return INTEL_PT_NEED_MORE_BYTES;
332 	packet->type = INTEL_PT_BEP_IP;
333 	return 2;
334 }
335 
336 static int intel_pt_get_ext(const unsigned char *buf, size_t len,
337 			    struct intel_pt_pkt *packet)
338 {
339 	if (len < 2)
340 		return INTEL_PT_NEED_MORE_BYTES;
341 
342 	if ((buf[1] & 0x1f) == 0x12)
343 		return intel_pt_get_ptwrite(buf, len, packet);
344 
345 	switch (buf[1]) {
346 	case 0xa3: /* Long TNT */
347 		return intel_pt_get_long_tnt(buf, len, packet);
348 	case 0x43: /* PIP */
349 		return intel_pt_get_pip(buf, len, packet);
350 	case 0x83: /* TraceStop */
351 		return intel_pt_get_tracestop(packet);
352 	case 0x03: /* CBR */
353 		return intel_pt_get_cbr(buf, len, packet);
354 	case 0xc8: /* VMCS */
355 		return intel_pt_get_vmcs(buf, len, packet);
356 	case 0xf3: /* OVF */
357 		return intel_pt_get_ovf(packet);
358 	case 0x82: /* PSB */
359 		return intel_pt_get_psb(buf, len, packet);
360 	case 0x23: /* PSBEND */
361 		return intel_pt_get_psbend(packet);
362 	case 0x73: /* TMA */
363 		return intel_pt_get_tma(buf, len, packet);
364 	case 0xC3: /* 3-byte header */
365 		return intel_pt_get_3byte(buf, len, packet);
366 	case 0x62: /* EXSTOP no IP */
367 		return intel_pt_get_exstop(packet);
368 	case 0xE2: /* EXSTOP with IP */
369 		return intel_pt_get_exstop_ip(packet);
370 	case 0xC2: /* MWAIT */
371 		return intel_pt_get_mwait(buf, len, packet);
372 	case 0x22: /* PWRE */
373 		return intel_pt_get_pwre(buf, len, packet);
374 	case 0xA2: /* PWRX */
375 		return intel_pt_get_pwrx(buf, len, packet);
376 	case 0x63: /* BBP */
377 		return intel_pt_get_bbp(buf, len, packet);
378 	case 0x33: /* BEP no IP */
379 		return intel_pt_get_bep(len, packet);
380 	case 0xb3: /* BEP with IP */
381 		return intel_pt_get_bep_ip(len, packet);
382 	default:
383 		return INTEL_PT_BAD_PACKET;
384 	}
385 }
386 
387 static int intel_pt_get_short_tnt(unsigned int byte,
388 				  struct intel_pt_pkt *packet)
389 {
390 	int count;
391 
392 	for (count = 6; count; count--) {
393 		if (byte & BIT(7))
394 			break;
395 		byte <<= 1;
396 	}
397 
398 	packet->type = INTEL_PT_TNT;
399 	packet->count = count;
400 	packet->payload = (uint64_t)byte << 57;
401 
402 	return 1;
403 }
404 
405 static int intel_pt_get_cyc(unsigned int byte, const unsigned char *buf,
406 			    size_t len, struct intel_pt_pkt *packet)
407 {
408 	unsigned int offs = 1, shift;
409 	uint64_t payload = byte >> 3;
410 
411 	byte >>= 2;
412 	len -= 1;
413 	for (shift = 5; byte & 1; shift += 7) {
414 		if (offs > 9)
415 			return INTEL_PT_BAD_PACKET;
416 		if (len < offs)
417 			return INTEL_PT_NEED_MORE_BYTES;
418 		byte = buf[offs++];
419 		payload |= ((uint64_t)byte >> 1) << shift;
420 	}
421 
422 	packet->type = INTEL_PT_CYC;
423 	packet->payload = payload;
424 	return offs;
425 }
426 
427 static int intel_pt_get_ip(enum intel_pt_pkt_type type, unsigned int byte,
428 			   const unsigned char *buf, size_t len,
429 			   struct intel_pt_pkt *packet)
430 {
431 	int ip_len;
432 
433 	packet->count = byte >> 5;
434 
435 	switch (packet->count) {
436 	case 0:
437 		ip_len = 0;
438 		break;
439 	case 1:
440 		if (len < 3)
441 			return INTEL_PT_NEED_MORE_BYTES;
442 		ip_len = 2;
443 		packet->payload = le16_to_cpu(*(uint16_t *)(buf + 1));
444 		break;
445 	case 2:
446 		if (len < 5)
447 			return INTEL_PT_NEED_MORE_BYTES;
448 		ip_len = 4;
449 		packet->payload = le32_to_cpu(*(uint32_t *)(buf + 1));
450 		break;
451 	case 3:
452 	case 4:
453 		if (len < 7)
454 			return INTEL_PT_NEED_MORE_BYTES;
455 		ip_len = 6;
456 		memcpy_le64(&packet->payload, buf + 1, 6);
457 		break;
458 	case 6:
459 		if (len < 9)
460 			return INTEL_PT_NEED_MORE_BYTES;
461 		ip_len = 8;
462 		packet->payload = le64_to_cpu(*(uint64_t *)(buf + 1));
463 		break;
464 	default:
465 		return INTEL_PT_BAD_PACKET;
466 	}
467 
468 	packet->type = type;
469 
470 	return ip_len + 1;
471 }
472 
473 static int intel_pt_get_mode(const unsigned char *buf, size_t len,
474 			     struct intel_pt_pkt *packet)
475 {
476 	if (len < 2)
477 		return INTEL_PT_NEED_MORE_BYTES;
478 
479 	switch (buf[1] >> 5) {
480 	case 0:
481 		packet->type = INTEL_PT_MODE_EXEC;
482 		switch (buf[1] & 3) {
483 		case 0:
484 			packet->payload = 16;
485 			break;
486 		case 1:
487 			packet->payload = 64;
488 			break;
489 		case 2:
490 			packet->payload = 32;
491 			break;
492 		default:
493 			return INTEL_PT_BAD_PACKET;
494 		}
495 		break;
496 	case 1:
497 		packet->type = INTEL_PT_MODE_TSX;
498 		if ((buf[1] & 3) == 3)
499 			return INTEL_PT_BAD_PACKET;
500 		packet->payload = buf[1] & 3;
501 		break;
502 	default:
503 		return INTEL_PT_BAD_PACKET;
504 	}
505 
506 	return 2;
507 }
508 
509 static int intel_pt_get_tsc(const unsigned char *buf, size_t len,
510 			    struct intel_pt_pkt *packet)
511 {
512 	if (len < 8)
513 		return INTEL_PT_NEED_MORE_BYTES;
514 	packet->type = INTEL_PT_TSC;
515 	memcpy_le64(&packet->payload, buf + 1, 7);
516 	return 8;
517 }
518 
519 static int intel_pt_get_mtc(const unsigned char *buf, size_t len,
520 			    struct intel_pt_pkt *packet)
521 {
522 	if (len < 2)
523 		return INTEL_PT_NEED_MORE_BYTES;
524 	packet->type = INTEL_PT_MTC;
525 	packet->payload = buf[1];
526 	return 2;
527 }
528 
529 static int intel_pt_do_get_packet(const unsigned char *buf, size_t len,
530 				  struct intel_pt_pkt *packet,
531 				  enum intel_pt_pkt_ctx ctx)
532 {
533 	unsigned int byte;
534 
535 	memset(packet, 0, sizeof(struct intel_pt_pkt));
536 
537 	if (!len)
538 		return INTEL_PT_NEED_MORE_BYTES;
539 
540 	byte = buf[0];
541 
542 	switch (ctx) {
543 	case INTEL_PT_NO_CTX:
544 		break;
545 	case INTEL_PT_BLK_4_CTX:
546 		if ((byte & 0x7) == 4)
547 			return intel_pt_get_bip_4(buf, len, packet);
548 		break;
549 	case INTEL_PT_BLK_8_CTX:
550 		if ((byte & 0x7) == 4)
551 			return intel_pt_get_bip_8(buf, len, packet);
552 		break;
553 	default:
554 		break;
555 	}
556 
557 	if (!(byte & BIT(0))) {
558 		if (byte == 0)
559 			return intel_pt_get_pad(packet);
560 		if (byte == 2)
561 			return intel_pt_get_ext(buf, len, packet);
562 		return intel_pt_get_short_tnt(byte, packet);
563 	}
564 
565 	if ((byte & 2))
566 		return intel_pt_get_cyc(byte, buf, len, packet);
567 
568 	switch (byte & 0x1f) {
569 	case 0x0D:
570 		return intel_pt_get_ip(INTEL_PT_TIP, byte, buf, len, packet);
571 	case 0x11:
572 		return intel_pt_get_ip(INTEL_PT_TIP_PGE, byte, buf, len,
573 				       packet);
574 	case 0x01:
575 		return intel_pt_get_ip(INTEL_PT_TIP_PGD, byte, buf, len,
576 				       packet);
577 	case 0x1D:
578 		return intel_pt_get_ip(INTEL_PT_FUP, byte, buf, len, packet);
579 	case 0x19:
580 		switch (byte) {
581 		case 0x99:
582 			return intel_pt_get_mode(buf, len, packet);
583 		case 0x19:
584 			return intel_pt_get_tsc(buf, len, packet);
585 		case 0x59:
586 			return intel_pt_get_mtc(buf, len, packet);
587 		default:
588 			return INTEL_PT_BAD_PACKET;
589 		}
590 	default:
591 		return INTEL_PT_BAD_PACKET;
592 	}
593 }
594 
595 void intel_pt_upd_pkt_ctx(const struct intel_pt_pkt *packet,
596 			  enum intel_pt_pkt_ctx *ctx)
597 {
598 	switch (packet->type) {
599 	case INTEL_PT_BAD:
600 	case INTEL_PT_PAD:
601 	case INTEL_PT_TSC:
602 	case INTEL_PT_TMA:
603 	case INTEL_PT_MTC:
604 	case INTEL_PT_FUP:
605 	case INTEL_PT_CYC:
606 	case INTEL_PT_CBR:
607 	case INTEL_PT_MNT:
608 	case INTEL_PT_EXSTOP:
609 	case INTEL_PT_EXSTOP_IP:
610 	case INTEL_PT_PWRE:
611 	case INTEL_PT_PWRX:
612 	case INTEL_PT_BIP:
613 		break;
614 	case INTEL_PT_TNT:
615 	case INTEL_PT_TIP:
616 	case INTEL_PT_TIP_PGD:
617 	case INTEL_PT_TIP_PGE:
618 	case INTEL_PT_MODE_EXEC:
619 	case INTEL_PT_MODE_TSX:
620 	case INTEL_PT_PIP:
621 	case INTEL_PT_OVF:
622 	case INTEL_PT_VMCS:
623 	case INTEL_PT_TRACESTOP:
624 	case INTEL_PT_PSB:
625 	case INTEL_PT_PSBEND:
626 	case INTEL_PT_PTWRITE:
627 	case INTEL_PT_PTWRITE_IP:
628 	case INTEL_PT_MWAIT:
629 	case INTEL_PT_BEP:
630 	case INTEL_PT_BEP_IP:
631 		*ctx = INTEL_PT_NO_CTX;
632 		break;
633 	case INTEL_PT_BBP:
634 		if (packet->count)
635 			*ctx = INTEL_PT_BLK_4_CTX;
636 		else
637 			*ctx = INTEL_PT_BLK_8_CTX;
638 		break;
639 	default:
640 		break;
641 	}
642 }
643 
644 int intel_pt_get_packet(const unsigned char *buf, size_t len,
645 			struct intel_pt_pkt *packet, enum intel_pt_pkt_ctx *ctx)
646 {
647 	int ret;
648 
649 	ret = intel_pt_do_get_packet(buf, len, packet, *ctx);
650 	if (ret > 0) {
651 		while (ret < 8 && len > (size_t)ret && !buf[ret])
652 			ret += 1;
653 		intel_pt_upd_pkt_ctx(packet, ctx);
654 	}
655 	return ret;
656 }
657 
658 int intel_pt_pkt_desc(const struct intel_pt_pkt *packet, char *buf,
659 		      size_t buf_len)
660 {
661 	int ret, i, nr;
662 	unsigned long long payload = packet->payload;
663 	const char *name = intel_pt_pkt_name(packet->type);
664 
665 	switch (packet->type) {
666 	case INTEL_PT_BAD:
667 	case INTEL_PT_PAD:
668 	case INTEL_PT_PSB:
669 	case INTEL_PT_PSBEND:
670 	case INTEL_PT_TRACESTOP:
671 	case INTEL_PT_OVF:
672 		return snprintf(buf, buf_len, "%s", name);
673 	case INTEL_PT_TNT: {
674 		size_t blen = buf_len;
675 
676 		ret = snprintf(buf, blen, "%s ", name);
677 		if (ret < 0)
678 			return ret;
679 		buf += ret;
680 		blen -= ret;
681 		for (i = 0; i < packet->count; i++) {
682 			if (payload & BIT63)
683 				ret = snprintf(buf, blen, "T");
684 			else
685 				ret = snprintf(buf, blen, "N");
686 			if (ret < 0)
687 				return ret;
688 			buf += ret;
689 			blen -= ret;
690 			payload <<= 1;
691 		}
692 		ret = snprintf(buf, blen, " (%d)", packet->count);
693 		if (ret < 0)
694 			return ret;
695 		blen -= ret;
696 		return buf_len - blen;
697 	}
698 	case INTEL_PT_TIP_PGD:
699 	case INTEL_PT_TIP_PGE:
700 	case INTEL_PT_TIP:
701 	case INTEL_PT_FUP:
702 		if (!(packet->count))
703 			return snprintf(buf, buf_len, "%s no ip", name);
704 		__fallthrough;
705 	case INTEL_PT_CYC:
706 	case INTEL_PT_VMCS:
707 	case INTEL_PT_MTC:
708 	case INTEL_PT_MNT:
709 	case INTEL_PT_CBR:
710 	case INTEL_PT_TSC:
711 		return snprintf(buf, buf_len, "%s 0x%llx", name, payload);
712 	case INTEL_PT_TMA:
713 		return snprintf(buf, buf_len, "%s CTC 0x%x FC 0x%x", name,
714 				(unsigned)payload, packet->count);
715 	case INTEL_PT_MODE_EXEC:
716 		return snprintf(buf, buf_len, "%s %lld", name, payload);
717 	case INTEL_PT_MODE_TSX:
718 		return snprintf(buf, buf_len, "%s TXAbort:%u InTX:%u",
719 				name, (unsigned)(payload >> 1) & 1,
720 				(unsigned)payload & 1);
721 	case INTEL_PT_PIP:
722 		nr = packet->payload & NR_FLAG ? 1 : 0;
723 		payload &= ~NR_FLAG;
724 		ret = snprintf(buf, buf_len, "%s 0x%llx (NR=%d)",
725 			       name, payload, nr);
726 		return ret;
727 	case INTEL_PT_PTWRITE:
728 		return snprintf(buf, buf_len, "%s 0x%llx IP:0", name, payload);
729 	case INTEL_PT_PTWRITE_IP:
730 		return snprintf(buf, buf_len, "%s 0x%llx IP:1", name, payload);
731 	case INTEL_PT_BEP:
732 	case INTEL_PT_EXSTOP:
733 		return snprintf(buf, buf_len, "%s IP:0", name);
734 	case INTEL_PT_BEP_IP:
735 	case INTEL_PT_EXSTOP_IP:
736 		return snprintf(buf, buf_len, "%s IP:1", name);
737 	case INTEL_PT_MWAIT:
738 		return snprintf(buf, buf_len, "%s 0x%llx Hints 0x%x Extensions 0x%x",
739 				name, payload, (unsigned int)(payload & 0xff),
740 				(unsigned int)((payload >> 32) & 0x3));
741 	case INTEL_PT_PWRE:
742 		return snprintf(buf, buf_len, "%s 0x%llx HW:%u CState:%u Sub-CState:%u",
743 				name, payload, !!(payload & 0x80),
744 				(unsigned int)((payload >> 12) & 0xf),
745 				(unsigned int)((payload >> 8) & 0xf));
746 	case INTEL_PT_PWRX:
747 		return snprintf(buf, buf_len, "%s 0x%llx Last CState:%u Deepest CState:%u Wake Reason 0x%x",
748 				name, payload,
749 				(unsigned int)((payload >> 4) & 0xf),
750 				(unsigned int)(payload & 0xf),
751 				(unsigned int)((payload >> 8) & 0xf));
752 	case INTEL_PT_BBP:
753 		return snprintf(buf, buf_len, "%s SZ %s-byte Type 0x%llx",
754 				name, packet->count ? "4" : "8", payload);
755 	case INTEL_PT_BIP:
756 		return snprintf(buf, buf_len, "%s ID 0x%02x Value 0x%llx",
757 				name, packet->count, payload);
758 	default:
759 		break;
760 	}
761 	return snprintf(buf, buf_len, "%s 0x%llx (%d)",
762 			name, payload, packet->count);
763 }
764