X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=palacios%2Fsrc%2Fgeekos%2Fvmm_paging.c;h=4c1469d53527d9f57e653d349fbeee514806de79;hb=271ad3fd89672d441db3c5ffa673ee649e4ce532;hp=81719a4484134f5c8306002bc5edbaacb18756b0;hpb=190b2ef9470c23c275754b74745933d973f8c439;p=palacios.git diff --git a/palacios/src/geekos/vmm_paging.c b/palacios/src/geekos/vmm_paging.c index 81719a4..4c1469d 100644 --- a/palacios/src/geekos/vmm_paging.c +++ b/palacios/src/geekos/vmm_paging.c @@ -1,19 +1,225 @@ #include - +#include 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) && (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); +} + + +int init_shadow_paging_state(shadow_paging_state_t *state) +{ + state->guest_page_directory_type=state->shadow_page_directory_type=PDE32; + + state->guest_page_directory=state->shadow_page_directory=NULL; + + init_shadow_map(&(state->shadow_map)); + return 0; +} + + +int wholesale_update_shadow_paging_state(shadow_paging_state_t *state) +{ + unsigned i, j; + vmm_pde_t *cur_guest_pde, *cur_shadow_pde; + vmm_pte_t *cur_guest_pte, *cur_shadow_pte; + + // For now, we'll only work with PDE32 + if (state->guest_page_directory_type!=PDE32) { + return -1; + } + + cur_shadow_pde=(vmm_pde_t*)(state->shadow_page_directory); + + cur_guest_pde = (vmm_pde_t*)(os_hooks->physical_to_virtual(state->guest_page_directory)); + + // Delete the current page table + delete_page_tables_pde32(cur_shadow_pde); + + cur_shadow_pde = os_hooks->allocate_pages(1); + + state->shadow_page_directory = cur_shadow_pde; + state->shadow_page_directory_type=PDE32; + + for (i=0;ishadow_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 (map_guest_physical_to_host_physical(ent,guest_addr,&host_addr)) { + // Panic here + return -1; + } + cur_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 + cur_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 + cur_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 { + addr_t host_addr; + addr_t guest_addr; + + // small page - set PDE and follow down to the child table + cur_shadow_pde[i] = cur_guest_pde[i]; + + // Allocate a new second level page table for the shadow + cur_shadow_pte = os_hooks->allocate_pages(1); + + // make our first level page table in teh shadow point to it + cur_shadow_pde[i].pt_base_addr = PAGE_ALIGNED_ADDR(cur_shadow_pte); + + shadow_map_entry_t *ent; + + guest_addr=PAGE_ADDR(cur_guest_pde[i].pt_base_addr); + + ent = get_shadow_map_region_by_addr(&(state->shadow_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; + } + + // Address of the relevant second level page table in the guest + if (map_guest_physical_to_host_physical(ent,guest_addr,&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 + cur_guest_pte = os_hooks->physical_to_virtual((void*)host_addr); + + // Now we walk through the second level guest page table + // and clone it into the shadow + for (j=0;jshadow_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: + // points into currently allocated physical memory, so we just + // set up the shadow to point to the mapped location + if (map_guest_physical_to_host_physical(ent,guest_addr,&host_addr)) { + // Panic here + return -1; + } + cur_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 + cur_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 + cur_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; +} + + + +#if 0 /* We generate a page table to correspond to a given memory layout * pulling pages from the mem_list when necessary * If there are any gaps in the layout, we add them as unmapped pages */ -pde_t * generate_guest_page_tables(vmm_mem_layout_t * layout, vmm_mem_list_t * list) { +vmm_pde_t * generate_guest_page_tables(vmm_mem_layout_t * layout, vmm_mem_list_t * list) { ullong_t current_page_addr = 0; uint_t layout_index = 0; uint_t list_index = 0; @@ -24,7 +230,7 @@ pde_t * generate_guest_page_tables(vmm_mem_layout_t * layout, vmm_mem_list_t * l - pde_t * pde = os_hooks->allocate_pages(1); + vmm_pde_t * pde = os_hooks->allocate_pages(1); for (i = 0; i < MAX_PAGE_DIR_ENTRIES; i++) { if (num_entries == 0) { @@ -37,7 +243,7 @@ pde_t * generate_guest_page_tables(vmm_mem_layout_t * layout, vmm_mem_list_t * l pde[i].vmm_info = 0; pde[i].pt_base_addr = 0; } else { - pte_t * pte = os_hooks->allocate_pages(1); + vmm_pte_t * pte = os_hooks->allocate_pages(1); pde[i].present = 1; pde[i].flags = VM_READ | VM_WRITE | VM_EXEC | VM_USER; @@ -67,7 +273,7 @@ pde_t * generate_guest_page_tables(vmm_mem_layout_t * layout, vmm_mem_list_t * l 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_layout_cursor(layout, layout_addr); + layout_region_t * page_region = get_mem_layout_region(layout, layout_addr); if (page_region->type == UNMAPPED) { pte[j].present = 0; @@ -86,17 +292,25 @@ pde_t * generate_guest_page_tables(vmm_mem_layout_t * layout, vmm_mem_list_t * l if (page_region->type == UNMAPPED) { pte[j].page_base_addr = 0; } else if (page_region->type == SHARED) { - pte[j].page_base_addr = page_region->host_addr >> 12; + 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.... + // 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--; @@ -106,6 +320,7 @@ pde_t * generate_guest_page_tables(vmm_mem_layout_t * layout, vmm_mem_list_t * l // error PrintDebug("Error creating page table...\n"); // cleanup + free_guest_page_tables(pde); return NULL; } } @@ -115,10 +330,13 @@ pde_t * generate_guest_page_tables(vmm_mem_layout_t * layout, vmm_mem_list_t * l return pde; } +#endif + -void PrintPDE(void * virtual_address, pde_t * pde) + +void PrintPDE(void * virtual_address, vmm_pde_t * pde) { PrintDebug("PDE %p -> %p : present=%x, flags=%x, accessed=%x, reserved=%x, largePages=%x, globalPage=%x, kernelInfo=%x\n", virtual_address, @@ -132,7 +350,7 @@ void PrintPDE(void * virtual_address, pde_t * pde) pde->vmm_info); } -void PrintPTE(void * virtual_address, pte_t * pte) +void PrintPTE(void * virtual_address, vmm_pte_t * pte) { PrintDebug("PTE %p -> %p : present=%x, flags=%x, accessed=%x, dirty=%x, pteAttribute=%x, globalPage=%x, vmm_info=%x\n", virtual_address, @@ -148,7 +366,7 @@ void PrintPTE(void * virtual_address, pte_t * pte) -void PrintPD(pde_t * pde) +void PrintPD(vmm_pde_t * pde) { int i; @@ -158,11 +376,11 @@ void PrintPD(pde_t * pde) } } -void PrintPT(void * starting_address, pte_t * pte) +void PrintPT(void * starting_address, vmm_pte_t * pte) { int i; - // PrintDebug("Page Table at %p:\n", pte); + PrintDebug("Page Table at %p:\n", pte); for (i = 0; (i < MAX_PAGE_TABLE_ENTRIES) && pte[i].present; i++) { PrintPTE(starting_address + (PAGE_SIZE * i), &(pte[i])); } @@ -172,7 +390,7 @@ void PrintPT(void * starting_address, pte_t * pte) -void PrintDebugPageTables(pde_t * pde) +void PrintDebugPageTables(vmm_pde_t * pde) { int i; @@ -185,3 +403,198 @@ void PrintDebugPageTables(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