[linux-2.6-block.git] / arch / x86 / kvm / mmutrace.h

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

#include <linux/tracepoint.h>
#include <linux/trace_events.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)			     \
	__entry->gfn = sp->gfn;			     \
	__entry->role = sp->role.word;		     \
	__entry->root_count = sp->root_count;        \
	__entry->unsync = sp->unsync;

#define KVM_MMU_PAGE_PRINTK() ({				        \
	const char *saved_ptr = trace_seq_buffer_ptr(p);		\
	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 l%u %u-byte q%u%s %s%s"	\
			 " %snxe %sad root %u %s%c",			\
			 __entry->gfn, role.level,			\
			 role.gpte_is_8_bytes ? 8 : 4,			\
			 role.quadrant,					\
			 role.direct ? " direct" : "",			\
			 access_str[role.access],			\
			 role.invalid ? " invalid" : "",		\
			 role.nxe ? "" : "!",				\
			 role.ad_disabled ? "!" : "",			\
			 __entry->root_count,				\
			 __entry->unsync ? "unsync" : "sync", 0);	\
	saved_ptr;							\
		})

#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
 */
TRACE_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(
		__entry->addr = addr;
		__entry->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 */
TRACE_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(
		__entry->pte = pte;
		__entry->level = level;
		),

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

DECLARE_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(
		__entry->gpa = ((u64)table_gfn << PAGE_SHIFT)
				+ index * size;
		),

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

/* We set a pte accessed bit */
DEFINE_EVENT(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 */
DEFINE_EVENT(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)
);

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

	TP_STRUCT__entry(
		__field(__u32, pferr)
		),

	TP_fast_assign(
		__entry->pferr = pferr;
		),

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

TRACE_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)
		__entry->created = created;
		),

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

DECLARE_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())
);

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

	TP_ARGS(sp)
);

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

	TP_ARGS(sp)
);

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

	TP_ARGS(sp)
);

TRACE_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(
		__entry->sptep = sptep;
		__entry->gfn = gfn;
		__entry->access = access;
		__entry->gen = gen;
	),

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

TRACE_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(
		__entry->addr = addr;
		__entry->gfn = gfn;
		__entry->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))

TRACE_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(
		__entry->vcpu_id = vcpu->vcpu_id;
		__entry->gva = gva;
		__entry->error_code = error_code;
		__entry->sptep = sptep;
		__entry->old_spte = old_spte;
		__entry->new_spte = *sptep;
		__entry->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)
	)
);

TRACE_EVENT(
	check_mmio_spte,
	TP_PROTO(u64 spte, unsigned int kvm_gen, unsigned int spte_gen),
	TP_ARGS(spte, kvm_gen, spte_gen),

	TP_STRUCT__entry(
		__field(unsigned int, kvm_gen)
		__field(unsigned int, spte_gen)
		__field(u64, spte)
	),

	TP_fast_assign(
		__entry->kvm_gen = kvm_gen;
		__entry->spte_gen = spte_gen;
		__entry->spte = spte;
	),

	TP_printk("spte %llx kvm_gen %x spte-gen %x valid %d", __entry->spte,
		  __entry->kvm_gen, __entry->spte_gen,
		  __entry->kvm_gen == __entry->spte_gen
	)
);

TRACE_EVENT(
	kvm_mmu_set_spte,
	TP_PROTO(int level, gfn_t gfn, u64 *sptep),
	TP_ARGS(level, gfn, sptep),

	TP_STRUCT__entry(
		__field(u64, gfn)
		__field(u64, spte)
		__field(u64, sptep)
		__field(u8, level)
		/* These depend on page entry type, so compute them now.  */
		__field(bool, r)
		__field(bool, x)
		__field(u8, u)
	),

	TP_fast_assign(
		__entry->gfn = gfn;
		__entry->spte = *sptep;
		__entry->sptep = virt_to_phys(sptep);
		__entry->level = level;
		__entry->r = shadow_present_mask || (__entry->spte & PT_PRESENT_MASK);
		__entry->x = is_executable_pte(__entry->spte);
		__entry->u = shadow_user_mask ? !!(__entry->spte & shadow_user_mask) : -1;
	),

	TP_printk("gfn %llx spte %llx (%s%s%s%s) level %d at %llx",
		  __entry->gfn, __entry->spte,
		  __entry->r ? "r" : "-",
		  __entry->spte & PT_WRITABLE_MASK ? "w" : "-",
		  __entry->x ? "x" : "-",
		  __entry->u == -1 ? "" : (__entry->u ? "u" : "-"),
		  __entry->level, __entry->sptep
	)
);

