xnu-2422.90.20.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 499d6f61baea3f635ac3c4603b8bd9bdd1cc3e6e..575110d697f4b3ff30ed32d151090bad347721c3 100644 (file)
--- a/bsd/kern/kern_mman.c
+++ b/bsd/kern/kern_mman.c
@@ -95,11 +95,14 @@
 #include <sys/ubc.h>
 #include <sys/ubc_internal.h>
 #include <sys/sysproto.h>
 #include <sys/ubc.h>
 #include <sys/ubc_internal.h>
 #include <sys/sysproto.h>

+#if CONFIG_PROTECT
+#include <sys/cprotect.h>
+#endif

 
 #include <sys/syscall.h>
 #include <sys/kdebug.h>
 
 
 #include <sys/syscall.h>
 #include <sys/kdebug.h>
 

-#include <bsm/audit_kernel.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>


@@ -112,71 +115,21 @@
 #include <mach/vm_map.h>
 #include <mach/host_priv.h>
 
 #include <mach/vm_map.h>
 #include <mach/host_priv.h>
 

+#include <machine/machine_routines.h>
+

 #include <kern/cpu_number.h>
 #include <kern/host.h>
 #include <kern/cpu_number.h>
 #include <kern/host.h>

+#include <kern/task.h>

 
 #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>

-
-struct osmmap_args {
-               caddr_t addr;
-               int     len;
-               int     prot;
-               int     share;
-               int     fd;
-               long    pos;
-};
+#include <vm/vm_protos.h>

 
 /* 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 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 the following two functions aren't used anywhere */
