// 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_mnt32.cpp

// CFatMountCB code, specific to the EFAT32.FSY

// 

//

/**

 @file 

*/

#include "sl_std.h"

#include "sl_cache.h"

#include "sl_leafdir_cache.h"

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

/**

    Write aligned members of TFatBootSector to media

    @param  aMediaPos   media position the data will be written to

    @param  aBootSector data to write

    @return Media write error code

*/

TInt CFatMountCB::DoWriteBootSector(TInt64 aMediaPos, const TFatBootSector& aBootSector)  const

    {

    __PRINT2(_L("#- CFatMountCB::DoWriteBootSector() drv:%d, pos:0x%x"),Drive().DriveNumber(), (TUint32)aMediaPos);   

    ASSERT(aMediaPos>=0);

    TBuf8<KDefaultSectorSize> bootSecBuf(KDefaultSectorSize);

    bootSecBuf.FillZ();

    //-- externalize boot sector to the data buffer

    aBootSector.Externalize(bootSecBuf);

    //-- put a boot sector signature to the last 2 bytes

    bootSecBuf[KDefaultSectorSize-2] = 0x55;

    bootSecBuf[KDefaultSectorSize-1] = 0xaa;

    //-- write boot sector to the media

    TInt r=LocalDrive()->Write(aMediaPos, bootSecBuf);

    if (r!=KErrNone)

        {//-- write failure

        __PRINT2(_L("CFatMountCB::DoWriteBootSector() failed! drv:%d, code:%d"),Drive().DriveNumber(),r);

        }

    return r;

    }

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

/**

    Read non aligned boot data from media into TFatBootSector structure

    @param  aMediaPos   media position the data will be read from

    @param  aBootSector refrence to TFatBootSector populate

    @return Media read error code

*/

TInt CFatMountCB::DoReadBootSector(TInt64 aMediaPos, TFatBootSector& aBootSector)  const

    {

    __PRINT2(_L("#- CFatMountCB::DoReadBootSector() drv:%d, pos:0x%x"),Drive().DriveNumber(), (TUint32)aMediaPos);   

    ASSERT(aMediaPos>=0);

    TBuf8<KSizeOfFatBootSector> bootSecBuf(KSizeOfFatBootSector);

    //-- read boot sector from the media

    TInt r=LocalDrive()->Read(aMediaPos, KSizeOfFatBootSector, bootSecBuf);

    if (r != KErrNone)

        {

        __PRINT2(_L("CFatMountCB::DoReadBootSector() failed! drv:%d, code:%d"),Drive().DriveNumber(),r);

	    //-- fiddling with the error code; taken from MountL()

        if (r==KErrNotSupported)

		    return KErrNotReady;

    #if defined(_LOCKABLE_MEDIA)

	    else if(r==KErrLocked)

		    return KErrLocked;

    #endif

	    else if (r!=KErrNoMemory && r!=KErrNotReady && r!=KErrCorrupt && r!=KErrUnknown)

                return KErrCorrupt; 

        return r;

        }

    ASSERT(r==KErrNone);

    //-- initialise TFatBootSector object

    aBootSector.Internalize(bootSecBuf);

    //-- Validate the partition size, and fix up if the out of bounds

    TLocalDriveCapsV2Buf localDriveCaps;

    r = LocalDrive()->Caps(localDriveCaps);

    if (r != KErrNone)

        {

        //-- fiddling with the error code; taken from MountL()

        if (r!=KErrNoMemory && r!=KErrNotReady && r!=KErrCorrupt && r!=KErrUnknown)

            return KErrCorrupt;

        else

            return r;

        }

    if(!(localDriveCaps().iMediaAtt & KMediaAttVariableSize))

        {//-- this is not a RAM drive.

        const TUint32 maxSectors = I64LOW(localDriveCaps().iSize >> KDefSectorSzLog2);

        if(aBootSector.TotalSectors())

            aBootSector.SetTotalSectors(Min(aBootSector.TotalSectors(), maxSectors));

        else

            aBootSector.SetHugeSectors(Min(aBootSector.HugeSectors(), maxSectors));

        }

    return KErrNone;

    }

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

/**

    Read and validate the boot sector.

    If there is an error in reading the main boot sector (sec:0) or it is invalid, tries to read backup boot sector from sec:6.

    Flag iMainBootSecValid indicates the validity of the main boot sector. if it is false, but ret. value is KErrNone, it means that

    the backup boot sector was used and it is valid.

    @param      aBootSector reference to the boot sector object to be read.

    @param      aDoNotReadBkBootSec if true, there won't be an attempt to read backup sector

    @return     standard error code.

*/

TInt CFatMountCB::ReadBootSector(TFatBootSector& aBootSector, TBool aDoNotReadBkBootSec/*=EFalse*/)

    {

    iMainBootSecValid = EFalse; 

    //-- read main boot sector from the sector 0

    TInt nRes = DoReadBootSector(KBootSectorNum << KDefSectorSzLog2, aBootSector); 

    if(nRes == KErrNone)

        {

        if(aBootSector.IsValid())

            {

            iMainBootSecValid = ETrue; //-- main boot sector is valid, everything is OK

            return KErrNone;

            }

        else

            {

            __PRINT(_L("MainBoot Sector is invalid! dump:\n"));

            aBootSector.PrintDebugInfo();

            nRes = KErrCorrupt;

            }

        }

    ASSERT(nRes!= KErrNone && !iMainBootSecValid);

    if(aDoNotReadBkBootSec)

        return nRes;

    //-- main boot sector is invalid, try backup one (it might not present at all) 

    __PRINT(_L("Using backup boot sector...\n"));

    nRes=DoReadBootSector(KBkBootSectorNum << KDefSectorSzLog2, aBootSector); 

    if(nRes == KErrNone )

        {

        if(aBootSector.IsValid())

            return KErrNone; //-- main boot sector is bad, but backup one is OK

        else

            {//-- backup boot sector is invalid

            __PRINT(_L("Backup Sector is invalid! dump:\n"));    

            aBootSector.PrintDebugInfo();

            nRes = KErrCorrupt;

            }

        }

    //-- can't read boot sectors, or both are invalid

    return nRes;

    }

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

/**

Write a new volume label to BPB in media

@param aVolumeLabel Descriptor containing the new volume label

@leave 

*/

void CFatMountCB::WriteVolumeLabelL(const TDesC8& aVolumeLabel) const

    {

    if(aVolumeLabel.Length() > KVolumeLabelSize)

        User::Leave(KErrArgument);

    const TUint32 posVolLabel = Is32BitFat() ? KFat32VolumeLabelPos : KFat16VolumeLabelPos;

    User::LeaveIfError(LocalDrive()->Write(posVolLabel, aVolumeLabel)); 

    }

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

const TUint32 KFat32CleanShutDownMask	= 0x08000000; ///< Mask used to indicate test clean/dirty bit for Fat32

const TUint16 KFat16CleanShutDownMask	= 0x08000;    ///< Mask used to indicate test clean/dirty bit for Fat16

/**

Set or reset "VolumeClean" (ClnShutBitmask) flag.

@param  aClean if ETrue, marks the volume as clean, otherwise as dirty.

@leave  if write error occured.        

*/

