1
/* SPDX-License-Identifier: GPL-2.0 */
2
#if !defined(_TRACE_KVM_H) || defined(TRACE_HEADER_MULTI_READ)
3
#define _TRACE_KVM_H
4

5
#include <linux/tracepoint.h>
6
#include <asm/vmx.h>
7
#include <asm/svm.h>
8
#include <asm/clocksource.h>
9
#include <asm/pvclock-abi.h>
10

11
#undef TRACE_SYSTEM
12
#define TRACE_SYSTEM kvm
13

14
#ifdef CREATE_TRACE_POINTS
15
#define tracing_kvm_rip_read(vcpu) ({					\
16
	typeof(vcpu) __vcpu = vcpu;					\
17
	__vcpu->arch.guest_state_protected ? 0 : kvm_rip_read(__vcpu);	\
18
	})
19
#endif
20

21
/*
22
 * Tracepoint for guest mode entry.
23
 */
24
TRACE_EVENT(kvm_entry,
25
	TP_PROTO(struct kvm_vcpu *vcpu, bool force_immediate_exit),
26
	TP_ARGS(vcpu, force_immediate_exit),
27

28
	TP_STRUCT__entry(
29
		__field(	unsigned int,	vcpu_id		)
30
		__field(	unsigned long,	rip		)
31
		__field(	bool,		immediate_exit	)
32
		__field(	u32,		intr_info	)
33
		__field(	u32,		error_code	)
34
	),
35

36
	TP_fast_assign(
37
		__entry->vcpu_id        = vcpu->vcpu_id;
38
		__entry->rip		= tracing_kvm_rip_read(vcpu);
39
		__entry->immediate_exit	= force_immediate_exit;
40

41
		kvm_x86_call(get_entry_info)(vcpu, &__entry->intr_info,
42
					     &__entry->error_code);
43
	),
44

45
	TP_printk("vcpu %u, rip 0x%lx intr_info 0x%08x error_code 0x%08x%s",
46
		  __entry->vcpu_id, __entry->rip,
47
		  __entry->intr_info, __entry->error_code,
48
		  __entry->immediate_exit ? "[immediate exit]" : "")
49
);
50

51
/*
52
 * Tracepoint for hypercall.
53
 */
54
TRACE_EVENT(kvm_hypercall,
55
	TP_PROTO(unsigned long nr, unsigned long a0, unsigned long a1,
56
		 unsigned long a2, unsigned long a3),
57
	TP_ARGS(nr, a0, a1, a2, a3),
58

59
	TP_STRUCT__entry(
60
		__field(	unsigned long, 	nr		)
61
		__field(	unsigned long,	a0		)
62
		__field(	unsigned long,	a1		)
63
		__field(	unsigned long,	a2		)
64
		__field(	unsigned long,	a3		)
65
	),
66

67
	TP_fast_assign(
68
		__entry->nr		= nr;
69
		__entry->a0		= a0;
70
		__entry->a1		= a1;
71
		__entry->a2		= a2;
72
		__entry->a3		= a3;
73
	),
74

75
	TP_printk("nr 0x%lx a0 0x%lx a1 0x%lx a2 0x%lx a3 0x%lx",
76
		 __entry->nr, __entry->a0, __entry->a1,  __entry->a2,
77
		 __entry->a3)
78
);
79

80
/*
81
 * Tracepoint for hypercall.
82
 */
83
TRACE_EVENT(kvm_hv_hypercall,
84
	TP_PROTO(__u16 code, bool fast,  __u16 var_cnt, __u16 rep_cnt,
85
		 __u16 rep_idx, __u64 ingpa, __u64 outgpa),
86
	TP_ARGS(code, fast, var_cnt, rep_cnt, rep_idx, ingpa, outgpa),
87

88
	TP_STRUCT__entry(
89
		__field(	__u16,		rep_cnt		)
90
		__field(	__u16,		rep_idx		)
91
		__field(	__u64,		ingpa		)
92
		__field(	__u64,		outgpa		)
93
		__field(	__u16, 		code		)
94
		__field(	__u16,		var_cnt		)
95
		__field(	bool,		fast		)
96
	),
97

98
	TP_fast_assign(
99
		__entry->rep_cnt	= rep_cnt;
100
		__entry->rep_idx	= rep_idx;
101
		__entry->ingpa		= ingpa;
102
		__entry->outgpa		= outgpa;
103
		__entry->code		= code;
104
		__entry->var_cnt	= var_cnt;
105
		__entry->fast		= fast;
106
	),
107

108
	TP_printk("code 0x%x %s var_cnt 0x%x rep_cnt 0x%x idx 0x%x in 0x%llx out 0x%llx",
109
		  __entry->code, __entry->fast ? "fast" : "slow",
110
		  __entry->var_cnt, __entry->rep_cnt, __entry->rep_idx,
111
		  __entry->ingpa, __entry->outgpa)
112
);
113

114
TRACE_EVENT(kvm_hv_hypercall_done,
115
	TP_PROTO(u64 result),
116
	TP_ARGS(result),
117

118
	TP_STRUCT__entry(
119
		__field(__u64, result)
120
	),
121

122
	TP_fast_assign(
123
		__entry->result	= result;
124
	),
125

126
	TP_printk("result 0x%llx", __entry->result)
127
);
128

129
/*
130
 * Tracepoint for Xen hypercall.
131
 */
132
TRACE_EVENT(kvm_xen_hypercall,
133
	    TP_PROTO(u8 cpl, unsigned long nr,
134
		     unsigned long a0, unsigned long a1, unsigned long a2,
135
		     unsigned long a3, unsigned long a4, unsigned long a5),
136
	    TP_ARGS(cpl, nr, a0, a1, a2, a3, a4, a5),
137

138
	TP_STRUCT__entry(
139
		__field(u8, cpl)
140
		__field(unsigned long, nr)
141
		__field(unsigned long, a0)
142
		__field(unsigned long, a1)
143
		__field(unsigned long, a2)
144
		__field(unsigned long, a3)
145
		__field(unsigned long, a4)
146
		__field(unsigned long, a5)
147
	),
148

149
	TP_fast_assign(
150
		__entry->cpl = cpl;
151
		__entry->nr = nr;
152
		__entry->a0 = a0;
153
		__entry->a1 = a1;
154
		__entry->a2 = a2;
155
		__entry->a3 = a3;
156
		__entry->a4 = a4;
157
		__entry->a4 = a5;
158
	),
159

160
	TP_printk("cpl %d nr 0x%lx a0 0x%lx a1 0x%lx a2 0x%lx a3 0x%lx a4 0x%lx a5 %lx",
161
		  __entry->cpl, __entry->nr,
162
		  __entry->a0, __entry->a1, __entry->a2,
163
		  __entry->a3, __entry->a4, __entry->a5)
164
);
165

166

167

168
/*
169
 * Tracepoint for PIO.
170
 */
171

172
#define KVM_PIO_IN   0
173
#define KVM_PIO_OUT  1
174

175
TRACE_EVENT(kvm_pio,
176
	TP_PROTO(unsigned int rw, unsigned int port, unsigned int size,
177
		 unsigned int count, const void *data),
178
	TP_ARGS(rw, port, size, count, data),
179

180
	TP_STRUCT__entry(
181
		__field(	unsigned int, 	rw		)
182
		__field(	unsigned int, 	port		)
183
		__field(	unsigned int, 	size		)
184
		__field(	unsigned int,	count		)
185
		__field(	unsigned int,	val		)
186
	),
187

188
	TP_fast_assign(
189
		__entry->rw		= rw;
190
		__entry->port		= port;
191
		__entry->size		= size;
192
		__entry->count		= count;
193
		if (size == 1)
194
			__entry->val	= *(unsigned char *)data;
195
		else if (size == 2)
196
			__entry->val	= *(unsigned short *)data;
197
		else
198
			__entry->val	= *(unsigned int *)data;
199
	),
200

201
	TP_printk("pio_%s at 0x%x size %d count %d val 0x%x %s",
202
		  __entry->rw ? "write" : "read",
203
		  __entry->port, __entry->size, __entry->count, __entry->val,
204
		  __entry->count > 1 ? "(...)" : "")
205
);
206

207
/*
208
 * Tracepoint for fast mmio.
209
 */
210
TRACE_EVENT(kvm_fast_mmio,
211
	TP_PROTO(u64 gpa),
212
	TP_ARGS(gpa),
213

214
	TP_STRUCT__entry(
215
		__field(u64,	gpa)
216
	),
217

218
	TP_fast_assign(
219
		__entry->gpa		= gpa;
220
	),
221

222
	TP_printk("fast mmio at gpa 0x%llx", __entry->gpa)
223
);
224

225
/*
226
 * Tracepoint for cpuid.
227
 */
228
TRACE_EVENT(kvm_cpuid,
229
	TP_PROTO(unsigned int function, unsigned int index, unsigned long rax,
230
		 unsigned long rbx, unsigned long rcx, unsigned long rdx,
231
		 bool found, bool used_max_basic),
232
	TP_ARGS(function, index, rax, rbx, rcx, rdx, found, used_max_basic),
233

234
	TP_STRUCT__entry(
235
		__field(	unsigned int,	function	)
236
		__field(	unsigned int,	index		)
237
		__field(	unsigned long,	rax		)
238
		__field(	unsigned long,	rbx		)
239
		__field(	unsigned long,	rcx		)
240
		__field(	unsigned long,	rdx		)
241
		__field(	bool,		found		)
242
		__field(	bool,		used_max_basic	)
243
	),
244

245
	TP_fast_assign(
246
		__entry->function	= function;
247
		__entry->index		= index;
248
		__entry->rax		= rax;
249
		__entry->rbx		= rbx;
250
		__entry->rcx		= rcx;
251
		__entry->rdx		= rdx;
252
		__entry->found		= found;
253
		__entry->used_max_basic	= used_max_basic;
254
	),
255

256
	TP_printk("func %x idx %x rax %lx rbx %lx rcx %lx rdx %lx, cpuid entry %s%s",
257
		  __entry->function, __entry->index, __entry->rax,
258
		  __entry->rbx, __entry->rcx, __entry->rdx,
259
		  __entry->found ? "found" : "not found",
260
		  __entry->used_max_basic ? ", used max basic" : "")
261
);
262

