WebSVN – HelenOS – Diff – /branches/sparc/kernel/generic/src/ipc/ipc.c

 #include <synch/spinlock.h>
 #include <synch/mutex.h>
 #include <synch/waitq.h>
 #include <synch/synch.h>
 #include <ipc/ipc.h>
+#include <ipc/kbox.h>
 #include <errno.h>
 #include <mm/slab.h>
 #include <arch.h>
 #include <proc/task.h>
 #include <memstr.h>
 #include <debug.h>
 #include <print.h>
+#include <console/console.h>
 #include <proc/thread.h>
 #include <arch/interrupt.h>
 #include <ipc/irq.h>
 /** Open channel that is assigned automatically to new tasks */
 /** Answer all calls from list with EHANGUP answer.
+ *
  * @param lst       Head of the list to be cleaned up.
  */
-static void ipc_cleanup_call_list(link_t *lst)
+void ipc_cleanup_call_list(link_t *lst)
+{
     call_t *call;
     while (!list_empty(lst)) {
         call = list_get_instance(lst->next, call_t, link);
         IPC_SET_RETVAL(call->data, EHANGUP);
         _ipc_answer_free_call(call);
+    }
+}
-/** Cleans up all IPC communication of the current task.
+/** Disconnects all phones connected to an answerbox.
+ *
- * Note: ipc_hangup sets returning answerbox to TASK->answerbox, you
+ * @param box       Answerbox to disconnect phones from.
- * have to change it as well if you want to cleanup other tasks than TASK.
+ * @param notify_box    If true, the answerbox will get a hangup message for
+ *          each disconnected phone.
  */
-void ipc_cleanup(void)
+void ipc_answerbox_slam_phones(answerbox_t *box, bool notify_box)
+{
-    int i;
-    call_t *call;
     phone_t *phone;
     DEADLOCK_PROBE_INIT(p_phonelck);
+    ipl_t ipl;
+    call_t *call;
-    /* Disconnect all our phones ('ipc_phone_hangup') */
-    for (i = 0; i < IPC_MAX_PHONES; i++)
-        ipc_phone_hangup(&TASK->phones[i]);
-    /* Disconnect all connected irqs */
+    call = notify_box ? ipc_call_alloc(0) : NULL;
-    ipc_irq_cleanup(&TASK->answerbox);
     /* Disconnect all phones connected to our answerbox */
 restart_phones:
+    ipl = interrupts_disable();
-    spinlock_lock(&TASK->answerbox.lock);
+    spinlock_lock(&box->lock);
-    while (!list_empty(&TASK->answerbox.connected_phones)) {
+    while (!list_empty(&box->connected_phones)) {
-        phone = list_get_instance(TASK->answerbox.connected_phones.next,
+        phone = list_get_instance(box->connected_phones.next,
             phone_t, link);
         if (SYNCH_FAILED(mutex_trylock(&phone->lock))) {
-            spinlock_unlock(&TASK->answerbox.lock);
+            spinlock_unlock(&box->lock);
+            interrupts_restore(ipl);
             DEADLOCK_PROBE(p_phonelck, DEADLOCK_THRESHOLD);
             goto restart_phones;
+        }
         /* Disconnect phone */
         ASSERT(phone->state == IPC_PHONE_CONNECTED);
-        phone->state = IPC_PHONE_SLAMMED;
         list_remove(&phone->link);
+        phone->state = IPC_PHONE_SLAMMED;
+        if (notify_box) {
+            mutex_unlock(&phone->lock);
+            spinlock_unlock(&box->lock);
+            interrupts_restore(ipl);
+            /*
+             * Send one message to the answerbox for each
+             * phone. Used to make sure the kbox thread
+             * wakes up after the last phone has been
+             * disconnected.
+             */
+            IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
+            call->flags |= IPC_CALL_DISCARD_ANSWER;
+            _ipc_call(phone, box, call);
+            /* Allocate another call in advance */
+            call = ipc_call_alloc(0);
+            /* Must start again */
+            goto restart_phones;
+        }
         mutex_unlock(&phone->lock);
+    }
+    spinlock_unlock(&box->lock);
+    interrupts_restore(ipl);
+    /* Free unused call */
+    if (call)
+        ipc_call_free(call);
+}
+/** Cleans up all IPC communication of the current task.
+ *
+ * Note: ipc_hangup sets returning answerbox to TASK->answerbox, you
+ * have to change it as well if you want to cleanup other tasks than TASK.
+ */
+void ipc_cleanup(void)
+{
+    int i;
+    call_t *call;
+    /* Disconnect all our phones ('ipc_phone_hangup') */
+    for (i = 0; i < IPC_MAX_PHONES; i++)
+        ipc_phone_hangup(&TASK->phones[i]);
+    /* Disconnect all connected irqs */
+    ipc_irq_cleanup(&TASK->answerbox);
+    /* Disconnect all phones connected to our regular answerbox */
+    ipc_answerbox_slam_phones(&TASK->answerbox, false);
+#ifdef CONFIG_UDEBUG
+    /* Clean up kbox thread and communications */
+    ipc_kbox_cleanup();
+#endif
     /* Answer all messages in 'calls' and 'dispatched_calls' queues */
+    spinlock_lock(&TASK->answerbox.lock);
     ipc_cleanup_call_list(&TASK->answerbox.dispatched_calls);
     ipc_cleanup_call_list(&TASK->answerbox.calls);
     spinlock_unlock(&TASK->answerbox.lock);
     /* Wait for all async answers to arrive */
             SYNCH_FLAGS_NONE);
         ASSERT((call->flags & IPC_CALL_ANSWERED) ||
             (call->flags & IPC_CALL_NOTIF));
         ASSERT(!(call->flags & IPC_CALL_STATIC_ALLOC));
+        /*
+         * Record the receipt of this call in the current task's counter
+         * of active calls. IPC_M_PHONE_HUNGUP calls do not contribute
+         * to this counter so do not record answers to them either.
+         */
+        if (!(call->flags & IPC_CALL_DISCARD_ANSWER))
-        atomic_dec(&TASK->active_calls);
+            atomic_dec(&TASK->active_calls);
         ipc_call_free(call);
+    }
+}

Subversion Repositories HelenOS

(root)/branches/sparc/kernel/generic/src/ipc/ipc.c @ 3549 – Rev 3397 → 3492