xnu-792.6.61.tar.gz

[apple/xnu.git] / osfmk / kern / thread.h

diff --git a/osfmk/kern/thread.h b/osfmk/kern/thread.h
index 559a640e04d0d2956929a4ff2fcf040ac1b95766..cde616313efd9a750dad3a68533792e6cda339ac 100644 (file)
--- a/osfmk/kern/thread.h
+++ b/osfmk/kern/thread.h
@@ -1,5 +1,5 @@
 /*
 /*

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

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


@@ -82,301 +82,276 @@
 #include <mach/mach_types.h>
 #include <mach/message.h>
 #include <mach/boolean.h>
 #include <mach/mach_types.h>
 #include <mach/message.h>
 #include <mach/boolean.h>

-#include <mach/vm_types.h>
-#include <mach/vm_prot.h>
+#include <mach/vm_param.h>

 #include <mach/thread_info.h>
 #include <mach/thread_status.h>
 #include <mach/thread_info.h>
 #include <mach/thread_status.h>

-#include <kern/cpu_data.h>             /* for current_thread */
+#include <mach/exception_types.h>
+

 #include <kern/kern_types.h>
 
 #include <kern/kern_types.h>
 

-/*
- * Logically, a thread of control consists of two parts:
- *     a thread_shuttle, which may migrate during an RPC, and
- *     a thread_activation, which remains attached to a task.
- * The thread_shuttle is the larger portion of the two-part thread,
- * and contains scheduling info, messaging support, accounting info,
- * and links to the thread_activation within which the shuttle is
- * currently operating.
- *
- * It might make sense to have the thread_shuttle be a proper sub-structure
- * of the thread, with the thread containing links to both the shuttle and
- * activation.  In order to reduce the scope and complexity of source
- * changes and the overhead of maintaining these linkages, we have subsumed
- * the shuttle into the thread, calling it a thread_shuttle.
- *
- * User accesses to threads always come in via the user's thread port,
- * which gets translated to a pointer to the target thread_activation.
- * Kernel accesses intended to effect the entire thread, typically use
- * a pointer to the thread_shuttle (current_thread()) as the target of
- * their operations.  This makes sense given that we have subsumed the
- * shuttle into the thread_shuttle, eliminating one set of linkages.
- * Operations effecting only the shuttle may use a thread_shuttle_t
- * to indicate this.
- *
- * The current_act() macro returns a pointer to the current thread_act, while
- * the current_thread() macro returns a pointer to the currently active
- * thread_shuttle (representing the thread in its entirety).
- */
+#include <sys/cdefs.h>

 
 

-/*
- *     Possible results of thread_block - returned in
- *     current_thread()->wait_result.
- */
-#define THREAD_AWAKENED                0               /* normal wakeup */
-#define THREAD_TIMED_OUT       1               /* timeout expired */
-#define THREAD_INTERRUPTED     2               /* interrupted by clear_wait */
-#define THREAD_RESTART         3               /* restart operation entirely */
+#ifdef MACH_KERNEL_PRIVATE

 
 

-/*
- * Interruptible flags for assert_wait
- *
- */
-#define THREAD_UNINT                   0               /* not interruptible      */
-#define THREAD_INTERRUPTIBLE   1               /* may not be restartable */
-#define THREAD_ABORTSAFE               2               /* abortable safely       */
+#include <cputypes.h>

 
 

-#ifdef MACH_KERNEL_PRIVATE
-#include <cpus.h>
-#include <hw_footprint.h>
+#include <mach_assert.h>

 #include <mach_host.h>
 #include <mach_prof.h>
 #include <mach_host.h>
 #include <mach_prof.h>

-#include <mach_lock_mon.h>

 #include <mach_ldebug.h>
 
 #include <mach_ldebug.h>
 

+#include <ipc/ipc_types.h>
+

 #include <mach/port.h>
 #include <mach/port.h>

-#include <kern/ast.h>

 #include <kern/cpu_number.h>
 #include <kern/queue.h>
 #include <kern/cpu_number.h>
 #include <kern/queue.h>

-#include <kern/time_out.h>

 #include <kern/timer.h>
 #include <kern/lock.h>
 #include <kern/timer.h>
 #include <kern/lock.h>

+#include <kern/locks.h>

 #include <kern/sched.h>
 #include <kern/sched_prim.h>
 #include <kern/sched.h>
 #include <kern/sched_prim.h>

-#include <kern/thread_pool.h>

 #include <kern/thread_call.h>
 #include <kern/timer_call.h>
 #include <kern/task.h>
 #include <kern/thread_call.h>
 #include <kern/timer_call.h>
 #include <kern/task.h>

+#include <kern/exception.h>
+

 #include <ipc/ipc_kmsg.h>
 #include <ipc/ipc_kmsg.h>

+
+#include <machine/cpu_data.h>

 #include <machine/thread.h>
 
 #include <machine/thread.h>
 

