xnu-6153.61.1.tar.gz

[apple/xnu.git] / bsd / vm / vm_unix.c

diff --git a/bsd/vm/vm_unix.c b/bsd/vm/vm_unix.c
index df5f607ae13951edf46b0fe9dd269ee21af94f57..b9626cc5ef259622374eff21c633b0c76e253318 100644 (file)
--- a/bsd/vm/vm_unix.c
+++ b/bsd/vm/vm_unix.c
@@ -2,7 +2,7 @@
  * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * Copyright (c) 2000-2018 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


@@ -11,10 +11,10 @@
  * 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.
  * 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.
  * 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
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,


@@ -22,10 +22,10 @@
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.

- * 
+ *

  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */

-/* 
+/*

  * Mach Operating System
  * Copyright (c) 1987 Carnegie-Mellon University
  * All rights reserved.  The CMU software License Agreement specifies
  * Mach Operating System
  * Copyright (c) 1987 Carnegie-Mellon University
  * All rights reserved.  The CMU software License Agreement specifies


@@ -98,11 +98,17 @@
 #include <vm/vm_protos.h>
 
 #include <sys/kern_memorystatus.h>
 #include <vm/vm_protos.h>
 
 #include <sys/kern_memorystatus.h>

+#include <sys/kern_memorystatus_freeze.h>

 
 #if CONFIG_MACF
 #include <security/mac_framework.h>
 #endif
 
 
 #if CONFIG_MACF
 #include <security/mac_framework.h>
 #endif
 

+#if CONFIG_CSR
+#include <sys/csr.h>
+#endif /* CONFIG_CSR */
+#include <IOKit/IOBSD.h>
+

 int _shared_region_map_and_slide(struct proc*, int, unsigned int, struct shared_file_mapping_np*, uint32_t, user_addr_t, user_addr_t);
 int shared_region_copyin_mappings(struct proc*, user_addr_t, unsigned int, struct shared_file_mapping_np *);
 
 int _shared_region_map_and_slide(struct proc*, int, unsigned int, struct shared_file_mapping_np*, uint32_t, user_addr_t, user_addr_t);
 int shared_region_copyin_mappings(struct proc*, user_addr_t, unsigned int, struct shared_file_mapping_np *);
 


@@ -120,25 +126,27 @@ static int
 sysctl_kmem_alloc_contig SYSCTL_HANDLER_ARGS
 {
 #pragma unused(arg1, arg2)
 sysctl_kmem_alloc_contig SYSCTL_HANDLER_ARGS
 {
 #pragma unused(arg1, arg2)

-       vm_offset_t     kaddr;
-       kern_return_t   kr;
-       int     error = 0;
-       int     size = 0;
+       vm_offset_t     kaddr;
+       kern_return_t   kr;
+       int     error = 0;
+       int     size = 0;

 
        error = sysctl_handle_int(oidp, &size, 0, req);
 
        error = sysctl_handle_int(oidp, &size, 0, req);

-       if (error || !req->newptr)
-               return (error);
+       if (error || !req->newptr) {
+               return error;
+       }

 
        kr = kmem_alloc_contig(kernel_map, &kaddr, (vm_size_t)size, 0, 0, 0, 0, VM_KERN_MEMORY_IOKIT);
 
 
        kr = kmem_alloc_contig(kernel_map, &kaddr, (vm_size_t)size, 0, 0, 0, 0, VM_KERN_MEMORY_IOKIT);
 

-       if (kr == KERN_SUCCESS)
+       if (kr == KERN_SUCCESS) {

                kmem_free(kernel_map, kaddr, size);
                kmem_free(kernel_map, kaddr, size);

+       }

 
        return error;
 }
 
 
        return error;
 }
 

-SYSCTL_PROC(_vm, OID_AUTO, kmem_alloc_contig, CTLTYPE_INT|CTLFLAG_WR|CTLFLAG_LOCKED|CTLFLAG_MASKED,
-           0, 0, &sysctl_kmem_alloc_contig, "I", "");
+SYSCTL_PROC(_vm, OID_AUTO, kmem_alloc_contig, CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_LOCKED | CTLFLAG_MASKED,
+    0, 0, &sysctl_kmem_alloc_contig, "I", "");

 
 extern int vm_region_footprint;
 SYSCTL_INT(_vm, OID_AUTO, region_footprint, CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED, &vm_region_footprint, 0, "");
 
 extern int vm_region_footprint;
 SYSCTL_INT(_vm, OID_AUTO, region_footprint, CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED, &vm_region_footprint, 0, "");


@@ -146,11 +154,11 @@ static int
 sysctl_vm_self_region_footprint SYSCTL_HANDLER_ARGS
 {
 #pragma unused(arg1, arg2, oidp)
 sysctl_vm_self_region_footprint SYSCTL_HANDLER_ARGS
 {
 #pragma unused(arg1, arg2, oidp)

-       int     error = 0;
-       int     value;
+       int     error = 0;
+       int     value;

 
        value = task_self_region_footprint();
 
        value = task_self_region_footprint();

-       error = SYSCTL_OUT(req, &value, sizeof (int));
+       error = SYSCTL_OUT(req, &value, sizeof(int));

        if (error) {
                return error;
        }
        if (error) {
                return error;
        }


@@ -159,14 +167,14 @@ sysctl_vm_self_region_footprint SYSCTL_HANDLER_ARGS
                return 0;
        }
 
                return 0;
        }
 

-       error = SYSCTL_IN(req, &value, sizeof (int));
+       error = SYSCTL_IN(req, &value, sizeof(int));

        if (error) {
        if (error) {

-               return (error);
+               return error;

        }
        task_self_region_footprint_set(value);
        return 0;
 }
        }
        task_self_region_footprint_set(value);
        return 0;
 }

-SYSCTL_PROC(_vm, OID_AUTO, self_region_footprint, CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY|CTLFLAG_LOCKED|CTLFLAG_MASKED, 0, 0, &sysctl_vm_self_region_footprint, "I", "");
+SYSCTL_PROC(_vm, OID_AUTO, self_region_footprint, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED | CTLFLAG_MASKED, 0, 0, &sysctl_vm_self_region_footprint, "I", "");

 
 #endif /* DEVELOPMENT || DEBUG */
 
 
 #endif /* DEVELOPMENT || DEBUG */
 


@@ -224,6 +232,10 @@ SYSCTL_UINT(_vm, OID_AUTO, user_tte_pages, CTLFLAG_RD | CTLFLAG_LOCKED, &inuse_u
 SYSCTL_UINT(_vm, OID_AUTO, kernel_tte_pages, CTLFLAG_RD | CTLFLAG_LOCKED, &inuse_kernel_ttepages_count, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, user_pte_pages, CTLFLAG_RD | CTLFLAG_LOCKED, &inuse_user_ptepages_count, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, kernel_pte_pages, CTLFLAG_RD | CTLFLAG_LOCKED, &inuse_kernel_ptepages_count, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, kernel_tte_pages, CTLFLAG_RD | CTLFLAG_LOCKED, &inuse_kernel_ttepages_count, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, user_pte_pages, CTLFLAG_RD | CTLFLAG_LOCKED, &inuse_user_ptepages_count, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, kernel_pte_pages, CTLFLAG_RD | CTLFLAG_LOCKED, &inuse_kernel_ptepages_count, 0, "");

+#if DEVELOPMENT || DEBUG
+extern unsigned long pmap_asid_flushes;
+SYSCTL_ULONG(_vm, OID_AUTO, pmap_asid_flushes, CTLFLAG_RD | CTLFLAG_LOCKED, &pmap_asid_flushes, "");
+#endif

 #endif /* __arm__ || __arm64__ */
 
 #if __arm64__
 #endif /* __arm__ || __arm64__ */
 
 #if __arm64__


@@ -250,12 +262,13 @@ vm_shadow_max SYSCTL_HANDLER_ARGS
 #pragma unused(arg1, arg2, oidp)
        int value = 0;
 
 #pragma unused(arg1, arg2, oidp)
        int value = 0;
 

-       if (vm_shadow_max_enabled)
+       if (vm_shadow_max_enabled) {

                value = proc_shadow_max();
                value = proc_shadow_max();

+       }

 
        return SYSCTL_OUT(req, &value, sizeof(value));
 }
 
        return SYSCTL_OUT(req, &value, sizeof(value));
 }

-SYSCTL_PROC(_vm, OID_AUTO, vm_shadow_max, CTLTYPE_INT|CTLFLAG_RD|CTLFLAG_LOCKED,
+SYSCTL_PROC(_vm, OID_AUTO, vm_shadow_max, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,

     0, 0, &vm_shadow_max, "I", "");
 
 SYSCTL_INT(_vm, OID_AUTO, vm_shadow_max_enabled, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_shadow_max_enabled, 0, "");
     0, 0, &vm_shadow_max, "I", "");
 
 SYSCTL_INT(_vm, OID_AUTO, vm_shadow_max_enabled, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_shadow_max_enabled, 0, "");


@@ -276,12 +289,6 @@ extern int allow_stack_exec, allow_data_exec;
 SYSCTL_INT(_vm, OID_AUTO, allow_stack_exec, CTLFLAG_RW | CTLFLAG_LOCKED, &allow_stack_exec, 0, "");
 SYSCTL_INT(_vm, OID_AUTO, allow_data_exec, CTLFLAG_RW | CTLFLAG_LOCKED, &allow_data_exec, 0, "");
 
 SYSCTL_INT(_vm, OID_AUTO, allow_stack_exec, CTLFLAG_RW | CTLFLAG_LOCKED, &allow_stack_exec, 0, "");
 SYSCTL_INT(_vm, OID_AUTO, allow_data_exec, CTLFLAG_RW | CTLFLAG_LOCKED, &allow_data_exec, 0, "");
 

