xnu-7195.50.7.100.1.tar.gz

[apple/xnu.git] / osfmk / kern / ipc_host.c

diff --git a/osfmk/kern/ipc_host.c b/osfmk/kern/ipc_host.c
index 65f1035fe92a267f4561cd2b7a069c3c548b80a4..427bcee120ad880d65b016c0bd702bf1c420c5fe 100644 (file)
--- a/osfmk/kern/ipc_host.c
+++ b/osfmk/kern/ipc_host.c
@@ -2,7 +2,7 @@
  * Copyright (c) 2000-2009 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * Copyright (c) 2000-2009 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,34 +22,34 @@
  * 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@
  */
 /*
  * @OSF_COPYRIGHT@
  */
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /*
  * @OSF_COPYRIGHT@
  */

-/* 
+/*

  * Mach Operating System
  * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
  * All Rights Reserved.
  * Mach Operating System
  * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
  * All Rights Reserved.

- * 
+ *

  * Permission to use, copy, modify and distribute this software and its
  * documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.
  * Permission to use, copy, modify and distribute this software and its
  * documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.

- * 
+ *

  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.

- * 
+ *

  * Carnegie Mellon requests users of this software to return to
  * Carnegie Mellon requests users of this software to return to

- * 
+ *

  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890

- * 
+ *

  * any improvements or extensions that they make and grant Carnegie Mellon
  * the rights to redistribute these changes.
  */
  * any improvements or extensions that they make and grant Carnegie Mellon
  * the rights to redistribute these changes.
  */


@@ -67,7 +67,6 @@
 #include <mach/host_priv_server.h>
 #include <kern/host.h>
 #include <kern/processor.h>
 #include <mach/host_priv_server.h>
 #include <kern/host.h>
 #include <kern/processor.h>

-#include <kern/lock.h>

 #include <kern/task.h>
 #include <kern/thread.h>
 #include <kern/ipc_host.h>
 #include <kern/task.h>
 #include <kern/thread.h>
 #include <kern/ipc_host.h>


@@ -77,6 +76,10 @@
 #include <ipc/ipc_port.h>
 #include <ipc/ipc_space.h>
 
 #include <ipc/ipc_port.h>
 #include <ipc/ipc_space.h>
 

+#if CONFIG_MACF
+#include <security/mac_mach_internal.h>
+#endif
+

 /*
  * Forward declarations
  */
 /*
  * Forward declarations
  */


