MCL/sf/os/kernelhwsrv: comparison userlibandfileserver/fileserver/sfile/sf

equal deleted inserted replaced

-:c1f20ce4abcf
+:3e88ff8f41d5
 //
 //
 #include "sf_std.h"
 #include "sf_file_cache.h"
-#ifdef OST_TRACE_COMPILER_IN_USE
-#include "sf_drvTraces.h"
-#endif
 //const TInt KMaxNotifierAttempts=4; // not used anywhere
 static TPtrC StripBackSlash(const TDesC& aName)
 //
 // If aName ends in a backslash, strip it.
 	iReason=KErrNone;
 	if (!aMount.IsDismounted() && !aMount.ProxyDriveDismounted())
 		{
 		aMount.SetDrive(this);
-		OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBREMOUNT1, "drive %d", DriveNumber());
+		TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBReMount, EF32TraceUidFileSys, DriveNumber());
 //-- actually, this is asking CMountCB to see if it belongs to the current media.
 iReason = aMount.ReMount();
-		OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBREMOUNT1RET, "success %d", iReason);
+		TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBReMountRet, EF32TraceUidFileSys, iReason);
 if (iReason == KErrNone)	//	ReMount succeeded
 			{
 			aMount.Open();
 			iCurrentMount = &aMount;
 	{
 	CFileSystem* pMountsFs = NULL; //-- reference to the filesystem that will be producing CMountCB
 apMount = NULL;
-OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTL, "this %x drive %d", (TUint) &FSys(), (TUint) DriveNumber());
+TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountL, EF32TraceUidFileSys, &FSys(), DriveNumber());
 //-- construct a new CmountCB object.
 //-- on return pMountsFs will be the pointer to the factory object of CFileSystem that produced this mount
 apMount = FSys().NewMountExL(this, &pMountsFs, aForceMount, aFsNameHash);
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTLRET, "r %d CMountCB %x", (TUint) KErrNone, (TUint) apMount);
+	TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountLRet, EF32TraceUidFileSys, KErrNone, apMount);
 	__PRINT2(_L("TDrive::MountMediaL created mount:0x%x FileSys:0x%x"), apMount, pMountsFs);
 ASSERT(pMountsFs && apMount);
 	apMount->SetMountNumber(iMountNumber++);
 @return standard error code.
 */
 TInt TDrive::MountControl(TInt aLevel, TInt aOption, TAny* aParam)
 {
-	OstTraceExt4(TRACE_FILESYSTEM, FSYS_ECMOUNTCBMOUNTCONTROL, "drive %d aLevel %d aOption %x aParam %x", (TUint) DriveNumber(), (TUint) aLevel, (TUint) aOption, (TUint) aParam);
+	TRACE4(UTF::EBorder, UTraceModuleFileSys::ECMountCBMountControl, EF32TraceUidFileSys, DriveNumber(), aLevel, aOption, aParam);
 TInt r = CurrentMount().MountControl(aLevel, aOption, aParam);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBMountControlRet, EF32TraceUidFileSys, r);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBMOUNTCONTROLRET, "r %d", r);
 	return r;
 }
 //----------------------------------------------------------------------------
 /**
 //-- 1. Try mount-specific request first. If the mount is still performing free space calculations,
 //-- the caller will be suspended until aFreeSpaceRequired bytes is available or scanning process finishes
 {
 TUint64 freeSpaceReq = aFreeSpaceRequired;
-		OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBFREESPACE, "drive %d", DriveNumber());
+		TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBFreeSpace, EF32TraceUidFileSys, DriveNumber());
 nRes = CurrentMount().RequestFreeSpace(freeSpaceReq);
-		OstTraceExt3(TRACE_FILESYSTEM, FSYS_ECMOUNTCBFREESPACERET, "r %d FreeSpace %x:%x", (TUint) nRes, (TUint) I64HIGH(freeSpaceReq), (TUint) I64LOW(freeSpaceReq));
+		TRACERET3(UTF::EBorder, UTraceModuleFileSys::ECMountCBFreeSpaceRet, EF32TraceUidFileSys, nRes, I64LOW(freeSpaceReq), I64HIGH(freeSpaceReq));
 if(nRes == KErrNone)
 {
 return (freeSpaceReq >= aFreeSpaceRequired) ? KErrNone : KErrDiskFull;
 }
 }
 TInt nRes;
 nRes = CheckMount();
 if(nRes != KErrNone)
 return nRes;
 //-- 1. Try mount-specific request first. It won't block this call as CMountCB::VolumeL() can do if some background activity is going on the mount
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBVOLUMESIZE, "drive %d", DriveNumber());
+	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBVolumeSize, EF32TraceUidFileSys, DriveNumber());
 nRes = CurrentMount().MountedVolumeSize(aSize);
-	OstTraceExt3(TRACE_FILESYSTEM, FSYS_ECMOUNTCBVOLUMESIZERET, "r %d aSize %x:%x", (TUint) nRes, (TUint) I64HIGH(aSize), (TUint) I64LOW(aSize));
+	TRACERET3(UTF::EBorder, UTraceModuleFileSys::ECMountCBVolumeSize, EF32TraceUidFileSys, nRes, I64LOW(aSize), I64HIGH(aSize));
 if(nRes == KErrNone)
 return nRes;
 //-- given Mount doesn't support this functionality, use legacy method
 TVolumeInfo volInfo;
 nRes = CheckMount();
 if(nRes != KErrNone)
 return nRes;
 //-- 1. Try mount-specific request first. It won't block this call as CMountCB::VolumeL() can do
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBCURRENTFREESPACE, "drive %d", DriveNumber());
+	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBCurrentFreeSpace, EF32TraceUidFileSys, DriveNumber());
 nRes = CurrentMount().GetCurrentFreeSpaceAvailable(aFreeDiskSpace);
-	OstTraceExt3(TRACE_FILESYSTEM, FSYS_ECMOUNTCBCURRENTFREESPACERET, "r %d FreeSpace %x:%x", (TUint) nRes, (TUint) I64HIGH(aFreeDiskSpace), (TUint) I64LOW(aFreeDiskSpace));
+	TRACERET3(UTF::EBorder, UTraceModuleFileSys::ECMountCBCurrentFreeSpaceRet, EF32TraceUidFileSys, nRes, I64LOW(aFreeDiskSpace), I64HIGH(aFreeDiskSpace));
 if(nRes == KErrNone)
 return nRes;
 //-- given Mount doesn't support this functionality, use legacy method
 TVolumeInfo volInfo;
 		return(r);
 	if(IsWriteProtected())
 		return(KErrAccessDenied);
-	OstTraceExt4(TRACE_FILESYSTEM, FSYS_ECMOUNTCBFINALISEMOUNT2, "drive %d aOperation %d aParam1 %x aParam2 %x", (TUint) DriveNumber(), (TUint) aOperation, (TUint) aParam1, (TUint) aParam2);
+	TRACE4(UTF::EBorder, UTraceModuleFileSys::ECMountCBFinaliseMount2, EF32TraceUidFileSys, DriveNumber(), aOperation, aParam1, aParam2);
 	TRAP(r,CurrentMount().FinaliseMountL(aOperation, aParam1, aParam2));
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBFINALISEMOUNT2RET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBFinaliseMount2Ret, EF32TraceUidFileSys, r);
 	// Pass FinaliseDrive notification down to media driver
 	TInt driveNumber = DriveNumber();
 	if (LocalDrives::IsValidDriveMapping(driveNumber) && !LocalDrives::IsProxyDrive(driveNumber))
 		{
 		return(r);
 	if(IsWriteProtected())
 		return(KErrAccessDenied);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBFINALISEMOUNT1, "drive %d", DriveNumber());
+	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBFinaliseMount1, EF32TraceUidFileSys, DriveNumber());
 	TRAP(r,CurrentMount().FinaliseMountL());
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBFinaliseMount1Ret, EF32TraceUidFileSys, r);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBFINALISEMOUNT1RET, "r %d", r);
 return r;
 	}
 TInt TDrive::ValidateShare(CFileCB& aFile, TShare aReqShare)
 //
 // Check that the sharing rules are obeyed.
 //
 	{
-	// Check the correct share modes are passed in
 	switch (aReqShare)
 		{
 	case EFileShareExclusive:
 	case EFileShareReadersOnly:
 	case EFileShareAny:
 	case EFileShareReadersOrWriters:
 		break;
 	default:
-		return KErrArgument;
+		return(KErrArgument);
 		}
-	// Check the share mode of the file
 	switch (aFile.iShare)
 		{
 	case EFileShareExclusive:
-		return KErrInUse;
+		return(KErrInUse);
 	case EFileShareReadersOnly:
 	case EFileShareAny:
 		if (aReqShare != aFile.iShare && aReqShare != EFileShareReadersOrWriters)
-		    {
+			return(KErrInUse);
-return KErrInUse;
-		    }
 		break;
 	case EFileShareReadersOrWriters:
-		if (aReqShare == EFileShareExclusive)
+		if (aReqShare==EFileShareExclusive)
-		    {
+			return(KErrInUse);
-return KErrInUse;
-		    }
 		//
-		// If the file is currently opened as EFileShareReadersOrWriters then
+		// If the file is currently open as EFileShareReadersOrWriters then
 		// promote the share to the requested share mode.
-		//
-		// If the requested share is EFileShareReadersOnly, verify that no
-		// other share has the file opened for writing.
 		//
+		// If the requested share is EFileShareReadersOnly, verfiy that no
+		// other share has the file open for writing.
+		//
 		if (aReqShare == EFileShareReadersOnly)
 			{
-			TDblQueIter<CFileShare> fileShareIter(aFile.FileShareList());
+			FileShares->Lock();
-			CFileShare* pFileShare;
+			TInt count = FileShares->Count();
-			while ((pFileShare = fileShareIter++) != NULL)
+			while(count--)
 				{
-				if(pFileShare->iMode & EFileWrite)
+				CFileShare* share = (CFileShare*)(*FileShares)[count];
+				if (&share->File() == &aFile)
 					{
-					return KErrInUse;
+					if(share->iMode & EFileWrite)
+						{
+						FileShares->Unlock();
+						return KErrInUse;
+						}
 					}
 				}
+			FileShares->Unlock();
 			}
 		break;
 	default:
 		Fault(EDrvIllegalShareValue);
 break;
 		}
+	return(KErrNone);
-	return KErrNone;
+	}
-	}
 void TDrive::DriveInfo(TDriveInfo& anInfo)
 //
 // Get the drive info.
 //
 	{
 	anInfo.iBattery=EBatNotSupported;
 anInfo.iConnectionBusType=EConnectionBusInternal;
 	if(iFSys)
 		{
-		OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMDRIVEINFO, "this %x aDriveNumber %d", (TUint) &FSys(), (TUint) DriveNumber());
+		TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemDriveInfo, EF32TraceUidFileSys, &FSys(), DriveNumber());
 		FSys().DriveInfo(anInfo,DriveNumber());
-		OstTraceExt3(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMDRIVEINFORET, "type %d driveAtt %x mediaAtt %x", (TUint) anInfo.iType, (TUint) anInfo.iDriveAtt, (TUint) anInfo.iMediaAtt);
+		TRACE3(UTF::EBorder, UTraceModuleFileSys::ECFileSystemDriveInfoRet, EF32TraceUidFileSys,
+			anInfo.iType, anInfo.iDriveAtt, anInfo.iMediaAtt);
 		}
 	anInfo.iDriveAtt=Att();
 	}
 		CMountCB& m=CurrentMount();
 		aVolume.iName=m.VolumeName();
 		aVolume.iUniqueID=m.iUniqueID;
 		aVolume.iSize=m.iSize;
-		OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBVOLUMEL, "drive %d", DriveNumber());
+		TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBVolumeL, EF32TraceUidFileSys, DriveNumber());
 		TRAP(r,m.VolumeL(aVolume))
-		OstTraceExt5(TRACE_FILESYSTEM, FSYS_ECMOUNTCBVOLUMELRETA, "r %d iSize %x:%x iFree %x:%x", (TUint) r, (TUint) I64HIGH(aVolume.iSize), (TUint) I64LOW(aVolume.iSize), (TUint) I64HIGH(aVolume.iFree), (TUint) I64LOW(aVolume.iFree));
+		TRACE7(UTF::EBorder, UTraceModuleFileSys::ECMountCBVolumeLRet, EF32TraceUidFileSys,
-		OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECMOUNTCBVOLUMELRETB, "iUniqueID %x iFileCacheFlags %x", (TUint) aVolume.iUniqueID, (TUint) aVolume.iFileCacheFlags);
+			r, aVolume.iUniqueID, I64LOW(aVolume.iSize), I64HIGH(aVolume.iSize),
+			I64LOW(aVolume.iFree), I64HIGH(aVolume.iFree), aVolume.iFileCacheFlags);
 		}
 	return(r);
 	}
 //
 	{
 	__CHECK_DRIVETHREAD(iDriveNumber);
 	aBuf=aName.AllocL();
 	TPtr volumeName=aBuf->Des();
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBSETVOLUMEL, "drive %d", DriveNumber());
-	OstTraceData(TRACE_FILESYSTEM, FSYS_EVOLUMENAME, "VolumeName %S", aName.Ptr(), aName.Length()<<1);
+	TRACEMULT2(UTF::EBorder, UTraceModuleFileSys::ECMountCBSetVolumeL, EF32TraceUidFileSys, DriveNumber(), aName);
 	CurrentMount().SetVolumeL(volumeName);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBSETVOLUMELRET, "r %d", KErrNone);
+	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBSetVolumeLRet, EF32TraceUidFileSys, KErrNone);
 	delete &CurrentMount().VolumeName();
 	CurrentMount().SetVolumeName(aBuf);
 	}
 TInt TDrive::SetVolume(const TDesC& aName)
 		return(r);
 	if(IsWriteProtected())
 		return(KErrAccessDenied);
 	TParse newDirName;
 	newDirName.Set(aName,NULL,NULL);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBMKDIRL, "drive %d", DriveNumber());
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBMKDIRLYS_EDIRNAME, "Dir %S", aName.Ptr(), aName.Length()<<1);
+	TRACEMULT2(UTF::EBorder, UTraceModuleFileSys::ECMountCBMkDirL, EF32TraceUidFileSys, DriveNumber(), aName);
 	TRAP(r,CurrentMount().MkDirL(newDirName.FullName()))
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBMKDIRLRET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBMkDirLRet, EF32TraceUidFileSys, r);
 	return(r);
 	}
 TInt TDrive::RmDir(const TDesC& aName)
 //
 // Remove a directory.
 //
 	{
 		return(r);
 	if (entry.IsDir()==EFalse)
 		return(KErrPathNotFound);
 	if ((entry.iAtt&KEntryAttReadOnly) || IsWriteProtected())
 		return(KErrAccessDenied);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBRMDIRL, "drive %d", DriveNumber());
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBRMDIRLYS_EDIRNAME, "Dir %S", aName.Ptr(), aName.Length()<<1);
+	TRACEMULT2(UTF::EBorder, UTraceModuleFileSys::ECMountCBRmDirL, EF32TraceUidFileSys, DriveNumber(), aName);
 	TRAP(r,CurrentMount().RmDirL(aName))
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBRMDIRLRET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBRmDirLRet, EF32TraceUidFileSys, r);
 	return(r);
 	}
 /*
 Delete files allowing wild cards.
 	// remove from closed queue - NB this isn't strictly necessary if file is read-only or write-protected...
 	LocateClosedFile(aName, EFalse);
 if (IsWriteProtected())
 		return(KErrAccessDenied);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBDELETEL1, "drive %d", DriveNumber());
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBDELETEL1_EFILENAME, "FileName %S", aName.Ptr(), aName.Length()<<1);
+//-- filesystems' CMountCB::DeleteL() implementations shall check the entry attributes themeselves.
+	TRACEMULT2(UTF::EBorder, UTraceModuleFileSys::ECMountCBDeleteL, EF32TraceUidFileSys, DriveNumber(), aName);
 	TRAP(r,CurrentMount().DeleteL(aName))
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBDELETEL1_RET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBDeleteLRet, EF32TraceUidFileSys, r);
 	return r;
 	}
 TInt TDrive::CheckMountAndEntryNames(const TDesC& anOldName,const TDesC& aNewName)
 //
 		return(KErrAccessDenied);
 	// remove from closed queue
 	LocateClosedFile(anOldName, EFalse);
 	LocateClosedFile(aNewName, EFalse);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBRENAMEL, "drive %d", DriveNumber());
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBRENAMELYS_EOLDNAME, "OldName %S", oldEntryName.Ptr(), oldEntryName.Length()<<1);
+	TRACEMULT3(UTF::EBorder, UTraceModuleFileSys::ECMountCBRenameL, EF32TraceUidFileSys, DriveNumber(), oldEntryName,newEntryName);
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBRENAMELYS_ENEWNAME, "NewName %S", newEntryName.Ptr(), newEntryName.Length()<<1);
 	TRAP(r,CurrentMount().RenameL(oldEntryName,newEntryName))
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBRENAMELRET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBRenameLRet, EF32TraceUidFileSys, r);
 	return(r);
 	}
 TInt TDrive::Replace(const TDesC& anOldName,const TDesC& aNewName)
 //
 		return(KErrInUse);
 	// remove from closed queue
 	LocateClosedFile(anOldName, EFalse);
 	LocateClosedFile(aNewName, EFalse);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBREPLACEL, "drive %d", DriveNumber());
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBREPLACEL_EOLDNAME, "OldName %S", anOldName.Ptr(), anOldName.Length()<<1);
+	TRACEMULT3(UTF::EBorder, UTraceModuleFileSys::ECMountCBReplaceL, EF32TraceUidFileSys, DriveNumber(), anOldName, aNewName);
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBREPLACEL_ENEWNAME, "NewName %S", aNewName.Ptr(), aNewName.Length()<<1);
 	TRAP(r,CurrentMount().ReplaceL(anOldName,aNewName))
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBREPLACELRET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBReplaceLRet, EF32TraceUidFileSys, r);
 	return(r);
 	}
 TInt TDrive::Entry(const TDesC& aName,TEntry& anEntry)
 //
 void TDrive::DoEntryL(const TDesC& aName, TEntry& anEntry)
 //
 // Get entry details
 //
 	{
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBENTRYL, "drive %d", DriveNumber());
+	TRACEMULT2(UTF::EBorder, UTraceModuleFileSys::ECMountCBEntryL, EF32TraceUidFileSys, DriveNumber(), aName);
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBENTRYL_EFILEPATH, "FilePath %S", aName.Ptr(), aName.Length()<<1);
 	CurrentMount().EntryL(aName,anEntry);
 	// If the file is already open then read the file attributes directly from the file
 	TFileName foldedName;
 	TUint32 nameHash=0;
 			break;
 			}
 		}
-	OstTraceExt5(TRACE_FILESYSTEM, FSYS_ECMOUNTCBENTRYLRET, "att %x modified %x:%x  size %x:%x", (TUint) anEntry.iAtt, (TUint) I64HIGH(anEntry.iModified.Int64()), (TUint) I64LOW(anEntry.iModified.Int64()), (TUint) I64HIGH(anEntry.FileSize()), (TUint) anEntry.FileSize());
+	TRACE5(UTF::EBorder, UTraceModuleFileSys::ECMountCBEntryLRet, EF32TraceUidFileSys,
+		KErrNone, anEntry.iAtt,
+		I64LOW(anEntry.iModified.Int64()), I64HIGH(anEntry.iModified.Int64()),
+		anEntry.iSize);
 	}
 TInt TDrive::CheckAttributes(TUint& aSetAttMask,TUint& aClearAttMask)
 //
 // Validate the changes against the current entry attributes
 	if (IsWriteProtected())
 		return(KErrAccessDenied);
 	TTime nullTime(0);
 	if (aTime!=nullTime)
 		aSetAttMask|=KEntryAttModified;
-	OstTraceExt5(TRACE_FILESYSTEM, FSYS_ECMOUNTCBSETENTRYL, "drive %d aTime %x:%x  aSetAttMask %x aClearAttMask %x", (TUint) DriveNumber(), (TUint) I64HIGH(aTime.Int64()), (TUint) I64LOW(aTime.Int64()), (TUint) aSetAttMask, (TUint) aClearAttMask);
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBSETENTRYL_EFILEPATH, "FilePath %S", aName.Ptr(), aName.Length()<<1);
+	TRACEMULT6(UTF::EBorder, UTraceModuleFileSys::ECMountCBSetEntryL, EF32TraceUidFileSys,
+		DriveNumber(), aName, I64LOW(aTime.Int64()), I64HIGH(aTime.Int64()), aSetAttMask, aClearAttMask);
 	TRAP(r,CurrentMount().SetEntryL(entryName,aTime,aSetAttMask,aClearAttMask))
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBSETENTRYLRET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBSetEntryLRet, EF32TraceUidFileSys, r);
 	// If the file is already open then write the file attributes directly to the file
 	TFileName foldedName;
 	TUint32 nameHash=0;
 	foldedName.CopyF(aName);
 	nameHash=CalcNameHash(foldedName);
 	// Only allow delete on close for a newly created file.
 	if ((aMode & EDeleteOnClose) && (anOpen!=EFileCreate))
 		User::Leave(KErrArgument);
-	CFileCB* pFile=LocateFile(aName);
+	CFileCB* pF=LocateFile(aName);
 	CFileCache* pFileCache = NULL;
-	TBool openFile=EFalse;	// True if file is being opened for the first time
+	TBool openFile=EFalse;
-	if (pFile!=NULL)		// File is already opened on the drive
+	if (pF!=NULL)
 		{
-		if (pFile->iShare==EFileShareReadersOnly && (aMode&EFileWrite))
+		if (pF->iShare==EFileShareReadersOnly && (aMode&EFileWrite)!=0)
 			User::Leave(KErrInUse);
 		if (anOpen==EFileCreate)
 			User::Leave(KErrAlreadyExists);
-		TInt r=ValidateShare(*pFile,share);
+		TInt r=ValidateShare(*pF,share);
 		if (r!=KErrNone)
 			User::Leave(r);
-		if ((r=pFile->Open())!=KErrNone)
+		if ((r=pF->Open())!=KErrNone)
 			User::Leave(r);
+		aFileCB=pF;
-		aFileCB=pFile;
+		pFileCache = pF->FileCache();
-		pFileCache = pFile->FileCache();
 		}
 	else
 		{
-		OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWFILEL, "this %x drive %d", (TUint) &FSys(), (TUint) DriveNumber());
+		TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewFileL, EF32TraceUidFileSys, &FSys(), DriveNumber());
 //-- construct CFileCB object, belonging to the corresponding mount
-pFile = aFileCB = CurrentMount().NewFileL();
+pF = aFileCB = CurrentMount().NewFileL();
-		OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWFILELRET, "r %d CFileCB %x", (TUint) r, (TUint) pFile);
+		TRACERET2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewFileLRet, EF32TraceUidFileSys, r, pF);
 		TDrive* createdDrive=!aRequest->SubstedDrive() ? this : aRequest->SubstedDrive();
 	HBufC* fileName = CreateFileNameL(aName);
-pFile->InitL(this, createdDrive, fileName);
+pF->InitL(this, createdDrive, fileName);
-		pFile->iShare = share;
-		pFile->SetSequentialMode(aMode & EFileSequential);
+		pF->iShare = share;
 		openFile=ETrue;
-		CurrentMount().iMountQ.AddLast(*pFile);
+		CurrentMount().iMountQ.AddLast(*pF);
-		Files->AddL(pFile,ETrue);
+		Files->AddL(pF,ETrue);
-		__PRINT1(_L("TDrive::FileOpenL - CFileCB->IsSequentialMode = %d"), pFile->IsSequentialMode());
 		}
-CFileShare* pFileShare=aFileShare=new(ELeave) CFileShare(pFile);
+CFileShare* pS=aFileShare=new(ELeave) CFileShare(pF);
 	// We need to call CFileCB::PromoteShare immediately after the CFileShare
 	// instance is created since the destructor calls CFileCB::DemoteShare()
 	// which checks the share count is non-zero
-	pFileShare->iMode=aMode;
+	pS->iMode=aMode;
-	pFile->PromoteShare(pFileShare);
+	pF->PromoteShare(pS);
-	pFileShare->InitL();
+	pS->InitL();
 	aFileCB=NULL;
-	FileShares->AddL(pFileShare,ETrue);
+	FileShares->AddL(pS,ETrue);
-	aHandle=aRequest->Session()->Handles().AddL(pFileShare,ETrue);
+	aHandle=aRequest->Session()->Handles().AddL(pS,ETrue);
 	if (openFile)
 		{
-		OstTraceExt4(TRACE_FILESYSTEM, FSYS_ECMOUNTCBFILEOPENL, "drive %d aMode %x anOpen %d aFile %x", (TUint) DriveNumber(), (TUint) aMode, (TUint) anOpen, (TUint) pFile);
+		TRACEMULT5(UTF::EBorder, UTraceModuleFileSys::ECMountCBFileOpenL, EF32TraceUidFileSys, DriveNumber(), aName, aMode, (TUint) anOpen, (TUint) pF);
-		OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBFILEOPENL_EFILENAME, "FileName %S", aName.Ptr(), aName.Length()<<1);
+		CurrentMount().FileOpenL(aName,aMode,anOpen,pF);
-		CurrentMount().FileOpenL(aName,aMode,anOpen,pFile);
+		TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBFileOpenLRet, EF32TraceUidFileSys, KErrNone);
-		OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBFILEOPENLRET, "r %d", KErrNone);
 		// Delete on close may now be safely flagged if required.
 		// The file did not exist on the media prior to the
 		// CMountCB::FileOpenL() call for the case of a create.
 		if ((aMode & EDeleteOnClose) && (anOpen==EFileCreate))
-			pFile->SetDeleteOnClose();
+			pF->SetDeleteOnClose();
-		TBool localBufferSuppport = (CurrentMount().LocalBufferSupport(pFile) == KErrNone)?(TBool)ETrue:(TBool)EFalse;
+		TBool localBufferSuppport = (CurrentMount().LocalBufferSupport(pF) == KErrNone)?(TBool)ETrue:(TBool)EFalse;
-		pFile->SetLocalBufferSupport(localBufferSuppport);
+		pF->SetLocalBufferSupport(localBufferSuppport);
 		if (localBufferSuppport)
 			{
-			// If file exists on closed queue resurrect it or discard it,
+			// if file exists on closed queue resurrect it or discard it,
 			// depending on the file open mode
 			pFileCache = LocateClosedFile(aName, anOpen == EFileOpen?(TBool)ETrue:(TBool)EFalse);
 			if (pFileCache)
 				{
-				pFileCache = pFileCache->ReNewL(*pFileShare);	// NB may return NULL if caching not enabled
+				pFileCache = pFileCache->ReNewL(*pS);	// NB may return NULL if caching not enabled
 				}
 			else
 				{
-				pFileCache = CFileCache::NewL(*pFileShare);		// NB may return NULL if caching not enabled
+				pFileCache = CFileCache::NewL(*pS);		// NB may return NULL if caching not enabled
 				}
 			if (pFileCache)
-				// Set the cached size to be the same as the uncached size
+				// set the cached size to be the same as the uncached size
-				pFile->SetCachedSize64(pFile->Size64());
+				pF->SetCachedSize64(pF->Size64());
 			}
 		else
 			{
 			__CACHE_PRINT(_L("TDrive::FileOpenL(), Local buffers not supported"));
 			}
 		}
-	// Initialize share mode flags
+	// initialize share mode flags
 	if (pFileCache != NULL)
-		pFileCache->Init(*pFileShare);
+		pFileCache->Init(*pS);
 	}
 TInt TDrive::FileOpen(CFsRequest* aRequest,TInt& aHandle,const TDesC& aName,TUint aMode,TFileOpen anOpen)
 //
 // Open/Create/Replace a file.
 	{
 	__CHECK_DRIVETHREAD(iDriveNumber);
 	CFileCB* pF=NULL;
 	CFileShare* pS=NULL;
 	aHandle=0;
-	TRAPD(r,FileOpenL(aRequest,aHandle,aName,aMode,anOpen,pF,pS));
+	TRAPD(r,FileOpenL(aRequest,aHandle,aName,aMode,anOpen,pF,pS))
 	// Allow files > 2GB-1 to be opened only if EFileBigFile is specified in iMode
 	if (r == KErrNone && pS && ((TUint64)pS->File().Size64() > KMaxLegacyFileSize) && (!(pS->IsFileModeBig())))
 		r = KErrTooBig;
 void TDrive::DirOpenL(CSessionFs* aSession,TInt& aHandle,const TDesC& aName,TUint anAtt,const TUidType& aUidType,CDirCB*& aDir)
 //
 // Open a directory listing. Leave on error.
 //
 	{
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWDIRL, "this %x drive %d", (TUint) &FSys(), (TUint) DriveNumber());
+	TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewDirL, EF32TraceUidFileSys, &FSys(), DriveNumber());
 CDirCB* pD = aDir = CurrentMount().NewDirL(); //-- construct CDirCB object, belonging to the corresponding mount
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWDIRLRET, "r %d CDirCB %x", (TUint) KErrNone, (TUint) pD);
+	TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewDirLRet, EF32TraceUidFileSys, KErrNone, pD);
 	pD->InitL(this);
 	// modify resource counter after initialisation to ensure correct cleanup
 	AddResource(CurrentMount());
 	pD->iAtt=anAtt;
 	pD->iUidType=aUidType;
 	Dirs->AddL(pD,ETrue);
 	aHandle=aSession->Handles().AddL(pD,ETrue);
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECMOUNTCBDIROPENL, "drive %d aDir %x", (TUint) DriveNumber(), (TUint) pD);
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBDIROPENL_EDIRNAME, "Dir %S", aName.Ptr(), aName.Length()<<1);
+	TRACEMULT3(UTF::EBorder, UTraceModuleFileSys::ECMountCBDirOpenL, EF32TraceUidFileSys, DriveNumber(), aName, (TUint) pD);
 	CurrentMount().DirOpenL(aName,pD);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBDIROPENLRET, "r %d", KErrNone);
+	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBDirOpenLRet, EF32TraceUidFileSys, KErrNone);
 	}
 TInt TDrive::DirOpen(CSessionFs* aSession,TInt& aHandle,const TDesC& aName,TUint anAtt,const TUidType& aUidType)
 //
 // Open a directory listing.
 	__PRINT(_L("TDrive::ReadSection"));
 	TInt r=CheckMountAndEntryName(aName);
 	if (r!=KErrNone)
 		return(r);
 	TPtrC entryName(StripBackSlash(aName));
 	TRACETHREADID(aMessage);
-	OstTraceExt5(TRACE_FILESYSTEM, FSYS_ECMOUNTCBREADFILESECTIONL, "drive %d clientThreadId %x aPos %x:%x aLength %d", (TUint) DriveNumber(), (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), (TUint) aLength);
+	TRACEMULT7(UTF::EBorder, UTraceModuleFileSys::ECMountCBReadFileSectionL, EF32TraceUidFileSys,
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBREADFILESECTIONL_EFILENAME, "FileName %S", aName.Ptr(), aName.Length()<<1);
+		DriveNumber(), aName, I64LOW(aPos), I64HIGH(aPos), (TUint) aTrg, aLength, I64LOW(threadId));
 	TRAP(r,ReadSectionL(entryName,aPos,aTrg,aLength,aMessage));
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBREADFILESECTIONLRET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBReadFileSectionLRet, EF32TraceUidFileSys, r);
 	if (r==KErrHidden)
 		r=KErrNotFound;
 	else if (r==KErrPathHidden)
 		r=KErrPathNotFound;
 	TInt r=CheckMount();
 	if (r==KErrNone)
 		TRAP(r,FlushCachedFileInfoL());
 	if (r==KErrNone)
 		{
-		OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBCHECKDISK1, "drive %d", DriveNumber());
+		TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBCheckDisk1, EF32TraceUidFileSys, DriveNumber());
 		r=CurrentMount().CheckDisk();
-		OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBCHECKDISK1RET, "r %d", r);
+		TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBCheckDisk1Ret, EF32TraceUidFileSys, r);
 		}
 	return(r);
 	}
 /**
 	TInt r=CheckMount();
 	if (r==KErrNone)
 		TRAP(r,FlushCachedFileInfoL());
 	if (r==KErrNone)
 		{
-		OstTraceExt4(TRACE_FILESYSTEM, FSYS_ECMOUNTCBCHECKDISK2, "drive %d aOperation %d aParam1 %x aParam2 %x", (TUint) DriveNumber(), (TUint) aOperation, (TUint) aParam1, (TUint) aParam2);
+		TRACE4(UTF::EBorder, UTraceModuleFileSys::ECMountCBCheckDisk2, EF32TraceUidFileSys, DriveNumber(), aOperation, aParam1, aParam2);
 		r=CurrentMount().CheckDisk(aOperation, aParam1, aParam2);
-		OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBCHECKDISK2RET, "r %d", r);
+		TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBCheckDisk2Ret, EF32TraceUidFileSys, r);
 		}
 	return(r);
 }
 		return r;
 	// Empty closed file queue
 	TClosedFileUtils::Remove(DriveNumber());
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBSCANDRIVE1, "drive %d", DriveNumber());
+	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBScanDrive1, EF32TraceUidFileSys, DriveNumber());
 	r = CurrentMount().ScanDrive();
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBSCANDRIVE1RET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBScanDrive1Ret, EF32TraceUidFileSys, r);
 	return r;
 	}
 /**
 		return r;
 	// Empty closed file queue
 	TClosedFileUtils::Remove(DriveNumber());
-	OstTraceExt4(TRACE_FILESYSTEM, FSYS_ECMOUNTCBSCANDRIVE2, "drive %d aOperation %d aParam1 %x aParam2 %x", (TUint) DriveNumber(), (TUint) aOperation, (TUint) aParam1, (TUint) aParam2);
+	TRACE4(UTF::EBorder, UTraceModuleFileSys::ECMountCBScanDrive2, EF32TraceUidFileSys, DriveNumber(), aOperation, aParam1, aParam2);
 	r = CurrentMount().ScanDrive(aOperation, aParam1, aParam2);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBSCANDRIVE2RET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBScanDrive2Ret, EF32TraceUidFileSys, r);
 	return r;
 	}
 TInt TDrive::GetShortName(const TDesC& aName,TDes& aShortName)
 	{
 	TInt r=CheckMountAndEntryName(aName);
 	if (r!=KErrNone)
 		return(r);
 	TPtrC entryName(StripBackSlash(aName));
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBGETSHORTNAMEL, "drive %d", DriveNumber());
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBGETSHORTNAMEL_ELONGNAME, "LongName %S", entryName.Ptr(), entryName.Length()<<1);
+	TRACEMULT2(UTF::EBorder, UTraceModuleFileSys::ECMountCBGetShortNameL, EF32TraceUidFileSys, DriveNumber(), entryName);
 	TRAP(r,CurrentMount().GetShortNameL(entryName,aShortName));
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBGETSHORTNAMEL_ESHORTNAME, "ShortName %S", aShortName.Ptr(), aShortName.Length()<<1);
+	TRACERETMULT2(UTF::EBorder, UTraceModuleFileSys::ECMountCBGetShortNameLRet, EF32TraceUidFileSys, r, aShortName);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBGETSHORTNAMEL_ECMOUNTCBGETSHORTNAMELRET, "r %d", r);
 	return(r);
 	}
 TInt TDrive::GetLongName(const TDesC& aShortName,TDes& aLongName)
 //
 	{
 	TInt r=CheckMountAndEntryName(aShortName);
 	if (r!=KErrNone)
 		return(r);
 	TPtrC entryName(StripBackSlash(aShortName));
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBGETLONGNAMEL, "drive %d", DriveNumber());
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBGETLONGNAMEL_ESHORTNAME, "ShortName %S", entryName.Ptr(), entryName.Length()<<1);
+	TRACEMULT2(UTF::EBorder, UTraceModuleFileSys::ECMountCBGetLongNameL, EF32TraceUidFileSys, DriveNumber(), entryName);
 	TRAP(r,CurrentMount().GetLongNameL(entryName,aLongName));
-	OstTraceData(TRACE_FILESYSTEM, FSYS_ECMOUNTCBGETLONGNAMEL_ELONGNAME, "LongName %S", aLongName.Ptr(), aLongName.Length()<<1);
+	TRACERETMULT2(UTF::EBorder, UTraceModuleFileSys::ECMountCBGetLongNameLRet, EF32TraceUidFileSys, r, aLongName);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBGETLONGNAMELRET, "r %d", r);
 	return(r);
 	}
 /**
 	__CHECK_DRIVETHREAD(iDriveNumber);
 	if(iFSys==NULL)
 		return(KErrNotReady);
 	TInt r;
 	CMountCB* pM=NULL;
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTL1, "this %x drive %d", (TUint) &FSys(), (TUint) DriveNumber());
+	TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountL, EF32TraceUidFileSys, &FSys(), DriveNumber());
 	TRAP(r,pM=FSys().NewMountL());
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTL1RET, "r %d CMountCB %x", (TUint) r, (TUint) pM);
+	TRACERET2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountLRet, EF32TraceUidFileSys, r, pM);
 	if(r!=KErrNone)
 		return(r);
 	pM->SetDrive(this);
-	OstTraceExt4(TRACE_FILESYSTEM, FSYS_ECMOUNTCBFORCEREMOUNTDRIVE, "drive %d aMountInfo %x aMountInfoMessageHandle %x aFlags %x", (TUint) DriveNumber(), (TUint) aMountInfo, (TUint) aMountInfoMessageHandle, (TUint) aFlags);
+	TRACE4(UTF::EBorder, UTraceModuleFileSys::ECMountCBForceRemountDrive, EF32TraceUidFileSys,
+		DriveNumber(), aMountInfo, aMountInfoMessageHandle, aFlags);
 	r=pM->ForceRemountDrive(aMountInfo,aMountInfoMessageHandle,aFlags);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBFORCEREMOUNTDRIVERET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBForceRemountDriveRet, EF32TraceUidFileSys, r);
 	pM->Close();
 	return(r);
 	}
 TBool TDrive::IsExtensionMounted(CProxyDriveFactory* aFactory)
 //
 // return ETrue if extension mounted on the drive
 //
 	{
 		if(iExtInfo.iInfo[i].iFactory==aFactory)
 			return(ETrue);
 		}
 	return(EFalse);
 	}
 TInt TDrive::MountExtension(CProxyDriveFactory* aFactory,TBool aIsPrimary)
 //
 // Mount an extension
 //
 	{
 	__CHECK_DRIVETHREAD(iDriveNumber);
 	// must be a secondary extension
 	if(iFSys==NULL)
 		return(KErrNotReady);
 	TBool extSupported = iFSys->IsExtensionSupported();
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMISEXTENSIONSUPPORTED1, "%x r %d", (TUint) iFSys, (TUint) extSupported);
+	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemIsExtensionSupported, EF32TraceUidFileSys, extSupported);
 	if(!extSupported)
 		return(KErrNotSupported);
 	if(IsExtensionMounted(aFactory))
 		return(KErrAlreadyExists);
 	if(iCurrentMount && (CurrentMount().LockStatus()!=0 || Mount().Count()>1))
 	__CHECK_DRIVETHREAD(iDriveNumber);
 	if(iFSys==NULL)
 		return(KErrNotReady);
 	TInt r;
 	CMountCB* pM=NULL;
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTL2, "this %x drive %d", (TUint) &FSys(), (TUint) DriveNumber());
+	TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountL, EF32TraceUidFileSys, &FSys(), DriveNumber());
 	TRAP(r,pM=FSys().NewMountL());
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTL2RET, "r %d CMountCB %x", (TUint) r, (TUint) pM);
+	TRACERET2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountLRet, EF32TraceUidFileSys, r, pM);
 	if(r!=KErrNone)
 		return(r);
 	pM->SetDrive(this);
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECMOUNTCBLOCK, "drive %d aStore %d", (TUint) DriveNumber(), (TUint) aStore);
+	TRACE2(UTF::EBorder, UTraceModuleFileSys::ECMountCBLock, EF32TraceUidFileSys, DriveNumber(), aStore);
 	r=pM->Lock(aOld,aNew,aStore);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBLOCKRET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBLockRet, EF32TraceUidFileSys, r);
 	pM->Close();
 	return(r);
 	}
 TInt TDrive::UnlockDevice(TMediaPassword& aPassword,TBool aStore)
 	__CHECK_DRIVETHREAD(iDriveNumber);
 	if(iFSys==NULL)
 		return(KErrNotReady);
 	TInt r;
 	CMountCB* pM=NULL;
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTL3, "this %x drive %d", (TUint) &FSys(), (TUint) DriveNumber());
+	TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountL, EF32TraceUidFileSys, &FSys(), DriveNumber());
 	TRAP(r,pM=FSys().NewMountL());
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTL3RET, "r %d CMountCB %x", (TUint) r, (TUint) pM);
+	TRACERET2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountLRet, EF32TraceUidFileSys, r, pM);
 	if(r!=KErrNone)
 		return(r);
 	// reset mount failure count - which is likely to be non-zero if drive is locked
 	iMountFailures = 0;
 	pM->SetDrive(this);
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECMOUNTCBUNLOCK, "drive %d aStore %d", (TUint) DriveNumber(), (TUint) aStore);
+	TRACE2(UTF::EBorder, UTraceModuleFileSys::ECMountCBUnlock, EF32TraceUidFileSys, DriveNumber(), aStore);
 	r=pM->Unlock(aPassword,aStore);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBUNLOCKRET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBUnlockRet, EF32TraceUidFileSys, r);
 	pM->Close();
 	return(r);
 	}
 TInt TDrive::ClearDevicePassword(TMediaPassword& aPassword)
 	__CHECK_DRIVETHREAD(iDriveNumber);
 	if(iFSys==NULL)
 		return(KErrNotReady);
 	TInt r;
 	CMountCB* pM=NULL;
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTL4, "this %x drive %d", (TUint) &FSys(), (TUint) DriveNumber());
+	TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountL, EF32TraceUidFileSys, &FSys(), DriveNumber());
 	TRAP(r,pM=FSys().NewMountL());
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTL4RET, "r %d CMountCB %x", (TUint) r, (TUint) pM);
+	TRACERET2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountLRet, EF32TraceUidFileSys, r, pM);
 	if(r!=KErrNone)
 		return(r);
 	pM->SetDrive(this);
 	// ClearPassword() will only work if the card is already unlocked.
 	TDriveInfo info;
 	DriveInfo(info);
 	if (info.iMediaAtt & KMediaAttLocked)
 		UnlockDevice(aPassword, EFalse);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBCLEARPASSWORD, "drive %d", DriveNumber());
+	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBClearPassword, EF32TraceUidFileSys, DriveNumber());
 	r=pM->ClearPassword(aPassword);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBCLEARPASSWORDRET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBClearPasswordRet, EF32TraceUidFileSys, r);
 	pM->Close();
 	return(r);
 	}
 TInt TDrive::EraseDevicePassword()
 	__CHECK_DRIVETHREAD(iDriveNumber);
 	if(iFSys==NULL)
 		return(KErrNotReady);
 	TInt r;
 	CMountCB* pM=NULL;
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTL5, "this %x drive %d", (TUint) &FSys(), (TUint) DriveNumber());
+	TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountL, EF32TraceUidFileSys, &FSys(), DriveNumber());
 	TRAP(r,pM=FSys().NewMountL());
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWMOUNTL5RET, "r %d CMountCB %x", (TUint) r, (TUint) pM);
+	TRACERET2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewMountLRet, EF32TraceUidFileSys, r, pM);
 	if(r!=KErrNone)
 		return(r);
 	pM->SetDrive(this);
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBERASEPASSWORD, "drive %d", DriveNumber());
+	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBErasePassword, EF32TraceUidFileSys, DriveNumber());
 	r=pM->ErasePassword();
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBERASEPASSWORDRET, "r %d", r);
+	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBErasePasswordRet, EF32TraceUidFileSys, r);
 	pM->Close();
 	return(r);
 	}
 #else
 /**
-Gracefully dismounts the current mount. This is method is called from outside, so do some finalisation work on mount.
+Dismounts the current mount. This is method is called from outside, so do some finalisation work on mount.
 After calling this function there is no current mount on the drive.
 */
 EXPORT_C void TDrive::Dismount()
 	{
 	__PRINT1(_L("TDrive::Dismount() iCurrentMount:0x%x"),iCurrentMount);
 	iMountFailures = 0;
 	if (!iCurrentMount)
 		return;
-//-- try to do the best flushing file caches
 TRAP_IGNORE(FlushCachedFileInfoL());
 //-- try our best to finalise the mount (the mount can decide to do some job during finalisation, e.g. write some data)
-//-- finalise the mount in RO mode, we are dismounting the FS anyway
+TRAP_IGNORE(iCurrentMount->FinaliseMountL());
-TRAP_IGNORE(iCurrentMount->FinaliseMountL(RFs::EFinal_RO));
 DoDismount();
 	}
 /**
-Dismounts the current mount by force.
+Forcibly dismounts the current mount and prevents it being remounted.
+After calling this function there is no current mount on the drive.
 */
 void TDrive::ForceDismount()
 	{
 	__PRINT1(_L("TDrive::ForceDismount() iCurrentMount:0x%x"),iCurrentMount);
 	if(!iCurrentMount)
 		return;
 	TRAP_IGNORE(FlushCachedFileInfoL());
+	iCurrentMount->SetDismounted(); //! this affects TDrive::ReMount()
-//-- try our best to finalise the mount (the mount can decide to do some job during finalisation, e.g. write some data)
-//-- finalise the mount in RO mode, we are dismounting the FS anyway
-TRAP_IGNORE(iCurrentMount->FinaliseMountL(RFs::EFinal_RO));
-//-- mark the mount as 'Dismounted'; this invalidates all object handles until the mount is successfully "remounted".
-//-- if there are still some objects opened on this mount, CMountCB::Close() won't destroy it until all objects are closed.
-iCurrentMount->SetDismounted();
 DoDismount();
 	}
 /**
 An internal method. Dismounts and closes a current mount.
 iMountFailures = 0;
 	if (!iCurrentMount)
 		return;
-	OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBDISMOUNTED, "drive %d", DriveNumber());
+	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECMountCBDismounted, EF32TraceUidFileSys, DriveNumber());
 iCurrentMount->Dismounted();
-	OstTrace0(TRACE_FILESYSTEM, FSYS_ECMOUNTCBDISMOUNTEDRET, "");
+	TRACE0(UTF::EBorder, UTraceModuleFileSys::ECMountCBDismountedRet, EF32TraceUidFileSys);
 	iCurrentMount->Close();
 	iCurrentMount=NULL;
 }
 	else
 		iDriveFlags &= ~EDismountDeferred;
 	}
 TInt TDrive::ControlIO(const RMessagePtr2& aMessage,TInt aCommand,TAny* aParam1,TAny* aParam2)
 //
 // General purpose test interface - .FSY specific.
 //
 	{
 	TInt r=CheckMount();
 	if(r==KErrNone || (r==KErrInUse && iReason==KErrNone))
 		{
 		TRACETHREADID(aMessage);
-		OstTraceExt5(TRACE_FILESYSTEM, FSYS_ECMOUNTCBCONTROLIO, "drive %d aCommand %d aParam1 %x aParam2 %x clientThreadId %x", (TUint) DriveNumber(), (TUint) aCommand, (TUint) aParam1, (TUint) aParam2, (TUint) threadId);
+		TRACE5(UTF::EBorder, UTraceModuleFileSys::ECMountCBControlIO, EF32TraceUidFileSys,
+			DriveNumber(), aCommand, aParam1, aParam2, I64LOW(threadId));
 		r=CurrentMount().ControlIO(aMessage,aCommand,aParam1,aParam2);
-		OstTrace1(TRACE_FILESYSTEM, FSYS_ECMOUNTCBCONTROLIORET, "r %d", r);
+		TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBControlIORet, EF32TraceUidFileSys, r);
 		}
 	return(r);
 	}
 */
 CFormatCB* TDrive::FormatOpenL(CFsRequest* aRequest, TInt& aFmtHandle, TFormatMode aFmtMode, const TLDFormatInfo* apLDFormatInfo, const TVolFormatParam* apVolFormatParam)
 {
 ASSERT(!(apLDFormatInfo && apVolFormatParam));  //-- these parameters are mutually exclusive
-OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWFORMATL, "this %x drive %d", (TUint) &FSys(), (TUint) DriveNumber());
+TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewFormatL, EF32TraceUidFileSys, &FSys(), DriveNumber());
 CFormatCB* pFormat = CurrentMount().NewFormatL();
-	OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWFORMATLRET, "r %d CFormatCB %x", (TUint) KErrNone, (TUint) pFormat);
+	TRACE2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewFormatLRet, EF32TraceUidFileSys, KErrNone, pFormat);
 Formats->AddL(pFormat, ETrue);
 	pFormat->InitL(this, aFmtMode);
 if(aFmtMode & ESpecialFormat)

branch	RCL_3
changeset 44	3e88ff8f41d5
parent 43	c1f20ce4abcf