TRACE_EVENT(
	kvm_mmu_spte_requested,
	TP_PROTO(gpa_t addr, int level, kvm_pfn_t pfn),
	TP_ARGS(addr, level, pfn),

	TP_STRUCT__entry(
		__field(u64, gfn)
		__field(u64, pfn)
		__field(u8, level)
	),

	TP_fast_assign(
		__entry->gfn = addr >> PAGE_SHIFT;
		__entry->pfn = pfn | (__entry->gfn & (KVM_PAGES_PER_HPAGE(level) - 1));
		__entry->level = level;
	),

	TP_printk("gfn %llx pfn %llx level %d",
		  __entry->gfn, __entry->pfn, __entry->level
	)
);

#endif /* _TRACE_KVMMMU_H */

#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH .
#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_FILE mmutrace

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
07420171 AK	2	#if !defined(_TRACE_KVMMMU_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	3	#define _TRACE_KVMMMU_H
	4
	5	#include <linux/tracepoint.h>
af658dca	6	#include <linux/trace_events.h>
07420171 AK	7
	8	#undef TRACE_SYSTEM
	9	#define TRACE_SYSTEM kvmmmu
07420171	10
b59c4830 SC	11	#define KVM_MMU_PAGE_FIELDS \
	12	__field(__u64, gfn) \
	13	__field(__u32, role) \
	14	__field(__u32, root_count) \
df2fb6e7	15	__field(bool, unsync)
f691fe1d	16
b59c4830 SC	17	#define KVM_MMU_PAGE_ASSIGN(sp) \
	18	__entry->gfn = sp->gfn; \
	19	__entry->role = sp->role.word; \
	20	__entry->root_count = sp->root_count; \
f691fe1d AK	21	__entry->unsync = sp->unsync;
	22
	23	#define KVM_MMU_PAGE_PRINTK() ({ \
467aa1f2	24	const char *saved_ptr = trace_seq_buffer_ptr(p); \
f691fe1d AK	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	\
47c42e6b	32	trace_seq_printf(p, "sp gfn %llx l%u %u-byte q%u%s %s%s" \
ac8d57e5	33	" %snxe %sad root %u %s%c", \
5b7e0102	34	__entry->gfn, role.level, \
47c42e6b	35	role.gpte_is_8_bytes ? 8 : 4, \
f691fe1d AK	36	role.quadrant, \
	37	role.direct ? " direct" : "", \
	38	access_str[role.access], \
	39	role.invalid ? " invalid" : "", \
f691fe1d	40	role.nxe ? "" : "!", \
ac8d57e5	41	role.ad_disabled ? "!" : "", \
f691fe1d AK	42	__entry->root_count, \
f691fe1d AK	43	__entry->unsync ? "unsync" : "sync", 0); \
467aa1f2	44	saved_ptr; \
f691fe1d AK	45	})
f691fe1d AK	46
07420171 AK	47	#define kvm_mmu_trace_pferr_flags \
	48	{ PFERR_PRESENT_MASK, "P" }, \
	49	{ PFERR_WRITE_MASK, "W" }, \
	50	{ PFERR_USER_MASK, "U" }, \
	51	{ PFERR_RSVD_MASK, "RSVD" }, \
	52	{ PFERR_FETCH_MASK, "F" }
	53
	54	/*
	55	* A pagetable walk has started
	56	*/
	57	TRACE_EVENT(
	58	kvm_mmu_pagetable_walk,
6fbc2770 XG	59	TP_PROTO(u64 addr, u32 pferr),
6fbc2770 XG	60	TP_ARGS(addr, pferr),
07420171 AK	61
	62	TP_STRUCT__entry(
	63	__field(__u64, addr)
	64	__field(__u32, pferr)
	65	),
	66
	67	TP_fast_assign(
	68	__entry->addr = addr;
6fbc2770	69	__entry->pferr = pferr;
07420171 AK	70	),
	71
	72	TP_printk("addr %llx pferr %x %s", __entry->addr, __entry->pferr,
	73	__print_flags(__entry->pferr, "\|", kvm_mmu_trace_pferr_flags))
	74	);
	75
	76
	77	/* We just walked a paging element */
	78	TRACE_EVENT(
	79	kvm_mmu_paging_element,
	80	TP_PROTO(u64 pte, int level),
	81	TP_ARGS(pte, level),
	82
	83	TP_STRUCT__entry(
	84	__field(__u64, pte)
	85	__field(__u32, level)
	86	),
	87
	88	TP_fast_assign(
	89	__entry->pte = pte;
	90	__entry->level = level;
	91	),
	92
	93	TP_printk("pte %llx level %u", __entry->pte, __entry->level)
	94	);
	95
