Everywhere: Hoist the Libraries folder to the top-level

Author: https://github.com/trflynn89
Commit: 93712b24bf
Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/2256
Reviewed-by: https://github.com/sideshowbarker

Libraries/LibThreading/RWLock.h

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2024, Ali Mohammad Pur <mpfard@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Assertions.h>
+#include <AK/Noncopyable.h>
+#include <AK/Types.h>
+#include <pthread.h>
+
+namespace Threading {
+
+class RWLock {
+    AK_MAKE_NONCOPYABLE(RWLock);
+    AK_MAKE_NONMOVABLE(RWLock);
+
+public:
+    RWLock()
+    {
+        pthread_rwlock_init(&m_rwlock, nullptr);
+    }
+
+    ~RWLock()
+    {
+        VERIFY(!m_write_locked);
+        pthread_rwlock_destroy(&m_rwlock);
+    }
+
+    void lock_read();
+    void lock_write();
+
+    void unlock();
+
+private:
+    pthread_rwlock_t m_rwlock;
+    bool m_write_locked { false };
+    bool m_read_locked_with_write_lock { false };
+};
+
+enum class LockMode {
+    Read,
+    Write,
+};
+template<LockMode mode>
+class RWLockLocker {
+    AK_MAKE_NONCOPYABLE(RWLockLocker);
+    AK_MAKE_NONMOVABLE(RWLockLocker);
+
+public:
+    ALWAYS_INLINE explicit RWLockLocker(RWLock& l)
+        : m_lock(l)
+    {
+        lock();
+    }
+
+    ALWAYS_INLINE ~RWLockLocker()
+    {
+        unlock();
+    }
+
+    ALWAYS_INLINE void unlock()
+    {
+        m_lock.unlock();
+    }
+
+    ALWAYS_INLINE void lock()
+    {
+        if constexpr (mode == LockMode::Read)
+            m_lock.lock_read();
+        else
+            m_lock.lock_write();
+    }
+
+private:
+    RWLock& m_lock;
+};
+
+ALWAYS_INLINE void RWLock::lock_read()
+{
+    auto rc = pthread_rwlock_rdlock(&m_rwlock);
+    if (rc == EDEADLK) {
+        // We're already holding the write lock, so we can just return.
+        m_read_locked_with_write_lock = true;
+    } else {
+        VERIFY(rc == 0);
+    }
+}
+
+ALWAYS_INLINE void RWLock::lock_write()
+{
+    auto rc = pthread_rwlock_wrlock(&m_rwlock);
+    VERIFY(rc == 0);
+    m_write_locked = true;
+}
+
+ALWAYS_INLINE void RWLock::unlock()
+{
+    m_write_locked = false;
+    auto needs_unlock = !m_read_locked_with_write_lock;
+    m_read_locked_with_write_lock = false;
+    if (needs_unlock)
+        pthread_rwlock_unlock(&m_rwlock);
+}
+
+}