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, orig_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         orig_addr = 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                 if (fp->f_ops == &shm_ops && shm_largepage(fp->f_data))
 426                         addr = orig_addr;
 427                 /* This relies on VM_PROT_* matching PROT_*. */
 428                 error = fo_mmap(fp, &vms->vm_map, &addr, size, prot,
 429                     max_prot & cap_maxprot, flags, pos, td);
 430         }
 431
 432         if (error == 0)
 433                 td->td_retval[0] = (register_t) (addr + pageoff);
 434 done:
 435         if (fp)
 436                 fdrop(fp, td);
 437
 438         return (error);
 439 }
 440
 441 #if defined(COMPAT_FREEBSD6)
 442 int
 443 freebsd6_mmap(struct thread *td, struct freebsd6_mmap_args *uap)
 444 {
 445
 446         return (kern_mmap(td, (uintptr_t)uap->addr, uap->len, uap->prot,
 447             uap->flags, uap->fd, uap->pos));
 448 }
 449 #endif
 450
 451 #ifdef COMPAT_43
 452 #ifndef _SYS_SYSPROTO_H_
 453 struct ommap_args {
 454         caddr_t addr;
 455         int len;
 456         int prot;
 457         int flags;
 458         int fd;
 459         long pos;
 460 };
 461 #endif
 462 int
 463 ommap(struct thread *td, struct ommap_args *uap)
 464 {
 465         static const char cvtbsdprot[8] = {
 466                 0,
 467                 PROT_EXEC,
 468                 PROT_WRITE,
 469                 PROT_EXEC | PROT_WRITE,
 470                 PROT_READ,
 471                 PROT_EXEC | PROT_READ,
 472                 PROT_WRITE | PROT_READ,
 473                 PROT_EXEC | PROT_WRITE | PROT_READ,
 474         };
 475         int flags, prot;
 476
 477 #define OMAP_ANON       0x0002
 478 #define OMAP_COPY       0x0020
 479 #define OMAP_SHARED     0x0010
 480 #define OMAP_FIXED      0x0100
 481
 482         prot = cvtbsdprot[uap->prot & 0x7];
 483 #if (defined(COMPAT_FREEBSD32) && defined(__amd64__)) || defined(__i386__)
 484         if (i386_read_exec && SV_PROC_FLAG(td->td_proc, SV_ILP32) &&
 485             prot != 0)
 486                 prot |= PROT_EXEC;
 487 #endif
 488         flags = 0;
 489         if (uap->flags & OMAP_ANON)
 490                 flags |= MAP_ANON;
 491         if (uap->flags & OMAP_COPY)
 492                 flags |= MAP_COPY;
 493         if (uap->flags & OMAP_SHARED)
 494                 flags |= MAP_SHARED;
 495         else
 496                 flags |= MAP_PRIVATE;
 497         if (uap->flags & OMAP_FIXED)
 498                 flags |= MAP_FIXED;
 499         return (kern_mmap(td, (uintptr_t)uap->addr, uap->len, prot, flags,
 500             uap->fd, uap->pos));
 501 }
 502 #endif                          /* COMPAT_43 */
 503
 504 #ifndef _SYS_SYSPROTO_H_
 505 struct msync_args {
 506         void *addr;
 507         size_t len;
 508         int flags;
 509 };
 510 #endif
 511 int
 512 sys_msync(struct thread *td, struct msync_args *uap)
 513 {
 514
 515         return (kern_msync(td, (uintptr_t)uap->addr, uap->len, uap->flags));
 516 }
 517
 518 int
 519 kern_msync(struct thread *td, uintptr_t addr0, size_t size, int flags)
 520 {
 521         vm_offset_t addr;
 522         vm_size_t pageoff;
 523         vm_map_t map;
 524         int rv;
 525
 526         addr = addr0;
 527         pageoff = (addr & PAGE_MASK);
 528         addr -= pageoff;
 529         size += pageoff;
 530         size = (vm_size_t) round_page(size);
 531         if (addr + size < addr)
 532                 return (EINVAL);
 533
 534         if ((flags & (MS_ASYNC|MS_INVALIDATE)) == (MS_ASYNC|MS_INVALIDATE))
 535                 return (EINVAL);
 536
 537         map = &td->td_proc->p_vmspace->vm_map;
 538
 539         /*
 540          * Clean the pages and interpret the return value.
 541          */
 542         rv = vm_map_sync(map, addr, addr + size, (flags & MS_ASYNC) == 0,
 543             (flags & MS_INVALIDATE) != 0);
 544         switch (rv) {
 545         case KERN_SUCCESS:
 546                 return (0);
 547         case KERN_INVALID_ADDRESS:
 548                 return (ENOMEM);
 549         case KERN_INVALID_ARGUMENT:
 550                 return (EBUSY);
 551         case KERN_FAILURE:
 552                 return (EIO);
 553         default:
 554                 return (EINVAL);
 555         }
 556 }
 557
 558 #ifndef _SYS_SYSPROTO_H_
 559 struct munmap_args {
 560         void *addr;
 561         size_t len;
 562 };
 563 #endif
 564 int
 565 sys_munmap(struct thread *td, struct munmap_args *uap)
 566 {
 567
 568         return (kern_munmap(td, (uintptr_t)uap->addr, uap->len));
 569 }
 570
 571 int
 572 kern_munmap(struct thread *td, uintptr_t addr0, size_t size)
 573 {
 574 #ifdef HWPMC_HOOKS
 575         struct pmckern_map_out pkm;
 576         vm_map_entry_t entry;
 577         bool pmc_handled;
 578 #endif
 579         vm_offset_t addr, end;
 580         vm_size_t pageoff;
 581         vm_map_t map;
 582         int rv;
 583
 584         if (size == 0)
 585                 return (EINVAL);
 586
 587         addr = addr0;
 588         pageoff = (addr & PAGE_MASK);
 589         addr -= pageoff;
 590         size += pageoff;
 591         size = (vm_size_t) round_page(size);
 592         end = addr + size;
 593         map = &td->td_proc->p_vmspace->vm_map;
 594         if (!vm_map_range_valid(map, addr, end))
 595                 return (EINVAL);
 596
 597         vm_map_lock(map);
 598 #ifdef HWPMC_HOOKS
 599         pmc_handled = false;
 600         if (PMC_HOOK_INSTALLED(PMC_FN_MUNMAP)) {
 601                 pmc_handled = true;
 602                 /*
 603                  * Inform hwpmc if the address range being unmapped contains
 604                  * an executable region.
 605                  */
 606                 pkm.pm_address = (uintptr_t) NULL;
 607                 if (vm_map_lookup_entry(map, addr, &entry)) {
 608                         for (; entry->start < end;
 609                             entry = vm_map_entry_succ(entry)) {
 610                                 if (vm_map_check_protection(map, entry->start,
 611                                         entry->end, VM_PROT_EXECUTE) == TRUE) {
 612                                         pkm.pm_address = (uintptr_t) addr;
 613                                         pkm.pm_size = (size_t) size;
 614                                         break;
 615                                 }
 616                         }
 617                 }
 618         }
 619 #endif
 620         rv = vm_map_delete(map, addr, end);
 621
 622 #ifdef HWPMC_HOOKS
 623         if (rv == KERN_SUCCESS && __predict_false(pmc_handled)) {
 624                 /* downgrade the lock to prevent a LOR with the pmc-sx lock */
 625                 vm_map_lock_downgrade(map);
 626                 if (pkm.pm_address != (uintptr_t) NULL)
 627                         PMC_CALL_HOOK(td, PMC_FN_MUNMAP, (void *) &pkm);
 628                 vm_map_unlock_read(map);
 629         } else
 630 #endif
 631                 vm_map_unlock(map);
 632
 633         return (vm_mmap_to_errno(rv));
 634 }
 635
 636 #ifndef _SYS_SYSPROTO_H_
 637 struct mprotect_args {
 638         const void *addr;
 639         size_t len;
 640         int prot;
 641 };
 642 #endif
 643 int
 644 sys_mprotect(struct thread *td, struct mprotect_args *uap)
 645 {
 646
 647         return (kern_mprotect(td, (uintptr_t)uap->addr, uap->len, uap->prot));
 648 }
 649
 650 int
 651 kern_mprotect(struct thread *td, uintptr_t addr0, size_t size, int prot)
 652 {
 653         vm_offset_t addr;
 654         vm_size_t pageoff;
 655         int vm_error, max_prot;
 656
 657         addr = addr0;
 658         if ((prot & ~(_PROT_ALL | PROT_MAX(_PROT_ALL))) != 0)
 659                 return (EINVAL);
 660         max_prot = PROT_MAX_EXTRACT(prot);
 661         prot = PROT_EXTRACT(prot);
 662         pageoff = (addr & PAGE_MASK);
 663         addr -= pageoff;
 664         size += pageoff;
 665         size = (vm_size_t) round_page(size);
 666 #ifdef COMPAT_FREEBSD32
 667         if (SV_PROC_FLAG(td->td_proc, SV_ILP32)) {
 668                 if (((addr + size) & 0xffffffff) < addr)
 669                         return (EINVAL);
 670         } else
 671 #endif
 672         if (addr + size < addr)
 673                 return (EINVAL);
 674
 675         vm_error = KERN_SUCCESS;
 676         if (max_prot != 0) {
 677                 if ((max_prot & prot) != prot)
 678                         return (ENOTSUP);
 679                 vm_error = vm_map_protect(&td->td_proc->p_vmspace->vm_map,
 680                     addr, addr + size, max_prot, TRUE);
 681         }
 682         if (vm_error == KERN_SUCCESS)
 683                 vm_error = vm_map_protect(&td->td_proc->p_vmspace->vm_map,
 684                     addr, addr + size, prot, FALSE);
 685
 686         switch (vm_error) {
 687         case KERN_SUCCESS:
 688                 return (0);
 689         case KERN_PROTECTION_FAILURE:
 690                 return (EACCES);
 691         case KERN_RESOURCE_SHORTAGE:
 692                 return (ENOMEM);
 693         }
 694         return (EINVAL);
 695 }
 696
 697 #ifndef _SYS_SYSPROTO_H_
 698 struct minherit_args {
 699         void *addr;
 700         size_t len;
 701         int inherit;
 702 };
 703 #endif
 704 int
 705 sys_minherit(struct thread *td, struct minherit_args *uap)
 706 {
 707
 708         return (kern_minherit(td, (uintptr_t)uap->addr, uap->len,
 709             uap->inherit));
 710 }
 711
 712 int
 713 kern_minherit(struct thread *td, uintptr_t addr0, size_t len, int inherit0)
 714 {
 715         vm_offset_t addr;
 716         vm_size_t size, pageoff;
 717         vm_inherit_t inherit;
 718
 719         addr = (vm_offset_t)addr0;
 720         size = len;
 721         inherit = inherit0;
 722
 723         pageoff = (addr & PAGE_MASK);
 724         addr -= pageoff;
 725         size += pageoff;
 726         size = (vm_size_t) round_page(size);
 727         if (addr + size < addr)
 728                 return (EINVAL);
 729
 730         switch (vm_map_inherit(&td->td_proc->p_vmspace->vm_map, addr,
 731             addr + size, inherit)) {
 732         case KERN_SUCCESS:
 733                 return (0);
 734         case KERN_PROTECTION_FAILURE:
 735                 return (EACCES);
 736         }
 737         return (EINVAL);
 738 }
 739
 740 #ifndef _SYS_SYSPROTO_H_
 741 struct madvise_args {
 742         void *addr;
 743         size_t len;
 744         int behav;
 745 };
 746 #endif
 747
 748 int
 749 sys_madvise(struct thread *td, struct madvise_args *uap)
 750 {
 751
 752         return (kern_madvise(td, (uintptr_t)uap->addr, uap->len, uap->behav));
 753 }
 754
 755 int
 756 kern_madvise(struct thread *td, uintptr_t addr0, size_t len, int behav)
 757 {
 758         vm_map_t map;
 759         vm_offset_t addr, end, start;
 760         int flags;
 761
 762         /*
 763          * Check for our special case, advising the swap pager we are
 764          * "immortal."
 765          */
 766         if (behav == MADV_PROTECT) {
 767                 flags = PPROT_SET;
 768                 return (kern_procctl(td, P_PID, td->td_proc->p_pid,
 769                     PROC_SPROTECT, &flags));
 770         }
 771
 772         /*
 773          * Check for illegal addresses.  Watch out for address wrap... Note
 774          * that VM_*_ADDRESS are not constants due to casts (argh).
 775          */
 776         map = &td->td_proc->p_vmspace->vm_map;
 777         addr = addr0;
 778         if (!vm_map_range_valid(map, addr, addr + len))
 779                 return (EINVAL);
 780
 781         /*
 782          * Since this routine is only advisory, we default to conservative
 783          * behavior.
 784          */
 785         start = trunc_page(addr);
 786         end = round_page(addr + len);
 787
 788         /*
 789          * vm_map_madvise() checks for illegal values of behav.
 790          */
 791         return (vm_map_madvise(map, start, end, behav));
 792 }
 793
 794 #ifndef _SYS_SYSPROTO_H_
 795 struct mincore_args {
 796         const void *addr;
 797         size_t len;
 798         char *vec;
 799 };
 800 #endif
 801
 802 int
 803 sys_mincore(struct thread *td, struct mincore_args *uap)
 804 {
 805
 806         return (kern_mincore(td, (uintptr_t)uap->addr, uap->len, uap->vec));
 807 }
 808
 809 int
 810 kern_mincore(struct thread *td, uintptr_t addr0, size_t len, char *vec)
 811 {
 812         pmap_t pmap;
 813         vm_map_t map;
 814         vm_map_entry_t current, entry;
 815         vm_object_t object;
 816         vm_offset_t addr, cend, end, first_addr;
 817         vm_paddr_t pa;
 818         vm_page_t m;
 819         vm_pindex_t pindex;
 820         int error, lastvecindex, mincoreinfo, vecindex;
 821         unsigned int timestamp;
 822
 823         /*
 824          * Make sure that the addresses presented are valid for user
 825          * mode.
 826          */
 827         first_addr = addr = trunc_page(addr0);
 828         end = round_page(addr0 + len);
 829         map = &td->td_proc->p_vmspace->vm_map;
 830         if (end > vm_map_max(map) || end < addr)
 831                 return (ENOMEM);
 832
 833         pmap = vmspace_pmap(td->td_proc->p_vmspace);
 834
 835         vm_map_lock_read(map);
 836 RestartScan:
 837         timestamp = map->timestamp;
 838
 839         if (!vm_map_lookup_entry(map, addr, &entry)) {
 840                 vm_map_unlock_read(map);
 841                 return (ENOMEM);
 842         }
 843
 844         /*
 845          * Do this on a map entry basis so that if the pages are not
 846          * in the current processes address space, we can easily look
 847          * up the pages elsewhere.
 848          */
 849         lastvecindex = -1;
 850         while (entry->start < end) {
 851                 /*
 852                  * check for contiguity
 853                  */
 854                 current = entry;
 855                 entry = vm_map_entry_succ(current);
 856                 if (current->end < end &&
 857                     entry->start > current->end) {
 858                         vm_map_unlock_read(map);
 859                         return (ENOMEM);
 860                 }
 861
 862                 /*
 863                  * ignore submaps (for now) or null objects
 864                  */
 865                 if ((current->eflags & MAP_ENTRY_IS_SUB_MAP) ||
 866                     current->object.vm_object == NULL)
 867                         continue;
 868
 869                 /*
 870                  * limit this scan to the current map entry and the
 871                  * limits for the mincore call
 872                  */
 873                 if (addr < current->start)
 874                         addr = current->start;
 875                 cend = current->end;
 876                 if (cend > end)
 877                         cend = end;
 878
 879                 for (; addr < cend; addr += PAGE_SIZE) {
 880                         /*
 881                          * Check pmap first, it is likely faster, also
 882                          * it can provide info as to whether we are the
 883                          * one referencing or modifying the page.
 884                          */
 885                         m = NULL;
 886                         object = NULL;
 887 retry:
 888                         pa = 0;
 889                         mincoreinfo = pmap_mincore(pmap, addr, &pa);
 890                         if (mincore_mapped) {
 891                                 /*
 892                                  * We only care about this pmap's
 893                                  * mapping of the page, if any.
 894                                  */
 895                                 ;
 896                         } else if (pa != 0) {
 897                                 /*
 898                                  * The page is mapped by this process but not
 899                                  * both accessed and modified.  It is also
 900                                  * managed.  Acquire the object lock so that
 901                                  * other mappings might be examined.  The page's
 902                                  * identity may change at any point before its
 903                                  * object lock is acquired, so re-validate if
 904                                  * necessary.
 905                                  */
 906                                 m = PHYS_TO_VM_PAGE(pa);
 907                                 while (object == NULL || m->object != object) {
 908                                         if (object != NULL)
 909                                                 VM_OBJECT_WUNLOCK(object);
 910                                         object = atomic_load_ptr(&m->object);
 911                                         if (object == NULL)
 912                                                 goto retry;
 913                                         VM_OBJECT_WLOCK(object);
 914                                 }
 915                                 if (pa != pmap_extract(pmap, addr))
 916                                         goto retry;
 917                                 KASSERT(vm_page_all_valid(m),
 918                                     ("mincore: page %p is mapped but invalid",
 919                                     m));
 920                         } else if (mincoreinfo == 0) {
 921                                 /*
 922                                  * The page is not mapped by this process.  If
 923                                  * the object implements managed pages, then
 924                                  * determine if the page is resident so that
 925                                  * the mappings might be examined.
 926                                  */
 927                                 if (current->object.vm_object != object) {
 928                                         if (object != NULL)
 929                                                 VM_OBJECT_WUNLOCK(object);
 930                                         object = current->object.vm_object;
 931                                         VM_OBJECT_WLOCK(object);
 932                                 }
 933                                 if (object->type == OBJT_DEFAULT ||
 934                                     object->type == OBJT_SWAP ||
 935                                     object->type == OBJT_VNODE) {
 936                                         pindex = OFF_TO_IDX(current->offset +
 937                                             (addr - current->start));
 938                                         m = vm_page_lookup(object, pindex);
 939                                         if (m != NULL && vm_page_none_valid(m))
 940                                                 m = NULL;
 941                                         if (m != NULL)
 942                                                 mincoreinfo = MINCORE_INCORE;
 943                                 }
 944                         }
 945                         if (m != NULL) {
 946                                 VM_OBJECT_ASSERT_WLOCKED(m->object);
 947
 948                                 /* Examine other mappings of the page. */
 949                                 if (m->dirty == 0 && pmap_is_modified(m))
 950                                         vm_page_dirty(m);
 951                                 if (m->dirty != 0)
 952                                         mincoreinfo |= MINCORE_MODIFIED_OTHER;
 953
 954                                 /*
 955                                  * The first test for PGA_REFERENCED is an
 956                                  * optimization.  The second test is
 957                                  * required because a concurrent pmap
 958                                  * operation could clear the last reference
 959                                  * and set PGA_REFERENCED before the call to
 960                                  * pmap_is_referenced().
 961                                  */
 962                                 if ((m->a.flags & PGA_REFERENCED) != 0 ||
 963                                     pmap_is_referenced(m) ||
 964                                     (m->a.flags & PGA_REFERENCED) != 0)
 965                                         mincoreinfo |= MINCORE_REFERENCED_OTHER;
 966                         }
 967                         if (object != NULL)
 968                                 VM_OBJECT_WUNLOCK(object);
 969
 970                         /*
 971                          * subyte may page fault.  In case it needs to modify
 972                          * the map, we release the lock.
 973                          */
 974                         vm_map_unlock_read(map);
 975
 976                         /*
 977                          * calculate index into user supplied byte vector
 978                          */
 979                         vecindex = atop(addr - first_addr);
 980
 981                         /*
 982                          * If we have skipped map entries, we need to make sure that
 983                          * the byte vector is zeroed for those skipped entries.
 984                          */
 985                         while ((lastvecindex + 1) < vecindex) {
 986                                 ++lastvecindex;
 987                                 error = subyte(vec + lastvecindex, 0);
 988                                 if (error) {
 989                                         error = EFAULT;
 990                                         goto done2;
 991                                 }
 992                         }
 993
 994                         /*
 995                          * Pass the page information to the user
 996                          */
 997                         error = subyte(vec + vecindex, mincoreinfo);
 998                         if (error) {
 999                                 error = EFAULT;
1000                                 goto done2;
1001                         }
1002
1003                         /*
1004                          * If the map has changed, due to the subyte, the previous
1005                          * output may be invalid.
1006                          */
1007                         vm_map_lock_read(map);
1008                         if (timestamp != map->timestamp)
1009                                 goto RestartScan;
1010
1011                         lastvecindex = vecindex;
1012                 }
1013         }
1014
1015         /*
1016          * subyte may page fault.  In case it needs to modify
1017          * the map, we release the lock.
1018          */
1019         vm_map_unlock_read(map);
1020
1021         /*
1022          * Zero the last entries in the byte vector.
1023          */
1024         vecindex = atop(end - first_addr);
1025         while ((lastvecindex + 1) < vecindex) {
1026                 ++lastvecindex;
1027                 error = subyte(vec + lastvecindex, 0);
1028                 if (error) {
1029                         error = EFAULT;
1030                         goto done2;
1031                 }
1032         }
1033
1034         /*
1035          * If the map has changed, due to the subyte, the previous
1036          * output may be invalid.
1037          */
1038         vm_map_lock_read(map);
1039         if (timestamp != map->timestamp)
1040                 goto RestartScan;
1041         vm_map_unlock_read(map);
1042 done2:
1043         return (error);
1044 }
1045
1046 #ifndef _SYS_SYSPROTO_H_
1047 struct mlock_args {
1048         const void *addr;
1049         size_t len;
1050 };
1051 #endif
1052 int
1053 sys_mlock(struct thread *td, struct mlock_args *uap)
1054 {
1055
1056         return (kern_mlock(td->td_proc, td->td_ucred,
1057             __DECONST(uintptr_t, uap->addr), uap->len));
1058 }
1059
1060 int
1061 kern_mlock(struct proc *proc, struct ucred *cred, uintptr_t addr0, size_t len)
1062 {
1063         vm_offset_t addr, end, last, start;
1064         vm_size_t npages, size;
1065         vm_map_t map;
1066         unsigned long nsize;
1067         int error;
1068
1069         error = priv_check_cred(cred, PRIV_VM_MLOCK);
1070         if (error)
1071                 return (error);
1072         addr = addr0;
1073         size = len;
1074         last = addr + size;
1075         start = trunc_page(addr);
1076         end = round_page(last);
1077         if (last < addr || end < addr)
1078                 return (EINVAL);
1079         npages = atop(end - start);
1080         if (npages > vm_page_max_user_wired)
1081                 return (ENOMEM);
1082         map = &proc->p_vmspace->vm_map;
1083         PROC_LOCK(proc);
1084         nsize = ptoa(npages + pmap_wired_count(map->pmap));
1085         if (nsize > lim_cur_proc(proc, RLIMIT_MEMLOCK)) {
1086                 PROC_UNLOCK(proc);
1087                 return (ENOMEM);
1088         }
1089         PROC_UNLOCK(proc);
1090 #ifdef RACCT
1091         if (racct_enable) {
1092                 PROC_LOCK(proc);
1093                 error = racct_set(proc, RACCT_MEMLOCK, nsize);
1094                 PROC_UNLOCK(proc);
1095                 if (error != 0)
1096                         return (ENOMEM);
1097         }
1098 #endif
1099         error = vm_map_wire(map, start, end,
1100             VM_MAP_WIRE_USER | VM_MAP_WIRE_NOHOLES);
1101 #ifdef RACCT
1102         if (racct_enable && error != KERN_SUCCESS) {
1103                 PROC_LOCK(proc);
1104                 racct_set(proc, RACCT_MEMLOCK,
1105                     ptoa(pmap_wired_count(map->pmap)));
1106                 PROC_UNLOCK(proc);
1107         }
1108 #endif
1109         switch (error) {
1110         case KERN_SUCCESS:
1111                 return (0);
1112         case KERN_INVALID_ARGUMENT:
1113                 return (EINVAL);
1114         default:
1115                 return (ENOMEM);
1116         }
1117 }
1118
1119 #ifndef _SYS_SYSPROTO_H_
1120 struct mlockall_args {
1121         int     how;
1122 };
1123 #endif
1124
1125 int
1126 sys_mlockall(struct thread *td, struct mlockall_args *uap)
1127 {
1128         vm_map_t map;
1129         int error;
1130
1131         map = &td->td_proc->p_vmspace->vm_map;
1132         error = priv_check(td, PRIV_VM_MLOCK);
1133         if (error)
1134                 return (error);
1135
1136         if ((uap->how == 0) || ((uap->how & ~(MCL_CURRENT|MCL_FUTURE)) != 0))
1137                 return (EINVAL);
1138
1139         /*
1140          * If wiring all pages in the process would cause it to exceed
1141          * a hard resource limit, return ENOMEM.
1142          */
1143         if (!old_mlock && uap->how & MCL_CURRENT) {
1144                 if (map->size > lim_cur(td, RLIMIT_MEMLOCK))
1145                         return (ENOMEM);
1146         }
1147 #ifdef RACCT
1148         if (racct_enable) {
1149                 PROC_LOCK(td->td_proc);
1150                 error = racct_set(td->td_proc, RACCT_MEMLOCK, map->size);
1151                 PROC_UNLOCK(td->td_proc);
1152                 if (error != 0)
1153                         return (ENOMEM);
1154         }
1155 #endif
1156
1157         if (uap->how & MCL_FUTURE) {
1158                 vm_map_lock(map);
1159                 vm_map_modflags(map, MAP_WIREFUTURE, 0);
1160                 vm_map_unlock(map);
1161                 error = 0;
1162         }
1163
1164         if (uap->how & MCL_CURRENT) {
1165                 /*
1166                  * P1003.1-2001 mandates that all currently mapped pages
1167                  * will be memory resident and locked (wired) upon return
1168                  * from mlockall(). vm_map_wire() will wire pages, by
1169                  * calling vm_fault_wire() for each page in the region.
1170                  */
1171                 error = vm_map_wire(map, vm_map_min(map), vm_map_max(map),
1172                     VM_MAP_WIRE_USER|VM_MAP_WIRE_HOLESOK);
1173                 if (error == KERN_SUCCESS)
1174                         error = 0;
1175                 else if (error == KERN_RESOURCE_SHORTAGE)
1176                         error = ENOMEM;
1177                 else
1178                         error = EAGAIN;
1179         }
1180 #ifdef RACCT
1181         if (racct_enable && error != KERN_SUCCESS) {
1182                 PROC_LOCK(td->td_proc);
1183                 racct_set(td->td_proc, RACCT_MEMLOCK,
1184                     ptoa(pmap_wired_count(map->pmap)));
1185                 PROC_UNLOCK(td->td_proc);
1186         }
1187 #endif
1188
1189         return (error);
1190 }
1191
1192 #ifndef _SYS_SYSPROTO_H_
1193 struct munlockall_args {
1194         register_t dummy;
1195 };
1196 #endif
1197
1198 int
1199 sys_munlockall(struct thread *td, struct munlockall_args *uap)
1200 {
1201         vm_map_t map;
1202         int error;
1203
1204         map = &td->td_proc->p_vmspace->vm_map;
1205         error = priv_check(td, PRIV_VM_MUNLOCK);
1206         if (error)
1207                 return (error);
1208
1209         /* Clear the MAP_WIREFUTURE flag from this vm_map. */
1210         vm_map_lock(map);
1211         vm_map_modflags(map, 0, MAP_WIREFUTURE);
1212         vm_map_unlock(map);
1213
1214         /* Forcibly unwire all pages. */
1215         error = vm_map_unwire(map, vm_map_min(map), vm_map_max(map),
1216             VM_MAP_WIRE_USER|VM_MAP_WIRE_HOLESOK);
1217 #ifdef RACCT
1218         if (racct_enable && error == KERN_SUCCESS) {
1219                 PROC_LOCK(td->td_proc);
1220                 racct_set(td->td_proc, RACCT_MEMLOCK, 0);
1221                 PROC_UNLOCK(td->td_proc);
1222         }
1223 #endif
1224
1225         return (error);
1226 }
1227
1228 #ifndef _SYS_SYSPROTO_H_
1229 struct munlock_args {
1230         const void *addr;
1231         size_t len;
1232 };
1233 #endif
1234 int
1235 sys_munlock(struct thread *td, struct munlock_args *uap)
1236 {
1237
1238         return (kern_munlock(td, (uintptr_t)uap->addr, uap->len));
1239 }
1240
1241 int
1242 kern_munlock(struct thread *td, uintptr_t addr0, size_t size)
1243 {
1244         vm_offset_t addr, end, last, start;
1245 #ifdef RACCT
1246         vm_map_t map;
1247 #endif
1248         int error;
1249
1250         error = priv_check(td, PRIV_VM_MUNLOCK);
1251         if (error)
1252                 return (error);
1253         addr = addr0;
1254         last = addr + size;
1255         start = trunc_page(addr);
1256         end = round_page(last);
1257         if (last < addr || end < addr)
1258                 return (EINVAL);
1259         error = vm_map_unwire(&td->td_proc->p_vmspace->vm_map, start, end,
1260             VM_MAP_WIRE_USER | VM_MAP_WIRE_NOHOLES);
1261 #ifdef RACCT
1262         if (racct_enable && error == KERN_SUCCESS) {
1263                 PROC_LOCK(td->td_proc);
1264                 map = &td->td_proc->p_vmspace->vm_map;
1265                 racct_set(td->td_proc, RACCT_MEMLOCK,
1266                     ptoa(pmap_wired_count(map->pmap)));
1267                 PROC_UNLOCK(td->td_proc);
1268         }
1269 #endif
1270         return (error == KERN_SUCCESS ? 0 : ENOMEM);
1271 }
1272
1273 /*
1274  * vm_mmap_vnode()
1275  *
1276  * Helper function for vm_mmap.  Perform sanity check specific for mmap
1277  * operations on vnodes.
1278  */
1279 int
1280 vm_mmap_vnode(struct thread *td, vm_size_t objsize,
1281     vm_prot_t prot, vm_prot_t *maxprotp, int *flagsp,
1282     struct vnode *vp, vm_ooffset_t *foffp, vm_object_t *objp,
1283     boolean_t *writecounted)
1284 {
1285         struct vattr va;
1286         vm_object_t obj;
1287         vm_ooffset_t foff;
1288         struct ucred *cred;
1289         int error, flags;
1290         bool writex;
1291
1292         cred = td->td_ucred;
1293         writex = (*maxprotp & VM_PROT_WRITE) != 0 &&
1294             (*flagsp & MAP_SHARED) != 0;
1295         if ((error = vget(vp, LK_SHARED)) != 0)
1296                 return (error);
1297         AUDIT_ARG_VNODE1(vp);
1298         foff = *foffp;
1299         flags = *flagsp;
1300         obj = vp->v_object;
1301         if (vp->v_type == VREG) {
1302                 /*
1303                  * Get the proper underlying object
1304                  */
1305                 if (obj == NULL) {
1306                         error = EINVAL;
1307                         goto done;
1308                 }
1309                 if (obj->type == OBJT_VNODE && obj->handle != vp) {
1310                         vput(vp);
1311                         vp = (struct vnode *)obj->handle;
1312                         /*
1313                          * Bypass filesystems obey the mpsafety of the
1314                          * underlying fs.  Tmpfs never bypasses.
1315                          */
1316                         error = vget(vp, LK_SHARED);
1317                         if (error != 0)
1318                                 return (error);
1319                 }
1320                 if (writex) {
1321                         *writecounted = TRUE;
1322                         vm_pager_update_writecount(obj, 0, objsize);
1323                 }
1324         } else {
1325                 error = EINVAL;
1326                 goto done;
1327         }
1328         if ((error = VOP_GETATTR(vp, &va, cred)))
1329                 goto done;
1330 #ifdef MAC
1331         /* This relies on VM_PROT_* matching PROT_*. */
1332         error = mac_vnode_check_mmap(cred, vp, (int)prot, flags);
1333         if (error != 0)
1334                 goto done;
1335 #endif
1336         if ((flags & MAP_SHARED) != 0) {
1337                 if ((va.va_flags & (SF_SNAPSHOT|IMMUTABLE|APPEND)) != 0) {
1338                         if (prot & VM_PROT_WRITE) {
1339                                 error = EPERM;
1340                                 goto done;
1341                         }
1342                         *maxprotp &= ~VM_PROT_WRITE;
1343                 }
1344         }
1345         /*
1346          * If it is a regular file without any references
1347          * we do not need to sync it.
1348          * Adjust object size to be the size of actual file.
1349          */
1350         objsize = round_page(va.va_size);
1351         if (va.va_nlink == 0)
1352                 flags |= MAP_NOSYNC;
1353         if (obj->type == OBJT_VNODE) {
1354                 obj = vm_pager_allocate(OBJT_VNODE, vp, objsize, prot, foff,
1355                     cred);
1356                 if (obj == NULL) {
1357                         error = ENOMEM;
1358                         goto done;
1359                 }
1360         } else {
1361                 KASSERT(obj->type == OBJT_DEFAULT || obj->type == OBJT_SWAP,
1362                     ("wrong object type"));
1363                 vm_object_reference(obj);
1364 #if VM_NRESERVLEVEL > 0
1365                 if ((obj->flags & OBJ_COLORED) == 0) {
1366                         VM_OBJECT_WLOCK(obj);
1367                         vm_object_color(obj, 0);
1368                         VM_OBJECT_WUNLOCK(obj);
1369                 }
1370 #endif
1371         }
1372         *objp = obj;
1373         *flagsp = flags;
1374
1375         VOP_MMAPPED(vp);
1376
1377 done:
1378         if (error != 0 && *writecounted) {
1379                 *writecounted = FALSE;
1380                 vm_pager_update_writecount(obj, objsize, 0);
1381         }
1382         vput(vp);
1383         return (error);
1384 }
1385
1386 /*
1387  * vm_mmap_cdev()
1388  *
1389  * Helper function for vm_mmap.  Perform sanity check specific for mmap
1390  * operations on cdevs.
1391  */
1392 int
1393 vm_mmap_cdev(struct thread *td, vm_size_t objsize, vm_prot_t prot,
1394     vm_prot_t *maxprotp, int *flagsp, struct cdev *cdev, struct cdevsw *dsw,
1395     vm_ooffset_t *foff, vm_object_t *objp)
1396 {
1397         vm_object_t obj;
1398         int error, flags;
1399
1400         flags = *flagsp;
1401
1402         if (dsw->d_flags & D_MMAP_ANON) {
1403                 *objp = NULL;
1404                 *foff = 0;
1405                 *maxprotp = VM_PROT_ALL;
1406                 *flagsp |= MAP_ANON;
1407                 return (0);
1408         }
1409         /*
1410          * cdevs do not provide private mappings of any kind.
1411          */
1412         if ((*maxprotp & VM_PROT_WRITE) == 0 &&
1413             (prot & VM_PROT_WRITE) != 0)
1414                 return (EACCES);
1415         if (flags & (MAP_PRIVATE|MAP_COPY))
1416                 return (EINVAL);
1417         /*
1418          * Force device mappings to be shared.
1419          */
1420         flags |= MAP_SHARED;
1421 #ifdef MAC_XXX
1422         error = mac_cdev_check_mmap(td->td_ucred, cdev, (int)prot);
1423         if (error != 0)
1424                 return (error);
1425 #endif
1426         /*
1427          * First, try d_mmap_single().  If that is not implemented
1428          * (returns ENODEV), fall back to using the device pager.
1429          * Note that d_mmap_single() must return a reference to the
1430          * object (it needs to bump the reference count of the object
1431          * it returns somehow).
1432          *
1433          * XXX assumes VM_PROT_* == PROT_*
1434          */
1435         error = dsw->d_mmap_single(cdev, foff, objsize, objp, (int)prot);
1436         if (error != ENODEV)
1437                 return (error);
1438         obj = vm_pager_allocate(OBJT_DEVICE, cdev, objsize, prot, *foff,
1439             td->td_ucred);
1440         if (obj == NULL)
1441                 return (EINVAL);
1442         *objp = obj;
1443         *flagsp = flags;
1444         return (0);
1445 }
1446
1447 /*
1448  * vm_mmap()
1449  *
1450  * Internal version of mmap used by exec, sys5 shared memory, and
1451  * various device drivers.  Handle is either a vnode pointer, a
1452  * character device, or NULL for MAP_ANON.
1453  */
1454 int
1455 vm_mmap(vm_map_t map, vm_offset_t *addr, vm_size_t size, vm_prot_t prot,
1456         vm_prot_t maxprot, int flags,
1457         objtype_t handle_type, void *handle,
1458         vm_ooffset_t foff)
1459 {
1460         vm_object_t object;
1461         struct thread *td = curthread;
1462         int error;
1463         boolean_t writecounted;
1464
1465         if (size == 0)
1466                 return (EINVAL);
1467
1468         size = round_page(size);
1469         object = NULL;
1470         writecounted = FALSE;
1471
1472         /*
1473          * Lookup/allocate object.
1474          */
1475         switch (handle_type) {
1476         case OBJT_DEVICE: {
1477                 struct cdevsw *dsw;
1478                 struct cdev *cdev;
1479                 int ref;
1480
1481                 cdev = handle;
1482                 dsw = dev_refthread(cdev, &ref);
1483                 if (dsw == NULL)
1484                         return (ENXIO);
1485                 error = vm_mmap_cdev(td, size, prot, &maxprot, &flags, cdev,
1486                     dsw, &foff, &object);
1487                 dev_relthread(cdev, ref);
1488                 break;
1489         }
1490         case OBJT_VNODE:
1491                 error = vm_mmap_vnode(td, size, prot, &maxprot, &flags,
1492                     handle, &foff, &object, &writecounted);
1493                 break;
1494         case OBJT_DEFAULT:
1495                 if (handle == NULL) {
1496                         error = 0;
1497                         break;
1498                 }
1499                 /* FALLTHROUGH */
1500         default:
1501                 error = EINVAL;
1502                 break;
1503         }
1504         if (error)
1505                 return (error);
1506
1507         error = vm_mmap_object(map, addr, size, prot, maxprot, flags, object,
1508             foff, writecounted, td);
1509         if (error != 0 && object != NULL) {
1510                 /*
1511                  * If this mapping was accounted for in the vnode's
1512                  * writecount, then undo that now.
1513                  */
1514                 if (writecounted)
1515                         vm_pager_release_writecount(object, 0, size);
1516                 vm_object_deallocate(object);
1517         }
1518         return (error);
1519 }
1520
1521 int
1522 kern_mmap_racct_check(struct thread *td, vm_map_t map, vm_size_t size)
1523 {
1524         int error;
1525
1526         RACCT_PROC_LOCK(td->td_proc);
1527         if (map->size + size > lim_cur(td, RLIMIT_VMEM)) {
1528                 RACCT_PROC_UNLOCK(td->td_proc);
1529                 return (ENOMEM);
1530         }
1531         if (racct_set(td->td_proc, RACCT_VMEM, map->size + size)) {
1532                 RACCT_PROC_UNLOCK(td->td_proc);
1533                 return (ENOMEM);
1534         }
1535         if (!old_mlock && map->flags & MAP_WIREFUTURE) {
1536                 if (ptoa(pmap_wired_count(map->pmap)) + size >
1537                     lim_cur(td, RLIMIT_MEMLOCK)) {
1538                         racct_set_force(td->td_proc, RACCT_VMEM, map->size);
1539                         RACCT_PROC_UNLOCK(td->td_proc);
1540                         return (ENOMEM);
1541                 }
1542                 error = racct_set(td->td_proc, RACCT_MEMLOCK,
1543                     ptoa(pmap_wired_count(map->pmap)) + size);
1544                 if (error != 0) {
1545                         racct_set_force(td->td_proc, RACCT_VMEM, map->size);
1546                         RACCT_PROC_UNLOCK(td->td_proc);
1547                         return (error);
1548                 }
1549         }
1550         RACCT_PROC_UNLOCK(td->td_proc);
1551         return (0);
1552 }
1553
1554 /*
1555  * Internal version of mmap that maps a specific VM object into an
1556  * map.  Called by mmap for MAP_ANON, vm_mmap, shm_mmap, and vn_mmap.
1557  */
1558 int
1559 vm_mmap_object(vm_map_t map, vm_offset_t *addr, vm_size_t size, vm_prot_t prot,
1560     vm_prot_t maxprot, int flags, vm_object_t object, vm_ooffset_t foff,
1561     boolean_t writecounted, struct thread *td)
1562 {
1563         vm_offset_t max_addr;
1564         int docow, error, findspace, rv;
1565         bool curmap, fitit;
1566
1567         curmap = map == &td->td_proc->p_vmspace->vm_map;
1568         if (curmap) {
1569                 error = kern_mmap_racct_check(td, map, size);
1570                 if (error != 0)
1571                         return (error);
1572         }
1573
1574         /*
1575          * We currently can only deal with page aligned file offsets.
1576          * The mmap() system call already enforces this by subtracting
1577          * the page offset from the file offset, but checking here
1578          * catches errors in device drivers (e.g. d_single_mmap()
1579          * callbacks) and other internal mapping requests (such as in
1580          * exec).
1581          */
1582         if (foff & PAGE_MASK)
1583                 return (EINVAL);
1584
1585         if ((flags & MAP_FIXED) == 0) {
1586                 fitit = TRUE;
1587                 *addr = round_page(*addr);
1588         } else {
1589                 if (*addr != trunc_page(*addr))
1590                         return (EINVAL);
1591                 fitit = FALSE;
1592         }
1593
1594         if (flags & MAP_ANON) {
1595                 if (object != NULL || foff != 0)
1596                         return (EINVAL);
1597                 docow = 0;
1598         } else if (flags & MAP_PREFAULT_READ)
1599                 docow = MAP_PREFAULT;
1600         else
1601                 docow = MAP_PREFAULT_PARTIAL;
1602
1603         if ((flags & (MAP_ANON|MAP_SHARED)) == 0)
1604                 docow |= MAP_COPY_ON_WRITE;
1605         if (flags & MAP_NOSYNC)
1606                 docow |= MAP_DISABLE_SYNCER;
1607         if (flags & MAP_NOCORE)
1608                 docow |= MAP_DISABLE_COREDUMP;
1609         /* Shared memory is also shared with children. */
1610         if (flags & MAP_SHARED)
1611                 docow |= MAP_INHERIT_SHARE;
1612         if (writecounted)
1613                 docow |= MAP_WRITECOUNT;
1614         if (flags & MAP_STACK) {
1615                 if (object != NULL)
1616                         return (EINVAL);
1617                 docow |= MAP_STACK_GROWS_DOWN;
1618         }
1619         if ((flags & MAP_EXCL) != 0)
1620                 docow |= MAP_CHECK_EXCL;
1621         if ((flags & MAP_GUARD) != 0)
1622                 docow |= MAP_CREATE_GUARD;
1623
1624         if (fitit) {
1625                 if ((flags & MAP_ALIGNMENT_MASK) == MAP_ALIGNED_SUPER)
1626                         findspace = VMFS_SUPER_SPACE;
1627                 else if ((flags & MAP_ALIGNMENT_MASK) != 0)
1628                         findspace = VMFS_ALIGNED_SPACE(flags >>
1629                             MAP_ALIGNMENT_SHIFT);
1630                 else
1631                         findspace = VMFS_OPTIMAL_SPACE;
1632                 max_addr = 0;
1633 #ifdef MAP_32BIT
1634                 if ((flags & MAP_32BIT) != 0)
1635                         max_addr = MAP_32BIT_MAX_ADDR;
1636 #endif
1637                 if (curmap) {
1638                         rv = vm_map_find_min(map, object, foff, addr, size,
1639                             round_page((vm_offset_t)td->td_proc->p_vmspace->
1640                             vm_daddr + lim_max(td, RLIMIT_DATA)), max_addr,
1641                             findspace, prot, maxprot, docow);
1642                 } else {
1643                         rv = vm_map_find(map, object, foff, addr, size,
1644                             max_addr, findspace, prot, maxprot, docow);
1645                 }
1646         } else {
1647                 rv = vm_map_fixed(map, object, foff, *addr, size,
1648                     prot, maxprot, docow);
1649         }
1650
1651         if (rv == KERN_SUCCESS) {
1652                 /*
1653                  * If the process has requested that all future mappings
1654                  * be wired, then heed this.
1655                  */
1656                 if ((map->flags & MAP_WIREFUTURE) != 0) {
1657                         vm_map_lock(map);
1658                         if ((map->flags & MAP_WIREFUTURE) != 0)
1659                                 (void)vm_map_wire_locked(map, *addr,
1660                                     *addr + size, VM_MAP_WIRE_USER |
1661                                     ((flags & MAP_STACK) ? VM_MAP_WIRE_HOLESOK :
1662                                     VM_MAP_WIRE_NOHOLES));
1663                         vm_map_unlock(map);
1664                 }
1665         }
1666         return (vm_mmap_to_errno(rv));
1667 }
1668
1669 /*
1670  * Translate a Mach VM return code to zero on success or the appropriate errno
1671  * on failure.
1672  */
1673 int
1674 vm_mmap_to_errno(int rv)
1675 {
1676
1677         switch (rv) {
1678         case KERN_SUCCESS:
1679                 return (0);
1680         case KERN_INVALID_ADDRESS:
1681         case KERN_NO_SPACE:
1682                 return (ENOMEM);
1683         case KERN_PROTECTION_FAILURE:
1684                 return (EACCES);
1685         default:
1686                 return (EINVAL);
1687         }
1688 }