diff -r 000000000000 -r a41df078684a userlibandfileserver/fileserver/sfat/fat_table.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/userlibandfileserver/fileserver/sfat/fat_table.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,1044 @@
+// 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\sfat\fat_table.cpp
+// FAT12/16 File Allocation Table classes implementation
+// 
+//
+
+/**
+ @file
+ @internalTechnology
+*/
+
+
+
+#include "sl_std.h"
+#include "sl_fatcache.h"
+#include "fat_table.h"
+
+
+//#######################################################################################################################################
+//#     CFatTable class implementation 
+//#######################################################################################################################################
+
+/**
+    FAT object factory method.
+    Constructs either CAtaFatTable or CRamFatTable depending on the media type parameter
+
+    @param aOwner Pointer to the owning mount
+    @param aLocDrvCaps local drive attributes
+    @leave KErrNoMemory
+    @return Pointer to the Fat table
+*/
+CFatTable* CFatTable::NewL(CFatMountCB& aOwner, const TLocalDriveCaps& aLocDrvCaps)
+	{
+    CFatTable* pFatTable=NULL;
+
+    
+    switch(aLocDrvCaps.iType)
+        {
+        case EMediaRam:
+		    {//-- this is RAM media, try to create CRamFatTable instance.
+            const TFatType fatType = aOwner.FatType();
+            
+            if(fatType != EFat16 )
+                {//-- CRamFatTable doesn't support FAT12; FAT16 only.
+                __PRINT1(_L("CFatTable::NewL() CRamFatTable doesn't support this FAT type:%d"), fatType);
+                ASSERT(0);
+                return NULL;
+                }
+            
+                pFatTable = CRamFatTable::NewL(aOwner);            
+            }
+        break;
+
+        default:
+            //-- other media
+		    pFatTable = CAtaFatTable::NewL(aOwner);
+        break;
+        };
+
+	return pFatTable;
+	}
+
+CFatTable::CFatTable(CFatMountCB& aOwner)
+{
+    iOwner = &aOwner;
+    ASSERT(iOwner);
+}
+
+CFatTable::~CFatTable()
+{
+    //-- destroy cache ignoring dirty data in cache
+    //-- the destructor isn't an appropriate place to flush the data.
+    Dismount(ETrue); 
+}
+
+//-----------------------------------------------------------------------------
+
+/**
+    Initialise the object, get data from the owning CFatMountCB
+*/
+void CFatTable::InitializeL()
+	{
+	ASSERT(iOwner);
+
+    //-- get FAT type from the owner
+    iFatType = iOwner->FatType();
+    ASSERT(IsFat12() || IsFat16());
+
+    iFreeClusterHint = KFatFirstSearchCluster;
+
+    //-- cache the media attributes
+	TLocalDriveCapsV2 caps;
+	TPckg<TLocalDriveCapsV2> capsPckg(caps);
+    User::LeaveIfError(iOwner->LocalDrive()->Caps(capsPckg));
+	iMediaAtt = caps.iMediaAtt;
+	
+    //-- obtain maximal number of entries in the table
+    iMaxEntries = iOwner->UsableClusters()+KFatFirstSearchCluster; //-- FAT[0] & FAT[1] are not in use
+
+    __PRINT3(_L("CFatTable::InitializeL(), drv:%d, iMediaAtt = %08X, max Entries:%d"), iOwner->DriveNumber(), iMediaAtt, iMaxEntries);
+	}
+
+//-----------------------------------------------------------------------------
+
+/** 
+    Decrements the free cluster count.
+    Note that can be quite expensive operation (especially for overrides with synchronisation), if it is called for every 
+    cluster of a large file. Use more than one cluster granularity.
+     
+    @param  aCount a number of clusters 
+*/
+void CFatTable::DecrementFreeClusterCount(TUint32 aCount)
+{
+    __ASSERT_DEBUG(iFreeClusters >= aCount, Fault(EFatCorrupt));
+    iFreeClusters -= aCount;
+}
+
+/** 
+    Increments the free cluster count.
+    Note that can be quite expensive operation (especially for overrides with synchronisation), if it is called for every 
+    cluster of a large file. Use more than one cluster granularity.
+
+    @param  aCount a number of clusters 
+*/
+void CFatTable::IncrementFreeClusterCount(TUint32 aCount)
+{
+	const TUint32 newVal = iFreeClusters+aCount;
+    __ASSERT_DEBUG(newVal<=MaxEntries(), Fault(EFatCorrupt));
+    
+    iFreeClusters = newVal;
+}
+
+/** @return number of free clusters in the FAT */
+TUint32 CFatTable::NumberOfFreeClusters(TBool /*aSyncOperation=EFalse*/) const
+{
+    return FreeClusters();
+}
+
+void CFatTable::SetFreeClusters(TUint32 aFreeClusters)
+{   
+    iFreeClusters=aFreeClusters;
+}
+
+/**
+    Get the hint about the last known free cluster number.
+    Note that can be quite expensive operation (especially for overrides with synchronisation), if it is called for every 
+    cluster of a large file.
+
+    @return cluster number supposedly close to the free one.
+*/
+TUint32 CFatTable::FreeClusterHint() const 
+{
+    ASSERT(ClusterNumberValid(iFreeClusterHint));
+    return iFreeClusterHint;
+} 
+
+/**
+    Set a free cluster hint. The next search fro the free cluster can start from this value.
+    aCluster doesn't have to be a precise number of free FAT entry; it just needs to be as close as possible to the 
+    free entries chain.
+    Note that can be quite expensive operation (especially for overrides with synchronisation), if it is called for every 
+    cluster of a large file.
+
+    @param aCluster cluster number hint.
+*/
+void CFatTable::SetFreeClusterHint(TUint32 aCluster) 
+{
+    ASSERT(ClusterNumberValid(aCluster));
+    iFreeClusterHint=aCluster;
+} 
+
+//-----------------------------------------------------------------------------
+
+/**
+    Find out the number of free clusters on the volume.
+    Reads whole FAT and counts free clusters.
+*/
+void CFatTable::CountFreeClustersL()
+{
+    __PRINT1(_L("#- CFatTable::CountFreeClustersL(), drv:%d"), iOwner->DriveNumber());
+
+    const TUint32 KUsableClusters = iOwner->UsableClusters();
+    (void)KUsableClusters;
+    
+    TUint32 freeClusters = 0;
+    TUint32 firstFreeCluster = 0;
+
+    TTime   timeStart;
+    TTime   timeEnd;
+    timeStart.UniversalTime(); //-- take start time
+
+    //-- walk through whole FAT table looking for free clusters
+	for(TUint i=KFatFirstSearchCluster; i<MaxEntries(); ++i)
+    {
+	    if(ReadL(i) == KSpareCluster)
+        {//-- found a free cluster
+		    ++freeClusters;
+            
+            if(!firstFreeCluster)
+                firstFreeCluster = i;
+        }
+	}
+
+    timeEnd.UniversalTime(); //-- take end time
+    const TInt msScanTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);
+    __PRINT1(_L("#- CFatTable::CountFreeClustersL() finished. Taken:%d ms"), msScanTime);
+    (void)msScanTime;
+
+    if(!firstFreeCluster) //-- haven't found free clusters on the volume
+        firstFreeCluster = KFatFirstSearchCluster;
+
+    ASSERT(freeClusters <= KUsableClusters);
+
+    SetFreeClusters(freeClusters);
+    SetFreeClusterHint(firstFreeCluster);
+}
+
+//-----------------------------------------------------------------------------
+
+/**
+Count the number of contiguous cluster from a start cluster
+
+@param aStartCluster cluster to start counting from
+@param anEndCluster contains the end cluster number upon return
+@param aMaxCount Maximum cluster required
+@leave System wide error values
+@return Number of contiguous clusters from aStartCluster.
+*/
+TInt CFatTable::CountContiguousClustersL(TUint32 aStartCluster,TInt& anEndCluster,TUint32 aMaxCount) const
+	{
+	__PRINT2(_L("CFatTable::CountContiguousClustersL() start:%d, max:%d"),aStartCluster, aMaxCount);
+	TUint32 clusterListLen=1;
+	TInt endCluster=aStartCluster;
+	TInt64 endClusterPos=DataPositionInBytes(endCluster);
+	while (clusterListLen<aMaxCount)
+		{
+		TInt oldCluster=endCluster;
+		TInt64 oldClusterPos=endClusterPos;
+		if (GetNextClusterL(endCluster)==EFalse || (endClusterPos=DataPositionInBytes(endCluster))!=(oldClusterPos+(1<<iOwner->ClusterSizeLog2())))
+			{
+			endCluster=oldCluster;
+			break;
+			}
+		clusterListLen++;
+		}
+	anEndCluster=endCluster;
+	return(clusterListLen);
+	}	
+
+//-----------------------------------------------------------------------------
+
+/**
+    Extend a file or directory cluster chain, leaves if there are no free clusters (the disk is full).
+
+    @param aNumber  amount of clusters to allocate
+    @param aCluster FAT entry index to start with.
+
+    @leave KErrDiskFull + system wide error codes
+*/
+void CFatTable::ExtendClusterListL(TUint32 aNumber,TInt& aCluster)
+	{
+	__PRINT2(_L("CFatTable::ExtendClusterListL() num:%d, clust:%d"), aNumber, aCluster);
+	__ASSERT_DEBUG(aNumber>0,Fault(EFatBadParameter));
+	
+	while(aNumber && GetNextClusterL(aCluster))
+		aNumber--;
+
+    if(!aNumber)
+        return;
+
+	if (iFreeClusters<aNumber)
+		{
+		__PRINT(_L("CFatTable::ExtendClusterListL - leaving KErrDirFull"));
+		User::Leave(KErrDiskFull);
+		}
+
+
+    TUint32 freeCluster = 0;
+    
+    //-- note: this can be impoved by trying to fing as long chain of free clusters as possible in FindClosestFreeClusterL()
+    for(TUint i=0; i<aNumber; ++i)
+		{
+        freeCluster = FindClosestFreeClusterL(aCluster);
+		WriteFatEntryEofL(freeCluster); //	Must write EOF for FindClosestFreeCluster to work again
+		WriteL(aCluster,freeCluster);
+		aCluster=freeCluster;
+		}
+    
+    //-- decrement number of available clusters
+    DecrementFreeClusterCount(aNumber);
+
+    //-- update free cluster hint, it isn't required to be a precise value, just a hint where to start the from from
+    SetFreeClusterHint(aCluster); 
+    
+	}
+
+//-----------------------------------------------------------------------------
+
+/**
+Allocate and mark as EOF a single cluster as close as possible to aNearestCluster
+
+@param aNearestCluster Cluster the new cluster should be nearest to
+@leave System wide error codes
+@return The cluster number allocated
+*/
+TUint32 CFatTable::AllocateSingleClusterL(TUint32 aNearestCluster)
+	{
+	__PRINT1(_L("CFatTable::AllocateSingleCluster() nearest:%d"), aNearestCluster);
+	if (iFreeClusters==0)
+		User::Leave(KErrDiskFull);
+	const TInt freeCluster=FindClosestFreeClusterL(aNearestCluster);
+	WriteFatEntryEofL(freeCluster);
+	DecrementFreeClusterCount(1);
+
+    //-- update free cluster hint, it isn't required to be a precise value, just a hint where to start the from from.
+    SetFreeClusterHint(freeCluster); 
+
+	return(freeCluster);
+	}	
+
+//-----------------------------------------------------------------------------
+
+/**
+Allocate and link a cluster chain, leaves if there are not enough free clusters.
+Chain starts as close as possible to aNearestCluster, last cluster will be marked as EOF.
+
+@param aNumber Number of clusters to allocate
+@param aNearestCluster Cluster the new chain should be nearest to
+@leave System wide error codes
+@return The first cluster number allocated
+*/
+TUint32 CFatTable::AllocateClusterListL(TUint32 aNumber, TUint32 aNearestCluster)
+	{
+    __PRINT2(_L("#>> CFatTable::AllocateClusterList() N:%d,NearestCL:%d"),aNumber,aNearestCluster);
+	__ASSERT_DEBUG(aNumber>0,Fault(EFatBadParameter));
+
+	if (iFreeClusters<aNumber)
+		{
+		__PRINT(_L("CFatTable::AllocateClusterListL - leaving KErrDirFull"));
+		User::Leave(KErrDiskFull);
+		}
+
+    TInt firstCluster = aNearestCluster = AllocateSingleClusterL(aNearestCluster);
+	if (aNumber>1)
+		ExtendClusterListL(aNumber-1, (TInt&)aNearestCluster);
+
+	return(firstCluster);
+	}	
+
+//-----------------------------------------------------------------------------
+
+/**
+    Notify the media drive about media areas that shall be treated as "deleted" if this feature is supported.
+    @param aFreedClusters array with FAT numbers of clusters that shall be marked as "deleted"
+*/
+void CFatTable::DoFreedClustersNotify(RClusterArray &aFreedClusters)
+{
+    ASSERT(iMediaAtt & KMediaAttDeleteNotify);
+
+    const TUint clusterCount = aFreedClusters.Count();
+
+    if(!clusterCount)
+        return;
+    
+    FlushL(); //-- Commit the FAT changes to disk first to be safe
+
+    const TUint bytesPerCluster = 1 << iOwner->ClusterSizeLog2();
+
+    TInt64  byteAddress = 0;	
+	TUint   deleteLen = 0;	// zero indicates no clusters accumulated yet
+
+	for (TUint i=0; i<clusterCount; ++i)
+	{
+        const TUint currCluster = aFreedClusters[i];
+        
+        if (deleteLen == 0)
+		    byteAddress = DataPositionInBytes(currCluster); //-- start of the media range
+        
+        deleteLen += bytesPerCluster;
+
+        //-- if this is the last entry in the array or the net cluster number is not consecutive, notify the driver
+		if ((i+1) == clusterCount || aFreedClusters[i+1] != (currCluster+1))
+        {
+            //__PRINT3(_L("DeleteNotify(%08X:%08X, %u), first cluster %u last cluster #%u"), I64HIGH(byteAddress), I64LOW(byteAddress), deleteLen);
+			//__PRINT2(_L("   first cluster %u last cluster #%u"), I64LOW((byteAddress - iOwner->ClusterBasePosition()) >> iOwner->ClusterSizeLog2()) + 2, cluster);
+            const TInt r = iOwner->LocalDrive()->DeleteNotify(byteAddress, deleteLen);
+			if(r != KErrNone)
+                {//-- if DeleteNotify() failed, it means that something terribly wrong happened to the NAND media; 
+                 //-- in normal circumstances it can not happen. One of the reasons: totally worn out media.
+                const TBool platSecEnabled = PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement);
+                __PRINT3(_L("CFatTable::DoFreedClustersNotify() DeleteNotify failure! drv:%d err:%d, PlatSec:%d"),iOwner->DriveNumber(), r, platSecEnabled);
+
+                if(platSecEnabled)
+                    {
+                    //-- if PlatSec is enabled, we can't afford jeopardize the security; without DeleteNotify()
+                    //-- it's possible to pick up data from deleted files, so, panic the file server.
+                    Fault(EFatBadLocalDrive);
+                    }
+                else
+                    {
+                    //-- if PlatSec is disabled, it's OK to ignore the NAND fault in release mode.
+                    __ASSERT_DEBUG(0, Fault(EFatBadLocalDrive));
+                    }        
+                }
+			
+            
+            deleteLen = 0;
+        }
+
+    }
+
+    //-- empty the array.
+    aFreedClusters.Reset();
+}
+
+//-----------------------------------------------------------------------------
+/**
+Mark a chain of clusters as free in the FAT. 
+
+@param aCluster Start cluster of cluster chain to free
+@leave System wide error codes
+*/
+void CFatTable::FreeClusterListL(TUint32 aCluster)
+	{
+	__PRINT1(_L("CFatTable::FreeClusterListL startCluster=%d"),aCluster);
+	if (aCluster == KSpareCluster)
+		return; 
+
+	//-- here we can store array of freed cluster numbers in order to 
+    //-- notify media drive about the media addresses marked as "invalid"
+    RClusterArray deletedClusters;      
+	CleanupClosePushL(deletedClusters);
+
+    //-- if ETrue, we need to notify media driver about invalidated media addressses
+    const TBool bFreeClustersNotify = iMediaAtt & KMediaAttDeleteNotify;
+
+    //-- this is a maximal number of FAT entries in the deletedClusters array.
+    //-- as soon as we collect this number of entries in the array, FAT cache will be flushed
+    //-- and driver notified. The array will be emptied. Used to avoid huge array when deleting
+    //--  large files on NAND media 
+    const TUint KSubListLen = 4096;
+    ASSERT(IsPowerOf2(KSubListLen));
+
+    TUint32 lastKnownFreeCluster = FreeClusterHint();
+    TUint32 cntFreedClusters = 0;
+
+    TUint32 currCluster = aCluster;
+    TInt    nextCluster = aCluster;
+
+    for(;;)
+		{
+        const TBool bEOF = !GetNextClusterL(nextCluster);    
+        WriteL(currCluster, KSpareCluster);
+
+        lastKnownFreeCluster = Min(currCluster, lastKnownFreeCluster);
+
+		// Keep a record of the deleted clusters so that we can subsequently notify the media driver. This is only safe 
+		// to do once the FAT changes have been written to disk.
+        if(bFreeClustersNotify)
+            deletedClusters.Append(currCluster);
+
+        ++cntFreedClusters;
+        currCluster = nextCluster;
+
+		if (bEOF || aCluster == KSpareCluster)
+			break;
+
+        if(bFreeClustersNotify && cntFreedClusters && (cntFreedClusters & (KSubListLen-1))==0)
+        {//-- reached a limit of the entries in the array. Flush FAT cache, notify the driver and empty the array.
+            IncrementFreeClusterCount(cntFreedClusters);
+            cntFreedClusters = 0;
+
+            SetFreeClusterHint(lastKnownFreeCluster);
+            DoFreedClustersNotify(deletedClusters);
+        }
+
+    }
+
+    //-- increase the number of free clusters and notify the driver if required.
+    IncrementFreeClusterCount(cntFreedClusters);
+    SetFreeClusterHint(lastKnownFreeCluster);
+    
+    if(bFreeClustersNotify)
+    DoFreedClustersNotify(deletedClusters);
+
+	CleanupStack::PopAndDestroy(&deletedClusters);
+	}
+
+//-----------------------------------------------------------------------------
+
+/**
+Find a free cluster nearest to aCluster, Always checks to the right of aCluster first 
+but checks in both directions in the Fat.
+
+@param aCluster Cluster to find nearest free cluster to.
+@leave KErrDiskFull + system wide error codes
+@return cluster number found
+*/
+TUint32 CFatTable::FindClosestFreeClusterL(TUint32 aCluster)
+	{
+    __PRINT2(_L("CFatTable::FindClosestFreeClusterL() drv:%d cl:%d"),iOwner->DriveNumber(),aCluster);
+
+    if(!ClusterNumberValid(aCluster))
+        {
+        ASSERT(0);
+        User::Leave(KErrCorrupt);
+        }
+
+
+    if(iFreeClusters==0)
+	    {//-- there is no at least 1 free cluster available
+    	__PRINT(_L("CFatTable::FindClosestFreeClusterL() leaving KErrDiskFull #1"));
+		User::Leave(KErrDiskFull);
+        }
+	
+    //-- 1. look if the given index contains a free entry 
+    if(ReadL(aCluster) != KSpareCluster)
+        {//-- no, it doesn't...
+        
+        //-- 2. look in both directions starting from the aCluster, looking in the right direction first
+        
+        const TUint32 maxEntries = MaxEntries();
+        const TUint32 MinIdx = KFatFirstSearchCluster;
+        const TUint32 MaxIdx = maxEntries-1; 
+
+        TBool canGoRight = ETrue;
+        TBool canGoLeft = ETrue;
+    
+        TUint32 rightIdx = aCluster;
+        TUint32 leftIdx  = aCluster;
+        
+        for(TUint i=0; i<maxEntries; ++i)
+            {
+            if(canGoRight)
+                {
+                if(rightIdx < MaxIdx)
+                    ++rightIdx;
+                else
+                    canGoRight = EFalse;
+                }
+
+            if(canGoLeft)
+                {
+                if(leftIdx > MinIdx)
+                    --leftIdx;
+                else        
+                    canGoLeft = EFalse;
+                }
+
+        if(!canGoRight && !canGoLeft)
+	        {
+    	    __PRINT(_L("CFatTable::FindClosestFreeClusterL() leaving KErrDiskFull #2"));
+            User::Leave(KErrDiskFull);
+            }
+
+        if (canGoRight && ReadL(rightIdx) == KSpareCluster)
+			{
+			aCluster = rightIdx;
+			break;
+			}
+
+		if (canGoLeft && ReadL(leftIdx) == KSpareCluster)
+			{
+			aCluster = leftIdx;
+			break;
+			}
+            }//for(..)
+
+        }//if(ReadL(aCluster) != KSpareCluster)
+
+
+    //-- note: do not update free cluster hint here by calling SetFreeClusterHint(). This is going to be 
+    //-- expensive especially if overridden methods with synchronisation are called. Instead, set the number of 
+    //-- the last known free cluster in the caller of this internal method.
+
+//    __PRINT1(_L("CFatTable::FindClosestFreeClusterL found:%d"),aCluster);
+
+    return aCluster;
+	}
+
+//-----------------------------------------------------------------------------
+
+/**
+    Converts a cluster number to byte offset in the FAT
+
+@param aFatIndex Cluster number
+    @return Number of bytes from the beginning of the FAT
+*/
+TUint32 CFatTable::PosInBytes(TUint32 aFatIndex) const
+	{
+    switch(FatType())
+        {
+        case EFat12:
+            return (((aFatIndex>>1)<<1) + (aFatIndex>>1)); //-- 1.5 bytes per FAT entry
+
+        case EFat16:
+            return aFatIndex<<1; //-- 2 bytes per FAT entry
+
+        default:
+            ASSERT(0);
+            return 0;//-- get rid of warning
+        };
+
+	}
+
+//-----------------------------------------------------------------------------
+
+/**
+    Checks if we have at least aClustersRequired clusters free in the FAT.
+    This is, actually a dummy implementation.
+
+    @param  aClustersRequired number of free clusters required
+    @return ETrue if there is at least aClustersRequired free clusters available, EFalse otherwise.
+*/
+TBool CFatTable::RequestFreeClusters(TUint32 aClustersRequired) const
+{
+    //ASSERT(aClustersRequired >0 && aClustersRequired <= iOwner->UsableClusters());
+    ASSERT(aClustersRequired >0);
+    return (NumberOfFreeClusters() >= aClustersRequired);
+}
+
+//-----------------------------------------------------------------------------
+/**
+    @return ETrue if the cluster number aClusterNo is valid, i.e. belongs to the FAT table
+*/
+TBool CFatTable::ClusterNumberValid(TUint32 aClusterNo) const 
+    {
+    return (aClusterNo >= KFatFirstSearchCluster) && (aClusterNo < iMaxEntries); 
+    }
+
+
+
+//#######################################################################################################################################
+//#     CAtaFatTable class implementation 
+//#######################################################################################################################################
+
+/**
+Constructor
+*/
+CAtaFatTable::CAtaFatTable(CFatMountCB& aOwner)
+             :CFatTable(aOwner)
+	{
+	}
+
+
+/** factory method */
+CAtaFatTable* CAtaFatTable::NewL(CFatMountCB& aOwner)
+{
+    __PRINT1(_L("CAtaFatTable::NewL() drv:%d"),aOwner.DriveNumber());
+    CAtaFatTable* pSelf = new (ELeave) CAtaFatTable(aOwner);
+
+    CleanupStack::PushL(pSelf);
+    pSelf->InitializeL();
+    CleanupStack::Pop();
+
+    return pSelf;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------------------------------
+
+/**
+    CAtaFatTable's FAT cache factory method.
+    Creates fixed cache for FAT12 or FAT16
+*/
+void CAtaFatTable::CreateCacheL()
+{
+    ASSERT(iOwner);
+    const TUint32 fatSize=iOwner->FatSizeInBytes();
+    __PRINT3(_L("CAtaFatTable::CreateCacheL drv:%d, FAT:%d, FAT Size:%d"), iOwner->DriveNumber(), FatType(), fatSize);
+	
+
+    //-- according to FAT specs:
+    //-- FAT12 max size is 4084 entries or 6126 bytes                                               => create fixed cache for whole FAT
+    //-- FAT16 min size is 4085 entries or 8170 bytes, max size is 65525 entries or 131048 bytes    => create fixed cache for whole FAT
+
+    ASSERT(!iCache);
+
+    //-- this is used for chaches granularity sanity check 
+    const TUint32 KMaxGranularityLog2 = 18; //-- 256K is a maximal allowed granularity
+    const TUint32 KMinGranularityLog2 = KDefSectorSzLog2;  //-- 512 bytes is a minimal allowed granularity
+
+    switch(FatType())
+    {
+        case EFat12: //-- create fixed FAT12 cache
+            iCache = CFat12Cache::NewL(iOwner, fatSize); 
+        break;
+    
+        case EFat16: //-- create fixed FAT16 cache
+        {
+            TUint32 fat16_ReadGranularity_Log2; //-- FAT16 cache read granularity Log2
+            TUint32 fat16_WriteGranularity_Log2;//-- FAT16 cache write granularity Log2
+            
+            iOwner->FatConfig().Fat16FixedCacheParams(fat16_ReadGranularity_Log2, fat16_WriteGranularity_Log2);
+            
+            //-- check if granularity values look sensible
+            const TBool bParamsValid = fat16_ReadGranularity_Log2  >= KMinGranularityLog2 && fat16_ReadGranularity_Log2  <= KMaxGranularityLog2 &&
+                                       fat16_WriteGranularity_Log2 >= KMinGranularityLog2 && fat16_WriteGranularity_Log2 <= KMaxGranularityLog2;
+            
+            __ASSERT_ALWAYS(bParamsValid, Fault(EFatCache_BadGranularity)); 
+
+        
+            iCache = CFat16FixedCache::NewL(iOwner, fatSize, fat16_ReadGranularity_Log2, fat16_WriteGranularity_Log2); 
+        }
+        break;
+
+        default:
+        ASSERT(0);
+		User::Leave(KErrCorrupt);
+        break;
+    };
+
+    ASSERT(iCache);
+}
+
+//---------------------------------------------------------------------------------------------------------------------------------------
+
+
+/**
+    Flush the FAT cache on disk
+@leave System wide error codes
+*/
+void CAtaFatTable::FlushL()
+	{
+    //-- the data can't be written if the mount is inconsistent
+    iOwner->CheckStateConsistentL();
+
+	if (iCache)
+		iCache->FlushL();
+	}
+
+/**
+Clear any cached data
+    @param aDiscardDirtyData if ETrue, non-flushed data in the cache will be discarded.
+*/
+void CAtaFatTable::Dismount(TBool aDiscardDirtyData)
+	{
+	if (iCache)
+		{
+        //-- cache's Close() can check if the cache is clean. 
+        //-- ignore dirty data in cache if the mount is not in consistent state (it's impossible to flush cache data)
+        //-- or if we are asked to do so.
+        const TBool bIgnoreDirtyData = aDiscardDirtyData || !iOwner->ConsistentState();
+        iCache->Close(bIgnoreDirtyData);
+
+		delete iCache;
+		iCache=NULL;
+		}
+
+	}
+
+//---------------------------------------------------------------------------------------------------------------------------------------
+
+/**
+    Invalidate whole FAT cache.
+    Depending of cache type this may just mark cache invalid with reading on demand or re-read whole cache from the media
+*/
+void CAtaFatTable::InvalidateCacheL()
+{
+    __PRINT1(_L("CAtaFatTable::InvalidateCache(), drv:%d"), iOwner->DriveNumber());
+
+    //-- if we have a cache, invalidate it entirely
+    if(iCache)
+    {
+        User::LeaveIfError(iCache->Invalidate());
+    }
+}
+
+
+//---------------------------------------------------------------------------------------------------------------------------------------
+
+/**
+    Invalidate specified region of the FAT cache
+    Depending of cache type this may just mark part of the cache invalid with reading on demand later
+    or re-read whole cache from the media.
+
+    @param aPos absolute media position where the region being invalidated starts.
+    @param aLength length in bytes of region to invalidate / refresh
+*/
+void CAtaFatTable::InvalidateCacheL(TInt64 aPos, TUint32 aLength)
+	{
+    __PRINT3(_L("CAtaFatTable::InvalidateCacheL() drv:%d, pos:%LU, len:%u,"), iOwner->DriveNumber(), aPos, aLength);
+
+    if(I64HIGH(aPos) || !aLength || I64HIGH(aPos+aLength))
+        return; //-- FAT tables can't span over 4G 
+
+    const TUint32 mediaPos32 = I64LOW(aPos);
+
+    //-- we do not use other copies of FAT, so trach changes only in FAT1
+    const TUint32 fat1StartPos = iOwner->StartOfFatInBytes();
+    const TUint32 fat1EndPos   = fat1StartPos + iOwner->FatSizeInBytes();
+
+    TUint32 invRegionPosStart = 0; //-- media pos where the invalidated region starts
+    TUint32 invRegionLen = 0;      //-- size of the invalidated region, bytes
+    
+    //-- calculate the FAT1 region being invalidated
+    if(mediaPos32 < fat1StartPos)
+    {
+        if((mediaPos32 + aLength) <= fat1StartPos)
+            return;
+
+        invRegionPosStart = fat1StartPos;
+        invRegionLen = aLength - (fat1StartPos-mediaPos32);
+    }
+    else //if(mediaPos32 < fat1StartPos)
+    {//-- mediaPos32 >= fat1StartPos)
+        if(mediaPos32 >= fat1EndPos)
+            return;
+    
+        invRegionPosStart = mediaPos32;
+        
+        if((mediaPos32 + aLength) <= fat1EndPos)
+        {
+            invRegionLen = aLength;
+        }
+        else 
+        {
+            invRegionLen = mediaPos32+aLength-fat1EndPos;
+        }
+    }
+
+    //-- convert the media pos of the region into FAT entries basis, depending on the FAT type
+    ASSERT(invRegionPosStart >= fat1StartPos && invRegionLen <= (TUint)iOwner->FatSizeInBytes());
+    
+    TUint32 startFatEntry=0;
+    TUint32 numEntries = 0;
+
+    switch(FatType())
+    {
+        case EFat12:
+        //-- invalidate whole cache; it is not worth making calculations for such small memory region.
+        User::LeaveIfError(iCache->Invalidate());
+        return;
+
+        case EFat16:
+        startFatEntry = (invRegionPosStart-fat1StartPos) >> KFat16EntrySzLog2;
+        numEntries = (invRegionLen + (sizeof(TFat16Entry)-1)) >> KFat16EntrySzLog2;
+        break;
+
+        default:
+        ASSERT(0);
+        return;
+    };
+
+    if(startFatEntry < KFatFirstSearchCluster)
+    {//-- FAT[0] and FAT[1] can't be legally accessed, they are reserved entries. We need to adjust region being refreshed.
+        if(numEntries <= KFatFirstSearchCluster)
+            return; //-- nothing to refresh
+                    
+        startFatEntry += KFatFirstSearchCluster;
+        numEntries -= KFatFirstSearchCluster;
+    }
+
+    User::LeaveIfError(iCache->InvalidateRegion(startFatEntry, numEntries));
+	}
+
+
+//-----------------------------------------------------------------------------
+/**
+    Initialize the object, create FAT cache if required
+@leave KErrNoMemory
+*/
+void CAtaFatTable::InitializeL()
+	{
+    __PRINT1(_L("CAtaFatTable::InitializeL() drv:%d"), iOwner->DriveNumber());
+    CFatTable::InitializeL();
+
+    //-- create the FAT cache.
+    ASSERT(!iCache);
+    CreateCacheL();
+	}
+
+
+//-----------------------------------------------------------------------------
+/**
+    Remount the FAT table. This method call means that the media parameters wasn't changed, 
+    otherwise CFatMountCB::DoReMountL() would reject it. 
+    Just do some re-initialisation work.
+*/
+void CAtaFatTable::ReMountL()
+{
+    __PRINT1(_L("CAtaFatTable::ReMountL() drv:%d"), iOwner->DriveNumber());
+
+    if(iCache)
+        {
+        iCache->Invalidate();
+        }
+    else
+        {
+        //-- this situation can happen when someone called CAtaFatTable::Dismount() that deletes the cache object
+        //-- and then ReMount happens. We need to re-initialise this object.
+        InitializeL();
+        }
+}
+
+
+//-----------------------------------------------------------------------------
+/**
+    Read an entry from the FAT table
+
+    @param aFatIndex FAT entry number to read
+    @return FAT entry value
+*/
+TUint32 CAtaFatTable::ReadL(TUint32 aFatIndex) const
+	{
+    if(!ClusterNumberValid(aFatIndex))
+        {
+        //ASSERT(0); //-- for some silly reason some callers pass 0 here and expect it to leave
+        User::Leave(KErrCorrupt);
+        }
+
+
+    const TUint entry = iCache->ReadEntryL(aFatIndex);
+    return entry;
+    }
+
+
+//-----------------------------------------------------------------------------
+/**
+    Write an entry to the FAT table
+
+    @param aFatIndex    aFatIndex FAT entry number to write
+    @param aValue       FAT entry to write
+@leave
+*/
+void CAtaFatTable::WriteL(TUint32 aFatIndex, TUint32 aValue)
+	{
+    const TUint32 KFat16EntryMask = 0x0FFFF;
+    
+    __PRINT2(_L("CAtaFatTable::WriteL() entry:%d, val:0x%x"), aFatIndex, aValue);
+    
+    if(!ClusterNumberValid(aFatIndex))
+        {
+        ASSERT(0); 
+        User::Leave(KErrCorrupt);
+        }
+    
+    if(aValue != KSpareCluster && (aValue < KFatFirstSearchCluster || aValue > KFat16EntryMask))
+        {
+        ASSERT(0);
+        User::Leave(KErrCorrupt);
+        }
+    iCache->WriteEntryL(aFatIndex, aValue);
+	}
+
+
+/**
+Get the next cluster in the chain from the FAT
+
+@param aCluster number to read, contains next cluster upon return
+@leave
+@return False if end of cluster chain
+*/
+TBool CFatTable::GetNextClusterL(TInt& aCluster) const
+    {
+	__PRINT1(_L("CAtaFatTable::GetNextClusterL(%d)"), aCluster);
+    
+    const TInt nextCluster = ReadL(aCluster);
+    TBool ret = EFalse; 
+
+    switch(FatType())
+        {
+        case EFat12:
+            ret=!IsEof12Bit(nextCluster);
+        break;
+
+        case EFat16:
+            ret=!IsEof16Bit(nextCluster);
+        break;
+
+        default:
+            ASSERT(0);
+            return EFalse;//-- get rid of warning
+        };
+	
+    if (ret)
+        {
+		aCluster=nextCluster;
+	    }
+	
+    return ret;
+
+    }
+
+/**
+Write EOF to aFatIndex
+    @param aFatIndex index in FAT (cluster number) to be written
+*/
+void CFatTable::WriteFatEntryEofL(TUint32 aFatIndex)
+	{
+	__PRINT1(_L("CAtaFatTable::WriteFatEntryEofL(%d)"), aFatIndex);
+
+    //-- use EOF_16Bit (0x0ffff) for all types of FAT, FAT cache will mask it appropriately
+    WriteL(aFatIndex, EOF_16Bit);
+	}
+
+
+
+/** 
+    Mark cluster number aFatIndex in FAT as bad 
+    @param aFatIndex index in FAT (cluster number) to be written
+*/
+void CFatTable::MarkAsBadClusterL(TUint32 aFatIndex)
+    {
+    __PRINT1(_L("CAtaFatTable::MarkAsBadClusterL(%d)"),aFatIndex);
+
+    //-- use KBad_16Bit (0x0fff7) for all types of FAT, FAT cache will mask it appropriately
+    WriteL(aFatIndex, KBad_16Bit);
+    
+    FlushL();
+	}
+
+
+/**
+Return the location of a Cluster in the data section of the media
+
+@param aCluster to find location of
+@return Byte offset of the cluster data 
+*/
+TInt64 CAtaFatTable::DataPositionInBytes(TUint32 aCluster) const
+	{
+    __ASSERT_DEBUG(ClusterNumberValid(aCluster), Fault(EFatTable_InvalidIndex));
+
+    const TInt clusterBasePosition=iOwner->ClusterBasePosition();
+	return(((TInt64(aCluster)-KFatFirstSearchCluster) << iOwner->ClusterSizeLog2()) + clusterBasePosition);
+	}
+
+
+
+
+
+