[deliverable/linux.git] / include / trace / events / kvm.h

#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)

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