//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1992.
//
//  File:	page.cxx
//
//  Contents:	Paging code for MSF
//
//  Classes:	Defined in page.hxx
//
//  Functions:	
//
//  History:	20-Oct-92	PhilipLa	Created
//
//----------------------------------------------------------------------------

#include "msfhead.cxx"

#pragma hdrstop


#include <mread.hxx>
#include <filest.hxx>


#define FLUSH_MULTIPLE

//+---------------------------------------------------------------------------
//
//  Member:     CMSFPage::SetSect, public
//
//  Synopsis:   Sets the SECT for this page
//
//  History:    20-Oct-92       PhilipLa        Created
//
//----------------------------------------------------------------------------
#ifdef SORTPAGETABLE    
inline void CMSFPage::SetSect(const SECT sect)
{
    msfAssert(_pmpNext != NULL && _pmpPrev != NULL);
    
    msfAssert((_pmpPrev->_sect >= _pmpNext->_sect) || //Edge
              ((_sect >= _pmpPrev->_sect) && (_sect <= _pmpNext->_sect)));
    _sect = sect;
}
#endif    


//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::IsSorted, public
//
//  Synopsis:	Return TRUE if the specified page is in the right place
//                in the list.
//
//  Arguments:	[pmp] -- Page to check
//
//  History:	13-Dec-95	PhilipLa	Created
//
//----------------------------------------------------------------------------

inline BOOL CMSFPageTable::IsSorted(CMSFPage *pmp)
{
    //There are three cases:
    //1)  Page is first in the list.
    //2)  Page is last in the list.
    //3)  Page is in the middle of the list.

    SECT sect = pmp->GetSect();
    CMSFPage *pmpStart = BP_TO_P(CMSFPage *, _pmpStart);
    CMSFPage *pmpNext = pmp->GetNext();

    if (pmp == pmpStart)
    {
        return (sect <= pmpNext->GetSect());
    }
    if (pmpNext == pmpStart)
    {
        return (sect >= pmp->GetPrev()->GetSect());
    }
    return ((sect <= pmpNext->GetSect()) &&
            (sect >= pmp->GetPrev()->GetSect()));
}


//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::SetSect, public
//
//  Synopsis:	Set the sector stamp on a page, and sort the list if
//              necessary.
//
//  Arguments:	[pmp] -- Pointer to page to stamp
//              [sect] -- SECT to stamp it with
//
//  Returns:	void
//
//  History:	12-Dec-95	PhilipLa	Created
//
//----------------------------------------------------------------------------

void CMSFPageTable::SetSect(CMSFPage *pmp, SECT sect)
{
    msfDebugOut((DEB_ITRACE, "In  CMSFPageTable::SetSect:%p(%p, %lX)\n",
                 this,
                pmp,
                sect));
    pmp->SetSect(sect);

    //Resort list if necessary.
    if (!IsSorted(pmp))
    {
        CMSFPage *pmpTemp, *pmpStart;
        pmpStart = BP_TO_P(CMSFPage *, _pmpStart);

        if (pmpStart == pmp)
        {
            pmpStart = pmp->GetNext();
            _pmpStart = P_TO_BP(CBasedMSFPagePtr , pmpStart);
        }
        pmp->Remove();
    
        pmpTemp = pmpStart;
        while (sect > pmpTemp->GetSect())
        {
            pmpTemp = pmpTemp->GetNext();
            if (pmpTemp == pmpStart)
            {
                break;
            }
        }
        //Insert node before pmpTemp.
        pmpTemp->GetPrev()->SetNext(pmp);
        pmp->SetChain(pmpTemp->GetPrev(), pmpTemp);
        pmpTemp->SetPrev(pmp);

        if (sect <= pmpStart->GetSect())
        {
            _pmpStart = P_TO_BP(CBasedMSFPagePtr, pmp);
        }
    }
    msfAssert(IsSorted(pmp));
    
    msfDebugOut((DEB_ITRACE, "Out CMSFPageTable::SetSect\n"));
}


