arch/x86/xen/mmu.c

   1 /*
   2  * Xen mmu operations
   3  *
   4  * This file contains the various mmu fetch and update operations.
   5  * The most important job they must perform is the mapping between the
   6  * domain's pfn and the overall machine mfns.
   7  *
   8  * Xen allows guests to directly update the pagetable, in a controlled
   9  * fashion.  In other words, the guest modifies the same pagetable
  10  * that the CPU actually uses, which eliminates the overhead of having
  11  * a separate shadow pagetable.
  12  *
  13  * In order to allow this, it falls on the guest domain to map its
  14  * notion of a "physical" pfn - which is just a domain-local linear
  15  * address - into a real "machine address" which the CPU's MMU can
  16  * use.
  17  *
  18  * A pgd_t/pmd_t/pte_t will typically contain an mfn, and so can be
  19  * inserted directly into the pagetable.  When creating a new
  20  * pte/pmd/pgd, it converts the passed pfn into an mfn.  Conversely,
  21  * when reading the content back with __(pgd|pmd|pte)_val, it converts
  22  * the mfn back into a pfn.
  23  *
  24  * The other constraint is that all pages which make up a pagetable
  25  * must be mapped read-only in the guest.  This prevents uncontrolled
  26  * guest updates to the pagetable.  Xen strictly enforces this, and
  27  * will disallow any pagetable update which will end up mapping a
  28  * pagetable page RW, and will disallow using any writable page as a
  29  * pagetable.
  30  *
  31  * Naively, when loading %cr3 with the base of a new pagetable, Xen
  32  * would need to validate the whole pagetable before going on.
  33  * Naturally, this is quite slow.  The solution is to "pin" a
  34  * pagetable, which enforces all the constraints on the pagetable even
  35  * when it is not actively in use.  This menas that Xen can be assured
  36  * that it is still valid when you do load it into %cr3, and doesn't
  37  * need to revalidate it.
  38  *
  39  * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
  40  */
  41 #include <linux/sched.h>
  42 #include <linux/highmem.h>
  43 #include <linux/bug.h>
  44
  45 #include <asm/pgtable.h>
  46 #include <asm/tlbflush.h>
  47 #include <asm/mmu_context.h>
  48 #include <asm/paravirt.h>
  49
  50 #include <asm/xen/hypercall.h>
  51 #include <asm/xen/hypervisor.h>
  52
  53 #include <xen/page.h>
  54 #include <xen/interface/xen.h>
  55
  56 #include "multicalls.h"
  57 #include "mmu.h"
  58
  59 xmaddr_t arbitrary_virt_to_machine(unsigned long address)
  60 {
  61         unsigned int level;
  62         pte_t *pte = lookup_address(address, &level);
  63         unsigned offset = address & ~PAGE_MASK;
  64
  65         BUG_ON(pte == NULL);
  66
  67         return XMADDR((pte_mfn(*pte) << PAGE_SHIFT) + offset);
  68 }
  69
  70 void make_lowmem_page_readonly(void *vaddr)
  71 {
  72         pte_t *pte, ptev;
  73         unsigned long address = (unsigned long)vaddr;
  74         unsigned int level;
  75
  76         pte = lookup_address(address, &level);
  77         BUG_ON(pte == NULL);
  78
  79         ptev = pte_wrprotect(*pte);
  80
  81         if (HYPERVISOR_update_va_mapping(address, ptev, 0))
  82                 BUG();
  83 }
  84
  85 void make_lowmem_page_readwrite(void *vaddr)
  86 {
  87         pte_t *pte, ptev;
  88         unsigned long address = (unsigned long)vaddr;
  89         unsigned int level;
  90
  91         pte = lookup_address(address, &level);
  92         BUG_ON(pte == NULL);
  93
  94         ptev = pte_mkwrite(*pte);
  95
  96         if (HYPERVISOR_update_va_mapping(address, ptev, 0))
  97                 BUG();
  98 }
  99
 100
 101 void xen_set_pmd(pmd_t *ptr, pmd_t val)
 102 {
 103         struct multicall_space mcs;
 104         struct mmu_update *u;
 105
 106         preempt_disable();
 107
 108         mcs = xen_mc_entry(sizeof(*u));
 109         u = mcs.args;
 110         u->ptr = virt_to_machine(ptr).maddr;
 111         u->val = pmd_val_ma(val);
 112         MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
 113
 114         xen_mc_issue(PARAVIRT_LAZY_MMU);
 115
 116         preempt_enable();
 117 }
 118
 119 /*
 120  * Associate a virtual page frame with a given physical page frame
 121  * and protection flags for that frame.
 122  */
 123 void set_pte_mfn(unsigned long vaddr, unsigned long mfn, pgprot_t flags)
 124 {
 125         pgd_t *pgd;
 126         pud_t *pud;
 127         pmd_t *pmd;
 128         pte_t *pte;
 129
 130         pgd = swapper_pg_dir + pgd_index(vaddr);
 131         if (pgd_none(*pgd)) {
 132                 BUG();
 133                 return;
 134         }
 135         pud = pud_offset(pgd, vaddr);
 136         if (pud_none(*pud)) {
 137                 BUG();
 138                 return;
 139         }
 140         pmd = pmd_offset(pud, vaddr);
 141         if (pmd_none(*pmd)) {
 142                 BUG();
 143                 return;
 144         }
 145         pte = pte_offset_kernel(pmd, vaddr);
 146         /* <mfn,flags> stored as-is, to permit clearing entries */
 147         xen_set_pte(pte, mfn_pte(mfn, flags));
 148
 149         /*
 150          * It's enough to flush this one mapping.
 151          * (PGE mappings get flushed as well)
 152          */
 153         __flush_tlb_one(vaddr);
 154 }
 155
 156 void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
 157                     pte_t *ptep, pte_t pteval)
 158 {
 159         /* updates to init_mm may be done without lock */
 160         if (mm == &init_mm)
 161                 preempt_disable();
 162
 163         if (mm == current->mm || mm == &init_mm) {
 164                 if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
 165                         struct multicall_space mcs;
 166                         mcs = xen_mc_entry(0);
 167
 168                         MULTI_update_va_mapping(mcs.mc, addr, pteval, 0);
 169                         xen_mc_issue(PARAVIRT_LAZY_MMU);
 170                         goto out;
 171                 } else
 172                         if (HYPERVISOR_update_va_mapping(addr, pteval, 0) == 0)
 173                                 goto out;
 174         }
 175         xen_set_pte(ptep, pteval);
 176
 177 out:
 178         if (mm == &init_mm)
 179                 preempt_enable();
 180 }
 181
 182 pteval_t xen_pte_val(pte_t pte)
 183 {
 184         pteval_t ret = pte.pte;
 185
 186         if (ret & _PAGE_PRESENT)
 187                 ret = machine_to_phys(XMADDR(ret)).paddr | _PAGE_PRESENT;
 188
 189         return ret;
 190 }
 191
 192 pgdval_t xen_pgd_val(pgd_t pgd)
 193 {
 194         pgdval_t ret = pgd.pgd;
 195         if (ret & _PAGE_PRESENT)
 196                 ret = machine_to_phys(XMADDR(ret)).paddr | _PAGE_PRESENT;
 197         return ret;
 198 }
 199
 200 pte_t xen_make_pte(pteval_t pte)
 201 {
 202         if (pte & _PAGE_PRESENT)
 203                 pte = phys_to_machine(XPADDR(pte)).maddr;
 204
 205         return (pte_t){ .pte = pte };
 206 }
 207
 208 pgd_t xen_make_pgd(pgdval_t pgd)
 209 {
 210         if (pgd & _PAGE_PRESENT)
 211                 pgd = phys_to_machine(XPADDR(pgd)).maddr;
 212
 213         return (pgd_t){ pgd };
 214 }
 215
 216 pmdval_t xen_pmd_val(pmd_t pmd)
 217 {
 218         pmdval_t ret = native_pmd_val(pmd);
 219         if (ret & _PAGE_PRESENT)
 220                 ret = machine_to_phys(XMADDR(ret)).paddr | _PAGE_PRESENT;
 221         return ret;
 222 }
 223 #ifdef CONFIG_X86_PAE
 224 void xen_set_pud(pud_t *ptr, pud_t val)
 225 {
 226         struct multicall_space mcs;
 227         struct mmu_update *u;
 228
 229         preempt_disable();
 230
 231         mcs = xen_mc_entry(sizeof(*u));
 232         u = mcs.args;
 233         u->ptr = virt_to_machine(ptr).maddr;
 234         u->val = pud_val_ma(val);
 235         MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
 236
 237         xen_mc_issue(PARAVIRT_LAZY_MMU);
 238
 239         preempt_enable();
 240 }
 241
 242 void xen_set_pte(pte_t *ptep, pte_t pte)
 243 {
 244         ptep->pte_high = pte.pte_high;
 245         smp_wmb();
 246         ptep->pte_low = pte.pte_low;
 247 }
 248
 249 void xen_set_pte_atomic(pte_t *ptep, pte_t pte)
 250 {
 251         set_64bit((u64 *)ptep, pte_val_ma(pte));
 252 }
 253
 254 void xen_pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 255 {
 256         ptep->pte_low = 0;
 257         smp_wmb();              /* make sure low gets written first */
 258         ptep->pte_high = 0;
 259 }
 260
 261 void xen_pmd_clear(pmd_t *pmdp)
 262 {
 263         xen_set_pmd(pmdp, __pmd(0));
 264 }
 265
 266 pmd_t xen_make_pmd(pmdval_t pmd)
 267 {
 268         if (pmd & _PAGE_PRESENT)
 269                 pmd = phys_to_machine(XPADDR(pmd)).maddr;
 270
 271         return native_make_pmd(pmd);
 272 }
 273 #else  /* !PAE */
 274 void xen_set_pte(pte_t *ptep, pte_t pte)
 275 {
 276         *ptep = pte;
 277 }
 278 #endif  /* CONFIG_X86_PAE */
 279
 280 /*
 281   (Yet another) pagetable walker.  This one is intended for pinning a
 282   pagetable.  This means that it walks a pagetable and calls the
 283   callback function on each page it finds making up the page table,
 284   at every level.  It walks the entire pagetable, but it only bothers
 285   pinning pte pages which are below pte_limit.  In the normal case
 286   this will be TASK_SIZE, but at boot we need to pin up to
 287   FIXADDR_TOP.  But the important bit is that we don't pin beyond
 288   there, because then we start getting into Xen's ptes.
 289 */
 290 static int pgd_walk(pgd_t *pgd_base, int (*func)(struct page *, enum pt_level),
 291                     unsigned long limit)
 292 {
 293         pgd_t *pgd = pgd_base;
 294         int flush = 0;
 295         unsigned long addr = 0;
 296         unsigned long pgd_next;
 297
 298         BUG_ON(limit > FIXADDR_TOP);
 299
 300         if (xen_feature(XENFEAT_auto_translated_physmap))
 301                 return 0;
 302
 303         for (; addr != FIXADDR_TOP; pgd++, addr = pgd_next) {
 304                 pud_t *pud;
 305                 unsigned long pud_limit, pud_next;
 306
 307                 pgd_next = pud_limit = pgd_addr_end(addr, FIXADDR_TOP);
 308
 309                 if (!pgd_val(*pgd))
 310                         continue;
 311
 312                 pud = pud_offset(pgd, 0);
 313
 314                 if (PTRS_PER_PUD > 1) /* not folded */
 315                         flush |= (*func)(virt_to_page(pud), PT_PUD);
 316
 317                 for (; addr != pud_limit; pud++, addr = pud_next) {
 318                         pmd_t *pmd;
 319                         unsigned long pmd_limit;
 320
 321                         pud_next = pud_addr_end(addr, pud_limit);
 322
 323                         if (pud_next < limit)
 324                                 pmd_limit = pud_next;
 325                         else
 326                                 pmd_limit = limit;
 327
 328                         if (pud_none(*pud))
 329                                 continue;
 330
 331                         pmd = pmd_offset(pud, 0);
 332
 333                         if (PTRS_PER_PMD > 1) /* not folded */
 334                                 flush |= (*func)(virt_to_page(pmd), PT_PMD);
 335
 336                         for (; addr != pmd_limit; pmd++) {
 337                                 addr += (PAGE_SIZE * PTRS_PER_PTE);
 338                                 if ((pmd_limit-1) < (addr-1)) {
 339                                         addr = pmd_limit;
 340                                         break;
 341                                 }
 342
 343                                 if (pmd_none(*pmd))
 344                                         continue;
 345
 346                                 flush |= (*func)(pmd_page(*pmd), PT_PTE);
 347                         }
 348                 }
 349         }
 350
 351         flush |= (*func)(virt_to_page(pgd_base), PT_PGD);
 352
 353         return flush;
 354 }
 355
 356 static spinlock_t *lock_pte(struct page *page)
 357 {
 358         spinlock_t *ptl = NULL;
 359
 360 #if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
 361         ptl = __pte_lockptr(page);
 362         spin_lock(ptl);
 363 #endif
 364
 365         return ptl;
 366 }
 367
 368 static void do_unlock(void *v)
 369 {
 370         spinlock_t *ptl = v;
 371         spin_unlock(ptl);
 372 }
 373
 374 static void xen_do_pin(unsigned level, unsigned long pfn)
 375 {
 376         struct mmuext_op *op;
 377         struct multicall_space mcs;
 378
 379         mcs = __xen_mc_entry(sizeof(*op));
 380         op = mcs.args;
 381         op->cmd = level;
 382         op->arg1.mfn = pfn_to_mfn(pfn);
 383         MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);
 384 }
 385
 386 static int pin_page(struct page *page, enum pt_level level)
 387 {
 388         unsigned pgfl = TestSetPagePinned(page);
 389         int flush;
 390
 391         if (pgfl)
 392                 flush = 0;              /* already pinned */
 393         else if (PageHighMem(page))
 394                 /* kmaps need flushing if we found an unpinned
 395                    highpage */
 396                 flush = 1;
 397         else {
 398                 void *pt = lowmem_page_address(page);
 399                 unsigned long pfn = page_to_pfn(page);
 400                 struct multicall_space mcs = __xen_mc_entry(0);
 401                 spinlock_t *ptl;
 402
 403                 flush = 0;
 404
 405                 ptl = NULL;
 406                 if (level == PT_PTE)
 407                         ptl = lock_pte(page);
 408
 409                 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
 410                                         pfn_pte(pfn, PAGE_KERNEL_RO),
 411                                         level == PT_PGD ? UVMF_TLB_FLUSH : 0);
 412
 413                 if (level == PT_PTE)
 414                         xen_do_pin(MMUEXT_PIN_L1_TABLE, pfn);
 415
 416                 if (ptl) {
 417                         /* Queue a deferred unlock for when this batch
 418                            is completed. */
 419                         xen_mc_callback(do_unlock, ptl);
 420                 }
 421         }
 422
 423         return flush;
 424 }
 425
 426 /* This is called just after a mm has been created, but it has not
 427    been used yet.  We need to make sure that its pagetable is all
 428    read-only, and can be pinned. */
 429 void xen_pgd_pin(pgd_t *pgd)
 430 {
 431         unsigned level;
 432
 433         xen_mc_batch();
 434
 435         if (pgd_walk(pgd, pin_page, TASK_SIZE)) {
 436                 /* re-enable interrupts for kmap_flush_unused */
 437                 xen_mc_issue(0);
 438                 kmap_flush_unused();
 439                 xen_mc_batch();
 440         }
 441
 442 #ifdef CONFIG_X86_PAE
 443         level = MMUEXT_PIN_L3_TABLE;
 444 #else
 445         level = MMUEXT_PIN_L2_TABLE;
 446 #endif
 447
 448         xen_do_pin(level, PFN_DOWN(__pa(pgd)));
 449
 450         xen_mc_issue(0);
 451 }
 452
 453 /* The init_mm pagetable is really pinned as soon as its created, but
 454    that's before we have page structures to store the bits.  So do all
 455    the book-keeping now. */
 456 static __init int mark_pinned(struct page *page, enum pt_level level)
 457 {
 458         SetPagePinned(page);
 459         return 0;
 460 }
 461
 462 void __init xen_mark_init_mm_pinned(void)
 463 {
 464         pgd_walk(init_mm.pgd, mark_pinned, FIXADDR_TOP);
 465 }
 466
 467 static int unpin_page(struct page *page, enum pt_level level)
 468 {
 469         unsigned pgfl = TestClearPagePinned(page);
 470
 471         if (pgfl && !PageHighMem(page)) {
 472                 void *pt = lowmem_page_address(page);
 473                 unsigned long pfn = page_to_pfn(page);
 474                 spinlock_t *ptl = NULL;
 475                 struct multicall_space mcs;
 476
 477                 if (level == PT_PTE) {
 478                         ptl = lock_pte(page);
 479
 480                         xen_do_pin(MMUEXT_UNPIN_TABLE, pfn);
 481                 }
 482
 483                 mcs = __xen_mc_entry(0);
 484
 485                 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
 486                                         pfn_pte(pfn, PAGE_KERNEL),
 487                                         level == PT_PGD ? UVMF_TLB_FLUSH : 0);
 488
 489                 if (ptl) {
 490                         /* unlock when batch completed */
 491                         xen_mc_callback(do_unlock, ptl);
 492                 }
 493         }
 494
 495         return 0;               /* never need to flush on unpin */
 496 }
 497
 498 /* Release a pagetables pages back as normal RW */
 499 static void xen_pgd_unpin(pgd_t *pgd)
 500 {
 501         xen_mc_batch();
 502
 503         xen_do_pin(MMUEXT_UNPIN_TABLE, PFN_DOWN(__pa(pgd)));
 504
 505         pgd_walk(pgd, unpin_page, TASK_SIZE);
 506
 507         xen_mc_issue(0);
 508 }
 509
 510 void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next)
 511 {
 512         spin_lock(&next->page_table_lock);
 513         xen_pgd_pin(next->pgd);
 514         spin_unlock(&next->page_table_lock);
 515 }
 516
 517 void xen_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
 518 {
 519         spin_lock(&mm->page_table_lock);
 520         xen_pgd_pin(mm->pgd);
 521         spin_unlock(&mm->page_table_lock);
 522 }
 523
 524
 525 #ifdef CONFIG_SMP
 526 /* Another cpu may still have their %cr3 pointing at the pagetable, so
 527    we need to repoint it somewhere else before we can unpin it. */
 528 static void drop_other_mm_ref(void *info)
 529 {
 530         struct mm_struct *mm = info;
 531
 532         if (__get_cpu_var(cpu_tlbstate).active_mm == mm)
 533                 leave_mm(smp_processor_id());
 534
 535         /* If this cpu still has a stale cr3 reference, then make sure
 536            it has been flushed. */
 537         if (x86_read_percpu(xen_current_cr3) == __pa(mm->pgd)) {
 538                 load_cr3(swapper_pg_dir);
 539                 arch_flush_lazy_cpu_mode();
 540         }
 541 }
 542
 543 static void drop_mm_ref(struct mm_struct *mm)
 544 {
 545         cpumask_t mask;
 546         unsigned cpu;
 547
 548         if (current->active_mm == mm) {
 549                 if (current->mm == mm)
 550                         load_cr3(swapper_pg_dir);
 551                 else
 552                         leave_mm(smp_processor_id());
 553                 arch_flush_lazy_cpu_mode();
 554         }
 555
 556         /* Get the "official" set of cpus referring to our pagetable. */
 557         mask = mm->cpu_vm_mask;
 558
 559         /* It's possible that a vcpu may have a stale reference to our
 560            cr3, because its in lazy mode, and it hasn't yet flushed
 561            its set of pending hypercalls yet.  In this case, we can
 562            look at its actual current cr3 value, and force it to flush
 563            if needed. */
 564         for_each_online_cpu(cpu) {
 565                 if (per_cpu(xen_current_cr3, cpu) == __pa(mm->pgd))
 566                         cpu_set(cpu, mask);
 567         }
 568
 569         if (!cpus_empty(mask))
 570                 xen_smp_call_function_mask(mask, drop_other_mm_ref, mm, 1);
 571 }
 572 #else
 573 static void drop_mm_ref(struct mm_struct *mm)
 574 {
 575         if (current->active_mm == mm)
 576                 load_cr3(swapper_pg_dir);
 577 }
 578 #endif
 579
 580 /*
 581  * While a process runs, Xen pins its pagetables, which means that the
 582  * hypervisor forces it to be read-only, and it controls all updates
 583  * to it.  This means that all pagetable updates have to go via the
 584  * hypervisor, which is moderately expensive.
 585  *
 586  * Since we're pulling the pagetable down, we switch to use init_mm,
 587  * unpin old process pagetable and mark it all read-write, which
 588  * allows further operations on it to be simple memory accesses.
 589  *
 590  * The only subtle point is that another CPU may be still using the
 591  * pagetable because of lazy tlb flushing.  This means we need need to
 592  * switch all CPUs off this pagetable before we can unpin it.
 593  */
 594 void xen_exit_mmap(struct mm_struct *mm)
 595 {
 596         get_cpu();              /* make sure we don't move around */
 597         drop_mm_ref(mm);
 598         put_cpu();
 599
 600         spin_lock(&mm->page_table_lock);
 601
 602         /* pgd may not be pinned in the error exit path of execve */
 603         if (PagePinned(virt_to_page(mm->pgd)))
 604                 xen_pgd_unpin(mm->pgd);
 605
 606         spin_unlock(&mm->page_table_lock);
 607 }