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