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 V3_LARGE_PG 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
 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(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 467 int v3_translate_host_pt_32pae(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 468 int v3_translate_host_pt_64(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 469
 470
 471 int v3_find_host_pt_32_page(struct guest_info * info, v3_reg_t host_cr3, page_type_t type, addr_t vaddr,
 472                             addr_t * page_ptr, addr_t * page_pa);
 473 int v3_find_host_pt_32pae_page(struct guest_info * info, v3_reg_t host_cr3, page_type_t type, addr_t vaddr,
 474                                addr_t * page_ptr, addr_t * page_pa);
 475 int v3_find_host_pt_64_page(struct guest_info * info, v3_reg_t host_cr3, page_type_t type, addr_t vaddr,
 476                             addr_t * page_ptr, addr_t * page_pa);
 477 int v3_find_guest_pt_32_page(struct guest_info * info, v3_reg_t guest_cr3,
 478                              page_type_t type, addr_t vaddr,
 479                              addr_t * page_ptr, addr_t * page_pa);
 480 int v3_find_guest_pt_32pae_page(struct guest_info * info, v3_reg_t guest_cr3,
 481                                 page_type_t type, addr_t vaddr,
 482                                 addr_t * page_ptr, addr_t * page_pa);
 483 int v3_find_guest_pt_64_page(struct guest_info * info, v3_reg_t guest_cr3,
 484                              page_type_t type, addr_t vaddr,
 485                              addr_t * page_ptr, addr_t * page_pa);
 486
 487
 488
 489 pt_access_status_t inline v3_can_access_pde32(pde32_t * pde, addr_t addr, pf_error_t access_type);
 490 pt_access_status_t inline v3_can_access_pte32(pte32_t * pte, addr_t addr, pf_error_t access_type);
 491
 492 pt_access_status_t inline v3_can_access_pdpe32pae(pdpe32pae_t * pdpe, addr_t addr, pf_error_t access_type);
 493 pt_access_status_t inline v3_can_access_pde32pae(pde32pae_t * pde, addr_t addr, pf_error_t access_type);
 494 pt_access_status_t inline v3_can_access_pte32pae(pte32pae_t * pte, addr_t addr, pf_error_t access_type);
 495
 496 pt_access_status_t inline v3_can_access_pml4e64(pml4e64_t * pmle, addr_t addr, pf_error_t access_type);
 497 pt_access_status_t inline v3_can_access_pdpe64(pdpe64_t * pdpe, addr_t addr, pf_error_t access_type);
 498 pt_access_status_t inline v3_can_access_pde64(pde64_t * pde, addr_t addr, pf_error_t access_type);
 499 pt_access_status_t inline v3_can_access_pte64(pte64_t * pte, addr_t addr, pf_error_t access_type);
 500
 501
 502 int v3_check_host_pt_32(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr,
 503                         pf_error_t access_type, pt_access_status_t * access_status);
 504 int v3_check_host_pt_32pae(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr,
 505                            pf_error_t access_type, pt_access_status_t * access_status);
 506 int v3_check_host_pt_64(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr,
 507                         pf_error_t access_type, pt_access_status_t * access_status);
 508 int v3_check_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 509                          pf_error_t access_type, pt_access_status_t * access_status);
 510 int v3_check_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 511                             pf_error_t access_type, pt_access_status_t * access_status);
 512 int v3_check_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 513                          pf_error_t access_type, pt_access_status_t * access_status);
 514
 515
 516
 517 page_type_t v3_get_guest_data_page_type_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 518 page_type_t v3_get_guest_data_page_type_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 519 page_type_t v3_get_guest_data_page_type_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 520 page_type_t v3_get_host_data_page_type_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 521 page_type_t v3_get_host_data_page_type_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 522 page_type_t v3_get_host_data_page_type_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 523
 524
 525 int v3_drill_host_pt_32(struct guest_info * info, v3_reg_t host_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_host_pt_32pae(struct guest_info * info, v3_reg_t host_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_host_pt_64(struct guest_info * info, v3_reg_t host_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 int v3_drill_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 536                          int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 537                          void * private_data);
 538 int v3_drill_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 539                             int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 540                             void * private_data);
 541 int v3_drill_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 542                          int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 543                          void * private_data);
 544
 545
 546
 547
 548 int v3_walk_host_pt_32(struct guest_info * info, v3_reg_t host_cr3,
 549                        int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 550                        void * private_data);
 551
 552 int v3_walk_host_pt_32pae(struct guest_info * info, v3_reg_t host_cr3,
 553                           int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 554                           void * private_data);
 555
 556 int v3_walk_host_pt_64(struct guest_info * info, v3_reg_t host_cr3,
 557                        int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 558                        void * private_data);
 559
 560 int v3_walk_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3,
 561                         int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 562                         void * private_data);
 563
 564 int v3_walk_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3,
 565                            int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 566                            void * private_data);
 567
 568 int v3_walk_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3,
 569                         int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 570                         void * private_data);
 571
 572
 573 pde32_t * create_passthrough_pts_32(struct guest_info * guest_info);
 574 pdpe32pae_t * create_passthrough_pts_32PAE(struct guest_info * guest_info);
 575 pml4e64_t * create_passthrough_pts_64(struct guest_info * info);
 576
 577
 578 void delete_page_tables_32(pde32_t * pde);
 579 void delete_page_tables_32pae(pdpe32pae_t * pdpe);
 580 void delete_page_tables_64(pml4e64_t *  pml4);
 581
 582
 583
 584 const uchar_t * v3_page_type_to_str(page_type_t type);
 585
 586
 587
 588 void PrintPTEntry(struct guest_info * info, page_type_t type, addr_t vaddr, void * entry);
 589 void PrintHostPageTables(struct guest_info * info,  addr_t cr3);
 590 void PrintGuestPageTables(struct guest_info * info, addr_t cr3);
 591 void PrintHostPageTree(struct guest_info * info, addr_t virtual_addr, addr_t cr3);
 592 void PrintGuestPageTree(struct guest_info * info, addr_t virtual_addr, addr_t cr3);
 593
 594
 595 #endif /* !__V3VEE__ */
 596
 597
 598
 599 #endif