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

// f32test\server\t_mount.cpp

// Testing some issues connected with mounting/dismounting file fystems, drives finalisation etc.

//

//

/**

 @file

*/

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <e32math.h>

#include <e32property.h>

#include <f32dbg.h>

#include "t_server.h"

#include "fat_utils.h"

using namespace Fat_Test_Utils;

#ifdef __VC32__

    // Solve compilation problem caused by non-English locale

    #pragma setlocale("english")

#endif

RTest test(_L("T_Mount"));

static TInt     gDriveNum=-1; ///< drive number we are dealing with

static TInt64   gRndSeed;

const TInt KBM_Repetitions = 5;     ///< number of repetitions for BM testing

const TUint32 KCheckFileSize = 533; ///< size of the small file to be deleted

_LIT(KFileNameFirst,  "\\FIRST%d.DAT");

_LIT(KFileNameMiddle, "\\MID%d.DAT");

_LIT(KFileNameLast,   "\\LAST%d.DAT");

_LIT(KFileNameFiller, "\\FILL%d.DAT");

typedef void (*TStressFN)(TInt);    //-- pointer to the FAT mount stress function

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

//-- debug bit flags that may be set in the property which controls FAT volume mounting

const TUid KThisTestSID={0x10210EB3}; ///< this EXE SID

const TUint32 KMntProp_EnableALL    = 0x00000000; //-- enable all operations

#ifdef _DEBUG

const TUint32 KMntProp_DisableALL   = 0xFFFFFFFF; //-- disable all operations

const TUint32 KMntProp_Disable_FsInfo       = 0x00000001; //-- mask for disabling/enabling FSInfo information

const TUint32 KMntProp_Disable_FatBkGndScan = 0x00000002; //-- mask for disabling/enabling FAT background scanner

#endif

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

/** set a debug property value, which then wiil be read by FAT fsy */

void SetFsyDebugFlag(TInt aDriveNo, TUint32 aFlags)

{

    TInt nRes;

    nRes = RProperty::Set(KThisTestSID, aDriveNo, aFlags);

    test_KErrNone(nRes);

}

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

/**

    format the volume and read the boot sector

*/

static void FormatVolume(TBool aQuickFormat)

{

    TInt nRes;

    #if 0

    //-- FAT32 SPC:1; for the FAT32 testing on the emulator

    (void)aQuickFormat;

    #ifdef  __EPOC32__

    test.Printf(_L("This is emulator configuration!!!!\n"));

    test(0);

    #endif

    TFatFormatParam fp;

    fp.iFatType = EFat32;

    fp.iSecPerCluster = 1;

    nRes = FormatFatDrive(TheFs, CurrentDrive(), ETrue, &fp); //-- always quick; doesn't matter for the emulator

    #else

    nRes = FormatFatDrive(TheFs, CurrentDrive(), aQuickFormat);

    #endif

    test_KErrNone(nRes);

}

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

/**

    Prepare FAT volume for mounting performance testing

    1. quick format the drive

    2. create KBM_Repetitions files in the beginning (first files)

    3. create KMaxFillFiles/2 large files (they take about 40% of the volume);

    4. create KBM_Repetitions files (middle files)

    5. create KMaxFillFiles/2 large files (they take other 40% of the volume);

    6. create KBM_Repetitions files (last files)

    @return ETrue if everythis is OK

*/

TBool PrepareVolumeForBM()

