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

/*
 * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This 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 OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990,1989,1988 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.
 */
/*
 */
/*
 *	Mach kernel interface type declarations
 */

#ifndef	_MACH_MACH_TYPES_DEFS_
#define _MACH_MACH_TYPES_DEFS_


#include <mach/std_types.defs>

type upl_page_info_t		= struct[2] of integer_t;
type upl_page_info_array_t	= array[*:20] of upl_page_info_t;

type memory_object_offset_t 	= uint64_t;
type memory_object_size_t 	= uint64_t;


type mach_port_status_t = struct[10] of integer_t;	/* obsolete */

		/* mach_port_info_t: can hold either a
		 * mach_port_status_t (9 ints) or a
		 * mach_port_limits_t (1 int). If new flavors of
		 * mach_port_{get,set}_attributes are added, the size of
		 * this array may have to be increased. (See mach/port.h)
		 */
type mach_port_flavor_t 	= int;
type mach_port_info_t		= array[*:10] of integer_t;

type task_t = mach_port_t
#if	KERNEL_SERVER
		intran: task_t convert_port_to_task(mach_port_t)
		outtran: mach_port_t convert_task_to_port(task_t)
		destructor: task_deallocate(task_t)
#endif	/* KERNEL_SERVER */
		;

type thread_t = mach_port_t
#if	KERNEL_SERVER
		intran: thread_t convert_port_to_thread(mach_port_t)
		outtran: mach_port_t convert_thread_to_port(thread_t)
		destructor: thread_deallocate(thread_t)
#endif	/* KERNEL_SERVER */
		;

type thread_act_t = mach_port_t
#if	KERNEL_SERVER
		intran: thread_act_t convert_port_to_act(mach_port_t)
		outtran: mach_port_t convert_act_to_port(thread_act_t)
		destructor: act_deallocate(thread_act_t)
#endif	/* KERNEL_SERVER */
		;

type thread_act_consume_ref_t = mach_port_move_send_t
		ctype: thread_act_t
#if	KERNEL_SERVER
		intran: thread_act_t convert_port_to_act(mach_port_t)
		destructor: act_deallocate(thread_act_t)
#endif	/* KERNEL_SERVER */
		;

		/* thread_state_t: This inline array can hold
		 * a machine-dependent amount of data, defined in
		 * mach/machine/???? (currently THREAD_STATE_MAX,
		 * in mach/thread_state.h)
		 */
#include <mach/machine/thread_state.h>
type thread_state_flavor_t	= int;
type thread_state_t		= array[*:THREAD_STATE_MAX] of natural_t;

type task_array_t = ^array[] of task_t;
type thread_array_t = ^array[] of thread_t;
type thread_act_array_t = ^array[] of thread_act_t;
type act_params_t = array[6] of int;

type vm_map_t = mach_port_t
#if	KERNEL_SERVER
		intran: vm_map_t convert_port_to_map(mach_port_t)
		destructor: vm_map_deallocate(vm_map_t)
#endif	/* KERNEL_SERVER */
		;

type vm_task_entry_t = mach_port_t
		ctype: vm_map_t
#if	KERNEL_SERVER
		intran: vm_map_t convert_port_entry_to_map(mach_port_t)
		destructor: vm_map_deallocate(vm_map_t)
#endif	/* KERNEL_SERVER */
		;

type ipc_space_t = mach_port_t
#if	KERNEL_SERVER
		intran: ipc_space_t convert_port_to_space(mach_port_t)
		destructor: space_deallocate(ipc_space_t)
#endif	/* KERNEL_SERVER */
		;

type vm_address_t = natural_t;
type vm_offset_t = natural_t;
type vm_size_t = natural_t;
type vm_prot_t = int;
type vm_inherit_t = int;
type xxx_vm_statistics_data_t = struct[13] of integer_t;
type vm_behavior_t = int;
type vm_statistics_data_t = struct[12] of integer_t;
type vm_machine_attribute_t = int;
type vm_machine_attribute_val_t = int;
type vm_sync_t = int;

		/* thread_info_t: this inline array can hold any of:
		 * thread_basic_info_t (10 ints)
		 * policy_timeshare_info_t (5 ints)
		 * policy_fifo_info_t (4 ints)
		 * policy_rr_info_t (5 ints)
		 * if other thread_info flavors are added, this
		 * definition may need to be changed. (See
		 * mach/thread_info.h and mach/policy.h) */
