WebSVN – HelenOS – Blame – /trunk/kernel/generic/src/ipc/sysipc.c

Rev	Author	Line No.	Line
1027	palkovsky	1	/*
2071	jermar	2	* Copyright (c) 2006 Ondrej Palkovsky
1027	palkovsky	3	* All rights reserved.
		4	*
		5	* Redistribution and use in source and binary forms, with or without
		6	* modification, are permitted provided that the following conditions
		7	* are met:
		8	*
		9	* - Redistributions of source code must retain the above copyright
		10	* notice, this list of conditions and the following disclaimer.
		11	* - Redistributions in binary form must reproduce the above copyright
		12	* notice, this list of conditions and the following disclaimer in the
		13	* documentation and/or other materials provided with the distribution.
		14	* - The name of the author may not be used to endorse or promote products
		15	* derived from this software without specific prior written permission.
		16	*
		17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
		18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
		19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
		20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
		21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
		22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
		23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
		24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
		26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		27	*/
		28
1757	jermar	29	/** @addtogroup genericipc
1702	cejka	30	* @{
		31	*/
		32	/** @file
		33	*/
		34
1027	palkovsky	35	#include <arch.h>
		36	#include <proc/task.h>
1288	jermar	37	#include <proc/thread.h>
1027	palkovsky	38	#include <errno.h>
		39	#include <memstr.h>
		40	#include <debug.h>
		41	#include <ipc/ipc.h>
		42	#include <ipc/sysipc.h>
1281	palkovsky	43	#include <ipc/irq.h>
1072	palkovsky	44	#include <ipc/ipcrsc.h>
3445	jermar	45	#include <ipc/kbox.h>
3438	svoboda	46	#include <udebug/udebug_ipc.h>
1258	palkovsky	47	#include <arch/interrupt.h>
1288	jermar	48	#include <syscall/copy.h>
1297	jermar	49	#include <security/cap.h>
1329	palkovsky	50	#include <mm/as.h>
1875	jermar	51	#include <print.h>
1027	palkovsky	52
2660	jermar	53	/**
		54	* Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ
		55	* requests.
		56	*/
		57	#define DATA_XFER_LIMIT (64 * 1024)
2494	jermar	58
2471	jermar	59	#define GET_CHECK_PHONE(phone, phoneid, err) \
		60	{ \
		61	if (phoneid > IPC_MAX_PHONES) { \
		62	err; \
		63	} \
		64	phone = &TASK->phones[phoneid]; \
1084	palkovsky	65	}
		66
2471	jermar	67	#define STRUCT_TO_USPACE(dst, src) copy_to_uspace(dst, src, sizeof(*(src)))
1084	palkovsky	68
2471	jermar	69	/** Decide if the method is a system method.
		70	*
		71	* @param method Method to be decided.
		72	*
		73	* @return Return 1 if the method is a system method.
		74	* Otherwise return 0.
		75	*/
2557	jermar	76	static inline int method_is_system(unative_t method)
1040	palkovsky	77	{
		78	if (method <= IPC_M_LAST_SYSTEM)
		79	return 1;
		80	return 0;
		81	}
		82
2471	jermar	83	/** Decide if the message with this method is forwardable.
1040	palkovsky	84	*
		85	* - some system messages may be forwarded, for some of them
		86	* it is useless
2471	jermar	87	*
		88	* @param method Method to be decided.
		89	*
		90	* @return Return 1 if the method is forwardable.
		91	* Otherwise return 0.
1040	palkovsky	92	*/
2557	jermar	93	static inline int method_is_forwardable(unative_t method)
1040	palkovsky	94	{
2494	jermar	95	switch (method) {
4407	jermar	96	case IPC_M_CONNECTION_CLONE:
		97	case IPC_M_CONNECT_ME:
2494	jermar	98	case IPC_M_PHONE_HUNGUP:
		99	/* This message is meant only for the original recipient. */
		100	return 0;
		101	default:
		102	return 1;
		103	}
1040	palkovsky	104	}
		105
2557	jermar	106	/** Decide if the message with this method is immutable on forward.
		107	*
2601	jermar	108	* - some system messages may be forwarded but their content cannot be altered
2557	jermar	109	*
		110	* @param method Method to be decided.
		111	*
		112	* @return Return 1 if the method is immutable on forward.
		113	* Otherwise return 0.
		114	*/
		115	static inline int method_is_immutable(unative_t method)
		116	{
		117	switch (method) {
2677	jermar	118	case IPC_M_SHARE_OUT:
		119	case IPC_M_SHARE_IN:
2660	jermar	120	case IPC_M_DATA_WRITE:
		121	case IPC_M_DATA_READ:
2557	jermar	122	return 1;
		123	break;
		124	default:
		125	return 0;
		126	}
		127	}
1027	palkovsky	128
2557	jermar	129
2471	jermar	130	/***********************************************************************
		131	* Functions that preprocess answer before sending it to the recepient.
		132	***********************************************************************/
		133
		134	/** Decide if the caller (e.g. ipc_answer()) should save the old call contents
		135	* for answer_preprocess().
		136	*
		137	* @param call Call structure to be decided.
		138	*
		139	* @return Return 1 if the old call contents should be saved.
		140	* Return 0 otherwise.
1027	palkovsky	141	*/
1088	palkovsky	142	static inline int answer_need_old(call_t *call)
1027	palkovsky	143	{
2494	jermar	144	switch (IPC_GET_METHOD(call->data)) {
4407	jermar	145	case IPC_M_CONNECTION_CLONE:
		146	case IPC_M_CONNECT_ME:
2494	jermar	147	case IPC_M_CONNECT_TO_ME:
		148	case IPC_M_CONNECT_ME_TO:
2677	jermar	149	case IPC_M_SHARE_OUT:
		150	case IPC_M_SHARE_IN:
2660	jermar	151	case IPC_M_DATA_WRITE:
		152	case IPC_M_DATA_READ:
1027	palkovsky	153	return 1;
2494	jermar	154	default:
		155	return 0;
		156	}
1027	palkovsky	157	}
		158
