// Copyright (c) 1995-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\sfile\sf_fmt.cpp

 // 

 //

 #include "sf_std.h"

 LOCAL_C CFormatCB* GetFormatFromHandle(TInt aHandle,CSessionFs* aSession)

 //

 // Get the format control block from aHandle

 //

 	{

 	return((CFormatCB*)(SessionObjectFromHandle(aHandle,Formats->UniqueID(),aSession)));

 	}

 /**

 Default constructor.

 */

 EXPORT_C CFormatCB::CFormatCB()

 	{

 	}

 /**

     Destructor.

     Frees resources before destruction of the object.

 */

 EXPORT_C CFormatCB::~CFormatCB()

 	{

 	if (iMount)

 		{

 		RemoveDiskAccess(*iMount);

 		iMount->Drive().SetChanged(ETrue);

 		iMount->Close();

 		}

 	}

 /**

     Checks that the disk media is still mounted.

     @return KErrNone if the media is still mounted; KErrDisMounted otherwise.

 */

 EXPORT_C TInt CFormatCB::CheckMount()

 	{

 	TDrive& d=Drive();

 	TInt r=d.CheckMount();

 	if (r!=KErrNone)

 		return(r);

 	if (&Mount()!=&d.CurrentMount())

 		return(KErrDisMounted);

 	return(KErrNone);

 	}

 void CFormatCB::InitL(TDrive* aDrive,TFormatMode aMode)

 	{

 	DoInitL(aDrive->DriveNumber());

 	iDrive=aDrive;

 	iMount=&iDrive->CurrentMount();

 	iMode=aMode;

 	User::LeaveIfError(iMount->Open());

 	}

 EXPORT_C TInt CFormatCB::GetInterface(TInt /*aInterfaceId*/,TAny*& /*aInterface*/,TAny* /*aInput*/)

 	{

 	return(KErrNotSupported);

 	}

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

 /** 

     set volume formatting parameters, which are provided in TLDFormatInfo structure 

     @param  apLDFormatInfo  pointer to the parameters structure. If NULL, iSpecialInfo will be initialised

 */

 void CFormatCB::SetFormatParameters(const TLDFormatInfo* apLDFormatInfo)

     {

     TLDFormatInfo& fmtInfo = iSpecialInfo();

     if(!apLDFormatInfo)

         {//-- special meaning; invalidate iSpecialInfo by setting its package size as 0

         iSpecialInfo.SetLength(0);

         }

     else

         {

         Mem::Copy(&fmtInfo, apLDFormatInfo, sizeof(TLDFormatInfo));

         }

     }

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

 /** set volume formatting parameters, which are provided in TVolFormatParam structure */

 TInt CFormatCB::SetFormatParameters(const TVolFormatParam* apVolFormatParam)

     {

     ASSERT(apVolFormatParam);

     TAny* dummy;

     //-- push parameters to the particular implementation of the CFormatCB. Default behaviour: KErrNotSupported

     return GetInterface(ESetFmtParameters, dummy, (TAny*)apVolFormatParam);

     }

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

 #ifdef _DEBUG

 #define DUMP_OPENED_OBJECTS

 #endif

 /**

     Debug helper method. Dumps names of opened files and directories on this drive

     define DUMP_OPENED_OBJECTS to have it called

 */

 #ifdef DUMP_OPENED_OBJECTS

 static void DumpOpenedObjects(TDrive& aDrive)

     {

         {//-- 1. files 

         const TInt nFiles = Files->Count();

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

             {

             CFileCB* pFile=(CFileCB*)(*Files)[i];

             if(pFile->Drive().DriveNumber() == aDrive.DriveNumber())

                 {

                 __PRINT1(_L("FsFormatOpen() opened file:'%S'"), &pFile->FileName());

                 }

             }

         }

         {//-- 2. directories; CDirCB doesn't have associated name.

         const TInt nDirs = Dirs->Count();

         TInt cntDirs = 0;

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

             {

             CDirCB* pDir = (CDirCB*)(*Dirs)[i];

             if(pDir->Drive().DriveNumber() == aDrive.DriveNumber())

                 {

                 ++cntDirs;

                 }

             }

         if(cntDirs)

             {

             __PRINT1(_L("FsFormatOpen() opened directories:%d"), cntDirs);

             }

         }

     }

 #endif //DUMP_OPENED_OBJECTS

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

 /**

     Open a drive for formatting.

 */

 TInt FsFormatOpen(CFsRequest* aRequest)

 	{

     TDrive& drive = *aRequest->Drive();

 	__PRINT1(_L("FsFormatOpen() drv:%d"), drive.DriveNumber());

     TInt nMountRes = drive.CheckMount();

     //-- KErrNotReady means that there is no file system mounted on this drive

     //-- KErrInUse means that there are some "disk access" objects, like RFormat or RRawDisk opened on the mount.

     if(nMountRes == KErrNotReady || nMountRes == KErrInUse) 

         {

         __PRINT1(_L("FsFormatOpen() ChkMount:%d"), nMountRes);

         return nMountRes;

         }

     const TFormatMode fmtMode = (TFormatMode)aRequest->Message().Int1();

     TName buf;

     TUint32 currFsNameHash = 0; //-- current file system name hash, 0 means "not set"; used during forced FS dismounting

     if((nMountRes == KErrNone) && drive.CurrentMount().LockStatus() < 0)

         {//-- the mount is locked, it has normal objects (files, directories) opened on it. 

         //-- if someone is interested in the list of opened files and number of opened directories, compile this code in.

         #ifdef DUMP_OPENED_OBJECTS

             DumpOpenedObjects(drive);

         #endif //DUMP_OPENED_OBJECTS

         if(!(fmtMode & EForceFormat))

             {

             __PRINT(_L("FsFormatOpen() The mount is in use"));

             return KErrInUse;

             }    

         //-- there is a special flag that tells to force media dismounting even if it has files or dirs opened.

         __PRINT(_L("FsFormatOpen() The mount is in use, forcing dismounting!"));

         //-- record currently mounted FS name hash, it may be used after forced dismounting

         drive.CurrentMount().FileSystemName(buf); //-- the iCurrentMount is alive

         currFsNameHash = TVolFormatParam::CalcFSNameHash(buf);

         //-- kill the current mount

         FsThreadManager::LockDrive(drive.DriveNumber());

         TInt nRes = drive.ForceUnmountFileSystemForFormatting();

         FsThreadManager::UnlockDrive(drive.DriveNumber());

         switch(nRes)

             {

             case KErrInUse: 

             __PRINT(_L("FsFormatOpen() The mount has clamps! Can't force dismount"));    

             return KErrInUse; //-- there are clamps on this drive - can't dismount

             case KErrNone:

             break;

             default:

             ASSERT(0); //-- unexpected error code

             return nRes;

             };

         if(fmtMode & EQuickFormat)

             {//-- quick format may require the normally mounted FS, make the best effrot to mount it

             nMountRes = drive.CheckMount();

             }

         else

             {//-- this will make the FS mounted by force; for full format it will be quicker

             nMountRes = KErrCorrupt;

             }

         }

 	//-- if True, we will need mount (probably specific) file system by force because normal mounting has failed

     TBool bNeedForceMount = (nMountRes != KErrNone); 

     //-- find out if we have optional data structure that describes format parameter

     TUint32 newFsNameHash = 0; //-- file system name hash, may be used for selecting which file system to put onto the volume. 0 means "not specified"

     const TLDFormatInfo*    pLDFormatInfo   = NULL;

     const TVolFormatParam*  pVolFormatParam = NULL;

     __ASSERT_COMPILE(sizeof(TVolFormatParam) >= sizeof(TLDFormatInfo));

     TBuf8<sizeof(TVolFormatParam)> paramBuf;

     if(fmtMode & ESpecialFormat)  

         {   

         //-- the user has provided format parameters structure.

         //-- IPC argument #2 contains a structure: <TUint32>[optional package descriptor]

         //-- where 1st mandatory TUint32 is a pointer to format counter and the optional additional package is a data structure passed to the filesystem by the client of RFormat

         const TInt desLen = aRequest->GetDesLength(KMsgPtr2);

         ASSERT((TUint32)desLen >= sizeof(TUint32));

         const TInt dataPckgLen = desLen - sizeof(TUint32);

         if((TUint32)dataPckgLen > sizeof(TUint32))

             {

             aRequest->ReadL(KMsgPtr2, paramBuf); 

             }

         if(dataPckgLen == sizeof(TLDFormatInfo))

             {//-- the user has provided formatting parameters via TLDFormatInfo structure.

             pLDFormatInfo = (const TLDFormatInfo*)(paramBuf.Ptr() + sizeof(TUint32));

             }

         else if(dataPckgLen == sizeof(TVolFormatParam))

             {//-- it's likely to be TVolFormatParam, need to check UId to be sure.

             pVolFormatParam = (const TVolFormatParam*)(const TVolFormatParam*)(paramBuf.Ptr() + sizeof(TUint32));

             if(pVolFormatParam->iUId == TVolFormatParam::KUId)  //-- check the class UID

                 {//-- this is the real TVolFormatParam object passed

                 newFsNameHash = pVolFormatParam->FSNameHash();

                 }

             }

         else if(dataPckgLen >0)

             {//-- parameters data structure has strange length

             return KErrArgument;

             }

         }

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

     if(!newFsNameHash && currFsNameHash)

         {//-- new file system name isn't specified (default formatting), but the volume had been forcedly dismounted.

          //-- restore the original file system   

         newFsNameHash = currFsNameHash;

         }

     if(newFsNameHash)

         {//-- check if the specified FS is already mounted on the volume

         if(!bNeedForceMount)

             {

             drive.CurrentMount().FileSystemName(buf); //-- the iCurrentMount is alive

             }

         else

             { //-- the iCurrentMount can be NULL, use the iFsys - the real file system associated with this drive

             buf = drive.GetFSys()->Name();

             }

         const TUint32 currFSNameHash = TVolFormatParam::CalcFSNameHash(buf);

         if(currFSNameHash == newFsNameHash)

             {//-- no need to do anything, the required FS is already mounted

             newFsNameHash = 0; 

             } 

         }

     if(newFsNameHash) 

         {

         //-- the user has specified some filesystem to be mounted on the volume. Check if this FS is supported at all.

         //-- if it is supported, but some other FS is currently mounted, it will be dismounted and the new one will be forced.

         TInt nRes;

         for(TInt cntFS=0; ;++cntFS)

             {

             nRes = drive.FSys().GetSupportedFileSystemName(cntFS, buf); //-- enumerate possible child file systems

             if(nRes != KErrNone)

                 return KErrNotSupported; //-- the filesystem with the given name (fsNameHash) is not supported.

             if(newFsNameHash == TVolFormatParam::CalcFSNameHash(buf))

                 {//-- the filesystem with the given name (fsNameHash) is supported, but some other filesystem can be already mounted

                 drive.Dismount();

                 bNeedForceMount = ETrue; //-- this will force the desired FS to be mounted

                 break;

                 }

             }

         }//if(fsNameHash) 

     //-- try force mounting the desired file system if it is required

     if(bNeedForceMount)

         {

         const TInt KMaxRetries = 3;

         for(TInt cnt=0; ; ++cnt)

             {

             drive.MountFileSystem(ETrue, newFsNameHash);

             nMountRes = drive.GetReason();

             if(nMountRes == KErrNone || nMountRes == KErrLocked)

                 break;

             drive.Dismount(); //-- will reset mount retries counter

             if(cnt >= KMaxRetries)

                 {

                 __PRINT1(_L("FsFormatOpen() can't mount FS! res:%d"), nMountRes);    

                 return nMountRes;

                 }

             }

         }

     ASSERT(nMountRes == KErrNone || nMountRes == KErrLocked);

     __ASSERT_DEBUG(drive.CurrentMount().LockStatus()==0, Fault(ESvrFormatOpenFailed));

 	TDriveInfo dInfo;

 	drive.DriveInfo(dInfo);

 	const TInt mediaAtt = dInfo.iMediaAtt;

 #if defined(_LOCKABLE_MEDIA)

 	if (!(fmtMode & EForceErase) && (mediaAtt & KMediaAttLocked))

 		{

 		// if attempting to format a locked drive, dismount otherwise subsequent 

 		// requests will operate on a mount that has been forcibly mounted (a few lines above)

 		CMountCB* pM = &drive.CurrentMount();

         if(pM)

 			pM->Close();

 		drive.MountFileSystem(EFalse);	// clear iCurrentMount

 		return KErrLocked;

 		}

 #endif

 	if (!(mediaAtt & KMediaAttFormattable) || (mediaAtt & KMediaAttWriteProtected))

 		{

 		CMountCB* pM = &drive.CurrentMount();

         if(pM)

 			pM->Close();

 		drive.MountFileSystem(EFalse);

         return KErrAccessDenied;

 		}

 	//-- instantinate and open CFormatCB object for this drive

     CFormatCB* formatCB=NULL;

 	TInt fmtHandle;

     TRAPD(ret, formatCB = drive.FormatOpenL(aRequest, fmtHandle, fmtMode, pLDFormatInfo, pVolFormatParam ));

 	if (ret!=KErrNone)

 		{

 		if(formatCB)

 			formatCB->Close();

 		return ret;

 		}

 	TPtrC8 pH((TUint8*)&fmtHandle,sizeof(TInt));

 	aRequest->WriteL(KMsgPtr3,pH);

 	TInt count=100;

 	TPtrC8 pCount((TUint8*)&count,sizeof(TInt));

 	aRequest->WriteL(KMsgPtr2,pCount);

 	aRequest->Session()->IncResourceCount();

     return KErrNone;

 	}

 TInt TFsFormatOpen::DoRequestL(CFsRequest* aRequest)

 //

 // Open a drive for formatting.

 //

 	{

 	// Can not format if any files are clamped

 	TInt r=FsFormatOpen(aRequest);

 	return r;

 	}

 TInt TFsFormatOpen::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	TInt r;

 	if (!KCapFsFormatOpen.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Format Open")))

 		return KErrPermissionDenied;

 	r=ParseNoWildSubstPtr0(aRequest,aRequest->Src());

 	if (r!=KErrNone)

 		return(r);

 	if (aRequest->Src().NameOrExtPresent())

 		return(KErrBadName);

 	if (aRequest->SubstedDrive())

 		return(KErrAccessDenied);

 	return(r);

 	}

 TInt TFsFormatNext::DoRequestL(CFsRequest* aRequest)

 //

 // Format the next part of the media.

 //

 	{

 	__PRINT1(_L("TFsFormatNext::DoRequestL() drv:%d"), aRequest->DriveNumber());

 	CFormatCB* format=(CFormatCB*)aRequest->ScratchValue();

 	TInt r=format->CheckMount();

 	if (r!=KErrNone && r!=KErrInUse)

         {

     	__PRINT1(_L("TFsFormatNext::DoRequestL() err:%d"), r);

         return r;

         }

 	TPtr8 pStep((TUint8*)&format->CurrentStep(),sizeof(TInt));

 	aRequest->ReadL(KMsgPtr0,pStep);

 	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFormatCBDoFormatStepL, EF32TraceUidFileSys, format);

 	TRAP(r,format->DoFormatStepL());

 	TRACERET2(UTF::EBorder, UTraceModuleFileSys::ECFormatCBDoFormatStepLRet, EF32TraceUidFileSys, r, format->CurrentStep());

 	if (r==KErrNone)

 		aRequest->WriteL(KMsgPtr0,pStep);

 	if (r==KErrNone && format->CurrentStep()==0)

 		{

 		FsNotify::DiskChange(aRequest->DriveNumber());

 		}

 	return(r);

 	}

 TInt TFsFormatNext::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	if (!KCapFsFormatNext.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Format Next")))

 		return KErrPermissionDenied;

 	CFormatCB* format;

 	format=GetFormatFromHandle(aRequest->Message().Int3(), aRequest->Session());

 	if(!format)

 		return(KErrBadHandle);	

 	aRequest->SetDrive(&format->Drive());

 	aRequest->SetScratchValue((TUint)format);

 	return KErrNone;

 	}