diff --git a/xflaim/src/fdbcnfig.cpp b/xflaim/src/fdbcnfig.cpp index 23047a3..29f8ea2 100644 --- a/xflaim/src/fdbcnfig.cpp +++ b/xflaim/src/fdbcnfig.cpp @@ -64,7 +64,7 @@ RCODE FLMAPI F_Db::setRflKeepFilesFlag( if (!(m_uiFlags & (FDB_HAS_FILE_LOCK | FDB_FILE_LOCK_SHARED))) { - if (RC_BAD( rc = dbLock( XFLM_LOCK_EXCLUSIVE, 0, + if (RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, XFLM_NO_TIMEOUT))) { goto Exit; @@ -175,7 +175,7 @@ RCODE FLMAPI F_Db::setRflDir( if (!(m_uiFlags & (FDB_HAS_FILE_LOCK | FDB_FILE_LOCK_SHARED))) { - if( RC_BAD( rc = dbLock( XFLM_LOCK_EXCLUSIVE, 0, + if( RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, XFLM_NO_TIMEOUT))) { goto Exit; @@ -1273,7 +1273,7 @@ RCODE FLMAPI 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/xflaim/src/fdbcopy.cpp b/xflaim/src/fdbcopy.cpp index 8203f0c..6fccd3d 100644 --- a/xflaim/src/fdbcopy.cpp +++ b/xflaim/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( XFLM_LOCK_EXCLUSIVE, 0, XFLM_NO_TIMEOUT))) + if (RC_BAD( rc = pDb->dbLock( FLM_LOCK_EXCLUSIVE, 0, XFLM_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 currLockType; 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, - &eCurrLockType, + pDatabase->m_pDatabaseLockObj->getLockInfo( (FLMINT)0, + &currLockType, &uiThreadId, &uiNumExclQueued, &uiNumSharedQueued, &uiPriorityCount); - if (eCurrLockType != XFLM_LOCK_EXCLUSIVE || + if (currLockType != 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, - &eCurrLockType, + pDatabase->m_pWriteLockObj->getLockInfo( (FLMINT)0, + &currLockType, &uiThreadId, &uiNumExclQueued, &uiNumSharedQueued, &uiPriorityCount); - if (eCurrLockType != XFLM_LOCK_EXCLUSIVE || + if (currLockType != FLM_LOCK_EXCLUSIVE || uiThreadId != (FLMUINT)f_threadId()) { pWriteLockObj = pDatabase->m_pWriteLockObj; @@ -616,23 +616,24 @@ Exit: { RCODE rc3; - if (RC_BAD( rc3 = pDatabaseLockObj->Unlock( TRUE, NULL))) + if (RC_BAD( rc3 = pDatabaseLockObj->unlock())) { if (RC_OK( rc)) rc = rc3; } + bDatabaseLocked = FALSE; } if (pWriteLockObj) { - pWriteLockObj->Release( FALSE); + pWriteLockObj->Release(); pWriteLockObj = NULL; } if (pDatabaseLockObj) { - pDatabaseLockObj->Release( FALSE); + pDatabaseLockObj->Release(); pDatabaseLockObj = NULL; } diff --git a/xflaim/src/flaimsys.h b/xflaim/src/flaimsys.h index de4553b..8c2d42c 100644 --- a/xflaim/src/flaimsys.h +++ b/xflaim/src/flaimsys.h @@ -98,7 +98,6 @@ class F_RebuildNodeIStream; #include "flmstat.h" #include "fxpath.h" #include "fbtrset.h" -#include "fsrvlock.h" #include "fquery.h" #include "fcollate.h" #include "f_btree.h" @@ -1878,19 +1877,19 @@ public: FLMUINT uiTimeout); RCODE FLMAPI dbLock( - eDbLockType eLockType, + eLockType lockType, FLMINT iPriority, FLMUINT uiTimeout); RCODE FLMAPI dbUnlock( void); RCODE FLMAPI getLockType( - eDbLockType * peLockType, + eLockType * pLockType, FLMBOOL * pbImplicit); RCODE FLMAPI getLockInfo( FLMINT iPriority, - eDbLockType * peCurrLockType, + eLockType * pCurrLockType, FLMUINT * puiThreadId, FLMUINT * puiNumExclQueued, FLMUINT * puiNumSharedQueued, @@ -2425,7 +2424,7 @@ public: FINLINE FLMBOOL threadWaitingLock( void) { - return( m_pDatabase->m_pDatabaseLockObj->ThreadWaitingLock()); + return( m_pDatabase->m_pDatabaseLockObj->getWaiterCount() ? TRUE : FALSE); } RCODE FLMAPI getLockWaiters( @@ -3292,7 +3291,6 @@ friend class F_BlockCacheMgr; friend class F_NodeCacheMgr; friend class F_GlobalCacheMgr; friend class F_QueryResultSet; -friend class ServerLockObject; friend class F_BTreeInfo; friend class F_AttrItem; }; diff --git a/xflaim/src/flbackup.cpp b/xflaim/src/flbackup.cpp index 47c9666..64402ba 100644 --- a/xflaim/src/flbackup.cpp +++ b/xflaim/src/flbackup.cpp @@ -617,7 +617,8 @@ RCODE F_Backup::backup( if ((m_pDb->m_uiFlags & FDB_HAS_FILE_LOCK) == 0) { - if (RC_BAD( rc = m_pDb->dbLock(XFLM_LOCK_EXCLUSIVE, 0, XFLM_NO_TIMEOUT))) + if (RC_BAD( rc = m_pDb->dbLock( FLM_LOCK_EXCLUSIVE, + 0, XFLM_NO_TIMEOUT))) { goto Exit; } diff --git a/xflaim/src/flblddb.cpp b/xflaim/src/flblddb.cpp index fd4ddff..9893ef9 100644 --- a/xflaim/src/flblddb.cpp +++ b/xflaim/src/flblddb.cpp @@ -331,11 +331,11 @@ RCODE F_DbRebuild::dbRebuild( F_Database * pDatabase = NULL; FLMBOOL bDatabaseLocked = FALSE; FLMBOOL bWriteLocked = FALSE; - ServerLockObject * pWriteLockObj = NULL; - ServerLockObject * pDatabaseLockObj = NULL; + IF_LockObject * pWriteLockObj = NULL; + IF_LockObject * pDatabaseLockObj = NULL; FLMBOOL bMutexLocked = FALSE; IF_FileHdl * pLockFileHdl = NULL; - eDbLockType eCurrLockType; + eLockType currLockType; FLMUINT uiThreadId; FLMUINT uiNumExclQueued; FLMUINT uiNumSharedQueued; @@ -416,18 +416,18 @@ Retry: // make sure there is no write lock. If there is, // we cannot do the rebuild right now. - pDatabase->m_pDatabaseLockObj->GetLockInfo( (FLMINT)0, &eCurrLockType, + pDatabase->m_pDatabaseLockObj->getLockInfo( 0, &currLockType, &uiThreadId, &uiNumExclQueued, &uiNumSharedQueued, &uiPriorityCount); - if( eCurrLockType == XFLM_LOCK_EXCLUSIVE && uiThreadId == f_threadId()) + if( currLockType == FLM_LOCK_EXCLUSIVE && uiThreadId == f_threadId()) { // See if there is already a transaction going. - pDatabase->m_pWriteLockObj->GetLockInfo( (FLMINT)0, &eCurrLockType, + pDatabase->m_pWriteLockObj->getLockInfo( (FLMINT)0, &currLockType, &uiThreadId, &uiNumExclQueued, &uiNumSharedQueued, &uiPriorityCount); - if( eCurrLockType == XFLM_LOCK_EXCLUSIVE && + if( currLockType == FLM_LOCK_EXCLUSIVE && uiThreadId == f_threadId()) { rc = RC_SET( NE_XFLM_TRANS_ACTIVE); @@ -439,8 +439,8 @@ Retry: pDatabaseLockObj = pDatabase->m_pDatabaseLockObj; pDatabaseLockObj->AddRef(); - if (RC_BAD( rc = pDatabaseLockObj->Lock( NULL, hWaitSem, - TRUE, FALSE, TRUE, XFLM_NO_TIMEOUT, 0))) + if (RC_BAD( rc = pDatabaseLockObj->lock( hWaitSem, + TRUE, XFLM_NO_TIMEOUT, 0))) { goto Exit; } @@ -750,7 +750,7 @@ Exit: { RCODE rc3; - if( RC_BAD( rc3 = pDatabaseLockObj->Unlock( TRUE, NULL))) + if( RC_BAD( rc3 = pDatabaseLockObj->unlock())) { if (RC_OK( rc)) { @@ -763,13 +763,13 @@ Exit: if( pWriteLockObj) { - pWriteLockObj->Release( FALSE); + pWriteLockObj->Release(); pWriteLockObj = NULL; } if( pDatabaseLockObj) { - pDatabaseLockObj->Release( FALSE); + pDatabaseLockObj->Release(); pDatabaseLockObj = NULL; } diff --git a/xflaim/src/flclose.cpp b/xflaim/src/flclose.cpp index 7905054..7227dfd 100644 --- a/xflaim/src/flclose.cpp +++ b/xflaim/src/flclose.cpp @@ -163,7 +163,7 @@ Retry: } pBucket = gv_XFlmSysData.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/xflaim/src/flconvrt.cpp b/xflaim/src/flconvrt.cpp index eabd3ef..e846865 100644 --- a/xflaim/src/flconvrt.cpp +++ b/xflaim/src/flconvrt.cpp @@ -48,7 +48,7 @@ RCODE FLMAPI F_Db::upgrade( if (!(m_uiFlags & FDB_HAS_FILE_LOCK)) { - if (RC_BAD( rc = dbLock( XFLM_LOCK_EXCLUSIVE, 0, 15))) + if (RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, 15))) { goto Exit; } @@ -241,7 +241,7 @@ RCODE FLMAPI F_Db::enableEncryption( void) if (!(m_uiFlags & FDB_HAS_FILE_LOCK)) { - if ( RC_BAD( rc = dbLock( XFLM_LOCK_EXCLUSIVE, 0, XFLM_NO_TIMEOUT))) + if ( RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, XFLM_NO_TIMEOUT))) { goto Exit; } @@ -372,7 +372,7 @@ RCODE FLMAPI F_Db::wrapKey( if( !(m_uiFlags & FDB_HAS_FILE_LOCK)) { - if ( RC_BAD( rc = dbLock( XFLM_LOCK_EXCLUSIVE, 0, XFLM_NO_TIMEOUT))) + if ( RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, XFLM_NO_TIMEOUT))) { goto Exit; } @@ -578,7 +578,7 @@ RCODE FLMAPI F_Db::rollOverDbKey( void) if (!(m_uiFlags & FDB_HAS_FILE_LOCK)) { - if ( RC_BAD( rc = dbLock( XFLM_LOCK_EXCLUSIVE, 0, XFLM_NO_TIMEOUT))) + if ( RC_BAD( rc = dbLock( FLM_LOCK_EXCLUSIVE, 0, XFLM_NO_TIMEOUT))) { goto Exit; } diff --git a/xflaim/src/flindex.cpp b/xflaim/src/flindex.cpp index 1f80a06..028b3c5 100644 --- a/xflaim/src/flindex.cpp +++ b/xflaim/src/flindex.cpp @@ -656,9 +656,9 @@ Notes: This routine DOES NOT assume that the global mutex is locked. It will lock and unlock the mutex as needed. ****************************************************************************/ void F_Db::stopBackgroundIndexThread( - FLMUINT uiIndexNum, - FLMBOOL bWait, - FLMBOOL * pbStopped) + FLMUINT uiIndexNum, + FLMBOOL bWait, + FLMBOOL * pbStopped) { F_BKGND_IX * pBackgroundIx; FLMUINT uiThreadId; @@ -702,8 +702,9 @@ void F_Db::stopBackgroundIndexThread( // The thread may be waiting to start a transaction. - gv_XFlmSysData.pServerLockMgr->SignalLockWaiter( uiThreadId); - + m_pDatabase->m_pDatabaseLockObj->timeoutLockWaiter( uiThreadId); + m_pDatabase->m_pWriteLockObj->timeoutLockWaiter( uiThreadId); + if( !bWait) { break; diff --git a/xflaim/src/flmstat.cpp b/xflaim/src/flmstat.cpp index f4432d0..0687fa8 100644 --- a/xflaim/src/flmstat.cpp +++ b/xflaim/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/xflaim/src/flmstat.h b/xflaim/src/flmstat.h index ad3cbb0..070303d 100644 --- a/xflaim/src/flmstat.h +++ b/xflaim/src/flmstat.h @@ -125,8 +125,8 @@ void flmAddElapTime( // Source: flmstat.cpp } FINLINE void flmUpdateCountTimeStats( - XFLM_COUNT_TIME_STAT * pDest, - XFLM_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/xflaim/src/flopen.cpp b/xflaim/src/flopen.cpp index fdfe12e..fd7ad64 100644 --- a/xflaim/src/flopen.cpp +++ b/xflaim/src/flopen.cpp @@ -524,7 +524,6 @@ RCODE flmCreateLckFile( char * pszFileExt; IF_FileHdl * pLockFileHdl = NULL; char szFilePathStr[ F_PATH_MAX_SIZE]; - FLMUINT uiIoFlags; if( RC_BAD( rc = gv_XFlmSysData.pFileSystem->pathToStorageString( pszFilePath, szFilePathStr))) @@ -545,67 +544,30 @@ RCODE flmCreateLckFile( pszFileExt++; f_strcpy( pszFileExt, ".lck"); - if (RC_BAD( rc = gv_XFlmSysData.pFileSystem->pathAppend( + if( RC_BAD( rc = gv_XFlmSysData.pFileSystem->pathAppend( szLockPath, szDbBaseName))) { goto Exit; } - - // Attempt to create the lock file. If that succeeds, we are - // OK to use the database. If it fails, the lock file may have - // been left because of a crash if FLAIM was not shut down properly. - // Hence, we first try to delete the file. If that succeeds, we - // then attempt to create the file again. If it, or the 2nd create - // fail, we simply return an access denied error. - -uiIoFlags = FLM_IO_RDWR | FLM_IO_EXCL | FLM_IO_SH_DENYRW; -#ifndef FLM_UNIX - uiIoFlags |= FLM_IO_DELETE_ON_RELEASE; -#endif - - if( RC_BAD( gv_XFlmSysData.pFileSystem->createFile( - szLockPath, uiIoFlags, &pLockFileHdl))) + + if( RC_BAD( rc = gv_XFlmSysData.pFileSystem->createLockFile( + szLockPath, &pLockFileHdl))) { -#ifndef FLM_UNIX - if (RC_BAD( gv_XFlmSysData.pFileSystem->deleteFile( szLockPath))) - { - rc = RC_SET( NE_FLM_IO_ACCESS_DENIED); - goto Exit; - } - else if (RC_BAD( gv_XFlmSysData.pFileSystem->createFile( - szLockPath, uiIoFlags, &pLockFileHdl))) - { - rc = RC_SET( NE_FLM_IO_ACCESS_DENIED); - goto Exit; - } -#else - - if( RC_BAD( gv_XFlmSysData.pFileSystem->openFile( - szLockPath, FLM_IO_RDWR | FLM_IO_SH_DENYRW, &pLockFileHdl))) - { - rc = RC_SET( NE_FLM_IO_ACCESS_DENIED); - goto Exit; - } -#endif - } - -#ifdef FLM_UNIX - if( RC_BAD( pLockFileHdl->lock())) - { - rc = RC_SET( NE_FLM_IO_ACCESS_DENIED); goto Exit; } -#endif *ppLockFileHdlRV = (IF_FileHdl *)pLockFileHdl; pLockFileHdl = NULL; + Exit: + if (pLockFileHdl) { (void)pLockFileHdl->close(); pLockFileHdl->Release(); pLockFileHdl = NULL; } + return( rc); } @@ -869,7 +831,7 @@ Retry: } pBucket = gv_XFlmSysData.pDatabaseHashTbl; - uiBucket = flmStrHashBucket( szDbPathStr1, pBucket, FILE_HASH_ENTRIES); + uiBucket = f_strHashBucket( szDbPathStr1, pBucket, FILE_HASH_ENTRIES); pDatabase = (F_Database *)pBucket [uiBucket].pFirstInBucket; while (pDatabase) { @@ -1247,7 +1209,7 @@ F_Database::~F_Database() if (m_pWriteLockObj) { - m_pWriteLockObj->Release( FALSE); + m_pWriteLockObj->Release(); m_pWriteLockObj = NULL; } @@ -1381,8 +1343,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]; @@ -1468,52 +1428,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_XFLM_MEM); - goto Exit; - } - if ((pFileItemId2 = f_new FFileItemId( this, FALSE)) == NULL) - { - rc = RC_SET( NE_XFLM_MEM); - goto Exit; - } - // Allocate a lock object for write locking. - - if ((m_pWriteLockObj = gv_XFlmSysData.pServerLockMgr->GetLockObject( - pFileItemId1)) == NULL) + + if( RC_BAD( rc = FlmAllocLockObject( &m_pWriteLockObj))) { - rc = RC_SET( NE_XFLM_MEM); goto Exit; } - m_pWriteLockObj->AddRef(); // Allocate a lock object for file locking. - - if ((m_pDatabaseLockObj = gv_XFlmSysData.pServerLockMgr->GetLockObject( - pFileItemId2)) == NULL) + + if( RC_BAD( rc = FlmAllocLockObject( &m_pDatabaseLockObj))) { - rc = RC_SET( NE_XFLM_MEM); goto Exit; } - m_pDatabaseLockObj->AddRef(); - + Exit: - if (pFileItemId1) - { - pFileItemId1->Release(); - } - - if (pFileItemId2) - { - pFileItemId2->Release(); - } - return( rc); } @@ -1883,7 +1813,7 @@ FLMBOOL F_Database::tryCheckpoint( m_lastCommittedDbHdr.ui64CurrTransID || !m_pRfl->seeIfRflWritesDone( pCPInfo->hWaitSem, FALSE)) { - dbWriteUnlock( pDbStats); + dbWriteUnlock(); goto Exit; } } @@ -1897,7 +1827,7 @@ FLMBOOL F_Database::tryCheckpoint( (void)flmStatUpdate( &pCPInfo->Stats); } - dbWriteUnlock( pDbStats); + dbWriteUnlock(); // Set the thread's status diff --git a/xflaim/src/flreduce.cpp b/xflaim/src/flreduce.cpp index ee28bf1..86717a1 100644 --- a/xflaim/src/flreduce.cpp +++ b/xflaim/src/flreduce.cpp @@ -79,8 +79,8 @@ RCODE FLMAPI 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, XFLM_NO_TIMEOUT, 0, m_pDbStats))) + if (RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->lock( m_hWaitSem, + TRUE, XFLM_NO_TIMEOUT, 0, m_pDbStats ? &m_pDbStats->LockStats : NULL))) { 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/xflaim/src/fltrbeg.cpp b/xflaim/src/fltrbeg.cpp index b091b74..6af77ad 100644 --- a/xflaim/src/fltrbeg.cpp +++ b/xflaim/src/fltrbeg.cpp @@ -713,7 +713,7 @@ Area : TRANSACTION Desc : Obtains a a lock on the database. *END************************************************************************/ RCODE FLMAPI F_Db::dbLock( - eDbLockType eLockType, + eLockType lockType, // [IN] Type of lock request - must be FLM_LOCK_EXCLUSIVE or // FLM_LOCK_SHARED FLMINT iPriority, @@ -725,9 +725,9 @@ RCODE FLMAPI F_Db::dbLock( { RCODE rc = NE_XFLM_OK; - // eLockType better be exclusive or shared + // lockType better be exclusive or shared - if (eLockType != XFLM_LOCK_EXCLUSIVE && eLockType != XFLM_LOCK_SHARED) + if (lockType != FLM_LOCK_EXCLUSIVE && lockType != FLM_LOCK_SHARED) { rc = RC_SET( NE_XFLM_ILLEGAL_OP); goto Exit; @@ -751,16 +751,17 @@ RCODE FLMAPI F_Db::dbLock( // Attempt to acquire the lock. - if (RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->Lock( this, m_hWaitSem, - TRUE, FALSE, (FLMBOOL)((eLockType == XFLM_LOCK_EXCLUSIVE) + if (RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->lock( m_hWaitSem, + (FLMBOOL)((lockType == 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 == XFLM_LOCK_SHARED) + if (lockType == FLM_LOCK_SHARED) { m_uiFlags |= FDB_FILE_LOCK_SHARED; } @@ -791,7 +792,7 @@ RCODE FLMAPI 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; } @@ -819,7 +820,7 @@ RCODE FLMAPI F_Db::getLockInfo( FLMINT iPriority, // [IN] A count of all locks with a priority >= to this priority // level will be returned in pLockInfo. - eDbLockType * peCurrLockType, + eLockType * pCurrLockType, FLMUINT * puiThreadId, FLMUINT * puiNumExclQueued, FLMUINT * puiNumSharedQueued, @@ -833,8 +834,8 @@ RCODE FLMAPI F_Db::getLockInfo( goto Exit; } - m_pDatabase->m_pDatabaseLockObj->GetLockInfo( iPriority, - peCurrLockType, puiThreadId, + m_pDatabase->m_pDatabaseLockObj->getLockInfo( iPriority, + pCurrLockType, puiThreadId, puiNumExclQueued, puiNumSharedQueued, puiPriorityCount); @@ -848,14 +849,14 @@ Desc : Returns information about the lock held by the specified database handle. *END************************************************************************/ RCODE FLMAPI F_Db::getLockType( - eDbLockType * peLockType, + eLockType * pLockType, FLMBOOL * pbImplicit) { RCODE rc = NE_XFLM_OK; - if (peLockType) + if (pLockType) { - *peLockType = XFLM_LOCK_NONE; + *pLockType = FLM_LOCK_NONE; } if (pbImplicit) @@ -870,15 +871,15 @@ RCODE FLMAPI F_Db::getLockType( if (m_uiFlags & FDB_HAS_FILE_LOCK) { - if (peLockType) + if (pLockType) { if (m_uiFlags & FDB_FILE_LOCK_SHARED) { - *peLockType = XFLM_LOCK_SHARED; + *pLockType = FLM_LOCK_SHARED; } else { - *peLockType = XFLM_LOCK_EXCLUSIVE; + *pLockType = FLM_LOCK_EXCLUSIVE; } } @@ -966,8 +967,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; } @@ -986,7 +988,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)); } @@ -1003,7 +1005,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)); } @@ -1024,14 +1026,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/xflaim/src/fslfileu.cpp b/xflaim/src/fslfileu.cpp index 39cde4a..ce98535 100644 --- a/xflaim/src/fslfileu.cpp +++ b/xflaim/src/fslfileu.cpp @@ -1743,29 +1743,28 @@ RCODE F_Db::indexSetOfDocuments( FLMBOOL * pbHitEnd, IF_Thread * pThread) { - RCODE rc = NE_XFLM_OK; - FLMUINT64 ui64DocumentId; - FLMUINT64 ui64LastDocumentId = 0; - IXD * pIxd = NULL; - F_COLLECTION * pCollection; - ServerLockObject * - pDatabaseLockObj = m_pDatabase->m_pDatabaseLockObj; - FLMBOOL bHitEnd = FALSE; - FLMUINT uiCurrTime; - FLMUINT uiLastStatusTime = 0; - FLMUINT uiStartTime; - FLMUINT uiMinTU; - FLMUINT uiStatusIntervalTU; - FLMUINT64 ui64DocumentsProcessed = 0; - FLMBOOL bUpdateTracker = FALSE; - FLMBOOL bRelinquish = FALSE; - FLMBYTE ucKey[ FLM_MAX_NUM_BUF_SIZE]; - FLMUINT uiKeyLen; - void * pvTmpPoolMark = m_tempPool.poolMark(); - F_Btree * pbtree = NULL; - FLMBOOL bNeg; - FLMUINT uiBytesProcessed; - F_DOMNode * pNode = NULL; + RCODE rc = NE_XFLM_OK; + FLMUINT64 ui64DocumentId; + FLMUINT64 ui64LastDocumentId = 0; + IXD * pIxd = NULL; + F_COLLECTION * pCollection; + IF_LockObject * pDatabaseLockObj = m_pDatabase->m_pDatabaseLockObj; + FLMBOOL bHitEnd = FALSE; + FLMUINT uiCurrTime; + FLMUINT uiLastStatusTime = 0; + FLMUINT uiStartTime; + FLMUINT uiMinTU; + FLMUINT uiStatusIntervalTU; + FLMUINT64 ui64DocumentsProcessed = 0; + FLMBOOL bUpdateTracker = FALSE; + FLMBOOL bRelinquish = FALSE; + FLMBYTE ucKey[ FLM_MAX_NUM_BUF_SIZE]; + FLMUINT uiKeyLen; + void * pvTmpPoolMark = m_tempPool.poolMark(); + F_Btree * pbtree = NULL; + FLMBOOL bNeg; + FLMUINT uiBytesProcessed; + F_DOMNode * pNode = NULL; uiMinTU = FLM_MILLI_TO_TIMER_UNITS( 500); uiStatusIntervalTU = FLM_SECS_TO_TIMER_UNITS( 10); @@ -1924,7 +1923,7 @@ RCODE F_Db::indexSetOfDocuments( break; } - if (pDatabaseLockObj->ThreadWaitingLock()) + if (pDatabaseLockObj->getWaiterCount()) { // See if our minimum run time has elapsed @@ -1961,7 +1960,7 @@ RCODE F_Db::indexSetOfDocuments( if (FLM_ELAPSED_TIME( uiCurrTime, uiStartTime) > gv_XFlmSysData.uiMaxCPInterval && - m_pDatabase->m_pWriteLockObj->ThreadWaitingLock()) + m_pDatabase->m_pWriteLockObj->getWaiterCount()) { bRelinquish = TRUE; break; @@ -2528,9 +2527,9 @@ RetryLock: flmAssert( !(m_uiFlags & FDB_HAS_FILE_LOCK)); - if( RC_BAD( rc = m_pDatabase->m_pDatabaseLockObj->Lock( this, m_hWaitSem, - TRUE, FALSE, TRUE, XFLM_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_XFLM_DATABASE_LOCK_REQ_TIMEOUT) { @@ -2558,7 +2557,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; } @@ -2596,7 +2595,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/xflaim/src/fsrvlock.cpp b/xflaim/src/fsrvlock.cpp deleted file mode 100644 index c753294..0000000 --- a/xflaim/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: fsrvlock.cpp 3114 2006-01-19 13:22:45 -0700 (Thu, 19 Jan 2006) dsanders $ -//------------------------------------------------------------------------------ - -#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_XFLM_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_XFLM_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_XFlmSysData.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_XFLM_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 - XFLM_DB_STATS * pDbStats) // Place to collect stats. -{ - RCODE rc = NE_XFLM_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_XFLM_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_XFLM_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 == XFLM_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_XFlmSysData.EventHdrs [XFLM_EVENT_LOCKS].pEventCBList) - { - flmDoEventCallback( XFLM_EVENT_LOCKS, - (eEventType)((bSendSuspendEvent) - ? XFLM_EVENT_LOCK_SUSPENDED - : XFLM_EVENT_LOCK_WAITING), - pDb, LockWait.uiThreadId, - 0, 0, 0, NE_XFLM_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_XFLM_FAILURE. - - if (rc == NE_XFLM_FAILURE) - { - RC_UNEXPECTED_ASSERT( rc); - } - } - - // Do the event callback, if any registered. - - if (bLogEvent && - gv_XFlmSysData.EventHdrs [XFLM_EVENT_LOCKS].pEventCBList) - { - if (RC_BAD( rc)) - { - flmDoEventCallback( XFLM_EVENT_LOCKS, - XFLM_EVENT_LOCK_TIMEOUT, - pDb, LockWait.uiThreadId, - 0, 0, 0, NE_XFLM_OK); - } - else - { - flmDoEventCallback( XFLM_EVENT_LOCKS, - (eEventType)((bSendSuspendEvent) - ? XFLM_EVENT_LOCK_RESUMED - : XFLM_EVENT_LOCK_GRANTED), - pDb, LockWait.uiThreadId, - 0, 0, 0, NE_XFLM_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_XFlmSysData.EventHdrs [XFLM_EVENT_LOCKS].pEventCBList) - { - m_pServerLockMgr->unlockMutex( FALSE); - bMutexLocked = FALSE; - flmDoEventCallback( XFLM_EVENT_LOCKS, - XFLM_EVENT_LOCK_GRANTED, - pDb, m_uiLockThreadId, - 0, 0, 0, NE_XFLM_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, - XFLM_DB_STATS * pDbStats) -{ - RCODE rc = NE_XFLM_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_XFlmSysData.EventHdrs [XFLM_EVENT_LOCKS].pEventCBList) - { - flmDoEventCallback( XFLM_EVENT_LOCKS, - XFLM_EVENT_LOCK_RELEASED, - pDb, m_uiLockThreadId, - 0, 0, 0, NE_XFLM_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_XFLM_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 = XFLM_LOCK_EXCLUSIVE; - *puiThreadId = m_uiLockThreadId; - } - else if (m_uiSharedLockCnt) - { - *peCurrLockType = XFLM_LOCK_SHARED; - *puiThreadId = 0; - } - else - { - *peCurrLockType = XFLM_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_XFLM_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/xflaim/src/fsrvlock.h b/xflaim/src/fsrvlock.h deleted file mode 100644 index 936d4a1..0000000 --- a/xflaim/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: fsrvlock.h 3109 2006-01-19 13:07:07 -0700 (Thu, 19 Jan 2006) dsanders $ -//------------------------------------------------------------------------------ - -#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) - XFLM_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 - XFLM_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 - XFLM_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 FLMAPI 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/xflaim/src/fstructs.h b/xflaim/src/fstructs.h index 7e45d42..b1e45fb 100644 --- a/xflaim/src/fstructs.h +++ b/xflaim/src/fstructs.h @@ -41,8 +41,6 @@ class F_SuperFileHdl; class F_Btree; class F_DbRebuild; class F_DbCheck; -class ServerLockManager; -class ServerLockObject; class F_Cursor; class F_MultiAlloc; class F_CachedNode; @@ -728,8 +726,7 @@ public: XFLM_DB_STATS * pDbStats = NULL, FLMUINT uiTimeout = XFLM_NO_TIMEOUT); - void dbWriteUnlock( - XFLM_DB_STATS * pDbStats = NULL); + void dbWriteUnlock( void); void shutdownDatabaseThreads( void); @@ -1254,8 +1251,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 @@ -1335,18 +1332,6 @@ friend class F_AttrBufferRelocator; friend class F_BlockRelocator; }; -/*************************************************************************** -Desc: This is the hash bucket header structure. Each bucket header - points to a list of items that belong to the bucket. -***************************************************************************/ -typedef struct FBucket -{ - void * pFirstInBucket; // Pointer to first item in the bucket. - // The type of structure being pointed to - // depends on the usage of the hash bucket. - FLMUINT uiHashValue; // Hash value for this bucket. -} FBUCKET; - typedef struct QueryHdrTag { F_Query * pQuery; @@ -1557,8 +1542,6 @@ typedef struct FlmSystemData // 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/xflaim/src/fsuperfl.h b/xflaim/src/fsuperfl.h index afac08a..7b66dae 100644 --- a/xflaim/src/fsuperfl.h +++ b/xflaim/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/xflaim/src/fsysdata.cpp b/xflaim/src/fsysdata.cpp index ccf0ccd..c3567cc 100644 --- a/xflaim/src/fsysdata.cpp +++ b/xflaim/src/fsysdata.cpp @@ -514,9 +514,8 @@ RCODE F_Database::dbWriteLock( { RCODE rc = NE_XFLM_OK; - if (RC_BAD( rc = m_pWriteLockObj->Lock( NULL, hWaitSem, FALSE, - (FLMBOOL)(uiTimeout ? TRUE : FALSE), - TRUE, uiTimeout, 0, pDbStats))) + if (RC_BAD( rc = m_pWriteLockObj->lock( hWaitSem, + TRUE, uiTimeout, 0, pDbStats ? &pDbStats->LockStats : NULL))) { goto Exit; } @@ -529,10 +528,9 @@ Exit: /**************************************************************************** Desc: This routine unlocks the write lock on a database. ****************************************************************************/ -void F_Database::dbWriteUnlock( - XFLM_DB_STATS * pDbStats) +void F_Database::dbWriteUnlock( void) { - (void)m_pWriteLockObj->Unlock( FALSE, NULL, FALSE, pDbStats); + (void)m_pWriteLockObj->unlock(); } /**************************************************************************** @@ -700,35 +698,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. @@ -776,7 +745,7 @@ RCODE F_Database::linkToBucket( void) FLMUINT uiBucket; pBucket = gv_XFlmSysData.pDatabaseHashTbl; - uiBucket = flmStrHashBucket( m_pszDbPath, pBucket, FILE_HASH_ENTRIES); + uiBucket = f_strHashBucket( m_pszDbPath, pBucket, FILE_HASH_ENTRIES); pBucket = &pBucket [uiBucket]; if (pBucket->pFirstInBucket) { @@ -999,12 +968,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_XFlmSysData.pServerLockMgr->CheckLockTimeouts( FALSE, FALSE); - // Check the adjusting cache limit (void)gv_XFlmSysData.pGlobalCacheMgr->adjustCache( &uiCurrTime, @@ -1995,26 +1958,6 @@ RCODE F_DbSystem::init( void) flmDbgLogInit(); #endif - // Allocate and Initialize FLAIM Server Lock Manager. - - if ((gv_XFlmSysData.pServerLockMgr = f_new ServerLockManager) == NULL) - { - rc = RC_SET( NE_XFLM_MEM); - goto Exit; - } - - if (RC_BAD( rc = gv_XFlmSysData.pServerLockMgr->setupLockMgr())) - { - goto Exit; - } - - // Set up hash table for lock manager. - - if (RC_BAD( rc = gv_XFlmSysData.pServerLockMgr->SetupHashTbl())) - { - goto Exit; - } - // Set up mutexes for the event table. for (iEventCategory = 0; @@ -2206,33 +2149,6 @@ void F_DbSystem::cleanup( void) { f_mutexDestroy( &gv_XFlmSysData.hStatsMutex); } - - // Free (release) FLAIM's Server Lock Manager. - - if (gv_XFlmSysData.pServerLockMgr) - { - FLMUINT uiRefCnt; - - // Release all locks. - - gv_XFlmSysData.pServerLockMgr->CheckLockTimeouts( FALSE, TRUE); - - // Release the lock manager. - - uiRefCnt = gv_XFlmSysData.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_XFlmSysData.pServerLockMgr = NULL; - } // Make sure the purge list is empty diff --git a/xflaim/src/scache.cpp b/xflaim/src/scache.cpp index 5a2d57b..144d330 100644 --- a/xflaim/src/scache.cpp +++ b/xflaim/src/scache.cpp @@ -1259,7 +1259,7 @@ RCODE F_Database::flushLogBlocks( } else { - if (m_pWriteLockObj->ThreadWaitingLock() && + if (m_pWriteLockObj->getWaiterCount() && uiDirtyCacheLeft <= uiMaxDirtyCache) { bDone = TRUE; @@ -4193,7 +4193,7 @@ Add_Contiguous_Block: } else { - if (m_pWriteLockObj->ThreadWaitingLock() && + if (m_pWriteLockObj->getWaiterCount() && *puiDirtyCacheLeft <= uiMaxDirtyCache) { diff --git a/xflaim/src/xflaim.h b/xflaim/src/xflaim.h index a8c6063..5cf9484 100644 --- a/xflaim/src/xflaim.h +++ b/xflaim/src/xflaim.h @@ -63,7 +63,6 @@ flminterface IF_EventClient; flminterface IF_IxClient; flminterface IF_IxStatus; - flminterface IF_LockInfoClient; flminterface IF_LoggerClient; flminterface IF_LogMessageClient; flminterface IF_OperandComparer; @@ -394,13 +393,6 @@ XFLM_UPDATE_TRANS } eDbTransType; - typedef enum - { - XFLM_LOCK_NONE = 0, - XFLM_LOCK_EXCLUSIVE, - XFLM_LOCK_SHARED - } eDbLockType; - // Transaction flags #define XFLM_DONT_KILL_TRANS 0x1 @@ -584,14 +576,6 @@ XFLM_ECACHE_USAGE ECache; } XFLM_CACHE_INFO; - typedef struct - { - FLMUINT64 ui64Count; // Number of times operation - // was performed. - FLMUINT64 ui64ElapMilli; // Total elapsed time for the - // operations. - } XFLM_COUNT_TIME_STAT; - typedef struct { FLMUINT64 ui64Count; // Number of times read or @@ -606,16 +590,16 @@ typedef struct { - XFLM_COUNT_TIME_STAT CommittedTrans; // Transactions committed - XFLM_COUNT_TIME_STAT AbortedTrans; // Transactions aborted + F_COUNT_TIME_STAT CommittedTrans; // Transactions committed + F_COUNT_TIME_STAT AbortedTrans; // Transactions aborted } XFLM_RTRANS_STATS; typedef struct { - XFLM_COUNT_TIME_STAT CommittedTrans; // Transactions committed - XFLM_COUNT_TIME_STAT GroupCompletes; // Group completes. + F_COUNT_TIME_STAT CommittedTrans; // Transactions committed + F_COUNT_TIME_STAT GroupCompletes; // Group completes. FLMUINT64 ui64GroupFinished; // Transactions finished in group - XFLM_COUNT_TIME_STAT AbortedTrans; // Transactions aborted + F_COUNT_TIME_STAT AbortedTrans; // Transactions aborted } XFLM_UTRANS_STATS; typedef struct @@ -701,10 +685,8 @@ FLMUINT uiWriteErrors; // Number of times we got write // errors. // Lock statistics - - XFLM_COUNT_TIME_STAT NoLocks; // Times when no lock was held - XFLM_COUNT_TIME_STAT WaitingForLock; // Time waiting for lock - XFLM_COUNT_TIME_STAT HeldLock; // Time holding lock + + F_LOCK_STATS LockStats; } XFLM_DB_STATS; @@ -2483,19 +2465,19 @@ FLMUINT uiTimeout) = 0; virtual RCODE FLMAPI dbLock( - eDbLockType eLockType, + eLockType lockType, FLMINT iPriority, FLMUINT uiTimeout) = 0; virtual RCODE FLMAPI dbUnlock( void) = 0; virtual RCODE FLMAPI getLockType( - eDbLockType * peLockType, + eLockType * pLockType, FLMBOOL * pbImplicit) = 0; virtual RCODE FLMAPI getLockInfo( FLMINT iPriority, - eDbLockType * peCurrLockType, + eLockType * pCurrLockType, FLMUINT * puiThreadId, FLMUINT * puiNumExclQueued, FLMUINT * puiNumSharedQueued, @@ -3689,25 +3671,6 @@ IF_DOMNode * pDocNode) = 0; }; - /**************************************************************************** - Desc: - ****************************************************************************/ - flminterface IF_LockInfoClient : public F_Object - { - virtual FLMBOOL FLMAPI setLockCount( // Return TRUE to continue, FALSE to stop - FLMUINT uiTotalLocks) = 0; - - virtual FLMBOOL FLMAPI addLockInfo( // Return TRUE to continue, FALSE to stop - FLMUINT uiLockNum, // Position in queue (0 = lock holder, - // 1 ... n = lock waiter) - FLMUINT uiThreadID, // Thread ID of the lock holder/waiter - FLMUINT uiTime) = 0; // For the lock holder, this is the - // time when the lock was obtained. - // For a lock waiter, this is the time - // that the waiter was placed in the queue. - // Both times are presented in milliseconds. - }; - /**************************************************************************** Desc: ****************************************************************************/