Changeset 20282ef3 in mainline

Timestamp:

2012-08-26T13:36:41Z (12 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

53af6e8c

Parents:

b1e6269

Message:

When answer_preprocess() wins the race for a call, let it also dequeue
the call from the sender's active list so that we have a real atomic
either-answered-or-forgotten behavior.

This change avoids the possibility that the race is won in
answer_preprocess(), but lost later in _ipc_answer_free_call(), which
would have the effect of skipping some of the necessary call_t cleanup.

Location:

kernel/generic

Files:

• include/ipc/ipc.h (modified) (1 diff)
• src/ipc/ipc.c (modified) (4 diffs)
• src/ipc/sysipc.c (modified) (1 diff)

kernel/generic/include/ipc/ipc.h

@@ -131 +131 @@
          */
         bool forget;
+
+        /** True if the call is in the active list. */
+        bool active;
         
         /**

kernel/generic/src/ipc/ipc.c

@@ -73 +73 @@
         memsetb(call, sizeof(*call), 0);
         spinlock_initialize(&call->forget_lock, "forget_lock");
+        call->active = false;
         call->forget = false;
         call->sender = TASK;
@@ -201 +202 @@
 
                 /*
-                 * 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. 
+                 * If the call is still active, i.e. it was answered
+                 * in a non-standard way, remove the call from the
+                 * sender's active call list.
                  */
-                spinlock_lock(&call->sender->active_calls_lock);
-                list_remove(&call->ta_link);
-                spinlock_unlock(&call->sender->active_calls_lock);
+                if (call->active) {
+                        spinlock_lock(&call->sender->active_calls_lock);
+                        list_remove(&call->ta_link);
+                        spinlock_unlock(&call->sender->active_calls_lock);
+                }
         }
         spinlock_unlock(&call->forget_lock);
@@ -291 +292 @@
         if (!(call->flags & IPC_CALL_FORWARDED)) {
                 atomic_inc(&phone->active_calls);
+
+                call->active = true;
 
                 spinlock_lock(&TASK->active_calls_lock);
@@ -594 +597 @@
         if (!spinlock_trylock(&call->forget_lock)) {
                 /*
-                 * Avoid deadlock and let _ipc_answer_free_call() win the race
-                 * to answer the first call on the list.
+                 * Avoid deadlock and let async_answer() or
+                 *  _ipc_answer_free_call() win the race to dequeue the first
+                 * call on the list.
                  */
                 spinlock_unlock(&TASK->active_calls_lock);      

kernel/generic/src/ipc/sysipc.c

@@ -175 +175 @@
                 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);
+
                 /*
                  * Hold the sender task so that it cannot suddenly disappear