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