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