mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 07:38:10 +00:00
691b6f69c5
The LOCKER() macro appears to have been added to LibThread as a userspace analog to the previous LOCKER() macro that existed in the kernel. The kernel version used the macro to inject __FILE__ and __LINE__ number into the lock acquisition for debugging. However AK::SourceLocation was used to remove the need for the macro. So the kernel version no longer exists. The LOCKER() in LibThread doesn't appear to actually need to be a macro, using the type directly works fine, and arguably is more readable as it removes an unnecessary level of indirection.
122 lines
1.9 KiB
C++
122 lines
1.9 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#ifdef __serenity__
|
|
|
|
# include <AK/Assertions.h>
|
|
# include <AK/Atomic.h>
|
|
# include <AK/Types.h>
|
|
# include <unistd.h>
|
|
|
|
namespace LibThread {
|
|
|
|
class Lock {
|
|
public:
|
|
Lock() { }
|
|
~Lock() { }
|
|
|
|
void lock();
|
|
void unlock();
|
|
|
|
private:
|
|
Atomic<pid_t> m_holder { 0 };
|
|
u32 m_level { 0 };
|
|
};
|
|
|
|
class Locker {
|
|
public:
|
|
ALWAYS_INLINE explicit Locker(Lock& l)
|
|
: m_lock(l)
|
|
{
|
|
lock();
|
|
}
|
|
ALWAYS_INLINE ~Locker() { unlock(); }
|
|
ALWAYS_INLINE void unlock() { m_lock.unlock(); }
|
|
ALWAYS_INLINE void lock() { m_lock.lock(); }
|
|
|
|
private:
|
|
Lock& m_lock;
|
|
};
|
|
|
|
ALWAYS_INLINE void Lock::lock()
|
|
{
|
|
pid_t tid = gettid();
|
|
if (m_holder == tid) {
|
|
++m_level;
|
|
return;
|
|
}
|
|
for (;;) {
|
|
int expected = 0;
|
|
if (m_holder.compare_exchange_strong(expected, tid, AK::memory_order_acq_rel)) {
|
|
m_level = 1;
|
|
return;
|
|
}
|
|
donate(expected);
|
|
}
|
|
}
|
|
|
|
inline void Lock::unlock()
|
|
{
|
|
VERIFY(m_holder == gettid());
|
|
VERIFY(m_level);
|
|
if (m_level == 1)
|
|
m_holder.store(0, AK::memory_order_release);
|
|
else
|
|
--m_level;
|
|
}
|
|
|
|
template<typename T>
|
|
class Lockable {
|
|
public:
|
|
Lockable() { }
|
|
|
|
template<typename... Args>
|
|
Lockable(Args&&... args)
|
|
: m_resource(forward(args)...)
|
|
{
|
|
}
|
|
|
|
Lockable(T&& resource)
|
|
: m_resource(move(resource))
|
|
{
|
|
}
|
|
Lock& lock() { return m_lock; }
|
|
T& resource() { return m_resource; }
|
|
|
|
T lock_and_copy()
|
|
{
|
|
Locker locker(m_lock);
|
|
return m_resource;
|
|
}
|
|
|
|
private:
|
|
T m_resource;
|
|
Lock m_lock;
|
|
};
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
namespace LibThread {
|
|
|
|
class Lock {
|
|
public:
|
|
Lock() { }
|
|
~Lock() { }
|
|
};
|
|
|
|
class Locker {
|
|
public:
|
|
explicit Locker(Lock&) { }
|
|
~Locker() { }
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|