2471	jermar	159	/** Interpret process answer as control information.
1428	palkovsky	160	*
2471	jermar	161	* This function is called directly after sys_ipc_answer().
		162	*
		163	* @param answer Call structure with the answer.
		164	* @param olddata Saved data of the request.
		165	*
		166	* @return Return 0 on success or an error code.
1428	palkovsky	167	*/
1329	palkovsky	168	static inline int answer_preprocess(call_t answer, ipc_data_t olddata)
1027	palkovsky	169	{
		170	int phoneid;
		171
2745	decky	172	if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
1141	palkovsky	173	/* In case of forward, hangup the forwared phone,
		174	* not the originator
		175	*/
3020	jermar	176	mutex_lock(&answer->data.phone->lock);
1141	palkovsky	177	spinlock_lock(&TASK->answerbox.lock);
1568	palkovsky	178	if (answer->data.phone->state == IPC_PHONE_CONNECTED) {
1573	palkovsky	179	list_remove(&answer->data.phone->link);
1568	palkovsky	180	answer->data.phone->state = IPC_PHONE_SLAMMED;
1141	palkovsky	181	}
		182	spinlock_unlock(&TASK->answerbox.lock);
3020	jermar	183	mutex_unlock(&answer->data.phone->lock);
1088	palkovsky	184	}
		185
		186	if (!olddata)
1329	palkovsky	187	return 0;
1088	palkovsky	188
4407	jermar	189	if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECTION_CLONE) {
		190	phoneid = IPC_GET_ARG1(*olddata);
		191	phone_t *phone = &TASK->phones[phoneid];
		192	if (IPC_GET_RETVAL(answer->data) != EOK) {
		193	/*
		194	* The recipient of the cloned phone rejected the offer.
		195	* In this case, the connection was established at the
		196	* request time and therefore we need to slam the phone.
		197	* We don't merely hangup as that would result in
		198	* sending IPC_M_HUNGUP to the third party on the
		199	* other side of the cloned phone.
		200	*/
		201	mutex_lock(&phone->lock);
		202	if (phone->state == IPC_PHONE_CONNECTED) {
		203	spinlock_lock(&phone->callee->lock);
		204	list_remove(&phone->link);
		205	phone->state = IPC_PHONE_SLAMMED;
		206	spinlock_unlock(&phone->callee->lock);
		207	}
		208	mutex_unlock(&phone->lock);
		209	}
		210	} else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME) {
		211	phone_t phone = (phone_t )IPC_GET_ARG5(*olddata);
		212	if (IPC_GET_RETVAL(answer->data) != EOK) {
		213	/*
		214	* The other party on the cloned phoned rejected our
		215	* request for connection on the protocol level.
		216	* We need to break the connection without sending
		217	* IPC_M_HUNGUP back.
		218	*/
		219	mutex_lock(&phone->lock);
		220	if (phone->state == IPC_PHONE_CONNECTED) {
		221	spinlock_lock(&phone->callee->lock);
		222	list_remove(&phone->link);
		223	phone->state = IPC_PHONE_SLAMMED;
		224	spinlock_unlock(&phone->callee->lock);
		225	}
		226	mutex_unlock(&phone->lock);
		227	}
		228	} else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
2637	cejka	229	phoneid = IPC_GET_ARG5(*olddata);
4407	jermar	230	if (IPC_GET_RETVAL(answer->data) != EOK) {
1027	palkovsky	231	/* The connection was not accepted */
		232	phone_dealloc(phoneid);
1040	palkovsky	233	} else {
1090	palkovsky	234	/* The connection was accepted */
2359	jermar	235	phone_connect(phoneid, &answer->sender->answerbox);
2638	jermar	236	/* Set 'phone hash' as arg5 of response */
2637	cejka	237	IPC_SET_ARG5(answer->data,
2359	jermar	238	(unative_t) &TASK->phones[phoneid]);
1027	palkovsky	239	}
1086	palkovsky	240	} else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
1060	palkovsky	241	/* If the users accepted call, connect */
4407	jermar	242	if (IPC_GET_RETVAL(answer->data) == EOK) {
2635	cejka	243	ipc_phone_connect((phone_t ) IPC_GET_ARG5(olddata),
2359	jermar	244	&TASK->answerbox);
1060	palkovsky	245	}
2677	jermar	246	} else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_OUT) {
2359	jermar	247	if (!IPC_GET_RETVAL(answer->data)) {
		248	/* Accepted, handle as_area receipt */
1413	jermar	249	ipl_t ipl;
1461	palkovsky	250	int rc;
1413	jermar	251	as_t *as;
		252
		253	ipl = interrupts_disable();
		254	spinlock_lock(&answer->sender->lock);
		255	as = answer->sender->as;
		256	spinlock_unlock(&answer->sender->lock);
		257	interrupts_restore(ipl);
		258
2359	jermar	259	rc = as_area_share(as, IPC_GET_ARG1(*olddata),
		260	IPC_GET_ARG2(*olddata), AS,
		261	IPC_GET_ARG1(answer->data), IPC_GET_ARG3(*olddata));
1461	palkovsky	262	IPC_SET_RETVAL(answer->data, rc);
		263	return rc;
1329	palkovsky	264	}
2677	jermar	265	} else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_IN) {
1428	palkovsky	266	if (!IPC_GET_RETVAL(answer->data)) {
		267	ipl_t ipl;
		268	as_t *as;
1434	palkovsky	269	int rc;
1428	palkovsky	270
		271	ipl = interrupts_disable();
		272	spinlock_lock(&answer->sender->lock);
		273	as = answer->sender->as;
		274	spinlock_unlock(&answer->sender->lock);
		275	interrupts_restore(ipl);
		276
2359	jermar	277	rc = as_area_share(AS, IPC_GET_ARG1(answer->data),
		278	IPC_GET_ARG2(olddata), as, IPC_GET_ARG1(olddata),
		279	IPC_GET_ARG2(answer->data));
1434	palkovsky	280	IPC_SET_RETVAL(answer->data, rc);
1428	palkovsky	281	}
2662	jermar	282	} else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_READ) {
		283	ASSERT(!answer->buffer);
		284	if (!IPC_GET_RETVAL(answer->data)) {
		285	/* The recipient agreed to send data. */
		286	uintptr_t src = IPC_GET_ARG1(answer->data);
		287	uintptr_t dst = IPC_GET_ARG1(*olddata);
		288	size_t max_size = IPC_GET_ARG2(*olddata);
		289	size_t size = IPC_GET_ARG2(answer->data);
2934	jermar	290	if (size && size <= max_size) {
2662	jermar	291	/*
		292	* Copy the destination VA so that this piece of
		293	* information is not lost.
		294	*/
		295	IPC_SET_ARG1(answer->data, dst);
		296
		297	answer->buffer = malloc(size, 0);
		298	int rc = copy_from_uspace(answer->buffer,
		299	(void *) src, size);
		300	if (rc) {
		301	IPC_SET_RETVAL(answer->data, rc);
		302	free(answer->buffer);
		303	answer->buffer = NULL;
		304	}
2934	jermar	305	} else if (!size) {
		306	IPC_SET_RETVAL(answer->data, EOK);
2662	jermar	307	} else {
		308	IPC_SET_RETVAL(answer->data, ELIMIT);
		309	}
		310	}
2660	jermar	311	} else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_WRITE) {
2661	jermar	312	ASSERT(answer->buffer);
2494	jermar	313	if (!IPC_GET_RETVAL(answer->data)) {
2662	jermar	314	/* The recipient agreed to receive data. */
2494	jermar	315	int rc;
		316	uintptr_t dst;
3332	jermar	317	size_t size;
		318	size_t max_size;
2494	jermar	319
3332	jermar	320	dst = (uintptr_t)IPC_GET_ARG1(answer->data);
		321	size = (size_t)IPC_GET_ARG2(answer->data);
		322	max_size = (size_t)IPC_GET_ARG2(*olddata);
2494	jermar	323
2662	jermar	324	if (size <= max_size) {
		325	rc = copy_to_uspace((void *) dst,
		326	answer->buffer, size);
		327	if (rc)
		328	IPC_SET_RETVAL(answer->data, rc);
		329	} else {
		330	IPC_SET_RETVAL(answer->data, ELIMIT);
		331	}
2494	jermar	332	}
2661	jermar	333	free(answer->buffer);
		334	answer->buffer = NULL;
1027	palkovsky	335	}
1329	palkovsky	336	return 0;
1027	palkovsky	337	}
		338
