aboutsummaryrefslogtreecommitdiffstats
path: root/os/rt/src
diff options
context:
space:
mode:
Diffstat (limited to 'os/rt/src')
-rw-r--r--os/rt/src/chcond.c10
-rw-r--r--os/rt/src/chdynamic.c27
-rw-r--r--os/rt/src/chevents.c20
-rw-r--r--os/rt/src/chheap.c13
-rw-r--r--os/rt/src/chmboxes.c24
-rw-r--r--os/rt/src/chmemcore.c16
-rw-r--r--os/rt/src/chmsg.c8
-rw-r--r--os/rt/src/chmtx.c67
-rw-r--r--os/rt/src/chqueues.c21
-rw-r--r--os/rt/src/chregistry.c23
-rw-r--r--os/rt/src/chsem.c8
-rw-r--r--os/rt/src/chthreads.c36
12 files changed, 167 insertions, 106 deletions
diff --git a/os/rt/src/chcond.c b/os/rt/src/chcond.c
index d4234d6b6..b6d6219da 100644
--- a/os/rt/src/chcond.c
+++ b/os/rt/src/chcond.c
@@ -39,7 +39,7 @@
#include "ch.h"
-#if CH_CFG_USE_CONDVARS || defined(__DOXYGEN__)
+#if (CH_CFG_USE_CONDVARS == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Module local definitions. */
@@ -116,7 +116,7 @@ void chCondSignalI(condition_variable_t *cp) {
if (queue_notempty(&cp->c_queue)) {
thread_t *tp = queue_fifo_remove(&cp->c_queue);
tp->p_u.rdymsg = MSG_OK;
- chSchReadyI(tp);
+ (void) chSchReadyI(tp);
}
}
@@ -226,7 +226,7 @@ msg_t chCondWaitS(condition_variable_t *cp) {
return msg;
}
-#if CH_CFG_USE_CONDVARS_TIMEOUT || defined(__DOXYGEN__)
+#if (CH_CFG_USE_CONDVARS_TIMEOUT == TRUE) || defined(__DOXYGEN__)
/**
* @brief Waits on the condition variable releasing the mutex lock.
* @details Releases the currently owned mutex, waits on the condition
@@ -316,8 +316,8 @@ msg_t chCondWaitTimeoutS(condition_variable_t *cp, systime_t time) {
return msg;
}
-#endif /* CH_CFG_USE_CONDVARS_TIMEOUT */
+#endif /* CH_CFG_USE_CONDVARS_TIMEOUT == TRUE */
-#endif /* CH_CFG_USE_CONDVARS */
+#endif /* CH_CFG_USE_CONDVARS == TRUE */
/** @} */
diff --git a/os/rt/src/chdynamic.c b/os/rt/src/chdynamic.c
index 9a0c33303..185a456b3 100644
--- a/os/rt/src/chdynamic.c
+++ b/os/rt/src/chdynamic.c
@@ -28,7 +28,7 @@
#include "ch.h"
-#if CH_CFG_USE_DYNAMIC || defined(__DOXYGEN__)
+#if (CH_CFG_USE_DYNAMIC == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Module local definitions. */
@@ -101,27 +101,30 @@ void chThdRelease(thread_t *tp) {
allocator. Of course static threads are not affected.*/
if ((refs == 0U) && (tp->p_state == CH_STATE_FINAL)) {
switch (tp->p_flags & CH_FLAG_MODE_MASK) {
-#if CH_CFG_USE_HEAP
+#if CH_CFG_USE_HEAP == TRUE
case CH_FLAG_MODE_HEAP:
-#if CH_CFG_USE_REGISTRY
+#if CH_CFG_USE_REGISTRY == TRUE
REG_REMOVE(tp);
#endif
chHeapFree(tp);
break;
#endif
-#if CH_CFG_USE_MEMPOOLS
+#if CH_CFG_USE_MEMPOOLS == TRUE
case CH_FLAG_MODE_MEMPOOL:
-#if CH_CFG_USE_REGISTRY
+#if CH_CFG_USE_REGISTRY == TRUE
REG_REMOVE(tp);
#endif
chPoolFree(tp->p_mpool, tp);
break;
#endif
+ default:
+ chDbgAssert(false, "unexpected case");
+ break;
}
}
}
-#if CH_CFG_USE_HEAP || defined(__DOXYGEN__)
+#if (CH_CFG_USE_HEAP == TRUE) || defined(__DOXYGEN__)
/**
* @brief Creates a new thread allocating the memory from the heap.
* @pre The configuration options @p CH_CFG_USE_DYNAMIC and
@@ -154,7 +157,7 @@ thread_t *chThdCreateFromHeap(memory_heap_t *heapp, size_t size,
return NULL;
}
-#if CH_DBG_FILL_THREADS
+#if CH_DBG_FILL_THREADS == TRUE
_thread_memfill((uint8_t *)wsp,
(uint8_t *)wsp + sizeof(thread_t),
CH_DBG_THREAD_FILL_VALUE);
@@ -171,9 +174,9 @@ thread_t *chThdCreateFromHeap(memory_heap_t *heapp, size_t size,
return tp;
}
-#endif /* CH_CFG_USE_HEAP */
+#endif /* CH_CFG_USE_HEAP == TRUE */
-#if CH_CFG_USE_MEMPOOLS || defined(__DOXYGEN__)
+#if (CH_CFG_USE_MEMPOOLS == TRUE) || defined(__DOXYGEN__)
/**
* @brief Creates a new thread allocating the memory from the specified
* memory pool.
@@ -208,7 +211,7 @@ thread_t *chThdCreateFromMemoryPool(memory_pool_t *mp, tprio_t prio,
return NULL;
}
-#if CH_DBG_FILL_THREADS
+#if CH_DBG_FILL_THREADS == TRUE
_thread_memfill((uint8_t *)wsp,
(uint8_t *)wsp + sizeof(thread_t),
CH_DBG_THREAD_FILL_VALUE);
@@ -226,8 +229,8 @@ thread_t *chThdCreateFromMemoryPool(memory_pool_t *mp, tprio_t prio,
return tp;
}
-#endif /* CH_CFG_USE_MEMPOOLS */
+#endif /* CH_CFG_USE_MEMPOOLS == TRUE */
-#endif /* CH_CFG_USE_DYNAMIC */
+#endif /* CH_CFG_USE_DYNAMIC == TRUE */
/** @} */
diff --git a/os/rt/src/chevents.c b/os/rt/src/chevents.c
index dfd1171bd..61b93086c 100644
--- a/os/rt/src/chevents.c
+++ b/os/rt/src/chevents.c
@@ -59,7 +59,7 @@
#include "ch.h"
-#if CH_CFG_USE_EVENTS || defined(__DOXYGEN__)
+#if (CH_CFG_USE_EVENTS == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Module local definitions. */
@@ -135,9 +135,13 @@ void chEvtUnregister(event_source_t *esp, event_listener_t *elp) {
chDbgCheck((esp != NULL) && (elp != NULL));
+ /*lint -save -e9087 -e740 [11.3, 1.3] Cast required by list handling.*/
p = (event_listener_t *)esp;
+ /*lint -restore*/
chSysLock();
+ /*lint -save -e9087 -e740 [11.3, 1.3] Cast required by list handling.*/
while (p->el_next != (event_listener_t *)esp) {
+ /*lint -restore*/
if (p->el_next == elp) {
p->el_next = elp->el_next;
break;
@@ -208,7 +212,9 @@ void chEvtBroadcastFlagsI(event_source_t *esp, eventflags_t flags) {
chDbgCheck(esp != NULL);
elp = esp->es_next;
+ /*lint -save -e9087 -e740 [11.3, 1.3] Cast required by list handling.*/
while (elp != (event_listener_t *)esp) {
+ /*list -restore*/
elp->el_flags |= flags;
/* When flags == 0 the thread will always be signaled because the
source does not emit any flag.*/
@@ -283,7 +289,7 @@ void chEvtSignalI(thread_t *tp, eventmask_t events) {
((tp->p_state == CH_STATE_WTANDEVT) &&
((tp->p_epending & tp->p_u.ewmask) == tp->p_u.ewmask))) {
tp->p_u.rdymsg = MSG_OK;
- chSchReadyI(tp);
+ (void) chSchReadyI(tp);
}
}
@@ -353,7 +359,9 @@ void chEvtDispatch(const evhandler_t *handlers, eventmask_t events) {
}
}
-#if CH_CFG_OPTIMIZE_SPEED || !CH_CFG_USE_EVENTS_TIMEOUT || defined(__DOXYGEN__)
+#if (CH_CFG_OPTIMIZE_SPEED == TRUE) || \
+ (CH_CFG_USE_EVENTS_TIMEOUT == FALSE) || \
+ defined(__DOXYGEN__)
/**
* @brief Waits for exactly one of the specified events.
* @details The function waits for one event among those specified in
@@ -441,7 +449,7 @@ eventmask_t chEvtWaitAll(eventmask_t events) {
}
#endif /* CH_CFG_OPTIMIZE_SPEED || !CH_CFG_USE_EVENTS_TIMEOUT */
-#if CH_CFG_USE_EVENTS_TIMEOUT || defined(__DOXYGEN__)
+#if (CH_CFG_USE_EVENTS_TIMEOUT == TRUE) || defined(__DOXYGEN__)
/**
* @brief Waits for exactly one of the specified events.
* @details The function waits for one event among those specified in
@@ -566,8 +574,8 @@ eventmask_t chEvtWaitAllTimeout(eventmask_t events, systime_t time) {
return events;
}
-#endif /* CH_CFG_USE_EVENTS_TIMEOUT */
+#endif /* CH_CFG_USE_EVENTS_TIMEOUT == TRUE */
-#endif /* CH_CFG_USE_EVENTS */
+#endif /* CH_CFG_USE_EVENTS == TRUE */
/** @} */
diff --git a/os/rt/src/chheap.c b/os/rt/src/chheap.c
index 305b88795..a2ed3ddb0 100644
--- a/os/rt/src/chheap.c
+++ b/os/rt/src/chheap.c
@@ -35,7 +35,7 @@
#include "ch.h"
-#if CH_CFG_USE_HEAP || defined(__DOXYGEN__)
+#if (CH_CFG_USE_HEAP == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Module local definitions. */
@@ -44,7 +44,7 @@
/*
* Defaults on the best synchronization mechanism available.
*/
-#if CH_CFG_USE_MUTEXES || defined(__DOXYGEN__)
+#if (CH_CFG_USE_MUTEXES == TRUE) || defined(__DOXYGEN__)
#define H_LOCK(h) chMtxLock(&(h)->h_mtx)
#define H_UNLOCK(h) chMtxUnlock(&(h)->h_mtx)
#else
@@ -87,7 +87,7 @@ 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;
-#if CH_CFG_USE_MUTEXES || defined(__DOXYGEN__)
+#if (CH_CFG_USE_MUTEXES == TRUE) || defined(__DOXYGEN__)
chMtxObjectInit(&default_heap.h_mtx);
#else
chSemObjectInit(&default_heap.h_sem, 1);
@@ -115,7 +115,7 @@ void chHeapObjectInit(memory_heap_t *heapp, void *buf, size_t size) {
heapp->h_free.h.size = 0;
hp->h.u.next = NULL;
hp->h.size = size - sizeof(union heap_header);
-#if CH_CFG_USE_MUTEXES || defined(__DOXYGEN__)
+#if (CH_CFG_USE_MUTEXES == TRUE) || defined(__DOXYGEN__)
chMtxObjectInit(&heapp->h_mtx);
#else
chSemObjectInit(&heapp->h_sem, 1);
@@ -215,8 +215,11 @@ void chHeapFree(void *p) {
while (true) {
chDbgAssert((hp < qp) || (hp >= LIMIT(qp)), "within free block");
+ /*lint -save -e946 -e947 [18.2, 18.3] Normal pointers arithmetic, it
+ is safe.*/
if (((qp == &heapp->h_free) || (hp > qp)) &&
((qp->h.u.next == NULL) || (hp < qp->h.u.next))) {
+ /*lint -restore*/
/* Insertion after qp.*/
hp->h.u.next = qp->h.u.next;
qp->h.u.next = hp;
@@ -274,6 +277,6 @@ size_t chHeapStatus(memory_heap_t *heapp, size_t *sizep) {
return n;
}
-#endif /* CH_CFG_USE_HEAP */
+#endif /* CH_CFG_USE_HEAP == TRUE */
/** @} */
diff --git a/os/rt/src/chmboxes.c b/os/rt/src/chmboxes.c
index 32d0f35ea..5b8bc3f64 100644
--- a/os/rt/src/chmboxes.c
+++ b/os/rt/src/chmboxes.c
@@ -51,7 +51,7 @@
#include "ch.h"
-#if CH_CFG_USE_MAILBOXES || defined(__DOXYGEN__)
+#if (CH_CFG_USE_MAILBOXES == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Module exported variables. */
@@ -124,8 +124,12 @@ void chMBResetI(mailbox_t *mbp) {
chDbgCheckClassI();
chDbgCheck(mbp != NULL);
- mbp->mb_wrptr = mbp->mb_rdptr = mbp->mb_buffer;
- chSemResetI(&mbp->mb_emptysem, mbp->mb_top - mbp->mb_buffer);
+ mbp->mb_wrptr = mbp->mb_buffer;
+ mbp->mb_rdptr = mbp->mb_buffer;
+ /*lint -save -e946 -e947 [18.2, 18.3] Normal pointers arithmetic, it
+ is safe.*/
+ chSemResetI(&mbp->mb_emptysem, (cnt_t)(mbp->mb_top - mbp->mb_buffer));
+ /*lint -restore*/
chSemResetI(&mbp->mb_fullsem, 0);
}
@@ -186,7 +190,9 @@ 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;
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
if (mbp->mb_wrptr >= mbp->mb_top) {
+ /*lint -restore*/
mbp->mb_wrptr = mbp->mb_buffer;
}
chSemSignalI(&mbp->mb_fullsem);
@@ -221,7 +227,9 @@ msg_t chMBPostI(mailbox_t *mbp, msg_t msg) {
chSemFastWaitI(&mbp->mb_emptysem);
*mbp->mb_wrptr++ = msg;
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
if (mbp->mb_wrptr >= mbp->mb_top) {
+ /*lint -restore*/
mbp->mb_wrptr = mbp->mb_buffer;
}
chSemSignalI(&mbp->mb_fullsem);
@@ -285,7 +293,9 @@ msg_t chMBPostAheadS(mailbox_t *mbp, msg_t msg, systime_t time) {
rdymsg = chSemWaitTimeoutS(&mbp->mb_emptysem, time);
if (rdymsg == MSG_OK) {
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
if (--mbp->mb_rdptr < mbp->mb_buffer) {
+ /*lint -restore*/
mbp->mb_rdptr = mbp->mb_top - 1;
}
*mbp->mb_rdptr = msg;
@@ -319,7 +329,9 @@ msg_t chMBPostAheadI(mailbox_t *mbp, msg_t msg) {
return MSG_TIMEOUT;
}
chSemFastWaitI(&mbp->mb_emptysem);
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
if (--mbp->mb_rdptr < mbp->mb_buffer) {
+ /*lint -restore*/
mbp->mb_rdptr = mbp->mb_top - 1;
}
*mbp->mb_rdptr = msg;
@@ -385,7 +397,9 @@ 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++;
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
if (mbp->mb_rdptr >= mbp->mb_top) {
+ /*lint -restore*/
mbp->mb_rdptr = mbp->mb_buffer;
}
chSemSignalI(&mbp->mb_emptysem);
@@ -419,13 +433,15 @@ msg_t chMBFetchI(mailbox_t *mbp, msg_t *msgp) {
}
chSemFastWaitI(&mbp->mb_fullsem);
*msgp = *mbp->mb_rdptr++;
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
if (mbp->mb_rdptr >= mbp->mb_top) {
+ /*lint -restore*/
mbp->mb_rdptr = mbp->mb_buffer;
}
chSemSignalI(&mbp->mb_emptysem);
return MSG_OK;
}
-#endif /* CH_CFG_USE_MAILBOXES */
+#endif /* CH_CFG_USE_MAILBOXES == TRUE */
/** @} */
diff --git a/os/rt/src/chmemcore.c b/os/rt/src/chmemcore.c
index 95c8d2682..1529fc2cf 100644
--- a/os/rt/src/chmemcore.c
+++ b/os/rt/src/chmemcore.c
@@ -45,7 +45,7 @@
#include "ch.h"
-#if CH_CFG_USE_MEMCORE || defined(__DOXYGEN__)
+#if (CH_CFG_USE_MEMCORE == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Module exported variables. */
@@ -83,10 +83,12 @@ void _core_init(void) {
nextmem = (uint8_t *)MEM_ALIGN_NEXT(__heap_base__);
endmem = (uint8_t *)MEM_ALIGN_PREV(__heap_end__);
#else
- static stkalign_t buffer[MEM_ALIGN_NEXT(CH_CFG_MEMCORE_SIZE)/MEM_ALIGN_SIZE];
+ static stkalign_t buffer[MEM_ALIGN_NEXT(CH_CFG_MEMCORE_SIZE) /
+ MEM_ALIGN_SIZE];
nextmem = (uint8_t *)&buffer[0];
- endmem = (uint8_t *)&buffer[MEM_ALIGN_NEXT(CH_CFG_MEMCORE_SIZE)/MEM_ALIGN_SIZE];
+ endmem = (uint8_t *)&buffer[MEM_ALIGN_NEXT(CH_CFG_MEMCORE_SIZE) /
+ MEM_ALIGN_SIZE];
#endif
}
@@ -130,7 +132,10 @@ void *chCoreAllocI(size_t size) {
chDbgCheckClassI();
size = MEM_ALIGN_NEXT(size);
+ /*lint -save -e946 -e947 [18.2, 18.3] Normal pointers arithmetic, it
+ is safe.*/
if ((size_t)(endmem - nextmem) < size) {
+ /*lint -restore*/
return NULL;
}
p = nextmem;
@@ -148,8 +153,11 @@ void *chCoreAllocI(size_t size) {
*/
size_t chCoreGetStatusX(void) {
+ /*lint -save -e946 -e947 [18.2, 18.3] Normal pointers arithmetic, it
+ is safe.*/
return (size_t)(endmem - nextmem);
+ /*lint -restore*/
}
-#endif /* CH_CFG_USE_MEMCORE */
+#endif /* CH_CFG_USE_MEMCORE == TRUE */
/** @} */
diff --git a/os/rt/src/chmsg.c b/os/rt/src/chmsg.c
index d757efd77..7b559e8ed 100644
--- a/os/rt/src/chmsg.c
+++ b/os/rt/src/chmsg.c
@@ -45,7 +45,7 @@
#include "ch.h"
-#if CH_CFG_USE_MESSAGES || defined(__DOXYGEN__)
+#if (CH_CFG_USE_MESSAGES == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Module exported variables. */
@@ -63,7 +63,7 @@
/* Module local functions. */
/*===========================================================================*/
-#if CH_CFG_USE_MESSAGES_PRIORITY
+#if CH_CFG_USE_MESSAGES_PRIORITY == TRUE
#define msg_insert(tp, qp) queue_prio_insert(tp, qp)
#else
#define msg_insert(tp, qp) queue_insert(tp, qp)
@@ -94,7 +94,7 @@ msg_t chMsgSend(thread_t *tp, msg_t msg) {
ctp->p_u.wtobjp = &tp->p_msgqueue;
msg_insert(ctp, &tp->p_msgqueue);
if (tp->p_state == CH_STATE_WTMSG) {
- chSchReadyI(tp);
+ (void) chSchReadyI(tp);
}
chSchGoSleepS(CH_STATE_SNDMSGQ);
msg = ctp->p_u.rdymsg;
@@ -149,6 +149,6 @@ void chMsgRelease(thread_t *tp, msg_t msg) {
chSysUnlock();
}
-#endif /* CH_CFG_USE_MESSAGES */
+#endif /* CH_CFG_USE_MESSAGES == TRUE */
/** @} */
diff --git a/os/rt/src/chmtx.c b/os/rt/src/chmtx.c
index e31fbe558..13ae7e6fc 100644
--- a/os/rt/src/chmtx.c
+++ b/os/rt/src/chmtx.c
@@ -71,7 +71,7 @@
#include "ch.h"
-#if CH_CFG_USE_MUTEXES || defined(__DOXYGEN__)
+#if (CH_CFG_USE_MUTEXES == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Module exported variables. */
@@ -106,7 +106,7 @@ void chMtxObjectInit(mutex_t *mp) {
queue_init(&mp->m_queue);
mp->m_owner = NULL;
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
mp->m_cnt = 0;
#endif
}
@@ -144,7 +144,7 @@ void chMtxLockS(mutex_t *mp) {
/* Is the mutex already locked? */
if (mp->m_owner != NULL) {
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
chDbgAssert(mp->m_cnt >= 1, "counter is not positive");
@@ -174,30 +174,35 @@ void chMtxLockS(mutex_t *mp) {
(threads_queue_t *)tp->p_u.wtobjp);
tp = ((mutex_t *)tp->p_u.wtobjp)->m_owner;
continue;
- #if CH_CFG_USE_CONDVARS | \
- (CH_CFG_USE_SEMAPHORES && CH_CFG_USE_SEMAPHORES_PRIORITY) | \
- (CH_CFG_USE_MESSAGES && CH_CFG_USE_MESSAGES_PRIORITY)
- #if CH_CFG_USE_CONDVARS
+#if (CH_CFG_USE_CONDVARS == TRUE) | \
+ ((CH_CFG_USE_SEMAPHORES == TRUE) && \
+ (CH_CFG_USE_SEMAPHORES_PRIORITY) == TRUE) | \
+ ((CH_CFG_USE_MESSAGES == TRUE) && (CH_CFG_USE_MESSAGES_PRIORITY == TRUE))
+#if CH_CFG_USE_CONDVARS == TRUE
case CH_STATE_WTCOND:
- #endif
- #if CH_CFG_USE_SEMAPHORES && CH_CFG_USE_SEMAPHORES_PRIORITY
+#endif
+#if (CH_CFG_USE_SEMAPHORES == TRUE) && \
+ (CH_CFG_USE_SEMAPHORES_PRIORITY == TRUE)
case CH_STATE_WTSEM:
- #endif
- #if CH_CFG_USE_MESSAGES && CH_CFG_USE_MESSAGES_PRIORITY
+#endif
+#if (CH_CFG_USE_MESSAGES == TRUE) && (CH_CFG_USE_MESSAGES_PRIORITY == TRUE)
case CH_STATE_SNDMSGQ:
- #endif
+#endif
/* Re-enqueues tp with its new priority on the queue.*/
queue_prio_insert(queue_dequeue(tp),
(threads_queue_t *)tp->p_u.wtobjp);
break;
- #endif
+#endif
case CH_STATE_READY:
- #if CH_DBG_ENABLE_ASSERTS
+#if CH_DBG_ENABLE_ASSERTS == TRUE
/* Prevents an assertion in chSchReadyI().*/
tp->p_state = CH_STATE_CURRENT;
- #endif
+#endif
/* Re-enqueues tp with its new priority on the ready list.*/
- chSchReadyI(queue_dequeue(tp));
+ (void) chSchReadyI(queue_dequeue(tp));
+ break;
+ default:
+ chDbgAssert(false, "unexpected state");
break;
}
break;
@@ -212,13 +217,13 @@ void chMtxLockS(mutex_t *mp) {
the mutex to this thread.*/
chDbgAssert(mp->m_owner == ctp, "not owner");
chDbgAssert(ctp->p_mtxlist == mp, "not owned");
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
chDbgAssert(mp->m_cnt == 1, "counter is not one");
}
#endif
}
else {
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
chDbgAssert(mp->m_cnt == 0, "counter is not zero");
mp->m_cnt++;
@@ -280,7 +285,7 @@ bool chMtxTryLockS(mutex_t *mp) {
chDbgCheck(mp != NULL);
if (mp->m_owner != NULL) {
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
chDbgAssert(mp->m_cnt >= 1, "counter is not positive");
@@ -291,7 +296,7 @@ bool chMtxTryLockS(mutex_t *mp) {
#endif
return false;
}
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
chDbgAssert(mp->m_cnt == 0, "counter is not zero");
@@ -325,7 +330,7 @@ void chMtxUnlock(mutex_t *mp) {
chDbgAssert(ctp->p_mtxlist != NULL, "owned mutexes list empty");
chDbgAssert(ctp->p_mtxlist->m_owner == ctp, "ownership failure");
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
chDbgAssert(mp->m_cnt >= 1, "counter is not positive");
if (--mp->m_cnt == 0) {
@@ -363,7 +368,7 @@ void chMtxUnlock(mutex_t *mp) {
/* Awakens the highest priority thread waiting for the unlocked mutex and
assigns the mutex to it.*/
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
mp->m_cnt = 1;
#endif
tp = queue_fifo_remove(&mp->m_queue);
@@ -375,7 +380,7 @@ void chMtxUnlock(mutex_t *mp) {
else {
mp->m_owner = NULL;
}
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
}
#endif
@@ -405,7 +410,7 @@ void chMtxUnlockS(mutex_t *mp) {
chDbgAssert(ctp->p_mtxlist != NULL, "owned mutexes list empty");
chDbgAssert(ctp->p_mtxlist->m_owner == ctp, "ownership failure");
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
chDbgAssert(mp->m_cnt >= 1, "counter is not positive");
if (--mp->m_cnt == 0) {
@@ -443,19 +448,19 @@ void chMtxUnlockS(mutex_t *mp) {
/* Awakens the highest priority thread waiting for the unlocked mutex and
assigns the mutex to it.*/
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
mp->m_cnt = 1;
#endif
tp = queue_fifo_remove(&mp->m_queue);
mp->m_owner = tp;
mp->m_next = tp->p_mtxlist;
tp->p_mtxlist = mp;
- chSchReadyI(tp);
+ (void) chSchReadyI(tp);
}
else {
mp->m_owner = NULL;
}
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
}
#endif
}
@@ -480,17 +485,17 @@ void chMtxUnlockAll(void) {
mutex_t *mp = ctp->p_mtxlist;
ctp->p_mtxlist = mp->m_next;
if (chMtxQueueNotEmptyS(mp)) {
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
mp->m_cnt = 1;
#endif
thread_t *tp = queue_fifo_remove(&mp->m_queue);
mp->m_owner = tp;
mp->m_next = tp->p_mtxlist;
tp->p_mtxlist = mp;
- chSchReadyI(tp);
+ (void) chSchReadyI(tp);
}
else {
-#if CH_CFG_USE_MUTEXES_RECURSIVE
+#if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE
mp->m_cnt = 0;
#endif
mp->m_owner = NULL;
@@ -502,6 +507,6 @@ void chMtxUnlockAll(void) {
chSysUnlock();
}
-#endif /* CH_CFG_USE_MUTEXES */
+#endif /* CH_CFG_USE_MUTEXES == TRUE */
/** @} */
diff --git a/os/rt/src/chqueues.c b/os/rt/src/chqueues.c
index f85cac9bc..f02eb14a0 100644
--- a/os/rt/src/chqueues.c
+++ b/os/rt/src/chqueues.c
@@ -42,7 +42,7 @@
#include "ch.h"
-#if CH_CFG_USE_QUEUES || defined(__DOXYGEN__)
+#if (CH_CFG_USE_QUEUES == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Module local definitions. */
@@ -138,7 +138,9 @@ msg_t chIQPutI(input_queue_t *iqp, uint8_t b) {
iqp->q_counter++;
*iqp->q_wrptr++ = b;
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
if (iqp->q_wrptr >= iqp->q_top) {
+ /*lint -restore*/
iqp->q_wrptr = iqp->q_buffer;
}
@@ -185,7 +187,9 @@ msg_t chIQGetTimeout(input_queue_t *iqp, systime_t time) {
iqp->q_counter--;
b = *iqp->q_rdptr++;
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
if (iqp->q_rdptr >= iqp->q_top) {
+ /*lint -restore*/
iqp->q_rdptr = iqp->q_buffer;
}
chSysUnlock();
@@ -239,8 +243,11 @@ size_t chIQReadTimeout(input_queue_t *iqp, uint8_t *bp,
iqp->q_counter--;
*bp++ = *iqp->q_rdptr++;
- if (iqp->q_rdptr >= iqp->q_top)
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
+ if (iqp->q_rdptr >= iqp->q_top) {
+ /*lint -restore*/
iqp->q_rdptr = iqp->q_buffer;
+ }
chSysUnlock(); /* Gives a preemption chance in a controlled point.*/
r++;
@@ -295,7 +302,7 @@ void chOQResetI(output_queue_t *oqp) {
chDbgCheckClassI();
oqp->q_rdptr = oqp->q_wrptr = oqp->q_buffer;
- oqp->q_counter = QSIZE(oqp);
+ oqp->q_counter = chQSizeX(oqp);
chThdDequeueAllI(&oqp->q_waiting, Q_RESET);
}
@@ -335,7 +342,9 @@ msg_t chOQPutTimeout(output_queue_t *oqp, uint8_t b, systime_t time) {
oqp->q_counter--;
*oqp->q_wrptr++ = b;
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
if (oqp->q_wrptr >= oqp->q_top) {
+ /*lint -restore*/
oqp->q_wrptr = oqp->q_buffer;
}
@@ -368,7 +377,9 @@ msg_t chOQGetI(output_queue_t *oqp) {
oqp->q_counter++;
b = *oqp->q_rdptr++;
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
if (oqp->q_rdptr >= oqp->q_top) {
+ /*lint -restore*/
oqp->q_rdptr = oqp->q_buffer;
}
@@ -418,7 +429,9 @@ size_t chOQWriteTimeout(output_queue_t *oqp, const uint8_t *bp,
}
oqp->q_counter--;
*oqp->q_wrptr++ = *bp++;
+ /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/
if (oqp->q_wrptr >= oqp->q_top) {
+ /*lint -restore*/
oqp->q_wrptr = oqp->q_buffer;
}
@@ -434,6 +447,6 @@ size_t chOQWriteTimeout(output_queue_t *oqp, const uint8_t *bp,
chSysLock();
}
}
-#endif /* CH_CFG_USE_QUEUES */
+#endif /* CH_CFG_USE_QUEUES == TRUE */
/** @} */
diff --git a/os/rt/src/chregistry.c b/os/rt/src/chregistry.c
index 157d90d11..bd49925af 100644
--- a/os/rt/src/chregistry.c
+++ b/os/rt/src/chregistry.c
@@ -46,7 +46,7 @@
*/
#include "ch.h"
-#if CH_CFG_USE_REGISTRY || defined(__DOXYGEN__)
+#if (CH_CFG_USE_REGISTRY == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Module exported variables. */
@@ -65,7 +65,10 @@
/*===========================================================================*/
#define _offsetof(st, m) \
- ((size_t)((char *)&((st *)0)->m - (char *)0))
+ /*lint -save -e946 -e947 -e9033 -e413 [18.2, 18.3, 10.8 1.3] Normal
+ pointers arithmetic, it is safe.*/ \
+ ((size_t)((char *)&((st *)0)->m - (char *)0)) \
+ /*lint -restore*/
/*===========================================================================*/
/* Module exported functions. */
@@ -89,14 +92,14 @@ ROMCONST chdebug_t ch_debug = {
(uint8_t)_offsetof(thread_t, p_newer),
(uint8_t)_offsetof(thread_t, p_older),
(uint8_t)_offsetof(thread_t, p_name),
-#if CH_DBG_ENABLE_STACK_CHECK
+#if CH_DBG_ENABLE_STACK_CHECK == TRUE
(uint8_t)_offsetof(thread_t, p_stklimit),
#else
(uint8_t)0,
#endif
(uint8_t)_offsetof(thread_t, p_state),
(uint8_t)_offsetof(thread_t, p_flags),
-#if CH_CFG_USE_DYNAMIC
+#if CH_CFG_USE_DYNAMIC == TRUE
(uint8_t)_offsetof(thread_t, p_refs),
#else
(uint8_t)0,
@@ -106,7 +109,7 @@ ROMCONST chdebug_t ch_debug = {
#else
(uint8_t)0,
#endif
-#if CH_DBG_THREADS_PROFILING
+#if CH_DBG_THREADS_PROFILING == TRUE
(uint8_t)_offsetof(thread_t, p_time)
#else
(uint8_t)0
@@ -130,7 +133,7 @@ thread_t *chRegFirstThread(void) {
chSysLock();
tp = ch.rlist.r_newer;
-#if CH_CFG_USE_DYNAMIC
+#if CH_CFG_USE_DYNAMIC == TRUE
tp->p_refs++;
#endif
chSysUnlock();
@@ -154,23 +157,25 @@ thread_t *chRegNextThread(thread_t *tp) {
chSysLock();
ntp = tp->p_newer;
+ /*lint -save -e9087 -e740 [11.3, 1.3] Cast required by list handling.*/
if (ntp == (thread_t *)&ch.rlist) {
+ /*lint -restore*/
ntp = NULL;
}
-#if CH_CFG_USE_DYNAMIC
+#if CH_CFG_USE_DYNAMIC == TRUE
else {
chDbgAssert(ntp->p_refs < 255, "too many references");
ntp->p_refs++;
}
#endif
chSysUnlock();
-#if CH_CFG_USE_DYNAMIC
+#if CH_CFG_USE_DYNAMIC == TRUE
chThdRelease(tp);
#endif
return ntp;
}
-#endif /* CH_CFG_USE_REGISTRY */
+#endif /* CH_CFG_USE_REGISTRY == TRUE */
/** @} */
diff --git a/os/rt/src/chsem.c b/os/rt/src/chsem.c
index 36fa8a445..87a28eb28 100644
--- a/os/rt/src/chsem.c
+++ b/os/rt/src/chsem.c
@@ -57,7 +57,7 @@
#include "ch.h"
-#if CH_CFG_USE_SEMAPHORES || defined(__DOXYGEN__)
+#if (CH_CFG_USE_SEMAPHORES == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Module exported variables. */
@@ -75,7 +75,7 @@
/* Module local functions. */
/*===========================================================================*/
-#if CH_CFG_USE_SEMAPHORES_PRIORITY
+#if CH_CFG_USE_SEMAPHORES_PRIORITY == TRUE
#define sem_insert(tp, qp) queue_prio_insert(tp, qp)
#else
#define sem_insert(tp, qp) queue_insert(tp, qp)
@@ -329,7 +329,7 @@ void chSemSignalI(semaphore_t *sp) {
chSchReadyI().*/
thread_t *tp = queue_fifo_remove(&sp->s_queue);
tp->p_u.rdymsg = MSG_OK;
- chSchReadyI(tp);
+ (void) chSchReadyI(tp);
}
}
@@ -406,6 +406,6 @@ msg_t chSemSignalWait(semaphore_t *sps, semaphore_t *spw) {
return msg;
}
-#endif /* CH_CFG_USE_SEMAPHORES */
+#endif /* CH_CFG_USE_SEMAPHORES == TRUE */
/** @} */
diff --git a/os/rt/src/chthreads.c b/os/rt/src/chthreads.c
index 16a80aaab..af672774e 100644
--- a/os/rt/src/chthreads.c
+++ b/os/rt/src/chthreads.c
@@ -96,33 +96,33 @@ thread_t *_thread_init(thread_t *tp, tprio_t prio) {
#if CH_CFG_TIME_QUANTUM > 0
tp->p_preempt = CH_CFG_TIME_QUANTUM;
#endif
-#if CH_CFG_USE_MUTEXES
+#if CH_CFG_USE_MUTEXES == TRUE
tp->p_realprio = prio;
tp->p_mtxlist = NULL;
#endif
-#if CH_CFG_USE_EVENTS
+#if CH_CFG_USE_EVENTS == TRUE
tp->p_epending = 0;
#endif
-#if CH_DBG_THREADS_PROFILING
+#if CH_DBG_THREADS_PROFILING == TRUE
tp->p_time = 0;
#endif
-#if CH_CFG_USE_DYNAMIC
+#if CH_CFG_USE_DYNAMIC == TRUE
tp->p_refs = 1;
#endif
-#if CH_CFG_USE_REGISTRY
+#if CH_CFG_USE_REGISTRY == TRUE
tp->p_name = NULL;
REG_INSERT(tp);
#endif
-#if CH_CFG_USE_WAITEXIT
+#if CH_CFG_USE_WAITEXIT == TRUE
list_init(&tp->p_waiting);
#endif
-#if CH_CFG_USE_MESSAGES
+#if CH_CFG_USE_MESSAGES == TRUE
queue_init(&tp->p_msgqueue);
#endif
-#if CH_DBG_ENABLE_STACK_CHECK
+#if CH_DBG_ENABLE_STACK_CHECK == TRUE
tp->p_stklimit = (stkalign_t *)(tp + 1);
#endif
-#if CH_DBG_STATISTICS || defined(__DOXYGEN__)
+#if CH_DBG_STATISTICS == TRUE
chTMObjectInit(&tp->p_stats);
chTMStartMeasurementX(&tp->p_stats);
#endif
@@ -132,7 +132,7 @@ thread_t *_thread_init(thread_t *tp, tprio_t prio) {
return tp;
}
-#if CH_DBG_FILL_THREADS || defined(__DOXYGEN__)
+#if (CH_DBG_FILL_THREADS == TRUE) || defined(__DOXYGEN__)
/**
* @brief Memory fill utility.
*
@@ -209,7 +209,7 @@ thread_t *chThdCreateStatic(void *wsp, size_t size,
tprio_t prio, tfunc_t pf, void *arg) {
thread_t *tp;
-#if CH_DBG_FILL_THREADS
+#if CH_DBG_FILL_THREADS == TRUE
_thread_memfill((uint8_t *)wsp,
(uint8_t *)wsp + sizeof(thread_t),
CH_DBG_THREAD_FILL_VALUE);
@@ -261,7 +261,7 @@ tprio_t chThdSetPriority(tprio_t newprio) {
chDbgCheck(newprio <= HIGHPRIO);
chSysLock();
-#if CH_CFG_USE_MUTEXES
+#if CH_CFG_USE_MUTEXES == TRUE
oldprio = currp->p_realprio;
if ((currp->p_prio == currp->p_realprio) || (newprio > currp->p_prio)) {
currp->p_prio = newprio;
@@ -420,12 +420,12 @@ void chThdExitS(msg_t msg) {
#if defined(CH_CFG_THREAD_EXIT_HOOK)
CH_CFG_THREAD_EXIT_HOOK(tp);
#endif
-#if CH_CFG_USE_WAITEXIT
+#if CH_CFG_USE_WAITEXIT == TRUE
while (list_notempty(&tp->p_waiting)) {
- chSchReadyI(list_remove(&tp->p_waiting));
+ (void) chSchReadyI(list_remove(&tp->p_waiting));
}
#endif
-#if CH_CFG_USE_REGISTRY
+#if CH_CFG_USE_REGISTRY == TRUE
/* 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) {
@@ -438,7 +438,7 @@ void chThdExitS(msg_t msg) {
chDbgAssert(false, "zombies apocalypse");
}
-#if CH_CFG_USE_WAITEXIT || defined(__DOXYGEN__)
+#if (CH_CFG_USE_WAITEXIT == TRUE) || defined(__DOXYGEN__)
/**
* @brief Blocks the execution of the invoking thread until the specified
* thread terminates then the exit code is returned.
@@ -477,7 +477,7 @@ msg_t chThdWait(thread_t *tp) {
chSysLock();
chDbgAssert(tp != currp, "waiting self");
-#if CH_CFG_USE_DYNAMIC
+#if CH_CFG_USE_DYNAMIC == TRUE
chDbgAssert(tp->p_refs > 0, "not referenced");
#endif
if (tp->p_state != CH_STATE_FINAL) {
@@ -487,7 +487,7 @@ msg_t chThdWait(thread_t *tp) {
msg = tp->p_u.exitcode;
chSysUnlock();
-#if CH_CFG_USE_DYNAMIC
+#if CH_CFG_USE_DYNAMIC == TRUE
chThdRelease(tp);
#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-02 18:28:24 +0000