// 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:

// Common CFatMountCB code for both EFAT.FSY and EFAT32.fsy

//

//

/**

 @file

 @internalTechnology

*/

#include "sl_std.h"

#include "sl_cache.h"

#include "sl_leafdir_cache.h"

#include "sl_dir_cache.h"

#include "sl_scandrv.h"

#include <hal.h>

TShortName DoGenerateShortNameL(const TDesC& aLongName,TInt& aNum,TBool aUseTildeSelectively);

static void  MarkClusterVisited(RBitVector& aFatBitVec, TUint32 aCluster);

static TBool IsClusterVisited(const RBitVector& aFatBitVec, TUint32 aCluster);

static TInt  NextUnvisitedCluster(const RBitVector& aFatBitVec, TUint32 aCluster);

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

TFatVolParam::TFatVolParam()

    {

    Mem::FillZ(this, sizeof(TFatVolParam));

    }

/**

    populate the object with the values from the boot sector.

    @param aBootSector a reference to the valid boots sector

*/

void TFatVolParam::Populate(const TFatBootSector& aBootSector)

    {

    ASSERT(aBootSector.IsValid());

    iSectorsPerCluster = aBootSector.SectorsPerCluster();

    iSectorSizeLog2    = Log2(aBootSector.BytesPerSector());

    iClusterSizeLog2   = iSectorSizeLog2+Log2(iSectorsPerCluster);

    iFirstFatSector    = aBootSector.FirstFatSector();

    iNumberOfFats      = aBootSector.NumberOfFats();

    iFatSizeInBytes    = aBootSector.TotalFatSectors()*aBootSector.BytesPerSector();

    iTotalSectors      = aBootSector.VolumeTotalSectorNumber();

    iRootClusterNum    = aBootSector.RootClusterNum(); //-- will be 0 for FAT12/16

    iRootDirectorySector = aBootSector.RootDirStartSector();

    iRootDirEnd = (iRootDirectorySector + aBootSector.RootDirSectors()) << SectorSizeLog2(); //-- doesn't matter for FAT32

    //-- get main and backup FSInfo sectors position, these fields will be 0 for FAT12/16

    iFSInfoSectorNum   = aBootSector.FSInfoSectorNum();

    iBkFSInfoSectorNum = (TUint16)(aBootSector.BkBootRecSector()+iFSInfoSectorNum); //-- Bk FSInfo sector must follow the Bk boot sector

    }

TBool TFatVolParam::operator==(const TFatVolParam& aRhs) const

    {

    ASSERT(&aRhs != this);

    if(&aRhs == this)

        return ETrue; //-- comparing with itself

    return (Mem::Compare((TUint8*)this, sizeof(TFatVolParam), (TUint8*)&aRhs, sizeof(TFatVolParam)) == 0);

    }

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

CFatMountCB::CFatMountCB()

    {

    __PRINT2(_L("CFatMountCB::CFatMountCB() 0x%x, %S"), this, &KThisFsyName);

    iFatType = EInvalid;

    iState   = ENotMounted;

    DBG_STATEMENT(iCBRecFlag = 0); //-- debug flag only

    }

CFatMountCB::~CFatMountCB()

    {

    __PRINT1(_L("#-CFatMountCB::~CFatMountCB() 0x%x"), this);

    DoDismount();

    delete iNotifier;

    delete iFatTable;

    delete iRawDisk;

    delete iLeafDirCache;

    }

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

CFatMountCB* CFatMountCB::NewL()

    {

    CFatMountCB* pSelf = new(ELeave) CFatMountCB;

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL();

    CleanupStack::Pop(pSelf);

    return pSelf;

    }

// second-stage constructor

void CFatMountCB::ConstructL()

{

    //-- create Notifier

    iNotifier = CAsyncNotifier::New();

    if( !iNotifier )

        {

        Close();

        User::Leave(KErrNoMemory);

        }

    iNotifier->SetMount(this);

    }

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

