[mirror_ubuntu-eoan-kernel.git] / tools / lib / traceevent / plugin_kvm.c

/*
 * Copyright (C) 2009 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License (not later!)
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not,  see <http://www.gnu.org/licenses>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

#include "event-parse.h"
#include "trace-seq.h"

#ifdef HAVE_UDIS86

#include <udis86.h>

static ud_t ud;

static void init_disassembler(void)
{
	ud_init(&ud);
	ud_set_syntax(&ud, UD_SYN_ATT);
}

static const char *disassemble(unsigned char *insn, int len, uint64_t rip,
			       int cr0_pe, int eflags_vm,
			       int cs_d, int cs_l)
{
	int mode;

	if (!cr0_pe)
		mode = 16;
	else if (eflags_vm)
		mode = 16;
	else if (cs_l)
		mode = 64;
	else if (cs_d)
		mode = 32;
	else
		mode = 16;

	ud_set_pc(&ud, rip);
	ud_set_mode(&ud, mode);
	ud_set_input_buffer(&ud, insn, len);
	ud_disassemble(&ud);
	return ud_insn_asm(&ud);
}

#else

static void init_disassembler(void)
{
}

static const char *disassemble(unsigned char *insn, int len, uint64_t rip,
			       int cr0_pe, int eflags_vm,
			       int cs_d, int cs_l)
{
	static char out[15*3+1];
	int i;

	for (i = 0; i < len; ++i)
		sprintf(out + i * 3, "%02x ", insn[i]);
	out[len*3-1] = '\0';
	return out;
}

#endif


#define VMX_EXIT_REASONS			\
	_ER(EXCEPTION_NMI,	 0)		\
	_ER(EXTERNAL_INTERRUPT,	 1)		\
	_ER(TRIPLE_FAULT,	 2)		\
	_ER(PENDING_INTERRUPT,	 7)		\
	_ER(NMI_WINDOW,		 8)		\
	_ER(TASK_SWITCH,	 9)		\
	_ER(CPUID,		 10)		\
	_ER(HLT,		 12)		\
	_ER(INVD,		 13)		\
	_ER(INVLPG,		 14)		\
	_ER(RDPMC,		 15)		\
	_ER(RDTSC,		 16)		\
	_ER(VMCALL,		 18)		\
	_ER(VMCLEAR,		 19)		\
	_ER(VMLAUNCH,		 20)		\
	_ER(VMPTRLD,		 21)		\
	_ER(VMPTRST,		 22)		\
	_ER(VMREAD,		 23)		\
	_ER(VMRESUME,		 24)		\
	_ER(VMWRITE,		 25)		\
	_ER(VMOFF,		 26)		\
	_ER(VMON,		 27)		\
	_ER(CR_ACCESS,		 28)		\
	_ER(DR_ACCESS,		 29)		\
	_ER(IO_INSTRUCTION,	 30)		\
	_ER(MSR_READ,		 31)		\
	_ER(MSR_WRITE,		 32)		\
	_ER(MWAIT_INSTRUCTION,	 36)		\
	_ER(MONITOR_INSTRUCTION, 39)		\
	_ER(PAUSE_INSTRUCTION,	 40)		\
	_ER(MCE_DURING_VMENTRY,	 41)		\
	_ER(TPR_BELOW_THRESHOLD, 43)		\
	_ER(APIC_ACCESS,	 44)		\
	_ER(EOI_INDUCED,	 45)		\
	_ER(EPT_VIOLATION,	 48)		\
	_ER(EPT_MISCONFIG,	 49)		\
	_ER(INVEPT,		 50)		\
	_ER(PREEMPTION_TIMER,	 52)		\
	_ER(WBINVD,		 54)		\
	_ER(XSETBV,		 55)		\
	_ER(APIC_WRITE,		 56)		\
	_ER(INVPCID,		 58)		\
	_ER(PML_FULL,		 62)		\
	_ER(XSAVES,		 63)		\
	_ER(XRSTORS,		 64)

#define SVM_EXIT_REASONS \
	_ER(EXIT_READ_CR0,	0x000)		\
	_ER(EXIT_READ_CR3,	0x003)		\
	_ER(EXIT_READ_CR4,	0x004)		\
	_ER(EXIT_READ_CR8,	0x008)		\
	_ER(EXIT_WRITE_CR0,	0x010)		\
	_ER(EXIT_WRITE_CR3,	0x013)		\
	_ER(EXIT_WRITE_CR4,	0x014)		\
	_ER(EXIT_WRITE_CR8,	0x018)		\
	_ER(EXIT_READ_DR0,	0x020)		\
	_ER(EXIT_READ_DR1,	0x021)		\
	_ER(EXIT_READ_DR2,	0x022)		\
	_ER(EXIT_READ_DR3,	0x023)		\
	_ER(EXIT_READ_DR4,	0x024)		\
	_ER(EXIT_READ_DR5,	0x025)		\
	_ER(EXIT_READ_DR6,	0x026)		\
	_ER(EXIT_READ_DR7,	0x027)		\
	_ER(EXIT_WRITE_DR0,	0x030)		\
	_ER(EXIT_WRITE_DR1,	0x031)		\
	_ER(EXIT_WRITE_DR2,	0x032)		\
	_ER(EXIT_WRITE_DR3,	0x033)		\
	_ER(EXIT_WRITE_DR4,	0x034)		\
	_ER(EXIT_WRITE_DR5,	0x035)		\
	_ER(EXIT_WRITE_DR6,	0x036)		\
	_ER(EXIT_WRITE_DR7,	0x037)		\
	_ER(EXIT_EXCP_BASE,     0x040)		\
	_ER(EXIT_INTR,		0x060)		\
	_ER(EXIT_NMI,		0x061)		\
	_ER(EXIT_SMI,		0x062)		\
	_ER(EXIT_INIT,		0x063)		\
	_ER(EXIT_VINTR,		0x064)		\
	_ER(EXIT_CR0_SEL_WRITE,	0x065)		\
	_ER(EXIT_IDTR_READ,	0x066)		\
	_ER(EXIT_GDTR_READ,	0x067)		\
	_ER(EXIT_LDTR_READ,	0x068)		\
	_ER(EXIT_TR_READ,	0x069)		\
	_ER(EXIT_IDTR_WRITE,	0x06a)		\
	_ER(EXIT_GDTR_WRITE,	0x06b)		\
	_ER(EXIT_LDTR_WRITE,	0x06c)		\
	_ER(EXIT_TR_WRITE,	0x06d)		\
	_ER(EXIT_RDTSC,		0x06e)		\
	_ER(EXIT_RDPMC,		0x06f)		\
	_ER(EXIT_PUSHF,		0x070)		\
	_ER(EXIT_POPF,		0x071)		\
	_ER(EXIT_CPUID,		0x072)		\
	_ER(EXIT_RSM,		0x073)		\
	_ER(EXIT_IRET,		0x074)		\
	_ER(EXIT_SWINT,		0x075)		\
	_ER(EXIT_INVD,		0x076)		\
	_ER(EXIT_PAUSE,		0x077)		\
	_ER(EXIT_HLT,		0x078)		\
	_ER(EXIT_INVLPG,	0x079)		\
	_ER(EXIT_INVLPGA,	0x07a)		\
	_ER(EXIT_IOIO,		0x07b)		\
	_ER(EXIT_MSR,		0x07c)		\
	_ER(EXIT_TASK_SWITCH,	0x07d)		\
	_ER(EXIT_FERR_FREEZE,	0x07e)		\
	_ER(EXIT_SHUTDOWN,	0x07f)		\
	_ER(EXIT_VMRUN,		0x080)		\
	_ER(EXIT_VMMCALL,	0x081)		\
	_ER(EXIT_VMLOAD,	0x082)		\
	_ER(EXIT_VMSAVE,	0x083)		\
	_ER(EXIT_STGI,		0x084)		\
	_ER(EXIT_CLGI,		0x085)		\
	_ER(EXIT_SKINIT,	0x086)		\
	_ER(EXIT_RDTSCP,	0x087)		\
	_ER(EXIT_ICEBP,		0x088)		\
	_ER(EXIT_WBINVD,	0x089)		\
	_ER(EXIT_MONITOR,	0x08a)		\
	_ER(EXIT_MWAIT,		0x08b)		\
	_ER(EXIT_MWAIT_COND,	0x08c)		\
	_ER(EXIT_NPF,		0x400)		\
	_ER(EXIT_ERR,		-1)

#define _ER(reason, val)	{ #reason, val },
struct str_values {
	const char	*str;
	int		val;
};

static struct str_values vmx_exit_reasons[] = {
	VMX_EXIT_REASONS
	{ NULL, -1}
};

static struct str_values svm_exit_reasons[] = {
	SVM_EXIT_REASONS
	{ NULL, -1}
};

static struct isa_exit_reasons {
	unsigned isa;
	struct str_values *strings;
} isa_exit_reasons[] = {
	{ .isa = 1, .strings = vmx_exit_reasons },
	{ .isa = 2, .strings = svm_exit_reasons },
	{ }
};

static const char *find_exit_reason(unsigned isa, int val)
{
	struct str_values *strings = NULL;
	int i;

	for (i = 0; isa_exit_reasons[i].strings; ++i)
		if (isa_exit_reasons[i].isa == isa) {
			strings = isa_exit_reasons[i].strings;
			break;
		}
	if (!strings)
		return "UNKNOWN-ISA";
	for (i = 0; strings[i].val >= 0; i++)
		if (strings[i].val == val)
			break;

	return strings[i].str;
}

static int print_exit_reason(struct trace_seq *s, struct tep_record *record,
			     struct tep_event *event, const char *field)
{
	unsigned long long isa;
	unsigned long long val;
	const char *reason;

	if (tep_get_field_val(s, event, field, record, &val, 1) < 0)
		return -1;

	if (tep_get_field_val(s, event, "isa", record, &isa, 0) < 0)
		isa = 1;

	reason = find_exit_reason(isa, val);
	if (reason)
		trace_seq_printf(s, "reason %s", reason);
	else
		trace_seq_printf(s, "reason UNKNOWN (%llu)", val);
	return 0;
}

static int kvm_exit_handler(struct trace_seq *s, struct tep_record *record,
			    struct tep_event *event, void *context)
{
	unsigned long long info1 = 0, info2 = 0;

	if (print_exit_reason(s, record, event, "exit_reason") < 0)
		return -1;

	tep_print_num_field(s, " rip 0x%lx", event, "guest_rip", record, 1);

	if (tep_get_field_val(s, event, "info1", record, &info1, 0) >= 0
	    && tep_get_field_val(s, event, "info2", record, &info2, 0) >= 0)
		trace_seq_printf(s, " info %llx %llx", info1, info2);

	return 0;
}

#define KVM_EMUL_INSN_F_CR0_PE (1 << 0)
#define KVM_EMUL_INSN_F_EFL_VM (1 << 1)
#define KVM_EMUL_INSN_F_CS_D   (1 << 2)
#define KVM_EMUL_INSN_F_CS_L   (1 << 3)

static int kvm_emulate_insn_handler(struct trace_seq *s,
				    struct tep_record *record,
				    struct tep_event *event, void *context)
{
	unsigned long long rip, csbase, len, flags, failed;
	int llen;
	uint8_t *insn;
	const char *disasm;

	if (tep_get_field_val(s, event, "rip", record, &rip, 1) < 0)
		return -1;

	if (tep_get_field_val(s, event, "csbase", record, &csbase, 1) < 0)
		return -1;

	if (tep_get_field_val(s, event, "len", record, &len, 1) < 0)
		return -1;

	if (tep_get_field_val(s, event, "flags", record, &flags, 1) < 0)
		return -1;

	if (tep_get_field_val(s, event, "failed", record, &failed, 1) < 0)
		return -1;

	insn = tep_get_field_raw(s, event, "insn", record, &llen, 1);
	if (!insn)
		return -1;

	disasm = disassemble(insn, len, rip,
			     flags & KVM_EMUL_INSN_F_CR0_PE,
			     flags & KVM_EMUL_INSN_F_EFL_VM,
			     flags & KVM_EMUL_INSN_F_CS_D,
			     flags & KVM_EMUL_INSN_F_CS_L);

	trace_seq_printf(s, "%llx:%llx: %s%s", csbase, rip, disasm,
			 failed ? " FAIL" : "");
	return 0;
}


static int kvm_nested_vmexit_inject_handler(struct trace_seq *s, struct tep_record *record,
					    struct tep_event *event, void *context)
{
	if (print_exit_reason(s, record, event, "exit_code") < 0)
		return -1;

	tep_print_num_field(s, " info1 %llx", event, "exit_info1", record, 1);
	tep_print_num_field(s, " info2 %llx", event, "exit_info2", record, 1);
	tep_print_num_field(s, " int_info %llx", event, "exit_int_info", record, 1);
	tep_print_num_field(s, " int_info_err %llx", event, "exit_int_info_err", record, 1);

	return 0;
}

static int kvm_nested_vmexit_handler(struct trace_seq *s, struct tep_record *record,
				     struct tep_event *event, void *context)
{
	tep_print_num_field(s, "rip %llx ", event, "rip", record, 1);

	return kvm_nested_vmexit_inject_handler(s, record, event, context);
}

union kvm_mmu_page_role {
	unsigned word;
	struct {
		unsigned level:4;
		unsigned cr4_pae:1;
		unsigned quadrant:2;
		unsigned direct:1;
		unsigned access:3;
		unsigned invalid:1;
		unsigned nxe:1;
		unsigned cr0_wp:1;
		unsigned smep_and_not_wp:1;
		unsigned smap_and_not_wp:1;
		unsigned pad_for_nice_hex_output:8;
		unsigned smm:8;
	};
};

static int kvm_mmu_print_role(struct trace_seq *s, struct tep_record *record,
			      struct tep_event *event, void *context)
{
	unsigned long long val;
	static const char *access_str[] = {
		"---", "--x", "w--", "w-x", "-u-", "-ux", "wu-", "wux"
	};
	union kvm_mmu_page_role role;

	if (tep_get_field_val(s, event, "role", record, &val, 1) < 0)
		return -1;

	role.word = (int)val;

	/*
	 * We can only use the structure if file is of the same
	 * endianness.
	 */
	if (tep_file_bigendian(event->pevent) ==
	    tep_is_host_bigendian(event->pevent)) {

		trace_seq_printf(s, "%u q%u%s %s%s %spae %snxe %swp%s%s%s",
				 role.level,
				 role.quadrant,
				 role.direct ? " direct" : "",
				 access_str[role.access],
				 role.invalid ? " invalid" : "",
				 role.cr4_pae ? "" : "!",
				 role.nxe ? "" : "!",
				 role.cr0_wp ? "" : "!",
				 role.smep_and_not_wp ? " smep" : "",
				 role.smap_and_not_wp ? " smap" : "",
				 role.smm ? " smm" : "");
	} else
		trace_seq_printf(s, "WORD: %08x", role.word);

	tep_print_num_field(s, " root %u ",  event,
			    "root_count", record, 1);

	if (tep_get_field_val(s, event, "unsync", record, &val, 1) < 0)
		return -1;

	trace_seq_printf(s, "%s%c",  val ? "unsync" : "sync", 0);
	return 0;
}

