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

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

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

#undef TRACE_SYSTEM
#define TRACE_SYSTEM kvmmmu

#define KVM_MMU_PAGE_FIELDS \
	__field(__u64, gfn) \
	__field(__u32, role) \
	__field(__u32, root_count) \
	__field(bool, unsync)

#define KVM_MMU_PAGE_ASSIGN(sp)			     \
	tp_assign(gfn, sp->gfn)			     \
	tp_assign(role, sp->role.word)		     \
	tp_assign(root_count, sp->root_count)        \
	tp_assign(unsync, sp->unsync)

#define KVM_MMU_PAGE_PRINTK() ({				        \
	const char *ret = p->buffer + p->len;				\
	static const char *access_str[] = {			        \
		"---", "--x", "w--", "w-x", "-u-", "-ux", "wu-", "wux"  \
	};							        \
	union kvm_mmu_page_role role;				        \
								        \
	role.word = __entry->role;					\
									\
	trace_seq_printf(p, "sp gfn %llx %u%s q%u%s %s%s"		\
			 " %snxe root %u %s%c",				\
			 __entry->gfn, role.level,			\
			 role.cr4_pae ? " pae" : "",			\
			 role.quadrant,					\
			 role.direct ? " direct" : "",			\
			 access_str[role.access],			\
			 role.invalid ? " invalid" : "",		\
			 role.nxe ? "" : "!",				\
			 __entry->root_count,				\
			 __entry->unsync ? "unsync" : "sync", 0);	\
	ret;								\
		})

#define kvm_mmu_trace_pferr_flags       \
	{ PFERR_PRESENT_MASK, "P" },	\
	{ PFERR_WRITE_MASK, "W" },	\
	{ PFERR_USER_MASK, "U" },	\
	{ PFERR_RSVD_MASK, "RSVD" },	\
	{ PFERR_FETCH_MASK, "F" }

/*
 * A pagetable walk has started
 */
LTTNG_TRACEPOINT_EVENT(
	kvm_mmu_pagetable_walk,
	TP_PROTO(u64 addr, u32 pferr),
	TP_ARGS(addr, pferr),

	TP_STRUCT__entry(
		__field(__u64, addr)
		__field(__u32, pferr)
	),

	TP_fast_assign(
		tp_assign(addr, addr)
		tp_assign(pferr, pferr)
	),

	TP_printk("addr %llx pferr %x %s", __entry->addr, __entry->pferr,
		  __print_flags(__entry->pferr, "|", kvm_mmu_trace_pferr_flags))
)


/* We just walked a paging element */
LTTNG_TRACEPOINT_EVENT(
	kvm_mmu_paging_element,
	TP_PROTO(u64 pte, int level),
	TP_ARGS(pte, level),

	TP_STRUCT__entry(
		__field(__u64, pte)
		__field(__u32, level)
		),

	TP_fast_assign(
		tp_assign(pte, pte)
		tp_assign(level, level)
		),

	TP_printk("pte %llx level %u", __entry->pte, __entry->level)
)

LTTNG_TRACEPOINT_EVENT_CLASS(kvm_mmu_set_bit_class,

	TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size),

	TP_ARGS(table_gfn, index, size),

	TP_STRUCT__entry(
		__field(__u64, gpa)
	),

	TP_fast_assign(
		tp_assign(gpa, ((u64)table_gfn << PAGE_SHIFT)
				+ index * size)
		),

	TP_printk("gpa %llx", __entry->gpa)
)

/* We set a pte accessed bit */
LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_set_bit_class, kvm_mmu_set_accessed_bit,

	TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size),

	TP_ARGS(table_gfn, index, size)
)

/* We set a pte dirty bit */
LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_set_bit_class, kvm_mmu_set_dirty_bit,

	TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size),

	TP_ARGS(table_gfn, index, size)
)

LTTNG_TRACEPOINT_EVENT(
	kvm_mmu_walker_error,
	TP_PROTO(u32 pferr),
	TP_ARGS(pferr),

	TP_STRUCT__entry(
		__field(__u32, pferr)
		),

	TP_fast_assign(
		tp_assign(pferr, pferr)
		),

	TP_printk("pferr %x %s", __entry->pferr,
		  __print_flags(__entry->pferr, "|", kvm_mmu_trace_pferr_flags))
)

