// Copyright (c) 1996-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\sfat32\sl_fatcache32.cpp

// 

//

#include "sl_std.h"

#include "sl_fatcache32.h"

/**

    @file

    Various FAT32 caches implementation

*/

//#################################################################################################################################

//# CFat32LruCache implementation

//#################################################################################################################################

//-----------------------------------------------------------------------------

CFat32LruCache::CFat32LruCache()

               :CFatPagedCacheBase(), iPageList(_FOFF(CFat32LruCachePage, iLink))

    {

    }

//-----------------------------------------------------------------------------

/**

    FAT32 LRU cache factory function.

    @param  aOwner              pointer to the owning FAT mount

    @param  aMaxMemSize         maximal size of the memory the cache can use, bytes

    @param  aRdGranularityLog2  Log2(read granularity)

    @param  aWrGranularityLog2  Log2(write granularity)

    @return pointer to the constructed object.

*/

CFat32LruCache* CFat32LruCache::NewL(CFatMountCB* aOwner, TUint32 aMaxMemSize, TUint32 aRdGranularityLog2, TUint32 aWrGranularityLog2)

    {

    __PRINT(_L("#-CFat32LruCache::NewL()"));

    CFat32LruCache* pSelf = NULL;

    pSelf = new (ELeave) CFat32LruCache;

    CleanupStack::PushL(pSelf);

    pSelf->InitialiseL(aOwner, aMaxMemSize, aRdGranularityLog2, aWrGranularityLog2);

    CleanupStack::Pop();

    return pSelf;

    }

//-----------------------------------------------------------------------------

/** 

    @return pointer to the CFatBitCache interface. 

*/

CFatBitCache* CFat32LruCache::BitCacheInterface() 

    {

    return iBitCache;

    }  

//-----------------------------------------------------------------------------

/**

    FAT32 LRU cache initialisation.

    @param  aOwner              pointer to the owning FAT mount

    @param  aMaxMemSize         maximal size of the memory the cache can use, bytes

    @param  aRdGranularityLog2  Log2(read granularity)

    @param  aWrGranularityLog2  Log2(write granularity)

    @return pointer to the constructed object.

*/

void  CFat32LruCache::InitialiseL(CFatMountCB* aOwner, TUint32 aMaxMemSize, TUint32 aRdGranularityLog2, TUint32 aWrGranularityLog2)

    {

    const TUint32 KReadGranularity = Pow2(aRdGranularityLog2);

    const TUint32 KWriteGranularity = Pow2(aWrGranularityLog2);

    __PRINT3(_L("#-CFat32LruCache::InitialiseL MaxMem:%u, RdGr:%d, WrGr:%d"),aMaxMemSize, KReadGranularity, KWriteGranularity);

    (void)KReadGranularity;

    (void)KWriteGranularity;

    const TBool bParamsValid = (aRdGranularityLog2 >= aWrGranularityLog2) && (aWrGranularityLog2 >= KDefSectorSzLog2) && (aMaxMemSize > KReadGranularity);

    __ASSERT_ALWAYS(bParamsValid, Fault(EFatCache_BadGranularity));  

    CFatPagedCacheBase::InitialiseL(aOwner);

    ASSERT(FatType() == EFat32);

    //-- according to the FAT32 specs, FAT32 min size is 65526 entries or 262104 bytes.

    //-- It's possible to incorrectly format a small volume to FAT32, it shall be accessible read-only.

    if(aMaxMemSize > FatSize()) 

        {//-- strange situation, memory allocated for LRU cache is enough to cache whole FAT32

        __PRINT(_L("#-CFat32LruCache::InitialiseL warning: LRU cache becomes fixed! (too much memory allowed)"));

        aMaxMemSize = FatSize();

        }

    //-- LRU cache page size is (2^aRdGranularityLog2) bytes and consists of 2^(aRdGranularityLog2-aWrGranularity) sectors.

    iPageSizeLog2 = aRdGranularityLog2;

    iSectorSizeLog2 = aWrGranularityLog2; //-- Log2(number of sectors in cache page)

    iMaxPages = aMaxMemSize / PageSize(); //-- maximal number of cache pages we can allocate

    iNumPagesAllocated = 0;

    __ASSERT_ALWAYS((iMaxPages > 1 && SectorsInPage() < KMaxSectorsInPage), Fault(EFatCache_BadGranularity));

    //-- obtain maximal number of entries in the table

    if(aOwner->UsableClusters() < 1)

        {

        ASSERT(0);

        User::Leave(KErrCorrupt);

        }

    iMaxFatEntries = aOwner->UsableClusters()+KFatFirstSearchCluster; //-- FAT[0] & FAT[1] are not in use

    //-- create FAT bit supercache if it is enabled in config

    ASSERT(!iBitCache);

    if(aOwner->FatConfig().FAT32_UseBitSupercache())

        {

        iBitCache = CFatBitCache::New(*this);

        }

    else

        {

        __PRINT(_L("#++ !! Fat Bit Supercache is disabled in config !!"));

        }

    }

