WebSVN – HelenOS – Diff – /branches/tracing/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 <adt/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 three payload arguments can be passed using this function. However, this
 * function is faster than the generic ipc_call_sync_slow() because the payload
 * is passed directly in registers.
 *
 * @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, the return ARG1 will be stored there.
 * @param result2   If non-NULL, the return ARG2 will be stored there.
 * @param result3   If non-NULL, the return ARG3 will be stored there.
 * @param result4   If non-NULL, the return ARG4 will be stored there.
 * @param result5   If non-NULL, the return ARG5 will be stored there.
 *
 * @return      Negative values represent errors returned by IPC.
 *          Otherwise the RETVAL of the answer is returned.
 */
int
ipc_call_sync_fast(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
    ipcarg_t arg3, ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3,
    ipcarg_t *result4, ipcarg_t *result5)
{
    ipc_call_t resdata;
    int callres;
   
    callres = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
        arg2, arg3, (sysarg_t) &resdata);
    if (callres)
        return callres;
    if (result1)
        *result1 = IPC_GET_ARG1(resdata);
    if (result2)
        *result2 = IPC_GET_ARG2(resdata);
    if (result3)
        *result3 = IPC_GET_ARG3(resdata);
    if (result4)
        *result4 = IPC_GET_ARG4(resdata);
    if (result5)
        *result5 = IPC_GET_ARG5(resdata);
 
    return IPC_GET_RETVAL(resdata);
}
 
/** Make a synchronous call transmitting 5 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 arg4      Service-defined payload argument.
 * @param arg5      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.
 * @param result4   If non-NULL, storage for the fourth return argument.
 * @param result5   If non-NULL, storage for the fifth return argument.
 *
 * @return      Negative value means IPC error.
 *          Otherwise the RETVAL of the answer.
 */
int
ipc_call_sync_slow(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
    ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t *result1,
    ipcarg_t *result2, ipcarg_t *result3, ipcarg_t *result4, ipcarg_t *result5)
{
    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);
    IPC_SET_ARG4(data, arg4);
    IPC_SET_ARG5(data, arg5);
 
    callres = __SYSCALL3(SYS_IPC_CALL_SYNC_SLOW, 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);
    if (result4)
        *result4 = IPC_GET_ARG4(data);
    if (result5)
        *result5 = IPC_GET_ARG5(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_SLOW, 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 fibril 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_callid_t) 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_callid_t) 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_switch(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 four arguments of payload. It is, however,
 * faster than the more generic ipc_call_async_slow().
 *
 * 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 arg4      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 fibril will be preempted in
 *          case the kernel temporarily refuses to accept more
 *          asynchronous calls.
 */
void ipc_call_async_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, 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 = __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1,
        arg2, arg3, arg4);
 
    if (callid == (ipc_callid_t) 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_SET_ARG3(call->u.msg.data, arg3);
        IPC_SET_ARG4(call->u.msg.data, arg4);
        /*
         * To achieve deterministic behavior, we always zero out the
         * arguments that are beyond the limits of the fast version.
         */
        IPC_SET_ARG5(call->u.msg.data, 0);
    }
    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 arg4      Service-defined payload argument.
 * @param arg5      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 fibril will be preempted in
 *          case the kernel temporarily refuses to accept more
 *          asynchronous calls.
 *
 */
void ipc_call_async_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, 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);
    IPC_SET_ARG4(call->u.msg.data, arg4);
    IPC_SET_ARG5(call->u.msg.data, arg5);
    /*
     * 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 four arguments in
 * registers. If you need to return more, use the ipc_answer_slow() instead.
 *
 * @param callid    Hash of the call being answered.
 * @param retval    Return value.
 * @param arg1      First return argument.
 * @param arg2      Second return argument.
 * @param arg3      Third return argument.
 * @param arg4      Fourth 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, ipcarg_t arg3, ipcarg_t arg4)
{
    return __SYSCALL6(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2, arg3,
        arg4);
}
 
/** Answer a received call - slow full version.
 *
 * @param callid    Hash of the call being answered.
 * @param retval    Return value.
 * @param arg1      First return argument.
 * @param arg2      Second return argument.
 * @param arg3      Third return argument.
 * @param arg4      Fourth return argument.
 * @param arg5      Fifth return argument.
 *
 * @return      Zero on success or a value from @ref errno.h on failure.
 */
ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5)
{
    ipc_call_t data;
 
    IPC_SET_RETVAL(data, retval);
    IPC_SET_ARG1(data, arg1);
    IPC_SET_ARG2(data, arg2);
    IPC_SET_ARG3(data, arg3);
    IPC_SET_ARG4(data, arg4);
    IPC_SET_ARG5(data, arg5);
 
    return __SYSCALL2(SYS_IPC_ANSWER_SLOW, callid, (sysarg_t) &data);
}
 
 
/** 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_callid_t) IPC_CALLRET_TEMPORARY) {
            break;
        }
        list_remove(&call->list);
 
        futex_up(&async_futex);
        if (call->fid)
            fibril_add_ready(call->fid);
       
        if (callid == (ipc_callid_t) 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 arg3      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, int arg3,
    ipcarg_t *phonehash)
{
    return ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_TO_ME, arg1, arg2,
        arg3, NULL, NULL, NULL, NULL, 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.
 * @param arg3      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, int arg3)
{
    ipcarg_t newphid;
    int res;
 
    res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
        NULL, NULL, NULL, NULL, &newphid);
    if (res)
        return res;
    return newphid;
}
 
/** Ask through phone for a new connection to some service.
 *
 * If the connection is not available at the moment, the
 * call will block.
 *
 * @param phoneid   Phone handle used for contacting the other side.
 * @param arg1      User defined argument.
 * @param arg2      User defined argument.
 * @param arg3      User defined argument.
 *
 * @return      New phone handle on success or a negative error code.
 */