{

    test.Printf(_L("Prepare the volume for BM testing...\n"));

    TInt nRes;

    TInt i;

    //-- 1. quick format the drive

    FormatVolume(ETrue);

    if(!Is_Fat32(TheFs, gDriveNum))

    {

        test.Printf(_L("This test requires FAT32 ! Skipping.\n"));

        return EFalse;

    }

    TVolumeInfo volInfo;

    nRes = TheFs.Volume(volInfo, gDriveNum);

    test_KErrNone(nRes);

    //-- the files will take 80% of the drive space

    const TInt    KMaxFillFiles = 100;

    const TUint32 KFillFileSz = (TUint32)((volInfo.iFree*8) / (10*KMaxFillFiles));

    //-- 2. create KBM_Repetitions files in the very begining (occupies first FAT entries)

    TBuf<64> buf;

    for(i=0; i<KBM_Repetitions; ++i)

    {

        buf.Format(KFileNameFirst, i);

        nRes = CreateCheckableStuffedFile(TheFs, buf, KCheckFileSize);

        test_KErrNone(nRes);

    }

    //-- 3. Fill the FAT with entries and cteate a file in the middle

    const TInt nHalf1 = KMaxFillFiles / 2;

    for(i=0; i<nHalf1; ++i)

    {

        buf.Format(KFileNameFiller, i);

        nRes = CreateEmptyFile(TheFs, buf, KFillFileSz);

        test_KErrNone(nRes);

    }

    //-- 4. create a files in the middle

    for(i=0; i<KBM_Repetitions; ++i)

    {

        buf.Format(KFileNameMiddle, i);

        nRes = CreateCheckableStuffedFile(TheFs, buf, KCheckFileSize);

        test_KErrNone(nRes);

    }

    //-- 5. fill second half FAT

    for(i=nHalf1; i<KMaxFillFiles; ++i)

    {

        buf.Format(KFileNameFiller, i);

        nRes = CreateEmptyFile(TheFs, buf, KFillFileSz);

        test_KErrNone(nRes);

    }

    //-- 6. create files in the very end (occupiy last FAT entries)

    for(i=0; i<KBM_Repetitions; ++i)

    {

        buf.Format(KFileNameLast, i);

        nRes = CreateCheckableStuffedFile(TheFs, buf, KCheckFileSize);

        test_KErrNone(nRes);

    }

    return ETrue;

}

/**

    Mounts and dismounts FAT volume several times calculating average time taken to mount.

    Also can stress FS by calling stress function that can do some work on the volume.

    @param  apStressFN pointer to the stressing function which can be called just after mounting. Can be NULL.

    @return time in milliseconds taken to mout the volume

*/

static TUint32 DoMeasureMountTime(TStressFN apStressFN)

{

    TInt nRes;

    TTime   timeStart;

    TTime   timeEnd;

    TInt64   usMountTime=0;      //-- total time taken by "Mount"

    //-- disable FAT test utils print out, it can affects measured time

    EnablePrintOutput(EFalse);

    for(TInt i=0; i<KBM_Repetitions; ++i)

    {

        //-- A. remount FS taking the time when mounting starts

        nRes = RemountFS(TheFs, gDriveNum, &timeStart);

        test_KErrNone(nRes);

        //-- B. call a given stress function

        if(apStressFN)

            apStressFN(i);

        //-- C. take end time

        timeEnd.UniversalTime();

        test_KErrNone(nRes);

        usMountTime += (timeEnd.MicroSecondsFrom(timeStart)).Int64();

     }

    const TUint32 msMountTime = (TUint32)usMountTime / (K1mSec*KBM_Repetitions);

    EnablePrintOutput(ETrue); //-- Enable FAT test utils print out

    return msMountTime;

}

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

/**

    Stress function.

    Use case: read access to the first file on the volume in root dir.

*/

static void FirstReadAccess_FirstFile_Stress(TInt aRepNo)

{

    TBuf<64> buf;

    buf.Format(KFileNameFirst, aRepNo);

    TInt nRes = VerifyCheckableFile(TheFs, buf);

    test_KErrNone(nRes);

}

/**

    Stress function.

    Use case: read access to the middle file on the volume in root dir.

*/

static void FirstReadAccess_MiddleFile_Stress(TInt aRepNo)

{

    TBuf<64> buf;

    buf.Format(KFileNameMiddle, aRepNo);

    TInt nRes = VerifyCheckableFile(TheFs, buf);

    test_KErrNone(nRes);

}

/**

    Stress function.

    Use case: read access to the last file on the volume in root dir.

*/

static void FirstReadAccess_LastFile_Stress(TInt aRepNo)

{

    TBuf<64> buf;

    buf.Format(KFileNameLast, aRepNo);

    TInt nRes = VerifyCheckableFile(TheFs, buf);

    test_KErrNone(nRes);

}

/**

    Stress function.

    Use case: Getting volume information SYNCHRONOUSLY.

*/

static void GetVolInfo_Synch_Stress(TInt)

{

    TVolumeInfo volInfo;

    TInt nRes = TheFs.Volume(volInfo, gDriveNum);

    test_KErrNone(nRes);

}

/**

    Stress function.

    Use case: Getting volume information _ASYNCHRONOUSLY_, i.e. do not wait until

    FAT32 free space scan thread finishes

*/

static void GetVolInfo_Asynch_Stress(TInt)