//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::CMSFPageTable, public
//
//  Synopsis:	CMSFPageTable constructor.
//
//  Arguments:	[pmsParent] -- Pointer to multistream for this page table.
//
//  History:	22-Oct-92	PhilipLa	Created
//
//  Notes:	
//
//----------------------------------------------------------------------------

CMSFPageTable::CMSFPageTable(
        CMStream *const pmsParent,
        const ULONG cMinPages,
        const ULONG cMaxPages)
        : _cbSector(pmsParent->GetSectorSize()),
          _cMinPages(cMinPages), _cMaxPages(cMaxPages)
{
    _pmsParent = P_TO_BP(CBasedMStreamPtr, pmsParent);
    _cActivePages = 0;
    _cPages = 0;
    _pmpCurrent = NULL;
#ifdef SORTPAGETABLE
    _pmpStart = NULL;
#endif    
    _cReferences = 1;
#if DBG == 1
    _cCurrentPageRef = 0;
    _cMaxPageRef = 0;
#endif
}

//+---------------------------------------------------------------------------
//
//  Member:	CMSFPage::CMSFPage, public
//
//  Synopsis:	CMSFPage default constructor
//
//  History:	20-Oct-92	PhilipLa	Created
//
//----------------------------------------------------------------------------

#if DBG == 1
CMSFPage::CMSFPage(CMSFPage *pmp, CMSFPageTable *pmpt)
#else
CMSFPage::CMSFPage(CMSFPage *pmp)
#endif
{
    if (pmp == NULL)
    {
        SetChain(this, this);
    }
    else
    {
        SetChain(pmp->GetPrev(), pmp);
        GetPrev()->SetNext(this);
        GetNext()->SetPrev(this);
    }

#if DBG == 1
    _pmpt = P_TO_BP(CBasedMSFPageTablePtr, pmpt);
#endif

    SetSid(NOSTREAM);
    SetOffset(0);
//    SetSect(ENDOFCHAIN);
    //SetSect() contains assertions to verify sortedness of the list,
    //which we don't want here.
    _sect = ENDOFCHAIN;
    SetFlags(0);
    SetVector(NULL);
    _cReferences = 0;
}

//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::GetNewPage, private
//
//  Synopsis:	Insert a new page into the list and return a pointer to it.
//
//  Arguments:	None.
//
//  Returns:	Pointer to new page.  Null if there was an allocation error.
//
//  History:	22-Oct-92	PhilipLa	Created
//
//  Notes:	
//
//----------------------------------------------------------------------------

inline CMSFPage * CMSFPageTable::GetNewPage(void)
{
#ifndef SORTPAGETABLE    
#if DBG == 1
    return new (_pmsParent->GetMalloc(), (size_t)_cbSector)
               CMSFPage(BP_TO_P(CMSFPage *, _pmpCurrent), this);
#else
    return new (_pmsParent->GetMalloc(), (size_t)_cbSector)
               CMSFPage(BP_TO_P(CMSFPage *, _pmpCurrent));
#endif
#else
#if DBG == 1
    return new (_pmsParent->GetMalloc(), (size_t)_cbSector)
               CMSFPage(BP_TO_P(CMSFPage *, _pmpStart), this);
#else
    return new (_pmsParent->GetMalloc(), (size_t)_cbSector)
               CMSFPage(BP_TO_P(CMSFPage *, _pmpStart));
#endif
#endif //SORTPAGETABLE    
}

//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::~CMSFPageTable, public
//
//  Synopsis:	CMSFPageTable destructor
//
//  History:	26-Oct-92	PhilipLa	Created
//		21-Jul-95	SusiA		Modified to delete the object without
//						obtaining the mutex.  Calling functions
//						should have locked the mutex first.
//
//----------------------------------------------------------------------------

