OpenE2K
/
linux-headers
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
linux-headers/arch/e2k/include/asm/kvm/trace_kvm.h

1747 lines
44 KiB
C
Raw Blame History

#if !defined(_TRACE_KVM_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_KVM_H
#include <linux/tracepoint.h>
#include <asm/kvm_host.h>
#undef TRACE_SYSTEM
#define TRACE_SYSTEM kvm
/*
* Tracepoint for guest mode entry.
*/
TRACE_EVENT(kvm_entry,
TP_PROTO(unsigned int vcpu_id),
TP_ARGS(vcpu_id),
TP_STRUCT__entry(
__field( unsigned int, vcpu_id )
),
TP_fast_assign(
__entry->vcpu_id = vcpu_id;
),
TP_printk("vcpu %u", __entry->vcpu_id)
);
/*
* Tracepoint for hypercall.
*/
TRACE_EVENT(kvm_hypercall,
TP_PROTO(unsigned long nr, unsigned long a0, unsigned long a1,
unsigned long a2, unsigned long a3),
TP_ARGS(nr, a0, a1, a2, a3),
TP_STRUCT__entry(
__field( unsigned long, nr )
__field( unsigned long, a0 )
__field( unsigned long, a1 )
__field( unsigned long, a2 )
__field( unsigned long, a3 )
),
TP_fast_assign(
__entry->nr = nr;
__entry->a0 = a0;
__entry->a1 = a1;
__entry->a2 = a2;
__entry->a3 = a3;
),
TP_printk("nr 0x%lx a0 0x%lx a1 0x%lx a2 0x%lx a3 0x%lx",
__entry->nr, __entry->a0, __entry->a1, __entry->a2,
__entry->a3)
);
/*
* Tracepoint for PIO.
*/
TRACE_EVENT(kvm_pio,
TP_PROTO(unsigned int rw, unsigned int port, unsigned int size,
unsigned int count),
TP_ARGS(rw, port, size, count),
TP_STRUCT__entry(
__field( unsigned int, rw )
__field( unsigned int, port )
__field( unsigned int, size )
__field( unsigned int, count )
),
TP_fast_assign(
__entry->rw = rw;
__entry->port = port;
__entry->size = size;
__entry->count = count;
),
TP_printk("pio_%s at 0x%x size %d count %d",
__entry->rw ? "write" : "read",
__entry->port, __entry->size, __entry->count)
);
/*
* Tracepoint for cpuid.
*/
TRACE_EVENT(kvm_cpuid,
TP_PROTO(unsigned int function, unsigned long rax, unsigned long rbx,
unsigned long rcx, unsigned long rdx),
TP_ARGS(function, rax, rbx, rcx, rdx),
TP_STRUCT__entry(
__field( unsigned int, function )
__field( unsigned long, rax )
__field( unsigned long, rbx )
__field( unsigned long, rcx )
__field( unsigned long, rdx )
),
TP_fast_assign(
__entry->function = function;
__entry->rax = rax;
__entry->rbx = rbx;
__entry->rcx = rcx;
__entry->rdx = rdx;
),
TP_printk("func %x rax %lx rbx %lx rcx %lx rdx %lx",
__entry->function, __entry->rax,
__entry->rbx, __entry->rcx, __entry->rdx)
);
#define AREG(x) { APIC_##x, "APIC_" #x }
#define kvm_trace_symbol_apic \
AREG(ID), AREG(LVR), AREG(TASKPRI), AREG(ARBPRI), AREG(PROCPRI), \
AREG(EOI), AREG(RRR), AREG(LDR), AREG(DFR), AREG(SPIV), AREG(ISR), \
AREG(TMR), AREG(IRR), AREG(ESR), AREG(ICR), AREG(ICR2), AREG(LVTT), \
AREG(LVTTHMR), AREG(LVTPC), AREG(LVT0), AREG(LVT1), AREG(LVTERR), \
AREG(TMICT), AREG(TMCCT), AREG(TDCR), AREG(SELF_IPI)
/*
* Tracepoint for apic access.
*/
TRACE_EVENT(kvm_apic,
TP_PROTO(unsigned int rw, unsigned int reg, unsigned int val),
TP_ARGS(rw, reg, val),
TP_STRUCT__entry(
__field( unsigned int, rw )
__field( unsigned int, reg )
__field( unsigned int, val )
),
TP_fast_assign(
__entry->rw = rw;
__entry->reg = reg;
__entry->val = val;
),
TP_printk("apic_%s %s = 0x%x",
__entry->rw ? "write" : "read",
__print_symbolic(__entry->reg, kvm_trace_symbol_apic),
__entry->val)
);
#define trace_kvm_apic_read(reg, val) trace_kvm_apic(0, reg, val)
#define trace_kvm_apic_write(reg, val) trace_kvm_apic(1, reg, val)
#define CREG(x) { CEPIC_##x, "CEPIC_" #x }
#define kvm_trace_symbol_cepic \
CREG(CTRL), CREG(ID), CREG(CTRL2), CREG(DAT), CREG(DAT2), \
CREG(EPIC_INT), CREG(EPIC_INT2), CREG(EPIC_INT3), CREG(CPR), \
CREG(ESR), CREG(ESR2), CREG(EOI), CREG(CIR), CREG(GSTBASE_LO), \
CREG(GSTBASE_HI), CREG(GSTID), CREG(PNMIRR), CREG(ICR), \
CREG(ICR2), CREG(TIMER_LVTT), CREG(TIMER_INIT), CREG(TIMER_CUR),\
CREG(TIMER_DIV), CREG(SVR), CREG(PNMIRR_MASK), CREG(VECT_INTA) \
#define kvm_trace_symbol_epic kvm_trace_symbol_cepic
/*
* Tracepoint for 32/64 epic access
*/
TRACE_EVENT(kvm_epic,
TP_PROTO(unsigned int rw, unsigned int dword, unsigned int reg,
unsigned long val),
TP_ARGS(rw, dword, reg, val),
TP_STRUCT__entry(
__field(unsigned int, rw)
__field(unsigned int, dword)
__field(unsigned int, reg)
__field(unsigned long, val)
),
TP_fast_assign(
__entry->rw = rw;
__entry->dword = dword;
__entry->reg = reg;
__entry->val = val;
),
TP_printk("epic_%s%s %s = 0x%lx",
__entry->rw ? "write" : "read",
__entry->dword ? "64" : "32",
__print_symbolic(__entry->reg, kvm_trace_symbol_epic),
__entry->val)
);
#define trace_kvm_epic_read_w(reg, val) trace_kvm_epic(0, 0, reg, val)
#define trace_kvm_epic_write_w(reg, val) trace_kvm_epic(1, 0, reg, val)
#define trace_kvm_epic_read_d(reg, val) trace_kvm_epic(0, 1, reg, val)
#define trace_kvm_epic_write_d(reg, val) trace_kvm_epic(1, 1, reg, val)
/*
* Tracepoint for kvm guest exit:
*/
TRACE_EVENT(kvm_exit,
TP_PROTO(unsigned int exit_reason, unsigned long guest_rip),
TP_ARGS(exit_reason, guest_rip),
TP_STRUCT__entry(
__field( unsigned int, exit_reason )
__field( unsigned long, guest_rip )
),
TP_fast_assign(
__entry->exit_reason = exit_reason;
__entry->guest_rip = guest_rip;
),
TP_printk("reason %d rip 0x%lx",
__entry->exit_reason,
__entry->guest_rip)
);
/*
* Tracepoint for kvm interrupt injection:
*/
TRACE_EVENT(kvm_inj_virq,
TP_PROTO(unsigned int irq),
TP_ARGS(irq),
TP_STRUCT__entry(
__field( unsigned int, irq )
),
TP_fast_assign(
__entry->irq = irq;
),
TP_printk("irq %u", __entry->irq)
);
/*
* Tracepoint for page fault.
*/
TRACE_EVENT(kvm_page_fault,
TP_PROTO(unsigned long fault_address, unsigned int error_code),
TP_ARGS(fault_address, error_code),
TP_STRUCT__entry(
__field( unsigned long, fault_address )
__field( unsigned int, error_code )
),
TP_fast_assign(
__entry->fault_address = fault_address;
__entry->error_code = error_code;
),
TP_printk("address %lx error_code %x",
__entry->fault_address, __entry->error_code)
);
/*
* Tracepoint for guest MSR access.
*/
TRACE_EVENT(kvm_msr,
TP_PROTO(unsigned int rw, unsigned int ecx, unsigned long data),
TP_ARGS(rw, ecx, data),
TP_STRUCT__entry(
__field( unsigned int, rw )
__field( unsigned int, ecx )
__field( unsigned long, data )
),
TP_fast_assign(
__entry->rw = rw;
__entry->ecx = ecx;
__entry->data = data;
),
TP_printk("msr_%s %x = 0x%lx",
__entry->rw ? "write" : "read",
__entry->ecx, __entry->data)
);
#define trace_kvm_msr_read(ecx, data) trace_kvm_msr(0, ecx, data)
#define trace_kvm_msr_write(ecx, data) trace_kvm_msr(1, ecx, data)
/*
* Tracepoint for guest CR access.
*/
TRACE_EVENT(kvm_cr,
TP_PROTO(unsigned int rw, unsigned int cr, unsigned long val),
TP_ARGS(rw, cr, val),
TP_STRUCT__entry(
__field( unsigned int, rw )
__field( unsigned int, cr )
__field( unsigned long, val )
),
TP_fast_assign(
__entry->rw = rw;
__entry->cr = cr;
__entry->val = val;
),
TP_printk("cr_%s %x = 0x%lx",
__entry->rw ? "write" : "read",
__entry->cr, __entry->val)
);
#define trace_kvm_cr_read(cr, val) trace_kvm_cr(0, cr, val)
#define trace_kvm_cr_write(cr, val) trace_kvm_cr(1, cr, val)
TRACE_EVENT(kvm_pic_set_irq,
TP_PROTO(__u8 chip, __u8 pin, __u8 elcr, __u8 imr, bool coalesced),
TP_ARGS(chip, pin, elcr, imr, coalesced),
TP_STRUCT__entry(
__field( __u8, chip )
__field( __u8, pin )
__field( __u8, elcr )
__field( __u8, imr )
__field( bool, coalesced )
),
TP_fast_assign(
__entry->chip = chip;
__entry->pin = pin;
__entry->elcr = elcr;
__entry->imr = imr;
__entry->coalesced = coalesced;
),
TP_printk("chip %u pin %u (%s%s)%s",
__entry->chip, __entry->pin,
(__entry->elcr & (1 << __entry->pin)) ? "level":"edge",
(__entry->imr & (1 << __entry->pin)) ? "|masked":"",
__entry->coalesced ? " (coalesced)" : "")
);
#define kvm_apic_dst_shorthand \
{0x0, "dst"}, \
{0x1, "self"}, \
{0x2, "all"}, \
{0x3, "all-but-self"}
#define kvm_deliver_mode \
{0x0, "Fixed"}, \
{0x1, "LowPrio"}, \
{0x2, "SMI"}, \
{0x3, "Res3"}, \
{0x4, "NMI"}, \
{0x5, "INIT"}, \
{0x6, "SIPI"}, \
{0x7, "ExtINT"}
TRACE_EVENT(kvm_apic_ipi,
TP_PROTO(__u32 icr_low, __u32 dest_id),
TP_ARGS(icr_low, dest_id),
TP_STRUCT__entry(
__field( __u32, icr_low )
__field( __u32, dest_id )
),
TP_fast_assign(
__entry->icr_low = icr_low;
__entry->dest_id = dest_id;
),
TP_printk("dst %x vec %u (%s|%s|%s|%s|%s)",
__entry->dest_id, (u8)__entry->icr_low,
__print_symbolic((__entry->icr_low >> 8 & 0x7),
kvm_deliver_mode),
(__entry->icr_low & (1<<11)) ? "logical" : "physical",
(__entry->icr_low & (1<<14)) ? "assert" : "de-assert",
(__entry->icr_low & (1<<15)) ? "level" : "edge",
__print_symbolic((__entry->icr_low >> 18 & 0x3),
kvm_apic_dst_shorthand))
);
TRACE_EVENT(kvm_apic_accept_irq,
TP_PROTO(__u32 apicid, __u16 dm, __u8 tm, __u8 vec, bool coalesced),
TP_ARGS(apicid, dm, tm, vec, coalesced),
TP_STRUCT__entry(
__field( __u32, apicid )
__field( __u16, dm )
__field( __u8, tm )
__field( __u8, vec )
__field( bool, coalesced )
),
TP_fast_assign(
__entry->apicid = apicid;
__entry->dm = dm;
__entry->tm = tm;
__entry->vec = vec;
__entry->coalesced = coalesced;
),
TP_printk("apicid %x vec %u (%s|%s)%s",
__entry->apicid, __entry->vec,
__print_symbolic((__entry->dm >> 8 & 0x7), kvm_deliver_mode),
__entry->tm ? "level" : "edge",
__entry->coalesced ? " (coalesced)" : "")
);
TRACE_EVENT(kvm_epic_ipi,
TP_PROTO(__u32 dest_id, __u32 vector),
TP_ARGS(dest_id, vector),
TP_STRUCT__entry(
__field(__u32, dest_id)
__field(__u32, vector)
),
TP_fast_assign(
__entry->dest_id = dest_id;
__entry->vector = vector;
),
TP_printk("dst %u vec %u",
__entry->dest_id, __entry->vector)
);
#define kvm_epic_deliver_mode \
{0x0, "fixed(0)"}, \
{0x1, "fixed(1)"}, \
{0x2, "smi"}, \
{0x3, "nm_special"}, \
{0x4, "nmi"}, \
{0x5, "init"}, \
{0x6, "startup"}, \
{0x7, "reserved"}
TRACE_EVENT(kvm_ioepic_set_irq,
TP_PROTO(__u32 dst, __u32 vector, __u32 dlvm, bool level, bool mask,
int pin, int pin_status, bool coalesced),
TP_ARGS(dst, vector, dlvm, level, mask, pin, pin_status, coalesced),
TP_STRUCT__entry(
__field( __u32, dst )
__field( __u32, vector )
__field( __u32, dlvm )
__field( bool, level )
__field( bool, mask )
__field( int, pin )
__field( int, pin_status )
__field( bool, coalesced )
),
TP_fast_assign(
__entry->dst = dst;
__entry->vector = vector;
__entry->dlvm = dlvm;
__entry->level = level;
__entry->mask = mask;
__entry->pin = pin;
__entry->pin = pin_status;
__entry->coalesced = coalesced;
),
TP_printk("pin %u %s. dst %d vec 0x%x (%s|%s%s)%s",
__entry->pin, __entry->pin_status ? "set" : "unset",
__entry->dst, __entry->vector,
__print_symbolic(__entry->dlvm, kvm_epic_deliver_mode),
__entry->level ? "level" : "edge",
__entry->mask ? "|masked" : "",
__entry->coalesced ? " (coalesced)" : "")
);
TRACE_EVENT(kvm_epic_accept_irq,
TP_PROTO(__u32 epicid, __u16 dm, __u8 tm, __u32 vec,
bool coalesced),
TP_ARGS(epicid, dm, tm, vec, coalesced),
TP_STRUCT__entry(
__field(__u32, epicid)
__field(__u16, dm)
__field(__u8, tm)
__field(__u32, vec)
__field(bool, coalesced)
),
TP_fast_assign(
__entry->epicid = epicid;
__entry->dm = dm;
__entry->tm = tm;
__entry->vec = vec;
__entry->coalesced = coalesced;
),
TP_printk("epicid %x vec %u (%s|%s)%s",
__entry->epicid, __entry->vec,
__print_symbolic(__entry->dm, kvm_epic_deliver_mode),
__entry->tm ? "level" : "edge",
__entry->coalesced ? " (coalesced)" : "")
);
TRACE_EVENT(kvm_epic_eoi,
TP_PROTO(__u32 vector),
TP_ARGS(vector),
TP_STRUCT__entry(
__field(__u32, vector)
),
TP_fast_assign(
__entry->vector = vector;
),
TP_printk("vector %u", __entry->vector)
);
/*
* Tracepoint for nested VMRUN
*/
TRACE_EVENT(kvm_nested_vmrun,
TP_PROTO(__u64 rip, __u64 vmcb, __u64 nested_rip, __u32 int_ctl,
__u32 event_inj, bool npt),
TP_ARGS(rip, vmcb, nested_rip, int_ctl, event_inj, npt),
TP_STRUCT__entry(
__field( __u64, rip )
__field( __u64, vmcb )
__field( __u64, nested_rip )
__field( __u32, int_ctl )
__field( __u32, event_inj )
__field( bool, npt )
),
TP_fast_assign(
__entry->rip = rip;
__entry->vmcb = vmcb;
__entry->nested_rip = nested_rip;
__entry->int_ctl = int_ctl;
__entry->event_inj = event_inj;
__entry->npt = npt;
),
TP_printk("rip: 0x%016llx vmcb: 0x%016llx nrip: 0x%016llx "
"int_ctl: 0x%08x event_inj: 0x%08x npt: %s\n",
__entry->rip, __entry->vmcb, __entry->nested_rip,
__entry->int_ctl, __entry->event_inj,
__entry->npt ? "on" : "off")
);
/*
* Tracepoint for #VMEXIT while nested
*/
TRACE_EVENT(kvm_nested_vmexit,
TP_PROTO(__u64 rip, __u32 exit_code,
__u64 exit_info1, __u64 exit_info2,
__u32 exit_int_info, __u32 exit_int_info_err),
TP_ARGS(rip, exit_code, exit_info1, exit_info2,
exit_int_info, exit_int_info_err),
TP_STRUCT__entry(
__field( __u64, rip )
__field( __u32, exit_code )
__field( __u64, exit_info1 )
__field( __u64, exit_info2 )
__field( __u32, exit_int_info )
__field( __u32, exit_int_info_err )
),
TP_fast_assign(
__entry->rip = rip;
__entry->exit_code = exit_code;
__entry->exit_info1 = exit_info1;
__entry->exit_info2 = exit_info2;
__entry->exit_int_info = exit_int_info;
__entry->exit_int_info_err = exit_int_info_err;
),
TP_printk("rip: 0x%016llx reason: %d ext_inf1: 0x%016llx "
"ext_inf2: 0x%016llx ext_int: 0x%08x ext_int_err: 0x%08x\n",
__entry->rip,
__entry->exit_code,
__entry->exit_info1, __entry->exit_info2,
__entry->exit_int_info, __entry->exit_int_info_err)
);
/*
* Tracepoint for #VMEXIT reinjected to the guest
*/
TRACE_EVENT(kvm_nested_vmexit_inject,
TP_PROTO(__u32 exit_code,
__u64 exit_info1, __u64 exit_info2,
__u32 exit_int_info, __u32 exit_int_info_err),
TP_ARGS(exit_code, exit_info1, exit_info2,
exit_int_info, exit_int_info_err),
TP_STRUCT__entry(
__field( __u32, exit_code )
__field( __u64, exit_info1 )
__field( __u64, exit_info2 )
__field( __u32, exit_int_info )
__field( __u32, exit_int_info_err )
),
TP_fast_assign(
__entry->exit_code = exit_code;
__entry->exit_info1 = exit_info1;
__entry->exit_info2 = exit_info2;
__entry->exit_int_info = exit_int_info;
__entry->exit_int_info_err = exit_int_info_err;
),
TP_printk("reason: %d ext_inf1: 0x%016llx "
"ext_inf2: 0x%016llx ext_int: 0x%08x ext_int_err: 0x%08x\n",
__entry->exit_code,
__entry->exit_info1, __entry->exit_info2,
__entry->exit_int_info, __entry->exit_int_info_err)
);
/*
* Tracepoint for nested #vmexit because of interrupt pending
*/
TRACE_EVENT(kvm_nested_intr_vmexit,
TP_PROTO(__u64 rip),
TP_ARGS(rip),
TP_STRUCT__entry(
__field( __u64, rip )
),
TP_fast_assign(
__entry->rip = rip
),
TP_printk("rip: 0x%016llx\n", __entry->rip)
);
/*
* Tracepoint for nested #vmexit because of interrupt pending
*/
TRACE_EVENT(kvm_invlpga,
TP_PROTO(__u64 rip, int asid, u64 address),
TP_ARGS(rip, asid, address),
TP_STRUCT__entry(
__field( __u64, rip )
__field( int, asid )
__field( __u64, address )
),
TP_fast_assign(
__entry->rip = rip;
__entry->asid = asid;
__entry->address = address;
),
TP_printk("rip: 0x%016llx asid: %d address: 0x%016llx\n",
__entry->rip, __entry->asid, __entry->address)
);
/*
* Tracepoint for nested #vmexit because of interrupt pending
*/
TRACE_EVENT(kvm_skinit,
TP_PROTO(__u64 rip, __u32 slb),
TP_ARGS(rip, slb),
TP_STRUCT__entry(
__field( __u64, rip )
__field( __u32, slb )
),
TP_fast_assign(
__entry->rip = rip;
__entry->slb = slb;
),
TP_printk("rip: 0x%016llx slb: 0x%08x\n",
__entry->rip, __entry->slb)
);
#define TIRHI_EXC_MASK 0x00000fffffffffffULL
#define TIRHI_ALS_MASK 0x0003f00000000000ULL
#define TIRHI_ALS_SHIFT 44ULL
#define TIRHI_MOVA_MASK 0x00f0000000000000ULL
#define TIRHI_MOVA0_MASK 0x0010000000000000ULL
#define TIRHI_MOVA1_MASK 0x0020000000000000ULL
#define TIRHI_MOVA2_MASK 0x0040000000000000ULL
#define TIRHI_MOVA3_MASK 0x0080000000000000ULL
#define E2K_TRACE_PRINT_TIR_HI(entry) \
(entry & (TIRHI_EXC_MASK | TIRHI_MOVA_MASK)) ? \
__print_flags(entry & (TIRHI_EXC_MASK | TIRHI_MOVA_MASK), "|", \
{ TIRHI_MOVA0_MASK, "mova0" }, \
{ TIRHI_MOVA1_MASK, "mova1" }, \
{ TIRHI_MOVA2_MASK, "mova2" }, \
{ TIRHI_MOVA3_MASK, "mova3" }, \
{ exc_illegal_opcode_mask, "illegal_opcode" }, \
{ exc_priv_action_mask, "priv_action" }, \
{ exc_fp_disabled_mask, "fp_disabled" }, \
{ exc_fp_stack_u_mask, "fp_stack_u" }, \
{ exc_d_interrupt_mask, "d_interrupt" }, \
{ exc_diag_ct_cond_mask, "diag_ct_cond" }, \
{ exc_diag_instr_addr_mask, "diag_instr_addr" }, \
{ exc_illegal_instr_addr_mask, "illegal_instr_addr" }, \
{ exc_instr_debug_mask, "instr_debug" }, \
{ exc_window_bounds_mask, "window_bounds" }, \
{ exc_user_stack_bounds_mask, "user_stack_bounds" }, \
{ exc_proc_stack_bounds_mask, "proc_stack_bounds" }, \
{ exc_chain_stack_bounds_mask, "chain_stack_bounds" }, \
{ exc_fp_stack_o_mask, "fp_stack_o" }, \
{ exc_diag_cond_mask, "diag_cond" }, \
{ exc_diag_operand_mask, "diag_operand" }, \
{ exc_illegal_operand_mask, "illegal_operand" }, \
{ exc_array_bounds_mask, "array_bounds" }, \
{ exc_access_rights_mask, "access_rights" }, \
{ exc_addr_not_aligned_mask, "addr_not_aligned" }, \
{ exc_instr_page_miss_mask, "instr_page_miss" }, \
{ exc_instr_page_prot_mask, "instr_page_prot" }, \
{ exc_ainstr_page_miss_mask, "ainstr_page_miss" }, \
{ exc_ainstr_page_prot_mask, "ainstr_page_prot" }, \
{ exc_last_wish_mask, "last_wish" }, \
{ exc_base_not_aligned_mask, "base_not_aligned" }, \
{ exc_software_trap_mask, "software_trap" }, \
{ exc_data_debug_mask, "data_debug" }, \
{ exc_data_page_mask, "data_page" }, \
{ exc_recovery_point_mask, "recovery_point" }, \
{ exc_interrupt_mask, "interrupt" }, \
{ exc_nm_interrupt_mask, "nm_interrupt" }, \
{ exc_div_mask, "div" }, \
{ exc_fp_mask, "fp" }, \
{ exc_mem_lock_mask, "mem_lock" }, \
{ exc_mem_lock_as_mask, "mem_lock_as" }, \
{ exc_mem_error_out_cpu_mask, "mem_error_out_cpu" }, \
{ exc_mem_error_MAU_mask, "mem_error_MAU" }, \
{ exc_mem_error_L2_mask, "mem_error_L2" }, \
{ exc_mem_error_L1_35_mask, "mem_error_L1_35" }, \
{ exc_mem_error_L1_02_mask, "mem_error_L1_02" }, \
{ exc_mem_error_ICACHE_mask, "mem_error_ICACHE" } \
) : "(none)"
TRACE_EVENT(
intc_tir,
TP_PROTO(u64 tir_lo, u64 tir_hi),
TP_ARGS(tir_lo, tir_hi),
TP_STRUCT__entry(
__field( u64, tir_lo )
__field( u64, tir_hi )
),
TP_fast_assign(
__entry->tir_lo = tir_lo;
__entry->tir_hi = tir_hi;
),
TP_printk("TIR%lld: ip 0x%llx, als 0x%llx\n"
" exceptions: %s"
,
__entry->tir_hi >> 56,
__entry->tir_lo & E2K_VA_MASK,
(__entry->tir_hi & TIRHI_ALS_MASK) >> TIRHI_ALS_SHIFT,
E2K_TRACE_PRINT_TIR_HI(__entry->tir_hi)
)
);
TRACE_EVENT(
intc_ctprs,
TP_PROTO(u64 ctpr1, u64 ctpr1_hi, u64 ctpr2, u64 ctpr2_hi, u64 ctpr3,
u64 ctpr3_hi),
TP_ARGS(ctpr1, ctpr1_hi, ctpr2, ctpr2_hi, ctpr3, ctpr3_hi),
TP_STRUCT__entry(
__field( u64, ctpr1 )
__field( u64, ctpr1_hi )
__field( u64, ctpr2 )
__field( u64, ctpr2_hi )
__field( u64, ctpr3 )
__field( u64, ctpr3_hi )
),
TP_fast_assign(
__entry->ctpr1 = ctpr1;
__entry->ctpr1_hi = ctpr1_hi;
__entry->ctpr2 = ctpr2;
__entry->ctpr2_hi = ctpr2_hi;
__entry->ctpr3 = ctpr3;
__entry->ctpr3_hi = ctpr3_hi;
),
TP_printk("\n"
"ctpr1 0x%llx, ctpr1_hi 0x%llx\n"
"ctpr2 0x%llx, ctpr2_hi 0x%llx\n"
"ctpr3 0x%llx, ctpr3_hi 0x%llx",
__entry->ctpr1, __entry->ctpr1_hi,
__entry->ctpr2, __entry->ctpr2_hi,
__entry->ctpr3, __entry->ctpr3_hi)
);
TRACE_EVENT(
intc_aau,
TP_PROTO(const e2k_aau_t *aau_ctxt, e2k_aasr_t aasr,
u64 lsr, u64 lsr1, u64 ilcr, u64 ilcr1),
TP_ARGS(aau_ctxt, aasr, lsr, lsr1, ilcr, ilcr1),
TP_STRUCT__entry(
__field( u32, aasr )
__field( u64, lsr )
__field( u64, lsr1 )
__field( u64, ilcr )
__field( u64, ilcr1 )
__field( u32, aafstr )
__field( u64, aaldm )
__field( u64, aaldv )
/* Synchronous part */
__array( u64, aastis, AASTIS_REGS_NUM);
__field( u32, aasti_tags );
/* Asynchronous part */
__array( u64, aainds, AAINDS_REGS_NUM);
__field( u32, aaind_tags );
__array( u64, aaincrs, AAINCRS_REGS_NUM);
__field( u32, aaincr_tags );
__array( u64, aads, AADS_REGS_NUM * 2);
/* Since iset v6 */
__array( u64, aaldi, AALDIS_REGS_NUM);
),
TP_fast_assign(
int i;
__entry->aasr = AW(aasr);
__entry->lsr = lsr;
__entry->lsr1 = lsr1;
__entry->ilcr = ilcr;
__entry->ilcr1 = ilcr1;
__entry->aafstr = aau_ctxt->aafstr;
__entry->aaldm = AW(aau_ctxt->aaldm);
__entry->aaldv = AW(aau_ctxt->aaldv);
for (i = 0; i < AADS_REGS_NUM; i++) {
__entry->aads[2 * i] = AW(aau_ctxt->aads[i]).lo;
__entry->aads[2 * i + 1] = AW(aau_ctxt->aads[i]).hi;
}
for (i = 0; i < AAINCRS_REGS_NUM; i++)
__entry->aaincrs[i] = aau_ctxt->aaincrs[i];
__entry->aaincr_tags = aau_ctxt->aaincr_tags;
for (i = 0; i < AAINDS_REGS_NUM; i++)
__entry->aainds[i] = aau_ctxt->aainds[i];
__entry->aaind_tags = aau_ctxt->aaind_tags;
for (i = 0; i < AASTIS_REGS_NUM; i++)
__entry->aastis[i] = aau_ctxt->aastis[i];
__entry->aasti_tags = aau_ctxt->aasti_tags;
for (i = 0; i < AALDIS_REGS_NUM; i++)
__entry->aaldi[i] = aau_ctxt->aaldi[i];
),
TP_printk("\n"
"aasr 0x%x, lsr 0x%llx, lsr1 0x%llx, ilcr 0x%llx, ilcr1 0x%llx\n"
"aaldv 0x%llx, aaldm = 0x%llx\n"
"aads lo/hi 0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx\n"
"0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx\n"
"0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx\n"
"0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx\n"
"0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx\n"
"0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx\n"
"0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx\n"
"0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx 0x%llx/0x%llx\n"
"aaincrs 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n"
"aaincr_tags 0x%x\n"
"aainds 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n"
"0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n"
"aaind_tags 0x%x\n"
"aastis 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n"
"0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n"
"aasti_tags 0x%x\n"
"aaldis 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n"
"0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n"
"0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n"
"0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx",
__entry->aasr, __entry->lsr, __entry->lsr1,
__entry->ilcr, __entry->ilcr1,
__entry->aaldv, __entry->aaldm,
__entry->aads[0], __entry->aads[1],
__entry->aads[2], __entry->aads[3],
__entry->aads[4], __entry->aads[5],
__entry->aads[6], __entry->aads[7],
__entry->aads[8], __entry->aads[9],
__entry->aads[10], __entry->aads[11],
__entry->aads[12], __entry->aads[13],
__entry->aads[14], __entry->aads[15],
__entry->aads[16], __entry->aads[17],
__entry->aads[18], __entry->aads[19],
__entry->aads[20], __entry->aads[21],
__entry->aads[22], __entry->aads[23],
__entry->aads[24], __entry->aads[25],
__entry->aads[26], __entry->aads[27],
__entry->aads[28], __entry->aads[29],
__entry->aads[30], __entry->aads[31],
__entry->aads[32], __entry->aads[33],
__entry->aads[34], __entry->aads[35],
__entry->aads[36], __entry->aads[37],
__entry->aads[38], __entry->aads[39],
__entry->aads[40], __entry->aads[41],
__entry->aads[42], __entry->aads[43],
__entry->aads[44], __entry->aads[45],
__entry->aads[46], __entry->aads[47],
__entry->aads[48], __entry->aads[49],
__entry->aads[50], __entry->aads[51],
__entry->aads[52], __entry->aads[53],
__entry->aads[54], __entry->aads[55],
__entry->aads[56], __entry->aads[57],
__entry->aads[58], __entry->aads[59],
__entry->aads[60], __entry->aads[61],
__entry->aads[62], __entry->aads[63],
__entry->aaincrs[0], __entry->aaincrs[1],
__entry->aaincrs[2], __entry->aaincrs[3],
__entry->aaincrs[4], __entry->aaincrs[5],
__entry->aaincrs[6], __entry->aaincrs[7],
__entry->aaincr_tags,
__entry->aainds[0], __entry->aainds[1],
__entry->aainds[2], __entry->aainds[3],
__entry->aainds[4], __entry->aainds[5],
__entry->aainds[6], __entry->aainds[7],
__entry->aainds[8], __entry->aainds[9],
__entry->aainds[10], __entry->aainds[11],
__entry->aainds[12], __entry->aainds[13],
__entry->aainds[14], __entry->aainds[15],
__entry->aaind_tags,
__entry->aastis[0], __entry->aastis[1],
__entry->aastis[2], __entry->aastis[3],
__entry->aastis[4], __entry->aastis[5],
__entry->aastis[6], __entry->aastis[7],
__entry->aastis[8], __entry->aastis[9],
__entry->aastis[10], __entry->aastis[11],
__entry->aastis[12], __entry->aastis[13],
__entry->aastis[14], __entry->aastis[15],
__entry->aasti_tags,
__entry->aaldi[0], __entry->aaldi[1],
__entry->aaldi[2], __entry->aaldi[3],
__entry->aaldi[4], __entry->aaldi[5],
__entry->aaldi[6], __entry->aaldi[7],
__entry->aaldi[8], __entry->aaldi[9],
__entry->aaldi[10], __entry->aaldi[11],
__entry->aaldi[12], __entry->aaldi[13],
__entry->aaldi[14], __entry->aaldi[15],
__entry->aaldi[16], __entry->aaldi[17],
__entry->aaldi[18], __entry->aaldi[19],
__entry->aaldi[20], __entry->aaldi[21],
__entry->aaldi[22], __entry->aaldi[23],
__entry->aaldi[24], __entry->aaldi[25],
__entry->aaldi[26], __entry->aaldi[27],
__entry->aaldi[28], __entry->aaldi[29],
__entry->aaldi[30], __entry->aaldi[31])
);
TRACE_EVENT(kvm_pid,
TP_PROTO(kvm_e2k_from_t from, unsigned long vmid, unsigned long vcpu_id, unsigned long pid),
TP_ARGS(from, vmid, vcpu_id, pid),
TP_STRUCT__entry(
__field( kvm_e2k_from_t, from )
__field( u64, vmid )
__field( u64, vcpu_id )
__field( u64, pid )
),
TP_fast_assign(
__entry->from = from;
__entry->vmid = vmid;
__entry->vcpu_id = vcpu_id;
__entry->pid = pid;
),
TP_printk("%s: vmid %llu vcpu %llu mmu pid 0x%llx",
__print_symbolic(__entry->from,
{ FROM_GENERIC_HYPERCALL, "generic hcall" },
{ FROM_LIGHT_HYPERCALL, "light hcall" },
{ FROM_PV_INTERCEPT, "pv intc" },
{ FROM_HV_INTERCEPT, "hv intc" },
{ FROM_VCPU_LOAD, "vcpu load" },
{ FROM_VCPU_PUT, "vcpu put" }),
__entry->vmid, __entry->vcpu_id, __entry->pid)
);
TRACE_EVENT(
generic_hcall,
TP_PROTO(unsigned long hcall_num, unsigned long arg1,
unsigned long arg2, unsigned long arg3,
unsigned long arg4, unsigned long arg5,
unsigned long arg6, unsigned long gsbr),
TP_ARGS(hcall_num, arg1, arg2, arg3, arg4, arg5, arg6, gsbr),
TP_STRUCT__entry(
__field( u64, hcall_num )
__field( u64, arg1 )
__field( u64, arg2 )
__field( u64, arg3 )
__field( u64, arg4 )
__field( u64, arg5 )
__field( u64, arg6 )
__field( u64, gsbr )
),
TP_fast_assign(
__entry->hcall_num = hcall_num;
__entry->arg1 = arg1;
__entry->arg2 = arg2;
__entry->arg3 = arg3;
__entry->arg4 = arg4;
__entry->arg5 = arg5;
__entry->arg6 = arg6;
__entry->gsbr = gsbr;
),
TP_printk("nr %llu\n"
"Args: 0x%llx, 0x%llx, 0x%llx, 0x%llx, 0x%llx, 0x%llx; gsbr: 0x%llx"
,
__entry->hcall_num,
__entry->arg1,
__entry->arg2,
__entry->arg3,
__entry->arg4,
__entry->arg5,
__entry->arg6,
__entry->gsbr)
);
TRACE_EVENT(
light_hcall,
TP_PROTO(unsigned long hcall_num, unsigned long arg1,
unsigned long arg2, unsigned long arg3,
unsigned long arg4, unsigned long arg5,
unsigned long arg6),
TP_ARGS(hcall_num, arg1, arg2, arg3, arg4, arg5, arg6),
TP_STRUCT__entry(
__field( u64, hcall_num )
__field( u64, arg1 )
__field( u64, arg2 )
__field( u64, arg3 )
__field( u64, arg4 )
__field( u64, arg5 )
__field( u64, arg6 )
),
TP_fast_assign(
__entry->hcall_num = hcall_num;
__entry->arg1 = arg1;
__entry->arg2 = arg2;
__entry->arg3 = arg3;
__entry->arg4 = arg4;
__entry->arg5 = arg5;
__entry->arg6 = arg6;
),
TP_printk("nr %llu\n"
"Args: 0x%llx, 0x%llx, 0x%llx, 0x%llx, 0x%llx, 0x%llx"
,
__entry->hcall_num,
__entry->arg1,
__entry->arg2,
__entry->arg3,
__entry->arg4,
__entry->arg5,
__entry->arg6)
);
TRACE_EVENT(
generic_hcall_exit,
TP_PROTO(unsigned long ret),
TP_ARGS(ret),
TP_STRUCT__entry(
__field( u64, ret )
),
TP_fast_assign(
__entry->ret = ret;
),
TP_printk("Generic hypercall exit: %llu", __entry->ret)
);
TRACE_EVENT(
light_hcall_exit,
TP_PROTO(unsigned long ret),
TP_ARGS(ret),
TP_STRUCT__entry(
__field( u64, ret )
),
TP_fast_assign(
__entry->ret = ret;
),
TP_printk("Light hypercall exit: %llu", __entry->ret)
);
TRACE_EVENT(
guest_switch_to,
TP_PROTO(struct kvm_vcpu *vcpu, int gpid_from, int gmmid_from,
int gpid_to, int gmmid_to, struct sw_regs *next_gsw),
TP_ARGS(vcpu, gpid_from, gmmid_from, gpid_to, gmmid_to, next_gsw),
TP_STRUCT__entry(
__field( int, vcpu_id )
__field( int, gpid_from )
__field( int, gmmid_from )
__field( int, gpid_to )
__field( int, gmmid_to )
__field( e2k_addr_t, top )
__field_struct( e2k_usd_lo_t, usd_lo )
__field_struct( e2k_usd_hi_t, usd_hi )
__field_struct( e2k_psp_lo_t, psp_lo )
__field_struct( e2k_psp_hi_t, psp_hi )
__field_struct( e2k_pcsp_lo_t, pcsp_lo )
__field_struct( e2k_pcsp_hi_t, pcsp_hi )
__field( pgprotval_t, u_pptb )
__field( gva_t, u_vptb )
__field( hpa_t, root )
__field( u64, mmu_pptb )
__field( u64, mmu_pid )
__field( u64, ctxt_pid )
),
TP_fast_assign(
__entry->vcpu_id = vcpu->vcpu_id;
__entry->gpid_from = gpid_from;
__entry->gmmid_from = gmmid_from;
__entry->gpid_to = gpid_to;
__entry->gmmid_to = gmmid_to;
__entry->top = next_gsw->top;
__entry->usd_lo = next_gsw->usd_lo;
__entry->usd_hi = next_gsw->usd_hi;
__entry->psp_lo = next_gsw->psp_lo;
__entry->psp_hi = next_gsw->psp_hi;
__entry->pcsp_lo = next_gsw->pcsp_lo;
__entry->pcsp_hi = next_gsw->pcsp_hi;
__entry->u_pptb = vcpu->arch.mmu.get_vcpu_u_pptb(vcpu);
__entry->u_vptb = vcpu->arch.mmu.get_vcpu_sh_u_vptb(vcpu);
__entry->root = kvm_get_space_type_spt_u_root(vcpu);
__entry->mmu_pptb = get_mmu_u_pptb_reg();
__entry->mmu_pid = get_mmu_pid_reg();
__entry->ctxt_pid = kvm_get_guest_mmu_pid(vcpu);
),
TP_printk("VCPU #%d: switch from gpid #%d gmm #%d to gpid #%d gmm #%d\n"
" USD: base 0x%llx size 0x%x top at 0x%lx\n"
" PSP: base 0x%llx ind 0x%x size 0x%x\n"
" PCSP: base 0x%llx ind 0x%x size 0x%x\n"
" MMU: u_pptb 0x%lx u_vptb 0x%lx sh_pptb 0x%llx\n"
" mmu_upptb 0x%llx mmu_pid 0x%llx ctxt pid 0x%llx",
__entry->vcpu_id,
__entry->gpid_from, __entry->gmmid_from,
__entry->gpid_to, __entry->gmmid_to,
__entry->usd_lo.USD_lo_base,
__entry->usd_hi.USD_hi_size,
__entry->top,
__entry->psp_lo.PSP_lo_base,
__entry->psp_hi.PSP_hi_ind,
__entry->psp_hi.PSP_hi_size,
__entry->pcsp_lo.PCSP_lo_base,
__entry->pcsp_hi.PCSP_hi_ind,
__entry->pcsp_hi.PCSP_hi_size,
__entry->u_pptb, __entry->u_vptb, __entry->root,
__entry->mmu_pptb, __entry->mmu_pid, __entry->ctxt_pid
)
);
TRACE_EVENT(
vcpu_put,
TP_PROTO(int vcpu, int cpu),
TP_ARGS(vcpu, cpu),
TP_STRUCT__entry(
__field( int, vcpu )
__field( int, cpu )
),
TP_fast_assign(
__entry->vcpu = vcpu;
__entry->cpu = cpu;
),
TP_printk("vcpu %d, cpu %d", __entry->vcpu, __entry->cpu)
);
TRACE_EVENT(
vcpu_load,
TP_PROTO(int vcpu, int last_cpu, int cpu),
TP_ARGS(vcpu, last_cpu, cpu),
TP_STRUCT__entry(
__field( int, vcpu )
__field( int, last_cpu )
__field( int, cpu )
),
TP_fast_assign(
__entry->vcpu = vcpu;
__entry->last_cpu = last_cpu;
__entry->cpu = cpu;
),
TP_printk("vcpu %d, cpu %d, last_cpu %d", __entry->vcpu, __entry->cpu,
__entry->last_cpu)
);
TRACE_EVENT(
kvm_handle_rmap_range,
TP_PROTO(u64 hva_start, u64 hva_end, u64 gpa_start, u64 gpa_end,
void *handler),
TP_ARGS(hva_start, hva_end, gpa_start, gpa_end, handler),
TP_STRUCT__entry(
__field( u64, hva_start )
__field( u64, hva_end )
__field( u64, gpa_start )
__field( u64, gpa_end )
__field( void *, handler )
),
TP_fast_assign(
__entry->hva_start = hva_start;
__entry->hva_end = hva_end;
__entry->gpa_start = gpa_start;
__entry->gpa_end = gpa_end;
__entry->handler = handler;
),
TP_printk("HVA 0x%llx - 0x%llx; GPA 0x%llx - 0x%llx; handler 0x%px",
__entry->hva_start, __entry->hva_end,
__entry->gpa_start, __entry->gpa_end,
__entry->handler)
);
TRACE_EVENT(
rmap_add_sp_entry,
TP_PROTO(struct kvm_mmu_page *sp, gfn_t gfn, pgprot_t *sptep,
struct kvm_rmap_head *rmap_head),
TP_ARGS(sp, gfn, sptep, rmap_head),
TP_STRUCT__entry(
__field(struct kvm_mmu_page *, sp )
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(gfn_t, gfn )
__field(int, level )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sp = sp;
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->gfn = gfn;
__entry->level = sp->role.level;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : add sp %px gfn 0x%llx level %d "
"spte %px : 0x%lx\n",
__entry->rmap_head, __entry->sp, __entry->gfn, __entry->level,
__entry->sptep, __entry->spte)
);
TRACE_EVENT(
rmap_add_parent_pte,
TP_PROTO(struct kvm_mmu_page *sp, pgprot_t *sptep,
struct kvm_rmap_head *rmap_head),
TP_ARGS(sp, sptep, rmap_head),
TP_STRUCT__entry(
__field(struct kvm_mmu_page *, sp )
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(gfn_t, gfn )
__field(int, level )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sp = sp;
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->gfn = sp->gfn;
__entry->level = sp->role.level;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : add sp %px gfn 0x%llx level %d "
"parent spte %px : 0x%lx\n",
__entry->rmap_head, __entry->sp, __entry->gfn, __entry->level,
__entry->sptep, __entry->spte)
);
TRACE_EVENT(
rmap_remove_sp_entry,
TP_PROTO(struct kvm_mmu_page *sp, gfn_t gfn, pgprot_t *sptep,
struct kvm_rmap_head *rmap_head),
TP_ARGS(sp, gfn, sptep, rmap_head),
TP_STRUCT__entry(
__field(struct kvm_mmu_page *, sp )
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(gfn_t, gfn )
__field(int, level )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sp = sp;
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->gfn = gfn;
__entry->level = sp->role.level;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : remove sp %px gfn 0x%llx level %d "
"spte %px : 0x%lx\n",
__entry->rmap_head, __entry->sp, __entry->gfn, __entry->level,
__entry->sptep, __entry->spte)
);
TRACE_EVENT(
rmap_remove_parent_pte,
TP_PROTO(struct kvm_mmu_page *sp, pgprot_t *sptep,
struct kvm_rmap_head *rmap_head),
TP_ARGS(sp, sptep, rmap_head),
TP_STRUCT__entry(
__field(struct kvm_mmu_page *, sp )
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(gfn_t, gfn )
__field(int, level )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sp = sp;
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->gfn = sp->gfn;
__entry->level = sp->role.level;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : remove sp %px gfn 0x%llx level %d "
"parent spte %px : 0x%lx\n",
__entry->rmap_head, __entry->sp, __entry->gfn, __entry->level,
__entry->sptep, __entry->spte)
);
TRACE_EVENT(
rmap_add_0_1_spte,
TP_PROTO(struct kvm_rmap_head *rmap_head, pgprot_t *sptep),
TP_ARGS(rmap_head, sptep),
TP_STRUCT__entry(
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(unsigned long, val )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->val = rmap_head->val;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : add 0->1 spte %px : 0x%lx head val 0x%lx\n",
__entry->rmap_head, __entry->sptep, __entry->spte, __entry->val)
);
TRACE_EVENT(
rmap_add_1_many_spte,
TP_PROTO(struct kvm_rmap_head *rmap_head, struct pte_list_desc *desc,
pgprot_t *sptep),
TP_ARGS(rmap_head, desc, sptep),
TP_STRUCT__entry(
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(struct pte_list_desc *, desc )
__field(unsigned long, val )
__field(pgprot_t *, desc0 )
__field(pgprot_t *, desc1 )
__field(pgprotval_t, spte1 )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->desc = desc;
__entry->desc0 = desc->sptes[0];
__entry->desc1 = desc->sptes[1];
__entry->spte1 = pgprot_val(*(desc->sptes[1]));
__entry->val = rmap_head->val;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : add 1->many spte %px : 0x%lx head val 0x%lx "
"desc %px\n"
" desc[0] : val %px\n"
" desc[1] : spte %px : 0x%lx\n",
__entry->rmap_head, __entry->sptep, __entry->spte, __entry->val,
__entry->desc, __entry->desc0, __entry->desc1, __entry->spte1)
);
TRACE_EVENT(
rmap_add_new_desc,
TP_PROTO(struct kvm_rmap_head *rmap_head, struct pte_list_desc *desc),
TP_ARGS(rmap_head, desc),
TP_STRUCT__entry(
__field(struct pte_list_desc *, desc )
__field(unsigned long, val )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->desc = desc;
__entry->val = rmap_head->val;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : add many->many new desc %px head val 0x%lx\n",
__entry->rmap_head, __entry->desc, __entry->val)
);
TRACE_EVENT(
rmap_add_many_many_spte,
TP_PROTO(struct kvm_rmap_head *rmap_head, struct pte_list_desc *desc,
pgprot_t *sptep, int index),
TP_ARGS(rmap_head, desc, sptep, index),
TP_STRUCT__entry(
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(struct pte_list_desc *, desc )
__field(unsigned long, val )
__field(int, index )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->desc = desc;
__entry->index = index;
__entry->val = rmap_head->val;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : add many->many val 0x%lx\n"
" adde to desc %px[%04x] : spte %px : 0x%lx\n",
__entry->rmap_head, __entry->val, __entry->desc,
__entry->index, __entry->sptep, __entry->spte)
);
TRACE_EVENT(
rmap_remove_1_0_spte,
TP_PROTO(struct kvm_rmap_head *rmap_head, pgprot_t *sptep),
TP_ARGS(rmap_head, sptep),
TP_STRUCT__entry(
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(pgprot_t *, rmap_sptep )
__field(pgprotval_t, rmap_spte )
__field(unsigned long, val )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->rmap_sptep = (pgprot_t *)rmap_head->val;
__entry->rmap_spte = pgprot_val(*(pgprot_t *)rmap_head->val);
__entry->val = 0;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : remove 1->0 head val 0x%lx\n"
" rmap spte : %px : 0x%lx\n"
" to remove : %px : 0x%lx\n",
__entry->rmap_head, __entry->val,
__entry->rmap_sptep, __entry->rmap_spte,
__entry->sptep, __entry->spte)
);
TRACE_EVENT(
rmap_move_desc,
TP_PROTO(struct kvm_rmap_head *rmap_head, struct pte_list_desc *desc,
int index_to, int index_from),
TP_ARGS(rmap_head, desc, index_to, index_from),
TP_STRUCT__entry(
__field(struct pte_list_desc *, desc )
__field(pgprot_t *, sptep_to )
__field(pgprotval_t, spte_to )
__field(pgprot_t *, sptep_from )
__field(pgprotval_t, spte_from )
__field(int, index_to )
__field(int, index_from )
__field(unsigned long, val )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->desc = desc;
__entry->index_to = index_to;
__entry->index_from = index_from;
__entry->sptep_to = desc->sptes[index_to];
__entry->spte_to = pgprot_val(*(desc->sptes[index_to]));
__entry->sptep_from = desc->sptes[index_from];
__entry->spte_from = pgprot_val(*(desc->sptes[index_from]));
__entry->val = rmap_head->val;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : move many->many head val 0x%lx\n"
" deleted desc at %px[%04x] : %px : 0x%lx\n"
" moved to from %px[%04x] : %px ; 0x%lx\n",
__entry->rmap_head, __entry->val,
__entry->desc, __entry->index_to,
__entry->sptep_to, __entry->spte_to,
__entry->desc, __entry->index_from,
__entry->sptep_from, __entry->spte_from)
);
TRACE_EVENT(
rmap_remove_desc,
TP_PROTO(struct kvm_rmap_head *rmap_head, struct pte_list_desc *desc,
struct pte_list_desc *prev),
TP_ARGS(rmap_head, desc, prev),
TP_STRUCT__entry(
__field(struct pte_list_desc *, desc )
__field(struct pte_list_desc *, prev )
__field(struct pte_list_desc *, next )
__field(unsigned long, val )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->desc = desc;
__entry->desc = prev;
if (prev != NULL) {
__entry->next = prev->more;
} else {
__entry->next = NULL;
}
__entry->val = rmap_head->val;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : remove many->many head val 0x%lx\n"
" desc %px\n"
" prev %px\n"
" next %px\n",
__entry->rmap_head, __entry->val,
__entry->desc, __entry->prev, __entry->next)
);
TRACE_EVENT(
rmap_remove_many_many_spte,
TP_PROTO(struct kvm_rmap_head *rmap_head, pgprot_t *sptep,
struct pte_list_desc *desc, int index),
TP_ARGS(rmap_head, sptep, desc, index),
TP_STRUCT__entry(
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(pgprot_t *, rmap_sptep )
__field(pgprotval_t, rmap_spte )
__field(struct pte_list_desc *, desc )
__field(int, index )
__field(unsigned long, val )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->desc = desc;
__entry->index = index;
__entry->rmap_sptep = desc->sptes[index];
__entry->rmap_spte = pgprot_val(*(desc->sptes[index]));
__entry->val = rmap_head->val;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : add many->many head val 0x%lx "
"desc %px[%04x]\n"
" rmap spte : %px : 0x%lx\n"
" to remove : %px : 0x%lx\n",
__entry->rmap_head, __entry->val, __entry->desc, __entry->index,
__entry->rmap_sptep, __entry->rmap_spte,
__entry->sptep, __entry->spte)
);
TRACE_EVENT(
rmap_remove_0_bad_spte,
TP_PROTO(struct kvm_rmap_head *rmap_head, pgprot_t *sptep),
TP_ARGS(rmap_head, sptep),
TP_STRUCT__entry(
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(unsigned long, val )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->val = rmap_head->val;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : remove 0->bad not found spte %px : 0x%lx "
"head val 0x%lx\n",
__entry->rmap_head, __entry->sptep, __entry->spte, __entry->val)
);
TRACE_EVENT(
rmap_remove_1_bad_spte,
TP_PROTO(struct kvm_rmap_head *rmap_head, pgprot_t *sptep),
TP_ARGS(rmap_head, sptep),
TP_STRUCT__entry(
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(unsigned long, val )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->val = rmap_head->val;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : remove 1->bad not found spte %px : 0x%lx "
"head val 0x%lx\n",
__entry->rmap_head, __entry->sptep, __entry->spte, __entry->val)
);
TRACE_EVENT(
rmap_remove_many_bad_spte,
TP_PROTO(struct kvm_rmap_head *rmap_head, pgprot_t *sptep),
TP_ARGS(rmap_head, sptep),
TP_STRUCT__entry(
__field(pgprot_t *, sptep )
__field(pgprotval_t, spte )
__field(unsigned long, val )
__field(struct kvm_rmap_head *, rmap_head )
),
TP_fast_assign(
__entry->sptep = sptep;
__entry->spte = pgprot_val(*sptep);
__entry->val = rmap_head->val;
__entry->rmap_head = rmap_head;
),
TP_printk("rmap head %px : remove many->bad not found spte %px : 0x%lx "
"head val 0x%lx\n",
__entry->rmap_head, __entry->sptep, __entry->spte, __entry->val)
);
#endif /* _TRACE_KVM_H */
#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH ../../arch/e2k/include/asm/kvm
#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_FILE trace_kvm
/* This part must be outside protection */
#include <trace/define_trace.h>
Reference in New Issue View Git Blame Copy Permalink