LTTNG_TRACEPOINT_EVENT(
	kvm_mmu_get_page,
	TP_PROTO(struct kvm_mmu_page *sp, bool created),
	TP_ARGS(sp, created),

	TP_STRUCT__entry(
		KVM_MMU_PAGE_FIELDS
		__field(bool, created)
		),

	TP_fast_assign(
		KVM_MMU_PAGE_ASSIGN(sp)
		tp_assign(created, created)
		),

	TP_printk("%s %s", KVM_MMU_PAGE_PRINTK(),
		  __entry->created ? "new" : "existing")
)

LTTNG_TRACEPOINT_EVENT_CLASS(kvm_mmu_page_class,

	TP_PROTO(struct kvm_mmu_page *sp),
	TP_ARGS(sp),

	TP_STRUCT__entry(
		KVM_MMU_PAGE_FIELDS
	),

	TP_fast_assign(
		KVM_MMU_PAGE_ASSIGN(sp)
	),

	TP_printk("%s", KVM_MMU_PAGE_PRINTK())
)

LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_sync_page,
	TP_PROTO(struct kvm_mmu_page *sp),

	TP_ARGS(sp)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_unsync_page,
	TP_PROTO(struct kvm_mmu_page *sp),

	TP_ARGS(sp)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_prepare_zap_page,
	TP_PROTO(struct kvm_mmu_page *sp),

	TP_ARGS(sp)
)

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

LTTNG_TRACEPOINT_EVENT(
	mark_mmio_spte,
	TP_PROTO(u64 *sptep, gfn_t gfn, unsigned access, unsigned int gen),
	TP_ARGS(sptep, gfn, access, gen),

	TP_STRUCT__entry(
		__field(void *, sptep)
		__field(gfn_t, gfn)
		__field(unsigned, access)
		__field(unsigned int, gen)
	),

	TP_fast_assign(
		tp_assign(sptep, sptep)
		tp_assign(gfn, gfn)
		tp_assign(access, access)
		tp_assign(gen, gen)
	),

	TP_printk("sptep:%p gfn %llx access %x", __entry->sptep, __entry->gfn,
		  __entry->access)
)

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

LTTNG_TRACEPOINT_EVENT(
	mark_mmio_spte,
	TP_PROTO(u64 *sptep, gfn_t gfn, unsigned access),
	TP_ARGS(sptep, gfn, access),

	TP_STRUCT__entry(
		__field(void *, sptep)
		__field(gfn_t, gfn)
		__field(unsigned, access)
	),

	TP_fast_assign(
		tp_assign(sptep, sptep)
		tp_assign(gfn, gfn)
		tp_assign(access, access)
	),

	TP_printk("sptep:%p gfn %llx access %x", __entry->sptep, __entry->gfn,
		  __entry->access)
)

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

LTTNG_TRACEPOINT_EVENT(
	handle_mmio_page_fault,
	TP_PROTO(u64 addr, gfn_t gfn, unsigned access),
	TP_ARGS(addr, gfn, access),

	TP_STRUCT__entry(
		__field(u64, addr)
		__field(gfn_t, gfn)
		__field(unsigned, access)
	),

	TP_fast_assign(
		tp_assign(addr, addr)
		tp_assign(gfn, gfn)
		tp_assign(access, access)
	),

	TP_printk("addr:%llx gfn %llx access %x", __entry->addr, __entry->gfn,
		  __entry->access)
)

#define __spte_satisfied(__spte)				\
	(__entry->retry && is_writable_pte(__entry->__spte))

LTTNG_TRACEPOINT_EVENT(
	fast_page_fault,
	TP_PROTO(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code,
		 u64 *sptep, u64 old_spte, bool retry),
	TP_ARGS(vcpu, gva, error_code, sptep, old_spte, retry),

	TP_STRUCT__entry(
		__field(int, vcpu_id)
		__field(gva_t, gva)
		__field(u32, error_code)
		__field(u64 *, sptep)
		__field(u64, old_spte)
		__field(u64, new_spte)
		__field(bool, retry)
	),

	TP_fast_assign(
		tp_assign(vcpu_id, vcpu->vcpu_id)
		tp_assign(gva, gva)
		tp_assign(error_code, error_code)
		tp_assign(sptep, sptep)
		tp_assign(old_spte, old_spte)
		tp_assign(new_spte, *sptep)
		tp_assign(retry, retry)
	),

	TP_printk("vcpu %d gva %lx error_code %s sptep %p old %#llx"
		  " new %llx spurious %d fixed %d", __entry->vcpu_id,
		  __entry->gva, __print_flags(__entry->error_code, "|",
		  kvm_mmu_trace_pferr_flags), __entry->sptep,
		  __entry->old_spte, __entry->new_spte,
		  __spte_satisfied(old_spte), __spte_satisfied(new_spte)
	)
)
#endif /* LTTNG_TRACE_KVMMMU_H */