int ipc_connect_me_to_blocking(int phoneid, int arg1, int arg2, int arg3)
{
    ipcarg_t newphid;
    int res;
 
    res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
        IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &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.
 * @param arg2      New value of the second argument for the forwarded call.
 * @param mode      Flags specifying mode of the forward operation.
 *
 * @return      Zero on success or an error code.
 *
 * For non-system methods, the old method, arg1 and arg2 are rewritten by the
 * new values. For system methods, the new method, arg1 and arg2 are written
 * to the old arg1, arg2 and arg3, respectivelly. Calls with immutable
 * methods are forwarded verbatim.
 */
int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method,
    ipcarg_t arg1, ipcarg_t arg2, int mode)
{
    return __SYSCALL6(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1,
        arg2, mode);
}
 
 
int ipc_forward_slow(ipc_callid_t callid, int phoneid, int method,
    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
    int mode)
{
    ipc_call_t data;
 
    IPC_SET_METHOD(data, method);
    IPC_SET_ARG1(data, arg1);
    IPC_SET_ARG2(data, arg2);
    IPC_SET_ARG3(data, arg3);
    IPC_SET_ARG4(data, arg4);
    IPC_SET_ARG5(data, arg5);
 
    return __SYSCALL4(SYS_IPC_FORWARD_SLOW, callid, phoneid, (sysarg_t) &data, mode);
}
 
/** Wrapper for making IPC_M_SHARE_IN calls.
 *
 * @param phoneid   Phone that will be used to contact the receiving side.
 * @param dst       Destination address space area base.
 * @param size      Size of the destination address space area.
 * @param arg       User defined argument.
 * @param flags     Storage where the received flags will be stored. Can be
 *          NULL.
 *
 * @return      Zero on success or a negative error code from errno.h.
 */
int ipc_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
    int *flags)
{
    int res;
    sysarg_t tmp_flags;
    res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
        (ipcarg_t) size, arg, NULL, &tmp_flags);
    if (flags)
        *flags = tmp_flags;
    return res;
}
 
/** Wrapper for receiving the IPC_M_SHARE_IN calls.
 *
 * This wrapper only makes it more comfortable to receive IPC_M_SHARE_IN 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_SHARE_IN call will
 *          be stored.
 * @param size      Destination address space area size.   
 *
 * @return      Non-zero on success, zero on failure.
 */
int ipc_share_in_receive(ipc_callid_t *callid, size_t *size)
{
    ipc_call_t data;
   
    assert(callid);
    assert(size);
 
    *callid = async_get_call(&data);
    if (IPC_GET_METHOD(data) != IPC_M_SHARE_IN)
        return 0;
    *size = (size_t) IPC_GET_ARG2(data);
    return 1;
}
 
/** Wrapper for answering the IPC_M_SHARE_IN calls.
 *
 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
 * so that the user doesn't have to remember the meaning of each IPC argument.
 *
 * @param callid    Hash of the IPC_M_DATA_READ call to answer.
 * @param src       Source address space base.
 * @param flags     Flags to be used for sharing. Bits can be only cleared.
 *
 * @return      Zero on success or a value from @ref errno.h on failure.
 */
int ipc_share_in_finalize(ipc_callid_t callid, void *src, int flags)
{
    return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) flags);
}
 
/** Wrapper for making IPC_M_SHARE_OUT calls.
 *
 * @param phoneid   Phone that will be used to contact the receiving side.
 * @param src       Source address space area base address.
 * @param flags     Flags to be used for sharing. Bits can be only cleared.
 *
 * @return      Zero on success or a negative error code from errno.h.
 */
int ipc_share_out_start(int phoneid, void *src, int flags)
{
    return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
        (ipcarg_t) flags);
}
 
/** Wrapper for receiving the IPC_M_SHARE_OUT calls.
 *
 * This wrapper only makes it more comfortable to receive IPC_M_SHARE_OUT 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_SHARE_OUT call will
 *          be stored.
 * @param size      Storage where the source address space area size will be
 *          stored.
 * @param flags     Storage where the sharing flags will be stored.
 *
 * @return      Non-zero on success, zero on failure.
 */
