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>
#include <async.h>
#include <psthread.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;
    pstid_t ptid;   /**< Thread waiting for sending this msg */
} async_call_t;
 
LIST_INITIALIZE(dispatched_calls);
 
/* queued_calls is protcted by async_futex, because if the
 * call cannot be sent into kernel, async framework is used
 * automatically
 */
LIST_INITIALIZE(queued_calls); /**< List of async calls that were not accepted
                *   by kernel */
 
static atomic_t ipc_futex = FUTEX_INITIALIZER;
 
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);
}
 
/** Prolog to ipc_async_send functions */
static inline async_call_t *ipc_prepare_async(void *private, ipc_async_callback_t callback)
{
    async_call_t *call;
 
    call = malloc(sizeof(*call));
    if (!call) {
        if (callback)
            callback(private, ENOMEM, NULL);
        return NULL;
    }
    call->callback = callback;
    call->private = private;
 
    return call;
}
 
/** Epilogue of ipc_async_send functions */
static inline void ipc_finish_async(ipc_callid_t callid, int phoneid,
                    async_call_t *call, int can_preempt)
{
    if (callid == IPC_CALLRET_FATAL) {
        futex_up(&ipc_futex);
        /* Call asynchronous handler with error code */
        if (call->callback)
            call->callback(call->private, ENOENT, NULL);
        free(call);
        return;
    }
 
    if (callid == IPC_CALLRET_TEMPORARY) {
        futex_up(&ipc_futex);
 
        call->u.msg.phoneid = phoneid;
       
 
        futex_down(&async_futex);
        list_append(&call->list, &queued_calls);
 
        if (can_preempt) {
            call->ptid = psthread_get_id();
            psthread_schedule_next_adv(PS_TO_MANAGER);
            /* Async futex unlocked by previous call */
        } else {
            call->ptid = 0;
            futex_up(&async_futex);
        }
        return;
    }
    call->u.callid = callid;
    /* Add call to list of dispatched calls */
    list_append(&call->list, &dispatched_calls);
    futex_up(&ipc_futex);
   
}
 
/** 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, int can_preempt)
{
    async_call_t *call;
    ipc_callid_t callid;
 
    call = ipc_prepare_async(private, callback);
    if (!call)
        return;
 
    /* We need to make sure that we get callid before
     * another thread accesses the queue again */
    futex_down(&ipc_futex);
    callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2);
 
    if (callid == IPC_CALLRET_TEMPORARY) {
        IPC_SET_METHOD(call->u.msg.data, method);
        IPC_SET_ARG1(call->u.msg.data, arg1);
        IPC_SET_ARG2(call->u.msg.data, arg2);
    }
    ipc_finish_async(callid, phoneid, call, can_preempt);
}
 
/** 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_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
              ipcarg_t arg2, ipcarg_t arg3, void *private,
              ipc_async_callback_t callback, int can_preempt)
{
    async_call_t *call;
    ipc_callid_t callid;
 
    call = ipc_prepare_async(private, callback);
    if (!call)
        return;
 
    IPC_SET_METHOD(call->u.msg.data, method);
    IPC_SET_ARG1(call->u.msg.data, arg1);
    IPC_SET_ARG2(call->u.msg.data, arg2);
    IPC_SET_ARG3(call->u.msg.data, arg3);
    /* We need to make sure that we get callid before
     * another thread accesses the queue again */
    futex_down(&ipc_futex);
    callid = _ipc_call_async(phoneid, &call->u.msg.data);
 
    ipc_finish_async(callid, phoneid, call, can_preempt);
}
 
 
/** 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;
 
    /* TODO: integrate intelligently ipc_futex, so that it
     * is locked during ipc_call_async, until it is added
     * to dispatched_calls
     */
    futex_down(&async_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);
 
        futex_up(&async_futex);
        if (call->ptid)
            psthread_add_ready(call->ptid);
       
        if (callid == IPC_CALLRET_FATAL) {
            if (call->callback)
                call->callback(call->private, ENOENT, NULL);
            free(call);
        } else {
            call->u.callid = callid;
            futex_down(&ipc_futex);
            list_append(&call->list, &dispatched_calls);
            futex_up(&ipc_futex);
        }
        futex_down(&async_futex);
    }
    futex_up(&async_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);
            if (call->callback)
                call->callback(call->private,
                           IPC_GET_RETVAL(*data),
                           data);
            free(call);
            return;
        }
    }
    futex_up(&ipc_futex);
    printf("Received unidentified answer: %P!!!\n", callid);
}
 
 
/** One cycle of ipc wait for call call
 *
 * - dispatch ASYNC reoutines in the background
 * @param call Space where the message is stored
 * @param usec Timeout in microseconds
 * @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking)
 * @return Callid of the answer.
 */
ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags)
{
    ipc_callid_t callid;
 
    callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
    /* Handle received answers */
    if (callid & IPC_CALLID_ANSWERED) {
        handle_answer(callid, call);
        try_dispatch_queued_calls();
    }
 
    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 {
        callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);
    } 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 {
        callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING);
    } 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);
}
 
 
 
 
 
 
 
 
/* Primitive functions for simple communication */
 
void send_call_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
 
 
 
 
 
 
 
 
 
 
 
         ipcarg_t arg2, ipcarg_t arg3)
{
    ipc_call_async_3(phoneid, method, arg1, arg2, arg3, NULL, NULL, 1);
}
 
void send_call_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2)
{
 
    ipc_call_async_2(phoneid, method, arg1, arg2, NULL, NULL, 1);
}
 
void nsend_call_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
          ipcarg_t arg2, ipcarg_t arg3)
{
    ipc_call_async_3(phoneid, method, arg1, arg2, arg3, NULL, NULL, 0);
}
 
 
void nsend_call_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2)
{
    ipc_call_async_2(phoneid, method, arg1, arg2, NULL, NULL, 0);
}
 
 
 

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

Subversion Repositories HelenOS-historic

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