X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=palacios%2Fsrc%2Fpalacios%2Fvmm_paging.c;h=4784e90abc0f05d9514a20dee8f7b10a0e64f613;hb=976d67e1c6f988ca38ae83347859ccc86d485651;hp=dff74dd0e6325567377b3b4d38db3c18abc36fee;hpb=11c0d91392ab632542eb364412b62fa7c96697c4;p=palacios.git

diff --git a/palacios/src/palacios/vmm_paging.c b/palacios/src/palacios/vmm_paging.c
index dff74dd..4784e90 100644
--- a/palacios/src/palacios/vmm_paging.c
+++ b/palacios/src/palacios/vmm_paging.c
@@ -25,12 +25,14 @@
 
 
 
-
-  
+#define USE_VMM_PAGING_DEBUG
+// All of the debug functions defined in vmm_paging.h are implemented in this file
+#include "vmm_paging_debug.h"
+#undef USE_VMM_PAGING_DEBUG
 
 
-void delete_page_tables_pde32(pde32_t * pde) {
-  int i;//, j;
+void delete_page_tables_32(pde32_t * pde) {
+  int i;
 
   if (pde == NULL) { 
     return;
@@ -42,13 +44,6 @@ void delete_page_tables_pde32(pde32_t * pde) {
       PrintDebug("PTE base addr %x \n", pde[i].pt_base_addr);
       pte32_t * pte = (pte32_t *)((addr_t)(uint_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));
-	}
-	}
-      */
       PrintDebug("Deleting PTE %d (%p)\n", i, pte);
       V3_FreePage(pte);
     }
@@ -58,6 +53,115 @@ void delete_page_tables_pde32(pde32_t * pde) {
   V3_FreePage(V3_PAddr(pde));
 }
 
+void delete_page_tables_32PAE(pdpe32pae_t * pdpe) { 
+  PrintError("Unimplemented function\n");
+}
+
+void delete_page_tables_64(pml4e64_t * pml4) {
+  PrintError("Unimplemented function\n");
+}
+
+
+int translate_guest_pt_32(struct guest_info * info, addr_t guest_cr3, addr_t vaddr, addr_t * paddr) {
+  addr_t guest_pde_pa = CR3_TO_PDE32_PA((void *)guest_cr3);
+  pde32_t * guest_pde = 0;
+  addr_t guest_pte_pa = 0;
+
+  if (guest_pa_to_host_va(info, guest_pde_pa, (addr_t*)&guest_pde) == -1) {
+    PrintError("Could not get virtual address of Guest PDE32 (PA=%p)\n", 
+	       (void *)guest_pde_pa);
+    return -1;
+  }
+  
+  switch (pde32_lookup(guest_pde, vaddr, &guest_pte_pa)) {
+  case PDE32_ENTRY_NOT_PRESENT:
+    *paddr = 0;  
+    return -1;
+  case PDE32_ENTRY_LARGE_PAGE:
+    *paddr = guest_pte_pa;
+    return 0;
+  case PDE32_ENTRY_PTE32:
+    {
+      pte32_t * guest_pte;
+      if (guest_pa_to_host_va(info, guest_pte_pa, (addr_t*)&guest_pte) == -1) {
+	PrintError("Could not get virtual address of Guest PTE32 (PA=%p)\n", 
+		   (void *)guest_pte_pa);
+	return -1;
+      }
+
+      if (pte32_lookup(guest_pte, vaddr, paddr) == -1) {
+	return -1;
+      }
+    }
+  }
+
+  return 0;
+}
+
+
+int translate_host_pt_32(addr_t host_cr3, addr_t vaddr, addr_t * paddr) {
+  pde32_t * host_pde = (pde32_t *)CR3_TO_PDE32_VA((void *)host_cr3);
+  pte32_t * host_pte = 0;
+    
+  switch (pde32_lookup(host_pde, vaddr, (addr_t *)&host_pte)) {
+  case PDE32_ENTRY_NOT_PRESENT:
+    *paddr = 0;
+    return -1;
+  case PDE32_ENTRY_LARGE_PAGE:
+    *paddr = (addr_t)host_pte;
+    return 0;
+  case PDE32_ENTRY_PTE32:
+    if (pte32_lookup(host_pte, vaddr, paddr) == -1) {
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+
+int translate_host_pt_32pae(addr_t host_cr3, addr_t vaddr, addr_t * paddr) {
+  pde32_t * host_pde = (pde32_t *)CR3_TO_PDE32_VA((void *)host_cr3);
+  pte32_t * host_pte = 0;
+    
+  switch (pde32_lookup(host_pde, vaddr, (addr_t *)&host_pte)) {
+  case PDE32_ENTRY_NOT_PRESENT:
+    *paddr = 0;
+    return -1;
+  case PDE32_ENTRY_LARGE_PAGE:
+    *paddr = (addr_t)host_pte;
+    return 0;
+  case PDE32_ENTRY_PTE32:
+    if (pte32_lookup(host_pte, vaddr, paddr) == -1) {
+      return -1;
+    }
+  }
+
+  return -1;
+}
+
+
+int translate_host_pt_64(addr_t host_cr3, addr_t vaddr, addr_t * paddr) {
+  pde32_t * host_pde = (pde32_t *)CR3_TO_PDE32_VA((void *)host_cr3);
+  pte32_t * host_pte = 0;
+    
+  switch (pde32_lookup(host_pde, vaddr, (addr_t *)&host_pte)) {
+  case PDE32_ENTRY_NOT_PRESENT:
+    *paddr = 0;
+    return -1;
+  case PDE32_ENTRY_LARGE_PAGE:
+    *paddr = (addr_t)host_pte;
+    return 0;
+  case PDE32_ENTRY_PTE32:
+    if (pte32_lookup(host_pte, vaddr, paddr) == -1) {
+      return -1;
+    }
+  }
+
+  return -1;
+}
+
+
 
 
 
@@ -88,6 +192,11 @@ int pt32_lookup(pde32_t * pd, addr_t vaddr, addr_t * paddr) {
  * 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...
  */
+/* The value of entry is a return type:
+ * Page not present: *entry = 0
+ * Large Page: *entry = translated physical address (byte granularity)
+ * PTE entry: *entry is the address of the PTE Page
+ */
 pde32_entry_type_t pde32_lookup(pde32_t * pd, addr_t addr, addr_t * entry) {
   pde32_t * pde_entry = &(pd[PDE32_INDEX(addr)]);
 
@@ -99,11 +208,11 @@ pde32_entry_type_t pde32_lookup(pde32_t * pd, addr_t addr, addr_t * entry) {
     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);
+      *entry = BASE_TO_PAGE_ADDR_4MB(large_pde->page_base_addr);
+      *entry += PAGE_OFFSET_4MB(addr);
       return PDE32_ENTRY_LARGE_PAGE;
     } else {
-      *entry = PDE32_T_ADDR(*pde_entry);
+      *entry = BASE_TO_PAGE_ADDR(pde_entry->pt_base_addr);
       return PDE32_ENTRY_PTE32;
     }
   }  
@@ -119,10 +228,25 @@ int pte32_lookup(pte32_t * pt, addr_t addr, addr_t * entry) {
 
   if (!pte_entry->present) {
     *entry = 0;
-    PrintDebug("Lookup at non present page (index=%d)\n", PTE32_INDEX(addr));
+    //    PrintDebug("Lookup at non present page (index=%d)\n", PTE32_INDEX(addr));
     return -1;
   } else {
-    *entry = PTE32_T_ADDR(*pte_entry) + PT32_PAGE_OFFSET(addr);
+    *entry = BASE_TO_PAGE_ADDR(pte_entry->page_base_addr) + PAGE_OFFSET(addr);
+    return 0;
+  }
+
+  return -1;
+}
+
+
+int pdpe32pae_lookup(pdpe32pae_t * pdp, addr_t addr, addr_t * entry) {
+  pdpe32pae_t * pdpe_entry = &(pdp[PDPE32PAE_INDEX(addr)]);
+  
+  if (!pdpe_entry->present) {
+    *entry = 0;
+    return -1;
+  } else {
+    *entry = BASE_TO_PAGE_ADDR(pdpe_entry->pd_base_addr) + PAGE_OFFSET(addr);
     return 0;
   }
 
@@ -253,7 +377,7 @@ pde32_t * create_passthrough_pts_32(struct guest_info * guest_info) {
       pde[i].large_page = 0;
       pde[i].global_page = 0;
       pde[i].vmm_info = 0;
-      pde[i].pt_base_addr = PAGE_ALIGNED_ADDR((addr_t)V3_PAddr(pte));
+      pde[i].pt_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pte));
     }
 
   }
@@ -262,6 +386,147 @@ pde32_t * create_passthrough_pts_32(struct guest_info * guest_info) {
 }
 
 
+/* 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
+ */
+pdpe32pae_t * create_passthrough_pts_32PAE(struct guest_info * guest_info) {
+  addr_t current_page_addr = 0;
+  int i, j, k;
+  struct shadow_map * map = &(guest_info->mem_map);
+
+  pdpe32pae_t * pdpe = V3_VAddr(V3_AllocPages(1));
+  memset(pdpe, 0, PAGE_SIZE);
+
+  for (i = 0; i < MAX_PDPE32PAE_ENTRIES; i++) {
+    int pde_present = 0;
+    pde32pae_t * pde = V3_VAddr(V3_AllocPages(1));
+
+    for (j = 0; j < MAX_PDE32PAE_ENTRIES; j++) {
+
+
+      int pte_present = 0;
+      pte32pae_t * pte = V3_VAddr(V3_AllocPages(1));
+      
+      
+      for (k = 0; k < MAX_PTE32PAE_ENTRIES; k++) {
+	struct shadow_region * region = get_shadow_region_by_addr(map, current_page_addr);
+	
+	if (!region || 
+	    (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[k].present = 0;
+	  pte[k].writable = 0;
+	  pte[k].user_page = 0;
+	  pte[k].write_through = 0;
+	  pte[k].cache_disable = 0;
+	  pte[k].accessed = 0;
+	  pte[k].dirty = 0;
+	  pte[k].pte_attr = 0;
+	  pte[k].global_page = 0;
+	  pte[k].vmm_info = 0;
+	  pte[k].page_base_addr = 0;
+	  pte[k].rsvd = 0;
+	} else {
+	  addr_t host_addr;
+	  pte[k].present = 1;
+	  pte[k].writable = 1;
+	  pte[k].user_page = 1;
+	  pte[k].write_through = 0;
+	  pte[k].cache_disable = 0;
+	  pte[k].accessed = 0;
+	  pte[k].dirty = 0;
+	  pte[k].pte_attr = 0;
+	  pte[k].global_page = 0;
+	  pte[k].vmm_info = 0;
+	  
+	  if (guest_pa_to_host_pa(guest_info, current_page_addr, &host_addr) == -1) {
+	    // BIG ERROR
+	    // PANIC
+	    return NULL;
+	  }
+	  
+	  pte[k].page_base_addr = host_addr >> 12;
+	  pte[k].rsvd = 0;
+
+	  pte_present = 1;
+	}
+	
+	current_page_addr += PAGE_SIZE;
+      }
+      
+      if (pte_present == 0) { 
+	V3_FreePage(V3_PAddr(pte));
+	
+	pde[j].present = 0;
+	pde[j].writable = 0;
+	pde[j].user_page = 0;
+	pde[j].write_through = 0;
+	pde[j].cache_disable = 0;
+	pde[j].accessed = 0;
+	pde[j].avail = 0;
+	pde[j].large_page = 0;
+	pde[j].global_page = 0;
+	pde[j].vmm_info = 0;
+	pde[j].pt_base_addr = 0;
+	pde[j].rsvd = 0;
+      } else {
+	pde[j].present = 1;
+	pde[j].writable = 1;
+	pde[j].user_page = 1;
+	pde[j].write_through = 0;
+	pde[j].cache_disable = 0;
+	pde[j].accessed = 0;
+	pde[j].avail = 0;
+	pde[j].large_page = 0;
+	pde[j].global_page = 0;
+	pde[j].vmm_info = 0;
+	pde[j].pt_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pte));
+	pde[j].rsvd = 0;
+
+	pde_present = 1;
+      }
+      
+    }
+    
+    if (pde_present == 0) { 
+      V3_FreePage(V3_PAddr(pde));
+      
+      pdpe[i].present = 0;
+      pdpe[i].rsvd = 0;
+      pdpe[i].write_through = 0;
+      pdpe[i].cache_disable = 0;
+      pdpe[i].accessed = 0;
+      pdpe[i].avail = 0;
+      pdpe[i].rsvd2 = 0;
+      pdpe[i].vmm_info = 0;
+      pdpe[i].pd_base_addr = 0;
+      pdpe[i].rsvd3 = 0;
+    } else {
+      pdpe[i].present = 1;
+      pdpe[i].rsvd = 0;
+      pdpe[i].write_through = 0;
+      pdpe[i].cache_disable = 0;
+      pdpe[i].accessed = 0;
+      pdpe[i].avail = 0;
+      pdpe[i].rsvd2 = 0;
+      pdpe[i].vmm_info = 0;
+      pdpe[i].pd_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pde));
+      pdpe[i].rsvd3 = 0;
+    }
+    
+  }
+
+
+  return pdpe;
+}
+
+
+
+
 
 
 pml4e64_t * create_passthrough_pts_64(struct guest_info * info) {
@@ -275,7 +540,7 @@ pml4e64_t * create_passthrough_pts_64(struct guest_info * info) {
     int pdpe_present = 0;
     pdpe64_t * pdpe = V3_VAddr(V3_AllocPages(1));
 
-    for (j = 0; j < 1; j++) {
+    for (j = 0; j < 20; j++) {
       int pde_present = 0;
       pde64_t * pde = V3_VAddr(V3_AllocPages(1));
 
@@ -325,7 +590,7 @@ pml4e64_t * create_passthrough_pts_64(struct guest_info * info) {
 	      return NULL;
 	    }
 
-	    pte[m].page_base_addr = PTE64_BASE_ADDR(host_addr);
+	    pte[m].page_base_addr = PAGE_BASE_ADDR(host_addr);
 
 	    //PrintPTE64(current_page_addr, &(pte[m]));
 
@@ -363,7 +628,7 @@ pml4e64_t * create_passthrough_pts_64(struct guest_info * info) {
 	  pde[k].large_page = 0;
 	  //pde[k].global_page = 0;
 	  pde[k].vmm_info = 0;
-	  pde[k].pt_base_addr = PAGE_ALIGNED_ADDR((addr_t)V3_PAddr(pte));
+	  pde[k].pt_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pte));
 
 	  pde_present = 1;
 	}
@@ -394,7 +659,7 @@ pml4e64_t * create_passthrough_pts_64(struct guest_info * info) {
 	pdpe[j].large_page = 0;
 	//pdpe[j].global_page = 0;
 	pdpe[j].vmm_info = 0;
-	pdpe[j].pd_base_addr = PAGE_ALIGNED_ADDR((addr_t)V3_PAddr(pde));
+	pdpe[j].pd_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pde));
 
 
 	pdpe_present = 1;
@@ -429,7 +694,7 @@ pml4e64_t * create_passthrough_pts_64(struct guest_info * info) {
       //pml[i].large_page = 0;
       //pml[i].global_page = 0;
       pml[i].vmm_info = 0;
-      pml[i].pdp_base_addr = PAGE_ALIGNED_ADDR((addr_t)V3_PAddr(pdpe));
+      pml[i].pdp_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pdpe));
     }
   }
 
