// 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.

*/

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

	{

	return new TDynamicDirCachePage(aOwnerCache, aStartMedPos, aStartRamAddr);

	}

/**

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),

				  iLastVisitedPage(NULL),

                  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

    //-- At present moment the size of TDrive thread pool is 1 (1 drive thread in a pool)

    const TUint KThreadCount = 1;

    iPermanentlyAllocatedPageCount = KThreadCount; 

	if (iPermanentlyAllocatedPageCount > iMinSizeInPages)

		iMinSizeInPages = iPermanentlyAllocatedPageCount;

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

		{

        TDynamicDirCachePage* pPage = AllocateAndLockNewPage();

        ASSERT(pPage);

        if (!pPage)

            User::Leave(KErrNoMemory);

		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;

    }

/**

    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, try to keep it locked until we move to a 

            //  different page from the unlocked queue 

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

            //  highly likely to happen when DoFindL() linearly scan through the directory

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

                && iLastVisitedPage != pPage)

                {

                // Note: iLastVisitedPage may have been moved from unlocked queue to locked queue

                if(iLastVisitedPage && iLastVisitedPage->PageType() == TDynamicDirCachePage::EUnlocked)

                    {

                    User::LeaveIfError(UnlockPage(iLastVisitedPage));

                    }

                iLastVisitedPage = 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

		ResetPagePos(page);				// reset start media position (0), invalidate page content

		}

	// however we should decommit unlocked pages here

	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(iLockedQCount == iPermanentlyAllocatedPageCount);

	ASSERT(iCacheMemoryClient);

	}

/**

Implementation of pure virtual function.

@see	MWTCacheInterface::InvalidateCache()

*/

void CDynamicDirCache::InvalidateCache(void)

	{

	DoInvalidateCache();

	}