xnu-517.9.4.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 a32975e15e3c852fb8ee950a634dfc166e8241b3..04071f778fa10baa83c80dffef08e0c7971d190a 100644 (file)
--- a/osfmk/kern/ipc_tt.c
+++ b/osfmk/kern/ipc_tt.c
@@ -1,5 +1,5 @@
 /*
 /*

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

  *
  * @APPLE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_LICENSE_HEADER_START@
  * 


@@ -56,6 +56,7 @@
  *     Task and thread related IPC functions.
  */
 
  *     Task and thread related IPC functions.
  */
 

+#include <mach/mach_types.h>

 #include <mach/boolean.h>
 #include <mach_rt.h>
 #include <mach/kern_return.h>
 #include <mach/boolean.h>
 #include <mach_rt.h>
 #include <mach/kern_return.h>


@@ -110,16 +111,21 @@ ipc_task_init(
        task->itk_self = kport;
        task->itk_sself = ipc_port_make_send(kport);
        task->itk_space = space;
        task->itk_self = kport;
        task->itk_sself = ipc_port_make_send(kport);
        task->itk_space = space;

-       space->is_fast = task->kernel_loaded;
+       space->is_fast = FALSE;

 
        if (parent == TASK_NULL) {
 
        if (parent == TASK_NULL) {

+               ipc_port_t port;
+

                for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
                        task->exc_actions[i].port = IP_NULL;
                }/* for */
                for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
                        task->exc_actions[i].port = IP_NULL;
                }/* for */

-               task->exc_actions[EXC_MACH_SYSCALL].port = 
-                       ipc_port_make_send(realhost.host_self);
-               task->itk_host = ipc_port_make_send(realhost.host_self);
+               
+               kr = host_get_host_port(host_priv_self(), &port);
+               assert(kr == KERN_SUCCESS);
+               task->itk_host = port;
+

                task->itk_bootstrap = IP_NULL;
                task->itk_bootstrap = IP_NULL;

+

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


@@ -249,6 +255,74 @@ ipc_task_terminate(
        ipc_port_dealloc_kernel(kport);
 }
 
        ipc_port_dealloc_kernel(kport);
 }
 

+/*
+ *     Routine:        ipc_task_reset
+ *     Purpose:
+ *             Reset a task's IPC state to protect it when
+ *             it enters an elevated security context.
+ *     Conditions:
+ *             Nothing locked.  The task must be suspended.
+ *             (Or the current thread must be in the task.)
+ */
+
+void
+ipc_task_reset(
+       task_t          task)
+{
+       ipc_port_t old_kport, new_kport;
+       ipc_port_t old_sself;
+#if 0
+       ipc_port_t old_exc_actions[EXC_TYPES_COUNT];
+       int i;
+#endif
+
+       new_kport = ipc_port_alloc_kernel();
+       if (new_kport == IP_NULL)
+               panic("ipc_task_reset");
+
+       itk_lock(task);
+
+       old_kport = task->itk_self;
+
+       if (old_kport == IP_NULL) {
+               /* the task is already terminated (can this happen?) */
+               itk_unlock(task);
+               ipc_port_dealloc_kernel(new_kport);
+               return;
+       }
+
+       task->itk_self = new_kport;
+       old_sself = task->itk_sself;
+       task->itk_sself = ipc_port_make_send(new_kport);
+       ipc_kobject_set(old_kport, IKO_NULL, IKOT_NONE);
+       ipc_kobject_set(new_kport, (ipc_kobject_t) task, IKOT_TASK);
+
+#if 0
+       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
+               old_exc_actions[i] = task->exc_action[i].port;
+               task->exc_actions[i].port = IP_NULL;
+       }/* for */
+#endif
+
+       itk_unlock(task);
+
+       /* release the naked send rights */
+
+       if (IP_VALID(old_sself))
+               ipc_port_release_send(old_sself);
+
+#if 0
+       for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
+               if (IP_VALID(old_exc_actions[i])) {
+                       ipc_port_release_send(old_exc_actions[i]);
+               }
+       }/* for */
+#endif
+
+       /* destroy the kernel port */
+       ipc_port_dealloc_kernel(old_kport);
+}
+

 /*
  *     Routine:        ipc_thread_init
  *     Purpose:
 /*
  *     Routine:        ipc_thread_init
  *     Purpose:


@@ -309,9 +383,6 @@ ipc_thr_act_init(task_t task, thread_act_t thr_act)
        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++)
                thr_act->exc_actions[i].port = IP_NULL;
 
        for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++)
                thr_act->exc_actions[i].port = IP_NULL;
 

-       thr_act->exc_actions[EXC_MACH_SYSCALL].port =
-                                       ipc_port_make_send(realhost.host_self);
-

        ipc_kobject_set(kport, (ipc_kobject_t) thr_act, IKOT_ACT);
 }
 
        ipc_kobject_set(kport, (ipc_kobject_t) thr_act, IKOT_ACT);
 }
 


@@ -881,6 +952,21 @@ convert_port_to_upl(
        return upl;
 }
 
        return upl;
 }
 

+mach_port_t
+convert_upl_to_port(
+       upl_t           upl)
+{
+       return MACH_PORT_NULL;
+}
+
+__private_extern__ void
+upl_no_senders(
+       upl_t                   upl,
+       mach_port_mscount_t     mscount)
+{
+       return;
+}
+

 /*
  *     Routine:        convert_port_entry_to_map
  *     Purpose:
 /*
  *     Routine:        convert_port_entry_to_map
  *     Purpose:


@@ -1078,16 +1164,15 @@ ref_act_port_locked( ipc_port_t port, thread_act_t *pthr_act )
                assert(thr_act != THR_ACT_NULL);
 
                /*
                assert(thr_act != THR_ACT_NULL);
 
                /*

-                * Normal lock ordering is act_lock(), then ip_lock().
-                * Allow out-of-order locking here, using
-                * act_reference_act_locked() to accomodate it.
+                * Out of order locking here, normal
+                * ordering is act_lock(), then ip_lock().

                 */
                if (!act_lock_try(thr_act)) {
                        ip_unlock(port);
                        mutex_pause();
                        return (FALSE);
                }
                 */
                if (!act_lock_try(thr_act)) {
                        ip_unlock(port);
                        mutex_pause();
                        return (FALSE);
                }

-               act_locked_act_reference(thr_act);
+               act_reference_locked(thr_act);

                act_unlock(thr_act);
        }
        *pthr_act = thr_act;
                act_unlock(thr_act);
        }
        *pthr_act = thr_act;