type thread_flavor_t		= int;
type thread_info_t		= array[*:12] of integer_t;

type thread_policy_flavor_t	= natural_t;
type thread_policy_t		= array[*:16] of integer_t;

		/* task_info_t: this inline array can hold any of:
		 * task_basic_info_t (8 ints)
		 * task_events_info_t (8 ints)
		 * task_thread_times_info_t (4 ints)
		 * policy_timeshare_info_t (5 ints)
		 * policy_fifo_info_t (4 ints)
		 * policy_rr_info_t (5 ints)
		 * task security token (2 ints)
		 * task audit token (8 ints)
		 * If other task_info flavors are added, this
		 * definition may need to be changed. (See
		 * mach/task_info.h and mach/policy.h) */
type task_flavor_t		= int;
type task_info_t		= array[*:8] of integer_t;

type task_policy_flavor_t	= natural_t;
type task_policy_t		= array[*:16] of integer_t;

type mem_entry_name_port_t = mach_port_t
#if     KERNEL_SERVER
		intran: mem_entry_name_port_t null_conversion(mach_port_t)
#endif  /* KERNEL_SERVER */
		;

type memory_object_default_t = mach_port_t
#if	KERNEL_PRIVATE
		intran: memory_object_default_t null_conversion(mach_port_t)
		outtran: mach_port_t null_conversion(memory_object_default_t)
#endif	/* KERNEL_PRIVATE */
		;
 
type memory_object_t = mach_port_t
#if	KERNEL_PRIVATE
		intran: memory_object_t convert_port_to_memory_object(mach_port_t)
		outtran: mach_port_t convert_memory_object_to_port(memory_object_t)
#endif	/* KERNEL_PRIVATE */
		;


type memory_object_control_t = mach_port_t
#if	KERNEL_PRIVATE
		intran: memory_object_control_t convert_port_to_mo_control(mach_port_t)
		outtran: mach_port_t convert_mo_control_to_port(memory_object_control_t)
		destructor: memory_object_control_deallocate(memory_object_control_t)
#endif	/* KERNEL_PRIVATE */
		;

type memory_object_name_t = mach_port_t
		ctype: mach_port_t
		;

type upl_t = mach_port_t
#if	KERNEL_PRIVATE
		intran: upl_t convert_port_to_upl(mach_port_t)
		outtran: mach_port_t convert_upl_to_port(upl_t)
		destructor: upl_deallocate(upl_t)
#endif	/* KERNEL_PRIVATE */
		;


type memory_object_copy_strategy_t = int;
type memory_object_return_t = int;

type machine_info_data_t = struct[5] of integer_t;
type machine_slot_data_t = struct[8] of integer_t;

type host_t = mach_port_t
#if	KERNEL_SERVER
		intran: host_t convert_port_to_host(mach_port_t)
		outtran: mach_port_t convert_host_to_port(host_t)
#endif	/* KERNEL_SERVER */
		;

type host_priv_t = mach_port_t
#if	KERNEL_SERVER
		intran: host_priv_t convert_port_to_host_priv(mach_port_t)
#endif	/* KERNEL_SERVER */
		;

type host_security_t = mach_port_t
#if	KERNEL_SERVER
		intran: host_security_t convert_port_to_host_security(mach_port_t)
#endif	/* KERNEL_SERVER */
		;

		/* host_info_t: variable-sized inline array that can contain:
		 * host_basic_info_t (5 ints)
		 * host_sched_info_t (2 ints)
		 * kernel_resource_sizes_t (5 ints)
		 * host_load_info_t (6 ints)
		 * vm_statistics_t (12 ints)
		 * If other host_info flavors are added, this definition may
		 * need to be changed. (See mach/{host_info,vm_statistics}.h)
		 */
type host_flavor_t		= int;
type host_info_t 		= array[*:12] of integer_t;

type processor_t = mach_port_t
#if	KERNEL_SERVER
		intran: processor_t convert_port_to_processor(mach_port_t)
		outtran: mach_port_t convert_processor_to_port(processor_t)
#endif	/* KERNEL_SERVER */
		;