263
#define kvm_deliver_mode		\
264
	{0x0, "Fixed"},			\
265
	{0x1, "LowPrio"},		\
266
	{0x2, "SMI"},			\
267
	{0x3, "Res3"},			\
268
	{0x4, "NMI"},			\
269
	{0x5, "INIT"},			\
270
	{0x6, "SIPI"},			\
271
	{0x7, "ExtINT"}
272

273
#ifdef CONFIG_KVM_IOAPIC
274
TRACE_EVENT(kvm_ioapic_set_irq,
275
	    TP_PROTO(__u64 e, int pin, bool coalesced),
276
	    TP_ARGS(e, pin, coalesced),
277

278
	TP_STRUCT__entry(
279
		__field(	__u64,		e		)
280
		__field(	int,		pin		)
281
		__field(	bool,		coalesced	)
282
	),
283

284
	TP_fast_assign(
285
		__entry->e		= e;
286
		__entry->pin		= pin;
287
		__entry->coalesced	= coalesced;
288
	),
289

290
	TP_printk("pin %u dst %x vec %u (%s|%s|%s%s)%s",
291
		  __entry->pin, (u8)(__entry->e >> 56), (u8)__entry->e,
292
		  __print_symbolic((__entry->e >> 8 & 0x7), kvm_deliver_mode),
293
		  (__entry->e & (1<<11)) ? "logical" : "physical",
294
		  (__entry->e & (1<<15)) ? "level" : "edge",
295
		  (__entry->e & (1<<16)) ? "|masked" : "",
296
		  __entry->coalesced ? " (coalesced)" : "")
297
);
298

299
TRACE_EVENT(kvm_ioapic_delayed_eoi_inj,
300
	    TP_PROTO(__u64 e),
301
	    TP_ARGS(e),
302

303
	TP_STRUCT__entry(
304
		__field(	__u64,		e		)
305
	),
306

307
	TP_fast_assign(
308
		__entry->e		= e;
309
	),
310

311
	TP_printk("dst %x vec %u (%s|%s|%s%s)",
312
		  (u8)(__entry->e >> 56), (u8)__entry->e,
313
		  __print_symbolic((__entry->e >> 8 & 0x7), kvm_deliver_mode),
314
		  (__entry->e & (1<<11)) ? "logical" : "physical",
315
		  (__entry->e & (1<<15)) ? "level" : "edge",
316
		  (__entry->e & (1<<16)) ? "|masked" : "")
317
);
318
#endif
319

320
TRACE_EVENT(kvm_msi_set_irq,
321
	    TP_PROTO(__u64 address, __u64 data),
322
	    TP_ARGS(address, data),
323

324
	TP_STRUCT__entry(
325
		__field(	__u64,		address		)
326
		__field(	__u64,		data		)
327
	),
328

329
	TP_fast_assign(
330
		__entry->address	= address;
331
		__entry->data		= data;
332
	),
333

334
	TP_printk("dst %llx vec %u (%s|%s|%s%s)",
335
		  (u8)(__entry->address >> 12) | ((__entry->address >> 32) & 0xffffff00),
336
		  (u8)__entry->data,
337
		  __print_symbolic((__entry->data >> 8 & 0x7), kvm_deliver_mode),
338
		  (__entry->address & (1<<2)) ? "logical" : "physical",
339
		  (__entry->data & (1<<15)) ? "level" : "edge",
340
		  (__entry->address & (1<<3)) ? "|rh" : "")
341
);
342

343
#define AREG(x) { APIC_##x, "APIC_" #x }
344

345
#define kvm_trace_symbol_apic						    \
346
	AREG(ID), AREG(LVR), AREG(TASKPRI), AREG(ARBPRI), AREG(PROCPRI),    \
347
	AREG(EOI), AREG(RRR), AREG(LDR), AREG(DFR), AREG(SPIV), AREG(ISR),  \
348
	AREG(TMR), AREG(IRR), AREG(ESR), AREG(ICR), AREG(ICR2), AREG(LVTT), \
349
	AREG(LVTTHMR), AREG(LVTPC), AREG(LVT0), AREG(LVT1), AREG(LVTERR),   \
350
	AREG(TMICT), AREG(TMCCT), AREG(TDCR), AREG(SELF_IPI), AREG(EFEAT),  \
351
	AREG(ECTRL)
352
/*
353
 * Tracepoint for apic access.
354
 */
355
TRACE_EVENT(kvm_apic,
356
	TP_PROTO(unsigned int rw, unsigned int reg, u64 val),
357
	TP_ARGS(rw, reg, val),
358

359
	TP_STRUCT__entry(
360
		__field(	unsigned int,	rw		)
361
		__field(	unsigned int,	reg		)
362
		__field(	u64,		val		)
363
	),
364

365
	TP_fast_assign(
366
		__entry->rw		= rw;
367
		__entry->reg		= reg;
368
		__entry->val		= val;
369
	),
370

371
	TP_printk("apic_%s %s = 0x%llx",
372
		  __entry->rw ? "write" : "read",
373
		  __print_symbolic(__entry->reg, kvm_trace_symbol_apic),
374
		  __entry->val)
375
);
376

377
#define trace_kvm_apic_read(reg, val)		trace_kvm_apic(0, reg, val)
378
#define trace_kvm_apic_write(reg, val)		trace_kvm_apic(1, reg, val)
379

380
#define KVM_ISA_VMX   1
381
#define KVM_ISA_SVM   2
382

383
#define kvm_print_exit_reason(exit_reason, isa)				\
384
	(isa == KVM_ISA_VMX) ?						\
385
	__print_symbolic(exit_reason & 0xffff, VMX_EXIT_REASONS) :	\
386
	__print_symbolic(exit_reason, SVM_EXIT_REASONS),		\
387
	(isa == KVM_ISA_VMX && exit_reason & ~0xffff) ? " " : "",	\
388
	(isa == KVM_ISA_VMX) ?						\
389
	__print_flags(exit_reason & ~0xffff, " ", VMX_EXIT_REASON_FLAGS) : ""
390

391
#define TRACE_EVENT_KVM_EXIT(name)					     \
392
TRACE_EVENT(name,							     \
393
	TP_PROTO(struct kvm_vcpu *vcpu, u32 isa),			     \
394
	TP_ARGS(vcpu, isa),						     \
395
									     \
396
	TP_STRUCT__entry(						     \
397
		__field(	unsigned int,	exit_reason	)	     \
398
		__field(	unsigned long,	guest_rip	)	     \
399
		__field(	u32,	        isa             )	     \
400
		__field(	u64,	        info1           )	     \
401
		__field(	u64,	        info2           )	     \
402
		__field(	u32,	        intr_info	)	     \
403
		__field(	u32,	        error_code	)	     \
404
		__field(	unsigned int,	vcpu_id         )	     \
405
		__field(	u64,		requests        )	     \
406
	),								     \
407
									     \
408
	TP_fast_assign(							     \
409
		__entry->guest_rip	= tracing_kvm_rip_read(vcpu);		     \
410
		__entry->isa            = isa;				     \
411
		__entry->vcpu_id        = vcpu->vcpu_id;		     \
412
		__entry->requests       = READ_ONCE(vcpu->requests);	     \
413
		kvm_x86_call(get_exit_info)(vcpu,			     \
414
					    &__entry->exit_reason,	     \
415
					    &__entry->info1,		     \
416
					    &__entry->info2,		     \
417
					    &__entry->intr_info,	     \
418
					    &__entry->error_code);	     \
419
	),								     \
420
									     \
421
	TP_printk("vcpu %u reason %s%s%s rip 0x%lx info1 0x%016llx "	     \
422
		  "info2 0x%016llx intr_info 0x%08x error_code 0x%08x "      \
423
		  "requests 0x%016llx",					     \
424
		  __entry->vcpu_id,					     \
425
		  kvm_print_exit_reason(__entry->exit_reason, __entry->isa), \
426
		  __entry->guest_rip, __entry->info1, __entry->info2,	     \
427
		  __entry->intr_info, __entry->error_code, 		     \
428
		  __entry->requests)					     \
429
)
430

431
/*
432
 * Tracepoint for kvm guest exit:
433
 */
434
TRACE_EVENT_KVM_EXIT(kvm_exit);
435

436
/*
437
 * Tracepoint for kvm interrupt injection:
438
 */
439
TRACE_EVENT(kvm_inj_virq,
440
	TP_PROTO(unsigned int vector, bool soft, bool reinjected),
441
	TP_ARGS(vector, soft, reinjected),
442

443
	TP_STRUCT__entry(
444
		__field(	unsigned int,	vector		)
445
		__field(	bool,		soft		)
446
		__field(	bool,		reinjected	)
447
	),
448

449
	TP_fast_assign(
450
		__entry->vector		= vector;
451
		__entry->soft		= soft;
452
		__entry->reinjected	= reinjected;
453
	),
454

455
	TP_printk("%s 0x%x%s",
456
		  __entry->soft ? "Soft/INTn" : "IRQ", __entry->vector,
457
		  __entry->reinjected ? " [reinjected]" : "")
458
);
459

460
#define EXS(x) { x##_VECTOR, "#" #x }
461

462
#define kvm_trace_sym_exc						\
463
	EXS(DE), EXS(DB), EXS(BP), EXS(OF), EXS(BR), EXS(UD), EXS(NM),	\
464
	EXS(DF), EXS(TS), EXS(NP), EXS(SS), EXS(GP), EXS(PF), EXS(MF),	\
465
	EXS(AC), EXS(MC), EXS(XM), EXS(VE), EXS(CP),			\
466
	EXS(HV), EXS(VC), EXS(SX)
467

468
/*
469
 * Tracepoint for kvm interrupt injection:
470
 */
471
TRACE_EVENT(kvm_inj_exception,
472
	TP_PROTO(unsigned exception, bool has_error, unsigned error_code,
473
		 bool reinjected),
474
	TP_ARGS(exception, has_error, error_code, reinjected),
475

476
	TP_STRUCT__entry(
477
		__field(	u8,	exception	)
478
		__field(	u8,	has_error	)
479
		__field(	u32,	error_code	)
480
		__field(	bool,	reinjected	)
481
	),
482

483
	TP_fast_assign(
484
		__entry->exception	= exception;
485
		__entry->has_error	= has_error;
486
		__entry->error_code	= error_code;
487
		__entry->reinjected	= reinjected;
488
	),
489

490
	TP_printk("%s%s%s%s%s",
491
		  __print_symbolic(__entry->exception, kvm_trace_sym_exc),
492
		  !__entry->has_error ? "" : " (",
493
		  !__entry->has_error ? "" : __print_symbolic(__entry->error_code, { }),
494
		  !__entry->has_error ? "" : ")",
495
		  __entry->reinjected ? " [reinjected]" : "")
496
);
497