85f2067c XG	96	DECLARE_EVENT_CLASS(kvm_mmu_set_bit_class,
85f2067c XG	97
07420171	98	TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size),
85f2067c	99
07420171 AK	100	TP_ARGS(table_gfn, index, size),
	101
	102	TP_STRUCT__entry(
	103	__field(__u64, gpa)
85f2067c	104	),
07420171 AK	105
	106	TP_fast_assign(
	107	__entry->gpa = ((u64)table_gfn << PAGE_SHIFT)
	108	+ index * size;
	109	),
	110
	111	TP_printk("gpa %llx", __entry->gpa)
	112	);
	113
85f2067c XG	114	/* We set a pte accessed bit */
	115	DEFINE_EVENT(kvm_mmu_set_bit_class, kvm_mmu_set_accessed_bit,
	116
07420171	117	TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size),
07420171	118
85f2067c XG	119	TP_ARGS(table_gfn, index, size)
85f2067c XG	120	);
07420171	121
85f2067c XG	122	/* We set a pte dirty bit */
85f2067c XG	123	DEFINE_EVENT(kvm_mmu_set_bit_class, kvm_mmu_set_dirty_bit,
07420171	124
85f2067c XG	125	TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size),
	126
	127	TP_ARGS(table_gfn, index, size)
07420171 AK	128	);
	129
	130	TRACE_EVENT(
	131	kvm_mmu_walker_error,
	132	TP_PROTO(u32 pferr),
	133	TP_ARGS(pferr),
	134
	135	TP_STRUCT__entry(
	136	__field(__u32, pferr)
	137	),
	138
	139	TP_fast_assign(
	140	__entry->pferr = pferr;
	141	),
	142
	143	TP_printk("pferr %x %s", __entry->pferr,
	144	__print_flags(__entry->pferr, "\|", kvm_mmu_trace_pferr_flags))
	145	);
	146
f691fe1d AK	147	TRACE_EVENT(
	148	kvm_mmu_get_page,
	149	TP_PROTO(struct kvm_mmu_page *sp, bool created),
	150	TP_ARGS(sp, created),
	151
	152	TP_STRUCT__entry(
	153	KVM_MMU_PAGE_FIELDS
	154	__field(bool, created)
	155	),
	156
	157	TP_fast_assign(
	158	KVM_MMU_PAGE_ASSIGN(sp)
	159	__entry->created = created;
	160	),
	161
	162	TP_printk("%s %s", KVM_MMU_PAGE_PRINTK(),
	163	__entry->created ? "new" : "existing")
	164	);
	165
85f2067c XG	166	DECLARE_EVENT_CLASS(kvm_mmu_page_class,
85f2067c XG	167
f691fe1d AK	168	TP_PROTO(struct kvm_mmu_page *sp),
	169	TP_ARGS(sp),
	170
	171	TP_STRUCT__entry(
	172	KVM_MMU_PAGE_FIELDS
85f2067c	173	),
f691fe1d AK	174
	175	TP_fast_assign(
	176	KVM_MMU_PAGE_ASSIGN(sp)
85f2067c	177	),
f691fe1d AK	178
	179	TP_printk("%s", KVM_MMU_PAGE_PRINTK())
	180	);
	181
