palacios/include/palacios/vmm_paging.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
  21 #ifndef __VMM_PAGING_H__
  22 #define __VMM_PAGING_H__
  23
  24
  25 #ifdef __V3VEE__
  26
  27 #include <palacios/vmm_types.h>
  28 #include <palacios/vmm_util.h>
  29
  30
  31 /*
  32
  33 In the following, when we say "page table", we mean the whole 2 or 4 layer
  34 page table (PDEs, PTEs), etc.
  35
  36
  37 guest-visible paging state
  38  This is the state that the guest thinks the machine is using
  39  It consists of
  40    - guest physical memory
  41        The physical memory addresses the guest is allowed to use
  42        (see shadow page maps, below)
  43    - guest page tables
  44        (we care about when the current one changes)
  45    - guest paging registers (these are never written to hardware)
  46         CR0
  47         CR3
  48
  49
  50 shadow paging state
  51  This the state that the machine will actually use when the guest
  52  is running.  It consists of:
  53    - current shadow page table
  54         This is the page table actually useed when the guest is running.
  55         It is changed/regenerated when the guest page table changes
  56         It mostly reflects the guest page table, except that it restricts
  57         physical addresses to those the VMM allocates to the guest.
  58    - shadow page maps
  59         This is a mapping from guest physical memory addresses to
  60         the current location of the guest physical memory content.
  61         It maps from regions of physical memory addresses to regions
  62         located in physical memory or elsewhere.
  63         (8192,16384) -> MEM(8912,...)
  64         (0,8191) -> DISK(65536,..)
  65    - guest paging registers (these are written to guest state)
  66         CR0
  67         CR3
  68
  69 host paging state
  70   This is the state we expect to be operative when the VMM is running.
  71   Typically, this is set up by the host os into which we have embedded
  72   the VMM, but we include the description here for clarity.
  73     - current page table
  74         This is the page table we use when we are executing in
  75         the VMM (or the host os)
  76     - paging regisers
  77         CR0
  78         CR3
  79
  80
  81 The reason why the shadow paging state and the host paging state are
  82 distinct is to permit the guest to use any virtual address it wants,
  83 irrespective of the addresses the VMM or the host os use.  These guest
  84 virtual addresses are reflected in the shadow paging state.  When we
  85 exit from the guest, we switch to the host paging state so that any
  86 virtual addresses that overlap between the guest and VMM/host now map
  87 to the physical addresses epxected by the VMM/host.  On AMD SVM, this
  88 switch is done by the hardware.  On Intel VT, the switch is done
  89 by the hardware as well, but we are responsible for manually updating
  90 the host state in the vmcs before entering the guest.
  91 */
  92
  93
  94
  95
  96 #define MAX_PDE32_ENTRIES          1024
  97 #define MAX_PTE32_ENTRIES          1024
  98
  99 #define MAX_PDPE32PAE_ENTRIES      4
 100 #define MAX_PDE32PAE_ENTRIES       512
 101 #define MAX_PTE32PAE_ENTRIES       512
 102
 103 #define MAX_PML4E64_ENTRIES        512
 104 #define MAX_PDPE64_ENTRIES         512
 105 #define MAX_PDE64_ENTRIES          512
 106 #define MAX_PTE64_ENTRIES          512
 107
 108
 109 typedef enum {PAGE_4KB, PAGE_2MB, PAGE_4MB, PAGE_1GB,
 110               PAGE_NOT_PRESENT,
 111               PAGE_PT32, PAGE_PD32,
 112               PAGE_PDP32PAE, PAGE_PD32PAE, PAGE_PT32PAE,
 113               PAGE_PML464, PAGE_PDP64, PAGE_PD64, PAGE_PT64} page_type_t;
 114
 115
 116 /* Converts an address into a page table index */
 117 #define PDE32_INDEX(x)  ((((uint_t)x) >> 22) & 0x3ff)
 118 #define PTE32_INDEX(x)  ((((uint_t)x) >> 12) & 0x3ff)
 119
 120
 121 #define PDPE32PAE_INDEX(x) ((((uint_t)x) >> 30) & 0x3)
 122 #define PDE32PAE_INDEX(x)  ((((uint_t)x) >> 21) & 0x1ff)
 123 #define PTE32PAE_INDEX(x)  ((((uint_t)x) >> 12) & 0x1ff)
 124
 125 #define PML4E64_INDEX(x) ((((ullong_t)x) >> 39) & 0x1ff)
 126 #define PDPE64_INDEX(x) ((((ullong_t)x) >> 30) & 0x1ff)
 127 #define PDE64_INDEX(x) ((((ullong_t)x) >> 21) & 0x1ff)
 128 #define PTE64_INDEX(x) ((((ullong_t)x) >> 12) & 0x1ff)
 129
 130
 131 /* Gets the base address needed for a Page Table entry */
 132
 133 #define PAGE_BASE_ADDR(x) ((x) >> 12)
 134 #define PAGE_BASE_ADDR_4KB(x) ((x) >> 12)
 135 #define PAGE_BASE_ADDR_2MB(x) ((x) >> 21)
 136 #define PAGE_BASE_ADDR_4MB(x) ((x) >> 22)
 137 #define PAGE_BASE_ADDR_1GB(x) ((x) >> 30)
 138
 139 #define BASE_TO_PAGE_ADDR(x) (((addr_t)x) << 12)
 140 #define BASE_TO_PAGE_ADDR_4KB(x) (((addr_t)x) << 12)
 141 #define BASE_TO_PAGE_ADDR_2MB(x) (((addr_t)x) << 21)
 142 #define BASE_TO_PAGE_ADDR_4MB(x) (((addr_t)x) << 22)
 143 #define BASE_TO_PAGE_ADDR_1GB(x) (((addr_t)x) << 30)
 144 /* *** */
 145
 146
 147 #define PAGE_OFFSET(x) ((x) & 0xfff)
 148 #define PAGE_OFFSET_4KB(x) ((x) & 0xfff)
 149 #define PAGE_OFFSET_2MB(x) ((x) & 0x1fffff)
 150 #define PAGE_OFFSET_4MB(x) ((x) & 0x3fffff)
 151 #define PAGE_OFFSET_1GB(x) ((x) & 0x3fffffff)
 152
 153 #define PAGE_POWER 12
 154 #define PAGE_POWER_4KB 12
 155 #define PAGE_POWER_2MB 21
 156 #define PAGE_POWER_4MB 22
 157 #define PAGE_POWER_1GB 30
 158
 159 // We shift instead of mask because we don't know the address size
 160 #define PAGE_ADDR(x) (((x) >> PAGE_POWER) << PAGE_POWER)
 161 #define PAGE_ADDR_4KB(x) (((x) >> PAGE_POWER_4KB) << PAGE_POWER_4KB)
 162 #define PAGE_ADDR_2MB(x) (((x) >> PAGE_POWER_2MB) << PAGE_POWER_2MB)
 163 #define PAGE_ADDR_4MB(x) (((x) >> PAGE_POWER_4MB) << PAGE_POWER_4MB)
 164 #define PAGE_ADDR_1GB(x) (((x) >> PAGE_POWER_1GB) << PAGE_POWER_1GB)
 165
 166 #define PAGE_SIZE 4096
 167 #define PAGE_SIZE_4KB 4096
 168 #define PAGE_SIZE_2MB (4096 * 512)
 169 #define PAGE_SIZE_4MB (4096 * 1024)
 170 #define PAGE_SIZE_1GB 0x40000000
 171
 172 /* *** */
 173
 174
 175
 176
 177
 178 #define CR3_TO_PDE32_PA(cr3) ((addr_t)(((uint_t)cr3) & 0xfffff000))
 179 #define CR3_TO_PDPE32PAE_PA(cr3) ((addr_t)(((uint_t)cr3) & 0xffffffe0))
 180 #define CR3_TO_PML4E64_PA(cr3)  ((addr_t)(((ullong_t)cr3) & 0x000ffffffffff000LL))
 181
 182 #define CR3_TO_PDE32_VA(cr3) ((pde32_t *)V3_VAddr((void *)(addr_t)(((uint_t)cr3) & 0xfffff000)))
 183 #define CR3_TO_PDPE32PAE_VA(cr3) ((pdpe32pae_t *)V3_VAddr((void *)(addr_t)(((uint_t)cr3) & 0xffffffe0)))
 184 #define CR3_TO_PML4E64_VA(cr3)  ((pml4e64_t *)V3_VAddr((void *)(addr_t)(((ullong_t)cr3) & 0x000ffffffffff000LL)))
 185
 186
 187
 188
 189
 190
 191 /* Page Table Flag Values */
 192 #define PT32_HOOK 0x1
 193 #define PT32_GUEST_PT 0x2
 194
 195
 196
 197 /* We'll use the general form for now....
 198    typedef enum {PDE32_ENTRY_NOT_PRESENT, PDE32_ENTRY_PTE32, PDE32_ENTRY_LARGE_PAGE} pde32_entry_type_t;
 199    typedef enum {PTE32_ENTRY_NOT_PRESENT, PTE32_ENTRY_PAGE} pte32_entry_type_t;
 200
 201    typedef enum {PDPE32PAE_ENTRY_NOT_PRESENT, PDPE32PAE_ENTRY_PAGE} pdpe32pae_entry_type_t;
 202    typedef enum {PDE32PAE_ENTRY_NOT_PRESENT, PDE32PAE_ENTRY_PTE32, PDE32PAE_ENTRY_LARGE_PAGE} pde32pae_entry_type_t;
 203    typedef enum {PTE32PAE_ENTRY_NOT_PRESENT, PTE32PAE_ENTRY_PAGE} pte32pae_entry_type_t;
 204
 205    typedef enum {PML4E64_ENTRY_NOT_PRESENT, PML4E64_ENTRY_PAGE} pml4e64_entry_type_t;
 206    typedef enum {PDPE64_ENTRY_NOT_PRESENT, PDPE64_ENTRY_PTE32, PDPE64_ENTRY_LARGE_PAGE} pdpe64_entry_type_t;
 207    typedef enum {PDE64_ENTRY_NOT_PRESENT, PDE64_ENTRY_PTE32, PDE64_ENTRY_LARGE_PAGE} pde64_entry_type_t;
 208    typedef enum {PTE64_ENTRY_NOT_PRESENT, PTE64_ENTRY_PAGE} pte64_entry_type_t;
 209 */
 210
 211
 212 typedef enum {PT_ENTRY_NOT_PRESENT, PT_ENTRY_LARGE_PAGE, PT_ENTRY_PAGE} pt_entry_type_t;
 213 typedef enum {PT_ACCESS_OK, PT_ACCESS_NOT_PRESENT, PT_ACCESS_WRITE_ERROR, PT_ACCESS_USER_ERROR} pt_access_status_t;
 214
 215
 216 typedef struct gen_pt {
 217   uint_t present        : 1;
 218   uint_t writable       : 1;
 219   uint_t user_page      : 1;
 220 } __attribute__((packed)) gen_pt_t;
 221
 222 typedef struct pde32 {
 223   uint_t present         : 1;
 224   uint_t writable        : 1;
 225   uint_t user_page       : 1;
 226   uint_t write_through   : 1;
 227   uint_t cache_disable   : 1;
 228   uint_t accessed        : 1;
 229   uint_t reserved        : 1;
 230   uint_t large_page     : 1;
 231   uint_t global_page     : 1;
 232   uint_t vmm_info        : 3;
 233   uint_t pt_base_addr    : 20;
 234 } __attribute__((packed))  pde32_t;
 235
 236 typedef struct pde32_4MB {
 237   uint_t present         : 1;
 238   uint_t writable        : 1;
 239   uint_t user_page       : 1;
 240   uint_t write_through   : 1;
 241   uint_t cache_disable   : 1;
 242   uint_t accessed        : 1;
 243   uint_t dirty           : 1;
 244   uint_t large_page      : 1;
 245   uint_t global_page     : 1;
 246   uint_t vmm_info        : 3;
 247   uint_t pat             : 1;
 248   uint_t rsvd            : 9;
 249   uint_t page_base_addr  : 10;
 250
 251 } __attribute__((packed))  pde32_4MB_t;
 252
 253 typedef struct pte32 {
 254   uint_t present         : 1;
 255   uint_t writable        : 1;
 256   uint_t user_page       : 1;
 257   uint_t write_through   : 1;
 258   uint_t cache_disable   : 1;
 259   uint_t accessed        : 1;
 260   uint_t dirty           : 1;
 261   uint_t pte_attr        : 1;
 262   uint_t global_page     : 1;
 263   uint_t vmm_info        : 3;
 264   uint_t page_base_addr  : 20;
 265 }  __attribute__((packed)) pte32_t;
 266 /* ***** */
 267
 268 /* 32 bit PAE PAGE STRUCTURES */
 269 typedef struct pdpe32pae {
 270   uint_t present       : 1;
 271   uint_t rsvd          : 2; // MBZ
 272   uint_t write_through : 1;
 273   uint_t cache_disable : 1;
 274   uint_t accessed      : 1;
 275   uint_t avail         : 1;
 276   uint_t rsvd2         : 2;  // MBZ
 277   uint_t vmm_info      : 3;
 278   uint_t pd_base_addr  : 24;
 279   uint_t rsvd3         : 28; // MBZ
 280 } __attribute__((packed)) pdpe32pae_t;
 281
 282
 283
 284 typedef struct pde32pae {
 285   uint_t present         : 1;
 286   uint_t writable        : 1;
 287   uint_t user_page       : 1;
 288   uint_t write_through   : 1;
 289   uint_t cache_disable   : 1;
 290   uint_t accessed        : 1;
 291   uint_t avail           : 1;
 292   uint_t large_page      : 1;
 293   uint_t global_page     : 1;
 294   uint_t vmm_info        : 3;
 295   uint_t pt_base_addr    : 24;
 296   uint_t rsvd            : 28;
 297 } __attribute__((packed)) pde32pae_t;
 298
 299 typedef struct pde32pae_2MB {
 300   uint_t present         : 1;
 301   uint_t writable        : 1;
 302   uint_t user_page       : 1;
 303   uint_t write_through   : 1;
 304   uint_t cache_disable   : 1;
 305   uint_t accessed        : 1;
 306   uint_t dirty           : 1;
 307   uint_t one             : 1;
 308   uint_t global_page     : 1;
 309   uint_t vmm_info        : 3;
 310   uint_t pat             : 1;
 311   uint_t rsvd            : 8;
 312   uint_t page_base_addr  : 15;
 313   uint_t rsvd2           : 28;
 314
 315 } __attribute__((packed)) pde32pae_2MB_t;
 316
 317 typedef struct pte32pae {
 318   uint_t present         : 1;
 319   uint_t writable        : 1;
 320   uint_t user_page       : 1;
 321   uint_t write_through   : 1;
 322   uint_t cache_disable   : 1;
 323   uint_t accessed        : 1;
 324   uint_t dirty           : 1;
 325   uint_t pte_attr        : 1;
 326   uint_t global_page     : 1;
 327   uint_t vmm_info        : 3;
 328   uint_t page_base_addr  : 24;
 329   uint_t rsvd            : 28;
 330 } __attribute__((packed)) pte32pae_t;
 331
 332
 333
 334
 335
 336 /* ********** */
 337
 338
 339 /* LONG MODE 64 bit PAGE STRUCTURES */
 340 typedef struct pml4e64 {
 341   uint_t present        : 1;
 342   uint_t writable       : 1;
 343   uint_t user_page           : 1;
 344   uint_t write_through  : 1;
 345   uint_t cache_disable  : 1;
 346   uint_t accessed       : 1;
 347   uint_t reserved       : 1;
 348   uint_t zero           : 2;
 349   uint_t vmm_info       : 3;
 350   ullong_t pdp_base_addr : 40;
 351   uint_t available      : 11;
 352   uint_t no_execute     : 1;
 353 } __attribute__((packed)) pml4e64_t;
 354
 355
 356 typedef struct pdpe64 {
 357   uint_t present        : 1;
 358   uint_t writable       : 1;
 359   uint_t user_page      : 1;
 360   uint_t write_through  : 1;
 361   uint_t cache_disable  : 1;
 362   uint_t accessed       : 1;
 363   uint_t avail          : 1;
 364   uint_t large_page     : 1;
 365   uint_t zero           : 1;
 366   uint_t vmm_info       : 3;
 367   ullong_t pd_base_addr : 40;
 368   uint_t available      : 11;
 369   uint_t no_execute     : 1;
 370 } __attribute__((packed)) pdpe64_t;
 371
 372
 373 // We Don't support this
 374 typedef struct pdpe64_1GB {
 375   uint_t present        : 1;
 376   uint_t writable       : 1;
 377   uint_t user_page      : 1;
 378   uint_t write_through  : 1;
 379   uint_t cache_disable  : 1;
 380   uint_t accessed       : 1;
 381   uint_t dirty          : 1;
 382   uint_t large_page     : 1;
 383   uint_t global_page    : 1;
 384   uint_t vmm_info       : 3;
 385   uint_t pat            : 1;
 386   uint_t rsvd           : 17;
 387   ullong_t page_base_addr : 22;
 388   uint_t available      : 11;
 389   uint_t no_execute     : 1;
 390 } __attribute__((packed)) pdpe64_1GB_t;
 391
 392
 393
 394 typedef struct pde64 {
 395   uint_t present         : 1;
 396   uint_t writable        : 1;
 397   uint_t user_page       : 1;
 398   uint_t write_through   : 1;
 399   uint_t cache_disable   : 1;
 400   uint_t accessed        : 1;
 401   uint_t avail           : 1;
 402   uint_t large_page      : 1;
 403   uint_t global_page     : 1;
 404   uint_t vmm_info        : 3;
 405   ullong_t pt_base_addr  : 40;
 406   uint_t available       : 11;
 407   uint_t no_execute      : 1;
 408 } __attribute__((packed)) pde64_t;
 409
 410 typedef struct pde64_2MB {
 411   uint_t present         : 1;
 412   uint_t writable        : 1;
 413   uint_t user_page       : 1;
 414   uint_t write_through   : 1;
 415   uint_t cache_disable   : 1;
 416   uint_t accessed        : 1;
 417   uint_t dirty           : 1;
 418   uint_t large_page      : 1;
 419   uint_t global_page     : 1;
 420   uint_t vmm_info        : 3;
 421   uint_t pat             : 1;
 422   uint_t rsvd            : 8;
 423   ullong_t page_base_addr  : 31;
 424   uint_t available       : 11;
 425   uint_t no_execute      : 1;
 426 } __attribute__((packed)) pde64_2MB_t;
 427
 428
 429 typedef struct pte64 {
 430   uint_t present         : 1;
 431   uint_t writable        : 1;
 432   uint_t user_page       : 1;
 433   uint_t write_through   : 1;
 434   uint_t cache_disable   : 1;
 435   uint_t accessed        : 1;
 436   uint_t dirty           : 1;
 437   uint_t pte_attr        : 1;
 438   uint_t global_page     : 1;
 439   uint_t vmm_info        : 3;
 440   ullong_t page_base_addr : 40;
 441   uint_t available       : 11;
 442   uint_t no_execute      : 1;
 443 } __attribute__((packed)) pte64_t;
 444
 445 /* *************** */
 446
 447 typedef struct pf_error_code {
 448   uint_t present           : 1; // if 0, fault due to page not present
 449   uint_t write             : 1; // if 1, faulting access was a write
 450   uint_t user              : 1; // if 1, faulting access was in user mode
 451   uint_t rsvd_access       : 1; // if 1, fault from reading a 1 from a reserved field (?)
 452   uint_t ifetch            : 1; // if 1, faulting access was an instr fetch (only with NX)
 453   uint_t rsvd              : 27;
 454 } __attribute__((packed)) pf_error_t;
 455
 456
 457
 458
 459
 460 struct guest_info;
 461
 462 int v3_translate_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr);
 463 int v3_translate_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr);
 464 int v3_translate_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr);
 465
 466 int v3_translate_host_pt_32(v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 467 int v3_translate_host_pt_32pae(v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 468 int v3_translate_host_pt_64(v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 469
 470
 471 int v3_find_host_pt_32_page(v3_reg_t host_cr3, page_type_t type, addr_t vaddr, addr_t * page_addr);
 472 int v3_find_host_pt_32pae_page(v3_reg_t host_cr3, page_type_t type, addr_t vaddr, addr_t * page_addr);
 473 int v3_find_host_pt_64_page(v3_reg_t host_cr3, page_type_t type, addr_t vaddr, addr_t * page_addr);
 474 int v3_find_guest_pt_32_page(struct guest_info * info, v3_reg_t guest_cr3,
 475                              page_type_t type, addr_t vaddr,
 476                              addr_t * page_addr);
 477 int v3_find_guest_pt_32pae_page(struct guest_info * info, v3_reg_t guest_cr3,
 478                                 page_type_t type, addr_t vaddr,
 479                                 addr_t * page_addr);
 480 int v3_find_guest_pt_64_page(struct guest_info * info, v3_reg_t guest_cr3,
 481                              page_type_t type, addr_t vaddr,
 482                              addr_t * page_addr);
 483
 484 pt_access_status_t inline v3_can_access_pde32(pde32_t * pde, addr_t addr, pf_error_t access_type);
 485 pt_access_status_t inline v3_can_access_pte32(pte32_t * pte, addr_t addr, pf_error_t access_type);
 486
 487 pt_access_status_t inline v3_can_access_pdpe32pae(pdpe32pae_t * pdpe, addr_t addr, pf_error_t access_type);
 488 pt_access_status_t inline v3_can_access_pde32pae(pde32pae_t * pde, addr_t addr, pf_error_t access_type);
 489 pt_access_status_t inline v3_can_access_pte32pae(pte32pae_t * pte, addr_t addr, pf_error_t access_type);
 490
 491 pt_access_status_t inline v3_can_access_pml4e64(pml4e64_t * pmle, addr_t addr, pf_error_t access_type);
 492 pt_access_status_t inline v3_can_access_pdpe64(pdpe64_t * pdpe, addr_t addr, pf_error_t access_type);
 493 pt_access_status_t inline v3_can_access_pde64(pde64_t * pde, addr_t addr, pf_error_t access_type);
 494 pt_access_status_t inline v3_can_access_pte64(pte64_t * pte, addr_t addr, pf_error_t access_type);
 495
 496
 497 int v3_check_host_pt_32(v3_reg_t host_cr3, addr_t vaddr,
 498                         pf_error_t access_type, pt_access_status_t * access_status);
 499 int v3_check_host_pt_32pae(v3_reg_t host_cr3, addr_t vaddr,
 500                            pf_error_t access_type, pt_access_status_t * access_status);
 501 int v3_check_host_pt_64(v3_reg_t host_cr3, addr_t vaddr,
 502                         pf_error_t access_type, pt_access_status_t * access_status);
 503 int v3_check_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 504                          pf_error_t access_type, pt_access_status_t * access_status);
 505 int v3_check_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 506                             pf_error_t access_type, pt_access_status_t * access_status);
 507 int v3_check_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 508                          pf_error_t access_type, pt_access_status_t * access_status);
 509
 510
 511
 512
 513 int v3_drill_host_pt_32(v3_reg_t host_cr3, addr_t vaddr,
 514                         int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 515                         void * private_data);
 516 int v3_drill_host_pt_32pae(v3_reg_t host_cr3, addr_t vaddr,
 517                            int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 518                            void * private_data);
 519 int v3_drill_host_pt_64(v3_reg_t host_cr3, addr_t vaddr,
 520                         int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 521                         void * private_data);
 522
 523 int v3_drill_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 524                          int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 525                          void * private_data);
 526 int v3_drill_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 527                             int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 528                             void * private_data);
 529 int v3_drill_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 530                          int (*callback)(page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 531                          void * private_data);
 532
 533
 534
 535 int v3_walk_host_pt_32(v3_reg_t host_cr3,
 536                        int (*callback)(page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 537                        void * private_data);
 538
 539 int v3_walk_host_pt_32pae(v3_reg_t host_cr3,
 540                           int (*callback)(page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 541                           void * private_data);
 542
 543 int v3_walk_host_pt_64(v3_reg_t host_cr3,
 544                        int (*callback)(page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 545                        void * private_data);
 546
 547 int v3_walk_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3,
 548                         int (*callback)(page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 549                         void * private_data);
 550
 551 int v3_walk_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3,
 552                            int (*callback)(page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 553                            void * private_data);
 554
 555 int v3_walk_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3,
 556                         int (*callback)(page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 557                         void * private_data);
 558
 559
 560 pde32_t * create_passthrough_pts_32(struct guest_info * guest_info);
 561 pdpe32pae_t * create_passthrough_pts_32PAE(struct guest_info * guest_info);
 562 pml4e64_t * create_passthrough_pts_64(struct guest_info * info);
 563
 564
 565 void delete_page_tables_32(pde32_t * pde);
 566 void delete_page_tables_32PAE(pdpe32pae_t * pdpe);
 567 void delete_page_tables_64(pml4e64_t *  pml4);
 568
 569
 570
 571 const uchar_t * v3_page_type_to_str(page_type_t type);
 572
 573
 574
 575 void PrintPTEntry(page_type_t type, addr_t vaddr, void * entry);
 576 void PrintHostPageTables(v3_vm_cpu_mode_t cpu_mode, addr_t cr3);
 577 void PrintGuestPageTables(struct guest_info * info, addr_t cr3);
 578 void PrintHostPageTree(v3_vm_cpu_mode_t cpu_mode, addr_t virtual_addr, addr_t cr3);
 579 void PrintGuestPageTree(struct guest_info * info, addr_t virtual_addr, addr_t cr3);
 580
 581
 582 #endif // !__V3VEE__
 583
 584
 585
 586 #endif