// 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\fat_table32.cpp

// FAT32 File Allocation Table classes implementation

// 

//

/**

 @file

 @internalTechnology

*/

#include "sl_std.h"

#include "sl_fatcache32.h"

#include "fat_table32.h"

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

/** 

    Implements automatic locking object.

    Calls TFatDriveInterface::AcquireLock() on construction and TFatDriveInterface::ReleaseLock() on destruction. 

    Can be constructed on the stack only.

*/

class XAutoLock

    {

     public:

       inline XAutoLock(CFatMountCB* apOwner) : iDrv(apOwner->DriveInterface()) {iDrv.AcquireLock();}

       inline XAutoLock(TFatDriveInterface& aDrv) : iDrv(aDrv) {iDrv.AcquireLock();}

       inline ~XAutoLock() {iDrv.ReleaseLock();}

     private:

        void* operator new(TUint); //-- disable creating objects on heap.

        void* operator new(TUint, void*);

     private:

        TFatDriveInterface &iDrv; ///< reference to the drive interface

    };

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

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

//#     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 && fatType != EFat32)

                {//-- CRamFatTable doesn't support FAT12, FAT16 & FAT32 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() || IsFat32());

    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(!RequestFreeClusters(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);

    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(!RequestFreeClusters(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);

	}