[people/arne_f/kernel.git] / include / trace / events / kvm.h

/* SPDX-License-Identifier: GPL-2.0 */
#if !defined(_TRACE_KVM_MAIN_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_KVM_MAIN_H

#include <linux/tracepoint.h>

#undef TRACE_SYSTEM
#define TRACE_SYSTEM kvm

#define ERSN(x) { KVM_EXIT_##x, "KVM_EXIT_" #x }

#define kvm_trace_exit_reason						\
	ERSN(UNKNOWN), ERSN(EXCEPTION), ERSN(IO), ERSN(HYPERCALL),	\
	ERSN(DEBUG), ERSN(HLT), ERSN(MMIO), ERSN(IRQ_WINDOW_OPEN),	\
	ERSN(SHUTDOWN), ERSN(FAIL_ENTRY), ERSN(INTR), ERSN(SET_TPR),	\
	ERSN(TPR_ACCESS), ERSN(S390_SIEIC), ERSN(S390_RESET), ERSN(DCR),\
	ERSN(NMI), ERSN(INTERNAL_ERROR), ERSN(OSI), ERSN(PAPR_HCALL),	\
	ERSN(S390_UCONTROL), ERSN(WATCHDOG), ERSN(S390_TSCH), ERSN(EPR),\
	ERSN(SYSTEM_EVENT), ERSN(S390_STSI), ERSN(IOAPIC_EOI),          \
	ERSN(HYPERV)

TRACE_EVENT(kvm_userspace_exit,
	    TP_PROTO(__u32 reason, int errno),
	    TP_ARGS(reason, errno),

	TP_STRUCT__entry(
		__field(	__u32,		reason		)
		__field(	int,		errno		)
	),

	TP_fast_assign(
		__entry->reason		= reason;
		__entry->errno		= errno;
	),

	TP_printk("reason %s (%d)",
		  __entry->errno < 0 ?
		  (__entry->errno == -EINTR ? "restart" : "error") :
		  __print_symbolic(__entry->reason, kvm_trace_exit_reason),
		  __entry->errno < 0 ? -__entry->errno : __entry->reason)
);

TRACE_EVENT(kvm_vcpu_wakeup,
	    TP_PROTO(__u64 ns, bool waited, bool valid),
	    TP_ARGS(ns, waited, valid),

	TP_STRUCT__entry(
		__field(	__u64,		ns		)
		__field(	bool,		waited		)
		__field(	bool,		valid		)
	),

	TP_fast_assign(
		__entry->ns		= ns;
		__entry->waited		= waited;
		__entry->valid		= valid;
	),

	TP_printk("%s time %lld ns, polling %s",
		  __entry->waited ? "wait" : "poll",
		  __entry->ns,
		  __entry->valid ? "valid" : "invalid")
);

#if defined(CONFIG_HAVE_KVM_IRQFD)
TRACE_EVENT(kvm_set_irq,
	TP_PROTO(unsigned int gsi, int level, int irq_source_id),
	TP_ARGS(gsi, level, irq_source_id),

	TP_STRUCT__entry(
		__field(	unsigned int,	gsi		)
		__field(	int,		level		)
		__field(	int,		irq_source_id	)
	),

	TP_fast_assign(
		__entry->gsi		= gsi;
		__entry->level		= level;
		__entry->irq_source_id	= irq_source_id;
	),

	TP_printk("gsi %u level %d source %d",
		  __entry->gsi, __entry->level, __entry->irq_source_id)
);
#endif /* defined(CONFIG_HAVE_KVM_IRQFD) */

#if defined(__KVM_HAVE_IOAPIC)
#define kvm_deliver_mode		\
	{0x0, "Fixed"},			\
	{0x1, "LowPrio"},		\
	{0x2, "SMI"},			\
	{0x3, "Res3"},			\
	{0x4, "NMI"},			\
	{0x5, "INIT"},			\
	{0x6, "SIPI"},			\
	{0x7, "ExtINT"}

