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 #define PAGE_BASE_ADDR(x) ((x) >> 12)
 133 #define PAGE_BASE_ADDR_4KB(x) ((x) >> 12)
 134 #define PAGE_BASE_ADDR_2MB(x) ((x) >> 21)
 135 #define PAGE_BASE_ADDR_4MB(x) ((x) >> 22)
 136 #define PAGE_BASE_ADDR_1GB(x) ((x) >> 30)
 137
 138 #define BASE_TO_PAGE_ADDR(x) (((addr_t)x) << 12)
 139 #define BASE_TO_PAGE_ADDR_4KB(x) (((addr_t)x) << 12)
 140 #define BASE_TO_PAGE_ADDR_2MB(x) (((addr_t)x) << 21)
 141 #define BASE_TO_PAGE_ADDR_4MB(x) (((addr_t)x) << 22)
 142 #define BASE_TO_PAGE_ADDR_1GB(x) (((addr_t)x) << 30)
 143 /* *** */
 144
 145
 146 #define PAGE_OFFSET(x) ((x) & 0xfff)
 147 #define PAGE_OFFSET_4KB(x) ((x) & 0xfff)
 148 #define PAGE_OFFSET_2MB(x) ((x) & 0x1fffff)
 149 #define PAGE_OFFSET_4MB(x) ((x) & 0x3fffff)
 150 #define PAGE_OFFSET_1GB(x) ((x) & 0x3fffffff)
 151
 152 #define PAGE_POWER 12
 153 #define PAGE_POWER_4KB 12
 154 #define PAGE_POWER_2MB 21
 155 #define PAGE_POWER_4MB 22
 156 #define PAGE_POWER_1GB 30
 157
 158 // We shift instead of mask because we don't know the address size
 159 #define PAGE_ADDR(x) (((x) >> PAGE_POWER) << PAGE_POWER)
 160 #define PAGE_ADDR_4KB(x) (((x) >> PAGE_POWER_4KB) << PAGE_POWER_4KB)
 161 #define PAGE_ADDR_2MB(x) (((x) >> PAGE_POWER_2MB) << PAGE_POWER_2MB)
 162 #define PAGE_ADDR_4MB(x) (((x) >> PAGE_POWER_4MB) << PAGE_POWER_4MB)
 163 #define PAGE_ADDR_1GB(x) (((x) >> PAGE_POWER_1GB) << PAGE_POWER_1GB)
 164
 165 #define PAGE_SIZE 4096
 166 #define PAGE_SIZE_4KB 4096
 167 #define PAGE_SIZE_2MB (4096 * 512)
 168 #define PAGE_SIZE_4MB (4096 * 1024)
 169 #define PAGE_SIZE_1GB 0x40000000
 170
 171 /* *** */
 172
 173
 174
 175
 176
 177 #define CR3_TO_PDE32_PA(cr3) ((addr_t)(((uint_t)cr3) & 0xfffff000))
 178 #define CR3_TO_PDPE32PAE_PA(cr3) ((addr_t)(((uint_t)cr3) & 0xffffffe0))
 179 #define CR3_TO_PML4E64_PA(cr3)  ((addr_t)(((ullong_t)cr3) & 0x000ffffffffff000LL))
 180
 181 #define CR3_TO_PDE32_VA(cr3) ((pde32_t *)V3_VAddr((void *)(addr_t)(((uint_t)cr3) & 0xfffff000)))
 182 #define CR3_TO_PDPE32PAE_VA(cr3) ((pdpe32pae_t *)V3_VAddr((void *)(addr_t)(((uint_t)cr3) & 0xffffffe0)))
 183 #define CR3_TO_PML4E64_VA(cr3)  ((pml4e64_t *)V3_VAddr((void *)(addr_t)(((ullong_t)cr3) & 0x000ffffffffff000LL)))
 184
 185
 186
 187
 188
 189
 190 /* Page Table Flag Values */
 191 #define PT32_HOOK 0x1
 192 #define PT32_GUEST_PT 0x2
 193
 194
 195
 196 /* We'll use the general form for now....
 197    typedef enum {PDE32_ENTRY_NOT_PRESENT, PDE32_ENTRY_PTE32, PDE32_ENTRY_LARGE_PAGE} pde32_entry_type_t;
 198    typedef enum {PTE32_ENTRY_NOT_PRESENT, PTE32_ENTRY_PAGE} pte32_entry_type_t;
 199
 200    typedef enum {PDPE32PAE_ENTRY_NOT_PRESENT, PDPE32PAE_ENTRY_PAGE} pdpe32pae_entry_type_t;
 201    typedef enum {PDE32PAE_ENTRY_NOT_PRESENT, PDE32PAE_ENTRY_PTE32, PDE32PAE_ENTRY_LARGE_PAGE} pde32pae_entry_type_t;
 202    typedef enum {PTE32PAE_ENTRY_NOT_PRESENT, PTE32PAE_ENTRY_PAGE} pte32pae_entry_type_t;
 203
 204    typedef enum {PML4E64_ENTRY_NOT_PRESENT, PML4E64_ENTRY_PAGE} pml4e64_entry_type_t;
 205    typedef enum {PDPE64_ENTRY_NOT_PRESENT, PDPE64_ENTRY_PTE32, PDPE64_ENTRY_LARGE_PAGE} pdpe64_entry_type_t;
 206    typedef enum {PDE64_ENTRY_NOT_PRESENT, PDE64_ENTRY_PTE32, PDE64_ENTRY_LARGE_PAGE} pde64_entry_type_t;
 207    typedef enum {PTE64_ENTRY_NOT_PRESENT, PTE64_ENTRY_PAGE} pte64_entry_type_t;
 208 */
 209
 210
 211 typedef enum {PT_ENTRY_NOT_PRESENT, PT_ENTRY_LARGE_PAGE, PT_ENTRY_PAGE} pt_entry_type_t;
 212 typedef enum {PT_ACCESS_OK, PT_ACCESS_NOT_PRESENT, PT_ACCESS_WRITE_ERROR, PT_ACCESS_USER_ERROR} pt_access_status_t;
 213
 214
 215 typedef struct gen_pt {
 216   uint_t present        : 1;
 217   uint_t writable       : 1;
 218   uint_t user_page      : 1;
 219 } __attribute__((packed)) gen_pt_t;
 220
 221 typedef struct pde32 {
 222   uint_t present         : 1;
 223   uint_t writable        : 1;
 224   uint_t user_page       : 1;
 225   uint_t write_through   : 1;
 226   uint_t cache_disable   : 1;
 227   uint_t accessed        : 1;
 228   uint_t reserved        : 1;
 229   uint_t large_page     : 1;
 230   uint_t global_page     : 1;
 231   uint_t vmm_info        : 3;
 232   uint_t pt_base_addr    : 20;
 233 } __attribute__((packed))  pde32_t;
 234
 235 typedef struct pde32_4MB {
 236   uint_t present         : 1;
 237   uint_t writable        : 1;
 238   uint_t user_page       : 1;
 239   uint_t write_through   : 1;
 240   uint_t cache_disable   : 1;
 241   uint_t accessed        : 1;
 242   uint_t dirty           : 1;
 243   uint_t large_page      : 1;
 244   uint_t global_page     : 1;
 245   uint_t vmm_info        : 3;
 246   uint_t pat             : 1;
 247   uint_t rsvd            : 9;
 248   uint_t page_base_addr  : 10;
 249
 250 } __attribute__((packed))  pde32_4MB_t;
 251
 252 typedef struct pte32 {
 253   uint_t present         : 1;
 254   uint_t writable        : 1;
 255   uint_t user_page       : 1;
 256   uint_t write_through   : 1;
 257   uint_t cache_disable   : 1;
 258   uint_t accessed        : 1;
 259   uint_t dirty           : 1;
 260   uint_t pte_attr        : 1;
 261   uint_t global_page     : 1;
 262   uint_t vmm_info        : 3;
 263   uint_t page_base_addr  : 20;
 264 }  __attribute__((packed)) pte32_t;
 265 /* ***** */
 266
 267 /* 32 bit PAE PAGE STRUCTURES */
 268 typedef struct pdpe32pae {
 269   uint_t present       : 1;
 270   uint_t rsvd          : 2; // MBZ
 271   uint_t write_through : 1;
 272   uint_t cache_disable : 1;
 273   uint_t accessed      : 1;
 274   uint_t avail         : 1;
 275   uint_t rsvd2         : 2;  // MBZ
 276   uint_t vmm_info      : 3;
 277   uint_t pd_base_addr  : 24;
 278   uint_t rsvd3         : 28; // MBZ
 279 } __attribute__((packed)) pdpe32pae_t;
 280
 281
 282
 283 typedef struct pde32pae {
 284   uint_t present         : 1;
 285   uint_t writable        : 1;
 286   uint_t user_page       : 1;
 287   uint_t write_through   : 1;
 288   uint_t cache_disable   : 1;
 289   uint_t accessed        : 1;
 290   uint_t avail           : 1;
 291   uint_t large_page      : 1;
 292   uint_t global_page     : 1;
 293   uint_t vmm_info        : 3;
 294   uint_t pt_base_addr    : 24;
 295   uint_t rsvd            : 28;
 296 } __attribute__((packed)) pde32pae_t;
 297
 298 typedef struct pde32pae_2MB {
 299   uint_t present         : 1;
 300   uint_t writable        : 1;
 301   uint_t user_page       : 1;
 302   uint_t write_through   : 1;
 303   uint_t cache_disable   : 1;
 304   uint_t accessed        : 1;
 305   uint_t dirty           : 1;
 306   uint_t one             : 1;
 307   uint_t global_page     : 1;
 308   uint_t vmm_info        : 3;
 309   uint_t pat             : 1;
 310   uint_t rsvd            : 8;
 311   uint_t page_base_addr  : 15;
 312   uint_t rsvd2           : 28;
 313
 314 } __attribute__((packed)) pde32pae_2MB_t;
 315
 316 typedef struct pte32pae {
 317   uint_t present         : 1;
 318   uint_t writable        : 1;
 319   uint_t user_page       : 1;
 320   uint_t write_through   : 1;
 321   uint_t cache_disable   : 1;
 322   uint_t accessed        : 1;
 323   uint_t dirty           : 1;
 324   uint_t pte_attr        : 1;
 325   uint_t global_page     : 1;
 326   uint_t vmm_info        : 3;
 327   uint_t page_base_addr  : 24;
 328   uint_t rsvd            : 28;
 329 } __attribute__((packed)) pte32pae_t;
 330
 331
 332
 333
 334
 335 /* ********** */
 336
 337
 338 /* LONG MODE 64 bit PAGE STRUCTURES */
 339 typedef struct pml4e64 {
 340   uint_t present        : 1;
 341   uint_t writable       : 1;
 342   uint_t user_page           : 1;
 343   uint_t write_through  : 1;
 344   uint_t cache_disable  : 1;
 345   uint_t accessed       : 1;
 346   uint_t reserved       : 1;
 347   uint_t zero           : 2;
 348   uint_t vmm_info       : 3;
 349   ullong_t pdp_base_addr : 40;
 350   uint_t available      : 11;
 351   uint_t no_execute     : 1;
 352 } __attribute__((packed)) pml4e64_t;
 353
 354
 355 typedef struct pdpe64 {
 356   uint_t present        : 1;
 357   uint_t writable       : 1;
 358   uint_t user_page      : 1;
 359   uint_t write_through  : 1;
 360   uint_t cache_disable  : 1;
 361   uint_t accessed       : 1;
 362   uint_t avail          : 1;
 363   uint_t large_page     : 1;
 364   uint_t zero           : 1;
 365   uint_t vmm_info       : 3;
 366   ullong_t pd_base_addr : 40;
 367   uint_t available      : 11;
 368   uint_t no_execute     : 1;
 369 } __attribute__((packed)) pdpe64_t;
 370
 371
 372 // We Don't support this
 373 typedef struct pdpe64_1GB {
 374   uint_t present        : 1;
 375   uint_t writable       : 1;
 376   uint_t user_page      : 1;
 377   uint_t write_through  : 1;
 378   uint_t cache_disable  : 1;
 379   uint_t accessed       : 1;
 380   uint_t dirty          : 1;
 381   uint_t large_page     : 1;
 382   uint_t global_page    : 1;
 383   uint_t vmm_info       : 3;
 384   uint_t pat            : 1;
 385   uint_t rsvd           : 17;
 386   ullong_t page_base_addr : 22;
 387   uint_t available      : 11;
 388   uint_t no_execute     : 1;
 389 } __attribute__((packed)) pdpe64_1GB_t;
 390
 391
 392
 393 typedef struct pde64 {
 394   uint_t present         : 1;
 395   uint_t writable        : 1;
 396   uint_t user_page       : 1;
 397   uint_t write_through   : 1;
 398   uint_t cache_disable   : 1;
 399   uint_t accessed        : 1;
 400   uint_t avail           : 1;
 401   uint_t large_page      : 1;
 402   uint_t global_page     : 1;
 403   uint_t vmm_info        : 3;
 404   ullong_t pt_base_addr  : 40;
 405   uint_t available       : 11;
 406   uint_t no_execute      : 1;
 407 } __attribute__((packed)) pde64_t;
 408
 409 typedef struct pde64_2MB {
 410   uint_t present         : 1;
 411   uint_t writable        : 1;
 412   uint_t user_page       : 1;
 413   uint_t write_through   : 1;
 414   uint_t cache_disable   : 1;
 415   uint_t accessed        : 1;
 416   uint_t dirty           : 1;
 417   uint_t large_page      : 1;
 418   uint_t global_page     : 1;
 419   uint_t vmm_info        : 3;
 420   uint_t pat             : 1;
 421   uint_t rsvd            : 8;
 422   ullong_t page_base_addr  : 31;
 423   uint_t available       : 11;
 424   uint_t no_execute      : 1;
 425 } __attribute__((packed)) pde64_2MB_t;
 426
 427
 428 typedef struct pte64 {
 429   uint_t present         : 1;
 430   uint_t writable        : 1;
 431   uint_t user_page       : 1;
 432   uint_t write_through   : 1;
 433   uint_t cache_disable   : 1;
 434   uint_t accessed        : 1;
 435   uint_t dirty           : 1;
 436   uint_t pte_attr        : 1;
 437   uint_t global_page     : 1;
 438   uint_t vmm_info        : 3;
 439   ullong_t page_base_addr : 40;
 440   uint_t available       : 11;
 441   uint_t no_execute      : 1;
 442 } __attribute__((packed)) pte64_t;
 443
 444 /* *************** */
 445
 446 typedef struct pf_error_code {
 447   uint_t present           : 1; // if 0, fault due to page not present
 448   uint_t write             : 1; // if 1, faulting access was a write
 449   uint_t user              : 1; // if 1, faulting access was in user mode
 450   uint_t rsvd_access       : 1; // if 1, fault from reading a 1 from a reserved field (?)
 451   uint_t ifetch            : 1; // if 1, faulting access was an instr fetch (only with NX)
 452   uint_t rsvd              : 27;
 453 } __attribute__((packed)) pf_error_t;
 454
 455
 456
 457
 458
 459 struct guest_info;
 460
 461 int v3_translate_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr);
 462 int v3_translate_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr);
 463 int v3_translate_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr);
 464
 465 int v3_translate_host_pt_32(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 466 int v3_translate_host_pt_32pae(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 467 int v3_translate_host_pt_64(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 468
 469
 470 int v3_find_host_pt_32_page(struct guest_info * info, v3_reg_t host_cr3, page_type_t type, addr_t vaddr,
 471                             addr_t * page_ptr, addr_t * page_pa);
 472 int v3_find_host_pt_32pae_page(struct guest_info * info, v3_reg_t host_cr3, page_type_t type, addr_t vaddr,
 473                                addr_t * page_ptr, addr_t * page_pa);
 474 int v3_find_host_pt_64_page(struct guest_info * info, v3_reg_t host_cr3, page_type_t type, addr_t vaddr,
 475                             addr_t * page_ptr, addr_t * page_pa);
 476 int v3_find_guest_pt_32_page(struct guest_info * info, v3_reg_t guest_cr3,
 477                              page_type_t type, addr_t vaddr,
 478                              addr_t * page_ptr, addr_t * page_pa);
 479 int v3_find_guest_pt_32pae_page(struct guest_info * info, v3_reg_t guest_cr3,
 480                                 page_type_t type, addr_t vaddr,
 481                                 addr_t * page_ptr, addr_t * page_pa);
 482 int v3_find_guest_pt_64_page(struct guest_info * info, v3_reg_t guest_cr3,
 483                              page_type_t type, addr_t vaddr,
 484                              addr_t * page_ptr, addr_t * page_pa);
 485
 486 pt_access_status_t inline v3_can_access_pde32(pde32_t * pde, addr_t addr, pf_error_t access_type);
 487 pt_access_status_t inline v3_can_access_pte32(pte32_t * pte, addr_t addr, pf_error_t access_type);
 488
 489 pt_access_status_t inline v3_can_access_pdpe32pae(pdpe32pae_t * pdpe, addr_t addr, pf_error_t access_type);
 490 pt_access_status_t inline v3_can_access_pde32pae(pde32pae_t * pde, addr_t addr, pf_error_t access_type);
 491 pt_access_status_t inline v3_can_access_pte32pae(pte32pae_t * pte, addr_t addr, pf_error_t access_type);
 492
 493 pt_access_status_t inline v3_can_access_pml4e64(pml4e64_t * pmle, addr_t addr, pf_error_t access_type);
 494 pt_access_status_t inline v3_can_access_pdpe64(pdpe64_t * pdpe, addr_t addr, pf_error_t access_type);
 495 pt_access_status_t inline v3_can_access_pde64(pde64_t * pde, addr_t addr, pf_error_t access_type);
 496 pt_access_status_t inline v3_can_access_pte64(pte64_t * pte, addr_t addr, pf_error_t access_type);
 497
 498
 499 int v3_check_host_pt_32(struct guest_info * info, 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_32pae(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr,
 502                            pf_error_t access_type, pt_access_status_t * access_status);
 503 int v3_check_host_pt_64(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr,
 504                         pf_error_t access_type, pt_access_status_t * access_status);
 505 int v3_check_guest_pt_32(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_32pae(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 int v3_check_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 510                          pf_error_t access_type, pt_access_status_t * access_status);
 511
 512
 513
 514
 515 int v3_drill_host_pt_32(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr,
 516                         int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 517                         void * private_data);
 518 int v3_drill_host_pt_32pae(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr,
 519                            int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 520                            void * private_data);
 521 int v3_drill_host_pt_64(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr,
 522                         int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 523                         void * private_data);
 524
 525 int v3_drill_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 526                          int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 527                          void * private_data);
 528 int v3_drill_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 529                             int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 530                             void * private_data);
 531 int v3_drill_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 532                          int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 533                          void * private_data);
 534
 535
 536
 537 int v3_walk_host_pt_32(struct guest_info * info, v3_reg_t host_cr3,
 538                        int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 539                        void * private_data);
 540
 541 int v3_walk_host_pt_32pae(struct guest_info * info, v3_reg_t host_cr3,
 542                           int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 543                           void * private_data);
 544
 545 int v3_walk_host_pt_64(struct guest_info * info, v3_reg_t host_cr3,
 546                        int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 547                        void * private_data);
 548
 549 int v3_walk_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3,
 550                         int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 551                         void * private_data);
 552
 553 int v3_walk_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3,
 554                            int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 555                            void * private_data);
 556
 557 int v3_walk_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3,
 558                         int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 559                         void * private_data);
 560
 561
 562 pde32_t * create_passthrough_pts_32(struct guest_info * guest_info);
 563 pdpe32pae_t * create_passthrough_pts_32PAE(struct guest_info * guest_info);
 564 pml4e64_t * create_passthrough_pts_64(struct guest_info * info);
 565
 566
 567 void delete_page_tables_32(pde32_t * pde);
 568 void delete_page_tables_32PAE(pdpe32pae_t * pdpe);
 569 void delete_page_tables_64(pml4e64_t *  pml4);
 570
 571
 572
 573 const uchar_t * v3_page_type_to_str(page_type_t type);
 574
 575
 576
 577 void PrintPTEntry(struct guest_info * info, page_type_t type, addr_t vaddr, void * entry);
 578 void PrintHostPageTables(struct guest_info * info,  addr_t cr3);
 579 void PrintGuestPageTables(struct guest_info * info, addr_t cr3);
 580 void PrintHostPageTree(struct guest_info * info, addr_t virtual_addr, addr_t cr3);
 581 void PrintGuestPageTree(struct guest_info * info, addr_t virtual_addr, addr_t cr3);
 582
 583
 584 #endif // !__V3VEE__
 585
 586
 587
 588 #endif