colin
/
tripwire-open-source
mirror of https://github.com/Tripwire/tripwire-open-source.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
tripwire-open-source/src/db/blockfile.cpp

364 lines
12 KiB
C++
Raw Blame History

//
// The developer of the original code and/or files is Tripwire, Inc.
// Portions created by Tripwire, Inc. are copyright (C) 2000-2018 Tripwire,
// Inc. Tripwire is a registered trademark of Tripwire, Inc. All rights
// reserved.
//
// This program is free software. The contents of this file are subject
// to the terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at your
// option) any later version. You may redistribute it and/or modify it
// only in compliance with the GNU General Public License.
//
// This program is distributed in the hope that it will be useful.
// However, this program is distributed AS-IS WITHOUT ANY
// WARRANTY; INCLUDING THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS
// FOR A PARTICULAR PURPOSE. Please 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, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
//
// Nothing in the GNU General Public License or any other license to use
// the code or files shall permit you to use Tripwire's trademarks,
// service marks, or other intellectual property without Tripwire's
// prior written consent.
//
// If you have any questions, please contact Tripwire, Inc. at either
// info@tripwire.org or www.tripwire.org.
//
///////////////////////////////////////////////////////////////////////////////
// blockfile.cpp
#include "stddb.h"
#ifndef __TCHAR_H
# error
#endif
#include "blockfile.h"
#include "core/archive.h"
#include "core/debug.h"
#include "core/archive.h"
#include <vector>
//-----------------------------------------------------------------------------
// cBlockFile
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// ctor
///////////////////////////////////////////////////////////////////////////////
cBlockFile::cBlockFile() : mNumPages(-1), mNumBlocks(-1), mTimer(0), mpArchive(0)
{
#ifdef _BLOCKFILE_DEBUG
mNumBlockWrite = 0;
mNumBlockRead = 0;
mNumPageFault = 0;
mNumPageRequests = 0;
#endif //_BLOCKFILE_DEBUG
}
///////////////////////////////////////////////////////////////////////////////
// dtor
///////////////////////////////////////////////////////////////////////////////
cBlockFile::~cBlockFile()
{
Close();
}
///////////////////////////////////////////////////////////////////////////////
// Open
///////////////////////////////////////////////////////////////////////////////
void cBlockFile::Open(const TSTRING& fileName, int numPages, bool bTruncate) //throw (eArchive)
{
ASSERT(numPages > 0);
ASSERT(!mpArchive);
cFileArchive* pArch = new cFileArchive;
pArch->OpenReadWrite(fileName.c_str(), (bTruncate ? cFileArchive::FA_OPEN_TRUNCATE : 0));
Open(pArch, numPages);
}
void cBlockFile::Open(cBidirArchive* pArch, int numPages) //throw (eArchive)
{
ASSERT(numPages > 0);
ASSERT(!mpArchive);
//
// keep my sanity...
//
pArch->Seek(0, cBidirArchive::BEGINNING);
//
// initialize the paged blocks list...
//
mpArchive = pArch;
mNumPages = numPages;
mvPagedBlocks.resize(mNumPages);
ASSERT(mvPagedBlocks.capacity() == mNumPages); // make sure that we didn't alloc too many!
//
// if the file is newly created, set its size to that of a single block
//
if (mpArchive->Length() == 0)
{
mpArchive->WriteBlob(mvPagedBlocks[0].GetData(), GetBlockSize());
}
//
// make sure that the file is an appropriate length
// TODO -- what is the correct thing to do if this fails? right now, I assert, but
// perhaps I should throw an exception or increase the file size to the next block interval
ASSERT(mpArchive->Length() % GetBlockSize() == 0);
mNumBlocks = mpArchive->Length() / GetBlockSize();
}
///////////////////////////////////////////////////////////////////////////////
// Close
///////////////////////////////////////////////////////////////////////////////
void cBlockFile::Close()
{
if (mpArchive)
{
Flush();
delete mpArchive;
mpArchive = 0;
}
}
///////////////////////////////////////////////////////////////////////////////
// Flush
///////////////////////////////////////////////////////////////////////////////
void cBlockFile::Flush()
{
ASSERT(mpArchive);
for (BlockVector::iterator i = mvPagedBlocks.begin(); i != mvPagedBlocks.end(); ++i)
{
FlushBlock(&(*i));
}
}
///////////////////////////////////////////////////////////////////////////////
// GetBlock
///////////////////////////////////////////////////////////////////////////////
cBlockFile::Block* cBlockFile::GetBlock(int blockNum) //throw (eArchive)
{
#ifdef _BLOCKFILE_DEBUG
mNumPageRequests++;
AssertValid();
#endif
//
// debug stuff
//
cDebug d("cBlockFile::GetBlock");
d.TraceNever("Request for block %d\n", blockNum);
//TODO -- I should really throw an exception here...
ASSERT((blockNum >= 0) && (blockNum < GetNumBlocks()));
ASSERT(mpArchive);
//
// first, increment the timer; if it flips, reset everybody's access times to 0.
//
mTimer++;
if (mTimer == 0)
{
for (BlockVector::iterator i = mvPagedBlocks.begin(); i != mvPagedBlocks.end(); ++i)
{
i->SetTimestamp(0);
}
}
//
// now, see if the desired block is in memory...
//
for (BlockVector::iterator i = mvPagedBlocks.begin(); i != mvPagedBlocks.end(); ++i)
{
if (i->GetBlockNum() == blockNum)
{
// this is easy; just return the block.
i->SetTimestamp(mTimer);
d.TraceNever("\tBlock %d was in memory.\n", blockNum);
return &(*i);
}
}
//
// ok, we are going to have to page it into memory; look for the page with the earliest timestamp to
// remove...
//
#ifdef _BLOCKFILE_DEBUG
mNumPageFault++;
#endif
d.TraceNever("\tBlock %d was not in memory; paging it in\n", blockNum);
uint32_t earliestTime = mvPagedBlocks[0].GetTimestamp();
BlockVector::iterator it = mvPagedBlocks.begin();
BlockVector::iterator earliestIter = it;
++it; // since we don't want to check the first one
ASSERT(it != mvPagedBlocks.end());
for (; it != mvPagedBlocks.end(); ++it)
{
if (it->GetTimestamp() < earliestTime)
{
earliestIter = it;
earliestTime = it->GetTimestamp();
}
}
ASSERT((earliestIter >= mvPagedBlocks.begin()) && (earliestIter < mvPagedBlocks.end()));
//
// flush the page data to disk if it is dirty...
//
FlushBlock(&(*earliestIter));
d.TraceNever("\tPaging out block %d\n", earliestIter->GetBlockNum());
//
// ok, now we can read in the new page...
//
earliestIter->SetBlockNum(blockNum);
earliestIter->Read(*mpArchive);
earliestIter->SetTimestamp(mTimer);
//
// this variable keeps track of how many block reads we do.
#ifdef _BLOCKFILE_DEBUG
mNumBlockRead++;
AssertValid();
#endif
return &(*earliestIter);
}
///////////////////////////////////////////////////////////////////////////////
// CreateBlock
///////////////////////////////////////////////////////////////////////////////
cBlockFile::Block* cBlockFile::CreateBlock()
{
// debug stuff
//
ASSERT(mpArchive);
cDebug d("cBlockFile::CreateBlock()");
d.TraceDetail("Creating new block (number %d)\n", GetNumBlocks());
char emptyBlock[BLOCK_SIZE];
memset(emptyBlock, 0, BLOCK_SIZE);
//
// write empty data in the new block's location
//
//ASSERT(GetNumBlocks() * GetBlockSize() <= mpArchive->Length());
d.TraceDetail("Seeking to %d * %d = %d\n", GetNumBlocks(), GetBlockSize(), GetNumBlocks() * GetBlockSize());
mpArchive->Seek(GetNumBlocks() * GetBlockSize(), cBidirArchive::BEGINNING);
mpArchive->WriteBlob(emptyBlock, BLOCK_SIZE);
//
// now, page it in...
//
mNumBlocks++;
return GetBlock(GetNumBlocks() - 1);
}
///////////////////////////////////////////////////////////////////////////////
// DestroyLastBlock
///////////////////////////////////////////////////////////////////////////////
void cBlockFile::DestroyLastBlock()
{
//TODO -- implement this!!!
ASSERT(false);
/*
mNumBlocks--;
mpArchive->Seek( mNumBlocks * BLOCK_SIZE, cBidirArchive::BEGINNING );
mpArchive->Truncate();
AssertValid();
*/
}
//-----------------------------------------------------------------------------
// Debug methods...
//-----------------------------------------------------------------------------
#ifdef _BLOCKFILE_DEBUG
///////////////////////////////////////////////////////////////////////////////
// TraceContents
///////////////////////////////////////////////////////////////////////////////
void cBlockFile::TraceContents(int dl) const
{
cDebug d("cBlockFile::TraceContents");
if (dl == -1)
dl = cDebug::D_DEBUG;
d.Trace(dl, "Block size: %d\n", GetBlockSize());
d.Trace(dl, "Number of blocks: %d\n", mNumBlocks);
d.Trace(dl, "Current timer: %d\n", mTimer);
//
// trace out the profiling info...
//
d.Trace(dl, "Number of page writes: %d\n", mNumBlockWrite);
d.Trace(dl, "Number of page reads: %d\n", mNumBlockRead);
d.Trace(dl, "Number of page faults: %d\n", mNumPageFault);
d.Trace(dl, "Number of page requests:%d\n", mNumPageRequests);
d.Trace(dl, "Number of pages: %d\n", mNumPages);
d.Trace(dl, "-------------------------\n");
//
// trace out all the block information...
//
int cnt = 0;
for (BlockVector::const_iterator i = mvPagedBlocks.begin(); i != mvPagedBlocks.end(); i++, cnt++)
{
d.Trace(dl,
"Page[%d] Block Num=%d Timestamp=%d Dirty=%s\n",
cnt,
i->GetBlockNum(),
i->GetTimestamp(),
i->IsDirty() ? "true" : "false");
}
d.Trace(dl, "-------------------------\n");
}
///////////////////////////////////////////////////////////////////////////////
// CreateBlock
///////////////////////////////////////////////////////////////////////////////
void cBlockFile::AssertValid() const
{
if (!mpArchive)
return;
//
// make sure the archive length and block count match up
//
# ifdef DEBUG
if (mpArchive->Length() != (GetBlockSize() * GetNumBlocks()))
{
cDebug d("cBlockFile::AssertValid");
d.Trace(cDebug::D_DEBUG, "FATAL ERROR!!!\n");
d.Trace(cDebug::D_DEBUG,
"mpArchive->Length() = %d \n\t!= blocksize * numblocks = %d * %d\n",
int(mpArchive->Length()),
int(GetBlockSize()),
int(GetNumBlocks()));
d.Trace(cDebug::D_DEBUG, "now tracing the contents...\n");
TraceContents(cDebug::D_DEBUG);
}
# endif
ASSERT(mpArchive->Length() == (GetBlockSize() * GetNumBlocks()));
//
// iterate through the pages...
//
for (BlockVector::const_iterator i = mvPagedBlocks.begin(); i != mvPagedBlocks.end(); i++)
{
// make sure the block number is valid
//
int blockNum = i->GetBlockNum();
ASSERT((blockNum == cBlock<BLOCK_SIZE>::INVALID_NUM) || ((blockNum >= 0) && (blockNum < GetNumBlocks())));
//
// make sure the time stamp is less than or equal to the timer time...
//
ASSERT(i->GetTimestamp() <= mTimer);
//
// assert that the guard bytes haven't been modified
i->AssertValid();
}
}
#endif //_BLOCKFILE_DEBUG
Reference in New Issue View Git Blame Copy Permalink