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);
4422	jermar	358	if (phone == cloned_phone)
		359	return EEXISTS;
4407	jermar	360	if (cloned_phone < phone) {
		361	mutex_lock(&cloned_phone->lock);
		362	mutex_lock(&phone->lock);
		363	} else {
		364	mutex_lock(&phone->lock);
		365	mutex_lock(&cloned_phone->lock);
		366	}
		367	if ((cloned_phone->state != IPC_PHONE_CONNECTED) \|\|
		368	phone->state != IPC_PHONE_CONNECTED) {
		369	mutex_unlock(&cloned_phone->lock);
		370	mutex_unlock(&phone->lock);
		371	return EINVAL;
		372	}
		373	/*
		374	* We can be pretty sure now that both tasks exist and we are
		375	* connected to them. As we continue to hold the phone locks,
		376	* we are effectively preventing them from finishing their
		377	* potential cleanup.
		378	*/
		379	newphid = phone_alloc(phone->callee->task);
		380	if (newphid < 0) {
		381	mutex_unlock(&cloned_phone->lock);
		382	mutex_unlock(&phone->lock);
		383	return ELIMIT;
		384	}
		385	ipc_phone_connect(&phone->callee->task->phones[newphid],
		386	cloned_phone->callee);
		387	mutex_unlock(&cloned_phone->lock);
		388	mutex_unlock(&phone->lock);
		389	/* Set the new phone for the callee. */
		390	IPC_SET_ARG1(call->data, newphid);
		391	break;
		392	}
		393	case IPC_M_CONNECT_ME:
		394	IPC_SET_ARG5(call->data, (unative_t) phone);
		395	break;
1090	palkovsky	396	case IPC_M_CONNECT_ME_TO:
4407	jermar	397	newphid = phone_alloc(TASK);
1090	palkovsky	398	if (newphid < 0)
		399	return ELIMIT;
2638	jermar	400	/* Set arg5 for server */
2635	cejka	401	IPC_SET_ARG5(call->data, (unative_t) &TASK->phones[newphid]);
1090	palkovsky	402	call->flags \|= IPC_CALL_CONN_ME_TO;
2098	decky	403	call->priv = newphid;
1090	palkovsky	404	break;
2677	jermar	405	case IPC_M_SHARE_OUT:
2556	jermar	406	size = as_area_get_size(IPC_GET_ARG1(call->data));
2471	jermar	407	if (!size)
1329	palkovsky	408	return EPERM;
1417	jermar	409	IPC_SET_ARG2(call->data, size);
1329	palkovsky	410	break;
2662	jermar	411	case IPC_M_DATA_READ:
		412	size = IPC_GET_ARG2(call->data);
		413	if ((size <= 0 \|\| (size > DATA_XFER_LIMIT)))
		414	return ELIMIT;
		415	break;
2660	jermar	416	case IPC_M_DATA_WRITE:
2676	jermar	417	src = IPC_GET_ARG1(call->data);
		418	size = IPC_GET_ARG2(call->data);
2494	jermar	419
4304	jermar	420	if (size > DATA_XFER_LIMIT)
2494	jermar	421	return ELIMIT;
		422
		423	call->buffer = (uint8_t *) malloc(size, 0);
		424	rc = copy_from_uspace(call->buffer, (void *) src, size);
		425	if (rc != 0) {
		426	free(call->buffer);
		427	return rc;
		428	}
		429	break;
3438	svoboda	430	#ifdef CONFIG_UDEBUG
		431	case IPC_M_DEBUG_ALL:
		432	return udebug_request_preprocess(call, phone);
		433	#endif
1090	palkovsky	434	default:
		435	break;
		436	}
		437	return 0;
		438	}
		439
