ipc.c

Go to the documentation of this file.

/*
 * Copyright (c) 2006 Ondrej Palkovsky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <ipc/ipc.h>
#include <libc.h>
#include <malloc.h>
#include <errno.h>
#include <adt/list.h>
#include <futex.h>
#include <fibril.h>

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;
} async_call_t;

LIST_INITIALIZE(dispatched_calls);

LIST_INITIALIZE(queued_calls);

static atomic_t ipc_futex = FUTEX_INITIALIZER;

int ipc_call_sync_fast(int phoneid, sysarg_t method, sysarg_t arg1,
    sysarg_t arg2, sysarg_t arg3, sysarg_t *result1, sysarg_t *result2,
    sysarg_t *result3, sysarg_t *result4, sysarg_t *result5)
{
        ipc_call_t resdata;
        int 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);
}

int ipc_call_sync_slow(int phoneid, sysarg_t imethod, sysarg_t arg1,
    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
    sysarg_t *result1, sysarg_t *result2, sysarg_t *result3, sysarg_t *result4,
    sysarg_t *result5)
{
        ipc_call_t data;
        
        IPC_SET_IMETHOD(data, imethod);
        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);
        
        int 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);
}

static ipc_callid_t ipc_call_async_internal(int phoneid, ipc_call_t *data)
{
        return __SYSCALL2(SYS_IPC_CALL_ASYNC_SLOW, phoneid, (sysarg_t) data);
}

static inline async_call_t *ipc_prepare_async(void *private,
    ipc_async_callback_t callback)
{
        async_call_t *call =
            (async_call_t *) malloc(sizeof(async_call_t));
        if (!call) {
                if (callback)
                        callback(private, ENOMEM, NULL);
                
                return NULL;
        }
        
        call->callback = callback;
        call->private = private;
        
        return call;
}

static inline void ipc_finish_async(ipc_callid_t callid, int phoneid,
    async_call_t *call, bool 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);
}

void ipc_call_async_fast(int phoneid, sysarg_t imethod, sysarg_t arg1,
    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, void *private,
    ipc_async_callback_t callback, bool can_preempt)
{
        async_call_t *call = NULL;
        
        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);
        ipc_callid_t callid = __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phoneid,
            imethod, 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_IMETHOD(call->u.msg.data, imethod);
                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);
}

void ipc_call_async_slow(int phoneid, sysarg_t imethod, sysarg_t arg1,
    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, void *private,
    ipc_async_callback_t callback, bool can_preempt)
{
        async_call_t *call = ipc_prepare_async(private, callback);
        if (!call)
                return;
        
        IPC_SET_IMETHOD(call->u.msg.data, imethod);
        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 threadaccesses the queue again.
         */
        
        futex_down(&ipc_futex);
        ipc_callid_t callid =
            ipc_call_async_internal(phoneid, &call->u.msg.data);
        
        ipc_finish_async(callid, phoneid, call, can_preempt);
}

sysarg_t ipc_answer_fast(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
{
        return __SYSCALL6(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2, arg3,
            arg4);
}

sysarg_t ipc_answer_slow(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_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);
}

static void dispatch_queued_calls(void)
{
        futex_down(&async_futex);
        
        while (!list_empty(&queued_calls)) {
                async_call_t *call =
                    list_get_instance(queued_calls.next, async_call_t, list);
                ipc_callid_t callid =
                    ipc_call_async_internal(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);
}

static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
{
        callid &= ~IPC_CALLID_ANSWERED;
        
        futex_down(&ipc_futex);
        
        link_t *item;
        for (item = dispatched_calls.next; item != &dispatched_calls;
            item = item->next) {
                async_call_t *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);
}

ipc_callid_t ipc_wait_cycle(ipc_call_t *call, sysarg_t usec,
    unsigned int flags)
{
        ipc_callid_t callid =
            __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
        
        /* Handle received answers */
        if (callid & IPC_CALLID_ANSWERED) {
                handle_answer(callid, call);
                dispatch_queued_calls();
        }
        
        return callid;
}

void ipc_poke(void)
{
        __SYSCALL0(SYS_IPC_POKE);
}

ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, sysarg_t usec)
{
        ipc_callid_t callid;
        
        do {
                callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);
        } while (callid & IPC_CALLID_ANSWERED);
        
        return callid;
}

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;
}

int ipc_connect_to_me(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
    sysarg_t *taskhash, sysarg_t *phonehash)
{
        return ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_TO_ME, arg1, arg2,
            arg3, NULL, NULL, NULL, taskhash, phonehash);
}

int ipc_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
{
        sysarg_t newphid;
        int 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;
}

int ipc_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,
    sysarg_t arg3)
{
        sysarg_t newphid;
        int 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;
}

int ipc_hangup(int phoneid)
{
        return __SYSCALL1(SYS_IPC_HANGUP, phoneid);
}

int ipc_forward_fast(ipc_callid_t callid, int phoneid, sysarg_t imethod,
    sysarg_t arg1, sysarg_t arg2, unsigned int mode)
{
        return __SYSCALL6(SYS_IPC_FORWARD_FAST, callid, phoneid, imethod, arg1,
            arg2, mode);
}

int ipc_forward_slow(ipc_callid_t callid, int phoneid, sysarg_t imethod,
    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
    unsigned int mode)
{
        ipc_call_t data;
        
        IPC_SET_IMETHOD(data, imethod);
        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);
}

int ipc_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg,
    unsigned int *flags)
{
        sysarg_t tmp_flags = 0;
        int res = ipc_call_sync_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst,
            (sysarg_t) size, arg, NULL, &tmp_flags);
        
        if (flags)
                *flags = (unsigned int) tmp_flags;
        
        return res;
}

int ipc_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
{
        return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) flags);
}

int ipc_share_out_start(int phoneid, void *src, unsigned int flags)
{
        return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0,
            (sysarg_t) flags);
}

int ipc_share_out_finalize(ipc_callid_t callid, void *dst)
{
        return ipc_answer_1(callid, EOK, (sysarg_t) dst);
}

int ipc_data_read_start(int phoneid, void *dst, size_t size)
{
        return ipc_call_sync_2_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
            (sysarg_t) size);
}

int ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
{
        return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) size);
}

int ipc_data_write_start(int phoneid, const void *src, size_t size)
{
        return ipc_call_sync_2_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src,
            (sysarg_t) size);
}

int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
{
        return ipc_answer_2(callid, EOK, (sysarg_t) dst, (sysarg_t) size);
}

int ipc_connect_kbox(task_id_t id)
{
#ifdef __32_BITS__
        sysarg64_t arg = (sysarg64_t) id;
        return __SYSCALL1(SYS_IPC_CONNECT_KBOX, (sysarg_t) &arg);
#endif
        
#ifdef __64_BITS__
        return __SYSCALL1(SYS_IPC_CONNECT_KBOX, (sysarg_t) id);
#endif
}

---