xnu-1228.3.13.tar.gz

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

diff --git a/osfmk/kern/thread_act.c b/osfmk/kern/thread_act.c
index eb8099a4d02d8b93742397df2adcfbd8e653dc5f..4fcb5f9570a6291d0bf2f301a223e5c92bbef664 100644 (file)
--- a/osfmk/kern/thread_act.c
+++ b/osfmk/kern/thread_act.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
@@ -52,7 +52,6 @@
 #include <mach/mach_types.h>
 #include <mach/kern_return.h>
 #include <mach/alert.h>
-#include <mach_prof.h>
 #include <mach/rpc.h>
 #include <mach/thread_act_server.h>
 
@@ -68,21 +67,39 @@
 #include <kern/exception.h>
 #include <kern/ipc_mig.h>
 #include <kern/ipc_tt.h>
-#include <kern/profile.h>
 #include <kern/machine.h>
 #include <kern/spl.h>
 #include <kern/syscall_subr.h>
 #include <kern/sync_lock.h>
 #include <kern/processor.h>
 #include <kern/timer.h>
-#include <mach_prof.h>
+#include <kern/affinity.h>
+
 #include <mach/rpc.h>
 
+#include <mach/sdt.h>
+
 void                   act_abort(thread_t);
-void                   act_set_apc(thread_t);
 void                   install_special_handler_locked(thread_t);
 void                   special_handler_continue(void);
 
+/*
+ * Internal routine to mark a thread as started.
+ * Always called with the thread locked.
+ *
+ * Note: function intentionall declared with the noinline attribute to
+ * prevent multiple declaration of probe symbols in this file; we would
+ * prefer "#pragma noinline", but gcc does not support it.
+ */
+void
+thread_start_internal(
+       thread_t                        thread)
+{
+       clear_wait(thread, THREAD_AWAKENED);
+       thread->started = TRUE;
+       DTRACE_PROC1(lwp__start, thread_t, thread);
+}
+
 /*
  * Internal routine to terminate a thread.
  * Sometimes called with task already locked.
@@ -93,6 +110,8 @@ thread_terminate_internal(
 {
        kern_return_t           result = KERN_SUCCESS;
 
+       DTRACE_PROC(lwp__exit);
+
        thread_mtx_lock(thread);
 
        if (thread->active) {
@@ -103,13 +122,15 @@ thread_terminate_internal(
                if (thread->started)
                        clear_wait(thread, THREAD_INTERRUPTED);
                else {
-                       clear_wait(thread, THREAD_AWAKENED);
-                       thread->started = TRUE;
+                       thread_start_internal(thread);
                }
        }
        else
                result = KERN_TERMINATED;
 
+       if (thread->affinity_set != NULL)
+               thread_affinity_terminate(thread);
+
        thread_mtx_unlock(thread);
 
        if (thread != current_thread() && result == KERN_SUCCESS)
@@ -184,8 +205,7 @@ thread_release(
                if (thread->started)
                        thread_wakeup_one(&thread->suspend_count);
                else {
-                       clear_wait(thread, THREAD_AWAKENED);
-                       thread->started = TRUE;
+                       thread_start_internal(thread);
                }
        }
 }
@@ -239,8 +259,7 @@ thread_resume(
                                if (thread->started)
                                        thread_wakeup_one(&thread->suspend_count);
                                else {
-                                       clear_wait(thread, THREAD_AWAKENED);
-                                       thread->started = TRUE;
+                                       thread_start_internal(thread);
                                }
                        }
                }
@@ -296,12 +315,12 @@ act_abort(
 
        thread_lock(thread);
 
-       if (!(thread->state & TH_ABORT)) {
-               thread->state |= TH_ABORT;
+       if (!(thread->sched_mode & TH_MODE_ABORT)) {
+               thread->sched_mode |= TH_MODE_ABORT;
                install_special_handler_locked(thread);
        }
        else
-               thread->state &= ~TH_ABORT_SAFELY;
+               thread->sched_mode &= ~TH_MODE_ABORTSAFELY;
 
        thread_unlock(thread);
        splx(s);
@@ -346,9 +365,9 @@ thread_abort_safely(
 
                thread_lock(thread);
                if (!thread->at_safe_point ||
-                       clear_wait_internal(thread, THREAD_INTERRUPTED) != KERN_SUCCESS) {
-                       if (!(thread->state & TH_ABORT)) {
-                               thread->state |= (TH_ABORT|TH_ABORT_SAFELY);
+                               clear_wait_internal(thread, THREAD_INTERRUPTED) != KERN_SUCCESS) {
+                       if (!(thread->sched_mode & TH_MODE_ABORT)) {
+                               thread->sched_mode |= TH_MODE_ISABORTED;
                                install_special_handler_locked(thread);
                        }
                }
@@ -556,6 +575,8 @@ thread_dup(
                if (thread_stop(target)) {
                        thread_mtx_lock(target);
                        result = machine_thread_dup(self, target);
+                       if (self->affinity_set != AFFINITY_SET_NULL)
+                               thread_affinity_dup(self, target);
                        thread_unstop(target);
                }
                else {
@@ -738,7 +759,6 @@ special_handler_continue(void)
 
                        thread->sched_pri = DEPRESSPRI;
                        myprocessor->current_pri = thread->sched_pri;
-                       thread->sched_mode &= ~TH_MODE_PREEMPT;
                }
                thread_unlock(thread);
                splx(s);
@@ -765,7 +785,7 @@ special_handler(
 
        s = splsched();
        thread_lock(thread);
-       thread->state &= ~(TH_ABORT|TH_ABORT_SAFELY);   /* clear any aborts */
+       thread->sched_mode &= ~TH_MODE_ISABORTED;
        thread_unlock(thread);
        splx(s);