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(VM_NONE, VCORE_NONE, "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(VM_NONE, VCORE_NONE, "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(VM_NONE, VCORE_NONE, "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(VM_NONE, VCORE_NONE, "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(VM_NONE, VCORE_NONE, "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(VM_NONE, VCORE_NONE, "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(VM_NONE, VCORE_NONE, "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(VM_NONE, VCORE_NONE, "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(VM_NONE, VCORE_NONE, "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(info->vm_info, info, "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(info->vm_info, info, "PDPE64 Page\n");
 224                 for (i = 0; i < MAX_PDPE64_ENTRIES; i++) {
 225                     tmp_vaddr = 4096UL * 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(info->vm_info, info, "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(info->vm_info, info, "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(info->vm_info, info, "PDPE32PAE Page\n");
 263                 for (i = 0; i < MAX_PDPE32PAE_ENTRIES; i++) {
 264                     tmp_vaddr = 4096UL * 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(info->vm_info, info, "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(info->vm_info, info, "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(info->vm_info, info, "PDE32 Page\n");
 302                 for (i = 0; i < MAX_PTE32_ENTRIES; i++) {
 303                     tmp_vaddr = 4096UL * 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(info->vm_info, info, "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(info->vm_info, info, "%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, v3_cpu_mode_t cpu_mode, addr_t cr3) {
 414     PrintDebug(info->vm_info, info, "CR3: %p\n", (void *)cr3);
 415     switch (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(info->vm_info, info, "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(info->vm_info, info, "CR3: %p\n", (void *)cr3);
 436     switch (info->cpu_mode) {
 437         case REAL:
 438         case PROTECTED:
 439             v3_walk_guest_pt_32(info, cr3, print_page_walk_cb, NULL);
 440             break;
 441         case PROTECTED_PAE:
 442             v3_walk_guest_pt_32pae(info, cr3, print_page_walk_cb, NULL);
 443             break;
 444         case LONG:
 445         case LONG_32_COMPAT:
 446         case LONG_16_COMPAT:
 447             v3_walk_guest_pt_64(info, cr3, print_page_walk_cb, NULL);
 448             break;
 449         default:
 450             PrintError(info->vm_info, info, "Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(info->cpu_mode));
 451             break;
 452     }
 453 }
 454
 455 void PrintHostPageTree(struct guest_info * info,  addr_t virtual_addr, addr_t cr3) {
 456     PrintDebug(info->vm_info, info, "CR3: %p\n, cpu mode is %x", (void *)cr3, info->cpu_mode);
 457     switch (info->cpu_mode) {
 458         case PROTECTED:
 459             v3_drill_host_pt_32(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 460             break;
 461         case PROTECTED_PAE:
 462             v3_drill_host_pt_32pae(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 463             break;
 464         case LONG:
 465         case LONG_32_COMPAT:
 466         case LONG_16_COMPAT:
 467             v3_drill_host_pt_64(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 468             break;
 469         default:
 470             PrintError(info->vm_info, info, "Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(info->cpu_mode));
 471             break;
 472     }
 473 }
 474
 475 void PrintGuestPageTree(struct guest_info * info, addr_t virtual_addr, addr_t cr3) {
 476     PrintDebug(info->vm_info, info, "CR3: %p\n", (void *)cr3);
 477     switch (info->cpu_mode) {
 478         case PROTECTED:
 479             v3_drill_guest_pt_32(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 480             break;
 481         case PROTECTED_PAE:
 482             v3_drill_guest_pt_32pae(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 483             break;
 484         case LONG:
 485         case LONG_32_COMPAT:
 486         case LONG_16_COMPAT:
 487             v3_drill_guest_pt_64(info, cr3, virtual_addr, print_page_tree_cb, NULL);
 488             break;
 489         default:
 490             PrintError(info->vm_info, info, "Unsupported CPU MODE %s\n", v3_cpu_mode_to_str(info->cpu_mode));
 491             break;
 492     }
 493 }
 494
 495
 496 #endif