palacios/include/palacios/vmm_paging.h

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