/* * Copyright (C) 2024 Linux Studio Plugins Project * (C) 2024 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 25 февр. 2019 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #ifndef LSP_PLUG_IN_IPC_MUTEX_H_ #define LSP_PLUG_IN_IPC_MUTEX_H_ #include #include #include #if defined(PLATFORM_WINDOWS) // Nothing #elif defined(PLATFORM_LINUX) #include #include #include #include #include #include #else #include #include #include #endif namespace lsp { namespace ipc { #if defined(PLATFORM_WINDOWS) namespace detail { struct CRITICAL_SECTION; } /* namespace detail */ /** * Recursive mutex for Windows platform */ class Mutex { private: mutable detail::CRITICAL_SECTION *hMutex; // Mutex object public: explicit Mutex(); Mutex(const Mutex &) = delete; Mutex(Mutex &&) = delete; ~Mutex(); Mutex & operator = (const Mutex &) = delete; Mutex & operator = (Mutex &&) = delete; /** Wait until mutex is unlocked and lock it * */ bool lock() const; /** Try to lock mutex and return status of operation * * @return non-zero value if mutex was locked */ bool try_lock() const; /** Unlock mutex * */ bool unlock() const; }; #elif defined(PLATFORM_LINUX) /** * Fast recursive mutex implementation for Linux using Futex primitive */ class Mutex { private: mutable int nLock; // 1 = unlocked, 0 = locked mutable volatile pthread_t nThreadId; // Locked thread identifier mutable ssize_t nLocks; // Number of locks by current thread public: explicit Mutex() { nLock = 1; nThreadId = -1; nLocks = 0; } Mutex(const Mutex &) = delete; Mutex(Mutex &&) = delete; ~Mutex() = default; Mutex & operator = (const Mutex &) = delete; Mutex & operator = (Mutex &&) = delete; /** Wait until mutex is unlocked and lock it * */ bool lock() const; /** Try to lock mutex and return status of operation * * @return non-zero value if mutex was locked */ bool try_lock() const; /** Unlock mutex * */ bool unlock() const; }; #else /** * Recursive mutex implementation using pthread */ class Mutex { private: mutable pthread_mutex_t sMutex; public: explicit Mutex(); Mutex(const Mutex &) = delete; Mutex(Mutex &&) = delete; ~Mutex(); Mutex & operator = (const Mutex &) = delete; Mutex & operator = (Mutex &&) = delete; /** Wait until mutex is unlocked and lock it * */ inline bool lock() const { while (true) { switch (pthread_mutex_lock(&sMutex)) { case 0: return true; case EBUSY: sched_yield(); break; default: return false; } } } /** Try to lock mutex and return status of operation * * @return non-zero value if mutex was locked */ inline bool try_lock() const { return pthread_mutex_trylock(&sMutex) == 0; } /** Unlock mutex * */ inline bool unlock() const { return pthread_mutex_unlock(&sMutex) == 0; } }; #endif } /* namespace ipc */ } /* namespace lsp */ #endif /* LSP_PLUG_IN_IPC_MUTEX_H_ */