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.
 */
 
/** @addtogroup libc
 * @{
 * @}
 */
 
/** @addtogroup libcipc IPC
 * @brief HelenOS uspace IPC
 * @{
 * @ingroup libc
 */
/** @file
 */
 
#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 <fibril.h>
#include <assert.h>
 
/**
 * Structures of this type are used for keeping track of sent asynchronous calls
 * and queing unsent calls.
 */
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;
    fid_t fid;  /**< Fibril waiting for sending this call. */
} async_call_t;
 
LIST_INITIALIZE(dispatched_calls);
 
/** List of asynchronous calls that were not accepted by kernel.
 *
 * It is protected by async_futex, because if the call cannot be sent into the
 * kernel, the async framework is used automatically.
 */
LIST_INITIALIZE(queued_calls);
 
static atomic_t ipc_futex = FUTEX_INITIALIZER;
 
/** Make a fast synchronous call.
 *
 * Only one payload argument can be passed using this function. However, this
 * function is faster than the generic ipc_call_sync_3().
 *
 * @param phoneid   Phone handle for the call.
 * @param method    Requested method.
 * @param arg1      Service-defined payload argument.
 * @param result    If non-NULL, the return ARG1 will be stored there.
 *
 * @return      Negative values represent errors returned by IPC.
 *          Otherwise the RETVAL of the answer is returned.
 */
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);
}
 
/** Make a synchronous call transmitting 3 arguments of payload.
 *
 * @param phoneid   Phone handle for the call.
 * @param method    Requested method.
 * @param arg1      Service-defined payload argument.
 * @param arg2      Service-defined payload argument.
 * @param arg3      Service-defined payload argument.
 * @param result1   If non-NULL, storage for the first return argument.
 * @param result2   If non-NULL, storage for the second return argument.
 * @param result3   If non-NULL, storage for the third return argument.
 *
 * @return      Negative value means IPC error.
 *          Otherwise the RETVAL of the answer.
 */
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.
 *
 * @param phoneid   Phone handle for the call.
 * @param data      Call data with the request.
 *
 * @return      Hash of the call or an error code.
 */
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_call_async_*() functions.
 *
 * @param private   Argument for the answer/error callback.
 * @param callback  Answer/error callback.
 *
 * @return      New, partially initialized async_call structure or NULL.
 */
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_call_async_*() functions.
 *
 * @param callid    Value returned by the SYS_IPC_CALL_ASYNC_* syscall.
 * @param phoneid   Phone handle through which the call was made.
 * @param call      async_call structure returned by ipc_prepare_async().
 * @param can_preempt   If non-zero, the current pseudo thread can be preempted
 *          in this call.
 */
static inline void ipc_finish_async(ipc_callid_t callid, int phoneid,
    async_call_t *call, int can_preempt)
{
    if (!call) { /* Nothing to do regardless if failed or not */
        futex_up(&ipc_futex);
        return;
    }
 
    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->fid = fibril_get_id();
            fibril_schedule_next_adv(FIBRIL_TO_MANAGER);
            /* Async futex unlocked by previous call */
        } else {
            call->fid = 0;
            futex_up(&async_futex);
        }
        return;
    }
    call->u.callid = callid;
    /* Add call to the list of dispatched calls */
    list_append(&call->list, &dispatched_calls);
    futex_up(&ipc_futex);
   
}
 
