xnu-2050.7.9.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 872fc21dcdb5c99785b39317357267f9db3cc7ba..d99ee186c07c9082add778e62c6f1d428385e2ac 100644 (file)
--- a/osfmk/kern/thread_act.c
+++ b/osfmk/kern/thread_act.c
@@ -1,23 +1,29 @@
 /*
 /*

- * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2007 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_FREE_COPYRIGHT@
  */
 /*
  * @OSF_FREE_COPYRIGHT@


@@ -46,7 +52,6 @@
 #include <mach/mach_types.h>
 #include <mach/kern_return.h>
 #include <mach/alert.h>
 #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>
 
 #include <mach/rpc.h>
 #include <mach/thread_act_server.h>
 


@@ -54,6 +59,7 @@
 #include <kern/ast.h>
 #include <kern/mach_param.h>
 #include <kern/zalloc.h>
 #include <kern/ast.h>
 #include <kern/mach_param.h>
 #include <kern/zalloc.h>

+#include <kern/extmod_statistics.h>

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


@@ -62,21 +68,42 @@
 #include <kern/exception.h>
 #include <kern/ipc_mig.h>
 #include <kern/ipc_tt.h>
 #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 <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/rpc.h>
 

+#include <security/mac_mach_internal.h>
+

 void                   act_abort(thread_t);
 void                   act_abort(thread_t);

-void                   act_set_apc(thread_t);

 void                   install_special_handler_locked(thread_t);
 void                   special_handler_continue(void);
 
 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 intentionally 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.
+ * PR-6385749 -- the lwp-start probe should fire from within the context
+ * of the newly created thread.  Commented out for now, in case we
+ * turn it into a dead code probe.
+ */
+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.
 /*
  * Internal routine to terminate a thread.
  * Sometimes called with task already locked.


@@ -97,17 +124,19 @@ thread_terminate_internal(
                if (thread->started)
                        clear_wait(thread, THREAD_INTERRUPTED);
                else {
                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;
 
                }
        }
        else
                result = KERN_TERMINATED;
 

+       if (thread->affinity_set != NULL)
+               thread_affinity_terminate(thread);
+

        thread_mtx_unlock(thread);
 
        if (thread != current_thread() && result == KERN_SUCCESS)
        thread_mtx_unlock(thread);
 
        if (thread != current_thread() && result == KERN_SUCCESS)

-               thread_wait(thread);
+               thread_wait(thread, FALSE);

 
        return (result);
 }
 
        return (result);
 }


@@ -178,8 +207,7 @@ thread_release(
                if (thread->started)
                        thread_wakeup_one(&thread->suspend_count);
                else {
                if (thread->started)
                        thread_wakeup_one(&thread->suspend_count);
                else {

-                       clear_wait(thread, THREAD_AWAKENED);
-                       thread->started = TRUE;
+                       thread_start_internal(thread);

                }
        }
 }
                }
        }
 }


@@ -210,7 +238,7 @@ thread_suspend(
        thread_mtx_unlock(thread);
 
        if (thread != self && result == KERN_SUCCESS)
        thread_mtx_unlock(thread);
 
        if (thread != self && result == KERN_SUCCESS)

-               thread_wait(thread);
+               thread_wait(thread, TRUE);

 
        return (result);
 }
 
        return (result);
 }


@@ -233,8 +261,7 @@ thread_resume(
                                if (thread->started)
                                        thread_wakeup_one(&thread->suspend_count);
                                else {
                                if (thread->started)
                                        thread_wakeup_one(&thread->suspend_count);
                                else {

-                                       clear_wait(thread, THREAD_AWAKENED);
-                                       thread->started = TRUE;
+                                       thread_start_internal(thread);

                                }
                        }
                }
                                }
                        }
                }


@@ -290,12 +317,12 @@ act_abort(
 
        thread_lock(thread);
 
 
        thread_lock(thread);
 

-       if (!(thread->state & TH_ABORT)) {
-               thread->state |= TH_ABORT;
+       if (!(thread->sched_flags & TH_SFLAG_ABORT)) {
+               thread->sched_flags |= TH_SFLAG_ABORT;

                install_special_handler_locked(thread);
        }
        else
                install_special_handler_locked(thread);
        }
        else

-               thread->state &= ~TH_ABORT_SAFELY;
+               thread->sched_flags &= ~TH_SFLAG_ABORTSAFELY;

 
        thread_unlock(thread);
        splx(s);
 
        thread_unlock(thread);
        splx(s);


@@ -340,9 +367,9 @@ thread_abort_safely(
 
                thread_lock(thread);
                if (!thread->at_safe_point ||
 
                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_flags & TH_SFLAG_ABORT)) {
+                               thread->sched_flags |= TH_SFLAG_ABORTED_MASK;

                                install_special_handler_locked(thread);
                        }
                }
                                install_special_handler_locked(thread);
                        }
                }


@@ -436,12 +463,13 @@ thread_get_state(
  *     Change thread's machine-dependent state.  Called with nothing
  *     locked.  Returns same way.
  */
  *     Change thread's machine-dependent state.  Called with nothing
  *     locked.  Returns same way.
  */

