1526d0993ceaee943c9f25c18d3a126cc52a1cae
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSLock.cpp
1 /*
2  * Copyright (C) 2005, 2008, 2012, 2014 Apple Inc. All rights reserved.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the NU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB.  If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA 
18  *
19  */
20
21 #include "config.h"
22 #include "JSLock.h"
23
24 #include "Heap.h"
25 #include "CallFrame.h"
26 #include "JSGlobalObject.h"
27 #include "JSObject.h"
28 #include "JSCInlines.h"
29 #include <thread>
30
31 namespace JSC {
32
33 std::mutex* GlobalJSLock::s_sharedInstanceMutex;
34
35 GlobalJSLock::GlobalJSLock()
36 {
37     s_sharedInstanceMutex->lock();
38 }
39
40 GlobalJSLock::~GlobalJSLock()
41 {
42     s_sharedInstanceMutex->unlock();
43 }
44
45 void GlobalJSLock::initialize()
46 {
47     s_sharedInstanceMutex = new std::mutex();
48 }
49
50 JSLockHolder::JSLockHolder(ExecState* exec)
51     : m_vm(&exec->vm())
52 {
53     init();
54 }
55
56 JSLockHolder::JSLockHolder(VM* vm)
57     : m_vm(vm)
58 {
59     init();
60 }
61
62 JSLockHolder::JSLockHolder(VM& vm)
63     : m_vm(&vm)
64 {
65     init();
66 }
67
68 void JSLockHolder::init()
69 {
70     m_vm->apiLock().lock();
71 }
72
73 JSLockHolder::~JSLockHolder()
74 {
75     RefPtr<JSLock> apiLock(&m_vm->apiLock());
76     m_vm = nullptr;
77     apiLock->unlock();
78 }
79
80 JSLock::JSLock(VM* vm)
81     : m_ownerThreadID(std::thread::id())
82     , m_lockCount(0)
83     , m_lockDropDepth(0)
84     , m_hasExclusiveThread(false)
85     , m_vm(vm)
86     , m_entryAtomicStringTable(nullptr)
87 {
88 }
89
90 JSLock::~JSLock()
91 {
92 }
93
94 void JSLock::willDestroyVM(VM* vm)
95 {
96     ASSERT_UNUSED(vm, m_vm == vm);
97     m_vm = nullptr;
98 }
99
100 void JSLock::setExclusiveThread(std::thread::id threadId)
101 {
102     RELEASE_ASSERT(!m_lockCount && m_ownerThreadID == std::thread::id());
103     m_hasExclusiveThread = (threadId != std::thread::id());
104     m_ownerThreadID = threadId;
105 }
106
107 void JSLock::lock()
108 {
109     lock(1);
110 }
111
112 void JSLock::lock(intptr_t lockCount)
113 {
114     ASSERT(lockCount > 0);
115     if (currentThreadIsHoldingLock()) {
116         m_lockCount += lockCount;
117         return;
118     }
119
120     if (!m_hasExclusiveThread) {
121         m_lock.lock();
122         m_ownerThreadID = std::this_thread::get_id();
123     }
124     ASSERT(!m_lockCount);
125     m_lockCount = lockCount;
126
127     didAcquireLock();
128 }
129
130 void JSLock::didAcquireLock()
131 {
132     // FIXME: What should happen to the per-thread identifier table if we don't have a VM?
133     if (!m_vm)
134         return;
135
136     RELEASE_ASSERT(!m_vm->stackPointerAtVMEntry());
137     void* p = &p; // A proxy for the current stack pointer.
138     m_vm->setStackPointerAtVMEntry(p);
139
140     WTFThreadData& threadData = wtfThreadData();
141     m_vm->setLastStackTop(threadData.savedLastStackTop());
142
143     ASSERT(!m_entryAtomicStringTable);
144     m_entryAtomicStringTable = threadData.setCurrentAtomicStringTable(m_vm->atomicStringTable());
145     ASSERT(m_entryAtomicStringTable);
146
147     m_vm->heap.machineThreads().addCurrentThread();
148 }
149
150 void JSLock::unlock()
151 {
152     unlock(1);
153 }
154
155 void JSLock::unlock(intptr_t unlockCount)
156 {
157     RELEASE_ASSERT(currentThreadIsHoldingLock());
158     ASSERT(m_lockCount >= unlockCount);
159
160     // Maintain m_lockCount while calling willReleaseLock() so that its callees know that
161     // they still have the lock.
162     if (unlockCount == m_lockCount)
163         willReleaseLock();
164
165     m_lockCount -= unlockCount;
166
167     if (!m_lockCount) {
168
169         if (!m_hasExclusiveThread) {
170             m_ownerThreadID = std::thread::id();
171             m_lock.unlock();
172         }
173     }
174 }
175
176 void JSLock::willReleaseLock()
177 {
178     if (m_vm) {
179         m_vm->drainMicrotasks();
180
181         m_vm->heap.releaseDelayedReleasedObjects();
182         m_vm->setStackPointerAtVMEntry(nullptr);
183     }
184
185     if (m_entryAtomicStringTable) {
186         wtfThreadData().setCurrentAtomicStringTable(m_entryAtomicStringTable);
187         m_entryAtomicStringTable = nullptr;
188     }
189 }
190
191 void JSLock::lock(ExecState* exec)
192 {
193     exec->vm().apiLock().lock();
194 }
195
196 void JSLock::unlock(ExecState* exec)
197 {
198     exec->vm().apiLock().unlock();
199 }
200
201 bool JSLock::currentThreadIsHoldingLock()
202 {
203     ASSERT(!m_hasExclusiveThread || (exclusiveThread() == std::this_thread::get_id()));
204     if (m_hasExclusiveThread)
205         return !!m_lockCount;
206     return m_ownerThreadID == std::this_thread::get_id();
207 }
208
209 // This function returns the number of locks that were dropped.
210 unsigned JSLock::dropAllLocks(DropAllLocks* dropper)
211 {
212     if (m_hasExclusiveThread) {
213         ASSERT(exclusiveThread() == std::this_thread::get_id());
214         return 0;
215     }
216
217     if (!currentThreadIsHoldingLock())
218         return 0;
219
220     ++m_lockDropDepth;
221
222     dropper->setDropDepth(m_lockDropDepth);
223
224     WTFThreadData& threadData = wtfThreadData();
225     threadData.setSavedStackPointerAtVMEntry(m_vm->stackPointerAtVMEntry());
226     threadData.setSavedLastStackTop(m_vm->lastStackTop());
227
228     unsigned droppedLockCount = m_lockCount;
229     unlock(droppedLockCount);
230
231     return droppedLockCount;
232 }
233
234 void JSLock::grabAllLocks(DropAllLocks* dropper, unsigned droppedLockCount)
235 {
236     ASSERT(!m_hasExclusiveThread || !droppedLockCount);
237
238     // If no locks were dropped, nothing to do!
239     if (!droppedLockCount)
240         return;
241
242     ASSERT(!currentThreadIsHoldingLock());
243     lock(droppedLockCount);
244
245     while (dropper->dropDepth() != m_lockDropDepth) {
246         unlock(droppedLockCount);
247         std::this_thread::yield();
248         lock(droppedLockCount);
249     }
250
251     --m_lockDropDepth;
252
253     WTFThreadData& threadData = wtfThreadData();
254     m_vm->setStackPointerAtVMEntry(threadData.savedStackPointerAtVMEntry());
255     m_vm->setLastStackTop(threadData.savedLastStackTop());
256 }
257
258 JSLock::DropAllLocks::DropAllLocks(VM* vm)
259     : m_droppedLockCount(0)
260     // If the VM is in the middle of being destroyed then we don't want to resurrect it
261     // by allowing DropAllLocks to ref it. By this point the JSLock has already been 
262     // released anyways, so it doesn't matter that DropAllLocks is a no-op.
263     , m_vm(vm->refCount() ? vm : nullptr)
264 {
265     if (!m_vm)
266         return;
267     wtfThreadData().resetCurrentAtomicStringTable();
268     RELEASE_ASSERT(!m_vm->apiLock().currentThreadIsHoldingLock() || !m_vm->isCollectorBusy());
269     m_droppedLockCount = m_vm->apiLock().dropAllLocks(this);
270 }
271
272 JSLock::DropAllLocks::DropAllLocks(ExecState* exec)
273     : DropAllLocks(exec ? &exec->vm() : nullptr)
274 {
275 }
276
277 JSLock::DropAllLocks::DropAllLocks(VM& vm)
278     : DropAllLocks(&vm)
279 {
280 }
281
282 JSLock::DropAllLocks::~DropAllLocks()
283 {
284     if (!m_vm)
285         return;
286     m_vm->apiLock().grabAllLocks(this, m_droppedLockCount);
287     wtfThreadData().setCurrentAtomicStringTable(m_vm->atomicStringTable());
288 }
289
290 } // namespace JSC