//-----------------------------------------------------------------------------

/**

    Close the cache and deallocate its memory.

    @param  aDiscardDirtyData if ETrue, will ignore dirty data. If EFalse, will panic on atempt to close dirty cache.  

*/

void CFat32LruCache::Close(TBool aDiscardDirtyData)

    {

    __PRINT1(_L("#-CFat32LruCache::Close(%d)"), aDiscardDirtyData);

    //-- delete FAT bit supercache if present

    delete iBitCache;

    iBitCache=NULL;

    //-- delete existing cache pages

    TPageIterator itr(iPageList);

    for(;;)

        {

        CFat32LruCachePage* pPage = itr++;

        if(!pPage) 

            break;

        pPage->iLink.Deque(); //-- remove page from the list

        if(pPage->IsDirty())

            {//-- trying to destroy the cache that has dirty pages

            __PRINT1(_L("#-CFat32LruCache::Close() The page is dirty! Start idx:%d"), pPage->StartFatIndex());

            if(!aDiscardDirtyData)

                {

                Fault(EFatCache_DiscardingDirtyData);  

                }

            //-- ignore this fact if requested.

            }

        delete pPage;

        --iNumPagesAllocated;

        }

    SetDirty(EFalse);

    ASSERT(!iNumPagesAllocated);

    }

//-----------------------------------------------------------------------------

/**

    Tries to read FAT entry from the cache. If the entry at aFatIndex is not cached, does nothing and returns EFalse.

    If finds the cache page that contains entry at index "aFatIndex", reads it and returns ETrue.

    @param  aFatIndex  FAT entry index within FAT table

    @param  aFatEntry  on success it will contain FAT entry value

    @return ETrue if the entry has been read

            EFalse if index aFatIndex isn't cached

*/

TBool CFat32LruCache::ReadCachedEntryL(TUint32 aFatIndex, TFat32Entry& aResult)

    {

    //-- iterate through LRU list looking if the entry is cached.

    TPageIterator itr(iPageList);

    for(;;)

        {

        CFat32LruCachePage* pPage = itr++;

        if(!pPage) 

            break;

        if(pPage->ReadCachedEntryL(aFatIndex, aResult))

            {//-- found entry in some cache page. Make this page LRU

            if(!iPageList.IsFirst(pPage))

                {

                pPage->iLink.Deque();

                iPageList.AddFirst(*pPage);

                }

            return ETrue; 

            }

        }

    return EFalse; //-- the entry is not cached

    }

//-----------------------------------------------------------------------------

/**

    Tries to write FAT entry to the cache. If the entry at aFatIndex is not cached, does nothing and returns EFalse.

    If finds the cache page that contains entry at index "aFatIndex", overwrites it and returns ETrue

    @param  aFatIndex  FAT entry index within FAT table

    @param  aFatEntry  new FAT entry value

    @return ETrue if the entry has been overwritten

            EFalse if index aFatIndex isn't cached

*/

TBool CFat32LruCache::WriteCachedEntryL(TUint32 aFatIndex, TFat32Entry aFatEntry)

    {

    //-- iterate through LRU list looking if the entry is cached.

    TPageIterator itr(iPageList);

    for(;;)

        {

        CFat32LruCachePage* pPage = itr++;

        if(!pPage) 

            break;

        if(pPage->WriteCachedEntryL(aFatIndex, aFatEntry))

            {//-- the entry was cached and modified now. Make this page LRU

            if(!iPageList.IsFirst(pPage))

                {

                pPage->iLink.Deque();

                iPageList.AddFirst(*pPage);

                }

            return ETrue; 

            }

        }

    return EFalse; //-- the entry is not cached

    }

//-----------------------------------------------------------------------------

/**

    Get a spare page. This function can either allocate a page if memory limit isn't reached yet

    or find the least recently used (in the end of the LRU list) and evict it.

    @return pointer to the cache page to use, it will be insertet to the beginning of the LRU list

*/

