Changes in kernel/generic/src/proc/thread.c [f22dc820:c0699467] in mainline

File:

• kernel/generic/src/proc/thread.c (modified) (14 diffs)

kernel/generic/src/proc/thread.c

@@ -173 +173 @@
 #endif /* CONFIG_FPU */
         
-        /*
-         * Allocate the kernel stack from the low-memory to prevent an infinite
-         * nesting of TLB-misses when accessing the stack from the part of the
-         * TLB-miss handler written in C.
-         *
-         * Note that low-memory is safe to be used for the stack as it will be
-         * covered by the kernel identity mapping, which guarantees not to
-         * nest TLB-misses infinitely (either via some hardware mechanism or
-         * by the construciton of the assembly-language part of the TLB-miss
-         * handler).
-         *
-         * This restriction can be lifted once each architecture provides
-         * a similar guarantee, for example by locking the kernel stack
-         * in the TLB whenever it is allocated from the high-memory and the
-         * thread is being scheduled to run.
-         */
-        kmflags |= FRAME_LOWMEM;
-        kmflags &= ~FRAME_HIGHMEM;
-        
         thread->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
         if (!thread->kstack) {
@@ -236 +217 @@
         
         atomic_set(&nrdy, 0);
-        thread_slab = slab_cache_create("thread_t", sizeof(thread_t), 0,
+        thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0,
             thr_constructor, thr_destructor, 0);
         
 #ifdef CONFIG_FPU
-        fpu_context_slab = slab_cache_create("fpu_context_t",
-            sizeof(fpu_context_t), FPU_CONTEXT_ALIGN, NULL, NULL, 0);
+        fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t),
+            FPU_CONTEXT_ALIGN, NULL, NULL, 0);
 #endif
         
@@ -247 +228 @@
 }
 
-/** Wire thread to the given CPU
- *
- * @param cpu CPU to wire the thread to.
- *
- */
-void thread_wire(thread_t *thread, cpu_t *cpu)
+/** Make thread ready
+ *
+ * Switch thread to the ready state.
+ *
+ * @param thread Thread to make ready.
+ *
+ */
+void thread_ready(thread_t *thread)
 {
         irq_spinlock_lock(&thread->lock, true);
-        thread->cpu = cpu;
-        thread->wired = true;
-        irq_spinlock_unlock(&thread->lock, true);
-}
-
-/** Make thread ready
- *
- * Switch thread to the ready state.
- *
- * @param thread Thread to make ready.
- *
- */
-void thread_ready(thread_t *thread)
-{
-        irq_spinlock_lock(&thread->lock, true);
         
         ASSERT(thread->state != Ready);
         
-        int i = (thread->priority < RQ_COUNT - 1) ?
-            ++thread->priority : thread->priority;
-        
-        cpu_t *cpu;
-        if (thread->wired || thread->nomigrate || thread->fpu_context_engaged) {
+        int i = (thread->priority < RQ_COUNT - 1)
+            ? ++thread->priority : thread->priority;
+        
+        cpu_t *cpu = CPU;
+        if (thread->flags & THREAD_FLAG_WIRED) {
                 ASSERT(thread->cpu != NULL);
                 cpu = thread->cpu;
-        } else
-                cpu = CPU;
-        
+        }
         thread->state = Ready;
         
@@ -313 +279 @@
  * @param flags     Thread flags.
  * @param name      Symbolic name (a copy is made).
+ * @param uncounted Thread's accounting doesn't affect accumulated task
+ *                  accounting.
  *
  * @return New thread's structure on success, NULL on failure.
@@ -318 +286 @@
  */
 thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
-    thread_flags_t flags, const char *name)
+    unsigned int flags, const char *name, bool uncounted)
 {
         thread_t *thread = (thread_t *) slab_alloc(thread_slab, 0);
@@ -348 +316 @@
         thread->ucycles = 0;
         thread->kcycles = 0;
-        thread->uncounted =
-            ((flags & THREAD_FLAG_UNCOUNTED) == THREAD_FLAG_UNCOUNTED);
+        thread->uncounted = uncounted;
         thread->priority = -1;          /* Start in rq[0] */
         thread->cpu = NULL;
-        thread->wired = false;
-        thread->stolen = false;
-        thread->uspace =
-            ((flags & THREAD_FLAG_USPACE) == THREAD_FLAG_USPACE);
-        
+        thread->flags = flags;
         thread->nomigrate = 0;
         thread->state = Entering;
@@ -374 +337 @@
         thread->task = task;
         
-        thread->fpu_context_exists = false;
-        thread->fpu_context_engaged = false;
+        thread->fpu_context_exists = 0;
+        thread->fpu_context_engaged = 0;
         
         avltree_node_initialize(&thread->threads_tree_node);
@@ -389 +352 @@
         thread_create_arch(thread);
         
-        if ((flags & THREAD_FLAG_NOATTACH) != THREAD_FLAG_NOATTACH)
+        if (!(flags & THREAD_FLAG_NOATTACH))
                 thread_attach(thread, task);
         
@@ -455 +418 @@
         
         /* Must not count kbox thread into lifecount */
-        if (thread->uspace)
+        if (thread->flags & THREAD_FLAG_USPACE)
                 atomic_inc(&task->lifecount);
         
@@ -477 +440 @@
 void thread_exit(void)
 {
-        if (THREAD->uspace) {
+        if (THREAD->flags & THREAD_FLAG_USPACE) {
 #ifdef CONFIG_UDEBUG
                 /* Generate udebug THREAD_E event */
                 udebug_thread_e_event();
-                
+
                 /*
                  * This thread will not execute any code or system calls from
@@ -524 +487 @@
 {
         ASSERT(THREAD);
-        
+
         THREAD->nomigrate++;
 }
@@ -533 +496 @@
         ASSERT(THREAD);
         ASSERT(THREAD->nomigrate > 0);
-        
-        if (THREAD->nomigrate > 0)
-                THREAD->nomigrate--;
+
+        THREAD->nomigrate--;
 }
 
@@ -873 +835 @@
          * In case of failure, kernel_uarg will be deallocated in this function.
          * In case of success, kernel_uarg will be freed in uinit().
+         *
          */
         uspace_arg_t *kernel_uarg =
@@ -884 +847 @@
         
         thread_t *thread = thread_create(uinit, kernel_uarg, TASK,
-            THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf);
+            THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf, false);
         if (thread) {
                 if (uspace_thread_id != NULL) {