X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=palacios%2Fsrc%2Fpalacios%2Fvmm_mem.c;h=6a4f5da0b576cf7a6e4e333828f69e4d53033cc4;hb=a19f42cc45ff4c4a07bf917a78a2a422319a78bb;hp=95108102427dd9eb8f61e365e5f342fe3d91de07;hpb=f86f45f3cbbd4c85b30a2eee73ff79e2908e1495;p=palacios.git diff --git a/palacios/src/palacios/vmm_mem.c b/palacios/src/palacios/vmm_mem.c index 9510810..6a4f5da 100644 --- a/palacios/src/palacios/vmm_mem.c +++ b/palacios/src/palacios/vmm_mem.c @@ -22,6 +22,7 @@ #include #include #include +#include #include #include @@ -30,7 +31,7 @@ static int mem_offset_hypercall(struct guest_info * info, uint_t hcall_id, void * private_data) { - PrintDebug("V3Vee: Memory offset hypercall (offset=%p)\n", + PrintDebug(info->vm_info, info,"V3Vee: Memory offset hypercall (offset=%p)\n", (void *)(info->vm_info->mem_map.base_region.host_addr)); info->vm_regs.rbx = info->vm_info->mem_map.base_region.host_addr; @@ -41,7 +42,8 @@ static int mem_offset_hypercall(struct guest_info * info, uint_t hcall_id, void static int unhandled_err(struct guest_info * core, addr_t guest_va, addr_t guest_pa, struct v3_mem_region * reg, pf_error_t access_info) { - PrintError("Unhandled memory access error\n"); + PrintError(core->vm_info, core, "Unhandled memory access error (gpa=%p, gva=%p, error_code=%d)\n", + (void *)guest_pa, (void *)guest_va, *(uint32_t *)&access_info); v3_print_mem_map(core->vm_info); @@ -59,17 +61,27 @@ int v3_init_mem_map(struct v3_vm_info * vm) { map->mem_regions.rb_node = NULL; // There is an underlying region that contains all of the guest memory - // PrintDebug("Mapping %d pages of memory (%u bytes)\n", (int)mem_pages, (uint_t)info->mem_size); + // PrintDebug(info->vm_info, info, "Mapping %d pages of memory (%u bytes)\n", (int)mem_pages, (uint_t)info->mem_size); + // 2MB page alignment needed for 2MB hardware nested paging map->base_region.guest_start = 0; map->base_region.guest_end = mem_pages * PAGE_SIZE_4KB; -#ifdef CONFIG_ALIGNED_PG_ALLOC +#ifdef V3_CONFIG_ALIGNED_PG_ALLOC map->base_region.host_addr = (addr_t)V3_AllocAlignedPages(mem_pages, vm->mem_align); #else map->base_region.host_addr = (addr_t)V3_AllocPages(mem_pages); #endif + if ((void*)map->base_region.host_addr == NULL) { + PrintError(vm, VCORE_NONE,"Could not allocate guest memory\n"); + return -1; + } + + // Clear the memory... + memset(V3_VAddr((void *)map->base_region.host_addr), 0, mem_pages * PAGE_SIZE_4KB); + + map->base_region.flags.read = 1; map->base_region.flags.write = 1; map->base_region.flags.exec = 1; @@ -78,13 +90,6 @@ int v3_init_mem_map(struct v3_vm_info * vm) { map->base_region.unhandled = unhandled_err; - if ((void *)map->base_region.host_addr == NULL) { - PrintError("Could not allocate Guest memory\n"); - return -1; - } - - //memset(V3_VAddr((void *)map->base_region.host_addr), 0xffffffff, map->base_region.guest_end); - v3_register_hypercall(vm, MEM_OFFSET_HCALL, mem_offset_hypercall, NULL); return 0; @@ -95,6 +100,7 @@ void v3_delete_mem_map(struct v3_vm_info * vm) { struct rb_node * node = v3_rb_first(&(vm->mem_map.mem_regions)); struct v3_mem_region * reg; struct rb_node * tmp_node = NULL; + addr_t mem_pages = vm->mem_size >> 12; while (node) { reg = rb_entry(node, struct v3_mem_region, tree_node); @@ -104,14 +110,26 @@ void v3_delete_mem_map(struct v3_vm_info * vm) { v3_delete_mem_region(vm, reg); } - V3_FreePage((void *)(vm->mem_map.base_region.host_addr)); + V3_FreePages((void *)(vm->mem_map.base_region.host_addr), mem_pages); } struct v3_mem_region * v3_create_mem_region(struct v3_vm_info * vm, uint16_t core_id, addr_t guest_addr_start, addr_t guest_addr_end) { - - struct v3_mem_region * entry = (struct v3_mem_region *)V3_Malloc(sizeof(struct v3_mem_region)); + struct v3_mem_region * entry = NULL; + + if (guest_addr_start >= guest_addr_end) { + PrintError(vm, VCORE_NONE, "Region start is after region end\n"); + return NULL; + } + + entry = (struct v3_mem_region *)V3_Malloc(sizeof(struct v3_mem_region)); + + if (!entry) { + PrintError(vm, VCORE_NONE, "Cannot allocate in creating a memory region\n"); + return NULL; + } + memset(entry, 0, sizeof(struct v3_mem_region)); entry->guest_start = guest_addr_start; @@ -138,7 +156,6 @@ int v3_add_shadow_mem( struct v3_vm_info * vm, uint16_t core_id, entry->host_addr = host_addr; - entry->flags.read = 1; entry->flags.write = 1; entry->flags.exec = 1; @@ -156,7 +173,7 @@ int v3_add_shadow_mem( struct v3_vm_info * vm, uint16_t core_id, static inline struct v3_mem_region * __insert_mem_region(struct v3_vm_info * vm, - struct v3_mem_region * region) { + struct v3_mem_region * region) { struct rb_node ** p = &(vm->mem_map.mem_regions.rb_node); struct rb_node * parent = NULL; struct v3_mem_region * tmp_region; @@ -172,9 +189,10 @@ struct v3_mem_region * __insert_mem_region(struct v3_vm_info * vm, } else { if ((region->guest_end != tmp_region->guest_end) || (region->guest_start != tmp_region->guest_start)) { - PrintError("Trying to map a partial overlapped core specific page...\n"); + PrintError(vm, VCORE_NONE, "Trying to map a partial overlapped core specific page...\n"); return tmp_region; // This is ugly... } else if (region->core_id == tmp_region->core_id) { + PrintError(vm, VCORE_NONE, "Trying to map a core-overlapping page\n"); return tmp_region; } else if (region->core_id < tmp_region->core_id) { p = &(*p)->rb_left; @@ -196,6 +214,7 @@ int v3_insert_mem_region(struct v3_vm_info * vm, struct v3_mem_region * region) int i = 0; if ((ret = __insert_mem_region(vm, region))) { + PrintError(vm, VCORE_NONE, "Internal insert failed returned region is from 0x%p to 0x%p on vcore %d\n", (void*)(ret->guest_start), (void*)(ret->guest_end), ret->core_id); return -1; } @@ -268,7 +287,7 @@ struct v3_mem_region * v3_get_mem_region(struct v3_vm_info * vm, uint16_t core_i // go right, core too small n = n->rb_right; } else { - PrintDebug("v3_get_mem_region: Impossible!\n"); + PrintDebug(vm, VCORE_NONE, "v3_get_mem_region: Impossible!\n"); return NULL; } } @@ -278,7 +297,7 @@ struct v3_mem_region * v3_get_mem_region(struct v3_vm_info * vm, uint16_t core_i // There is not registered region, so we check if its a valid address in the base region if (guest_addr > vm->mem_map.base_region.guest_end) { - PrintError("Guest Address Exceeds Base Memory Size (ga=0x%p), (limit=0x%p) (core=0x%x)\n", + PrintError(vm, VCORE_NONE, "Guest Address Exceeds Base Memory Size (ga=0x%p), (limit=0x%p) (core=0x%x)\n", (void *)guest_addr, (void *)vm->mem_map.base_region.guest_end, core_id); v3_print_mem_map(vm); @@ -290,44 +309,123 @@ struct v3_mem_region * v3_get_mem_region(struct v3_vm_info * vm, uint16_t core_i -/* Search the "hooked" memory regions for a region that ends after the given address. If the - * address is invalid, return NULL. Else, return the first region found or the base region if no - * region ends after the given address. +/* This returns the next memory region based on a given address. + * If the address falls inside a sub region, that region is returned. + * If the address falls outside a sub region, the next sub region is returned + * NOTE that we have to be careful about core_ids here... */ -struct v3_mem_region * v3_get_next_mem_region( struct v3_vm_info * vm, uint16_t core_id, addr_t guest_addr) { +static struct v3_mem_region * get_next_mem_region( struct v3_vm_info * vm, uint16_t core_id, addr_t guest_addr) { struct rb_node * n = vm->mem_map.mem_regions.rb_node; struct v3_mem_region * reg = NULL; + struct v3_mem_region * parent = NULL; + + if (n == NULL) { + return NULL; + } - // Keep going to the right in the tree while the address is greater than the current region's - // end address. while (n) { - reg = rb_entry(n, struct v3_mem_region, tree_node); - if (guest_addr >= reg->guest_end) { // reg is [start,end) - n = n->rb_right; - } else { - if ((core_id == reg->core_id) || (reg->core_id == V3_MEM_CORE_ANY)) { + + reg = rb_entry(n, struct v3_mem_region, tree_node); + + if (guest_addr < reg->guest_start) { + n = n->rb_left; + } else if (guest_addr >= reg->guest_end) { + n = n->rb_right; + } else { + if (reg->core_id == V3_MEM_CORE_ANY) { + // found relevant region, it's available on all cores return reg; - } else { + } else if (core_id == reg->core_id) { + // found relevant region, it's available on the indicated core + return reg; + } else if (core_id < reg->core_id) { + // go left, core too big + n = n->rb_left; + } else if (core_id > reg->core_id) { + // go right, core too small n = n->rb_right; + } else { + PrintError(vm, VCORE_NONE, "v3_get_mem_region: Impossible!\n"); + return NULL; } - } + } + + if ((reg->core_id == core_id) || (reg->core_id == V3_MEM_CORE_ANY)) { + parent = reg; + } } - // There is no registered region, so we check if it's a valid address in the base region - if (guest_addr >= vm->mem_map.base_region.guest_end) { - PrintError("%s: Guest Address Exceeds Base Memory Size (ga=%p), (limit=%p)\n", - __FUNCTION__, (void *)guest_addr, (void *)vm->mem_map.base_region.guest_end); - v3_print_mem_map(vm); - return NULL; + if (parent->guest_start > guest_addr) { + return parent; + } else if (parent->guest_end < guest_addr) { + struct rb_node * node = &(parent->tree_node); + + while ((node = v3_rb_next(node)) != NULL) { + struct v3_mem_region * next_reg = rb_entry(node, struct v3_mem_region, tree_node); + + if ((next_reg->core_id == V3_MEM_CORE_ANY) || + (next_reg->core_id == core_id)) { + + // This check is not strictly necessary, but it makes it clearer + if (next_reg->guest_start > guest_addr) { + return next_reg; + } + } + } } - return &(vm->mem_map.base_region); + return NULL; } +/* Given an address region of memory, find if there are any regions that overlap with it. + * This checks that the range lies in a single region, and returns that region if it does, + * this can be either the base region or a sub region. + * IF there are multiple regions in the range then it returns NULL + */ +static struct v3_mem_region * get_overlapping_region(struct v3_vm_info * vm, uint16_t core_id, + addr_t start_gpa, addr_t end_gpa) { + struct v3_mem_region * start_region = v3_get_mem_region(vm, core_id, start_gpa); + + if (start_region == NULL) { + PrintError(vm, VCORE_NONE, "Invalid memory region\n"); + return NULL; + } + + + if (start_region->guest_end < end_gpa) { + // Region ends before range + return NULL; + } else if (start_region->flags.base == 0) { + // sub region overlaps range + return start_region; + } else { + // Base region, now we have to scan forward for the next sub region + struct v3_mem_region * next_reg = get_next_mem_region(vm, core_id, start_gpa); + + if (next_reg == NULL) { + // no sub regions after start_addr, base region is ok + return start_region; + } else if (next_reg->guest_start >= end_gpa) { + // Next sub region begins outside range + return start_region; + } else { + return NULL; + } + } + + + // Should never get here + return NULL; +} + + + + + void v3_delete_mem_region(struct v3_vm_info * vm, struct v3_mem_region * reg) { int i = 0; @@ -335,6 +433,19 @@ void v3_delete_mem_region(struct v3_vm_info * vm, struct v3_mem_region * reg) { return; } + + v3_rb_erase(&(reg->tree_node), &(vm->mem_map.mem_regions)); + + + + // If the guest isn't running then there shouldn't be anything to invalidate. + // Page tables should __always__ be created on demand during execution + // NOTE: This is a sanity check, and can be removed if that assumption changes + if (vm->run_state != VM_RUNNING) { + V3_Free(reg); + return; + } + for (i = 0; i < vm->num_cores; i++) { struct guest_info * info = &(vm->cores[i]); @@ -368,8 +479,6 @@ void v3_delete_mem_region(struct v3_vm_info * vm, struct v3_mem_region * reg) { } } - v3_rb_erase(&(reg->tree_node), &(vm->mem_map.mem_regions)); - V3_Free(reg); // flush virtual page tables @@ -377,6 +486,72 @@ void v3_delete_mem_region(struct v3_vm_info * vm, struct v3_mem_region * reg) { } +// Determine if a given address can be handled by a large page of the requested size +uint32_t v3_get_max_page_size(struct guest_info * core, addr_t page_addr, v3_cpu_mode_t mode) { + addr_t pg_start = 0; + addr_t pg_end = 0; + uint32_t page_size = PAGE_SIZE_4KB; + struct v3_mem_region * reg = NULL; + + switch (mode) { + case PROTECTED: + if (core->use_large_pages == 1) { + pg_start = PAGE_ADDR_4MB(page_addr); + pg_end = (pg_start + PAGE_SIZE_4MB); + + reg = get_overlapping_region(core->vm_info, core->vcpu_id, pg_start, pg_end); + + if ((reg) && ((reg->host_addr % PAGE_SIZE_4MB) == 0)) { + page_size = PAGE_SIZE_4MB; + } + } + break; + case PROTECTED_PAE: + if (core->use_large_pages == 1) { + pg_start = PAGE_ADDR_2MB(page_addr); + pg_end = (pg_start + PAGE_SIZE_2MB); + + reg = get_overlapping_region(core->vm_info, core->vcpu_id, pg_start, pg_end); + + if ((reg) && ((reg->host_addr % PAGE_SIZE_2MB) == 0)) { + page_size = PAGE_SIZE_2MB; + } + } + break; + case LONG: + case LONG_32_COMPAT: + case LONG_16_COMPAT: + if (core->use_giant_pages == 1) { + pg_start = PAGE_ADDR_1GB(page_addr); + pg_end = (pg_start + PAGE_SIZE_1GB); + + reg = get_overlapping_region(core->vm_info, core->vcpu_id, pg_start, pg_end); + + if ((reg) && ((reg->host_addr % PAGE_SIZE_1GB) == 0)) { + page_size = PAGE_SIZE_1GB; + break; + } + } + + if (core->use_large_pages == 1) { + pg_start = PAGE_ADDR_2MB(page_addr); + pg_end = (pg_start + PAGE_SIZE_2MB); + + reg = get_overlapping_region(core->vm_info, core->vcpu_id, pg_start, pg_end); + + if ((reg) && ((reg->host_addr % PAGE_SIZE_2MB) == 0)) { + page_size = PAGE_SIZE_2MB; + } + } + break; + default: + PrintError(core->vm_info, core, "Invalid CPU mode: %s\n", v3_cpu_mode_to_str(v3_get_vm_cpu_mode(core))); + return -1; + } + + return page_size; +} + void v3_print_mem_map(struct v3_vm_info * vm) { @@ -384,10 +559,10 @@ void v3_print_mem_map(struct v3_vm_info * vm) { struct v3_mem_region * reg = &(vm->mem_map.base_region); int i = 0; - V3_Print("Memory Layout (all cores):\n"); + V3_Print(vm, VCORE_NONE, "Memory Layout (all cores):\n"); - V3_Print("Base Region (all cores): 0x%p - 0x%p -> 0x%p\n", + V3_Print(vm, VCORE_NONE, "Base Region (all cores): 0x%p - 0x%p -> 0x%p\n", (void *)(reg->guest_start), (void *)(reg->guest_end - 1), (void *)(reg->host_addr)); @@ -401,12 +576,12 @@ void v3_print_mem_map(struct v3_vm_info * vm) { do { reg = rb_entry(node, struct v3_mem_region, tree_node); - V3_Print("%d: 0x%p - 0x%p -> 0x%p\n", i, + V3_Print(vm, VCORE_NONE, "%d: 0x%p - 0x%p -> 0x%p\n", i, (void *)(reg->guest_start), (void *)(reg->guest_end - 1), (void *)(reg->host_addr)); - V3_Print("\t(flags=0x%x) (core=0x%x) (unhandled = 0x%p)\n", + V3_Print(vm, VCORE_NONE, "\t(flags=0x%x) (core=0x%x) (unhandled = 0x%p)\n", reg->flags.value, reg->core_id, reg->unhandled);