Changes in kernel/generic/src/ipc/sysipc.c [2541646:6c34f587] in mainline

File:

• kernel/generic/src/ipc/sysipc.c (modified) (8 diffs)

kernel/generic/src/ipc/sysipc.c

@@ -34 +34 @@
 
 #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 <abi/ipc/methods.h>
 #include <ipc/sysipc.h>
-#include <ipc/sysipc_ops.h>
-#include <ipc/sysipc_priv.h>
 #include <ipc/irq.h>
 #include <ipc/ipcrsc.h>
@@ -46 +47 @@
 #include <ipc/kbox.h>
 #include <synch/waitq.h>
+#include <udebug/udebug_ipc.h>
 #include <arch/interrupt.h>
 #include <syscall/copy.h>
 #include <security/cap.h>
 #include <console/console.h>
+#include <mm/as.h>
 #include <print.h>
 #include <macros.h>
 
+/**
+ * Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ
+ * requests.
+ */
+#define DATA_XFER_LIMIT  (64 * 1024)
+
 #define STRUCT_TO_USPACE(dst, src)  copy_to_uspace((dst), (src), sizeof(*(src)))
+
+/** Get phone from the current task by ID.
+ *
+ * @param phoneid Phone ID.
+ * @param phone   Place to store pointer to phone.
+ *
+ * @return EOK on success, EINVAL if ID is invalid.
+ *
+ */
+static int phone_get(sysarg_t phoneid, phone_t **phone)
+{
+        if (phoneid >= IPC_MAX_PHONES)
+                return EINVAL;
+        
+        *phone = &TASK->phones[phoneid];
+        return EOK;
+}
 
 /** Decide if the interface and method is a system method.
@@ -155 +181 @@
  * @param olddata Saved data of the request.
  *
- * @return Return EOK on success or a negative error code.
- *
- */
-int answer_preprocess(call_t *answer, ipc_data_t *olddata)
-{
-        int rc = EOK;
-        sysipc_ops_t *ops;
-
-        spinlock_lock(&answer->forget_lock);
-        if (answer->forget) {
-                /*
-                 * This is a forgotten call and answer->sender is not valid.
+ * @return Return 0 on success or an error code.
+ *
+ */
+static inline int answer_preprocess(call_t *answer, ipc_data_t *olddata)
+{
+        if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
+                /* In case of forward, hangup the forwared phone,
+                 * not the originator
                  */
-                spinlock_unlock(&answer->forget_lock);
-
-                ops = sysipc_ops_get(answer->request_method);
-                if (ops->answer_cleanup)
-                        ops->answer_cleanup(answer, olddata);
-
-                return rc;
-        } else {
-                ASSERT(answer->active);
-
-                /*
-                 * Mark the call as inactive to prevent _ipc_answer_free_call()
-                 * from attempting to remove the call from the active list
-                 * itself.
-                 */
-                answer->active = false;
-
-                /*
-                 * Remove the call from the sender's active call list.
-                 * We enforce this locking order so that any potential
-                 * concurrently executing forget operation is forced to
-                 * release its active_calls_lock and lose the race to
-                 * forget this soon to be answered call. 
-                 */
-                spinlock_lock(&answer->sender->active_calls_lock);
-                list_remove(&answer->ta_link);
-                spinlock_unlock(&answer->sender->active_calls_lock);
-        }
-        spinlock_unlock(&answer->forget_lock);
-
-        if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
-                phone_t *phone = answer->caller_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);
+                mutex_lock(&answer->data.phone->lock);
+                irq_spinlock_lock(&TASK->answerbox.lock, true);
+                if (answer->data.phone->state == IPC_PHONE_CONNECTED) {
+                        list_remove(&answer->data.phone->link);
+                        answer->data.phone->state = IPC_PHONE_SLAMMED;
+                }
+                irq_spinlock_unlock(&TASK->answerbox.lock, true);
+                mutex_unlock(&answer->data.phone->lock);
         }
         
         if (!olddata)
-                return rc;
-
-        ops = sysipc_ops_get(answer->request_method);
-        if (ops->answer_preprocess)
-                rc = ops->answer_preprocess(answer, olddata);
-        
-        return rc;
+                return 0;
+        
+        if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECTION_CLONE) {
+                int 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) {
+                                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);
+                }
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CLONE_ESTABLISH) {
+                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) {
+                                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);
+                }
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
+                int 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,
+                            (sysarg_t) &TASK->phones[phoneid]);
+                }
+        } else if (IPC_GET_IMETHOD(*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_IMETHOD(*olddata) == IPC_M_SHARE_OUT) {
+                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;
+                        int 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;
+                }
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_IN) {
+                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);
+                }
+        } else if (IPC_GET_IMETHOD(*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_IMETHOD(*olddata) == IPC_M_DATA_WRITE) {
+                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;
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_STATE_CHANGE_AUTHORIZE) {
+                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;
+                        int rc;
+
+                        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;
+                }
+        }
+        
+        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);
 }
 