#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module/arch/x86/kvm
#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_FILE mmutrace

/* This part must be outside protection */
#include "../../../../../../probes/define_trace.h"
Commit	Line	Data
3bc29f0a MD	1	#if !defined(LTTNG_TRACE_KVMMMU_H) \|\| defined(TRACE_HEADER_MULTI_READ)
3bc29f0a MD	2	#define LTTNG_TRACE_KVMMMU_H
b3c40230	3
3bc29f0a	4	#include "../../../../../../probes/lttng-tracepoint-event.h"
b3c40230	5	#include <linux/ftrace_event.h>
6c23a6ee	6	#include <linux/version.h>
b3c40230 MG	7
	8	#undef TRACE_SYSTEM
	9	#define TRACE_SYSTEM kvmmmu
	10
	11	#define KVM_MMU_PAGE_FIELDS \
	12	__field(__u64, gfn) \
	13	__field(__u32, role) \
	14	__field(__u32, root_count) \
	15	__field(bool, unsync)
	16
	17	#define KVM_MMU_PAGE_ASSIGN(sp) \
	18	tp_assign(gfn, sp->gfn) \
	19	tp_assign(role, sp->role.word) \
	20	tp_assign(root_count, sp->root_count) \
	21	tp_assign(unsync, sp->unsync)
	22
	23	#define KVM_MMU_PAGE_PRINTK() ({ \
	24	const char *ret = p->buffer + p->len; \
	25	static const char *access_str[] = { \
	26	"---", "--x", "w--", "w-x", "-u-", "-ux", "wu-", "wux" \
	27	}; \
	28	union kvm_mmu_page_role role; \
	29	\
	30	role.word = __entry->role; \
	31	\
	32	trace_seq_printf(p, "sp gfn %llx %u%s q%u%s %s%s" \
	33	" %snxe root %u %s%c", \
	34	__entry->gfn, role.level, \
	35	role.cr4_pae ? " pae" : "", \
	36	role.quadrant, \
	37	role.direct ? " direct" : "", \
	38	access_str[role.access], \
	39	role.invalid ? " invalid" : "", \
	40	role.nxe ? "" : "!", \
	41	__entry->root_count, \
	42	__entry->unsync ? "unsync" : "sync", 0); \
	43	ret; \
	44	})
	45
	46	#define kvm_mmu_trace_pferr_flags \
	47	{ PFERR_PRESENT_MASK, "P" }, \
	48	{ PFERR_WRITE_MASK, "W" }, \
	49	{ PFERR_USER_MASK, "U" }, \
	50	{ PFERR_RSVD_MASK, "RSVD" }, \
	51	{ PFERR_FETCH_MASK, "F" }
	52
	53	/*
	54	* A pagetable walk has started
	55	*/
3bc29f0a	56	LTTNG_TRACEPOINT_EVENT(
b3c40230 MG	57	kvm_mmu_pagetable_walk,
	58	TP_PROTO(u64 addr, u32 pferr),
	59	TP_ARGS(addr, pferr),
	60
	61	TP_STRUCT__entry(
	62	__field(__u64, addr)
	63	__field(__u32, pferr)
	64	),
	65
	66	TP_fast_assign(
	67	tp_assign(addr, addr)
	68	tp_assign(pferr, pferr)
	69	),
	70
	71	TP_printk("addr %llx pferr %x %s", __entry->addr, __entry->pferr,
	72	__print_flags(__entry->pferr, "\|", kvm_mmu_trace_pferr_flags))
	73	)
	74
	75
	76	/* We just walked a paging element */
