[apple/xnu.git] / osfmk / mach / task.defs

/*
 * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_FREE_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990,1989 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */
/*
 */
/*
 *	File:	mach/mach_port.defs
 *	Author:	Rich Draves
 *
 *	Exported kernel calls.
 */

subsystem
#if	KERNEL_SERVER
	  KernelServer
#endif	/* KERNEL_SERVER */
	  task 3400;

#include <mach/std_types.defs>
#include <mach/mach_types.defs>
#include <mach_debug/mach_debug_types.defs>

/*
 *	Create a new task with an empty set of IPC rights,
 *	and having an address space constructed from the
 *	target task (or empty, if inherit_memory is FALSE).
 */
routine task_create(
		target_task	: task_t;
		ledgers		: ledger_array_t;
		inherit_memory	: boolean_t;
	out	child_task	: task_t);

/*
 *	Destroy the target task, causing all of its threads
 *	to be destroyed, all of its IPC rights to be deallocated,
 *	and all of its address space to be deallocated.
 */
routine task_terminate(
		target_task	: task_t);

/*
 *	Returns the set of threads belonging to the target task.
 */
routine task_threads(
		target_task	: task_t;
	out	act_list	: thread_act_array_t);

/*
 *	Stash a handful of ports for the target task; child
 *	tasks inherit this stash at task_create time.
 */
routine	mach_ports_register(
		target_task	: task_t;
		init_port_set	: mach_port_array_t =
					^array[] of mach_port_t);

/*
 *	Retrieve the stashed ports for the target task.
 */
routine	mach_ports_lookup(
		target_task	: task_t;
	out	init_port_set	: mach_port_array_t =
					^array[] of mach_port_t);

/*
 *      Returns information about the target task.
 */
routine task_info(
                target_task     : task_name_t;
                flavor          : task_flavor_t;
        out     task_info_out   : task_info_t, CountInOut);

/*
 * Set task information.
 */
routine	task_set_info(
		target_task	: task_t;
		flavor		: task_flavor_t;
		task_info_in	: task_info_t);

/*
 *	Increment the suspend count for the target task.
 *	No threads within a task may run when the suspend
 *	count for that task is non-zero.
 */
routine	task_suspend(
		target_task	: task_t);


/*
 *	Decrement the suspend count for the target task,
 *	if the count is currently non-zero.  If the resulting
 *	suspend	count is zero, then threads within the task
 *	that also have non-zero suspend counts may execute.
 */
routine	task_resume(
		target_task	: task_t);

/*
 *	Returns the current value of the selected special port
 *	associated with the target task.
 */
routine task_get_special_port(
		task		: task_t;
		which_port	: int;
	out	special_port	: mach_port_t);

/*
 *	Set one of the special ports associated with the
 *	target task.
 */
routine task_set_special_port(
		task		: task_t;
		which_port	: int;
		special_port	: mach_port_t);

/*
 *	Create a new thread within the target task, returning
 *	the port representing the first thr_act in that new thread.  The
 *	initial execution state of the thread is undefined.
 */
