WebSVN – HelenOS – Diff – /branches/tracing/kernel/generic/src/ipc/sysipc.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 genericipc
 * @{
 */
/** @file
 */
 
#include <arch.h>
#include <proc/task.h>
#include <proc/thread.h>
#include <errno.h>
#include <memstr.h>
#include <debug.h>
#include <ipc/ipc.h>
#include <ipc/sysipc.h>
#include <ipc/irq.h>
#include <ipc/ipcrsc.h>
#include <ipc/kbox.h>
#include <udebug/udebug_ipc.h>
#include <arch/interrupt.h>
#include <syscall/copy.h>
#include <security/cap.h>
#include <mm/as.h>
#include <print.h>
 
/**
 * Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ
 * requests.
 */
#define DATA_XFER_LIMIT     (64 * 1024)
 
#define GET_CHECK_PHONE(phone, phoneid, err) \
{ \
    if (phoneid > IPC_MAX_PHONES) { \
        err; \
    } \
    phone = &TASK->phones[phoneid]; \
}
 
#define STRUCT_TO_USPACE(dst, src)  copy_to_uspace(dst, src, sizeof(*(src)))
 
/** Decide if the method is a system method.
 *
 * @param method    Method to be decided.
 *
 * @return      Return 1 if the method is a system method.
 *          Otherwise return 0.
 */
static inline int method_is_system(unative_t method)
{
    if (method <= IPC_M_LAST_SYSTEM)
        return 1;
    return 0;
}
 
/** Decide if the message with this method is forwardable.
 *
 * - some system messages may be forwarded, for some of them
 *   it is useless
 *
 * @param method    Method to be decided.
 *
 * @return      Return 1 if the method is forwardable.
 *          Otherwise return 0.
 */
static inline int method_is_forwardable(unative_t method)
{
    switch (method) {
    case IPC_M_CONNECTION_CLONE:
    case IPC_M_CONNECT_ME:
    case IPC_M_PHONE_HUNGUP:
        /* This message is meant only for the original recipient. */
        return 0;
    default:
        return 1;
    }
}
 
/** Decide if the message with this method is immutable on forward.
 *
 * - some system messages may be forwarded but their content cannot be altered
 *
 * @param method    Method to be decided.
 *
 * @return      Return 1 if the method is immutable on forward.
 *          Otherwise return 0.
 */
static inline int method_is_immutable(unative_t method)
{
    switch (method) {
    case IPC_M_SHARE_OUT:
    case IPC_M_SHARE_IN:
    case IPC_M_DATA_WRITE:
    case IPC_M_DATA_READ:
        return 1;
        break;
    default:
        return 0;
    }
}
 
 
/***********************************************************************
 * Functions that preprocess answer before sending it to the recepient.
 ***********************************************************************/
 
/** Decide if the caller (e.g. ipc_answer()) should save the old call contents
 * for answer_preprocess().
 *
 * @param call      Call structure to be decided.
 *
 * @return      Return 1 if the old call contents should be saved.
 *          Return 0 otherwise.
 */
static inline int answer_need_old(call_t *call)
{
    switch (IPC_GET_METHOD(call->data)) {
    case IPC_M_CONNECTION_CLONE:
    case IPC_M_CONNECT_ME:
    case IPC_M_CONNECT_TO_ME:
    case IPC_M_CONNECT_ME_TO:
    case IPC_M_SHARE_OUT:
    case IPC_M_SHARE_IN:
    case IPC_M_DATA_WRITE:
    case IPC_M_DATA_READ:
        return 1;
    default:
        return 0;
    }
}
 
/** Interpret process answer as control information.
 *
 * This function is called directly after sys_ipc_answer().
 *
 * @param answer    Call structure with the answer.
 * @param olddata   Saved data of the request.
 *
 * @return      Return 0 on success or an error code.
 */
static inline int answer_preprocess(call_t *answer, ipc_data_t *olddata)
{
    int phoneid;
 
    if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
        /* In case of forward, hangup the forwared phone,
         * not the originator
         */
        mutex_lock(&answer->data.phone->lock);
        spinlock_lock(&TASK->answerbox.lock);
        if (answer->data.phone->state == IPC_PHONE_CONNECTED) {
            list_remove(&answer->data.phone->link);
            answer->data.phone->state = IPC_PHONE_SLAMMED;
        }
        spinlock_unlock(&TASK->answerbox.lock);
        mutex_unlock(&answer->data.phone->lock);
    }
 
    if (!olddata)
        return 0;
 
    if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECTION_CLONE) {
        phoneid = IPC_GET_ARG1(*olddata);
        phone_t *phone = &TASK->phones[phoneid];
        if (IPC_GET_RETVAL(answer->data) != EOK) {
            /*
             * The recipient of the cloned phone rejected the offer.
             * In this case, the connection was established at the
             * request time and therefore we need to slam the phone.
             * We don't merely hangup as that would result in
             * sending IPC_M_HUNGUP to the third party on the
             * other side of the cloned phone.
             */
            mutex_lock(&phone->lock);
            if (phone->state == IPC_PHONE_CONNECTED) {
                spinlock_lock(&phone->callee->lock);
                list_remove(&phone->link);
                phone->state = IPC_PHONE_SLAMMED;
                spinlock_unlock(&phone->callee->lock);
            }
            mutex_unlock(&phone->lock);
        }
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME) {
        phone_t *phone = (phone_t *)IPC_GET_ARG5(*olddata);
        if (IPC_GET_RETVAL(answer->data) != EOK) {
            /*
             * The other party on the cloned phoned rejected our
             * request for connection on the protocol level.
             * We need to break the connection without sending
             * IPC_M_HUNGUP back.
             */
            mutex_lock(&phone->lock);
            if (phone->state == IPC_PHONE_CONNECTED) {
                spinlock_lock(&phone->callee->lock);
                list_remove(&phone->link);
                phone->state = IPC_PHONE_SLAMMED;
                spinlock_unlock(&phone->callee->lock);
            }
            mutex_unlock(&phone->lock);
        }
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
        phoneid = IPC_GET_ARG5(*olddata);
        if (IPC_GET_RETVAL(answer->data) != EOK) {
            /* The connection was not accepted */
            phone_dealloc(phoneid);
        } else {
            /* The connection was accepted */
            phone_connect(phoneid, &answer->sender->answerbox);
            /* Set 'phone hash' as arg5 of response */
            IPC_SET_ARG5(answer->data,
                (unative_t) &TASK->phones[phoneid]);
        }
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
        /* If the users accepted call, connect */
        if (IPC_GET_RETVAL(answer->data) == EOK) {
            ipc_phone_connect((phone_t *) IPC_GET_ARG5(*olddata),
                &TASK->answerbox);
        }
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_OUT) {
        if (!IPC_GET_RETVAL(answer->data)) {
            /* Accepted, handle as_area receipt */
            ipl_t ipl;
            int rc;
            as_t *as;
           
            ipl = interrupts_disable();
            spinlock_lock(&answer->sender->lock);
            as = answer->sender->as;
            spinlock_unlock(&answer->sender->lock);
            interrupts_restore(ipl);
           
            rc = as_area_share(as, IPC_GET_ARG1(*olddata),
                IPC_GET_ARG2(*olddata), AS,
                IPC_GET_ARG1(answer->data), IPC_GET_ARG3(*olddata));
            IPC_SET_RETVAL(answer->data, rc);
            return rc;
        }
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_IN) {
        if (!IPC_GET_RETVAL(answer->data)) {
            ipl_t ipl;
            as_t *as;
            int rc;
           
            ipl = interrupts_disable();
            spinlock_lock(&answer->sender->lock);
            as = answer->sender->as;
            spinlock_unlock(&answer->sender->lock);
            interrupts_restore(ipl);
           
            rc = as_area_share(AS, IPC_GET_ARG1(answer->data),
                IPC_GET_ARG2(*olddata), as, IPC_GET_ARG1(*olddata),
                IPC_GET_ARG2(answer->data));
            IPC_SET_RETVAL(answer->data, rc);
        }
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_READ) {
        ASSERT(!answer->buffer);
        if (!IPC_GET_RETVAL(answer->data)) {
            /* The recipient agreed to send data. */
            uintptr_t src = IPC_GET_ARG1(answer->data);
            uintptr_t dst = IPC_GET_ARG1(*olddata);
            size_t max_size = IPC_GET_ARG2(*olddata);
            size_t size = IPC_GET_ARG2(answer->data);
            if (size && size <= max_size) {
                /*
                 * Copy the destination VA so that this piece of
                 * information is not lost.
                 */
                IPC_SET_ARG1(answer->data, dst);
 
                answer->buffer = malloc(size, 0);
                int rc = copy_from_uspace(answer->buffer,
                    (void *) src, size);
                if (rc) {
                    IPC_SET_RETVAL(answer->data, rc);
                    free(answer->buffer);
                    answer->buffer = NULL;
                }
            } else if (!size) {
                IPC_SET_RETVAL(answer->data, EOK);
            } else {
                IPC_SET_RETVAL(answer->data, ELIMIT);
            }
        }
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_WRITE) {
        ASSERT(answer->buffer);
        if (!IPC_GET_RETVAL(answer->data)) {
            /* The recipient agreed to receive data. */
            int rc;
            uintptr_t dst;
            size_t size;
            size_t max_size;
 
            dst = (uintptr_t)IPC_GET_ARG1(answer->data);
            size = (size_t)IPC_GET_ARG2(answer->data);
            max_size = (size_t)IPC_GET_ARG2(*olddata);
 
            if (size <= max_size) {
                rc = copy_to_uspace((void *) dst,
                    answer->buffer, size);
                if (rc)
                    IPC_SET_RETVAL(answer->data, rc);
            } else {
                IPC_SET_RETVAL(answer->data, ELIMIT);
            }
        }
        free(answer->buffer);
        answer->buffer = NULL;
    }
    return 0;
}
 
