xnu-2782.40.9.tar.gz

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

diff --git a/osfmk/kern/ipc_tt.c b/osfmk/kern/ipc_tt.c
index 548a47297105e5999912cc961cddb57258dd3114..9a870298f9f48e4a89845cef2f47f4445e17bf41 100644 (file)
--- a/osfmk/kern/ipc_tt.c
+++ b/osfmk/kern/ipc_tt.c
@@ -1,23 +1,29 @@
 /*
 /*

- * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2010 Apple Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * 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,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE 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_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*
  * @OSF_COPYRIGHT@
  */
 /*
  * @OSF_COPYRIGHT@


@@ -47,6 +53,12 @@
  * 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.
  */

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

 /*
  */
 
 /*
  */
 


@@ -82,9 +94,10 @@
 
 #include <vm/vm_map.h>
 #include <vm/vm_pageout.h>
 
 #include <vm/vm_map.h>
 #include <vm/vm_pageout.h>

-#include <vm/vm_shared_memory_server.h>

 #include <vm/vm_protos.h>
 
 #include <vm/vm_protos.h>
 

+#include <security/mac_mach_internal.h>
+

 /* forward declarations */
 task_t convert_port_to_locked_task(ipc_port_t port);
 
 /* forward declarations */
 task_t convert_port_to_locked_task(ipc_port_t port);
 