type processor_array_t 	= ^array[] of processor_t;

		/* processor_info_t: variable-sized inline array that can
		 * contain:
		 * processor_basic_info_t:   (5 ints)
		 * processor_cpu_load_info_t:(4 ints)
		 * processor_machine_info_t :(12 ints)
		 * If other processor_info flavors are added, this definition
		 * may need to be changed. (See mach/processor_info.h) */
type processor_flavor_t		= int;
type processor_info_t		= array[*:12] of integer_t;
type processor_info_array_t	= ^array[] of integer_t;

type processor_set_t = mach_port_t
#if	KERNEL_SERVER
		intran: processor_set_t convert_port_to_pset(mach_port_t)
		outtran: mach_port_t convert_pset_to_port(processor_set_t)
		destructor: pset_deallocate(processor_set_t)
#endif	/* KERNEL_SERVER */
		;

type processor_set_array_t = ^array[] of processor_set_t;

type processor_set_name_t = mach_port_t
#if	KERNEL_SERVER
		intran: processor_set_name_t convert_port_to_pset_name(mach_port_t)
		outtran: mach_port_t convert_pset_name_to_port(processor_set_name_t)
		destructor: pset_deallocate(processor_set_name_t)
#endif	/* KERNEL_SERVER */
		;

type processor_set_name_array_t = ^array[] of processor_set_name_t;

		/* processor_set_info_t: variable-size inline array
		 * that can hold:
		 * processor_set_basic_info (5 ints)
		 * processor_set_load_info (4 ints)
		 * policy_timeshare_base_t (1 int)
		 * policy_fifo_base_t (1 int)
		 * policy_rr_base_t (1 int)
		 * policy_timeshare_base_t (1 int)
		 * policy_fifo_base_t (1 int)
		 * policy_rr_base_t (1 int)
		 * policy_t (1 int)
		 * If other flavors are added, this definition may
		 * need to be changed. (see mach/processor.h) */
type processor_set_flavor_t	= int;
type processor_set_info_t	= array[*:5] of integer_t;	

type bootstrap_t = mach_port_t;

type kernel_version_t           = c_string[*:512];
type kernel_boot_info_t         = c_string[*:4096];

type time_value_t = struct[2] of integer_t;

type mach_port_qos_t = struct[2] of integer_t;

type emulation_vector_t		= ^array[] of vm_offset_t;

type inline_existence_map_t	= array[*:512] of char;

type policy_t			= int;
		/* policy_info_t: variable-size inline array. Can hold:
		 * policy_timeshare_info_t (5 ints)
		 * policy_fifo_info_t (4 ints)
		 * policy_rr_info_t (5 ints) */
type policy_base_t		= array[*:5] of integer_t;
type policy_info_t		= array[*:2] of integer_t;
type policy_limit_t		= array[*:1] of integer_t;

type ledger_t = mach_port_t
#if	KERNEL_SERVER
		intran: ledger_t convert_port_to_ledger(mach_port_t)
		outtran: mach_port_t convert_ledger_to_port(ledger_t)
#endif	/* KERNEL_SERVER */
                ;

type ledger_array_t	 	= ^array[] of ledger_t;
type ledger_item_t		= integer_t;

type security_token_t		= struct[2] of uint32_t;
type audit_token_t		= struct[8] of uint32_t;

		/* memory_object_info_t: variable-size inline array:
		 * memory_object_attr_info_t (5 ints)
		 * XXX actually it's 6 ints temporarily (object_ready!)
		 * memory_object_behave_info_t (4 ints)
		 * memory_object_perf_info_t (2 ints)
		 * old_memory_object_attr_info_t (3 ints)
		 * memory_object_norma_info_t (5 ints)
		 * If other flavors are added, this definition may
		 * need to be changed. (see mach/memory_object.h) */
type memory_object_flavor_t	= int;
type memory_object_info_t	= array[*:6] of int;

		/* vm_region_info_t: variable-size inline array that can hold:
		 * vm_region_basic_info_t (8 ints)
		 * If other flavors are added, this definition may
		 * need to be changed. (see mach/vm_region.h) */
type vm_region_flavor_t		= int;
type vm_region_info_t		= array[*:9] of int;
type vm_region_info_64_t	= array[*:10] of int;
type vm_region_recurse_info_t	= array[*:19] of int;
type vm_region_recurse_info_64_t	= array[*:19] of int;

type vm_read_entry_t = array[512] of int
	ctype: vm_read_entry_t;