void CFatMountCB::SetVolumeCleanL(TBool aClean) 

    {

	//-- The volume can't be set clean if there are objects opened on it. This precondition must be checked before calling this function

    if(aClean && LockStatus()!=0)

        {

        __PRINT1(_L("#- CFatMountCB::SetVolumeCleanL drive:%d isn't free!"),DriveNumber());

        ASSERT(0);

        User::Leave(KErrInUse);

        return;

        }

    if(FatType() == EFat12)

        {//-- Fat12 doesn't support this feature; do nothing other than notify the underlying drive (ignoring any error for now as there's nothing we can do with it)

		(void)LocalDrive()->Finalise(aClean);

        return;

        }

    //-- further read and write will be directly from the CProxyDrive, bypassing FAT cache. 

    //-- this is because CFatTable doesn't allow access to FAT[0] & FAT[1]

    //-- We also need to write data through CProxyDrive, because TDriveInterface has a call back that can call this method

    if(Is32BitFat())

        {//-- Fat32

		__PRINT2(_L("#- CFatMountCB::SetVolumeCleanL, drive:%d, param:%d, FAT32"),DriveNumber(), aClean);

        TFat32Entry fatEntry;

        const TInt  KFatEntrySize=sizeof(fatEntry); //-- FAT entry size in bytes

        TPtr8       ptrFatEntry((TUint8*)&fatEntry,KFatEntrySize);

        User::LeaveIfError(LocalDrive()->Read(StartOfFatInBytes()+KFatEntrySize, KFatEntrySize, ptrFatEntry)); //read FAT32[1] entry

        const TFat32Entry tmp = fatEntry;

        if(aClean)

            fatEntry |= KFat32CleanShutDownMask;  //-- set ClnShutBit flag

        else

            fatEntry &= ~KFat32CleanShutDownMask; //-- reset ClnShutBit flag

        if(tmp != fatEntry)

            {//-- write FAT[1] entry to all available FATs

                for(TUint32 i=0; i<NumberOfFats(); ++i)

                {

                const TInt64 pos = StartOfFatInBytes()+KFatEntrySize+(FatSizeInBytes()*i);

                User::LeaveIfError(LocalDrive()->Write(pos, ptrFatEntry)); //write FAT32[1] entry

                }

            }

        __PRINT2(_L("#- CFatMountCB::SetVolumeCleanL() entry:  %x->%x"), tmp, fatEntry);

        }

    else 

    if(Is16BitFat())

        {//-- Fat16. 

            __PRINT2(_L("#- CFatMountCB::SetVolumeCleanL, drive:%d, param:%d, FAT16"),DriveNumber(), aClean);

            if(FatConfig().FAT16_UseCleanShutDownBit())

                {

            TFat16Entry fatEntry;

            const TInt  KFatEntrySize=sizeof(fatEntry); //-- FAT entry size in bytes

            TPtr8       ptrFatEntry((TUint8*)&fatEntry,KFatEntrySize);

            User::LeaveIfError(LocalDrive()->Read(StartOfFatInBytes()+KFatEntrySize, KFatEntrySize, ptrFatEntry)); //read FAT16[1] entry

            const TFat16Entry tmp = fatEntry;

            if(aClean)

                fatEntry |= KFat16CleanShutDownMask;  //-- set ClnShutBit flag

            else

                fatEntry &= ~KFat16CleanShutDownMask; //-- reset ClnShutBit flag

            if(tmp != fatEntry)

                {//-- write FAT[1] entry to all available FATs

                for(TUint32 i=0; i<NumberOfFats(); ++i)

                    {

                    const TInt64 pos = StartOfFatInBytes()+KFatEntrySize+(FatSizeInBytes()*i);

                    User::LeaveIfError(LocalDrive()->Write(pos, ptrFatEntry)); //write FAT16[1] entry

                    }

                }

            __PRINT2(_L("#- CFatMountCB::SetVolumeCleanL() entry:  %x->%x"), tmp, fatEntry);    

            }

            else

            {

            __PRINT(_L("#- changing FAT16[1] is disabled in config!"));    

            }

        }

    else

        {//-- must never get here

        ASSERT(0);

        }

		//-- Notify the underlying media that the mount is consistent  (ignoring any error for now as there's nothing we can do with it)

		(void)LocalDrive()->Finalise(aClean);

    }

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

/**

Determine whether "VolumeClean" (ClnShutBitmask) flag is set.

@return ETrue if the volume is marked as clean and EFalse otherwise.

@leave  if is called for FAT12 or if read error occured.

*/

