// Copyright (C) 2016 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:significant reason:default

#ifndef QMUTEX_H

#define QMUTEX_H

#include <QtCore/qglobal.h>

#include <QtCore/qatomic.h>

#include <QtCore/qdeadlinetimer.h>

#include <QtCore/qtsan_impl.h>

#include <chrono>

QT_BEGIN_NAMESPACE

#if QT_CONFIG(thread) || defined(Q_QDOC)

class QMutex;

class QRecursiveMutex;

class QMutexPrivate;

class QT6_ONLY(Q_CORE_EXPORT) QBasicMutex

{

    Q_DISABLE_COPY_MOVE(QBasicMutex)

protected:

    static constexpr bool FutexAlwaysAvailable =

#if defined(Q_OS_FREEBSD) || defined(Q_OS_LINUX) || defined(Q_OS_WIN) // these platforms use futex

            true

#else

            false

#endif

            ;

public:

    constexpr QBasicMutex()

        : d_ptr(nullptr)

    {}

    // BasicLockable concept

    inline void lock() noexcept(FutexAlwaysAvailable) {

        QtTsan::mutexPreLock(this, 0u);

        if (!fastTryLock())

            lockInternal();

        QtTsan::mutexPostLock(this, 0u, 0);

    }

    // BasicLockable concept

    inline void unlock() noexcept {

        Q_ASSERT(d_ptr.loadRelaxed()); //mutex must be locked

        QtTsan::mutexPreUnlock(this, 0u);

        if constexpr (FutexAlwaysAvailable) {

            // we always unlock if we have futexes

            if (QMutexPrivate *d = d_ptr.fetchAndStoreRelease(nullptr); Q_UNLIKELY(d != dummyLocked()))

                unlockInternalFutex(d);     // was contended

        } else {

            // if we don't have futexes, we can only unlock if not contended

            if (QMutexPrivate *d; !d_ptr.testAndSetRelease(dummyLocked(), nullptr, d))

                unlockInternal(d);          // was contended

        }

        QtTsan::mutexPostUnlock(this, 0u);

    }

    bool tryLock() noexcept {

        unsigned tsanFlags = QtTsan::TryLock;

        QtTsan::mutexPreLock(this, tsanFlags);

        const bool success = fastTryLock();

        if (!success)

            tsanFlags |= QtTsan::TryLockFailed;

        QtTsan::mutexPostLock(this, tsanFlags, 0);

        return success;

    }

    // Lockable concept

    bool try_lock() noexcept { return tryLock(); }

private:

    inline bool fastTryLock() noexcept

    {

        if (Q_UNLIKELY(d_ptr.loadRelaxed() != nullptr))

            return false;

        return d_ptr.testAndSetAcquire(nullptr, dummyLocked());

    }

#if QT_CORE_REMOVED_SINCE(6, 10)

    inline bool fastTryUnlock() noexcept {

        return d_ptr.testAndSetRelease(dummyLocked(), nullptr);

    }

#endif

    QT7_ONLY(Q_CORE_EXPORT)

    void lockInternal() noexcept(FutexAlwaysAvailable);

    QT7_ONLY(Q_CORE_EXPORT)

    bool lockInternal(QDeadlineTimer timeout) noexcept(FutexAlwaysAvailable);

#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)

    bool lockInternal(int timeout) noexcept(FutexAlwaysAvailable);

    void unlockInternal() noexcept;

#endif

    QT7_ONLY(Q_CORE_EXPORT)

    void unlockInternalFutex(void *d) noexcept;

    QT7_ONLY(Q_CORE_EXPORT)

    void unlockInternal(void *d) noexcept;

#if QT_CORE_REMOVED_SINCE(6, 9)

    void destroyInternal(QMutexPrivate *d);

#endif

    QT7_ONLY(Q_CORE_EXPORT)

    void destroyInternal(void *d);

    QBasicAtomicPointer<QMutexPrivate> d_ptr;

    static inline QMutexPrivate *dummyLocked() {

        return reinterpret_cast<QMutexPrivate *>(quintptr(1));

    }

    friend class QMutex;

    friend class QMutexPrivate;

};

class QT6_ONLY(Q_CORE_EXPORT) QMutex : public QBasicMutex

{

public:

    constexpr QMutex() = default;

    ~QMutex()

    {

        QMutexPrivate *d = d_ptr.loadRelaxed();

        if (d)

            destroyInternal(d);

    }

#ifdef Q_QDOC

    inline void lock() noexcept(FutexAlwaysAvailable);

    inline void unlock() noexcept;

    bool tryLock() noexcept;

#endif

    // Lockable concept

    bool try_lock() noexcept { return tryLock(); }

    using QBasicMutex::tryLock;

    bool tryLock(int timeout) noexcept(FutexAlwaysAvailable)

    {

        return tryLock(QDeadlineTimer(timeout));

    }

    bool tryLock(QDeadlineTimer timeout) noexcept(FutexAlwaysAvailable)

    {

        unsigned tsanFlags = QtTsan::TryLock;

        QtTsan::mutexPreLock(this, tsanFlags);

        bool success = fastTryLock();

        if (success) {

            QtTsan::mutexPostLock(this, tsanFlags, 0);

            return success;

        }

        success = lockInternal(timeout);

        if (!success)

            tsanFlags |= QtTsan::TryLockFailed;

        QtTsan::mutexPostLock(this, tsanFlags, 0);

        return success;

    }

    // TimedLockable concept

    template <class Rep, class Period>

    bool try_lock_for(std::chrono::duration<Rep, Period> duration)

