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 xmaddr_t arbitrary_virt_to_machine(unsigned long address)
62 pte_t *pte = lookup_address(address, &level);
63 unsigned offset = address & ~PAGE_MASK;
67 return XMADDR((pte_mfn(*pte) << PAGE_SHIFT) + offset);
70 void make_lowmem_page_readonly(void *vaddr)
73 unsigned long address = (unsigned long)vaddr;
76 pte = lookup_address(address, &level);
79 ptev = pte_wrprotect(*pte);
81 if (HYPERVISOR_update_va_mapping(address, ptev, 0))
85 void make_lowmem_page_readwrite(void *vaddr)
88 unsigned long address = (unsigned long)vaddr;
91 pte = lookup_address(address, &level);
94 ptev = pte_mkwrite(*pte);
96 if (HYPERVISOR_update_va_mapping(address, ptev, 0))
101 void xen_set_pmd(pmd_t *ptr, pmd_t val)
103 struct multicall_space mcs;
104 struct mmu_update *u;
108 mcs = xen_mc_entry(sizeof(*u));
110 u->ptr = virt_to_machine(ptr).maddr;
111 u->val = pmd_val_ma(val);
112 MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
114 xen_mc_issue(PARAVIRT_LAZY_MMU);
120 * Associate a virtual page frame with a given physical page frame
121 * and protection flags for that frame.
123 void set_pte_mfn(unsigned long vaddr, unsigned long mfn, pgprot_t flags)
130 pgd = swapper_pg_dir + pgd_index(vaddr);
131 if (pgd_none(*pgd)) {
135 pud = pud_offset(pgd, vaddr);
136 if (pud_none(*pud)) {
140 pmd = pmd_offset(pud, vaddr);
141 if (pmd_none(*pmd)) {
145 pte = pte_offset_kernel(pmd, vaddr);
146 /* <mfn,flags> stored as-is, to permit clearing entries */
147 xen_set_pte(pte, mfn_pte(mfn, flags));
150 * It's enough to flush this one mapping.
151 * (PGE mappings get flushed as well)
153 __flush_tlb_one(vaddr);
156 void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
157 pte_t *ptep, pte_t pteval)
159 /* updates to init_mm may be done without lock */
163 if (mm == current->mm || mm == &init_mm) {
164 if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
165 struct multicall_space mcs;
166 mcs = xen_mc_entry(0);
168 MULTI_update_va_mapping(mcs.mc, addr, pteval, 0);
169 xen_mc_issue(PARAVIRT_LAZY_MMU);
172 if (HYPERVISOR_update_va_mapping(addr, pteval, 0) == 0)
175 xen_set_pte(ptep, pteval);
182 /* Assume pteval_t is equivalent to all the other *val_t types. */
183 static pteval_t pte_mfn_to_pfn(pteval_t val)
185 if (val & _PAGE_PRESENT) {
186 unsigned long mfn = (val & PTE_MASK) >> PAGE_SHIFT;
187 pteval_t flags = val & ~PTE_MASK;
188 val = (mfn_to_pfn(mfn) << PAGE_SHIFT) | flags;
194 static pteval_t pte_pfn_to_mfn(pteval_t val)
196 if (val & _PAGE_PRESENT) {
197 unsigned long pfn = (val & PTE_MASK) >> PAGE_SHIFT;
198 pteval_t flags = val & ~PTE_MASK;
199 val = (pfn_to_mfn(pfn) << PAGE_SHIFT) | flags;
205 pteval_t xen_pte_val(pte_t pte)
207 return pte_mfn_to_pfn(pte.pte);
210 pgdval_t xen_pgd_val(pgd_t pgd)
212 return pte_mfn_to_pfn(pgd.pgd);
215 pte_t xen_make_pte(pteval_t pte)
217 pte = pte_pfn_to_mfn(pte);
218 return native_make_pte(pte);
221 pgd_t xen_make_pgd(pgdval_t pgd)
223 pgd = pte_pfn_to_mfn(pgd);
224 return native_make_pgd(pgd);
227 pmdval_t xen_pmd_val(pmd_t pmd)
229 return pte_mfn_to_pfn(pmd.pmd);
231 #ifdef CONFIG_X86_PAE
232 void xen_set_pud(pud_t *ptr, pud_t val)
234 struct multicall_space mcs;
235 struct mmu_update *u;
239 mcs = xen_mc_entry(sizeof(*u));
241 u->ptr = virt_to_machine(ptr).maddr;
242 u->val = pud_val_ma(val);
243 MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
245 xen_mc_issue(PARAVIRT_LAZY_MMU);
250 void xen_set_pte(pte_t *ptep, pte_t pte)
252 ptep->pte_high = pte.pte_high;
254 ptep->pte_low = pte.pte_low;
257 void xen_set_pte_atomic(pte_t *ptep, pte_t pte)
259 set_64bit((u64 *)ptep, pte_val_ma(pte));
262 void xen_pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
265 smp_wmb(); /* make sure low gets written first */
269 void xen_pmd_clear(pmd_t *pmdp)
271 xen_set_pmd(pmdp, __pmd(0));
274 pmd_t xen_make_pmd(pmdval_t pmd)
276 pmd = pte_pfn_to_mfn(pmd);
277 return native_make_pmd(pmd);
280 void xen_set_pte(pte_t *ptep, pte_t pte)
284 #endif /* CONFIG_X86_PAE */
287 (Yet another) pagetable walker. This one is intended for pinning a
288 pagetable. This means that it walks a pagetable and calls the
289 callback function on each page it finds making up the page table,
290 at every level. It walks the entire pagetable, but it only bothers
291 pinning pte pages which are below pte_limit. In the normal case
292 this will be TASK_SIZE, but at boot we need to pin up to
293 FIXADDR_TOP. But the important bit is that we don't pin beyond
294 there, because then we start getting into Xen's ptes.
296 static int pgd_walk(pgd_t *pgd_base, int (*func)(struct page *, enum pt_level),
299 pgd_t *pgd = pgd_base;
301 unsigned long addr = 0;
302 unsigned long pgd_next;
304 BUG_ON(limit > FIXADDR_TOP);
306 if (xen_feature(XENFEAT_auto_translated_physmap))
309 for (; addr != FIXADDR_TOP; pgd++, addr = pgd_next) {
311 unsigned long pud_limit, pud_next;
313 pgd_next = pud_limit = pgd_addr_end(addr, FIXADDR_TOP);
318 pud = pud_offset(pgd, 0);
320 if (PTRS_PER_PUD > 1) /* not folded */
321 flush |= (*func)(virt_to_page(pud), PT_PUD);
323 for (; addr != pud_limit; pud++, addr = pud_next) {
325 unsigned long pmd_limit;
327 pud_next = pud_addr_end(addr, pud_limit);
329 if (pud_next < limit)
330 pmd_limit = pud_next;
337 pmd = pmd_offset(pud, 0);
339 if (PTRS_PER_PMD > 1) /* not folded */
340 flush |= (*func)(virt_to_page(pmd), PT_PMD);
342 for (; addr != pmd_limit; pmd++) {
343 addr += (PAGE_SIZE * PTRS_PER_PTE);
344 if ((pmd_limit-1) < (addr-1)) {
352 flush |= (*func)(pmd_page(*pmd), PT_PTE);
357 flush |= (*func)(virt_to_page(pgd_base), PT_PGD);
362 static spinlock_t *lock_pte(struct page *page)
364 spinlock_t *ptl = NULL;
366 #if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
367 ptl = __pte_lockptr(page);
374 static void do_unlock(void *v)
380 static void xen_do_pin(unsigned level, unsigned long pfn)
382 struct mmuext_op *op;
383 struct multicall_space mcs;
385 mcs = __xen_mc_entry(sizeof(*op));
388 op->arg1.mfn = pfn_to_mfn(pfn);
389 MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);
392 static int pin_page(struct page *page, enum pt_level level)
394 unsigned pgfl = TestSetPagePinned(page);
398 flush = 0; /* already pinned */
399 else if (PageHighMem(page))
400 /* kmaps need flushing if we found an unpinned
404 void *pt = lowmem_page_address(page);
405 unsigned long pfn = page_to_pfn(page);
406 struct multicall_space mcs = __xen_mc_entry(0);
413 ptl = lock_pte(page);
415 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
416 pfn_pte(pfn, PAGE_KERNEL_RO),
417 level == PT_PGD ? UVMF_TLB_FLUSH : 0);
420 xen_do_pin(MMUEXT_PIN_L1_TABLE, pfn);
423 /* Queue a deferred unlock for when this batch
425 xen_mc_callback(do_unlock, ptl);
432 /* This is called just after a mm has been created, but it has not
433 been used yet. We need to make sure that its pagetable is all
434 read-only, and can be pinned. */
435 void xen_pgd_pin(pgd_t *pgd)
441 if (pgd_walk(pgd, pin_page, TASK_SIZE)) {
442 /* re-enable interrupts for kmap_flush_unused */
448 #ifdef CONFIG_X86_PAE
449 level = MMUEXT_PIN_L3_TABLE;
451 level = MMUEXT_PIN_L2_TABLE;
454 xen_do_pin(level, PFN_DOWN(__pa(pgd)));
459 /* The init_mm pagetable is really pinned as soon as its created, but
460 that's before we have page structures to store the bits. So do all
461 the book-keeping now. */
462 static __init int mark_pinned(struct page *page, enum pt_level level)
468 void __init xen_mark_init_mm_pinned(void)
470 pgd_walk(init_mm.pgd, mark_pinned, FIXADDR_TOP);
473 static int unpin_page(struct page *page, enum pt_level level)
475 unsigned pgfl = TestClearPagePinned(page);
477 if (pgfl && !PageHighMem(page)) {
478 void *pt = lowmem_page_address(page);
479 unsigned long pfn = page_to_pfn(page);
480 spinlock_t *ptl = NULL;
481 struct multicall_space mcs;
483 if (level == PT_PTE) {
484 ptl = lock_pte(page);
486 xen_do_pin(MMUEXT_UNPIN_TABLE, pfn);
489 mcs = __xen_mc_entry(0);
491 MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
492 pfn_pte(pfn, PAGE_KERNEL),
493 level == PT_PGD ? UVMF_TLB_FLUSH : 0);
496 /* unlock when batch completed */
497 xen_mc_callback(do_unlock, ptl);
501 return 0; /* never need to flush on unpin */
504 /* Release a pagetables pages back as normal RW */
505 static void xen_pgd_unpin(pgd_t *pgd)
509 xen_do_pin(MMUEXT_UNPIN_TABLE, PFN_DOWN(__pa(pgd)));
511 pgd_walk(pgd, unpin_page, TASK_SIZE);
516 void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next)
518 spin_lock(&next->page_table_lock);
519 xen_pgd_pin(next->pgd);
520 spin_unlock(&next->page_table_lock);
523 void xen_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
525 spin_lock(&mm->page_table_lock);
526 xen_pgd_pin(mm->pgd);
527 spin_unlock(&mm->page_table_lock);
532 /* Another cpu may still have their %cr3 pointing at the pagetable, so
533 we need to repoint it somewhere else before we can unpin it. */
534 static void drop_other_mm_ref(void *info)
536 struct mm_struct *mm = info;
538 if (__get_cpu_var(cpu_tlbstate).active_mm == mm)
539 leave_mm(smp_processor_id());
541 /* If this cpu still has a stale cr3 reference, then make sure
542 it has been flushed. */
543 if (x86_read_percpu(xen_current_cr3) == __pa(mm->pgd)) {
544 load_cr3(swapper_pg_dir);
545 arch_flush_lazy_cpu_mode();
549 static void drop_mm_ref(struct mm_struct *mm)
554 if (current->active_mm == mm) {
555 if (current->mm == mm)
556 load_cr3(swapper_pg_dir);
558 leave_mm(smp_processor_id());
559 arch_flush_lazy_cpu_mode();
562 /* Get the "official" set of cpus referring to our pagetable. */
563 mask = mm->cpu_vm_mask;
565 /* It's possible that a vcpu may have a stale reference to our
566 cr3, because its in lazy mode, and it hasn't yet flushed
567 its set of pending hypercalls yet. In this case, we can
568 look at its actual current cr3 value, and force it to flush
570 for_each_online_cpu(cpu) {
571 if (per_cpu(xen_current_cr3, cpu) == __pa(mm->pgd))
575 if (!cpus_empty(mask))
576 xen_smp_call_function_mask(mask, drop_other_mm_ref, mm, 1);
579 static void drop_mm_ref(struct mm_struct *mm)
581 if (current->active_mm == mm)
582 load_cr3(swapper_pg_dir);
587 * While a process runs, Xen pins its pagetables, which means that the
588 * hypervisor forces it to be read-only, and it controls all updates
589 * to it. This means that all pagetable updates have to go via the
590 * hypervisor, which is moderately expensive.
592 * Since we're pulling the pagetable down, we switch to use init_mm,
593 * unpin old process pagetable and mark it all read-write, which
594 * allows further operations on it to be simple memory accesses.
596 * The only subtle point is that another CPU may be still using the
597 * pagetable because of lazy tlb flushing. This means we need need to
598 * switch all CPUs off this pagetable before we can unpin it.
600 void xen_exit_mmap(struct mm_struct *mm)
602 get_cpu(); /* make sure we don't move around */
606 spin_lock(&mm->page_table_lock);
608 /* pgd may not be pinned in the error exit path of execve */
609 if (PagePinned(virt_to_page(mm->pgd)))
610 xen_pgd_unpin(mm->pgd);
612 spin_unlock(&mm->page_table_lock);