2471	jermar	339	/** Called before the request is sent.
1090	palkovsky	340	*
2471	jermar	341	* @param call Call structure with the request.
3438	svoboda	342	* @param phone Phone that the call will be sent through.
2471	jermar	343	*
		344	* @return Return 0 on success, ELIMIT or EPERM on error.
1090	palkovsky	345	*/
3438	svoboda	346	static int request_preprocess(call_t call, phone_t phone)
1090	palkovsky	347	{
		348	int newphid;
1329	palkovsky	349	size_t size;
2494	jermar	350	uintptr_t src;
		351	int rc;
1090	palkovsky	352
		353	switch (IPC_GET_METHOD(call->data)) {
4407	jermar	354	case IPC_M_CONNECTION_CLONE: {
		355	phone_t *cloned_phone;
		356	GET_CHECK_PHONE(cloned_phone, IPC_GET_ARG1(call->data),
		357	return ENOENT);
		358	if (cloned_phone < phone) {
		359	mutex_lock(&cloned_phone->lock);
		360	mutex_lock(&phone->lock);
		361	} else {
		362	mutex_lock(&phone->lock);
		363	mutex_lock(&cloned_phone->lock);
		364	}
		365	if ((cloned_phone->state != IPC_PHONE_CONNECTED) \|\|
		366	phone->state != IPC_PHONE_CONNECTED) {
		367	mutex_unlock(&cloned_phone->lock);
		368	mutex_unlock(&phone->lock);
		369	return EINVAL;
		370	}
		371	/*
		372	* We can be pretty sure now that both tasks exist and we are
		373	* connected to them. As we continue to hold the phone locks,
		374	* we are effectively preventing them from finishing their
		375	* potential cleanup.
		376	*/
		377	newphid = phone_alloc(phone->callee->task);
		378	if (newphid < 0) {
		379	mutex_unlock(&cloned_phone->lock);
		380	mutex_unlock(&phone->lock);
		381	return ELIMIT;
		382	}
		383	ipc_phone_connect(&phone->callee->task->phones[newphid],
		384	cloned_phone->callee);
		385	mutex_unlock(&cloned_phone->lock);
		386	mutex_unlock(&phone->lock);
		387	/* Set the new phone for the callee. */
		388	IPC_SET_ARG1(call->data, newphid);
		389	break;
		390	}
		391	case IPC_M_CONNECT_ME:
		392	IPC_SET_ARG5(call->data, (unative_t) phone);
		393	break;
1090	palkovsky	394	case IPC_M_CONNECT_ME_TO:
4407	jermar	395	newphid = phone_alloc(TASK);
1090	palkovsky	396	if (newphid < 0)
		397	return ELIMIT;
2638	jermar	398	/* Set arg5 for server */
2635	cejka	399	IPC_SET_ARG5(call->data, (unative_t) &TASK->phones[newphid]);
1090	palkovsky	400	call->flags \|= IPC_CALL_CONN_ME_TO;
2098	decky	401	call->priv = newphid;
1090	palkovsky	402	break;
2677	jermar	403	case IPC_M_SHARE_OUT:
2556	jermar	404	size = as_area_get_size(IPC_GET_ARG1(call->data));
2471	jermar	405	if (!size)
1329	palkovsky	406	return EPERM;
1417	jermar	407	IPC_SET_ARG2(call->data, size);
1329	palkovsky	408	break;
2662	jermar	409	case IPC_M_DATA_READ:
		410	size = IPC_GET_ARG2(call->data);
		411	if ((size <= 0 \|\| (size > DATA_XFER_LIMIT)))
		412	return ELIMIT;
		413	break;
2660	jermar	414	case IPC_M_DATA_WRITE:
2676	jermar	415	src = IPC_GET_ARG1(call->data);
		416	size = IPC_GET_ARG2(call->data);
2494	jermar	417
4304	jermar	418	if (size > DATA_XFER_LIMIT)
2494	jermar	419	return ELIMIT;
		420
		421	call->buffer = (uint8_t *) malloc(size, 0);
		422	rc = copy_from_uspace(call->buffer, (void *) src, size);
		423	if (rc != 0) {
		424	free(call->buffer);
		425	return rc;
		426	}
		427	break;
3438	svoboda	428	#ifdef CONFIG_UDEBUG
		429	case IPC_M_DEBUG_ALL:
		430	return udebug_request_preprocess(call, phone);
		431	#endif
1090	palkovsky	432	default:
		433	break;
		434	}
		435	return 0;
		436	}
		437