@@ -439,122 +704,3 @@ pml4e64_t * create_passthrough_pts_64(struct guest_info * info) {
 
 
 
-
-void PrintPDE32(addr_t virtual_address, pde32_t * pde)
-{
-  PrintDebug("PDE %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, reserved=%x, largePages=%x, globalPage=%x, kernelInfo=%x\n",
-	     (void *)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(addr_t virtual_address, pte32_t * pte)
-{
-  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",
-	     (void *)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);
-}
-
-
-void PrintPDE64(addr_t virtual_address, pde64_t * pde)
-{
-  PrintDebug("PDE64 %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, reserved=%x, largePages=%x, globalPage=%x, kernelInfo=%x\n",
-	     (void *)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,
-	     0,//pde->global_page,
-	     pde->vmm_info);
-}
-
-  
-void PrintPTE64(addr_t virtual_address, pte64_t * pte)
-{
-  PrintDebug("PTE64 %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, dirty=%x, pteAttribute=%x, globalPage=%x, vmm_info=%x\n",
-	     (void *)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);
-}
-
-  
-
-
-
-
-void PrintPD32(pde32_t * pde)
-{
-  int i;
-
-  PrintDebug("Page Directory at %p:\n", pde);
-  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(addr_t starting_address, pte32_t * pte) 
-{
-  int i;
-
-  PrintDebug("Page Table at %p:\n", pte);
-  for (i = 0; (i < MAX_PTE32_ENTRIES) ; i++) { 
-    if (pte[i].present) {
-      PrintPTE32(starting_address + (PAGE_SIZE * i), &(pte[i]));
-    }
-  }
-}
-
-
-
-
-
-void PrintDebugPageTables(pde32_t * pde)
-{
-  int i;
-  
-  PrintDebug("Dumping the pages starting with the pde page at %p\n", pde);
-
-  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)));
-    }
-  }
-}
-