85f2067c	182	DEFINE_EVENT(kvm_mmu_page_class, kvm_mmu_sync_page,
f691fe1d	183	TP_PROTO(struct kvm_mmu_page *sp),
f691fe1d	184
85f2067c	185	TP_ARGS(sp)
f691fe1d AK	186	);
f691fe1d AK	187
85f2067c	188	DEFINE_EVENT(kvm_mmu_page_class, kvm_mmu_unsync_page,
f691fe1d	189	TP_PROTO(struct kvm_mmu_page *sp),
f691fe1d	190
85f2067c XG	191	TP_ARGS(sp)
85f2067c XG	192	);
f691fe1d	193
7775834a	194	DEFINE_EVENT(kvm_mmu_page_class, kvm_mmu_prepare_zap_page,
85f2067c	195	TP_PROTO(struct kvm_mmu_page *sp),
f691fe1d	196
85f2067c	197	TP_ARGS(sp)
f691fe1d	198	);
8b1fe17c	199
4f022648 XG	200	TRACE_EVENT(
4f022648 XG	201	mark_mmio_spte,
f2fd125d XG	202	TP_PROTO(u64 *sptep, gfn_t gfn, unsigned access, unsigned int gen),
f2fd125d XG	203	TP_ARGS(sptep, gfn, access, gen),
4f022648 XG	204
	205	TP_STRUCT__entry(
	206	__field(void *, sptep)
	207	__field(gfn_t, gfn)
	208	__field(unsigned, access)
f2fd125d	209	__field(unsigned int, gen)
4f022648 XG	210	),
	211
	212	TP_fast_assign(
	213	__entry->sptep = sptep;
	214	__entry->gfn = gfn;
	215	__entry->access = access;
f2fd125d	216	__entry->gen = gen;
4f022648 XG	217	),
4f022648 XG	218
f2fd125d XG	219	TP_printk("sptep:%p gfn %llx access %x gen %x", __entry->sptep,
f2fd125d XG	220	__entry->gfn, __entry->access, __entry->gen)
4f022648 XG	221	);
	222
	223	TRACE_EVENT(
	224	handle_mmio_page_fault,
	225	TP_PROTO(u64 addr, gfn_t gfn, unsigned access),
	226	TP_ARGS(addr, gfn, access),
	227
	228	TP_STRUCT__entry(
	229	__field(u64, addr)
	230	__field(gfn_t, gfn)
	231	__field(unsigned, access)
	232	),
	233
	234	TP_fast_assign(
	235	__entry->addr = addr;
	236	__entry->gfn = gfn;
	237	__entry->access = access;
	238	),
	239
	240	TP_printk("addr:%llx gfn %llx access %x", __entry->addr, __entry->gfn,
	241	__entry->access)
	242	);
a72faf25 XG	243
	244	#define __spte_satisfied(__spte) \
	245	(__entry->retry && is_writable_pte(__entry->__spte))
	246
	247	TRACE_EVENT(
	248	fast_page_fault,
	249	TP_PROTO(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code,
	250	u64 *sptep, u64 old_spte, bool retry),
	251	TP_ARGS(vcpu, gva, error_code, sptep, old_spte, retry),
	252
	253	TP_STRUCT__entry(
	254	__field(int, vcpu_id)
	255	__field(gva_t, gva)
	256	__field(u32, error_code)
	257	__field(u64 *, sptep)
	258	__field(u64, old_spte)
	259	__field(u64, new_spte)
	260	__field(bool, retry)
	261	),
	262
	263	TP_fast_assign(
	264	__entry->vcpu_id = vcpu->vcpu_id;
	265	__entry->gva = gva;
	266	__entry->error_code = error_code;
	267	__entry->sptep = sptep;
	268	__entry->old_spte = old_spte;
	269	__entry->new_spte = *sptep;
	270	__entry->retry = retry;
	271	),
	272
	273	TP_printk("vcpu %d gva %lx error_code %s sptep %p old %#llx"
	274	" new %llx spurious %d fixed %d", __entry->vcpu_id,
	275	__entry->gva, __print_flags(__entry->error_code, "\|",
	276	kvm_mmu_trace_pferr_flags), __entry->sptep,
	277	__entry->old_spte, __entry->new_spte,
	278	__spte_satisfied(old_spte), __spte_satisfied(new_spte)
	279	)
	280	);
