drivers/kvm/paging_tmpl.h

   1 /*
   2  * Kernel-based Virtual Machine driver for Linux
   3  *
   4  * This module enables machines with Intel VT-x extensions to run virtual
   5  * machines without emulation or binary translation.
   6  *
   7  * MMU support
   8  *
   9  * Copyright (C) 2006 Qumranet, Inc.
  10  *
  11  * Authors:
  12  *   Yaniv Kamay  <yaniv@qumranet.com>
  13  *   Avi Kivity   <avi@qumranet.com>
  14  *
  15  * This work is licensed under the terms of the GNU GPL, version 2.  See
  16  * the COPYING file in the top-level directory.
  17  *
  18  */
  19
  20 /*
  21  * We need the mmu code to access both 32-bit and 64-bit guest ptes,
  22  * so the code in this file is compiled twice, once per pte size.
  23  */
  24
  25 #if PTTYPE == 64
  26         #define pt_element_t u64
  27         #define guest_walker guest_walker64
  28         #define FNAME(name) paging##64_##name
  29         #define PT_BASE_ADDR_MASK PT64_BASE_ADDR_MASK
  30         #define PT_DIR_BASE_ADDR_MASK PT64_DIR_BASE_ADDR_MASK
  31         #define PT_INDEX(addr, level) PT64_INDEX(addr, level)
  32         #define SHADOW_PT_INDEX(addr, level) PT64_INDEX(addr, level)
  33         #define PT_LEVEL_MASK(level) PT64_LEVEL_MASK(level)
  34         #define PT_LEVEL_BITS PT64_LEVEL_BITS
  35         #ifdef CONFIG_X86_64
  36         #define PT_MAX_FULL_LEVELS 4
  37         #define CMPXCHG cmpxchg
  38         #else
  39         #define CMPXCHG cmpxchg64
  40         #define PT_MAX_FULL_LEVELS 2
  41         #endif
  42 #elif PTTYPE == 32
  43         #define pt_element_t u32
  44         #define guest_walker guest_walker32
  45         #define FNAME(name) paging##32_##name
  46         #define PT_BASE_ADDR_MASK PT32_BASE_ADDR_MASK
  47         #define PT_DIR_BASE_ADDR_MASK PT32_DIR_BASE_ADDR_MASK
  48         #define PT_INDEX(addr, level) PT32_INDEX(addr, level)
  49         #define SHADOW_PT_INDEX(addr, level) PT64_INDEX(addr, level)
  50         #define PT_LEVEL_MASK(level) PT32_LEVEL_MASK(level)
  51         #define PT_LEVEL_BITS PT32_LEVEL_BITS
  52         #define PT_MAX_FULL_LEVELS 2
  53         #define CMPXCHG cmpxchg
  54 #else
  55         #error Invalid PTTYPE value
  56 #endif
  57
  58 #define gpte_to_gfn FNAME(gpte_to_gfn)
  59 #define gpte_to_gfn_pde FNAME(gpte_to_gfn_pde)
  60
  61 /*
  62  * The guest_walker structure emulates the behavior of the hardware page
  63  * table walker.
  64  */
  65 struct guest_walker {
  66         int level;
  67         gfn_t table_gfn[PT_MAX_FULL_LEVELS];
  68         pt_element_t pte;
  69         pt_element_t inherited_ar;
  70         gfn_t gfn;
  71         u32 error_code;
  72 };
  73
  74 static gfn_t gpte_to_gfn(pt_element_t gpte)
  75 {
  76         return (gpte & PT_BASE_ADDR_MASK) >> PAGE_SHIFT;
  77 }
  78
  79 static gfn_t gpte_to_gfn_pde(pt_element_t gpte)
  80 {
  81         return (gpte & PT_DIR_BASE_ADDR_MASK) >> PAGE_SHIFT;
  82 }
  83
  84 static bool FNAME(cmpxchg_gpte)(struct kvm *kvm,
  85                          gfn_t table_gfn, unsigned index,
  86                          pt_element_t orig_pte, pt_element_t new_pte)
  87 {
  88         pt_element_t ret;
  89         pt_element_t *table;
  90         struct page *page;
  91
  92         page = gfn_to_page(kvm, table_gfn);
  93         table = kmap_atomic(page, KM_USER0);
  94
  95         ret = CMPXCHG(&table[index], orig_pte, new_pte);
  96
  97         kunmap_atomic(table, KM_USER0);
  98
  99         kvm_release_page_dirty(page);
 100
 101         return (ret != orig_pte);
 102 }
 103
 104 /*
 105  * Fetch a guest pte for a guest virtual address
 106  */
 107 static int FNAME(walk_addr)(struct guest_walker *walker,
 108                             struct kvm_vcpu *vcpu, gva_t addr,
 109                             int write_fault, int user_fault, int fetch_fault)
 110 {
 111         pt_element_t pte;
 112         gfn_t table_gfn;
 113         unsigned index;
 114         gpa_t pte_gpa;
 115
 116         pgprintk("%s: addr %lx\n", __FUNCTION__, addr);
 117 walk:
 118         walker->level = vcpu->mmu.root_level;
 119         pte = vcpu->cr3;
 120 #if PTTYPE == 64
 121         if (!is_long_mode(vcpu)) {
 122                 pte = vcpu->pdptrs[(addr >> 30) & 3];
 123                 if (!is_present_pte(pte))
 124                         goto not_present;
 125                 --walker->level;
 126         }
 127 #endif
 128         ASSERT((!is_long_mode(vcpu) && is_pae(vcpu)) ||
 129                (vcpu->cr3 & CR3_NONPAE_RESERVED_BITS) == 0);
 130
 131         walker->inherited_ar = PT_USER_MASK | PT_WRITABLE_MASK;
 132
 133         for (;;) {
 134                 index = PT_INDEX(addr, walker->level);
 135
 136                 table_gfn = gpte_to_gfn(pte);
 137                 pte_gpa = gfn_to_gpa(table_gfn);
 138                 pte_gpa += index * sizeof(pt_element_t);
 139                 walker->table_gfn[walker->level - 1] = table_gfn;
 140                 pgprintk("%s: table_gfn[%d] %lx\n", __FUNCTION__,
 141                          walker->level - 1, table_gfn);
 142
 143                 kvm_read_guest(vcpu->kvm, pte_gpa, &pte, sizeof(pte));
 144
 145                 if (!is_present_pte(pte))
 146                         goto not_present;
 147
 148                 if (write_fault && !is_writeble_pte(pte))
 149                         if (user_fault || is_write_protection(vcpu))
 150                                 goto access_error;
 151
 152                 if (user_fault && !(pte & PT_USER_MASK))
 153                         goto access_error;
 154
 155 #if PTTYPE == 64
 156                 if (fetch_fault && is_nx(vcpu) && (pte & PT64_NX_MASK))
 157                         goto access_error;
 158 #endif
 159
 160                 if (!(pte & PT_ACCESSED_MASK)) {
 161                         mark_page_dirty(vcpu->kvm, table_gfn);
 162                         if (FNAME(cmpxchg_gpte)(vcpu->kvm, table_gfn,
 163                             index, pte, pte|PT_ACCESSED_MASK))
 164                                 goto walk;
 165                         pte |= PT_ACCESSED_MASK;
 166                 }
 167
 168                 if (walker->level == PT_PAGE_TABLE_LEVEL) {
 169                         walker->gfn = gpte_to_gfn(pte);
 170                         break;
 171                 }
 172
 173                 if (walker->level == PT_DIRECTORY_LEVEL
 174                     && (pte & PT_PAGE_SIZE_MASK)
 175                     && (PTTYPE == 64 || is_pse(vcpu))) {
 176                         walker->gfn = gpte_to_gfn_pde(pte);
 177                         walker->gfn += PT_INDEX(addr, PT_PAGE_TABLE_LEVEL);
 178                         if (PTTYPE == 32 && is_cpuid_PSE36())
 179                                 walker->gfn += pse36_gfn_delta(pte);
 180                         break;
 181                 }
 182
 183                 walker->inherited_ar &= pte;
 184                 --walker->level;
 185         }
 186
 187         if (write_fault && !is_dirty_pte(pte)) {
 188                 bool ret;
 189
 190                 mark_page_dirty(vcpu->kvm, table_gfn);
 191                 ret = FNAME(cmpxchg_gpte)(vcpu->kvm, table_gfn, index, pte,
 192                             pte|PT_DIRTY_MASK);
 193                 if (ret)
 194                         goto walk;
 195                 pte |= PT_DIRTY_MASK;
 196                 kvm_mmu_pte_write(vcpu, pte_gpa, (u8 *)&pte, sizeof(pte));
 197         }
 198
 199         walker->pte = pte;
 200         pgprintk("%s: pte %llx\n", __FUNCTION__, (u64)pte);
 201         return 1;
 202
 203 not_present:
 204         walker->error_code = 0;
 205         goto err;
 206
 207 access_error:
 208         walker->error_code = PFERR_PRESENT_MASK;
 209
 210 err:
 211         if (write_fault)
 212                 walker->error_code |= PFERR_WRITE_MASK;
 213         if (user_fault)
 214                 walker->error_code |= PFERR_USER_MASK;
 215         if (fetch_fault)
 216                 walker->error_code |= PFERR_FETCH_MASK;
 217         return 0;
 218 }
 219
 220 static void FNAME(set_pte)(struct kvm_vcpu *vcpu, pt_element_t gpte,
 221                            u64 *shadow_pte, u64 access_bits,
 222                            int user_fault, int write_fault,
 223                            int *ptwrite, struct guest_walker *walker,
 224                            gfn_t gfn)
 225 {
 226         int dirty = gpte & PT_DIRTY_MASK;
 227         u64 spte;
 228         int was_rmapped = is_rmap_pte(*shadow_pte);
 229         struct page *page;
 230
 231         pgprintk("%s: spte %llx gpte %llx access %llx write_fault %d"
 232                  " user_fault %d gfn %lx\n",
 233                  __FUNCTION__, *shadow_pte, (u64)gpte, access_bits,
 234                  write_fault, user_fault, gfn);
 235
 236         access_bits &= gpte;
 237         /*
 238          * We don't set the accessed bit, since we sometimes want to see
 239          * whether the guest actually used the pte (in order to detect
 240          * demand paging).
 241          */
 242         spte = PT_PRESENT_MASK | PT_DIRTY_MASK;
 243         spte |= gpte & PT64_NX_MASK;
 244         if (!dirty)
 245                 access_bits &= ~PT_WRITABLE_MASK;
 246
 247         page = gfn_to_page(vcpu->kvm, gfn);
 248
 249         spte |= PT_PRESENT_MASK;
 250         if (access_bits & PT_USER_MASK)
 251                 spte |= PT_USER_MASK;
 252
 253         if (is_error_page(page)) {
 254                 set_shadow_pte(shadow_pte,
 255                                shadow_trap_nonpresent_pte | PT_SHADOW_IO_MARK);
 256                 kvm_release_page_clean(page);
 257                 return;
 258         }
 259
 260         spte |= page_to_phys(page);
 261
 262         if ((access_bits & PT_WRITABLE_MASK)
 263             || (write_fault && !is_write_protection(vcpu) && !user_fault)) {
 264                 struct kvm_mmu_page *shadow;
 265
 266                 spte |= PT_WRITABLE_MASK;
 267                 if (user_fault) {
 268                         mmu_unshadow(vcpu->kvm, gfn);
 269                         goto unshadowed;
 270                 }
 271
 272                 shadow = kvm_mmu_lookup_page(vcpu->kvm, gfn);
 273                 if (shadow) {
 274                         pgprintk("%s: found shadow page for %lx, marking ro\n",
 275                                  __FUNCTION__, gfn);
 276                         access_bits &= ~PT_WRITABLE_MASK;
 277                         if (is_writeble_pte(spte)) {
 278                                 spte &= ~PT_WRITABLE_MASK;
 279                                 kvm_x86_ops->tlb_flush(vcpu);
 280                         }
 281                         if (write_fault)
 282                                 *ptwrite = 1;
 283                 }
 284         }
 285
 286 unshadowed:
 287
 288         if (access_bits & PT_WRITABLE_MASK)
 289                 mark_page_dirty(vcpu->kvm, gfn);
 290
 291         pgprintk("%s: setting spte %llx\n", __FUNCTION__, spte);
 292         set_shadow_pte(shadow_pte, spte);
 293         page_header_update_slot(vcpu->kvm, shadow_pte, gfn);
 294         if (!was_rmapped) {
 295                 rmap_add(vcpu, shadow_pte, gfn);
 296                 if (!is_rmap_pte(*shadow_pte))
 297                         kvm_release_page_clean(page);
 298         }
 299         else
 300                 kvm_release_page_clean(page);
 301         if (!ptwrite || !*ptwrite)
 302                 vcpu->last_pte_updated = shadow_pte;
 303 }
 304
 305 static void FNAME(update_pte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *page,
 306                               u64 *spte, const void *pte, int bytes,
 307                               int offset_in_pte)
 308 {
 309         pt_element_t gpte;
 310
 311         gpte = *(const pt_element_t *)pte;
 312         if (~gpte & (PT_PRESENT_MASK | PT_ACCESSED_MASK)) {
 313                 if (!offset_in_pte && !is_present_pte(gpte))
 314                         set_shadow_pte(spte, shadow_notrap_nonpresent_pte);
 315                 return;
 316         }
 317         if (bytes < sizeof(pt_element_t))
 318                 return;
 319         pgprintk("%s: gpte %llx spte %p\n", __FUNCTION__, (u64)gpte, spte);
 320         FNAME(set_pte)(vcpu, gpte, spte, PT_USER_MASK | PT_WRITABLE_MASK, 0,
 321                        0, NULL, NULL, gpte_to_gfn(gpte));
 322 }
 323
 324 /*
 325  * Fetch a shadow pte for a specific level in the paging hierarchy.
 326  */
 327 static u64 *FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
 328                          struct guest_walker *walker,
 329                          int user_fault, int write_fault, int *ptwrite)
 330 {
 331         hpa_t shadow_addr;
 332         int level;
 333         u64 *shadow_ent;
 334
 335         if (!is_present_pte(walker->pte))
 336                 return NULL;
 337
 338         shadow_addr = vcpu->mmu.root_hpa;
 339         level = vcpu->mmu.shadow_root_level;
 340         if (level == PT32E_ROOT_LEVEL) {
 341                 shadow_addr = vcpu->mmu.pae_root[(addr >> 30) & 3];
 342                 shadow_addr &= PT64_BASE_ADDR_MASK;
 343                 --level;
 344         }
 345
 346         for (; ; level--) {
 347                 u32 index = SHADOW_PT_INDEX(addr, level);
 348                 struct kvm_mmu_page *shadow_page;
 349                 u64 shadow_pte;
 350                 int metaphysical;
 351                 gfn_t table_gfn;
 352                 unsigned hugepage_access = 0;
 353
 354                 shadow_ent = ((u64 *)__va(shadow_addr)) + index;
 355                 if (is_shadow_present_pte(*shadow_ent)) {
 356                         if (level == PT_PAGE_TABLE_LEVEL)
 357                                 break;
 358                         shadow_addr = *shadow_ent & PT64_BASE_ADDR_MASK;
 359                         continue;
 360                 }
 361
 362                 if (level == PT_PAGE_TABLE_LEVEL)
 363                         break;
 364
 365                 if (level - 1 == PT_PAGE_TABLE_LEVEL
 366                     && walker->level == PT_DIRECTORY_LEVEL) {
 367                         metaphysical = 1;
 368                         hugepage_access = walker->pte;
 369                         hugepage_access &= PT_USER_MASK | PT_WRITABLE_MASK;
 370                         if (!is_dirty_pte(walker->pte))
 371                                 hugepage_access &= ~PT_WRITABLE_MASK;
 372                         hugepage_access >>= PT_WRITABLE_SHIFT;
 373                         if (walker->pte & PT64_NX_MASK)
 374                                 hugepage_access |= (1 << 2);
 375                         table_gfn = gpte_to_gfn(walker->pte);
 376                 } else {
 377                         metaphysical = 0;
 378                         table_gfn = walker->table_gfn[level - 2];
 379                 }
 380                 shadow_page = kvm_mmu_get_page(vcpu, table_gfn, addr, level-1,
 381                                                metaphysical, hugepage_access,
 382                                                shadow_ent);
 383                 shadow_addr = __pa(shadow_page->spt);
 384                 shadow_pte = shadow_addr | PT_PRESENT_MASK | PT_ACCESSED_MASK
 385                         | PT_WRITABLE_MASK | PT_USER_MASK;
 386                 *shadow_ent = shadow_pte;
 387         }
 388
 389         FNAME(set_pte)(vcpu, walker->pte, shadow_ent,
 390                        walker->inherited_ar, user_fault, write_fault,
 391                        ptwrite, walker, walker->gfn);
 392
 393         return shadow_ent;
 394 }
 395
 396 /*
 397  * Page fault handler.  There are several causes for a page fault:
 398  *   - there is no shadow pte for the guest pte
 399  *   - write access through a shadow pte marked read only so that we can set
 400  *     the dirty bit
 401  *   - write access to a shadow pte marked read only so we can update the page
 402  *     dirty bitmap, when userspace requests it
 403  *   - mmio access; in this case we will never install a present shadow pte
 404  *   - normal guest page fault due to the guest pte marked not present, not
 405  *     writable, or not executable
 406  *
 407  *  Returns: 1 if we need to emulate the instruction, 0 otherwise, or
 408  *           a negative value on error.
 409  */
 410 static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr,
 411                                u32 error_code)
 412 {
 413         int write_fault = error_code & PFERR_WRITE_MASK;
 414         int user_fault = error_code & PFERR_USER_MASK;
 415         int fetch_fault = error_code & PFERR_FETCH_MASK;
 416         struct guest_walker walker;
 417         u64 *shadow_pte;
 418         int write_pt = 0;
 419         int r;
 420
 421         pgprintk("%s: addr %lx err %x\n", __FUNCTION__, addr, error_code);
 422         kvm_mmu_audit(vcpu, "pre page fault");
 423
 424         r = mmu_topup_memory_caches(vcpu);
 425         if (r)
 426                 return r;
 427
 428         /*
 429          * Look up the shadow pte for the faulting address.
 430          */
 431         r = FNAME(walk_addr)(&walker, vcpu, addr, write_fault, user_fault,
 432                              fetch_fault);
 433
 434         /*
 435          * The page is not mapped by the guest.  Let the guest handle it.
 436          */
 437         if (!r) {
 438                 pgprintk("%s: guest page fault\n", __FUNCTION__);
 439                 inject_page_fault(vcpu, addr, walker.error_code);
 440                 vcpu->last_pt_write_count = 0; /* reset fork detector */
 441                 return 0;
 442         }
 443
 444         shadow_pte = FNAME(fetch)(vcpu, addr, &walker, user_fault, write_fault,
 445                                   &write_pt);
 446         pgprintk("%s: shadow pte %p %llx ptwrite %d\n", __FUNCTION__,
 447                  shadow_pte, *shadow_pte, write_pt);
 448
 449         if (!write_pt)
 450                 vcpu->last_pt_write_count = 0; /* reset fork detector */
 451
 452         /*
 453          * mmio: emulate if accessible, otherwise its a guest fault.
 454          */
 455         if (is_io_pte(*shadow_pte))
 456                 return 1;
 457
 458         ++vcpu->stat.pf_fixed;
 459         kvm_mmu_audit(vcpu, "post page fault (fixed)");
 460
 461         return write_pt;
 462 }
 463
 464 static gpa_t FNAME(gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t vaddr)
 465 {
 466         struct guest_walker walker;
 467         gpa_t gpa = UNMAPPED_GVA;
 468         int r;
 469
 470         r = FNAME(walk_addr)(&walker, vcpu, vaddr, 0, 0, 0);
 471
 472         if (r) {
 473                 gpa = gfn_to_gpa(walker.gfn);
 474                 gpa |= vaddr & ~PAGE_MASK;
 475         }
 476
 477         return gpa;
 478 }
 479
 480 static void FNAME(prefetch_page)(struct kvm_vcpu *vcpu,
 481                                  struct kvm_mmu_page *sp)
 482 {
 483         int i, offset = 0;
 484         pt_element_t *gpt;
 485         struct page *page;
 486
 487         if (sp->role.metaphysical
 488             || (PTTYPE == 32 && sp->role.level > PT_PAGE_TABLE_LEVEL)) {
 489                 nonpaging_prefetch_page(vcpu, sp);
 490                 return;
 491         }
 492
 493         if (PTTYPE == 32)
 494                 offset = sp->role.quadrant << PT64_LEVEL_BITS;
 495         page = gfn_to_page(vcpu->kvm, sp->gfn);
 496         gpt = kmap_atomic(page, KM_USER0);
 497         for (i = 0; i < PT64_ENT_PER_PAGE; ++i)
 498                 if (is_present_pte(gpt[offset + i]))
 499                         sp->spt[i] = shadow_trap_nonpresent_pte;
 500                 else
 501                         sp->spt[i] = shadow_notrap_nonpresent_pte;
 502         kunmap_atomic(gpt, KM_USER0);
 503         kvm_release_page_clean(page);
 504 }
 505
 506 #undef pt_element_t
 507 #undef guest_walker
 508 #undef FNAME
 509 #undef PT_BASE_ADDR_MASK
 510 #undef PT_INDEX
 511 #undef SHADOW_PT_INDEX
 512 #undef PT_LEVEL_MASK
 513 #undef PT_DIR_BASE_ADDR_MASK
 514 #undef PT_LEVEL_BITS
 515 #undef PT_MAX_FULL_LEVELS
 516 #undef gpte_to_gfn
 517 #undef gpte_to_gfn_pde
 518 #undef CMPXCHG