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

File:

• kernel/generic/src/ipc/ipc.c (modified) (15 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;
@@ -77 +79 @@
         call->forget = false;
         call->sender = NULL;
+        call->callerbox = NULL;
         call->buffer = NULL;
 }
@@ -185 +188 @@
         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;
 }
 
@@ -220 +292 @@
         spinlock_unlock(&call->forget_lock);
 
-        answerbox_t *callerbox = &call->sender->answerbox;
+        answerbox_t *callerbox = call->callerbox ? call->callerbox :
+            &call->sender->answerbox;
         bool do_lock = ((!selflocked) || (callerbox != &TASK->answerbox));
         
@@ -255 +328 @@
 }
 
-static void _ipc_call_actions_internal(phone_t *phone, call_t *call)
+static void _ipc_call_actions_internal(phone_t *phone, call_t *call,
+    bool preforget)
 {
         task_t *caller = phone->caller;
 
-        atomic_inc(&phone->active_calls);
         call->caller_phone = phone;
-        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);
+
+        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->data.phone = phone;
@@ -284 +362 @@
 void ipc_backsend_err(phone_t *phone, call_t *call, sysarg_t err)
 {
-        _ipc_call_actions_internal(phone, call);
+        _ipc_call_actions_internal(phone, call, false);
         IPC_SET_RETVAL(call->data, err);
         _ipc_answer_free_call(call, false);
@@ -291 +369 @@
 /** 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.
- *
- */
-static void _ipc_call(phone_t *phone, answerbox_t *box, call_t *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)
 {
         task_t *caller = phone->caller;
@@ -306 +386 @@
         
         if (!(call->flags & IPC_CALL_FORWARDED))
-                _ipc_call_actions_internal(phone, call);
+                _ipc_call_actions_internal(phone, call, preforget);
         
         irq_spinlock_lock(&box->lock, true);
@@ -340 +420 @@
         
         answerbox_t *box = phone->callee;
-        _ipc_call(phone, box, call);
+        _ipc_call(phone, box, call, false);
         
         mutex_unlock(&phone->lock);
@@ -378 +458 @@
                 call->request_method = IPC_M_PHONE_HUNGUP;
                 call->flags |= IPC_CALL_DISCARD_ANSWER;
-                _ipc_call(phone, box, call);
+                _ipc_call(phone, box, call, false);
         }
         
@@ -537 +617 @@
         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 */
@@ -559 +637 @@
                 
                 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 message to the answerbox for each
-                         * phone. Used to make sure the kbox thread
-                         * wakes up after the last phone has been
-                         * disconnected.
+                         * 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.
                          */
+                        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);
-                        
-                        /* Allocate another call in advance */
-                        call = ipc_call_alloc(0);
+                        _ipc_call(phone, box, call, true);
+
+                        task_release(phone->caller);
                         
                         /* Must start again */
@@ -586 +664 @@
         
         irq_spinlock_unlock(&box->lock, true);
-        
-        /* Free unused call */
-        if (call)
-                ipc_call_free(call);
+}
+
+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);
 }
 
@@ -620 +724 @@
         }
 
-        /*
-         * 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);
+        ipc_forget_call(call);
 
         goto restart;
@@ -755 +837 @@
         ipc_cleanup_call_list(&TASK->answerbox,
             &TASK->answerbox.dispatched_calls);
-
+        
         ipc_forget_all_active_calls();
         ipc_wait_for_all_answered_calls();