From b9933c2089f5f0cd93738ae9081c45fcf3df54b7 Mon Sep 17 00:00:00 2001
From: gdisirio <gdisirio@35acf78f-673a-0410-8e92-d51de3d6d3f4>
Date: Thu, 11 Aug 2011 17:51:37 +0000
Subject: Implemented system state checker debug option, remove the option
 CH_USE_NESTED_LOCKS. Documentation improvements and fixes.

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@3221 35acf78f-673a-0410-8e92-d51de3d6d3f4
---
 os/kernel/src/chdebug.c | 163 +++++++++++++++++++++++++++++++++++++++++++++---
 os/kernel/src/chmtx.c   |   1 +
 os/kernel/src/chschd.c  |   3 -
 os/kernel/src/chsys.c   |  22 +------
 4 files changed, 157 insertions(+), 32 deletions(-)

(limited to 'os/kernel/src')

diff --git a/os/kernel/src/chdebug.c b/os/kernel/src/chdebug.c
index 0e378cc6d..28d4f7520 100644
--- a/os/kernel/src/chdebug.c
+++ b/os/kernel/src/chdebug.c
@@ -24,18 +24,161 @@
  *
  * @addtogroup debug
  * @details Debug APIs and services:
+ *          - Runtime system state and call protocol check. The following
+ *            panic messages can be generated:
+ *            - SV#1, misplaced @p chSysDisable().
+ *            - SV#2, misplaced @p chSysSuspend()
+ *            - SV#3, misplaced @p chSysEnable().
+ *            - SV#4, misplaced @p chSysLock().
+ *            - SV#5, misplaced @p chSysUnlock().
+ *            - SV#6, misplaced @p chSysLockFromIsr().
+ *            - SV#7, misplaced @p chSysUnlockFromIsr().
+ *            - SV#8, misplaced @p CH_IRQ_PROLOGUE().
+ *            - SV#9, misplaced @p CH_IRQ_EPILOGUE().
+ *            .
  *          - Trace buffer.
  *          - Parameters check.
  *          - Kernel assertions.
+ *          - Kernel panics.
  *          .
