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_PTE32_ENTRIES          1024
  97 #define MAX_PDE32_ENTRIES          1024
  98
  99 #define MAX_PTE32PAE_ENTRIES       512
 100 #define MAX_PDE32PAE_ENTRIES       512
 101 #define MAX_PDPE32PAE_ENTRIES      4
 102
 103 #define MAX_PTE64_ENTRIES          512
 104 #define MAX_PDE64_ENTRIES          512
 105 #define MAX_PDPE64_ENTRIES         512
 106 #define MAX_PML4E64_ENTRIES        512
 107
 108
 109 /* Converts an address into a page table index */
 110 #define PDE32_INDEX(x)  ((((uint_t)x) >> 22) & 0x3ff)
 111 #define PTE32_INDEX(x)  ((((uint_t)x) >> 12) & 0x3ff)
 112
 113
 114 #define PDPE32PAE_INDEX(x) ((((uint_t)x) >> 30) & 0x3)
 115 #define PDE32PAE_INDEX(x)  ((((uint_t)x) >> 21) & 0x1ff)
 116 #define PTE32PAE_INDEX(x)  ((((uint_t)x) >> 12) & 0x1ff)
 117
 118 #define PML4E64_INDEX(x) ((((ullong_t)x) >> 39) & 0x1ff)
 119 #define PDPE64_INDEX(x) ((((ullong_t)x) >> 30) & 0x1ff)
 120 #define PDE64_INDEX(x) ((((ullong_t)x) >> 21) & 0x1ff)
 121 #define PTE64_INDEX(x) ((((ullong_t)x) >> 12) & 0x1ff)
 122
 123
 124 /* Gets the base address needed for a Page Table entry */
 125 /* Deprecate these :*/
 126 #define PD32_BASE_ADDR(x) (((uint_t)x) >> 12)
 127 #define PT32_BASE_ADDR(x) (((uint_t)x) >> 12)
 128 #define PD32_4MB_BASE_ADDR(x) (((uint_t)x) >> 22)
 129
 130 #define PML4E64_BASE_ADDR(x) (((ullong_t)x) >> 12)
 131 #define PDPE64_BASE_ADDR(x) (((ullong_t)x) >> 12)
 132 #define PDE64_BASE_ADDR(x) (((ullong_t)x) >> 12)
 133 #define PTE64_BASE_ADDR(x) (((ullong_t)x) >> 12)
 134 /* Accessor functions for the page table structures */
 135 #define PDE32_T_ADDR(x) (((x).pt_base_addr) << 12)
 136 #define PTE32_T_ADDR(x) (((x).page_base_addr) << 12)
 137 #define PDE32_4MB_T_ADDR(x) (((x).page_base_addr) << 22)
 138
 139 /* Replace The above with these... */
 140 #define PAGE_BASE_ADDR(x) (((uint_t)x) >> 12)
 141 #define LARGE_PAGE_BASE_ADDR(x) (((uint_t)x) >> 22)
 142 #define BASE_TO_PAGE_ADDR(x) (((uint_t)x) << 12)
 143 #define LARGE_BASE_TO_PAGE_ADDR(x) (((uint_t)x) << 22)
 144
 145
 146
 147 #define PT32_PAGE_ADDR(x)   (((uint_t)x) & 0xfffff000)
 148 #define PT32_PAGE_OFFSET(x) (((uint_t)x) & 0xfff)
 149 #define PT32_PAGE_POWER 12
 150
 151 #define PD32_4MB_PAGE_ADDR(x) (((uint_t)x) & 0xffc00000)
 152 #define PD32_4MB_PAGE_OFFSET(x) (((uint_t)x) & 0x003fffff)
 153 #define PAGE_SIZE_4MB (4096 * 1024)
 154
 155 /* The following should be phased out */
 156 #define PAGE_OFFSET(x)  ((((uint_t)x) & 0xfff))
 157 #define PAGE_ALIGNED_ADDR(x)   (((uint_t) (x)) >> 12)
 158 #define PAGE_ADDR(x)   (PAGE_ALIGNED_ADDR(x) << 12)
 159 #define PAGE_POWER 12
 160 #define PAGE_SIZE 4096
 161 /* ** */
 162
 163
 164
 165 #define CR3_TO_PDE32_PA(cr3) ((addr_t)(((ulong_t)cr3) & 0xfffff000))
 166 #define CR3_TO_PDPTRE_PA(cr3) ((addr_t)(((ulong_t)cr3) & 0xffffffe0))
 167 #define CR3_TO_PML4E64_PA(cr3)  ((addr_t)(((ullong_t)cr3) & 0x000ffffffffff000LL))
 168
 169 #define CR3_TO_PDE32_VA(cr3) ((pde32_t *)V3_VAddr((void *)(addr_t)(((ulong_t)cr3) & 0xfffff000)))
 170 #define CR3_TO_PDPTRE_VA(cr3) (V3_VAddr((void *)(((ulong_t)cr3) & 0xffffffe0)))
 171 #define CR3_TO_PML4E64_VA(cr3)  ((pml4e64_t *)V3_VAddr((void *)(addr_t)(((ullong_t)cr3) & 0x000ffffffffff000LL)))
 172
 173
 174
 175
 176
 177
 178 /* Page Table Flag Values */
 179 #define PT32_HOOK 0x1
 180 #define PT32_GUEST_PT 0x2
 181
 182
 183
 184
 185 /* PDE 32 bit PAGE STRUCTURES */
 186 typedef enum {PDE32_ENTRY_NOT_PRESENT, PDE32_ENTRY_PTE32, PDE32_ENTRY_LARGE_PAGE} pde32_entry_type_t;
 187 typedef enum {PT_ACCESS_OK, PT_ENTRY_NOT_PRESENT, PT_WRITE_ERROR, PT_USER_ERROR} pt_access_status_t;
 188
 189 typedef struct pde32 {
 190   uint_t present         : 1;
 191   uint_t writable        : 1;
 192   uint_t user_page       : 1;
 193   uint_t write_through   : 1;
 194   uint_t cache_disable   : 1;
 195   uint_t accessed        : 1;
 196   uint_t reserved        : 1;
 197   uint_t large_page     : 1;
 198   uint_t global_page     : 1;
 199   uint_t vmm_info        : 3;
 200   uint_t pt_base_addr    : 20;
 201 } __attribute__((packed))  pde32_t;
 202
 203 typedef struct pde32_4MB {
 204   uint_t present         : 1;
 205   uint_t writable        : 1;
 206   uint_t user_page       : 1;
 207   uint_t write_through   : 1;
 208   uint_t cache_disable   : 1;
 209   uint_t accessed        : 1;
 210   uint_t dirty           : 1;
 211   uint_t one             : 1;
 212   uint_t global_page     : 1;
 213   uint_t vmm_info        : 3;
 214   uint_t pat             : 1;
 215   uint_t rsvd            : 9;
 216   uint_t page_base_addr  : 10;
 217
 218 } __attribute__((packed))  pde32_4MB_t;
 219
 220 typedef struct pte32 {
 221   uint_t present         : 1;
 222   uint_t writable        : 1;
 223   uint_t user_page       : 1;
 224   uint_t write_through   : 1;
 225   uint_t cache_disable   : 1;
 226   uint_t accessed        : 1;
 227   uint_t dirty           : 1;
 228   uint_t pte_attr        : 1;
 229   uint_t global_page     : 1;
 230   uint_t vmm_info        : 3;
 231   uint_t page_base_addr  : 20;
 232 }  __attribute__((packed)) pte32_t;
 233 /* ***** */
 234
 235 /* 32 bit PAE PAGE STRUCTURES */
 236 typedef struct pdpe32pae {
 237   uint_t present       : 1;
 238   uint_t rsvd          : 2; // MBZ
 239   uint_t write_through : 1;
 240   uint_t cache_disable : 1;
 241   uint_t accessed      : 1;
 242   uint_t avail         : 1;
 243   uint_t rsvd2         : 2;  // MBZ
 244   uint_t vmm_info      : 3;
 245   uint_t pd_base_addr  : 24;
 246   uint_t rsvd3         : 28; // MBZ
 247 } __attribute__((packed)) pdpe32pae_t;
 248
 249
 250
 251 typedef struct pde32pae {
 252   uint_t present         : 1;
 253   uint_t writable        : 1;
 254   uint_t user_page       : 1;
 255   uint_t write_through   : 1;
 256   uint_t cache_disable   : 1;
 257   uint_t accessed        : 1;
 258   uint_t avail           : 1;
 259   uint_t large_page      : 1;
 260   uint_t global_page     : 1;
 261   uint_t vmm_info        : 3;
 262   uint_t pt_base_addr    : 24;
 263   uint_t rsvd            : 28;
 264 } __attribute__((packed)) pde32pae_t;
 265
 266 typedef struct pde32pae_4MB {
 267   uint_t present         : 1;
 268   uint_t writable        : 1;
 269   uint_t user_page       : 1;
 270   uint_t write_through   : 1;
 271   uint_t cache_disable   : 1;
 272   uint_t accessed        : 1;
 273   uint_t dirty           : 1;
 274   uint_t one             : 1;
 275   uint_t global_page     : 1;
 276   uint_t vmm_info        : 3;
 277   uint_t pat             : 1;
 278   uint_t rsvd            : 9;
 279   uint_t page_base_addr  : 14;
 280   uint_t rsvd2           : 28;
 281
 282 } __attribute__((packed)) pde32pae_4MB_t;
 283
 284 typedef struct pte32pae {
 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 dirty           : 1;
 292   uint_t pte_attr        : 1;
 293   uint_t global_page     : 1;
 294   uint_t vmm_info        : 3;
 295   uint_t page_base_addr  : 24;
 296   uint_t rsvd            : 28;
 297 } __attribute__((packed)) pte32pae_t;
 298
 299
 300
 301
 302
 303 /* ********** */
 304
 305
 306 /* LONG MODE 64 bit PAGE STRUCTURES */
 307 typedef struct pml4e64 {
 308   uint_t present        : 1;
 309   uint_t writable       : 1;
 310   uint_t user_page           : 1;
 311   uint_t write_through  : 1;
 312   uint_t cache_disable  : 1;
 313   uint_t accessed       : 1;
 314   uint_t reserved       : 1;
 315   uint_t zero           : 2;
 316   uint_t vmm_info       : 3;
 317   ullong_t pdp_base_addr : 40;
 318   uint_t available      : 11;
 319   uint_t no_execute     : 1;
 320 } __attribute__((packed)) pml4e64_t;
 321
 322
 323 typedef struct pdpe64 {
 324   uint_t present        : 1;
 325   uint_t writable       : 1;
 326   uint_t user_page           : 1;
 327   uint_t write_through  : 1;
 328   uint_t cache_disable  : 1;
 329   uint_t accessed       : 1;
 330   uint_t reserved       : 1;
 331   uint_t large_page    : 1;
 332   uint_t zero           : 1;
 333   uint_t vmm_info       : 3;
 334   ullong_t pd_base_addr : 40;
 335   uint_t available      : 11;
 336   uint_t no_execute     : 1;
 337 } __attribute__((packed)) pdpe64_t;
 338
 339
 340
 341
 342 typedef struct pde64 {
 343   uint_t present         : 1;
 344   uint_t writable        : 1;
 345   uint_t user_page       : 1;
 346   uint_t write_through   : 1;
 347   uint_t cache_disable   : 1;
 348   uint_t accessed        : 1;
 349   uint_t reserved        : 1;
 350   uint_t large_page     : 1;
 351   uint_t reserved2       : 1;
 352   uint_t vmm_info        : 3;
 353   ullong_t pt_base_addr  : 40;
 354   uint_t available       : 11;
 355   uint_t no_execute      : 1;
 356 } __attribute__((packed)) pde64_t;
 357
 358 typedef struct pte64 {
 359   uint_t present         : 1;
 360   uint_t writable        : 1;
 361   uint_t user_page       : 1;
 362   uint_t write_through   : 1;
 363   uint_t cache_disable   : 1;
 364   uint_t accessed        : 1;
 365   uint_t dirty           : 1;
 366   uint_t pte_attr        : 1;
 367   uint_t global_page     : 1;
 368   uint_t vmm_info        : 3;
 369   ullong_t page_base_addr : 40;
 370   uint_t available       : 11;
 371   uint_t no_execute      : 1;
 372 } __attribute__((packed)) pte64_t;
 373
 374 /* *************** */
 375
 376 typedef struct pf_error_code {
 377   uint_t present           : 1; // if 0, fault due to page not present
 378   uint_t write             : 1; // if 1, faulting access was a write
 379   uint_t user              : 1; // if 1, faulting access was in user mode
 380   uint_t rsvd_access       : 1; // if 1, fault from reading a 1 from a reserved field (?)
 381   uint_t ifetch            : 1; // if 1, faulting access was an instr fetch (only with NX)
 382   uint_t rsvd              : 27;
 383 } __attribute__((packed)) pf_error_t;
 384
 385
 386
 387
 388 void delete_page_tables_32(pde32_t * pde);
 389 void delete_page_tables_32PAE(pdpe32pae_t * pdpe);
 390 void delete_page_tables_64(pml4e64_t *  pml4);
 391
 392 pde32_entry_type_t pde32_lookup(pde32_t * pd, addr_t addr, addr_t * entry);
 393 int pte32_lookup(pte32_t * pte, addr_t addr, addr_t * entry);
 394
 395 // This assumes that the page table resides in the host address space
 396 // IE. IT DOES NO VM ADDR TRANSLATION
 397 int pt32_lookup(pde32_t * pd, addr_t vaddr, addr_t * paddr);
 398
 399
 400
 401 pt_access_status_t can_access_pde32(pde32_t * pde, addr_t addr, pf_error_t access_type);
 402 pt_access_status_t can_access_pte32(pte32_t * pte, addr_t addr, pf_error_t access_type);
 403
 404
 405
 406
 407
 408 struct guest_info;
 409
 410 pde32_t * create_passthrough_pts_32(struct guest_info * guest_info);
 411 pdpe32pae_t * create_passthrough_pts_32PAE(struct guest_info * guest_info);
 412 pml4e64_t * create_passthrough_pts_64(struct guest_info * info);
 413
 414
 415
 416
 417 //#include <palacios/vm_guest.h>
 418
 419 void PrintDebugPageTables(pde32_t * pde);
 420
 421
 422 void PrintPageTree(v3_vm_cpu_mode_t cpu_mode, addr_t virtual_addr, addr_t cr3);
 423 void PrintPageTree_64(addr_t virtual_addr, pml4e64_t * pml);
 424
 425
 426 void PrintPT32(addr_t starting_address, pte32_t * pte);
 427 void PrintPD32(pde32_t * pde);
 428 void PrintPTE32(addr_t virtual_address, pte32_t * pte);
 429 void PrintPDE32(addr_t virtual_address, pde32_t * pde);
 430
 431 void PrintDebugPageTables32PAE(pdpe32pae_t * pde);
 432 void PrintPTE32PAE(addr_t virtual_address, pte32pae_t * pte);
 433 void PrintPDE32PAE(addr_t virtual_address, pde32pae_t * pde);
 434 void PrintPTE64(addr_t virtual_address, pte64_t * pte);
 435
 436 #endif // !__V3VEE__
 437
 438
 439
 440 #endif