type exception_mask_t		= int;
type exception_behavior_t	= int;

type    exception_handler_t = mach_port_t;

type	exception_handler_array_t	=
			array[*:32] of exception_handler_t;

type	exception_behavior_array_t	=
			array[*:32] of exception_behavior_t;

type	exception_flavor_array_t	=
			array[*:32] of thread_state_flavor_t;

type	exception_mask_array_t	=
			array[*:32] of exception_mask_t;

type semaphore_t = mach_port_t
#if	KERNEL_SERVER
		intran: semaphore_t convert_port_to_semaphore(mach_port_t)
		outtran: mach_port_t convert_semaphore_to_port(semaphore_t)
		destructor: semaphore_dereference(semaphore_t)
#endif	/* KERNEL_SERVER */
		;

type semaphore_consume_ref_t = mach_port_move_send_t
		ctype: semaphore_t
#if	KERNEL_SERVER
		intran: semaphore_t convert_port_to_semaphore(mach_port_t)
		outtran: mach_port_t convert_semaphore_to_port(semaphore_t)
		destructor: semaphore_dereference(semaphore_t)
#endif	/* KERNEL_SERVER */
		;

type lock_set_t = mach_port_t
#if	KERNEL_SERVER
		intran: lock_set_t convert_port_to_lock_set(mach_port_t)
		outtran: mach_port_t convert_lock_set_to_port(lock_set_t)
		destructor: lock_set_dereference(lock_set_t)
#endif	/* KERNEL_SERVER */
		;

/* kernel module loader */
type kmod_t = int;
type kmod_control_flavor_t = int;

type kmod_args_t = ^array[] of MACH_MSG_TYPE_BYTE
	ctype: kmod_args_t;

type io_master_t = mach_port_t;
type UNDServerRef = mach_port_t;

#if KERNEL_SERVER
#ifdef	MACH_KERNEL_PRIVATE
simport <kern/ipc_kobject.h>;	/* for null conversion */
simport <kern/ipc_tt.h>;	/* for task/thread conversion */
simport <kern/ipc_host.h>;	/* for host/processor/pset conversions */
simport <kern/ipc_sync.h>;      /* for lock_set and semaphore conversions */
simport <kern/ledger.h>;	/* for ledger conversions */
simport <vm/memory_object.h>; /* for memory object type conversions */
#endif	/* MACH_KERNEL_PRIVATE */

simport <kern/ipc_mig.h>;	/* pick up kernel-specific MIG things */

#endif /* KERNEL_SERVER */

import <mach/mig.h>;
import <mach/mach_types.h>;

#endif	/* _MACH_MACH_TYPES_DEFS_ */
Commit	Line	Data
1c79356b	1	/*
55e303ae	2	* Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
1c79356b A	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
e5568f75 A	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.
1c79356b	11	*
e5568f75 A	12	* This Original Code and all software distributed under the License are
e5568f75 A	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
e5568f75 A	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.
1c79356b A	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* @OSF_COPYRIGHT@
	24	*/
	25	/*
	26	* Mach Operating System
	27	* Copyright (c) 1991,1990,1989,1988 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 Software.Distribution@CS.CMU.EDU
	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	* Mach kernel interface type declarations
	54	*/
	55
	56	#ifndef _MACH_MACH_TYPES_DEFS_
	57	#define _MACH_MACH_TYPES_DEFS_
	58
	59
	60	#include <mach/std_types.defs>
	61
0b4e3aa0 A	62	type upl_page_info_t = struct[2] of integer_t;
	63	type upl_page_info_array_t = array[*:20] of upl_page_info_t;
	64