CFat32LruCachePage* CFat32LruCache::DoGetSpareCachePageL()

    {

    CFat32LruCachePage* pPage=NULL;

    if(iNumPagesAllocated < iMaxPages)

        {//-- we still can allocate a page

        pPage = CFat32LruCachePage::NewL(*this);

        ++iNumPagesAllocated;

        iPageList.AddFirst(*pPage); //-- insert the page into the beginning of LRU list

        return pPage;

        }

    //-- all pages are already allocated, evict the last recently used and remove it from the list

    pPage = iPageList.Last();   //-- least recently used page, last in the list

    pPage->iLink.Deque();       //-- remove it from the LRU list

    iPageList.AddFirst(*pPage); //-- insert the page into the beginning of LRU list

    //__PRINT1(_L("#-CFat32LruCache::DoGetSpareCachePageL() page @FAT idx:%d evicted"), pPage->StartFatIndex());

    //-- flush the page, writing its data to all copies of FAT, to FAT1, then to FAT2 etc.

    ASSERT(NumFATs() >0);

    if(pPage->IsDirty())

        {

        //-- write page data to all copies of FAT

        for(iCurrentFatNo=0; iCurrentFatNo < NumFATs(); ++iCurrentFatNo)

            {

            const TBool keepDirty = iCurrentFatNo < (NumFATs()-1);

            pPage->FlushL(keepDirty);

            }

        iCurrentFatNo = KInvalidFatNo;

        }

    return pPage;

    }

//-----------------------------------------------------------------------------

/**

    Read FAT entry from the cache. 

    @param  aIndex FAT entry index to read

    @return FAT entry value at the index "aIndex"

*/

TUint32 CFat32LruCache::ReadEntryL(TUint32 aIndex)

    {

//    __PRINT1(_L("#-CFat32LruCache::ReadEntryL() FAT idx:%d"), aIndex);

    ASSERT(aIndex >= KFatFirstSearchCluster &&  aIndex < (FatSize() >> KFat32EntrySzLog2));

    //-- firstly try to locate required entry in cache

    TFat32Entry entry;

    if(ReadCachedEntryL(aIndex, entry))

        return entry; //-- the requested entry found in cache

    //-- No luck, get a spare cache page (it will be inserted to the head of the LRU list)

    CFat32LruCachePage* pPage = DoGetSpareCachePageL();

    ASSERT(pPage); 

    entry = pPage->ReadFromMediaL(aIndex); //-- read whole FAT page from the media

    return entry;

    }

//-----------------------------------------------------------------------------

/**

    Write FAT entry to the cache. 

    Appropriate FAT cache sector will be marked as "dirty" and will be eventually flushed to the media.

    @param  aIndex FAT entry index

    @param  aEntry FAT entry value

*/

void CFat32LruCache::WriteEntryL(TUint32 aIndex, TUint32 aEntry)

    {

    //__PRINT2(_L("#-CFat32LruCache::WriteEntryL() FAT idx:%d, val:%d"), aIndex, aEntry);

    ASSERT(aIndex >= KFatFirstSearchCluster &&  aIndex < (FatSize() >> KFat32EntrySzLog2));

    SetDirty(ETrue);

    //-- 1. try to locate entry in the cache and overwrite it there if it is cached

    if(WriteCachedEntryL(aIndex, aEntry))

        return; //-- the entry in cache altered

    //-- 2. the entry isn't cached; find a spare cache page (it will be inserted to the head of the LRU list)

    CFat32LruCachePage* pPage = DoGetSpareCachePageL();

    ASSERT(pPage); 

    pPage->ReadFromMediaL(aIndex); //-- read whole FAT page from the media

    //-- 3. overwrite entry in cache

    TBool bRes = pPage->WriteCachedEntryL(aIndex, aEntry);

    ASSERT(bRes);

    (void)bRes;

    }

//-----------------------------------------------------------------------------

/**

    A debug method that asserts that the cache is really clean

*/

void CFat32LruCache::AssertCacheReallyClean() 

    {

#ifdef _DEBUG 

    TPageIterator itr(iPageList);

    for(;;)

        {//-- iterate through LRU list flushing pages into the current copy of FAT

        CFat32LruCachePage* pPage = itr++;

        if(!pPage) 

            break;

        if(pPage->IsDirty())

            {

            __PRINT(_L("#-CFat32LruCache::AssertCacheReallyClean()"));

            ASSERT(0);

            }

        }

#endif   

    }

//-----------------------------------------------------------------------------

/**

    Flushes all dirty data to the media.

*/

