src/btmutex.c

   1 /*
   2 ** 2007 August 27
   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 **
  13 ** This file contains code used to implement mutexes on Btree objects.
  14 ** This code really belongs in btree.c.  But btree.c is getting too
  15 ** big and we want to break it down some.  This packaged seemed like
  16 ** a good breakout.
  17 */
  18 #include "btreeInt.h"
  19 #ifndef SQLITE_OMIT_SHARED_CACHE
  20 #if SQLITE_THREADSAFE
  21
  22 /*
  23 ** Obtain the BtShared mutex associated with B-Tree handle p. Also,
  24 ** set BtShared.db to the database handle associated with p and the
  25 ** p->locked boolean to true.
  26 */
  27 static void lockBtreeMutex(Btree *p){
  28   assert( p->locked==0 );
  29   assert( sqlite3_mutex_notheld(p->pBt->mutex) );
  30   assert( sqlite3_mutex_held(p->db->mutex) );
  31
  32   sqlite3_mutex_enter(p->pBt->mutex);
  33   p->pBt->db = p->db;
  34   p->locked = 1;
  35 }
  36
  37 /*
  38 ** Release the BtShared mutex associated with B-Tree handle p and
  39 ** clear the p->locked boolean.
  40 */
  41 static void SQLITE_NOINLINE unlockBtreeMutex(Btree *p){
  42   BtShared *pBt = p->pBt;
  43   assert( p->locked==1 );
  44   assert( sqlite3_mutex_held(pBt->mutex) );
  45   assert( sqlite3_mutex_held(p->db->mutex) );
  46   assert( p->db==pBt->db );
  47
  48   sqlite3_mutex_leave(pBt->mutex);
  49   p->locked = 0;
  50 }
  51
  52 /* Forward reference */
  53 static void SQLITE_NOINLINE btreeLockCarefully(Btree *p);
  54
  55 /*
  56 ** Enter a mutex on the given BTree object.
  57 **
  58 ** If the object is not sharable, then no mutex is ever required
  59 ** and this routine is a no-op.  The underlying mutex is non-recursive.
  60 ** But we keep a reference count in Btree.wantToLock so the behavior
  61 ** of this interface is recursive.
  62 **
  63 ** To avoid deadlocks, multiple Btrees are locked in the same order
  64 ** by all database connections.  The p->pNext is a list of other
  65 ** Btrees belonging to the same database connection as the p Btree
  66 ** which need to be locked after p.  If we cannot get a lock on
  67 ** p, then first unlock all of the others on p->pNext, then wait
  68 ** for the lock to become available on p, then relock all of the
  69 ** subsequent Btrees that desire a lock.
  70 */
  71 void sqlite3BtreeEnter(Btree *p){
  72   /* Some basic sanity checking on the Btree.  The list of Btrees
  73   ** connected by pNext and pPrev should be in sorted order by
  74   ** Btree.pBt value. All elements of the list should belong to
  75   ** the same connection. Only shared Btrees are on the list. */
  76   assert( p->pNext==0 || p->pNext->pBt>p->pBt );
  77   assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
  78   assert( p->pNext==0 || p->pNext->db==p->db );
  79   assert( p->pPrev==0 || p->pPrev->db==p->db );
  80   assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
  81
  82   /* Check for locking consistency */
  83   assert( !p->locked || p->wantToLock>0 );
  84   assert( p->sharable || p->wantToLock==0 );
  85
  86   /* We should already hold a lock on the database connection */
  87   assert( sqlite3_mutex_held(p->db->mutex) );
  88
  89   /* Unless the database is sharable and unlocked, then BtShared.db
  90   ** should already be set correctly. */
  91   assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
  92
  93   if( !p->sharable ) return;
  94   p->wantToLock++;
  95   if( p->locked ) return;
  96   btreeLockCarefully(p);
  97 }
  98
  99 /* This is a helper function for sqlite3BtreeLock(). By moving
 100 ** complex, but seldom used logic, out of sqlite3BtreeLock() and
 101 ** into this routine, we avoid unnecessary stack pointer changes
 102 ** and thus help the sqlite3BtreeLock() routine to run much faster
 103 ** in the common case.
 104 */
 105 static void SQLITE_NOINLINE btreeLockCarefully(Btree *p){
 106   Btree *pLater;
 107
 108   /* In most cases, we should be able to acquire the lock we
 109   ** want without having to go through the ascending lock
 110   ** procedure that follows.  Just be sure not to block.
 111   */
 112   if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
 113     p->pBt->db = p->db;
 114     p->locked = 1;
 115     return;
 116   }
 117
 118   /* To avoid deadlock, first release all locks with a larger
 119   ** BtShared address.  Then acquire our lock.  Then reacquire
 120   ** the other BtShared locks that we used to hold in ascending
 121   ** order.
 122   */
 123   for(pLater=p->pNext; pLater; pLater=pLater->pNext){
 124     assert( pLater->sharable );
 125     assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
 126     assert( !pLater->locked || pLater->wantToLock>0 );
 127     if( pLater->locked ){
 128       unlockBtreeMutex(pLater);
 129     }
 130   }
 131   lockBtreeMutex(p);
 132   for(pLater=p->pNext; pLater; pLater=pLater->pNext){
 133     if( pLater->wantToLock ){
 134       lockBtreeMutex(pLater);
 135     }
 136   }
 137 }
 138
 139
 140 /*
 141 ** Exit the recursive mutex on a Btree.
 142 */
 143 void sqlite3BtreeLeave(Btree *p){
 144   assert( sqlite3_mutex_held(p->db->mutex) );
 145   if( p->sharable ){
 146     assert( p->wantToLock>0 );
 147     p->wantToLock--;
 148     if( p->wantToLock==0 ){
 149       unlockBtreeMutex(p);
 150     }
 151   }
 152 }
 153
 154 #ifndef NDEBUG
 155 /*
 156 ** Return true if the BtShared mutex is held on the btree, or if the
 157 ** B-Tree is not marked as sharable.
 158 **
 159 ** This routine is used only from within assert() statements.
 160 */
 161 int sqlite3BtreeHoldsMutex(Btree *p){
 162   assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 );
 163   assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
 164   assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
 165   assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) );
 166
 167   return (p->sharable==0 || p->locked);
 168 }
 169 #endif
 170
 171
 172 /*
 173 ** Enter the mutex on every Btree associated with a database
 174 ** connection.  This is needed (for example) prior to parsing
 175 ** a statement since we will be comparing table and column names
 176 ** against all schemas and we do not want those schemas being
 177 ** reset out from under us.
 178 **
 179 ** There is a corresponding leave-all procedures.
 180 **
 181 ** Enter the mutexes in ascending order by BtShared pointer address
 182 ** to avoid the possibility of deadlock when two threads with
 183 ** two or more btrees in common both try to lock all their btrees
 184 ** at the same instant.
 185 */
 186 static void SQLITE_NOINLINE btreeEnterAll(sqlite3 *db){
 187   int i;
 188   int skipOk = 1;
 189   Btree *p;
 190   assert( sqlite3_mutex_held(db->mutex) );
 191   for(i=0; i<db->nDb; i++){
 192     p = db->aDb[i].pBt;
 193     if( p && p->sharable ){
 194       sqlite3BtreeEnter(p);
 195       skipOk = 0;
 196     }
 197   }
 198   db->noSharedCache = skipOk;
 199 }
 200 void sqlite3BtreeEnterAll(sqlite3 *db){
 201   if( db->noSharedCache==0 ) btreeEnterAll(db);
 202 }
 203 static void SQLITE_NOINLINE btreeLeaveAll(sqlite3 *db){
 204   int i;
 205   Btree *p;
 206   assert( sqlite3_mutex_held(db->mutex) );
 207   for(i=0; i<db->nDb; i++){
 208     p = db->aDb[i].pBt;
 209     if( p ) sqlite3BtreeLeave(p);
 210   }
 211 }
 212 void sqlite3BtreeLeaveAll(sqlite3 *db){
 213   if( db->noSharedCache==0 ) btreeLeaveAll(db);
 214 }
 215
 216 #ifndef NDEBUG
 217 /*
 218 ** Return true if the current thread holds the database connection
 219 ** mutex and all required BtShared mutexes.
 220 **
 221 ** This routine is used inside assert() statements only.
 222 */
 223 int sqlite3BtreeHoldsAllMutexes(sqlite3 *db){
 224   int i;
 225   if( !sqlite3_mutex_held(db->mutex) ){
 226     return 0;
 227   }
 228   for(i=0; i<db->nDb; i++){
 229     Btree *p;
 230     p = db->aDb[i].pBt;
 231     if( p && p->sharable &&
 232          (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){
 233       return 0;
 234     }
 235   }
 236   return 1;
 237 }
 238 #endif /* NDEBUG */
 239
 240 #ifndef NDEBUG
 241 /*
 242 ** Return true if the correct mutexes are held for accessing the
 243 ** db->aDb[iDb].pSchema structure.  The mutexes required for schema
 244 ** access are:
 245 **
 246 **   (1) The mutex on db
 247 **   (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
 248 **
 249 ** If pSchema is not NULL, then iDb is computed from pSchema and
 250 ** db using sqlite3SchemaToIndex().
 251 */
 252 int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){
 253   Btree *p;
 254   assert( db!=0 );
 255   if( db->pVfs==0 && db->nDb==0 ) return 1;
 256   if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema);
 257   assert( iDb>=0 && iDb<db->nDb );
 258   if( !sqlite3_mutex_held(db->mutex) ) return 0;
 259   if( iDb==1 ) return 1;
 260   p = db->aDb[iDb].pBt;
 261   assert( p!=0 );
 262   return p->sharable==0 || p->locked==1;
 263 }
 264 #endif /* NDEBUG */
 265
 266 #else /* SQLITE_THREADSAFE>0 above.  SQLITE_THREADSAFE==0 below */
 267 /*
 268 ** The following are special cases for mutex enter routines for use
 269 ** in single threaded applications that use shared cache.  Except for
 270 ** these two routines, all mutex operations are no-ops in that case and
 271 ** are null #defines in btree.h.
 272 **
 273 ** If shared cache is disabled, then all btree mutex routines, including
 274 ** the ones below, are no-ops and are null #defines in btree.h.
 275 */
 276
 277 void sqlite3BtreeEnter(Btree *p){
 278   p->pBt->db = p->db;
 279 }
 280 void sqlite3BtreeEnterAll(sqlite3 *db){
 281   int i;
 282   for(i=0; i<db->nDb; i++){
 283     Btree *p = db->aDb[i].pBt;
 284     if( p ){
 285       p->pBt->db = p->db;
 286     }
 287   }
 288 }
 289 #endif /* if SQLITE_THREADSAFE */
 290
 291 #ifndef SQLITE_OMIT_INCRBLOB
 292 /*
 293 ** Enter a mutex on a Btree given a cursor owned by that Btree.
 294 **
 295 ** These entry points are used by incremental I/O only. Enter() is required
 296 ** any time OMIT_SHARED_CACHE is not defined, regardless of whether or not
 297 ** the build is threadsafe. Leave() is only required by threadsafe builds.
 298 */
 299 void sqlite3BtreeEnterCursor(BtCursor *pCur){
 300   sqlite3BtreeEnter(pCur->pBtree);
 301 }
 302 # if SQLITE_THREADSAFE
 303 void sqlite3BtreeLeaveCursor(BtCursor *pCur){
 304   sqlite3BtreeLeave(pCur->pBtree);
 305 }
 306 # endif
 307 #endif /* ifndef SQLITE_OMIT_INCRBLOB */
 308
 309 #endif /* ifndef SQLITE_OMIT_SHARED_CACHE */