kern/mach.server.c

Bug Summary

File:	obj-scan-build/kern/mach.server.c
Location:	line 3793, column 12
Description:	Value stored to 'msgh_simple' during its initialization is never read

Annotated Source Code

1	/* Module mach */
2
3	#ifndef _GNU_SOURCE1
4	#define _GNU_SOURCE1 1
5	#endif
6
7	#define EXPORT_BOOLEAN
8	#include <mach/boolean.h>
9	#include <mach/kern_return.h>
10	#include <mach/message.h>
11	#include <mach/mig_errors.h>
12	#include <mach/mig_support.h>
13	#include <ipc/ipc_port.h>
14
15	#ifndef mig_internalstatic
16	#define mig_internalstatic static
17	#endif
18
19	#ifndef mig_external
20	#define mig_external
21	#endif
22
23	#ifndef mig_unlikely
24	#define mig_unlikely(X)__builtin_expect (!! (X), 0) __builtin_expect (!! (X), 0)
25	#endif
26
27	#ifndef TypeCheck1
28	#define TypeCheck1 1
29	#endif
30
31	#ifndef UseExternRCSId1
32	#define UseExternRCSId1 1
33	#endif
34
35	#define BAD_TYPECHECK(type, check)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (type); _c.t = (check);_t.w != _c.w; } )), 0) mig_unlikely (({\__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (type); _c.t = (check);_t.w != _c.w; } )), 0)
36	union { mach_msg_type_t t; unsigned32_t w; } _t, _c;\__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (type); _c.t = (check);_t.w != _c.w; } )), 0)
37	_t.t = (type); _c.t = (check);_t.w != _c.w; }))__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (type); _c.t = (check);_t.w != _c.w; } )), 0)
38	#define msgh_request_portmsgh_remote_port msgh_remote_port
39	#define MACH_MSGH_BITS_REQUEST(bits)((bits) & 0x000000ff) MACH_MSGH_BITS_REMOTE(bits)((bits) & 0x000000ff)
40	#define msgh_reply_portmsgh_local_port msgh_local_port
41	#define MACH_MSGH_BITS_REPLY(bits)(((bits) & 0x0000ff00) >> 8) MACH_MSGH_BITS_LOCAL(bits)(((bits) & 0x0000ff00) >> 8)
42
43	#include <mach/std_types.h>
44	#include <kern/ipc_kobject.h>
45	#include <kern/ipc_tt.h>
46	#include <kern/ipc_host.h>
47	#include <kern/task.h>
48	#include <kern/thread.h>
49	#include <kern/host.h>
50	#include <kern/processor.h>
51	#include <vm/vm_object.h>
52	#include <vm/vm_map.h>
53	#include <ipc/ipc_space.h>
54	#include <mach/mach_types.h>
55
56	/* Routine task_create */
57	mig_internalstatic void _Xtask_create
58	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
59	{
60	typedef struct {
61	mach_msg_header_t Head;
62	mach_msg_type_t inherit_memoryType;
63	boolean_t inherit_memory;
64	} Request;
65
66	typedef struct {
67	mach_msg_header_t Head;
68	mach_msg_type_t RetCodeType;
69	kern_return_t RetCode;
70	mach_msg_type_t child_taskType;
71	ipc_port_t child_task;
72	} Reply;
73
74	Request In0P = (Request ) InHeadP;
75	Reply OutP = (Reply ) OutHeadP;
76	mig_external kern_return_t task_create
77	(task_t target_task, boolean_t inherit_memory, task_t *child_task);
78
79	const mach_msg_type_t inherit_memoryCheck = {
80	/* msgt_name = */ 0,
81	/* msgt_size = */ 32,
82	/* msgt_number = */ 1,
83	/* msgt_inline = */ TRUE((boolean_t) 1),
84	/* msgt_longform = */ FALSE((boolean_t) 0),
85	/* msgt_deallocate = */ FALSE((boolean_t) 0),
86	/* msgt_unused = */ 0
87	};
88
89	const mach_msg_type_t child_taskType = {
90	/* msgt_name = */ 17,
91	/* msgt_size = */ 32,
92	/* msgt_number = */ 1,
93	/* msgt_inline = */ TRUE((boolean_t) 1),
94	/* msgt_longform = */ FALSE((boolean_t) 0),
95	/* msgt_deallocate = */ FALSE((boolean_t) 0),
96	/* msgt_unused = */ 0
97	};
98
99	task_t target_task;
100	task_t child_task;
101
102	#if TypeCheck1
103	if (mig_unlikely ((In0P->Head.msgh_size != 32) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
104	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
105	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
106	#endif /* TypeCheck */
107
108	#if TypeCheck1
109	if (BAD_TYPECHECK(&In0P->inherit_memoryType, &inherit_memoryCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->inherit_memoryType); _c. t = (&inherit_memoryCheck);_t.w != _c.w; })), 0))
110	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
111	#endif /* TypeCheck */
112
113	target_task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
114
115	OutP->RetCode = task_create(target_task, In0P->inherit_memory, &child_task);
116	task_deallocate(target_task);
117	if (OutP->RetCode != KERN_SUCCESS0)
118	return;
119
120	OutP->Head.msgh_bits \|= MACH_MSGH_BITS_COMPLEX0x80000000U;
121	OutP->Head.msgh_size = 40;
122
123	OutP->child_taskType = child_taskType;
124
125	OutP->child_task = convert_task_to_port(child_task);
126	}
127
128	/* Default implementation of task_create */
129	#ifdef MIG_EOPNOTSUPP
130	kern_return_t __attribute__ ((weak))
131	task_create
132	(
133	task_t target_task,
134	boolean_t inherit_memory,
135	task_t *child_task
136	) { return MIG_EOPNOTSUPP; }
137	#endif /* MIG_EOPNOTSUPP */
138
139	/* Routine task_terminate */
140	mig_internalstatic void _Xtask_terminate
141	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
142	{
143	typedef struct {
144	mach_msg_header_t Head;
145	} Request;
146
147	typedef struct {
148	mach_msg_header_t Head;
149	mach_msg_type_t RetCodeType;
150	kern_return_t RetCode;
151	} Reply;
152
153	Request In0P = (Request ) InHeadP;
154	Reply OutP = (Reply ) OutHeadP;
155	mig_external kern_return_t task_terminate
156	(task_t target_task);
157
158	task_t target_task;
159
160	#if TypeCheck1
161	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
162	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
163	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
164	#endif /* TypeCheck */
165
166	target_task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
167
168	OutP->RetCode = task_terminate(target_task);
169	task_deallocate(target_task);
170	}
171
172	/* Default implementation of task_terminate */
173	#ifdef MIG_EOPNOTSUPP
174	kern_return_t __attribute__ ((weak))
175	task_terminate
176	(
177	task_t target_task
178	) { return MIG_EOPNOTSUPP; }
179	#endif /* MIG_EOPNOTSUPP */
180
181	/* Routine task_get_emulation_vector */
182	mig_internalstatic void _Xtask_get_emulation_vector
183	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
184	{
185	typedef struct {
186	mach_msg_header_t Head;
187	} Request;
188
189	typedef struct {
190	mach_msg_header_t Head;
191	mach_msg_type_t RetCodeType;
192	kern_return_t RetCode;
193	mach_msg_type_t vector_startType;
194	int vector_start;
195	mach_msg_type_long_t emulation_vectorType;
196	emulation_vector_t emulation_vector;
197	} Reply;
198
199	Request In0P = (Request ) InHeadP;
200	Reply OutP = (Reply ) OutHeadP;
201	mig_external kern_return_t task_get_emulation_vector
202	(task_t task, int vector_start, emulation_vector_t emulation_vector, mach_msg_type_number_t *emulation_vectorCnt);
203
204	const mach_msg_type_t vector_startType = {
205	/* msgt_name = */ 2,
206	/* msgt_size = */ 32,
207	/* msgt_number = */ 1,
208	/* msgt_inline = */ TRUE((boolean_t) 1),
209	/* msgt_longform = */ FALSE((boolean_t) 0),
210	/* msgt_deallocate = */ FALSE((boolean_t) 0),
211	/* msgt_unused = */ 0
212	};
213
214	const mach_msg_type_long_t emulation_vectorType = {
215	{
216	/* msgt_name = */ 0,
217	/* msgt_size = */ 0,
218	/* msgt_number = */ 0,
219	/* msgt_inline = */ FALSE((boolean_t) 0),
220	/* msgt_longform = */ TRUE((boolean_t) 1),
221	/* msgt_deallocate = */ FALSE((boolean_t) 0),
222	/* msgt_unused = */ 0
223	},
224	/* msgtl_name = */ 2,
225	/* msgtl_size = */ 32,
226	/* msgtl_number = */ 0,
227	};
228
229	task_t task;
230	mach_msg_type_number_t emulation_vectorCnt;
231
232	#if TypeCheck1
233	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
234	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
235	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
236	#endif /* TypeCheck */
237
238	task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
239
240	OutP->RetCode = task_get_emulation_vector(task, &OutP->vector_start, &OutP->emulation_vector, &emulation_vectorCnt);
241	task_deallocate(task);
242	if (OutP->RetCode != KERN_SUCCESS0)
243	return;
244
245	OutP->Head.msgh_bits \|= MACH_MSGH_BITS_COMPLEX0x80000000U;
246	OutP->Head.msgh_size = 56;
247
248	OutP->vector_startType = vector_startType;
249
250	OutP->emulation_vectorType = emulation_vectorType;
251
252	OutP->emulation_vectorType.msgtl_number = emulation_vectorCnt;
253	}
254
255	/* Default implementation of task_get_emulation_vector */
256	#ifdef MIG_EOPNOTSUPP
257	kern_return_t __attribute__ ((weak))
258	task_get_emulation_vector
259	(
260	task_t task,
261	int *vector_start,
262	emulation_vector_t *emulation_vector,
263	mach_msg_type_number_t *emulation_vectorCnt
264	) { return MIG_EOPNOTSUPP; }
265	#endif /* MIG_EOPNOTSUPP */
266
267	/* Routine task_set_emulation_vector */
268	mig_internalstatic void _Xtask_set_emulation_vector
269	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
270	{
271	typedef struct {
272	mach_msg_header_t Head;
273	mach_msg_type_t vector_startType;
274	int vector_start;
275	mach_msg_type_long_t emulation_vectorType;
276	emulation_vector_t emulation_vector;
277	} Request;
278
279	typedef struct {
280	mach_msg_header_t Head;
281	mach_msg_type_t RetCodeType;
282	kern_return_t RetCode;
283	} Reply;
284
285	Request In0P = (Request ) InHeadP;
286	Reply OutP = (Reply ) OutHeadP;
287	mig_external kern_return_t task_set_emulation_vector
288	(task_t task, int vector_start, emulation_vector_t emulation_vector, mach_msg_type_number_t emulation_vectorCnt);
289
290	const mach_msg_type_t vector_startCheck = {
291	/* msgt_name = */ 2,
292	/* msgt_size = */ 32,
293	/* msgt_number = */ 1,
294	/* msgt_inline = */ TRUE((boolean_t) 1),
295	/* msgt_longform = */ FALSE((boolean_t) 0),
296	/* msgt_deallocate = */ FALSE((boolean_t) 0),
297	/* msgt_unused = */ 0
298	};
299
300	task_t task;
301
302	#if TypeCheck1
303	if (mig_unlikely ((In0P->Head.msgh_size != 48) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0)
304	!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0))
305	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
306	#endif /* TypeCheck */
307
308	#if TypeCheck1
309	if (BAD_TYPECHECK(&In0P->vector_startType, &vector_startCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->vector_startType); _c.t = (&vector_startCheck);_t.w != _c.w; })), 0))
310	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
311	#endif /* TypeCheck */
312
313	#if TypeCheck1
314	if (mig_unlikely ((In0P->emulation_vectorType.msgtl_header.msgt_inline != FALSE) \|\|__builtin_expect (!! ((In0P->emulation_vectorType.msgtl_header .msgt_inline != ((boolean_t) 0)) \|\| (In0P->emulation_vectorType .msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P-> emulation_vectorType.msgtl_name != 2) \|\| (In0P->emulation_vectorType .msgtl_size != 32)), 0)
315	(In0P->emulation_vectorType.msgtl_header.msgt_longform != TRUE) \|\|__builtin_expect (!! ((In0P->emulation_vectorType.msgtl_header .msgt_inline != ((boolean_t) 0)) \|\| (In0P->emulation_vectorType .msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P-> emulation_vectorType.msgtl_name != 2) \|\| (In0P->emulation_vectorType .msgtl_size != 32)), 0)
316	(In0P->emulation_vectorType.msgtl_name != 2) \|\|__builtin_expect (!! ((In0P->emulation_vectorType.msgtl_header .msgt_inline != ((boolean_t) 0)) \|\| (In0P->emulation_vectorType .msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P-> emulation_vectorType.msgtl_name != 2) \|\| (In0P->emulation_vectorType .msgtl_size != 32)), 0)
317	(In0P->emulation_vectorType.msgtl_size != 32))__builtin_expect (!! ((In0P->emulation_vectorType.msgtl_header .msgt_inline != ((boolean_t) 0)) \|\| (In0P->emulation_vectorType .msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P-> emulation_vectorType.msgtl_name != 2) \|\| (In0P->emulation_vectorType .msgtl_size != 32)), 0))
318	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
319	#endif /* TypeCheck */
320
321	task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
322
323	OutP->RetCode = task_set_emulation_vector(task, In0P->vector_start, In0P->emulation_vector, In0P->emulation_vectorType.msgtl_number);
324	task_deallocate(task);
325	}
326
327	/* Default implementation of task_set_emulation_vector */
328	#ifdef MIG_EOPNOTSUPP
329	kern_return_t __attribute__ ((weak))
330	task_set_emulation_vector
331	(
332	task_t task,
333	int vector_start,
334	emulation_vector_t emulation_vector,
335	mach_msg_type_number_t emulation_vectorCnt
336	) { return MIG_EOPNOTSUPP; }
337	#endif /* MIG_EOPNOTSUPP */
338
339	/* Routine task_threads */
340	mig_internalstatic void _Xtask_threads
341	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
342	{
343	typedef struct {
344	mach_msg_header_t Head;
345	} Request;
346
347	typedef struct {
348	mach_msg_header_t Head;
349	mach_msg_type_t RetCodeType;
350	kern_return_t RetCode;
351	mach_msg_type_long_t thread_listType;
352	thread_array_t thread_list;
353	} Reply;
354
355	Request In0P = (Request ) InHeadP;
356	Reply OutP = (Reply ) OutHeadP;
357	mig_external kern_return_t task_threads
358	(task_t target_task, thread_array_t thread_list, mach_msg_type_number_t thread_listCnt);
359
360	const mach_msg_type_long_t thread_listType = {
361	{
362	/* msgt_name = */ 0,
363	/* msgt_size = */ 0,
364	/* msgt_number = */ 0,
365	/* msgt_inline = */ FALSE((boolean_t) 0),
366	/* msgt_longform = */ TRUE((boolean_t) 1),
367	/* msgt_deallocate = */ FALSE((boolean_t) 0),
368	/* msgt_unused = */ 0
369	},
370	/* msgtl_name = */ 17,
371	/* msgtl_size = */ 32,
372	/* msgtl_number = */ 0,
373	};
374
375	task_t target_task;
376	mach_msg_type_number_t thread_listCnt;
377
378	#if TypeCheck1
379	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
380	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
381	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
382	#endif /* TypeCheck */
383
384	target_task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
385
386	OutP->RetCode = task_threads(target_task, &OutP->thread_list, &thread_listCnt);
387	task_deallocate(target_task);
388	if (OutP->RetCode != KERN_SUCCESS0)
389	return;
390
391	OutP->Head.msgh_bits \|= MACH_MSGH_BITS_COMPLEX0x80000000U;
392	OutP->Head.msgh_size = 48;
393
394	OutP->thread_listType = thread_listType;
395
396	OutP->thread_listType.msgtl_number = thread_listCnt;
397	}
398
399	/* Default implementation of task_threads */
400	#ifdef MIG_EOPNOTSUPP
401	kern_return_t __attribute__ ((weak))
402	task_threads
403	(
404	task_t target_task,
405	thread_array_t *thread_list,
406	mach_msg_type_number_t *thread_listCnt
407	) { return MIG_EOPNOTSUPP; }
408	#endif /* MIG_EOPNOTSUPP */
409
410	/* Routine task_info */
411	mig_internalstatic void _Xtask_info
412	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
413	{
414	typedef struct {
415	mach_msg_header_t Head;
416	mach_msg_type_t flavorType;
417	int flavor;
418	mach_msg_type_t task_info_outCntType;
419	mach_msg_type_number_t task_info_outCnt;
420	} Request;
421
422	typedef struct {
423	mach_msg_header_t Head;
424	mach_msg_type_t RetCodeType;
425	kern_return_t RetCode;
426	mach_msg_type_t task_info_outType;
427	integer_t task_info_out[1024];
428	} Reply;
429
430	Request In0P = (Request ) InHeadP;
431	Reply OutP = (Reply ) OutHeadP;
432	mig_external kern_return_t task_info
433	(task_t target_task, int flavor, task_info_t task_info_out, mach_msg_type_number_t *task_info_outCnt);
434
435	const mach_msg_type_t flavorCheck = {
436	/* msgt_name = */ 2,
437	/* msgt_size = */ 32,
438	/* msgt_number = */ 1,
439	/* msgt_inline = */ TRUE((boolean_t) 1),
440	/* msgt_longform = */ FALSE((boolean_t) 0),
441	/* msgt_deallocate = */ FALSE((boolean_t) 0),
442	/* msgt_unused = */ 0
443	};
444
445	const mach_msg_type_t task_info_outCntCheck = {
446	/* msgt_name = */ MACH_MSG_TYPE_INTEGER_322,
447	/* msgt_size = */ 32,
448	/* msgt_number = */ 1,
449	/* msgt_inline = */ TRUE((boolean_t) 1),
450	/* msgt_longform = */ FALSE((boolean_t) 0),
451	/* msgt_deallocate = */ FALSE((boolean_t) 0),
452	/* msgt_unused = */ 0
453	};
454
455	const mach_msg_type_t task_info_outType = {
456	/* msgt_name = */ 2,
457	/* msgt_size = */ 32,
458	/* msgt_number = */ 1024,
459	/* msgt_inline = */ TRUE((boolean_t) 1),
460	/* msgt_longform = */ FALSE((boolean_t) 0),
461	/* msgt_deallocate = */ FALSE((boolean_t) 0),
462	/* msgt_unused = */ 0
463	};
464
465	task_t target_task;
466	mach_msg_type_number_t task_info_outCnt;
467
468	#if TypeCheck1
469	if (mig_unlikely ((In0P->Head.msgh_size != 40) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
470	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
471	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
472	#endif /* TypeCheck */
473
474	#if TypeCheck1
475	if (BAD_TYPECHECK(&In0P->flavorType, &flavorCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->flavorType); _c.t = (& flavorCheck);_t.w != _c.w; })), 0))
476	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
477	#endif /* TypeCheck */
478
479	#if TypeCheck1
480	if (BAD_TYPECHECK(&In0P->task_info_outCntType, &task_info_outCntCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->task_info_outCntType); _c .t = (&task_info_outCntCheck);_t.w != _c.w; })), 0))
481	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
482	#endif /* TypeCheck */
483
484	target_task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
485
486	task_info_outCnt = 1024;
487	if (In0P->task_info_outCnt < task_info_outCnt)
488	task_info_outCnt = In0P->task_info_outCnt;
489
490	OutP->RetCode = task_info(target_task, In0P->flavor, OutP->task_info_out, &task_info_outCnt);
491	task_deallocate(target_task);
492	if (OutP->RetCode != KERN_SUCCESS0)
493	return;
494
495	OutP->task_info_outType = task_info_outType;
496
497	OutP->task_info_outType.msgt_number = task_info_outCnt;
498	OutP->Head.msgh_size = 36 + (4 * task_info_outCnt);
499	}
500
501	/* Default implementation of task_info */
502	#ifdef MIG_EOPNOTSUPP
503	kern_return_t __attribute__ ((weak))
504	task_info
505	(
506	task_t target_task,
507	int flavor,
508	task_info_t task_info_out,
509	mach_msg_type_number_t *task_info_outCnt
510	) { return MIG_EOPNOTSUPP; }
511	#endif /* MIG_EOPNOTSUPP */
512
513	/* Routine thread_terminate */
514	mig_internalstatic void _Xthread_terminate
515	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
516	{
517	typedef struct {
518	mach_msg_header_t Head;
519	} Request;
520
521	typedef struct {
522	mach_msg_header_t Head;
523	mach_msg_type_t RetCodeType;
524	kern_return_t RetCode;
525	} Reply;
526
527	Request In0P = (Request ) InHeadP;
528	Reply OutP = (Reply ) OutHeadP;
529	mig_external kern_return_t thread_terminate
530	(thread_t target_thread);
531
532	thread_t target_thread;
533
534	#if TypeCheck1
535	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
536	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
537	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
538	#endif /* TypeCheck */
539
540	target_thread = convert_port_to_thread((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
541
542	OutP->RetCode = thread_terminate(target_thread);
543	thread_deallocate(target_thread);
544	}
545
546	/* Default implementation of thread_terminate */
547	#ifdef MIG_EOPNOTSUPP
548	kern_return_t __attribute__ ((weak))
549	thread_terminate
550	(
551	thread_t target_thread
552	) { return MIG_EOPNOTSUPP; }
553	#endif /* MIG_EOPNOTSUPP */
554
555	/* Routine thread_get_state */
556	mig_internalstatic void _Xthread_get_state
557	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
558	{
559	typedef struct {
560	mach_msg_header_t Head;
561	mach_msg_type_t flavorType;
562	int flavor;
563	mach_msg_type_t old_stateCntType;
564	mach_msg_type_number_t old_stateCnt;
565	} Request;
566
567	typedef struct {
568	mach_msg_header_t Head;
569	mach_msg_type_t RetCodeType;
570	kern_return_t RetCode;
571	mach_msg_type_t old_stateType;
572	natural_t old_state[1024];
573	} Reply;
574
575	Request In0P = (Request ) InHeadP;
576	Reply OutP = (Reply ) OutHeadP;
577	mig_external kern_return_t thread_get_state
578	(thread_t target_thread, int flavor, thread_state_t old_state, mach_msg_type_number_t *old_stateCnt);
579
580	const mach_msg_type_t flavorCheck = {
581	/* msgt_name = */ 2,
582	/* msgt_size = */ 32,
583	/* msgt_number = */ 1,
584	/* msgt_inline = */ TRUE((boolean_t) 1),
585	/* msgt_longform = */ FALSE((boolean_t) 0),
586	/* msgt_deallocate = */ FALSE((boolean_t) 0),
587	/* msgt_unused = */ 0
588	};
589
590	const mach_msg_type_t old_stateCntCheck = {
591	/* msgt_name = */ MACH_MSG_TYPE_INTEGER_322,
592	/* msgt_size = */ 32,
593	/* msgt_number = */ 1,
594	/* msgt_inline = */ TRUE((boolean_t) 1),
595	/* msgt_longform = */ FALSE((boolean_t) 0),
596	/* msgt_deallocate = */ FALSE((boolean_t) 0),
597	/* msgt_unused = */ 0
598	};
599
600	const mach_msg_type_t old_stateType = {
601	/* msgt_name = */ 2,
602	/* msgt_size = */ 32,
603	/* msgt_number = */ 1024,
604	/* msgt_inline = */ TRUE((boolean_t) 1),
605	/* msgt_longform = */ FALSE((boolean_t) 0),
606	/* msgt_deallocate = */ FALSE((boolean_t) 0),
607	/* msgt_unused = */ 0
608	};
609
610	thread_t target_thread;
611	mach_msg_type_number_t old_stateCnt;
612
613	#if TypeCheck1
614	if (mig_unlikely ((In0P->Head.msgh_size != 40) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
615	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
616	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
617	#endif /* TypeCheck */
618
619	#if TypeCheck1
620	if (BAD_TYPECHECK(&In0P->flavorType, &flavorCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->flavorType); _c.t = (& flavorCheck);_t.w != _c.w; })), 0))
621	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
622	#endif /* TypeCheck */
623
624	#if TypeCheck1
625	if (BAD_TYPECHECK(&In0P->old_stateCntType, &old_stateCntCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->old_stateCntType); _c.t = (&old_stateCntCheck);_t.w != _c.w; })), 0))
626	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
627	#endif /* TypeCheck */
628
629	target_thread = convert_port_to_thread((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
630
631	old_stateCnt = 1024;
632	if (In0P->old_stateCnt < old_stateCnt)
633	old_stateCnt = In0P->old_stateCnt;
634
635	OutP->RetCode = thread_get_state(target_thread, In0P->flavor, OutP->old_state, &old_stateCnt);
636	thread_deallocate(target_thread);
637	if (OutP->RetCode != KERN_SUCCESS0)
638	return;
639
640	OutP->old_stateType = old_stateType;
641
642	OutP->old_stateType.msgt_number = old_stateCnt;
643	OutP->Head.msgh_size = 36 + (4 * old_stateCnt);
644	}
645
646	/* Default implementation of thread_get_state */
647	#ifdef MIG_EOPNOTSUPP
648	kern_return_t __attribute__ ((weak))
649	thread_get_state
650	(
651	thread_t target_thread,
652	int flavor,
653	thread_state_t old_state,
654	mach_msg_type_number_t *old_stateCnt
655	) { return MIG_EOPNOTSUPP; }
656	#endif /* MIG_EOPNOTSUPP */
657
658	/* Routine thread_set_state */
659	mig_internalstatic void _Xthread_set_state
660	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
661	{
662	typedef struct {
663	mach_msg_header_t Head;
664	mach_msg_type_t flavorType;
665	int flavor;
666	mach_msg_type_t new_stateType;
667	natural_t new_state[1024];
668	} Request;
669
670	typedef struct {
671	mach_msg_header_t Head;
672	mach_msg_type_t RetCodeType;
673	kern_return_t RetCode;
674	} Reply;
675
676	Request In0P = (Request ) InHeadP;
677	Reply OutP = (Reply ) OutHeadP;
678	mig_external kern_return_t thread_set_state
679	(thread_t target_thread, int flavor, thread_state_t new_state, mach_msg_type_number_t new_stateCnt);
680
681	unsigned int msgh_size;
682
683	const mach_msg_type_t flavorCheck = {
684	/* msgt_name = */ 2,
685	/* msgt_size = */ 32,
686	/* msgt_number = */ 1,
687	/* msgt_inline = */ TRUE((boolean_t) 1),
688	/* msgt_longform = */ FALSE((boolean_t) 0),
689	/* msgt_deallocate = */ FALSE((boolean_t) 0),
690	/* msgt_unused = */ 0
691	};
692
693	thread_t target_thread;
694
695	#if TypeCheck1
696	msgh_size = In0P->Head.msgh_size;
697	if (mig_unlikely ((msgh_size < 36) \|\|__builtin_expect (!! ((msgh_size < 36) \|\| (In0P->Head.msgh_bits & 0x80000000U)), 0)
698	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((msgh_size < 36) \|\| (In0P->Head.msgh_bits & 0x80000000U)), 0))
699	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
700	#endif /* TypeCheck */
701
702	#if TypeCheck1
703	if (BAD_TYPECHECK(&In0P->flavorType, &flavorCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->flavorType); _c.t = (& flavorCheck);_t.w != _c.w; })), 0))
704	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
705	#endif /* TypeCheck */
706
707	#if TypeCheck1
708	if (mig_unlikely ((In0P->new_stateType.msgt_inline != TRUE) \|\|__builtin_expect (!! ((In0P->new_stateType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->new_stateType.msgt_longform != ( (boolean_t) 0)) \|\| (In0P->new_stateType.msgt_name != 2) \|\| (In0P->new_stateType.msgt_size != 32)), 0)
709	(In0P->new_stateType.msgt_longform != FALSE) \|\|__builtin_expect (!! ((In0P->new_stateType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->new_stateType.msgt_longform != ( (boolean_t) 0)) \|\| (In0P->new_stateType.msgt_name != 2) \|\| (In0P->new_stateType.msgt_size != 32)), 0)
710	(In0P->new_stateType.msgt_name != 2) \|\|__builtin_expect (!! ((In0P->new_stateType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->new_stateType.msgt_longform != ( (boolean_t) 0)) \|\| (In0P->new_stateType.msgt_name != 2) \|\| (In0P->new_stateType.msgt_size != 32)), 0)
711	(In0P->new_stateType.msgt_size != 32))__builtin_expect (!! ((In0P->new_stateType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->new_stateType.msgt_longform != ( (boolean_t) 0)) \|\| (In0P->new_stateType.msgt_name != 2) \|\| (In0P->new_stateType.msgt_size != 32)), 0))
712	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
713	#endif /* TypeCheck */
714
715	#if TypeCheck1
716	if (mig_unlikely (msgh_size != 36 + (4 * In0P->new_stateType.msgt_number))__builtin_expect (!! (msgh_size != 36 + (4 * In0P->new_stateType .msgt_number)), 0))
717	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
718	#endif /* TypeCheck */
719
720	target_thread = convert_port_to_thread((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
721
722	OutP->RetCode = thread_set_state(target_thread, In0P->flavor, In0P->new_state, In0P->new_stateType.msgt_number);
723	thread_deallocate(target_thread);
724	}
725
726	/* Default implementation of thread_set_state */
727	#ifdef MIG_EOPNOTSUPP
728	kern_return_t __attribute__ ((weak))
729	thread_set_state
730	(
731	thread_t target_thread,
732	int flavor,
733	thread_state_t new_state,
734	mach_msg_type_number_t new_stateCnt
735	) { return MIG_EOPNOTSUPP; }
736	#endif /* MIG_EOPNOTSUPP */
737
738	/* Routine thread_info */
739	mig_internalstatic void _Xthread_info
740	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
741	{
742	typedef struct {
743	mach_msg_header_t Head;
744	mach_msg_type_t flavorType;
745	int flavor;
746	mach_msg_type_t thread_info_outCntType;
747	mach_msg_type_number_t thread_info_outCnt;
748	} Request;
749
750	typedef struct {
751	mach_msg_header_t Head;
752	mach_msg_type_t RetCodeType;
753	kern_return_t RetCode;
754	mach_msg_type_t thread_info_outType;
755	integer_t thread_info_out[1024];
756	} Reply;
757
758	Request In0P = (Request ) InHeadP;
759	Reply OutP = (Reply ) OutHeadP;
760	mig_external kern_return_t thread_info
761	(thread_t target_thread, int flavor, thread_info_t thread_info_out, mach_msg_type_number_t *thread_info_outCnt);
762
763	const mach_msg_type_t flavorCheck = {
764	/* msgt_name = */ 2,
765	/* msgt_size = */ 32,
766	/* msgt_number = */ 1,
767	/* msgt_inline = */ TRUE((boolean_t) 1),
768	/* msgt_longform = */ FALSE((boolean_t) 0),
769	/* msgt_deallocate = */ FALSE((boolean_t) 0),
770	/* msgt_unused = */ 0
771	};
772
773	const mach_msg_type_t thread_info_outCntCheck = {
774	/* msgt_name = */ MACH_MSG_TYPE_INTEGER_322,
775	/* msgt_size = */ 32,
776	/* msgt_number = */ 1,
777	/* msgt_inline = */ TRUE((boolean_t) 1),
778	/* msgt_longform = */ FALSE((boolean_t) 0),
779	/* msgt_deallocate = */ FALSE((boolean_t) 0),
780	/* msgt_unused = */ 0
781	};
782
783	const mach_msg_type_t thread_info_outType = {
784	/* msgt_name = */ 2,
785	/* msgt_size = */ 32,
786	/* msgt_number = */ 1024,
787	/* msgt_inline = */ TRUE((boolean_t) 1),
788	/* msgt_longform = */ FALSE((boolean_t) 0),
789	/* msgt_deallocate = */ FALSE((boolean_t) 0),
790	/* msgt_unused = */ 0
791	};
792
793	thread_t target_thread;
794	mach_msg_type_number_t thread_info_outCnt;
795
796	#if TypeCheck1
797	if (mig_unlikely ((In0P->Head.msgh_size != 40) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
798	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
799	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
800	#endif /* TypeCheck */
801
802	#if TypeCheck1
803	if (BAD_TYPECHECK(&In0P->flavorType, &flavorCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->flavorType); _c.t = (& flavorCheck);_t.w != _c.w; })), 0))
804	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
805	#endif /* TypeCheck */
806
807	#if TypeCheck1
808	if (BAD_TYPECHECK(&In0P->thread_info_outCntType, &thread_info_outCntCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->thread_info_outCntType); _c.t = (&thread_info_outCntCheck);_t.w != _c.w; })), 0))
809	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
810	#endif /* TypeCheck */
811
812	target_thread = convert_port_to_thread((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
813
814	thread_info_outCnt = 1024;
815	if (In0P->thread_info_outCnt < thread_info_outCnt)
816	thread_info_outCnt = In0P->thread_info_outCnt;
817
818	OutP->RetCode = thread_info(target_thread, In0P->flavor, OutP->thread_info_out, &thread_info_outCnt);
819	thread_deallocate(target_thread);
820	if (OutP->RetCode != KERN_SUCCESS0)
821	return;
822
823	OutP->thread_info_outType = thread_info_outType;
824
825	OutP->thread_info_outType.msgt_number = thread_info_outCnt;
826	OutP->Head.msgh_size = 36 + (4 * thread_info_outCnt);
827	}
828
829	/* Default implementation of thread_info */
830	#ifdef MIG_EOPNOTSUPP
831	kern_return_t __attribute__ ((weak))
832	thread_info
833	(
834	thread_t target_thread,
835	int flavor,
836	thread_info_t thread_info_out,
837	mach_msg_type_number_t *thread_info_outCnt
838	) { return MIG_EOPNOTSUPP; }
839	#endif /* MIG_EOPNOTSUPP */
840
841	/* Routine vm_allocate */
842	mig_internalstatic void _Xvm_allocate
843	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
844	{
845	typedef struct {
846	mach_msg_header_t Head;
847	mach_msg_type_t addressType;
848	vm_address_t address;
849	mach_msg_type_t sizeType;
850	vm_size_t size;
851	mach_msg_type_t anywhereType;
852	boolean_t anywhere;
853	} Request;
854
855	typedef struct {
856	mach_msg_header_t Head;
857	mach_msg_type_t RetCodeType;
858	kern_return_t RetCode;
859	mach_msg_type_t addressType;
860	vm_address_t address;
861	} Reply;
862
863	Request In0P = (Request ) InHeadP;
864	Reply OutP = (Reply ) OutHeadP;
865	mig_external kern_return_t vm_allocate
866	(vm_map_t target_task, vm_address_t *address, vm_size_t size, boolean_t anywhere);
867
868	const mach_msg_type_t addressCheck = {
869	/* msgt_name = */ 2,
870	/* msgt_size = */ 32,
871	/* msgt_number = */ 1,
872	/* msgt_inline = */ TRUE((boolean_t) 1),
873	/* msgt_longform = */ FALSE((boolean_t) 0),
874	/* msgt_deallocate = */ FALSE((boolean_t) 0),
875	/* msgt_unused = */ 0
876	};
877
878	const mach_msg_type_t sizeCheck = {
879	/* msgt_name = */ 2,
880	/* msgt_size = */ 32,
881	/* msgt_number = */ 1,
882	/* msgt_inline = */ TRUE((boolean_t) 1),
883	/* msgt_longform = */ FALSE((boolean_t) 0),
884	/* msgt_deallocate = */ FALSE((boolean_t) 0),
885	/* msgt_unused = */ 0
886	};
887
888	const mach_msg_type_t anywhereCheck = {
889	/* msgt_name = */ 0,
890	/* msgt_size = */ 32,
891	/* msgt_number = */ 1,
892	/* msgt_inline = */ TRUE((boolean_t) 1),
893	/* msgt_longform = */ FALSE((boolean_t) 0),
894	/* msgt_deallocate = */ FALSE((boolean_t) 0),
895	/* msgt_unused = */ 0
896	};
897
898	const mach_msg_type_t addressType = {
899	/* msgt_name = */ 2,
900	/* msgt_size = */ 32,
901	/* msgt_number = */ 1,
902	/* msgt_inline = */ TRUE((boolean_t) 1),
903	/* msgt_longform = */ FALSE((boolean_t) 0),
904	/* msgt_deallocate = */ FALSE((boolean_t) 0),
905	/* msgt_unused = */ 0
906	};
907
908	vm_map_t target_task;
909
910	#if TypeCheck1
911	if (mig_unlikely ((In0P->Head.msgh_size != 48) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
912	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
913	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
914	#endif /* TypeCheck */
915
916	#if TypeCheck1
917	if (BAD_TYPECHECK(&In0P->addressType, &addressCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->addressType); _c.t = (& addressCheck);_t.w != _c.w; })), 0))
918	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
919	#endif /* TypeCheck */
920
921	#if TypeCheck1
922	if (BAD_TYPECHECK(&In0P->sizeType, &sizeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->sizeType); _c.t = (& sizeCheck);_t.w != _c.w; })), 0))
923	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
924	#endif /* TypeCheck */
925
926	#if TypeCheck1
927	if (BAD_TYPECHECK(&In0P->anywhereType, &anywhereCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->anywhereType); _c.t = ( &anywhereCheck);_t.w != _c.w; })), 0))
928	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
929	#endif /* TypeCheck */
930
931	target_task = convert_port_to_map((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
932
933	OutP->RetCode = vm_allocate(target_task, &In0P->address, In0P->size, In0P->anywhere);
934	vm_map_deallocate(target_task);
935	if (OutP->RetCode != KERN_SUCCESS0)
936	return;
937
938	OutP->Head.msgh_size = 40;
939
940	OutP->addressType = addressType;
941
942	OutP->address = In0P->address;
943	}
944
945	/* Default implementation of vm_allocate */
946	#ifdef MIG_EOPNOTSUPP
947	kern_return_t __attribute__ ((weak))
948	vm_allocate
949	(
950	vm_map_t target_task,
951	vm_address_t *address,
952	vm_size_t size,
953	boolean_t anywhere
954	) { return MIG_EOPNOTSUPP; }
955	#endif /* MIG_EOPNOTSUPP */
956
957	/* Routine vm_deallocate */
958	mig_internalstatic void _Xvm_deallocate
959	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
960	{
961	typedef struct {
962	mach_msg_header_t Head;
963	mach_msg_type_t addressType;
964	vm_address_t address;
965	mach_msg_type_t sizeType;
966	vm_size_t size;
967	} Request;
968
969	typedef struct {
970	mach_msg_header_t Head;
971	mach_msg_type_t RetCodeType;
972	kern_return_t RetCode;
973	} Reply;
974
975	Request In0P = (Request ) InHeadP;
976	Reply OutP = (Reply ) OutHeadP;
977	mig_external kern_return_t vm_deallocate
978	(vm_map_t target_task, vm_address_t address, vm_size_t size);
979
980	const mach_msg_type_t addressCheck = {
981	/* msgt_name = */ 2,
982	/* msgt_size = */ 32,
983	/* msgt_number = */ 1,
984	/* msgt_inline = */ TRUE((boolean_t) 1),
985	/* msgt_longform = */ FALSE((boolean_t) 0),
986	/* msgt_deallocate = */ FALSE((boolean_t) 0),
987	/* msgt_unused = */ 0
988	};
989
990	const mach_msg_type_t sizeCheck = {
991	/* msgt_name = */ 2,
992	/* msgt_size = */ 32,
993	/* msgt_number = */ 1,
994	/* msgt_inline = */ TRUE((boolean_t) 1),
995	/* msgt_longform = */ FALSE((boolean_t) 0),
996	/* msgt_deallocate = */ FALSE((boolean_t) 0),
997	/* msgt_unused = */ 0
998	};
999
1000	vm_map_t target_task;
1001
1002	#if TypeCheck1
1003	if (mig_unlikely ((In0P->Head.msgh_size != 40) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
1004	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
1005	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1006	#endif /* TypeCheck */
1007
1008	#if TypeCheck1
1009	if (BAD_TYPECHECK(&In0P->addressType, &addressCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->addressType); _c.t = (& addressCheck);_t.w != _c.w; })), 0))
1010	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1011	#endif /* TypeCheck */
1012
1013	#if TypeCheck1
1014	if (BAD_TYPECHECK(&In0P->sizeType, &sizeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->sizeType); _c.t = (& sizeCheck);_t.w != _c.w; })), 0))
1015	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1016	#endif /* TypeCheck */
1017
1018	target_task = convert_port_to_map((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
1019
1020	OutP->RetCode = vm_deallocate(target_task, In0P->address, In0P->size);
1021	vm_map_deallocate(target_task);
1022	}
1023
1024	/* Default implementation of vm_deallocate */
1025	#ifdef MIG_EOPNOTSUPP
1026	kern_return_t __attribute__ ((weak))
1027	vm_deallocate
1028	(
1029	vm_map_t target_task,
1030	vm_address_t address,
1031	vm_size_t size
1032	) { return MIG_EOPNOTSUPP; }
1033	#endif /* MIG_EOPNOTSUPP */
1034
1035	/* Routine vm_protect */
1036	mig_internalstatic void _Xvm_protect
1037	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
1038	{
1039	typedef struct {
1040	mach_msg_header_t Head;
1041	mach_msg_type_t addressType;
1042	vm_address_t address;
1043	mach_msg_type_t sizeType;
1044	vm_size_t size;
1045	mach_msg_type_t set_maximumType;
1046	boolean_t set_maximum;
1047	mach_msg_type_t new_protectionType;
1048	vm_prot_t new_protection;
1049	} Request;
1050
1051	typedef struct {
1052	mach_msg_header_t Head;
1053	mach_msg_type_t RetCodeType;
1054	kern_return_t RetCode;
1055	} Reply;
1056
1057	Request In0P = (Request ) InHeadP;
1058	Reply OutP = (Reply ) OutHeadP;
1059	mig_external kern_return_t vm_protect
1060	(vm_map_t target_task, vm_address_t address, vm_size_t size, boolean_t set_maximum, vm_prot_t new_protection);
1061
1062	const mach_msg_type_t addressCheck = {
1063	/* msgt_name = */ 2,
1064	/* msgt_size = */ 32,
1065	/* msgt_number = */ 1,
1066	/* msgt_inline = */ TRUE((boolean_t) 1),
1067	/* msgt_longform = */ FALSE((boolean_t) 0),
1068	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1069	/* msgt_unused = */ 0
1070	};
1071
1072	const mach_msg_type_t sizeCheck = {
1073	/* msgt_name = */ 2,
1074	/* msgt_size = */ 32,
1075	/* msgt_number = */ 1,
1076	/* msgt_inline = */ TRUE((boolean_t) 1),
1077	/* msgt_longform = */ FALSE((boolean_t) 0),
1078	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1079	/* msgt_unused = */ 0
1080	};
1081
1082	const mach_msg_type_t set_maximumCheck = {
1083	/* msgt_name = */ 0,
1084	/* msgt_size = */ 32,
1085	/* msgt_number = */ 1,
1086	/* msgt_inline = */ TRUE((boolean_t) 1),
1087	/* msgt_longform = */ FALSE((boolean_t) 0),
1088	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1089	/* msgt_unused = */ 0
1090	};
1091
1092	const mach_msg_type_t new_protectionCheck = {
1093	/* msgt_name = */ 2,
1094	/* msgt_size = */ 32,
1095	/* msgt_number = */ 1,
1096	/* msgt_inline = */ TRUE((boolean_t) 1),
1097	/* msgt_longform = */ FALSE((boolean_t) 0),
1098	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1099	/* msgt_unused = */ 0
1100	};
1101
1102	vm_map_t target_task;
1103
1104	#if TypeCheck1
1105	if (mig_unlikely ((In0P->Head.msgh_size != 56) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 56) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
1106	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 56) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
1107	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1108	#endif /* TypeCheck */
1109
1110	#if TypeCheck1
1111	if (BAD_TYPECHECK(&In0P->addressType, &addressCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->addressType); _c.t = (& addressCheck);_t.w != _c.w; })), 0))
1112	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1113	#endif /* TypeCheck */
1114
1115	#if TypeCheck1
1116	if (BAD_TYPECHECK(&In0P->sizeType, &sizeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->sizeType); _c.t = (& sizeCheck);_t.w != _c.w; })), 0))
1117	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1118	#endif /* TypeCheck */
1119
1120	#if TypeCheck1
1121	if (BAD_TYPECHECK(&In0P->set_maximumType, &set_maximumCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->set_maximumType); _c.t = (&set_maximumCheck);_t.w != _c.w; })), 0))
1122	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1123	#endif /* TypeCheck */
1124
1125	#if TypeCheck1
1126	if (BAD_TYPECHECK(&In0P->new_protectionType, &new_protectionCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->new_protectionType); _c. t = (&new_protectionCheck);_t.w != _c.w; })), 0))
1127	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1128	#endif /* TypeCheck */
1129
1130	target_task = convert_port_to_map((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
1131
1132	OutP->RetCode = vm_protect(target_task, In0P->address, In0P->size, In0P->set_maximum, In0P->new_protection);
1133	vm_map_deallocate(target_task);
1134	}
1135
1136	/* Default implementation of vm_protect */
1137	#ifdef MIG_EOPNOTSUPP
1138	kern_return_t __attribute__ ((weak))
1139	vm_protect
1140	(
1141	vm_map_t target_task,
1142	vm_address_t address,
1143	vm_size_t size,
1144	boolean_t set_maximum,
1145	vm_prot_t new_protection
1146	) { return MIG_EOPNOTSUPP; }
1147	#endif /* MIG_EOPNOTSUPP */
1148
1149	/* Routine vm_inherit */
1150	mig_internalstatic void _Xvm_inherit
1151	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
1152	{
1153	typedef struct {
1154	mach_msg_header_t Head;
1155	mach_msg_type_t addressType;
1156	vm_address_t address;
1157	mach_msg_type_t sizeType;
1158	vm_size_t size;
1159	mach_msg_type_t new_inheritanceType;
1160	vm_inherit_t new_inheritance;
1161	} Request;
1162
1163	typedef struct {
1164	mach_msg_header_t Head;
1165	mach_msg_type_t RetCodeType;
1166	kern_return_t RetCode;
1167	} Reply;
1168
1169	Request In0P = (Request ) InHeadP;
1170	Reply OutP = (Reply ) OutHeadP;
1171	mig_external kern_return_t vm_inherit
1172	(vm_map_t target_task, vm_address_t address, vm_size_t size, vm_inherit_t new_inheritance);
1173
1174	const mach_msg_type_t addressCheck = {
1175	/* msgt_name = */ 2,
1176	/* msgt_size = */ 32,
1177	/* msgt_number = */ 1,
1178	/* msgt_inline = */ TRUE((boolean_t) 1),
1179	/* msgt_longform = */ FALSE((boolean_t) 0),
1180	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1181	/* msgt_unused = */ 0
1182	};
1183
1184	const mach_msg_type_t sizeCheck = {
1185	/* msgt_name = */ 2,
1186	/* msgt_size = */ 32,
1187	/* msgt_number = */ 1,
1188	/* msgt_inline = */ TRUE((boolean_t) 1),
1189	/* msgt_longform = */ FALSE((boolean_t) 0),
1190	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1191	/* msgt_unused = */ 0
1192	};
1193
1194	const mach_msg_type_t new_inheritanceCheck = {
1195	/* msgt_name = */ 2,
1196	/* msgt_size = */ 32,
1197	/* msgt_number = */ 1,
1198	/* msgt_inline = */ TRUE((boolean_t) 1),
1199	/* msgt_longform = */ FALSE((boolean_t) 0),
1200	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1201	/* msgt_unused = */ 0
1202	};
1203
1204	vm_map_t target_task;
1205
1206	#if TypeCheck1
1207	if (mig_unlikely ((In0P->Head.msgh_size != 48) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
1208	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
1209	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1210	#endif /* TypeCheck */
1211
1212	#if TypeCheck1
1213	if (BAD_TYPECHECK(&In0P->addressType, &addressCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->addressType); _c.t = (& addressCheck);_t.w != _c.w; })), 0))
1214	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1215	#endif /* TypeCheck */
1216
1217	#if TypeCheck1
1218	if (BAD_TYPECHECK(&In0P->sizeType, &sizeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->sizeType); _c.t = (& sizeCheck);_t.w != _c.w; })), 0))
1219	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1220	#endif /* TypeCheck */
1221
1222	#if TypeCheck1
1223	if (BAD_TYPECHECK(&In0P->new_inheritanceType, &new_inheritanceCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->new_inheritanceType); _c .t = (&new_inheritanceCheck);_t.w != _c.w; })), 0))
1224	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1225	#endif /* TypeCheck */
1226
1227	target_task = convert_port_to_map((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
1228
1229	OutP->RetCode = vm_inherit(target_task, In0P->address, In0P->size, In0P->new_inheritance);
1230	vm_map_deallocate(target_task);
1231	}
1232
1233	/* Default implementation of vm_inherit */
1234	#ifdef MIG_EOPNOTSUPP
1235	kern_return_t __attribute__ ((weak))
1236	vm_inherit
1237	(
1238	vm_map_t target_task,
1239	vm_address_t address,
1240	vm_size_t size,
1241	vm_inherit_t new_inheritance
1242	) { return MIG_EOPNOTSUPP; }
1243	#endif /* MIG_EOPNOTSUPP */
1244
1245	/* Routine vm_read */
1246	mig_internalstatic void _Xvm_read
1247	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
1248	{
1249	typedef struct {
1250	mach_msg_header_t Head;
1251	mach_msg_type_t addressType;
1252	vm_address_t address;
1253	mach_msg_type_t sizeType;
1254	vm_size_t size;
1255	} Request;
1256
1257	typedef struct {
1258	mach_msg_header_t Head;
1259	mach_msg_type_t RetCodeType;
1260	kern_return_t RetCode;
1261	mach_msg_type_long_t dataType;
1262	vm_offset_t data;
1263	} Reply;
1264
1265	Request In0P = (Request ) InHeadP;
1266	Reply OutP = (Reply ) OutHeadP;
1267	mig_external kern_return_t vm_read
1268	(vm_map_t target_task, vm_address_t address, vm_size_t size, vm_offset_t data, mach_msg_type_number_t dataCnt);
1269
1270	const mach_msg_type_t addressCheck = {
1271	/* msgt_name = */ 2,
1272	/* msgt_size = */ 32,
1273	/* msgt_number = */ 1,
1274	/* msgt_inline = */ TRUE((boolean_t) 1),
1275	/* msgt_longform = */ FALSE((boolean_t) 0),
1276	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1277	/* msgt_unused = */ 0
1278	};
1279
1280	const mach_msg_type_t sizeCheck = {
1281	/* msgt_name = */ 2,
1282	/* msgt_size = */ 32,
1283	/* msgt_number = */ 1,
1284	/* msgt_inline = */ TRUE((boolean_t) 1),
1285	/* msgt_longform = */ FALSE((boolean_t) 0),
1286	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1287	/* msgt_unused = */ 0
1288	};
1289
1290	const mach_msg_type_long_t dataType = {
1291	{
1292	/* msgt_name = */ 0,
1293	/* msgt_size = */ 0,
1294	/* msgt_number = */ 0,
1295	/* msgt_inline = */ FALSE((boolean_t) 0),
1296	/* msgt_longform = */ TRUE((boolean_t) 1),
1297	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1298	/* msgt_unused = */ 0
1299	},
1300	/* msgtl_name = */ 9,
1301	/* msgtl_size = */ 8,
1302	/* msgtl_number = */ 0,
1303	};
1304
1305	vm_map_t target_task;
1306	mach_msg_type_number_t dataCnt;
1307
1308	#if TypeCheck1
1309	if (mig_unlikely ((In0P->Head.msgh_size != 40) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
1310	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
1311	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1312	#endif /* TypeCheck */
1313
1314	#if TypeCheck1
1315	if (BAD_TYPECHECK(&In0P->addressType, &addressCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->addressType); _c.t = (& addressCheck);_t.w != _c.w; })), 0))
1316	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1317	#endif /* TypeCheck */
1318
1319	#if TypeCheck1
1320	if (BAD_TYPECHECK(&In0P->sizeType, &sizeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->sizeType); _c.t = (& sizeCheck);_t.w != _c.w; })), 0))
1321	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1322	#endif /* TypeCheck */
1323
1324	target_task = convert_port_to_map((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
1325
1326	OutP->RetCode = vm_read(target_task, In0P->address, In0P->size, &OutP->data, &dataCnt);
1327	vm_map_deallocate(target_task);
1328	if (OutP->RetCode != KERN_SUCCESS0)
1329	return;
1330
1331	OutP->Head.msgh_bits \|= MACH_MSGH_BITS_COMPLEX0x80000000U;
1332	OutP->Head.msgh_size = 48;
1333
1334	OutP->dataType = dataType;
1335
1336	OutP->dataType.msgtl_number = dataCnt;
1337	}
1338
1339	/* Default implementation of vm_read */
1340	#ifdef MIG_EOPNOTSUPP
1341	kern_return_t __attribute__ ((weak))
1342	vm_read
1343	(
1344	vm_map_t target_task,
1345	vm_address_t address,
1346	vm_size_t size,
1347	vm_offset_t *data,
1348	mach_msg_type_number_t *dataCnt
1349	) { return MIG_EOPNOTSUPP; }
1350	#endif /* MIG_EOPNOTSUPP */
1351
1352	/* Routine vm_write */
1353	mig_internalstatic void _Xvm_write
1354	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
1355	{
1356	typedef struct {
1357	mach_msg_header_t Head;
1358	mach_msg_type_t addressType;
1359	vm_address_t address;
1360	mach_msg_type_long_t dataType;
1361	vm_offset_t data;
1362	} Request;
1363
1364	typedef struct {
1365	mach_msg_header_t Head;
1366	mach_msg_type_t RetCodeType;
1367	kern_return_t RetCode;
1368	} Reply;
1369
1370	Request In0P = (Request ) InHeadP;
1371	Reply OutP = (Reply ) OutHeadP;
1372	mig_external kern_return_t vm_write
1373	(vm_map_t target_task, vm_address_t address, vm_offset_t data, mach_msg_type_number_t dataCnt);
1374
1375	const mach_msg_type_t addressCheck = {
1376	/* msgt_name = */ 2,
1377	/* msgt_size = */ 32,
1378	/* msgt_number = */ 1,
1379	/* msgt_inline = */ TRUE((boolean_t) 1),
1380	/* msgt_longform = */ FALSE((boolean_t) 0),
1381	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1382	/* msgt_unused = */ 0
1383	};
1384
1385	vm_map_t target_task;
1386
1387	#if TypeCheck1
1388	if (mig_unlikely ((In0P->Head.msgh_size != 48) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0)
1389	!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0))
1390	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1391	#endif /* TypeCheck */
1392
1393	#if TypeCheck1
1394	if (BAD_TYPECHECK(&In0P->addressType, &addressCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->addressType); _c.t = (& addressCheck);_t.w != _c.w; })), 0))
1395	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1396	#endif /* TypeCheck */
1397
1398	#if TypeCheck1
1399	if (mig_unlikely ((In0P->dataType.msgtl_header.msgt_inline != FALSE) \|\|__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0)
1400	(In0P->dataType.msgtl_header.msgt_longform != TRUE) \|\|__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0)
1401	(In0P->dataType.msgtl_name != 9) \|\|__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0)
1402	(In0P->dataType.msgtl_size != 8))__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0))
1403	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1404	#endif /* TypeCheck */
1405
1406	target_task = convert_port_to_map((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
1407
1408	OutP->RetCode = vm_write(target_task, In0P->address, In0P->data, In0P->dataType.msgtl_number);
1409	vm_map_deallocate(target_task);
1410	}
1411
1412	/* Default implementation of vm_write */
1413	#ifdef MIG_EOPNOTSUPP
1414	kern_return_t __attribute__ ((weak))
1415	vm_write
1416	(
1417	vm_map_t target_task,
1418	vm_address_t address,
1419	vm_offset_t data,
1420	mach_msg_type_number_t dataCnt
1421	) { return MIG_EOPNOTSUPP; }
1422	#endif /* MIG_EOPNOTSUPP */
1423
1424	/* Routine vm_copy */
1425	mig_internalstatic void _Xvm_copy
1426	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
1427	{
1428	typedef struct {
1429	mach_msg_header_t Head;
1430	mach_msg_type_t source_addressType;
1431	vm_address_t source_address;
1432	mach_msg_type_t sizeType;
1433	vm_size_t size;
1434	mach_msg_type_t dest_addressType;
1435	vm_address_t dest_address;
1436	} Request;
1437
1438	typedef struct {
1439	mach_msg_header_t Head;
1440	mach_msg_type_t RetCodeType;
1441	kern_return_t RetCode;
1442	} Reply;
1443
1444	Request In0P = (Request ) InHeadP;
1445	Reply OutP = (Reply ) OutHeadP;
1446	mig_external kern_return_t vm_copy
1447	(vm_map_t target_task, vm_address_t source_address, vm_size_t size, vm_address_t dest_address);
1448
1449	const mach_msg_type_t source_addressCheck = {
1450	/* msgt_name = */ 2,
1451	/* msgt_size = */ 32,
1452	/* msgt_number = */ 1,
1453	/* msgt_inline = */ TRUE((boolean_t) 1),
1454	/* msgt_longform = */ FALSE((boolean_t) 0),
1455	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1456	/* msgt_unused = */ 0
1457	};
1458
1459	const mach_msg_type_t sizeCheck = {
1460	/* msgt_name = */ 2,
1461	/* msgt_size = */ 32,
1462	/* msgt_number = */ 1,
1463	/* msgt_inline = */ TRUE((boolean_t) 1),
1464	/* msgt_longform = */ FALSE((boolean_t) 0),
1465	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1466	/* msgt_unused = */ 0
1467	};
1468
1469	const mach_msg_type_t dest_addressCheck = {
1470	/* msgt_name = */ 2,
1471	/* msgt_size = */ 32,
1472	/* msgt_number = */ 1,
1473	/* msgt_inline = */ TRUE((boolean_t) 1),
1474	/* msgt_longform = */ FALSE((boolean_t) 0),
1475	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1476	/* msgt_unused = */ 0
1477	};
1478
1479	vm_map_t target_task;
1480
1481	#if TypeCheck1
1482	if (mig_unlikely ((In0P->Head.msgh_size != 48) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
1483	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
1484	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1485	#endif /* TypeCheck */
1486
1487	#if TypeCheck1
1488	if (BAD_TYPECHECK(&In0P->source_addressType, &source_addressCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->source_addressType); _c. t = (&source_addressCheck);_t.w != _c.w; })), 0))
1489	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1490	#endif /* TypeCheck */
1491
1492	#if TypeCheck1
1493	if (BAD_TYPECHECK(&In0P->sizeType, &sizeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->sizeType); _c.t = (& sizeCheck);_t.w != _c.w; })), 0))
1494	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1495	#endif /* TypeCheck */
1496
1497	#if TypeCheck1
1498	if (BAD_TYPECHECK(&In0P->dest_addressType, &dest_addressCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->dest_addressType); _c.t = (&dest_addressCheck);_t.w != _c.w; })), 0))
1499	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1500	#endif /* TypeCheck */
1501
1502	target_task = convert_port_to_map((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
1503
1504	OutP->RetCode = vm_copy(target_task, In0P->source_address, In0P->size, In0P->dest_address);
1505	vm_map_deallocate(target_task);
1506	}
1507
1508	/* Default implementation of vm_copy */
1509	#ifdef MIG_EOPNOTSUPP
1510	kern_return_t __attribute__ ((weak))
1511	vm_copy
1512	(
1513	vm_map_t target_task,
1514	vm_address_t source_address,
1515	vm_size_t size,
1516	vm_address_t dest_address
1517	) { return MIG_EOPNOTSUPP; }
1518	#endif /* MIG_EOPNOTSUPP */
1519
1520	/* Routine vm_region */
1521	mig_internalstatic void _Xvm_region
1522	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
1523	{
1524	typedef struct {
1525	mach_msg_header_t Head;
1526	mach_msg_type_t addressType;
1527	vm_address_t address;
1528	} Request;
1529
1530	typedef struct {
1531	mach_msg_header_t Head;
1532	mach_msg_type_t RetCodeType;
1533	kern_return_t RetCode;
1534	mach_msg_type_t addressType;
1535	vm_address_t address;
1536	mach_msg_type_t sizeType;
1537	vm_size_t size;
1538	mach_msg_type_t protectionType;
1539	vm_prot_t protection;
1540	mach_msg_type_t max_protectionType;
1541	vm_prot_t max_protection;
1542	mach_msg_type_t inheritanceType;
1543	vm_inherit_t inheritance;
1544	mach_msg_type_t is_sharedType;
1545	boolean_t is_shared;
1546	mach_msg_type_t object_nameType;
1547	ipc_port_t object_name;
1548	mach_msg_type_t offsetType;
1549	vm_offset_t offset;
1550	} Reply;
1551
1552	Request In0P = (Request ) InHeadP;
1553	Reply OutP = (Reply ) OutHeadP;
1554	mig_external kern_return_t vm_region
1555	(vm_map_t target_task, vm_address_t address, vm_size_t size, vm_prot_t protection, vm_prot_t max_protection, vm_inherit_t inheritance, boolean_t is_shared, ipc_port_t object_name, vm_offset_t offset);
1556
1557	const mach_msg_type_t addressCheck = {
1558	/* msgt_name = */ 2,
1559	/* msgt_size = */ 32,
1560	/* msgt_number = */ 1,
1561	/* msgt_inline = */ TRUE((boolean_t) 1),
1562	/* msgt_longform = */ FALSE((boolean_t) 0),
1563	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1564	/* msgt_unused = */ 0
1565	};
1566
1567	const mach_msg_type_t addressType = {
1568	/* msgt_name = */ 2,
1569	/* msgt_size = */ 32,
1570	/* msgt_number = */ 1,
1571	/* msgt_inline = */ TRUE((boolean_t) 1),
1572	/* msgt_longform = */ FALSE((boolean_t) 0),
1573	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1574	/* msgt_unused = */ 0
1575	};
1576
1577	const mach_msg_type_t sizeType = {
1578	/* msgt_name = */ 2,
1579	/* msgt_size = */ 32,
1580	/* msgt_number = */ 1,
1581	/* msgt_inline = */ TRUE((boolean_t) 1),
1582	/* msgt_longform = */ FALSE((boolean_t) 0),
1583	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1584	/* msgt_unused = */ 0
1585	};
1586
1587	const mach_msg_type_t protectionType = {
1588	/* msgt_name = */ 2,
1589	/* msgt_size = */ 32,
1590	/* msgt_number = */ 1,
1591	/* msgt_inline = */ TRUE((boolean_t) 1),
1592	/* msgt_longform = */ FALSE((boolean_t) 0),
1593	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1594	/* msgt_unused = */ 0
1595	};
1596
1597	const mach_msg_type_t max_protectionType = {
1598	/* msgt_name = */ 2,
1599	/* msgt_size = */ 32,
1600	/* msgt_number = */ 1,
1601	/* msgt_inline = */ TRUE((boolean_t) 1),
1602	/* msgt_longform = */ FALSE((boolean_t) 0),
1603	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1604	/* msgt_unused = */ 0
1605	};
1606
1607	const mach_msg_type_t inheritanceType = {
1608	/* msgt_name = */ 2,
1609	/* msgt_size = */ 32,
1610	/* msgt_number = */ 1,
1611	/* msgt_inline = */ TRUE((boolean_t) 1),
1612	/* msgt_longform = */ FALSE((boolean_t) 0),
1613	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1614	/* msgt_unused = */ 0
1615	};
1616
1617	const mach_msg_type_t is_sharedType = {
1618	/* msgt_name = */ 0,
1619	/* msgt_size = */ 32,
1620	/* msgt_number = */ 1,
1621	/* msgt_inline = */ TRUE((boolean_t) 1),
1622	/* msgt_longform = */ FALSE((boolean_t) 0),
1623	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1624	/* msgt_unused = */ 0
1625	};
1626
1627	const mach_msg_type_t object_nameType = {
1628	/* msgt_name = */ 17,
1629	/* msgt_size = */ 32,
1630	/* msgt_number = */ 1,
1631	/* msgt_inline = */ TRUE((boolean_t) 1),
1632	/* msgt_longform = */ FALSE((boolean_t) 0),
1633	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1634	/* msgt_unused = */ 0
1635	};
1636
1637	const mach_msg_type_t offsetType = {
1638	/* msgt_name = */ 2,
1639	/* msgt_size = */ 32,
1640	/* msgt_number = */ 1,
1641	/* msgt_inline = */ TRUE((boolean_t) 1),
1642	/* msgt_longform = */ FALSE((boolean_t) 0),
1643	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1644	/* msgt_unused = */ 0
1645	};
1646
1647	vm_map_t target_task;
1648
1649	#if TypeCheck1
1650	if (mig_unlikely ((In0P->Head.msgh_size != 32) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
1651	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
1652	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1653	#endif /* TypeCheck */
1654
1655	#if TypeCheck1
1656	if (BAD_TYPECHECK(&In0P->addressType, &addressCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->addressType); _c.t = (& addressCheck);_t.w != _c.w; })), 0))
1657	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1658	#endif /* TypeCheck */
1659
1660	target_task = convert_port_to_map((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
1661
1662	OutP->RetCode = vm_region(target_task, &In0P->address, &OutP->size, &OutP->protection, &OutP->max_protection, &OutP->inheritance, &OutP->is_shared, &OutP->object_name, &OutP->offset);
1663	vm_map_deallocate(target_task);
1664	if (OutP->RetCode != KERN_SUCCESS0)
1665	return;
1666
1667	OutP->Head.msgh_bits \|= MACH_MSGH_BITS_COMPLEX0x80000000U;
1668	OutP->Head.msgh_size = 96;
1669
1670	OutP->addressType = addressType;
1671
1672	OutP->address = In0P->address;
1673
1674	OutP->sizeType = sizeType;
1675
1676	OutP->protectionType = protectionType;
1677
1678	OutP->max_protectionType = max_protectionType;
1679
1680	OutP->inheritanceType = inheritanceType;
1681
1682	OutP->is_sharedType = is_sharedType;
1683
1684	OutP->object_nameType = object_nameType;
1685
1686	OutP->offsetType = offsetType;
1687	}
1688
1689	/* Default implementation of vm_region */
1690	#ifdef MIG_EOPNOTSUPP
1691	kern_return_t __attribute__ ((weak))
1692	vm_region
1693	(
1694	vm_map_t target_task,
1695	vm_address_t *address,
1696	vm_size_t *size,
1697	vm_prot_t *protection,
1698	vm_prot_t *max_protection,
1699	vm_inherit_t *inheritance,
1700	boolean_t *is_shared,
1701	ipc_port_t *object_name,
1702	vm_offset_t *offset
1703	) { return MIG_EOPNOTSUPP; }
1704	#endif /* MIG_EOPNOTSUPP */
1705
1706	/* Routine vm_statistics */
1707	mig_internalstatic void _Xvm_statistics
1708	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
1709	{
1710	typedef struct {
1711	mach_msg_header_t Head;
1712	} Request;
1713
1714	typedef struct {
1715	mach_msg_header_t Head;
1716	mach_msg_type_t RetCodeType;
1717	kern_return_t RetCode;
1718	mach_msg_type_t vm_statsType;
1719	vm_statistics_data_t vm_stats;
1720	} Reply;
1721
1722	Request In0P = (Request ) InHeadP;
1723	Reply OutP = (Reply ) OutHeadP;
1724	mig_external kern_return_t vm_statistics
1725	(vm_map_t target_task, vm_statistics_data_t *vm_stats);
1726
1727	const mach_msg_type_t vm_statsType = {
1728	/* msgt_name = */ 2,
1729	/* msgt_size = */ 32,
1730	/* msgt_number = */ 13,
1731	/* msgt_inline = */ TRUE((boolean_t) 1),
1732	/* msgt_longform = */ FALSE((boolean_t) 0),
1733	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1734	/* msgt_unused = */ 0
1735	};
1736
1737	vm_map_t target_task;
1738
1739	#if TypeCheck1
1740	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
1741	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
1742	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1743	#endif /* TypeCheck */
1744
1745	target_task = convert_port_to_map((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
1746
1747	OutP->RetCode = vm_statistics(target_task, &OutP->vm_stats);
1748	vm_map_deallocate(target_task);
1749	if (OutP->RetCode != KERN_SUCCESS0)
1750	return;
1751
1752	OutP->Head.msgh_size = 88;
1753
1754	OutP->vm_statsType = vm_statsType;
1755	}
1756
1757	/* Default implementation of vm_statistics */
1758	#ifdef MIG_EOPNOTSUPP
1759	kern_return_t __attribute__ ((weak))
1760	vm_statistics
1761	(
1762	vm_map_t target_task,
1763	vm_statistics_data_t *vm_stats
1764	) { return MIG_EOPNOTSUPP; }
1765	#endif /* MIG_EOPNOTSUPP */
1766
1767	/* Routine mach_ports_register */
1768	mig_internalstatic void _Xmach_ports_register
1769	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
1770	{
1771	typedef struct {
1772	mach_msg_header_t Head;
1773	mach_msg_type_long_t init_port_setType;
1774	mach_port_array_t init_port_set;
1775	} Request;
1776
1777	typedef struct {
1778	mach_msg_header_t Head;
1779	mach_msg_type_t RetCodeType;
1780	kern_return_t RetCode;
1781	} Reply;
1782
1783	Request In0P = (Request ) InHeadP;
1784	Reply OutP = (Reply ) OutHeadP;
1785	mig_external kern_return_t mach_ports_register
1786	(task_t target_task, mach_port_array_t init_port_set, mach_msg_type_number_t init_port_setCnt);
1787
1788	task_t target_task;
1789
1790	#if TypeCheck1
1791	if (mig_unlikely ((In0P->Head.msgh_size != 40) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0)
1792	!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0))
1793	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1794	#endif /* TypeCheck */
1795
1796	#if TypeCheck1
1797	if (mig_unlikely ((In0P->init_port_setType.msgtl_header.msgt_inline != FALSE) \|\|__builtin_expect (!! ((In0P->init_port_setType.msgtl_header .msgt_inline != ((boolean_t) 0)) \|\| (In0P->init_port_setType .msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P-> init_port_setType.msgtl_name != 17) \|\| (In0P->init_port_setType .msgtl_size != 32)), 0)
1798	(In0P->init_port_setType.msgtl_header.msgt_longform != TRUE) \|\|__builtin_expect (!! ((In0P->init_port_setType.msgtl_header .msgt_inline != ((boolean_t) 0)) \|\| (In0P->init_port_setType .msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P-> init_port_setType.msgtl_name != 17) \|\| (In0P->init_port_setType .msgtl_size != 32)), 0)
1799	(In0P->init_port_setType.msgtl_name != 17) \|\|__builtin_expect (!! ((In0P->init_port_setType.msgtl_header .msgt_inline != ((boolean_t) 0)) \|\| (In0P->init_port_setType .msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P-> init_port_setType.msgtl_name != 17) \|\| (In0P->init_port_setType .msgtl_size != 32)), 0)
1800	(In0P->init_port_setType.msgtl_size != 32))__builtin_expect (!! ((In0P->init_port_setType.msgtl_header .msgt_inline != ((boolean_t) 0)) \|\| (In0P->init_port_setType .msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P-> init_port_setType.msgtl_name != 17) \|\| (In0P->init_port_setType .msgtl_size != 32)), 0))
1801	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1802	#endif /* TypeCheck */
1803
1804	target_task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
1805
1806	OutP->RetCode = mach_ports_register(target_task, In0P->init_port_set, In0P->init_port_setType.msgtl_number);
1807	task_deallocate(target_task);
1808	}
1809
1810	/* Default implementation of mach_ports_register */
1811	#ifdef MIG_EOPNOTSUPP
1812	kern_return_t __attribute__ ((weak))
1813	mach_ports_register
1814	(
1815	task_t target_task,
1816	mach_port_array_t init_port_set,
1817	mach_msg_type_number_t init_port_setCnt
1818	) { return MIG_EOPNOTSUPP; }
1819	#endif /* MIG_EOPNOTSUPP */
1820
1821	/* Routine mach_ports_lookup */
1822	mig_internalstatic void _Xmach_ports_lookup
1823	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
1824	{
1825	typedef struct {
1826	mach_msg_header_t Head;
1827	} Request;
1828
1829	typedef struct {
1830	mach_msg_header_t Head;
1831	mach_msg_type_t RetCodeType;
1832	kern_return_t RetCode;
1833	mach_msg_type_long_t init_port_setType;
1834	mach_port_array_t init_port_set;
1835	} Reply;
1836
1837	Request In0P = (Request ) InHeadP;
1838	Reply OutP = (Reply ) OutHeadP;
1839	mig_external kern_return_t mach_ports_lookup
1840	(task_t target_task, mach_port_array_t init_port_set, mach_msg_type_number_t init_port_setCnt);
1841
1842	const mach_msg_type_long_t init_port_setType = {
1843	{
1844	/* msgt_name = */ 0,
1845	/* msgt_size = */ 0,
1846	/* msgt_number = */ 0,
1847	/* msgt_inline = */ FALSE((boolean_t) 0),
1848	/* msgt_longform = */ TRUE((boolean_t) 1),
1849	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1850	/* msgt_unused = */ 0
1851	},
1852	/* msgtl_name = */ 17,
1853	/* msgtl_size = */ 32,
1854	/* msgtl_number = */ 0,
1855	};
1856
1857	task_t target_task;
1858	mach_msg_type_number_t init_port_setCnt;
1859
1860	#if TypeCheck1
1861	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
1862	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
1863	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1864	#endif /* TypeCheck */
1865
1866	target_task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
1867
1868	OutP->RetCode = mach_ports_lookup(target_task, &OutP->init_port_set, &init_port_setCnt);
1869	task_deallocate(target_task);
1870	if (OutP->RetCode != KERN_SUCCESS0)
1871	return;
1872
1873	OutP->Head.msgh_bits \|= MACH_MSGH_BITS_COMPLEX0x80000000U;
1874	OutP->Head.msgh_size = 48;
1875
1876	OutP->init_port_setType = init_port_setType;
1877
1878	OutP->init_port_setType.msgtl_number = init_port_setCnt;
1879	}
1880
1881	/* Default implementation of mach_ports_lookup */
1882	#ifdef MIG_EOPNOTSUPP
1883	kern_return_t __attribute__ ((weak))
1884	mach_ports_lookup
1885	(
1886	task_t target_task,
1887	mach_port_array_t *init_port_set,
1888	mach_msg_type_number_t *init_port_setCnt
1889	) { return MIG_EOPNOTSUPP; }
1890	#endif /* MIG_EOPNOTSUPP */
1891
1892	/* SimpleRoutine memory_object_data_provided */
1893	mig_internalstatic void _Xmemory_object_data_provided
1894	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
1895	{
1896	typedef struct {
1897	mach_msg_header_t Head;
1898	mach_msg_type_t offsetType;
1899	vm_offset_t offset;
1900	mach_msg_type_long_t dataType;
1901	vm_offset_t data;
1902	mach_msg_type_t lock_valueType;
1903	vm_prot_t lock_value;
1904	} Request;
1905
1906	typedef struct {
1907	mach_msg_header_t Head;
1908	mach_msg_type_t RetCodeType;
1909	kern_return_t RetCode;
1910	} Reply;
1911
1912	Request In0P = (Request ) InHeadP;
1913	Reply OutP = (Reply ) OutHeadP;
1914	mig_external kern_return_t memory_object_data_provided
1915	(vm_object_t memory_control, vm_offset_t offset, vm_offset_t data, mach_msg_type_number_t dataCnt, vm_prot_t lock_value);
1916
1917	const mach_msg_type_t offsetCheck = {
1918	/* msgt_name = */ 2,
1919	/* msgt_size = */ 32,
1920	/* msgt_number = */ 1,
1921	/* msgt_inline = */ TRUE((boolean_t) 1),
1922	/* msgt_longform = */ FALSE((boolean_t) 0),
1923	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1924	/* msgt_unused = */ 0
1925	};
1926
1927	const mach_msg_type_t lock_valueCheck = {
1928	/* msgt_name = */ 2,
1929	/* msgt_size = */ 32,
1930	/* msgt_number = */ 1,
1931	/* msgt_inline = */ TRUE((boolean_t) 1),
1932	/* msgt_longform = */ FALSE((boolean_t) 0),
1933	/* msgt_deallocate = */ FALSE((boolean_t) 0),
1934	/* msgt_unused = */ 0
1935	};
1936
1937	#if TypeCheck1
1938	if (mig_unlikely ((In0P->Head.msgh_size != 56) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 56) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0)
1939	!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 56) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0))
1940	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1941	#endif /* TypeCheck */
1942
1943	#if TypeCheck1
1944	if (BAD_TYPECHECK(&In0P->offsetType, &offsetCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->offsetType); _c.t = (& offsetCheck);_t.w != _c.w; })), 0))
1945	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1946	#endif /* TypeCheck */
1947
1948	#if TypeCheck1
1949	if (mig_unlikely ((In0P->dataType.msgtl_header.msgt_inline != FALSE) \|\|__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0)
1950	(In0P->dataType.msgtl_header.msgt_longform != TRUE) \|\|__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0)
1951	(In0P->dataType.msgtl_name != 9) \|\|__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0)
1952	(In0P->dataType.msgtl_size != 8))__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0))
1953	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1954	#endif /* TypeCheck */
1955
1956	#if TypeCheck1
1957	if (BAD_TYPECHECK(&In0P->lock_valueType, &lock_valueCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->lock_valueType); _c.t = (&lock_valueCheck);_t.w != _c.w; })), 0))
1958	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
1959	#endif /* TypeCheck */
1960
1961	OutP->RetCode = memory_object_data_provided(vm_object_lookup((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port), In0P->offset, In0P->data, In0P->dataType.msgtl_number, In0P->lock_value);
1962	}
1963
1964	/* Default implementation of memory_object_data_provided */
1965	#ifdef MIG_EOPNOTSUPP
1966	kern_return_t __attribute__ ((weak))
1967	memory_object_data_provided
1968	(
1969	vm_object_t memory_control,
1970	vm_offset_t offset,
1971	vm_offset_t data,
1972	mach_msg_type_number_t dataCnt,
1973	vm_prot_t lock_value
1974	) { return MIG_EOPNOTSUPP; }
1975	#endif /* MIG_EOPNOTSUPP */
1976
1977	/* SimpleRoutine memory_object_data_unavailable */
1978	mig_internalstatic void _Xmemory_object_data_unavailable
1979	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
1980	{
1981	typedef struct {
1982	mach_msg_header_t Head;
1983	mach_msg_type_t offsetType;
1984	vm_offset_t offset;
1985	mach_msg_type_t sizeType;
1986	vm_size_t size;
1987	} Request;
1988
1989	typedef struct {
1990	mach_msg_header_t Head;
1991	mach_msg_type_t RetCodeType;
1992	kern_return_t RetCode;
1993	} Reply;
1994
1995	Request In0P = (Request ) InHeadP;
1996	Reply OutP = (Reply ) OutHeadP;
1997	mig_external kern_return_t memory_object_data_unavailable
1998	(vm_object_t memory_control, vm_offset_t offset, vm_size_t size);
1999
2000	const mach_msg_type_t offsetCheck = {
2001	/* msgt_name = */ 2,
2002	/* msgt_size = */ 32,
2003	/* msgt_number = */ 1,
2004	/* msgt_inline = */ TRUE((boolean_t) 1),
2005	/* msgt_longform = */ FALSE((boolean_t) 0),
2006	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2007	/* msgt_unused = */ 0
2008	};
2009
2010	const mach_msg_type_t sizeCheck = {
2011	/* msgt_name = */ 2,
2012	/* msgt_size = */ 32,
2013	/* msgt_number = */ 1,
2014	/* msgt_inline = */ TRUE((boolean_t) 1),
2015	/* msgt_longform = */ FALSE((boolean_t) 0),
2016	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2017	/* msgt_unused = */ 0
2018	};
2019
2020	#if TypeCheck1
2021	if (mig_unlikely ((In0P->Head.msgh_size != 40) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
2022	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
2023	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2024	#endif /* TypeCheck */
2025
2026	#if TypeCheck1
2027	if (BAD_TYPECHECK(&In0P->offsetType, &offsetCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->offsetType); _c.t = (& offsetCheck);_t.w != _c.w; })), 0))
2028	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2029	#endif /* TypeCheck */
2030
2031	#if TypeCheck1
2032	if (BAD_TYPECHECK(&In0P->sizeType, &sizeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->sizeType); _c.t = (& sizeCheck);_t.w != _c.w; })), 0))
2033	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2034	#endif /* TypeCheck */
2035
2036	OutP->RetCode = memory_object_data_unavailable(vm_object_lookup((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port), In0P->offset, In0P->size);
2037	}
2038
2039	/* Default implementation of memory_object_data_unavailable */
2040	#ifdef MIG_EOPNOTSUPP
2041	kern_return_t __attribute__ ((weak))
2042	memory_object_data_unavailable
2043	(
2044	vm_object_t memory_control,
2045	vm_offset_t offset,
2046	vm_size_t size
2047	) { return MIG_EOPNOTSUPP; }
2048	#endif /* MIG_EOPNOTSUPP */
2049
2050	/* Routine memory_object_get_attributes */
2051	mig_internalstatic void _Xmemory_object_get_attributes
2052	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2053	{
2054	typedef struct {
2055	mach_msg_header_t Head;
2056	} Request;
2057
2058	typedef struct {
2059	mach_msg_header_t Head;
2060	mach_msg_type_t RetCodeType;
2061	kern_return_t RetCode;
2062	mach_msg_type_t object_readyType;
2063	boolean_t object_ready;
2064	mach_msg_type_t may_cacheType;
2065	boolean_t may_cache;
2066	mach_msg_type_t copy_strategyType;
2067	memory_object_copy_strategy_t copy_strategy;
2068	} Reply;
2069
2070	Request In0P = (Request ) InHeadP;
2071	Reply OutP = (Reply ) OutHeadP;
2072	mig_external kern_return_t memory_object_get_attributes
2073	(vm_object_t memory_control, boolean_t object_ready, boolean_t may_cache, memory_object_copy_strategy_t *copy_strategy);
2074
2075	const mach_msg_type_t object_readyType = {
2076	/* msgt_name = */ 0,
2077	/* msgt_size = */ 32,
2078	/* msgt_number = */ 1,
2079	/* msgt_inline = */ TRUE((boolean_t) 1),
2080	/* msgt_longform = */ FALSE((boolean_t) 0),
2081	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2082	/* msgt_unused = */ 0
2083	};
2084
2085	const mach_msg_type_t may_cacheType = {
2086	/* msgt_name = */ 0,
2087	/* msgt_size = */ 32,
2088	/* msgt_number = */ 1,
2089	/* msgt_inline = */ TRUE((boolean_t) 1),
2090	/* msgt_longform = */ FALSE((boolean_t) 0),
2091	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2092	/* msgt_unused = */ 0
2093	};
2094
2095	const mach_msg_type_t copy_strategyType = {
2096	/* msgt_name = */ 2,
2097	/* msgt_size = */ 32,
2098	/* msgt_number = */ 1,
2099	/* msgt_inline = */ TRUE((boolean_t) 1),
2100	/* msgt_longform = */ FALSE((boolean_t) 0),
2101	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2102	/* msgt_unused = */ 0
2103	};
2104
2105	#if TypeCheck1
2106	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
2107	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
2108	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2109	#endif /* TypeCheck */
2110
2111	OutP->RetCode = memory_object_get_attributes(vm_object_lookup((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port), &OutP->object_ready, &OutP->may_cache, &OutP->copy_strategy);
2112	if (OutP->RetCode != KERN_SUCCESS0)
2113	return;
2114
2115	OutP->Head.msgh_size = 56;
2116
2117	OutP->object_readyType = object_readyType;
2118
2119	OutP->may_cacheType = may_cacheType;
2120
2121	OutP->copy_strategyType = copy_strategyType;
2122	}
2123
2124	/* Default implementation of memory_object_get_attributes */
2125	#ifdef MIG_EOPNOTSUPP
2126	kern_return_t __attribute__ ((weak))
2127	memory_object_get_attributes
2128	(
2129	vm_object_t memory_control,
2130	boolean_t *object_ready,
2131	boolean_t *may_cache,
2132	memory_object_copy_strategy_t *copy_strategy
2133	) { return MIG_EOPNOTSUPP; }
2134	#endif /* MIG_EOPNOTSUPP */
2135
2136	/* Routine vm_set_default_memory_manager */
2137	mig_internalstatic void _Xvm_set_default_memory_manager
2138	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2139	{
2140	typedef struct {
2141	mach_msg_header_t Head;
2142	mach_msg_type_t default_managerType;
2143	ipc_port_t default_manager;
2144	} Request;
2145
2146	typedef struct {
2147	mach_msg_header_t Head;
2148	mach_msg_type_t RetCodeType;
2149	kern_return_t RetCode;
2150	mach_msg_type_t default_managerType;
2151	ipc_port_t default_manager;
2152	} Reply;
2153
2154	Request In0P = (Request ) InHeadP;
2155	Reply OutP = (Reply ) OutHeadP;
2156	mig_external kern_return_t vm_set_default_memory_manager
2157	(host_t host_priv, ipc_port_t *default_manager);
2158
2159	const mach_msg_type_t default_managerType = {
2160	/* msgt_name = */ 17,
2161	/* msgt_size = */ 32,
2162	/* msgt_number = */ 1,
2163	/* msgt_inline = */ TRUE((boolean_t) 1),
2164	/* msgt_longform = */ FALSE((boolean_t) 0),
2165	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2166	/* msgt_unused = */ 0
2167	};
2168
2169	#if TypeCheck1
2170	if (mig_unlikely ((In0P->Head.msgh_size != 32) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0)
2171	!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0))
2172	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2173	#endif /* TypeCheck */
2174
2175	#if TypeCheck1
2176	if (mig_unlikely ((In0P->default_managerType.msgt_inline != TRUE) \|\|__builtin_expect (!! ((In0P->default_managerType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->default_managerType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->default_managerType.msgt_name != 17) \|\| (In0P->default_managerType.msgt_number != 1) \|\| (In0P->default_managerType.msgt_size != 32)), 0)
2177	(In0P->default_managerType.msgt_longform != FALSE) \|\|__builtin_expect (!! ((In0P->default_managerType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->default_managerType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->default_managerType.msgt_name != 17) \|\| (In0P->default_managerType.msgt_number != 1) \|\| (In0P->default_managerType.msgt_size != 32)), 0)
2178	(In0P->default_managerType.msgt_name != 17) \|\|__builtin_expect (!! ((In0P->default_managerType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->default_managerType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->default_managerType.msgt_name != 17) \|\| (In0P->default_managerType.msgt_number != 1) \|\| (In0P->default_managerType.msgt_size != 32)), 0)
2179	(In0P->default_managerType.msgt_number != 1) \|\|__builtin_expect (!! ((In0P->default_managerType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->default_managerType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->default_managerType.msgt_name != 17) \|\| (In0P->default_managerType.msgt_number != 1) \|\| (In0P->default_managerType.msgt_size != 32)), 0)
2180	(In0P->default_managerType.msgt_size != 32))__builtin_expect (!! ((In0P->default_managerType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->default_managerType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->default_managerType.msgt_name != 17) \|\| (In0P->default_managerType.msgt_number != 1) \|\| (In0P->default_managerType.msgt_size != 32)), 0))
2181	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2182	#endif /* TypeCheck */
2183
2184	OutP->RetCode = vm_set_default_memory_manager(convert_port_to_host_priv((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port), &In0P->default_manager);
2185	if (OutP->RetCode != KERN_SUCCESS0)
2186	return;
2187
2188	OutP->Head.msgh_bits \|= MACH_MSGH_BITS_COMPLEX0x80000000U;
2189	OutP->Head.msgh_size = 40;
2190
2191	OutP->default_managerType = default_managerType;
2192
2193	OutP->default_manager = In0P->default_manager;
2194	}
2195
2196	/* Default implementation of vm_set_default_memory_manager */
2197	#ifdef MIG_EOPNOTSUPP
2198	kern_return_t __attribute__ ((weak))
2199	vm_set_default_memory_manager
2200	(
2201	host_t host_priv,
2202	ipc_port_t *default_manager
2203	) { return MIG_EOPNOTSUPP; }
2204	#endif /* MIG_EOPNOTSUPP */
2205
2206	/* SimpleRoutine memory_object_lock_request */
2207	mig_internalstatic void _Xmemory_object_lock_request
2208	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2209	{
2210	typedef struct {
2211	mach_msg_header_t Head;
2212	mach_msg_type_t offsetType;
2213	vm_offset_t offset;
2214	mach_msg_type_t sizeType;
2215	vm_size_t size;
2216	mach_msg_type_t should_returnType;
2217	memory_object_return_t should_return;
2218	mach_msg_type_t should_flushType;
2219	boolean_t should_flush;
2220	mach_msg_type_t lock_valueType;
2221	vm_prot_t lock_value;
2222	mach_msg_type_t reply_toType;
2223	ipc_port_t reply_to;
2224	} Request;
2225
2226	typedef struct {
2227	mach_msg_header_t Head;
2228	mach_msg_type_t RetCodeType;
2229	kern_return_t RetCode;
2230	} Reply;
2231
2232	Request In0P = (Request ) InHeadP;
2233	Reply OutP = (Reply ) OutHeadP;
2234	mig_external kern_return_t memory_object_lock_request
2235	(vm_object_t memory_control, vm_offset_t offset, vm_size_t size, memory_object_return_t should_return, boolean_t should_flush, vm_prot_t lock_value, ipc_port_t reply_to, mach_msg_type_name_t reply_toPoly);
2236
2237	#if TypeCheck1
2238	boolean_t msgh_simple = msgh_simple;
2239	#endif /* TypeCheck */
2240
2241	const mach_msg_type_t offsetCheck = {
2242	/* msgt_name = */ 2,
2243	/* msgt_size = */ 32,
2244	/* msgt_number = */ 1,
2245	/* msgt_inline = */ TRUE((boolean_t) 1),
2246	/* msgt_longform = */ FALSE((boolean_t) 0),
2247	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2248	/* msgt_unused = */ 0
2249	};
2250
2251	const mach_msg_type_t sizeCheck = {
2252	/* msgt_name = */ 2,
2253	/* msgt_size = */ 32,
2254	/* msgt_number = */ 1,
2255	/* msgt_inline = */ TRUE((boolean_t) 1),
2256	/* msgt_longform = */ FALSE((boolean_t) 0),
2257	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2258	/* msgt_unused = */ 0
2259	};
2260
2261	const mach_msg_type_t should_returnCheck = {
2262	/* msgt_name = */ 2,
2263	/* msgt_size = */ 32,
2264	/* msgt_number = */ 1,
2265	/* msgt_inline = */ TRUE((boolean_t) 1),
2266	/* msgt_longform = */ FALSE((boolean_t) 0),
2267	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2268	/* msgt_unused = */ 0
2269	};
2270
2271	const mach_msg_type_t should_flushCheck = {
2272	/* msgt_name = */ 0,
2273	/* msgt_size = */ 32,
2274	/* msgt_number = */ 1,
2275	/* msgt_inline = */ TRUE((boolean_t) 1),
2276	/* msgt_longform = */ FALSE((boolean_t) 0),
2277	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2278	/* msgt_unused = */ 0
2279	};
2280
2281	const mach_msg_type_t lock_valueCheck = {
2282	/* msgt_name = */ 2,
2283	/* msgt_size = */ 32,
2284	/* msgt_number = */ 1,
2285	/* msgt_inline = */ TRUE((boolean_t) 1),
2286	/* msgt_longform = */ FALSE((boolean_t) 0),
2287	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2288	/* msgt_unused = */ 0
2289	};
2290
2291	#if TypeCheck1
2292	msgh_simple = !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX0x80000000U);
2293	if (mig_unlikely ((In0P->Head.msgh_size != 72))__builtin_expect (!! ((In0P->Head.msgh_size != 72)), 0))
2294	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2295	#endif /* TypeCheck */
2296
2297	#if TypeCheck1
2298	if (BAD_TYPECHECK(&In0P->offsetType, &offsetCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->offsetType); _c.t = (& offsetCheck);_t.w != _c.w; })), 0))
2299	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2300	#endif /* TypeCheck */
2301
2302	#if TypeCheck1
2303	if (BAD_TYPECHECK(&In0P->sizeType, &sizeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->sizeType); _c.t = (& sizeCheck);_t.w != _c.w; })), 0))
2304	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2305	#endif /* TypeCheck */
2306
2307	#if TypeCheck1
2308	if (BAD_TYPECHECK(&In0P->should_returnType, &should_returnCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->should_returnType); _c.t = (&should_returnCheck);_t.w != _c.w; })), 0))
2309	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2310	#endif /* TypeCheck */
2311
2312	#if TypeCheck1
2313	if (BAD_TYPECHECK(&In0P->should_flushType, &should_flushCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->should_flushType); _c.t = (&should_flushCheck);_t.w != _c.w; })), 0))
2314	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2315	#endif /* TypeCheck */
2316
2317	#if TypeCheck1
2318	if (BAD_TYPECHECK(&In0P->lock_valueType, &lock_valueCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->lock_valueType); _c.t = (&lock_valueCheck);_t.w != _c.w; })), 0))
2319	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2320	#endif /* TypeCheck */
2321
2322	#if TypeCheck1
2323	if (mig_unlikely ((In0P->reply_toType.msgt_inline != TRUE) \|\|__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| ((((In0P->reply_toType.msgt_name) >= 16 ) && ((In0P->reply_toType.msgt_name) <= 21)) && msgh_simple) \|\| (In0P->reply_toType.msgt_number != 1) \|\| ( In0P->reply_toType.msgt_size != 32)), 0)
2324	(In0P->reply_toType.msgt_longform != FALSE) \|\|__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| ((((In0P->reply_toType.msgt_name) >= 16 ) && ((In0P->reply_toType.msgt_name) <= 21)) && msgh_simple) \|\| (In0P->reply_toType.msgt_number != 1) \|\| ( In0P->reply_toType.msgt_size != 32)), 0)
2325	(MACH_MSG_TYPE_PORT_ANY(In0P->reply_toType.msgt_name) && msgh_simple) \|\|__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| ((((In0P->reply_toType.msgt_name) >= 16 ) && ((In0P->reply_toType.msgt_name) <= 21)) && msgh_simple) \|\| (In0P->reply_toType.msgt_number != 1) \|\| ( In0P->reply_toType.msgt_size != 32)), 0)
2326	(In0P->reply_toType.msgt_number != 1) \|\|__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| ((((In0P->reply_toType.msgt_name) >= 16 ) && ((In0P->reply_toType.msgt_name) <= 21)) && msgh_simple) \|\| (In0P->reply_toType.msgt_number != 1) \|\| ( In0P->reply_toType.msgt_size != 32)), 0)
2327	(In0P->reply_toType.msgt_size != 32))__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| ((((In0P->reply_toType.msgt_name) >= 16 ) && ((In0P->reply_toType.msgt_name) <= 21)) && msgh_simple) \|\| (In0P->reply_toType.msgt_number != 1) \|\| ( In0P->reply_toType.msgt_size != 32)), 0))
2328	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2329	#endif /* TypeCheck */
2330
2331	OutP->RetCode = memory_object_lock_request(vm_object_lookup((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port), In0P->offset, In0P->size, In0P->should_return, In0P->should_flush, In0P->lock_value, In0P->reply_to, In0P->reply_toType.msgt_name);
2332	}
2333
2334	/* Default implementation of memory_object_lock_request */
2335	#ifdef MIG_EOPNOTSUPP
2336	kern_return_t __attribute__ ((weak))
2337	memory_object_lock_request
2338	(
2339	vm_object_t memory_control,
2340	vm_offset_t offset,
2341	vm_size_t size,
2342	memory_object_return_t should_return,
2343	boolean_t should_flush,
2344	vm_prot_t lock_value,
2345	ipc_port_t reply_to,
2346	mach_msg_type_name_t reply_toPoly
2347	) { return MIG_EOPNOTSUPP; }
2348	#endif /* MIG_EOPNOTSUPP */
2349
2350	/* Routine task_suspend */
2351	mig_internalstatic void _Xtask_suspend
2352	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2353	{
2354	typedef struct {
2355	mach_msg_header_t Head;
2356	} Request;
2357
2358	typedef struct {
2359	mach_msg_header_t Head;
2360	mach_msg_type_t RetCodeType;
2361	kern_return_t RetCode;
2362	} Reply;
2363
2364	Request In0P = (Request ) InHeadP;
2365	Reply OutP = (Reply ) OutHeadP;
2366	mig_external kern_return_t task_suspend
2367	(task_t target_task);
2368
2369	task_t target_task;
2370
2371	#if TypeCheck1
2372	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
2373	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
2374	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2375	#endif /* TypeCheck */
2376
2377	target_task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
2378
2379	OutP->RetCode = task_suspend(target_task);
2380	task_deallocate(target_task);
2381	}
2382
2383	/* Default implementation of task_suspend */
2384	#ifdef MIG_EOPNOTSUPP
2385	kern_return_t __attribute__ ((weak))
2386	task_suspend
2387	(
2388	task_t target_task
2389	) { return MIG_EOPNOTSUPP; }
2390	#endif /* MIG_EOPNOTSUPP */
2391
2392	/* Routine task_resume */
2393	mig_internalstatic void _Xtask_resume
2394	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2395	{
2396	typedef struct {
2397	mach_msg_header_t Head;
2398	} Request;
2399
2400	typedef struct {
2401	mach_msg_header_t Head;
2402	mach_msg_type_t RetCodeType;
2403	kern_return_t RetCode;
2404	} Reply;
2405
2406	Request In0P = (Request ) InHeadP;
2407	Reply OutP = (Reply ) OutHeadP;
2408	mig_external kern_return_t task_resume
2409	(task_t target_task);
2410
2411	task_t target_task;
2412
2413	#if TypeCheck1
2414	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
2415	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
2416	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2417	#endif /* TypeCheck */
2418
2419	target_task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
2420
2421	OutP->RetCode = task_resume(target_task);
2422	task_deallocate(target_task);
2423	}
2424
2425	/* Default implementation of task_resume */
2426	#ifdef MIG_EOPNOTSUPP
2427	kern_return_t __attribute__ ((weak))
2428	task_resume
2429	(
2430	task_t target_task
2431	) { return MIG_EOPNOTSUPP; }
2432	#endif /* MIG_EOPNOTSUPP */
2433
2434	/* Routine task_get_special_port */
2435	mig_internalstatic void _Xtask_get_special_port
2436	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2437	{
2438	typedef struct {
2439	mach_msg_header_t Head;
2440	mach_msg_type_t which_portType;
2441	int which_port;
2442	} Request;
2443
2444	typedef struct {
2445	mach_msg_header_t Head;
2446	mach_msg_type_t RetCodeType;
2447	kern_return_t RetCode;
2448	mach_msg_type_t special_portType;
2449	ipc_port_t special_port;
2450	} Reply;
2451
2452	Request In0P = (Request ) InHeadP;
2453	Reply OutP = (Reply ) OutHeadP;
2454	mig_external kern_return_t task_get_special_port
2455	(task_t task, int which_port, ipc_port_t *special_port);
2456
2457	const mach_msg_type_t which_portCheck = {
2458	/* msgt_name = */ 2,
2459	/* msgt_size = */ 32,
2460	/* msgt_number = */ 1,
2461	/* msgt_inline = */ TRUE((boolean_t) 1),
2462	/* msgt_longform = */ FALSE((boolean_t) 0),
2463	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2464	/* msgt_unused = */ 0
2465	};
2466
2467	const mach_msg_type_t special_portType = {
2468	/* msgt_name = */ 17,
2469	/* msgt_size = */ 32,
2470	/* msgt_number = */ 1,
2471	/* msgt_inline = */ TRUE((boolean_t) 1),
2472	/* msgt_longform = */ FALSE((boolean_t) 0),
2473	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2474	/* msgt_unused = */ 0
2475	};
2476
2477	task_t task;
2478
2479	#if TypeCheck1
2480	if (mig_unlikely ((In0P->Head.msgh_size != 32) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
2481	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
2482	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2483	#endif /* TypeCheck */
2484
2485	#if TypeCheck1
2486	if (BAD_TYPECHECK(&In0P->which_portType, &which_portCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->which_portType); _c.t = (&which_portCheck);_t.w != _c.w; })), 0))
2487	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2488	#endif /* TypeCheck */
2489
2490	task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
2491
2492	OutP->RetCode = task_get_special_port(task, In0P->which_port, &OutP->special_port);
2493	task_deallocate(task);
2494	if (OutP->RetCode != KERN_SUCCESS0)
2495	return;
2496
2497	OutP->Head.msgh_bits \|= MACH_MSGH_BITS_COMPLEX0x80000000U;
2498	OutP->Head.msgh_size = 40;
2499
2500	OutP->special_portType = special_portType;
2501	}
2502
2503	/* Default implementation of task_get_special_port */
2504	#ifdef MIG_EOPNOTSUPP
2505	kern_return_t __attribute__ ((weak))
2506	task_get_special_port
2507	(
2508	task_t task,
2509	int which_port,
2510	ipc_port_t *special_port
2511	) { return MIG_EOPNOTSUPP; }
2512	#endif /* MIG_EOPNOTSUPP */
2513
2514	/* Routine task_set_special_port */
2515	mig_internalstatic void _Xtask_set_special_port
2516	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2517	{
2518	typedef struct {
2519	mach_msg_header_t Head;
2520	mach_msg_type_t which_portType;
2521	int which_port;
2522	mach_msg_type_t special_portType;
2523	ipc_port_t special_port;
2524	} Request;
2525
2526	typedef struct {
2527	mach_msg_header_t Head;
2528	mach_msg_type_t RetCodeType;
2529	kern_return_t RetCode;
2530	} Reply;
2531
2532	Request In0P = (Request ) InHeadP;
2533	Reply OutP = (Reply ) OutHeadP;
2534	mig_external kern_return_t task_set_special_port
2535	(task_t task, int which_port, ipc_port_t special_port);
2536
2537	const mach_msg_type_t which_portCheck = {
2538	/* msgt_name = */ 2,
2539	/* msgt_size = */ 32,
2540	/* msgt_number = */ 1,
2541	/* msgt_inline = */ TRUE((boolean_t) 1),
2542	/* msgt_longform = */ FALSE((boolean_t) 0),
2543	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2544	/* msgt_unused = */ 0
2545	};
2546
2547	task_t task;
2548
2549	#if TypeCheck1
2550	if (mig_unlikely ((In0P->Head.msgh_size != 40) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0)
2551	!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0))
2552	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2553	#endif /* TypeCheck */
2554
2555	#if TypeCheck1
2556	if (BAD_TYPECHECK(&In0P->which_portType, &which_portCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->which_portType); _c.t = (&which_portCheck);_t.w != _c.w; })), 0))
2557	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2558	#endif /* TypeCheck */
2559
2560	#if TypeCheck1
2561	if (mig_unlikely ((In0P->special_portType.msgt_inline != TRUE) \|\|__builtin_expect (!! ((In0P->special_portType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->special_portType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->special_portType.msgt_name != 17) \|\| (In0P->special_portType.msgt_number != 1) \|\| (In0P ->special_portType.msgt_size != 32)), 0)
2562	(In0P->special_portType.msgt_longform != FALSE) \|\|__builtin_expect (!! ((In0P->special_portType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->special_portType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->special_portType.msgt_name != 17) \|\| (In0P->special_portType.msgt_number != 1) \|\| (In0P ->special_portType.msgt_size != 32)), 0)
2563	(In0P->special_portType.msgt_name != 17) \|\|__builtin_expect (!! ((In0P->special_portType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->special_portType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->special_portType.msgt_name != 17) \|\| (In0P->special_portType.msgt_number != 1) \|\| (In0P ->special_portType.msgt_size != 32)), 0)
2564	(In0P->special_portType.msgt_number != 1) \|\|__builtin_expect (!! ((In0P->special_portType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->special_portType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->special_portType.msgt_name != 17) \|\| (In0P->special_portType.msgt_number != 1) \|\| (In0P ->special_portType.msgt_size != 32)), 0)
2565	(In0P->special_portType.msgt_size != 32))__builtin_expect (!! ((In0P->special_portType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->special_portType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->special_portType.msgt_name != 17) \|\| (In0P->special_portType.msgt_number != 1) \|\| (In0P ->special_portType.msgt_size != 32)), 0))
2566	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2567	#endif /* TypeCheck */
2568
2569	task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
2570
2571	OutP->RetCode = task_set_special_port(task, In0P->which_port, In0P->special_port);
2572	task_deallocate(task);
2573	}
2574
2575	/* Default implementation of task_set_special_port */
2576	#ifdef MIG_EOPNOTSUPP
2577	kern_return_t __attribute__ ((weak))
2578	task_set_special_port
2579	(
2580	task_t task,
2581	int which_port,
2582	ipc_port_t special_port
2583	) { return MIG_EOPNOTSUPP; }
2584	#endif /* MIG_EOPNOTSUPP */
2585
2586	/* Routine thread_create */
2587	mig_internalstatic void _Xthread_create
2588	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2589	{
2590	typedef struct {
2591	mach_msg_header_t Head;
2592	} Request;
2593
2594	typedef struct {
2595	mach_msg_header_t Head;
2596	mach_msg_type_t RetCodeType;
2597	kern_return_t RetCode;
2598	mach_msg_type_t child_threadType;
2599	ipc_port_t child_thread;
2600	} Reply;
2601
2602	Request In0P = (Request ) InHeadP;
2603	Reply OutP = (Reply ) OutHeadP;
2604	mig_external kern_return_t thread_create
2605	(task_t parent_task, thread_t *child_thread);
2606
2607	const mach_msg_type_t child_threadType = {
2608	/* msgt_name = */ 17,
2609	/* msgt_size = */ 32,
2610	/* msgt_number = */ 1,
2611	/* msgt_inline = */ TRUE((boolean_t) 1),
2612	/* msgt_longform = */ FALSE((boolean_t) 0),
2613	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2614	/* msgt_unused = */ 0
2615	};
2616
2617	task_t parent_task;
2618	thread_t child_thread;
2619
2620	#if TypeCheck1
2621	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
2622	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
2623	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2624	#endif /* TypeCheck */
2625
2626	parent_task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
2627
2628	OutP->RetCode = thread_create(parent_task, &child_thread);
2629	task_deallocate(parent_task);
2630	if (OutP->RetCode != KERN_SUCCESS0)
2631	return;
2632
2633	OutP->Head.msgh_bits \|= MACH_MSGH_BITS_COMPLEX0x80000000U;
2634	OutP->Head.msgh_size = 40;
2635
2636	OutP->child_threadType = child_threadType;
2637
2638	OutP->child_thread = convert_thread_to_port(child_thread);
2639	}
2640
2641	/* Default implementation of thread_create */
2642	#ifdef MIG_EOPNOTSUPP
2643	kern_return_t __attribute__ ((weak))
2644	thread_create
2645	(
2646	task_t parent_task,
2647	thread_t *child_thread
2648	) { return MIG_EOPNOTSUPP; }
2649	#endif /* MIG_EOPNOTSUPP */
2650
2651	/* Routine thread_suspend */
2652	mig_internalstatic void _Xthread_suspend
2653	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2654	{
2655	typedef struct {
2656	mach_msg_header_t Head;
2657	} Request;
2658
2659	typedef struct {
2660	mach_msg_header_t Head;
2661	mach_msg_type_t RetCodeType;
2662	kern_return_t RetCode;
2663	} Reply;
2664
2665	Request In0P = (Request ) InHeadP;
2666	Reply OutP = (Reply ) OutHeadP;
2667	mig_external kern_return_t thread_suspend
2668	(thread_t target_thread);
2669
2670	thread_t target_thread;
2671
2672	#if TypeCheck1
2673	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
2674	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
2675	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2676	#endif /* TypeCheck */
2677
2678	target_thread = convert_port_to_thread((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
2679
2680	OutP->RetCode = thread_suspend(target_thread);
2681	thread_deallocate(target_thread);
2682	}
2683
2684	/* Default implementation of thread_suspend */
2685	#ifdef MIG_EOPNOTSUPP
2686	kern_return_t __attribute__ ((weak))
2687	thread_suspend
2688	(
2689	thread_t target_thread
2690	) { return MIG_EOPNOTSUPP; }
2691	#endif /* MIG_EOPNOTSUPP */
2692
2693	/* Routine thread_resume */
2694	mig_internalstatic void _Xthread_resume
2695	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2696	{
2697	typedef struct {
2698	mach_msg_header_t Head;
2699	} Request;
2700
2701	typedef struct {
2702	mach_msg_header_t Head;
2703	mach_msg_type_t RetCodeType;
2704	kern_return_t RetCode;
2705	} Reply;
2706
2707	Request In0P = (Request ) InHeadP;
2708	Reply OutP = (Reply ) OutHeadP;
2709	mig_external kern_return_t thread_resume
2710	(thread_t target_thread);
2711
2712	thread_t target_thread;
2713
2714	#if TypeCheck1
2715	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
2716	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
2717	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2718	#endif /* TypeCheck */
2719
2720	target_thread = convert_port_to_thread((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
2721
2722	OutP->RetCode = thread_resume(target_thread);
2723	thread_deallocate(target_thread);
2724	}
2725
2726	/* Default implementation of thread_resume */
2727	#ifdef MIG_EOPNOTSUPP
2728	kern_return_t __attribute__ ((weak))
2729	thread_resume
2730	(
2731	thread_t target_thread
2732	) { return MIG_EOPNOTSUPP; }
2733	#endif /* MIG_EOPNOTSUPP */
2734
2735	/* Routine thread_abort */
2736	mig_internalstatic void _Xthread_abort
2737	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2738	{
2739	typedef struct {
2740	mach_msg_header_t Head;
2741	} Request;
2742
2743	typedef struct {
2744	mach_msg_header_t Head;
2745	mach_msg_type_t RetCodeType;
2746	kern_return_t RetCode;
2747	} Reply;
2748
2749	Request In0P = (Request ) InHeadP;
2750	Reply OutP = (Reply ) OutHeadP;
2751	mig_external kern_return_t thread_abort
2752	(thread_t target_thread);
2753
2754	thread_t target_thread;
2755
2756	#if TypeCheck1
2757	if (mig_unlikely ((In0P->Head.msgh_size != 24) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
2758	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 24) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
2759	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2760	#endif /* TypeCheck */
2761
2762	target_thread = convert_port_to_thread((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
2763
2764	OutP->RetCode = thread_abort(target_thread);
2765	thread_deallocate(target_thread);
2766	}
2767
2768	/* Default implementation of thread_abort */
2769	#ifdef MIG_EOPNOTSUPP
2770	kern_return_t __attribute__ ((weak))
2771	thread_abort
2772	(
2773	thread_t target_thread
2774	) { return MIG_EOPNOTSUPP; }
2775	#endif /* MIG_EOPNOTSUPP */
2776
2777	/* Routine thread_get_special_port */
2778	mig_internalstatic void _Xthread_get_special_port
2779	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2780	{
2781	typedef struct {
2782	mach_msg_header_t Head;
2783	mach_msg_type_t which_portType;
2784	int which_port;
2785	} Request;
2786
2787	typedef struct {
2788	mach_msg_header_t Head;
2789	mach_msg_type_t RetCodeType;
2790	kern_return_t RetCode;
2791	mach_msg_type_t special_portType;
2792	ipc_port_t special_port;
2793	} Reply;
2794
2795	Request In0P = (Request ) InHeadP;
2796	Reply OutP = (Reply ) OutHeadP;
2797	mig_external kern_return_t thread_get_special_port
2798	(thread_t thread, int which_port, ipc_port_t *special_port);
2799
2800	const mach_msg_type_t which_portCheck = {
2801	/* msgt_name = */ 2,
2802	/* msgt_size = */ 32,
2803	/* msgt_number = */ 1,
2804	/* msgt_inline = */ TRUE((boolean_t) 1),
2805	/* msgt_longform = */ FALSE((boolean_t) 0),
2806	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2807	/* msgt_unused = */ 0
2808	};
2809
2810	const mach_msg_type_t special_portType = {
2811	/* msgt_name = */ 17,
2812	/* msgt_size = */ 32,
2813	/* msgt_number = */ 1,
2814	/* msgt_inline = */ TRUE((boolean_t) 1),
2815	/* msgt_longform = */ FALSE((boolean_t) 0),
2816	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2817	/* msgt_unused = */ 0
2818	};
2819
2820	thread_t thread;
2821
2822	#if TypeCheck1
2823	if (mig_unlikely ((In0P->Head.msgh_size != 32) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
2824	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
2825	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2826	#endif /* TypeCheck */
2827
2828	#if TypeCheck1
2829	if (BAD_TYPECHECK(&In0P->which_portType, &which_portCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->which_portType); _c.t = (&which_portCheck);_t.w != _c.w; })), 0))
2830	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2831	#endif /* TypeCheck */
2832
2833	thread = convert_port_to_thread((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
2834
2835	OutP->RetCode = thread_get_special_port(thread, In0P->which_port, &OutP->special_port);
2836	thread_deallocate(thread);
2837	if (OutP->RetCode != KERN_SUCCESS0)
2838	return;
2839
2840	OutP->Head.msgh_bits \|= MACH_MSGH_BITS_COMPLEX0x80000000U;
2841	OutP->Head.msgh_size = 40;
2842
2843	OutP->special_portType = special_portType;
2844	}
2845
2846	/* Default implementation of thread_get_special_port */
2847	#ifdef MIG_EOPNOTSUPP
2848	kern_return_t __attribute__ ((weak))
2849	thread_get_special_port
2850	(
2851	thread_t thread,
2852	int which_port,
2853	ipc_port_t *special_port
2854	) { return MIG_EOPNOTSUPP; }
2855	#endif /* MIG_EOPNOTSUPP */
2856
2857	/* Routine thread_set_special_port */
2858	mig_internalstatic void _Xthread_set_special_port
2859	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2860	{
2861	typedef struct {
2862	mach_msg_header_t Head;
2863	mach_msg_type_t which_portType;
2864	int which_port;
2865	mach_msg_type_t special_portType;
2866	ipc_port_t special_port;
2867	} Request;
2868
2869	typedef struct {
2870	mach_msg_header_t Head;
2871	mach_msg_type_t RetCodeType;
2872	kern_return_t RetCode;
2873	} Reply;
2874
2875	Request In0P = (Request ) InHeadP;
2876	Reply OutP = (Reply ) OutHeadP;
2877	mig_external kern_return_t thread_set_special_port
2878	(thread_t thread, int which_port, ipc_port_t special_port);
2879
2880	const mach_msg_type_t which_portCheck = {
2881	/* msgt_name = */ 2,
2882	/* msgt_size = */ 32,
2883	/* msgt_number = */ 1,
2884	/* msgt_inline = */ TRUE((boolean_t) 1),
2885	/* msgt_longform = */ FALSE((boolean_t) 0),
2886	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2887	/* msgt_unused = */ 0
2888	};
2889
2890	thread_t thread;
2891
2892	#if TypeCheck1
2893	if (mig_unlikely ((In0P->Head.msgh_size != 40) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0)
2894	!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0))
2895	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2896	#endif /* TypeCheck */
2897
2898	#if TypeCheck1
2899	if (BAD_TYPECHECK(&In0P->which_portType, &which_portCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->which_portType); _c.t = (&which_portCheck);_t.w != _c.w; })), 0))
2900	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2901	#endif /* TypeCheck */
2902
2903	#if TypeCheck1
2904	if (mig_unlikely ((In0P->special_portType.msgt_inline != TRUE) \|\|__builtin_expect (!! ((In0P->special_portType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->special_portType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->special_portType.msgt_name != 17) \|\| (In0P->special_portType.msgt_number != 1) \|\| (In0P ->special_portType.msgt_size != 32)), 0)
2905	(In0P->special_portType.msgt_longform != FALSE) \|\|__builtin_expect (!! ((In0P->special_portType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->special_portType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->special_portType.msgt_name != 17) \|\| (In0P->special_portType.msgt_number != 1) \|\| (In0P ->special_portType.msgt_size != 32)), 0)
2906	(In0P->special_portType.msgt_name != 17) \|\|__builtin_expect (!! ((In0P->special_portType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->special_portType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->special_portType.msgt_name != 17) \|\| (In0P->special_portType.msgt_number != 1) \|\| (In0P ->special_portType.msgt_size != 32)), 0)
2907	(In0P->special_portType.msgt_number != 1) \|\|__builtin_expect (!! ((In0P->special_portType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->special_portType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->special_portType.msgt_name != 17) \|\| (In0P->special_portType.msgt_number != 1) \|\| (In0P ->special_portType.msgt_size != 32)), 0)
2908	(In0P->special_portType.msgt_size != 32))__builtin_expect (!! ((In0P->special_portType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->special_portType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->special_portType.msgt_name != 17) \|\| (In0P->special_portType.msgt_number != 1) \|\| (In0P ->special_portType.msgt_size != 32)), 0))
2909	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2910	#endif /* TypeCheck */
2911
2912	thread = convert_port_to_thread((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
2913
2914	OutP->RetCode = thread_set_special_port(thread, In0P->which_port, In0P->special_port);
2915	thread_deallocate(thread);
2916	}
2917
2918	/* Default implementation of thread_set_special_port */
2919	#ifdef MIG_EOPNOTSUPP
2920	kern_return_t __attribute__ ((weak))
2921	thread_set_special_port
2922	(
2923	thread_t thread,
2924	int which_port,
2925	ipc_port_t special_port
2926	) { return MIG_EOPNOTSUPP; }
2927	#endif /* MIG_EOPNOTSUPP */
2928
2929	/* Routine task_set_emulation */
2930	mig_internalstatic void _Xtask_set_emulation
2931	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
2932	{
2933	typedef struct {
2934	mach_msg_header_t Head;
2935	mach_msg_type_t routine_entry_ptType;
2936	vm_address_t routine_entry_pt;
2937	mach_msg_type_t routine_numberType;
2938	int routine_number;
2939	} Request;
2940
2941	typedef struct {
2942	mach_msg_header_t Head;
2943	mach_msg_type_t RetCodeType;
2944	kern_return_t RetCode;
2945	} Reply;
2946
2947	Request In0P = (Request ) InHeadP;
2948	Reply OutP = (Reply ) OutHeadP;
2949	mig_external kern_return_t task_set_emulation
2950	(task_t target_port, vm_address_t routine_entry_pt, int routine_number);
2951
2952	const mach_msg_type_t routine_entry_ptCheck = {
2953	/* msgt_name = */ 2,
2954	/* msgt_size = */ 32,
2955	/* msgt_number = */ 1,
2956	/* msgt_inline = */ TRUE((boolean_t) 1),
2957	/* msgt_longform = */ FALSE((boolean_t) 0),
2958	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2959	/* msgt_unused = */ 0
2960	};
2961
2962	const mach_msg_type_t routine_numberCheck = {
2963	/* msgt_name = */ 2,
2964	/* msgt_size = */ 32,
2965	/* msgt_number = */ 1,
2966	/* msgt_inline = */ TRUE((boolean_t) 1),
2967	/* msgt_longform = */ FALSE((boolean_t) 0),
2968	/* msgt_deallocate = */ FALSE((boolean_t) 0),
2969	/* msgt_unused = */ 0
2970	};
2971
2972	task_t target_port;
2973
2974	#if TypeCheck1
2975	if (mig_unlikely ((In0P->Head.msgh_size != 40) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
2976	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
2977	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2978	#endif /* TypeCheck */
2979
2980	#if TypeCheck1
2981	if (BAD_TYPECHECK(&In0P->routine_entry_ptType, &routine_entry_ptCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->routine_entry_ptType); _c .t = (&routine_entry_ptCheck);_t.w != _c.w; })), 0))
2982	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2983	#endif /* TypeCheck */
2984
2985	#if TypeCheck1
2986	if (BAD_TYPECHECK(&In0P->routine_numberType, &routine_numberCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->routine_numberType); _c. t = (&routine_numberCheck);_t.w != _c.w; })), 0))
2987	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
2988	#endif /* TypeCheck */
2989
2990	target_port = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
2991
2992	OutP->RetCode = task_set_emulation(target_port, In0P->routine_entry_pt, In0P->routine_number);
2993	task_deallocate(target_port);
2994	}
2995
2996	/* Default implementation of task_set_emulation */
2997	#ifdef MIG_EOPNOTSUPP
2998	kern_return_t __attribute__ ((weak))
2999	task_set_emulation
3000	(
3001	task_t target_port,
3002	vm_address_t routine_entry_pt,
3003	int routine_number
3004	) { return MIG_EOPNOTSUPP; }
3005	#endif /* MIG_EOPNOTSUPP */
3006
3007	/* Routine task_ras_control */
3008	mig_internalstatic void _Xtask_ras_control
3009	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
3010	{
3011	typedef struct {
3012	mach_msg_header_t Head;
3013	mach_msg_type_t basepcType;
3014	vm_address_t basepc;
3015	mach_msg_type_t boundspcType;
3016	vm_address_t boundspc;
3017	mach_msg_type_t flavorType;
3018	int flavor;
3019	} Request;
3020
3021	typedef struct {
3022	mach_msg_header_t Head;
3023	mach_msg_type_t RetCodeType;
3024	kern_return_t RetCode;
3025	} Reply;
3026
3027	Request In0P = (Request ) InHeadP;
3028	Reply OutP = (Reply ) OutHeadP;
3029	mig_external kern_return_t task_ras_control
3030	(task_t target_task, vm_address_t basepc, vm_address_t boundspc, int flavor);
3031
3032	const mach_msg_type_t basepcCheck = {
3033	/* msgt_name = */ 2,
3034	/* msgt_size = */ 32,
3035	/* msgt_number = */ 1,
3036	/* msgt_inline = */ TRUE((boolean_t) 1),
3037	/* msgt_longform = */ FALSE((boolean_t) 0),
3038	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3039	/* msgt_unused = */ 0
3040	};
3041
3042	const mach_msg_type_t boundspcCheck = {
3043	/* msgt_name = */ 2,
3044	/* msgt_size = */ 32,
3045	/* msgt_number = */ 1,
3046	/* msgt_inline = */ TRUE((boolean_t) 1),
3047	/* msgt_longform = */ FALSE((boolean_t) 0),
3048	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3049	/* msgt_unused = */ 0
3050	};
3051
3052	const mach_msg_type_t flavorCheck = {
3053	/* msgt_name = */ 2,
3054	/* msgt_size = */ 32,
3055	/* msgt_number = */ 1,
3056	/* msgt_inline = */ TRUE((boolean_t) 1),
3057	/* msgt_longform = */ FALSE((boolean_t) 0),
3058	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3059	/* msgt_unused = */ 0
3060	};
3061
3062	task_t target_task;
3063
3064	#if TypeCheck1
3065	if (mig_unlikely ((In0P->Head.msgh_size != 48) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
3066	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
3067	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3068	#endif /* TypeCheck */
3069
3070	#if TypeCheck1
3071	if (BAD_TYPECHECK(&In0P->basepcType, &basepcCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->basepcType); _c.t = (& basepcCheck);_t.w != _c.w; })), 0))
3072	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3073	#endif /* TypeCheck */
3074
3075	#if TypeCheck1
3076	if (BAD_TYPECHECK(&In0P->boundspcType, &boundspcCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->boundspcType); _c.t = ( &boundspcCheck);_t.w != _c.w; })), 0))
3077	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3078	#endif /* TypeCheck */
3079
3080	#if TypeCheck1
3081	if (BAD_TYPECHECK(&In0P->flavorType, &flavorCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->flavorType); _c.t = (& flavorCheck);_t.w != _c.w; })), 0))
3082	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3083	#endif /* TypeCheck */
3084
3085	target_task = convert_port_to_task((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
3086
3087	OutP->RetCode = task_ras_control(target_task, In0P->basepc, In0P->boundspc, In0P->flavor);
3088	task_deallocate(target_task);
3089	}
3090
3091	/* Default implementation of task_ras_control */
3092	#ifdef MIG_EOPNOTSUPP
3093	kern_return_t __attribute__ ((weak))
3094	task_ras_control
3095	(
3096	task_t target_task,
3097	vm_address_t basepc,
3098	vm_address_t boundspc,
3099	int flavor
3100	) { return MIG_EOPNOTSUPP; }
3101	#endif /* MIG_EOPNOTSUPP */
3102
3103	/* Routine vm_map */
3104	mig_internalstatic void _Xvm_map
3105	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
3106	{
3107	typedef struct {
3108	mach_msg_header_t Head;
3109	mach_msg_type_t addressType;
3110	vm_address_t address;
3111	mach_msg_type_t sizeType;
3112	vm_size_t size;
3113	mach_msg_type_t maskType;
3114	vm_address_t mask;
3115	mach_msg_type_t anywhereType;
3116	boolean_t anywhere;
3117	mach_msg_type_t memory_objectType;
3118	ipc_port_t memory_object;
3119	mach_msg_type_t offsetType;
3120	vm_offset_t offset;
3121	mach_msg_type_t copyType;
3122	boolean_t copy;
3123	mach_msg_type_t cur_protectionType;
3124	vm_prot_t cur_protection;
3125	mach_msg_type_t max_protectionType;
3126	vm_prot_t max_protection;
3127	mach_msg_type_t inheritanceType;
3128	vm_inherit_t inheritance;
3129	} Request;
3130
3131	typedef struct {
3132	mach_msg_header_t Head;
3133	mach_msg_type_t RetCodeType;
3134	kern_return_t RetCode;
3135	mach_msg_type_t addressType;
3136	vm_address_t address;
3137	} Reply;
3138
3139	Request In0P = (Request ) InHeadP;
3140	Reply OutP = (Reply ) OutHeadP;
3141	mig_external kern_return_t vm_map
3142	(vm_map_t target_task, vm_address_t *address, vm_size_t size, vm_address_t mask, boolean_t anywhere, ipc_port_t memory_object, vm_offset_t offset, boolean_t copy, vm_prot_t cur_protection, vm_prot_t max_protection, vm_inherit_t inheritance);
3143
3144	const mach_msg_type_t addressCheck = {
3145	/* msgt_name = */ 2,
3146	/* msgt_size = */ 32,
3147	/* msgt_number = */ 1,
3148	/* msgt_inline = */ TRUE((boolean_t) 1),
3149	/* msgt_longform = */ FALSE((boolean_t) 0),
3150	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3151	/* msgt_unused = */ 0
3152	};
3153
3154	const mach_msg_type_t sizeCheck = {
3155	/* msgt_name = */ 2,
3156	/* msgt_size = */ 32,
3157	/* msgt_number = */ 1,
3158	/* msgt_inline = */ TRUE((boolean_t) 1),
3159	/* msgt_longform = */ FALSE((boolean_t) 0),
3160	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3161	/* msgt_unused = */ 0
3162	};
3163
3164	const mach_msg_type_t maskCheck = {
3165	/* msgt_name = */ 2,
3166	/* msgt_size = */ 32,
3167	/* msgt_number = */ 1,
3168	/* msgt_inline = */ TRUE((boolean_t) 1),
3169	/* msgt_longform = */ FALSE((boolean_t) 0),
3170	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3171	/* msgt_unused = */ 0
3172	};
3173
3174	const mach_msg_type_t anywhereCheck = {
3175	/* msgt_name = */ 0,
3176	/* msgt_size = */ 32,
3177	/* msgt_number = */ 1,
3178	/* msgt_inline = */ TRUE((boolean_t) 1),
3179	/* msgt_longform = */ FALSE((boolean_t) 0),
3180	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3181	/* msgt_unused = */ 0
3182	};
3183
3184	const mach_msg_type_t offsetCheck = {
3185	/* msgt_name = */ 2,
3186	/* msgt_size = */ 32,
3187	/* msgt_number = */ 1,
3188	/* msgt_inline = */ TRUE((boolean_t) 1),
3189	/* msgt_longform = */ FALSE((boolean_t) 0),
3190	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3191	/* msgt_unused = */ 0
3192	};
3193
3194	const mach_msg_type_t copyCheck = {
3195	/* msgt_name = */ 0,
3196	/* msgt_size = */ 32,
3197	/* msgt_number = */ 1,
3198	/* msgt_inline = */ TRUE((boolean_t) 1),
3199	/* msgt_longform = */ FALSE((boolean_t) 0),
3200	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3201	/* msgt_unused = */ 0
3202	};
3203
3204	const mach_msg_type_t cur_protectionCheck = {
3205	/* msgt_name = */ 2,
3206	/* msgt_size = */ 32,
3207	/* msgt_number = */ 1,
3208	/* msgt_inline = */ TRUE((boolean_t) 1),
3209	/* msgt_longform = */ FALSE((boolean_t) 0),
3210	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3211	/* msgt_unused = */ 0
3212	};
3213
3214	const mach_msg_type_t max_protectionCheck = {
3215	/* msgt_name = */ 2,
3216	/* msgt_size = */ 32,
3217	/* msgt_number = */ 1,
3218	/* msgt_inline = */ TRUE((boolean_t) 1),
3219	/* msgt_longform = */ FALSE((boolean_t) 0),
3220	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3221	/* msgt_unused = */ 0
3222	};
3223
3224	const mach_msg_type_t inheritanceCheck = {
3225	/* msgt_name = */ 2,
3226	/* msgt_size = */ 32,
3227	/* msgt_number = */ 1,
3228	/* msgt_inline = */ TRUE((boolean_t) 1),
3229	/* msgt_longform = */ FALSE((boolean_t) 0),
3230	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3231	/* msgt_unused = */ 0
3232	};
3233
3234	const mach_msg_type_t addressType = {
3235	/* msgt_name = */ 2,
3236	/* msgt_size = */ 32,
3237	/* msgt_number = */ 1,
3238	/* msgt_inline = */ TRUE((boolean_t) 1),
3239	/* msgt_longform = */ FALSE((boolean_t) 0),
3240	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3241	/* msgt_unused = */ 0
3242	};
3243
3244	vm_map_t target_task;
3245
3246	#if TypeCheck1
3247	if (mig_unlikely ((In0P->Head.msgh_size != 104) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 104) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0)
3248	!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 104) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0))
3249	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3250	#endif /* TypeCheck */
3251
3252	#if TypeCheck1
3253	if (BAD_TYPECHECK(&In0P->addressType, &addressCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->addressType); _c.t = (& addressCheck);_t.w != _c.w; })), 0))
3254	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3255	#endif /* TypeCheck */
3256
3257	#if TypeCheck1
3258	if (BAD_TYPECHECK(&In0P->sizeType, &sizeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->sizeType); _c.t = (& sizeCheck);_t.w != _c.w; })), 0))
3259	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3260	#endif /* TypeCheck */
3261
3262	#if TypeCheck1
3263	if (BAD_TYPECHECK(&In0P->maskType, &maskCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->maskType); _c.t = (& maskCheck);_t.w != _c.w; })), 0))
3264	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3265	#endif /* TypeCheck */
3266
3267	#if TypeCheck1
3268	if (BAD_TYPECHECK(&In0P->anywhereType, &anywhereCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->anywhereType); _c.t = ( &anywhereCheck);_t.w != _c.w; })), 0))
3269	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3270	#endif /* TypeCheck */
3271
3272	#if TypeCheck1
3273	if (mig_unlikely ((In0P->memory_objectType.msgt_inline != TRUE) \|\|__builtin_expect (!! ((In0P->memory_objectType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->memory_objectType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->memory_objectType.msgt_name != 17) \|\| (In0P->memory_objectType.msgt_number != 1) \|\| ( In0P->memory_objectType.msgt_size != 32)), 0)
3274	(In0P->memory_objectType.msgt_longform != FALSE) \|\|__builtin_expect (!! ((In0P->memory_objectType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->memory_objectType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->memory_objectType.msgt_name != 17) \|\| (In0P->memory_objectType.msgt_number != 1) \|\| ( In0P->memory_objectType.msgt_size != 32)), 0)
3275	(In0P->memory_objectType.msgt_name != 17) \|\|__builtin_expect (!! ((In0P->memory_objectType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->memory_objectType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->memory_objectType.msgt_name != 17) \|\| (In0P->memory_objectType.msgt_number != 1) \|\| ( In0P->memory_objectType.msgt_size != 32)), 0)
3276	(In0P->memory_objectType.msgt_number != 1) \|\|__builtin_expect (!! ((In0P->memory_objectType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->memory_objectType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->memory_objectType.msgt_name != 17) \|\| (In0P->memory_objectType.msgt_number != 1) \|\| ( In0P->memory_objectType.msgt_size != 32)), 0)
3277	(In0P->memory_objectType.msgt_size != 32))__builtin_expect (!! ((In0P->memory_objectType.msgt_inline != ((boolean_t) 1)) \|\| (In0P->memory_objectType.msgt_longform != ((boolean_t) 0)) \|\| (In0P->memory_objectType.msgt_name != 17) \|\| (In0P->memory_objectType.msgt_number != 1) \|\| ( In0P->memory_objectType.msgt_size != 32)), 0))
3278	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3279	#endif /* TypeCheck */
3280
3281	#if TypeCheck1
3282	if (BAD_TYPECHECK(&In0P->offsetType, &offsetCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->offsetType); _c.t = (& offsetCheck);_t.w != _c.w; })), 0))
3283	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3284	#endif /* TypeCheck */
3285
3286	#if TypeCheck1
3287	if (BAD_TYPECHECK(&In0P->copyType, &copyCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->copyType); _c.t = (& copyCheck);_t.w != _c.w; })), 0))
3288	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3289	#endif /* TypeCheck */
3290
3291	#if TypeCheck1
3292	if (BAD_TYPECHECK(&In0P->cur_protectionType, &cur_protectionCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->cur_protectionType); _c. t = (&cur_protectionCheck);_t.w != _c.w; })), 0))
3293	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3294	#endif /* TypeCheck */
3295
3296	#if TypeCheck1
3297	if (BAD_TYPECHECK(&In0P->max_protectionType, &max_protectionCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->max_protectionType); _c. t = (&max_protectionCheck);_t.w != _c.w; })), 0))
3298	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3299	#endif /* TypeCheck */
3300
3301	#if TypeCheck1
3302	if (BAD_TYPECHECK(&In0P->inheritanceType, &inheritanceCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->inheritanceType); _c.t = (&inheritanceCheck);_t.w != _c.w; })), 0))
3303	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3304	#endif /* TypeCheck */
3305
3306	target_task = convert_port_to_map((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
3307
3308	OutP->RetCode = vm_map(target_task, &In0P->address, In0P->size, In0P->mask, In0P->anywhere, null_conversion(In0P->memory_object)(In0P->memory_object), In0P->offset, In0P->copy, In0P->cur_protection, In0P->max_protection, In0P->inheritance);
3309	vm_map_deallocate(target_task);
3310	if (OutP->RetCode != KERN_SUCCESS0)
3311	return;
3312
3313	if (IP_VALID(In0P->memory_object)(((&(In0P->memory_object)->ip_target.ipt_object) != ((ipc_object_t) 0)) && ((&(In0P->memory_object )->ip_target.ipt_object) != ((ipc_object_t) -1))))
3314	ipc_port_release_send(In0P->memory_object);
3315
3316	OutP->Head.msgh_size = 40;
3317
3318	OutP->addressType = addressType;
3319
3320	OutP->address = In0P->address;
3321	}
3322
3323	/* Default implementation of vm_map */
3324	#ifdef MIG_EOPNOTSUPP
3325	kern_return_t __attribute__ ((weak))
3326	vm_map
3327	(
3328	vm_map_t target_task,
3329	vm_address_t *address,
3330	vm_size_t size,
3331	vm_address_t mask,
3332	boolean_t anywhere,
3333	ipc_port_t memory_object,
3334	vm_offset_t offset,
3335	boolean_t copy,
3336	vm_prot_t cur_protection,
3337	vm_prot_t max_protection,
3338	vm_inherit_t inheritance
3339	) { return MIG_EOPNOTSUPP; }
3340	#endif /* MIG_EOPNOTSUPP */
3341
3342	/* SimpleRoutine memory_object_data_error */
3343	mig_internalstatic void _Xmemory_object_data_error
3344	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
3345	{
3346	typedef struct {
3347	mach_msg_header_t Head;
3348	mach_msg_type_t offsetType;
3349	vm_offset_t offset;
3350	mach_msg_type_t sizeType;
3351	vm_size_t size;
3352	mach_msg_type_t error_valueType;
3353	kern_return_t error_value;
3354	} Request;
3355
3356	typedef struct {
3357	mach_msg_header_t Head;
3358	mach_msg_type_t RetCodeType;
3359	kern_return_t RetCode;
3360	} Reply;
3361
3362	Request In0P = (Request ) InHeadP;
3363	Reply OutP = (Reply ) OutHeadP;
3364	mig_external kern_return_t memory_object_data_error
3365	(vm_object_t memory_control, vm_offset_t offset, vm_size_t size, kern_return_t error_value);
3366
3367	const mach_msg_type_t offsetCheck = {
3368	/* msgt_name = */ 2,
3369	/* msgt_size = */ 32,
3370	/* msgt_number = */ 1,
3371	/* msgt_inline = */ TRUE((boolean_t) 1),
3372	/* msgt_longform = */ FALSE((boolean_t) 0),
3373	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3374	/* msgt_unused = */ 0
3375	};
3376
3377	const mach_msg_type_t sizeCheck = {
3378	/* msgt_name = */ 2,
3379	/* msgt_size = */ 32,
3380	/* msgt_number = */ 1,
3381	/* msgt_inline = */ TRUE((boolean_t) 1),
3382	/* msgt_longform = */ FALSE((boolean_t) 0),
3383	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3384	/* msgt_unused = */ 0
3385	};
3386
3387	const mach_msg_type_t error_valueCheck = {
3388	/* msgt_name = */ 2,
3389	/* msgt_size = */ 32,
3390	/* msgt_number = */ 1,
3391	/* msgt_inline = */ TRUE((boolean_t) 1),
3392	/* msgt_longform = */ FALSE((boolean_t) 0),
3393	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3394	/* msgt_unused = */ 0
3395	};
3396
3397	#if TypeCheck1
3398	if (mig_unlikely ((In0P->Head.msgh_size != 48) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
3399	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
3400	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3401	#endif /* TypeCheck */
3402
3403	#if TypeCheck1
3404	if (BAD_TYPECHECK(&In0P->offsetType, &offsetCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->offsetType); _c.t = (& offsetCheck);_t.w != _c.w; })), 0))
3405	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3406	#endif /* TypeCheck */
3407
3408	#if TypeCheck1
3409	if (BAD_TYPECHECK(&In0P->sizeType, &sizeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->sizeType); _c.t = (& sizeCheck);_t.w != _c.w; })), 0))
3410	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3411	#endif /* TypeCheck */
3412
3413	#if TypeCheck1
3414	if (BAD_TYPECHECK(&In0P->error_valueType, &error_valueCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->error_valueType); _c.t = (&error_valueCheck);_t.w != _c.w; })), 0))
3415	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3416	#endif /* TypeCheck */
3417
3418	OutP->RetCode = memory_object_data_error(vm_object_lookup((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port), In0P->offset, In0P->size, In0P->error_value);
3419	}
3420
3421	/* Default implementation of memory_object_data_error */
3422	#ifdef MIG_EOPNOTSUPP
3423	kern_return_t __attribute__ ((weak))
3424	memory_object_data_error
3425	(
3426	vm_object_t memory_control,
3427	vm_offset_t offset,
3428	vm_size_t size,
3429	kern_return_t error_value
3430	) { return MIG_EOPNOTSUPP; }
3431	#endif /* MIG_EOPNOTSUPP */
3432
3433	/* SimpleRoutine memory_object_set_attributes */
3434	mig_internalstatic void _Xmemory_object_set_attributes
3435	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
3436	{
3437	typedef struct {
3438	mach_msg_header_t Head;
3439	mach_msg_type_t object_readyType;
3440	boolean_t object_ready;
3441	mach_msg_type_t may_cacheType;
3442	boolean_t may_cache;
3443	mach_msg_type_t copy_strategyType;
3444	memory_object_copy_strategy_t copy_strategy;
3445	} Request;
3446
3447	typedef struct {
3448	mach_msg_header_t Head;
3449	mach_msg_type_t RetCodeType;
3450	kern_return_t RetCode;
3451	} Reply;
3452
3453	Request In0P = (Request ) InHeadP;
3454	Reply OutP = (Reply ) OutHeadP;
3455	mig_external kern_return_t memory_object_set_attributes
3456	(vm_object_t memory_control, boolean_t object_ready, boolean_t may_cache, memory_object_copy_strategy_t copy_strategy);
3457
3458	const mach_msg_type_t object_readyCheck = {
3459	/* msgt_name = */ 0,
3460	/* msgt_size = */ 32,
3461	/* msgt_number = */ 1,
3462	/* msgt_inline = */ TRUE((boolean_t) 1),
3463	/* msgt_longform = */ FALSE((boolean_t) 0),
3464	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3465	/* msgt_unused = */ 0
3466	};
3467
3468	const mach_msg_type_t may_cacheCheck = {
3469	/* msgt_name = */ 0,
3470	/* msgt_size = */ 32,
3471	/* msgt_number = */ 1,
3472	/* msgt_inline = */ TRUE((boolean_t) 1),
3473	/* msgt_longform = */ FALSE((boolean_t) 0),
3474	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3475	/* msgt_unused = */ 0
3476	};
3477
3478	const mach_msg_type_t copy_strategyCheck = {
3479	/* msgt_name = */ 2,
3480	/* msgt_size = */ 32,
3481	/* msgt_number = */ 1,
3482	/* msgt_inline = */ TRUE((boolean_t) 1),
3483	/* msgt_longform = */ FALSE((boolean_t) 0),
3484	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3485	/* msgt_unused = */ 0
3486	};
3487
3488	#if TypeCheck1
3489	if (mig_unlikely ((In0P->Head.msgh_size != 48) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
3490	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 48) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
3491	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3492	#endif /* TypeCheck */
3493
3494	#if TypeCheck1
3495	if (BAD_TYPECHECK(&In0P->object_readyType, &object_readyCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->object_readyType); _c.t = (&object_readyCheck);_t.w != _c.w; })), 0))
3496	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3497	#endif /* TypeCheck */
3498
3499	#if TypeCheck1
3500	if (BAD_TYPECHECK(&In0P->may_cacheType, &may_cacheCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->may_cacheType); _c.t = (&may_cacheCheck);_t.w != _c.w; })), 0))
3501	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3502	#endif /* TypeCheck */
3503
3504	#if TypeCheck1
3505	if (BAD_TYPECHECK(&In0P->copy_strategyType, &copy_strategyCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->copy_strategyType); _c.t = (&copy_strategyCheck);_t.w != _c.w; })), 0))
3506	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3507	#endif /* TypeCheck */
3508
3509	OutP->RetCode = memory_object_set_attributes(vm_object_lookup((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port), In0P->object_ready, In0P->may_cache, In0P->copy_strategy);
3510	}
3511
3512	/* Default implementation of memory_object_set_attributes */
3513	#ifdef MIG_EOPNOTSUPP
3514	kern_return_t __attribute__ ((weak))
3515	memory_object_set_attributes
3516	(
3517	vm_object_t memory_control,
3518	boolean_t object_ready,
3519	boolean_t may_cache,
3520	memory_object_copy_strategy_t copy_strategy
3521	) { return MIG_EOPNOTSUPP; }
3522	#endif /* MIG_EOPNOTSUPP */
3523
3524	/* SimpleRoutine memory_object_destroy */
3525	mig_internalstatic void _Xmemory_object_destroy
3526	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
3527	{
3528	typedef struct {
3529	mach_msg_header_t Head;
3530	mach_msg_type_t reasonType;
3531	kern_return_t reason;
3532	} Request;
3533
3534	typedef struct {
3535	mach_msg_header_t Head;
3536	mach_msg_type_t RetCodeType;
3537	kern_return_t RetCode;
3538	} Reply;
3539
3540	Request In0P = (Request ) InHeadP;
3541	Reply OutP = (Reply ) OutHeadP;
3542	mig_external kern_return_t memory_object_destroy
3543	(vm_object_t memory_control, kern_return_t reason);
3544
3545	const mach_msg_type_t reasonCheck = {
3546	/* msgt_name = */ 2,
3547	/* msgt_size = */ 32,
3548	/* msgt_number = */ 1,
3549	/* msgt_inline = */ TRUE((boolean_t) 1),
3550	/* msgt_longform = */ FALSE((boolean_t) 0),
3551	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3552	/* msgt_unused = */ 0
3553	};
3554
3555	#if TypeCheck1
3556	if (mig_unlikely ((In0P->Head.msgh_size != 32) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
3557	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 32) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
3558	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3559	#endif /* TypeCheck */
3560
3561	#if TypeCheck1
3562	if (BAD_TYPECHECK(&In0P->reasonType, &reasonCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->reasonType); _c.t = (& reasonCheck);_t.w != _c.w; })), 0))
3563	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3564	#endif /* TypeCheck */
3565
3566	OutP->RetCode = memory_object_destroy(vm_object_lookup((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port), In0P->reason);
3567	}
3568
3569	/* Default implementation of memory_object_destroy */
3570	#ifdef MIG_EOPNOTSUPP
3571	kern_return_t __attribute__ ((weak))
3572	memory_object_destroy
3573	(
3574	vm_object_t memory_control,
3575	kern_return_t reason
3576	) { return MIG_EOPNOTSUPP; }
3577	#endif /* MIG_EOPNOTSUPP */
3578
3579	/* SimpleRoutine memory_object_data_supply */
3580	mig_internalstatic void _Xmemory_object_data_supply
3581	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
3582	{
3583	typedef struct {
3584	mach_msg_header_t Head;
3585	mach_msg_type_t offsetType;
3586	vm_offset_t offset;
3587	mach_msg_type_long_t dataType;
3588	vm_offset_t data;
3589	mach_msg_type_t lock_valueType;
3590	vm_prot_t lock_value;
3591	mach_msg_type_t preciousType;
3592	boolean_t precious;
3593	mach_msg_type_t reply_toType;
3594	ipc_port_t reply_to;
3595	} Request;
3596
3597	typedef struct {
3598	mach_msg_header_t Head;
3599	mach_msg_type_t RetCodeType;
3600	kern_return_t RetCode;
3601	} Reply;
3602
3603	Request In0P = (Request ) InHeadP;
3604	Reply OutP = (Reply ) OutHeadP;
3605	mig_external kern_return_t memory_object_data_supply
3606	(vm_object_t memory_control, vm_offset_t offset, vm_offset_t data, mach_msg_type_number_t dataCnt, vm_prot_t lock_value, boolean_t precious, ipc_port_t reply_to, mach_msg_type_name_t reply_toPoly);
3607
3608	const mach_msg_type_t offsetCheck = {
3609	/* msgt_name = */ 2,
3610	/* msgt_size = */ 32,
3611	/* msgt_number = */ 1,
3612	/* msgt_inline = */ TRUE((boolean_t) 1),
3613	/* msgt_longform = */ FALSE((boolean_t) 0),
3614	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3615	/* msgt_unused = */ 0
3616	};
3617
3618	const mach_msg_type_t lock_valueCheck = {
3619	/* msgt_name = */ 2,
3620	/* msgt_size = */ 32,
3621	/* msgt_number = */ 1,
3622	/* msgt_inline = */ TRUE((boolean_t) 1),
3623	/* msgt_longform = */ FALSE((boolean_t) 0),
3624	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3625	/* msgt_unused = */ 0
3626	};
3627
3628	const mach_msg_type_t preciousCheck = {
3629	/* msgt_name = */ 0,
3630	/* msgt_size = */ 32,
3631	/* msgt_number = */ 1,
3632	/* msgt_inline = */ TRUE((boolean_t) 1),
3633	/* msgt_longform = */ FALSE((boolean_t) 0),
3634	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3635	/* msgt_unused = */ 0
3636	};
3637
3638	#if TypeCheck1
3639	if (mig_unlikely ((In0P->Head.msgh_size != 72) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 72) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0)
3640	!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 72) \|\| !(In0P ->Head.msgh_bits & 0x80000000U)), 0))
3641	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3642	#endif /* TypeCheck */
3643
3644	#if TypeCheck1
3645	if (BAD_TYPECHECK(&In0P->offsetType, &offsetCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->offsetType); _c.t = (& offsetCheck);_t.w != _c.w; })), 0))
3646	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3647	#endif /* TypeCheck */
3648
3649	#if TypeCheck1
3650	if (mig_unlikely ((In0P->dataType.msgtl_header.msgt_inline != FALSE) \|\|__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0)
3651	(In0P->dataType.msgtl_header.msgt_longform != TRUE) \|\|__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0)
3652	(In0P->dataType.msgtl_name != 9) \|\|__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0)
3653	(In0P->dataType.msgtl_size != 8))__builtin_expect (!! ((In0P->dataType.msgtl_header.msgt_inline != ((boolean_t) 0)) \|\| (In0P->dataType.msgtl_header.msgt_longform != ((boolean_t) 1)) \|\| (In0P->dataType.msgtl_name != 9) \|\| (In0P->dataType.msgtl_size != 8)), 0))
3654	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3655	#endif /* TypeCheck */
3656
3657	#if TypeCheck1
3658	if (BAD_TYPECHECK(&In0P->lock_valueType, &lock_valueCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->lock_valueType); _c.t = (&lock_valueCheck);_t.w != _c.w; })), 0))
3659	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3660	#endif /* TypeCheck */
3661
3662	#if TypeCheck1
3663	if (BAD_TYPECHECK(&In0P->preciousType, &preciousCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->preciousType); _c.t = ( &preciousCheck);_t.w != _c.w; })), 0))
3664	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3665	#endif /* TypeCheck */
3666
3667	#if TypeCheck1
3668	if (mig_unlikely ((In0P->reply_toType.msgt_inline != TRUE) \|\|__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| (In0P->reply_toType.msgt_number != 1) \|\| (In0P->reply_toType.msgt_size != 32)), 0)
3669	(In0P->reply_toType.msgt_longform != FALSE) \|\|__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| (In0P->reply_toType.msgt_number != 1) \|\| (In0P->reply_toType.msgt_size != 32)), 0)
3670	(In0P->reply_toType.msgt_number != 1) \|\|__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| (In0P->reply_toType.msgt_number != 1) \|\| (In0P->reply_toType.msgt_size != 32)), 0)
3671	(In0P->reply_toType.msgt_size != 32))__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| (In0P->reply_toType.msgt_number != 1) \|\| (In0P->reply_toType.msgt_size != 32)), 0))
3672	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3673	#endif /* TypeCheck */
3674
3675	OutP->RetCode = memory_object_data_supply(vm_object_lookup((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port), In0P->offset, In0P->data, In0P->dataType.msgtl_number, In0P->lock_value, In0P->precious, In0P->reply_to, In0P->reply_toType.msgt_name);
3676	}
3677
3678	/* Default implementation of memory_object_data_supply */
3679	#ifdef MIG_EOPNOTSUPP
3680	kern_return_t __attribute__ ((weak))
3681	memory_object_data_supply
3682	(
3683	vm_object_t memory_control,
3684	vm_offset_t offset,
3685	vm_offset_t data,
3686	mach_msg_type_number_t dataCnt,
3687	vm_prot_t lock_value,
3688	boolean_t precious,
3689	ipc_port_t reply_to,
3690	mach_msg_type_name_t reply_toPoly
3691	) { return MIG_EOPNOTSUPP; }
3692	#endif /* MIG_EOPNOTSUPP */
3693
3694	/* SimpleRoutine memory_object_ready */
3695	mig_internalstatic void _Xmemory_object_ready
3696	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
3697	{
3698	typedef struct {
3699	mach_msg_header_t Head;
3700	mach_msg_type_t may_cacheType;
3701	boolean_t may_cache;
3702	mach_msg_type_t copy_strategyType;
3703	memory_object_copy_strategy_t copy_strategy;
3704	} Request;
3705
3706	typedef struct {
3707	mach_msg_header_t Head;
3708	mach_msg_type_t RetCodeType;
3709	kern_return_t RetCode;
3710	} Reply;
3711
3712	Request In0P = (Request ) InHeadP;
3713	Reply OutP = (Reply ) OutHeadP;
3714	mig_external kern_return_t memory_object_ready
3715	(vm_object_t memory_control, boolean_t may_cache, memory_object_copy_strategy_t copy_strategy);
3716
3717	const mach_msg_type_t may_cacheCheck = {
3718	/* msgt_name = */ 0,
3719	/* msgt_size = */ 32,
3720	/* msgt_number = */ 1,
3721	/* msgt_inline = */ TRUE((boolean_t) 1),
3722	/* msgt_longform = */ FALSE((boolean_t) 0),
3723	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3724	/* msgt_unused = */ 0
3725	};
3726
3727	const mach_msg_type_t copy_strategyCheck = {
3728	/* msgt_name = */ 2,
3729	/* msgt_size = */ 32,
3730	/* msgt_number = */ 1,
3731	/* msgt_inline = */ TRUE((boolean_t) 1),
3732	/* msgt_longform = */ FALSE((boolean_t) 0),
3733	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3734	/* msgt_unused = */ 0
3735	};
3736
3737	#if TypeCheck1
3738	if (mig_unlikely ((In0P->Head.msgh_size != 40) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
3739	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 40) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
3740	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3741	#endif /* TypeCheck */
3742
3743	#if TypeCheck1
3744	if (BAD_TYPECHECK(&In0P->may_cacheType, &may_cacheCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->may_cacheType); _c.t = (&may_cacheCheck);_t.w != _c.w; })), 0))
3745	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3746	#endif /* TypeCheck */
3747
3748	#if TypeCheck1
3749	if (BAD_TYPECHECK(&In0P->copy_strategyType, &copy_strategyCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->copy_strategyType); _c.t = (&copy_strategyCheck);_t.w != _c.w; })), 0))
3750	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3751	#endif /* TypeCheck */
3752
3753	OutP->RetCode = memory_object_ready(vm_object_lookup((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port), In0P->may_cache, In0P->copy_strategy);
3754	}
3755
3756	/* Default implementation of memory_object_ready */
3757	#ifdef MIG_EOPNOTSUPP
3758	kern_return_t __attribute__ ((weak))
3759	memory_object_ready
3760	(
3761	vm_object_t memory_control,
3762	boolean_t may_cache,
3763	memory_object_copy_strategy_t copy_strategy
3764	) { return MIG_EOPNOTSUPP; }
3765	#endif /* MIG_EOPNOTSUPP */
3766
3767	/* SimpleRoutine memory_object_change_attributes */
3768	mig_internalstatic void _Xmemory_object_change_attributes
3769	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
3770	{
3771	typedef struct {
3772	mach_msg_header_t Head;
3773	mach_msg_type_t may_cacheType;
3774	boolean_t may_cache;
3775	mach_msg_type_t copy_strategyType;
3776	memory_object_copy_strategy_t copy_strategy;
3777	mach_msg_type_t reply_toType;
3778	ipc_port_t reply_to;
3779	} Request;
3780
3781	typedef struct {
3782	mach_msg_header_t Head;
3783	mach_msg_type_t RetCodeType;
3784	kern_return_t RetCode;
3785	} Reply;
3786
3787	Request In0P = (Request ) InHeadP;
3788	Reply OutP = (Reply ) OutHeadP;
3789	mig_external kern_return_t memory_object_change_attributes
3790	(vm_object_t memory_control, boolean_t may_cache, memory_object_copy_strategy_t copy_strategy, ipc_port_t reply_to, mach_msg_type_name_t reply_toPoly);
3791
3792	#if TypeCheck1
3793	boolean_t msgh_simple = msgh_simple;
	Value stored to 'msgh_simple' during its initialization is never read
3794	#endif /* TypeCheck */
3795
3796	const mach_msg_type_t may_cacheCheck = {
3797	/* msgt_name = */ 0,
3798	/* msgt_size = */ 32,
3799	/* msgt_number = */ 1,
3800	/* msgt_inline = */ TRUE((boolean_t) 1),
3801	/* msgt_longform = */ FALSE((boolean_t) 0),
3802	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3803	/* msgt_unused = */ 0
3804	};
3805
3806	const mach_msg_type_t copy_strategyCheck = {
3807	/* msgt_name = */ 2,
3808	/* msgt_size = */ 32,
3809	/* msgt_number = */ 1,
3810	/* msgt_inline = */ TRUE((boolean_t) 1),
3811	/* msgt_longform = */ FALSE((boolean_t) 0),
3812	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3813	/* msgt_unused = */ 0
3814	};
3815
3816	#if TypeCheck1
3817	msgh_simple = !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX0x80000000U);
3818	if (mig_unlikely ((In0P->Head.msgh_size != 48))__builtin_expect (!! ((In0P->Head.msgh_size != 48)), 0))
3819	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3820	#endif /* TypeCheck */
3821
3822	#if TypeCheck1
3823	if (BAD_TYPECHECK(&In0P->may_cacheType, &may_cacheCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->may_cacheType); _c.t = (&may_cacheCheck);_t.w != _c.w; })), 0))
3824	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3825	#endif /* TypeCheck */
3826
3827	#if TypeCheck1
3828	if (BAD_TYPECHECK(&In0P->copy_strategyType, &copy_strategyCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->copy_strategyType); _c.t = (&copy_strategyCheck);_t.w != _c.w; })), 0))
3829	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3830	#endif /* TypeCheck */
3831
3832	#if TypeCheck1
3833	if (mig_unlikely ((In0P->reply_toType.msgt_inline != TRUE) \|\|__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| ((((In0P->reply_toType.msgt_name) >= 16 ) && ((In0P->reply_toType.msgt_name) <= 21)) && msgh_simple) \|\| (In0P->reply_toType.msgt_number != 1) \|\| ( In0P->reply_toType.msgt_size != 32)), 0)
3834	(In0P->reply_toType.msgt_longform != FALSE) \|\|__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| ((((In0P->reply_toType.msgt_name) >= 16 ) && ((In0P->reply_toType.msgt_name) <= 21)) && msgh_simple) \|\| (In0P->reply_toType.msgt_number != 1) \|\| ( In0P->reply_toType.msgt_size != 32)), 0)
3835	(MACH_MSG_TYPE_PORT_ANY(In0P->reply_toType.msgt_name) && msgh_simple) \|\|__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| ((((In0P->reply_toType.msgt_name) >= 16 ) && ((In0P->reply_toType.msgt_name) <= 21)) && msgh_simple) \|\| (In0P->reply_toType.msgt_number != 1) \|\| ( In0P->reply_toType.msgt_size != 32)), 0)
3836	(In0P->reply_toType.msgt_number != 1) \|\|__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| ((((In0P->reply_toType.msgt_name) >= 16 ) && ((In0P->reply_toType.msgt_name) <= 21)) && msgh_simple) \|\| (In0P->reply_toType.msgt_number != 1) \|\| ( In0P->reply_toType.msgt_size != 32)), 0)
3837	(In0P->reply_toType.msgt_size != 32))__builtin_expect (!! ((In0P->reply_toType.msgt_inline != ( (boolean_t) 1)) \|\| (In0P->reply_toType.msgt_longform != (( boolean_t) 0)) \|\| ((((In0P->reply_toType.msgt_name) >= 16 ) && ((In0P->reply_toType.msgt_name) <= 21)) && msgh_simple) \|\| (In0P->reply_toType.msgt_number != 1) \|\| ( In0P->reply_toType.msgt_size != 32)), 0))
3838	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3839	#endif /* TypeCheck */
3840
3841	OutP->RetCode = memory_object_change_attributes(vm_object_lookup((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port), In0P->may_cache, In0P->copy_strategy, In0P->reply_to, In0P->reply_toType.msgt_name);
3842	}
3843
3844	/* Default implementation of memory_object_change_attributes */
3845	#ifdef MIG_EOPNOTSUPP
3846	kern_return_t __attribute__ ((weak))
3847	memory_object_change_attributes
3848	(
3849	vm_object_t memory_control,
3850	boolean_t may_cache,
3851	memory_object_copy_strategy_t copy_strategy,
3852	ipc_port_t reply_to,
3853	mach_msg_type_name_t reply_toPoly
3854	) { return MIG_EOPNOTSUPP; }
3855	#endif /* MIG_EOPNOTSUPP */
3856
3857	/* Routine vm_machine_attribute */
3858	mig_internalstatic void _Xvm_machine_attribute
3859	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
3860	{
3861	typedef struct {
3862	mach_msg_header_t Head;
3863	mach_msg_type_t addressType;
3864	vm_address_t address;
3865	mach_msg_type_t sizeType;
3866	vm_size_t size;
3867	mach_msg_type_t attributeType;
3868	vm_machine_attribute_t attribute;
3869	mach_msg_type_t valueType;
3870	vm_machine_attribute_val_t value;
3871	} Request;
3872
3873	typedef struct {
3874	mach_msg_header_t Head;
3875	mach_msg_type_t RetCodeType;
3876	kern_return_t RetCode;
3877	mach_msg_type_t valueType;
3878	vm_machine_attribute_val_t value;
3879	} Reply;
3880
3881	Request In0P = (Request ) InHeadP;
3882	Reply OutP = (Reply ) OutHeadP;
3883	mig_external kern_return_t vm_machine_attribute
3884	(vm_map_t target_task, vm_address_t address, vm_size_t size, vm_machine_attribute_t attribute, vm_machine_attribute_val_t *value);
3885
3886	const mach_msg_type_t addressCheck = {
3887	/* msgt_name = */ 2,
3888	/* msgt_size = */ 32,
3889	/* msgt_number = */ 1,
3890	/* msgt_inline = */ TRUE((boolean_t) 1),
3891	/* msgt_longform = */ FALSE((boolean_t) 0),
3892	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3893	/* msgt_unused = */ 0
3894	};
3895
3896	const mach_msg_type_t sizeCheck = {
3897	/* msgt_name = */ 2,
3898	/* msgt_size = */ 32,
3899	/* msgt_number = */ 1,
3900	/* msgt_inline = */ TRUE((boolean_t) 1),
3901	/* msgt_longform = */ FALSE((boolean_t) 0),
3902	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3903	/* msgt_unused = */ 0
3904	};
3905
3906	const mach_msg_type_t attributeCheck = {
3907	/* msgt_name = */ 2,
3908	/* msgt_size = */ 32,
3909	/* msgt_number = */ 1,
3910	/* msgt_inline = */ TRUE((boolean_t) 1),
3911	/* msgt_longform = */ FALSE((boolean_t) 0),
3912	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3913	/* msgt_unused = */ 0
3914	};
3915
3916	const mach_msg_type_t valueCheck = {
3917	/* msgt_name = */ 2,
3918	/* msgt_size = */ 32,
3919	/* msgt_number = */ 1,
3920	/* msgt_inline = */ TRUE((boolean_t) 1),
3921	/* msgt_longform = */ FALSE((boolean_t) 0),
3922	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3923	/* msgt_unused = */ 0
3924	};
3925
3926	const mach_msg_type_t valueType = {
3927	/* msgt_name = */ 2,
3928	/* msgt_size = */ 32,
3929	/* msgt_number = */ 1,
3930	/* msgt_inline = */ TRUE((boolean_t) 1),
3931	/* msgt_longform = */ FALSE((boolean_t) 0),
3932	/* msgt_deallocate = */ FALSE((boolean_t) 0),
3933	/* msgt_unused = */ 0
3934	};
3935
3936	vm_map_t target_task;
3937
3938	#if TypeCheck1
3939	if (mig_unlikely ((In0P->Head.msgh_size != 56) \|\|__builtin_expect (!! ((In0P->Head.msgh_size != 56) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0)
3940	(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))__builtin_expect (!! ((In0P->Head.msgh_size != 56) \|\| (In0P ->Head.msgh_bits & 0x80000000U)), 0))
3941	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3942	#endif /* TypeCheck */
3943
3944	#if TypeCheck1
3945	if (BAD_TYPECHECK(&In0P->addressType, &addressCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->addressType); _c.t = (& addressCheck);_t.w != _c.w; })), 0))
3946	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3947	#endif /* TypeCheck */
3948
3949	#if TypeCheck1
3950	if (BAD_TYPECHECK(&In0P->sizeType, &sizeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->sizeType); _c.t = (& sizeCheck);_t.w != _c.w; })), 0))
3951	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3952	#endif /* TypeCheck */
3953
3954	#if TypeCheck1
3955	if (BAD_TYPECHECK(&In0P->attributeType, &attributeCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->attributeType); _c.t = (&attributeCheck);_t.w != _c.w; })), 0))
3956	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3957	#endif /* TypeCheck */
3958
3959	#if TypeCheck1
3960	if (BAD_TYPECHECK(&In0P->valueType, &valueCheck)__builtin_expect (!! (({ union { mach_msg_type_t t; unsigned32_t w; } _t, _c; _t.t = (&In0P->valueType); _c.t = (& valueCheck);_t.w != _c.w; })), 0))
3961	{ OutP->RetCode = MIG_BAD_ARGUMENTS-304; return; }
3962	#endif /* TypeCheck */
3963
3964	target_task = convert_port_to_map((ipc_port_t) In0P->Head.msgh_request_portmsgh_remote_port);
3965
3966	OutP->RetCode = vm_machine_attribute(target_task, In0P->address, In0P->size, In0P->attribute, &In0P->value);
3967	vm_map_deallocate(target_task);
3968	if (OutP->RetCode != KERN_SUCCESS0)
3969	return;
3970
3971	OutP->Head.msgh_size = 40;
3972
3973	OutP->valueType = valueType;
3974
3975	OutP->value = In0P->value;
3976	}
3977
3978	/* Default implementation of vm_machine_attribute */
3979	#ifdef MIG_EOPNOTSUPP
3980	kern_return_t __attribute__ ((weak))
3981	vm_machine_attribute
3982	(
3983	vm_map_t target_task,
3984	vm_address_t address,
3985	vm_size_t size,
3986	vm_machine_attribute_t attribute,
3987	vm_machine_attribute_val_t *value
3988	) { return MIG_EOPNOTSUPP; }
3989	#endif /* MIG_EOPNOTSUPP */
3990
3991	mig_routine_t mach_server_routines[] = {
3992	0,
3993	0,
3994	0,
3995	0,
3996	0,
3997	0,
3998	0,
3999	_Xtask_create,
4000	_Xtask_terminate,
4001	_Xtask_get_emulation_vector,
4002	_Xtask_set_emulation_vector,
4003	_Xtask_threads,
4004	_Xtask_info,
4005	0,
4006	0,
4007	0,
4008	_Xthread_terminate,
4009	_Xthread_get_state,
4010	_Xthread_set_state,
4011	_Xthread_info,
4012	0,
4013	_Xvm_allocate,
4014	0,
4015	_Xvm_deallocate,
4016	_Xvm_protect,
4017	_Xvm_inherit,
4018	_Xvm_read,
4019	_Xvm_write,
4020	_Xvm_copy,
4021	_Xvm_region,
4022	_Xvm_statistics,
4023	0,
4024	0,
4025	_Xmach_ports_register,
4026	_Xmach_ports_lookup,
4027	0,
4028	0,
4029	0,
4030	_Xmemory_object_data_provided,
4031	_Xmemory_object_data_unavailable,
4032	_Xmemory_object_get_attributes,
4033	_Xvm_set_default_memory_manager,
4034	0,
4035	0,
4036	_Xmemory_object_lock_request,
4037	0,
4038	0,
4039	0,
4040	0,
4041	0,
4042	0,
4043	0,
4044	0,
4045	0,
4046	0,
4047	0,
4048	_Xtask_suspend,
4049	_Xtask_resume,
4050	_Xtask_get_special_port,
4051	_Xtask_set_special_port,
4052	0,
4053	_Xthread_create,
4054	_Xthread_suspend,
4055	_Xthread_resume,
4056	_Xthread_abort,
4057	0,
4058	0,
4059	_Xthread_get_special_port,
4060	_Xthread_set_special_port,
4061	0,
4062	_Xtask_set_emulation,
4063	_Xtask_ras_control,
4064	0,
4065	0,
4066	0,
4067	0,
4068	0,
4069	0,
4070	0,
4071	0,
4072	0,
4073	0,
4074	0,
4075	0,
4076	0,
4077	0,
4078	0,
4079	0,
4080	0,
4081	_Xvm_map,
4082	_Xmemory_object_data_error,
4083	_Xmemory_object_set_attributes,
4084	_Xmemory_object_destroy,
4085	_Xmemory_object_data_supply,
4086	_Xmemory_object_ready,
4087	_Xmemory_object_change_attributes,
4088	0,
4089	0,
4090	0,
4091	_Xvm_machine_attribute,
4092	0,
4093	};
4094
4095	mig_external boolean_t mach_server
4096	(mach_msg_header_t InHeadP, mach_msg_header_t OutHeadP)
4097	{
4098	mach_msg_header_t *InP = InHeadP;
4099	mig_reply_header_t OutP = (mig_reply_header_t ) OutHeadP;
4100
4101	const mach_msg_type_t RetCodeType = {
4102	/* msgt_name = */ MACH_MSG_TYPE_INTEGER_322,
4103	/* msgt_size = */ 32,
4104	/* msgt_number = */ 1,
4105	/* msgt_inline = */ TRUE((boolean_t) 1),
4106	/* msgt_longform = */ FALSE((boolean_t) 0),
4107	/* msgt_deallocate = */ FALSE((boolean_t) 0),
4108	/* msgt_unused = */ 0
4109	};
4110
4111	mig_routine_t routine;
4112
4113	OutP->Head.msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REPLY(InP->msgh_bits), 0)(((((InP->msgh_bits) & 0x0000ff00) >> 8)) \| ((0) << 8));
4114	OutP->Head.msgh_size = sizeof *OutP;
4115	OutP->Head.msgh_remote_port = InP->msgh_reply_portmsgh_local_port;
4116	OutP->Head.msgh_local_port = MACH_PORT_NULL((mach_port_t) 0);
4117	OutP->Head.msgh_seqno = 0;
4118	OutP->Head.msgh_id = InP->msgh_id + 100;
4119
4120	OutP->RetCodeType = RetCodeType;
4121
4122	if ((InP->msgh_id > 2100) \|\| (InP->msgh_id < 2000) \|\|
4123	((routine = mach_server_routines[InP->msgh_id - 2000]) == 0)) {
4124	OutP->RetCode = MIG_BAD_ID-303;
4125	return FALSE((boolean_t) 0);
4126	}
4127	(*routine) (InP, &OutP->Head);
4128	return TRUE((boolean_t) 1);
4129	}
4130
4131	mig_external mig_routine_t mach_server_routine
4132	(const mach_msg_header_t *InHeadP)
4133	{
4134	int msgh_id;
4135
4136	msgh_id = InHeadP->msgh_id - 2000;
4137
4138	if ((msgh_id > 100) \|\| (msgh_id < 0))
4139	return 0;
4140
4141	return mach_server_routines[msgh_id];
4142	}
4143