2471	jermar	440	/*******************************************************************************
		441	* Functions called to process received call/answer before passing it to uspace.
		442	*******************************************************************************/
		443
		444	/** Do basic kernel processing of received call answer.
		445	*
		446	* @param call Call structure with the answer.
1027	palkovsky	447	*/
1090	palkovsky	448	static void process_answer(call_t *call)
1027	palkovsky	449	{
2745	decky	450	if (((native_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&
2359	jermar	451	(call->flags & IPC_CALL_FORWARDED))
1088	palkovsky	452	IPC_SET_RETVAL(call->data, EFORWARD);
1090	palkovsky	453
		454	if (call->flags & IPC_CALL_CONN_ME_TO) {
		455	if (IPC_GET_RETVAL(call->data))
2098	decky	456	phone_dealloc(call->priv);
1090	palkovsky	457	else
2635	cejka	458	IPC_SET_ARG5(call->data, call->priv);
1090	palkovsky	459	}
2662	jermar	460
		461	if (call->buffer) {
		462	/* This must be an affirmative answer to IPC_M_DATA_READ. */
3438	svoboda	463	/* or IPC_M_DEBUG_ALL/UDEBUG_M_MEM_READ... */
2662	jermar	464	uintptr_t dst = IPC_GET_ARG1(call->data);
		465	size_t size = IPC_GET_ARG2(call->data);
		466	int rc = copy_to_uspace((void *) dst, call->buffer, size);
		467	if (rc)
		468	IPC_SET_RETVAL(call->data, rc);
		469	free(call->buffer);
		470	call->buffer = NULL;
		471	}
1027	palkovsky	472	}
		473
2471	jermar	474	/** Do basic kernel processing of received call request.
1027	palkovsky	475	*
2471	jermar	476	* @param box Destination answerbox structure.
		477	* @param call Call structure with the request.
		478	*
		479	* @return Return 0 if the call should be passed to userspace.
		480	* Return -1 if the call should be ignored.
1027	palkovsky	481	*/
2359	jermar	482	static int process_request(answerbox_t box, call_t call)
1027	palkovsky	483	{
		484	int phoneid;
		485
1086	palkovsky	486	if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {
4407	jermar	487	phoneid = phone_alloc(TASK);
1027	palkovsky	488	if (phoneid < 0) { /* Failed to allocate phone */
		489	IPC_SET_RETVAL(call->data, ELIMIT);
2471	jermar	490	ipc_answer(box, call);
1027	palkovsky	491	return -1;
		492	}
2637	cejka	493	IPC_SET_ARG5(call->data, phoneid);
3438	svoboda	494	}
		495	switch (IPC_GET_METHOD(call->data)) {
		496	case IPC_M_DEBUG_ALL:
		497	return -1;
		498	default:
		499	break;
		500	}
1027	palkovsky	501	return 0;
		502	}
		503
2471	jermar	504	/** Make a fast call over IPC, wait for reply and return to user.
1027	palkovsky	505	*
2615	jermar	506	* This function can handle only three arguments of payload, but is faster than
		507	* the generic function (i.e. sys_ipc_call_sync_slow()).
2471	jermar	508	*
		509	* @param phoneid Phone handle for the call.
		510	* @param method Method of the call.
		511	* @param arg1 Service-defined payload argument.
2615	jermar	512	* @param arg2 Service-defined payload argument.
		513	* @param arg3 Service-defined payload argument.
2471	jermar	514	* @param data Address of userspace structure where the reply call will
		515	* be stored.
		516	*
		517	* @return Returns 0 on success.
		518	* Return ENOENT if there is no such phone handle.
1027	palkovsky	519	*/
2359	jermar	520	unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
2615	jermar	521	unative_t arg1, unative_t arg2, unative_t arg3, ipc_data_t *data)
1027	palkovsky	522	{
		523	call_t call;
		524	phone_t *phone;
1090	palkovsky	525	int res;
2617	jermar	526	int rc;
3054	decky	527
1084	palkovsky	528	GET_CHECK_PHONE(phone, phoneid, return ENOENT);
1027	palkovsky	529
1084	palkovsky	530	ipc_call_static_init(&call);
1027	palkovsky	531	IPC_SET_METHOD(call.data, method);
		532	IPC_SET_ARG1(call.data, arg1);
2615	jermar	533	IPC_SET_ARG2(call.data, arg2);
		534	IPC_SET_ARG3(call.data, arg3);
2620	jermar	535	/*
		536	* To achieve deterministic behavior, zero out arguments that are beyond
		537	* the limits of the fast version.
		538	*/
		539	IPC_SET_ARG4(call.data, 0);
		540	IPC_SET_ARG5(call.data, 0);
1027	palkovsky	541
3438	svoboda	542	if (!(res = request_preprocess(&call, phone))) {
3603	svoboda	543	#ifdef CONFIG_UDEBUG
		544	udebug_stoppable_begin();
		545	#endif
3370	jermar	546	rc = ipc_call_sync(phone, &call);
3603	svoboda	547	#ifdef CONFIG_UDEBUG
		548	udebug_stoppable_end();
		549	#endif
3370	jermar	550	if (rc != EOK)
		551	return rc;
1090	palkovsky	552	process_answer(&call);
3603	svoboda	553
2471	jermar	554	} else {
1090	palkovsky	555	IPC_SET_RETVAL(call.data, res);
2471	jermar	556	}
2617	jermar	557	rc = STRUCT_TO_USPACE(&data->args, &call.data.args);
		558	if (rc != 0)
		559	return rc;
1027	palkovsky	560
		561	return 0;
		562	}
		563
2471	jermar	564	/** Make a synchronous IPC call allowing to transmit the entire payload.
		565	*
		566	* @param phoneid Phone handle for the call.
		567	* @param question Userspace address of call data with the request.
2494	jermar	568	* @param reply Userspace address of call data where to store the
		569	* answer.
2471	jermar	570	*
		571	* @return Zero on success or an error code.
		572	*/
2615	jermar	573	unative_t sys_ipc_call_sync_slow(unative_t phoneid, ipc_data_t *question,
2359	jermar	574	ipc_data_t *reply)
1027	palkovsky	575	{
		576	call_t call;
		577	phone_t *phone;
1090	palkovsky	578	int res;
1288	jermar	579	int rc;
1027	palkovsky	580
1084	palkovsky	581	ipc_call_static_init(&call);
2359	jermar	582	rc = copy_from_uspace(&call.data.args, &question->args,
		583	sizeof(call.data.args));
1288	jermar	584	if (rc != 0)
1780	jermar	585	return (unative_t) rc;
1040	palkovsky	586
1084	palkovsky	587	GET_CHECK_PHONE(phone, phoneid, return ENOENT);
1072	palkovsky	588
3438	svoboda	589	if (!(res = request_preprocess(&call, phone))) {
3603	svoboda	590	#ifdef CONFIG_UDEBUG
		591	udebug_stoppable_begin();
		592	#endif
3370	jermar	593	rc = ipc_call_sync(phone, &call);
3603	svoboda	594	#ifdef CONFIG_UDEBUG
		595	udebug_stoppable_end();
		596	#endif
3370	jermar	597	if (rc != EOK)
		598	return rc;
1090	palkovsky	599	process_answer(&call);
		600	} else
		601	IPC_SET_RETVAL(call.data, res);
1027	palkovsky	602
1288	jermar	603	rc = STRUCT_TO_USPACE(&reply->args, &call.data.args);
		604	if (rc != 0)
		605	return rc;
1027	palkovsky	606
		607	return 0;
		608	}
		609
2471	jermar	610	/** Check that the task did not exceed the allowed limit of asynchronous calls.
1027	palkovsky	611	*
2471	jermar	612	* @return Return 0 if limit not reached or -1 if limit exceeded.
1027	palkovsky	613	*/
		614	static int check_call_limit(void)
		615	{
		616	if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
		617	atomic_dec(&TASK->active_calls);
		618	return -1;
		619	}
		620	return 0;
		621	}
		622
