Changes in kernel/generic/src/ipc/ipc.c [cd529c4:f97f1e51] in mainline

File:

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

kernel/generic/src/ipc/ipc.c

@@ -71 +71 @@
 {
         memsetb(call, sizeof(*call), 0);
+        call->callerbox = &TASK->answerbox;
         call->sender = TASK;
         call->buffer = NULL;
@@ -119 +120 @@
         irq_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);
@@ -161 +163 @@
 }
 
+/** Helper function to facilitate synchronous calls.
+ *
+ * @param phone   Destination kernel phone structure.
+ * @param request Call structure with request.
+ *
+ * @return EOK on success or EINTR if the sleep was interrupted.
+ *
+ */
+int ipc_call_sync(phone_t *phone, call_t *request)
+{
+        answerbox_t *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.
+         */
+        irq_spinlock_lock(&TASK->lock, true);
+        list_append(&sync_box->sync_box_link, &TASK->sync_boxes);
+        irq_spinlock_unlock(&TASK->lock, true);
+        
+        /* We will receive data in a special box. */
+        request->callerbox = sync_box;
+        
+        ipc_call(phone, request);
+        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.
+         */
+        irq_spinlock_lock(&TASK->lock, true);
+        list_remove(&sync_box->sync_box_link);
+        irq_spinlock_unlock(&TASK->lock, true);
+        
+        slab_free(ipc_answerbox_slab, sync_box);
+        return EOK;
+}
+
 /** Answer a message which was not dispatched and is not listed in any queue.
  *
@@ -169 +214 @@
 static void _ipc_answer_free_call(call_t *call, bool selflocked)
 {
-        answerbox_t *callerbox = &call->sender->answerbox;
+        answerbox_t *callerbox = call->callerbox;
         bool do_lock = ((!selflocked) || callerbox != (&TASK->answerbox));
         
@@ -561 +606 @@
         ipc_cleanup_call_list(&TASK->answerbox.calls);
         irq_spinlock_unlock(&TASK->answerbox.lock, true);
+        
+        /* Wait for all answers to interrupted synchronous calls to arrive */
+        ipl_t ipl = interrupts_disable();
+        while (!list_empty(&TASK->sync_boxes)) {
+                answerbox_t *box = list_get_instance(
+                    list_first(&TASK->sync_boxes), answerbox_t, sync_box_link);
+                
+                list_remove(&box->sync_box_link);
+                call_t *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 */