From: Jack Lange <jarusl@cs.northwestern.edu>
Date: Fri, 31 Oct 2008 22:33:35 +0000 (-0500)
Subject: fixed a ton of compile errors...
X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?p=palacios.git;a=commitdiff_plain;h=e20b8f10c2d0be317fc77c75ac36f9fd283d2d8c

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
--- 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
--- 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
--- 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");
   }