palacios/src/palacios/vmm_paging.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu>
  11  * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Jack Lange <jarusl@cs.northwestern.edu>
  15  *
  16  * This is free software.  You are permitted to use,
  17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  18  */
  19
  20 #include <palacios/vmm_paging.h>
  21
  22 #include <palacios/vmm.h>
  23
  24 #include <palacios/vm_guest_mem.h>
  25
  26
  27 static pt_entry_type_t pde32_lookup(pde32_t * pd, addr_t addr, addr_t * entry);
  28 static pt_entry_type_t pte32_lookup(pte32_t * pt, addr_t addr, addr_t * entry);
  29
  30 static pt_entry_type_t pdpe32pae_lookup(pdpe32pae_t * pdp, addr_t addr, addr_t * entry);
  31 static pt_entry_type_t pde32pae_lookup(pde32pae_t * pd, addr_t addr, addr_t * entry);
  32 static pt_entry_type_t pte32pae_lookup(pte32pae_t * pt, addr_t addr, addr_t * entry);
  33
  34 static pt_entry_type_t pml4e64_lookup(pml4e64_t * pml, addr_t addr, addr_t * entry);
  35 static pt_entry_type_t pdpe64_lookup(pdpe64_t * pdp, addr_t addr, addr_t * entry);
  36 static pt_entry_type_t pde64_lookup(pde64_t * pd, addr_t addr, addr_t * entry);
  37 static pt_entry_type_t pte64_lookup(pte64_t * pt, addr_t addr, addr_t * entry);
  38
  39
  40
  41
  42 #define USE_VMM_PAGING_DEBUG
  43 // All of the debug functions defined in vmm_paging.h are implemented in this file
  44 #include "vmm_paging_debug.h"
  45 #undef USE_VMM_PAGING_DEBUG
  46
  47
  48
  49
  50
  51 void delete_page_tables_32(pde32_t * pde) {
  52   int i;
  53
  54   if (pde == NULL) {
  55     return;
  56   }
  57
  58   for (i = 0; (i < MAX_PDE32_ENTRIES); i++) {
  59     if (pde[i].present) {
  60       // We double cast, first to an addr_t to handle 64 bit issues, then to the pointer
  61       PrintDebug("PTE base addr %x \n", pde[i].pt_base_addr);
  62       pte32_t * pte = (pte32_t *)((addr_t)(uint_t)(pde[i].pt_base_addr << PAGE_POWER));
  63
  64       PrintDebug("Deleting PTE %d (%p)\n", i, pte);
  65       V3_FreePage(pte);
  66     }
  67   }
  68
  69   PrintDebug("Deleting PDE (%p)\n", pde);
  70   V3_FreePage(V3_PAddr(pde));
  71 }
  72
  73 void delete_page_tables_32PAE(pdpe32pae_t * pdpe) {
  74   PrintError("Unimplemented function\n");
  75 }
  76
  77 void delete_page_tables_64(pml4e64_t * pml4) {
  78   PrintError("Unimplemented function\n");
  79 }
  80
  81
  82
  83
  84 static int translate_pt_32_cb(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
  85   addr_t * paddr = (addr_t *)private_data;
  86
  87   switch (type) {
  88   case PAGE_PD32:
  89   case PAGE_PT32:
  90     return 0;
  91   case PAGE_4MB:
  92     *paddr = page_pa + PAGE_OFFSET_4MB(vaddr);
  93     return 0;
  94   case PAGE_4KB:
  95     *paddr = page_pa + PAGE_OFFSET_4KB(vaddr);
  96     return 0;
  97   default:
  98     PrintError("Inavlid page type (%s) in tranlate pt 32 callback\n", v3_page_type_to_str(type));
  99     return -1;
 100   }
 101 }
 102
 103 static int translate_pt_32pae_cb(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
 104   addr_t * paddr = (addr_t *)private_data;
 105
 106   switch (type) {
 107   case PAGE_PDP32PAE:
 108   case PAGE_PD32PAE:
 109   case PAGE_PT32PAE:
 110     return 0;
 111   case PAGE_2MB:
 112     *paddr = page_pa + PAGE_OFFSET_2MB(vaddr);
 113     return 0;
 114   case PAGE_4KB:
 115     *paddr = page_pa + PAGE_OFFSET_4KB(vaddr);
 116     return 0;
 117   default:
 118     PrintError("Inavlid page type (%s) in translate pt 32pae callback\n", v3_page_type_to_str(type));
 119     return -1;
 120   }
 121 }
 122
 123 static int translate_pt_64_cb(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
 124   addr_t * paddr = (addr_t *)private_data;
 125
 126   switch (type) {
 127   case PAGE_PML464:
 128   case PAGE_PDP64:
 129   case PAGE_PD64:
 130   case PAGE_PT64:
 131     return 0;
 132   case PAGE_1GB:
 133     *paddr = page_pa + PAGE_OFFSET_1GB(vaddr);
 134     return 0;
 135   case PAGE_2MB:
 136     *paddr = page_pa + PAGE_OFFSET_2MB(vaddr);
 137     return 0;
 138   case PAGE_4KB:
 139     *paddr = page_pa + PAGE_OFFSET_4KB(vaddr);
 140     return 0;
 141   default:
 142     PrintError("Inavlid page type (%s) in translate pt 64 callback\n", v3_page_type_to_str(type));
 143     return -1;
 144   }
 145 }
 146
 147
 148 int v3_translate_host_pt_32(v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr) {
 149   return v3_drill_host_pt_32(host_cr3, vaddr, translate_pt_32_cb, paddr);
 150 }
 151 int v3_translate_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr) {
 152   return v3_drill_guest_pt_32(info, guest_cr3, vaddr, translate_pt_32_cb, paddr);
 153 }
 154
 155
 156 int v3_translate_host_pt_32pae(v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr) {
 157   return v3_drill_host_pt_32pae(host_cr3, vaddr, translate_pt_32pae_cb, paddr);
 158 }
 159 int v3_translate_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr) {
 160   return v3_drill_guest_pt_32pae(info, guest_cr3, vaddr, translate_pt_32pae_cb, paddr);
 161 }
 162
 163
 164 int v3_translate_host_pt_64(v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr) {
 165   return v3_drill_host_pt_64(host_cr3, vaddr, translate_pt_64_cb, paddr);
 166 }
 167 int v3_translate_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr) {
 168   return v3_drill_guest_pt_64(info, guest_cr3, vaddr, translate_pt_64_cb, paddr);
 169 }
 170
 171
 172
 173 struct pt_find_data {
 174   page_type_t type;
 175   addr_t * pt_page_addr;
 176 };
 177
 178 static int find_pt_cb(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
 179   struct pt_find_data * pt_data = (struct pt_find_data *)private_data;
 180
 181   if (type == pt_data->type) {
 182     *(pt_data->pt_page_addr) = page_ptr;
 183     return 1;
 184   }
 185
 186   return 0;
 187 }
 188
 189
 190 int v3_find_host_pt_32_page(v3_reg_t host_cr3, page_type_t type, addr_t vaddr, addr_t * page_addr) {
 191   struct pt_find_data data;
 192
 193   data.type = type;
 194   data.pt_page_addr = page_addr;
 195
 196   return v3_drill_host_pt_32(host_cr3, vaddr, find_pt_cb, &data);
 197 }
 198
 199 int v3_find_host_pt_32pae_page(v3_reg_t host_cr3, page_type_t type, addr_t vaddr, addr_t * page_addr) {
 200   struct pt_find_data data;
 201
 202   data.type = type;
 203   data.pt_page_addr = page_addr;
 204
 205   return v3_drill_host_pt_32pae(host_cr3, vaddr, find_pt_cb, &data);
 206 }
 207
 208 int v3_find_host_pt_64_page(v3_reg_t host_cr3, page_type_t type, addr_t vaddr, addr_t * page_addr) {
 209   struct pt_find_data data;
 210
 211   data.type = type;
 212   data.pt_page_addr = page_addr;
 213
 214   return v3_drill_host_pt_64(host_cr3, vaddr, find_pt_cb, &data);
 215 }
 216 int v3_find_guest_pt_32_page(struct guest_info * info, v3_reg_t guest_cr3, page_type_t type, addr_t vaddr, addr_t * page_addr) {
 217   struct pt_find_data data;
 218
 219   data.type = type;
 220   data.pt_page_addr = page_addr;
 221
 222   return v3_drill_guest_pt_32(info, guest_cr3, vaddr, find_pt_cb, &data);
 223 }
 224
 225 int v3_find_guest_pt_32pae_page(struct guest_info * info, v3_reg_t guest_cr3, page_type_t type, addr_t vaddr, addr_t * page_addr) {
 226   struct pt_find_data data;
 227
 228   data.type = type;
 229   data.pt_page_addr = page_addr;
 230
 231   return v3_drill_guest_pt_32pae(info, guest_cr3, vaddr, find_pt_cb, &data);
 232 }
 233
 234 int v3_find_guest_pt_64_page(struct guest_info * info, v3_reg_t guest_cr3, page_type_t type, addr_t vaddr, addr_t * page_addr) {
 235   struct pt_find_data data;
 236
 237   data.type = type;
 238   data.pt_page_addr = page_addr;
 239
 240   return v3_drill_guest_pt_64(info, guest_cr3, vaddr, find_pt_cb, &data);
 241 }
 242
 243
 244 /*
 245  *
 246  * Page Table Access Checks
 247  *
 248  */
 249
 250
 251 struct pt_check_data {
 252   pf_error_t access_type;
 253   pt_access_status_t * access_status;
 254 };
 255
 256 static int check_pt_32_cb(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
 257   struct pt_check_data * chk_data = (struct pt_check_data *)private_data;
 258
 259   switch (type) {
 260   case PAGE_PD32:
 261     *(chk_data->access_status) = v3_can_access_pde32((pde32_t *)page_ptr, vaddr, chk_data->access_type);
 262     break;
 263   case PAGE_PT32:
 264     *(chk_data->access_status) = v3_can_access_pte32((pte32_t *)page_ptr, vaddr, chk_data->access_type);
 265     break;
 266   case PAGE_4MB:
 267   case PAGE_4KB:
 268     return 0;
 269   default:
 270     PrintError("Inavlid page type (%s) in check pt 32 callback\n", v3_page_type_to_str(type));
 271     return -1;
 272   }
 273
 274   if (chk_data->access_status != PT_ACCESS_OK) {
 275     return 1;
 276   }
 277
 278   return 0;
 279 }
 280
 281
 282 static int check_pt_32pae_cb(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
 283   struct pt_check_data * chk_data = (struct pt_check_data *)private_data;
 284
 285   switch (type) {
 286   case PAGE_PDP32PAE:
 287     *(chk_data->access_status) = v3_can_access_pdpe32pae((pdpe32pae_t *)page_ptr, vaddr, chk_data->access_type);
 288     break;
 289   case PAGE_PD32PAE:
 290     *(chk_data->access_status) = v3_can_access_pde32pae((pde32pae_t *)page_ptr, vaddr, chk_data->access_type);
 291     break;
 292   case PAGE_PT32PAE:
 293     *(chk_data->access_status) = v3_can_access_pte32pae((pte32pae_t *)page_ptr, vaddr, chk_data->access_type);
 294     break;
 295   case PAGE_2MB:
 296   case PAGE_4KB:
 297     return 0;
 298   default:
 299     PrintError("Inavlid page type (%s) in check pt 32pae callback\n", v3_page_type_to_str(type));
 300     return -1;
 301   }
 302
 303   if (chk_data->access_status != PT_ACCESS_OK) {
 304     return 1;
 305   }
 306
 307   return 0;
 308 }
 309
 310
 311 static int check_pt_64_cb(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
 312   struct pt_check_data * chk_data = (struct pt_check_data *)private_data;
 313
 314   switch (type) {
 315   case PAGE_PML464:
 316     *(chk_data->access_status) = v3_can_access_pml4e64((pml4e64_t *)page_ptr, vaddr, chk_data->access_type);
 317     break;
 318   case PAGE_PDP64:
 319     *(chk_data->access_status) = v3_can_access_pdpe64((pdpe64_t *)page_ptr, vaddr, chk_data->access_type);
 320     break;
 321   case PAGE_PD64:
 322     *(chk_data->access_status) = v3_can_access_pde64((pde64_t *)page_ptr, vaddr, chk_data->access_type);
 323     break;
 324   case PAGE_PT64:
 325     *(chk_data->access_status) = v3_can_access_pte64((pte64_t *)page_ptr, vaddr, chk_data->access_type);
 326     break;
 327   case PAGE_1GB:
 328   case PAGE_2MB:
 329   case PAGE_4KB:
 330     return 0;
 331   default:
 332     PrintError("Inavlid page type (%s) in check pt 64 callback\n", v3_page_type_to_str(type));
 333     return -1;
 334   }
 335
 336   if (chk_data->access_status != PT_ACCESS_OK) {
 337     return 1;
 338   }
 339
 340   return 0;
 341 }
 342
 343
 344
 345 int v3_check_host_pt_32(v3_reg_t host_cr3, addr_t vaddr, pf_error_t access_type, pt_access_status_t * access_status) {
 346   struct pt_check_data access_data;
 347
 348   access_data.access_type = access_type;
 349   access_data.access_status = access_status;
 350
 351   return v3_drill_host_pt_32(host_cr3, vaddr, check_pt_32_cb, &access_data);
 352 }
 353
 354 int v3_check_host_pt_32pae(v3_reg_t host_cr3, addr_t vaddr, pf_error_t access_type, pt_access_status_t * access_status) {
 355   struct pt_check_data access_data;
 356
 357   access_data.access_type = access_type;
 358   access_data.access_status = access_status;
 359
 360   return v3_drill_host_pt_32pae(host_cr3, vaddr, check_pt_32pae_cb, &access_data);
 361 }
 362
 363
 364
 365 int v3_check_host_pt_64(v3_reg_t host_cr3, addr_t vaddr, pf_error_t access_type, pt_access_status_t * access_status) {
 366   struct pt_check_data access_data;
 367
 368   access_data.access_type = access_type;
 369   access_data.access_status = access_status;
 370
 371   return v3_drill_host_pt_64(host_cr3, vaddr, check_pt_64_cb, &access_data);
 372 }
 373
 374
 375
 376 int v3_check_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 377                          pf_error_t access_type, pt_access_status_t * access_status) {
 378   struct pt_check_data access_data;
 379
 380   access_data.access_type = access_type;
 381   access_data.access_status = access_status;
 382
 383   return v3_drill_guest_pt_32(info, guest_cr3, vaddr, check_pt_32_cb, &access_data);
 384 }
 385
 386
 387
 388
 389
 390 int v3_check_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 391                             pf_error_t access_type, pt_access_status_t * access_status) {
 392   struct pt_check_data access_data;
 393
 394   access_data.access_type = access_type;
 395   access_data.access_status = access_status;
 396
 397   return v3_drill_guest_pt_32pae(info, guest_cr3, vaddr, check_pt_32pae_cb, &access_data);
 398 }
 399
 400
 401
 402 int v3_check_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 403                          pf_error_t access_type, pt_access_status_t * access_status) {
 404   struct pt_check_data access_data;
 405
 406   access_data.access_type = access_type;
 407   access_data.access_status = access_status;
 408
 409   return v3_drill_guest_pt_64(info, guest_cr3, vaddr, check_pt_64_cb, &access_data);
 410 }
 411
 412
 413
 414 /*
 415  * PAGE TABLE LOOKUP FUNCTIONS
 416  *
 417  * The value of entry is a return type:
 418  * Page not present: *entry = 0
 419  */
 420
 421 /**
 422  *
 423  *  32 bit Page Table lookup functions
 424  *
 425  **/
 426
 427 static pt_entry_type_t pde32_lookup(pde32_t * pd, addr_t addr, addr_t * entry) {
 428   pde32_t * pde_entry = &(pd[PDE32_INDEX(addr)]);
 429
 430   if (!pde_entry->present) {
 431     *entry = 0;
 432     return PT_ENTRY_NOT_PRESENT;
 433   } else if (pde_entry->large_page) {
 434     pde32_4MB_t * large_pde = (pde32_4MB_t *)pde_entry;
 435
 436     *entry = BASE_TO_PAGE_ADDR_4MB(large_pde->page_base_addr);
 437
 438     return PT_ENTRY_LARGE_PAGE;
 439   } else {
 440     *entry = BASE_TO_PAGE_ADDR(pde_entry->pt_base_addr);
 441     return PT_ENTRY_PAGE;
 442   }
 443 }
 444
 445
 446
 447 /* Takes a virtual addr (addr) and returns the physical addr (entry) as defined in the page table
 448  */
 449 static pt_entry_type_t pte32_lookup(pte32_t * pt, addr_t addr, addr_t * entry) {
 450   pte32_t * pte_entry = &(pt[PTE32_INDEX(addr)]);
 451
 452   if (!pte_entry->present) {
 453     *entry = 0;
 454     //    PrintDebug("Lookup at non present page (index=%d)\n", PTE32_INDEX(addr));
 455     return PT_ENTRY_NOT_PRESENT;
 456   } else {
 457     *entry = BASE_TO_PAGE_ADDR(pte_entry->page_base_addr);
 458
 459     return PT_ENTRY_PAGE;
 460   }
 461
 462 }
 463
 464
 465
 466 /**
 467  *
 468  *  32 bit PAE Page Table lookup functions
 469  *
 470  **/
 471 static pt_entry_type_t pdpe32pae_lookup(pdpe32pae_t * pdp, addr_t addr, addr_t * entry) {
 472   pdpe32pae_t * pdpe_entry = &(pdp[PDPE32PAE_INDEX(addr)]);
 473
 474   if (!pdpe_entry->present) {
 475     *entry = 0;
 476     return PT_ENTRY_NOT_PRESENT;
 477   } else {
 478     *entry = BASE_TO_PAGE_ADDR(pdpe_entry->pd_base_addr);
 479     return PT_ENTRY_PAGE;
 480   }
 481 }
 482
 483 static pt_entry_type_t pde32pae_lookup(pde32pae_t * pd, addr_t addr, addr_t * entry) {
 484   pde32pae_t * pde_entry = &(pd[PDE32PAE_INDEX(addr)]);
 485
 486   if (!pde_entry->present) {
 487     *entry = 0;
 488     return PT_ENTRY_NOT_PRESENT;
 489   } else if (pde_entry->large_page) {
 490     pde32pae_2MB_t * large_pde = (pde32pae_2MB_t *)pde_entry;
 491
 492     *entry = BASE_TO_PAGE_ADDR_2MB(large_pde->page_base_addr);
 493
 494     return PT_ENTRY_LARGE_PAGE;
 495   } else {
 496     *entry = BASE_TO_PAGE_ADDR(pde_entry->pt_base_addr);
 497     return PT_ENTRY_PAGE;
 498   }
 499 }
 500
 501 static pt_entry_type_t pte32pae_lookup(pte32pae_t * pt, addr_t addr, addr_t * entry) {
 502   pte32pae_t * pte_entry = &(pt[PTE32PAE_INDEX(addr)]);
 503
 504   if (!pte_entry->present) {
 505     *entry = 0;
 506     return PT_ENTRY_NOT_PRESENT;
 507   } else {
 508     *entry = BASE_TO_PAGE_ADDR(pte_entry->page_base_addr);
 509     return PT_ENTRY_PAGE;
 510   }
 511 }
 512
 513
 514
 515 /**
 516  *
 517  *  64 bit Page Table lookup functions
 518  *
 519  **/
 520 static pt_entry_type_t pml4e64_lookup(pml4e64_t * pml, addr_t addr, addr_t * entry) {
 521   pml4e64_t * pml_entry = &(pml[PML4E64_INDEX(addr)]);
 522
 523   if (!pml_entry->present) {
 524     *entry = 0;
 525     return PT_ENTRY_NOT_PRESENT;
 526   } else {
 527     *entry = BASE_TO_PAGE_ADDR(pml_entry->pdp_base_addr);
 528     return PT_ENTRY_PAGE;
 529   }
 530 }
 531
 532 static pt_entry_type_t pdpe64_lookup(pdpe64_t * pdp, addr_t addr, addr_t * entry) {
 533   pdpe64_t * pdpe_entry = &(pdp[PDPE64_INDEX(addr)]);
 534
 535   if (!pdpe_entry->present) {
 536     *entry = 0;
 537     return PT_ENTRY_NOT_PRESENT;
 538   } else if (pdpe_entry->large_page) {
 539     PrintError("1 Gigabyte pages not supported\n");
 540     V3_ASSERT(0);
 541     return -1;
 542   } else {
 543     *entry = BASE_TO_PAGE_ADDR(pdpe_entry->pd_base_addr);
 544     return PT_ENTRY_PAGE;
 545   }
 546 }
 547
 548 static pt_entry_type_t pde64_lookup(pde64_t * pd, addr_t addr, addr_t * entry) {
 549   pde64_t * pde_entry = &(pd[PDE64_INDEX(addr)]);
 550
 551   if (!pde_entry->present) {
 552     *entry = 0;
 553     return PT_ENTRY_NOT_PRESENT;
 554   } else if (pde_entry->large_page) {
 555     pde64_2MB_t * large_pde = (pde64_2MB_t *)pde_entry;
 556
 557     *entry = BASE_TO_PAGE_ADDR_2MB(large_pde->page_base_addr);
 558
 559     return PT_ENTRY_LARGE_PAGE;
 560   } else {
 561     *entry = BASE_TO_PAGE_ADDR(pde_entry->pt_base_addr);
 562     return PT_ENTRY_PAGE;
 563   }
 564 }
 565
 566 static pt_entry_type_t pte64_lookup(pte64_t * pt, addr_t addr, addr_t * entry) {
 567   pte64_t * pte_entry = &(pt[PTE64_INDEX(addr)]);
 568
 569   if (!pte_entry->present) {
 570     *entry = 0;
 571     return PT_ENTRY_NOT_PRESENT;
 572   } else {
 573     *entry = BASE_TO_PAGE_ADDR(pte_entry->page_base_addr);
 574     return PT_ENTRY_PAGE;
 575   }
 576 }
 577
 578
 579
 580
 581 static pt_access_status_t can_access_pt_entry(gen_pt_t * pt, pf_error_t access_type) {
 582   if (pt->present == 0) {
 583     return PT_ACCESS_NOT_PRESENT;
 584   } else if ((pt->writable == 0) && (access_type.write == 1)) {
 585     return PT_ACCESS_WRITE_ERROR;
 586   } else if ((pt->user_page == 0) && (access_type.user == 1)) {
 587     // Check CR0.WP?
 588     return PT_ACCESS_USER_ERROR;
 589   }
 590
 591   return PT_ACCESS_OK;
 592 }
 593
 594
 595
 596 /*
 597  *   32 bit access checks
 598  */
 599 pt_access_status_t inline v3_can_access_pde32(pde32_t * pde, addr_t addr, pf_error_t access_type) {
 600   gen_pt_t * entry = (gen_pt_t *)&pde[PDE32_INDEX(addr)];
 601   return can_access_pt_entry(entry, access_type);
 602 }
 603
 604 pt_access_status_t inline v3_can_access_pte32(pte32_t * pte, addr_t addr, pf_error_t access_type) {
 605   gen_pt_t * entry = (gen_pt_t *)&pte[PTE32_INDEX(addr)];
 606   return can_access_pt_entry(entry, access_type);
 607 }
 608
 609
 610 /*
 611  *  32 bit PAE access checks
 612  */
 613 pt_access_status_t inline v3_can_access_pdpe32pae(pdpe32pae_t * pdpe, addr_t addr, pf_error_t access_type) {
 614   gen_pt_t * entry = (gen_pt_t *)&pdpe[PDPE32PAE_INDEX(addr)];
 615   return can_access_pt_entry(entry, access_type);
 616 }
 617
 618 pt_access_status_t inline v3_can_access_pde32pae(pde32pae_t * pde, addr_t addr, pf_error_t access_type) {
 619   gen_pt_t * entry = (gen_pt_t *)&pde[PDE32PAE_INDEX(addr)];
 620   return can_access_pt_entry(entry, access_type);
 621 }
 622
 623 pt_access_status_t inline v3_can_access_pte32pae(pte32pae_t * pte, addr_t addr, pf_error_t access_type) {
 624   gen_pt_t * entry = (gen_pt_t *)&pte[PTE32PAE_INDEX(addr)];
 625   return can_access_pt_entry(entry, access_type);
 626 }
 627
 628 /*
 629  *   64 Bit access checks
 630  */
 631 pt_access_status_t inline v3_can_access_pml4e64(pml4e64_t * pmle, addr_t addr, pf_error_t access_type) {
 632   gen_pt_t * entry = (gen_pt_t *)&pmle[PML4E64_INDEX(addr)];
 633   return can_access_pt_entry(entry, access_type);
 634 }
 635
 636 pt_access_status_t inline v3_can_access_pdpe64(pdpe64_t * pdpe, addr_t addr, pf_error_t access_type) {
 637   gen_pt_t * entry = (gen_pt_t *)&pdpe[PDPE64_INDEX(addr)];
 638   return can_access_pt_entry(entry, access_type);
 639 }
 640
 641 pt_access_status_t inline v3_can_access_pde64(pde64_t * pde, addr_t addr, pf_error_t access_type) {
 642   gen_pt_t * entry = (gen_pt_t *)&pde[PDE32_INDEX(addr)];
 643   return can_access_pt_entry(entry, access_type);
 644 }
 645
 646 pt_access_status_t inline v3_can_access_pte64(pte64_t * pte, addr_t addr, pf_error_t access_type) {
 647   gen_pt_t * entry = (gen_pt_t *)&pte[PTE64_INDEX(addr)];
 648   return can_access_pt_entry(entry, access_type);
 649 }
 650
 651
 652
 653
 654
 655
 656
 657
 658
 659
 660 /* We generate a page table to correspond to a given memory layout
 661  * pulling pages from the mem_list when necessary
 662  * If there are any gaps in the layout, we add them as unmapped pages
 663  */
 664 pde32_t * create_passthrough_pts_32(struct guest_info * guest_info) {
 665   addr_t current_page_addr = 0;
 666   int i, j;
 667   struct shadow_map * map = &(guest_info->mem_map);
 668
 669   pde32_t * pde = V3_VAddr(V3_AllocPages(1));
 670
 671   for (i = 0; i < MAX_PDE32_ENTRIES; i++) {
 672     int pte_present = 0;
 673     pte32_t * pte = V3_VAddr(V3_AllocPages(1));
 674
 675
 676     for (j = 0; j < MAX_PTE32_ENTRIES; j++) {
 677       struct shadow_region * region = get_shadow_region_by_addr(map, current_page_addr);
 678
 679       if (!region ||
 680           (region->host_type == SHDW_REGION_FULL_HOOK) ||
 681           (region->host_type == SHDW_REGION_UNALLOCATED)) {
 682         pte[j].present = 0;
 683         pte[j].writable = 0;
 684         pte[j].user_page = 0;
 685         pte[j].write_through = 0;
 686         pte[j].cache_disable = 0;
 687         pte[j].accessed = 0;
 688         pte[j].dirty = 0;
 689         pte[j].pte_attr = 0;
 690         pte[j].global_page = 0;
 691         pte[j].vmm_info = 0;
 692         pte[j].page_base_addr = 0;
 693       } else {
 694         addr_t host_addr;
 695         pte[j].present = 1;
 696
 697         if (region->host_type == SHDW_REGION_WRITE_HOOK) {
 698           pte[j].writable = 0;
 699           PrintDebug("Marking Write hook host_addr %p as RO\n", (void *)current_page_addr);
 700         } else {
 701           pte[j].writable = 1;
 702         }
 703
 704         pte[j].user_page = 1;
 705         pte[j].write_through = 0;
 706         pte[j].cache_disable = 0;
 707         pte[j].accessed = 0;
 708         pte[j].dirty = 0;
 709         pte[j].pte_attr = 0;
 710         pte[j].global_page = 0;
 711         pte[j].vmm_info = 0;
 712
 713         if (guest_pa_to_host_pa(guest_info, current_page_addr, &host_addr) == -1) {
 714           // BIG ERROR
 715           // PANIC
 716           return NULL;
 717         }
 718
 719         pte[j].page_base_addr = host_addr >> 12;
 720
 721         pte_present = 1;
 722       }
 723
 724       current_page_addr += PAGE_SIZE;
 725     }
 726
 727     if (pte_present == 0) {
 728       V3_FreePage(V3_PAddr(pte));
 729
 730       pde[i].present = 0;
 731       pde[i].writable = 0;
 732       pde[i].user_page = 0;
 733       pde[i].write_through = 0;
 734       pde[i].cache_disable = 0;
 735       pde[i].accessed = 0;
 736       pde[i].reserved = 0;
 737       pde[i].large_page = 0;
 738       pde[i].global_page = 0;
 739       pde[i].vmm_info = 0;
 740       pde[i].pt_base_addr = 0;
 741     } else {
 742       pde[i].present = 1;
 743       pde[i].writable = 1;
 744       pde[i].user_page = 1;
 745       pde[i].write_through = 0;
 746       pde[i].cache_disable = 0;
 747       pde[i].accessed = 0;
 748       pde[i].reserved = 0;
 749       pde[i].large_page = 0;
 750       pde[i].global_page = 0;
 751       pde[i].vmm_info = 0;
 752       pde[i].pt_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pte));
 753     }
 754
 755   }
 756
 757   return pde;
 758 }
 759
 760
 761 /* We generate a page table to correspond to a given memory layout
 762  * pulling pages from the mem_list when necessary
 763  * If there are any gaps in the layout, we add them as unmapped pages
 764  */
 765 pdpe32pae_t * create_passthrough_pts_32PAE(struct guest_info * guest_info) {
 766   addr_t current_page_addr = 0;
 767   int i, j, k;
 768   struct shadow_map * map = &(guest_info->mem_map);
 769
 770   pdpe32pae_t * pdpe = V3_VAddr(V3_AllocPages(1));
 771   memset(pdpe, 0, PAGE_SIZE);
 772
 773   for (i = 0; i < MAX_PDPE32PAE_ENTRIES; i++) {
 774     int pde_present = 0;
 775     pde32pae_t * pde = V3_VAddr(V3_AllocPages(1));
 776
 777     for (j = 0; j < MAX_PDE32PAE_ENTRIES; j++) {
 778
 779
 780       int pte_present = 0;
 781       pte32pae_t * pte = V3_VAddr(V3_AllocPages(1));
 782
 783
 784       for (k = 0; k < MAX_PTE32PAE_ENTRIES; k++) {
 785         struct shadow_region * region = get_shadow_region_by_addr(map, current_page_addr);
 786
 787         if (!region ||
 788             (region->host_type == SHDW_REGION_FULL_HOOK) ||
 789             (region->host_type == SHDW_REGION_UNALLOCATED)) {
 790           pte[k].present = 0;
 791           pte[k].writable = 0;
 792           pte[k].user_page = 0;
 793           pte[k].write_through = 0;
 794           pte[k].cache_disable = 0;
 795           pte[k].accessed = 0;
 796           pte[k].dirty = 0;
 797           pte[k].pte_attr = 0;
 798           pte[k].global_page = 0;
 799           pte[k].vmm_info = 0;
 800           pte[k].page_base_addr = 0;
 801           pte[k].rsvd = 0;
 802         } else {
 803           addr_t host_addr;
 804           pte[k].present = 1;
 805
 806           if (region->host_type == SHDW_REGION_WRITE_HOOK) {
 807             pte[k].writable = 0;
 808           } else {
 809             pte[k].writable = 1;
 810           }
 811
 812           pte[k].user_page = 1;
 813           pte[k].write_through = 0;
 814           pte[k].cache_disable = 0;
 815           pte[k].accessed = 0;
 816           pte[k].dirty = 0;
 817           pte[k].pte_attr = 0;
 818           pte[k].global_page = 0;
 819           pte[k].vmm_info = 0;
 820
 821           if (guest_pa_to_host_pa(guest_info, current_page_addr, &host_addr) == -1) {
 822             // BIG ERROR
 823             // PANIC
 824             return NULL;
 825           }
 826
 827           pte[k].page_base_addr = host_addr >> 12;
 828           pte[k].rsvd = 0;
 829
 830           pte_present = 1;
 831         }
 832
 833         current_page_addr += PAGE_SIZE;
 834       }
 835
 836       if (pte_present == 0) {
 837         V3_FreePage(V3_PAddr(pte));
 838
 839         pde[j].present = 0;
 840         pde[j].writable = 0;
 841         pde[j].user_page = 0;
 842         pde[j].write_through = 0;
 843         pde[j].cache_disable = 0;
 844         pde[j].accessed = 0;
 845         pde[j].avail = 0;
 846         pde[j].large_page = 0;
 847         pde[j].global_page = 0;
 848         pde[j].vmm_info = 0;
 849         pde[j].pt_base_addr = 0;
 850         pde[j].rsvd = 0;
 851       } else {
 852         pde[j].present = 1;
 853         pde[j].writable = 1;
 854         pde[j].user_page = 1;
 855         pde[j].write_through = 0;
 856         pde[j].cache_disable = 0;
 857         pde[j].accessed = 0;
 858         pde[j].avail = 0;
 859         pde[j].large_page = 0;
 860         pde[j].global_page = 0;
 861         pde[j].vmm_info = 0;
 862         pde[j].pt_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pte));
 863         pde[j].rsvd = 0;
 864
 865         pde_present = 1;
 866       }
 867
 868     }
 869
 870     if (pde_present == 0) {
 871       V3_FreePage(V3_PAddr(pde));
 872
 873       pdpe[i].present = 0;
 874       pdpe[i].rsvd = 0;
 875       pdpe[i].write_through = 0;
 876       pdpe[i].cache_disable = 0;
 877       pdpe[i].accessed = 0;
 878       pdpe[i].avail = 0;
 879       pdpe[i].rsvd2 = 0;
 880       pdpe[i].vmm_info = 0;
 881       pdpe[i].pd_base_addr = 0;
 882       pdpe[i].rsvd3 = 0;
 883     } else {
 884       pdpe[i].present = 1;
 885       pdpe[i].rsvd = 0;
 886       pdpe[i].write_through = 0;
 887       pdpe[i].cache_disable = 0;
 888       pdpe[i].accessed = 0;
 889       pdpe[i].avail = 0;
 890       pdpe[i].rsvd2 = 0;
 891       pdpe[i].vmm_info = 0;
 892       pdpe[i].pd_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pde));
 893       pdpe[i].rsvd3 = 0;
 894     }
 895
 896   }
 897
 898
 899   return pdpe;
 900 }
 901
 902
 903
 904
 905
 906
 907 pml4e64_t * create_passthrough_pts_64(struct guest_info * info) {
 908   addr_t current_page_addr = 0;
 909   int i, j, k, m;
 910   struct shadow_map * map = &(info->mem_map);
 911
 912   pml4e64_t * pml = V3_VAddr(V3_AllocPages(1));
 913
 914   for (i = 0; i < 1; i++) {
 915     int pdpe_present = 0;
 916     pdpe64_t * pdpe = V3_VAddr(V3_AllocPages(1));
 917
 918     for (j = 0; j < 20; j++) {
 919       int pde_present = 0;
 920       pde64_t * pde = V3_VAddr(V3_AllocPages(1));
 921
 922       for (k = 0; k < MAX_PDE64_ENTRIES; k++) {
 923         int pte_present = 0;
 924         pte64_t * pte = V3_VAddr(V3_AllocPages(1));
 925
 926
 927         for (m = 0; m < MAX_PTE64_ENTRIES; m++) {
 928           struct shadow_region * region = get_shadow_region_by_addr(map, current_page_addr);
 929
 930
 931
 932           if (!region ||
 933               (region->host_type == SHDW_REGION_FULL_HOOK) ||
 934               (region->host_type == SHDW_REGION_UNALLOCATED)) {
 935             pte[m].present = 0;
 936             pte[m].writable = 0;
 937             pte[m].user_page = 0;
 938             pte[m].write_through = 0;
 939             pte[m].cache_disable = 0;
 940             pte[m].accessed = 0;
 941             pte[m].dirty = 0;
 942             pte[m].pte_attr = 0;
 943             pte[m].global_page = 0;
 944             pte[m].vmm_info = 0;
 945             pte[m].page_base_addr = 0;
 946           } else {
 947             addr_t host_addr;
 948             pte[m].present = 1;
 949
 950             if (region->host_type == SHDW_REGION_WRITE_HOOK) {
 951               pte[m].writable = 0;
 952             } else {
 953               pte[m].writable = 1;
 954             }
 955
 956             pte[m].user_page = 1;
 957             pte[m].write_through = 0;
 958             pte[m].cache_disable = 0;
 959             pte[m].accessed = 0;
 960             pte[m].dirty = 0;
 961             pte[m].pte_attr = 0;
 962             pte[m].global_page = 0;
 963             pte[m].vmm_info = 0;
 964
 965             if (guest_pa_to_host_pa(info, current_page_addr, &host_addr) == -1) {
 966               // BIG ERROR
 967               // PANIC
 968               return NULL;
 969             }
 970
 971             pte[m].page_base_addr = PAGE_BASE_ADDR(host_addr);
 972
 973             //PrintPTE64(current_page_addr, &(pte[m]));
 974
 975             pte_present = 1;
 976           }
 977
 978
 979
 980
 981           current_page_addr += PAGE_SIZE;
 982         }
 983
 984         if (pte_present == 0) {
 985           V3_FreePage(V3_PAddr(pte));
 986
 987           pde[k].present = 0;
 988           pde[k].writable = 0;
 989           pde[k].user_page = 0;
 990           pde[k].write_through = 0;
 991           pde[k].cache_disable = 0;
 992           pde[k].accessed = 0;
 993           pde[k].avail = 0;
 994           pde[k].large_page = 0;
 995           //pde[k].global_page = 0;
 996           pde[k].vmm_info = 0;
 997           pde[k].pt_base_addr = 0;
 998         } else {
 999           pde[k].present = 1;
1000           pde[k].writable = 1;
1001           pde[k].user_page = 1;
1002           pde[k].write_through = 0;
1003           pde[k].cache_disable = 0;
1004           pde[k].accessed = 0;
1005           pde[k].avail = 0;
1006           pde[k].large_page = 0;
1007           //pde[k].global_page = 0;
1008           pde[k].vmm_info = 0;
1009           pde[k].pt_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pte));
1010
1011           pde_present = 1;
1012         }
1013       }
1014
1015       if (pde_present == 0) {
1016         V3_FreePage(V3_PAddr(pde));
1017
1018         pdpe[j].present = 0;
1019         pdpe[j].writable = 0;
1020         pdpe[j].user_page = 0;
1021         pdpe[j].write_through = 0;
1022         pdpe[j].cache_disable = 0;
1023         pdpe[j].accessed = 0;
1024         pdpe[j].avail = 0;
1025         pdpe[j].large_page = 0;
1026         //pdpe[j].global_page = 0;
1027         pdpe[j].vmm_info = 0;
1028         pdpe[j].pd_base_addr = 0;
1029       } else {
1030         pdpe[j].present = 1;
1031         pdpe[j].writable = 1;
1032         pdpe[j].user_page = 1;
1033         pdpe[j].write_through = 0;
1034         pdpe[j].cache_disable = 0;
1035         pdpe[j].accessed = 0;
1036         pdpe[j].avail = 0;
1037         pdpe[j].large_page = 0;
1038         //pdpe[j].global_page = 0;
1039         pdpe[j].vmm_info = 0;
1040         pdpe[j].pd_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pde));
1041
1042
1043         pdpe_present = 1;
1044       }
1045
1046     }
1047
1048     PrintDebug("PML index=%d\n", i);
1049
1050     if (pdpe_present == 0) {
1051       V3_FreePage(V3_PAddr(pdpe));
1052
1053       pml[i].present = 0;
1054       pml[i].writable = 0;
1055       pml[i].user_page = 0;
1056       pml[i].write_through = 0;
1057       pml[i].cache_disable = 0;
1058       pml[i].accessed = 0;
1059       pml[i].reserved = 0;
1060       //pml[i].large_page = 0;
1061       //pml[i].global_page = 0;
1062       pml[i].vmm_info = 0;
1063       pml[i].pdp_base_addr = 0;
1064     } else {
1065       pml[i].present = 1;
1066       pml[i].writable = 1;
1067       pml[i].user_page = 1;
1068       pml[i].write_through = 0;
1069       pml[i].cache_disable = 0;
1070       pml[i].accessed = 0;
1071       pml[i].reserved = 0;
1072       //pml[i].large_page = 0;
1073       //pml[i].global_page = 0;
1074       pml[i].vmm_info = 0;
1075       pml[i].pdp_base_addr = PAGE_BASE_ADDR((addr_t)V3_PAddr(pdpe));
1076     }
1077   }
1078
1079   return pml;
1080 }
1081
1082
1083 int v3_drill_host_pt_32(v3_reg_t host_cr3, addr_t vaddr,
1084                         int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1085                         void * private_data) {
1086   pde32_t * host_pde = (pde32_t *)CR3_TO_PDE32_VA(host_cr3);
1087   addr_t host_pde_pa = CR3_TO_PDE32_PA(host_cr3);
1088   addr_t host_pte_pa = 0;
1089   addr_t page_pa = 0;
1090   int ret;
1091
1092   if ((ret = callback(PAGE_PD32, vaddr, (addr_t)host_pde, host_pde_pa, private_data)) != 0) {
1093     return (ret == -1) ? -1 : PAGE_PD32;
1094   }
1095
1096   switch (pde32_lookup(host_pde, vaddr, &host_pte_pa)) {
1097   case PT_ENTRY_NOT_PRESENT:
1098     return -1;
1099   case PT_ENTRY_LARGE_PAGE:
1100     if ((ret == callback(PAGE_4MB, vaddr, (addr_t)V3_VAddr((void *)host_pte_pa), host_pte_pa, private_data)) != 0) {
1101       return (ret == -1) ? -1 : PAGE_4MB;
1102     }
1103     return 0;
1104   case PT_ENTRY_PAGE:
1105     if ((ret = callback(PAGE_PT32, vaddr, (addr_t)V3_VAddr((void *)host_pte_pa), host_pte_pa, private_data) != 0)) {
1106       return (ret == -1) ? -1 : PAGE_PT32;
1107     }
1108
1109     if (pte32_lookup(V3_VAddr((void *)host_pte_pa), vaddr, &page_pa) == PT_ENTRY_NOT_PRESENT) {
1110       return -1;
1111     } else {
1112       if ((ret = callback(PAGE_4KB, vaddr, (addr_t)V3_VAddr((void *)PAGE_BASE_ADDR(page_pa)), page_pa, private_data)) != 0) {
1113         return (ret == -1) ? -1 : PAGE_4KB;
1114       }
1115       return 0;
1116     }
1117   }
1118   return -1;
1119 }
1120
1121
1122
1123 int v3_drill_host_pt_32pae(v3_reg_t host_cr3, addr_t vaddr,
1124                            int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1125                            void * private_data) {
1126   pdpe32pae_t * host_pdpe = (pdpe32pae_t *)CR3_TO_PDPE32PAE_VA(host_cr3);
1127   addr_t host_pdpe_pa = CR3_TO_PDPE32PAE_PA(host_cr3);
1128   addr_t host_pde_pa = 0;
1129   addr_t host_pte_pa = 0;
1130   addr_t page_pa = 0;
1131   int ret;
1132
1133   if ((ret = callback(PAGE_PDP32PAE, vaddr, (addr_t)host_pdpe, host_pdpe_pa, private_data)) != 0) {
1134     return (ret == -1) ? -1 : PAGE_PDP32PAE;
1135   }
1136
1137   switch (pdpe32pae_lookup(host_pdpe, vaddr, &host_pde_pa)) {
1138   case PT_ENTRY_NOT_PRESENT:
1139     return -1;
1140   case PT_ENTRY_PAGE:
1141
1142     if ((ret = callback(PAGE_PD32PAE, vaddr, (addr_t)V3_VAddr((void *)host_pde_pa), host_pde_pa, private_data) != 0)) {
1143       return (ret == -1) ? -1 : PAGE_PD32PAE;
1144     }
1145
1146     switch (pde32pae_lookup(V3_VAddr((void *)host_pde_pa), vaddr, &host_pte_pa)) {
1147     case PT_ENTRY_NOT_PRESENT:
1148       return -1;
1149     case PT_ENTRY_LARGE_PAGE:
1150       if ((ret == callback(PAGE_2MB, vaddr, (addr_t)V3_VAddr((void *)host_pte_pa), host_pte_pa, private_data)) != 0) {
1151         return (ret == -1) ? -1 : PAGE_2MB;
1152       }
1153       return 0;
1154     case PT_ENTRY_PAGE:
1155       if ((ret = callback(PAGE_PT32PAE, vaddr, (addr_t)V3_VAddr((void *)host_pte_pa), host_pte_pa, private_data) != 0)) {
1156         return (ret == -1) ? -1 : PAGE_PT32PAE;
1157       }
1158
1159       if (pte32pae_lookup(V3_VAddr((void *)host_pte_pa), vaddr, &page_pa) == PT_ENTRY_NOT_PRESENT) {
1160         return -1;
1161       } else {
1162         if ((ret = callback(PAGE_4KB, vaddr, (addr_t)V3_VAddr((void *)PAGE_BASE_ADDR(page_pa)), page_pa, private_data)) != 0) {
1163           return (ret == -1) ? -1 : PAGE_4KB;
1164         }
1165         return 0;
1166       }
1167     }
1168   default:
1169     return -1;
1170   }
1171
1172   // should never get here
1173   return -1;
1174 }
1175
1176
1177 int v3_drill_host_pt_64(v3_reg_t host_cr3, addr_t vaddr,
1178                         int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1179                         void * private_data) {
1180   pml4e64_t * host_pmle = (pml4e64_t *)CR3_TO_PML4E64_VA(host_cr3);
1181   addr_t host_pmle_pa = CR3_TO_PML4E64_PA(host_cr3);
1182   addr_t host_pdpe_pa = 0;
1183   addr_t host_pde_pa = 0;
1184   addr_t host_pte_pa = 0;
1185   addr_t page_pa = 0;
1186   int ret;
1187
1188   if ((ret = callback(PAGE_PML464, vaddr, (addr_t)host_pmle, host_pmle_pa, private_data)) != 0) {
1189     return (ret == -1) ? -1 : PAGE_PML464;
1190   }
1191
1192   switch(pml4e64_lookup(host_pmle, vaddr, &host_pdpe_pa)) {
1193   case PT_ENTRY_NOT_PRESENT:
1194     return -1;
1195   case PT_ENTRY_PAGE:
1196
1197     if ((ret = callback(PAGE_PDP64, vaddr, (addr_t)V3_VAddr((void *)host_pdpe_pa), host_pdpe_pa, private_data)) != 0) {
1198       return (ret == -1) ? -1 : PAGE_PDP64;
1199     }
1200
1201     switch(pdpe64_lookup(V3_VAddr((void *)host_pdpe_pa), vaddr, &host_pde_pa)) {
1202     case PT_ENTRY_NOT_PRESENT:
1203       return -1;
1204     case PT_ENTRY_LARGE_PAGE:
1205       if ((ret == callback(PAGE_1GB, vaddr, (addr_t)V3_VAddr((void *)host_pde_pa), host_pde_pa, private_data)) != 0) {
1206         return (ret == -1) ? -1 : PAGE_1GB;
1207       }
1208       PrintError("1 Gigabyte Pages not supported\n");
1209       return 0;
1210     case PT_ENTRY_PAGE:
1211
1212       if ((ret = callback(PAGE_PD64, vaddr, (addr_t)V3_VAddr((void *)host_pde_pa), host_pde_pa, private_data) != 0)) {
1213         return (ret == -1) ? -1 : PAGE_PD64;
1214       }
1215
1216       switch (pde64_lookup(V3_VAddr((void *)host_pde_pa), vaddr, &host_pte_pa)) {
1217       case PT_ENTRY_NOT_PRESENT:
1218         return -1;
1219       case PT_ENTRY_LARGE_PAGE:
1220         if ((ret == callback(PAGE_2MB, vaddr, (addr_t)V3_VAddr((void *)host_pte_pa), host_pte_pa, private_data)) != 0) {
1221           return (ret == -1) ? -1 : PAGE_2MB;
1222         }
1223         return 0;
1224       case PT_ENTRY_PAGE:
1225
1226         if ((ret = callback(PAGE_PT64, vaddr, (addr_t)V3_VAddr((void *)host_pte_pa), host_pte_pa, private_data) != 0)) {
1227           return (ret == -1) ? -1 : PAGE_PT64;
1228         }
1229
1230         if (pte64_lookup(V3_VAddr((void *)host_pte_pa), vaddr, &page_pa) == PT_ENTRY_NOT_PRESENT) {
1231           return -1;
1232         } else {
1233           if ((ret = callback(PAGE_4KB, vaddr, (addr_t)V3_VAddr((void *)PAGE_BASE_ADDR(page_pa)), page_pa, private_data)) != 0) {
1234             return (ret == -1) ? -1 : PAGE_4KB;
1235           }
1236           return 0;
1237         }
1238       }
1239     }
1240   default:
1241     return -1;
1242   }
1243   // should never get here
1244   return -1;
1245 }
1246
1247
1248
1249
1250
1251
1252
1253 int v3_drill_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
1254                          int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1255                          void * private_data) {
1256   addr_t guest_pde_pa = CR3_TO_PDE32_PA(guest_cr3);
1257   pde32_t * guest_pde = NULL;
1258   addr_t guest_pte_pa = 0;
1259   int ret;
1260
1261
1262   if (guest_pa_to_host_va(info, guest_pde_pa, (addr_t*)&guest_pde) == -1) {
1263     PrintError("Could not get virtual address of Guest PDE32 (PA=%p)\n",
1264                (void *)guest_pde_pa);
1265     return -1;
1266   }
1267
1268   if ((ret = callback(PAGE_PD32, vaddr, (addr_t)guest_pde, guest_pde_pa, private_data)) != 0) {
1269     return (ret == -1) ? -1 : PAGE_PD32;
1270   }
1271
1272   switch (pde32_lookup(guest_pde, vaddr, &guest_pte_pa)) {
1273   case PT_ENTRY_NOT_PRESENT:
1274     return -1;
1275   case PT_ENTRY_LARGE_PAGE:
1276     {
1277       addr_t large_page_pa = (addr_t)guest_pte_pa;
1278       addr_t large_page_va = 0;
1279
1280       if (guest_pa_to_host_va(info, large_page_pa, &large_page_va) == -1) {
1281         PrintError("Could not get virtual address of Guest Page 4MB (PA=%p)\n",
1282                    (void *)large_page_va);
1283         return -1;
1284       }
1285
1286
1287       if ((ret == callback(PAGE_4MB, vaddr, large_page_va, large_page_pa, private_data)) != 0) {
1288         return (ret == -1) ? -1 : PAGE_4MB;
1289       }
1290       return 0;
1291     }
1292   case PT_ENTRY_PAGE:
1293     {
1294       pte32_t * guest_pte = NULL;
1295       addr_t page_pa;
1296
1297       if (guest_pa_to_host_va(info, guest_pte_pa, (addr_t*)&guest_pte) == -1) {
1298         PrintError("Could not get virtual address of Guest PTE32 (PA=%p)\n",
1299                    (void *)guest_pte_pa);
1300         return -1;
1301       }
1302
1303       if ((ret = callback(PAGE_PT32, vaddr, (addr_t)guest_pte, guest_pte_pa, private_data) != 0)) {
1304         return (ret == -1) ? -1 : PAGE_PT32;
1305       }
1306
1307       if (pte32_lookup(guest_pte, vaddr, &page_pa) == PT_ENTRY_NOT_PRESENT) {
1308         return -1;
1309       } else {
1310         addr_t page_va;
1311
1312         if (guest_pa_to_host_va(info, page_pa, &page_va) == -1) {
1313           PrintError("Could not get virtual address of Guest Page 4KB (PA=%p)\n",
1314                      (void *)page_pa);
1315           return -1;
1316         }
1317
1318         if ((ret = callback(PAGE_4KB, vaddr, page_va, page_pa, private_data)) != 0) {
1319           return (ret == -1) ? -1 : PAGE_4KB;
1320         }
1321         return 0;
1322       }
1323     }
1324   }
1325
1326   // should never get here
1327   PrintError("End of drill function (guest 32)... Should never have gotten here...\n");
1328   return -1;
1329 }
1330
1331
1332
1333 int v3_drill_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
1334                                 int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1335                                 void * private_data) {
1336   addr_t guest_pdpe_pa = CR3_TO_PDPE32PAE_PA(guest_cr3);
1337   pdpe32pae_t * guest_pdpe = 0;
1338   addr_t guest_pde_pa = 0;
1339   int ret = 0;
1340
1341   if (guest_pa_to_host_va(info, guest_pdpe_pa, (addr_t*)&guest_pdpe) == -1) {
1342     PrintError("Could not get virtual address of Guest PDPE32PAE (PA=%p)\n",
1343                (void *)guest_pdpe_pa);
1344     return -1;
1345   }
1346
1347   if ((ret = callback(PAGE_PDP32PAE, vaddr, (addr_t)guest_pdpe, guest_pdpe_pa, private_data)) != 0) {
1348     return (ret == -1) ? -1 : PAGE_PDP32PAE;
1349   }
1350
1351   switch (pdpe32pae_lookup(guest_pdpe, vaddr, &guest_pde_pa))
1352     {
1353     case PT_ENTRY_NOT_PRESENT:
1354       return -1;
1355     case PT_ENTRY_PAGE:
1356       {
1357         pde32pae_t * guest_pde = NULL;
1358         addr_t guest_pte_pa = 0;
1359
1360         if (guest_pa_to_host_va(info, guest_pde_pa, (addr_t *)&guest_pde) == -1) {
1361           PrintError("Could not get virtual Address of Guest PDE32PAE (PA=%p)\n",
1362                      (void *)guest_pde_pa);
1363           return -1;
1364         }
1365
1366         if ((ret = callback(PAGE_PD32PAE, vaddr, (addr_t)guest_pde, guest_pde_pa, private_data)) != 0) {
1367           return (ret == -1) ? -1 : PAGE_PD32PAE;
1368         }
1369
1370         switch (pde32pae_lookup(guest_pde, vaddr, &guest_pte_pa))
1371           {
1372           case PT_ENTRY_NOT_PRESENT:
1373             return -1;
1374           case PT_ENTRY_LARGE_PAGE:
1375             {
1376               addr_t large_page_pa = (addr_t)guest_pte_pa;
1377               addr_t large_page_va = 0;
1378
1379               if (guest_pa_to_host_va(info, large_page_pa, &large_page_va) == -1) {
1380                 PrintDebug("Could not get virtual address of Guest Page 2MB (PA=%p)\n",
1381                            (void *)large_page_va);
1382
1383               }
1384
1385               if ((ret == callback(PAGE_2MB, vaddr, large_page_va, large_page_pa, private_data)) != 0) {
1386                 return (ret == -1) ? -1 : PAGE_2MB;
1387               }
1388               return 0;
1389             }
1390           case PT_ENTRY_PAGE:
1391             {
1392               pte32pae_t * guest_pte = NULL;
1393               addr_t page_pa;
1394
1395               if (guest_pa_to_host_va(info, guest_pte_pa, (addr_t *)&guest_pte) == -1) {
1396                 PrintError("Could not get virtual Address of Guest PTE32PAE (PA=%p)\n",
1397                            (void *)guest_pte_pa);
1398                 return -1;
1399               }
1400
1401               if ((ret = callback(PAGE_PT32PAE, vaddr, (addr_t)guest_pte, guest_pte_pa, private_data) != 0)) {
1402                 return (ret == -1) ? -1 : PAGE_PT32PAE;
1403               }
1404
1405               if (pte32pae_lookup(guest_pte, vaddr, &page_pa) == PT_ENTRY_NOT_PRESENT) {
1406                 return -1;
1407               } else {
1408                 addr_t page_va;
1409
1410                 if (guest_pa_to_host_va(info, page_pa, &page_va) == -1) {
1411                   PrintError("Could not get virtual address of Guest Page 4KB (PA=%p)\n",
1412                              (void *)page_pa);
1413                   return -1;
1414                 }
1415
1416                 if ((ret = callback(PAGE_4KB, vaddr, page_va, page_pa, private_data)) != 0) {
1417                   return (ret == -1) ? -1 : PAGE_4KB;
1418                 }
1419                 return 0;
1420               }
1421             }
1422           }
1423       }
1424     default:
1425       PrintError("Invalid page type for PD32PAE\n");
1426       return -1;
1427     }
1428
1429   // should never get here
1430   PrintError("End of drill function (guest 32pae)... Should never have gotten here...\n");
1431   return -1;
1432 }
1433
1434 int v3_drill_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
1435                                 int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1436                                 void * private_data) {
1437   addr_t guest_pml4_pa = CR3_TO_PML4E64_PA(guest_cr3);
1438   pml4e64_t * guest_pmle = 0;
1439   addr_t guest_pdpe_pa = 0;
1440   int ret = 0;
1441
1442   if (guest_pa_to_host_va(info, guest_pml4_pa, (addr_t*)&guest_pmle) == -1) {
1443     PrintError("Could not get virtual address of Guest PML4E64 (PA=%p)\n",
1444                (void *)guest_pml4_pa);
1445     return -1;
1446   }
1447
1448   if ((ret = callback(PAGE_PML464, vaddr, (addr_t)guest_pmle, guest_pml4_pa, private_data)) != 0) {
1449     return (ret == -1) ? -1 : PAGE_PML464;
1450   }
1451
1452   switch (pml4e64_lookup(guest_pmle, vaddr, &guest_pdpe_pa)) {
1453   case PT_ENTRY_NOT_PRESENT:
1454     return -1;
1455   case PT_ENTRY_PAGE:
1456     {
1457       pdpe64_t * guest_pdp = NULL;
1458       addr_t guest_pde_pa = 0;
1459
1460       if (guest_pa_to_host_va(info, guest_pdpe_pa, (addr_t *)&guest_pdp) == -1) {
1461         PrintError("Could not get virtual address of Guest PDPE64 (PA=%p)\n",
1462                    (void *)guest_pdpe_pa);
1463         return -1;
1464       }
1465
1466       if ((ret = callback(PAGE_PDP64, vaddr, (addr_t)guest_pdp, guest_pdpe_pa, private_data)) != 0) {
1467         return (ret == -1) ? -1 : PAGE_PDP64;
1468       }
1469
1470       switch (pdpe64_lookup(guest_pdp, vaddr, &guest_pde_pa)) {
1471       case PT_ENTRY_NOT_PRESENT:
1472         return -1;
1473       case PT_ENTRY_LARGE_PAGE:
1474         {
1475           addr_t large_page_pa = (addr_t)guest_pde_pa;
1476           addr_t large_page_va = 0;
1477
1478           if (guest_pa_to_host_va(info, large_page_pa, &large_page_va) == -1) {
1479             PrintDebug("Could not get virtual address of Guest Page 1GB (PA=%p)\n",
1480                        (void *)large_page_va);
1481
1482           }
1483
1484           if ((ret == callback(PAGE_1GB, vaddr, large_page_va, large_page_pa, private_data)) != 0) {
1485             return (ret == -1) ? -1 : PAGE_1GB;
1486           }
1487           PrintError("1 Gigabyte Pages not supported\n");
1488           return 0;
1489         }
1490       case PT_ENTRY_PAGE:
1491         {
1492           pde64_t * guest_pde = NULL;
1493           addr_t guest_pte_pa = 0;
1494
1495           if (guest_pa_to_host_va(info, guest_pde_pa, (addr_t *)&guest_pde) == -1) {
1496             PrintError("Could not get virtual address of guest PDE64 (PA=%p)\n",
1497                        (void *)guest_pde_pa);
1498             return -1;
1499           }
1500
1501           if ((ret = callback(PAGE_PD64, vaddr, (addr_t)guest_pde, guest_pde_pa, private_data)) != 0) {
1502             return (ret == -1) ? -1 : PAGE_PD64;
1503           }
1504
1505           switch (pde64_lookup(guest_pde, vaddr, &guest_pte_pa)) {
1506           case PT_ENTRY_NOT_PRESENT:
1507             return -1;
1508           case PT_ENTRY_LARGE_PAGE:
1509             {
1510               addr_t large_page_pa = (addr_t)guest_pte_pa;
1511               addr_t large_page_va = 0;
1512
1513               if (guest_pa_to_host_va(info, large_page_pa, &large_page_va) == -1) {
1514                 PrintDebug("Could not get virtual address of Guest Page 2MB (PA=%p)\n",
1515                            (void *)large_page_va);
1516
1517               }
1518
1519               if ((ret == callback(PAGE_2MB, vaddr, large_page_va, large_page_pa, private_data)) != 0) {
1520                 return (ret == -1) ? -1 : PAGE_2MB;
1521               }
1522               return 0;
1523             }
1524           case PT_ENTRY_PAGE:
1525             {
1526               pte64_t * guest_pte = NULL;
1527               addr_t page_pa;
1528
1529               if (guest_pa_to_host_va(info, guest_pte_pa, (addr_t *)&guest_pte) == -1) {
1530                 PrintError("Could not get virtual address of guest PTE64 (PA=%p)\n",
1531                            (void *)guest_pte_pa);
1532                 return -1;
1533               }
1534
1535               if ((ret = callback(PAGE_PT64, vaddr, (addr_t)guest_pte, guest_pte_pa, private_data) != 0)) {
1536                 return (ret == -1) ? -1 : PAGE_PT64;
1537               }
1538
1539               if (pte64_lookup(guest_pte, vaddr, &page_pa) == PT_ENTRY_NOT_PRESENT) {
1540                 return -1;
1541               } else {
1542                 addr_t page_va;
1543
1544                 if (guest_pa_to_host_va(info, page_pa, &page_va) == -1) {
1545                   PrintError("Could not get virtual address of Guest Page 4KB (PA=%p)\n",
1546                              (void *)page_pa);
1547                   return -1;
1548                 }
1549
1550                 if ((ret = callback(PAGE_4KB, vaddr, page_va, page_pa, private_data)) != 0) {
1551                   return (ret == -1) ? -1 : PAGE_4KB;
1552                 }
1553
1554                 return 0;
1555               }
1556             }
1557           }
1558         }
1559       }
1560     }
1561   default:
1562     return -1;
1563   }
1564
1565   // should never get here
1566   PrintError("End of drill function (guest 64)... Should never have gotten here...\n");
1567   return -1;
1568 }
1569
1570
1571
1572
1573 int v3_walk_guest_pt_32(struct guest_info * info,  v3_reg_t guest_cr3,
1574                         int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1575                         void * private_data) {
1576   addr_t guest_pde_pa = CR3_TO_PDE32_PA(guest_cr3);
1577   pde32_t * guest_pde = NULL;
1578   int i, j;
1579   addr_t vaddr = 0;
1580
1581   if (!callback) {
1582     PrintError("Call back was not specified\n");
1583     return -1;
1584   }
1585
1586   if (guest_pa_to_host_va(info, guest_pde_pa, (addr_t *)&guest_pde) == -1) {
1587     PrintError("Could not get virtual address of Guest PDE32 (PA=%p)\n",
1588                (void *)guest_pde_pa);
1589     return -1;
1590   }
1591
1592   callback(PAGE_PD32, vaddr, (addr_t)guest_pde, guest_pde_pa, private_data);
1593
1594   for (i = 0; i < MAX_PDE32_ENTRIES; i++) {
1595     if (guest_pde[i].present) {
1596       if (guest_pde[i].large_page) {
1597         pde32_4MB_t * large_pde = (pde32_4MB_t *)&(guest_pde[i]);
1598         addr_t large_page_pa = BASE_TO_PAGE_ADDR_4MB(large_pde->page_base_addr);
1599         addr_t large_page_va = 0;
1600
1601         if (guest_pa_to_host_va(info, large_page_pa, &large_page_va) == -1) {
1602           PrintDebug("Could not get virtual address of Guest 4MB Page (PA=%p)\n",
1603                      (void *)large_page_pa);
1604           // We'll let it through for data pages because they may be unmapped or hooked
1605           large_page_va = 0;
1606         }
1607
1608         callback(PAGE_4MB, vaddr, large_page_va, large_page_pa, private_data);
1609
1610         vaddr += PAGE_SIZE_4MB;
1611       } else {
1612         addr_t pte_pa = BASE_TO_PAGE_ADDR(guest_pde[i].pt_base_addr);
1613         pte32_t * tmp_pte = NULL;
1614
1615         if (guest_pa_to_host_va(info, pte_pa, (addr_t *)&tmp_pte) == -1) {
1616           PrintError("Could not get virtual address of Guest PTE32 (PA=%p)\n",
1617                      (void *)pte_pa);
1618           return -1;
1619         }
1620
1621         callback(PAGE_PT32, vaddr, (addr_t)tmp_pte, pte_pa, private_data);
1622
1623         for (j = 0; j < MAX_PTE32_ENTRIES; j++) {
1624           if (tmp_pte[j].present) {
1625             addr_t page_pa = BASE_TO_PAGE_ADDR(tmp_pte[j].page_base_addr);
1626             addr_t page_va = 0;
1627
1628             if (guest_pa_to_host_va(info, page_pa, &page_va) == -1) {
1629               PrintDebug("Could not get virtual address of Guest 4KB Page (PA=%p)\n",
1630                  (void *)page_pa);
1631               // We'll let it through for data pages because they may be unmapped or hooked
1632               page_va = 0;
1633             }
1634
1635             callback(PAGE_4KB, vaddr, page_va, page_pa, private_data);
1636           }
1637
1638           vaddr += PAGE_SIZE_4KB;
1639         }
1640       }
1641     } else {
1642       vaddr += PAGE_SIZE_4MB;
1643     }
1644   }
1645   return 0;
1646 }
1647
1648
1649 int v3_walk_guest_pt_32pae(struct guest_info * info,  v3_reg_t guest_cr3,
1650                            int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1651                            void * private_data) {
1652   addr_t guest_pdpe_pa = CR3_TO_PDPE32PAE_PA(guest_cr3);
1653   pdpe32pae_t * guest_pdpe = NULL;
1654   int i, j, k;
1655   addr_t vaddr = 0;
1656
1657   if (!callback) {
1658     PrintError("Call back was not specified\n");
1659     return -1;
1660   }
1661
1662   if (guest_pa_to_host_va(info, guest_pdpe_pa, (addr_t *)&guest_pdpe) == -1) {
1663     PrintError("Could not get virtual address of Guest PDPE32PAE (PA=%p)\n",
1664                (void *)guest_pdpe_pa);
1665     return -1;
1666   }
1667
1668
1669
1670   callback(PAGE_PDP32PAE, vaddr, (addr_t)guest_pdpe, guest_pdpe_pa, private_data);
1671
1672   for (i = 0; i < MAX_PDPE32PAE_ENTRIES; i++) {
1673     if (guest_pdpe[i].present) {
1674       addr_t pde_pa = BASE_TO_PAGE_ADDR(guest_pdpe[i].pd_base_addr);
1675       pde32pae_t * tmp_pde = NULL;
1676
1677       if (guest_pa_to_host_va(info, pde_pa, (addr_t *)&tmp_pde) == -1) {
1678         PrintError("Could not get virtual address of Guest PDE32PAE (PA=%p)\n",
1679                    (void *)pde_pa);
1680         return -1;
1681       }
1682
1683       callback(PAGE_PD32PAE, vaddr, (addr_t)tmp_pde, pde_pa, private_data);
1684
1685       for (j = 0; j < MAX_PDE32PAE_ENTRIES; j++) {
1686         if (tmp_pde[j].present) {
1687           if (tmp_pde[j].large_page) {
1688             pde32pae_2MB_t * large_pde = (pde32pae_2MB_t *)&(tmp_pde[j]);
1689             addr_t large_page_pa = BASE_TO_PAGE_ADDR_2MB(large_pde->page_base_addr);
1690             addr_t large_page_va = 0;
1691
1692             if (guest_pa_to_host_va(info, large_page_pa, &large_page_va) == -1) {
1693               PrintDebug("Could not get virtual address of Guest 2MB Page (PA=%p)\n",
1694                          (void *)large_page_pa);
1695               // We'll let it through for data pages because they may be unmapped or hooked
1696               large_page_va = 0;
1697             }
1698
1699             callback(PAGE_2MB, vaddr, large_page_va, large_page_pa, private_data);
1700
1701             vaddr += PAGE_SIZE_2MB;
1702           } else {
1703             addr_t pte_pa = BASE_TO_PAGE_ADDR(tmp_pde[j].pt_base_addr);
1704             pte32pae_t * tmp_pte = NULL;
1705
1706             if (guest_pa_to_host_va(info, pte_pa, (addr_t *)&tmp_pte) == -1) {
1707               PrintError("Could not get virtual address of Guest PTE32PAE (PA=%p)\n",
1708                          (void *)pte_pa);
1709               return -1;
1710             }
1711
1712             callback(PAGE_PT32PAE, vaddr, (addr_t)tmp_pte, pte_pa, private_data);
1713
1714             for (k = 0; k < MAX_PTE32PAE_ENTRIES; k++) {
1715               if (tmp_pte[k].present) {
1716                 addr_t page_pa = BASE_TO_PAGE_ADDR(tmp_pte[k].page_base_addr);
1717                 addr_t page_va = 0;
1718
1719                 if (guest_pa_to_host_va(info, page_pa, &page_va) == -1) {
1720                   PrintDebug("Could not get virtual address of Guest 4KB Page (PA=%p)\n",
1721                              (void *)page_pa);
1722                   // We'll let it through for data pages because they may be unmapped or hooked
1723                   page_va = 0;
1724                 }
1725
1726                 callback(PAGE_4KB, vaddr, page_va, page_pa, private_data);
1727               }
1728
1729               vaddr += PAGE_SIZE_4KB;
1730             }
1731           }
1732         } else {
1733           vaddr += PAGE_SIZE_2MB;
1734         }
1735       }
1736     } else {
1737       vaddr += PAGE_SIZE_2MB * MAX_PDE32PAE_ENTRIES;
1738     }
1739   }
1740   return 0;
1741 }
1742
1743
1744
1745
1746 int v3_walk_guest_pt_64(struct guest_info * info,  v3_reg_t guest_cr3,
1747                         int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1748                         void * private_data) {
1749   addr_t guest_pml_pa = CR3_TO_PML4E64_PA(guest_cr3);
1750   pml4e64_t * guest_pml = NULL;
1751   int i, j, k, m;
1752   addr_t vaddr = 0;
1753
1754   if (!callback) {
1755     PrintError("Call back was not specified\n");
1756     return -1;
1757   }
1758
1759   if (guest_pa_to_host_va(info, guest_pml_pa, (addr_t *)&guest_pml) == -1) {
1760     PrintError("Could not get virtual address of Guest PML464 (PA=%p)\n",
1761                (void *)guest_pml);
1762     return -1;
1763   }
1764
1765
1766   callback(PAGE_PML464, vaddr, (addr_t)guest_pml, guest_pml_pa, private_data);
1767
1768   for (i = 0; i < MAX_PML4E64_ENTRIES; i++) {
1769     if (guest_pml[i].present) {
1770       addr_t pdpe_pa = BASE_TO_PAGE_ADDR(guest_pml[i].pdp_base_addr);
1771       pdpe64_t * tmp_pdpe = NULL;
1772
1773
1774       if (guest_pa_to_host_va(info, pdpe_pa, (addr_t *)&tmp_pdpe) == -1) {
1775         PrintError("Could not get virtual address of Guest PDPE64 (PA=%p)\n",
1776                    (void *)pdpe_pa);
1777         return -1;
1778       }
1779
1780       callback(PAGE_PDP64, vaddr, (addr_t)tmp_pdpe, pdpe_pa, private_data);
1781
1782       for (j = 0; j < MAX_PDPE64_ENTRIES; j++) {
1783         if (tmp_pdpe[j].present) {
1784           if (tmp_pdpe[j].large_page) {
1785             pdpe64_1GB_t * large_pdpe = (pdpe64_1GB_t *)&(tmp_pdpe[j]);
1786             addr_t large_page_pa = BASE_TO_PAGE_ADDR_1GB(large_pdpe->page_base_addr);
1787             addr_t large_page_va = 0;
1788
1789             if (guest_pa_to_host_va(info, large_page_pa, &large_page_va) == -1) {
1790               PrintDebug("Could not get virtual address of Guest 1GB page (PA=%p)\n",
1791                          (void *)large_page_pa);
1792               // We'll let it through for data pages because they may be unmapped or hooked
1793               large_page_va = 0;
1794             }
1795
1796             callback(PAGE_1GB, vaddr, (addr_t)large_page_va, large_page_pa, private_data);
1797
1798             vaddr += PAGE_SIZE_1GB;
1799           } else {
1800             addr_t pde_pa = BASE_TO_PAGE_ADDR(tmp_pdpe[j].pd_base_addr);
1801             pde64_t * tmp_pde = NULL;
1802
1803             if (guest_pa_to_host_va(info, pde_pa, (addr_t *)&tmp_pde) == -1) {
1804               PrintError("Could not get virtual address of Guest PDE64 (PA=%p)\n",
1805                          (void *)pde_pa);
1806               return -1;
1807             }
1808
1809             callback(PAGE_PD64, vaddr, (addr_t)tmp_pde, pde_pa, private_data);
1810
1811             for (k = 0; k < MAX_PDE64_ENTRIES; k++) {
1812               if (tmp_pde[k].present) {
1813                 if (tmp_pde[k].large_page) {
1814                   pde64_2MB_t * large_pde = (pde64_2MB_t *)&(tmp_pde[k]);
1815                   addr_t large_page_pa = BASE_TO_PAGE_ADDR_2MB(large_pde->page_base_addr);
1816                   addr_t large_page_va = 0;
1817
1818                   if (guest_pa_to_host_va(info, large_page_pa, &large_page_va) == -1) {
1819                     PrintDebug("Could not get virtual address of Guest 2MB page (PA=%p)\n",
1820                                (void *)large_page_pa);
1821                     // We'll let it through for data pages because they may be unmapped or hooked
1822                     large_page_va = 0;
1823                   }
1824
1825                   callback(PAGE_2MB, vaddr, large_page_va, large_page_pa, private_data);
1826
1827                   vaddr += PAGE_SIZE_2MB;
1828                 } else {
1829                   addr_t pte_pa = BASE_TO_PAGE_ADDR(tmp_pde[k].pt_base_addr);
1830                   pte64_t * tmp_pte = NULL;
1831
1832                   if (guest_pa_to_host_va(info, pte_pa, (addr_t *)&tmp_pte) == -1) {
1833                     PrintError("Could not get virtual address of Guest PTE64 (PA=%p)\n",
1834                                (void *)pte_pa);
1835                     return -1;
1836                   }
1837
1838                   callback(PAGE_PT64, vaddr, (addr_t)tmp_pte, pte_pa, private_data);
1839
1840                   for (m = 0; m < MAX_PTE64_ENTRIES; m++) {
1841                     if (tmp_pte[m].present) {
1842                       addr_t page_pa = BASE_TO_PAGE_ADDR(tmp_pte[m].page_base_addr);
1843                       addr_t page_va = 0;
1844
1845                       if (guest_pa_to_host_va(info, page_pa, &page_va) == -1) {
1846                         PrintDebug("Could not get virtual address of Guest 4KB Page (PA=%p)\n",
1847                                    (void *)page_pa);
1848                         // We'll let it through for data pages because they may be unmapped or hooked
1849                         page_va = 0;
1850                       }
1851
1852                       callback(PAGE_4KB, vaddr, page_va, page_pa, private_data);
1853                     }
1854
1855                     vaddr += PAGE_SIZE_4KB;
1856                   }
1857                 }
1858               } else {
1859                 vaddr += PAGE_SIZE_2MB;
1860               }
1861             }
1862           }
1863         } else {
1864           vaddr += PAGE_SIZE_1GB;
1865         }
1866       }
1867     } else {
1868       vaddr += ((ullong_t)PAGE_SIZE_1GB * (ullong_t)MAX_PDPE64_ENTRIES);
1869     }
1870   }
1871   return 0;
1872 }
1873
1874 int v3_walk_host_pt_32(v3_reg_t host_cr3,
1875                        int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1876                        void * private_data) {
1877   pde32_t * host_pde = (pde32_t *)CR3_TO_PDE32_VA(host_cr3);
1878   addr_t pde_pa = CR3_TO_PDE32_PA(host_cr3);
1879   int i, j;
1880   addr_t vaddr = 0;
1881
1882   if (!callback) {
1883     PrintError("Call back was not specified\n");
1884     return -1;
1885   }
1886
1887   callback(PAGE_PD32, vaddr, (addr_t)host_pde, pde_pa, private_data);
1888
1889   for (i = 0; i < MAX_PDE32_ENTRIES; i++) {
1890     if (host_pde[i].present) {
1891       if (host_pde[i].large_page) {
1892         pde32_4MB_t * large_pde = (pde32_4MB_t *)&(host_pde[i]);
1893         addr_t large_page_pa = BASE_TO_PAGE_ADDR_4MB(large_pde->page_base_addr);
1894
1895         callback(PAGE_4MB, vaddr, (addr_t)V3_VAddr((void *)large_page_pa), large_page_pa, private_data);
1896
1897         vaddr += PAGE_SIZE_4MB;
1898       } else {
1899         addr_t pte_pa = BASE_TO_PAGE_ADDR(host_pde[i].pt_base_addr);
1900         pte32_t * tmp_pte = (pte32_t *)V3_VAddr((void *)pte_pa);
1901
1902         callback(PAGE_PT32, vaddr, (addr_t)tmp_pte, pte_pa, private_data);
1903
1904         for (j = 0; j < MAX_PTE32_ENTRIES; j++) {
1905           if (tmp_pte[j].present) {
1906             addr_t page_pa = BASE_TO_PAGE_ADDR(tmp_pte[j].page_base_addr);
1907             callback(PAGE_4KB, vaddr, (addr_t)V3_VAddr((void *)page_pa), page_pa, private_data);
1908           }
1909
1910           vaddr += PAGE_SIZE_4KB;
1911         }
1912       }
1913     } else {
1914       vaddr += PAGE_SIZE_4MB;
1915     }
1916   }
1917   return 0;
1918 }
1919
1920
1921
1922
1923
1924 int v3_walk_host_pt_32pae(v3_reg_t host_cr3,
1925                           int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1926                           void * private_data) {
1927   pdpe32pae_t * host_pdpe = (pdpe32pae_t *)CR3_TO_PDPE32PAE_VA(host_cr3);
1928   addr_t pdpe_pa = CR3_TO_PDPE32PAE_PA(host_cr3);
1929   int i, j, k;
1930   addr_t vaddr = 0;
1931
1932   if (!callback) {
1933     PrintError("Callback was not specified\n");
1934     return -1;
1935   }
1936
1937   callback(PAGE_PDP32PAE, vaddr, (addr_t)host_pdpe, pdpe_pa, private_data);
1938
1939   for (i = 0; i < MAX_PDPE32PAE_ENTRIES; i++) {
1940     if (host_pdpe[i].present) {
1941       addr_t pde_pa = BASE_TO_PAGE_ADDR(host_pdpe[i].pd_base_addr);
1942       pde32pae_t * tmp_pde = (pde32pae_t *)V3_VAddr((void *)pde_pa);
1943
1944       callback(PAGE_PD32PAE, vaddr, (addr_t)tmp_pde, pde_pa, private_data);
1945
1946       for (j = 0; j < MAX_PDE32PAE_ENTRIES; j++) {
1947         if (tmp_pde[j].present) {
1948
1949           if (tmp_pde[j].large_page) {
1950             pde32pae_2MB_t * large_pde = (pde32pae_2MB_t *)&(tmp_pde[j]);
1951             addr_t large_page_pa = BASE_TO_PAGE_ADDR_2MB(large_pde->page_base_addr);
1952
1953             callback(PAGE_2MB, vaddr, (addr_t)V3_VAddr((void *)large_page_pa), large_page_pa, private_data);
1954
1955             vaddr += PAGE_SIZE_2MB;
1956           } else {
1957             addr_t pte_pa = BASE_TO_PAGE_ADDR(tmp_pde[j].pt_base_addr);
1958             pte32pae_t * tmp_pte = (pte32pae_t *)V3_VAddr((void *)pte_pa);
1959
1960             callback(PAGE_PT32PAE, vaddr, (addr_t)tmp_pte, pte_pa, private_data);
1961
1962             for (k = 0; k < MAX_PTE32PAE_ENTRIES; k++) {
1963               if (tmp_pte[k].present) {
1964                 addr_t page_pa = BASE_TO_PAGE_ADDR(tmp_pte[k].page_base_addr);
1965                 callback(PAGE_4KB, vaddr, (addr_t)V3_VAddr((void *)page_pa), page_pa, private_data);
1966               }
1967
1968               vaddr += PAGE_SIZE_4KB;
1969             }
1970           }
1971         } else {
1972           vaddr += PAGE_SIZE_2MB;
1973         }
1974       }
1975     } else {
1976       vaddr += PAGE_SIZE_2MB * MAX_PDE32PAE_ENTRIES;
1977     }
1978   }
1979   return 0;
1980 }
1981
1982
1983 int v3_walk_host_pt_64(v3_reg_t host_cr3,
1984                        int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
1985                        void * private_data) {
1986   pml4e64_t * host_pml = (pml4e64_t *)CR3_TO_PML4E64_VA(host_cr3);
1987   addr_t pml_pa = CR3_TO_PML4E64_PA(host_cr3);
1988   int i, j, k, m;
1989   addr_t vaddr = 0;
1990
1991   if (!callback) {
1992     PrintError("Callback was not specified\n");
1993     return -1;
1994   }
1995
1996   callback(PAGE_PML464, vaddr, (addr_t)host_pml, pml_pa, private_data);
1997
1998   for (i = 0; i < MAX_PML4E64_ENTRIES; i++) {
1999     if (host_pml[i].present) {
2000       addr_t pdpe_pa = BASE_TO_PAGE_ADDR(host_pml[i].pdp_base_addr);
2001       pdpe64_t * tmp_pdpe = (pdpe64_t *)V3_VAddr((void *)pdpe_pa);
2002
2003       callback(PAGE_PDP64, vaddr, (addr_t)tmp_pdpe, pdpe_pa, private_data);
2004
2005       for (j = 0; j < MAX_PDPE64_ENTRIES; j++) {
2006         if (tmp_pdpe[j].present) {
2007           if (tmp_pdpe[j].large_page) {
2008             pdpe64_1GB_t * large_pdp = (pdpe64_1GB_t *)&(tmp_pdpe[j]);
2009             addr_t large_page_pa = BASE_TO_PAGE_ADDR_1GB(large_pdp->page_base_addr);
2010
2011             callback(PAGE_1GB, vaddr, (addr_t)V3_VAddr((void *)large_page_pa), large_page_pa, private_data);
2012
2013             vaddr += PAGE_SIZE_1GB;
2014           } else {
2015             addr_t pde_pa = BASE_TO_PAGE_ADDR(tmp_pdpe[j].pd_base_addr);
2016             pde64_t * tmp_pde = (pde64_t *)V3_VAddr((void *)pde_pa);
2017
2018             callback(PAGE_PD64, vaddr, (addr_t)tmp_pde, pde_pa, private_data);
2019
2020             for (k = 0; k < MAX_PDE64_ENTRIES; k++) {
2021               if (tmp_pde[k].present) {
2022                 if (tmp_pde[k].large_page) {
2023                   pde64_2MB_t * large_pde = (pde64_2MB_t *)&(tmp_pde[k]);
2024                   addr_t large_page_pa = BASE_TO_PAGE_ADDR_2MB(large_pde->page_base_addr);
2025
2026                   callback(PAGE_2MB, vaddr, (addr_t)V3_VAddr((void *)large_page_pa), large_page_pa, private_data);
2027
2028                   vaddr += PAGE_SIZE_2MB;
2029                 } else {
2030                   addr_t pte_pa = BASE_TO_PAGE_ADDR(tmp_pde[k].pt_base_addr);
2031                   pte64_t * tmp_pte = (pte64_t *)V3_VAddr((void *)pte_pa);
2032
2033                   callback(PAGE_PT64, vaddr, (addr_t)tmp_pte, pte_pa, private_data);
2034
2035                   for (m = 0; m < MAX_PTE64_ENTRIES; m++) {
2036                     if (tmp_pte[m].present) {
2037                       addr_t page_pa = BASE_TO_PAGE_ADDR(tmp_pte[m].page_base_addr);
2038                       callback(PAGE_4KB, vaddr, (addr_t)V3_VAddr((void *)page_pa), page_pa, private_data);
2039                     }
2040                     vaddr += PAGE_SIZE_4KB;
2041                   }
2042                 }
2043               } else {
2044                 vaddr += PAGE_SIZE_2MB;
2045               }
2046             }
2047           }
2048         } else {
2049           vaddr += PAGE_SIZE_1GB;
2050         }
2051       }
2052     } else {
2053       vaddr += (ullong_t)PAGE_SIZE_1GB * (ullong_t)MAX_PDPE64_ENTRIES;
2054     }
2055   }
2056   return 0;
2057 }
2058
2059
2060
2061 static const uchar_t PAGE_4KB_STR[] = "4KB_PAGE";
2062 static const uchar_t PAGE_2MB_STR[] = "2MB_PAGE";
2063 static const uchar_t PAGE_4MB_STR[] = "4MB_PAGE";
2064 static const uchar_t PAGE_1GB_STR[] = "1GB_PAGE";
2065 static const uchar_t PAGE_PT32_STR[] = "32 Bit PT";
2066 static const uchar_t PAGE_PD32_STR[] = "32 Bit PD";
2067 static const uchar_t PAGE_PDP32PAE_STR[] = "32 Bit PAE PDP";
2068 static const uchar_t PAGE_PD32PAE_STR[] = "32 Bit PAE PD";
2069 static const uchar_t PAGE_PT32PAE_STR[] = "32 Bit PAE PT";
2070 static const uchar_t PAGE_PML464_STR[] = "64 Bit PML4";
2071 static const uchar_t PAGE_PDP64_STR[] = "64 Bit PDP";
2072 static const uchar_t PAGE_PD64_STR[] = "64 Bit PD";
2073 static const uchar_t PAGE_PT64_STR[] = "64 Bit PT";
2074
2075
2076 const uchar_t * v3_page_type_to_str(page_type_t type) {
2077   switch (type) {
2078   case PAGE_4KB:
2079     return PAGE_4KB_STR;
2080   case PAGE_2MB:
2081     return PAGE_2MB_STR;
2082   case PAGE_4MB:
2083     return PAGE_4MB_STR;
2084   case PAGE_1GB:
2085     return PAGE_1GB_STR;
2086   case PAGE_PT32:
2087     return PAGE_PT32_STR;
2088   case PAGE_PD32:
2089     return PAGE_PD32_STR;
2090   case PAGE_PDP32PAE:
2091     return PAGE_PDP32PAE_STR;
2092   case PAGE_PD32PAE:
2093     return PAGE_PD32PAE_STR;
2094   case PAGE_PT32PAE:
2095     return PAGE_PT32PAE_STR;
2096   case PAGE_PML464:
2097     return PAGE_PML464_STR;
2098   case PAGE_PDP64:
2099     return PAGE_PDP64_STR;
2100   case PAGE_PD64:
2101     return PAGE_PD64_STR;
2102   case PAGE_PT64:
2103     return PAGE_PT64_STR;
2104   default:
2105     return NULL;
2106   }
2107 }