static void phones_lock(phone_t *p1, phone_t *p2)
{
    if (p1 < p2) {
        mutex_lock(&p1->lock);
        mutex_lock(&p2->lock);
    } else if (p1 > p2) {
        mutex_lock(&p2->lock);
        mutex_lock(&p1->lock);
    } else {
        mutex_lock(&p1->lock);
    }
}
 
static void phones_unlock(phone_t *p1, phone_t *p2)
{
    mutex_unlock(&p1->lock);
    if (p1 != p2)
        mutex_unlock(&p2->lock);
}
 
/** Called before the request is sent.
 *
 * @param call      Call structure with the request.
 * @param phone     Phone that the call will be sent through.
 *
 * @return      Return 0 on success, ELIMIT or EPERM on error.
 */
static int request_preprocess(call_t *call, phone_t *phone)
{
    int newphid;
    size_t size;
    uintptr_t src;
    int rc;
 
    switch (IPC_GET_METHOD(call->data)) {
    case IPC_M_CONNECTION_CLONE: {
        phone_t *cloned_phone;
        GET_CHECK_PHONE(cloned_phone, IPC_GET_ARG1(call->data),
            return ENOENT);
        phones_lock(cloned_phone, phone);
        if ((cloned_phone->state != IPC_PHONE_CONNECTED) ||
            phone->state != IPC_PHONE_CONNECTED) {
            phones_unlock(cloned_phone, phone);
            return EINVAL;
        }
        /*
         * We can be pretty sure now that both tasks exist and we are
         * connected to them. As we continue to hold the phone locks,
         * we are effectively preventing them from finishing their
         * potential cleanup.
         */
        newphid = phone_alloc(phone->callee->task);
        if (newphid < 0) {
            phones_unlock(cloned_phone, phone);
            return ELIMIT;
        }
        ipc_phone_connect(&phone->callee->task->phones[newphid],
            cloned_phone->callee);
        phones_unlock(cloned_phone, phone);
        /* Set the new phone for the callee. */
        IPC_SET_ARG1(call->data, newphid);
        break;
    }
    case IPC_M_CONNECT_ME:
        IPC_SET_ARG5(call->data, (unative_t) phone);
        break;
    case IPC_M_CONNECT_ME_TO:
        newphid = phone_alloc(TASK);
        if (newphid < 0)
            return ELIMIT;
        /* Set arg5 for server */
        IPC_SET_ARG5(call->data, (unative_t) &TASK->phones[newphid]);
        call->flags |= IPC_CALL_CONN_ME_TO;
        call->priv = newphid;
        break;
    case IPC_M_SHARE_OUT:
        size = as_area_get_size(IPC_GET_ARG1(call->data));
        if (!size)
            return EPERM;
        IPC_SET_ARG2(call->data, size);
        break;
    case IPC_M_DATA_READ:
        size = IPC_GET_ARG2(call->data);
        if ((size <= 0 || (size > DATA_XFER_LIMIT)))
            return ELIMIT;
        break;
    case IPC_M_DATA_WRITE:
        src = IPC_GET_ARG1(call->data);
        size = IPC_GET_ARG2(call->data);
       
        if (size > DATA_XFER_LIMIT)
            return ELIMIT;
       
        call->buffer = (uint8_t *) malloc(size, 0);
        rc = copy_from_uspace(call->buffer, (void *) src, size);
        if (rc != 0) {
            free(call->buffer);
            return rc;
        }
        break;
#ifdef CONFIG_UDEBUG
    case IPC_M_DEBUG_ALL:
        return udebug_request_preprocess(call, phone);
#endif
    default:
        break;
    }
    return 0;
}
 
/*******************************************************************************
 * Functions called to process received call/answer before passing it to uspace.
 *******************************************************************************/
 
/** Do basic kernel processing of received call answer.
 *
 * @param call      Call structure with the answer.
 */
