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_radix.h>
  55 #include <vm/vm_reserv.h>
  56 #include <vm/vm_extern.h>
  57
  58 #include <vm/uma.h>
  59 #include <vm/uma_int.h>
  60
  61 #include <linux/gfp.h>
  62 #include <linux/mm.h>
  63 #include <linux/preempt.h>
  64
  65 #if defined(__amd64__) || defined(__aarch64__) || defined(__riscv__)
  66 #define LINUXKPI_HAVE_DMAP
  67 #else
  68 #undef  LINUXKPI_HAVE_DMAP
  69 #endif
  70
  71 void *
  72 linux_page_address(struct page *page)
  73 {
  74 #ifdef LINUXKPI_HAVE_DMAP
  75         return ((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(page)));
  76 #else
  77         if (page->object != kmem_object && page->object != kernel_object)
  78                 return (NULL);
  79         return ((void *)(uintptr_t)(VM_MIN_KERNEL_ADDRESS +
  80             IDX_TO_OFF(page->pindex)));
  81 #endif
  82 }
  83
  84 vm_page_t
  85 linux_alloc_pages(gfp_t flags, unsigned int order)
  86 {
  87 #ifdef LINUXKPI_HAVE_DMAP
  88         unsigned long npages = 1UL << order;
  89         int req = (flags & M_ZERO) ? (VM_ALLOC_ZERO | VM_ALLOC_NOOBJ |
  90             VM_ALLOC_NORMAL) : (VM_ALLOC_NOOBJ | VM_ALLOC_NORMAL);
  91         vm_page_t page;
  92
  93         if (order == 0 && (flags & GFP_DMA32) == 0) {
  94                 page = vm_page_alloc(NULL, 0, req);
  95                 if (page == NULL)
  96                         return (NULL);
  97         } else {
  98                 vm_paddr_t pmax = (flags & GFP_DMA32) ?
  99                     BUS_SPACE_MAXADDR_32BIT : BUS_SPACE_MAXADDR;
 100 retry:
 101                 page = vm_page_alloc_contig(NULL, 0, req,
 102                     npages, 0, pmax, PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);
 103
 104                 if (page == NULL) {
 105                         if (flags & M_WAITOK) {
 106                                 if (!vm_page_reclaim_contig(req,
 107                                     npages, 0, pmax, PAGE_SIZE, 0)) {
 108                                         VM_WAIT;
 109                                 }
 110                                 flags &= ~M_WAITOK;
 111                                 goto retry;
 112                         }
 113                         return (NULL);
 114                 }
 115         }
 116         if (flags & M_ZERO) {
 117                 unsigned long x;
 118
 119                 for (x = 0; x != npages; x++) {
 120                         vm_page_t pgo = page + x;
 121
 122                         if ((pgo->flags & PG_ZERO) == 0)
 123                                 pmap_zero_page(pgo);
 124                 }
 125         }
 126 #else
 127         vm_offset_t vaddr;
 128         vm_page_t page;
 129
 130         vaddr = linux_alloc_kmem(flags, order);
 131         if (vaddr == 0)
 132                 return (NULL);
 133
 134         page = PHYS_TO_VM_PAGE(vtophys((void *)vaddr));
 135
 136         KASSERT(vaddr == (vm_offset_t)page_address(page),
 137             ("Page address mismatch"));
 138 #endif
 139         return (page);
 140 }
 141
 142 void
 143 linux_free_pages(vm_page_t page, unsigned int order)
 144 {
 145 #ifdef LINUXKPI_HAVE_DMAP
 146         unsigned long npages = 1UL << order;
 147         unsigned long x;
 148
 149         for (x = 0; x != npages; x++) {
 150                 vm_page_t pgo = page + x;
 151
 152                 vm_page_lock(pgo);
 153                 vm_page_free(pgo);
 154                 vm_page_unlock(pgo);
 155         }
 156 #else
 157         vm_offset_t vaddr;
 158
 159         vaddr = (vm_offset_t)page_address(page);
 160
 161         linux_free_kmem(vaddr, order);
 162 #endif
 163 }
 164
 165 vm_offset_t
 166 linux_alloc_kmem(gfp_t flags, unsigned int order)
 167 {
 168         size_t size = ((size_t)PAGE_SIZE) << order;
 169         vm_offset_t addr;
 170
 171         if ((flags & GFP_DMA32) == 0) {
 172                 addr = kmem_malloc(kmem_arena, size, flags & GFP_NATIVE_MASK);
 173         } else {
 174                 addr = kmem_alloc_contig(kmem_arena, size,
 175                     flags & GFP_NATIVE_MASK, 0, BUS_SPACE_MAXADDR_32BIT,
 176                     PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);
 177         }
 178         return (addr);
 179 }
 180
 181 void
 182 linux_free_kmem(vm_offset_t addr, unsigned int order)
 183 {
 184         size_t size = ((size_t)PAGE_SIZE) << order;
 185
 186         kmem_free(kmem_arena, addr, size);
 187 }
 188
 189 static int
 190 linux_get_user_pages_internal(vm_map_t map, unsigned long start, int nr_pages,
 191     int write, struct page **pages)
 192 {
 193         vm_prot_t prot;
 194         size_t len;
 195         int count;
 196         int i;
 197
 198         prot = write ? (VM_PROT_READ | VM_PROT_WRITE) : VM_PROT_READ;
 199         len = ((size_t)nr_pages) << PAGE_SHIFT;
 200         count = vm_fault_quick_hold_pages(map, start, len, prot, pages, nr_pages);
 201         if (count == -1)
 202                 return (-EFAULT);
 203
 204         for (i = 0; i != nr_pages; i++) {
 205                 struct page *pg = pages[i];
 206
 207                 vm_page_lock(pg);
 208                 vm_page_wire(pg);
 209                 vm_page_unlock(pg);
 210         }
 211         return (nr_pages);
 212 }
 213
 214 int
 215 __get_user_pages_fast(unsigned long start, int nr_pages, int write,
 216     struct page **pages)
 217 {
 218         vm_map_t map;
 219         vm_page_t *mp;
 220         vm_offset_t va;
 221         vm_offset_t end;
 222         vm_prot_t prot;
 223         int count;
 224
 225         if (nr_pages == 0 || in_interrupt())
 226                 return (0);
 227
 228         MPASS(pages != NULL);
 229         va = start;
 230         map = &curthread->td_proc->p_vmspace->vm_map;
 231         end = start + (((size_t)nr_pages) << PAGE_SHIFT);
 232         if (start < vm_map_min(map) || end > vm_map_max(map))
 233                 return (-EINVAL);
 234         prot = write ? (VM_PROT_READ | VM_PROT_WRITE) : VM_PROT_READ;
 235         for (count = 0, mp = pages, va = start; va < end;
 236             mp++, va += PAGE_SIZE, count++) {
 237                 *mp = pmap_extract_and_hold(map->pmap, va, prot);
 238                 if (*mp == NULL)
 239                         break;
 240
 241                 vm_page_lock(*mp);
 242                 vm_page_wire(*mp);
 243                 vm_page_unlock(*mp);
 244
 245                 if ((prot & VM_PROT_WRITE) != 0 &&
 246                     (*mp)->dirty != VM_PAGE_BITS_ALL) {
 247                         /*
 248                          * Explicitly dirty the physical page.  Otherwise, the
 249                          * caller's changes may go unnoticed because they are
 250                          * performed through an unmanaged mapping or by a DMA
 251                          * operation.
 252                          *
 253                          * The object lock is not held here.
 254                          * See vm_page_clear_dirty_mask().
 255                          */
 256                         vm_page_dirty(*mp);
 257                 }
 258         }
 259         return (count);
 260 }
 261
 262 long
 263 get_user_pages_remote(struct task_struct *task, struct mm_struct *mm,
 264     unsigned long start, unsigned long nr_pages, int gup_flags,
 265     struct page **pages, struct vm_area_struct **vmas)
 266 {
 267         vm_map_t map;
 268
 269         map = &mm->vmspace->vm_map;
 270         return (linux_get_user_pages_internal(map, start, nr_pages,
 271             !!(gup_flags & FOLL_WRITE), pages));
 272 }
 273
 274 long
 275 get_user_pages(unsigned long start, unsigned long nr_pages, int gup_flags,
 276     struct page **pages, struct vm_area_struct **vmas)
 277 {
 278         vm_map_t map;
 279
 280         map = &curthread->td_proc->p_vmspace->vm_map;
 281         return (linux_get_user_pages_internal(map, start, nr_pages,
 282             !!(gup_flags & FOLL_WRITE), pages));
 283 }
 284
 285 int
 286 is_vmalloc_addr(const void *addr)
 287 {
 288         return (vtoslab((vm_offset_t)addr & ~UMA_SLAB_MASK) != NULL);
 289 }