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

     "Entering",
     "Exiting",
     "Undead"
 };
+/** Lock protecting the threads_btree B+tree.
+ *
-/** Lock protecting the threads_btree B+tree. For locking rules, see declaration thereof. */
+ * For locking rules, see declaration thereof.
+ */
 SPINLOCK_INITIALIZE(threads_lock);
 /** B+tree of all threads.
+ *
- * When a thread is found in the threads_btree B+tree, it is guaranteed to exist as long
+ * When a thread is found in the threads_btree B+tree, it is guaranteed to
- * as the threads_lock is held.
+ * exist as long as the threads_lock is held.
  */
 btree_t threads_btree;
 SPINLOCK_INITIALIZE(tidlock);
 uint32_t last_tid = 0;
 static slab_cache_t *thread_slab;
 #ifdef ARCH_HAS_FPU
 slab_cache_t *fpu_context_slab;
 #endif
-/** Thread wrapper
+/** Thread wrapper.
+ *
- * This wrapper is provided to ensure that every thread
+ * This wrapper is provided to ensure that every thread makes a call to
- * makes a call to thread_exit() when its implementing
+ * thread_exit() when its implementing function returns.
- * function returns.
+ *
  * interrupts_disable() is assumed.
+ *
  */
 static void cushion(void)
  */
 void thread_init(void)
+{
     THREAD = NULL;
     atomic_set(&nrdy,0);
-    thread_slab = slab_cache_create("thread_slab",
+    thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0,
-                    sizeof(thread_t),0,
-                    thr_constructor, thr_destructor, 0);
+        thr_constructor, thr_destructor, 0);
 #ifdef ARCH_HAS_FPU
-    fpu_context_slab = slab_cache_create("fpu_slab",
+    fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t),
-                         sizeof(fpu_context_t),
-                         FPU_CONTEXT_ALIGN,
-                         NULL, NULL, 0);
+        FPU_CONTEXT_ALIGN, NULL, NULL, 0);
 #endif
     btree_create(&threads_btree);
+}
     spinlock_lock(&t->lock);
     ASSERT(! (t->state == Ready));
-    i = (t->priority < RQ_COUNT -1) ? ++t->priority : t->priority;
+    i = (t->priority < RQ_COUNT - 1) ? ++t->priority : t->priority;
     cpu = CPU;
     if (t->flags & THREAD_FLAG_WIRED) {
         cpu = t->cpu;
+    }
+ *
  * Assume thread->lock is held!!
  */
 void thread_destroy(thread_t *t)
+{
     bool destroy_task = false;
     ASSERT(t->state == Exiting || t->state == Undead);
     ASSERT(t->task);
     ASSERT(t->cpu);
     spinlock_lock(&t->cpu->lock);
-    if(t->cpu->fpu_owner==t)
+    if(t->cpu->fpu_owner == t)
-        t->cpu->fpu_owner=NULL;
+        t->cpu->fpu_owner = NULL;
     spinlock_unlock(&t->cpu->lock);
     spinlock_unlock(&t->lock);
     spinlock_lock(&threads_lock);
  * @param func      Thread's implementing function.
  * @param arg       Thread's implementing function argument.
  * @param task      Task to which the thread belongs.
  * @param flags     Thread flags.
  * @param name      Symbolic name.
- * @param uncounted Thread's accounting doesn't affect accumulated task accounting.
+ * @param uncounted Thread's accounting doesn't affect accumulated task
+ *   accounting.
+ *
  * @return New thread's structure on success, NULL on failure.
+ *
  */
-thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, int flags, char *name, bool uncounted)
+thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
+    int flags, char *name, bool uncounted)
+{
     thread_t *t;
     ipl_t ipl;
     t = (thread_t *) slab_alloc(thread_slab, 0);
     if (!t)
         return NULL;
     /* Not needed, but good for debugging */
-    memsetb((uintptr_t) t->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0);
+    memsetb((uintptr_t) t->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES,
+);
     ipl = interrupts_disable();
     spinlock_lock(&tidlock);
     t->tid = ++last_tid;
     spinlock_unlock(&tidlock);
     interrupts_restore(ipl);
     context_save(&t->saved_context);
-    context_set(&t->saved_context, FADDR(cushion), (uintptr_t) t->kstack, THREAD_STACK_SIZE);
+    context_set(&t->saved_context, FADDR(cushion), (uintptr_t) t->kstack,
+        THREAD_STACK_SIZE);
     the_initialize((the_t *) t->kstack);
     ipl = interrupts_disable();
     t->saved_context.ipl = interrupts_read();
     t->task = task;
     t->fpu_context_exists = 0;
     t->fpu_context_engaged = 0;
-    thread_create_arch(t);      /* might depend on previous initialization */
+    /* might depend on previous initialization */
+    thread_create_arch(t);
     /*
      * Attach to the containing task.
      */
     ipl = interrupts_disable();
     /*
      * Register this thread in the system-wide list.
      */
     spinlock_lock(&threads_lock);
-    btree_insert(&threads_btree, (btree_key_t) ((uintptr_t) t), (void *) t, NULL);
+    btree_insert(&threads_btree, (btree_key_t) ((uintptr_t) t), (void *) t,
+        NULL);
     spinlock_unlock(&threads_lock);
     interrupts_restore(ipl);
     return t;
+}
 /** Terminate thread.
+ *
- * End current thread execution and switch it to the exiting
+ * End current thread execution and switch it to the exiting state. All pending
- * state. All pending timeouts are executed.
+ * timeouts are executed.
- *
  */
 void thread_exit(void)
+{
     ipl_t ipl;
 restart:
     ipl = interrupts_disable();
     spinlock_lock(&THREAD->lock);
+    if (THREAD->timeout_pending) {
-    if (THREAD->timeout_pending) { /* busy waiting for timeouts in progress */
+        /* busy waiting for timeouts in progress */
         spinlock_unlock(&THREAD->lock);
         interrupts_restore(ipl);
         goto restart;
+    }
     THREAD->state = Exiting;
  * @param sec Number of seconds to sleep.
+ *
  */
 void thread_sleep(uint32_t sec)
+{
-    thread_usleep(sec*1000000);
+    thread_usleep(sec * 1000000);
+}
 /** Wait for another thread to exit.
+ *
  * @param t Thread to join on exit.

Subversion Repositories HelenOS

(root)//trunk/kernel/generic/src/proc/thread.c – Rev 2050 → 2067