35006126	281
089504c0 XG	282	TRACE_EVENT(
	283	check_mmio_spte,
	284	TP_PROTO(u64 spte, unsigned int kvm_gen, unsigned int spte_gen),
	285	TP_ARGS(spte, kvm_gen, spte_gen),
	286
	287	TP_STRUCT__entry(
	288	__field(unsigned int, kvm_gen)
	289	__field(unsigned int, spte_gen)
	290	__field(u64, spte)
	291	),
	292
	293	TP_fast_assign(
	294	__entry->kvm_gen = kvm_gen;
	295	__entry->spte_gen = spte_gen;
	296	__entry->spte = spte;
	297	),
	298
	299	TP_printk("spte %llx kvm_gen %x spte-gen %x valid %d", __entry->spte,
	300	__entry->kvm_gen, __entry->spte_gen,
	301	__entry->kvm_gen == __entry->spte_gen
	302	)
	303	);
335e192a PB	304
	305	TRACE_EVENT(
	306	kvm_mmu_set_spte,
	307	TP_PROTO(int level, gfn_t gfn, u64 *sptep),
	308	TP_ARGS(level, gfn, sptep),
	309
	310	TP_STRUCT__entry(
	311	__field(u64, gfn)
	312	__field(u64, spte)
	313	__field(u64, sptep)
	314	__field(u8, level)
	315	/* These depend on page entry type, so compute them now. */
	316	__field(bool, r)
	317	__field(bool, x)
	318	__field(u8, u)
	319	),
	320
	321	TP_fast_assign(
	322	__entry->gfn = gfn;
	323	__entry->spte = *sptep;
	324	__entry->sptep = virt_to_phys(sptep);
	325	__entry->level = level;
	326	__entry->r = shadow_present_mask \|\| (__entry->spte & PT_PRESENT_MASK);
	327	__entry->x = is_executable_pte(__entry->spte);
	328	__entry->u = shadow_user_mask ? !!(__entry->spte & shadow_user_mask) : -1;
	329	),
	330
	331	TP_printk("gfn %llx spte %llx (%s%s%s%s) level %d at %llx",
	332	__entry->gfn, __entry->spte,
	333	__entry->r ? "r" : "-",
	334	__entry->spte & PT_WRITABLE_MASK ? "w" : "-",
	335	__entry->x ? "x" : "-",
	336	__entry->u == -1 ? "" : (__entry->u ? "u" : "-"),
	337	__entry->level, __entry->sptep
	338	)
	339	);
	340
	341	TRACE_EVENT(
	342	kvm_mmu_spte_requested,
	343	TP_PROTO(gpa_t addr, int level, kvm_pfn_t pfn),
	344	TP_ARGS(addr, level, pfn),
	345
	346	TP_STRUCT__entry(
	347	__field(u64, gfn)
	348	__field(u64, pfn)
	349	__field(u8, level)
	350	),
	351
	352	TP_fast_assign(
	353	__entry->gfn = addr >> PAGE_SHIFT;
	354	__entry->pfn = pfn \| (__entry->gfn & (KVM_PAGES_PER_HPAGE(level) - 1));
	355	__entry->level = level;
	356	),
	357
	358	TP_printk("gfn %llx pfn %llx level %d",
	359	__entry->gfn, __entry->pfn, __entry->level
	360	)
	361	);
	362
07420171 AK	363	#endif /* _TRACE_KVMMMU_H */
07420171 AK	364
2ed152af XG	365	#undef TRACE_INCLUDE_PATH
	366	#define TRACE_INCLUDE_PATH .
	367	#undef TRACE_INCLUDE_FILE
	368	#define TRACE_INCLUDE_FILE mmutrace
	369
07420171 AK	370	/* This part must be outside protection */
07420171 AK	371	#include <trace/define_trace.h>