windows-xp/Source/XPSP1/NT/inetsrv/query/ntciutil/phystr.cxx

//+---------------------------------------------------------------------------
//
//  Microsoft Corporation
//  Copyright (C) Microsoft Corporation, 1992 - 1998.
//
//  File:       PhysIdx.CXX
//
//  Contents:   FAT Buffer/Index package
//
//  Classes:    CPhysBuffer -- Buffer
//
//  History:    05-Mar-92   KyleP       Created
//              07-Aug-92   KyleP       Kernel implementation
//              21-Apr-93   BartoszM    Rewrote to use memory mapped files
//
//----------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#include <pstore.hxx>
#include <phystr.hxx>
#include <eventlog.hxx>
#include <psavtrak.hxx>

//+-------------------------------------------------------------------------
//
//  Function:   PageToLow
//
//  Returns:    Low part of byte count in cPage pages
//
//  History:    21-Apr-93       BartoszM        Created
//
//--------------------------------------------------------------------------

inline ULONG PageToLow(ULONG cPage)
{
    return(cPage << CI_PAGE_SHIFT);
}

//+-------------------------------------------------------------------------
//
//  Function:   PageToHigh
//
//  Returns:    High part of byte count in cPage pages
//
//  History:    21-Apr-93       BartoszM        Created
//
//--------------------------------------------------------------------------

inline ULONG PageToHigh(ULONG cPage)
{
    return(cPage >> (ULONG_BITS - CI_PAGE_SHIFT));
}

//+-------------------------------------------------------------------------
//
//  Function:   ToPages
//
//  Returns:    Number of pages equivalent to (cbLow, cbHigh) bytes
//
//  History:    21-Apr-93       BartoszM        Created
//
//--------------------------------------------------------------------------

inline ULONG ToPages ( ULONG cbLow, ULONG cbHigh )
{
    Win4Assert ( cbHigh >> CI_PAGE_SHIFT == 0 );
    return (cbLow >> CI_PAGE_SHIFT) + (cbHigh << (ULONG_BITS - CI_PAGE_SHIFT));
}

//+-------------------------------------------------------------------------
//
//  Function:   PgCommonPgTrunc
//
//  Returns:    Number of pages truncated to multiple of largest common page
//
//  History:    21-Apr-93       BartoszM        Created
//
//--------------------------------------------------------------------------

inline ULONG PgCommonPgTrunc(ULONG nPage)
{
    return nPage & ~(PAGES_PER_COMMON_PAGE - 1);
}

inline ULONGLONG MAKEULONGLONG( ULONG l, ULONG h )
{
    return ( l | ( h << 32 ) );
}

//+-------------------------------------------------------------------------
//
//  Function:   PgCommonPgRound
//
//  Returns:    Number of pages rounded to multiple of largest common page
//
//  History:    21-Apr-93       BartoszM        Created
//
//--------------------------------------------------------------------------

inline ULONG PgCommonPgRound(ULONG nPage)
{
    return (nPage + PAGES_PER_COMMON_PAGE - 1) & ~(PAGES_PER_COMMON_PAGE - 1);
}

//+-------------------------------------------------------------------------
//
//  Member:     CPhysBuffer::~CPhysBuffer
//
//  History:    07-Dec-93   BartoszM    Created
//
//--------------------------------------------------------------------------

CPhysBuffer::~CPhysBuffer()
{
    Win4Assert( !_fNeedToFlush );

#if CIDBG == 1
    Flush( FALSE );
#endif
}

//+-------------------------------------------------------------------------
//
//  Member:     CPhysBuffer::CPhysBuffer, public
//
//  Synopsis:   Allocates virtual memory
//
//  Arguments:  [stream]         -- stream to use
//              [PageNo]         -- page number
//              [fWrite]         -- for writable memory
//              [fIntentToWrite] -- When fWrite is TRUE, whether the
//                                  client intends to write to the memory so
//                                  it needs to be flushed.
//
//  History:    10-Mar-92 KyleP     Created
//              21-Apr-93 BartoszM  Rewrote to use memory mapped files
//
//--------------------------------------------------------------------------

CPhysBuffer::CPhysBuffer(
    PMmStream& stream,
    ULONG      PageNo,
    BOOL       fWrite,
    BOOL       fIntentToWrite,
    BOOL       fMap ) :
    _cRef( 0 ),
    _pphysNext( 0 ),
    _fNeedToFlush( fIntentToWrite ),
    _fWrite( fWrite ),
    _fMap( fMap ),
    _stream( stream )
{
    _PageNo = PgCommonPgTrunc( PageNo );

    if ( _fMap )
        stream.Map( _strmBuf,
                    COMMON_PAGE_SIZE,
                    PageToLow( _PageNo ),
                    PageToHigh( _PageNo ),
                    fWrite );
    else
    {
        DWORD cbRead;

        _xBuffer.Init( COMMON_PAGE_SIZE );
        _stream.Read( _xBuffer.Get(),
                      MAKEULONGLONG( PageToLow( _PageNo ),
                                     PageToHigh( _PageNo ) ),
                      COMMON_PAGE_SIZE,
                      cbRead );
    }
} //CPhysBuffer

//+-------------------------------------------------------------------------
//
//  Member:     CPhysBuffer::Flush, public
//
//  Synopsis:   Flushes the buffer to disk
//
//  Arguments:  [fFailFlush]     -- If TRUE and flush fails, an exception is
//                                  raised.  Otherwise failures to flush are
//                                  ignored.
//
//  History:    10/30/98    dlee    Moved out of header
//
//--------------------------------------------------------------------------