static int kvm_mmu_get_page_handler(struct trace_seq *s,
				    struct tep_record *record,
				    struct tep_event *event, void *context)
{
	unsigned long long val;

	if (tep_get_field_val(s, event, "created", record, &val, 1) < 0)
		return -1;

	trace_seq_printf(s, "%s ", val ? "new" : "existing");

	if (tep_get_field_val(s, event, "gfn", record, &val, 1) < 0)
		return -1;

	trace_seq_printf(s, "sp gfn %llx ", val);
	return kvm_mmu_print_role(s, record, event, context);
}

#define PT_WRITABLE_SHIFT 1
#define PT_WRITABLE_MASK (1ULL << PT_WRITABLE_SHIFT)

static unsigned long long
process_is_writable_pte(struct trace_seq *s, unsigned long long *args)
{
	unsigned long pte = args[0];
	return pte & PT_WRITABLE_MASK;
}

int TEP_PLUGIN_LOADER(struct tep_handle *pevent)
{
	init_disassembler();

	tep_register_event_handler(pevent, -1, "kvm", "kvm_exit",
				   kvm_exit_handler, NULL);

	tep_register_event_handler(pevent, -1, "kvm", "kvm_emulate_insn",
				   kvm_emulate_insn_handler, NULL);

	tep_register_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit",
				   kvm_nested_vmexit_handler, NULL);

	tep_register_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit_inject",
				   kvm_nested_vmexit_inject_handler, NULL);

	tep_register_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_get_page",
				   kvm_mmu_get_page_handler, NULL);

	tep_register_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_sync_page",
				   kvm_mmu_print_role, NULL);

	tep_register_event_handler(pevent, -1,
				   "kvmmmu", "kvm_mmu_unsync_page",
				   kvm_mmu_print_role, NULL);

	tep_register_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_zap_page",
				   kvm_mmu_print_role, NULL);

	tep_register_event_handler(pevent, -1, "kvmmmu",
			"kvm_mmu_prepare_zap_page", kvm_mmu_print_role,
			NULL);

	tep_register_print_function(pevent,
				    process_is_writable_pte,
				    TEP_FUNC_ARG_INT,
				    "is_writable_pte",
				    TEP_FUNC_ARG_LONG,
				    TEP_FUNC_ARG_VOID);
	return 0;
}

