[apple/xnu.git] / osfmk / ipc / mach_kernelrpc.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_types.h>
#include <mach/mach_traps.h>
#include <mach/mach_vm_server.h>
#include <mach/mach_port_server.h>
#include <mach/vm_map.h>
#include <kern/task.h>
#include <kern/ipc_tt.h>
#include <vm/vm_protos.h>

int
_kernelrpc_mach_vm_allocate_trap(struct _kernelrpc_mach_vm_allocate_trap_args *args)
{
	mach_vm_offset_t addr;
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	if (copyin(args->addr, (char *)&addr, sizeof (addr)))
		goto done;

	rv = mach_vm_allocate(task->map, &addr, args->size, args->flags);
	if (rv == KERN_SUCCESS)
		rv = copyout(&addr, args->addr, sizeof (addr));
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_vm_deallocate_trap(struct _kernelrpc_mach_vm_deallocate_args *args)
{
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_vm_deallocate(task->map, args->address, args->size);
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_vm_protect_trap(struct _kernelrpc_mach_vm_protect_args *args)
{
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_vm_protect(task->map, args->address, args->size,
	    args->set_maximum, args->new_protection);
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_vm_map_trap(struct _kernelrpc_mach_vm_map_trap_args *args)
{
	mach_vm_offset_t addr;
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	if (copyin(args->addr, (char *)&addr, sizeof (addr)))
		goto done;

	rv = mach_vm_map(task->map, &addr, args->size, args->mask, args->flags,
			IPC_PORT_NULL, 0, FALSE, args->cur_protection, VM_PROT_ALL,
			VM_INHERIT_DEFAULT);
	if (rv == KERN_SUCCESS)
		rv = copyout(&addr, args->addr, sizeof (addr));

done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_port_allocate_trap(struct _kernelrpc_mach_port_allocate_args *args)
{
	task_t task = port_name_to_task(args->target);
	mach_port_name_t name;
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_port_allocate(task->itk_space, args->right, &name);
	if (rv == KERN_SUCCESS)
		rv = copyout(&name, args->name, sizeof (name));

	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_port_destroy_trap(struct _kernelrpc_mach_port_destroy_args *args)
{
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_port_destroy(task->itk_space, args->name);
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_port_deallocate_trap(struct _kernelrpc_mach_port_deallocate_args *args)
{
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_port_deallocate(task->itk_space, args->name);
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_port_mod_refs_trap(struct _kernelrpc_mach_port_mod_refs_args *args)
{
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_port_mod_refs(task->itk_space, args->name, args->right, args->delta);
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}


int
_kernelrpc_mach_port_move_member_trap(struct _kernelrpc_mach_port_move_member_args *args)
{
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_port_move_member(task->itk_space, args->member, args->after);
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_port_insert_right_trap(struct _kernelrpc_mach_port_insert_right_args *args)
{
	task_t task = port_name_to_task(args->target);
	ipc_port_t port;
	mach_msg_type_name_t disp;
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = ipc_object_copyin(task->itk_space, args->poly, args->polyPoly,
	    (ipc_object_t *)&port);
	if (rv != KERN_SUCCESS)
		goto done;
	disp = ipc_object_copyin_type(args->polyPoly);

	rv = mach_port_insert_right(task->itk_space, args->name, port, disp);
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_port_insert_member_trap(struct _kernelrpc_mach_port_insert_member_args *args)
{
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_port_insert_member(task->itk_space, args->name, args->pset);
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}


int
_kernelrpc_mach_port_extract_member_trap(struct _kernelrpc_mach_port_extract_member_args *args)
{
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_port_extract_member(task->itk_space, args->name, args->pset);
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_port_construct_trap(struct _kernelrpc_mach_port_construct_args *args)
{
	task_t task = port_name_to_task(args->target);
	mach_port_name_t name;
	int rv = MACH_SEND_INVALID_DEST;
	mach_port_options_t options;

	if (copyin(args->options, (char *)&options, sizeof (options))) {
		rv = MACH_SEND_INVALID_DATA;
		goto done;
	}

	if (task != current_task())
		goto done;

	rv = mach_port_construct(task->itk_space, &options, args->context, &name);
	if (rv == KERN_SUCCESS)
		rv = copyout(&name, args->name, sizeof (name));

done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_port_destruct_trap(struct _kernelrpc_mach_port_destruct_args *args)
{
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_port_destruct(task->itk_space, args->name, args->srdelta, args->guard);
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_port_guard_trap(struct _kernelrpc_mach_port_guard_args *args)
{
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_port_guard(task->itk_space, args->name, args->guard, args->strict);
	
done:
	if (task)
		task_deallocate(task);
	return (rv);
}

int
_kernelrpc_mach_port_unguard_trap(struct _kernelrpc_mach_port_unguard_args *args)
{
	task_t task = port_name_to_task(args->target);
	int rv = MACH_SEND_INVALID_DEST;

	if (task != current_task())
		goto done;

	rv = mach_port_unguard(task->itk_space, args->name, args->guard);
	
done:
	if (task)
		task_deallocate(task);
	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_types.h>
	30	#include <mach/mach_traps.h>
	31	#include <mach/mach_vm_server.h>
	32	#include <mach/mach_port_server.h>
	33	#include <mach/vm_map.h>
	34	#include <kern/task.h>
	35	#include <kern/ipc_tt.h>
	36	#include <vm/vm_protos.h>
	37
	38	int
	39	_kernelrpc_mach_vm_allocate_trap(struct _kernelrpc_mach_vm_allocate_trap_args *args)
	40	{
	41	mach_vm_offset_t addr;
	42	task_t task = port_name_to_task(args->target);
	43	int rv = MACH_SEND_INVALID_DEST;
	44
	45	if (task != current_task())
	46	goto done;
	47
	48	if (copyin(args->addr, (char *)&addr, sizeof (addr)))
	49	goto done;
	50
	51	rv = mach_vm_allocate(task->map, &addr, args->size, args->flags);
	52	if (rv == KERN_SUCCESS)
	53	rv = copyout(&addr, args->addr, sizeof (addr));
	54
	55	done:
	56	if (task)
	57	task_deallocate(task);
	58	return (rv);
	59	}
	60
	61	int
	62	_kernelrpc_mach_vm_deallocate_trap(struct _kernelrpc_mach_vm_deallocate_args *args)
	63	{
	64	task_t task = port_name_to_task(args->target);
65	int rv = MACH_SEND_INVALID_DEST;
66
67	if (task != current_task())
68	goto done;
69
70	rv = mach_vm_deallocate(task->map, args->address, args->size);
71
72	done:
73	if (task)
74	task_deallocate(task);
75	return (rv);
76	}
77
78	int
79	_kernelrpc_mach_vm_protect_trap(struct _kernelrpc_mach_vm_protect_args *args)
80	{
81	task_t task = port_name_to_task(args->target);
82	int rv = MACH_SEND_INVALID_DEST;
83
84	if (task != current_task())
85	goto done;
86
87	rv = mach_vm_protect(task->map, args->address, args->size,
88	args->set_maximum, args->new_protection);
89
90	done:
91	if (task)
92	task_deallocate(task);
93	return (rv);
94	}
95
39236c6e A	96	int
	97	_kernelrpc_mach_vm_map_trap(struct _kernelrpc_mach_vm_map_trap_args *args)
	98	{
	99	mach_vm_offset_t addr;
	100	task_t task = port_name_to_task(args->target);
	101	int rv = MACH_SEND_INVALID_DEST;
	102
	103	if (task != current_task())
	104	goto done;
	105
	106	if (copyin(args->addr, (char *)&addr, sizeof (addr)))
	107	goto done;
	108
	109	rv = mach_vm_map(task->map, &addr, args->size, args->mask, args->flags,
	110	IPC_PORT_NULL, 0, FALSE, args->cur_protection, VM_PROT_ALL,
	111	VM_INHERIT_DEFAULT);
	112	if (rv == KERN_SUCCESS)
	113	rv = copyout(&addr, args->addr, sizeof (addr));
	114
	115	done:
	116	if (task)
	117	task_deallocate(task);
	118	return (rv);
	119	}
	120
316670eb A	121	int
	122	_kernelrpc_mach_port_allocate_trap(struct _kernelrpc_mach_port_allocate_args *args)
	123	{
	124	task_t task = port_name_to_task(args->target);
	125	mach_port_name_t name;
	126	int rv = MACH_SEND_INVALID_DEST;
	127
	128	if (task != current_task())
	129	goto done;
	130
	131	rv = mach_port_allocate(task->itk_space, args->right, &name);
	132	if (rv == KERN_SUCCESS)
	133	rv = copyout(&name, args->name, sizeof (name));
	134
	135
	136	done:
	137	if (task)
	138	task_deallocate(task);
	139	return (rv);
	140	}
	141
	142	int
	143	_kernelrpc_mach_port_destroy_trap(struct _kernelrpc_mach_port_destroy_args *args)
	144	{
	145	task_t task = port_name_to_task(args->target);
	146	int rv = MACH_SEND_INVALID_DEST;
	147
	148	if (task != current_task())
	149	goto done;
	150
	151	rv = mach_port_destroy(task->itk_space, args->name);
	152
	153	done:
	154	if (task)
	155	task_deallocate(task);
	156	return (rv);
	157	}
	158
	159	int
	160	_kernelrpc_mach_port_deallocate_trap(struct _kernelrpc_mach_port_deallocate_args *args)
	161	{
	162	task_t task = port_name_to_task(args->target);
	163	int rv = MACH_SEND_INVALID_DEST;
	164
	165	if (task != current_task())
	166	goto done;
	167
	168	rv = mach_port_deallocate(task->itk_space, args->name);
	169
	170	done:
	171	if (task)
	172	task_deallocate(task);
	173	return (rv);
	174	}
	175
	176	int
	177	_kernelrpc_mach_port_mod_refs_trap(struct _kernelrpc_mach_port_mod_refs_args *args)
	178	{
	179	task_t task = port_name_to_task(args->target);
	180	int rv = MACH_SEND_INVALID_DEST;
	181
	182	if (task != current_task())
	183	goto done;
	184
185	rv = mach_port_mod_refs(task->itk_space, args->name, args->right, args->delta);
186
187	done:
188	if (task)
189	task_deallocate(task);
190	return (rv);
191	}
192
193
194	int
195	_kernelrpc_mach_port_move_member_trap(struct _kernelrpc_mach_port_move_member_args *args)
196	{
197	task_t task = port_name_to_task(args->target);
198	int rv = MACH_SEND_INVALID_DEST;
199
200	if (task != current_task())
201	goto done;
202
203	rv = mach_port_move_member(task->itk_space, args->member, args->after);
204
205	done:
206	if (task)
207	task_deallocate(task);
208	return (rv);
209	}
210
211	int
212	_kernelrpc_mach_port_insert_right_trap(struct _kernelrpc_mach_port_insert_right_args *args)
213	{
214	task_t task = port_name_to_task(args->target);
215	ipc_port_t port;
216	mach_msg_type_name_t disp;
217	int rv = MACH_SEND_INVALID_DEST;
218
219	if (task != current_task())
220	goto done;
221
222	rv = ipc_object_copyin(task->itk_space, args->poly, args->polyPoly,
223	(ipc_object_t *)&port);
224	if (rv != KERN_SUCCESS)
225	goto done;
226	disp = ipc_object_copyin_type(args->polyPoly);
227
228	rv = mach_port_insert_right(task->itk_space, args->name, port, disp);
229
230	done:
231	if (task)
232	task_deallocate(task);
233	return (rv);
234	}
235
236	int
237	_kernelrpc_mach_port_insert_member_trap(struct _kernelrpc_mach_port_insert_member_args *args)
238	{
239	task_t task = port_name_to_task(args->target);
240	int rv = MACH_SEND_INVALID_DEST;
241
242	if (task != current_task())
243	goto done;
244
245	rv = mach_port_insert_member(task->itk_space, args->name, args->pset);
246
247	done:
248	if (task)
249	task_deallocate(task);
250	return (rv);
251	}
252
253
254	int
255	_kernelrpc_mach_port_extract_member_trap(struct _kernelrpc_mach_port_extract_member_args *args)
256	{
257	task_t task = port_name_to_task(args->target);
258	int rv = MACH_SEND_INVALID_DEST;
259
260	if (task != current_task())
261	goto done;
262
263	rv = mach_port_extract_member(task->itk_space, args->name, args->pset);
264
265	done:
266	if (task)
267	task_deallocate(task);
268	return (rv);
269	}
39236c6e A	270
	271	int
	272	_kernelrpc_mach_port_construct_trap(struct _kernelrpc_mach_port_construct_args *args)
	273	{
	274	task_t task = port_name_to_task(args->target);
	275	mach_port_name_t name;
	276	int rv = MACH_SEND_INVALID_DEST;
	277	mach_port_options_t options;
	278
	279	if (copyin(args->options, (char *)&options, sizeof (options))) {
	280	rv = MACH_SEND_INVALID_DATA;
	281	goto done;
	282	}
	283
	284	if (task != current_task())
	285	goto done;
	286
	287	rv = mach_port_construct(task->itk_space, &options, args->context, &name);
	288	if (rv == KERN_SUCCESS)
	289	rv = copyout(&name, args->name, sizeof (name));
	290
	291	done:
	292	if (task)
	293	task_deallocate(task);
	294	return (rv);
	295	}
	296
	297	int
	298	_kernelrpc_mach_port_destruct_trap(struct _kernelrpc_mach_port_destruct_args *args)
	299	{
	300	task_t task = port_name_to_task(args->target);
	301	int rv = MACH_SEND_INVALID_DEST;
	302
	303	if (task != current_task())
	304	goto done;
	305
	306	rv = mach_port_destruct(task->itk_space, args->name, args->srdelta, args->guard);
	307
	308	done:
	309	if (task)
	310	task_deallocate(task);
	311	return (rv);
	312	}
	313
	314	int
	315	_kernelrpc_mach_port_guard_trap(struct _kernelrpc_mach_port_guard_args *args)
	316	{
	317	task_t task = port_name_to_task(args->target);
	318	int rv = MACH_SEND_INVALID_DEST;
	319
	320	if (task != current_task())
	321	goto done;
	322
	323	rv = mach_port_guard(task->itk_space, args->name, args->guard, args->strict);
	324
	325	done:
	326	if (task)
	327	task_deallocate(task);
	328	return (rv);
	329	}
	330
	331	int
	332	_kernelrpc_mach_port_unguard_trap(struct _kernelrpc_mach_port_unguard_args *args)
	333	{
334	task_t task = port_name_to_task(args->target);
335	int rv = MACH_SEND_INVALID_DEST;
336
337	if (task != current_task())
338	goto done;
339
340	rv = mach_port_unguard(task->itk_space, args->name, args->guard);
341
342	done:
343	if (task)
344	task_deallocate(task);
345	return (rv);
346	}
347