void CPhysBuffer::Flush( BOOL fFailFlush )
{
    if ( _fNeedToFlush )
    {
        Win4Assert( _fWrite );

        //
        // Reset the flag first, so subsequent attempts to flush won't
        // fail if first attempt fails.  This is so we don't throw
        // in destructors.  If we can't tolerate failures to flush, don't
        // even bother trying to write the data if we can't fail.
        //

        _fNeedToFlush = FALSE;

        if ( fFailFlush )
        {
            if ( _fMap )
            {
                // Flush the buffer and metadata in one call

                _strmBuf.Flush( TRUE );
            }
            else
            {
                _stream.Write( _xBuffer.Get(),
                               MAKEULONGLONG( PageToLow( _PageNo ),
                                              PageToHigh( _PageNo ) ),
                               COMMON_PAGE_SIZE );
            }
        }
        else
        {
            ciDebugOut(( DEB_WARN, "not flushing at %#p, in failure path?\n",
                         this ));
        }
    }

#if CIDBG == 1

    //
    // Make sure the bits on disk are the same as those in memory, since
    // the buffer is marked as not needing to be flushed.  Only do this if
    // using read/write instead of mapping.
    //

    else if ( !_fMap && fFailFlush )
    {
        TRY
        {
            XArrayVirtual<BYTE> xTmp( COMMON_PAGE_SIZE );
    
            DWORD cbRead;
            _stream.Read( xTmp.Get(),
                          MAKEULONGLONG( PageToLow( _PageNo ),
                                         PageToHigh( _PageNo ) ),
                          COMMON_PAGE_SIZE,
                          cbRead );
    
            if ( 0 != memcmp( xTmp.Get(), _xBuffer.Get(), COMMON_PAGE_SIZE ) )
            {
                ciDebugOut(( DEB_ERROR, "read: %p, have: %p\n",
                             xTmp.Get(), _xBuffer.Get() ));
                Win4Assert( !"writable non-flushed buffer was modified!" );
            }
        }
        CATCH( CException, e )
        {
            // Ignore -- it's just an assert.
        }
        END_CATCH;
    }
#endif // CIDBG == 1

} //Flush
    
//+-------------------------------------------------------------------------
//
//  Member:     CBufferCacheIter::CBufferCacheIter, public
//
//  Synopsis:   Constructor
//
//  History:    18-Mar-93 BartoszM     Created
//
//--------------------------------------------------------------------------

CBufferCacheIter::CBufferCacheIter ( CBufferCache& cache )
: _pPhysBuf(cache._aPhysBuf.GetPointer()), _idx(0), _cHash( cache._cHash )
{
    do
    {
        _pBuf = _pPhysBuf[_idx];
        if (_pBuf != 0)
            break;
        _idx++;
    } while ( _idx < _cHash );
} //CBufferCacheIter

//+-------------------------------------------------------------------------
//
//  Member:     CBufferCacheIter::operator++, public
//
//  Synopsis:   Increments the iterator
//
//  History:    18-Mar-93 BartoszM     Created
//
//--------------------------------------------------------------------------

void CBufferCacheIter::operator++()
{
    Win4Assert(_pBuf != 0);
    _pBuf = _pBuf->Next();
    while (_pBuf == 0 && ++_idx < _cHash )
        _pBuf = _pPhysBuf[_idx];
}

//+-------------------------------------------------------------------------
//
//  Member:     CBufferCache::CBufferCache, public
//
//  Synopsis:   Constructor
//
//  History:    18-Mar-93 BartoszM     Created
//
//--------------------------------------------------------------------------

CBufferCache::CBufferCache( unsigned cHash )
    : _cBuffers( 0 ),
      _cHash( cHash ),
      _aPhysBuf( cHash )
    #if CIDBG == 1
        , _cCacheHits( 0 ), _cCacheMisses( 0 )
    #endif

{
    RtlZeroMemory( _aPhysBuf.GetPointer(), _aPhysBuf.SizeOf() );
}

//+-------------------------------------------------------------------------
//
//  Member:     CBufferCache::~CBufferCache, public
//
//  Synopsis:   Destructor
//
//  History:    18-Mar-93 BartoszM     Created
//
//--------------------------------------------------------------------------

CBufferCache::~CBufferCache()
{
    Free( FALSE );
}

//+-------------------------------------------------------------------------
//
//  Member:     CBufferCache::Free, public
//
//  Synopsis:   Deletes all buffers
//
//  Arguments:  [fFailFlush]  -- If TRUE, this method will THROW if the flush
//                               fails.  If FALSE, flush failures are
//                               ignored.
//
//  History:    18-Mar-93 BartoszM     Created
//
//--------------------------------------------------------------------------

void CBufferCache::Free( BOOL fFailFlush )
{
    if ( 0 != _cBuffers )
    {
        for ( unsigned i = 0; i < _cHash; i++ )
        {
            // Keep the cache consistent in case we fail flushing.

            while ( 0 != _aPhysBuf[i] )
            {
                CPhysBuffer * pTemp = _aPhysBuf[i];

                pTemp->Flush( fFailFlush );

#if CIDBG == 1
                if ( pTemp->IsReferenced() )
                    ciDebugOut(( DEB_WARN,
                                 "Buffer for page %ld still referenced.\n",
                                 pTemp->PageNumber() ));
#endif // CIDBG == 1

                _aPhysBuf[i] = pTemp->Next();
                delete pTemp;
                _cBuffers--;
            }

            Win4Assert( 0 == _aPhysBuf[i] );
        }

        Win4Assert( 0 == _cBuffers );
    }
} //Free

//+-------------------------------------------------------------------------
//
//  Member:     CBufferCache::TryToRemoveBuffers, public
//
//  Synopsis:   Tries to remove unreferenced buffers from the cache.
//              If one is not found, it's not a problem.
//
//  Arguments:  [cMax] -- Recommended maximum in the cache
//
//  History:    15-March-96 dlee     Created
//
//--------------------------------------------------------------------------