2471	jermar	438	/*******************************************************************************
		439	* Functions called to process received call/answer before passing it to uspace.
		440	*******************************************************************************/
		441
		442	/** Do basic kernel processing of received call answer.
		443	*
		444	* @param call Call structure with the answer.
1027	palkovsky	445	*/
1090	palkovsky	446	static void process_answer(call_t *call)
1027	palkovsky	447	{
2745	decky	448	if (((native_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&
2359	jermar	449	(call->flags & IPC_CALL_FORWARDED))
1088	palkovsky	450	IPC_SET_RETVAL(call->data, EFORWARD);
1090	palkovsky	451
		452	if (call->flags & IPC_CALL_CONN_ME_TO) {
		453	if (IPC_GET_RETVAL(call->data))
2098	decky	454	phone_dealloc(call->priv);
1090	palkovsky	455	else
2635	cejka	456	IPC_SET_ARG5(call->data, call->priv);
1090	palkovsky	457	}
2662	jermar	458
		459	if (call->buffer) {
		460	/* This must be an affirmative answer to IPC_M_DATA_READ. */
3438	svoboda	461	/* or IPC_M_DEBUG_ALL/UDEBUG_M_MEM_READ... */
2662	jermar	462	uintptr_t dst = IPC_GET_ARG1(call->data);
		463	size_t size = IPC_GET_ARG2(call->data);
		464	int rc = copy_to_uspace((void *) dst, call->buffer, size);
		465	if (rc)
		466	IPC_SET_RETVAL(call->data, rc);
		467	free(call->buffer);
		468	call->buffer = NULL;
		469	}
1027	palkovsky	470	}
		471
2471	jermar	472	/** Do basic kernel processing of received call request.
1027	palkovsky	473	*
2471	jermar	474	* @param box Destination answerbox structure.
		475	* @param call Call structure with the request.
		476	*
		477	* @return Return 0 if the call should be passed to userspace.
		478	* Return -1 if the call should be ignored.
1027	palkovsky	479	*/
2359	jermar	480	static int process_request(answerbox_t box, call_t call)
1027	palkovsky	481	{
		482	int phoneid;
		483
1086	palkovsky	484	if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {
4407	jermar	485	phoneid = phone_alloc(TASK);
1027	palkovsky	486	if (phoneid < 0) { /* Failed to allocate phone */
		487	IPC_SET_RETVAL(call->data, ELIMIT);
2471	jermar	488	ipc_answer(box, call);
1027	palkovsky	489	return -1;
		490	}
2637	cejka	491	IPC_SET_ARG5(call->data, phoneid);
3438	svoboda	492	}
		493	switch (IPC_GET_METHOD(call->data)) {
		494	case IPC_M_DEBUG_ALL:
		495	return -1;
		496	default:
		497	break;
		498	}
1027	palkovsky	499	return 0;
		500	}
		501
2471	jermar	502	/** Make a fast call over IPC, wait for reply and return to user.
1027	palkovsky	503	*
2615	jermar	504	* This function can handle only three arguments of payload, but is faster than
		505	* the generic function (i.e. sys_ipc_call_sync_slow()).
2471	jermar	506	*
		507	* @param phoneid Phone handle for the call.
		508	* @param method Method of the call.
		509	* @param arg1 Service-defined payload argument.
2615	jermar	510	* @param arg2 Service-defined payload argument.
		511	* @param arg3 Service-defined payload argument.
2471	jermar	512	* @param data Address of userspace structure where the reply call will
		513	* be stored.
		514	*
		515	* @return Returns 0 on success.
		516	* Return ENOENT if there is no such phone handle.
1027	palkovsky	517	*/
2359	jermar	518	unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
2615	jermar	519	unative_t arg1, unative_t arg2, unative_t arg3, ipc_data_t *data)
1027	palkovsky	520	{
		521	call_t call;
		522	phone_t *phone;
1090	palkovsky	523	int res;
2617	jermar	524	int rc;
3054	decky	525
1084	palkovsky	526	GET_CHECK_PHONE(phone, phoneid, return ENOENT);
1027	palkovsky	527
1084	palkovsky	528	ipc_call_static_init(&call);
1027	palkovsky	529	IPC_SET_METHOD(call.data, method);
		530	IPC_SET_ARG1(call.data, arg1);
2615	jermar	531	IPC_SET_ARG2(call.data, arg2);
		532	IPC_SET_ARG3(call.data, arg3);
2620	jermar	533	/*
		534	* To achieve deterministic behavior, zero out arguments that are beyond
		535	* the limits of the fast version.
		536	*/
		537	IPC_SET_ARG4(call.data, 0);
		538	IPC_SET_ARG5(call.data, 0);
1027	palkovsky	539
3438	svoboda	540	if (!(res = request_preprocess(&call, phone))) {
3603	svoboda	541	#ifdef CONFIG_UDEBUG
		542	udebug_stoppable_begin();
		543	#endif
3370	jermar	544	rc = ipc_call_sync(phone, &call);
3603	svoboda	545	#ifdef CONFIG_UDEBUG
		546	udebug_stoppable_end();
		547	#endif
3370	jermar	548	if (rc != EOK)
		549	return rc;
1090	palkovsky	550	process_answer(&call);
3603	svoboda	551
2471	jermar	552	} else {
1090	palkovsky	553	IPC_SET_RETVAL(call.data, res);
2471	jermar	554	}
2617	jermar	555	rc = STRUCT_TO_USPACE(&data->args, &call.data.args);
		556	if (rc != 0)
		557	return rc;
1027	palkovsky	558
		559	return 0;
		560	}
		561
2471	jermar	562	/** Make a synchronous IPC call allowing to transmit the entire payload.
		563	*
		564	* @param phoneid Phone handle for the call.
		565	* @param question Userspace address of call data with the request.
2494	jermar	566	* @param reply Userspace address of call data where to store the
		567	* answer.
2471	jermar	568	*
		569	* @return Zero on success or an error code.
		570	*/
2615	jermar	571	unative_t sys_ipc_call_sync_slow(unative_t phoneid, ipc_data_t *question,
2359	jermar	572	ipc_data_t *reply)
1027	palkovsky	573	{
		574	call_t call;
		575	phone_t *phone;
1090	palkovsky	576	int res;
1288	jermar	577	int rc;
1027	palkovsky	578
1084	palkovsky	579	ipc_call_static_init(&call);
2359	jermar	580	rc = copy_from_uspace(&call.data.args, &question->args,
		581	sizeof(call.data.args));
1288	jermar	582	if (rc != 0)
1780	jermar	583	return (unative_t) rc;
1040	palkovsky	584
1084	palkovsky	585	GET_CHECK_PHONE(phone, phoneid, return ENOENT);
1072	palkovsky	586
3438	svoboda	587	if (!(res = request_preprocess(&call, phone))) {
3603	svoboda	588	#ifdef CONFIG_UDEBUG
		589	udebug_stoppable_begin();
		590	#endif
3370	jermar	591	rc = ipc_call_sync(phone, &call);
3603	svoboda	592	#ifdef CONFIG_UDEBUG
		593	udebug_stoppable_end();
		594	#endif
3370	jermar	595	if (rc != EOK)
		596	return rc;
1090	palkovsky	597	process_answer(&call);
		598	} else
		599	IPC_SET_RETVAL(call.data, res);
1027	palkovsky	600
1288	jermar	601	rc = STRUCT_TO_USPACE(&reply->args, &call.data.args);
		602	if (rc != 0)
		603	return rc;
1027	palkovsky	604
		605	return 0;
		606	}
		607
2471	jermar	608	/** Check that the task did not exceed the allowed limit of asynchronous calls.
1027	palkovsky	609	*
2471	jermar	610	* @return Return 0 if limit not reached or -1 if limit exceeded.
1027	palkovsky	611	*/
		612	static int check_call_limit(void)
		613	{
		614	if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
		615	atomic_dec(&TASK->active_calls);
		616	return -1;
		617	}
		618	return 0;
		619	}
		620
