Changeset fedac2f in mainline for kernel/generic/src/ipc/sysipc.c

Timestamp:

2012-09-16T11:27:35Z (12 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

289fa65

Parents:

8930624 (diff), 00b4a68 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

merge mainline changes

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>
@@ -47 +46 @@
 #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.
@@ -181 +155 @@
  * @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)
-{
+ * @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.
+                 */
+                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) {
-                /* In case of forward, hangup the forwared phone,
-                 * not the originator
-                 */
-                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;
+                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);
                 }
-                irq_spinlock_unlock(&TASK->answerbox.lock, true);
-                mutex_unlock(&answer->data.phone->lock);
+                mutex_unlock(&phone->lock);
         }
         
         if (!olddata)
-                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);
+                return rc;
+
+        ops = sysipc_ops_get(answer->request_method);
+        if (ops->answer_preprocess)
+                rc = ops->answer_preprocess(answer, olddata);
+        
+        return rc;
 }
 
@@ -424 +230 @@
 static int request_preprocess(call_t *call, phone_t *phone)
 {
-        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;
+        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;
 }
 
@@ -561 +256 @@
                 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/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;
-        }
-}
+        sysipc_ops_t *ops = sysipc_ops_get(call->request_method);
+        if (ops->answer_process)
+                (void) ops->answer_process(call);
+}
+
 
 /** Do basic kernel processing of received call request.
@@ -595 +273 @@
 static int process_request(answerbox_t *box, call_t *call)
 {
-        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;
+        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;
 }
 
@@ -745 +411 @@
 {
         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;
+        
+        if (phone_get(phoneid, &phone) != EOK) {
+                rc = ENOENT;
+                goto error;
+        }
+        
+        if (!method_is_forwardable(IPC_GET_IMETHOD(call->data))) {
+                rc = EPERM;
+                goto error;
+        }
+
         call->flags |= IPC_CALL_FORWARDED;
-        
-        phone_t *phone;
-        if (phone_get(phoneid, &phone) != EOK) {
-                IPC_SET_RETVAL(call->data, EFORWARD);
-                ipc_answer(&TASK->answerbox, call);
-                return ENOENT;
-        }
-        
-        if (!method_is_forwardable(IPC_GET_IMETHOD(call->data))) {
-                IPC_SET_RETVAL(call->data, EFORWARD);
-                ipc_answer(&TASK->answerbox, call);
-                return EPERM;
-        }
         
         /*
@@ -797 +469 @@
         }
         
-        return ipc_forward(call, phone, &TASK->answerbox, mode);
+        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;
 }