@@ -230 +424 @@
 static int request_preprocess(call_t *call, phone_t *phone)
 {
-        int rc = EOK;
-
-        call->request_method = IPC_GET_IMETHOD(call->data);
-
-        sysipc_ops_t *ops = sysipc_ops_get(call->request_method);
-        if (ops->request_preprocess)
-                rc = ops->request_preprocess(call, phone);
-        
-        return rc;
+        switch (IPC_GET_IMETHOD(call->data)) {
+        case IPC_M_CONNECTION_CLONE: {
+                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);
+                break;
+        }
+        case IPC_M_CLONE_ESTABLISH:
+                IPC_SET_ARG5(call->data, (sysarg_t) phone);
+                break;
+        case IPC_M_CONNECT_ME_TO: {
+                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;
+                break;
+        }
+        case IPC_M_SHARE_OUT: {
+                size_t 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_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;
+                }
+                break;
+        }
+        case IPC_M_DATA_WRITE: {
+                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;
+                }
+                
+                break;
+        }
+        case IPC_M_STATE_CHANGE_AUTHORIZE: {
+                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);
+                break;
+        }
+#ifdef CONFIG_UDEBUG
+        case IPC_M_DEBUG:
+                return udebug_request_preprocess(call, phone);
+#endif
+        default:
+                break;
+        }
+        
+        return 0;
 }
 
@@ -256 +561 @@
                 IPC_SET_RETVAL(call->data, EFORWARD);
         
-        sysipc_ops_t *ops = sysipc_ops_get(call->request_method);
-        if (ops->answer_process)
-                (void) ops->answer_process(call);
-}
-
+        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/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.
@@ -273 +595 @@
 static int process_request(answerbox_t *box, call_t *call)
 {
-        int rc = EOK;
-
-        sysipc_ops_t *ops = sysipc_ops_get(call->request_method);
-        if (ops->request_process)
-                rc = ops->request_process(call, box);
-        
-        return rc;
+        if (IPC_GET_IMETHOD(call->data) == IPC_M_CONNECT_TO_ME) {
+                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);
+        }
+        
+        switch (IPC_GET_IMETHOD(call->data)) {
+        case IPC_M_DEBUG:
+                return -1;
+        default:
+                break;
+        }
+        
+        return 0;
 }
 
@@ -411 +745 @@
 {
         call_t *call = get_call(callid);
-        phone_t *phone;
-        bool need_old = answer_need_old(call);
-        bool after_forward = false;
-        ipc_data_t old;
-        int rc;
-
         if (!call)
                 return ENOENT;
-
-        if (need_old)
-                old = call->data;
-        
+        
+        call->flags |= IPC_CALL_FORWARDED;
+        
+        phone_t *phone;
         if (phone_get(phoneid, &phone) != EOK) {
-                rc = ENOENT;
-                goto error;
+                IPC_SET_RETVAL(call->data, EFORWARD);
+                ipc_answer(&TASK->answerbox, call);
+                return ENOENT;
         }
         
         if (!method_is_forwardable(IPC_GET_IMETHOD(call->data))) {
-                rc = EPERM;
-                goto error;
-        }
-
-        call->flags |= IPC_CALL_FORWARDED;
+                IPC_SET_RETVAL(call->data, EFORWARD);
+                ipc_answer(&TASK->answerbox, call);
+                return EPERM;
+        }
         
         /*
@@ -469 +797 @@
         }
         
-        rc = ipc_forward(call, phone, &TASK->answerbox, mode);
-        if (rc != EOK) {
-                after_forward = true;
-                goto error;
-        }
-
-        return EOK;
-
-error:
-        IPC_SET_RETVAL(call->data, EFORWARD);
-        (void) answer_preprocess(call, need_old ? &old : NULL);
-        if (after_forward)
-                _ipc_answer_free_call(call, false);
-        else
-                ipc_answer(&TASK->answerbox, call);
-
-        return rc;
+        return ipc_forward(call, phone, &TASK->answerbox, mode);
 }