void TEP_PLUGIN_UNLOADER(struct tep_handle *pevent)
{
	tep_unregister_event_handler(pevent, -1, "kvm", "kvm_exit",
				     kvm_exit_handler, NULL);

	tep_unregister_event_handler(pevent, -1, "kvm", "kvm_emulate_insn",
				     kvm_emulate_insn_handler, NULL);

	tep_unregister_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit",
				     kvm_nested_vmexit_handler, NULL);

	tep_unregister_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit_inject",
				     kvm_nested_vmexit_inject_handler, NULL);

	tep_unregister_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_get_page",
				     kvm_mmu_get_page_handler, NULL);

	tep_unregister_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_sync_page",
				     kvm_mmu_print_role, NULL);

	tep_unregister_event_handler(pevent, -1,
				     "kvmmmu", "kvm_mmu_unsync_page",
				     kvm_mmu_print_role, NULL);

	tep_unregister_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_zap_page",
				     kvm_mmu_print_role, NULL);

	tep_unregister_event_handler(pevent, -1, "kvmmmu",
			"kvm_mmu_prepare_zap_page", kvm_mmu_print_role,
			NULL);

	tep_unregister_print_function(pevent, process_is_writable_pte,
				      "is_writable_pte");
}
Commit	Line	Data
35d79f9f JO	1	/*
	2	* Copyright (C) 2009 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
	3	*
	4	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Lesser General Public
	7	* License as published by the Free Software Foundation;
	8	* version 2.1 of the License (not later!)
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU Lesser General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Lesser General Public
	16	* License along with this program; if not, see <http://www.gnu.org/licenses>
	17	*
	18	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	19	*/
	20	#include <stdio.h>
	21	#include <stdlib.h>
	22	#include <string.h>
	23	#include <stdint.h>
	24
	25	#include "event-parse.h"