/**

Implementation of CMountCB::FileSystemClusterSize(). Returns cluster size of this mount.

@return Cluster size value if successful; otherwise KErrNotReady if the mount is not ready.

@see CMountCB::FileSystemClusterSize()

*/

TInt CFatMountCB::ClusterSize() const

    {

    if (ClusterSizeLog2())

        return (1 << ClusterSizeLog2());

    return KErrNotReady;

    }

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

/**

    @leave KErrAccessDenied if the mount is read-only

*/

void CFatMountCB::CheckWritableL() const

    {

    if(ReadOnly())

        {

        __PRINT(_L("CFatMountCB is RO!"));

        User::Leave(KErrAccessDenied);

        }

    }

/**

    @leave KErrCorrupt if the mount is in inconsistent state i.e high-level file and directory  operations can not be performed

*/

void CFatMountCB::CheckStateConsistentL() const

    {

    if(!ConsistentState())

        {

        __PRINT(_L("CFatMountCB state is inconsistent !"));

        User::Leave(KErrCorrupt);

        }

    }

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

/**

    Helper Method. Check if the parameters of the volume being remounted are the same as current ones.

    @return ETrue if volume parameters remained same.

*/

TBool CFatMountCB::CheckVolumeTheSame()

{

    //-- initialise local drive

    TInt nRes =InitLocalDrive();

    if(nRes != KErrNone)

        return EFalse;

    //-- read the boot sector or its backup copy if the main is damaged. It will aslo validate it.

    TFatBootSector bootSector;

    nRes = ReadBootSector(bootSector, iRamDrive);

    if(nRes != KErrNone)

        return EFalse;

    //-- 1. check volume Uid

    if(iUniqueID != bootSector.UniqueID())

        return EFalse;

    //-- check volume parameters, they must remain the same

    TFatVolParam volParam;

    volParam.Populate(bootSector);

    if(!(volParam == iVolParam))

        return EFalse;

    return ETrue;

}

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

/**

    Helper Method. Check if the parameters of the volume being remounted are the same as current ones.

    If they are, re-initialises the mount.

*/

void CFatMountCB::DoReMountL()

    {

    if(!CheckVolumeTheSame())

        User::Leave(KErrGeneral);

	//-- get drive capabilities

    TLocalDriveCapsV2Buf capsBuf;

	User::LeaveIfError(LocalDrive()->Caps(capsBuf));

    //-- the volume is the same as it was on original MountL()

    //-- we need to re-initialize for the case when the media was removed, FAT or directory structure changed on other device and the media returned back.

    DoDismount();

    SetState(EMounting);

    InitializeL(capsBuf(), ETrue); //-- forcedly disable FSInfo usage. This will lead to FAT free clusters re-counting.

    }

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

/**

    Try remount this Fat volume. Checks if the volume parameters remained the same as on original MountL() call, and

    if they are, re-initialises the mount. This includes resetting all caches.

    ! Do not call this method from TFatDriveInterface methods, like citical and non-critical notifiers ! This can lead to the

    recursive loops and undefined behaviour.

    @return KErrNone if the remount was OK

            system-wide error code otherwise

*/

