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 1a35834683c13c27db0bdc23a73bd178bd510b45..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,8 +108,30 @@ const char *proc_currentName(void);
 INLINE void proc_forbid(void)
 {
        #if CONFIG_KERN_PREEMPT
-               extern int _preempt_forbid_cnt;
-               // No need to protect against interrupts here.
+               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;
 
                /*
@@ -131,10 +156,10 @@ INLINE void proc_permit(void)
                 * flushed to memory before task switching is re-enabled.
                 */
                MEMORY_BARRIER;
-               extern int _preempt_forbid_cnt;
+               extern cpu_atomic_t _preempt_forbid_cnt;
                /* No need to protect against interrupts here. */
+               ASSERT(_preempt_forbid_cnt != 0);
                --_preempt_forbid_cnt;
-               ASSERT(_preempt_forbid_cnt >= 0);
 
                /*
                 * This ensures _preempt_forbid_cnt is flushed to memory immediately
@@ -153,7 +178,7 @@ INLINE void proc_permit(void)
 INLINE bool proc_allowed(void)
 {
        #if CONFIG_KERN_PREEMPT
-               extern int _preempt_forbid_cnt;
+               extern cpu_atomic_t _preempt_forbid_cnt;
                return (_preempt_forbid_cnt == 0);
        #else
                return true;
@@ -196,7 +221,7 @@ INLINE bool proc_allowed(void)
                 * 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
@@ -205,23 +230,23 @@ INLINE bool proc_allowed(void)
 #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