// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// f32\sfat\sl_dir_cache.cpp

//

//

#include "sl_std.h"

#include "sl_dir_cache.h"

//======================================================================

TDynamicDirCachePage::~TDynamicDirCachePage()

	{

	}

/**

The static cache page creation function.

Cache page objects are not supposed to be created on the stack, so this factory function is required.

*/

	{

	}

/**

Cache page constructor.

@param	aOwnerCache	pointer of the cache that owns this page

@param	aStartMedPos	the start address on the media that this page caches

@param	aStartRamAddr	the start address in the ram that this page content lives

*/

TDynamicDirCachePage::TDynamicDirCachePage(CDynamicDirCache* aOwnerCache, TInt64 aStartMedPos, TUint8* aStartRamAddr)

                     :iStartMedPos(aStartMedPos),

                      iStartRamAddr(aStartRamAddr),

                      iOwnerCache(aOwnerCache),

                      iValid(EFalse),

                      iLocked(EFalse)

	{

	//__PRINT3(_L("TDynamicDirCachePage::TDynamicDirCachePage(aStartMedPos=%lx, aStartRamAddr=0x%X, aPageSize=%u)"), aStartMedPos, aStartRamAddr, PageSizeInBytes());

	iType = EUnknown;

	}

/////////////////////////////// class CDynamicDirCache::TLookupEntry ///////////////////////////

/**

Required by RHashSet<TLookupEntry> to identify individual hash set entries.

@see	RHashSet

*/

TBool IdentityFunction(const TLookupEntry& aEntry1, const TLookupEntry& aEntry2)

	{

	// only check starting med pos for hash searching

	return aEntry1.iPos == aEntry2.iPos;

	}

/**

Required by RHashSet<TLookupEntry> to generate hash value.

@see	RHashSet

*/

TUint32 HashFunction(const TLookupEntry& aEntry)

	{

	return (DefaultHash::Integer(I64HIGH(aEntry.iPos)) + DefaultHash::Integer(I64LOW(aEntry.iPos)));

	}

/////////////////////////////// class CDynamicDirCache ///////////////////////////

CDynamicDirCache::~CDynamicDirCache()

	{

	__PRINT(_L("CDynamicDirCache::~CDynamicDirCache()"));

	// we should never decommit locked pages

    while (!iLockedQ.IsEmpty())

		{

		TDynamicDirCachePage* page = iLockedQ.Last();

		DeQueue(page);		// remove from queue

		LookupTblRemove(page->StartPos());	// remove from lookuptable

		delete page;

		}

	ASSERT(iLockedQCount == 0);

	while (!iUnlockedQ.IsEmpty())

		{

		TDynamicDirCachePage* page = iUnlockedQ.Last();

		DeQueue(page);		// remove from queue

		LookupTblRemove(page->StartPos());	// remove from lookuptable

		DecommitPage(page);	// inform cache client to decommit page memory

		delete page;

		}

	ASSERT(iUnlockedQCount == 0);

	ASSERT(iLookupTable.Count() == 0);

	iLookupTable.Close();

    if (iCacheMemoryClient)

    	iCacheMemoryClient->Reset();

	}

/**

Constructor of CDynamicDirCache.

@param	aDrive	local drive interface to read/write media

@param	aMinPageNum	the minimum page number for the cache, includes iActive page and locked pages.

@param	aMaxPageNum	the maximum page number for the cache, includes iActive page, locked pages and unlocked pages.

    @param	aPageSizeInBytesLog2	Log2 of the page size in bytes, this is the cache read granularity

    @param  aWrGranularityLog2      Log2(cache write granularity)

*/

