/******************************************************************************
* vm_event.h
*
* Memory event common structures.
*
* Copyright (c) 2009 by Citrix Systems, Inc. (Patrick Colp)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#ifndef _XEN_PUBLIC_VM_EVENT_H
#define _XEN_PUBLIC_VM_EVENT_H
#include "xen.h"
#define VM_EVENT_INTERFACE_VERSION 0x00000002
#if defined(__XEN__) || defined(__XEN_TOOLS__)
#include "io/ring.h"
/*
* Memory event flags
*/
/*
* VCPU_PAUSED in a request signals that the vCPU triggering the event has been
* paused
* VCPU_PAUSED in a response signals to unpause the vCPU
*/
#define VM_EVENT_FLAG_VCPU_PAUSED (1 << 0)
/* Flags to aid debugging vm_event */
#define VM_EVENT_FLAG_FOREIGN (1 << 1)
/*
* The following flags can be set in response to a mem_access event.
*
* Emulate the fault-causing instruction (if set in the event response flags).
* This will allow the guest to continue execution without lifting the page
* access restrictions.
*/
#define VM_EVENT_FLAG_EMULATE (1 << 2)
/*
* Same as VM_EVENT_FLAG_EMULATE, but with write operations or operations
* potentially having side effects (like memory mapped or port I/O) disabled.
*/
#define VM_EVENT_FLAG_EMULATE_NOWRITE (1 << 3)
/*
* Toggle singlestepping on vm_event response.
* Requires the vCPU to be paused already (synchronous events only).
*/
#define VM_EVENT_FLAG_TOGGLE_SINGLESTEP (1 << 4)
/*
* Data is being sent back to the hypervisor in the event response, to be
* returned by the read function when emulating an instruction.
* This flag is only useful when combined with VM_EVENT_FLAG_EMULATE
* and takes precedence if combined with VM_EVENT_FLAG_EMULATE_NOWRITE
* (i.e. if both VM_EVENT_FLAG_EMULATE_NOWRITE and
* VM_EVENT_FLAG_SET_EMUL_READ_DATA are set, only the latter will be honored).
*/
#define VM_EVENT_FLAG_SET_EMUL_READ_DATA (1 << 5)
/*
* Deny completion of the operation that triggered the event.
* Currently only useful for MSR and control-register write events.
* Requires the vCPU to be paused already (synchronous events only).
*/
#define VM_EVENT_FLAG_DENY (1 << 6)
/*
* This flag can be set in a request or a response
*
* On a request, indicates that the event occurred in the alternate p2m
* specified by the altp2m_idx request field.
*
* On a response, indicates that the VCPU should resume in the alternate p2m
* specified by the altp2m_idx response field if possible.
*/
#define VM_EVENT_FLAG_ALTERNATE_P2M (1 << 7)
/*
* Set the vCPU registers to the values in the vm_event response.
* At the moment x86-only, applies to EAX-EDX, ESP, EBP, ESI, EDI, R8-R15,
* EFLAGS, and EIP.
* Requires the vCPU to be paused already (synchronous events only).
*/
#define VM_EVENT_FLAG_SET_REGISTERS (1 << 8)
/*
* Instruction cache is being sent back to the hypervisor in the event response
* to be used by the emulator. This flag is only useful when combined with
* VM_EVENT_FLAG_EMULATE and does not take presedence if combined with
* VM_EVENT_FLAG_EMULATE_NOWRITE or VM_EVENT_FLAG_SET_EMUL_READ_DATA, (i.e.
* if any of those flags are set, only those will be honored).
*/
#define VM_EVENT_FLAG_SET_EMUL_INSN_DATA (1 << 9)
/*
* Have a one-shot VM_EVENT_REASON_INTERRUPT event sent for the first
* interrupt pending after resuming the VCPU.
*/
#define VM_EVENT_FLAG_GET_NEXT_INTERRUPT (1 << 10)
/*
* Reasons for the vm event request
*/
/* Default case */
#define VM_EVENT_REASON_UNKNOWN 0
/* Memory access violation */
#define VM_EVENT_REASON_MEM_ACCESS 1
/* Memory sharing event */
#define VM_EVENT_REASON_MEM_SHARING 2
/* Memory paging event */
#define VM_EVENT_REASON_MEM_PAGING 3
/* A control register was updated */
#define VM_EVENT_REASON_WRITE_CTRLREG 4
/* An MSR was updated. */
#define VM_EVENT_REASON_MOV_TO_MSR 5
/* Debug operation executed (e.g. int3) */
#define VM_EVENT_REASON_SOFTWARE_BREAKPOINT 6
/* Single-step (e.g. MTF) */
#define VM_EVENT_REASON_SINGLESTEP 7
/* An event has been requested via HVMOP_guest_request_vm_event. */
#define VM_EVENT_REASON_GUEST_REQUEST 8
/* A debug exception was caught */
#define VM_EVENT_REASON_DEBUG_EXCEPTION 9
/* CPUID executed */
#define VM_EVENT_REASON_CPUID 10
/*
* Privileged call executed (e.g. SMC).
* Note: event may be generated even if SMC condition check fails on some CPUs.
* As this behavior is CPU-specific, users are advised to not rely on it.
* These kinds of events will be filtered out in future versions.
*/
#define VM_EVENT_REASON_PRIVILEGED_CALL 11
/* An interrupt has been delivered. */
#define VM_EVENT_REASON_INTERRUPT 12
/* A descriptor table register was accessed. */
#define VM_EVENT_REASON_DESCRIPTOR_ACCESS 13
/* Current instruction is not implemented by the emulator */
#define VM_EVENT_REASON_EMUL_UNIMPLEMENTED 14
/* Supported values for the vm_event_write_ctrlreg index. */
#define VM_EVENT_X86_CR0 0
#define VM_EVENT_X86_CR3 1
#define VM_EVENT_X86_CR4 2
#define VM_EVENT_X86_XCR0 3
/*
* Using custom vCPU structs (i.e. not hvm_hw_cpu) for both x86 and ARM
* so as to not fill the vm_event ring buffer too quickly.
*/
struct vm_event_regs_x86 {
uint64_t rax;
uint64_t rcx;
uint64_t rdx;
uint64_t rbx;
uint64_t rsp;
uint64_t rbp;
uint64_t rsi;
uint64_t rdi;
uint64_t r8;
uint64_t r9;
uint64_t r10;
uint64_t r11;
uint64_t r12;
uint64_t r13;
uint64_t r14;
uint64_t r15;
uint64_t rflags;
uint64_t dr7;
uint64_t rip;
uint64_t cr0;
uint64_t cr2;
uint64_t cr3;
uint64_t cr4;
uint64_t sysenter_cs;
uint64_t sysenter_esp;
uint64_t sysenter_eip;
uint64_t msr_efer;
uint64_t msr_star;
uint64_t msr_lstar;
uint64_t fs_base;
uint64_t gs_base;
uint32_t cs_arbytes;
uint32_t _pad;
};
/*
* Only the register 'pc' can be set on a vm_event response using the
* VM_EVENT_FLAG_SET_REGISTERS flag.
*/
struct vm_event_regs_arm {
uint64_t ttbr0;
uint64_t ttbr1;
uint64_t ttbcr;
uint64_t pc;
uint32_t cpsr;
uint32_t _pad;
};
/*
* mem_access flag definitions
*
* These flags are set only as part of a mem_event request.
*
* R/W/X: Defines the type of violation that has triggered the event
* Multiple types can be set in a single violation!
* GLA_VALID: If the gla field holds a guest VA associated with the event
* FAULT_WITH_GLA: If the violation was triggered by accessing gla
* FAULT_IN_GPT: If the violation was triggered during translating gla
*/
#define MEM_ACCESS_R (1 << 0)
#define MEM_ACCESS_W (1 << 1)
#define MEM_ACCESS_X (1 << 2)
#define MEM_ACCESS_RWX (MEM_ACCESS_R | MEM_ACCESS_W | MEM_ACCESS_X)
#define MEM_ACCESS_RW (MEM_ACCESS_R | MEM_ACCESS_W)
#define MEM_ACCESS_RX (MEM_ACCESS_R | MEM_ACCESS_X)
#define MEM_ACCESS_WX (MEM_ACCESS_W | MEM_ACCESS_X)
#define MEM_ACCESS_GLA_VALID (1 << 3)
#define MEM_ACCESS_FAULT_WITH_GLA (1 << 4)
#define MEM_ACCESS_FAULT_IN_GPT (1 << 5)
struct vm_event_mem_access {
uint64_t gfn;
uint64_t offset;
uint64_t gla; /* if flags has MEM_ACCESS_GLA_VALID set */
uint32_t flags; /* MEM_ACCESS_* */
uint32_t _pad;
};
struct vm_event_write_ctrlreg {
uint32_t index;
uint32_t _pad;
uint64_t new_value;
uint64_t old_value;
};
struct vm_event_singlestep {
uint64_t gfn;
};
struct vm_event_debug {
uint64_t gfn;
uint32_t insn_length;
uint8_t type; /* HVMOP_TRAP_* */
uint8_t _pad[3];
};
struct vm_event_mov_to_msr {
uint64_t msr;
uint64_t value;
};
#define VM_EVENT_DESC_IDTR 1
#define VM_EVENT_DESC_GDTR 2
#define VM_EVENT_DESC_LDTR 3
#define VM_EVENT_DESC_TR 4
struct vm_event_desc_access {
union {
struct {
uint32_t instr_info; /* VMX: VMCS Instruction-Information */
uint32_t _pad1;
uint64_t exit_qualification; /* VMX: VMCS Exit Qualification */
} vmx;
struct {
uint64_t exitinfo; /* SVM: VMCB EXITINFO */
uint64_t _pad2;
} svm;
} arch;
uint8_t descriptor; /* VM_EVENT_DESC_* */
uint8_t is_write;
uint8_t _pad[6];
};
struct vm_event_cpuid {
uint32_t insn_length;
uint32_t leaf;
uint32_t subleaf;
uint32_t _pad;
};
struct vm_event_interrupt_x86 {
uint32_t vector;
uint32_t type;
uint32_t error_code;
uint32_t _pad;
uint64_t cr2;
};
#define MEM_PAGING_DROP_PAGE (1 << 0)
#define MEM_PAGING_EVICT_FAIL (1 << 1)
struct vm_event_paging {
uint64_t gfn;
uint32_t p2mt;
uint32_t flags;
};
struct vm_event_sharing {
uint64_t gfn;
uint32_t p2mt;
uint32_t _pad;
};
struct vm_event_emul_read_data {
uint32_t size;
/* The struct is used in a union with vm_event_regs_x86. */
uint8_t data[sizeof(struct vm_event_regs_x86) - sizeof(uint32_t)];
};
struct vm_event_emul_insn_data {
uint8_t data[16]; /* Has to be completely filled */
};
typedef struct vm_event_st {
uint32_t version; /* VM_EVENT_INTERFACE_VERSION */
uint32_t flags; /* VM_EVENT_FLAG_* */
uint32_t reason; /* VM_EVENT_REASON_* */
uint32_t vcpu_id;
uint16_t altp2m_idx; /* may be used during request and response */
uint16_t _pad[3];
union {
struct vm_event_paging mem_paging;
struct vm_event_sharing mem_sharing;
struct vm_event_mem_access mem_access;
struct vm_event_write_ctrlreg write_ctrlreg;
struct vm_event_mov_to_msr mov_to_msr;
struct vm_event_desc_access desc_access;
struct vm_event_singlestep singlestep;
struct vm_event_debug software_breakpoint;
struct vm_event_debug debug_exception;
struct vm_event_cpuid cpuid;
union {
struct vm_event_interrupt_x86 x86;
} interrupt;
} u;
union {
union {
struct vm_event_regs_x86 x86;
struct vm_event_regs_arm arm;
} regs;
union {
struct vm_event_emul_read_data read;
struct vm_event_emul_insn_data insn;
} emul;
} data;
} vm_event_request_t, vm_event_response_t;
DEFINE_RING_TYPES(vm_event, vm_event_request_t, vm_event_response_t);
#endif /* defined(__XEN__) || defined(__XEN_TOOLS__) */
#endif /* _XEN_PUBLIC_VM_EVENT_H */
/*
* Local variables:
* mode: C
* c-file-style: "BSD"
* c-basic-offset: 4
* tab-width: 4
* indent-tabs-mode: nil
* End:
*/