The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/vm/vm_mmap.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1988 University of Utah.
    3  * Copyright (c) 1991, 1993
    4  *      The Regents of the University of California.  All rights reserved.
    5  *
    6  * This code is derived from software contributed to Berkeley by
    7  * the Systems Programming Group of the University of Utah Computer
    8  * Science Department.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 4. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  *
   34  * from: Utah $Hdr: vm_mmap.c 1.6 91/10/21$
   35  *
   36  *      @(#)vm_mmap.c   8.4 (Berkeley) 1/12/94
   37  */
   38 
   39 /*
   40  * Mapped file (mmap) interface to VM
   41  */
   42 
   43 #include <sys/cdefs.h>
   44 __FBSDID("$FreeBSD$");
   45 
   46 #include "opt_compat.h"
   47 #include "opt_hwpmc_hooks.h"
   48 #include "opt_vm.h"
   49 
   50 #include <sys/param.h>
   51 #include <sys/systm.h>
   52 #include <sys/capsicum.h>
   53 #include <sys/kernel.h>
   54 #include <sys/lock.h>
   55 #include <sys/mutex.h>
   56 #include <sys/sysproto.h>
   57 #include <sys/filedesc.h>
   58 #include <sys/priv.h>
   59 #include <sys/proc.h>
   60 #include <sys/procctl.h>
   61 #include <sys/racct.h>
   62 #include <sys/resource.h>
   63 #include <sys/resourcevar.h>
   64 #include <sys/rwlock.h>
   65 #include <sys/sysctl.h>
   66 #include <sys/vnode.h>
   67 #include <sys/fcntl.h>
   68 #include <sys/file.h>
   69 #include <sys/mman.h>
   70 #include <sys/mount.h>
   71 #include <sys/conf.h>
   72 #include <sys/stat.h>
   73 #include <sys/syscallsubr.h>
   74 #include <sys/sysent.h>
   75 #include <sys/vmmeter.h>
   76 
   77 #include <security/audit/audit.h>
   78 #include <security/mac/mac_framework.h>
   79 
   80 #include <vm/vm.h>
   81 #include <vm/vm_param.h>
   82 #include <vm/pmap.h>
   83 #include <vm/vm_map.h>
   84 #include <vm/vm_object.h>
   85 #include <vm/vm_page.h>
   86 #include <vm/vm_pager.h>
   87 #include <vm/vm_pageout.h>
   88 #include <vm/vm_extern.h>
   89 #include <vm/vm_page.h>
   90 #include <vm/vnode_pager.h>
   91 
   92 #ifdef HWPMC_HOOKS
   93 #include <sys/pmckern.h>
   94 #endif
   95 
   96 int old_mlock = 0;
   97 SYSCTL_INT(_vm, OID_AUTO, old_mlock, CTLFLAG_RWTUN, &old_mlock, 0,
   98     "Do not apply RLIMIT_MEMLOCK on mlockall");
   99 static int mincore_mapped = 1;
  100 SYSCTL_INT(_vm, OID_AUTO, mincore_mapped, CTLFLAG_RWTUN, &mincore_mapped, 0,
  101     "mincore reports mappings, not residency");
  102 
  103 #ifdef MAP_32BIT
  104 #define MAP_32BIT_MAX_ADDR      ((vm_offset_t)1 << 31)
  105 #endif
  106 
  107 #ifndef _SYS_SYSPROTO_H_
  108 struct sbrk_args {
  109         int incr;
  110 };
  111 #endif
  112 
  113 int
  114 sys_sbrk(struct thread *td, struct sbrk_args *uap)
  115 {
  116         /* Not yet implemented */
  117         return (EOPNOTSUPP);
  118 }
  119 
  120 #ifndef _SYS_SYSPROTO_H_
  121 struct sstk_args {
  122         int incr;
  123 };
  124 #endif
  125 
  126 int
  127 sys_sstk(struct thread *td, struct sstk_args *uap)
  128 {
  129         /* Not yet implemented */
  130         return (EOPNOTSUPP);
  131 }
  132 
  133 #if defined(COMPAT_43)
  134 #ifndef _SYS_SYSPROTO_H_
  135 struct getpagesize_args {
  136         int dummy;
  137 };
  138 #endif
  139 
  140 int
  141 ogetpagesize(struct thread *td, struct getpagesize_args *uap)
  142 {
  143 
  144         td->td_retval[0] = PAGE_SIZE;
  145         return (0);
  146 }
  147 #endif                          /* COMPAT_43 */
  148 
  149 
  150 /*
  151  * Memory Map (mmap) system call.  Note that the file offset
  152  * and address are allowed to be NOT page aligned, though if
  153  * the MAP_FIXED flag it set, both must have the same remainder
  154  * modulo the PAGE_SIZE (POSIX 1003.1b).  If the address is not
  155  * page-aligned, the actual mapping starts at trunc_page(addr)
  156  * and the return value is adjusted up by the page offset.
  157  *
  158  * Generally speaking, only character devices which are themselves
  159  * memory-based, such as a video framebuffer, can be mmap'd.  Otherwise
  160  * there would be no cache coherency between a descriptor and a VM mapping
  161  * both to the same character device.
  162  */
  163 #ifndef _SYS_SYSPROTO_H_
  164 struct mmap_args {
  165         void *addr;
  166         size_t len;
  167         int prot;
  168         int flags;
  169         int fd;
  170         long pad;
  171         off_t pos;
  172 };
  173 #endif
  174 
  175 int
  176 sys_mmap(struct thread *td, struct mmap_args *uap)
  177 {
  178 
  179         return (kern_mmap(td, (uintptr_t)uap->addr, uap->len, uap->prot,
  180             uap->flags, uap->fd, uap->pos));
  181 }
  182 
  183 int
  184 kern_mmap(struct thread *td, uintptr_t addr0, size_t size, int prot, int flags,
  185     int fd, off_t pos)
  186 {
  187 
  188         return (kern_mmap_fpcheck(td, addr0, size, prot, flags, fd, pos, NULL));
  189 }
  190 
  191 /*
  192  * When mmap'ing a file, check_fp_fn may be used for the caller to do any
  193  * last-minute validation based on the referenced file in a non-racy way.
  194  */
  195 int
  196 kern_mmap_fpcheck(struct thread *td, uintptr_t addr0, size_t size, int prot,
  197     int flags, int fd, off_t pos, mmap_check_fp_fn check_fp_fn)
  198 {
  199         struct vmspace *vms;
  200         struct file *fp;
  201         vm_offset_t addr;
  202         vm_size_t pageoff;
  203         vm_prot_t cap_maxprot;
  204         int align, error;
  205         cap_rights_t rights;
  206 
  207         vms = td->td_proc->p_vmspace;
  208         fp = NULL;
  209         AUDIT_ARG_FD(fd);
  210         addr = addr0;
  211 
  212         /*
  213          * Ignore old flags that used to be defined but did not do anything.
  214          */
  215         flags &= ~(MAP_RESERVED0020 | MAP_RESERVED0040);
  216         
  217         /*
  218          * Enforce the constraints.
  219          * Mapping of length 0 is only allowed for old binaries.
  220          * Anonymous mapping shall specify -1 as filedescriptor and
  221          * zero position for new code. Be nice to ancient a.out
  222          * binaries and correct pos for anonymous mapping, since old
  223          * ld.so sometimes issues anonymous map requests with non-zero
  224          * pos.
  225          */
  226         if (!SV_CURPROC_FLAG(SV_AOUT)) {
  227                 if ((size == 0 && curproc->p_osrel >= P_OSREL_MAP_ANON) ||
  228                     ((flags & MAP_ANON) != 0 && (fd != -1 || pos != 0)))
  229                         return (EINVAL);
  230         } else {
  231                 if ((flags & MAP_ANON) != 0)
  232                         pos = 0;
  233         }
  234 
  235         if (flags & MAP_STACK) {
  236                 if ((fd != -1) ||
  237                     ((prot & (PROT_READ | PROT_WRITE)) != (PROT_READ | PROT_WRITE)))
  238                         return (EINVAL);
  239                 flags |= MAP_ANON;
  240                 pos = 0;
  241         }
  242         if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_HASSEMAPHORE |
  243             MAP_STACK | MAP_NOSYNC | MAP_ANON | MAP_EXCL | MAP_NOCORE |
  244             MAP_PREFAULT_READ | MAP_GUARD |
  245 #ifdef MAP_32BIT
  246             MAP_32BIT |
  247 #endif
  248             MAP_ALIGNMENT_MASK)) != 0)
  249                 return (EINVAL);
  250         if ((flags & (MAP_EXCL | MAP_FIXED)) == MAP_EXCL)
  251                 return (EINVAL);
  252         if ((flags & (MAP_SHARED | MAP_PRIVATE)) == (MAP_SHARED | MAP_PRIVATE))
  253                 return (EINVAL);
  254         if (prot != PROT_NONE &&
  255             (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC)) != 0)
  256                 return (EINVAL);
  257         if ((flags & MAP_GUARD) != 0 && (prot != PROT_NONE || fd != -1 ||
  258             pos != 0 || (flags & (MAP_SHARED | MAP_PRIVATE | MAP_PREFAULT |
  259             MAP_PREFAULT_READ | MAP_ANON | MAP_STACK)) != 0))
  260                 return (EINVAL);
  261 
  262         /*
  263          * Align the file position to a page boundary,
  264          * and save its page offset component.
  265          */
  266         pageoff = (pos & PAGE_MASK);
  267         pos -= pageoff;
  268 
  269         /* Adjust size for rounding (on both ends). */
  270         size += pageoff;                        /* low end... */
  271         size = (vm_size_t) round_page(size);    /* hi end */
  272 
  273         /* Ensure alignment is at least a page and fits in a pointer. */
  274         align = flags & MAP_ALIGNMENT_MASK;
  275         if (align != 0 && align != MAP_ALIGNED_SUPER &&
  276             (align >> MAP_ALIGNMENT_SHIFT >= sizeof(void *) * NBBY ||
  277             align >> MAP_ALIGNMENT_SHIFT < PAGE_SHIFT))
  278                 return (EINVAL);
  279 
  280         /*
  281          * Check for illegal addresses.  Watch out for address wrap... Note
  282          * that VM_*_ADDRESS are not constants due to casts (argh).
  283          */
  284         if (flags & MAP_FIXED) {
  285                 /*
  286                  * The specified address must have the same remainder
  287                  * as the file offset taken modulo PAGE_SIZE, so it
  288                  * should be aligned after adjustment by pageoff.
  289                  */
  290                 addr -= pageoff;
  291                 if (addr & PAGE_MASK)
  292                         return (EINVAL);
  293 
  294                 /* Address range must be all in user VM space. */
  295                 if (addr < vm_map_min(&vms->vm_map) ||
  296                     addr + size > vm_map_max(&vms->vm_map))
  297                         return (EINVAL);
  298                 if (addr + size < addr)
  299                         return (EINVAL);
  300 #ifdef MAP_32BIT
  301                 if (flags & MAP_32BIT && addr + size > MAP_32BIT_MAX_ADDR)
  302                         return (EINVAL);
  303         } else if (flags & MAP_32BIT) {
  304                 /*
  305                  * For MAP_32BIT, override the hint if it is too high and
  306                  * do not bother moving the mapping past the heap (since
  307                  * the heap is usually above 2GB).
  308                  */
  309                 if (addr + size > MAP_32BIT_MAX_ADDR)
  310                         addr = 0;
  311 #endif
  312         } else {
  313                 /*
  314                  * XXX for non-fixed mappings where no hint is provided or
  315                  * the hint would fall in the potential heap space,
  316                  * place it after the end of the largest possible heap.
  317                  *
  318                  * There should really be a pmap call to determine a reasonable
  319                  * location.
  320                  */
  321                 if (addr == 0 ||
  322                     (addr >= round_page((vm_offset_t)vms->vm_taddr) &&
  323                     addr < round_page((vm_offset_t)vms->vm_daddr +
  324                     lim_max(td, RLIMIT_DATA))))
  325                         addr = round_page((vm_offset_t)vms->vm_daddr +
  326                             lim_max(td, RLIMIT_DATA));
  327         }
  328         if (size == 0) {
  329                 /*
  330                  * Return success without mapping anything for old
  331                  * binaries that request a page-aligned mapping of
  332                  * length 0.  For modern binaries, this function
  333                  * returns an error earlier.
  334                  */
  335                 error = 0;
  336         } else if ((flags & MAP_GUARD) != 0) {
  337                 error = vm_mmap_object(&vms->vm_map, &addr, size, VM_PROT_NONE,
  338                     VM_PROT_NONE, flags, NULL, pos, FALSE, td);
  339         } else if ((flags & MAP_ANON) != 0) {
  340                 /*
  341                  * Mapping blank space is trivial.
  342                  *
  343                  * This relies on VM_PROT_* matching PROT_*.
  344                  */
  345                 error = vm_mmap_object(&vms->vm_map, &addr, size, prot,
  346                     VM_PROT_ALL, flags, NULL, pos, FALSE, td);
  347         } else {
  348                 /*
  349                  * Mapping file, get fp for validation and don't let the
  350                  * descriptor disappear on us if we block. Check capability
  351                  * rights, but also return the maximum rights to be combined
  352                  * with maxprot later.
  353                  */
  354                 cap_rights_init(&rights, CAP_MMAP);
  355                 if (prot & PROT_READ)
  356                         cap_rights_set(&rights, CAP_MMAP_R);
  357                 if ((flags & MAP_SHARED) != 0) {
  358                         if (prot & PROT_WRITE)
  359                                 cap_rights_set(&rights, CAP_MMAP_W);
  360                 }
  361                 if (prot & PROT_EXEC)
  362                         cap_rights_set(&rights, CAP_MMAP_X);
  363                 error = fget_mmap(td, fd, &rights, &cap_maxprot, &fp);
  364                 if (error != 0)
  365                         goto done;
  366                 if ((flags & (MAP_SHARED | MAP_PRIVATE)) == 0 &&
  367                     td->td_proc->p_osrel >= P_OSREL_MAP_FSTRICT) {
  368                         error = EINVAL;
  369                         goto done;
  370                 }
  371                 if (check_fp_fn != NULL) {
  372                         error = check_fp_fn(fp, prot, cap_maxprot, flags);
  373                         if (error != 0)
  374                                 goto done;
  375                 }
  376                 /* This relies on VM_PROT_* matching PROT_*. */
  377                 error = fo_mmap(fp, &vms->vm_map, &addr, size, prot,
  378                     cap_maxprot, flags, pos, td);
  379         }
  380 
  381         if (error == 0)
  382                 td->td_retval[0] = (register_t) (addr + pageoff);
  383 done:
  384         if (fp)
  385                 fdrop(fp, td);
  386 
  387         return (error);
  388 }
  389 
  390 #if defined(COMPAT_FREEBSD6)
  391 int
  392 freebsd6_mmap(struct thread *td, struct freebsd6_mmap_args *uap)
  393 {
  394 
  395         return (kern_mmap(td, (uintptr_t)uap->addr, uap->len, uap->prot,
  396             uap->flags, uap->fd, uap->pos));
  397 }
  398 #endif
  399 
  400 #ifdef COMPAT_43
  401 #ifndef _SYS_SYSPROTO_H_
  402 struct ommap_args {
  403         caddr_t addr;
  404         int len;
  405         int prot;
  406         int flags;
  407         int fd;
  408         long pos;
  409 };
  410 #endif
  411 int
  412 ommap(struct thread *td, struct ommap_args *uap)
  413 {
  414         static const char cvtbsdprot[8] = {
  415                 0,
  416                 PROT_EXEC,
  417                 PROT_WRITE,
  418                 PROT_EXEC | PROT_WRITE,
  419                 PROT_READ,
  420                 PROT_EXEC | PROT_READ,
  421                 PROT_WRITE | PROT_READ,
  422                 PROT_EXEC | PROT_WRITE | PROT_READ,
  423         };
  424         int flags, prot;
  425 
  426 #define OMAP_ANON       0x0002
  427 #define OMAP_COPY       0x0020
  428 #define OMAP_SHARED     0x0010
  429 #define OMAP_FIXED      0x0100
  430 
  431         prot = cvtbsdprot[uap->prot & 0x7];
  432 #ifdef COMPAT_FREEBSD32
  433 #if defined(__amd64__)
  434         if (i386_read_exec && SV_PROC_FLAG(td->td_proc, SV_ILP32) &&
  435             prot != 0)
  436                 prot |= PROT_EXEC;
  437 #endif
  438 #endif
  439         flags = 0;
  440         if (uap->flags & OMAP_ANON)
  441                 flags |= MAP_ANON;
  442         if (uap->flags & OMAP_COPY)
  443                 flags |= MAP_COPY;
  444         if (uap->flags & OMAP_SHARED)
  445                 flags |= MAP_SHARED;
  446         else
  447                 flags |= MAP_PRIVATE;
  448         if (uap->flags & OMAP_FIXED)
  449                 flags |= MAP_FIXED;
  450         return (kern_mmap(td, (uintptr_t)uap->addr, uap->len, prot, flags,
  451             uap->fd, uap->pos));
  452 }
  453 #endif                          /* COMPAT_43 */
  454 
  455 
  456 #ifndef _SYS_SYSPROTO_H_
  457 struct msync_args {
  458         void *addr;
  459         size_t len;
  460         int flags;
  461 };
  462 #endif
  463 int
  464 sys_msync(struct thread *td, struct msync_args *uap)
  465 {
  466 
  467         return (kern_msync(td, (uintptr_t)uap->addr, uap->len, uap->flags));
  468 }
  469 
  470 int
  471 kern_msync(struct thread *td, uintptr_t addr0, size_t size, int flags)
  472 {
  473         vm_offset_t addr;
  474         vm_size_t pageoff;
  475         vm_map_t map;
  476         int rv;
  477 
  478         addr = addr0;
  479         pageoff = (addr & PAGE_MASK);
  480         addr -= pageoff;
  481         size += pageoff;
  482         size = (vm_size_t) round_page(size);
  483         if (addr + size < addr)
  484                 return (EINVAL);
  485 
  486         if ((flags & (MS_ASYNC|MS_INVALIDATE)) == (MS_ASYNC|MS_INVALIDATE))
  487                 return (EINVAL);
  488 
  489         map = &td->td_proc->p_vmspace->vm_map;
  490 
  491         /*
  492          * Clean the pages and interpret the return value.
  493          */
  494         rv = vm_map_sync(map, addr, addr + size, (flags & MS_ASYNC) == 0,
  495             (flags & MS_INVALIDATE) != 0);
  496         switch (rv) {
  497         case KERN_SUCCESS:
  498                 return (0);
  499         case KERN_INVALID_ADDRESS:
  500                 return (ENOMEM);
  501         case KERN_INVALID_ARGUMENT:
  502                 return (EBUSY);
  503         case KERN_FAILURE:
  504                 return (EIO);
  505         default:
  506                 return (EINVAL);
  507         }
  508 }
  509 
  510 #ifndef _SYS_SYSPROTO_H_
  511 struct munmap_args {
  512         void *addr;
  513         size_t len;
  514 };
  515 #endif
  516 int
  517 sys_munmap(struct thread *td, struct munmap_args *uap)
  518 {
  519 
  520         return (kern_munmap(td, (uintptr_t)uap->addr, uap->len));
  521 }
  522 
  523 int
  524 kern_munmap(struct thread *td, uintptr_t addr0, size_t size)
  525 {
  526 #ifdef HWPMC_HOOKS
  527         struct pmckern_map_out pkm;
  528         vm_map_entry_t entry;
  529         bool pmc_handled;
  530 #endif
  531         vm_offset_t addr;
  532         vm_size_t pageoff;
  533         vm_map_t map;
  534 
  535         if (size == 0)
  536                 return (EINVAL);
  537 
  538         addr = addr0;
  539         pageoff = (addr & PAGE_MASK);
  540         addr -= pageoff;
  541         size += pageoff;
  542         size = (vm_size_t) round_page(size);
  543         if (addr + size < addr)
  544                 return (EINVAL);
  545 
  546         /*
  547          * Check for illegal addresses.  Watch out for address wrap...
  548          */
  549         map = &td->td_proc->p_vmspace->vm_map;
  550         if (addr < vm_map_min(map) || addr + size > vm_map_max(map))
  551                 return (EINVAL);
  552         vm_map_lock(map);
  553 #ifdef HWPMC_HOOKS
  554         pmc_handled = false;
  555         if (PMC_HOOK_INSTALLED(PMC_FN_MUNMAP)) {
  556                 pmc_handled = true;
  557                 /*
  558                  * Inform hwpmc if the address range being unmapped contains
  559                  * an executable region.
  560                  */
  561                 pkm.pm_address = (uintptr_t) NULL;
  562                 if (vm_map_lookup_entry(map, addr, &entry)) {
  563                         for (; entry->start < addr + size;
  564                             entry = entry->next) {
  565                                 if (vm_map_check_protection(map, entry->start,
  566                                         entry->end, VM_PROT_EXECUTE) == TRUE) {
  567                                         pkm.pm_address = (uintptr_t) addr;
  568                                         pkm.pm_size = (size_t) size;
  569                                         break;
  570                                 }
  571                         }
  572                 }
  573         }
  574 #endif
  575         vm_map_delete(map, addr, addr + size);
  576 
  577 #ifdef HWPMC_HOOKS
  578         if (__predict_false(pmc_handled)) {
  579                 /* downgrade the lock to prevent a LOR with the pmc-sx lock */
  580                 vm_map_lock_downgrade(map);
  581                 if (pkm.pm_address != (uintptr_t) NULL)
  582                         PMC_CALL_HOOK(td, PMC_FN_MUNMAP, (void *) &pkm);
  583                 vm_map_unlock_read(map);
  584         } else
  585 #endif
  586                 vm_map_unlock(map);
  587 
  588         /* vm_map_delete returns nothing but KERN_SUCCESS anyway */
  589         return (0);
  590 }
  591 
  592 #ifndef _SYS_SYSPROTO_H_
  593 struct mprotect_args {
  594         const void *addr;
  595         size_t len;
  596         int prot;
  597 };
  598 #endif
  599 int
  600 sys_mprotect(struct thread *td, struct mprotect_args *uap)
  601 {
  602 
  603         return (kern_mprotect(td, (uintptr_t)uap->addr, uap->len, uap->prot));
  604 }
  605 
  606 int
  607 kern_mprotect(struct thread *td, uintptr_t addr0, size_t size, int prot)
  608 {
  609         vm_offset_t addr;
  610         vm_size_t pageoff;
  611 
  612         addr = addr0;
  613         prot = (prot & VM_PROT_ALL);
  614         pageoff = (addr & PAGE_MASK);
  615         addr -= pageoff;
  616         size += pageoff;
  617         size = (vm_size_t) round_page(size);
  618 #ifdef COMPAT_FREEBSD32
  619         if (SV_PROC_FLAG(td->td_proc, SV_ILP32)) {
  620                 if (((addr + size) & 0xffffffff) < addr)
  621                         return (EINVAL);
  622         } else
  623 #endif
  624         if (addr + size < addr)
  625                 return (EINVAL);
  626 
  627         switch (vm_map_protect(&td->td_proc->p_vmspace->vm_map, addr,
  628             addr + size, prot, FALSE)) {
  629         case KERN_SUCCESS:
  630                 return (0);
  631         case KERN_PROTECTION_FAILURE:
  632                 return (EACCES);
  633         case KERN_RESOURCE_SHORTAGE:
  634                 return (ENOMEM);
  635         }
  636         return (EINVAL);
  637 }
  638 
  639 #ifndef _SYS_SYSPROTO_H_
  640 struct minherit_args {
  641         void *addr;
  642         size_t len;
  643         int inherit;
  644 };
  645 #endif
  646 int
  647 sys_minherit(struct thread *td, struct minherit_args *uap)
  648 {
  649         vm_offset_t addr;
  650         vm_size_t size, pageoff;
  651         vm_inherit_t inherit;
  652 
  653         addr = (vm_offset_t)uap->addr;
  654         size = uap->len;
  655         inherit = uap->inherit;
  656 
  657         pageoff = (addr & PAGE_MASK);
  658         addr -= pageoff;
  659         size += pageoff;
  660         size = (vm_size_t) round_page(size);
  661         if (addr + size < addr)
  662                 return (EINVAL);
  663 
  664         switch (vm_map_inherit(&td->td_proc->p_vmspace->vm_map, addr,
  665             addr + size, inherit)) {
  666         case KERN_SUCCESS:
  667                 return (0);
  668         case KERN_PROTECTION_FAILURE:
  669                 return (EACCES);
  670         }
  671         return (EINVAL);
  672 }
  673 
  674 #ifndef _SYS_SYSPROTO_H_
  675 struct madvise_args {
  676         void *addr;
  677         size_t len;
  678         int behav;
  679 };
  680 #endif
  681 
  682 int
  683 sys_madvise(struct thread *td, struct madvise_args *uap)
  684 {
  685 
  686         return (kern_madvise(td, (uintptr_t)uap->addr, uap->len, uap->behav));
  687 }
  688 
  689 int
  690 kern_madvise(struct thread *td, uintptr_t addr0, size_t len, int behav)
  691 {
  692         vm_map_t map;
  693         vm_offset_t addr, end, start;
  694         int flags;
  695 
  696         /*
  697          * Check for our special case, advising the swap pager we are
  698          * "immortal."
  699          */
  700         if (behav == MADV_PROTECT) {
  701                 flags = PPROT_SET;
  702                 return (kern_procctl(td, P_PID, td->td_proc->p_pid,
  703                     PROC_SPROTECT, &flags));
  704         }
  705 
  706         /*
  707          * Check for illegal behavior
  708          */
  709         if (behav < 0 || behav > MADV_CORE)
  710                 return (EINVAL);
  711         /*
  712          * Check for illegal addresses.  Watch out for address wrap... Note
  713          * that VM_*_ADDRESS are not constants due to casts (argh).
  714          */
  715         map = &td->td_proc->p_vmspace->vm_map;
  716         addr = addr0;
  717         if (addr < vm_map_min(map) || addr + len > vm_map_max(map))
  718                 return (EINVAL);
  719         if ((addr + len) < addr)
  720                 return (EINVAL);
  721 
  722         /*
  723          * Since this routine is only advisory, we default to conservative
  724          * behavior.
  725          */
  726         start = trunc_page(addr);
  727         end = round_page(addr + len);
  728 
  729         if (vm_map_madvise(map, start, end, behav))
  730                 return (EINVAL);
  731         return (0);
  732 }
  733 
  734 #ifndef _SYS_SYSPROTO_H_
  735 struct mincore_args {
  736         const void *addr;
  737         size_t len;
  738         char *vec;
  739 };
  740 #endif
  741 
  742 int
  743 sys_mincore(struct thread *td, struct mincore_args *uap)
  744 {
  745 
  746         return (kern_mincore(td, (uintptr_t)uap->addr, uap->len, uap->vec));
  747 }
  748 
  749 int
  750 kern_mincore(struct thread *td, uintptr_t addr0, size_t len, char *vec)
  751 {
  752         vm_offset_t addr, first_addr;
  753         vm_offset_t end, cend;
  754         pmap_t pmap;
  755         vm_map_t map;
  756         int error = 0;
  757         int vecindex, lastvecindex;
  758         vm_map_entry_t current;
  759         vm_map_entry_t entry;
  760         vm_object_t object;
  761         vm_paddr_t locked_pa;
  762         vm_page_t m;
  763         vm_pindex_t pindex;
  764         int mincoreinfo;
  765         unsigned int timestamp;
  766         boolean_t locked;
  767 
  768         /*
  769          * Make sure that the addresses presented are valid for user
  770          * mode.
  771          */
  772         first_addr = addr = trunc_page(addr0);
  773         end = addr + (vm_size_t)round_page(len);
  774         map = &td->td_proc->p_vmspace->vm_map;
  775         if (end > vm_map_max(map) || end < addr)
  776                 return (ENOMEM);
  777 
  778         pmap = vmspace_pmap(td->td_proc->p_vmspace);
  779 
  780         vm_map_lock_read(map);
  781 RestartScan:
  782         timestamp = map->timestamp;
  783 
  784         if (!vm_map_lookup_entry(map, addr, &entry)) {
  785                 vm_map_unlock_read(map);
  786                 return (ENOMEM);
  787         }
  788 
  789         /*
  790          * Do this on a map entry basis so that if the pages are not
  791          * in the current processes address space, we can easily look
  792          * up the pages elsewhere.
  793          */
  794         lastvecindex = -1;
  795         for (current = entry; current->start < end; current = current->next) {
  796 
  797                 /*
  798                  * check for contiguity
  799                  */
  800                 if (current->end < end && current->next->start > current->end) {
  801                         vm_map_unlock_read(map);
  802                         return (ENOMEM);
  803                 }
  804 
  805                 /*
  806                  * ignore submaps (for now) or null objects
  807                  */
  808                 if ((current->eflags & MAP_ENTRY_IS_SUB_MAP) ||
  809                         current->object.vm_object == NULL)
  810                         continue;
  811 
  812                 /*
  813                  * limit this scan to the current map entry and the
  814                  * limits for the mincore call
  815                  */
  816                 if (addr < current->start)
  817                         addr = current->start;
  818                 cend = current->end;
  819                 if (cend > end)
  820                         cend = end;
  821 
  822                 /*
  823                  * scan this entry one page at a time
  824                  */
  825                 while (addr < cend) {
  826                         /*
  827                          * Check pmap first, it is likely faster, also
  828                          * it can provide info as to whether we are the
  829                          * one referencing or modifying the page.
  830                          */
  831                         object = NULL;
  832                         locked_pa = 0;
  833                 retry:
  834                         m = NULL;
  835                         mincoreinfo = pmap_mincore(pmap, addr, &locked_pa);
  836                         if (mincore_mapped) {
  837                                 /*
  838                                  * We only care about this pmap's
  839                                  * mapping of the page, if any.
  840                                  */
  841                                 if (locked_pa != 0) {
  842                                         vm_page_unlock(PHYS_TO_VM_PAGE(
  843                                             locked_pa));
  844                                 }
  845                         } else if (locked_pa != 0) {
  846                                 /*
  847                                  * The page is mapped by this process but not
  848                                  * both accessed and modified.  It is also
  849                                  * managed.  Acquire the object lock so that
  850                                  * other mappings might be examined.
  851                                  */
  852                                 m = PHYS_TO_VM_PAGE(locked_pa);
  853                                 if (m->object != object) {
  854                                         if (object != NULL)
  855                                                 VM_OBJECT_WUNLOCK(object);
  856                                         object = m->object;
  857                                         locked = VM_OBJECT_TRYWLOCK(object);
  858                                         vm_page_unlock(m);
  859                                         if (!locked) {
  860                                                 VM_OBJECT_WLOCK(object);
  861                                                 vm_page_lock(m);
  862                                                 goto retry;
  863                                         }
  864                                 } else
  865                                         vm_page_unlock(m);
  866                                 KASSERT(m->valid == VM_PAGE_BITS_ALL,
  867                                     ("mincore: page %p is mapped but invalid",
  868                                     m));
  869                         } else if (mincoreinfo == 0) {
  870                                 /*
  871                                  * The page is not mapped by this process.  If
  872                                  * the object implements managed pages, then
  873                                  * determine if the page is resident so that
  874                                  * the mappings might be examined.
  875                                  */
  876                                 if (current->object.vm_object != object) {
  877                                         if (object != NULL)
  878                                                 VM_OBJECT_WUNLOCK(object);
  879                                         object = current->object.vm_object;
  880                                         VM_OBJECT_WLOCK(object);
  881                                 }
  882                                 if (object->type == OBJT_DEFAULT ||
  883                                     object->type == OBJT_SWAP ||
  884                                     object->type == OBJT_VNODE) {
  885                                         pindex = OFF_TO_IDX(current->offset +
  886                                             (addr - current->start));
  887                                         m = vm_page_lookup(object, pindex);
  888                                         if (m != NULL && m->valid == 0)
  889                                                 m = NULL;
  890                                         if (m != NULL)
  891                                                 mincoreinfo = MINCORE_INCORE;
  892                                 }
  893                         }
  894                         if (m != NULL) {
  895                                 /* Examine other mappings to the page. */
  896                                 if (m->dirty == 0 && pmap_is_modified(m))
  897                                         vm_page_dirty(m);
  898                                 if (m->dirty != 0)
  899                                         mincoreinfo |= MINCORE_MODIFIED_OTHER;
  900                                 /*
  901                                  * The first test for PGA_REFERENCED is an
  902                                  * optimization.  The second test is
  903                                  * required because a concurrent pmap
  904                                  * operation could clear the last reference
  905                                  * and set PGA_REFERENCED before the call to
  906                                  * pmap_is_referenced(). 
  907                                  */
  908                                 if ((m->aflags & PGA_REFERENCED) != 0 ||
  909                                     pmap_is_referenced(m) ||
  910                                     (m->aflags & PGA_REFERENCED) != 0)
  911                                         mincoreinfo |= MINCORE_REFERENCED_OTHER;
  912                         }
  913                         if (object != NULL)
  914                                 VM_OBJECT_WUNLOCK(object);
  915 
  916                         /*
  917                          * subyte may page fault.  In case it needs to modify
  918                          * the map, we release the lock.
  919                          */
  920                         vm_map_unlock_read(map);
  921 
  922                         /*
  923                          * calculate index into user supplied byte vector
  924                          */
  925                         vecindex = atop(addr - first_addr);
  926 
  927                         /*
  928                          * If we have skipped map entries, we need to make sure that
  929                          * the byte vector is zeroed for those skipped entries.
  930                          */
  931                         while ((lastvecindex + 1) < vecindex) {
  932                                 ++lastvecindex;
  933                                 error = subyte(vec + lastvecindex, 0);
  934                                 if (error) {
  935                                         error = EFAULT;
  936                                         goto done2;
  937                                 }
  938                         }
  939 
  940                         /*
  941                          * Pass the page information to the user
  942                          */
  943                         error = subyte(vec + vecindex, mincoreinfo);
  944                         if (error) {
  945                                 error = EFAULT;
  946                                 goto done2;
  947                         }
  948 
  949                         /*
  950                          * If the map has changed, due to the subyte, the previous
  951                          * output may be invalid.
  952                          */
  953                         vm_map_lock_read(map);
  954                         if (timestamp != map->timestamp)
  955                                 goto RestartScan;
  956 
  957                         lastvecindex = vecindex;
  958                         addr += PAGE_SIZE;
  959                 }
  960         }
  961 
  962         /*
  963          * subyte may page fault.  In case it needs to modify
  964          * the map, we release the lock.
  965          */
  966         vm_map_unlock_read(map);
  967 
  968         /*
  969          * Zero the last entries in the byte vector.
  970          */
  971         vecindex = atop(end - first_addr);
  972         while ((lastvecindex + 1) < vecindex) {
  973                 ++lastvecindex;
  974                 error = subyte(vec + lastvecindex, 0);
  975                 if (error) {
  976                         error = EFAULT;
  977                         goto done2;
  978                 }
  979         }
  980 
  981         /*
  982          * If the map has changed, due to the subyte, the previous
  983          * output may be invalid.
  984          */
  985         vm_map_lock_read(map);
  986         if (timestamp != map->timestamp)
  987                 goto RestartScan;
  988         vm_map_unlock_read(map);
  989 done2:
  990         return (error);
  991 }
  992 
  993 #ifndef _SYS_SYSPROTO_H_
  994 struct mlock_args {
  995         const void *addr;
  996         size_t len;
  997 };
  998 #endif
  999 int
 1000 sys_mlock(struct thread *td, struct mlock_args *uap)
 1001 {
 1002 
 1003         return (kern_mlock(td->td_proc, td->td_ucred,
 1004             __DECONST(uintptr_t, uap->addr), uap->len));
 1005 }
 1006 
 1007 int
 1008 kern_mlock(struct proc *proc, struct ucred *cred, uintptr_t addr0, size_t len)
 1009 {
 1010         vm_offset_t addr, end, last, start;
 1011         vm_size_t npages, size;
 1012         vm_map_t map;
 1013         unsigned long nsize;
 1014         int error;
 1015 
 1016         error = priv_check_cred(cred, PRIV_VM_MLOCK, 0);
 1017         if (error)
 1018                 return (error);
 1019         addr = addr0;
 1020         size = len;
 1021         last = addr + size;
 1022         start = trunc_page(addr);
 1023         end = round_page(last);
 1024         if (last < addr || end < addr)
 1025                 return (EINVAL);
 1026         npages = atop(end - start);
 1027         if (npages > vm_page_max_wired)
 1028                 return (ENOMEM);
 1029         map = &proc->p_vmspace->vm_map;
 1030         PROC_LOCK(proc);
 1031         nsize = ptoa(npages + pmap_wired_count(map->pmap));
 1032         if (nsize > lim_cur_proc(proc, RLIMIT_MEMLOCK)) {
 1033                 PROC_UNLOCK(proc);
 1034                 return (ENOMEM);
 1035         }
 1036         PROC_UNLOCK(proc);
 1037         if (npages + vm_cnt.v_wire_count > vm_page_max_wired)
 1038                 return (EAGAIN);
 1039 #ifdef RACCT
 1040         if (racct_enable) {
 1041                 PROC_LOCK(proc);
 1042                 error = racct_set(proc, RACCT_MEMLOCK, nsize);
 1043                 PROC_UNLOCK(proc);
 1044                 if (error != 0)
 1045                         return (ENOMEM);
 1046         }
 1047 #endif
 1048         error = vm_map_wire(map, start, end,
 1049             VM_MAP_WIRE_USER | VM_MAP_WIRE_NOHOLES);
 1050 #ifdef RACCT
 1051         if (racct_enable && error != KERN_SUCCESS) {
 1052                 PROC_LOCK(proc);
 1053                 racct_set(proc, RACCT_MEMLOCK,
 1054                     ptoa(pmap_wired_count(map->pmap)));
 1055                 PROC_UNLOCK(proc);
 1056         }
 1057 #endif
 1058         return (error == KERN_SUCCESS ? 0 : ENOMEM);
 1059 }
 1060 
 1061 #ifndef _SYS_SYSPROTO_H_
 1062 struct mlockall_args {
 1063         int     how;
 1064 };
 1065 #endif
 1066 
 1067 int
 1068 sys_mlockall(struct thread *td, struct mlockall_args *uap)
 1069 {
 1070         vm_map_t map;
 1071         int error;
 1072 
 1073         map = &td->td_proc->p_vmspace->vm_map;
 1074         error = priv_check(td, PRIV_VM_MLOCK);
 1075         if (error)
 1076                 return (error);
 1077 
 1078         if ((uap->how == 0) || ((uap->how & ~(MCL_CURRENT|MCL_FUTURE)) != 0))
 1079                 return (EINVAL);
 1080 
 1081         /*
 1082          * If wiring all pages in the process would cause it to exceed
 1083          * a hard resource limit, return ENOMEM.
 1084          */
 1085         if (!old_mlock && uap->how & MCL_CURRENT) {
 1086                 PROC_LOCK(td->td_proc);
 1087                 if (map->size > lim_cur(td, RLIMIT_MEMLOCK)) {
 1088                         PROC_UNLOCK(td->td_proc);
 1089                         return (ENOMEM);
 1090                 }
 1091                 PROC_UNLOCK(td->td_proc);
 1092         }
 1093 #ifdef RACCT
 1094         if (racct_enable) {
 1095                 PROC_LOCK(td->td_proc);
 1096                 error = racct_set(td->td_proc, RACCT_MEMLOCK, map->size);
 1097                 PROC_UNLOCK(td->td_proc);
 1098                 if (error != 0)
 1099                         return (ENOMEM);
 1100         }
 1101 #endif
 1102 
 1103         if (uap->how & MCL_FUTURE) {
 1104                 vm_map_lock(map);
 1105                 vm_map_modflags(map, MAP_WIREFUTURE, 0);
 1106                 vm_map_unlock(map);
 1107                 error = 0;
 1108         }
 1109 
 1110         if (uap->how & MCL_CURRENT) {
 1111                 /*
 1112                  * P1003.1-2001 mandates that all currently mapped pages
 1113                  * will be memory resident and locked (wired) upon return
 1114                  * from mlockall(). vm_map_wire() will wire pages, by
 1115                  * calling vm_fault_wire() for each page in the region.
 1116                  */
 1117                 error = vm_map_wire(map, vm_map_min(map), vm_map_max(map),
 1118                     VM_MAP_WIRE_USER|VM_MAP_WIRE_HOLESOK);
 1119                 error = (error == KERN_SUCCESS ? 0 : EAGAIN);
 1120         }
 1121 #ifdef RACCT
 1122         if (racct_enable && error != KERN_SUCCESS) {
 1123                 PROC_LOCK(td->td_proc);
 1124                 racct_set(td->td_proc, RACCT_MEMLOCK,
 1125                     ptoa(pmap_wired_count(map->pmap)));
 1126                 PROC_UNLOCK(td->td_proc);
 1127         }
 1128 #endif
 1129 
 1130         return (error);
 1131 }
 1132 
 1133 #ifndef _SYS_SYSPROTO_H_
 1134 struct munlockall_args {
 1135         register_t dummy;
 1136 };
 1137 #endif
 1138 
 1139 int
 1140 sys_munlockall(struct thread *td, struct munlockall_args *uap)
 1141 {
 1142         vm_map_t map;
 1143         int error;
 1144 
 1145         map = &td->td_proc->p_vmspace->vm_map;
 1146         error = priv_check(td, PRIV_VM_MUNLOCK);
 1147         if (error)
 1148                 return (error);
 1149 
 1150         /* Clear the MAP_WIREFUTURE flag from this vm_map. */
 1151         vm_map_lock(map);
 1152         vm_map_modflags(map, 0, MAP_WIREFUTURE);
 1153         vm_map_unlock(map);
 1154 
 1155         /* Forcibly unwire all pages. */
 1156         error = vm_map_unwire(map, vm_map_min(map), vm_map_max(map),
 1157             VM_MAP_WIRE_USER|VM_MAP_WIRE_HOLESOK);
 1158 #ifdef RACCT
 1159         if (racct_enable && error == KERN_SUCCESS) {
 1160                 PROC_LOCK(td->td_proc);
 1161                 racct_set(td->td_proc, RACCT_MEMLOCK, 0);
 1162                 PROC_UNLOCK(td->td_proc);
 1163         }
 1164 #endif
 1165 
 1166         return (error);
 1167 }
 1168 
 1169 #ifndef _SYS_SYSPROTO_H_
 1170 struct munlock_args {
 1171         const void *addr;
 1172         size_t len;
 1173 };
 1174 #endif
 1175 int
 1176 sys_munlock(struct thread *td, struct munlock_args *uap)
 1177 {
 1178 
 1179         return (kern_munlock(td, (uintptr_t)uap->addr, uap->len));
 1180 }
 1181 
 1182 int
 1183 kern_munlock(struct thread *td, uintptr_t addr0, size_t size)
 1184 {
 1185         vm_offset_t addr, end, last, start;
 1186 #ifdef RACCT
 1187         vm_map_t map;
 1188 #endif
 1189         int error;
 1190 
 1191         error = priv_check(td, PRIV_VM_MUNLOCK);
 1192         if (error)
 1193                 return (error);
 1194         addr = addr0;
 1195         last = addr + size;
 1196         start = trunc_page(addr);
 1197         end = round_page(last);
 1198         if (last < addr || end < addr)
 1199                 return (EINVAL);
 1200         error = vm_map_unwire(&td->td_proc->p_vmspace->vm_map, start, end,
 1201             VM_MAP_WIRE_USER | VM_MAP_WIRE_NOHOLES);
 1202 #ifdef RACCT
 1203         if (racct_enable && error == KERN_SUCCESS) {
 1204                 PROC_LOCK(td->td_proc);
 1205                 map = &td->td_proc->p_vmspace->vm_map;
 1206                 racct_set(td->td_proc, RACCT_MEMLOCK,
 1207                     ptoa(pmap_wired_count(map->pmap)));
 1208                 PROC_UNLOCK(td->td_proc);
 1209         }
 1210 #endif
 1211         return (error == KERN_SUCCESS ? 0 : ENOMEM);
 1212 }
 1213 
 1214 /*
 1215  * vm_mmap_vnode()
 1216  *
 1217  * Helper function for vm_mmap.  Perform sanity check specific for mmap
 1218  * operations on vnodes.
 1219  */
 1220 int
 1221 vm_mmap_vnode(struct thread *td, vm_size_t objsize,
 1222     vm_prot_t prot, vm_prot_t *maxprotp, int *flagsp,
 1223     struct vnode *vp, vm_ooffset_t *foffp, vm_object_t *objp,
 1224     boolean_t *writecounted)
 1225 {
 1226         struct vattr va;
 1227         vm_object_t obj;
 1228         vm_ooffset_t foff;
 1229         struct ucred *cred;
 1230         int error, flags, locktype;
 1231 
 1232         cred = td->td_ucred;
 1233         if ((*maxprotp & VM_PROT_WRITE) && (*flagsp & MAP_SHARED))
 1234                 locktype = LK_EXCLUSIVE;
 1235         else
 1236                 locktype = LK_SHARED;
 1237         if ((error = vget(vp, locktype, td)) != 0)
 1238                 return (error);
 1239         AUDIT_ARG_VNODE1(vp);
 1240         foff = *foffp;
 1241         flags = *flagsp;
 1242         obj = vp->v_object;
 1243         if (vp->v_type == VREG) {
 1244                 /*
 1245                  * Get the proper underlying object
 1246                  */
 1247                 if (obj == NULL) {
 1248                         error = EINVAL;
 1249                         goto done;
 1250                 }
 1251                 if (obj->type == OBJT_VNODE && obj->handle != vp) {
 1252                         vput(vp);
 1253                         vp = (struct vnode *)obj->handle;
 1254                         /*
 1255                          * Bypass filesystems obey the mpsafety of the
 1256                          * underlying fs.  Tmpfs never bypasses.
 1257                          */
 1258                         error = vget(vp, locktype, td);
 1259                         if (error != 0)
 1260                                 return (error);
 1261                 }
 1262                 if (locktype == LK_EXCLUSIVE) {
 1263                         *writecounted = TRUE;
 1264                         vnode_pager_update_writecount(obj, 0, objsize);
 1265                 }
 1266         } else {
 1267                 error = EINVAL;
 1268                 goto done;
 1269         }
 1270         if ((error = VOP_GETATTR(vp, &va, cred)))
 1271                 goto done;
 1272 #ifdef MAC
 1273         /* This relies on VM_PROT_* matching PROT_*. */
 1274         error = mac_vnode_check_mmap(cred, vp, (int)prot, flags);
 1275         if (error != 0)
 1276                 goto done;
 1277 #endif
 1278         if ((flags & MAP_SHARED) != 0) {
 1279                 if ((va.va_flags & (SF_SNAPSHOT|IMMUTABLE|APPEND)) != 0) {
 1280                         if (prot & VM_PROT_WRITE) {
 1281                                 error = EPERM;
 1282                                 goto done;
 1283                         }
 1284                         *maxprotp &= ~VM_PROT_WRITE;
 1285                 }
 1286         }
 1287         /*
 1288          * If it is a regular file without any references
 1289          * we do not need to sync it.
 1290          * Adjust object size to be the size of actual file.
 1291          */
 1292         objsize = round_page(va.va_size);
 1293         if (va.va_nlink == 0)
 1294                 flags |= MAP_NOSYNC;
 1295         if (obj->type == OBJT_VNODE) {
 1296                 obj = vm_pager_allocate(OBJT_VNODE, vp, objsize, prot, foff,
 1297                     cred);
 1298                 if (obj == NULL) {
 1299                         error = ENOMEM;
 1300                         goto done;
 1301                 }
 1302         } else {
 1303                 KASSERT(obj->type == OBJT_DEFAULT || obj->type == OBJT_SWAP,
 1304                     ("wrong object type"));
 1305                 VM_OBJECT_WLOCK(obj);
 1306                 vm_object_reference_locked(obj);
 1307 #if VM_NRESERVLEVEL > 0
 1308                 vm_object_color(obj, 0);
 1309 #endif
 1310                 VM_OBJECT_WUNLOCK(obj);
 1311         }
 1312         *objp = obj;
 1313         *flagsp = flags;
 1314 
 1315         vfs_mark_atime(vp, cred);
 1316 
 1317 done:
 1318         if (error != 0 && *writecounted) {
 1319                 *writecounted = FALSE;
 1320                 vnode_pager_update_writecount(obj, objsize, 0);
 1321         }
 1322         vput(vp);
 1323         return (error);
 1324 }
 1325 
 1326 /*
 1327  * vm_mmap_cdev()
 1328  *
 1329  * Helper function for vm_mmap.  Perform sanity check specific for mmap
 1330  * operations on cdevs.
 1331  */
 1332 int
 1333 vm_mmap_cdev(struct thread *td, vm_size_t objsize, vm_prot_t prot,
 1334     vm_prot_t *maxprotp, int *flagsp, struct cdev *cdev, struct cdevsw *dsw,
 1335     vm_ooffset_t *foff, vm_object_t *objp)
 1336 {
 1337         vm_object_t obj;
 1338         int error, flags;
 1339 
 1340         flags = *flagsp;
 1341 
 1342         if (dsw->d_flags & D_MMAP_ANON) {
 1343                 *objp = NULL;
 1344                 *foff = 0;
 1345                 *maxprotp = VM_PROT_ALL;
 1346                 *flagsp |= MAP_ANON;
 1347                 return (0);
 1348         }
 1349         /*
 1350          * cdevs do not provide private mappings of any kind.
 1351          */
 1352         if ((*maxprotp & VM_PROT_WRITE) == 0 &&
 1353             (prot & VM_PROT_WRITE) != 0)
 1354                 return (EACCES);
 1355         if (flags & (MAP_PRIVATE|MAP_COPY))
 1356                 return (EINVAL);
 1357         /*
 1358          * Force device mappings to be shared.
 1359          */
 1360         flags |= MAP_SHARED;
 1361 #ifdef MAC_XXX
 1362         error = mac_cdev_check_mmap(td->td_ucred, cdev, (int)prot);
 1363         if (error != 0)
 1364                 return (error);
 1365 #endif
 1366         /*
 1367          * First, try d_mmap_single().  If that is not implemented
 1368          * (returns ENODEV), fall back to using the device pager.
 1369          * Note that d_mmap_single() must return a reference to the
 1370          * object (it needs to bump the reference count of the object
 1371          * it returns somehow).
 1372          *
 1373          * XXX assumes VM_PROT_* == PROT_*
 1374          */
 1375         error = dsw->d_mmap_single(cdev, foff, objsize, objp, (int)prot);
 1376         if (error != ENODEV)
 1377                 return (error);
 1378         obj = vm_pager_allocate(OBJT_DEVICE, cdev, objsize, prot, *foff,
 1379             td->td_ucred);
 1380         if (obj == NULL)
 1381                 return (EINVAL);
 1382         *objp = obj;
 1383         *flagsp = flags;
 1384         return (0);
 1385 }
 1386 
 1387 /*
 1388  * vm_mmap()
 1389  *
 1390  * Internal version of mmap used by exec, sys5 shared memory, and
 1391  * various device drivers.  Handle is either a vnode pointer, a
 1392  * character device, or NULL for MAP_ANON.
 1393  */
 1394 int
 1395 vm_mmap(vm_map_t map, vm_offset_t *addr, vm_size_t size, vm_prot_t prot,
 1396         vm_prot_t maxprot, int flags,
 1397         objtype_t handle_type, void *handle,
 1398         vm_ooffset_t foff)
 1399 {
 1400         vm_object_t object;
 1401         struct thread *td = curthread;
 1402         int error;
 1403         boolean_t writecounted;
 1404 
 1405         if (size == 0)
 1406                 return (EINVAL);
 1407 
 1408         size = round_page(size);
 1409         object = NULL;
 1410         writecounted = FALSE;
 1411 
 1412         /*
 1413          * Lookup/allocate object.
 1414          */
 1415         switch (handle_type) {
 1416         case OBJT_DEVICE: {
 1417                 struct cdevsw *dsw;
 1418                 struct cdev *cdev;
 1419                 int ref;
 1420 
 1421                 cdev = handle;
 1422                 dsw = dev_refthread(cdev, &ref);
 1423                 if (dsw == NULL)
 1424                         return (ENXIO);
 1425                 error = vm_mmap_cdev(td, size, prot, &maxprot, &flags, cdev,
 1426                     dsw, &foff, &object);
 1427                 dev_relthread(cdev, ref);
 1428                 break;
 1429         }
 1430         case OBJT_VNODE:
 1431                 error = vm_mmap_vnode(td, size, prot, &maxprot, &flags,
 1432                     handle, &foff, &object, &writecounted);
 1433                 break;
 1434         case OBJT_DEFAULT:
 1435                 if (handle == NULL) {
 1436                         error = 0;
 1437                         break;
 1438                 }
 1439                 /* FALLTHROUGH */
 1440         default:
 1441                 error = EINVAL;
 1442                 break;
 1443         }
 1444         if (error)
 1445                 return (error);
 1446 
 1447         error = vm_mmap_object(map, addr, size, prot, maxprot, flags, object,
 1448             foff, writecounted, td);
 1449         if (error != 0 && object != NULL) {
 1450                 /*
 1451                  * If this mapping was accounted for in the vnode's
 1452                  * writecount, then undo that now.
 1453                  */
 1454                 if (writecounted)
 1455                         vnode_pager_release_writecount(object, 0, size);
 1456                 vm_object_deallocate(object);
 1457         }
 1458         return (error);
 1459 }
 1460 
 1461 /*
 1462  * Internal version of mmap that maps a specific VM object into an
 1463  * map.  Called by mmap for MAP_ANON, vm_mmap, shm_mmap, and vn_mmap.
 1464  */
 1465 int
 1466 vm_mmap_object(vm_map_t map, vm_offset_t *addr, vm_size_t size, vm_prot_t prot,
 1467     vm_prot_t maxprot, int flags, vm_object_t object, vm_ooffset_t foff,
 1468     boolean_t writecounted, struct thread *td)
 1469 {
 1470         boolean_t curmap, fitit;
 1471         vm_offset_t max_addr;
 1472         int docow, error, findspace, rv;
 1473 
 1474         curmap = map == &td->td_proc->p_vmspace->vm_map;
 1475         if (curmap) {
 1476                 PROC_LOCK(td->td_proc);
 1477                 if (map->size + size > lim_cur_proc(td->td_proc, RLIMIT_VMEM)) {
 1478                         PROC_UNLOCK(td->td_proc);
 1479                         return (ENOMEM);
 1480                 }
 1481                 if (racct_set(td->td_proc, RACCT_VMEM, map->size + size)) {
 1482                         PROC_UNLOCK(td->td_proc);
 1483                         return (ENOMEM);
 1484                 }
 1485                 if (!old_mlock && map->flags & MAP_WIREFUTURE) {
 1486                         if (ptoa(pmap_wired_count(map->pmap)) + size >
 1487                             lim_cur_proc(td->td_proc, RLIMIT_MEMLOCK)) {
 1488                                 racct_set_force(td->td_proc, RACCT_VMEM,
 1489                                     map->size);
 1490                                 PROC_UNLOCK(td->td_proc);
 1491                                 return (ENOMEM);
 1492                         }
 1493                         error = racct_set(td->td_proc, RACCT_MEMLOCK,
 1494                             ptoa(pmap_wired_count(map->pmap)) + size);
 1495                         if (error != 0) {
 1496                                 racct_set_force(td->td_proc, RACCT_VMEM,
 1497                                     map->size);
 1498                                 PROC_UNLOCK(td->td_proc);
 1499                                 return (error);
 1500                         }
 1501                 }
 1502                 PROC_UNLOCK(td->td_proc);
 1503         }
 1504 
 1505         /*
 1506          * We currently can only deal with page aligned file offsets.
 1507          * The mmap() system call already enforces this by subtracting
 1508          * the page offset from the file offset, but checking here
 1509          * catches errors in device drivers (e.g. d_single_mmap()
 1510          * callbacks) and other internal mapping requests (such as in
 1511          * exec).
 1512          */
 1513         if (foff & PAGE_MASK)
 1514                 return (EINVAL);
 1515 
 1516         if ((flags & MAP_FIXED) == 0) {
 1517                 fitit = TRUE;
 1518                 *addr = round_page(*addr);
 1519         } else {
 1520                 if (*addr != trunc_page(*addr))
 1521                         return (EINVAL);
 1522                 fitit = FALSE;
 1523         }
 1524 
 1525         if (flags & MAP_ANON) {
 1526                 if (object != NULL || foff != 0)
 1527                         return (EINVAL);
 1528                 docow = 0;
 1529         } else if (flags & MAP_PREFAULT_READ)
 1530                 docow = MAP_PREFAULT;
 1531         else
 1532                 docow = MAP_PREFAULT_PARTIAL;
 1533 
 1534         if ((flags & (MAP_ANON|MAP_SHARED)) == 0)
 1535                 docow |= MAP_COPY_ON_WRITE;
 1536         if (flags & MAP_NOSYNC)
 1537                 docow |= MAP_DISABLE_SYNCER;
 1538         if (flags & MAP_NOCORE)
 1539                 docow |= MAP_DISABLE_COREDUMP;
 1540         /* Shared memory is also shared with children. */
 1541         if (flags & MAP_SHARED)
 1542                 docow |= MAP_INHERIT_SHARE;
 1543         if (writecounted)
 1544                 docow |= MAP_VN_WRITECOUNT;
 1545         if (flags & MAP_STACK) {
 1546                 if (object != NULL)
 1547                         return (EINVAL);
 1548                 docow |= MAP_STACK_GROWS_DOWN;
 1549         }
 1550         if ((flags & MAP_EXCL) != 0)
 1551                 docow |= MAP_CHECK_EXCL;
 1552         if ((flags & MAP_GUARD) != 0)
 1553                 docow |= MAP_CREATE_GUARD;
 1554 
 1555         if (fitit) {
 1556                 if ((flags & MAP_ALIGNMENT_MASK) == MAP_ALIGNED_SUPER)
 1557                         findspace = VMFS_SUPER_SPACE;
 1558                 else if ((flags & MAP_ALIGNMENT_MASK) != 0)
 1559                         findspace = VMFS_ALIGNED_SPACE(flags >>
 1560                             MAP_ALIGNMENT_SHIFT);
 1561                 else
 1562                         findspace = VMFS_OPTIMAL_SPACE;
 1563                 max_addr = 0;
 1564 #ifdef MAP_32BIT
 1565                 if ((flags & MAP_32BIT) != 0)
 1566                         max_addr = MAP_32BIT_MAX_ADDR;
 1567 #endif
 1568                 if (curmap) {
 1569                         rv = vm_map_find_min(map, object, foff, addr, size,
 1570                             round_page((vm_offset_t)td->td_proc->p_vmspace->
 1571                             vm_daddr + lim_max(td, RLIMIT_DATA)), max_addr,
 1572                             findspace, prot, maxprot, docow);
 1573                 } else {
 1574                         rv = vm_map_find(map, object, foff, addr, size,
 1575                             max_addr, findspace, prot, maxprot, docow);
 1576                 }
 1577         } else {
 1578                 rv = vm_map_fixed(map, object, foff, *addr, size,
 1579                     prot, maxprot, docow);
 1580         }
 1581 
 1582         if (rv == KERN_SUCCESS) {
 1583                 /*
 1584                  * If the process has requested that all future mappings
 1585                  * be wired, then heed this.
 1586                  */
 1587                 if (map->flags & MAP_WIREFUTURE) {
 1588                         vm_map_wire(map, *addr, *addr + size,
 1589                             VM_MAP_WIRE_USER | ((flags & MAP_STACK) ?
 1590                             VM_MAP_WIRE_HOLESOK : VM_MAP_WIRE_NOHOLES));
 1591                 }
 1592         }
 1593         return (vm_mmap_to_errno(rv));
 1594 }
 1595 
 1596 /*
 1597  * Translate a Mach VM return code to zero on success or the appropriate errno
 1598  * on failure.
 1599  */
 1600 int
 1601 vm_mmap_to_errno(int rv)
 1602 {
 1603 
 1604         switch (rv) {
 1605         case KERN_SUCCESS:
 1606                 return (0);
 1607         case KERN_INVALID_ADDRESS:
 1608         case KERN_NO_SPACE:
 1609                 return (ENOMEM);
 1610         case KERN_PROTECTION_FAILURE:
 1611                 return (EACCES);
 1612         default:
 1613                 return (EINVAL);
 1614         }
 1615 }

Cache object: e246325a3f2374549b49628ddaa15160


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.