FCL/sf/mw/remoteconn: comparison mtpfws/mtpfw/src/cmtpstoragemgr.cpp

equal deleted inserted replaced

-:2c19c7cf5550
+:c20dd21d1eb4
 #include <mtp/mtpdatatypeconstants.h>
 #include <mtp/mtpprotocolconstants.h>
 #include "cmtpdataprovidercontroller.h"
 #include "cmtpstoragemgr.h"
+#include "mtpdebug.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmtpstoragemgrTraces.h"
+#endif
 // Class constants.
-__FLOG_STMT(_LIT8(KComponent,"StorageMgr");)
 // StorageID bit manipulation patterns.
 static const TUint32    KLogicalIdMask(0x0000FFFF);
 static const TUint32    KPhysicalIdMask(0xFFFF0000);
 /**
 Destructor.
 */
 EXPORT_C CMTPStorageMgr::~CMTPStorageMgr()
 {
-__FLOG(_L8("~CMTPStorageMgr - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_CMTPSTORAGEMGR_DES_ENTRY );
 iPhysicalStorageNumbers.Reset();
 iStorages.ResetAndDestroy();
 iSingletons.Close();
-__FLOG(_L8("~CMTPStorageMgr - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_CMTPSTORAGEMGR_DES_EXIT );
-__FLOG_CLOSE;
 }
 /**
 Extracts the storage number of the logical storage ID encoded in the specified
 StorageID.
 @param aStorageId The storage ID.
 @return The storage number.
 */
 EXPORT_C TUint CMTPStorageMgr::LogicalStorageNumber(TUint32 aStorageId)
 {
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_LOGICALSTORAGENUMBER_ENTRY );
+OstTraceFunctionExit0( CMTPSTORAGEMGR_LOGICALSTORAGENUMBER_EXIT );
 return (aStorageId & KLogicalNumberMask);
 }
 /**
 Extracts the ID of the data provider responsible for the logical storage ID
 @param aStorageId The storage ID.
 @return The data provider owner ID.
 */
 EXPORT_C TUint CMTPStorageMgr::LogicalStorageOwner(TUint32 aStorageId)
 {
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_LOGICALSTORAGEOWNER_ENTRY );
 return ((aStorageId & KLogicalIdMask) >> KLogicalOwnerShift);
 }
 /**
 Extracts the storage number of the physical storage ID encoded in the specified
 @param aStorageId The storage ID.
 @return The storage number.
 */
 EXPORT_C TUint CMTPStorageMgr::PhysicalStorageNumber(TUint32 aStorageId)
 {
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_PHYSICALSTORAGENUMBER_ENTRY );
 return ((aStorageId & KPhysicalIdMask) >> KPhysicalNumberShift);
 }
 /**
 Extracts the ID of the data provider responsible for the physical storage ID
 @param aStorageId The storage ID.
 @return The data provider owner ID.
 */
 EXPORT_C TUint CMTPStorageMgr::PhysicalStorageOwner(TUint32 aStorageId)
 {
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_PHYSICALSTORAGEOWNER_ENTRY );
 return ((aStorageId & KPhysicalIdMask) >> KPhysicalOwnerShift);
 }
 /**
 Sets the default MTP StorageID. This should be set once at start up and not
 @panic USER 0, in debug builds only, if the default StorageID is set more than
 once.
 */
 EXPORT_C void CMTPStorageMgr::SetDefaultStorageId(TUint32 aStorageId)
 {
-__FLOG(_L8("SetDefaultStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_SETDEFAULTSTORAGEID_ENTRY );
 iDefaultStorageId = aStorageId;
-__FLOG_VA((_L8("Default StorageId = 0x%08X"), aStorageId));
+OstTrace1(TRACE_NORMAL, CMTPSTORAGEMGR_SETDEFAULTSTORAGEID,
-__FLOG(_L8("SetDefaultStorageId - Exit"));
+"Default StorageId = 0x%08X", aStorageId);
+OstTraceFunctionExit0( CMTPSTORAGEMGR_SETDEFAULTSTORAGEID_EXIT );
 }
 /**
 Creates a mapping between the specified Symbian OS drive number and MTP
 StorageID.
 @param aStorageId The MTP StorageID.
 @leave One of the sysem wide error codes, if a processing failure occurs.
 */
 EXPORT_C void CMTPStorageMgr::SetDriveMappingL(TDriveNumber aDriveNumber, TUint32 aStorageId)
 {
-__FLOG(_L8("DefineDriveNumberMapping - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_SETDRIVEMAPPINGL_ENTRY );
 iMapDriveToStorage[aDriveNumber] = aStorageId;
-__FLOG_VA((_L8("Drive number %d = StorageID 0x%08X"), aDriveNumber, aStorageId));
+OstTraceExt2(TRACE_NORMAL, CMTPSTORAGEMGR_SETDRIVEMAPPINGL,
-__FLOG(_L8("DefineDriveNumberMapping - Exit"));
+"Drive number %d = StorageID 0x%08X", (int)aDriveNumber, (int)aStorageId);
+OstTraceFunctionExit0( CMTPSTORAGEMGR_SETDRIVEMAPPINGL_EXIT );
 }
 /**
 Sets the framework storages owner identifier. This should be set once at start
 up and not subsequently changed.
 @panic USER 0, in debug builds only, if the framework storages owner identifier
 is set more than once.
 */
 EXPORT_C void CMTPStorageMgr::SetFrameworkId(TUint aDataProviderId)
 {
-__FLOG(_L8("SetFrameworkStoragesOwner - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_SETFRAMEWORKID_ENTRY );
 __ASSERT_DEBUG((iFrameworkId == KErrNotFound), User::Invariant());
 iFrameworkId = aDataProviderId;
-__FLOG_VA((_L8("System storages owner DP Id = %d"), aDataProviderId));
+OstTrace1(TRACE_NORMAL, CMTPSTORAGEMGR_SETFRAMEWORKID,
-__FLOG(_L8("SetFrameworkStoragesOwner - Exit"));
+"System storages owner DP Id = %d", aDataProviderId);
+OstTraceFunctionExit0( CMTPSTORAGEMGR_SETFRAMEWORKID_EXIT );
 }
 EXPORT_C TUint32 CMTPStorageMgr::AllocateLogicalStorageIdL(TUint aDataProviderId, TDriveNumber aDriveNumber, const CMTPStorageMetaData& aStorage)
 {
-__FLOG(_L8("AllocateLogicalStorageIdL - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL_TDRIVERNUMBER_ENTRY );
 TUint id(AllocateLogicalStorageIdL(aDataProviderId, PhysicalStorageId(aDriveNumber), aStorage));
-__FLOG(_L8("AllocateLogicalStorageIdL - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL_EXIT );
 return id;
 }
 EXPORT_C TUint32 CMTPStorageMgr::AllocateLogicalStorageIdL(TUint aDataProviderId, TUint32 aPhysicalStorageId, const CMTPStorageMetaData& aStorage)
 {
-__FLOG(_L8("AllocateLogicalStorageIdL - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL_TUINT32_ENTRY );
 //if support uninstall DP, comment the below assert.
 //__ASSERT_DEBUG((aDataProviderId < iSingletons.DpController().Count()), User::Invariant());
 // Resolve the physical storage.
 CMTPStorageMetaData& physical(StorageMetaDataL(aPhysicalStorageId));
 // Validate the SUID and storage type.
 if (iStorages.Find(aStorage.DesC(CMTPStorageMetaData::EStorageSuid), StorageKeyMatchSuid) != KErrNotFound)
 {
 // SUID is not unique.
+OstTrace0( TRACE_ERROR, CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL, "SUID is not unique" );
 User::Leave(KErrAlreadyExists);
 }
 else if (aStorage.Uint(CMTPStorageMetaData::EStorageSystemType) != physical.Uint(CMTPStorageMetaData::EStorageSystemType))
 {
 // Physical/logical storage type mis-match.
+OstTrace0( TRACE_ERROR, DUP2_CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL, "Physical/logical storage type mis-match" );
 User::Leave(KErrArgument);
 }
 else if (aStorage.Uint(CMTPStorageMetaData::EStorageSystemType) == CMTPStorageMetaData::ESystemTypeDefaultFileSystem)
 {
 // Validate that the SUID path exists.
 if (!BaflUtils::PathExists(iSingletons.Fs(), aStorage.DesC(CMTPStorageMetaData::EStorageSuid)))
 {
+OstTrace0( TRACE_ERROR, DUP3_CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL, "the SUID path doesn't exist" );
 User::Leave(KErrPathNotFound);
 }
 // Validate that the SUID path corresponds to the physical storage drive.
 TInt storageDrive(DriveNumber(aPhysicalStorageId));
 TParse p;
-User::LeaveIfError(p.Set(aStorage.DesC(CMTPStorageMetaData::EStorageSuid), NULL, NULL));
+LEAVEIFERROR(p.Set(aStorage.DesC(CMTPStorageMetaData::EStorageSuid), NULL, NULL),
+OstTrace0( TRACE_ERROR, DUP4_CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL, "storage can't be parsed!"));
 TInt suidDrive(0);
-User::LeaveIfError(iSingletons.Fs().CharToDrive(TChar(p.Drive()[0]), suidDrive));
+LEAVEIFERROR(iSingletons.Fs().CharToDrive(TChar(p.Drive()[0]), suidDrive),
+OstTrace0( TRACE_ERROR, DUP5_CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL, "CharToDrive failed!" ));
 if (suidDrive != storageDrive)
 {
 // SUID path/physical storage drive mis-match.
+OstTraceExt2( TRACE_ERROR, DUP6_CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL,
+"SUID path %d /physical storage drive %d  mis-match", suidDrive, storageDrive);
 User::Leave(KErrArgument);
 }
 }
 // Allocate a logical StorageId.
 TInt32 id(AllocateLogicalStorageId(aDataProviderId, aPhysicalStorageId));
-User::LeaveIfError(id);
+LEAVEIFERROR(id,
+OstTraceExt2( TRACE_ERROR, DUP7_CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL,
+"allocate logical storageId for Dp %d, Physical StorageId %d failed!", aDataProviderId, aPhysicalStorageId));
 // Create the logical storage meta-data.
 CMTPStorageMetaData* logical(CMTPStorageMetaData::NewLC(aStorage));
 logical->SetUint(CMTPStorageMetaData::EStorageId, id);
 // Store the logical storage meta-data.
 physical.GetUintArrayL(CMTPStorageMetaData::EStorageLogicalIds, logicals);
 logicals.InsertInOrderL(id);
 physical.SetUintArrayL(CMTPStorageMetaData::EStorageLogicalIds, logicals);
 CleanupStack::PopAndDestroy(&logicals);
-#ifdef __FLOG_ACTIVE
+#ifdef OST_TRACE_COMPILER_IN_USE
 HBufC8* buf(HBufC8::NewLC(aStorage.DesC(CMTPStorageMetaData::EStorageSuid).Length()));
 buf->Des().Copy(aStorage.DesC(CMTPStorageMetaData::EStorageSuid));
-__FLOG_VA((_L8("Allocated logical StorageID 0x%08X for storage SUID %S"), id, buf));
+OstTraceExt2(TRACE_NORMAL, DUP8_CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL_TUINT32,
+"Allocated logical StorageID 0x%08X for storage SUID %s", (TUint)id, *buf);
 CleanupStack::PopAndDestroy(buf);
-#endif // __FLOG_ACTIVE
+#endif // OST_TRACE_COMPILER_IN_USE
-__FLOG(_L8("AllocateLogicalStorageIdL - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEIDL_TUINT32_EXIT );
 return id;
 }
 EXPORT_C TUint32 CMTPStorageMgr::AllocatePhysicalStorageIdL(TUint aDataProviderId, const CMTPStorageMetaData& aStorage)
 {
-__FLOG(_L8("AllocatePhysicalStorageIdL - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_ALLOCATEPHYSICALSTORAGEIDL_ENTRY );
 // Validate the SUID.
 if (iStorages.Find(aStorage.DesC(CMTPStorageMetaData::EStorageSuid), StorageKeyMatchSuid) != KErrNotFound)
 {
 // SUID is not unique.
+OstTrace0( TRACE_ERROR, DUP1_CMTPSTORAGEMGR_ALLOCATEPHYSICALSTORAGEIDL, "SUID is not unique" );
 User::Leave(KErrAlreadyExists);
 }
 // Allocate a physical StorageId.
 TInt32 id(AllocatePhysicalStorageId(aDataProviderId));
-User::LeaveIfError(id);
+LEAVEIFERROR(id,
+OstTrace1( TRACE_ERROR, DUP2_CMTPSTORAGEMGR_ALLOCATEPHYSICALSTORAGEIDL, "Allocate Physical StorageId for Dp %d failed", aDataProviderId));
 // Create the physical storage meta-data.
 CMTPStorageMetaData* physical(CMTPStorageMetaData::NewLC(aStorage));
 const RArray<TUint> noStorages;
 physical->SetUint(CMTPStorageMetaData::EStorageId, id);
 // Store the physical storage meta-data.
 iStorages.InsertInOrderL(physical, StorageOrder);
 CleanupStack::Pop(physical);
-__FLOG_VA((_L8("Allocated physical StorageID 0x%08X"), id));
+OstTrace1(TRACE_NORMAL, CMTPSTORAGEMGR_ALLOCATEPHYSICALSTORAGEIDL,
-__FLOG(_L8("AllocatePhysicalStorageIdL - Exit"));
+"Allocated physical StorageID 0x%08X", id);
+OstTraceFunctionExit0( CMTPSTORAGEMGR_ALLOCATEPHYSICALSTORAGEIDL_EXIT );
 return id;
 }
 EXPORT_C TInt CMTPStorageMgr::DeallocateLogicalStorageId(TUint aDataProviderId, TUint32 aLogicalStorageId)
 {
-__FLOG(_L8("DeallocateLogicalStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_DEALLOCATELOGICALSTORAGEID_ENTRY );
 TInt ret(KErrArgument);
 // Validate the StorageID.
 if (LogicalStorageId(aLogicalStorageId))
 {
 TRAPD(err, RemoveLogicalStorageL(ret));
 ret = err;
 }
 }
 }
-__FLOG(_L8("DeallocateLogicalStorageId - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_DEALLOCATELOGICALSTORAGEID_EXIT );
 return ret;
 }
 EXPORT_C void CMTPStorageMgr::DeallocateLogicalStorageIds(TUint aDataProviderId, TUint32 aPhysicalStorageId)
 {
-__FLOG(_L8("DeallocateLogicalStorageIds - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_DEALLOCATELOGICALSTORAGEIDS_ENTRY );
 TInt ret(iStorages.FindInOrder(aPhysicalStorageId, StorageOrder));
 if (ret != KErrNotFound)
 {
 const RArray<TUint>& logicals(iStorages[ret]->UintArray(CMTPStorageMetaData::EStorageLogicalIds));
 TUint count(logicals.Count());
 DeallocateLogicalStorageId(aDataProviderId, logicals[KIdx]);
 }
 count--;
 }
 }
-__FLOG(_L8("DeallocateLogicalStorageIds - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_DEALLOCATELOGICALSTORAGEIDS_EXIT );
 }
 EXPORT_C TInt CMTPStorageMgr::DeallocatePhysicalStorageId(TUint aDataProviderId, TUint32 aPhysicalStorageId)
 {
-__FLOG(_L8("DeallocatePhysicalStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_DEALLOCATEPHYSICALSTORAGEID_ENTRY );
 TInt ret(KErrArgument);
 // Validate the StorageID.
 if (!LogicalStorageId(aPhysicalStorageId))
 {
 delete iStorages[ret];
 iStorages.Remove(ret);
 }
 }
 }
-__FLOG(_L8("DeallocatePhysicalStorageId - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_DEALLOCATEPHYSICALSTORAGEID_EXIT );
 return ret;
 }
 EXPORT_C TUint32 CMTPStorageMgr::DefaultStorageId() const
 {
-__FLOG(_L8("DefaultStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_DEFAULTSTORAGEID_ENTRY );
-__FLOG(_L8("DefaultStorageId - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_DEFAULTSTORAGEID_EXIT );
 return iDefaultStorageId;
 }
 EXPORT_C TInt CMTPStorageMgr::DriveNumber(TUint32 aStorageId) const
 {
-__FLOG(_L8("DriveNumber - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_DRIVENUMBER_ENTRY );
 TInt drive(KErrNotFound);
 if (PhysicalStorageOwner(aStorageId) == iFrameworkId)
 {
 const TUint32 KPhysicalId(PhysicalStorageId(aStorageId));
 const TUint KCount(iMapDriveToStorage.Count());
 {
 drive = i;
 }
 }
 }
-__FLOG(_L8("DriveNumber - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_DRIVENUMBER_EXIT );
 return drive;
 }
 EXPORT_C TInt32 CMTPStorageMgr::FrameworkStorageId(TDriveNumber aDriveNumber) const
 {
-__FLOG(_L8("FrameworkStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_FRAMEWORKSTORAGEID_ENTRY );
 TInt32 ret(KErrNotFound);
 TInt32 id(iMapDriveToStorage[aDriveNumber]);
 if ((id != KErrNotFound) && (LogicalStorageId(id)))
 {
 ret = id;
 }
-__FLOG(_L8("FrameworkStorageId - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_FRAMEWORKSTORAGEID_EXIT );
 return ret;
 }
 EXPORT_C void CMTPStorageMgr::GetAvailableDrivesL(RArray<TDriveNumber>& aDrives) const
 {
-__FLOG(_L8("GetAvailableDrivesL - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_GETAVAILABLEDRIVESL_ENTRY );
 aDrives.Reset();
 for (TUint i(0); (i < iMapDriveToStorage.Count()); i++)
 {
 if (iMapDriveToStorage[i] != KErrNotFound)
 {
 aDrives.AppendL(static_cast<TDriveNumber>(i));
 }
 }
-__FLOG(_L8("GetAvailableDrivesL - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_GETAVAILABLEDRIVESL_EXIT );
 }
 EXPORT_C void CMTPStorageMgr::GetLogicalStoragesL(const TMTPStorageMgrQueryParams& aParams, RPointerArray<const CMTPStorageMetaData>& aStorages) const
 {
-__FLOG(_L8("GetLogicalStoragesL - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_GETLOGICALSTORAGESL_ENTRY );
 aStorages.Reset();
 const TBool KAllStorages(aParams.StorageSuid() == KNullDesC);
 const TBool KAllStorageSystemTypes(aParams.StorageSystemType() == CMTPStorageMetaData::ESystemTypeUndefined);
 const TUint KCount(iStorages.Count());
 for (TUint i(0); (i < KCount); i++)
 (LogicalStorageId(storage.Uint(CMTPStorageMetaData::EStorageId))))
 {
 aStorages.AppendL(iStorages[i]);
 }
 }
-__FLOG(_L8("GetLogicalStoragesL - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_GETLOGICALSTORAGESL_EXIT );
 }
 EXPORT_C void CMTPStorageMgr::GetPhysicalStoragesL(const TMTPStorageMgrQueryParams& aParams, RPointerArray<const CMTPStorageMetaData>& aStorages) const
 {
-__FLOG(_L8("GetPhysicalStoragesL - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_GETPHYSICALSTORAGESL_ENTRY );
 aStorages.Reset();
 const TBool KAllStorages(aParams.StorageSuid() == KNullDesC);
 const TBool KAllStorageSystemTypes(aParams.StorageSystemType() == CMTPStorageMetaData::ESystemTypeUndefined);
 const TUint KCount(iStorages.Count());
 for (TUint i(0); (i < KCount); i++)
 (!LogicalStorageId(storage.Uint(CMTPStorageMetaData::EStorageId))))
 {
 aStorages.AppendL(iStorages[i]);
 }
 }
-__FLOG(_L8("GetPhysicalStoragesL - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_GETPHYSICALSTORAGESL_EXIT );
 }
 EXPORT_C TUint32 CMTPStorageMgr::LogicalStorageId(TUint32 aStorageId) const
 {
-__FLOG(_L8("LogicalStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_LOGICALSTORAGEID_TUINT32_ENTRY );
-__FLOG(_L8("LogicalStorageId - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_LOGICALSTORAGEID_TUINT32_EXIT );
 return (aStorageId & KLogicalIdMask);
 }
 EXPORT_C TInt32 CMTPStorageMgr::LogicalStorageId(const TDesC& aStorageSuid) const
 {
-__FLOG(_L8("LogicalStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_LOGICALSTORAGEID_TDESC_ENTRY );
 TInt32 id(KErrNotFound);
 TInt idx(iStorages.Find(aStorageSuid, StorageKeyMatchSuid));
 if (idx != KErrNotFound)
 {
 id = iStorages[idx]->Uint(CMTPStorageMetaData::EStorageId);
 if (!LogicalStorageId(id))
 {
 id = KErrNotFound;
 }
 }
-__FLOG(_L8("LogicalStorageId - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_LOGICALSTORAGEID_TDESC_EXIT );
 return id;
 }
 EXPORT_C TInt32 CMTPStorageMgr::PhysicalStorageId(TDriveNumber aDriveNumber) const
 {
-__FLOG(_L8("PhysicalStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_PHYSICALSTORAGEID_TDRIVENUMBER_ENTRY );
 TInt32 storageId(iMapDriveToStorage[aDriveNumber]);
 if (storageId != KErrNotFound)
 {
 storageId = PhysicalStorageId(storageId);
 }
-__FLOG(_L8("PhysicalStorageId - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_PHYSICALSTORAGEID_TDRIVENUMBER_EXIT );
 return storageId;
 }
 EXPORT_C TUint32 CMTPStorageMgr::PhysicalStorageId(TUint32 aStorageId) const
 {
-__FLOG(_L8("PhysicalStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_PHYSICALSTORAGEID_TUINT32_ENTRY );
-__FLOG(_L8("PhysicalStorageId - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_PHYSICALSTORAGEID_TUINT32_EXIT );
 return (aStorageId & KPhysicalIdMask);
 }
 EXPORT_C const CMTPStorageMetaData& CMTPStorageMgr::StorageL(TUint32 aStorageId) const
 {
-__FLOG(_L8("StorageL - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_STORAGEL_ENTRY );
 TInt idx(iStorages.FindInOrder(aStorageId, StorageOrder));
-User::LeaveIfError(idx);
+LEAVEIFERROR(idx,
-__FLOG(_L8("StorageL - Exit"));
+OstTrace1( TRACE_ERROR, CMTPSTORAGEMGR_STORAGEL, "can't find storage with StorageId %d", idx ));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_STORAGEL_EXIT );
 return *iStorages[idx];
 }
 EXPORT_C TUint32 CMTPStorageMgr::StorageId(TUint32 aPhysicalStorageId, TUint32 aLogicalStorageId) const
 {
-__FLOG(_L8("StorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_STORAGEID_ENTRY );
-__FLOG(_L8("StorageId - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_STORAGEID_EXIT );
 return (aPhysicalStorageId | aLogicalStorageId);
 }
 EXPORT_C TBool CMTPStorageMgr::ValidStorageId(TUint32 aStorageId) const
 {
-__FLOG(_L8("ValidStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_VALIDSTORAGEID_ENTRY );
 TInt idx(iStorages.FindInOrder(aStorageId, StorageOrder));
 if(KErrNotFound == idx)
 	{
-	__FLOG(_L8("ValidStorageId - False Exit"));
+	OstTraceFunctionExit0( CMTPSTORAGEMGR_VALIDSTORAGEID_EXIT );
 	return EFalse;
 	}
 _LIT(KSeperator,"\\");
 	TBool ret = ETrue;
 buf.Append(KSeperator);
 ret = BaflUtils::PathExists(iSingletons.Fs(), buf);
 			}
 		}
-__FLOG(_L8("ValidStorageId - Exit"));
+OstTraceFunctionExit0( DUP1_CMTPSTORAGEMGR_VALIDSTORAGEID_EXIT );
 return ret;
 }
 EXPORT_C CMTPTypeString* CMTPStorageMgr::VolumeIdL(TUint aDataProviderId, TUint32 aStorageId, const TDesC& aVolumeIdSuffix) const
 {
-__FLOG(_L8("VolumeIdL - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_VOLUMEIDL_ENTRY );
 // Validate the StorageId.
 TUint owner(LogicalStorageId(aStorageId) ? LogicalStorageOwner(aStorageId) : PhysicalStorageOwner(aStorageId));
 if (!ValidStorageId(aStorageId))
 {
+OstTrace1( TRACE_ERROR, CMTPSTORAGEMGR_VOLUMEIDL, "invalid storage id %d", aStorageId);
 User::Leave(KErrNotFound);
 }
 else if (aDataProviderId != owner)
 {
+OstTrace1( TRACE_ERROR, DUP1_CMTPSTORAGEMGR_VOLUMEIDL, "Dp %d not owner", aDataProviderId);
 User::Leave(KErrAccessDenied);
 }
 // Generate a unique volume ID.
 RBuf16 buffer;
 buffer.Append(aVolumeIdSuffix.Left(KMTPMaxStringCharactersLength - buffer.Length()));
 }
 CMTPTypeString* volumeId = CMTPTypeString::NewL(buffer);
 	CleanupStack::PopAndDestroy(&buffer);
-__FLOG(_L8("VolumeIdL - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_VOLUMEIDL_EXIT );
 return volumeId;
 }
 /**
 Constructor.
 */
 CMTPStorageMgr::CMTPStorageMgr() :
 iFrameworkId(KErrNotFound)
 {
 }
 /**
 Second phase constructor.
 @leave One of the system wide error code, if a processing failure occurs.
 */
 void CMTPStorageMgr::ConstructL()
 {
-__FLOG_OPEN(KMTPSubsystem, KComponent);
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_CONSTRUCTL_ENTRY );
-__FLOG(_L8("ConstructL - Entry"));
 iSingletons.OpenL();
 for (TUint i(0); (i < KMaxDrives); i++)
 {
 iMapDriveToStorage[i] = KErrNotFound;
 }
-__FLOG(_L8("ConstructL - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_CONSTRUCTL_EXIT );
 }
 /**
 Allocates a new 32-bit logical StorageId for the storage owner as a partition
 of the specified physical MTP StorageID.
 @return KErrNotFound, if the specified physical MTP StorageID does not exist
 @return KErrOverflow, if the maximum number of storages would be exceeded.
 */
 TInt32 CMTPStorageMgr::AllocateLogicalStorageId(TUint aDataProviderId, TUint32 aPhysicalStorageId)
 {
-__FLOG_STATIC(KMTPSubsystem, KComponent, _L8("AllocateLogicalStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEID_ENTRY );
 TInt ret(iStorages.FindInOrder(aPhysicalStorageId, StorageOrder));
 if (ret != KErrNotFound)
 {
 // Scan for the first available storage number.
 const RArray<TUint>& logicalIds(iStorages[ret]->UintArray(CMTPStorageMetaData::EStorageLogicalIds));
 if (num >= KMaxOwnedStorages)
 {
 ret = KErrOverflow;
 }
 }
-__FLOG_STATIC(KMTPSubsystem, KComponent, _L8("AllocateLogicalStorageId - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEID_EXIT );
 return ret;
 }
 /**
 Allocates a new 32-bit physical StorageId for the storage owner.
 @return KErrOverflow, if the maximum number of storages would be exceeded.
 @return One of the system wide error code, if a processing failure occurs.
 */
 TInt32 CMTPStorageMgr::AllocatePhysicalStorageId(TUint aDataProviderId)
 {
-__FLOG_STATIC(KMTPSubsystem, KComponent, _L8("AllocatePhysicalStorageId - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_ALLOCATEPHYSICALSTORAGEID_ENTRY );
 TInt32 ret(KErrNone);
 while ((iPhysicalStorageNumbers.Count() < (aDataProviderId + 1)) && (ret == KErrNone))
 {
 ret = iPhysicalStorageNumbers.Append(0);
 }
 else
 {
 ret = KErrOverflow;
 }
 }
-__FLOG_STATIC(KMTPSubsystem, KComponent, _L8("AllocatePhysicalStorageId - Exit"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_ALLOCATEPHYSICALSTORAGEID_EXIT );
 return ret;
 }
 /**
 Encodes the specified physical MTP StorageID, data provider identifier, and
 @param aIdx The storages table index.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPStorageMgr::RemoveLogicalStorageL(TUint aIdx)
 {
-__FLOG(_L8("RemoveLogicalStorageL - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_REMOVELOGICALSTORAGEL_ENTRY );
 TUint32 id(iStorages[aIdx]->Uint(CMTPStorageMetaData::EStorageId));
 // Disassociate the logical and physical storages.
 CMTPStorageMetaData& physical(StorageMetaDataL(PhysicalStorageId(id)));
 RArray<TUint> logicals;
 CleanupStack::PopAndDestroy(&logicals);
 // Delete the storage.
 delete iStorages[aIdx];
 iStorages.Remove(aIdx);
-__FLOG(_L8("RemoveLogicalStorageL - Entry"));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_REMOVELOGICALSTORAGEL_EXIT );
 }
 /**
 Provides a non-const reference to the storage meta-data for the specified
 logical MTP StorageID.
 @leave KErrNotFound if the specified StorageID does not exist.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 CMTPStorageMetaData& CMTPStorageMgr::StorageMetaDataL(TUint32 aStorageId)
 {
-__FLOG(_L8("StorageMetaDataL - Entry"));
+OstTraceFunctionEntry0( CMTPSTORAGEMGR_STORAGEMETADATAL_ENTRY );
 TInt idx(iStorages.FindInOrder(aStorageId, StorageOrder));
-User::LeaveIfError(idx);
+LEAVEIFERROR(idx,
-__FLOG(_L8("StorageMetaDataL - Exit"));
+OstTrace1( TRACE_ERROR, CMTPSTORAGEMGR_STORAGEMETADATAL, "can't find storage with storageId %d", idx ));
+OstTraceFunctionExit0( CMTPSTORAGEMGR_STORAGEMETADATAL_EXIT );
 return *iStorages[idx];
 }
 /**
 Implements a storage key match identity relation using

changeset 49	c20dd21d1eb4
parent 29	3ae5cb0b4c02