9bccf70c A	65	type memory_object_offset_t = uint64_t;
9bccf70c A	66	type memory_object_size_t = uint64_t;
1c79356b A	67
	68
	69
	70
	71	type mach_port_status_t = struct[10] of integer_t; /* obsolete */
	72
	73	/* mach_port_info_t: can hold either a
	74	* mach_port_status_t (9 ints) or a
	75	* mach_port_limits_t (1 int). If new flavors of
	76	* mach_port_{get,set}_attributes are added, the size of
	77	* this array may have to be increased. (See mach/port.h)
	78	*/
	79	type mach_port_flavor_t = int;
	80	type mach_port_info_t = array[*:10] of integer_t;
	81
	82	type task_t = mach_port_t
	83	#if KERNEL_SERVER
	84	intran: task_t convert_port_to_task(mach_port_t)
	85	outtran: mach_port_t convert_task_to_port(task_t)
	86	destructor: task_deallocate(task_t)
	87	#endif /* KERNEL_SERVER */
	88	;
	89
	90	type thread_t = mach_port_t
	91	#if KERNEL_SERVER
	92	intran: thread_t convert_port_to_thread(mach_port_t)
	93	outtran: mach_port_t convert_thread_to_port(thread_t)
	94	destructor: thread_deallocate(thread_t)
	95	#endif /* KERNEL_SERVER */
	96	;
	97
	98	type thread_act_t = mach_port_t
	99	#if KERNEL_SERVER
	100	intran: thread_act_t convert_port_to_act(mach_port_t)
	101	outtran: mach_port_t convert_act_to_port(thread_act_t)
	102	destructor: act_deallocate(thread_act_t)
55e303ae	103	#endif /* KERNEL_SERVER */
1c79356b A	104	;
	105
	106	type thread_act_consume_ref_t = mach_port_move_send_t
	107	ctype: thread_act_t
	108	#if KERNEL_SERVER
	109	intran: thread_act_t convert_port_to_act(mach_port_t)
	110	destructor: act_deallocate(thread_act_t)
55e303ae	111	#endif /* KERNEL_SERVER */
1c79356b A	112	;
	113
	114	/* thread_state_t: This inline array can hold
	115	* a machine-dependent amount of data, defined in
	116	* mach/machine/???? (currently THREAD_STATE_MAX,
	117	* in mach/thread_state.h)
	118	*/
	119	#include <mach/machine/thread_state.h>
	120	type thread_state_flavor_t = int;
	121	type thread_state_t = array[*:THREAD_STATE_MAX] of natural_t;
	122
	123	type task_array_t = ^array[] of task_t;
	124	type thread_array_t = ^array[] of thread_t;
	125	type thread_act_array_t = ^array[] of thread_act_t;
	126	type act_params_t = array[6] of int;
	127
	128	type vm_map_t = mach_port_t
	129	#if KERNEL_SERVER
	130	intran: vm_map_t convert_port_to_map(mach_port_t)
	131	destructor: vm_map_deallocate(vm_map_t)
	132	#endif /* KERNEL_SERVER */
	133	;
	134
	135	type vm_task_entry_t = mach_port_t
	136	ctype: vm_map_t
	137	#if KERNEL_SERVER
	138	intran: vm_map_t convert_port_entry_to_map(mach_port_t)
	139	destructor: vm_map_deallocate(vm_map_t)
	140	#endif /* KERNEL_SERVER */
	141	;
	142
1c79356b A	143	type ipc_space_t = mach_port_t
	144	#if KERNEL_SERVER
	145	intran: ipc_space_t convert_port_to_space(mach_port_t)
	146	destructor: space_deallocate(ipc_space_t)
	147	#endif /* KERNEL_SERVER */
	148	;
	149
	150	type vm_address_t = natural_t;
	151	type vm_offset_t = natural_t;
	152	type vm_size_t = natural_t;
	153	type vm_prot_t = int;
	154	type vm_inherit_t = int;
	155	type xxx_vm_statistics_data_t = struct[13] of integer_t;
	156	type vm_behavior_t = int;
	157	type vm_statistics_data_t = struct[12] of integer_t;
	158	type vm_machine_attribute_t = int;
	159	type vm_machine_attribute_val_t = int;
	160	type vm_sync_t = int;
	161
	162	/* thread_info_t: this inline array can hold any of:
	163	* thread_basic_info_t (10 ints)
	164	* policy_timeshare_info_t (5 ints)
	165	* policy_fifo_info_t (4 ints)
	166	* policy_rr_info_t (5 ints)
	167	* if other thread_info flavors are added, this
	168	* definition may need to be changed. (See
	169	* mach/thread_info.h and mach/policy.h) */
	170	type thread_flavor_t = int;
	171	type thread_info_t = array[*:12] of integer_t;
	172
	173	type thread_policy_flavor_t = natural_t;
	174	type thread_policy_t = array[*:16] of integer_t;
	175
	176	/* task_info_t: this inline array can hold any of:
	177	* task_basic_info_t (8 ints)
	178	* task_events_info_t (8 ints)
	179	* task_thread_times_info_t (4 ints)
	180	* policy_timeshare_info_t (5 ints)
	181	* policy_fifo_info_t (4 ints)
	182	* policy_rr_info_t (5 ints)
55e303ae A	183	* task security token (2 ints)
55e303ae A	184	* task audit token (8 ints)
1c79356b A	185	* If other task_info flavors are added, this
	186	* definition may need to be changed. (See
	187	* mach/task_info.h and mach/policy.h) */
	188	type task_flavor_t = int;
	189	type task_info_t = array[*:8] of integer_t;
	190
	191	type task_policy_flavor_t = natural_t;
	192	type task_policy_t = array[*:16] of integer_t;
	193
	194	type mem_entry_name_port_t = mach_port_t
	195	#if KERNEL_SERVER