void CFat32LruCache::FlushL()

    {

    if(!IsDirty())

        {

        AssertCacheReallyClean();

        return;

        }

    //-- flush dirty data to all copies of FAT

    //-- all dirty pages will be written firstly to FAT1, then all of them will be written to FAT2 etc.

    for(iCurrentFatNo=0; iCurrentFatNo < NumFATs(); ++iCurrentFatNo)

        {

        TPageIterator itr(iPageList);

        for(;;)

            {//-- iterate through LRU list flushing pages into the current copy of FAT

            CFat32LruCachePage* pPage = itr++;

            if(!pPage) 

                break;

            //-- we need to keep page dirty until it is flushed to the last copy of FAT table

            const TBool keepDirty = iCurrentFatNo < (NumFATs() - 1);

            pPage->FlushL(keepDirty);

            }

        }

    iCurrentFatNo = KInvalidFatNo;

    SetDirty(EFalse);

    }

//-----------------------------------------------------------------------------

/**

    Invalidate whole cache. All pages will be marked as invalid and will be re-read from the media on first access to them.

    @return always KErrNone

*/

TInt CFat32LruCache::Invalidate()

    {

    __PRINT(_L("#-CFat32LruCache::Invalidate()"));

    const TBool bIgnoreDirtyData = CheckInvalidatingDirtyCache();

    //-- iterate through LRU list marking every page as invalid

    TPageIterator itr(iPageList);

    for(;;)

        {

        CFat32LruCachePage* pPage = itr++;

        if(!pPage) 

            break;

        pPage->Invalidate(bIgnoreDirtyData);

        }

    SetDirty(EFalse);

    return KErrNone;

    }

//-----------------------------------------------------------------------------

/**

    Invalidate FAT cache pages that contain FAT32 entries from aStartIndex to (aStartIndex+aNumEntries)

    These pages will be marked as invalid and will be re-read from the media on first access to them.

    @param  aStartIndex FAT start index of the region being invalidated

    @param  aNumEntries number of entries to invalidate

    @return always KErrNone

*/

TInt CFat32LruCache::InvalidateRegion(TUint32 aStartIndex, TUint32 aNumEntries)

    {

    __PRINT2(_L("#-CFat32LruCache::InvalidateRegion() startIndex:%d, entries:%d"),aStartIndex, aNumEntries);

    ASSERT(aStartIndex >= KFatFirstSearchCluster &&  aStartIndex < (FatSize() >> KFat32EntrySzLog2));

    if(!aNumEntries)

        {

        ASSERT(0);

        return KErrNone;

        }

    const TBool bIgnoreDirtyData = CheckInvalidatingDirtyCache();

    const TUint KEntriesInPage = Pow2(PageSizeLog2() - KFat32EntrySzLog2);

    const TUint KLastIndex = aStartIndex+aNumEntries;

    TBool bCacheIsStillDirty = EFalse; //-- ETrue if the cache is still dirty after invalidating its region

    for(TUint currIndex = aStartIndex; currIndex < KLastIndex; currIndex+=KEntriesInPage)

        {

        TPageIterator itr(iPageList);

        for(;;)

            {//-- iterate through all pages, invalidating required

            CFat32LruCachePage* pPage = itr++;

            if(!pPage) 

                break;

            if(pPage->IsEntryCached(currIndex))

                {

                pPage->Invalidate(bIgnoreDirtyData); 

                }

            else if(pPage->IsDirty()) //-- invalid page can't be ditry.

                {

                bCacheIsStillDirty = ETrue; //-- we have at least 1 dirty page

                }

            }

        }

    SetDirty(bCacheIsStillDirty);

    return KErrNone;

}

//-----------------------------------------------------------------------------

/**

    Look for free FAT entry in the FAT sector that corresponds to the aFatEntryIndex.

    Search is performed in both directions, the right one has more priority (FAT cluster chain needs to grow right).

    See FindFreeEntryInCacheSector()

*/

TBool CFat32LruCache::FindFreeEntryInCacheSectorL(TUint32& aFatEntryIndex)

    {

    if(ReadEntryL(aFatEntryIndex) == KSpareCluster)

        return ETrue;

    //-- look for free FAT entries in the FAT cache sector corresponting to the aStartIndex.

    //-- use the same approach as in CFatTable::FindClosestFreeClusterL()

    const TUint32 coeff = SectorSizeLog2()-KFat32EntrySzLog2;

    const TUint32 numEntriesInSector = Pow2(coeff); //-- number of FAT32 entries in FAT cache sector

    TUint32 MinIdx = (aFatEntryIndex >> coeff) << coeff;

    TUint32 MaxIdx = MinIdx+numEntriesInSector-1;

    if(MinIdx == 0)

        {//-- correct values if this is the first FAT sector; FAT[0] & FAT[1] are reserved

        MinIdx += KFatFirstSearchCluster;

        }

    //-- actual number of usable FAT entries can be less than deducted from number of FAT sectors.

    MaxIdx = Min(MaxIdx, iMaxFatEntries-1);