CMSFPageTable::~CMSFPageTable()
{
    if (_pmpCurrent != NULL)
    {
        CMSFPage *pmp = BP_TO_P(CMSFPage *, _pmpCurrent);
        CMSFPage *pmpNext;

        while (pmp != pmp->GetNext())
        {
            pmpNext = pmp->GetNext();
            msfAssert(pmpNext != NULL &&
                      aMsg("NULL found in page table circular list."));
#if DBG == 1
            msfAssert(!pmp->IsInUse() &&
                    aMsg("Active page left at page table destruct time."));

            if (!_pmsParent->IsScratch())
            {
                //Dirty paged can be thrown away if we are unconverted or
                //   in a commit.
                if ((!_pmsParent->IsUnconverted()) &&
                    (_pmsParent->GetParentSize() == 0))
                {
                    msfAssert(!pmp->IsDirty() &&
                        aMsg("Dirty page left at page table destruct time."));
                }
            }
#endif
            pmp->~CMSFPage();
	    pmp->deleteNoMutex(pmp);
            	    
	    pmp = pmpNext;
        }
        pmp->~CMSFPage();
        pmp->deleteNoMutex(pmp);
	
	
    }
#if DBG == 1
    msfDebugOut((DEB_ITRACE,
            "Page Table Max Page Count for %s: %lu\n",
            (_pmsParent->IsScratch()) ? "Scratch" : "Base",
            _cMaxPageRef));
#endif

}


//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::Init, public
//
//  Synopsis:	Initialize a CMSFPageTable
//
//  Arguments:	[cPages] -- Number of pages to preallocate.
//
//  Returns:	Appropriate status code
//
//  History:	22-Oct-92	PhilipLa	Created
//
//  Notes:	
//
//----------------------------------------------------------------------------

SCODE CMSFPageTable::Init(void)
{
    SCODE sc = S_OK;

    msfDebugOut((DEB_ITRACE, "In  CMSFPageTable::Init:%p()\n", this));

    for (ULONG i = 0; i < _cMinPages; i++)
    {
        CMSFPage *pmp;

        msfMem(pmp = GetNewPage());
#ifndef SORTPAGETABLE        
        _pmpCurrent = P_TO_BP(CBasedMSFPagePtr, pmp);
#else
        _pmpStart = P_TO_BP(CBasedMSFPagePtr, pmp);
#endif        
    }
    _cPages = _cMinPages;
    _cActivePages = 0;
#ifdef SORTPAGETABLE
    _pmpCurrent = _pmpStart;
#endif

    msfDebugOut((DEB_ITRACE, "Out CMSFPageTable::Init\n"));

 Err:

    return sc;
}



//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::FlushPage, public
//
//  Synopsis:	Flush a page
//
//  Arguments:	[pmp] -- Pointer to page to flush
//
//  Returns:	Appropriate status code
//
//  History:	09-Nov-92	PhilipLa	Created
//
//----------------------------------------------------------------------------

SCODE CMSFPageTable::FlushPage(CMSFPage *pmp)
{
    SCODE sc = S_OK;

    pmp->AddRef();

    CMStream *pms;
    pms = pmp->GetVector()->GetParent();

    //Flush the page, reset the dirty bit.

    msfAssert((pmp->GetSect() != ENDOFCHAIN) &&
            aMsg("Page location not set - don't know where to flush to."));
    msfAssert (pms != NULL);

    ULONG ulRet;

    ILockBytes *pilb;
#if DBG == 1
    if ((pmp->GetSid() == SIDFAT) && (pms->IsInCOW()))
    {
        msfDebugOut((DEB_ITRACE, "** Fat sect %lu written to %lX\n",
                pmp->GetOffset(), pmp->GetSect()));
    }
    if ((pmp->GetSid() == SIDDIF) && (pms->IsInCOW()))
    {
        msfDebugOut((DEB_ITRACE, "** DIF sect %lu written to %lX\n",
                pmp->GetOffset(), pmp->GetSect()));
    }

#endif
    ULARGE_INTEGER ul;
#ifdef LARGE_DOCFILE
    ul.QuadPart = ConvertSectOffset(
            pmp->GetSect(),
            0,
            pms->GetSectorShift());
#else
    ULISet32(ul, ConvertSectOffset(
            pmp->GetSect(),
            0,
            pms->GetSectorShift()));
#endif

    pilb = pms->GetILB();

    msfAssert(!pms->IsUnconverted() &&
            aMsg("Tried to flush page to unconverted base."));

    sc = GetScode(pilb->WriteAt(ul,
                                (BYTE *)(pmp->GetData()),
                                _cbSector,
                                &ulRet));
    if (sc == E_PENDING)
    {
        sc = STG_E_PENDINGCONTROL;
    }
    msfChk(sc);

    pmp->ResetDirty();

 Err:
    pmp->Release();
    return sc;
}


