X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=palacios%2Fsrc%2Fgeekos%2Fvmm_paging.c;h=5daea0fa938e6a84bfff6abaea5cca0a99348cc3;hb=3f025fd4e0e535801836faa4259b94b18b94f231;hp=879d68af6ba8d171660fb562730a681b0f633786;hpb=4939ecae04ce6416f404670640620a23aee9b914;p=palacios.git diff --git a/palacios/src/geekos/vmm_paging.c b/palacios/src/geekos/vmm_paging.c index 879d68a..5daea0f 100644 --- a/palacios/src/geekos/vmm_paging.c +++ b/palacios/src/geekos/vmm_paging.c @@ -6,6 +6,230 @@ extern struct vmm_os_hooks * os_hooks; +void delete_page_tables_pde32(vmm_pde_t * pde) { + int i, j; + + if (pde == NULL) { + return; + } + + for (i = 0; (i < MAX_PAGE_DIR_ENTRIES); i++) { + if (pde[i].present) { + vmm_pte_t * pte = (vmm_pte_t *)(pde[i].pt_base_addr << PAGE_POWER); + + for (j = 0; (j < MAX_PAGE_TABLE_ENTRIES); j++) { + if ((pte[j].present)) { + os_hooks->free_page((void *)(pte[j].page_base_addr << PAGE_POWER)); + } + } + + os_hooks->free_page(pte); + } + } + + os_hooks->free_page(pde); +} + + +int init_shadow_page_state(shadow_page_state_t * state) { + state->guest_mode = PDE32; + state->shadow_mode = PDE32; + + state->guest_cr3.r_reg = 0; + state->shadow_cr3.r_reg = 0; + + return 0; +} + + +int wholesale_update_shadow_page_state(shadow_page_state_t * state, shadow_map_t * mem_map) { + unsigned i, j; + vmm_pde_t * guest_pde; + vmm_pde_t * shadow_pde; + + + // For now, we'll only work with PDE32 + if (state->guest_mode != PDE32) { + return -1; + } + + + + shadow_pde = (vmm_pde_t *)(CR3_TO_PDE(state->shadow_cr3.e_reg.low)); + guest_pde = (vmm_pde_t *)(os_hooks->paddr_to_vaddr((void*)CR3_TO_PDE(state->guest_cr3.e_reg.low))); + + // Delete the current page table + delete_page_tables_pde32(shadow_pde); + + shadow_pde = os_hooks->allocate_pages(1); + + + state->shadow_cr3.e_reg.low = (addr_t)shadow_pde; + + state->shadow_mode = PDE32; + + + for (i = 0; i < MAX_PAGE_DIR_ENTRIES; i++) { + shadow_pde[i] = guest_pde[i]; + + // The shadow can be identical to the guest if it's not present + if (!shadow_pde[i].present) { + continue; + } + + if (shadow_pde[i].large_pages) { + // large page - just map it through shadow map to generate its physical location + addr_t guest_addr = PAGE_ADDR(shadow_pde[i].pt_base_addr); + addr_t host_addr; + shadow_region_t * ent; + + ent = get_shadow_region_by_addr(mem_map, guest_addr); + + if (!ent) { + // FIXME Panic here - guest is trying to map to physical memory + // it does not own in any way! + return -1; + } + + // FIXME Bounds check here to see if it's trying to trick us + + switch (ent->host_type) { + case HOST_REGION_PHYSICAL_MEMORY: + // points into currently allocated physical memory, so we just + // set up the shadow to point to the mapped location + if (guest_paddr_to_host_paddr(ent, guest_addr, &host_addr)) { + // Panic here + return -1; + } + + shadow_pde[i].pt_base_addr = PAGE_ALIGNED_ADDR(host_addr); + // FIXME set vmm_info bits here + break; + case HOST_REGION_UNALLOCATED: + // points to physical memory that is *allowed* but that we + // have not yet allocated. We mark as not present and set a + // bit to remind us to allocate it later + shadow_pde[i].present = 0; + // FIXME Set vminfo bits here so that we know that we will be + // allocating it later + break; + case HOST_REGION_NOTHING: + // points to physical memory that is NOT ALLOWED. + // We will mark it as not present and set a bit to remind + // us that it's bad later and insert a GPF then + shadow_pde[i].present = 0; + break; + case HOST_REGION_MEMORY_MAPPED_DEVICE: + case HOST_REGION_REMOTE: + case HOST_REGION_SWAPPED: + default: + // Panic. Currently unhandled + return -1; + break; + } + } else { + vmm_pte_t * guest_pte; + vmm_pte_t * shadow_pte; + addr_t guest_addr; + addr_t guest_pte_host_addr; + shadow_region_t * ent; + + // small page - set PDE and follow down to the child table + shadow_pde[i] = guest_pde[i]; + + guest_addr = PAGE_ADDR(guest_pde[i].pt_base_addr); + + // Allocate a new second level page table for the shadow + shadow_pte = os_hooks->allocate_pages(1); + + // make our first level page table in the shadow point to it + shadow_pde[i].pt_base_addr = PAGE_ALIGNED_ADDR(shadow_pte); + + ent = get_shadow_region_by_addr(mem_map, guest_addr); + + + /* JRL: This is bad.... */ + // For now the guest Page Table must always be mapped to host physical memory + /* If we swap out a page table or if it isn't present for some reason, this turns real ugly */ + + if ((!ent) || (ent->host_type != HOST_REGION_PHYSICAL_MEMORY)) { + // FIXME Panic here - guest is trying to map to physical memory + // it does not own in any way! + return -1; + } + + // Address of the relevant second level page table in the guest + if (guest_paddr_to_host_paddr(ent, guest_addr, &guest_pte_host_addr)) { + // Panic here + return -1; + } + + + // host_addr now contains the host physical address for the guest's 2nd level page table + // Now we transform it to relevant virtual address + guest_pte = os_hooks->paddr_to_vaddr((void *)guest_pte_host_addr); + + // Now we walk through the second level guest page table + // and clone it into the shadow + for (j = 0; j < MAX_PAGE_TABLE_ENTRIES; j++) { + shadow_pte[j] = guest_pte[j]; + + addr_t guest_addr = PAGE_ADDR(shadow_pte[j].page_base_addr); + + shadow_region_t * ent; + + ent = get_shadow_region_by_addr(mem_map, guest_addr); + + if (!ent) { + // FIXME Panic here - guest is trying to map to physical memory + // it does not own in any way! + return -1; + } + + switch (ent->host_type) { + case HOST_REGION_PHYSICAL_MEMORY: + { + addr_t host_addr; + + // points into currently allocated physical memory, so we just + // set up the shadow to point to the mapped location + if (guest_paddr_to_host_paddr(ent, guest_addr, &host_addr)) { + // Panic here + return -1; + } + + shadow_pte[j].page_base_addr = PAGE_ALIGNED_ADDR(host_addr); + // FIXME set vmm_info bits here + break; + } + case HOST_REGION_UNALLOCATED: + // points to physical memory that is *allowed* but that we + // have not yet allocated. We mark as not present and set a + // bit to remind us to allocate it later + shadow_pte[j].present = 0; + // FIXME Set vminfo bits here so that we know that we will be + // allocating it later + break; + case HOST_REGION_NOTHING: + // points to physical memory that is NOT ALLOWED. + // We will mark it as not present and set a bit to remind + // us that it's bad later and insert a GPF then + shadow_pte[j].present = 0; + break; + case HOST_REGION_MEMORY_MAPPED_DEVICE: + case HOST_REGION_REMOTE: + case HOST_REGION_SWAPPED: + default: + // Panic. Currently unhandled + return -1; + break; + } + } + } + } + return 0; +} + @@ -13,21 +237,63 @@ extern struct vmm_os_hooks * os_hooks; * pulling pages from the mem_list when necessary * If there are any gaps in the layout, we add them as unmapped pages */ -vmm_pde_t * generate_guest_page_tables(vmm_mem_layout_t * layout, vmm_mem_list_t * list) { +vmm_pde_t * create_passthrough_pde32_pts(shadow_map_t * map) { ullong_t current_page_addr = 0; - uint_t layout_index = 0; - uint_t list_index = 0; - ullong_t layout_addr = 0; int i, j; - uint_t num_entries = layout->num_pages; // The number of pages left in the layout - - vmm_pde_t * pde = os_hooks->allocate_pages(1); for (i = 0; i < MAX_PAGE_DIR_ENTRIES; i++) { - if (num_entries == 0) { + int pte_present = 0; + vmm_pte_t * pte = os_hooks->allocate_pages(1); + + + for (j = 0; j < MAX_PAGE_TABLE_ENTRIES; j++) { + shadow_region_t * region = get_shadow_region_by_addr(map, current_page_addr); + + if (!region || + (region->host_type == HOST_REGION_NOTHING) || + (region->host_type == HOST_REGION_UNALLOCATED) || + (region->host_type == HOST_REGION_MEMORY_MAPPED_DEVICE) || + (region->host_type == HOST_REGION_REMOTE) || + (region->host_type == HOST_REGION_SWAPPED)) { + pte[j].present = 0; + pte[j].flags = 0; + pte[j].accessed = 0; + pte[j].dirty = 0; + pte[j].pte_attr = 0; + pte[j].global_page = 0; + pte[j].vmm_info = 0; + pte[j].page_base_addr = 0; + } else { + addr_t host_addr; + pte[j].present = 1; + pte[j].flags = VM_READ | VM_WRITE | VM_EXEC | VM_USER; + + pte[j].accessed = 0; + pte[j].dirty = 0; + pte[j].pte_attr = 0; + pte[j].global_page = 0; + pte[j].vmm_info = 0; + + if (guest_paddr_to_host_paddr(region, current_page_addr, &host_addr) == -1) { + // BIG ERROR + // PANIC + return NULL; + } + + pte[j].page_base_addr = host_addr >> 12; + + pte_present = 1; + } + + current_page_addr += PAGE_SIZE; + } + + if (pte_present == 0) { + os_hooks->free_page(pte); + pde[i].present = 0; pde[i].flags = 0; pde[i].accessed = 0; @@ -37,8 +303,6 @@ vmm_pde_t * generate_guest_page_tables(vmm_mem_layout_t * layout, vmm_mem_list_t pde[i].vmm_info = 0; pde[i].pt_base_addr = 0; } else { - vmm_pte_t * pte = os_hooks->allocate_pages(1); - pde[i].present = 1; pde[i].flags = VM_READ | VM_WRITE | VM_EXEC | VM_USER; pde[i].accessed = 0; @@ -46,106 +310,17 @@ vmm_pde_t * generate_guest_page_tables(vmm_mem_layout_t * layout, vmm_mem_list_t pde[i].large_pages = 0; pde[i].global_page = 0; pde[i].vmm_info = 0; - pde[i].pt_base_addr = PAGE_ALLIGNED_ADDR(pte); - - - - for (j = 0; j < MAX_PAGE_TABLE_ENTRIES; j++) { - layout_addr = get_mem_layout_addr(layout, layout_index); - - if ((current_page_addr < layout_addr) || (num_entries == 0)) { - // We have a gap in the layout, fill with unmapped page - pte[j].present = 0; - pte[j].flags = 0; - pte[j].accessed = 0; - pte[j].dirty = 0; - pte[j].pte_attr = 0; - pte[j].global_page = 0; - pte[j].vmm_info = 0; - pte[j].page_base_addr = 0; - - current_page_addr += PAGE_SIZE; - } else if (current_page_addr == layout_addr) { - // Set up the Table entry to map correctly to the layout region - layout_region_t * page_region = get_mem_layout_region(layout, layout_addr); - - if (page_region->type == UNMAPPED) { - pte[j].present = 0; - pte[j].flags = 0; - } else { - pte[j].present = 1; - pte[j].flags = VM_READ | VM_WRITE | VM_EXEC | VM_USER; - } - - pte[j].accessed = 0; - pte[j].dirty = 0; - pte[j].pte_attr = 0; - pte[j].global_page = 0; - pte[j].vmm_info = 0; - - if (page_region->type == UNMAPPED) { - pte[j].page_base_addr = 0; - } else if (page_region->type == SHARED) { - addr_t host_addr = page_region->host_addr + (layout_addr - page_region->start); - - pte[j].page_base_addr = host_addr >> 12; - pte[j].vmm_info = SHARED_PAGE; - } else if (page_region->type == GUEST) { - addr_t list_addr = get_mem_list_addr(list, list_index++); - - if (list_addr == -1) { - // error - // cleanup... - free_guest_page_tables(pde); - return NULL; - } - PrintDebug("Adding guest page (%x)\n", list_addr); - pte[j].page_base_addr = list_addr >> 12; - - // Reset this when we move over to dynamic page allocation - // pte[j].vmm_info = GUEST_PAGE; - pte[j].vmm_info = SHARED_PAGE; - } - - num_entries--; - current_page_addr += PAGE_SIZE; - layout_index++; - } else { - // error - PrintDebug("Error creating page table...\n"); - // cleanup - free_guest_page_tables(pde); - return NULL; - } - } + pde[i].pt_base_addr = PAGE_ALIGNED_ADDR(pte); } + } return pde; } -void free_guest_page_tables(vmm_pde_t * pde) { - int i, j; - for (i = 0; (i < MAX_PAGE_DIR_ENTRIES); i++) { - if (pde[i].present) { - vmm_pte_t * pte = (vmm_pte_t *)(pde[i].pt_base_addr << PAGE_POWER); - - for (j = 0; (j < MAX_PAGE_TABLE_ENTRIES); j++) { - if ((pte[j].present) && (pte[j].vmm_info & GUEST_PAGE)){ - os_hooks->free_page((void *)(pte[j].page_base_addr << PAGE_POWER)); - } - } - - os_hooks->free_page(pte); - } - } - - os_hooks->free_page(pde); -} - @@ -216,3 +391,198 @@ void PrintDebugPageTables(vmm_pde_t * pde) } + +#if 0 + +pml4e64_t * generate_guest_page_tables_64(vmm_mem_layout_t * layout, vmm_mem_list_t * list) { + pml4e64_t * pml = os_hooks->allocate_pages(1); + int i, j, k, m; + ullong_t current_page_addr = 0; + uint_t layout_index = 0; + uint_t list_index = 0; + ullong_t layout_addr = 0; + uint_t num_entries = layout->num_pages; // The number of pages left in the layout + + for (m = 0; m < MAX_PAGE_MAP_ENTRIES_64; m++ ) { + if (num_entries == 0) { + pml[m].present = 0; + pml[m].writable = 0; + pml[m].user = 0; + pml[m].pwt = 0; + pml[m].pcd = 0; + pml[m].accessed = 0; + pml[m].reserved = 0; + pml[m].zero = 0; + pml[m].vmm_info = 0; + pml[m].pdp_base_addr_lo = 0; + pml[m].pdp_base_addr_hi = 0; + pml[m].available = 0; + pml[m].no_execute = 0; + } else { + pdpe64_t * pdpe = os_hooks->allocate_pages(1); + + pml[m].present = 1; + pml[m].writable = 1; + pml[m].user = 1; + pml[m].pwt = 0; + pml[m].pcd = 0; + pml[m].accessed = 0; + pml[m].reserved = 0; + pml[m].zero = 0; + pml[m].vmm_info = 0; + pml[m].pdp_base_addr_lo = PAGE_ALLIGNED_ADDR(pdpe) & 0xfffff; + pml[m].pdp_base_addr_hi = 0; + pml[m].available = 0; + pml[m].no_execute = 0; + + for (k = 0; k < MAX_PAGE_DIR_PTR_ENTRIES_64; k++) { + if (num_entries == 0) { + pdpe[k].present = 0; + pdpe[k].writable = 0; + pdpe[k].user = 0; + pdpe[k].pwt = 0; + pdpe[k].pcd = 0; + pdpe[k].accessed = 0; + pdpe[k].reserved = 0; + pdpe[k].large_pages = 0; + pdpe[k].zero = 0; + pdpe[k].vmm_info = 0; + pdpe[k].pd_base_addr_lo = 0; + pdpe[k].pd_base_addr_hi = 0; + pdpe[k].available = 0; + pdpe[k].no_execute = 0; + } else { + pde64_t * pde = os_hooks->allocate_pages(1); + + pdpe[k].present = 1; + pdpe[k].writable = 1; + pdpe[k].user = 1; + pdpe[k].pwt = 0; + pdpe[k].pcd = 0; + pdpe[k].accessed = 0; + pdpe[k].reserved = 0; + pdpe[k].large_pages = 0; + pdpe[k].zero = 0; + pdpe[k].vmm_info = 0; + pdpe[k].pd_base_addr_lo = PAGE_ALLIGNED_ADDR(pde) & 0xfffff; + pdpe[k].pd_base_addr_hi = 0; + pdpe[k].available = 0; + pdpe[k].no_execute = 0; + + + + for (i = 0; i < MAX_PAGE_DIR_ENTRIES_64; i++) { + if (num_entries == 0) { + pde[i].present = 0; + pde[i].flags = 0; + pde[i].accessed = 0; + pde[i].reserved = 0; + pde[i].large_pages = 0; + pde[i].reserved2 = 0; + pde[i].vmm_info = 0; + pde[i].pt_base_addr_lo = 0; + pde[i].pt_base_addr_hi = 0; + pde[i].available = 0; + pde[i].no_execute = 0; + } else { + pte64_t * pte = os_hooks->allocate_pages(1); + + pde[i].present = 1; + pde[i].flags = VM_READ | VM_WRITE | VM_EXEC | VM_USER; + pde[i].accessed = 0; + pde[i].reserved = 0; + pde[i].large_pages = 0; + pde[i].reserved2 = 0; + pde[i].vmm_info = 0; + pde[i].pt_base_addr_lo = PAGE_ALLIGNED_ADDR(pte) & 0xfffff; + pde[i].pt_base_addr_hi = 0; + pde[i].available = 0; + pde[i].no_execute = 0; + + + for (j = 0; j < MAX_PAGE_TABLE_ENTRIES_64; j++) { + layout_addr = get_mem_layout_addr(layout, layout_index); + + if ((current_page_addr < layout_addr) || (num_entries == 0)) { + // We have a gap in the layout, fill with unmapped page + pte[j].present = 0; + pte[j].flags = 0; + pte[j].accessed = 0; + pte[j].dirty = 0; + pte[j].pte_attr = 0; + pte[j].global_page = 0; + pte[j].vmm_info = 0; + pte[j].page_base_addr_lo = 0; + pte[j].page_base_addr_hi = 0; + pte[j].available = 0; + pte[j].no_execute = 0; + + current_page_addr += PAGE_SIZE; + } else if (current_page_addr == layout_addr) { + // Set up the Table entry to map correctly to the layout region + layout_region_t * page_region = get_mem_layout_region(layout, layout_addr); + + if (page_region->type == UNMAPPED) { + pte[j].present = 0; + pte[j].flags = 0; + } else { + pte[j].present = 1; + pte[j].flags = VM_READ | VM_WRITE | VM_EXEC | VM_USER; + } + + pte[j].accessed = 0; + pte[j].dirty = 0; + pte[j].pte_attr = 0; + pte[j].global_page = 0; + pte[j].vmm_info = 0; + pte[j].available = 0; + pte[j].no_execute = 0; + + if (page_region->type == UNMAPPED) { + pte[j].page_base_addr_lo = 0; + pte[j].page_base_addr_hi = 0; + } else if (page_region->type == SHARED) { + addr_t host_addr = page_region->host_addr + (layout_addr - page_region->start); + + pte[j].page_base_addr_lo = PAGE_ALLIGNED_ADDR(host_addr) & 0xfffff; + pte[j].page_base_addr_hi = 0; + pte[j].vmm_info = SHARED_PAGE; + } else if (page_region->type == GUEST) { + addr_t list_addr = get_mem_list_addr(list, list_index++); + + if (list_addr == -1) { + // error + // cleanup... + //free_guest_page_tables(pde); + return NULL; + } + PrintDebug("Adding guest page (%x)\n", list_addr); + pte[j].page_base_addr_lo = PAGE_ALLIGNED_ADDR(list_addr) & 0xfffff; + pte[j].page_base_addr_hi = 0; + + // Reset this when we move over to dynamic page allocation + // pte[j].vmm_info = GUEST_PAGE; + pte[j].vmm_info = SHARED_PAGE; + } + + num_entries--; + current_page_addr += PAGE_SIZE; + layout_index++; + } else { + // error + PrintDebug("Error creating page table...\n"); + // cleanup + // free_guest_page_tables64(pde); + return NULL; + } + } + } + } + } + } + } + } + return pml; +} + +#endif