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.
14 ** This implementation in this file does not provide any mutual
15 ** exclusion and is thus suitable for use only in applications
16 ** that use SQLite in a single thread. The routines defined
17 ** here are place-holders. Applications can substitute working
18 ** mutex routines at start-time using the
20 ** sqlite3_config(SQLITE_CONFIG_MUTEX,...)
24 ** If compiled with SQLITE_DEBUG, then additional logic is inserted
25 ** that does error checking on mutexes to make sure they are being
28 #include "sqliteInt.h"
30 #ifndef SQLITE_MUTEX_OMIT
34 ** Stub routines for all mutex methods.
36 ** This routines provide no mutual exclusion or error checking.
38 static int noopMutexInit(void){ return SQLITE_OK; }
39 static int noopMutexEnd(void){ return SQLITE_OK; }
40 static sqlite3_mutex *noopMutexAlloc(int id){
42 return (sqlite3_mutex*)8;
44 static void noopMutexFree(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
45 static void noopMutexEnter(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
46 static int noopMutexTry(sqlite3_mutex *p){
50 static void noopMutexLeave(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
52 sqlite3_mutex_methods const *sqlite3NoopMutex(void){
53 static const sqlite3_mutex_methods sMutex = {
68 #endif /* !SQLITE_DEBUG */
72 ** In this implementation, error checking is provided for testing
73 ** and debugging purposes. The mutexes still do not provide any
80 typedef struct sqlite3_debug_mutex {
81 int id; /* The mutex type */
82 int cnt; /* Number of entries without a matching leave */
83 } sqlite3_debug_mutex;
86 ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
87 ** intended for use inside assert() statements.
89 static int debugMutexHeld(sqlite3_mutex *pX){
90 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
91 return p==0 || p->cnt>0;
93 static int debugMutexNotheld(sqlite3_mutex *pX){
94 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
95 return p==0 || p->cnt==0;
99 ** Initialize and deinitialize the mutex subsystem.
101 static int debugMutexInit(void){ return SQLITE_OK; }
102 static int debugMutexEnd(void){ return SQLITE_OK; }
105 ** The sqlite3_mutex_alloc() routine allocates a new
106 ** mutex and returns a pointer to it. If it returns NULL
107 ** that means that a mutex could not be allocated.
109 static sqlite3_mutex *debugMutexAlloc(int id){
110 static sqlite3_debug_mutex aStatic[6];
111 sqlite3_debug_mutex *pNew = 0;
113 case SQLITE_MUTEX_FAST:
114 case SQLITE_MUTEX_RECURSIVE: {
115 pNew = sqlite3Malloc(sizeof(*pNew));
124 assert( id-2 < (int)(sizeof(aStatic)/sizeof(aStatic[0])) );
125 pNew = &aStatic[id-2];
130 return (sqlite3_mutex*)pNew;
134 ** This routine deallocates a previously allocated mutex.
136 static void debugMutexFree(sqlite3_mutex *pX){
137 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
139 assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
144 ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
145 ** to enter a mutex. If another thread is already within the mutex,
146 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
147 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
148 ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
149 ** be entered multiple times by the same thread. In such cases the,
150 ** mutex must be exited an equal number of times before another thread
151 ** can enter. If the same thread tries to enter any other kind of mutex
152 ** more than once, the behavior is undefined.
154 static void debugMutexEnter(sqlite3_mutex *pX){
155 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
156 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
159 static int debugMutexTry(sqlite3_mutex *pX){
160 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
161 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
167 ** The sqlite3_mutex_leave() routine exits a mutex that was
168 ** previously entered by the same thread. The behavior
169 ** is undefined if the mutex is not currently entered or
170 ** is not currently allocated. SQLite will never do either.
172 static void debugMutexLeave(sqlite3_mutex *pX){
173 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
174 assert( debugMutexHeld(pX) );
176 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
179 sqlite3_mutex_methods const *sqlite3NoopMutex(void){
180 static const sqlite3_mutex_methods sMutex = {
195 #endif /* SQLITE_DEBUG */
198 ** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation
199 ** is used regardless of the run-time threadsafety setting.
201 #ifdef SQLITE_MUTEX_NOOP
202 sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
203 return sqlite3NoopMutex();
205 #endif /* SQLITE_MUTEX_NOOP */
206 #endif /* SQLITE_MUTEX_OMIT */