-#if __arm64__
-extern int fourk_binary_compatibility_unsafe;
-extern int fourk_binary_compatibility_allow_wx;
-SYSCTL_INT(_vm, OID_AUTO, fourk_binary_compatibility_unsafe, CTLFLAG_RW | CTLFLAG_LOCKED, &fourk_binary_compatibility_unsafe, 0, "");
-SYSCTL_INT(_vm, OID_AUTO, fourk_binary_compatibility_allow_wx, CTLFLAG_RW | CTLFLAG_LOCKED, &fourk_binary_compatibility_allow_wx, 0, "");
-#endif /* __arm64__ */

 #endif /* DEVELOPMENT || DEBUG */
 
 static const char *prot_values[] = {
 #endif /* DEVELOPMENT || DEBUG */
 
 static const char *prot_values[] = {


@@ -298,8 +305,8 @@ static const char *prot_values[] = {
 void
 log_stack_execution_failure(addr64_t vaddr, vm_prot_t prot)
 {
 void
 log_stack_execution_failure(addr64_t vaddr, vm_prot_t prot)
 {

-       printf("Data/Stack execution not permitted: %s[pid %d] at virtual address 0x%qx, protections were %s\n", 
-               current_proc()->p_comm, current_proc()->p_pid, vaddr, prot_values[prot & VM_PROT_ALL]);
+       printf("Data/Stack execution not permitted: %s[pid %d] at virtual address 0x%qx, protections were %s\n",
+           current_proc()->p_comm, current_proc()->p_pid, vaddr, prot_values[prot & VM_PROT_ALL]);

 }
 
 /*
 }
 
 /*


@@ -312,7 +319,7 @@ log_stack_execution_failure(addr64_t vaddr, vm_prot_t prot)
 int shared_region_unnest_logging = 1;
 
 SYSCTL_INT(_vm, OID_AUTO, shared_region_unnest_logging, CTLFLAG_RW | CTLFLAG_LOCKED,
 int shared_region_unnest_logging = 1;
 
 SYSCTL_INT(_vm, OID_AUTO, shared_region_unnest_logging, CTLFLAG_RW | CTLFLAG_LOCKED,

-          &shared_region_unnest_logging, 0, "");
+    &shared_region_unnest_logging, 0, "");

 
 int vm_shared_region_unnest_log_interval = 10;
 int shared_region_unnest_log_count_threshold = 5;
 
 int vm_shared_region_unnest_log_interval = 10;
 int shared_region_unnest_log_count_threshold = 5;


@@ -330,27 +337,39 @@ static char scdir_path[] = "/System/Library/Caches/com.apple.dyld/";
 #endif
 
 #ifndef SECURE_KERNEL
 #endif
 
 #ifndef SECURE_KERNEL

-SYSCTL_INT(_vm, OID_AUTO, enforce_shared_cache_dir, CTLFLAG_RW | CTLFLAG_LOCKED, &scdir_enforce, 0, "");
+static int sysctl_scdir_enforce SYSCTL_HANDLER_ARGS
+{
+#if CONFIG_CSR
+       if (csr_check(CSR_ALLOW_UNRESTRICTED_FS) != 0) {
+               printf("Failed attempt to set vm.enforce_shared_cache_dir sysctl\n");
+               return EPERM;
+       }
+#endif /* CONFIG_CSR */
+       return sysctl_handle_int(oidp, arg1, arg2, req);
+}
+
+SYSCTL_PROC(_vm, OID_AUTO, enforce_shared_cache_dir, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &scdir_enforce, 0, sysctl_scdir_enforce, "I", "");

 #endif
 
 /* These log rate throttling state variables aren't thread safe, but
  * are sufficient unto the task.
  */
 #endif
 
 /* These log rate throttling state variables aren't thread safe, but
  * are sufficient unto the task.
  */

-static int64_t last_unnest_log_time = 0; 
+static int64_t last_unnest_log_time = 0;

 static int shared_region_unnest_log_count = 0;
 
 void
 log_unnest_badness(
 static int shared_region_unnest_log_count = 0;
 
 void
 log_unnest_badness(

-       vm_map_t        m,
+       vm_map_t        m,

        vm_map_offset_t s,
        vm_map_offset_t e,
        vm_map_offset_t s,
        vm_map_offset_t e,

-       boolean_t       is_nested_map,
-       vm_map_offset_t lowest_unnestable_addr)
+       boolean_t       is_nested_map,
+       vm_map_offset_t lowest_unnestable_addr)

 {
 {

-       struct timeval  tv;
+       struct timeval  tv;

 
 

-       if (shared_region_unnest_logging == 0)
+       if (shared_region_unnest_logging == 0) {

                return;
                return;

+       }

 
        if (shared_region_unnest_logging <= 2 &&
            is_nested_map &&
 
        if (shared_region_unnest_logging <= 2 &&
            is_nested_map &&


@@ -366,8 +385,9 @@ log_unnest_badness(
                if ((tv.tv_sec - last_unnest_log_time) <
                    vm_shared_region_unnest_log_interval) {
                        if (shared_region_unnest_log_count++ >
                if ((tv.tv_sec - last_unnest_log_time) <
                    vm_shared_region_unnest_log_interval) {
                        if (shared_region_unnest_log_count++ >

-                           shared_region_unnest_log_count_threshold)
+                           shared_region_unnest_log_count_threshold) {

                                return;
                                return;

+                       }

                } else {
                        last_unnest_log_time = tv.tv_sec;
                        shared_region_unnest_log_count = 0;
                } else {
                        last_unnest_log_time = tv.tv_sec;
                        shared_region_unnest_log_count = 0;


@@ -375,58 +395,58 @@ log_unnest_badness(
        }
 
        DTRACE_VM4(log_unnest_badness,
        }
 
        DTRACE_VM4(log_unnest_badness,

-                  vm_map_t, m,
-                  vm_map_offset_t, s,
-                  vm_map_offset_t, e,
-                  vm_map_offset_t, lowest_unnestable_addr);
+           vm_map_t, m,
+           vm_map_offset_t, s,
+           vm_map_offset_t, e,
+           vm_map_offset_t, lowest_unnestable_addr);

        printf("%s[%d] triggered unnest of range 0x%qx->0x%qx of DYLD shared region in VM map %p. While not abnormal for debuggers, this increases system memory footprint until the target exits.\n", current_proc()->p_comm, current_proc()->p_pid, (uint64_t)s, (uint64_t)e, (void *) VM_KERNEL_ADDRPERM(m));
 }
 
 int
 useracc(
        printf("%s[%d] triggered unnest of range 0x%qx->0x%qx of DYLD shared region in VM map %p. While not abnormal for debuggers, this increases system memory footprint until the target exits.\n", current_proc()->p_comm, current_proc()->p_pid, (uint64_t)s, (uint64_t)e, (void *) VM_KERNEL_ADDRPERM(m));
 }
 
 int
 useracc(

-       user_addr_t     addr,
-       user_size_t     len,
-       int     prot)
+       user_addr_t     addr,
+       user_size_t     len,
+       int     prot)

 {
 {

-       vm_map_t        map;
+       vm_map_t        map;

 
        map = current_map();
 
        map = current_map();

-       return (vm_map_check_protection(
-                       map,
-                       vm_map_trunc_page(addr,
-                                         vm_map_page_mask(map)),
-                       vm_map_round_page(addr+len,
-                                         vm_map_page_mask(map)),
-                       prot == B_READ ? VM_PROT_READ : VM_PROT_WRITE));
+       return vm_map_check_protection(
+               map,
+               vm_map_trunc_page(addr,
+               vm_map_page_mask(map)),
+               vm_map_round_page(addr + len,
+               vm_map_page_mask(map)),
+               prot == B_READ ? VM_PROT_READ : VM_PROT_WRITE);

 }
 
 int
 vslock(
 }
 
 int
 vslock(

-       user_addr_t     addr,
-       user_size_t     len)
+       user_addr_t     addr,
+       user_size_t     len)

 {
 {

-       kern_return_t   kret;
-       vm_map_t        map;
+       kern_return_t   kret;
+       vm_map_t        map;

 
        map = current_map();
        kret = vm_map_wire_kernel(map,
 
        map = current_map();
        kret = vm_map_wire_kernel(map,

-                          vm_map_trunc_page(addr,
-                                            vm_map_page_mask(map)),
-                          vm_map_round_page(addr+len,
-                                            vm_map_page_mask(map)), 
-                          VM_PROT_READ | VM_PROT_WRITE, VM_KERN_MEMORY_BSD,
-                          FALSE);
+           vm_map_trunc_page(addr,
+           vm_map_page_mask(map)),
+           vm_map_round_page(addr + len,
+           vm_map_page_mask(map)),
+           VM_PROT_READ | VM_PROT_WRITE, VM_KERN_MEMORY_BSD,
+           FALSE);

 
        switch (kret) {
        case KERN_SUCCESS:
 
        switch (kret) {
        case KERN_SUCCESS:

-               return (0);
+               return 0;

        case KERN_INVALID_ADDRESS:
        case KERN_NO_SPACE:
        case KERN_INVALID_ADDRESS:
        case KERN_NO_SPACE:

-               return (ENOMEM);
+               return ENOMEM;

        case KERN_PROTECTION_FAILURE:
        case KERN_PROTECTION_FAILURE:

-               return (EACCES);
+               return EACCES;

        default:
        default:

-               return (EINVAL);
+               return EINVAL;

        }
 }
 
        }
 }
 


@@ -437,13 +457,13 @@ vsunlock(
        __unused int dirtied)
 {
 #if FIXME  /* [ */
        __unused int dirtied)
 {
 #if FIXME  /* [ */

-       pmap_t          pmap;
-       vm_page_t       pg;
-       vm_map_offset_t vaddr;
-       ppnum_t         paddr;
+       pmap_t          pmap;
+       vm_page_t       pg;
+       vm_map_offset_t vaddr;
+       ppnum_t         paddr;

 #endif  /* FIXME ] */
 #endif  /* FIXME ] */

-       kern_return_t   kret;
-       vm_map_t        map;
+       kern_return_t   kret;
+       vm_map_t        map;

 
        map = current_map();
 
 
        map = current_map();
 


@@ -451,33 +471,33 @@ vsunlock(
        if (dirtied) {
                pmap = get_task_pmap(current_task());
                for (vaddr = vm_map_trunc_page(addr, PAGE_MASK);
        if (dirtied) {
                pmap = get_task_pmap(current_task());
                for (vaddr = vm_map_trunc_page(addr, PAGE_MASK);

-                    vaddr < vm_map_round_page(addr+len, PAGE_MASK);
-                    vaddr += PAGE_SIZE) {
+                   vaddr < vm_map_round_page(addr + len, PAGE_MASK);
+                   vaddr += PAGE_SIZE) {

                        paddr = pmap_extract(pmap, vaddr);
                        pg = PHYS_TO_VM_PAGE(paddr);
                        vm_page_set_modified(pg);
                }
        }
 #endif  /* FIXME ] */
                        paddr = pmap_extract(pmap, vaddr);
                        pg = PHYS_TO_VM_PAGE(paddr);
                        vm_page_set_modified(pg);
                }
        }
 #endif  /* FIXME ] */

-#ifdef lint
+#ifdef  lint

        dirtied++;
        dirtied++;

-#endif /* lint */
+#endif  /* lint */

        kret = vm_map_unwire(map,
        kret = vm_map_unwire(map,

-                            vm_map_trunc_page(addr,
-                                              vm_map_page_mask(map)),
-                            vm_map_round_page(addr+len,
-                                              vm_map_page_mask(map)),
-                            FALSE);
+           vm_map_trunc_page(addr,
+           vm_map_page_mask(map)),
+           vm_map_round_page(addr + len,
+           vm_map_page_mask(map)),
+           FALSE);

        switch (kret) {
        case KERN_SUCCESS:
        switch (kret) {
        case KERN_SUCCESS:

-               return (0);
+               return 0;

        case KERN_INVALID_ADDRESS:
        case KERN_NO_SPACE:
        case KERN_INVALID_ADDRESS:
        case KERN_NO_SPACE:

-               return (ENOMEM);
+               return ENOMEM;

        case KERN_PROTECTION_FAILURE:
        case KERN_PROTECTION_FAILURE:

-               return (EACCES);
+               return EACCES;

        default:
        default:

-               return (EINVAL);
+               return EINVAL;

        }
 }
 
        }
 }
 


@@ -487,9 +507,9 @@ subyte(
        int byte)
 {
        char character;
        int byte)
 {
        char character;

-       
+

        character = (char)byte;
        character = (char)byte;

-       return (copyout((void *)&(character), addr, sizeof(char)) == 0 ? 0 : -1);
+       return copyout((void *)&(character), addr, sizeof(char)) == 0 ? 0 : -1;

 }
 
 int
 }
 
 int


@@ -498,27 +518,31 @@ suibyte(
        int byte)
 {
        char character;
        int byte)
 {
        char character;

-       
+

        character = (char)byte;
        character = (char)byte;

-       return (copyout((void *)&(character), addr, sizeof(char)) == 0 ? 0 : -1);
+       return copyout((void *)&(character), addr, sizeof(char)) == 0 ? 0 : -1;

 }
 
 }
 

-int fubyte(user_addr_t addr)
+int
+fubyte(user_addr_t addr)

 {
        unsigned char byte;
 
 {
        unsigned char byte;
 

-       if (copyin(addr, (void *) &byte, sizeof(char)))
-               return(-1);
-       return(byte);
+       if (copyin(addr, (void *) &byte, sizeof(char))) {
+               return -1;
+       }
+       return byte;

 }
 
 }
 

-int fuibyte(user_addr_t addr)
+int
+fuibyte(user_addr_t addr)

 {
        unsigned char byte;
 
 {
        unsigned char byte;
 

-       if (copyin(addr, (void *) &(byte), sizeof(char)))
-               return(-1);
-       return(byte);
+       if (copyin(addr, (void *) &(byte), sizeof(char))) {
+               return -1;
+       }
+       return byte;

 }
 
 int
 }
 
 int


@@ -526,16 +550,18 @@ suword(
        user_addr_t addr,
        long word)
 {
        user_addr_t addr,
        long word)
 {

-       return (copyout((void *) &word, addr, sizeof(int)) == 0 ? 0 : -1);
+       return copyout((void *) &word, addr, sizeof(int)) == 0 ? 0 : -1;

 }
 
 }
 

-long fuword(user_addr_t addr)
+long
+fuword(user_addr_t addr)

 {
        long word = 0;
 
 {
        long word = 0;
 

-       if (copyin(addr, (void *) &word, sizeof(int)))
-               return(-1);
-       return(word);
+       if (copyin(addr, (void *) &word, sizeof(int))) {
+               return -1;
+       }
+       return word;

 }
 
 /* suiword and fuiword are the same as suword and fuword, respectively */
 }
 
 /* suiword and fuiword are the same as suword and fuword, respectively */


@@ -545,16 +571,18 @@ suiword(
        user_addr_t addr,
        long word)
 {
        user_addr_t addr,
        long word)
 {

-       return (copyout((void *) &word, addr, sizeof(int)) == 0 ? 0 : -1);
+       return copyout((void *) &word, addr, sizeof(int)) == 0 ? 0 : -1;

 }
 
 }
 

-long fuiword(user_addr_t addr)
+long
+fuiword(user_addr_t addr)

 {
        long word = 0;
 
 {
        long word = 0;
 

-       if (copyin(addr, (void *) &word, sizeof(int)))
-               return(-1);
-       return(word);
+       if (copyin(addr, (void *) &word, sizeof(int))) {
+               return -1;
+       }
+       return word;

 }
 
 /*
 }
 
 /*


@@ -564,11 +592,10 @@ long fuiword(user_addr_t addr)
 int
 sulong(user_addr_t addr, int64_t word)
 {
 int
 sulong(user_addr_t addr, int64_t word)
 {

-

        if (IS_64BIT_PROCESS(current_proc())) {
        if (IS_64BIT_PROCESS(current_proc())) {

-               return(copyout((void *)&word, addr, sizeof(word)) == 0 ? 0 : -1);
+               return copyout((void *)&word, addr, sizeof(word)) == 0 ? 0 : -1;

        } else {
        } else {

-               return(suiword(addr, (long)word));
+               return suiword(addr, (long)word);

        }
 }
 
        }
 }
 


@@ -578,22 +605,22 @@ fulong(user_addr_t addr)
        int64_t longword;
 
        if (IS_64BIT_PROCESS(current_proc())) {
        int64_t longword;
 
        if (IS_64BIT_PROCESS(current_proc())) {

-               if (copyin(addr, (void *)&longword, sizeof(longword)) != 0)
-                       return(-1);
-               return(longword);
+               if (copyin(addr, (void *)&longword, sizeof(longword)) != 0) {
+                       return -1;
+               }
+               return longword;

        } else {
        } else {

-               return((int64_t)fuiword(addr));
+               return (int64_t)fuiword(addr);

        }
 }
 
 int
 suulong(user_addr_t addr, uint64_t uword)
 {
        }
 }
 
 int
 suulong(user_addr_t addr, uint64_t uword)
 {

-

        if (IS_64BIT_PROCESS(current_proc())) {
        if (IS_64BIT_PROCESS(current_proc())) {

-               return(copyout((void *)&uword, addr, sizeof(uword)) == 0 ? 0 : -1);
+               return copyout((void *)&uword, addr, sizeof(uword)) == 0 ? 0 : -1;

        } else {
        } else {

-               return(suiword(addr, (uint32_t)uword));
+               return suiword(addr, (uint32_t)uword);

        }
 }
 
        }
 }
 


@@ -603,33 +630,34 @@ fuulong(user_addr_t addr)
        uint64_t ulongword;
 
        if (IS_64BIT_PROCESS(current_proc())) {
        uint64_t ulongword;
 
        if (IS_64BIT_PROCESS(current_proc())) {

-               if (copyin(addr, (void *)&ulongword, sizeof(ulongword)) != 0)
-                       return(-1ULL);
-               return(ulongword);
+               if (copyin(addr, (void *)&ulongword, sizeof(ulongword)) != 0) {
+                       return -1ULL;
+               }
+               return ulongword;

        } else {
        } else {

-               return((uint64_t)fuiword(addr));
+               return (uint64_t)fuiword(addr);

        }
 }
 
 int
 swapon(__unused proc_t procp, __unused struct swapon_args *uap, __unused int *retval)
 {
        }
 }
 
 int
 swapon(__unused proc_t procp, __unused struct swapon_args *uap, __unused int *retval)
 {

-       return(ENOTSUP);
+       return ENOTSUP;

 }
 
 /*
  * pid_for_task
  *
 }
 
 /*
  * pid_for_task
  *

- * Find the BSD process ID for the Mach task associated with the given Mach port 
+ * Find the BSD process ID for the Mach task associated with the given Mach port

  * name
  *
  * Parameters: args            User argument descriptor (see below)
  *
  * Indirect parameters:        args->t         Mach port name
  * name
  *
  * Parameters: args            User argument descriptor (see below)
  *
  * Indirect parameters:        args->t         Mach port name

- *                     args->pid       Process ID (returned value; see below)
+ *                      args->pid      Process ID (returned value; see below)

  *
  * Returns:    KERL_SUCCESS    Success
  *
  * Returns:    KERL_SUCCESS    Success

- *             KERN_FAILURE    Not success           
+ *              KERN_FAILURE   Not success

  *
  * Implicit returns: args->pid         Process ID
  *
  *
  * Implicit returns: args->pid         Process ID
  *


@@ -638,12 +666,12 @@ kern_return_t
 pid_for_task(
        struct pid_for_task_args *args)
 {
 pid_for_task(
        struct pid_for_task_args *args)
 {

-       mach_port_name_t        t = args->t;
-       user_addr_t             pid_addr  = args->pid;  
+       mach_port_name_t        t = args->t;
+       user_addr_t             pid_addr  = args->pid;

        proc_t p;
        proc_t p;

-       task_t          t1;
-       int     pid = -1;
-       kern_return_t   err = KERN_SUCCESS;
+       task_t          t1;
+       int     pid = -1;
+       kern_return_t   err = KERN_SUCCESS;

 
        AUDIT_MACH_SYSCALL_ENTER(AUE_PIDFORTASK);
        AUDIT_ARG(mach_port1, t);
 
        AUDIT_MACH_SYSCALL_ENTER(AUE_PIDFORTASK);
        AUDIT_ARG(mach_port1, t);


@@ -661,7 +689,7 @@ pid_for_task(
                } else if (is_corpsetask(t1)) {
                        pid = task_pid(t1);
                        err = KERN_SUCCESS;
                } else if (is_corpsetask(t1)) {
                        pid = task_pid(t1);
                        err = KERN_SUCCESS;

-               }else {
+               } else {

                        err = KERN_FAILURE;
                }
        }
                        err = KERN_FAILURE;
                }
        }


@@ -670,10 +698,10 @@ pftout:
        AUDIT_ARG(pid, pid);
        (void) copyout((char *) &pid, pid_addr, sizeof(int));
        AUDIT_MACH_SYSCALL_EXIT(err);
        AUDIT_ARG(pid, pid);
        (void) copyout((char *) &pid, pid_addr, sizeof(int));
        AUDIT_MACH_SYSCALL_EXIT(err);

-       return(err);
+       return err;

 }
 
 }
 

-/* 
+/*

  *
  * tfp_policy = KERN_TFP_POLICY_DENY; Deny Mode: None allowed except for self
  * tfp_policy = KERN_TFP_POLICY_DEFAULT; default mode: all posix checks and upcall via task port for authentication
  *
  * tfp_policy = KERN_TFP_POLICY_DENY; Deny Mode: None allowed except for self
  * tfp_policy = KERN_TFP_POLICY_DEFAULT; default mode: all posix checks and upcall via task port for authentication


@@ -685,7 +713,7 @@ static  int tfp_policy = KERN_TFP_POLICY_DEFAULT;
  *     Routine:        task_for_pid_posix_check
  *     Purpose:
  *                     Verify that the current process should be allowed to
  *     Routine:        task_for_pid_posix_check
  *     Purpose:
  *                     Verify that the current process should be allowed to

- *                     get the target process's task port. This is only 
+ *                     get the target process's task port. This is only

  *                     permitted if:
  *                     - The current process is root
  *                     OR all of the following are true:
  *                     permitted if:
  *                     - The current process is root
  *                     OR all of the following are true:


@@ -703,7 +731,7 @@ task_for_pid_posix_check(proc_t target)
 {
        kauth_cred_t targetcred, mycred;
        uid_t myuid;
 {
        kauth_cred_t targetcred, mycred;
        uid_t myuid;

-       int allowed; 
+       int allowed;

 
        /* No task_for_pid on bad targets */
        if (target->p_stat == SZOMB) {
 
        /* No task_for_pid on bad targets */
        if (target->p_stat == SZOMB) {


@@ -714,18 +742,20 @@ task_for_pid_posix_check(proc_t target)
        myuid = kauth_cred_getuid(mycred);
 
        /* If we're running as root, the check passes */
        myuid = kauth_cred_getuid(mycred);
 
        /* If we're running as root, the check passes */

-       if (kauth_cred_issuser(mycred))
+       if (kauth_cred_issuser(mycred)) {

                return TRUE;
                return TRUE;

+       }

 
        /* We're allowed to get our own task port */
 
        /* We're allowed to get our own task port */

-       if (target == current_proc())
+       if (target == current_proc()) {

                return TRUE;
                return TRUE;

+       }

 
 

-       /* 
+       /*

         * Under DENY, only root can get another proc's task port,
         * so no more checks are needed.
         */
         * Under DENY, only root can get another proc's task port,
         * so no more checks are needed.
         */

-       if (tfp_policy == KERN_TFP_POLICY_DENY) { 
+       if (tfp_policy == KERN_TFP_POLICY_DENY) {

                return FALSE;
        }
 
                return FALSE;
        }
 


@@ -733,16 +763,16 @@ task_for_pid_posix_check(proc_t target)
        allowed = TRUE;
 
        /* Do target's ruid, euid, and saved uid match my euid? */
        allowed = TRUE;
 
        /* Do target's ruid, euid, and saved uid match my euid? */

-       if ((kauth_cred_getuid(targetcred) != myuid) || 
-                       (kauth_cred_getruid(targetcred) != myuid) ||
-                       (kauth_cred_getsvuid(targetcred) != myuid)) {
+       if ((kauth_cred_getuid(targetcred) != myuid) ||
+           (kauth_cred_getruid(targetcred) != myuid) ||
+           (kauth_cred_getsvuid(targetcred) != myuid)) {

                allowed = FALSE;
                goto out;
        }
 
        /* Are target's groups a subset of my groups? */
        if (kauth_cred_gid_subset(targetcred, mycred, &allowed) ||
                allowed = FALSE;
                goto out;
        }
 
        /* Are target's groups a subset of my groups? */
        if (kauth_cred_gid_subset(targetcred, mycred, &allowed) ||

-                       allowed == 0) {
+           allowed == 0) {

                allowed = FALSE;
                goto out;
        }
                allowed = FALSE;
                goto out;
        }


@@ -752,7 +782,7 @@ task_for_pid_posix_check(proc_t target)
                allowed = FALSE;
                goto out;
        }
                allowed = FALSE;
                goto out;
        }

-       
+

 out:
        kauth_cred_unref(&targetcred);
        return allowed;
 out:
        kauth_cred_unref(&targetcred);
        return allowed;


@@ -765,7 +795,8 @@ out:
  *                     we made. Function declared non inline to be visible in
  *                     stackshots and spindumps as well as debugging.
  */
  *                     we made. Function declared non inline to be visible in
  *                     stackshots and spindumps as well as debugging.
  */

-__attribute__((noinline)) int __KERNEL_WAITING_ON_TASKGATED_CHECK_ACCESS_UPCALL__(
+__attribute__((noinline)) int
+__KERNEL_WAITING_ON_TASKGATED_CHECK_ACCESS_UPCALL__(

        mach_port_t task_access_port, int32_t calling_pid, uint32_t calling_gid, int32_t target_pid)
 {
        return check_task_access(task_access_port, calling_pid, calling_gid, target_pid);
        mach_port_t task_access_port, int32_t calling_pid, uint32_t calling_gid, int32_t target_pid)
 {
        return check_task_access(task_access_port, calling_pid, calling_gid, target_pid);


@@ -788,14 +819,14 @@ kern_return_t
 task_for_pid(
        struct task_for_pid_args *args)
 {
 task_for_pid(
        struct task_for_pid_args *args)
 {

-       mach_port_name_t        target_tport = args->target_tport;
-       int                     pid = args->pid;
-       user_addr_t             task_addr = args->t;
-       proc_t                  p = PROC_NULL;
-       task_t                  t1 = TASK_NULL;
-       task_t                  task = TASK_NULL;
-       mach_port_name_t        tret = MACH_PORT_NULL;
-       ipc_port_t              tfpport = MACH_PORT_NULL;
+       mach_port_name_t        target_tport = args->target_tport;
+       int                     pid = args->pid;
+       user_addr_t             task_addr = args->t;
+       proc_t                  p = PROC_NULL;
+       task_t                  t1 = TASK_NULL;
+       task_t                  task = TASK_NULL;
+       mach_port_name_t        tret = MACH_PORT_NULL;
+       ipc_port_t              tfpport = MACH_PORT_NULL;

        void * sright;
        int error = 0;
 
        void * sright;
        int error = 0;
 


@@ -805,17 +836,17 @@ task_for_pid(
 
        /* Always check if pid == 0 */
        if (pid == 0) {
 
        /* Always check if pid == 0 */
        if (pid == 0) {

-               (void ) copyout((char *)&t1, task_addr, sizeof(mach_port_name_t));
+               (void) copyout((char *)&t1, task_addr, sizeof(mach_port_name_t));

                AUDIT_MACH_SYSCALL_EXIT(KERN_FAILURE);
                AUDIT_MACH_SYSCALL_EXIT(KERN_FAILURE);

-               return(KERN_FAILURE);
+               return KERN_FAILURE;

        }
 
        t1 = port_name_to_task(target_tport);
        if (t1 == TASK_NULL) {
                (void) copyout((char *)&t1, task_addr, sizeof(mach_port_name_t));
                AUDIT_MACH_SYSCALL_EXIT(KERN_FAILURE);
        }
 
        t1 = port_name_to_task(target_tport);
        if (t1 == TASK_NULL) {
                (void) copyout((char *)&t1, task_addr, sizeof(mach_port_name_t));
                AUDIT_MACH_SYSCALL_EXIT(KERN_FAILURE);

-               return(KERN_FAILURE);
-       } 
+               return KERN_FAILURE;
+       }

 
 
        p = proc_find(pid);
 
 
        p = proc_find(pid);


@@ -852,10 +883,9 @@ task_for_pid(
 
        /* If we aren't root and target's task access port is set... */
        if (!kauth_cred_issuser(kauth_cred_get()) &&
 
        /* If we aren't root and target's task access port is set... */
        if (!kauth_cred_issuser(kauth_cred_get()) &&

-               p != current_proc() &&
-               (task_get_task_access_port(task, &tfpport) == 0) &&
-               (tfpport != IPC_PORT_NULL)) {
-
+           p != current_proc() &&
+           (task_get_task_access_port(task, &tfpport) == 0) &&
+           (tfpport != IPC_PORT_NULL)) {

                if (tfpport == IPC_PORT_DEAD) {
                        error = KERN_PROTECTION_FAILURE;
                        goto tfpout;
                if (tfpport == IPC_PORT_DEAD) {
                        error = KERN_PROTECTION_FAILURE;
                        goto tfpout;


@@ -873,10 +903,11 @@ task_for_pid(
                error = __KERNEL_WAITING_ON_TASKGATED_CHECK_ACCESS_UPCALL__(tfpport, proc_selfpid(), kauth_getgid(), pid);
 
                if (error != MACH_MSG_SUCCESS) {
                error = __KERNEL_WAITING_ON_TASKGATED_CHECK_ACCESS_UPCALL__(tfpport, proc_selfpid(), kauth_getgid(), pid);
 
                if (error != MACH_MSG_SUCCESS) {

-                       if (error == MACH_RCV_INTERRUPTED)
+                       if (error == MACH_RCV_INTERRUPTED) {

                                error = KERN_ABORTED;
                                error = KERN_ABORTED;

-                       else
+                       } else {

                                error = KERN_FAILURE;
                                error = KERN_FAILURE;

+                       }

                        goto tfpout;
                }
        }
                        goto tfpout;
                }
        }


@@ -897,8 +928,8 @@ task_for_pid(
        /* task ref consumed by convert_task_to_port */
        task = TASK_NULL;
        tret = ipc_port_copyout_send(
        /* task ref consumed by convert_task_to_port */
        task = TASK_NULL;
        tret = ipc_port_copyout_send(

-                       sright,
-                       get_task_ipcspace(current_task()));
+               sright,
+               get_task_ipcspace(current_task()));

 
        error = KERN_SUCCESS;
 
 
        error = KERN_SUCCESS;
 


@@ -913,10 +944,11 @@ tfpout:
        if (task != TASK_NULL) {
                task_deallocate(task);
        }
        if (task != TASK_NULL) {
                task_deallocate(task);
        }

-       if (p != PROC_NULL)
+       if (p != PROC_NULL) {

                proc_rele(p);
                proc_rele(p);

+       }

        AUDIT_MACH_SYSCALL_EXIT(error);
        AUDIT_MACH_SYSCALL_EXIT(error);

-       return(error);
+       return error;

 }
 
 /*
 }
 
 /*


@@ -935,12 +967,12 @@ kern_return_t
 task_name_for_pid(
        struct task_name_for_pid_args *args)
 {
 task_name_for_pid(
        struct task_name_for_pid_args *args)
 {

-       mach_port_name_t        target_tport = args->target_tport;
-       int                     pid = args->pid;
-       user_addr_t             task_addr = args->t;
-       proc_t          p = PROC_NULL;
-       task_t          t1;
-       mach_port_name_t        tret;
+       mach_port_name_t        target_tport = args->target_tport;
+       int                     pid = args->pid;
+       user_addr_t             task_addr = args->t;
+       proc_t          p = PROC_NULL;
+       task_t          t1;
+       mach_port_name_t        tret;

        void * sright;
        int error = 0, refheld = 0;
        kauth_cred_t target_cred;
        void * sright;
        int error = 0, refheld = 0;
        kauth_cred_t target_cred;


@@ -953,8 +985,8 @@ task_name_for_pid(
        if (t1 == TASK_NULL) {
                (void) copyout((char *)&t1, task_addr, sizeof(mach_port_name_t));
                AUDIT_MACH_SYSCALL_EXIT(KERN_FAILURE);
        if (t1 == TASK_NULL) {
                (void) copyout((char *)&t1, task_addr, sizeof(mach_port_name_t));
                AUDIT_MACH_SYSCALL_EXIT(KERN_FAILURE);

-               return(KERN_FAILURE);
-       } 
+               return KERN_FAILURE;
+       }

 
        p = proc_find(pid);
        if (p != PROC_NULL) {
 
        p = proc_find(pid);
        if (p != PROC_NULL) {


@@ -964,24 +996,24 @@ task_name_for_pid(
 
                if ((p->p_stat != SZOMB)
                    && ((current_proc() == p)
 
                if ((p->p_stat != SZOMB)
                    && ((current_proc() == p)

-                       || kauth_cred_issuser(kauth_cred_get()) 
-                       || ((kauth_cred_getuid(target_cred) == kauth_cred_getuid(kauth_cred_get())) && 
-                           ((kauth_cred_getruid(target_cred) == kauth_getruid()))))) {
-
+                   || kauth_cred_issuser(kauth_cred_get())
+                   || ((kauth_cred_getuid(target_cred) == kauth_cred_getuid(kauth_cred_get())) &&
+                   ((kauth_cred_getruid(target_cred) == kauth_getruid()))))) {

                        if (p->task != TASK_NULL) {
                                task_reference(p->task);
 #if CONFIG_MACF
                        if (p->task != TASK_NULL) {
                                task_reference(p->task);
 #if CONFIG_MACF

-                               error = mac_proc_check_get_task_name(kauth_cred_get(),  p);
+                               error = mac_proc_check_get_task_name(kauth_cred_get(), p);

                                if (error) {
                                        task_deallocate(p->task);
                                        goto noperm;
                                }
 #endif
                                sright = (void *)convert_task_name_to_port(p->task);
                                if (error) {
                                        task_deallocate(p->task);
                                        goto noperm;
                                }
 #endif
                                sright = (void *)convert_task_name_to_port(p->task);

-                               tret = ipc_port_copyout_send(sright, 
-                                               get_task_ipcspace(current_task()));
-                       } else
+                               tret = ipc_port_copyout_send(sright,
+                                   get_task_ipcspace(current_task()));
+                       } else {

                                tret  = MACH_PORT_NULL;
                                tret  = MACH_PORT_NULL;

+                       }

 
                        AUDIT_ARG(mach_port2, tret);
                        (void) copyout((char *)&tret, task_addr, sizeof(mach_port_name_t));
 
                        AUDIT_ARG(mach_port2, tret);
                        (void) copyout((char *)&tret, task_addr, sizeof(mach_port_name_t));


@@ -994,26 +1026,29 @@ task_name_for_pid(
 #if CONFIG_MACF
 noperm:
 #endif
 #if CONFIG_MACF
 noperm:
 #endif

-    task_deallocate(t1);
+       task_deallocate(t1);

        tret = MACH_PORT_NULL;
        (void) copyout((char *) &tret, task_addr, sizeof(mach_port_name_t));
        error = KERN_FAILURE;
 tnfpout:
        tret = MACH_PORT_NULL;
        (void) copyout((char *) &tret, task_addr, sizeof(mach_port_name_t));
        error = KERN_FAILURE;
 tnfpout:

-       if (refheld != 0)
+       if (refheld != 0) {

                kauth_cred_unref(&target_cred);
                kauth_cred_unref(&target_cred);

-       if (p != PROC_NULL)
+       }
+       if (p != PROC_NULL) {

                proc_rele(p);
                proc_rele(p);

+       }

        AUDIT_MACH_SYSCALL_EXIT(error);
        AUDIT_MACH_SYSCALL_EXIT(error);

-       return(error);
+       return error;

 }
 
 kern_return_t
 pid_suspend(struct proc *p __unused, struct pid_suspend_args *args, int *ret)
 {
 }
 
 kern_return_t
 pid_suspend(struct proc *p __unused, struct pid_suspend_args *args, int *ret)
 {

-       task_t  target = NULL;
-       proc_t  targetproc = PROC_NULL;
-       int     pid = args->pid;
-       int     error = 0;
+       task_t  target = NULL;
+       proc_t  targetproc = PROC_NULL;
+       int     pid = args->pid;
+       int     error = 0;
+       mach_port_t tfpport = MACH_PORT_NULL;

 
 #if CONFIG_MACF
        error = mac_proc_check_suspend_resume(p, MAC_PROC_CHECK_SUSPEND);
 
 #if CONFIG_MACF
        error = mac_proc_check_suspend_resume(p, MAC_PROC_CHECK_SUSPEND);


@@ -1034,7 +1069,8 @@ pid_suspend(struct proc *p __unused, struct pid_suspend_args *args, int *ret)
                goto out;
        }
 
                goto out;
        }
 

-       if (!task_for_pid_posix_check(targetproc)) {
+       if (!task_for_pid_posix_check(targetproc) &&
+           !IOTaskHasEntitlement(current_task(), PROCESS_RESUME_SUSPEND_ENTITLEMENT)) {

                error = EPERM;
                goto out;
        }
                error = EPERM;
                goto out;
        }


@@ -1042,14 +1078,11 @@ pid_suspend(struct proc *p __unused, struct pid_suspend_args *args, int *ret)
        target = targetproc->task;
 #ifndef CONFIG_EMBEDDED
        if (target != TASK_NULL) {
        target = targetproc->task;
 #ifndef CONFIG_EMBEDDED
        if (target != TASK_NULL) {

-               mach_port_t tfpport;
-

                /* If we aren't root and target's task access port is set... */
                if (!kauth_cred_issuser(kauth_cred_get()) &&
                /* If we aren't root and target's task access port is set... */
                if (!kauth_cred_issuser(kauth_cred_get()) &&

-                       targetproc != current_proc() &&
-                       (task_get_task_access_port(target, &tfpport) == 0) &&
-                       (tfpport != IPC_PORT_NULL)) {
-
+                   targetproc != current_proc() &&
+                   (task_get_task_access_port(target, &tfpport) == 0) &&
+                   (tfpport != IPC_PORT_NULL)) {

                        if (tfpport == IPC_PORT_DEAD) {
                                error = EACCES;
                                goto out;
                        if (tfpport == IPC_PORT_DEAD) {
                                error = EACCES;
                                goto out;


@@ -1059,10 +1092,11 @@ pid_suspend(struct proc *p __unused, struct pid_suspend_args *args, int *ret)
                        error = __KERNEL_WAITING_ON_TASKGATED_CHECK_ACCESS_UPCALL__(tfpport, proc_selfpid(), kauth_getgid(), pid);
 
                        if (error != MACH_MSG_SUCCESS) {
                        error = __KERNEL_WAITING_ON_TASKGATED_CHECK_ACCESS_UPCALL__(tfpport, proc_selfpid(), kauth_getgid(), pid);
 
                        if (error != MACH_MSG_SUCCESS) {

-                               if (error == MACH_RCV_INTERRUPTED)
+                               if (error == MACH_RCV_INTERRUPTED) {

                                        error = EINTR;
                                        error = EINTR;

-                               else
+                               } else {

                                        error = EPERM;
                                        error = EPERM;

+                               }

                                goto out;
                        }
                }
                                goto out;
                        }
                }


@@ -1087,19 +1121,160 @@ pid_suspend(struct proc *p __unused, struct pid_suspend_args *args, int *ret)
        task_deallocate(target);
 
 out:
        task_deallocate(target);
 
 out:

-       if (targetproc != PROC_NULL)
+       if (tfpport != IPC_PORT_NULL) {
+               ipc_port_release_send(tfpport);
+       }
+
+       if (targetproc != PROC_NULL) {

                proc_rele(targetproc);
                proc_rele(targetproc);

+       }

        *ret = error;
        return error;
 }
 
        *ret = error;
        return error;
 }
 

+kern_return_t
+debug_control_port_for_pid(struct debug_control_port_for_pid_args *args)
+{
+       mach_port_name_t        target_tport = args->target_tport;
+       int                     pid = args->pid;
+       user_addr_t             task_addr = args->t;
+       proc_t                  p = PROC_NULL;
+       task_t                  t1 = TASK_NULL;
+       task_t                  task = TASK_NULL;
+       mach_port_name_t        tret = MACH_PORT_NULL;
+       ipc_port_t              tfpport = MACH_PORT_NULL;
+       ipc_port_t              sright = NULL;
+       int                     error = 0;
+
+
+       AUDIT_MACH_SYSCALL_ENTER(AUE_DBGPORTFORPID);
+       AUDIT_ARG(pid, pid);
+       AUDIT_ARG(mach_port1, target_tport);
+
+       /* Always check if pid == 0 */
+       if (pid == 0) {
+               (void) copyout((char *)&t1, task_addr, sizeof(mach_port_name_t));
+               AUDIT_MACH_SYSCALL_EXIT(KERN_FAILURE);
+               return KERN_FAILURE;
+       }
+
+       t1 = port_name_to_task(target_tport);
+       if (t1 == TASK_NULL) {
+               (void) copyout((char *)&t1, task_addr, sizeof(mach_port_name_t));
+               AUDIT_MACH_SYSCALL_EXIT(KERN_FAILURE);
+               return KERN_FAILURE;
+       }
+
+
+       p = proc_find(pid);
+       if (p == PROC_NULL) {
+               error = KERN_FAILURE;
+               goto tfpout;
+       }
+
+#if CONFIG_AUDIT
+       AUDIT_ARG(process, p);
+#endif
+
+       if (!(task_for_pid_posix_check(p))) {
+               error = KERN_FAILURE;
+               goto tfpout;
+       }
+
+       if (p->task == TASK_NULL) {
+               error = KERN_SUCCESS;
+               goto tfpout;
+       }
+
+       /* Grab a task reference since the proc ref might be dropped if an upcall to task access server is made */
+       task = p->task;
+       task_reference(task);
+
+
+       if (!IOTaskHasEntitlement(current_task(), DEBUG_PORT_ENTITLEMENT)) {
+#if CONFIG_MACF
+               error = mac_proc_check_get_task(kauth_cred_get(), p);
+               if (error) {
+                       error = KERN_FAILURE;
+                       goto tfpout;
+               }
+#endif
+
+               /* If we aren't root and target's task access port is set... */
+               if (!kauth_cred_issuser(kauth_cred_get()) &&
+                   p != current_proc() &&
+                   (task_get_task_access_port(task, &tfpport) == 0) &&
+                   (tfpport != IPC_PORT_NULL)) {
+                       if (tfpport == IPC_PORT_DEAD) {
+                               error = KERN_PROTECTION_FAILURE;
+                               goto tfpout;
+                       }
+
+                       /*
+                        * Drop the proc_find proc ref before making an upcall
+                        * to taskgated, since holding a proc_find
+                        * ref while making an upcall can cause deadlock.
+                        */
+                       proc_rele(p);
+                       p = PROC_NULL;
+
+                       /* Call up to the task access server */
+                       error = __KERNEL_WAITING_ON_TASKGATED_CHECK_ACCESS_UPCALL__(tfpport, proc_selfpid(), kauth_getgid(), pid);
+
+                       if (error != MACH_MSG_SUCCESS) {
+                               if (error == MACH_RCV_INTERRUPTED) {
+                                       error = KERN_ABORTED;
+                               } else {
+                                       error = KERN_FAILURE;
+                               }
+                               goto tfpout;
+                       }
+               }
+       }
+
+       /* Check if the task has been corpsified */
+       if (is_corpsetask(task)) {
+               error = KERN_FAILURE;
+               goto tfpout;
+       }
+
+       error = task_get_debug_control_port(task, &sright);
+       if (error != KERN_SUCCESS) {
+               goto tfpout;
+       }
+
+       tret = ipc_port_copyout_send(
+               sright,
+               get_task_ipcspace(current_task()));
+
+       error = KERN_SUCCESS;
+
+tfpout:
+       task_deallocate(t1);
+       AUDIT_ARG(mach_port2, tret);
+       (void) copyout((char *) &tret, task_addr, sizeof(mach_port_name_t));
+
+       if (tfpport != IPC_PORT_NULL) {
+               ipc_port_release_send(tfpport);
+       }
+       if (task != TASK_NULL) {
+               task_deallocate(task);
+       }
+       if (p != PROC_NULL) {
+               proc_rele(p);
+       }
+       AUDIT_MACH_SYSCALL_EXIT(error);
+       return error;
+}
+

 kern_return_t
 pid_resume(struct proc *p __unused, struct pid_resume_args *args, int *ret)
 {
 kern_return_t
 pid_resume(struct proc *p __unused, struct pid_resume_args *args, int *ret)
 {

-       task_t  target = NULL;
-       proc_t  targetproc = PROC_NULL;
-       int     pid = args->pid;
-       int     error = 0;
+       task_t  target = NULL;
+       proc_t  targetproc = PROC_NULL;
+       int     pid = args->pid;
+       int     error = 0;
+       mach_port_t tfpport = MACH_PORT_NULL;

 
 #if CONFIG_MACF
        error = mac_proc_check_suspend_resume(p, MAC_PROC_CHECK_RESUME);
 
 #if CONFIG_MACF
        error = mac_proc_check_suspend_resume(p, MAC_PROC_CHECK_RESUME);


@@ -1120,7 +1295,8 @@ pid_resume(struct proc *p __unused, struct pid_resume_args *args, int *ret)
                goto out;
        }
 
                goto out;
        }
 

-       if (!task_for_pid_posix_check(targetproc)) {
+       if (!task_for_pid_posix_check(targetproc) &&
+           !IOTaskHasEntitlement(current_task(), PROCESS_RESUME_SUSPEND_ENTITLEMENT)) {

                error = EPERM;
                goto out;
        }
                error = EPERM;
                goto out;
        }


@@ -1128,14 +1304,11 @@ pid_resume(struct proc *p __unused, struct pid_resume_args *args, int *ret)
        target = targetproc->task;
 #ifndef CONFIG_EMBEDDED
        if (target != TASK_NULL) {
        target = targetproc->task;
 #ifndef CONFIG_EMBEDDED
        if (target != TASK_NULL) {

-               mach_port_t tfpport;
-

                /* If we aren't root and target's task access port is set... */
                if (!kauth_cred_issuser(kauth_cred_get()) &&
                /* If we aren't root and target's task access port is set... */
                if (!kauth_cred_issuser(kauth_cred_get()) &&

-                       targetproc != current_proc() &&
-                       (task_get_task_access_port(target, &tfpport) == 0) &&
-                       (tfpport != IPC_PORT_NULL)) {
-
+                   targetproc != current_proc() &&
+                   (task_get_task_access_port(target, &tfpport) == 0) &&
+                   (tfpport != IPC_PORT_NULL)) {

                        if (tfpport == IPC_PORT_DEAD) {
                                error = EACCES;
                                goto out;
                        if (tfpport == IPC_PORT_DEAD) {
                                error = EACCES;
                                goto out;


@@ -1145,10 +1318,11 @@ pid_resume(struct proc *p __unused, struct pid_resume_args *args, int *ret)
                        error = __KERNEL_WAITING_ON_TASKGATED_CHECK_ACCESS_UPCALL__(tfpport, proc_selfpid(), kauth_getgid(), pid);
 
                        if (error != MACH_MSG_SUCCESS) {
                        error = __KERNEL_WAITING_ON_TASKGATED_CHECK_ACCESS_UPCALL__(tfpport, proc_selfpid(), kauth_getgid(), pid);
 
                        if (error != MACH_MSG_SUCCESS) {

-                               if (error == MACH_RCV_INTERRUPTED)
+                               if (error == MACH_RCV_INTERRUPTED) {

                                        error = EINTR;
                                        error = EINTR;

-                               else
+                               } else {

                                        error = EPERM;
                                        error = EPERM;

+                               }

                                goto out;
                        }
                }
                                goto out;
                        }
                }


@@ -1175,17 +1349,23 @@ pid_resume(struct proc *p __unused, struct pid_resume_args *args, int *ret)
                        if (error == KERN_MEMORY_ERROR) {
                                psignal(targetproc, SIGKILL);
                                error = EIO;
                        if (error == KERN_MEMORY_ERROR) {
                                psignal(targetproc, SIGKILL);
                                error = EIO;

-                       } else
+                       } else {

                                error = EPERM;
                                error = EPERM;

+                       }

                }
        }
                }
        }

-       
+

        task_deallocate(target);
 
 out:
        task_deallocate(target);
 
 out:

-       if (targetproc != PROC_NULL)
+       if (tfpport != IPC_PORT_NULL) {
+               ipc_port_release_send(tfpport);
+       }
+
+       if (targetproc != PROC_NULL) {

                proc_rele(targetproc);
                proc_rele(targetproc);

-       
+       }
+

        *ret = error;
        return error;
 }
        *ret = error;
        return error;
 }


@@ -1199,9 +1379,9 @@ out:
 kern_return_t
 pid_hibernate(struct proc *p __unused, struct pid_hibernate_args *args, int *ret)
 {
 kern_return_t
 pid_hibernate(struct proc *p __unused, struct pid_hibernate_args *args, int *ret)
 {

-       int     error = 0;
-       proc_t  targetproc = PROC_NULL;
-       int     pid = args->pid;
+       int     error = 0;
+       proc_t  targetproc = PROC_NULL;
+       int     pid = args->pid;

 
 #ifndef CONFIG_FREEZE
        #pragma unused(pid)
 
 #ifndef CONFIG_FREEZE
        #pragma unused(pid)


@@ -1245,8 +1425,9 @@ out:
 
 #endif /* CONFIG_FREEZE */
 
 
 #endif /* CONFIG_FREEZE */
 

-       if (targetproc != PROC_NULL)
+       if (targetproc != PROC_NULL) {

                proc_rele(targetproc);
                proc_rele(targetproc);

+       }

        *ret = error;
        return error;
 }
        *ret = error;
        return error;
 }


@@ -1256,7 +1437,7 @@ out:
 int
 networking_memstatus_callout(proc_t p, uint32_t status)
 {
 int
 networking_memstatus_callout(proc_t p, uint32_t status)
 {

-       struct filedesc *fdp;
+       struct filedesc *fdp;

        int i;
 
        /*
        int i;
 
        /*


@@ -1270,7 +1451,7 @@ networking_memstatus_callout(proc_t p, uint32_t status)
        proc_fdlock(p);
        fdp = p->p_fd;
        for (i = 0; i < fdp->fd_nfiles; i++) {
        proc_fdlock(p);
        fdp = p->p_fd;
        for (i = 0; i < fdp->fd_nfiles; i++) {

-               struct fileproc *fp;
+               struct fileproc *fp;

 
                fp = fdp->fd_ofiles[i];
                if (fp == NULL || (fdp->fd_ofileflags[i] & UF_RESERVED) != 0) {
 
                fp = fdp->fd_ofiles[i];
                if (fp == NULL || (fdp->fd_ofileflags[i] & UF_RESERVED) != 0) {


@@ -1289,7 +1470,7 @@ networking_memstatus_callout(proc_t p, uint32_t status)
        }
        proc_fdunlock(p);
 
        }
        proc_fdunlock(p);
 

-       return (1);
+       return 1;

 }
 
 
 }
 
 


@@ -1299,13 +1480,13 @@ networking_defunct_callout(proc_t p, void *arg)
        struct pid_shutdown_sockets_args *args = arg;
        int pid = args->pid;
        int level = args->level;
        struct pid_shutdown_sockets_args *args = arg;
        int pid = args->pid;
        int level = args->level;

-       struct filedesc *fdp;
+       struct filedesc *fdp;

        int i;
 
        proc_fdlock(p);
        fdp = p->p_fd;
        for (i = 0; i < fdp->fd_nfiles; i++) {
        int i;
 
        proc_fdlock(p);
        fdp = p->p_fd;
        for (i = 0; i < fdp->fd_nfiles; i++) {

-               struct fileproc *fp = fdp->fd_ofiles[i];
+               struct fileproc *fp = fdp->fd_ofiles[i];

                struct fileglob *fg;
 
                if (fp == NULL || (fdp->fd_ofileflags[i] & UF_RESERVED) != 0) {
                struct fileglob *fg;
 
                if (fp == NULL || (fdp->fd_ofileflags[i] & UF_RESERVED) != 0) {


@@ -1316,7 +1497,7 @@ networking_defunct_callout(proc_t p, void *arg)
                switch (FILEGLOB_DTYPE(fg)) {
                case DTYPE_SOCKET: {
                        struct socket *so = (struct socket *)fg->fg_data;
                switch (FILEGLOB_DTYPE(fg)) {
                case DTYPE_SOCKET: {
                        struct socket *so = (struct socket *)fg->fg_data;

-                       if (p->p_pid == pid || so->last_pid == pid || 
+                       if (p->p_pid == pid || so->last_pid == pid ||

                            ((so->so_flags & SOF_DELEGATED) && so->e_pid == pid)) {
                                /* Call networking stack with socket and level */
                                (void) socket_defunct(p, so, level);
                            ((so->so_flags & SOF_DELEGATED) && so->e_pid == pid)) {
                                /* Call networking stack with socket and level */
                                (void) socket_defunct(p, so, level);


@@ -1339,16 +1520,16 @@ networking_defunct_callout(proc_t p, void *arg)
 
        proc_fdunlock(p);
 
 
        proc_fdunlock(p);
 

-       return (PROC_RETURNED);
+       return PROC_RETURNED;

 }
 
 int
 pid_shutdown_sockets(struct proc *p __unused, struct pid_shutdown_sockets_args *args, int *ret)
 {
 }
 
 int
 pid_shutdown_sockets(struct proc *p __unused, struct pid_shutdown_sockets_args *args, int *ret)
 {

-       int                             error = 0;
-       proc_t                          targetproc = PROC_NULL;
-       int                             pid = args->pid;
-       int                             level = args->level;
+       int                             error = 0;
+       proc_t                          targetproc = PROC_NULL;
+       int                             pid = args->pid;
+       int                             level = args->level;

 
        if (level != SHUTDOWN_SOCKET_LEVEL_DISCONNECT_SVC &&
            level != SHUTDOWN_SOCKET_LEVEL_DISCONNECT_ALL) {
 
        if (level != SHUTDOWN_SOCKET_LEVEL_DISCONNECT_SVC &&
            level != SHUTDOWN_SOCKET_LEVEL_DISCONNECT_ALL) {


@@ -1370,7 +1551,8 @@ pid_shutdown_sockets(struct proc *p __unused, struct pid_shutdown_sockets_args *
                goto out;
        }
 
                goto out;
        }
 

-       if (!task_for_pid_posix_check(targetproc)) {
+       if (!task_for_pid_posix_check(targetproc) &&
+           !IOTaskHasEntitlement(current_task(), PROCESS_RESUME_SUSPEND_ENTITLEMENT)) {

                error = EPERM;
                goto out;
        }
                error = EPERM;
                goto out;
        }


@@ -1379,8 +1561,9 @@ pid_shutdown_sockets(struct proc *p __unused, struct pid_shutdown_sockets_args *
            networking_defunct_callout, args, NULL, NULL);
 
 out:
            networking_defunct_callout, args, NULL, NULL);
 
 out:

-       if (targetproc != PROC_NULL)
+       if (targetproc != PROC_NULL) {

                proc_rele(targetproc);
                proc_rele(targetproc);

+       }

        *ret = error;
        return error;
 }
        *ret = error;
        return error;
 }


@@ -1391,27 +1574,29 @@ static int
 sysctl_settfp_policy(__unused struct sysctl_oid *oidp, void *arg1,
     __unused int arg2, struct sysctl_req *req)
 {
 sysctl_settfp_policy(__unused struct sysctl_oid *oidp, void *arg1,
     __unused int arg2, struct sysctl_req *req)
 {

-    int error = 0;
+       int error = 0;

        int new_value;
 
        int new_value;
 

-    error = SYSCTL_OUT(req, arg1, sizeof(int));
-    if (error || req->newptr == USER_ADDR_NULL)
-        return(error);
+       error = SYSCTL_OUT(req, arg1, sizeof(int));
+       if (error || req->newptr == USER_ADDR_NULL) {
+               return error;
+       }

 
 

-       if (!kauth_cred_issuser(kauth_cred_get()))
-               return(EPERM);
+       if (!kauth_cred_issuser(kauth_cred_get())) {
+               return EPERM;
+       }

 
        if ((error = SYSCTL_IN(req, &new_value, sizeof(int)))) {
                goto out;
        }
 
        if ((error = SYSCTL_IN(req, &new_value, sizeof(int)))) {
                goto out;
        }

-       if ((new_value == KERN_TFP_POLICY_DENY) 
-               || (new_value == KERN_TFP_POLICY_DEFAULT))
-                       tfp_policy = new_value;
-       else
-                       error = EINVAL;         
+       if ((new_value == KERN_TFP_POLICY_DENY)
+           || (new_value == KERN_TFP_POLICY_DEFAULT)) {
+               tfp_policy = new_value;
+       } else {
+               error = EINVAL;
+       }

 out:
 out:

-    return(error);
-
+       return error;

 }
 
 #if defined(SECURE_KERNEL)
 }
 
 #if defined(SECURE_KERNEL)


@@ -1424,14 +1609,14 @@ SYSCTL_INT(_kern, OID_AUTO, secure_kernel, CTLFLAG_RD | CTLFLAG_LOCKED, &kern_se
 
 SYSCTL_NODE(_kern, KERN_TFP, tfp, CTLFLAG_RW | CTLFLAG_LOCKED, 0, "tfp");
 SYSCTL_PROC(_kern_tfp, KERN_TFP_POLICY, policy, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
 
 SYSCTL_NODE(_kern, KERN_TFP, tfp, CTLFLAG_RW | CTLFLAG_LOCKED, 0, "tfp");
 SYSCTL_PROC(_kern_tfp, KERN_TFP_POLICY, policy, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,

-    &tfp_policy, sizeof(uint32_t), &sysctl_settfp_policy ,"I","policy");
+    &tfp_policy, sizeof(uint32_t), &sysctl_settfp_policy, "I", "policy");

 
 SYSCTL_INT(_vm, OID_AUTO, shared_region_trace_level, CTLFLAG_RW | CTLFLAG_LOCKED,
 
 SYSCTL_INT(_vm, OID_AUTO, shared_region_trace_level, CTLFLAG_RW | CTLFLAG_LOCKED,

-          &shared_region_trace_level, 0, "");
+    &shared_region_trace_level, 0, "");

 SYSCTL_INT(_vm, OID_AUTO, shared_region_version, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_INT(_vm, OID_AUTO, shared_region_version, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &shared_region_version, 0, "");
+    &shared_region_version, 0, "");

 SYSCTL_INT(_vm, OID_AUTO, shared_region_persistence, CTLFLAG_RW | CTLFLAG_LOCKED,
 SYSCTL_INT(_vm, OID_AUTO, shared_region_persistence, CTLFLAG_RW | CTLFLAG_LOCKED,

-          &shared_region_persistence, 0, "");
+    &shared_region_persistence, 0, "");

 
 /*
  * shared_region_check_np:
 
 /*
  * shared_region_check_np:


@@ -1461,43 +1646,43 @@ SYSCTL_INT(_vm, OID_AUTO, shared_region_persistence, CTLFLAG_RW | CTLFLAG_LOCKED
  */
 int
 shared_region_check_np(
  */
 int
 shared_region_check_np(

-       __unused struct proc                    *p,
-       struct shared_region_check_np_args      *uap,
-       __unused int                            *retvalp)
+       __unused struct proc                    *p,
+       struct shared_region_check_np_args      *uap,
+       __unused int                            *retvalp)

 {
 {

-       vm_shared_region_t      shared_region;
-       mach_vm_offset_t        start_address = 0;
-       int                     error;
-       kern_return_t           kr;
+       vm_shared_region_t      shared_region;
+       mach_vm_offset_t        start_address = 0;
+       int                     error;
+       kern_return_t           kr;

 
        SHARED_REGION_TRACE_DEBUG(
                ("shared_region: %p [%d(%s)] -> check_np(0x%llx)\n",
 
        SHARED_REGION_TRACE_DEBUG(
                ("shared_region: %p [%d(%s)] -> check_np(0x%llx)\n",

-                (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                p->p_pid, p->p_comm,
-                (uint64_t)uap->start_address));
+               (void *)VM_KERNEL_ADDRPERM(current_thread()),
+               p->p_pid, p->p_comm,
+               (uint64_t)uap->start_address));

 
        /* retrieve the current tasks's shared region */
        shared_region = vm_shared_region_get(current_task());
        if (shared_region != NULL) {
                /* retrieve address of its first mapping... */
                kr = vm_shared_region_start_address(shared_region,
 
        /* retrieve the current tasks's shared region */
        shared_region = vm_shared_region_get(current_task());
        if (shared_region != NULL) {
                /* retrieve address of its first mapping... */
                kr = vm_shared_region_start_address(shared_region,

-                                                   &start_address);
+                   &start_address);

                if (kr != KERN_SUCCESS) {
                        error = ENOMEM;
                } else {
                        /* ... and give it to the caller */
                        error = copyout(&start_address,
                if (kr != KERN_SUCCESS) {
                        error = ENOMEM;
                } else {
                        /* ... and give it to the caller */
                        error = copyout(&start_address,

-                                       (user_addr_t) uap->start_address,
-                                       sizeof (start_address));
+                           (user_addr_t) uap->start_address,
+                           sizeof(start_address));

                        if (error) {
                                SHARED_REGION_TRACE_ERROR(
                                        ("shared_region: %p [%d(%s)] "
                        if (error) {
                                SHARED_REGION_TRACE_ERROR(
                                        ("shared_region: %p [%d(%s)] "

-                                        "check_np(0x%llx) "
-                                        "copyout(0x%llx) error %d\n",
-                                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                                        p->p_pid, p->p_comm,
-                                        (uint64_t)uap->start_address, (uint64_t)start_address,
-                                        error));
+                                       "check_np(0x%llx) "
+                                       "copyout(0x%llx) error %d\n",
+                                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                                       p->p_pid, p->p_comm,
+                                       (uint64_t)uap->start_address, (uint64_t)start_address,
+                                       error));

                        }
                }
                vm_shared_region_deallocate(shared_region);
                        }
                }
                vm_shared_region_deallocate(shared_region);


@@ -1508,9 +1693,9 @@ shared_region_check_np(
 
        SHARED_REGION_TRACE_DEBUG(
                ("shared_region: %p [%d(%s)] check_np(0x%llx) <- 0x%llx %d\n",
 
        SHARED_REGION_TRACE_DEBUG(
                ("shared_region: %p [%d(%s)] check_np(0x%llx) <- 0x%llx %d\n",

-                (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                p->p_pid, p->p_comm,
-                (uint64_t)uap->start_address, (uint64_t)start_address, error));
+               (void *)VM_KERNEL_ADDRPERM(current_thread()),
+               p->p_pid, p->p_comm,
+               (uint64_t)uap->start_address, (uint64_t)start_address, error));

 
        return error;
 }
 
        return error;
 }


@@ -1518,26 +1703,26 @@ shared_region_check_np(
 
 int
 shared_region_copyin_mappings(
 
 int
 shared_region_copyin_mappings(

-               struct proc                     *p,
-               user_addr_t                     user_mappings,
-               unsigned int                    mappings_count,
-               struct shared_file_mapping_np   *mappings)
+       struct proc                     *p,
+       user_addr_t                     user_mappings,
+       unsigned int                    mappings_count,
+       struct shared_file_mapping_np   *mappings)

 {
 {

-       int             error = 0;
-       vm_size_t       mappings_size = 0;
+       int             error = 0;
+       vm_size_t       mappings_size = 0;

 
        /* get the list of mappings the caller wants us to establish */
 
        /* get the list of mappings the caller wants us to establish */

-       mappings_size = (vm_size_t) (mappings_count * sizeof (mappings[0]));
+       mappings_size = (vm_size_t) (mappings_count * sizeof(mappings[0]));

        error = copyin(user_mappings,
        error = copyin(user_mappings,

-                      mappings,
-                      mappings_size);
+           mappings,
+           mappings_size);

        if (error) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(): "
        if (error) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(): "

-                        "copyin(0x%llx, %d) failed (error=%d)\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        (uint64_t)user_mappings, mappings_count, error));
+                       "copyin(0x%llx, %d) failed (error=%d)\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm,
+                       (uint64_t)user_mappings, mappings_count, error));

        }
        return error;
 }
        }
        return error;
 }


@@ -1553,32 +1738,32 @@ shared_region_copyin_mappings(
  */
 int
 _shared_region_map_and_slide(
  */
 int
 _shared_region_map_and_slide(

-       struct proc                             *p,
-       int                                     fd,
-       uint32_t                                mappings_count,
-       struct shared_file_mapping_np           *mappings,
-       uint32_t                                slide,
-       user_addr_t                             slide_start,
-       user_addr_t                             slide_size)
+       struct proc                             *p,
+       int                                     fd,
+       uint32_t                                mappings_count,
+       struct shared_file_mapping_np           *mappings,
+       uint32_t                                slide,
+       user_addr_t                             slide_start,
+       user_addr_t                             slide_size)

 {
 {

-       int                             error;
-       kern_return_t                   kr;
-       struct fileproc                 *fp;
-       struct vnode                    *vp, *root_vp, *scdir_vp;
-       struct vnode_attr               va;
-       off_t                           fs;
-       memory_object_size_t            file_size;
+       int                             error;
+       kern_return_t                   kr;
+       struct fileproc                 *fp;
+       struct vnode                    *vp, *root_vp, *scdir_vp;
+       struct vnode_attr               va;
+       off_t                           fs;
+       memory_object_size_t            file_size;

 #if CONFIG_MACF
 #if CONFIG_MACF

-       vm_prot_t                       maxprot = VM_PROT_ALL;
+       vm_prot_t                       maxprot = VM_PROT_ALL;

 #endif
 #endif

-       memory_object_control_t         file_control;
-       struct vm_shared_region         *shared_region;
-       uint32_t                        i;
+       memory_object_control_t         file_control;
+       struct vm_shared_region         *shared_region;
+       uint32_t                        i;

 
        SHARED_REGION_TRACE_DEBUG(
                ("shared_region: %p [%d(%s)] -> map\n",
 
        SHARED_REGION_TRACE_DEBUG(
                ("shared_region: %p [%d(%s)] -> map\n",

-                (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                p->p_pid, p->p_comm));
+               (void *)VM_KERNEL_ADDRPERM(current_thread()),
+               p->p_pid, p->p_comm));

 
        shared_region = NULL;
        fp = NULL;
 
        shared_region = NULL;
        fp = NULL;


@@ -1590,9 +1775,9 @@ _shared_region_map_and_slide(
        if (error) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map: "
        if (error) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map: "

-                        "fd=%d lookup failed (error=%d)\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm, fd, error));
+                       "fd=%d lookup failed (error=%d)\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm, fd, error));

                goto done;
        }
 
                goto done;
        }
 


@@ -1600,21 +1785,21 @@ _shared_region_map_and_slide(
        if (FILEGLOB_DTYPE(fp->f_fglob) != DTYPE_VNODE) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map: "
        if (FILEGLOB_DTYPE(fp->f_fglob) != DTYPE_VNODE) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map: "

-                        "fd=%d not a vnode (type=%d)\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        fd, FILEGLOB_DTYPE(fp->f_fglob)));
+                       "fd=%d not a vnode (type=%d)\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm,
+                       fd, FILEGLOB_DTYPE(fp->f_fglob)));

                error = EINVAL;
                goto done;
        }
 
        /* we need at least read permission on the file */
                error = EINVAL;
                goto done;
        }
 
        /* we need at least read permission on the file */

-       if (! (fp->f_fglob->fg_flag & FREAD)) {
+       if (!(fp->f_fglob->fg_flag & FREAD)) {

                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map: "
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map: "

-                        "fd=%d not readable\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm, fd));
+                       "fd=%d not readable\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm, fd));

                error = EPERM;
                goto done;
        }
                error = EPERM;
                goto done;
        }


@@ -1624,9 +1809,9 @@ _shared_region_map_and_slide(
        if (error) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map: "
        if (error) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map: "

-                        "fd=%d getwithref failed (error=%d)\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm, fd, error));
+                       "fd=%d getwithref failed (error=%d)\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm, fd, error));

                goto done;
        }
        vp = (struct vnode *) fp->f_fglob->fg_data;
                goto done;
        }
        vp = (struct vnode *) fp->f_fglob->fg_data;


@@ -1635,73 +1820,94 @@ _shared_region_map_and_slide(
        if (vp->v_type != VREG) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "
        if (vp->v_type != VREG) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "

-                        "not a file (type=%d)\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        (void *)VM_KERNEL_ADDRPERM(vp),
-                        vp->v_name, vp->v_type));
+                       "not a file (type=%d)\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm,
+                       (void *)VM_KERNEL_ADDRPERM(vp),
+                       vp->v_name, vp->v_type));

                error = EINVAL;
                goto done;
        }
 
 #if CONFIG_MACF
        /* pass in 0 for the offset argument because AMFI does not need the offset
                error = EINVAL;
                goto done;
        }
 
 #if CONFIG_MACF
        /* pass in 0 for the offset argument because AMFI does not need the offset

-               of the shared cache */
+        *       of the shared cache */

        error = mac_file_check_mmap(vfs_context_ucred(vfs_context_current()),
        error = mac_file_check_mmap(vfs_context_ucred(vfs_context_current()),

-                       fp->f_fglob, VM_PROT_ALL, MAP_FILE, 0, &maxprot);
+           fp->f_fglob, VM_PROT_ALL, MAP_FILE, 0, &maxprot);

        if (error) {
                goto done;
        }
 #endif /* MAC */
 
        if (error) {
                goto done;
        }
 #endif /* MAC */
 

-       /* make sure vnode is on the process's root volume */
+       /* The calling process cannot be chroot-ed. */

        root_vp = p->p_fd->fd_rdir;
        if (root_vp == NULL) {
                root_vp = rootvnode;
        } else {
        root_vp = p->p_fd->fd_rdir;
        if (root_vp == NULL) {
                root_vp = rootvnode;
        } else {

-               /*
-                * Chroot-ed processes can't use the shared_region.
-                */
-               error = EINVAL;
-               goto done;
-       }
-
-       if (vp->v_mount != root_vp->v_mount) {

                SHARED_REGION_TRACE_ERROR(
                SHARED_REGION_TRACE_ERROR(

-                       ("shared_region: %p [%d(%s)] map(%p:'%s'): "
-                        "not on process's root volume\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name));
+                       ("calling process [%d(%s)] is chroot-ed, permission denied\n",
+                       p->p_pid, p->p_comm));

                error = EPERM;
                goto done;
        }
 
                error = EPERM;
                goto done;
        }
 

-       /* make sure vnode is owned by "root" */
+       /* The shared cache file must be owned by root */

        VATTR_INIT(&va);
        VATTR_WANTED(&va, va_uid);
        VATTR_INIT(&va);
        VATTR_WANTED(&va, va_uid);

+       VATTR_WANTED(&va, va_flags);

        error = vnode_getattr(vp, &va, vfs_context_current());
        if (error) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "
        error = vnode_getattr(vp, &va, vfs_context_current());
        if (error) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "

-                        "vnode_getattr(%p) failed (error=%d)\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name,
-                        (void *)VM_KERNEL_ADDRPERM(vp), error));
+                       "vnode_getattr(%p) failed (error=%d)\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm,
+                       (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name,
+                       (void *)VM_KERNEL_ADDRPERM(vp), error));

                goto done;
        }
        if (va.va_uid != 0) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "
                goto done;
        }
        if (va.va_uid != 0) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "

-                        "owned by uid=%d instead of 0\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        (void *)VM_KERNEL_ADDRPERM(vp),
-                        vp->v_name, va.va_uid));
+                       "owned by uid=%d instead of 0\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm,
+                       (void *)VM_KERNEL_ADDRPERM(vp),
+                       vp->v_name, va.va_uid));
+               error = EPERM;
+               goto done;
+       }
+
+#if CONFIG_CSR
+       if (csr_check(CSR_ALLOW_UNRESTRICTED_FS) != 0 &&
+           !(va.va_flags & SF_RESTRICTED)) {
+               /*
+                * CSR is not configured in CSR_ALLOW_UNRESTRICTED_FS mode, and
+                * the shared cache file is NOT SIP-protected, so reject the
+                * mapping request
+                */
+               SHARED_REGION_TRACE_ERROR(
+                       ("shared_region: %p [%d(%s)] map(%p:'%s'), "
+                       "vnode is not SIP-protected. \n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm, (void *)VM_KERNEL_ADDRPERM(vp),
+                       vp->v_name));
+               error = EPERM;
+               goto done;
+       }
+#else
+       /* Devices without SIP/ROSP need to make sure that the shared cache is on the root volume. */
+       if (vp->v_mount != root_vp->v_mount) {
+               SHARED_REGION_TRACE_ERROR(
+                       ("shared_region: %p [%d(%s)] map(%p:'%s'): "
+                       "not on process's root volume\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm,
+                       (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name));

                error = EPERM;
                goto done;
        }
                error = EPERM;
                goto done;
        }

+#endif /* CONFIG_CSR */

 
        if (scdir_enforce) {
                /* get vnode for scdir_path */
 
        if (scdir_enforce) {
                /* get vnode for scdir_path */


@@ -1709,11 +1915,11 @@ _shared_region_map_and_slide(
                if (error) {
                        SHARED_REGION_TRACE_ERROR(
                                ("shared_region: %p [%d(%s)] map(%p:'%s'): "
                if (error) {
                        SHARED_REGION_TRACE_ERROR(
                                ("shared_region: %p [%d(%s)] map(%p:'%s'): "

-                                "vnode_lookup(%s) failed (error=%d)\n",
-                                (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                                p->p_pid, p->p_comm,
-                                (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name,
-                                scdir_path, error));
+                               "vnode_lookup(%s) failed (error=%d)\n",
+                               (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                               p->p_pid, p->p_comm,
+                               (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name,
+                               scdir_path, error));

                        goto done;
                }
 
                        goto done;
                }
 


@@ -1721,11 +1927,11 @@ _shared_region_map_and_slide(
                if (vnode_parent(vp) != scdir_vp) {
                        SHARED_REGION_TRACE_ERROR(
                                ("shared_region: %p [%d(%s)] map(%p:'%s'): "
                if (vnode_parent(vp) != scdir_vp) {
                        SHARED_REGION_TRACE_ERROR(
                                ("shared_region: %p [%d(%s)] map(%p:'%s'): "

-                                "shared cache file not in %s\n",
-                                (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                                p->p_pid, p->p_comm,
-                                (void *)VM_KERNEL_ADDRPERM(vp),
-                                vp->v_name, scdir_path));
+                               "shared cache file not in %s\n",
+                               (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                               p->p_pid, p->p_comm,
+                               (void *)VM_KERNEL_ADDRPERM(vp),
+                               vp->v_name, scdir_path));

                        error = EPERM;
                        goto done;
                }
                        error = EPERM;
                        goto done;
                }


@@ -1736,11 +1942,11 @@ _shared_region_map_and_slide(
        if (error) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "
        if (error) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "

-                        "vnode_size(%p) failed (error=%d)\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name,
-                        (void *)VM_KERNEL_ADDRPERM(vp), error));
+                       "vnode_size(%p) failed (error=%d)\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm,
+                       (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name,
+                       (void *)VM_KERNEL_ADDRPERM(vp), error));

                goto done;
        }
        file_size = fs;
                goto done;
        }
        file_size = fs;


@@ -1750,74 +1956,77 @@ _shared_region_map_and_slide(
        if (file_control == MEMORY_OBJECT_CONTROL_NULL) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "
        if (file_control == MEMORY_OBJECT_CONTROL_NULL) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "

-                        "no memory object\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name));
+                       "no memory object\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm,
+                       (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name));

                error = EINVAL;
                goto done;
        }
 
        /* check that the mappings are properly covered by code signatures */
                error = EINVAL;
                goto done;
        }
 
        /* check that the mappings are properly covered by code signatures */

-       if (!cs_enforcement(NULL)) {
+       if (!cs_system_enforcement()) {

                /* code signing is not enforced: no need to check */
                /* code signing is not enforced: no need to check */

-       } else for (i = 0; i < mappings_count; i++) {
-               if (mappings[i].sfm_init_prot & VM_PROT_ZF) {
-                       /* zero-filled mapping: not backed by the file */
-                       continue;
-               }
-               if (ubc_cs_is_range_codesigned(vp,
-                                              mappings[i].sfm_file_offset,
-                                              mappings[i].sfm_size)) {
-                       /* this mapping is fully covered by code signatures */
-                       continue;
+       } else {
+               for (i = 0; i < mappings_count; i++) {
+                       if (mappings[i].sfm_init_prot & VM_PROT_ZF) {
+                               /* zero-filled mapping: not backed by the file */
+                               continue;
+                       }
+                       if (ubc_cs_is_range_codesigned(vp,
+                           mappings[i].sfm_file_offset,
+                           mappings[i].sfm_size)) {
+                               /* this mapping is fully covered by code signatures */
+                               continue;
+                       }
+                       SHARED_REGION_TRACE_ERROR(
+                               ("shared_region: %p [%d(%s)] map(%p:'%s'): "
+                               "mapping #%d/%d [0x%llx:0x%llx:0x%llx:0x%x:0x%x] "
+                               "is not code-signed\n",
+                               (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                               p->p_pid, p->p_comm,
+                               (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name,
+                               i, mappings_count,
+                               mappings[i].sfm_address,
+                               mappings[i].sfm_size,
+                               mappings[i].sfm_file_offset,
+                               mappings[i].sfm_max_prot,
+                               mappings[i].sfm_init_prot));
+                       error = EINVAL;
+                       goto done;

                }
                }

-               SHARED_REGION_TRACE_ERROR(
-                       ("shared_region: %p [%d(%s)] map(%p:'%s'): "
-                        "mapping #%d/%d [0x%llx:0x%llx:0x%llx:0x%x:0x%x] "
-                        "is not code-signed\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name,
-                        i, mappings_count,
-                        mappings[i].sfm_address,
-                        mappings[i].sfm_size,
-                        mappings[i].sfm_file_offset,
-                        mappings[i].sfm_max_prot,
-                        mappings[i].sfm_init_prot));
-               error = EINVAL;
-               goto done;

        }
 
        /* get the process's shared region (setup in vm_map_exec()) */
        }
 
        /* get the process's shared region (setup in vm_map_exec()) */

-       shared_region = vm_shared_region_get(current_task());
+       shared_region = vm_shared_region_trim_and_get(current_task());

        if (shared_region == NULL) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "
        if (shared_region == NULL) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "

-                        "no shared region\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name));
+                       "no shared region\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm,
+                       (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name));
+               error = EINVAL;

                goto done;
        }
 
        /* map the file into that shared region's submap */
        kr = vm_shared_region_map_file(shared_region,
                goto done;
        }
 
        /* map the file into that shared region's submap */
        kr = vm_shared_region_map_file(shared_region,

-                                      mappings_count,
-                                      mappings,
-                                      file_control,
-                                      file_size,
-                                      (void *) p->p_fd->fd_rdir,
-                                      slide,
-                                      slide_start,
-                                      slide_size);
+           mappings_count,
+           mappings,
+           file_control,
+           file_size,
+           (void *) p->p_fd->fd_rdir,
+           slide,
+           slide_start,
+           slide_size);

        if (kr != KERN_SUCCESS) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "
        if (kr != KERN_SUCCESS) {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(%p:'%s'): "

-                        "vm_shared_region_map_file() failed kr=0x%x\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name, kr));
+                       "vm_shared_region_map_file() failed kr=0x%x\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm,
+                       (void *)VM_KERNEL_ADDRPERM(vp), vp->v_name, kr));

                switch (kr) {
                case KERN_INVALID_ADDRESS:
                        error = EFAULT;
                switch (kr) {
                case KERN_INVALID_ADDRESS:
                        error = EFAULT;


@@ -1846,7 +2055,7 @@ _shared_region_map_and_slide(
        vnode_unlock(vp);
 
        /* update the vnode's access time */
        vnode_unlock(vp);
 
        /* update the vnode's access time */

-       if (! (vnode_vfsvisflags(vp) & MNT_NOATIME)) {
+       if (!(vnode_vfsvisflags(vp) & MNT_NOATIME)) {

                VATTR_INIT(&va);
                nanotime(&va.va_access_time);
                VATTR_SET_ACTIVE(&va, va_access_time);
                VATTR_INIT(&va);
                nanotime(&va.va_access_time);
                VATTR_SET_ACTIVE(&va, va_access_time);


@@ -1883,36 +2092,36 @@ done:
 
        SHARED_REGION_TRACE_DEBUG(
                ("shared_region: %p [%d(%s)] <- map\n",
 
        SHARED_REGION_TRACE_DEBUG(
                ("shared_region: %p [%d(%s)] <- map\n",

-                (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                p->p_pid, p->p_comm));
+               (void *)VM_KERNEL_ADDRPERM(current_thread()),
+               p->p_pid, p->p_comm));

 
        return error;
 }
 
 int
 shared_region_map_and_slide_np(
 
        return error;
 }
 
 int
 shared_region_map_and_slide_np(

-       struct proc                             *p,
-       struct shared_region_map_and_slide_np_args      *uap,
-       __unused int                                    *retvalp)
+       struct proc                             *p,
+       struct shared_region_map_and_slide_np_args      *uap,
+       __unused int                                    *retvalp)

 {
 {

-       struct shared_file_mapping_np   *mappings;
-       unsigned int                    mappings_count = uap->count;
-       kern_return_t                   kr = KERN_SUCCESS;
-       uint32_t                        slide = uap->slide;
-       
-#define SFM_MAX_STACK  8
-       struct shared_file_mapping_np   stack_mappings[SFM_MAX_STACK];
+       struct shared_file_mapping_np   *mappings;
+       unsigned int                    mappings_count = uap->count;
+       kern_return_t                   kr = KERN_SUCCESS;
+       uint32_t                        slide = uap->slide;
+
+#define SFM_MAX_STACK   8
+       struct shared_file_mapping_np   stack_mappings[SFM_MAX_STACK];

 
        /* Is the process chrooted?? */
        if (p->p_fd->fd_rdir != NULL) {
                kr = EINVAL;
                goto done;
        }
 
        /* Is the process chrooted?? */
        if (p->p_fd->fd_rdir != NULL) {
                kr = EINVAL;
                goto done;
        }

-               
+

        if ((kr = vm_shared_region_sliding_valid(slide)) != KERN_SUCCESS) {
                if (kr == KERN_INVALID_ARGUMENT) {
                        /*
        if ((kr = vm_shared_region_sliding_valid(slide)) != KERN_SUCCESS) {
                if (kr == KERN_INVALID_ARGUMENT) {
                        /*

-                        * This will happen if we request sliding again 
+                        * This will happen if we request sliding again

                         * with the same slide value that was used earlier
                         * for the very first sliding.
                         */
                         * with the same slide value that was used earlier
                         * for the very first sliding.
                         */


@@ -1924,32 +2133,32 @@ shared_region_map_and_slide_np(
        if (mappings_count == 0) {
                SHARED_REGION_TRACE_INFO(
                        ("shared_region: %p [%d(%s)] map(): "
        if (mappings_count == 0) {
                SHARED_REGION_TRACE_INFO(
                        ("shared_region: %p [%d(%s)] map(): "

-                        "no mappings\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm));
-               kr = 0; /* no mappings: we're done ! */
+                       "no mappings\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm));
+               kr = 0; /* no mappings: we're done ! */

                goto done;
        } else if (mappings_count <= SFM_MAX_STACK) {
                mappings = &stack_mappings[0];
        } else {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(): "
                goto done;
        } else if (mappings_count <= SFM_MAX_STACK) {
                mappings = &stack_mappings[0];
        } else {
                SHARED_REGION_TRACE_ERROR(
                        ("shared_region: %p [%d(%s)] map(): "

-                        "too many mappings (%d)\n",
-                        (void *)VM_KERNEL_ADDRPERM(current_thread()),
-                        p->p_pid, p->p_comm,
-                        mappings_count));
+                       "too many mappings (%d)\n",
+                       (void *)VM_KERNEL_ADDRPERM(current_thread()),
+                       p->p_pid, p->p_comm,
+                       mappings_count));

                kr = KERN_FAILURE;
                goto done;
        }
 
                kr = KERN_FAILURE;
                goto done;
        }
 

-       if ( (kr = shared_region_copyin_mappings(p, uap->mappings, uap->count, mappings))) {
+       if ((kr = shared_region_copyin_mappings(p, uap->mappings, uap->count, mappings))) {

                goto done;
        }
 
 
        kr = _shared_region_map_and_slide(p, uap->fd, mappings_count, mappings,
                goto done;
        }
 
 
        kr = _shared_region_map_and_slide(p, uap->fd, mappings_count, mappings,

-                                         slide,
-                                         uap->slide_start, uap->slide_size);
+           slide,
+           uap->slide_start, uap->slide_size);

        if (kr != KERN_SUCCESS) {
                return kr;
        }
        if (kr != KERN_SUCCESS) {
                return kr;
        }


@@ -1960,19 +2169,18 @@ done:
 
 /* sysctl overflow room */
 
 
 /* sysctl overflow room */
 

-SYSCTL_INT (_vm, OID_AUTO, pagesize, CTLFLAG_RD | CTLFLAG_LOCKED,
-           (int *) &page_size, 0, "vm page size");
+SYSCTL_INT(_vm, OID_AUTO, pagesize, CTLFLAG_RD | CTLFLAG_LOCKED,
+    (int *) &page_size, 0, "vm page size");

 
 /* vm_page_free_target is provided as a makeshift solution for applications that want to
 
 /* vm_page_free_target is provided as a makeshift solution for applications that want to

-       allocate buffer space, possibly purgeable memory, but not cause inactive pages to be
-       reclaimed. It allows the app to calculate how much memory is free outside the free target. */
-extern unsigned int    vm_page_free_target;
-SYSCTL_INT(_vm, OID_AUTO, vm_page_free_target, CTLFLAG_RD | CTLFLAG_LOCKED, 
-                  &vm_page_free_target, 0, "Pageout daemon free target");
+ *       allocate buffer space, possibly purgeable memory, but not cause inactive pages to be
+ *       reclaimed. It allows the app to calculate how much memory is free outside the free target. */
+extern unsigned int     vm_page_free_target;
+SYSCTL_INT(_vm, OID_AUTO, vm_page_free_target, CTLFLAG_RD | CTLFLAG_LOCKED,
+    &vm_page_free_target, 0, "Pageout daemon free target");

 
 

-extern unsigned int    vm_memory_pressure;

 SYSCTL_INT(_vm, OID_AUTO, memory_pressure, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_INT(_vm, OID_AUTO, memory_pressure, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_memory_pressure, 0, "Memory pressure indicator");
+    &vm_pageout_state.vm_memory_pressure, 0, "Memory pressure indicator");

 
 static int
 vm_ctl_page_free_wanted SYSCTL_HANDLER_ARGS
 
 static int
 vm_ctl_page_free_wanted SYSCTL_HANDLER_ARGS


@@ -1981,60 +2189,97 @@ vm_ctl_page_free_wanted SYSCTL_HANDLER_ARGS
        unsigned int page_free_wanted;
 
        page_free_wanted = mach_vm_ctl_page_free_wanted();
        unsigned int page_free_wanted;
 
        page_free_wanted = mach_vm_ctl_page_free_wanted();

-       return SYSCTL_OUT(req, &page_free_wanted, sizeof (page_free_wanted));
+       return SYSCTL_OUT(req, &page_free_wanted, sizeof(page_free_wanted));

 }
 SYSCTL_PROC(_vm, OID_AUTO, page_free_wanted,
 }
 SYSCTL_PROC(_vm, OID_AUTO, page_free_wanted,

-           CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
-           0, 0, vm_ctl_page_free_wanted, "I", "");
+    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
+    0, 0, vm_ctl_page_free_wanted, "I", "");

 
 

-extern unsigned int    vm_page_purgeable_count;
+extern unsigned int     vm_page_purgeable_count;

 SYSCTL_INT(_vm, OID_AUTO, page_purgeable_count, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_INT(_vm, OID_AUTO, page_purgeable_count, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_purgeable_count, 0, "Purgeable page count");
+    &vm_page_purgeable_count, 0, "Purgeable page count");

 
 

-extern unsigned int    vm_page_purgeable_wired_count;
+extern unsigned int     vm_page_purgeable_wired_count;

 SYSCTL_INT(_vm, OID_AUTO, page_purgeable_wired_count, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_INT(_vm, OID_AUTO, page_purgeable_wired_count, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_purgeable_wired_count, 0, "Wired purgeable page count");
+    &vm_page_purgeable_wired_count, 0, "Wired purgeable page count");
+
+extern unsigned int vm_page_kern_lpage_count;
+SYSCTL_INT(_vm, OID_AUTO, kern_lpage_count, CTLFLAG_RD | CTLFLAG_LOCKED,
+    &vm_page_kern_lpage_count, 0, "kernel used large pages");
+
+#if DEVELOPMENT || DEBUG
+extern uint64_t get_pages_grabbed_count(void);
+
+static int
+pages_grabbed SYSCTL_HANDLER_ARGS
+{
+#pragma unused(arg1, arg2, oidp)
+       uint64_t value = get_pages_grabbed_count();
+       return SYSCTL_OUT(req, &value, sizeof(value));
+}
+
+SYSCTL_PROC(_vm, OID_AUTO, pages_grabbed, CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
+    0, 0, &pages_grabbed, "QU", "Total pages grabbed");
+SYSCTL_ULONG(_vm, OID_AUTO, pages_freed, CTLFLAG_RD | CTLFLAG_LOCKED,
+    &vm_pageout_vminfo.vm_page_pages_freed, "Total pages freed");

 
 

-extern unsigned int    vm_pageout_purged_objects;

 SYSCTL_INT(_vm, OID_AUTO, pageout_purged_objects, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_INT(_vm, OID_AUTO, pageout_purged_objects, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_pageout_purged_objects, 0, "System purged object count");
+    &vm_pageout_debug.vm_pageout_purged_objects, 0, "System purged object count");
+SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_busy, CTLFLAG_RD | CTLFLAG_LOCKED,
+    &vm_pageout_debug.vm_pageout_cleaned_busy, 0, "Cleaned pages busy (deactivated)");
+SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_nolock, CTLFLAG_RD | CTLFLAG_LOCKED,
+    &vm_pageout_debug.vm_pageout_cleaned_nolock, 0, "Cleaned pages no-lock (deactivated)");
+
+SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_volatile_reactivated, CTLFLAG_RD | CTLFLAG_LOCKED,
+    &vm_pageout_debug.vm_pageout_cleaned_volatile_reactivated, 0, "Cleaned pages volatile reactivated");
+SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_fault_reactivated, CTLFLAG_RD | CTLFLAG_LOCKED,
+    &vm_pageout_debug.vm_pageout_cleaned_fault_reactivated, 0, "Cleaned pages fault reactivated");
+SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_reactivated, CTLFLAG_RD | CTLFLAG_LOCKED,
+    &vm_pageout_debug.vm_pageout_cleaned_reactivated, 0, "Cleaned pages reactivated");         /* sum of all reactivated AND busy and nolock (even though those actually get reDEactivated */
+SYSCTL_ULONG(_vm, OID_AUTO, pageout_cleaned, CTLFLAG_RD | CTLFLAG_LOCKED,
+    &vm_pageout_vminfo.vm_pageout_freed_cleaned, "Cleaned pages freed");
+SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_reference_reactivated, CTLFLAG_RD | CTLFLAG_LOCKED,
+    &vm_pageout_debug.vm_pageout_cleaned_reference_reactivated, 0, "Cleaned pages reference reactivated");
+SYSCTL_UINT(_vm, OID_AUTO, pageout_enqueued_cleaned, CTLFLAG_RD | CTLFLAG_LOCKED,
+    &vm_pageout_debug.vm_pageout_enqueued_cleaned, 0, "");         /* sum of next two */
+#endif

 
 extern int madvise_free_debug;
 SYSCTL_INT(_vm, OID_AUTO, madvise_free_debug, CTLFLAG_RW | CTLFLAG_LOCKED,
 
 extern int madvise_free_debug;
 SYSCTL_INT(_vm, OID_AUTO, madvise_free_debug, CTLFLAG_RW | CTLFLAG_LOCKED,

-          &madvise_free_debug, 0, "zero-fill on madvise(MADV_FREE*)");
+    &madvise_free_debug, 0, "zero-fill on madvise(MADV_FREE*)");

 
 SYSCTL_INT(_vm, OID_AUTO, page_reusable_count, CTLFLAG_RD | CTLFLAG_LOCKED,
 
 SYSCTL_INT(_vm, OID_AUTO, page_reusable_count, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.reusable_count, 0, "Reusable page count");
+    &vm_page_stats_reusable.reusable_count, 0, "Reusable page count");

 SYSCTL_QUAD(_vm, OID_AUTO, reusable_success, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, reusable_success, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.reusable_pages_success, "");
+    &vm_page_stats_reusable.reusable_pages_success, "");

 SYSCTL_QUAD(_vm, OID_AUTO, reusable_failure, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, reusable_failure, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.reusable_pages_failure, "");
+    &vm_page_stats_reusable.reusable_pages_failure, "");

 SYSCTL_QUAD(_vm, OID_AUTO, reusable_pages_shared, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, reusable_pages_shared, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.reusable_pages_shared, "");
+    &vm_page_stats_reusable.reusable_pages_shared, "");

 SYSCTL_QUAD(_vm, OID_AUTO, all_reusable_calls, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, all_reusable_calls, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.all_reusable_calls, "");
+    &vm_page_stats_reusable.all_reusable_calls, "");

 SYSCTL_QUAD(_vm, OID_AUTO, partial_reusable_calls, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, partial_reusable_calls, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.partial_reusable_calls, "");
+    &vm_page_stats_reusable.partial_reusable_calls, "");

 SYSCTL_QUAD(_vm, OID_AUTO, reuse_success, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, reuse_success, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.reuse_pages_success, "");
+    &vm_page_stats_reusable.reuse_pages_success, "");

 SYSCTL_QUAD(_vm, OID_AUTO, reuse_failure, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, reuse_failure, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.reuse_pages_failure, "");