/** Make a fast asynchronous call.
 *
 * This function can only handle two arguments of payload. It is, however,
 * faster than the more generic ipc_call_async_3().
 *
 * Note that this function is a void function.
 * During normal opertation, answering this call will trigger the callback.
 * In case of fatal error, call the callback handler with the proper error code.
 * If the call cannot be temporarily made, queue it.
 *
 * @param phoneid   Phone handle for the call.
 * @param method    Requested method.
 * @param arg1      Service-defined payload argument.
 * @param arg2      Service-defined payload argument.
 * @param private   Argument to be passed to the answer/error callback.
 * @param callback  Answer or error callback.
 * @param can_preempt   If non-zero, the current pseudo thread will be preempted
 *          in case the kernel temporarily refuses to accept more
 *          asynchronous calls.
 */
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 = NULL;
    ipc_callid_t callid;
 
    if (callback) {
        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) {
        if (!call) {
            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_finish_async(callid, phoneid, call, can_preempt);
}
 
/** Make an asynchronous call transmitting the entire payload.
 *
 * Note that this function is a void function.
 * During normal opertation, answering this call will trigger the callback.
 * In case of fatal error, call the callback handler with the proper error code.
 * If the call cannot be temporarily made, queue it.
 *
 * @param phoneid   Phone handle for the call.
 * @param method    Requested method.
 * @param arg1      Service-defined payload argument.
 * @param arg2      Service-defined payload argument.
 * @param arg3      Service-defined payload argument.
 * @param private   Argument to be passed to the answer/error callback.
 * @param callback  Answer or error callback.
 * @param can_preempt   If non-zero, the current pseudo thread will be preempted
 *          in case the kernel temporarily refuses to accept more
 *          asynchronous calls.
 *
 */
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);
}
 
 
/** Answer a received call - fast version.
 *
 * 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    Hash 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);
}
 
/** Answer a received call - full version.
 *
 * @param callid    Hash of the call being answered.
 * @param call      Call structure with the answer.
 *          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 queued calls from the 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->fid)
            fibril_add_ready(call->fid);
       
        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 a received answer.
 *
 * Find the hash of the answer and call the answer callback.
 *
 * @todo Make it use hash table.
 *
 * @param callid    Hash of the received answer.
 *          The answer has the same hash as the request OR'ed with
 *          the IPC_CALLID_ANSWERED bit.
 * @param data      Call data of the answer.
 */
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);
}
 
 
/** Wait for a first call to come.
 *
 * @param call      Storage where the incoming call data will be stored.
 * @param usec      Timeout in microseconds
 * @param flags     Flags passed to SYS_IPC_WAIT (blocking, nonblocking).
 *
 * @return      Hash of the call. Note that certain bits have special
 *          meaning. IPC_CALLID_ANSWERED will be set in an answer
 *          and IPC_CALLID_NOTIFICATION is used for notifications.
 *         
 */
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.
 *
 * The call will return after an answer is received.
 *
 * @param call      Storage where the incoming call data will be stored.
 * @param usec      Timeout in microseconds.
 *
 * @return      Hash 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.
 *
 * @param call      Storage where the incoming call will be stored.
 * @return      Hash 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.
 *
 * @param phoneid   Phone handle used for contacting the other side.
 * @param arg1      Service-defined argument.
 * @param arg2      Service-defined argument.
 * @param phonehash Storage where the library will store an opaque
 *          identifier of the phone that will be used for incoming
 *          calls. This identifier can be used for connection
 *          tracking.
 *
 * @return      Zero on success or a negative error code.
 */
int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phonehash)
{
    return ipc_call_sync_3(phoneid, IPC_M_CONNECT_TO_ME, arg1, arg2, 0, 0, 0,
        phonehash);
}
 
/** Ask through phone for a new connection to some service.
 *
 * @param phoneid   Phone handle used for contacting the other side.
 * @param arg1      User defined argument.
 * @param arg2      User defined argument.
 *
 * @return      New phone handle on success or a negative 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 a phone.
 *
 * @param phoneid   Handle of the phone to be hung up.
 *
 * @return      Zero on success or a negative error code.
 */
int ipc_hangup(int phoneid)
{
    return __SYSCALL1(SYS_IPC_HANGUP, phoneid);
}
 
/** Register IRQ notification.
 *
 * @param inr       IRQ number.
 * @param devno     Device number of the device generating inr.
 * @param method    Use this method for notifying me.
 * @param ucode     Top-half pseudocode handler.
 *
 * @return      Value returned by the kernel.
 */
int ipc_register_irq(int inr, int devno, int method, irq_code_t *ucode)
{
    return __SYSCALL4(SYS_IPC_REGISTER_IRQ, inr, devno, method,
        (sysarg_t) ucode);
}
 
/** Unregister IRQ notification.
 *
 * @param inr       IRQ number.
 * @param devno     Device number of the device generating inr.
 *
 * @return      Value returned by the kernel.
 */
int ipc_unregister_irq(int inr, int devno)
{
    return __SYSCALL2(SYS_IPC_UNREGISTER_IRQ, inr, devno);
}
 
/** Forward a received call to another destination.
 *
 * @param callid    Hash of the call to forward.
 * @param phoneid   Phone handle to use for forwarding.
 * @param method    New method for the forwarded call.
 * @param arg1      New value of the first argument for the forwarded call.
 *
 * @return      Zero on success or an error code.
 *
 * For non-system methods, the old method and arg1 are rewritten by the new
 * values. For system methods, the new method and arg1 are written to the old
 * arg1 and arg2, respectivelly.
 */
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);
}
 
/** Wrapper for accepting the IPC_M_DATA_SEND calls.
 *
 * This wrapper only makes it more comfortable to accept IPC_M_DATA_SEND calls
 * so that the user doesn't have to remember the meaning of each IPC argument.
 *
 * So far, this wrapper is to be used from within a connection fibril.
 *
 * @param callid    Storage where the hash of the IPC_M_DATA_SEND call will
 *          be stored.
 * @param call      Storage where the incoming call will be stored.
 * @param dst       Storage where the suggested destination address will
 *          be stored. May be NULL.
 * @param size      Storage where the suggested size will be stored. May be
 *          NULL
 *
 * @return      Non-zero on success, zero on failure.
 */
int ipc_data_send_accept(ipc_callid_t *callid, ipc_call_t *call, void **dst,
    size_t *size)
{
    assert(callid);
    assert(call);
 
    *callid = async_get_call(call);
    if (IPC_GET_METHOD(*call) != IPC_M_DATA_SEND)
        return 0;
    if (dst)
        *dst = (void *) IPC_GET_ARG1(*call);
    if (size)
        *size = (size_t) IPC_GET_ARG3(*call);
    return 1;
}
 