void CBufferCache::TryToRemoveBuffers( unsigned cMax )
{
    for ( unsigned i = 0; i < 3 && ( Count() > cMax ); i++ )
    {
        // find an unreferenced page with the lowest (oldest) usn.
    
        ULONG ulPage = ULONG_MAX;
        ULONG ulUSN = ULONG_MAX;
    
        for ( CBufferCacheIter iter(*this); !iter.AtEnd(); ++iter )
        {
            CPhysBuffer * pPhys = iter.Get();
    
            Win4Assert( 0 != pPhys );
    
            if ( ( ulUSN > pPhys->GetUSN() ) &&
                 ( !pPhys->IsReferenced() ) )
            {
                ulUSN = pPhys->GetUSN();
                ulPage = pPhys->PageNumber();
            }
        }
    
        if ( ULONG_MAX == ulPage )
            break;
        else
            Destroy( ulPage );
    }
} //TryToRemoveBuffers

//+-------------------------------------------------------------------------
//
//  Member:     CBufferCache::Search, public
//
//  Synopsis:   Searches the buffer hash for the requested buffer.
//
//  Arguments:  [ulPage] -- Page number of page to be found.
//
//  Returns:    0 if page not currently buffered, or the pointer
//              to the (physical) buffer.
//
//  History:    09-Mar-92 KyleP     Created
//              17-Mar-93 BartoszM  Rewrote
//
//--------------------------------------------------------------------------

CPhysBuffer * CBufferCache::Search(
    ULONG hash,
    ULONG commonPage )
{
    // ciDebugOut (( DEB_ITRACE, "CBufferCache::Search %d\n", ulPage ));

    for ( CPhysBuffer *pPhys = _aPhysBuf[ hash ];
          0 != pPhys;
          pPhys = pPhys->Next() )
    {
        if ( pPhys->PageNumber() == commonPage )
            break;
    }

    #if DBG==1 || CIDBG==1
        if ( 0 == pPhys )
            _cCacheMisses++;
        else
            _cCacheHits++;
    #endif // DBG==1 || CIDBG==1

    return pPhys;
} //Search

//+---------------------------------------------------------------------------
//
//  Function:   Flush
//
//  Synopsis:   Flushes all cached pages upto and including the specified
//              page to disk.
//
//  Arguments:  [nHighPage] -- The "CI" page number below which all pages
//              must be flushed to disk.
//
//  History:    4-20-94   srikants   Created
//
//  Notes:      nHighPage is in units of "CI" page (4K bytes) and not
//              CommonPage which is 64K.
//
//----------------------------------------------------------------------------

void CBufferCache::Flush( ULONG nHighPage, BOOL fLeaveFlushFlagAlone )
{
    nHighPage = PgCommonPgTrunc(nHighPage);
    ciDebugOut(( DEB_ITRACE, "CBufferCache : Flushing All Pages <= 0x%x\n",
                 nHighPage ));

    if ( 0 == _cBuffers )
        return;

    //
    // We Must Flush All pages <= the given page number.
    //

    for ( CBufferCacheIter iter(*this); !iter.AtEnd(); ++iter )
    {
        CPhysBuffer * pPhys = iter.Get();

        Win4Assert( 0 != pPhys );

        if ( pPhys->PageNumber() <= nHighPage )
        {
            // Call flush even if not required to get assertions checked

            BOOL fRequiresFlush = pPhys->RequiresFlush();

            pPhys->Flush( TRUE );

            if ( fLeaveFlushFlagAlone && fRequiresFlush )
                pPhys->SetIntentToWrite();
        }
    }
} //Flush

//+-------------------------------------------------------------------------
//
//  Member:     CBufferCache::Destroy, public
//
//  Synopsis:   Deletes a buffer.
//
//  Arguments:  [ulPage] -- page number to be deleted
//
//  History:    18-Mar-93 BartoszM     Created
//
//--------------------------------------------------------------------------

void CBufferCache::Destroy( ULONG ulPage, BOOL fFailFlush )
{
    ulPage = PgCommonPgTrunc(ulPage);

    ULONG iHash = hash( ulPage );

    CPhysBuffer * pPhys = _aPhysBuf[ iHash ];
    Win4Assert( 0 != pPhys );

    // Find the page.  Don't remove from the list until it is flushed.
    // Is it first? (common case)

    if (pPhys->PageNumber() == ulPage)
    {
        // This should be flushed before being unmapped. Fix for bug 132655

        pPhys->Flush( fFailFlush );

        _aPhysBuf[iHash] = pPhys->Next();
    }
    else
    {
        // Search linked list

        CPhysBuffer * pPhysPrev;
        do
        {
            pPhysPrev = pPhys;
            pPhys = pPhys->Next();
            Win4Assert( 0 != pPhys );
        }
        while (pPhys->PageNumber() != ulPage );

        // This should be flushed before being unmapped. Fix for bug 132655

        pPhys->Flush( fFailFlush );

        // delete from the linked list

        pPhysPrev->Link( pPhys->Next() );
        Win4Assert ( !pPhys->IsReferenced() );
    }

    _cBuffers--;
    delete pPhys;
} //Destroy

//+-------------------------------------------------------------------------
//
//  Member:     CBufferCache::Add, public
//
//  Synopsis:   Adds a buffer to the buffer hash.
//
//  Arguments:  [pPhysBuf] -- Buffer to add.
//
//  History:    09-Mar-92 KyleP     Created
//
//--------------------------------------------------------------------------

void CBufferCache::Add( CPhysBuffer * pPhysBuf, ULONG hash )
{
    _cBuffers++;

    pPhysBuf->Reference();

    pPhysBuf->Link( _aPhysBuf[ hash ] );

    _aPhysBuf[ hash ] = pPhysBuf;
} //Add

