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 void xen_set_pmd_hyper(pmd_t *ptr, pmd_t val)
 234 {
 235         struct multicall_space mcs;
 236         struct mmu_update *u;
 237
 238         preempt_disable();
 239
 240         mcs = xen_mc_entry(sizeof(*u));
 241         u = mcs.args;
 242         u->ptr = virt_to_machine(ptr).maddr;
 243         u->val = pmd_val_ma(val);
 244         MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
 245
 246         xen_mc_issue(PARAVIRT_LAZY_MMU);
 247
 248         preempt_enable();
 249 }
 250
 251 void xen_set_pmd(pmd_t *ptr, pmd_t val)
 252 {
 253         /* If page is not pinned, we can just update the entry
 254            directly */
 255         if (!page_pinned(ptr)) {
 256                 *ptr = val;
 257                 return;
 258         }
 259
 260         xen_set_pmd_hyper(ptr, val);
 261 }
 262
 263 /*
 264  * Associate a virtual page frame with a given physical page frame
 265  * and protection flags for that frame.
 266  */
 267 void set_pte_mfn(unsigned long vaddr, unsigned long mfn, pgprot_t flags)
 268 {
 269         pgd_t *pgd;
 270         pud_t *pud;
 271         pmd_t *pmd;
 272         pte_t *pte;
 273
 274         pgd = swapper_pg_dir + pgd_index(vaddr);
 275         if (pgd_none(*pgd)) {
 276                 BUG();
 277                 return;
 278         }
 279         pud = pud_offset(pgd, vaddr);
 280         if (pud_none(*pud)) {
 281                 BUG();
 282                 return;
 283         }
 284         pmd = pmd_offset(pud, vaddr);
 285         if (pmd_none(*pmd)) {
 286                 BUG();
 287                 return;
 288         }
 289         pte = pte_offset_kernel(pmd, vaddr);
 290         /* <mfn,flags> stored as-is, to permit clearing entries */
 291         xen_set_pte(pte, mfn_pte(mfn, flags));
 292
 293         /*
 294          * It's enough to flush this one mapping.
 295          * (PGE mappings get flushed as well)
 296          */
 297         __flush_tlb_one(vaddr);
 298 }
 299
 300 void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
 301                     pte_t *ptep, pte_t pteval)
 302 {
 303         /* updates to init_mm may be done without lock */
 304         if (mm == &init_mm)
 305                 preempt_disable();
 306
 307         if (mm == current->mm || mm == &init_mm) {
 308                 if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
 309                         struct multicall_space mcs;
 310                         mcs = xen_mc_entry(0);
 311
 312                         MULTI_update_va_mapping(mcs.mc, addr, pteval, 0);
 313                         xen_mc_issue(PARAVIRT_LAZY_MMU);
 314                         goto out;
 315                 } else
 316                         if (HYPERVISOR_update_va_mapping(addr, pteval, 0) == 0)
 317                                 goto out;
 318         }
 319         xen_set_pte(ptep, pteval);
 320
 321 out:
 322         if (mm == &init_mm)
 323                 preempt_enable();
 324 }
 325
 326 pte_t xen_ptep_modify_prot_start(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 327 {
 328         /* Just return the pte as-is.  We preserve the bits on commit */
 329         return *ptep;
 330 }
 331
 332 void xen_ptep_modify_prot_commit(struct mm_struct *mm, unsigned long addr,
 333                                  pte_t *ptep, pte_t pte)
 334 {
 335         struct multicall_space mcs;
 336         struct mmu_update *u;
 337
 338         mcs = xen_mc_entry(sizeof(*u));
 339         u = mcs.args;
 340         u->ptr = virt_to_machine(ptep).maddr | MMU_PT_UPDATE_PRESERVE_AD;
 341         u->val = pte_val_ma(pte);
 342         MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
 343
 344         xen_mc_issue(PARAVIRT_LAZY_MMU);
 345 }
 346
 347 /* Assume pteval_t is equivalent to all the other *val_t types. */
 348 static pteval_t pte_mfn_to_pfn(pteval_t val)
 349 {
 350         if (val & _PAGE_PRESENT) {
 351                 unsigned long mfn = (val & PTE_MASK) >> PAGE_SHIFT;
 352                 pteval_t flags = val & ~PTE_MASK;
 353                 val = (mfn_to_pfn(mfn) << PAGE_SHIFT) | flags;
 354         }
 355
 356         return val;
 357 }
 358
 359 static pteval_t pte_pfn_to_mfn(pteval_t val)
 360 {
 361         if (val & _PAGE_PRESENT) {
 362                 unsigned long pfn = (val & PTE_MASK) >> PAGE_SHIFT;
 363                 pteval_t flags = val & ~PTE_MASK;
 364                 val = (pfn_to_mfn(pfn) << PAGE_SHIFT) | flags;
 365         }
 366
 367         return val;
 368 }
 369
 370 pteval_t xen_pte_val(pte_t pte)
 371 {
 372         return pte_mfn_to_pfn(pte.pte);
 373 }
 374
 375 pgdval_t xen_pgd_val(pgd_t pgd)
 376 {
 377         return pte_mfn_to_pfn(pgd.pgd);
 378 }
 379
 380 pte_t xen_make_pte(pteval_t pte)
 381 {
 382         pte = pte_pfn_to_mfn(pte);
 383         return native_make_pte(pte);
 384 }
 385
 386 pgd_t xen_make_pgd(pgdval_t pgd)
 387 {
 388         pgd = pte_pfn_to_mfn(pgd);
 389         return native_make_pgd(pgd);
 390 }
 391
 392 pmdval_t xen_pmd_val(pmd_t pmd)
 393 {
 394         return pte_mfn_to_pfn(pmd.pmd);
 395 }
 396
 397 void xen_set_pud_hyper(pud_t *ptr, pud_t val)
 398 {
 399         struct multicall_space mcs;
 400         struct mmu_update *u;
 401
 402         preempt_disable();
 403
 404         mcs = xen_mc_entry(sizeof(*u));
 405         u = mcs.args;
 406         u->ptr = virt_to_machine(ptr).maddr;
 407         u->val = pud_val_ma(val);
 408         MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
 409
 410         xen_mc_issue(PARAVIRT_LAZY_MMU);
 411
 412         preempt_enable();
 413 }
 414
 415 void xen_set_pud(pud_t *ptr, pud_t val)
 416 {
 417         /* If page is not pinned, we can just update the entry
 418            directly */
 419         if (!page_pinned(ptr)) {
 420                 *ptr = val;
 421                 return;
 422         }
 423
 424         xen_set_pud_hyper(ptr, val);
 425 }
 426
 427 void xen_set_pte(pte_t *ptep, pte_t pte)
 428 {
 429         ptep->pte_high = pte.pte_high;
 430         smp_wmb();
 431         ptep->pte_low = pte.pte_low;
 432 }
 433
 434 void xen_set_pte_atomic(pte_t *ptep, pte_t pte)
 435 {
 436         set_64bit((u64 *)ptep, pte_val_ma(pte));
 437 }
 438
 439 void xen_pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 440 {
 441         ptep->pte_low = 0;
 442         smp_wmb();              /* make sure low gets written first */
 443         ptep->pte_high = 0;
 444 }
 445
 446 void xen_pmd_clear(pmd_t *pmdp)
 447 {
 448         set_pmd(pmdp, __pmd(0));
 449 }
 450
 451 pmd_t xen_make_pmd(pmdval_t pmd)
 452 {
 453         pmd = pte_pfn_to_mfn(pmd);
 454         return native_make_pmd(pmd);
 455 }
 456
 457 /*
 458   (Yet another) pagetable walker.  This one is intended for pinning a
 459   pagetable.  This means that it walks a pagetable and calls the
 460   callback function on each page it finds making up the page table,
 461   at every level.  It walks the entire pagetable, but it only bothers
 462   pinning pte pages which are below pte_limit.  In the normal case
 463   this will be TASK_SIZE, but at boot we need to pin up to
 464   FIXADDR_TOP.  But the important bit is that we don't pin beyond
 465   there, because then we start getting into Xen's ptes.
 466 */
 467 static int pgd_walk(pgd_t *pgd_base, int (*func)(struct page *, enum pt_level),
 468                     unsigned long limit)
 469 {
 470         pgd_t *pgd = pgd_base;
 471         int flush = 0;
 472         unsigned long addr = 0;
 473         unsigned long pgd_next;
 474
 475         BUG_ON(limit > FIXADDR_TOP);
 476
 477         if (xen_feature(XENFEAT_auto_translated_physmap))
 478                 return 0;
 479
 480         for (; addr != FIXADDR_TOP; pgd++, addr = pgd_next) {
 481                 pud_t *pud;
 482                 unsigned long pud_limit, pud_next;
 483
 484                 pgd_next = pud_limit = pgd_addr_end(addr, FIXADDR_TOP);
 485
 486                 if (!pgd_val(*pgd))
 487                         continue;
 488
 489                 pud = pud_offset(pgd, 0);
 490
 491                 if (PTRS_PER_PUD > 1) /* not folded */
 492                         flush |= (*func)(virt_to_page(pud), PT_PUD);
 493
 494                 for (; addr != pud_limit; pud++, addr = pud_next) {
 495                         pmd_t *pmd;
 496                         unsigned long pmd_limit;
 497
 498                         pud_next = pud_addr_end(addr, pud_limit);
 499
 500                         if (pud_next < limit)
 501                                 pmd_limit = pud_next;
 502                         else
 503                                 pmd_limit = limit;
 504
 505                         if (pud_none(*pud))
 506                                 continue;
 507
 508                         pmd = pmd_offset(pud, 0);
 509
 510                         if (PTRS_PER_PMD > 1) /* not folded */
 511                                 flush |= (*func)(virt_to_page(pmd), PT_PMD);
 512
 513                         for (; addr != pmd_limit; pmd++) {
 514                                 addr += (PAGE_SIZE * PTRS_PER_PTE);
 515                                 if ((pmd_limit-1) < (addr-1)) {
 516                                         addr = pmd_limit;
 517                                         break;
 518                                 }
 519
 520                                 if (pmd_none(*pmd))
 521                                         continue;
 522
 523                                 flush |= (*func)(pmd_page(*pmd), PT_PTE);
 524                         }
 525                 }
 526         }
 527
 528         flush |= (*func)(virt_to_page(pgd_base), PT_PGD);
 529
 530         return flush;
 531 }
 532
 533 static spinlock_t *lock_pte(struct page *page)
 534 {
 535         spinlock_t *ptl = NULL;
 536
 537 #if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
 538         ptl = __pte_lockptr(page);
 539         spin_lock(ptl);
 540 #endif
 541
 542         return ptl;
 543 }
 544
 545 static void do_unlock(void *v)
 546 {
 547         spinlock_t *ptl = v;
 548         spin_unlock(ptl);
 549 }
 550
 551 static void xen_do_pin(unsigned level, unsigned long pfn)
 552 {
 553         struct mmuext_op *op;
 554         struct multicall_space mcs;
 555
 556         mcs = __xen_mc_entry(sizeof(*op));
 557         op = mcs.args;
 558         op->cmd = level;
 559         op->arg1.mfn = pfn_to_mfn(pfn);
 560         MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);
 561 }
 562
 563 static int pin_page(struct page *page, enum pt_level level)
 564 {
 565         unsigned pgfl = TestSetPagePinned(page);
 566         int flush;
 567
 568         if (pgfl)
 569                 flush = 0;              /* already pinned */
 570         else if (PageHighMem(page))
 571                 /* kmaps need flushing if we found an unpinned
 572                    highpage */
 573                 flush = 1;
 574         else {
 575                 void *pt = lowmem_page_address(page);
 576                 unsigned long pfn = page_to_pfn(page);
 577                 struct multicall_space mcs = __xen_mc_entry(0);
 578                 spinlock_t *ptl;
 579
 580                 flush = 0;
 581
 582                 ptl = NULL;
 583                 if (level == PT_PTE)
 584                         ptl = lock_pte(page);
 585
 586                 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
 587                                         pfn_pte(pfn, PAGE_KERNEL_RO),
 588                                         level == PT_PGD ? UVMF_TLB_FLUSH : 0);
 589
 590                 if (level == PT_PTE)
 591                         xen_do_pin(MMUEXT_PIN_L1_TABLE, pfn);
 592
 593                 if (ptl) {
 594                         /* Queue a deferred unlock for when this batch
 595                            is completed. */
 596                         xen_mc_callback(do_unlock, ptl);
 597                 }
 598         }
 599
 600         return flush;
 601 }
 602
 603 /* This is called just after a mm has been created, but it has not
 604    been used yet.  We need to make sure that its pagetable is all
 605    read-only, and can be pinned. */
 606 void xen_pgd_pin(pgd_t *pgd)
 607 {
 608         xen_mc_batch();
 609
 610         if (pgd_walk(pgd, pin_page, TASK_SIZE)) {
 611                 /* re-enable interrupts for kmap_flush_unused */
 612                 xen_mc_issue(0);
 613                 kmap_flush_unused();
 614                 xen_mc_batch();
 615         }
 616
 617         xen_do_pin(MMUEXT_PIN_L3_TABLE, PFN_DOWN(__pa(pgd)));
 618         xen_mc_issue(0);
 619 }
 620
 621 /*
 622  * On save, we need to pin all pagetables to make sure they get their
 623  * mfns turned into pfns.  Search the list for any unpinned pgds and pin
 624  * them (unpinned pgds are not currently in use, probably because the
 625  * process is under construction or destruction).
 626  */
 627 void xen_mm_pin_all(void)
 628 {
 629         unsigned long flags;
 630         struct page *page;
 631
 632         spin_lock_irqsave(&pgd_lock, flags);
 633
 634         list_for_each_entry(page, &pgd_list, lru) {
 635                 if (!PagePinned(page)) {
 636                         xen_pgd_pin((pgd_t *)page_address(page));
 637                         SetPageSavePinned(page);
 638                 }
 639         }
 640
 641         spin_unlock_irqrestore(&pgd_lock, flags);
 642 }
 643
 644 /* The init_mm pagetable is really pinned as soon as its created, but
 645    that's before we have page structures to store the bits.  So do all
 646    the book-keeping now. */
 647 static __init int mark_pinned(struct page *page, enum pt_level level)
 648 {
 649         SetPagePinned(page);
 650         return 0;
 651 }
 652
 653 void __init xen_mark_init_mm_pinned(void)
 654 {
 655         pgd_walk(init_mm.pgd, mark_pinned, FIXADDR_TOP);
 656 }
 657
 658 static int unpin_page(struct page *page, enum pt_level level)
 659 {
 660         unsigned pgfl = TestClearPagePinned(page);
 661
 662         if (pgfl && !PageHighMem(page)) {
 663                 void *pt = lowmem_page_address(page);
 664                 unsigned long pfn = page_to_pfn(page);
 665                 spinlock_t *ptl = NULL;
 666                 struct multicall_space mcs;
 667
 668                 if (level == PT_PTE) {
 669                         ptl = lock_pte(page);
 670
 671                         xen_do_pin(MMUEXT_UNPIN_TABLE, pfn);
 672                 }
 673
 674                 mcs = __xen_mc_entry(0);
 675
 676                 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
 677                                         pfn_pte(pfn, PAGE_KERNEL),
 678                                         level == PT_PGD ? UVMF_TLB_FLUSH : 0);
 679
 680                 if (ptl) {
 681                         /* unlock when batch completed */
 682                         xen_mc_callback(do_unlock, ptl);
 683                 }
 684         }
 685
 686         return 0;               /* never need to flush on unpin */
 687 }
 688
 689 /* Release a pagetables pages back as normal RW */
 690 static void xen_pgd_unpin(pgd_t *pgd)
 691 {
 692         xen_mc_batch();
 693
 694         xen_do_pin(MMUEXT_UNPIN_TABLE, PFN_DOWN(__pa(pgd)));
 695
 696         pgd_walk(pgd, unpin_page, TASK_SIZE);
 697
 698         xen_mc_issue(0);
 699 }
 700
 701 /*
 702  * On resume, undo any pinning done at save, so that the rest of the
 703  * kernel doesn't see any unexpected pinned pagetables.
 704  */
 705 void xen_mm_unpin_all(void)
 706 {
 707         unsigned long flags;
 708         struct page *page;
 709
 710         spin_lock_irqsave(&pgd_lock, flags);
 711
 712         list_for_each_entry(page, &pgd_list, lru) {
 713                 if (PageSavePinned(page)) {
 714                         BUG_ON(!PagePinned(page));
 715                         printk("unpinning pinned %p\n", page_address(page));
 716                         xen_pgd_unpin((pgd_t *)page_address(page));
 717                         ClearPageSavePinned(page);
 718                 }
 719         }
 720
 721         spin_unlock_irqrestore(&pgd_lock, flags);
 722 }
 723
 724 void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next)
 725 {
 726         spin_lock(&next->page_table_lock);
 727         xen_pgd_pin(next->pgd);
 728         spin_unlock(&next->page_table_lock);
 729 }
 730
 731 void xen_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
 732 {
 733         spin_lock(&mm->page_table_lock);
 734         xen_pgd_pin(mm->pgd);
 735         spin_unlock(&mm->page_table_lock);
 736 }
 737
 738
 739 #ifdef CONFIG_SMP
 740 /* Another cpu may still have their %cr3 pointing at the pagetable, so
 741    we need to repoint it somewhere else before we can unpin it. */
 742 static void drop_other_mm_ref(void *info)
 743 {
 744         struct mm_struct *mm = info;
 745
 746         if (__get_cpu_var(cpu_tlbstate).active_mm == mm)
 747                 leave_mm(smp_processor_id());
 748
 749         /* If this cpu still has a stale cr3 reference, then make sure
 750            it has been flushed. */
 751         if (x86_read_percpu(xen_current_cr3) == __pa(mm->pgd)) {
 752                 load_cr3(swapper_pg_dir);
 753                 arch_flush_lazy_cpu_mode();
 754         }
 755 }
 756
 757 static void drop_mm_ref(struct mm_struct *mm)
 758 {
 759         cpumask_t mask;
 760         unsigned cpu;
 761
 762         if (current->active_mm == mm) {
 763                 if (current->mm == mm)
 764                         load_cr3(swapper_pg_dir);
 765                 else
 766                         leave_mm(smp_processor_id());
 767                 arch_flush_lazy_cpu_mode();
 768         }
 769
 770         /* Get the "official" set of cpus referring to our pagetable. */
 771         mask = mm->cpu_vm_mask;
 772
 773         /* It's possible that a vcpu may have a stale reference to our
 774            cr3, because its in lazy mode, and it hasn't yet flushed
 775            its set of pending hypercalls yet.  In this case, we can
 776            look at its actual current cr3 value, and force it to flush
 777            if needed. */
 778         for_each_online_cpu(cpu) {
 779                 if (per_cpu(xen_current_cr3, cpu) == __pa(mm->pgd))
 780                         cpu_set(cpu, mask);
 781         }
 782
 783         if (!cpus_empty(mask))
 784                 xen_smp_call_function_mask(mask, drop_other_mm_ref, mm, 1);
 785 }
 786 #else
 787 static void drop_mm_ref(struct mm_struct *mm)
 788 {
 789         if (current->active_mm == mm)
 790                 load_cr3(swapper_pg_dir);
 791 }
 792 #endif
 793
 794 /*
 795  * While a process runs, Xen pins its pagetables, which means that the
 796  * hypervisor forces it to be read-only, and it controls all updates
 797  * to it.  This means that all pagetable updates have to go via the
 798  * hypervisor, which is moderately expensive.
 799  *
 800  * Since we're pulling the pagetable down, we switch to use init_mm,
 801  * unpin old process pagetable and mark it all read-write, which
 802  * allows further operations on it to be simple memory accesses.
 803  *
 804  * The only subtle point is that another CPU may be still using the
 805  * pagetable because of lazy tlb flushing.  This means we need need to
 806  * switch all CPUs off this pagetable before we can unpin it.
 807  */
 808 void xen_exit_mmap(struct mm_struct *mm)
 809 {
 810         get_cpu();              /* make sure we don't move around */
 811         drop_mm_ref(mm);
 812         put_cpu();
 813
 814         spin_lock(&mm->page_table_lock);
 815
 816         /* pgd may not be pinned in the error exit path of execve */
 817         if (page_pinned(mm->pgd))
 818                 xen_pgd_unpin(mm->pgd);
 819
 820         spin_unlock(&mm->page_table_lock);
 821 }