{

    TVolumeInfo volInfo;

    //-- let's use special version of the RFS API

    TRequestStatus rqStat;

    TheFs.Volume(volInfo, gDriveNum, rqStat);

    User::WaitForRequest(rqStat);

    test(rqStat.Int()==KErrNone);

}

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

/**

    Stress function.

    Use case: deletes files in the beginning of the volume (or FAT table)

*/

static void DeleteFirstFile_Stress(TInt aRepNo)

{

    TBuf<64> buf;

    buf.Format(KFileNameFirst, aRepNo);

    TInt nRes = TheFs.Delete(buf);

    test_KErrNone(nRes);

}

/**

    Stress function.

    Use case: deletes files in the middle of the volume (or FAT table)

*/

static void DeleteMiddleFile_Stress(TInt aRepNo)

{

    TBuf<64> buf;

    buf.Format(KFileNameMiddle, aRepNo);

    TInt nRes = TheFs.Delete(buf);

    test_KErrNone(nRes);

}

/**

    Stress function.

    Use case: deletes files in the end of the volume (or FAT table)

*/

static void DeleteLastFile_Stress(TInt aRepNo)

{

    TBuf<64> buf;

    buf.Format(KFileNameLast, aRepNo);

    TInt nRes = TheFs.Delete(buf);

    test_KErrNone(nRes);

}

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

/**

    perform series of tests that measure and print out FAT volume mount time for different secenarios

*/

void MeasureMountTime()

{

    TUint32 msTime;

    if(!PrepareVolumeForBM()) //-- prepare the volume for BM tests: format it, create file structure etc.

        return;

    //-- 1. no stress function, measure just pure mount time

    msTime = DoMeasureMountTime(NULL);

    test.Printf(_L("#--> Pure mount:%d ms\n"), msTime);

    //-- 2.1 measure mount time with a read-acess to the first file on the volume

    msTime = DoMeasureMountTime(FirstReadAccess_FirstFile_Stress);

    test.Printf(_L("#--> mount and read access to 1st file:%d ms\n"), msTime);

    //-- 2.2 measure mount time with a read-acess to the middle file on the volume

    msTime = DoMeasureMountTime(FirstReadAccess_MiddleFile_Stress);

    test.Printf(_L("#--> mount and read access to middle file:%d ms\n"), msTime);

    //-- 2.3 measure mount time with a read-acess to the last file on the volume

    msTime = DoMeasureMountTime(FirstReadAccess_LastFile_Stress);

    test.Printf(_L("#--> mount and read access to last file:%d ms\n"), msTime);

    //-- 2.4 measure mount time with getting a volume information

    msTime = DoMeasureMountTime(GetVolInfo_Synch_Stress);

    test.Printf(_L("#--> mount and getting volInfo (synch):%d ms\n"), msTime);

    msTime = DoMeasureMountTime(GetVolInfo_Asynch_Stress);

    test.Printf(_L("#--> mount and getting volInfo (Asynch):%d ms\n"), msTime);

    //-- 2.4 measure mount time with deleting file in the beginning (write access to the first entries of the FAT32)

    msTime = DoMeasureMountTime(DeleteFirstFile_Stress);

    test.Printf(_L("#--> mount and delete first file:%d ms\n"), msTime);

    //-- 2.5 measure mount time with deleting file in the middle (write access to the middle entries of the FAT32)

    msTime = DoMeasureMountTime(DeleteMiddleFile_Stress);

    test.Printf(_L("#--> mount and delete middle file:%d ms\n"), msTime);

    //-- 2.6 measure mount time with deleting file in the end (write access to the last entries of the FAT32)

    msTime = DoMeasureMountTime(DeleteLastFile_Stress);

    test.Printf(_L("#--> mount and delete last file:%d ms\n"), msTime);

    test.Printf(_L("---\n"), msTime);

}

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

//! @SYMTestCaseID      PBASE-T_MOUNT-0521

//! @SYMTestType        PT

//! @SYMPREQ            PREQ1721

//! @SYMTestCaseDesc    Testing FAT volume mount performance for various scenarios

//!

//! @SYMTestActions

//!             0   Prepare the volume by formatting it and creating 100 files to occupy the space.

//!             1   Turn OFF all mount enhancements

//!             2   Measure and print out volume mount time for the next scenarios:

//!                   a.  simple mount

//!                   b.  mount and read access to the media (reading the last file in the root dir.)

//!                   c.  mount and write access to the media (writing data into the last file in the root dir)

//!                   d.  mount getting volume information

//!

//!

//!             3     Turn ON using FSInfo.