3bc29f0a	77	LTTNG_TRACEPOINT_EVENT(
b3c40230 MG	78	kvm_mmu_paging_element,
	79	TP_PROTO(u64 pte, int level),
	80	TP_ARGS(pte, level),
	81
	82	TP_STRUCT__entry(
	83	__field(__u64, pte)
	84	__field(__u32, level)
	85	),
	86
	87	TP_fast_assign(
	88	tp_assign(pte, pte)
	89	tp_assign(level, level)
	90	),
	91
	92	TP_printk("pte %llx level %u", __entry->pte, __entry->level)
	93	)
	94
3bc29f0a	95	LTTNG_TRACEPOINT_EVENT_CLASS(kvm_mmu_set_bit_class,
b3c40230 MG	96
	97	TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size),
	98
	99	TP_ARGS(table_gfn, index, size),
	100
	101	TP_STRUCT__entry(
	102	__field(__u64, gpa)
	103	),
	104
	105	TP_fast_assign(
	106	tp_assign(gpa, ((u64)table_gfn << PAGE_SHIFT)
	107	+ index * size)
	108	),
	109
	110	TP_printk("gpa %llx", __entry->gpa)
	111	)
	112
	113	/* We set a pte accessed bit */
3bc29f0a	114	LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_set_bit_class, kvm_mmu_set_accessed_bit,
b3c40230 MG	115
	116	TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size),
	117
	118	TP_ARGS(table_gfn, index, size)
	119	)
	120
	121	/* We set a pte dirty bit */
3bc29f0a	122	LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_set_bit_class, kvm_mmu_set_dirty_bit,
b3c40230 MG	123
	124	TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size),
	125
	126	TP_ARGS(table_gfn, index, size)
	127	)
	128
3bc29f0a	129	LTTNG_TRACEPOINT_EVENT(
b3c40230 MG	130	kvm_mmu_walker_error,
	131	TP_PROTO(u32 pferr),
	132	TP_ARGS(pferr),
	133
	134	TP_STRUCT__entry(
	135	__field(__u32, pferr)
	136	),
	137
	138	TP_fast_assign(
	139	tp_assign(pferr, pferr)
	140	),
	141
	142	TP_printk("pferr %x %s", __entry->pferr,
	143	__print_flags(__entry->pferr, "\|", kvm_mmu_trace_pferr_flags))
	144	)
	145
3bc29f0a	146	LTTNG_TRACEPOINT_EVENT(
b3c40230 MG	147	kvm_mmu_get_page,
	148	TP_PROTO(struct kvm_mmu_page *sp, bool created),
	149	TP_ARGS(sp, created),
	150
	151	TP_STRUCT__entry(
	152	KVM_MMU_PAGE_FIELDS
	153	__field(bool, created)
	154	),
	155
	156	TP_fast_assign(
	157	KVM_MMU_PAGE_ASSIGN(sp)
	158	tp_assign(created, created)
	159	),
	160
	161	TP_printk("%s %s", KVM_MMU_PAGE_PRINTK(),
	162	__entry->created ? "new" : "existing")
	163	)
	164
3bc29f0a	165	LTTNG_TRACEPOINT_EVENT_CLASS(kvm_mmu_page_class,
b3c40230 MG	166
	167	TP_PROTO(struct kvm_mmu_page *sp),
	168	TP_ARGS(sp),
	169
	170	TP_STRUCT__entry(
	171	KVM_MMU_PAGE_FIELDS
	172	),
	173
	174	TP_fast_assign(
	175	KVM_MMU_PAGE_ASSIGN(sp)
	176	),
	177
	178	TP_printk("%s", KVM_MMU_PAGE_PRINTK())
	179	)
	180
3bc29f0a	181	LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_sync_page,
b3c40230 MG	182	TP_PROTO(struct kvm_mmu_page *sp),
	183
	184	TP_ARGS(sp)
	185	)
	186
3bc29f0a	187	LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_unsync_page,
b3c40230 MG	188	TP_PROTO(struct kvm_mmu_page *sp),
	189
	190	TP_ARGS(sp)
	191	)
	192
3bc29f0a	193	LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_prepare_zap_page,
b3c40230 MG	194	TP_PROTO(struct kvm_mmu_page *sp),
	195
	196	TP_ARGS(sp)
	197	)
	198
