WebSVN – HelenOS – Diff – /trunk/uspace/lib/libc/generic/ipc.c


/*
 * Copyright (C) 2006 Ondrej Palkovsky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#include <ipc.h>
#include <libc.h>
#include <malloc.h>
#include <errno.h>
#include <list.h>
#include <stdio.h>
#include <unistd.h>
 
/** Structure used for keeping track of sent async msgs
 * and queing unsent msgs
 *
 */
typedef struct {
    link_t list;
 
    ipc_async_callback_t callback;
    void *private;
    union {
        ipc_callid_t callid;
        struct {
            ipc_call_t data;
            int phoneid;
        } msg;
    }u;
} async_call_t;
 
LIST_INITIALIZE(dispatched_calls);
LIST_INITIALIZE(queued_calls);
 
int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1,
          ipcarg_t *result)
{
    ipc_call_t resdata;
    int callres;
   
    callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
                 (sysarg_t)&resdata);
    if (callres)
        return callres;
    if (result)
        *result = IPC_GET_ARG1(resdata);
    return IPC_GET_RETVAL(resdata);
}
 
int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
            ipcarg_t arg2, ipcarg_t arg3,
            ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3)
{
    ipc_call_t data;
    int callres;
 
    IPC_SET_METHOD(data, method);
    IPC_SET_ARG1(data, arg1);
    IPC_SET_ARG2(data, arg2);
    IPC_SET_ARG3(data, arg3);
 
    callres = __SYSCALL3(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t)&data,
                 (sysarg_t)&data);
    if (callres)
        return callres;
 
    if (result1)
        *result1 = IPC_GET_ARG1(data);
    if (result2)
        *result2 = IPC_GET_ARG2(data);
    if (result3)
        *result3 = IPC_GET_ARG3(data);
    return IPC_GET_RETVAL(data);
}
 
/** Syscall to send asynchronous message */
static  ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)
{
    return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t)data);
}
 
/** Send asynchronous message
 *
 * - if fatal error, call callback handler with proper error code
 * - if message cannot be temporarily sent, add to queue
 */
void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,
              ipcarg_t arg2, void *private,
              ipc_async_callback_t callback)
{
    async_call_t *call;
    ipc_callid_t callid;
 
    call = malloc(sizeof(*call));
    if (!call) {
        callback(private, ENOMEM, NULL);
        return;
    }
       
    callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2);
    if (callid == IPC_CALLRET_FATAL) {
        /* Call asynchronous handler with error code */
        callback(private, ENOENT, NULL);
        free(call);
        return;
    }
 
    call->callback = callback;
    call->private = private;
 
    if (callid == IPC_CALLRET_TEMPORARY) {
        /* Add asynchronous call to queue of non-dispatched async calls */
        call->u.msg.phoneid = phoneid;
        IPC_SET_METHOD(call->u.msg.data, method);
        IPC_SET_ARG1(call->u.msg.data, arg1);
        IPC_SET_ARG2(call->u.msg.data, arg2);
 
        list_append(&call->list, &queued_calls);
        return;
    }
    call->u.callid = callid;
    /* Add call to list of dispatched calls */
    list_append(&call->list, &dispatched_calls);
}
 
 
/** Send answer to a received call */
void ipc_answer(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
        ipcarg_t arg2)
{
    __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);
}
 
/** Try to dispatch queed calls from async queue */
static void try_dispatch_queued_calls(void)
{
    async_call_t *call;
    ipc_callid_t callid;
 
    while (!list_empty(&queued_calls)) {
        call = list_get_instance(queued_calls.next, async_call_t,
                     list);
 
        callid = _ipc_call_async(call->u.msg.phoneid,
                     &call->u.msg.data);
        if (callid == IPC_CALLRET_TEMPORARY)
            break;
        list_remove(&call->list);
        if (callid == IPC_CALLRET_FATAL) {
            call->callback(call->private, ENOENT, NULL);
            free(call);
        } else {
            call->u.callid = callid;
            list_append(&call->list, &dispatched_calls);
        }
    }
}
 
/** Handle received answer
 *
 * TODO: Make it use hash table
 *
 * @param callid Callid (with first bit set) of the answered call
 */
