/** * @brief Performs atomic signal and wait operations on two semaphores. * * @param[in] sps pointer to a @p semaphore_t structure to be signaled * @param[in] spw pointer to a @p semaphore_t structure to wait on * @return A message specifying how the invoking thread has been * released from the semaphore. * @retval MSG_OK if the thread has not stopped on the semaphore or the * semaphore has been signaled. * @retval MSG_RESET if the semaphore has been reset using @p chSemReset(). * * @api */ msg_t chSemSignalWait(semaphore_t *sps, semaphore_t *spw) { msg_t msg; chDbgCheck((sps != NULL) && (spw != NULL)); chDbgAssert(((sps->s_cnt >= (cnt_t)0) && queue_isempty(&sps->s_queue)) || ((sps->s_cnt < (cnt_t)0) && queue_notempty(&sps->s_queue)), "inconsistent semaphore"); chDbgAssert(((spw->s_cnt >= (cnt_t)0) && queue_isempty(&spw->s_queue)) || ((spw->s_cnt < (cnt_t)0) && queue_notempty(&spw->s_queue)), "inconsistent semaphore"); chSysLock(); if (++sps->s_cnt <= (cnt_t)0) { chSchReadyI(queue_fifo_remove(&sps->s_queue))->p_u.rdymsg = MSG_OK; } if (--spw->s_cnt < (cnt_t)0) { thread_t *ctp = currp; sem_insert(ctp, &spw->s_queue); ctp->p_u.wtsemp = spw; chSchGoSleepS(CH_STATE_WTSEM); msg = ctp->p_u.rdymsg; } else { chSchRescheduleS(); msg = MSG_OK; } chSysUnlock(); return msg; }
/** * @brief Signals one thread that is waiting on the condition variable. * * @param[in] cp pointer to the @p condition_variable_t structure * * @api */ void chCondSignal(condition_variable_t *cp) { chDbgCheck(cp != NULL); chSysLock(); if (queue_notempty(&cp->c_queue)) chSchWakeupS(queue_fifo_remove(&cp->c_queue), MSG_OK); chSysUnlock(); }
/** * @brief Signals one thread that is waiting on the condition variable. * @post This function does not reschedule so a call to a rescheduling * function must be performed before unlocking the kernel. Note that * interrupt handlers always reschedule on exit so an explicit * reschedule must not be performed in ISRs. * * @param[in] cp pointer to the @p condition_variable_t structure * * @iclass */ void chCondSignalI(condition_variable_t *cp) { chDbgCheckClassI(); chDbgCheck(cp != NULL); if (queue_notempty(&cp->c_queue)) { thread_t *tp = queue_fifo_remove(&cp->c_queue); tp->p_u.rdymsg = MSG_OK; chSchReadyI(tp); } }
/** * @brief Performs a signal operation on a semaphore. * * @param[in] sp pointer to a @p semaphore_t structure * * @api */ void chSemSignal(semaphore_t *sp) { chDbgCheck(sp != NULL); chDbgAssert(((sp->s_cnt >= 0) && queue_isempty(&sp->s_queue)) || ((sp->s_cnt < 0) && queue_notempty(&sp->s_queue)), "inconsistent semaphore"); chSysLock(); if (++sp->s_cnt <= 0) chSchWakeupS(queue_fifo_remove(&sp->s_queue), MSG_OK); chSysUnlock(); }
/** * @brief Signals all threads that are waiting on the condition variable. * @post This function does not reschedule so a call to a rescheduling * function must be performed before unlocking the kernel. Note that * interrupt handlers always reschedule on exit so an explicit * reschedule must not be performed in ISRs. * * @param[in] cp pointer to the @p condition_variable_t structure * * @iclass */ void chCondBroadcastI(condition_variable_t *cp) { chDbgCheckClassI(); chDbgCheck(cp != NULL); /* 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 (queue_notempty(&cp->queue)) { chSchReadyI(queue_fifo_remove(&cp->queue))->u.rdymsg = MSG_RESET; } }
/** * @brief Adds the specified value to the semaphore counter. * @post This function does not reschedule so a call to a rescheduling * function must be performed before unlocking the kernel. Note that * interrupt handlers always reschedule on exit so an explicit * reschedule must not be performed in ISRs. * * @param[in] sp pointer to a @p semaphore_t structure * @param[in] n value to be added to the semaphore counter. The value * must be positive. * * @iclass */ void chSemAddCounterI(semaphore_t *sp, cnt_t n) { chDbgCheckClassI(); chDbgCheck((sp != NULL) && (n > 0)); chDbgAssert(((sp->s_cnt >= 0) && queue_isempty(&sp->s_queue)) || ((sp->s_cnt < 0) && queue_notempty(&sp->s_queue)), "inconsistent semaphore"); while (n > 0) { if (++sp->s_cnt <= 0) chSchReadyI(queue_fifo_remove(&sp->s_queue))->p_u.rdymsg = MSG_OK; n--; } }
/** * @brief Performs a reset operation on the semaphore. * @post After invoking this function all the threads waiting on the * semaphore, if any, are released and the semaphore counter is set * to the specified, non negative, value. * @post This function does not reschedule so a call to a rescheduling * function must be performed before unlocking the kernel. Note that * interrupt handlers always reschedule on exit so an explicit * reschedule must not be performed in ISRs. * @note The released threads can recognize they were waked up by a reset * rather than a signal because the @p chSemWait() will return * @p MSG_RESET instead of @p MSG_OK. * * @param[in] sp pointer to a @p semaphore_t structure * @param[in] n the new value of the semaphore counter. The value must * be non-negative. * * @iclass */ void chSemResetI(semaphore_t *sp, cnt_t n) { cnt_t cnt; chDbgCheckClassI(); chDbgCheck((sp != NULL) && (n >= 0)); chDbgAssert(((sp->s_cnt >= 0) && queue_isempty(&sp->s_queue)) || ((sp->s_cnt < 0) && queue_notempty(&sp->s_queue)), "inconsistent semaphore"); cnt = sp->s_cnt; sp->s_cnt = n; while (++cnt <= 0) chSchReadyI(queue_lifo_remove(&sp->s_queue))->p_u.rdymsg = MSG_RESET; }
/** * @brief Performs a signal operation on a semaphore. * @post This function does not reschedule so a call to a rescheduling * function must be performed before unlocking the kernel. Note that * interrupt handlers always reschedule on exit so an explicit * reschedule must not be performed in ISRs. * * @param[in] sp pointer to a @p semaphore_t structure * * @iclass */ void chSemSignalI(semaphore_t *sp) { chDbgCheckClassI(); chDbgCheck(sp != NULL); chDbgAssert(((sp->s_cnt >= (cnt_t)0) && queue_isempty(&sp->s_queue)) || ((sp->s_cnt < (cnt_t)0) && queue_notempty(&sp->s_queue)), "inconsistent semaphore"); if (++sp->s_cnt <= (cnt_t)0) { /* Note, it is done this way in order to allow a tail call on chSchReadyI().*/ thread_t *tp = queue_fifo_remove(&sp->s_queue); tp->p_u.rdymsg = MSG_OK; (void) chSchReadyI(tp); } }
/** * @brief Performs a wait operation on a semaphore. * * @param[in] sp pointer to a @p semaphore_t structure * @return A message specifying how the invoking thread has been * released from the semaphore. * @retval MSG_OK if the thread has not stopped on the semaphore or the * semaphore has been signaled. * @retval MSG_RESET if the semaphore has been reset using @p chSemReset(). * * @sclass */ msg_t chSemWaitS(semaphore_t *sp) { chDbgCheckClassS(); chDbgCheck(sp != NULL); chDbgAssert(((sp->s_cnt >= 0) && queue_isempty(&sp->s_queue)) || ((sp->s_cnt < 0) && queue_notempty(&sp->s_queue)), "inconsistent semaphore"); if (--sp->s_cnt < 0) { currp->p_u.wtobjp = sp; sem_insert(currp, &sp->s_queue); chSchGoSleepS(CH_STATE_WTSEM); return currp->p_u.rdymsg; } return MSG_OK; }
/** * @brief Performs a wait operation on a semaphore with timeout specification. * * @param[in] sp pointer to a @p semaphore_t structure * @param[in] time the number of ticks before the operation timeouts, * the following special values are allowed: * - @a TIME_IMMEDIATE immediate timeout. * - @a TIME_INFINITE no timeout. * . * @return A message specifying how the invoking thread has been * released from the semaphore. * @retval MSG_OK if the thread has not stopped on the semaphore or the * semaphore has been signaled. * @retval MSG_RESET if the semaphore has been reset using @p chSemReset(). * @retval MSG_TIMEOUT if the semaphore has not been signaled or reset within * the specified timeout. * * @sclass */ msg_t chSemWaitTimeoutS(semaphore_t *sp, systime_t time) { chDbgCheckClassS(); chDbgCheck(sp != NULL); chDbgAssert(((sp->s_cnt >= 0) && queue_isempty(&sp->s_queue)) || ((sp->s_cnt < 0) && queue_notempty(&sp->s_queue)), "inconsistent semaphore"); 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; }
/** * @brief Dequeues and wakes up all threads from the threads queue object. * * @param[in] tqp pointer to the threads queue object * @param[in] msg the message code * * @iclass */ void chThdDequeueAllI(threads_queue_t *tqp, msg_t msg) { while (queue_notempty(tqp)) { chThdDoDequeueNextI(tqp, msg); } }
/** * @brief Dequeues and wakes up one thread from the threads queue object, * if any. * * @param[in] tqp pointer to the threads queue object * @param[in] msg the message code * * @iclass */ void chThdDequeueNextI(threads_queue_t *tqp, msg_t msg) { if (queue_notempty(tqp)) chThdDoDequeueNextI(tqp, msg); }