//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::GetFreePage, public
//
//  Synopsis:	Return a pointer to a free page.
//
//  Arguments:	[ppmp] -- Pointer to storage for return pointer
//
//  Returns:	Appropriate status code
//
//  History:	22-Oct-92	PhilipLa	Created
//
//  Notes:	
//
//----------------------------------------------------------------------------

SCODE CMSFPageTable::GetFreePage(CMSFPage **ppmp)
{
    SCODE sc = S_OK;
    CMSFPage *pmp;
    if (_cPages > _cActivePages)
    {
        //We have some unused page already allocated.  Find and return it.
        pmp = BP_TO_P(CMSFPage *, _pmpCurrent);

        do
        {
            pmp = pmp->GetNext();
        }
        while ((pmp != _pmpCurrent) && (pmp->GetSid() != NOSTREAM));

        msfAssert((pmp->GetSid() == NOSTREAM) &&
                aMsg("Expected empty page, none found."));

        *ppmp = pmp;
        _cActivePages++;
    }
    else if (_cPages == _cMaxPages)
    {
        msfMem(pmp = FindSwapPage());
        msfDebugOut((DEB_ITRACE, "Got swap page %p\n",pmp));

        msfAssert((pmp->GetVector() != NULL) &&
                aMsg("FindSwapPage returned unowned page."));

        msfDebugOut((DEB_ITRACE, "Freeing page %lu from vector %p\n",
                pmp->GetOffset(), pmp->GetVector()));


        if (pmp->IsDirty())
        {
            msfChk(FlushPage(pmp));
            msfAssert(!pmp->IsDirty() &&
                    aMsg("Page remained dirty after flush call"));
        }

        pmp->GetVector()->FreeTable(pmp->GetOffset());
#if DBG == 1
        pmp->SetVector(NULL);
#endif
        *ppmp = pmp;
    }
    else
    {
        //Create a new page and return it.
        pmp = GetNewPage();
        if (pmp != NULL)
        {
            *ppmp = pmp;
            _cActivePages++;
            _cPages++;
        }
        else
        {
            msfMem(pmp = FindSwapPage());
            if (pmp->IsDirty())
            {
                msfChk(FlushPage(pmp));
                msfAssert(!pmp->IsDirty() &&
                        aMsg("Page remained dirty after flush call"));
            }
            if (pmp->GetVector() != NULL)
                pmp->GetVector()->FreeTable(pmp->GetOffset());
#if DBG == 1
            pmp->SetVector(NULL);
#endif
            *ppmp = pmp;
        }
    }

 Err:
    return sc;
}


//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::FindPage, public
//
//  Synopsis:	Find and return a given page
//
//  Arguments:  [ppv] -- Pointer to vector of page to return
//              [sid] -- SID of page to return
//              [ulOffset] -- Offset of page to return
//              [ppmp] -- Location to return pointer
//
//  Returns:	Appropriate status code
//
//  History:	22-Oct-92	PhilipLa	Created
//
//  Notes:	
//
//----------------------------------------------------------------------------

