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 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 /* 53 ** Enter a mutex on the given BTree object. 54 ** 55 ** If the object is not sharable, then no mutex is ever required 56 ** and this routine is a no-op. The underlying mutex is non-recursive. 57 ** But we keep a reference count in Btree.wantToLock so the behavior 58 ** of this interface is recursive. 59 ** 60 ** To avoid deadlocks, multiple Btrees are locked in the same order 61 ** by all database connections. The p->pNext is a list of other 62 ** Btrees belonging to the same database connection as the p Btree 63 ** which need to be locked after p. If we cannot get a lock on 64 ** p, then first unlock all of the others on p->pNext, then wait 65 ** for the lock to become available on p, then relock all of the 66 ** subsequent Btrees that desire a lock. 67 */ 68 void sqlite3BtreeEnter(Btree *p){ 69 Btree *pLater; 70 71 /* Some basic sanity checking on the Btree. The list of Btrees 72 ** connected by pNext and pPrev should be in sorted order by 73 ** Btree.pBt value. All elements of the list should belong to 74 ** the same connection. Only shared Btrees are on the list. */ 75 assert( p->pNext==0 || p->pNext->pBt>p->pBt ); 76 assert( p->pPrev==0 || p->pPrev->pBt<p->pBt ); 77 assert( p->pNext==0 || p->pNext->db==p->db ); 78 assert( p->pPrev==0 || p->pPrev->db==p->db ); 79 assert( p->sharable || (p->pNext==0 && p->pPrev==0) ); 80 81 /* Check for locking consistency */ 82 assert( !p->locked || p->wantToLock>0 ); 83 assert( p->sharable || p->wantToLock==0 ); 84 85 /* We should already hold a lock on the database connection */ 86 assert( sqlite3_mutex_held(p->db->mutex) ); 87 88 /* Unless the database is sharable and unlocked, then BtShared.db 89 ** should already be set correctly. */ 90 assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db ); 91 92 if( !p->sharable ) return; 93 p->wantToLock++; 94 if( p->locked ) return; 95 96 /* In most cases, we should be able to acquire the lock we 97 ** want without having to go throught the ascending lock 98 ** procedure that follows. Just be sure not to block. 99 */ 100 if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){ 101 p->pBt->db = p->db; 102 p->locked = 1; 103 return; 104 } 105 106 /* To avoid deadlock, first release all locks with a larger 107 ** BtShared address. Then acquire our lock. Then reacquire 108 ** the other BtShared locks that we used to hold in ascending 109 ** order. 110 */ 111 for(pLater=p->pNext; pLater; pLater=pLater->pNext){ 112 assert( pLater->sharable ); 113 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt ); 114 assert( !pLater->locked || pLater->wantToLock>0 ); 115 if( pLater->locked ){ 116 unlockBtreeMutex(pLater); 117 } 118 } 119 lockBtreeMutex(p); 120 for(pLater=p->pNext; pLater; pLater=pLater->pNext){ 121 if( pLater->wantToLock ){ 122 lockBtreeMutex(pLater); 123 } 124 } 125 } 126 127 /* 128 ** Exit the recursive mutex on a Btree. 129 */ 130 void sqlite3BtreeLeave(Btree *p){ 131 if( p->sharable ){ 132 assert( p->wantToLock>0 ); 133 p->wantToLock--; 134 if( p->wantToLock==0 ){ 135 unlockBtreeMutex(p); 136 } 137 } 138 } 139 140 #ifndef NDEBUG 141 /* 142 ** Return true if the BtShared mutex is held on the btree, or if the 143 ** B-Tree is not marked as sharable. 144 ** 145 ** This routine is used only from within assert() statements. 146 */ 147 int sqlite3BtreeHoldsMutex(Btree *p){ 148 assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 ); 149 assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db ); 150 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) ); 151 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) ); 152 153 return (p->sharable==0 || p->locked); 154 } 155 #endif 156 157 158 #ifndef SQLITE_OMIT_INCRBLOB 159 /* 160 ** Enter and leave a mutex on a Btree given a cursor owned by that 161 ** Btree. These entry points are used by incremental I/O and can be 162 ** omitted if that module is not used. 163 */ 164 void sqlite3BtreeEnterCursor(BtCursor *pCur){ 165 sqlite3BtreeEnter(pCur->pBtree); 166 } 167 void sqlite3BtreeLeaveCursor(BtCursor *pCur){ 168 sqlite3BtreeLeave(pCur->pBtree); 169 } 170 #endif /* SQLITE_OMIT_INCRBLOB */ 171 172 173 /* 174 ** Enter the mutex on every Btree associated with a database 175 ** connection. This is needed (for example) prior to parsing 176 ** a statement since we will be comparing table and column names 177 ** against all schemas and we do not want those schemas being 178 ** reset out from under us. 179 ** 180 ** There is a corresponding leave-all procedures. 181 ** 182 ** Enter the mutexes in accending order by BtShared pointer address 183 ** to avoid the possibility of deadlock when two threads with 184 ** two or more btrees in common both try to lock all their btrees 185 ** at the same instant. 186 */ 187 void sqlite3BtreeEnterAll(sqlite3 *db){ 188 int i; 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 ) sqlite3BtreeEnter(p); 194 } 195 } 196 void sqlite3BtreeLeaveAll(sqlite3 *db){ 197 int i; 198 Btree *p; 199 assert( sqlite3_mutex_held(db->mutex) ); 200 for(i=0; i<db->nDb; i++){ 201 p = db->aDb[i].pBt; 202 if( p ) sqlite3BtreeLeave(p); 203 } 204 } 205 206 #ifndef NDEBUG 207 /* 208 ** Return true if the current thread holds the database connection 209 ** mutex and all required BtShared mutexes. 210 ** 211 ** This routine is used inside assert() statements only. 212 */ 213 int sqlite3BtreeHoldsAllMutexes(sqlite3 *db){ 214 int i; 215 if( !sqlite3_mutex_held(db->mutex) ){ 216 return 0; 217 } 218 for(i=0; i<db->nDb; i++){ 219 Btree *p; 220 p = db->aDb[i].pBt; 221 if( p && p->sharable && 222 (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){ 223 return 0; 224 } 225 } 226 return 1; 227 } 228 #endif /* NDEBUG */ 229 230 #ifndef NDEBUG 231 /* 232 ** Return true if the correct mutexes are held for accessing the 233 ** db->aDb[iDb].pSchema structure. The mutexes required for schema 234 ** access are: 235 ** 236 ** (1) The mutex on db 237 ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt. 238 ** 239 ** If pSchema is not NULL, then iDb is computed from pSchema and 240 ** db using sqlite3SchemaToIndex(). 241 */ 242 int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){ 243 Btree *p; 244 assert( db!=0 ); 245 if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema); 246 assert( iDb>=0 && iDb<db->nDb ); 247 if( !sqlite3_mutex_held(db->mutex) ) return 0; 248 if( iDb==1 ) return 1; 249 p = db->aDb[iDb].pBt; 250 assert( p!=0 ); 251 return p->sharable==0 || p->locked==1; 252 } 253 #endif /* NDEBUG */ 254 255 #else /* SQLITE_THREADSAFE>0 above. SQLITE_THREADSAFE==0 below */ 256 /* 257 ** The following are special cases for mutex enter routines for use 258 ** in single threaded applications that use shared cache. Except for 259 ** these two routines, all mutex operations are no-ops in that case and 260 ** are null #defines in btree.h. 261 ** 262 ** If shared cache is disabled, then all btree mutex routines, including 263 ** the ones below, are no-ops and are null #defines in btree.h. 264 */ 265 266 void sqlite3BtreeEnter(Btree *p){ 267 p->pBt->db = p->db; 268 } 269 void sqlite3BtreeEnterAll(sqlite3 *db){ 270 int i; 271 for(i=0; i<db->nDb; i++){ 272 Btree *p = db->aDb[i].pBt; 273 if( p ){ 274 p->pBt->db = p->db; 275 } 276 } 277 } 278 #endif /* if SQLITE_THREADSAFE */ 279 #endif /* ifndef SQLITE_OMIT_SHARED_CACHE */ 280