+/*
+ * This file is part of the Palacios Virtual Machine Monitor developed
+ * by the V3VEE Project with funding from the United States National
+ * Science Foundation and the Department of Energy.
+ *
+ * The V3VEE Project is a joint project between Northwestern University
+ * and the University of New Mexico. You can find out more at
+ * http://www.v3vee.org
+ *
+ * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu>
+ * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
+ * All rights reserved.
+ *
+ * Author: Jack Lange <jarusl@cs.northwestern.edu>
+ *
+ * This is free software. You are permitted to use,
+ * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
+ */
+
#include <palacios/vmm_paging.h>
#include <palacios/vmm.h>
#include <palacios/vm_guest_mem.h>
-extern struct vmm_os_hooks * os_hooks;
+
void delete_page_tables_pde32(pde32_t * pde) {
- int i, j;
+ int i;//, j;
if (pde == NULL) {
return;
for (i = 0; (i < MAX_PDE32_ENTRIES); i++) {
if (pde[i].present) {
- pte32_t * pte = (pte32_t *)(pde[i].pt_base_addr << PAGE_POWER);
-
- for (j = 0; (j < MAX_PTE32_ENTRIES); j++) {
+ // We double cast, first to an addr_t to handle 64 bit issues, then to the pointer
+ pte32_t * pte = (pte32_t *)((addr_t)(pde[i].pt_base_addr << PAGE_POWER));
+
+ /*
+ for (j = 0; (j < MAX_PTE32_ENTRIES); j++) {
if ((pte[j].present)) {
- os_hooks->free_page((void *)(pte[j].page_base_addr << PAGE_POWER));
+ os_hooks->free_page((void *)(pte[j].page_base_addr << PAGE_POWER));
}
- }
-
- os_hooks->free_page(pte);
+ }
+ */
+ //PrintDebug("Deleting PTE %d (%x)\n", i, pte);
+ V3_FreePage(pte);
}
}
- os_hooks->free_page(pde);
+ // PrintDebug("Deleting PDE (%x)\n", pde);
+ V3_FreePage(V3_PAddr(pde));
}
+int pt32_lookup(pde32_t * pd, addr_t vaddr, addr_t * paddr) {
+ addr_t pde_entry;
+ pde32_entry_type_t pde_entry_type;
+
+ if (pd == 0) {
+ return -1;
+ }
+
+ pde_entry_type = pde32_lookup(pd, vaddr, &pde_entry);
+
+ if (pde_entry_type == PDE32_ENTRY_PTE32) {
+ return pte32_lookup((pte32_t *)pde_entry, vaddr, paddr);
+ } else if (pde_entry_type == PDE32_ENTRY_LARGE_PAGE) {
+ *paddr = pde_entry;
+ return 0;
+ }
+
+ return -1;
+}
+
/* We can't do a full lookup because we don't know what context the page tables are in...
* The entry addresses could be pointing to either guest physical memory or host physical memory
* Instead we just return the entry address, and a flag to show if it points to a pte or a large page...
*/
-pde32_entry_type_t pde32_lookup(pde32_t * pde, addr_t addr, addr_t * entry) {
- pde32_t * pde_entry = &(pde[PDE32_INDEX(addr)]);
+pde32_entry_type_t pde32_lookup(pde32_t * pd, addr_t addr, addr_t * entry) {
+ pde32_t * pde_entry = &(pd[PDE32_INDEX(addr)]);
if (!pde_entry->present) {
*entry = 0;
- return NOT_PRESENT;
+ return PDE32_ENTRY_NOT_PRESENT;
} else {
- *entry = PAGE_ADDR(pde_entry->pt_base_addr);
-
- if (pde_entry->large_pages) {
- *entry += PAGE_OFFSET(addr);
- return LARGE_PAGE;
+
+ if (pde_entry->large_page) {
+ pde32_4MB_t * large_pde = (pde32_4MB_t *)pde_entry;
+
+ *entry = PDE32_4MB_T_ADDR(*large_pde);
+ *entry += PD32_4MB_PAGE_OFFSET(addr);
+ return PDE32_ENTRY_LARGE_PAGE;
} else {
- return PTE32;
+ *entry = PDE32_T_ADDR(*pde_entry);
+ return PDE32_ENTRY_PTE32;
}
}
- return NOT_PRESENT;
+ return PDE32_ENTRY_NOT_PRESENT;
}
-int pte32_lookup(pte32_t * pte, addr_t addr, addr_t * entry) {
- pte32_t * pte_entry = &(pte[PTE32_INDEX(addr)]);
+
+/* Takes a virtual addr (addr) and returns the physical addr (entry) as defined in the page table
+ */
+int pte32_lookup(pte32_t * pt, addr_t addr, addr_t * entry) {
+ pte32_t * pte_entry = &(pt[PTE32_INDEX(addr)]);
if (!pte_entry->present) {
*entry = 0;
+ PrintDebug("Lookup at non present page (index=%d)\n", PTE32_INDEX(addr));
return -1;
} else {
- *entry = PAGE_ADDR(pte_entry->page_base_addr);
- *entry += PAGE_OFFSET(addr);
+ *entry = PTE32_T_ADDR(*pte_entry) + PT32_PAGE_OFFSET(addr);
return 0;
}
+pt_access_status_t can_access_pde32(pde32_t * pde, addr_t addr, pf_error_t access_type) {
+ pde32_t * entry = &pde[PDE32_INDEX(addr)];
+
+ if (entry->present == 0) {
+ return PT_ENTRY_NOT_PRESENT;
+ } else if ((entry->writable == 0) && (access_type.write == 1)) {
+ return PT_WRITE_ERROR;
+ } else if ((entry->user_page == 0) && (access_type.user == 1)) {
+ // Check CR0.WP?
+ return PT_USER_ERROR;
+ }
+ return PT_ACCESS_OK;
+}
+
+
+pt_access_status_t can_access_pte32(pte32_t * pte, addr_t addr, pf_error_t access_type) {
+ pte32_t * entry = &pte[PTE32_INDEX(addr)];
+
+ if (entry->present == 0) {
+ return PT_ENTRY_NOT_PRESENT;
+ } else if ((entry->writable == 0) && (access_type.write == 1)) {
+ return PT_WRITE_ERROR;
+ } else if ((entry->user_page == 0) && (access_type.user == 1)) {
+ // Check CR0.WP?
+ return PT_USER_ERROR;
+ }
+
+ return PT_ACCESS_OK;
+}
pde32_t * create_passthrough_pde32_pts(struct guest_info * guest_info) {
ullong_t current_page_addr = 0;
int i, j;
- shadow_map_t * map = &(guest_info->mem_map);
+ struct shadow_map * map = &(guest_info->mem_map);
-
- pde32_t * pde = os_hooks->allocate_pages(1);
+ pde32_t * pde = V3_VAddr(V3_AllocPages(1));
for (i = 0; i < MAX_PDE32_ENTRIES; i++) {
int pte_present = 0;
- pte32_t * pte = os_hooks->allocate_pages(1);
+ pte32_t * pte = V3_VAddr(V3_AllocPages(1));
for (j = 0; j < MAX_PTE32_ENTRIES; j++) {
- shadow_region_t * region = get_shadow_region_by_addr(map, current_page_addr);
+ struct shadow_region * region = get_shadow_region_by_addr(map, current_page_addr);
if (!region ||
- (region->host_type == HOST_REGION_NOTHING) ||
+ (region->host_type == HOST_REGION_HOOK) ||
(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].writable = 0;
+ pte[j].user_page = 0;
+ pte[j].write_through = 0;
+ pte[j].cache_disable = 0;
pte[j].accessed = 0;
pte[j].dirty = 0;
pte[j].pte_attr = 0;
} else {
addr_t host_addr;
pte[j].present = 1;
- pte[j].flags = VM_READ | VM_WRITE | VM_EXEC | VM_USER;
-
+ pte[j].writable = 1;
+ pte[j].user_page = 1;
+ pte[j].write_through = 0;
+ pte[j].cache_disable = 0;
pte[j].accessed = 0;
pte[j].dirty = 0;
pte[j].pte_attr = 0;
}
if (pte_present == 0) {
- os_hooks->free_page(pte);
+ V3_FreePage(V3_PAddr(pte));
pde[i].present = 0;
- pde[i].flags = 0;
+ pde[i].writable = 0;
+ pde[i].user_page = 0;
+ pde[i].write_through = 0;
+ pde[i].cache_disable = 0;
pde[i].accessed = 0;
pde[i].reserved = 0;
- pde[i].large_pages = 0;
+ pde[i].large_page = 0;
pde[i].global_page = 0;
pde[i].vmm_info = 0;
pde[i].pt_base_addr = 0;
} else {
pde[i].present = 1;
- pde[i].flags = VM_READ | VM_WRITE | VM_EXEC | VM_USER;
+ pde[i].writable = 1;
+ pde[i].user_page = 1;
+ pde[i].write_through = 0;
+ pde[i].cache_disable = 0;
pde[i].accessed = 0;
pde[i].reserved = 0;
- pde[i].large_pages = 0;
+ pde[i].large_page = 0;
pde[i].global_page = 0;
pde[i].vmm_info = 0;
- pde[i].pt_base_addr = PAGE_ALIGNED_ADDR(pte);
+ pde[i].pt_base_addr = PAGE_ALIGNED_ADDR((addr_t)V3_PAddr(pte));
}
}
-void PrintPDE32(void * virtual_address, pde32_t * pde)
+void PrintPDE32(addr_t virtual_address, pde32_t * pde)
{
- PrintDebug("PDE %p -> %p : present=%x, flags=%x, accessed=%x, reserved=%x, largePages=%x, globalPage=%x, kernelInfo=%x\n",
- virtual_address,
- (void *) (pde->pt_base_addr << PAGE_POWER),
- pde->present,
- pde->flags,
- pde->accessed,
- pde->reserved,
- pde->large_pages,
- pde->global_page,
- pde->vmm_info);
+ PrintDebug("PDE %x -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, reserved=%x, largePages=%x, globalPage=%x, kernelInfo=%x\n",
+ virtual_address,
+ (void *)(addr_t) (pde->pt_base_addr << PAGE_POWER),
+ pde->present,
+ pde->writable,
+ pde->user_page,
+ pde->write_through,
+ pde->cache_disable,
+ pde->accessed,
+ pde->reserved,
+ pde->large_page,
+ pde->global_page,
+ pde->vmm_info);
}
-void PrintPTE32(void * virtual_address, pte32_t * pte)
+void PrintPTE32(addr_t virtual_address, pte32_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*)(pte->page_base_addr << PAGE_POWER),
- pte->present,
- pte->flags,
- pte->accessed,
- pte->dirty,
- pte->pte_attr,
- pte->global_page,
- pte->vmm_info);
+ PrintDebug("PTE %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, dirty=%x, pteAttribute=%x, globalPage=%x, vmm_info=%x\n",
+ virtual_address,
+ (void*)(addr_t)(pte->page_base_addr << PAGE_POWER),
+ pte->present,
+ pte->writable,
+ pte->user_page,
+ pte->write_through,
+ pte->cache_disable,
+ pte->accessed,
+ pte->dirty,
+ pte->pte_attr,
+ pte->global_page,
+ pte->vmm_info);
}
int i;
PrintDebug("Page Directory at %p:\n", pde);
- for (i = 0; (i < MAX_PDE32_ENTRIES) && pde[i].present; i++) {
- PrintPDE32((void*)(PAGE_SIZE * MAX_PTE32_ENTRIES * i), &(pde[i]));
+ for (i = 0; (i < MAX_PDE32_ENTRIES); i++) {
+ if ( pde[i].present) {
+ PrintPDE32((addr_t)(PAGE_SIZE * MAX_PTE32_ENTRIES * i), &(pde[i]));
+ }
}
}
-void PrintPT32(void * starting_address, pte32_t * pte)
+void PrintPT32(addr_t starting_address, pte32_t * pte)
{
int i;
PrintDebug("Page Table at %p:\n", pte);
- for (i = 0; (i < MAX_PTE32_ENTRIES) && pte[i].present; i++) {
- PrintPTE32(starting_address + (PAGE_SIZE * i), &(pte[i]));
+ for (i = 0; (i < MAX_PTE32_ENTRIES) ; i++) {
+ if (pte[i].present) {
+ PrintPTE32(starting_address + (PAGE_SIZE * i), &(pte[i]));
+ }
}
}
PrintDebug("Dumping the pages starting with the pde page at %p\n", pde);
- for (i = 0; (i < MAX_PDE32_ENTRIES) && pde[i].present; i++) {
- PrintPDE32((void *)(PAGE_SIZE * MAX_PTE32_ENTRIES * i), &(pde[i]));
- PrintPT32((void *)(PAGE_SIZE * MAX_PTE32_ENTRIES * i), (void *)(pde[i].pt_base_addr << PAGE_POWER));
+ for (i = 0; (i < MAX_PDE32_ENTRIES); i++) {
+ if (pde[i].present) {
+ PrintPDE32((addr_t)(PAGE_SIZE * MAX_PTE32_ENTRIES * i), &(pde[i]));
+ PrintPT32((addr_t)(PAGE_SIZE * MAX_PTE32_ENTRIES * i), (pte32_t *)V3_VAddr((void *)(addr_t)(pde[i].pt_base_addr << PAGE_POWER)));
+ }
}
}
