Changeset 33adc6ce in mainline

Timestamp:

2009-11-21T10:26:29Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

fd1210a

Parents:

c70ce74

Message:

Introduce the per-task list of active synchronous answerboxes and make
ipc_cleanup() aware of it.

Location:

kernel/generic

Files:

• include/ipc/ipc.h (modified) (1 diff)
• include/proc/task.h (modified) (1 diff)
• src/ipc/ipc.c (modified) (5 diffs)
• src/ipc/sysipc.c (modified) (2 diffs)
• src/proc/task.c (modified) (1 diff)

kernel/generic/include/ipc/ipc.h

@@ -264 +264 @@
 
         waitq_t wq;
+
+        /** Linkage for the list of task's synchronous answerboxes. */
+        link_t sync_box_link;
 
         /** Phones connected to this answerbox. */

kernel/generic/include/proc/task.h

@@ -98 +98 @@
          */
         atomic_t active_calls;
+        /** List of synchronous answerboxes. */
+        link_t sync_box_head;
 
 #ifdef CONFIG_UDEBUG

kernel/generic/src/ipc/ipc.c

@@ -119 +119 @@
         spinlock_initialize(&box->irq_lock, "ipc_box_irqlock");
         waitq_initialize(&box->wq);
+        link_initialize(&box->sync_box_link);
         list_initialize(&box->connected_phones);
         list_initialize(&box->calls);
@@ -169 +170 @@
 {
         answerbox_t *sync_box; 
+        ipl_t ipl;
 
         sync_box = slab_alloc(ipc_answerbox_slab, 0);
         ipc_answerbox_init(sync_box, TASK);
+
+        /*
+         * Put the answerbox on the TASK's list of synchronous answerboxes so
+         * that it can be cleaned up if the call is interrupted.
+         */
+        ipl = interrupts_disable();
+        spinlock_lock(&TASK->lock);
+        list_append(&sync_box->sync_box_link, &TASK->sync_box_head);
+        spinlock_unlock(&TASK->lock);
+        interrupts_restore(ipl);
 
         /* We will receive data in a special box. */
@@ -179 +191 @@
         if (!ipc_wait_for_call(sync_box, SYNCH_NO_TIMEOUT,
             SYNCH_FLAGS_INTERRUPTIBLE)) {
-                /* The asnwerbox will be freed by someone else. */
+                /* The answerbox and the call will be freed by ipc_cleanup(). */
                 return EINTR;
         }
+
+        /*
+         * The answer arrived without interruption so we can remove the
+         * answerbox from the TASK's list of synchronous answerboxes.
+         */
+        (void) interrupts_disable();
+        spinlock_lock(&TASK->lock);
+        list_remove(&sync_box->sync_box_link);
+        spinlock_unlock(&TASK->lock);
+        interrupts_restore(ipl);
+
         slab_free(ipc_answerbox_slab, sync_box);
         return EOK;
@@ -513 +536 @@
         int i;
         call_t *call;
+        ipl_t ipl;
 
         /* Disconnect all our phones ('ipc_phone_hangup') */
@@ -538 +562 @@
         spinlock_unlock(&TASK->answerbox.lock);
         
-        /* Wait for all async answers to arrive */
+        /* Wait for all answers to interrupted synchronous calls to arrive */
+        ipl = interrupts_disable();
+        while (!list_empty(&TASK->sync_box_head)) {
+                answerbox_t *box = list_get_instance(TASK->sync_box_head.next,
+                    answerbox_t, sync_box_link);
+
+                list_remove(&box->sync_box_link);
+                call = ipc_wait_for_call(box, SYNCH_NO_TIMEOUT,
+                    SYNCH_FLAGS_NONE);
+                ipc_call_free(call);
+                slab_free(ipc_answerbox_slab, box);
+        }
+        interrupts_restore(ipl);
+
+        /* Wait for all answers to asynchronous calls to arrive */
         while (1) {
                 /* Go through all phones, until all are FREE... */

kernel/generic/src/ipc/sysipc.c

@@ -559 +559 @@
 #endif
                 if (rc != EOK) {
-                        /* The call will be freed by someone else. */
+                        /* The call will be freed by ipc_cleanup(). */
                         return rc;
                 }
@@ -612 +612 @@
 #endif
                 if (rc != EOK) {
-                        /* The call will be freed by someone else. */
+                        /* The call will be freed by ipc_cleanup(). */
                         return rc;
                 }

kernel/generic/src/proc/task.c

@@ -178 +178 @@
                 ipc_phone_connect(&ta->phones[0], ipc_phone_0);
         atomic_set(&ta->active_calls, 0);
+        list_initialize(&ta->sync_box_head);
 
         mutex_initialize(&ta->futexes_lock, MUTEX_PASSIVE);