/****************************************************************************
Desc: This is a private method that will truncate the spill file back to
the specified size.
****************************************************************************/
RCODE F_MultiFileHdl::truncateFile(
FLMUINT64 ui64NewSize)
{
RCODE rc = NE_FLM_OK;
FLMUINT uiFileNum = getFileNum( ui64NewSize);
IF_FileHdl * pFileHdl;
if( RC_BAD( rc = getFileHdl( uiFileNum, TRUE, &pFileHdl)))
{
goto Exit;
}
if (RC_BAD( rc = pFileHdl->truncateFile( getFileOffset( ui64NewSize))))
{
goto Exit;
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Copy a file that is one of the files of the database.
*****************************************************************************/
FSTATIC RCODE flmCopyFile(
IF_FileSystem * pFileSystem,
FLMUINT uiStartOffset,
FLMUINT uiEndOffset,
DB_COPY_INFO * pDbCopyInfo,
COPIED_NAME ** ppCopiedListRV,
FLMBYTE * pucInMemLogHdr,
FLMBOOL bOkToTruncate,
STATUS_HOOK fnStatusCallback,
void * UserData)
{
RCODE rc = FERR_OK;
FLMBYTE * pucBuffer = NULL;
IF_FileHdl * pSrcFileHdl = NULL;
IF_FileHdl * pDestFileHdl = NULL;
FLMUINT uiBufferSize = 32768;
FLMUINT uiBytesToRead;
FLMUINT uiBytesRead;
FLMUINT uiBytesWritten;
FLMUINT uiOffset;
FLMBYTE * pucLogHdr = NULL;
FLMUINT uiNewChecksum;
FLMBOOL bCreatedDestFile = FALSE;
// Open the source file.
if( RC_BAD( rc = gv_FlmSysData.pFileSystem->openFile(
pDbCopyInfo->szSrcFileName, gv_FlmSysData.uiFileOpenFlags,
&pSrcFileHdl)))
{
goto Exit;
}
// First attempt to open the destination file. If it does
// not exist, attempt to create it.
if (RC_BAD( rc = gv_FlmSysData.pFileSystem->openFile(
pDbCopyInfo->szDestFileName, gv_FlmSysData.uiFileOpenFlags,
&pDestFileHdl)))
{
if (rc != FERR_IO_PATH_NOT_FOUND &&
rc != FERR_IO_INVALID_PATH)
{
goto Exit;
}
if( RC_BAD( rc = gv_FlmSysData.pFileSystem->createFile(
pDbCopyInfo->szDestFileName, gv_FlmSysData.uiFileCreateFlags,
&pDestFileHdl)))
{
goto Exit;
}
bCreatedDestFile = TRUE;
}
// Allocate a buffer for reading and writing
if( RC_BAD( rc = f_allocAlignedBuffer( uiBufferSize, &pucBuffer)))
{
goto Exit;
}
// Allocate a buffer for the log header
if( RC_BAD( rc = f_allocAlignedBuffer( 2048, &pucLogHdr)))
{
goto Exit;
}
// If uiStartOffset is 2048, it is the special case of
// the control file, and we are not copying the first 2K.
// However, we need to set up the first 2K so that if
// someone reads the first 2K, it will return them a
// maintenance in progress error.
if (uiStartOffset == 2048)
{
// Read the first 2K of the source file.
if (RC_BAD( rc = pSrcFileHdl->read( 0, 2048, pucBuffer, &uiBytesRead)))
{
if (rc == FERR_IO_END_OF_FILE)
{
rc = FERR_OK;
}
else
{
goto Exit;
}
}
// Zero out whatever part of the 2K we didn't get on the read.
if (uiBytesRead < 2048)
{
f_memset( &pucBuffer[ uiBytesRead], 0, (int)(2048 - uiBytesRead));
}
// Attempt to read the log header from the destination file.
// It is OK if we can't read it, because if we created the
// destination file, these bytes may not be present.
if( bCreatedDestFile ||
RC_BAD( pDestFileHdl->read( 0, 2048, pucLogHdr, &uiBytesRead)))
{
f_memset( pucLogHdr, 0, sizeof( 2048));
}
// Set the transaction ID to zero. MUST ALSO SET THE TRANS ACTIVE FLAG
// TO FALSE - OTHERWISE READERS WILL ATTEMPT TO DECREMENT THE
// TRANSACTION ID AND WILL END UP WITH 0xFFFFFFFF - very bad!
// We must use zero, because it is the only transaction ID that will not
// appear on ANY block.
UD2FBA( 0, &pucLogHdr[ 16 + LOG_CURR_TRANS_ID]);
// Recalculate the log header checksum so that readers will not get a
// checksum error.
uiNewChecksum = lgHdrCheckSum( &pucLogHdr[ 16], FALSE);
UW2FBA( (FLMUINT16)uiNewChecksum, &pucLogHdr[ 16 + LOG_HDR_CHECKSUM]);
f_memcpy( &pucBuffer[ 16], &pucLogHdr[ 16], LOG_HEADER_SIZE);
// Write this "special" first 2K into the destination file.
// The real first 2K from the source file will be copied in
// at a later time.
if (RC_BAD( rc = pDestFileHdl->write( 0, 2048,
pucBuffer, &uiBytesWritten)))
{
goto Exit;
}
// Save the log header to the in-memory version of the log
// header as well - if pucInMemLogHdr is NULL, it is pointing
// to the pFile->ucLastCommittedLogHdr buffer.
if (pucInMemLogHdr)
{
f_memcpy( pucInMemLogHdr, &pucLogHdr[ 16], LOG_HEADER_SIZE);
}
}
// Read from source file until we hit EOF in the file or
// we hit the end offset.
uiOffset = uiStartOffset;
for (;;)
{
uiBytesToRead = (FLMUINT)((uiEndOffset - uiOffset >=
uiBufferSize)
? uiBufferSize
: (FLMUINT)(uiEndOffset - uiOffset));
// Read data from source file.
if (RC_BAD( rc = pSrcFileHdl->read( uiOffset, uiBytesToRead,
pucBuffer, &uiBytesRead)))
{
if (rc == FERR_IO_END_OF_FILE)
{
rc = FERR_OK;
if (!uiBytesRead)
{
break;
}
}
else
{
goto Exit;
}
}
// Write data to destination file.
if (RC_BAD( rc = pDestFileHdl->write( uiOffset,
uiBytesRead, pucBuffer, &uiBytesWritten)))
{
goto Exit;
}
// See if we wrote out the buffer that has the log header
// If so, we need to copy it back to the in-memory log
// header.
if ((pucInMemLogHdr) &&
(uiOffset <= 16) &&
(uiOffset + uiBytesWritten >= 16 + LOG_HEADER_SIZE))
{
f_memcpy( pucInMemLogHdr, &pucBuffer[ 16 - uiOffset],
LOG_HEADER_SIZE);
}
uiOffset += uiBytesWritten;
// Do callback to report progress.
if (fnStatusCallback)
{
pDbCopyInfo->ui64BytesCopied += (FLMUINT64)uiBytesWritten;
if (RC_BAD( rc = (*fnStatusCallback)( FLM_DB_COPY_STATUS,
(void *)pDbCopyInfo,
(void *)0, UserData)))
{
goto Exit;
}
pDbCopyInfo->bNewSrcFile = FALSE;
}
// Quit once we reach the end offset or we read fewer bytes
// than we asked for.
if (uiOffset >= uiEndOffset || uiBytesRead < uiBytesToRead)
{
break;
}
}
// If we overwrote the destination file, as opposed to creating
// it, truncate it in case it was larger than the number of
// bytes we actually copied.
if (!bCreatedDestFile && bOkToTruncate)
{
if (RC_BAD( rc = pDestFileHdl->truncateFile( uiOffset)))
{
goto Exit;
}
}
// If the copy succeeded, add the destination name to a list
// of destination files. This is done so we can clean up
// copied files if we fail somewhere in the overall database
// copy.
if (ppCopiedListRV)
{
COPIED_NAME * pCopyName;
if( RC_BAD( rc = f_alloc(
(FLMUINT)sizeof( COPIED_NAME), &pCopyName)))
{
goto Exit;
}
f_strcpy( pCopyName->szPath, pDbCopyInfo->szDestFileName);
pCopyName->pNext = *ppCopiedListRV;
*ppCopiedListRV = pCopyName;
}
Exit:
if( pucBuffer)
{
f_freeAlignedBuffer( &pucBuffer);
}
if( pucLogHdr)
{
f_freeAlignedBuffer( &pucLogHdr);
}
if( pSrcFileHdl)
{
pSrcFileHdl->Release();
}
if( pDestFileHdl)
{
pDestFileHdl->flush();
pDestFileHdl->Release();
}
// Attempt to delete the destination file if
// we didn't successfully copy it.
if( RC_BAD( rc))
{
(void)pFileSystem->deleteFile( pDbCopyInfo->szDestFileName);
}
return( rc);
}