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 /* We'll use the general form for now....
 190    typedef enum {PDE32_ENTRY_NOT_PRESENT, PDE32_ENTRY_PTE32, PDE32_ENTRY_LARGE_PAGE} pde32_entry_type_t;
 191    typedef enum {PTE32_ENTRY_NOT_PRESENT, PTE32_ENTRY_PAGE} pte32_entry_type_t;
 192
 193    typedef enum {PDPE32PAE_ENTRY_NOT_PRESENT, PDPE32PAE_ENTRY_PAGE} pdpe32pae_entry_type_t;
 194    typedef enum {PDE32PAE_ENTRY_NOT_PRESENT, PDE32PAE_ENTRY_PTE32, PDE32PAE_ENTRY_LARGE_PAGE} pde32pae_entry_type_t;
 195    typedef enum {PTE32PAE_ENTRY_NOT_PRESENT, PTE32PAE_ENTRY_PAGE} pte32pae_entry_type_t;
 196
 197    typedef enum {PML4E64_ENTRY_NOT_PRESENT, PML4E64_ENTRY_PAGE} pml4e64_entry_type_t;
 198    typedef enum {PDPE64_ENTRY_NOT_PRESENT, PDPE64_ENTRY_PTE32, PDPE64_ENTRY_LARGE_PAGE} pdpe64_entry_type_t;
 199    typedef enum {PDE64_ENTRY_NOT_PRESENT, PDE64_ENTRY_PTE32, PDE64_ENTRY_LARGE_PAGE} pde64_entry_type_t;
 200    typedef enum {PTE64_ENTRY_NOT_PRESENT, PTE64_ENTRY_PAGE} pte64_entry_type_t;
 201 */
 202
 203
 204 typedef enum {PT_ENTRY_NOT_PRESENT, PT_ENTRY_LARGE_PAGE, PT_ENTRY_PAGE} pt_entry_type_t;
 205
 206 typedef enum {PT_ACCESS_OK, PT_ACCESS_NOT_PRESENT, PT_ACCESS_WRITE_ERROR, PT_ACCESS_USER_ERROR} pt_access_status_t;
 207
 208
 209 typedef struct gen_pt {
 210     uint_t present        : 1;
 211     uint_t writable       : 1;
 212     uint_t user_page      : 1;
 213 } __attribute__((packed)) gen_pt_t;
 214
 215 typedef struct pde32 {
 216     uint_t present         : 1;
 217     uint_t writable        : 1;
 218     uint_t user_page       : 1;
 219     uint_t write_through   : 1;
 220     uint_t cache_disable   : 1;
 221     uint_t accessed        : 1;
 222     uint_t reserved        : 1;
 223     uint_t large_page     : 1;
 224     uint_t global_page     : 1;
 225     uint_t vmm_info        : 3;
 226     uint_t pt_base_addr    : 20;
 227 } __attribute__((packed))  pde32_t;
 228
 229 typedef struct pde32_4MB {
 230     uint_t present         : 1;
 231     uint_t writable        : 1;
 232     uint_t user_page       : 1;
 233     uint_t write_through   : 1;
 234     uint_t cache_disable   : 1;
 235     uint_t accessed        : 1;
 236     uint_t dirty           : 1;
 237     uint_t large_page      : 1;
 238     uint_t global_page     : 1;
 239     uint_t vmm_info        : 3;
 240     uint_t pat             : 1;
 241     uint_t rsvd            : 9;
 242     uint_t page_base_addr  : 10;
 243
 244 } __attribute__((packed))  pde32_4MB_t;
 245
 246 typedef struct pte32 {
 247     uint_t present         : 1;
 248     uint_t writable        : 1;
 249     uint_t user_page       : 1;
 250     uint_t write_through   : 1;
 251     uint_t cache_disable   : 1;
 252     uint_t accessed        : 1;
 253     uint_t dirty           : 1;
 254     uint_t pte_attr        : 1;
 255     uint_t global_page     : 1;
 256     uint_t vmm_info        : 3;
 257     uint_t page_base_addr  : 20;
 258 }  __attribute__((packed)) pte32_t;
 259 /* ***** */
 260
 261 /* 32 bit PAE PAGE STRUCTURES */
 262 typedef struct pdpe32pae {
 263     uint_t present       : 1;
 264     uint_t rsvd          : 2; // MBZ
 265     uint_t write_through : 1;
 266     uint_t cache_disable : 1;
 267     uint_t accessed      : 1;
 268     uint_t avail         : 1;
 269     uint_t rsvd2         : 2;  // MBZ
 270     uint_t vmm_info      : 3;
 271     uint_t pd_base_addr  : 24;
 272     uint_t rsvd3         : 28; // MBZ
 273 } __attribute__((packed)) pdpe32pae_t;
 274
 275
 276
 277 typedef struct pde32pae {
 278     uint_t present         : 1;
 279     uint_t writable        : 1;
 280     uint_t user_page       : 1;
 281     uint_t write_through   : 1;
 282     uint_t cache_disable   : 1;
 283     uint_t accessed        : 1;
 284     uint_t avail           : 1;
 285     uint_t large_page      : 1;
 286     uint_t global_page     : 1;
 287     uint_t vmm_info        : 3;
 288     uint_t pt_base_addr    : 24;
 289     uint_t rsvd            : 28;
 290 } __attribute__((packed)) pde32pae_t;
 291
 292 typedef struct pde32pae_2MB {
 293     uint_t present         : 1;
 294     uint_t writable        : 1;
 295     uint_t user_page       : 1;
 296     uint_t write_through   : 1;
 297     uint_t cache_disable   : 1;
 298     uint_t accessed        : 1;
 299     uint_t dirty           : 1;
 300     uint_t one             : 1;
 301     uint_t global_page     : 1;
 302     uint_t vmm_info        : 3;
 303     uint_t pat             : 1;
 304     uint_t rsvd            : 8;
 305     uint_t page_base_addr  : 15;
 306     uint_t rsvd2           : 28;
 307
 308 } __attribute__((packed)) pde32pae_2MB_t;
 309
 310 typedef struct pte32pae {
 311     uint_t present         : 1;
 312     uint_t writable        : 1;
 313     uint_t user_page       : 1;
 314     uint_t write_through   : 1;
 315     uint_t cache_disable   : 1;
 316     uint_t accessed        : 1;
 317     uint_t dirty           : 1;
 318     uint_t pte_attr        : 1;
 319     uint_t global_page     : 1;
 320     uint_t vmm_info        : 3;
 321     uint_t page_base_addr  : 24;
 322     uint_t rsvd            : 28;
 323 } __attribute__((packed)) pte32pae_t;
 324
 325
 326
 327
 328
 329 /* ********** */
 330
 331
 332 /* LONG MODE 64 bit PAGE STRUCTURES */
 333 typedef struct pml4e64 {
 334     uint_t present        : 1;
 335     uint_t writable       : 1;
 336     uint_t user_page           : 1;
 337     uint_t write_through  : 1;
 338     uint_t cache_disable  : 1;
 339     uint_t accessed       : 1;
 340     uint_t reserved       : 1;
 341     uint_t zero           : 2;
 342     uint_t vmm_info       : 3;
 343     ullong_t pdp_base_addr : 40;
 344     uint_t available      : 11;
 345     uint_t no_execute     : 1;
 346 } __attribute__((packed)) pml4e64_t;
 347
 348
 349 typedef struct pdpe64 {
 350     uint_t present        : 1;
 351     uint_t writable       : 1;
 352     uint_t user_page      : 1;
 353     uint_t write_through  : 1;
 354     uint_t cache_disable  : 1;
 355     uint_t accessed       : 1;
 356     uint_t avail          : 1;
 357     uint_t large_page     : 1;
 358     uint_t zero           : 1;
 359     uint_t vmm_info       : 3;
 360     ullong_t pd_base_addr : 40;
 361     uint_t available      : 11;
 362     uint_t no_execute     : 1;
 363 } __attribute__((packed)) pdpe64_t;
 364
 365
 366 // We Don't support this
 367 typedef struct pdpe64_1GB {
 368     uint_t present        : 1;
 369     uint_t writable       : 1;
 370     uint_t user_page      : 1;
 371     uint_t write_through  : 1;
 372     uint_t cache_disable  : 1;
 373     uint_t accessed       : 1;
 374     uint_t dirty          : 1;
 375     uint_t large_page     : 1;
 376     uint_t global_page    : 1;
 377     uint_t vmm_info       : 3;
 378     uint_t pat            : 1;
 379     uint_t rsvd           : 17;
 380     ullong_t page_base_addr : 22;
 381     uint_t available      : 11;
 382     uint_t no_execute     : 1;
 383 } __attribute__((packed)) pdpe64_1GB_t;
 384
 385
 386
 387 typedef struct pde64 {
 388     uint_t present         : 1;
 389     uint_t writable        : 1;
 390     uint_t user_page       : 1;
 391     uint_t write_through   : 1;
 392     uint_t cache_disable   : 1;
 393     uint_t accessed        : 1;
 394     uint_t avail           : 1;
 395     uint_t large_page      : 1;
 396     uint_t global_page     : 1;
 397     uint_t vmm_info        : 3;
 398     ullong_t pt_base_addr  : 40;
 399     uint_t available       : 11;
 400     uint_t no_execute      : 1;
 401 } __attribute__((packed)) pde64_t;
 402
 403 typedef struct pde64_2MB {
 404     uint_t present         : 1;
 405     uint_t writable        : 1;
 406     uint_t user_page       : 1;
 407     uint_t write_through   : 1;
 408     uint_t cache_disable   : 1;
 409     uint_t accessed        : 1;
 410     uint_t dirty           : 1;
 411     uint_t large_page      : 1;
 412     uint_t global_page     : 1;
 413     uint_t vmm_info        : 3;
 414     uint_t pat             : 1;
 415     uint_t rsvd            : 8;
 416     ullong_t page_base_addr  : 31;
 417     uint_t available       : 11;
 418     uint_t no_execute      : 1;
 419 } __attribute__((packed)) pde64_2MB_t;
 420
 421
 422 typedef struct pte64 {
 423     uint_t present         : 1;
 424     uint_t writable        : 1;
 425     uint_t user_page       : 1;
 426     uint_t write_through   : 1;
 427     uint_t cache_disable   : 1;
 428     uint_t accessed        : 1;
 429     uint_t dirty           : 1;
 430     uint_t pte_attr        : 1;
 431     uint_t global_page     : 1;
 432     uint_t vmm_info        : 3;
 433     ullong_t page_base_addr : 40;
 434     uint_t available       : 11;
 435     uint_t no_execute      : 1;
 436 } __attribute__((packed)) pte64_t;
 437
 438 /* *************** */
 439
 440 typedef struct pf_error_code {
 441     uint_t present           : 1; // if 0, fault due to page not present
 442     uint_t write             : 1; // if 1, faulting access was a write
 443     uint_t user              : 1; // if 1, faulting access was in user mode
 444     uint_t rsvd_access       : 1; // if 1, fault from reading a 1 from a reserved field (?)
 445     uint_t ifetch            : 1; // if 1, faulting access was an instr fetch (only with NX)
 446     uint_t rsvd              : 27;
 447 } __attribute__((packed)) pf_error_t;
 448
 449
 450
 451
 452
 453 struct guest_info;
 454
 455 int v3_translate_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr);
 456 int v3_translate_guest_pt_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr);
 457 int v3_translate_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr, addr_t * paddr);
 458
 459 int v3_translate_host_pt_32(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 460 int v3_translate_host_pt_32pae(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 461 int v3_translate_host_pt_64(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr, addr_t * paddr);
 462
 463
 464 int v3_find_host_pt_32_page(struct guest_info * info, v3_reg_t host_cr3, page_type_t type, addr_t vaddr,
 465                             addr_t * page_ptr, addr_t * page_pa);
 466 int v3_find_host_pt_32pae_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_64_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_guest_pt_32_page(struct guest_info * info, v3_reg_t guest_cr3,
 471                              page_type_t type, addr_t vaddr,
 472                              addr_t * page_ptr, addr_t * page_pa);
 473 int v3_find_guest_pt_32pae_page(struct guest_info * info, v3_reg_t guest_cr3,
 474                                 page_type_t type, addr_t vaddr,
 475                                 addr_t * page_ptr, addr_t * page_pa);
 476 int v3_find_guest_pt_64_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
 480
 481
 482 pt_access_status_t inline v3_can_access_pde32(pde32_t * pde, addr_t addr, pf_error_t access_type);
 483 pt_access_status_t inline v3_can_access_pte32(pte32_t * pte, addr_t addr, pf_error_t access_type);
 484
 485 pt_access_status_t inline v3_can_access_pdpe32pae(pdpe32pae_t * pdpe, addr_t addr, pf_error_t access_type);
 486 pt_access_status_t inline v3_can_access_pde32pae(pde32pae_t * pde, addr_t addr, pf_error_t access_type);
 487 pt_access_status_t inline v3_can_access_pte32pae(pte32pae_t * pte, addr_t addr, pf_error_t access_type);
 488
 489 pt_access_status_t inline v3_can_access_pml4e64(pml4e64_t * pmle, addr_t addr, pf_error_t access_type);
 490 pt_access_status_t inline v3_can_access_pdpe64(pdpe64_t * pdpe, addr_t addr, pf_error_t access_type);
 491 pt_access_status_t inline v3_can_access_pde64(pde64_t * pde, addr_t addr, pf_error_t access_type);
 492 pt_access_status_t inline v3_can_access_pte64(pte64_t * pte, addr_t addr, pf_error_t access_type);
 493
 494
 495 int v3_check_host_pt_32(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr,
 496                         pf_error_t access_type, pt_access_status_t * access_status);
 497 int v3_check_host_pt_32pae(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_64(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_guest_pt_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 502                          pf_error_t access_type, pt_access_status_t * access_status);
 503 int v3_check_guest_pt_32pae(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_64(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
 508
 509
 510 page_type_t v3_get_guest_data_page_type_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 511 page_type_t v3_get_guest_data_page_type_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 512 page_type_t v3_get_guest_data_page_type_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 513 page_type_t v3_get_host_data_page_type_32(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 514 page_type_t v3_get_host_data_page_type_32pae(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 515 page_type_t v3_get_host_data_page_type_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr);
 516
 517
 518 int v3_drill_host_pt_32(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_32pae(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 int v3_drill_host_pt_64(struct guest_info * info, v3_reg_t host_cr3, addr_t vaddr,
 525                         int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 526                         void * private_data);
 527
 528 int v3_drill_guest_pt_32(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_32pae(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 int v3_drill_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3, addr_t vaddr,
 535                          int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_ptr, addr_t page_pa, void * private_data),
 536                          void * private_data);
 537
 538
 539
 540
 541 int v3_walk_host_pt_32(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_32pae(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_host_pt_64(struct guest_info * info, v3_reg_t host_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_32(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_32pae(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 int v3_walk_guest_pt_64(struct guest_info * info, v3_reg_t guest_cr3,
 562                         int (*callback)(struct guest_info * info, page_type_t type, addr_t vaddr, addr_t page_va, addr_t page_pa, void * private_data),
 563                         void * private_data);
 564
 565
 566 pde32_t * create_passthrough_pts_32(struct guest_info * guest_info);
 567 pdpe32pae_t * create_passthrough_pts_32PAE(struct guest_info * guest_info);
 568 pml4e64_t * create_passthrough_pts_64(struct guest_info * info);
 569
 570
 571 void delete_page_tables_32(pde32_t * pde);
 572 void delete_page_tables_32pae(pdpe32pae_t * pdpe);
 573 void delete_page_tables_64(pml4e64_t *  pml4);
 574
 575
 576
 577 const uchar_t * v3_page_type_to_str(page_type_t type);
 578
 579
 580
 581 void PrintPTEntry(struct guest_info * info, page_type_t type, addr_t vaddr, void * entry);
 582 void PrintHostPageTables(struct guest_info * info,  addr_t cr3);
 583 void PrintGuestPageTables(struct guest_info * info, addr_t cr3);
 584 void PrintHostPageTree(struct guest_info * info, addr_t virtual_addr, addr_t cr3);
 585 void PrintGuestPageTree(struct guest_info * info, addr_t virtual_addr, addr_t cr3);
 586
 587
 588 #endif // !__V3VEE__
 589
 590
 591
 592 #endif