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

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

#include <linux/tracepoint.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

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(
		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)
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(
		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"}

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(
		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)" : "")
)

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

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

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

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

TRACE_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

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

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

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

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(
		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)) */

TRACE_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 /* _TRACE_KVM_MAIN_H */

/* This part must be outside protection */
#include "../../../probes/define_trace.h"
Commit	Line	Data
f62b389e MD	1	#if !defined(_TRACE_KVM_MAIN_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	2	#define _TRACE_KVM_MAIN_H
	3
	4	#include <linux/tracepoint.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
f62b389e MD	45	TRACE_EVENT(kvm_userspace_exit,
	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)
f62b389e MD	75	TRACE_EVENT(kvm_set_irq,
	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
	107	TRACE_EVENT(kvm_ioapic_set_irq,
	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
	132	TRACE_EVENT(kvm_msi_set_irq,
	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
	159	TRACE_EVENT(kvm_ack_irq,
	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
191	TRACE_EVENT(kvm_mmio,
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
	220	TRACE_EVENT(kvm_fpu,
	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
	235	TRACE_EVENT(kvm_age_page,
	236	TP_PROTO(ulong hva, struct kvm_memory_slot *slot, int ref),
	237	TP_ARGS(hva, slot, ref),
	238
	239	TP_STRUCT__entry(
	240	__field( u64, hva )
	241	__field( u64, gfn )
	242	__field( u8, referenced )
	243	),
	244
	245	TP_fast_assign(
	246	tp_assign(hva, hva)
	247	tp_assign(gfn,
	248	slot->base_gfn + ((hva - slot->userspace_addr) >> PAGE_SHIFT))
	249	tp_assign(referenced, ref)
	250	),
	251
	252	TP_printk("hva %llx gfn %llx %s",
	253	__entry->hva, __entry->gfn,
	254	__entry->referenced ? "YOUNG" : "OLD")
	255	)
7c68b363 AG	256	#endif
	257
	258	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
f62b389e MD	259
	260	#ifdef CONFIG_KVM_ASYNC_PF
	261	DECLARE_EVENT_CLASS(kvm_async_get_page_class,
	262
	263	TP_PROTO(u64 gva, u64 gfn),
	264
	265	TP_ARGS(gva, gfn),
	266
	267	TP_STRUCT__entry(
	268	__field(__u64, gva)
	269	__field(u64, gfn)
	270	),
	271
	272	TP_fast_assign(
	273	tp_assign(gva, gva)
	274	tp_assign(gfn, gfn)
	275	),
	276
	277	TP_printk("gva = %#llx, gfn = %#llx", __entry->gva, __entry->gfn)
	278	)
	279
	280	DEFINE_EVENT(kvm_async_get_page_class, kvm_try_async_get_page,
	281
	282	TP_PROTO(u64 gva, u64 gfn),
	283
	284	TP_ARGS(gva, gfn)
	285	)
	286
	287	DEFINE_EVENT(kvm_async_get_page_class, kvm_async_pf_doublefault,
	288
	289	TP_PROTO(u64 gva, u64 gfn),
	290
	291	TP_ARGS(gva, gfn)
	292	)
	293
	294	DECLARE_EVENT_CLASS(kvm_async_pf_nopresent_ready,
	295
	296	TP_PROTO(u64 token, u64 gva),
	297
	298	TP_ARGS(token, gva),
	299
	300	TP_STRUCT__entry(
	301	__field(__u64, token)
	302	__field(__u64, gva)
	303	),
	304
	305	TP_fast_assign(
	306	tp_assign(token, token)
	307	tp_assign(gva, gva)
	308	),
	309
	310	TP_printk("token %#llx gva %#llx", __entry->token, __entry->gva)
	311
	312	)
	313
	314	DEFINE_EVENT(kvm_async_pf_nopresent_ready, kvm_async_pf_not_present,
	315
	316	TP_PROTO(u64 token, u64 gva),
	317
	318	TP_ARGS(token, gva)
	319	)
	320
	321	DEFINE_EVENT(kvm_async_pf_nopresent_ready, kvm_async_pf_ready,
	322
323	TP_PROTO(u64 token, u64 gva),
324
325	TP_ARGS(token, gva)
326	)
327
0d019e70 MD	328	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0))
	329
	330	TRACE_EVENT(
	331	kvm_async_pf_completed,
	332	TP_PROTO(unsigned long address, u64 gva),
	333	TP_ARGS(address, gva),
	334
	335	TP_STRUCT__entry(
	336	__field(unsigned long, address)
	337	__field(u64, gva)
	338	),
	339
	340	TP_fast_assign(
	341	tp_assign(address, address)
	342	tp_assign(gva, gva)
	343	),
	344
	345	TP_printk("gva %#llx address %#lx", __entry->gva,
	346	__entry->address)
	347	)
	348
	349	#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0)) */
	350
f62b389e MD	351	TRACE_EVENT(
	352	kvm_async_pf_completed,
	353	TP_PROTO(unsigned long address, struct page *page, u64 gva),
	354	TP_ARGS(address, page, gva),
	355
	356	TP_STRUCT__entry(
	357	__field(unsigned long, address)
	358	__field(pfn_t, pfn)
	359	__field(u64, gva)
	360	),
	361
	362	TP_fast_assign(
	363	tp_assign(address, address)
	364	tp_assign(pfn, page ? page_to_pfn(page) : 0)
	365	tp_assign(gva, gva)
	366	),
	367
	368	TP_printk("gva %#llx address %#lx pfn %#llx", __entry->gva,
	369	__entry->address, __entry->pfn)
	370	)
	371
0d019e70 MD	372	#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0)) */
0d019e70 MD	373
f62b389e MD	374	#endif
f62b389e MD	375
7c68b363 AG	376	#endif
7c68b363 AG	377
f62b389e MD	378	#endif /* _TRACE_KVM_MAIN_H */
	379
	380	/* This part must be outside protection */
5b88d86e	381	#include "../../../probes/define_trace.h"