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

File:

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

kernel/generic/src/proc/thread.c

@@ -46 +46 @@
 #include <synch/spinlock.h>
 #include <synch/waitq.h>
+#include <synch/workqueue.h>
+#include <synch/rcu.h>
 #include <cpu.h>
 #include <str.h>
@@ -192 +194 @@
         kmflags &= ~FRAME_HIGHMEM;
         
-        thread->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
-        if (!thread->kstack) {
+        uintptr_t stack_phys =
+            frame_alloc(STACK_FRAMES, kmflags, STACK_SIZE - 1);
+        if (!stack_phys) {
 #ifdef CONFIG_FPU
                 if (thread->saved_fpu_context)
@@ -201 +204 @@
         }
         
+        thread->kstack = (uint8_t *) PA2KA(stack_phys);
+        
 #ifdef CONFIG_UDEBUG
         mutex_initialize(&thread->udebug.lock, MUTEX_PASSIVE);
@@ -216 +221 @@
         thr_destructor_arch(thread);
         
-        frame_free(KA2PA(thread->kstack));
+        frame_free(KA2PA(thread->kstack), STACK_FRAMES);
         
 #ifdef CONFIG_FPU
@@ -260 +265 @@
 }
 
+/** Invoked right before thread_ready() readies the thread. thread is locked. */
+static void before_thread_is_ready(thread_t *thread)
+{
+        ASSERT(irq_spinlock_locked(&thread->lock));
+        workq_before_thread_is_ready(thread);
+}
+
 /** Make thread ready
  *
@@ -272 +284 @@
         
         ASSERT(thread->state != Ready);
+
+        before_thread_is_ready(thread);
         
         int i = (thread->priority < RQ_COUNT - 1) ?
             ++thread->priority : thread->priority;
-        
+
         cpu_t *cpu;
         if (thread->wired || thread->nomigrate || thread->fpu_context_engaged) {
+                /* Cannot ready to another CPU */
                 ASSERT(thread->cpu != NULL);
                 cpu = thread->cpu;
-        } else
+        } else if (thread->stolen) {
+                /* Ready to the stealing CPU */
                 cpu = CPU;
+        } else if (thread->cpu) {
+                /* Prefer the CPU on which the thread ran last */
+                ASSERT(thread->cpu != NULL);
+                cpu = thread->cpu;
+        } else {
+                cpu = CPU;
+        }
         
         thread->state = Ready;
@@ -297 +320 @@
         
         atomic_inc(&nrdy);
-        // FIXME: Why is the avg value not used
-        // avg = atomic_get(&nrdy) / config.cpu_active;
         atomic_inc(&cpu->nrdy);
 }
@@ -374 +395 @@
         thread->task = task;
         
+        thread->workq = NULL;
+        
         thread->fpu_context_exists = false;
         thread->fpu_context_engaged = false;
@@ -388 +411 @@
         /* Might depend on previous initialization */
         thread_create_arch(thread);
+        
+        rcu_thread_init(thread);
         
         if ((flags & THREAD_FLAG_NOATTACH) != THREAD_FLAG_NOATTACH)
@@ -498 +523 @@
                          */
                         ipc_cleanup();
-                        futex_cleanup();
+                        futex_task_cleanup();
                         LOG("Cleanup of task %" PRIu64" completed.", TASK->taskid);
                 }
@@ -518 +543 @@
         /* Not reached */
         while (true);
+}
+
+/** Interrupts an existing thread so that it may exit as soon as possible.
+ * 
+ * Threads that are blocked waiting for a synchronization primitive 
+ * are woken up with a return code of ESYNCH_INTERRUPTED if the
+ * blocking call was interruptable. See waitq_sleep_timeout().
+ * 
+ * The caller must guarantee the thread object is valid during the entire
+ * function, eg by holding the threads_lock lock.
+ * 
+ * Interrupted threads automatically exit when returning back to user space.
+ * 
+ * @param thread A valid thread object. The caller must guarantee it
+ *               will remain valid until thread_interrupt() exits.
+ */
+void thread_interrupt(thread_t *thread)
+{
+        ASSERT(thread != NULL);
+        
+        irq_spinlock_lock(&thread->lock, true);
+        
+        thread->interrupted = true;
+        bool sleeping = (thread->state == Sleeping);
+        
+        irq_spinlock_unlock(&thread->lock, true);
+        
+        if (sleeping)
+                waitq_interrupt_sleep(thread);
+}
+
+/** Returns true if the thread was interrupted.
+ * 
+ * @param thread A valid thread object. User must guarantee it will
+ *               be alive during the entire call.
+ * @return true if the thread was already interrupted via thread_interrupt().
+ */
+bool thread_interrupted(thread_t *thread)
+{
+        ASSERT(thread != NULL);
+        
+        bool interrupted;
+        
+        irq_spinlock_lock(&thread->lock, true);
+        interrupted = thread->interrupted;
+        irq_spinlock_unlock(&thread->lock, true);
+        
+        return interrupted;
 }