Changeset 43e2cbc in mainline for kernel/generic/src/ipc/ipc.c

Timestamp:

2016-09-10T13:56:43Z (9 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

0b00599

Parents:

838ea8aa

Message:

Implement interruptible wait for messages sent by the kernel

This pertains specifically to handling the IPC_M_PAGE_IN requests
sent by the kernel on behalf of the faulting thread. If the external
pager process does not respond for some reason, the user may decide to
kill the blocked client. That will result in interrupting the client
from the sleep. The kernel will then perform cleanup.

This changeset implements the cleanup by either forgetting the call
(i.e. donating it to the callee) or waiting for the arriving answer,
whichever of the two succeeds.

File:

• kernel/generic/src/ipc/ipc.c (modified) (4 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;
@@ -209 +211 @@
                 return rc;
         }
-        // TODO: forget the call if interrupted
-        (void) ipc_wait_for_call(mybox, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
+
+        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 EOK;
+        return rc;
 }
 
@@ -621 +664 @@
 }
 
+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);
+}
+
 static void ipc_forget_all_active_calls(void)
 {
@@ -649 +722 @@
         }
 
-        /*
-         * 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;