jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this
9 * list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation
13 * and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
22 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#pragma once
28
29#ifdef __serenity__
30
31#include <AK/Assertions.h>
32#include <AK/Types.h>
33#include <AK/Atomic.h>
34#include <unistd.h>
35
36namespace LibThread {
37
38class Lock {
39public:
40 Lock() {}
41 ~Lock() {}
42
43 void lock();
44 void unlock();
45
46private:
47 AK::Atomic<bool> m_lock { false };
48 u32 m_level { 0 };
49 int m_holder { -1 };
50};
51
52class Locker {
53public:
54 [[gnu::always_inline]] inline explicit Locker(Lock& l)
55 : m_lock(l)
56 {
57 lock();
58 }
59 [[gnu::always_inline]] inline ~Locker() { unlock(); }
60 [[gnu::always_inline]] inline void unlock() { m_lock.unlock(); }
61 [[gnu::always_inline]] inline void lock() { m_lock.lock(); }
62
63private:
64 Lock& m_lock;
65};
66
67[[gnu::always_inline]] inline void Lock::lock()
68{
69 int tid = gettid();
70 for (;;) {
71 bool expected = false;
72 if (m_lock.compare_exchange_strong(expected, true, AK::memory_order_acq_rel)) {
73 if (m_holder == -1 || m_holder == tid) {
74 m_holder = tid;
75 ++m_level;
76 m_lock.store(false, AK::memory_order_release);
77 return;
78 }
79 m_lock.store(false, AK::memory_order_release);
80 }
81 donate(m_holder);
82 }
83}
84
85inline void Lock::unlock()
86{
87 for (;;) {
88 bool expected = false;
89 if (m_lock.compare_exchange_strong(expected, true, AK::memory_order_acq_rel)) {
90 ASSERT(m_holder == gettid());
91 ASSERT(m_level);
92 --m_level;
93 if (m_level) {
94 m_lock.store(false, AK::memory_order_release);
95 return;
96 }
97 m_holder = -1;
98 m_lock.store(false, AK::memory_order_release);
99 return;
100 }
101 donate(m_holder);
102 }
103}
104
105#define LOCKER(lock) LibThread::Locker locker(lock)
106
107template<typename T>
108class Lockable {
109public:
110 Lockable() {}
111 Lockable(T&& resource)
112 : m_resource(move(resource))
113 {
114 }
115 Lock& lock() { return m_lock; }
116 T& resource() { return m_resource; }
117
118 T lock_and_copy()
119 {
120 LOCKER(m_lock);
121 return m_resource;
122 }
123
124private:
125 T m_resource;
126 Lock m_lock;
127};
128
129}
130
131#else
132
133namespace LibThread {
134
135class Lock {
136public:
137 Lock() { }
138 ~Lock() { }
139};
140
141}
142
143#define LOCKER(x)
144
145#endif