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

// 

//

#include "sl_std.h"

#include "sl_cache.h"

#include <e32math.h>

const TInt KSeekIndexSize=128; // Cache 128 clusters

const TInt KSeekIndexSizeLog2=7;

const TInt KFirstClusterNum=2;

CFatFileCB::CFatFileCB()

    {

    __PRINT1(_L("CFatFileCB created 0x%x"),this);

    }

CFatFileCB::~CFatFileCB()

    {

    __PRINT1(_L("~CFatFileCB deleted 0x%x"),this);

    //-- a nasty trick to find out if the CFatFileCB is in consistent state on the moment of destruction.

    //-- Because of OOM conditions CFatFileCB might not be fully constructed and to be deleted, while FlushAll()

    //-- implies valid iMount.

    const CMountCB* pMount  = &Mount();

    if(pMount)

        {//-- do some finalisation work if CMountCB is valid

        if(FileAttModified())

            {

            IndicateFileTimeModified(ETrue); //-- this will force writing file modification time to the media on Flush

            TRAP_IGNORE(FlushAllL());

            }

        }

    delete[] iSeekIndex;

    }

void CFatFileCB::CreateSeekIndex()

//

// Create a seek index

//

    {

    iSeekIndex = new TUint32[KSeekIndexSize];

    if (iSeekIndex == NULL)

        return;

    Mem::FillZ(iSeekIndex, sizeof(TUint32) * KSeekIndexSize);

    iSeekIndexSize=CalcSeekIndexSize(FCB_FileSize());

    }

TInt CFatFileCB::SeekToPosition(TUint aNewRelCluster, TUint aClusterOffset)

//

// Use the seek index to set iCurrentPos.iCluster as close as possible to aNewRelCluster

// Return aNewRelCluster-aCurrentPos.iCluster

//

    {

    TInt clusterOffset=aClusterOffset;

    TInt seekPos=(aNewRelCluster>>iSeekIndexSize)-1;

    __ASSERT_DEBUG(seekPos<KSeekIndexSize,Fault(EFatFileSeekIndexTooSmall));

    while(seekPos>=0 && iSeekIndex[seekPos]==0 && clusterOffset!=0)

        {

        seekPos--;

        clusterOffset--;

        }

    if (clusterOffset==0) // Counted back to the current cluster

        return(aClusterOffset);

    if (seekPos<0)

        {

        iCurrentPos.iCluster=FCB_StartCluster();

        return(aNewRelCluster);

        }

    iCurrentPos.iCluster=iSeekIndex[seekPos];

    return(aNewRelCluster-((seekPos+1)<<iSeekIndexSize));

    }

void CFatFileCB::SetSeekIndexValueL(TUint aRelCluster, TUint aStoredCluster)

//

// Sets a value in the seekindex

//

    {

    TInt seekPos=(aRelCluster>>iSeekIndexSize)-1;

    __ASSERT_DEBUG(seekPos<KSeekIndexSize,Fault(EFatFileSeekIndexTooSmall));

    __ASSERT_DEBUG(seekPos>=0,Fault(EFatFileSeekIndexTooSmall2));

    iSeekIndex[seekPos] = aStoredCluster;

    }

TBool CFatFileCB::IsSeekBackwards(TUint aPos)

//

// Return true if aPos<currentPos

//

    {

    TUint cluster=iCurrentPos.iCluster<<ClusterSizeLog2();

    TInt offset=ClusterRelativePos(iCurrentPos.iPos);

    TUint currentPos=cluster+offset;

    return(aPos<currentPos);

    }

void CFatFileCB::CheckPosL(TUint aPos)

//

// Check that the file is positioned correctly.

// If aPos<currentPos attempt to guess the new position.

