// 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;
}