498
/*
499
 * Tracepoint for page fault.
500
 */
501
TRACE_EVENT(kvm_page_fault,
502
	TP_PROTO(struct kvm_vcpu *vcpu, u64 fault_address, u64 error_code),
503
	TP_ARGS(vcpu, fault_address, error_code),
504

505
	TP_STRUCT__entry(
506
		__field(	unsigned int,	vcpu_id		)
507
		__field(	unsigned long,	guest_rip	)
508
		__field(	u64,		fault_address	)
509
		__field(	u64,		error_code	)
510
	),
511

512
	TP_fast_assign(
513
		__entry->vcpu_id	= vcpu->vcpu_id;
514
		__entry->guest_rip	= tracing_kvm_rip_read(vcpu);
515
		__entry->fault_address	= fault_address;
516
		__entry->error_code	= error_code;
517
	),
518

519
	TP_printk("vcpu %u rip 0x%lx address 0x%016llx error_code 0x%llx",
520
		  __entry->vcpu_id, __entry->guest_rip,
521
		  __entry->fault_address, __entry->error_code)
522
);
523

524
/*
525
 * Tracepoint for guest MSR access.
526
 */
527
TRACE_EVENT(kvm_msr,
528
	TP_PROTO(unsigned write, u32 ecx, u64 data, bool exception),
529
	TP_ARGS(write, ecx, data, exception),
530

531
	TP_STRUCT__entry(
532
		__field(	unsigned,	write		)
533
		__field(	u32,		ecx		)
534
		__field(	u64,		data		)
535
		__field(	u8,		exception	)
536
	),
537

538
	TP_fast_assign(
539
		__entry->write		= write;
540
		__entry->ecx		= ecx;
541
		__entry->data		= data;
542
		__entry->exception	= exception;
543
	),
544

545
	TP_printk("msr_%s %x = 0x%llx%s",
546
		  __entry->write ? "write" : "read",
547
		  __entry->ecx, __entry->data,
548
		  __entry->exception ? " (#GP)" : "")
549
);
550

551
#define trace_kvm_msr_read(ecx, data)      trace_kvm_msr(0, ecx, data, false)
552
#define trace_kvm_msr_write(ecx, data)     trace_kvm_msr(1, ecx, data, false)
553
#define trace_kvm_msr_read_ex(ecx)         trace_kvm_msr(0, ecx, 0, true)
554
#define trace_kvm_msr_write_ex(ecx, data)  trace_kvm_msr(1, ecx, data, true)
555

556
/*
557
 * Tracepoint for guest CR access.
558
 */
559
TRACE_EVENT(kvm_cr,
560
	TP_PROTO(unsigned int rw, unsigned int cr, unsigned long val),
561
	TP_ARGS(rw, cr, val),
562

563
	TP_STRUCT__entry(
564
		__field(	unsigned int,	rw		)
565
		__field(	unsigned int,	cr		)
566
		__field(	unsigned long,	val		)
567
	),
568

569
	TP_fast_assign(
570
		__entry->rw		= rw;
571
		__entry->cr		= cr;
572
		__entry->val		= val;
573
	),
574

575
	TP_printk("cr_%s %x = 0x%lx",
576
		  __entry->rw ? "write" : "read",
577
		  __entry->cr, __entry->val)
578
);
579

580
#define trace_kvm_cr_read(cr, val)		trace_kvm_cr(0, cr, val)
581
#define trace_kvm_cr_write(cr, val)		trace_kvm_cr(1, cr, val)
582

583
TRACE_EVENT(kvm_pic_set_irq,
584
	    TP_PROTO(__u8 chip, __u8 pin, __u8 elcr, __u8 imr, bool coalesced),
585
	    TP_ARGS(chip, pin, elcr, imr, coalesced),
586

587
	TP_STRUCT__entry(
588
		__field(	__u8,		chip		)
589
		__field(	__u8,		pin		)
590
		__field(	__u8,		elcr		)
591
		__field(	__u8,		imr		)
592
		__field(	bool,		coalesced	)
593
	),
594

595
	TP_fast_assign(
596
		__entry->chip		= chip;
597
		__entry->pin		= pin;
598
		__entry->elcr		= elcr;
599
		__entry->imr		= imr;
600
		__entry->coalesced	= coalesced;
601
	),
602

603
	TP_printk("chip %u pin %u (%s%s)%s",
604
		  __entry->chip, __entry->pin,
605
		  (__entry->elcr & (1 << __entry->pin)) ? "level":"edge",
606
		  (__entry->imr & (1 << __entry->pin)) ? "|masked":"",
607
		  __entry->coalesced ? " (coalesced)" : "")
608
);
609

610
#define kvm_apic_dst_shorthand		\
611
	{0x0, "dst"},			\
612
	{0x1, "self"},			\
613
	{0x2, "all"},			\
614
	{0x3, "all-but-self"}
615

616
TRACE_EVENT(kvm_apic_ipi,
617
	    TP_PROTO(__u32 icr_low, __u32 dest_id),
618
	    TP_ARGS(icr_low, dest_id),
619

620
	TP_STRUCT__entry(
621
		__field(	__u32,		icr_low		)
622
		__field(	__u32,		dest_id		)
623
	),
624

625
	TP_fast_assign(
626
		__entry->icr_low	= icr_low;
627
		__entry->dest_id	= dest_id;
628
	),
629

630
	TP_printk("dst %x vec %u (%s|%s|%s|%s|%s)",
631
		  __entry->dest_id, (u8)__entry->icr_low,
632
		  __print_symbolic((__entry->icr_low >> 8 & 0x7),
633
				   kvm_deliver_mode),
634
		  (__entry->icr_low & (1<<11)) ? "logical" : "physical",
635
		  (__entry->icr_low & (1<<14)) ? "assert" : "de-assert",
636
		  (__entry->icr_low & (1<<15)) ? "level" : "edge",
637
		  __print_symbolic((__entry->icr_low >> 18 & 0x3),
638
				   kvm_apic_dst_shorthand))
639
);
640

641
TRACE_EVENT(kvm_apic_accept_irq,
642
	    TP_PROTO(__u32 apicid, __u16 dm, __u16 tm, __u8 vec),
643
	    TP_ARGS(apicid, dm, tm, vec),
644

645
	TP_STRUCT__entry(
646
		__field(	__u32,		apicid		)
647
		__field(	__u16,		dm		)
648
		__field(	__u16,		tm		)
649
		__field(	__u8,		vec		)
650
	),
651

652
	TP_fast_assign(
653
		__entry->apicid		= apicid;
654
		__entry->dm		= dm;
655
		__entry->tm		= tm;
656
		__entry->vec		= vec;
657
	),
658

659
	TP_printk("apicid %x vec %u (%s|%s)",
660
		  __entry->apicid, __entry->vec,
661
		  __print_symbolic((__entry->dm >> 8 & 0x7), kvm_deliver_mode),
662
		  __entry->tm ? "level" : "edge")
663
);
664

665
TRACE_EVENT(kvm_eoi,
666
	    TP_PROTO(struct kvm_lapic *apic, int vector),
667
	    TP_ARGS(apic, vector),
668

669
	TP_STRUCT__entry(
670
		__field(	__u32,		apicid		)
671
		__field(	int,		vector		)
672
	),
673

674
	TP_fast_assign(
675
		__entry->apicid		= apic->vcpu->vcpu_id;
676
		__entry->vector		= vector;
677
	),
678

679
	TP_printk("apicid %x vector %d", __entry->apicid, __entry->vector)
680
);
681

682
TRACE_EVENT(kvm_pv_eoi,
683
	    TP_PROTO(struct kvm_lapic *apic, int vector),
684
	    TP_ARGS(apic, vector),
685

686
	TP_STRUCT__entry(
687
		__field(	__u32,		apicid		)
688
		__field(	int,		vector		)
689
	),
690

691
	TP_fast_assign(
692
		__entry->apicid		= apic->vcpu->vcpu_id;
693
		__entry->vector		= vector;
694
	),
695

696
	TP_printk("apicid %x vector %d", __entry->apicid, __entry->vector)
697
);
698

699
/*
700
 * Tracepoint for nested VMRUN
701
 */
702
TRACE_EVENT(kvm_nested_vmenter,
703
	    TP_PROTO(__u64 rip, __u64 vmcb, __u64 nested_rip, __u32 int_ctl,
704
		     __u32 event_inj, bool tdp_enabled, __u64 guest_tdp_pgd,
705
		     __u64 guest_cr3, __u32 isa),
706
	    TP_ARGS(rip, vmcb, nested_rip, int_ctl, event_inj, tdp_enabled,
707
		    guest_tdp_pgd, guest_cr3, isa),
708

709
	TP_STRUCT__entry(
710
		__field(	__u64,		rip		)
711
		__field(	__u64,		vmcb		)
712
		__field(	__u64,		nested_rip	)
713
		__field(	__u32,		int_ctl		)
714
		__field(	__u32,		event_inj	)
715
		__field(	bool,		tdp_enabled	)
716
		__field(	__u64,		guest_pgd	)
717
		__field(	__u32,		isa		)
718
	),
719

720
	TP_fast_assign(
721
		__entry->rip		= rip;
722
		__entry->vmcb		= vmcb;
723
		__entry->nested_rip	= nested_rip;
724
		__entry->int_ctl	= int_ctl;
725
		__entry->event_inj	= event_inj;
726
		__entry->tdp_enabled	= tdp_enabled;
727
		__entry->guest_pgd	= tdp_enabled ? guest_tdp_pgd : guest_cr3;
728
		__entry->isa		= isa;
729
	),
730

731
	TP_printk("rip: 0x%016llx %s: 0x%016llx nested_rip: 0x%016llx "
732
		  "int_ctl: 0x%08x event_inj: 0x%08x nested_%s=%s %s: 0x%016llx",
733
		  __entry->rip,
734
		  __entry->isa == KVM_ISA_VMX ? "vmcs" : "vmcb",
735
		  __entry->vmcb,
736
		  __entry->nested_rip,
737
		  __entry->int_ctl,
738
		  __entry->event_inj,
739
		  __entry->isa == KVM_ISA_VMX ? "ept" : "npt",
740
		  __entry->tdp_enabled ? "y" : "n",
741
		  !__entry->tdp_enabled ? "guest_cr3" :
742
		  __entry->isa == KVM_ISA_VMX ? "nested_eptp" : "nested_cr3",
743
		  __entry->guest_pgd)
744
);
745