TInt CFatMountCB::ReMount()

    {

    __PRINT2(_L("CFatMountCB::ReMount(), drv:%d, curr state:%d"), DriveNumber(), State());

    const TFatMntState currState = State();

    //-- analyse the mount state and find out if we can remount at all.

    switch(currState)

        {

        case ENotMounted:

        __PRINT(_L("CFatMountCB::ReMount() Invalid mount state!"));

        ASSERT(0);

        return KErrGeneral;

        //-- correct state, proceed to remount

        default:

        break;

    }

    //-- there are 2 options here:

    //-- 1. normally initialised mount had been forcedly dismounted (it can optionally have objects opened on it)

    //--    in this case the DoReMountL() will succeed and everything will be fine, the objects will be accessible afterwards

    //-- 2. the mount hasn't been initialised at all (it does not have for example, FAT table created etc.)

    //--    in this case we may need to fake the success. This can only happen on forced mount by CFormatCB

    TInt nRes;

    TRAP(nRes, DoReMountL());

    if(nRes != KErrNone)

        {

        //-- note that the mount may be here left in inconsistent state (EMounting)

        //-- if DoReMountL() fails. This is OK, because we can not make any valid read/write operations in such a state and

        //-- the drive must be dismounted and mounted again. File Server's TDrive shall do this.

        __PRINT1(_L("CFatMountCB::ReMount() failed! code:%d"), nRes);

        //-- If we are in the EInit_Forced state, it means that we are trying to remount the volume that has been formatted.

        //-- scenario: On formatting, if we can't read a bootsector, new _empty_ object of the CFatMountCB is created and

        //-- it is used for performing a format. If the format has finished, but RFormat isn't closed yet and we try to access the volume,

        //-- we will get here, because all members of the constructed mount will be zeroes.

        if(currState == EInit_Forced)

            {

            __PRINT(_L("CFatMountCB::ReMount() simulating normal remount!"));

            SetState(currState);

            return KErrNone;

            }

        return nRes;

        }

    __PRINT1(_L("CFatMountCB::ReMount() Completed drv:%d"), DriveNumber());

    SetState(EInit_R);

    return nRes;

    }

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

/**

    Reset the last leaf dir or invalidate leaf dir cache if leaf dir cache is

    instantiated.

*/

void CFatMountCB::InvalidateLeafDirCache()

	{

    if (iLeafDirCache)

    	{

        iLeafDirCache->Reset();

    	}

    else

    	{

        User::Free(iLastLeafDir);

        iLastLeafDir=NULL;

    	}

	}

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

/**

    Delete mount's caches

    Moves CFatMountCB into ENotMounted state immediately.

*/

void CFatMountCB::DoDismount()

    {

    __PRINT1(_L("CFatMountCB::DoDismount() drv:%d"), DriveNumber());

    //-- try to flush and destroy FAT cache

    if (iFatTable)

        {

        if(!ConsistentState() || ReadOnly())

            {//-- the mount state is inconsistent, so the data can't be flushed. Ignore dirty cache either.

            iFatTable->Dismount(ETrue);

            }

        else

            {//-- Try to flush the FAT - if this fails there's not much we can do

            TRAPD(r, iFatTable->FlushL());

            iFatTable->Dismount(r != KErrNone); //-- ignore dirty data if we failed to flush the cache

            }

        }

    //-- destroy leafdir name cache, this cache will be re-created while mounting or re-mounting

    //-- see CFatMountCB::InitializeL()

    delete iLeafDirCache;

    iLeafDirCache = NULL;

    //-- destroy directory cache, this cache will be re-created while mounting or re-mounting

    //-- see CFatMountCB::InitializeL()

    delete iRawDisk;

    iRawDisk = NULL;

    //-- Set mount state to "Dismounted". Which means that there might be no caches, but the mount is alive,

    //-- i.e. iFatTable & iRawDisk are valid

    SetState(EDismounted);

    }

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

/** old implementation */

void CFatMountCB::FinaliseMountL()

    {

    FinaliseMountL(RFs::EFinal_RW);

    }

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

/**

    Dismount the CFatMountCB and the drive.

    called from TDrive::Dismount().

*/

void CFatMountCB::Dismounted()

    {

    __PRINT1(_L("CFatMountCB::Dismounted() drv:%d"), DriveNumber());

    //-- n.b. it is no safe to do a kind of filnalisatin work here that implies accessing the media.

    //-- this method may be called after the media change occured from the TDrive::Dismount(). It means

    //-- that if we try to write some data here, they could be written into a different medium, if it had been

    //-- physically changed.

    const TFatMntState prevState = State();

    DoDismount(); //-- it will change mount state to EDismounted

    DismountedLocalDrive();

    //-- check if the previous state was EInit_Forced, which means that this method was called

    //-- on the mount that might not be alive (no valid iFatTable & iRawDisk).

    //-- This can happen only during format operation on non-mounted previously volume.

    //-- this EInit_Forced state must be processed separately, see ::Remount()

    if(prevState == EInit_Forced)

        SetState(EInit_Forced);

    }

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