0b4e3aa0	196	intran: mem_entry_name_port_t null_conversion(mach_port_t)
1c79356b A	197	#endif /* KERNEL_SERVER */
	198	;
	199
1c79356b	200	type memory_object_default_t = mach_port_t
0b4e3aa0	201	#if KERNEL_PRIVATE
1c79356b	202	intran: memory_object_default_t null_conversion(mach_port_t)
0b4e3aa0 A	203	outtran: mach_port_t null_conversion(memory_object_default_t)
0b4e3aa0 A	204	#endif /* KERNEL_PRIVATE */
1c79356b	205	;
0b4e3aa0 A	206
	207	type memory_object_t = mach_port_t
	208	#if KERNEL_PRIVATE
	209	intran: memory_object_t convert_port_to_memory_object(mach_port_t)
	210	outtran: mach_port_t convert_memory_object_to_port(memory_object_t)
	211	#endif /* KERNEL_PRIVATE */
1c79356b A	212	;
1c79356b A	213
0b4e3aa0 A	214
	215	type memory_object_control_t = mach_port_t
	216	#if KERNEL_PRIVATE
	217	intran: memory_object_control_t convert_port_to_mo_control(mach_port_t)
	218	outtran: mach_port_t convert_mo_control_to_port(memory_object_control_t)
	219	destructor: memory_object_control_deallocate(memory_object_control_t)
	220	#endif /* KERNEL_PRIVATE */
1c79356b A	221	;
	222
	223	type memory_object_name_t = mach_port_t
	224	ctype: mach_port_t
	225	;
	226
0b4e3aa0 A	227	type upl_t = mach_port_t
	228	#if KERNEL_PRIVATE
	229	intran: upl_t convert_port_to_upl(mach_port_t)
	230	outtran: mach_port_t convert_upl_to_port(upl_t)
	231	destructor: upl_deallocate(upl_t)
	232	#endif /* KERNEL_PRIVATE */
	233	;
	234
	235
1c79356b A	236	type memory_object_copy_strategy_t = int;
	237	type memory_object_return_t = int;
	238
	239	type machine_info_data_t = struct[5] of integer_t;
	240	type machine_slot_data_t = struct[8] of integer_t;
	241
	242	type host_t = mach_port_t
	243	#if KERNEL_SERVER
	244	intran: host_t convert_port_to_host(mach_port_t)
	245	outtran: mach_port_t convert_host_to_port(host_t)
	246	#endif /* KERNEL_SERVER */
	247	;
	248
	249	type host_priv_t = mach_port_t
	250	#if KERNEL_SERVER
	251	intran: host_priv_t convert_port_to_host_priv(mach_port_t)
	252	#endif /* KERNEL_SERVER */
	253	;
	254
	255	type host_security_t = mach_port_t
	256	#if KERNEL_SERVER
	257	intran: host_security_t convert_port_to_host_security(mach_port_t)
	258	#endif /* KERNEL_SERVER */
	259	;
	260
	261	/* host_info_t: variable-sized inline array that can contain:
	262	* host_basic_info_t (5 ints)
	263	* host_sched_info_t (2 ints)
	264	* kernel_resource_sizes_t (5 ints)
	265	* host_load_info_t (6 ints)
	266	* vm_statistics_t (12 ints)
	267	* If other host_info flavors are added, this definition may
	268	* need to be changed. (See mach/{host_info,vm_statistics}.h)
	269	*/
	270	type host_flavor_t = int;
	271	type host_info_t = array[*:12] of integer_t;
	272
	273	type processor_t = mach_port_t
	274	#if KERNEL_SERVER
	275	intran: processor_t convert_port_to_processor(mach_port_t)
	276	outtran: mach_port_t convert_processor_to_port(processor_t)
	277	#endif /* KERNEL_SERVER */
	278	;
	279
	280	type processor_array_t = ^array[] of processor_t;
	281
	282	/* processor_info_t: variable-sized inline array that can
	283	* contain:
	284	* processor_basic_info_t: (5 ints)
	285	* processor_cpu_load_info_t:(4 ints)
	286	* processor_machine_info_t :(12 ints)
	287	* If other processor_info flavors are added, this definition
	288	* may need to be changed. (See mach/processor_info.h) */
	289	type processor_flavor_t = int;
	290	type processor_info_t = array[*:12] of integer_t;
	291	type processor_info_array_t = ^array[] of integer_t;
	292
	293	type processor_set_t = mach_port_t
	294	#if KERNEL_SERVER
	295	intran: processor_set_t convert_port_to_pset(mach_port_t)
	296	outtran: mach_port_t convert_pset_to_port(processor_set_t)
	297	destructor: pset_deallocate(processor_set_t)
	298	#endif /* KERNEL_SERVER */
	299	;