746
TRACE_EVENT(kvm_nested_intercepts,
747
	    TP_PROTO(__u16 cr_read, __u16 cr_write, __u32 exceptions,
748
		     __u32 intercept1, __u32 intercept2, __u32 intercept3),
749
	    TP_ARGS(cr_read, cr_write, exceptions, intercept1,
750
		    intercept2, intercept3),
751

752
	TP_STRUCT__entry(
753
		__field(	__u16,		cr_read		)
754
		__field(	__u16,		cr_write	)
755
		__field(	__u32,		exceptions	)
756
		__field(	__u32,		intercept1	)
757
		__field(	__u32,		intercept2	)
758
		__field(	__u32,		intercept3	)
759
	),
760

761
	TP_fast_assign(
762
		__entry->cr_read	= cr_read;
763
		__entry->cr_write	= cr_write;
764
		__entry->exceptions	= exceptions;
765
		__entry->intercept1	= intercept1;
766
		__entry->intercept2	= intercept2;
767
		__entry->intercept3	= intercept3;
768
	),
769

770
	TP_printk("cr_read: %04x cr_write: %04x excp: %08x "
771
		  "intercepts: %08x %08x %08x",
772
		  __entry->cr_read, __entry->cr_write, __entry->exceptions,
773
		  __entry->intercept1, __entry->intercept2, __entry->intercept3)
774
);
775
/*
776
 * Tracepoint for #VMEXIT while nested
777
 */
778
TRACE_EVENT_KVM_EXIT(kvm_nested_vmexit);
779

780
/*
781
 * Tracepoint for #VMEXIT reinjected to the guest
782
 */
783
TRACE_EVENT(kvm_nested_vmexit_inject,
784
	    TP_PROTO(__u32 exit_code,
785
		     __u64 exit_info1, __u64 exit_info2,
786
		     __u32 exit_int_info, __u32 exit_int_info_err, __u32 isa),
787
	    TP_ARGS(exit_code, exit_info1, exit_info2,
788
		    exit_int_info, exit_int_info_err, isa),
789

790
	TP_STRUCT__entry(
791
		__field(	__u32,		exit_code		)
792
		__field(	__u64,		exit_info1		)
793
		__field(	__u64,		exit_info2		)
794
		__field(	__u32,		exit_int_info		)
795
		__field(	__u32,		exit_int_info_err	)
796
		__field(	__u32,		isa			)
797
	),
798

799
	TP_fast_assign(
800
		__entry->exit_code		= exit_code;
801
		__entry->exit_info1		= exit_info1;
802
		__entry->exit_info2		= exit_info2;
803
		__entry->exit_int_info		= exit_int_info;
804
		__entry->exit_int_info_err	= exit_int_info_err;
805
		__entry->isa			= isa;
806
	),
807

808
	TP_printk("reason: %s%s%s ext_inf1: 0x%016llx "
809
		  "ext_inf2: 0x%016llx ext_int: 0x%08x ext_int_err: 0x%08x",
810
		  kvm_print_exit_reason(__entry->exit_code, __entry->isa),
811
		  __entry->exit_info1, __entry->exit_info2,
812
		  __entry->exit_int_info, __entry->exit_int_info_err)
813
);
814

815
/*
816
 * Tracepoint for nested #vmexit because of interrupt pending
817
 */
818
TRACE_EVENT(kvm_nested_intr_vmexit,
819
	    TP_PROTO(__u64 rip),
820
	    TP_ARGS(rip),
821

822
	TP_STRUCT__entry(
823
		__field(	__u64,	rip	)
824
	),
825

826
	TP_fast_assign(
827
		__entry->rip	=	rip
828
	),
829

830
	TP_printk("rip: 0x%016llx", __entry->rip)
831
);
832

833
/*
834
 * Tracepoint for nested #vmexit because of interrupt pending
835
 */
836
TRACE_EVENT(kvm_invlpga,
837
	    TP_PROTO(__u64 rip, unsigned int asid, u64 address),
838
	    TP_ARGS(rip, asid, address),
839

840
	TP_STRUCT__entry(
841
		__field(	__u64,		rip	)
842
		__field(	unsigned int,	asid	)
843
		__field(	__u64,		address	)
844
	),
845

846
	TP_fast_assign(
847
		__entry->rip		=	rip;
848
		__entry->asid		=	asid;
849
		__entry->address	=	address;
850
	),
851

852
	TP_printk("rip: 0x%016llx asid: %u address: 0x%016llx",
853
		  __entry->rip, __entry->asid, __entry->address)
854
);
855

856
/*
857
 * Tracepoint for nested #vmexit because of interrupt pending
858
 */
859
TRACE_EVENT(kvm_skinit,
860
	    TP_PROTO(__u64 rip, __u32 slb),
861
	    TP_ARGS(rip, slb),
862

863
	TP_STRUCT__entry(
864
		__field(	__u64,	rip	)
865
		__field(	__u32,	slb	)
866
	),
867

868
	TP_fast_assign(
869
		__entry->rip		=	rip;
870
		__entry->slb		=	slb;
871
	),
872

873
	TP_printk("rip: 0x%016llx slb: 0x%08x",
874
		  __entry->rip, __entry->slb)
875
);
876

877
#define KVM_EMUL_INSN_F_CR0_PE (1 << 0)
878
#define KVM_EMUL_INSN_F_EFL_VM (1 << 1)
879
#define KVM_EMUL_INSN_F_CS_D   (1 << 2)
880
#define KVM_EMUL_INSN_F_CS_L   (1 << 3)
881

882
#define kvm_trace_symbol_emul_flags	                  \
883
	{ 0,   			    "real" },		  \
884
	{ KVM_EMUL_INSN_F_CR0_PE			  \
885
	  | KVM_EMUL_INSN_F_EFL_VM, "vm16" },		  \
886
	{ KVM_EMUL_INSN_F_CR0_PE,   "prot16" },		  \
887
	{ KVM_EMUL_INSN_F_CR0_PE			  \
888
	  | KVM_EMUL_INSN_F_CS_D,   "prot32" },		  \
889
	{ KVM_EMUL_INSN_F_CR0_PE			  \
890
	  | KVM_EMUL_INSN_F_CS_L,   "prot64" }
891

892
#define kei_decode_mode(mode) ({			\
893
	u8 flags = 0xff;				\
894
	switch (mode) {					\
895
	case X86EMUL_MODE_REAL:				\
896
		flags = 0;				\
897
		break;					\
898
	case X86EMUL_MODE_VM86:				\
899
		flags = KVM_EMUL_INSN_F_EFL_VM;		\
900
		break;					\
901
	case X86EMUL_MODE_PROT16:			\
902
		flags = KVM_EMUL_INSN_F_CR0_PE;		\
903
		break;					\
904
	case X86EMUL_MODE_PROT32:			\
905
		flags = KVM_EMUL_INSN_F_CR0_PE		\
906
			| KVM_EMUL_INSN_F_CS_D;		\
907
		break;					\
908
	case X86EMUL_MODE_PROT64:			\
909
		flags = KVM_EMUL_INSN_F_CR0_PE		\
910
			| KVM_EMUL_INSN_F_CS_L;		\
911
		break;					\
912
	}						\
913
	flags;						\
914
	})
915

916
TRACE_EVENT(kvm_emulate_insn,
917
	TP_PROTO(struct kvm_vcpu *vcpu, __u8 failed),
918
	TP_ARGS(vcpu, failed),
919

920
	TP_STRUCT__entry(
921
		__field(    __u64, rip                              )
922
		__field(    __u32, csbase                           )
923
		__field(    __u8,  len                              )
924
		__array(    __u8,  insn, X86_MAX_INSTRUCTION_LENGTH )
925
		__field(    __u8,  flags       	   	            )
926
		__field(    __u8,  failed                           )
927
		),
928

929
	TP_fast_assign(
930
		__entry->csbase = kvm_x86_call(get_segment_base)(vcpu,
931
								 VCPU_SREG_CS);
932
		__entry->len = vcpu->arch.emulate_ctxt->fetch.ptr
933
			       - vcpu->arch.emulate_ctxt->fetch.data;
934
		__entry->rip = vcpu->arch.emulate_ctxt->_eip - __entry->len;
935
		memcpy(__entry->insn,
936
		       vcpu->arch.emulate_ctxt->fetch.data,
937
		       X86_MAX_INSTRUCTION_LENGTH);
938
		__entry->flags = kei_decode_mode(vcpu->arch.emulate_ctxt->mode);
939
		__entry->failed = failed;
940
		),
941

942
	TP_printk("%x:%llx:%s (%s)%s",
943
		  __entry->csbase, __entry->rip,
944
		  __print_hex(__entry->insn, __entry->len),
945
		  __print_symbolic(__entry->flags,
946
				   kvm_trace_symbol_emul_flags),
947
		  __entry->failed ? " failed" : ""
948
		)
949
	);
950

951
#define trace_kvm_emulate_insn_start(vcpu) trace_kvm_emulate_insn(vcpu, 0)
952
#define trace_kvm_emulate_insn_failed(vcpu) trace_kvm_emulate_insn(vcpu, 1)
953

954
TRACE_EVENT(
955
	vcpu_match_mmio,
956
	TP_PROTO(gva_t gva, gpa_t gpa, bool write, bool gpa_match),
957
	TP_ARGS(gva, gpa, write, gpa_match),
958

959
	TP_STRUCT__entry(
960
		__field(gva_t, gva)
961
		__field(gpa_t, gpa)
962
		__field(bool, write)
963
		__field(bool, gpa_match)
964
		),
965

966
	TP_fast_assign(
967
		__entry->gva = gva;
968
		__entry->gpa = gpa;
969
		__entry->write = write;
970
		__entry->gpa_match = gpa_match
971
		),
972

973
	TP_printk("gva %#lx gpa %#llx %s %s", __entry->gva, __entry->gpa,
974
		  __entry->write ? "Write" : "Read",
975
		  __entry->gpa_match ? "GPA" : "GVA")
976
);
977