SCODE CMSFPageTable::FindPage(
        CPagedVector *ppv,
        SID sid,
        ULONG ulOffset,
        CMSFPage **ppmp)
{
    SCODE sc;
    CMSFPage *pmp = BP_TO_P(CMSFPage *, _pmpCurrent);

    do
    {
        if ((pmp->GetVector() == ppv) && (pmp->GetOffset() == ulOffset))
        {
            //Bingo!

            *ppmp = pmp;
            return STG_S_FOUND;
        }

        pmp = pmp->GetNext();
    }
    while (pmp != _pmpCurrent);

    //The page isn't currently in memory.  Get a free page and
    //bring it into memory.

    msfChk(GetFreePage(&pmp));

    msfAssert((pmp->GetVector() == NULL) &&
            aMsg("Attempting to reassign owned page."));
    pmp->SetVector(ppv);
    pmp->SetSid(sid);
    pmp->SetOffset(ulOffset);
#ifdef SORTPAGETABLE
    SetSect(pmp, ENDOFCHAIN);
#else    
    pmp->SetSect(ENDOFCHAIN);
#endif
    
    *ppmp = pmp;

 Err:
    return sc;
}


//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::GetPage, public
//
//  Synopsis:	Find and return a given page
//
//  Arguments:	[sid] -- SID of page to return
//              [ulOffset] -- Offset of page to return
//              [ppmp] -- Location to return pointer
//
//  Returns:	Appropriate status code
//
//  History:	22-Oct-92	PhilipLa	Created
//
//  Notes:	
//
//----------------------------------------------------------------------------

SCODE CMSFPageTable::GetPage(
        CPagedVector *ppv,
        SID sid,
        ULONG ulOffset,
        SECT sectKnown,
        CMSFPage **ppmp)
{
    SCODE sc;

    *ppmp = NULL;
    msfChk(FindPage(ppv, sid, ulOffset, ppmp));

    (*ppmp)->AddRef();

    if (sc != STG_S_FOUND)
    {
        ULONG ulRet;
        SECT sect;

        if (sectKnown != ENDOFCHAIN)
        {
            sect = sectKnown;
        }
        else
        {
            msfChk(ppv->GetParent()->GetSect(sid, ulOffset, &sect));
        }
#ifdef SORTPAGETABLE
        SetSect(*ppmp, sect);
#else        
        (*ppmp)->SetSect(sect);
#endif        

        CMStream *pms = (*ppmp)->GetVector()->GetParent();
#if DBG == 1
        if ((sid == SIDFAT) && (pms->IsInCOW()))
        {
            msfDebugOut((DEB_ITRACE, "Fat sect %lu read from %lX\n",
                    ulOffset, sect));
        }
        if ((sid == SIDDIF) && (pms->IsInCOW()))
        {
            msfDebugOut((DEB_ITRACE, "DIF sect %lu read from %lX\n",
                    ulOffset, sect));
        }

#endif

        ULARGE_INTEGER ul;
#ifdef LARGE_DOCFILE
        ul.QuadPart = ConvertSectOffset(
                (*ppmp)->GetSect(),
                0,
                pms->GetSectorShift());
#else
        ULISet32(ul, ConvertSectOffset(
                (*ppmp)->GetSect(),
                0,
                pms->GetSectorShift()));
#endif

        msfAssert(pms->GetILB() != NULL &&
                  aMsg("NULL ILockBytes - missing SetAccess?"));

        sc = GetScode(pms->GetILB()->ReadAt(ul,
                                            (BYTE *)((*ppmp)->GetData()),
                                            _cbSector,
                                            &ulRet));
        if (sc == E_PENDING)
        {
            sc = STG_E_PENDINGCONTROL;
        }
        msfChk(sc);
        
        if (ulRet != _cbSector)
        {
                //  09/23/93 - No error, but insufficient bytes read
                sc = STG_E_READFAULT;
        }
    }

Err:
    if (*ppmp != NULL)
    {
        if (FAILED(sc))
        {
            //  09/19/93 - Reset page so that we don't accidentally use it

            (*ppmp)->SetSid(NOSTREAM);
            (*ppmp)->SetOffset(0);
#ifdef SORTPAGETABLE
            SetSect(*ppmp, ENDOFCHAIN);
#else
            (*ppmp)->SetSect(ENDOFCHAIN);
#endif            
            (*ppmp)->SetFlags(0);
            (*ppmp)->SetVector(NULL);
            _cActivePages--;
        }
        (*ppmp)->Release();
    }

    return sc;
}



