projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
BSD 4_4 release
[unix-history] / usr / src / sys / vm / vm_mmap.c
diff --git a/usr/src/sys/vm/vm_mmap.c b/usr/src/sys/vm/vm_mmap.c
index bc47558..060aeb1 100644 (file)
--- a/usr/src/sys/vm/vm_mmap.c
+++ b/usr/src/sys/vm/vm_mmap.c
@@ -1,38 +1,64 @@
 /*
  * Copyright (c) 1988 University of Utah.
 /*
  * Copyright (c) 1988 University of Utah.
- * Copyright (c) 1991 The Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
  *
  * This code is derived from software contributed to Berkeley by
  * the Systems Programming Group of the University of Utah Computer
  * Science Department.
  *
  *
  * This code is derived from software contributed to Berkeley by
  * the Systems Programming Group of the University of Utah Computer
  * Science Department.
  *
- * %sccs.include.redist.c%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
  *
  *
- * from: Utah $Hdr: vm_mmap.c 1.3 90/01/21$
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
  *
  *
- *     @(#)vm_mmap.c   7.2 (Berkeley) %G%
+ * from: Utah $Hdr: vm_mmap.c 1.6 91/10/21$
+ *
+ *     @(#)vm_mmap.c   8.1 (Berkeley) 6/18/93
  */
 
 /*
  * Mapped file (mmap) interface to VM
  */
 
  */
 
 /*
  * Mapped file (mmap) interface to VM
  */
 
-#include "param.h"
-#include "systm.h"
-#include "user.h"
-#include "filedesc.h"
-#include "proc.h"
-#include "vnode.h"
-#include "specdev.h"
-#include "file.h"
-#include "mman.h"
-#include "conf.h"
-
-#include "../vm/vm_param.h"
-#include "../vm/vm_map.h"
-#include "../vm/vm_pager.h"
-#include "../vm/vm_prot.h"
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/filedesc.h>
+#include <sys/resourcevar.h>
+#include <sys/proc.h>
+#include <sys/vnode.h>
+#include <sys/file.h>
+#include <sys/mman.h>
+#include <sys/conf.h>
+
+#include <miscfs/specfs/specdev.h>
+
+#include <vm/vm.h>
+#include <vm/vm_pager.h>
+#include <vm/vm_prot.h>
 
 #ifdef DEBUG
 int mmapdebug = 0;
 
 #ifdef DEBUG
 int mmapdebug = 0;
@@ -41,23 +67,29 @@ int mmapdebug = 0;
 #define MDB_MAPIT      0x04
 #endif
 
 #define MDB_MAPIT      0x04
 #endif
 
+struct sbrk_args {
+       int     incr;
+};
 /* ARGSUSED */
 /* ARGSUSED */
-getpagesize(p, uap, retval)
+int
+sbrk(p, uap, retval)
        struct proc *p;
        struct proc *p;
-       struct args *uap;
+       struct sbrk_args *uap;
        int *retval;
 {
 
        int *retval;
 {
 
-       *retval = NBPG * CLSIZE;
-       return (0);
+       /* Not yet implemented */
+       return (EOPNOTSUPP);
 }
 
 }
 
+struct sstk_args {
+       int     incr;
+};
 /* ARGSUSED */
 /* ARGSUSED */
-sbrk(p, uap, retval)
+int
+sstk(p, uap, retval)
        struct proc *p;
        struct proc *p;
-       struct args {
-               int     incr;
-       } *uap;
+       struct sstk_args *uap;
        int *retval;
 {
 
        int *retval;
 {
 
@@ -65,29 +97,91 @@ sbrk(p, uap, retval)
        return (EOPNOTSUPP);
 }
 
        return (EOPNOTSUPP);
 }
 
+#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
+struct getpagesize_args {
+       int     dummy;
+};
 /* ARGSUSED */
 /* ARGSUSED */
-sstk(p, uap, retval)
+int
+ogetpagesize(p, uap, retval)
        struct proc *p;
        struct proc *p;
-       struct args {
-               int     incr;
-       } *uap;
+       struct getpagesize_args *uap;
        int *retval;
 {
 
        int *retval;
 {
 
-       /* Not yet implemented */
-       return (EOPNOTSUPP);
+       *retval = PAGE_SIZE;
+       return (0);
+}
+#endif /* COMPAT_43 || COMPAT_SUNOS */
+
+struct mmap_args {
+       caddr_t addr;
+       size_t  len;
+       int     prot;
+       int     flags;
+       int     fd;
+       long    pad;
+       off_t   pos;
+};
+
+#ifdef COMPAT_43
+struct ommap_args {
+       caddr_t addr;
+       int     len;
+       int     prot;
+       int     flags;
+       int     fd;
+       long    pos;
+};
+int
+ommap(p, uap, retval)
+       struct proc *p;
+       register struct ommap_args *uap;
+       int *retval;
+{
+       struct mmap_args nargs;
+       static const char cvtbsdprot[8] = {
+               0,
+               PROT_EXEC,
+               PROT_WRITE,
+               PROT_EXEC|PROT_WRITE,
+               PROT_READ,
+               PROT_EXEC|PROT_READ,
+               PROT_WRITE|PROT_READ,
+               PROT_EXEC|PROT_WRITE|PROT_READ,
+       };
+#define        OMAP_ANON       0x0002
+#define        OMAP_COPY       0x0020
+#define        OMAP_SHARED     0x0010
+#define        OMAP_FIXED      0x0100
+#define        OMAP_INHERIT    0x0800
+
+       nargs.addr = uap->addr;
+       nargs.len = uap->len;
+       nargs.prot = cvtbsdprot[uap->prot&0x7];
+       nargs.flags = 0;
+       if (uap->flags & OMAP_ANON)
+               nargs.flags |= MAP_ANON;
+       if (uap->flags & OMAP_COPY)
+               nargs.flags |= MAP_COPY;
+       if (uap->flags & OMAP_SHARED)
+               nargs.flags |= MAP_SHARED;
+       else
+               nargs.flags |= MAP_PRIVATE;
+       if (uap->flags & OMAP_FIXED)
+               nargs.flags |= MAP_FIXED;
+       if (uap->flags & OMAP_INHERIT)
+               nargs.flags |= MAP_INHERIT;
+       nargs.fd = uap->fd;
+       nargs.pos = uap->pos;
+       return (mmap(p, &nargs, retval));
 }
 }