//+-------------------------------------------------------------------------
//
//  Member:     CBufferCache::MinPageInUse, public
//
//  Synopsis:   Finds the smallest page in use within the cache
//
//  Returns :   TRUE if any page is in the cache; FALSE o/w
//              If TRUE is returned, then minPageInUse will contain the
//              minimum page that is present in the cache.
//
//  Arguments:  minPageInUse    (out) Will be set to the minimum page in
//              the cache if the return value is TRUE.
//
//  History:    02-May-94   DwightKr    Created
//              08-Dec-94   SrikantS    Fixed to return the correct value for
//                                      empty cache.
//
//--------------------------------------------------------------------------
BOOL CBufferCache::MinPageInUse(ULONG &minPageInUse)
{
    ULONG minPage = 0xFFFFFFFF;

    for (CBufferCacheIter iter(*this); !iter.AtEnd(); ++iter)
    {
        minPage = min(minPage, iter.Get()->PageNumber() );
    }

    if ( minPage == 0xFFFFFFFF )
    {
        return FALSE;
    }
    else
    {
        minPageInUse = minPage;
        return TRUE;
    }
} //MinPageInUse

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::CPhysStorage, public
//
//  Effects:    Creates a new index.
//
//  Arguments:  [storage]   -- physical storage to create index in
//              [obj]          -- Storage object
//              [objectId]  -- Index ID
//              [cPageReqSize] --
//              [stream]       -- Memory mapped stream
//              [fThrowCorruptErrorOnFailures  -- If true, then errors during
//                                                opening will be marked as
//                                                catalog corruption
//              [cCachedItems] -- # of non-referenced pages to cache
//              [fAllowReadAhead] -- if TRUE, non-mapped IO will be used
//                                   when the physical storage says it's ok.
//
//  Signals:    Cannot create.
//
//  Modifies:   A new index (file) is created on the disk.
//
//  History:    07-Mar-92 KyleP    Created
//
//--------------------------------------------------------------------------

CPhysStorage::CPhysStorage( PStorage & storage,
                            PStorageObject& obj,
                            WORKID objectId,
                            UINT cpageReqSize,
                            PMmStream * stream,
                            BOOL fThrowCorruptErrorOnFailures,
                            unsigned cCachedItems,
                            BOOL fAllowReadAhead )
        : _sigPhysStorage(eSigPhysStorage),
          _fWritable( TRUE ),
          _objectId( objectId ),
          _obj ( obj),
          _cpageUsedFileSize( 0 ),
          _storage(storage),
          _stream(stream),
          _iFirstNonShrunkPage( 0 ),
          _fThrowCorruptErrorOnFailures(fThrowCorruptErrorOnFailures),
          _cpageGrowth(1),
          _cMaxCachedBuffers( cCachedItems ),
          _cache( __max( 17, ( cCachedItems & 1 ) ? cCachedItems :
                                                    cCachedItems + 1 ) ),
          _usnGen( 0 ),
          _fAllowReadAhead( fAllowReadAhead )
{
    //
    // Use different locking schemes depending on usage
    //

    if ( 0 == _cMaxCachedBuffers )
        _xMutex.Set( new CMutexSem() );
    else
        _xRWAccess.Set( new CReadWriteAccess() );

    if ( _stream.IsNull() || !_stream->Ok() )
    {
        ciDebugOut((DEB_ERROR, "Index Creation failed %08x\n", objectId ));

        if ( _fThrowCorruptErrorOnFailures || _stream->FStatusFileNotFound() )
        {
           //
           // We don't have code to handle such failures, hence mark
           // catalog as corrupt; otherwise throw e_fail
           //
           Win4Assert( !"Corrupt catalog" );
           _storage.ReportCorruptComponent( L"PhysStorage1" );
           THROW( CException( CI_CORRUPT_DATABASE ));
        }
        else
           THROW( CException( E_FAIL ));
    }

    if (cpageReqSize == 0)
        cpageReqSize = 1;

    TRY
    {
        _GrowFile( cpageReqSize );
    }
    CATCH( CException, e )
    {
        //
        // There may not be enough space on the disk to allocate the
        // requested size.  If not enough space, do the best that we
        // can and hope space gets freed.
        //

        _GrowFile( 1 );
    }
    END_CATCH

    ciDebugOut(( DEB_ITRACE, "Physical index %08x created.\n", _objectId ));
}

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::CPhysStorage, public
//
//  Effects:    Opens an existing index.
//
//  Arguments:  [storage]   -- physical storage to open index in
//              [obj]       -- Storage object
//              [objectId]  -- Index ID.
//              [stream]    -- Memory mapped stream
//              [mode]      -- Open mode
//              [fThrowCorruptErrorOnFailures  -- If true, then errors during
//                                                opening will be marked as
//                                                catalog corruption
//              [cCachedItems] -- # of non-referenced pages to cache
//              [fAllowReadAhead] -- if TRUE, non-mapped IO will be used
//                                   when the physical storage says it's ok.
//
//  History:    07-Mar-92 KyleP    Created
//
//--------------------------------------------------------------------------

CPhysStorage::CPhysStorage( PStorage & storage,
                            PStorageObject& obj,
                            WORKID objectId,
                            PMmStream * stream,
                            PStorage::EOpenMode mode,
                            BOOL fThrowCorruptErrorOnFailures,
                            unsigned cCachedItems,
                            BOOL fAllowReadAhead )
        : _sigPhysStorage(eSigPhysStorage),
          _fWritable( PStorage::eOpenForWrite == mode ),
          _objectId( objectId ),
          _obj ( obj ),
          _cpageUsedFileSize( 0 ),
          _storage(storage),
          _stream(stream),
          _fThrowCorruptErrorOnFailures(fThrowCorruptErrorOnFailures),
          _cpageGrowth(1),
          _iFirstNonShrunkPage( 0 ),
          _cMaxCachedBuffers( cCachedItems ),
          _cache( __max( 17, ( cCachedItems & 1 ) ? cCachedItems :
                                                    cCachedItems + 1 ) ),
          _usnGen( 0 ),
          _fAllowReadAhead( fAllowReadAhead )
{
    //
    // Use different locking schemes depending on usage
    //

    if ( 0 == _cMaxCachedBuffers )
        _xMutex.Set( new CMutexSem() );
    else
        _xRWAccess.Set( new CReadWriteAccess() );

    if ( _stream.IsNull() || !_stream->Ok() )
    {
        ciDebugOut(( DEB_ERROR, "Open of index %08x failed\n", objectId ));

        if ( _fThrowCorruptErrorOnFailures || _stream->FStatusFileNotFound() )
        {
           //
           // We don't have code to handle such failures, hence mark
           // catalog as corrupt; otherwise throw e_fail
           //
           Win4Assert( !"Corrupt catalog" );
           _storage.ReportCorruptComponent( L"PhysStorage2" );
           THROW( CException( CI_CORRUPT_DATABASE ));
        }
        else
           THROW( CException( E_FAIL ));
    }

    _cpageFileSize = ToPages(_stream->SizeLow(), _stream->SizeHigh());

    ciDebugOut(( DEB_ITRACE, "Physical index %08x (%d pages) opened.\n",
            _objectId, _cpageFileSize ));
}