//

    {

    __PRINT1(_L("CFatFileCB::CheckPosL(%d)"), aPos);

    if (aPos==iCurrentPos.iPos)

        return;

    __ASSERT_DEBUG(aPos <= FCB_FileSize(), Fault(EFatFilePosBeyondEnd));

    if (FileSizeModified() && IsSeekBackwards(aPos))

        FlushDataL(); 

    TUint newRelCluster=aPos>>ClusterSizeLog2();

    if ( aPos && (aPos==(newRelCluster<<ClusterSizeLog2())) )

        newRelCluster--;

    TUint oldRelCluster=iCurrentPos.iPos>>ClusterSizeLog2();

    if ( iCurrentPos.iPos && (iCurrentPos.iPos==(oldRelCluster<<ClusterSizeLog2())) )

        oldRelCluster--;    

    TInt clusterOffset=newRelCluster-oldRelCluster;

    TUint32 oldCluster=iCurrentPos.iCluster;

    iCurrentPos.iPos=aPos;

    if (clusterOffset==0)

        return;

    TInt seekOffset=clusterOffset;

    if (iSeekIndex!=NULL)

        { // Can alter iCurrentPos.iCluster

        seekOffset=SeekToPosition(newRelCluster,seekOffset);

        if (seekOffset==0)

            return;

        }

    if (clusterOffset==-1 && seekOffset!=1)

        { // Check previous cluster

        TUint32 cluster=oldCluster-1;

        if (FAT().GetNextClusterL(cluster) && cluster==oldCluster)

            {

            iCurrentPos.iCluster=oldCluster-1;

            return;

            }

        }

    if (seekOffset<0)

        {

        seekOffset=newRelCluster;

        iCurrentPos.iCluster=FCB_StartCluster();

        }

    while (seekOffset--)

        {

        if (!FAT().GetNextClusterL(iCurrentPos.iCluster))

            {

            __PRINT(_L("CFatFileCB::CheckPosL() corrupt#1"));

            User::Leave(KErrCorrupt);

            }

        TInt cluster=newRelCluster-seekOffset;

        if (iSeekIndex!=NULL && cluster && (cluster>>iSeekIndexSize)<<iSeekIndexSize==cluster)

            SetSeekIndexValueL(cluster,iCurrentPos.iCluster);

        }

    }

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

/** 

    Initialize FileCB from file's entry data.

    @param  aFatDirEntry        this file DOS dir entry.

    @param  aFileDosEntryPos    this file DOS entry dir. iterator in the parent directory.

*/

void CFatFileCB::SetupL(const TFatDirEntry& aFatDirEntry, const TEntryPos& aFileDosEntryPos)

    {

    __PRINT1(_L("CFatFileCB::SetupL[0x%x]"), this);

    //-- set up a file control block

    iCurrentPos.iCluster= FatMount().StartCluster(aFatDirEntry);

    iCurrentPos.iPos=0;

    SetAtt(aFatDirEntry.Attributes());

    SetModified(aFatDirEntry.Time(FatMount().TimeOffset()));

    FCB_SetStartCluster(iCurrentPos.iCluster);

    FCB_SetFileSize(aFatDirEntry.Size()); 

    iFileDosEntryPos = aFileDosEntryPos;

    SetMaxSupportedSize(KMaxSupportedFatFileSize);

    //-- create seek index

    ASSERT(!iSeekIndex);

    CreateSeekIndex();

    if(!iSeekIndex)

        User::Leave(KErrNoMemory);

    IndicateFileAttModified(EFalse);

    IndicateFileSizeModified(EFalse);

    IndicateFileTimeModified(EFalse);

    }

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

/**

    Read data from the file.

    @param  aFilePos    start read position within a file

    @param  aLength     how many bytes to read; on return will be how many bytes actually read

    @param  aDes        local buffer desctriptor

    @param  aMessage    from file server, used to write data to the buffer in different address space.

    @param  aDesOffset  offset within data descriptor where the data will be copied

    @leave on media read error

*/