+    &vm_page_stats_reusable.reuse_pages_failure, "");

 SYSCTL_QUAD(_vm, OID_AUTO, all_reuse_calls, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, all_reuse_calls, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.all_reuse_calls, "");
+    &vm_page_stats_reusable.all_reuse_calls, "");

 SYSCTL_QUAD(_vm, OID_AUTO, partial_reuse_calls, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, partial_reuse_calls, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.partial_reuse_calls, "");
+    &vm_page_stats_reusable.partial_reuse_calls, "");

 SYSCTL_QUAD(_vm, OID_AUTO, can_reuse_success, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, can_reuse_success, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.can_reuse_success, "");
+    &vm_page_stats_reusable.can_reuse_success, "");

 SYSCTL_QUAD(_vm, OID_AUTO, can_reuse_failure, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, can_reuse_failure, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.can_reuse_failure, "");
+    &vm_page_stats_reusable.can_reuse_failure, "");

 SYSCTL_QUAD(_vm, OID_AUTO, reusable_reclaimed, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, reusable_reclaimed, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.reusable_reclaimed, "");
+    &vm_page_stats_reusable.reusable_reclaimed, "");

 SYSCTL_QUAD(_vm, OID_AUTO, reusable_nonwritable, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, reusable_nonwritable, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.reusable_nonwritable, "");
