WebSVN – HelenOS – Diff – //branches/network/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 */
     answerbox_t *callerbox = call->callerbox;
     call->flags |= IPC_CALL_ANSWERED;
     if (call->flags & IPC_CALL_FORWARDED) {
-        if (call->data.caller_phone) {
+        if (call->caller_phone) {
             /* Demasquerade the caller phone. */
-            call->data.phone = call->data.caller_phone;
+            call->data.phone = call->caller_phone;
+        }
+    }
     spinlock_lock(&callerbox->lock);
     list_append(&call->link, &callerbox->answers);
     spinlock_lock(&oldbox->lock);
     list_remove(&call->link);
     spinlock_unlock(&oldbox->lock);
     if (mode & IPC_FF_ROUTE_FROM_ME) {
-        if (!call->data.caller_phone)
+        if (!call->caller_phone)
-            call->data.caller_phone = call->data.phone;
+            call->caller_phone = call->data.phone;
         call->data.phone = newphone;
+    }
     return ipc_call(newphone, call);
+}
 /** 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);
+    }
+}
     printf("ABOX - CALLS:\n");
     for (tmp = task->answerbox.calls.next; tmp != &task->answerbox.calls;
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
             " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
-            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call, call->sender->taskid,
+            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
+            call->sender->taskid,
             IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
             call->flags);
+    }
     for (tmp = task->answerbox.dispatched_calls.next;
         tmp != &task->answerbox.dispatched_calls;
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
             " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
-            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call, call->sender->taskid,
+            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
+            call->sender->taskid,
             IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
             call->flags);
+    }
     /* Print answerbox - calls */
     printf("ABOX - ANSWERS:\n");
-    for (tmp = task->answerbox.answers.next; tmp != &task->answerbox.answers;
+    for (tmp = task->answerbox.answers.next;
+        tmp != &task->answerbox.answers;
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid:%p M:%" PRIun " A1:%" PRIun " A2:%" PRIun
             " A3:%" PRIun " A4:%" PRIun " A5:%" PRIun " Flags:%x\n",
             call, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
             call->flags);
+    }

Subversion Repositories HelenOS

(root)//branches/network/kernel/generic/src/ipc/ipc.c – Rev 3386 → 4153