TBool CFatMountCB::VolumeCleanL() 

    {

    //-- read access to the FAT is through TDriveInterface, because CFatTable doesn't allow access to FAT[1]

    TDriveInterface& drive =DriveInterface();

    if(Is32BitFat())

        {//-- Fat32

        TFat32Entry fatEntry;

        const TInt  KFatEntrySize=sizeof(fatEntry); //-- FAT entry size in bytes

        TPtr8       ptrFatEntry((TUint8*)&fatEntry, KFatEntrySize);

        User::LeaveIfError(drive.ReadNonCritical(StartOfFatInBytes()+KFatEntrySize, KFatEntrySize, ptrFatEntry)); //read FAT32[1] entry

        return (fatEntry & KFat32CleanShutDownMask);

        }

    else 

    if(Is16BitFat())

        {//-- Fat16

        TFat16Entry fatEntry;

        const TInt  KFatEntrySize=sizeof(fatEntry); //-- FAT entry size in bytes

        TPtr8       ptrFatEntry((TUint8*)&fatEntry, KFatEntrySize);

        User::LeaveIfError(drive.ReadNonCritical(StartOfFatInBytes()+KFatEntrySize, KFatEntrySize, ptrFatEntry)); //read FAT16[1] entry

        return (fatEntry & KFat16CleanShutDownMask);

        }

    else

        {//-- Fat12 doesn't support this feature, shan't get here, actually

        ASSERT(0);

        User::Leave(KErrNotSupported);

        return ETrue; //-- to satisfy the compiler

        }

    }

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

/**

Mount a Fat volume. 

@param aForceMount Flag to indicate whether mount should be forced to succeed if an error occurs

@leave KErrNoMemory,KErrNotReady,KErrCorrupt,KErrUnknown.

*/

void CFatMountCB::MountL(TBool aForceMount)

	{

    const TInt driveNo = Drive().DriveNumber();

    __PRINT3(_L("CFatMountCB::MountL() drv:%d, forceMount=%d, RuggedFAT:%d\n"), driveNo, aForceMount, IsRuggedFSys());

    ASSERT(State() == ENotMounted || State() == EDismounted);

    SetState(EMounting);

    SetReadOnly(EFalse);

	User::LeaveIfError(CreateDrive(driveNo));

    //-- read FAT configuration parameters from estart.txt

    iFatConfig.ReadConfig(driveNo);

    //-- initialise interface to the low-level drive access

    if(!iDriverInterface.Init(this))

        User::LeaveIfError(KErrNoMemory);    

	//-- get drive capabilities

    TLocalDriveCapsV2Buf capsBuf;

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

    iSize=capsBuf().iSize;

    iRamDrive = EFalse;

    if(capsBuf().iMediaAtt & KMediaAttVariableSize)

    {//-- this is a RAM drive

        UserSvr::UnlockRamDrive();

        iRamDrive = ETrue;

    }

	if(aForceMount)

	{//-- the state is "forcedly mounted", special case. This is an inconsistent state.

        SetState(EInit_Forced);  

    	return;

    }

    //-- read boot sector. If main is damaged, try to use backup one instead if this is not a RAM drive.

    TFatBootSector bootSector;

    User::LeaveIfError(ReadBootSector(bootSector, iRamDrive));

    //-- print out boot sector debug information

    bootSector.PrintDebugInfo();

    //-- determine FAT type by data from boot sector. This is done by counting number of clusters, not by BPB_RootEntCnt

    SetFatType(bootSector.FatType());

    ASSERT(iFatType != EInvalid); //-- this shall be checked in ReadBootSector()

    if(bootSector.RootDirEntries() == 0 && !Is32BitFat())

    {//-- FAT types mismatch. BPB_RootEntCnt is 0, which can be only for FAT32, but the number of clusters is less 

     //-- than required for FAT32. Probably this is incorrectly FAT32 formatted media. Put the drive into ReadOnly mode, assuming

     //-- that is FAT32.

        __PRINT(_L("FAT type mismatch! Setting drive to ReadOnly mode for FAT32. \n"));

        SetFatType(EFat32); //-- force FAT type to be FAT32

        SetReadOnly(ETrue);

    }

    //-- store volume UID, it can be checked on Remount

    iUniqueID = bootSector.UniqueID();

    //-- populate volume parameters with the values from boot sector. They had been validated in TFatBootSector::IsValid()

    iVolParam.Populate(bootSector); 

    //-- initialize the volume

    InitializeL(capsBuf());

    ASSERT(State()==EInit_R);

    GetVolumeLabelFromDiskL(bootSector);

	__PRINT2(_L("CFatMountCB::MountL() Completed, drv: %d, state:%d"), DriveNumber(), State());

	}

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