266b851c	26	#include "trace-seq.h"
35d79f9f JO	27
	28	#ifdef HAVE_UDIS86
	29
	30	#include <udis86.h>
	31
	32	static ud_t ud;
	33
	34	static void init_disassembler(void)
	35	{
	36	ud_init(&ud);
	37	ud_set_syntax(&ud, UD_SYN_ATT);
	38	}
	39
	40	static const char disassemble(unsigned char insn, int len, uint64_t rip,
	41	int cr0_pe, int eflags_vm,
	42	int cs_d, int cs_l)
	43	{
	44	int mode;
	45
	46	if (!cr0_pe)
	47	mode = 16;
	48	else if (eflags_vm)
	49	mode = 16;
	50	else if (cs_l)
	51	mode = 64;
	52	else if (cs_d)
	53	mode = 32;
	54	else
	55	mode = 16;
	56
	57	ud_set_pc(&ud, rip);
	58	ud_set_mode(&ud, mode);
	59	ud_set_input_buffer(&ud, insn, len);
	60	ud_disassemble(&ud);
	61	return ud_insn_asm(&ud);
	62	}
	63
	64	#else
	65
	66	static void init_disassembler(void)
	67	{
	68	}
	69
	70	static const char disassemble(unsigned char insn, int len, uint64_t rip,
	71	int cr0_pe, int eflags_vm,
	72	int cs_d, int cs_l)
	73	{
	74	static char out[15*3+1];
	75	int i;
	76
	77	for (i = 0; i < len; ++i)
	78	sprintf(out + i * 3, "%02x ", insn[i]);
	79	out[len*3-1] = '\0';
	80	return out;
	81	}
	82
	83	#endif
	84
	85
	86	#define VMX_EXIT_REASONS \
	87	_ER(EXCEPTION_NMI, 0) \
	88	_ER(EXTERNAL_INTERRUPT, 1) \
	89	_ER(TRIPLE_FAULT, 2) \
	90	_ER(PENDING_INTERRUPT, 7) \
