Changes in kernel/generic/src/ipc/ipc.c [97b8ca9:466e95f7] in mainline

File:

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

kernel/generic/src/ipc/ipc.c

@@ -59 +59 @@
 #include <ipc/irq.h>
 
-static void ipc_forget_call(call_t *);
-
 /** Open channel that is assigned automatically to new tasks */
 answerbox_t *ipc_phone_0 = NULL;
@@ -79 +77 @@
         call->forget = false;
         call->sender = NULL;
-        call->callerbox = NULL;
         call->buffer = NULL;
 }
@@ -188 +185 @@
         phone->state = IPC_PHONE_FREE;
         atomic_set(&phone->active_calls, 0);
-}
-
-/** Helper function to facilitate synchronous calls.
- *
- * @param phone   Destination kernel phone structure.
- * @param request Call structure with request.
- *
- * @return EOK on success or a negative error code.
- *
- */
-int ipc_call_sync(phone_t *phone, call_t *request)
-{
-        answerbox_t *mybox = slab_alloc(ipc_answerbox_slab, 0);
-        ipc_answerbox_init(mybox, TASK);
-        
-        /* We will receive data in a special box. */
-        request->callerbox = mybox;
-        
-        int rc = ipc_call(phone, request);
-        if (rc != EOK) {
-                slab_free(ipc_answerbox_slab, mybox);
-                return rc;
-        }
-
-        call_t *answer = ipc_wait_for_call(mybox, SYNCH_NO_TIMEOUT,
-            SYNCH_FLAGS_INTERRUPTIBLE);
-        if (!answer) {
-
-                /*
-                 * The sleep was interrupted.
-                 *
-                 * There are two possibilities now:
-                 * 1) the call gets answered before we manage to forget it
-                 * 2) we manage to forget the call before it gets answered
-                 */
-
-                spinlock_lock(&request->forget_lock);
-                spinlock_lock(&TASK->active_calls_lock);
-
-                ASSERT(!request->forget);
-
-                bool answered = !request->active;
-                if (!answered) {
-                        /*
-                         * The call is not yet answered and we won the race to
-                         * forget it.
-                         */
-                        ipc_forget_call(request);       /* releases locks */
-                        rc = EINTR;
-                        
-                } else {
-                        spinlock_unlock(&TASK->active_calls_lock);
-                        spinlock_unlock(&request->forget_lock);
-                }
-
-                if (answered) {
-                        /*
-                         * The other side won the race to answer the call.
-                         * It is safe to wait for the answer uninterruptibly
-                         * now.
-                         */
-                        answer = ipc_wait_for_call(mybox, SYNCH_NO_TIMEOUT,
-                            SYNCH_FLAGS_NONE);
-                }
-        }
-        ASSERT(!answer || request == answer);
-        
-        slab_free(ipc_answerbox_slab, mybox);
-        return rc;
 }
 
@@ -292 +220 @@
         spinlock_unlock(&call->forget_lock);
 
-        answerbox_t *callerbox = call->callerbox ? call->callerbox :
-            &call->sender->answerbox;
+        answerbox_t *callerbox = &call->sender->answerbox;
         bool do_lock = ((!selflocked) || (callerbox != &TASK->answerbox));
         
@@ -328 +255 @@
 }
 