+#endif
 
 
-smmap(p, uap, retval)
+int
+mmap(p, uap, retval)
        struct proc *p;
        struct proc *p;
-       register struct args {
-               caddr_t addr;
-               int     len;
-               int     prot;
-               int     flags;
-               int     fd;
-               off_t   pos;
-       } *uap;
+       register struct mmap_args *uap;
        int *retval;
 {
        register struct filedesc *fdp = p->p_fd;
        int *retval;
 {
        register struct filedesc *fdp = p->p_fd;
@@ -95,94 +189,104 @@ smmap(p, uap, retval)
        struct vnode *vp;
        vm_offset_t addr;
        vm_size_t size;
        struct vnode *vp;
        vm_offset_t addr;
        vm_size_t size;
-       vm_prot_t prot;
+       vm_prot_t prot, maxprot;
        caddr_t handle;
        caddr_t handle;
-       int mtype, error;
+       int flags, error;
 
 
+       prot = uap->prot & VM_PROT_ALL;
+       flags = uap->flags;
 #ifdef DEBUG
        if (mmapdebug & MDB_FOLLOW)
                printf("mmap(%d): addr %x len %x pro %x flg %x fd %d pos %x\n",
 #ifdef DEBUG
        if (mmapdebug & MDB_FOLLOW)
                printf("mmap(%d): addr %x len %x pro %x flg %x fd %d pos %x\n",
-                      p->p_pid, uap->addr, uap->len, uap->prot,
-                      uap->flags, uap->fd, uap->pos);
+                      p->p_pid, uap->addr, uap->len, prot,
+                      flags, uap->fd, (vm_offset_t)uap->pos);
 #endif
        /*
 #endif
        /*
-        * Make sure one of the sharing types is specified
-        */
-       mtype = uap->flags & MAP_TYPE;
-       switch (mtype) {
-       case MAP_FILE:
-       case MAP_ANON:
-               break;
-       default:
-               return(EINVAL);
-       }
-       /*
-        * Address (if FIXED) and size must be page aligned
+        * Address (if FIXED) must be page aligned.
+        * Size is implicitly rounded to a page boundary.
         */
         */
-       size = (vm_size_t)uap->len;
-       addr = (vm_offset_t)uap->addr;
-       if ((size & page_mask) ||
-           (uap->flags & MAP_FIXED) && (addr & page_mask))
-               return(EINVAL);
+       addr = (vm_offset_t) uap->addr;
+       if (((flags & MAP_FIXED) && (addr & PAGE_MASK)) ||
+           (ssize_t)uap->len < 0 || ((flags & MAP_ANON) && uap->fd != -1))
+               return (EINVAL);
+       size = (vm_size_t) round_page(uap->len);
        /*
        /*
-        * Mapping file or named anonymous, get fp for validation
+        * Check for illegal addresses.  Watch out for address wrap...
+        * Note that VM_*_ADDRESS are not constants due to casts (argh).
         */
         */
-       if (mtype == MAP_FILE || uap->fd != -1) {
-               if (((unsigned)uap->fd) >= fdp->fd_maxfiles ||
-                   (fp = OFILE(fdp, uap->fd)) == NULL)
-                       return(EBADF);
+       if (flags & MAP_FIXED) {
+               if (VM_MAXUSER_ADDRESS > 0 && addr + size >= VM_MAXUSER_ADDRESS)
+                       return (EINVAL);
+               if (VM_MIN_ADDRESS > 0 && addr < VM_MIN_ADDRESS)
+                       return (EINVAL);
+               if (addr > addr + size)
+                       return (EINVAL);
        }
        /*
        }
        /*
-        * If we are mapping a file we need to check various
-        * file/vnode related things.
+        * XXX if no hint provided for a non-fixed mapping place it after
+        * the end of the largest possible heap.
+        *
+        * There should really be a pmap call to determine a reasonable
+        * location.
         */
         */
-       if (mtype == MAP_FILE) {
+       if (addr == 0 && (flags & MAP_FIXED) == 0)
+               addr = round_page(p->p_vmspace->vm_daddr + MAXDSIZ);
+       if (flags & MAP_ANON) {
                /*
                /*
-                * Obtain vnode and make sure it is of appropriate type
+                * Mapping blank space is trivial.
                 */
                 */
+               handle = NULL;
+               maxprot = VM_PROT_ALL;
+       } else {
+               /*
+                * Mapping file, get fp for validation.
+                * Obtain vnode and make sure it is of appropriate type.
+                */
+               if (((unsigned)uap->fd) >= fdp->fd_nfiles ||
+                   (fp = fdp->fd_ofiles[uap->fd]) == NULL)
+                       return (EBADF);
                if (fp->f_type != DTYPE_VNODE)
                if (fp->f_type != DTYPE_VNODE)
-                       return(EINVAL);
+                       return (EINVAL);
                vp = (struct vnode *)fp->f_data;
                if (vp->v_type != VREG && vp->v_type != VCHR)
                vp = (struct vnode *)fp->f_data;
                if (vp->v_type != VREG && vp->v_type != VCHR)
-                       return(EINVAL);
+                       return (EINVAL);
                /*
                /*
-                * Ensure that file protection and desired protection
-                * are compatible.  Note that we only worry about writability
-                * if mapping is shared.
+                * Ensure that file and memory protections are compatible.
+                * Note that we only worry about writability if mapping is
+                * shared; in this case, current and max prot are dictated
+                * by the open file.
+                * XXX use the vnode instead?  Problem is: what credentials
+                * do we use for determination?  What if proc does a setuid?
                 */
                 */
-               if ((uap->prot & PROT_READ) && (fp->f_flag & FREAD) == 0 ||
-                   ((uap->flags & MAP_SHARED) &&
-                    (uap->prot & PROT_WRITE) && (fp->f_flag & FWRITE) == 0))
-                       return(EACCES);
+               maxprot = VM_PROT_EXECUTE;      /* ??? */
+               if (fp->f_flag & FREAD)
+                       maxprot |= VM_PROT_READ;
+               else if (prot & PROT_READ)
+                       return (EACCES);
+               if (flags & MAP_SHARED) {
+                       if (fp->f_flag & FWRITE)
+                               maxprot |= VM_PROT_WRITE;
+                       else if (prot & PROT_WRITE)
+                               return (EACCES);
+               } else
+                       maxprot |= VM_PROT_WRITE;
                handle = (caddr_t)vp;
                handle = (caddr_t)vp;
-       } else if (uap->fd != -1)
-               handle = (caddr_t)fp;
-       else
-               handle = NULL;
-       /*
-        * Map protections to MACH style
-        */
-       prot = VM_PROT_NONE;
-       if (uap->prot & PROT_READ)
-               prot |= VM_PROT_READ;
-       if (uap->prot & PROT_WRITE)
-               prot |= VM_PROT_WRITE;
-       if (uap->prot & PROT_EXEC)
-               prot |= VM_PROT_EXECUTE;
-
-       error = vm_mmap(p->p_map, &addr, size, prot,
-                       uap->flags, handle, (vm_offset_t)uap->pos);
+       }
+       error = vm_mmap(&p->p_vmspace->vm_map, &addr, size, prot, maxprot,
+           flags, handle, (vm_offset_t)uap->pos);
        if (error == 0)
        if (error == 0)
-               *retval = (int) addr;
-       return(error);
+               *retval = (int)addr;
+       return (error);
 }
 
 }
 
+struct msync_args {
+       caddr_t addr;
+       int     len;
+};
+int
 msync(p, uap, retval)
        struct proc *p;
 msync(p, uap, retval)
        struct proc *p;
-       struct args {
-               char    *addr;
-               int     len;
-       } *uap;
+       struct msync_args *uap;
        int *retval;
 {
        vm_offset_t addr, objoff, oaddr;
        int *retval;
 {
        vm_offset_t addr, objoff, oaddr;
@@ -198,20 +302,21 @@ msync(p, uap, retval)
                printf("msync(%d): addr %x len %x\n",
                       p->p_pid, uap->addr, uap->len);
 #endif
                printf("msync(%d): addr %x len %x\n",
                       p->p_pid, uap->addr, uap->len);
 #endif
-       if (((int)uap->addr & page_mask) || (uap->len & page_mask))
+       if (((int)uap->addr & PAGE_MASK) || uap->len < 0)
                return(EINVAL);
        addr = oaddr = (vm_offset_t)uap->addr;
        osize = (vm_size_t)uap->len;
        /*
         * Region must be entirely contained in a single entry
         */
                return(EINVAL);
        addr = oaddr = (vm_offset_t)uap->addr;
        osize = (vm_size_t)uap->len;
        /*
         * Region must be entirely contained in a single entry
         */
-       if (!vm_map_is_allocated(p->p_map, addr, addr+osize, TRUE))
+       if (!vm_map_is_allocated(&p->p_vmspace->vm_map, addr, addr+osize,
+           TRUE))
                return(EINVAL);
        /*
         * Determine the object associated with that entry
         * (object is returned locked on KERN_SUCCESS)
         */
                return(EINVAL);
        /*
         * Determine the object associated with that entry
         * (object is returned locked on KERN_SUCCESS)
         */
-       rv = vm_region(p->p_map, &addr, &size, &prot, &mprot,
+       rv = vm_region(&p->p_vmspace->vm_map, &addr, &size, &prot, &mprot,
                       &inherit, &shared, &object, &objoff);
        if (rv != KERN_SUCCESS)
                return(EINVAL);
                       &inherit, &shared, &object, &objoff);
        if (rv != KERN_SUCCESS)
                return(EINVAL);
@@ -223,7 +328,7 @@ msync(p, uap, retval)
        /*
         * Do not msync non-vnoded backed objects.
         */
        /*
         * Do not msync non-vnoded backed objects.
         */
-       if (object->internal || object->pager == vm_pager_null ||
+       if ((object->flags & OBJ_INTERNAL) || object->pager == NULL ||
            object->pager->pg_type != PG_VNODE) {
                vm_object_unlock(object);
                return(EINVAL);
            object->pager->pg_type != PG_VNODE) {
                vm_object_unlock(object);
                return(EINVAL);
@@ -237,7 +342,7 @@ msync(p, uap, retval)
                       objoff, objoff+osize);
 #endif
        if (prot & VM_PROT_WRITE)
                       objoff, objoff+osize);
 #endif
        if (prot & VM_PROT_WRITE)
-               vm_object_page_clean(object, objoff, objoff+osize);
+               vm_object_page_clean(object, objoff, objoff+osize, FALSE);
        /*
         * (XXX)
         * Bummer, gotta flush all cached pages to ensure
        /*
         * (XXX)
         * Bummer, gotta flush all cached pages to ensure
@@ -248,12 +353,14 @@ msync(p, uap, retval)
        return(0);
 }
 
        return(0);
 }
 
+struct munmap_args {
+       caddr_t addr;
+       int     len;
+};
+int
 munmap(p, uap, retval)
        register struct proc *p;
 munmap(p, uap, retval)
        register struct proc *p;
-       register struct args {
-               caddr_t addr;
-               int     len;
-       } *uap;
+       register struct munmap_args *uap;
        int *retval;
 {
        vm_offset_t addr;
        int *retval;
 {
        vm_offset_t addr;
@@ -266,38 +373,53 @@ munmap(p, uap, retval)
 #endif
 
        addr = (vm_offset_t) uap->addr;
 #endif
 
        addr = (vm_offset_t) uap->addr;
-       size = (vm_size_t) uap->len;
-       if ((addr & page_mask) || (size & page_mask))
+       if ((addr & PAGE_MASK) || uap->len < 0)
                return(EINVAL);
                return(EINVAL);
+       size = (vm_size_t) round_page(uap->len);
        if (size == 0)
                return(0);
        if (size == 0)
                return(0);
-       if (!vm_map_is_allocated(p->p_map, addr, addr+size, FALSE))
+       /*
+        * Check for illegal addresses.  Watch out for address wrap...
+        * Note that VM_*_ADDRESS are not constants due to casts (argh).
+        */
+       if (VM_MAXUSER_ADDRESS > 0 && addr + size >= VM_MAXUSER_ADDRESS)
+               return (EINVAL);
+       if (VM_MIN_ADDRESS > 0 && addr < VM_MIN_ADDRESS)
+               return (EINVAL);
+       if (addr > addr + size)
+               return (EINVAL);
+       if (!vm_map_is_allocated(&p->p_vmspace->vm_map, addr, addr + size,
+           FALSE))
                return(EINVAL);
        /* returns nothing but KERN_SUCCESS anyway */
                return(EINVAL);
        /* returns nothing but KERN_SUCCESS anyway */
-       (void) vm_map_remove(p->p_map, addr, addr+size);
+       (void) vm_map_remove(&p->p_vmspace->vm_map, addr, addr+size);
        return(0);
 }
 
        return(0);
 }
 
+void
 munmapfd(fd)
 munmapfd(fd)
+       int fd;
 {
 #ifdef DEBUG
        if (mmapdebug & MDB_FOLLOW)
 {
 #ifdef DEBUG
        if (mmapdebug & MDB_FOLLOW)
-               printf("munmapfd(%d): fd %d\n", u.u_procp->p_pid, fd);
+               printf("munmapfd(%d): fd %d\n", curproc->p_pid, fd);
 #endif
 
        /*
         * XXX -- should vm_deallocate any regions mapped to this file
         */
 #endif
 
        /*
         * XXX -- should vm_deallocate any regions mapped to this file
         */
-       OFILEFLAGS(u.u_procp->p_fd, fd) &= ~UF_MAPPED;
+       curproc->p_fd->fd_ofileflags[fd] &= ~UF_MAPPED;
 }
 
 }
 
+struct mprotect_args {
+       caddr_t addr;
+       int     len;
+       int     prot;
+};
+int
 mprotect(p, uap, retval)
        struct proc *p;
 mprotect(p, uap, retval)
        struct proc *p;
-       struct args {
-               char    *addr;
-               int     len;
-               int     prot;
-       } *uap;
+       struct mprotect_args *uap;
        int *retval;
 {
        vm_offset_t addr;
        int *retval;
 {
        vm_offset_t addr;
@@ -310,22 +432,14 @@ mprotect(p, uap, retval)
                       p->p_pid, uap->addr, uap->len, uap->prot);
 #endif
 
                       p->p_pid, uap->addr, uap->len, uap->prot);
 #endif
 
-       addr = (vm_offset_t) uap->addr;
-       size = (vm_size_t) uap->len;
-       if ((addr & page_mask) || (size & page_mask))
+       addr = (vm_offset_t)uap->addr;
+       if ((addr & PAGE_MASK) || uap->len < 0)
                return(EINVAL);
                return(EINVAL);
-       /*
-        * Map protections
-        */
-       prot = VM_PROT_NONE;
-       if (uap->prot & PROT_READ)
-               prot |= VM_PROT_READ;
-       if (uap->prot & PROT_WRITE)
-               prot |= VM_PROT_WRITE;
-       if (uap->prot & PROT_EXEC)
-               prot |= VM_PROT_EXECUTE;
-
-       switch (vm_map_protect(p->p_map, addr, addr+size, prot, FALSE)) {
+       size = (vm_size_t)uap->len;
+       prot = uap->prot & VM_PROT_ALL;
+
+       switch (vm_map_protect(&p->p_vmspace->vm_map, addr, addr+size, prot,
+           FALSE)) {
        case KERN_SUCCESS:
                return (0);
        case KERN_PROTECTION_FAILURE:
        case KERN_SUCCESS:
                return (0);
        case KERN_PROTECTION_FAILURE:
@@ -334,14 +448,16 @@ mprotect(p, uap, retval)
        return (EINVAL);
 }
 
        return (EINVAL);
 }
 
+struct madvise_args {
+       caddr_t addr;
+       int     len;
+       int     behav;
+};
 /* ARGSUSED */
 /* ARGSUSED */
+int
 madvise(p, uap, retval)
        struct proc *p;
 madvise(p, uap, retval)
        struct proc *p;
-       struct args {
-               char    *addr;
-               int     len;
-               int     behav;
-       } *uap;
+       struct madvise_args *uap;
        int *retval;
 {
 
        int *retval;
 {
 
@@ -349,14 +465,16 @@ madvise(p, uap, retval)
        return (EOPNOTSUPP);
 }
 
        return (EOPNOTSUPP);
 }
 
+struct mincore_args {
+       caddr_t addr;
+       int     len;
+       char    *vec;
+};
 /* ARGSUSED */
 /* ARGSUSED */
+int
 mincore(p, uap, retval)
        struct proc *p;
 mincore(p, uap, retval)
        struct proc *p;
-       struct args {
-               char    *addr;
-               int     len;
-               char    *vec;
-       } *uap;
+       struct mincore_args *uap;
        int *retval;
 {
 
        int *retval;
 {
 
@@ -364,18 +482,88 @@ mincore(p, uap, retval)
        return (EOPNOTSUPP);
 }
 
        return (EOPNOTSUPP);
 }
 
+struct mlock_args {
+       caddr_t addr;
+       size_t  len;
+};
+int
+mlock(p, uap, retval)
+       struct proc *p;
+       struct mlock_args *uap;
+       int *retval;
+{
+       vm_offset_t addr;
+       vm_size_t size;
+       int error;
+       extern int vm_page_max_wired;
+
+#ifdef DEBUG
+       if (mmapdebug & MDB_FOLLOW)
+               printf("mlock(%d): addr %x len %x\n",
+                      p->p_pid, uap->addr, uap->len);
+#endif
+       addr = (vm_offset_t)uap->addr;
+       if ((addr & PAGE_MASK) || uap->addr + uap->len < uap->addr)
+               return (EINVAL);
+       size = round_page((vm_size_t)uap->len);
+       if (atop(size) + cnt.v_wire_count > vm_page_max_wired)
+               return (EAGAIN);
+#ifdef pmap_wired_count
+       if (size + ptoa(pmap_wired_count(vm_map_pmap(&p->p_vmspace->vm_map))) >
+           p->p_rlimit[RLIMIT_MEMLOCK].rlim_cur)
+               return (EAGAIN);
+#else
+       if (error = suser(p->p_ucred, &p->p_acflag))
+               return (error);
+#endif
+
+       error = vm_map_pageable(&p->p_vmspace->vm_map, addr, addr+size, FALSE);
+       return (error == KERN_SUCCESS ? 0 : ENOMEM);
+}
+
+struct munlock_args {
+       caddr_t addr;
+       size_t  len;
+};
+int
+munlock(p, uap, retval)
+       struct proc *p;
+       struct munlock_args *uap;
+       int *retval;
+{
+       vm_offset_t addr;
+       vm_size_t size;
+       int error;
+
+#ifdef DEBUG
+       if (mmapdebug & MDB_FOLLOW)
+               printf("munlock(%d): addr %x len %x\n",
+                      p->p_pid, uap->addr, uap->len);
+#endif
+       addr = (vm_offset_t)uap->addr;
+       if ((addr & PAGE_MASK) || uap->addr + uap->len < uap->addr)
+               return (EINVAL);
+#ifndef pmap_wired_count
+       if (error = suser(p->p_ucred, &p->p_acflag))
+               return (error);
+#endif
+       size = round_page((vm_size_t)uap->len);
+
+       error = vm_map_pageable(&p->p_vmspace->vm_map, addr, addr+size, TRUE);
+       return (error == KERN_SUCCESS ? 0 : ENOMEM);
+}
+
 /*
  * Internal version of mmap.
  * Currently used by mmap, exec, and sys5 shared memory.
 /*
  * Internal version of mmap.
  * Currently used by mmap, exec, and sys5 shared memory.
- * Handle is:
- *     MAP_FILE: a vnode pointer
- *     MAP_ANON: NULL or a file pointer
+ * Handle is either a vnode pointer or NULL for MAP_ANON.
  */
  */
-vm_mmap(map, addr, size, prot, flags, handle, foff)
+int
+vm_mmap(map, addr, size, prot, maxprot, flags, handle, foff)
        register vm_map_t map;
        register vm_offset_t *addr;
        register vm_size_t size;
        register vm_map_t map;
        register vm_offset_t *addr;
        register vm_size_t size;
-       vm_prot_t prot;
+       vm_prot_t prot, maxprot;
        register int flags;
        caddr_t handle;         /* XXX should be vp */
        vm_offset_t foff;
        register int flags;
        caddr_t handle;         /* XXX should be vp */
        vm_offset_t foff;
@@ -383,7 +571,7 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
        register vm_pager_t pager;
        boolean_t fitit;
        vm_object_t object;
        register vm_pager_t pager;
        boolean_t fitit;
        vm_object_t object;
-       struct vnode *vp;
+       struct vnode *vp = NULL;
        int type;
        int rv = KERN_SUCCESS;
 
        int type;
        int rv = KERN_SUCCESS;
 
@@ -395,7 +583,7 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
                *addr = round_page(*addr);
        } else {
                fitit = FALSE;
                *addr = round_page(*addr);
        } else {
                fitit = FALSE;
-               (void) vm_deallocate(map, *addr, size);
+               (void)vm_deallocate(map, *addr, size);
        }
 
        /*
        }
 
        /*
@@ -403,7 +591,7 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
         * gain a reference to ensure continued existance of the object.
         * (XXX the exception is to appease the pageout daemon)
         */
         * gain a reference to ensure continued existance of the object.
         * (XXX the exception is to appease the pageout daemon)
         */