91	_ER(NMI_WINDOW, 8) \
92	_ER(TASK_SWITCH, 9) \
93	_ER(CPUID, 10) \
94	_ER(HLT, 12) \
95	_ER(INVD, 13) \
96	_ER(INVLPG, 14) \
97	_ER(RDPMC, 15) \
98	_ER(RDTSC, 16) \
99	_ER(VMCALL, 18) \
100	_ER(VMCLEAR, 19) \
101	_ER(VMLAUNCH, 20) \
102	_ER(VMPTRLD, 21) \
103	_ER(VMPTRST, 22) \
104	_ER(VMREAD, 23) \
105	_ER(VMRESUME, 24) \
106	_ER(VMWRITE, 25) \
107	_ER(VMOFF, 26) \
108	_ER(VMON, 27) \
109	_ER(CR_ACCESS, 28) \
110	_ER(DR_ACCESS, 29) \
111	_ER(IO_INSTRUCTION, 30) \
112	_ER(MSR_READ, 31) \
113	_ER(MSR_WRITE, 32) \
114	_ER(MWAIT_INSTRUCTION, 36) \
115	_ER(MONITOR_INSTRUCTION, 39) \
116	_ER(PAUSE_INSTRUCTION, 40) \
117	_ER(MCE_DURING_VMENTRY, 41) \
118	_ER(TPR_BELOW_THRESHOLD, 43) \
119	_ER(APIC_ACCESS, 44) \
120	_ER(EOI_INDUCED, 45) \
121	_ER(EPT_VIOLATION, 48) \
122	_ER(EPT_MISCONFIG, 49) \
123	_ER(INVEPT, 50) \
124	_ER(PREEMPTION_TIMER, 52) \
125	_ER(WBINVD, 54) \
126	_ER(XSETBV, 55) \
127	_ER(APIC_WRITE, 56) \
2f465dee PB	128	_ER(INVPCID, 58) \
	129	_ER(PML_FULL, 62) \
	130	_ER(XSAVES, 63) \
	131	_ER(XRSTORS, 64)
35d79f9f JO	132
	133	#define SVM_EXIT_REASONS \
	134	_ER(EXIT_READ_CR0, 0x000) \
	135	_ER(EXIT_READ_CR3, 0x003) \
	136	_ER(EXIT_READ_CR4, 0x004) \
	137	_ER(EXIT_READ_CR8, 0x008) \
	138	_ER(EXIT_WRITE_CR0, 0x010) \
	139	_ER(EXIT_WRITE_CR3, 0x013) \
	140	_ER(EXIT_WRITE_CR4, 0x014) \
	141	_ER(EXIT_WRITE_CR8, 0x018) \
	142	_ER(EXIT_READ_DR0, 0x020) \
	143	_ER(EXIT_READ_DR1, 0x021) \
	144	_ER(EXIT_READ_DR2, 0x022) \
	145	_ER(EXIT_READ_DR3, 0x023) \
	146	_ER(EXIT_READ_DR4, 0x024) \
	147	_ER(EXIT_READ_DR5, 0x025) \
	148	_ER(EXIT_READ_DR6, 0x026) \
	149	_ER(EXIT_READ_DR7, 0x027) \
	150	_ER(EXIT_WRITE_DR0, 0x030) \
	151	_ER(EXIT_WRITE_DR1, 0x031) \
	152	_ER(EXIT_WRITE_DR2, 0x032) \
	153	_ER(EXIT_WRITE_DR3, 0x033) \
	154	_ER(EXIT_WRITE_DR4, 0x034) \
	155	_ER(EXIT_WRITE_DR5, 0x035) \
	156	_ER(EXIT_WRITE_DR6, 0x036) \
	157	_ER(EXIT_WRITE_DR7, 0x037) \
	158	_ER(EXIT_EXCP_BASE, 0x040) \
	159	_ER(EXIT_INTR, 0x060) \
	160	_ER(EXIT_NMI, 0x061) \
	161	_ER(EXIT_SMI, 0x062) \
	162	_ER(EXIT_INIT, 0x063) \
	163	_ER(EXIT_VINTR, 0x064) \
	164	_ER(EXIT_CR0_SEL_WRITE, 0x065) \
	165	_ER(EXIT_IDTR_READ, 0x066) \
	166	_ER(EXIT_GDTR_READ, 0x067) \
	167	_ER(EXIT_LDTR_READ, 0x068) \
	168	_ER(EXIT_TR_READ, 0x069) \
	169	_ER(EXIT_IDTR_WRITE, 0x06a) \
	170	_ER(EXIT_GDTR_WRITE, 0x06b) \
	171	_ER(EXIT_LDTR_WRITE, 0x06c) \
	172	_ER(EXIT_TR_WRITE, 0x06d) \
	173	_ER(EXIT_RDTSC, 0x06e) \
	174	_ER(EXIT_RDPMC, 0x06f) \
	175	_ER(EXIT_PUSHF, 0x070) \
	176	_ER(EXIT_POPF, 0x071) \
	177	_ER(EXIT_CPUID, 0x072) \
	178	_ER(EXIT_RSM, 0x073) \
	179	_ER(EXIT_IRET, 0x074) \
	180	_ER(EXIT_SWINT, 0x075) \
	181	_ER(EXIT_INVD, 0x076) \
	182	_ER(EXIT_PAUSE, 0x077) \
	183	_ER(EXIT_HLT, 0x078) \
	184	_ER(EXIT_INVLPG, 0x079) \
	185	_ER(EXIT_INVLPGA, 0x07a) \
	186	_ER(EXIT_IOIO, 0x07b) \
	187	_ER(EXIT_MSR, 0x07c) \
	188	_ER(EXIT_TASK_SWITCH, 0x07d) \
	189	_ER(EXIT_FERR_FREEZE, 0x07e) \
	190	_ER(EXIT_SHUTDOWN, 0x07f) \
	191	_ER(EXIT_VMRUN, 0x080) \
	192	_ER(EXIT_VMMCALL, 0x081) \
	193	_ER(EXIT_VMLOAD, 0x082) \
	194	_ER(EXIT_VMSAVE, 0x083) \
	195	_ER(EXIT_STGI, 0x084) \
