WebSVN – HelenOS-historic – Diff – /uspace/trunk/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/ipc.h>
#include <libc.h>
#include <malloc.h>
#include <errno.h>
#include <libadt/list.h>
#include <stdio.h>
#include <unistd.h>
#include <futex.h>
#include <kernel/synch/synch.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);
 
static atomic_t ipc_futex;
 
void _ipc_init(void)
{
    futex_initialize(&ipc_futex, 1);
}
 
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);
       
        futex_down(&ipc_futex);
        list_append(&call->list, &queued_calls);
        futex_up(&ipc_futex);
        return;
    }
    call->u.callid = callid;
    /* Add call to list of dispatched calls */
    futex_down(&ipc_futex);
    list_append(&call->list, &dispatched_calls);
    futex_up(&ipc_futex);
}
 
 
/** Send a fast answer to a received call.
 *
 * The fast answer makes use of passing retval and first two arguments in registers.
 * If you need to return more, use the ipc_answer() instead.
 *
 * @param callid ID of the call being answered.
 * @param retval Return value.
 * @param arg1 First return argument.
 * @param arg2 Second return argument.
 *
 * @return Zero on success or a value from @ref errno.h on failure.
 */
ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
        ipcarg_t arg2)
{
    return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);
}
 
/** Send a full answer to a received call.
 *
 * @param callid ID of the call being answered.
 * @param call Call data. Must be already initialized by the responder.
 *
 * @return Zero on success or a value from @ref errno.h on failure.
 */
ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call)
{
    return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call);
}
 
 
/** Try to dispatch queed calls from async queue */
static void try_dispatch_queued_calls(void)
{
    async_call_t *call;
    ipc_callid_t callid;
 
    futex_down(&ipc_futex);
    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) {
            futex_up(&ipc_futex);
            call->callback(call->private, ENOENT, NULL);
            free(call);
            futex_down(&ipc_futex);
        } else {
            call->u.callid = callid;
            list_append(&call->list, &dispatched_calls);
        }
    }
    futex_up(&ipc_futex);
}
 
/** 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;
   
    futex_down(&ipc_futex);
    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);
            futex_up(&ipc_futex);
            call->callback(call->private,
                       IPC_GET_RETVAL(*data),
                       data);
            return;
        }
    }
    futex_up(&ipc_futex);
    printf("Received unidentified answer: %P!!!\n", callid);
}
 
 
/** Unconditionally wait for an IPC call.
 *
 * - dispatch ASYNC reoutines in the background
 * @param call Space where the message is stored
 * @return Callid of the answer.
 
 */
ipc_callid_t ipc_wait_for_call(ipc_call_t *call)
{
    ipc_callid_t callid;
 
    do {
        try_dispatch_queued_calls();
 
        callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, SYNCH_NO_TIMEOUT, SYNCH_BLOCKING);
        /* Handle received answers */
        if (callid & IPC_CALLID_ANSWERED)
            handle_answer(callid, call);
    } while (callid & IPC_CALLID_ANSWERED);
 
    return callid;
}
 
/** Wait some time for an IPC call.
 *
 * - dispatch ASYNC reoutines in the background
 * @param call Space where the message is stored
 * @param usec Timeout in microseconds.
 * @return Callid of the answer.
 */
ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec)
{
    ipc_callid_t callid;
 
    do {
        try_dispatch_queued_calls();
 
        callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, SYNCH_BLOCKING);
        /* Handle received answers */
        if (callid & IPC_CALLID_ANSWERED)
            handle_answer(callid, call);
    } while (callid & IPC_CALLID_ANSWERED);
 
    return callid;
}
 
/** Check if there is an IPC call waiting to be picked up.
 *
 * - dispatch ASYNC reoutines in the background
 * @param call Space where the message is stored
 * @return Callid of the answer.
 */
ipc_callid_t ipc_trywait_for_call(ipc_call_t *call)
{
    ipc_callid_t callid;
 
    do {
        try_dispatch_queued_calls();
 
        callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t)call, SYNCH_NO_TIMEOUT, SYNCH_NON_BLOCKING);
        /* 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, irq_code_t *ucode)
{
    return __SYSCALL2(SYS_IPC_REGISTER_IRQ, irq, (sysarg_t) ucode);
}
 
int ipc_unregister_irq(int irq)
{
    return __SYSCALL1(SYS_IPC_UNREGISTER_IRQ, irq);
}
 
int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method, ipcarg_t arg1)
{
    return __SYSCALL4(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1);
}
 
 
/** Open shared memory connection over specified phoneid
 *
 *
 * Allocate as_area, notify the other side about our intention
 * to open the connection
 *
 * @return Connection id identifying this connection
 */
