#include <palacios/vmm_sprintf.h>
+#ifdef V3_CONFIG_SWAPPING
+#include <palacios/vmm_swapping.h>
+#endif
+#ifdef V3_CONFIG_MULTIBOOT
+#include <palacios/vmm_multiboot.h>
+#endif
+#ifdef V3_CONFIG_HVM
+#include <palacios/vmm_hvm.h>
+#endif
#include <palacios/vmm_host_events.h>
+#include <palacios/vmm_perftune.h>
#include "vmm_config_class.h"
+
+/* The Palacios cookie encodes "v3vee" followed by a
+ 3 byte version code. There are currently two versions:
+
+ \0\0\0 => original (no checksum)
+ \0\0\1 => checksum
+*/
+#define COOKIE_LEN 8
+#define COOKIE_V0 "v3vee\0\0\0"
+#define COOKIE_V1 "v3vee\0\0\1"
+
// This is used to access the configuration file index table
-struct file_hdr {
+struct file_hdr_v0 {
uint32_t index;
uint32_t size;
uint64_t offset;
};
-struct file_idx_table {
+struct file_hdr_v1 {
+ uint32_t index;
+ uint32_t size;
+ uint64_t offset;
+ ulong_t hash;
+};
+
+
+struct file_idx_table_v0 {
+ uint64_t num_files;
+ struct file_hdr_v0 hdrs[0];
+};
+
+struct file_idx_table_v1 {
uint64_t num_files;
- struct file_hdr hdrs[0];
+ struct file_hdr_v1 hdrs[0];
};
char * val = NULL;
if ((child_entry != NULL) && (attrib != NULL)) {
- PrintError("Duplicate Configuration parameters present for %s\n", tag);
+ PrintError(VM_NONE, VCORE_NONE, "Duplicate Configuration parameters present for %s\n", tag);
return NULL;
}
struct v3_config * cfg = NULL;
int offset = 0;
uint_t xml_len = 0;
- struct file_idx_table * files = NULL;
+ struct file_idx_table_v0 * files_v0 = NULL;
+ struct file_idx_table_v1 * files_v1 = NULL;
v3_cfg_tree_t * file_tree = NULL;
+ int version=-1;
- V3_Print("cfg data at %p\n", cfg_blob);
+ V3_Print(VM_NONE, VCORE_NONE, "cfg data at %p\n", cfg_blob);
- if (memcmp(cfg_blob, "v3vee\0\0\0", 8) != 0) {
- PrintError("Invalid Configuration Header\n");
+ if (memcmp(cfg_blob, COOKIE_V0, COOKIE_LEN) == 0) {
+ version = 0;
+ } else if (memcmp(cfg_blob, COOKIE_V1, COOKIE_LEN) == 0) {
+ version = 1;
+ } else {
+ PrintError(VM_NONE, VCORE_NONE, "Invalid Configuration Header Or Unknown Version\n");
return NULL;
- }
+ }
- offset += 8;
+ V3_Print(VM_NONE, VCORE_NONE, "Handling Palacios Image Format, Version 0x%x\n",version);
+
+ offset += COOKIE_LEN;
cfg = (struct v3_config *)V3_Malloc(sizeof(struct v3_config));
if (!cfg) {
- PrintError("Unable to allocate while parsing\n");
+ PrintError(VM_NONE, VCORE_NONE, "Unable to allocate while parsing\n");
return NULL;
}
cfg->file_table = v3_create_htable(0, file_hash_fn, file_eq_fn);
if (!(cfg->file_table)) {
- PrintError("Unable to allocate hash table while parsing\n");
+ PrintError(VM_NONE, VCORE_NONE, "Unable to allocate hash table while parsing\n");
V3_Free(cfg);
return NULL;
}
offset += 8;
- files = (struct file_idx_table *)(cfg_blob + offset);
+ // This is hideous, but the file formats are still very close
+ if (version==0) {
+ files_v0 = (struct file_idx_table_v0 *)(cfg_blob + offset);
+ V3_Print(VM_NONE, VCORE_NONE, "Number of files in cfg: %d\n", (uint32_t)(files_v0->num_files));
+ } else {
+ files_v1 = (struct file_idx_table_v1 *)(cfg_blob + offset);
+ V3_Print(VM_NONE, VCORE_NONE, "Number of files in cfg: %d\n", (uint32_t)(files_v1->num_files));
+ }
- V3_Print("Number of files in cfg: %d\n", (uint32_t)(files->num_files));
file_tree = v3_cfg_subtree(v3_cfg_subtree(cfg->cfg, "files"), "file");
char * id = v3_cfg_val(file_tree, "id");
char * index = v3_cfg_val(file_tree, "index");
int idx = atoi(index);
- struct file_hdr * hdr = &(files->hdrs[idx]);
struct v3_cfg_file * file = NULL;
file = (struct v3_cfg_file *)V3_Malloc(sizeof(struct v3_cfg_file));
if (!file) {
- PrintError("Could not allocate file structure\n");
+ PrintError(VM_NONE, VCORE_NONE, "Could not allocate file structure\n");
v3_free_htable(cfg->file_table,0,0);
V3_Free(cfg);
return NULL;
}
- V3_Print("File index=%d id=%s\n", idx, id);
+ V3_Print(VM_NONE, VCORE_NONE, "File index=%d id=%s\n", idx, id);
strncpy(file->tag, id, V3_MAX_TAG_LEN);
- file->size = hdr->size;
- file->data = cfg_blob + hdr->offset;
-
- V3_Print("Storing file data offset = %d, size=%d\n", (uint32_t)hdr->offset, hdr->size);
- V3_Print("file data at %p\n", file->data);
+ file->tag[V3_MAX_TAG_LEN-1] = 0 ;
+
+ if (version==0) {
+ struct file_hdr_v0 * hdr = &(files_v0->hdrs[idx]);
+
+ file->size = hdr->size;
+ file->data = cfg_blob + hdr->offset;
+ file->hash = 0;
+
+ V3_Print(VM_NONE, VCORE_NONE, "Storing file data offset = %d, size=%d\n", (uint32_t)hdr->offset, hdr->size);
+ V3_Print(VM_NONE, VCORE_NONE, "file data at %p\n", file->data);
+
+ } else if (version==1) {
+ struct file_hdr_v1 * hdr = &(files_v1->hdrs[idx]);
+ unsigned long hash;
+
+ file->size = hdr->size;
+ file->data = cfg_blob + hdr->offset;
+ file->hash = hdr->hash;
+
+ V3_Print(VM_NONE, VCORE_NONE, "Storing file data offset = %d, size=%d\n", (uint32_t)hdr->offset, hdr->size);
+ V3_Print(VM_NONE, VCORE_NONE, "file data at %p\n", file->data);
+ V3_Print(VM_NONE, VCORE_NONE, "Checking file data integrity...\n");
+ if ((hash = v3_hash_buffer(file->data, file->size)) != file->hash) {
+ PrintError(VM_NONE, VCORE_NONE, "File data corrupted! (orig hash=0x%lx, new=0x%lx\n",
+ file->hash, hash);
+ return NULL;
+ }
+ V3_Print(VM_NONE, VCORE_NONE, "File data OK\n");
+
+ }
+
+
list_add( &(file->file_node), &(cfg->file_list));
- V3_Print("Keying file to name\n");
+ V3_Print(VM_NONE, VCORE_NONE, "Keying file to name\n");
v3_htable_insert(cfg->file_table, (addr_t)(file->tag), (addr_t)(file));
- V3_Print("Iterating to next file\n");
+ V3_Print(VM_NONE, VCORE_NONE, "Iterating to next file\n");
file_tree = v3_cfg_next_branch(file_tree);
}
- V3_Print("Configuration parsed successfully\n");
+ V3_Print(VM_NONE, VCORE_NONE, "Configuration parsed successfully\n");
return cfg;
}
#ifndef V3_CONFIG_ALIGNED_PG_ALLOC
if (alignment != PAGE_SIZE_4KB) {
- PrintError("Aligned page allocations are not supported in this host (requested alignment=%d)\n", alignment);
- PrintError("Ignoring alignment request\n");
+ PrintError(VM_NONE, VCORE_NONE, "Aligned page allocations are not supported in this host (requested alignment=%d)\n", alignment);
+ PrintError(VM_NONE, VCORE_NONE, "Ignoring alignment request\n");
+ alignment = PAGE_SIZE_4KB;
}
#endif
}
+
static int pre_config_vm(struct v3_vm_info * vm, v3_cfg_tree_t * vm_cfg) {
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");
char * align_str = v3_cfg_val(v3_cfg_subtree(vm_cfg, "memory"), "alignment");
uint32_t sched_hz = 100; // set the schedule frequency to 100 HZ
-
+
if (!memory_str) {
- PrintError("Memory is a required configuration parameter\n");
+ PrintError(VM_NONE, VCORE_NONE, "Memory is a required configuration parameter\n");
return -1;
}
- PrintDebug("Memory=%s\n", memory_str);
+ PrintDebug(VM_NONE, VCORE_NONE, "Memory=%s\n", memory_str);
if (align_str) {
- PrintDebug("Alignment=%s\n", align_str);
+ PrintDebug(VM_NONE, VCORE_NONE, "Alignment=%s\n", align_str);
} else {
- PrintDebug("Alignment defaulted to 4KB.\n");
+ PrintDebug(VM_NONE, VCORE_NONE, "Alignment defaulted to 4KB.\n");
}
// Amount of ram the Guest will have, always in MB
vm->mem_size = (addr_t)atoi(memory_str) * 1024 * 1024;
vm->mem_align = get_alignment(align_str);
-
- PrintDebug("Alignment for %lu bytes of memory computed as 0x%x\n", vm->mem_size, vm->mem_align);
+ // set up defaults for memory management for threads associated
+ // with this VM
+ vm->resource_control.pg_alignment=vm->mem_align;
+ vm->resource_control.pg_node_id=-1;
+
+#ifdef V3_CONFIG_SWAPPING
+ if (v3_init_swapping_vm(vm,vm_cfg)) {
+ PrintError(vm,VCORE_NONE,"Unable to initialize swapping correctly\n");
+ return -1;
+ }
+ if (vm->swap_state.enable_swapping) {
+ PrintDebug(vm,VCORE_NONE,"Swapping enabled\n");
+ } else {
+ PrintDebug(vm,VCORE_NONE,"Swapping disabled\n");
+ }
+#endif
+
+ PrintDebug(VM_NONE, VCORE_NONE, "Alignment for %lu bytes of memory computed as 0x%x\n", vm->mem_size, vm->mem_align);
if (strcasecmp(vm_class, "PC") == 0) {
vm->vm_class = V3_PC_VM;
} else {
- PrintError("Invalid VM class\n");
+ PrintError(VM_NONE, VCORE_NONE, "Invalid VM class\n");
return -1;
}
#endif
if (v3_init_vm(vm) == -1) {
- PrintError("Failed to initialize VM\n");
+ PrintError(VM_NONE, VCORE_NONE, "Failed to initialize VM\n");
return -1;
}
-
+#ifdef V3_CONFIG_MULTIBOOT
+ if (v3_init_multiboot_vm(vm,vm_cfg)) {
+ PrintError(vm,VCORE_NONE,"Cannot initialize Multiboot for VM\n");
+ return -1;
+ }
+#endif
+#ifdef V3_CONFIG_HVM
+ if (v3_init_hvm_vm(vm,vm_cfg)) {
+ PrintError(vm,VCORE_NONE,"Cannot initialize HVM for VM\n");
+ return -1;
+ }
+#endif
if (schedule_hz_str) {
sched_hz = atoi(schedule_hz_str);
+ if (sched_hz==0) {
+ PrintError(vm,VCORE_NONE,"Cannot set sched Hz to 0\n");
+ return -1;
+ }
}
- PrintDebug("CPU_KHZ = %d, schedule_freq=%p\n", V3_CPU_KHZ(),
+ PrintDebug(VM_NONE, VCORE_NONE, "CPU_KHZ = %d, schedule_freq=%p\n", V3_CPU_KHZ(),
(void *)(addr_t)sched_hz);
vm->yield_cycle_period = (V3_CPU_KHZ() * 1000) / sched_hz;
v3_cfg_tree_t * pg_tree = v3_cfg_subtree(vm_tree, "paging");
char * pg_mode = v3_cfg_val(pg_tree, "mode");
- PrintDebug("Paging mode specified as %s\n", pg_mode);
+ PrintDebug(info->vm_info, info, "Paging mode specified as %s\n", pg_mode);
if (pg_mode) {
if ((strcasecmp(pg_mode, "nested") == 0)) {
(v3_mach_type == V3_VMX_EPT_CPU) ||
(v3_mach_type == V3_VMX_EPT_UG_CPU)) {
- V3_Print("Setting paging mode to NESTED\n");
+ V3_Print(info->vm_info, info, "Setting paging mode to NESTED\n");
info->shdw_pg_mode = NESTED_PAGING;
} else {
- PrintError("Nested paging not supported on this hardware. Defaulting to shadow paging\n");
+ PrintError(info->vm_info, info, "Nested paging not supported on this hardware. Defaulting to shadow paging\n");
info->shdw_pg_mode = SHADOW_PAGING;
}
} else if ((strcasecmp(pg_mode, "shadow") == 0)) {
- V3_Print("Setting paging mode to SHADOW\n");
+ V3_Print(info->vm_info, info, "Setting paging mode to SHADOW\n");
info->shdw_pg_mode = SHADOW_PAGING;
} else {
- PrintError("Invalid paging mode (%s) specified in configuration. Defaulting to shadow paging\n", pg_mode);
+ PrintError(info->vm_info, info, "Invalid paging mode (%s) specified in configuration. Defaulting to shadow paging\n", pg_mode);
info->shdw_pg_mode = SHADOW_PAGING;
}
} else {
- V3_Print("No paging type specified in configuration. Defaulting to shadow paging\n");
+ V3_Print(info->vm_info, info, "No paging type specified in configuration. Defaulting to shadow paging\n");
info->shdw_pg_mode = SHADOW_PAGING;
}
if (v3_cfg_val(pg_tree, "large_pages") != NULL) {
if (strcasecmp(v3_cfg_val(pg_tree, "large_pages"), "true") == 0) {
info->use_large_pages = 1;
- PrintDebug("Use of large pages in memory virtualization enabled.\n");
+ PrintDebug(info->vm_info, info, "Use of large pages in memory virtualization enabled.\n");
}
}
return 0;
}
if (v3_init_core(info) == -1) {
- PrintError("Error Initializing Core\n");
+ PrintError(info->vm_info, info, "Error Initializing Core\n");
+ return -1;
+ }
+
+#ifdef V3_CONFIG_MULTIBOOT
+ if (v3_init_multiboot_core(info)) {
+ PrintError(info->vm_info, info, "Error Initializing Multiboot Core\n");
return -1;
}
+#endif
+#ifdef V3_CONFIG_HVM
+ if (v3_init_hvm_core(info)) {
+ PrintError(info->vm_info, info, "Error Initializing HVM Core\n");
+ return -1;
+ }
+#endif
if (info->vm_info->vm_class == V3_PC_VM) {
if (pre_config_pc_core(info, core_cfg) == -1) {
- PrintError("PC Post configuration failure\n");
+ PrintError(info->vm_info, info, "PC Post configuration failure\n");
return -1;
}
} else {
- PrintError("Invalid VM Class\n");
+ PrintError(info->vm_info, info, "Invalid VM Class\n");
return -1;
}
// Configure the memory map for the guest
if (setup_memory_map(vm, cfg) == -1) {
- PrintError("Setting up guest memory map failed...\n");
+ PrintError(vm, VCORE_NONE,"Setting up guest memory map failed...\n");
return -1;
}
if (vm->vm_class == V3_PC_VM) {
if (post_config_pc(vm, cfg) == -1) {
- PrintError("PC Post configuration failure\n");
+ PrintError(vm, VCORE_NONE,"PC Post configuration failure\n");
return -1;
}
} else {
- PrintError("Invalid VM Class\n");
+ PrintError(vm, VCORE_NONE,"Invalid VM Class\n");
return -1;
}
+
+ // Initialize fw_cfg state for VMM<->VM SEABIOS communication
+ if (v3_fw_cfg_init(vm) == -1) {
+ PrintError(vm, VCORE_NONE, "Error initializing Firmware Config (fw_cfg) state\n");
+ return -1;
+ }
+
/*
* Initialize configured devices
*/
if (setup_devices(vm, cfg) == -1) {
- PrintError("Failed to setup devices\n");
+ PrintError(vm, VCORE_NONE,"Failed to setup devices\n");
return -1;
}
* Initialize configured extensions
*/
if (setup_extensions(vm, cfg) == -1) {
- PrintError("Failed to setup extensions\n");
+ PrintError(vm, VCORE_NONE,"Failed to setup extensions\n");
+ return -1;
+ }
+
+ if (v3_setup_performance_tuning(vm, cfg) == -1) {
+ PrintError(vm, VCORE_NONE,"Failed to configure performance tuning parameters\n");
return -1;
}
if (v3_init_core_extensions(info) == -1) {
- PrintError("Error intializing extension core states\n");
+ PrintError(info->vm_info, info, "Error intializing extension core states\n");
return -1;
}
if (info->vm_info->vm_class == V3_PC_VM) {
if (post_config_pc_core(info, cfg) == -1) {
- PrintError("PC Post configuration failure\n");
+ PrintError(info->vm_info, info, "PC Post configuration failure\n");
return -1;
}
} else {
- PrintError("Invalid VM Class\n");
+ PrintError(info->vm_info, info, "Invalid VM Class\n");
return -1;
}
struct v3_vm_info * vm = V3_Malloc(guest_state_size);
if (!vm) {
- PrintError("Unable to allocate space for guest data structures\n");
+ PrintError(VM_NONE, VCORE_NONE, "Unable to allocate space for guest data structures\n");
return NULL;
}
return vm;
}
+/*
+
+
+*/
struct v3_vm_info * v3_config_guest(void * cfg_blob, void * priv_data) {
v3_cfg_tree_t * cores_cfg = NULL;
v3_cfg_tree_t * per_core_cfg = NULL;
+
if (v3_mach_type == V3_INVALID_CPU) {
- PrintError("Configuring guest on invalid CPU\n");
+ PrintError(VM_NONE, VCORE_NONE, "Configuring guest on invalid CPU\n");
return NULL;
}
cfg_data = parse_config(cfg_blob);
+
if (!cfg_data) {
- PrintError("Could not parse configuration\n");
+ PrintError(VM_NONE, VCORE_NONE, "Could not parse configuration\n");
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");
+ PrintError(VM_NONE, VCORE_NONE, "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");
+ PrintError(VM_NONE, VCORE_NONE, "No cores specified in configuration\n");
return NULL;
}
- V3_Print("Configuring %d cores\n", num_cores);
+ V3_Print(VM_NONE, VCORE_NONE, "Configuring %d cores\n", num_cores);
vm = allocate_guest(num_cores);
if (!vm) {
- PrintError("Could not allocate %d core guest\n", vm->num_cores);
+ PrintError(VM_NONE, VCORE_NONE, "Could not allocate %d core guest\n", num_cores);
return NULL;
}
+#ifdef V3_CONFIG_CACHEPART
+ // Need to initialize cache management and resource control
+ // as early as possible so that allocations are done accordingly
+ if (v3_init_cachepart_vm(vm,cfg_data->cfg)) {
+ PrintError(VM_NONE, VCORE_NONE, "Could not initialize cache partioning\n");
+ V3_Free(vm);
+ return NULL;
+ }
+#endif
+
vm->host_priv_data = priv_data;
vm->cfg_data = cfg_data;
- V3_Print("Preconfiguration\n");
+ V3_Print(vm, VCORE_NONE, "Preconfiguration\n");
if (pre_config_vm(vm, vm->cfg_data->cfg) == -1) {
- PrintError("Error in preconfiguration\n");
+ PrintError(vm, VCORE_NONE, "Error in preconfiguration, attempting to free\n");
+ vm->run_state=VM_ERROR;
+ v3_free_vm(vm);
return NULL;
}
- V3_Print("Per core configuration\n");
+ V3_Print(vm, VCORE_NONE, "Per core configuration\n");
per_core_cfg = v3_cfg_subtree(cores_cfg, "core");
// per core configuration
info->core_cfg_data = per_core_cfg;
if (pre_config_core(info, per_core_cfg) == -1) {
- PrintError("Error in core %d preconfiguration\n", i);
+ PrintError(vm, VCORE_NONE, "Error in core %d preconfiguration, attempting to free guest\n", i);
+ vm->run_state=VM_ERROR;
+ v3_free_vm(vm);
return NULL;
}
}
- V3_Print("Post Configuration\n");
+ V3_Print(vm, VCORE_NONE, "Post Configuration\n");
if (post_config_vm(vm, vm->cfg_data->cfg) == -1) {
- PrintError("Error in postconfiguration\n");
+ PrintError(vm, VCORE_NONE, "Error in postconfiguration, attempting to free guest\n");
+ vm->run_state=VM_ERROR;
+ v3_free_vm(vm);
return NULL;
}
per_core_cfg = v3_cfg_next_branch(per_core_cfg);
}
- V3_Print("Configuration successfull\n");
+ V3_Print(vm, VCORE_NONE, "Configuration successfull\n");
return vm;
}
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",
+ PrintError(vm, VCORE_NONE,"Could not map memory region: %p-%p => %p\n",
(void *)start_addr, (void *)end_addr, (void *)host_addr);
return -1;
}
char * ext_name = v3_cfg_val(extension, "name");
if (!ext_name) {
- PrintError("Extension has no name\n");
+ PrintError(vm, VCORE_NONE, "Extension has no name\n");
return -1;
}
- V3_Print("Configuring extension %s\n", ext_name);
+ V3_Print(vm, VCORE_NONE, "Configuring extension %s\n", ext_name);
if (v3_add_extension(vm, ext_name, extension) == -1) {
- PrintError("Error adding extension %s\n", ext_name);
+ PrintError(vm, VCORE_NONE, "Error adding extension %s\n", ext_name);
return -1;
}
while (device) {
char * dev_class = v3_cfg_val(device, "class");
- V3_Print("configuring device %s\n", dev_class);
+ V3_Print(vm, VCORE_NONE, "configuring device %s\n", dev_class);
if (v3_create_device(vm, dev_class, device) == -1) {
- PrintError("Error creating device %s\n", dev_class);
+ PrintError(vm, VCORE_NONE, "Error creating device %s\n", dev_class);
return -1;
}