+    &vm_page_stats_reusable.reusable_nonwritable, "");

 SYSCTL_QUAD(_vm, OID_AUTO, reusable_shared, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, reusable_shared, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.reusable_shared, "");
+    &vm_page_stats_reusable.reusable_shared, "");

 SYSCTL_QUAD(_vm, OID_AUTO, free_shared, CTLFLAG_RD | CTLFLAG_LOCKED,
 SYSCTL_QUAD(_vm, OID_AUTO, free_shared, CTLFLAG_RD | CTLFLAG_LOCKED,

-          &vm_page_stats_reusable.free_shared, "");
+    &vm_page_stats_reusable.free_shared, "");

 
 
 extern unsigned int vm_page_free_count, vm_page_speculative_count;
 
 
 extern unsigned int vm_page_free_count, vm_page_speculative_count;


@@ -2049,34 +2294,16 @@ SYSCTL_UINT(_vm, OID_AUTO, page_pageable_internal_count, CTLFLAG_RD | CTLFLAG_LO
 SYSCTL_UINT(_vm, OID_AUTO, page_pageable_external_count, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_pageable_external_count, 0, "");
 
 /* pageout counts */
 SYSCTL_UINT(_vm, OID_AUTO, page_pageable_external_count, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_pageable_external_count, 0, "");
 
 /* pageout counts */

-extern unsigned int vm_pageout_inactive_dirty_internal, vm_pageout_inactive_dirty_external, vm_pageout_inactive_clean, vm_pageout_speculative_clean, vm_pageout_inactive_used;
-extern unsigned int vm_pageout_freed_from_inactive_clean, vm_pageout_freed_from_speculative;
-SYSCTL_UINT(_vm, OID_AUTO, pageout_inactive_dirty_internal, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_inactive_dirty_internal, 0, "");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_inactive_dirty_external, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_inactive_dirty_external, 0, "");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_inactive_clean, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_inactive_clean, 0, "");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_speculative_clean, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_speculative_clean, 0, "");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_inactive_used, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_inactive_used, 0, "");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_freed_from_inactive_clean, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_freed_from_inactive_clean, 0, "");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_freed_from_speculative, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_freed_from_speculative, 0, "");
-
-extern unsigned int vm_pageout_freed_from_cleaned;
-SYSCTL_UINT(_vm, OID_AUTO, pageout_freed_from_cleaned, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_freed_from_cleaned, 0, "");
-
-/* counts of pages entering the cleaned queue */
-extern unsigned int vm_pageout_enqueued_cleaned, vm_pageout_enqueued_cleaned_from_inactive_dirty;
-SYSCTL_UINT(_vm, OID_AUTO, pageout_enqueued_cleaned, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_enqueued_cleaned, 0, ""); /* sum of next two */
-SYSCTL_UINT(_vm, OID_AUTO, pageout_enqueued_cleaned_from_inactive_dirty, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_enqueued_cleaned_from_inactive_dirty, 0, "");
-
-/* counts of pages leaving the cleaned queue */
-extern unsigned int vm_pageout_cleaned_reclaimed, vm_pageout_cleaned_reactivated, vm_pageout_cleaned_reference_reactivated, vm_pageout_cleaned_volatile_reactivated, vm_pageout_cleaned_fault_reactivated, vm_pageout_cleaned_commit_reactivated, vm_pageout_cleaned_busy, vm_pageout_cleaned_nolock;
-SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_cleaned_reclaimed, 0, "Cleaned pages reclaimed");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_reactivated, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_cleaned_reactivated, 0, "Cleaned pages reactivated"); /* sum of all reactivated AND busy and nolock (even though those actually get reDEactivated */
-SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_reference_reactivated, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_cleaned_reference_reactivated, 0, "Cleaned pages reference reactivated");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_volatile_reactivated, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_cleaned_volatile_reactivated, 0, "Cleaned pages volatile reactivated");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_fault_reactivated, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_cleaned_fault_reactivated, 0, "Cleaned pages fault reactivated");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_commit_reactivated, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_cleaned_commit_reactivated, 0, "Cleaned pages commit reactivated");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_busy, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_cleaned_busy, 0, "Cleaned pages busy (deactivated)");
-SYSCTL_UINT(_vm, OID_AUTO, pageout_cleaned_nolock, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_cleaned_nolock, 0, "Cleaned pages no-lock (deactivated)");
+SYSCTL_UINT(_vm, OID_AUTO, pageout_inactive_clean, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_state.vm_pageout_inactive_clean, 0, "");
+SYSCTL_UINT(_vm, OID_AUTO, pageout_inactive_used, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_state.vm_pageout_inactive_used, 0, "");
+
+SYSCTL_ULONG(_vm, OID_AUTO, pageout_inactive_dirty_internal, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_vminfo.vm_pageout_inactive_dirty_internal, "");
+SYSCTL_ULONG(_vm, OID_AUTO, pageout_inactive_dirty_external, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_vminfo.vm_pageout_inactive_dirty_external, "");
+SYSCTL_ULONG(_vm, OID_AUTO, pageout_speculative_clean, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_vminfo.vm_pageout_freed_speculative, "");
+SYSCTL_ULONG(_vm, OID_AUTO, pageout_freed_external, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_vminfo.vm_pageout_freed_external, "");
+SYSCTL_ULONG(_vm, OID_AUTO, pageout_freed_speculative, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_vminfo.vm_pageout_freed_speculative, "");
+SYSCTL_ULONG(_vm, OID_AUTO, pageout_freed_cleaned, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_vminfo.vm_pageout_freed_cleaned, "");
+

 
 /* counts of pages prefaulted when entering a memory object */
 extern int64_t vm_prefault_nb_pages, vm_prefault_nb_bailout;
 
 /* counts of pages prefaulted when entering a memory object */
 extern int64_t vm_prefault_nb_pages, vm_prefault_nb_bailout;


