fixed a ton of compile errors...

I suck...

diff --git a/palacios/include/palacios/vmm_paging.h b/palacios/include/palacios/vmm_paging.h
index ad20d94..a4f520e 100644 (file)
--- a/palacios/include/palacios/vmm_paging.h
+++ b/palacios/include/palacios/vmm_paging.h
@@ -538,7 +538,7 @@ int v3_check_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t va
 
 
 int v3_walk_host_pt_32(v3_reg_t host_cr3,
-                      int (*callback)(int level, addr_t page_va, addr_t page_pa, void private_data),
+                      int (*callback)(int level, addr_t page_va, addr_t page_pa, void * private_data),
                       void * private_data);
 
 int v3_walk_host_pt_32pae(v3_reg_t host_cr3,

diff --git a/palacios/src/palacios/vmm_paging.c b/palacios/src/palacios/vmm_paging.c
index 7d2878f..8c5d369 100644 (file)
--- a/palacios/src/palacios/vmm_paging.c
+++ b/palacios/src/palacios/vmm_paging.c
@@ -1410,19 +1410,40 @@ pml4e64_t * create_passthrough_pts_64(struct guest_info * info) {
   return pml;
 }
 
-
+/*
 int v3_walk_guest_pt_32(struct guest_info * info,  v3_reg_t guest_cr3,
                        int (*callback)(int level, addr_t page_va, addr_t page_pa, void private_data),
                        void * private_data) {
-  
+  addr_t guest_pde_pa = CR3_TO_PDE32_PA(guest_cr3);
+  pde32_t * guest_pde = NULL;
+  int i, j;
 
-}
+  if (!callback) {
+    PrintError("Call back was not specified\n");
+    return -1;
+  }
 
+  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;
+  }
+
+  callback(PAGE_PD32, guest_pde, guest_pde_pa, private_data);
+
+  for (i = 0; i < MAX_PDE32_ENTRIES; i++) {
+    if (guet_pde[i].present) {
+      if (guest_pde[i].large_page) {
+
+
+
+}
+*/
 
 
 
 int v3_walk_host_pt_32(v3_reg_t host_cr3,
-                      int (*callback)(int level, addr_t page_va, addr_t page_pa, void private_data),
+                      int (*callback)(int level, addr_t page_va, addr_t page_pa, void * private_data),
                       void * private_data) {
   pde32_t * host_pde = (pde32_t *)CR3_TO_PDE32_VA(host_cr3);
   addr_t pde_pa = CR3_TO_PDE32_PA(host_cr3);
@@ -1433,25 +1454,25 @@ int v3_walk_host_pt_32(v3_reg_t host_cr3,
     return -1;
   }
 
-  callback(PAGE_PD32, host_pde, pde_pa, private_data);
+  callback(PAGE_PD32, (addr_t)host_pde, pde_pa, private_data);
 
   for (i = 0; i < MAX_PDE32_ENTRIES; i++) {
     if (host_pde[i].present) {
-      if (host_pde[i].lage_page) {
+      if (host_pde[i].large_page) {
        pde32_4MB_t * large_pde = (pde32_4MB_t *)&(host_pde[i]);
        addr_t large_page_pa = BASE_TO_PAGE_ADDR_4MB(large_pde->page_base_addr);
 
-       callback(PAGE_4MB, V3_VAddr(large_page_pa), large_page_pa, private_data);
+       callback(PAGE_4MB, (addr_t)V3_VAddr((void *)large_page_pa), large_page_pa, private_data);
       } else {
        addr_t pte_pa = BASE_TO_PAGE_ADDR(host_pde[i].pt_base_addr);
-       pte32_t * tmp_pte = (pte32_t *)V3_VAddr(pte_pa);
+       pte32_t * tmp_pte = (pte32_t *)V3_VAddr((void *)pte_pa);
 
-       callback(PAGE_PT32, tmp_pte, pte_pa, private_data);
+       callback(PAGE_PT32, (addr_t)tmp_pte, pte_pa, private_data);
 
        for (j = 0; j < MAX_PTE32_ENTRIES; j++) {
          if (tmp_pte[j].present) {
            addr_t page_pa = BASE_TO_PAGE_ADDR(tmp_pte[j].page_base_addr);
-           callback(PAGE_4KB, V3_VAddr(page_pa), page_pa, private_data);
+           callback(PAGE_4KB, (addr_t)V3_VAddr((void *)page_pa), page_pa, private_data);
          }
        }
       }
@@ -1476,14 +1497,14 @@ int v3_walk_host_pt_32pae(v3_reg_t host_cr3,
     return -1;
   }
   
-  callback(PAGE_PDP32PAE, host_pdpe, pdpe_pa, private_data);
+  callback(PAGE_PDP32PAE, (addr_t)host_pdpe, pdpe_pa, private_data);
   
   for (i = 0; i < MAX_PDPE32PAE_ENTRIES; i++) {
     if (host_pdpe[i].present) {        
       addr_t pde_pa = BASE_TO_PAGE_ADDR(host_pdpe[i].pd_base_addr);
-      pde32pae_t * tmp_pde = (pde32pae_t *)V3_VAddr(pde_pa);
+      pde32pae_t * tmp_pde = (pde32pae_t *)V3_VAddr((void *)pde_pa);
       
-      callback(PAGE_PD32PAE, tmp_pde, pde_pa, private_data);
+      callback(PAGE_PD32PAE, (addr_t)tmp_pde, pde_pa, private_data);
       
       for (j = 0; j < MAX_PDE32PAE_ENTRIES; j++) {
        if (tmp_pde[j].present) {
@@ -1492,17 +1513,17 @@ int v3_walk_host_pt_32pae(v3_reg_t host_cr3,
            pde32pae_2MB_t * large_pde = (pde32pae_2MB_t *)&(tmp_pde[j]);
            addr_t large_page_pa = BASE_TO_PAGE_ADDR_2MB(large_pde->page_base_addr);
 
-           callback(PAGE_2MB, V3_VAddr(lage_page_pa), lage_page_pa, private_data);
+           callback(PAGE_2MB, (addr_t)V3_VAddr((void *)large_page_pa), large_page_pa, private_data);
          } else {
            addr_t pte_pa = BASE_TO_PAGE_ADDR(tmp_pde[j].pt_base_addr);
-           pte32pae_t * tmp_pte = (pte32pae_t *)V3_VAddr(pte_pa);
+           pte32pae_t * tmp_pte = (pte32pae_t *)V3_VAddr((void *)pte_pa);
            
-           callback(PAGE_PT32PAE, tmp_pte, pte_pa, private_data);
+           callback(PAGE_PT32PAE, (addr_t)tmp_pte, pte_pa, private_data);
            
            for (k = 0; k < MAX_PTE32PAE_ENTRIES; k++) {
              if (tmp_pte[k].present) {
                addr_t page_pa = BASE_TO_PAGE_ADDR(tmp_pte[k].page_base_addr);
-               callback(PAGE_4KB, V3_VAddr(page_pa), page_pa, private_data);
+               callback(PAGE_4KB, (addr_t)V3_VAddr((void *)page_pa), page_pa, private_data);
              }
            }
          }         
@@ -1517,7 +1538,7 @@ int v3_walk_host_pt_32pae(v3_reg_t host_cr3,
 int v3_walk_host_pt_64(v3_reg_t host_cr3,
                       void (*callback)(page_type_t type, addr_t page_va, addr_t page_pa, void * private_data),
                       void * private_data) {
-  pml4e64_t * host_pml = (pml3e64_t *)CR3_TO_PML4E64_VA(host_cr3);
+  pml4e64_t * host_pml = (pml4e64_t *)CR3_TO_PML4E64_VA(host_cr3);
   addr_t pml_pa = CR3_TO_PML4E64_PA(host_cr3);
   int i, j, k, m;
 
@@ -1526,45 +1547,45 @@ int v3_walk_host_pt_64(v3_reg_t host_cr3,
     return -1;
   }
 
-  callback(PAGE_PML464, host_pml, pml_pa, private_data);
+  callback(PAGE_PML464, (addr_t)host_pml, pml_pa, private_data);
 
   for (i = 0; i < MAX_PML4E64_ENTRIES; i++) {
     if (host_pml[i].present) {
       addr_t pdpe_pa = BASE_TO_PAGE_ADDR(host_pml[i].pdp_base_addr);
-      pdpe64_t * tmp_pdpe = (pdpe64_t *)V3_VAddr(pdpe_pa);
+      pdpe64_t * tmp_pdpe = (pdpe64_t *)V3_VAddr((void *)pdpe_pa);
 
-      callback(PAGE_PDP64, tmp_pdpe, pdpe_pa, private_data);
+      callback(PAGE_PDP64, (addr_t)tmp_pdpe, pdpe_pa, private_data);
 
       for (j = 0; j < MAX_PDPE64_ENTRIES; j++) {
        if (tmp_pdpe[j].present) {
          if (tmp_pdpe[j].large_page) {
-           pdpe64_1GB_t * large_pdp = (pdpe64_t *)&(tmp_pdpe[j]);
-           addr_t large_page_pa = BASE_TO_PAGE_ADDR_1GB(large_pdp->page_addr);
+           pdpe64_1GB_t * large_pdp = (pdpe64_1GB_t *)&(tmp_pdpe[j]);
+           addr_t large_page_pa = BASE_TO_PAGE_ADDR_1GB(large_pdp->page_base_addr);
 
-           callback(PAGE_1GB, V3_VAddr(large_page_pa), large_page_pa, private_data);       
+           callback(PAGE_1GB, (addr_t)V3_VAddr((void *)large_page_pa), large_page_pa, private_data);       
          } else {
            addr_t pde_pa = BASE_TO_PAGE_ADDR(tmp_pdpe[j].pd_base_addr);
-           pde64_t * tmp_pde = (pde64_t *)V3_VAddr(pde_pa);
+           pde64_t * tmp_pde = (pde64_t *)V3_VAddr((void *)pde_pa);
 
-           callback(PAGE_PD64, tmp_pde, pde_pa, private_data);
+           callback(PAGE_PD64, (addr_t)tmp_pde, pde_pa, private_data);
 
-           for (k = 0; k < MAX_PDE64_ENRIES; k++) {
+           for (k = 0; k < MAX_PDE64_ENTRIES; k++) {
              if (tmp_pde[k].present) {
                if (tmp_pde[k].large_page) {
                  pde64_2MB_t * large_pde = (pde64_2MB_t *)&(tmp_pde[k]);
-                 addr_t large_page_pa = BASE_TO_PAGE_ADDR_2MB(large_pde->page_addr);
+                 addr_t large_page_pa = BASE_TO_PAGE_ADDR_2MB(large_pde->page_base_addr);
                  
-                 callback(PAGE_2MB, V3_VAddr(large_page_pa), large_page_pa, private_data);
+                 callback(PAGE_2MB, (addr_t)V3_VAddr((void *)large_page_pa), large_page_pa, private_data);
                } else {
                  addr_t pte_pa = BASE_TO_PAGE_ADDR(tmp_pde[k].pt_base_addr);
-                 pte64_t * tmp_pte = (pte64_t *)V3_VAddr(pte_pa);
+                 pte64_t * tmp_pte = (pte64_t *)V3_VAddr((void *)pte_pa);
 
-                 callback(PAGE_PT64, tmp_pte, pte_pa, private_data);
+                 callback(PAGE_PT64, (addr_t)tmp_pte, pte_pa, private_data);
 
                  for (m = 0; m < MAX_PTE64_ENTRIES; m++) {
                    if (tmp_pte[m].present) {
                      addr_t page_pa = BASE_TO_PAGE_ADDR(tmp_pte[m].page_base_addr);
-                     callback(PAGE_4KB, V3_VAddr(page_pa), page_pa, private_data);
+                     callback(PAGE_4KB, (addr_t)V3_VAddr((void *)page_pa), page_pa, private_data);
                    }
                  }
                }

diff --git a/palacios/src/palacios/vmm_shadow_paging.c b/palacios/src/palacios/vmm_shadow_paging.c
index 4e6b573..933ef6b 100644 (file)
--- a/palacios/src/palacios/vmm_shadow_paging.c
+++ b/palacios/src/palacios/vmm_shadow_paging.c
@@ -207,6 +207,10 @@ static int cache_page_tables_32(struct guest_info * info, addr_t pde) {
 }
 
 
+static int cache_page_tables_64(struct guest_info * info, addr_t pde) {
+  return -1;
+}
+
 
 int v3_replace_shdw_page32(struct guest_info * info, addr_t location, pte32_t * new_page, pte32_t * old_page) {
   pde32_t * shadow_pd = (pde32_t *)CR3_TO_PDE32_VA(info->ctrl_regs.cr3);
@@ -293,8 +297,8 @@ static int activate_shadow_pt_64(struct guest_info * info) {
     
     shadow_pt = v3_create_new_shadow_pt();
     
-    shadow_cr3->pdt_base_addr = (addr_t)V3_PAddr((void *)(addr_t)PAGE_BASE_ADDR(shadow_pt));
-    PrintDebug( "Created new shadow page table %p\n", (void *)(addr_t)shadow_cr3->pdt_base_addr );
+    shadow_cr3->pml4t_base_addr = (addr_t)V3_PAddr((void *)(addr_t)PAGE_BASE_ADDR(shadow_pt));
+    PrintDebug( "Created new shadow page table %p\n", (void *)(addr_t)shadow_cr3->pml4t_base_addr );
   } else {
     PrintDebug("Reusing cached shadow Page table\n");
   }