xnu-1456.1.26.tar.gz

[apple/xnu.git] / bsd / kern / kern_mman.c

diff --git a/bsd/kern/kern_mman.c b/bsd/kern/kern_mman.c
index 594cef6eb09a672291d3162bdb2e5d68a0878eb9..02166d578bc6aa04041b641746da756ed6be35bc 100644 (file)
--- a/bsd/kern/kern_mman.c
+++ b/bsd/kern/kern_mman.c
@@ -1,14 +1,19 @@
 /*
 /*

- * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
+ * Copyright (c) 2007 Apple Inc. All Rights Reserved.
+ * 
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in
  * 
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in

- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ * 
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.

  * 
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * 
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER


@@ -18,7 +23,7 @@
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * 
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*
  * Copyright (c) 1988 University of Utah.
  */
 /*
  * Copyright (c) 1988 University of Utah.


@@ -61,6 +66,12 @@
  *
  *     @(#)vm_mmap.c   8.10 (Berkeley) 2/19/95
  */
  *
  *     @(#)vm_mmap.c   8.10 (Berkeley) 2/19/95
  */

+/*
+ * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
+ * support for mandatory and extensible security protections.  This notice
+ * is included in support of clause 2.2 (b) of the Apple Public License,
+ * Version 2.0.
+ */

 
 /*
  * Mapped file (mmap) interface to VM
 
 /*
  * Mapped file (mmap) interface to VM


@@ -82,9 +93,13 @@
 #include <sys/conf.h>
 #include <sys/stat.h>
 #include <sys/ubc.h>
 #include <sys/conf.h>
 #include <sys/stat.h>
 #include <sys/ubc.h>

+#include <sys/ubc_internal.h>

 #include <sys/sysproto.h>
 
 #include <sys/sysproto.h>
 

-#include <bsm/audit_kernel.h>
+#include <sys/syscall.h>
+#include <sys/kdebug.h>
+
+#include <security/audit/audit.h>

 #include <bsm/audit_kevents.h>
 
 #include <mach/mach_types.h>
 #include <bsm/audit_kevents.h>
 
 #include <mach/mach_types.h>


@@ -103,59 +118,19 @@
 #include <vm/vm_map.h>
 #include <vm/vm_kern.h>
 #include <vm/vm_pager.h>
 #include <vm/vm_map.h>
 #include <vm/vm_kern.h>
 #include <vm/vm_pager.h>

+#include <vm/vm_protos.h>

 
 

-int
-sbrk(__unused struct proc *p, __unused struct sbrk_args *uap, __unused register_t *retval)
-{
-       /* Not yet implemented */
-       return (ENOTSUP);
-}
-
-int
-sstk(__unused struct proc *p, __unused struct sstk_args *uap, __unused register_t *retval)
-{
-       /* Not yet implemented */
-       return (ENOTSUP);
-}
-
-
-struct osmmap_args {
-               caddr_t addr;
-               int     len;
-               int     prot;
-               int     share;
-               int     fd;
-               long    pos;
-};
-
-int
-osmmap(
-       struct proc *curp,
-       register struct osmmap_args *uap,
-       register_t *retval)
-{
-       struct mmap_args newargs;
-       user_addr_t addr;
-       int ret;
-
-       if ((uap->share ==  MAP_SHARED )|| (uap->share ==  MAP_PRIVATE )) {
-               newargs.addr = CAST_USER_ADDR_T(uap->addr);
-               newargs.len = CAST_USER_ADDR_T(uap->len);
-               newargs.prot = uap->prot;
-               newargs.flags = uap->share;
-               newargs.fd = uap->fd;
-               newargs.pos = (off_t)uap->pos;
-               ret = mmap(curp, &newargs, &addr);
-               if (ret == 0)
-                       *retval = CAST_DOWN(register_t, addr);
-       } else
-               ret = EINVAL;
-       return ret;
-}
-
+/* XXX the following function should probably be static */
+kern_return_t map_fd_funneled(int, vm_object_offset_t, vm_offset_t *,
+                               boolean_t, vm_size_t);

 
 

+/*
+ * XXX Internally, we use VM_PROT_* somewhat interchangeably, but the correct
+ * XXX usage is PROT_* from an interface perspective.  Thus the values of
+ * XXX VM_PROT_* and PROT_* need to correspond.
+ */

 int
 int

-mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
+mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)

 {
        /*
         *      Map in special device (must be SHARED) or file
 {
        /*
         *      Map in special device (must be SHARED) or file


@@ -171,11 +146,12 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
        mach_vm_size_t          user_size;
        vm_object_offset_t      pageoff;
        vm_object_offset_t      file_pos;
        mach_vm_size_t          user_size;
        vm_object_offset_t      pageoff;
        vm_object_offset_t      file_pos;

-       int                     alloc_flags;
+       int                     alloc_flags=0;

        boolean_t               docow;
        vm_prot_t               maxprot;
        void                    *handle;
        boolean_t               docow;
        vm_prot_t               maxprot;
        void                    *handle;

-       vm_pager_t              pager;
+       memory_object_t         pager = MEMORY_OBJECT_NULL;
+       memory_object_control_t  control;

        int                     mapanon=0;
        int                     fpref=0;
        int error =0;
        int                     mapanon=0;
        int                     fpref=0;
        int error =0;


@@ -189,6 +165,17 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
        AUDIT_ARG(fd, uap->fd);
 
        prot = (uap->prot & VM_PROT_ALL);
        AUDIT_ARG(fd, uap->fd);
 
        prot = (uap->prot & VM_PROT_ALL);

+#if 3777787
+       /*
+        * Since the hardware currently does not support writing without
+        * read-before-write, or execution-without-read, if the request is
+        * for write or execute access, we must imply read access as well;
+        * otherwise programs expecting this to work will fail to operate.
+        */
+       if (prot & (VM_PROT_EXECUTE | VM_PROT_WRITE))
+               prot |= VM_PROT_READ;
+#endif /* radar 3777787 */
+

        flags = uap->flags;
        vp = NULLVP;
 
        flags = uap->flags;
        vp = NULLVP;
 


@@ -201,8 +188,7 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
 
 
        /* make sure mapping fits into numeric range etc */
 
 
        /* make sure mapping fits into numeric range etc */

-       if ((file_pos + user_size > (vm_object_offset_t)-PAGE_SIZE_64) ||
-           ((flags & MAP_ANON) && fd != -1))
+       if (file_pos + user_size > (vm_object_offset_t)-PAGE_SIZE_64)

                return (EINVAL);
 
        /*
                return (EINVAL);
 
        /*


@@ -230,7 +216,7 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
                 */
                user_addr -= pageoff;
                if (user_addr & PAGE_MASK)
                 */
                user_addr -= pageoff;
                if (user_addr & PAGE_MASK)

-                       return (EINVAL);
+               return (EINVAL);

        }
 #ifdef notyet
        /* DO not have apis to get this info, need to wait till then*/
        }
 #ifdef notyet
        /* DO not have apis to get this info, need to wait till then*/


@@ -247,18 +233,34 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
 
 #endif
 
 
 #endif
 

