/* ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio. This file is part of ChibiOS. ChibiOS is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. ChibiOS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ /** * @file chmtx.c * @brief Mutexes code. * * @addtogroup mutexes * @details Mutexes related APIs and services. *

Operation mode

* A mutex is a threads synchronization object that can be in two * distinct states: * - Not owned (unlocked). * - Owned by a thread (locked). * . * Operations defined for mutexes: * - Lock: The mutex is checked, if the mutex is not owned by * some other thread then it is associated to the locking thread * else the thread is queued on the mutex in a list ordered by * priority. * - Unlock: The mutex is released by the owner and the highest * priority thread waiting in the queue, if any, is resumed and made * owner of the mutex. * . *

Constraints

* In ChibiOS/RT the Unlock operations must always be performed * in lock-reverse order. This restriction both improves the * performance and is required for an efficient implementation * of the priority inheritance mechanism.
* Operating under this restriction also ensures that deadlocks * are no possible. * *

Recursive mode

* By default mutexes are not recursive, this mean that it is not * possible to take a mutex already owned by the same thread. * It is possible to enable the recursive behavior by enabling the * option @p CH_CFG_USE_MUTEXES_RECURSIVE. * *

The priority inversion problem

* The mutexes in ChibiOS/RT implements the full priority * inheritance mechanism in order handle the priority inversion * problem.
* When a thread is queued on a mutex, any thread, directly or * indirectly, holding the mutex gains the same priority of the * waiting thread (if their priority was not already equal or higher). * The mechanism works with any number of nested mutexes and any * number of involved threads. The algorithm complexity (worst case) * is N with N equal to the number of nested mutexes. * @pre In order to use the mutex APIs the @p CH_CFG_USE_MUTEXES option * must be enabled in @p chconf.h. * @post Enabling mutexes requires 5-12 (depending on the architecture) * extra bytes in the @p thread_t structure. * @{ */ #include "ch.h" #if (CH_CFG_USE_MUTEXES == TRUE) || defined(__DOXYGEN__) /*===========================================================================*/ /* Module exported variables. */ /*===========================================================================*/ /*===========================================================================*/ /* Module local types. */ /*===========================================================================*/ /*===========================================================================*/ /* Module local variables. */ /*===========================================================================*/ /*===========================================================================*/ /* Module local functions. */ /*===========================================================================*/ /*===========================================================================*/ /* Module exported functions. */ /*=============================================

#ifndef WAIT_H
#define WAIT_H

#include <inttypes.h>

#ifdef __cplusplus
extern "C" {
#endif

#if defined(__AVR__)
#    include <util/delay.h>
#    define wait_ms(ms) _delay_ms(ms)
#    define wait_us(us) _delay_us(us)
#elif defined PROTOCOL_CHIBIOS
#    include "ch.h"
#    define wait_ms(ms)                     \
        do {                                \
            if (ms != 0) {                  \
                chThdSleepMilliseconds(ms); \
            } else {                        \
                chThdSleepMicroseconds(1);  \
            }                               \
        } while (0)
#    define wait_us(us)                     \
        do {                                \
            if (us != 0) {                  \
                chThdSleepMicroseconds(us); \
            } else {                        \
                chThdSleepMicroseconds(1);  \
            }                               \
        } while (0)
#elif defined PROTOCOL_ARM_ATSAM
#    include "clks.h"
#    define wait_ms(ms) CLK_delay_ms(ms)
#    define wait_us(us) CLK_delay_us(us)
#else  // Unit tests
void wait_ms(uint32_t ms);
#    define wait_us(us) wait_ms(us / 1000)
#endif

#ifdef __cplusplus
}
#endif

#endif