2471	jermar	623	/** Make a fast asynchronous call over IPC.
1027	palkovsky	624	*
2618	jermar	625	* This function can only handle four arguments of payload, but is faster than
		626	* the generic function sys_ipc_call_async_slow().
2471	jermar	627	*
		628	* @param phoneid Phone handle for the call.
		629	* @param method Method of the call.
		630	* @param arg1 Service-defined payload argument.
		631	* @param arg2 Service-defined payload argument.
2618	jermar	632	* @param arg3 Service-defined payload argument.
		633	* @param arg4 Service-defined payload argument.
2471	jermar	634	*
		635	* @return Return call hash on success.
		636	* Return IPC_CALLRET_FATAL in case of a fatal error and
		637	* IPC_CALLRET_TEMPORARY if there are too many pending
		638	* asynchronous requests; answers should be handled first.
1027	palkovsky	639	*/
2359	jermar	640	unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
2618	jermar	641	unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
1027	palkovsky	642	{
		643	call_t *call;
		644	phone_t *phone;
1090	palkovsky	645	int res;
1027	palkovsky	646
		647	if (check_call_limit())
		648	return IPC_CALLRET_TEMPORARY;
		649
1090	palkovsky	650	GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
1072	palkovsky	651
1258	palkovsky	652	call = ipc_call_alloc(0);
1027	palkovsky	653	IPC_SET_METHOD(call->data, method);
		654	IPC_SET_ARG1(call->data, arg1);
		655	IPC_SET_ARG2(call->data, arg2);
2618	jermar	656	IPC_SET_ARG3(call->data, arg3);
		657	IPC_SET_ARG4(call->data, arg4);
2620	jermar	658	/*
		659	* To achieve deterministic behavior, zero out arguments that are beyond
		660	* the limits of the fast version.
		661	*/
		662	IPC_SET_ARG5(call->data, 0);
1027	palkovsky	663
3438	svoboda	664	if (!(res = request_preprocess(call, phone)))
1090	palkovsky	665	ipc_call(phone, call);
		666	else
		667	ipc_backsend_err(phone, call, res);
1027	palkovsky	668
1780	jermar	669	return (unative_t) call;
1027	palkovsky	670	}
		671