/**

    Find out if the mount is finalised.

    @param  aFinalised on exit will be ETrue if the maunt is finalised, EFalse otherwise.

    @return standard error codes.

*/

TInt CFatMountCB::IsFinalised(TBool& aFinalised)

    {

    switch(State())

        {

        case EFinalised: //-- already explicitly finalised

            aFinalised = ETrue;

        return KErrNone;

        case EInit_W: //-- the volume had been written

            aFinalised = EFalse;

        return KErrNone;

        default: //-- it depends on the state

        break;

        }

    //-- find out if the volume is _physically_ finalised.

    //-- It can be in the state EInit_R, but finalised before mounting

    if(!VolCleanFlagSupported())

        return KErrNotSupported;

    TInt nRes = KErrNone;

    TRAP(nRes, aFinalised = VolumeCleanL());

    return nRes;

    }

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

/**

    @return ETrue if the mount is in consistent state i.e. normally mounted.

    See TFatMntState enum for more detail.

*/

TBool CFatMountCB::ConsistentState() const

    {

    return (iState==EInit_R) || (iState==EInit_W) || (iState == EFinalised);

    }

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

/**

    Open CFatMountCB for write. I.e. perform some actions on the first write attempt.

    This is a callback from TFatDriveInterface.

    @return System wide error code.

*/

TInt CFatMountCB::OpenMountForWrite()

    {

    if(State() == EInit_W)

        return KErrNone; //-- nothing to do, the mount is already opened for write

    __PRINT1(_L("#- CFatMountCB::OpenMountForWrite() drv:%d\n"),DriveNumber());

    ASSERT(State() == EInit_R || State() == EFinalised);

    //-- Check possible recursion. This method must not be called recursively. SetVolumeCleanL() works through direct disc access and

    //-- can not call TFatDriveInterface methods that call this method etc.

    ASSERT(iCBRecFlag == 0);

    DBG_STATEMENT(iCBRecFlag = 1); //-- set recursion check flag

    //-- do here some "opening" work, like marking volme as dirty

    //-- be careful here, as soon as this is a callback from TFatDriveInterface, writing via TFatDriveInterface may cause some unwanted recursion.

    //-- mark the volume as dirty

    TInt nRes=KErrNone;

    TRAP(nRes, SetVolumeCleanL(EFalse));

    if(nRes == KErrNone)

        {

        SetState(EInit_W);

        }

    DBG_STATEMENT(iCBRecFlag = 0); //-- reset recursion check flag

    return nRes;

    }

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

/**

    Unfinalise the mount, reset "VolumeCleanShutDown" flag and change the state if necessarily.

*/

void CFatMountCB::UnFinaliseMountL()

    {

    switch(State())

        {

        case EFinalised:

        case EInit_R:

            SetVolumeCleanL(EFalse); //-- the mount, mark volume "dirty"

            SetState(EInit_R);

        return;

        case EInit_W:

        return; //-- nothing to do

        default:

        //-- other mount states are inconsistent; can't perform this operation

        User::Leave(KErrAbort);

        break;

        }

    }

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

/**

    Finalise the mount.

    @param  aOperation  describes finalisation operation ,see RFs::TFinaliseDrvMode

    @param  aParam1     not used, for future expansion

    @param  aParam2     not used, for future expansion

    @leave  System wide error code. particular cases:

            KErrArgument invalid arguments

            KErrInUse    if the volume has opened objects (files, directories etc)

            KErrCorrupt  if the volume is corrupt

*/

void CFatMountCB::FinaliseMountL(TInt aOperation, TAny* /*aParam1*/, TAny* /*aParam2*/)

    {

    __PRINT2(_L("#- CFatMountCB::FinaliseMountL() op:%d, drv:%d"), aOperation, DriveNumber());

    switch(aOperation)

        {

        case RFs::EFinal_RW:

        case RFs::EFinal_RO:

        break;

        case RFs::EForceUnfinalise:

            UnFinaliseMountL();

        return;