Annotation of embedaddon/sqlite3/src/btmutex.c, revision 1.1
1.1 ! misho 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: /*
! 207: ** Return true if a particular Btree requires a lock. Return FALSE if
! 208: ** no lock is ever required since it is not sharable.
! 209: */
! 210: int sqlite3BtreeSharable(Btree *p){
! 211: return p->sharable;
! 212: }
! 213:
! 214: #ifndef NDEBUG
! 215: /*
! 216: ** Return true if the current thread holds the database connection
! 217: ** mutex and all required BtShared mutexes.
! 218: **
! 219: ** This routine is used inside assert() statements only.
! 220: */
! 221: int sqlite3BtreeHoldsAllMutexes(sqlite3 *db){
! 222: int i;
! 223: if( !sqlite3_mutex_held(db->mutex) ){
! 224: return 0;
! 225: }
! 226: for(i=0; i<db->nDb; i++){
! 227: Btree *p;
! 228: p = db->aDb[i].pBt;
! 229: if( p && p->sharable &&
! 230: (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){
! 231: return 0;
! 232: }
! 233: }
! 234: return 1;
! 235: }
! 236: #endif /* NDEBUG */
! 237:
! 238: #ifndef NDEBUG
! 239: /*
! 240: ** Return true if the correct mutexes are held for accessing the
! 241: ** db->aDb[iDb].pSchema structure. The mutexes required for schema
! 242: ** access are:
! 243: **
! 244: ** (1) The mutex on db
! 245: ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
! 246: **
! 247: ** If pSchema is not NULL, then iDb is computed from pSchema and
! 248: ** db using sqlite3SchemaToIndex().
! 249: */
! 250: int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){
! 251: Btree *p;
! 252: assert( db!=0 );
! 253: if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema);
! 254: assert( iDb>=0 && iDb<db->nDb );
! 255: if( !sqlite3_mutex_held(db->mutex) ) return 0;
! 256: if( iDb==1 ) return 1;
! 257: p = db->aDb[iDb].pBt;
! 258: assert( p!=0 );
! 259: return p->sharable==0 || p->locked==1;
! 260: }
! 261: #endif /* NDEBUG */
! 262:
! 263: #else /* SQLITE_THREADSAFE>0 above. SQLITE_THREADSAFE==0 below */
! 264: /*
! 265: ** The following are special cases for mutex enter routines for use
! 266: ** in single threaded applications that use shared cache. Except for
! 267: ** these two routines, all mutex operations are no-ops in that case and
! 268: ** are null #defines in btree.h.
! 269: **
! 270: ** If shared cache is disabled, then all btree mutex routines, including
! 271: ** the ones below, are no-ops and are null #defines in btree.h.
! 272: */
! 273:
! 274: void sqlite3BtreeEnter(Btree *p){
! 275: p->pBt->db = p->db;
! 276: }
! 277: void sqlite3BtreeEnterAll(sqlite3 *db){
! 278: int i;
! 279: for(i=0; i<db->nDb; i++){
! 280: Btree *p = db->aDb[i].pBt;
! 281: if( p ){
! 282: p->pBt->db = p->db;
! 283: }
! 284: }
! 285: }
! 286: #endif /* if SQLITE_THREADSAFE */
! 287: #endif /* ifndef SQLITE_OMIT_SHARED_CACHE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to btmutex.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src