2471	jermar	672	/** Make an asynchronous IPC call allowing to transmit the entire payload.
1027	palkovsky	673	*
2471	jermar	674	* @param phoneid Phone handle for the call.
		675	* @param data Userspace address of call data with the request.
		676	*
		677	* @return See sys_ipc_call_async_fast().
1027	palkovsky	678	*/
2618	jermar	679	unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data)
1027	palkovsky	680	{
		681	call_t *call;
		682	phone_t *phone;
1090	palkovsky	683	int res;
1288	jermar	684	int rc;
1027	palkovsky	685
1072	palkovsky	686	if (check_call_limit())
		687	return IPC_CALLRET_TEMPORARY;
		688
1090	palkovsky	689	GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
1027	palkovsky	690
1258	palkovsky	691	call = ipc_call_alloc(0);
2359	jermar	692	rc = copy_from_uspace(&call->data.args, &data->args,
		693	sizeof(call->data.args));
1293	palkovsky	694	if (rc != 0) {
		695	ipc_call_free(call);
1780	jermar	696	return (unative_t) rc;
1293	palkovsky	697	}
3438	svoboda	698	if (!(res = request_preprocess(call, phone)))
1090	palkovsky	699	ipc_call(phone, call);
		700	else
		701	ipc_backsend_err(phone, call, res);
1040	palkovsky	702
1780	jermar	703	return (unative_t) call;
1027	palkovsky	704	}
		705
3819	jermar	706	/** Forward a received call to another destination - common code for both the
		707	* fast and the slow version.
1040	palkovsky	708	*
2471	jermar	709	* @param callid Hash of the call to forward.
		710	* @param phoneid Phone handle to use for forwarding.
		711	* @param method New method to use for the forwarded call.
		712	* @param arg1 New value of the first argument for the forwarded call.
2636	jermar	713	* @param arg2 New value of the second argument for the forwarded call.
3819	jermar	714	* @param arg3 New value of the third argument for the forwarded call.
		715	* @param arg4 New value of the fourth argument for the forwarded call.
		716	* @param arg5 New value of the fifth argument for the forwarded call.
2622	jermar	717	* @param mode Flags that specify mode of the forward operation.
3819	jermar	718	* @param slow If true, arg3, arg4 and arg5 are considered. Otherwise
		719	* the function considers only the fast version arguments:
		720	* i.e. arg1 and arg2.
1060	palkovsky	721	*
2471	jermar	722	* @return Return 0 on succes, otherwise return an error code.
		723	*
3819	jermar	724	* Warning: Make sure that ARG5 is not rewritten for certain system IPC
1040	palkovsky	725	*/
3819	jermar	726	static unative_t sys_ipc_forward_common(unative_t callid, unative_t phoneid,
		727	unative_t method, unative_t arg1, unative_t arg2, unative_t arg3,
		728	unative_t arg4, unative_t arg5, int mode, bool slow)