2471	jermar	621	/** Make a fast asynchronous call over IPC.
1027	palkovsky	622	*
2618	jermar	623	* This function can only handle four arguments of payload, but is faster than
		624	* the generic function sys_ipc_call_async_slow().
2471	jermar	625	*
		626	* @param phoneid Phone handle for the call.
		627	* @param method Method of the call.
		628	* @param arg1 Service-defined payload argument.
		629	* @param arg2 Service-defined payload argument.
2618	jermar	630	* @param arg3 Service-defined payload argument.
		631	* @param arg4 Service-defined payload argument.
2471	jermar	632	*
		633	* @return Return call hash on success.
		634	* Return IPC_CALLRET_FATAL in case of a fatal error and
		635	* IPC_CALLRET_TEMPORARY if there are too many pending
		636	* asynchronous requests; answers should be handled first.
1027	palkovsky	637	*/
2359	jermar	638	unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
2618	jermar	639	unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
1027	palkovsky	640	{
		641	call_t *call;
		642	phone_t *phone;
1090	palkovsky	643	int res;
1027	palkovsky	644
		645	if (check_call_limit())
		646	return IPC_CALLRET_TEMPORARY;
		647
1090	palkovsky	648	GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
1072	palkovsky	649
1258	palkovsky	650	call = ipc_call_alloc(0);
1027	palkovsky	651	IPC_SET_METHOD(call->data, method);
		652	IPC_SET_ARG1(call->data, arg1);
		653	IPC_SET_ARG2(call->data, arg2);
2618	jermar	654	IPC_SET_ARG3(call->data, arg3);
		655	IPC_SET_ARG4(call->data, arg4);
2620	jermar	656	/*
		657	* To achieve deterministic behavior, zero out arguments that are beyond
		658	* the limits of the fast version.
		659	*/
		660	IPC_SET_ARG5(call->data, 0);
1027	palkovsky	661
3438	svoboda	662	if (!(res = request_preprocess(call, phone)))
1090	palkovsky	663	ipc_call(phone, call);
		664	else
		665	ipc_backsend_err(phone, call, res);
1027	palkovsky	666
1780	jermar	667	return (unative_t) call;
1027	palkovsky	668	}
		669
2471	jermar	670	/** Make an asynchronous IPC call allowing to transmit the entire payload.
1027	palkovsky	671	*
2471	jermar	672	* @param phoneid Phone handle for the call.
		673	* @param data Userspace address of call data with the request.
		674	*
		675	* @return See sys_ipc_call_async_fast().
1027	palkovsky	676	*/
2618	jermar	677	unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data)
1027	palkovsky	678	{
		679	call_t *call;
		680	phone_t *phone;
1090	palkovsky	681	int res;
1288	jermar	682	int rc;
1027	palkovsky	683
1072	palkovsky	684	if (check_call_limit())
		685	return IPC_CALLRET_TEMPORARY;
		686
1090	palkovsky	687	GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
1027	palkovsky	688
1258	palkovsky	689	call = ipc_call_alloc(0);
2359	jermar	690	rc = copy_from_uspace(&call->data.args, &data->args,
		691	sizeof(call->data.args));
1293	palkovsky	692	if (rc != 0) {
		693	ipc_call_free(call);
1780	jermar	694	return (unative_t) rc;
1293	palkovsky	695	}
3438	svoboda	696	if (!(res = request_preprocess(call, phone)))
1090	palkovsky	697	ipc_call(phone, call);
		698	else
		699	ipc_backsend_err(phone, call, res);
1040	palkovsky	700
1780	jermar	701	return (unative_t) call;
1027	palkovsky	702	}
		703