//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::ReleasePage, public
//
//  Synopsis:	Release a given page
//
//  Arguments:	[sid] -- SID of page to release
//              [ulOffset] -- Offset of page to release
//
//  History:	28-Oct-92	PhilipLa	Created
//
//----------------------------------------------------------------------------

void CMSFPageTable::ReleasePage(CPagedVector *ppv,
                                SID sid, ULONG ulOffset)
{
    SCODE sc;
    CMSFPage *pmp;

    sc = FindPage(ppv, sid, ulOffset, &pmp);

    if (SUCCEEDED(sc))
    {
        pmp->Release();
    }
}


//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::Flush, public
//
//  Synopsis:	Flush dirty pages to disk
//
//  Returns:	Appropriate status code
//
//  History:	02-Nov-92	PhilipLa	Created
//
//----------------------------------------------------------------------------

SCODE CMSFPageTable::Flush(void)
{
#ifndef SORTPAGETABLE
    SCODE sc = S_OK;

    CMSFPage *pmp = BP_TO_P(CMSFPage *, _pmpCurrent);

    //We use pmpLast in case FlushPage changes _pmpCurrent.
    CMSFPage *pmpLast = pmp;

    do
    {
        if ((pmp->IsDirty()) && !(pmp->IsInUse()) &&
            !(pmp->GetVector()->GetParent()->IsScratch()))
        {
            msfChk(FlushPage(pmp));
        }

        pmp = pmp->GetNext();

    }
    while (pmp != pmpLast);

 Err:
    return sc;
#else
    SCODE sc = S_OK;
    msfDebugOut((DEB_ITRACE, "In CMSFPageTable::Flush()\n"));

    CMSFPage *pmp;
    CMSFPage *pmpStart;
    BYTE *pb = NULL;
    ULONG ulBufferSize = 0;

    pmpStart = BP_TO_P(CMSFPage *, _pmpStart);
    pmp = pmpStart;
    do
    {
        CMSFPage *pmpFirst = NULL;
        CMSFPage *pmpLast = NULL;

        //Find first page that needs to be flushed.
        while (!pmp->IsFlushable())
        {
            pmp = pmp->GetNext();
            if (pmp == pmpStart)
                break;
        }

        //If we haven't hit the end of the list, then find a contiguous
        //   range of pages to flush.
        if (pmp->IsFlushable())
        {
            pmpFirst = pmp;
            //Store pointer to last page in range in pmpLast.
            while (pmp->IsFlushable())
            {
                pmpLast = pmp;
                pmp = pmp->GetNext();
                if (pmp->GetSect() != pmpLast->GetSect() + 1)
                {
                    break;
                }
            }
            //At this point, we can flush everything from pmpFirst to
            //  pmpLast, and they are all contiguous.  pmp points to the
            //  next sector after the current range.

            if (pmpFirst == pmpLast)
            {
                msfDebugOut((DEB_ITRACE,
                             "Flushing page to %lx\n",
                             pmpFirst->GetSect()));
                
                //Only one page:  Call FlushPage.
                msfChk(FlushPage(pmpFirst));
            }
            else
            {
                ULONG ulWriteSize;
                ULONG cSect;
                CMSFPage *pmpTemp;
                ULONG i;

                msfDebugOut((DEB_ITRACE,
                             "Flushing pages from %lx to %lx\n",
                             pmpFirst->GetSect(),
                             pmpLast->GetSect()));
                
                cSect = pmpLast->GetSect() - pmpFirst->GetSect() + 1;
                ulWriteSize = cSect * _cbSector;
                
                if (ulWriteSize > ulBufferSize)
                {
                    delete [] pb;
                    pb = new BYTE[ulWriteSize];
                    ulBufferSize = ulWriteSize;
                }

                pmpTemp = pmpFirst;
                if (pb == NULL)
                {
                    ulBufferSize = 0;
                    
                    //Low memory case - write out pages one at a time
                    for (i = 0; i < cSect; i++)
                    {
                        msfChk(FlushPage(pmpTemp));
                        pmpTemp = pmpTemp->GetNext();
                    }
                }
                else
                {
                    for (i = 0; i < cSect; i++)
                    {
                        memcpy(pb + (i * _cbSector),
                               pmpTemp->GetData(),
                               _cbSector);
                        pmpTemp = pmpTemp->GetNext();
                    }
                    //The buffer is loaded up - now write it out.
                    ULARGE_INTEGER ul;
                    ULONG cbWritten;
                    ULONG cbTotal = 0;
                    BYTE *pbCurrent = pb;
#ifdef LARGE_DOCFILE
                    ul.QuadPart = ConvertSectOffset(pmpFirst->GetSect(),
                                                  0,
                                                 _pmsParent->GetSectorShift());
#else
                    ULISet32(ul, ConvertSectOffset(pmpFirst->GetSect(),
                                                  0,
                                                 _pmsParent->GetSectorShift()));
#endif
                    while (cbTotal < ulWriteSize)
                    {
                        sc = _pmsParent->GetILB()->WriteAt(ul,
                                                       pbCurrent,
                                                       ulWriteSize - cbTotal,
                                                       &cbWritten);
                        if (sc == E_PENDING)
                        {
                            sc = STG_E_PENDINGCONTROL;
                        }
                        msfChk(sc);
                        if (cbWritten == 0)
                        {
                            msfErr(Err, STG_E_WRITEFAULT);
                        }
                        cbTotal += cbWritten;
                        pbCurrent += cbWritten;
                        ul.QuadPart += cbWritten;
                    }
                
                    //Mark all the pages as clean.
                    pmpTemp = pmpFirst;
                    for (i = 0; i < cSect; i++)
                    {
                        pmpTemp->ResetDirty();
                        pmpTemp = pmpTemp->GetNext();
                    }
                }
            }            
        }
        else
        {
            //We've hit the end of the list, do nothing.
        }
    }
    while (pmp != pmpStart);
    msfDebugOut((DEB_ITRACE, "Out CMSFPageTable::Flush() => %lX\n", sc));
Err:
    if (pb != NULL)
    {
        delete [] pb;
    }
    return sc;
#endif //SORTPAGETABLE    
}



