fixed paging callbacks to normalize calling convention

[palacios.git] / palacios / src / palacios / vmm_paging_debug.h

diff --git a/palacios/src/palacios/vmm_paging_debug.h b/palacios/src/palacios/vmm_paging_debug.h
index 21817a3..caaa549 100644 (file)
--- a/palacios/src/palacios/vmm_paging_debug.h
+++ b/palacios/src/palacios/vmm_paging_debug.h
@@ -197,14 +197,140 @@ static void PrintPTE64(addr_t virtual_address, pte64_t * pte)
 
 
 
+static int print_page_walk_cb(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
+  int i = 0;
+  addr_t tmp_vaddr = 0;
+  switch (type) {
 
+    /* 64 Bit */
 
+  case PAGE_PML464:
+    {
+      pml4e64_t * pml = (pml4e64_t *)page_ptr;
+      PrintDebug("PML4E64 Page\n");
+      for (i = 0; i < MAX_PML4E64_ENTRIES; i++) {
+       tmp_vaddr = (4096 * MAX_PTE64_ENTRIES);
+       tmp_vaddr *= (MAX_PDE64_ENTRIES * MAX_PDPE64_ENTRIES * i); // break apart to avoid int overflow compile errors
+       tmp_vaddr += vaddr;
+       if (pml[i].present) 
+         PrintPML4e64(tmp_vaddr, &(pml[i]));
+      }
+      break;
+    }
+  case PAGE_PDP64:
+    {
+      pdpe64_t * pdp = (pdpe64_t *)page_ptr;
+      PrintDebug("PDPE64 Page\n");
+      for (i = 0; i < MAX_PDPE64_ENTRIES; i++) {
+       tmp_vaddr = 4096 * MAX_PTE64_ENTRIES * MAX_PDE64_ENTRIES * i; 
+       tmp_vaddr += vaddr;
+       if (pdp[i].present)
+         PrintPDPE64(tmp_vaddr, &(pdp[i]));
+      }
+      break;
+    }
+  case PAGE_PD64:
+    {
+      pde64_t * pd = (pde64_t *)page_ptr;
+      PrintDebug("PDE64 Page\n");
+      for (i = 0; i < MAX_PDE64_ENTRIES; i++) {
+       tmp_vaddr = 4096 * MAX_PTE64_ENTRIES * i; 
+       tmp_vaddr += vaddr;
+       if (pd[i].present)
+         PrintPDE64(tmp_vaddr, &(pd[i]));
+      }
+      break;
+    }
+  case PAGE_PT64:
+    {
+      pte64_t * pt = (pte64_t *)page_ptr;
+      PrintDebug("PTE64 Page\n");
+      for (i = 0; i < MAX_PTE64_ENTRIES; i++) {
+       tmp_vaddr = 4096 * i; 
+       tmp_vaddr += vaddr;
+       if (pt[i].present)
+         PrintPTE64(tmp_vaddr, &(pt[i]));
+      }
+      break;
+    }
+
+    /* 32 BIT PAE */
+    
+  case PAGE_PDP32PAE:
+    {
+      pdpe32pae_t * pdp = (pdpe32pae_t *)page_ptr;
+      PrintDebug("PDPE32PAE Page\n");
+      for (i = 0; i < MAX_PDPE32PAE_ENTRIES; i++) {
+       tmp_vaddr = 4096 * MAX_PTE32PAE_ENTRIES * MAX_PDE32PAE_ENTRIES * i; 
+       tmp_vaddr += vaddr;
+       if (pdp[i].present) 
+         PrintPDPE32PAE(tmp_vaddr, &(pdp[i]));
+      }
+      break;
+    }
+  case PAGE_PD32PAE:
+    {
+      pde32pae_t * pd = (pde32pae_t *)page_ptr;
+      PrintDebug("PDE32PAE Page\n");
+      for (i = 0; i < MAX_PDE32PAE_ENTRIES; i++) {
+       tmp_vaddr = 4096 * MAX_PTE32PAE_ENTRIES * i; 
+       tmp_vaddr += vaddr;
+       if (pd[i].present)
+         PrintPDE32PAE(tmp_vaddr, &(pd[i]));
+      }
+      break;
+    }
+  case PAGE_PT32PAE:
+    {
+      pte32pae_t * pt = (pte32pae_t *)page_ptr;
+      PrintDebug("PTE32PAE Page\n");
+      for (i = 0; i < MAX_PTE32PAE_ENTRIES; i++) {
+       tmp_vaddr = 4096 * i; 
+       tmp_vaddr += vaddr;
+       if (pt[i].present) 
+         PrintPTE32PAE(tmp_vaddr, &(pt[i]));
+      }
+      break;
+    }
+
+    /* 32 Bit */
+
+  case PAGE_PD32:
+    {
+      pde32_t * pd = (pde32_t *)page_ptr;
+      PrintDebug("PDE32 Page\n");
+      for (i = 0; i < MAX_PTE32_ENTRIES; i++) {
+       tmp_vaddr = 4096 * MAX_PTE32_ENTRIES * i; 
+       tmp_vaddr += vaddr;
+       if (pd[i].present)
+         PrintPDE32(tmp_vaddr, &(pd[i]));
+      }
+      break;
+    }
+  case PAGE_PT32:
+    {
+      pte32_t * pt = (pte32_t *)page_ptr;
+      PrintDebug("PTE32 Page\n");
+      for (i = 0; i < MAX_PTE32_ENTRIES; i++) {
+       tmp_vaddr = 4096 * i; 
+       tmp_vaddr += vaddr;
+       if (pt[i].present)
+         PrintPTE32(tmp_vaddr, &(pt[i]));
+      }
+      break;
+    }
+  default:
+    break;
+  }
+
+  return 0;
+}
 
 
 
 
-static int print_page_tree_cb(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
 
+static int print_page_tree_cb(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
   switch (type) {
 
     /* 64 Bit */
@@ -279,39 +405,45 @@ static int print_page_tree_cb(page_type_t type, addr_t vaddr, addr_t page_ptr, a
 
 
 
-void PrintPTEntry(page_type_t type, addr_t vaddr, void * entry) {
-  print_page_tree_cb(type, vaddr, PAGE_ADDR_4KB((addr_t)entry), 0, NULL);
+void PrintPTEntry(struct guest_info * info, page_type_t type, addr_t vaddr, void * entry) {
+  print_page_tree_cb(info, type, vaddr, PAGE_ADDR_4KB((addr_t)entry), 0, NULL);
 }
 
 
-void PrintHostPageTables(v3_vm_cpu_mode_t cpu_mode, addr_t cr3) {
-  switch (cpu_mode) {
+void PrintHostPageTables(struct guest_info * info, addr_t cr3) {
+  PrintDebug("CR3: %p\n", (void *)cr3);
+  switch (info->cpu_mode) {
   case PROTECTED:
-    v3_walk_host_pt_32(cr3, print_page_tree_cb, NULL);
+    v3_walk_host_pt_32(info, cr3, print_page_walk_cb, NULL);
+    break;
   case PROTECTED_PAE:
-    v3_walk_host_pt_32pae(cr3, print_page_tree_cb, NULL);
+    v3_walk_host_pt_32pae(info, cr3, print_page_walk_cb, NULL);
+    break;
   case LONG:
   case LONG_32_COMPAT:
   case LONG_16_COMPAT:
-    v3_walk_host_pt_64(cr3, print_page_tree_cb, NULL);
+    v3_walk_host_pt_64(info, cr3, print_page_walk_cb, NULL);
     break;
   default:
-    PrintError("Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(cpu_mode));
+    PrintError("Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(info->cpu_mode));
     break;
   }
 }
 
 
 void PrintGuestPageTables(struct guest_info * info, addr_t cr3) {
+  PrintDebug("CR3: %p\n", (void *)cr3);
   switch (info->cpu_mode) {
   case PROTECTED:
-    v3_walk_guest_pt_32(info, cr3, print_page_tree_cb, NULL);
+    v3_walk_guest_pt_32(info, cr3, print_page_walk_cb, NULL);
+    break;
   case PROTECTED_PAE:
-    v3_walk_guest_pt_32pae(info, cr3, print_page_tree_cb, NULL);
+    v3_walk_guest_pt_32pae(info, cr3, print_page_walk_cb, NULL);
+    break;
   case LONG:
   case LONG_32_COMPAT:
   case LONG_16_COMPAT:
-    v3_walk_guest_pt_64(info, cr3, print_page_tree_cb, NULL);
+    v3_walk_guest_pt_64(info, cr3, print_page_walk_cb, NULL);
     break;
   default:
     PrintError("Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(info->cpu_mode));
@@ -319,29 +451,35 @@ void PrintGuestPageTables(struct guest_info * info, addr_t cr3) {
   }
 }
 
-void PrintHostPageTree(v3_vm_cpu_mode_t cpu_mode, addr_t virtual_addr, addr_t cr3) {
-  switch (cpu_mode) {
+void PrintHostPageTree(struct guest_info * info,  addr_t virtual_addr, addr_t cr3) {
+  PrintDebug("CR3: %p\n", (void *)cr3);
+  switch (info->cpu_mode) {
   case PROTECTED:
-    v3_drill_host_pt_32(cr3, virtual_addr, print_page_tree_cb, NULL);
+    v3_drill_host_pt_32(info, cr3, virtual_addr, print_page_tree_cb, NULL);
+    break;
   case PROTECTED_PAE:
-    v3_drill_host_pt_32pae(cr3, virtual_addr, print_page_tree_cb, NULL);
+    v3_drill_host_pt_32pae(info, cr3, virtual_addr, print_page_tree_cb, NULL);
+    break;
   case LONG:
   case LONG_32_COMPAT:
   case LONG_16_COMPAT:
-    v3_drill_host_pt_64(cr3, virtual_addr, print_page_tree_cb, NULL);
+    v3_drill_host_pt_64(info, cr3, virtual_addr, print_page_tree_cb, NULL);
     break;
   default:
-    PrintError("Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(cpu_mode));
+    PrintError("Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(info->cpu_mode));
     break;
   }
 }
 
 void PrintGuestPageTree(struct guest_info * info, addr_t virtual_addr, addr_t cr3) {
+  PrintDebug("CR3: %p\n", (void *)cr3);
   switch (info->cpu_mode) {
   case PROTECTED:
     v3_drill_guest_pt_32(info, cr3, virtual_addr, print_page_tree_cb, NULL);
+    break;
   case PROTECTED_PAE:
     v3_drill_guest_pt_32pae(info, cr3, virtual_addr, print_page_tree_cb, NULL);
+    break;
   case LONG:
   case LONG_32_COMPAT:
   case LONG_16_COMPAT: