2 * KVM guest address space mapping code
4 * Copyright IBM Corp. 2007, 2016
5 * Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
8 #include <linux/kernel.h>
10 #include <linux/swap.h>
11 #include <linux/smp.h>
12 #include <linux/spinlock.h>
13 #include <linux/slab.h>
14 #include <linux/swapops.h>
15 #include <linux/ksm.h>
16 #include <linux/mman.h>
18 #include <asm/pgtable.h>
19 #include <asm/pgalloc.h>
24 * gmap_alloc - allocate a guest address space
25 * @mm: pointer to the parent mm_struct
26 * @limit: maximum address of the gmap address space
28 * Returns a guest address space structure.
30 struct gmap *gmap_alloc(struct mm_struct *mm, unsigned long limit)
35 unsigned long etype, atype;
37 if (limit < (1UL << 31)) {
38 limit = (1UL << 31) - 1;
39 atype = _ASCE_TYPE_SEGMENT;
40 etype = _SEGMENT_ENTRY_EMPTY;
41 } else if (limit < (1UL << 42)) {
42 limit = (1UL << 42) - 1;
43 atype = _ASCE_TYPE_REGION3;
44 etype = _REGION3_ENTRY_EMPTY;
45 } else if (limit < (1UL << 53)) {
46 limit = (1UL << 53) - 1;
47 atype = _ASCE_TYPE_REGION2;
48 etype = _REGION2_ENTRY_EMPTY;
51 atype = _ASCE_TYPE_REGION1;
52 etype = _REGION1_ENTRY_EMPTY;
54 gmap = kzalloc(sizeof(struct gmap), GFP_KERNEL);
57 INIT_LIST_HEAD(&gmap->crst_list);
58 INIT_RADIX_TREE(&gmap->guest_to_host, GFP_KERNEL);
59 INIT_RADIX_TREE(&gmap->host_to_guest, GFP_ATOMIC);
60 spin_lock_init(&gmap->guest_table_lock);
62 page = alloc_pages(GFP_KERNEL, 2);
66 list_add(&page->lru, &gmap->crst_list);
67 table = (unsigned long *) page_to_phys(page);
68 crst_table_init(table, etype);
70 gmap->asce = atype | _ASCE_TABLE_LENGTH |
71 _ASCE_USER_BITS | __pa(table);
72 gmap->asce_end = limit;
73 spin_lock(&mm->context.gmap_lock);
74 list_add_rcu(&gmap->list, &mm->context.gmap_list);
75 spin_unlock(&mm->context.gmap_lock);
83 EXPORT_SYMBOL_GPL(gmap_alloc);
85 static void gmap_flush_tlb(struct gmap *gmap)
88 __tlb_flush_asce(gmap->mm, gmap->asce);
93 static void gmap_radix_tree_free(struct radix_tree_root *root)
95 struct radix_tree_iter iter;
96 unsigned long indices[16];
101 /* A radix tree is freed by deleting all of its entries */
105 radix_tree_for_each_slot(slot, root, &iter, index) {
106 indices[nr] = iter.index;
110 for (i = 0; i < nr; i++) {
112 radix_tree_delete(root, index);
118 * gmap_free - free a guest address space
119 * @gmap: pointer to the guest address space structure
121 void gmap_free(struct gmap *gmap)
123 struct page *page, *next;
126 if (MACHINE_HAS_IDTE)
127 __tlb_flush_asce(gmap->mm, gmap->asce);
129 __tlb_flush_global();
131 spin_lock(&gmap->mm->context.gmap_lock);
132 list_del_rcu(&gmap->list);
133 spin_unlock(&gmap->mm->context.gmap_lock);
136 /* Free all segment & region tables. */
137 list_for_each_entry_safe(page, next, &gmap->crst_list, lru)
138 __free_pages(page, 2);
139 gmap_radix_tree_free(&gmap->guest_to_host);
140 gmap_radix_tree_free(&gmap->host_to_guest);
143 EXPORT_SYMBOL_GPL(gmap_free);
146 * gmap_enable - switch primary space to the guest address space
147 * @gmap: pointer to the guest address space structure
149 void gmap_enable(struct gmap *gmap)
151 S390_lowcore.gmap = (unsigned long) gmap;
153 EXPORT_SYMBOL_GPL(gmap_enable);
156 * gmap_disable - switch back to the standard primary address space
157 * @gmap: pointer to the guest address space structure
159 void gmap_disable(struct gmap *gmap)
161 S390_lowcore.gmap = 0UL;
163 EXPORT_SYMBOL_GPL(gmap_disable);
166 * gmap_alloc_table is assumed to be called with mmap_sem held
168 static int gmap_alloc_table(struct gmap *gmap, unsigned long *table,
169 unsigned long init, unsigned long gaddr)
174 /* since we dont free the gmap table until gmap_free we can unlock */
175 page = alloc_pages(GFP_KERNEL, 2);
178 new = (unsigned long *) page_to_phys(page);
179 crst_table_init(new, init);
180 spin_lock(&gmap->mm->page_table_lock);
181 if (*table & _REGION_ENTRY_INVALID) {
182 list_add(&page->lru, &gmap->crst_list);
183 *table = (unsigned long) new | _REGION_ENTRY_LENGTH |
184 (*table & _REGION_ENTRY_TYPE_MASK);
188 spin_unlock(&gmap->mm->page_table_lock);
190 __free_pages(page, 2);
195 * __gmap_segment_gaddr - find virtual address from segment pointer
196 * @entry: pointer to a segment table entry in the guest address space
198 * Returns the virtual address in the guest address space for the segment
200 static unsigned long __gmap_segment_gaddr(unsigned long *entry)
203 unsigned long offset, mask;
205 offset = (unsigned long) entry / sizeof(unsigned long);
206 offset = (offset & (PTRS_PER_PMD - 1)) * PMD_SIZE;
207 mask = ~(PTRS_PER_PMD * sizeof(pmd_t) - 1);
208 page = virt_to_page((void *)((unsigned long) entry & mask));
209 return page->index + offset;
213 * __gmap_unlink_by_vmaddr - unlink a single segment via a host address
214 * @gmap: pointer to the guest address space structure
215 * @vmaddr: address in the host process address space
217 * Returns 1 if a TLB flush is required
219 static int __gmap_unlink_by_vmaddr(struct gmap *gmap, unsigned long vmaddr)
221 unsigned long *entry;
224 spin_lock(&gmap->guest_table_lock);
225 entry = radix_tree_delete(&gmap->host_to_guest, vmaddr >> PMD_SHIFT);
227 flush = (*entry != _SEGMENT_ENTRY_INVALID);
228 *entry = _SEGMENT_ENTRY_INVALID;
230 spin_unlock(&gmap->guest_table_lock);
235 * __gmap_unmap_by_gaddr - unmap a single segment via a guest address
236 * @gmap: pointer to the guest address space structure
237 * @gaddr: address in the guest address space
239 * Returns 1 if a TLB flush is required
241 static int __gmap_unmap_by_gaddr(struct gmap *gmap, unsigned long gaddr)
243 unsigned long vmaddr;
245 vmaddr = (unsigned long) radix_tree_delete(&gmap->guest_to_host,
247 return vmaddr ? __gmap_unlink_by_vmaddr(gmap, vmaddr) : 0;
251 * gmap_unmap_segment - unmap segment from the guest address space
252 * @gmap: pointer to the guest address space structure
253 * @to: address in the guest address space
254 * @len: length of the memory area to unmap
256 * Returns 0 if the unmap succeeded, -EINVAL if not.
258 int gmap_unmap_segment(struct gmap *gmap, unsigned long to, unsigned long len)
263 if ((to | len) & (PMD_SIZE - 1))
265 if (len == 0 || to + len < to)
269 down_write(&gmap->mm->mmap_sem);
270 for (off = 0; off < len; off += PMD_SIZE)
271 flush |= __gmap_unmap_by_gaddr(gmap, to + off);
272 up_write(&gmap->mm->mmap_sem);
274 gmap_flush_tlb(gmap);
277 EXPORT_SYMBOL_GPL(gmap_unmap_segment);
280 * gmap_map_segment - map a segment to the guest address space
281 * @gmap: pointer to the guest address space structure
282 * @from: source address in the parent address space
283 * @to: target address in the guest address space
284 * @len: length of the memory area to map
286 * Returns 0 if the mmap succeeded, -EINVAL or -ENOMEM if not.
288 int gmap_map_segment(struct gmap *gmap, unsigned long from,
289 unsigned long to, unsigned long len)
294 if ((from | to | len) & (PMD_SIZE - 1))
296 if (len == 0 || from + len < from || to + len < to ||
297 from + len - 1 > TASK_MAX_SIZE || to + len - 1 > gmap->asce_end)
301 down_write(&gmap->mm->mmap_sem);
302 for (off = 0; off < len; off += PMD_SIZE) {
303 /* Remove old translation */
304 flush |= __gmap_unmap_by_gaddr(gmap, to + off);
305 /* Store new translation */
306 if (radix_tree_insert(&gmap->guest_to_host,
307 (to + off) >> PMD_SHIFT,
308 (void *) from + off))
311 up_write(&gmap->mm->mmap_sem);
313 gmap_flush_tlb(gmap);
316 gmap_unmap_segment(gmap, to, len);
319 EXPORT_SYMBOL_GPL(gmap_map_segment);
322 * __gmap_translate - translate a guest address to a user space address
323 * @gmap: pointer to guest mapping meta data structure
324 * @gaddr: guest address
326 * Returns user space address which corresponds to the guest address or
327 * -EFAULT if no such mapping exists.
328 * This function does not establish potentially missing page table entries.
329 * The mmap_sem of the mm that belongs to the address space must be held
330 * when this function gets called.
332 unsigned long __gmap_translate(struct gmap *gmap, unsigned long gaddr)
334 unsigned long vmaddr;
336 vmaddr = (unsigned long)
337 radix_tree_lookup(&gmap->guest_to_host, gaddr >> PMD_SHIFT);
338 return vmaddr ? (vmaddr | (gaddr & ~PMD_MASK)) : -EFAULT;
340 EXPORT_SYMBOL_GPL(__gmap_translate);
343 * gmap_translate - translate a guest address to a user space address
344 * @gmap: pointer to guest mapping meta data structure
345 * @gaddr: guest address
347 * Returns user space address which corresponds to the guest address or
348 * -EFAULT if no such mapping exists.
349 * This function does not establish potentially missing page table entries.
351 unsigned long gmap_translate(struct gmap *gmap, unsigned long gaddr)
355 down_read(&gmap->mm->mmap_sem);
356 rc = __gmap_translate(gmap, gaddr);
357 up_read(&gmap->mm->mmap_sem);
360 EXPORT_SYMBOL_GPL(gmap_translate);
363 * gmap_unlink - disconnect a page table from the gmap shadow tables
364 * @gmap: pointer to guest mapping meta data structure
365 * @table: pointer to the host page table
366 * @vmaddr: vm address associated with the host page table
368 void gmap_unlink(struct mm_struct *mm, unsigned long *table,
369 unsigned long vmaddr)
375 list_for_each_entry_rcu(gmap, &mm->context.gmap_list, list) {
376 flush = __gmap_unlink_by_vmaddr(gmap, vmaddr);
378 gmap_flush_tlb(gmap);
384 * gmap_link - set up shadow page tables to connect a host to a guest address
385 * @gmap: pointer to guest mapping meta data structure
386 * @gaddr: guest address
387 * @vmaddr: vm address
389 * Returns 0 on success, -ENOMEM for out of memory conditions, and -EFAULT
390 * if the vm address is already mapped to a different guest segment.
391 * The mmap_sem of the mm that belongs to the address space must be held
392 * when this function gets called.
394 int __gmap_link(struct gmap *gmap, unsigned long gaddr, unsigned long vmaddr)
396 struct mm_struct *mm;
397 unsigned long *table;
404 /* Create higher level tables in the gmap page table */
406 if ((gmap->asce & _ASCE_TYPE_MASK) >= _ASCE_TYPE_REGION1) {
407 table += (gaddr >> 53) & 0x7ff;
408 if ((*table & _REGION_ENTRY_INVALID) &&
409 gmap_alloc_table(gmap, table, _REGION2_ENTRY_EMPTY,
410 gaddr & 0xffe0000000000000UL))
412 table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
414 if ((gmap->asce & _ASCE_TYPE_MASK) >= _ASCE_TYPE_REGION2) {
415 table += (gaddr >> 42) & 0x7ff;
416 if ((*table & _REGION_ENTRY_INVALID) &&
417 gmap_alloc_table(gmap, table, _REGION3_ENTRY_EMPTY,
418 gaddr & 0xfffffc0000000000UL))
420 table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
422 if ((gmap->asce & _ASCE_TYPE_MASK) >= _ASCE_TYPE_REGION3) {
423 table += (gaddr >> 31) & 0x7ff;
424 if ((*table & _REGION_ENTRY_INVALID) &&
425 gmap_alloc_table(gmap, table, _SEGMENT_ENTRY_EMPTY,
426 gaddr & 0xffffffff80000000UL))
428 table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
430 table += (gaddr >> 20) & 0x7ff;
431 /* Walk the parent mm page table */
433 pgd = pgd_offset(mm, vmaddr);
434 VM_BUG_ON(pgd_none(*pgd));
435 pud = pud_offset(pgd, vmaddr);
436 VM_BUG_ON(pud_none(*pud));
437 pmd = pmd_offset(pud, vmaddr);
438 VM_BUG_ON(pmd_none(*pmd));
439 /* large pmds cannot yet be handled */
442 /* Link gmap segment table entry location to page table. */
443 rc = radix_tree_preload(GFP_KERNEL);
446 ptl = pmd_lock(mm, pmd);
447 spin_lock(&gmap->guest_table_lock);
448 if (*table == _SEGMENT_ENTRY_INVALID) {
449 rc = radix_tree_insert(&gmap->host_to_guest,
450 vmaddr >> PMD_SHIFT, table);
452 *table = pmd_val(*pmd);
455 spin_unlock(&gmap->guest_table_lock);
457 radix_tree_preload_end();
462 * gmap_fault - resolve a fault on a guest address
463 * @gmap: pointer to guest mapping meta data structure
464 * @gaddr: guest address
465 * @fault_flags: flags to pass down to handle_mm_fault()
467 * Returns 0 on success, -ENOMEM for out of memory conditions, and -EFAULT
468 * if the vm address is already mapped to a different guest segment.
470 int gmap_fault(struct gmap *gmap, unsigned long gaddr,
471 unsigned int fault_flags)
473 unsigned long vmaddr;
477 down_read(&gmap->mm->mmap_sem);
481 vmaddr = __gmap_translate(gmap, gaddr);
482 if (IS_ERR_VALUE(vmaddr)) {
486 if (fixup_user_fault(current, gmap->mm, vmaddr, fault_flags,
492 * In the case that fixup_user_fault unlocked the mmap_sem during
493 * faultin redo __gmap_translate to not race with a map/unmap_segment.
498 rc = __gmap_link(gmap, gaddr, vmaddr);
500 up_read(&gmap->mm->mmap_sem);
503 EXPORT_SYMBOL_GPL(gmap_fault);
506 * this function is assumed to be called with mmap_sem held
508 void __gmap_zap(struct gmap *gmap, unsigned long gaddr)
510 unsigned long vmaddr;
514 /* Find the vm address for the guest address */
515 vmaddr = (unsigned long) radix_tree_lookup(&gmap->guest_to_host,
518 vmaddr |= gaddr & ~PMD_MASK;
519 /* Get pointer to the page table entry */
520 ptep = get_locked_pte(gmap->mm, vmaddr, &ptl);
522 ptep_zap_unused(gmap->mm, vmaddr, ptep, 0);
523 pte_unmap_unlock(ptep, ptl);
526 EXPORT_SYMBOL_GPL(__gmap_zap);
528 void gmap_discard(struct gmap *gmap, unsigned long from, unsigned long to)
530 unsigned long gaddr, vmaddr, size;
531 struct vm_area_struct *vma;
533 down_read(&gmap->mm->mmap_sem);
534 for (gaddr = from; gaddr < to;
535 gaddr = (gaddr + PMD_SIZE) & PMD_MASK) {
536 /* Find the vm address for the guest address */
537 vmaddr = (unsigned long)
538 radix_tree_lookup(&gmap->guest_to_host,
542 vmaddr |= gaddr & ~PMD_MASK;
543 /* Find vma in the parent mm */
544 vma = find_vma(gmap->mm, vmaddr);
545 size = min(to - gaddr, PMD_SIZE - (gaddr & ~PMD_MASK));
546 zap_page_range(vma, vmaddr, size, NULL);
548 up_read(&gmap->mm->mmap_sem);
550 EXPORT_SYMBOL_GPL(gmap_discard);
552 static LIST_HEAD(gmap_notifier_list);
553 static DEFINE_SPINLOCK(gmap_notifier_lock);
556 * gmap_register_ipte_notifier - register a pte invalidation callback
557 * @nb: pointer to the gmap notifier block
559 void gmap_register_ipte_notifier(struct gmap_notifier *nb)
561 spin_lock(&gmap_notifier_lock);
562 list_add_rcu(&nb->list, &gmap_notifier_list);
563 spin_unlock(&gmap_notifier_lock);
565 EXPORT_SYMBOL_GPL(gmap_register_ipte_notifier);
568 * gmap_unregister_ipte_notifier - remove a pte invalidation callback
569 * @nb: pointer to the gmap notifier block
571 void gmap_unregister_ipte_notifier(struct gmap_notifier *nb)
573 spin_lock(&gmap_notifier_lock);
574 list_del_rcu(&nb->list);
575 spin_unlock(&gmap_notifier_lock);
578 EXPORT_SYMBOL_GPL(gmap_unregister_ipte_notifier);
581 * gmap_call_notifier - call all registered invalidation callbacks
582 * @gmap: pointer to guest mapping meta data structure
583 * @start: start virtual address in the guest address space
584 * @end: end virtual address in the guest address space
586 static void gmap_call_notifier(struct gmap *gmap, unsigned long start,
589 struct gmap_notifier *nb;
591 list_for_each_entry(nb, &gmap_notifier_list, list)
592 nb->notifier_call(gmap, start, end);
596 * gmap_ipte_notify - mark a range of ptes for invalidation notification
597 * @gmap: pointer to guest mapping meta data structure
598 * @gaddr: virtual address in the guest address space
601 * Returns 0 if for each page in the given range a gmap mapping exists and
602 * the invalidation notification could be set. If the gmap mapping is missing
603 * for one or more pages -EFAULT is returned. If no memory could be allocated
604 * -ENOMEM is returned. This function establishes missing page table entries.
606 int gmap_ipte_notify(struct gmap *gmap, unsigned long gaddr, unsigned long len)
614 if ((gaddr & ~PAGE_MASK) || (len & ~PAGE_MASK))
616 down_read(&gmap->mm->mmap_sem);
619 /* Convert gmap address and connect the page tables */
620 addr = __gmap_translate(gmap, gaddr);
621 if (IS_ERR_VALUE(addr)) {
625 /* Get the page mapped */
626 if (fixup_user_fault(current, gmap->mm, addr, FAULT_FLAG_WRITE,
631 /* While trying to map mmap_sem got unlocked. Let us retry */
634 rc = __gmap_link(gmap, gaddr, addr);
637 /* Walk the process page table, lock and get pte pointer */
638 ptep = get_locked_pte(gmap->mm, addr, &ptl);
640 /* Set notification bit in the pgste of the pte */
641 if ((pte_val(*ptep) & (_PAGE_INVALID | _PAGE_PROTECT)) == 0) {
642 ptep_set_notify(gmap->mm, addr, ptep);
646 pte_unmap_unlock(ptep, ptl);
648 up_read(&gmap->mm->mmap_sem);
651 EXPORT_SYMBOL_GPL(gmap_ipte_notify);
654 * ptep_notify - call all invalidation callbacks for a specific pte.
655 * @mm: pointer to the process mm_struct
656 * @addr: virtual address in the process address space
657 * @pte: pointer to the page table entry
659 * This function is assumed to be called with the page table lock held
660 * for the pte to notify.
662 void ptep_notify(struct mm_struct *mm, unsigned long vmaddr, pte_t *pte)
664 unsigned long offset, gaddr;
665 unsigned long *table;
668 offset = ((unsigned long) pte) & (255 * sizeof(pte_t));
669 offset = offset * (4096 / sizeof(pte_t));
671 list_for_each_entry_rcu(gmap, &mm->context.gmap_list, list) {
672 spin_lock(&gmap->guest_table_lock);
673 table = radix_tree_lookup(&gmap->host_to_guest,
674 vmaddr >> PMD_SHIFT);
676 gaddr = __gmap_segment_gaddr(table) + offset;
677 spin_unlock(&gmap->guest_table_lock);
679 gmap_call_notifier(gmap, gaddr, gaddr + PAGE_SIZE - 1);
683 EXPORT_SYMBOL_GPL(ptep_notify);
685 static inline void thp_split_mm(struct mm_struct *mm)
687 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
688 struct vm_area_struct *vma;
691 for (vma = mm->mmap; vma != NULL; vma = vma->vm_next) {
692 for (addr = vma->vm_start;
695 follow_page(vma, addr, FOLL_SPLIT);
696 vma->vm_flags &= ~VM_HUGEPAGE;
697 vma->vm_flags |= VM_NOHUGEPAGE;
699 mm->def_flags |= VM_NOHUGEPAGE;
704 * switch on pgstes for its userspace process (for kvm)
706 int s390_enable_sie(void)
708 struct mm_struct *mm = current->mm;
710 /* Do we have pgstes? if yes, we are done */
711 if (mm_has_pgste(mm))
713 /* Fail if the page tables are 2K */
714 if (!mm_alloc_pgste(mm))
716 down_write(&mm->mmap_sem);
717 mm->context.has_pgste = 1;
718 /* split thp mappings and disable thp for future mappings */
720 up_write(&mm->mmap_sem);
723 EXPORT_SYMBOL_GPL(s390_enable_sie);
726 * Enable storage key handling from now on and initialize the storage
727 * keys with the default key.
729 static int __s390_enable_skey(pte_t *pte, unsigned long addr,
730 unsigned long next, struct mm_walk *walk)
733 * Remove all zero page mappings,
734 * after establishing a policy to forbid zero page mappings
735 * following faults for that page will get fresh anonymous pages
737 if (is_zero_pfn(pte_pfn(*pte)))
738 ptep_xchg_direct(walk->mm, addr, pte, __pte(_PAGE_INVALID));
739 /* Clear storage key */
740 ptep_zap_key(walk->mm, addr, pte);
744 int s390_enable_skey(void)
746 struct mm_walk walk = { .pte_entry = __s390_enable_skey };
747 struct mm_struct *mm = current->mm;
748 struct vm_area_struct *vma;
751 down_write(&mm->mmap_sem);
755 mm->context.use_skey = 1;
756 for (vma = mm->mmap; vma; vma = vma->vm_next) {
757 if (ksm_madvise(vma, vma->vm_start, vma->vm_end,
758 MADV_UNMERGEABLE, &vma->vm_flags)) {
759 mm->context.use_skey = 0;
764 mm->def_flags &= ~VM_MERGEABLE;
767 walk_page_range(0, TASK_SIZE, &walk);
770 up_write(&mm->mmap_sem);
773 EXPORT_SYMBOL_GPL(s390_enable_skey);
776 * Reset CMMA state, make all pages stable again.
778 static int __s390_reset_cmma(pte_t *pte, unsigned long addr,
779 unsigned long next, struct mm_walk *walk)
781 ptep_zap_unused(walk->mm, addr, pte, 1);
785 void s390_reset_cmma(struct mm_struct *mm)
787 struct mm_walk walk = { .pte_entry = __s390_reset_cmma };
789 down_write(&mm->mmap_sem);
791 walk_page_range(0, TASK_SIZE, &walk);
792 up_write(&mm->mmap_sem);
794 EXPORT_SYMBOL_GPL(s390_reset_cmma);