static void process_answer(call_t *call)
{
    if (((native_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&
        (call->flags & IPC_CALL_FORWARDED))
        IPC_SET_RETVAL(call->data, EFORWARD);
 
    if (call->flags & IPC_CALL_CONN_ME_TO) {
        if (IPC_GET_RETVAL(call->data))
            phone_dealloc(call->priv);
        else
            IPC_SET_ARG5(call->data, call->priv);
    }
 
    if (call->buffer) {
        /* This must be an affirmative answer to IPC_M_DATA_READ. */
        /* or IPC_M_DEBUG_ALL/UDEBUG_M_MEM_READ... */
        uintptr_t dst = IPC_GET_ARG1(call->data);
        size_t size = IPC_GET_ARG2(call->data);
        int rc = copy_to_uspace((void *) dst, call->buffer, size);
        if (rc)
            IPC_SET_RETVAL(call->data, rc);
        free(call->buffer);
        call->buffer = NULL;
    }
}
 
/** Do basic kernel processing of received call request.
 *
 * @param box       Destination answerbox structure.
 * @param call      Call structure with the request.
 *
 * @return      Return 0 if the call should be passed to userspace.
 *          Return -1 if the call should be ignored.
 */
static int process_request(answerbox_t *box, call_t *call)
{
    int phoneid;
 
    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {
        phoneid = phone_alloc(TASK);
        if (phoneid < 0) { /* Failed to allocate phone */
            IPC_SET_RETVAL(call->data, ELIMIT);
            ipc_answer(box, call);
            return -1;
        }
        IPC_SET_ARG5(call->data, phoneid);
    }
    switch (IPC_GET_METHOD(call->data)) {
    case IPC_M_DEBUG_ALL:
        return -1;
    default:
        break;
    }
    return 0;
}
 
/** Make a fast call over IPC, wait for reply and return to user.
 *
 * This function can handle only three arguments of payload, but is faster than
 * the generic function (i.e. sys_ipc_call_sync_slow()).
 *
 * @param phoneid   Phone handle for the call.
 * @param method    Method of the call.
 * @param arg1      Service-defined payload argument.
 * @param arg2      Service-defined payload argument.
 * @param arg3      Service-defined payload argument.
 * @param data      Address of userspace structure where the reply call will
 *          be stored.
 *
 * @return      Returns 0 on success.
 *          Return ENOENT if there is no such phone handle.
 */
unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
    unative_t arg1, unative_t arg2, unative_t arg3, ipc_data_t *data)
{
    call_t call;
    phone_t *phone;
    int res;
    int rc;
   
    GET_CHECK_PHONE(phone, phoneid, return ENOENT);
 
    ipc_call_static_init(&call);
    IPC_SET_METHOD(call.data, method);
    IPC_SET_ARG1(call.data, arg1);
    IPC_SET_ARG2(call.data, arg2);
    IPC_SET_ARG3(call.data, arg3);
    /*
     * To achieve deterministic behavior, zero out arguments that are beyond
     * the limits of the fast version.
     */
    IPC_SET_ARG4(call.data, 0);
    IPC_SET_ARG5(call.data, 0);
 
    if (!(res = request_preprocess(&call, phone))) {
#ifdef CONFIG_UDEBUG
        udebug_stoppable_begin();
#endif
        rc = ipc_call_sync(phone, &call);
#ifdef CONFIG_UDEBUG
        udebug_stoppable_end();
#endif
        if (rc != EOK)
            return rc;
        process_answer(&call);
 
    } else {
        IPC_SET_RETVAL(call.data, res);
    }
    rc = STRUCT_TO_USPACE(&data->args, &call.data.args);
    if (rc != 0)
        return rc;
 
    return 0;
}
 
/** Make a synchronous IPC call allowing to transmit the entire payload.
 *
 * @param phoneid   Phone handle for the call.
 * @param question  Userspace address of call data with the request.
 * @param reply     Userspace address of call data where to store the
 *          answer.
 *
 * @return      Zero on success or an error code.
 */
unative_t sys_ipc_call_sync_slow(unative_t phoneid, ipc_data_t *question,
    ipc_data_t *reply)
{
    call_t call;
    phone_t *phone;
    int res;
    int rc;
 
    ipc_call_static_init(&call);
    rc = copy_from_uspace(&call.data.args, &question->args,
        sizeof(call.data.args));
    if (rc != 0)
        return (unative_t) rc;
 
    GET_CHECK_PHONE(phone, phoneid, return ENOENT);
 
    if (!(res = request_preprocess(&call, phone))) {
#ifdef CONFIG_UDEBUG
        udebug_stoppable_begin();
#endif
        rc = ipc_call_sync(phone, &call);
#ifdef CONFIG_UDEBUG
        udebug_stoppable_end();
#endif
        if (rc != EOK)
            return rc;
        process_answer(&call);
    } else
        IPC_SET_RETVAL(call.data, res);
 
    rc = STRUCT_TO_USPACE(&reply->args, &call.data.args);
    if (rc != 0)
        return rc;
 
    return 0;
}
 
/** Check that the task did not exceed the allowed limit of asynchronous calls.
 *
 * @return      Return 0 if limit not reached or -1 if limit exceeded.
 */
static int check_call_limit(void)
{
    if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
        atomic_dec(&TASK->active_calls);
        return -1;
    }
    return 0;
}
 
/** Make a fast asynchronous call over IPC.
 *
 * This function can only handle four arguments of payload, but is faster than
 * the generic function sys_ipc_call_async_slow().
 *
 * @param phoneid   Phone handle for the call.
 * @param method    Method of the call.
 * @param arg1      Service-defined payload argument.
 * @param arg2      Service-defined payload argument.
 * @param arg3      Service-defined payload argument.
 * @param arg4      Service-defined payload argument.
 *
 * @return      Return call hash on success.
 *          Return IPC_CALLRET_FATAL in case of a fatal error and
 *          IPC_CALLRET_TEMPORARY if there are too many pending
 *          asynchronous requests; answers should be handled first.
 */
unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
    unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
{
    call_t *call;
    phone_t *phone;
    int res;
 
    if (check_call_limit())
        return IPC_CALLRET_TEMPORARY;
 
    GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
 
    call = ipc_call_alloc(0);
    IPC_SET_METHOD(call->data, method);
    IPC_SET_ARG1(call->data, arg1);
    IPC_SET_ARG2(call->data, arg2);
    IPC_SET_ARG3(call->data, arg3);
    IPC_SET_ARG4(call->data, arg4);
    /*
     * To achieve deterministic behavior, zero out arguments that are beyond
     * the limits of the fast version.
     */
    IPC_SET_ARG5(call->data, 0);
 
    if (!(res = request_preprocess(call, phone)))
        ipc_call(phone, call);
    else
        ipc_backsend_err(phone, call, res);
 
    return (unative_t) call;
}
 
/** Make an asynchronous IPC call allowing to transmit the entire payload.
 *
 * @param phoneid   Phone handle for the call.
 * @param data      Userspace address of call data with the request.
 *
 * @return      See sys_ipc_call_async_fast().
 */
unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data)
{
    call_t *call;
    phone_t *phone;
    int res;
    int rc;
 
    if (check_call_limit())
        return IPC_CALLRET_TEMPORARY;
 
    GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
 
    call = ipc_call_alloc(0);
    rc = copy_from_uspace(&call->data.args, &data->args,
        sizeof(call->data.args));
    if (rc != 0) {
        ipc_call_free(call);
        return (unative_t) rc;
    }
    if (!(res = request_preprocess(call, phone)))
        ipc_call(phone, call);
    else
        ipc_backsend_err(phone, call, res);
 
    return (unative_t) call;
}
 
/** Forward a received call to another destination - common code for both the
 * fast and the slow version.
 *
 * @param callid    Hash of the call to forward.
 * @param phoneid   Phone handle to use for forwarding.
 * @param method    New method to use 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 arg3      New value of the third argument for the forwarded call.
 * @param arg4      New value of the fourth argument for the forwarded call.
 * @param arg5      New value of the fifth argument for the forwarded call.
 * @param mode      Flags that specify mode of the forward operation.
 * @param slow      If true, arg3, arg4 and arg5 are considered. Otherwise
 *          the function considers only the fast version arguments:
 *          i.e. arg1 and arg2.
 *
 * @return      Return 0 on succes, otherwise return an error code.
 *
 * Warning: Make sure that ARG5 is not rewritten for certain system IPC
 */
static unative_t sys_ipc_forward_common(unative_t callid, unative_t phoneid,
    unative_t method, unative_t arg1, unative_t arg2, unative_t arg3,
    unative_t arg4, unative_t arg5, int mode, bool slow)
{
    call_t *call;
    phone_t *phone;
 
    call = get_call(callid);
    if (!call)
        return ENOENT;
   
    call->flags |= IPC_CALL_FORWARDED;
 
    GET_CHECK_PHONE(phone, phoneid, {
        IPC_SET_RETVAL(call->data, EFORWARD);
        ipc_answer(&TASK->answerbox, call);
        return ENOENT;
    });
 
    if (!method_is_forwardable(IPC_GET_METHOD(call->data))) {
        IPC_SET_RETVAL(call->data, EFORWARD);
        ipc_answer(&TASK->answerbox, call);
        return EPERM;
    }
 
    /*
     * Userspace is not allowed to change method of system methods on
     * forward, allow changing ARG1, ARG2, ARG3 and ARG4 by means of method,
     * arg1, arg2 and arg3.
     * If the method is immutable, don't change anything.
     */
    if (!method_is_immutable(IPC_GET_METHOD(call->data))) {
        if (method_is_system(IPC_GET_METHOD(call->data))) {
            if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
                phone_dealloc(IPC_GET_ARG5(call->data));
 
            IPC_SET_ARG1(call->data, method);
            IPC_SET_ARG2(call->data, arg1);
            IPC_SET_ARG3(call->data, arg2);
            if (slow) {
                IPC_SET_ARG4(call->data, arg3);
                /*
                 * For system methods we deliberately don't
                 * overwrite ARG5.
                 */
            }
        } else {
            IPC_SET_METHOD(call->data, method);
            IPC_SET_ARG1(call->data, arg1);
            IPC_SET_ARG2(call->data, arg2);
            if (slow) {
                IPC_SET_ARG3(call->data, arg3);
                IPC_SET_ARG4(call->data, arg4);
                IPC_SET_ARG5(call->data, arg5);
            }
        }
    }
 
    return ipc_forward(call, phone, &TASK->answerbox, mode);
}
 
