/Languages/IronPython/IronPython.SQLite/c#sqlite/btmutex_c.cs
C# | 303 lines | 152 code | 26 blank | 125 comment | 46 complexity | 20fd6f6a839c7892b713241cec9fb956 MD5 | raw file
Possible License(s): CPL-1.0, BSD-3-Clause, ISC, GPL-2.0, MPL-2.0-no-copyleft-exception
- using System.Diagnostics;
- namespace Community.CsharpSqlite
- {
- public partial class Sqlite3
- {
- /*
- ** 2007 August 27
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- **
- ** This file contains code used to implement mutexes on Btree objects.
- ** This code really belongs in btree.c. But btree.c is getting too
- ** big and we want to break it down some. This packaged seemed like
- ** a good breakout.
- *************************************************************************
- ** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
- ** C#-SQLite is an independent reimplementation of the SQLite software library
- **
- ** SQLITE_SOURCE_ID: 2011-05-19 13:26:54 ed1da510a239ea767a01dc332b667119fa3c908e
- **
- *************************************************************************
- */
- //#include "btreeInt.h"
- #if !SQLITE_OMIT_SHARED_CACHE
- #if SQLITE_THREADSAFE
- /*
- ** Obtain the BtShared mutex associated with B-Tree handle p. Also,
- ** set BtShared.db to the database handle associated with p and the
- ** p->locked boolean to true.
- */
- static void lockBtreeMutex(Btree *p){
- assert( p->locked==0 );
- assert( sqlite3_mutex_notheld(p->pBt->mutex) );
- assert( sqlite3_mutex_held(p->db->mutex) );
- sqlite3_mutex_enter(p->pBt->mutex);
- p->pBt->db = p->db;
- p->locked = 1;
- }
- /*
- ** Release the BtShared mutex associated with B-Tree handle p and
- ** clear the p->locked boolean.
- */
- static void unlockBtreeMutex(Btree *p){
- BtShared *pBt = p->pBt;
- assert( p->locked==1 );
- assert( sqlite3_mutex_held(pBt->mutex) );
- assert( sqlite3_mutex_held(p->db->mutex) );
- assert( p->db==pBt->db );
- sqlite3_mutex_leave(pBt->mutex);
- p->locked = 0;
- }
- /*
- ** Enter a mutex on the given BTree object.
- **
- ** If the object is not sharable, then no mutex is ever required
- ** and this routine is a no-op. The underlying mutex is non-recursive.
- ** But we keep a reference count in Btree.wantToLock so the behavior
- ** of this interface is recursive.
- **
- ** To avoid deadlocks, multiple Btrees are locked in the same order
- ** by all database connections. The p->pNext is a list of other
- ** Btrees belonging to the same database connection as the p Btree
- ** which need to be locked after p. If we cannot get a lock on
- ** p, then first unlock all of the others on p->pNext, then wait
- ** for the lock to become available on p, then relock all of the
- ** subsequent Btrees that desire a lock.
- */
- void sqlite3BtreeEnter(Btree *p){
- Btree *pLater;
- /* Some basic sanity checking on the Btree. The list of Btrees
- ** connected by pNext and pPrev should be in sorted order by
- ** Btree.pBt value. All elements of the list should belong to
- ** the same connection. Only shared Btrees are on the list. */
- assert( p->pNext==0 || p->pNext->pBt>p->pBt );
- assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
- assert( p->pNext==0 || p->pNext->db==p->db );
- assert( p->pPrev==0 || p->pPrev->db==p->db );
- assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
- /* Check for locking consistency */
- assert( !p->locked || p->wantToLock>0 );
- assert( p->sharable || p->wantToLock==0 );
- /* We should already hold a lock on the database connection */
- assert( sqlite3_mutex_held(p->db->mutex) );
- /* Unless the database is sharable and unlocked, then BtShared.db
- ** should already be set correctly. */
- assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
- if( !p->sharable ) return;
- p->wantToLock++;
- if( p->locked ) return;
- /* In most cases, we should be able to acquire the lock we
- ** want without having to go throught the ascending lock
- ** procedure that follows. Just be sure not to block.
- */
- if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
- p->pBt->db = p->db;
- p->locked = 1;
- return;
- }
- /* To avoid deadlock, first release all locks with a larger
- ** BtShared address. Then acquire our lock. Then reacquire
- ** the other BtShared locks that we used to hold in ascending
- ** order.
- */
- for(pLater=p->pNext; pLater; pLater=pLater->pNext){
- assert( pLater->sharable );
- assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
- assert( !pLater->locked || pLater->wantToLock>0 );
- if( pLater->locked ){
- unlockBtreeMutex(pLater);
- }
- }
- lockBtreeMutex(p);
- for(pLater=p->pNext; pLater; pLater=pLater->pNext){
- if( pLater->wantToLock ){
- lockBtreeMutex(pLater);
- }
- }
- }
- /*
- ** Exit the recursive mutex on a Btree.
- */
- void sqlite3BtreeLeave(Btree *p){
- if( p->sharable ){
- assert( p->wantToLock>0 );
- p->wantToLock--;
- if( p->wantToLock==0 ){
- unlockBtreeMutex(p);
- }
- }
- }
- #if NDEBUG
- /*
- ** Return true if the BtShared mutex is held on the btree, or if the
- ** B-Tree is not marked as sharable.
- **
- ** This routine is used only from within assert() statements.
- */
- int sqlite3BtreeHoldsMutex(Btree *p){
- assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 );
- assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
- assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
- assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) );
- return (p->sharable==0 || p->locked);
- }
- #endif
- #if SQLITE_OMIT_INCRBLOB
- /*
- ** Enter and leave a mutex on a Btree given a cursor owned by that
- ** Btree. These entry points are used by incremental I/O and can be
- ** omitted if that module is not used.
- */
- void sqlite3BtreeEnterCursor(BtCursor *pCur){
- sqlite3BtreeEnter(pCur->pBtree);
- }
- void sqlite3BtreeLeaveCursor(BtCursor *pCur){
- sqlite3BtreeLeave(pCur->pBtree);
- }
- #endif //* SQLITE_OMIT_INCRBLOB */
- /*
- ** Enter the mutex on every Btree associated with a database
- ** connection. This is needed (for example) prior to parsing
- ** a statement since we will be comparing table and column names
- ** against all schemas and we do not want those schemas being
- ** reset out from under us.
- **
- ** There is a corresponding leave-all procedures.
- **
- ** Enter the mutexes in accending order by BtShared pointer address
- ** to avoid the possibility of deadlock when two threads with
- ** two or more btrees in common both try to lock all their btrees
- ** at the same instant.
- */
- void sqlite3BtreeEnterAll(sqlite3 db){
- int i;
- Btree *p;
- assert( sqlite3_mutex_held(db->mutex) );
- for(i=0; i<db->nDb; i++){
- p = db->aDb[i].pBt;
- if( p ) sqlite3BtreeEnter(p);
- }
- }
- void sqlite3BtreeLeaveAll(sqlite3 db){
- int i;
- Btree *p;
- assert( sqlite3_mutex_held(db->mutex) );
- for(i=0; i<db->nDb; i++){
- p = db->aDb[i].pBt;
- if( p ) sqlite3BtreeLeave(p);
- }
- }
- /*
- ** Return true if a particular Btree requires a lock. Return FALSE if
- ** no lock is ever required since it is not sharable.
- */
- int sqlite3BtreeSharable(Btree *p){
- return p->sharable;
- }
- #if NDEBUG
- /*
- ** Return true if the current thread holds the database connection
- ** mutex and all required BtShared mutexes.
- **
- ** This routine is used inside assert() statements only.
- */
- int sqlite3BtreeHoldsAllMutexes(sqlite3 db){
- int i;
- if( !sqlite3_mutex_held(db->mutex) ){
- return 0;
- }
- for(i=0; i<db->nDb; i++){
- Btree *p;
- p = db->aDb[i].pBt;
- if( p && p->sharable &&
- (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){
- return 0;
- }
- }
- return 1;
- }
- #endif //* NDEBUG */
- #if NDEBUG
- /*
- ** Return true if the correct mutexes are held for accessing the
- ** db->aDb[iDb].pSchema structure. The mutexes required for schema
- ** access are:
- **
- ** (1) The mutex on db
- ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
- **
- ** If pSchema is not NULL, then iDb is computed from pSchema and
- ** db using sqlite3SchemaToIndex().
- */
- int sqlite3SchemaMutexHeld(sqlite3 db, int iDb, Schema *pSchema){
- Btree *p;
- assert( db!=0 );
- if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema);
- assert( iDb>=0 && iDb<db->nDb );
- if( !sqlite3_mutex_held(db->mutex) ) return 0;
- if( iDb==1 ) return 1;
- p = db->aDb[iDb].pBt;
- assert( p!=0 );
- return p->sharable==0 || p->locked==1;
- }
- #endif //* NDEBUG */
- #else //* SQLITE_THREADSAFE>0 above. SQLITE_THREADSAFE==0 below */
- /*
- ** The following are special cases for mutex enter routines for use
- ** in single threaded applications that use shared cache. Except for
- ** these two routines, all mutex operations are no-ops in that case and
- ** are null #defines in btree.h.
- **
- ** If shared cache is disabled, then all btree mutex routines, including
- ** the ones below, are no-ops and are null #defines in btree.h.
- */
- void sqlite3BtreeEnter(Btree *p){
- p->pBt->db = p->db;
- }
- void sqlite3BtreeEnterAll(sqlite3 db){
- int i;
- for(i=0; i<db->nDb; i++){
- Btree *p = db->aDb[i].pBt;
- if( p ){
- p->pBt->db = p->db;
- }
- }
- }
- #endif //* if SQLITE_THREADSAFE */
- #endif //* ifndef SQLITE_OMIT_SHARED_CACHE */
- }
- }