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.
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.
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
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.
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
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.
39 * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
41 #include <linux/sched.h>
42 #include <linux/highmem.h>
43 #include <linux/bug.h>
45 #include <asm/pgtable.h>
46 #include <asm/tlbflush.h>
47 #include <asm/mmu_context.h>
48 #include <asm/paravirt.h>
50 #include <asm/xen/hypercall.h>
51 #include <asm/xen/hypervisor.h>
54 #include <xen/interface/xen.h>
56 #include "multicalls.h"
60 * This should probably be a config option. On 32-bit, it costs 1
61 * page/gig of memory; on 64-bit its 2 pages/gig. If we want it to be
62 * completely unbounded we can add another level to the p2m structure.
64 #define MAX_GUEST_PAGES (16ull * 1024*1024*1024 / PAGE_SIZE)
65 #define P2M_ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(unsigned long))
67 static unsigned long *p2m_top[MAX_GUEST_PAGES / P2M_ENTRIES_PER_PAGE];
69 static inline unsigned p2m_top_index(unsigned long pfn)
71 BUG_ON(pfn >= MAX_GUEST_PAGES);
72 return pfn / P2M_ENTRIES_PER_PAGE;
75 static inline unsigned p2m_index(unsigned long pfn)
77 return pfn % P2M_ENTRIES_PER_PAGE;
80 void __init xen_build_dynamic_phys_to_machine(void)
83 unsigned long *mfn_list = (unsigned long *)xen_start_info->mfn_list;
85 BUG_ON(xen_start_info->nr_pages >= MAX_GUEST_PAGES);
88 pfn < xen_start_info->nr_pages;
89 pfn += P2M_ENTRIES_PER_PAGE) {
90 unsigned topidx = p2m_top_index(pfn);
92 p2m_top[topidx] = &mfn_list[pfn];
96 unsigned long get_phys_to_machine(unsigned long pfn)
100 topidx = p2m_top_index(pfn);
101 if (p2m_top[topidx] == NULL)
102 return INVALID_P2M_ENTRY;
104 idx = p2m_index(pfn);
105 return p2m_top[topidx][idx];
108 static void alloc_p2m(unsigned long **pp)
113 p = (void *)__get_free_page(GFP_KERNEL | __GFP_NOFAIL);
116 for(i = 0; i < P2M_ENTRIES_PER_PAGE; i++)
117 p[i] = INVALID_P2M_ENTRY;
119 if (cmpxchg(pp, NULL, p) != NULL)
120 free_page((unsigned long)p);
123 void set_phys_to_machine(unsigned long pfn, unsigned long mfn)
125 unsigned topidx, idx;
127 if (unlikely(xen_feature(XENFEAT_auto_translated_physmap))) {
128 BUG_ON(pfn != mfn && mfn != INVALID_P2M_ENTRY);
132 topidx = p2m_top_index(pfn);
133 if (p2m_top[topidx] == NULL) {
134 /* no need to allocate a page to store an invalid entry */
135 if (mfn == INVALID_P2M_ENTRY)
137 alloc_p2m(&p2m_top[topidx]);
140 idx = p2m_index(pfn);
141 p2m_top[topidx][idx] = mfn;
144 xmaddr_t arbitrary_virt_to_machine(unsigned long address)
147 pte_t *pte = lookup_address(address, &level);
148 unsigned offset = address & PAGE_MASK;
152 return XMADDR((pte_mfn(*pte) << PAGE_SHIFT) + offset);
155 void make_lowmem_page_readonly(void *vaddr)
158 unsigned long address = (unsigned long)vaddr;
161 pte = lookup_address(address, &level);
164 ptev = pte_wrprotect(*pte);
166 if (HYPERVISOR_update_va_mapping(address, ptev, 0))
170 void make_lowmem_page_readwrite(void *vaddr)
173 unsigned long address = (unsigned long)vaddr;
176 pte = lookup_address(address, &level);
179 ptev = pte_mkwrite(*pte);
181 if (HYPERVISOR_update_va_mapping(address, ptev, 0))
186 void xen_set_pmd(pmd_t *ptr, pmd_t val)
188 struct multicall_space mcs;
189 struct mmu_update *u;
193 mcs = xen_mc_entry(sizeof(*u));
195 u->ptr = virt_to_machine(ptr).maddr;
196 u->val = pmd_val_ma(val);
197 MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
199 xen_mc_issue(PARAVIRT_LAZY_MMU);
205 * Associate a virtual page frame with a given physical page frame
206 * and protection flags for that frame.
208 void set_pte_mfn(unsigned long vaddr, unsigned long mfn, pgprot_t flags)
215 pgd = swapper_pg_dir + pgd_index(vaddr);
216 if (pgd_none(*pgd)) {
220 pud = pud_offset(pgd, vaddr);
221 if (pud_none(*pud)) {
225 pmd = pmd_offset(pud, vaddr);
226 if (pmd_none(*pmd)) {
230 pte = pte_offset_kernel(pmd, vaddr);
231 /* <mfn,flags> stored as-is, to permit clearing entries */
232 xen_set_pte(pte, mfn_pte(mfn, flags));
235 * It's enough to flush this one mapping.
236 * (PGE mappings get flushed as well)
238 __flush_tlb_one(vaddr);
241 void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
242 pte_t *ptep, pte_t pteval)
244 /* updates to init_mm may be done without lock */
248 if (mm == current->mm || mm == &init_mm) {
249 if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
250 struct multicall_space mcs;
251 mcs = xen_mc_entry(0);
253 MULTI_update_va_mapping(mcs.mc, addr, pteval, 0);
254 xen_mc_issue(PARAVIRT_LAZY_MMU);
257 if (HYPERVISOR_update_va_mapping(addr, pteval, 0) == 0)
260 xen_set_pte(ptep, pteval);
267 pteval_t xen_pte_val(pte_t pte)
269 pteval_t ret = pte.pte;
271 if (ret & _PAGE_PRESENT)
272 ret = machine_to_phys(XMADDR(ret)).paddr | _PAGE_PRESENT;
277 pgdval_t xen_pgd_val(pgd_t pgd)
279 pgdval_t ret = pgd.pgd;
280 if (ret & _PAGE_PRESENT)
281 ret = machine_to_phys(XMADDR(ret)).paddr | _PAGE_PRESENT;
285 pte_t xen_make_pte(pteval_t pte)
287 if (pte & _PAGE_PRESENT) {
288 pte = phys_to_machine(XPADDR(pte)).maddr;
289 pte &= ~(_PAGE_PCD | _PAGE_PWT);
292 return (pte_t){ .pte = pte };
295 pgd_t xen_make_pgd(pgdval_t pgd)
297 if (pgd & _PAGE_PRESENT)
298 pgd = phys_to_machine(XPADDR(pgd)).maddr;
300 return (pgd_t){ pgd };
303 pmdval_t xen_pmd_val(pmd_t pmd)
305 pmdval_t ret = native_pmd_val(pmd);
306 if (ret & _PAGE_PRESENT)
307 ret = machine_to_phys(XMADDR(ret)).paddr | _PAGE_PRESENT;
311 void xen_set_pud(pud_t *ptr, pud_t val)
313 struct multicall_space mcs;
314 struct mmu_update *u;
318 mcs = xen_mc_entry(sizeof(*u));
320 u->ptr = virt_to_machine(ptr).maddr;
321 u->val = pud_val_ma(val);
322 MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
324 xen_mc_issue(PARAVIRT_LAZY_MMU);
329 void xen_set_pte(pte_t *ptep, pte_t pte)
331 ptep->pte_high = pte.pte_high;
333 ptep->pte_low = pte.pte_low;
336 void xen_set_pte_atomic(pte_t *ptep, pte_t pte)
338 set_64bit((u64 *)ptep, pte_val_ma(pte));
341 void xen_pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
344 smp_wmb(); /* make sure low gets written first */
348 void xen_pmd_clear(pmd_t *pmdp)
350 xen_set_pmd(pmdp, __pmd(0));
353 pmd_t xen_make_pmd(pmdval_t pmd)
355 if (pmd & _PAGE_PRESENT)
356 pmd = phys_to_machine(XPADDR(pmd)).maddr;
358 return native_make_pmd(pmd);
362 (Yet another) pagetable walker. This one is intended for pinning a
363 pagetable. This means that it walks a pagetable and calls the
364 callback function on each page it finds making up the page table,
365 at every level. It walks the entire pagetable, but it only bothers
366 pinning pte pages which are below pte_limit. In the normal case
367 this will be TASK_SIZE, but at boot we need to pin up to
368 FIXADDR_TOP. But the important bit is that we don't pin beyond
369 there, because then we start getting into Xen's ptes.
371 static int pgd_walk(pgd_t *pgd_base, int (*func)(struct page *, enum pt_level),
374 pgd_t *pgd = pgd_base;
376 unsigned long addr = 0;
377 unsigned long pgd_next;
379 BUG_ON(limit > FIXADDR_TOP);
381 if (xen_feature(XENFEAT_auto_translated_physmap))
384 for (; addr != FIXADDR_TOP; pgd++, addr = pgd_next) {
386 unsigned long pud_limit, pud_next;
388 pgd_next = pud_limit = pgd_addr_end(addr, FIXADDR_TOP);
393 pud = pud_offset(pgd, 0);
395 if (PTRS_PER_PUD > 1) /* not folded */
396 flush |= (*func)(virt_to_page(pud), PT_PUD);
398 for (; addr != pud_limit; pud++, addr = pud_next) {
400 unsigned long pmd_limit;
402 pud_next = pud_addr_end(addr, pud_limit);
404 if (pud_next < limit)
405 pmd_limit = pud_next;
412 pmd = pmd_offset(pud, 0);
414 if (PTRS_PER_PMD > 1) /* not folded */
415 flush |= (*func)(virt_to_page(pmd), PT_PMD);
417 for (; addr != pmd_limit; pmd++) {
418 addr += (PAGE_SIZE * PTRS_PER_PTE);
419 if ((pmd_limit-1) < (addr-1)) {
427 flush |= (*func)(pmd_page(*pmd), PT_PTE);
432 flush |= (*func)(virt_to_page(pgd_base), PT_PGD);
437 static spinlock_t *lock_pte(struct page *page)
439 spinlock_t *ptl = NULL;
441 #if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
442 ptl = __pte_lockptr(page);
449 static void do_unlock(void *v)
455 static void xen_do_pin(unsigned level, unsigned long pfn)
457 struct mmuext_op *op;
458 struct multicall_space mcs;
460 mcs = __xen_mc_entry(sizeof(*op));
463 op->arg1.mfn = pfn_to_mfn(pfn);
464 MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);
467 static int pin_page(struct page *page, enum pt_level level)
469 unsigned pgfl = TestSetPagePinned(page);
473 flush = 0; /* already pinned */
474 else if (PageHighMem(page))
475 /* kmaps need flushing if we found an unpinned
479 void *pt = lowmem_page_address(page);
480 unsigned long pfn = page_to_pfn(page);
481 struct multicall_space mcs = __xen_mc_entry(0);
488 ptl = lock_pte(page);
490 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
491 pfn_pte(pfn, PAGE_KERNEL_RO),
492 level == PT_PGD ? UVMF_TLB_FLUSH : 0);
495 xen_do_pin(MMUEXT_PIN_L1_TABLE, pfn);
498 /* Queue a deferred unlock for when this batch
500 xen_mc_callback(do_unlock, ptl);
507 /* This is called just after a mm has been created, but it has not
508 been used yet. We need to make sure that its pagetable is all
509 read-only, and can be pinned. */
510 void xen_pgd_pin(pgd_t *pgd)
514 if (pgd_walk(pgd, pin_page, TASK_SIZE)) {
515 /* re-enable interrupts for kmap_flush_unused */
521 xen_do_pin(MMUEXT_PIN_L3_TABLE, PFN_DOWN(__pa(pgd)));
525 /* The init_mm pagetable is really pinned as soon as its created, but
526 that's before we have page structures to store the bits. So do all
527 the book-keeping now. */
528 static __init int mark_pinned(struct page *page, enum pt_level level)
534 void __init xen_mark_init_mm_pinned(void)
536 pgd_walk(init_mm.pgd, mark_pinned, FIXADDR_TOP);
539 static int unpin_page(struct page *page, enum pt_level level)
541 unsigned pgfl = TestClearPagePinned(page);
543 if (pgfl && !PageHighMem(page)) {
544 void *pt = lowmem_page_address(page);
545 unsigned long pfn = page_to_pfn(page);
546 spinlock_t *ptl = NULL;
547 struct multicall_space mcs;
549 if (level == PT_PTE) {
550 ptl = lock_pte(page);
552 xen_do_pin(MMUEXT_UNPIN_TABLE, pfn);
555 mcs = __xen_mc_entry(0);
557 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
558 pfn_pte(pfn, PAGE_KERNEL),
559 level == PT_PGD ? UVMF_TLB_FLUSH : 0);
562 /* unlock when batch completed */
563 xen_mc_callback(do_unlock, ptl);
567 return 0; /* never need to flush on unpin */
570 /* Release a pagetables pages back as normal RW */
571 static void xen_pgd_unpin(pgd_t *pgd)
575 xen_do_pin(MMUEXT_UNPIN_TABLE, PFN_DOWN(__pa(pgd)));
577 pgd_walk(pgd, unpin_page, TASK_SIZE);
582 void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next)
584 spin_lock(&next->page_table_lock);
585 xen_pgd_pin(next->pgd);
586 spin_unlock(&next->page_table_lock);
589 void xen_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
591 spin_lock(&mm->page_table_lock);
592 xen_pgd_pin(mm->pgd);
593 spin_unlock(&mm->page_table_lock);
598 /* Another cpu may still have their %cr3 pointing at the pagetable, so
599 we need to repoint it somewhere else before we can unpin it. */
600 static void drop_other_mm_ref(void *info)
602 struct mm_struct *mm = info;
604 if (__get_cpu_var(cpu_tlbstate).active_mm == mm)
605 leave_mm(smp_processor_id());
607 /* If this cpu still has a stale cr3 reference, then make sure
608 it has been flushed. */
609 if (x86_read_percpu(xen_current_cr3) == __pa(mm->pgd)) {
610 load_cr3(swapper_pg_dir);
611 arch_flush_lazy_cpu_mode();
615 static void drop_mm_ref(struct mm_struct *mm)
620 if (current->active_mm == mm) {
621 if (current->mm == mm)
622 load_cr3(swapper_pg_dir);
624 leave_mm(smp_processor_id());
625 arch_flush_lazy_cpu_mode();
628 /* Get the "official" set of cpus referring to our pagetable. */
629 mask = mm->cpu_vm_mask;
631 /* It's possible that a vcpu may have a stale reference to our
632 cr3, because its in lazy mode, and it hasn't yet flushed
633 its set of pending hypercalls yet. In this case, we can
634 look at its actual current cr3 value, and force it to flush
636 for_each_online_cpu(cpu) {
637 if (per_cpu(xen_current_cr3, cpu) == __pa(mm->pgd))
641 if (!cpus_empty(mask))
642 xen_smp_call_function_mask(mask, drop_other_mm_ref, mm, 1);
645 static void drop_mm_ref(struct mm_struct *mm)
647 if (current->active_mm == mm)
648 load_cr3(swapper_pg_dir);
653 * While a process runs, Xen pins its pagetables, which means that the
654 * hypervisor forces it to be read-only, and it controls all updates
655 * to it. This means that all pagetable updates have to go via the
656 * hypervisor, which is moderately expensive.
658 * Since we're pulling the pagetable down, we switch to use init_mm,
659 * unpin old process pagetable and mark it all read-write, which
660 * allows further operations on it to be simple memory accesses.
662 * The only subtle point is that another CPU may be still using the
663 * pagetable because of lazy tlb flushing. This means we need need to
664 * switch all CPUs off this pagetable before we can unpin it.
666 void xen_exit_mmap(struct mm_struct *mm)
668 get_cpu(); /* make sure we don't move around */
672 spin_lock(&mm->page_table_lock);
674 /* pgd may not be pinned in the error exit path of execve */
675 if (PagePinned(virt_to_page(mm->pgd)))
676 xen_pgd_unpin(mm->pgd);
678 spin_unlock(&mm->page_table_lock);