[lttng-modules.git] / instrumentation / events / lttng-module / kvm.h

#if !defined(LTTNG_TRACE_KVM_MAIN_H) || defined(TRACE_HEADER_MULTI_READ)
#define LTTNG_TRACE_KVM_MAIN_H

#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/version.h>

#undef TRACE_SYSTEM
#define TRACE_SYSTEM kvm

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))

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

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))

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

#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0))

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

#else

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

#endif

LTTNG_TRACEPOINT_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(
		tp_assign(reason, reason)
		tp_assign(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)
)
#endif

#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
#if defined(__KVM_HAVE_IOAPIC)
#undef __KVM_HAVE_IRQ_LINE
#define __KVM_HAVE_IRQ_LINE
#endif
#endif

#if defined(__KVM_HAVE_IRQ_LINE)
LTTNG_TRACEPOINT_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(
		tp_assign(gsi, gsi)
		tp_assign(level, level)
		tp_assign(irq_source_id, irq_source_id)
	),

	TP_printk("gsi %u level %d source %d",
		  __entry->gsi, __entry->level, __entry->irq_source_id)
)
#endif

#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"}

LTTNG_TRACEPOINT_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(
		tp_assign(e, e)
		tp_assign(pin, pin)
		tp_assign(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)" : "")
)

LTTNG_TRACEPOINT_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(
		tp_assign(address, address)
		tp_assign(data, data)
	),

	TP_printk("dst %u vec %x (%s|%s|%s%s)",
		  (u8)(__entry->address >> 12), (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"}

LTTNG_TRACEPOINT_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(
		tp_assign(irqchip, irqchip)
		tp_assign(pin, pin)
	),

	TP_printk("irqchip %s pin %u",
		  __print_symbolic(__entry->irqchip, kvm_irqchips),
		 __entry->pin)
)


#endif /* defined(__KVM_HAVE_IOAPIC) */

#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" }

LTTNG_TRACEPOINT_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(
		tp_assign(type, type)
		tp_assign(len, len)
		tp_assign(gpa, gpa)
		tp_assign(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)
)

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))

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

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

	TP_STRUCT__entry(
		__field(	u32,	        load		)
	),

	TP_fast_assign(
		tp_assign(load, load)
	),

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

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,18,0))

LTTNG_TRACEPOINT_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(
		tp_assign(gfn, gfn)
		tp_assign(level, level)
		tp_assign(hva, ((gfn - slot->base_gfn) <<
			PAGE_SHIFT) + slot->userspace_addr)
		tp_assign(referenced, ref)
	),

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

#else

LTTNG_TRACEPOINT_EVENT(kvm_age_page,
	TP_PROTO(ulong hva, struct kvm_memory_slot *slot, int ref),
	TP_ARGS(hva, slot, ref),

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

	TP_fast_assign(
		tp_assign(hva, hva)
		tp_assign(gfn,
		  slot->base_gfn + ((hva - slot->userspace_addr) >> PAGE_SHIFT))
		tp_assign(referenced, ref)
	),

	TP_printk("hva %llx gfn %llx %s",
		  __entry->hva, __entry->gfn,
		  __entry->referenced ? "YOUNG" : "OLD")
)
#endif
#endif

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))

#ifdef CONFIG_KVM_ASYNC_PF
LTTNG_TRACEPOINT_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(
		tp_assign(gva, gva)
		tp_assign(gfn, gfn)
	),

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

LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_get_page_class, kvm_try_async_get_page,

	TP_PROTO(u64 gva, u64 gfn),

	TP_ARGS(gva, gfn)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_get_page_class, kvm_async_pf_doublefault,

	TP_PROTO(u64 gva, u64 gfn),

	TP_ARGS(gva, gfn)
)

LTTNG_TRACEPOINT_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(
		tp_assign(token, token)
		tp_assign(gva, gva)
	),

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

)

LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_pf_nopresent_ready, kvm_async_pf_not_present,

	TP_PROTO(u64 token, u64 gva),

	TP_ARGS(token, gva)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_pf_nopresent_ready, kvm_async_pf_ready,

	TP_PROTO(u64 token, u64 gva),

	TP_ARGS(token, gva)
)

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0))

LTTNG_TRACEPOINT_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(
		tp_assign(address, address)
		tp_assign(gva, gva)
		),

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

#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0)) */

LTTNG_TRACEPOINT_EVENT(
	kvm_async_pf_completed,
	TP_PROTO(unsigned long address, struct page *page, u64 gva),
	TP_ARGS(address, page, gva),

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

	TP_fast_assign(
		tp_assign(address, address)
		tp_assign(pfn, page ? page_to_pfn(page) : 0)
		tp_assign(gva, gva)
		),

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

#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0)) */

#endif

#endif

#endif /* LTTNG_TRACE_KVM_MAIN_H */

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