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

Subversion Repositories HelenOS

(root)/branches/dd/kernel/generic/src/ipc/sysipc.c – Rev 4420 → 4439