//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::FreePages, public
//
//  Synopsis:	Free all the pages associated with a vector.
//
//  Arguments:	[ppv] -- Pointer to vector to free pages for.
//
//  History:	09-Nov-92	PhilipLa	Created
//
//----------------------------------------------------------------------------

void CMSFPageTable::FreePages(CPagedVector *ppv)
{
    CMSFPage *pmp = BP_TO_P(CMSFPage *, _pmpCurrent);

    do
    {
        if (pmp->GetVector() == ppv)
        {
            pmp->SetSid(NOSTREAM);
            pmp->SetVector(NULL);
            pmp->ResetDirty();
            _cActivePages--;
        }
        pmp = pmp->GetNext();
    }
    while (pmp != _pmpCurrent);

}


//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::FindSwapPage, private
//
//  Synopsis:	Find a page to swap out.
//
//  Arguments:	None.
//
//  Returns:	Pointer to page to swap out.
//
//  History:	22-Oct-92	PhilipLa	Created
//
//----------------------------------------------------------------------------

CMSFPage * CMSFPageTable::FindSwapPage(void)
{
#if DBG == 1
    ULONG cpInUse = 0;
#endif

    while (TRUE)
    {
        if (!_pmpCurrent->IsInUse())
        {
            DWORD dwFlags;

            dwFlags = _pmpCurrent->GetFlags();
            _pmpCurrent->SetFlags(dwFlags & ~FB_TOUCHED);
            
            CMSFPage *pmpTemp = _pmpCurrent->GetNext();
            _pmpCurrent = P_TO_BP(CBasedMSFPagePtr, pmpTemp);

            if (!(dwFlags & FB_TOUCHED))
            {
                return _pmpCurrent->GetPrev();
            }
        }
        else
        {
            CMSFPage *pmpTemp = _pmpCurrent->GetNext();
            _pmpCurrent = P_TO_BP(CBasedMSFPagePtr, pmpTemp);
        }
#if DBG == 1
        cpInUse++;
        msfAssert((cpInUse < 3 * _cPages) &&
                aMsg("No swappable pages."));
#endif

    }
}