@@ -116,6 +129,7 @@ ipc_task_init(
        if (kr != KERN_SUCCESS)
                panic("ipc_task_init");
 
        if (kr != KERN_SUCCESS)
                panic("ipc_task_init");
 

+       space->is_task = task;

 
        kport = ipc_port_alloc_kernel();
        if (kport == IP_NULL)
 
        kport = ipc_port_alloc_kernel();
        if (kport == IP_NULL)


@@ -128,9 +142,10 @@ ipc_task_init(
        itk_lock_init(task);
        task->itk_self = kport;
        task->itk_nself = nport;
        itk_lock_init(task);
        task->itk_self = kport;
        task->itk_nself = nport;

+       task->itk_resume = IP_NULL; /* Lazily allocated on-demand */

        task->itk_sself = ipc_port_make_send(kport);
        task->itk_sself = ipc_port_make_send(kport);

+       task->itk_debug_control = IP_NULL;

        task->itk_space = space;
        task->itk_space = space;

-       space->is_fast = FALSE;

 
        if (parent == TASK_NULL) {
                ipc_port_t port;
 
        if (parent == TASK_NULL) {
                ipc_port_t port;


@@ -144,6 +159,9 @@ ipc_task_init(
                task->itk_host = port;
 
                task->itk_bootstrap = IP_NULL;
                task->itk_host = port;
 
                task->itk_bootstrap = IP_NULL;

+               task->itk_seatbelt = IP_NULL;
+               task->itk_gssd = IP_NULL;
+               task->itk_task_access = IP_NULL;

 
                for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
                        task->itk_registered[i] = IP_NULL;
 
                for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
                        task->itk_registered[i] = IP_NULL;


@@ -175,6 +193,15 @@ ipc_task_init(
                task->itk_bootstrap =
                        ipc_port_copy_send(parent->itk_bootstrap);
 
                task->itk_bootstrap =
                        ipc_port_copy_send(parent->itk_bootstrap);
 

+               task->itk_seatbelt =
+                       ipc_port_copy_send(parent->itk_seatbelt);
+
+               task->itk_gssd =
+                       ipc_port_copy_send(parent->itk_gssd);
+
+               task->itk_task_access =
+                       ipc_port_copy_send(parent->itk_task_access);
+

                itk_unlock(parent);
        }
 }
                itk_unlock(parent);
        }
 }


@@ -218,6 +245,7 @@ ipc_task_disable(
 {
        ipc_port_t kport;
        ipc_port_t nport;
 {
        ipc_port_t kport;
        ipc_port_t nport;

+       ipc_port_t rport;

 
        itk_lock(task);
        kport = task->itk_self;
 
        itk_lock(task);
        kport = task->itk_self;


@@ -226,6 +254,23 @@ ipc_task_disable(
        nport = task->itk_nself;
        if (nport != IP_NULL)
                ipc_kobject_set(nport, IKO_NULL, IKOT_NONE);
        nport = task->itk_nself;
        if (nport != IP_NULL)
                ipc_kobject_set(nport, IKO_NULL, IKOT_NONE);

+
+       rport = task->itk_resume;
+       if (rport != IP_NULL) {
+               /*
+                * From this point onwards this task is no longer accepting
+                * resumptions.
+                *
+                * There are still outstanding suspensions on this task,
+                * even as it is being torn down. Disconnect the task
+                * from the rport, thereby "orphaning" the rport. The rport 
+                * itself will go away only when the last suspension holder
+                * destroys his SO right to it -- when he either
+                * exits, or tries to actually use that last SO right to
+                * resume this (now non-existent) task.
+                */
+               ipc_kobject_set(rport, IKO_NULL, IKOT_NONE);
+       }

        itk_unlock(task);
 }
 
        itk_unlock(task);
 }
 


@@ -244,6 +289,7 @@ ipc_task_terminate(
 {
        ipc_port_t kport;
        ipc_port_t nport;
 {
        ipc_port_t kport;
        ipc_port_t nport;

+       ipc_port_t rport;       

        int i;
 
        itk_lock(task);
        int i;
 
        itk_lock(task);


@@ -260,6 +306,9 @@ ipc_task_terminate(
        assert(nport != IP_NULL);
        task->itk_nself = IP_NULL;
 
        assert(nport != IP_NULL);
        task->itk_nself = IP_NULL;
 

+       rport = task->itk_resume;
+       task->itk_resume = IP_NULL;
+

        itk_unlock(task);
 
        /* release the naked send rights */
        itk_unlock(task);
 
        /* release the naked send rights */


@@ -279,16 +328,29 @@ ipc_task_terminate(
        if (IP_VALID(task->itk_bootstrap))
                ipc_port_release_send(task->itk_bootstrap);
 
        if (IP_VALID(task->itk_bootstrap))
                ipc_port_release_send(task->itk_bootstrap);
 

+       if (IP_VALID(task->itk_seatbelt))
+               ipc_port_release_send(task->itk_seatbelt);
+       
+       if (IP_VALID(task->itk_gssd))
+               ipc_port_release_send(task->itk_gssd);
+
+       if (IP_VALID(task->itk_task_access))
+               ipc_port_release_send(task->itk_task_access);
+
+       if (IP_VALID(task->itk_debug_control))
+               ipc_port_release_send(task->itk_debug_control);
+

        for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
                if (IP_VALID(task->itk_registered[i]))
                        ipc_port_release_send(task->itk_registered[i]);
 
        for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
                if (IP_VALID(task->itk_registered[i]))
                        ipc_port_release_send(task->itk_registered[i]);
 

-       ipc_port_release_send(task->wired_ledger_port);
-       ipc_port_release_send(task->paged_ledger_port);
-

        /* destroy the kernel ports */
        ipc_port_dealloc_kernel(kport);
        ipc_port_dealloc_kernel(nport);
        /* destroy the kernel ports */
        ipc_port_dealloc_kernel(kport);
        ipc_port_dealloc_kernel(nport);

+       if (rport != IP_NULL)
+               ipc_port_dealloc_kernel(rport); 
+
+       itk_lock_destroy(task);

 }
 
 /*
 }
 
 /*


@@ -341,7 +403,12 @@ ipc_task_reset(
                        old_exc_actions[i] = IP_NULL;
                }
        }/* for */
                        old_exc_actions[i] = IP_NULL;
                }
        }/* for */

-
+       
+       if (IP_VALID(task->itk_debug_control)) {
+               ipc_port_release_send(task->itk_debug_control);
+       }
+       task->itk_debug_control = IP_NULL;
+       

        itk_unlock(task);
 
        /* release the naked send rights */
        itk_unlock(task);
 
        /* release the naked send rights */


@@ -372,7 +439,6 @@ ipc_thread_init(
        thread_t        thread)
 {
        ipc_port_t      kport;
        thread_t        thread)
 {
        ipc_port_t      kport;

-       int                     i;

 
        kport = ipc_port_alloc_kernel();
        if (kport == IP_NULL)
 
        kport = ipc_port_alloc_kernel();
        if (kport == IP_NULL)


@@ -380,17 +446,40 @@ ipc_thread_init(
 
        thread->ith_self = kport;
        thread->ith_sself = ipc_port_make_send(kport);
 
        thread->ith_self = kport;
        thread->ith_sself = ipc_port_make_send(kport);

-
-       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; ++i)
-               thread->exc_actions[i].port = IP_NULL;
+       thread->exc_actions = NULL;

 
        ipc_kobject_set(kport, (ipc_kobject_t)thread, IKOT_THREAD);
 
 
        ipc_kobject_set(kport, (ipc_kobject_t)thread, IKOT_THREAD);
 

+#if IMPORTANCE_INHERITANCE
+       thread->ith_assertions = 0;
+#endif
+

        ipc_kmsg_queue_init(&thread->ith_messages);
 
        thread->ith_rpc_reply = IP_NULL;
 }
 
        ipc_kmsg_queue_init(&thread->ith_messages);
 
        thread->ith_rpc_reply = IP_NULL;
 }
 

+void
+ipc_thread_init_exc_actions(
+       thread_t        thread)
+{
+       assert(thread->exc_actions == NULL);
+
+       thread->exc_actions = kalloc(sizeof(struct exception_action) * EXC_TYPES_COUNT);
+       bzero(thread->exc_actions, sizeof(struct exception_action) * EXC_TYPES_COUNT);
+}
+
+void
+ipc_thread_destroy_exc_actions(
+       thread_t        thread)
+{
+       if (thread->exc_actions != NULL) {
+               kfree(thread->exc_actions, 
+                     sizeof(struct exception_action) * EXC_TYPES_COUNT);
+               thread->exc_actions = NULL;
+       }
+}
+

 void
 ipc_thread_disable(
        thread_t        thread)
 void
 ipc_thread_disable(
        thread_t        thread)


@@ -423,14 +512,21 @@ ipc_thread_terminate(
 
                thread->ith_sself = thread->ith_self = IP_NULL;
 
 
                thread->ith_sself = thread->ith_self = IP_NULL;
 

-               for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; ++i) {
-                       if (IP_VALID(thread->exc_actions[i].port))
-                               ipc_port_release_send(thread->exc_actions[i].port);
-        }
+               if (thread->exc_actions != NULL) {
+                       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; ++i) {
+                               if (IP_VALID(thread->exc_actions[i].port))
+                                       ipc_port_release_send(thread->exc_actions[i].port);
+                       }
+                       ipc_thread_destroy_exc_actions(thread);
+               }

 
                ipc_port_dealloc_kernel(kport);
        }
 
 
                ipc_port_dealloc_kernel(kport);
        }
 

+#if IMPORTANCE_INHERITANCE
+       assert(thread->ith_assertions == 0);
+#endif
+

        assert(ipc_kmsg_queue_empty(&thread->ith_messages));
 
        if (thread->ith_rpc_reply != IP_NULL)
        assert(ipc_kmsg_queue_empty(&thread->ith_messages));
 
        if (thread->ith_rpc_reply != IP_NULL)


@@ -458,7 +554,8 @@ ipc_thread_reset(
        ipc_port_t old_kport, new_kport;
        ipc_port_t old_sself;
        ipc_port_t old_exc_actions[EXC_TYPES_COUNT];
        ipc_port_t old_kport, new_kport;
        ipc_port_t old_sself;
        ipc_port_t old_exc_actions[EXC_TYPES_COUNT];

-       int i;
+       boolean_t  has_old_exc_actions = FALSE; 
+       int                i;

 
        new_kport = ipc_port_alloc_kernel();
        if (new_kport == IP_NULL)
 
        new_kport = ipc_port_alloc_kernel();
        if (new_kport == IP_NULL)


@@ -481,14 +578,21 @@ ipc_thread_reset(
        ipc_kobject_set(old_kport, IKO_NULL, IKOT_NONE);
        ipc_kobject_set(new_kport, (ipc_kobject_t) thread, IKOT_THREAD);
 
        ipc_kobject_set(old_kport, IKO_NULL, IKOT_NONE);
        ipc_kobject_set(new_kport, (ipc_kobject_t) thread, IKOT_THREAD);
 

-       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
-               if (!thread->exc_actions[i].privileged) {
-                       old_exc_actions[i] = thread->exc_actions[i].port;
-                       thread->exc_actions[i].port = IP_NULL;
-               } else {
-                       old_exc_actions[i] = IP_NULL;
+       /*
+        * Only ports that were set by root-owned processes
+        * (privileged ports) should survive 
+        */
+       if (thread->exc_actions != NULL) {
+               has_old_exc_actions = TRUE;
+               for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
+                       if (thread->exc_actions[i].privileged) {
+                               old_exc_actions[i] = IP_NULL;
+                       } else {
+                               old_exc_actions[i] = thread->exc_actions[i].port;
+                               thread->exc_actions[i].port = IP_NULL;          
+                       }

                }
                }

-       }/* for */
+       }

 
        thread_mtx_unlock(thread);
 
 
        thread_mtx_unlock(thread);
 


@@ -497,11 +601,11 @@ ipc_thread_reset(
        if (IP_VALID(old_sself))
                ipc_port_release_send(old_sself);
 
        if (IP_VALID(old_sself))
                ipc_port_release_send(old_sself);
 

-       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
-               if (IP_VALID(old_exc_actions[i])) {
+       if (has_old_exc_actions) {
+               for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {

                        ipc_port_release_send(old_exc_actions[i]);
                }
                        ipc_port_release_send(old_exc_actions[i]);
                }

-       }/* for */
+       }

 
        /* destroy the kernel port */
        ipc_port_dealloc_kernel(old_kport);
 
        /* destroy the kernel port */
        ipc_port_dealloc_kernel(old_kport);


@@ -813,15 +917,20 @@ task_get_special_port(
                port = ipc_port_copy_send(task->itk_bootstrap);
                break;
 
                port = ipc_port_copy_send(task->itk_bootstrap);
                break;
 

-            case TASK_WIRED_LEDGER_PORT:
-               port = ipc_port_copy_send(task->wired_ledger_port);
-                break;
+           case TASK_SEATBELT_PORT:
+               port = ipc_port_copy_send(task->itk_seatbelt);
+               break;
+
+           case TASK_ACCESS_PORT:
+               port = ipc_port_copy_send(task->itk_task_access);
+               break;
+
+               case TASK_DEBUG_CONTROL_PORT:
+               port = ipc_port_copy_send(task->itk_debug_control);
+               break;

 
 

-            case TASK_PAGED_LEDGER_PORT:
-               port = ipc_port_copy_send(task->paged_ledger_port);
-                break;
-                    

            default:
            default:

+               itk_unlock(task);

                return KERN_INVALID_ARGUMENT;
        }
        itk_unlock(task);
                return KERN_INVALID_ARGUMENT;
        }
        itk_unlock(task);


@@ -843,6 +952,7 @@ task_get_special_port(
  *             KERN_INVALID_ARGUMENT   The task is null.
  *             KERN_FAILURE            The task/space is dead.
  *             KERN_INVALID_ARGUMENT   Invalid special port.
  *             KERN_INVALID_ARGUMENT   The task is null.
  *             KERN_FAILURE            The task/space is dead.
  *             KERN_INVALID_ARGUMENT   Invalid special port.

+ *             KERN_NO_ACCESS          Attempted overwrite of seatbelt port.

  */
 
 kern_return_t
  */
 
 kern_return_t


@@ -870,14 +980,19 @@ task_set_special_port(
                whichp = &task->itk_bootstrap;
                break;
 
                whichp = &task->itk_bootstrap;
                break;
 

-            case TASK_WIRED_LEDGER_PORT:
-                whichp = &task->wired_ledger_port;
-                break;
+           case TASK_SEATBELT_PORT:
+               whichp = &task->itk_seatbelt;
+               break;
+
+           case TASK_ACCESS_PORT:
+               whichp = &task->itk_task_access;
+               break;
+               
+           case TASK_DEBUG_CONTROL_PORT: 
+               whichp = &task->itk_debug_control;
+               break;
+

 
 

-            case TASK_PAGED_LEDGER_PORT:
-                whichp = &task->paged_ledger_port;
-                break;
-                    

            default:
                return KERN_INVALID_ARGUMENT;
        }/* switch */
            default:
                return KERN_INVALID_ARGUMENT;
        }/* switch */


@@ -888,6 +1003,13 @@ task_set_special_port(
                return KERN_FAILURE;
        }
 
                return KERN_FAILURE;
        }
 