-struct thread_shuttle {
+struct thread {

        /*
        /*

-        * Beginning of thread_shuttle proper.  When the thread is on
-        * a wait queue, these three fields are in treated as an un-
-        * official union with a wait_queue_element.  If you change
-        * these, you must change that definition as well.
+        *      NOTE:   The runq field in the thread structure has an unusual
+        *      locking protocol.  If its value is RUN_QUEUE_NULL, then it is
+        *      locked by the thread_lock, but if its value is something else
+        *      (i.e. a run_queue) then it is locked by that run_queue's lock.
+        *
+        *      When the thread is on a wait queue, these first three fields
+        *      are treated as an unofficial union with a wait_queue_element.
+        *      If you change these, you must change that definition as well
+        *      (kern/wait_queue.h).

         */
         */

-       queue_chain_t   links;                          /* current run/wait queue links */
-       run_queue_t             runq;                           /* run queue p is on SEE BELOW */
-       int                             whichq;                         /* which queue level p is on */
-/*
- *     NOTE:   The runq field in the thread structure has an unusual
- *     locking protocol.  If its value is RUN_QUEUE_NULL, then it is
- *     locked by the thread_lock, but if its value is something else
- *     (i.e. a run_queue) then it is locked by that run_queue's lock.
- */
-
-       /* Thread bookkeeping */
-       queue_chain_t   pset_threads;           /* list of all shuttles in proc set */
-
-       /* Synchronization */
-       decl_simple_lock_data(,lock)            /* scheduling lock (thread_lock()) */
+       /* Items examined often, modified infrequently */
+       queue_chain_t   links;                          /* run/wait queue links */
+       run_queue_t             runq;                           /* run queue thread is on SEE BELOW */
+       wait_queue_t    wait_queue;                     /* wait queue we are currently on */
+       event64_t               wait_event;                     /* wait queue event */
+       integer_t               options;                        /* options set by thread itself */
+#define TH_OPT_INTMASK         0x03            /* interrupt / abort level */
+#define TH_OPT_VMPRIV          0x04            /* may allocate reserved memory */
+#define TH_OPT_DELAYIDLE       0x08            /* performing delayed idle */
+#define TH_OPT_CALLOUT         0x10            /* executing as callout */
+
+       /* Data updated during assert_wait/thread_wakeup */
+       decl_simple_lock_data(,sched_lock)      /* scheduling lock (thread_lock()) */

        decl_simple_lock_data(,wake_lock)       /* covers wake_active (wake_lock())*/
        decl_simple_lock_data(,wake_lock)       /* covers wake_active (wake_lock())*/

-       decl_mutex_data(,rpc_lock)                      /* RPC lock (rpc_lock()) */
-       int                             ref_count;                      /* number of references to me */
-        
-       vm_offset_t     kernel_stack;
-       vm_offset_t             stack_privilege;        /* reserved kernel stack */
-
-       /* Blocking information */
-       int                             reason;                         /* why we blocked */
-
-       event_t                 wait_event;                     /* event we are waiting on */
-       kern_return_t   wait_result;            /* outcome of wait -
+       boolean_t                       wake_active;    /* Someone is waiting for this */
+       int                                     at_safe_point;  /* thread_abort_safely allowed */
+       ast_t                           reason;                 /* why we blocked */
+       wait_result_t           wait_result;    /* outcome of wait -

                                                                                 * may be examined by this thread
                                                                                 * WITHOUT locking */
                                                                                 * may be examined by this thread
                                                                                 * WITHOUT locking */

+       thread_continue_t       continuation;   /* continue here next dispatch */
+       void                            *parameter;             /* continuation parameter */

 
 

-       wait_queue_t    wait_queue;                     /* wait queue we are currently on */
-       queue_chain_t   wait_link;                      /* event's wait queue link */
+       /* Data updated/used in thread_invoke */
+    struct funnel_lock *funnel_lock;           /* Non-reentrancy funnel */
+    int                                    funnel_state;
+#define TH_FN_OWNED                    0x1                             /* we own the funnel */
+#define TH_FN_REFUNNEL         0x2                             /* re-acquire funnel on dispatch */

 
 

-       boolean_t               wake_active;            /* Someone is waiting for this
-                                                                                * thread to become suspended */
-
-       boolean_t               interruptible;          /* Thread is "interruptible" */
+       vm_offset_t             kernel_stack;           /* current kernel stack */
+       vm_offset_t                     reserved_stack;         /* reserved kernel stack */

 
        /* Thread state: */
 
        /* Thread state: */

-       int                             state;
+       int                                     state;

 /*
  *     Thread states [bits or'ed]
  */
 /*
  *     Thread states [bits or'ed]
  */

-#define TH_WAIT                        0x01    /* thread is queued for waiting */
-#define TH_SUSP                        0x02    /* thread has been asked to stop */
-#define TH_RUN                 0x04    /* thread is running or on runq */
-#define TH_UNINT               0x08    /* thread is waiting uninteruptibly */
-#define        TH_HALTED               0x10    /* thread is halted at clean point ? */
+#define TH_WAIT                        0x01                    /* queued for waiting */
+#define TH_SUSP                        0x02                    /* stopped or requested to stop */
+#define TH_RUN                 0x04                    /* running or on runq */
+#define TH_UNINT               0x08                    /* waiting uninteruptibly */
+#define        TH_TERMINATE    0x10                    /* halted at termination */

 
 

-#define TH_ABORT               0x20    /* abort interruptible waits */
+#define TH_ABORT               0x20                    /* abort interruptible waits */
+#define TH_ABORT_SAFELY        0x40                    /* ... but only those at safe point */

 
 

-#define TH_IDLE                        0x80    /* thread is an idle thread */
+#define TH_IDLE                        0x80                    /* processor idle thread */

 
 #define        TH_SCHED_STATE  (TH_WAIT|TH_SUSP|TH_RUN|TH_UNINT)
 
 
 #define        TH_SCHED_STATE  (TH_WAIT|TH_SUSP|TH_RUN|TH_UNINT)
 

-#define        TH_STACK_HANDOFF        0x0100  /* thread has no kernel stack */
-#define        TH_STACK_ALLOC          0x0200  /* thread is waiting for kernel stack */
-#define        TH_STACK_STATE  (TH_STACK_HANDOFF | TH_STACK_ALLOC)
+       /* Scheduling information */
+       integer_t                       sched_mode;                     /* scheduling mode bits */
+#define TH_MODE_REALTIME               0x0001          /* time constraints supplied */
+#define TH_MODE_TIMESHARE              0x0002          /* use timesharing algorithm */
+#define TH_MODE_PREEMPT                        0x0004          /* can preempt kernel contexts */
+#define TH_MODE_FAILSAFE               0x0008          /* fail-safe has tripped */
+#define        TH_MODE_PROMOTED                0x0010          /* sched pri has been promoted */
+#define        TH_MODE_DEPRESS                 0x0020          /* normal depress yield */
+#define TH_MODE_POLLDEPRESS            0x0040          /* polled depress yield */
+#define TH_MODE_ISDEPRESSED            (TH_MODE_DEPRESS | TH_MODE_POLLDEPRESS)

 
 

-#define        TH_TERMINATE            0x0400  /* thread is terminating */
+       integer_t                       sched_pri;                      /* scheduled (current) priority */
+       integer_t                       priority;                       /* base priority */
+       integer_t                       max_priority;           /* max base priority */
+       integer_t                       task_priority;          /* copy of task base priority */

 
 

-       /* Stack handoff information */
-       void            (*continuation)(void);  /* re-start here next dispatch */
+       integer_t                       promotions;                     /* level of promotion */
+       integer_t                       pending_promoter_index;
+       void                            *pending_promoter[2];

 
 

-       /* Scheduling information */
-       integer_t                       importance;             /* task-relative importance */
-       integer_t                       sched_mode;             /* scheduling mode bits */
-#define TH_MODE_REALTIME               0x0001
-#define TH_MODE_TIMESHARE              0x0002
-#define TH_MODE_FAILSAFE               0x0004
-#define TH_MODE_POLLDEPRESS            0x0008
-       integer_t                       safe_mode;              /* saved mode during fail-safe */
-       struct {                                                        /* see mach/thread_policy.h */
+       integer_t                       importance;                     /* task-relative importance */
+
+                                                                                       /* real-time parameters */
+       struct {                                                                /* see mach/thread_policy.h */

                uint32_t                        period;
                uint32_t                        computation;
                uint32_t                        constraint;
                boolean_t                       preemptible;
                uint32_t                        period;
                uint32_t                        computation;
                uint32_t                        constraint;
                boolean_t                       preemptible;

-       }                                       realtime;

 
 

-       integer_t                       priority;                       /* base priority */
-       integer_t                       sched_pri;                      /* scheduled (current) priority */
-       integer_t                       depress_priority;       /* priority to restore */
-       integer_t                       max_priority;
-       integer_t                       task_priority;          /* copy of task base priority */
+               uint64_t                        deadline;
+       }                                       realtime;

 
        uint32_t                        current_quantum;        /* duration of current quantum */
 
 
        uint32_t                        current_quantum;        /* duration of current quantum */
 

+  /* Data used during setrun/dispatch */
+       timer_data_t            system_timer;           /* system mode timer */
+       processor_set_t         processor_set;          /* assigned processor set */
+       processor_t                     bound_processor;        /* bound to a processor? */
+       processor_t                     last_processor;         /* processor last dispatched on */
+       uint64_t                        last_switch;            /* time of last context switch */
+

        /* Fail-safe computation since last unblock or qualifying yield */
        /* Fail-safe computation since last unblock or qualifying yield */

-       uint64_t                        metered_computation;
+       uint64_t                        computation_metered;

        uint64_t                        computation_epoch;
        uint64_t                        computation_epoch;

-
-       natural_t                       cpu_usage;              /* exp. decaying cpu usage [%cpu] */
-       natural_t                       cpu_delta;              /* cpu usage since last update */
-       natural_t                       sched_usage;    /* load-weighted cpu usage [sched] */
-       natural_t                       sched_delta;    /* weighted cpu usage since update */
-       natural_t                       sched_stamp;    /* when priority was updated */
-       natural_t                       sleep_stamp;    /* when entered TH_WAIT state */
+       integer_t                       safe_mode;              /* saved mode during fail-safe */

        natural_t                       safe_release;   /* when to release fail-safe */
 
        natural_t                       safe_release;   /* when to release fail-safe */
 

-       /* VM global variables */
-       boolean_t                       vm_privilege;   /* can use reserved memory? */
-       vm_offset_t                     recover;                /* page fault recovery (copyin/out) */
+       /* Statistics and timesharing calculations */
+       natural_t                       sched_stamp;    /* last scheduler tick */
+       natural_t                       sched_usage;    /* timesharing cpu usage [sched] */
+       natural_t                       pri_shift;              /* usage -> priority from pset */
+       natural_t                       cpu_usage;              /* instrumented cpu usage [%cpu] */
+       natural_t                       cpu_delta;              /* accumulated cpu_usage delta */

 
 

-       /* IPC data structures */
+       /* Timing data structures */
+       timer_data_t            user_timer;                     /* user mode timer */
+       uint64_t                        system_timer_save;      /* saved system timer value */
+       uint64_t                        user_timer_save;        /* saved user timer value */

 
 

-       struct ipc_kmsg_queue ith_messages;
+       /* Timed wait expiration */
+       timer_call_data_t       wait_timer;
+       integer_t                       wait_timer_active;
+       boolean_t                       wait_timer_is_set;

 
 

-       mach_port_t ith_mig_reply;      /* reply port for mig */
-       mach_port_t ith_rpc_reply;      /* reply port for kernel RPCs */
+       /* Priority depression expiration */
+       timer_call_data_t       depress_timer;
+       integer_t                       depress_timer_active;

 
        /* Various bits of stashed state */
        union {
                struct {
                        mach_msg_return_t       state;          /* receive state */
                        ipc_object_t            object;         /* object received on */
 
        /* Various bits of stashed state */
        union {
                struct {
                        mach_msg_return_t       state;          /* receive state */
                        ipc_object_t            object;         /* object received on */

-                       mach_msg_header_t       *msg;           /* receive buffer pointer */
+                       mach_vm_address_t       msg_addr;       /* receive buffer pointer */

                        mach_msg_size_t         msize;          /* max size for recvd msg */
                        mach_msg_option_t       option;         /* options for receive */
                        mach_msg_size_t         slist_size;     /* scatter list size */
                        struct ipc_kmsg         *kmsg;          /* received message */
                        mach_port_seqno_t       seqno;          /* seqno of recvd message */
                        mach_msg_size_t         msize;          /* max size for recvd msg */
                        mach_msg_option_t       option;         /* options for receive */
                        mach_msg_size_t         slist_size;     /* scatter list size */
                        struct ipc_kmsg         *kmsg;          /* received message */
                        mach_port_seqno_t       seqno;          /* seqno of recvd message */

-                       void                    (*continuation)(mach_msg_return_t);
-               }                       receive;
+                       mach_msg_continue_t     continuation;
+               } receive;

                struct {
                        struct semaphore        *waitsemaphore;         /* semaphore ref */
                        struct semaphore        *signalsemaphore;       /* semaphore ref */
                        int                                     options;                        /* semaphore options */
                        kern_return_t           result;                         /* primary result */
                struct {
                        struct semaphore        *waitsemaphore;         /* semaphore ref */
                        struct semaphore        *signalsemaphore;       /* semaphore ref */
                        int                                     options;                        /* semaphore options */
                        kern_return_t           result;                         /* primary result */

-                       void                    (*continuation)(kern_return_t);
-               }                       sema;
+                       mach_msg_continue_t continuation;
+               } sema;

                struct {
                struct {

-                       int                             option;         /* switch option */
-               }                       swtch;
-               int                                     misc;           /* catch-all for other state */
-       }               saved;
-
-       /* Timing data structures */
-       timer_data_t                    user_timer;                     /* user mode timer */
-       timer_data_t                    system_timer;           /* system mode timer */
-       timer_save_data_t               user_timer_save;        /* saved user timer value */
-       timer_save_data_t               system_timer_save;      /* saved system timer value */
-
-       /* Timed wait expiration */
-       timer_call_data_t               wait_timer;
-       integer_t                               wait_timer_active;
-       boolean_t                               wait_timer_is_set;
+                       int                                     option;         /* switch option */
+               } swtch;
+               int                                             misc;           /* catch-all for other state */
+       } saved;

 
 

-       /* Priority depression expiration */
-       timer_call_data_t               depress_timer;
-       integer_t                               depress_timer_active;
+       /* IPC data structures */
+       struct ipc_kmsg_queue ith_messages;
+       mach_port_t ith_rpc_reply;                      /* reply port for kernel RPCs */

 
        /* Ast/Halt data structures */
 
        /* Ast/Halt data structures */

-       boolean_t                       active;                         /* thread is active */
+       vm_offset_t                     recover;                /* page fault recover(copyin/out) */
+       int                                     ref_count;              /* number of references to me */

 
 

-       int                                     at_safe_point;          /* thread_abort_safely allowed */
-
-       /* Processor data structures */
-       processor_set_t         processor_set;          /* assigned processor set */
-       processor_t                     bound_processor;        /* bound to processor ?*/
+       /* Processor set info */
+       queue_chain_t           pset_threads;   /* list of all threads in pset */

 #if    MACH_HOST
 #if    MACH_HOST

-       boolean_t                       may_assign;                     /* may assignment change? */
-       boolean_t                       assign_active;          /* waiting for may_assign */
+       boolean_t                       may_assign;             /* may assignment change? */
+       boolean_t                       assign_active;  /* waiting for may_assign */

 #endif /* MACH_HOST */
 
 #endif /* MACH_HOST */
 

-       processor_t                     last_processor;         /* processor last ran on */
+       /* Activation */
+               queue_chain_t                   task_threads;

 
 

-       /* Non-reentrancy funnel */
-    struct funnel_lock         *funnel_lock;
-    int                                        funnel_state;
-#define TH_FN_OWNED                            0x1                     /* we own the funnel */
-#define TH_FN_REFUNNEL                 0x2                     /* re-acquire funnel on dispatch */
+               /*** Machine-dependent state ***/
+               struct machine_thread   machine;

 
 

-/* BEGIN TRACING/DEBUG */
+               /* Task membership */
+               struct task                             *task;
+               vm_map_t                                map;

 
 

-#if    MACH_LOCK_MON
-       unsigned                        lock_stack;                     /* number of locks held */
-#endif  /* MACH_LOCK_MON */
+               decl_mutex_data(,mutex)

 
 

-#if    ETAP_EVENT_MONITOR
-       int                                     etap_reason;            /* real reason why we blocked */
-       boolean_t                       etap_trace;                     /* ETAP trace status */
-#endif /* ETAP_EVENT_MONITOR */
+               /* Kernel holds on this thread  */
+               int                                             suspend_count;

 
 

-#if    MACH_LDEBUG
-       /*
-        *      Debugging:  track acquired mutexes and locks.
-        *      Because a thread can block while holding such
-        *      synchronizers, we think of the thread as
-        *      "owning" them.
-        */
-#define        MUTEX_STACK_DEPTH       20
-#define        LOCK_STACK_DEPTH        20
-       mutex_t                         *mutex_stack[MUTEX_STACK_DEPTH];
-       lock_t                          *lock_stack[LOCK_STACK_DEPTH];
-       unsigned int            mutex_stack_index;
-       unsigned int            lock_stack_index;
-       unsigned                        mutex_count;            /* XXX to be deleted XXX */
-       boolean_t                       kthread;                        /* thread is a kernel thread */
-#endif /* MACH_LDEBUG */
-
-/* END TRACING/DEBUG */
-
-       /* Migration and thread_activation linkage */
-       struct thread_activation        *top_act;               /* "current" thr_act */
-};
+               /* User level suspensions */
+               int                                             user_stop_count;
+
+               /* Pending thread ast(s) */
+               ast_t                                   ast;

 
 

-#define THREAD_SHUTTLE_NULL    ((thread_shuttle_t)0)
+               /* Miscellaneous bits guarded by mutex */
+               uint32_t
+               /* Indicates that the thread has not been terminated */
+                                               active:1,
+
+          /* Indicates that the thread has been started after creation */
+                                               started:1,
+                                               :0;
+
+               /* Return Handers */
+               struct ReturnHandler {
+                       struct ReturnHandler    *next;
+                       void            (*handler)(
+                                                       struct ReturnHandler            *rh,
+                                                       struct thread                           *thread);
+               } *handlers, special_handler;
+
+               /* Ports associated with this thread */
+               struct ipc_port                 *ith_self;              /* not a right, doesn't hold ref */
+               struct ipc_port                 *ith_sself;             /* a send right */
+               struct exception_action exc_actions[EXC_TYPES_COUNT];
+
+               /* Owned ulocks (a lock set element) */
+               queue_head_t                    held_ulocks;
+
+#if    MACH_PROF
+               /* Profiling */
+               boolean_t                               profiled;
+               boolean_t                               profiled_own;
+               struct prof_data                *profil_buffer;
+#endif /* MACH_PROF */
+
+#ifdef MACH_BSD
+               void                                    *uthread;
+#endif
+};

 
 #define ith_state              saved.receive.state
 #define ith_object             saved.receive.object
 
 #define ith_state              saved.receive.state
 #define ith_object             saved.receive.object