    {

        return tryLock(QDeadlineTimer(duration));

    }

    // TimedLockable concept

    template<class Clock, class Duration>

    bool try_lock_until(std::chrono::time_point<Clock, Duration> timePoint)

    {

        return tryLock(QDeadlineTimer(timePoint));

    }

};

class QT6_ONLY(Q_CORE_EXPORT) QRecursiveMutex

{

    Q_DISABLE_COPY_MOVE(QRecursiveMutex)

    // written to by the thread that first owns 'mutex';

    // read during attempts to acquire ownership of 'mutex' from any other thread:

    QAtomicPointer<void> owner = nullptr;

    // only ever accessed from the thread that owns 'mutex':

    uint count = 0;

    QMutex mutex;

    static constexpr bool LockIsNoexcept = noexcept(std::declval<QMutex>().lock());

public:

    constexpr QRecursiveMutex() = default;

    QT7_ONLY(Q_CORE_EXPORT)

    ~QRecursiveMutex();

    // BasicLockable concept

    void lock() noexcept(LockIsNoexcept)

    { tryLock(QDeadlineTimer(QDeadlineTimer::Forever)); }

    QT_CORE_INLINE_SINCE(6, 6)

    bool tryLock(int timeout) noexcept(LockIsNoexcept);

    QT7_ONLY(Q_CORE_EXPORT)

    bool tryLock(QDeadlineTimer timer = {}) noexcept(LockIsNoexcept);

    // BasicLockable concept

    QT7_ONLY(Q_CORE_EXPORT)

    void unlock() noexcept;

    // Lockable concept

    bool try_lock() noexcept(LockIsNoexcept) { return tryLock(); }

    // TimedLockable concept

    template <class Rep, class Period>

    bool try_lock_for(std::chrono::duration<Rep, Period> duration)

    {

        return tryLock(QDeadlineTimer(duration));

    }

    // TimedLockable concept

    template<class Clock, class Duration>

    bool try_lock_until(std::chrono::time_point<Clock, Duration> timePoint)

    {

        return tryLock(QDeadlineTimer(timePoint));

    }

};

#if QT_CORE_INLINE_IMPL_SINCE(6, 6)

bool QRecursiveMutex::tryLock(int timeout) noexcept(LockIsNoexcept)

{

    return tryLock(QDeadlineTimer(timeout));

}

#endif

template <typename Mutex>

class QMutexLocker

{

#ifdef Q_CC_GHS

    // internal compiler error otherwise

    static constexpr bool LockIsNoexcept = false;

#else

    static constexpr bool LockIsNoexcept = noexcept(std::declval<Mutex>().lock());

#endif

public:

    Q_NODISCARD_CTOR

    inline explicit QMutexLocker(Mutex *mutex) noexcept(LockIsNoexcept)

    {

        m_mutex = mutex;

        if (Q_LIKELY(mutex)) {

            mutex->lock();

            m_isLocked = true;

        }

    }

    Q_NODISCARD_CTOR

    inline QMutexLocker(QMutexLocker &&other) noexcept

        : m_mutex(std::exchange(other.m_mutex, nullptr)),

          m_isLocked(std::exchange(other.m_isLocked, false))

    {}

    QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_MOVE_AND_SWAP(QMutexLocker)

    inline ~QMutexLocker()

    {

        if (m_isLocked)

            unlock();

    }

    inline bool isLocked() const noexcept

    {

        return m_isLocked;

    }

    inline void unlock() noexcept

    {

        Q_ASSERT(m_isLocked);

        m_mutex->unlock();

        m_isLocked = false;

    }

    inline void relock() noexcept(LockIsNoexcept)

    {

        Q_ASSERT(!m_isLocked);

        m_mutex->lock();

        m_isLocked = true;

    }

    inline void swap(QMutexLocker &other) noexcept

    {

        qt_ptr_swap(m_mutex, other.m_mutex);

        std::swap(m_isLocked, other.m_isLocked);

    }

    Mutex *mutex() const

    {

        return m_mutex;

    }

private:

    Q_DISABLE_COPY(QMutexLocker)

    Mutex *m_mutex;

    bool m_isLocked = false;

};

#else // !QT_CONFIG(thread) && !Q_QDOC

class QMutex

{

public:

    constexpr QMutex() noexcept { }

    inline void lock() noexcept {}

    inline bool tryLock(int timeout = 0) noexcept { Q_UNUSED(timeout); return true; }

    inline bool try_lock() noexcept { return true; }

    inline void unlock() noexcept {}

    template <class Rep, class Period>

    inline bool try_lock_for(std::chrono::duration<Rep, Period> duration) noexcept

    {

        Q_UNUSED(duration);

        return true;

    }

    template<class Clock, class Duration>

    inline bool try_lock_until(std::chrono::time_point<Clock, Duration> timePoint) noexcept

    {

        Q_UNUSED(timePoint);

        return true;

    }

private:

    Q_DISABLE_COPY(QMutex)

};

class QRecursiveMutex : public QMutex {};

template <typename Mutex>

class QMutexLocker

{

public:

    Q_NODISCARD_CTOR

    inline explicit QMutexLocker(Mutex *) noexcept {}

    inline ~QMutexLocker() noexcept {}

    inline void unlock() noexcept {}

    void relock() noexcept {}

    inline Mutex *mutex() const noexcept { return nullptr; }

private:

    Q_DISABLE_COPY(QMutexLocker)

};

typedef QMutex QBasicMutex;

#endif // !QT_CONFIG(thread) && !Q_QDOC

QT_END_NAMESPACE

#endif // QMUTEX_H