1040	palkovsky	729	{
		730	call_t *call;
		731	phone_t *phone;
		732
		733	call = get_call(callid);
		734	if (!call)
		735	return ENOENT;
3819	jermar	736
1088	palkovsky	737	call->flags \|= IPC_CALL_FORWARDED;
		738
1084	palkovsky	739	GET_CHECK_PHONE(phone, phoneid, {
1040	palkovsky	740	IPC_SET_RETVAL(call->data, EFORWARD);
		741	ipc_answer(&TASK->answerbox, call);
		742	return ENOENT;
3054	decky	743	});
1040	palkovsky	744
2557	jermar	745	if (!method_is_forwardable(IPC_GET_METHOD(call->data))) {
1040	palkovsky	746	IPC_SET_RETVAL(call->data, EFORWARD);
		747	ipc_answer(&TASK->answerbox, call);
		748	return EPERM;
		749	}
		750
2557	jermar	751	/*
		752	* Userspace is not allowed to change method of system methods on
3819	jermar	753	* forward, allow changing ARG1, ARG2, ARG3 and ARG4 by means of method,
		754	* arg1, arg2 and arg3.
2557	jermar	755	* If the method is immutable, don't change anything.
1040	palkovsky	756	*/
2557	jermar	757	if (!method_is_immutable(IPC_GET_METHOD(call->data))) {
		758	if (method_is_system(IPC_GET_METHOD(call->data))) {
		759	if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
2635	cejka	760	phone_dealloc(IPC_GET_ARG5(call->data));
1090	palkovsky	761
2557	jermar	762	IPC_SET_ARG1(call->data, method);
		763	IPC_SET_ARG2(call->data, arg1);
2635	cejka	764	IPC_SET_ARG3(call->data, arg2);
3819	jermar	765	if (slow) {
		766	IPC_SET_ARG4(call->data, arg3);
		767	/*
		768	* For system methods we deliberately don't
		769	* overwrite ARG5.
		770	*/
		771	}
2557	jermar	772	} else {
		773	IPC_SET_METHOD(call->data, method);
		774	IPC_SET_ARG1(call->data, arg1);
2635	cejka	775	IPC_SET_ARG2(call->data, arg2);
3819	jermar	776	if (slow) {
		777	IPC_SET_ARG3(call->data, arg3);
		778	IPC_SET_ARG4(call->data, arg4);
		779	IPC_SET_ARG5(call->data, arg5);
		780	}
2557	jermar	781	}
1040	palkovsky	782	}
		783
2622	jermar	784	return ipc_forward(call, phone, &TASK->answerbox, mode);
1040	palkovsky	785	}
		786
