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