1/*
2 * Copyright (C) 2005, 2008, 2009 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 GNU
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#ifndef JSLock_h
22#define JSLock_h
23
24#include <wtf/Assertions.h>
25#include <wtf/Noncopyable.h>
26
27namespace JSC {
28
29    // To make it safe to use JavaScript on multiple threads, it is
30    // important to lock before doing anything that allocates a
31    // JavaScript data structure or that interacts with shared state
32    // such as the protect count hash table. The simplest way to lock
33    // is to create a local JSLock object in the scope where the lock
34    // must be held. The lock is recursive so nesting is ok. The JSLock
35    // object also acts as a convenience short-hand for running important
36    // initialization routines.
37
38    // To avoid deadlock, sometimes it is necessary to temporarily
39    // release the lock. Since it is recursive you actually have to
40    // release all locks held by your thread. This is safe to do if
41    // you are executing code that doesn't require the lock, and you
42    // reacquire the right number of locks at the end. You can do this
43    // by constructing a locally scoped JSLock::DropAllLocks object. The
44    // DropAllLocks object takes care to release the JSLock only if your
45    // thread acquired it to begin with.
46
47    // For contexts other than the single shared one, implicit locking is not done,
48    // but we still need to perform all the counting in order to keep debug
49    // assertions working, so that clients that use the shared context don't break.
50
51    class ExecState;
52    class JSGlobalData;
53
54    enum JSLockBehavior { SilenceAssertionsOnly, LockForReal };
55
56    class JSLock {
57        WTF_MAKE_NONCOPYABLE(JSLock);
58    public:
59        JSLock(ExecState*);
60        JSLock(JSGlobalData*);
61
62        JSLock(JSLockBehavior lockBehavior)
63            : m_lockBehavior(lockBehavior)
64        {
65#ifdef NDEBUG
66            // Locking "not for real" is a debug-only feature.
67            if (lockBehavior == SilenceAssertionsOnly)
68                return;
69#endif
70            lock(lockBehavior);
71        }
72
73        ~JSLock()
74        {
75#ifdef NDEBUG
76            // Locking "not for real" is a debug-only feature.
77            if (m_lockBehavior == SilenceAssertionsOnly)
78                return;
79#endif
80            unlock(m_lockBehavior);
81        }
82
83        static void lock(JSLockBehavior);
84        static void unlock(JSLockBehavior);
85        static void lock(ExecState*);
86        static void unlock(ExecState*);
87
88        static intptr_t lockCount();
89        static bool currentThreadIsHoldingLock();
90
91        JSLockBehavior m_lockBehavior;
92
93        class DropAllLocks {
94            WTF_MAKE_NONCOPYABLE(DropAllLocks);
95        public:
96            DropAllLocks(ExecState* exec);
97            DropAllLocks(JSLockBehavior);
98            ~DropAllLocks();
99
100        private:
101            intptr_t m_lockCount;
102            JSLockBehavior m_lockBehavior;
103        };
104    };
105
106} // namespace
107
108#endif // JSLock_h
109