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
  76
  77
  78
  79 #define MAX_PTE32_ENTRIES          1024
  80 #define MAX_PDE32_ENTRIES          1024
  81
  82 #define MAX_PTE64_ENTRIES          512
  83 #define MAX_PDE64_ENTRIES          512
  84 #define MAX_PDPE64_ENTRIES         512
  85 #define MAX_PML4E64_ENTRIES        512
  86
  87 #define PDE32_INDEX(x)  ((((uint_t)x) >> 22) & 0x3ff)
  88 #define PTE32_INDEX(x)  ((((uint_t)x) >> 12) & 0x3ff)
  89
  90
  91 #define PAGE_ALIGNED_ADDR(x)   (((uint_t) (x)) >> 12)
  92
  93 #ifndef PAGE_ADDR
  94 #define PAGE_ADDR(x)   (PAGE_ALIGNED_ADDR(x) << 12)
  95 #endif
  96 #define PAGE_OFFSET(x)  ((((uint_t)x) & 0xfff))
  97
  98
  99 #define PAGE_POWER 12
 100
 101 #define CR3_TO_PDE32(cr3) (((ulong_t)cr3) & 0xfffff000)
 102 #define CR3_TO_PDPTRE(cr3) (((ulong_t)cr3) & 0xffffffe0)
 103 #define CR3_TO_PML4E64(cr3)  (((ullong_t)cr3) & 0x000ffffffffff000)
 104
 105 #define VM_WRITE     1
 106 #define VM_USER      2
 107 #define VM_NOCACHE   8
 108 #define VM_READ      0
 109 #define VM_EXEC      0
 110
 111
 112 /* PDE 32 bit PAGE STRUCTURES */
 113 typedef enum {NOT_PRESENT, PTE32, LARGE_PAGE} pde32_entry_type_t;
 114
 115 typedef struct pde32 {
 116   uint_t present         : 1;
 117   uint_t flags           : 4;
 118   uint_t accessed        : 1;
 119   uint_t reserved        : 1;
 120   uint_t large_pages     : 1;
 121   uint_t global_page     : 1;
 122   uint_t vmm_info        : 3;
 123   uint_t pt_base_addr    : 20;
 124 } pde32_t;
 125
 126 typedef struct pte32 {
 127   uint_t present         : 1;
 128   uint_t flags           : 4;
 129   uint_t accessed        : 1;
 130   uint_t dirty           : 1;
 131   uint_t pte_attr        : 1;
 132   uint_t global_page     : 1;
 133   uint_t vmm_info        : 3;
 134   uint_t page_base_addr  : 20;
 135 } pte32_t;
 136 /* ***** */
 137
 138 /* 32 bit PAE PAGE STRUCTURES */
 139
 140 //
 141 // Fill in
 142 //
 143
 144 /* ********** */
 145
 146
 147 /* LONG MODE 64 bit PAGE STRUCTURES */
 148 typedef struct pml4e64 {
 149   uint_t present        : 1;
 150   uint_t writable       : 1;
 151   uint_t user           : 1;
 152   uint_t pwt            : 1;
 153   uint_t pcd            : 1;
 154   uint_t accessed       : 1;
 155   uint_t reserved       : 1;
 156   uint_t zero           : 2;
 157   uint_t vmm_info       : 3;
 158   uint_t pdp_base_addr_lo : 20;
 159   uint_t pdp_base_addr_hi : 20;
 160   uint_t available      : 11;
 161   uint_t no_execute     : 1;
 162 } pml4e64_t;
 163
 164
 165 typedef struct pdpe64 {
 166   uint_t present        : 1;
 167   uint_t writable       : 1;
 168   uint_t user           : 1;
 169   uint_t pwt            : 1;
 170   uint_t pcd            : 1;
 171   uint_t accessed       : 1;
 172   uint_t reserved       : 1;
 173   uint_t large_pages    : 1;
 174   uint_t zero           : 1;
 175   uint_t vmm_info       : 3;
 176   uint_t pd_base_addr_lo : 20;
 177   uint_t pd_base_addr_hi : 20;
 178   uint_t available      : 11;
 179   uint_t no_execute     : 1;
 180 } pdpe64_t;
 181
 182
 183
 184
 185 typedef struct pde64 {
 186   uint_t present         : 1;
 187   uint_t flags           : 4;
 188   uint_t accessed        : 1;
 189   uint_t reserved        : 1;
 190   uint_t large_pages     : 1;
 191   uint_t reserved2       : 1;
 192   uint_t vmm_info        : 3;
 193   uint_t pt_base_addr_lo    : 20;
 194   uint_t pt_base_addr_hi : 20;
 195   uint_t available       : 11;
 196   uint_t no_execute      : 1;
 197 } pde64_t;
 198
 199 typedef struct pte64 {
 200   uint_t present         : 1;
 201   uint_t flags           : 4;
 202   uint_t accessed        : 1;
 203   uint_t dirty           : 1;
 204   uint_t pte_attr        : 1;
 205   uint_t global_page     : 1;
 206   uint_t vmm_info        : 3;
 207   uint_t page_base_addr_lo  : 20;
 208   uint_t page_base_addr_hi : 20;
 209   uint_t available       : 11;
 210   uint_t no_execute      : 1;
 211 } pte64_t;
 212
 213 /* *************** */
 214
 215
 216 typedef enum { PDE32 } paging_mode_t;
 217
 218
 219
 220
 221 void delete_page_tables_pde32(pde32_t * pde);
 222
 223
 224 pde32_entry_type_t pde32_lookup(pde32_t * pde, addr_t addr, addr_t * entry);
 225 int pte32_lookup(pte32_t * pte, addr_t addr, addr_t * entry);
 226
 227
 228
 229 struct guest_info;
 230
 231 pde32_t * create_passthrough_pde32_pts(struct guest_info * guest_info);
 232
 233
 234
 235
 236
 237
 238 void PrintDebugPageTables(pde32_t * pde);
 239
 240
 241
 242
 243 #endif