diff -r 000000000000 -r a41df078684a userlibandfileserver/fileserver/sfat32/inc/fat_table32.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/userlibandfileserver/fileserver/sfat32/inc/fat_table32.h Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,427 @@ +// 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\sfat32\inc\fat_table32.h +// FAT32 File Allocation Table classes definitions +// +// + +/** + @file + @internalTechnology +*/ + +#ifndef FAT_TABLE_32_H +#define FAT_TABLE_32_H + +//--------------------------------------------------------------------------------------------------------------------------------------- + +class CFatHelperThreadBase; +class CFat32ScanThread; + +TInt FAT32_ScanThread(TAny* apHostObject); + +//--------------------------------------------------------------------------------------------------------------------------------------- + +/** + Fat table abstraction for all media types except RAM. + Supports FAT12/16/32 +*/ +class CAtaFatTable : public CFatTable + { + +public: + + static CAtaFatTable* NewL(CFatMountCB& aOwner); + ~CAtaFatTable(); + + //-- overrides from th ebase class + TUint32 ReadL(TUint32 aFatIndex) const; + void WriteL(TUint32 aFatIndex, TUint32 aValue); + void MountL(const TMountParams& aMountParam); + + TInt64 DataPositionInBytes(TUint32 aCluster) const; + + void InitializeL(); + void Dismount(TBool aDiscardDirtyData); + void FlushL(); + + void InvalidateCacheL(); + void InvalidateCacheL(TInt64 aPos, TUint32 aLength); + + TUint32 FreeClusterHint() const; + TUint32 NumberOfFreeClusters(TBool aSyncOperation=EFalse) const; + + TBool ConsistentState() const; + + inline void AcquireLock() const {iDriveInteface.AcquireLock();} + inline void ReleaseLock() const {iDriveInteface.ReleaseLock();} + + inline TFatDriveInterface& DriveInterface() const; + inline CFatMountCB* OwnerMount() const; + + +private: + + /** internal states of this object */ + enum TState + { + ENotInitialised, ///< 0 initial invalid state + EInitialised, ///< 1 initialised, i.e. internal objects created, but unusable becasue number of free entries isn't known + EMounting, ///< 2 mounting started + EMounted, ///< 3 successfully mounted; number of free entries is known. This is the only consistent state. + EDismounted, ///< 4 FAT table object is dismounted + EFreeClustersScan, ///< 5 FAT32 scan thread is currently scanning FAT table for free clusters + EMountAborted ///< 6 Mounting failed, probably because of FAT32 free clusters scan thread failure. + }; + +public: + + /** A helper class used in FAT scanning for free clusters*/ + class TFatScanParam + { + public: + inline TFatScanParam(); + + public: + TUint32 iEntriesScanned; ///< total number of FAT entries scanned by DoParseFatBuf() + TUint32 iFirstFree; ///< first free FAT entry found + TUint32 iCurrFreeEntries; ///< current number of free FAT entries found by DoParseFatBuf() + TUint32 iCurrOccupiedEntries; ///< current number of non-free FAT entries found by DoParseFatBuf() + }; + + +private: + CAtaFatTable(CFatMountCB& aOwner); + + void RequestRawWriteAccess(TInt64 aPos, TUint32 aLen) const; + + void SetFreeClusters(TUint32 aFreeClusters); + void SetFreeClusterHint(TUint32 aCluster); + void CountFreeClustersL(); + void CreateCacheL(); + + virtual void DecrementFreeClusterCount(TUint32 aCount); + virtual void IncrementFreeClusterCount(TUint32 aCount); + virtual TUint32 FindClosestFreeClusterL(TUint32 aCluster); + + void DoCountFreeClustersL(); + void DoParseFatBuf(const TPtrC8& aBuf, TFatScanParam& aScanParam) const; + + TBool RequestFreeClusters(TUint32 aClustersRequired) const; + void DoLaunchFat32FreeSpaceScanThreadL(); + void DestroyHelperThread(); + + inline TState State() const; + inline void SetState(TState aState); + +private: + + + CFatCacheBase* iCache; ///< FAT cache, fixed or LRU depending on the FAT type + TFatDriveInterface& iDriveInteface; ///< reference to the drive interface + CFatHelperThreadBase* ipHelperThread; ///< helper thread object pointer. NULL if it is not present + TState iState; ///< state of this object + + //-- friends + friend TInt FAT32_ScanThread(TAny* apHostObject); + friend class CFat32ScanThread; + friend class CFat32FreeSpaceScanner; + friend class CFat32BitCachePopulator; + }; + +//--------------------------------------------------------------------------------------------------------------------------------------- + +/** + Fat table abstraction for RAM media type. + Supports FAT16/32 only +*/ +class CRamFatTable : public CFatTable + { +public: + + static CRamFatTable* NewL(CFatMountCB& aOwner); + void InitializeL(); + void MountL(const TMountParams& aMountParam); + + + TUint32 ReadL(TUint32 aFatIndex) const; + void WriteL(TUint32 aFatIndex, TUint32 aValue); + TInt64 DataPositionInBytes(TUint32 aCluster) const; + void FreeClusterListL(TUint32 aCluster); + TUint32 AllocateSingleClusterL(TUint32 aNearestCluster); + void ExtendClusterListL(TUint32 aNumber,TInt& aCluster); + +private: + CRamFatTable(CFatMountCB& aOwner); + + inline TUint8 *RamDiskBase() const; + inline TInt AllocateClusterNumber(); + inline void WriteFatTable(TInt aFatIndex,TInt aValue); + inline void WriteFatTable(TInt aFatIndex,TInt aFatValue,TInt anIndirectionTableValue); + inline void ReadIndirectionTable(TUint32& aCluster) const; + inline void WriteIndirectionTable(TInt aFatIndex,TInt aValue); + inline TUint8* MemCopy(TAny* aTrg,const TAny* aSrc,TInt aLength); + inline TUint8* MemCopyFillZ(TAny* aTrg, TAny* aSrc, TInt aLength); + inline void ZeroFillCluster(TInt aCluster); + + void UpdateIndirectionTable(TUint32 aStartCluster,TUint32 anEndCluster,TInt aNum); + +protected: + + TInt iFatTablePos; ///< Current position in the fat table + TInt iIndirectionTablePos; ///< Current position in indirection table, second fat used for this + TUint8* iRamDiskBase; ///< Pointer to the Ram disk base + }; + + + +//--------------------------------------------------------------------------------------------------------------------------------------- + +/** + Abstract base class for the FAT32 helper threads. + Provides basic functionality of the helper threads and interface to the owher CAtaFatTable. +*/ +class CFatHelperThreadBase : public CBase +{ + public: + + /** Possible types of the FAT32 helper threads */ + enum TFatHelperThreadType + { + EInvalidType, ///< invalid type + EFreeSpaceScanner, ///< Free FAT32 entries counter, see CFat32FreeSpaceScanner + EBitCachePopulator ///< FAT32 bit supercache populating thread. + }; + + /** this object states, mostly related to the worker thread activity and results */ + enum TState + { + EInvalid, ///< invalid initial state + ENotStarted, ///< the worker thread hasn't started yet + EWorking, ///< worker thread is working + EFinished_OK, ///< worker thread has successfully finished, everything is fine. + EFailed ///< worker thread failed to finish its job for some reason; see the thread completion status + }; + + public: + ~CFatHelperThreadBase(); + + //-- virtual interface + virtual TFatHelperThreadType Type() const = 0; + virtual TInt Launch()=0; + virtual void RequestFatEntryWriteAccess(TUint32 aFatIndex) const=0; + + //-- non-virtual interface for external user only + void Close(); + void ForceStop(); + + inline TState State() const; + + inline void Suspend() const; + inline void Resume() const; + + inline TInt ThreadCompletionCode() const; + inline TBool ThreadWorking() const; + + inline void BoostPriority(TBool aBoost) const; + inline TBool IsPriorityBoosted() const; + + inline TThreadId ThreadId() const; + + TInt WaitToFinish() const; + + protected: + CFatHelperThreadBase(CAtaFatTable& aOwner); + + //-- outlaws + CFatHelperThreadBase(); + CFatHelperThreadBase(const CFatHelperThreadBase&); + CFatHelperThreadBase& operator=(const CFatHelperThreadBase&); + + /** the worker thread priorities values */ + enum + { + EHelperPriorityNormal = EPriorityMuchLess, ///< FAT32 Helper thread normal priority (assigned on start) + EHelperPriorityBoosted = EPriorityNormal ///< FAT32 Helper thread bosted priority + }; + + TInt DoLaunchThread(TThreadFunction aFunction, TAny* aThreadParameter); + + inline void SetState(TState aState); + inline TBool AllowedToLive() const; + inline void AllowToLive(TBool aAllow); + + protected: + CAtaFatTable& iOwner; ///< owner, CAtaFatTable + + private: + TState iState; ///< internal state of this object + RThread iThread; ///< FAT helper thread handle + mutable TRequestStatus iThreadStatus; ///< helper thread logon status + + TBool iAllowedToLive : 1; ///< if EFalse the worker thread must gracefully finish ASAP. + mutable TBool iPriorityBoosted : 1; ///< ETrue when thread priority is boosted by BoostPriority() call + + +}; + +//--------------------------------------------------------------------------------------------------------------------------------------- +/** + Abstract base class for the FAT32 helper threads that read FAT by big chunks of data and parse it. + Provides basic functionality of the helper threads and interface to the owher CAtaFatTable. +*/ +class CFat32ScanThread : public CFatHelperThreadBase +{ + public: + + virtual TInt Launch(); + + protected: + CFat32ScanThread(CAtaFatTable& aOwner); + + //-- virtual private interface for the thread function. + virtual TInt Thread_Preamble(); + virtual TInt Thread_Postamble(TInt aResult); + virtual TInt Thread_ProcessCollectedFreeEntries(const CAtaFatTable::TFatScanParam& aFatScanParam)=0; + + friend TInt FAT32_ScanThread(TAny* apHostObject); ///< FAT32 scanner thread function, generic functionality for derived classes + + protected: + + RBuf8 iFatChunkBuf; ///< a buffer for reading FAT directly from the media + + TTime iTimeStart; ///< thread start time, used to measure how long thread worked + TTime iTimeEnd; ///< thread end time, used to measure how long thread worked + + CFatBitCache *ipFatBitCache; ///< interface to the FAT bit supercache (if it is present) +}; + + +//--------------------------------------------------------------------------------------------------------------------------------------- +/** + FAT32 free FAT entries scanner thread. + Represents transient FAT32 helper thread that can be launched on FAT table object mounting stage and will be + counting free FAT entries in order to find out free space on the volume. +*/ +class CFat32FreeSpaceScanner : public CFat32ScanThread +{ + public: + + static CFat32FreeSpaceScanner* NewL(CAtaFatTable& aOwner); + + virtual inline TFatHelperThreadType Type() const; + + private: + CFat32FreeSpaceScanner(CAtaFatTable& aOwner); + + void RequestFatEntryWriteAccess(TUint32 aFatIndex) const; + + //-- virtual private interface for the thread function. + TInt Thread_Preamble(); + TInt Thread_Postamble(TInt aResult); + TInt Thread_ProcessCollectedFreeEntries(const CAtaFatTable::TFatScanParam& aFatScanParam); + //-- + + private: + + void SetClustersScanned(TUint32 aClusters); + TUint32 ClustersScanned() const; + + friend TInt FAT32_ScanThread(TAny* apHostObject); ///< FAT32 scanner thread function, generic functionality for CFat32ScanThread derived classes + + private: + + enum + { + KFatChunkBufSize_Small = 16*K1KiloByte, //-- buffer size for reading small FAT tables + KFatChunkBufSize_Big = 64*K1KiloByte, //-- buffer size for reading large FAT tables + + KBigSzFat_Threshold = 2*K1MegaByte, //-- if FAT table size > this value, larger FAT read chunk (KFatChunkBufSize_Big) will be used + }; + + TUint32 iClustersScanned; ///< Number of FAT entries already scanned by the thread. Counts from the beginning of the FAT + + //-- volume space treshold in bytes that causes CMountCB::SetDiskSpaceChange() to be called by FAT32 free space scanner thread. + //-- This thread will be calling CMountCB::SetDiskSpaceChange() after processing number of FAT32 entries corresponding to + //-- this amount of space in FAT clusters. e.g. after processing amount of FAT32 entries comprising 256MB volume space + enum {KVolSpaceNotifyThreshold = 256 * K1MegaByte}; + + TUint32 iEntriesNotifyThreshold; ///< the value of FAT32 entries need to be counted for CMountCB::SetDiskSpaceChange() call + TUint32 iNfyThresholdInc; ///< Threshold increment in FAT32 entries. + + +}; + +//--------------------------------------------------------------------------------------------------------------------------------------- +/** + FAT32 Bit supercache populating thread. + Represents transient FAT32 helper thread that is populating bit supercache in backgroud. +*/ +class CFat32BitCachePopulator : public CFat32ScanThread +{ + public: + + static CFat32BitCachePopulator* NewL(CAtaFatTable& aOwner); + + virtual inline TFatHelperThreadType Type() const; + + private: + CFat32BitCachePopulator(CAtaFatTable& aOwner); + + void RequestFatEntryWriteAccess(TUint32 aFatIndex) const; + + //-- virtual private interface for the thread function. + TInt Thread_Preamble(); + TInt Thread_Postamble(TInt aResult); + TInt Thread_ProcessCollectedFreeEntries(const CAtaFatTable::TFatScanParam& aFatScanParam); + //-- + + private: + friend TInt FAT32_ScanThread(TAny* apHostObject); ///< FAT32 scanner thread function, generic functionality for CFat32ScanThread derived classes + enum {KFatChunkBufSize = 16*K1KiloByte}; //-- buffer size for FAT reading + + private: + TUint32 iTotalOccupiedFatEntries; ///< total counted number of non-free FAT entries + +}; + + +//--------------------------------------------------------------------------------------------------------------------------------------- + +#include "fat_table32.inl" + +#endif //FAT_TABLE_32_H + + + + + + + + + + + + + + + + + + + + + + +