MISRA-related fixes.
git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@7711 35acf78f-673a-0410-8e92-d51de3d6d3f4
This commit is contained in:
parent
3d1a86e9fb
commit
fbd65c1f6a
|
@ -267,8 +267,9 @@ static inline void chBSemSignalI(binary_semaphore_t *bsp) {
|
|||
|
||||
chDbgCheckClassI();
|
||||
|
||||
if (bsp->bs_sem.s_cnt < 1)
|
||||
if (bsp->bs_sem.s_cnt < 1) {
|
||||
chSemSignalI(&bsp->bs_sem);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -165,8 +165,9 @@ typedef struct {
|
|||
*/
|
||||
#if !defined(chDbgCheck)
|
||||
#define chDbgCheck(c) do { \
|
||||
if (CH_DBG_ENABLE_CHECKS && !(c)) \
|
||||
if (CH_DBG_ENABLE_CHECKS && !(c)) { \
|
||||
chSysHalt(__func__); \
|
||||
} \
|
||||
} while (0)
|
||||
#endif /* !defined(chDbgCheck) */
|
||||
|
||||
|
@ -186,8 +187,9 @@ typedef struct {
|
|||
*/
|
||||
#if !defined(chDbgAssert)
|
||||
#define chDbgAssert(c, r) do { \
|
||||
if (CH_DBG_ENABLE_ASSERTS && !(c)) \
|
||||
if (CH_DBG_ENABLE_ASSERTS && !(c)) { \
|
||||
chSysHalt(__func__); \
|
||||
} \
|
||||
} while (0)
|
||||
#endif /* !defined(chDbgAssert) */
|
||||
/** @} */
|
||||
|
|
|
@ -48,6 +48,7 @@
|
|||
#if CH_CFG_USE_DYNAMIC && !CH_CFG_USE_WAITEXIT
|
||||
#error "CH_CFG_USE_DYNAMIC requires CH_CFG_USE_WAITEXIT"
|
||||
#endif
|
||||
|
||||
#if CH_CFG_USE_DYNAMIC && !CH_CFG_USE_HEAP && !CH_CFG_USE_MEMPOOLS
|
||||
#error "CH_CFG_USE_DYNAMIC requires CH_CFG_USE_HEAP and/or CH_CFG_USE_MEMPOOLS"
|
||||
#endif
|
||||
|
|
|
@ -613,6 +613,7 @@ static inline thread_t *list_remove(threads_list_t *tlp) {
|
|||
|
||||
thread_t *tp = tlp->p_next;
|
||||
tlp->p_next = tp->p_next;
|
||||
|
||||
return tp;
|
||||
}
|
||||
|
||||
|
@ -638,6 +639,7 @@ static inline thread_t *queue_fifo_remove(threads_queue_t *tqp) {
|
|||
thread_t *tp = tqp->p_next;
|
||||
|
||||
(tqp->p_next = tp->p_next)->p_prev = (thread_t *)tqp;
|
||||
|
||||
return tp;
|
||||
}
|
||||
|
||||
|
@ -645,6 +647,7 @@ static inline thread_t *queue_lifo_remove(threads_queue_t *tqp) {
|
|||
thread_t *tp = tqp->p_prev;
|
||||
|
||||
(tqp->p_prev = tp->p_prev)->p_next = (thread_t *)tqp;
|
||||
|
||||
return tp;
|
||||
}
|
||||
|
||||
|
@ -652,6 +655,7 @@ static inline thread_t *queue_dequeue(thread_t *tp) {
|
|||
|
||||
tp->p_prev->p_next = tp->p_next;
|
||||
tp->p_next->p_prev = tp->p_prev;
|
||||
|
||||
return tp;
|
||||
}
|
||||
#endif /* CH_CFG_OPTIMIZE_SPEED */
|
||||
|
@ -703,8 +707,9 @@ static inline void chSchDoYieldS(void) {
|
|||
|
||||
chDbgCheckClassS();
|
||||
|
||||
if (chSchCanYieldS())
|
||||
if (chSchCanYieldS()) {
|
||||
chSchDoRescheduleBehind();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -720,16 +725,19 @@ static inline void chSchPreemption(void) {
|
|||
|
||||
#if CH_CFG_TIME_QUANTUM > 0
|
||||
if (currp->p_preempt) {
|
||||
if (p1 > p2)
|
||||
if (p1 > p2) {
|
||||
chSchDoRescheduleAhead();
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (p1 >= p2)
|
||||
if (p1 >= p2) {
|
||||
chSchDoRescheduleBehind();
|
||||
}
|
||||
}
|
||||
#else /* CH_CFG_TIME_QUANTUM == 0 */
|
||||
if (p1 >= p2)
|
||||
if (p1 >= p2) {
|
||||
chSchDoRescheduleAhead();
|
||||
}
|
||||
#endif /* CH_CFG_TIME_QUANTUM == 0 */
|
||||
}
|
||||
|
||||
|
|
|
@ -369,8 +369,9 @@ static inline void chSysUnlockFromISR(void) {
|
|||
*/
|
||||
static inline void chSysUnconditionalLock(void) {
|
||||
|
||||
if (port_irq_enabled(port_get_irq_status()))
|
||||
if (port_irq_enabled(port_get_irq_status())) {
|
||||
chSysLock();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -382,8 +383,9 @@ static inline void chSysUnconditionalLock(void) {
|
|||
*/
|
||||
static inline void chSysUnconditionalUnlock(void) {
|
||||
|
||||
if (!port_irq_enabled(port_get_irq_status()))
|
||||
if (!port_irq_enabled(port_get_irq_status())) {
|
||||
chSysUnlock();
|
||||
}
|
||||
}
|
||||
|
||||
#if !CH_CFG_NO_IDLE_THREAD || defined(__DOXYGEN__)
|
||||
|
|
|
@ -248,6 +248,7 @@ static inline systime_t chVTGetSystemTime(void) {
|
|||
chSysLock();
|
||||
systime = chVTGetSystemTimeX();
|
||||
chSysUnlock();
|
||||
|
||||
return systime;
|
||||
}
|
||||
|
||||
|
@ -350,8 +351,9 @@ static inline bool chVTIsArmedI(virtual_timer_t *vtp) {
|
|||
*/
|
||||
static inline void chVTResetI(virtual_timer_t *vtp) {
|
||||
|
||||
if (chVTIsArmedI(vtp))
|
||||
if (chVTIsArmedI(vtp)) {
|
||||
chVTDoResetI(vtp);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -474,8 +476,9 @@ static inline void chVTDoTickI(void) {
|
|||
|
||||
/* The next element is outside the current time window, the loop
|
||||
is stopped here.*/
|
||||
if ((vtp = ch.vtlist.vt_next)->vt_delta > delta)
|
||||
if ((vtp = ch.vtlist.vt_next)->vt_delta > delta) {
|
||||
break;
|
||||
}
|
||||
|
||||
/* The "last time" becomes this timer's expiration time.*/
|
||||
delta -= vtp->vt_delta;
|
||||
|
@ -500,10 +503,12 @@ static inline void chVTDoTickI(void) {
|
|||
else {
|
||||
/* Updating the alarm to the next deadline, deadline that must not be
|
||||
closer in time than the minimum time delta.*/
|
||||
if (vtp->vt_delta >= CH_CFG_ST_TIMEDELTA)
|
||||
if (vtp->vt_delta >= CH_CFG_ST_TIMEDELTA) {
|
||||
port_timer_set_alarm(now + vtp->vt_delta);
|
||||
else
|
||||
}
|
||||
else {
|
||||
port_timer_set_alarm(now + CH_CFG_ST_TIMEDELTA);
|
||||
}
|
||||
}
|
||||
#endif /* CH_CFG_ST_TIMEDELTA > 0 */
|
||||
}
|
||||
|
|
|
@ -91,8 +91,9 @@ void chCondSignal(condition_variable_t *cp) {
|
|||
chDbgCheck(cp != NULL);
|
||||
|
||||
chSysLock();
|
||||
if (queue_notempty(&cp->c_queue))
|
||||
if (queue_notempty(&cp->c_queue)) {
|
||||
chSchWakeupS(queue_fifo_remove(&cp->c_queue), MSG_OK);
|
||||
}
|
||||
chSysUnlock();
|
||||
}
|
||||
|
||||
|
@ -153,8 +154,9 @@ void chCondBroadcastI(condition_variable_t *cp) {
|
|||
/* Empties the condition variable queue and inserts all the threads into the
|
||||
ready list in FIFO order. The wakeup message is set to @p MSG_RESET in
|
||||
order to make a chCondBroadcast() detectable from a chCondSignal().*/
|
||||
while (cp->c_queue.p_next != (void *)&cp->c_queue)
|
||||
while (cp->c_queue.p_next != (void *)&cp->c_queue) {
|
||||
chSchReadyI(queue_fifo_remove(&cp->c_queue))->p_u.rdymsg = MSG_RESET;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -209,13 +211,18 @@ msg_t chCondWaitS(condition_variable_t *cp) {
|
|||
chDbgCheck(cp != NULL);
|
||||
chDbgAssert(ctp->p_mtxlist != NULL, "not owning a mutex");
|
||||
|
||||
/* Getting "current" mutex and releasing it.*/
|
||||
mp = chMtxGetNextMutexS();
|
||||
chMtxUnlockS(mp);
|
||||
|
||||
/* Start waiting on the condition variable, on exit the mutex is taken
|
||||
again.*/
|
||||
ctp->p_u.wtobjp = cp;
|
||||
queue_prio_insert(ctp, &cp->c_queue);
|
||||
chSchGoSleepS(CH_STATE_WTCOND);
|
||||
msg = ctp->p_u.rdymsg;
|
||||
chMtxLockS(mp);
|
||||
|
||||
return msg;
|
||||
}
|
||||
|
||||
|
@ -254,6 +261,7 @@ msg_t chCondWaitTimeout(condition_variable_t *cp, systime_t time) {
|
|||
chSysLock();
|
||||
msg = chCondWaitTimeoutS(cp, time);
|
||||
chSysUnlock();
|
||||
|
||||
return msg;
|
||||
}
|
||||
|
||||
|
@ -293,13 +301,19 @@ msg_t chCondWaitTimeoutS(condition_variable_t *cp, systime_t time) {
|
|||
chDbgCheck((cp != NULL) && (time != TIME_IMMEDIATE));
|
||||
chDbgAssert(currp->p_mtxlist != NULL, "not owning a mutex");
|
||||
|
||||
/* Getting "current" mutex and releasing it.*/
|
||||
mp = chMtxGetNextMutexS();
|
||||
chMtxUnlockS(mp);
|
||||
|
||||
/* Start waiting on the condition variable, on exit the mutex is taken
|
||||
again.*/
|
||||
currp->p_u.wtobjp = cp;
|
||||
queue_prio_insert(currp, &cp->c_queue);
|
||||
msg = chSchGoSleepTimeoutS(CH_STATE_WTCOND, time);
|
||||
if (msg != MSG_TIMEOUT)
|
||||
if (msg != MSG_TIMEOUT) {
|
||||
chMtxLockS(mp);
|
||||
}
|
||||
|
||||
return msg;
|
||||
}
|
||||
#endif /* CH_CFG_USE_CONDVARS_TIMEOUT */
|
||||
|
|
|
@ -113,8 +113,9 @@
|
|||
*/
|
||||
void _dbg_check_disable(void) {
|
||||
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt != 0))
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt != 0)) {
|
||||
chSysHalt("SV#1");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -124,8 +125,9 @@ void _dbg_check_disable(void) {
|
|||
*/
|
||||
void _dbg_check_suspend(void) {
|
||||
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt != 0))
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt != 0)) {
|
||||
chSysHalt("SV#2");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -135,8 +137,9 @@ void _dbg_check_suspend(void) {
|
|||
*/
|
||||
void _dbg_check_enable(void) {
|
||||
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt != 0))
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt != 0)) {
|
||||
chSysHalt("SV#3");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -146,8 +149,9 @@ void _dbg_check_enable(void) {
|
|||
*/
|
||||
void _dbg_check_lock(void) {
|
||||
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt != 0))
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt != 0)) {
|
||||
chSysHalt("SV#4");
|
||||
}
|
||||
_dbg_enter_lock();
|
||||
}
|
||||
|
||||
|
@ -158,8 +162,9 @@ void _dbg_check_lock(void) {
|
|||
*/
|
||||
void _dbg_check_unlock(void) {
|
||||
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt <= 0))
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt <= 0)) {
|
||||
chSysHalt("SV#5");
|
||||
}
|
||||
_dbg_leave_lock();
|
||||
}
|
||||
|
||||
|
@ -170,8 +175,9 @@ void _dbg_check_unlock(void) {
|
|||
*/
|
||||
void _dbg_check_lock_from_isr(void) {
|
||||
|
||||
if ((ch.dbg.isr_cnt <= 0) || (ch.dbg.lock_cnt != 0))
|
||||
if ((ch.dbg.isr_cnt <= 0) || (ch.dbg.lock_cnt != 0)) {
|
||||
chSysHalt("SV#6");
|
||||
}
|
||||
_dbg_enter_lock();
|
||||
}
|
||||
|
||||
|
@ -182,8 +188,9 @@ void _dbg_check_lock_from_isr(void) {
|
|||
*/
|
||||
void _dbg_check_unlock_from_isr(void) {
|
||||
|
||||
if ((ch.dbg.isr_cnt <= 0) || (ch.dbg.lock_cnt <= 0))
|
||||
if ((ch.dbg.isr_cnt <= 0) || (ch.dbg.lock_cnt <= 0)) {
|
||||
chSysHalt("SV#7");
|
||||
}
|
||||
_dbg_leave_lock();
|
||||
}
|
||||
|
||||
|
@ -195,8 +202,9 @@ void _dbg_check_unlock_from_isr(void) {
|
|||
void _dbg_check_enter_isr(void) {
|
||||
|
||||
port_lock_from_isr();
|
||||
if ((ch.dbg.isr_cnt < 0) || (ch.dbg.lock_cnt != 0))
|
||||
if ((ch.dbg.isr_cnt < 0) || (ch.dbg.lock_cnt != 0)) {
|
||||
chSysHalt("SV#8");
|
||||
}
|
||||
ch.dbg.isr_cnt++;
|
||||
port_unlock_from_isr();
|
||||
}
|
||||
|
@ -209,8 +217,9 @@ void _dbg_check_enter_isr(void) {
|
|||
void _dbg_check_leave_isr(void) {
|
||||
|
||||
port_lock_from_isr();
|
||||
if ((ch.dbg.isr_cnt <= 0) || (ch.dbg.lock_cnt != 0))
|
||||
if ((ch.dbg.isr_cnt <= 0) || (ch.dbg.lock_cnt != 0)) {
|
||||
chSysHalt("SV#9");
|
||||
}
|
||||
ch.dbg.isr_cnt--;
|
||||
port_unlock_from_isr();
|
||||
}
|
||||
|
@ -225,8 +234,9 @@ void _dbg_check_leave_isr(void) {
|
|||
*/
|
||||
void chDbgCheckClassI(void) {
|
||||
|
||||
if ((ch.dbg.isr_cnt < 0) || (ch.dbg.lock_cnt <= 0))
|
||||
if ((ch.dbg.isr_cnt < 0) || (ch.dbg.lock_cnt <= 0)) {
|
||||
chSysHalt("SV#10");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -239,8 +249,9 @@ void chDbgCheckClassI(void) {
|
|||
*/
|
||||
void chDbgCheckClassS(void) {
|
||||
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt <= 0))
|
||||
if ((ch.dbg.isr_cnt != 0) || (ch.dbg.lock_cnt <= 0)) {
|
||||
chSysHalt("SV#11");
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* CH_DBG_SYSTEM_STATE_CHECK */
|
||||
|
@ -270,8 +281,9 @@ void _dbg_trace(thread_t *otp) {
|
|||
ch.dbg.trace_buffer.tb_ptr->se_wtobjp = otp->p_u.wtobjp;
|
||||
ch.dbg.trace_buffer.tb_ptr->se_state = (uint8_t)otp->p_state;
|
||||
if (++ch.dbg.trace_buffer.tb_ptr >=
|
||||
&ch.dbg.trace_buffer.tb_buffer[CH_DBG_TRACE_BUFFER_SIZE])
|
||||
&ch.dbg.trace_buffer.tb_buffer[CH_DBG_TRACE_BUFFER_SIZE]) {
|
||||
ch.dbg.trace_buffer.tb_ptr = &ch.dbg.trace_buffer.tb_buffer[0];
|
||||
}
|
||||
}
|
||||
#endif /* CH_DBG_ENABLE_TRACE */
|
||||
|
||||
|
|
|
@ -149,8 +149,9 @@ thread_t *chThdCreateFromHeap(memory_heap_t *heapp, size_t size,
|
|||
thread_t *tp;
|
||||
|
||||
wsp = chHeapAlloc(heapp, size);
|
||||
if (wsp == NULL)
|
||||
if (wsp == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#if CH_DBG_FILL_THREADS
|
||||
_thread_memfill((uint8_t *)wsp,
|
||||
|
@ -166,6 +167,7 @@ thread_t *chThdCreateFromHeap(memory_heap_t *heapp, size_t size,
|
|||
tp->p_flags = CH_FLAG_MODE_HEAP;
|
||||
chSchWakeupS(tp, MSG_OK);
|
||||
chSysUnlock();
|
||||
|
||||
return tp;
|
||||
}
|
||||
#endif /* CH_CFG_USE_HEAP */
|
||||
|
@ -201,8 +203,9 @@ thread_t *chThdCreateFromMemoryPool(memory_pool_t *mp, tprio_t prio,
|
|||
chDbgCheck(mp != NULL);
|
||||
|
||||
wsp = chPoolAlloc(mp);
|
||||
if (wsp == NULL)
|
||||
if (wsp == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#if CH_DBG_FILL_THREADS
|
||||
_thread_memfill((uint8_t *)wsp,
|
||||
|
@ -219,6 +222,7 @@ thread_t *chThdCreateFromMemoryPool(memory_pool_t *mp, tprio_t prio,
|
|||
tp->p_mpool = mp;
|
||||
chSchWakeupS(tp, MSG_OK);
|
||||
chSysUnlock();
|
||||
|
||||
return tp;
|
||||
}
|
||||
#endif /* CH_CFG_USE_MEMPOOLS */
|
||||
|
|
|
@ -159,11 +159,10 @@ eventmask_t chEvtGetAndClearEvents(eventmask_t events) {
|
|||
eventmask_t m;
|
||||
|
||||
chSysLock();
|
||||
|
||||
m = currp->p_epending & events;
|
||||
currp->p_epending &= ~events;
|
||||
|
||||
chSysUnlock();
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
|
@ -179,10 +178,9 @@ eventmask_t chEvtGetAndClearEvents(eventmask_t events) {
|
|||
eventmask_t chEvtAddEvents(eventmask_t events) {
|
||||
|
||||
chSysLock();
|
||||
|
||||
events = (currp->p_epending |= events);
|
||||
|
||||
chSysUnlock();
|
||||
|
||||
return events;
|
||||
}
|
||||
|
||||
|
@ -214,8 +212,9 @@ void chEvtBroadcastFlagsI(event_source_t *esp, eventflags_t flags) {
|
|||
elp->el_flags |= flags;
|
||||
/* When flags == 0 the thread will always be signaled because the
|
||||
source does not emit any flag.*/
|
||||
if ((flags == 0) || ((elp->el_flags & elp->el_wflags) != 0))
|
||||
if ((flags == 0) || ((elp->el_flags & elp->el_wflags) != 0)) {
|
||||
chEvtSignalI(elp->el_listener, elp->el_events);
|
||||
}
|
||||
elp = elp->el_next;
|
||||
}
|
||||
}
|
||||
|
@ -235,11 +234,10 @@ eventflags_t chEvtGetAndClearFlags(event_listener_t *elp) {
|
|||
eventflags_t flags;
|
||||
|
||||
chSysLock();
|
||||
|
||||
flags = elp->el_flags;
|
||||
elp->el_flags = 0;
|
||||
|
||||
chSysUnlock();
|
||||
|
||||
return flags;
|
||||
}
|
||||
|
||||
|
@ -377,7 +375,6 @@ eventmask_t chEvtWaitOne(eventmask_t events) {
|
|||
eventmask_t m;
|
||||
|
||||
chSysLock();
|
||||
|
||||
if ((m = (ctp->p_epending & events)) == 0) {
|
||||
ctp->p_u.ewmask = events;
|
||||
chSchGoSleepS(CH_STATE_WTOREVT);
|
||||
|
@ -385,8 +382,8 @@ eventmask_t chEvtWaitOne(eventmask_t events) {
|
|||
}
|
||||
m ^= m & (m - 1);
|
||||
ctp->p_epending &= ~m;
|
||||
|
||||
chSysUnlock();
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
|
@ -407,15 +404,14 @@ eventmask_t chEvtWaitAny(eventmask_t events) {
|
|||
eventmask_t m;
|
||||
|
||||
chSysLock();
|
||||
|
||||
if ((m = (ctp->p_epending & events)) == 0) {
|
||||
ctp->p_u.ewmask = events;
|
||||
chSchGoSleepS(CH_STATE_WTOREVT);
|
||||
m = ctp->p_epending & events;
|
||||
}
|
||||
ctp->p_epending &= ~m;
|
||||
|
||||
chSysUnlock();
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
|
@ -434,14 +430,13 @@ eventmask_t chEvtWaitAll(eventmask_t events) {
|
|||
thread_t *ctp = currp;
|
||||
|
||||
chSysLock();
|
||||
|
||||
if ((ctp->p_epending & events) != events) {
|
||||
ctp->p_u.ewmask = events;
|
||||
chSchGoSleepS(CH_STATE_WTANDEVT);
|
||||
}
|
||||
ctp->p_epending &= ~events;
|
||||
|
||||
chSysUnlock();
|
||||
|
||||
return events;
|
||||
}
|
||||
#endif /* CH_CFG_OPTIMIZE_SPEED || !CH_CFG_USE_EVENTS_TIMEOUT */
|
||||
|
@ -474,7 +469,6 @@ eventmask_t chEvtWaitOneTimeout(eventmask_t events, systime_t time) {
|
|||
eventmask_t m;
|
||||
|
||||
chSysLock();
|
||||
|
||||
if ((m = (ctp->p_epending & events)) == 0) {
|
||||
if (TIME_IMMEDIATE == time) {
|
||||
chSysUnlock();
|
||||
|
@ -489,8 +483,8 @@ eventmask_t chEvtWaitOneTimeout(eventmask_t events, systime_t time) {
|
|||
}
|
||||
m ^= m & (m - 1);
|
||||
ctp->p_epending &= ~m;
|
||||
|
||||
chSysUnlock();
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
|
@ -517,7 +511,6 @@ eventmask_t chEvtWaitAnyTimeout(eventmask_t events, systime_t time) {
|
|||
eventmask_t m;
|
||||
|
||||
chSysLock();
|
||||
|
||||
if ((m = (ctp->p_epending & events)) == 0) {
|
||||
if (TIME_IMMEDIATE == time) {
|
||||
chSysUnlock();
|
||||
|
@ -531,8 +524,8 @@ eventmask_t chEvtWaitAnyTimeout(eventmask_t events, systime_t time) {
|
|||
m = ctp->p_epending & events;
|
||||
}
|
||||
ctp->p_epending &= ~m;
|
||||
|
||||
chSysUnlock();
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
|
@ -557,7 +550,6 @@ eventmask_t chEvtWaitAllTimeout(eventmask_t events, systime_t time) {
|
|||
thread_t *ctp = currp;
|
||||
|
||||
chSysLock();
|
||||
|
||||
if ((ctp->p_epending & events) != events) {
|
||||
if (TIME_IMMEDIATE == time) {
|
||||
chSysUnlock();
|
||||
|
@ -570,8 +562,8 @@ eventmask_t chEvtWaitAllTimeout(eventmask_t events, systime_t time) {
|
|||
}
|
||||
}
|
||||
ctp->p_epending &= ~events;
|
||||
|
||||
chSysUnlock();
|
||||
|
||||
return events;
|
||||
}
|
||||
#endif /* CH_CFG_USE_EVENTS_TIMEOUT */
|
||||
|
|
|
@ -83,6 +83,7 @@ static memory_heap_t default_heap;
|
|||
* @notapi
|
||||
*/
|
||||
void _heap_init(void) {
|
||||
|
||||
default_heap.h_provider = chCoreAlloc;
|
||||
default_heap.h_free.h.u.next = (union heap_header *)NULL;
|
||||
default_heap.h_free.h.size = 0;
|
||||
|
@ -145,8 +146,8 @@ void *chHeapAlloc(memory_heap_t *heapp, size_t size) {
|
|||
|
||||
size = MEM_ALIGN_NEXT(size);
|
||||
qp = &heapp->h_free;
|
||||
H_LOCK(heapp);
|
||||
|
||||
H_LOCK(heapp);
|
||||
while (qp->h.u.next != NULL) {
|
||||
hp = qp->h.u.next;
|
||||
if (hp->h.size >= size) {
|
||||
|
@ -165,13 +166,12 @@ void *chHeapAlloc(memory_heap_t *heapp, size_t size) {
|
|||
hp->h.size = size;
|
||||
}
|
||||
hp->h.u.heap = heapp;
|
||||
|
||||
H_UNLOCK(heapp);
|
||||
|
||||
return (void *)(hp + 1);
|
||||
}
|
||||
qp = hp;
|
||||
}
|
||||
|
||||
H_UNLOCK(heapp);
|
||||
|
||||
/* More memory is required, tries to get it from the associated provider
|
||||
|
@ -182,9 +182,11 @@ void *chHeapAlloc(memory_heap_t *heapp, size_t size) {
|
|||
hp->h.u.heap = heapp;
|
||||
hp->h.size = size;
|
||||
hp++;
|
||||
|
||||
return (void *)hp;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -208,8 +210,8 @@ void chHeapFree(void *p) {
|
|||
hp = (union heap_header *)p - 1;
|
||||
heapp = hp->h.u.heap;
|
||||
qp = &heapp->h_free;
|
||||
H_LOCK(heapp);
|
||||
|
||||
H_LOCK(heapp);
|
||||
while (true) {
|
||||
chDbgAssert((hp < qp) || (hp >= LIMIT(qp)), "within free block");
|
||||
|
||||
|
@ -233,8 +235,8 @@ void chHeapFree(void *p) {
|
|||
}
|
||||
qp = qp->h.u.next;
|
||||
}
|
||||
|
||||
H_UNLOCK(heapp);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -255,18 +257,20 @@ size_t chHeapStatus(memory_heap_t *heapp, size_t *sizep) {
|
|||
union heap_header *qp;
|
||||
size_t n, sz;
|
||||
|
||||
if (heapp == NULL)
|
||||
if (heapp == NULL) {
|
||||
heapp = &default_heap;
|
||||
}
|
||||
|
||||
H_LOCK(heapp);
|
||||
|
||||
sz = 0;
|
||||
for (n = 0, qp = &heapp->h_free; qp->h.u.next; n++, qp = qp->h.u.next)
|
||||
for (n = 0, qp = &heapp->h_free; qp->h.u.next; n++, qp = qp->h.u.next) {
|
||||
sz += qp->h.u.next->h.size;
|
||||
if (sizep)
|
||||
}
|
||||
if (sizep) {
|
||||
*sizep = sz;
|
||||
|
||||
}
|
||||
H_UNLOCK(heapp);
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
|
|
|
@ -154,6 +154,7 @@ msg_t chMBPost(mailbox_t *mbp, msg_t msg, systime_t time) {
|
|||
chSysLock();
|
||||
rdymsg = chMBPostS(mbp, msg, time);
|
||||
chSysUnlock();
|
||||
|
||||
return rdymsg;
|
||||
}
|
||||
|
||||
|
@ -185,11 +186,13 @@ msg_t chMBPostS(mailbox_t *mbp, msg_t msg, systime_t time) {
|
|||
rdymsg = chSemWaitTimeoutS(&mbp->mb_emptysem, time);
|
||||
if (rdymsg == MSG_OK) {
|
||||
*mbp->mb_wrptr++ = msg;
|
||||
if (mbp->mb_wrptr >= mbp->mb_top)
|
||||
if (mbp->mb_wrptr >= mbp->mb_top) {
|
||||
mbp->mb_wrptr = mbp->mb_buffer;
|
||||
}
|
||||
chSemSignalI(&mbp->mb_fullsem);
|
||||
chSchRescheduleS();
|
||||
}
|
||||
|
||||
return rdymsg;
|
||||
}
|
||||
|
||||
|
@ -212,13 +215,17 @@ msg_t chMBPostI(mailbox_t *mbp, msg_t msg) {
|
|||
chDbgCheckClassI();
|
||||
chDbgCheck(mbp != NULL);
|
||||
|
||||
if (chSemGetCounterI(&mbp->mb_emptysem) <= 0)
|
||||
if (chSemGetCounterI(&mbp->mb_emptysem) <= 0) {
|
||||
return MSG_TIMEOUT;
|
||||
}
|
||||
|
||||
chSemFastWaitI(&mbp->mb_emptysem);
|
||||
*mbp->mb_wrptr++ = msg;
|
||||
if (mbp->mb_wrptr >= mbp->mb_top)
|
||||
if (mbp->mb_wrptr >= mbp->mb_top) {
|
||||
mbp->mb_wrptr = mbp->mb_buffer;
|
||||
}
|
||||
chSemSignalI(&mbp->mb_fullsem);
|
||||
|
||||
return MSG_OK;
|
||||
}
|
||||
|
||||
|
@ -247,6 +254,7 @@ msg_t chMBPostAhead(mailbox_t *mbp, msg_t msg, systime_t time) {
|
|||
chSysLock();
|
||||
rdymsg = chMBPostAheadS(mbp, msg, time);
|
||||
chSysUnlock();
|
||||
|
||||
return rdymsg;
|
||||
}
|
||||
|
||||
|
@ -277,12 +285,14 @@ msg_t chMBPostAheadS(mailbox_t *mbp, msg_t msg, systime_t time) {
|
|||
|
||||
rdymsg = chSemWaitTimeoutS(&mbp->mb_emptysem, time);
|
||||
if (rdymsg == MSG_OK) {
|
||||
if (--mbp->mb_rdptr < mbp->mb_buffer)
|
||||
if (--mbp->mb_rdptr < mbp->mb_buffer) {
|
||||
mbp->mb_rdptr = mbp->mb_top - 1;
|
||||
}
|
||||
*mbp->mb_rdptr = msg;
|
||||
chSemSignalI(&mbp->mb_fullsem);
|
||||
chSchRescheduleS();
|
||||
}
|
||||
|
||||
return rdymsg;
|
||||
}
|
||||
|
||||
|
@ -305,13 +315,16 @@ msg_t chMBPostAheadI(mailbox_t *mbp, msg_t msg) {
|
|||
chDbgCheckClassI();
|
||||
chDbgCheck(mbp != NULL);
|
||||
|
||||
if (chSemGetCounterI(&mbp->mb_emptysem) <= 0)
|
||||
if (chSemGetCounterI(&mbp->mb_emptysem) <= 0) {
|
||||
return MSG_TIMEOUT;
|
||||
}
|
||||
chSemFastWaitI(&mbp->mb_emptysem);
|
||||
if (--mbp->mb_rdptr < mbp->mb_buffer)
|
||||
if (--mbp->mb_rdptr < mbp->mb_buffer) {
|
||||
mbp->mb_rdptr = mbp->mb_top - 1;
|
||||
}
|
||||
*mbp->mb_rdptr = msg;
|
||||
chSemSignalI(&mbp->mb_fullsem);
|
||||
|
||||
return MSG_OK;
|
||||
}
|
||||
|
||||
|
@ -340,6 +353,7 @@ msg_t chMBFetch(mailbox_t *mbp, msg_t *msgp, systime_t time) {
|
|||
chSysLock();
|
||||
rdymsg = chMBFetchS(mbp, msgp, time);
|
||||
chSysUnlock();
|
||||
|
||||
return rdymsg;
|
||||
}
|
||||
|
||||
|
@ -371,11 +385,13 @@ msg_t chMBFetchS(mailbox_t *mbp, msg_t *msgp, systime_t time) {
|
|||
rdymsg = chSemWaitTimeoutS(&mbp->mb_fullsem, time);
|
||||
if (rdymsg == MSG_OK) {
|
||||
*msgp = *mbp->mb_rdptr++;
|
||||
if (mbp->mb_rdptr >= mbp->mb_top)
|
||||
if (mbp->mb_rdptr >= mbp->mb_top) {
|
||||
mbp->mb_rdptr = mbp->mb_buffer;
|
||||
}
|
||||
chSemSignalI(&mbp->mb_emptysem);
|
||||
chSchRescheduleS();
|
||||
}
|
||||
|
||||
return rdymsg;
|
||||
}
|
||||
|
||||
|
@ -398,13 +414,16 @@ msg_t chMBFetchI(mailbox_t *mbp, msg_t *msgp) {
|
|||
chDbgCheckClassI();
|
||||
chDbgCheck((mbp != NULL) && (msgp != NULL));
|
||||
|
||||
if (chSemGetCounterI(&mbp->mb_fullsem) <= 0)
|
||||
if (chSemGetCounterI(&mbp->mb_fullsem) <= 0) {
|
||||
return MSG_TIMEOUT;
|
||||
}
|
||||
chSemFastWaitI(&mbp->mb_fullsem);
|
||||
*msgp = *mbp->mb_rdptr++;
|
||||
if (mbp->mb_rdptr >= mbp->mb_top)
|
||||
if (mbp->mb_rdptr >= mbp->mb_top) {
|
||||
mbp->mb_rdptr = mbp->mb_buffer;
|
||||
}
|
||||
chSemSignalI(&mbp->mb_emptysem);
|
||||
|
||||
return MSG_OK;
|
||||
}
|
||||
#endif /* CH_CFG_USE_MAILBOXES */
|
||||
|
|
|
@ -108,6 +108,7 @@ void *chCoreAlloc(size_t size) {
|
|||
chSysLock();
|
||||
p = chCoreAllocI(size);
|
||||
chSysUnlock();
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
|
@ -129,10 +130,12 @@ void *chCoreAllocI(size_t size) {
|
|||
chDbgCheckClassI();
|
||||
|
||||
size = MEM_ALIGN_NEXT(size);
|
||||
if ((size_t)(endmem - nextmem) < size)
|
||||
if ((size_t)(endmem - nextmem) < size) {
|
||||
return NULL;
|
||||
}
|
||||
p = nextmem;
|
||||
nextmem += size;
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
|
|
|
@ -121,10 +121,13 @@ void *chPoolAllocI(memory_pool_t *mp) {
|
|||
chDbgCheckClassI();
|
||||
chDbgCheck(mp != NULL);
|
||||
|
||||
if ((objp = mp->mp_next) != NULL)
|
||||
if ((objp = mp->mp_next) != NULL) {
|
||||
mp->mp_next = mp->mp_next->ph_next;
|
||||
else if (mp->mp_provider != NULL)
|
||||
}
|
||||
else if (mp->mp_provider != NULL) {
|
||||
objp = mp->mp_provider(mp->mp_object_size);
|
||||
}
|
||||
|
||||
return objp;
|
||||
}
|
||||
|
||||
|
@ -144,6 +147,7 @@ void *chPoolAlloc(memory_pool_t *mp) {
|
|||
chSysLock();
|
||||
objp = chPoolAllocI(mp);
|
||||
chSysUnlock();
|
||||
|
||||
return objp;
|
||||
}
|
||||
|
||||
|
|
|
@ -93,11 +93,13 @@ msg_t chMsgSend(thread_t *tp, msg_t msg) {
|
|||
ctp->p_msg = msg;
|
||||
ctp->p_u.wtobjp = &tp->p_msgqueue;
|
||||
msg_insert(ctp, &tp->p_msgqueue);
|
||||
if (tp->p_state == CH_STATE_WTMSG)
|
||||
if (tp->p_state == CH_STATE_WTMSG) {
|
||||
chSchReadyI(tp);
|
||||
}
|
||||
chSchGoSleepS(CH_STATE_SNDMSGQ);
|
||||
msg = ctp->p_u.rdymsg;
|
||||
chSysUnlock();
|
||||
|
||||
return msg;
|
||||
}
|
||||
|
||||
|
@ -119,11 +121,13 @@ thread_t *chMsgWait(void) {
|
|||
thread_t *tp;
|
||||
|
||||
chSysLock();
|
||||
if (!chMsgIsPendingI(currp))
|
||||
if (!chMsgIsPendingI(currp)) {
|
||||
chSchGoSleepS(CH_STATE_WTMSG);
|
||||
}
|
||||
tp = queue_fifo_remove(&currp->p_msgqueue);
|
||||
tp->p_state = CH_STATE_SNDMSG;
|
||||
chSysUnlock();
|
||||
|
||||
return tp;
|
||||
}
|
||||
|
||||
|
|
|
@ -123,9 +123,7 @@ void chMtxObjectInit(mutex_t *mp) {
|
|||
void chMtxLock(mutex_t *mp) {
|
||||
|
||||
chSysLock();
|
||||
|
||||
chMtxLockS(mp);
|
||||
|
||||
chSysUnlock();
|
||||
}
|
||||
|
||||
|
@ -152,8 +150,9 @@ void chMtxLockS(mutex_t *mp) {
|
|||
|
||||
/* If the mutex is already owned by this thread, the counter is increased
|
||||
and there is no need of more actions.*/
|
||||
if (mp->m_owner == ctp)
|
||||
if (mp->m_owner == ctp) {
|
||||
mp->m_cnt++;
|
||||
}
|
||||
else {
|
||||
#endif
|
||||
/* Priority inheritance protocol; explores the thread-mutex dependencies
|
||||
|
@ -252,10 +251,9 @@ bool chMtxTryLock(mutex_t *mp) {
|
|||
bool b;
|
||||
|
||||
chSysLock();
|
||||
|
||||
b = chMtxTryLockS(mp);
|
||||
|
||||
chSysUnlock();
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
|
@ -352,8 +350,10 @@ void chMtxUnlock(mutex_t *mp) {
|
|||
/* If the highest priority thread waiting in the mutexes list has a
|
||||
greater priority than the current thread base priority then the
|
||||
final priority will have at least that priority.*/
|
||||
if (chMtxQueueNotEmptyS(lmp) && (lmp->m_queue.p_next->p_prio > newprio))
|
||||
if (chMtxQueueNotEmptyS(lmp) &&
|
||||
(lmp->m_queue.p_next->p_prio > newprio)) {
|
||||
newprio = lmp->m_queue.p_next->p_prio;
|
||||
}
|
||||
lmp = lmp->m_next;
|
||||
}
|
||||
|
||||
|
@ -372,8 +372,9 @@ void chMtxUnlock(mutex_t *mp) {
|
|||
tp->p_mtxlist = mp;
|
||||
chSchWakeupS(tp, MSG_OK);
|
||||
}
|
||||
else
|
||||
else {
|
||||
mp->m_owner = NULL;
|
||||
}
|
||||
#if CH_CFG_USE_MUTEXES_RECURSIVE
|
||||
}
|
||||
#endif
|
||||
|
@ -429,8 +430,10 @@ void chMtxUnlockS(mutex_t *mp) {
|
|||
/* If the highest priority thread waiting in the mutexes list has a
|
||||
greater priority than the current thread base priority then the
|
||||
final priority will have at least that priority.*/
|
||||
if (chMtxQueueNotEmptyS(lmp) && (lmp->m_queue.p_next->p_prio > newprio))
|
||||
if (chMtxQueueNotEmptyS(lmp) &&
|
||||
(lmp->m_queue.p_next->p_prio > newprio)) {
|
||||
newprio = lmp->m_queue.p_next->p_prio;
|
||||
}
|
||||
lmp = lmp->m_next;
|
||||
}
|
||||
|
||||
|
@ -449,8 +452,9 @@ void chMtxUnlockS(mutex_t *mp) {
|
|||
tp->p_mtxlist = mp;
|
||||
chSchReadyI(tp);
|
||||
}
|
||||
else
|
||||
else {
|
||||
mp->m_owner = NULL;
|
||||
}
|
||||
#if CH_CFG_USE_MUTEXES_RECURSIVE
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -132,13 +132,15 @@ msg_t chIQPutI(input_queue_t *iqp, uint8_t b) {
|
|||
|
||||
chDbgCheckClassI();
|
||||
|
||||
if (chIQIsFullI(iqp))
|
||||
if (chIQIsFullI(iqp)) {
|
||||
return Q_FULL;
|
||||
}
|
||||
|
||||
iqp->q_counter++;
|
||||
*iqp->q_wrptr++ = b;
|
||||
if (iqp->q_wrptr >= iqp->q_top)
|
||||
if (iqp->q_wrptr >= iqp->q_top) {
|
||||
iqp->q_wrptr = iqp->q_buffer;
|
||||
}
|
||||
|
||||
chThdDequeueNextI(&iqp->q_waiting, Q_OK);
|
||||
|
||||
|
@ -169,8 +171,9 @@ msg_t chIQGetTimeout(input_queue_t *iqp, systime_t time) {
|
|||
uint8_t b;
|
||||
|
||||
chSysLock();
|
||||
if (iqp->q_notify)
|
||||
if (iqp->q_notify) {
|
||||
iqp->q_notify(iqp);
|
||||
}
|
||||
|
||||
while (chIQIsEmptyI(iqp)) {
|
||||
msg_t msg;
|
||||
|
@ -182,10 +185,11 @@ msg_t chIQGetTimeout(input_queue_t *iqp, systime_t time) {
|
|||
|
||||
iqp->q_counter--;
|
||||
b = *iqp->q_rdptr++;
|
||||
if (iqp->q_rdptr >= iqp->q_top)
|
||||
if (iqp->q_rdptr >= iqp->q_top) {
|
||||
iqp->q_rdptr = iqp->q_buffer;
|
||||
|
||||
}
|
||||
chSysUnlock();
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
|
@ -222,8 +226,9 @@ size_t chIQReadTimeout(input_queue_t *iqp, uint8_t *bp,
|
|||
|
||||
chSysLock();
|
||||
while (true) {
|
||||
if (nfy)
|
||||
if (nfy) {
|
||||
nfy(iqp);
|
||||
}
|
||||
|
||||
while (chIQIsEmptyI(iqp)) {
|
||||
if (chThdEnqueueTimeoutS(&iqp->q_waiting, time) != Q_OK) {
|
||||
|
@ -239,8 +244,9 @@ size_t chIQReadTimeout(input_queue_t *iqp, uint8_t *bp,
|
|||
|
||||
chSysUnlock(); /* Gives a preemption chance in a controlled point.*/
|
||||
r++;
|
||||
if (--n == 0)
|
||||
if (--n == 0) {
|
||||
return r;
|
||||
}
|
||||
|
||||
chSysLock();
|
||||
}
|
||||
|
@ -329,13 +335,15 @@ msg_t chOQPutTimeout(output_queue_t *oqp, uint8_t b, systime_t time) {
|
|||
|
||||
oqp->q_counter--;
|
||||
*oqp->q_wrptr++ = b;
|
||||
if (oqp->q_wrptr >= oqp->q_top)
|
||||
if (oqp->q_wrptr >= oqp->q_top) {
|
||||
oqp->q_wrptr = oqp->q_buffer;
|
||||
}
|
||||
|
||||
if (oqp->q_notify)
|
||||
if (oqp->q_notify) {
|
||||
oqp->q_notify(oqp);
|
||||
|
||||
}
|
||||
chSysUnlock();
|
||||
|
||||
return Q_OK;
|
||||
}
|
||||
|
||||
|
@ -354,13 +362,15 @@ msg_t chOQGetI(output_queue_t *oqp) {
|
|||
|
||||
chDbgCheckClassI();
|
||||
|
||||
if (chOQIsEmptyI(oqp))
|
||||
if (chOQIsEmptyI(oqp)) {
|
||||
return Q_EMPTY;
|
||||
}
|
||||
|
||||
oqp->q_counter++;
|
||||
b = *oqp->q_rdptr++;
|
||||
if (oqp->q_rdptr >= oqp->q_top)
|
||||
if (oqp->q_rdptr >= oqp->q_top) {
|
||||
oqp->q_rdptr = oqp->q_buffer;
|
||||
}
|
||||
|
||||
chThdDequeueNextI(&oqp->q_waiting, Q_OK);
|
||||
|
||||
|
@ -408,16 +418,19 @@ size_t chOQWriteTimeout(output_queue_t *oqp, const uint8_t *bp,
|
|||
}
|
||||
oqp->q_counter--;
|
||||
*oqp->q_wrptr++ = *bp++;
|
||||
if (oqp->q_wrptr >= oqp->q_top)
|
||||
if (oqp->q_wrptr >= oqp->q_top) {
|
||||
oqp->q_wrptr = oqp->q_buffer;
|
||||
}
|
||||
|
||||
if (nfy)
|
||||
if (nfy) {
|
||||
nfy(oqp);
|
||||
}
|
||||
|
||||
chSysUnlock(); /* Gives a preemption chance in a controlled point.*/
|
||||
w++;
|
||||
if (--n == 0)
|
||||
if (--n == 0) {
|
||||
return w;
|
||||
}
|
||||
chSysLock();
|
||||
}
|
||||
}
|
||||
|
|
|
@ -134,6 +134,7 @@ thread_t *chRegFirstThread(void) {
|
|||
tp->p_refs++;
|
||||
#endif
|
||||
chSysUnlock();
|
||||
|
||||
return tp;
|
||||
}
|
||||
|
||||
|
@ -153,8 +154,9 @@ thread_t *chRegNextThread(thread_t *tp) {
|
|||
|
||||
chSysLock();
|
||||
ntp = tp->p_newer;
|
||||
if (ntp == (thread_t *)&ch.rlist)
|
||||
if (ntp == (thread_t *)&ch.rlist) {
|
||||
ntp = NULL;
|
||||
}
|
||||
#if CH_CFG_USE_DYNAMIC
|
||||
else {
|
||||
chDbgAssert(ntp->p_refs < 255, "too many references");
|
||||
|
@ -165,6 +167,7 @@ thread_t *chRegNextThread(thread_t *tp) {
|
|||
#if CH_CFG_USE_DYNAMIC
|
||||
chThdRelease(tp);
|
||||
#endif
|
||||
|
||||
return ntp;
|
||||
}
|
||||
|
||||
|
|
|
@ -126,6 +126,7 @@ thread_t *queue_fifo_remove(threads_queue_t *tqp) {
|
|||
thread_t *tp = tqp->p_next;
|
||||
|
||||
(tqp->p_next = tp->p_next)->p_prev = (thread_t *)tqp;
|
||||
|
||||
return tp;
|
||||
}
|
||||
|
||||
|
@ -143,6 +144,7 @@ thread_t *queue_lifo_remove(threads_queue_t *tqp) {
|
|||
thread_t *tp = tqp->p_prev;
|
||||
|
||||
(tqp->p_prev = tp->p_prev)->p_next = (thread_t *)tqp;
|
||||
|
||||
return tp;
|
||||
}
|
||||
|
||||
|
@ -160,6 +162,7 @@ thread_t *queue_dequeue(thread_t *tp) {
|
|||
|
||||
tp->p_prev->p_next = tp->p_next;
|
||||
tp->p_next->p_prev = tp->p_prev;
|
||||
|
||||
return tp;
|
||||
}
|
||||
|
||||
|
@ -190,6 +193,7 @@ thread_t *list_remove(threads_list_t *tlp) {
|
|||
|
||||
thread_t *tp = tlp->p_next;
|
||||
tlp->p_next = tp->p_next;
|
||||
|
||||
return tp;
|
||||
}
|
||||
#endif /* CH_CFG_OPTIMIZE_SPEED */
|
||||
|
@ -228,6 +232,7 @@ thread_t *chSchReadyI(thread_t *tp) {
|
|||
tp->p_next = cp;
|
||||
tp->p_prev = cp->p_prev;
|
||||
tp->p_prev->p_next = cp->p_prev = tp;
|
||||
|
||||
return tp;
|
||||
}
|
||||
|
||||
|
@ -327,8 +332,10 @@ msg_t chSchGoSleepTimeoutS(tstate_t newstate, systime_t time) {
|
|||
if (chVTIsArmedI(&vt))
|
||||
chVTDoResetI(&vt);
|
||||
}
|
||||
else
|
||||
else {
|
||||
chSchGoSleepS(newstate);
|
||||
}
|
||||
|
||||
return currp->p_u.rdymsg;
|
||||
}
|
||||
|
||||
|
@ -388,8 +395,9 @@ void chSchRescheduleS(void) {
|
|||
|
||||
chDbgCheckClassS();
|
||||
|
||||
if (chSchIsRescRequiredI())
|
||||
if (chSchIsRescRequiredI()) {
|
||||
chSchDoRescheduleAhead();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -408,6 +416,7 @@ void chSchRescheduleS(void) {
|
|||
bool chSchIsPreemptionRequired(void) {
|
||||
tprio_t p1 = firstprio(&ch.rlist.r_queue);
|
||||
tprio_t p2 = currp->p_prio;
|
||||
|
||||
#if CH_CFG_TIME_QUANTUM > 0
|
||||
/* If the running thread has not reached its time quantum, reschedule only
|
||||
if the first thread on the ready queue has a higher priority.
|
||||
|
|
|
@ -155,8 +155,9 @@ void chSemResetI(semaphore_t *sp, cnt_t n) {
|
|||
|
||||
cnt = sp->s_cnt;
|
||||
sp->s_cnt = n;
|
||||
while (++cnt <= 0)
|
||||
while (++cnt <= 0) {
|
||||
chSchReadyI(queue_lifo_remove(&sp->s_queue))->p_u.rdymsg = MSG_RESET;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -177,6 +178,7 @@ msg_t chSemWait(semaphore_t *sp) {
|
|||
chSysLock();
|
||||
msg = chSemWaitS(sp);
|
||||
chSysUnlock();
|
||||
|
||||
return msg;
|
||||
}
|
||||
|
||||
|
@ -204,8 +206,10 @@ msg_t chSemWaitS(semaphore_t *sp) {
|
|||
currp->p_u.wtobjp = sp;
|
||||
sem_insert(currp, &sp->s_queue);
|
||||
chSchGoSleepS(CH_STATE_WTSEM);
|
||||
|
||||
return currp->p_u.rdymsg;
|
||||
}
|
||||
|
||||
return MSG_OK;
|
||||
}
|
||||
|
||||
|
@ -234,6 +238,7 @@ msg_t chSemWaitTimeout(semaphore_t *sp, systime_t time) {
|
|||
chSysLock();
|
||||
msg = chSemWaitTimeoutS(sp, time);
|
||||
chSysUnlock();
|
||||
|
||||
return msg;
|
||||
}
|
||||
|
||||
|
@ -267,12 +272,15 @@ msg_t chSemWaitTimeoutS(semaphore_t *sp, systime_t time) {
|
|||
if (--sp->s_cnt < 0) {
|
||||
if (TIME_IMMEDIATE == time) {
|
||||
sp->s_cnt++;
|
||||
|
||||
return MSG_TIMEOUT;
|
||||
}
|
||||
currp->p_u.wtobjp = sp;
|
||||
sem_insert(currp, &sp->s_queue);
|
||||
|
||||
return chSchGoSleepTimeoutS(CH_STATE_WTSEM, time);
|
||||
}
|
||||
|
||||
return MSG_OK;
|
||||
}
|
||||
|
||||
|
@ -291,8 +299,9 @@ void chSemSignal(semaphore_t *sp) {
|
|||
"inconsistent semaphore");
|
||||
|
||||
chSysLock();
|
||||
if (++sp->s_cnt <= 0)
|
||||
if (++sp->s_cnt <= 0) {
|
||||
chSchWakeupS(queue_fifo_remove(&sp->s_queue), MSG_OK);
|
||||
}
|
||||
chSysUnlock();
|
||||
}
|
||||
|
||||
|
@ -346,8 +355,9 @@ void chSemAddCounterI(semaphore_t *sp, cnt_t n) {
|
|||
"inconsistent semaphore");
|
||||
|
||||
while (n > 0) {
|
||||
if (++sp->s_cnt <= 0)
|
||||
if (++sp->s_cnt <= 0) {
|
||||
chSchReadyI(queue_fifo_remove(&sp->s_queue))->p_u.rdymsg = MSG_OK;
|
||||
}
|
||||
n--;
|
||||
}
|
||||
}
|
||||
|
@ -377,8 +387,9 @@ msg_t chSemSignalWait(semaphore_t *sps, semaphore_t *spw) {
|
|||
"inconsistent semaphore");
|
||||
|
||||
chSysLock();
|
||||
if (++sps->s_cnt <= 0)
|
||||
if (++sps->s_cnt <= 0) {
|
||||
chSchReadyI(queue_fifo_remove(&sps->s_queue))->p_u.rdymsg = MSG_OK;
|
||||
}
|
||||
if (--spw->s_cnt < 0) {
|
||||
thread_t *ctp = currp;
|
||||
sem_insert(ctp, &spw->s_queue);
|
||||
|
@ -391,6 +402,7 @@ msg_t chSemSignalWait(semaphore_t *sps, semaphore_t *spw) {
|
|||
msg = MSG_OK;
|
||||
}
|
||||
chSysUnlock();
|
||||
|
||||
return msg;
|
||||
}
|
||||
|
||||
|
|
|
@ -164,8 +164,8 @@ void chSysHalt(const char *reason) {
|
|||
ch.dbg.panic_msg = reason;
|
||||
|
||||
/* Harmless infinite loop.*/
|
||||
while (true)
|
||||
;
|
||||
while (true) {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -215,10 +215,12 @@ syssts_t chSysGetStatusAndLockX(void) {
|
|||
|
||||
syssts_t sts = port_get_irq_status();
|
||||
if (port_irq_enabled(sts)) {
|
||||
if (port_is_isr_context())
|
||||
if (port_is_isr_context()) {
|
||||
chSysLockFromISR();
|
||||
else
|
||||
}
|
||||
else {
|
||||
chSysLock();
|
||||
}
|
||||
}
|
||||
return sts;
|
||||
}
|
||||
|
@ -235,8 +237,9 @@ syssts_t chSysGetStatusAndLockX(void) {
|
|||
void chSysRestoreStatusX(syssts_t sts) {
|
||||
|
||||
if (port_irq_enabled(sts)) {
|
||||
if (port_is_isr_context())
|
||||
if (port_is_isr_context()) {
|
||||
chSysUnlockFromISR();
|
||||
}
|
||||
else {
|
||||
chSchRescheduleS();
|
||||
chSysUnlock();
|
||||
|
@ -283,8 +286,9 @@ bool chSysIsCounterWithinX(rtcnt_t cnt, rtcnt_t start, rtcnt_t end) {
|
|||
void chSysPolledDelayX(rtcnt_t cycles) {
|
||||
rtcnt_t start = chSysGetRealtimeCounterX();
|
||||
rtcnt_t end = start + cycles;
|
||||
while (chSysIsCounterWithinX(chSysGetRealtimeCounterX(), start, end))
|
||||
;
|
||||
|
||||
while (chSysIsCounterWithinX(chSysGetRealtimeCounterX(), start, end)) {
|
||||
}
|
||||
}
|
||||
#endif /* PORT_SUPPORTS_RT */
|
||||
|
||||
|
|
|
@ -144,8 +144,9 @@ thread_t *_thread_init(thread_t *tp, tprio_t prio) {
|
|||
*/
|
||||
void _thread_memfill(uint8_t *startp, uint8_t *endp, uint8_t v) {
|
||||
|
||||
while (startp < endp)
|
||||
while (startp < endp) {
|
||||
*startp++ = v;
|
||||
}
|
||||
}
|
||||
#endif /* CH_DBG_FILL_THREADS */
|
||||
|
||||
|
@ -184,6 +185,7 @@ thread_t *chThdCreateI(void *wsp, size_t size,
|
|||
(prio <= HIGHPRIO) && (pf != NULL));
|
||||
|
||||
PORT_SETUP_CONTEXT(tp, wsp, size, pf, arg);
|
||||
|
||||
return _thread_init(tp, prio);
|
||||
}
|
||||
|
||||
|
@ -215,9 +217,11 @@ thread_t *chThdCreateStatic(void *wsp, size_t size,
|
|||
(uint8_t *)wsp + size,
|
||||
CH_DBG_STACK_FILL_VALUE);
|
||||
#endif
|
||||
|
||||
chSysLock();
|
||||
chSchWakeupS(tp = chThdCreateI(wsp, size, prio, pf, arg), MSG_OK);
|
||||
chSysUnlock();
|
||||
|
||||
return tp;
|
||||
}
|
||||
|
||||
|
@ -235,6 +239,7 @@ thread_t *chThdStart(thread_t *tp) {
|
|||
chSysLock();
|
||||
tp = chThdStartI(tp);
|
||||
chSysUnlock();
|
||||
|
||||
return tp;
|
||||
}
|
||||
|
||||
|
@ -258,8 +263,9 @@ tprio_t chThdSetPriority(tprio_t newprio) {
|
|||
chSysLock();
|
||||
#if CH_CFG_USE_MUTEXES
|
||||
oldprio = currp->p_realprio;
|
||||
if ((currp->p_prio == currp->p_realprio) || (newprio > currp->p_prio))
|
||||
if ((currp->p_prio == currp->p_realprio) || (newprio > currp->p_prio)) {
|
||||
currp->p_prio = newprio;
|
||||
}
|
||||
currp->p_realprio = newprio;
|
||||
#else
|
||||
oldprio = currp->p_prio;
|
||||
|
@ -267,6 +273,7 @@ tprio_t chThdSetPriority(tprio_t newprio) {
|
|||
#endif
|
||||
chSchRescheduleS();
|
||||
chSysUnlock();
|
||||
|
||||
return oldprio;
|
||||
}
|
||||
|
||||
|
@ -324,8 +331,9 @@ void chThdSleep(systime_t time) {
|
|||
void chThdSleepUntil(systime_t time) {
|
||||
|
||||
chSysLock();
|
||||
if ((time -= chVTGetSystemTimeX()) > 0)
|
||||
if ((time -= chVTGetSystemTimeX()) > 0) {
|
||||
chThdSleepS(time);
|
||||
}
|
||||
chSysUnlock();
|
||||
}
|
||||
|
||||
|
@ -348,9 +356,11 @@ systime_t chThdSleepUntilWindowed(systime_t prev, systime_t next) {
|
|||
|
||||
chSysLock();
|
||||
time = chVTGetSystemTimeX();
|
||||
if (chVTIsTimeWithinX(time, prev, next))
|
||||
if (chVTIsTimeWithinX(time, prev, next)) {
|
||||
chThdSleepS(next - time);
|
||||
}
|
||||
chSysUnlock();
|
||||
|
||||
return next;
|
||||
}
|
||||
|
||||
|
@ -411,16 +421,19 @@ void chThdExitS(msg_t msg) {
|
|||
CH_CFG_THREAD_EXIT_HOOK(tp);
|
||||
#endif
|
||||
#if CH_CFG_USE_WAITEXIT
|
||||
while (list_notempty(&tp->p_waiting))
|
||||
while (list_notempty(&tp->p_waiting)) {
|
||||
chSchReadyI(list_remove(&tp->p_waiting));
|
||||
}
|
||||
#endif
|
||||
#if CH_CFG_USE_REGISTRY
|
||||
/* Static threads are immediately removed from the registry because
|
||||
there is no memory to recover.*/
|
||||
if ((tp->p_flags & CH_FLAG_MODE_MASK) == CH_FLAG_MODE_STATIC)
|
||||
if ((tp->p_flags & CH_FLAG_MODE_MASK) == CH_FLAG_MODE_STATIC) {
|
||||
REG_REMOVE(tp);
|
||||
}
|
||||
#endif
|
||||
chSchGoSleepS(CH_STATE_FINAL);
|
||||
|
||||
/* The thread never returns here.*/
|
||||
chDbgAssert(false, "zombies apocalypse");
|
||||
}
|
||||
|
@ -473,9 +486,11 @@ msg_t chThdWait(thread_t *tp) {
|
|||
}
|
||||
msg = tp->p_u.exitcode;
|
||||
chSysUnlock();
|
||||
|
||||
#if CH_CFG_USE_DYNAMIC
|
||||
chThdRelease(tp);
|
||||
#endif
|
||||
|
||||
return msg;
|
||||
}
|
||||
#endif /* CH_CFG_USE_WAITEXIT */
|
||||
|
@ -498,6 +513,7 @@ msg_t chThdSuspendS(thread_reference_t *trp) {
|
|||
*trp = tp;
|
||||
tp->p_u.wtobjp = &trp;
|
||||
chSchGoSleepS(CH_STATE_SUSPENDED);
|
||||
|
||||
return chThdGetSelfX()->p_u.rdymsg;
|
||||
}
|
||||
|
||||
|
@ -525,11 +541,13 @@ msg_t chThdSuspendTimeoutS(thread_reference_t *trp, systime_t timeout) {
|
|||
|
||||
chDbgAssert(*trp == NULL, "not NULL");
|
||||
|
||||
if (TIME_IMMEDIATE == timeout)
|
||||
if (TIME_IMMEDIATE == timeout) {
|
||||
return MSG_TIMEOUT;
|
||||
}
|
||||
|
||||
*trp = tp;
|
||||
tp->p_u.wtobjp = &trp;
|
||||
|
||||
return chSchGoSleepTimeoutS(CH_STATE_SUSPENDED, timeout);
|
||||
}
|
||||
|
||||
|
@ -622,10 +640,12 @@ void chThdResume(thread_reference_t *trp, msg_t msg) {
|
|||
*/
|
||||
msg_t chThdEnqueueTimeoutS(threads_queue_t *tqp, systime_t timeout) {
|
||||
|
||||
if (TIME_IMMEDIATE == timeout)
|
||||
if (TIME_IMMEDIATE == timeout) {
|
||||
return MSG_TIMEOUT;
|
||||
}
|
||||
|
||||
queue_insert(currp, tqp);
|
||||
|
||||
return chSchGoSleepTimeoutS(CH_STATE_QUEUED, timeout);
|
||||
}
|
||||
|
||||
|
@ -640,8 +660,9 @@ msg_t chThdEnqueueTimeoutS(threads_queue_t *tqp, systime_t timeout) {
|
|||
*/
|
||||
void chThdDequeueNextI(threads_queue_t *tqp, msg_t msg) {
|
||||
|
||||
if (queue_notempty(tqp))
|
||||
if (queue_notempty(tqp)) {
|
||||
chThdDoDequeueNextI(tqp, msg);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -654,8 +675,9 @@ void chThdDequeueNextI(threads_queue_t *tqp, msg_t msg) {
|
|||
*/
|
||||
void chThdDequeueAllI(threads_queue_t *tqp, msg_t msg) {
|
||||
|
||||
while (queue_notempty(tqp))
|
||||
while (queue_notempty(tqp)) {
|
||||
chThdDoDequeueNextI(tqp, msg);
|
||||
}
|
||||
}
|
||||
|
||||
/** @} */
|
||||
|
|
|
@ -57,10 +57,12 @@ static inline void tm_stop(time_measurement_t *tmp,
|
|||
tmp->n++;
|
||||
tmp->last = now - tmp->last - offset;
|
||||
tmp->cumulative += (rttime_t)tmp->last;
|
||||
if (tmp->last > tmp->worst)
|
||||
if (tmp->last > tmp->worst) {
|
||||
tmp->worst = tmp->last;
|
||||
else if (tmp->last < tmp->best)
|
||||
}
|
||||
else if (tmp->last < tmp->best) {
|
||||
tmp->best = tmp->last;
|
||||
}
|
||||
}
|
||||
|
||||
/*===========================================================================*/
|
||||
|
|
|
@ -108,8 +108,9 @@ void chVTDoSetI(virtual_timer_t *vtp, systime_t delay,
|
|||
|
||||
/* If the requested delay is lower than the minimum safe delta then it
|
||||
is raised to the minimum safe value.*/
|
||||
if (delay < CH_CFG_ST_TIMEDELTA)
|
||||
if (delay < CH_CFG_ST_TIMEDELTA) {
|
||||
delay = CH_CFG_ST_TIMEDELTA;
|
||||
}
|
||||
|
||||
if (&ch.vtlist == (virtual_timers_list_t *)p) {
|
||||
/* The delta list is empty, the current time becomes the new
|
||||
|
@ -124,8 +125,9 @@ void chVTDoSetI(virtual_timer_t *vtp, systime_t delay,
|
|||
|
||||
/* If the specified delay is closer in time than the first element
|
||||
in the delta list then it becomes the next alarm event in time.*/
|
||||
if (delay < p->vt_delta)
|
||||
if (delay < p->vt_delta) {
|
||||
port_timer_set_alarm(ch.vtlist.vt_lasttime + delay);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* CH_CFG_ST_TIMEDELTA > 0 */
|
||||
|
@ -181,12 +183,14 @@ void chVTDoResetI(virtual_timer_t *vtp) {
|
|||
else {
|
||||
/* Updating the alarm to the next deadline, deadline that must not be
|
||||
closer in time than the minimum time delta.*/
|
||||
if (ch.vtlist.vt_next->vt_delta >= CH_CFG_ST_TIMEDELTA)
|
||||
if (ch.vtlist.vt_next->vt_delta >= CH_CFG_ST_TIMEDELTA) {
|
||||
port_timer_set_alarm(ch.vtlist.vt_lasttime +
|
||||
ch.vtlist.vt_next->vt_delta);
|
||||
else
|
||||
}
|
||||
else {
|
||||
port_timer_set_alarm(ch.vtlist.vt_lasttime +
|
||||
CH_CFG_ST_TIMEDELTA);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* CH_CFG_ST_TIMEDELTA > 0 */
|
||||
|
|
Loading…
Reference in New Issue