diff -r 000000000000 -r a41df078684a userlibandfileserver/fileserver/sfat/sl_fatcache.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/userlibandfileserver/fileserver/sfat/sl_fatcache.h Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,380 @@ +// Copyright (c) 1998-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_facache.h +// FAT cache base classes definition +// FAT12 and FAT16 cache classes definition +// +// + +/** + @file + @internalTechnology +*/ + +#ifndef SL_FAT_CACHE_H +#define SL_FAT_CACHE_H + + +//----------------------------------------------------------------------------- + +/** + A simple abstraction of the 32 bit flags +*/ +class T32Bits +{ + public: + T32Bits() : iData(0) {} + + inline void Clear(); + inline TBool HasBitsSet() const; + inline void SetBit(TUint32 aIndex); + inline TBool operator[](TUint32 aIndex) const; + + private: + TUint32 iData; ///< 32 bits data +}; + +//----------------------------------------------------------------------------- + +class CFatBitCache; + +/** + An abstract base class for all types of FAT caches. + Provides user interface and some common for all types of FAT caches functionality. +*/ +class CFatCacheBase : public CBase +{ + public: + + virtual ~CFatCacheBase(); + + //-- public interface + virtual void Close(TBool /*aDiscardDirtyData*/) {}; + virtual void FlushL() = 0; + + virtual TUint32 ReadEntryL(TUint32 aIndex) = 0; + virtual void WriteEntryL(TUint32 aIndex, TUint32 aEntry) = 0; + + virtual TInt Invalidate() = 0; + virtual TInt InvalidateRegion(TUint32 aStartEntry, TUint32 aNumEntries) = 0; + + TInt ReadFatData(TUint32 aPos, TUint32 aLen, TDes8& aData) const; + TInt WriteFatData(TUint32 aPos, const TDesC8& aData) const; + + inline TUint32 FatStartPos() const; + inline TUint32 FatSize() const; + inline TFatType FatType() const; + + public: + + //-- auxilary interface to additional bit supercache (it may exist only in FAT32 cache implementation) + virtual CFatBitCache* BitCacheInterface(); + + + protected: + CFatCacheBase(); + + virtual void InitialiseL(CFatMountCB* aOwner); + + inline TBool IsDirty() const; + inline void SetDirty(TBool aDirty); + inline TUint NumFATs() const; + + TBool CheckInvalidatingDirtyCache() const; + + inline TUint FAT_SectorSzLog2() const; + inline TUint FAT_SectorSz() const; + inline TUint FAT_ClusterSzLog2() const; + + protected: + + enum {KInvalidFatNo = 0xFF}; ///< used to invalidate current FAT no. + TUint iCurrentFatNo; ///< current FAT number WriteFatData will write to. + + private: + //-- values cached from owning mount. + TUint32 iFatStartPos; ///< media position of FAT1 start + TUint32 iFatSize; ///< size of FAT in bytes + TUint16 iNumFATs; ///< number of FATs on the volume + TUint16 iFatSecSzLog2; ///< Log2(FAT Sector size) + TUint16 iFatClustSzLog2;///< Log2(FAT cluster size) + TFatType iFatType; ///< FAT type + TFatDriveInterface* ipDrive;///< interface to the media driver + //--- + + TBool iDirty; ///< ETrue if the cache is dirty +}; + + +//----------------------------------------------------------------------------- + +/** + Fixed FAT12 cache. This is a contiguous cache that caches whole FAT12. + This cache is logically divided to sectors, maximal number of sectors in this cache is KMaxSectorsInCache (32). + + Read granularity: whole cache; anyway it can't be larger than 6126 bytes. + Write granularity: cache sector size, which is always "FAT Sector Size" and non-configurable. +*/ +class CFat12Cache : public CFatCacheBase +{ + public: + static CFat12Cache* NewL(CFatMountCB* aOwner, TUint32 aFatSize); + + //-- overrides from base class + virtual void Close(TBool aDiscardDirtyData); + virtual void FlushL(); + + virtual TUint32 ReadEntryL(TUint32 aIndex); + virtual void WriteEntryL(TUint32 aIndex, TUint32 aEntry); + + virtual TInt Invalidate(); + virtual TInt InvalidateRegion(TUint32 aStartEntry, TUint32 aNumEntries); + //------------------------------------ + + private: + + void InitialiseL(CFatMountCB* aOwner, TUint32 aFatSize); + + CFat12Cache(); + CFat12Cache(const CFat12Cache&); + CFat12Cache& operator=(const CFat12Cache&); + + + inline TUint32 NumSectors() const; + void AssertCacheReallyClean() const; + + private: + + enum {KMaxSectorsInCache = 32}; ///< maximal number sectors in FAT12 cache + enum {KFat12EntryMask = 0x0FFF}; ///< FAT12 entry mask + + TUint32 iSectorsInCache; ///< total number sectors in the cache, KMaxSectorsInCache max. + T32Bits iDirtySectors; ///< dirty sectors bitmap. '1' bit corresponds to the dirty sector; + RBuf8 iData; ///< Whole FAT12 cache data. +}; + + +//----------------------------------------------------------------------------- + +/** + Abstract base class for paged caches, i.e. those that consist of some number of cache pages. + In this case the most of the functionality is implemented in page classes and this is just a page container. + Each cache page in turn is logically divided to sectors. The sector is a logical unit of write granularity + See also CFatCachePageBase et al. +*/ +class CFatPagedCacheBase : public CFatCacheBase +{ + public: + + inline TUint PageSizeLog2() const; + inline TUint PageSize() const; + + inline TUint SectorSizeLog2() const; + inline TUint SectorsInPage() const; + + protected: + CFatPagedCacheBase(); + + protected: + + enum {KMaxSectorsInPage = 32}; ///< maximal number sectors in FAT cache page + + TUint iPageSizeLog2; ///< Log2(page size) + TUint iSectorSizeLog2; ///< Log2(page sector size) + +}; + +//----------------------------------------------------------------------------- + +class CFat16FixedCachePage; + +/** + FAT16 fixed paged cache. Used for FAT16 only and caches whole FAT16 (its max size is 131048 bytes). + Consists of the fixed array of cache pages; Pages are allocated on demand and never get evicted. + Each page is logically divided to page sectors. The number of pages depends on the FAT16 size. + + Read granularity: One page, which size is 2^aRdGranularityLog2 + Write granularity: cache's page sector; its size is 2^aWrGranularityLog2 +*/ +class CFat16FixedCache : public CFatPagedCacheBase +{ + public: + + static CFat16FixedCache* NewL(CFatMountCB* aOwner, TUint32 aFatSize, TUint32 aRdGranularityLog2, TUint32 aWrGranularityLog2); + + //-- overrides from base class + virtual void Close(TBool aDiscardDirtyData); + virtual void FlushL(); + + virtual TUint32 ReadEntryL(TUint32 aIndex); + virtual void WriteEntryL(TUint32 aIndex, TUint32 aEntry); + + + virtual TInt Invalidate(); + virtual TInt InvalidateRegion(TUint32 aStartEntry, TUint32 aNumEntries); + //------------------------------------ + + private: + + void InitialiseL(CFatMountCB* aOwner, TUint32 aFatSize, TUint32 aRdGranularityLog2, TUint32 aWrGranularityLog2); + + CFat16FixedCache(); + CFat16FixedCache(const CFat16FixedCache&); + CFat16FixedCache& operator=(const CFat16FixedCache&); + + inline TUint NumPages() const; + void AssertCacheReallyClean() const; + + private: + RPointerArray iPages; ///< array of pointer to the cahe pages; if the entry is NULL, it means that the page isn't allocated yet. + +}; + + +//----------------------------------------------------------------------------- + + +/** + An abstract base class for the cache page. Paged caches, i.e derived form CFatPagedCacheBase uses this functionality. + Provides an interface and common functionality for all types of cache pages. + + The FAT cache page contains a number of FAT16 or FAT32 entries, their number is always the power of 2. + The page is logically divided into sectors, the maximal number of sectors in the page is KMaxSectorsInPage (32). + The page read granularity is whole page and the write granularity is the sector (see aRdGranularityLog2, aWrGranularityLog2 from the cache) + + The caching is write-back, i.e WriteCachedEntryL() modifies data in the cache and marks corresponding page sector as dirty. + FlushL() shall be called to flust all dirty sectors in page to the media + +*/ +class CFatCachePageBase : public CBase +{ +public: + + ~CFatCachePageBase(); + + //---------------- + virtual TBool ReadCachedEntryL (TUint32 aFatIndex, TUint32& aResult) = 0; + virtual TBool WriteCachedEntryL(TUint32 aFatIndex, TUint32 aFatEntry) = 0; + virtual TUint32 ReadFromMediaL(TUint32 aFatIndex) = 0; + virtual void FlushL(TBool aKeepDirty); + + //---------------- + inline TBool IsEntryCached(TUint32 aFatIndex) const ; + void Invalidate(TBool aIgnoreDirtyData = EFalse); + + inline TBool IsDirty() const; + inline TBool IsValid() const; + + inline TUint32 StartFatIndex() const; + +protected: + CFatCachePageBase(CFatPagedCacheBase& aCache); + + /** possible states of the page */ + enum TState + { + EInvalid, ///< the page's data are invalid + EClean, ///< the page is clean, data valid and the same as on the media + EDirty ///< the page is dirty, there are data eventually to be flushed to the media, iDirtySectors contains dirty sectors bitmap. + }; + + inline void SetState(TState aState); + inline TState State() const; + inline void SetClean(); + inline TUint32 PageSize() const; + inline TUint32 NumSectors() const; + + virtual void DoWriteSectorL(TUint32 aSector)=0; + inline TUint32 EntriesInPage() const; + +protected: + TUint32 iStartIndexInFAT; ///< FAT index this page starts from + T32Bits iDirtySectors; ///< dirty sectors bitmap. '1' bit corresponds to the dirty sector; + CFatPagedCacheBase& iCache; ///< reference to the owher cache + RBuf8 iData; ///< page Data + +private: + TState iState; ///< page state + TUint32 iFatEntriesInPage; ///< number of FAT entries in the page. + +}; + + +//--------------------------------------------------------------------------------------------------------------------------------- + +/** + FAT16 cache page. Used only by CFat16FixedCache. +*/ +class CFat16FixedCachePage : public CFatCachePageBase +{ + public: + ~CFat16FixedCachePage() {} + + static CFat16FixedCachePage* NewL(CFatPagedCacheBase& aCache); + + //-- overrides + virtual TBool ReadCachedEntryL (TUint32 aFatIndex, TUint32& aResult); + virtual TBool WriteCachedEntryL(TUint32 aFatIndex, TUint32 aFatEntry); + virtual TUint32 ReadFromMediaL(TUint32 aFatIndex); + //---- + + private: + CFat16FixedCachePage(CFatPagedCacheBase& aCache); + + //-- outlaws here + CFat16FixedCachePage(); + CFat16FixedCachePage(const CFat16FixedCachePage&); + CFat16FixedCachePage& operator=(const CFat16FixedCachePage&); + + virtual void DoWriteSectorL(TUint32 aSector); + + inline TFat16Entry* GetEntryPtr(TUint32 aFatIndex) const; + + private: + enum {KFat16EntryMask = 0xFFFF}; ///< FAT16 entry mask +}; + + + +//--------------------------------------------------------------------------------------------------------------------------------- + + + +#include "sl_fatcache.inl" + + +#endif //SL_FAT_CACHE_H + + + + + + + + + + + + + + + + + + + + + + +