/** Forward a received call to another destination - fast version.
 *
 * @param callid    Hash of the call to forward.
 * @param phoneid   Phone handle to use for forwarding.
 * @param method    New method to use 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 that specify mode of the forward operation.
 *
 * @return      Return 0 on succes, otherwise return an error code.
 *
 * In case the original method is a system method, ARG1, ARG2 and ARG3 are
 * overwritten in the forwarded message with the new method and the new
 * arg1 and arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are
 * rewritten with the new method, arg1 and arg2, respectively. Also note there
 * is a set of immutable methods, for which the new method and arguments are not
 * set and these values are ignored.
 */
unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
    unative_t method, unative_t arg1, unative_t arg2, int mode)
{
    return sys_ipc_forward_common(callid, phoneid, method, arg1, arg2, 0, 0,
        0, mode, false);
}
 
/** Forward a received call to another destination - slow version.
 *
 * @param callid    Hash of the call to forward.
 * @param phoneid   Phone handle to use for forwarding.
 * @param data      Userspace address of the new IPC data.
 * @param mode      Flags that specify mode of the forward operation.
 *
 * @return      Return 0 on succes, otherwise return an error code.
 *
 * This function is the slow verision of the sys_ipc_forward_fast interface.
 * It can copy all five new arguments and the new method from the userspace.
 * It naturally extends the functionality of the fast version. For system
 * methods, it additionally stores the new value of arg3 to ARG4. For non-system
 * methods, it additionally stores the new value of arg3, arg4 and arg5,
 * respectively, to ARG3, ARG4 and ARG5, respectively.
 */
unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
    ipc_data_t *data, int mode)
{
    ipc_data_t newdata;
    int rc;
 
    rc = copy_from_uspace(&newdata.args, &data->args,
        sizeof(newdata.args));
    if (rc != 0)
        return (unative_t) rc;
 
    return sys_ipc_forward_common(callid, phoneid,
        IPC_GET_METHOD(newdata), IPC_GET_ARG1(newdata),
        IPC_GET_ARG2(newdata), IPC_GET_ARG3(newdata),
        IPC_GET_ARG4(newdata), IPC_GET_ARG5(newdata), mode, true);
}
 
/** Answer an IPC call - fast version.
 *
 * This function can handle only two return arguments of payload, but is faster
 * than the generic sys_ipc_answer().
 *
 * @param callid    Hash of the call to be answered.
 * @param retval    Return value of the answer.
 * @param arg1      Service-defined return value.
 * @param arg2      Service-defined return value.
 * @param arg3      Service-defined return value.
 * @param arg4      Service-defined return value.
 *
 * @return      Return 0 on success, otherwise return an error code.   
 */
unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
    unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
{
    call_t *call;
    ipc_data_t saved_data;
    int saveddata = 0;
    int rc;
 
    /* Do not answer notification callids */
    if (callid & IPC_CALLID_NOTIFICATION)
        return 0;
 
    call = get_call(callid);
    if (!call)
        return ENOENT;
 
    if (answer_need_old(call)) {
        memcpy(&saved_data, &call->data, sizeof(call->data));
        saveddata = 1;
    }
 
    IPC_SET_RETVAL(call->data, retval);
    IPC_SET_ARG1(call->data, arg1);
    IPC_SET_ARG2(call->data, arg2);
    IPC_SET_ARG3(call->data, arg3);
    IPC_SET_ARG4(call->data, arg4);
    /*
     * To achieve deterministic behavior, zero out arguments that are beyond
     * the limits of the fast version.
     */
    IPC_SET_ARG5(call->data, 0);
    rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
 
    ipc_answer(&TASK->answerbox, call);
    return rc;
}
 
/** Answer an IPC call.
 *
 * @param callid    Hash of the call to be answered.
 * @param data      Userspace address of call data with the answer.
 *
 * @return      Return 0 on success, otherwise return an error code.
 */
unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data)
{
    call_t *call;
    ipc_data_t saved_data;
    int saveddata = 0;
    int rc;
 
    /* Do not answer notification callids */
    if (callid & IPC_CALLID_NOTIFICATION)
        return 0;
 
    call = get_call(callid);
    if (!call)
        return ENOENT;
 
    if (answer_need_old(call)) {
        memcpy(&saved_data, &call->data, sizeof(call->data));
        saveddata = 1;
    }
    rc = copy_from_uspace(&call->data.args, &data->args,
        sizeof(call->data.args));
    if (rc != 0)
        return rc;
 
    rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
   
    ipc_answer(&TASK->answerbox, call);
 
    return rc;
}
 
/** Hang up a phone.
 *
 * @param       Phone handle of the phone to be hung up.
 *
 * @return      Return 0 on success or an error code.
 */
unative_t sys_ipc_hangup(int phoneid)
{
    phone_t *phone;
 
    GET_CHECK_PHONE(phone, phoneid, return ENOENT);
 
    if (ipc_phone_hangup(phone))
        return -1;
 
    return 0;
}
 
/** Wait for an incoming IPC call or an answer.
 *
 * @param calldata  Pointer to buffer where the call/answer data is stored.
 * @param usec      Timeout. See waitq_sleep_timeout() for explanation.
 * @param flags     Select mode of sleep operation. See waitq_sleep_timeout()
 *          for explanation.
 *
 * @return      Hash of the call.
 *          If IPC_CALLID_NOTIFICATION bit is set in the hash, the
 *          call is a notification. IPC_CALLID_ANSWERED denotes an
 *          answer.
 */
unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int flags)
{
    call_t *call;
 
restart:
 
#ifdef CONFIG_UDEBUG
    udebug_stoppable_begin();
#endif  
    call = ipc_wait_for_call(&TASK->answerbox, usec,
        flags | SYNCH_FLAGS_INTERRUPTIBLE);
 
#ifdef CONFIG_UDEBUG
    udebug_stoppable_end();
#endif
    if (!call)
        return 0;
 
    if (call->flags & IPC_CALL_NOTIF) {
        ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
 
        /* Set in_phone_hash to the interrupt counter */
        call->data.phone = (void *) call->priv;
       
        STRUCT_TO_USPACE(calldata, &call->data);
 
        ipc_call_free(call);
       
        return ((unative_t) call) | IPC_CALLID_NOTIFICATION;
    }
 
    if (call->flags & IPC_CALL_ANSWERED) {
        process_answer(call);
 
        ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
 
        if (call->flags & IPC_CALL_DISCARD_ANSWER) {
            ipc_call_free(call);
            goto restart;
        } else {
            /*
             * Decrement the counter of active calls only if the
             * call is not an answer to IPC_M_PHONE_HUNGUP,
             * which doesn't contribute to the counter.
             */
            atomic_dec(&TASK->active_calls);
        }
 
        STRUCT_TO_USPACE(&calldata->args, &call->data.args);
        ipc_call_free(call);
 
        return ((unative_t) call) | IPC_CALLID_ANSWERED;
    }
 
    if (process_request(&TASK->answerbox, call))
        goto restart;
 
    /* Include phone address('id') of the caller in the request,
     * copy whole call->data, not only call->data.args */
    if (STRUCT_TO_USPACE(calldata, &call->data)) {
        /*
         * The callee will not receive this call and no one else has
         * a chance to answer it. Reply with the EPARTY error code.
         */
        ipc_data_t saved_data;
        int saveddata = 0;
 
        if (answer_need_old(call)) {
            memcpy(&saved_data, &call->data, sizeof(call->data));
            saveddata = 1;
        }
       
        IPC_SET_RETVAL(call->data, EPARTY);
        (void) answer_preprocess(call, saveddata ? &saved_data : NULL);
        ipc_answer(&TASK->answerbox, call);
        return 0;
    }
    return (unative_t)call;
}
 