@@ -89,48 +92,45 @@ ref_pset_port_locked(
  *     ipc_host_init: set up various things.
  */
 
  *     ipc_host_init: set up various things.
  */
 

-extern lck_grp_t               host_notify_lock_grp;
-extern lck_attr_t              host_notify_lock_attr;
+extern lck_grp_t                host_notify_lock_grp;

 
 

-void ipc_host_init(void)
+void
+ipc_host_init(void)

 {
 {

-       ipc_port_t      port;
+       ipc_port_t      port;

        int i;
 
        int i;
 

-       lck_mtx_init(&realhost.lock, &host_notify_lock_grp, &host_notify_lock_attr);
+       lck_mtx_init(&realhost.lock, &host_notify_lock_grp, LCK_ATTR_NULL);

 
        /*
         *      Allocate and set up the two host ports.
         */
 
        /*
         *      Allocate and set up the two host ports.
         */

-       port = ipc_port_alloc_kernel();
-       if (port == IP_NULL)
-               panic("ipc_host_init");
-
-       ipc_kobject_set(port, (ipc_kobject_t) &realhost, IKOT_HOST_SECURITY);
-       kernel_set_special_port(&realhost, HOST_SECURITY_PORT,
-                               ipc_port_make_send(port));
-
-       port = ipc_port_alloc_kernel();
-       if (port == IP_NULL)
-               panic("ipc_host_init");
-
-       ipc_kobject_set(port, (ipc_kobject_t) &realhost, IKOT_HOST);
-       kernel_set_special_port(&realhost, HOST_PORT,
-                               ipc_port_make_send(port));
+       port = ipc_kobject_alloc_port((ipc_kobject_t) &realhost, IKOT_HOST_SECURITY,
+           IPC_KOBJECT_ALLOC_MAKE_SEND);
+       kernel_set_special_port(&realhost, HOST_SECURITY_PORT, port);

 
 

-       port = ipc_port_alloc_kernel();
-       if (port == IP_NULL)
-               panic("ipc_host_init");
+       port = ipc_kobject_alloc_port((ipc_kobject_t) &realhost, IKOT_HOST,
+           IPC_KOBJECT_ALLOC_MAKE_SEND);
+       kernel_set_special_port(&realhost, HOST_PORT, port);

 
 

-       ipc_kobject_set(port, (ipc_kobject_t) &realhost, IKOT_HOST_PRIV);
-       kernel_set_special_port(&realhost, HOST_PRIV_PORT,
-                               ipc_port_make_send(port));
+       port = ipc_kobject_alloc_port((ipc_kobject_t) &realhost, IKOT_HOST_PRIV,
+           IPC_KOBJECT_ALLOC_MAKE_SEND);
+       kernel_set_special_port(&realhost, HOST_PRIV_PORT, port);

 
        /* the rest of the special ports will be set up later */
 
 
        /* the rest of the special ports will be set up later */
 

+       bzero(&realhost.exc_actions[0], sizeof(realhost.exc_actions[0]));

        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {

-                       realhost.exc_actions[i].port = IP_NULL;
-               }/* for */
+               realhost.exc_actions[i].port = IP_NULL;
+               /* The mac framework is not yet initialized, so we defer
+                * initializing the labels to later, when they are set
+                * for the first time. */
+               realhost.exc_actions[i].label = NULL;
+               /* initialize the entire exception action struct */
+               realhost.exc_actions[i].behavior = 0;
+               realhost.exc_actions[i].flavor = 0;
+               realhost.exc_actions[i].privileged = FALSE;
+       } /* for */

 
        /*
         *      Set up ipc for default processor set.
 
        /*
         *      Set up ipc for default processor set.


@@ -160,10 +160,13 @@ mach_port_name_t
 host_self_trap(
        __unused struct host_self_trap_args *args)
 {
 host_self_trap(
        __unused struct host_self_trap_args *args)
 {

+       task_t self = current_task();

        ipc_port_t sright;
        mach_port_name_t name;
 
        ipc_port_t sright;
        mach_port_name_t name;
 

-       sright = ipc_port_copy_send(current_task()->itk_host);
+       itk_lock(self);
+       sright = ipc_port_copy_send(self->itk_host);
+       itk_unlock(self);

        name = ipc_port_copyout_send(sright, current_space());
        return name;
 }
        name = ipc_port_copyout_send(sright, current_space());
        return name;
 }


@@ -176,13 +179,14 @@ host_self_trap(
 
 void
 ipc_processor_init(
 
 void
 ipc_processor_init(

-       processor_t     processor)
+       processor_t     processor)

 {
 {

-       ipc_port_t      port;
+       ipc_port_t      port;

 
        port = ipc_port_alloc_kernel();
 
        port = ipc_port_alloc_kernel();

-       if (port == IP_NULL)
+       if (port == IP_NULL) {

                panic("ipc_processor_init");
                panic("ipc_processor_init");

+       }

        processor->processor_self = port;
 }
 
        processor->processor_self = port;
 }
 


@@ -193,14 +197,14 @@ ipc_processor_init(
  */
 void
 ipc_processor_enable(
  */
 void
 ipc_processor_enable(

-       processor_t     processor)
+       processor_t     processor)

 {
 {

-       ipc_port_t      myport;
+       ipc_port_t      myport;

 
        myport = processor->processor_self;
        ipc_kobject_set(myport, (ipc_kobject_t) processor, IKOT_PROCESSOR);
 }
 
        myport = processor->processor_self;
        ipc_kobject_set(myport, (ipc_kobject_t) processor, IKOT_PROCESSOR);
 }

-       
+

 /*
  *     ipc_pset_init:
  *
 /*
  *     ipc_pset_init:
  *


@@ -209,18 +213,20 @@ ipc_processor_enable(
 
 void
 ipc_pset_init(
 
 void
 ipc_pset_init(

-       processor_set_t         pset)
+       processor_set_t         pset)

 {
 {

-       ipc_port_t      port;
+       ipc_port_t      port;

 
        port = ipc_port_alloc_kernel();
 
        port = ipc_port_alloc_kernel();

-       if (port == IP_NULL)
+       if (port == IP_NULL) {

                panic("ipc_pset_init");
                panic("ipc_pset_init");

+       }

        pset->pset_self = port;
 
        port = ipc_port_alloc_kernel();
        pset->pset_self = port;
 
        port = ipc_port_alloc_kernel();

-       if (port == IP_NULL)
+       if (port == IP_NULL) {

                panic("ipc_pset_init");
                panic("ipc_pset_init");

+       }

        pset->pset_name_self = port;
 }
 
        pset->pset_name_self = port;
 }
 


@@ -231,7 +237,7 @@ ipc_pset_init(
  */
 void
 ipc_pset_enable(
  */
 void
 ipc_pset_enable(

-       processor_set_t         pset)
+       processor_set_t         pset)

 {
        ipc_kobject_set(pset->pset_self, (ipc_kobject_t) pset, IKOT_PSET);
        ipc_kobject_set(pset->pset_name_self, (ipc_kobject_t) pset, IKOT_PSET_NAME);
 {
        ipc_kobject_set(pset->pset_self, (ipc_kobject_t) pset, IKOT_PSET);
        ipc_kobject_set(pset->pset_name_self, (ipc_kobject_t) pset, IKOT_PSET_NAME);


@@ -244,15 +250,16 @@ ipc_pset_enable(
  */
 kern_return_t
 processor_set_default(
  */
 kern_return_t
 processor_set_default(

-       host_t                  host,
-       processor_set_t         *pset)
+       host_t                  host,
+       processor_set_t         *pset)

 {
 {

-       if (host == HOST_NULL)
-               return(KERN_INVALID_ARGUMENT);
+       if (host == HOST_NULL) {
+               return KERN_INVALID_ARGUMENT;
+       }

 
        *pset = &pset0;
 
 
        *pset = &pset0;
 

-       return (KERN_SUCCESS);
+       return KERN_SUCCESS;

 }
 
 /*
 }
 
 /*


@@ -266,20 +273,17 @@ processor_set_default(
 
 host_t
 convert_port_to_host(
 
 host_t
 convert_port_to_host(

-       ipc_port_t      port)
+       ipc_port_t      port)

 {
        host_t host = HOST_NULL;
 
        if (IP_VALID(port)) {
 {
        host_t host = HOST_NULL;
 
        if (IP_VALID(port)) {

-               ip_lock(port);
-               if (ip_active(port) &&
-                   ((ip_kotype(port) == IKOT_HOST) ||
-                    (ip_kotype(port) == IKOT_HOST_PRIV) 
-                    ))
-                       host = (host_t) port->ip_kobject;
-               ip_unlock(port);
+               if (ip_kotype(port) == IKOT_HOST ||
+                   ip_kotype(port) == IKOT_HOST_PRIV) {
+                       host = (host_t) ip_get_kobject(port);
+                       require_ip_active(port);
+               }

        }
        }

-

        return host;
 }
 
        return host;
 }
 


@@ -294,15 +298,16 @@ convert_port_to_host(
 
 host_t
 convert_port_to_host_priv(
 
 host_t
 convert_port_to_host_priv(

-       ipc_port_t      port)
+       ipc_port_t      port)

 {
        host_t host = HOST_NULL;
 
        if (IP_VALID(port)) {
                ip_lock(port);
                if (ip_active(port) &&
 {
        host_t host = HOST_NULL;
 
        if (IP_VALID(port)) {
                ip_lock(port);
                if (ip_active(port) &&

-                   (ip_kotype(port) == IKOT_HOST_PRIV))
-                       host = (host_t) port->ip_kobject;
+                   (ip_kotype(port) == IKOT_HOST_PRIV)) {
+                       host = (host_t) ip_get_kobject(port);
+               }

                ip_unlock(port);
        }
 
                ip_unlock(port);
        }
 


@@ -321,15 +326,16 @@ convert_port_to_host_priv(
 
 processor_t
 convert_port_to_processor(
 
 processor_t
 convert_port_to_processor(

-       ipc_port_t      port)
+       ipc_port_t      port)

 {
        processor_t processor = PROCESSOR_NULL;
 
        if (IP_VALID(port)) {
                ip_lock(port);
                if (ip_active(port) &&
 {
        processor_t processor = PROCESSOR_NULL;
 
        if (IP_VALID(port)) {
                ip_lock(port);
                if (ip_active(port) &&

-                   (ip_kotype(port) == IKOT_PROCESSOR))
-                       processor = (processor_t) port->ip_kobject;
+                   (ip_kotype(port) == IKOT_PROCESSOR)) {
+                       processor = (processor_t) ip_get_kobject(port);
+               }

                ip_unlock(port);
        }
 
                ip_unlock(port);
        }
 


@@ -348,7 +354,7 @@ convert_port_to_processor(
 
 processor_set_t
 convert_port_to_pset(
 
 processor_set_t
 convert_port_to_pset(

-       ipc_port_t      port)
+       ipc_port_t      port)

 {
        boolean_t r;
        processor_set_t pset = PROCESSOR_SET_NULL;
 {
        boolean_t r;
        processor_set_t pset = PROCESSOR_SET_NULL;


@@ -374,7 +380,7 @@ convert_port_to_pset(
 
 processor_set_name_t
 convert_port_to_pset_name(
 
 processor_set_name_t
 convert_port_to_pset_name(

-       ipc_port_t      port)
+       ipc_port_t      port)

 {
        boolean_t r;
        processor_set_t pset = PROCESSOR_SET_NULL;
 {
        boolean_t r;
        processor_set_t pset = PROCESSOR_SET_NULL;


@@ -395,15 +401,15 @@ ref_pset_port_locked(ipc_port_t port, boolean_t matchn, processor_set_t *ppset)
 
        pset = PROCESSOR_SET_NULL;
        if (ip_active(port) &&
 
        pset = PROCESSOR_SET_NULL;
        if (ip_active(port) &&

-               ((ip_kotype(port) == IKOT_PSET) ||
-                       (matchn && (ip_kotype(port) == IKOT_PSET_NAME)))) {
-               pset = (processor_set_t) port->ip_kobject;
+           ((ip_kotype(port) == IKOT_PSET) ||
+           (matchn && (ip_kotype(port) == IKOT_PSET_NAME)))) {
+               pset = (processor_set_t) ip_get_kobject(port);

        }
 
        *ppset = pset;
        ip_unlock(port);
 
        }
 
        *ppset = pset;
        ip_unlock(port);
 

-       return (TRUE);
+       return TRUE;

 }
 
 /*
 }
 
 /*


@@ -417,7 +423,7 @@ ref_pset_port_locked(ipc_port_t port, boolean_t matchn, processor_set_t *ppset)
 
 ipc_port_t
 convert_host_to_port(
 
 ipc_port_t
 convert_host_to_port(

-       host_t          host)
+       host_t          host)

 {
        ipc_port_t port;
 
 {
        ipc_port_t port;
 


@@ -437,12 +443,13 @@ convert_host_to_port(
 
 ipc_port_t
 convert_processor_to_port(
 
 ipc_port_t
 convert_processor_to_port(

-       processor_t             processor)
+       processor_t             processor)

 {
        ipc_port_t port = processor->processor_self;
 
 {
        ipc_port_t port = processor->processor_self;
 

-       if (port != IP_NULL)
+       if (port != IP_NULL) {

                port = ipc_port_make_send(port);
                port = ipc_port_make_send(port);

+       }

        return port;
 }
 
        return port;
 }
 


@@ -458,12 +465,13 @@ convert_processor_to_port(
 
 ipc_port_t
 convert_pset_to_port(
 
 ipc_port_t
 convert_pset_to_port(

-       processor_set_t         pset)
+       processor_set_t         pset)

 {
        ipc_port_t port = pset->pset_self;
 
 {
        ipc_port_t port = pset->pset_self;
 

-       if (port != IP_NULL)
+       if (port != IP_NULL) {

                port = ipc_port_make_send(port);
                port = ipc_port_make_send(port);

+       }

 
        return port;
 }
 
        return port;
 }


@@ -480,12 +488,13 @@ convert_pset_to_port(
 
 ipc_port_t
 convert_pset_name_to_port(
 
 ipc_port_t
 convert_pset_name_to_port(

-       processor_set_name_t            pset)
+       processor_set_name_t            pset)

 {
        ipc_port_t port = pset->pset_name_self;
 
 {
        ipc_port_t port = pset->pset_name_self;
 

-       if (port != IP_NULL)
+       if (port != IP_NULL) {

                port = ipc_port_make_send(port);
                port = ipc_port_make_send(port);

+       }

 
        return port;
 }
 
        return port;
 }


@@ -508,8 +517,9 @@ convert_port_to_host_security(
        if (IP_VALID(port)) {
                ip_lock(port);
                if (ip_active(port) &&
        if (IP_VALID(port)) {
                ip_lock(port);
                if (ip_active(port) &&

-                   (ip_kotype(port) == IKOT_HOST_SECURITY))
-                       host = (host_t) port->ip_kobject;
+                   (ip_kotype(port) == IKOT_HOST_SECURITY)) {
+                       host = (host_t) ip_get_kobject(port);
+               }

                ip_unlock(port);
        }
 
                ip_unlock(port);
        }
 


@@ -534,27 +544,30 @@ convert_port_to_host_security(
  */
 kern_return_t
 host_set_exception_ports(
  */
 kern_return_t
 host_set_exception_ports(

-       host_priv_t                             host_priv,
-       exception_mask_t                exception_mask,
-       ipc_port_t                      new_port,
-       exception_behavior_t            new_behavior,
-       thread_state_flavor_t           new_flavor)
+       host_priv_t                     host_priv,
+       exception_mask_t                exception_mask,
+       ipc_port_t                      new_port,
+       exception_behavior_t            new_behavior,
+       thread_state_flavor_t           new_flavor)

 {
 {

-       register int    i;
-       ipc_port_t      old_port[EXC_TYPES_COUNT];
+       int     i;
+       ipc_port_t      old_port[EXC_TYPES_COUNT];
+
+#if CONFIG_MACF
+       struct label *deferred_labels[EXC_TYPES_COUNT];
+       struct label *new_label;
+#endif

 
        if (host_priv == HOST_PRIV_NULL) {
                return KERN_INVALID_ARGUMENT;
        }
 
 
        if (host_priv == HOST_PRIV_NULL) {
                return KERN_INVALID_ARGUMENT;
        }
 

-       assert(host_priv == &realhost);
-

        if (exception_mask & ~EXC_MASK_VALID) {
                return KERN_INVALID_ARGUMENT;
        }
 
        if (IP_VALID(new_port)) {
        if (exception_mask & ~EXC_MASK_VALID) {
                return KERN_INVALID_ARGUMENT;
        }
 
        if (IP_VALID(new_port)) {

-               switch (new_behavior & ~MACH_EXCEPTION_CODES) {
+               switch (new_behavior & ~MACH_EXCEPTION_MASK) {

                case EXCEPTION_DEFAULT:
                case EXCEPTION_STATE:
                case EXCEPTION_STATE_IDENTITY:
                case EXCEPTION_DEFAULT:
                case EXCEPTION_STATE:
                case EXCEPTION_STATE_IDENTITY:


@@ -563,34 +576,86 @@ host_set_exception_ports(
                        return KERN_INVALID_ARGUMENT;
                }
        }
                        return KERN_INVALID_ARGUMENT;
                }
        }

-       /* Cannot easily check "new_flavor", but that just means that
-        * the flavor in the generated exception message might be garbage:
-        * GIGO
+
+       /*
+        * Check the validity of the thread_state_flavor by calling the
+        * VALID_THREAD_STATE_FLAVOR architecture dependent macro defined in
+        * osfmk/mach/ARCHITECTURE/thread_status.h

         */
         */

+       if (new_flavor != 0 && !VALID_THREAD_STATE_FLAVOR(new_flavor)) {
+               return KERN_INVALID_ARGUMENT;
+       }
+
+#if CONFIG_MACF
+       if (mac_task_check_set_host_exception_ports(current_task(), exception_mask) != 0) {
+               return KERN_NO_ACCESS;
+       }
+
+       new_label = mac_exc_create_label_for_current_proc();
+
+       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
+               if (host_priv->exc_actions[i].label == NULL) {
+                       deferred_labels[i] = mac_exc_create_label();
+               } else {
+                       deferred_labels[i] = NULL;
+               }
+       }
+#endif
+
+       assert(host_priv == &realhost);
+

        host_lock(host_priv);
 
        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
        host_lock(host_priv);
 
        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {

-               if (exception_mask & (1 << i)) {
+#if CONFIG_MACF
+               if (host_priv->exc_actions[i].label == NULL) {
+                       // Lazy initialization (see ipc_port_init).
+                       mac_exc_associate_action_label(&host_priv->exc_actions[i], deferred_labels[i]);
+                       deferred_labels[i] = NULL; // Label is used, do not free.
+               }
+#endif
+
+               if ((exception_mask & (1 << i))
+#if CONFIG_MACF
+                   && mac_exc_update_action_label(&host_priv->exc_actions[i], new_label) == 0
+#endif
+                   ) {

                        old_port[i] = host_priv->exc_actions[i].port;
                        old_port[i] = host_priv->exc_actions[i].port;

+

                        host_priv->exc_actions[i].port =
                        host_priv->exc_actions[i].port =

-                               ipc_port_copy_send(new_port);
+                           ipc_port_copy_send(new_port);

                        host_priv->exc_actions[i].behavior = new_behavior;
                        host_priv->exc_actions[i].flavor = new_flavor;
                        host_priv->exc_actions[i].behavior = new_behavior;
                        host_priv->exc_actions[i].flavor = new_flavor;

-               } else
+               } else {

                        old_port[i] = IP_NULL;
                        old_port[i] = IP_NULL;

+               }

        }/* for */
 
        /*
         * Consume send rights without any lock held.
         */
        host_unlock(host_priv);
        }/* for */
 
        /*
         * Consume send rights without any lock held.
         */
        host_unlock(host_priv);

-       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++)
-               if (IP_VALID(old_port[i]))
+
+#if CONFIG_MACF
+       mac_exc_free_label(new_label);
+#endif
+
+       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
+               if (IP_VALID(old_port[i])) {

                        ipc_port_release_send(old_port[i]);
                        ipc_port_release_send(old_port[i]);

-       if (IP_VALID(new_port))          /* consume send right */
+               }
+#if CONFIG_MACF
+               if (deferred_labels[i] != NULL) {
+                       /* Deferred label went unused: Another thread has completed the lazy initialization. */
+                       mac_exc_free_label(deferred_labels[i]);
+               }
+#endif
+       }
+       if (IP_VALID(new_port)) {        /* consume send right */

                ipc_port_release_send(new_port);
                ipc_port_release_send(new_port);

+       }

 
 

-        return KERN_SUCCESS;
+       return KERN_SUCCESS;

 }
 
 /*
 }
 
 /*


@@ -613,24 +678,25 @@ host_set_exception_ports(
  */
 kern_return_t
 host_get_exception_ports(
  */
 kern_return_t
 host_get_exception_ports(

-       host_priv_t                     host_priv,
+       host_priv_t                     host_priv,

        exception_mask_t                exception_mask,
        exception_mask_t                exception_mask,

-       exception_mask_array_t          masks,
-       mach_msg_type_number_t          * CountCnt,
-       exception_port_array_t          ports,
+       exception_mask_array_t          masks,
+       mach_msg_type_number_t          * CountCnt,
+       exception_port_array_t          ports,

        exception_behavior_array_t      behaviors,
        exception_behavior_array_t      behaviors,

-       thread_state_flavor_array_t     flavors         )
+       thread_state_flavor_array_t     flavors         )

 {
 {

-       unsigned int    i, j, count;
+       unsigned int    i, j, count;

 
 

-       if (host_priv == HOST_PRIV_NULL)
+       if (host_priv == HOST_PRIV_NULL) {

                return KERN_INVALID_ARGUMENT;
                return KERN_INVALID_ARGUMENT;

+       }

 
        if (exception_mask & ~EXC_MASK_VALID) {
                return KERN_INVALID_ARGUMENT;
        }
 
 
        if (exception_mask & ~EXC_MASK_VALID) {
                return KERN_INVALID_ARGUMENT;
        }
 

-       assert (host_priv == &realhost);
+       assert(host_priv == &realhost);

 
        host_lock(host_priv);
 
 
        host_lock(host_priv);
 


@@ -644,9 +710,8 @@ host_get_exception_ports(
  *                             set corresponding mask for this exception.
  */
                                if (host_priv->exc_actions[i].port == ports[j] &&
  *                             set corresponding mask for this exception.
  */
                                if (host_priv->exc_actions[i].port == ports[j] &&

-                                       host_priv->exc_actions[i].behavior == behaviors[j]
-                                 && host_priv->exc_actions[i].flavor == flavors[j])
-                               {
+                                   host_priv->exc_actions[i].behavior == behaviors[j]
+                                   && host_priv->exc_actions[i].flavor == flavors[j]) {

                                        masks[j] |= (1 << i);
                                        break;
                                }
                                        masks[j] |= (1 << i);
                                        break;
                                }


@@ -654,7 +719,7 @@ host_get_exception_ports(
                        if (j == count) {
                                masks[j] = (1 << i);
                                ports[j] =
                        if (j == count) {
                                masks[j] = (1 << i);
                                ports[j] =

-                                 ipc_port_copy_send(host_priv->exc_actions[i].port);
+                                   ipc_port_copy_send(host_priv->exc_actions[i].port);

                                behaviors[j] = host_priv->exc_actions[i].behavior;
                                flavors[j] = host_priv->exc_actions[i].flavor;
                                count++;
                                behaviors[j] = host_priv->exc_actions[i].behavior;
                                flavors[j] = host_priv->exc_actions[i].flavor;
                                count++;


@@ -672,24 +737,30 @@ host_get_exception_ports(
 
 kern_return_t
 host_swap_exception_ports(
 
 kern_return_t
 host_swap_exception_ports(

-       host_priv_t                             host_priv,
-       exception_mask_t                exception_mask,
-       ipc_port_t                      new_port,
-       exception_behavior_t            new_behavior,
-       thread_state_flavor_t           new_flavor,
-       exception_mask_array_t          masks,
-       mach_msg_type_number_t          * CountCnt,
-       exception_port_array_t          ports,
+       host_priv_t                     host_priv,
+       exception_mask_t                exception_mask,
+       ipc_port_t                      new_port,
+       exception_behavior_t            new_behavior,
+       thread_state_flavor_t           new_flavor,
+       exception_mask_array_t          masks,
+       mach_msg_type_number_t          * CountCnt,
+       exception_port_array_t          ports,

        exception_behavior_array_t      behaviors,
        exception_behavior_array_t      behaviors,

-       thread_state_flavor_array_t     flavors         )
+       thread_state_flavor_array_t     flavors         )

 {
 {

-       unsigned int    i,
-                       j,
-                       count;
-       ipc_port_t      old_port[EXC_TYPES_COUNT];
+       unsigned int    i,
+           j,
+           count;
+       ipc_port_t      old_port[EXC_TYPES_COUNT];
+
+#if CONFIG_MACF
+       struct label *deferred_labels[EXC_TYPES_COUNT];
+       struct label *new_label;
+#endif

 
 

-       if (host_priv == HOST_PRIV_NULL)
+       if (host_priv == HOST_PRIV_NULL) {

                return KERN_INVALID_ARGUMENT;
                return KERN_INVALID_ARGUMENT;

+       }

 
        if (exception_mask & ~EXC_MASK_VALID) {
                return KERN_INVALID_ARGUMENT;
 
        if (exception_mask & ~EXC_MASK_VALID) {
                return KERN_INVALID_ARGUMENT;


@@ -705,25 +776,52 @@ host_swap_exception_ports(
                        return KERN_INVALID_ARGUMENT;
                }
        }
                        return KERN_INVALID_ARGUMENT;
                }
        }

-       /* Cannot easily check "new_flavor", but that just means that
-        * the flavor in the generated exception message might be garbage:
-        * GIGO */

 
 

-       host_lock(host_priv);
+       if (new_flavor != 0 && !VALID_THREAD_STATE_FLAVOR(new_flavor)) {
+               return KERN_INVALID_ARGUMENT;
+       }

 
 

-       count = 0;
+#if CONFIG_MACF
+       if (mac_task_check_set_host_exception_ports(current_task(), exception_mask) != 0) {
+               return KERN_NO_ACCESS;
+       }
+
+       new_label = mac_exc_create_label_for_current_proc();

 
        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
 
        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {

-               if (exception_mask & (1 << i)) {
+               if (host_priv->exc_actions[i].label == NULL) {
+                       deferred_labels[i] = mac_exc_create_label();
+               } else {
+                       deferred_labels[i] = NULL;
+               }
+       }
+#endif /* CONFIG_MACF */
+
+       host_lock(host_priv);
+
+       assert(EXC_TYPES_COUNT > FIRST_EXCEPTION);
+       for (count = 0, i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT && count < *CountCnt; i++) {
+#if CONFIG_MACF
+               if (host_priv->exc_actions[i].label == NULL) {
+                       // Lazy initialization (see ipc_port_init).
+                       mac_exc_associate_action_label(&host_priv->exc_actions[i], deferred_labels[i]);
+                       deferred_labels[i] = NULL; // Label is used, do not free.
+               }
+#endif
+
+               if ((exception_mask & (1 << i))
+#if CONFIG_MACF
+                   && mac_exc_update_action_label(&host_priv->exc_actions[i], new_label) == 0
+#endif
+                   ) {

                        for (j = 0; j < count; j++) {
 /*
  *                             search for an identical entry, if found
  *                             set corresponding mask for this exception.
  */
                                if (host_priv->exc_actions[i].port == ports[j] &&
                        for (j = 0; j < count; j++) {
 /*
  *                             search for an identical entry, if found
  *                             set corresponding mask for this exception.
  */
                                if (host_priv->exc_actions[i].port == ports[j] &&

-                                 host_priv->exc_actions[i].behavior == behaviors[j]
-                                 && host_priv->exc_actions[i].flavor == flavors[j])
-                               {
+                                   host_priv->exc_actions[i].behavior == behaviors[j]
+                                   && host_priv->exc_actions[i].flavor == flavors[j]) {

                                        masks[j] |= (1 << i);
                                        break;
                                }
                                        masks[j] |= (1 << i);
                                        break;
                                }


@@ -731,32 +829,43 @@ host_swap_exception_ports(
                        if (j == count) {
                                masks[j] = (1 << i);
                                ports[j] =
                        if (j == count) {
                                masks[j] = (1 << i);
                                ports[j] =

-                               ipc_port_copy_send(host_priv->exc_actions[i].port);
+                                   ipc_port_copy_send(host_priv->exc_actions[i].port);

                                behaviors[j] = host_priv->exc_actions[i].behavior;
                                flavors[j] = host_priv->exc_actions[i].flavor;
                                count++;
                        }
                        old_port[i] = host_priv->exc_actions[i].port;
                        host_priv->exc_actions[i].port =
                                behaviors[j] = host_priv->exc_actions[i].behavior;
                                flavors[j] = host_priv->exc_actions[i].flavor;
                                count++;
                        }
                        old_port[i] = host_priv->exc_actions[i].port;
                        host_priv->exc_actions[i].port =

-                               ipc_port_copy_send(new_port);
+                           ipc_port_copy_send(new_port);

                        host_priv->exc_actions[i].behavior = new_behavior;
                        host_priv->exc_actions[i].flavor = new_flavor;
                        host_priv->exc_actions[i].behavior = new_behavior;
                        host_priv->exc_actions[i].flavor = new_flavor;

-                       if (count > *CountCnt) {
-                               break;
-                       }
-               } else
+               } else {

                        old_port[i] = IP_NULL;
                        old_port[i] = IP_NULL;

+               }

        }/* for */
        host_unlock(host_priv);
 
        }/* for */
        host_unlock(host_priv);
 

+#if CONFIG_MACF
+       mac_exc_free_label(new_label);
+#endif
+

        /*
         * Consume send rights without any lock held.
         */
        /*
         * Consume send rights without any lock held.
         */

-       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++)
-               if (IP_VALID(old_port[i]))
+       while (--i >= FIRST_EXCEPTION) {
+               if (IP_VALID(old_port[i])) {

                        ipc_port_release_send(old_port[i]);
                        ipc_port_release_send(old_port[i]);

-       if (IP_VALID(new_port))          /* consume send right */
+               }
+#if CONFIG_MACF
+               if (deferred_labels[i] != NULL) {
+                       mac_exc_free_label(deferred_labels[i]); // Label unused.
+               }
+#endif
+       }
+
+       if (IP_VALID(new_port)) {        /* consume send right */

                ipc_port_release_send(new_port);
                ipc_port_release_send(new_port);

+       }

        *CountCnt = count;
 
        return KERN_SUCCESS;
        *CountCnt = count;
 
        return KERN_SUCCESS;