1 /* 2 * Copyright (C) 2005, 2008 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 "JSObject.h" 27 #include "ScopeChain.h" 28 29 #if USE(PTHREADS) 30 #include <pthread.h> 31 #endif 32 33 namespace JSC { 34 35 // JSLock is only needed to support an obsolete execution model where JavaScriptCore 36 // automatically protected against concurrent access from multiple threads. 37 // So it's safe to disable it on non-mac platforms where we don't have native pthreads. 38 #if ENABLE(JSC_MULTIPLE_THREADS) && (OS(DARWIN) || USE(PTHREADS)) 39 40 // Acquire this mutex before accessing lock-related data. 41 static pthread_mutex_t JSMutex = PTHREAD_MUTEX_INITIALIZER; 42 43 // Thread-specific key that tells whether a thread holds the JSMutex, and how many times it was taken recursively. 44 pthread_key_t JSLockCount; 45 46 static void createJSLockCount() 47 { 48 pthread_key_create(&JSLockCount, 0); 49 } 50 51 pthread_once_t createJSLockCountOnce = PTHREAD_ONCE_INIT; 52 53 // Lock nesting count. 54 intptr_t JSLock::lockCount() 55 { 56 pthread_once(&createJSLockCountOnce, createJSLockCount); 57 58 return reinterpret_cast<intptr_t>(pthread_getspecific(JSLockCount)); 59 } 60 61 static void setLockCount(intptr_t count) 62 { 63 ASSERT(count >= 0); 64 pthread_setspecific(JSLockCount, reinterpret_cast<void*>(count)); 65 } 66 67 JSLock::JSLock(ExecState* exec) 68 : m_lockBehavior(exec->globalData().isSharedInstance() ? LockForReal : SilenceAssertionsOnly) 69 { 70 lock(m_lockBehavior); 71 } 72 73 JSLock::JSLock(JSGlobalData* globalData) 74 : m_lockBehavior(globalData->isSharedInstance() ? LockForReal : SilenceAssertionsOnly) 75 { 76 lock(m_lockBehavior); 77 } 78 79 void JSLock::lock(JSLockBehavior lockBehavior) 80 { 81 #ifdef NDEBUG 82 // Locking "not for real" is a debug-only feature. 83 if (lockBehavior == SilenceAssertionsOnly) 84 return; 85 #endif 86 87 pthread_once(&createJSLockCountOnce, createJSLockCount); 88 89 intptr_t currentLockCount = lockCount(); 90 if (!currentLockCount && lockBehavior == LockForReal) { 91 int result; 92 result = pthread_mutex_lock(&JSMutex); 93 ASSERT(!result); 94 } 95 setLockCount(currentLockCount + 1); 96 } 97 98 void JSLock::unlock(JSLockBehavior lockBehavior) 99 { 100 ASSERT(lockCount()); 101 102 #ifdef NDEBUG 103 // Locking "not for real" is a debug-only feature. 104 if (lockBehavior == SilenceAssertionsOnly) 105 return; 106 #endif 107 108 intptr_t newLockCount = lockCount() - 1; 109 setLockCount(newLockCount); 110 if (!newLockCount && lockBehavior == LockForReal) { 111 int result; 112 result = pthread_mutex_unlock(&JSMutex); 113 ASSERT(!result); 114 } 115 } 116 117 void JSLock::lock(ExecState* exec) 118 { 119 lock(exec->globalData().isSharedInstance() ? LockForReal : SilenceAssertionsOnly); 120 } 121 122 void JSLock::unlock(ExecState* exec) 123 { 124 unlock(exec->globalData().isSharedInstance() ? LockForReal : SilenceAssertionsOnly); 125 } 126 127 bool JSLock::currentThreadIsHoldingLock() 128 { 129 pthread_once(&createJSLockCountOnce, createJSLockCount); 130 return !!pthread_getspecific(JSLockCount); 131 } 132 133 // This is fairly nasty. We allow multiple threads to run on the same 134 // context, and we do not require any locking semantics in doing so - 135 // clients of the API may simply use the context from multiple threads 136 // concurently, and assume this will work. In order to make this work, 137 // We lock the context when a thread enters, and unlock it when it leaves. 138 // However we do not only unlock when the thread returns from its 139 // entry point (evaluate script or call function), we also unlock the 140 // context if the thread leaves JSC by making a call out to an external 141 // function through a callback. 142 // 143 // All threads using the context share the same JS stack (the RegisterFile). 144 // Whenever a thread calls into JSC it starts using the RegisterFile from the 145 // previous 'high water mark' - the maximum point the stack has ever grown to 146 // (returned by RegisterFile::end()). So if a first thread calls out to a 147 // callback, and a second thread enters JSC, then also exits by calling out 148 // to a callback, we can be left with stackframes from both threads in the 149 // RegisterFile. As such, a problem may occur should the first thread's 150 // callback complete first, and attempt to return to JSC. Were we to allow 151 // this to happen, and were its stack to grow further, then it may potentially 152 // write over the second thread's call frames. 153 // 154 // In avoid JS stack corruption we enforce a policy of only ever allowing two 155 // threads to use a JS context concurrently, and only allowing the second of 156 // these threads to execute until it has completed and fully returned from its 157 // outermost call into JSC. We enforce this policy using 'lockDropDepth'. The 158 // first time a thread exits it will call DropAllLocks - which will do as expected 159 // and drop locks allowing another thread to enter. Should another thread, or the 160 // same thread again, enter JSC (through evaluate script or call function), and exit 161 // again through a callback, then the locks will not be dropped when DropAllLocks 162 // is called (since lockDropDepth is non-zero). Since this thread is still holding 163 // the locks, only it will re able to re-enter JSC (either be returning from the 164 // callback, or by re-entering through another call to evaulate script or call 165 // function). 166 // 167 // This policy is slightly more restricive than it needs to be for correctness - 168 // we could validly allow futher entries into JSC from other threads, we only 169 // need ensure that callbacks return in the reverse chronological order of the 170 // order in which they were made - though implementing the less restrictive policy 171 // would likely increase complexity and overhead. 172 // 173 static unsigned lockDropDepth = 0; 174 175 JSLock::DropAllLocks::DropAllLocks(ExecState* exec) 176 : m_lockBehavior(exec->globalData().isSharedInstance() ? LockForReal : SilenceAssertionsOnly) 177 { 178 pthread_once(&createJSLockCountOnce, createJSLockCount); 179 180 if (lockDropDepth++) { 181 m_lockCount = 0; 182 return; 183 } 184 185 m_lockCount = JSLock::lockCount(); 186 for (intptr_t i = 0; i < m_lockCount; i++) 187 JSLock::unlock(m_lockBehavior); 188 } 189 190 JSLock::DropAllLocks::DropAllLocks(JSLockBehavior JSLockBehavior) 191 : m_lockBehavior(JSLockBehavior) 192 { 193 pthread_once(&createJSLockCountOnce, createJSLockCount); 194 195 if (lockDropDepth++) { 196 m_lockCount = 0; 197 return; 198 } 199 200 // It is necessary to drop even "unreal" locks, because having a non-zero lock count 201 // will prevent a real lock from being taken. 202 203 m_lockCount = JSLock::lockCount(); 204 for (intptr_t i = 0; i < m_lockCount; i++) 205 JSLock::unlock(m_lockBehavior); 206 } 207 208 JSLock::DropAllLocks::~DropAllLocks() 209 { 210 for (intptr_t i = 0; i < m_lockCount; i++) 211 JSLock::lock(m_lockBehavior); 212 213 --lockDropDepth; 214 } 215 216 #else // ENABLE(JSC_MULTIPLE_THREADS) && (OS(DARWIN) || USE(PTHREADS)) 217 218 JSLock::JSLock(ExecState*) 219 : m_lockBehavior(SilenceAssertionsOnly) 220 { 221 } 222 223 // If threading support is off, set the lock count to a constant value of 1 so ssertions 224 // that the lock is held don't fail 225 intptr_t JSLock::lockCount() 226 { 227 return 1; 228 } 229 230 bool JSLock::currentThreadIsHoldingLock() 231 { 232 return true; 233 } 234 235 void JSLock::lock(JSLockBehavior) 236 { 237 } 238 239 void JSLock::unlock(JSLockBehavior) 240 { 241 } 242 243 void JSLock::lock(ExecState*) 244 { 245 } 246 247 void JSLock::unlock(ExecState*) 248 { 249 } 250 251 JSLock::DropAllLocks::DropAllLocks(ExecState*) 252 { 253 } 254 255 JSLock::DropAllLocks::DropAllLocks(JSLockBehavior) 256 { 257 } 258 259 JSLock::DropAllLocks::~DropAllLocks() 260 { 261 } 262 263 #endif // ENABLE(JSC_MULTIPLE_THREADS) && (OS(DARWIN) || USE(PTHREADS)) 264 265 } // namespace JSC 266