978
TRACE_EVENT(kvm_write_tsc_offset,
979
	TP_PROTO(unsigned int vcpu_id, __u64 previous_tsc_offset,
980
		 __u64 next_tsc_offset),
981
	TP_ARGS(vcpu_id, previous_tsc_offset, next_tsc_offset),
982

983
	TP_STRUCT__entry(
984
		__field( unsigned int,	vcpu_id				)
985
		__field(	__u64,	previous_tsc_offset		)
986
		__field(	__u64,	next_tsc_offset			)
987
	),
988

989
	TP_fast_assign(
990
		__entry->vcpu_id		= vcpu_id;
991
		__entry->previous_tsc_offset	= previous_tsc_offset;
992
		__entry->next_tsc_offset	= next_tsc_offset;
993
	),
994

995
	TP_printk("vcpu=%u prev=%llu next=%llu", __entry->vcpu_id,
996
		  __entry->previous_tsc_offset, __entry->next_tsc_offset)
997
);
998

999
#ifdef CONFIG_X86_64
1000

1001
#define host_clocks					\
1002
	{VDSO_CLOCKMODE_NONE, "none"},			\
1003
	{VDSO_CLOCKMODE_TSC,  "tsc"}			\
1004

1005
TRACE_EVENT(kvm_update_master_clock,
1006
	TP_PROTO(bool use_master_clock, unsigned int host_clock, bool offset_matched),
1007
	TP_ARGS(use_master_clock, host_clock, offset_matched),
1008

1009
	TP_STRUCT__entry(
1010
		__field(		bool,	use_master_clock	)
1011
		__field(	unsigned int,	host_clock		)
1012
		__field(		bool,	offset_matched		)
1013
	),
1014

1015
	TP_fast_assign(
1016
		__entry->use_master_clock	= use_master_clock;
1017
		__entry->host_clock		= host_clock;
1018
		__entry->offset_matched		= offset_matched;
1019
	),
1020

1021
	TP_printk("masterclock %d hostclock %s offsetmatched %u",
1022
		  __entry->use_master_clock,
1023
		  __print_symbolic(__entry->host_clock, host_clocks),
1024
		  __entry->offset_matched)
1025
);
1026

1027
TRACE_EVENT(kvm_track_tsc,
1028
	TP_PROTO(unsigned int vcpu_id, unsigned int nr_matched,
1029
		 unsigned int online_vcpus, bool use_master_clock,
1030
		 unsigned int host_clock),
1031
	TP_ARGS(vcpu_id, nr_matched, online_vcpus, use_master_clock,
1032
		host_clock),
1033

1034
	TP_STRUCT__entry(
1035
		__field(	unsigned int,	vcpu_id			)
1036
		__field(	unsigned int,	nr_vcpus_matched_tsc	)
1037
		__field(	unsigned int,	online_vcpus		)
1038
		__field(	bool,		use_master_clock	)
1039
		__field(	unsigned int,	host_clock		)
1040
	),
1041

1042
	TP_fast_assign(
1043
		__entry->vcpu_id		= vcpu_id;
1044
		__entry->nr_vcpus_matched_tsc	= nr_matched;
1045
		__entry->online_vcpus		= online_vcpus;
1046
		__entry->use_master_clock	= use_master_clock;
1047
		__entry->host_clock		= host_clock;
1048
	),
1049

1050
	TP_printk("vcpu_id %u masterclock %u offsetmatched %u nr_online %u"
1051
		  " hostclock %s",
1052
		  __entry->vcpu_id, __entry->use_master_clock,
1053
		  __entry->nr_vcpus_matched_tsc, __entry->online_vcpus,
1054
		  __print_symbolic(__entry->host_clock, host_clocks))
1055
);
1056

1057
#endif /* CONFIG_X86_64 */
1058

1059
/*
1060
 * Tracepoint for PML full VMEXIT.
1061
 */
1062
TRACE_EVENT(kvm_pml_full,
1063
	TP_PROTO(unsigned int vcpu_id),
1064
	TP_ARGS(vcpu_id),
1065

1066
	TP_STRUCT__entry(
1067
		__field(	unsigned int,	vcpu_id			)
1068
	),
1069

1070
	TP_fast_assign(
1071
		__entry->vcpu_id		= vcpu_id;
1072
	),
1073

1074
	TP_printk("vcpu %d: PML full", __entry->vcpu_id)
1075
);
1076

1077
TRACE_EVENT(kvm_ple_window_update,
1078
	TP_PROTO(unsigned int vcpu_id, unsigned int new, unsigned int old),
1079
	TP_ARGS(vcpu_id, new, old),
1080

1081
	TP_STRUCT__entry(
1082
		__field(        unsigned int,   vcpu_id         )
1083
		__field(        unsigned int,       new         )
1084
		__field(        unsigned int,       old         )
1085
	),
1086

1087
	TP_fast_assign(
1088
		__entry->vcpu_id        = vcpu_id;
1089
		__entry->new            = new;
1090
		__entry->old            = old;
1091
	),
1092

1093
	TP_printk("vcpu %u old %u new %u (%s)",
1094
	          __entry->vcpu_id, __entry->old, __entry->new,
1095
		  __entry->old < __entry->new ? "growed" : "shrinked")
1096
);
1097

1098
TRACE_EVENT(kvm_pvclock_update,
1099
	TP_PROTO(unsigned int vcpu_id, struct pvclock_vcpu_time_info *pvclock),
1100
	TP_ARGS(vcpu_id, pvclock),
1101

1102
	TP_STRUCT__entry(
1103
		__field(	unsigned int,	vcpu_id			)
1104
		__field(	__u32,		version			)
1105
		__field(	__u64,		tsc_timestamp		)
1106
		__field(	__u64,		system_time		)
1107
		__field(	__u32,		tsc_to_system_mul	)
1108
		__field(	__s8,		tsc_shift		)
1109
		__field(	__u8,		flags			)
1110
	),
1111

1112
	TP_fast_assign(
1113
		__entry->vcpu_id	   = vcpu_id;
1114
		__entry->version	   = pvclock->version;
1115
		__entry->tsc_timestamp	   = pvclock->tsc_timestamp;
1116
		__entry->system_time	   = pvclock->system_time;
1117
		__entry->tsc_to_system_mul = pvclock->tsc_to_system_mul;
1118
		__entry->tsc_shift	   = pvclock->tsc_shift;
1119
		__entry->flags		   = pvclock->flags;
1120
	),
1121

1122
	TP_printk("vcpu_id %u, pvclock { version %u, tsc_timestamp 0x%llx, "
1123
		  "system_time 0x%llx, tsc_to_system_mul 0x%x, tsc_shift %d, "
1124
		  "flags 0x%x }",
1125
		  __entry->vcpu_id,
1126
		  __entry->version,
1127
		  __entry->tsc_timestamp,
1128
		  __entry->system_time,
1129
		  __entry->tsc_to_system_mul,
1130
		  __entry->tsc_shift,
1131
		  __entry->flags)
1132
);
1133

1134
TRACE_EVENT(kvm_wait_lapic_expire,
1135
	TP_PROTO(unsigned int vcpu_id, s64 delta),
1136
	TP_ARGS(vcpu_id, delta),
1137

1138
	TP_STRUCT__entry(
1139
		__field(	unsigned int,	vcpu_id		)
1140
		__field(	s64,		delta		)
1141
	),
1142

1143
	TP_fast_assign(
1144
		__entry->vcpu_id	   = vcpu_id;
1145
		__entry->delta             = delta;
1146
	),
1147

1148
	TP_printk("vcpu %u: delta %lld (%s)",
1149
		  __entry->vcpu_id,
1150
		  __entry->delta,
1151
		  __entry->delta < 0 ? "early" : "late")
1152
);
1153

1154
TRACE_EVENT(kvm_smm_transition,
1155
	TP_PROTO(unsigned int vcpu_id, u64 smbase, bool entering),
1156
	TP_ARGS(vcpu_id, smbase, entering),
1157

1158
	TP_STRUCT__entry(
1159
		__field(	unsigned int,	vcpu_id		)
1160
		__field(	u64,		smbase		)
1161
		__field(	bool,		entering	)
1162
	),
1163

1164
	TP_fast_assign(
1165
		__entry->vcpu_id	= vcpu_id;
1166
		__entry->smbase		= smbase;
1167
		__entry->entering	= entering;
1168
	),
1169

1170
	TP_printk("vcpu %u: %s SMM, smbase 0x%llx",
1171
		  __entry->vcpu_id,
1172
		  __entry->entering ? "entering" : "leaving",
1173
		  __entry->smbase)
1174
);
1175

1176
/*
1177
 * Tracepoint for VT-d posted-interrupts and AMD-Vi Guest Virtual APIC.
1178
 */
1179
TRACE_EVENT(kvm_pi_irte_update,
1180
	TP_PROTO(unsigned int host_irq, struct kvm_vcpu *vcpu,
1181
		 unsigned int gsi, unsigned int gvec, bool set),
1182
	TP_ARGS(host_irq, vcpu, gsi, gvec, set),
1183

1184
	TP_STRUCT__entry(
1185
		__field(	unsigned int,	host_irq	)
1186
		__field(	int,		vcpu_id		)
1187
		__field(	unsigned int,	gsi		)
1188
		__field(	unsigned int,	gvec		)
1189
		__field(	bool,		set		)
1190
	),
1191

1192
	TP_fast_assign(
1193
		__entry->host_irq	= host_irq;
1194
		__entry->vcpu_id	= vcpu ? vcpu->vcpu_id : -1;
1195
		__entry->gsi		= gsi;
1196
		__entry->gvec		= gvec;
1197
		__entry->set		= set;
1198
	),
1199

1200
	TP_printk("PI is %s for irq %u, vcpu %d, gsi: 0x%x, gvec: 0x%x",
1201
		  __entry->set ? "enabled and being updated" : "disabled",
1202
		  __entry->host_irq,
1203
		  __entry->vcpu_id,
1204
		  __entry->gsi,
1205
		  __entry->gvec)
1206
);
1207

