sl@0: // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of the License "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // f32\sfat32\inc\sl_facache32.h
sl@0: // FAT32 various cache classes definition
sl@0: // 
sl@0: //
sl@0: 
sl@0: /**
sl@0:  @file
sl@0:  @internalTechnology
sl@0: */
sl@0: 
sl@0: #ifndef SL_FAT_CACHE_32_H
sl@0: #define SL_FAT_CACHE_32_H
sl@0: 
sl@0: #include "sl_fatcache.h"
sl@0: 
sl@0: class CFat32LruCachePage;
sl@0: 
sl@0: 
sl@0: //---------------------------------------------------------------------------------------------------------------------------------
sl@0: 
sl@0: /**
sl@0:     FAT32 LRU paged cache. Used for FAT32 only.
sl@0: 
sl@0:     Consists of LRU list of cache pages; Each page is logically divided to page sectors. The number of pages depends on the
sl@0:     maximal amount of memory this cache allowed to use.  Usually, whole FAT32 can not be cached fully because of its large size.
sl@0:     So, this type caches the most receinlly used areas of the FAT32. This is the wriite-back cache.
sl@0:  
sl@0:     Read granularity: One page, which size is 2^aRdGranularityLog2
sl@0:     Write granularity: cache's page sector; its size is 2^aWrGranularityLog2
sl@0: */
sl@0: class CFat32LruCache : public CFatPagedCacheBase
sl@0: {
sl@0:  public:
sl@0: 
sl@0:     static CFat32LruCache* NewL(CFatMountCB* aOwner, TUint32 aMaxMemSize, TUint32 aRdGranularityLog2, TUint32 aWrGranularityLog2);
sl@0: 
sl@0:     //-- overrides from base class
sl@0:     virtual void Close(TBool aDiscardDirtyData);
sl@0:     virtual void FlushL();
sl@0: 
sl@0:     virtual TUint32 ReadEntryL(TUint32 aIndex);
sl@0:     virtual void WriteEntryL(TUint32 aIndex, TUint32 aEntry);
sl@0: 
sl@0:     virtual TInt Invalidate();
sl@0:     virtual TInt InvalidateRegion(TUint32 aStartEntry, TUint32 aNumEntries);
sl@0:     
sl@0: 
sl@0:     virtual CFatBitCache* BitCacheInterface();
sl@0: 
sl@0:  public:     
sl@0:      TBool FindFreeEntryInCacheSectorL(TUint32& aFatEntryIndex);
sl@0: 
sl@0:  private:
sl@0:     
sl@0:     void InitialiseL(CFatMountCB* aOwner, TUint32 aFatSize, TUint32 aRdGranularityLog2, TUint32 aWrGranularityLog2);
sl@0:     
sl@0:     CFat32LruCache();
sl@0:     CFat32LruCache(const CFat32LruCache&);
sl@0:     CFat32LruCache& operator=(const CFat32LruCache&);
sl@0:     
sl@0:     TBool ReadCachedEntryL(TUint32 aFatIndex, TFat32Entry& aResult);
sl@0:     TBool WriteCachedEntryL(TUint32 aFatIndex, TFat32Entry aFatEntry);
sl@0: 
sl@0:     CFat32LruCachePage* DoGetSpareCachePageL();
sl@0: 
sl@0:     void AssertCacheReallyClean() ;
sl@0: 
sl@0:  private:
sl@0: 
sl@0:     typedef TDblQue<CFat32LruCachePage> TPageList;
sl@0:     typedef TDblQueIter<CFat32LruCachePage> TPageIterator;
sl@0: 
sl@0:     TUint32   iMaxFatEntries;       ///< maximal number of FAT entries in FAT table
sl@0:     TUint     iNumPagesAllocated;   ///< number of pages currently allocated
sl@0:     TUint     iMaxPages;            ///< maximal pages allowed to allocate
sl@0:     TPageList iPageList;            ///< LRU list of cache pages.
sl@0: 
sl@0:     
sl@0:     CFatBitCache *iBitCache; ///< pointer to the FAT bit supercache
sl@0: 
sl@0: };
sl@0: 
sl@0: 
sl@0: //---------------------------------------------------------------------------------------------------------------------------------
sl@0: 
sl@0: /**
sl@0:     FAT32 LRU cache page. Used only by CFat32LruCache. 
sl@0: */
sl@0: class CFat32LruCachePage : public CFatCachePageBase
sl@0: {
sl@0:  public:
sl@0: 
sl@0:     static CFat32LruCachePage* NewL(CFatPagedCacheBase& aCache);
sl@0: 
sl@0:     //-- overrides
sl@0:     virtual TBool ReadCachedEntryL (TUint32 aFatIndex, TUint32& aResult);
sl@0:     virtual TBool WriteCachedEntryL(TUint32 aFatIndex, TUint32 aFatEntry); 
sl@0:     virtual TUint32 ReadFromMediaL(TUint32 aFatIndex);
sl@0:     //----
sl@0: 
sl@0:  private:
sl@0:     CFat32LruCachePage(CFatPagedCacheBase& aCache);
sl@0: 
sl@0:     //-- outlaws here
sl@0:     CFat32LruCachePage();
sl@0:     CFat32LruCachePage(const CFat32LruCachePage&);
sl@0:     CFat32LruCachePage& operator=(const CFat32LruCachePage&);
sl@0: 
sl@0:     inline TFat32Entry* GetEntryPtr(TUint32 aFatIndex) const;
sl@0:     virtual void DoWriteSectorL(TUint32 aSector);
sl@0: 
sl@0:  private: 
sl@0:     enum {KFat32EntryMask = 0x0FFFFFFF}; ///< FAT32 entry mask 
sl@0: 
sl@0:  public:
sl@0:     TDblQueLink iLink; ///< list link object. See TPageList
sl@0: };
sl@0: 
sl@0: //---------------------------------------------------------------------------------------------------------------------------------
sl@0: 
sl@0: /**
sl@0:     FAT32 bit supercache. This is a special cache above the CFat32LruCache.
sl@0:     Used for quick lookup for the free entries in FAT32 table without accessing media and thrashing FAT32 LRU cache.
sl@0:     
sl@0:     Logically consists of a bit vector, where each bit represents one FAT sector (one unit of read granularity within CFat32LruCachePage)
sl@0:     for the _whole_ FAT table.
sl@0:     
sl@0:     If some bit in the vector is set to '1' it means that the corresponding FAT cache sector (not necessarily currently cached) _may_ have
sl@0:     a at least one free FAT entry. If the bit is '0' it means that there is no free fat entries in this part of the FAT.
sl@0: 
sl@0:     The situation when bit set to '1' corresponds to the FAT cache sector without free entries is quite possible, but it is resolved by this cache.
sl@0:     The situation when '0' bit corresponds to the fat sector that _does_ contain free entries is extremely unlikely and can be
sl@0:     caused by direct raw writes to the FAT, for example. Nothing terribly wrong with this situation, the search for free entry will fall back
sl@0:     to the old algorithm CFatTable::FindClosestFreeClusterL() .
sl@0:     
sl@0:     The information in this cache is also updated on flushing dirty sectros by  CFat32LruCachePage.
sl@0: 
sl@0: 
sl@0: */
sl@0: class CFatBitCache : public CBase
sl@0: {
sl@0:  public:
sl@0: 
sl@0:     ~CFatBitCache();
sl@0:  
sl@0:     static CFatBitCache* New(CFat32LruCache& aOnwerFatCache);
sl@0: 
sl@0:     void Close();
sl@0:    
sl@0:     TBool StartPopulating();
sl@0:     TBool FinishPopulating(TBool aSuccess);
sl@0: 
sl@0:     
sl@0:     /** possible states of this cache */
sl@0:     enum TState
sl@0:         {
sl@0:         EInvalid,       ///< initial, invalid
sl@0:         ENotPopulated,  ///< initialised, but not populated yet
sl@0:         EPopulating,    ///< in the process of populating
sl@0:         EPopulated,     ///< successfully populated; the only consistent state.
sl@0:         };
sl@0:     
sl@0:     inline TState State() const;
sl@0:     inline TBool  UsableState() const;
sl@0:     inline TBool  FatSectorHasFreeEntry(TUint32 aFatSectorNum) const;
sl@0:     inline void   SetFreeEntryInFatSector(TUint32 aFatSectorNum, TBool aHasFreeEntry);
sl@0: 
sl@0:     TBool SetFreeFatEntry(TUint32 aFatIndex);
sl@0:     TInt  FindClosestFreeFatEntry(TUint32& aFatIndex);
sl@0:     void  MarkFatRange(TUint32 aStartFatIndex, TUint32 aEndFatIndex, TBool aAsFree);
sl@0: 
sl@0: 
sl@0:     void Dump() const;
sl@0: 
sl@0:  private:
sl@0: 
sl@0:     //-- outlaws
sl@0:     CFatBitCache();
sl@0:     CFatBitCache(const CFatBitCache&);
sl@0:     CFatBitCache& operator=(const CFatBitCache&);
sl@0: 
sl@0:     CFatBitCache(CFat32LruCache& aOnwerFatCache);
sl@0: 
sl@0:     TInt Initialise();
sl@0: 
sl@0:     inline void SetState(TState aState);
sl@0:     inline TUint32 FatIndexToCacheSectorNumber(TUint32 aFatIndex) const;
sl@0:     inline TUint32 CacheSectorNumberToFatIndex(TUint32 aCacheSecNum) const;
sl@0: 
sl@0:  private:
sl@0: 
sl@0:     TState          iState;             ///< internal state of the cache
sl@0:     RBitVector      iBitCache;          ///< bit vector itself
sl@0:     TUint32         iFatIdxToSecCoeff;  ///< Log2(FatCacheSectorSize/Sizeof(FAT32 entry)). Used to convert FAT32 index to FAT32 cache sector number and back.
sl@0:     CFat32LruCache& iOwnerFatCache;     ///< reference to the owner FAT32 LRU cache
sl@0: 
sl@0:     DBG_STATEMENT(TUint  iPopulatingThreadId;)  ///< used in debug mode for checking multithreading issues
sl@0: };
sl@0: 
sl@0: //---------------------------------------------------------------------------------------------------------------------------------
sl@0: 
sl@0: #include "sl_fatcache32.inl"
sl@0: 
sl@0: #endif //SL_FAT_CACHE_32_H
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: