palacios/include/palacios/vmm_paging.h

   1 /* (c) 2008, Jack Lange <jarusl@cs.northwestern.edu> */
   2 /* (c) 2008, The V3VEE Project <http://www.v3vee.org> */
   3
   4 #ifndef __VMM_PAGING_H
   5 #define __VMM_PAGING_H
   6
   7
   8 #ifdef __V3VEE__
   9
  10 #include <palacios/vmm_types.h>
  11 #include <palacios/vmm_util.h>
  12
  13 /*
  14
  15 In the following, when we say "page table", we mean the whole 2 or 4 layer
  16 page table (PDEs, PTEs), etc.
  17
  18
  19 guest-visible paging state
  20  This is the state that the guest thinks the machine is using
  21  It consists of
  22    - guest physical memory
  23        The physical memory addresses the guest is allowed to use
  24        (see shadow page maps, below)
  25    - guest page tables
  26        (we care about when the current one changes)
  27    - guest paging registers (these are never written to hardware)
  28         CR0
  29         CR3
  30
  31
  32 shadow paging state
  33  This the state that the machine will actually use when the guest
  34  is running.  It consists of:
  35    - current shadow page table
  36         This is the page table actually useed when the guest is running.
  37         It is changed/regenerated when the guest page table changes
  38         It mostly reflects the guest page table, except that it restricts
  39         physical addresses to those the VMM allocates to the guest.
  40    - shadow page maps
  41         This is a mapping from guest physical memory addresses to
  42         the current location of the guest physical memory content.
  43         It maps from regions of physical memory addresses to regions
  44         located in physical memory or elsewhere.
  45         (8192,16384) -> MEM(8912,...)
  46         (0,8191) -> DISK(65536,..)
  47    - guest paging registers (these are written to guest state)
  48         CR0
  49         CR3
  50
  51 host paging state
  52   This is the state we expect to be operative when the VMM is running.
  53   Typically, this is set up by the host os into which we have embedded
  54   the VMM, but we include the description here for clarity.
  55     - current page table
  56         This is the page table we use when we are executing in
  57         the VMM (or the host os)
  58     - paging regisers
  59         CR0
  60         CR3
  61
  62
  63 The reason why the shadow paging state and the host paging state are
  64 distinct is to permit the guest to use any virtual address it wants,
  65 irrespective of the addresses the VMM or the host os use.  These guest
  66 virtual addresses are reflected in the shadow paging state.  When we
  67 exit from the guest, we switch to the host paging state so that any
  68 virtual addresses that overlap between the guest and VMM/host now map
  69 to the physical addresses epxected by the VMM/host.  On AMD SVM, this
  70 switch is done by the hardware.  On Intel VT, the switch is done
  71 by the hardware as well, but we are responsible for manually updating
  72 the host state in the vmcs before entering the guest.
  73 */
  74
  75
  76
  77
  78 #define MAX_PTE32_ENTRIES          1024
  79 #define MAX_PDE32_ENTRIES          1024
  80
  81 #define MAX_PTE64_ENTRIES          512
  82 #define MAX_PDE64_ENTRIES          512
  83 #define MAX_PDPE64_ENTRIES         512
  84 #define MAX_PML4E64_ENTRIES        512
  85
  86
  87 /* Converts an address into a page table index */
  88 #define PDE32_INDEX(x)  ((((uint_t)x) >> 22) & 0x3ff)
  89 #define PTE32_INDEX(x)  ((((uint_t)x) >> 12) & 0x3ff)
  90
  91 /* Gets the base address needed for a Page Table entry */
  92 #define PD32_BASE_ADDR(x) (((uint_t)x) >> 12)
  93 #define PT32_BASE_ADDR(x) (((uint_t)x) >> 12)
  94 #define PD32_4MB_BASE_ADDR(x) (((uint_t)x) >> 22)
  95
  96 #define PT32_PAGE_ADDR(x)   (((uint_t)x) & 0xfffff000)
  97 #define PT32_PAGE_OFFSET(x) (((uint_t)x) & 0xfff)
  98 #define PT32_PAGE_POWER 12
  99
 100 #define PD32_4MB_PAGE_ADDR(x) (((uint_t)x) & 0xffc00000)
 101 #define PD32_4MB_PAGE_OFFSET(x) (((uint_t)x) & 0x003fffff)
 102 #define PAGE_SIZE_4MB (4096 * 1024)
 103
 104 /* The following should be phased out */
 105 #define PAGE_OFFSET(x)  ((((uint_t)x) & 0xfff))
 106 #define PAGE_ALIGNED_ADDR(x)   (((uint_t) (x)) >> 12)
 107 #define PAGE_ADDR(x)   (PAGE_ALIGNED_ADDR(x) << 12)
 108 #define PAGE_POWER 12
 109 #define PAGE_SIZE 4096
 110 /* ** */
 111
 112
 113
 114
 115 #define CR3_TO_PDE32(cr3) (((ulong_t)cr3) & 0xfffff000)
 116 #define CR3_TO_PDPTRE(cr3) (((ulong_t)cr3) & 0xffffffe0)
 117 #define CR3_TO_PML4E64(cr3)  (((ullong_t)cr3) & 0x000ffffffffff000LL)
 118
 119
 120
 121
 122 /* Accessor functions for the page table structures */
 123 #define PDE32_T_ADDR(x) (((x).pt_base_addr) << 12)
 124 #define PTE32_T_ADDR(x) (((x).page_base_addr) << 12)
 125 #define PDE32_4MB_T_ADDR(x) (((x).page_base_addr) << 22)
 126
 127 /* Page Table Flag Values */
 128 #define PT32_HOOK 0x1
 129 #define PT32_GUEST_PT 0x2
 130
 131
 132 #endif
 133
 134 /* PDE 32 bit PAGE STRUCTURES */
 135 typedef enum {PDE32_ENTRY_NOT_PRESENT, PDE32_ENTRY_PTE32, PDE32_ENTRY_LARGE_PAGE} pde32_entry_type_t;
 136 typedef enum {PT_ACCESS_OK, PT_ENTRY_NOT_PRESENT, PT_WRITE_ERROR, PT_USER_ERROR} pt_access_status_t;
 137
 138 typedef struct pde32 {
 139   uint_t present         : 1;
 140   uint_t writable        : 1;
 141   uint_t user_page       : 1;
 142   uint_t write_through   : 1;
 143   uint_t cache_disable   : 1;
 144   uint_t accessed        : 1;
 145   uint_t reserved        : 1;
 146   uint_t large_page     : 1;
 147   uint_t global_page     : 1;
 148   uint_t vmm_info        : 3;
 149   uint_t pt_base_addr    : 20;
 150 } pde32_t;
 151
 152 typedef struct pde32_4MB {
 153   uint_t present         : 1;
 154   uint_t writable        : 1;
 155   uint_t user_page       : 1;
 156   uint_t write_through   : 1;
 157   uint_t cache_disable   : 1;
 158   uint_t accessed        : 1;
 159   uint_t dirty           : 1;
 160   uint_t one             : 1;
 161   uint_t global_page     : 1;
 162   uint_t vmm_info        : 3;
 163   uint_t pat             : 1;
 164   uint_t rsvd            : 9;
 165   uint_t page_base_addr  : 10;
 166
 167 } pde32_4MB_t;
 168
 169 typedef struct pte32 {
 170   uint_t present         : 1;
 171   uint_t writable        : 1;
 172   uint_t user_page       : 1;
 173   uint_t write_through   : 1;
 174   uint_t cache_disable   : 1;
 175   uint_t accessed        : 1;
 176   uint_t dirty           : 1;
 177   uint_t pte_attr        : 1;
 178   uint_t global_page     : 1;
 179   uint_t vmm_info        : 3;
 180   uint_t page_base_addr  : 20;
 181 } pte32_t;
 182 /* ***** */
 183
 184 /* 32 bit PAE PAGE STRUCTURES */
 185
 186 //
 187 // Fill in
 188 //
 189
 190 /* ********** */
 191
 192
 193 /* LONG MODE 64 bit PAGE STRUCTURES */
 194 typedef struct pml4e64 {
 195   uint_t present        : 1;
 196   uint_t writable       : 1;
 197   uint_t user           : 1;
 198   uint_t pwt            : 1;
 199   uint_t pcd            : 1;
 200   uint_t accessed       : 1;
 201   uint_t reserved       : 1;
 202   uint_t zero           : 2;
 203   uint_t vmm_info       : 3;
 204   uint_t pdp_base_addr_lo : 20;
 205   uint_t pdp_base_addr_hi : 20;
 206   uint_t available      : 11;
 207   uint_t no_execute     : 1;
 208 } pml4e64_t;
 209
 210
 211 typedef struct pdpe64 {
 212   uint_t present        : 1;
 213   uint_t writable       : 1;
 214   uint_t user           : 1;
 215   uint_t pwt            : 1;
 216   uint_t pcd            : 1;
 217   uint_t accessed       : 1;
 218   uint_t reserved       : 1;
 219   uint_t large_pages    : 1;
 220   uint_t zero           : 1;
 221   uint_t vmm_info       : 3;
 222   uint_t pd_base_addr_lo : 20;
 223   uint_t pd_base_addr_hi : 20;
 224   uint_t available      : 11;
 225   uint_t no_execute     : 1;
 226 } pdpe64_t;
 227
 228
 229
 230
 231 typedef struct pde64 {
 232   uint_t present         : 1;
 233   uint_t flags           : 4;
 234   uint_t accessed        : 1;
 235   uint_t reserved        : 1;
 236   uint_t large_pages     : 1;
 237   uint_t reserved2       : 1;
 238   uint_t vmm_info        : 3;
 239   uint_t pt_base_addr_lo    : 20;
 240   uint_t pt_base_addr_hi : 20;
 241   uint_t available       : 11;
 242   uint_t no_execute      : 1;
 243 } pde64_t;
 244
 245 typedef struct pte64 {
 246   uint_t present         : 1;
 247   uint_t flags           : 4;
 248   uint_t accessed        : 1;
 249   uint_t dirty           : 1;
 250   uint_t pte_attr        : 1;
 251   uint_t global_page     : 1;
 252   uint_t vmm_info        : 3;
 253   uint_t page_base_addr_lo  : 20;
 254   uint_t page_base_addr_hi : 20;
 255   uint_t available       : 11;
 256   uint_t no_execute      : 1;
 257 } pte64_t;
 258
 259 /* *************** */
 260
 261 typedef struct pf_error_code {
 262   uint_t present           : 1; // if 0, fault due to page not present
 263   uint_t write             : 1; // if 1, faulting access was a write
 264   uint_t user              : 1; // if 1, faulting access was in user mode
 265   uint_t rsvd_access       : 1; // if 1, fault from reading a 1 from a reserved field (?)
 266   uint_t ifetch            : 1; // if 1, faulting access was an instr fetch (only with NX)
 267   uint_t rsvd              : 27;
 268 } pf_error_t;
 269
 270 typedef enum { PDE32 } paging_mode_t;
 271
 272
 273
 274
 275 void delete_page_tables_pde32(pde32_t * pde);
 276
 277
 278 pde32_entry_type_t pde32_lookup(pde32_t * pd, addr_t addr, addr_t * entry);
 279 int pte32_lookup(pte32_t * pte, addr_t addr, addr_t * entry);
 280
 281 // This assumes that the page table resides in the host address space
 282 // IE. IT DOES NO VM ADDR TRANSLATION
 283 int pt32_lookup(pde32_t * pd, addr_t vaddr, addr_t * paddr);
 284
 285
 286
 287 pt_access_status_t can_access_pde32(pde32_t * pde, addr_t addr, pf_error_t access_type);
 288 pt_access_status_t can_access_pte32(pte32_t * pte, addr_t addr, pf_error_t access_type);
 289
 290
 291
 292
 293
 294 struct guest_info;
 295
 296 pde32_t * create_passthrough_pde32_pts(struct guest_info * guest_info);
 297
 298
 299
 300
 301
 302
 303 void PrintDebugPageTables(pde32_t * pde);
 304
 305
 306 #ifdef __V3VEE__
 307
 308
 309 void PrintPT32(addr_t starting_address, pte32_t * pte);
 310 void PrintPD32(pde32_t * pde);
 311 void PrintPTE32(addr_t virtual_address, pte32_t * pte);
 312 void PrintPDE32(addr_t virtual_address, pde32_t * pde);
 313
 314 #endif // !__V3VEE__
 315
 316
 317
 318 #endif