void CFatFileCB::ReadL(TInt64 aPos,TInt& aLength, TDes8* aDes, const RMessagePtr2& aMessage, TInt aOffset)

    {

    __PRINT3(_L("CFatFileCB::ReadL[0x%x] pos=%LU len=%d"), this, aPos, aLength);

    if((TUint64)aPos > KMaxSupportedFatFileSize-1)

        User::Leave(KErrNotSupported);  //-- max. position in the file is 0xFFFFFFFE

    FatMount().CheckStateConsistentL();

    CheckPosL(I64LOW(aPos));

    const TUint startPos = iCurrentPos.iPos;

    const TUint curSize  = FCB_FileSize();

    const TUint length   = (TUint)aLength;

    if((startPos + length > curSize) || (startPos > startPos + length) )

        aLength=curSize-startPos;

	TUint flag = DirectIOMode(aMessage) ? RLocalDrive::ELocDrvDirectIO : 0;

    FatMount().ReadFromClusterListL(iCurrentPos,aLength,aDes,aMessage,aOffset, flag);

	aLength=iCurrentPos.iPos-startPos;

	}

void CFatFileCB::ReadL(TInt aFilePos,TInt& aLength,const TAny* aTrg,const RMessagePtr2& aMessage)

    {

    ReadL(TInt64(aFilePos),aLength,(TDes8*) aTrg,aMessage, 0);

    }

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

/**

    Write data to the file.

    @param  aFilePos    start write position within a file

    @param  aLength     how many bytes to write; on return contain amount of data actually written

    @param  aDes        local buffer desctriptor

    @param  aMessage    from file server, used to write data to the media from different address space.

    @param  aDesOffset  offset within data descriptor 

    @leave on media read error

*/

void CFatFileCB::WriteL(TInt64 aPos,TInt& aLength,const TDesC8* aSrc,const RMessagePtr2& aMessage, TInt aOffset)

    {

    __PRINT3(_L("CFatFileCB::WriteL[0x%x] pos=%LU len=%d"), this, aPos, aLength);

    // FAT supports 32 bits only for file size

    TUint64 endPos = aPos + aLength;

    if(endPos > KMaxSupportedFatFileSize)

        User::Leave(KErrNotSupported);

    FatMount().CheckStateConsistentL();

    FatMount().CheckWritableL();

    const TUint pos = I64LOW(aPos);

    CheckPosL(pos);

    const TUint startCluster = FCB_StartCluster();

    const TUint length       = (TUint)aLength;

    endPos = iCurrentPos.iPos + length; 

    if ((endPos           > FCB_FileSize()) ||

        (iCurrentPos.iPos > endPos)         ) // Overflow condition 

        DoSetSizeL(iCurrentPos.iPos+length,EFalse);

    TUint startPos=iCurrentPos.iPos;

    TUint badcluster=0;

    TUint goodcluster=0;

	TUint flag = DirectIOMode(aMessage) ? RLocalDrive::ELocDrvDirectIO : 0;

	TRAPD(ret, FatMount().WriteToClusterListL(iCurrentPos,aLength,aSrc,aMessage,aOffset,badcluster, goodcluster, flag));

    if (ret == KErrCorrupt || ret == KErrDied)

        {

        if(startCluster == 0)

            { //Empty File, revert all the clusters allocated.

            const TUint32 cluster = FCB_StartCluster();

            FCB_SetStartCluster(0);

            FCB_SetFileSize(0);

            IndicateFileSizeModified(ETrue);

            FlushAllL();

            iCurrentPos.iCluster = 0;

            iCurrentPos.iPos = 0;

            FAT().FreeClusterListL(cluster);

            FAT().FlushL();

            }

        else

            { //Calculate the clusters required based on file size, revert extra clusters if allocated.

            const TUint curSize = FCB_FileSize();

            TUint ClustersNeeded = curSize >> ClusterSizeLog2();

            if(curSize > (ClustersNeeded << ClusterSizeLog2()))

                {

                ClustersNeeded++;

                }

            TUint32 cluster = FCB_StartCluster();

            while(--ClustersNeeded)

                {

                FAT().GetNextClusterL(cluster);

                }

            iCurrentPos.iCluster = cluster;

            if (FAT().GetNextClusterL(cluster))

                {

                FAT().FreeClusterListL(cluster);

                }

            FAT().WriteFatEntryEofL(iCurrentPos.iCluster);

            FAT().FlushL();

            }

        }

    User::LeaveIfError(ret);

    if(badcluster != 0)

        {

        if(FCB_StartCluster() == badcluster)

            {

            FCB_SetStartCluster(goodcluster);

            FlushStartClusterL();

            }

        else

            {

            TUint32 aCluster = FCB_StartCluster();

            do

                {

                if((TUint)badcluster == FAT().ReadL(aCluster))

                    {

                    FAT().WriteL(aCluster, goodcluster);

                    FAT().FlushL();

                    break;

                    }

                }

            while(FAT().GetNextClusterL(aCluster));

            }

        }

    aLength=iCurrentPos.iPos-startPos;

    if(!IsSequentialMode() && FatMount().IsRuggedFSys() && pos+(TUint)aLength > FCB_FileSize())

        {

        WriteFileSizeL(pos+aLength);

        }

    }

