rename cpuXXX_t to cpu_XXX_t

[bertos.git] / bertos / kern / proc.h

diff --git a/bertos/kern/proc.h b/bertos/kern/proc.h
index afb9639f28b68a6c30decee00eae6f220dcc6977..e9a910d4d5fbc466ae7bc217f7e651103b4532a5 100644 (file)
--- a/bertos/kern/proc.h
+++ b/bertos/kern/proc.h
@@ -45,7 +45,7 @@
        #include <cfg/debug.h> // ASSERT()
 #endif
 
-#include <cpu/types.h> // cpustack_t
+#include <cpu/types.h> // cpu_stack_t
 #include <cpu/frame.h> // CPU_SAVED_REGS_CNT
 
 /*
@@ -56,7 +56,7 @@ struct Process;
 
 /* Task scheduling services */
 void proc_init(void);
-struct Process *proc_new_with_name(const char* name, void (*entry)(void), iptr_t data, size_t stacksize, cpustack_t *stack);
+struct Process *proc_new_with_name(const char* name, void (*entry)(void), iptr_t data, size_t stacksize, cpu_stack_t *stack);
 
 #if !CONFIG_KERN_MONITOR
        #define proc_new(entry,data,size,stack) proc_new_with_name(NULL,(entry),(data),(size),(stack))
@@ -95,6 +95,9 @@ const char *proc_currentName(void);
  * \note Calling functions that could sleep while task switching is disabled
  * is dangerous and unsupported.
  *
+ * \note calling proc_forbid() from within an interrupt is illegal and
+ * meaningless.
+ *
  * \note proc_permit() expands inline to 1-2 asm instructions, so it's a
  * very efficient locking primitive in simple but performance-critical
  * situations.  In all other cases, semaphores offer a more flexible and
@@ -105,12 +108,34 @@ const char *proc_currentName(void);
 INLINE void proc_forbid(void)
 {
        #if CONFIG_KERN_PREEMPT
-               // No need to protect against interrupts here.
-               extern int preempt_forbid_cnt;
-               ++preempt_forbid_cnt;
+               extern cpu_atomic_t _preempt_forbid_cnt;
+               /*
+                * We don't need to protect the counter against other processes.
+                * The reason why is a bit subtle.
+                *
+                * If a process gets here, preempt_forbid_cnt can be either 0,
+                * or != 0.  In the latter case, preemption is already disabled
+                * and no concurrency issues can occur.
+                *
+                * In the former case, we could be preempted just after reading the
+                * value 0 from memory, and a concurrent process might, in fact,
+                * bump the value of preempt_forbid_cnt under our nose!
+                *
+                * BUT: if this ever happens, then we won't get another chance to
+                * run until the other process calls proc_permit() to re-enable
+                * preemption.  At this point, the value of preempt_forbid_cnt
+                * must be back to 0, and thus what we had originally read from
+                * memory happens to be valid.
+                *
+                * No matter how hard you think about it, and how complicated you
+                * make your scenario, the above holds true as long as
+                * "preempt_forbid_cnt != 0" means that no task switching is
+                * possible.
+                */
+               ++_preempt_forbid_cnt;
 
                /*
-                * Make sure preempt_forbid_cnt is flushed to memory so the
+                * Make sure _preempt_forbid_cnt is flushed to memory so the
                 * preemption softirq will see the correct value from now on.
                 */
                MEMORY_BARRIER;
@@ -131,14 +156,13 @@ INLINE void proc_permit(void)
                 * flushed to memory before task switching is re-enabled.
                 */
                MEMORY_BARRIER;
-
+               extern cpu_atomic_t _preempt_forbid_cnt;
                /* No need to protect against interrupts here. */
-               extern int preempt_forbid_cnt;
-               --preempt_forbid_cnt;
-               ASSERT(preempt_forbid_cnt >= 0);
+               ASSERT(_preempt_forbid_cnt != 0);
+               --_preempt_forbid_cnt;
 
                /*
-                * This ensures preempt_forbid_cnt is flushed to memory immediately
+                * This ensures _preempt_forbid_cnt is flushed to memory immediately
                 * so the preemption interrupt sees the correct value.
                 */
                MEMORY_BARRIER;
@@ -146,7 +170,20 @@ INLINE void proc_permit(void)
        #endif
 }
 
-extern int preempt_forbid_cnt;
+/**
+ * \return true if preemptive task switching is allowed.
+ * \note This accessor is needed because _preempt_forbid_cnt
+ *       must be absoultely private.
+ */
+INLINE bool proc_allowed(void)
+{
+       #if CONFIG_KERN_PREEMPT
+               extern cpu_atomic_t _preempt_forbid_cnt;
+               return (_preempt_forbid_cnt == 0);
+       #else
+               return true;
+       #endif
+}
 
 /**
  * Execute a block of \a CODE atomically with respect to task scheduling.
@@ -184,7 +221,7 @@ extern int preempt_forbid_cnt;
                 * usage.
                 */
                #define CONFIG_KERN_MINSTACKSIZE  \
-                   (CPU_SAVED_REGS_CNT * 2 * sizeof(cpustack_t) \
+                   (CPU_SAVED_REGS_CNT * 2 * sizeof(cpu_stack_t) \
                    + 32 * sizeof(int))
        #endif
 #endif
@@ -193,23 +230,23 @@ extern int preempt_forbid_cnt;
 #if CONFIG_KERN_MONITOR
        #include <cpu/types.h>
        #if (SIZEOF_CPUSTACK_T == 1)
-               /* 8bit cpustack_t */
+               /* 8bit cpu_stack_t */
                #define CONFIG_KERN_STACKFILLCODE  0xA5
                #define CONFIG_KERN_MEMFILLCODE    0xDB
        #elif (SIZEOF_CPUSTACK_T == 2)
-               /* 16bit cpustack_t */
+               /* 16bit cpu_stack_t */
                #define CONFIG_KERN_STACKFILLCODE  0xA5A5
                #define CONFIG_KERN_MEMFILLCODE    0xDBDB
        #elif (SIZEOF_CPUSTACK_T == 4)
-               /* 32bit cpustack_t */
+               /* 32bit cpu_stack_t */
                #define CONFIG_KERN_STACKFILLCODE  0xA5A5A5A5UL
                #define CONFIG_KERN_MEMFILLCODE    0xDBDBDBDBUL
        #elif (SIZEOF_CPUSTACK_T == 8)
-               /* 64bit cpustack_t */
+               /* 64bit cpu_stack_t */
                #define CONFIG_KERN_STACKFILLCODE  0xA5A5A5A5A5A5A5A5ULL
                #define CONFIG_KERN_MEMFILLCODE    0xDBDBDBDBDBDBDBDBULL
        #else
-               #error No cpustack_t size supported!
+               #error No cpu_stack_t size supported!
        #endif
 #endif