Changeset b23c88e in mainline

Timestamp:

2012-07-11T05:45:48Z (12 years ago)

Author:

Adam Hraska <adam.hraska+hos@…>

Branches:

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

Children:

b68ae24

Parents:

9f8745c5

Message:

preemption_disable: Replaced memory barriers with compiler barriers. Added checks if reschedule is needed once preemption is enabled.

Location:

kernel/generic

Files:

• include/arch.h (modified) (1 diff)
• include/preemption.h (modified) (1 diff)
• include/proc/thread.h (modified) (1 diff)
• src/preempt/preemption.c (modified) (3 diffs)
• src/proc/scheduler.c (modified) (2 diffs)
• src/proc/thread.c (modified) (1 diff)
• src/time/clock.c (modified) (1 diff)

kernel/generic/include/arch.h

@@ -53 +53 @@
 #define TASK                 THE->task
 #define AS                   THE->as
-#define PREEMPTION_DISABLED  THE->preemption_disabled
+#define PREEMPTION_DISABLED  (0 != THE->preemption_disabled)
+#define PREEMPTION_ENABLED   (0 == THE->preemption_disabled)
 #define MAGIC                UINT32_C(0xfacefeed)
 

kernel/generic/include/preemption.h

@@ -38 +38 @@
 extern void preemption_disable(void);
 extern void preemption_enable(void);
+extern void preemption_enable_noresched(void);
+extern void preemption_enabled_scheduler(void);
+
+
 
 #endif

kernel/generic/include/proc/thread.h

@@ -155 +155 @@
         state_t state;
         
+        /** The thread would have been rescheduled had it not disabled preemption.*/
+        bool need_resched;
+        
         /** Thread CPU. */
         cpu_t *cpu;

kernel/generic/src/preempt/preemption.c

@@ -38 +38 @@
 #include <preemption.h>
 #include <arch.h>
-#include <arch/asm.h>
-#include <arch/barrier.h>
+#include <compiler/barrier.h>
 #include <debug.h>
+#include <proc/scheduler.h>
 
 /** Increment preemption disabled counter. */
@@ -46 +46 @@
 {
         THE->preemption_disabled++;
-        memory_barrier();
+        compiler_barrier();
 }
 
@@ -52 +52 @@
 void preemption_enable(void)
 {
+        preemption_enable_noresched();
+        
+        if (PREEMPTION_ENABLED && THREAD && THREAD->need_resched) {
+                preemption_enabled_scheduler();
+        }
+}
+
+/** Decrement preemption disabled counter. */
+void preemption_enable_noresched(void)
+{
         ASSERT(PREEMPTION_DISABLED);
-        memory_barrier();
+        compiler_barrier();
         THE->preemption_disabled--;
+}
+
+/** Preemption was enabled. Calls scheduler(). */
+void preemption_enabled_scheduler(void)
+{
+        ASSERT(PREEMPTION_ENABLED);
+        
+        /* 
+         * Avoid a race between a thread about to invoke the scheduler() 
+         * after checking THREAD->need_resched and an interrupt that
+         * occurs right after the check.
+         * 
+         * Also ensures that code that relies on disabled interrupts
+         * to suppress preemption continues to work.
+         */
+        if (!interrupts_disabled()) {
+                scheduler();
+        }
 }
 

kernel/generic/src/proc/scheduler.c

@@ -404 +404 @@
         ASSERT((!THREAD) || (irq_spinlock_locked(&THREAD->lock)));
         ASSERT(CPU != NULL);
+        ASSERT(interrupts_disabled());
         
         /*
@@ -419 +420 @@
                 /* Must be run after the switch to scheduler stack */
                 after_thread_ran();
+                
+                THREAD->need_resched = false;
                 
                 switch (THREAD->state) {

kernel/generic/src/proc/thread.c

@@ -375 +375 @@
         thread->nomigrate = 0;
         thread->state = Entering;
+        thread->need_resched = false;
         
         timeout_initialize(&thread->sleep_timeout);

kernel/generic/src/time/clock.c

@@ -212 +212 @@
                 irq_spinlock_unlock(&THREAD->lock, false);
                 
-                if ((!ticks) && (!PREEMPTION_DISABLED)) {
-                        scheduler();
+                if (ticks == 0) {
+                        if (PREEMPTION_ENABLED) {
+                                scheduler();
 #ifdef CONFIG_UDEBUG
-                        /*
-                         * Give udebug chance to stop the thread
-                         * before it begins executing userspace code.
-                         */
-                        istate_t *istate = THREAD->udebug.uspace_state;
-                        if ((istate) && (istate_from_uspace(istate)))
-                                udebug_before_thread_runs();
+                                /*
+                                * Give udebug chance to stop the thread
+                                * before it begins executing userspace code.
+                                */
+                                istate_t *istate = THREAD->udebug.uspace_state;
+                                if ((istate) && (istate_from_uspace(istate)))
+                                        udebug_before_thread_runs();
 #endif
+                        } else {
+                                THREAD->need_resched = true;
+                        }
                 }
         }