void CFatFileCB::WriteL(TInt aFilePos,TInt& aLength,const TAny* aSrc,const RMessagePtr2& aMessage)

    {

    WriteL(TInt64(aFilePos),aLength,(TDesC8*) aSrc,aMessage, 0);

    }

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

void CFatFileCB::ResizeIndex(TInt aNewMult,TUint aNewSize)

//

// Resize the seek index to accomodate a larger or smaller filesize

// Assumes KSeekIndexSize is a power of 2.

//

    {

    TInt maxNewIndex=aNewSize>>(ClusterSizeLog2()+aNewMult);

    TInt    index=0;

    TInt    indexEnd=KSeekIndexSize;

    TInt    newValEnd=maxNewIndex;

    if (iSeekIndexSize<aNewMult)

        {

        TInt newVal=index;

        TInt step=1<<(aNewMult-iSeekIndexSize);

        index+=step-1;

        while(index<indexEnd && newVal<newValEnd)

            {

            iSeekIndex[newVal] =  iSeekIndex[index];

            newVal++;

            index+=step;

            }

        while(newVal<indexEnd)

            iSeekIndex[newVal++] =  0;

        }

    else

        {

        TInt diffSize = iSeekIndexSize-aNewMult;

        TInt oldVal=(KSeekIndexSize>>diffSize) - 1;

        TInt newVal=indexEnd-1;

        TInt skip=(1<<diffSize)-1;

        if ((iSeekIndexSize - aNewMult) > KSeekIndexSizeLog2)

            {

            ClearIndex(0); //-- Invalidate every entry.

            }

        else

            {

            while(newVal>=index)

                {

                iSeekIndex[newVal--] =  iSeekIndex[oldVal--];

                for(TInt i=skip;i>0;i--)

                    {   

                    iSeekIndex[newVal--] = 0;

                    }

                }

            }

        }

    iSeekIndexSize=aNewMult;

    }

/**

    Zero freed clusters in the index

    @param  aNewSize new size of the file that the index corresponds to.

            if = 0  all existing index will be zero filled

*/ 

void CFatFileCB::ClearIndex(TUint aNewSize)

    {

    if (!iSeekIndex)

        return;

    if(aNewSize==0)

        {

        //-- zero fill all the array

        Mem::FillZ(iSeekIndex, KSeekIndexSize*sizeof(TUint32));

        return;

        }

    // Files that fill up a cluster exactly do not have a trailing empty

    // cluster. So the entry for that position must also be invalidated

    aNewSize--;

    TInt firstInvalidIndex=aNewSize>>(iSeekIndexSize+ClusterSizeLog2());

    TInt indexLen=KSeekIndexSize-firstInvalidIndex;

    Mem::FillZ(iSeekIndex+firstInvalidIndex, indexLen * sizeof(TUint32));

    }

TInt CFatFileCB::CalcSeekIndexSize(TUint aSize)

//

// Find the nearest power of 2 > aSize

//

    {

    TInt count = 0;

    const TUint indexSize=KSeekIndexSize<<ClusterSizeLog2();//KSeekIndexSize=128

    if (aSize<=indexSize)

      return(count);

    while((aSize>>=1)>0)

        {

        count++;

        }

    return (count - (KSeekIndexSizeLog2 + ClusterSizeLog2()) + 1);

    }

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

/**