sys/vm/vm_mmap.c

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