[apple/xnu.git] / libsyscall / mach / mach_port.c

/*
 * Copyright (c) 2011 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

#include <mach/mach_port_internal.h>
#include <mach/mach.h>
#include <mach/mach_vm.h>
#include <mach/mach_traps.h>

kern_return_t
mach_port_names(
	ipc_space_t task,
	mach_port_name_array_t *names,
	mach_msg_type_number_t *namesCnt,
	mach_port_type_array_t *types,
	mach_msg_type_number_t *typesCnt)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_names(task, names, namesCnt, types,
			typesCnt);

	return (rv);
}

kern_return_t
mach_port_type(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_type_t *ptype)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_type(task, name, ptype);

	return (rv);
}

kern_return_t
mach_port_rename(
	ipc_space_t task,
	mach_port_name_t old_name,
	mach_port_name_t new_name)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_rename(task, old_name, new_name);

	return (rv);
}

kern_return_t
mach_port_allocate_name(
	ipc_space_t task,
	mach_port_right_t right,
	mach_port_name_t name)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_allocate_name(task, right, name);

	return (rv);
}

kern_return_t
mach_port_allocate(
	ipc_space_t task,
	mach_port_right_t right,
	mach_port_name_t *name)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_allocate_trap(task, right, name);

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_allocate(task, right, name);

	return (rv);
}

kern_return_t
mach_port_destroy(
	ipc_space_t task,
	mach_port_name_t name)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_destroy_trap(task, name);

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_destroy(task, name);

	return (rv);
}

kern_return_t
mach_port_deallocate(
	ipc_space_t task,
	mach_port_name_t name)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_deallocate_trap(task, name); 

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_deallocate(task,name);

	return (rv);
}

kern_return_t
mach_port_get_refs(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_right_t right,
	mach_port_urefs_t *refs)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_get_refs(task, name, right, refs);

	return (rv);
}

kern_return_t
mach_port_mod_refs(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_right_t right,
	mach_port_delta_t delta)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_mod_refs_trap(task, name, right, delta); 

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_mod_refs(task, name, right, delta);

	return (rv);
}

kern_return_t
mach_port_peek(
	ipc_space_t		task,
	mach_port_name_t	name,
	mach_msg_trailer_type_t trailer_type,
	mach_port_seqno_t	*seqnop,
	mach_msg_size_t		*msg_sizep,
	mach_msg_id_t		*msg_idp,
	mach_msg_trailer_info_t trailer_infop,
	mach_msg_type_number_t	*trailer_sizep)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_peek(task, name, trailer_type, 
				       seqnop, msg_sizep, msg_idp,
				       trailer_infop, trailer_sizep);

	return (rv);
}

kern_return_t
mach_port_set_mscount(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_mscount_t mscount)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_set_mscount(task, name, mscount);

	return (rv);
}

kern_return_t
mach_port_get_set_status(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_name_array_t *members,
	mach_msg_type_number_t *membersCnt)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_get_set_status(task, name, members,
			membersCnt);

	return (rv);
}

kern_return_t
mach_port_move_member(
	ipc_space_t task,
	mach_port_name_t member,
	mach_port_name_t after)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_move_member_trap(task, member, after);

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_move_member(task, member, after);

	return (rv);
}

kern_return_t
mach_port_request_notification(
	ipc_space_t task,
	mach_port_name_t name,
	mach_msg_id_t msgid,
	mach_port_mscount_t sync,
	mach_port_t notify,
	mach_msg_type_name_t notifyPoly,
	mach_port_t *previous)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_request_notification(task, name, msgid,
		sync, notify, notifyPoly, previous);

	return (rv);
}

kern_return_t
mach_port_insert_right(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_t poly,
	mach_msg_type_name_t polyPoly)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_insert_right_trap(task, name, poly, polyPoly); 

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_insert_right(task, name, poly,
		    polyPoly);

	return (rv);
}

kern_return_t
mach_port_extract_right(
	ipc_space_t task,
	mach_port_name_t name,
	mach_msg_type_name_t msgt_name,
	mach_port_t *poly,
	mach_msg_type_name_t *polyPoly)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_extract_right(task, name, msgt_name,
		poly, polyPoly);

	return (rv);
}

kern_return_t
mach_port_set_seqno(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_seqno_t seqno)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_set_seqno(task, name, seqno);

	return (rv);
}

kern_return_t
mach_port_get_attributes(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_flavor_t flavor,
	mach_port_info_t port_info_out,
	mach_msg_type_number_t *port_info_outCnt)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_get_attributes(task, name, flavor,
			port_info_out, port_info_outCnt);

	return (rv);
}

kern_return_t
mach_port_set_attributes(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_flavor_t flavor,
	mach_port_info_t port_info,
	mach_msg_type_number_t port_infoCnt)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_set_attributes(task, name, flavor,
			port_info, port_infoCnt);

	return (rv);
}

kern_return_t
mach_port_allocate_qos(
	ipc_space_t task,
	mach_port_right_t right,
	mach_port_qos_t *qos,
	mach_port_name_t *name)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_allocate_qos(task, right, qos, name);

	return (rv);
}

kern_return_t
mach_port_allocate_full(
	ipc_space_t task,
	mach_port_right_t right,
	mach_port_t proto,
	mach_port_qos_t *qos,
	mach_port_name_t *name)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_allocate_full(task, right, proto, qos, name);

	return (rv);
}

kern_return_t
task_set_port_space(
	ipc_space_t task,
	int table_entries)
{
	kern_return_t rv;

	rv = _kernelrpc_task_set_port_space(task, table_entries);

	return (rv);
}

kern_return_t
mach_port_get_srights(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_rights_t *srights)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_get_srights(task, name, srights);

	return (rv);
}

kern_return_t
mach_port_space_info(
	ipc_space_t task,
	ipc_info_space_t *space_info,
	ipc_info_name_array_t *table_info,
	mach_msg_type_number_t *table_infoCnt,
	ipc_info_tree_name_array_t *tree_info,
	mach_msg_type_number_t *tree_infoCnt)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_space_info(task, space_info, table_info,
			table_infoCnt, tree_info, tree_infoCnt);

	return (rv);
}

kern_return_t
mach_port_dnrequest_info(
	ipc_space_t task,
	mach_port_name_t name,
	unsigned *dnr_total,
	unsigned *dnr_used)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_dnrequest_info(task, name, dnr_total,
			dnr_used);

	return (rv);
}

kern_return_t
mach_port_kernel_object(
	ipc_space_t task,
	mach_port_name_t name,
	unsigned *object_type,
	unsigned *object_addr)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_kernel_object(task, name,
			object_type, object_addr);

	return (rv);
}

kern_return_t
mach_port_insert_member(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_name_t pset)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_insert_member_trap(task, name, pset);

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_insert_member(task, name, pset);

	return (rv);
}

kern_return_t
mach_port_extract_member(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_name_t pset)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_extract_member_trap(task, name, pset); 

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_extract_member(task, name, pset);

	return (rv);
}

kern_return_t
mach_port_get_context(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_context_t *context)
{
	kern_return_t rv;
	mach_vm_address_t wide_context;

	rv = _kernelrpc_mach_port_get_context(task, name, &wide_context);

	if (rv == KERN_SUCCESS) {
		*context = (mach_port_context_t)wide_context;
	}

	return (rv);
}

kern_return_t
mach_port_set_context(
	ipc_space_t task,
	mach_port_name_t name,
	mach_port_context_t context)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_set_context(task, name, context);

	return (rv);
}

kern_return_t
mach_port_kobject(
	ipc_space_t task,
	mach_port_name_t name,
	natural_t *object_type,
	mach_vm_address_t *object_addr)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_kobject(task, name, object_type, object_addr);

	return (rv);
}

kern_return_t
mach_port_construct(
	ipc_space_t		task,
	mach_port_options_t	*options,
	mach_port_context_t	context,
	mach_port_name_t	*name)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_construct_trap(task, options, (uint64_t) context, name);

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_construct(task, options, (uint64_t) context, name);

	return (rv);
}

kern_return_t
mach_port_destruct(
	ipc_space_t		task,
	mach_port_name_t	name,
	mach_port_delta_t	srdelta,
	mach_port_context_t	guard)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_destruct_trap(task, name, srdelta, (uint64_t) guard);

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_destruct(task, name, srdelta, (uint64_t) guard);

	return (rv);

}

kern_return_t
mach_port_guard(
	ipc_space_t		task,
	mach_port_name_t	name,
	mach_port_context_t	guard,
	boolean_t		strict)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_guard_trap(task, name, (uint64_t) guard, strict);

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_guard(task, name, (uint64_t) guard, strict);

	return (rv);

}

kern_return_t
mach_port_unguard(
	ipc_space_t		task,
	mach_port_name_t	name,
	mach_port_context_t	guard)
{
	kern_return_t rv;

	rv = _kernelrpc_mach_port_unguard_trap(task, name, (uint64_t) guard);

	if (rv == MACH_SEND_INVALID_DEST)
		rv = _kernelrpc_mach_port_unguard(task, name, (uint64_t) guard);

	return (rv);

}
Commit	Line	Data
316670eb A	1	/*
	2	* Copyright (c) 2011 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28
	29	#include <mach/mach_port_internal.h>
	30	#include <mach/mach.h>
	31	#include <mach/mach_vm.h>
	32	#include <mach/mach_traps.h>
	33
	34	kern_return_t
	35	mach_port_names(
	36	ipc_space_t task,
	37	mach_port_name_array_t *names,
	38	mach_msg_type_number_t *namesCnt,
	39	mach_port_type_array_t *types,
	40	mach_msg_type_number_t *typesCnt)
	41	{
	42	kern_return_t rv;
	43
	44	rv = _kernelrpc_mach_port_names(task, names, namesCnt, types,
	45	typesCnt);
	46
	47	return (rv);
	48	}
	49
	50	kern_return_t
	51	mach_port_type(
	52	ipc_space_t task,
	53	mach_port_name_t name,
	54	mach_port_type_t *ptype)
	55	{
	56	kern_return_t rv;
	57
	58	rv = _kernelrpc_mach_port_type(task, name, ptype);
	59
	60	return (rv);
	61	}
	62
	63	kern_return_t
	64	mach_port_rename(
65	ipc_space_t task,
66	mach_port_name_t old_name,
67	mach_port_name_t new_name)
68	{
69	kern_return_t rv;
70
71	rv = _kernelrpc_mach_port_rename(task, old_name, new_name);
72
73	return (rv);
74	}
75
76	kern_return_t
77	mach_port_allocate_name(
78	ipc_space_t task,
79	mach_port_right_t right,
80	mach_port_name_t name)
81	{
82	kern_return_t rv;
83
84	rv = _kernelrpc_mach_port_allocate_name(task, right, name);
85
86	return (rv);
87	}
88
89	kern_return_t
90	mach_port_allocate(
91	ipc_space_t task,
92	mach_port_right_t right,
93	mach_port_name_t *name)
94	{
95	kern_return_t rv;
96
97	rv = _kernelrpc_mach_port_allocate_trap(task, right, name);
98
99	if (rv == MACH_SEND_INVALID_DEST)
100	rv = _kernelrpc_mach_port_allocate(task, right, name);
101
102	return (rv);
103	}
104
105	kern_return_t
106	mach_port_destroy(
107	ipc_space_t task,
108	mach_port_name_t name)
109	{
110	kern_return_t rv;
111
112	rv = _kernelrpc_mach_port_destroy_trap(task, name);
113
114	if (rv == MACH_SEND_INVALID_DEST)
115	rv = _kernelrpc_mach_port_destroy(task, name);
116
117	return (rv);
118	}
119
120	kern_return_t
121	mach_port_deallocate(
122	ipc_space_t task,
123	mach_port_name_t name)
124	{
125	kern_return_t rv;
126
127	rv = _kernelrpc_mach_port_deallocate_trap(task, name);
128
129	if (rv == MACH_SEND_INVALID_DEST)
130	rv = _kernelrpc_mach_port_deallocate(task,name);
131
132	return (rv);
133	}
134
135	kern_return_t
136	mach_port_get_refs(
137	ipc_space_t task,
138	mach_port_name_t name,
139	mach_port_right_t right,
140	mach_port_urefs_t *refs)
141	{
142	kern_return_t rv;
143
144	rv = _kernelrpc_mach_port_get_refs(task, name, right, refs);
145
146	return (rv);
147	}
148
149	kern_return_t
150	mach_port_mod_refs(
151	ipc_space_t task,
152	mach_port_name_t name,
153	mach_port_right_t right,
154	mach_port_delta_t delta)
155	{
156	kern_return_t rv;
157
158	rv = _kernelrpc_mach_port_mod_refs_trap(task, name, right, delta);
159
160	if (rv == MACH_SEND_INVALID_DEST)
161	rv = _kernelrpc_mach_port_mod_refs(task, name, right, delta);
162
163	return (rv);
164	}
165
39236c6e A	166	kern_return_t
	167	mach_port_peek(
	168	ipc_space_t task,
	169	mach_port_name_t name,
	170	mach_msg_trailer_type_t trailer_type,
	171	mach_port_seqno_t *seqnop,
	172	mach_msg_size_t *msg_sizep,
	173	mach_msg_id_t *msg_idp,
	174	mach_msg_trailer_info_t trailer_infop,
	175	mach_msg_type_number_t *trailer_sizep)
	176	{
	177	kern_return_t rv;
	178
	179	rv = _kernelrpc_mach_port_peek(task, name, trailer_type,
	180	seqnop, msg_sizep, msg_idp,
	181	trailer_infop, trailer_sizep);
	182
	183	return (rv);
	184	}
	185
316670eb A	186	kern_return_t
	187	mach_port_set_mscount(
	188	ipc_space_t task,
	189	mach_port_name_t name,
	190	mach_port_mscount_t mscount)
	191	{
	192	kern_return_t rv;
	193
	194	rv = _kernelrpc_mach_port_set_mscount(task, name, mscount);
	195
	196	return (rv);
	197	}
	198
	199	kern_return_t
	200	mach_port_get_set_status(
	201	ipc_space_t task,
	202	mach_port_name_t name,
	203	mach_port_name_array_t *members,
	204	mach_msg_type_number_t *membersCnt)
	205	{
	206	kern_return_t rv;
	207
	208	rv = _kernelrpc_mach_port_get_set_status(task, name, members,
	209	membersCnt);
	210
	211	return (rv);
	212	}
	213
	214	kern_return_t
	215	mach_port_move_member(
	216	ipc_space_t task,
	217	mach_port_name_t member,
	218	mach_port_name_t after)
	219	{
	220	kern_return_t rv;
	221
	222	rv = _kernelrpc_mach_port_move_member_trap(task, member, after);
	223
	224	if (rv == MACH_SEND_INVALID_DEST)
	225	rv = _kernelrpc_mach_port_move_member(task, member, after);
	226
	227	return (rv);
	228	}
	229
	230	kern_return_t
	231	mach_port_request_notification(
	232	ipc_space_t task,
	233	mach_port_name_t name,
	234	mach_msg_id_t msgid,
	235	mach_port_mscount_t sync,
	236	mach_port_t notify,
	237	mach_msg_type_name_t notifyPoly,
	238	mach_port_t *previous)
	239	{
	240	kern_return_t rv;
	241
	242	rv = _kernelrpc_mach_port_request_notification(task, name, msgid,
	243	sync, notify, notifyPoly, previous);
	244
	245	return (rv);
	246	}
	247
	248	kern_return_t
	249	mach_port_insert_right(
250	ipc_space_t task,
251	mach_port_name_t name,
252	mach_port_t poly,
253	mach_msg_type_name_t polyPoly)
254	{
255	kern_return_t rv;
256
257	rv = _kernelrpc_mach_port_insert_right_trap(task, name, poly, polyPoly);
258
259	if (rv == MACH_SEND_INVALID_DEST)
260	rv = _kernelrpc_mach_port_insert_right(task, name, poly,
261	polyPoly);
262
263	return (rv);
264	}
265
266	kern_return_t
267	mach_port_extract_right(
268	ipc_space_t task,
269	mach_port_name_t name,
270	mach_msg_type_name_t msgt_name,
271	mach_port_t *poly,
272	mach_msg_type_name_t *polyPoly)
273	{
274	kern_return_t rv;
275
276	rv = _kernelrpc_mach_port_extract_right(task, name, msgt_name,
277	poly, polyPoly);
278
279	return (rv);
280	}
281
282	kern_return_t
283	mach_port_set_seqno(
284	ipc_space_t task,
285	mach_port_name_t name,
286	mach_port_seqno_t seqno)
287	{
288	kern_return_t rv;
289
290	rv = _kernelrpc_mach_port_set_seqno(task, name, seqno);
291
292	return (rv);
293	}
294
295	kern_return_t
296	mach_port_get_attributes(
297	ipc_space_t task,
298	mach_port_name_t name,
299	mach_port_flavor_t flavor,
300	mach_port_info_t port_info_out,
301	mach_msg_type_number_t *port_info_outCnt)
302	{
303	kern_return_t rv;
304
305	rv = _kernelrpc_mach_port_get_attributes(task, name, flavor,
306	port_info_out, port_info_outCnt);
307
308	return (rv);
309	}
310
311	kern_return_t
312	mach_port_set_attributes(
313	ipc_space_t task,
314	mach_port_name_t name,
315	mach_port_flavor_t flavor,
316	mach_port_info_t port_info,
317	mach_msg_type_number_t port_infoCnt)
318	{
319	kern_return_t rv;
320
321	rv = _kernelrpc_mach_port_set_attributes(task, name, flavor,
322	port_info, port_infoCnt);
323
324	return (rv);
325	}
326
327	kern_return_t
328	mach_port_allocate_qos(
329	ipc_space_t task,
330	mach_port_right_t right,
331	mach_port_qos_t *qos,
332	mach_port_name_t *name)
333	{
334	kern_return_t rv;
335
336	rv = _kernelrpc_mach_port_allocate_qos(task, right, qos, name);
337
338	return (rv);
339	}
340
341	kern_return_t
342	mach_port_allocate_full(
343	ipc_space_t task,
344	mach_port_right_t right,
345	mach_port_t proto,
346	mach_port_qos_t *qos,
347	mach_port_name_t *name)
348	{
349	kern_return_t rv;
350
351	rv = _kernelrpc_mach_port_allocate_full(task, right, proto, qos, name);
352
353	return (rv);
354	}
355
356	kern_return_t
357	task_set_port_space(
358	ipc_space_t task,
359	int table_entries)
360	{
361	kern_return_t rv;
362
363	rv = _kernelrpc_task_set_port_space(task, table_entries);
364
365	return (rv);
366	}
367
368	kern_return_t
369	mach_port_get_srights(
370	ipc_space_t task,
371	mach_port_name_t name,
372	mach_port_rights_t *srights)
373	{
374	kern_return_t rv;
375
376	rv = _kernelrpc_mach_port_get_srights(task, name, srights);
377
378	return (rv);
379	}
380
381	kern_return_t
382	mach_port_space_info(
383	ipc_space_t task,
384	ipc_info_space_t *space_info,
385	ipc_info_name_array_t *table_info,
386	mach_msg_type_number_t *table_infoCnt,
387	ipc_info_tree_name_array_t *tree_info,
388	mach_msg_type_number_t *tree_infoCnt)
389	{
390	kern_return_t rv;
391
392	rv = _kernelrpc_mach_port_space_info(task, space_info, table_info,
393	table_infoCnt, tree_info, tree_infoCnt);
394
395	return (rv);
396	}
397
398	kern_return_t
399	mach_port_dnrequest_info(
400	ipc_space_t task,
401	mach_port_name_t name,
402	unsigned *dnr_total,
403	unsigned *dnr_used)
404	{
405	kern_return_t rv;
406
407	rv = _kernelrpc_mach_port_dnrequest_info(task, name, dnr_total,
408	dnr_used);
409
410	return (rv);
411	}
412
413	kern_return_t
414	mach_port_kernel_object(
415	ipc_space_t task,
416	mach_port_name_t name,
417	unsigned *object_type,
418	unsigned *object_addr)
419	{
420	kern_return_t rv;
421
422	rv = _kernelrpc_mach_port_kernel_object(task, name,
423	object_type, object_addr);
424
425	return (rv);
426	}
427
428	kern_return_t
429	mach_port_insert_member(
430	ipc_space_t task,
431	mach_port_name_t name,
432	mach_port_name_t pset)
433	{
434	kern_return_t rv;
435
436	rv = _kernelrpc_mach_port_insert_member_trap(task, name, pset);
437
438	if (rv == MACH_SEND_INVALID_DEST)
439	rv = _kernelrpc_mach_port_insert_member(task, name, pset);
440
441	return (rv);
442	}
443
444	kern_return_t
445	mach_port_extract_member(
446	ipc_space_t task,
447	mach_port_name_t name,
448	mach_port_name_t pset)
449	{
450	kern_return_t rv;
451
452	rv = _kernelrpc_mach_port_extract_member_trap(task, name, pset);
453
454	if (rv == MACH_SEND_INVALID_DEST)
455	rv = _kernelrpc_mach_port_extract_member(task, name, pset);
456
457	return (rv);
458	}
459
460	kern_return_t
461	mach_port_get_context(
462	ipc_space_t task,
463	mach_port_name_t name,
464	mach_port_context_t *context)
465	{
466	kern_return_t rv;
467	mach_vm_address_t wide_context;
468
469	rv = _kernelrpc_mach_port_get_context(task, name, &wide_context);
470
471	if (rv == KERN_SUCCESS) {
472	*context = (mach_port_context_t)wide_context;
473	}
474
475	return (rv);
476	}
477
478	kern_return_t
479	mach_port_set_context(
480	ipc_space_t task,
481	mach_port_name_t name,
482	mach_port_context_t context)
483	{
484	kern_return_t rv;
485
486	rv = _kernelrpc_mach_port_set_context(task, name, context);
487
488	return (rv);
489	}
490
491	kern_return_t
492	mach_port_kobject(
493	ipc_space_t task,
494	mach_port_name_t name,
495	natural_t *object_type,
496	mach_vm_address_t *object_addr)
497	{
498	kern_return_t rv;
499
500	rv = _kernelrpc_mach_port_kobject(task, name, object_type, object_addr);
501
502	return (rv);
503	}
39236c6e A	504
	505	kern_return_t
	506	mach_port_construct(
	507	ipc_space_t task,
	508	mach_port_options_t *options,
	509	mach_port_context_t context,
	510	mach_port_name_t *name)
	511	{
	512	kern_return_t rv;
	513
	514	rv = _kernelrpc_mach_port_construct_trap(task, options, (uint64_t) context, name);
	515
	516	if (rv == MACH_SEND_INVALID_DEST)
	517	rv = _kernelrpc_mach_port_construct(task, options, (uint64_t) context, name);
	518
	519	return (rv);
	520	}
	521
	522	kern_return_t
	523	mach_port_destruct(
	524	ipc_space_t task,
	525	mach_port_name_t name,
	526	mach_port_delta_t srdelta,
	527	mach_port_context_t guard)
	528	{
	529	kern_return_t rv;
	530
	531	rv = _kernelrpc_mach_port_destruct_trap(task, name, srdelta, (uint64_t) guard);
	532
	533	if (rv == MACH_SEND_INVALID_DEST)
	534	rv = _kernelrpc_mach_port_destruct(task, name, srdelta, (uint64_t) guard);
	535
	536	return (rv);
	537
	538	}
	539
	540	kern_return_t
	541	mach_port_guard(
	542	ipc_space_t task,
	543	mach_port_name_t name,
	544	mach_port_context_t guard,
	545	boolean_t strict)
	546	{
	547	kern_return_t rv;
	548
	549	rv = _kernelrpc_mach_port_guard_trap(task, name, (uint64_t) guard, strict);
	550
	551	if (rv == MACH_SEND_INVALID_DEST)
	552	rv = _kernelrpc_mach_port_guard(task, name, (uint64_t) guard, strict);
	553
	554	return (rv);
	555
	556	}
	557
	558	kern_return_t
	559	mach_port_unguard(
	560	ipc_space_t task,
	561	mach_port_name_t name,
	562	mach_port_context_t guard)
	563	{
	564	kern_return_t rv;
	565
	566	rv = _kernelrpc_mach_port_unguard_trap(task, name, (uint64_t) guard);
	567
568	if (rv == MACH_SEND_INVALID_DEST)
569	rv = _kernelrpc_mach_port_unguard(task, name, (uint64_t) guard);
570
571	return (rv);
572
573	}
574