-       if ((flags & MAP_TYPE) == MAP_ANON)
+       if (flags & MAP_ANON)
                type = PG_DFLT;
        else {
                vp = (struct vnode *)handle;
                type = PG_DFLT;
        else {
                vp = (struct vnode *)handle;
@@ -414,7 +602,7 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
                        type = PG_VNODE;
        }
        pager = vm_pager_allocate(type, handle, size, prot);
                        type = PG_VNODE;
        }
        pager = vm_pager_allocate(type, handle, size, prot);
-       if (pager == VM_PAGER_NULL)
+       if (pager == NULL)
                return (type == PG_DEVICE ? EINVAL : ENOMEM);
        /*
         * Find object and release extra reference gained by lookup
                return (type == PG_DEVICE ? EINVAL : ENOMEM);
        /*
         * Find object and release extra reference gained by lookup
@@ -425,9 +613,9 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
        /*
         * Anonymous memory.
         */
        /*
         * Anonymous memory.
         */
-       if ((flags & MAP_TYPE) == MAP_ANON) {
+       if (flags & MAP_ANON) {
                rv = vm_allocate_with_pager(map, addr, size, fitit,
                rv = vm_allocate_with_pager(map, addr, size, fitit,
-                                           pager, (vm_offset_t)foff, TRUE);
+                                           pager, foff, TRUE);
                if (rv != KERN_SUCCESS) {
                        if (handle == NULL)
                                vm_pager_deallocate(pager);
                if (rv != KERN_SUCCESS) {
                        if (handle == NULL)
                                vm_pager_deallocate(pager);
@@ -438,21 +626,24 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
                /*
                 * Don't cache anonymous objects.
                 * Loses the reference gained by vm_pager_allocate.
                /*
                 * Don't cache anonymous objects.
                 * Loses the reference gained by vm_pager_allocate.
+                * Note that object will be NULL when handle == NULL,
+                * this is ok since vm_allocate_with_pager has made
+                * sure that these objects are uncached.
                 */
                (void) pager_cache(object, FALSE);
 #ifdef DEBUG
                if (mmapdebug & MDB_MAPIT)
                        printf("vm_mmap(%d): ANON *addr %x size %x pager %x\n",
                 */
                (void) pager_cache(object, FALSE);
 #ifdef DEBUG
                if (mmapdebug & MDB_MAPIT)
                        printf("vm_mmap(%d): ANON *addr %x size %x pager %x\n",
-                              u.u_procp->p_pid, *addr, size, pager);
+                              curproc->p_pid, *addr, size, pager);
 #endif
        }
        /*
 #endif
        }
        /*
-        * Must be type MAP_FILE.
+        * Must be a mapped file.
         * Distinguish between character special and regular files.
         */
        else if (vp->v_type == VCHR) {
                rv = vm_allocate_with_pager(map, addr, size, fitit,
         * Distinguish between character special and regular files.
         */
        else if (vp->v_type == VCHR) {
                rv = vm_allocate_with_pager(map, addr, size, fitit,
-                                           pager, (vm_offset_t)foff, FALSE);
+                                           pager, foff, FALSE);
                /*
                 * Uncache the object and lose the reference gained
                 * by vm_pager_allocate().  If the call to
                /*
                 * Uncache the object and lose the reference gained
                 * by vm_pager_allocate().  If the call to
@@ -471,7 +662,7 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
         */
        else {
 #ifdef DEBUG
         */
        else {
 #ifdef DEBUG
-               if (object == VM_OBJECT_NULL)
+               if (object == NULL)
                        printf("vm_mmap: no object: vp %x, pager %x\n",
                               vp, pager);
 #endif
                        printf("vm_mmap: no object: vp %x, pager %x\n",
                               vp, pager);
 #endif
@@ -482,7 +673,7 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
                if (flags & MAP_SHARED) {
                        rv = vm_allocate_with_pager(map, addr, size,
                                                    fitit, pager,
                if (flags & MAP_SHARED) {
                        rv = vm_allocate_with_pager(map, addr, size,
                                                    fitit, pager,
-                                                   (vm_offset_t)foff, FALSE);
+                                                   foff, FALSE);
                        if (rv != KERN_SUCCESS) {
                                vm_object_deallocate(object);
                                goto out;
                        if (rv != KERN_SUCCESS) {
                                vm_object_deallocate(object);
                                goto out;
@@ -510,7 +701,7 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
                        vm_offset_t off;
 
                        /* locate and allocate the target address space */
                        vm_offset_t off;
 
                        /* locate and allocate the target address space */
-                       rv = vm_map_find(map, VM_OBJECT_NULL, (vm_offset_t)0,
+                       rv = vm_map_find(map, NULL, (vm_offset_t)0,
                                         addr, size, fitit);
                        if (rv != KERN_SUCCESS) {
                                vm_object_deallocate(object);
                                         addr, size, fitit);
                        if (rv != KERN_SUCCESS) {
                                vm_object_deallocate(object);
@@ -521,7 +712,7 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
                        off = VM_MIN_ADDRESS;
                        rv = vm_allocate_with_pager(tmap, &off, size,
                                                    TRUE, pager,
                        off = VM_MIN_ADDRESS;
                        rv = vm_allocate_with_pager(tmap, &off, size,
                                                    TRUE, pager,
-                                                   (vm_offset_t)foff, FALSE);
+                                                   foff, FALSE);
                        if (rv != KERN_SUCCESS) {
                                vm_object_deallocate(object);
                                vm_map_deallocate(tmap);
                        if (rv != KERN_SUCCESS) {
                                vm_object_deallocate(object);
                                vm_map_deallocate(tmap);
@@ -538,10 +729,10 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
                         * internal temporarily.
                         */
                        if ((flags & MAP_COPY) == 0)
                         * internal temporarily.
                         */
                        if ((flags & MAP_COPY) == 0)
-                               object->internal = TRUE;
+                               object->flags |= OBJ_INTERNAL;
                        rv = vm_map_copy(map, tmap, *addr, size, off,
                                         FALSE, FALSE);
                        rv = vm_map_copy(map, tmap, *addr, size, off,
                                         FALSE, FALSE);
-                       object->internal = FALSE;
+                       object->flags &= ~OBJ_INTERNAL;
                        /*
                         * (XXX)
                         * My oh my, this only gets worse...
                        /*
                         * (XXX)
                         * My oh my, this only gets worse...
@@ -566,13 +757,9 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
                         * (XXX)
                         * Map copy code cannot detect sharing unless a
                         * sharing map is involved.  So we cheat and write
                         * (XXX)
                         * Map copy code cannot detect sharing unless a
                         * sharing map is involved.  So we cheat and write
-                        * protect everything ourselves.  Note we cannot
-                        * use vm_object_pmap_copy() because that relies
-                        * on the page copy_on_write bit which isn't
-                        * always accurate with shared objects.
+                        * protect everything ourselves.
                         */
                         */
-                       vm_object_pmap_force_copy(object, (vm_offset_t)foff,
-                                           (vm_offset_t)foff+size);
+                       vm_object_pmap_copy(object, foff, foff + size);
                        vm_object_deallocate(object);
                        vm_map_deallocate(tmap);
                        if (rv != KERN_SUCCESS)
                        vm_object_deallocate(object);
                        vm_map_deallocate(tmap);
                        if (rv != KERN_SUCCESS)
@@ -581,23 +768,21 @@ vm_mmap(map, addr, size, prot, flags, handle, foff)
 #ifdef DEBUG
                if (mmapdebug & MDB_MAPIT)
                        printf("vm_mmap(%d): FILE *addr %x size %x pager %x\n",
 #ifdef DEBUG
                if (mmapdebug & MDB_MAPIT)
                        printf("vm_mmap(%d): FILE *addr %x size %x pager %x\n",
-                              u.u_procp->p_pid, *addr, size, pager);
+                              curproc->p_pid, *addr, size, pager);
 #endif
        }
        /*
         * Correct protection (default is VM_PROT_ALL).
 #endif
        }
        /*
         * Correct protection (default is VM_PROT_ALL).
-        * Note that we set the maximum protection.  This may not be
-        * entirely correct.  Maybe the maximum protection should be based
-        * on the object permissions where it makes sense (e.g. a vnode).
-        *
-        * Changed my mind: leave max prot at VM_PROT_ALL.
+        * If maxprot is different than prot, we must set both explicitly.
         */
         */
-       if (prot != VM_PROT_ALL) {
+       rv = KERN_SUCCESS;
+       if (maxprot != VM_PROT_ALL)
+               rv = vm_map_protect(map, *addr, *addr+size, maxprot, TRUE);
+       if (rv == KERN_SUCCESS && prot != maxprot)
                rv = vm_map_protect(map, *addr, *addr+size, prot, FALSE);
                rv = vm_map_protect(map, *addr, *addr+size, prot, FALSE);
-               if (rv != KERN_SUCCESS) {
-                       (void) vm_deallocate(map, *addr, size);
-                       goto out;
-               }
+       if (rv != KERN_SUCCESS) {
+               (void) vm_deallocate(map, *addr, size);
+               goto out;
        }
        /*
         * Shared memory is also shared with children.
        }
        /*
         * Shared memory is also shared with children.
@@ -632,6 +817,7 @@ out:
  * Given address and size it returns map attributes as well
  * as the (locked) object mapped at that location. 
  */
  * Given address and size it returns map attributes as well
  * as the (locked) object mapped at that location. 
  */
+int
 vm_region(map, addr, size, prot, max_prot, inheritance, shared, object, objoff)
        vm_map_t        map;
        vm_offset_t     *addr;          /* IN/OUT */
 vm_region(map, addr, size, prot, max_prot, inheritance, shared, object, objoff)
        vm_map_t        map;
        vm_offset_t     *addr;          /* IN/OUT */
@@ -650,7 +836,7 @@ vm_region(map, addr, size, prot, max_prot, inheritance, shared, object, objoff)
        vm_offset_t     tmp_offset;
        vm_offset_t     start;
 
        vm_offset_t     tmp_offset;
        vm_offset_t     start;
 
-       if (map == VM_MAP_NULL)
+       if (map == NULL)
                return(KERN_INVALID_ARGUMENT);
        
        start = *addr;
                return(KERN_INVALID_ARGUMENT);
        
        start = *addr;
@@ -707,6 +893,7 @@ vm_region(map, addr, size, prot, max_prot, inheritance, shared, object, objoff)
 /*
  * Yet another bastard routine.
  */
 /*
  * Yet another bastard routine.
  */
+int
 vm_allocate_with_pager(map, addr, size, fitit, pager, poffset, internal)
        register vm_map_t       map;
        register vm_offset_t    *addr;
 vm_allocate_with_pager(map, addr, size, fitit, pager, poffset, internal)
        register vm_map_t       map;
        register vm_offset_t    *addr;
@@ -719,7 +906,7 @@ vm_allocate_with_pager(map, addr, size, fitit, pager, poffset, internal)
        register vm_object_t    object;
        register int            result;
 
        register vm_object_t    object;
        register int            result;
 
-       if (map == VM_MAP_NULL)
+       if (map == NULL)
                return(KERN_INVALID_ARGUMENT);
 
        *addr = trunc_page(*addr);
                return(KERN_INVALID_ARGUMENT);
 
        *addr = trunc_page(*addr);
@@ -731,18 +918,28 @@ vm_allocate_with_pager(map, addr, size, fitit, pager, poffset, internal)
         *      it.
         */
        object = vm_object_lookup(pager);
         *      it.
         */
        object = vm_object_lookup(pager);
-       vm_stat.lookups++;
-       if (object == VM_OBJECT_NULL) {
+       cnt.v_lookups++;
+       if (object == NULL) {
                object = vm_object_allocate(size);
                object = vm_object_allocate(size);
-               vm_object_enter(object, pager);
+               /*
+                * From Mike Hibler: "unnamed anonymous objects should never
+                * be on the hash list ... For now you can just change
+                * vm_allocate_with_pager to not do vm_object_enter if this
+                * is an internal object ..."
+                */
+               if (!internal)
+                       vm_object_enter(object, pager);
        } else
        } else
-               vm_stat.hits++;
-       object->internal = internal;
+               cnt.v_hits++;
+       if (internal)
+               object->flags |= OBJ_INTERNAL;
+       else
+               object->flags &= ~OBJ_INTERNAL;
 
        result = vm_map_find(map, object, poffset, addr, size, fitit);
        if (result != KERN_SUCCESS)
                vm_object_deallocate(object);
 
        result = vm_map_find(map, object, poffset, addr, size, fitit);
        if (result != KERN_SUCCESS)
                vm_object_deallocate(object);
-       else if (pager != vm_pager_null)
+       else if (pager != NULL)
                vm_object_setpager(object, pager, (vm_offset_t) 0, TRUE);
        return(result);
 }
                vm_object_setpager(object, pager, (vm_offset_t) 0, TRUE);
        return(result);
 }
@@ -789,32 +986,3 @@ vm_map_is_allocated(map, start, end, single_entry)
        vm_map_unlock_read(map);
        return (end <= nend);
 }
        vm_map_unlock_read(map);
        return (end <= nend);
 }
-
-#include "../vm/vm_page.h"
-
-/*
- * Doesn't trust the COW bit in the page structure.
- * vm_fault can improperly set it.
- */
-void
-vm_object_pmap_force_copy(object, start, end)
-       register vm_object_t    object;
-       register vm_offset_t    start;
-       register vm_offset_t    end;
-{
-       register vm_page_t      p;
-
-       if (object == VM_OBJECT_NULL)
-               return;
-
-       vm_object_lock(object);
-       p = (vm_page_t) queue_first(&object->memq);
-       while (!queue_end(&object->memq, (queue_entry_t) p)) {
-               if (start <= p->offset && p->offset < end) {
-                       pmap_copy_on_write(VM_PAGE_TO_PHYS(p));
-                       p->copy_on_write = TRUE;
-               }
-               p = (vm_page_t) queue_next(&p->listq);
-       }
-       vm_object_unlock(object);
-}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.