Changeset 48e7dd6 in mainline

Timestamp:

2006-06-08T09:03:29Z (18 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

22bea15

Parents:

4bc141c

Message:

Collect Undead threads while waiting to join uinit.
Rename ktaskkill to ktaskgc.

Location:

generic

Files:

• include/proc/thread.h (modified) (3 diffs)
• src/proc/task.c (modified) (6 diffs)
• src/proc/thread.c (modified) (1 diff)

generic/include/proc/thread.h

@@ -47 +47 @@
 #define THREAD_STACK_SIZE       STACK_SIZE
 
+/**< Thread states. */
 enum state {
         Invalid,        /**< It is an error, if thread is found in this state. */
@@ -58 +59 @@
 
 extern char *thread_states[];
+
+/**< Join types. */
+typedef enum {
+        None,
+        TaskClnp,       /**< The thread will be joined by ktaskclnp thread. */
+        TaskGC          /**< The thread will be joined by ktaskgc thread. */
+} thread_join_type_t;
 
 #define X_WIRED         (1<<0)
@@ -104 +112 @@
         bool interrupted;                       
         
+        thread_join_type_t      join_type;      /**< Who joinins the thread. */
         bool detached;                          /**< If true, thread_join_timeout() cannot be used on this thread. */
         waitq_t join_wq;                        /**< Waitq for thread_join_timeout(). */

generic/src/proc/task.c

@@ -72 +72 @@
 
 static void ktaskclnp(void *arg);
-static void ktaskkill(void *arg);
+static void ktaskgc(void *arg);
 
 /** Initialize tasks
@@ -222 +222 @@
          * Create killer thread for the new task.
          */
-        t2 = thread_create(ktaskkill, t1, task, 0, "ktaskkill");
+        t2 = thread_create(ktaskgc, t1, task, 0, "ktaskgc");
         ASSERT(t2);
         thread_ready(t2);
@@ -373 +373 @@
         thread_t *t = NULL, *main_thread;
         link_t *cur;
+        bool again;
 
         thread_detach(THREAD);
@@ -385 +386 @@
          * Find a thread to join.
          */
+        again = false;
         for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
                 t = list_get_instance(cur, thread_t, th_link);
-                if (t == THREAD)
+
+                spinlock_lock(&t->lock);
+                if (t == THREAD) {
+                        spinlock_unlock(&t->lock);
                         continue;
-                else if (t == main_thread)
+                } else if (t == main_thread) {
+                        spinlock_unlock(&t->lock);
                         continue;
-                else
+                } else if (t->join_type != None) {
+                        spinlock_unlock(&t->lock);
+                        again = true;
+                        continue;
+                } else {
+                        t->join_type = TaskClnp;
+                        spinlock_unlock(&t->lock);
+                        again = false;
                         break;
+                }
         }
         
@@ -398 +412 @@
         interrupts_restore(ipl);
         
+        if (again) {
+                /*
+                 * Other cleanup (e.g. ktaskgc) is in progress.
+                 */
+                scheduler();
+                goto loop;
+        }
+        
         if (t != THREAD) {
-                ASSERT(t != main_thread);       /* uninit is joined and detached in ktaskkill */
+                ASSERT(t != main_thread);       /* uninit is joined and detached in ktaskgc */
                 thread_join(t);
                 thread_detach(t);
@@ -418 +440 @@
  *
  * This thread waits until the main userspace thread (i.e. uninit) exits.
- * When this happens, the task is killed.
+ * When this happens, the task is killed. In the meantime, exited threads
+ * are garbage collected.
  *
  * @param arg Pointer to the thread structure of the task's main thread.
  */
-void ktaskkill(void *arg)
+void ktaskgc(void *arg)
 {
         thread_t *t = (thread_t *) arg;
-        
+loop:   
         /*
          * Userspace threads cannot detach themselves,
          * therefore the thread pointer is guaranteed to be valid.
          */
-        thread_join(t); /* sleep uninterruptibly here! */
+        if (thread_join_timeout(t, 1000000, SYNCH_FLAGS_NONE) == ESYNCH_TIMEOUT) {      /* sleep uninterruptibly here! */
+                ipl_t ipl;
+                link_t *cur;
+                thread_t *thr = NULL;
+        
+                /*
+                 * The join timed out. Try to do some garbage collection of Undead threads.
+                 */
+more_gc:                
+                ipl = interrupts_disable();
+                spinlock_lock(&TASK->lock);
+                
+                for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
+                        thr = list_get_instance(cur, thread_t, th_link);
+                        spinlock_lock(&thr->lock);
+                        if (thr->state == Undead && thr->join_type == None) {
+                                thr->join_type = TaskGC;
+                                spinlock_unlock(&thr->lock);
+                                break;
+                        }
+                        spinlock_unlock(&thr->lock);
+                        thr = NULL;
+                }
+                spinlock_unlock(&TASK->lock);
+                
+                if (thr) {
+                        thread_join(thr);
+                        thread_detach(thr);
+                        scheduler();
+                        goto more_gc;
+                }
+                        
+                goto loop;
+        }
         thread_detach(t);
         task_kill(TASK->taskid);

generic/src/proc/thread.c

@@ -337 +337 @@
 
         t->interrupted = false; 
+        t->join_type = None;
         t->detached = false;
         waitq_initialize(&t->join_wq);