/***************************************************************************
Desc: Allocates and initializes an F_Db object for a database which
is to be opened or created.
****************************************************************************/
RCODE F_DbSystem::allocDb(
F_Db ** ppDb,
FLMBOOL bInternalOpen)
{
RCODE rc = NE_XFLM_OK;
F_Db * pDb = NULL;
*ppDb = NULL;
// Allocate the F_Db object.
if ((pDb = f_new F_Db( bInternalOpen)) == NULL)
{
rc = RC_SET( NE_XFLM_MEM);
goto Exit;
}
if( RC_BAD( rc = f_semCreate( &pDb->m_hWaitSem)))
{
goto Exit;
}
*ppDb = pDb;
pDb = NULL;
Exit:
if (pDb)
{
pDb->Release();
}
return( rc);
}
/****************************************************************************
Desc:
****************************************************************************/
RCODE F_IOBufferMgr::setupBufferMgr(
FLMUINT uiMaxBuffers,
FLMUINT uiMaxBytes,
FLMBOOL bReuseBuffers)
{
RCODE rc = NE_FLM_OK;
f_assert( uiMaxBuffers);
f_assert( uiMaxBytes);
if( RC_BAD( rc = f_mutexCreate( &m_hMutex)))
{
goto Exit;
}
#if !defined( FLM_UNIX) && !defined( FLM_NLM)
if( RC_BAD( rc = f_semCreate( &m_hAvailSem)))
{
goto Exit;
}
#endif
m_uiMaxBuffers = uiMaxBuffers;
m_uiMaxBufferBytes = uiMaxBytes;
m_bReuseBuffers = bReuseBuffers;
Exit:
return( rc);
}
/***************************************************************************
Desc:
*****************************************************************************/
RCODE F_Database::startMaintThread( void)
{
RCODE rc = NE_SFLM_OK;
char szThreadName[ F_PATH_MAX_SIZE];
char szBaseName[ 32];
flmAssert( !m_pMaintThrd);
flmAssert( m_hMaintSem == F_SEM_NULL);
// Generate the thread name
if( RC_BAD( rc = gv_SFlmSysData.pFileSystem->pathReduce(
m_pszDbPath, szThreadName, szBaseName)))
{
goto Exit;
}
f_sprintf( (char *)szThreadName, "Maintenance (%s)", (char *)szBaseName);
// Create the maintenance semaphore
if( RC_BAD( rc = f_semCreate( &m_hMaintSem)))
{
goto Exit;
}
// Start the thread.
if( RC_BAD( rc = gv_SFlmSysData.pThreadMgr->createThread( &m_pMaintThrd,
F_Database::maintenanceThread, szThreadName,
0, 0, this, NULL, 32000)))
{
goto Exit;
}
// Signal the thread to check for any queued work
f_semSignal( m_hMaintSem);
Exit:
if( RC_BAD( rc))
{
if( m_hMaintSem != F_SEM_NULL)
{
f_semDestroy( &m_hMaintSem);
}
}
return( rc);
}
/****************************************************************************
Desc: This routine checks to see if it is OK for another F_Db to use an
F_Database object.
If so, it increments the database's use counter. NOTE: This routine
assumes that the calling routine has locked the global mutex.
****************************************************************************/
RCODE F_Database::verifyOkToUse(
FLMBOOL * pbWaited)
{
RCODE rc = NE_XFLM_OK;
F_SEM hWaitSem = F_SEM_NULL;
// Can't open the database if it is being closed by someone else.
if (m_uiFlags & DBF_BEING_CLOSED)
{
rc = RC_SET( NE_FLM_IO_ACCESS_DENIED);
goto Exit;
}
// If the file is in the process of being opened by another
// thread, wait for the open to complete.
if (m_uiFlags & DBF_BEING_OPENED)
{
if( RC_BAD( rc = f_semCreate( &hWaitSem)))
{
goto Exit;
}
*pbWaited = TRUE;
if( RC_BAD( rc = f_notifyWait(
gv_XFlmSysData.hShareMutex, hWaitSem, NULL,&m_pOpenNotifies)))
{
// If f_notifyWait returns a bad RC, assume that the other
// thread will unlock and free the F_Database object. This
// routine should only unlock the object if an error occurs at
// some other point.
goto Exit;
}
}
else
{
*pbWaited = FALSE;
}
Exit:
if( hWaitSem != F_SEM_NULL)
{
f_semDestroy( &hWaitSem);
}
return( rc);
}
/****************************************************************************
Desc: This routine links a request into a notification list and
then waits to be notified that the event has occurred. The mutex
is assumed to protect the notify list.
****************************************************************************/
RCODE FLMAPI f_notifyWait(
F_MUTEX hMutex,
F_SEM hSem,
void * pvData,
F_NOTIFY_LIST_ITEM ** ppNotifyList)
{
RCODE rc = NE_FLM_OK;
RCODE tmpRc;
F_NOTIFY_LIST_ITEM stackNotify;
F_NOTIFY_LIST_ITEM * pNotify = &stackNotify;
f_assertMutexLocked( hMutex);
f_assert( pNotify != *ppNotifyList);
f_memset( &stackNotify, 0, sizeof( F_NOTIFY_LIST_ITEM));
pNotify->uiThreadId = f_threadId();
pNotify->hSem = F_SEM_NULL;
if( hSem == F_SEM_NULL)
{
if( RC_BAD( rc = f_semCreate( &pNotify->hSem)))
{
goto Exit;
}
}
else
{
pNotify->hSem = hSem;
}
pNotify->pRc = &rc;
pNotify->pvData = pvData;
pNotify->pNext = *ppNotifyList;
*ppNotifyList = pNotify;
// Unlock the mutex and wait on the semaphore
f_mutexUnlock( hMutex);
if( RC_BAD( tmpRc = f_semWait( pNotify->hSem, F_WAITFOREVER)))
{
rc = tmpRc;
}
// Free the semaphore
if( hSem != pNotify->hSem)
{
f_semDestroy( &pNotify->hSem);
}
// Relock the mutex
f_mutexLock( hMutex);
Exit:
return( rc);
}
/****************************************************************************
Desc: This routine is used to see if a file is already in use somewhere.
This is only called for files which are opened directly by the
application.
Notes: This routine assumes that the global mutex is locked, but it
may unlock and re-lock the mutex if needed.
****************************************************************************/
RCODE F_DbSystem::findDatabase(
const char * pszDbPath,
const char * pszDataDir,
F_Database ** ppDatabase)
{
RCODE rc = NE_XFLM_OK;
F_BUCKET * pBucket;
FLMUINT uiBucket;
FLMBOOL bMutexLocked = TRUE;
F_Database * pDatabase;
char szDbPathStr1 [F_PATH_MAX_SIZE];
char szDbPathStr2 [F_PATH_MAX_SIZE];
F_SEM hWaitSem = F_SEM_NULL;
*ppDatabase = NULL;
// Normalize the path to a string before looking for it.
// NOTE: On non-UNIX, non-WIN platforms, this will basically convert
// the string to upper case.
if (RC_BAD( rc = gv_XFlmSysData.pFileSystem->pathToStorageString(
pszDbPath, szDbPathStr1)))
{
goto Exit;
}
Retry:
*ppDatabase = NULL;
if( !bMutexLocked)
{
f_mutexLock( gv_XFlmSysData.hShareMutex);
bMutexLocked = TRUE;
}
pBucket = gv_XFlmSysData.pDatabaseHashTbl;
uiBucket = f_strHashBucket( szDbPathStr1, pBucket, FILE_HASH_ENTRIES);
pDatabase = (F_Database *)pBucket [uiBucket].pFirstInBucket;
while (pDatabase)
{
// Compare the strings. On non-Unix platforms we must use
// f_stricmp, because case does not matter for file names
// on those platforms.
#ifdef FLM_UNIX
if( f_strcmp( szDbPathStr1, pDatabase->m_pszDbPath) == 0)
#else
if( f_stricmp( szDbPathStr1, pDatabase->m_pszDbPath) == 0)
#endif
{
// Make sure data paths match.
if (pszDataDir && *pszDataDir)
{
if (RC_BAD( rc = gv_XFlmSysData.pFileSystem->pathToStorageString(
pszDataDir, szDbPathStr2)))
{
goto Exit;
}
if (pDatabase->m_pszDataDir)
{
// f_stricmp must be used on non-unix platforms because file
// names are case insensitive on those platforms.
#ifdef FLM_UNIX
if (f_strcmp( pDatabase->m_pszDataDir, szDbPathStr2) != 0)
#else
if (f_stricmp( pDatabase->m_pszDataDir, szDbPathStr2) != 0)
#endif
{
rc = RC_SET( NE_XFLM_DATA_PATH_MISMATCH);
goto Exit;
}
}
else
{
rc = RC_SET( NE_XFLM_DATA_PATH_MISMATCH);
goto Exit;
}
}
else if (pDatabase->m_pszDataDir)
{
rc = RC_SET( NE_XFLM_DATA_PATH_MISMATCH);
goto Exit;
}
*ppDatabase = pDatabase;
break;
}
pDatabase = pDatabase->m_pNext;
}
if (*ppDatabase && pDatabase->m_uiFlags & DBF_BEING_CLOSED)
{
if( RC_BAD( rc = f_semCreate( &hWaitSem)))
{
goto Exit;
}
// Put ourselves into the notify list and then re-try
// the lookup when we wake up
if (RC_BAD( rc = f_notifyWait( gv_XFlmSysData.hShareMutex, hWaitSem,
NULL, &pDatabase->m_pCloseNotifies)))
{
goto Exit;
}
f_semDestroy( &hWaitSem);
// The mutex will be locked at this point. Re-try the lookup.
// IMPORTANT NOTE: pDatabase will have been destroyed by this
// time. DO NOT use it for anything!
goto Retry;
}
Exit:
if( hWaitSem != F_SEM_NULL)
{
f_semDestroy( &hWaitSem);
}
// Make sure the global mutex is re-locked before exiting
if( !bMutexLocked)
{
f_mutexLock( gv_XFlmSysData.hShareMutex);
}
return( rc);
}
/****************************************************************************
Desc: This routine obtains exclusive access to a database by creating
a .lck file. FLAIM holds the .lck file open as long as the database
is open. When the database is finally closed, it deletes the .lck
file. This is only used for 3.x databases.
****************************************************************************/
RCODE F_Database::getExclAccess(
const char * pszFilePath)
{
RCODE rc = NE_XFLM_OK;
FLMBOOL bNotifyWaiters = FALSE;
FLMBOOL bMutexLocked = FALSE;
F_SEM hWaitSem = F_SEM_NULL;
// If m_pLockFileHdl is non-NULL, it means that we currently
// have the database locked with a lock file. There is no need to make
// this test inside a mutex lock, because the lock file handle can only
// be set to NULL when the use count goes to zero, meaning that the thread
// that sets it to NULL will be the only thread accessing it.
// However, it is possible that two or more threads will simultaneously
// test m_pLockFileHdl and discover that it is NULL. In that case,
// we allow one thread to proceed and attempt to get a lock on the database
// while the other threads wait to be notified of the results of the
// attempt to lock the database.
if (m_pLockFileHdl)
{
goto Exit;
}
lockMutex();
bMutexLocked = TRUE;
if (m_bBeingLocked)
{
// If the database is in the process of being locked by another
// thread, wait for the lock to complete. NOTE: f_notifyWait will
// re-lock the mutex before returning.
if( RC_BAD( rc = f_semCreate( &hWaitSem)))
{
goto Exit;
}
rc = f_notifyWait( m_hMutex, hWaitSem, NULL, &m_pLockNotifies);
goto Exit;
}
// No other thread was attempting to lock the database, so
// set this thread up to make the attempt. Other threads
// coming in at this point will be required to wait and
// be notified of the results.
m_bBeingLocked = TRUE;
bNotifyWaiters = TRUE;
unlockMutex();
bMutexLocked = FALSE;
if (RC_BAD( rc = flmCreateLckFile( pszFilePath, &m_pLockFileHdl)))
{
goto Exit;
}
Exit:
if (bNotifyWaiters)
{
F_NOTIFY_LIST_ITEM * pNotify;
F_SEM hSem;
// Notify any thread waiting on the lock what its status is.
if( !bMutexLocked)
{
lockMutex();
bMutexLocked = TRUE;
}
pNotify = m_pLockNotifies;
while (pNotify)
{
*(pNotify->pRc) = rc;
hSem = pNotify->hSem;
pNotify = pNotify->pNext;
f_semSignal( hSem);
}
m_bBeingLocked = FALSE;
m_pLockNotifies = NULL;
unlockMutex();
bMutexLocked = FALSE;
}
if( bMutexLocked)
{
unlockMutex();
}
if( hWaitSem != F_SEM_NULL)
{
f_semDestroy( &hWaitSem);
}
return( rc);
}
/***************************************************************************
Desc: This routine begins a thread that will do checkpoints for the
passed in database. It gives the thread its own FLAIM session and its
own handle to the database.
*****************************************************************************/
RCODE F_Database::startCPThread( void)
{
RCODE rc = NE_XFLM_OK;
CP_INFO * pCPInfo = NULL;
char szThreadName[ F_PATH_MAX_SIZE];
char szBaseName[ 32];
F_SuperFileClient * pSFileClient = NULL;
// Allocate a CP_INFO structure that will be passed into the
// thread when it is created.
if (RC_BAD( rc = f_calloc( (FLMUINT)(sizeof( CP_INFO)), &pCPInfo)))
{
goto Exit;
}
pCPInfo->pDatabase = this;
// Create a "wait" semaphore
if( RC_BAD( rc = f_semCreate( &pCPInfo->hWaitSem)))
{
goto Exit;
}
// Allocate a super file handle.
if( (pCPInfo->pSFileHdl = f_new F_SuperFileHdl) == NULL)
{
rc = RC_SET( NE_XFLM_MEM);
goto Exit;
}
if( (pSFileClient = f_new F_SuperFileClient) == NULL)
{
rc = RC_SET( NE_XFLM_MEM);
goto Exit;
}
if( RC_BAD( rc = pSFileClient->setup( m_pszDbPath, m_pszDataDir,
m_uiMaxFileSize)))
{
goto Exit;
}
// Set up the super file
if( RC_BAD( rc = pCPInfo->pSFileHdl->setup( pSFileClient,
gv_XFlmSysData.pFileHdlCache, gv_XFlmSysData.uiFileOpenFlags,
gv_XFlmSysData.uiFileCreateFlags)))
{
goto Exit;
}
f_memset( &pCPInfo->Stats, 0, sizeof( XFLM_STATS));
pCPInfo->bStatsInitialized = TRUE;
// Generate the thread name
if (RC_BAD( rc = gv_XFlmSysData.pFileSystem->pathReduce( m_pszDbPath,
szThreadName, szBaseName)))
{
goto Exit;
}
f_sprintf( (char *)szThreadName, "Checkpoint (%s)", (char *)szBaseName);
// Start the checkpoint thread.
if (RC_BAD( rc = gv_XFlmSysData.pThreadMgr->createThread( &m_pCPThrd,
flmCPThread, szThreadName, gv_XFlmSysData.uiCheckpointThreadGroup,
0, pCPInfo, NULL, 32000)))
{
goto Exit;
}
m_pCPInfo = pCPInfo;
pCPInfo = NULL;
Exit:
if( pCPInfo)
{
flmFreeCPInfo( &pCPInfo);
}
if( pSFileClient)
{
pSFileClient->Release();
}
return( rc);
}
/****************************************************************************
Desc: Copy a database's files, including roll-forward log files.
*****************************************************************************/
FSTATIC RCODE flmCopyDb(
FLMUINT uiDbVersion,
const char * pszSrcDbName,
const char * pszSrcDataDir,
const char * pszSrcRflDir,
const char * pszDestDbName,
const char * pszDestDataDir,
const char * pszDestRflDir,
STATUS_HOOK fnStatusCallback,
void * UserData)
{
RCODE rc = FERR_OK;
DB_COPY_INFO DbCopyInfo;
F_SuperFileHdl * pSrcSFileHdl = NULL;
F_SuperFileHdl * pDestSFileHdl = NULL;
F_SuperFileClient * pSrcSFileClient = NULL;
F_SuperFileClient * pDestSFileClient = NULL;
FLMUINT uiFileNumber;
FLMUINT uiHighFileNumber;
FLMUINT uiHighLogFileNumber;
FLMUINT64 ui64FileSize;
FFILE * pFile = NULL;
FLMBOOL bMutexLocked = FALSE;
IF_FileHdl * pLockFileHdl = NULL;
IF_FileHdl * pTmpFileHdl = NULL;
IF_DirHdl * pDirHdl = NULL;
FLMBOOL bFileLocked = FALSE;
FLMBOOL bWriteLocked = FALSE;
IF_LockObject * pWriteLockObj = NULL;
IF_LockObject * pFileLockObj = NULL;
COPIED_NAME * pCopiedList = NULL;
FLMBOOL bUsedFFile = FALSE;
FLMBYTE * pucInMemLogHdr = NULL;
eLockType currLockType;
FLMUINT uiLockThreadId;
char * pszActualSrcRflPath = NULL;
char * pszSrcPrefix = NULL;
char * pszActualDestRflPath = NULL;
char * pszDestPrefix = NULL;
FLMBOOL bCreatedDestRflDir = FALSE;
F_SEM hWaitSem = F_SEM_NULL;
f_memset( &DbCopyInfo, 0, sizeof( DbCopyInfo));
// Should not do anything if the source and destination names
// are the same.
if (f_stricmp( pszSrcDbName, pszDestDbName) == 0)
{
goto Exit;
}
// Allocate a semaphore
if( RC_BAD( rc = f_semCreate( &hWaitSem)))
{
goto Exit;
}
// Allocate memory for paths we don't want to push onto the stack.
if (RC_BAD( rc = f_calloc(
(F_PATH_MAX_SIZE + F_FILENAME_SIZE) * 2, &pszActualSrcRflPath)))
{
goto Exit;
}
pszSrcPrefix = &pszActualSrcRflPath[ F_PATH_MAX_SIZE];
pszActualDestRflPath = &pszSrcPrefix[ F_FILENAME_SIZE];
pszDestPrefix = &pszActualDestRflPath[ F_PATH_MAX_SIZE];
// Set up the super file object for the source database.
// Must at least open the control file.
if( (pSrcSFileClient = f_new F_SuperFileClient) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if( RC_BAD( rc = pSrcSFileClient->setup(
pszSrcDbName, pszSrcDataDir, uiDbVersion)))
{
goto Exit;
}
if( (pSrcSFileHdl = f_new F_SuperFileHdl) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if( RC_BAD( rc = pSrcSFileHdl->setup( pSrcSFileClient,
gv_FlmSysData.pFileHdlCache, gv_FlmSysData.uiFileOpenFlags, 0)))
{
goto Exit;
}
// Lock the destination database, if not already locked.
// This is so we can overwrite it without necessarily
// deleting it. May unlock and re-lock the global mutex.
f_mutexLock( gv_FlmSysData.hShareMutex);
bMutexLocked = TRUE;
if (RC_BAD( rc = flmFindFile( pszDestDbName, pszDestDataDir, &pFile)))
{
goto Exit;
}
// If we didn't find an FFILE structure, get an
// exclusive lock on the file.
if (!pFile)
{
f_mutexUnlock( gv_FlmSysData.hShareMutex);
bMutexLocked = FALSE;
// Attempt to get an exclusive lock on the file.
if (RC_BAD( rc = flmCreateLckFile( pszDestDbName, &pLockFileHdl)))
{
goto Exit;
}
}
else
{
// The call to flmVerifyFileUse will wait if the file is in
// the process of being opened by another thread.
if (RC_BAD( rc = flmVerifyFileUse( gv_FlmSysData.hShareMutex, &pFile)))
{
goto Exit;
}
// Increment the use count on the FFILE so it will not
// disappear while we are copying the file.
if (++pFile->uiUseCount == 1)
{
flmUnlinkFileFromNUList( pFile);
}
bUsedFFile = TRUE;
f_mutexUnlock( gv_FlmSysData.hShareMutex);
bMutexLocked = FALSE;
pucInMemLogHdr = &pFile->ucLastCommittedLogHdr [0];
// Lock the destination file object and transaction
// object, if not already locked.
pFile->pFileLockObj->getLockInfo( 0, &currLockType, &uiLockThreadId, NULL);
if (currLockType != FLM_LOCK_EXCLUSIVE || uiLockThreadId != f_threadId())
{
pFileLockObj = pFile->pFileLockObj;
pFileLockObj->AddRef();
if (RC_BAD( rc = pFileLockObj->lock( hWaitSem,
TRUE, FLM_NO_TIMEOUT, 0)))
{
goto Exit;
}
bFileLocked = TRUE;
}
// Lock the write object, if not already locked
pFile->pWriteLockObj->getLockInfo( 0, &currLockType, &uiLockThreadId, NULL);
if( currLockType != FLM_LOCK_EXCLUSIVE ||
uiLockThreadId != f_threadId())
{
pWriteLockObj = pFile->pWriteLockObj;
pWriteLockObj->AddRef();
// Only contention here is with the checkpoint thread - wait
// forever until the checkpoint thread gives it up.
if( RC_BAD( rc = pWriteLockObj->lock( hWaitSem,
TRUE, FLM_NO_TIMEOUT, 0)))
{
goto Exit;
}
bWriteLocked = TRUE;
}
}
// Set up the super file object for the destination database.
if( (pDestSFileClient = f_new F_SuperFileClient) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if( RC_BAD( rc = pDestSFileClient->setup(
pszDestDbName, pszDestDataDir, uiDbVersion)))
{
goto Exit;
}
if( (pDestSFileHdl = f_new F_SuperFileHdl) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if( RC_BAD( rc = pDestSFileHdl->setup( pDestSFileClient,
gv_FlmSysData.pFileHdlCache, gv_FlmSysData.uiFileOpenFlags,
gv_FlmSysData.uiFileCreateFlags)))
{
goto Exit;
}
// See how many files we have and calculate the total size.
uiHighFileNumber = 0;
for (;;)
{
if( RC_BAD( rc = pSrcSFileHdl->getFileSize(
uiHighFileNumber, &ui64FileSize)) || !ui64FileSize)
{
if (rc == FERR_IO_PATH_NOT_FOUND ||
rc == FERR_IO_INVALID_PATH ||
!ui64FileSize)
{
// If the control file doesn't exist, we will return
// path not found.
if (!uiHighFileNumber)
{
goto Exit;
}
uiHighFileNumber--;
rc = FERR_OK;
break;
}
goto Exit;
}
DbCopyInfo.ui64BytesToCopy += ui64FileSize;
if (uiHighFileNumber == MAX_DATA_BLOCK_FILE_NUMBER( uiDbVersion))
{
break;
}
uiHighFileNumber++;
}
// See how many rollback log files we have, and calculate
// their total size.
uiHighLogFileNumber = FIRST_LOG_BLOCK_FILE_NUMBER( uiDbVersion);
for (;;)
{
if ((RC_BAD( rc = pSrcSFileHdl->getFileSize(
uiHighLogFileNumber, &ui64FileSize))) || !ui64FileSize)
{
if (rc == FERR_IO_PATH_NOT_FOUND ||
rc == FERR_IO_INVALID_PATH ||
!ui64FileSize)
{
if (uiHighLogFileNumber ==
FIRST_LOG_BLOCK_FILE_NUMBER( uiDbVersion))
{
uiHighLogFileNumber = 0;
}
else
{
uiHighLogFileNumber--;
}
rc = FERR_OK;
break;
}
goto Exit;
}
DbCopyInfo.ui64BytesToCopy += ui64FileSize;
if (uiHighLogFileNumber == MAX_LOG_BLOCK_FILE_NUMBER( uiDbVersion))
{
break;
}
uiHighLogFileNumber++;
}
// Get the sizes of the roll-forward log files
if( uiDbVersion < FLM_FILE_FORMAT_VER_4_3)
{
// For pre-4.3 versions, only need to copy one RFL file.
if (RC_BAD( rc = rflGetFileName( uiDbVersion,
pszSrcDbName, pszSrcRflDir, 1, pszActualSrcRflPath)))
{
goto Exit;
}
if( RC_BAD( rc = gv_FlmSysData.pFileSystem->openFile(
pszActualSrcRflPath, gv_FlmSysData.uiFileOpenFlags,
&pTmpFileHdl)))
{
if (rc == FERR_IO_PATH_NOT_FOUND ||
rc == FERR_IO_INVALID_PATH)
{
rc = FERR_OK;
}
else
{
goto Exit;
}
}
else
{
if (RC_BAD( rc = pTmpFileHdl->size( &ui64FileSize)))
{
goto Exit;
}
DbCopyInfo.ui64BytesToCopy += ui64FileSize;
pTmpFileHdl->Release();
pTmpFileHdl = NULL;
}
}
else
{
if( RC_BAD( rc = rflGetDirAndPrefix( uiDbVersion, pszSrcDbName,
pszSrcRflDir, pszActualSrcRflPath, pszSrcPrefix)))
{
goto Exit;
}
if (RC_BAD( rc = gv_FlmSysData.pFileSystem->openDir(
pszActualSrcRflPath, (char *)"*", &pDirHdl)))
{
goto Exit;
}
for (;;)
{
if( RC_BAD( rc = pDirHdl->next()))
{
if (rc == FERR_IO_NO_MORE_FILES)
{
rc = FERR_OK;
break;
}
else
{
goto Exit;
}
}
// If the current file is an RFL file, increment ui64BytesToCopy
if( rflGetFileNum( uiDbVersion, pszSrcPrefix,
pDirHdl->currentItemName(), &uiFileNumber))
{
DbCopyInfo.ui64BytesToCopy += pDirHdl->currentItemSize();
}
}
pDirHdl->Release();
pDirHdl = NULL;
}
// Close all file handles in the source and destination
pSrcSFileHdl->releaseFiles();
pDestSFileHdl->releaseFiles();
// Copy the database files.
for (uiFileNumber = 0; uiFileNumber <= uiHighFileNumber; uiFileNumber++)
{
// Get the source file path and destination file path.
if( RC_BAD( rc = pSrcSFileHdl->getFilePath(
uiFileNumber, DbCopyInfo.szSrcFileName)))
{
goto Exit;
}
if( RC_BAD( rc = pDestSFileHdl->getFilePath(
uiFileNumber, DbCopyInfo.szDestFileName)))
{
goto Exit;
}
// For the control file, don't copy first 2K - it will be set up
// to show maintenance in progress. Then the first 2K will be copied
// later.
if (!uiFileNumber)
{
DbCopyInfo.bNewSrcFile = TRUE;
if (RC_BAD( rc = flmCopyFile( gv_FlmSysData.pFileSystem,
2048, 0xFFFFFFFF,
&DbCopyInfo, &pCopiedList, pucInMemLogHdr, TRUE,
fnStatusCallback, UserData)))
{
goto Exit;
}
}
else
{
DbCopyInfo.bNewSrcFile = TRUE;
if (RC_BAD( rc = flmCopyFile( gv_FlmSysData.pFileSystem,
0, 0xFFFFFFFF,
&DbCopyInfo, &pCopiedList, NULL, TRUE,
fnStatusCallback, UserData)))
{
goto Exit;
}
}
}
// Copy the additional rollback log files, if any.
for (uiFileNumber = FIRST_LOG_BLOCK_FILE_NUMBER( uiDbVersion);
uiFileNumber <= uiHighLogFileNumber; uiFileNumber++)
{
// Get the source file path and destination file path.
if (RC_BAD( rc = pSrcSFileHdl->getFilePath( uiFileNumber,
DbCopyInfo.szSrcFileName)))
{
goto Exit;
}
if (RC_BAD( rc = pDestSFileHdl->getFilePath( uiFileNumber,
DbCopyInfo.szDestFileName)))
{
goto Exit;
}
DbCopyInfo.bNewSrcFile = TRUE;
if (RC_BAD( rc = flmCopyFile( gv_FlmSysData.pFileSystem,
0, 0xFFFFFFFF,
&DbCopyInfo, &pCopiedList, NULL, TRUE,
fnStatusCallback, UserData)))
{
goto Exit;
}
}
// Copy the RFL files
if( uiDbVersion < FLM_FILE_FORMAT_VER_4_3)
{
// Get the source file path and the destination file path.
if (RC_BAD( rc = rflGetFileName( uiDbVersion, pszSrcDbName,
pszSrcRflDir, 1,
DbCopyInfo.szSrcFileName)))
{
goto Exit;
}
if (RC_BAD( rc = rflGetFileName( uiDbVersion, pszDestDbName,
pszDestRflDir, 1,
DbCopyInfo.szDestFileName)))
{
goto Exit;
}
DbCopyInfo.bNewSrcFile = TRUE;
if (RC_BAD( rc = flmCopyFile( gv_FlmSysData.pFileSystem,
0, 0xFFFFFFFF,
&DbCopyInfo, &pCopiedList, NULL, TRUE,
fnStatusCallback, UserData)))
{
goto Exit;
}
}
else
{
// Create the destination RFL directory, if needed. The purpose of this
// code is two-fold: 1) We want to keep track of the fact that we tried
// to create the destination RFL directory so we can try to remove it
// if the copy fails; 2) If the destination RFL directory path specifies
// a directory with existing files, we want to remove them.
if( RC_BAD( rc = rflGetDirAndPrefix( uiDbVersion, pszDestDbName,
pszDestRflDir, pszActualDestRflPath, pszDestPrefix)))
{
goto Exit;
}
if( RC_OK( gv_FlmSysData.pFileSystem->doesFileExist(
pszActualDestRflPath)))
{
if( gv_FlmSysData.pFileSystem->isDir( pszActualDestRflPath))
{
// Remove the existing directory and all files, etc.
(void)gv_FlmSysData.pFileSystem->removeDir(
pszActualDestRflPath, TRUE);
}
else
{
(void)gv_FlmSysData.pFileSystem->deleteFile( pszActualDestRflPath);
}
}
// Try to create the destination RFL directory. This might fail if
// another process was accessing the directory for some reason
// (i.e., from a command prompt), when we tried to remove it above.
// We really don't care if the call to CreateDir is sucessful, because
// when we try to create the destination files (below), the FLAIM file
// file system code will try to create any necessary directories.
(void)gv_FlmSysData.pFileSystem->createDir( pszActualDestRflPath);
bCreatedDestRflDir = TRUE;
// Copy the RFL files. NOTE: We need to copy all of the RFL files
// in the source RFL directory so that they will be available
// when performing a database restore operation.
if (RC_BAD( rc = gv_FlmSysData.pFileSystem->openDir(
pszActualSrcRflPath, (char *)"*", &pDirHdl)))
{
goto Exit;
}
for (;;)
{
if( RC_BAD( rc = pDirHdl->next()))
{
if (rc == FERR_IO_NO_MORE_FILES)
{
rc = FERR_OK;
break;
}
else
{
goto Exit;
}
}
// If the current file is an RFL file, copy it to the destination
if( rflGetFileNum( uiDbVersion, pszSrcPrefix,
pDirHdl->currentItemName(), &uiFileNumber))
{
// Get the source file path and the destination file path.
if (RC_BAD( rc = rflGetFileName( uiDbVersion, pszSrcDbName,
pszSrcRflDir, uiFileNumber,
DbCopyInfo.szSrcFileName)))
{
goto Exit;
}
if (RC_BAD( rc = rflGetFileName( uiDbVersion, pszDestDbName,
pszDestRflDir, uiFileNumber,
DbCopyInfo.szDestFileName)))
{
goto Exit;
}
DbCopyInfo.bNewSrcFile = TRUE;
if (RC_BAD( rc = flmCopyFile( gv_FlmSysData.pFileSystem,
0, 0xFFFFFFFF,
&DbCopyInfo, &pCopiedList, NULL, TRUE,
fnStatusCallback, UserData)))
{
goto Exit;
}
}
}
pDirHdl->Release();
pDirHdl = NULL;
}
// Do one final copy on the control file to copy just the first 2K
if (RC_BAD( rc = pSrcSFileHdl->getFilePath( 0, DbCopyInfo.szSrcFileName)))
{
goto Exit;
}
if (RC_BAD( rc = pDestSFileHdl->getFilePath( 0, DbCopyInfo.szDestFileName)))
{
goto Exit;
}
DbCopyInfo.bNewSrcFile = FALSE;
if (RC_BAD( rc = flmCopyFile( gv_FlmSysData.pFileSystem,
0, 2048,
&DbCopyInfo, NULL, pucInMemLogHdr, FALSE,
fnStatusCallback, UserData)))
{
goto Exit;
}
Exit:
if (bUsedFFile)
{
if (!bMutexLocked)
{
f_mutexLock( gv_FlmSysData.hShareMutex);
bMutexLocked = TRUE;
}
if (!(--pFile->uiUseCount))
{
flmLinkFileToNUList( pFile);
}
}
if (bMutexLocked)
{
f_mutexUnlock( gv_FlmSysData.hShareMutex);
bMutexLocked = FALSE;
}
if (bWriteLocked)
{
if( RC_BAD( rc = pWriteLockObj->unlock()))
{
goto Exit;
}
bWriteLocked = FALSE;
}
if (bFileLocked)
{
RCODE rc3;
if (RC_BAD( rc3 = pFileLockObj->unlock()))
{
if (RC_OK( rc))
rc = rc3;
}
bFileLocked = FALSE;
}
if (pWriteLockObj)
{
pWriteLockObj->Release();
pWriteLockObj = NULL;
}
if (pFileLockObj)
{
pFileLockObj->Release();
pFileLockObj = NULL;
}
if (pLockFileHdl)
{
pLockFileHdl->Release();
pLockFileHdl = NULL;
}
if( pTmpFileHdl)
{
pTmpFileHdl->Release();
}
if( pDirHdl)
{
pDirHdl->Release();
}
// Free all the names of files that were copied.
// If the copy didn't finish, try to delete any files
// that were copied.
while (pCopiedList)
{
COPIED_NAME * pNext = pCopiedList->pNext;
// If the overall copy failed, delete the copied file.
if (RC_BAD( rc))
{
(void)gv_FlmSysData.pFileSystem->deleteFile( pCopiedList->szPath);
}
f_free( &pCopiedList);
pCopiedList = pNext;
}
if( RC_BAD( rc) && bCreatedDestRflDir)
{
(void)gv_FlmSysData.pFileSystem->removeDir( pszActualDestRflPath);
}
if( pszActualSrcRflPath)
{
f_free( &pszActualSrcRflPath);
}
if( hWaitSem != F_SEM_NULL)
{
f_semDestroy( &hWaitSem);
}
if( pSrcSFileHdl)
{
pSrcSFileHdl->Release();
}
if( pSrcSFileClient)
{
pSrcSFileClient->Release();
}
if( pDestSFileHdl)
{
pDestSFileHdl->Release();
}
if( pDestSFileClient)
{
pDestSFileClient->Release();
}
return( rc);
}