//+---------------------------------------------------------------------------
//
//  Member:     CPhysStorage::MakeBackupCopy
//
//  Synopsis:   Makes a backup copy of the current storage using the
//              destination storage.
//
//  Arguments:  [dst]             - Destination storage.
//              [progressTracker] - Progress tracking
//
//  History:    3-18-97   srikants   Created
//
//----------------------------------------------------------------------------

void CPhysStorage::MakeBackupCopy( CPhysStorage & dst,
                                   PSaveProgressTracker & progressTracker )
{
    //
    // Copy one page at a time.
    //
    ULONG * pSrcNext = 0;
    ULONG * pDstNext = 0;

    unsigned iCurrBorrow = 0; // always has the current buffers borrowed.

    SCODE sc = S_OK;

    TRY
    {
        //
        // Grow the destination to be as big as the current one.
        //
        dst._GrowFile( _cpageFileSize );

        if ( _cpageFileSize > 0 )
        {
            iCurrBorrow = 0;

            pSrcNext = BorrowBuffer(iCurrBorrow, FALSE );
            pDstNext = dst.BorrowNewBuffer(iCurrBorrow);

            const unsigned iLastPage = _cpageFileSize-1;

            for ( unsigned j = 0; j < _cpageFileSize; j++ )
            {
                ULONG * pSrc = pSrcNext;
                ULONG * pDst = pDstNext;

                Win4Assert( 0 != pSrc && 0 != pDst );

                RtlCopyMemory( pDst, pSrc, CI_PAGE_SIZE );

                //
                // Before returning buffers, grab the next ones to prevent
                // the large page from being taken out of cache.
                //

                if ( j != iLastPage )
                {
                    iCurrBorrow = j+1;
                    pSrcNext = BorrowBuffer(iCurrBorrow, FALSE );
                    pDstNext = dst.BorrowNewBuffer(iCurrBorrow);
                }
                else
                {
                    pSrcNext = pDstNext = 0;
                }

                ReturnBuffer( j );
                dst.ReturnBuffer( j, TRUE );

                if ( progressTracker.IsAbort() )
                    THROW( CException( STATUS_TOO_LATE ) );

                //
                // Update the progress every 64 K.
                //
                if ( (j % PAGES_PER_COMMON_PAGE) == (PAGES_PER_COMMON_PAGE-1) )
                    progressTracker.UpdateCopyProgress( (ULONG) j, _cpageFileSize );
            }
        }

        dst.Flush();
    }
    CATCH( CException, e )
    {
        if ( pSrcNext )
            ReturnBuffer( iCurrBorrow );

        if ( pDstNext )
            dst.ReturnBuffer(iCurrBorrow);

        sc = e.GetErrorCode();
    }
    END_CATCH

    if ( S_OK != sc )
    {
        //
        // _GrowFile throws CI_CORRUPT_DATABASE if it cannot create
        // the file that big. We don't want to consider that a
        // corruption.
        //
        if ( CI_CORRUPT_DATABASE == sc )
            sc = E_FAIL;

        THROW( CException( sc ) );
    }

    //
    // Consider 100% of the copy work is done.
    //
    progressTracker.UpdateCopyProgress( 1,1 );
}


//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::~CPhysStorage, public
//
//  Synopsis:   closes index.
//
//  History:    09-Mar-92 KyleP     Created
//
//  Notes:      Don't write back pages. This is either a read only
//              index or we are aborting a merge. Pages are written
//              back after a successful merge using Reopen().
//
//--------------------------------------------------------------------------

CPhysStorage::~CPhysStorage()
{
    ciDebugOut(( DEB_ITRACE, "Physical index %lx closed.\n", _objectId ));

    _cache.Free( FALSE );
}

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::Close, public
//
//  Effects:    Closes the stream.
//
//  History:    07-Mar-92 KyleP    Created
//
//--------------------------------------------------------------------------

void CPhysStorage::Close()
{
    _cache.Free();
    _stream.Free();
}

//+---------------------------------------------------------------------------
//
//  Function:   Flush
//
//  Synopsis:   Flushes all the pages that were unmapped since the last
//              flush.
//
//  History:    4-29-94   srikants   Created
//
//  Notes:
//
//----------------------------------------------------------------------------

void CPhysStorage::Flush( BOOL fLeaveFlushFlagAlone )
{
    Win4Assert( _fWritable );

    // Grab the lock to make sure the pages aren't deleted while
    // they are being flushed.

    if ( 0 == _cMaxCachedBuffers )
    {
        CLock lock( _xMutex.GetReference() );

        _cache.Flush( ULONG_MAX, fLeaveFlushFlagAlone );
    }
    else
    {
        CReadAccess readLock( _xRWAccess.GetReference() );

        _cache.Flush( ULONG_MAX, fLeaveFlushFlagAlone );
    }
} //Flush