/** Connect an IRQ handler to a task.
 *
 * @param inr       IRQ number.
 * @param devno     Device number.
 * @param method    Method to be associated with the notification.
 * @param ucode     Uspace pointer to the top-half pseudocode.
 *
 * @return      EPERM or a return code returned by ipc_irq_register().
 */
unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
    irq_code_t *ucode)
{
    if (!(cap_get(TASK) & CAP_IRQ_REG))
        return EPERM;
 
    return ipc_irq_register(&TASK->answerbox, inr, devno, method, ucode);
}
 
/** Disconnect an IRQ handler from a task.
 *
 * @param inr       IRQ number.
 * @param devno     Device number.
 *
 * @return      Zero on success or EPERM on error..
 */
unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
{
    if (!(cap_get(TASK) & CAP_IRQ_REG))
        return EPERM;
 
    ipc_irq_unregister(&TASK->answerbox, inr, devno);
 
    return 0;
}
 
#include <console/console.h>
 
/**
 * Syscall connect to a task by id.
 *
 * @return      Phone id on success, or negative error code.
 */
unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
{
#ifdef CONFIG_UDEBUG
    sysarg64_t taskid_arg;
    int rc;
   
    rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
    if (rc != 0)
        return (unative_t) rc;
 
    LOG("sys_ipc_connect_kbox(%" PRIu64 ")\n", taskid_arg.value);
 
    return ipc_connect_kbox(taskid_arg.value);
#else
    return (unative_t) ENOTSUP;
#endif
}
 