1208
/*
1209
 * Tracepoint for kvm_hv_notify_acked_sint.
1210
 */
1211
TRACE_EVENT(kvm_hv_notify_acked_sint,
1212
	TP_PROTO(int vcpu_id, u32 sint),
1213
	TP_ARGS(vcpu_id, sint),
1214

1215
	TP_STRUCT__entry(
1216
		__field(int, vcpu_id)
1217
		__field(u32, sint)
1218
	),
1219

1220
	TP_fast_assign(
1221
		__entry->vcpu_id = vcpu_id;
1222
		__entry->sint = sint;
1223
	),
1224

1225
	TP_printk("vcpu_id %d sint %u", __entry->vcpu_id, __entry->sint)
1226
);
1227

1228
/*
1229
 * Tracepoint for synic_set_irq.
1230
 */
1231
TRACE_EVENT(kvm_hv_synic_set_irq,
1232
	TP_PROTO(int vcpu_id, u32 sint, int vector, int ret),
1233
	TP_ARGS(vcpu_id, sint, vector, ret),
1234

1235
	TP_STRUCT__entry(
1236
		__field(int, vcpu_id)
1237
		__field(u32, sint)
1238
		__field(int, vector)
1239
		__field(int, ret)
1240
	),
1241

1242
	TP_fast_assign(
1243
		__entry->vcpu_id = vcpu_id;
1244
		__entry->sint = sint;
1245
		__entry->vector = vector;
1246
		__entry->ret = ret;
1247
	),
1248

1249
	TP_printk("vcpu_id %d sint %u vector %d ret %d",
1250
		  __entry->vcpu_id, __entry->sint, __entry->vector,
1251
		  __entry->ret)
1252
);
1253

1254
/*
1255
 * Tracepoint for kvm_hv_synic_send_eoi.
1256
 */
1257
TRACE_EVENT(kvm_hv_synic_send_eoi,
1258
	TP_PROTO(int vcpu_id, int vector),
1259
	TP_ARGS(vcpu_id, vector),
1260

1261
	TP_STRUCT__entry(
1262
		__field(int, vcpu_id)
1263
		__field(u32, sint)
1264
		__field(int, vector)
1265
		__field(int, ret)
1266
	),
1267

1268
	TP_fast_assign(
1269
		__entry->vcpu_id = vcpu_id;
1270
		__entry->vector	= vector;
1271
	),
1272

1273
	TP_printk("vcpu_id %d vector %d", __entry->vcpu_id, __entry->vector)
1274
);
1275

1276
/*
1277
 * Tracepoint for synic_set_msr.
1278
 */
1279
TRACE_EVENT(kvm_hv_synic_set_msr,
1280
	TP_PROTO(int vcpu_id, u32 msr, u64 data, bool host),
1281
	TP_ARGS(vcpu_id, msr, data, host),
1282

1283
	TP_STRUCT__entry(
1284
		__field(int, vcpu_id)
1285
		__field(u32, msr)
1286
		__field(u64, data)
1287
		__field(bool, host)
1288
	),
1289

1290
	TP_fast_assign(
1291
		__entry->vcpu_id = vcpu_id;
1292
		__entry->msr = msr;
1293
		__entry->data = data;
1294
		__entry->host = host
1295
	),
1296

1297
	TP_printk("vcpu_id %d msr 0x%x data 0x%llx host %d",
1298
		  __entry->vcpu_id, __entry->msr, __entry->data, __entry->host)
1299
);
1300

1301
/*
1302
 * Tracepoint for stimer_set_config.
1303
 */
1304
TRACE_EVENT(kvm_hv_stimer_set_config,
1305
	TP_PROTO(int vcpu_id, int timer_index, u64 config, bool host),
1306
	TP_ARGS(vcpu_id, timer_index, config, host),
1307

1308
	TP_STRUCT__entry(
1309
		__field(int, vcpu_id)
1310
		__field(int, timer_index)
1311
		__field(u64, config)
1312
		__field(bool, host)
1313
	),
1314

1315
	TP_fast_assign(
1316
		__entry->vcpu_id = vcpu_id;
1317
		__entry->timer_index = timer_index;
1318
		__entry->config = config;
1319
		__entry->host = host;
1320
	),
1321

1322
	TP_printk("vcpu_id %d timer %d config 0x%llx host %d",
1323
		  __entry->vcpu_id, __entry->timer_index, __entry->config,
1324
		  __entry->host)
1325
);
1326

1327
/*
1328
 * Tracepoint for stimer_set_count.
1329
 */
1330
TRACE_EVENT(kvm_hv_stimer_set_count,
1331
	TP_PROTO(int vcpu_id, int timer_index, u64 count, bool host),
1332
	TP_ARGS(vcpu_id, timer_index, count, host),
1333

1334
	TP_STRUCT__entry(
1335
		__field(int, vcpu_id)
1336
		__field(int, timer_index)
1337
		__field(u64, count)
1338
		__field(bool, host)
1339
	),
1340

1341
	TP_fast_assign(
1342
		__entry->vcpu_id = vcpu_id;
1343
		__entry->timer_index = timer_index;
1344
		__entry->count = count;
1345
		__entry->host = host;
1346
	),
1347

1348
	TP_printk("vcpu_id %d timer %d count %llu host %d",
1349
		  __entry->vcpu_id, __entry->timer_index, __entry->count,
1350
		  __entry->host)
1351
);
1352

1353
/*
1354
 * Tracepoint for stimer_start(periodic timer case).
1355
 */
1356
TRACE_EVENT(kvm_hv_stimer_start_periodic,
1357
	TP_PROTO(int vcpu_id, int timer_index, u64 time_now, u64 exp_time),
1358
	TP_ARGS(vcpu_id, timer_index, time_now, exp_time),
1359

1360
	TP_STRUCT__entry(
1361
		__field(int, vcpu_id)
1362
		__field(int, timer_index)
1363
		__field(u64, time_now)
1364
		__field(u64, exp_time)
1365
	),
1366

1367
	TP_fast_assign(
1368
		__entry->vcpu_id = vcpu_id;
1369
		__entry->timer_index = timer_index;
1370
		__entry->time_now = time_now;
1371
		__entry->exp_time = exp_time;
1372
	),
1373

1374
	TP_printk("vcpu_id %d timer %d time_now %llu exp_time %llu",
1375
		  __entry->vcpu_id, __entry->timer_index, __entry->time_now,
1376
		  __entry->exp_time)
1377
);
1378

1379
/*
1380
 * Tracepoint for stimer_start(one-shot timer case).
1381
 */
1382
TRACE_EVENT(kvm_hv_stimer_start_one_shot,
1383
	TP_PROTO(int vcpu_id, int timer_index, u64 time_now, u64 count),
1384
	TP_ARGS(vcpu_id, timer_index, time_now, count),
1385

1386
	TP_STRUCT__entry(
1387
		__field(int, vcpu_id)
1388
		__field(int, timer_index)
1389
		__field(u64, time_now)
1390
		__field(u64, count)
1391
	),
1392

1393
	TP_fast_assign(
1394
		__entry->vcpu_id = vcpu_id;
1395
		__entry->timer_index = timer_index;
1396
		__entry->time_now = time_now;
1397
		__entry->count = count;
1398
	),
1399

1400
	TP_printk("vcpu_id %d timer %d time_now %llu count %llu",
1401
		  __entry->vcpu_id, __entry->timer_index, __entry->time_now,
1402
		  __entry->count)
1403
);
1404

1405
/*
1406
 * Tracepoint for stimer_timer_callback.
1407
 */
1408
TRACE_EVENT(kvm_hv_stimer_callback,
1409
	TP_PROTO(int vcpu_id, int timer_index),
1410
	TP_ARGS(vcpu_id, timer_index),
1411

1412
	TP_STRUCT__entry(
1413
		__field(int, vcpu_id)
1414
		__field(int, timer_index)
1415
	),
1416

1417
	TP_fast_assign(
1418
		__entry->vcpu_id = vcpu_id;
1419
		__entry->timer_index = timer_index;
1420
	),
1421

1422
	TP_printk("vcpu_id %d timer %d",
1423
		  __entry->vcpu_id, __entry->timer_index)
1424
);
1425

1426
/*
1427
 * Tracepoint for stimer_expiration.
1428
 */
1429
TRACE_EVENT(kvm_hv_stimer_expiration,
1430
	TP_PROTO(int vcpu_id, int timer_index, int direct, int msg_send_result),
1431
	TP_ARGS(vcpu_id, timer_index, direct, msg_send_result),
1432

1433
	TP_STRUCT__entry(
1434
		__field(int, vcpu_id)
1435
		__field(int, timer_index)
1436
		__field(int, direct)
1437
		__field(int, msg_send_result)
1438
	),
1439

1440
	TP_fast_assign(
1441
		__entry->vcpu_id = vcpu_id;
1442
		__entry->timer_index = timer_index;
1443
		__entry->direct = direct;
1444
		__entry->msg_send_result = msg_send_result;
1445
	),
1446

1447
	TP_printk("vcpu_id %d timer %d direct %d send result %d",
1448
		  __entry->vcpu_id, __entry->timer_index,
1449
		  __entry->direct, __entry->msg_send_result)
1450
);
1451

1452
/*
1453
 * Tracepoint for stimer_cleanup.
1454
 */
1455
TRACE_EVENT(kvm_hv_stimer_cleanup,
1456
	TP_PROTO(int vcpu_id, int timer_index),
1457
	TP_ARGS(vcpu_id, timer_index),
1458

1459
	TP_STRUCT__entry(
1460
		__field(int, vcpu_id)
1461
		__field(int, timer_index)
1462
	),
1463

1464
	TP_fast_assign(
1465
		__entry->vcpu_id = vcpu_id;
1466
		__entry->timer_index = timer_index;
1467
	),
1468

1469
	TP_printk("vcpu_id %d timer %d",
1470
		  __entry->vcpu_id, __entry->timer_index)
1471
);
1472

1473
#define kvm_print_apicv_inhibit_reasons(inhibits)	\
1474
	(inhibits), (inhibits) ? " " : "",		\
