1/*
2** 2007 August 14
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
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.
10**
11*************************************************************************
12** This file contains the C functions that implement mutexes for Win32.
13*/
14#include "sqliteInt.h"
15
16#if SQLITE_OS_WIN
17/*
18** Include code that is common to all os_*.c files
19*/
20#include "os_common.h"
21
22/*
23** Include the header file for the Windows VFS.
24*/
25#include "os_win.h"
26#endif
27
28/*
29** The code in this file is only used if we are compiling multithreaded
30** on a Win32 system.
31*/
32#ifdef SQLITE_MUTEX_W32
33
34/*
35** Each recursive mutex is an instance of the following structure.
36*/
37struct sqlite3_mutex {
38 CRITICAL_SECTION mutex; /* Mutex controlling the lock */
39 int id; /* Mutex type */
40#ifdef SQLITE_DEBUG
41 volatile int nRef; /* Number of enterances */
42 volatile DWORD owner; /* Thread holding this mutex */
43 volatile LONG trace; /* True to trace changes */
44#endif
45};
46
47/*
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.
51*/
52#define SQLITE_W32_MUTEX_INITIALIZER { 0 }
53
54#ifdef SQLITE_DEBUG
55#define SQLITE3_MUTEX_INITIALIZER(id) { SQLITE_W32_MUTEX_INITIALIZER, id, \
56 0L, (DWORD)0, 0 }
57#else
58#define SQLITE3_MUTEX_INITIALIZER(id) { SQLITE_W32_MUTEX_INITIALIZER, id }
59#endif
60
61#ifdef SQLITE_DEBUG
62/*
63** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
64** intended for use only inside assert() statements.
65*/
66static int winMutexHeld(sqlite3_mutex *p){
67 return p->nRef!=0 && p->owner==GetCurrentThreadId();
68}
69
70static int winMutexNotheld2(sqlite3_mutex *p, DWORD tid){
71 return p->nRef==0 || p->owner!=tid;
72}
73
74static int winMutexNotheld(sqlite3_mutex *p){
75 DWORD tid = GetCurrentThreadId();
76 return winMutexNotheld2(p, tid);
77}
78#endif
79
80/*
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).
84*/
85void sqlite3MemoryBarrier(void){
86#if defined(SQLITE_MEMORY_BARRIER)
87 SQLITE_MEMORY_BARRIER;
88#elif defined(__GNUC__)
89 __sync_synchronize();
90#elif MSVC_VERSION>=1300
91 _ReadWriteBarrier();
92#elif defined(MemoryBarrier)
93 MemoryBarrier();
94#endif
95}
96
97/*
98** Initialize and deinitialize the mutex subsystem.
99*/
100static sqlite3_mutex winMutex_staticMutexes[] = {
101 SQLITE3_MUTEX_INITIALIZER(2),
102 SQLITE3_MUTEX_INITIALIZER(3),
103 SQLITE3_MUTEX_INITIALIZER(4),
104 SQLITE3_MUTEX_INITIALIZER(5),
105 SQLITE3_MUTEX_INITIALIZER(6),
106 SQLITE3_MUTEX_INITIALIZER(7),
107 SQLITE3_MUTEX_INITIALIZER(8),
108 SQLITE3_MUTEX_INITIALIZER(9),
109 SQLITE3_MUTEX_INITIALIZER(10),
110 SQLITE3_MUTEX_INITIALIZER(11),
111 SQLITE3_MUTEX_INITIALIZER(12),
112 SQLITE3_MUTEX_INITIALIZER(13)
113};
114
115static int winMutex_isInit = 0;
116static int winMutex_isNt = -1; /* <0 means "need to query" */
117
118/* As the winMutexInit() and winMutexEnd() functions are called as part
119** of the sqlite3_initialize() and sqlite3_shutdown() processing, the
120** "interlocked" magic used here is probably not strictly necessary.
121*/
122static LONG SQLITE_WIN32_VOLATILE winMutex_lock = 0;
123
124int sqlite3_win32_is_nt(void); /* os_win.c */
125void sqlite3_win32_sleep(DWORD milliseconds); /* os_win.c */
126
127static int winMutexInit(void){
128 /* The first to increment to 1 does actual initialization */
129 if( InterlockedCompareExchange(&winMutex_lock, 1, 0)==0 ){
130 int i;
131 for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
132#if SQLITE_OS_WINRT
133 InitializeCriticalSectionEx(&winMutex_staticMutexes[i].mutex, 0, 0);
134#else
135 InitializeCriticalSection(&winMutex_staticMutexes[i].mutex);
136#endif
137 }
138 winMutex_isInit = 1;
139 }else{
140 /* Another thread is (in the process of) initializing the static
141 ** mutexes */
142 while( !winMutex_isInit ){
143 sqlite3_win32_sleep(1);
144 }
145 }
146 return SQLITE_OK;
147}
148
149static int winMutexEnd(void){
150 /* The first to decrement to 0 does actual shutdown
151 ** (which should be the last to shutdown.) */
152 if( InterlockedCompareExchange(&winMutex_lock, 0, 1)==1 ){
153 if( winMutex_isInit==1 ){
154 int i;
155 for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
156 DeleteCriticalSection(&winMutex_staticMutexes[i].mutex);
157 }
158 winMutex_isInit = 0;
159 }
160 }
161 return SQLITE_OK;
162}
163
164/*
165** The sqlite3_mutex_alloc() routine allocates a new
166** mutex and returns a pointer to it. If it returns NULL
167** that means that a mutex could not be allocated. SQLite
168** will unwind its stack and return an error. The argument
169** to sqlite3_mutex_alloc() is one of these integer constants:
170**
171** <ul>
172** <li> SQLITE_MUTEX_FAST
173** <li> SQLITE_MUTEX_RECURSIVE
174** <li> SQLITE_MUTEX_STATIC_MAIN
175** <li> SQLITE_MUTEX_STATIC_MEM
176** <li> SQLITE_MUTEX_STATIC_OPEN
177** <li> SQLITE_MUTEX_STATIC_PRNG
178** <li> SQLITE_MUTEX_STATIC_LRU
179** <li> SQLITE_MUTEX_STATIC_PMEM
180** <li> SQLITE_MUTEX_STATIC_APP1
181** <li> SQLITE_MUTEX_STATIC_APP2
182** <li> SQLITE_MUTEX_STATIC_APP3
183** <li> SQLITE_MUTEX_STATIC_VFS1
184** <li> SQLITE_MUTEX_STATIC_VFS2
185** <li> SQLITE_MUTEX_STATIC_VFS3
186** </ul>
187**
188** The first two constants cause sqlite3_mutex_alloc() to create
189** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
190** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
191** The mutex implementation does not need to make a distinction
192** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
193** not want to. But SQLite will only request a recursive mutex in
194** cases where it really needs one. If a faster non-recursive mutex
195** implementation is available on the host platform, the mutex subsystem
196** might return such a mutex in response to SQLITE_MUTEX_FAST.
197**
198** The other allowed parameters to sqlite3_mutex_alloc() each return
199** a pointer to a static preexisting mutex. Six static mutexes are
200** used by the current version of SQLite. Future versions of SQLite
201** may add additional static mutexes. Static mutexes are for internal
202** use by SQLite only. Applications that use SQLite mutexes should
203** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
204** SQLITE_MUTEX_RECURSIVE.
205**
206** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
207** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
208** returns a different mutex on every call. But for the static
209** mutex types, the same mutex is returned on every call that has
210** the same type number.
211*/
212static sqlite3_mutex *winMutexAlloc(int iType){
213 sqlite3_mutex *p;
214
215 switch( iType ){
216 case SQLITE_MUTEX_FAST:
217 case SQLITE_MUTEX_RECURSIVE: {
218 p = sqlite3MallocZero( sizeof(*p) );
219 if( p ){
220 p->id = iType;
221#ifdef SQLITE_DEBUG
222#ifdef SQLITE_WIN32_MUTEX_TRACE_DYNAMIC
223 p->trace = 1;
224#endif
225#endif
226#if SQLITE_OS_WINRT
227 InitializeCriticalSectionEx(&p->mutex, 0, 0);
228#else
229 InitializeCriticalSection(&p->mutex);
230#endif
231 }
232 break;
233 }
234 default: {
235#ifdef SQLITE_ENABLE_API_ARMOR
236 if( iType-2<0 || iType-2>=ArraySize(winMutex_staticMutexes) ){
237 (void)SQLITE_MISUSE_BKPT;
238 return 0;
239 }
240#endif
241 p = &winMutex_staticMutexes[iType-2];
242#ifdef SQLITE_DEBUG
243#ifdef SQLITE_WIN32_MUTEX_TRACE_STATIC
244 InterlockedCompareExchange(&p->trace, 1, 0);
245#endif
246#endif
247 break;
248 }
249 }
250 assert( p==0 || p->id==iType );
251 return p;
252}
253
254
255/*
256** This routine deallocates a previously
257** allocated mutex. SQLite is careful to deallocate every
258** mutex that it allocates.
259*/
260static void winMutexFree(sqlite3_mutex *p){
261 assert( p );
262 assert( p->nRef==0 && p->owner==0 );
263 if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ){
264 DeleteCriticalSection(&p->mutex);
265 sqlite3_free(p);
266 }else{
267#ifdef SQLITE_ENABLE_API_ARMOR
268 (void)SQLITE_MISUSE_BKPT;
269#endif
270 }
271}
272
273/*
274** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
275** to enter a mutex. If another thread is already within the mutex,
276** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
277** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
278** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
279** be entered multiple times by the same thread. In such cases the,
280** mutex must be exited an equal number of times before another thread
281** can enter. If the same thread tries to enter any other kind of mutex
282** more than once, the behavior is undefined.
283*/
284static void winMutexEnter(sqlite3_mutex *p){
285#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
286 DWORD tid = GetCurrentThreadId();
287#endif
288#ifdef SQLITE_DEBUG
289 assert( p );
290 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
291#else
292 assert( p );
293#endif
294 assert( winMutex_isInit==1 );
295 EnterCriticalSection(&p->mutex);
296#ifdef SQLITE_DEBUG
297 assert( p->nRef>0 || p->owner==0 );
298 p->owner = tid;
299 p->nRef++;
300 if( p->trace ){
301 OSTRACE(("ENTER-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n",
302 tid, p->id, p, p->trace, p->nRef));
303 }
304#endif
305}
306
307static int winMutexTry(sqlite3_mutex *p){
308#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
309 DWORD tid = GetCurrentThreadId();
310#endif
311 int rc = SQLITE_BUSY;
312 assert( p );
313 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
314 /*
315 ** The sqlite3_mutex_try() routine is very rarely used, and when it
316 ** is used it is merely an optimization. So it is OK for it to always
317 ** fail.
318 **
319 ** The TryEnterCriticalSection() interface is only available on WinNT.
320 ** And some windows compilers complain if you try to use it without
321 ** first doing some #defines that prevent SQLite from building on Win98.
322 ** For that reason, we will omit this optimization for now. See
323 ** ticket #2685.
324 */
325#if defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0400
326 assert( winMutex_isInit==1 );
327 assert( winMutex_isNt>=-1 && winMutex_isNt<=1 );
328 if( winMutex_isNt<0 ){
329 winMutex_isNt = sqlite3_win32_is_nt();
330 }
331 assert( winMutex_isNt==0 || winMutex_isNt==1 );
332 if( winMutex_isNt && TryEnterCriticalSection(&p->mutex) ){
333#ifdef SQLITE_DEBUG
334 p->owner = tid;
335 p->nRef++;
336#endif
337 rc = SQLITE_OK;
338 }
339#else
340 UNUSED_PARAMETER(p);
341#endif
342#ifdef SQLITE_DEBUG
343 if( p->trace ){
344 OSTRACE(("TRY-MUTEX tid=%lu, mutex(%d)=%p (%d), owner=%lu, nRef=%d, rc=%s\n",
345 tid, p->id, p, p->trace, p->owner, p->nRef, sqlite3ErrName(rc)));
346 }
347#endif
348 return rc;
349}
350
351/*
352** The sqlite3_mutex_leave() routine exits a mutex that was
353** previously entered by the same thread. The behavior
354** is undefined if the mutex is not currently entered or
355** is not currently allocated. SQLite will never do either.
356*/
357static void winMutexLeave(sqlite3_mutex *p){
358#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
359 DWORD tid = GetCurrentThreadId();
360#endif
361 assert( p );
362#ifdef SQLITE_DEBUG
363 assert( p->nRef>0 );
364 assert( p->owner==tid );
365 p->nRef--;
366 if( p->nRef==0 ) p->owner = 0;
367 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
368#endif
369 assert( winMutex_isInit==1 );
370 LeaveCriticalSection(&p->mutex);
371#ifdef SQLITE_DEBUG
372 if( p->trace ){
373 OSTRACE(("LEAVE-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n",
374 tid, p->id, p, p->trace, p->nRef));
375 }
376#endif
377}
378
379sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
380 static const sqlite3_mutex_methods sMutex = {
381 winMutexInit,
382 winMutexEnd,
383 winMutexAlloc,
384 winMutexFree,
385 winMutexEnter,
386 winMutexTry,
387 winMutexLeave,
388#ifdef SQLITE_DEBUG
389 winMutexHeld,
390 winMutexNotheld
391#else
392 0,
393 0
394#endif
395 };
396 return &sMutex;
397}
398
399#endif /* SQLITE_MUTEX_W32 */
400