/** Wrapper for answering the IPC_M_DATA_SEND calls.
 *
 * This wrapper only makes it more comfortable to answer IPC_M_DATA_SEND calls
 * so that the user doesn't have to remember the meaning of each IPC argument.
 *
 * @param callid    Hash of the IPC_M_DATA_SEND call to answer.
 * @param call      Call structure with the request.
 * @param dst       Final destination address for the IPC_M_DATA_SEND call.
 * @param size      Final size for the IPC_M_DATA_SEND call.
 *
 * @return      Zero on success or a value from @ref errno.h on failure.
 */
ipcarg_t ipc_data_send_answer(ipc_callid_t callid, ipc_call_t *call, void *dst,     size_t size)
{
    IPC_SET_RETVAL(*call, EOK);
    IPC_SET_ARG1(*call, (ipcarg_t) dst);
    IPC_SET_ARG3(*call, (ipcarg_t) size);
    return ipc_answer(callid, call);
}
 
/** @}
 */
 

Rev 2490	Rev 2522
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	/** @addtogroup libc	29	/** @addtogroup libc
30	* @{	30	* @{
31	* @}	31	* @}
32	*/	32	*/
33		33
34	/** @addtogroup libcipc IPC	34	/** @addtogroup libcipc IPC
35	* @brief HelenOS uspace IPC	35	* @brief HelenOS uspace IPC
36	* @{	36	* @{
37	* @ingroup libc	37	* @ingroup libc
38	*/	38	*/
39	/** @file	39	/** @file
40	*/	40	*/
41		41
42	#include <ipc/ipc.h>	42	#include <ipc/ipc.h>
43	#include <libc.h>	43	#include <libc.h>
44	#include <malloc.h>	44	#include <malloc.h>
45	#include <errno.h>	45	#include <errno.h>
46	#include <libadt/list.h>	46	#include <libadt/list.h>
47	#include <stdio.h>	47	#include <stdio.h>
48	#include <unistd.h>	48	#include <unistd.h>
49	#include <futex.h>	49	#include <futex.h>
50	#include <kernel/synch/synch.h>	50	#include <kernel/synch/synch.h>
51	#include <async.h>	51	#include <async.h>
52	#include <fibril.h>	52	#include <fibril.h>
-		53	#include <assert.h>
53		54
54	/**	55	/**
55	* Structures of this type are used for keeping track of sent asynchronous calls	56	* Structures of this type are used for keeping track of sent asynchronous calls
56	* and queing unsent calls.	57	* and queing unsent calls.
57	*/	58	*/
58	typedef struct {	59	typedef struct {
59	link_t list;	60	link_t list;
60		61
61	ipc_async_callback_t callback;	62	ipc_async_callback_t callback;
62	void *private;	63	void *private;
63	union {	64	union {
64	ipc_callid_t callid;	65	ipc_callid_t callid;
65	struct {	66	struct {
66	ipc_call_t data;	67	ipc_call_t data;
67	int phoneid;	68	int phoneid;
68	} msg;	69	} msg;
69	} u;	70	} u;
70	fid_t fid; /*< Fibril waiting for sending this call. /	71	fid_t fid; /*< Fibril waiting for sending this call. /
71	} async_call_t;	72	} async_call_t;
72		73
73	LIST_INITIALIZE(dispatched_calls);	74	LIST_INITIALIZE(dispatched_calls);
74		75
75	/** List of asynchronous calls that were not accepted by kernel.	76	/** List of asynchronous calls that were not accepted by kernel.
76	*	77	*
77	* It is protected by async_futex, because if the call cannot be sent into the	78	* It is protected by async_futex, because if the call cannot be sent into the
78	* kernel, the async framework is used automatically.	79	* kernel, the async framework is used automatically.
79	*/	80	*/
80	LIST_INITIALIZE(queued_calls);	81	LIST_INITIALIZE(queued_calls);
81		82
82	static atomic_t ipc_futex = FUTEX_INITIALIZER;	83	static atomic_t ipc_futex = FUTEX_INITIALIZER;
83		84
84	/** Make a fast synchronous call.	85	/** Make a fast synchronous call.
85	*	86	*
86	* Only one payload argument can be passed using this function. However, this	87	* Only one payload argument can be passed using this function. However, this
87	* function is faster than the generic ipc_call_sync_3().	88	* function is faster than the generic ipc_call_sync_3().
88	*	89	*
89	* @param phoneid Phone handle for the call.	90	* @param phoneid Phone handle for the call.
90	* @param method Requested method.	91	* @param method Requested method.
91	* @param arg1 Service-defined payload argument.	92	* @param arg1 Service-defined payload argument.
92	* @param result If non-NULL, the return ARG1 will be stored there.	93	* @param result If non-NULL, the return ARG1 will be stored there.
93	*	94	*
94	* @return Negative values represent errors returned by IPC.	95	* @return Negative values represent errors returned by IPC.
95	* Otherwise the RETVAL of the answer is returned.	96	* Otherwise the RETVAL of the answer is returned.
96	*/	97	*/
97	int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t *result)	98	int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t *result)
98	{	99	{
99	ipc_call_t resdata;	100	ipc_call_t resdata;
100	int callres;	101	int callres;
101		102
102	callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,	103	callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
103	(sysarg_t) &resdata);	104	(sysarg_t) &resdata);
104	if (callres)	105	if (callres)
105	return callres;	106	return callres;
106	if (result)	107	if (result)
107	*result = IPC_GET_ARG1(resdata);	108	*result = IPC_GET_ARG1(resdata);
108	return IPC_GET_RETVAL(resdata);	109	return IPC_GET_RETVAL(resdata);
109	}	110	}
110		111
111	/** Make a synchronous call transmitting 3 arguments of payload.	112	/** Make a synchronous call transmitting 3 arguments of payload.
112	*	113	*
113	* @param phoneid Phone handle for the call.	114	* @param phoneid Phone handle for the call.
114	* @param method Requested method.	115	* @param method Requested method.
115	* @param arg1 Service-defined payload argument.	116	* @param arg1 Service-defined payload argument.
116	* @param arg2 Service-defined payload argument.	117	* @param arg2 Service-defined payload argument.
117	* @param arg3 Service-defined payload argument.	118	* @param arg3 Service-defined payload argument.
118	* @param result1 If non-NULL, storage for the first return argument.	119	* @param result1 If non-NULL, storage for the first return argument.
119	* @param result2 If non-NULL, storage for the second return argument.	120	* @param result2 If non-NULL, storage for the second return argument.
120	* @param result3 If non-NULL, storage for the third return argument.	121	* @param result3 If non-NULL, storage for the third return argument.
121	*	122	*
122	* @return Negative value means IPC error.	123	* @return Negative value means IPC error.
123	* Otherwise the RETVAL of the answer.	124	* Otherwise the RETVAL of the answer.
124	*/	125	*/
125	int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,	126	int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
126	ipcarg_t arg3, ipcarg_t result1, ipcarg_t result2, ipcarg_t *result3)	127	ipcarg_t arg3, ipcarg_t result1, ipcarg_t result2, ipcarg_t *result3)
127	{	128	{
128	ipc_call_t data;	129	ipc_call_t data;
129	int callres;	130	int callres;
130		131
131	IPC_SET_METHOD(data, method);	132	IPC_SET_METHOD(data, method);
132	IPC_SET_ARG1(data, arg1);	133	IPC_SET_ARG1(data, arg1);
133	IPC_SET_ARG2(data, arg2);	134	IPC_SET_ARG2(data, arg2);
134	IPC_SET_ARG3(data, arg3);	135	IPC_SET_ARG3(data, arg3);
135		136
136	callres = __SYSCALL3(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t) &data,	137	callres = __SYSCALL3(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t) &data,
137	(sysarg_t) &data);	138	(sysarg_t) &data);
138	if (callres)	139	if (callres)
139	return callres;	140	return callres;
140		141
141	if (result1)	142	if (result1)
142	*result1 = IPC_GET_ARG1(data);	143	*result1 = IPC_GET_ARG1(data);
143	if (result2)	144	if (result2)
144	*result2 = IPC_GET_ARG2(data);	145	*result2 = IPC_GET_ARG2(data);
145	if (result3)	146	if (result3)
146	*result3 = IPC_GET_ARG3(data);	147	*result3 = IPC_GET_ARG3(data);
147	return IPC_GET_RETVAL(data);	148	return IPC_GET_RETVAL(data);
148	}	149	}
149		150
150	/** Syscall to send asynchronous message.	151	/** Syscall to send asynchronous message.
151	*	152	*
152	* @param phoneid Phone handle for the call.	153	* @param phoneid Phone handle for the call.
153	* @param data Call data with the request.	154	* @param data Call data with the request.
154	*	155	*
155	* @return Hash of the call or an error code.	156	* @return Hash of the call or an error code.
156	*/	157	*/
157	static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)	158	static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)
158	{	159	{
159	return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t) data);	160	return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t) data);
160	}	161	}
161		162
162	/** Prolog to ipc_call_async_*() functions.	163	/** Prolog to ipc_call_async_*() functions.
163	*	164	*
164	* @param private Argument for the answer/error callback.	165	* @param private Argument for the answer/error callback.
165	* @param callback Answer/error callback.	166	* @param callback Answer/error callback.
166	*	167	*
167	* @return New, partially initialized async_call structure or NULL.	168	* @return New, partially initialized async_call structure or NULL.
168	*/	169	*/
169	static inline async_call_t ipc_prepare_async(void private,	170	static inline async_call_t ipc_prepare_async(void private,
170	ipc_async_callback_t callback)	171	ipc_async_callback_t callback)
171	{	172	{
172	async_call_t *call;	173	async_call_t *call;
173		174
174	call = malloc(sizeof(*call));	175	call = malloc(sizeof(*call));
175	if (!call) {	176	if (!call) {
176	if (callback)	177	if (callback)
177	callback(private, ENOMEM, NULL);	178	callback(private, ENOMEM, NULL);
178	return NULL;	179	return NULL;
179	}	180	}
180	call->callback = callback;	181	call->callback = callback;
181	call->private = private;	182	call->private = private;
182		183
183	return call;	184	return call;
184	}	185	}
185		186
186	/** Epilogue of ipc_call_async_*() functions.	187	/** Epilogue of ipc_call_async_*() functions.
187	*	188	*
188	* @param callid Value returned by the SYS_IPC_CALL_ASYNC_* syscall.	189	* @param callid Value returned by the SYS_IPC_CALL_ASYNC_* syscall.
189	* @param phoneid Phone handle through which the call was made.	190	* @param phoneid Phone handle through which the call was made.
190	* @param call async_call structure returned by ipc_prepare_async().	191	* @param call async_call structure returned by ipc_prepare_async().
191	* @param can_preempt If non-zero, the current pseudo thread can be preempted	192	* @param can_preempt If non-zero, the current pseudo thread can be preempted
192	* in this call.	193	* in this call.
193	*/	194	*/
194	static inline void ipc_finish_async(ipc_callid_t callid, int phoneid,	195	static inline void ipc_finish_async(ipc_callid_t callid, int phoneid,
195	async_call_t *call, int can_preempt)	196	async_call_t *call, int can_preempt)
196	{	197	{
197	if (!call) { /* Nothing to do regardless if failed or not */	198	if (!call) { /* Nothing to do regardless if failed or not */
198	futex_up(&ipc_futex);	199	futex_up(&ipc_futex);
199	return;	200	return;
200	}	201	}
201		202
202	if (callid == IPC_CALLRET_FATAL) {	203	if (callid == IPC_CALLRET_FATAL) {
203	futex_up(&ipc_futex);	204	futex_up(&ipc_futex);
204	/* Call asynchronous handler with error code */	205	/* Call asynchronous handler with error code */
205	if (call->callback)	206	if (call->callback)
206	call->callback(call->private, ENOENT, NULL);	207	call->callback(call->private, ENOENT, NULL);
207	free(call);	208	free(call);
208	return;	209	return;
209	}	210	}
210		211
211	if (callid == IPC_CALLRET_TEMPORARY) {	212	if (callid == IPC_CALLRET_TEMPORARY) {
212	futex_up(&ipc_futex);	213	futex_up(&ipc_futex);
213		214
214	call->u.msg.phoneid = phoneid;	215	call->u.msg.phoneid = phoneid;
215		216
216	futex_down(&async_futex);	217	futex_down(&async_futex);
217	list_append(&call->list, &queued_calls);	218	list_append(&call->list, &queued_calls);
218		219
219	if (can_preempt) {	220	if (can_preempt) {
220	call->fid = fibril_get_id();	221	call->fid = fibril_get_id();
221	fibril_schedule_next_adv(FIBRIL_TO_MANAGER);	222	fibril_schedule_next_adv(FIBRIL_TO_MANAGER);
222	/* Async futex unlocked by previous call */	223	/* Async futex unlocked by previous call */
223	} else {	224	} else {
224	call->fid = 0;	225	call->fid = 0;
225	futex_up(&async_futex);	226	futex_up(&async_futex);
226	}	227	}
227	return;	228	return;
228	}	229	}
229	call->u.callid = callid;	230	call->u.callid = callid;
230	/* Add call to the list of dispatched calls */	231	/* Add call to the list of dispatched calls */
231	list_append(&call->list, &dispatched_calls);	232	list_append(&call->list, &dispatched_calls);
232	futex_up(&ipc_futex);	233	futex_up(&ipc_futex);
233		234
234	}	235	}
235		236
236	/** Make a fast asynchronous call.	237	/** Make a fast asynchronous call.
237	*	238	*
238	* This function can only handle two arguments of payload. It is, however,	239	* This function can only handle two arguments of payload. It is, however,
239	* faster than the more generic ipc_call_async_3().	240	* faster than the more generic ipc_call_async_3().
240	*	241	*
241	* Note that this function is a void function.	242	* Note that this function is a void function.
242	* During normal opertation, answering this call will trigger the callback.	243	* During normal opertation, answering this call will trigger the callback.
243	* In case of fatal error, call the callback handler with the proper error code.	244	* In case of fatal error, call the callback handler with the proper error code.
244	* If the call cannot be temporarily made, queue it.	245	* If the call cannot be temporarily made, queue it.
245	*	246	*
246	* @param phoneid Phone handle for the call.	247	* @param phoneid Phone handle for the call.
247	* @param method Requested method.	248	* @param method Requested method.
248	* @param arg1 Service-defined payload argument.	249	* @param arg1 Service-defined payload argument.
249	* @param arg2 Service-defined payload argument.	250	* @param arg2 Service-defined payload argument.
250	* @param private Argument to be passed to the answer/error callback.	251	* @param private Argument to be passed to the answer/error callback.
251	* @param callback Answer or error callback.	252	* @param callback Answer or error callback.
252	* @param can_preempt If non-zero, the current pseudo thread will be preempted	253	* @param can_preempt If non-zero, the current pseudo thread will be preempted
253	* in case the kernel temporarily refuses to accept more	254	* in case the kernel temporarily refuses to accept more
254	* asynchronous calls.	255	* asynchronous calls.
255	*/	256	*/
256	void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,	257	void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,
257	ipcarg_t arg2, void *private, ipc_async_callback_t callback,	258	ipcarg_t arg2, void *private, ipc_async_callback_t callback,
258	int can_preempt)	259	int can_preempt)
259	{	260	{
260	async_call_t *call = NULL;	261	async_call_t *call = NULL;
261	ipc_callid_t callid;	262	ipc_callid_t callid;
262		263
263	if (callback) {	264	if (callback) {
264	call = ipc_prepare_async(private, callback);	265	call = ipc_prepare_async(private, callback);
265	if (!call)	266	if (!call)
266	return;	267	return;
267	}	268	}
268		269
269	/*	270	/*
270	* We need to make sure that we get callid before another thread	271	* We need to make sure that we get callid before another thread
271	* accesses the queue again.	272	* accesses the queue again.
272	*/	273	*/
273	futex_down(&ipc_futex);	274	futex_down(&ipc_futex);
274	callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1,	275	callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1,
275	arg2);	276	arg2);
276		277
277	if (callid == IPC_CALLRET_TEMPORARY) {	278	if (callid == IPC_CALLRET_TEMPORARY) {
278	if (!call) {	279	if (!call) {
279	call = ipc_prepare_async(private, callback);	280	call = ipc_prepare_async(private, callback);
280	if (!call)	281	if (!call)
281	return;	282	return;
282	}	283	}
283	IPC_SET_METHOD(call->u.msg.data, method);	284	IPC_SET_METHOD(call->u.msg.data, method);
284	IPC_SET_ARG1(call->u.msg.data, arg1);	285	IPC_SET_ARG1(call->u.msg.data, arg1);
285	IPC_SET_ARG2(call->u.msg.data, arg2);	286	IPC_SET_ARG2(call->u.msg.data, arg2);
286	}	287	}
287	ipc_finish_async(callid, phoneid, call, can_preempt);	288	ipc_finish_async(callid, phoneid, call, can_preempt);
288	}	289	}
289		290
290	/** Make an asynchronous call transmitting the entire payload.	291	/** Make an asynchronous call transmitting the entire payload.
291	*	292	*
292	* Note that this function is a void function.	293	* Note that this function is a void function.
293	* During normal opertation, answering this call will trigger the callback.	294	* During normal opertation, answering this call will trigger the callback.
294	* In case of fatal error, call the callback handler with the proper error code.	295	* In case of fatal error, call the callback handler with the proper error code.
295	* If the call cannot be temporarily made, queue it.	296	* If the call cannot be temporarily made, queue it.
296	*	297	*
297	* @param phoneid Phone handle for the call.	298	* @param phoneid Phone handle for the call.
298	* @param method Requested method.	299	* @param method Requested method.
299	* @param arg1 Service-defined payload argument.	300	* @param arg1 Service-defined payload argument.
300	* @param arg2 Service-defined payload argument.	301	* @param arg2 Service-defined payload argument.
301	* @param arg3 Service-defined payload argument.	302	* @param arg3 Service-defined payload argument.
302	* @param private Argument to be passed to the answer/error callback.	303	* @param private Argument to be passed to the answer/error callback.
303	* @param callback Answer or error callback.	304	* @param callback Answer or error callback.
304	* @param can_preempt If non-zero, the current pseudo thread will be preempted	305	* @param can_preempt If non-zero, the current pseudo thread will be preempted
305	* in case the kernel temporarily refuses to accept more	306	* in case the kernel temporarily refuses to accept more
306	* asynchronous calls.	307	* asynchronous calls.
307	*	308	*
308	*/	309	*/
309	void ipc_call_async_3(int phoneid, ipcarg_t method, ipcarg_t arg1,	310	void ipc_call_async_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
310	ipcarg_t arg2, ipcarg_t arg3, void *private, ipc_async_callback_t callback,	311	ipcarg_t arg2, ipcarg_t arg3, void *private, ipc_async_callback_t callback,
311	int can_preempt)	312	int can_preempt)
312	{	313	{
313	async_call_t *call;	314	async_call_t *call;
314	ipc_callid_t callid;	315	ipc_callid_t callid;
315		316
316	call = ipc_prepare_async(private, callback);	317	call = ipc_prepare_async(private, callback);
317	if (!call)	318	if (!call)
318	return;	319	return;
319		320
320	IPC_SET_METHOD(call->u.msg.data, method);	321	IPC_SET_METHOD(call->u.msg.data, method);
321	IPC_SET_ARG1(call->u.msg.data, arg1);	322	IPC_SET_ARG1(call->u.msg.data, arg1);
322	IPC_SET_ARG2(call->u.msg.data, arg2);	323	IPC_SET_ARG2(call->u.msg.data, arg2);
323	IPC_SET_ARG3(call->u.msg.data, arg3);	324	IPC_SET_ARG3(call->u.msg.data, arg3);
324	/*	325	/*
325	* We need to make sure that we get callid before another thread accesses	326	* We need to make sure that we get callid before another thread accesses
326	* the queue again.	327	* the queue again.
327	*/	328	*/
328	futex_down(&ipc_futex);	329	futex_down(&ipc_futex);
329	callid = _ipc_call_async(phoneid, &call->u.msg.data);	330	callid = _ipc_call_async(phoneid, &call->u.msg.data);
330		331
331	ipc_finish_async(callid, phoneid, call, can_preempt);	332	ipc_finish_async(callid, phoneid, call, can_preempt);
332	}	333	}
333		334
334		335
335	/** Answer a received call - fast version.	336	/** Answer a received call - fast version.
336	*	337	*
337	* The fast answer makes use of passing retval and first two arguments in	338	* The fast answer makes use of passing retval and first two arguments in
338	* registers. If you need to return more, use the ipc_answer() instead.	339	* registers. If you need to return more, use the ipc_answer() instead.
339	*	340	*
340	* @param callid Hash of the call being answered.	341	* @param callid Hash of the call being answered.
341	* @param retval Return value.	342	* @param retval Return value.
342	* @param arg1 First return argument.	343	* @param arg1 First return argument.
343	* @param arg2 Second return argument.	344	* @param arg2 Second return argument.
344	*	345	*
345	* @return Zero on success or a value from @ref errno.h on failure.	346	* @return Zero on success or a value from @ref errno.h on failure.
346	*/	347	*/
347	ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,	348	ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
348	ipcarg_t arg2)	349	ipcarg_t arg2)
349	{	350	{
350	return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);	351	return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);
351	}	352	}
352		353
353	/** Answer a received call - full version.	354	/** Answer a received call - full version.
354	*	355	*
355	* @param callid Hash of the call being answered.	356	* @param callid Hash of the call being answered.
356	* @param call Call structure with the answer.	357	* @param call Call structure with the answer.
357	* Must be already initialized by the responder.	358	* Must be already initialized by the responder.
358	*	359	*
359	* @return Zero on success or a value from @ref errno.h on failure.	360	* @return Zero on success or a value from @ref errno.h on failure.
360	*/	361	*/
361	ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call)	362	ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call)
362	{	363	{
363	return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call);	364	return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call);
364	}	365	}
365		366
366		367
367	/** Try to dispatch queued calls from the async queue. */	368	/** Try to dispatch queued calls from the async queue. */
368	static void try_dispatch_queued_calls(void)	369	static void try_dispatch_queued_calls(void)
369	{	370	{
370	async_call_t *call;	371	async_call_t *call;
371	ipc_callid_t callid;	372	ipc_callid_t callid;
372		373
373	/** @todo	374	/** @todo
374	* Integrate intelligently ipc_futex, so that it is locked during	375	* Integrate intelligently ipc_futex, so that it is locked during
375	* ipc_call_async_*(), until it is added to dispatched_calls.	376	* ipc_call_async_*(), until it is added to dispatched_calls.
376	*/	377	*/
377	futex_down(&async_futex);	378	futex_down(&async_futex);
378	while (!list_empty(&queued_calls)) {	379	while (!list_empty(&queued_calls)) {
379	call = list_get_instance(queued_calls.next, async_call_t, list);	380	call = list_get_instance(queued_calls.next, async_call_t, list);
380	callid = _ipc_call_async(call->u.msg.phoneid, &call->u.msg.data);	381	callid = _ipc_call_async(call->u.msg.phoneid, &call->u.msg.data);
381	if (callid == IPC_CALLRET_TEMPORARY) {	382	if (callid == IPC_CALLRET_TEMPORARY) {
382	break;	383	break;
383	}	384	}
384	list_remove(&call->list);	385	list_remove(&call->list);
385		386
386	futex_up(&async_futex);	387	futex_up(&async_futex);
387	if (call->fid)	388	if (call->fid)
388	fibril_add_ready(call->fid);	389	fibril_add_ready(call->fid);
389		390
390	if (callid == IPC_CALLRET_FATAL) {	391	if (callid == IPC_CALLRET_FATAL) {
391	if (call->callback)	392	if (call->callback)
392	call->callback(call->private, ENOENT, NULL);	393	call->callback(call->private, ENOENT, NULL);
393	free(call);	394	free(call);
394	} else {	395	} else {
395	call->u.callid = callid;	396	call->u.callid = callid;
396	futex_down(&ipc_futex);	397	futex_down(&ipc_futex);
397	list_append(&call->list, &dispatched_calls);	398	list_append(&call->list, &dispatched_calls);
398	futex_up(&ipc_futex);	399	futex_up(&ipc_futex);
399	}	400	}
400	futex_down(&async_futex);	401	futex_down(&async_futex);
401	}	402	}
402	futex_up(&async_futex);	403	futex_up(&async_futex);
403	}	404	}
404		405
405	/** Handle a received answer.	406	/** Handle a received answer.
406	*	407	*
407	* Find the hash of the answer and call the answer callback.	408	* Find the hash of the answer and call the answer callback.
408	*	409	*
409	* @todo Make it use hash table.	410	* @todo Make it use hash table.
410	*	411	*
411	* @param callid Hash of the received answer.	412	* @param callid Hash of the received answer.
412	* The answer has the same hash as the request OR'ed with	413	* The answer has the same hash as the request OR'ed with
413	* the IPC_CALLID_ANSWERED bit.	414	* the IPC_CALLID_ANSWERED bit.
414	* @param data Call data of the answer.	415	* @param data Call data of the answer.
415	*/	416	*/
416	static void handle_answer(ipc_callid_t callid, ipc_call_t *data)	417	static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
417	{	418	{
418	link_t *item;	419	link_t *item;
419	async_call_t *call;	420	async_call_t *call;
420		421
421	callid &= ~IPC_CALLID_ANSWERED;	422	callid &= ~IPC_CALLID_ANSWERED;
422		423
423	futex_down(&ipc_futex);	424	futex_down(&ipc_futex);
424	for (item = dispatched_calls.next; item != &dispatched_calls;	425	for (item = dispatched_calls.next; item != &dispatched_calls;
425	item = item->next) {	426	item = item->next) {
426	call = list_get_instance(item, async_call_t, list);	427	call = list_get_instance(item, async_call_t, list);
427	if (call->u.callid == callid) {	428	if (call->u.callid == callid) {
428	list_remove(&call->list);	429	list_remove(&call->list);
429	futex_up(&ipc_futex);	430	futex_up(&ipc_futex);
430	if (call->callback)	431	if (call->callback)
431	call->callback(call->private,	432	call->callback(call->private,
432	IPC_GET_RETVAL(*data), data);	433	IPC_GET_RETVAL(*data), data);
433	free(call);	434	free(call);
434	return;	435	return;
435	}	436	}
436	}	437	}
437	futex_up(&ipc_futex);	438	futex_up(&ipc_futex);
438	}	439	}
439		440
440		441
441	/** Wait for a first call to come.	442	/** Wait for a first call to come.
442	*	443	*
443	* @param call Storage where the incoming call data will be stored.	444	* @param call Storage where the incoming call data will be stored.
444	* @param usec Timeout in microseconds	445	* @param usec Timeout in microseconds
445	* @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking).	446	* @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking).
446	*	447	*
447	* @return Hash of the call. Note that certain bits have special	448	* @return Hash of the call. Note that certain bits have special
448	* meaning. IPC_CALLID_ANSWERED will be set in an answer	449	* meaning. IPC_CALLID_ANSWERED will be set in an answer
449	* and IPC_CALLID_NOTIFICATION is used for notifications.	450	* and IPC_CALLID_NOTIFICATION is used for notifications.
450	*	451	*
451	*/	452	*/
452	ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags)	453	ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags)
453	{	454	{
454	ipc_callid_t callid;	455	ipc_callid_t callid;
455		456
456	callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);	457	callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
457	/* Handle received answers */	458	/* Handle received answers */
458	if (callid & IPC_CALLID_ANSWERED) {	459	if (callid & IPC_CALLID_ANSWERED) {
459	handle_answer(callid, call);	460	handle_answer(callid, call);
460	try_dispatch_queued_calls();	461	try_dispatch_queued_calls();
461	}	462	}
462		463
463	return callid;	464	return callid;
464	}	465	}
465		466
466	/** Wait some time for an IPC call.	467	/** Wait some time for an IPC call.
467	*	468	*
468	* The call will return after an answer is received.	469	* The call will return after an answer is received.
469	*	470	*
470	* @param call Storage where the incoming call data will be stored.	471	* @param call Storage where the incoming call data will be stored.
471	* @param usec Timeout in microseconds.	472	* @param usec Timeout in microseconds.
472	*	473	*
473	* @return Hash of the answer.	474	* @return Hash of the answer.
474	*/	475	*/
475	ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec)	476	ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec)
476	{	477	{
477	ipc_callid_t callid;	478	ipc_callid_t callid;
478		479
479	do {	480	do {
480	callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);	481	callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);
481	} while (callid & IPC_CALLID_ANSWERED);	482	} while (callid & IPC_CALLID_ANSWERED);
482		483
483	return callid;	484	return callid;
484	}	485	}
485		486
486	/** Check if there is an IPC call waiting to be picked up.	487	/** Check if there is an IPC call waiting to be picked up.
487	*	488	*
488	* @param call Storage where the incoming call will be stored.	489	* @param call Storage where the incoming call will be stored.
489	* @return Hash of the answer.	490	* @return Hash of the answer.
490	*/	491	*/
491	ipc_callid_t ipc_trywait_for_call(ipc_call_t *call)	492	ipc_callid_t ipc_trywait_for_call(ipc_call_t *call)
492	{	493	{
493	ipc_callid_t callid;	494	ipc_callid_t callid;
494		495
495	do {	496	do {
496	callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT,	497	callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT,
497	SYNCH_FLAGS_NON_BLOCKING);	498	SYNCH_FLAGS_NON_BLOCKING);
498	} while (callid & IPC_CALLID_ANSWERED);	499	} while (callid & IPC_CALLID_ANSWERED);
499		500

Subversion Repositories HelenOS

(root)/trunk/uspace/lib/libc/generic/ipc.c – Rev 2490 → 2522