//!             4     Repeat step 2 for this case.

//! @SYMTestExpectedResults Finishes ok.

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

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

void TestFAT_Mounting_Performance()

{

    test.Next(_L("\n#--> Measuring FAT volumes mount performance.\n"));

#ifndef _DEBUG

    test.Printf(_L("Skipping the test in the Release build! \n"));

    return;

#else

   //-- 1. turn OFF all mount enhancements like using FSInfo, backround FAT scan etc.

   test.Printf(_L("#--> ==== All mount enhancements are disabled ====\n"));

   SetFsyDebugFlag(gDriveNum, KMntProp_DisableALL);

   MeasureMountTime();

   //-- 2. Turn ON using FSInfo

   test.Printf(_L("#--> ==== Enabled Using FSInfo ====\n"));

   SetFsyDebugFlag(gDriveNum, KMntProp_DisableALL & ~KMntProp_Disable_FsInfo);

   MeasureMountTime();

   //-- 2. Turn OFF using FSInfo and ON FAT32 bacground scanning

   test.Printf(_L("#--> ==== Enabled FAT32 BkGnd scan, FSInfo disabled ====\n"));

   SetFsyDebugFlag(gDriveNum, KMntProp_DisableALL & ~KMntProp_Disable_FatBkGndScan);

   MeasureMountTime();

   //-- restore mounting mechanism

   SetFsyDebugFlag(gDriveNum, KMntProp_EnableALL);

#endif //_DEBUG

}

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

/**

    Check if the drive aDriveNo is finalised or not.

    The "CleanShutDown" is obtained by QueryVolumeInfoExt API and by reading 2 FATs directly with checking their consistence.

    @param  aDriveNo drive number to query.

    @return ETrue if the drive if finalised

*/

static TBool DoCheckVolumeFinalised(TInt aDriveNo)

{

    TInt nRes;

    TPckgBuf<TBool> boolPckg;

    //-- 1. get "Finalised" state by using the API

    nRes = TheFs.QueryVolumeInfoExt(aDriveNo, EIsDriveFinalised, boolPckg);

    test_KErrNone(nRes);

    //-- N.B. for FAT12 the result can be either OK or "NotSupported"

    //-- If FAT12 is in explicit "finalised" state, the result will be OK

    //-- if not, we can't query the volume state, because FAT12 doesn't support flags in FAT[1]

    const TBool bFinalised_From_API = boolPckg() >0;

          TBool bFinalised_From_FAT1 = bFinalised_From_API;

    TBuf8<32> fatBuf(32);

    TFatBootSector  bootSec;

    const TUint32 posMainBootSec = KBootSectorNum << KDefaultSectorLog2;

    nRes = ReadBootSector(TheFs, gDriveNum, posMainBootSec, bootSec);

    test_KErrNone(nRes);

    test(bootSec.IsValid());

    const TUint32 Fat1StartPos = bootSec.FirstFatSector() * bootSec.BytesPerSector();

    if(bootSec.FatType() == EFat16)

    {//-- FAT16

        TUint16 fatEntry;

        const TUint16 KClnShtdnMask = 0x8000; //-- "ClnShutBitMask", see FAT specs

        //-- read "CleanShutDown" flag directly from the 1st FAT

        nRes = MediaRawRead(TheFs, gDriveNum, Fat1StartPos, fatBuf.Size(), fatBuf);

        test_KErrNone(nRes);

        Mem::Copy(&fatEntry, (fatBuf.Ptr()+sizeof(fatEntry)), sizeof(fatEntry));

        bFinalised_From_FAT1 = (fatEntry & KClnShtdnMask) >0;

        for(TInt i=1; i<bootSec.NumberOfFats(); ++i)

        {

            //-- read a flag from the next FAT

            const TUint32 currFatStartPos = (bootSec.FirstFatSector() + i*bootSec.TotalFatSectors())*bootSec.BytesPerSector();

            nRes = MediaRawRead(TheFs, gDriveNum, currFatStartPos, fatBuf.Size(), fatBuf);

            test_KErrNone(nRes);

            Mem::Copy(&fatEntry, (fatBuf.Ptr()+sizeof(fatEntry)), sizeof(fatEntry));

            const TBool bFinalised_From_currFAT = (fatEntry & KClnShtdnMask)>0;

            test(bFinalised_From_currFAT == bFinalised_From_FAT1);

        }

    }

    else if(bootSec.FatType() == EFat32)

    {//-- FAT32