-int osmmap(proc_t , struct osmmap_args *, register_t *);
-int mremap(void);
-
-int
-sbrk(__unused proc_t p, __unused struct sbrk_args *uap, __unused register_t *retval)
-{
-       /* Not yet implemented */
-       return (ENOTSUP);
-}
-
-int
-sstk(__unused proc_t p, __unused struct sstk_args *uap, __unused register_t *retval)
-{
-       /* Not yet implemented */
-       return (ENOTSUP);
-}
-
-
-int
-osmmap(
-       proc_t curp,
-       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 Internally, we use VM_PROT_* somewhat interchangeably, but the correct
  * XXX usage is PROT_* from an interface perspective.  Thus the values of
 /*
  * XXX Internally, we use VM_PROT_* somewhat interchangeably, but the correct
  * XXX usage is PROT_* from an interface perspective.  Thus the values of


@@ -191,26 +144,29 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
        struct fileproc *fp;
        register struct         vnode *vp;
        int                     flags;
        struct fileproc *fp;
        register struct         vnode *vp;
        int                     flags;

-       int                     prot, file_prot;
+       int                     prot;

        int                     err=0;
        vm_map_t                user_map;
        kern_return_t           result;
        int                     err=0;
        vm_map_t                user_map;
        kern_return_t           result;

-       mach_vm_offset_t        user_addr;
-       mach_vm_size_t          user_size;
+       vm_map_offset_t         user_addr;
+       vm_map_size_t           user_size;

        vm_object_offset_t      pageoff;
        vm_object_offset_t      file_pos;
        int                     alloc_flags=0;
        boolean_t               docow;
        vm_prot_t               maxprot;
        void                    *handle;
        vm_object_offset_t      pageoff;
        vm_object_offset_t      file_pos;
        int                     alloc_flags=0;
        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 fd = uap->fd;
        int                     mapanon=0;
        int                     fpref=0;
        int error =0;
        int fd = uap->fd;

+       int num_retries = 0;

 
 

-       user_addr = (mach_vm_offset_t)uap->addr;
-       user_size = (mach_vm_size_t) uap->len;
+       user_map = current_map();
+       user_addr = (vm_map_offset_t)uap->addr;
+       user_size = (vm_map_size_t) uap->len;

 
        AUDIT_ARG(addr, user_addr);
        AUDIT_ARG(len, user_size);
 
        AUDIT_ARG(addr, user_addr);
        AUDIT_ARG(len, user_size);


@@ -247,15 +203,18 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
         * Align the file position to a page boundary,
         * and save its page offset component.
         */
         * Align the file position to a page boundary,
         * and save its page offset component.
         */

-       pageoff = (file_pos & PAGE_MASK);
+       pageoff = (file_pos & vm_map_page_mask(user_map));

        file_pos -= (vm_object_offset_t)pageoff;
 
 
        /* Adjust size for rounding (on both ends). */
        file_pos -= (vm_object_offset_t)pageoff;
 
 
        /* Adjust size for rounding (on both ends). */

-       user_size += pageoff;                   /* low end... */
-       user_size = mach_vm_round_page(user_size);      /* hi end */
-
+       user_size += pageoff;   /* low end... */
+       user_size = vm_map_round_page(user_size,        
+                                     vm_map_page_mask(user_map)); /* hi end */

 
 

+       if ((flags & MAP_JIT) && ((flags & MAP_FIXED) || (flags & MAP_SHARED) || !(flags & MAP_ANON))){
+               return EINVAL;
+       }

        /*
         * Check for illegal addresses.  Watch out for address wrap... Note
         * that VM_*_ADDRESS are not constants due to casts (argh).
        /*
         * Check for illegal addresses.  Watch out for address wrap... Note
         * that VM_*_ADDRESS are not constants due to casts (argh).


@@ -267,8 +226,8 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
                 * should be aligned after adjustment by pageoff.
                 */
                user_addr -= pageoff;
                 * should be aligned after adjustment by pageoff.
                 */
                user_addr -= pageoff;

-               if (user_addr & PAGE_MASK)
-               return (EINVAL);
+               if (user_addr & vm_map_page_mask(user_map))
+                       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*/


@@ -280,14 +239,28 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
         * There should really be a pmap call to determine a reasonable
         * location.
         */
         * There should really be a pmap call to determine a reasonable
         * location.
         */

-       else if (addr < mach_vm_round_page(p->p_vmspace->vm_daddr + MAXDSIZ))
-               addr = mach_vm_round_page(p->p_vmspace->vm_daddr + MAXDSIZ);
+       else if (addr < vm_map_round_page(p->p_vmspace->vm_daddr + MAXDSIZ,
+                                         vm_map_page_mask(user_map)))
+               addr = vm_map_round_page(p->p_vmspace->vm_daddr + MAXDSIZ,
+                                        vm_map_page_mask(user_map));

 
 #endif
 
        alloc_flags = 0;
 
        if (flags & MAP_ANON) {
 
 #endif
 
        alloc_flags = 0;
 
        if (flags & MAP_ANON) {

+
+               maxprot = VM_PROT_ALL;
+#if CONFIG_MACF
+               /*
+                * Entitlement check.
+                */
+               error = mac_proc_check_map_anon(p, user_addr, user_size, prot, flags, &maxprot);
+               if (error) {
+                       return EINVAL;
+               }               
+#endif /* MAC */
+

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


@@ -297,7 +270,7 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
                         * Use "fd" to pass (some) Mach VM allocation flags,
                         * (see the VM_FLAGS_* definitions).
                         */
                         * Use "fd" to pass (some) Mach VM allocation flags,
                         * (see the VM_FLAGS_* definitions).
                         */

-                       alloc_flags = fd & (VM_FLAGS_ALIAS_MASK |
+                       alloc_flags = fd & (VM_FLAGS_ALIAS_MASK | VM_FLAGS_SUPERPAGE_MASK |

                                            VM_FLAGS_PURGABLE);
                        if (alloc_flags != fd) {
                                /* reject if there are any extra flags */
                                            VM_FLAGS_PURGABLE);
                        if (alloc_flags != fd) {
                                /* reject if there are any extra flags */


@@ -306,13 +279,15 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
                }
                        
                handle = NULL;
                }
                        
                handle = NULL;

-               maxprot = VM_PROT_ALL;

                file_pos = 0;
                mapanon = 1;
        } else {
                struct vnode_attr va;
                vfs_context_t ctx = vfs_context_current();
 
                file_pos = 0;
                mapanon = 1;
        } else {
                struct vnode_attr va;
                vfs_context_t ctx = vfs_context_current();
 

+               if (flags & MAP_JIT)
+                       return EINVAL;
+

                /*
                 * 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.


@@ -321,7 +296,8 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
                if (err)
                        return(err);
                fpref = 1;
                if (err)
                        return(err);
                fpref = 1;

-               if(fp->f_fglob->fg_type == DTYPE_PSXSHM) {
+               switch (FILEGLOB_DTYPE(fp->f_fglob)) {
+               case DTYPE_PSXSHM:

                        uap->addr = (user_addr_t)user_addr;
                        uap->len = (user_size_t)user_size;
                        uap->prot = prot;
                        uap->addr = (user_addr_t)user_addr;
                        uap->len = (user_size_t)user_size;
                        uap->prot = prot;


@@ -329,9 +305,9 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
                        uap->pos = file_pos;
                        error = pshm_mmap(p, uap, retval, fp, (off_t)pageoff);
                        goto bad;
                        uap->pos = file_pos;
                        error = pshm_mmap(p, uap, retval, fp, (off_t)pageoff);
                        goto bad;

-               }
-
-               if (fp->f_fglob->fg_type != DTYPE_VNODE) {
+               case DTYPE_VNODE:
+                       break;
+               default:

                        error = EINVAL;
                        goto bad;
                }
                        error = EINVAL;
                        goto bad;
                }


@@ -357,7 +333,7 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
                        VATTR_SET_ACTIVE(&va, va_access_time);
                        vnode_setattr(vp, &va, ctx);
                }
                        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
                 * SunOS).
                /*
                 * XXX hack to handle use of /dev/zero to map anon memory (ala
                 * SunOS).


@@ -393,7 +369,12 @@ mmap(proc_t 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
                                         *
                                        /*
                                         * check for write access
                                         *


@@ -429,6 +410,18 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
                                goto bad;
                        }
 #endif /* MAC */
                                goto bad;
                        }
 #endif /* MAC */

+
+#if CONFIG_PROTECT
+                       {
+                               error = cp_handle_vnop(vp, CP_READ_ACCESS | CP_WRITE_ACCESS, 0);
+                               if (error) {
+                                       (void) vnode_put(vp);
+                                       goto bad;
+                               }
+                       }
+#endif /* CONFIG_PROTECT */
+
+

                }
        }
 
                }
        }
 