196	_ER(EXIT_CLGI, 0x085) \
197	_ER(EXIT_SKINIT, 0x086) \
198	_ER(EXIT_RDTSCP, 0x087) \
199	_ER(EXIT_ICEBP, 0x088) \
200	_ER(EXIT_WBINVD, 0x089) \
201	_ER(EXIT_MONITOR, 0x08a) \
202	_ER(EXIT_MWAIT, 0x08b) \
203	_ER(EXIT_MWAIT_COND, 0x08c) \
204	_ER(EXIT_NPF, 0x400) \
205	_ER(EXIT_ERR, -1)
206
207	#define _ER(reason, val) { #reason, val },
208	struct str_values {
209	const char *str;
210	int val;
211	};
212
213	static struct str_values vmx_exit_reasons[] = {
214	VMX_EXIT_REASONS
215	{ NULL, -1}
216	};
217
218	static struct str_values svm_exit_reasons[] = {
219	SVM_EXIT_REASONS
220	{ NULL, -1}
221	};
222
223	static struct isa_exit_reasons {
224	unsigned isa;
225	struct str_values *strings;
226	} isa_exit_reasons[] = {
227	{ .isa = 1, .strings = vmx_exit_reasons },
228	{ .isa = 2, .strings = svm_exit_reasons },
229	{ }
230	};
231
232	static const char *find_exit_reason(unsigned isa, int val)
233	{
234	struct str_values *strings = NULL;
235	int i;
236
237	for (i = 0; isa_exit_reasons[i].strings; ++i)
238	if (isa_exit_reasons[i].isa == isa) {
239	strings = isa_exit_reasons[i].strings;
240	break;
241	}
242	if (!strings)
243	return "UNKNOWN-ISA";
244	for (i = 0; strings[i].val >= 0; i++)
245	if (strings[i].val == val)
246	break;
20d3cbd7 JK	247
20d3cbd7 JK	248	return strings[i].str;
35d79f9f JO	249	}
35d79f9f JO	250
cbc49b25	251	static int print_exit_reason(struct trace_seq s, struct tep_record record,
97fbf3f0	252	struct tep_event event, const char field)
35d79f9f JO	253	{
	254	unsigned long long isa;
	255	unsigned long long val;
20d3cbd7	256	const char *reason;
35d79f9f	257
8b3e0872	258	if (tep_get_field_val(s, event, field, record, &val, 1) < 0)
35d79f9f JO	259	return -1;
35d79f9f JO	260
8b3e0872	261	if (tep_get_field_val(s, event, "isa", record, &isa, 0) < 0)
35d79f9f JO	262	isa = 1;
35d79f9f JO	263
20d3cbd7 JK	264	reason = find_exit_reason(isa, val);
	265	if (reason)
	266	trace_seq_printf(s, "reason %s", reason);
	267	else
	268	trace_seq_printf(s, "reason UNKNOWN (%llu)", val);
6f21037b JK	269	return 0;
	270	}
	271
cbc49b25	272	static int kvm_exit_handler(struct trace_seq s, struct tep_record record,
97fbf3f0	273	struct tep_event event, void context)
6f21037b JK	274	{
	275	unsigned long long info1 = 0, info2 = 0;
	276
	277	if (print_exit_reason(s, record, event, "exit_reason") < 0)
	278	return -1;
35d79f9f	279
6a48dc29	280	tep_print_num_field(s, " rip 0x%lx", event, "guest_rip", record, 1);
35d79f9f	281
8b3e0872 TSV	282	if (tep_get_field_val(s, event, "info1", record, &info1, 0) >= 0
8b3e0872 TSV	283	&& tep_get_field_val(s, event, "info2", record, &info2, 0) >= 0)
35d79f9f JO	284	trace_seq_printf(s, " info %llx %llx", info1, info2);
	285
	286	return 0;
	287	}
	288
	289	#define KVM_EMUL_INSN_F_CR0_PE (1 << 0)
	290	#define KVM_EMUL_INSN_F_EFL_VM (1 << 1)
	291	#define KVM_EMUL_INSN_F_CS_D (1 << 2)
	292	#define KVM_EMUL_INSN_F_CS_L (1 << 3)
	293
	294	static int kvm_emulate_insn_handler(struct trace_seq *s,
cbc49b25	295	struct tep_record *record,
97fbf3f0	296	struct tep_event event, void context)
35d79f9f JO	297	{
	298	unsigned long long rip, csbase, len, flags, failed;
	299	int llen;
	300	uint8_t *insn;
	301	const char *disasm;
	302
8b3e0872	303	if (tep_get_field_val(s, event, "rip", record, &rip, 1) < 0)
35d79f9f JO	304	return -1;
35d79f9f JO	305
8b3e0872	306	if (tep_get_field_val(s, event, "csbase", record, &csbase, 1) < 0)
35d79f9f JO	307	return -1;
35d79f9f JO	308
8b3e0872	309	if (tep_get_field_val(s, event, "len", record, &len, 1) < 0)
35d79f9f JO	310	return -1;
35d79f9f JO	311
8b3e0872	312	if (tep_get_field_val(s, event, "flags", record, &flags, 1) < 0)
35d79f9f JO	313	return -1;
35d79f9f JO	314
8b3e0872	315	if (tep_get_field_val(s, event, "failed", record, &failed, 1) < 0)
35d79f9f JO	316	return -1;
35d79f9f JO	317
8b3e0872	318	insn = tep_get_field_raw(s, event, "insn", record, &llen, 1);
35d79f9f JO	319	if (!insn)
	320	return -1;
	321
	322	disasm = disassemble(insn, len, rip,
	323	flags & KVM_EMUL_INSN_F_CR0_PE,
	324	flags & KVM_EMUL_INSN_F_EFL_VM,
	325	flags & KVM_EMUL_INSN_F_CS_D,
	326	flags & KVM_EMUL_INSN_F_CS_L);
	327
	328	trace_seq_printf(s, "%llx:%llx: %s%s", csbase, rip, disasm,
	329	failed ? " FAIL" : "");
	330	return 0;
	331	}
	332