routine
#ifdef KERNEL_SERVER
thread_create_from_user(
#else
thread_create(
#endif
		parent_task	: task_t;
	out	child_act	: thread_act_t);

/*
 *      Create a new thread within the target task, returning
 *      the port representing that new thread.  The new thread 
 *	is not suspended; its initial execution state is given
 *	by flavor and new_state. Returns the port representing 
 *	the new thread.
 */
routine
#ifdef KERNEL_SERVER
thread_create_running_from_user(
#else
thread_create_running(
#endif
                parent_task     : task_t;
                flavor          : thread_state_flavor_t;
                new_state       : thread_state_t;
        out     child_act       : thread_act_t);

/*
 * Set an exception handler for a task on one or more exception types.
 * These handlers are invoked for all threads in the task if there are
 * no thread-specific exception handlers or those handlers returned an
 * error.
 */
routine	task_set_exception_ports(
		task		: task_t;
		exception_mask	: exception_mask_t;
		new_port	: mach_port_t;
		behavior	: exception_behavior_t;
		new_flavor	: thread_state_flavor_t);


/*
 * Lookup some of the old exception handlers for a task
 */
routine	task_get_exception_ports(
		task		: task_t;
		exception_mask	: exception_mask_t;
	  out	masks		: exception_mask_array_t;
	  out	old_handlers	: exception_handler_array_t, SameCount;
	  out	old_behaviors	: exception_behavior_array_t, SameCount;
	  out	old_flavors	: exception_flavor_array_t, SameCount);


/*
 * Set an exception handler for a thread on one or more exception types.
 * At the same time, return the previously defined exception handlers for
 * those types.
 */
routine	task_swap_exception_ports(
		task		: task_t;
		exception_mask	: exception_mask_t;
		new_port	: mach_port_t;
		behavior	: exception_behavior_t;
		new_flavor	: thread_state_flavor_t;
	  out	masks		: exception_mask_array_t;
	  out	old_handlerss	: exception_handler_array_t, SameCount;
	  out	old_behaviors	: exception_behavior_array_t, SameCount;
	  out	old_flavors	: exception_flavor_array_t, SameCount);

/*
 * Create and destroy lock_set and semaphore synchronizers on a
 * per-task basis (i.e. the task owns them).
 */
routine lock_set_create(
		task		: task_t;
	out	new_lock_set	: lock_set_t;
		n_ulocks	: int;
		policy		: int);

routine lock_set_destroy(
		task		: task_t;
		lock_set	: lock_set_t);

routine semaphore_create(
		task		: task_t;
	out	semaphore	: semaphore_t;
		policy		: int;
		value		: int);

routine semaphore_destroy(
		task		: task_t;
		semaphore	: semaphore_consume_ref_t);

/*
 * Set/get policy information for a task.
 * (Approved Mac OS X microkernel interface)
 */

routine task_policy_set(
	task			: task_t;
	flavor			: task_policy_flavor_t;
	policy_info		: task_policy_t);

routine task_policy_get(
	task			: task_t;
	flavor			: task_policy_flavor_t;
out	policy_info		: task_policy_t, CountInOut;
inout	get_default		: boolean_t);

/*
 *	Removed from the kernel.
 */
#if KERNEL_SERVER
skip;
#else
routine task_sample(
		task		: task_t;
		reply		: mach_port_make_send_t);
#endif

/*
 * JMM - Everything from here down is likely to go away soon
 */
/*
 * OBSOLETE interface.
 */
routine task_policy(
	task			: task_t;
	policy			: policy_t;
	base			: policy_base_t;
	set_limit		: boolean_t;
	change			: boolean_t);


/*
 *	Establish a user-level handler for the specified
 *	system call.
 */
routine task_set_emulation(
		target_port	: task_t;
		routine_entry_pt: vm_address_t;
		routine_number  : int);	

/*
 *	Get user-level handler entry points for all
 *	emulated system calls.
 */
routine task_get_emulation_vector(
		task		: task_t;
	out	vector_start	: int;
	out	emulation_vector: emulation_vector_t);

/*
 *	Establish user-level handlers for the specified
 *	system calls. Non-emulated system calls are specified
 *	with emulation_vector[i] == EML_ROUTINE_NULL.
 */
routine task_set_emulation_vector(
		task		: task_t;
		vector_start	: int;
		emulation_vector: emulation_vector_t);


/*
 *      Establish restart pc for interrupted atomic sequences.
 */
routine task_set_ras_pc(
		target_task     : task_t;
		basepc          : vm_address_t;
		boundspc        : vm_address_t);


/*
 * Return zone info as seen/used by this task.
 */
routine task_zone_info(
		target_task	: task_t;
	out	names		: mach_zone_name_array_t,
					Dealloc;
	out	info		: task_zone_info_array_t,
					Dealloc);


/* 
 * JMM - Want to eliminate processor_set so keep them at the end.
 */

/*
 *	Assign task to processor set.
 */
routine task_assign(
		task		: task_t;
		new_set		: processor_set_t;
		assign_threads	: boolean_t);

/*
 *	Assign task to default set.
 */
routine task_assign_default(
		task		: task_t;
		assign_threads	: boolean_t);

/*
 *	Get current assignment for task.
 */
routine task_get_assignment(
		task		: task_t;
	out	assigned_set	: processor_set_name_t);

/*
 * OBSOLETE interface.
 */
routine task_set_policy(
	task			: task_t;
	pset			: processor_set_t;
	policy			: policy_t;
	base			: policy_base_t;
	limit			: policy_limit_t;
	change			: boolean_t);

/*
 * Read the selected state which is to be installed on new 
 * threads in the task as they are created.
 */
routine task_get_state(
		task		: task_t;
		flavor		: thread_state_flavor_t;
	out	old_state	: thread_state_t, CountInOut);
 
/*
 * Set the selected state information to be installed on
 * all subsequently created threads in the task.
 */
routine	task_set_state(
		task		: task_t;
		flavor		: thread_state_flavor_t;
		new_state	: thread_state_t);

/* vim: set ft=c : */
Commit	Line	Data
1c79356b	1	/*
2d21ac55	2	* Copyright (c) 2000-2007 Apple Inc. All rights reserved.
1c79356b	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	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.
8f6c56a5	14	*
2d21ac55 A	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
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	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.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* @OSF_FREE_COPYRIGHT@
	30	*/
	31	/*
	32	* Mach Operating System
	33	* Copyright (c) 1991,1990,1989 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: mach/mach_port.defs
	60	* Author: Rich Draves
	61	*
	62	* Exported kernel calls.
	63	*/
	64
	65	subsystem
	66	#if KERNEL_SERVER
	67	KernelServer
55e303ae	68	#endif /* KERNEL_SERVER */
1c79356b A	69	task 3400;
	70
	71	#include <mach/std_types.defs>
	72	#include <mach/mach_types.defs>
6d2010ae A	73	#include <mach_debug/mach_debug_types.defs>
6d2010ae A	74
1c79356b A	75	/*
	76	* Create a new task with an empty set of IPC rights,
	77	* and having an address space constructed from the
	78	* target task (or empty, if inherit_memory is FALSE).
	79	*/
	80	routine task_create(
	81	target_task : task_t;
	82	ledgers : ledger_array_t;
	83	inherit_memory : boolean_t;
	84	out child_task : task_t);
	85
	86	/*
	87	* Destroy the target task, causing all of its threads
	88	* to be destroyed, all of its IPC rights to be deallocated,
	89	* and all of its address space to be deallocated.
	90	*/
	91	routine task_terminate(
	92	target_task : task_t);
	93
	94	/*
	95	* Returns the set of threads belonging to the target task.
	96	*/
	97	routine task_threads(
	98	target_task : task_t;
	99	out act_list : thread_act_array_t);
	100
	101	/*
	102	* Stash a handful of ports for the target task; child
	103	* tasks inherit this stash at task_create time.
	104	*/
	105	routine mach_ports_register(
	106	target_task : task_t;
	107	init_port_set : mach_port_array_t =
	108	^array[] of mach_port_t);
	109
	110	/*
	111	* Retrieve the stashed ports for the target task.
	112	*/
	113	routine mach_ports_lookup(
	114	target_task : task_t;
	115	out init_port_set : mach_port_array_t =
	116	^array[] of mach_port_t);
	117
	118	/*
	119	* Returns information about the target task.
	120	*/
	121	routine task_info(
0c530ab8	122	target_task : task_name_t;
1c79356b A	123	flavor : task_flavor_t;
	124	out task_info_out : task_info_t, CountInOut);
	125
	126	/*
	127	* Set task information.
	128	*/
	129	routine task_set_info(
	130	target_task : task_t;
	131	flavor : task_flavor_t;
	132	task_info_in : task_info_t);
	133
	134	/*
	135	* Increment the suspend count for the target task.
	136	* No threads within a task may run when the suspend
	137	* count for that task is non-zero.
	138	*/
	139	routine task_suspend(
	140	target_task : task_t);
	141
	142
	143	/*
	144	* Decrement the suspend count for the target task,
	145	* if the count is currently non-zero. If the resulting
	146	* suspend count is zero, then threads within the task
	147	* that also have non-zero suspend counts may execute.
	148	*/
	149	routine task_resume(
	150	target_task : task_t);
	151
	152	/*
	153	* Returns the current value of the selected special port
	154	* associated with the target task.
	155	*/
	156	routine task_get_special_port(
	157	task : task_t;
	158	which_port : int;
	159	out special_port : mach_port_t);
	160
	161	/*
	162	* Set one of the special ports associated with the
	163	* target task.
	164	*/
	165	routine task_set_special_port(
	166	task : task_t;
	167	which_port : int;
	168	special_port : mach_port_t);
	169
	170	/*
	171	* Create a new thread within the target task, returning
	172	* the port representing the first thr_act in that new thread. The
	173	* initial execution state of the thread is undefined.
	174	*/
6d2010ae A	175	routine
	176	#ifdef KERNEL_SERVER
	177	thread_create_from_user(
	178	#else
	179	thread_create(
	180	#endif
1c79356b A	181	parent_task : task_t;
	182	out child_act : thread_act_t);
	183
	184	/*
	185	* Create a new thread within the target task, returning
	186	* the port representing that new thread. The new thread
	187	* is not suspended; its initial execution state is given
	188	* by flavor and new_state. Returns the port representing
	189	* the new thread.
	190	*/
6d2010ae A	191	routine
	192	#ifdef KERNEL_SERVER
	193	thread_create_running_from_user(
	194	#else
	195	thread_create_running(
	196	#endif
1c79356b A	197	parent_task : task_t;
	198	flavor : thread_state_flavor_t;
	199	new_state : thread_state_t;
	200	out child_act : thread_act_t);
	201
	202	/*
	203	* Set an exception handler for a task on one or more exception types.
	204	* These handlers are invoked for all threads in the task if there are
	205	* no thread-specific exception handlers or those handlers returned an
	206	* error.
	207	*/
	208	routine task_set_exception_ports(
	209	task : task_t;
	210	exception_mask : exception_mask_t;
	211	new_port : mach_port_t;
	212	behavior : exception_behavior_t;
	213	new_flavor : thread_state_flavor_t);
	214
	215
	216	/*
	217	* Lookup some of the old exception handlers for a task
	218	*/
	219	routine task_get_exception_ports(
	220	task : task_t;
	221	exception_mask : exception_mask_t;
	222	out masks : exception_mask_array_t;
	223	out old_handlers : exception_handler_array_t, SameCount;
	224	out old_behaviors : exception_behavior_array_t, SameCount;
	225	out old_flavors : exception_flavor_array_t, SameCount);
	226
	227
	228	/*
	229	* Set an exception handler for a thread on one or more exception types.
	230	* At the same time, return the previously defined exception handlers for
	231	* those types.
	232	*/
	233	routine task_swap_exception_ports(
	234	task : task_t;
	235	exception_mask : exception_mask_t;
	236	new_port : mach_port_t;
	237	behavior : exception_behavior_t;
	238	new_flavor : thread_state_flavor_t;
	239	out masks : exception_mask_array_t;
	240	out old_handlerss : exception_handler_array_t, SameCount;
	241	out old_behaviors : exception_behavior_array_t, SameCount;
	242	out old_flavors : exception_flavor_array_t, SameCount);
	243
	244	/*
	245	* Create and destroy lock_set and semaphore synchronizers on a
	246	* per-task basis (i.e. the task owns them).
	247	*/
	248	routine lock_set_create(
	249	task : task_t;
	250	out new_lock_set : lock_set_t;
	251	n_ulocks : int;
	252	policy : int);
	253
	254	routine lock_set_destroy(
	255	task : task_t;
	256	lock_set : lock_set_t);
	257
	258	routine semaphore_create(
	259	task : task_t;
	260	out semaphore : semaphore_t;
261	policy : int;
262	value : int);
263
264	routine semaphore_destroy(
265	task : task_t;
266	semaphore : semaphore_consume_ref_t);
267
268	/*
269	* Set/get policy information for a task.
270	* (Approved Mac OS X microkernel interface)
271	*/
272
273	routine task_policy_set(
274	task : task_t;
275	flavor : task_policy_flavor_t;
276	policy_info : task_policy_t);
277
278	routine task_policy_get(
279	task : task_t;
280	flavor : task_policy_flavor_t;
281	out policy_info : task_policy_t, CountInOut;
282	inout get_default : boolean_t);
283
284	/*
2d21ac55	285	* Removed from the kernel.
1c79356b	286	*/
2d21ac55 A	287	#if KERNEL_SERVER
	288	skip;
	289	#else
1c79356b A	290	routine task_sample(
	291	task : task_t;
	292	reply : mach_port_make_send_t);
2d21ac55	293	#endif
1c79356b A	294
	295	/*
	296	* JMM - Everything from here down is likely to go away soon
	297	*/
	298	/*
	299	* OBSOLETE interface.
	300	*/
	301	routine task_policy(
	302	task : task_t;
	303	policy : policy_t;
	304	base : policy_base_t;
	305	set_limit : boolean_t;
	306	change : boolean_t);
	307
	308
	309	/*
	310	* Establish a user-level handler for the specified
	311	* system call.
	312	*/
	313	routine task_set_emulation(
	314	target_port : task_t;
	315	routine_entry_pt: vm_address_t;
	316	routine_number : int);
	317
	318	/*
	319	* Get user-level handler entry points for all
	320	* emulated system calls.
	321	*/
	322	routine task_get_emulation_vector(
	323	task : task_t;
	324	out vector_start : int;
	325	out emulation_vector: emulation_vector_t);
	326
	327	/*
	328	* Establish user-level handlers for the specified
	329	* system calls. Non-emulated system calls are specified
	330	* with emulation_vector[i] == EML_ROUTINE_NULL.
	331	*/
	332	routine task_set_emulation_vector(
	333	task : task_t;
	334	vector_start : int;
	335	emulation_vector: emulation_vector_t);
	336
	337
	338	/*
	339	* Establish restart pc for interrupted atomic sequences.
	340	*/
	341	routine task_set_ras_pc(
	342	target_task : task_t;
	343	basepc : vm_address_t;
	344	boundspc : vm_address_t);
	345
	346
6d2010ae A	347	/*
	348	* Return zone info as seen/used by this task.
	349	*/
	350	routine task_zone_info(
	351	target_task : task_t;
	352	out names : mach_zone_name_array_t,
	353	Dealloc;
	354	out info : task_zone_info_array_t,
	355	Dealloc);
	356
91447636	357
1c79356b	358	/*
91447636	359	* JMM - Want to eliminate processor_set so keep them at the end.
1c79356b	360	*/
1c79356b A	361
	362	/*
	363	* Assign task to processor set.
	364	*/
	365	routine task_assign(
	366	task : task_t;
	367	new_set : processor_set_t;
	368	assign_threads : boolean_t);
	369
	370	/*
	371	* Assign task to default set.
	372	*/
	373	routine task_assign_default(
	374	task : task_t;
	375	assign_threads : boolean_t);
	376
	377	/*
	378	* Get current assignment for task.
	379	*/
	380	routine task_get_assignment(
	381	task : task_t;
	382	out assigned_set : processor_set_name_t);
	383
	384	/*
	385	* OBSOLETE interface.
	386	*/
	387	routine task_set_policy(
	388	task : task_t;
	389	pset : processor_set_t;
	390	policy : policy_t;
	391	base : policy_base_t;
	392	limit : policy_limit_t;
	393	change : boolean_t);
	394
b0d623f7 A	395	/*
	396	* Read the selected state which is to be installed on new
	397	* threads in the task as they are created.
	398	*/
	399	routine task_get_state(
	400	task : task_t;
	401	flavor : thread_state_flavor_t;
	402	out old_state : thread_state_t, CountInOut);
	403
	404	/*
	405	* Set the selected state information to be installed on
	406	* all subsequently created threads in the task.
	407	*/
	408	routine task_set_state(
	409	task : task_t;
	410	flavor : thread_state_flavor_t;
	411	new_state : thread_state_t);
	412
2d21ac55	413	/* vim: set ft=c : */