Changes in kernel/generic/src/ipc/ipc.c [287e83f:c713aa56] in mainline

File:

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

kernel/generic/src/ipc/ipc.c

@@ -62 +62 @@
 
 static slab_cache_t *ipc_call_slab;
+static slab_cache_t *ipc_answerbox_slab;
 
 /** Initialize a call structure.
@@ -96 +97 @@
 }
 
-/** Initialize a statically allocated call structure.
- *
- * @param call          Statically allocated kernel call structure to be
- *                      initialized.
- */
-void ipc_call_static_init(call_t *call)
-{
-        _ipc_call_init(call);
-        call->flags |= IPC_CALL_STATIC_ALLOC;
-}
-
 /** Deallocate a call structure.
  *
@@ -113 +103 @@
 void ipc_call_free(call_t *call)
 {
-        ASSERT(!(call->flags & IPC_CALL_STATIC_ALLOC));
         /* Check to see if we have data in the IPC_M_DATA_SEND buffer. */
         if (call->buffer)
@@ -130 +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);
@@ -179 +169 @@
 int ipc_call_sync(phone_t *phone, call_t *request)
 {
-        answerbox_t sync_box; 
-
-        ipc_answerbox_init(&sync_box, TASK);
+        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. */
-        request->callerbox = &sync_box;
+        request->callerbox = sync_box;
 
         ipc_call(phone, request);
-        if (!ipc_wait_for_call(&sync_box, SYNCH_NO_TIMEOUT,
-            SYNCH_FLAGS_INTERRUPTIBLE))
+        if (!ipc_wait_for_call(sync_box, SYNCH_NO_TIMEOUT,
+            SYNCH_FLAGS_INTERRUPTIBLE)) {
+                /* 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;
 }
@@ -196 +212 @@
  *
  * @param call          Call structure to be answered.
- */
-static void _ipc_answer_free_call(call_t *call)
+ * @param selflocked    If true, then TASK->answebox is locked.
+ */
+static void _ipc_answer_free_call(call_t *call, bool selflocked)
 {
         answerbox_t *callerbox = call->callerbox;
+        bool do_lock = ((!selflocked) || callerbox != (&TASK->answerbox));
 
         call->flags |= IPC_CALL_ANSWERED;
@@ -210 +228 @@
         }
 
-        spinlock_lock(&callerbox->lock);
+        if (do_lock)
+                spinlock_lock(&callerbox->lock);
         list_append(&call->link, &callerbox->answers);
-        spinlock_unlock(&callerbox->lock);
+        if (do_lock)
+                spinlock_unlock(&callerbox->lock);
         waitq_wakeup(&callerbox->wq, WAKEUP_FIRST);
 }
@@ -228 +248 @@
         spinlock_unlock(&box->lock);
         /* Send back answer */
-        _ipc_answer_free_call(call);
+        _ipc_answer_free_call(call, false);
 }
 
@@ -245 +265 @@
         atomic_inc(&phone->active_calls);
         IPC_SET_RETVAL(call->data, err);
-        _ipc_answer_free_call(call);
+        _ipc_answer_free_call(call, false);
 }
 
@@ -284 +304 @@
                 if (call->flags & IPC_CALL_FORWARDED) {
                         IPC_SET_RETVAL(call->data, EFORWARD);
-                        _ipc_answer_free_call(call);
+                        _ipc_answer_free_call(call, false);
                 } else {
                         if (phone->state == IPC_PHONE_HUNGUP)
@@ -439 +459 @@
 
                 IPC_SET_RETVAL(call->data, EHANGUP);
-                _ipc_answer_free_call(call);
+                _ipc_answer_free_call(call, true);
         }
 }
@@ -520 +540 @@
         int i;
         call_t *call;
+        ipl_t ipl;
 
         /* Disconnect all our phones ('ipc_phone_hangup') */
@@ -545 +566 @@
         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... */
@@ -552 +587 @@
                 for (i = 0; i < IPC_MAX_PHONES; i++) {
                         if (TASK->phones[i].state == IPC_PHONE_HUNGUP &&
-                            atomic_get(&TASK->phones[i].active_calls) == 0)
+                            atomic_get(&TASK->phones[i].active_calls) == 0) {
                                 TASK->phones[i].state = IPC_PHONE_FREE;
+                                TASK->phones[i].callee = NULL;
+                        }
                         
                         /* Just for sure, we might have had some 
@@ -574 +611 @@
                 ASSERT((call->flags & IPC_CALL_ANSWERED) ||
                     (call->flags & IPC_CALL_NOTIF));
-                ASSERT(!(call->flags & IPC_CALL_STATIC_ALLOC));
                 
                 /*
@@ -593 +629 @@
         ipc_call_slab = slab_cache_create("ipc_call", sizeof(call_t), 0, NULL,
             NULL, 0);
+        ipc_answerbox_slab = slab_cache_create("ipc_answerbox",
+            sizeof(answerbox_t), 0, NULL, NULL, 0);
 }