ea092aeb	333
cbc49b25	334	static int kvm_nested_vmexit_inject_handler(struct trace_seq s, struct tep_record record,
97fbf3f0	335	struct tep_event event, void context)
ea092aeb	336	{
7f6e3635	337	if (print_exit_reason(s, record, event, "exit_code") < 0)
ea092aeb SRRH	338	return -1;
ea092aeb SRRH	339
6a48dc29 TSV	340	tep_print_num_field(s, " info1 %llx", event, "exit_info1", record, 1);
	341	tep_print_num_field(s, " info2 %llx", event, "exit_info2", record, 1);
	342	tep_print_num_field(s, " int_info %llx", event, "exit_int_info", record, 1);
	343	tep_print_num_field(s, " int_info_err %llx", event, "exit_int_info_err", record, 1);
ea092aeb SRRH	344
	345	return 0;
	346	}
	347
cbc49b25	348	static int kvm_nested_vmexit_handler(struct trace_seq s, struct tep_record record,
97fbf3f0	349	struct tep_event event, void context)
ea092aeb	350	{
6a48dc29	351	tep_print_num_field(s, "rip %llx ", event, "rip", record, 1);
ea092aeb SRRH	352
	353	return kvm_nested_vmexit_inject_handler(s, record, event, context);
	354	}
	355
35d79f9f JO	356	union kvm_mmu_page_role {
	357	unsigned word;
	358	struct {
35d79f9f	359	unsigned level:4;
2f465dee	360	unsigned cr4_pae:1;
35d79f9f	361	unsigned quadrant:2;
35d79f9f JO	362	unsigned direct:1;
	363	unsigned access:3;
	364	unsigned invalid:1;
35d79f9f	365	unsigned nxe:1;
2f465dee PB	366	unsigned cr0_wp:1;
	367	unsigned smep_and_not_wp:1;
	368	unsigned smap_and_not_wp:1;
	369	unsigned pad_for_nice_hex_output:8;
	370	unsigned smm:8;
35d79f9f JO	371	};
	372	};
	373
cbc49b25	374	static int kvm_mmu_print_role(struct trace_seq s, struct tep_record record,
97fbf3f0	375	struct tep_event event, void context)
35d79f9f JO	376	{
	377	unsigned long long val;
	378	static const char *access_str[] = {
	379	"---", "--x", "w--", "w-x", "-u-", "-ux", "wu-", "wux"
	380	};
	381	union kvm_mmu_page_role role;
	382
8b3e0872	383	if (tep_get_field_val(s, event, "role", record, &val, 1) < 0)
35d79f9f JO	384	return -1;
	385
	386	role.word = (int)val;
	387
	388	/*
	389	* We can only use the structure if file is of the same
3e449f7c	390	* endianness.
35d79f9f	391	*/
4104e604	392	if (tep_file_bigendian(event->pevent) ==
413af01c	393	tep_is_host_bigendian(event->pevent)) {
35d79f9f	394
2f465dee	395	trace_seq_printf(s, "%u q%u%s %s%s %spae %snxe %swp%s%s%s",
35d79f9f	396	role.level,
35d79f9f JO	397	role.quadrant,
	398	role.direct ? " direct" : "",
	399	access_str[role.access],
	400	role.invalid ? " invalid" : "",
2f465dee PB	401	role.cr4_pae ? "" : "!",
	402	role.nxe ? "" : "!",
	403	role.cr0_wp ? "" : "!",
	404	role.smep_and_not_wp ? " smep" : "",
	405	role.smap_and_not_wp ? " smap" : "",
	406	role.smm ? " smm" : "");
35d79f9f JO	407	} else
	408	trace_seq_printf(s, "WORD: %08x", role.word);
	409
6a48dc29 TSV	410	tep_print_num_field(s, " root %u ", event,
6a48dc29 TSV	411	"root_count", record, 1);
35d79f9f	412
8b3e0872	413	if (tep_get_field_val(s, event, "unsync", record, &val, 1) < 0)
35d79f9f JO	414	return -1;
	415
	416	trace_seq_printf(s, "%s%c", val ? "unsync" : "sync", 0);
	417	return 0;
	418	}
	419
	420	static int kvm_mmu_get_page_handler(struct trace_seq *s,
cbc49b25	421	struct tep_record *record,
97fbf3f0	422	struct tep_event event, void context)
35d79f9f JO	423	{
	424	unsigned long long val;
	425
8b3e0872	426	if (tep_get_field_val(s, event, "created", record, &val, 1) < 0)
35d79f9f JO	427	return -1;
	428
	429	trace_seq_printf(s, "%s ", val ? "new" : "existing");
	430
8b3e0872	431	if (tep_get_field_val(s, event, "gfn", record, &val, 1) < 0)
35d79f9f JO	432	return -1;
	433
	434	trace_seq_printf(s, "sp gfn %llx ", val);
	435	return kvm_mmu_print_role(s, record, event, context);
	436	}
	437