3819	jermar	704	/** Forward a received call to another destination - common code for both the
		705	* fast and the slow version.
1040	palkovsky	706	*
2471	jermar	707	* @param callid Hash of the call to forward.
		708	* @param phoneid Phone handle to use for forwarding.
		709	* @param method New method to use for the forwarded call.
		710	* @param arg1 New value of the first argument for the forwarded call.
2636	jermar	711	* @param arg2 New value of the second argument for the forwarded call.
3819	jermar	712	* @param arg3 New value of the third argument for the forwarded call.
		713	* @param arg4 New value of the fourth argument for the forwarded call.
		714	* @param arg5 New value of the fifth argument for the forwarded call.
2622	jermar	715	* @param mode Flags that specify mode of the forward operation.
3819	jermar	716	* @param slow If true, arg3, arg4 and arg5 are considered. Otherwise
		717	* the function considers only the fast version arguments:
		718	* i.e. arg1 and arg2.
1060	palkovsky	719	*
2471	jermar	720	* @return Return 0 on succes, otherwise return an error code.
		721	*
3819	jermar	722	* Warning: Make sure that ARG5 is not rewritten for certain system IPC
1040	palkovsky	723	*/
3819	jermar	724	static unative_t sys_ipc_forward_common(unative_t callid, unative_t phoneid,
		725	unative_t method, unative_t arg1, unative_t arg2, unative_t arg3,
		726	unative_t arg4, unative_t arg5, int mode, bool slow)
1040	palkovsky	727	{
		728	call_t *call;
		729	phone_t *phone;
		730
		731	call = get_call(callid);
		732	if (!call)
		733	return ENOENT;
3819	jermar	734
1088	palkovsky	735	call->flags \|= IPC_CALL_FORWARDED;
		736
1084	palkovsky	737	GET_CHECK_PHONE(phone, phoneid, {
1040	palkovsky	738	IPC_SET_RETVAL(call->data, EFORWARD);
		739	ipc_answer(&TASK->answerbox, call);
		740	return ENOENT;
3054	decky	741	});
1040	palkovsky	742
2557	jermar	743	if (!method_is_forwardable(IPC_GET_METHOD(call->data))) {
1040	palkovsky	744	IPC_SET_RETVAL(call->data, EFORWARD);
		745	ipc_answer(&TASK->answerbox, call);
		746	return EPERM;
		747	}
		748
2557	jermar	749	/*
		750	* Userspace is not allowed to change method of system methods on
3819	jermar	751	* forward, allow changing ARG1, ARG2, ARG3 and ARG4 by means of method,
		752	* arg1, arg2 and arg3.
2557	jermar	753	* If the method is immutable, don't change anything.
1040	palkovsky	754	*/
2557	jermar	755	if (!method_is_immutable(IPC_GET_METHOD(call->data))) {
		756	if (method_is_system(IPC_GET_METHOD(call->data))) {
		757	if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
2635	cejka	758	phone_dealloc(IPC_GET_ARG5(call->data));
1090	palkovsky	759
2557	jermar	760	IPC_SET_ARG1(call->data, method);
		761	IPC_SET_ARG2(call->data, arg1);
2635	cejka	762	IPC_SET_ARG3(call->data, arg2);
3819	jermar	763	if (slow) {
		764	IPC_SET_ARG4(call->data, arg3);
		765	/*
		766	* For system methods we deliberately don't
		767	* overwrite ARG5.
		768	*/
		769	}
2557	jermar	770	} else {
		771	IPC_SET_METHOD(call->data, method);
		772	IPC_SET_ARG1(call->data, arg1);
2635	cejka	773	IPC_SET_ARG2(call->data, arg2);
3819	jermar	774	if (slow) {
		775	IPC_SET_ARG3(call->data, arg3);
		776	IPC_SET_ARG4(call->data, arg4);
		777	IPC_SET_ARG5(call->data, arg5);
		778	}
2557	jermar	779	}
1040	palkovsky	780	}
		781
2622	jermar	782	return ipc_forward(call, phone, &TASK->answerbox, mode);
1040	palkovsky	783	}
		784
3819	jermar	785	/** Forward a received call to another destination - fast version.
		786	*
		787	* @param callid Hash of the call to forward.
		788	* @param phoneid Phone handle to use for forwarding.
		789	* @param method New method to use for the forwarded call.
		790	* @param arg1 New value of the first argument for the forwarded call.
		791	* @param arg2 New value of the second argument for the forwarded call.
		792	* @param mode Flags that specify mode of the forward operation.
		793	*
		794	* @return Return 0 on succes, otherwise return an error code.
		795	*
		796	* In case the original method is a system method, ARG1, ARG2 and ARG3 are
		797	* overwritten in the forwarded message with the new method and the new
		798	* arg1 and arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are
		799	* rewritten with the new method, arg1 and arg2, respectively. Also note there
		800	* is a set of immutable methods, for which the new method and arguments are not
		801	* set and these values are ignored.
		802	*/
		803	unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
		804	unative_t method, unative_t arg1, unative_t arg2, int mode)
		805	{
		806	return sys_ipc_forward_common(callid, phoneid, method, arg1, arg2, 0, 0,
		807	0, mode, false);
		808	}
		809
		810	/** Forward a received call to another destination - slow version.
		811	*
		812	* @param callid Hash of the call to forward.
		813	* @param phoneid Phone handle to use for forwarding.
		814	* @param data Userspace address of the new IPC data.
		815	* @param mode Flags that specify mode of the forward operation.
		816	*
		817	* @return Return 0 on succes, otherwise return an error code.
		818	*
		819	* This function is the slow verision of the sys_ipc_forward_fast interface.
		820	* It can copy all five new arguments and the new method from the userspace.
		821	* It naturally extends the functionality of the fast version. For system
		822	* methods, it additionally stores the new value of arg3 to ARG4. For non-system
		823	* methods, it additionally stores the new value of arg3, arg4 and arg5,
		824	* respectively, to ARG3, ARG4 and ARG5, respectively.
		825	*/
		826	unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
		827	ipc_data_t *data, int mode)
		828	{
		829	ipc_data_t newdata;
		830	int rc;
		831
		832	rc = copy_from_uspace(&newdata.args, &data->args,
		833	sizeof(newdata.args));
		834	if (rc != 0)
		835	return (unative_t) rc;
		836
		837	return sys_ipc_forward_common(callid, phoneid,
		838	IPC_GET_METHOD(newdata), IPC_GET_ARG1(newdata),
		839	IPC_GET_ARG2(newdata), IPC_GET_ARG3(newdata),
		840	IPC_GET_ARG4(newdata), IPC_GET_ARG5(newdata), mode, true);
		841	}
		842
