#include <palacios/vmm_dev_mgr.h>
#include <palacios/vmm_cpuid.h>
#include <palacios/vmm_xml.h>
+#include <palacios/vmm_io.h>
+#include <palacios/vmm_msr.h>
+#include <palacios/vmm_mptable.h>
-#include <palacios/svm.h>
-#include <palacios/vmx.h>
-#ifdef CONFIG_SYMBIOTIC
-#include <palacios/vmm_sym_iface.h>
-#ifdef CONFIG_SYMBIOTIC_SWAP
-#include <palacios/vmm_sym_swap.h>
-#endif
-#endif
#include <palacios/vmm_host_events.h>
-static int setup_memory_map(struct guest_info * info, struct v3_config * config_ptr);
-static int setup_devices(struct guest_info * info, struct v3_config * config_ptr);
+static int setup_memory_map(struct v3_vm_info * vm, v3_cfg_tree_t * cfg);
+static int setup_devices(struct v3_vm_info * vm, v3_cfg_tree_t * cfg);
+
char * v3_cfg_val(v3_cfg_tree_t * tree, char * tag) {
-struct v3_cfg_file * v3_cfg_get_file(struct guest_info * info, char * tag) {
+struct v3_cfg_file * v3_cfg_get_file(struct v3_vm_info * vm, char * tag) {
struct v3_cfg_file * file = NULL;
- file = (struct v3_cfg_file *)v3_htable_search(info->cfg_data->file_table, (addr_t)tag);
+ file = (struct v3_cfg_file *)v3_htable_search(vm->cfg_data->file_table, (addr_t)tag);
return file;
}
return cfg;
}
+static int pre_config_vm(struct v3_vm_info * vm, v3_cfg_tree_t * vm_cfg) {
-static int pre_config_guest(struct guest_info * info, struct v3_config * config_ptr) {
- extern v3_cpu_arch_t v3_cpu_types[];
- char * memory_str = v3_cfg_val(config_ptr->cfg, "memory");
- char * paging = v3_cfg_val(config_ptr->cfg, "paging");
- char * schedule_hz_str = v3_cfg_val(config_ptr->cfg, "schedule_hz");
- char * vm_class = v3_cfg_val(config_ptr->cfg, "class");
+
+ char * memory_str = v3_cfg_val(vm_cfg, "memory");
+ char * schedule_hz_str = v3_cfg_val(vm_cfg, "schedule_hz");
+ char * vm_class = v3_cfg_val(vm_cfg, "class");
uint32_t sched_hz = 100; // set the schedule frequency to 100 HZ
if (!memory_str) {
PrintDebug("Memory=%s\n", memory_str);
// Amount of ram the Guest will have, always in MB
- info->mem_size = atoi(memory_str) * 1024 * 1024;
+ vm->mem_size = atoi(memory_str) * 1024 * 1024;
if (strcasecmp(vm_class, "PC") == 0) {
- info->vm_class = V3_PC_VM;
+ vm->vm_class = V3_PC_VM;
} else {
PrintError("Invalid VM class\n");
return -1;
}
- /*
- * Initialize the subsystem data strutures
- */
#ifdef CONFIG_TELEMETRY
{
- char * telemetry = v3_cfg_val(config_ptr->cfg, "telemetry");
+ char * telemetry = v3_cfg_val(vm_cfg, "telemetry");
// This should go first, because other subsystems will depend on the guest_info flag
if ((telemetry) && (strcasecmp(telemetry, "enable") == 0)) {
- info->enable_telemetry = 1;
- v3_init_telemetry(info);
+ vm->enable_telemetry = 1;
} else {
- info->enable_telemetry = 0;
+ vm->enable_telemetry = 0;
}
}
#endif
- v3_init_hypercall_map(info);
- v3_init_io_map(info);
- v3_init_msr_map(info);
- v3_init_cpuid_map(info);
- v3_init_host_events(info);
-
- // Initialize the memory map
- if (v3_init_shadow_map(info) == -1) {
- PrintError("Could not initialize shadow map\n");
+ if (v3_init_vm(vm) == -1) {
+ PrintError("Failed to initialize VM\n");
return -1;
}
-
- if ((v3_cpu_types[info->cpu_id] == V3_SVM_REV3_CPU) &&
- (paging) && (strcasecmp(paging, "nested") == 0)) {
- PrintDebug("Guest Page Mode: NESTED_PAGING\n");
- info->shdw_pg_mode = NESTED_PAGING;
- } else {
- PrintDebug("Guest Page Mode: SHADOW_PAGING\n");
- v3_init_shadow_page_state(info);
- info->shdw_pg_mode = SHADOW_PAGING;
- }
-#ifdef CONFIG_SYMBIOTIC
- v3_init_sym_iface(info);
-#endif
- v3_init_time(info);
- v3_init_interrupt_state(info);
- v3_init_exception_state(info);
- v3_init_dev_mgr(info);
- v3_init_decoder(info);
-
-#ifdef CONFIG_SYMBIOTIC_SWAP
- PrintDebug("initializing symbiotic swap\n");
- v3_init_sym_swap(info);
-#endif
- if (schedule_hz_str) {
+ if (schedule_hz_str) {
sched_hz = atoi(schedule_hz_str);
}
PrintDebug("CPU_KHZ = %d, schedule_freq=%p\n", V3_CPU_KHZ(),
(void *)(addr_t)sched_hz);
- info->yield_cycle_period = (V3_CPU_KHZ() * 1000) / sched_hz;
+ vm->yield_cycle_period = (V3_CPU_KHZ() * 1000) / sched_hz;
+
+ return 0;
+}
+
+static int determine_paging_mode(struct guest_info *info, v3_cfg_tree_t * core_cfg)
+{
+ extern v3_cpu_arch_t v3_cpu_types[];
+
+ v3_cfg_tree_t *vm_tree = info->vm_info->cfg_data->cfg;
+ v3_cfg_tree_t *pg_tree = v3_cfg_subtree(vm_tree, "paging");
+ char *pg_type = v3_cfg_val(vm_tree, "paging");
+ char *pg_mode = v3_cfg_val(pg_tree, "mode");
+ PrintDebug("Paging mode specified as %s(%s)\n", pg_type, pg_mode);
+
+ if (pg_type) {
+ if ((strcasecmp(pg_type, "nested") == 0)) {
+ if (v3_cpu_types[info->cpu_id] == V3_SVM_REV3_CPU) {
+ info->shdw_pg_mode = NESTED_PAGING;
+ } else {
+ PrintError("Nested paging not supported on this hardware. Defaulting to shadow paging\n");
+ info->shdw_pg_mode = SHADOW_PAGING;
+ }
+ } else if ((strcasecmp(pg_type, "shadow") == 0)) {
+ info->shdw_pg_mode = SHADOW_PAGING;
+ } else {
+ PrintError("Invalid paging type (%s) specified in configuration. Defaulting to shadow paging\n", pg_type);
+ info->shdw_pg_mode = SHADOW_PAGING;
+ }
+ } else {
+ PrintDebug("No paging type specified in configuration.\n");
+ info->shdw_pg_mode = SHADOW_PAGING;
+ }
+
+ if (info->shdw_pg_mode == NESTED_PAGING) {
+ PrintDebug("Guest Page Mode: NESTED_PAGING\n");
+ } else if (info->shdw_pg_mode == SHADOW_PAGING) {
+ PrintDebug("Guest Page Mode: SHADOW_PAGING\n");
+ } else {
+ PrintError("Guest paging mode incorrectly set.\n");
+ return -1;
+ }
+ return 0;
+}
+
+static int pre_config_core(struct guest_info * info, v3_cfg_tree_t * core_cfg) {
+
+ if (determine_paging_mode(info, core_cfg))
+ return -1;
+ v3_init_core(info);
+
+ if (info->vm_info->vm_class == V3_PC_VM) {
+ if (pre_config_pc_core(info, core_cfg) == -1) {
+ PrintError("PC Post configuration failure\n");
+ return -1;
+ }
+ } else {
+ PrintError("Invalid VM Class\n");
+ return -1;
+ }
return 0;
}
-static int post_config_guest(struct guest_info * info, struct v3_config * config_ptr) {
+
+static int post_config_vm(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) {
+
+ vm->run_state = VM_STOPPED;
// Configure the memory map for the guest
- if (setup_memory_map(info, config_ptr) == -1) {
+ if (setup_memory_map(vm, cfg) == -1) {
PrintError("Setting up guest memory map failed...\n");
return -1;
}
//v3_hook_io_port(info, 1234, &IO_Read, NULL, info);
- if (setup_devices(info, config_ptr) == -1) {
+ if (setup_devices(vm, cfg) == -1) {
PrintError("Failed to setup devices\n");
return -1;
}
+
// v3_print_io_map(info);
- v3_print_msr_map(info);
+ v3_print_msr_map(vm);
+
+
+ if (vm->vm_class == V3_PC_VM) {
+ if (post_config_pc(vm, cfg) == -1) {
+ PrintError("PC Post configuration failure\n");
+ return -1;
+ }
+ } else {
+ PrintError("Invalid VM Class\n");
+ return -1;
+ }
+
+ if (v3_inject_mptable(vm)==-1) {
+ PrintError("Failed to inject mptable during configuration\n");
+ return -1;
+ }
+
+ return 0;
+}
- info->run_state = VM_STOPPED;
- if (info->vm_class == V3_PC_VM) {
- if (post_config_pc(info, config_ptr) == -1) {
+
+static int post_config_core(struct guest_info * info, v3_cfg_tree_t * cfg) {
+
+
+
+ if (info->vm_info->vm_class == V3_PC_VM) {
+ if (post_config_pc_core(info, cfg) == -1) {
PrintError("PC Post configuration failure\n");
return -1;
}
-int v3_config_guest(struct guest_info * info, void * cfg_blob) {
+static struct v3_vm_info * allocate_guest(int num_cores) {
+ int guest_state_size = sizeof(struct v3_vm_info) + (sizeof(struct guest_info) * num_cores);
+ struct v3_vm_info * vm = V3_Malloc(guest_state_size);
+
+ memset(vm, 0, guest_state_size);
+
+ vm->num_cores = num_cores;
+
+ return vm;
+}
+
+
+
+struct v3_vm_info * v3_config_guest(void * cfg_blob) {
v3_cpu_arch_t cpu_type = v3_get_cpu_type(v3_get_cpu_id());
+ struct v3_config * cfg_data = NULL;
+ struct v3_vm_info * vm = NULL;
+ int num_cores = 0;
+ int i = 0;
+ v3_cfg_tree_t * cores_cfg = NULL;
+ v3_cfg_tree_t * per_core_cfg = NULL;
if (cpu_type == V3_INVALID_CPU) {
PrintError("Configuring guest on invalid CPU\n");
- return -1;
+ return NULL;
}
- info->cfg_data = parse_config(cfg_blob);
+ cfg_data = parse_config(cfg_blob);
- if (!info->cfg_data) {
+ if (!cfg_data) {
PrintError("Could not parse configuration\n");
- return -1;
+ return NULL;
+ }
+
+ cores_cfg = v3_cfg_subtree(cfg_data->cfg, "cores");
+
+ if (!cores_cfg) {
+ PrintError("Could not find core configuration (new config format required)\n");
+ return NULL;
+ }
+
+ num_cores = atoi(v3_cfg_val(cores_cfg, "count"));
+
+ if (num_cores == 0) {
+ PrintError("No cores specified in configuration\n");
+ return NULL;
}
+ V3_Print("Configuring %d cores\n", num_cores);
+
+ vm = allocate_guest(num_cores);
+
+ if (!vm) {
+ PrintError("Could not allocate %d core guest\n", vm->num_cores);
+ return NULL;
+ }
+
+ vm->cfg_data = cfg_data;
+
V3_Print("Preconfiguration\n");
- if (pre_config_guest(info, info->cfg_data) == -1) {
+ if (pre_config_vm(vm, vm->cfg_data->cfg) == -1) {
PrintError("Error in preconfiguration\n");
- return -1;
+ return NULL;
}
- V3_Print("Arch dependent configuration\n");
- // init SVM/VMX
-#ifdef CONFIG_SVM
- if ((cpu_type == V3_SVM_CPU) || (cpu_type == V3_SVM_REV3_CPU)) {
- if (v3_init_svm_vmcb(info, info->vm_class) == -1) {
- PrintError("Error in SVM initialization\n");
- return -1;
- }
- }
-#endif
-#ifdef CONFIG_VMX
- else if ((cpu_type == V3_VMX_CPU) || (cpu_type == V3_VMX_EPT_CPU)) {
- if (v3_init_vmx_vmcs(info, info->vm_class) == -1) {
- PrintError("Error in VMX initialization\n");
- return -1;
+ V3_Print("Per core configuration\n");
+ per_core_cfg = v3_cfg_subtree(cores_cfg, "core");
+
+ // per core configuration
+ for (i = 0; i < vm->num_cores; i++) {
+ struct guest_info * info = &(vm->cores[i]);
+
+ info->cpu_id = i;
+ info->vm_info = vm;
+
+ if (pre_config_core(info, per_core_cfg) == -1) {
+ PrintError("Error in core %d preconfiguration\n", i);
+ return NULL;
}
- }
-#endif
- else {
- PrintError("Invalid CPU Type\n");
- return -1;
+
+ per_core_cfg = v3_cfg_next_branch(per_core_cfg);
}
+
V3_Print("Post Configuration\n");
- if (post_config_guest(info, info->cfg_data) == -1) {
+ if (post_config_vm(vm, vm->cfg_data->cfg) == -1) {
PrintError("Error in postconfiguration\n");
- return -1;
+ return NULL;
+ }
+
+
+ per_core_cfg = v3_cfg_subtree(cores_cfg, "core");
+
+ // per core configuration
+ for (i = 0; i < vm->num_cores; i++) {
+ struct guest_info * info = &(vm->cores[i]);
+
+ post_config_core(info, per_core_cfg);
+
+ per_core_cfg = v3_cfg_next_branch(per_core_cfg);
}
V3_Print("Configuration successfull\n");
- return 0;
+ return vm;
}
-static int setup_memory_map(struct guest_info * info, struct v3_config * config_ptr) {
- v3_cfg_tree_t * mem_region = v3_cfg_subtree(v3_cfg_subtree(config_ptr->cfg, "memmap"), "region");
+static int setup_memory_map(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) {
+ v3_cfg_tree_t * mem_region = v3_cfg_subtree(v3_cfg_subtree(cfg, "memmap"), "region");
while (mem_region) {
addr_t start_addr = atox(v3_cfg_val(mem_region, "start"));
addr_t host_addr = atox(v3_cfg_val(mem_region, "host_addr"));
- if (v3_add_shadow_mem(info, start_addr, end_addr, host_addr) == -1) {
+ if (v3_add_shadow_mem(vm, V3_MEM_CORE_ANY, start_addr, end_addr, host_addr) == -1) {
PrintError("Could not map memory region: %p-%p => %p\n",
(void *)start_addr, (void *)end_addr, (void *)host_addr);
return -1;
-
-
-
-
-
-static int setup_devices(struct guest_info * info, struct v3_config * config_ptr) {
- v3_cfg_tree_t * device = v3_cfg_subtree(v3_cfg_subtree(config_ptr->cfg, "devices"), "device");
+static int setup_devices(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) {
+ v3_cfg_tree_t * device = v3_cfg_subtree(v3_cfg_subtree(cfg, "devices"), "device");
while (device) {
V3_Print("configuring device %s\n", id);
- if (v3_create_device(info, id, device) == -1) {
+ if (v3_create_device(vm, id, device) == -1) {
PrintError("Error creating device %s\n", id);
return -1;
}
device = v3_cfg_next_branch(device);
}
-
- v3_print_dev_mgr(info);
+ v3_print_dev_mgr(vm);
return 0;
}
+
+