//+---------------------------------------------------------------------------
//
//  Function:   ShrinkToFit
//
//  Synopsis:   Reduces the size of the stream by giving up pages in the end
//              which are not needed.
//
//  Arguments:  (none)
//
//  History:    9-08-94   srikants   Created
//
//  Notes:
//
//----------------------------------------------------------------------------

void CPhysStorage::ShrinkToFit()
{
    _cache.Free();
    _stream->SetSize( _storage,
                      PageToLow(_cpageUsedFileSize),
                      PageToHigh(_cpageUsedFileSize) );
    _cpageFileSize = _cpageUsedFileSize;
}

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::Reopen, public
//
//  Synopsis:   Flushes, closes, and reopens for reading.
//
//  History:    09-Mar-92 KyleP     Created
//              26-Aug-92 BartoszM  Separated from destructor
//              06-May-94 Srikants  Add fSetSize as a parameter to truncate
//                                  the stream optionally.
//
//--------------------------------------------------------------------------
void CPhysStorage::Reopen( BOOL fWritable )
{
    // No need to lock.

    _cache.Free(); // will flush all buffers

    if ( _fWritable && !_stream.IsNull() )
    {
        //
        // Give it an accurate used length.
        //

        _stream->SetSize( _storage,
                          PageToLow(_cpageUsedFileSize),
                          PageToHigh(_cpageUsedFileSize) );

        _cpageFileSize = _cpageUsedFileSize;

        _stream.Free();

        //
        // reopen shadow indexes as read and master indexes as write to
        // support shrink from front.
        //

        _fWritable = fWritable;
    }

    //
    // reopen it with the new mode
    //

    ReOpenStream();

    if ( _stream.IsNull() || !_stream->Ok() )
    {
        ciDebugOut(( DEB_ERROR, "Re-Open file of index %08x failed\n",
                     _objectId ));

        if ( _fThrowCorruptErrorOnFailures || _stream->FStatusFileNotFound() )
        {
           //
           // We don't have code to handle such failures, hence mark
           // catalog as corrupt; otherwise throw e_fail
           //
           Win4Assert( !"Corrupt catalog" );
           _storage.ReportCorruptComponent( L"PhysStorage3" );
           THROW( CException( CI_CORRUPT_DATABASE ));
        }
        else
           THROW( CException( E_FAIL ));
    }

    _cpageFileSize = ToPages(_stream->SizeLow(), _stream->SizeHigh());

    ciDebugOut(( DEB_ITRACE, "Physical index %08x opened.\n", _objectId ));
} //Reopen

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::LokBorrowNewBuffer, public
//
//  Arguments:  [hash]        -- hash value for doing the lookup
//              [commonPage]] -- the common page of nPage
//              [nPage]       -- page number
//
//  Returns:    A buffer for a new (unused) page.
//
//  History:    03-Mar-98 dlee    Created from existing BorrowNewBuffer
//
//  Notes:      On creation, the buffer is filled with zeros.
//
//--------------------------------------------------------------------------

ULONG * CPhysStorage::LokBorrowNewBuffer(
    ULONG hash,
    ULONG commonPage,
    ULONG nPage )
{
    CPhysBuffer* pBuf = _cache.Search( hash, commonPage );

    if (pBuf)
    {
        pBuf->Reference();
        Win4Assert( nPage < _cpageFileSize );

        // fIntentToWrite should be TRUE

        pBuf->SetIntentToWrite();
    }
    else
    {
        // If we've moved beyond the previous end of file, set the new
        // size of file.

        if ( nPage >= _cpageFileSize )
            _GrowFile( nPage + _cpageGrowth );

        // First try to release unreferenced buffers if the cache is full.

        _cache.TryToRemoveBuffers( _cMaxCachedBuffers );

        pBuf = new CPhysBuffer( _stream.GetReference(),
                                nPage,
                                TRUE,          // writable
                                TRUE,          // intent to write
                                ! ( _fAllowReadAhead &&
                                    _storage.FavorReadAhead() ) );
        _cache.Add( pBuf, hash );
    }

    Win4Assert( nPage + 1 > _cpageUsedFileSize );

    _cpageUsedFileSize = nPage + 1;
    Win4Assert( _cpageUsedFileSize <= _cpageFileSize );

    RtlZeroMemory( pBuf->GetPage( nPage ), CI_PAGE_SIZE );

    return pBuf->GetPage( nPage );
} //LokBorrowNewBuffer

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::BorrowNewBuffer, public
//
//  Arguments:  [nPage] -- page number
//
//  Returns:    A buffer for a new (unused) page.
//
//  Signals:    No more disk space.
//
//  History:    09-Mar-92 KyleP     Created
//
//  Notes:      On creation, the buffer is filled with zeros.
//
//--------------------------------------------------------------------------

ULONG * CPhysStorage::BorrowNewBuffer( ULONG nPage )
{
    Win4Assert( _fWritable );

    ULONG commonPage = PgCommonPgTrunc( nPage );
    ULONG hash = _cache.hash( commonPage );

    // Use appropriate locking based on whether any pages are in the cache.

    if ( 0 == _cMaxCachedBuffers )
    {
        CLock lock( _xMutex.GetReference() );

        return LokBorrowNewBuffer( hash, commonPage, nPage );
    }
    else
    {
        CWriteAccess writeLock( _xRWAccess.GetReference() );

        return LokBorrowNewBuffer( hash, commonPage, nPage );
    }
} //BorrowNewBuffer

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::LokBorrowOrAddBuffer, public
//
//  Arguments:  [hash]           -- hash value for doing the lookup
//              [commonPage]]    -- the common page of nPage
//              [nPage]          -- page number
//              [fAdd]           -- if TRUE, create the page if not found
//                                  if FALSE and not found, return 0
//              [fWritable]      -- if TRUE, the page is writable
//              [fIntentToWrite] -- TRUE if the caller intends to write
//
//  Returns:    A buffer loaded with page [nPage]
//
//  History:    09-Mar-92 KyleP     Created
//
//--------------------------------------------------------------------------

