Palacios Public Git Repository

To checkout Palacios execute 

  git clone http://v3vee.org/palacios/palacios.web/palacios.git
This will give you the master branch. You probably want the devel branch or one of the release branches. To switch to the devel branch, simply execute 
  cd palacios
  git checkout --track -b devel origin/devel
The other branches are similar.

projects / palacios.git / blobdiff
? search: re
summary | shortlog | log | commit | commitdiff | tree
raw
fixed a ton of compile errors...
[palacios.git] / palacios / src / palacios / vmm_paging.c
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);
                    }
                  }
                }
Public Palacios Development Repository for the V3VEE Project