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