CDynamicDirCache::CDynamicDirCache(TDriveInterface& aDrive, TUint32 aMinPageNum, TUint32 aMaxPageNum, TUint32 aPageSizeInBytesLog2, TUint32 aWrGranularityLog2)

                 :iPageSizeLog2(aPageSizeInBytesLog2),

                  iWrGranularityLog2(aWrGranularityLog2),

                  iMinSizeInPages(aMinPageNum),

                  iMaxSizeInPages(aMaxPageNum),

                  iDrive(aDrive),

                  iLockedQ(_FOFF(TDynamicDirCachePage, iLink)),

                  iUnlockedQ(_FOFF(TDynamicDirCachePage, iLink)),

                  iLockedQCount(0),

                  iUnlockedQCount(0),

                  iHashFunction(HashFunction),

                  iIdentityFunction(IdentityFunction),

                  iLookupTable(iHashFunction, iIdentityFunction)

	{

	iPageSizeInBytes = 1 << aPageSizeInBytesLog2;

	iCacheDisabled = EFalse;

    iMinCacheSizeInBytes = aMinPageNum << aPageSizeInBytesLog2;

    iMaxCacheSizeInBytes = aMaxPageNum << aPageSizeInBytesLog2;

    ASSERT(iPageSizeInBytes && iPageSizeInBytes <= iMinCacheSizeInBytes && iMinCacheSizeInBytes <= iMaxCacheSizeInBytes);

	// initial value, will be reset from outside

	iCacheBasePos = 0;

	}

/**

Second phase constructor of CDynamicDirCache.

@param	aClientName the identification of cache memeory client this cache connects

*/

