palacios/src/palacios/vmm_paging_debug.h

   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 #ifdef USE_VMM_PAGING_DEBUG
  21
  22 /*
  23  *
  24  *  This is an implementation file that gets included only in vmm_paging.c
  25  *
  26  */
  27
  28
  29 static void PrintPDE32(addr_t virtual_address, pde32_t * pde)
  30 {
  31   PrintDebug("PDE %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, reserved=%x, largePages=%x, globalPage=%x, kernelInfo=%x\n",
  32              (void *)virtual_address,
  33              (void *)(addr_t) (pde->pt_base_addr << PAGE_POWER),
  34              pde->present,
  35              pde->writable,
  36              pde->user_page,
  37              pde->write_through,
  38              pde->cache_disable,
  39              pde->accessed,
  40              pde->reserved,
  41              pde->large_page,
  42              pde->global_page,
  43              pde->vmm_info);
  44 }
  45
  46
  47 static void PrintPTE32(addr_t virtual_address, pte32_t * pte)
  48 {
  49   PrintDebug("PTE %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, dirty=%x, pteAttribute=%x, globalPage=%x, vmm_info=%x\n",
  50              (void *)virtual_address,
  51              (void*)(addr_t)(pte->page_base_addr << PAGE_POWER),
  52              pte->present,
  53              pte->writable,
  54              pte->user_page,
  55              pte->write_through,
  56              pte->cache_disable,
  57              pte->accessed,
  58              pte->dirty,
  59              pte->pte_attr,
  60              pte->global_page,
  61              pte->vmm_info);
  62 }
  63
  64
  65
  66
  67
  68
  69
  70
  71 static void PrintPDPE32PAE(addr_t virtual_address, pdpe32pae_t * pdpe)
  72 {
  73   PrintDebug("PDPE %p -> %p : present=%x, wt=%x, cd=%x, accessed=%x, kernelInfo=%x\n",
  74              (void *)virtual_address,
  75              (void *)(addr_t) (pdpe->pd_base_addr << PAGE_POWER),
  76              pdpe->present,
  77              pdpe->write_through,
  78              pdpe->cache_disable,
  79              pdpe->accessed,
  80              pdpe->vmm_info);
  81 }
  82
  83 static void PrintPDE32PAE(addr_t virtual_address, pde32pae_t * pde)
  84 {
  85   PrintDebug("PDE %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, largePages=%x, globalPage=%x, kernelInfo=%x\n",
  86              (void *)virtual_address,
  87              (void *)(addr_t) (pde->pt_base_addr << PAGE_POWER),
  88              pde->present,
  89              pde->writable,
  90              pde->user_page,
  91              pde->write_through,
  92              pde->cache_disable,
  93              pde->accessed,
  94              pde->large_page,
  95              pde->global_page,
  96              pde->vmm_info);
  97 }
  98
  99
 100 static void PrintPTE32PAE(addr_t virtual_address, pte32pae_t * pte)
 101 {
 102   PrintDebug("PTE %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, dirty=%x, pteAttribute=%x, globalPage=%x, vmm_info=%x\n",
 103              (void *)virtual_address,
 104              (void*)(addr_t)(pte->page_base_addr << PAGE_POWER),
 105              pte->present,
 106              pte->writable,
 107              pte->user_page,
 108              pte->write_through,
 109              pte->cache_disable,
 110              pte->accessed,
 111              pte->dirty,
 112              pte->pte_attr,
 113              pte->global_page,
 114              pte->vmm_info);
 115 }
 116
 117
 118
 119
 120
 121
 122
 123
 124 static void PrintPML4e64(addr_t virtual_address, pml4e64_t * pml)
 125 {
 126   PrintDebug("PML4e64 %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, reserved=%x, kernelInfo=%x\n",
 127              (void *)virtual_address,
 128              (void *)(addr_t) (BASE_TO_PAGE_ADDR(pml->pdp_base_addr)),
 129              pml->present,
 130              pml->writable,
 131              pml->user_page,
 132              pml->write_through,
 133              pml->cache_disable,
 134              pml->accessed,
 135              pml->reserved,
 136              pml->vmm_info);
 137 }
 138
 139 static void PrintPDPE64(addr_t virtual_address, pdpe64_t * pdpe)
 140 {
 141   PrintDebug("PDPE64 %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, reserved=%x, largePages=%x, globalPage/zero=%x, kernelInfo=%x\n",
 142              (void *)virtual_address,
 143              (void *)(addr_t) (BASE_TO_PAGE_ADDR(pdpe->pd_base_addr)),
 144              pdpe->present,
 145              pdpe->writable,
 146              pdpe->user_page,
 147              pdpe->write_through,
 148              pdpe->cache_disable,
 149              pdpe->accessed,
 150              pdpe->avail,
 151              pdpe->large_page,
 152              pdpe->zero,
 153              pdpe->vmm_info);
 154 }
 155
 156
 157
 158 static void PrintPDE64(addr_t virtual_address, pde64_t * pde)
 159 {
 160   PrintDebug("PDE64 %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, reserved=%x, largePages=%x, globalPage=%x, kernelInfo=%x\n",
 161              (void *)virtual_address,
 162              (void *)(addr_t) (BASE_TO_PAGE_ADDR(pde->pt_base_addr)),
 163              pde->present,
 164              pde->writable,
 165              pde->user_page,
 166              pde->write_through,
 167              pde->cache_disable,
 168              pde->accessed,
 169              pde->avail,
 170              pde->large_page,
 171              pde->global_page,
 172              pde->vmm_info);
 173 }
 174
 175
 176 static void PrintPTE64(addr_t virtual_address, pte64_t * pte)
 177 {
 178   PrintDebug("PTE64 %p -> %p : present=%x, writable=%x, user=%x, wt=%x, cd=%x, accessed=%x, dirty=%x, pteAttribute=%x, globalPage=%x, vmm_info=%x\n",
 179              (void *)virtual_address,
 180              (void*)(addr_t)(BASE_TO_PAGE_ADDR(pte->page_base_addr)),
 181              pte->present,
 182              pte->writable,
 183              pte->user_page,
 184              pte->write_through,
 185              pte->cache_disable,
 186              pte->accessed,
 187              pte->dirty,
 188              pte->pte_attr,
 189              pte->global_page,
 190              pte->vmm_info);
 191 }
 192
 193
 194
 195
 196
 197
 198
 199
 200 static int print_page_walk_cb(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
 201   int i = 0;
 202   addr_t tmp_vaddr = 0;
 203   switch (type) {
 204
 205     /* 64 Bit */
 206
 207   case PAGE_PML464:
 208     {
 209       pml4e64_t * pml = (pml4e64_t *)page_ptr;
 210       PrintDebug("PML4E64 Page\n");
 211       for (i = 0; i < MAX_PML4E64_ENTRIES; i++) {
 212         tmp_vaddr = (4096 * MAX_PTE64_ENTRIES);
 213         tmp_vaddr *= (MAX_PDE64_ENTRIES * MAX_PDPE64_ENTRIES * i); // break apart to avoid int overflow compile errors
 214         tmp_vaddr += vaddr;
 215         if (pml[i].present)
 216           PrintPML4e64(tmp_vaddr, &(pml[i]));
 217       }
 218       break;
 219     }
 220   case PAGE_PDP64:
 221     {
 222       pdpe64_t * pdp = (pdpe64_t *)page_ptr;
 223       PrintDebug("PDPE64 Page\n");
 224       for (i = 0; i < MAX_PDPE64_ENTRIES; i++) {
 225         tmp_vaddr = 4096 * MAX_PTE64_ENTRIES * MAX_PDE64_ENTRIES * i;
 226         tmp_vaddr += vaddr;
 227         if (pdp[i].present)
 228           PrintPDPE64(tmp_vaddr, &(pdp[i]));
 229       }
 230       break;
 231     }
 232   case PAGE_PD64:
 233     {
 234       pde64_t * pd = (pde64_t *)page_ptr;
 235       PrintDebug("PDE64 Page\n");
 236       for (i = 0; i < MAX_PDE64_ENTRIES; i++) {
 237         tmp_vaddr = 4096 * MAX_PTE64_ENTRIES * i;
 238         tmp_vaddr += vaddr;
 239         if (pd[i].present)
 240           PrintPDE64(tmp_vaddr, &(pd[i]));
 241       }
 242       break;
 243     }
 244   case PAGE_PT64:
 245     {
 246       pte64_t * pt = (pte64_t *)page_ptr;
 247       PrintDebug("PTE64 Page\n");
 248       for (i = 0; i < MAX_PTE64_ENTRIES; i++) {
 249         tmp_vaddr = 4096 * i;
 250         tmp_vaddr += vaddr;
 251         if (pt[i].present)
 252           PrintPTE64(tmp_vaddr, &(pt[i]));
 253       }
 254       break;
 255     }
 256
 257     /* 32 BIT PAE */
 258
 259   case PAGE_PDP32PAE:
 260     {
 261       pdpe32pae_t * pdp = (pdpe32pae_t *)page_ptr;
 262       PrintDebug("PDPE32PAE Page\n");
 263       for (i = 0; i < MAX_PDPE32PAE_ENTRIES; i++) {
 264         tmp_vaddr = 4096 * MAX_PTE32PAE_ENTRIES * MAX_PDE32PAE_ENTRIES * i;
 265         tmp_vaddr += vaddr;
 266         if (pdp[i].present)
 267           PrintPDPE32PAE(tmp_vaddr, &(pdp[i]));
 268       }
 269       break;
 270     }
 271   case PAGE_PD32PAE:
 272     {
 273       pde32pae_t * pd = (pde32pae_t *)page_ptr;
 274       PrintDebug("PDE32PAE Page\n");
 275       for (i = 0; i < MAX_PDE32PAE_ENTRIES; i++) {
 276         tmp_vaddr = 4096 * MAX_PTE32PAE_ENTRIES * i;
 277         tmp_vaddr += vaddr;
 278         if (pd[i].present)
 279           PrintPDE32PAE(tmp_vaddr, &(pd[i]));
 280       }
 281       break;
 282     }
 283   case PAGE_PT32PAE:
 284     {
 285       pte32pae_t * pt = (pte32pae_t *)page_ptr;
 286       PrintDebug("PTE32PAE Page\n");
 287       for (i = 0; i < MAX_PTE32PAE_ENTRIES; i++) {
 288         tmp_vaddr = 4096 * i;
 289         tmp_vaddr += vaddr;
 290         if (pt[i].present)
 291           PrintPTE32PAE(tmp_vaddr, &(pt[i]));
 292       }
 293       break;
 294     }
 295
 296     /* 32 Bit */
 297
 298   case PAGE_PD32:
 299     {
 300       pde32_t * pd = (pde32_t *)page_ptr;
 301       PrintDebug("PDE32 Page\n");
 302       for (i = 0; i < MAX_PTE32_ENTRIES; i++) {
 303         tmp_vaddr = 4096 * MAX_PTE32_ENTRIES * i;
 304         tmp_vaddr += vaddr;
 305         if (pd[i].present)
 306           PrintPDE32(tmp_vaddr, &(pd[i]));
 307       }
 308       break;
 309     }
 310   case PAGE_PT32:
 311     {
 312       pte32_t * pt = (pte32_t *)page_ptr;
 313       PrintDebug("PTE32 Page\n");
 314       for (i = 0; i < MAX_PTE32_ENTRIES; i++) {
 315         tmp_vaddr = 4096 * i;
 316         tmp_vaddr += vaddr;
 317         if (pt[i].present)
 318           PrintPTE32(tmp_vaddr, &(pt[i]));
 319       }
 320       break;
 321     }
 322   default:
 323     break;
 324   }
 325
 326   return 0;
 327 }
 328
 329
 330
 331
 332
 333 static int print_page_tree_cb(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data) {
 334   switch (type) {
 335
 336     /* 64 Bit */
 337
 338   case PAGE_PML464:
 339     {
 340       pml4e64_t * pml = (pml4e64_t *)page_ptr;
 341       PrintPML4e64(vaddr, &(pml[PML4E64_INDEX(vaddr)]));
 342       break;
 343     }
 344   case PAGE_PDP64:
 345     {
 346       pdpe64_t * pdp = (pdpe64_t *)page_ptr;
 347       PrintPDPE64(vaddr, &(pdp[PDPE64_INDEX(vaddr)]));
 348       break;
 349     }
 350   case PAGE_PD64:
 351     {
 352       pde64_t * pd = (pde64_t *)page_ptr;
 353       PrintPDE64(vaddr, &(pd[PDE64_INDEX(vaddr)]));
 354       break;
 355     }
 356   case PAGE_PT64:
 357     {
 358       pte64_t * pt = (pte64_t *)page_ptr;
 359       PrintPTE64(vaddr, &(pt[PTE64_INDEX(vaddr)]));
 360       break;
 361     }
 362
 363     /* 32 BIT PAE */
 364
 365   case PAGE_PDP32PAE:
 366     {
 367       pdpe32pae_t * pdp = (pdpe32pae_t *)page_ptr;
 368       PrintPDPE32PAE(vaddr, &(pdp[PDPE32PAE_INDEX(vaddr)]));
 369       break;
 370     }
 371   case PAGE_PD32PAE:
 372     {
 373       pde32pae_t * pd = (pde32pae_t *)page_ptr;
 374       PrintPDE32PAE(vaddr, &(pd[PDE32PAE_INDEX(vaddr)]));
 375       break;
 376     }
 377   case PAGE_PT32PAE:
 378     {
 379       pte32pae_t * pt = (pte32pae_t *)page_ptr;
 380       PrintPTE32PAE(vaddr, &(pt[PTE32PAE_INDEX(vaddr)]));
 381       break;
 382     }
 383
 384     /* 32 Bit */
 385
 386   case PAGE_PD32:
 387     {
 388       pde32_t * pd = (pde32_t *)page_ptr;
 389       PrintPDE32(vaddr, &(pd[PDE32_INDEX(vaddr)]));
 390       break;
 391     }
 392   case PAGE_PT32:
 393     {
 394       pte32_t * pt = (pte32_t *)page_ptr;
 395       PrintPTE32(vaddr, &(pt[PTE32_INDEX(vaddr)]));
 396       break;
 397     }
 398   default:
 399     PrintDebug("%s %p->%p \n", v3_page_type_to_str(type), (void *)vaddr, (void *)page_pa);
 400     break;
 401   }
 402
 403   return 0;
 404 }
 405
 406
 407
 408 void PrintPTEntry(struct guest_info * info, page_type_t type, addr_t vaddr, void * entry) {
 409   print_page_tree_cb(info, type, vaddr, PAGE_ADDR_4KB((addr_t)entry), 0, NULL);
 410 }
 411
 412
 413 void PrintHostPageTables(struct guest_info * info, addr_t cr3) {
 414   PrintDebug("CR3: %p\n", (void *)cr3);
 415   switch (info->cpu_mode) {
 416   case PROTECTED:
 417     v3_walk_host_pt_32(info, cr3, print_page_walk_cb, NULL);
 418     break;
 419   case PROTECTED_PAE:
 420     v3_walk_host_pt_32pae(info, cr3, print_page_walk_cb, NULL);
 421     break;
 422   case LONG:
 423   case LONG_32_COMPAT:
 424   case LONG_16_COMPAT:
 425     v3_walk_host_pt_64(info, cr3, print_page_walk_cb, NULL);
 426     break;
 427   default:
 428     PrintError("Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(info->cpu_mode));
 429     break;
 430   }
 431 }
 432
 433
 434 void PrintGuestPageTables(struct guest_info * info, addr_t cr3) {
 435   PrintDebug("CR3: %p\n", (void *)cr3);
 436   switch (info->cpu_mode) {
 437   case PROTECTED:
 438     v3_walk_guest_pt_32(info, cr3, print_page_walk_cb, NULL);
 439     break;
 440   case PROTECTED_PAE:
 441     v3_walk_guest_pt_32pae(info, cr3, print_page_walk_cb, NULL);
 442     break;
 443   case LONG:
 444   case LONG_32_COMPAT:
 445   case LONG_16_COMPAT:
 446     v3_walk_guest_pt_64(info, cr3, print_page_walk_cb, NULL);
 447     break;
 448   default:
 449     PrintError("Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(info->cpu_mode));
 450     break;
 451   }
 452 }
 453
 454 void PrintHostPageTree(struct guest_info * info,  addr_t virtual_addr, addr_t cr3) {
 455   PrintDebug("CR3: %p\n", (void *)cr3);
 456   switch (info->cpu_mode) {
 457   case PROTECTED:
 458     v3_drill_host_pt_32(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 459     break;
 460   case PROTECTED_PAE:
 461     v3_drill_host_pt_32pae(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 462     break;
 463   case LONG:
 464   case LONG_32_COMPAT:
 465   case LONG_16_COMPAT:
 466     v3_drill_host_pt_64(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 467     break;
 468   default:
 469     PrintError("Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(info->cpu_mode));
 470     break;
 471   }
 472 }
 473
 474 void PrintGuestPageTree(struct guest_info * info, addr_t virtual_addr, addr_t cr3) {
 475   PrintDebug("CR3: %p\n", (void *)cr3);
 476   switch (info->cpu_mode) {
 477   case PROTECTED:
 478     v3_drill_guest_pt_32(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 479     break;
 480   case PROTECTED_PAE:
 481     v3_drill_guest_pt_32pae(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 482     break;
 483   case LONG:
 484   case LONG_32_COMPAT:
 485   case LONG_16_COMPAT:
 486     v3_drill_guest_pt_64(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 487     break;
 488   default:
 489     PrintError("Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(info->cpu_mode));
 490     break;
 491   }
 492 }
 493
 494
 495 #endif