ULONG * CPhysStorage::LokBorrowOrAddBuffer(
    ULONG hash,
    ULONG commonPage,
    ULONG nPage,
    BOOL  fAdd,
    BOOL  fWritable,
    BOOL  fIntentToWrite )
{
    // First, look in the cache.  Either we haven't looked yet (if no
    // caching) or another thread may have added it between the time the
    // read lock was released and the write lock taken.

    Win4Assert( commonPage >= _iFirstNonShrunkPage );
    CPhysBuffer * pbuf = _cache.Search( hash, commonPage );

    if ( 0 != pbuf )
    {
        Win4Assert( !fWritable || pbuf->IsWritable() );

        pbuf->Reference();
        if ( fIntentToWrite )
            pbuf->SetIntentToWrite();

        return pbuf->GetPage( nPage );
    }

    ULONG * pulRet = 0;

    if ( fAdd )
    {
        pbuf = new CPhysBuffer( _stream.GetReference(),
                                nPage,
                                fWritable,
                                fIntentToWrite,
                                ! ( _fAllowReadAhead &&
                                    _storage.FavorReadAhead() ) );
    
        _cache.Add( pbuf, hash );
        pulRet = pbuf->GetPage( nPage );
    
        // Try to release unreferenced buffers if the cache is full.
    
        _cache.TryToRemoveBuffers( _cMaxCachedBuffers );
    }

    return pulRet;
} //LokBorrowOrAddBuffer

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::BorrowBuffer, public
//
//  Arguments:  [nPage] -- Page number of buffer to find.
//
//  Returns:    A buffer loaded with page [nPage]
//
//  Signals:    Out of memory?  Buffer not found?
//
//  History:    09-Mar-92 KyleP     Created
//
//--------------------------------------------------------------------------

ULONG * CPhysStorage::BorrowBuffer(
    ULONG nPage,
    BOOL  fWritable,
    BOOL  fIntentToWrite )
{
    ULONG commonPage = PgCommonPgTrunc( nPage );
    ULONG hash = _cache.hash( commonPage );

    Win4Assert( fWritable || !fIntentToWrite );

    // Make sure we didn't walk off the end.

    if ( nPage >= _cpageFileSize )
    {
        ciDebugOut(( DEB_WARN, "Asking for page %d, file size %d pages\n",
                     nPage, _cpageFileSize ));
        Win4Assert( !"BorrowBuffer walked off end of file" );

        _storage.ReportCorruptComponent( L"PhysStorage4" );

        THROW( CException( CI_CORRUPT_DATABASE ) );
    }

    // If caching, try finding it in the cache first under a read lock
    // This is the fast path for when the entire property cache is in memory.

    if ( 0 != _cMaxCachedBuffers )
    {
        CReadAccess readLock( _xRWAccess.GetReference() );

        ULONG * p = LokBorrowOrAddBuffer( hash, commonPage, nPage, FALSE,
                                          fWritable, fIntentToWrite );
        if ( 0 != p )
            return p;
    }

    // Ok, maybe we have to add it.

    if ( 0 == _cMaxCachedBuffers )
    {
        CLock lock( _xMutex.GetReference() );

        return LokBorrowOrAddBuffer( hash, commonPage, nPage, TRUE,
                                     fWritable, fIntentToWrite );
    }
    else
    {
        CWriteAccess writeLock( _xRWAccess.GetReference() );

        return LokBorrowOrAddBuffer( hash, commonPage, nPage, TRUE,
                                     fWritable, fIntentToWrite );
    }
} //BorrowBuffer

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::ReturnBuffer, public
//
//  Synopsis:   Dereference and return the buffer to the pool.
//
//  Arguments:  [nPage]  -- Page number of buffer being returned.
//              [fFlush] -- TRUE if the buffer should be flushed if this
//                          is the last reference to the buffer.
//              [fFailFlush] -- TRUE if an exception should be raised if
//                              the flush fails.  Note that even if fFlush
//                              is FALSE, the buffer may still be flushed
//                              because previously it was borrowed with
//                              intent to write.
//
//  Notes:      If flush throws, this call doesn't return the buffer.
//
//  History:    16-Mar-93       BartoszM     Created
//
//--------------------------------------------------------------------------

void CPhysStorage::ReturnBuffer(
    ULONG nPage,
    BOOL  fFlush,
    BOOL  fFailFlush )
{
    ULONG commonPage = PgCommonPgTrunc( nPage );
    ULONG hash = _cache.hash( commonPage );

    // if caching is off, grab the write lock, else the read lock

    if ( 0 == _cMaxCachedBuffers )
    {
        CLock lock( _xMutex.GetReference() );

        Win4Assert( commonPage >= _iFirstNonShrunkPage );
        CPhysBuffer *pbuf = _cache.Search( hash, commonPage );

        Win4Assert( 0 != pbuf );
        Win4Assert( pbuf->IsReferenced() );

        // If the refcount is 1, it's about to be destroyed.  Do the Flush
        // now, in case it fails, before mucking with any data structures.

        BOOL fDestroy = pbuf->IsRefCountOne();

        if ( fDestroy && fFlush )
        {
            Win4Assert( pbuf->IsWritable() );
            pbuf->Flush( fFailFlush );
        }

        pbuf->DeReference( _usnGen++ );

        if ( fDestroy )
        {
            Win4Assert( !pbuf->IsReferenced() );

            _cache.Destroy( nPage, fFailFlush );
            Win4Assert( !_cache.Search( hash, commonPage ) );
        }
    }
    else
    {
        CReadAccess readLock( _xRWAccess.GetReference() );

        Win4Assert( commonPage >= _iFirstNonShrunkPage );
        CPhysBuffer *pbuf = _cache.Search( hash, commonPage );

        Win4Assert( 0 != pbuf );
        Win4Assert( pbuf->IsReferenced() );

        if ( fFlush )
        {
            Win4Assert( pbuf->IsWritable() );

            if ( pbuf->IsRefCountOne() )
                pbuf->Flush( fFailFlush );
        }

        pbuf->DeReference( _usnGen++ );

        // leave it in the cache -- it'll be cleared out by BorrowBuffer
    }
} //ReturnBuffer

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::RequiresFlush, public
//
//  Synopsis:   Determines if the page is scheduled for flushing
//
//  Arguments:  [nPage]  -- Page number to check
//
//  Returns:    TRUE if the buffer will be flushed if Flush or Destroy is
//              called.
//
//  History:    3-Nov-98       dlee     Created
//
//--------------------------------------------------------------------------

