/******************************************************************************

 * 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:

 */