2471	jermar	843	/** Answer an IPC call - fast version.
		844	*
		845	* This function can handle only two return arguments of payload, but is faster
		846	* than the generic sys_ipc_answer().
		847	*
		848	* @param callid Hash of the call to be answered.
		849	* @param retval Return value of the answer.
		850	* @param arg1 Service-defined return value.
		851	* @param arg2 Service-defined return value.
2619	jermar	852	* @param arg3 Service-defined return value.
		853	* @param arg4 Service-defined return value.
2471	jermar	854	*
		855	* @return Return 0 on success, otherwise return an error code.
		856	*/
2359	jermar	857	unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
2619	jermar	858	unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
1027	palkovsky	859	{
		860	call_t *call;
1040	palkovsky	861	ipc_data_t saved_data;
1088	palkovsky	862	int saveddata = 0;
1329	palkovsky	863	int rc;
1027	palkovsky	864
1346	palkovsky	865	/* Do not answer notification callids */
		866	if (callid & IPC_CALLID_NOTIFICATION)
		867	return 0;
		868
1040	palkovsky	869	call = get_call(callid);
		870	if (!call)
		871	return ENOENT;
1027	palkovsky	872
1088	palkovsky	873	if (answer_need_old(call)) {
1040	palkovsky	874	memcpy(&saved_data, &call->data, sizeof(call->data));
1088	palkovsky	875	saveddata = 1;
1027	palkovsky	876	}
		877
		878	IPC_SET_RETVAL(call->data, retval);
		879	IPC_SET_ARG1(call->data, arg1);
		880	IPC_SET_ARG2(call->data, arg2);
2619	jermar	881	IPC_SET_ARG3(call->data, arg3);
		882	IPC_SET_ARG4(call->data, arg4);
2620	jermar	883	/*
		884	* To achieve deterministic behavior, zero out arguments that are beyond
		885	* the limits of the fast version.
		886	*/
		887	IPC_SET_ARG5(call->data, 0);
1329	palkovsky	888	rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
1040	palkovsky	889
1027	palkovsky	890	ipc_answer(&TASK->answerbox, call);
1329	palkovsky	891	return rc;
1027	palkovsky	892	}
		893
2471	jermar	894	/** Answer an IPC call.
		895	*
		896	* @param callid Hash of the call to be answered.
		897	* @param data Userspace address of call data with the answer.
		898	*
		899	* @return Return 0 on success, otherwise return an error code.
		900	*/
2619	jermar	901	unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data)
1027	palkovsky	902	{
		903	call_t *call;
1040	palkovsky	904	ipc_data_t saved_data;
1088	palkovsky	905	int saveddata = 0;
1288	jermar	906	int rc;
1027	palkovsky	907
1346	palkovsky	908	/* Do not answer notification callids */
		909	if (callid & IPC_CALLID_NOTIFICATION)
		910	return 0;
		911
1040	palkovsky	912	call = get_call(callid);
		913	if (!call)
		914	return ENOENT;
1027	palkovsky	915
1088	palkovsky	916	if (answer_need_old(call)) {
1040	palkovsky	917	memcpy(&saved_data, &call->data, sizeof(call->data));
1088	palkovsky	918	saveddata = 1;
1027	palkovsky	919	}
1288	jermar	920	rc = copy_from_uspace(&call->data.args, &data->args,
2359	jermar	921	sizeof(call->data.args));
1288	jermar	922	if (rc != 0)
		923	return rc;
1027	palkovsky	924
1329	palkovsky	925	rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
1027	palkovsky	926
		927	ipc_answer(&TASK->answerbox, call);
		928
1329	palkovsky	929	return rc;
1027	palkovsky	930	}
		931
2471	jermar	932	/** Hang up a phone.
1086	palkovsky	933	*
2471	jermar	934	* @param Phone handle of the phone to be hung up.
		935	*
		936	* @return Return 0 on success or an error code.
1086	palkovsky	937	*/
1780	jermar	938	unative_t sys_ipc_hangup(int phoneid)
1086	palkovsky	939	{
		940	phone_t *phone;
		941
		942	GET_CHECK_PHONE(phone, phoneid, return ENOENT);
		943
1591	palkovsky	944	if (ipc_phone_hangup(phone))
1086	palkovsky	945	return -1;
		946
		947	return 0;
		948	}
		949
