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