1475
	(inhibits) ? __print_flags(inhibits, "|", APICV_INHIBIT_REASONS) : ""
1476

1477
TRACE_EVENT(kvm_apicv_inhibit_changed,
1478
	    TP_PROTO(int reason, bool set, unsigned long inhibits),
1479
	    TP_ARGS(reason, set, inhibits),
1480

1481
	TP_STRUCT__entry(
1482
		__field(int, reason)
1483
		__field(bool, set)
1484
		__field(unsigned long, inhibits)
1485
	),
1486

1487
	TP_fast_assign(
1488
		__entry->reason = reason;
1489
		__entry->set = set;
1490
		__entry->inhibits = inhibits;
1491
	),
1492

1493
	TP_printk("%s reason=%u, inhibits=0x%lx%s%s",
1494
		  __entry->set ? "set" : "cleared",
1495
		  __entry->reason,
1496
		  kvm_print_apicv_inhibit_reasons(__entry->inhibits))
1497
);
1498

1499
TRACE_EVENT(kvm_apicv_accept_irq,
1500
	    TP_PROTO(__u32 apicid, __u16 dm, __u16 tm, __u8 vec),
1501
	    TP_ARGS(apicid, dm, tm, vec),
1502

1503
	TP_STRUCT__entry(
1504
		__field(	__u32,		apicid		)
1505
		__field(	__u16,		dm		)
1506
		__field(	__u16,		tm		)
1507
		__field(	__u8,		vec		)
1508
	),
1509

1510
	TP_fast_assign(
1511
		__entry->apicid		= apicid;
1512
		__entry->dm		= dm;
1513
		__entry->tm		= tm;
1514
		__entry->vec		= vec;
1515
	),
1516

1517
	TP_printk("apicid %x vec %u (%s|%s)",
1518
		  __entry->apicid, __entry->vec,
1519
		  __print_symbolic((__entry->dm >> 8 & 0x7), kvm_deliver_mode),
1520
		  __entry->tm ? "level" : "edge")
1521
);
1522

1523
/*
1524
 * Tracepoint for AMD AVIC
1525
 */
1526
TRACE_EVENT(kvm_avic_incomplete_ipi,
1527
	    TP_PROTO(u32 vcpu, u32 icrh, u32 icrl, u32 id, u32 index),
1528
	    TP_ARGS(vcpu, icrh, icrl, id, index),
1529

1530
	TP_STRUCT__entry(
1531
		__field(u32, vcpu)
1532
		__field(u32, icrh)
1533
		__field(u32, icrl)
1534
		__field(u32, id)
1535
		__field(u32, index)
1536
	),
1537

1538
	TP_fast_assign(
1539
		__entry->vcpu = vcpu;
1540
		__entry->icrh = icrh;
1541
		__entry->icrl = icrl;
1542
		__entry->id = id;
1543
		__entry->index = index;
1544
	),
1545

1546
	TP_printk("vcpu=%u, icrh:icrl=%#010x:%08x, id=%u, index=%u",
1547
		  __entry->vcpu, __entry->icrh, __entry->icrl,
1548
		  __entry->id, __entry->index)
1549
);
1550

1551
TRACE_EVENT(kvm_avic_unaccelerated_access,
1552
	    TP_PROTO(u32 vcpu, u32 offset, bool ft, bool rw, u32 vec),
1553
	    TP_ARGS(vcpu, offset, ft, rw, vec),
1554

1555
	TP_STRUCT__entry(
1556
		__field(u32, vcpu)
1557
		__field(u32, offset)
1558
		__field(bool, ft)
1559
		__field(bool, rw)
1560
		__field(u32, vec)
1561
	),
1562

1563
	TP_fast_assign(
1564
		__entry->vcpu = vcpu;
1565
		__entry->offset = offset;
1566
		__entry->ft = ft;
1567
		__entry->rw = rw;
1568
		__entry->vec = vec;
1569
	),
1570

1571
	TP_printk("vcpu=%u, offset=%#x(%s), %s, %s, vec=%#x",
1572
		  __entry->vcpu,
1573
		  __entry->offset,
1574
		  __print_symbolic(__entry->offset, kvm_trace_symbol_apic),
1575
		  __entry->ft ? "trap" : "fault",
1576
		  __entry->rw ? "write" : "read",
1577
		  __entry->vec)
1578
);
1579

1580
TRACE_EVENT(kvm_avic_ga_log,
1581
	    TP_PROTO(u32 vmid, u32 vcpuid),
1582
	    TP_ARGS(vmid, vcpuid),
1583

1584
	TP_STRUCT__entry(
1585
		__field(u32, vmid)
1586
		__field(u32, vcpuid)
1587
	),
1588

1589
	TP_fast_assign(
1590
		__entry->vmid = vmid;
1591
		__entry->vcpuid = vcpuid;
1592
	),
1593

1594
	TP_printk("vmid=%u, vcpuid=%u",
1595
		  __entry->vmid, __entry->vcpuid)
1596
);
1597

1598
TRACE_EVENT(kvm_avic_kick_vcpu_slowpath,
1599
	    TP_PROTO(u32 icrh, u32 icrl, u32 index),
1600
	    TP_ARGS(icrh, icrl, index),
1601

1602
	TP_STRUCT__entry(
1603
		__field(u32, icrh)
1604
		__field(u32, icrl)
1605
		__field(u32, index)
1606
	),
1607

1608
	TP_fast_assign(
1609
		__entry->icrh = icrh;
1610
		__entry->icrl = icrl;
1611
		__entry->index = index;
1612
	),
1613

1614
	TP_printk("icrh:icrl=%#08x:%08x, index=%u",
1615
		  __entry->icrh, __entry->icrl, __entry->index)
1616
);
1617

1618
TRACE_EVENT(kvm_avic_doorbell,
1619
	    TP_PROTO(u32 vcpuid, u32 apicid),
1620
	    TP_ARGS(vcpuid, apicid),
1621

1622
	TP_STRUCT__entry(
1623
		__field(u32, vcpuid)
1624
		__field(u32, apicid)
1625
	),
1626

1627
	TP_fast_assign(
1628
		__entry->vcpuid = vcpuid;
1629
		__entry->apicid = apicid;
1630
	),
1631

1632
	TP_printk("vcpuid=%u, apicid=%u",
1633
		  __entry->vcpuid, __entry->apicid)
1634
);
1635

1636
TRACE_EVENT(kvm_hv_timer_state,
1637
		TP_PROTO(unsigned int vcpu_id, unsigned int hv_timer_in_use),
1638
		TP_ARGS(vcpu_id, hv_timer_in_use),
1639
		TP_STRUCT__entry(
1640
			__field(unsigned int, vcpu_id)
1641
			__field(unsigned int, hv_timer_in_use)
1642
			),
1643
		TP_fast_assign(
1644
			__entry->vcpu_id = vcpu_id;
1645
			__entry->hv_timer_in_use = hv_timer_in_use;
1646
			),
1647
		TP_printk("vcpu_id %x hv_timer %x",
1648
			__entry->vcpu_id,
1649
			__entry->hv_timer_in_use)
1650
);
1651

1652
/*
1653
 * Tracepoint for kvm_hv_flush_tlb.
1654
 */
1655
TRACE_EVENT(kvm_hv_flush_tlb,
1656
	TP_PROTO(u64 processor_mask, u64 address_space, u64 flags, bool guest_mode),
1657
	TP_ARGS(processor_mask, address_space, flags, guest_mode),
1658

1659
	TP_STRUCT__entry(
1660
		__field(u64, processor_mask)
1661
		__field(u64, address_space)
1662
		__field(u64, flags)
1663
		__field(bool, guest_mode)
1664
	),
1665

1666
	TP_fast_assign(
1667
		__entry->processor_mask = processor_mask;
1668
		__entry->address_space = address_space;
1669
		__entry->flags = flags;
1670
		__entry->guest_mode = guest_mode;
1671
	),
1672

1673
	TP_printk("processor_mask 0x%llx address_space 0x%llx flags 0x%llx %s",
1674
		  __entry->processor_mask, __entry->address_space,
1675
		  __entry->flags, __entry->guest_mode ? "(L2)" : "")
1676
);
1677

1678
/*
1679
 * Tracepoint for kvm_hv_flush_tlb_ex.
1680
 */
1681
TRACE_EVENT(kvm_hv_flush_tlb_ex,
1682
	TP_PROTO(u64 valid_bank_mask, u64 format, u64 address_space, u64 flags, bool guest_mode),
1683
	TP_ARGS(valid_bank_mask, format, address_space, flags, guest_mode),
1684

1685
	TP_STRUCT__entry(
1686
		__field(u64, valid_bank_mask)
1687
		__field(u64, format)
1688
		__field(u64, address_space)
1689
		__field(u64, flags)
1690
		__field(bool, guest_mode)
1691
	),
1692

1693
	TP_fast_assign(
1694
		__entry->valid_bank_mask = valid_bank_mask;
1695
		__entry->format = format;
1696
		__entry->address_space = address_space;
1697
		__entry->flags = flags;
1698
		__entry->guest_mode = guest_mode;
1699
	),
1700

1701
	TP_printk("valid_bank_mask 0x%llx format 0x%llx "
1702
		  "address_space 0x%llx flags 0x%llx %s",
1703
		  __entry->valid_bank_mask, __entry->format,
1704
		  __entry->address_space, __entry->flags,
1705
		  __entry->guest_mode ? "(L2)" : "")
1706
);
1707

1708
/*
1709
 * Tracepoints for kvm_hv_send_ipi.
1710
 */
1711
TRACE_EVENT(kvm_hv_send_ipi,
1712
	TP_PROTO(u32 vector, u64 processor_mask),
1713
	TP_ARGS(vector, processor_mask),
1714

1715
	TP_STRUCT__entry(
1716
		__field(u32, vector)
1717
		__field(u64, processor_mask)
1718
	),
1719

1720
	TP_fast_assign(
1721
		__entry->vector = vector;
1722
		__entry->processor_mask = processor_mask;
1723
	),
1724

1725
	TP_printk("vector %x processor_mask 0x%llx",
1726
		  __entry->vector, __entry->processor_mask)
1727
);
1728

