![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to thread.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / kern|
Return to thread.h CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_FREE_COPYRIGHT@
24: */
25: /*
26: * Mach Operating System
27: * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
28: * All Rights Reserved.
29: *
30: * Permission to use, copy, modify and distribute this software and its
31: * documentation is hereby granted, provided that both the copyright
32: * notice and this permission notice appear in all copies of the
33: * software, derivative works or modified versions, and any portions
34: * thereof, and that both notices appear in supporting documentation.
35: *
36: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
37: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
38: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
39: *
40: * Carnegie Mellon requests users of this software to return to
41: *
42: * Software Distribution Coordinator or [email protected]
43: * School of Computer Science
44: * Carnegie Mellon University
45: * Pittsburgh PA 15213-3890
46: *
47: * any improvements or extensions that they make and grant Carnegie Mellon
48: * the rights to redistribute these changes.
49: */
50: /*
51: */
52: /*
53: * File: thread.h
54: * Author: Avadis Tevanian, Jr.
55: *
56: * This file contains the structure definitions for threads.
57: *
58: */
59: /*
60: * Copyright (c) 1993 The University of Utah and
61: * the Computer Systems Laboratory (CSL). All rights reserved.
62: *
63: * Permission to use, copy, modify and distribute this software and its
64: * documentation is hereby granted, provided that both the copyright
65: * notice and this permission notice appear in all copies of the
66: * software, derivative works or modified versions, and any portions
67: * thereof, and that both notices appear in supporting documentation.
68: *
69: * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
70: * IS" CONDITION. THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
71: * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
72: *
73: * CSL requests users of this software to return to [email protected] any
74: * improvements that they make and grant CSL redistribution rights.
75: *
76: */
77:
78: #ifndef _KERN_THREAD_H_
79: #define _KERN_THREAD_H_
80:
81: #include <mach/kern_return.h>
82: #include <mach/mach_types.h>
83: #include <mach/message.h>
84: #include <mach/boolean.h>
85: #include <mach/vm_types.h>
86: #include <mach/vm_prot.h>
87: #include <mach/thread_info.h>
88: #include <mach/thread_status.h>
89: #include <kern/cpu_data.h> /* for current_thread */
90: #include <kern/kern_types.h>
91:
92: /*
93: * Logically, a thread of control consists of two parts:
94: * a thread_shuttle, which may migrate during an RPC, and
95: * a thread_activation, which remains attached to a task.
96: * The thread_shuttle is the larger portion of the two-part thread,
97: * and contains scheduling info, messaging support, accounting info,
98: * and links to the thread_activation within which the shuttle is
99: * currently operating.
100: *
101: * It might make sense to have the thread_shuttle be a proper sub-structure
102: * of the thread, with the thread containing links to both the shuttle and
103: * activation. In order to reduce the scope and complexity of source
104: * changes and the overhead of maintaining these linkages, we have subsumed
105: * the shuttle into the thread, calling it a thread_shuttle.
106: *
107: * User accesses to threads always come in via the user's thread port,
108: * which gets translated to a pointer to the target thread_activation.
109: * Kernel accesses intended to effect the entire thread, typically use
110: * a pointer to the thread_shuttle (current_thread()) as the target of
111: * their operations. This makes sense given that we have subsumed the
112: * shuttle into the thread_shuttle, eliminating one set of linkages.
113: * Operations effecting only the shuttle may use a thread_shuttle_t
114: * to indicate this.
115: *
116: * The current_act() macro returns a pointer to the current thread_act, while
117: * the current_thread() macro returns a pointer to the currently active
118: * thread_shuttle (representing the thread in its entirety).
119: */
120:
121: /*
122: * Possible results of thread_block - returned in
123: * current_thread()->wait_result.
124: */
125: #define THREAD_AWAKENED 0 /* normal wakeup */
126: #define THREAD_TIMED_OUT 1 /* timeout expired */
127: #define THREAD_INTERRUPTED 2 /* interrupted by clear_wait */
128: #define THREAD_RESTART 3 /* restart operation entirely */
129:
130: /*
131: * Interruptible flags for assert_wait
132: *
133: */
134: #define THREAD_UNINT 0 /* not interruptible */
135: #define THREAD_INTERRUPTIBLE 1 /* may not be restartable */
136: #define THREAD_ABORTSAFE 2 /* abortable safely */
137:
138: #ifdef MACH_KERNEL_PRIVATE
139: #include <cpus.h>
140: #include <hw_footprint.h>
141: #include <mach_host.h>
142: #include <mach_prof.h>
143: #include <dipc.h>
144: #include <xkmachkernel.h>
145: #include <mach_lock_mon.h>
146: #include <mach_ldebug.h>
147:
148: #include <mach/port.h>
149: #include <kern/ast.h>
150: #include <kern/cpu_number.h>
151: #include <kern/queue.h>
152: #include <kern/time_out.h>
153: #include <kern/timer.h>
154: #include <kern/lock.h>
155: #include <kern/sched.h>
156: #include <kern/sched_prim.h>
157: #include <kern/thread_pool.h>
158: #include <kern/thread_call.h>
159: #include <kern/thread_call_private.h>
160: #include <kern/task.h>
161: #include <ipc/ipc_kmsg.h>
162: #include <machine/thread.h>
163:
164:
165: typedef struct thread_shuttle {
166: /*
167: * Beginning of thread_shuttle proper. When the thread is on
168: * a wait queue, these three fields are in treated as an un-
169: * official union with a wait_queue_element. If you change
170: * these, you must change that definition as well.
171: */
172: queue_chain_t links; /* current run/wait queue links */
173: run_queue_t runq; /* run queue p is on SEE BELOW */
174: int whichq; /* which queue level p is on */
175:
176: /*
177: * NOTE: The runq field in the thread structure has an unusual
178: * locking protocol. If its value is RUN_QUEUE_NULL, then it is
179: * locked by the thread_lock, but if its value is something else
180: * (i.e. a run_queue) then it is locked by that run_queue's lock.
181: */
182:
183: /* Thread bookkeeping */
184: queue_chain_t pset_threads; /* list of all shuttles in proc set */
185:
186: /* Self-preservation */
187: decl_simple_lock_data(,lock) /* scheduling lock (thread_lock()) */
188: decl_simple_lock_data(,wake_lock) /* covers wake_active (wake_lock())*/
189: decl_mutex_data(,rpc_lock) /* RPC lock (rpc_lock()) */
190: int ref_count; /* number of references to me */
191:
192: vm_offset_t kernel_stack; /* accurate only if the thread is
193: not swapped and not executing */
194:
195: vm_offset_t stack_privilege;/* reserved kernel stack */
196:
197: /* Blocking information */
198: int reason; /* why we blocked */
199: event_t wait_event; /* event we are waiting on */
200: kern_return_t wait_result; /* outcome of wait -
201: may be examined by this thread
202: WITHOUT locking */
203: wait_queue_t wait_queue; /* wait queue we are currently on */
204: queue_chain_t wait_link; /* event's wait queue link */
205: boolean_t wake_active; /* Someone is waiting for this
206: thread to become suspended */
207: int state; /* Thread state: */
208: boolean_t preempt; /* Thread is undergoing preemption */
209:
210: #if ETAP_EVENT_MONITOR
211: int etap_reason; /* real reason why we blocked */
212: boolean_t etap_trace; /* ETAP trace status */
213: #endif /* ETAP_EVENT_MONITOR */
214:
215: /*
216: * Thread states [bits or'ed]
217: */
218: #define TH_WAIT 0x01 /* thread is queued for waiting */
219: #define TH_SUSP 0x02 /* thread has been asked to stop */
220: #define TH_RUN 0x04 /* thread is running or on runq */
221: #define TH_UNINT 0x08 /* thread is waiting uninteruptibly */
222: #define TH_HALTED 0x10 /* thread is halted at clean point ? */
223:
224: #define TH_ABORT 0x20 /* abort interruptible waits */
225: #define TH_SWAPPED_OUT 0x40 /* thread is swapped out */
226:
227: #define TH_IDLE 0x80 /* thread is an idle thread */
228:
229: #define TH_SCHED_STATE (TH_WAIT|TH_SUSP|TH_RUN|TH_UNINT)
230:
231: #define TH_STACK_HANDOFF 0x0100 /* thread has no kernel stack */
232: #define TH_STACK_COMING_IN 0x0200 /* thread is waiting for kernel stack */
233: #define TH_STACK_STATE (TH_STACK_HANDOFF | TH_STACK_COMING_IN)
234:
235: #define TH_TERMINATE 0x400 /* thread is terminating */
236:
237: #if 0 /* Grenoble version */
238: int preempt; /* Thread preemption status */
239: #define TH_PREEMPTABLE 0 /* Thread is preemptable */
240: #define TH_NOT_PREEMPTABLE 1 /* Thread is not preemptable */
241: #define TH_PREEMPTED 2 /* Thread has been preempted */
242:
243: #if ETAP_EVENT_MONITOR
244: int etap_reason; /* real reason why we blocked */
245: boolean_t etap_trace; /* ETAP trace status */
246: #endif /* ETAP_EVENT_MONITOR */
247:
248: #endif
249:
250: /* Stack handoff information */
251: void (*continuation)(/* start here next time runnable */
252: void);
253: int cont_arg; /* continuation argument */
254:
255: /* Scheduling information */
256: int policy; /* scheduling policy */
257: sp_info_t sp_info; /* policy-specific information */
258: int pending_policy; /* pending scheduling policy */
259: sp_attributes_t pending_sched_attr;
260: /* policy-specific information */
261: kern_return_t change_sfr; /* return value for pending change */
262: int sched_pri; /* scheduled (computed) priority */
263: unsigned int sleep_stamp; /* last time in TH_WAIT state */
264: #if 0 /* Grenoble */
265: unsigned int sched_change_stamp;
266: /* last time priority or policy was
267: explicitly changed (not the same
268: units as sched_stamp!) */
269: int unconsumed_quantum; /* leftover quantum (RR/FIFO) */
270: #endif
271:
272: /* VM global variables */
273: boolean_t vm_privilege; /* can use reserved memory? */
274: vm_offset_t recover; /* page fault recovery (copyin/out) */
275:
276: /* IPC data structures */
277:
278: struct ipc_kmsg_queue ith_messages;
279:
280: mach_port_t ith_mig_reply; /* reply port for mig */
281: mach_port_t ith_rpc_reply; /* reply port for kernel RPCs */
282:
283: /* Various bits of stashed state */
284: union {
285: struct {
286: mach_msg_return_t state; /* receive state */
287: mach_msg_size_t msize; /* max size for recvd msg */
288: struct ipc_kmsg *kmsg; /* received message */
289: mach_port_seqno_t seqno; /* seqno of recvd message */
290: mach_msg_option_t option;
291: mach_msg_body_t *scatter_list;
292: mach_msg_size_t scatter_list_size;
293: } receive;
294: char *other; /* catch-all for other state */
295: } saved;
296:
297: /* Timing data structures */
298: timer_data_t user_timer; /* user mode timer */
299: timer_data_t system_timer; /* system mode timer */
300: timer_data_t depressed_timer;/* depressed priority timer */
301: timer_save_data_t user_timer_save; /* saved user timer value */
302: timer_save_data_t system_timer_save; /* saved sys timer val. */
303: /*** ??? should the next two fields be moved to SP-specific struct?***/
304: unsigned int cpu_delta; /* cpu usage since last update */
305: unsigned int sched_delta; /* weighted cpu usage since update */
306:
307: /* Timers for time-outs */
308: thread_call_data_t wait_timer;
309: boolean_t wait_timer_is_set;
310: thread_call_data_t depress_timer;
311:
312: /* Ast/Halt data structures */
313: boolean_t active; /* how alive is the thread */
314:
315: /* Processor data structures */
316: processor_set_t processor_set; /* assigned processor set */
317: #if NCPUS > 1
318: processor_t bound_processor; /* bound to processor ?*/
319: #endif /* NCPUS > 1 */
320: #if MACH_HOST
321: boolean_t may_assign; /* may assignment change? */
322: boolean_t assign_active; /* someone waiting for may_assign */
323: #endif /* MACH_HOST */
324:
325: #if XKMACHKERNEL
326: int xk_type;
327: #endif /* XKMACHKERNEL */
328:
329: #if NCPUS > 1
330: processor_t last_processor; /* processor this last ran on */
331: #if MACH_LOCK_MON
332: unsigned lock_stack; /* number of locks held */
333: #endif /* MACH_LOCK_MON */
334: #endif /* NCPUS > 1 */
335:
336: int at_safe_point; /* thread_abort_safely allowed */
337: int funnel_state;
338: #define TH_FN_OWNED 0x1 /* we own the funnel lock */
339: #define TH_FN_REFUNNEL 0x2 /* must reaquire funnel lock when unblocking */
340:
341: #if MACH_LDEBUG
342: /*
343: * Debugging: track acquired mutexes and locks.
344: * Because a thread can block while holding such
345: * synchronizers, we think of the thread as
346: * "owning" them.
347: */
348: #define MUTEX_STACK_DEPTH 20
349: #define LOCK_STACK_DEPTH 20
350: mutex_t *mutex_stack[MUTEX_STACK_DEPTH];
351: lock_t *lock_stack[LOCK_STACK_DEPTH];
352: unsigned int mutex_stack_index;
353: unsigned int lock_stack_index;
354: unsigned mutex_count; /* XXX to be deleted XXX */
355: boolean_t kthread; /* thread is a kernel thread */
356: #endif /* MACH_LDEBUG */
357:
358: /*
359: * End of thread_shuttle proper
360: */
361:
362: /*
363: * Migration and thread_activation linkage information
364: */
365: struct thread_activation *top_act; /* "current" thr_act */
366:
367: } Thread_Shuttle;
368:
369: #define THREAD_SHUTTLE_NULL ((thread_shuttle_t)0)
370:
371: #define ith_state saved.receive.state
372: #define ith_msize saved.receive.msize
373: #define ith_kmsg saved.receive.kmsg
374: #define ith_seqno saved.receive.seqno
375: #define ith_option saved.receive.option
376: #define ith_scatter_list saved.receive.scatter_list
377: #define ith_scatter_list_size saved.receive.scatter_list_size
378: #define ith_other saved.other
379:
380: extern thread_act_t active_kloaded[NCPUS]; /* "" kernel-loaded acts */
381: extern vm_offset_t active_stacks[NCPUS]; /* active kernel stacks */
382: extern vm_offset_t kernel_stack[NCPUS];
383:
384: decl_mutex_data(extern,funnel_lock);
385:
386: #ifndef MACHINE_STACK_STASH
387: /*
388: * MD Macro to fill up global stack state,
389: * keeping the MD structure sizes + games private
390: */
391: #define MACHINE_STACK_STASH(stack) \
392: MACRO_BEGIN \
393: mp_disable_preemption(); \
394: active_stacks[cpu_number()] = (stack); \
395: kernel_stack[cpu_number()] = (stack) + KERNEL_STACK_SIZE; \
396: mp_enable_preemption(); \
397: MACRO_END
398: #endif /* MACHINE_STACK_STASH */
399:
400: /*
401: * Kernel-only routines
402: */
403:
404: /* Initialize thread module */
405: extern void thread_init(void);
406:
407: /* Take reference on thread (make sure it doesn't go away) */
408: extern void thread_reference(
409: thread_t thread);
410:
411: /* Release reference on thread */
412: extern void thread_deallocate(
413: thread_t thread);
414:
415: /* Set priority of calling thread */
416: extern void thread_set_own_priority(
417: int priority);
418:
419: /* Reset thread's priority */
420: extern kern_return_t thread_priority(
421: thread_act_t thr_act,
422: int priority,
423: boolean_t set_max);
424:
425: /* Reset thread's max priority */
426: extern kern_return_t thread_max_priority(
427: thread_act_t thr_act,
428: processor_set_t pset,
429: int max_priority);
430:
431: /* Reset thread's max priority while holding RPC locks */
432: extern kern_return_t thread_max_priority_locked(
433: thread_t thread,
434: processor_set_t pset,
435: int max_priority);
436:
437: /* Set a thread's priority while holding RPC locks */
438: extern kern_return_t thread_priority_locked(
439: thread_t thread,
440: int priority,
441: boolean_t set_max);
442:
443: /* Start a thread at specified routine */
444: #define thread_start(thread, start) \
445: (thread)->continuation = (start)
446:
447:
448: /* Reaps threads waiting to be destroyed */
449: extern void thread_reaper(void);
450:
451: extern boolean_t thread_not_preemptable(
452: thread_t thread);
453:
454: #if MACH_HOST
455: /* Preclude thread processor set assignement */
456: extern void thread_freeze(
457: thread_t thread);
458:
459: /* Assign thread to a processor set */
460: extern void thread_doassign(
461: thread_t thread,
462: processor_set_t new_pset,
463: boolean_t release_freeze);
464:
465: /* Allow thread processor set assignement */
466: extern void thread_unfreeze(
467: thread_t thread);
468:
469: #endif /* MACH_HOST */
470:
471: /* Insure thread always has a kernel stack */
472: extern void stack_privilege(
473: thread_t thread);
474:
475: extern void consider_thread_collect(void);
476:
477: /*
478: * Arguments to specify aggressiveness to thread halt.
479: * Can't have MUST_HALT and SAFELY at the same time.
480: */
481: #define THREAD_HALT_NORMAL 0
482: #define THREAD_HALT_MUST_HALT 1 /* no deadlock checks */
483: #define THREAD_HALT_SAFELY 2 /* result must be restartable */
484:
485: /*
486: * Macro-defined routines
487: */
488:
489: #define thread_pcb(th) ((th)->pcb)
490:
491: #define thread_lock_init(th) \
492: simple_lock_init(&(th)->lock, ETAP_THREAD_LOCK)
493: #define thread_lock(th) simple_lock(&(th)->lock)
494: #define thread_unlock(th) simple_unlock(&(th)->lock)
495:
496: #define thread_should_halt_fast(thread) \
497: (!(thread)->top_act || \
498: !(thread)->top_act->active || \
499: (thread)->top_act->ast & (AST_HALT|AST_TERMINATE))
500:
501: #define thread_should_halt(thread) thread_should_halt_fast(thread)
502:
503: #if 0 /* Gernoble */
504: /*
505: * We consider a thread not preemptable if it is marked as either
506: * suspended, waiting or halted.
507: * XXX - when scheduling framework and such is done, the
508: * thread state check can be eliminated
509: */
510: #define thread_not_preemptable(thread) \
511: (((thread)->state & (TH_WAIT|TH_SUSP)) != 0)
512:
513: #endif
514:
515: #define thread_lock_pair(ta,tb) \
516: MACRO_BEGIN \
517: if ((ta) < (tb)) { \
518: thread_lock(ta); \
519: thread_lock(tb); \
520: } \
521: else { \
522: thread_lock(tb); \
523: thread_lock(ta); \
524: } \
525: MACRO_END
526:
527: #define thread_unlock_pair(ta,tb) \
528: MACRO_BEGIN \
529: if ((ta) < (tb)) { \
530: thread_unlock(tb); \
531: thread_unlock(ta); \
532: } \
533: else { \
534: thread_unlock(ta); \
535: thread_unlock (tb); \
536: } \
537: MACRO_END
538:
539: #define rpc_lock_init(th) mutex_init(&(th)->rpc_lock, ETAP_THREAD_RPC)
540: #define rpc_lock(th) mutex_lock(&(th)->rpc_lock)
541: #define rpc_lock_try(th) mutex_try(&(th)->rpc_lock)
542: #define rpc_unlock(th) mutex_unlock(&(th)->rpc_lock)
543:
544: /*
545: * Lock to cover wake_active only; like thread_lock(), is taken
546: * at splsched(). Used to avoid calling into scheduler with a
547: * thread_lock() held. Precedes thread_lock() (and other scheduling-
548: * related locks) in the system lock ordering.
549: */
550: #define wake_lock_init(th) \
551: simple_lock_init(&(th)->wake_lock, ETAP_THREAD_WAKE)
552: #define wake_lock(th) simple_lock(&(th)->wake_lock)
553: #define wake_unlock(th) simple_unlock(&(th)->wake_lock)
554:
555: static __inline__ vm_offset_t current_stack(void);
556: static __inline__ vm_offset_t
557: current_stack(void)
558: {
559: vm_offset_t ret;
560:
561: mp_disable_preemption();
562: ret = active_stacks[cpu_number()];
563: mp_enable_preemption();
564: return ret;
565: }
566:
567:
568: extern void pcb_module_init(void);
569:
570: extern void pcb_init(
571: thread_act_t thr_act);
572:
573: extern void pcb_terminate(
574: thread_act_t thr_act);
575:
576: extern void pcb_collect(
577: thread_act_t thr_act);
578:
579: extern void pcb_user_to_kernel(
580: thread_act_t thr_act);
581:
582: extern kern_return_t thread_setstatus(
583: thread_act_t thr_act,
584: int flavor,
585: thread_state_t tstate,
586: mach_msg_type_number_t count);
587:
588: extern kern_return_t thread_getstatus(
589: thread_act_t thr_act,
590: int flavor,
591: thread_state_t tstate,
592: mach_msg_type_number_t *count);
593:
594: extern boolean_t stack_alloc_try(
595: thread_t thread,
596: void (*continuation)(void));
597:
598: /* This routine now used only internally */
599: extern kern_return_t thread_info_shuttle(
600: thread_act_t thr_act,
601: thread_flavor_t flavor,
602: thread_info_t thread_info_out,
603: mach_msg_type_number_t *thread_info_count);
604:
605: extern void thread_user_to_kernel(
606: thread_t thread);
607:
608: /* Machine-dependent routines */
609: extern void thread_machine_init(void);
610:
611: extern void thread_machine_set_current(
612: thread_t thread );
613:
614: extern kern_return_t thread_machine_create(
615: thread_t thread,
616: thread_act_t thr_act,
617: void (*start_pos)(void));
618:
619: extern void thread_set_syscall_return(
620: thread_t thread,
621: kern_return_t retval);
622:
623: extern void thread_machine_destroy(
624: thread_t thread );
625:
626: extern void thread_machine_flush(
627: thread_act_t thr_act);
628:
629: extern thread_t kernel_thread_with_attributes(
630: task_t task,
631: sp_attributes_t attributes,
632: void (*start_at)(void),
633: boolean_t start_running);
634:
635: #else /* !MACH_KERNEL_PRIVATE */
636:
637: extern boolean_t thread_should_halt(thread_t);
638:
639: #endif /* !MACH_KERNEL_PRIVATE */
640:
641: extern thread_t kernel_thread(
642: task_t task,
643: void (*start)(void));
644:
645: extern void thread_terminate_self(void);
646:
647: extern boolean_t thread_get_funneled(void);
648:
649: extern boolean_t thread_set_funneled(
650: boolean_t funneled);
651:
652: extern void thread_set_cont_arg(int);
653:
654: extern int thread_get_cont_arg(void);
655:
656: /* JMM - These are only temporary */
657: extern boolean_t is_thread_running(thread_t); /* True is TH_RUN */
658: extern boolean_t is_thread_idle(thread_t); /* True is TH_IDLE */
659: extern event_t get_thread_waitevent(thread_t);
660: extern kern_return_t get_thread_waitresult(thread_t);
661:
662: #endif /* _KERN_THREAD_H_ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.