@@ -2119,10 +2346,12 @@ extern unsigned int vm_page_secluded_target;
 extern unsigned int vm_page_secluded_count;
 extern unsigned int vm_page_secluded_count_free;
 extern unsigned int vm_page_secluded_count_inuse;
 extern unsigned int vm_page_secluded_count;
 extern unsigned int vm_page_secluded_count_free;
 extern unsigned int vm_page_secluded_count_inuse;

+extern unsigned int vm_page_secluded_count_over_target;

 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_target, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded_target, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_count, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded_count, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_count_free, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded_count_free, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_count_inuse, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded_count_inuse, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_target, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded_target, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_count, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded_count, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_count_free, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded_count_free, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_count_inuse, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded_count_inuse, 0, "");

+SYSCTL_UINT(_vm, OID_AUTO, page_secluded_count_over_target, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded_count_over_target, 0, "");

 
 extern struct vm_page_secluded_data vm_page_secluded;
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_eligible, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded.eligible_for_secluded, 0, "");
 
 extern struct vm_page_secluded_data vm_page_secluded;
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_eligible, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded.eligible_for_secluded, 0, "");


@@ -2134,9 +2363,6 @@ SYSCTL_UINT(_vm, OID_AUTO, page_secluded_grab_failure_dirty, CTLFLAG_RD | CTLFLA
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_grab_for_iokit, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded.grab_for_iokit, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_grab_for_iokit_success, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded.grab_for_iokit_success, 0, "");
 
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_grab_for_iokit, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded.grab_for_iokit, 0, "");
 SYSCTL_UINT(_vm, OID_AUTO, page_secluded_grab_for_iokit_success, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_secluded.grab_for_iokit_success, 0, "");
 

