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"
59 #define P2M_ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(unsigned long))
60 #define TOP_ENTRIES (MAX_DOMAIN_PAGES / P2M_ENTRIES_PER_PAGE)
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 };
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] };
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")));
76 static unsigned long p2m_top_mfn_list[
77 PAGE_ALIGN(TOP_ENTRIES / P2M_ENTRIES_PER_PAGE)]
78 __attribute__((section(".bss.page_aligned")));
80 static inline unsigned p2m_top_index(unsigned long pfn)
82 BUG_ON(pfn >= MAX_DOMAIN_PAGES);
83 return pfn / P2M_ENTRIES_PER_PAGE;
86 static inline unsigned p2m_index(unsigned long pfn)
88 return pfn % P2M_ENTRIES_PER_PAGE;
91 /* Build the parallel p2m_top_mfn structures */
92 void xen_setup_mfn_list_list(void)
96 for(pfn = 0; pfn < MAX_DOMAIN_PAGES; pfn += P2M_ENTRIES_PER_PAGE) {
97 unsigned topidx = p2m_top_index(pfn);
99 p2m_top_mfn[topidx] = virt_to_mfn(p2m_top[topidx]);
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]);
107 BUG_ON(HYPERVISOR_shared_info == &xen_dummy_shared_info);
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;
114 /* Set up p2m_top to point to the domain-builder provided p2m pages */
115 void __init xen_build_dynamic_phys_to_machine(void)
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);
121 for(pfn = 0; pfn < max_pfn; pfn += P2M_ENTRIES_PER_PAGE) {
122 unsigned topidx = p2m_top_index(pfn);
124 p2m_top[topidx] = &mfn_list[pfn];
128 unsigned long get_phys_to_machine(unsigned long pfn)
130 unsigned topidx, idx;
132 if (unlikely(pfn >= MAX_DOMAIN_PAGES))
133 return INVALID_P2M_ENTRY;
135 topidx = p2m_top_index(pfn);
136 idx = p2m_index(pfn);
137 return p2m_top[topidx][idx];
140 static void alloc_p2m(unsigned long **pp, unsigned long *mfnp)
145 p = (void *)__get_free_page(GFP_KERNEL | __GFP_NOFAIL);
148 for(i = 0; i < P2M_ENTRIES_PER_PAGE; i++)
149 p[i] = INVALID_P2M_ENTRY;
151 if (cmpxchg(pp, p2m_missing, p) != p2m_missing)
152 free_page((unsigned long)p);
154 *mfnp = virt_to_mfn(p);
157 void set_phys_to_machine(unsigned long pfn, unsigned long mfn)
159 unsigned topidx, idx;
161 if (unlikely(xen_feature(XENFEAT_auto_translated_physmap))) {
162 BUG_ON(pfn != mfn && mfn != INVALID_P2M_ENTRY);
166 if (unlikely(pfn >= MAX_DOMAIN_PAGES)) {
167 BUG_ON(mfn != INVALID_P2M_ENTRY);
171 topidx = p2m_top_index(pfn);
172 if (p2m_top[topidx] == p2m_missing) {
173 /* no need to allocate a page to store an invalid entry */
174 if (mfn == INVALID_P2M_ENTRY)
176 alloc_p2m(&p2m_top[topidx], &p2m_top_mfn[topidx]);
179 idx = p2m_index(pfn);
180 p2m_top[topidx][idx] = mfn;
183 xmaddr_t arbitrary_virt_to_machine(unsigned long address)
186 pte_t *pte = lookup_address(address, &level);
187 unsigned offset = address & PAGE_MASK;
191 return XMADDR((pte_mfn(*pte) << PAGE_SHIFT) + offset);
194 void make_lowmem_page_readonly(void *vaddr)
197 unsigned long address = (unsigned long)vaddr;
200 pte = lookup_address(address, &level);
203 ptev = pte_wrprotect(*pte);
205 if (HYPERVISOR_update_va_mapping(address, ptev, 0))
209 void make_lowmem_page_readwrite(void *vaddr)
212 unsigned long address = (unsigned long)vaddr;
215 pte = lookup_address(address, &level);
218 ptev = pte_mkwrite(*pte);
220 if (HYPERVISOR_update_va_mapping(address, ptev, 0))
225 void xen_set_pmd(pmd_t *ptr, pmd_t val)
227 struct multicall_space mcs;
228 struct mmu_update *u;
232 mcs = xen_mc_entry(sizeof(*u));
234 u->ptr = virt_to_machine(ptr).maddr;
235 u->val = pmd_val_ma(val);
236 MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
238 xen_mc_issue(PARAVIRT_LAZY_MMU);
244 * Associate a virtual page frame with a given physical page frame
245 * and protection flags for that frame.
247 void set_pte_mfn(unsigned long vaddr, unsigned long mfn, pgprot_t flags)
254 pgd = swapper_pg_dir + pgd_index(vaddr);
255 if (pgd_none(*pgd)) {
259 pud = pud_offset(pgd, vaddr);
260 if (pud_none(*pud)) {
264 pmd = pmd_offset(pud, vaddr);
265 if (pmd_none(*pmd)) {
269 pte = pte_offset_kernel(pmd, vaddr);
270 /* <mfn,flags> stored as-is, to permit clearing entries */
271 xen_set_pte(pte, mfn_pte(mfn, flags));
274 * It's enough to flush this one mapping.
275 * (PGE mappings get flushed as well)
277 __flush_tlb_one(vaddr);
280 void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
281 pte_t *ptep, pte_t pteval)
283 /* updates to init_mm may be done without lock */
287 if (mm == current->mm || mm == &init_mm) {
288 if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
289 struct multicall_space mcs;
290 mcs = xen_mc_entry(0);
292 MULTI_update_va_mapping(mcs.mc, addr, pteval, 0);
293 xen_mc_issue(PARAVIRT_LAZY_MMU);
296 if (HYPERVISOR_update_va_mapping(addr, pteval, 0) == 0)
299 xen_set_pte(ptep, pteval);
306 pteval_t xen_pte_val(pte_t pte)
308 pteval_t ret = pte.pte;
310 if (ret & _PAGE_PRESENT)
311 ret = machine_to_phys(XMADDR(ret)).paddr | _PAGE_PRESENT;
316 pgdval_t xen_pgd_val(pgd_t pgd)
318 pgdval_t ret = pgd.pgd;
319 if (ret & _PAGE_PRESENT)
320 ret = machine_to_phys(XMADDR(ret)).paddr | _PAGE_PRESENT;
324 pte_t xen_make_pte(pteval_t pte)
326 if (pte & _PAGE_PRESENT) {
327 pte = phys_to_machine(XPADDR(pte)).maddr;
328 pte &= ~(_PAGE_PCD | _PAGE_PWT);
331 return (pte_t){ .pte = pte };
334 pgd_t xen_make_pgd(pgdval_t pgd)
336 if (pgd & _PAGE_PRESENT)
337 pgd = phys_to_machine(XPADDR(pgd)).maddr;
339 return (pgd_t){ pgd };
342 pmdval_t xen_pmd_val(pmd_t pmd)
344 pmdval_t ret = native_pmd_val(pmd);
345 if (ret & _PAGE_PRESENT)
346 ret = machine_to_phys(XMADDR(ret)).paddr | _PAGE_PRESENT;
350 void xen_set_pud(pud_t *ptr, pud_t val)
352 struct multicall_space mcs;
353 struct mmu_update *u;
357 mcs = xen_mc_entry(sizeof(*u));
359 u->ptr = virt_to_machine(ptr).maddr;
360 u->val = pud_val_ma(val);
361 MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
363 xen_mc_issue(PARAVIRT_LAZY_MMU);
368 void xen_set_pte(pte_t *ptep, pte_t pte)
370 ptep->pte_high = pte.pte_high;
372 ptep->pte_low = pte.pte_low;
375 void xen_set_pte_atomic(pte_t *ptep, pte_t pte)
377 set_64bit((u64 *)ptep, pte_val_ma(pte));
380 void xen_pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
383 smp_wmb(); /* make sure low gets written first */
387 void xen_pmd_clear(pmd_t *pmdp)
389 xen_set_pmd(pmdp, __pmd(0));
392 pmd_t xen_make_pmd(pmdval_t pmd)
394 if (pmd & _PAGE_PRESENT)
395 pmd = phys_to_machine(XPADDR(pmd)).maddr;
397 return native_make_pmd(pmd);
401 (Yet another) pagetable walker. This one is intended for pinning a
402 pagetable. This means that it walks a pagetable and calls the
403 callback function on each page it finds making up the page table,
404 at every level. It walks the entire pagetable, but it only bothers
405 pinning pte pages which are below pte_limit. In the normal case
406 this will be TASK_SIZE, but at boot we need to pin up to
407 FIXADDR_TOP. But the important bit is that we don't pin beyond
408 there, because then we start getting into Xen's ptes.
410 static int pgd_walk(pgd_t *pgd_base, int (*func)(struct page *, enum pt_level),
413 pgd_t *pgd = pgd_base;
415 unsigned long addr = 0;
416 unsigned long pgd_next;
418 BUG_ON(limit > FIXADDR_TOP);
420 if (xen_feature(XENFEAT_auto_translated_physmap))
423 for (; addr != FIXADDR_TOP; pgd++, addr = pgd_next) {
425 unsigned long pud_limit, pud_next;
427 pgd_next = pud_limit = pgd_addr_end(addr, FIXADDR_TOP);
432 pud = pud_offset(pgd, 0);
434 if (PTRS_PER_PUD > 1) /* not folded */
435 flush |= (*func)(virt_to_page(pud), PT_PUD);
437 for (; addr != pud_limit; pud++, addr = pud_next) {
439 unsigned long pmd_limit;
441 pud_next = pud_addr_end(addr, pud_limit);
443 if (pud_next < limit)
444 pmd_limit = pud_next;
451 pmd = pmd_offset(pud, 0);
453 if (PTRS_PER_PMD > 1) /* not folded */
454 flush |= (*func)(virt_to_page(pmd), PT_PMD);
456 for (; addr != pmd_limit; pmd++) {
457 addr += (PAGE_SIZE * PTRS_PER_PTE);
458 if ((pmd_limit-1) < (addr-1)) {
466 flush |= (*func)(pmd_page(*pmd), PT_PTE);
471 flush |= (*func)(virt_to_page(pgd_base), PT_PGD);
476 static spinlock_t *lock_pte(struct page *page)
478 spinlock_t *ptl = NULL;
480 #if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
481 ptl = __pte_lockptr(page);
488 static void do_unlock(void *v)
494 static void xen_do_pin(unsigned level, unsigned long pfn)
496 struct mmuext_op *op;
497 struct multicall_space mcs;
499 mcs = __xen_mc_entry(sizeof(*op));
502 op->arg1.mfn = pfn_to_mfn(pfn);
503 MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);
506 static int pin_page(struct page *page, enum pt_level level)
508 unsigned pgfl = TestSetPagePinned(page);
512 flush = 0; /* already pinned */
513 else if (PageHighMem(page))
514 /* kmaps need flushing if we found an unpinned
518 void *pt = lowmem_page_address(page);
519 unsigned long pfn = page_to_pfn(page);
520 struct multicall_space mcs = __xen_mc_entry(0);
527 ptl = lock_pte(page);
529 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
530 pfn_pte(pfn, PAGE_KERNEL_RO),
531 level == PT_PGD ? UVMF_TLB_FLUSH : 0);
534 xen_do_pin(MMUEXT_PIN_L1_TABLE, pfn);
537 /* Queue a deferred unlock for when this batch
539 xen_mc_callback(do_unlock, ptl);
546 /* This is called just after a mm has been created, but it has not
547 been used yet. We need to make sure that its pagetable is all
548 read-only, and can be pinned. */
549 void xen_pgd_pin(pgd_t *pgd)
553 if (pgd_walk(pgd, pin_page, TASK_SIZE)) {
554 /* re-enable interrupts for kmap_flush_unused */
560 xen_do_pin(MMUEXT_PIN_L3_TABLE, PFN_DOWN(__pa(pgd)));
565 * On save, we need to pin all pagetables to make sure they get their
566 * mfns turned into pfns. Search the list for any unpinned pgds and pin
567 * them (unpinned pgds are not currently in use, probably because the
568 * process is under construction or destruction).
570 void xen_mm_pin_all(void)
575 spin_lock_irqsave(&pgd_lock, flags);
577 list_for_each_entry(page, &pgd_list, lru) {
578 if (!PagePinned(page)) {
579 xen_pgd_pin((pgd_t *)page_address(page));
580 SetPageSavePinned(page);
584 spin_unlock_irqrestore(&pgd_lock, flags);
587 /* The init_mm pagetable is really pinned as soon as its created, but
588 that's before we have page structures to store the bits. So do all
589 the book-keeping now. */
590 static __init int mark_pinned(struct page *page, enum pt_level level)
596 void __init xen_mark_init_mm_pinned(void)
598 pgd_walk(init_mm.pgd, mark_pinned, FIXADDR_TOP);
601 static int unpin_page(struct page *page, enum pt_level level)
603 unsigned pgfl = TestClearPagePinned(page);
605 if (pgfl && !PageHighMem(page)) {
606 void *pt = lowmem_page_address(page);
607 unsigned long pfn = page_to_pfn(page);
608 spinlock_t *ptl = NULL;
609 struct multicall_space mcs;
611 if (level == PT_PTE) {
612 ptl = lock_pte(page);
614 xen_do_pin(MMUEXT_UNPIN_TABLE, pfn);
617 mcs = __xen_mc_entry(0);
619 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
620 pfn_pte(pfn, PAGE_KERNEL),
621 level == PT_PGD ? UVMF_TLB_FLUSH : 0);
624 /* unlock when batch completed */
625 xen_mc_callback(do_unlock, ptl);
629 return 0; /* never need to flush on unpin */
632 /* Release a pagetables pages back as normal RW */
633 static void xen_pgd_unpin(pgd_t *pgd)
637 xen_do_pin(MMUEXT_UNPIN_TABLE, PFN_DOWN(__pa(pgd)));
639 pgd_walk(pgd, unpin_page, TASK_SIZE);
645 * On resume, undo any pinning done at save, so that the rest of the
646 * kernel doesn't see any unexpected pinned pagetables.
648 void xen_mm_unpin_all(void)
653 spin_lock_irqsave(&pgd_lock, flags);
655 list_for_each_entry(page, &pgd_list, lru) {
656 if (PageSavePinned(page)) {
657 BUG_ON(!PagePinned(page));
658 printk("unpinning pinned %p\n", page_address(page));
659 xen_pgd_unpin((pgd_t *)page_address(page));
660 ClearPageSavePinned(page);
664 spin_unlock_irqrestore(&pgd_lock, flags);
667 void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next)
669 spin_lock(&next->page_table_lock);
670 xen_pgd_pin(next->pgd);
671 spin_unlock(&next->page_table_lock);
674 void xen_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
676 spin_lock(&mm->page_table_lock);
677 xen_pgd_pin(mm->pgd);
678 spin_unlock(&mm->page_table_lock);
683 /* Another cpu may still have their %cr3 pointing at the pagetable, so
684 we need to repoint it somewhere else before we can unpin it. */
685 static void drop_other_mm_ref(void *info)
687 struct mm_struct *mm = info;
689 if (__get_cpu_var(cpu_tlbstate).active_mm == mm)
690 leave_mm(smp_processor_id());
692 /* If this cpu still has a stale cr3 reference, then make sure
693 it has been flushed. */
694 if (x86_read_percpu(xen_current_cr3) == __pa(mm->pgd)) {
695 load_cr3(swapper_pg_dir);
696 arch_flush_lazy_cpu_mode();
700 static void drop_mm_ref(struct mm_struct *mm)
705 if (current->active_mm == mm) {
706 if (current->mm == mm)
707 load_cr3(swapper_pg_dir);
709 leave_mm(smp_processor_id());
710 arch_flush_lazy_cpu_mode();
713 /* Get the "official" set of cpus referring to our pagetable. */
714 mask = mm->cpu_vm_mask;
716 /* It's possible that a vcpu may have a stale reference to our
717 cr3, because its in lazy mode, and it hasn't yet flushed
718 its set of pending hypercalls yet. In this case, we can
719 look at its actual current cr3 value, and force it to flush
721 for_each_online_cpu(cpu) {
722 if (per_cpu(xen_current_cr3, cpu) == __pa(mm->pgd))
726 if (!cpus_empty(mask))
727 xen_smp_call_function_mask(mask, drop_other_mm_ref, mm, 1);
730 static void drop_mm_ref(struct mm_struct *mm)
732 if (current->active_mm == mm)
733 load_cr3(swapper_pg_dir);
738 * While a process runs, Xen pins its pagetables, which means that the
739 * hypervisor forces it to be read-only, and it controls all updates
740 * to it. This means that all pagetable updates have to go via the
741 * hypervisor, which is moderately expensive.
743 * Since we're pulling the pagetable down, we switch to use init_mm,
744 * unpin old process pagetable and mark it all read-write, which
745 * allows further operations on it to be simple memory accesses.
747 * The only subtle point is that another CPU may be still using the
748 * pagetable because of lazy tlb flushing. This means we need need to
749 * switch all CPUs off this pagetable before we can unpin it.
751 void xen_exit_mmap(struct mm_struct *mm)
753 get_cpu(); /* make sure we don't move around */
757 spin_lock(&mm->page_table_lock);
759 /* pgd may not be pinned in the error exit path of execve */
760 if (PagePinned(virt_to_page(mm->pgd)))
761 xen_pgd_unpin(mm->pgd);
763 spin_unlock(&mm->page_table_lock);