diff --git a/sql/src/fdbcnfig.cpp b/sql/src/fdbcnfig.cpp index cea2344..e2be908 100644 --- a/sql/src/fdbcnfig.cpp +++ b/sql/src/fdbcnfig.cpp @@ -64,8 +64,8 @@ RCODE F_Db::setRflKeepFilesFlag( if (!(m_uiFlags & (FDB_HAS_FILE_LOCK | FDB_FILE_LOCK_SHARED))) { - if (RC_BAD( rc = dbLock( SFLM_LOCK_EXCLUSIVE, 0, - SFLM_NO_TIMEOUT))) + if (RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, + FLM_NO_TIMEOUT))) { goto Exit; } @@ -88,7 +88,7 @@ RCODE F_Db::setRflKeepFilesFlag( // go to a new RFL file so that the new RFL file gets new // serial numbers and a new keep or no-keep flag. - if (RC_BAD( rc = doCheckpoint( SFLM_NO_TIMEOUT))) + if (RC_BAD( rc = doCheckpoint( FLM_NO_TIMEOUT))) { goto Exit; } @@ -175,8 +175,8 @@ RCODE F_Db::setRflDir( if (!(m_uiFlags & (FDB_HAS_FILE_LOCK | FDB_FILE_LOCK_SHARED))) { - if( RC_BAD( rc = dbLock( SFLM_LOCK_EXCLUSIVE, 0, - SFLM_NO_TIMEOUT))) + if( RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, + FLM_NO_TIMEOUT))) { goto Exit; } @@ -192,7 +192,7 @@ RCODE F_Db::setRflDir( // ensures that no more transactions will be logged to the current // RFL file. - if (RC_BAD( rc = doCheckpoint( SFLM_NO_TIMEOUT))) + if (RC_BAD( rc = doCheckpoint( FLM_NO_TIMEOUT))) { goto Exit; } @@ -1273,7 +1273,7 @@ RCODE F_Db::getLockWaiters( if (m_pDatabase->m_pDatabaseLockObj) { - rc = m_pDatabase->m_pDatabaseLockObj->GetLockInfo( pLockInfo); + rc = m_pDatabase->m_pDatabaseLockObj->getLockInfo( pLockInfo); } else { diff --git a/sql/src/fdbcopy.cpp b/sql/src/fdbcopy.cpp index db2448f..82888ff 100644 --- a/sql/src/fdbcopy.cpp +++ b/sql/src/fdbcopy.cpp @@ -99,7 +99,7 @@ RCODE F_DbSystem::dbCopy( // threads have the opportunity to get in and update the // database. - if (RC_BAD( rc = pDb->dbLock( SFLM_LOCK_EXCLUSIVE, 0, SFLM_NO_TIMEOUT))) + if (RC_BAD( rc = pDb->dbLock( FLM_LOCK_EXCLUSIVE, 0, FLM_NO_TIMEOUT))) { goto Exit; } @@ -107,7 +107,7 @@ RCODE F_DbSystem::dbCopy( // Force a checkpoint - if (RC_BAD( rc = pDb->doCheckpoint( SFLM_NO_TIMEOUT))) + if (RC_BAD( rc = pDb->doCheckpoint( FLM_NO_TIMEOUT))) { goto Exit; } @@ -164,11 +164,11 @@ RCODE F_DbSystem::copyDb( IF_DirHdl * pDirHdl = NULL; FLMBOOL bDatabaseLocked = FALSE; FLMBOOL bWriteLocked = FALSE; - ServerLockObject * pWriteLockObj = NULL; - ServerLockObject * pDatabaseLockObj = NULL; + IF_LockObject * pWriteLockObj = NULL; + IF_LockObject * pDatabaseLockObj = NULL; COPIED_NAME * pCopiedList = NULL; FLMBOOL bUsedDatabase = FALSE; - eDbLockType eCurrLockType; + eLockType eCurrLockType; FLMUINT uiThreadId; FLMUINT uiNumExclQueued; FLMUINT uiNumSharedQueued; @@ -271,19 +271,19 @@ retry: // Lock the destination file object and transaction // object, if not already locked. - pDatabase->m_pDatabaseLockObj->GetLockInfo( (FLMINT)0, + pDatabase->m_pDatabaseLockObj->getLockInfo( (FLMINT)0, &eCurrLockType, &uiThreadId, &uiNumExclQueued, &uiNumSharedQueued, &uiPriorityCount); - if (eCurrLockType != SFLM_LOCK_EXCLUSIVE || + if (eCurrLockType != FLM_LOCK_EXCLUSIVE || uiThreadId != f_threadId()) { pDatabaseLockObj = pDatabase->m_pDatabaseLockObj; pDatabaseLockObj->AddRef(); - if (RC_BAD( rc = pDatabaseLockObj->Lock( - NULL, hWaitSem, TRUE, FALSE, TRUE, 15, 0))) + if (RC_BAD( rc = pDatabaseLockObj->lock( + hWaitSem, TRUE, FLM_NO_TIMEOUT, 0))) { goto Exit; } @@ -292,12 +292,12 @@ retry: // Lock the write object, if not already locked - pDatabase->m_pWriteLockObj->GetLockInfo( (FLMINT)0, + pDatabase->m_pWriteLockObj->getLockInfo( (FLMINT)0, &eCurrLockType, &uiThreadId, &uiNumExclQueued, &uiNumSharedQueued, &uiPriorityCount); - if (eCurrLockType != SFLM_LOCK_EXCLUSIVE || + if (eCurrLockType != FLM_LOCK_EXCLUSIVE || uiThreadId != (FLMUINT)f_threadId()) { pWriteLockObj = pDatabase->m_pWriteLockObj; @@ -306,7 +306,7 @@ retry: // Only contention here is with the checkpoint thread - wait // forever until the checkpoint thread gives it up. - if (RC_BAD( rc = pDatabase->dbWriteLock( hWaitSem))) + if (RC_BAD( rc = pDatabase->dbWriteLock( hWaitSem, NULL, FLM_NO_TIMEOUT))) { goto Exit; } @@ -616,7 +616,7 @@ Exit: { RCODE rc3; - if (RC_BAD( rc3 = pDatabaseLockObj->Unlock( TRUE, NULL))) + if (RC_BAD( rc3 = pDatabaseLockObj->unlock())) { if (RC_OK( rc)) rc = rc3; @@ -626,13 +626,13 @@ Exit: if (pWriteLockObj) { - pWriteLockObj->Release( FALSE); + pWriteLockObj->Release(); pWriteLockObj = NULL; } if (pDatabaseLockObj) { - pDatabaseLockObj->Release( FALSE); + pDatabaseLockObj->Release(); pDatabaseLockObj = NULL; } diff --git a/sql/src/flaimsql.h b/sql/src/flaimsql.h index cff86e4..bbdd2f7 100644 --- a/sql/src/flaimsql.h +++ b/sql/src/flaimsql.h @@ -243,23 +243,11 @@ typedef enum SFLM_UPDATE_TRANS ///< 2 = Update transaction } eDbTransType; -/// Database lock types. -typedef enum -{ - SFLM_LOCK_NONE = 0, - SFLM_LOCK_EXCLUSIVE, ///< 1 = Exclusive lock. - SFLM_LOCK_SHARED ///< 2 = Shared lock. -} eDbLockType; - // Transaction flags #define SFLM_DONT_KILL_TRANS 0x1 #define SFLM_DONT_POISON_CACHE 0x2 -// Defines used for uiMaxLockWait parameter - -#define SFLM_NO_TIMEOUT 0xFF - /// Backup types. typedef enum { @@ -586,13 +574,6 @@ typedef struct SFLM_CACHE_USAGE RowCache; ///< Information about row cache usage. } SFLM_CACHE_INFO; -/// Structure used in gathering statistics to hold an operation count and an elapsed time. -typedef struct -{ - FLMUINT64 ui64Count; ///< Number of times operation was performed - FLMUINT64 ui64ElapMilli; ///< Total elapsed time (milliseconds) for the operations. -} SFLM_COUNT_TIME_STAT; - /// Structure used in gathering statistics to hold a operation count, a byte count, and an elapsed time. This /// is typically used for I/O operations where it is useful to know the number of bytes that were read or /// written by the operation. @@ -607,17 +588,17 @@ typedef struct /// Statistics for read transactions. typedef struct { - SFLM_COUNT_TIME_STAT CommittedTrans; ///< Statistics for read transactions committed. - SFLM_COUNT_TIME_STAT AbortedTrans; ///< Statistics for read transactions aborted. + F_COUNT_TIME_STAT CommittedTrans; ///< Statistics for read transactions committed. + F_COUNT_TIME_STAT AbortedTrans; ///< Statistics for read transactions aborted. } SFLM_RTRANS_STATS; /// Statistics for update transactions. typedef struct { - SFLM_COUNT_TIME_STAT CommittedTrans; ///< Statistics for update transactions committed. - SFLM_COUNT_TIME_STAT GroupCompletes; ///< Statistics for number of times multiple transactions were committed together. - FLMUINT64 ui64GroupFinished;///< Total update transactions that were committed in a group. - SFLM_COUNT_TIME_STAT AbortedTrans; ///< Statistics for update transactions aborted. + F_COUNT_TIME_STAT CommittedTrans; ///< Statistics for update transactions committed. + F_COUNT_TIME_STAT GroupCompletes; ///< Statistics for number of times multiple transactions were committed together. + FLMUINT64 ui64GroupFinished;///< Total update transactions that were committed in a group. + F_COUNT_TIME_STAT AbortedTrans; ///< Statistics for update transactions aborted. } SFLM_UTRANS_STATS; /// Statistics for block reads and writes. @@ -680,17 +661,15 @@ typedef struct // Lock statistics - SFLM_COUNT_TIME_STAT NoLocks; ///< Statistics on times when nobody was holding a lock on the database. - SFLM_COUNT_TIME_STAT WaitingForLock; ///< Statistics on times threads were waiting to obtain a database lock. - SFLM_COUNT_TIME_STAT HeldLock; ///< Statistics on times when a thread was holding a lock on the database. + F_LOCK_STATS LockStats; ///< Lock statistics. // Update statistics - SFLM_COUNT_TIME_STAT RowInserts; ///< Number of row insert operations that have been performed on + F_COUNT_TIME_STAT RowInserts; ///< Number of row insert operations that have been performed on ///< this database. - SFLM_COUNT_TIME_STAT RowDeletes; ///< Number of row delete operations that have been performed + F_COUNT_TIME_STAT RowDeletes; ///< Number of row delete operations that have been performed ///< on this database. - SFLM_COUNT_TIME_STAT RowModifies; ///< Number of row modify operations that have been performed + F_COUNT_TIME_STAT RowModifies; ///< Number of row modify operations that have been performed ///< on this database. } SFLM_DB_STATS; diff --git a/sql/src/flaimsys.h b/sql/src/flaimsys.h index 22b0b84..3187e71 100644 --- a/sql/src/flaimsys.h +++ b/sql/src/flaimsys.h @@ -477,7 +477,6 @@ FINLINE RCODE FlmStorage2UTF8( #include "fcache.h" #include "flmstat.h" #include "fbtrset.h" -#include "fsrvlock.h" #include "fcollate.h" #include "f_btree.h" #include "f_btpool.h" @@ -1501,7 +1500,7 @@ public: RCODE transBegin( eDbTransType eTransType, - FLMUINT uiMaxLockWait = SFLM_NO_TIMEOUT, + FLMUINT uiMaxLockWait = FLM_NO_TIMEOUT, FLMUINT uiFlags = 0, SFLM_DB_HDR * pDbHeader = NULL); @@ -1522,19 +1521,19 @@ public: FLMUINT uiTimeout); RCODE dbLock( - eDbLockType eLockType, + eLockType eLockType, FLMINT iPriority, FLMUINT uiTimeout); RCODE dbUnlock( void); RCODE getLockType( - eDbLockType * peLockType, + eLockType * peLockType, FLMBOOL * pbImplicit); RCODE getLockInfo( FLMINT iPriority, - eDbLockType * peCurrLockType, + eLockType * peCurrLockType, FLMUINT * puiThreadId, FLMUINT * puiNumExclQueued, FLMUINT * puiNumSharedQueued, @@ -1773,11 +1772,6 @@ public: return( rc); } - FINLINE FLMBOOL threadWaitingLock( void) - { - return( m_pDatabase->m_pDatabaseLockObj->ThreadWaitingLock()); - } - RCODE getLockWaiters( IF_LockInfoClient * pLockInfo); @@ -1963,7 +1957,7 @@ private: RCODE beginTrans( eDbTransType eTransType, - FLMUINT uiMaxLockWait = SFLM_NO_TIMEOUT, + FLMUINT uiMaxLockWait = FLM_NO_TIMEOUT, FLMUINT uiFlags = 0, SFLM_DB_HDR * pDbHdr = NULL); @@ -2426,7 +2420,6 @@ friend class F_BlockCacheMgr; friend class F_RowCacheMgr; friend class F_GlobalCacheMgr; friend class F_QueryResultSet; -friend class ServerLockObject; friend class F_BTreeInfo; friend class SQLQuery; }; diff --git a/sql/src/flbackup.cpp b/sql/src/flbackup.cpp index 0f06033..c186125 100644 --- a/sql/src/flbackup.cpp +++ b/sql/src/flbackup.cpp @@ -617,7 +617,7 @@ RCODE F_Backup::backup( if ((m_pDb->m_uiFlags & FDB_HAS_FILE_LOCK) == 0) { - if (RC_BAD( rc = m_pDb->dbLock(SFLM_LOCK_EXCLUSIVE, 0, SFLM_NO_TIMEOUT))) + if (RC_BAD( rc = m_pDb->dbLock(FLM_LOCK_EXCLUSIVE, 0, FLM_NO_TIMEOUT))) { goto Exit; } diff --git a/sql/src/flclose.cpp b/sql/src/flclose.cpp index c759678..7d0c877 100644 --- a/sql/src/flclose.cpp +++ b/sql/src/flclose.cpp @@ -158,7 +158,7 @@ Retry: } pBucket = gv_SFlmSysData.pDatabaseHashTbl; - uiBucket = flmStrHashBucket( szDbPathStr1, pBucket, FILE_HASH_ENTRIES); + uiBucket = f_strHashBucket( szDbPathStr1, pBucket, FILE_HASH_ENTRIES); pDatabase = (F_Database *)pBucket [uiBucket].pFirstInBucket; while( pDatabase) diff --git a/sql/src/flconvrt.cpp b/sql/src/flconvrt.cpp index 8b8e069..5d5ef9a 100644 --- a/sql/src/flconvrt.cpp +++ b/sql/src/flconvrt.cpp @@ -48,7 +48,7 @@ RCODE F_Db::upgrade( if (!(m_uiFlags & FDB_HAS_FILE_LOCK)) { - if (RC_BAD( rc = dbLock( SFLM_LOCK_EXCLUSIVE, 0, 15))) + if (RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, 15))) { goto Exit; } @@ -241,7 +241,7 @@ RCODE F_Db::enableEncryption( void) if (!(m_uiFlags & FDB_HAS_FILE_LOCK)) { - if ( RC_BAD( rc = dbLock( SFLM_LOCK_EXCLUSIVE, 0, SFLM_NO_TIMEOUT))) + if ( RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, FLM_NO_TIMEOUT))) { goto Exit; } @@ -365,7 +365,7 @@ RCODE F_Db::wrapKey( if( !(m_uiFlags & FDB_HAS_FILE_LOCK)) { - if ( RC_BAD( rc = dbLock( SFLM_LOCK_EXCLUSIVE, 0, SFLM_NO_TIMEOUT))) + if ( RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, FLM_NO_TIMEOUT))) { goto Exit; } @@ -573,7 +573,7 @@ RCODE F_Db::rollOverDbKey( void) if (!(m_uiFlags & FDB_HAS_FILE_LOCK)) { - if ( RC_BAD( rc = dbLock( SFLM_LOCK_EXCLUSIVE, 0, SFLM_NO_TIMEOUT))) + if ( RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, FLM_NO_TIMEOUT))) { goto Exit; } diff --git a/sql/src/flindex.cpp b/sql/src/flindex.cpp index f55c410..a71c97e 100644 --- a/sql/src/flindex.cpp +++ b/sql/src/flindex.cpp @@ -632,7 +632,8 @@ void F_Db::stopBackgroundIndexThread( // The thread may be waiting to start a transaction. - gv_SFlmSysData.pServerLockMgr->SignalLockWaiter( uiThreadId); + m_pDatabase->m_pDatabaseLockObj->timeoutLockWaiter( uiThreadId); + m_pDatabase->m_pWriteLockObj->timeoutLockWaiter( uiThreadId); if( !bWait) { diff --git a/sql/src/flmstat.cpp b/sql/src/flmstat.cpp index 4c3af86..a90e7a5 100644 --- a/sql/src/flmstat.cpp +++ b/sql/src/flmstat.cpp @@ -651,10 +651,12 @@ FSTATIC RCODE flmUpdateDbStats( pDestDb->uiLogBlockChkErrs += pSrcDb->uiLogBlockChkErrs; pDestDb->uiReadErrors += pSrcDb->uiReadErrors; pDestDb->uiWriteErrors += pSrcDb->uiWriteErrors; - flmUpdateCountTimeStats( &pDestDb->NoLocks, &pSrcDb->NoLocks); - flmUpdateCountTimeStats( &pDestDb->WaitingForLock, - &pSrcDb->WaitingForLock); - flmUpdateCountTimeStats( &pDestDb->HeldLock, &pSrcDb->HeldLock); + flmUpdateCountTimeStats( &pDestDb->LockStats.NoLocks, + &pSrcDb->LockStats.NoLocks); + flmUpdateCountTimeStats( &pDestDb->LockStats.WaitingForLock, + &pSrcDb->LockStats.WaitingForLock); + flmUpdateCountTimeStats( &pDestDb->LockStats.HeldLock, + &pSrcDb->LockStats.HeldLock); // Go through the LFILE statistics. diff --git a/sql/src/flmstat.h b/sql/src/flmstat.h index 9e400ef..b86668e 100644 --- a/sql/src/flmstat.h +++ b/sql/src/flmstat.h @@ -125,8 +125,8 @@ void flmAddElapTime( // Source: flmstat.cpp } FINLINE void flmUpdateCountTimeStats( - SFLM_COUNT_TIME_STAT * pDest, - SFLM_COUNT_TIME_STAT * pSrc) + F_COUNT_TIME_STAT * pDest, + F_COUNT_TIME_STAT * pSrc) { pDest->ui64Count += pSrc->ui64Count; pDest->ui64ElapMilli += pSrc->ui64ElapMilli; diff --git a/sql/src/flopen.cpp b/sql/src/flopen.cpp index 663cd6e..07cad56 100644 --- a/sql/src/flopen.cpp +++ b/sql/src/flopen.cpp @@ -868,7 +868,7 @@ Retry: } pBucket = gv_SFlmSysData.pDatabaseHashTbl; - uiBucket = flmStrHashBucket( szDbPathStr1, pBucket, FILE_HASH_ENTRIES); + uiBucket = f_strHashBucket( szDbPathStr1, pBucket, FILE_HASH_ENTRIES); pDatabase = (F_Database *)pBucket [uiBucket].pFirstInBucket; while (pDatabase) { @@ -1241,7 +1241,7 @@ F_Database::~F_Database() if (m_pWriteLockObj) { - m_pWriteLockObj->Release( FALSE); + m_pWriteLockObj->Release(); m_pWriteLockObj = NULL; } @@ -1375,8 +1375,6 @@ RCODE F_Database::setupDatabase( FLMUINT uiAllocLen; FLMUINT uiDbNameLen; FLMUINT uiDirNameLen; - FFileItemId * pFileItemId1 = NULL; - FFileItemId * pFileItemId2 = NULL; char szDbPathStr[ F_PATH_MAX_SIZE]; char szDataDirStr[ F_PATH_MAX_SIZE]; @@ -1462,52 +1460,22 @@ RCODE F_Database::setupDatabase( goto Exit; } - // Allocate the lock objects - must be done AFTER setting up the - // file name stuff up above. - - if ((pFileItemId1 = f_new FFileItemId( this, TRUE)) == NULL) - { - rc = RC_SET( NE_SFLM_MEM); - goto Exit; - } - if ((pFileItemId2 = f_new FFileItemId( this, FALSE)) == NULL) - { - rc = RC_SET( NE_SFLM_MEM); - goto Exit; - } - // Allocate a lock object for write locking. - - if ((m_pWriteLockObj = gv_SFlmSysData.pServerLockMgr->GetLockObject( - pFileItemId1)) == NULL) + + if( RC_BAD( rc = FlmAllocLockObject( &m_pWriteLockObj))) { - rc = RC_SET( NE_SFLM_MEM); goto Exit; } - m_pWriteLockObj->AddRef(); // Allocate a lock object for file locking. - - if ((m_pDatabaseLockObj = gv_SFlmSysData.pServerLockMgr->GetLockObject( - pFileItemId2)) == NULL) + + if( RC_BAD( rc = FlmAllocLockObject( &m_pDatabaseLockObj))) { - rc = RC_SET( NE_SFLM_MEM); goto Exit; } - m_pDatabaseLockObj->AddRef(); - + Exit: - if (pFileItemId1) - { - pFileItemId1->Release(); - } - - if (pFileItemId2) - { - pFileItemId2->Release(); - } - return( rc); } @@ -1844,7 +1812,7 @@ FLMBOOL F_Database::tryCheckpoint( (m_uiDirtyCacheCount + m_uiLogCacheCount) * m_uiBlockSize > gv_SFlmSysData.pBlockCacheMgr->m_uiMaxDirtyCache)) { - if (RC_BAD( rc = dbWriteLock( pCPInfo->hWaitSem, pDbStats))) + if (RC_BAD( rc = dbWriteLock( pCPInfo->hWaitSem, pDbStats, FLM_NO_TIMEOUT))) { // THIS SHOULD NEVER HAPPEN BECAUSE dbWriteLock will @@ -1877,7 +1845,7 @@ FLMBOOL F_Database::tryCheckpoint( m_lastCommittedDbHdr.ui64CurrTransID || !m_pRfl->seeIfRflWritesDone( pCPInfo->hWaitSem, FALSE)) { - dbWriteUnlock( pDbStats); + dbWriteUnlock(); goto Exit; } } @@ -1891,7 +1859,7 @@ FLMBOOL F_Database::tryCheckpoint( (void)flmStatUpdate( &pCPInfo->Stats); } - dbWriteUnlock( pDbStats); + dbWriteUnlock(); // Set the thread's status diff --git a/sql/src/flreduce.cpp b/sql/src/flreduce.cpp index 6c1f722..809171a 100644 --- a/sql/src/flreduce.cpp +++ b/sql/src/flreduce.cpp @@ -79,8 +79,8 @@ RCODE F_Db::reduceSize( if (!(m_uiFlags & FDB_HAS_FILE_LOCK)) { - if (RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->Lock( this, m_hWaitSem, - TRUE, FALSE, TRUE, SFLM_NO_TIMEOUT, 0, m_pDbStats))) + if (RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->lock( m_hWaitSem, + TRUE, FLM_NO_TIMEOUT, 0, m_pDbStats ? &m_pDbStats->LockStats : NULL))) { goto Exit; } @@ -105,7 +105,7 @@ RCODE F_Db::reduceSize( // Start a database transaction if( RC_BAD(rc = beginTrans( SFLM_UPDATE_TRANS, - SFLM_NO_TIMEOUT, SFLM_DONT_POISON_CACHE))) + FLM_NO_TIMEOUT, SFLM_DONT_POISON_CACHE))) { goto Exit; } @@ -304,7 +304,7 @@ Exit: if (bLockedDb) { - (void)m_pDatabase->m_pDatabaseLockObj->Unlock( TRUE, this); + (void)m_pDatabase->m_pDatabaseLockObj->unlock(); m_uiFlags &= ~FDB_HAS_FILE_LOCK; } diff --git a/sql/src/fltrbeg.cpp b/sql/src/fltrbeg.cpp index 4578563..5247f92 100644 --- a/sql/src/fltrbeg.cpp +++ b/sql/src/fltrbeg.cpp @@ -689,7 +689,7 @@ Exit: Desc : Obtains a a lock on the database. ****************************************************************************/ RCODE F_Db::dbLock( - eDbLockType eLockType, + eLockType eLockType, FLMINT iPriority, FLMUINT uiTimeout) { @@ -697,7 +697,7 @@ RCODE F_Db::dbLock( // eLockType better be exclusive or shared - if (eLockType != SFLM_LOCK_EXCLUSIVE && eLockType != SFLM_LOCK_SHARED) + if (eLockType != FLM_LOCK_EXCLUSIVE && eLockType != FLM_LOCK_SHARED) { rc = RC_SET( NE_SFLM_ILLEGAL_OP); goto Exit; @@ -721,16 +721,17 @@ RCODE F_Db::dbLock( // Attempt to acquire the lock. - if (RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->Lock( this, m_hWaitSem, - TRUE, FALSE, (FLMBOOL)((eLockType == SFLM_LOCK_EXCLUSIVE) + if (RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->lock( m_hWaitSem, + (FLMBOOL)((eLockType == FLM_LOCK_EXCLUSIVE) ? (FLMBOOL)TRUE : (FLMBOOL)FALSE), - uiTimeout, iPriority, m_pDbStats))) + uiTimeout, iPriority, + m_pDbStats ? &m_pDbStats->LockStats : NULL))) { goto Exit; } m_uiFlags |= FDB_HAS_FILE_LOCK; - if (eLockType == SFLM_LOCK_SHARED) + if (eLockType == FLM_LOCK_SHARED) { m_uiFlags |= FDB_FILE_LOCK_SHARED; } @@ -760,7 +761,7 @@ RCODE F_Db::dbUnlock( void) // Unlock the file. - if (RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->Unlock( TRUE, this))) + if (RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->unlock())) { goto Exit; } @@ -785,7 +786,7 @@ Desc : Returns information about current and pending locks on the ****************************************************************************/ RCODE F_Db::getLockInfo( FLMINT iPriority, - eDbLockType * peCurrLockType, + eLockType * peCurrLockType, FLMUINT * puiThreadId, FLMUINT * puiNumExclQueued, FLMUINT * puiNumSharedQueued, @@ -798,7 +799,7 @@ RCODE F_Db::getLockInfo( goto Exit; } - m_pDatabase->m_pDatabaseLockObj->GetLockInfo( iPriority, + m_pDatabase->m_pDatabaseLockObj->getLockInfo( iPriority, peCurrLockType, puiThreadId, puiNumExclQueued, puiNumSharedQueued, puiPriorityCount); @@ -813,14 +814,14 @@ Desc : Returns information about the lock held by the specified database handle. ****************************************************************************/ RCODE F_Db::getLockType( - eDbLockType * peLockType, + eLockType * peLockType, FLMBOOL * pbImplicit) { RCODE rc = NE_SFLM_OK; if (peLockType) { - *peLockType = SFLM_LOCK_NONE; + *peLockType = FLM_LOCK_NONE; } if (pbImplicit) @@ -839,11 +840,11 @@ RCODE F_Db::getLockType( { if (m_uiFlags & FDB_FILE_LOCK_SHARED) { - *peLockType = SFLM_LOCK_SHARED; + *peLockType = FLM_LOCK_SHARED; } else { - *peLockType = SFLM_LOCK_EXCLUSIVE; + *peLockType = FLM_LOCK_EXCLUSIVE; } } @@ -926,8 +927,9 @@ RCODE F_Db::lockExclusive( if (!(m_uiFlags & FDB_HAS_FILE_LOCK)) { - if (RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->Lock( this, - m_hWaitSem, TRUE, FALSE, TRUE, uiMaxLockWait, 0, m_pDbStats))) + if (RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->lock( + m_hWaitSem, TRUE, uiMaxLockWait, 0, + m_pDbStats ? &m_pDbStats->LockStats : NULL))) { goto Exit; } @@ -935,7 +937,7 @@ RCODE F_Db::lockExclusive( m_uiFlags |= (FDB_HAS_FILE_LOCK | FDB_FILE_LOCK_IMPLICIT); } - if (RC_OK( rc = m_pDatabase->dbWriteLock( m_hWaitSem, m_pDbStats))) + if (RC_OK( rc = m_pDatabase->dbWriteLock( m_hWaitSem, m_pDbStats, FLM_NO_TIMEOUT))) { m_uiFlags |= FDB_HAS_WRITE_LOCK; } @@ -946,7 +948,7 @@ Exit: { if (bGotFileLock) { - (void)m_pDatabase->m_pDatabaseLockObj->Unlock( TRUE, this); + (void)m_pDatabase->m_pDatabaseLockObj->unlock(); m_uiFlags &= (~(FDB_HAS_FILE_LOCK | FDB_FILE_LOCK_IMPLICIT | FDB_HAS_WRITE_LOCK)); } @@ -963,7 +965,7 @@ Exit: { if (bGotFileLock) { - (void)m_pDatabase->m_pDatabaseLockObj->Unlock( TRUE, this); + (void)m_pDatabase->m_pDatabaseLockObj->unlock(); m_uiFlags &= (~(FDB_HAS_FILE_LOCK | FDB_FILE_LOCK_IMPLICIT | FDB_HAS_WRITE_LOCK)); } @@ -984,14 +986,14 @@ void F_Db::unlockExclusive( void) flmAssert( m_uiFlags & FDB_HAS_WRITE_LOCK); - m_pDatabase->dbWriteUnlock( m_pDbStats); + m_pDatabase->dbWriteUnlock(); m_uiFlags &= ~FDB_HAS_WRITE_LOCK; // Give up the file lock, if it was acquired implicitly. if (m_uiFlags & FDB_FILE_LOCK_IMPLICIT) { - (void)m_pDatabase->m_pDatabaseLockObj->Unlock( TRUE, this); + (void)m_pDatabase->m_pDatabaseLockObj->unlock(); m_uiFlags &= (~(FDB_HAS_FILE_LOCK | FDB_FILE_LOCK_IMPLICIT)); } diff --git a/sql/src/fslfileu.cpp b/sql/src/fslfileu.cpp index 9ad64cb..38f775c 100644 --- a/sql/src/fslfileu.cpp +++ b/sql/src/fslfileu.cpp @@ -206,7 +206,7 @@ RCODE F_Db::indexSetOfRows( FLMUINT64 ui64LastRowId = 0; F_INDEX * pIndex = NULL; F_TABLE * pTable; - ServerLockObject * + IF_LockObject * pDatabaseLockObj = m_pDatabase->m_pDatabaseLockObj; FLMBOOL bHitEnd = FALSE; FLMUINT uiCurrTime; @@ -334,7 +334,7 @@ RCODE F_Db::indexSetOfRows( break; } - if (pDatabaseLockObj->ThreadWaitingLock()) + if (pDatabaseLockObj->getWaiterCount()) { // See if our minimum run time has elapsed @@ -371,7 +371,7 @@ RCODE F_Db::indexSetOfRows( if (FLM_ELAPSED_TIME( uiCurrTime, uiStartTime) > gv_SFlmSysData.uiMaxCPInterval && - m_pDatabase->m_pWriteLockObj->ThreadWaitingLock()) + m_pDatabase->m_pWriteLockObj->getWaiterCount()) { bRelinquish = TRUE; break; @@ -789,9 +789,9 @@ RetryLock: flmAssert( !(m_uiFlags & FDB_HAS_FILE_LOCK)); - if( RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->Lock( this, m_hWaitSem, - TRUE, FALSE, TRUE, SFLM_NO_TIMEOUT, FLM_BACKGROUND_LOCK_PRIORITY, - m_pDbStats))) + if( RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->lock( m_hWaitSem, + TRUE, FLM_NO_TIMEOUT, FLM_BACKGROUND_LOCK_PRIORITY, + m_pDbStats ? &m_pDbStats->LockStats : NULL))) { if( rc == NE_SFLM_DATABASE_LOCK_REQ_TIMEOUT) { @@ -819,7 +819,7 @@ RetryLock: { goto Exit; } - if( RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->Unlock( TRUE, this))) + if( RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->unlock())) { goto Exit; } @@ -839,7 +839,7 @@ RetryLock: // Start an update transaction if( RC_BAD( rc = beginTrans( - SFLM_UPDATE_TRANS, SFLM_NO_TIMEOUT, SFLM_DONT_POISON_CACHE))) + SFLM_UPDATE_TRANS, FLM_NO_TIMEOUT, SFLM_DONT_POISON_CACHE))) { if( rc == NE_SFLM_DATABASE_LOCK_REQ_TIMEOUT) { @@ -857,7 +857,7 @@ Exit: { if( m_uiFlags & FDB_HAS_FILE_LOCK) { - (void)m_pDatabase->m_pDatabaseLockObj->Unlock( TRUE, this); + (void)m_pDatabase->m_pDatabaseLockObj->unlock(); m_uiFlags &= ~(FDB_HAS_FILE_LOCK | FDB_FILE_LOCK_IMPLICIT); } } diff --git a/sql/src/fsrvlock.cpp b/sql/src/fsrvlock.cpp deleted file mode 100644 index 15c70e3..0000000 --- a/sql/src/fsrvlock.cpp +++ /dev/null @@ -1,1204 +0,0 @@ -//------------------------------------------------------------------------------ -// Desc: Contains the methods for the ServerLockManager and -// ServerLockObject classes. -// -// Tabs: 3 -// -// Copyright (c) 1998-2006 Novell, Inc. All Rights Reserved. -// -// This program is free software; you can redistribute it and/or -// modify it under the terms of version 2 of the GNU General Public -// License as published by the Free Software Foundation. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program; if not, contact Novell, Inc. -// -// To contact Novell about this file by physical or electronic mail, -// you may find current contact information at www.novell.com -// -// $Id$ -//------------------------------------------------------------------------------ - -#include "flaimsys.h" - -#define LOCK_HASH_ENTRIES 256 - -/**************************************************************************** -Desc: -****************************************************************************/ -ServerLockManager::~ServerLockManager() -{ - // Free everything in the avail lock list. This is where all - // of the lock objects should be at this point. - - if (m_hMutex != F_MUTEX_NULL) - { - lockMutex( FALSE); - - // Signal all pending lock waiters. - - CheckLockTimeouts( TRUE, TRUE); - - while (m_pAvailLockList) - { - ServerLockObject_p pLockObject = m_pAvailLockList; - - UnlinkLockObject( pLockObject, FALSE); - - pLockObject->Release(); - } - unlockMutex( FALSE); - f_mutexDestroy( &m_hMutex); - } - - // Free the hash table. - - f_free( &m_pHashTbl); -} - -/**************************************************************************** -Desc: Initializes the lock manager's hash table. -****************************************************************************/ -RCODE ServerLockManager::SetupHashTbl() -{ - return( flmAllocHashTbl( LOCK_HASH_ENTRIES, &m_pHashTbl)); -} - -/**************************************************************************** -Desc: Finds the lock object for the passed in item identifier. - If one is not found, one will be created. -****************************************************************************/ -ServerLockObject_p ServerLockManager::GetLockObject( - F_ItemId_p pItemId) -{ - FLMUINT uiBucket; - ServerLockObject * pLockObject; - ServerLockObject * pTmpLockObject; - - // Get the hash bucket. - - uiBucket = pItemId->GetHashBucket( m_pHashTbl, LOCK_HASH_ENTRIES); - - // See if the desired file is already in the hash bucket. - - lockMutex( FALSE); - - pLockObject = (ServerLockObject_p)m_pHashTbl [uiBucket].pFirstInBucket; - - // See if any of the objects match. - - while (pLockObject) - { - if (pItemId->IsEqual( pLockObject->m_pItemId)) - { - goto Exit; - } - pLockObject = pLockObject->m_pNext; - } - - // If we didn't find a matching object, allocate an object and link it into - // the hash bucket. Check to see if we have any in the avail list - // first so that we don't have to allocate memory if we can avoid it. - - if ((pLockObject = m_pAvailLockList) != NULL) - { - UnlinkLockObject( pLockObject, FALSE); - } - else - { - if ((pLockObject = f_new ServerLockObject) == NULL) - { - goto Exit; - } - } - - // Setup the new object and put it into the hash bucket. - - pLockObject->Setup( this, pItemId, uiBucket); - pTmpLockObject = - (ServerLockObject_p)m_pHashTbl [uiBucket].pFirstInBucket; - pLockObject->m_pPrev = NULL; - pLockObject->m_pNext = pTmpLockObject; - if (pTmpLockObject) - { - pTmpLockObject->m_pPrev = pLockObject; - } - m_pHashTbl [uiBucket].pFirstInBucket = pLockObject; - -Exit: - - unlockMutex( FALSE); - return( pLockObject); -} - -/**************************************************************************** -Desc: Unlinks a lock object from whatever list it is in. This routine - assumes that the server lock manager's mutex is already locked. -****************************************************************************/ -void ServerLockManager::UnlinkLockObject( - ServerLockObject * pLockObject, - FLMBOOL bPutInAvailList) -{ - ServerLockObject * pTmpLockObject; - FLMUINT uiBucket; - - // If hash bucket 0xFFFF, unlink from the avail list. Otherwise, - // unlink from the hash bucket it is in. - - if ((uiBucket = pLockObject->m_uiBucket) == 0xFFFF) - { - if ((pTmpLockObject = pLockObject->m_pPrev) == NULL) - { - m_pAvailLockList = pLockObject->m_pNext; - } - else - { - pTmpLockObject->m_pNext = pLockObject->m_pNext; - } - m_uiNumAvail--; - } - else - { - if ((pTmpLockObject = pLockObject->m_pPrev) == NULL) - { - m_pHashTbl [uiBucket].pFirstInBucket = pLockObject->m_pNext; - } - else - { - pTmpLockObject->m_pNext = pLockObject->m_pNext; - } - } - if ((pTmpLockObject = pLockObject->m_pNext) != NULL) - { - pTmpLockObject->m_pPrev = pLockObject->m_pPrev; - } - - if (bPutInAvailList) - { - if (m_uiNumAvail >= 50) - { - flmAssert( getRefCount() == 1); - pLockObject->Release(); - } - else - { - pLockObject->Setup( this, NULL, 0xFFFF); - if (m_pAvailLockList) - { - m_pAvailLockList->m_pPrev = pLockObject; - } - pLockObject->m_pPrev = NULL; - pLockObject->m_pNext = m_pAvailLockList; - m_pAvailLockList = pLockObject; - m_uiNumAvail++; - } - } -} - -/**************************************************************************** -Desc: Checks for any pending lock requests that have timed out. -****************************************************************************/ -void ServerLockManager::CheckLockTimeouts( - FLMBOOL bMutexAlreadyLocked, - FLMBOOL bTimeoutAll) -{ - FLMUINT uiCurrTime; - LOCK_WAITER_p pLockWaiter; - - lockMutex( bMutexAlreadyLocked); - uiCurrTime = (FLMUINT)FLM_GET_TIMER(); - - while ((m_pFirstLockWaiter) && - ((bTimeoutAll) || - ((m_pFirstLockWaiter->uiWaitTime) && - (FLM_ELAPSED_TIME( uiCurrTime, m_pFirstLockWaiter->uiWaitStartTime) >= - m_pFirstLockWaiter->uiWaitTime)))) - { - // Sanity check - - flmAssert( m_pFirstLockWaiter->pPrevGlobal == NULL); - - // Lock waiter has timed out. - - pLockWaiter = m_pFirstLockWaiter; - - // Remove from global list and lock object's list - - RemoveWaiter( pLockWaiter); - pLockWaiter->pLockObject->RemoveWaiter( pLockWaiter); - - // Tell the waiter that the lock request timed out. - - *(pLockWaiter->pRc) = RC_SET( NE_SFLM_DATABASE_LOCK_REQ_TIMEOUT); - f_semSignal( pLockWaiter->hESem); - } - - unlockMutex( bMutexAlreadyLocked); -} - - -/**************************************************************************** -Desc: Signal a lock waiter that has a matching thread id. -****************************************************************************/ -void ServerLockManager::SignalLockWaiter( - FLMUINT uiThreadId) -{ - FLMUINT uiCurrTime; - LOCK_WAITER_p pLockWaiter; - LOCK_WAITER_p pNextWaiter; - - lockMutex( FALSE); - uiCurrTime = (FLMUINT)FLM_GET_TIMER(); - - for( pLockWaiter = m_pFirstLockWaiter; - pLockWaiter; - pLockWaiter = pNextWaiter) - { - pNextWaiter = pLockWaiter->pNextGlobal; - - if( pLockWaiter->uiThreadId == uiThreadId) - { - // Remove from global list and lock object's list - - RemoveWaiter( pLockWaiter); - pLockWaiter->pLockObject->RemoveWaiter( pLockWaiter); - - // Tell the waiter that the lock request timed out. - - *(pLockWaiter->pRc) = RC_SET( NE_SFLM_DATABASE_LOCK_REQ_TIMEOUT); - f_semSignal( pLockWaiter->hESem); - break; - } - } - - unlockMutex( FALSE); - return; -} - -/**************************************************************************** -Desc: Inserts a waiter into the global list of waiters, sorted by - its end wait time. - - NOTE: This routine assumes that the lock manager's semaphore - is already locked. -****************************************************************************/ -void ServerLockManager::InsertWaiter( - LOCK_WAITER_p pLockWaiter) -{ - LOCK_WAITER_p pPrevLockWaiter; - - // Determine where in the list this lock waiter should go. - - if ((pPrevLockWaiter = m_pFirstLockWaiter) != NULL) - { - FLMUINT uiCurrTime = FLM_GET_TIMER(); - FLMUINT uiElapTime; - FLMUINT uiTimeLeft; - - while (pPrevLockWaiter) - { - // Waiters with zero wait time go to end of list. - // They never time out. - - if (!pPrevLockWaiter->uiWaitTime) - { - - // Should go BEFORE the first zero waiter. - - pPrevLockWaiter = pPrevLockWaiter->pPrevGlobal; - break; - } - else if (!pLockWaiter->uiWaitTime) - { - if (!pPrevLockWaiter->pNextGlobal) - { - break; - } - pPrevLockWaiter = pPrevLockWaiter->pNextGlobal; - } - else - { - // Determine how much time is left on the previous - // lock waiter's timer. If it is less than the - // new lock waiter's wait time, the new lock waiter - // should be inserted AFTER it. Otherwise, the - // new lock waiter should be inserted BEFORE it. - - uiElapTime = FLM_ELAPSED_TIME( uiCurrTime, - pPrevLockWaiter->uiWaitStartTime); - if (uiElapTime >= pPrevLockWaiter->uiWaitTime) - { - uiTimeLeft = 0; - } - else - { - uiTimeLeft = pPrevLockWaiter->uiWaitTime - uiElapTime; - } - - // New lock waiter will time out before previous lock - // waiter - insert it BEFORE the previous lock waiter. - - if (pLockWaiter->uiWaitTime < uiTimeLeft) - { - pPrevLockWaiter = pPrevLockWaiter->pPrevGlobal; - break; - } - else - { - if (!pPrevLockWaiter->pNextGlobal) - break; - pPrevLockWaiter = pPrevLockWaiter->pNextGlobal; - } - } - } - } - - // Insert into list AFTER pPrevLockWaiter. - - if ((pLockWaiter->pPrevGlobal = pPrevLockWaiter) != NULL) - { - if ((pLockWaiter->pNextGlobal = pPrevLockWaiter->pNextGlobal) != NULL) - { - pLockWaiter->pNextGlobal->pPrevGlobal = pLockWaiter; - } - pPrevLockWaiter->pNextGlobal = pLockWaiter; - } - else - { - if( (pLockWaiter->pNextGlobal = m_pFirstLockWaiter) != NULL) - { - m_pFirstLockWaiter->pPrevGlobal = pLockWaiter; - } - m_pFirstLockWaiter = pLockWaiter; - } -} - -/**************************************************************************** -Desc: See if this item ID is equal to another F_ItemId. -****************************************************************************/ -FLMBOOL FFileItemId::IsEqual( - F_ItemId_p pItemId) -{ - FFileItemId_p pFFileItemId; - RFileItemId_p pRFileItemId; - char szName1 [F_FILENAME_SIZE]; - char szName2 [F_FILENAME_SIZE]; - FLMUINT uiItemType = pItemId->GetItemType(); - - switch (uiItemType) - { - case FFILE_ITEM: - case FFILE_TRANS_ITEM: - if (m_uiItemType != uiItemType) - return( FALSE); - pFFileItemId = (FFileItemId_p)pItemId; - - /* First see if the FFILE pointers are the same. */ - - if (pFFileItemId->getDatabase() == - this->getDatabase()) - { - return( TRUE); - } - - /* Next see if the file names are the same. */ - - this->GetFileName( szName1); - pFFileItemId->GetFileName( szName2); -#if !defined( FLM_UNIX) - if (f_stricmp( szName1, szName2) == 0) - return( TRUE); -#else - if (f_strcmp( szName1, szName2) == 0) - return( TRUE); -#endif - break; - case RFILE_ITEM: - case RFILE_TRANS_ITEM: - if ((uiItemType == RFILE_ITEM && - m_uiItemType != FFILE_ITEM) || - (uiItemType == RFILE_TRANS_ITEM && - m_uiItemType != FFILE_TRANS_ITEM)) - { - return( FALSE); - } - pRFileItemId = (RFileItemId_p)pItemId; - - /* See if the file names are the same. */ - - this->GetFileName( szName1); - pRFileItemId->GetFileName( szName2); -#if !defined( FLM_UNIX) - if (f_stricmp( szName1, szName2) == 0) - return( TRUE); -#else - if (f_strcmp( szName1, szName2) == 0) - return( TRUE); -#endif - break; - default: - break; - } - return( FALSE); -} - -/**************************************************************************** -Desc: Get file name for this file item. -****************************************************************************/ -void FFileItemId::GetFileName( - char * pszFileNameRV) -{ - // _ExtractFileName( m_pFile, pszFileNameRV); - char szTmpPath[ F_PATH_MAX_SIZE]; - - (void)gv_SFlmSysData.pFileSystem->pathReduce( - m_pDatabase->m_pszDbPath, szTmpPath, pszFileNameRV); - - // Convert to upper case for consistency when hashing. - -#if !defined( FLM_UNIX) - while (*pszFileNameRV) - { - *pszFileNameRV = (char)f_toupper( *pszFileNameRV); - pszFileNameRV++; - } -#endif -} - -/**************************************************************************** -Desc: -****************************************************************************/ -RFileItemId::RFileItemId( - char * pszFileName, - FLMBOOL bTrans) -{ - char * pszTmp = &m_szFileName [0]; - - while (*pszFileName) - { - // Convert to uppercase for consistency when hashing. - -#if !defined( FLM_UNIX) - *pszFileName = (char)f_toupper( *pszFileName); -#else - *pszTmp++ = *pszFileName; -#endif - pszFileName++; - } - *pszTmp = 0; - m_uiItemType = (FLMUINT)((bTrans) - ? (FLMUINT)RFILE_TRANS_ITEM - : (FLMUINT)RFILE_ITEM); -} - -/**************************************************************************** -Desc: See if this item ID is equal to another F_ItemId. -****************************************************************************/ -FLMBOOL RFileItemId::IsEqual( - F_ItemId * pItemId) -{ - FFileItemId * pFFileItemId; - RFileItemId * pRFileItemId; - char szName1 [F_FILENAME_SIZE]; - char szName2 [F_FILENAME_SIZE]; - FLMUINT uiItemType = pItemId->GetItemType(); - - switch (uiItemType) - { - case FFILE_ITEM: - case FFILE_TRANS_ITEM: - if ((uiItemType == FFILE_ITEM && - m_uiItemType != RFILE_ITEM) || - (uiItemType == FFILE_TRANS_ITEM && - m_uiItemType != RFILE_TRANS_ITEM)) - { - return( FALSE); - } - pFFileItemId = (FFileItemId_p)pItemId; - - /* See if the file names are the same. */ - - this->GetFileName( szName1); - pFFileItemId->GetFileName( szName2); -#if !defined( FLM_UNIX) - if (f_stricmp( szName1, szName2) == 0) - return( TRUE); -#else - if (f_strcmp( szName1, szName2) == 0) - return( TRUE); -#endif - break; - case RFILE_ITEM: - case RFILE_TRANS_ITEM: - if (m_uiItemType != uiItemType) - return( FALSE); - pRFileItemId = (RFileItemId_p)pItemId; - - /* See if the file names are the same. */ - - this->GetFileName( szName1); - pRFileItemId->GetFileName( szName2); -#if !defined( FLM_UNIX) - if (f_stricmp( szName1, szName2) == 0) - return( TRUE); -#else - if (f_strcmp( szName1, szName2) == 0) - return( TRUE); -#endif - break; - default: - break; - } - return( FALSE); -} - -/**************************************************************************** -Desc: -****************************************************************************/ -ServerLockObject::ServerLockObject() -{ - m_pServerLockMgr = NULL; - m_pItemId = NULL; - m_uiLockThreadId = 0; - m_uiLockTime = 0; - m_uiLockCnt = 0; - m_pFirstLockWaiter = - m_pLastLockWaiter = NULL; - m_uiNumWaiters = 0; - m_pNext = m_pPrev = NULL; - m_uiSharedLockCnt = 0; - m_bExclLock = FALSE; - m_uiBucket = 0xFFFF; - m_bStartTimeSet = FALSE; -} - -/**************************************************************************** -Desc: -****************************************************************************/ -FLMINT ServerLockObject::Release( - FLMBOOL bMutexAlreadyLocked) -{ - FLMINT iRefCnt = --m_refCnt; - - if( !iRefCnt) - { - delete this; - goto Exit; - } - - // When it is no longer pointed to from anything but the server lock - // manager, put it into the avail list. - - if (iRefCnt == 1) - { - LOCK_WAITER * pLockWaiter; - - // Signal all waiters that they cannot get the lock. - - m_pServerLockMgr->lockMutex( bMutexAlreadyLocked); - while (m_pFirstLockWaiter) - { - pLockWaiter = m_pFirstLockWaiter; - - // Remove from global list and lock object's list - - RemoveWaiter( pLockWaiter); - m_pServerLockMgr->RemoveWaiter( pLockWaiter); - - // Tell the waiter that the lock request timed out and signal - // the thread to wake it up. - - *(pLockWaiter->pRc) = RC_SET( NE_SFLM_DATABASE_LOCK_REQ_TIMEOUT); - f_semSignal( pLockWaiter->hESem); - } - - m_pServerLockMgr->UnlinkLockObject( this, TRUE); - m_pServerLockMgr->unlockMutex( bMutexAlreadyLocked); - } - -Exit: - - return( iRefCnt); -} - -/**************************************************************************** -Desc: Initialize some data for the lock object. -****************************************************************************/ -void ServerLockObject::Setup( - ServerLockManager_p pServerLockMgr, - F_ItemId_p pItemId, - FLMUINT uiBucket) -{ - m_pServerLockMgr = pServerLockMgr; - if (m_pItemId) - { - m_pItemId->Release(); - m_pItemId = NULL; - } - if ((m_pItemId = pItemId) != NULL) - { - m_pItemId->AddRef(); - } - m_uiBucket = uiBucket; -} - -/**************************************************************************** -Desc: Removes a waiter from the list of waiters on this object. - NOTE: This routine assumes that the lock manager's semaphore - is already locked. -****************************************************************************/ -void ServerLockObject::RemoveWaiter( - LOCK_WAITER_p pLockWaiter) -{ - if (pLockWaiter->pNext) - pLockWaiter->pNext->pPrev = pLockWaiter->pPrev; - else - m_pLastLockWaiter = pLockWaiter->pPrev; - - if (pLockWaiter->pPrev) - pLockWaiter->pPrev->pNext = pLockWaiter->pNext; - else - m_pFirstLockWaiter = pLockWaiter->pNext; - flmAssert( m_uiNumWaiters > 0); - m_uiNumWaiters--; -} - -/**************************************************************************** -Desc: Lock this object. If object is locked, wait the specified - number of seconds. -****************************************************************************/ -RCODE ServerLockObject::Lock( - F_Db * pDb, - F_SEM hWaitSem, - FLMBOOL bLogEvent, - FLMBOOL bSendSuspendEvent, // Send suspend event, as opposed to - // waiting event, when waiting. - FLMBOOL bExclReq, // Exclusive or shared lock? - FLMUINT uiMaxWaitSecs, // Maximum wait time in seconds. - FLMINT iPriority, // Lock priority - SFLM_DB_STATS * pDbStats) // Place to collect stats. -{ - RCODE rc = NE_SFLM_OK; - RCODE TempRc; - LOCK_WAITER LockWait; - FLMBOOL bMutexLocked = FALSE; - - flmAssert( hWaitSem != F_SEM_NULL); - - m_pServerLockMgr->lockMutex( FALSE); - bMutexLocked = TRUE; - - if ((m_pFirstLockWaiter) || - (m_bExclLock) || - ((bExclReq) && (m_uiSharedLockCnt))) - { - - // Object is locked, wait to get lock. - - if (!uiMaxWaitSecs) - { - rc = RC_SET( NE_SFLM_DATABASE_LOCK_REQ_TIMEOUT); - goto Exit; - } - - // Set up to wait for the lock. - - f_memset( &LockWait, 0, sizeof( LockWait)); - LockWait.pLockObject = this; - LockWait.hESem = hWaitSem; - - // Link into list of waiters on this object. - - if ((LockWait.pPrev = m_pLastLockWaiter) != NULL) - { - LockWait.pPrev->pNext = &LockWait; - } - else - { - m_pFirstLockWaiter = &LockWait; - } - m_pLastLockWaiter = &LockWait; - m_uiNumWaiters++; - - LockWait.uiThreadId = f_threadId(); - LockWait.pRc = &rc; - - rc = RC_SET( NE_SFLM_FAILURE); - - LockWait.bExclReq = bExclReq; - LockWait.iPriority = iPriority; - LockWait.uiWaitStartTime = (FLMUINT)FLM_GET_TIMER(); - - if (bExclReq && pDbStats) - { - f_timeGetTimeStamp( &LockWait.StartTime); - LockWait.pDbStats = pDbStats; - } - - if (uiMaxWaitSecs == SFLM_NO_TIMEOUT) - { - LockWait.uiWaitTime = 0; - } - else - { - LockWait.uiWaitTime = FLM_SECS_TO_TIMER_UNITS( uiMaxWaitSecs); - } - - // Link to list of global waiters - ordered by end time. - - m_pServerLockMgr->InsertWaiter( &LockWait); - - m_pServerLockMgr->unlockMutex( FALSE); - bMutexLocked = FALSE; - - // Do the event callback, if any registered. - - if (bLogEvent && - gv_SFlmSysData.EventHdrs [SFLM_EVENT_LOCKS].pEventCBList) - { - flmDoEventCallback( SFLM_EVENT_LOCKS, - (eEventType)((bSendSuspendEvent) - ? SFLM_EVENT_LOCK_SUSPENDED - : SFLM_EVENT_LOCK_WAITING), - pDb, LockWait.uiThreadId, - 0, 0, 0, NE_SFLM_OK); - } - - // Now just wait to be signaled. - - if (RC_BAD( TempRc = f_semWait( LockWait.hESem, F_SEM_WAITFOREVER))) - { - RC_UNEXPECTED_ASSERT( TempRc); - rc = TempRc; - } - else - { - // Process that signaled us better set the rc to something - // besides NE_SFLM_FAILURE. - - if (rc == NE_SFLM_FAILURE) - { - RC_UNEXPECTED_ASSERT( rc); - } - } - - // Do the event callback, if any registered. - - if (bLogEvent && - gv_SFlmSysData.EventHdrs [SFLM_EVENT_LOCKS].pEventCBList) - { - if (RC_BAD( rc)) - { - flmDoEventCallback( SFLM_EVENT_LOCKS, - SFLM_EVENT_LOCK_TIMEOUT, - pDb, LockWait.uiThreadId, - 0, 0, 0, NE_SFLM_OK); - } - else - { - flmDoEventCallback( SFLM_EVENT_LOCKS, - (eEventType)((bSendSuspendEvent) - ? SFLM_EVENT_LOCK_RESUMED - : SFLM_EVENT_LOCK_GRANTED), - pDb, LockWait.uiThreadId, - 0, 0, 0, NE_SFLM_OK); - } - } - } - else - { - - // Object is NOT locked in a conflicting mode. Grant the - // lock immediately. - - m_uiLockThreadId = f_threadId(); - m_bExclLock = bExclReq; - if (!bExclReq) - { - m_uiSharedLockCnt++; - } - else - { - m_uiLockTime = (FLMUINT)FLM_GET_TIMER(); - flmAssert( m_uiSharedLockCnt == 0); - - // Take care of statistics gathering. - - if (pDbStats) - { - - // If m_bStartTimeSet is TRUE, we started the - // clock the last time nobody had the exclusive - // lock, so we need to sum up idle time now. - - if (m_bStartTimeSet) - { - flmAddElapTime( &m_StartTime, &pDbStats->NoLocks.ui64ElapMilli); - pDbStats->NoLocks.ui64Count++; - } - - // Restart the clock for this locker. - - f_timeGetTimeStamp( &m_StartTime); - m_bStartTimeSet = TRUE; - } - else - { - m_bStartTimeSet = FALSE; - } - } - - // Do the event callback, if any registered. - - if (bLogEvent && - !bSendSuspendEvent && - gv_SFlmSysData.EventHdrs [SFLM_EVENT_LOCKS].pEventCBList) - { - m_pServerLockMgr->unlockMutex( FALSE); - bMutexLocked = FALSE; - flmDoEventCallback( SFLM_EVENT_LOCKS, - SFLM_EVENT_LOCK_GRANTED, - pDb, m_uiLockThreadId, - 0, 0, 0, NE_SFLM_OK); - } - } - -Exit: - - if (RC_OK( rc)) - { - m_uiLockCnt++; - } - - if (bMutexLocked) - { - m_pServerLockMgr->unlockMutex( FALSE); - } - - return( rc); -} - -/**************************************************************************** -Desc: Unlock this object. If there is a pending lock request, give - the lock to the next waiter. -****************************************************************************/ -RCODE ServerLockObject::Unlock( - FLMBOOL bLogEvent, - F_Db * pDb, - FLMBOOL bRelease, - SFLM_DB_STATS * pDbStats) -{ - RCODE rc = NE_SFLM_OK; - F_SEM hESem; - LOCK_WAITER_p pLockWaiter; - - m_pServerLockMgr->lockMutex( FALSE); - - if (m_bExclLock) - { - flmAssert( m_uiSharedLockCnt == 0); - m_bExclLock = FALSE; - - // Record how long the lock was held, if we were tracking - // it. - - if (pDbStats && m_bStartTimeSet) - { - flmAddElapTime( &m_StartTime, &pDbStats->HeldLock.ui64ElapMilli); - pDbStats->HeldLock.ui64Count++; - } - m_bStartTimeSet = FALSE; - } - else - { - flmAssert( m_uiSharedLockCnt > 0); - m_uiSharedLockCnt--; - } - - // Do the event callback, if any registered. - // NOTE: flmDoEventCallback locks the event mutex. - // Since we are inside the lock manager's mutex lock, - // the callback should not do ANYTHING that would cause - // us to end up in here again! - - if (bLogEvent && - gv_SFlmSysData.EventHdrs [SFLM_EVENT_LOCKS].pEventCBList) - { - flmDoEventCallback( SFLM_EVENT_LOCKS, - SFLM_EVENT_LOCK_RELEASED, - pDb, m_uiLockThreadId, - 0, 0, 0, NE_SFLM_OK); - } - - m_uiLockThreadId = 0; - - /* See if we need to signal the next set of waiters. */ - - if (m_pFirstLockWaiter && !m_uiSharedLockCnt) - { - m_bExclLock = m_pFirstLockWaiter->bExclReq; - while (m_pFirstLockWaiter) - { - if (!m_bExclLock) - { - m_uiSharedLockCnt++; - } - - - pLockWaiter = m_pFirstLockWaiter; - hESem = pLockWaiter->hESem; - - // Unlink the waiter from the list of waiters on this lock - // object and then from the global list of waiters. - // IMPORTANT NOTE: Do NOT signal the semaphore until AFTER - // doing this unlinking. This is because LOCK_WAITER - // structures exist only on the stack of the thread - // being signaled. If we tried to assign m_pFirstLockWaiter after - // signaling the semaphore, the LOCK_WAITER structure could - // disappear and m_pFirstLockWaiter would get garbage. - - RemoveWaiter( pLockWaiter); - m_pServerLockMgr->RemoveWaiter( pLockWaiter); - - // Update statistics for the waiter. - - if (pLockWaiter->pDbStats) - { - flmAddElapTime( &pLockWaiter->StartTime, - &pLockWaiter->pDbStats->WaitingForLock.ui64ElapMilli); - pLockWaiter->pDbStats->WaitingForLock.ui64Count++; - } - - // Grant the lock to this waiter and signal the thread - // to wake it up. - - m_uiLockThreadId = pLockWaiter->uiThreadId; - if (m_bExclLock) - { - m_uiLockTime = (FLMUINT)FLM_GET_TIMER(); - - // Restart the stats timer - - if (pDbStats) - { - m_bStartTimeSet = TRUE; - f_timeGetTimeStamp( &m_StartTime); - } - } - - *(pLockWaiter->pRc) = NE_SFLM_OK; - - f_semSignal( hESem); - - // If the next waiter is not a shared lock request or - // the lock that was granted was exclusive, we stop - // here. - - if (m_bExclLock || - (m_pFirstLockWaiter && m_pFirstLockWaiter->bExclReq)) - { - break; - } - } - } - else if (bRelease && - !m_pFirstLockWaiter && // No one is wating for the object - !m_uiSharedLockCnt) // No one has the object locked - { - // Release the object. If the reference count drops to 1, - // the object will be put in the avail list. The caller - // should have performed an AddRef() on the object at - // some point prior to calling this method. Once this routine - // returns the caller should not attempt further access of the object. - Release( TRUE); - bRelease = FALSE; - } - - // Start timer, if not already running. If the timer is not set at - // this point, it will be because nobody has been granted the exclusive - // lock. If someone was granted the exclusive lock, the timer would - // have been started above. We start it here so we can track idle - // time. - - if (pDbStats && !m_bStartTimeSet && !bRelease) - { - flmAssert( !m_bExclLock); - m_bStartTimeSet = TRUE; - f_timeGetTimeStamp( &m_StartTime); - } - - // If we get to this point and bRelease is still TRUE, someone was - // waiting to acquire the lock or there is still a shared lock - // count. - - if( bRelease) - { - // All lock waiters should have done an AddRef on the lock object. - // At this point we should still have our reference to the object, - // the lock manager's reference, and a reference from at least one - // waiter (that may have been granted above). - flmAssert( m_refCnt >= 3); - m_refCnt--; - } - - m_pServerLockMgr->unlockMutex( FALSE); - return( rc); -} - -/**************************************************************************** -Desc: Returns information about the pending lock requests. -****************************************************************************/ -void ServerLockObject::GetLockInfo( - FLMINT iPriority, - eDbLockType * peCurrLockType, - FLMUINT * puiThreadId, - FLMUINT * puiNumExclQueued, - FLMUINT * puiNumSharedQueued, - FLMUINT * puiPriorityCount) -{ - LOCK_WAITER_p pLockWaiter; - - *puiNumExclQueued = 0; - *puiNumSharedQueued = 0; - *puiPriorityCount = 0; - - m_pServerLockMgr->lockMutex( FALSE); - - // Get the type of lock, if any. - - if (m_bExclLock) - { - *peCurrLockType = SFLM_LOCK_EXCLUSIVE; - *puiThreadId = m_uiLockThreadId; - } - else if (m_uiSharedLockCnt) - { - *peCurrLockType = SFLM_LOCK_SHARED; - *puiThreadId = 0; - } - else - { - *peCurrLockType = SFLM_LOCK_NONE; - *puiThreadId = 0; - } - - // Get information on pending lock requests. - - pLockWaiter = m_pFirstLockWaiter; - for ( ; pLockWaiter; pLockWaiter = pLockWaiter->pNext ) - { - - // Count the number of exclusive and shared waiters. - - if (pLockWaiter->bExclReq) - { - (*puiNumExclQueued)++; - } - else - { - (*puiNumSharedQueued)++; - } - - // Count the number of waiters at or above input priority. - - if (pLockWaiter->iPriority >= iPriority) - { - (*puiPriorityCount)++; - } - } - - m_pServerLockMgr->unlockMutex( FALSE); -} - -/**************************************************************************** -Desc: Return the lock waiters for this object. -****************************************************************************/ -RCODE ServerLockObject::GetLockInfo( - IF_LockInfoClient * pLockInfo) -{ - RCODE rc = NE_SFLM_OK; - LOCK_WAITER * pLockWaiter; - FLMUINT uiCnt; - FLMUINT uiElapTime; - FLMUINT uiCurrTime; - FLMUINT uiMilli; - - m_pServerLockMgr->lockMutex( FALSE); - uiCurrTime = (FLMUINT)FLM_GET_TIMER(); - - if (!m_uiNumWaiters && !m_uiLockThreadId) - { - pLockInfo->setLockCount( 0); - goto Exit; - } - uiCnt = m_uiNumWaiters + 1; // Add one for lock holder. - if( pLockInfo->setLockCount( uiCnt) == FALSE) - { - goto Exit; - } - - // Output the lock holder first. - - uiElapTime = FLM_ELAPSED_TIME( uiCurrTime, m_uiLockTime); - uiMilli = FLM_TIMER_UNITS_TO_MILLI( uiElapTime); - if( pLockInfo->addLockInfo( 0, m_uiLockThreadId, uiMilli) == FALSE) - { - goto Exit; - } - uiCnt--; - - // Output the lock waiters. - - pLockWaiter = m_pFirstLockWaiter; - while( pLockWaiter && uiCnt) - { - uiElapTime = FLM_ELAPSED_TIME( uiCurrTime, pLockWaiter->uiWaitStartTime); - uiMilli = FLM_TIMER_UNITS_TO_MILLI( uiElapTime); - if( pLockInfo->addLockInfo( (m_uiNumWaiters - uiCnt) + 1, - pLockWaiter->uiThreadId, uiMilli) == FALSE) - { - goto Exit; - } - pLockWaiter = pLockWaiter->pNext; - uiCnt--; - } - flmAssert( pLockWaiter == NULL && uiCnt == 0); - -Exit: - - m_pServerLockMgr->unlockMutex( FALSE); - return( rc); -} - -/**************************************************************************** -Desc: Returns TRUE if there are lock waiters with a priority > iPriority -****************************************************************************/ -FLMBOOL ServerLockObject::haveHigherPriorityWaiter( - FLMINT iPriority) -{ - LOCK_WAITER_p pLockWaiter; - FLMBOOL bWaiters = FALSE; - - m_pServerLockMgr->lockMutex( FALSE); - - pLockWaiter = m_pFirstLockWaiter; - for ( ; pLockWaiter; pLockWaiter = pLockWaiter->pNext ) - { - // If we find a waiter with a priority > the specified - // priority, we're done. - - if (pLockWaiter->iPriority > iPriority) - { - bWaiters = TRUE; - break; - } - } - - m_pServerLockMgr->unlockMutex( FALSE); - return( bWaiters); -} diff --git a/sql/src/fsrvlock.h b/sql/src/fsrvlock.h deleted file mode 100644 index bdbd69a..0000000 --- a/sql/src/fsrvlock.h +++ /dev/null @@ -1,424 +0,0 @@ -//------------------------------------------------------------------------------ -// Desc: This include file contains the class definitions for FLAIM's -// ServerLockManager and ServerLockObject classes. -// -// Tabs: 3 -// -// Copyright (c) 1998-2006 Novell, Inc. All Rights Reserved. -// -// This program is free software; you can redistribute it and/or -// modify it under the terms of version 2 of the GNU General Public -// License as published by the Free Software Foundation. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program; if not, contact Novell, Inc. -// -// To contact Novell about this file by physical or electronic mail, -// you may find current contact information at www.novell.com -// -// $Id$ -//------------------------------------------------------------------------------ - -#ifndef FSRVLOCK_H -#define FSRVLOCK_H - -FLMUINT flmStrHashBucket( - char * pszStr, - FBUCKET * pHashTbl, - FLMUINT uiNumBuckets); - - /* - *** Define the 'C++' classes for FLAIM's File Handle cache code. - */ - -class ServerLockManager; // Forward Reference -class ServerLockObject; // Forward Reference -class F_ItemId; // Forward Reference -class FFileItemId; // Forward Reference -class RFileItemId; // Forward Reference - -typedef ServerLockManager * ServerLockManager_p; -typedef ServerLockObject * ServerLockObject_p; -typedef F_ItemId * F_ItemId_p; -typedef FFileItemId * FFileItemId_p; -typedef RFileItemId * RFileItemId_p; - -/************************************************************************** -Struct: LOCK_WAITER (Lock Waiter) -Desc: This structure is used to keep track of threads waiting for a - lock. -**************************************************************************/ -typedef struct Lock_Waiter * LOCK_WAITER_p; - -typedef struct Lock_Waiter -{ - ServerLockObject_p pLockObject; // Pointer to lock object. - FLMUINT uiThreadId; // Thread of waiter - F_SEM hESem; // Semaphore to signal when lock is - // granted (or denied). - RCODE * pRc; // Pointer to return code that is to - // be set when lock is granted or - // denied. - FLMUINT uiWaitStartTime; - // Time we started waiting. - FLMUINT uiWaitTime; // Time pending lock request should - // wait before being timed out. - // Zero means should not be timed out. - FLMBOOL bExclReq; // TRUE if exclusive lock request. - FLMINT iPriority; // Priority of waiter. - F_TMSTAMP StartTime; // Time we started waiting (for stats) - SFLM_DB_STATS * pDbStats; // Statistics to update. - LOCK_WAITER_p pNext; // Next lock waiter in list. - LOCK_WAITER_p pPrev; // Previous lock waiter in list. - LOCK_WAITER_p pNextGlobal; // Next lock waiter in global list - // that is ordered according to - // udWaitEndTime. - LOCK_WAITER_p pPrevGlobal; // Previous lock waiter in global list -} LOCK_WAITER; - -/*=========================================================================== -Class: ServerLockManager -Desc: The ServerLockManager class manages ServerLockObject objects. -===========================================================================*/ - -class ServerLockManager : public F_Object -{ -public: - - ServerLockManager() - { - m_hMutex = F_MUTEX_NULL; - m_pFirstLockWaiter = NULL; - m_pHashTbl = NULL; - m_uiNumAvail = 0; - m_pAvailLockList = NULL; - } - - virtual ~ServerLockManager(); // ServerLockManager Destructor - free - // ServerLockObjects owned by this - // ServerLockManager. - - FINLINE RCODE setupLockMgr( void) - { - return( f_mutexCreate( &m_hMutex)); - } - - RCODE SetupHashTbl(); // Setup hash table for lock manager. - - void CheckLockTimeouts( // See if any pending lock requests have - FLMBOOL bMutexAlreadyLocked, - FLMBOOL bTimeoutAll); // timed out. - - void InsertWaiter( // Insert waiter into global list. - LOCK_WAITER * pLockWaiter); - - FINLINE void RemoveWaiter( - LOCK_WAITER * pLockWaiter) - { - if (pLockWaiter->pNextGlobal) - pLockWaiter->pNextGlobal->pPrevGlobal = pLockWaiter->pPrevGlobal; - - if (pLockWaiter->pPrevGlobal) - { - pLockWaiter->pPrevGlobal->pNextGlobal = pLockWaiter->pNextGlobal; - } - else - { - m_pFirstLockWaiter = pLockWaiter->pNextGlobal; - } - } - - ServerLockObject_p GetLockObject(// Return a lock object for the file. - F_ItemId * pItemId); - - void SignalLockWaiter( // Unlink a lock object from lists - FLMUINT uiThreadId); - - void UnlinkLockObject( // Unlink a lock object from lists - ServerLockObject * pLockObject, - FLMBOOL bPutInAvailList); - - FINLINE void lockMutex( - FLMBOOL bMutexAlreadyLocked) - { - if (m_hMutex != F_MUTEX_NULL && !bMutexAlreadyLocked) - { - f_mutexLock( m_hMutex); - } - } - - FINLINE void unlockMutex( - FLMBOOL bMutexAlreadyLocked) - { - if (m_hMutex != F_MUTEX_NULL && !bMutexAlreadyLocked) - { - f_mutexUnlock( m_hMutex); - } - } - -private: - - // Private variables - - F_MUTEX m_hMutex; - FBUCKET * m_pHashTbl; // Hash table. - LOCK_WAITER * m_pFirstLockWaiter; // Pointer to first in list of global - // lock waiters. - FLMUINT m_uiNumAvail; // Number of lock objects in avail - // list. - ServerLockObject * - m_pAvailLockList; // List of available lock objects. - -friend class F_ServerLockMgrPage; -friend class ServerLockObject; - -}; - -/*=========================================================================== -Class: F_ItemId -Desc: The item id that identifies a particular object. -===========================================================================*/ -class F_ItemId : public F_Object -{ -public: - F_ItemId(); // F_ItemId Constructor - - virtual ~F_ItemId(); // F_ItemId Destructor - - virtual FLMBOOL IsEqual( // Compare to another F_ItemId. - F_ItemId * pItemId) = 0; - - virtual FLMUINT GetHashBucket( // Get hash bucket for lock item id - FBUCKET * pHashTbl, - FLMUINT uiHashTblSize) = 0; - - FLMUINT GetItemType() // Returns the type of item. - { return m_uiItemType; } - -protected: - FLMUINT m_uiItemType; // Item type. -#define FFILE_ITEM 1 -#define RFILE_ITEM 2 -#define FFILE_TRANS_ITEM 3 -#define RFILE_TRANS_ITEM 4 -}; - - - /* - Public: constructor, destructor - */ - FINLINE F_ItemId::F_ItemId() - { - m_uiItemType = 0; - } - - FINLINE F_ItemId::~F_ItemId() - { - } - -/*=========================================================================== -Class: FFileItemId -Desc: The item id that identifies an FFILE object. -===========================================================================*/ -class FFileItemId : public F_ItemId -{ -public: - - // Constructor - - FFileItemId( - F_Database * pDatabase, - FLMBOOL bTrans) - { - m_pDatabase = pDatabase; - m_uiItemType = (FLMUINT)(bTrans - ? (FLMUINT)FFILE_TRANS_ITEM - : (FLMUINT)FFILE_ITEM); - } - - virtual ~FFileItemId() - { - } - - FLMBOOL IsEqual( // Compare to another F_ItemId. - F_ItemId * pItemId); - - FINLINE FLMUINT GetHashBucket( - FBUCKET * pHashTbl, - FLMUINT uiHashTblSize) - { - char szFileName[ F_PATH_MAX_SIZE]; - - // Extract the file name - - this->GetFileName( szFileName); - - // Determine what hash bucket the file should be in - based on file name. - - return( flmStrHashBucket( szFileName, pHashTbl, uiHashTblSize)); - } - - FINLINE F_Database * getDatabase( void) // was GetFilePtr - { - return m_pDatabase; - } - - void GetFileName( // Returns file name - char * pszFileNameRV); - -private: - F_Database * m_pDatabase; -}; - -/*=========================================================================== -Class: RFileItemId -Desc: The item id that identifies a file being used by rebuild. -===========================================================================*/ -class RFileItemId : public F_ItemId -{ -public: - RFileItemId( // RFileItemId Constructor - char * pszFileName, - FLMBOOL bTrans = FALSE); - - virtual ~RFileItemId() // RFileItemId Destructor - { - } - - FLMBOOL IsEqual( // Compare to another F_ItemId. - F_ItemId * pItemId); - - FINLINE FLMUINT GetHashBucket( // Get hash bucket for lock item id - FBUCKET * pHashTbl, - FLMUINT uiHashTblSize) - { - // Determine what hash bucket the file should be in - based on file name. - - return( flmStrHashBucket( m_szFileName, pHashTbl, uiHashTblSize)); - } - - FINLINE void GetFileName( // Returns file name - char * pszFileNameRV) - { - f_strcpy( pszFileNameRV, m_szFileName); - } - -private: - char m_szFileName [F_PATH_MAX_SIZE]; // File's name. -}; - -/*=========================================================================== -Desc: The ServerLockObject is used to lock and unlock a particular - object. -===========================================================================*/ -class ServerLockObject : public F_Object -{ -public: - ServerLockObject(); // ServerLockObject Constructor - - virtual ~ServerLockObject() - { - if( m_pItemId) - { - m_pItemId->Release(); - } - } - - void Setup( - ServerLockManager * pServerLockMgr, - F_ItemId * pItemId, - FLMUINT uiBucket); - - RCODE Lock( - F_Db * pDb, - F_SEM hWaitSem, - FLMBOOL bLogEvent, - FLMBOOL bSendSuspendEvent, // Send suspend event when waiting - // for lock. - FLMBOOL bExclLock, // Exclusive or shared lock? - FLMUINT uiMaxWaitSecs, // Maximum wait time in seconds. - FLMINT iPriority, // Lock priority - SFLM_DB_STATS * pDbStats = NULL); // Place to gather DB stats. - - RCODE Unlock( - FLMBOOL bLogEvent, - F_Db * pDb, // used for event callbacks. - FLMBOOL bRelease = FALSE, // Release object if no one is waiting - SFLM_DB_STATS * pDbStats = NULL); // Place to gather DB stats. - - FLMINT Release( - FLMBOOL bMutexAlreadyLocked); - // Decrement ref count, when it gets - // down to 1, put it in the avail list. - - FLMINT Release( void) - { - return( Release( FALSE)); - } - - void RemoveWaiter( - LOCK_WAITER * pLockWaiter); - - FLMBOOL ThreadWaitingLock( void) - { - return( ((m_pFirstLockWaiter) ? (FLMBOOL)TRUE : (FLMBOOL)FALSE) ); - } - - FLMUINT LockCnt( void) - { - return( m_uiLockCnt); - } - - void GetLockInfo( // Returns lock information - FLMINT iPriority, // A count of all lock requests with - // a priority >= to this will be returned - // in pLockInfo. - eDbLockType * peCurrLockType, - FLMUINT * puiThreadId, - FLMUINT * puiNumExclQueued, - FLMUINT * puiNumSharedQueued, - FLMUINT * puiPriorityCount); - - RCODE GetLockInfo( - IF_LockInfoClient * pLockInfo); - - FLMBOOL haveHigherPriorityWaiter( - FLMINT iPriority); - -private: - - ServerLockManager * m_pServerLockMgr; // Server Lock Manager pointer. - F_ItemId * m_pItemId; // ID for object this lock - // object represents - FLMUINT m_uiLockThreadId; // Thread of thread that has this - // object locked. Zero if none. - FLMUINT m_uiLockTime; // Time lock was granted, if - // exclusive lock. - FLMUINT m_uiLockCnt; // Number of locks that have been - // granted thus far. - LOCK_WAITER * m_pFirstLockWaiter; - // Pointer to first in list of - // lock waiters. - LOCK_WAITER * m_pLastLockWaiter;// Pointer to last in list of - // lock waiters. - FLMUINT m_uiNumWaiters; // Number of threads waiting. - ServerLockObject * m_pNext; // Next in hash bucket or avail list - ServerLockObject * m_pPrev; // Prev in hash bucket or avail list - FLMUINT m_uiSharedLockCnt;// Number of shared locks that have - // been granted. - FLMBOOL m_bExclLock; // Is the granted lock exclusive? - FLMUINT m_uiBucket; // Hash bucket this object is in. - // 0xFFFF means it is in avail list. - F_TMSTAMP m_StartTime; // Time exclusive lock was grabbed. - FLMBOOL m_bStartTimeSet; // Was m_StartTime set? - -friend class ServerLockManager; - -}; - -#endif // FSRVLOCK_H diff --git a/sql/src/fstructs.h b/sql/src/fstructs.h index f679507..947a4be 100644 --- a/sql/src/fstructs.h +++ b/sql/src/fstructs.h @@ -40,8 +40,6 @@ class F_SuperFileHdl; class F_Btree; class F_DbRebuild; class F_DbCheck; -class ServerLockManager; -class ServerLockObject; class F_FileHdlMgr; class F_Cursor; class F_MultiAlloc; @@ -561,13 +559,19 @@ public: const char * pszDbPath, const char * pszDataDir); - RCODE dbWriteLock( + FINLINE RCODE dbWriteLock( F_SEM hWaitSem, - SFLM_DB_STATS * pDbStats = NULL, - FLMUINT uiTimeout = SFLM_NO_TIMEOUT); + SFLM_DB_STATS * pDbStats, + FLMUINT uiTimeout) + { + return( m_pWriteLockObj->lock( hWaitSem, + TRUE, uiTimeout, 0, pDbStats ? &pDbStats->LockStats : NULL)); + } - void dbWriteUnlock( - SFLM_DB_STATS * pDbStats = NULL); + FINLINE void dbWriteUnlock( void) + { + (void)m_pWriteLockObj->unlock(); + } void shutdownDatabaseThreads( void); @@ -1074,8 +1078,8 @@ private: // between blocks. FLMBYTE * m_pucReplaceStruct; // Buffer used by the Btree to hold additional // replace information during updates *only*. - ServerLockObject * m_pDatabaseLockObj; // Object for locking the database. - ServerLockObject * m_pWriteLockObj; // Object for locking to do writing. + IF_LockObject * m_pDatabaseLockObj; // Object for locking the database. + IF_LockObject * m_pWriteLockObj; // Object for locking to do writing. IF_FileHdl * m_pLockFileHdl; // Lock file handle. FNOTIFY * m_pLockNotifies; // Pointer to a list of notifies to // perform when this database is finally @@ -1129,7 +1133,6 @@ friend class F_Btree; friend class F_Dict; friend class F_DbSystem; friend class F_Backup; -friend class FFileItemId; friend class F_Row; friend class F_BTreeIStream; friend class F_DbRebuild; @@ -1208,8 +1211,6 @@ typedef struct FLMSYSDATA // OK To do async writes, if available. FLMBOOL bOkToUseESM; // OK to use Extended Server Memory, // if available - ServerLockManager * pServerLockMgr; - // Pointer to server lock manager. FLMUINT uiMaxCPInterval; // Maximum number of seconds to allow between // checkpoints diff --git a/sql/src/fsuperfl.h b/sql/src/fsuperfl.h index 250ef25..3007811 100644 --- a/sql/src/fsuperfl.h +++ b/sql/src/fsuperfl.h @@ -27,8 +27,6 @@ #ifndef FSUPERFL_H #define FSUPERFL_H -#include "fsrvlock.h" - #define MAX_CHECKED_OUT_FILE_HDLS 8 void bldSuperFileExtension( diff --git a/sql/src/fsysdata.cpp b/sql/src/fsysdata.cpp index 0023b6f..d4307d8 100644 --- a/sql/src/fsysdata.cpp +++ b/sql/src/fsysdata.cpp @@ -497,37 +497,6 @@ void F_Database::logMustCloseReason( } } -/**************************************************************************** -Desc: Acquires a write lock on the database -****************************************************************************/ -RCODE F_Database::dbWriteLock( - F_SEM hWaitSem, - SFLM_DB_STATS * pDbStats, - FLMUINT uiTimeout) -{ - RCODE rc = NE_SFLM_OK; - - if (RC_BAD( rc = m_pWriteLockObj->Lock( NULL, hWaitSem, FALSE, - (FLMBOOL)(uiTimeout ? TRUE : FALSE), - TRUE, uiTimeout, 0, pDbStats))) - { - goto Exit; - } - -Exit: - - return( rc); -} - -/**************************************************************************** -Desc: This routine unlocks the write lock on a database. -****************************************************************************/ -void F_Database::dbWriteUnlock( - SFLM_DB_STATS * pDbStats) -{ - (void)m_pWriteLockObj->Unlock( FALSE, NULL, FALSE, pDbStats); -} - /**************************************************************************** Desc: This shuts down the background threads Note: This routine assumes that the global mutex is locked. The mutex will @@ -656,35 +625,6 @@ FSTATIC void flmFreeEvent( f_free( &pEvent); } -/**************************************************************************** -Desc: This routine determines the hash bucket for a string. -****************************************************************************/ -FLMUINT flmStrHashBucket( - char * pszStr, // Pointer to string to be hashed - FBUCKET * pHashTbl, // Hash table to use - FLMUINT uiNumBuckets) // Number of hash buckets -{ - FLMUINT uiHashIndex; - - if ((uiHashIndex = (FLMUINT)*pszStr) >= uiNumBuckets) - { - uiHashIndex -= uiNumBuckets; - } - - while (*pszStr) - { - if ((uiHashIndex = - (FLMUINT)((pHashTbl [uiHashIndex].uiHashValue) ^ (FLMUINT)(f_toupper( *pszStr)))) >= - uiNumBuckets) - { - uiHashIndex -= uiNumBuckets; - } - pszStr++; - } - - return( uiHashIndex); -} - /**************************************************************************** Desc: This routine links a notify request into a notification list and then waits to be notified that the event has occurred. @@ -732,7 +672,7 @@ RCODE F_Database::linkToBucket( void) FLMUINT uiBucket; pBucket = gv_SFlmSysData.pDatabaseHashTbl; - uiBucket = flmStrHashBucket( m_pszDbPath, pBucket, FILE_HASH_ENTRIES); + uiBucket = f_strHashBucket( m_pszDbPath, pBucket, FILE_HASH_ENTRIES); pBucket = &pBucket [uiBucket]; if (pBucket->pFirstInBucket) { @@ -955,12 +895,6 @@ RCODE F_DbSystem::monitorThrd( uiCurrTime = uiLastUnusedCleanupTime = FLM_GET_TIMER(); } - // Call the lock manager to check timeouts. It is critial - // that this routine be called on a regular interval to - // timeout lock waiters that have expired. - - gv_SFlmSysData.pServerLockMgr->CheckLockTimeouts( FALSE, FALSE); - // Check the adjusting cache limit (void)gv_SFlmSysData.pGlobalCacheMgr->adjustCache( &uiCurrTime, @@ -1503,26 +1437,6 @@ RCODE F_DbSystem::init( void) flmDbgLogInit(); #endif - // Allocate and Initialize FLAIM Server Lock Manager. - - if ((gv_SFlmSysData.pServerLockMgr = f_new ServerLockManager) == NULL) - { - rc = RC_SET( NE_SFLM_MEM); - goto Exit; - } - - if (RC_BAD( rc = gv_SFlmSysData.pServerLockMgr->setupLockMgr())) - { - goto Exit; - } - - // Set up hash table for lock manager. - - if (RC_BAD( rc = gv_SFlmSysData.pServerLockMgr->SetupHashTbl())) - { - goto Exit; - } - // Set up mutexes for the event table. for (iEventCategory = 0; @@ -1745,33 +1659,6 @@ void F_DbSystem::cleanup( void) f_mutexDestroy( &gv_SFlmSysData.hStatsMutex); } - // Free (release) FLAIM's Server Lock Manager. - - if (gv_SFlmSysData.pServerLockMgr) - { - FLMUINT uiRefCnt; - - // Release all locks. - - gv_SFlmSysData.pServerLockMgr->CheckLockTimeouts( FALSE, TRUE); - - // Release the lock manager. - - uiRefCnt = gv_SFlmSysData.pServerLockMgr->Release(); - - // No one else should have a reference to the server lock manager - // at this point, so lets trip a flmAssert if the object was really - // not deleted. - -#ifdef FLM_DEBUG - flmAssert( 0 == uiRefCnt); -#else - // Quiet the compiler about the unused variable - (void)uiRefCnt; -#endif - gv_SFlmSysData.pServerLockMgr = NULL; - } - // Make sure the purge list is empty if( gv_SFlmSysData.pRowCacheMgr->m_pPurgeList) diff --git a/sql/src/rfl.cpp b/sql/src/rfl.cpp index e08448b..ce66ed9 100644 --- a/sql/src/rfl.cpp +++ b/sql/src/rfl.cpp @@ -2027,7 +2027,7 @@ RCODE F_Rfl::finishCurrFile( // Lock the database - need to prevent update // transactions and checkpoint thread from running. - if (RC_BAD( rc = pDb->lockExclusive( SFLM_NO_TIMEOUT))) + if (RC_BAD( rc = pDb->lockExclusive( FLM_NO_TIMEOUT))) { goto Exit; } diff --git a/sql/src/scache.cpp b/sql/src/scache.cpp index 7179770..7f0db66 100644 --- a/sql/src/scache.cpp +++ b/sql/src/scache.cpp @@ -1259,7 +1259,7 @@ RCODE F_Database::flushLogBlocks( } else { - if (m_pWriteLockObj->ThreadWaitingLock() && + if (m_pWriteLockObj->getWaiterCount() && uiDirtyCacheLeft <= uiMaxDirtyCache) { bDone = TRUE; @@ -4191,7 +4191,7 @@ Add_Contiguous_Block: } else { - if (m_pWriteLockObj->ThreadWaitingLock() && + if (m_pWriteLockObj->getWaiterCount() && *puiDirtyCacheLeft <= uiMaxDirtyCache) {