+       /* do not allow overwrite of seatbelt or task access ports */
+       if ((TASK_SEATBELT_PORT == which  || TASK_ACCESS_PORT == which) 
+               && IP_VALID(*whichp)) {
+                       itk_unlock(task);
+                       return KERN_NO_ACCESS;
+       }
+

        old = *whichp;
        *whichp = port;
        itk_unlock(task);
        old = *whichp;
        *whichp = port;
        itk_unlock(task);


@@ -914,6 +1036,7 @@ task_set_special_port(
  *             KERN_SUCCESS            Stashed the port rights.
  *             KERN_INVALID_ARGUMENT   The task is null.
  *             KERN_INVALID_ARGUMENT   The task is dead.
  *             KERN_SUCCESS            Stashed the port rights.
  *             KERN_INVALID_ARGUMENT   The task is null.
  *             KERN_INVALID_ARGUMENT   The task is dead.

+ *             KERN_INVALID_ARGUMENT   The memory param is null.

  *             KERN_INVALID_ARGUMENT   Too many port rights supplied.
  */
 
  *             KERN_INVALID_ARGUMENT   Too many port rights supplied.
  */
 


@@ -927,7 +1050,8 @@ mach_ports_register(
        unsigned int i;
 
        if ((task == TASK_NULL) ||
        unsigned int i;
 
        if ((task == TASK_NULL) ||

-           (portsCnt > TASK_PORT_REGISTER_MAX))
+           (portsCnt > TASK_PORT_REGISTER_MAX) ||
+           (portsCnt && memory == NULL))

                return KERN_INVALID_ARGUMENT;
 
        /*
                return KERN_INVALID_ARGUMENT;
 
        /*


@@ -1047,6 +1171,8 @@ mach_ports_lookup(
 task_t
 convert_port_to_locked_task(ipc_port_t port)
 {
 task_t
 convert_port_to_locked_task(ipc_port_t port)
 {

+        int try_failed_count = 0;
+

        while (IP_VALID(port)) {
                task_t task;
 
        while (IP_VALID(port)) {
                task_t task;
 


@@ -1066,9 +1192,10 @@ convert_port_to_locked_task(ipc_port_t port)
                        ip_unlock(port);
                        return(task);
                }
                        ip_unlock(port);
                        return(task);
                }

+               try_failed_count++;

 
                ip_unlock(port);
 
                ip_unlock(port);

-               mutex_pause();
+               mutex_pause(try_failed_count);

        }
        return TASK_NULL;
 }
        }
        return TASK_NULL;
 }


@@ -1138,6 +1265,38 @@ convert_port_to_task_name(
        return (task);
 }
 
        return (task);
 }
 

+/*
+ *     Routine:        convert_port_to_task_suspension_token
+ *     Purpose:
+ *             Convert from a port to a task suspension token.
+ *             Doesn't consume the port ref; produces a suspension token ref,
+ *             which may be null.
+ *     Conditions:
+ *             Nothing locked.
+ */
+task_suspension_token_t
+convert_port_to_task_suspension_token(
+       ipc_port_t              port)
+{
+       task_suspension_token_t         task = TASK_NULL;
+
+       if (IP_VALID(port)) {
+               ip_lock(port);
+
+               if (    ip_active(port)                                 &&
+                               ip_kotype(port) == IKOT_TASK_RESUME) {
+                       task = (task_suspension_token_t)port->ip_kobject;
+                       assert(task != TASK_NULL);
+
+                       task_reference_internal(task);
+               }
+
+               ip_unlock(port);
+       }
+
+       return (task);
+}
+

 /*
  *     Routine:        convert_port_to_space
  *     Purpose:
 /*
  *     Routine:        convert_port_to_space
  *     Purpose:


@@ -1317,6 +1476,50 @@ convert_task_to_port(
        return port;
 }
 
        return port;
 }
 

+/*
+ *     Routine:        convert_task_suspend_token_to_port
+ *     Purpose:
+ *             Convert from a task suspension token to a port.
+ *             Consumes a task suspension token ref; produces a naked send-once right
+ *             which may be invalid.  
+ *     Conditions:
+ *             Nothing locked.
+ */
+ipc_port_t
+convert_task_suspension_token_to_port(
+       task_suspension_token_t         task)
+{
+       ipc_port_t port;
+
+       task_lock(task);
+       if (task->active) {
+               if (task->itk_resume == IP_NULL) {
+                       task->itk_resume = ipc_port_alloc_kernel();
+                       if (!IP_VALID(task->itk_resume)) {
+                               panic("failed to create resume port");
+                       }
+
+                       ipc_kobject_set(task->itk_resume, (ipc_kobject_t) task, IKOT_TASK_RESUME);
+               }
+
+               /*
+                * Create a send-once right for each instance of a direct user-called
+                * task_suspend2 call. Each time one of these send-once rights is abandoned,
+                * the notification handler will resume the target task.
+                */
+               port = ipc_port_make_sonce(task->itk_resume);
+               assert(IP_VALID(port));
+       } else {
+               port = IP_NULL;
+       }
+
+       task_unlock(task);
+       task_suspension_token_deallocate(task);
+
+       return port;
+}
+
+

 /*
  *     Routine:        convert_task_name_to_port
  *     Purpose:
 /*
  *     Routine:        convert_task_name_to_port
  *     Purpose:


@@ -1423,11 +1626,11 @@ thread_set_exception_ports(
        if (thread == THREAD_NULL)
                return (KERN_INVALID_ARGUMENT);
 
        if (thread == THREAD_NULL)
                return (KERN_INVALID_ARGUMENT);
 

-       if (exception_mask & ~EXC_MASK_ALL)
+       if (exception_mask & ~EXC_MASK_VALID)

                return (KERN_INVALID_ARGUMENT);
 
        if (IP_VALID(new_port)) {
                return (KERN_INVALID_ARGUMENT);
 
        if (IP_VALID(new_port)) {

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

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


@@ -1444,7 +1647,7 @@ thread_set_exception_ports(
         * VALID_THREAD_STATE_FLAVOR architecture dependent macro defined in
         * osfmk/mach/ARCHITECTURE/thread_status.h
         */
         * VALID_THREAD_STATE_FLAVOR architecture dependent macro defined in
         * osfmk/mach/ARCHITECTURE/thread_status.h
         */

-       if (!VALID_THREAD_STATE_FLAVOR(new_flavor))
+       if (new_flavor != 0 && !VALID_THREAD_STATE_FLAVOR(new_flavor))

                return (KERN_INVALID_ARGUMENT);
 
        thread_mtx_lock(thread);
                return (KERN_INVALID_ARGUMENT);
 
        thread_mtx_lock(thread);


@@ -1455,6 +1658,9 @@ thread_set_exception_ports(
                return (KERN_FAILURE);
        }
 
                return (KERN_FAILURE);
        }
 

+       if (thread->exc_actions == NULL) {
+               ipc_thread_init_exc_actions(thread);
+       }

        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; ++i) {
                if (exception_mask & (1 << i)) {
                        old_port[i] = thread->exc_actions[i].port;
        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; ++i) {
                if (exception_mask & (1 << i)) {
                        old_port[i] = thread->exc_actions[i].port;


@@ -1494,11 +1700,11 @@ task_set_exception_ports(
        if (task == TASK_NULL)
                return (KERN_INVALID_ARGUMENT);
 
        if (task == TASK_NULL)
                return (KERN_INVALID_ARGUMENT);
 

-       if (exception_mask & ~EXC_MASK_ALL)
+       if (exception_mask & ~EXC_MASK_VALID)

                return (KERN_INVALID_ARGUMENT);
 
        if (IP_VALID(new_port)) {
                return (KERN_INVALID_ARGUMENT);
 
        if (IP_VALID(new_port)) {

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

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


@@ -1510,6 +1716,14 @@ task_set_exception_ports(
                }
        }
 
                }
        }
 

+       /*
+        * 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);
+

        itk_lock(task);
 
        if (task->itk_self == IP_NULL) {
        itk_lock(task);
 
        if (task->itk_self == IP_NULL) {


@@ -1590,11 +1804,11 @@ thread_swap_exception_ports(
        if (thread == THREAD_NULL)
                return (KERN_INVALID_ARGUMENT);
 
        if (thread == THREAD_NULL)
                return (KERN_INVALID_ARGUMENT);
 

-       if (exception_mask & ~EXC_MASK_ALL)
+       if (exception_mask & ~EXC_MASK_VALID)

                return (KERN_INVALID_ARGUMENT);
 
        if (IP_VALID(new_port)) {
                return (KERN_INVALID_ARGUMENT);
 
        if (IP_VALID(new_port)) {

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

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


@@ -1606,6 +1820,9 @@ thread_swap_exception_ports(
                }
        }
 
                }
        }
 

+       if (new_flavor != 0 && !VALID_THREAD_STATE_FLAVOR(new_flavor))
+               return (KERN_INVALID_ARGUMENT);
+

        thread_mtx_lock(thread);
 
        if (!thread->active) {
        thread_mtx_lock(thread);
 
        if (!thread->active) {


@@ -1614,9 +1831,12 @@ thread_swap_exception_ports(
                return (KERN_FAILURE);
        }
 
                return (KERN_FAILURE);
        }
 

-       count = 0;
+       if (thread->exc_actions == NULL) {
+               ipc_thread_init_exc_actions(thread);
+       }

 
 

-       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; ++i) {
+       assert(EXC_TYPES_COUNT > FIRST_EXCEPTION);
+       for (count = 0, i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT && count < *CountCnt; ++i) {

                if (exception_mask & (1 << i)) {
                        for (j = 0; j < count; ++j) {
                                /*
                if (exception_mask & (1 << i)) {
                        for (j = 0; j < count; ++j) {
                                /*


@@ -1645,8 +1865,6 @@ thread_swap_exception_ports(
                        thread->exc_actions[i].behavior = new_behavior;
                        thread->exc_actions[i].flavor = new_flavor;
                        thread->exc_actions[i].privileged = privileged;
                        thread->exc_actions[i].behavior = new_behavior;
                        thread->exc_actions[i].flavor = new_flavor;
                        thread->exc_actions[i].privileged = privileged;

-                       if (count > *CountCnt)
-                               break;

                }
                else
                        old_port[i] = IP_NULL;
                }
                else
                        old_port[i] = IP_NULL;


@@ -1654,9 +1872,10 @@ thread_swap_exception_ports(
 
        thread_mtx_unlock(thread);
 
 
        thread_mtx_unlock(thread);
 

-       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; ++i)
+       while (--i >= FIRST_EXCEPTION) {

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

+       }

 
        if (IP_VALID(new_port))          /* consume send right */
                ipc_port_release_send(new_port);
 
        if (IP_VALID(new_port))          /* consume send right */
                ipc_port_release_send(new_port);


@@ -1686,11 +1905,11 @@ task_swap_exception_ports(
        if (task == TASK_NULL)
                return (KERN_INVALID_ARGUMENT);
 
        if (task == TASK_NULL)
                return (KERN_INVALID_ARGUMENT);
 

-       if (exception_mask & ~EXC_MASK_ALL)
+       if (exception_mask & ~EXC_MASK_VALID)

                return (KERN_INVALID_ARGUMENT);
 
        if (IP_VALID(new_port)) {
                return (KERN_INVALID_ARGUMENT);
 
        if (IP_VALID(new_port)) {

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

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


@@ -1702,6 +1921,9 @@ task_swap_exception_ports(
                }
        }
 
                }
        }
 

+       if (new_flavor != 0 && !VALID_THREAD_STATE_FLAVOR(new_flavor))
+               return (KERN_INVALID_ARGUMENT);
+

        itk_lock(task);
 
        if (task->itk_self == IP_NULL) {
        itk_lock(task);
 
        if (task->itk_self == IP_NULL) {


@@ -1710,9 +1932,8 @@ task_swap_exception_ports(
                return (KERN_FAILURE);
        }
 
                return (KERN_FAILURE);
        }
 

-       count = 0;
-
-       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; ++i) {
+       assert(EXC_TYPES_COUNT > FIRST_EXCEPTION);
+       for (count = 0, i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT && count < *CountCnt; ++i) {

                if (exception_mask & (1 << i)) {
                        for (j = 0; j < count; j++) {
                                /*
                if (exception_mask & (1 << i)) {
                        for (j = 0; j < count; j++) {
                                /*


@@ -1736,12 +1957,11 @@ task_swap_exception_ports(
                        }
 
                        old_port[i] = task->exc_actions[i].port;
                        }
 
                        old_port[i] = task->exc_actions[i].port;

+

                        task->exc_actions[i].port =     ipc_port_copy_send(new_port);
                        task->exc_actions[i].behavior = new_behavior;
                        task->exc_actions[i].flavor = new_flavor;
                        task->exc_actions[i].privileged = privileged;
                        task->exc_actions[i].port =     ipc_port_copy_send(new_port);
                        task->exc_actions[i].behavior = new_behavior;
                        task->exc_actions[i].flavor = new_flavor;
                        task->exc_actions[i].privileged = privileged;

-                       if (count > *CountCnt)
-                               break;

                }
                else
                        old_port[i] = IP_NULL;
                }
                else
                        old_port[i] = IP_NULL;


@@ -1749,9 +1969,10 @@ task_swap_exception_ports(
 
        itk_unlock(task);
 
 
        itk_unlock(task);
 

-       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++)
+       while (--i >= FIRST_EXCEPTION) {

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

+       }

 
        if (IP_VALID(new_port))          /* consume send right */
                ipc_port_release_send(new_port);
 
        if (IP_VALID(new_port))          /* consume send right */
                ipc_port_release_send(new_port);


@@ -1795,7 +2016,7 @@ thread_get_exception_ports(
        if (thread == THREAD_NULL)
                return (KERN_INVALID_ARGUMENT);
 
        if (thread == THREAD_NULL)
                return (KERN_INVALID_ARGUMENT);
 

-       if (exception_mask & ~EXC_MASK_ALL)
+       if (exception_mask & ~EXC_MASK_VALID)

                return (KERN_INVALID_ARGUMENT);
 
        thread_mtx_lock(thread);
                return (KERN_INVALID_ARGUMENT);
 
        thread_mtx_lock(thread);


@@ -1808,6 +2029,10 @@ thread_get_exception_ports(
 
        count = 0;
 
 
        count = 0;
 

+       if (thread->exc_actions == NULL) {
+               goto done;
+       }
+

        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; ++i) {
                if (exception_mask & (1 << i)) {
                        for (j = 0; j < count; ++j) {
        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; ++i) {
                if (exception_mask & (1 << i)) {
                        for (j = 0; j < count; ++j) {


@@ -1835,6 +2060,7 @@ thread_get_exception_ports(
                }
        }
 
                }
        }
 

+done:

        thread_mtx_unlock(thread);
 
        *CountCnt = count;
        thread_mtx_unlock(thread);
 
        *CountCnt = count;


@@ -1857,7 +2083,7 @@ task_get_exception_ports(
        if (task == TASK_NULL)
                return (KERN_INVALID_ARGUMENT);
 
        if (task == TASK_NULL)
                return (KERN_INVALID_ARGUMENT);
 

-       if (exception_mask & ~EXC_MASK_ALL)
+       if (exception_mask & ~EXC_MASK_VALID)

                return (KERN_INVALID_ARGUMENT);
 
        itk_lock(task);
                return (KERN_INVALID_ARGUMENT);
 
        itk_lock(task);