@@ -443,22 +436,23 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
         *      We bend a little - round the start and end addresses
         *      to the nearest page boundary.
         */
         *      We bend a little - round the start and end addresses
         *      to the nearest page boundary.
         */

-       user_size = mach_vm_round_page(user_size);
+       user_size = vm_map_round_page(user_size,
+                                     vm_map_page_mask(user_map));

 
 

-       if (file_pos & PAGE_MASK_64) {
+       if (file_pos & vm_map_page_mask(user_map)) {

                if (!mapanon)
                        (void)vnode_put(vp);
                error = EINVAL;
                goto bad;
        }
 
                if (!mapanon)
                        (void)vnode_put(vp);
                error = EINVAL;
                goto bad;
        }
 

-       user_map = current_map();
-

        if ((flags & MAP_FIXED) == 0) {
                alloc_flags |= VM_FLAGS_ANYWHERE;
        if ((flags & MAP_FIXED) == 0) {
                alloc_flags |= VM_FLAGS_ANYWHERE;

-               user_addr = mach_vm_round_page(user_addr);
+               user_addr = vm_map_round_page(user_addr,
+                                             vm_map_page_mask(user_map));

        } else {
        } else {

-               if (user_addr != mach_vm_trunc_page(user_addr)) {
+               if (user_addr != vm_map_trunc_page(user_addr,
+                                                  vm_map_page_mask(user_map))) {

                        if (!mapanon)
                                (void)vnode_put(vp);
                        error = EINVAL;
                        if (!mapanon)
                                (void)vnode_put(vp);
                        error = EINVAL;


@@ -481,11 +475,14 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
        if (flags & MAP_NOCACHE)
                alloc_flags |= VM_FLAGS_NO_CACHE;
 
        if (flags & MAP_NOCACHE)
                alloc_flags |= VM_FLAGS_NO_CACHE;
 

+       if (flags & MAP_JIT){
+               alloc_flags |= VM_FLAGS_MAP_JIT;
+       }

        /*
         * 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)
 #ifdef notyet
 /* Hmm .. */
 #if defined(VM_PROT_READ_IS_EXEC)


@@ -502,7 +499,7 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
                if (maxprot & (VM_PROT_EXECUTE | VM_PROT_WRITE))
                        maxprot |= VM_PROT_READ;
 #endif /* radar 3777787 */
                if (maxprot & (VM_PROT_EXECUTE | VM_PROT_WRITE))
                        maxprot |= VM_PROT_READ;
 #endif /* radar 3777787 */

-
+map_anon_retry:

                result = vm_map_enter_mem_object(user_map,
                                                 &user_addr, user_size,
                                                 0, alloc_flags,
                result = vm_map_enter_mem_object(user_map,
                                                 &user_addr, user_size,
                                                 0, alloc_flags,


@@ -511,12 +508,32 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
                                                 (flags & MAP_SHARED) ?
                                                 VM_INHERIT_SHARE : 
                                                 VM_INHERIT_DEFAULT);
                                                 (flags & MAP_SHARED) ?
                                                 VM_INHERIT_SHARE : 
                                                 VM_INHERIT_DEFAULT);

-               if (result != KERN_SUCCESS) 
-                               goto out;
+
+               /* If a non-binding address was specified for this anonymous
+                * mapping, retry the mapping with a zero base
+                * in the event the mapping operation failed due to
+                * lack of space between the address and the map's maximum.
+                */
+               if ((result == KERN_NO_SPACE) && ((flags & MAP_FIXED) == 0) && user_addr && (num_retries++ == 0)) {
+                       user_addr = vm_map_page_size(user_map);
+                       goto map_anon_retry;
+               }

        } else {
        } else {

-               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;


@@ -551,33 +568,31 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
                if (maxprot & (VM_PROT_EXECUTE | VM_PROT_WRITE))
                        maxprot |= VM_PROT_READ;
 #endif /* radar 3777787 */
                if (maxprot & (VM_PROT_EXECUTE | VM_PROT_WRITE))
                        maxprot |= VM_PROT_READ;
 #endif /* radar 3777787 */

-
-               result = vm_map_enter_mem_object(user_map,
+map_file_retry:
+               result = vm_map_enter_mem_object_control(user_map,

                                                 &user_addr, user_size,
                                                 0, alloc_flags,
                                                 &user_addr, user_size,
                                                 0, alloc_flags,

-                                                (ipc_port_t)pager, file_pos,
+                                                control, file_pos,

                                                 docow, prot, maxprot, 
                                                 (flags & MAP_SHARED) ?
                                                 VM_INHERIT_SHARE : 
                                                 VM_INHERIT_DEFAULT);
 
                                                 docow, prot, maxprot, 
                                                 (flags & MAP_SHARED) ?
                                                 VM_INHERIT_SHARE : 
                                                 VM_INHERIT_DEFAULT);
 

-               if (result != KERN_SUCCESS)  {
-                               (void)vnode_put(vp);
-                               goto out;
-               }
-
-               file_prot = prot & (PROT_READ | PROT_WRITE | PROT_EXEC);
-               if (docow) {
-                       /* private mapping: won't write to the file */
-                       file_prot &= ~PROT_WRITE;
+               /* If a non-binding address was specified for this file backed
+                * mapping, retry the mapping with a zero base
+                * in the event the mapping operation failed due to
+                * lack of space between the address and the map's maximum.
+                */
+               if ((result == KERN_NO_SPACE) && ((flags & MAP_FIXED) == 0) && user_addr && (num_retries++ == 0)) {
+                       user_addr = vm_map_page_size(user_map);
+                       goto map_file_retry;

                }
                }

-               (void) ubc_map(vp, file_prot);

        }
 
        }
 

-       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;


@@ -595,25 +610,32 @@ 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);
 
        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);
        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 proc_t p, struct msync_args *uap, 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
 {
        __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 register_t *retval)