-extern uint64_t vm_pageout_secluded_burst_count;
-SYSCTL_QUAD(_vm, OID_AUTO, pageout_secluded_burst_count, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_secluded_burst_count, "");
-

 #endif /* CONFIG_SECLUDED_MEMORY */
 
 #include <kern/thread.h>
 #endif /* CONFIG_SECLUDED_MEMORY */
 
 #include <kern/thread.h>


@@ -2144,21 +2370,22 @@ SYSCTL_QUAD(_vm, OID_AUTO, pageout_secluded_burst_count, CTLFLAG_RD | CTLFLAG_LO
 
 void vm_pageout_io_throttle(void);
 
 
 void vm_pageout_io_throttle(void);
 

-void vm_pageout_io_throttle(void) {
+void
+vm_pageout_io_throttle(void)
+{

        struct uthread *uthread = get_bsdthread_info(current_thread());
        struct uthread *uthread = get_bsdthread_info(current_thread());

- 
-               /*
-                * thread is marked as a low priority I/O type
-                * and the I/O we issued while in this cleaning operation
-                * collided with normal I/O operations... we'll
-                * delay in order to mitigate the impact of this
-                * task on the normal operation of the system
-                */
+
+       /*
+        * thread is marked as a low priority I/O type
+        * and the I/O we issued while in this cleaning operation
+        * collided with normal I/O operations... we'll
+        * delay in order to mitigate the impact of this
+        * task on the normal operation of the system
+        */

 
        if (uthread->uu_lowpri_window) {
                throttle_lowpri_io(1);
        }
 
        if (uthread->uu_lowpri_window) {
                throttle_lowpri_io(1);
        }

-

 }
 
 int
 }
 
 int


@@ -2167,9 +2394,9 @@ vm_pressure_monitor(
        struct vm_pressure_monitor_args *uap,
        int *retval)
 {
        struct vm_pressure_monitor_args *uap,
        int *retval)
 {

-       kern_return_t   kr;
-       uint32_t        pages_reclaimed;
-       uint32_t        pages_wanted;
+       kern_return_t   kr;
+       uint32_t        pages_reclaimed;
+       uint32_t        pages_wanted;

 
        kr = mach_vm_pressure_monitor(
                (boolean_t) uap->wait_for_pressure,
 
        kr = mach_vm_pressure_monitor(
                (boolean_t) uap->wait_for_pressure,


@@ -2188,8 +2415,8 @@ vm_pressure_monitor(
 
        if (uap->pages_reclaimed) {
                if (copyout((void *)&pages_reclaimed,
 
        if (uap->pages_reclaimed) {
                if (copyout((void *)&pages_reclaimed,

-                           uap->pages_reclaimed,
-                           sizeof (pages_reclaimed)) != 0) {
+                   uap->pages_reclaimed,
+                   sizeof(pages_reclaimed)) != 0) {

                        return EFAULT;
                }
        }
                        return EFAULT;
                }
        }


@@ -2200,19 +2427,19 @@ vm_pressure_monitor(
 
 int
 kas_info(struct proc *p,
 
 int
 kas_info(struct proc *p,

-                         struct kas_info_args *uap,
-                         int *retval __unused)
+    struct kas_info_args *uap,
+    int *retval __unused)

 {
 #ifdef SECURE_KERNEL
        (void)p;
        (void)uap;
        return ENOTSUP;
 #else /* !SECURE_KERNEL */
 {
 #ifdef SECURE_KERNEL
        (void)p;
        (void)uap;
        return ENOTSUP;
 #else /* !SECURE_KERNEL */

-       int                     selector = uap->selector;
-       user_addr_t     valuep = uap->value;
-       user_addr_t     sizep = uap->size;
+       int                     selector = uap->selector;
+       user_addr_t     valuep = uap->value;
+       user_addr_t     sizep = uap->size;

        user_size_t size;
        user_size_t size;

-       int                     error;
+       int                     error;

 
        if (!kauth_cred_issuser(kauth_cred_get())) {
                return EPERM;
 
        if (!kauth_cred_issuser(kauth_cred_get())) {
                return EPERM;


@@ -2239,33 +2466,33 @@ kas_info(struct proc *p,
        }
 
        switch (selector) {
        }
 
        switch (selector) {

-               case KAS_INFO_KERNEL_TEXT_SLIDE_SELECTOR:
-                       {
-                               uint64_t slide = vm_kernel_slide;
+       case KAS_INFO_KERNEL_TEXT_SLIDE_SELECTOR:
+       {
+               uint64_t slide = vm_kernel_slide;

 
 

-                               if (sizeof(slide) != size) {
-                                       return EINVAL;
-                               }
-                               
-                               if (IS_64BIT_PROCESS(p)) {
-                                       user64_size_t size64 = (user64_size_t)size;
-                                       error = copyout(&size64, sizep, sizeof(size64));
-                               } else {
-                                       user32_size_t size32 = (user32_size_t)size;
-                                       error = copyout(&size32, sizep, sizeof(size32));
-                               }
-                               if (error) {
-                                       return error;
-                               }
-                               
-                               error = copyout(&slide, valuep, sizeof(slide));
-                               if (error) {
-                                       return error;
-                               }
-                       }
-                       break;
-               default:
+               if (sizeof(slide) != size) {

                        return EINVAL;
                        return EINVAL;

+               }
+
+               if (IS_64BIT_PROCESS(p)) {
+                       user64_size_t size64 = (user64_size_t)size;
+                       error = copyout(&size64, sizep, sizeof(size64));
+               } else {
+                       user32_size_t size32 = (user32_size_t)size;
+                       error = copyout(&size32, sizep, sizeof(size32));
+               }
+               if (error) {
+                       return error;
+               }
+
+               error = copyout(&slide, valuep, sizeof(slide));
+               if (error) {
+                       return error;
+               }
+       }
+       break;
+       default:
+               return EINVAL;

        }
 
        return 0;
        }
 
        return 0;


@@ -2277,7 +2504,9 @@ kas_info(struct proc *p,
 #pragma clang diagnostic ignored "-Wcast-qual"
 #pragma clang diagnostic ignored "-Wunused-function"
 
 #pragma clang diagnostic ignored "-Wcast-qual"
 #pragma clang diagnostic ignored "-Wunused-function"
 

-static void asserts() {
+static void
+asserts()
+{

        static_assert(sizeof(vm_min_kernel_address) == sizeof(unsigned long));
        static_assert(sizeof(vm_max_kernel_address) == sizeof(unsigned long));
 }
        static_assert(sizeof(vm_min_kernel_address) == sizeof(unsigned long));
        static_assert(sizeof(vm_max_kernel_address) == sizeof(unsigned long));
 }


@@ -2289,10 +2518,18 @@ SYSCTL_ULONG(_vm, OID_AUTO, vm_max_kernel_address, CTLFLAG_RD, (unsigned long *)
 extern uint32_t vm_page_pages;
 SYSCTL_UINT(_vm, OID_AUTO, pages, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_pages, 0, "");
 
 extern uint32_t vm_page_pages;
 SYSCTL_UINT(_vm, OID_AUTO, pages, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_pages, 0, "");
 

+extern uint32_t vm_page_busy_absent_skipped;
+SYSCTL_UINT(_vm, OID_AUTO, page_busy_absent_skipped, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_busy_absent_skipped, 0, "");
+
+extern uint32_t vm_page_upl_tainted;
+SYSCTL_UINT(_vm, OID_AUTO, upl_pages_tainted, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_upl_tainted, 0, "");
+
+extern uint32_t vm_page_iopl_tainted;
+SYSCTL_UINT(_vm, OID_AUTO, iopl_pages_tainted, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_iopl_tainted, 0, "");
+

 #if (__arm__ || __arm64__) && (DEVELOPMENT || DEBUG)
 #if (__arm__ || __arm64__) && (DEVELOPMENT || DEBUG)

-extern int pacified_footprint_suspend;
-int footprint_suspend_allowed = 0;
-SYSCTL_INT(_vm, OID_AUTO, footprint_suspend_allowed, CTLFLAG_RW | CTLFLAG_LOCKED, &footprint_suspend_allowed, 0, "");
+extern int vm_footprint_suspend_allowed;
+SYSCTL_INT(_vm, OID_AUTO, footprint_suspend_allowed, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_footprint_suspend_allowed, 0, "");

 
 extern void pmap_footprint_suspend(vm_map_t map, boolean_t suspend);
 static int
 
 extern void pmap_footprint_suspend(vm_map_t map, boolean_t suspend);
 static int


@@ -2309,8 +2546,7 @@ sysctl_vm_footprint_suspend SYSCTL_HANDLER_ARGS
        if (error) {
                return error;
        }
        if (error) {
                return error;
        }

-       if (pacified_footprint_suspend &&
-           !footprint_suspend_allowed) {
+       if (!vm_footprint_suspend_allowed) {

                if (new_value != 0) {
                        /* suspends are not allowed... */
                        return 0;
                if (new_value != 0) {
                        /* suspends are not allowed... */
                        return 0;


@@ -2318,14 +2554,64 @@ sysctl_vm_footprint_suspend SYSCTL_HANDLER_ARGS
                /* ... but let resumes proceed */
        }
        DTRACE_VM2(footprint_suspend,
                /* ... but let resumes proceed */
        }
        DTRACE_VM2(footprint_suspend,

-                  vm_map_t, current_map(),
-                  int, new_value);
+           vm_map_t, current_map(),
+           int, new_value);

 
        pmap_footprint_suspend(current_map(), new_value);
 
        return 0;
 }
 SYSCTL_PROC(_vm, OID_AUTO, footprint_suspend,
 
        pmap_footprint_suspend(current_map(), new_value);
 
        return 0;
 }
 SYSCTL_PROC(_vm, OID_AUTO, footprint_suspend,

-           CTLTYPE_INT|CTLFLAG_WR|CTLFLAG_ANYBODY|CTLFLAG_LOCKED|CTLFLAG_MASKED,
-           0, 0, &sysctl_vm_footprint_suspend, "I", "");
+    CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_ANYBODY | CTLFLAG_LOCKED | CTLFLAG_MASKED,
+    0, 0, &sysctl_vm_footprint_suspend, "I", "");

 #endif /* (__arm__ || __arm64__) && (DEVELOPMENT || DEBUG) */
 #endif /* (__arm__ || __arm64__) && (DEVELOPMENT || DEBUG) */

+
+extern uint64_t vm_map_corpse_footprint_count;
+extern uint64_t vm_map_corpse_footprint_size_avg;
+extern uint64_t vm_map_corpse_footprint_size_max;
+extern uint64_t vm_map_corpse_footprint_full;
+extern uint64_t vm_map_corpse_footprint_no_buf;
+SYSCTL_QUAD(_vm, OID_AUTO, corpse_footprint_count,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &vm_map_corpse_footprint_count, "");
+SYSCTL_QUAD(_vm, OID_AUTO, corpse_footprint_size_avg,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &vm_map_corpse_footprint_size_avg, "");
+SYSCTL_QUAD(_vm, OID_AUTO, corpse_footprint_size_max,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &vm_map_corpse_footprint_size_max, "");
+SYSCTL_QUAD(_vm, OID_AUTO, corpse_footprint_full,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &vm_map_corpse_footprint_full, "");
+SYSCTL_QUAD(_vm, OID_AUTO, corpse_footprint_no_buf,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &vm_map_corpse_footprint_no_buf, "");
+
+#if PMAP_CS
+extern uint64_t vm_cs_defer_to_pmap_cs;
+extern uint64_t vm_cs_defer_to_pmap_cs_not;
+SYSCTL_QUAD(_vm, OID_AUTO, cs_defer_to_pmap_cs,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &vm_cs_defer_to_pmap_cs, "");
+SYSCTL_QUAD(_vm, OID_AUTO, cs_defer_to_pmap_cs_not,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &vm_cs_defer_to_pmap_cs_not, "");
+#endif /* PMAP_CS */
+
+extern uint64_t shared_region_pager_copied;
+extern uint64_t shared_region_pager_slid;
+extern uint64_t shared_region_pager_slid_error;
+extern uint64_t shared_region_pager_reclaimed;
+SYSCTL_QUAD(_vm, OID_AUTO, shared_region_pager_copied,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &shared_region_pager_copied, "");
+SYSCTL_QUAD(_vm, OID_AUTO, shared_region_pager_slid,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &shared_region_pager_slid, "");
+SYSCTL_QUAD(_vm, OID_AUTO, shared_region_pager_slid_error,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &shared_region_pager_slid_error, "");
+SYSCTL_QUAD(_vm, OID_AUTO, shared_region_pager_reclaimed,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &shared_region_pager_reclaimed, "");
+
+#if MACH_ASSERT
+extern int pmap_ledgers_panic_leeway;
+SYSCTL_INT(_vm, OID_AUTO, pmap_ledgers_panic_leeway, CTLFLAG_RW | CTLFLAG_LOCKED, &pmap_ledgers_panic_leeway, 0, "");
+#endif /* MACH_ASSERT */
+
+extern int vm_protect_privileged_from_untrusted;
+SYSCTL_INT(_vm, OID_AUTO, protect_privileged_from_untrusted,
+    CTLFLAG_RW | CTLFLAG_LOCKED, &vm_protect_privileged_from_untrusted, 0, "");
+extern uint64_t vm_copied_on_read;
+SYSCTL_QUAD(_vm, OID_AUTO, copied_on_read,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &vm_copied_on_read, "");