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

 #include <synch/waitq.h>
 #include <synch/rwlock.h>
 #include <cpu.h>
 #include <func.h>
 #include <context.h>
+#include <adt/btree.h>
 #include <adt/list.h>
 #include <typedefs.h>
 #include <time/clock.h>
 #include <adt/list.h>
 #include <config.h>
 #include <debug.h>
 #include <main/uinit.h>
 char *thread_states[] = {"Invalid", "Running", "Sleeping", "Ready", "Entering", "Exiting"}; /**< Thread states */
-SPINLOCK_INITIALIZE(threads_lock);  /**< Lock protecting threads_head list. For locking rules, see declaration thereof. */
+/** Lock protecting threads_head list. For locking rules, see declaration thereof. */
+SPINLOCK_INITIALIZE(threads_lock);
-LIST_INITIALIZE(threads_head);      /**< List of all threads. */
+btree_t threads_btree;          /**< B+tree of all threads. */
 SPINLOCK_INITIALIZE(tidlock);
 __u32 last_tid = 0;
 static slab_cache_t *thread_slab;
 #ifdef ARCH_HAS_FPU
 slab_cache_t *fpu_context_slab;
 #endif
 /** Thread wrapper
+ *
  * This wrapper is provided to ensure that every thread
  * makes a call to thread_exit() when its implementing
  * function returns.
     spinlock_initialize(&t->lock, "thread_t_lock");
     link_initialize(&t->rq_link);
     link_initialize(&t->wq_link);
     link_initialize(&t->th_link);
-    link_initialize(&t->threads_link);
 #ifdef ARCH_HAS_FPU
 #  ifdef CONFIG_FPU_LAZY
     t->saved_fpu_context = NULL;
 #  else
     fpu_context_slab = slab_cache_create("fpu_slab",
                          sizeof(fpu_context_t),
                          FPU_CONTEXT_ALIGN,
                          NULL, NULL, 0);
 #endif
-}
+    btree_create(&threads_btree);
+}
 /** Make thread ready
+ *
  * Switch thread t to the ready state.
+ *
     atomic_inc(&cpu->nrdy);
     interrupts_restore(ipl);
+}
 /** Destroy thread memory structure
+ *
  * Detach thread from all queues, cpus etc. and destroy it.
+ *
  * Assume thread->lock is held!!
     spinlock_unlock(&t->task->lock);
     spinlock_unlock(&t->lock);
     spinlock_lock(&threads_lock);
-    list_remove(&t->threads_link);
+    btree_remove(&threads_btree, (__native) t, NULL);
     spinlock_unlock(&threads_lock);
     slab_free(thread_slab, t);
+}
 /** Create new thread
+ *
  * Create a new thread.
+ *
  * @param func  Thread's implementing function.
     /*
      * Register this thread in the system-wide list.
      */
     ipl = interrupts_disable();
     spinlock_lock(&threads_lock);
-    list_append(&t->threads_link, &threads_head);
+    btree_insert(&threads_btree, (__native) t, (void *) t, NULL);
     spinlock_unlock(&threads_lock);
     /*
      * Attach to the containing task.
      */
     interrupts_restore(ipl);
     return t;
+}
 /** Make thread exiting
+ *
  * End current thread execution and switch it to the exiting
  * state. All pending timeouts are executed.
+ *
 void thread_sleep(__u32 sec)
+{
     thread_usleep(sec*1000000);
+}
 /** Thread usleep
+ *
  * Suspend execution of the current thread.
+ *
  * @param usec Number of microseconds to sleep.
     waitq_initialize(&wq);
     (void) waitq_sleep_timeout(&wq, usec, SYNCH_NON_BLOCKING);
+}
 /** Register thread out-of-context invocation
+ *
  * Register a function and its argument to be executed
  * on next context switch to the current thread.
+ *
 /** Print list of threads debug info */
 void thread_print_list(void)
+{
     link_t *cur;
-    thread_t *t;
     ipl_t ipl;
     /* Messing with thread structures, avoid deadlock */
     ipl = interrupts_disable();
     spinlock_lock(&threads_lock);
-    for (cur=threads_head.next; cur!=&threads_head; cur=cur->next) {
+    for (cur = threads_btree.leaf_head.next; cur != &threads_btree.leaf_head; cur = cur->next) {
+        btree_node_t *node;
+        int i;
-        t = list_get_instance(cur, thread_t, threads_link);
+        node = list_get_instance(cur, btree_node_t, leaf_link);
+        for (i = 0; i < node->keys; i++) {
+            thread_t *t;
+            t = (thread_t *) node->value[i];
-        printf("%s: address=%P, tid=%d, state=%s, task=%P, code=%P, stack=%P, cpu=",
+            printf("%s: address=%P, tid=%d, state=%s, task=%P, code=%P, stack=%P, cpu=",
-            t->name, t, t->tid, thread_states[t->state], t->task, t->thread_code, t->kstack);
+                t->name, t, t->tid, thread_states[t->state], t->task, t->thread_code, t->kstack);
-        if (t->cpu)
+            if (t->cpu)
-            printf("cpu%d ", t->cpu->id);
+                printf("cpu%d ", t->cpu->id);
-        else
+            else
-            printf("none");
+                printf("none");
-        printf("\n");
+            printf("\n");
+        }
+    }
     spinlock_unlock(&threads_lock);
     interrupts_restore(ipl);
+}
+/** Check whether thread exists.
+ *
+ * Note that threads_lock must be already held and
+ * interrupts must be already disabled.
+ *
+ * @param t Pointer to thread.
+ *
+ * @return True if thread t is known to the system, false otherwise.
+ */
+bool thread_exists(thread_t *t)
+{
+    btree_node_t *leaf;
+    return btree_search(&threads_btree, (__native) t, &leaf) != NULL;
+}
 /** Process syscall to create new thread.
+ *
  */
 __native sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name)
+{

Subversion Repositories HelenOS-historic

(root)//kernel/trunk/generic/src/proc/thread.c – Rev 1138 → 1158