+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;


@@ -622,12 +644,11 @@ msync_nocancel(__unused proc_t p, struct msync_nocancel_args *uap, __unused regi
        int rv;
        vm_sync_t sync_flags=0;
 
        int rv;
        vm_sync_t sync_flags=0;
 

+       user_map = current_map();

        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);
        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) {
+       if (addr & vm_map_page_mask(user_map)) {

                /* UNIX SPEC: user address is not page-aligned, return EINVAL */
                return EINVAL;
        }
                /* UNIX SPEC: user address is not page-aligned, return EINVAL */
                return EINVAL;
        }


@@ -663,7 +684,6 @@ msync_nocancel(__unused proc_t p, struct msync_nocancel_args *uap, __unused regi
 
        sync_flags |= VM_SYNC_CONTIGUOUS;       /* complain if holes */
 
 
        sync_flags |= VM_SYNC_CONTIGUOUS;       /* complain if holes */
 

-       user_map = current_map();

        rv = mach_vm_msync(user_map, addr, size, sync_flags);
 
        switch (rv) {
        rv = mach_vm_msync(user_map, addr, size, sync_flags);
 
        switch (rv) {


@@ -681,26 +701,21 @@ msync_nocancel(__unused proc_t p, struct msync_nocancel_args *uap, __unused regi
 
 
 int
 
 
 int

-mremap(void)
-{
-       /* Not yet implemented */
-       return (ENOTSUP);
-}
-
-int
-munmap(__unused proc_t 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_offset_t        user_addr;

-       mach_vm_size_t  user_size;
-       kern_return_t   result;
+       mach_vm_size_t          user_size;
+       kern_return_t           result;
+       vm_map_t                user_map;

 
 

+       user_map = current_map();

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

-       if (user_addr & PAGE_MASK_64) {
+       if (user_addr & vm_map_page_mask(user_map)) {

                /* UNIX SPEC: user address is not page-aligned, return EINVAL */
                return EINVAL;
        }
                /* UNIX SPEC: user address is not page-aligned, return EINVAL */
                return EINVAL;
        }


@@ -713,7 +728,7 @@ munmap(__unused proc_t p, struct munmap_args *uap, __unused register_t *retval)
                return EINVAL;
        }
 
                return EINVAL;
        }
 

-       result = mach_vm_deallocate(current_map(), user_addr, user_size);
+       result = mach_vm_deallocate(user_map, user_addr, user_size);

        if (result != KERN_SUCCESS) {
                return(EINVAL);
        }
        if (result != KERN_SUCCESS) {
                return(EINVAL);
        }


@@ -721,7 +736,7 @@ munmap(__unused proc_t p, struct munmap_args *uap, __unused register_t *retval)
 }
 
 int
 }
 
 int

-mprotect(__unused proc_t 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;
 {
        register vm_prot_t prot;
        mach_vm_offset_t        user_addr;


@@ -734,13 +749,14 @@ mprotect(__unused proc_t p, struct mprotect_args *uap, __unused register_t *retv
 
        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_map = current_map();

        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;

-       prot = (vm_prot_t)(uap->prot & VM_PROT_ALL);
+       prot = (vm_prot_t)(uap->prot & (VM_PROT_ALL | VM_PROT_TRUSTED));

 
 

-       if (user_addr & PAGE_MASK_64) {
+       if (user_addr & vm_map_page_mask(user_map)) {

                /* UNIX SPEC: user address is not page-aligned, return EINVAL */
                return EINVAL;
        }
                /* UNIX SPEC: user address is not page-aligned, return EINVAL */
                return EINVAL;
        }


@@ -758,8 +774,6 @@ mprotect(__unused proc_t p, struct mprotect_args *uap, __unused register_t *retv
                prot |= VM_PROT_READ;
 #endif /* 3936456 */
 
                prot |= VM_PROT_READ;
 #endif /* 3936456 */
 

-       user_map = current_map();
-

 #if CONFIG_MACF
        /*
         * The MAC check for mprotect is of limited use for 2 reasons:
 #if CONFIG_MACF
        /*
         * The MAC check for mprotect is of limited use for 2 reasons:


@@ -776,6 +790,37 @@ mprotect(__unused proc_t p, struct mprotect_args *uap, __unused register_t *retv
        if (error)
                return (error);
 #endif
        if (error)
                return (error);
 #endif

+
+       if(prot & VM_PROT_TRUSTED) {
+#if CONFIG_DYNAMIC_CODE_SIGNING
+               /* CODE SIGNING ENFORCEMENT - JIT support */
+               /* The special protection value VM_PROT_TRUSTED requests that we treat
+                * this page as if it had a valid code signature.
+                * If this is enabled, there MUST be a MAC policy implementing the 
+                * mac_proc_check_mprotect() hook above. Otherwise, Codesigning will be
+                * compromised because the check would always succeed and thusly any
+                * process could sign dynamically. */
+               result = vm_map_sign(
+                       user_map, 
+                       vm_map_trunc_page(user_addr,
+                                         vm_map_page_mask(user_map)),
+                       vm_map_round_page(user_addr+user_size,
+                                         vm_map_page_mask(user_map)));
+               switch (result) {
+                       case KERN_SUCCESS:
+                               break;
+                       case KERN_INVALID_ADDRESS:
+                               /* UNIX SPEC: for an invalid address range, return ENOMEM */
+                               return ENOMEM;
+                       default:
+                               return EINVAL;
+               }
+#else
+               return ENOTSUP;
+#endif
+       }
+       prot &= ~VM_PROT_TRUSTED;
+       

        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) {


@@ -792,7 +837,7 @@ mprotect(__unused proc_t p, struct mprotect_args *uap, __unused register_t *retv
 
 
 int
 
 
 int

-minherit(__unused proc_t 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;


@@ -802,7 +847,7 @@ minherit(__unused proc_t p, struct minherit_args *uap, __unused register_t *retv
 
        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;


@@ -821,7 +866,7 @@ minherit(__unused proc_t p, struct minherit_args *uap, __unused register_t *retv
 }
 
 int
 }
 
 int

-madvise(__unused proc_t 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;


@@ -849,6 +894,21 @@ madvise(__unused proc_t p, struct madvise_args *uap, __unused register_t *retval
                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);
        }


@@ -860,17 +920,19 @@ madvise(__unused proc_t p, struct madvise_args *uap, __unused register_t *retval
 
        result = mach_vm_behavior_set(user_map, start, size, new_behavior);
        switch (result) {
 
        result = mach_vm_behavior_set(user_map, start, size, new_behavior);
        switch (result) {

-               case KERN_SUCCESS:
-                       return (0);
-               case KERN_INVALID_ADDRESS:
-                       return (ENOMEM);
+       case KERN_SUCCESS:
+               return 0;
+       case KERN_INVALID_ADDRESS:
+               return EINVAL;
+       case KERN_NO_SPACE:     
+               return ENOMEM;

        }
 
        }
 

-       return (EINVAL);
+       return EINVAL;

 }
 
 int
 }
 
 int

-mincore(__unused proc_t 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;


@@ -890,8 +952,10 @@ mincore(__unused proc_t p, struct mincore_args *uap, __unused register_t *retval
         * Make sure that the addresses presented are valid for user
         * mode.
         */
         * Make sure that the addresses presented are valid for user
         * mode.
         */

-       first_addr = addr = mach_vm_trunc_page(uap->addr);
-       end = addr + mach_vm_round_page(uap->len);
+       first_addr = addr = vm_map_trunc_page(uap->addr,
+                                             vm_map_page_mask(map));
+       end = addr + vm_map_round_page(uap->len,
+                                      vm_map_page_mask(map));

 
        if (end < addr)
                return (EINVAL);
 
        if (end < addr)
                return (EINVAL);


@@ -970,7 +1034,7 @@ mincore(__unused proc_t p, struct mincore_args *uap, __unused register_t *retval
 }
 
 int
 }
 
 int

-mlock(__unused proc_t 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;


@@ -990,10 +1054,10 @@ mlock(__unused proc_t p, struct mlock_args *uap, __unused register_t *retvalval)
        if (size == 0)
                return (0);
 
        if (size == 0)
                return (0);
 

-       pageoff = (addr & PAGE_MASK);
-       addr -= pageoff;
-       size = vm_map_round_page(size+pageoff);

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

+       pageoff = (addr & vm_map_page_mask(user_map));
+       addr -= pageoff;
+       size = vm_map_round_page(size+pageoff, vm_map_page_mask(user_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);
 
        /* 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);


@@ -1007,7 +1071,7 @@ mlock(__unused proc_t p, struct mlock_args *uap, __unused register_t *retvalval)
 }
 
 int
 }
 
 int

-munlock(__unused proc_t 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;


@@ -1028,39 +1092,17 @@ munlock(__unused proc_t p, struct munlock_args *uap, __unused register_t *retval
 
 
 int
 
 
 int

-mlockall(__unused proc_t 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 proc_t 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 proc_t p, __unused struct obreak_args *uap, __unused register_t *retval)
-{
-       /* Not implemented, obsolete */
-       return (ENOMEM);
-}
-
-int    both;
-
-int
-ovadvise(__unused proc_t 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)


@@ -1073,7 +1115,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);


@@ -1097,10 +1139,13 @@ map_fd_funneled(
        vm_offset_t     map_addr=0;
        vm_size_t       map_size;
        int             err=0;
        vm_offset_t     map_addr=0;
        vm_size_t       map_size;
        int             err=0;

+       vm_prot_t       maxprot = VM_PROT_ALL;

        vm_map_t        my_map;
        proc_t          p = current_proc();
        struct vnode_attr vattr;
 
        vm_map_t        my_map;
        proc_t          p = current_proc();
        struct vnode_attr vattr;
 

+       my_map = current_map();
+

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


@@ -1109,7 +1154,7 @@ map_fd_funneled(
        if (err)
                return(err);
        
        if (err)
                return(err);
        

-       if (fp->f_fglob->fg_type != DTYPE_VNODE){
+       if (FILEGLOB_DTYPE(fp->f_fglob) != DTYPE_VNODE) {

                err = KERN_INVALID_ARGUMENT;
                goto bad;
        }
                err = KERN_INVALID_ARGUMENT;
                goto bad;
        }


@@ -1130,6 +1175,26 @@ map_fd_funneled(
                goto bad;
        }
 
                goto bad;
        }
 

+#if CONFIG_MACF
+       err = mac_file_check_mmap(vfs_context_ucred(vfs_context_current()),
+                       fp->f_fglob, VM_PROT_DEFAULT, MAP_FILE, &maxprot);
+       if (err) {
+               (void)vnode_put(vp);
+               goto bad;
+       }
+#endif /* MAC */
+
+#if CONFIG_PROTECT
+       /* check for content protection access */
+       {
+               err = cp_handle_vnop(vp, CP_READ_ACCESS | CP_WRITE_ACCESS, 0);
+               if (err != 0) { 
+                       (void) vnode_put(vp);
+                       goto bad;
+               }
+       }
+#endif /* CONFIG_PROTECT */
+

        AUDIT_ARG(vnpath, vp, ARG_VNODE1);
 
        /*
        AUDIT_ARG(vnpath, vp, ARG_VNODE1);
 
        /*


@@ -1142,13 +1207,13 @@ map_fd_funneled(
                vnode_setattr(vp, &vattr, vfs_context_current());
        }
        
                vnode_setattr(vp, &vattr, vfs_context_current());
        }
        

-       if (offset & PAGE_MASK_64) {
+       if (offset & vm_map_page_mask(my_map)) {

                printf("map_fd: file offset not page aligned(%d : %s)\n",p->p_pid, p->p_comm);
                (void)vnode_put(vp);
                err = KERN_INVALID_ARGUMENT;
                goto bad;
        }
                printf("map_fd: file offset not page aligned(%d : %s)\n",p->p_pid, p->p_comm);
                (void)vnode_put(vp);
                err = KERN_INVALID_ARGUMENT;
                goto bad;
        }

-       map_size = round_page(size);
+       map_size = vm_map_round_page(size, vm_map_page_mask(my_map));

 
        /*
         * Allow user to map in a zero length file.
 
        /*
         * Allow user to map in a zero length file.


@@ -1168,14 +1233,11 @@ map_fd_funneled(
                goto bad;
        }
 
                goto bad;
        }
 

-
-       my_map = current_map();
-

        result = vm_map_64(
                        my_map,
                        &map_addr, map_size, (vm_offset_t)0, 
                        VM_FLAGS_ANYWHERE, pager, offset, TRUE,
        result = vm_map_64(
                        my_map,
                        &map_addr, map_size, (vm_offset_t)0, 
                        VM_FLAGS_ANYWHERE, pager, offset, TRUE,

-                       VM_PROT_DEFAULT, VM_PROT_ALL,
+                       VM_PROT_DEFAULT, maxprot,

                        VM_INHERIT_DEFAULT);
        if (result != KERN_SUCCESS) {
                (void)vnode_put(vp);
                        VM_INHERIT_DEFAULT);
        if (result != KERN_SUCCESS) {
                (void)vnode_put(vp);


@@ -1185,11 +1247,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,


@@ -1203,9 +1266,13 @@ map_fd_funneled(
                                       (vm_map_size_t)map_size, TRUE, &tmp);
                if (result != KERN_SUCCESS) {
                        
                                       (vm_map_size_t)map_size, TRUE, &tmp);
                if (result != KERN_SUCCESS) {
                        

-                       (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_page_mask(my_map)),
+                               vm_map_round_page(map_addr + map_size,
+                                                 vm_map_page_mask(my_map)),
+                               VM_MAP_NO_FLAGS);

                        (void)vnode_put(vp);
                        err = result;
                        goto bad;
                        (void)vnode_put(vp);
                        err = result;
                        goto bad;


@@ -1220,10 +1287,16 @@ map_fd_funneled(
                        goto bad;
                }
        } else {
                        goto bad;
                }
        } else {

-               if (copyout(&map_addr, CAST_USER_ADDR_T(va), sizeof (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);
+               // 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_page_mask(my_map)),
+                               vm_map_round_page(map_addr + map_size,
+                                                 vm_map_page_mask(my_map)),
+                               VM_MAP_NO_FLAGS);

                        (void)vnode_put(vp);
                        err = KERN_INVALID_ADDRESS;
                        goto bad;
                        (void)vnode_put(vp);
                        err = KERN_INVALID_ADDRESS;
                        goto bad;


@@ -1231,7 +1304,6 @@ map_fd_funneled(
        }
 
        ubc_setthreadcred(vp, current_proc(), current_thread());
        }
 
        ubc_setthreadcred(vp, current_proc(), current_thread());

-       (void)ubc_map(vp, (PROT_READ | PROT_EXEC));

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