-kern_return_t
-thread_set_state(
+static kern_return_t
+thread_set_state_internal(

        register thread_t               thread,
        int                                             flavor,
        thread_state_t                  state,
        register thread_t               thread,
        int                                             flavor,
        thread_state_t                  state,

-       mach_msg_type_number_t  state_count)
+       mach_msg_type_number_t  state_count,
+       boolean_t                               from_user)

 {
        kern_return_t           result = KERN_SUCCESS;
 
 {
        kern_return_t           result = KERN_SUCCESS;
 


@@ -476,11 +504,41 @@ thread_set_state(
        else
                result = KERN_TERMINATED;
 
        else
                result = KERN_TERMINATED;
 

+       if ((result == KERN_SUCCESS) && from_user)
+               extmod_statistics_incr_thread_set_state(thread);
+

        thread_mtx_unlock(thread);
 
        return (result);
 }
        thread_mtx_unlock(thread);
 
        return (result);
 }

+
+/* No prototype, since thread_act_server.h has the _from_user version if KERNEL_SERVER */ 
+kern_return_t
+thread_set_state(
+       register thread_t               thread,
+       int                                             flavor,
+       thread_state_t                  state,
+       mach_msg_type_number_t  state_count);
+
+kern_return_t
+thread_set_state(
+       register thread_t               thread,
+       int                                             flavor,
+       thread_state_t                  state,
+       mach_msg_type_number_t  state_count)
+{
+       return thread_set_state_internal(thread, flavor, state, state_count, FALSE);
+}

  
  

+kern_return_t
+thread_set_state_from_user(
+       register thread_t               thread,
+       int                                             flavor,
+       thread_state_t                  state,
+       mach_msg_type_number_t  state_count)
+{
+       return thread_set_state_internal(thread, flavor, state, state_count, TRUE);
+}

  
 /*
  * Kernel-internal "thread" interfaces used outside this file:
  
 /*
  * Kernel-internal "thread" interfaces used outside this file:


@@ -519,7 +577,7 @@ thread_state_initialize(
                        thread_release(thread);
                }
                else
                        thread_release(thread);
                }
                else

-            result = machine_thread_state_initialize( thread );
+                       result = machine_thread_state_initialize( thread );

        }
        else
                result = KERN_TERMINATED;
        }
        else
                result = KERN_TERMINATED;


@@ -550,6 +608,8 @@ thread_dup(
                if (thread_stop(target)) {
                        thread_mtx_lock(target);
                        result = machine_thread_dup(self, target);
                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 {
                        thread_unstop(target);
                }
                else {


@@ -646,8 +706,8 @@ install_special_handler_locked(
         * a chance to do locking required to
         * block itself in special_handler().
         */
         * a chance to do locking required to
         * block itself in special_handler().
         */

-       if (thread->sched_mode & TH_MODE_ISDEPRESSED)
-               compute_priority(thread, TRUE);
+       if (thread->sched_flags & TH_SFLAG_DEPRESSED_MASK)
+               SCHED(compute_priority)(thread, TRUE);

 
        thread_ast_set(thread, AST_APC);
 
 
        thread_ast_set(thread, AST_APC);
 


@@ -727,12 +787,11 @@ special_handler_continue(void)
                spl_t                   s = splsched();
 
                thread_lock(thread);
                spl_t                   s = splsched();
 
                thread_lock(thread);

-               if (thread->sched_mode & TH_MODE_ISDEPRESSED) {
+               if (thread->sched_flags & TH_SFLAG_DEPRESSED_MASK) {

                        processor_t             myprocessor = thread->last_processor;
 
                        thread->sched_pri = DEPRESSPRI;
                        myprocessor->current_pri = thread->sched_pri;
                        processor_t             myprocessor = thread->last_processor;
 
                        thread->sched_pri = DEPRESSPRI;
                        myprocessor->current_pri = thread->sched_pri;

-                       thread->sched_mode &= ~TH_MODE_PREEMPT;

                }
                thread_unlock(thread);
                splx(s);
                }
                thread_unlock(thread);
                splx(s);


@@ -759,7 +818,7 @@ special_handler(
 
        s = splsched();
        thread_lock(thread);
 
        s = splsched();
        thread_lock(thread);

-       thread->state &= ~(TH_ABORT|TH_ABORT_SAFELY);   /* clear any aborts */
+       thread->sched_flags &= ~TH_SFLAG_ABORTED_MASK;

        thread_unlock(thread);
        splx(s);
 
        thread_unlock(thread);
        splx(s);
 


@@ -791,6 +850,14 @@ special_handler(
        thread_mtx_unlock(thread);
 }
 
        thread_mtx_unlock(thread);
 }
 

+/* Prototype, see justification above */
+kern_return_t
+act_set_state(
+       thread_t                                thread,
+       int                                             flavor,
+       thread_state_t                  state,
+       mach_msg_type_number_t  count);
+

 kern_return_t
 act_set_state(
        thread_t                                thread,
 kern_return_t
 act_set_state(
        thread_t                                thread,


@@ -805,6 +872,20 @@ act_set_state(
     
 }
 
     
 }
 

+kern_return_t
+act_set_state_from_user(
+       thread_t                                thread,
+       int                                             flavor,
+       thread_state_t                  state,
+       mach_msg_type_number_t  count)
+{
+    if (thread == current_thread())
+           return (KERN_INVALID_ARGUMENT);
+
+    return (thread_set_state_from_user(thread, flavor, state, count));
+    
+}
+

 kern_return_t
 act_get_state(
        thread_t                                thread,
 kern_return_t
 act_get_state(
        thread_t                                thread,


@@ -818,25 +899,26 @@ act_get_state(
     return (thread_get_state(thread, flavor, state, count));
 }
 
     return (thread_get_state(thread, flavor, state, count));
 }
 

-void
-act_set_astbsd(
-       thread_t        thread)
+static void
+act_set_ast(
+           thread_t    thread,
+           ast_t ast)

 {
        spl_t           s = splsched();
        
        if (thread == current_thread()) {
 {
        spl_t           s = splsched();
        
        if (thread == current_thread()) {

-               thread_ast_set(thread, AST_BSD);
+               thread_ast_set(thread, ast);

                ast_propagate(thread->ast);
        }
        else {
                processor_t             processor;
 
                thread_lock(thread);
                ast_propagate(thread->ast);
        }
        else {
                processor_t             processor;
 
                thread_lock(thread);

-               thread_ast_set(thread, AST_BSD);
+               thread_ast_set(thread, ast);

                processor = thread->last_processor;
                processor = thread->last_processor;

-               if (    processor != PROCESSOR_NULL                                     &&
-                               processor->state == PROCESSOR_RUNNING           &&
-                               processor->active_thread == thread                      )
+               if ( processor != PROCESSOR_NULL            &&
+                    processor->state == PROCESSOR_RUNNING  &&
+                    processor->active_thread == thread      )

                        cause_ast_check(processor);
                thread_unlock(thread);
        }
                        cause_ast_check(processor);
                thread_unlock(thread);
        }


@@ -844,28 +926,37 @@ act_set_astbsd(
        splx(s);
 }
 
        splx(s);
 }
 

+void
+act_set_astbsd(
+       thread_t        thread)
+{
+       act_set_ast( thread, AST_BSD );
+}
+

 void
 act_set_apc(
        thread_t        thread)
 {
 void
 act_set_apc(
        thread_t        thread)
 {

-       spl_t           s = splsched();
-       
-       if (thread == current_thread()) {
-               thread_ast_set(thread, AST_APC);
-               ast_propagate(thread->ast);
-       }
-       else {
-               processor_t             processor;
+       act_set_ast( thread, AST_APC );
+}

 
 

-               thread_lock(thread);
-               thread_ast_set(thread, AST_APC);
-               processor = thread->last_processor;
-               if (    processor != PROCESSOR_NULL                                     &&
-                               processor->state == PROCESSOR_RUNNING           &&
-                               processor->active_thread == thread                      )
-                       cause_ast_check(processor);
-               thread_unlock(thread);
-       }
-       
-       splx(s);
+void
+act_set_kperf(
+       thread_t        thread)
+{
+       /* safety check */
+       if (thread != current_thread())
+               if( !ml_get_interrupts_enabled() )
+                       panic("unsafe act_set_kperf operation");
+
+       act_set_ast( thread, AST_KPERF );
+}
+
+#if CONFIG_MACF
+void
+act_set_astmacf(
+       thread_t        thread)
+{
+       act_set_ast( thread, AST_MACF);

 }
 }

+#endif