300
301	type processor_set_array_t = ^array[] of processor_set_t;
302
303	type processor_set_name_t = mach_port_t
304	#if KERNEL_SERVER
305	intran: processor_set_name_t convert_port_to_pset_name(mach_port_t)
306	outtran: mach_port_t convert_pset_name_to_port(processor_set_name_t)
307	destructor: pset_deallocate(processor_set_name_t)
308	#endif /* KERNEL_SERVER */
309	;
310
311	type processor_set_name_array_t = ^array[] of processor_set_name_t;
312
313	/* processor_set_info_t: variable-size inline array
314	* that can hold:
315	* processor_set_basic_info (5 ints)
316	* processor_set_load_info (4 ints)
317	* policy_timeshare_base_t (1 int)
318	* policy_fifo_base_t (1 int)
319	* policy_rr_base_t (1 int)
320	* policy_timeshare_base_t (1 int)
321	* policy_fifo_base_t (1 int)
322	* policy_rr_base_t (1 int)
323	* policy_t (1 int)
324	* If other flavors are added, this definition may
325	* need to be changed. (see mach/processor.h) */
326	type processor_set_flavor_t = int;
327	type processor_set_info_t = array[*:5] of integer_t;
328
329	type bootstrap_t = mach_port_t;
330
331	type kernel_version_t = c_string[*:512];
332	type kernel_boot_info_t = c_string[*:4096];
333
334	type time_value_t = struct[2] of integer_t;
335
1c79356b A	336	type mach_port_qos_t = struct[2] of integer_t;
	337
	338	type emulation_vector_t = ^array[] of vm_offset_t;
	339
	340	type inline_existence_map_t = array[*:512] of char;
	341
	342	type policy_t = int;
	343	/* policy_info_t: variable-size inline array. Can hold:
	344	* policy_timeshare_info_t (5 ints)
	345	* policy_fifo_info_t (4 ints)
	346	* policy_rr_info_t (5 ints) */
	347	type policy_base_t = array[*:5] of integer_t;
	348	type policy_info_t = array[*:2] of integer_t;
	349	type policy_limit_t = array[*:1] of integer_t;
	350
	351	type ledger_t = mach_port_t
	352	#if KERNEL_SERVER
	353	intran: ledger_t convert_port_to_ledger(mach_port_t)
	354	outtran: mach_port_t convert_ledger_to_port(ledger_t)
	355	#endif /* KERNEL_SERVER */
	356	;
	357