/** @}
 */
 

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 genericipc	29	/** @addtogroup genericipc
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <arch.h>	35	#include <arch.h>
36	#include <proc/task.h>	36	#include <proc/task.h>
37	#include <proc/thread.h>	37	#include <proc/thread.h>
38	#include <errno.h>	38	#include <errno.h>
39	#include <memstr.h>	39	#include <memstr.h>
40	#include <debug.h>	40	#include <debug.h>
41	#include <ipc/ipc.h>	41	#include <ipc/ipc.h>
42	#include <ipc/sysipc.h>	42	#include <ipc/sysipc.h>
43	#include <ipc/irq.h>	43	#include <ipc/irq.h>
44	#include <ipc/ipcrsc.h>	44	#include <ipc/ipcrsc.h>
45	#include <ipc/kbox.h>	45	#include <ipc/kbox.h>
46	#include <udebug/udebug_ipc.h>	46	#include <udebug/udebug_ipc.h>
47	#include <arch/interrupt.h>	47	#include <arch/interrupt.h>
48	#include <syscall/copy.h>	48	#include <syscall/copy.h>
49	#include <security/cap.h>	49	#include <security/cap.h>
50	#include <mm/as.h>	50	#include <mm/as.h>
51	#include <print.h>	51	#include <print.h>
52		52
53	/**	53	/**
54	* Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ	54	* Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ
55	* requests.	55	* requests.
56	*/	56	*/
57	#define DATA_XFER_LIMIT (64 * 1024)	57	#define DATA_XFER_LIMIT (64 * 1024)
58		58
59	#define GET_CHECK_PHONE(phone, phoneid, err) \	59	#define GET_CHECK_PHONE(phone, phoneid, err) \
60	{ \	60	{ \
61	if (phoneid > IPC_MAX_PHONES) { \	61	if (phoneid > IPC_MAX_PHONES) { \
62	err; \	62	err; \
63	} \	63	} \
64	phone = &TASK->phones[phoneid]; \	64	phone = &TASK->phones[phoneid]; \
65	}	65	}
66		66
67	#define STRUCT_TO_USPACE(dst, src) copy_to_uspace(dst, src, sizeof(*(src)))	67	#define STRUCT_TO_USPACE(dst, src) copy_to_uspace(dst, src, sizeof(*(src)))
68		68
69	/** Decide if the method is a system method.	69	/** Decide if the method is a system method.
70	*	70	*
71	* @param method Method to be decided.	71	* @param method Method to be decided.
72	*	72	*
73	* @return Return 1 if the method is a system method.	73	* @return Return 1 if the method is a system method.
74	* Otherwise return 0.	74	* Otherwise return 0.
75	*/	75	*/
76	static inline int method_is_system(unative_t method)	76	static inline int method_is_system(unative_t method)
77	{	77	{
78	if (method <= IPC_M_LAST_SYSTEM)	78	if (method <= IPC_M_LAST_SYSTEM)
79	return 1;	79	return 1;
80	return 0;	80	return 0;
81	}	81	}
82		82
83	/** Decide if the message with this method is forwardable.	83	/** Decide if the message with this method is forwardable.
84	*	84	*
85	* - some system messages may be forwarded, for some of them	85	* - some system messages may be forwarded, for some of them
86	* it is useless	86	* it is useless
87	*	87	*
88	* @param method Method to be decided.	88	* @param method Method to be decided.
89	*	89	*
90	* @return Return 1 if the method is forwardable.	90	* @return Return 1 if the method is forwardable.
91	* Otherwise return 0.	91	* Otherwise return 0.
92	*/	92	*/
93	static inline int method_is_forwardable(unative_t method)	93	static inline int method_is_forwardable(unative_t method)
94	{	94	{
95	switch (method) {	95	switch (method) {
-		96	case IPC_M_CONNECTION_CLONE:
-		97	case IPC_M_CONNECT_ME:
96	case IPC_M_PHONE_HUNGUP:	98	case IPC_M_PHONE_HUNGUP:
97	/* This message is meant only for the original recipient. */	99	/* This message is meant only for the original recipient. */
98	return 0;	100	return 0;
99	default:	101	default:
100	return 1;	102	return 1;
101	}	103	}
102	}	104	}
103		105
104	/** Decide if the message with this method is immutable on forward.	106	/** Decide if the message with this method is immutable on forward.
105	*	107	*
106	* - some system messages may be forwarded but their content cannot be altered	108	* - some system messages may be forwarded but their content cannot be altered
107	*	109	*
108	* @param method Method to be decided.	110	* @param method Method to be decided.
109	*	111	*
110	* @return Return 1 if the method is immutable on forward.	112	* @return Return 1 if the method is immutable on forward.
111	* Otherwise return 0.	113	* Otherwise return 0.
112	*/	114	*/
113	static inline int method_is_immutable(unative_t method)	115	static inline int method_is_immutable(unative_t method)
114	{	116	{
115	switch (method) {	117	switch (method) {
116	case IPC_M_SHARE_OUT:	118	case IPC_M_SHARE_OUT:
117	case IPC_M_SHARE_IN:	119	case IPC_M_SHARE_IN:
118	case IPC_M_DATA_WRITE:	120	case IPC_M_DATA_WRITE:
119	case IPC_M_DATA_READ:	121	case IPC_M_DATA_READ:
120	return 1;	122	return 1;
121	break;	123	break;
122	default:	124	default:
123	return 0;	125	return 0;
124	}	126	}
125	}	127	}
126		128
127		129
128	/***********************************************************************	130	/***********************************************************************
129	* Functions that preprocess answer before sending it to the recepient.	131	* Functions that preprocess answer before sending it to the recepient.
130	***********************************************************************/	132	***********************************************************************/
131		133
132	/** Decide if the caller (e.g. ipc_answer()) should save the old call contents	134	/** Decide if the caller (e.g. ipc_answer()) should save the old call contents
133	* for answer_preprocess().	135	* for answer_preprocess().
134	*	136	*
135	* @param call Call structure to be decided.	137	* @param call Call structure to be decided.
136	*	138	*
137	* @return Return 1 if the old call contents should be saved.	139	* @return Return 1 if the old call contents should be saved.
138	* Return 0 otherwise.	140	* Return 0 otherwise.
139	*/	141	*/
140	static inline int answer_need_old(call_t *call)	142	static inline int answer_need_old(call_t *call)
141	{	143	{
142	switch (IPC_GET_METHOD(call->data)) {	144	switch (IPC_GET_METHOD(call->data)) {
-		145	case IPC_M_CONNECTION_CLONE:
-		146	case IPC_M_CONNECT_ME:
143	case IPC_M_CONNECT_TO_ME:	147	case IPC_M_CONNECT_TO_ME:
144	case IPC_M_CONNECT_ME_TO:	148	case IPC_M_CONNECT_ME_TO:
145	case IPC_M_SHARE_OUT:	149	case IPC_M_SHARE_OUT:
146	case IPC_M_SHARE_IN:	150	case IPC_M_SHARE_IN:
147	case IPC_M_DATA_WRITE:	151	case IPC_M_DATA_WRITE:
148	case IPC_M_DATA_READ:	152	case IPC_M_DATA_READ:
149	return 1;	153	return 1;
150	default:	154	default:
151	return 0;	155	return 0;
152	}	156	}
153	}	157	}
154		158
155	/** Interpret process answer as control information.	159	/** Interpret process answer as control information.
156	*	160	*
157	* This function is called directly after sys_ipc_answer().	161	* This function is called directly after sys_ipc_answer().
158	*	162	*
159	* @param answer Call structure with the answer.	163	* @param answer Call structure with the answer.
160	* @param olddata Saved data of the request.	164	* @param olddata Saved data of the request.
161	*	165	*
162	* @return Return 0 on success or an error code.	166	* @return Return 0 on success or an error code.
163	*/	167	*/
164	static inline int answer_preprocess(call_t answer, ipc_data_t olddata)	168	static inline int answer_preprocess(call_t answer, ipc_data_t olddata)
165	{	169	{
166	int phoneid;	170	int phoneid;
167		171
168	if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {	172	if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
169	/* In case of forward, hangup the forwared phone,	173	/* In case of forward, hangup the forwared phone,
170	* not the originator	174	* not the originator
171	*/	175	*/
172	mutex_lock(&answer->data.phone->lock);	176	mutex_lock(&answer->data.phone->lock);
173	spinlock_lock(&TASK->answerbox.lock);	177	spinlock_lock(&TASK->answerbox.lock);
174	if (answer->data.phone->state == IPC_PHONE_CONNECTED) {	178	if (answer->data.phone->state == IPC_PHONE_CONNECTED) {
175	list_remove(&answer->data.phone->link);	179	list_remove(&answer->data.phone->link);
176	answer->data.phone->state = IPC_PHONE_SLAMMED;	180	answer->data.phone->state = IPC_PHONE_SLAMMED;
177	}	181	}
178	spinlock_unlock(&TASK->answerbox.lock);	182	spinlock_unlock(&TASK->answerbox.lock);
179	mutex_unlock(&answer->data.phone->lock);	183	mutex_unlock(&answer->data.phone->lock);
180	}	184	}
181		185
182	if (!olddata)	186	if (!olddata)
183	return 0;	187	return 0;
184		188
-		189	if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECTION_CLONE) {
-		190	phoneid = IPC_GET_ARG1(*olddata);
-		191	phone_t *phone = &TASK->phones[phoneid];
-		192	if (IPC_GET_RETVAL(answer->data) != EOK) {
-		193	/*
-		194	* The recipient of the cloned phone rejected the offer.
-		195	* In this case, the connection was established at the
-		196	* request time and therefore we need to slam the phone.
-		197	* We don't merely hangup as that would result in
-		198	* sending IPC_M_HUNGUP to the third party on the
-		199	* other side of the cloned phone.
-		200	*/
-		201	mutex_lock(&phone->lock);
-		202	if (phone->state == IPC_PHONE_CONNECTED) {
-		203	spinlock_lock(&phone->callee->lock);
-		204	list_remove(&phone->link);
-		205	phone->state = IPC_PHONE_SLAMMED;
-		206	spinlock_unlock(&phone->callee->lock);
-		207	}
-		208	mutex_unlock(&phone->lock);
-		209	}
-		210	} else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME) {
-		211	phone_t phone = (phone_t )IPC_GET_ARG5(*olddata);
-		212	if (IPC_GET_RETVAL(answer->data) != EOK) {
-		213	/*
-		214	* The other party on the cloned phoned rejected our
-		215	* request for connection on the protocol level.
-		216	* We need to break the connection without sending
-		217	* IPC_M_HUNGUP back.
-		218	*/
-		219	mutex_lock(&phone->lock);
-		220	if (phone->state == IPC_PHONE_CONNECTED) {
-		221	spinlock_lock(&phone->callee->lock);
-		222	list_remove(&phone->link);
-		223	phone->state = IPC_PHONE_SLAMMED;
-		224	spinlock_unlock(&phone->callee->lock);
-		225	}
-		226	mutex_unlock(&phone->lock);
-		227	}
185	if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {	228	} else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
186	phoneid = IPC_GET_ARG5(*olddata);	229	phoneid = IPC_GET_ARG5(*olddata);
187	if (IPC_GET_RETVAL(answer->data)) {	230	if (IPC_GET_RETVAL(answer->data) != EOK) {
188	/* The connection was not accepted */	231	/* The connection was not accepted */
189	phone_dealloc(phoneid);	232	phone_dealloc(phoneid);
190	} else {	233	} else {
191	/* The connection was accepted */	234	/* The connection was accepted */
192	phone_connect(phoneid, &answer->sender->answerbox);	235	phone_connect(phoneid, &answer->sender->answerbox);
193	/* Set 'phone hash' as arg5 of response */	236	/* Set 'phone hash' as arg5 of response */
194	IPC_SET_ARG5(answer->data,	237	IPC_SET_ARG5(answer->data,
195	(unative_t) &TASK->phones[phoneid]);	238	(unative_t) &TASK->phones[phoneid]);
196	}	239	}
197	} else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {	240	} else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
198	/* If the users accepted call, connect */	241	/* If the users accepted call, connect */
199	if (!IPC_GET_RETVAL(answer->data)) {	242	if (IPC_GET_RETVAL(answer->data) == EOK) {
200	ipc_phone_connect((phone_t ) IPC_GET_ARG5(olddata),	243	ipc_phone_connect((phone_t ) IPC_GET_ARG5(olddata),
201	&TASK->answerbox);	244	&TASK->answerbox);
202	}	245	}
203	} else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_OUT) {	246	} else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_OUT) {
204	if (!IPC_GET_RETVAL(answer->data)) {	247	if (!IPC_GET_RETVAL(answer->data)) {
205	/* Accepted, handle as_area receipt */	248	/* Accepted, handle as_area receipt */
206	ipl_t ipl;	249	ipl_t ipl;
207	int rc;	250	int rc;
208	as_t *as;	251	as_t *as;
209		252
210	ipl = interrupts_disable();	253	ipl = interrupts_disable();
211	spinlock_lock(&answer->sender->lock);	254	spinlock_lock(&answer->sender->lock);
212	as = answer->sender->as;	255	as = answer->sender->as;
213	spinlock_unlock(&answer->sender->lock);	256	spinlock_unlock(&answer->sender->lock);
214	interrupts_restore(ipl);	257	interrupts_restore(ipl);
215		258
216	rc = as_area_share(as, IPC_GET_ARG1(*olddata),	259	rc = as_area_share(as, IPC_GET_ARG1(*olddata),
217	IPC_GET_ARG2(*olddata), AS,	260	IPC_GET_ARG2(*olddata), AS,
218	IPC_GET_ARG1(answer->data), IPC_GET_ARG3(*olddata));	261	IPC_GET_ARG1(answer->data), IPC_GET_ARG3(*olddata));
219	IPC_SET_RETVAL(answer->data, rc);	262	IPC_SET_RETVAL(answer->data, rc);
220	return rc;	263	return rc;
221	}	264	}
222	} else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_IN) {	265	} else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_IN) {
223	if (!IPC_GET_RETVAL(answer->data)) {	266	if (!IPC_GET_RETVAL(answer->data)) {
224	ipl_t ipl;	267	ipl_t ipl;
225	as_t *as;	268	as_t *as;
226	int rc;	269	int rc;
227		270
228	ipl = interrupts_disable();	271	ipl = interrupts_disable();
229	spinlock_lock(&answer->sender->lock);	272	spinlock_lock(&answer->sender->lock);
230	as = answer->sender->as;	273	as = answer->sender->as;
231	spinlock_unlock(&answer->sender->lock);	274	spinlock_unlock(&answer->sender->lock);
232	interrupts_restore(ipl);	275	interrupts_restore(ipl);
233		276
234	rc = as_area_share(AS, IPC_GET_ARG1(answer->data),	277	rc = as_area_share(AS, IPC_GET_ARG1(answer->data),
235	IPC_GET_ARG2(olddata), as, IPC_GET_ARG1(olddata),	278	IPC_GET_ARG2(olddata), as, IPC_GET_ARG1(olddata),
236	IPC_GET_ARG2(answer->data));	279	IPC_GET_ARG2(answer->data));
237	IPC_SET_RETVAL(answer->data, rc);	280	IPC_SET_RETVAL(answer->data, rc);
238	}	281	}
239	} else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_READ) {	282	} else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_READ) {
240	ASSERT(!answer->buffer);	283	ASSERT(!answer->buffer);
241	if (!IPC_GET_RETVAL(answer->data)) {	284	if (!IPC_GET_RETVAL(answer->data)) {
242	/* The recipient agreed to send data. */	285	/* The recipient agreed to send data. */
243	uintptr_t src = IPC_GET_ARG1(answer->data);	286	uintptr_t src = IPC_GET_ARG1(answer->data);
244	uintptr_t dst = IPC_GET_ARG1(*olddata);	287	uintptr_t dst = IPC_GET_ARG1(*olddata);
245	size_t max_size = IPC_GET_ARG2(*olddata);	288	size_t max_size = IPC_GET_ARG2(*olddata);
246	size_t size = IPC_GET_ARG2(answer->data);	289	size_t size = IPC_GET_ARG2(answer->data);
247	if (size && size <= max_size) {	290	if (size && size <= max_size) {
248	/*	291	/*
249	* Copy the destination VA so that this piece of	292	* Copy the destination VA so that this piece of
250	* information is not lost.	293	* information is not lost.
251	*/	294	*/
252	IPC_SET_ARG1(answer->data, dst);	295	IPC_SET_ARG1(answer->data, dst);
253		296
254	answer->buffer = malloc(size, 0);	297	answer->buffer = malloc(size, 0);
255	int rc = copy_from_uspace(answer->buffer,	298	int rc = copy_from_uspace(answer->buffer,
256	(void *) src, size);	299	(void *) src, size);
257	if (rc) {	300	if (rc) {
258	IPC_SET_RETVAL(answer->data, rc);	301	IPC_SET_RETVAL(answer->data, rc);
259	free(answer->buffer);	302	free(answer->buffer);
260	answer->buffer = NULL;	303	answer->buffer = NULL;
261	}	304	}
262	} else if (!size) {	305	} else if (!size) {
263	IPC_SET_RETVAL(answer->data, EOK);	306	IPC_SET_RETVAL(answer->data, EOK);
264	} else {	307	} else {
265	IPC_SET_RETVAL(answer->data, ELIMIT);	308	IPC_SET_RETVAL(answer->data, ELIMIT);
266	}	309	}
267	}	310	}
268	} else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_WRITE) {	311	} else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_WRITE) {
269	ASSERT(answer->buffer);	312	ASSERT(answer->buffer);
270	if (!IPC_GET_RETVAL(answer->data)) {	313	if (!IPC_GET_RETVAL(answer->data)) {
271	/* The recipient agreed to receive data. */	314	/* The recipient agreed to receive data. */
272	int rc;	315	int rc;
273	uintptr_t dst;	316	uintptr_t dst;
274	size_t size;	317	size_t size;
275	size_t max_size;	318	size_t max_size;
276		319
277	dst = (uintptr_t)IPC_GET_ARG1(answer->data);	320	dst = (uintptr_t)IPC_GET_ARG1(answer->data);
278	size = (size_t)IPC_GET_ARG2(answer->data);	321	size = (size_t)IPC_GET_ARG2(answer->data);
279	max_size = (size_t)IPC_GET_ARG2(*olddata);	322	max_size = (size_t)IPC_GET_ARG2(*olddata);
280		323
281	if (size <= max_size) {	324	if (size <= max_size) {
282	rc = copy_to_uspace((void *) dst,	325	rc = copy_to_uspace((void *) dst,
283	answer->buffer, size);	326	answer->buffer, size);
284	if (rc)	327	if (rc)
285	IPC_SET_RETVAL(answer->data, rc);	328	IPC_SET_RETVAL(answer->data, rc);
286	} else {	329	} else {
287	IPC_SET_RETVAL(answer->data, ELIMIT);	330	IPC_SET_RETVAL(answer->data, ELIMIT);
288	}	331	}
289	}	332	}
290	free(answer->buffer);	333	free(answer->buffer);
291	answer->buffer = NULL;	334	answer->buffer = NULL;
292	}	335	}
293	return 0;	336	return 0;
294	}	337	}
295		338
-		339	static void phones_lock(phone_t p1, phone_t p2)
-		340	{
-		341	if (p1 < p2) {
-		342	mutex_lock(&p1->lock);
-		343	mutex_lock(&p2->lock);
-		344	} else if (p1 > p2) {
-		345	mutex_lock(&p2->lock);
-		346	mutex_lock(&p1->lock);
-		347	} else {
-		348	mutex_lock(&p1->lock);
-		349	}
-		350	}
-		351
-		352	static void phones_unlock(phone_t p1, phone_t p2)
-		353	{
-		354	mutex_unlock(&p1->lock);
-		355	if (p1 != p2)
-		356	mutex_unlock(&p2->lock);
-		357	}
-		358
296	/** Called before the request is sent.	359	/** Called before the request is sent.
297	*	360	*
298	* @param call Call structure with the request.	361	* @param call Call structure with the request.
299	* @param phone Phone that the call will be sent through.	362	* @param phone Phone that the call will be sent through.
300	*	363	*
301	* @return Return 0 on success, ELIMIT or EPERM on error.	364	* @return Return 0 on success, ELIMIT or EPERM on error.
302	*/	365	*/
303	static int request_preprocess(call_t call, phone_t phone)	366	static int request_preprocess(call_t call, phone_t phone)
304	{	367	{
305	int newphid;	368	int newphid;
306	size_t size;	369	size_t size;
307	uintptr_t src;	370	uintptr_t src;
308	int rc;	371	int rc;
309		372
310	switch (IPC_GET_METHOD(call->data)) {	373	switch (IPC_GET_METHOD(call->data)) {
-		374	case IPC_M_CONNECTION_CLONE: {
-		375	phone_t *cloned_phone;
-		376	GET_CHECK_PHONE(cloned_phone, IPC_GET_ARG1(call->data),
-		377	return ENOENT);
-		378	phones_lock(cloned_phone, phone);
-		379	if ((cloned_phone->state != IPC_PHONE_CONNECTED) \|\|
-		380	phone->state != IPC_PHONE_CONNECTED) {
-		381	phones_unlock(cloned_phone, phone);
-		382	return EINVAL;
-		383	}
-		384	/*
-		385	* We can be pretty sure now that both tasks exist and we are
-		386	* connected to them. As we continue to hold the phone locks,
-		387	* we are effectively preventing them from finishing their
-		388	* potential cleanup.
-		389	*/
-		390	newphid = phone_alloc(phone->callee->task);
-		391	if (newphid < 0) {
-		392	phones_unlock(cloned_phone, phone);
-		393	return ELIMIT;
-		394	}
-		395	ipc_phone_connect(&phone->callee->task->phones[newphid],
-		396	cloned_phone->callee);
-		397	phones_unlock(cloned_phone, phone);
-		398	/* Set the new phone for the callee. */
-		399	IPC_SET_ARG1(call->data, newphid);
-		400	break;
-		401	}
-		402	case IPC_M_CONNECT_ME:
-		403	IPC_SET_ARG5(call->data, (unative_t) phone);
-		404	break;
311	case IPC_M_CONNECT_ME_TO:	405	case IPC_M_CONNECT_ME_TO:
312	newphid = phone_alloc();	406	newphid = phone_alloc(TASK);
313	if (newphid < 0)	407	if (newphid < 0)
314	return ELIMIT;	408	return ELIMIT;
315	/* Set arg5 for server */	409	/* Set arg5 for server */
316	IPC_SET_ARG5(call->data, (unative_t) &TASK->phones[newphid]);	410	IPC_SET_ARG5(call->data, (unative_t) &TASK->phones[newphid]);
317	call->flags \|= IPC_CALL_CONN_ME_TO;	411	call->flags \|= IPC_CALL_CONN_ME_TO;
318	call->priv = newphid;	412	call->priv = newphid;
319	break;	413	break;
320	case IPC_M_SHARE_OUT:	414	case IPC_M_SHARE_OUT:
321	size = as_area_get_size(IPC_GET_ARG1(call->data));	415	size = as_area_get_size(IPC_GET_ARG1(call->data));
322	if (!size)	416	if (!size)
323	return EPERM;	417	return EPERM;
324	IPC_SET_ARG2(call->data, size);	418	IPC_SET_ARG2(call->data, size);
325	break;	419	break;
326	case IPC_M_DATA_READ:	420	case IPC_M_DATA_READ:
327	size = IPC_GET_ARG2(call->data);	421	size = IPC_GET_ARG2(call->data);
328	if ((size <= 0 \|\| (size > DATA_XFER_LIMIT)))	422	if ((size <= 0 \|\| (size > DATA_XFER_LIMIT)))
329	return ELIMIT;	423	return ELIMIT;
330	break;	424	break;
331	case IPC_M_DATA_WRITE:	425	case IPC_M_DATA_WRITE:
332	src = IPC_GET_ARG1(call->data);	426	src = IPC_GET_ARG1(call->data);
333	size = IPC_GET_ARG2(call->data);	427	size = IPC_GET_ARG2(call->data);
334		428
335	if (size > DATA_XFER_LIMIT)	429	if (size > DATA_XFER_LIMIT)
336	return ELIMIT;	430	return ELIMIT;
337		431
338	call->buffer = (uint8_t *) malloc(size, 0);	432	call->buffer = (uint8_t *) malloc(size, 0);
339	rc = copy_from_uspace(call->buffer, (void *) src, size);	433	rc = copy_from_uspace(call->buffer, (void *) src, size);
340	if (rc != 0) {	434	if (rc != 0) {
341	free(call->buffer);	435	free(call->buffer);
342	return rc;	436	return rc;
343	}	437	}
344	break;	438	break;
345	#ifdef CONFIG_UDEBUG	439	#ifdef CONFIG_UDEBUG
346	case IPC_M_DEBUG_ALL:	440	case IPC_M_DEBUG_ALL:
347	return udebug_request_preprocess(call, phone);	441	return udebug_request_preprocess(call, phone);
348	#endif	442	#endif
349	default:	443	default:
350	break;	444	break;
351	}	445	}
352	return 0;	446	return 0;
353	}	447	}
354		448
355	/*******************************************************************************	449	/*******************************************************************************
356	* Functions called to process received call/answer before passing it to uspace.	450	* Functions called to process received call/answer before passing it to uspace.
357	*******************************************************************************/	451	*******************************************************************************/
358		452
359	/** Do basic kernel processing of received call answer.	453	/** Do basic kernel processing of received call answer.
360	*	454	*
361	* @param call Call structure with the answer.	455	* @param call Call structure with the answer.
362	*/	456	*/
363	static void process_answer(call_t *call)	457	static void process_answer(call_t *call)
364	{	458	{
365	if (((native_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&	459	if (((native_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&
366	(call->flags & IPC_CALL_FORWARDED))	460	(call->flags & IPC_CALL_FORWARDED))
367	IPC_SET_RETVAL(call->data, EFORWARD);	461	IPC_SET_RETVAL(call->data, EFORWARD);
368		462
369	if (call->flags & IPC_CALL_CONN_ME_TO) {	463	if (call->flags & IPC_CALL_CONN_ME_TO) {
370	if (IPC_GET_RETVAL(call->data))	464	if (IPC_GET_RETVAL(call->data))
371	phone_dealloc(call->priv);	465	phone_dealloc(call->priv);
372	else	466	else
373	IPC_SET_ARG5(call->data, call->priv);	467	IPC_SET_ARG5(call->data, call->priv);
374	}	468	}
375		469
376	if (call->buffer) {	470	if (call->buffer) {
377	/* This must be an affirmative answer to IPC_M_DATA_READ. */	471	/* This must be an affirmative answer to IPC_M_DATA_READ. */
378	/* or IPC_M_DEBUG_ALL/UDEBUG_M_MEM_READ... */	472	/* or IPC_M_DEBUG_ALL/UDEBUG_M_MEM_READ... */
379	uintptr_t dst = IPC_GET_ARG1(call->data);	473	uintptr_t dst = IPC_GET_ARG1(call->data);
380	size_t size = IPC_GET_ARG2(call->data);	474	size_t size = IPC_GET_ARG2(call->data);
381	int rc = copy_to_uspace((void *) dst, call->buffer, size);	475	int rc = copy_to_uspace((void *) dst, call->buffer, size);
382	if (rc)	476	if (rc)
383	IPC_SET_RETVAL(call->data, rc);	477	IPC_SET_RETVAL(call->data, rc);
384	free(call->buffer);	478	free(call->buffer);
385	call->buffer = NULL;	479	call->buffer = NULL;
386	}	480	}
387	}	481	}
388		482
389	/** Do basic kernel processing of received call request.	483	/** Do basic kernel processing of received call request.
390	*	484	*
391	* @param box Destination answerbox structure.	485	* @param box Destination answerbox structure.
392	* @param call Call structure with the request.	486	* @param call Call structure with the request.
393	*	487	*
394	* @return Return 0 if the call should be passed to userspace.	488	* @return Return 0 if the call should be passed to userspace.
395	* Return -1 if the call should be ignored.	489	* Return -1 if the call should be ignored.
396	*/	490	*/
397	static int process_request(answerbox_t box, call_t call)	491	static int process_request(answerbox_t box, call_t call)
398	{	492	{
399	int phoneid;	493	int phoneid;
400		494
401	if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {	495	if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {
402	phoneid = phone_alloc();	496	phoneid = phone_alloc(TASK);
403	if (phoneid < 0) { /* Failed to allocate phone */	497	if (phoneid < 0) { /* Failed to allocate phone */
404	IPC_SET_RETVAL(call->data, ELIMIT);	498	IPC_SET_RETVAL(call->data, ELIMIT);
405	ipc_answer(box, call);	499	ipc_answer(box, call);
406	return -1;	500	return -1;

Subversion Repositories HelenOS

(root)/branches/tracing/kernel/generic/src/ipc/sysipc.c – Rev 4377 → 4692