1/*
2 * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28/*
29 * @OSF_FREE_COPYRIGHT@
30 */
31/*
32 * Mach Operating System
33 * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
34 * All Rights Reserved.
35 *
36 * Permission to use, copy, modify and distribute this software and its
37 * documentation is hereby granted, provided that both the copyright
38 * notice and this permission notice appear in all copies of the
39 * software, derivative works or modified versions, and any portions
40 * thereof, and that both notices appear in supporting documentation.
41 *
42 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
43 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
44 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
45 *
46 * Carnegie Mellon requests users of this software to return to
47 *
48 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
49 *  School of Computer Science
50 *  Carnegie Mellon University
51 *  Pittsburgh PA 15213-3890
52 *
53 * any improvements or extensions that they make and grant Carnegie Mellon
54 * the rights to redistribute these changes.
55 */
56/*
57 */
58/*
59 *	File:	thread.h
60 *	Author:	Avadis Tevanian, Jr.
61 *
62 *	This file contains the structure definitions for threads.
63 *
64 */
65/*
66 * Copyright (c) 1993 The University of Utah and
67 * the Computer Systems Laboratory (CSL).  All rights reserved.
68 *
69 * Permission to use, copy, modify and distribute this software and its
70 * documentation is hereby granted, provided that both the copyright
71 * notice and this permission notice appear in all copies of the
72 * software, derivative works or modified versions, and any portions
73 * thereof, and that both notices appear in supporting documentation.
74 *
75 * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
76 * IS" CONDITION.  THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
77 * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
78 *
79 * CSL requests users of this software to return to csl-dist@cs.utah.edu any
80 * improvements that they make and grant CSL redistribution rights.
81 *
82 */
83
84#ifndef	_KERN_THREAD_H_
85#define _KERN_THREAD_H_
86
87#include <mach/kern_return.h>
88#include <mach/mach_types.h>
89#include <mach/message.h>
90#include <mach/boolean.h>
91#include <mach/vm_param.h>
92#include <mach/thread_info.h>
93#include <mach/thread_status.h>
94#include <mach/exception_types.h>
95
96#include <kern/kern_types.h>
97
98#include <sys/cdefs.h>
99
100#ifdef	MACH_KERNEL_PRIVATE
101
102#include <cputypes.h>
103
104#include <mach_assert.h>
105#include <mach_ldebug.h>
106
107#include <ipc/ipc_types.h>
108
109#include <mach/port.h>
110#include <kern/cpu_number.h>
111#include <kern/queue.h>
112#include <kern/timer.h>
113#include <kern/lock.h>
114#include <kern/locks.h>
115#include <kern/sched.h>
116#include <kern/sched_prim.h>
117#include <kern/thread_call.h>
118#include <kern/timer_call.h>
119#include <kern/task.h>
120#include <kern/exception.h>
121#include <kern/affinity.h>
122
123#include <ipc/ipc_kmsg.h>
124
125#include <machine/cpu_data.h>
126#include <machine/thread.h>
127
128struct thread {
129	/*
130	 *	NOTE:	The runq field in the thread structure has an unusual
131	 *	locking protocol.  If its value is PROCESSOR_NULL, then it is
132	 *	locked by the thread_lock, but if its value is something else
133	 *	then it is locked by the associated run queue lock.
134	 *
135	 *	When the thread is on a wait queue, these first three fields
136	 *	are treated as an unofficial union with a wait_queue_element.
137	 *	If you change these, you must change that definition as well
138	 *	(kern/wait_queue.h).
139	 */
140  	/* Items examined often, modified infrequently */
141	queue_chain_t	links;				/* run/wait queue links */
142	processor_t		runq;				/* run queue assignment */
143	wait_queue_t	wait_queue;			/* wait queue we are currently on */
144	event64_t		wait_event;			/* wait queue event */
145	integer_t		options;			/* options set by thread itself */
146#define TH_OPT_INTMASK		0x03		/* interrupt / abort level */
147#define TH_OPT_VMPRIV		0x04		/* may allocate reserved memory */
148#define TH_OPT_DTRACE		0x08		/* executing under dtrace_probe */
149
150	/* Data updated during assert_wait/thread_wakeup */
151	decl_simple_lock_data(,sched_lock)	/* scheduling lock (thread_lock()) */
152	decl_simple_lock_data(,wake_lock)	/* for thread stop / wait (wake_lock()) */
153	boolean_t			wake_active;	/* wake event on stop */
154	int					at_safe_point;	/* thread_abort_safely allowed */
155	ast_t				reason;			/* why we blocked */
156	wait_result_t		wait_result;	/* outcome of wait -
157										 * may be examined by this thread
158										 * WITHOUT locking */
159	thread_continue_t	continuation;	/* continue here next dispatch */
160	void				*parameter;		/* continuation parameter */
161
162	/* Data updated/used in thread_invoke */
163    struct funnel_lock	*funnel_lock;		/* Non-reentrancy funnel */
164    int				    funnel_state;
165#define TH_FN_OWNED			0x1				/* we own the funnel */
166#define TH_FN_REFUNNEL		0x2				/* re-acquire funnel on dispatch */
167
168	vm_offset_t     	kernel_stack;		/* current kernel stack */
169	vm_offset_t			reserved_stack;		/* reserved kernel stack */
170
171	/* Thread state: */
172	int					state;
173/*
174 *	Thread states [bits or'ed]
175 */
176#define TH_WAIT			0x01			/* queued for waiting */
177#define TH_SUSP			0x02			/* stopped or requested to stop */
178#define TH_RUN			0x04			/* running or on runq */
179#define TH_UNINT		0x08			/* waiting uninteruptibly */
180#define	TH_TERMINATE	0x10			/* halted at termination */
181
182#define TH_IDLE			0x80			/* idling processor */
183
184	/* Scheduling information */
185	integer_t			sched_mode;			/* scheduling mode bits */
186#define TH_MODE_REALTIME		0x0001		/* time constraints supplied */
187#define TH_MODE_TIMESHARE		0x0002		/* use timesharing algorithm */
188#define TH_MODE_FAILSAFE		0x0004		/* fail-safe has tripped */
189#define	TH_MODE_PROMOTED		0x0008		/* sched pri has been promoted */
190#define TH_MODE_ABORT			0x0010		/* abort interruptible waits */
191#define TH_MODE_ABORTSAFELY		0x0020		/* ... but only those at safe point */
192#define TH_MODE_ISABORTED		(TH_MODE_ABORT | TH_MODE_ABORTSAFELY)
193#define	TH_MODE_DEPRESS			0x0040		/* normal depress yield */
194#define TH_MODE_POLLDEPRESS		0x0080		/* polled depress yield */
195#define TH_MODE_ISDEPRESSED		(TH_MODE_DEPRESS | TH_MODE_POLLDEPRESS)
196
197	integer_t			sched_pri;			/* scheduled (current) priority */
198	integer_t			priority;			/* base priority */
199	integer_t			max_priority;		/* max base priority */
200	integer_t			task_priority;		/* copy of task base priority */
201
202	integer_t			promotions;			/* level of promotion */
203	integer_t			pending_promoter_index;
204	void				*pending_promoter[2];
205
206	integer_t			importance;			/* task-relative importance */
207
208											/* real-time parameters */
209	struct {								/* see mach/thread_policy.h */
210		uint32_t			period;
211		uint32_t			computation;
212		uint32_t			constraint;
213		boolean_t			preemptible;
214
215		uint64_t			deadline;
216	}					realtime;
217
218	uint32_t			current_quantum;	/* duration of current quantum */
219
220  /* Data used during setrun/dispatch */
221	timer_data_t		system_timer;		/* system mode timer */
222	processor_t			bound_processor;	/* bound to a processor? */
223	processor_t			last_processor;		/* processor last dispatched on */
224	uint64_t			last_switch;		/* time of last context switch */
225
226	/* Fail-safe computation since last unblock or qualifying yield */
227	uint64_t			computation_metered;
228	uint64_t			computation_epoch;
229	integer_t			safe_mode;		/* saved mode during fail-safe */
230	natural_t			safe_release;	/* when to release fail-safe */
231
232	/* Call out from scheduler */
233	void				(*sched_call)(
234							int			type,
235							thread_t	thread);
236
237	/* Statistics and timesharing calculations */
238	natural_t			sched_stamp;	/* last scheduler tick */
239	natural_t			sched_usage;	/* timesharing cpu usage [sched] */
240	natural_t			pri_shift;		/* usage -> priority from pset */
241	natural_t			cpu_usage;		/* instrumented cpu usage [%cpu] */
242	natural_t			cpu_delta;		/* accumulated cpu_usage delta */
243	uint32_t			c_switch;		/* total context switches */
244	uint32_t			p_switch;		/* total processor switches */
245	uint32_t			ps_switch;		/* total pset switches */
246
247	/* Timing data structures */
248	timer_data_t		user_timer;			/* user mode timer */
249	uint64_t			user_timer_save;	/* saved user timer value */
250	uint64_t			system_timer_save;	/* saved system timer value */
251	uint64_t			vtimer_user_save;	/* saved values for vtimers */
252	uint64_t			vtimer_prof_save;
253	uint64_t			vtimer_rlim_save;
254
255	/* Timed wait expiration */
256	timer_call_data_t	wait_timer;
257	integer_t			wait_timer_active;
258	boolean_t			wait_timer_is_set;
259
260	/* Priority depression expiration */
261	timer_call_data_t	depress_timer;
262	integer_t			depress_timer_active;
263
264	/*
265	 * Processor/cache affinity
266	 * - affinity_threads links task threads with the same affinity set
267	 */
268	affinity_set_t			affinity_set;
269	queue_chain_t			affinity_threads;
270
271	/* Various bits of stashed state */
272	union {
273		struct {
274		  	mach_msg_return_t	state;		/* receive state */
275		  	ipc_object_t		object;		/* object received on */
276		  	mach_vm_address_t	msg_addr;	/* receive buffer pointer */
277			mach_msg_size_t		msize;		/* max size for recvd msg */
278		  	mach_msg_option_t	option;		/* options for receive */
279		  	mach_msg_size_t		slist_size;	/* scatter list size */
280			struct ipc_kmsg		*kmsg;		/* received message */
281			mach_port_seqno_t	seqno;		/* seqno of recvd message */
282			mach_msg_continue_t	continuation;
283		} receive;
284		struct {
285			struct semaphore	*waitsemaphore;  	/* semaphore ref */
286			struct semaphore	*signalsemaphore;	/* semaphore ref */
287			int					options;			/* semaphore options */
288			kern_return_t		result;				/* primary result */
289			mach_msg_continue_t continuation;
290		} sema;
291	  	struct {
292			int					option;		/* switch option */
293		} swtch;
294		int						misc;		/* catch-all for other state */
295	} saved;
296
297	/* IPC data structures */
298	struct ipc_kmsg_queue ith_messages;
299	mach_port_t ith_rpc_reply;			/* reply port for kernel RPCs */
300
301	/* Ast/Halt data structures */
302	vm_offset_t			recover;		/* page fault recover(copyin/out) */
303	uint32_t					ref_count;		/* number of references to me */
304
305	queue_chain_t		threads;		/* global list of all threads */
306
307	/* Activation */
308		queue_chain_t			task_threads;
309
310		/*** Machine-dependent state ***/
311		struct machine_thread	machine;
312
313		/* Task membership */
314		struct task				*task;
315		vm_map_t				map;
316
317		decl_mutex_data(,mutex)
318
319		/* Kernel holds on this thread  */
320		int						suspend_count;
321
322		/* User level suspensions */
323		int						user_stop_count;
324
325		/* Pending thread ast(s) */
326		ast_t					ast;
327
328		/* Miscellaneous bits guarded by mutex */
329		uint32_t
330			active:1,				/* Thread is active and has not been terminated */
331			started:1,				/* Thread has been started after creation */
332			static_param:1,			/* Disallow policy parameter changes */
333			:0;
334
335		/* Return Handers */
336		struct ReturnHandler {
337			struct ReturnHandler	*next;
338			void		(*handler)(
339							struct ReturnHandler		*rh,
340							struct thread				*thread);
341		} *handlers, special_handler;
342
343		/* Ports associated with this thread */
344		struct ipc_port			*ith_self;		/* not a right, doesn't hold ref */
345		struct ipc_port			*ith_sself;		/* a send right */
346		struct exception_action	exc_actions[EXC_TYPES_COUNT];
347
348		/* Owned ulocks (a lock set element) */
349		queue_head_t			held_ulocks;
350
351#ifdef	MACH_BSD
352		void					*uthread;
353#endif
354
355#if CONFIG_DTRACE
356		uint32_t t_dtrace_predcache;/* DTrace per thread predicate value hint */
357		int64_t t_dtrace_tracing;       /* Thread time under dtrace_probe() */
358		int64_t t_dtrace_vtime;
359#endif
360		uint32_t t_chud;	/* CHUD flags, used for Shark */
361};
362
363#define ith_state		saved.receive.state
364#define ith_object		saved.receive.object
365#define ith_msg_addr			saved.receive.msg_addr
366#define ith_msize		saved.receive.msize
367#define	ith_option		saved.receive.option
368#define ith_scatter_list_size	saved.receive.slist_size
369#define ith_continuation	saved.receive.continuation
370#define ith_kmsg		saved.receive.kmsg
371#define ith_seqno		saved.receive.seqno
372
373#define sth_waitsemaphore	saved.sema.waitsemaphore
374#define sth_signalsemaphore	saved.sema.signalsemaphore
375#define sth_options		saved.sema.options
376#define sth_result		saved.sema.result
377#define sth_continuation	saved.sema.continuation
378
379extern void			thread_bootstrap(void) __attribute__((section("__TEXT, initcode")));
380
381extern void			thread_init(void) __attribute__((section("__TEXT, initcode")));
382
383extern void			thread_daemon_init(void);
384
385#define	thread_reference_internal(thread)	\
386			(void)hw_atomic_add(&(thread)->ref_count, 1)
387
388#define thread_deallocate_internal(thread)	\
389			hw_atomic_sub(&(thread)->ref_count, 1)
390
391#define thread_reference(thread)					\
392MACRO_BEGIN											\
393	if ((thread) != THREAD_NULL)					\
394		thread_reference_internal(thread);		\
395MACRO_END
396
397extern void			thread_deallocate(
398						thread_t		thread);
399
400extern void			thread_terminate_self(void);
401
402extern kern_return_t	thread_terminate_internal(
403							thread_t		thread);
404
405extern void			thread_start_internal(
406							thread_t			thread) __attribute__ ((noinline));
407
408extern void			thread_terminate_enqueue(
409						thread_t		thread);
410
411extern void			thread_stack_enqueue(
412						thread_t		thread);
413
414extern void			thread_hold(
415						thread_t	thread);
416
417extern void			thread_release(
418						thread_t	thread);
419
420#define	thread_lock_init(th)	simple_lock_init(&(th)->sched_lock, 0)
421#define thread_lock(th)			simple_lock(&(th)->sched_lock)
422#define thread_unlock(th)		simple_unlock(&(th)->sched_lock)
423
424#define wake_lock_init(th)		simple_lock_init(&(th)->wake_lock, 0)
425#define wake_lock(th)			simple_lock(&(th)->wake_lock)
426#define wake_unlock(th)			simple_unlock(&(th)->wake_lock)
427
428#define thread_should_halt_fast(thread)		(!(thread)->active)
429
430extern void				stack_alloc(
431							thread_t		thread);
432
433extern void				stack_free(
434							thread_t		thread);
435
436extern void				stack_free_stack(
437							vm_offset_t		stack);
438
439extern boolean_t		stack_alloc_try(
440							thread_t	    thread);
441
442extern void				stack_collect(void);
443
444extern void				stack_init(void) __attribute__((section("__TEXT, initcode")));
445
446extern kern_return_t    thread_state_initialize(
447							thread_t				thread);
448
449extern kern_return_t	thread_setstatus(
450							thread_t				thread,
451							int						flavor,
452							thread_state_t			tstate,
453							mach_msg_type_number_t	count);
454
455extern kern_return_t	thread_getstatus(
456							thread_t				thread,
457							int						flavor,
458							thread_state_t			tstate,
459							mach_msg_type_number_t	*count);
460
461extern kern_return_t	thread_info_internal(
462							thread_t				thread,
463							thread_flavor_t			flavor,
464							thread_info_t			thread_info_out,
465							mach_msg_type_number_t	*thread_info_count);
466
467extern void				thread_task_priority(
468							thread_t		thread,
469							integer_t		priority,
470							integer_t		max_priority);
471
472extern void				thread_policy_reset(
473							thread_t		thread);
474
475extern kern_return_t	kernel_thread_create(
476							thread_continue_t	continuation,
477							void				*parameter,
478							integer_t			priority,
479							thread_t			*new_thread);
480
481extern kern_return_t	kernel_thread_start_priority(
482							thread_continue_t	continuation,
483							void				*parameter,
484							integer_t			priority,
485							thread_t			*new_thread);
486
487extern void				machine_stack_attach(
488							thread_t		thread,
489							vm_offset_t		stack);
490
491extern vm_offset_t		machine_stack_detach(
492							thread_t		thread);
493
494extern void				machine_stack_handoff(
495							thread_t		old,
496							thread_t		new);
497
498extern thread_t			machine_switch_context(
499							thread_t			old_thread,
500							thread_continue_t	continuation,
501							thread_t			new_thread);
502
503extern void				machine_load_context(
504							thread_t		thread);
505
506extern kern_return_t	machine_thread_state_initialize(
507							thread_t				thread);
508
509extern kern_return_t	machine_thread_set_state(
510							thread_t				thread,
511							thread_flavor_t			flavor,
512							thread_state_t			state,
513							mach_msg_type_number_t	count);
514
515extern kern_return_t	machine_thread_get_state(
516							thread_t				thread,
517							thread_flavor_t			flavor,
518							thread_state_t			state,
519							mach_msg_type_number_t	*count);
520
521extern kern_return_t	machine_thread_dup(
522							thread_t		self,
523							thread_t		target);
524
525extern void				machine_thread_init(void);
526
527extern kern_return_t	machine_thread_create(
528							thread_t		thread,
529							task_t			task);
530extern void		machine_thread_switch_addrmode(
531						       thread_t			thread);
532
533extern void 		    machine_thread_destroy(
534							thread_t		thread);
535
536extern void				machine_set_current_thread(
537							thread_t			thread);
538
539extern void			machine_thread_terminate_self(void);
540
541extern kern_return_t	machine_thread_get_kern_state(
542							thread_t				thread,
543							thread_flavor_t			flavor,
544							thread_state_t			tstate,
545							mach_msg_type_number_t	*count);
546
547
548/*
549 * XXX Funnel locks XXX
550 */
551
552struct funnel_lock {
553	int			fnl_type;			/* funnel type */
554	lck_mtx_t	*fnl_mutex;			/* underlying mutex for the funnel */
555	void *		fnl_mtxholder;		/* thread (last)holdng mutex */
556	void *		fnl_mtxrelease;		/* thread (last)releasing mutex */
557	lck_mtx_t	*fnl_oldmutex;		/* Mutex before collapsing split funnel */
558};
559
560typedef struct ReturnHandler		ReturnHandler;
561
562#define	thread_mtx_lock(thread)			mutex_lock(&(thread)->mutex)
563#define	thread_mtx_try(thread)			mutex_try(&(thread)->mutex)
564#define	thread_mtx_unlock(thread)		mutex_unlock(&(thread)->mutex)
565
566extern void			act_execute_returnhandlers(void);
567
568extern void			install_special_handler(
569						thread_t		thread);
570
571extern void			special_handler(
572						ReturnHandler	*rh,
573						thread_t		thread);
574
575void act_machine_sv_free(thread_t, int);
576
577#else	/* MACH_KERNEL_PRIVATE */
578
579__BEGIN_DECLS
580
581extern thread_t		current_thread(void);
582
583extern void			thread_reference(
584						thread_t	thread);
585
586extern void			thread_deallocate(
587						thread_t	thread);
588
589__END_DECLS
590
591#endif	/* MACH_KERNEL_PRIVATE */
592
593#ifdef	KERNEL_PRIVATE
594
595typedef struct funnel_lock		funnel_t;
596
597#ifdef	MACH_KERNEL_PRIVATE
598
599extern void 		funnel_lock(
600						funnel_t	*lock);
601
602extern void 		funnel_unlock(
603						funnel_t	*lock);
604
605vm_offset_t			min_valid_stack_address(void);
606vm_offset_t			max_valid_stack_address(void);
607
608#endif	/* MACH_KERNEL_PRIVATE */
609
610__BEGIN_DECLS
611
612extern funnel_t		*thread_funnel_get(void);
613
614extern boolean_t	thread_funnel_set(
615						funnel_t	*lock,
616						boolean_t	 funneled);
617
618extern thread_t		kernel_thread(
619						task_t		task,
620						void		(*start)(void));
621
622__END_DECLS
623
624#endif	/* KERNEL_PRIVATE */
625
626__BEGIN_DECLS
627
628#ifdef	XNU_KERNEL_PRIVATE
629
630extern	void	thread_yield_internal(
631	mach_msg_timeout_t	interval);
632
633/*
634 * XXX Funnel locks XXX
635 */
636
637#define THR_FUNNEL_NULL (funnel_t *)0
638
639extern funnel_t		 *funnel_alloc(
640						int			type);
641
642extern void			funnel_free(
643						funnel_t	*lock);
644
645extern void			thread_read_times(
646						thread_t 		thread,
647						time_value_t	*user_time,
648						time_value_t	*system_time);
649
650extern void			thread_setuserstack(
651						thread_t		thread,
652						mach_vm_offset_t	user_stack);
653
654extern uint64_t		thread_adjuserstack(
655						thread_t		thread,
656						int				adjust);
657
658extern void			thread_setentrypoint(
659						thread_t		thread,
660						mach_vm_offset_t	entry);
661
662extern kern_return_t	thread_setsinglestep(
663						thread_t		thread,
664						int			on);
665
666extern kern_return_t	thread_wire_internal(
667							host_priv_t		host_priv,
668							thread_t		thread,
669							boolean_t		wired,
670							boolean_t		*prev_state);
671
672extern kern_return_t	thread_dup(thread_t);
673
674typedef void	(*sched_call_t)(
675					int				type,
676					thread_t		thread);
677
678#define SCHED_CALL_BLOCK		0x1
679#define SCHED_CALL_UNBLOCK		0x2
680
681extern void		thread_sched_call(
682					thread_t		thread,
683					sched_call_t	call);
684
685extern void		thread_static_param(
686					thread_t		thread,
687					boolean_t		state);
688
689extern task_t	get_threadtask(thread_t);
690#define thread_is_64bit(thd)	\
691	task_has_64BitAddr(get_threadtask(thd))
692
693
694extern void		*get_bsdthread_info(thread_t);
695extern void		set_bsdthread_info(thread_t, void *);
696extern void		*uthread_alloc(task_t, thread_t);
697extern void		uthread_cleanup(task_t, void *, void *);
698extern void		uthread_zone_free(void *);
699extern void		uthread_cred_free(void *);
700
701extern boolean_t	thread_should_halt(
702						thread_t		thread);
703
704extern int is_64signalregset(void);
705
706void act_set_apc(thread_t);
707
708extern uint32_t dtrace_get_thread_predcache(thread_t);
709extern int64_t dtrace_get_thread_vtime(thread_t);
710extern int64_t dtrace_get_thread_tracing(thread_t);
711extern boolean_t dtrace_get_thread_reentering(thread_t);
712extern vm_offset_t dtrace_get_kernel_stack(thread_t);
713extern void dtrace_set_thread_predcache(thread_t, uint32_t);
714extern void dtrace_set_thread_vtime(thread_t, int64_t);
715extern void dtrace_set_thread_tracing(thread_t, int64_t);
716extern void dtrace_set_thread_reentering(thread_t, boolean_t);
717extern vm_offset_t dtrace_set_thread_recover(thread_t, vm_offset_t);
718
719extern int64_t dtrace_calc_thread_recent_vtime(thread_t);
720
721
722extern void		thread_set_wq_state32(
723					      thread_t          thread,
724					      thread_state_t    tstate);
725
726extern void		thread_set_wq_state64(
727					      thread_t          thread,
728					      thread_state_t    tstate);
729
730#endif	/* XNU_KERNEL_PRIVATE */
731
732extern kern_return_t	kernel_thread_start(
733							thread_continue_t	continuation,
734							void				*parameter,
735							thread_t			*new_thread);
736
737__END_DECLS
738
739#endif	/* _KERN_THREAD_H_ */
740