1729
TRACE_EVENT(kvm_hv_send_ipi_ex,
1730
	TP_PROTO(u32 vector, u64 format, u64 valid_bank_mask),
1731
	TP_ARGS(vector, format, valid_bank_mask),
1732

1733
	TP_STRUCT__entry(
1734
		__field(u32, vector)
1735
		__field(u64, format)
1736
		__field(u64, valid_bank_mask)
1737
	),
1738

1739
	TP_fast_assign(
1740
		__entry->vector = vector;
1741
		__entry->format = format;
1742
		__entry->valid_bank_mask = valid_bank_mask;
1743
	),
1744

1745
	TP_printk("vector %x format %llx valid_bank_mask 0x%llx",
1746
		  __entry->vector, __entry->format,
1747
		  __entry->valid_bank_mask)
1748
);
1749

1750
TRACE_EVENT(kvm_pv_tlb_flush,
1751
	TP_PROTO(unsigned int vcpu_id, bool need_flush_tlb),
1752
	TP_ARGS(vcpu_id, need_flush_tlb),
1753

1754
	TP_STRUCT__entry(
1755
		__field(	unsigned int,	vcpu_id		)
1756
		__field(	bool,	need_flush_tlb		)
1757
	),
1758

1759
	TP_fast_assign(
1760
		__entry->vcpu_id	= vcpu_id;
1761
		__entry->need_flush_tlb = need_flush_tlb;
1762
	),
1763

1764
	TP_printk("vcpu %u need_flush_tlb %s", __entry->vcpu_id,
1765
		__entry->need_flush_tlb ? "true" : "false")
1766
);
1767

1768
/*
1769
 * Tracepoint for failed nested VMX VM-Enter.
1770
 */
1771
TRACE_EVENT(kvm_nested_vmenter_failed,
1772
	TP_PROTO(const char *msg, u32 err),
1773
	TP_ARGS(msg, err),
1774

1775
	TP_STRUCT__entry(
1776
		__string(msg, msg)
1777
		__field(u32, err)
1778
	),
1779

1780
	TP_fast_assign(
1781
		__assign_str(msg);
1782
		__entry->err = err;
1783
	),
1784

1785
	TP_printk("%s%s", __get_str(msg), !__entry->err ? "" :
1786
		__print_symbolic(__entry->err, VMX_VMENTER_INSTRUCTION_ERRORS))
1787
);
1788

1789
/*
1790
 * Tracepoint for syndbg_set_msr.
1791
 */
1792
TRACE_EVENT(kvm_hv_syndbg_set_msr,
1793
	TP_PROTO(int vcpu_id, u32 vp_index, u32 msr, u64 data),
1794
	TP_ARGS(vcpu_id, vp_index, msr, data),
1795

1796
	TP_STRUCT__entry(
1797
		__field(int, vcpu_id)
1798
		__field(u32, vp_index)
1799
		__field(u32, msr)
1800
		__field(u64, data)
1801
	),
1802

1803
	TP_fast_assign(
1804
		__entry->vcpu_id = vcpu_id;
1805
		__entry->vp_index = vp_index;
1806
		__entry->msr = msr;
1807
		__entry->data = data;
1808
	),
1809

1810
	TP_printk("vcpu_id %d vp_index %u msr 0x%x data 0x%llx",
1811
		  __entry->vcpu_id, __entry->vp_index, __entry->msr,
1812
		  __entry->data)
1813
);
1814

1815
/*
1816
 * Tracepoint for syndbg_get_msr.
1817
 */
1818
TRACE_EVENT(kvm_hv_syndbg_get_msr,
1819
	TP_PROTO(int vcpu_id, u32 vp_index, u32 msr, u64 data),
1820
	TP_ARGS(vcpu_id, vp_index, msr, data),
1821

1822
	TP_STRUCT__entry(
1823
		__field(int, vcpu_id)
1824
		__field(u32, vp_index)
1825
		__field(u32, msr)
1826
		__field(u64, data)
1827
	),
1828

1829
	TP_fast_assign(
1830
		__entry->vcpu_id = vcpu_id;
1831
		__entry->vp_index = vp_index;
1832
		__entry->msr = msr;
1833
		__entry->data = data;
1834
	),
1835

1836
	TP_printk("vcpu_id %d vp_index %u msr 0x%x data 0x%llx",
1837
		  __entry->vcpu_id, __entry->vp_index, __entry->msr,
1838
		  __entry->data)
1839
);
1840

1841
/*
1842
 * Tracepoint for the start of VMGEXIT processing
1843
 */
1844
TRACE_EVENT(kvm_vmgexit_enter,
1845
	TP_PROTO(unsigned int vcpu_id, struct ghcb *ghcb),
1846
	TP_ARGS(vcpu_id, ghcb),
1847

1848
	TP_STRUCT__entry(
1849
		__field(unsigned int, vcpu_id)
1850
		__field(u64, exit_reason)
1851
		__field(u64, info1)
1852
		__field(u64, info2)
1853
	),
1854

1855
	TP_fast_assign(
1856
		__entry->vcpu_id     = vcpu_id;
1857
		__entry->exit_reason = ghcb->save.sw_exit_code;
1858
		__entry->info1       = ghcb->save.sw_exit_info_1;
1859
		__entry->info2       = ghcb->save.sw_exit_info_2;
1860
	),
1861

1862
	TP_printk("vcpu %u, exit_reason %llx, exit_info1 %llx, exit_info2 %llx",
1863
		  __entry->vcpu_id, __entry->exit_reason,
1864
		  __entry->info1, __entry->info2)
1865
);
1866

1867
/*
1868
 * Tracepoint for the end of VMGEXIT processing
1869
 */
1870
TRACE_EVENT(kvm_vmgexit_exit,
1871
	TP_PROTO(unsigned int vcpu_id, struct ghcb *ghcb),
1872
	TP_ARGS(vcpu_id, ghcb),
1873

1874
	TP_STRUCT__entry(
1875
		__field(unsigned int, vcpu_id)
1876
		__field(u64, exit_reason)
1877
		__field(u64, info1)
1878
		__field(u64, info2)
1879
	),
1880

1881
	TP_fast_assign(
1882
		__entry->vcpu_id     = vcpu_id;
1883
		__entry->exit_reason = ghcb->save.sw_exit_code;
1884
		__entry->info1       = ghcb->save.sw_exit_info_1;
1885
		__entry->info2       = ghcb->save.sw_exit_info_2;
1886
	),
1887

1888
	TP_printk("vcpu %u, exit_reason %llx, exit_info1 %llx, exit_info2 %llx",
1889
		  __entry->vcpu_id, __entry->exit_reason,
1890
		  __entry->info1, __entry->info2)
1891
);
1892

1893
/*
1894
 * Tracepoint for the start of VMGEXIT MSR procotol processing
1895
 */
1896
TRACE_EVENT(kvm_vmgexit_msr_protocol_enter,
1897
	TP_PROTO(unsigned int vcpu_id, u64 ghcb_gpa),
1898
	TP_ARGS(vcpu_id, ghcb_gpa),
1899

1900
	TP_STRUCT__entry(
1901
		__field(unsigned int, vcpu_id)
1902
		__field(u64, ghcb_gpa)
1903
	),
1904

1905
	TP_fast_assign(
1906
		__entry->vcpu_id  = vcpu_id;
1907
		__entry->ghcb_gpa = ghcb_gpa;
1908
	),
1909

1910
	TP_printk("vcpu %u, ghcb_gpa %016llx",
1911
		  __entry->vcpu_id, __entry->ghcb_gpa)
1912
);
1913

1914
/*
1915
 * Tracepoint for the end of VMGEXIT MSR procotol processing
1916
 */
1917
TRACE_EVENT(kvm_vmgexit_msr_protocol_exit,
1918
	TP_PROTO(unsigned int vcpu_id, u64 ghcb_gpa, int result),
1919
	TP_ARGS(vcpu_id, ghcb_gpa, result),
1920

1921
	TP_STRUCT__entry(
1922
		__field(unsigned int, vcpu_id)
1923
		__field(u64, ghcb_gpa)
1924
		__field(int, result)
1925
	),
1926

1927
	TP_fast_assign(
1928
		__entry->vcpu_id  = vcpu_id;
1929
		__entry->ghcb_gpa = ghcb_gpa;
1930
		__entry->result   = result;
1931
	),
1932

1933
	TP_printk("vcpu %u, ghcb_gpa %016llx, result %d",
1934
		  __entry->vcpu_id, __entry->ghcb_gpa, __entry->result)
1935
);
1936

1937
/*
1938
 * Tracepoint for #NPFs due to RMP faults.
1939
 */
1940
TRACE_EVENT(kvm_rmp_fault,
1941
	TP_PROTO(struct kvm_vcpu *vcpu, u64 gpa, u64 pfn, u64 error_code,
1942
		 int rmp_level, int psmash_ret),
1943
	TP_ARGS(vcpu, gpa, pfn, error_code, rmp_level, psmash_ret),
1944

1945
	TP_STRUCT__entry(
1946
		__field(unsigned int, vcpu_id)
1947
		__field(u64, gpa)
1948
		__field(u64, pfn)
1949
		__field(u64, error_code)
1950
		__field(int, rmp_level)
1951
		__field(int, psmash_ret)
1952
	),
1953

1954
	TP_fast_assign(
1955
		__entry->vcpu_id	= vcpu->vcpu_id;
1956
		__entry->gpa		= gpa;
1957
		__entry->pfn		= pfn;
1958
		__entry->error_code	= error_code;
1959
		__entry->rmp_level	= rmp_level;
1960
		__entry->psmash_ret	= psmash_ret;
1961
	),
1962

1963
	TP_printk("vcpu %u gpa %016llx pfn 0x%llx error_code 0x%llx rmp_level %d psmash_ret %d",
1964
		  __entry->vcpu_id, __entry->gpa, __entry->pfn,
1965
		  __entry->error_code, __entry->rmp_level, __entry->psmash_ret)
1966
);
1967

1968
#endif /* _TRACE_KVM_H */
1969

1970
#undef TRACE_INCLUDE_PATH
1971
#define TRACE_INCLUDE_PATH ../../arch/x86/kvm
1972
#undef TRACE_INCLUDE_FILE
1973
#define TRACE_INCLUDE_FILE trace
1974

1975
/* This part must be outside protection */
1976
#include <trace/define_trace.h>
1977

1978