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

/*
 * Copyright (c) 2000 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 memory_object_offset_t = struct[2] of integer_t;
type memory_object_size_t = struct[2] of integer_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 vm_object_entry_t = mach_port_t
		ctype: vm_object_t
#if	KERNEL_SERVER
		intran: vm_object_t convert_port_entry_to_object(mach_port_t)
		destructor: vm_object_deallocate(vm_object_t)
#endif	/* KERNEL_SERVER */
		;

type upl_object_entry_t = mach_port_t
		ctype: upl_t
#if	KERNEL_SERVER
		intran: upl_t convert_port_to_upl(mach_port_t)
		destructor: mach_destroy_upl(upl_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)
		 * 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_t = mach_port_t
#if	KERNEL_SERVER
		intran: memory_object_t null_conversion(mach_port_t)
#endif	/* KERNEL_SERVER */
		;

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

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

type vm_object_t = mach_port_t
#if	KERNEL_SERVER
		intran: vm_object_t vm_object_lookup(mach_port_t)
#endif	/* KERNEL_SERVER */
		;

type memory_object_name_t = mach_port_t
		ctype: mach_port_t
		;

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 user_subsystem_t		= array[*:16384] of char;

type subsystem_t = mach_port_t
#if	KERNEL_SERVER
		intran: subsystem_t convert_port_to_subsystem(mach_port_t)
		outtran: mach_port_t convert_subsystem_to_port(subsystem_t)
#endif	/* KERNEL_SERVER */
		;

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		= MACH_MSG_TYPE_INTEGER_64;

		/* 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)
		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 */
		;

type upl_page_list_ptr_t	= array[*:20] of upl_page_info_t;

/* 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;

#ifdef  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_subsystem.h>;	/* for subsystem conversions */
simport <kern/ipc_sync.h>;      /* for lock_set and semaphore conversions */
#endif	/* MACH_KERNEL_PRIVATE */

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

#endif /* KERNEL_SERVER */

import <mach/mach_types.h>;

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