3819	jermar	787	/** Forward a received call to another destination - fast version.
		788	*
		789	* @param callid Hash of the call to forward.
		790	* @param phoneid Phone handle to use for forwarding.
		791	* @param method New method to use for the forwarded call.
		792	* @param arg1 New value of the first argument for the forwarded call.
		793	* @param arg2 New value of the second argument for the forwarded call.
		794	* @param mode Flags that specify mode of the forward operation.
		795	*
		796	* @return Return 0 on succes, otherwise return an error code.
		797	*
		798	* In case the original method is a system method, ARG1, ARG2 and ARG3 are
		799	* overwritten in the forwarded message with the new method and the new
		800	* arg1 and arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are
		801	* rewritten with the new method, arg1 and arg2, respectively. Also note there
		802	* is a set of immutable methods, for which the new method and arguments are not
		803	* set and these values are ignored.
		804	*/
		805	unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
		806	unative_t method, unative_t arg1, unative_t arg2, int mode)
		807	{
		808	return sys_ipc_forward_common(callid, phoneid, method, arg1, arg2, 0, 0,
		809	0, mode, false);
		810	}
		811
		812	/** Forward a received call to another destination - slow version.
		813	*
		814	* @param callid Hash of the call to forward.
		815	* @param phoneid Phone handle to use for forwarding.
		816	* @param data Userspace address of the new IPC data.
		817	* @param mode Flags that specify mode of the forward operation.
		818	*
		819	* @return Return 0 on succes, otherwise return an error code.
		820	*
		821	* This function is the slow verision of the sys_ipc_forward_fast interface.
		822	* It can copy all five new arguments and the new method from the userspace.
		823	* It naturally extends the functionality of the fast version. For system
		824	* methods, it additionally stores the new value of arg3 to ARG4. For non-system
		825	* methods, it additionally stores the new value of arg3, arg4 and arg5,
		826	* respectively, to ARG3, ARG4 and ARG5, respectively.
		827	*/
		828	unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
		829	ipc_data_t *data, int mode)
		830	{
		831	ipc_data_t newdata;
		832	int rc;
		833
		834	rc = copy_from_uspace(&newdata.args, &data->args,
		835	sizeof(newdata.args));
		836	if (rc != 0)
		837	return (unative_t) rc;
		838
		839	return sys_ipc_forward_common(callid, phoneid,
		840	IPC_GET_METHOD(newdata), IPC_GET_ARG1(newdata),
		841	IPC_GET_ARG2(newdata), IPC_GET_ARG3(newdata),
		842	IPC_GET_ARG4(newdata), IPC_GET_ARG5(newdata), mode, true);
		843	}
		844
2471	jermar	845	/** Answer an IPC call - fast version.
		846	*
		847	* This function can handle only two return arguments of payload, but is faster
		848	* than the generic sys_ipc_answer().
		849	*
		850	* @param callid Hash of the call to be answered.
		851	* @param retval Return value of the answer.
		852	* @param arg1 Service-defined return value.
		853	* @param arg2 Service-defined return value.
2619	jermar	854	* @param arg3 Service-defined return value.
		855	* @param arg4 Service-defined return value.
2471	jermar	856	*
		857	* @return Return 0 on success, otherwise return an error code.
		858	*/
2359	jermar	859	unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
2619	jermar	860	unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
1027	palkovsky	861	{
		862	call_t *call;
1040	palkovsky	863	ipc_data_t saved_data;
1088	palkovsky	864	int saveddata = 0;
1329	palkovsky	865	int rc;
1027	palkovsky	866
1346	palkovsky	867	/* Do not answer notification callids */
		868	if (callid & IPC_CALLID_NOTIFICATION)
		869	return 0;
		870
1040	palkovsky	871	call = get_call(callid);
		872	if (!call)
		873	return ENOENT;
1027	palkovsky	874
1088	palkovsky	875	if (answer_need_old(call)) {
1040	palkovsky	876	memcpy(&saved_data, &call->data, sizeof(call->data));
1088	palkovsky	877	saveddata = 1;
1027	palkovsky	878	}
		879
		880	IPC_SET_RETVAL(call->data, retval);
		881	IPC_SET_ARG1(call->data, arg1);
		882	IPC_SET_ARG2(call->data, arg2);
2619	jermar	883	IPC_SET_ARG3(call->data, arg3);
		884	IPC_SET_ARG4(call->data, arg4);
2620	jermar	885	/*
		886	* To achieve deterministic behavior, zero out arguments that are beyond
		887	* the limits of the fast version.
		888	*/
		889	IPC_SET_ARG5(call->data, 0);
1329	palkovsky	890	rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
1040	palkovsky	891
1027	palkovsky	892	ipc_answer(&TASK->answerbox, call);
1329	palkovsky	893	return rc;
1027	palkovsky	894	}
		895
2471	jermar	896	/** Answer an IPC call.
		897	*
		898	* @param callid Hash of the call to be answered.
		899	* @param data Userspace address of call data with the answer.
		900	*
		901	* @return Return 0 on success, otherwise return an error code.
		902	*/
