src/mutex.c

   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.
  13 **
  14 ** This file contains code that is common across all mutex implementations.
  15 */
  16 #include "sqliteInt.h"
  17
  18 #if defined(SQLITE_DEBUG) && !defined(SQLITE_MUTEX_OMIT)
  19 /*
  20 ** For debugging purposes, record when the mutex subsystem is initialized
  21 ** and uninitialized so that we can assert() if there is an attempt to
  22 ** allocate a mutex while the system is uninitialized.
  23 */
  24 static SQLITE_WSD int mutexIsInit = 0;
  25 #endif /* SQLITE_DEBUG && !defined(SQLITE_MUTEX_OMIT) */
  26
  27
  28 #ifndef SQLITE_MUTEX_OMIT
  29 /*
  30 ** Initialize the mutex system.
  31 */
  32 int sqlite3MutexInit(void){
  33   int rc = SQLITE_OK;
  34   if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){
  35     /* If the xMutexAlloc method has not been set, then the user did not
  36     ** install a mutex implementation via sqlite3_config() prior to
  37     ** sqlite3_initialize() being called. This block copies pointers to
  38     ** the default implementation into the sqlite3GlobalConfig structure.
  39     */
  40     sqlite3_mutex_methods const *pFrom;
  41     sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;
  42
  43     if( sqlite3GlobalConfig.bCoreMutex ){
  44       pFrom = sqlite3DefaultMutex();
  45     }else{
  46       pFrom = sqlite3NoopMutex();
  47     }
  48     pTo->xMutexInit = pFrom->xMutexInit;
  49     pTo->xMutexEnd = pFrom->xMutexEnd;
  50     pTo->xMutexFree = pFrom->xMutexFree;
  51     pTo->xMutexEnter = pFrom->xMutexEnter;
  52     pTo->xMutexTry = pFrom->xMutexTry;
  53     pTo->xMutexLeave = pFrom->xMutexLeave;
  54     pTo->xMutexHeld = pFrom->xMutexHeld;
  55     pTo->xMutexNotheld = pFrom->xMutexNotheld;
  56     sqlite3MemoryBarrier();
  57     pTo->xMutexAlloc = pFrom->xMutexAlloc;
  58   }
  59   assert( sqlite3GlobalConfig.mutex.xMutexInit );
  60   rc = sqlite3GlobalConfig.mutex.xMutexInit();
  61
  62 #ifdef SQLITE_DEBUG
  63   GLOBAL(int, mutexIsInit) = 1;
  64 #endif
  65
  66   return rc;
  67 }
  68
  69 /*
  70 ** Shutdown the mutex system. This call frees resources allocated by
  71 ** sqlite3MutexInit().
  72 */
  73 int sqlite3MutexEnd(void){
  74   int rc = SQLITE_OK;
  75   if( sqlite3GlobalConfig.mutex.xMutexEnd ){
  76     rc = sqlite3GlobalConfig.mutex.xMutexEnd();
  77   }
  78
  79 #ifdef SQLITE_DEBUG
  80   GLOBAL(int, mutexIsInit) = 0;
  81 #endif
  82
  83   return rc;
  84 }
  85
  86 /*
  87 ** Retrieve a pointer to a static mutex or allocate a new dynamic one.
  88 */
  89 sqlite3_mutex *sqlite3_mutex_alloc(int id){
  90 #ifndef SQLITE_OMIT_AUTOINIT
  91   if( id<=SQLITE_MUTEX_RECURSIVE && sqlite3_initialize() ) return 0;
  92   if( id>SQLITE_MUTEX_RECURSIVE && sqlite3MutexInit() ) return 0;
  93 #endif
  94   assert( sqlite3GlobalConfig.mutex.xMutexAlloc );
  95   return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
  96 }
  97
  98 sqlite3_mutex *sqlite3MutexAlloc(int id){
  99   if( !sqlite3GlobalConfig.bCoreMutex ){
 100     return 0;
 101   }
 102   assert( GLOBAL(int, mutexIsInit) );
 103   assert( sqlite3GlobalConfig.mutex.xMutexAlloc );
 104   return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
 105 }
 106
 107 /*
 108 ** Free a dynamic mutex.
 109 */
 110 void sqlite3_mutex_free(sqlite3_mutex *p){
 111   if( p ){
 112     assert( sqlite3GlobalConfig.mutex.xMutexFree );
 113     sqlite3GlobalConfig.mutex.xMutexFree(p);
 114   }
 115 }
 116
 117 /*
 118 ** Obtain the mutex p. If some other thread already has the mutex, block
 119 ** until it can be obtained.
 120 */
 121 void sqlite3_mutex_enter(sqlite3_mutex *p){
 122   if( p ){
 123     assert( sqlite3GlobalConfig.mutex.xMutexEnter );
 124     sqlite3GlobalConfig.mutex.xMutexEnter(p);
 125   }
 126 }
 127
 128 /*
 129 ** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
 130 ** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY.
 131 */
 132 int sqlite3_mutex_try(sqlite3_mutex *p){
 133   int rc = SQLITE_OK;
 134   if( p ){
 135     assert( sqlite3GlobalConfig.mutex.xMutexTry );
 136     return sqlite3GlobalConfig.mutex.xMutexTry(p);
 137   }
 138   return rc;
 139 }
 140
 141 /*
 142 ** The sqlite3_mutex_leave() routine exits a mutex that was previously
 143 ** entered by the same thread.  The behavior is undefined if the mutex
 144 ** is not currently entered. If a NULL pointer is passed as an argument
 145 ** this function is a no-op.
 146 */
 147 void sqlite3_mutex_leave(sqlite3_mutex *p){
 148   if( p ){
 149     assert( sqlite3GlobalConfig.mutex.xMutexLeave );
 150     sqlite3GlobalConfig.mutex.xMutexLeave(p);
 151   }
 152 }
 153
 154 #ifndef NDEBUG
 155 /*
 156 ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
 157 ** intended for use inside assert() statements.
 158 */
 159 int sqlite3_mutex_held(sqlite3_mutex *p){
 160   assert( p==0 || sqlite3GlobalConfig.mutex.xMutexHeld );
 161   return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p);
 162 }
 163 int sqlite3_mutex_notheld(sqlite3_mutex *p){
 164   assert( p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld );
 165   return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p);
 166 }
 167 #endif
 168
 169 #endif /* !defined(SQLITE_MUTEX_OMIT) */