232 lines
7.3 KiB
C
232 lines
7.3 KiB
C
/*
|
|
* Copyright (C) 2018 Intel Corporation. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
* * Neither the name of Intel Corporation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef VM_H_
|
|
#define VM_H_
|
|
|
|
enum vm_privilege_level {
|
|
VM_PRIVILEGE_LEVEL_HIGH = 0,
|
|
VM_PRIVILEGE_LEVEL_MEDIUM,
|
|
VM_PRIVILEGE_LEVEL_LOW
|
|
};
|
|
|
|
#define MAX_VM_NAME_LEN 16
|
|
struct vm_attr {
|
|
char name[MAX_VM_NAME_LEN]; /* Virtual machine name string */
|
|
int id; /* Virtual machine identifier */
|
|
int boot_idx; /* Index indicating the boot sequence for this VM */
|
|
};
|
|
|
|
struct vm_hw_info {
|
|
int num_vcpus; /* Number of total virtual cores */
|
|
int exp_num_vcpus; /* Number of real expected virtual cores */
|
|
int created_vcpus; /* Number of created vcpus */
|
|
struct vcpu **vcpu_array; /* vcpu array of this VM */
|
|
uint64_t gpa_lowtop; /* top lowmem gpa of this VM */
|
|
};
|
|
|
|
struct sw_linux {
|
|
void *ramdisk_src_addr;
|
|
void *ramdisk_load_addr;
|
|
uint32_t ramdisk_size;
|
|
void *bootargs_src_addr;
|
|
void *bootargs_load_addr;
|
|
uint32_t bootargs_size;
|
|
void *dtb_src_addr;
|
|
void *dtb_load_addr;
|
|
uint32_t dtb_size;
|
|
};
|
|
|
|
struct sw_kernel_info {
|
|
void *kernel_src_addr;
|
|
void *kernel_load_addr;
|
|
void *kernel_entry_addr;
|
|
uint32_t kernel_size;
|
|
};
|
|
|
|
struct vm_sw_info {
|
|
int kernel_type; /* Guest kernel type */
|
|
/* Kernel information (common for all guest types) */
|
|
struct sw_kernel_info kernel_info;
|
|
/* Additional information specific to Linux guests */
|
|
struct sw_linux linux_info;
|
|
/* HVA to IO shared page */
|
|
void *io_shared_page;
|
|
};
|
|
|
|
struct vm_pm_info {
|
|
uint8_t px_cnt; /* count of all Px states */
|
|
struct cpu_px_data px_data[MAX_PSTATE];
|
|
uint8_t cx_cnt; /* count of all Cx entries */
|
|
struct cpu_cx_data cx_data[MAX_CSTATE];
|
|
};
|
|
|
|
/* VM guest types */
|
|
#define VM_LINUX_GUEST 0x02
|
|
#define VM_MONO_GUEST 0x01
|
|
|
|
enum vpic_wire_mode {
|
|
VPIC_WIRE_INTR = 0,
|
|
VPIC_WIRE_LAPIC,
|
|
VPIC_WIRE_IOAPIC,
|
|
VPIC_WIRE_NULL
|
|
};
|
|
|
|
/* Enumerated type for VM states */
|
|
enum vm_state {
|
|
VM_CREATED = 0, /* VM created / awaiting start (boot) */
|
|
VM_STARTED, /* VM started (booted) */
|
|
VM_PAUSED, /* VM paused */
|
|
VM_STATE_UNKNOWN
|
|
};
|
|
|
|
/* Structure for VM state information */
|
|
struct vm_state_info {
|
|
enum vm_state state; /* State of the VM */
|
|
unsigned int privilege; /* Privilege level of the VM */
|
|
unsigned int boot_count;/* Number of times the VM has booted */
|
|
|
|
};
|
|
|
|
struct vm_arch {
|
|
uint64_t guest_init_pml4;/* Guest init pml4 */
|
|
/* EPT hierarchy for Normal World */
|
|
uint64_t nworld_eptp;
|
|
/* EPT hierarchy for Secure World
|
|
* Secure world can access Normal World's memory,
|
|
* but Normal World can not access Secure World's memory.
|
|
*/
|
|
uint64_t sworld_eptp;
|
|
uint64_t m2p; /* machine address to guest physical address */
|
|
void *tmp_pg_array; /* Page array for tmp guest paging struct */
|
|
void *iobitmap[2];/* IO bitmap page array base address for this VM */
|
|
void *msr_bitmap; /* MSR bitmap page base address for this VM */
|
|
void *virt_ioapic; /* Virtual IOAPIC base address */
|
|
/**
|
|
* A link to the IO handler of this VM.
|
|
* We only register io handle to this link
|
|
* when create VM on sequences and ungister it when
|
|
* destory VM. So there no need lock to prevent preempt.
|
|
* Besides, there only a few io handlers now, we don't
|
|
* need binary search temporary.
|
|
*/
|
|
struct vm_io_handler *io_handler;
|
|
|
|
/* reference to virtual platform to come here (as needed) */
|
|
};
|
|
|
|
#define CPUID_CHECK_SUBLEAF (1 << 0)
|
|
#define MAX_VM_VCPUID_ENTRIES 64
|
|
struct vcpuid_entry {
|
|
uint32_t eax;
|
|
uint32_t ebx;
|
|
uint32_t ecx;
|
|
uint32_t edx;
|
|
uint32_t leaf;
|
|
uint32_t subleaf;
|
|
uint32_t flags;
|
|
uint32_t padding;
|
|
};
|
|
|
|
struct vpic;
|
|
struct vm {
|
|
struct vm_attr attr; /* Reference to this VM's attributes */
|
|
struct vm_hw_info hw; /* Reference to this VM's HW information */
|
|
struct vm_sw_info sw; /* Reference to SW associated with this VM */
|
|
struct vm_pm_info pm; /* Reference to this VM's arch information */
|
|
struct vm_arch arch_vm; /* Reference to this VM's arch information */
|
|
struct vm_state_info state_info;/* State info of this VM */
|
|
enum vm_state state; /* VM state */
|
|
struct vcpu *current_vcpu; /* VCPU that caused vm exit */
|
|
void *vuart; /* Virtual UART */
|
|
struct vpic *vpic; /* Virtual PIC */
|
|
uint32_t vpic_wire_mode;
|
|
struct iommu_domain *iommu_domain; /* iommu domain of this VM */
|
|
struct list_head list; /* list of VM */
|
|
spinlock_t spinlock; /* Spin-lock used to protect VM modifications */
|
|
|
|
struct list_head mmio_list; /* list for mmio. This list is not updated
|
|
* when vm is active. So no lock needed
|
|
*/
|
|
|
|
struct _vm_shared_memory *shared_memory_area;
|
|
|
|
struct {
|
|
struct _vm_virtual_device_node *head;
|
|
struct _vm_virtual_device_node *tail;
|
|
} virtual_device_list;
|
|
|
|
unsigned char GUID[16];
|
|
struct secure_world_control sworld_control;
|
|
|
|
uint32_t vcpuid_entry_nr, vcpuid_level, vcpuid_xlevel;
|
|
struct vcpuid_entry vcpuid_entries[MAX_VM_VCPUID_ENTRIES];
|
|
};
|
|
|
|
struct vm_description {
|
|
/* Virtual machine identifier, assigned by the system */
|
|
char *vm_attr_name;
|
|
/* The logical CPU IDs associated with this VM - The first CPU listed
|
|
* will be the VM's BSP
|
|
*/
|
|
int *vm_hw_logical_core_ids;
|
|
unsigned char GUID[16]; /* GUID of the vm will be created */
|
|
int vm_hw_num_cores; /* Number of virtual cores */
|
|
/* Indicates to APs that the BSP has created a VM for this
|
|
* description
|
|
*/
|
|
bool vm_created;
|
|
/* Index indicating VM's privilege level */
|
|
unsigned int vm_state_info_privilege;
|
|
/* Whether secure world is enabled for current VM. */
|
|
bool sworld_enabled;
|
|
};
|
|
|
|
struct vm_description_array {
|
|
int num_vm_desc;
|
|
struct vm_description vm_desc_array[];
|
|
};
|
|
|
|
int shutdown_vm(struct vm *vm);
|
|
int pause_vm(struct vm *vm);
|
|
int start_vm(struct vm *vm);
|
|
int create_vm(struct vm_description *vm_desc, struct vm **vm);
|
|
int prepare_vm0(void);
|
|
void vm_fixup(struct vm *vm);
|
|
|
|
struct vm *get_vm_from_vmid(int vm_id);
|
|
struct vm_description *get_vm_desc(int idx);
|
|
|
|
extern struct list_head vm_list;
|
|
extern spinlock_t vm_list_lock;
|
|
extern bool x2apic_enabled;
|
|
|
|
#endif /* VM_H_ */
|