TRACE_EVENT(kvm_ioapic_set_irq,
	    TP_PROTO(__u64 e, int pin, bool coalesced),
	    TP_ARGS(e, pin, coalesced),

	TP_STRUCT__entry(
		__field(	__u64,		e		)
		__field(	int,		pin		)
		__field(	bool,		coalesced	)
	),

	TP_fast_assign(
		__entry->e		= e;
		__entry->pin		= pin;
		__entry->coalesced	= coalesced;
	),

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

TRACE_EVENT(kvm_ioapic_delayed_eoi_inj,
	    TP_PROTO(__u64 e),
	    TP_ARGS(e),

	TP_STRUCT__entry(
		__field(	__u64,		e		)
	),

	TP_fast_assign(
		__entry->e		= e;
	),

	TP_printk("dst %x vec %u (%s|%s|%s%s)",
		  (u8)(__entry->e >> 56), (u8)__entry->e,
		  __print_symbolic((__entry->e >> 8 & 0x7), kvm_deliver_mode),
		  (__entry->e & (1<<11)) ? "logical" : "physical",
		  (__entry->e & (1<<15)) ? "level" : "edge",
		  (__entry->e & (1<<16)) ? "|masked" : "")
);

TRACE_EVENT(kvm_msi_set_irq,
	    TP_PROTO(__u64 address, __u64 data),
	    TP_ARGS(address, data),

	TP_STRUCT__entry(
		__field(	__u64,		address		)
		__field(	__u64,		data		)
	),

	TP_fast_assign(
		__entry->address	= address;
		__entry->data		= data;
	),

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

#define kvm_irqchips						\
	{KVM_IRQCHIP_PIC_MASTER,	"PIC master"},		\
	{KVM_IRQCHIP_PIC_SLAVE,		"PIC slave"},		\
	{KVM_IRQCHIP_IOAPIC,		"IOAPIC"}

#endif /* defined(__KVM_HAVE_IOAPIC) */

#if defined(CONFIG_HAVE_KVM_IRQFD)

#ifdef kvm_irqchips
#define kvm_ack_irq_string "irqchip %s pin %u"
#define kvm_ack_irq_parm  __print_symbolic(__entry->irqchip, kvm_irqchips), __entry->pin
#else
#define kvm_ack_irq_string "irqchip %d pin %u"
#define kvm_ack_irq_parm  __entry->irqchip, __entry->pin
#endif

TRACE_EVENT(kvm_ack_irq,
	TP_PROTO(unsigned int irqchip, unsigned int pin),
	TP_ARGS(irqchip, pin),

	TP_STRUCT__entry(
		__field(	unsigned int,	irqchip		)
		__field(	unsigned int,	pin		)
	),

	TP_fast_assign(
		__entry->irqchip	= irqchip;
		__entry->pin		= pin;
	),

	TP_printk(kvm_ack_irq_string, kvm_ack_irq_parm)
);

#endif /* defined(CONFIG_HAVE_KVM_IRQFD) */


#define KVM_TRACE_MMIO_READ_UNSATISFIED 0
#define KVM_TRACE_MMIO_READ 1
#define KVM_TRACE_MMIO_WRITE 2

#define kvm_trace_symbol_mmio \
	{ KVM_TRACE_MMIO_READ_UNSATISFIED, "unsatisfied-read" }, \
	{ KVM_TRACE_MMIO_READ, "read" }, \
	{ KVM_TRACE_MMIO_WRITE, "write" }

TRACE_EVENT(kvm_mmio,
	TP_PROTO(int type, int len, u64 gpa, u64 val),
	TP_ARGS(type, len, gpa, val),

	TP_STRUCT__entry(
		__field(	u32,	type		)
		__field(	u32,	len		)
		__field(	u64,	gpa		)
		__field(	u64,	val		)
	),

	TP_fast_assign(
		__entry->type		= type;
		__entry->len		= len;
		__entry->gpa		= gpa;
		__entry->val		= val;
	),

	TP_printk("mmio %s len %u gpa 0x%llx val 0x%llx",
		  __print_symbolic(__entry->type, kvm_trace_symbol_mmio),
		  __entry->len, __entry->gpa, __entry->val)
);

#define kvm_fpu_load_symbol	\
	{0, "unload"},		\
	{1, "load"}

TRACE_EVENT(kvm_fpu,
	TP_PROTO(int load),
	TP_ARGS(load),

	TP_STRUCT__entry(
		__field(	u32,	        load		)
	),

	TP_fast_assign(
		__entry->load		= load;
	),

	TP_printk("%s", __print_symbolic(__entry->load, kvm_fpu_load_symbol))
);

TRACE_EVENT(kvm_age_page,
	TP_PROTO(ulong gfn, int level, struct kvm_memory_slot *slot, int ref),
	TP_ARGS(gfn, level, slot, ref),

	TP_STRUCT__entry(
		__field(	u64,	hva		)
		__field(	u64,	gfn		)
		__field(	u8,	level		)
		__field(	u8,	referenced	)
	),

	TP_fast_assign(
		__entry->gfn		= gfn;
		__entry->level		= level;
		__entry->hva		= ((gfn - slot->base_gfn) <<
					    PAGE_SHIFT) + slot->userspace_addr;
		__entry->referenced	= ref;
	),

	TP_printk("hva %llx gfn %llx level %u %s",
		  __entry->hva, __entry->gfn, __entry->level,
		  __entry->referenced ? "YOUNG" : "OLD")
);

#ifdef CONFIG_KVM_ASYNC_PF
DECLARE_EVENT_CLASS(kvm_async_get_page_class,

	TP_PROTO(u64 gva, u64 gfn),

	TP_ARGS(gva, gfn),

	TP_STRUCT__entry(
		__field(__u64, gva)
		__field(u64, gfn)
	),

	TP_fast_assign(
		__entry->gva = gva;
		__entry->gfn = gfn;
	),

	TP_printk("gva = %#llx, gfn = %#llx", __entry->gva, __entry->gfn)
);

DEFINE_EVENT(kvm_async_get_page_class, kvm_try_async_get_page,

	TP_PROTO(u64 gva, u64 gfn),

	TP_ARGS(gva, gfn)
);

DEFINE_EVENT(kvm_async_get_page_class, kvm_async_pf_doublefault,

	TP_PROTO(u64 gva, u64 gfn),

	TP_ARGS(gva, gfn)
);

DECLARE_EVENT_CLASS(kvm_async_pf_nopresent_ready,

	TP_PROTO(u64 token, u64 gva),

	TP_ARGS(token, gva),

	TP_STRUCT__entry(
		__field(__u64, token)
		__field(__u64, gva)
	),

	TP_fast_assign(
		__entry->token = token;
		__entry->gva = gva;
	),

	TP_printk("token %#llx gva %#llx", __entry->token, __entry->gva)

);

DEFINE_EVENT(kvm_async_pf_nopresent_ready, kvm_async_pf_not_present,

	TP_PROTO(u64 token, u64 gva),

	TP_ARGS(token, gva)
);

DEFINE_EVENT(kvm_async_pf_nopresent_ready, kvm_async_pf_ready,

	TP_PROTO(u64 token, u64 gva),

	TP_ARGS(token, gva)
);

TRACE_EVENT(
	kvm_async_pf_completed,
	TP_PROTO(unsigned long address, u64 gva),
	TP_ARGS(address, gva),

	TP_STRUCT__entry(
		__field(unsigned long, address)
		__field(u64, gva)
		),

	TP_fast_assign(
		__entry->address = address;
		__entry->gva = gva;
		),

	TP_printk("gva %#llx address %#lx",  __entry->gva,
		  __entry->address)
);

#endif

TRACE_EVENT(kvm_halt_poll_ns,
	TP_PROTO(bool grow, unsigned int vcpu_id, unsigned int new,
		 unsigned int old),
	TP_ARGS(grow, vcpu_id, new, old),

	TP_STRUCT__entry(
		__field(bool, grow)
		__field(unsigned int, vcpu_id)
		__field(unsigned int, new)
		__field(unsigned int, old)
	),

	TP_fast_assign(
		__entry->grow           = grow;
		__entry->vcpu_id        = vcpu_id;
		__entry->new            = new;
		__entry->old            = old;
	),

	TP_printk("vcpu %u: halt_poll_ns %u (%s %u)",
			__entry->vcpu_id,
			__entry->new,
			__entry->grow ? "grow" : "shrink",
			__entry->old)
);

#define trace_kvm_halt_poll_ns_grow(vcpu_id, new, old) \
	trace_kvm_halt_poll_ns(true, vcpu_id, new, old)
#define trace_kvm_halt_poll_ns_shrink(vcpu_id, new, old) \
	trace_kvm_halt_poll_ns(false, vcpu_id, new, old)

#endif /* _TRACE_KVM_MAIN_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
229456fc MT	2	#if !defined(_TRACE_KVM_MAIN_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	3	#define _TRACE_KVM_MAIN_H
	4
	5	#include <linux/tracepoint.h>
	6
	7	#undef TRACE_SYSTEM
	8	#define TRACE_SYSTEM kvm
229456fc	9
64be5007 GN	10	#define ERSN(x) { KVM_EXIT_##x, "KVM_EXIT_" #x }
	11
	12	#define kvm_trace_exit_reason \
	13	ERSN(UNKNOWN), ERSN(EXCEPTION), ERSN(IO), ERSN(HYPERCALL), \
	14	ERSN(DEBUG), ERSN(HLT), ERSN(MMIO), ERSN(IRQ_WINDOW_OPEN), \
	15	ERSN(SHUTDOWN), ERSN(FAIL_ENTRY), ERSN(INTR), ERSN(SET_TPR), \
	16	ERSN(TPR_ACCESS), ERSN(S390_SIEIC), ERSN(S390_RESET), ERSN(DCR),\
dcce0489	17	ERSN(NMI), ERSN(INTERNAL_ERROR), ERSN(OSI), ERSN(PAPR_HCALL), \
488e32f1 LP	18	ERSN(S390_UCONTROL), ERSN(WATCHDOG), ERSN(S390_TSCH), ERSN(EPR),\
	19	ERSN(SYSTEM_EVENT), ERSN(S390_STSI), ERSN(IOAPIC_EOI), \
	20	ERSN(HYPERV)
64be5007 GN	21
	22	TRACE_EVENT(kvm_userspace_exit,
	23	TP_PROTO(__u32 reason, int errno),
	24	TP_ARGS(reason, errno),
	25
	26	TP_STRUCT__entry(
	27	__field( __u32, reason )
	28	__field( int, errno )
	29	),
	30
	31	TP_fast_assign(
	32	__entry->reason = reason;
	33	__entry->errno = errno;
	34	),
	35
	36	TP_printk("reason %s (%d)",
	37	__entry->errno < 0 ?
	38	(__entry->errno == -EINTR ? "restart" : "error") :
	39	__print_symbolic(__entry->reason, kvm_trace_exit_reason),
	40	__entry->errno < 0 ? -__entry->errno : __entry->reason)
	41	);
	42
f7819512	43	TRACE_EVENT(kvm_vcpu_wakeup,
3491caf2 CB	44	TP_PROTO(__u64 ns, bool waited, bool valid),
3491caf2 CB	45	TP_ARGS(ns, waited, valid),
f7819512 PB	46
	47	TP_STRUCT__entry(
	48	__field( __u64, ns )
	49	__field( bool, waited )
3491caf2	50	__field( bool, valid )
f7819512 PB	51	),
	52
	53	TP_fast_assign(
	54	__entry->ns = ns;
	55	__entry->waited = waited;
3491caf2	56	__entry->valid = valid;
f7819512 PB	57	),
f7819512 PB	58
3491caf2	59	TP_printk("%s time %lld ns, polling %s",
f7819512	60	__entry->waited ? "wait" : "poll",
3491caf2 CB	61	__entry->ns,
3491caf2 CB	62	__entry->valid ? "valid" : "invalid")
f7819512 PB	63	);
f7819512 PB	64
c77dcacb	65	#if defined(CONFIG_HAVE_KVM_IRQFD)
229456fc	66	TRACE_EVENT(kvm_set_irq,
ae8c1c40 AK	67	TP_PROTO(unsigned int gsi, int level, int irq_source_id),
ae8c1c40 AK	68	TP_ARGS(gsi, level, irq_source_id),
229456fc MT	69
	70	TP_STRUCT__entry(
	71	__field( unsigned int, gsi )
ae8c1c40 AK	72	__field( int, level )
ae8c1c40 AK	73	__field( int, irq_source_id )
229456fc MT	74	),
	75
	76	TP_fast_assign(
	77	__entry->gsi = gsi;
ae8c1c40 AK	78	__entry->level = level;
ae8c1c40 AK	79	__entry->irq_source_id = irq_source_id;
229456fc MT	80	),
229456fc MT	81
ae8c1c40 AK	82	TP_printk("gsi %u level %d source %d",
ae8c1c40 AK	83	__entry->gsi, __entry->level, __entry->irq_source_id)
229456fc	84	);
c77dcacb	85	#endif /* defined(CONFIG_HAVE_KVM_IRQFD) */
229456fc	86
a1e4ccb9	87	#if defined(__KVM_HAVE_IOAPIC)
1000ff8d GN	88	#define kvm_deliver_mode \
	89	{0x0, "Fixed"}, \
	90	{0x1, "LowPrio"}, \
	91	{0x2, "SMI"}, \
	92	{0x3, "Res3"}, \
	93	{0x4, "NMI"}, \
	94	{0x5, "INIT"}, \
	95	{0x6, "SIPI"}, \
	96	{0x7, "ExtINT"}
	97
	98	TRACE_EVENT(kvm_ioapic_set_irq,
	99	TP_PROTO(__u64 e, int pin, bool coalesced),
	100	TP_ARGS(e, pin, coalesced),
	101
	102	TP_STRUCT__entry(
	103	__field( __u64, e )
	104	__field( int, pin )
	105	__field( bool, coalesced )
	106	),
	107
	108	TP_fast_assign(
	109	__entry->e = e;
	110	__entry->pin = pin;
	111	__entry->coalesced = coalesced;
	112	),
	113
cfc5abbc	114	TP_printk("pin %u dst %x vec %u (%s\|%s\|%s%s)%s",
1000ff8d GN	115	__entry->pin, (u8)(__entry->e >> 56), (u8)__entry->e,
	116	__print_symbolic((__entry->e >> 8 & 0x7), kvm_deliver_mode),
	117	(__entry->e & (1<<11)) ? "logical" : "physical",
	118	(__entry->e & (1<<15)) ? "level" : "edge",
	119	(__entry->e & (1<<16)) ? "\|masked" : "",
	120	__entry->coalesced ? " (coalesced)" : "")
	121	);
	122
184564ef ZH	123	TRACE_EVENT(kvm_ioapic_delayed_eoi_inj,
	124	TP_PROTO(__u64 e),
	125	TP_ARGS(e),
	126
	127	TP_STRUCT__entry(
	128	__field( __u64, e )
	129	),
	130
	131	TP_fast_assign(
	132	__entry->e = e;
	133	),
	134
cfc5abbc	135	TP_printk("dst %x vec %u (%s\|%s\|%s%s)",
184564ef ZH	136	(u8)(__entry->e >> 56), (u8)__entry->e,
	137	__print_symbolic((__entry->e >> 8 & 0x7), kvm_deliver_mode),
	138	(__entry->e & (1<<11)) ? "logical" : "physical",
	139	(__entry->e & (1<<15)) ? "level" : "edge",
	140	(__entry->e & (1<<16)) ? "\|masked" : "")
	141	);
	142
1000ff8d GN	143	TRACE_EVENT(kvm_msi_set_irq,
	144	TP_PROTO(__u64 address, __u64 data),
	145	TP_ARGS(address, data),
	146
	147	TP_STRUCT__entry(
	148	__field( __u64, address )
	149	__field( __u64, data )
	150	),
	151
	152	TP_fast_assign(
	153	__entry->address = address;
	154	__entry->data = data;
	155	),
	156
37131313 RK	157	TP_printk("dst %llx vec %u (%s\|%s\|%s%s)",
	158	(u8)(__entry->address >> 12) \| ((__entry->address >> 32) & 0xffffff00),
	159	(u8)__entry->data,
1000ff8d GN	160	__print_symbolic((__entry->data >> 8 & 0x7), kvm_deliver_mode),
	161	(__entry->address & (1<<2)) ? "logical" : "physical",
	162	(__entry->data & (1<<15)) ? "level" : "edge",
	163	(__entry->address & (1<<3)) ? "\|rh" : "")
	164	);
229456fc MT	165
	166	#define kvm_irqchips \
	167	{KVM_IRQCHIP_PIC_MASTER, "PIC master"}, \
	168	{KVM_IRQCHIP_PIC_SLAVE, "PIC slave"}, \
	169	{KVM_IRQCHIP_IOAPIC, "IOAPIC"}
	170
1c9f8520 AG	171	#endif /* defined(__KVM_HAVE_IOAPIC) */
1c9f8520 AG	172
c77dcacb	173	#if defined(CONFIG_HAVE_KVM_IRQFD)
1c9f8520	174
cdef5119 CB	175	#ifdef kvm_irqchips
	176	#define kvm_ack_irq_string "irqchip %s pin %u"
	177	#define kvm_ack_irq_parm __print_symbolic(__entry->irqchip, kvm_irqchips), __entry->pin
	178	#else
	179	#define kvm_ack_irq_string "irqchip %d pin %u"
	180	#define kvm_ack_irq_parm __entry->irqchip, __entry->pin
	181	#endif
	182
229456fc MT	183	TRACE_EVENT(kvm_ack_irq,
	184	TP_PROTO(unsigned int irqchip, unsigned int pin),
	185	TP_ARGS(irqchip, pin),
	186
	187	TP_STRUCT__entry(
	188	__field( unsigned int, irqchip )
	189	__field( unsigned int, pin )
	190	),
	191
	192	TP_fast_assign(
	193	__entry->irqchip = irqchip;
	194	__entry->pin = pin;
	195	),
	196
cdef5119	197	TP_printk(kvm_ack_irq_string, kvm_ack_irq_parm)
229456fc MT	198	);
229456fc MT	199
c77dcacb	200	#endif /* defined(CONFIG_HAVE_KVM_IRQFD) */
229456fc MT	201
229456fc MT	202
aec51dc4 AK	203
	204	#define KVM_TRACE_MMIO_READ_UNSATISFIED 0
	205	#define KVM_TRACE_MMIO_READ 1
	206	#define KVM_TRACE_MMIO_WRITE 2
	207
	208	#define kvm_trace_symbol_mmio \
	209	{ KVM_TRACE_MMIO_READ_UNSATISFIED, "unsatisfied-read" }, \
	210	{ KVM_TRACE_MMIO_READ, "read" }, \
	211	{ KVM_TRACE_MMIO_WRITE, "write" }
	212
	213	TRACE_EVENT(kvm_mmio,
	214	TP_PROTO(int type, int len, u64 gpa, u64 val),
	215	TP_ARGS(type, len, gpa, val),
	216
	217	TP_STRUCT__entry(
	218	__field( u32, type )
	219	__field( u32, len )
	220	__field( u64, gpa )
	221	__field( u64, val )
	222	),
	223
	224	TP_fast_assign(
	225	__entry->type = type;
	226	__entry->len = len;
	227	__entry->gpa = gpa;
	228	__entry->val = val;
	229	),
	230
	231	TP_printk("mmio %s len %u gpa 0x%llx val 0x%llx",
	232	__print_symbolic(__entry->type, kvm_trace_symbol_mmio),
	233	__entry->len, __entry->gpa, __entry->val)
	234	);
	235
0c04851c AK	236	#define kvm_fpu_load_symbol \
	237	{0, "unload"}, \
	238	{1, "load"}
	239
	240	TRACE_EVENT(kvm_fpu,
	241	TP_PROTO(int load),
	242	TP_ARGS(load),
	243
	244	TP_STRUCT__entry(
	245	__field( u32, load )
	246	),
	247
	248	TP_fast_assign(
	249	__entry->load = load;
	250	),
	251
	252	TP_printk("%s", __print_symbolic(__entry->load, kvm_fpu_load_symbol))
	253	);
	254
90bb6fc5	255	TRACE_EVENT(kvm_age_page,
8a9522d2 ALC	256	TP_PROTO(ulong gfn, int level, struct kvm_memory_slot *slot, int ref),
8a9522d2 ALC	257	TP_ARGS(gfn, level, slot, ref),
90bb6fc5 AK	258
	259	TP_STRUCT__entry(
	260	__field( u64, hva )
	261	__field( u64, gfn )
8a9522d2	262	__field( u8, level )
90bb6fc5 AK	263	__field( u8, referenced )
	264	),
	265
	266	TP_fast_assign(
8a9522d2 ALC	267	__entry->gfn = gfn;
	268	__entry->level = level;
	269	__entry->hva = ((gfn - slot->base_gfn) <<
	270	PAGE_SHIFT) + slot->userspace_addr;
90bb6fc5 AK	271	__entry->referenced = ref;
	272	),
	273
8a9522d2 ALC	274	TP_printk("hva %llx gfn %llx level %u %s",
8a9522d2 ALC	275	__entry->hva, __entry->gfn, __entry->level,
90bb6fc5 AK	276	__entry->referenced ? "YOUNG" : "OLD")
	277	);
	278
af585b92	279	#ifdef CONFIG_KVM_ASYNC_PF
0730388b XG	280	DECLARE_EVENT_CLASS(kvm_async_get_page_class,
0730388b XG	281
c9b263d2	282	TP_PROTO(u64 gva, u64 gfn),
0730388b	283
c9b263d2	284	TP_ARGS(gva, gfn),
af585b92 GN	285
af585b92 GN	286	TP_STRUCT__entry(
0730388b	287	__field(__u64, gva)
c9b263d2	288	__field(u64, gfn)
0730388b	289	),
af585b92 GN	290
af585b92 GN	291	TP_fast_assign(
c9b263d2 XG	292	__entry->gva = gva;
c9b263d2 XG	293	__entry->gfn = gfn;
0730388b	294	),
af585b92	295
c9b263d2	296	TP_printk("gva = %#llx, gfn = %#llx", __entry->gva, __entry->gfn)
af585b92 GN	297	);
af585b92 GN	298
0730388b XG	299	DEFINE_EVENT(kvm_async_get_page_class, kvm_try_async_get_page,
	300
	301	TP_PROTO(u64 gva, u64 gfn),
	302
	303	TP_ARGS(gva, gfn)
	304	);
	305
	306	DEFINE_EVENT(kvm_async_get_page_class, kvm_async_pf_doublefault,
	307
	308	TP_PROTO(u64 gva, u64 gfn),
	309
	310	TP_ARGS(gva, gfn)
	311	);
	312
	313	DECLARE_EVENT_CLASS(kvm_async_pf_nopresent_ready,
	314
7c90705b	315	TP_PROTO(u64 token, u64 gva),
0730388b	316
7c90705b	317	TP_ARGS(token, gva),
af585b92 GN	318
af585b92 GN	319	TP_STRUCT__entry(
7c90705b	320	__field(__u64, token)
af585b92	321	__field(__u64, gva)
0730388b	322	),
af585b92 GN	323
af585b92 GN	324	TP_fast_assign(
7c90705b	325	__entry->token = token;
af585b92	326	__entry->gva = gva;
0730388b XG	327	),
	328
	329	TP_printk("token %#llx gva %#llx", __entry->token, __entry->gva)
af585b92	330
af585b92 GN	331	);
af585b92 GN	332
0730388b XG	333	DEFINE_EVENT(kvm_async_pf_nopresent_ready, kvm_async_pf_not_present,
0730388b XG	334
7c90705b	335	TP_PROTO(u64 token, u64 gva),
af585b92	336
0730388b XG	337	TP_ARGS(token, gva)
0730388b XG	338	);
af585b92	339
0730388b XG	340	DEFINE_EVENT(kvm_async_pf_nopresent_ready, kvm_async_pf_ready,
	341
	342	TP_PROTO(u64 token, u64 gva),
af585b92	343
0730388b	344	TP_ARGS(token, gva)
af585b92 GN	345	);
	346
	347	TRACE_EVENT(
	348	kvm_async_pf_completed,
f2e10669	349	TP_PROTO(unsigned long address, u64 gva),
f2e10669	350	TP_ARGS(address, gva),
af585b92 GN	351
	352	TP_STRUCT__entry(
	353	__field(unsigned long, address)
af585b92 GN	354	__field(u64, gva)
	355	),
	356
	357	TP_fast_assign(
	358	__entry->address = address;
af585b92 GN	359	__entry->gva = gva;
	360	),
	361
f2e10669	362	TP_printk("gva %#llx address %#lx", __entry->gva,
f2e10669	363	__entry->address)
af585b92 GN	364	);
af585b92 GN	365
3dfe6a50 WL	366	#endif
3dfe6a50 WL	367
2cbd7824	368	TRACE_EVENT(kvm_halt_poll_ns,
6b6de68c CB	369	TP_PROTO(bool grow, unsigned int vcpu_id, unsigned int new,
6b6de68c CB	370	unsigned int old),
2cbd7824 WL	371	TP_ARGS(grow, vcpu_id, new, old),
	372
	373	TP_STRUCT__entry(
	374	__field(bool, grow)
	375	__field(unsigned int, vcpu_id)
6b6de68c CB	376	__field(unsigned int, new)
6b6de68c CB	377	__field(unsigned int, old)
2cbd7824 WL	378	),
	379
	380	TP_fast_assign(
	381	__entry->grow = grow;
	382	__entry->vcpu_id = vcpu_id;
	383	__entry->new = new;
	384	__entry->old = old;
	385	),
	386
6b6de68c	387	TP_printk("vcpu %u: halt_poll_ns %u (%s %u)",
2cbd7824 WL	388	__entry->vcpu_id,
	389	__entry->new,
	390	__entry->grow ? "grow" : "shrink",
	391	__entry->old)
	392	);
	393
	394	#define trace_kvm_halt_poll_ns_grow(vcpu_id, new, old) \
	395	trace_kvm_halt_poll_ns(true, vcpu_id, new, old)
	396	#define trace_kvm_halt_poll_ns_shrink(vcpu_id, new, old) \
	397	trace_kvm_halt_poll_ns(false, vcpu_id, new, old)
	398
229456fc MT	399	#endif /* _TRACE_KVM_MAIN_H */
	400
	401	/* This part must be outside protection */
	402	#include <trace/define_trace.h>