int ipc_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags)
{
    ipc_call_t data;
   
    assert(callid);
    assert(size);
    assert(flags);
 
    *callid = async_get_call(&data);
    if (IPC_GET_METHOD(data) != IPC_M_SHARE_OUT)
        return 0;
    *size = (size_t) IPC_GET_ARG2(data);
    *flags = (int) IPC_GET_ARG3(data);
    return 1;
}
 
/** Wrapper for answering the IPC_M_SHARE_OUT calls.
 *
 * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT calls
 * so that the user doesn't have to remember the meaning of each IPC argument.
 *
 * @param callid    Hash of the IPC_M_DATA_WRITE call to answer.
 * @param dst       Destination address space area base address.   
 *
 * @return      Zero on success or a value from @ref errno.h on failure.
 */
int ipc_share_out_finalize(ipc_callid_t callid, void *dst)
{
    return ipc_answer_1(callid, EOK, (ipcarg_t) dst);
}
 
 
/** Wrapper for making IPC_M_DATA_READ calls.
 *
 * @param phoneid   Phone that will be used to contact the receiving side.
 * @param dst       Address of the beginning of the destination buffer.
 * @param size      Size of the destination buffer.
 *
 * @return      Zero on success or a negative error code from errno.h.
 */
int ipc_data_read_start(int phoneid, void *dst, size_t size)
{
    return async_req_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
        (ipcarg_t) size);
}
 
/** Wrapper for receiving the IPC_M_DATA_READ calls.
 *
 * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ 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_READ call will
 *          be stored.
 * @param size      Storage where the maximum size will be stored. Can be
 *          NULL.
 *
 * @return      Non-zero on success, zero on failure.
 */
int ipc_data_read_receive(ipc_callid_t *callid, size_t *size)
{
    ipc_call_t data;
   
    assert(callid);
 
    *callid = async_get_call(&data);
    if (IPC_GET_METHOD(data) != IPC_M_DATA_READ)
        return 0;
    if (size)
        *size = (size_t) IPC_GET_ARG2(data);
    return 1;
}
 
/** Wrapper for answering the IPC_M_DATA_READ calls.
 *
 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
 * so that the user doesn't have to remember the meaning of each IPC argument.
 *
 * @param callid    Hash of the IPC_M_DATA_READ call to answer.
 * @param src       Source address for the IPC_M_DATA_READ call.
 * @param size      Size for the IPC_M_DATA_READ call. Can be smaller than
 *          the maximum size announced by the sender.
 *
 * @return      Zero on success or a value from @ref errno.h on failure.
 */
int ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
{
    return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) size);
}
 
/** Wrapper for making IPC_M_DATA_WRITE calls.
 *
 * @param phoneid   Phone that will be used to contact the receiving side.
 * @param src       Address of the beginning of the source buffer.
 * @param size      Size of the source buffer.
 *
 * @return      Zero on success or a negative error code from errno.h.
 */
int ipc_data_write_start(int phoneid, const void *src, size_t size)
{
    return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
        (ipcarg_t) size);
}
 
/** Wrapper for receiving the IPC_M_DATA_WRITE calls.
 *
 * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE 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_WRITE call will
 *          be stored.
 * @param size      Storage where the suggested size will be stored. May be
 *          NULL
 *
 * @return      Non-zero on success, zero on failure.
 */
int ipc_data_write_receive(ipc_callid_t *callid, size_t *size)
{
    ipc_call_t data;
   
    assert(callid);
 
    *callid = async_get_call(&data);
    if (IPC_GET_METHOD(data) != IPC_M_DATA_WRITE)
        return 0;
    if (size)
        *size = (size_t) IPC_GET_ARG2(data);
    return 1;
}
 
/** Wrapper for answering the IPC_M_DATA_WRITE calls.
 *
 * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE calls
 * so that the user doesn't have to remember the meaning of each IPC argument.
 *
 * @param callid    Hash of the IPC_M_DATA_WRITE call to answer.
 * @param dst       Final destination address for the IPC_M_DATA_WRITE call.
 * @param size      Final size for the IPC_M_DATA_WRITE call.
 *
 * @return      Zero on success or a value from @ref errno.h on failure.
 */
int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
{
    return ipc_answer_2(callid, EOK, (ipcarg_t) dst, (ipcarg_t) size);
}
 
#include <kernel/syscall/sysarg64.h>
/** Connect to a task specified by id.
 */
int ipc_connect_kbox(task_id_t id)
{
    sysarg64_t arg;
 
    arg.value = (unsigned long long) id;
 
    return __SYSCALL1(SYS_IPC_CONNECT_KBOX, (sysarg_t) &arg);
}
 
/** @}
 */
 

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

Subversion Repositories HelenOS

(root)/branches/tracing/uspace/lib/libc/generic/ipc.c – Rev 4377 → 4692