2471	jermar	950	/** Wait for an incoming IPC call or an answer.
1027	palkovsky	951	*
2359	jermar	952	* @param calldata Pointer to buffer where the call/answer data is stored.
		953	* @param usec Timeout. See waitq_sleep_timeout() for explanation.
		954	* @param flags Select mode of sleep operation. See waitq_sleep_timeout()
		955	* for explanation.
1364	jermar	956	*
2471	jermar	957	* @return Hash of the call.
		958	* If IPC_CALLID_NOTIFICATION bit is set in the hash, the
		959	* call is a notification. IPC_CALLID_ANSWERED denotes an
		960	* answer.
1027	palkovsky	961	*/
1780	jermar	962	unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int flags)
1027	palkovsky	963	{
		964	call_t *call;
		965
3603	svoboda	966	restart:
		967
		968	#ifdef CONFIG_UDEBUG
		969	udebug_stoppable_begin();
		970	#endif
2359	jermar	971	call = ipc_wait_for_call(&TASK->answerbox, usec,
		972	flags \| SYNCH_FLAGS_INTERRUPTIBLE);
3603	svoboda	973
		974	#ifdef CONFIG_UDEBUG
		975	udebug_stoppable_end();
		976	#endif
1088	palkovsky	977	if (!call)
		978	return 0;
1027	palkovsky	979
1258	palkovsky	980	if (call->flags & IPC_CALL_NOTIF) {
		981	ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
1693	palkovsky	982
		983	/* Set in_phone_hash to the interrupt counter */
2098	decky	984	call->data.phone = (void *) call->priv;
1693	palkovsky	985
		986	STRUCT_TO_USPACE(calldata, &call->data);
		987
1258	palkovsky	988	ipc_call_free(call);
		989
2471	jermar	990	return ((unative_t) call) \| IPC_CALLID_NOTIFICATION;
1258	palkovsky	991	}
		992
1027	palkovsky	993	if (call->flags & IPC_CALL_ANSWERED) {
1090	palkovsky	994	process_answer(call);
1027	palkovsky	995
1086	palkovsky	996	ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
		997
		998	if (call->flags & IPC_CALL_DISCARD_ANSWER) {
		999	ipc_call_free(call);
		1000	goto restart;
3476	jermar	1001	} else {
		1002	/*
		1003	* Decrement the counter of active calls only if the
		1004	* call is not an answer to IPC_M_PHONE_HUNGUP,
		1005	* which doesn't contribute to the counter.
		1006	*/
		1007	atomic_dec(&TASK->active_calls);
1086	palkovsky	1008	}
		1009
		1010	STRUCT_TO_USPACE(&calldata->args, &call->data.args);
1027	palkovsky	1011	ipc_call_free(call);
		1012
2471	jermar	1013	return ((unative_t) call) \| IPC_CALLID_ANSWERED;
1027	palkovsky	1014	}
1086	palkovsky	1015
1027	palkovsky	1016	if (process_request(&TASK->answerbox, call))
		1017	goto restart;
1086	palkovsky	1018
1090	palkovsky	1019	/* Include phone address('id') of the caller in the request,
		1020	* copy whole call->data, not only call->data.args */
1396	palkovsky	1021	if (STRUCT_TO_USPACE(calldata, &call->data)) {
4041	jermar	1022	/*
		1023	* The callee will not receive this call and no one else has
		1024	* a chance to answer it. Reply with the EPARTY error code.
4040	decky	1025	*/
4041	jermar	1026	ipc_data_t saved_data;
		1027	int saveddata = 0;
		1028
		1029	if (answer_need_old(call)) {
		1030	memcpy(&saved_data, &call->data, sizeof(call->data));
		1031	saveddata = 1;
		1032	}
		1033
		1034	IPC_SET_RETVAL(call->data, EPARTY);
		1035	(void) answer_preprocess(call, saveddata ? &saved_data : NULL);
		1036	ipc_answer(&TASK->answerbox, call);
1396	palkovsky	1037	return 0;
		1038	}
1780	jermar	1039	return (unative_t)call;
1027	palkovsky	1040	}
1258	palkovsky	1041
2471	jermar	1042	/** Connect an IRQ handler to a task.
1923	jermar	1043	*
2471	jermar	1044	* @param inr IRQ number.
		1045	* @param devno Device number.
		1046	* @param method Method to be associated with the notification.
		1047	* @param ucode Uspace pointer to the top-half pseudocode.
1923	jermar	1048	*
2471	jermar	1049	* @return EPERM or a return code returned by ipc_irq_register().
1923	jermar	1050	*/
2359	jermar	1051	unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
		1052	irq_code_t *ucode)
1258	palkovsky	1053	{
1297	jermar	1054	if (!(cap_get(TASK) & CAP_IRQ_REG))
		1055	return EPERM;
		1056
1923	jermar	1057	return ipc_irq_register(&TASK->answerbox, inr, devno, method, ucode);
1258	palkovsky	1058	}
		1059
2471	jermar	1060	/** Disconnect an IRQ handler from a task.
1923	jermar	1061	*
2471	jermar	1062	* @param inr IRQ number.
		1063	* @param devno Device number.
		1064	*
		1065	* @return Zero on success or EPERM on error..
1923	jermar	1066	*/
		1067	unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
1258	palkovsky	1068	{
1297	jermar	1069	if (!(cap_get(TASK) & CAP_IRQ_REG))
		1070	return EPERM;
		1071
1923	jermar	1072	ipc_irq_unregister(&TASK->answerbox, inr, devno);
1258	palkovsky	1073
		1074	return 0;
		1075	}
1702	cejka	1076
3438	svoboda	1077	#include <console/console.h>
		1078
		1079	/**
		1080	* Syscall connect to a task by id.
		1081	*
		1082	* @return Phone id on success, or negative error code.
		1083	*/
		1084	unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
		1085	{
		1086	#ifdef CONFIG_UDEBUG
		1087	sysarg64_t taskid_arg;
		1088	int rc;
		1089
		1090	rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
		1091	if (rc != 0)
		1092	return (unative_t) rc;
		1093
3441	svoboda	1094	LOG("sys_ipc_connect_kbox(%" PRIu64 ")\n", taskid_arg.value);
3438	svoboda	1095
		1096	return ipc_connect_kbox(taskid_arg.value);
		1097	#else
		1098	return (unative_t) ENOTSUP;
		1099	#endif
		1100	}
		1101
1757	jermar	1102	/** @}
1702	cejka	1103	*/

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/ipc/sysipc.c – Rev 4407