sys/vm/vm_mmap.c

   1 /*-
   2  * Copyright (c) 1988 University of Utah.
   3  * Copyright (c) 1991, 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * the Systems Programming Group of the University of Utah Computer
   8  * Science Department.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 4. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * from: Utah $Hdr: vm_mmap.c 1.6 91/10/21$
  35  *
  36  *      @(#)vm_mmap.c   8.4 (Berkeley) 1/12/94
  37  */
  38
  39 /*
  40  * Mapped file (mmap) interface to VM
  41  */
  42
  43 #include <sys/cdefs.h>
  44 __FBSDID("$FreeBSD$");
  45
  46 #include "opt_compat.h"
  47 #include "opt_mac.h"
  48
  49 #include <sys/param.h>
  50 #include <sys/systm.h>
  51 #include <sys/kernel.h>
  52 #include <sys/lock.h>
  53 #include <sys/mutex.h>
  54 #include <sys/sysproto.h>
  55 #include <sys/filedesc.h>
  56 #include <sys/proc.h>
  57 #include <sys/resource.h>
  58 #include <sys/resourcevar.h>
  59 #include <sys/vnode.h>
  60 #include <sys/fcntl.h>
  61 #include <sys/file.h>
  62 #include <sys/mac.h>
  63 #include <sys/mman.h>
  64 #include <sys/mount.h>
  65 #include <sys/conf.h>
  66 #include <sys/stat.h>
  67 #include <sys/vmmeter.h>
  68 #include <sys/sysctl.h>
  69
  70 #include <vm/vm.h>
  71 #include <vm/vm_param.h>
  72 #include <vm/pmap.h>
  73 #include <vm/vm_map.h>
  74 #include <vm/vm_object.h>
  75 #include <vm/vm_page.h>
  76 #include <vm/vm_pager.h>
  77 #include <vm/vm_pageout.h>
  78 #include <vm/vm_extern.h>
  79 #include <vm/vm_page.h>
  80 #include <vm/vm_kern.h>
  81
  82 #ifndef _SYS_SYSPROTO_H_
  83 struct sbrk_args {
  84         int incr;
  85 };
  86 #endif
  87
  88 static int max_proc_mmap;
  89 SYSCTL_INT(_vm, OID_AUTO, max_proc_mmap, CTLFLAG_RW, &max_proc_mmap, 0, "");
  90
  91 /*
  92  * Set the maximum number of vm_map_entry structures per process.  Roughly
  93  * speaking vm_map_entry structures are tiny, so allowing them to eat 1/100
  94  * of our KVM malloc space still results in generous limits.  We want a
  95  * default that is good enough to prevent the kernel running out of resources
  96  * if attacked from compromised user account but generous enough such that
  97  * multi-threaded processes are not unduly inconvenienced.
  98  */
  99 static void vmmapentry_rsrc_init(void *);
 100 SYSINIT(vmmersrc, SI_SUB_KVM_RSRC, SI_ORDER_FIRST, vmmapentry_rsrc_init, NULL)
 101
 102 static void
 103 vmmapentry_rsrc_init(dummy)
 104         void *dummy;
 105 {
 106     max_proc_mmap = vm_kmem_size / sizeof(struct vm_map_entry);
 107     max_proc_mmap /= 100;
 108 }
 109
 110 static int vm_mmap_vnode(struct thread *, vm_size_t, vm_prot_t, vm_prot_t *,
 111     int *, struct vnode *, vm_ooffset_t, vm_object_t *);
 112 static int vm_mmap_cdev(struct thread *, vm_size_t, vm_prot_t, vm_prot_t *,
 113     int *, struct cdev *, vm_ooffset_t, vm_object_t *);
 114
 115 /*
 116  * MPSAFE
 117  */
 118 /* ARGSUSED */
 119 int
 120 sbrk(td, uap)
 121         struct thread *td;
 122         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 /*
 135  * MPSAFE
 136  */
 137 /* ARGSUSED */
 138 int
 139 sstk(td, uap)
 140         struct thread *td;
 141         struct sstk_args *uap;
 142 {
 143         /* Not yet implemented */
 144         return (EOPNOTSUPP);
 145 }
 146
 147 #if defined(COMPAT_43)
 148 #ifndef _SYS_SYSPROTO_H_
 149 struct getpagesize_args {
 150         int dummy;
 151 };
 152 #endif
 153
 154 /* ARGSUSED */
 155 int
 156 ogetpagesize(td, uap)
 157         struct thread *td;
 158         struct getpagesize_args *uap;
 159 {
 160         /* MP SAFE */
 161         td->td_retval[0] = PAGE_SIZE;
 162         return (0);
 163 }
 164 #endif                          /* COMPAT_43 */
 165
 166
 167 /*
 168  * Memory Map (mmap) system call.  Note that the file offset
 169  * and address are allowed to be NOT page aligned, though if
 170  * the MAP_FIXED flag it set, both must have the same remainder
 171  * modulo the PAGE_SIZE (POSIX 1003.1b).  If the address is not
 172  * page-aligned, the actual mapping starts at trunc_page(addr)
 173  * and the return value is adjusted up by the page offset.
 174  *
 175  * Generally speaking, only character devices which are themselves
 176  * memory-based, such as a video framebuffer, can be mmap'd.  Otherwise
 177  * there would be no cache coherency between a descriptor and a VM mapping
 178  * both to the same character device.
 179  *
 180  * Block devices can be mmap'd no matter what they represent.  Cache coherency
 181  * is maintained as long as you do not write directly to the underlying
 182  * character device.
 183  */
 184 #ifndef _SYS_SYSPROTO_H_
 185 struct mmap_args {
 186         void *addr;
 187         size_t len;
 188         int prot;
 189         int flags;
 190         int fd;
 191         long pad;
 192         off_t pos;
 193 };
 194 #endif
 195
 196 /*
 197  * MPSAFE
 198  */
 199 int
 200 mmap(td, uap)
 201         struct thread *td;
 202         struct mmap_args *uap;
 203 {
 204         struct file *fp;
 205         struct vnode *vp;
 206         vm_offset_t addr;
 207         vm_size_t size, pageoff;
 208         vm_prot_t prot, maxprot;
 209         void *handle;
 210         objtype_t handle_type;
 211         int flags, error;
 212         off_t pos;
 213         struct vmspace *vms = td->td_proc->p_vmspace;
 214
 215         addr = (vm_offset_t) uap->addr;
 216         size = uap->len;
 217         prot = uap->prot & VM_PROT_ALL;
 218         flags = uap->flags;
 219         pos = uap->pos;
 220
 221         fp = NULL;
 222         /* make sure mapping fits into numeric range etc */
 223         if ((ssize_t) uap->len < 0 ||
 224             ((flags & MAP_ANON) && uap->fd != -1))
 225                 return (EINVAL);
 226
 227         if (flags & MAP_STACK) {
 228                 if ((uap->fd != -1) ||
 229                     ((prot & (PROT_READ | PROT_WRITE)) != (PROT_READ | PROT_WRITE)))
 230                         return (EINVAL);
 231                 flags |= MAP_ANON;
 232                 pos = 0;
 233         }
 234
 235         /*
 236          * Align the file position to a page boundary,
 237          * and save its page offset component.
 238          */
 239         pageoff = (pos & PAGE_MASK);
 240         pos -= pageoff;
 241
 242         /* Adjust size for rounding (on both ends). */
 243         size += pageoff;                        /* low end... */
 244         size = (vm_size_t) round_page(size);    /* hi end */
 245
 246         /*
 247          * Check for illegal addresses.  Watch out for address wrap... Note
 248          * that VM_*_ADDRESS are not constants due to casts (argh).
 249          */
 250         if (flags & MAP_FIXED) {
 251                 /*
 252                  * The specified address must have the same remainder
 253                  * as the file offset taken modulo PAGE_SIZE, so it
 254                  * should be aligned after adjustment by pageoff.
 255                  */
 256                 addr -= pageoff;
 257                 if (addr & PAGE_MASK)
 258                         return (EINVAL);
 259                 /* Address range must be all in user VM space. */
 260                 if (addr < vm_map_min(&vms->vm_map) ||
 261                     addr + size > vm_map_max(&vms->vm_map))
 262                         return (EINVAL);
 263                 if (addr + size < addr)
 264                         return (EINVAL);
 265         } else {
 266         /*
 267          * XXX for non-fixed mappings where no hint is provided or
 268          * the hint would fall in the potential heap space,
 269          * place it after the end of the largest possible heap.
 270          *
 271          * There should really be a pmap call to determine a reasonable
 272          * location.
 273          */
 274                 PROC_LOCK(td->td_proc);
 275                 if (addr == 0 ||
 276                     (addr >= round_page((vm_offset_t)vms->vm_taddr) &&
 277                     addr < round_page((vm_offset_t)vms->vm_daddr +
 278                     lim_max(td->td_proc, RLIMIT_DATA))))
 279                         addr = round_page((vm_offset_t)vms->vm_daddr +
 280                             lim_max(td->td_proc, RLIMIT_DATA));
 281                 PROC_UNLOCK(td->td_proc);
 282         }
 283         if (flags & MAP_ANON) {
 284                 /*
 285                  * Mapping blank space is trivial.
 286                  */
 287                 handle = NULL;
 288                 handle_type = OBJT_DEFAULT;
 289                 maxprot = VM_PROT_ALL;
 290                 pos = 0;
 291         } else {
 292                 /*
 293                  * Mapping file, get fp for validation. Obtain vnode and make
 294                  * sure it is of appropriate type.
 295                  * don't let the descriptor disappear on us if we block
 296                  */
 297                 if ((error = fget(td, uap->fd, &fp)) != 0)
 298                         goto done;
 299                 if (fp->f_type != DTYPE_VNODE) {
 300                         error = EINVAL;
 301                         goto done;
 302                 }
 303                 /*
 304                  * POSIX shared-memory objects are defined to have
 305                  * kernel persistence, and are not defined to support
 306                  * read(2)/write(2) -- or even open(2).  Thus, we can
 307                  * use MAP_ASYNC to trade on-disk coherence for speed.
 308                  * The shm_open(3) library routine turns on the FPOSIXSHM
 309                  * flag to request this behavior.
 310                  */
 311                 if (fp->f_flag & FPOSIXSHM)
 312                         flags |= MAP_NOSYNC;
 313                 vp = fp->f_vnode;
 314                 /*
 315                  * Ensure that file and memory protections are
 316                  * compatible.  Note that we only worry about
 317                  * writability if mapping is shared; in this case,
 318                  * current and max prot are dictated by the open file.
 319                  * XXX use the vnode instead?  Problem is: what
 320                  * credentials do we use for determination? What if
 321                  * proc does a setuid?
 322                  */
 323                 if (vp->v_mount != NULL && vp->v_mount->mnt_flag & MNT_NOEXEC)
 324                         maxprot = VM_PROT_NONE;
 325                 else
 326                         maxprot = VM_PROT_EXECUTE;
 327                 if (fp->f_flag & FREAD) {
 328                         maxprot |= VM_PROT_READ;
 329                 } else if (prot & PROT_READ) {
 330                         error = EACCES;
 331                         goto done;
 332                 }
 333                 /*
 334                  * If we are sharing potential changes (either via
 335                  * MAP_SHARED or via the implicit sharing of character
 336                  * device mappings), and we are trying to get write
 337                  * permission although we opened it without asking
 338                  * for it, bail out.
 339                  */
 340                 if ((flags & MAP_SHARED) != 0) {
 341                         if ((fp->f_flag & FWRITE) != 0) {
 342                                 maxprot |= VM_PROT_WRITE;
 343                         } else if ((prot & PROT_WRITE) != 0) {
 344                                 error = EACCES;
 345                                 goto done;
 346                         }
 347                 } else if (vp->v_type != VCHR || (fp->f_flag & FWRITE) != 0) {
 348                         maxprot |= VM_PROT_WRITE;
 349                 }
 350                 handle = (void *)vp;
 351                 handle_type = OBJT_VNODE;
 352         }
 353
 354         /*
 355          * Do not allow more then a certain number of vm_map_entry structures
 356          * per process.  Scale with the number of rforks sharing the map
 357          * to make the limit reasonable for threads.
 358          */
 359         if (max_proc_mmap &&
 360             vms->vm_map.nentries >= max_proc_mmap * vms->vm_refcnt) {
 361                 error = ENOMEM;
 362                 goto done;
 363         }
 364
 365         error = vm_mmap(&vms->vm_map, &addr, size, prot, maxprot,
 366             flags, handle_type, handle, pos);
 367         if (error == 0)
 368                 td->td_retval[0] = (register_t) (addr + pageoff);
 369 done:
 370         if (fp)
 371                 fdrop(fp, td);
 372
 373         return (error);
 374 }
 375
 376 #ifdef COMPAT_43
 377 #ifndef _SYS_SYSPROTO_H_
 378 struct ommap_args {
 379         caddr_t addr;
 380         int len;
 381         int prot;
 382         int flags;
 383         int fd;
 384         long pos;
 385 };
 386 #endif
 387 int
 388 ommap(td, uap)
 389         struct thread *td;
 390         struct ommap_args *uap;
 391 {
 392         struct mmap_args nargs;
 393         static const char cvtbsdprot[8] = {
 394                 0,
 395                 PROT_EXEC,
 396                 PROT_WRITE,
 397                 PROT_EXEC | PROT_WRITE,
 398                 PROT_READ,
 399                 PROT_EXEC | PROT_READ,
 400                 PROT_WRITE | PROT_READ,
 401                 PROT_EXEC | PROT_WRITE | PROT_READ,
 402         };
 403
 404 #define OMAP_ANON       0x0002
 405 #define OMAP_COPY       0x0020
 406 #define OMAP_SHARED     0x0010
 407 #define OMAP_FIXED      0x0100
 408
 409         nargs.addr = uap->addr;
 410         nargs.len = uap->len;
 411         nargs.prot = cvtbsdprot[uap->prot & 0x7];
 412         nargs.flags = 0;
 413         if (uap->flags & OMAP_ANON)
 414                 nargs.flags |= MAP_ANON;
 415         if (uap->flags & OMAP_COPY)
 416                 nargs.flags |= MAP_COPY;
 417         if (uap->flags & OMAP_SHARED)
 418                 nargs.flags |= MAP_SHARED;
 419         else
 420                 nargs.flags |= MAP_PRIVATE;
 421         if (uap->flags & OMAP_FIXED)
 422                 nargs.flags |= MAP_FIXED;
 423         nargs.fd = uap->fd;
 424         nargs.pos = uap->pos;
 425         return (mmap(td, &nargs));
 426 }
 427 #endif                          /* COMPAT_43 */
 428
 429
 430 #ifndef _SYS_SYSPROTO_H_
 431 struct msync_args {
 432         void *addr;
 433         int len;
 434         int flags;
 435 };
 436 #endif
 437 /*
 438  * MPSAFE
 439  */
 440 int
 441 msync(td, uap)
 442         struct thread *td;
 443         struct msync_args *uap;
 444 {
 445         vm_offset_t addr;
 446         vm_size_t size, pageoff;
 447         int flags;
 448         vm_map_t map;
 449         int rv;
 450
 451         addr = (vm_offset_t) uap->addr;
 452         size = uap->len;
 453         flags = uap->flags;
 454
 455         pageoff = (addr & PAGE_MASK);
 456         addr -= pageoff;
 457         size += pageoff;
 458         size = (vm_size_t) round_page(size);
 459         if (addr + size < addr)
 460                 return (EINVAL);
 461
 462         if ((flags & (MS_ASYNC|MS_INVALIDATE)) == (MS_ASYNC|MS_INVALIDATE))
 463                 return (EINVAL);
 464
 465         map = &td->td_proc->p_vmspace->vm_map;
 466
 467         /*
 468          * Clean the pages and interpret the return value.
 469          */
 470         rv = vm_map_sync(map, addr, addr + size, (flags & MS_ASYNC) == 0,
 471             (flags & MS_INVALIDATE) != 0);
 472         switch (rv) {
 473         case KERN_SUCCESS:
 474                 return (0);
 475         case KERN_INVALID_ADDRESS:
 476                 return (EINVAL);        /* Sun returns ENOMEM? */
 477         case KERN_INVALID_ARGUMENT:
 478                 return (EBUSY);
 479         default:
 480                 return (EINVAL);
 481         }
 482 }
 483
 484 #ifndef _SYS_SYSPROTO_H_
 485 struct munmap_args {
 486         void *addr;
 487         size_t len;
 488 };
 489 #endif
 490 /*
 491  * MPSAFE
 492  */
 493 int
 494 munmap(td, uap)
 495         struct thread *td;
 496         struct munmap_args *uap;
 497 {
 498         vm_offset_t addr;
 499         vm_size_t size, pageoff;
 500         vm_map_t map;
 501
 502         addr = (vm_offset_t) uap->addr;
 503         size = uap->len;
 504         if (size == 0)
 505                 return (EINVAL);
 506
 507         pageoff = (addr & PAGE_MASK);
 508         addr -= pageoff;
 509         size += pageoff;
 510         size = (vm_size_t) round_page(size);
 511         if (addr + size < addr)
 512                 return (EINVAL);
 513
 514         /*
 515          * Check for illegal addresses.  Watch out for address wrap...
 516          */
 517         map = &td->td_proc->p_vmspace->vm_map;
 518         if (addr < vm_map_min(map) || addr + size > vm_map_max(map))
 519                 return (EINVAL);
 520         vm_map_lock(map);
 521         /*
 522          * Make sure entire range is allocated.
 523          */
 524         if (!vm_map_check_protection(map, addr, addr + size, VM_PROT_NONE)) {
 525                 vm_map_unlock(map);
 526                 return (EINVAL);
 527         }
 528         /* returns nothing but KERN_SUCCESS anyway */
 529         vm_map_delete(map, addr, addr + size);
 530         vm_map_unlock(map);
 531         return (0);
 532 }
 533
 534 #ifndef _SYS_SYSPROTO_H_
 535 struct mprotect_args {
 536         const void *addr;
 537         size_t len;
 538         int prot;
 539 };
 540 #endif
 541 /*
 542  * MPSAFE
 543  */
 544 int
 545 mprotect(td, uap)
 546         struct thread *td;
 547         struct mprotect_args *uap;
 548 {
 549         vm_offset_t addr;
 550         vm_size_t size, pageoff;
 551         vm_prot_t prot;
 552
 553         addr = (vm_offset_t) uap->addr;
 554         size = uap->len;
 555         prot = uap->prot & VM_PROT_ALL;
 556 #if defined(VM_PROT_READ_IS_EXEC)
 557         if (prot & VM_PROT_READ)
 558                 prot |= VM_PROT_EXECUTE;
 559 #endif
 560
 561         pageoff = (addr & PAGE_MASK);
 562         addr -= pageoff;
 563         size += pageoff;
 564         size = (vm_size_t) round_page(size);
 565         if (addr + size < addr)
 566                 return (EINVAL);
 567
 568         switch (vm_map_protect(&td->td_proc->p_vmspace->vm_map, addr,
 569             addr + size, prot, FALSE)) {
 570         case KERN_SUCCESS:
 571                 return (0);
 572         case KERN_PROTECTION_FAILURE:
 573                 return (EACCES);
 574         }
 575         return (EINVAL);
 576 }
 577
 578 #ifndef _SYS_SYSPROTO_H_
 579 struct minherit_args {
 580         void *addr;
 581         size_t len;
 582         int inherit;
 583 };
 584 #endif
 585 /*
 586  * MPSAFE
 587  */
 588 int
 589 minherit(td, uap)
 590         struct thread *td;
 591         struct minherit_args *uap;
 592 {
 593         vm_offset_t addr;
 594         vm_size_t size, pageoff;
 595         vm_inherit_t inherit;
 596
 597         addr = (vm_offset_t)uap->addr;
 598         size = uap->len;
 599         inherit = uap->inherit;
 600
 601         pageoff = (addr & PAGE_MASK);
 602         addr -= pageoff;
 603         size += pageoff;
 604         size = (vm_size_t) round_page(size);
 605         if (addr + size < addr)
 606                 return (EINVAL);
 607
 608         switch (vm_map_inherit(&td->td_proc->p_vmspace->vm_map, addr,
 609             addr + size, inherit)) {
 610         case KERN_SUCCESS:
 611                 return (0);
 612         case KERN_PROTECTION_FAILURE:
 613                 return (EACCES);
 614         }
 615         return (EINVAL);
 616 }
 617
 618 #ifndef _SYS_SYSPROTO_H_
 619 struct madvise_args {
 620         void *addr;
 621         size_t len;
 622         int behav;
 623 };
 624 #endif
 625
 626 /*
 627  * MPSAFE
 628  */
 629 /* ARGSUSED */
 630 int
 631 madvise(td, uap)
 632         struct thread *td;
 633         struct madvise_args *uap;
 634 {
 635         vm_offset_t start, end;
 636         vm_map_t map;
 637         struct proc *p;
 638         int error;
 639
 640         /*
 641          * Check for our special case, advising the swap pager we are
 642          * "immortal."
 643          */
 644         if (uap->behav == MADV_PROTECT) {
 645                 error = suser(td);
 646                 if (error == 0) {
 647                         p = td->td_proc;
 648                         PROC_LOCK(p);
 649                         p->p_flag |= P_PROTECTED;
 650                         PROC_UNLOCK(p);
 651                 }
 652                 return (error);
 653         }
 654         /*
 655          * Check for illegal behavior
 656          */
 657         if (uap->behav < 0 || uap->behav > MADV_CORE)
 658                 return (EINVAL);
 659         /*
 660          * Check for illegal addresses.  Watch out for address wrap... Note
 661          * that VM_*_ADDRESS are not constants due to casts (argh).
 662          */
 663         map = &td->td_proc->p_vmspace->vm_map;
 664         if ((vm_offset_t)uap->addr < vm_map_min(map) ||
 665             (vm_offset_t)uap->addr + uap->len > vm_map_max(map))
 666                 return (EINVAL);
 667         if (((vm_offset_t) uap->addr + uap->len) < (vm_offset_t) uap->addr)
 668                 return (EINVAL);
 669
 670         /*
 671          * Since this routine is only advisory, we default to conservative
 672          * behavior.
 673          */
 674         start = trunc_page((vm_offset_t) uap->addr);
 675         end = round_page((vm_offset_t) uap->addr + uap->len);
 676
 677         if (vm_map_madvise(map, start, end, uap->behav))
 678                 return (EINVAL);
 679         return (0);
 680 }
 681
 682 #ifndef _SYS_SYSPROTO_H_
 683 struct mincore_args {
 684         const void *addr;
 685         size_t len;
 686         char *vec;
 687 };
 688 #endif
 689
 690 /*
 691  * MPSAFE
 692  */
 693 /* ARGSUSED */
 694 int
 695 mincore(td, uap)
 696         struct thread *td;
 697         struct mincore_args *uap;
 698 {
 699         vm_offset_t addr, first_addr;
 700         vm_offset_t end, cend;
 701         pmap_t pmap;
 702         vm_map_t map;
 703         char *vec;
 704         int error = 0;
 705         int vecindex, lastvecindex;
 706         vm_map_entry_t current;
 707         vm_map_entry_t entry;
 708         int mincoreinfo;
 709         unsigned int timestamp;
 710
 711         /*
 712          * Make sure that the addresses presented are valid for user
 713          * mode.
 714          */
 715         first_addr = addr = trunc_page((vm_offset_t) uap->addr);
 716         end = addr + (vm_size_t)round_page(uap->len);
 717         map = &td->td_proc->p_vmspace->vm_map;
 718         if (end > vm_map_max(map) || end < addr)
 719                 return (EINVAL);
 720
 721         /*
 722          * Address of byte vector
 723          */
 724         vec = uap->vec;
 725
 726         pmap = vmspace_pmap(td->td_proc->p_vmspace);
 727
 728         vm_map_lock_read(map);
 729 RestartScan:
 730         timestamp = map->timestamp;
 731
 732         if (!vm_map_lookup_entry(map, addr, &entry))
 733                 entry = entry->next;
 734
 735         /*
 736          * Do this on a map entry basis so that if the pages are not
 737          * in the current processes address space, we can easily look
 738          * up the pages elsewhere.
 739          */
 740         lastvecindex = -1;
 741         for (current = entry;
 742             (current != &map->header) && (current->start < end);
 743             current = current->next) {
 744
 745                 /*
 746                  * ignore submaps (for now) or null objects
 747                  */
 748                 if ((current->eflags & MAP_ENTRY_IS_SUB_MAP) ||
 749                         current->object.vm_object == NULL)
 750                         continue;
 751
 752                 /*
 753                  * limit this scan to the current map entry and the
 754                  * limits for the mincore call
 755                  */
 756                 if (addr < current->start)
 757                         addr = current->start;
 758                 cend = current->end;
 759                 if (cend > end)
 760                         cend = end;
 761
 762                 /*
 763                  * scan this entry one page at a time
 764                  */
 765                 while (addr < cend) {
 766                         /*
 767                          * Check pmap first, it is likely faster, also
 768                          * it can provide info as to whether we are the
 769                          * one referencing or modifying the page.
 770                          */
 771                         mincoreinfo = pmap_mincore(pmap, addr);
 772                         if (!mincoreinfo) {
 773                                 vm_pindex_t pindex;
 774                                 vm_ooffset_t offset;
 775                                 vm_page_t m;
 776                                 /*
 777                                  * calculate the page index into the object
 778                                  */
 779                                 offset = current->offset + (addr - current->start);
 780                                 pindex = OFF_TO_IDX(offset);
 781                                 VM_OBJECT_LOCK(current->object.vm_object);
 782                                 m = vm_page_lookup(current->object.vm_object,
 783                                         pindex);
 784                                 /*
 785                                  * if the page is resident, then gather information about
 786                                  * it.
 787                                  */
 788                                 if (m != NULL && m->valid != 0) {
 789                                         mincoreinfo = MINCORE_INCORE;
 790                                         vm_page_lock_queues();
 791                                         if (m->dirty ||
 792                                                 pmap_is_modified(m))
 793                                                 mincoreinfo |= MINCORE_MODIFIED_OTHER;
 794                                         if ((m->flags & PG_REFERENCED) ||
 795                                                 pmap_ts_referenced(m)) {
 796                                                 vm_page_flag_set(m, PG_REFERENCED);
 797                                                 mincoreinfo |= MINCORE_REFERENCED_OTHER;
 798                                         }
 799                                         vm_page_unlock_queues();
 800                                 }
 801                                 VM_OBJECT_UNLOCK(current->object.vm_object);
 802                         }
 803
 804                         /*
 805                          * subyte may page fault.  In case it needs to modify
 806                          * the map, we release the lock.
 807                          */
 808                         vm_map_unlock_read(map);
 809
 810                         /*
 811                          * calculate index into user supplied byte vector
 812                          */
 813                         vecindex = OFF_TO_IDX(addr - first_addr);
 814
 815                         /*
 816                          * If we have skipped map entries, we need to make sure that
 817                          * the byte vector is zeroed for those skipped entries.
 818                          */
 819                         while ((lastvecindex + 1) < vecindex) {
 820                                 error = subyte(vec + lastvecindex, 0);
 821                                 if (error) {
 822                                         error = EFAULT;
 823                                         goto done2;
 824                                 }
 825                                 ++lastvecindex;
 826                         }
 827
 828                         /*
 829                          * Pass the page information to the user
 830                          */
 831                         error = subyte(vec + vecindex, mincoreinfo);
 832                         if (error) {
 833                                 error = EFAULT;
 834                                 goto done2;
 835                         }
 836
 837                         /*
 838                          * If the map has changed, due to the subyte, the previous
 839                          * output may be invalid.
 840                          */
 841                         vm_map_lock_read(map);
 842                         if (timestamp != map->timestamp)
 843                                 goto RestartScan;
 844
 845                         lastvecindex = vecindex;
 846                         addr += PAGE_SIZE;
 847                 }
 848         }
 849
 850         /*
 851          * subyte may page fault.  In case it needs to modify
 852          * the map, we release the lock.
 853          */
 854         vm_map_unlock_read(map);
 855
 856         /*
 857          * Zero the last entries in the byte vector.
 858          */
 859         vecindex = OFF_TO_IDX(end - first_addr);
 860         while ((lastvecindex + 1) < vecindex) {
 861                 error = subyte(vec + lastvecindex, 0);
 862                 if (error) {
 863                         error = EFAULT;
 864                         goto done2;
 865                 }
 866                 ++lastvecindex;
 867         }
 868
 869         /*
 870          * If the map has changed, due to the subyte, the previous
 871          * output may be invalid.
 872          */
 873         vm_map_lock_read(map);
 874         if (timestamp != map->timestamp)
 875                 goto RestartScan;
 876         vm_map_unlock_read(map);
 877 done2:
 878         return (error);
 879 }
 880
 881 #ifndef _SYS_SYSPROTO_H_
 882 struct mlock_args {
 883         const void *addr;
 884         size_t len;
 885 };
 886 #endif
 887 /*
 888  * MPSAFE
 889  */
 890 int
 891 mlock(td, uap)
 892         struct thread *td;
 893         struct mlock_args *uap;
 894 {
 895         struct proc *proc;
 896         vm_offset_t addr, end, last, start;
 897         vm_size_t npages, size;
 898         int error;
 899
 900         error = suser(td);
 901         if (error)
 902                 return (error);
 903         addr = (vm_offset_t)uap->addr;
 904         size = uap->len;
 905         last = addr + size;
 906         start = trunc_page(addr);
 907         end = round_page(last);
 908         if (last < addr || end < addr)
 909                 return (EINVAL);
 910         npages = atop(end - start);
 911         if (npages > vm_page_max_wired)
 912                 return (ENOMEM);
 913         proc = td->td_proc;
 914         PROC_LOCK(proc);
 915         if (ptoa(npages +
 916             pmap_wired_count(vm_map_pmap(&proc->p_vmspace->vm_map))) >
 917             lim_cur(proc, RLIMIT_MEMLOCK)) {
 918                 PROC_UNLOCK(proc);
 919                 return (ENOMEM);
 920         }
 921         PROC_UNLOCK(proc);
 922         if (npages + cnt.v_wire_count > vm_page_max_wired)
 923                 return (EAGAIN);
 924         error = vm_map_wire(&proc->p_vmspace->vm_map, start, end,
 925             VM_MAP_WIRE_USER | VM_MAP_WIRE_NOHOLES);
 926         return (error == KERN_SUCCESS ? 0 : ENOMEM);
 927 }
 928
 929 #ifndef _SYS_SYSPROTO_H_
 930 struct mlockall_args {
 931         int     how;
 932 };
 933 #endif
 934
 935 /*
 936  * MPSAFE
 937  */
 938 int
 939 mlockall(td, uap)
 940         struct thread *td;
 941         struct mlockall_args *uap;
 942 {
 943         vm_map_t map;
 944         int error;
 945
 946         map = &td->td_proc->p_vmspace->vm_map;
 947         error = 0;
 948
 949         if ((uap->how == 0) || ((uap->how & ~(MCL_CURRENT|MCL_FUTURE)) != 0))
 950                 return (EINVAL);
 951
 952 #if 0
 953         /*
 954          * If wiring all pages in the process would cause it to exceed
 955          * a hard resource limit, return ENOMEM.
 956          */
 957         PROC_LOCK(td->td_proc);
 958         if (map->size - ptoa(pmap_wired_count(vm_map_pmap(map)) >
 959                 lim_cur(td->td_proc, RLIMIT_MEMLOCK))) {
 960                 PROC_UNLOCK(td->td_proc);
 961                 return (ENOMEM);
 962         }
 963         PROC_UNLOCK(td->td_proc);
 964 #else
 965         error = suser(td);
 966         if (error)
 967                 return (error);
 968 #endif
 969
 970         if (uap->how & MCL_FUTURE) {
 971                 vm_map_lock(map);
 972                 vm_map_modflags(map, MAP_WIREFUTURE, 0);
 973                 vm_map_unlock(map);
 974                 error = 0;
 975         }
 976
 977         if (uap->how & MCL_CURRENT) {
 978                 /*
 979                  * P1003.1-2001 mandates that all currently mapped pages
 980                  * will be memory resident and locked (wired) upon return
 981                  * from mlockall(). vm_map_wire() will wire pages, by
 982                  * calling vm_fault_wire() for each page in the region.
 983                  */
 984                 error = vm_map_wire(map, vm_map_min(map), vm_map_max(map),
 985                     VM_MAP_WIRE_USER|VM_MAP_WIRE_HOLESOK);
 986                 error = (error == KERN_SUCCESS ? 0 : EAGAIN);
 987         }
 988
 989         return (error);
 990 }
 991
 992 #ifndef _SYS_SYSPROTO_H_
 993 struct munlockall_args {
 994         register_t dummy;
 995 };
 996 #endif
 997
 998 /*
 999  * MPSAFE
1000  */
1001 int
1002 munlockall(td, uap)
1003         struct thread *td;
1004         struct munlockall_args *uap;
1005 {
1006         vm_map_t map;
1007         int error;
1008
1009         map = &td->td_proc->p_vmspace->vm_map;
1010         error = suser(td);
1011         if (error)
1012                 return (error);
1013
1014         /* Clear the MAP_WIREFUTURE flag from this vm_map. */
1015         vm_map_lock(map);
1016         vm_map_modflags(map, 0, MAP_WIREFUTURE);
1017         vm_map_unlock(map);
1018
1019         /* Forcibly unwire all pages. */
1020         error = vm_map_unwire(map, vm_map_min(map), vm_map_max(map),
1021             VM_MAP_WIRE_USER|VM_MAP_WIRE_HOLESOK);
1022
1023         return (error);
1024 }
1025
1026 #ifndef _SYS_SYSPROTO_H_
1027 struct munlock_args {
1028         const void *addr;
1029         size_t len;
1030 };
1031 #endif
1032 /*
1033  * MPSAFE
1034  */
1035 int
1036 munlock(td, uap)
1037         struct thread *td;
1038         struct munlock_args *uap;
1039 {
1040         vm_offset_t addr, end, last, start;
1041         vm_size_t size;
1042         int error;
1043
1044         error = suser(td);
1045         if (error)
1046                 return (error);
1047         addr = (vm_offset_t)uap->addr;
1048         size = uap->len;
1049         last = addr + size;
1050         start = trunc_page(addr);
1051         end = round_page(last);
1052         if (last < addr || end < addr)
1053                 return (EINVAL);
1054         error = vm_map_unwire(&td->td_proc->p_vmspace->vm_map, start, end,
1055             VM_MAP_WIRE_USER | VM_MAP_WIRE_NOHOLES);
1056         return (error == KERN_SUCCESS ? 0 : ENOMEM);
1057 }
1058
1059 /*
1060  * vm_mmap_vnode()
1061  *
1062  * MPSAFE
1063  *
1064  * Helper function for vm_mmap.  Perform sanity check specific for mmap
1065  * operations on vnodes.
1066  */
1067 int
1068 vm_mmap_vnode(struct thread *td, vm_size_t objsize,
1069     vm_prot_t prot, vm_prot_t *maxprotp, int *flagsp,
1070     struct vnode *vp, vm_ooffset_t foff, vm_object_t *objp)
1071 {
1072         struct vattr va;
1073         void *handle;
1074         vm_object_t obj;
1075         struct mount *mp;
1076         int error, flags, type;
1077         int vfslocked;
1078
1079         mp = vp->v_mount;
1080         vfslocked = VFS_LOCK_GIANT(mp);
1081         if ((error = vget(vp, LK_EXCLUSIVE, td)) != 0) {
1082                 VFS_UNLOCK_GIANT(vfslocked);
1083                 return (error);
1084         }
1085         flags = *flagsp;
1086         obj = vp->v_object;
1087         if (vp->v_type == VREG) {
1088                 /*
1089                  * Get the proper underlying object
1090                  */
1091                 if (obj == NULL) {
1092                         error = EINVAL;
1093                         goto done;
1094                 }
1095                 if (obj->handle != vp) {
1096                         vput(vp);
1097                         vp = (struct vnode*)obj->handle;
1098                         vget(vp, LK_EXCLUSIVE, td);
1099                 }
1100                 type = OBJT_VNODE;
1101                 handle = vp;
1102         } else if (vp->v_type == VCHR) {
1103                 type = OBJT_DEVICE;
1104                 handle = vp->v_rdev;
1105
1106                 /* XXX: lack thredref on device */
1107                 if(vp->v_rdev->si_devsw->d_flags & D_MMAP_ANON) {
1108                         *maxprotp = VM_PROT_ALL;
1109                         *flagsp |= MAP_ANON;
1110                         error = 0;
1111                         goto done;
1112                 }
1113                 /*
1114                  * cdevs does not provide private mappings of any kind.
1115                  */
1116                 if ((*maxprotp & VM_PROT_WRITE) == 0 &&
1117                     (prot & PROT_WRITE) != 0) {
1118                         error = EACCES;
1119                         goto done;
1120                 }
1121                 if (flags & (MAP_PRIVATE|MAP_COPY)) {
1122                         error = EINVAL;
1123                         goto done;
1124                 }
1125                 /*
1126                  * Force device mappings to be shared.
1127                  */
1128                 flags |= MAP_SHARED;
1129         } else {
1130                 error = EINVAL;
1131                 goto done;
1132         }
1133         if ((error = VOP_GETATTR(vp, &va, td->td_ucred, td))) {
1134                 goto done;
1135         }
1136 #ifdef MAC
1137         error = mac_check_vnode_mmap(td->td_ucred, vp, prot, flags);
1138         if (error != 0)
1139                 goto done;
1140 #endif
1141         if ((flags & MAP_SHARED) != 0) {
1142                 if ((va.va_flags & (SF_SNAPSHOT|IMMUTABLE|APPEND)) != 0) {
1143                         if (prot & PROT_WRITE) {
1144                                 error = EPERM;
1145                                 goto done;
1146                         }
1147                         *maxprotp &= ~VM_PROT_WRITE;
1148                 }
1149         }
1150         /*
1151          * If it is a regular file without any references
1152          * we do not need to sync it.
1153          * Adjust object size to be the size of actual file.
1154          */
1155         if (vp->v_type == VREG) {
1156                 objsize = round_page(va.va_size);
1157                 if (va.va_nlink == 0)
1158                         flags |= MAP_NOSYNC;
1159         }
1160         obj = vm_pager_allocate(type, handle, objsize, prot, foff);
1161         if (obj == NULL) {
1162                 error = (type == OBJT_DEVICE ? EINVAL : ENOMEM);
1163                 goto done;
1164         }
1165         *objp = obj;
1166         *flagsp = flags;
1167 done:
1168         vput(vp);
1169         VFS_UNLOCK_GIANT(vfslocked);
1170         return (error);
1171 }
1172
1173 /*
1174  * vm_mmap_cdev()
1175  *
1176  * MPSAFE
1177  *
1178  * Helper function for vm_mmap.  Perform sanity check specific for mmap
1179  * operations on cdevs.
1180  */
1181 int
1182 vm_mmap_cdev(struct thread *td, vm_size_t objsize,
1183     vm_prot_t prot, vm_prot_t *maxprotp, int *flagsp,
1184     struct cdev *cdev, vm_ooffset_t foff, vm_object_t *objp)
1185 {
1186         vm_object_t obj;
1187         int flags;
1188
1189         flags = *flagsp;
1190
1191         /* XXX: lack thredref on device */
1192         if (cdev->si_devsw->d_flags & D_MMAP_ANON) {
1193                 *maxprotp = VM_PROT_ALL;
1194                 *flagsp |= MAP_ANON;
1195                 return (0);
1196         }
1197         /*
1198          * cdevs does not provide private mappings of any kind.
1199          */
1200         if ((*maxprotp & VM_PROT_WRITE) == 0 &&
1201             (prot & PROT_WRITE) != 0)
1202                 return (EACCES);
1203         if (flags & (MAP_PRIVATE|MAP_COPY))
1204                 return (EINVAL);
1205         /*
1206          * Force device mappings to be shared.
1207          */
1208         flags |= MAP_SHARED;
1209 #ifdef MAC_XXX
1210         error = mac_check_cdev_mmap(td->td_ucred, cdev, prot);
1211         if (error != 0)
1212                 return (error);
1213 #endif
1214         obj = vm_pager_allocate(OBJT_DEVICE, cdev, objsize, prot, foff);
1215         if (obj == NULL)
1216                 return (EINVAL);
1217         *objp = obj;
1218         *flagsp = flags;
1219         return (0);
1220 }
1221
1222 /*
1223  * vm_mmap()
1224  *
1225  * MPSAFE
1226  *
1227  * Internal version of mmap.  Currently used by mmap, exec, and sys5
1228  * shared memory.  Handle is either a vnode pointer or NULL for MAP_ANON.
1229  */
1230 int
1231 vm_mmap(vm_map_t map, vm_offset_t *addr, vm_size_t size, vm_prot_t prot,
1232         vm_prot_t maxprot, int flags,
1233         objtype_t handle_type, void *handle,
1234         vm_ooffset_t foff)
1235 {
1236         boolean_t fitit;
1237         vm_object_t object;
1238         int rv = KERN_SUCCESS;
1239         vm_ooffset_t objsize;
1240         int docow, error;
1241         struct thread *td = curthread;
1242
1243         if (size == 0)
1244                 return (0);
1245
1246         objsize = size = round_page(size);
1247
1248         PROC_LOCK(td->td_proc);
1249         if (td->td_proc->p_vmspace->vm_map.size + size >
1250             lim_cur(td->td_proc, RLIMIT_VMEM)) {
1251                 PROC_UNLOCK(td->td_proc);
1252                 return(ENOMEM);
1253         }
1254         PROC_UNLOCK(td->td_proc);
1255
1256         /*
1257          * We currently can only deal with page aligned file offsets.
1258          * The check is here rather than in the syscall because the
1259          * kernel calls this function internally for other mmaping
1260          * operations (such as in exec) and non-aligned offsets will
1261          * cause pmap inconsistencies...so we want to be sure to
1262          * disallow this in all cases.
1263          */
1264         if (foff & PAGE_MASK)
1265                 return (EINVAL);
1266
1267         if ((flags & MAP_FIXED) == 0) {
1268                 fitit = TRUE;
1269                 *addr = round_page(*addr);
1270         } else {
1271                 if (*addr != trunc_page(*addr))
1272                         return (EINVAL);
1273                 fitit = FALSE;
1274                 (void) vm_map_remove(map, *addr, *addr + size);
1275         }
1276         /*
1277          * Lookup/allocate object.
1278          */
1279         switch (handle_type) {
1280         case OBJT_DEVICE:
1281                 error = vm_mmap_cdev(td, size, prot, &maxprot, &flags,
1282                     handle, foff, &object);
1283                 break;
1284         case OBJT_VNODE:
1285                 error = vm_mmap_vnode(td, size, prot, &maxprot, &flags,
1286                     handle, foff, &object);
1287                 break;
1288         case OBJT_DEFAULT:
1289                 if (handle == NULL) {
1290                         error = 0;
1291                         break;
1292                 }
1293                 /* FALLTHROUGH */
1294         default:
1295                 error = EINVAL;
1296         }
1297         if (error)
1298                 return (error);
1299         if (flags & MAP_ANON) {
1300                 object = NULL;
1301                 docow = 0;
1302                 /*
1303                  * Unnamed anonymous regions always start at 0.
1304                  */
1305                 if (handle == 0)
1306                         foff = 0;
1307         } else {
1308                 docow = MAP_PREFAULT_PARTIAL;
1309         }
1310
1311         if ((flags & (MAP_ANON|MAP_SHARED)) == 0)
1312                 docow |= MAP_COPY_ON_WRITE;
1313         if (flags & MAP_NOSYNC)
1314                 docow |= MAP_DISABLE_SYNCER;
1315         if (flags & MAP_NOCORE)
1316                 docow |= MAP_DISABLE_COREDUMP;
1317
1318 #if defined(VM_PROT_READ_IS_EXEC)
1319         if (prot & VM_PROT_READ)
1320                 prot |= VM_PROT_EXECUTE;
1321
1322         if (maxprot & VM_PROT_READ)
1323                 maxprot |= VM_PROT_EXECUTE;
1324 #endif
1325
1326         if (fitit)
1327                 *addr = pmap_addr_hint(object, *addr, size);
1328
1329         if (flags & MAP_STACK)
1330                 rv = vm_map_stack(map, *addr, size, prot, maxprot,
1331                     docow | MAP_STACK_GROWS_DOWN);
1332         else
1333                 rv = vm_map_find(map, object, foff, addr, size, fitit,
1334                                  prot, maxprot, docow);
1335
1336         if (rv != KERN_SUCCESS) {
1337                 /*
1338                  * Lose the object reference. Will destroy the
1339                  * object if it's an unnamed anonymous mapping
1340                  * or named anonymous without other references.
1341                  */
1342                 vm_object_deallocate(object);
1343         } else if (flags & MAP_SHARED) {
1344                 /*
1345                  * Shared memory is also shared with children.
1346                  */
1347                 rv = vm_map_inherit(map, *addr, *addr + size, VM_INHERIT_SHARE);
1348                 if (rv != KERN_SUCCESS)
1349                         (void) vm_map_remove(map, *addr, *addr + size);
1350         }
1351
1352         /*
1353          * If the process has requested that all future mappings
1354          * be wired, then heed this.
1355          */
1356         if ((rv == KERN_SUCCESS) && (map->flags & MAP_WIREFUTURE))
1357                 vm_map_wire(map, *addr, *addr + size,
1358                     VM_MAP_WIRE_USER|VM_MAP_WIRE_NOHOLES);
1359
1360         switch (rv) {
1361         case KERN_SUCCESS:
1362                 return (0);
1363         case KERN_INVALID_ADDRESS:
1364         case KERN_NO_SPACE:
1365                 return (ENOMEM);
1366         case KERN_PROTECTION_FAILURE:
1367                 return (EACCES);
1368         default:
1369                 return (EINVAL);
1370         }
1371 }