//int ipc_dgr_open(int pohoneid, size_t bufsize)
//{
    /* Find new file descriptor in local descriptor table */
    /* Create AS_area, initialize structures */
    /* Send AS to other side, handle error states */
 
//}
/*
void ipc_dgr_close(int cid)
{
}
 
void * ipc_dgr_alloc(int cid, size_t size)
{
}
 
void ipc_dgr_free(int cid, void *area)
{
 
}
 
int ipc_dgr_send(int cid, void *area)
{
}
 
 
int ipc_dgr_send_data(int cid, void *data, size_t size)
{
}
 
*/
 

Rev 1360	Rev 1365
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/ipc.h>	29	#include <ipc/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 <libadt/list.h>	33	#include <libadt/list.h>
34	#include <stdio.h>	34	#include <stdio.h>
35	#include <unistd.h>	35	#include <unistd.h>
36	#include <futex.h>	36	#include <futex.h>
-		37	#include <kernel/synch/synch.h>
37		38
38	/** Structure used for keeping track of sent async msgs	39	/** Structure used for keeping track of sent async msgs
39	* and queing unsent msgs	40	* and queing unsent msgs
40	*	41	*
41	*/	42	*/
42	typedef struct {	43	typedef struct {
43	link_t list;	44	link_t list;
44		45
45	ipc_async_callback_t callback;	46	ipc_async_callback_t callback;
46	void *private;	47	void *private;
47	union {	48	union {
48	ipc_callid_t callid;	49	ipc_callid_t callid;
49	struct {	50	struct {
50	ipc_call_t data;	51	ipc_call_t data;
51	int phoneid;	52	int phoneid;
52	} msg;	53	} msg;
53	}u;	54	}u;
54	} async_call_t;	55	} async_call_t;
55		56
56	LIST_INITIALIZE(dispatched_calls);	57	LIST_INITIALIZE(dispatched_calls);
57	LIST_INITIALIZE(queued_calls);	58	LIST_INITIALIZE(queued_calls);
58		59
59	static atomic_t ipc_futex;	60	static atomic_t ipc_futex;
60		61
61	void _ipc_init(void)	62	void _ipc_init(void)
62	{	63	{
63	futex_initialize(&ipc_futex, 1);	64	futex_initialize(&ipc_futex, 1);
64	}	65	}
65		66
66	int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1,	67	int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1,
67	ipcarg_t *result)	68	ipcarg_t *result)
68	{	69	{
69	ipc_call_t resdata;	70	ipc_call_t resdata;
70	int callres;	71	int callres;
71		72
72	callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,	73	callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
73	(sysarg_t)&resdata);	74	(sysarg_t)&resdata);
74	if (callres)	75	if (callres)
75	return callres;	76	return callres;
76	if (result)	77	if (result)
77	*result = IPC_GET_ARG1(resdata);	78	*result = IPC_GET_ARG1(resdata);
78	return IPC_GET_RETVAL(resdata);	79	return IPC_GET_RETVAL(resdata);
79	}	80	}
80		81
81	int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1,	82	int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
82	ipcarg_t arg2, ipcarg_t arg3,	83	ipcarg_t arg2, ipcarg_t arg3,
83	ipcarg_t result1, ipcarg_t result2, ipcarg_t *result3)	84	ipcarg_t result1, ipcarg_t result2, ipcarg_t *result3)
84	{	85	{
85	ipc_call_t data;	86	ipc_call_t data;
86	int callres;	87	int callres;
87		88
88	IPC_SET_METHOD(data, method);	89	IPC_SET_METHOD(data, method);
89	IPC_SET_ARG1(data, arg1);	90	IPC_SET_ARG1(data, arg1);
90	IPC_SET_ARG2(data, arg2);	91	IPC_SET_ARG2(data, arg2);
91	IPC_SET_ARG3(data, arg3);	92	IPC_SET_ARG3(data, arg3);
92		93
93	callres = __SYSCALL3(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t)&data,	94	callres = __SYSCALL3(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t)&data,
94	(sysarg_t)&data);	95	(sysarg_t)&data);
95	if (callres)	96	if (callres)
96	return callres;	97	return callres;
97		98
98	if (result1)	99	if (result1)
99	*result1 = IPC_GET_ARG1(data);	100	*result1 = IPC_GET_ARG1(data);
100	if (result2)	101	if (result2)
101	*result2 = IPC_GET_ARG2(data);	102	*result2 = IPC_GET_ARG2(data);
102	if (result3)	103	if (result3)
103	*result3 = IPC_GET_ARG3(data);	104	*result3 = IPC_GET_ARG3(data);
104	return IPC_GET_RETVAL(data);	105	return IPC_GET_RETVAL(data);
105	}	106	}
106		107
107	/** Syscall to send asynchronous message */	108	/** Syscall to send asynchronous message */
108	static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)	109	static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)
109	{	110	{
110	return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t)data);	111	return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t)data);
111	}	112	}
112		113
113	/** Send asynchronous message	114	/** Send asynchronous message
114	*	115	*
115	* - if fatal error, call callback handler with proper error code	116	* - if fatal error, call callback handler with proper error code
116	* - if message cannot be temporarily sent, add to queue	117	* - if message cannot be temporarily sent, add to queue
117	*/	118	*/
118	void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,	119	void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,
119	ipcarg_t arg2, void *private,	120	ipcarg_t arg2, void *private,
120	ipc_async_callback_t callback)	121	ipc_async_callback_t callback)
121	{	122	{
122	async_call_t *call;	123	async_call_t *call;
123	ipc_callid_t callid;	124	ipc_callid_t callid;
124		125
125	call = malloc(sizeof(*call));	126	call = malloc(sizeof(*call));
126	if (!call) {	127	if (!call) {
127	callback(private, ENOMEM, NULL);	128	callback(private, ENOMEM, NULL);
128	return;	129	return;
129	}	130	}
130		131
131	callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2);	132	callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2);
132	if (callid == IPC_CALLRET_FATAL) {	133	if (callid == IPC_CALLRET_FATAL) {
133	/* Call asynchronous handler with error code */	134	/* Call asynchronous handler with error code */
134	callback(private, ENOENT, NULL);	135	callback(private, ENOENT, NULL);
135	free(call);	136	free(call);
136	return;	137	return;
137	}	138	}
138		139
139	call->callback = callback;	140	call->callback = callback;
140	call->private = private;	141	call->private = private;
141		142
142	if (callid == IPC_CALLRET_TEMPORARY) {	143	if (callid == IPC_CALLRET_TEMPORARY) {
143	/* Add asynchronous call to queue of non-dispatched async calls */	144	/* Add asynchronous call to queue of non-dispatched async calls */
144	call->u.msg.phoneid = phoneid;	145	call->u.msg.phoneid = phoneid;
145	IPC_SET_METHOD(call->u.msg.data, method);	146	IPC_SET_METHOD(call->u.msg.data, method);
146	IPC_SET_ARG1(call->u.msg.data, arg1);	147	IPC_SET_ARG1(call->u.msg.data, arg1);
147	IPC_SET_ARG2(call->u.msg.data, arg2);	148	IPC_SET_ARG2(call->u.msg.data, arg2);
148		149
149	futex_down(&ipc_futex);	150	futex_down(&ipc_futex);
150	list_append(&call->list, &queued_calls);	151	list_append(&call->list, &queued_calls);
151	futex_up(&ipc_futex);	152	futex_up(&ipc_futex);
152	return;	153	return;
153	}	154	}
154	call->u.callid = callid;	155	call->u.callid = callid;
155	/* Add call to list of dispatched calls */	156	/* Add call to list of dispatched calls */
156	futex_down(&ipc_futex);	157	futex_down(&ipc_futex);
157	list_append(&call->list, &dispatched_calls);	158	list_append(&call->list, &dispatched_calls);
158	futex_up(&ipc_futex);	159	futex_up(&ipc_futex);
159	}	160	}
160		161
161		162
162	/** Send a fast answer to a received call.	163	/** Send a fast answer to a received call.
163	*	164	*
164	* The fast answer makes use of passing retval and first two arguments in registers.	165	* The fast answer makes use of passing retval and first two arguments in registers.
165	* If you need to return more, use the ipc_answer() instead.	166	* If you need to return more, use the ipc_answer() instead.
166	*	167	*
167	* @param callid ID of the call being answered.	168	* @param callid ID of the call being answered.
168	* @param retval Return value.	169	* @param retval Return value.
169	* @param arg1 First return argument.	170	* @param arg1 First return argument.
170	* @param arg2 Second return argument.	171	* @param arg2 Second return argument.
171	*	172	*
172	* @return Zero on success or a value from @ref errno.h on failure.	173	* @return Zero on success or a value from @ref errno.h on failure.
173	*/	174	*/
174	ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,	175	ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
175	ipcarg_t arg2)	176	ipcarg_t arg2)
176	{	177	{
177	return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);	178	return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);
178	}	179	}
179		180
180	/** Send a full answer to a received call.	181	/** Send a full answer to a received call.
181	*	182	*
182	* @param callid ID of the call being answered.	183	* @param callid ID of the call being answered.
183	* @param call Call data. Must be already initialized by the responder.	184	* @param call Call data. Must be already initialized by the responder.
184	*	185	*
185	* @return Zero on success or a value from @ref errno.h on failure.	186	* @return Zero on success or a value from @ref errno.h on failure.
186	*/	187	*/
187	ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call)	188	ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call)
188	{	189	{
189	return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call);	190	return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call);
190	}	191	}
191		192
192		193
193	/** Try to dispatch queed calls from async queue */	194	/** Try to dispatch queed calls from async queue */
194	static void try_dispatch_queued_calls(void)	195	static void try_dispatch_queued_calls(void)
195	{	196	{
196	async_call_t *call;	197	async_call_t *call;
197	ipc_callid_t callid;	198	ipc_callid_t callid;
198		199
199	futex_down(&ipc_futex);	200	futex_down(&ipc_futex);
200	while (!list_empty(&queued_calls)) {	201	while (!list_empty(&queued_calls)) {
201	call = list_get_instance(queued_calls.next, async_call_t,	202	call = list_get_instance(queued_calls.next, async_call_t,
202	list);	203	list);
203		204
204	callid = _ipc_call_async(call->u.msg.phoneid,	205	callid = _ipc_call_async(call->u.msg.phoneid,
205	&call->u.msg.data);	206	&call->u.msg.data);
206	if (callid == IPC_CALLRET_TEMPORARY)	207	if (callid == IPC_CALLRET_TEMPORARY)
207	break;	208	break;
208	list_remove(&call->list);	209	list_remove(&call->list);
209		210
210	if (callid == IPC_CALLRET_FATAL) {	211	if (callid == IPC_CALLRET_FATAL) {
211	futex_up(&ipc_futex);	212	futex_up(&ipc_futex);
212	call->callback(call->private, ENOENT, NULL);	213	call->callback(call->private, ENOENT, NULL);
213	free(call);	214	free(call);
214	futex_down(&ipc_futex);	215	futex_down(&ipc_futex);
215	} else {	216	} else {
216	call->u.callid = callid;	217	call->u.callid = callid;
217	list_append(&call->list, &dispatched_calls);	218	list_append(&call->list, &dispatched_calls);
218	}	219	}
219	}	220	}
220	futex_up(&ipc_futex);	221	futex_up(&ipc_futex);
221	}	222	}
222		223
223	/** Handle received answer	224	/** Handle received answer
224	*	225	*
225	* TODO: Make it use hash table	226	* TODO: Make it use hash table
226	*	227	*
227	* @param callid Callid (with first bit set) of the answered call	228	* @param callid Callid (with first bit set) of the answered call
228	*/	229	*/
229	static void handle_answer(ipc_callid_t callid, ipc_call_t *data)	230	static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
230	{	231	{
231	link_t *item;	232	link_t *item;
232	async_call_t *call;	233	async_call_t *call;
233		234
234	callid &= ~IPC_CALLID_ANSWERED;	235	callid &= ~IPC_CALLID_ANSWERED;
235		236
236	futex_down(&ipc_futex);	237	futex_down(&ipc_futex);
237	for (item = dispatched_calls.next; item != &dispatched_calls;	238	for (item = dispatched_calls.next; item != &dispatched_calls;
238	item = item->next) {	239	item = item->next) {
239	call = list_get_instance(item, async_call_t, list);	240	call = list_get_instance(item, async_call_t, list);
240	if (call->u.callid == callid) {	241	if (call->u.callid == callid) {
241	list_remove(&call->list);	242	list_remove(&call->list);
242	futex_up(&ipc_futex);	243	futex_up(&ipc_futex);
243	call->callback(call->private,	244	call->callback(call->private,
244	IPC_GET_RETVAL(*data),	245	IPC_GET_RETVAL(*data),
245	data);	246	data);
246	return;	247	return;
247	}	248	}
248	}	249	}
249	futex_up(&ipc_futex);	250	futex_up(&ipc_futex);
250	printf("Received unidentified answer: %P!!!\n", callid);	251	printf("Received unidentified answer: %P!!!\n", callid);
251	}	252	}
252		253
253		254
254	/** Wait for IPC call and return	255	/** Unconditionally wait for an IPC call.
255	*	256	*
256	* - dispatch ASYNC reoutines in the background	257	* - dispatch ASYNC reoutines in the background
257	* @param data Space where the message is stored	258	* @param call Space where the message is stored
258	* @return Callid or 0 if nothing available and started with	259	* @return Callid of the answer.
259	* IPC_WAIT_NONBLOCKING	-
260	*/	260	*/
261	ipc_callid_t ipc_wait_for_call(ipc_call_t *call, int flags)	261	ipc_callid_t ipc_wait_for_call(ipc_call_t *call)
262	{	262	{
263	ipc_callid_t callid;	263	ipc_callid_t callid;
264		264
265	do {	265	do {
266	try_dispatch_queued_calls();	266	try_dispatch_queued_calls();
267		267
-		268	callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, SYNCH_NO_TIMEOUT, SYNCH_BLOCKING);
-		269	/* Handle received answers */
-		270	if (callid & IPC_CALLID_ANSWERED)
-		271	handle_answer(callid, call);
-		272	} while (callid & IPC_CALLID_ANSWERED);
-		273
-		274	return callid;
-		275	}
-		276
-		277	/** Wait some time for an IPC call.
-		278	*
-		279	* - dispatch ASYNC reoutines in the background
-		280	* @param call Space where the message is stored
-		281	* @param usec Timeout in microseconds.
-		282	* @return Callid of the answer.
-		283	*/
-		284	ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec)
-		285	{
-		286	ipc_callid_t callid;
-		287
-		288	do {
-		289	try_dispatch_queued_calls();
-		290
268	callid = __SYSCALL2(SYS_IPC_WAIT, (sysarg_t)call, flags);	291	callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, SYNCH_BLOCKING);
-		292	/* Handle received answers */
-		293	if (callid & IPC_CALLID_ANSWERED)
-		294	handle_answer(callid, call);
-		295	} while (callid & IPC_CALLID_ANSWERED);
-		296
-		297	return callid;
-		298	}
-		299
-		300	/** Check if there is an IPC call waiting to be picked up.
-		301	*
-		302	* - dispatch ASYNC reoutines in the background
-		303	* @param call Space where the message is stored
-		304	* @return Callid of the answer.
-		305	*/
-		306	ipc_callid_t ipc_trywait_for_call(ipc_call_t *call)
-		307	{
-		308	ipc_callid_t callid;
-		309
-		310	do {
-		311	try_dispatch_queued_calls();
-		312
-		313	callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t)call, SYNCH_NO_TIMEOUT, SYNCH_NON_BLOCKING);
269	/* Handle received answers */	314	/* Handle received answers */
270	if (callid & IPC_CALLID_ANSWERED)	315	if (callid & IPC_CALLID_ANSWERED)
271	handle_answer(callid, call);	316	handle_answer(callid, call);
272	} while (callid & IPC_CALLID_ANSWERED);	317	} while (callid & IPC_CALLID_ANSWERED);
273		318
274	return callid;	319	return callid;
275	}	320	}
276		321
277	/** Ask destination to do a callback connection	322	/** Ask destination to do a callback connection
278	*	323	*
279	* @return 0 - OK, error code	324	* @return 0 - OK, error code
280	*/	325	*/
281	int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phone)	326	int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phone)
282	{	327	{
283	return ipc_call_sync_3(phoneid, IPC_M_CONNECT_TO_ME, arg1,	328	return ipc_call_sync_3(phoneid, IPC_M_CONNECT_TO_ME, arg1,
284	arg2, 0, 0, 0, phone);	329	arg2, 0, 0, 0, phone);
285	}	330	}
286		331
287	/** Ask through phone for a new connection to some service	332	/** Ask through phone for a new connection to some service
288	*	333	*
289	* @return new phoneid - OK, error code	334	* @return new phoneid - OK, error code
290	*/	335	*/
291	int ipc_connect_me_to(int phoneid, int arg1, int arg2)	336	int ipc_connect_me_to(int phoneid, int arg1, int arg2)
292	{	337	{
293	ipcarg_t newphid;	338	ipcarg_t newphid;
294	int res;	339	int res;
295		340
296	res = ipc_call_sync_3(phoneid, IPC_M_CONNECT_ME_TO, arg1,	341	res = ipc_call_sync_3(phoneid, IPC_M_CONNECT_ME_TO, arg1,
297	arg2, 0, 0, 0, &newphid);	342	arg2, 0, 0, 0, &newphid);
298	if (res)	343	if (res)
299	return res;	344	return res;
300	return newphid;	345	return newphid;
301	}	346	}
302		347
303	/* Hang up specified phone */	348	/* Hang up specified phone */
304	int ipc_hangup(int phoneid)	349	int ipc_hangup(int phoneid)
305	{	350	{
306	return __SYSCALL1(SYS_IPC_HANGUP, phoneid);	351	return __SYSCALL1(SYS_IPC_HANGUP, phoneid);
307	}	352	}
308		353
309	int ipc_register_irq(int irq, irq_code_t *ucode)	354	int ipc_register_irq(int irq, irq_code_t *ucode)
310	{	355	{
311	return __SYSCALL2(SYS_IPC_REGISTER_IRQ, irq, (sysarg_t) ucode);	356	return __SYSCALL2(SYS_IPC_REGISTER_IRQ, irq, (sysarg_t) ucode);
312	}	357	}
313		358
314	int ipc_unregister_irq(int irq)	359	int ipc_unregister_irq(int irq)
315	{	360	{
316	return __SYSCALL1(SYS_IPC_UNREGISTER_IRQ, irq);	361	return __SYSCALL1(SYS_IPC_UNREGISTER_IRQ, irq);
317	}	362	}
318		363
319	int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method, ipcarg_t arg1)	364	int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method, ipcarg_t arg1)
320	{	365	{
321	return __SYSCALL4(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1);	366	return __SYSCALL4(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1);
322	}	367	}
323		368
324		369
325	/** Open shared memory connection over specified phoneid	370	/** Open shared memory connection over specified phoneid
326	*	371	*
327	*	372	*
328	* Allocate as_area, notify the other side about our intention	373	* Allocate as_area, notify the other side about our intention
329	* to open the connection	374	* to open the connection
330	*	375	*
331	* @return Connection id identifying this connection	376	* @return Connection id identifying this connection
332	*/	377	*/
333	//int ipc_dgr_open(int pohoneid, size_t bufsize)	378	//int ipc_dgr_open(int pohoneid, size_t bufsize)
334	//{	379	//{
335	/* Find new file descriptor in local descriptor table */	380	/* Find new file descriptor in local descriptor table */
336	/* Create AS_area, initialize structures */	381	/* Create AS_area, initialize structures */
337	/* Send AS to other side, handle error states */	382	/* Send AS to other side, handle error states */
338		383
339	//}	384	//}
340	/*	385	/*
341	void ipc_dgr_close(int cid)	386	void ipc_dgr_close(int cid)
342	{	387	{
343	}	388	}
344		389
345	void * ipc_dgr_alloc(int cid, size_t size)	390	void * ipc_dgr_alloc(int cid, size_t size)
346	{	391	{
347	}	392	}
348		393
349	void ipc_dgr_free(int cid, void *area)	394	void ipc_dgr_free(int cid, void *area)
350	{	395	{
351		396
352	}	397	}
353		398
354	int ipc_dgr_send(int cid, void *area)	399	int ipc_dgr_send(int cid, void *area)
355	{	400	{
356	}	401	}
357		402
358		403
359	int ipc_dgr_send_data(int cid, void *data, size_t size)	404	int ipc_dgr_send_data(int cid, void *data, size_t size)
360	{	405	{
361	}	406	}
362		407
363	*/	408	*/
364		409

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/libc/generic/ipc.c @ 1653 – Rev 1360 → 1365