Changeset 7509ddc in mainline for generic/src/proc/task.c

Timestamp:

2006-06-04T21:54:49Z (19 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

34dcd3f

Parents:

2cb5e64

Message:

Framework for task_kill().
Some pieces (e.g. implementation of ktask_cleanup() kernel thread and
task_destroy() function) are missing.
Changed locking order for task lock, threads_lock and thread lock from
threads_lock, thread lock, task lock to task lock, threads_lock, thread lock.

File:

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

generic/src/proc/task.c

@@ -48 +48 @@
 #include <print.h>
 #include <elf.h>
+#include <errno.h>
 #include <syscall/copy.h>
 
@@ -57 +58 @@
 btree_t tasks_btree;
 static task_id_t task_counter = 0;
+
+static void ktask_cleanup(void *);
 
 /** Initialize tasks
@@ -95 +98 @@
         ta->name = name;
 
+        ta->refcount = 0;
+
         ta->capabilities = 0;
+        ta->accept_new_threads = true;
         
         ipc_answerbox_init(&ta->answerbox);
@@ -128 +134 @@
 }
 
+/** Destroy task.
+ *
+ * @param t Task to be destroyed.
+ */
+void task_destroy(task_t *t)
+{
+}
+
 /** Create new task with 1 thread and run it
  *
@@ -206 +220 @@
         
         return (task_t *) btree_search(&tasks_btree, (btree_key_t) id, &leaf);
+}
+
+/** Kill task.
+ *
+ * @param id ID of the task to be killed.
+ *
+ * @return 0 on success or an error code from errno.h
+ */
+int task_kill(task_id_t id)
+{
+        ipl_t ipl;
+        task_t *ta;
+        thread_t *t;
+        link_t *cur;
+        
+        ipl = interrupts_disable();
+        spinlock_lock(&tasks_lock);
+
+        if (!(ta = task_find_by_id(id))) {
+                spinlock_unlock(&tasks_lock);
+                interrupts_restore(ipl);
+                return ENOENT;
+        }
+        
+        spinlock_lock(&ta->lock);
+        ta->refcount++;
+        spinlock_unlock(&ta->lock);
+        
+        t = thread_create(ktask_cleanup, NULL, ta, 0, "ktask_cleanup");
+        
+        spinlock_lock(&ta->lock);
+        ta->refcount--;
+        
+        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);
+                if (thr == t)
+                        continue;
+                        
+                spinlock_lock(&thr->lock);
+                thr->interrupted = true;
+                if (thr->state == Sleeping)
+                        sleeping = true;
+                spinlock_unlock(&thr->lock);
+                
+                if (sleeping)
+                        waitq_interrupt_sleep(thr);
+        }
+        
+        thread_ready(t);
+        
+        return 0;
 }
 
@@ -244 +312 @@
         interrupts_restore(ipl);
 }
+
+/** Kernel thread used to cleanup the task. */
+void ktask_cleanup(void *arg)
+{
+        /*
+         * TODO:
+         * Wait until it is save to cleanup the task (i.e. all other threads exit)
+         * and do the cleanup (e.g. close IPC communication and release used futexes).
+         * When this thread exits, the task refcount drops to zero and the task structure is
+         * cleaned.
+         */
+}