+       alloc_flags = 0;

 
        if (flags & MAP_ANON) {
                /*
 
        if (flags & MAP_ANON) {
                /*

-                * Mapping blank space is trivial.
+                * Mapping blank space is trivial.  Use positive fds as the alias
+                * value for memory tracking. 

                 */
                 */

+               if (fd != -1) {
+                       /*
+                        * Use "fd" to pass (some) Mach VM allocation flags,
+                        * (see the VM_FLAGS_* definitions).
+                        */
+                       alloc_flags = fd & (VM_FLAGS_ALIAS_MASK |
+                                           VM_FLAGS_PURGABLE);
+                       if (alloc_flags != fd) {
+                               /* reject if there are any extra flags */
+                               return EINVAL;
+                       }
+               }
+                       

                handle = NULL;
                maxprot = VM_PROT_ALL;
                file_pos = 0;
                mapanon = 1;
        } else {
                struct vnode_attr va;
                handle = NULL;
                maxprot = VM_PROT_ALL;
                file_pos = 0;
                mapanon = 1;
        } else {
                struct vnode_attr va;

-               struct vfs_context context;
+               vfs_context_t ctx = vfs_context_current();
+

                /*
                 * Mapping file, get fp for validation. Obtain vnode and make
                 * sure it is of appropriate type.
                /*
                 * Mapping file, get fp for validation. Obtain vnode and make
                 * sure it is of appropriate type.


@@ -294,15 +296,15 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
 
                AUDIT_ARG(vnpath, vp, ARG_VNODE1);
                
 
                AUDIT_ARG(vnpath, vp, ARG_VNODE1);
                

-               /* conformance change - mmap needs to update access time for mapped
-                * files
+               /*
+                * POSIX: mmap needs to update access time for mapped files

                 */
                 */

-               VATTR_INIT(&va);
-               nanotime(&va.va_access_time);
-               VATTR_SET_ACTIVE(&va, va_access_time);
-               context.vc_proc = p;
-               context.vc_ucred = kauth_cred_get();
-               vnode_setattr(vp, &va, &context);
+               if ((vnode_vfsvisflags(vp) & MNT_NOATIME) == 0) {
+                       VATTR_INIT(&va);
+                       nanotime(&va.va_access_time);
+                       VATTR_SET_ACTIVE(&va, va_access_time);
+                       vnode_setattr(vp, &va, ctx);
+               }

 
                /*
                 * XXX hack to handle use of /dev/zero to map anon memory (ala
 
                /*
                 * XXX hack to handle use of /dev/zero to map anon memory (ala


@@ -339,14 +341,19 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
                         */
 
                        if ((flags & MAP_SHARED) != 0) {
                         */
 
                        if ((flags & MAP_SHARED) != 0) {

-                               if ((fp->f_fglob->fg_flag & FWRITE) != 0) {
+                               if ((fp->f_fglob->fg_flag & FWRITE) != 0 &&
+                                   /*
+                                    * Do not allow writable mappings of 
+                                    * swap files (see vm_swapfile_pager.c).
+                                    */
+                                   !vnode_isswap(vp)) {

                                        /*
                                         * check for write access
                                         *
                                         * Note that we already made this check when granting FWRITE
                                         * against the file, so it seems redundant here.
                                         */
                                        /*
                                         * check for write access
                                         *
                                         * Note that we already made this check when granting FWRITE
                                         * against the file, so it seems redundant here.
                                         */

-                                       error = vnode_authorize(vp, NULL, KAUTH_VNODE_CHECKIMMUTABLE, &context);
+                                       error = vnode_authorize(vp, NULL, KAUTH_VNODE_CHECKIMMUTABLE, ctx);

  
                                        /* if not granted for any reason, but we wanted it, bad */
                                        if ((prot & PROT_WRITE) && (error != 0)) {
  
                                        /* if not granted for any reason, but we wanted it, bad */
                                        if ((prot & PROT_WRITE) && (error != 0)) {


@@ -367,6 +374,14 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
                                maxprot |= VM_PROT_WRITE;
 
                        handle = (void *)vp;
                                maxprot |= VM_PROT_WRITE;
 
                        handle = (void *)vp;

+#if CONFIG_MACF
+                       error = mac_file_check_mmap(vfs_context_ucred(ctx),
+                           fp->f_fglob, prot, flags, &maxprot);
+                       if (error) {
+                               (void)vnode_put(vp);
+                               goto bad;
+                       }
+#endif /* MAC */

                }
        }
 
                }
        }
 


@@ -393,7 +408,7 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
        user_map = current_map();
 
        if ((flags & MAP_FIXED) == 0) {
        user_map = current_map();
 
        if ((flags & MAP_FIXED) == 0) {

-               alloc_flags = VM_FLAGS_ANYWHERE;
+               alloc_flags |= VM_FLAGS_ANYWHERE;

                user_addr = mach_vm_round_page(user_addr);
        } else {
                if (user_addr != mach_vm_trunc_page(user_addr)) {
                user_addr = mach_vm_round_page(user_addr);
        } else {
                if (user_addr != mach_vm_trunc_page(user_addr)) {


@@ -413,37 +428,58 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
                 * has to deallocate the existing mappings and establish the
                 * new ones atomically.
                 */
                 * has to deallocate the existing mappings and establish the
                 * new ones atomically.
                 */

-               alloc_flags = VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE;
+               alloc_flags |= VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE;

        }
 
        }
 

+       if (flags & MAP_NOCACHE)
+               alloc_flags |= VM_FLAGS_NO_CACHE;

 
        /*
         * Lookup/allocate object.
         */
        if (handle == NULL) {
 
        /*
         * Lookup/allocate object.
         */
        if (handle == NULL) {

-               pager = NULL;
+               control = NULL;

 #ifdef notyet
 /* Hmm .. */
 #if defined(VM_PROT_READ_IS_EXEC)
                if (prot & VM_PROT_READ)
                        prot |= VM_PROT_EXECUTE;
 #ifdef notyet
 /* Hmm .. */
 #if defined(VM_PROT_READ_IS_EXEC)
                if (prot & VM_PROT_READ)
                        prot |= VM_PROT_EXECUTE;

-

                if (maxprot & VM_PROT_READ)
                        maxprot |= VM_PROT_EXECUTE;
 #endif
 #endif
                if (maxprot & VM_PROT_READ)
                        maxprot |= VM_PROT_EXECUTE;
 #endif
 #endif

-               result = mach_vm_map(user_map, &user_addr, user_size, 0,
-                               alloc_flags, IPC_PORT_NULL, 0,
-                               FALSE, prot, maxprot,
-                               (flags & MAP_SHARED) ? VM_INHERIT_SHARE : 
-                                                      VM_INHERIT_DEFAULT);
-               if (result != KERN_SUCCESS) 
-                               goto out;
+
+#if 3777787
+               if (prot & (VM_PROT_EXECUTE | VM_PROT_WRITE))
+                       prot |= VM_PROT_READ;
+               if (maxprot & (VM_PROT_EXECUTE | VM_PROT_WRITE))
+                       maxprot |= VM_PROT_READ;
+#endif /* radar 3777787 */
+
+               result = vm_map_enter_mem_object(user_map,
+                                                &user_addr, user_size,
+                                                0, alloc_flags,
+                                                IPC_PORT_NULL, 0, FALSE,
+                                                prot, maxprot,
+                                                (flags & MAP_SHARED) ?
+                                                VM_INHERIT_SHARE : 
+                                                VM_INHERIT_DEFAULT);

        } else {
        } else {

-               UBCINFOCHECK("mmap", vp);
-               pager = (vm_pager_t)ubc_getpager(vp);
+               if (vnode_isswap(vp)) {
+                       /*
+                        * Map swap files with a special pager
+                        * that returns obfuscated contents.
+                        */
+                       control = NULL;
+                       pager = swapfile_pager_setup(vp);
+                       if (pager != MEMORY_OBJECT_NULL) {
+                               control = swapfile_pager_control(pager);
+                       }
+               } else {
+                       control = ubc_getobject(vp, UBC_FLAGS_NONE);
+               }

                
                

-               if (pager == NULL) {
+               if (control == NULL) {

                        (void)vnode_put(vp);
                        error = ENOMEM;
                        goto bad;
                        (void)vnode_put(vp);
                        error = ENOMEM;
                        goto bad;


@@ -456,7 +492,7 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
                 *      with ones that only work for read.
                 */
 
                 *      with ones that only work for read.
                 */
 

-               ubc_setcred(vp, p);
+               ubc_setthreadcred(vp, p, current_thread());

                docow = FALSE;
                if ((flags & (MAP_ANON|MAP_SHARED)) == 0) {
                        docow = TRUE;
                docow = FALSE;
                if ((flags & (MAP_ANON|MAP_SHARED)) == 0) {
                        docow = TRUE;


@@ -467,30 +503,32 @@ mmap(struct proc *p, struct mmap_args *uap, user_addr_t *retval)
 #if defined(VM_PROT_READ_IS_EXEC)
                if (prot & VM_PROT_READ)
                        prot |= VM_PROT_EXECUTE;
 #if defined(VM_PROT_READ_IS_EXEC)
                if (prot & VM_PROT_READ)
                        prot |= VM_PROT_EXECUTE;

-

                if (maxprot & VM_PROT_READ)
                        maxprot |= VM_PROT_EXECUTE;
 #endif
 #endif /* notyet */
 
                if (maxprot & VM_PROT_READ)
                        maxprot |= VM_PROT_EXECUTE;
 #endif
 #endif /* notyet */
 

-               result = mach_vm_map(user_map, &user_addr, user_size,
-                               0, alloc_flags, (ipc_port_t)pager, file_pos,
-                               docow, prot, maxprot, 
-                               (flags & MAP_SHARED) ? VM_INHERIT_SHARE : 
-                                                      VM_INHERIT_DEFAULT);
-
-               if (result != KERN_SUCCESS)  {
-                               (void)vnode_put(vp);
-                               goto out;
-               }
-
-               (void)ubc_map(vp,(prot & ( PROT_EXEC | PROT_READ | PROT_WRITE | PROT_EXEC)));
+#if 3777787
+               if (prot & (VM_PROT_EXECUTE | VM_PROT_WRITE))
+                       prot |= VM_PROT_READ;
+               if (maxprot & (VM_PROT_EXECUTE | VM_PROT_WRITE))
+                       maxprot |= VM_PROT_READ;
+#endif /* radar 3777787 */
+
+               result = vm_map_enter_mem_object_control(user_map,
+                                                &user_addr, user_size,
+                                                0, alloc_flags,
+                                                control, file_pos,
+                                                docow, prot, maxprot, 
+                                                (flags & MAP_SHARED) ?
+                                                VM_INHERIT_SHARE : 
+                                                VM_INHERIT_DEFAULT);

        }
 
        }
 

-       if (!mapanon)
+       if (!mapanon) {

                (void)vnode_put(vp);
                (void)vnode_put(vp);

+       }

 
 

-out:

        switch (result) {
        case KERN_SUCCESS:
                *retval = user_addr + pageoff;
        switch (result) {
        case KERN_SUCCESS:
                *retval = user_addr + pageoff;


@@ -508,13 +546,33 @@ out:
                break;
        }
 bad:
                break;
        }
 bad:

+       if (pager != MEMORY_OBJECT_NULL) {
+               /*
+                * Release the reference on the pager.
+                * If the mapping was successful, it now holds
+                * an extra reference.
+                */
+               memory_object_deallocate(pager);
+       }

        if (fpref)
                fp_drop(p, fd, fp, 0);
        if (fpref)
                fp_drop(p, fd, fp, 0);

+
+       KERNEL_DEBUG_CONSTANT((BSDDBG_CODE(DBG_BSD_SC_EXTENDED_INFO, SYS_mmap) | DBG_FUNC_NONE), fd, (uint32_t)(*retval), (uint32_t)user_size, error, 0);
+       KERNEL_DEBUG_CONSTANT((BSDDBG_CODE(DBG_BSD_SC_EXTENDED_INFO2, SYS_mmap) | DBG_FUNC_NONE), (uint32_t)(*retval >> 32), (uint32_t)(user_size >> 32),
+                             (uint32_t)(file_pos >> 32), (uint32_t)file_pos, 0);
+

        return(error);
 }
 
 int
        return(error);
 }
 
 int

-msync(__unused struct proc *p, struct msync_args *uap, __unused register_t *retval)
+msync(__unused proc_t p, struct msync_args *uap, int32_t *retval)
+{
+       __pthread_testcancel(1);
+       return(msync_nocancel(p, (struct msync_nocancel_args *)uap, retval));
+}
+
+int
+msync_nocancel(__unused proc_t p, struct msync_nocancel_args *uap, __unused int32_t *retval)

 {
        mach_vm_offset_t addr;
        mach_vm_size_t size;
 {
        mach_vm_offset_t addr;
        mach_vm_size_t size;


@@ -526,6 +584,8 @@ msync(__unused struct proc *p, struct msync_args *uap, __unused register_t *retv
        addr = (mach_vm_offset_t) uap->addr;
        size = (mach_vm_size_t)uap->len;
 
        addr = (mach_vm_offset_t) uap->addr;
        size = (mach_vm_size_t)uap->len;
 

+       KERNEL_DEBUG_CONSTANT((BSDDBG_CODE(DBG_BSD_SC_EXTENDED_INFO, SYS_msync) | DBG_FUNC_NONE), (uint32_t)(addr >> 32), (uint32_t)(size >> 32), 0, 0, 0);
+

        if (addr & PAGE_MASK_64) {
                /* UNIX SPEC: user address is not page-aligned, return EINVAL */
                return EINVAL;
        if (addr & PAGE_MASK_64) {
                /* UNIX SPEC: user address is not page-aligned, return EINVAL */
                return EINVAL;


@@ -543,8 +603,7 @@ msync(__unused struct proc *p, struct msync_args *uap, __unused register_t *retv
 
        flags = uap->flags;
        /* disallow contradictory flags */
 
        flags = uap->flags;
        /* disallow contradictory flags */

-       if ((flags & (MS_SYNC|MS_ASYNC)) == (MS_SYNC|MS_ASYNC) ||
-           (flags & (MS_ASYNC|MS_INVALIDATE)) == (MS_ASYNC|MS_INVALIDATE))
+       if ((flags & (MS_SYNC|MS_ASYNC)) == (MS_SYNC|MS_ASYNC))

                return (EINVAL);
 
        if (flags & MS_KILLPAGES)
                return (EINVAL);
 
        if (flags & MS_KILLPAGES)


@@ -581,14 +640,7 @@ msync(__unused struct proc *p, struct msync_args *uap, __unused register_t *retv
 
 
 int
 
 
 int

-mremap(void)
-{
-       /* Not yet implemented */
-       return (ENOTSUP);
-}
-
-int
-munmap(__unused struct proc *p, struct munmap_args *uap, __unused register_t *retval)
+munmap(__unused proc_t p, struct munmap_args *uap, __unused int32_t *retval)

 {
        mach_vm_offset_t        user_addr;
        mach_vm_size_t  user_size;
 {
        mach_vm_offset_t        user_addr;
        mach_vm_size_t  user_size;


@@ -621,17 +673,20 @@ munmap(__unused struct proc *p, struct munmap_args *uap, __unused register_t *re
 }
 
 int
 }
 
 int

-mprotect(__unused struct proc *p, struct mprotect_args *uap, __unused register_t *retval)
+mprotect(__unused proc_t p, struct mprotect_args *uap, __unused int32_t *retval)

 {
        register vm_prot_t prot;
        mach_vm_offset_t        user_addr;
        mach_vm_size_t  user_size;
        kern_return_t   result;
        vm_map_t        user_map;
 {
        register vm_prot_t prot;
        mach_vm_offset_t        user_addr;
        mach_vm_size_t  user_size;
        kern_return_t   result;
        vm_map_t        user_map;

+#if CONFIG_MACF
+       int error;
+#endif

 
        AUDIT_ARG(addr, uap->addr);
        AUDIT_ARG(len, uap->len);
 
        AUDIT_ARG(addr, uap->addr);
        AUDIT_ARG(len, uap->len);

-       AUDIT_ARG(value, uap->prot);
+       AUDIT_ARG(value32, uap->prot);

 
        user_addr = (mach_vm_offset_t) uap->addr;
        user_size = (mach_vm_size_t) uap->len;
 
        user_addr = (mach_vm_offset_t) uap->addr;
        user_size = (mach_vm_size_t) uap->len;


@@ -650,8 +705,29 @@ mprotect(__unused struct proc *p, struct mprotect_args *uap, __unused register_t
 #endif
 #endif /* notyet */
 
 #endif
 #endif /* notyet */
 

+#if 3936456
+       if (prot & (VM_PROT_EXECUTE | VM_PROT_WRITE))
+               prot |= VM_PROT_READ;
+#endif /* 3936456 */
+

        user_map = current_map();
 
        user_map = current_map();
 

+#if CONFIG_MACF
+       /*
+        * The MAC check for mprotect is of limited use for 2 reasons:
+        * Without mmap revocation, the caller could have asked for the max
+        * protections initially instead of a reduced set, so a mprotect
+        * check would offer no new security.
+        * It is not possible to extract the vnode from the pager object(s)
+        * of the target memory range.
+        * However, the MAC check may be used to prevent a process from,
+        * e.g., making the stack executable.
+        */
+       error = mac_proc_check_mprotect(p, user_addr,
+                       user_size, prot);
+       if (error)
+               return (error);
+#endif

        result = mach_vm_protect(user_map, user_addr, user_size,
                                 FALSE, prot);
        switch (result) {
        result = mach_vm_protect(user_map, user_addr, user_size,
                                 FALSE, prot);
        switch (result) {


@@ -668,7 +744,7 @@ mprotect(__unused struct proc *p, struct mprotect_args *uap, __unused register_t
 
 
 int
 
 
 int

-minherit(__unused struct proc *p, struct minherit_args *uap, __unused register_t *retval)
+minherit(__unused proc_t p, struct minherit_args *uap, __unused int32_t *retval)

 {
        mach_vm_offset_t addr;
        mach_vm_size_t size;
 {
        mach_vm_offset_t addr;
        mach_vm_size_t size;


@@ -678,7 +754,7 @@ minherit(__unused struct proc *p, struct minherit_args *uap, __unused register_t
 
        AUDIT_ARG(addr, uap->addr);
        AUDIT_ARG(len, uap->len);
 
        AUDIT_ARG(addr, uap->addr);
        AUDIT_ARG(len, uap->len);

-       AUDIT_ARG(value, uap->inherit);
+       AUDIT_ARG(value32, uap->inherit);

 
        addr = (mach_vm_offset_t)uap->addr;
        size = (mach_vm_size_t)uap->len;
 
        addr = (mach_vm_offset_t)uap->addr;
        size = (mach_vm_size_t)uap->len;


@@ -697,7 +773,7 @@ minherit(__unused struct proc *p, struct minherit_args *uap, __unused register_t
 }
 
 int
 }
 
 int

-madvise(__unused struct proc *p, struct madvise_args *uap, __unused register_t *retval)
+madvise(__unused proc_t p, struct madvise_args *uap, __unused int32_t *retval)

 {
        vm_map_t user_map;
        mach_vm_offset_t start;
 {
        vm_map_t user_map;
        mach_vm_offset_t start;


@@ -725,6 +801,21 @@ madvise(__unused struct proc *p, struct madvise_args *uap, __unused register_t *
                case MADV_DONTNEED:
                        new_behavior = VM_BEHAVIOR_DONTNEED;
                        break;
                case MADV_DONTNEED:
                        new_behavior = VM_BEHAVIOR_DONTNEED;
                        break;

+               case MADV_FREE:
+                       new_behavior = VM_BEHAVIOR_FREE;
+                       break;
+               case MADV_ZERO_WIRED_PAGES:
+                       new_behavior = VM_BEHAVIOR_ZERO_WIRED_PAGES;
+                       break;
+               case MADV_FREE_REUSABLE:
+                       new_behavior = VM_BEHAVIOR_REUSABLE;
+                       break;
+               case MADV_FREE_REUSE:
+                       new_behavior = VM_BEHAVIOR_REUSE;
+                       break;
+               case MADV_CAN_REUSE:
+                       new_behavior = VM_BEHAVIOR_CAN_REUSE;
+                       break;

                default:
                        return(EINVAL);
        }
                default:
                        return(EINVAL);
        }


@@ -746,7 +837,7 @@ madvise(__unused struct proc *p, struct madvise_args *uap, __unused register_t *
 }
 
 int
 }
 
 int

-mincore(__unused struct proc *p, struct mincore_args *uap, __unused register_t *retval)
+mincore(__unused proc_t p, struct mincore_args *uap, __unused int32_t *retval)

 {
        mach_vm_offset_t addr, first_addr, end;
        vm_map_t map;
 {
        mach_vm_offset_t addr, first_addr, end;
        vm_map_t map;


@@ -787,7 +878,7 @@ mincore(__unused struct proc *p, struct mincore_args *uap, __unused register_t *
        lastvecindex = -1;
        for( ; addr < end; addr += PAGE_SIZE ) {
                pqueryinfo = 0;
        lastvecindex = -1;
        for( ; addr < end; addr += PAGE_SIZE ) {
                pqueryinfo = 0;

-               ret = vm_map_page_query(map, addr, &pqueryinfo, &numref);
+               ret = mach_vm_page_query(map, addr, &pqueryinfo, &numref);

                if (ret != KERN_SUCCESS) 
                        pqueryinfo = 0;
                mincoreinfo = 0;
                if (ret != KERN_SUCCESS) 
                        pqueryinfo = 0;
                mincoreinfo = 0;


@@ -846,7 +937,7 @@ mincore(__unused struct proc *p, struct mincore_args *uap, __unused register_t *
 }
 
 int
 }
 
 int

-mlock(__unused struct proc *p, struct mlock_args *uap, __unused register_t *retvalval)
+mlock(__unused proc_t p, struct mlock_args *uap, __unused int32_t *retvalval)

 {
        vm_map_t user_map;
        vm_map_offset_t addr;
 {
        vm_map_t user_map;
        vm_map_offset_t addr;


@@ -869,31 +960,21 @@ mlock(__unused struct proc *p, struct mlock_args *uap, __unused register_t *retv
        pageoff = (addr & PAGE_MASK);
        addr -= pageoff;
        size = vm_map_round_page(size+pageoff);
        pageoff = (addr & PAGE_MASK);
        addr -= pageoff;
        size = vm_map_round_page(size+pageoff);

-
-#ifdef notyet 
-/* Hmm.. What am I going to do with this? */
-       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 (ENOMEM);
-#else
-       error = suser(kauth_cred_get(), &p->p_acflag);
-       if (error)
-               return (error);
-#endif
-#endif /* notyet */
-

        user_map = current_map();
 
        /* have to call vm_map_wire directly to pass "I don't know" protections */
        result = vm_map_wire(user_map, addr, addr+size, VM_PROT_NONE, TRUE);
        user_map = current_map();
 
        /* have to call vm_map_wire directly to pass "I don't know" protections */
        result = vm_map_wire(user_map, addr, addr+size, VM_PROT_NONE, TRUE);

-       return (result == KERN_SUCCESS ? 0 : ENOMEM);
+
+       if (result == KERN_RESOURCE_SHORTAGE)
+               return EAGAIN;
+       else if (result != KERN_SUCCESS)
+               return ENOMEM;
+
+       return 0;       /* KERN_SUCCESS */

 }
 
 int
 }
 
 int

-munlock(__unused struct proc *p, struct munlock_args *uap, __unused register_t *retval)
+munlock(__unused proc_t p, struct munlock_args *uap, __unused int32_t *retval)

 {
        mach_vm_offset_t addr;
        mach_vm_size_t size;
 {
        mach_vm_offset_t addr;
        mach_vm_size_t size;


@@ -905,17 +986,6 @@ munlock(__unused struct proc *p, struct munlock_args *uap, __unused register_t *
 
        addr = (mach_vm_offset_t) uap->addr;
        size = (mach_vm_size_t)uap->len;
 
        addr = (mach_vm_offset_t) uap->addr;
        size = (mach_vm_size_t)uap->len;

-
-
-#ifdef notyet 
-/* Hmm.. What am I going to do with this? */
-#ifndef pmap_wired_count
-       error = suser(kauth_cred_get(), &p->p_acflag);
-       if (error)
-               return (error);
-#endif
-#endif /* notyet */
-

        user_map = current_map();
 
        /* JMM - need to remove all wirings by spec - this just removes one */
        user_map = current_map();
 
        /* JMM - need to remove all wirings by spec - this just removes one */


@@ -925,39 +995,17 @@ munlock(__unused struct proc *p, struct munlock_args *uap, __unused register_t *
 
 
 int
 
 
 int

-mlockall(__unused struct proc *p, __unused struct mlockall_args *uap, __unused register_t *retval)
+mlockall(__unused proc_t p, __unused struct mlockall_args *uap, __unused int32_t *retval)

 {
        return (ENOSYS);
 }
 
 int
 {
        return (ENOSYS);
 }
 
 int

-munlockall(__unused struct proc *p, __unused struct munlockall_args *uap, __unused register_t *retval)
+munlockall(__unused proc_t p, __unused struct munlockall_args *uap, __unused int32_t *retval)

 {
        return(ENOSYS);
 }
 
 {
        return(ENOSYS);
 }
 

-
-/* BEGIN DEFUNCT */
-int
-obreak(__unused struct proc *p, __unused struct obreak_args *uap, __unused register_t *retval)
-{
-       /* Not implemented, obsolete */
-       return (ENOMEM);
-}
-
-int    both;
-
-int
-ovadvise(__unused struct proc *p, __unused struct ovadvise_args *uap, __unused register_t *retval)
-{
-
-#ifdef lint
-       both = 0;
-#endif
-       return( 0 );
-}
-/* END DEFUNCT */
-

 /* USV: No! need to obsolete map_fd()! mmap() already supports 64 bits */
 kern_return_t
 map_fd(struct map_fd_args *args)
 /* USV: No! need to obsolete map_fd()! mmap() already supports 64 bits */
 kern_return_t
 map_fd(struct map_fd_args *args)


@@ -970,7 +1018,7 @@ map_fd(struct map_fd_args *args)
        kern_return_t ret;
 
        AUDIT_MACH_SYSCALL_ENTER(AUE_MAPFD);
        kern_return_t ret;
 
        AUDIT_MACH_SYSCALL_ENTER(AUE_MAPFD);

-       AUDIT_ARG(addr, CAST_DOWN(user_addr_t, va));
+       AUDIT_ARG(addr, CAST_DOWN(user_addr_t, args->va));

        AUDIT_ARG(fd, fd);
 
        ret = map_fd_funneled( fd, (vm_object_offset_t)offset, va, findspace, size);
        AUDIT_ARG(fd, fd);
 
        ret = map_fd_funneled( fd, (vm_object_offset_t)offset, va, findspace, size);


@@ -995,9 +1043,8 @@ map_fd_funneled(
        vm_size_t       map_size;
        int             err=0;
        vm_map_t        my_map;
        vm_size_t       map_size;
        int             err=0;
        vm_map_t        my_map;

-       struct proc     *p =(struct proc *)current_proc();
+       proc_t          p = current_proc();

        struct vnode_attr vattr;
        struct vnode_attr vattr;

-       struct vfs_context context;

 
        /*
         *      Find the inode; verify that it's a regular file.
 
        /*
         *      Find the inode; verify that it's a regular file.


@@ -1030,16 +1077,16 @@ map_fd_funneled(
 
        AUDIT_ARG(vnpath, vp, ARG_VNODE1);
 
 
        AUDIT_ARG(vnpath, vp, ARG_VNODE1);
 

-       /* conformance change - mmap needs to update access time for mapped
-        * files
+       /*
+        * POSIX: mmap needs to update access time for mapped files

         */
         */

-       VATTR_INIT(&vattr);
-       nanotime(&vattr.va_access_time);
-       VATTR_SET_ACTIVE(&vattr, va_access_time);
-       context.vc_proc = p;
-       context.vc_ucred = kauth_cred_get();
-       vnode_setattr(vp, &vattr, &context);
-
+       if ((vnode_vfsvisflags(vp) & MNT_NOATIME) == 0) {
+               VATTR_INIT(&vattr);
+               nanotime(&vattr.va_access_time);
+               VATTR_SET_ACTIVE(&vattr, va_access_time);
+               vnode_setattr(vp, &vattr, vfs_context_current());
+       }
+       

        if (offset & PAGE_MASK_64) {
                printf("map_fd: file offset not page aligned(%d : %s)\n",p->p_pid, p->p_comm);
                (void)vnode_put(vp);
        if (offset & PAGE_MASK_64) {
                printf("map_fd: file offset not page aligned(%d : %s)\n",p->p_pid, p->p_comm);
                (void)vnode_put(vp);


@@ -1059,8 +1106,7 @@ map_fd_funneled(
        /*
         *      Map in the file.
         */
        /*
         *      Map in the file.
         */

-       UBCINFOCHECK("map_fd_funneled", vp);
-       pager = (void *) ubc_getpager(vp);
+       pager = (void *)ubc_getpager(vp);

        if (pager == NULL) {
                (void)vnode_put(vp);
                err = KERN_FAILURE;
        if (pager == NULL) {
                (void)vnode_put(vp);
                err = KERN_FAILURE;


@@ -1084,11 +1130,12 @@ map_fd_funneled(
 
 
        if (!findspace) {
 
 
        if (!findspace) {

-               vm_offset_t     dst_addr;
+               //K64todo fix for 64bit user?
+               uint32_t        dst_addr;

                vm_map_copy_t   tmp;
 
                if (copyin(CAST_USER_ADDR_T(va), &dst_addr, sizeof (dst_addr))  ||
                vm_map_copy_t   tmp;
 
                if (copyin(CAST_USER_ADDR_T(va), &dst_addr, sizeof (dst_addr))  ||

-                                       trunc_page_32(dst_addr) != dst_addr) {
+                                       trunc_page(dst_addr) != dst_addr) {

                        (void) vm_map_remove(
                                        my_map,
                                        map_addr, map_addr + map_size,
                        (void) vm_map_remove(
                                        my_map,
                                        map_addr, map_addr + map_size,


@@ -1119,7 +1166,9 @@ map_fd_funneled(
                        goto bad;
                }
        } else {
                        goto bad;
                }
        } else {

-               if (copyout(&map_addr, CAST_USER_ADDR_T(va), sizeof (map_addr))) {
+               // K64todo bug compatible now, should fix for 64bit user
+               uint32_t user_map_addr = CAST_DOWN_EXPLICIT(uint32_t, map_addr);
+               if (copyout(&user_map_addr, CAST_USER_ADDR_T(va), sizeof (user_map_addr))) {

                        (void) vm_map_remove(my_map, vm_map_trunc_page(map_addr),
                                        vm_map_round_page(map_addr + map_size),
                                        VM_MAP_NO_FLAGS);
                        (void) vm_map_remove(my_map, vm_map_trunc_page(map_addr),
                                        vm_map_round_page(map_addr + map_size),
                                        VM_MAP_NO_FLAGS);


@@ -1129,8 +1178,7 @@ map_fd_funneled(
                }
        }
 
                }
        }
 

-       ubc_setcred(vp, current_proc());
-       (void)ubc_map(vp, (PROT_READ | PROT_WRITE | PROT_EXEC));
+       ubc_setthreadcred(vp, current_proc(), current_thread());

        (void)vnode_put(vp);
        err = 0;
 bad:
        (void)vnode_put(vp);
        err = 0;
 bad: