X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=palacios%2Fsrc%2Fpalacios%2Fvm_guest.c;h=5c9884841f3586e998bcdbb68fc22c22f291194a;hb=c7dc4898f820a63f38c04add12f74d9ea1295ffc;hp=87a1ae6e4ed21d3497cea091304c46c7f884b3cd;hpb=266af4b5b19da7bee8e7445288c7c1cb3ee194c7;p=palacios.git diff --git a/palacios/src/palacios/vm_guest.c b/palacios/src/palacios/vm_guest.c index 87a1ae6..5c98848 100644 --- a/palacios/src/palacios/vm_guest.c +++ b/palacios/src/palacios/vm_guest.c @@ -23,22 +23,34 @@ #include #include #include +#include #include +#include +#include +#include +#include +#include +#include +#include -v3_vm_cpu_mode_t v3_get_cpu_mode(struct guest_info * info) { +v3_cpu_mode_t v3_get_vm_cpu_mode(struct guest_info * info) { struct cr0_32 * cr0; - struct cr4_32 * cr4 = (struct cr4_32 *)&(info->ctrl_regs.cr4); - struct efer_64 * efer = (struct efer_64 *)&(info->guest_efer); + struct efer_64 * efer; struct v3_segment * cs = &(info->segments.cs); + struct cr4_32 * cr4; if (info->shdw_pg_mode == SHADOW_PAGING) { cr0 = (struct cr0_32 *)&(info->shdw_pg_state.guest_cr0); + efer = (struct efer_64 *)&(info->shdw_pg_state.guest_efer); + cr4 = (struct cr4_32 *)&(info->shdw_pg_state.guest_cr4); } else if (info->shdw_pg_mode == NESTED_PAGING) { cr0 = (struct cr0_32 *)&(info->ctrl_regs.cr0); + efer = (struct efer_64 *)&(info->ctrl_regs.efer); + cr4 = (struct cr4_32 *)&(info->ctrl_regs.cr4); } else { - PrintError("Invalid Paging Mode...\n"); - V3_ASSERT(0); + PrintError(info->vm_info, info, "Invalid Paging Mode...\n"); + V3_ASSERT(info->vm_info, info, 0); return -1; } @@ -60,16 +72,19 @@ v3_vm_cpu_mode_t v3_get_cpu_mode(struct guest_info * info) { uint_t v3_get_addr_width(struct guest_info * info) { struct cr0_32 * cr0; struct cr4_32 * cr4 = (struct cr4_32 *)&(info->ctrl_regs.cr4); - struct efer_64 * efer = (struct efer_64 *)&(info->guest_efer); + struct efer_64 * efer; struct v3_segment * cs = &(info->segments.cs); + if (info->shdw_pg_mode == SHADOW_PAGING) { cr0 = (struct cr0_32 *)&(info->shdw_pg_state.guest_cr0); + efer = (struct efer_64 *)&(info->shdw_pg_state.guest_efer); } else if (info->shdw_pg_mode == NESTED_PAGING) { cr0 = (struct cr0_32 *)&(info->ctrl_regs.cr0); + efer = (struct efer_64 *)&(info->ctrl_regs.efer); } else { - PrintError("Invalid Paging Mode...\n"); - V3_ASSERT(0); + PrintError(info->vm_info, info, "Invalid Paging Mode...\n"); + V3_ASSERT(info->vm_info, info, 0); return -1; } @@ -95,7 +110,7 @@ static const uchar_t LONG_STR[] = "Long"; static const uchar_t LONG_32_COMPAT_STR[] = "32bit Compat"; static const uchar_t LONG_16_COMPAT_STR[] = "16bit Compat"; -const uchar_t * v3_cpu_mode_to_str(v3_vm_cpu_mode_t mode) { +const uchar_t * v3_cpu_mode_to_str(v3_cpu_mode_t mode) { switch (mode) { case REAL: return REAL_STR; @@ -114,7 +129,7 @@ const uchar_t * v3_cpu_mode_to_str(v3_vm_cpu_mode_t mode) { } } -v3_vm_mem_mode_t v3_get_mem_mode(struct guest_info * info) { +v3_mem_mode_t v3_get_vm_mem_mode(struct guest_info * info) { struct cr0_32 * cr0; if (info->shdw_pg_mode == SHADOW_PAGING) { @@ -122,8 +137,8 @@ v3_vm_mem_mode_t v3_get_mem_mode(struct guest_info * info) { } else if (info->shdw_pg_mode == NESTED_PAGING) { cr0 = (struct cr0_32 *)&(info->ctrl_regs.cr0); } else { - PrintError("Invalid Paging Mode...\n"); - V3_ASSERT(0); + PrintError(info->vm_info, info, "Invalid Paging Mode...\n"); + V3_ASSERT(info->vm_info, info, 0); return -1; } @@ -137,7 +152,7 @@ v3_vm_mem_mode_t v3_get_mem_mode(struct guest_info * info) { static const uchar_t PHYS_MEM_STR[] = "Physical Memory"; static const uchar_t VIRT_MEM_STR[] = "Virtual Memory"; -const uchar_t * v3_mem_mode_to_str(v3_vm_mem_mode_t mode) { +const uchar_t * v3_mem_mode_to_str(v3_mem_mode_t mode) { switch (mode) { case PHYSICAL_MEM: return PHYS_MEM_STR; @@ -149,79 +164,318 @@ const uchar_t * v3_mem_mode_to_str(v3_vm_mem_mode_t mode) { } -void v3_print_segments(struct guest_info * info) { - struct v3_segments * segs = &(info->segments); - int i = 0; - struct v3_segment * seg_ptr; - seg_ptr=(struct v3_segment *)segs; - - char *seg_names[] = {"CS", "DS" , "ES", "FS", "GS", "SS" , "LDTR", "GDTR", "IDTR", "TR", NULL}; - PrintDebug("Segments\n"); - for (i = 0; seg_names[i] != NULL; i++) { - PrintDebug("\t%s: Sel=%x, base=%p, limit=%x (long_mode=%d, db=%d)\n", seg_names[i], seg_ptr[i].selector, - (void *)(addr_t)seg_ptr[i].base, seg_ptr[i].limit, - seg_ptr[i].long_mode, seg_ptr[i].db); + +#include +#include +static int info_hcall(struct guest_info * core, uint_t hcall_id, void * priv_data) { + extern v3_cpu_arch_t v3_mach_type; + int cpu_valid = 0; + + V3_Print(core->vm_info, core, "************** Guest State ************\n"); + v3_print_guest_state(core); + + // init SVM/VMX +#ifdef V3_CONFIG_SVM + if ((v3_mach_type == V3_SVM_CPU) || (v3_mach_type == V3_SVM_REV3_CPU)) { + cpu_valid = 1; + PrintDebugVMCB((vmcb_t *)(core->vmm_data)); + } +#endif +#ifdef V3_CONFIG_VMX + if ((v3_mach_type == V3_VMX_CPU) || (v3_mach_type == V3_VMX_EPT_CPU) || (v3_mach_type == V3_VMX_EPT_UG_CPU)) { + cpu_valid = 1; + v3_print_vmcs(); } +#endif + if (!cpu_valid) { + PrintError(core->vm_info, core, "Invalid CPU Type 0x%x\n", v3_mach_type); + return -1; + } + + return 0; } -void v3_print_ctrl_regs(struct guest_info * info) { - struct v3_ctrl_regs * regs = &(info->ctrl_regs); - int i = 0; - v3_reg_t * reg_ptr; - char * reg_names[] = {"CR0", "CR2", "CR3", "CR4", "CR8", "FLAGS", NULL}; - vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA(info->vmm_data); +#ifdef V3_CONFIG_SVM +#include +#include +#include +#include +#endif + +#ifdef V3_CONFIG_VMX +#include +#include +#include +#include +#endif + + +int v3_init_vm(struct v3_vm_info * vm) { + extern v3_cpu_arch_t v3_mach_type; + + v3_init_events(vm); + +#ifdef V3_CONFIG_TELEMETRY + v3_init_telemetry(vm); +#endif + + v3_init_exit_hooks(vm); + v3_init_hypercall_map(vm); + v3_init_io_map(vm); + v3_init_msr_map(vm); + v3_init_cpuid_map(vm); + v3_init_host_events(vm); + + v3_init_intr_routers(vm); + v3_init_ext_manager(vm); + + v3_init_barrier(vm); + + // Initialize the memory map + if (v3_init_mem_map(vm) == -1) { + PrintError(vm, VCORE_NONE, "Could not initialize shadow map\n"); + return -1; + } + + v3_init_mem_hooks(vm); + + if (v3_init_shdw_impl(vm) == -1) { + PrintError(vm, VCORE_NONE, "VM initialization error in shadow implementaion\n"); + return -1; + } + + + v3_init_time_vm(vm); - reg_ptr= (v3_reg_t *)regs; + v3_init_vm_debugging(vm); - PrintDebug("32 bit Ctrl Regs:\n"); - for (i = 0; reg_names[i] != NULL; i++) { - PrintDebug("\t%s=0x%p\n", reg_names[i], (void *)(addr_t)reg_ptr[i]); +#ifdef V3_CONFIG_SYMBIOTIC + v3_init_symbiotic_vm(vm); +#endif + + v3_init_dev_mgr(vm); + + + // init SVM/VMX + switch (v3_mach_type) { +#ifdef V3_CONFIG_SVM + case V3_SVM_CPU: + case V3_SVM_REV3_CPU: + v3_init_svm_io_map(vm); + v3_init_svm_msr_map(vm); + v3_init_svm_exits(vm); + break; +#endif +#ifdef V3_CONFIG_VMX + case V3_VMX_CPU: + case V3_VMX_EPT_CPU: + case V3_VMX_EPT_UG_CPU: + v3_init_vmx_io_map(vm); + v3_init_vmx_msr_map(vm); + v3_init_vmx_exits(vm); + break; +#endif + default: + PrintError(vm, VCORE_NONE, "Invalid CPU Type 0x%x\n", v3_mach_type); + return -1; } + + v3_register_hypercall(vm, GUEST_INFO_HCALL, info_hcall, NULL); - PrintDebug("\tEFER=0x%p\n", (void*)(addr_t)(guest_state->efer)); + V3_Print(vm, VCORE_NONE, "GUEST_INFO_HCALL=%x\n", GUEST_INFO_HCALL); + return 0; } -#ifdef __V3_32BIT__ -void v3_print_GPRs(struct guest_info * info) { - struct v3_gprs * regs = &(info->vm_regs); - int i = 0; - v3_reg_t * reg_ptr; - char * reg_names[] = { "RDI", "RSI", "RBP", "RSP", "RBX", "RDX", "RCX", "RAX", NULL}; +int v3_free_vm_internal(struct v3_vm_info * vm) { + extern v3_cpu_arch_t v3_mach_type; + + v3_remove_hypercall(vm, GUEST_INFO_HCALL); + - reg_ptr= (v3_reg_t *)regs; - PrintDebug("32 bit GPRs:\n"); +#ifdef V3_CONFIG_SYMBIOTIC + v3_deinit_symbiotic_vm(vm); +#endif - for (i = 0; reg_names[i] != NULL; i++) { - PrintDebug("\t%s=0x%p\n", reg_names[i], (void *)(addr_t)reg_ptr[i]); + // init SVM/VMX + switch (v3_mach_type) { +#ifdef V3_CONFIG_SVM + case V3_SVM_CPU: + case V3_SVM_REV3_CPU: + v3_deinit_svm_io_map(vm); + v3_deinit_svm_msr_map(vm); + break; +#endif +#ifdef V3_CONFIG_VMX + case V3_VMX_CPU: + case V3_VMX_EPT_CPU: + case V3_VMX_EPT_UG_CPU: + v3_deinit_vmx_io_map(vm); + v3_deinit_vmx_msr_map(vm); + break; +#endif + default: + PrintError(vm, VCORE_NONE, "Invalid CPU Type 0x%x\n", v3_mach_type); + return -1; } + + v3_deinit_dev_mgr(vm); + + v3_deinit_time_vm(vm); + + v3_deinit_mem_hooks(vm); + v3_delete_mem_map(vm); + v3_deinit_shdw_impl(vm); + + v3_deinit_ext_manager(vm); + v3_deinit_intr_routers(vm); + v3_deinit_host_events(vm); + + v3_deinit_barrier(vm); + + v3_deinit_cpuid_map(vm); + v3_deinit_msr_map(vm); + v3_deinit_io_map(vm); + v3_deinit_hypercall_map(vm); + + v3_deinit_exit_hooks(vm); + +#ifdef V3_CONFIG_TELEMETRY + v3_deinit_telemetry(vm); +#endif + + v3_deinit_events(vm); + + v3_fw_cfg_deinit(vm); + + + return 0; } -#elif __V3_64BIT__ -void v3_print_GPRs(struct guest_info * info) { - struct v3_gprs * regs = &(info->vm_regs); - int i = 0; - v3_reg_t * reg_ptr; - char * reg_names[] = { "RDI", "RSI", "RBP", "RSP", "RBX", "RDX", "RCX", "RAX", \ - "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15", NULL}; - reg_ptr= (v3_reg_t *)regs; - PrintDebug("64 bit GPRs:\n"); +int v3_init_core(struct guest_info * core) { + extern v3_cpu_arch_t v3_mach_type; + struct v3_vm_info * vm = core->vm_info; - for (i = 0; reg_names[i] != NULL; i++) { - PrintDebug("\t%s=0x%p\n", reg_names[i], (void *)(addr_t)reg_ptr[i]); + + + /* + * Initialize the subsystem data strutures + */ +#ifdef V3_CONFIG_TELEMETRY + v3_init_core_telemetry(core); +#endif + + if (core->shdw_pg_mode == SHADOW_PAGING) { + v3_init_shdw_pg_state(core); } + + v3_init_time_core(core); + v3_init_intr_controllers(core); + v3_init_exception_state(core); + + v3_init_decoder(core); + + +#ifdef V3_CONFIG_SYMBIOTIC + v3_init_symbiotic_core(core); +#endif + + // init SVM/VMX + + + switch (v3_mach_type) { +#ifdef V3_CONFIG_SVM + case V3_SVM_CPU: + case V3_SVM_REV3_CPU: + if (v3_init_svm_vmcb(core, vm->vm_class) == -1) { + PrintError(vm, core, "Error in SVM initialization\n"); + return -1; + } + break; +#endif +#ifdef V3_CONFIG_VMX + case V3_VMX_CPU: + case V3_VMX_EPT_CPU: + case V3_VMX_EPT_UG_CPU: + if (v3_init_vmx_vmcs(core, vm->vm_class) == -1) { + PrintError(vm, core, "Error in VMX initialization\n"); + return -1; + } + break; +#endif + default: + PrintError(vm, core, "Invalid CPU Type 0x%x\n", v3_mach_type); + return -1; + } + + v3_init_exit_hooks_core(core); + + + return 0; } +int v3_free_core(struct guest_info * core) { + extern v3_cpu_arch_t v3_mach_type; + + +#ifdef V3_CONFIG_SYMBIOTIC + v3_deinit_symbiotic_core(core); +#endif + + v3_deinit_decoder(core); + + v3_deinit_intr_controllers(core); + v3_deinit_time_core(core); + + if (core->shdw_pg_mode == SHADOW_PAGING) { + v3_deinit_shdw_pg_state(core); + } + + v3_free_passthrough_pts(core); + +#ifdef V3_CONFIG_TELEMETRY + v3_deinit_core_telemetry(core); +#endif + + switch (v3_mach_type) { +#ifdef V3_CONFIG_SVM + case V3_SVM_CPU: + case V3_SVM_REV3_CPU: + if (v3_deinit_svm_vmcb(core) == -1) { + PrintError(VM_NONE,VCORE_NONE, "Error in SVM deinitialization\n"); + return -1; + } + break; #endif +#ifdef V3_CONFIG_VMX + case V3_VMX_CPU: + case V3_VMX_EPT_CPU: + case V3_VMX_EPT_UG_CPU: + if (v3_deinit_vmx_vmcs(core) == -1) { + PrintError(VM_NONE, VCORE_NONE, "Error in VMX initialization\n"); + return -1; + } + break; +#endif + default: + PrintError(core->vm_info, core, "Invalid CPU Type 0x%x\n", v3_mach_type); + return -1; + } + + return 0; +} + + +