/**

Initialize the FAT cache and disk access

@param  aLocDrvCaps local drive capabilities

@param  aIgnoreFSInfo if ETrue, FSInfo sector shall be ignored. Used on volume remount to force FAT free clusters counting.

@leave KErrNoMemory,KErrNotReady,KErrCorrupt,KErrUnknown.

*/

void CFatMountCB::InitializeL(const TLocalDriveCaps& aLocDrvCaps, TBool aIgnoreFSInfo/*=EFalse*/) 

	{

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

    ASSERT(State() == EMounting); //-- we must get here only from MountL()

    //========== Find out number of clusters on the volume

	if(iRamDrive && SectorsPerCluster()!=1)

		{// Align iFirstFreeByte to cluster boundary if internal ram drive

		const TInt sectorsPerClusterLog2=ClusterSizeLog2()-SectorSizeLog2();

		const TInt rootDirEndSector=RootDirEnd()>>SectorSizeLog2();

		const TInt alignedSector=((rootDirEndSector+SectorsPerCluster()-1)>>sectorsPerClusterLog2)<<sectorsPerClusterLog2;

		iFirstFreeByte=alignedSector<<SectorSizeLog2();

		}

	else

		{

		if(Is32BitFat())

			iFirstFreeByte=(NumberOfFats() * FatSizeInBytes()) + (FirstFatSector() << SectorSizeLog2());

		else

			iFirstFreeByte=RootDirEnd();

		}

	    {//-- check if volume geometry looks valid

        const TUint32 usableSectors = TotalSectors()-(iFirstFreeByte>>SectorSizeLog2());

	    iUsableClusters=usableSectors>>(ClusterSizeLog2()-SectorSizeLog2());

        const TUint32 KMinClusters = 32; //-- absolute minimum number of clusters on the volume

        const TUint32 KMaxClusters=(TotalSectors()-FirstFatSector()-NumberOfFats()*(FatSizeInBytes()>>SectorSizeLog2())) >> (ClusterSizeLog2()-SectorSizeLog2());

        if(iUsableClusters < KMinClusters || iUsableClusters > KMaxClusters)

            {

            __PRINT(_L("CFatMountCB::InitializeL() Wrong number of usable cluster/sectors on the volume!"));

            User::Leave(KErrCorrupt);

            }

        }

	//========== initialise RawDisk interface

	//-- CFatMountCB parameters might have changed, e.g. after formatting. Reconstruct directory cache with new parameters

    delete iRawDisk;

    iRawDisk = NULL;

	iRawDisk=CRawDisk::NewL(*this, aLocDrvCaps);

    iRawDisk->InitializeL();

    //========== Try to read FSInfo and deduct number of free clusters and other information from there

    TBool   bUseDataFromFsInfo = !aIgnoreFSInfo && Is32BitFat(); //-- if ETrue, we are going to use data from FSInfo sector (applicable for FAT32 only)

    //-- main boot sector shall be valid, otherwise we can't trust data from FSInfo

    bUseDataFromFsInfo = bUseDataFromFsInfo && iMainBootSecValid;

    //-- 1. check if using FSInfo is disabled in config

    if(bUseDataFromFsInfo && !FatConfig().FAT32_UseFSInfoOnMount())

    {

        __PRINT(_L("#- FSInfo using is disabled in config!"));

        bUseDataFromFsInfo = EFalse;

    }

#ifdef  _DEBUG

    //-- 2. check if FSInfo is disabled by test interface (special debug property). This property is defined and set by the test application.

    TInt nMntDebugFlags;

    if(bUseDataFromFsInfo && RProperty::Get(KSID_Test1, DriveNumber(), nMntDebugFlags) == KErrNone)

        {//-- test property for this drive is defined

            if(nMntDebugFlags & KMntDisable_FsInfo)

            {

            __PRINT(_L("#- FSInfo using is disabled by debug interface."));

            bUseDataFromFsInfo = EFalse;

            }

        }

#endif