-#define ith_msg                        saved.receive.msg
+#define ith_msg_addr                   saved.receive.msg_addr

 #define ith_msize              saved.receive.msize
 #define        ith_option              saved.receive.option
 #define ith_scatter_list_size  saved.receive.slist_size
 #define ith_msize              saved.receive.msize
 #define        ith_option              saved.receive.option
 #define ith_scatter_list_size  saved.receive.slist_size


@@ -390,246 +365,310 @@ struct thread_shuttle {
 #define sth_result             saved.sema.result
 #define sth_continuation       saved.sema.continuation
 
 #define sth_result             saved.sema.result
 #define sth_continuation       saved.sema.continuation
 

-struct funnel_lock {
-       int                     fnl_type;                       /* funnel type */
-       mutex_t         *fnl_mutex;                     /* underlying mutex for the funnel */
-       void *          fnl_mtxholder;          /* thread (last)holdng mutex */
-       void *          fnl_mtxrelease;         /* thread (last)releasing mutex */
-       mutex_t         *fnl_oldmutex;          /* Mutex before collapsing split funnel */
-};
+extern void                    thread_bootstrap(void);

 
 

-typedef struct funnel_lock             funnel_t;
+extern void                    thread_init(void);

 
 

-extern thread_act_t active_kloaded[NCPUS];     /* "" kernel-loaded acts */
-extern vm_offset_t active_stacks[NCPUS];       /* active kernel stacks */
-extern vm_offset_t kernel_stack[NCPUS];
+extern void                    thread_daemon_init(void);

 
 

-#ifndef MACHINE_STACK_STASH
-/*
- * MD Macro to fill up global stack state,
- * keeping the MD structure sizes + games private
- */
-#define MACHINE_STACK_STASH(stack)                                                             \
-MACRO_BEGIN                                                                                                            \
-       mp_disable_preemption();                                                                        \
-       active_stacks[cpu_number()] = (stack);                                          \
-       kernel_stack[cpu_number()] = (stack) + KERNEL_STACK_SIZE;       \
-       mp_enable_preemption();                                                                         \
-MACRO_END
-#endif /* MACHINE_STACK_STASH */
+#define        thread_reference_internal(thread)       \
+                       hw_atomic_add(&(thread)->ref_count, 1)

 
 

-/*
- *     Kernel-only routines
- */
+#define thread_deallocate_internal(thread)     \
+                       hw_atomic_sub(&(thread)->ref_count, 1)

 
 

-/* Initialize thread module */
-extern void            thread_init(void);
+#define thread_reference(thread)                                       \
+MACRO_BEGIN                                                                                    \
+       if ((thread) != THREAD_NULL)                                    \
+               thread_reference_internal(thread);                      \
+MACRO_END

 
 

-/* Take reference on thread (make sure it doesn't go away) */
-extern void            thread_reference(
-                                       thread_t                thread);
+extern void                    thread_deallocate(
+                                               thread_t                thread);

 
 

-/* Release reference on thread */
-extern void            thread_deallocate(
-                                       thread_t                thread);
+extern void                    thread_terminate_self(void);

 
 

-/* Set task priority of member thread */
-extern void            thread_task_priority(
-                                       thread_t                thread,
-                                       integer_t               priority,
-                                       integer_t               max_priority);
+extern kern_return_t   thread_terminate_internal(
+                                                       thread_t                thread);

 
 

-/* Start a thread at specified routine */
-#define thread_start(thread, start)                                            \
-                                       (thread)->continuation = (start)
+extern void                    thread_terminate_enqueue(
+                                               thread_t                thread);

 
 

+extern void                    thread_stack_enqueue(
+                                               thread_t                thread);

 
 

-/* Reaps threads waiting to be destroyed */
-extern void            thread_reaper(void);
+extern void                    thread_hold(
+                                               thread_t        thread);

 
 

+extern void                    thread_release(
+                                               thread_t        thread);

 
 

-#if    MACH_HOST
-/* Preclude thread processor set assignement */
-extern void            thread_freeze(
-                                       thread_t                thread);
+#define        thread_lock_init(th)    simple_lock_init(&(th)->sched_lock, 0)
+#define thread_lock(th)                        simple_lock(&(th)->sched_lock)
+#define thread_unlock(th)              simple_unlock(&(th)->sched_lock)
+#define thread_lock_try(th)            simple_lock_try(&(th)->sched_lock)

 
 

-/* Assign thread to a processor set */
-extern void            thread_doassign(
-                                       thread_t                thread,
-                                       processor_set_t new_pset,
-                                       boolean_t               release_freeze);
+#define thread_should_halt_fast(thread)                (!(thread)->active)

 
 

-/* Allow thread processor set assignement */
-extern void            thread_unfreeze(
-                                       thread_t                thread);
+#define wake_lock_init(th)             simple_lock_init(&(th)->wake_lock, 0)
+#define wake_lock(th)                  simple_lock(&(th)->wake_lock)
+#define wake_unlock(th)                        simple_unlock(&(th)->wake_lock)
+#define wake_lock_try(th)              simple_lock_try(&(th)->wake_lock)

 
 

-#endif /* MACH_HOST */
+extern void                            stack_alloc(
+                                                       thread_t                thread);

 
 

-/* Insure thread always has a kernel stack */
-extern void            stack_privilege(
-                                       thread_t                thread);
+extern void                            stack_free(
+                                                       thread_t                thread);

 
 

-extern void            consider_thread_collect(void);
+extern void                            stack_free_stack(
+                                                       vm_offset_t             stack);

 
 

-/*
- *     Arguments to specify aggressiveness to thread halt.
- *     Can't have MUST_HALT and SAFELY at the same time.
- */
-#define        THREAD_HALT_NORMAL      0
-#define        THREAD_HALT_MUST_HALT   1       /* no deadlock checks */
-#define        THREAD_HALT_SAFELY      2       /* result must be restartable */
+extern boolean_t               stack_alloc_try(
+                                                       thread_t            thread);

 
 

-/*
- *     Macro-defined routines
- */
+extern void                            stack_collect(void);

 
 

-#define thread_pcb(th)         ((th)->pcb)
+extern void                            stack_init(void);

 
 

-#define        thread_lock_init(th)                                                                                    \
-                               simple_lock_init(&(th)->lock, ETAP_THREAD_LOCK)
-#define thread_lock(th)                simple_lock(&(th)->lock)
-#define thread_unlock(th)      simple_unlock(&(th)->lock)
+extern kern_return_t    thread_state_initialize(
+                                                       thread_t                                thread);

 
 

-#define thread_should_halt_fast(thread)        \
-       (!(thread)->top_act || \
-       !(thread)->top_act->active || \
-       (thread)->top_act->ast & (AST_HALT|AST_TERMINATE))
+extern kern_return_t   thread_setstatus(
+                                                       thread_t                                thread,
+                                                       int                                             flavor,
+                                                       thread_state_t                  tstate,
+                                                       mach_msg_type_number_t  count);

 
 

-#define thread_should_halt(thread) thread_should_halt_fast(thread)
+extern kern_return_t   thread_getstatus(
+                                                       thread_t                                thread,
+                                                       int                                             flavor,
+                                                       thread_state_t                  tstate,
+                                                       mach_msg_type_number_t  *count);
+
+extern kern_return_t   thread_info_internal(
+                                                       thread_t                                thread,
+                                                       thread_flavor_t                 flavor,
+                                                       thread_info_t                   thread_info_out,
+                                                       mach_msg_type_number_t  *thread_info_count);

 
 

-#define rpc_lock_init(th)      mutex_init(&(th)->rpc_lock, ETAP_THREAD_RPC)
-#define rpc_lock(th)           mutex_lock(&(th)->rpc_lock)
-#define rpc_lock_try(th)       mutex_try(&(th)->rpc_lock)
-#define rpc_unlock(th)         mutex_unlock(&(th)->rpc_lock)
+extern void                            thread_task_priority(
+                                                       thread_t                thread,
+                                                       integer_t               priority,
+                                                       integer_t               max_priority);

 
 

-/*
- * Lock to cover wake_active only; like thread_lock(), is taken
- * at splsched().  Used to avoid calling into scheduler with a
- * thread_lock() held.  Precedes thread_lock() (and other scheduling-
- * related locks) in the system lock ordering.
- */
-#define wake_lock_init(th)                                     \
-                       simple_lock_init(&(th)->wake_lock, ETAP_THREAD_WAKE)
-#define wake_lock(th)          simple_lock(&(th)->wake_lock)
-#define wake_unlock(th)                simple_unlock(&(th)->wake_lock)
+extern void                            thread_policy_reset(
+                                                       thread_t                thread);

 
 

-static __inline__ vm_offset_t current_stack(void);
-static __inline__ vm_offset_t
-current_stack(void)
-{
-       vm_offset_t     ret;
+extern kern_return_t   kernel_thread_create(
+                                                       thread_continue_t       continuation,
+                                                       void                            *parameter,
+                                                       integer_t                       priority,
+                                                       thread_t                        *new_thread);

 
 

-       mp_disable_preemption();
-       ret = active_stacks[cpu_number()];
-       mp_enable_preemption();
-       return ret;
-}
+extern kern_return_t   kernel_thread_start_priority(
+                                                       thread_continue_t       continuation,
+                                                       void                            *parameter,
+                                                       integer_t                       priority,
+                                                       thread_t                        *new_thread);

 
 

+extern void                            machine_stack_attach(
+                                                       thread_t                thread,
+                                                       vm_offset_t             stack);

 
 

-extern void            pcb_module_init(void);
+extern vm_offset_t             machine_stack_detach(
+                                                       thread_t                thread);

 
 

-extern void            pcb_init(
-                                       thread_act_t    thr_act);
+extern void                            machine_stack_handoff(
+                                                       thread_t                old,
+                                                       thread_t                new);

 
 

-extern void            pcb_terminate(
-                                       thread_act_t    thr_act);
+extern thread_t                        machine_switch_context(
+                                                       thread_t                        old_thread,
+                                                       thread_continue_t       continuation,
+                                                       thread_t                        new_thread);

 
 

-extern void            pcb_collect(
-                                       thread_act_t    thr_act);
+extern void                            machine_load_context(
+                                                       thread_t                thread);

 
 

-extern void            pcb_user_to_kernel(
-                                       thread_act_t    thr_act);
+extern kern_return_t   machine_thread_state_initialize(
+                                                       thread_t                                thread);

 
 

-extern kern_return_t   thread_setstatus(
-                                                       thread_act_t                    thr_act,
-                                                       int                                             flavor,
-                                                       thread_state_t                  tstate,
+extern kern_return_t   machine_thread_set_state(
+                                                       thread_t                                thread,
+                                                       thread_flavor_t                 flavor,
+                                                       thread_state_t                  state,

                                                        mach_msg_type_number_t  count);
 
                                                        mach_msg_type_number_t  count);
 

-extern kern_return_t   thread_getstatus(
-                                                       thread_act_t                    thr_act,
-                                                       int                                             flavor,
-                                                       thread_state_t                  tstate,
+extern kern_return_t   machine_thread_get_state(
+                                                       thread_t                                thread,
+                                                       thread_flavor_t                 flavor,
+                                                       thread_state_t                  state,

                                                        mach_msg_type_number_t  *count);
 
                                                        mach_msg_type_number_t  *count);
 

-extern boolean_t               stack_alloc_try(
-                                                       thread_t                            thread,
-                                                       void                                    (*start_pos)(thread_t));
+extern kern_return_t   machine_thread_dup(
+                                                       thread_t                self,
+                                                       thread_t                target);
+
+extern void                            machine_thread_init(void);
+
+extern kern_return_t   machine_thread_create(
+                                                       thread_t                thread,
+                                                       task_t                  task);
+
+extern void                machine_thread_destroy(
+                                                       thread_t                thread);

 
 

-/* This routine now used only internally */
-extern kern_return_t   thread_info_shuttle(
-                                                       thread_act_t                    thr_act,
+extern void                            machine_set_current_thread(
+                                                       thread_t                        thread);
+
+extern void                    machine_thread_terminate_self(void);
+
+extern kern_return_t   machine_thread_get_kern_state(
+                                                       thread_t                                thread,

                                                        thread_flavor_t                 flavor,
                                                        thread_flavor_t                 flavor,

-                                                       thread_info_t                   thread_info_out,
-                                                       mach_msg_type_number_t  *thread_info_count);
+                                                       thread_state_t                  tstate,
+                                                       mach_msg_type_number_t  *count);
+

 
 

-extern void            thread_user_to_kernel(
-                                       thread_t                thread);
+/*
+ * XXX Funnel locks XXX
+ */

 
 

-/* Machine-dependent routines */
-extern void            thread_machine_init(void);
+struct funnel_lock {
+       int                     fnl_type;                       /* funnel type */
+       lck_mtx_t       *fnl_mutex;                     /* underlying mutex for the funnel */
+       void *          fnl_mtxholder;          /* thread (last)holdng mutex */
+       void *          fnl_mtxrelease;         /* thread (last)releasing mutex */
+       lck_mtx_t       *fnl_oldmutex;          /* Mutex before collapsing split funnel */
+};

 
 

-extern void            thread_machine_set_current(
-                                       thread_t                thread );
+typedef struct ReturnHandler           ReturnHandler;

 
 

-extern kern_return_t   thread_machine_create(
-                                                       thread_t                        thread,
-                                                       thread_act_t            thr_act,
-                                                       void                            (*start_pos)(thread_t));
+#define        thread_mtx_lock(thread)                 mutex_lock(&(thread)->mutex)
+#define        thread_mtx_try(thread)                  mutex_try(&(thread)->mutex)
+#define        thread_mtx_unlock(thread)               mutex_unlock(&(thread)->mutex)

 
 

-extern void            thread_set_syscall_return(
-                                       thread_t                thread,
-                                       kern_return_t   retval);
+extern void                    act_execute_returnhandlers(void);

 
 

-extern void            thread_machine_destroy(
-                                       thread_t                thread );
+extern void                    install_special_handler(
+                                               thread_t                thread);

 
 

-extern void            thread_machine_flush(
-                               thread_act_t thr_act);
+extern void                    special_handler(
+                                               ReturnHandler   *rh,
+                                               thread_t                thread);

 
 

-extern thread_t     kernel_thread_with_priority(
-                    task_t          task,
-                                       integer_t               priority,
-                    void            (*start)(void),
-                                       boolean_t               alloc_stack,
-                    boolean_t       start_running);
+#else  /* MACH_KERNEL_PRIVATE */

 
 

-extern void            funnel_lock(funnel_t *);
+__BEGIN_DECLS

 
 

-extern void            funnel_unlock(funnel_t *);
+extern thread_t                current_thread(void);

 
 

-#else /* !MACH_KERNEL_PRIVATE */
+extern void                    thread_reference(
+                                               thread_t        thread);
+
+extern void                    thread_deallocate(
+                                               thread_t        thread);
+
+__END_DECLS
+
+#endif /* MACH_KERNEL_PRIVATE */
+
+#ifdef KERNEL_PRIVATE

 
 typedef struct funnel_lock             funnel_t;
 
 
 typedef struct funnel_lock             funnel_t;
 

-extern boolean_t thread_should_halt(thread_t);
+#ifdef MACH_KERNEL_PRIVATE

 
 

-#endif /* !MACH_KERNEL_PRIVATE */
+extern void            funnel_lock(
+                                               funnel_t        *lock);

 
 

-#define THR_FUNNEL_NULL (funnel_t *)0
+extern void            funnel_unlock(
+                                               funnel_t        *lock);
+
+vm_offset_t                    min_valid_stack_address(void);
+vm_offset_t                    max_valid_stack_address(void);
+
+#endif /* MACH_KERNEL_PRIVATE */
+
+__BEGIN_DECLS
+
+extern funnel_t                *thread_funnel_get(void);
+
+extern boolean_t       thread_funnel_set(
+                                               funnel_t        *lock,
+                                               boolean_t        funneled);

 
 extern thread_t                kernel_thread(
 
 extern thread_t                kernel_thread(

-                                       task_t  task,
-                                       void    (*start)(void));
+                                               task_t          task,
+                                               void            (*start)(void));

 
 

-extern void                    thread_terminate_self(void);
+__END_DECLS
+
+#endif /* KERNEL_PRIVATE */
+
+__BEGIN_DECLS
+
+#ifdef XNU_KERNEL_PRIVATE
+
+/*
+ * XXX Funnel locks XXX
+ */
+
+#define THR_FUNNEL_NULL (funnel_t *)0
+
+extern funnel_t                 *funnel_alloc(
+                                               int                     type);

 
 

-extern funnel_t *      funnel_alloc(int);
+extern void                    funnel_free(
+                                               funnel_t        *lock);

 
 

-extern funnel_t *      thread_funnel_get(void);
+extern void                    thread_read_times(
+                                               thread_t                thread,
+                                               time_value_t    *user_time,
+                                               time_value_t    *system_time);

 
 

-extern boolean_t       thread_funnel_set(funnel_t * fnl, boolean_t funneled);
+extern void                    thread_setuserstack(
+                                               thread_t                thread,
+                                               mach_vm_offset_t        user_stack);

 
 

-extern boolean_t       thread_funnel_merge(funnel_t * fnl, funnel_t * otherfnl);
+extern uint64_t                thread_adjuserstack(
+                                               thread_t                thread,
+                                               int                             adjust);

 
 

-extern void         thread_set_cont_arg(int);
+extern void                    thread_setentrypoint(
+                                               thread_t                thread,
+                                               mach_vm_offset_t        entry);

 
 

-extern int          thread_get_cont_arg(void);
+extern kern_return_t   thread_wire_internal(
+                                                       host_priv_t             host_priv,
+                                                       thread_t                thread,
+                                                       boolean_t               wired,
+                                                       boolean_t               *prev_state);

 
 /* JMM - These are only temporary */
 extern boolean_t       is_thread_running(thread_t); /* True is TH_RUN */
 extern boolean_t       is_thread_idle(thread_t); /* True is TH_IDLE */
 
 /* JMM - These are only temporary */
 extern boolean_t       is_thread_running(thread_t); /* True is TH_RUN */
 extern boolean_t       is_thread_idle(thread_t); /* True is TH_IDLE */

-extern event_t         get_thread_waitevent(thread_t);
-extern kern_return_t   get_thread_waitresult(thread_t);
+
+extern kern_return_t   thread_dup(thread_t);
+
+extern task_t  get_threadtask(thread_t);
+
+extern void            *get_bsdthread_info(thread_t);
+extern void            set_bsdthread_info(thread_t, void *);
+extern void            *uthread_alloc(task_t, thread_t);
+extern void            uthread_free(task_t, void *, void *); 
+
+extern boolean_t       thread_should_halt(
+                                               thread_t                thread);
+
+#endif /* XNU_KERNEL_PRIVATE */
+
+extern kern_return_t   kernel_thread_start(
+                                                       thread_continue_t       continuation,
+                                                       void                            *parameter,
+                                                       thread_t                        *new_thread);
+
+__END_DECLS

 
 #endif /* _KERN_THREAD_H_ */
 
 #endif /* _KERN_THREAD_H_ */