Index: kernel/generic/src/ipc/ops/clnestab.c =================================================================== --- kernel/generic/src/ipc/ops/clnestab.c (revision f0defd23cf60e37c1e72fe4d48523e9b8794b239) +++ kernel/generic/src/ipc/ops/clnestab.c (revision e8039a869ee74ce2d6837e91b5331acd3a5a541d) @@ -34,9 +34,42 @@ #include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + IPC_SET_ARG5(call->data, (sysarg_t) phone); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata); + + if (IPC_GET_RETVAL(answer->data) != EOK) { + /* + * The other party on the cloned phone 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) { + irq_spinlock_lock(&phone->callee->lock, true); + list_remove(&phone->link); + phone->state = IPC_PHONE_SLAMMED; + irq_spinlock_unlock(&phone->callee->lock, true); + } + mutex_unlock(&phone->lock); + } + + return EOK; +} sysipc_ops_t ipc_m_clone_establish_ops = { - .request_preprocess = null_request_preprocess, + .request_preprocess = request_preprocess, .request_process = null_request_process, - .answer_preprocess = null_answer_preprocess, + .answer_preprocess = answer_preprocess, .answer_process = null_answer_process, }; Index: kernel/generic/src/ipc/ops/conctmeto.c =================================================================== --- kernel/generic/src/ipc/ops/conctmeto.c (revision f0defd23cf60e37c1e72fe4d48523e9b8794b239) +++ kernel/generic/src/ipc/ops/conctmeto.c (revision e8039a869ee74ce2d6837e91b5331acd3a5a541d) @@ -1,3 +1,4 @@ /* + * Copyright (c) 2006 Ondrej Palkovsky * Copyright (c) 2012 Jakub Jermar * All rights reserved. @@ -34,14 +35,43 @@ #include +#include +#include +#include +#include -static sysipc_ops_t ipc_m_connect_me_to_ops = { - .request_preprocess = null_request_preprocess, +static int request_preprocess(call_t *call, phone_t *phone) +{ + int newphid = phone_alloc(TASK); + + if (newphid < 0) + return ELIMIT; + + /* Set arg5 for server */ + IPC_SET_ARG5(call->data, (sysarg_t) &TASK->phones[newphid]); + call->flags |= IPC_CALL_CONN_ME_TO; + call->priv = newphid; + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata); + + /* If the user accepted call, connect */ + if (IPC_GET_RETVAL(answer->data) == EOK) + ipc_phone_connect(phone, &TASK->answerbox); + + return EOK; +} + + +sysipc_ops_t ipc_m_connect_me_to_ops = { + .request_preprocess = request_preprocess, .request_process = null_request_process, - .answer_preprocess = null_answer_preprocess, + .answer_preprocess = answer_preprocess, .answer_process = null_answer_process, }; -sysipc_ops_t *ipc_m_connect_me_to_ops_p = &ipc_m_connect_me_to_ops; - /** @} */ Index: kernel/generic/src/ipc/ops/concttome.c =================================================================== --- kernel/generic/src/ipc/ops/concttome.c (revision f0defd23cf60e37c1e72fe4d48523e9b8794b239) +++ kernel/generic/src/ipc/ops/concttome.c (revision e8039a869ee74ce2d6837e91b5331acd3a5a541d) @@ -1,3 +1,4 @@ /* + * Copyright (c) 2006 Ondrej Palkovsky * Copyright (c) 2012 Jakub Jermar * All rights reserved. @@ -34,9 +35,48 @@ #include +#include +#include +#include +#include + +static int request_process(call_t *call, answerbox_t *box) +{ + int 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); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + int phoneid = (int) IPC_GET_ARG5(*olddata); + + if (IPC_GET_RETVAL(answer->data) != EOK) { + /* The connection was not accepted */ + int phoneid = (int) IPC_GET_ARG5(*olddata); + + 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, (sysarg_t) &TASK->phones[phoneid]); + } + + return EOK; +} + sysipc_ops_t ipc_m_connect_to_me_ops = { .request_preprocess = null_request_preprocess, - .request_process = null_request_process, - .answer_preprocess = null_answer_preprocess, + .request_process = request_process, + .answer_preprocess = answer_preprocess, .answer_process = null_answer_process, }; Index: kernel/generic/src/ipc/ops/connclone.c =================================================================== --- kernel/generic/src/ipc/ops/connclone.c (revision f0defd23cf60e37c1e72fe4d48523e9b8794b239) +++ kernel/generic/src/ipc/ops/connclone.c (revision e8039a869ee74ce2d6837e91b5331acd3a5a541d) @@ -34,9 +34,99 @@ #include +#include +#include +#include +#include +#include + +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); +} + +static int request_preprocess(call_t *call, phone_t *phone) +{ + phone_t *cloned_phone; + + if (phone_get(IPC_GET_ARG1(call->data), &cloned_phone) != EOK) + 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. + * + */ + int 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); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + if (IPC_GET_RETVAL(answer->data) != EOK) { + /* + * The recipient of the cloned phone rejected the offer. + */ + int phoneid = (int) IPC_GET_ARG1(*olddata); + phone_t *phone = &TASK->phones[phoneid]; + + /* + * 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) { + irq_spinlock_lock(&phone->callee->lock, true); + list_remove(&phone->link); + phone->state = IPC_PHONE_SLAMMED; + irq_spinlock_unlock(&phone->callee->lock, true); + } + mutex_unlock(&phone->lock); + } + + return EOK; +} sysipc_ops_t ipc_m_connection_clone_ops = { - .request_preprocess = null_request_preprocess, + .request_preprocess = request_preprocess, .request_process = null_request_process, - .answer_preprocess = null_answer_preprocess, + .answer_preprocess = answer_preprocess, .answer_process = null_answer_process, }; Index: kernel/generic/src/ipc/ops/dataread.c =================================================================== --- kernel/generic/src/ipc/ops/dataread.c (revision f0defd23cf60e37c1e72fe4d48523e9b8794b239) +++ kernel/generic/src/ipc/ops/dataread.c (revision e8039a869ee74ce2d6837e91b5331acd3a5a541d) @@ -34,9 +34,65 @@ #include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + size_t size = IPC_GET_ARG2(call->data); + + if (size > DATA_XFER_LIMIT) { + int flags = IPC_GET_ARG3(call->data); + + if (flags & IPC_XF_RESTRICT) + IPC_SET_ARG2(call->data, DATA_XFER_LIMIT); + else + return ELIMIT; + } + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + 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); + } + } + + return EOK; +} sysipc_ops_t ipc_m_data_read_ops = { - .request_preprocess = null_request_preprocess, + .request_preprocess = request_preprocess, .request_process = null_request_process, - .answer_preprocess = null_answer_preprocess, + .answer_preprocess = answer_preprocess, .answer_process = null_answer_process, }; Index: kernel/generic/src/ipc/ops/datawrite.c =================================================================== --- kernel/generic/src/ipc/ops/datawrite.c (revision f0defd23cf60e37c1e72fe4d48523e9b8794b239) +++ kernel/generic/src/ipc/ops/datawrite.c (revision e8039a869ee74ce2d6837e91b5331acd3a5a541d) @@ -34,9 +34,65 @@ #include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + uintptr_t src = IPC_GET_ARG1(call->data); + size_t size = IPC_GET_ARG2(call->data); + + if (size > DATA_XFER_LIMIT) { + int flags = IPC_GET_ARG3(call->data); + + if (flags & IPC_XF_RESTRICT) { + size = DATA_XFER_LIMIT; + IPC_SET_ARG2(call->data, size); + } else + return ELIMIT; + } + + call->buffer = (uint8_t *) malloc(size, 0); + int rc = copy_from_uspace(call->buffer, (void *) src, size); + if (rc != 0) { + free(call->buffer); + return rc; + } + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + ASSERT(answer->buffer); + + if (!IPC_GET_RETVAL(answer->data)) { + /* The recipient agreed to receive data. */ + uintptr_t dst = (uintptr_t)IPC_GET_ARG1(answer->data); + size_t size = (size_t)IPC_GET_ARG2(answer->data); + size_t max_size = (size_t)IPC_GET_ARG2(*olddata); + + if (size <= max_size) { + int 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 EOK; +} + sysipc_ops_t ipc_m_data_write_ops = { - .request_preprocess = null_request_preprocess, + .request_preprocess = request_preprocess, .request_process = null_request_process, - .answer_preprocess = null_answer_preprocess, + .answer_preprocess = answer_preprocess, .answer_process = null_answer_process, }; Index: kernel/generic/src/ipc/ops/debug.c =================================================================== --- kernel/generic/src/ipc/ops/debug.c (revision f0defd23cf60e37c1e72fe4d48523e9b8794b239) +++ kernel/generic/src/ipc/ops/debug.c (revision e8039a869ee74ce2d6837e91b5331acd3a5a541d) @@ -1,4 +1,4 @@ /* - * Copyright (c) 2012 Jakub Jermar + * Copyright (c) 2008 Jiri Svoboda * All rights reserved. * @@ -34,8 +34,19 @@ #include +#include +#include + +static int request_process(call_t *call, answerbox_t *box) +{ + return -1; +} sysipc_ops_t ipc_m_debug_ops = { +#ifdef CONFIG_UDEBUG + .request_preprocess = udebug_request_preprocess, +#else .request_preprocess = null_request_preprocess, - .request_process = null_request_process, +#endif + .request_process = request_process, .answer_preprocess = null_answer_preprocess, .answer_process = null_answer_process, Index: kernel/generic/src/ipc/ops/sharein.c =================================================================== --- kernel/generic/src/ipc/ops/sharein.c (revision f0defd23cf60e37c1e72fe4d48523e9b8794b239) +++ kernel/generic/src/ipc/ops/sharein.c (revision e8039a869ee74ce2d6837e91b5331acd3a5a541d) @@ -34,9 +34,33 @@ #include +#include +#include +#include +#include +#include +#include + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + if (!IPC_GET_RETVAL(answer->data)) { + irq_spinlock_lock(&answer->sender->lock, true); + as_t *as = answer->sender->as; + irq_spinlock_unlock(&answer->sender->lock, true); + + uintptr_t dst_base = (uintptr_t) -1; + int rc = as_area_share(AS, IPC_GET_ARG1(answer->data), + IPC_GET_ARG1(*olddata), as, IPC_GET_ARG2(answer->data), + &dst_base, IPC_GET_ARG3(answer->data)); + IPC_SET_ARG4(answer->data, dst_base); + IPC_SET_RETVAL(answer->data, rc); + } + + return EOK; +} sysipc_ops_t ipc_m_share_in_ops = { .request_preprocess = null_request_preprocess, .request_process = null_request_process, - .answer_preprocess = null_answer_preprocess, + .answer_preprocess = answer_preprocess, .answer_process = null_answer_process, }; Index: kernel/generic/src/ipc/ops/shareout.c =================================================================== --- kernel/generic/src/ipc/ops/shareout.c (revision f0defd23cf60e37c1e72fe4d48523e9b8794b239) +++ kernel/generic/src/ipc/ops/shareout.c (revision e8039a869ee74ce2d6837e91b5331acd3a5a541d) @@ -34,9 +34,54 @@ #include +#include +#include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + size_t size = as_area_get_size(IPC_GET_ARG1(call->data)); + + if (!size) + return EPERM; + IPC_SET_ARG2(call->data, size); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + int rc = EOK; + + if (!IPC_GET_RETVAL(answer->data)) { + /* Accepted, handle as_area receipt */ + + irq_spinlock_lock(&answer->sender->lock, true); + as_t *as = answer->sender->as; + irq_spinlock_unlock(&answer->sender->lock, true); + + uintptr_t dst_base = (uintptr_t) -1; + rc = as_area_share(as, IPC_GET_ARG1(*olddata), + IPC_GET_ARG2(*olddata), AS, IPC_GET_ARG3(*olddata), + &dst_base, IPC_GET_ARG1(answer->data)); + + if (rc == EOK) { + rc = copy_to_uspace((void *) IPC_GET_ARG2(answer->data), + &dst_base, sizeof(dst_base)); + } + + IPC_SET_RETVAL(answer->data, rc); + } + + return rc; +} sysipc_ops_t ipc_m_share_out_ops = { - .request_preprocess = null_request_preprocess, + .request_preprocess = request_preprocess, .request_process = null_request_process, - .answer_preprocess = null_answer_preprocess, + .answer_preprocess = answer_preprocess, .answer_process = null_answer_process, }; Index: kernel/generic/src/ipc/ops/stchngath.c =================================================================== --- kernel/generic/src/ipc/ops/stchngath.c (revision f0defd23cf60e37c1e72fe4d48523e9b8794b239) +++ kernel/generic/src/ipc/ops/stchngath.c (revision e8039a869ee74ce2d6837e91b5331acd3a5a541d) @@ -34,9 +34,90 @@ #include +#include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + phone_t *sender_phone; + task_t *other_task_s; + + if (phone_get(IPC_GET_ARG5(call->data), &sender_phone) != EOK) + return ENOENT; + + mutex_lock(&sender_phone->lock); + if (sender_phone->state != IPC_PHONE_CONNECTED) { + mutex_unlock(&sender_phone->lock); + return EINVAL; + } + + other_task_s = sender_phone->callee->task; + + mutex_unlock(&sender_phone->lock); + + /* Remember the third party task hash. */ + IPC_SET_ARG5(call->data, (sysarg_t) other_task_s); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + int rc = EOK; + + if (!IPC_GET_RETVAL(answer->data)) { + /* The recipient authorized the change of state. */ + phone_t *recipient_phone; + task_t *other_task_s; + task_t *other_task_r; + + rc = phone_get(IPC_GET_ARG1(answer->data), + &recipient_phone); + if (rc != EOK) { + IPC_SET_RETVAL(answer->data, ENOENT); + return ENOENT; + } + + mutex_lock(&recipient_phone->lock); + if (recipient_phone->state != IPC_PHONE_CONNECTED) { + mutex_unlock(&recipient_phone->lock); + IPC_SET_RETVAL(answer->data, EINVAL); + return EINVAL; + } + + other_task_r = recipient_phone->callee->task; + other_task_s = (task_t *) IPC_GET_ARG5(*olddata); + + /* + * See if both the sender and the recipient meant the + * same third party task. + */ + if (other_task_r != other_task_s) { + IPC_SET_RETVAL(answer->data, EINVAL); + rc = EINVAL; + } else { + rc = event_task_notify_5(other_task_r, + EVENT_TASK_STATE_CHANGE, false, + IPC_GET_ARG1(*olddata), + IPC_GET_ARG2(*olddata), + IPC_GET_ARG3(*olddata), + LOWER32(olddata->task_id), + UPPER32(olddata->task_id)); + IPC_SET_RETVAL(answer->data, rc); + } + + mutex_unlock(&recipient_phone->lock); + } + + return rc; +} sysipc_ops_t ipc_m_state_change_authorize_ops = { - .request_preprocess = null_request_preprocess, + .request_preprocess = request_preprocess, .request_process = null_request_process, - .answer_preprocess = null_answer_preprocess, + .answer_preprocess = answer_preprocess, .answer_process = null_answer_process, };