static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
{
    link_t *item;
    async_call_t *call;
 
    callid &= ~IPC_CALLID_ANSWERED;
   
    for (item = dispatched_calls.next; item != &dispatched_calls;
         item = item->next) {
        call = list_get_instance(item, async_call_t, list);
        if (call->u.callid == callid) {
            list_remove(&call->list);
            call->callback(call->private,
                       IPC_GET_RETVAL(*data),
                       data);
            return;
        }
    }
    printf("Received unidentified answer: %P!!!\n", callid);
}
 
 
/** Wait for IPC call and return
 *
 * - dispatch ASYNC reoutines in the background
 * @param data Space where the message is stored
 * @return Callid or 0 if nothing available and started with
 *         IPC_WAIT_NONBLOCKING
 */
ipc_callid_t ipc_wait_for_call(ipc_call_t *call, int flags)
{
    ipc_callid_t callid;
 
    do {
        try_dispatch_queued_calls();
 
        callid = __SYSCALL2(SYS_IPC_WAIT, (sysarg_t)call, flags);
        /* Handle received answers */
        if (callid & IPC_CALLID_ANSWERED)
            handle_answer(callid, call);
    } while (callid & IPC_CALLID_ANSWERED);
 
    return callid;
}
 
/** Ask destination to do a callback connection
 *
 * @return 0 - OK, error code
 */
int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phone)
{
    return ipc_call_sync_3(phoneid, IPC_M_CONNECT_TO_ME, arg1,
                   arg2, 0, 0, 0, phone);
}
 
/** Ask through phone for a new connection to some service
 *
 * @return new phoneid - OK, error code
 */
int ipc_connect_me_to(int phoneid, int arg1, int arg2)
{
    ipcarg_t newphid;
    int res;
 
    res =  ipc_call_sync_3(phoneid, IPC_M_CONNECT_ME_TO, arg1,
                   arg2, 0, 0, 0, &newphid);
    if (res)
        return res;
    return newphid;
}
 
/* Hang up specified phone */
int ipc_hangup(int phoneid)
{
    return __SYSCALL1(SYS_IPC_HANGUP, phoneid);
}
 
int ipc_register_irq(int irq)
{
    return __SYSCALL1(SYS_IPC_REGISTER_IRQ, irq);
}
 
int ipc_unregister_irq(int irq)
{
    return __SYSCALL1(SYS_IPC_UNREGISTER_IRQ, irq);
}
 