6d65894b JO	438	#define PT_WRITABLE_SHIFT 1
	439	#define PT_WRITABLE_MASK (1ULL << PT_WRITABLE_SHIFT)
	440
	441	static unsigned long long
	442	process_is_writable_pte(struct trace_seq s, unsigned long long args)
	443	{
	444	unsigned long pte = args[0];
	445	return pte & PT_WRITABLE_MASK;
	446	}
	447
c32d52b4	448	int TEP_PLUGIN_LOADER(struct tep_handle *pevent)
35d79f9f JO	449	{
	450	init_disassembler();
	451
b843e9c3 TSV	452	tep_register_event_handler(pevent, -1, "kvm", "kvm_exit",
b843e9c3 TSV	453	kvm_exit_handler, NULL);
35d79f9f	454
b843e9c3 TSV	455	tep_register_event_handler(pevent, -1, "kvm", "kvm_emulate_insn",
b843e9c3 TSV	456	kvm_emulate_insn_handler, NULL);
35d79f9f	457
b843e9c3 TSV	458	tep_register_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit",
b843e9c3 TSV	459	kvm_nested_vmexit_handler, NULL);
ea092aeb	460
b843e9c3 TSV	461	tep_register_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit_inject",
b843e9c3 TSV	462	kvm_nested_vmexit_inject_handler, NULL);
ea092aeb	463
b843e9c3 TSV	464	tep_register_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_get_page",
b843e9c3 TSV	465	kvm_mmu_get_page_handler, NULL);
35d79f9f	466
b843e9c3 TSV	467	tep_register_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_sync_page",
b843e9c3 TSV	468	kvm_mmu_print_role, NULL);
35d79f9f	469
b843e9c3 TSV	470	tep_register_event_handler(pevent, -1,
	471	"kvmmmu", "kvm_mmu_unsync_page",
	472	kvm_mmu_print_role, NULL);
35d79f9f	473
b843e9c3 TSV	474	tep_register_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_zap_page",
b843e9c3 TSV	475	kvm_mmu_print_role, NULL);
35d79f9f	476
b843e9c3	477	tep_register_event_handler(pevent, -1, "kvmmmu",
35d79f9f JO	478	"kvm_mmu_prepare_zap_page", kvm_mmu_print_role,
35d79f9f JO	479	NULL);
6d65894b	480
b843e9c3 TSV	481	tep_register_print_function(pevent,
	482	process_is_writable_pte,
	483	TEP_FUNC_ARG_INT,
	484	"is_writable_pte",
	485	TEP_FUNC_ARG_LONG,
	486	TEP_FUNC_ARG_VOID);
35d79f9f JO	487	return 0;
35d79f9f JO	488	}
354a2bd0	489
c32d52b4	490	void TEP_PLUGIN_UNLOADER(struct tep_handle *pevent)
354a2bd0	491	{
b843e9c3 TSV	492	tep_unregister_event_handler(pevent, -1, "kvm", "kvm_exit",
b843e9c3 TSV	493	kvm_exit_handler, NULL);
354a2bd0	494
b843e9c3 TSV	495	tep_unregister_event_handler(pevent, -1, "kvm", "kvm_emulate_insn",
b843e9c3 TSV	496	kvm_emulate_insn_handler, NULL);
354a2bd0	497
b843e9c3 TSV	498	tep_unregister_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit",
b843e9c3 TSV	499	kvm_nested_vmexit_handler, NULL);
ea092aeb	500
b843e9c3 TSV	501	tep_unregister_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit_inject",
b843e9c3 TSV	502	kvm_nested_vmexit_inject_handler, NULL);
ea092aeb	503
b843e9c3 TSV	504	tep_unregister_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_get_page",
b843e9c3 TSV	505	kvm_mmu_get_page_handler, NULL);
354a2bd0	506
b843e9c3 TSV	507	tep_unregister_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_sync_page",
b843e9c3 TSV	508	kvm_mmu_print_role, NULL);
354a2bd0	509
b843e9c3 TSV	510	tep_unregister_event_handler(pevent, -1,
	511	"kvmmmu", "kvm_mmu_unsync_page",
	512	kvm_mmu_print_role, NULL);
354a2bd0	513
b843e9c3 TSV	514	tep_unregister_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_zap_page",
b843e9c3 TSV	515	kvm_mmu_print_role, NULL);
354a2bd0	516
b843e9c3	517	tep_unregister_event_handler(pevent, -1, "kvmmmu",
354a2bd0 NK	518	"kvm_mmu_prepare_zap_page", kvm_mmu_print_role,
	519	NULL);
	520
b843e9c3 TSV	521	tep_unregister_print_function(pevent, process_is_writable_pte,
b843e9c3 TSV	522	"is_writable_pte");
354a2bd0	523	}