-static void _ipc_call_actions_internal(phone_t *phone, call_t *call,
-    bool preforget)
+static void _ipc_call_actions_internal(phone_t *phone, call_t *call)
 {
         task_t *caller = phone->caller;
 
+        atomic_inc(&phone->active_calls);
         call->caller_phone = phone;
-
-        if (preforget) {
-                call->forget = true;
-        } else {
-                atomic_inc(&phone->active_calls);
-                call->sender = caller;
-                call->active = true;
-                spinlock_lock(&caller->active_calls_lock);
-                list_append(&call->ta_link, &caller->active_calls);
-                spinlock_unlock(&caller->active_calls_lock);
-        }
+        call->sender = caller;
+
+        call->active = true;
+        spinlock_lock(&caller->active_calls_lock);
+        list_append(&call->ta_link, &caller->active_calls);
+        spinlock_unlock(&caller->active_calls_lock);
 
         call->data.phone = phone;
@@ -362 +284 @@
 void ipc_backsend_err(phone_t *phone, call_t *call, sysarg_t err)
 {
-        _ipc_call_actions_internal(phone, call, false);
+        _ipc_call_actions_internal(phone, call);
         IPC_SET_RETVAL(call->data, err);
         _ipc_answer_free_call(call, false);
@@ -369 +291 @@
 /** Unsafe unchecking version of ipc_call.
  *
- * @param phone     Phone structure the call comes from.
- * @param box       Destination answerbox structure.
- * @param call      Call structure with request.
- * @param preforget If true, the call will be delivered already forgotten.
- *
- */
-static void _ipc_call(phone_t *phone, answerbox_t *box, call_t *call,
-    bool preforget)
+ * @param phone Phone structure the call comes from.
+ * @param box   Destination answerbox structure.
+ * @param call  Call structure with request.
+ *
+ */
+static void _ipc_call(phone_t *phone, answerbox_t *box, call_t *call)
 {
         task_t *caller = phone->caller;
@@ -386 +306 @@
         
         if (!(call->flags & IPC_CALL_FORWARDED))
-                _ipc_call_actions_internal(phone, call, preforget);
+                _ipc_call_actions_internal(phone, call);
         
         irq_spinlock_lock(&box->lock, true);
@@ -420 +340 @@
         
         answerbox_t *box = phone->callee;
-        _ipc_call(phone, box, call, false);
+        _ipc_call(phone, box, call);
         
         mutex_unlock(&phone->lock);
@@ -458 +378 @@
                 call->request_method = IPC_M_PHONE_HUNGUP;
                 call->flags |= IPC_CALL_DISCARD_ANSWER;
-                _ipc_call(phone, box, call, false);
+                _ipc_call(phone, box, call);
         }
         
@@ -617 +537 @@
         phone_t *phone;
         DEADLOCK_PROBE_INIT(p_phonelck);
+        
+        call_t *call = notify_box ? ipc_call_alloc(0) : NULL;
         
         /* Disconnect all phones connected to our answerbox */
@@ -637 +559 @@
                 
                 if (notify_box) {
-                        task_hold(phone->caller);
                         mutex_unlock(&phone->lock);
                         irq_spinlock_unlock(&box->lock, true);
 
+                        // FIXME: phone can become deallocated at any time now
+
                         /*
-                         * Send one call to the answerbox for each phone.
-                         * Used to make sure the kbox thread wakes up after
-                         * the last phone has been disconnected. The call is
-                         * forgotten upon sending, so the "caller" may cease
-                         * to exist as soon as we release it.
+                         * Send one message to the answerbox for each
+                         * phone. Used to make sure the kbox thread
+                         * wakes up after the last phone has been
+                         * disconnected.
                          */
-                        call_t *call = ipc_call_alloc(0);
                         IPC_SET_IMETHOD(call->data, IPC_M_PHONE_HUNGUP);
                         call->request_method = IPC_M_PHONE_HUNGUP;
                         call->flags |= IPC_CALL_DISCARD_ANSWER;
-                        _ipc_call(phone, box, call, true);
-
-                        task_release(phone->caller);
+                        _ipc_call(phone, box, call);
+                        
+                        /* Allocate another call in advance */
+                        call = ipc_call_alloc(0);
                         
                         /* Must start again */
@@ -664 +586 @@
         
         irq_spinlock_unlock(&box->lock, true);
-}
-
-static void ipc_forget_call(call_t *call)
-{
-        ASSERT(spinlock_locked(&TASK->active_calls_lock));
-        ASSERT(spinlock_locked(&call->forget_lock));
-
-        /*
-         * Forget the call and donate it to the task which holds up the answer.
-         */
-
-        call->forget = true;
-        call->sender = NULL;
-        list_remove(&call->ta_link);
-
-        /*
-         * The call may be freed by _ipc_answer_free_call() before we are done
-         * with it; to avoid working with a destroyed call_t structure, we
-         * must hold a reference to it.
-         */
-        ipc_call_hold(call);
-
-        spinlock_unlock(&call->forget_lock);
-        spinlock_unlock(&TASK->active_calls_lock);
-
-        atomic_dec(&call->caller_phone->active_calls);
-
-        SYSIPC_OP(request_forget, call);
-
-        ipc_call_release(call);
+        
+        /* Free unused call */
+        if (call)
+                ipc_call_free(call);
 }
 
@@ -724 +620 @@
         }
 
-        ipc_forget_call(call);
+        /*
+         * Forget the call and donate it to the task which holds up the answer.
+         */
+
+        call->forget = true;
+        call->sender = NULL;
+        list_remove(&call->ta_link);
+
+        /*
+         * The call may be freed by _ipc_answer_free_call() before we are done
+         * with it; to avoid working with a destroyed call_t structure, we
+         * must hold a reference to it.
+         */
+        ipc_call_hold(call);
+
+        spinlock_unlock(&call->forget_lock);
+        spinlock_unlock(&TASK->active_calls_lock);
+
+        atomic_dec(&call->caller_phone->active_calls);
+
+        SYSIPC_OP(request_forget, call);
+
+        ipc_call_release(call);
 
         goto restart;
@@ -837 +755 @@
         ipc_cleanup_call_list(&TASK->answerbox,
             &TASK->answerbox.dispatched_calls);
-        
+
         ipc_forget_all_active_calls();
         ipc_wait_for_all_answered_calls();
@@ -856 +774 @@
 static void ipc_print_call_list(list_t *list)
 {
-        list_foreach(*list, ab_link, call_t, call) {
+        list_foreach(*list, cur) {
+                call_t *call = list_get_instance(cur, call_t, ab_link);
+                
 #ifdef __32_BITS__
                 printf("%10p ", call);