Rev 1092	Rev 1259
1	/*	1	/*
2	* Copyright (C) 2006 Ondrej Palkovsky	2	* Copyright (C) 2006 Ondrej Palkovsky
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	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	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.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	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	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	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	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	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	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.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	#include <ipc.h>	29	#include <ipc.h>
30	#include <libc.h>	30	#include <libc.h>
31	#include <malloc.h>	31	#include <malloc.h>
32	#include <errno.h>	32	#include <errno.h>
33	#include <list.h>	33	#include <list.h>
34	#include <stdio.h>	34	#include <stdio.h>
35	#include <unistd.h>	35	#include <unistd.h>
36		36
37	/** Structure used for keeping track of sent async msgs	37	/** Structure used for keeping track of sent async msgs
38	* and queing unsent msgs	38	* and queing unsent msgs
39	*	39	*
40	*/	40	*/
41	typedef struct {	41	typedef struct {
42	link_t list;	42	link_t list;
43		43
44	ipc_async_callback_t callback;	44	ipc_async_callback_t callback;
45	void *private;	45	void *private;
46	union {	46	union {
47	ipc_callid_t callid;	47	ipc_callid_t callid;
48	struct {	48	struct {
49	ipc_call_t data;	49	ipc_call_t data;
50	int phoneid;	50	int phoneid;
51	} msg;	51	} msg;
52	}u;	52	}u;
53	} async_call_t;	53	} async_call_t;
54		54
55	LIST_INITIALIZE(dispatched_calls);	55	LIST_INITIALIZE(dispatched_calls);
56	LIST_INITIALIZE(queued_calls);	56	LIST_INITIALIZE(queued_calls);
57		57
58	int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1,	58	int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1,
59	ipcarg_t *result)	59	ipcarg_t *result)
60	{	60	{
61	ipc_call_t resdata;	61	ipc_call_t resdata;
62	int callres;	62	int callres;
63		63
64	callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,	64	callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
65	(sysarg_t)&resdata);	65	(sysarg_t)&resdata);
66	if (callres)	66	if (callres)
67	return callres;	67	return callres;
68	if (result)	68	if (result)
69	*result = IPC_GET_ARG1(resdata);	69	*result = IPC_GET_ARG1(resdata);
70	return IPC_GET_RETVAL(resdata);	70	return IPC_GET_RETVAL(resdata);
71	}	71	}
72		72
73	int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1,	73	int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
74	ipcarg_t arg2, ipcarg_t arg3,	74	ipcarg_t arg2, ipcarg_t arg3,
75	ipcarg_t result1, ipcarg_t result2, ipcarg_t *result3)	75	ipcarg_t result1, ipcarg_t result2, ipcarg_t *result3)
76	{	76	{
77	ipc_call_t data;	77	ipc_call_t data;
78	int callres;	78	int callres;
79		79
80	IPC_SET_METHOD(data, method);	80	IPC_SET_METHOD(data, method);
81	IPC_SET_ARG1(data, arg1);	81	IPC_SET_ARG1(data, arg1);
82	IPC_SET_ARG2(data, arg2);	82	IPC_SET_ARG2(data, arg2);
83	IPC_SET_ARG3(data, arg3);	83	IPC_SET_ARG3(data, arg3);
84		84
85	callres = __SYSCALL3(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t)&data,	85	callres = __SYSCALL3(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t)&data,
86	(sysarg_t)&data);	86	(sysarg_t)&data);
87	if (callres)	87	if (callres)
88	return callres;	88	return callres;
89		89
90	if (result1)	90	if (result1)
91	*result1 = IPC_GET_ARG1(data);	91	*result1 = IPC_GET_ARG1(data);
92	if (result2)	92	if (result2)
93	*result2 = IPC_GET_ARG2(data);	93	*result2 = IPC_GET_ARG2(data);
94	if (result3)	94	if (result3)
95	*result3 = IPC_GET_ARG3(data);	95	*result3 = IPC_GET_ARG3(data);
96	return IPC_GET_RETVAL(data);	96	return IPC_GET_RETVAL(data);
97	}	97	}
98		98
99	/** Syscall to send asynchronous message */	99	/** Syscall to send asynchronous message */
100	static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)	100	static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)
101	{	101	{
102	return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t)data);	102	return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t)data);
103	}	103	}
104		104
105	/** Send asynchronous message	105	/** Send asynchronous message
106	*	106	*
107	* - if fatal error, call callback handler with proper error code	107	* - if fatal error, call callback handler with proper error code
108	* - if message cannot be temporarily sent, add to queue	108	* - if message cannot be temporarily sent, add to queue
109	*/	109	*/
110	void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,	110	void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,
111	ipcarg_t arg2, void *private,	111	ipcarg_t arg2, void *private,
112	ipc_async_callback_t callback)	112	ipc_async_callback_t callback)
113	{	113	{
114	async_call_t *call;	114	async_call_t *call;
115	ipc_callid_t callid;	115	ipc_callid_t callid;
116		116
117	call = malloc(sizeof(*call));	117	call = malloc(sizeof(*call));
118	if (!call) {	118	if (!call) {
119	callback(private, ENOMEM, NULL);	119	callback(private, ENOMEM, NULL);
120	return;	120	return;
121	}	121	}
122		122
123	callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2);	123	callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2);
124	if (callid == IPC_CALLRET_FATAL) {	124	if (callid == IPC_CALLRET_FATAL) {
125	/* Call asynchronous handler with error code */	125	/* Call asynchronous handler with error code */
126	callback(private, ENOENT, NULL);	126	callback(private, ENOENT, NULL);
127	free(call);	127	free(call);
128	return;	128	return;
129	}	129	}
130		130
131	call->callback = callback;	131	call->callback = callback;
132	call->private = private;	132	call->private = private;
133		133
134	if (callid == IPC_CALLRET_TEMPORARY) {	134	if (callid == IPC_CALLRET_TEMPORARY) {
135	/* Add asynchronous call to queue of non-dispatched async calls */	135	/* Add asynchronous call to queue of non-dispatched async calls */
136	call->u.msg.phoneid = phoneid;	136	call->u.msg.phoneid = phoneid;
137	IPC_SET_METHOD(call->u.msg.data, method);	137	IPC_SET_METHOD(call->u.msg.data, method);
138	IPC_SET_ARG1(call->u.msg.data, arg1);	138	IPC_SET_ARG1(call->u.msg.data, arg1);
139	IPC_SET_ARG2(call->u.msg.data, arg2);	139	IPC_SET_ARG2(call->u.msg.data, arg2);
140		140
141	list_append(&call->list, &queued_calls);	141	list_append(&call->list, &queued_calls);
142	return;	142	return;
143	}	143	}
144	call->u.callid = callid;	144	call->u.callid = callid;
145	/* Add call to list of dispatched calls */	145	/* Add call to list of dispatched calls */
146	list_append(&call->list, &dispatched_calls);	146	list_append(&call->list, &dispatched_calls);
147	}	147	}
148		148
149		149
150	/** Send answer to a received call */	150	/** Send answer to a received call */
151	void ipc_answer(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,	151	void ipc_answer(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
152	ipcarg_t arg2)	152	ipcarg_t arg2)
153	{	153	{
154	__SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);	154	__SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);
155	}	155	}
156		156
157	/** Try to dispatch queed calls from async queue */	157	/** Try to dispatch queed calls from async queue */
158	static void try_dispatch_queued_calls(void)	158	static void try_dispatch_queued_calls(void)
159	{	159	{
160	async_call_t *call;	160	async_call_t *call;
161	ipc_callid_t callid;	161	ipc_callid_t callid;
162		162
163	while (!list_empty(&queued_calls)) {	163	while (!list_empty(&queued_calls)) {
164	call = list_get_instance(queued_calls.next, async_call_t,	164	call = list_get_instance(queued_calls.next, async_call_t,
165	list);	165	list);
166		166
167	callid = _ipc_call_async(call->u.msg.phoneid,	167	callid = _ipc_call_async(call->u.msg.phoneid,
168	&call->u.msg.data);	168	&call->u.msg.data);
169	if (callid == IPC_CALLRET_TEMPORARY)	169	if (callid == IPC_CALLRET_TEMPORARY)
170	break;	170	break;
171	list_remove(&call->list);	171	list_remove(&call->list);
172	if (callid == IPC_CALLRET_FATAL) {	172	if (callid == IPC_CALLRET_FATAL) {
173	call->callback(call->private, ENOENT, NULL);	173	call->callback(call->private, ENOENT, NULL);
174	free(call);	174	free(call);
175	} else {	175	} else {
176	call->u.callid = callid;	176	call->u.callid = callid;
177	list_append(&call->list, &dispatched_calls);	177	list_append(&call->list, &dispatched_calls);
178	}	178	}
179	}	179	}
180	}	180	}
181		181
182	/** Handle received answer	182	/** Handle received answer
183	*	183	*
184	* TODO: Make it use hash table	184	* TODO: Make it use hash table
185	*	185	*
186	* @param callid Callid (with first bit set) of the answered call	186	* @param callid Callid (with first bit set) of the answered call
187	*/	187	*/
188	static void handle_answer(ipc_callid_t callid, ipc_call_t *data)	188	static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
189	{	189	{
190	link_t *item;	190	link_t *item;
191	async_call_t *call;	191	async_call_t *call;
192		192
193	callid &= ~IPC_CALLID_ANSWERED;	193	callid &= ~IPC_CALLID_ANSWERED;
194		194
195	for (item = dispatched_calls.next; item != &dispatched_calls;	195	for (item = dispatched_calls.next; item != &dispatched_calls;
196	item = item->next) {	196	item = item->next) {
197	call = list_get_instance(item, async_call_t, list);	197	call = list_get_instance(item, async_call_t, list);
198	if (call->u.callid == callid) {	198	if (call->u.callid == callid) {
199	list_remove(&call->list);	199	list_remove(&call->list);
200	call->callback(call->private,	200	call->callback(call->private,
201	IPC_GET_RETVAL(*data),	201	IPC_GET_RETVAL(*data),
202	data);	202	data);
203	return;	203	return;
204	}	204	}
205	}	205	}
206	printf("Received unidentified answer: %P!!!\n", callid);	206	printf("Received unidentified answer: %P!!!\n", callid);
207	}	207	}
208		208
209		209
210	/** Wait for IPC call and return	210	/** Wait for IPC call and return
211	*	211	*
212	* - dispatch ASYNC reoutines in the background	212	* - dispatch ASYNC reoutines in the background
213	* @param data Space where the message is stored	213	* @param data Space where the message is stored
214	* @return Callid or 0 if nothing available and started with	214	* @return Callid or 0 if nothing available and started with
215	* IPC_WAIT_NONBLOCKING	215	* IPC_WAIT_NONBLOCKING
216	*/	216	*/
217	ipc_callid_t ipc_wait_for_call(ipc_call_t *call, int flags)	217	ipc_callid_t ipc_wait_for_call(ipc_call_t *call, int flags)
218	{	218	{
219	ipc_callid_t callid;	219	ipc_callid_t callid;
220		220
221	do {	221	do {
222	try_dispatch_queued_calls();	222	try_dispatch_queued_calls();
223		223
224	callid = __SYSCALL2(SYS_IPC_WAIT, (sysarg_t)call, flags);	224	callid = __SYSCALL2(SYS_IPC_WAIT, (sysarg_t)call, flags);
225	/* Handle received answers */	225	/* Handle received answers */
226	if (callid & IPC_CALLID_ANSWERED)	226	if (callid & IPC_CALLID_ANSWERED)
227	handle_answer(callid, call);	227	handle_answer(callid, call);
228	} while (callid & IPC_CALLID_ANSWERED);	228	} while (callid & IPC_CALLID_ANSWERED);
229		229
230	return callid;	230	return callid;
231	}	231	}
232		232
233	/** Ask destination to do a callback connection	233	/** Ask destination to do a callback connection
234	*	234	*
235	* @return 0 - OK, error code	235	* @return 0 - OK, error code
236	*/	236	*/
237	int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phone)	237	int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phone)
238	{	238	{
239	return ipc_call_sync_3(phoneid, IPC_M_CONNECT_TO_ME, arg1,	239	return ipc_call_sync_3(phoneid, IPC_M_CONNECT_TO_ME, arg1,
240	arg2, 0, 0, 0, phone);	240	arg2, 0, 0, 0, phone);
241	}	241	}
242		242
243	/** Ask through phone for a new connection to some service	243	/** Ask through phone for a new connection to some service
244	*	244	*
245	* @return new phoneid - OK, error code	245	* @return new phoneid - OK, error code
246	*/	246	*/
247	int ipc_connect_me_to(int phoneid, int arg1, int arg2)	247	int ipc_connect_me_to(int phoneid, int arg1, int arg2)
248	{	248	{
249	ipcarg_t newphid;	249	ipcarg_t newphid;
250	int res;	250	int res;
251		251
252	res = ipc_call_sync_3(phoneid, IPC_M_CONNECT_ME_TO, arg1,	252	res = ipc_call_sync_3(phoneid, IPC_M_CONNECT_ME_TO, arg1,
253	arg2, 0, 0, 0, &newphid);	253	arg2, 0, 0, 0, &newphid);
254	if (res)	254	if (res)
255	return res;	255	return res;
256	return newphid;	256	return newphid;
257	}	257	}
258		258
259	/* Hang up specified phone */	259	/* Hang up specified phone */
260	int ipc_hangup(int phoneid)	260	int ipc_hangup(int phoneid)
261	{	261	{
262	return __SYSCALL1(SYS_IPC_HANGUP, phoneid);	262	return __SYSCALL1(SYS_IPC_HANGUP, phoneid);
263	}	263	}
-		264
-		265	int ipc_register_irq(int irq)
-		266	{
-		267	return __SYSCALL1(SYS_IPC_REGISTER_IRQ, irq);
-		268	}
-		269
-		270	int ipc_unregister_irq(int irq)
-		271	{
-		272	return __SYSCALL1(SYS_IPC_UNREGISTER_IRQ, irq);
-		273	}
264		274

Subversion Repositories HelenOS

(root)/trunk/uspace/lib/libc/generic/ipc.c @ 2568 – Rev 1092 → 1259