sys/compat/linuxkpi/common/src/linux_page.c

   1 /*-
   2  * Copyright (c) 2010 Isilon Systems, Inc.
   3  * Copyright (c) 2016 Matt Macy (mmacy@nextbsd.org)
   4  * Copyright (c) 2017 Mellanox Technologies, Ltd.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice unmodified, this list of conditions, and the following
  12  *    disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/malloc.h>
  35 #include <sys/kernel.h>
  36 #include <sys/sysctl.h>
  37 #include <sys/lock.h>
  38 #include <sys/mutex.h>
  39 #include <sys/rwlock.h>
  40 #include <sys/proc.h>
  41 #include <sys/sched.h>
  42
  43 #include <machine/bus.h>
  44
  45 #include <vm/vm.h>
  46 #include <vm/pmap.h>
  47 #include <vm/vm_param.h>
  48 #include <vm/vm_kern.h>
  49 #include <vm/vm_object.h>
  50 #include <vm/vm_map.h>
  51 #include <vm/vm_page.h>
  52 #include <vm/vm_pageout.h>
  53 #include <vm/vm_pager.h>
  54 #include <vm/vm_phys.h>
  55 #include <vm/vm_radix.h>
  56 #include <vm/vm_reserv.h>
  57 #include <vm/vm_extern.h>
  58
  59 #include <vm/uma.h>
  60 #include <vm/uma_int.h>
  61
  62 #include <linux/gfp.h>
  63 #include <linux/mm.h>
  64 #include <linux/preempt.h>
  65
  66 #if defined(__amd64__) || defined(__aarch64__) || defined(__riscv__)
  67 #define LINUXKPI_HAVE_DMAP
  68 #else
  69 #undef  LINUXKPI_HAVE_DMAP
  70 #endif
  71
  72 void *
  73 linux_page_address(struct page *page)
  74 {
  75 #ifdef LINUXKPI_HAVE_DMAP
  76         return ((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(page)));
  77 #else
  78         if (page->object != kmem_object && page->object != kernel_object)
  79                 return (NULL);
  80         return ((void *)(uintptr_t)(VM_MIN_KERNEL_ADDRESS +
  81             IDX_TO_OFF(page->pindex)));
  82 #endif
  83 }
  84
  85 vm_page_t
  86 linux_alloc_pages(gfp_t flags, unsigned int order)
  87 {
  88 #ifdef LINUXKPI_HAVE_DMAP
  89         unsigned long npages = 1UL << order;
  90         int req = (flags & M_ZERO) ? (VM_ALLOC_ZERO | VM_ALLOC_NOOBJ |
  91             VM_ALLOC_NORMAL) : (VM_ALLOC_NOOBJ | VM_ALLOC_NORMAL);
  92         vm_page_t page;
  93
  94         if (order == 0 && (flags & GFP_DMA32) == 0) {
  95                 page = vm_page_alloc(NULL, 0, req);
  96                 if (page == NULL)
  97                         return (NULL);
  98         } else {
  99                 vm_paddr_t pmax = (flags & GFP_DMA32) ?
 100                     BUS_SPACE_MAXADDR_32BIT : BUS_SPACE_MAXADDR;
 101 retry:
 102                 page = vm_page_alloc_contig(NULL, 0, req,
 103                     npages, 0, pmax, PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);
 104
 105                 if (page == NULL) {
 106                         if (flags & M_WAITOK) {
 107                                 if (!vm_page_reclaim_contig(req,
 108                                     npages, 0, pmax, PAGE_SIZE, 0)) {
 109                                         VM_WAIT;
 110                                 }
 111                                 flags &= ~M_WAITOK;
 112                                 goto retry;
 113                         }
 114                         return (NULL);
 115                 }
 116         }
 117         if (flags & M_ZERO) {
 118                 unsigned long x;
 119
 120                 for (x = 0; x != npages; x++) {
 121                         vm_page_t pgo = page + x;
 122
 123                         if ((pgo->flags & PG_ZERO) == 0)
 124                                 pmap_zero_page(pgo);
 125                 }
 126         }
 127 #else
 128         vm_offset_t vaddr;
 129         vm_page_t page;
 130
 131         vaddr = linux_alloc_kmem(flags, order);
 132         if (vaddr == 0)
 133                 return (NULL);
 134
 135         page = PHYS_TO_VM_PAGE(vtophys((void *)vaddr));
 136
 137         KASSERT(vaddr == (vm_offset_t)page_address(page),
 138             ("Page address mismatch"));
 139 #endif
 140         return (page);
 141 }
 142
 143 void
 144 linux_free_pages(vm_page_t page, unsigned int order)
 145 {
 146 #ifdef LINUXKPI_HAVE_DMAP
 147         unsigned long npages = 1UL << order;
 148         unsigned long x;
 149
 150         for (x = 0; x != npages; x++) {
 151                 vm_page_t pgo = page + x;
 152
 153                 vm_page_lock(pgo);
 154                 vm_page_free(pgo);
 155                 vm_page_unlock(pgo);
 156         }
 157 #else
 158         vm_offset_t vaddr;
 159
 160         vaddr = (vm_offset_t)page_address(page);
 161
 162         linux_free_kmem(vaddr, order);
 163 #endif
 164 }
 165
 166 vm_offset_t
 167 linux_alloc_kmem(gfp_t flags, unsigned int order)
 168 {
 169         size_t size = ((size_t)PAGE_SIZE) << order;
 170         vm_offset_t addr;
 171
 172         if ((flags & GFP_DMA32) == 0) {
 173                 addr = kmem_malloc(kmem_arena, size, flags & GFP_NATIVE_MASK);
 174         } else {
 175                 addr = kmem_alloc_contig(kmem_arena, size,
 176                     flags & GFP_NATIVE_MASK, 0, BUS_SPACE_MAXADDR_32BIT,
 177                     PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);
 178         }
 179         return (addr);
 180 }
 181
 182 void
 183 linux_free_kmem(vm_offset_t addr, unsigned int order)
 184 {
 185         size_t size = ((size_t)PAGE_SIZE) << order;
 186
 187         kmem_free(kmem_arena, addr, size);
 188 }
 189
 190 static int
 191 linux_get_user_pages_internal(vm_map_t map, unsigned long start, int nr_pages,
 192     int write, struct page **pages)
 193 {
 194         vm_prot_t prot;
 195         size_t len;
 196         int count;
 197         int i;
 198
 199         prot = write ? (VM_PROT_READ | VM_PROT_WRITE) : VM_PROT_READ;
 200         len = ((size_t)nr_pages) << PAGE_SHIFT;
 201         count = vm_fault_quick_hold_pages(map, start, len, prot, pages, nr_pages);
 202         if (count == -1)
 203                 return (-EFAULT);
 204
 205         for (i = 0; i != nr_pages; i++) {
 206                 struct page *pg = pages[i];
 207
 208                 vm_page_lock(pg);
 209                 vm_page_wire(pg);
 210                 vm_page_unlock(pg);
 211         }
 212         return (nr_pages);
 213 }
 214
 215 int
 216 __get_user_pages_fast(unsigned long start, int nr_pages, int write,
 217     struct page **pages)
 218 {
 219         vm_map_t map;
 220         vm_page_t *mp;
 221         vm_offset_t va;
 222         vm_offset_t end;
 223         vm_prot_t prot;
 224         int count;
 225
 226         if (nr_pages == 0 || in_interrupt())
 227                 return (0);
 228
 229         MPASS(pages != NULL);
 230         va = start;
 231         map = &curthread->td_proc->p_vmspace->vm_map;
 232         end = start + (((size_t)nr_pages) << PAGE_SHIFT);
 233         if (start < vm_map_min(map) || end > vm_map_max(map))
 234                 return (-EINVAL);
 235         prot = write ? (VM_PROT_READ | VM_PROT_WRITE) : VM_PROT_READ;
 236         for (count = 0, mp = pages, va = start; va < end;
 237             mp++, va += PAGE_SIZE, count++) {
 238                 *mp = pmap_extract_and_hold(map->pmap, va, prot);
 239                 if (*mp == NULL)
 240                         break;
 241
 242                 vm_page_lock(*mp);
 243                 vm_page_wire(*mp);
 244                 vm_page_unlock(*mp);
 245
 246                 if ((prot & VM_PROT_WRITE) != 0 &&
 247                     (*mp)->dirty != VM_PAGE_BITS_ALL) {
 248                         /*
 249                          * Explicitly dirty the physical page.  Otherwise, the
 250                          * caller's changes may go unnoticed because they are
 251                          * performed through an unmanaged mapping or by a DMA
 252                          * operation.
 253                          *
 254                          * The object lock is not held here.
 255                          * See vm_page_clear_dirty_mask().
 256                          */
 257                         vm_page_dirty(*mp);
 258                 }
 259         }
 260         return (count);
 261 }
 262
 263 long
 264 get_user_pages_remote(struct task_struct *task, struct mm_struct *mm,
 265     unsigned long start, unsigned long nr_pages, int gup_flags,
 266     struct page **pages, struct vm_area_struct **vmas)
 267 {
 268         vm_map_t map;
 269
 270         map = &mm->vmspace->vm_map;
 271         return (linux_get_user_pages_internal(map, start, nr_pages,
 272             !!(gup_flags & FOLL_WRITE), pages));
 273 }
 274
 275 long
 276 get_user_pages(unsigned long start, unsigned long nr_pages, int gup_flags,
 277     struct page **pages, struct vm_area_struct **vmas)
 278 {
 279         vm_map_t map;
 280
 281         map = &curthread->td_proc->p_vmspace->vm_map;
 282         return (linux_get_user_pages_internal(map, start, nr_pages,
 283             !!(gup_flags & FOLL_WRITE), pages));
 284 }
 285
 286 int
 287 is_vmalloc_addr(const void *addr)
 288 {
 289         return (vtoslab((vm_offset_t)addr & ~UMA_SLAB_MASK) != NULL);
 290 }