BOOL CPhysStorage::RequiresFlush( ULONG nPage )
{
    ULONG commonPage = PgCommonPgTrunc( nPage );
    ULONG hash = _cache.hash( commonPage );

    // if caching is off, grab the write lock, else the read lock

    if ( 0 == _cMaxCachedBuffers )
    {
        CLock lock( _xMutex.GetReference() );

        Win4Assert( commonPage >= _iFirstNonShrunkPage );
        CPhysBuffer *pbuf = _cache.Search( hash, commonPage );

        Win4Assert( 0 != pbuf );
        Win4Assert( pbuf->IsReferenced() );

        return pbuf->RequiresFlush();
    }
    else
    {
        CReadAccess readLock( _xRWAccess.GetReference() );

        Win4Assert( commonPage >= _iFirstNonShrunkPage );
        CPhysBuffer *pbuf = _cache.Search( hash, commonPage );

        Win4Assert( 0 != pbuf );
        Win4Assert( pbuf->IsReferenced() );

        return pbuf->RequiresFlush();
    }
} //RequiresFlush

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::_GrowFile, private
//
//  Synopsis:   Increases the physical (disk) size of the file.
//
//  Arguments:  [cpageSize] -- New file size, in pages.
//
//  Signals:    Out of space.
//
//  History:    09-Mar-92 KyleP     Created
//
//--------------------------------------------------------------------------

void CPhysStorage::_GrowFile( ULONG cpageSize )
{
    Win4Assert( cpageSize > 0 );

    cpageSize = PgCommonPgRound(cpageSize);

    ciDebugOut(( DEB_ITRACE, "  Growing Index to %d pages\n", cpageSize ));

    _stream->SetSize( _storage,
                      PageToLow(cpageSize),
                      PageToHigh(cpageSize) );

    if (!_stream->Ok())
    {
        ciDebugOut(( DEB_ERROR, "GrowFile of index %08x failed: %d\n",
                     _objectId ));

        if ( _fThrowCorruptErrorOnFailures )
        {
           //
           // We don't have code to handle such failures, hence mark
           // catalog as corrupt; otherwise throw e_fail
           //
           Win4Assert( !"Corrupt catalog" );
           _storage.ReportCorruptComponent( L"PhysStorage5" );
           THROW( CException( CI_CORRUPT_DATABASE ) );
        }
        else
           THROW( CException( E_FAIL ) );
    }

    _cpageFileSize = cpageSize;
} //_GrowFile

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::ShrinkFromFront, public
//
//  Synopsis:   Makes the front part of a file sparse
//
//  Arguments:  [iFirstPage] -- first 4k page -- 64k granular
//              [cPages]     -- number of 4k pages
//
//  Returns:    The # of 4k pages actually shrunk, maybe 0
//
//  History:    09-Jan-97 dlee     Moved from .hxx
//
//--------------------------------------------------------------------------

ULONG CPhysStorage::ShrinkFromFront(
    ULONG iFirstPage,
    ULONG cPages )
{
    ULONG cShrunk = 0;

    if ( _storage.SupportsShrinkFromFront() )
    {
        //
        // Make sure the caller isn't leaving any gaps and was paying
        // attention to the return value from previous calls.
        //

        Win4Assert( iFirstPage == _iFirstNonShrunkPage );

        //
        // We must shrink on common page boundaries since we borrow on
        // common pages (even though the api is page granular)
        //

        ULONG cPagesToShrink = PgCommonPgTrunc( cPages );

        if ( 0 == cPagesToShrink )
            return 0;

        Win4Assert( _iFirstNonShrunkPage ==
                    PgCommonPgTrunc( _iFirstNonShrunkPage ) );
        Win4Assert( iFirstPage == PgCommonPgTrunc( iFirstPage ) );

        // Take a lock so no one else tries to borrow or free any pages

        Win4Assert ( 0 == _cMaxCachedBuffers );

        CLock lock( _xMutex.GetReference() );

        cShrunk = _stream->ShrinkFromFront( iFirstPage, cPagesToShrink );
        Win4Assert( cShrunk == PgCommonPgTrunc( cShrunk ) );

        _iFirstNonShrunkPage += cShrunk;
    }

    return cShrunk;
} //ShrinkFromFront

//+-------------------------------------------------------------------------
//
//  Member:     CPhysStorage::MinPageInUse, public
//
//  Synopsis:   Finds the smallest page in use within the cache
//
//  Arguments:  [minPage] -- returns the result
//
//  Returns :   TRUE if any page is in the cache; FALSE o/w
//              If TRUE is returned, then minPage will contain the
//              minimum page that is present in the cache.
//
//  History:    26-Mar-98 dlee     Moved from .hxx
//
//--------------------------------------------------------------------------

BOOL CPhysStorage::MinPageInUse( ULONG &minPage )
{
    if ( 0 == _cMaxCachedBuffers )
    {
        CLock lock( _xMutex.GetReference() );

        return _cache.MinPageInUse(minPage);
    }
    else
    {
        CReadAccess readLock( _xRWAccess.GetReference() );

        return _cache.MinPageInUse(minPage);
    }
} //MinPageInUse