- * @pre     In order to use the debug APIs the @p CH_DBG_ENABLE_TRACE,
- *          @p CH_DBG_ENABLE_ASSERTS, @p CH_DBG_ENABLE_CHECKS options must
- *          be enabled in @p chconf.h.
+ * @note    Stack checks are not implemented in this module but in the port
+ *          layer in an architecture-dependent way.
  * @{
  */
 
 #include "ch.h"
 
+/*===========================================================================*/
+/* System state checker related code and variables.                          */
+/*===========================================================================*/
+
+#if CH_DBG_SYSTEM_STATE_CHECK || defined(__DOXYGEN__)
+
+/**
+ * @brief   ISR nesting level.
+ */
+cnt_t dbg_isr_cnt;
+
+/**
+ * @brief   Lock nesting level.
+ */
+cnt_t dbg_lock_cnt;
+
+/**
+ * @brief   Guard code for @p chSysDisable().
+ *
+ * @notapi
+ */
+void dbg_check_disable(void) {
+
+  if ((dbg_isr_cnt != 0) || (dbg_lock_cnt != 0))
+    chDbgPanic("SV#1");
+}
+
+/**
+ * @brief   Guard code for @p chSysSuspend().
+ *
+ * @notapi
+ */
+void dbg_check_suspend(void) {
+
+  if ((dbg_isr_cnt != 0) || (dbg_lock_cnt != 0))
+    chDbgPanic("SV#2");
+}
+
+/**
+ * @brief   Guard code for @p chSysEnable().
+ *
+ * @notapi
+ */
+void dbg_check_enable(void) {
+
+  if ((dbg_isr_cnt != 0) || (dbg_lock_cnt != 0))
+    chDbgPanic("SV#3");
+}
+
+/**
+ * @brief   Guard code for @p chSysLock().
+ *
+ * @notapi
+ */
+void dbg_check_lock(void) {
+
+  if ((dbg_isr_cnt != 0) || (dbg_lock_cnt != 0))
+    chDbgPanic("SV#4");
+  dbg_lock_cnt = 1;
+}
+
+/**
+ * @brief   Guard code for @p chSysUnlock().
+ *
+ * @notapi
+ */
+void dbg_check_unlock(void) {
+
+  if ((dbg_isr_cnt != 0) || (dbg_lock_cnt <= 0))
+    chDbgPanic("SV#5");
+  dbg_lock_cnt = 0;
+}
+
+/**
+ * @brief   Guard code for @p chSysLockFromIsr().
+ *
+ * @notapi
+ */
+void dbg_check_lock_from_isr(void) {
+
+  if ((dbg_isr_cnt <= 0) || (dbg_lock_cnt != 0))
+    chDbgPanic("SV#6");
+  dbg_lock_cnt = 1;
+}
+
+/**
+ * @brief   Guard code for @p chSysUnlockFromIsr().
+ *
+ * @notapi
+ */
+void dbg_check_unlock_from_isr(void) {
+
+  if ((dbg_isr_cnt <= 0) || (dbg_lock_cnt <= 0))
+    chDbgPanic("SV#7");
+  dbg_lock_cnt = 0;
+}
+
+/**
+ * @brief   Guard code for @p CH_IRQ_PROLOGUE().
+ *
+ * @notapi
+ */
+void dbg_check_enter_isr(void) {
+
+  port_lock_from_isr();
+  if (dbg_isr_cnt < 0)
+    chDbgPanic("SV#8");
+  dbg_isr_cnt++;
+  port_unlock_from_isr();
+}
+
+/**
+ * @brief   Guard code for @p CH_IRQ_EPILOGUE().
+ *
+ * @notapi
+ */
+void dbg_check_leave_isr(void) {
+
+  port_lock_from_isr();
+  if (dbg_isr_cnt <= 0)
+    chDbgPanic("SV#9");
+  dbg_isr_cnt--;
+  port_unlock_from_isr();
+}
+
+#endif /* CH_DBG_SYSTEM_STATE_CHECK */
+
+/*===========================================================================*/
+/* Trace related code and variables.                                         */
+/*===========================================================================*/
+
 #if CH_DBG_ENABLE_TRACE || defined(__DOXYGEN__)
 /**
  * @brief   Public trace buffer.
@@ -59,7 +202,7 @@ void _trace_init(void) {
  *
  * @notapi
  */
-void chDbgTrace(Thread *otp) {
+void dbg_trace(Thread *otp) {
 
   dbg_trace_buffer.tb_ptr->se_time   = chTimeNow();
   dbg_trace_buffer.tb_ptr->se_tp     = currp;
@@ -71,13 +214,15 @@ void chDbgTrace(Thread *otp) {
 }
 #endif /* CH_DBG_ENABLE_TRACE */
 
-#if CH_DBG_ENABLE_ASSERTS || CH_DBG_ENABLE_CHECKS ||                        \
-    CH_DBG_ENABLE_STACK_CHECK || defined(__DOXYGEN__)
+/*===========================================================================*/
+/* Panic related code and variables.                                         */
+/*===========================================================================*/
+
+#if CH_DBG_ENABLED || defined(__DOXYGEN__)
 /**
  * @brief   Pointer to the panic message.
  * @details This pointer is meant to be accessed through the debugger, it is
- *          written once and then the system is halted. This variable can be
- *          set to @p NULL if the halt is caused by a stack overflow.
+ *          written once and then the system is halted.
  */
 char *dbg_panic_msg;
 
@@ -91,6 +236,6 @@ void chDbgPanic(char *msg) {
   dbg_panic_msg = msg;
   chSysHalt();
 }
-#endif /* CH_DBG_ENABLE_ASSERTS || CH_DBG_ENABLE_CHECKS || CH_DBG_ENABLE_STACK_CHECK */
+#endif /* CH_DBG_ENABLED */
 
 /** @} */
diff --git a/os/kernel/src/chmtx.c b/os/kernel/src/chmtx.c
index df71d1cc6..21b92e388 100644
--- a/os/kernel/src/chmtx.c
+++ b/os/kernel/src/chmtx.c
@@ -157,6 +157,7 @@ void chMtxLockS(Mutex *mp) {
 #endif
         /* Re-enqueues tp with its new priority on the ready list.*/
         chSchReadyI(dequeue(tp));
+        break;
       }
       break;
     }
diff --git a/os/kernel/src/chschd.c b/os/kernel/src/chschd.c
index d41649b4c..e989f4039 100644
--- a/os/kernel/src/chschd.c
+++ b/os/kernel/src/chschd.c
@@ -113,7 +113,6 @@ void chSchGoSleepS(tstate_t newstate) {
 #endif
   setcurrp(fifo_remove(&rlist.r_queue));
   currp->p_state = THD_STATE_CURRENT;
-  chDbgTrace(otp);
   chSysSwitchI(currp, otp);
 }
 #endif /* !defined(PORT_OPTIMIZED_GOSLEEPS) */
@@ -222,7 +221,6 @@ void chSchWakeupS(Thread *ntp, msg_t msg) {
 #endif
     setcurrp(ntp);
     ntp->p_state = THD_STATE_CURRENT;
-    chDbgTrace(otp);
     chSysSwitchI(ntp, otp);
   }
 }
@@ -247,7 +245,6 @@ void chSchDoRescheduleI(void) {
   setcurrp(fifo_remove(&rlist.r_queue));
   currp->p_state = THD_STATE_CURRENT;
   chSchReadyI(otp);
-  chDbgTrace(otp);
   chSysSwitchI(currp, otp);
 }
 #endif /* !defined(PORT_OPTIMIZED_DORESCHEDULEI) */
diff --git a/os/kernel/src/chsys.c b/os/kernel/src/chsys.c
index 4c8cd708d..6c63e113f 100644
--- a/os/kernel/src/chsys.c
+++ b/os/kernel/src/chsys.c
@@ -98,6 +98,8 @@ void chSysInit(void) {
   setcurrp(_thread_init(&mainthread, NORMALPRIO));
   currp->p_state = THD_STATE_CURRENT;
 #if CH_DBG_ENABLE_STACK_CHECK
+  /* This is a special case because the main thread Thread structure is not
+     adjacent to its stack area.*/
   currp->p_stklimit = &__main_thread_stack_base__;
 #endif
   chSysEnable();
@@ -141,24 +143,4 @@ void chSysTimerHandlerI(void) {
 #endif
 }
 
-#if CH_USE_NESTED_LOCKS && !CH_OPTIMIZE_SPEED
-void chSysLock(void) {
-
-  chDbgAssert(currp->p_locks >= 0,
-              "chSysLock(), #1",
-              "negative nesting counter");
-  if (currp->p_locks++ == 0)
-    port_lock();
-}
-
-void chSysUnlock(void) {
-
-  chDbgAssert(currp->p_locks > 0,
-              "chSysUnlock(), #1",
-              "non-positive nesting counter");
-  if (--currp->p_locks == 0)
-    port_unlock();
-}
-#endif /* CH_USE_NESTED_LOCKS && !CH_OPTIMIZE_SPEED */
-
 /** @} */
-- 
cgit v1.2.3


From 43752ee8d132fc57028a9ff15156c5bfcd81c013 Mon Sep 17 00:00:00 2001
From: gdisirio <gdisirio@35acf78f-673a-0410-8e92-d51de3d6d3f4>
Date: Fri, 12 Aug 2011 11:10:19 +0000
Subject: Extended state check to all kernel I-class and s-class APIs,
 corrected some test cases where call protocol rules were not strictly
 observerd. No the whole test suite pass with the state checker enabled.

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@3223 35acf78f-673a-0410-8e92-d51de3d6d3f4
---
 os/kernel/src/chcond.c     |  4 ++++
 os/kernel/src/chdebug.c    | 34 ++++++++++++++++++++++++++++++++--
 os/kernel/src/chevents.c   |  2 ++
 os/kernel/src/chmboxes.c   |  6 ++++++
 os/kernel/src/chmemcore.c  |  2 ++
 os/kernel/src/chmempools.c |  2 ++
 os/kernel/src/chmtx.c      |  3 +++
 os/kernel/src/chqueues.c   |  8 ++++++++
 os/kernel/src/chschd.c     | 13 ++++++++++++-
 os/kernel/src/chsem.c      | 13 +++++--------
 os/kernel/src/chsys.c      |  2 ++
 os/kernel/src/chthreads.c  |  2 ++
 os/kernel/src/chvt.c       |  2 ++
 13 files changed, 82 insertions(+), 11 deletions(-)

(limited to 'os/kernel/src')

diff --git a/os/kernel/src/chcond.c b/os/kernel/src/chcond.c
index 456fc454f..d1aeb75af 100644
--- a/os/kernel/src/chcond.c
+++ b/os/kernel/src/chcond.c
@@ -86,6 +86,7 @@ void chCondSignal(CondVar *cp) {
  */
 void chCondSignalI(CondVar *cp) {
 
+  chDbgCheckClassI();
   chDbgCheck(cp != NULL, "chCondSignalI");
 
   if (notempty(&cp->c_queue))
@@ -120,6 +121,7 @@ void chCondBroadcast(CondVar *cp) {
  */
 void chCondBroadcastI(CondVar *cp) {
 
+  chDbgCheckClassI();
   chDbgCheck(cp != NULL, "chCondBroadcastI");
 
   /* Empties the condition variable queue and inserts all the Threads into the
@@ -177,6 +179,7 @@ msg_t chCondWaitS(CondVar *cp) {
   Mutex *mp;
   msg_t msg;
 
+  chDbgCheckClassS();
   chDbgCheck(cp != NULL, "chCondWaitS");
   chDbgAssert(ctp->p_mtxlist != NULL,
               "chCondWaitS(), #1",
@@ -261,6 +264,7 @@ msg_t chCondWaitTimeoutS(CondVar *cp, systime_t time) {
   Mutex *mp;
   msg_t msg;
 
+  chDbgCheckClassS();
   chDbgCheck((cp != NULL) && (time != TIME_IMMEDIATE), "chCondWaitTimeoutS");
   chDbgAssert(currp->p_mtxlist != NULL,
               "chCondWaitTimeoutS(), #1",
diff --git a/os/kernel/src/chdebug.c b/os/kernel/src/chdebug.c
index 28d4f7520..8fd081c05 100644
--- a/os/kernel/src/chdebug.c
+++ b/os/kernel/src/chdebug.c
@@ -35,6 +35,8 @@
  *            - SV#7, misplaced @p chSysUnlockFromIsr().
  *            - SV#8, misplaced @p CH_IRQ_PROLOGUE().
  *            - SV#9, misplaced @p CH_IRQ_EPILOGUE().
+ *            - SV#10, misplaced I-class function.
+ *            - SV#11, misplaced S-class function.
  *            .
  *          - Trace buffer.
  *          - Parameters check.
@@ -153,7 +155,7 @@ void dbg_check_unlock_from_isr(void) {
 void dbg_check_enter_isr(void) {
 
   port_lock_from_isr();
-  if (dbg_isr_cnt < 0)
+  if ((dbg_isr_cnt < 0) || (dbg_lock_cnt != 0))
     chDbgPanic("SV#8");
   dbg_isr_cnt++;
   port_unlock_from_isr();
@@ -167,12 +169,40 @@ void dbg_check_enter_isr(void) {
 void dbg_check_leave_isr(void) {
 
   port_lock_from_isr();
-  if (dbg_isr_cnt <= 0)
+  if ((dbg_isr_cnt <= 0) || (dbg_lock_cnt != 0))
     chDbgPanic("SV#9");
   dbg_isr_cnt--;
   port_unlock_from_isr();
 }
 
+/**
+ * @brief   I-class functions context check.
+ * @details Verifies that the system is in an appropriate state for invoking
+ *          an I-class API function. A panic is generated if the state is
+ *          not compatible.
+ *
+ * @api
+ */
+void chDbgCheckClassI(void) {
+
+  if ((dbg_isr_cnt < 0) || (dbg_lock_cnt <= 0))
+    chDbgPanic("SV#10");
+}
+
+/**
+ * @brief   S-class functions context check.
+ * @details Verifies that the system is in an appropriate state for invoking
+ *          an S-class API function. A panic is generated if the state is
+ *          not compatible.
+ *
+ * @api
+ */
+void chDbgCheckClassS(void) {
+
+  if ((dbg_isr_cnt != 0) || (dbg_lock_cnt <= 0))
+    chDbgPanic("SV#11");
+}
+
 #endif /* CH_DBG_SYSTEM_STATE_CHECK */
 
 /*===========================================================================*/
diff --git a/os/kernel/src/chevents.c b/os/kernel/src/chevents.c
index d74ad2dc4..7193e3a12 100644
--- a/os/kernel/src/chevents.c
+++ b/os/kernel/src/chevents.c
@@ -185,6 +185,7 @@ void chEvtSignalFlags(Thread *tp, eventmask_t mask) {
  */
 void chEvtSignalFlagsI(Thread *tp, eventmask_t mask) {
 
+  chDbgCheckClassI();
   chDbgCheck(tp != NULL, "chEvtSignalI");
 
   tp->p_epending |= mask;
@@ -237,6 +238,7 @@ void chEvtBroadcastFlags(EventSource *esp, eventmask_t mask) {
 void chEvtBroadcastFlagsI(EventSource *esp, eventmask_t mask) {
   EventListener *elp;
 
+  chDbgCheckClassI();
   chDbgCheck(esp != NULL, "chEvtBroadcastMaskI");
 
   elp = esp->es_next;
diff --git a/os/kernel/src/chmboxes.c b/os/kernel/src/chmboxes.c
index af6ee5ea8..bf5fdfe29 100644
--- a/os/kernel/src/chmboxes.c
+++ b/os/kernel/src/chmboxes.c
@@ -143,6 +143,7 @@ msg_t chMBPost(Mailbox *mbp, msg_t msg, systime_t time) {
 msg_t chMBPostS(Mailbox *mbp, msg_t msg, systime_t time) {
   msg_t rdymsg;
 
+  chDbgCheckClassS();
   chDbgCheck(mbp != NULL, "chMBPostS");
 
   rdymsg = chSemWaitTimeoutS(&mbp->mb_emptysem, time);
@@ -172,6 +173,7 @@ msg_t chMBPostS(Mailbox *mbp, msg_t msg, systime_t time) {
  */
 msg_t chMBPostI(Mailbox *mbp, msg_t msg) {
 
+  chDbgCheckClassI();
   chDbgCheck(mbp != NULL, "chMBPostI");
 
   if (chSemGetCounterI(&mbp->mb_emptysem) <= 0)
@@ -234,6 +236,7 @@ msg_t chMBPostAhead(Mailbox *mbp, msg_t msg, systime_t time) {
 msg_t chMBPostAheadS(Mailbox *mbp, msg_t msg, systime_t time) {
   msg_t rdymsg;
 
+  chDbgCheckClassS();
   chDbgCheck(mbp != NULL, "chMBPostAheadS");
 
   rdymsg = chSemWaitTimeoutS(&mbp->mb_emptysem, time);
@@ -263,6 +266,7 @@ msg_t chMBPostAheadS(Mailbox *mbp, msg_t msg, systime_t time) {
  */
 msg_t chMBPostAheadI(Mailbox *mbp, msg_t msg) {
 
+  chDbgCheckClassI();
   chDbgCheck(mbp != NULL, "chMBPostAheadI");
 
   if (chSemGetCounterI(&mbp->mb_emptysem) <= 0)
@@ -325,6 +329,7 @@ msg_t chMBFetch(Mailbox *mbp, msg_t *msgp, systime_t time) {
 msg_t chMBFetchS(Mailbox *mbp, msg_t *msgp, systime_t time) {
   msg_t rdymsg;
 
+  chDbgCheckClassS();
   chDbgCheck((mbp != NULL) && (msgp != NULL), "chMBFetchS");
 
   rdymsg = chSemWaitTimeoutS(&mbp->mb_fullsem, time);
@@ -354,6 +359,7 @@ msg_t chMBFetchS(Mailbox *mbp, msg_t *msgp, systime_t time) {
  */
 msg_t chMBFetchI(Mailbox *mbp, msg_t *msgp) {
 
+  chDbgCheckClassI();
   chDbgCheck((mbp != NULL) && (msgp != NULL), "chMBFetchI");
 
   if (chSemGetCounterI(&mbp->mb_fullsem) <= 0)
diff --git a/os/kernel/src/chmemcore.c b/os/kernel/src/chmemcore.c
index 311d170c5..0eac9a429 100644
--- a/os/kernel/src/chmemcore.c
+++ b/os/kernel/src/chmemcore.c
@@ -105,6 +105,8 @@ void *chCoreAlloc(size_t size) {
 void *chCoreAllocI(size_t size) {
   void *p;
 
+  chDbgCheckClassI();
+
   size = MEM_ALIGN_NEXT(size);
   if ((size_t)(endmem - nextmem) < size)
     return NULL;
diff --git a/os/kernel/src/chmempools.c b/os/kernel/src/chmempools.c
index 38adc3d49..767bfda09 100644
--- a/os/kernel/src/chmempools.c
+++ b/os/kernel/src/chmempools.c
@@ -72,6 +72,7 @@ void chPoolInit(MemoryPool *mp, size_t size, memgetfunc_t provider) {
 void *chPoolAllocI(MemoryPool *mp) {
   void *objp;
 
+  chDbgCheckClassI();
   chDbgCheck(mp != NULL, "chPoolAllocI");
 
   if ((objp = mp->mp_next) != NULL)
@@ -114,6 +115,7 @@ void *chPoolAlloc(MemoryPool *mp) {
 void chPoolFreeI(MemoryPool *mp, void *objp) {
   struct pool_header *php = objp;
 
+  chDbgCheckClassI();
   chDbgCheck((mp != NULL) && (objp != NULL) && MEM_IS_ALIGNED(objp),
              "chPoolFreeI");
 
diff --git a/os/kernel/src/chmtx.c b/os/kernel/src/chmtx.c
index 21b92e388..7d5bbe15e 100644
--- a/os/kernel/src/chmtx.c
+++ b/os/kernel/src/chmtx.c
@@ -114,6 +114,7 @@ void chMtxLock(Mutex *mp) {
 void chMtxLockS(Mutex *mp) {
   Thread *ctp = currp;
 
+  chDbgCheckClassS();
   chDbgCheck(mp != NULL, "chMtxLockS");
 
   /* Ia the mutex already locked? */
@@ -225,6 +226,7 @@ bool_t chMtxTryLock(Mutex *mp) {
  */
 bool_t chMtxTryLockS(Mutex *mp) {
 
+  chDbgCheckClassS();
   chDbgCheck(mp != NULL, "chMtxTryLockS");
 
   if (mp->m_owner != NULL)
@@ -309,6 +311,7 @@ Mutex *chMtxUnlockS(void) {
   Thread *ctp = currp;
   Mutex *ump, *mp;
 
+  chDbgCheckClassS();
   chDbgAssert(ctp->p_mtxlist != NULL,
               "chMtxUnlockS(), #1",
               "owned mutexes list empty");
diff --git a/os/kernel/src/chqueues.c b/os/kernel/src/chqueues.c
index 8532f8307..cf3d21732 100644
--- a/os/kernel/src/chqueues.c
+++ b/os/kernel/src/chqueues.c
@@ -108,6 +108,8 @@ void chIQInit(InputQueue *iqp, uint8_t *bp, size_t size, qnotify_t infy) {
  */
 void chIQResetI(InputQueue *iqp) {
 
+  chDbgCheckClassI();
+
   iqp->q_rdptr = iqp->q_wrptr = iqp->q_buffer;
   iqp->q_counter = 0;
   while (notempty(&iqp->q_waiting))
@@ -129,6 +131,8 @@ void chIQResetI(InputQueue *iqp) {
  */
 msg_t chIQPutI(InputQueue *iqp, uint8_t b) {
 
+  chDbgCheckClassI();
+
   if (chIQIsFullI(iqp))
     return Q_FULL;
 
@@ -284,6 +288,8 @@ void chOQInit(OutputQueue *oqp, uint8_t *bp, size_t size, qnotify_t onfy) {
  */
 void chOQResetI(OutputQueue *oqp) {
 
+  chDbgCheckClassI();
+
   oqp->q_rdptr = oqp->q_wrptr = oqp->q_buffer;
   oqp->q_counter = chQSizeI(oqp);
   while (notempty(&oqp->q_waiting))
@@ -349,6 +355,8 @@ msg_t chOQPutTimeout(OutputQueue *oqp, uint8_t b, systime_t time) {
 msg_t chOQGetI(OutputQueue *oqp) {
   uint8_t b;
 
+  chDbgCheckClassI();
+
   if (chOQIsEmptyI(oqp))
     return Q_EMPTY;
 
diff --git a/os/kernel/src/chschd.c b/os/kernel/src/chschd.c
index e989f4039..b481a0b6a 100644
--- a/os/kernel/src/chschd.c
+++ b/os/kernel/src/chschd.c
@@ -75,7 +75,8 @@ void _scheduler_init(void) {
 Thread *chSchReadyI(Thread *tp) {
   Thread *cp;
 
-  /* Integrity check.*/
+  /* Integrity checks.*/
+  chDbgCheckClassI();
   chDbgAssert((tp->p_state != THD_STATE_READY) &&
               (tp->p_state != THD_STATE_FINAL),
               "chSchReadyI(), #1",
@@ -107,6 +108,8 @@ Thread *chSchReadyI(Thread *tp) {
 void chSchGoSleepS(tstate_t newstate) {
   Thread *otp;
 
+  chDbgCheckClassS();
+
   (otp = currp)->p_state = newstate;
 #if CH_TIME_QUANTUM > 0
   rlist.r_preempt = CH_TIME_QUANTUM;
@@ -173,6 +176,8 @@ static void wakeup(void *p) {
  */
 msg_t chSchGoSleepTimeoutS(tstate_t newstate, systime_t time) {
 
+  chDbgCheckClassS();
+
   if (TIME_INFINITE != time) {
     VirtualTimer vt;
 
@@ -207,6 +212,8 @@ msg_t chSchGoSleepTimeoutS(tstate_t newstate, systime_t time) {
 #if !defined(PORT_OPTIMIZED_WAKEUPS) || defined(__DOXYGEN__)
 void chSchWakeupS(Thread *ntp, msg_t msg) {
 
+  chDbgCheckClassS();
+
   ntp->p_u.rdymsg = msg;
   /* If the waken thread has a not-greater priority than the current
      one then it is just inserted in the ready list else it made
@@ -237,6 +244,8 @@ void chSchWakeupS(Thread *ntp, msg_t msg) {
 void chSchDoRescheduleI(void) {
   Thread *otp;
 
+  chDbgCheckClassI();
+
 #if CH_TIME_QUANTUM > 0
   rlist.r_preempt = CH_TIME_QUANTUM;
 #endif
@@ -259,6 +268,8 @@ void chSchDoRescheduleI(void) {
 #if !defined(PORT_OPTIMIZED_RESCHEDULES) || defined(__DOXYGEN__)
 void chSchRescheduleS(void) {
 
+  chDbgCheckClassS();
+
   if (chSchIsRescRequiredI())
     chSchDoRescheduleI();
 }
diff --git a/os/kernel/src/chsem.c b/os/kernel/src/chsem.c
index c22a568ea..bf985bead 100644
--- a/os/kernel/src/chsem.c
+++ b/os/kernel/src/chsem.c
@@ -129,8 +129,8 @@ void chSemReset(Semaphore *sp, cnt_t n) {
 void chSemResetI(Semaphore *sp, cnt_t n) {
   cnt_t cnt;
 
+  chDbgCheckClassI();
   chDbgCheck((sp != NULL) && (n >= 0), "chSemResetI");
-
   chDbgAssert(((sp->s_cnt >= 0) && isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && notempty(&sp->s_queue)),
               "chSemResetI(), #1",
@@ -177,8 +177,8 @@ msg_t chSemWait(Semaphore *sp) {
  */
 msg_t chSemWaitS(Semaphore *sp) {
 
+  chDbgCheckClassS();
   chDbgCheck(sp != NULL, "chSemWaitS");
-
   chDbgAssert(((sp->s_cnt >= 0) && isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && notempty(&sp->s_queue)),
               "chSemWaitS(), #1",
@@ -242,8 +242,8 @@ msg_t chSemWaitTimeout(Semaphore *sp, systime_t time) {
  */
 msg_t chSemWaitTimeoutS(Semaphore *sp, systime_t time) {
 
+  chDbgCheckClassS();
   chDbgCheck(sp != NULL, "chSemWaitTimeoutS");
-
   chDbgAssert(((sp->s_cnt >= 0) && isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && notempty(&sp->s_queue)),
               "chSemWaitTimeoutS(), #1",
@@ -271,7 +271,6 @@ msg_t chSemWaitTimeoutS(Semaphore *sp, systime_t time) {
 void chSemSignal(Semaphore *sp) {
 
   chDbgCheck(sp != NULL, "chSemSignal");
-
   chDbgAssert(((sp->s_cnt >= 0) && isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && notempty(&sp->s_queue)),
               "chSemSignal(), #1",
@@ -296,8 +295,8 @@ void chSemSignal(Semaphore *sp) {
  */
 void chSemSignalI(Semaphore *sp) {
 
+  chDbgCheckClassI();
   chDbgCheck(sp != NULL, "chSemSignalI");
-
   chDbgAssert(((sp->s_cnt >= 0) && isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && notempty(&sp->s_queue)),
               "chSemSignalI(), #1",
@@ -327,8 +326,8 @@ void chSemSignalI(Semaphore *sp) {
  */
 void chSemAddCounterI(Semaphore *sp, cnt_t n) {
 
+  chDbgCheckClassI();
   chDbgCheck((sp != NULL) && (n > 0), "chSemAddCounterI");
-
   chDbgAssert(((sp->s_cnt >= 0) && isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && notempty(&sp->s_queue)),
               "chSemAddCounterI(), #1",
@@ -361,12 +360,10 @@ msg_t chSemSignalWait(Semaphore *sps, Semaphore *spw) {
   msg_t msg;
 
   chDbgCheck((sps != NULL) && (spw != NULL), "chSemSignalWait");
-
   chDbgAssert(((sps->s_cnt >= 0) && isempty(&sps->s_queue)) ||
               ((sps->s_cnt < 0) && notempty(&sps->s_queue)),
               "chSemSignalWait(), #1",
               "inconsistent semaphore");
-
   chDbgAssert(((spw->s_cnt >= 0) && isempty(&spw->s_queue)) ||
               ((spw->s_cnt < 0) && notempty(&spw->s_queue)),
               "chSemSignalWait(), #2",
diff --git a/os/kernel/src/chsys.c b/os/kernel/src/chsys.c
index 6c63e113f..866ee81a8 100644
--- a/os/kernel/src/chsys.c
+++ b/os/kernel/src/chsys.c
@@ -128,6 +128,8 @@ void chSysInit(void) {
  */
 void chSysTimerHandlerI(void) {
 
+  chDbgCheckClassI();
+
 #if CH_TIME_QUANTUM > 0
   /* Running thread has not used up quantum yet? */
   if (rlist.r_preempt > 0)
diff --git a/os/kernel/src/chthreads.c b/os/kernel/src/chthreads.c
index 182de7673..19accdb55 100644
--- a/os/kernel/src/chthreads.c
+++ b/os/kernel/src/chthreads.c
@@ -154,6 +154,8 @@ Thread *chThdCreateI(void *wsp, size_t size,
   /* Thread structure is layed out in the lower part of the thread workspace */
   Thread *tp = wsp;
 
+  chDbgCheckClassI();
+
   chDbgCheck((wsp != NULL) && (size >= THD_WA_SIZE(0)) &&
              (prio <= HIGHPRIO) && (pf != NULL),
              "chThdCreateI");
diff --git a/os/kernel/src/chvt.c b/os/kernel/src/chvt.c
index 4674c728e..fb8e0b0c1 100644
--- a/os/kernel/src/chvt.c
+++ b/os/kernel/src/chvt.c
@@ -70,6 +70,7 @@ void _vt_init(void) {
 void chVTSetI(VirtualTimer *vtp, systime_t time, vtfunc_t vtfunc, void *par) {
   VirtualTimer *p;
 
+  chDbgCheckClassI();
   chDbgCheck((vtp != NULL) && (vtfunc != NULL) && (time != TIME_IMMEDIATE),
              "chVTSetI");
 
@@ -98,6 +99,7 @@ void chVTSetI(VirtualTimer *vtp, systime_t time, vtfunc_t vtfunc, void *par) {
  */
 void chVTResetI(VirtualTimer *vtp) {
 
+  chDbgCheckClassI();
   chDbgCheck(vtp != NULL, "chVTResetI");
   chDbgAssert(vtp->vt_func != NULL,
               "chVTResetI(), #1",
-- 
cgit v1.2.3


From aaad958769e757093a258cfdd5c75f515534fd7a Mon Sep 17 00:00:00 2001
From: gdisirio <gdisirio@35acf78f-673a-0410-8e92-d51de3d6d3f4>
Date: Sat, 13 Aug 2011 07:06:02 +0000
Subject: git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@3224
 35acf78f-673a-0410-8e92-d51de3d6d3f4

---
 os/kernel/src/chschd.c | 74 ++++++++++++++++++++++++--------------------------
 1 file changed, 36 insertions(+), 38 deletions(-)

(limited to 'os/kernel/src')

diff --git a/os/kernel/src/chschd.c b/os/kernel/src/chschd.c
index b481a0b6a..f2014b8c7 100644
--- a/os/kernel/src/chschd.c
+++ b/os/kernel/src/chschd.c
@@ -76,7 +76,6 @@ Thread *chSchReadyI(Thread *tp) {
   Thread *cp;
 
   /* Integrity checks.*/
-  chDbgCheckClassI();
   chDbgAssert((tp->p_state != THD_STATE_READY) &&
               (tp->p_state != THD_STATE_FINAL),
               "chSchReadyI(), #1",
@@ -116,7 +115,7 @@ void chSchGoSleepS(tstate_t newstate) {
 #endif
   setcurrp(fifo_remove(&rlist.r_queue));
   currp->p_state = THD_STATE_CURRENT;
-  chSysSwitchI(currp, otp);
+  chSysSwitch(currp, otp);
 }
 #endif /* !defined(PORT_OPTIMIZED_GOSLEEPS) */
 
@@ -228,36 +227,11 @@ void chSchWakeupS(Thread *ntp, msg_t msg) {
 #endif
     setcurrp(ntp);
     ntp->p_state = THD_STATE_CURRENT;
-    chSysSwitchI(ntp, otp);
+    chSysSwitch(ntp, otp);
   }
 }
 #endif /* !defined(PORT_OPTIMIZED_WAKEUPS) */
 
-/**
- * @brief   Switches to the first thread on the runnable queue.
- * @note    It is intended to be called if @p chSchRescRequiredI() evaluates
- *          to @p TRUE.
- *
- * @iclass
- */
-#if !defined(PORT_OPTIMIZED_DORESCHEDULEI) || defined(__DOXYGEN__)
-void chSchDoRescheduleI(void) {
-  Thread *otp;
-
-  chDbgCheckClassI();
-
-#if CH_TIME_QUANTUM > 0
-  rlist.r_preempt = CH_TIME_QUANTUM;
-#endif
-  otp = currp;
-  /* Picks the first thread from the ready queue and makes it current.*/
-  setcurrp(fifo_remove(&rlist.r_queue));
-  currp->p_state = THD_STATE_CURRENT;
-  chSchReadyI(otp);
-  chSysSwitchI(currp, otp);
-}
-#endif /* !defined(PORT_OPTIMIZED_DORESCHEDULEI) */
-
 /**
  * @brief   Performs a reschedule if a higher priority thread is runnable.
  * @details If a thread with a higher priority than the current thread is in
@@ -271,24 +245,25 @@ void chSchRescheduleS(void) {
   chDbgCheckClassS();
 
   if (chSchIsRescRequiredI())
-    chSchDoRescheduleI();
+    chSchDoReschedule();
 }
 #endif /* !defined(PORT_OPTIMIZED_RESCHEDULES) */
 
 /**
- * @brief   Evaluates if a reschedule is required.
+ * @brief   Evaluates if preemption is required.
  * @details The decision is taken by comparing the relative priorities and
  *          depending on the state of the round robin timeout counter.
- * @note    This function is meant to be used in the timer interrupt handler
- *          where @p chVTDoTickI() is invoked.
+ * @note    Not a user function, it is meant to be invoked by the scheduler
+ *          itself or from within the port layer.
  *
- * @retval TRUE         if there is a thread that should go in running state.
- * @retval FALSE        if a reschedule is not required.
+ * @retval TRUE         if there is a thread that must go in running state
+ *                      immediately.
+ * @retval FALSE        if preemption is not required.
  *
- * @iclass
+ * @special
  */
-#if !defined(PORT_OPTIMIZED_ISRESCHREQUIREDEXI) || defined(__DOXYGEN__)
-bool_t chSchIsRescRequiredExI(void) {
+#if !defined(PORT_OPTIMIZED_ISPREEMPTIONREQUIRED) || defined(__DOXYGEN__)
+bool_t chSchIsPreemptionRequired(void) {
   tprio_t p1 = firstprio(&rlist.r_queue);
   tprio_t p2 = currp->p_prio;
 #if CH_TIME_QUANTUM > 0
@@ -303,6 +278,29 @@ bool_t chSchIsRescRequiredExI(void) {
   return p1 > p2;
 #endif
 }
-#endif /* !defined(PORT_OPTIMIZED_ISRESCHREQUIREDEXI) */
+#endif /* !defined(PORT_OPTIMIZED_ISPREEMPTIONREQUIRED) */
+
+/**
+ * @brief   Switches to the first thread on the runnable queue.
+ * @note    Not a user function, it is meant to be invoked by the scheduler
+ *          itself or from within the port layer.
+ *
+ * @special
+ */
+#if !defined(PORT_OPTIMIZED_DORESCHEDULE) || defined(__DOXYGEN__)
+void chSchDoReschedule(void) {
+  Thread *otp;
+
+#if CH_TIME_QUANTUM > 0
+  rlist.r_preempt = CH_TIME_QUANTUM;
+#endif
+  otp = currp;
+  /* Picks the first thread from the ready queue and makes it current.*/
+  setcurrp(fifo_remove(&rlist.r_queue));
+  currp->p_state = THD_STATE_CURRENT;
+  chSchReadyI(otp);
+  chSysSwitch(currp, otp);
+}
+#endif /* !defined(PORT_OPTIMIZED_DORESCHEDULE) */
 
 /** @} */
-- 
cgit v1.2.3