//+---------------------------------------------------------------------------
//
//  Member:	CMSFPageTable::CopyPage, public
//
//  Synopsis:	Copy a page in memory, returning NULL if there is
//              insufficient space for a new page without swapping.
//
//  Arguments:	[ppv] -- Pointer to vector that will own the copy.
//              [pmpOld] -- Pointer to page to copy.
//              [ppmp] -- Pointer to return value
//
//  Returns:	Appropriate status code
//
//  Modifies:	
//
//  History:	04-Dec-92	PhilipLa	Created
//
//  Notes:	
//
//----------------------------------------------------------------------------

SCODE CMSFPageTable::CopyPage(
        CPagedVector *ppv,
        CMSFPage *pmpOld,
        CBasedMSFPagePtr *ppmp)
{
    CMSFPage *pmp;

    pmp = NULL;

    if (pmpOld != NULL)
    {
        msfAssert(!pmpOld->IsDirty() &&
                aMsg("Copying dirty page."));

        if (_cPages > _cActivePages)
        {

            //We have some unused page already allocated.  Find and return it.
            pmp = BP_TO_P(CMSFPage *, _pmpCurrent);

            do
            {
                pmp = pmp->GetNext();
            }
            while ((pmp != _pmpCurrent) && (pmp->GetSid() != NOSTREAM));


            msfAssert((pmp->GetSid() == NOSTREAM) &&
                    aMsg("Expected empty page, none found."));
            _cActivePages++;

        }
        else if (_cPages < _cMaxPages)
        {
            //Create a new page and return it.
            pmp = GetNewPage();
            if (pmp != NULL)
            {
                _cActivePages++;
                _cPages++;
            }
        }

        if (pmp != NULL)
        {
            msfAssert((pmp->GetVector() == NULL) &&
                    aMsg("Attempting to reassign owned page."));
            pmp->SetVector(ppv);
            pmp->SetSid(pmpOld->GetSid());
            pmp->SetOffset(pmpOld->GetOffset());
#ifdef SORTPAGETABLE
            SetSect(pmp, pmpOld->GetSect());
#else            
            pmp->SetSect(pmpOld->GetSect());
#endif            

            memcpy(pmp->GetData(), pmpOld->GetData(), (USHORT)_cbSector);
        }
    }

    *ppmp = P_TO_BP(CBasedMSFPagePtr, pmp);

    return S_OK;
}


#if DBG == 1

void CMSFPageTable::AddPageRef(void)
{
    msfAssert((LONG) _cCurrentPageRef >= 0);
    _cCurrentPageRef++;
    if (_cCurrentPageRef > _cMaxPageRef)
    {
        _cMaxPageRef = _cCurrentPageRef;
    }
}

void CMSFPageTable::ReleasePageRef(void)
{
    _cCurrentPageRef--;
    msfAssert((LONG) _cCurrentPageRef >= 0);
}
#endif