4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
11 *************************************************************************
12 ** This file contains the C functions that implement mutexes for Win32.
14 #include "sqliteInt.h"
18 ** Include code that is common to all os_*.c files
20 #include "os_common.h"
23 ** Include the header file for the Windows VFS.
29 ** The code in this file is only used if we are compiling multithreaded
32 #ifdef SQLITE_MUTEX_W32
35 ** Each recursive mutex is an instance of the following structure.
37 struct sqlite3_mutex
{
38 CRITICAL_SECTION mutex
; /* Mutex controlling the lock */
39 int id
; /* Mutex type */
41 volatile int nRef
; /* Number of enterances */
42 volatile DWORD owner
; /* Thread holding this mutex */
43 volatile int trace
; /* True to trace changes */
48 ** These are the initializer values used when declaring a "static" mutex
49 ** on Win32. It should be noted that all mutexes require initialization
50 ** on the Win32 platform.
52 #define SQLITE_W32_MUTEX_INITIALIZER { 0 }
55 #define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0, \
58 #define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0 }
63 ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
64 ** intended for use only inside assert() statements.
66 static int winMutexHeld(sqlite3_mutex
*p
){
67 return p
->nRef
!=0 && p
->owner
==GetCurrentThreadId();
70 static int winMutexNotheld2(sqlite3_mutex
*p
, DWORD tid
){
71 return p
->nRef
==0 || p
->owner
!=tid
;
74 static int winMutexNotheld(sqlite3_mutex
*p
){
75 DWORD tid
= GetCurrentThreadId();
76 return winMutexNotheld2(p
, tid
);
81 ** Try to provide a memory barrier operation, needed for initialization
82 ** and also for the xShmBarrier method of the VFS in cases when SQLite is
83 ** compiled without mutexes (SQLITE_THREADSAFE=0).
85 void sqlite3MemoryBarrier(void){
86 #if defined(SQLITE_MEMORY_BARRIER)
87 SQLITE_MEMORY_BARRIER
;
88 #elif defined(__GNUC__)
90 #elif !defined(SQLITE_DISABLE_INTRINSIC) && \
91 defined(_MSC_VER) && _MSC_VER>=1300
93 #elif defined(MemoryBarrier)
99 ** Initialize and deinitialize the mutex subsystem.
101 static sqlite3_mutex winMutex_staticMutexes
[] = {
102 SQLITE3_MUTEX_INITIALIZER
,
103 SQLITE3_MUTEX_INITIALIZER
,
104 SQLITE3_MUTEX_INITIALIZER
,
105 SQLITE3_MUTEX_INITIALIZER
,
106 SQLITE3_MUTEX_INITIALIZER
,
107 SQLITE3_MUTEX_INITIALIZER
,
108 SQLITE3_MUTEX_INITIALIZER
,
109 SQLITE3_MUTEX_INITIALIZER
,
110 SQLITE3_MUTEX_INITIALIZER
,
111 SQLITE3_MUTEX_INITIALIZER
,
112 SQLITE3_MUTEX_INITIALIZER
,
113 SQLITE3_MUTEX_INITIALIZER
116 static int winMutex_isInit
= 0;
117 static int winMutex_isNt
= -1; /* <0 means "need to query" */
119 /* As the winMutexInit() and winMutexEnd() functions are called as part
120 ** of the sqlite3_initialize() and sqlite3_shutdown() processing, the
121 ** "interlocked" magic used here is probably not strictly necessary.
123 static LONG SQLITE_WIN32_VOLATILE winMutex_lock
= 0;
125 int sqlite3_win32_is_nt(void); /* os_win.c */
126 void sqlite3_win32_sleep(DWORD milliseconds
); /* os_win.c */
128 static int winMutexInit(void){
129 /* The first to increment to 1 does actual initialization */
130 if( InterlockedCompareExchange(&winMutex_lock
, 1, 0)==0 ){
132 for(i
=0; i
<ArraySize(winMutex_staticMutexes
); i
++){
134 InitializeCriticalSectionEx(&winMutex_staticMutexes
[i
].mutex
, 0, 0);
136 InitializeCriticalSection(&winMutex_staticMutexes
[i
].mutex
);
141 /* Another thread is (in the process of) initializing the static
143 while( !winMutex_isInit
){
144 sqlite3_win32_sleep(1);
150 static int winMutexEnd(void){
151 /* The first to decrement to 0 does actual shutdown
152 ** (which should be the last to shutdown.) */
153 if( InterlockedCompareExchange(&winMutex_lock
, 0, 1)==1 ){
154 if( winMutex_isInit
==1 ){
156 for(i
=0; i
<ArraySize(winMutex_staticMutexes
); i
++){
157 DeleteCriticalSection(&winMutex_staticMutexes
[i
].mutex
);
166 ** The sqlite3_mutex_alloc() routine allocates a new
167 ** mutex and returns a pointer to it. If it returns NULL
168 ** that means that a mutex could not be allocated. SQLite
169 ** will unwind its stack and return an error. The argument
170 ** to sqlite3_mutex_alloc() is one of these integer constants:
173 ** <li> SQLITE_MUTEX_FAST
174 ** <li> SQLITE_MUTEX_RECURSIVE
175 ** <li> SQLITE_MUTEX_STATIC_MASTER
176 ** <li> SQLITE_MUTEX_STATIC_MEM
177 ** <li> SQLITE_MUTEX_STATIC_OPEN
178 ** <li> SQLITE_MUTEX_STATIC_PRNG
179 ** <li> SQLITE_MUTEX_STATIC_LRU
180 ** <li> SQLITE_MUTEX_STATIC_PMEM
181 ** <li> SQLITE_MUTEX_STATIC_APP1
182 ** <li> SQLITE_MUTEX_STATIC_APP2
183 ** <li> SQLITE_MUTEX_STATIC_APP3
184 ** <li> SQLITE_MUTEX_STATIC_VFS1
185 ** <li> SQLITE_MUTEX_STATIC_VFS2
186 ** <li> SQLITE_MUTEX_STATIC_VFS3
189 ** The first two constants cause sqlite3_mutex_alloc() to create
190 ** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
191 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
192 ** The mutex implementation does not need to make a distinction
193 ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
194 ** not want to. But SQLite will only request a recursive mutex in
195 ** cases where it really needs one. If a faster non-recursive mutex
196 ** implementation is available on the host platform, the mutex subsystem
197 ** might return such a mutex in response to SQLITE_MUTEX_FAST.
199 ** The other allowed parameters to sqlite3_mutex_alloc() each return
200 ** a pointer to a static preexisting mutex. Six static mutexes are
201 ** used by the current version of SQLite. Future versions of SQLite
202 ** may add additional static mutexes. Static mutexes are for internal
203 ** use by SQLite only. Applications that use SQLite mutexes should
204 ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
205 ** SQLITE_MUTEX_RECURSIVE.
207 ** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
208 ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
209 ** returns a different mutex on every call. But for the static
210 ** mutex types, the same mutex is returned on every call that has
211 ** the same type number.
213 static sqlite3_mutex
*winMutexAlloc(int iType
){
217 case SQLITE_MUTEX_FAST
:
218 case SQLITE_MUTEX_RECURSIVE
: {
219 p
= sqlite3MallocZero( sizeof(*p
) );
223 #ifdef SQLITE_WIN32_MUTEX_TRACE_DYNAMIC
228 InitializeCriticalSectionEx(&p
->mutex
, 0, 0);
230 InitializeCriticalSection(&p
->mutex
);
236 #ifdef SQLITE_ENABLE_API_ARMOR
237 if( iType
-2<0 || iType
-2>=ArraySize(winMutex_staticMutexes
) ){
238 (void)SQLITE_MISUSE_BKPT
;
242 p
= &winMutex_staticMutexes
[iType
-2];
245 #ifdef SQLITE_WIN32_MUTEX_TRACE_STATIC
257 ** This routine deallocates a previously
258 ** allocated mutex. SQLite is careful to deallocate every
259 ** mutex that it allocates.
261 static void winMutexFree(sqlite3_mutex
*p
){
263 assert( p
->nRef
==0 && p
->owner
==0 );
264 if( p
->id
==SQLITE_MUTEX_FAST
|| p
->id
==SQLITE_MUTEX_RECURSIVE
){
265 DeleteCriticalSection(&p
->mutex
);
268 #ifdef SQLITE_ENABLE_API_ARMOR
269 (void)SQLITE_MISUSE_BKPT
;
275 ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
276 ** to enter a mutex. If another thread is already within the mutex,
277 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
278 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
279 ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
280 ** be entered multiple times by the same thread. In such cases the,
281 ** mutex must be exited an equal number of times before another thread
282 ** can enter. If the same thread tries to enter any other kind of mutex
283 ** more than once, the behavior is undefined.
285 static void winMutexEnter(sqlite3_mutex
*p
){
286 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
287 DWORD tid
= GetCurrentThreadId();
291 assert( p
->id
==SQLITE_MUTEX_RECURSIVE
|| winMutexNotheld2(p
, tid
) );
295 assert( winMutex_isInit
==1 );
296 EnterCriticalSection(&p
->mutex
);
298 assert( p
->nRef
>0 || p
->owner
==0 );
302 OSTRACE(("ENTER-MUTEX tid=%lu, mutex=%p (%d), nRef=%d\n",
303 tid
, p
, p
->trace
, p
->nRef
));
308 static int winMutexTry(sqlite3_mutex
*p
){
309 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
310 DWORD tid
= GetCurrentThreadId();
312 int rc
= SQLITE_BUSY
;
314 assert( p
->id
==SQLITE_MUTEX_RECURSIVE
|| winMutexNotheld2(p
, tid
) );
316 ** The sqlite3_mutex_try() routine is very rarely used, and when it
317 ** is used it is merely an optimization. So it is OK for it to always
320 ** The TryEnterCriticalSection() interface is only available on WinNT.
321 ** And some windows compilers complain if you try to use it without
322 ** first doing some #defines that prevent SQLite from building on Win98.
323 ** For that reason, we will omit this optimization for now. See
326 #if defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0400
327 assert( winMutex_isInit
==1 );
328 assert( winMutex_isNt
>=-1 && winMutex_isNt
<=1 );
329 if( winMutex_isNt
<0 ){
330 winMutex_isNt
= sqlite3_win32_is_nt();
332 assert( winMutex_isNt
==0 || winMutex_isNt
==1 );
333 if( winMutex_isNt
&& TryEnterCriticalSection(&p
->mutex
) ){
345 OSTRACE(("TRY-MUTEX tid=%lu, mutex=%p (%d), owner=%lu, nRef=%d, rc=%s\n",
346 tid
, p
, p
->trace
, p
->owner
, p
->nRef
, sqlite3ErrName(rc
)));
353 ** The sqlite3_mutex_leave() routine exits a mutex that was
354 ** previously entered by the same thread. The behavior
355 ** is undefined if the mutex is not currently entered or
356 ** is not currently allocated. SQLite will never do either.
358 static void winMutexLeave(sqlite3_mutex
*p
){
359 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
360 DWORD tid
= GetCurrentThreadId();
365 assert( p
->owner
==tid
);
367 if( p
->nRef
==0 ) p
->owner
= 0;
368 assert( p
->nRef
==0 || p
->id
==SQLITE_MUTEX_RECURSIVE
);
370 assert( winMutex_isInit
==1 );
371 LeaveCriticalSection(&p
->mutex
);
374 OSTRACE(("LEAVE-MUTEX tid=%lu, mutex=%p (%d), nRef=%d\n",
375 tid
, p
, p
->trace
, p
->nRef
));
380 sqlite3_mutex_methods
const *sqlite3DefaultMutex(void){
381 static const sqlite3_mutex_methods sMutex
= {
400 #endif /* SQLITE_MUTEX_W32 */