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/fixmap.h>
  48 #include <asm/mmu_context.h>
  49 #include <asm/paravirt.h>
  50 #include <asm/linkage.h>
  51
  52 #include <asm/xen/hypercall.h>
  53 #include <asm/xen/hypervisor.h>
  54
  55 #include <xen/page.h>
  56 #include <xen/interface/xen.h>
  57
  58 #include "multicalls.h"
  59 #include "mmu.h"
  60
  61 #define P2M_ENTRIES_PER_PAGE    (PAGE_SIZE / sizeof(unsigned long))
  62 #define TOP_ENTRIES             (MAX_DOMAIN_PAGES / P2M_ENTRIES_PER_PAGE)
  63
  64 /* Placeholder for holes in the address space */
  65 static unsigned long p2m_missing[P2M_ENTRIES_PER_PAGE] __page_aligned_data =
  66                 { [ 0 ... P2M_ENTRIES_PER_PAGE-1 ] = ~0UL };
  67
  68  /* Array of pointers to pages containing p2m entries */
  69 static unsigned long *p2m_top[TOP_ENTRIES] __page_aligned_data =
  70                 { [ 0 ... TOP_ENTRIES - 1] = &p2m_missing[0] };
  71
  72 /* Arrays of p2m arrays expressed in mfns used for save/restore */
  73 static unsigned long p2m_top_mfn[TOP_ENTRIES] __page_aligned_bss;
  74
  75 static unsigned long p2m_top_mfn_list[TOP_ENTRIES / P2M_ENTRIES_PER_PAGE]
  76         __page_aligned_bss;
  77
  78 static inline unsigned p2m_top_index(unsigned long pfn)
  79 {
  80         BUG_ON(pfn >= MAX_DOMAIN_PAGES);
  81         return pfn / P2M_ENTRIES_PER_PAGE;
  82 }
  83
  84 static inline unsigned p2m_index(unsigned long pfn)
  85 {
  86         return pfn % P2M_ENTRIES_PER_PAGE;
  87 }
  88
  89 /* Build the parallel p2m_top_mfn structures */
  90 void xen_setup_mfn_list_list(void)
  91 {
  92         unsigned pfn, idx;
  93
  94         for(pfn = 0; pfn < MAX_DOMAIN_PAGES; pfn += P2M_ENTRIES_PER_PAGE) {
  95                 unsigned topidx = p2m_top_index(pfn);
  96
  97                 p2m_top_mfn[topidx] = virt_to_mfn(p2m_top[topidx]);
  98         }
  99
 100         for(idx = 0; idx < ARRAY_SIZE(p2m_top_mfn_list); idx++) {
 101                 unsigned topidx = idx * P2M_ENTRIES_PER_PAGE;
 102                 p2m_top_mfn_list[idx] = virt_to_mfn(&p2m_top_mfn[topidx]);
 103         }
 104
 105         BUG_ON(HYPERVISOR_shared_info == &xen_dummy_shared_info);
 106
 107         HYPERVISOR_shared_info->arch.pfn_to_mfn_frame_list_list =
 108                 virt_to_mfn(p2m_top_mfn_list);
 109         HYPERVISOR_shared_info->arch.max_pfn = xen_start_info->nr_pages;
 110 }
 111
 112 /* Set up p2m_top to point to the domain-builder provided p2m pages */
 113 void __init xen_build_dynamic_phys_to_machine(void)
 114 {
 115         unsigned long *mfn_list = (unsigned long *)xen_start_info->mfn_list;
 116         unsigned long max_pfn = min(MAX_DOMAIN_PAGES, xen_start_info->nr_pages);
 117         unsigned pfn;
 118
 119         for(pfn = 0; pfn < max_pfn; pfn += P2M_ENTRIES_PER_PAGE) {
 120                 unsigned topidx = p2m_top_index(pfn);
 121
 122                 p2m_top[topidx] = &mfn_list[pfn];
 123         }
 124 }
 125
 126 unsigned long get_phys_to_machine(unsigned long pfn)
 127 {
 128         unsigned topidx, idx;
 129
 130         if (unlikely(pfn >= MAX_DOMAIN_PAGES))
 131                 return INVALID_P2M_ENTRY;
 132
 133         topidx = p2m_top_index(pfn);
 134         idx = p2m_index(pfn);
 135         return p2m_top[topidx][idx];
 136 }
 137 EXPORT_SYMBOL_GPL(get_phys_to_machine);
 138
 139 static void alloc_p2m(unsigned long **pp, unsigned long *mfnp)
 140 {
 141         unsigned long *p;
 142         unsigned i;
 143
 144         p = (void *)__get_free_page(GFP_KERNEL | __GFP_NOFAIL);
 145         BUG_ON(p == NULL);
 146
 147         for(i = 0; i < P2M_ENTRIES_PER_PAGE; i++)
 148                 p[i] = INVALID_P2M_ENTRY;
 149
 150         if (cmpxchg(pp, p2m_missing, p) != p2m_missing)
 151                 free_page((unsigned long)p);
 152         else
 153                 *mfnp = virt_to_mfn(p);
 154 }
 155
 156 void set_phys_to_machine(unsigned long pfn, unsigned long mfn)
 157 {
 158         unsigned topidx, idx;
 159
 160         if (unlikely(xen_feature(XENFEAT_auto_translated_physmap))) {
 161                 BUG_ON(pfn != mfn && mfn != INVALID_P2M_ENTRY);
 162                 return;
 163         }
 164
 165         if (unlikely(pfn >= MAX_DOMAIN_PAGES)) {
 166                 BUG_ON(mfn != INVALID_P2M_ENTRY);
 167                 return;
 168         }
 169
 170         topidx = p2m_top_index(pfn);
 171         if (p2m_top[topidx] == p2m_missing) {
 172                 /* no need to allocate a page to store an invalid entry */
 173                 if (mfn == INVALID_P2M_ENTRY)
 174                         return;
 175                 alloc_p2m(&p2m_top[topidx], &p2m_top_mfn[topidx]);
 176         }
 177
 178         idx = p2m_index(pfn);
 179         p2m_top[topidx][idx] = mfn;
 180 }
 181
 182 xmaddr_t arbitrary_virt_to_machine(void *vaddr)
 183 {
 184         unsigned long address = (unsigned long)vaddr;
 185         unsigned int level;
 186         pte_t *pte = lookup_address(address, &level);
 187         unsigned offset = address & ~PAGE_MASK;
 188
 189         BUG_ON(pte == NULL);
 190
 191         return XMADDR(((phys_addr_t)pte_mfn(*pte) << PAGE_SHIFT) + offset);
 192 }
 193
 194 void make_lowmem_page_readonly(void *vaddr)
 195 {
 196         pte_t *pte, ptev;
 197         unsigned long address = (unsigned long)vaddr;
 198         unsigned int level;
 199
 200         pte = lookup_address(address, &level);
 201         BUG_ON(pte == NULL);
 202
 203         ptev = pte_wrprotect(*pte);
 204
 205         if (HYPERVISOR_update_va_mapping(address, ptev, 0))
 206                 BUG();
 207 }
 208
 209 void make_lowmem_page_readwrite(void *vaddr)
 210 {
 211         pte_t *pte, ptev;
 212         unsigned long address = (unsigned long)vaddr;
 213         unsigned int level;
 214
 215         pte = lookup_address(address, &level);
 216         BUG_ON(pte == NULL);
 217
 218         ptev = pte_mkwrite(*pte);
 219
 220         if (HYPERVISOR_update_va_mapping(address, ptev, 0))
 221                 BUG();
 222 }
 223
 224
 225 static bool page_pinned(void *ptr)
 226 {
 227         struct page *page = virt_to_page(ptr);
 228
 229         return PagePinned(page);
 230 }
 231
 232 static void extend_mmu_update(const struct mmu_update *update)
 233 {
 234         struct multicall_space mcs;
 235         struct mmu_update *u;
 236
 237         mcs = xen_mc_extend_args(__HYPERVISOR_mmu_update, sizeof(*u));
 238
 239         if (mcs.mc != NULL)
 240                 mcs.mc->args[1]++;
 241         else {
 242                 mcs = __xen_mc_entry(sizeof(*u));
 243                 MULTI_mmu_update(mcs.mc, mcs.args, 1, NULL, DOMID_SELF);
 244         }
 245
 246         u = mcs.args;
 247         *u = *update;
 248 }
 249
 250 void xen_set_pmd_hyper(pmd_t *ptr, pmd_t val)
 251 {
 252         struct mmu_update u;
 253
 254         preempt_disable();
 255
 256         xen_mc_batch();
 257
 258         /* ptr may be ioremapped for 64-bit pagetable setup */
 259         u.ptr = arbitrary_virt_to_machine(ptr).maddr;
 260         u.val = pmd_val_ma(val);
 261         extend_mmu_update(&u);
 262
 263         xen_mc_issue(PARAVIRT_LAZY_MMU);
 264
 265         preempt_enable();
 266 }
 267
 268 void xen_set_pmd(pmd_t *ptr, pmd_t val)
 269 {
 270         /* If page is not pinned, we can just update the entry
 271            directly */
 272         if (!page_pinned(ptr)) {
 273                 *ptr = val;
 274                 return;
 275         }
 276
 277         xen_set_pmd_hyper(ptr, val);
 278 }
 279
 280 /*
 281  * Associate a virtual page frame with a given physical page frame
 282  * and protection flags for that frame.
 283  */
 284 void set_pte_mfn(unsigned long vaddr, unsigned long mfn, pgprot_t flags)
 285 {
 286         set_pte_vaddr(vaddr, mfn_pte(mfn, flags));
 287 }
 288
 289 void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
 290                     pte_t *ptep, pte_t pteval)
 291 {
 292         /* updates to init_mm may be done without lock */
 293         if (mm == &init_mm)
 294                 preempt_disable();
 295
 296         if (mm == current->mm || mm == &init_mm) {
 297                 if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
 298                         struct multicall_space mcs;
 299                         mcs = xen_mc_entry(0);
 300
 301                         MULTI_update_va_mapping(mcs.mc, addr, pteval, 0);
 302                         xen_mc_issue(PARAVIRT_LAZY_MMU);
 303                         goto out;
 304                 } else
 305                         if (HYPERVISOR_update_va_mapping(addr, pteval, 0) == 0)
 306                                 goto out;
 307         }
 308         xen_set_pte(ptep, pteval);
 309
 310 out:
 311         if (mm == &init_mm)
 312                 preempt_enable();
 313 }
 314
 315 pte_t xen_ptep_modify_prot_start(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 316 {
 317         /* Just return the pte as-is.  We preserve the bits on commit */
 318         return *ptep;
 319 }
 320
 321 void xen_ptep_modify_prot_commit(struct mm_struct *mm, unsigned long addr,
 322                                  pte_t *ptep, pte_t pte)
 323 {
 324         struct mmu_update u;
 325
 326         xen_mc_batch();
 327
 328         u.ptr = virt_to_machine(ptep).maddr | MMU_PT_UPDATE_PRESERVE_AD;
 329         u.val = pte_val_ma(pte);
 330         extend_mmu_update(&u);
 331
 332         xen_mc_issue(PARAVIRT_LAZY_MMU);
 333 }
 334
 335 /* Assume pteval_t is equivalent to all the other *val_t types. */
 336 static pteval_t pte_mfn_to_pfn(pteval_t val)
 337 {
 338         if (val & _PAGE_PRESENT) {
 339                 unsigned long mfn = (val & PTE_MASK) >> PAGE_SHIFT;
 340                 pteval_t flags = val & ~PTE_MASK;
 341                 val = ((pteval_t)mfn_to_pfn(mfn) << PAGE_SHIFT) | flags;
 342         }
 343
 344         return val;
 345 }
 346
 347 static pteval_t pte_pfn_to_mfn(pteval_t val)
 348 {
 349         if (val & _PAGE_PRESENT) {
 350                 unsigned long pfn = (val & PTE_MASK) >> PAGE_SHIFT;
 351                 pteval_t flags = val & ~PTE_MASK;
 352                 val = ((pteval_t)pfn_to_mfn(pfn) << PAGE_SHIFT) | flags;
 353         }
 354
 355         return val;
 356 }
 357
 358 pteval_t xen_pte_val(pte_t pte)
 359 {
 360         return pte_mfn_to_pfn(pte.pte);
 361 }
 362
 363 pgdval_t xen_pgd_val(pgd_t pgd)
 364 {
 365         return pte_mfn_to_pfn(pgd.pgd);
 366 }
 367
 368 pte_t xen_make_pte(pteval_t pte)
 369 {
 370         pte = pte_pfn_to_mfn(pte);
 371         return native_make_pte(pte);
 372 }
 373
 374 pgd_t xen_make_pgd(pgdval_t pgd)
 375 {
 376         pgd = pte_pfn_to_mfn(pgd);
 377         return native_make_pgd(pgd);
 378 }
 379
 380 pmdval_t xen_pmd_val(pmd_t pmd)
 381 {
 382         return pte_mfn_to_pfn(pmd.pmd);
 383 }
 384
 385 void xen_set_pud_hyper(pud_t *ptr, pud_t val)
 386 {
 387         struct mmu_update u;
 388
 389         preempt_disable();
 390
 391         xen_mc_batch();
 392
 393         /* ptr may be ioremapped for 64-bit pagetable setup */
 394         u.ptr = arbitrary_virt_to_machine(ptr).maddr;
 395         u.val = pud_val_ma(val);
 396         extend_mmu_update(&u);
 397
 398         xen_mc_issue(PARAVIRT_LAZY_MMU);
 399
 400         preempt_enable();
 401 }
 402
 403 void xen_set_pud(pud_t *ptr, pud_t val)
 404 {
 405         /* If page is not pinned, we can just update the entry
 406            directly */
 407         if (!page_pinned(ptr)) {
 408                 *ptr = val;
 409                 return;
 410         }
 411
 412         xen_set_pud_hyper(ptr, val);
 413 }
 414
 415 void xen_set_pte(pte_t *ptep, pte_t pte)
 416 {
 417 #ifdef CONFIG_X86_PAE
 418         ptep->pte_high = pte.pte_high;
 419         smp_wmb();
 420         ptep->pte_low = pte.pte_low;
 421 #else
 422         *ptep = pte;
 423 #endif
 424 }
 425
 426 #ifdef CONFIG_X86_PAE
 427 void xen_set_pte_atomic(pte_t *ptep, pte_t pte)
 428 {
 429         set_64bit((u64 *)ptep, native_pte_val(pte));
 430 }
 431
 432 void xen_pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 433 {
 434         ptep->pte_low = 0;
 435         smp_wmb();              /* make sure low gets written first */
 436         ptep->pte_high = 0;
 437 }
 438
 439 void xen_pmd_clear(pmd_t *pmdp)
 440 {
 441         set_pmd(pmdp, __pmd(0));
 442 }
 443 #endif  /* CONFIG_X86_PAE */
 444
 445 pmd_t xen_make_pmd(pmdval_t pmd)
 446 {
 447         pmd = pte_pfn_to_mfn(pmd);
 448         return native_make_pmd(pmd);
 449 }
 450
 451 #if PAGETABLE_LEVELS == 4
 452 pudval_t xen_pud_val(pud_t pud)
 453 {
 454         return pte_mfn_to_pfn(pud.pud);
 455 }
 456
 457 pud_t xen_make_pud(pudval_t pud)
 458 {
 459         pud = pte_pfn_to_mfn(pud);
 460
 461         return native_make_pud(pud);
 462 }
 463
 464 void xen_set_pgd_hyper(pgd_t *ptr, pgd_t val)
 465 {
 466         struct mmu_update u;
 467
 468         preempt_disable();
 469
 470         xen_mc_batch();
 471
 472         u.ptr = virt_to_machine(ptr).maddr;
 473         u.val = pgd_val_ma(val);
 474         extend_mmu_update(&u);
 475
 476         xen_mc_issue(PARAVIRT_LAZY_MMU);
 477
 478         preempt_enable();
 479 }
 480
 481 void xen_set_pgd(pgd_t *ptr, pgd_t val)
 482 {
 483         /* If page is not pinned, we can just update the entry
 484            directly */
 485         if (!page_pinned(ptr)) {
 486                 *ptr = val;
 487                 return;
 488         }
 489
 490         xen_set_pgd_hyper(ptr, val);
 491 }
 492 #endif  /* PAGETABLE_LEVELS == 4 */
 493
 494 /*
 495  * (Yet another) pagetable walker.  This one is intended for pinning a
 496  * pagetable.  This means that it walks a pagetable and calls the
 497  * callback function on each page it finds making up the page table,
 498  * at every level.  It walks the entire pagetable, but it only bothers
 499  * pinning pte pages which are below limit.  In the normal case this
 500  * will be STACK_TOP_MAX, but at boot we need to pin up to
 501  * FIXADDR_TOP.
 502  *
 503  * For 32-bit the important bit is that we don't pin beyond there,
 504  * because then we start getting into Xen's ptes.
 505  *
 506  * For 64-bit, we must skip the Xen hole in the middle of the address
 507  * space, just after the big x86-64 virtual hole.
 508  */
 509 static int pgd_walk(pgd_t *pgd, int (*func)(struct page *, enum pt_level),
 510                     unsigned long limit)
 511 {
 512         int flush = 0;
 513         unsigned hole_low, hole_high;
 514         unsigned pgdidx_limit, pudidx_limit, pmdidx_limit;
 515         unsigned pgdidx, pudidx, pmdidx;
 516
 517         /* The limit is the last byte to be touched */
 518         limit--;
 519         BUG_ON(limit >= FIXADDR_TOP);
 520
 521         if (xen_feature(XENFEAT_auto_translated_physmap))
 522                 return 0;
 523
 524         /*
 525          * 64-bit has a great big hole in the middle of the address
 526          * space, which contains the Xen mappings.  On 32-bit these
 527          * will end up making a zero-sized hole and so is a no-op.
 528          */
 529         hole_low = pgd_index(STACK_TOP_MAX + PGDIR_SIZE - 1);
 530         hole_high = pgd_index(PAGE_OFFSET);
 531
 532         pgdidx_limit = pgd_index(limit);
 533 #if PTRS_PER_PUD > 1
 534         pudidx_limit = pud_index(limit);
 535 #else
 536         pudidx_limit = 0;
 537 #endif
 538 #if PTRS_PER_PMD > 1
 539         pmdidx_limit = pmd_index(limit);
 540 #else
 541         pmdidx_limit = 0;
 542 #endif
 543
 544         flush |= (*func)(virt_to_page(pgd), PT_PGD);
 545
 546         for (pgdidx = 0; pgdidx <= pgdidx_limit; pgdidx++) {
 547                 pud_t *pud;
 548
 549                 if (pgdidx >= hole_low && pgdidx < hole_high)
 550                         continue;
 551
 552                 if (!pgd_val(pgd[pgdidx]))
 553                         continue;
 554
 555                 pud = pud_offset(&pgd[pgdidx], 0);
 556
 557                 if (PTRS_PER_PUD > 1) /* not folded */
 558                         flush |= (*func)(virt_to_page(pud), PT_PUD);
 559
 560                 for (pudidx = 0; pudidx < PTRS_PER_PUD; pudidx++) {
 561                         pmd_t *pmd;
 562
 563                         if (pgdidx == pgdidx_limit &&
 564                             pudidx > pudidx_limit)
 565                                 goto out;
 566
 567                         if (pud_none(pud[pudidx]))
 568                                 continue;
 569
 570                         pmd = pmd_offset(&pud[pudidx], 0);
 571
 572                         if (PTRS_PER_PMD > 1) /* not folded */
 573                                 flush |= (*func)(virt_to_page(pmd), PT_PMD);
 574
 575                         for (pmdidx = 0; pmdidx < PTRS_PER_PMD; pmdidx++) {
 576                                 struct page *pte;
 577
 578                                 if (pgdidx == pgdidx_limit &&
 579                                     pudidx == pudidx_limit &&
 580                                     pmdidx > pmdidx_limit)
 581                                         goto out;
 582
 583                                 if (pmd_none(pmd[pmdidx]))
 584                                         continue;
 585
 586                                 pte = pmd_page(pmd[pmdidx]);
 587                                 flush |= (*func)(pte, PT_PTE);
 588                         }
 589                 }
 590         }
 591 out:
 592
 593         return flush;
 594 }
 595
 596 static spinlock_t *lock_pte(struct page *page)
 597 {
 598         spinlock_t *ptl = NULL;
 599
 600 #if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
 601         ptl = __pte_lockptr(page);
 602         spin_lock(ptl);
 603 #endif
 604
 605         return ptl;
 606 }
 607
 608 static void do_unlock(void *v)
 609 {
 610         spinlock_t *ptl = v;
 611         spin_unlock(ptl);
 612 }
 613
 614 static void xen_do_pin(unsigned level, unsigned long pfn)
 615 {
 616         struct mmuext_op *op;
 617         struct multicall_space mcs;
 618
 619         mcs = __xen_mc_entry(sizeof(*op));
 620         op = mcs.args;
 621         op->cmd = level;
 622         op->arg1.mfn = pfn_to_mfn(pfn);
 623         MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);
 624 }
 625
 626 static int pin_page(struct page *page, enum pt_level level)
 627 {
 628         unsigned pgfl = TestSetPagePinned(page);
 629         int flush;
 630
 631         if (pgfl)
 632                 flush = 0;              /* already pinned */
 633         else if (PageHighMem(page))
 634                 /* kmaps need flushing if we found an unpinned
 635                    highpage */
 636                 flush = 1;
 637         else {
 638                 void *pt = lowmem_page_address(page);
 639                 unsigned long pfn = page_to_pfn(page);
 640                 struct multicall_space mcs = __xen_mc_entry(0);
 641                 spinlock_t *ptl;
 642
 643                 flush = 0;
 644
 645                 ptl = NULL;
 646                 if (level == PT_PTE)
 647                         ptl = lock_pte(page);
 648
 649                 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
 650                                         pfn_pte(pfn, PAGE_KERNEL_RO),
 651                                         level == PT_PGD ? UVMF_TLB_FLUSH : 0);
 652
 653                 if (level == PT_PTE)
 654                         xen_do_pin(MMUEXT_PIN_L1_TABLE, pfn);
 655
 656                 if (ptl) {
 657                         /* Queue a deferred unlock for when this batch
 658                            is completed. */
 659                         xen_mc_callback(do_unlock, ptl);
 660                 }
 661         }
 662
 663         return flush;
 664 }
 665
 666 /* This is called just after a mm has been created, but it has not
 667    been used yet.  We need to make sure that its pagetable is all
 668    read-only, and can be pinned. */
 669 void xen_pgd_pin(pgd_t *pgd)
 670 {
 671         xen_mc_batch();
 672
 673         if (pgd_walk(pgd, pin_page, TASK_SIZE)) {
 674                 /* re-enable interrupts for kmap_flush_unused */
 675                 xen_mc_issue(0);
 676                 kmap_flush_unused();
 677                 xen_mc_batch();
 678         }
 679
 680 #ifdef CONFIG_X86_PAE
 681         /* Need to make sure unshared kernel PMD is pinnable */
 682         pin_page(virt_to_page(pgd_page(pgd[pgd_index(TASK_SIZE)])), PT_PMD);
 683 #endif
 684
 685         xen_do_pin(MMUEXT_PIN_L3_TABLE, PFN_DOWN(__pa(pgd)));
 686         xen_mc_issue(0);
 687 }
 688
 689 /*
 690  * On save, we need to pin all pagetables to make sure they get their
 691  * mfns turned into pfns.  Search the list for any unpinned pgds and pin
 692  * them (unpinned pgds are not currently in use, probably because the
 693  * process is under construction or destruction).
 694  */
 695 void xen_mm_pin_all(void)
 696 {
 697         unsigned long flags;
 698         struct page *page;
 699
 700         spin_lock_irqsave(&pgd_lock, flags);
 701
 702         list_for_each_entry(page, &pgd_list, lru) {
 703                 if (!PagePinned(page)) {
 704                         xen_pgd_pin((pgd_t *)page_address(page));
 705                         SetPageSavePinned(page);
 706                 }
 707         }
 708
 709         spin_unlock_irqrestore(&pgd_lock, flags);
 710 }
 711
 712 /*
 713  * The init_mm pagetable is really pinned as soon as its created, but
 714  * that's before we have page structures to store the bits.  So do all
 715  * the book-keeping now.
 716  */
 717 static __init int mark_pinned(struct page *page, enum pt_level level)
 718 {
 719         SetPagePinned(page);
 720         return 0;
 721 }
 722
 723 void __init xen_mark_init_mm_pinned(void)
 724 {
 725         pgd_walk(init_mm.pgd, mark_pinned, FIXADDR_TOP);
 726 }
 727
 728 static int unpin_page(struct page *page, enum pt_level level)
 729 {
 730         unsigned pgfl = TestClearPagePinned(page);
 731
 732         if (pgfl && !PageHighMem(page)) {
 733                 void *pt = lowmem_page_address(page);
 734                 unsigned long pfn = page_to_pfn(page);
 735                 spinlock_t *ptl = NULL;
 736                 struct multicall_space mcs;
 737
 738                 if (level == PT_PTE) {
 739                         ptl = lock_pte(page);
 740
 741                         xen_do_pin(MMUEXT_UNPIN_TABLE, pfn);
 742                 }
 743
 744                 mcs = __xen_mc_entry(0);
 745
 746                 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
 747                                         pfn_pte(pfn, PAGE_KERNEL),
 748                                         level == PT_PGD ? UVMF_TLB_FLUSH : 0);
 749
 750                 if (ptl) {
 751                         /* unlock when batch completed */
 752                         xen_mc_callback(do_unlock, ptl);
 753                 }
 754         }
 755
 756         return 0;               /* never need to flush on unpin */
 757 }
 758
 759 /* Release a pagetables pages back as normal RW */
 760 static void xen_pgd_unpin(pgd_t *pgd)
 761 {
 762         xen_mc_batch();
 763
 764         xen_do_pin(MMUEXT_UNPIN_TABLE, PFN_DOWN(__pa(pgd)));
 765
 766 #ifdef CONFIG_X86_PAE
 767         /* Need to make sure unshared kernel PMD is unpinned */
 768         pin_page(virt_to_page(pgd_page(pgd[pgd_index(TASK_SIZE)])), PT_PMD);
 769 #endif
 770         pgd_walk(pgd, unpin_page, TASK_SIZE);
 771
 772         xen_mc_issue(0);
 773 }
 774
 775 /*
 776  * On resume, undo any pinning done at save, so that the rest of the
 777  * kernel doesn't see any unexpected pinned pagetables.
 778  */
 779 void xen_mm_unpin_all(void)
 780 {
 781         unsigned long flags;
 782         struct page *page;
 783
 784         spin_lock_irqsave(&pgd_lock, flags);
 785
 786         list_for_each_entry(page, &pgd_list, lru) {
 787                 if (PageSavePinned(page)) {
 788                         BUG_ON(!PagePinned(page));
 789                         xen_pgd_unpin((pgd_t *)page_address(page));
 790                         ClearPageSavePinned(page);
 791                 }
 792         }
 793
 794         spin_unlock_irqrestore(&pgd_lock, flags);
 795 }
 796
 797 void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next)
 798 {
 799         spin_lock(&next->page_table_lock);
 800         xen_pgd_pin(next->pgd);
 801         spin_unlock(&next->page_table_lock);
 802 }
 803
 804 void xen_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
 805 {
 806         spin_lock(&mm->page_table_lock);
 807         xen_pgd_pin(mm->pgd);
 808         spin_unlock(&mm->page_table_lock);
 809 }
 810
 811
 812 #ifdef CONFIG_SMP
 813 /* Another cpu may still have their %cr3 pointing at the pagetable, so
 814    we need to repoint it somewhere else before we can unpin it. */
 815 static void drop_other_mm_ref(void *info)
 816 {
 817         struct mm_struct *mm = info;
 818         struct mm_struct *active_mm;
 819
 820 #ifdef CONFIG_X86_64
 821         active_mm = read_pda(active_mm);
 822 #else
 823         active_mm = __get_cpu_var(cpu_tlbstate).active_mm;
 824 #endif
 825
 826         if (active_mm == mm)
 827                 leave_mm(smp_processor_id());
 828
 829         /* If this cpu still has a stale cr3 reference, then make sure
 830            it has been flushed. */
 831         if (x86_read_percpu(xen_current_cr3) == __pa(mm->pgd)) {
 832                 load_cr3(swapper_pg_dir);
 833                 arch_flush_lazy_cpu_mode();
 834         }
 835 }
 836
 837 static void drop_mm_ref(struct mm_struct *mm)
 838 {
 839         cpumask_t mask;
 840         unsigned cpu;
 841
 842         if (current->active_mm == mm) {
 843                 if (current->mm == mm)
 844                         load_cr3(swapper_pg_dir);
 845                 else
 846                         leave_mm(smp_processor_id());
 847                 arch_flush_lazy_cpu_mode();
 848         }
 849
 850         /* Get the "official" set of cpus referring to our pagetable. */
 851         mask = mm->cpu_vm_mask;
 852
 853         /* It's possible that a vcpu may have a stale reference to our
 854            cr3, because its in lazy mode, and it hasn't yet flushed
 855            its set of pending hypercalls yet.  In this case, we can
 856            look at its actual current cr3 value, and force it to flush
 857            if needed. */
 858         for_each_online_cpu(cpu) {
 859                 if (per_cpu(xen_current_cr3, cpu) == __pa(mm->pgd))
 860                         cpu_set(cpu, mask);
 861         }
 862
 863         if (!cpus_empty(mask))
 864                 smp_call_function_mask(mask, drop_other_mm_ref, mm, 1);
 865 }
 866 #else
 867 static void drop_mm_ref(struct mm_struct *mm)
 868 {
 869         if (current->active_mm == mm)
 870                 load_cr3(swapper_pg_dir);
 871 }
 872 #endif
 873
 874 /*
 875  * While a process runs, Xen pins its pagetables, which means that the
 876  * hypervisor forces it to be read-only, and it controls all updates
 877  * to it.  This means that all pagetable updates have to go via the
 878  * hypervisor, which is moderately expensive.
 879  *
 880  * Since we're pulling the pagetable down, we switch to use init_mm,
 881  * unpin old process pagetable and mark it all read-write, which
 882  * allows further operations on it to be simple memory accesses.
 883  *
 884  * The only subtle point is that another CPU may be still using the
 885  * pagetable because of lazy tlb flushing.  This means we need need to
 886  * switch all CPUs off this pagetable before we can unpin it.
 887  */
 888 void xen_exit_mmap(struct mm_struct *mm)
 889 {
 890         get_cpu();              /* make sure we don't move around */
 891         drop_mm_ref(mm);
 892         put_cpu();
 893
 894         spin_lock(&mm->page_table_lock);
 895
 896         /* pgd may not be pinned in the error exit path of execve */
 897         if (page_pinned(mm->pgd))
 898                 xen_pgd_unpin(mm->pgd);
 899
 900         spin_unlock(&mm->page_table_lock);
 901 }