newprio = ctp->p_realprio; lmp = ctp->p_mtxlist; while (lmp != NULL) { /* 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)) { newprio = lmp->m_queue.p_next->p_prio; } lmp = lmp->m_next; } /* Assigns to the current thread the highest priority among all the waiting threads.*/ ctp->p_prio = newprio; /* Awakens the highest priority thread waiting for the unlocked mutex and assigns the mutex to it.*/ #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE mp->m_cnt = (cnt_t)1; #endif tp = queue_fifo_remove(&mp->m_queue); mp->m_owner = tp; mp->m_next = tp->p_mtxlist; tp->p_mtxlist = mp; /* Note, not using chSchWakeupS() becuase that function expects the current thread to have the higher or equal priority than the ones in the ready list. This is not necessarily true here because we just changed priority.*/ (void) chSchReadyI(tp); chSchRescheduleS(); } else { mp->m_owner = NULL; } #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE } #endif chSysUnlock(); } /** * @brief Unlocks the specified mutex. * @note Mutexes must be unlocked in reverse lock order. Violating this * rules will result in a panic if assertions are enabled. * @pre The invoking thread must have at least one owned mutex. * @post The mutex is unlocked and removed from the per-thread stack of * owned mutexes. * @post This function does not reschedule so a call to a rescheduling * function must be performed before unlocking the kernel. * * @param[in] mp pointer to the @p mutex_t structure * * @sclass */ void chMtxUnlockS(mutex_t *mp) { thread_t *ctp = currp; mutex_t *lmp; chDbgCheckClassS(); chDbgCheck(mp != NULL); chDbgAssert(ctp->p_mtxlist != NULL, "owned mutexes list empty"); chDbgAssert(ctp->p_mtxlist->m_owner == ctp, "ownership failure"); #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE chDbgAssert(mp->m_cnt >= (cnt_t)1, "counter is not positive"); if (--mp->m_cnt == (cnt_t)0) { #endif chDbgAssert(ctp->p_mtxlist == mp, "not next in list"); /* Removes the top mutex from the thread's owned mutexes list and marks it as not owned. Note, it is assumed to be the same mutex passed as parameter of this function.*/ ctp->p_mtxlist = mp->m_next; /* If a thread is waiting on the mutex then the fun part begins.*/ if (chMtxQueueNotEmptyS(mp)) { thread_t *tp; /* Recalculates the optimal thread priority by scanning the owned mutexes list.*/ tprio_t newprio = ctp->p_realprio; lmp = ctp->p_mtxlist; while (lmp != NULL) { /* 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)) { newprio = lmp->m_queue.p_next->p_prio; } lmp = lmp->m_next; } /* Assigns to the current thread the highest priority among all the waiting threads.*/ ctp->p_prio = newprio; /* Awakens the highest priority thread waiting for the unlocked mutex and assigns the mutex to it.*/ #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE mp->m_cnt = (cnt_t)1; #endif tp = queue_fifo_remove(&mp->m_queue); mp->m_owner = tp; mp->m_next = tp->p_mtxlist; tp->p_mtxlist = mp; (void) chSchReadyI(tp); } else { mp->m_owner = NULL; } #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE } #endif } /** * @brief Unlocks all mutexes owned by the invoking thread. * @post The stack of owned mutexes is emptied and all the found * mutexes are unlocked. * @note This function is MUCH MORE efficient than releasing the * mutexes one by one and not just because the call overhead, * this function does not have any overhead related to the priority * inheritance mechanism. * * @api */ void chMtxUnlockAll(void) { thread_t *ctp = currp; chSysLock(); if (ctp->p_mtxlist != NULL) { do { mutex_t *mp = ctp->p_mtxlist; ctp->p_mtxlist = mp->m_next; if (chMtxQueueNotEmptyS(mp)) { #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE mp->m_cnt = (cnt_t)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; (void) chSchReadyI(tp); } else { #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE mp->m_cnt = (cnt_t)0; #endif mp->m_owner = NULL; } } while (ctp->p_mtxlist != NULL); ctp->p_prio = ctp->p_realprio; chSchRescheduleS(); } chSysUnlock(); } #endif /* CH_CFG_USE_MUTEXES == TRUE */ /** @} */