55e303ae	358	type ledger_array_t = ^array[] of ledger_t;
1c79356b A	359	type ledger_item_t = integer_t;
1c79356b A	360
55e303ae A	361	type security_token_t = struct[2] of uint32_t;
55e303ae A	362	type audit_token_t = struct[8] of uint32_t;
1c79356b A	363
	364	/* memory_object_info_t: variable-size inline array:
	365	* memory_object_attr_info_t (5 ints)
	366	* XXX actually it's 6 ints temporarily (object_ready!)
	367	* memory_object_behave_info_t (4 ints)
	368	* memory_object_perf_info_t (2 ints)
	369	* old_memory_object_attr_info_t (3 ints)
	370	* memory_object_norma_info_t (5 ints)
	371	* If other flavors are added, this definition may
	372	* need to be changed. (see mach/memory_object.h) */
	373	type memory_object_flavor_t = int;
	374	type memory_object_info_t = array[*:6] of int;
	375
	376	/* vm_region_info_t: variable-size inline array that can hold:
	377	* vm_region_basic_info_t (8 ints)
	378	* If other flavors are added, this definition may
	379	* need to be changed. (see mach/vm_region.h) */
	380	type vm_region_flavor_t = int;
	381	type vm_region_info_t = array[*:9] of int;
	382	type vm_region_info_64_t = array[*:10] of int;
	383	type vm_region_recurse_info_t = array[*:19] of int;
	384	type vm_region_recurse_info_64_t = array[*:19] of int;
	385
	386	type vm_read_entry_t = array[512] of int
	387	ctype: vm_read_entry_t;
	388
	389	type exception_mask_t = int;
	390	type exception_behavior_t = int;
	391
	392	type exception_handler_t = mach_port_t;
	393
	394	type exception_handler_array_t =
	395	array[*:32] of exception_handler_t;
	396
	397	type exception_behavior_array_t =
	398	array[*:32] of exception_behavior_t;
	399
	400	type exception_flavor_array_t =
	401	array[*:32] of thread_state_flavor_t;
	402
	403	type exception_mask_array_t =
	404	array[*:32] of exception_mask_t;
	405
	406	type semaphore_t = mach_port_t
	407	#if KERNEL_SERVER
	408	intran: semaphore_t convert_port_to_semaphore(mach_port_t)
	409	outtran: mach_port_t convert_semaphore_to_port(semaphore_t)
	410	destructor: semaphore_dereference(semaphore_t)
	411	#endif /* KERNEL_SERVER */
	412	;
	413
	414	type semaphore_consume_ref_t = mach_port_move_send_t
	415	ctype: semaphore_t
	416	#if KERNEL_SERVER
	417	intran: semaphore_t convert_port_to_semaphore(mach_port_t)
0b4e3aa0	418	outtran: mach_port_t convert_semaphore_to_port(semaphore_t)
1c79356b A	419	destructor: semaphore_dereference(semaphore_t)
	420	#endif /* KERNEL_SERVER */
	421	;
	422
	423	type lock_set_t = mach_port_t
	424	#if KERNEL_SERVER
	425	intran: lock_set_t convert_port_to_lock_set(mach_port_t)
	426	outtran: mach_port_t convert_lock_set_to_port(lock_set_t)
	427	destructor: lock_set_dereference(lock_set_t)
	428	#endif /* KERNEL_SERVER */
	429	;
	430
1c79356b A	431	/* kernel module loader */
	432	type kmod_t = int;
	433	type kmod_control_flavor_t = int;
	434
	435	type kmod_args_t = ^array[] of MACH_MSG_TYPE_BYTE
	436	ctype: kmod_args_t;
	437
	438	type io_master_t = mach_port_t;
	439	type UNDServerRef = mach_port_t;
	440
9bccf70c	441	#if KERNEL_SERVER
1c79356b A	442	#ifdef MACH_KERNEL_PRIVATE
	443	simport <kern/ipc_kobject.h>; /* for null conversion */
	444	simport <kern/ipc_tt.h>; /* for task/thread conversion */
	445	simport <kern/ipc_host.h>; /* for host/processor/pset conversions */
1c79356b	446	simport <kern/ipc_sync.h>; /* for lock_set and semaphore conversions */
9bccf70c	447	simport <kern/ledger.h>; /* for ledger conversions */
0b4e3aa0	448	simport <vm/memory_object.h>; /* for memory object type conversions */
1c79356b A	449	#endif /* MACH_KERNEL_PRIVATE */
	450
	451	simport <kern/ipc_mig.h>; /* pick up kernel-specific MIG things */
	452
	453	#endif /* KERNEL_SERVER */
	454
9bccf70c	455	import <mach/mig.h>;
1c79356b A	456	import <mach/mach_types.h>;
	457
	458	#endif /* _MACH_MACH_TYPES_DEFS_ */