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