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

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/ipc/sysipc.c @ 2408 – Rev 4460