2619	jermar	903	unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data)
1027	palkovsky	904	{
		905	call_t *call;
1040	palkovsky	906	ipc_data_t saved_data;
1088	palkovsky	907	int saveddata = 0;
1288	jermar	908	int rc;
1027	palkovsky	909
1346	palkovsky	910	/* Do not answer notification callids */
		911	if (callid & IPC_CALLID_NOTIFICATION)
		912	return 0;
		913
1040	palkovsky	914	call = get_call(callid);
		915	if (!call)
		916	return ENOENT;
1027	palkovsky	917
1088	palkovsky	918	if (answer_need_old(call)) {
1040	palkovsky	919	memcpy(&saved_data, &call->data, sizeof(call->data));
1088	palkovsky	920	saveddata = 1;
1027	palkovsky	921	}
1288	jermar	922	rc = copy_from_uspace(&call->data.args, &data->args,
2359	jermar	923	sizeof(call->data.args));
1288	jermar	924	if (rc != 0)
		925	return rc;
1027	palkovsky	926
1329	palkovsky	927	rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
1027	palkovsky	928
		929	ipc_answer(&TASK->answerbox, call);
		930
1329	palkovsky	931	return rc;
1027	palkovsky	932	}
		933
2471	jermar	934	/** Hang up a phone.
1086	palkovsky	935	*
2471	jermar	936	* @param Phone handle of the phone to be hung up.
		937	*
		938	* @return Return 0 on success or an error code.
1086	palkovsky	939	*/
1780	jermar	940	unative_t sys_ipc_hangup(int phoneid)
1086	palkovsky	941	{
		942	phone_t *phone;
		943
		944	GET_CHECK_PHONE(phone, phoneid, return ENOENT);
		945
1591	palkovsky	946	if (ipc_phone_hangup(phone))
1086	palkovsky	947	return -1;
		948
		949	return 0;
		950	}
		951
2471	jermar	952	/** Wait for an incoming IPC call or an answer.
1027	palkovsky	953	*
2359	jermar	954	* @param calldata Pointer to buffer where the call/answer data is stored.
		955	* @param usec Timeout. See waitq_sleep_timeout() for explanation.
		956	* @param flags Select mode of sleep operation. See waitq_sleep_timeout()
		957	* for explanation.
1364	jermar	958	*
2471	jermar	959	* @return Hash of the call.
		960	* If IPC_CALLID_NOTIFICATION bit is set in the hash, the
		961	* call is a notification. IPC_CALLID_ANSWERED denotes an
		962	* answer.
1027	palkovsky	963	*/
1780	jermar	964	unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int flags)
1027	palkovsky	965	{
		966	call_t *call;
		967
3603	svoboda	968	restart:
		969
		970	#ifdef CONFIG_UDEBUG
		971	udebug_stoppable_begin();
		972	#endif
2359	jermar	973	call = ipc_wait_for_call(&TASK->answerbox, usec,
		974	flags \| SYNCH_FLAGS_INTERRUPTIBLE);
3603	svoboda	975
		976	#ifdef CONFIG_UDEBUG
		977	udebug_stoppable_end();
		978	#endif
1088	palkovsky	979	if (!call)
		980	return 0;
1027	palkovsky	981
1258	palkovsky	982	if (call->flags & IPC_CALL_NOTIF) {
		983	ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
1693	palkovsky	984
		985	/* Set in_phone_hash to the interrupt counter */
2098	decky	986	call->data.phone = (void *) call->priv;
1693	palkovsky	987
		988	STRUCT_TO_USPACE(calldata, &call->data);
		989
1258	palkovsky	990	ipc_call_free(call);
		991
2471	jermar	992	return ((unative_t) call) \| IPC_CALLID_NOTIFICATION;
1258	palkovsky	993	}
		994
1027	palkovsky	995	if (call->flags & IPC_CALL_ANSWERED) {
1090	palkovsky	996	process_answer(call);
1027	palkovsky	997
1086	palkovsky	998	ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
		999
		1000	if (call->flags & IPC_CALL_DISCARD_ANSWER) {
		1001	ipc_call_free(call);
		1002	goto restart;
3476	jermar	1003	} else {
		1004	/*
		1005	* Decrement the counter of active calls only if the
		1006	* call is not an answer to IPC_M_PHONE_HUNGUP,
		1007	* which doesn't contribute to the counter.
		1008	*/
		1009	atomic_dec(&TASK->active_calls);
1086	palkovsky	1010	}
		1011
		1012	STRUCT_TO_USPACE(&calldata->args, &call->data.args);
1027	palkovsky	1013	ipc_call_free(call);
		1014
2471	jermar	1015	return ((unative_t) call) \| IPC_CALLID_ANSWERED;
1027	palkovsky	1016	}
1086	palkovsky	1017
1027	palkovsky	1018	if (process_request(&TASK->answerbox, call))
		1019	goto restart;
1086	palkovsky	1020
1090	palkovsky	1021	/* Include phone address('id') of the caller in the request,
		1022	* copy whole call->data, not only call->data.args */
1396	palkovsky	1023	if (STRUCT_TO_USPACE(calldata, &call->data)) {
4041	jermar	1024	/*
		1025	* The callee will not receive this call and no one else has
		1026	* a chance to answer it. Reply with the EPARTY error code.
4040	decky	1027	*/
4041	jermar	1028	ipc_data_t saved_data;
		1029	int saveddata = 0;
		1030
		1031	if (answer_need_old(call)) {
		1032	memcpy(&saved_data, &call->data, sizeof(call->data));
		1033	saveddata = 1;
		1034	}
		1035
		1036	IPC_SET_RETVAL(call->data, EPARTY);
		1037	(void) answer_preprocess(call, saveddata ? &saved_data : NULL);
		1038	ipc_answer(&TASK->answerbox, call);
1396	palkovsky	1039	return 0;
		1040	}
1780	jermar	1041	return (unative_t)call;
1027	palkovsky	1042	}
1258	palkovsky	1043
2471	jermar	1044	/** Connect an IRQ handler to a task.
1923	jermar	1045	*
2471	jermar	1046	* @param inr IRQ number.
		1047	* @param devno Device number.
		1048	* @param method Method to be associated with the notification.
		1049	* @param ucode Uspace pointer to the top-half pseudocode.
1923	jermar	1050	*
2471	jermar	1051	* @return EPERM or a return code returned by ipc_irq_register().
1923	jermar	1052	*/
2359	jermar	1053	unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
		1054	irq_code_t *ucode)
