WebSVN – HelenOS-historic – Diff – /kernel/trunk/generic/src/proc/task.c

 SPINLOCK_INITIALIZE(tasks_lock);
 btree_t tasks_btree;
 static task_id_t task_counter = 0;
-static void ktaskclnp(void *);
+static void ktaskclnp(void *arg);
+static void ktaskkill(void *arg);
 /** Initialize tasks
+ *
  * Initialize kernel tasks support.
+ *
     spinlock_initialize(&ta->lock, "task_ta_lock");
     list_initialize(&ta->th_head);
     ta->as = as;
     ta->name = name;
+    ta->main_thread = NULL;
     ta->refcount = 0;
     ta->capabilities = 0;
     ta->accept_new_threads = true;
 task_t * task_run_program(void *program_addr, char *name)
+{
     as_t *as;
     as_area_t *a;
     int rc;
-    thread_t *t;
+    thread_t *t1, *t2;
     task_t *task;
     uspace_arg_t *kernel_uarg;
     as = as_create(0);
     ASSERT(as);
      */
     a = as_area_create(as, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
         LOADED_PROG_STACK_PAGES_NO*PAGE_SIZE,
         USTACK_ADDRESS, AS_AREA_ATTR_NONE, &anon_backend, NULL);
+    /*
+     * Create the main thread.
+     */
-    t = thread_create(uinit, kernel_uarg, task, 0, "uinit");
+    t1 = thread_create(uinit, kernel_uarg, task, 0, "uinit");
-    ASSERT(t);
+    ASSERT(t1);
-    thread_ready(t);
+    /*
+     * Create killer thread for the new task.
+     */
+    t2 = thread_create(ktaskkill, t1, task, 0, "ktaskkill");
+    ASSERT(t2);
+    thread_ready(t2);
+    thread_ready(t1);
     return task;
+}
 /** Syscall for reading task ID from userspace.
+ *
     t = thread_create(ktaskclnp, NULL, ta, 0, "ktaskclnp");
     spinlock_lock(&ta->lock);
     ta->accept_new_threads = false;
     ta->refcount--;
+    /*
+     * Interrupt all threads except this one.
+     */
     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_unlock(&tasks_lock);
     interrupts_restore(ipl);
+}
-/** Kernel thread used to cleanup the task. */
+/** Kernel thread used to cleanup the task after it is killed. */
 void ktaskclnp(void *arg)
+{
     ipl_t ipl;
-    thread_t *t = NULL;
+    thread_t *t = NULL, *main_thread;
     link_t *cur;
     thread_detach(THREAD);
 loop:
     ipl = interrupts_disable();
     spinlock_lock(&TASK->lock);
+    main_thread = TASK->main_thread;
     /*
      * Find a thread to join.
      */
     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)
             continue;
+        else if (t == main_thread)
+            continue;
         else
             break;
+    }
     spinlock_unlock(&TASK->lock);
     interrupts_restore(ipl);
     if (t != THREAD) {
+        ASSERT(t != main_thread);   /* uninit is joined and detached in ktaskkill */
         thread_join(t);
         thread_detach(t);
-        goto loop;
+        goto loop;  /* go for another thread */
+    }
     /*
      * Now there are no other threads in this task
      * and no new threads can be created.
      */
     ipc_cleanup();
     futex_cleanup();
+}
+/** Kernel task used to kill a userspace task when its main thread exits.
+ *
+ * This thread waits until the main userspace thread (i.e. uninit) exits.
+ * When this happens, the task is killed.
+ *
+ * @param arg Pointer to the thread structure of the task's main thread.
+ */
+void ktaskkill(void *arg)
+{
+    thread_t *t = (thread_t *) arg;
+    /*
+     * Userspace threads cannot detach themselves,
+     * therefore the thread pointer is guaranteed to be valid.
+     */
+    thread_join(t); /* sleep uninterruptibly here! */
+    thread_detach(t);
+    task_kill(TASK->taskid);
+}

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/proc/task.c – Rev 1583 → 1585