6c23a6ee MD	199	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
	200
	201	LTTNG_TRACEPOINT_EVENT(
	202	mark_mmio_spte,
	203	TP_PROTO(u64 *sptep, gfn_t gfn, unsigned access, unsigned int gen),
	204	TP_ARGS(sptep, gfn, access, gen),
	205
	206	TP_STRUCT__entry(
	207	__field(void *, sptep)
	208	__field(gfn_t, gfn)
	209	__field(unsigned, access)
	210	__field(unsigned int, gen)
	211	),
	212
	213	TP_fast_assign(
	214	tp_assign(sptep, sptep)
	215	tp_assign(gfn, gfn)
	216	tp_assign(access, access)
	217	tp_assign(gen, gen)
	218	),
	219
	220	TP_printk("sptep:%p gfn %llx access %x", __entry->sptep, __entry->gfn,
	221	__entry->access)
	222	)
	223
	224	#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0)) */
	225
3bc29f0a	226	LTTNG_TRACEPOINT_EVENT(
b3c40230 MG	227	mark_mmio_spte,
	228	TP_PROTO(u64 *sptep, gfn_t gfn, unsigned access),
	229	TP_ARGS(sptep, gfn, access),
	230
	231	TP_STRUCT__entry(
	232	__field(void *, sptep)
	233	__field(gfn_t, gfn)
	234	__field(unsigned, access)
	235	),
	236
	237	TP_fast_assign(
	238	tp_assign(sptep, sptep)
	239	tp_assign(gfn, gfn)
	240	tp_assign(access, access)
	241	),
	242
	243	TP_printk("sptep:%p gfn %llx access %x", __entry->sptep, __entry->gfn,
	244	__entry->access)
	245	)
	246
6c23a6ee MD	247	#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0)) */
6c23a6ee MD	248
3bc29f0a	249	LTTNG_TRACEPOINT_EVENT(
b3c40230 MG	250	handle_mmio_page_fault,
	251	TP_PROTO(u64 addr, gfn_t gfn, unsigned access),
	252	TP_ARGS(addr, gfn, access),
	253
	254	TP_STRUCT__entry(
	255	__field(u64, addr)
	256	__field(gfn_t, gfn)
	257	__field(unsigned, access)
	258	),
	259
	260	TP_fast_assign(
	261	tp_assign(addr, addr)
	262	tp_assign(gfn, gfn)
	263	tp_assign(access, access)
	264	),
	265
	266	TP_printk("addr:%llx gfn %llx access %x", __entry->addr, __entry->gfn,
	267	__entry->access)
	268	)
	269
	270	#define __spte_satisfied(__spte) \
	271	(__entry->retry && is_writable_pte(__entry->__spte))
	272
3bc29f0a	273	LTTNG_TRACEPOINT_EVENT(
b3c40230 MG	274	fast_page_fault,
	275	TP_PROTO(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code,
	276	u64 *sptep, u64 old_spte, bool retry),
	277	TP_ARGS(vcpu, gva, error_code, sptep, old_spte, retry),
	278
	279	TP_STRUCT__entry(
	280	__field(int, vcpu_id)
	281	__field(gva_t, gva)
	282	__field(u32, error_code)
	283	__field(u64 *, sptep)
	284	__field(u64, old_spte)
	285	__field(u64, new_spte)
	286	__field(bool, retry)
	287	),
	288
	289	TP_fast_assign(
	290	tp_assign(vcpu_id, vcpu->vcpu_id)
	291	tp_assign(gva, gva)
	292	tp_assign(error_code, error_code)
	293	tp_assign(sptep, sptep)
	294	tp_assign(old_spte, old_spte)
	295	tp_assign(new_spte, *sptep)
	296	tp_assign(retry, retry)
	297	),
	298
	299	TP_printk("vcpu %d gva %lx error_code %s sptep %p old %#llx"
	300	" new %llx spurious %d fixed %d", __entry->vcpu_id,
	301	__entry->gva, __print_flags(__entry->error_code, "\|",
	302	kvm_mmu_trace_pferr_flags), __entry->sptep,
	303	__entry->old_spte, __entry->new_spte,
	304	__spte_satisfied(old_spte), __spte_satisfied(new_spte)
	305	)
	306	)
3bc29f0a	307	#endif /* LTTNG_TRACE_KVMMMU_H */
b3c40230 MG	308
	309	#undef TRACE_INCLUDE_PATH
	310	#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module/arch/x86/kvm
	311	#undef TRACE_INCLUDE_FILE
	312	#define TRACE_INCLUDE_FILE mmutrace
	313
	314	/* This part must be outside protection */
	315	#include "../../../../../../probes/define_trace.h"