1258	palkovsky	1055	{
1297	jermar	1056	if (!(cap_get(TASK) & CAP_IRQ_REG))
		1057	return EPERM;
		1058
1923	jermar	1059	return ipc_irq_register(&TASK->answerbox, inr, devno, method, ucode);
1258	palkovsky	1060	}
		1061
2471	jermar	1062	/** Disconnect an IRQ handler from a task.
1923	jermar	1063	*
2471	jermar	1064	* @param inr IRQ number.
		1065	* @param devno Device number.
		1066	*
		1067	* @return Zero on success or EPERM on error..
1923	jermar	1068	*/
		1069	unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
1258	palkovsky	1070	{
1297	jermar	1071	if (!(cap_get(TASK) & CAP_IRQ_REG))
		1072	return EPERM;
		1073
1923	jermar	1074	ipc_irq_unregister(&TASK->answerbox, inr, devno);
1258	palkovsky	1075
		1076	return 0;
		1077	}
1702	cejka	1078
3438	svoboda	1079	#include <console/console.h>
		1080
		1081	/**
		1082	* Syscall connect to a task by id.
		1083	*
		1084	* @return Phone id on success, or negative error code.
		1085	*/
		1086	unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
		1087	{
		1088	#ifdef CONFIG_UDEBUG
		1089	sysarg64_t taskid_arg;
		1090	int rc;
		1091
		1092	rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
		1093	if (rc != 0)
		1094	return (unative_t) rc;
		1095
3441	svoboda	1096	LOG("sys_ipc_connect_kbox(%" PRIu64 ")\n", taskid_arg.value);
3438	svoboda	1097
		1098	return ipc_connect_kbox(taskid_arg.value);
		1099	#else
		1100	return (unative_t) ENOTSUP;
		1101	#endif
		1102	}
		1103
1757	jermar	1104	/** @}
1702	cejka	1105	*/

Subversion Repositories HelenOS

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