Changes in kernel/generic/src/proc/task.c [5ab1648:8658f89] in mainline

File:

• kernel/generic/src/proc/task.c (modified) (9 diffs)

kernel/generic/src/proc/task.c

@@ -75 +75 @@
 static task_id_t task_counter = 0;
 
-/* Forward declarations. */
-static void task_kill_internal(task_t *);
-
 /** Initialize kernel tasks support. */
 void task_init(void)
@@ -86 +83 @@
 
 /*
- * The idea behind this walker is to kill and count all tasks different from
+ * The idea behind this walker is to remember a single task different from
  * TASK.
  */
@@ -92 +89 @@
 {
         task_t *t = avltree_get_instance(node, task_t, tasks_tree_node);
-        unsigned *cnt = (unsigned *) arg;
-
-        if (t != TASK) {
-                (*cnt)++;
-#ifdef CONFIG_DEBUG
-                printf("[%"PRIu64"] ", t->taskid);
-#endif
-                task_kill_internal(t);
+        task_t **tp = (task_t **) arg;
+
+        if (t != TASK) { 
+                *tp = t;
+                return false;   /* stop walking */
         }
 
@@ -108 +102 @@
 void task_done(void)
 {
-        unsigned tasks_left;
-
+        task_t *t;
         do { /* Repeat until there are any tasks except TASK */
+                
                 /* Messing with task structures, avoid deadlock */
-#ifdef CONFIG_DEBUG
-                printf("Killing tasks... ");
-#endif
                 ipl_t ipl = interrupts_disable();
                 spinlock_lock(&tasks_lock);
-                tasks_left = 0;
-                avltree_walk(&tasks_tree, task_done_walker, &tasks_left);
-                spinlock_unlock(&tasks_lock);
-                interrupts_restore(ipl);
-                thread_sleep(1);
+                
+                t = NULL;
+                avltree_walk(&tasks_tree, task_done_walker, &t);
+                
+                if (t != NULL) {
+                        task_id_t id = t->taskid;
+                        
+                        spinlock_unlock(&tasks_lock);
+                        interrupts_restore(ipl);
+                        
 #ifdef CONFIG_DEBUG
-                printf("\n");
-#endif
-        } while (tasks_left);
+                        printf("Killing task %" PRIu64 "\n", id);
+#endif                  
+                        task_kill(id);
+                        thread_usleep(10000);
+                } else {
+                        spinlock_unlock(&tasks_lock);
+                        interrupts_restore(ipl);
+                }
+                
+        } while (t != NULL);
 }
 
@@ -197 +200 @@
         interrupts_restore(ipl);
         
+        /*
+         * Notify about task creation.
+         */
+        if (event_is_subscribed(EVENT_WAIT))
+                event_notify_3(EVENT_WAIT, TASK_CREATE, LOWER32(ta->taskid),
+                    UPPER32(ta->taskid));
+        
         return ta;
 }
@@ -228 +238 @@
         if (atomic_predec(&t->as->refcount) == 0) 
                 as_destroy(t->as);
+        
+        /*
+         * Notify about task destruction.
+         */
+        if (event_is_subscribed(EVENT_WAIT))
+                event_notify_3(EVENT_WAIT, TASK_DESTROY, LOWER32(t->taskid),
+                    UPPER32(t->taskid));
         
         free(t);
@@ -333 +350 @@
 }
 
-static void task_kill_internal(task_t *ta)
-{
-        link_t *cur;
-
-        /*
-         * Interrupt all threads.
-         */
-        spinlock_lock(&ta->lock);
-        for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
-                thread_t *thr;
-                bool sleeping = false;
-                
-                thr = list_get_instance(cur, thread_t, th_link);
-                
-                spinlock_lock(&thr->lock);
-                thr->interrupted = true;
-                if (thr->state == Sleeping)
-                        sleeping = true;
-                spinlock_unlock(&thr->lock);
-                
-                if (sleeping)
-                        waitq_interrupt_sleep(thr);
-        }
-        spinlock_unlock(&ta->lock);
-}
-
 /** Kill task.
  *
@@ -372 +363 @@
         ipl_t ipl;
         task_t *ta;
+        link_t *cur;
 
         if (id == 1)
@@ -383 +375 @@
                 return ENOENT;
         }
-        task_kill_internal(ta);
         spinlock_unlock(&tasks_lock);
+        
+        /*
+         * Interrupt all threads.
+         */
+        spinlock_lock(&ta->lock);
+        for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
+                thread_t *thr;
+                bool sleeping = false;
+                
+                thr = list_get_instance(cur, thread_t, th_link);
+                
+                spinlock_lock(&thr->lock);
+                thr->interrupted = true;
+                if (thr->state == Sleeping)
+                        sleeping = true;
+                spinlock_unlock(&thr->lock);
+                
+                if (sleeping)
+                        waitq_interrupt_sleep(thr);
+        }
+        spinlock_unlock(&ta->lock);
         interrupts_restore(ipl);
+        
         return 0;
 }