void CDynamicDirCache::ConstructL(const TDesC& aClientName)

	{

//    __PRINT3(_L("CDynamicDirCache::ConstructL(Min=%u, Max=%u, page=%u)"), iMinCacheSizeInBytes, iMaxCacheSizeInBytes, iPageSizeInBytes);

	CCacheMemoryManager* manager = CCacheMemoryManagerFactory::CacheMemoryManager();

	if (manager)

		{

		// client will register itself onto cache memory manager when created

		// note this operation may leave under OOM condition

		iCacheMemoryClient = manager->ConnectClientL(aClientName, iMinSizeInPages * PageSizeInSegs(), iMaxSizeInPages * PageSizeInSegs());

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	ASSERT(iCacheMemoryClient);

	if (!iCacheMemoryClient)

		{

		User::Leave(KErrNoMemory);

		}

	// allocate as many permanently locked pages as there are threads - plus one

	// otherwise DoMakePageMRU() won't work properly with only one thread

	const TUint KThreadCount = 1;

	iPermanentlyAllocatedPageCount = KThreadCount + 1; 

	if (iPermanentlyAllocatedPageCount > iMinSizeInPages)

		iMinSizeInPages = iPermanentlyAllocatedPageCount;

	for (TUint n=0; n<iPermanentlyAllocatedPageCount; n++)

		{

		AddFirstOntoQueue(pPage, TDynamicDirCachePage::ELocked);

		LookupTblAdd(pPage);

		}

	}

/**

Static factory function of CDynamicDirCache

*/

CDynamicDirCache* CDynamicDirCache::NewL(TDriveInterface& aDrive, TUint32 aMinPageNum, TUint32 aMaxPageNum, TUint32 aPageSizeLog2, TUint32 aWrGranularityLog2, const TDesC& aClientName)

    {

    __PRINT3(_L("CDynamicDirCache::NewL(MinPageNum=%u, MaxPageNum=%u, page=%u)"), aMinPageNum, aMaxPageNum, 1<<aPageSizeLog2);

    CDynamicDirCache* pSelf = new (ELeave) CDynamicDirCache(aDrive, aMinPageNum, aMaxPageNum, aPageSizeLog2, aWrGranularityLog2);

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL(aClientName);

    CleanupStack::Pop();

    return pSelf;

    }

/**

Insert an unlocked page into the last position of the locked queue, may squeeze the original last page into

the unlocked queue.

This function is used on last visited but 'unlocked' pages to avoid excessive lock/unlock calls to cache memory

manager as contiguous entry reading/writing often happens on the same page.

@param	aPage	the page to be inserted.

@pre	the page type of aPage should only be TDynamicDirCachePage::EUnknown

*/

void CDynamicDirCache::MakePageLastLocked(TDynamicDirCachePage* aPage)

	{

	// this function should not be called on active pages

	ASSERT(aPage->iType == TDynamicDirCachePage::EUnknown);

	if (iLockedQ.IsEmpty())

		{

		// if locked queue is empty, add it onto the locked queue directly

		AddFirstOntoQueue(aPage, TDynamicDirCachePage::ELocked);

		}

	else

		{

		// otherwise, we squeeze for the last position on locked queue

		while (iLockedQCount + 1 >= iMinSizeInPages)

			{

			TDynamicDirCachePage* last = iLockedQ.Last();

			DeQueue(last);

			UnlockPage(last);

			AddFirstOntoQueue(last, TDynamicDirCachePage::EUnlocked);

			}

		// iLockedQCount + 1 < iMinSizeInPages

		iLockedQ.AddLast(*aPage);

		aPage->SetPageType(TDynamicDirCachePage::ELocked);

		iLockedQCount++;

		}

	}

/**

    Read data from a single page. If the page is not found or not valid anymore, read media onto iActive page first.

    The data will be _Appended_ the the descriptor aDes. The caller is responsible for maintaining this descriptor.

    @param	aPos	the starting position of the media address to be read.

    @param	aLength	the length of the content to be read.

    @param	aDes	the descriptor to contain the content.

    @pre	aLength should be no more than page size.

*/

void CDynamicDirCache::ReadDataFromSinglePageL(TInt64 aPos, TInt aLength, TDes8& aDes)

	{

    //-- the data section is in the cache page entirely, take data directly from the cache

	TDynamicDirCachePage* pPage = FindPageByPos(aPos);

    if (pPage)

    	{

		// lock page before reading,

    	if (LockPage(pPage) != NULL)

    		{

    		// read data and append them to the descriptor

            aDes.Append(pPage->PtrInPage(aPos), aLength);

            // if page is from unlocked queue, insert it onto the last page of the locked

            //  queue. this is to avoid excessive locking and unlocking operations that is

            //  highly likely to happen for following reads.

            if (pPage->PageType() == TDynamicDirCachePage::EUnlocked)

            	{

            	DeQueue(pPage);

            	MakePageLastLocked(pPage);

            	}

    		}

    	else	// page locking failed

    		{

    		ASSERT(pPage->PageType() == TDynamicDirCachePage::EUnlocked);

    		DeQueue(pPage);

    		LookupTblRemove(pPage->StartPos());

    		DecommitPage(pPage);

    		delete pPage;

    		pPage = NULL;

    		}

    	}

	if (!pPage)

		{

        // if page not found or page data not valid anymore, use active page to read data in

        pPage = UpdateActivePageL(aPos);

        // read data and append them to the descriptor

        aDes.Append(pPage->PtrInPage(aPos), aLength);

    	}

	}

//====================================================================

/**

Implementation of pure virtual function.

@see	MWTCacheInterface::ReadL()

*/

void CDynamicDirCache::ReadL(TInt64 aPos, TInt aLength, TDes8& aDes)

	{

#ifdef _DEBUG

    if(iCacheDisabled)

        {

        // cache is disabled for debug purposes

        __PRINT(_L("CDynamicDirCache disabled"));

        User::LeaveIfError(iDrive.ReadNonCritical(aPos, aLength, aDes));

        return;

        }

#endif //_DEBUG

    aDes.Zero();

    const TUint32 PageSz = iPageSizeInBytes;//-- cache page size

    TInt64 pageStartMedPos = CalcPageStartPos(aPos);

    const TUint32 bytesToPageEnd = (TUint32)(pageStartMedPos + PageSz - aPos); //-- number of bytes from aPos to the end of the page

//    __PRINT5(_L("CDynamicDirCache::ReadL: aPos=%lx, aLength=%x, page:%lx, pageSz:%x, bytesToPageEnd=%x"), aPos, aLength, pageStartMedPos, PageSz, bytesToPageEnd);

    // if all data needed is on a single page

    if((TUint32)aLength <= bytesToPageEnd)

        {

        ReadDataFromSinglePageL(aPos, aLength, aDes);

        }

    // or data to be read cross cache page boundary or probably we have more than 1 page to read

    else

        {

        __PRINT(_L("CDynamicDirCache::ReadL() CROSS PAGE!"));

        TUint32 dataLen(aLength);   //-- current data length

        TInt64  currMediaPos(aPos); //-- current media position

        //-- 1. read data that are already in the current page

        ReadDataFromSinglePageL(currMediaPos, bytesToPageEnd, aDes);

        dataLen -= bytesToPageEnd;

        currMediaPos += bytesToPageEnd;

        //-- 2. read whole pages of data

        while (dataLen >= PageSz)

        	{

        	//-- find out if currMediaPos is in cache. If not, find a spare page and read data there

            ReadDataFromSinglePageL(currMediaPos, PageSz, aDes);

            currMediaPos += PageSz;

            dataLen -= PageSz;

        	}

        //-- 3. read the rest of the data

        if(dataLen > 0)

            {

            ReadDataFromSinglePageL(currMediaPos, dataLen, aDes);

            }

        } //else((TUint32)aLength <= bytesToPageEnd)

	}

/**

Write data through a single page. If the page is not found or not valid anymore, read media onto iActive page

first, then write data through iActive page.

@param	aPos	the starting position of the media address to be write.

@param	aData	the starting address that the writing content lives in the ram.

@param	aDataLen	the length of the content to be written.

@pre	aDataLen	should be no more than page size.

*/

TDynamicDirCachePage* CDynamicDirCache::WriteDataOntoSinglePageL(TInt64 aPos, const TUint8* aData, TUint32 aDataLen)

	{

	ASSERT(aDataLen <= iPageSizeInBytes);

    //-- the data section is in the cache page entirely, take data directly from the cache

	TDynamicDirCachePage* pPage = FindPageByPos(aPos);

    if (pPage)

    	{

		// lock page before writing,

    	if (LockPage(pPage) != NULL)

    		{

    		//-- update cache

            Mem::Copy(pPage->PtrInPage(aPos), aData, aDataLen);

    		}

    	else

    		{

    		ASSERT(pPage->PageType() == TDynamicDirCachePage::EUnlocked);

    		DeQueue(pPage);

    		LookupTblRemove(pPage->StartPos());

    		DecommitPage(pPage);

    		delete pPage;

    		pPage = NULL;

    		}

    	}

    // if page not found or page data not valid anymore, use active page to read data in

    if (!pPage)

    	{

        pPage = UpdateActivePageL(aPos);

        //-- update cache

        Mem::Copy(pPage->PtrInPage(aPos), aData, aDataLen);

    	}

	// make sure the page is unlocked after use

	if (pPage->PageType() == TDynamicDirCachePage::EUnlocked)

		{

		UnlockPage(pPage);

		}

	// always make writting events MRU

	DoMakePageMRU(aPos);

    return pPage;

	}

/**

Implementation of pure virtual function.

@see	MWTCacheInterface::WriteL()

*/

void CDynamicDirCache::WriteL(TInt64 aPos,const TDesC8& aDes)

	{

#ifdef _DEBUG

    if(iCacheDisabled)

        {

        // cache is disabled for debug purposes

        __PRINT(_L("CDynamicDirCache disabled"));

        User::LeaveIfError(iDrive.WriteCritical(aPos,aDes));

        return;

        }

#endif //_DEBUG

    TUint32 dataLen = aDes.Size();

    const TUint8* pData   = aDes.Ptr();

    const TUint32 PageSz  = iPageSizeInBytes; //-- cache page size

    TInt64 pageStartMedPos = CalcPageStartPos(aPos);

    TUint32 bytesToPageEnd = (TUint32)(pageStartMedPos + PageSz - aPos);

//    __PRINT5(_L("CDynamicDirCache::WriteL: aPos=%lx, aLength=%x, page:%lx, pageSz:%x, bytesToPageEnd=%x"), aPos, dataLen, pageStartMedPos, PageSz, bytesToPageEnd);

    if(dataLen <= bytesToPageEnd)

        {//-- make small write a multiple of a write granularity size (if it is used at all)

         //-- this is not the best way to use write granularity, but we would need to refactor cache pages code to make it normal

        TDynamicDirCachePage* pPage = WriteDataOntoSinglePageL(aPos, pData, dataLen);

        TPtrC8 desBlock(aDes);

        if(iWrGranularityLog2)

            {//-- write granularity is used

            const TInt64  newPos = (aPos >> iWrGranularityLog2)  << iWrGranularityLog2; //-- round position down to the granularity unit size

            TUint32 newLen = (TUint32)(aPos - newPos)+dataLen;

            newLen = RoundUp(newLen, iWrGranularityLog2);

            const TUint8* pd = pPage->PtrInPage(newPos);

            desBlock.Set(pd, newLen);

            aPos = newPos;

            }

        //-- write data to the media

        const TInt nErr = iDrive.WriteCritical(aPos, desBlock);

        if(nErr != KErrNone)

            {//-- some serious problem occured during writing, invalidate cache.

            InvalidateCache();

            User::Leave(nErr);

            }

        }

    else

        {//-- Data to be written cross cache page boundary or probably we have more than 1 page to write

         //-- this is a very rare case.   

        __PRINT(_L("CDynamicDirCache::WriteL() CROSS PAGE!"));

        //-- Data to be written cross cache page boundary or probably we have more than 1 page to write

        TInt64  currMediaPos(aPos);

        //-- 1. update the current page

        WriteDataOntoSinglePageL(currMediaPos, pData, bytesToPageEnd);

        pData += bytesToPageEnd;

        currMediaPos += bytesToPageEnd;

        dataLen -= bytesToPageEnd;

        //-- 2. write whole pages of data to the cache

        while (dataLen >= PageSz)

        	{

            WriteDataOntoSinglePageL(currMediaPos, pData, PageSz);

            pData += PageSz;

            currMediaPos += PageSz;

            dataLen -= PageSz;

        	}

        //-- 3. write the rest of the data

        if(dataLen > 0)

            {

            WriteDataOntoSinglePageL(currMediaPos, pData, dataLen);

            }

    //-- write data to the media

    const TInt nErr = iDrive.WriteCritical(aPos,aDes);

    if(nErr != KErrNone)

        {//-- some serious problem occured during writing, invalidate cache.

        InvalidateCache();

        User::Leave(nErr);

        }

        }// else(dataLen <= bytesToPageEnd)

	}

/**

    Invalidate the cache

    @see	MWTCacheInterface::InvalidateCache()

*/

void CDynamicDirCache::DoInvalidateCache(void)

	{

	__PRINT2(_L("CDynamicDirCache::InvalidateCache(locked=%d, unlocked=%d)"), iLockedQCount, iUnlockedQCount);

	// we should never decommit locked pages as they needs to be reserved anyway

	// the overhead of unnecessary page committing operations

	TInt pagesToRemoveFromLockedQueue = iLockedQCount - iPermanentlyAllocatedPageCount;

	TInt n;

	for (n=0; n<pagesToRemoveFromLockedQueue; n++)

		{

		TDynamicDirCachePage* page = iLockedQ.Last();

		DeQueue(page);						// remove from queue

		LookupTblRemove(page->StartPos());	// remove from lookuptable

		DecommitPage(page);					// inform cache client to decommit page memory

		delete page;

		}

	ASSERT(iLockedQCount == iPermanentlyAllocatedPageCount);

	TDblQueIter<TDynamicDirCachePage> q(iLockedQ);

	q.SetToFirst();

	while((TDynamicDirCachePage*) q)

		{

		TDynamicDirCachePage* page = q++;

		LookupTblRemove(page->StartPos());// remove from lookuptable