#include <geekos/vmm_paging.h>
-
+#include <geekos/vmm.h>
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;i<MAX_PAGE_DIR_ENTRIES;i++) {
+ cur_shadow_pde[i] = cur_guest_pde[i];
+ // The shadow can be identical to the guest if it's not present
+ if (!cur_shadow_pde[i].present) {
+ continue;
+ }
+ if (cur_shadow_pde[i].large_pages) {
+ // large page - just map it through shadow map to generate its physical location
+ addr_t guest_addr = PAGE_ADDR(cur_shadow_pde[i].pt_base_addr);
+ addr_t host_addr;
+ shadow_map_entry_t *ent;
+
+ 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;
+ }
+ // 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;j<MAX_PAGE_TABLE_ENTRIES;j++) {
+ cur_shadow_pte[j] = cur_guest_pte[j];
+
+ addr_t guest_addr = PAGE_ADDR(cur_shadow_pte[j].page_base_addr);
+
+ shadow_map_entry_t *ent;
+
+ 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;
+ }
+
+ 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;
- 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) {
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;
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;
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--;
// error
PrintDebug("Error creating page table...\n");
// cleanup
+ free_guest_page_tables(pde);
return NULL;
}
}
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,
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,
-void PrintPD(pde_t * pde)
+void PrintPD(vmm_pde_t * pde)
{
int i;
}
}
-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]));
}
-void PrintDebugPageTables(pde_t * pde)
+void PrintDebugPageTables(vmm_pde_t * pde)
{
int i;
}
+
+#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