Changeset 31696b4f in mainline for kernel/generic/src/ipc/kbox.c

Timestamp:

2008-11-23T10:59:21Z (16 years ago)

Author:

Jiri Svoboda <jirik.svoboda@…>

Branches:

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

Children:

50e5b25

Parents:

0aa1665

Message:

Move stuff related to kbox to a separate struct.

File:

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

kernel/generic/src/ipc/kbox.c

@@ -49 +49 @@
         bool have_kb_thread;
 
-        /* Only hold kb_cleanup_lock while setting kb_finished - this is enough */
-        mutex_lock(&TASK->kb_cleanup_lock);
-        TASK->kb_finished = true;
-        mutex_unlock(&TASK->kb_cleanup_lock);
-
-        have_kb_thread = (TASK->kb_thread != NULL);
-
-        /* From now on nobody will try to connect phones or attach kbox threads */
+        /* 
+         * Only hold kb.cleanup_lock while setting kb.finished -
+         * this is enough.
+         */
+        mutex_lock(&TASK->kb.cleanup_lock);
+        TASK->kb.finished = true;
+        mutex_unlock(&TASK->kb.cleanup_lock);
+
+        have_kb_thread = (TASK->kb.thread != NULL);
+
+        /*
+         * From now on nobody will try to connect phones or attach
+         * kbox threads
+         */
 
         /*
@@ -64 +70 @@
          * wake up and terminate.
          */
-        ipc_answerbox_slam_phones(&TASK->kernel_box, have_kb_thread);
+        ipc_answerbox_slam_phones(&TASK->kb.box, have_kb_thread);
 
         /* 
@@ -78 +84 @@
         
         if (have_kb_thread) {
-                LOG("join kb_thread..\n");
-                thread_join(TASK->kb_thread);
-                thread_detach(TASK->kb_thread);
+                LOG("join kb.thread..\n");
+                thread_join(TASK->kb.thread);
+                thread_detach(TASK->kb.thread);
                 LOG("join done\n");
-                TASK->kb_thread = NULL;
-        }
-
-        /* Answer all messages in 'calls' and 'dispatched_calls' queues */
-        spinlock_lock(&TASK->kernel_box.lock);
-        ipc_cleanup_call_list(&TASK->kernel_box.dispatched_calls);
-        ipc_cleanup_call_list(&TASK->kernel_box.calls);
-        spinlock_unlock(&TASK->kernel_box.lock);
+                TASK->kb.thread = NULL;
+        }
+
+        /* Answer all messages in 'calls' and 'dispatched_calls' queues. */
+        spinlock_lock(&TASK->kb.box.lock);
+        ipc_cleanup_call_list(&TASK->kb.box.dispatched_calls);
+        ipc_cleanup_call_list(&TASK->kb.box.calls);
+        spinlock_unlock(&TASK->kb.box.lock);
 }
 
@@ -106 +112 @@
         /* Was it our debugger, who hung up? */
         if (call->sender == TASK->udebug.debugger) {
-                /* Terminate debugging session (if any) */
+                /* Terminate debugging session (if any). */
                 LOG("kbox: terminate debug session\n");
                 ipl = interrupts_disable();
@@ -119 +125 @@
         LOG("kbox: continue with hangup message\n");
         IPC_SET_RETVAL(call->data, 0);
-        ipc_answer(&TASK->kernel_box, call);
+        ipc_answer(&TASK->kb.box, call);
 
         ipl = interrupts_disable();
@@ -131 +137 @@
 
                 /* Only detach kbox thread unless already terminating. */
-                mutex_lock(&TASK->kb_cleanup_lock);
-                if (&TASK->kb_finished == false) {
+                mutex_lock(&TASK->kb.cleanup_lock);
+                if (&TASK->kb.finished == false) {
                         /* Detach kbox thread so it gets freed from memory. */
-                        thread_detach(TASK->kb_thread);
-                        TASK->kb_thread = NULL;
+                        thread_detach(TASK->kb.thread);
+                        TASK->kb.thread = NULL;
                 }
-                mutex_unlock(&TASK->kb_cleanup_lock);
+                mutex_unlock(&TASK->kb.cleanup_lock);
 
                 LOG("phone list is empty\n");
@@ -167 +173 @@
 
         while (!done) {
-                call = ipc_wait_for_call(&TASK->kernel_box, SYNCH_NO_TIMEOUT,
+                call = ipc_wait_for_call(&TASK->kb.box, SYNCH_NO_TIMEOUT,
                         SYNCH_FLAGS_NONE);
 
@@ -202 +208 @@
  * Connect phone to a task kernel-box specified by id.
  *
- * Note that this is not completely atomic. For optimisation reasons,
- * The task might start cleaning up kbox after the phone has been connected
- * and before a kbox thread has been created. This must be taken into account
- * in the cleanup code.
+ * Note that this is not completely atomic. For optimisation reasons, the task
+ * might start cleaning up kbox after the phone has been connected and before
+ * a kbox thread has been created. This must be taken into account in the
+ * cleanup code.
  *
  * @return              Phone id on success, or negative error code.
@@ -231 +237 @@
         interrupts_restore(ipl);
 
-        mutex_lock(&ta->kb_cleanup_lock);
+        mutex_lock(&ta->kb.cleanup_lock);
 
         if (atomic_predec(&ta->refcount) == 0) {
-                mutex_unlock(&ta->kb_cleanup_lock);
+                mutex_unlock(&ta->kb.cleanup_lock);
                 task_destroy(ta);
                 return ENOENT;
         }
 
-        if (ta->kb_finished != false) {
-                mutex_unlock(&ta->kb_cleanup_lock);
+        if (ta->kb.finished != false) {
+                mutex_unlock(&ta->kb.cleanup_lock);
                 return EINVAL;
         }
@@ -246 +252 @@
         newphid = phone_alloc();
         if (newphid < 0) {
-                mutex_unlock(&ta->kb_cleanup_lock);
+                mutex_unlock(&ta->kb.cleanup_lock);
                 return ELIMIT;
         }
 
         /* Connect the newly allocated phone to the kbox */
-        ipc_phone_connect(&TASK->phones[newphid], &ta->kernel_box);
-
-        if (ta->kb_thread != NULL) {
-                mutex_unlock(&ta->kb_cleanup_lock);
+        ipc_phone_connect(&TASK->phones[newphid], &ta->kb.box);
+
+        if (ta->kb.thread != NULL) {
+                mutex_unlock(&ta->kb.cleanup_lock);
                 return newphid;
         }
 
         /* Create a kbox thread */
-        kb_thread = thread_create(kbox_thread_proc, NULL, ta, 0, "kbox", false);
+        kb_thread = thread_create(kbox_thread_proc, NULL, ta, 0,
+            "kbox", false);
         if (!kb_thread) {
-                mutex_unlock(&ta->kb_cleanup_lock);
+                mutex_unlock(&ta->kb.cleanup_lock);
                 return ENOMEM;
         }
 
-        ta->kb_thread = kb_thread;
+        ta->kb.thread = kb_thread;
         thread_ready(kb_thread);
 
-        mutex_unlock(&ta->kb_cleanup_lock);
+        mutex_unlock(&ta->kb.cleanup_lock);
 
         return newphid;