diff -r 2c19c7cf5550 -r c20dd21d1eb4 mtpfws/mtpfw/src/cmtpstoragemgr.cpp --- a/mtpfws/mtpfw/src/cmtpstoragemgr.cpp Fri Aug 20 17:43:33 2010 +0800 +++ b/mtpfws/mtpfw/src/cmtpstoragemgr.cpp Fri Sep 03 18:38:04 2010 +0800 @@ -20,9 +20,14 @@ #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); @@ -54,12 +59,11 @@ */ EXPORT_C CMTPStorageMgr::~CMTPStorageMgr() { - __FLOG(_L8("~CMTPStorageMgr - Entry")); + OstTraceFunctionEntry0( CMTPSTORAGEMGR_CMTPSTORAGEMGR_DES_ENTRY ); iPhysicalStorageNumbers.Reset(); iStorages.ResetAndDestroy(); iSingletons.Close(); - __FLOG(_L8("~CMTPStorageMgr - Exit")); - __FLOG_CLOSE; + OstTraceFunctionExit0( CMTPSTORAGEMGR_CMTPSTORAGEMGR_DES_EXIT ); } /** @@ -70,6 +74,8 @@ */ EXPORT_C TUint CMTPStorageMgr::LogicalStorageNumber(TUint32 aStorageId) { + OstTraceFunctionEntry0( CMTPSTORAGEMGR_LOGICALSTORAGENUMBER_ENTRY ); + OstTraceFunctionExit0( CMTPSTORAGEMGR_LOGICALSTORAGENUMBER_EXIT ); return (aStorageId & KLogicalNumberMask); } @@ -81,6 +87,7 @@ */ EXPORT_C TUint CMTPStorageMgr::LogicalStorageOwner(TUint32 aStorageId) { + OstTraceFunctionEntry0( CMTPSTORAGEMGR_LOGICALSTORAGEOWNER_ENTRY ); return ((aStorageId & KLogicalIdMask) >> KLogicalOwnerShift); } @@ -92,6 +99,7 @@ */ EXPORT_C TUint CMTPStorageMgr::PhysicalStorageNumber(TUint32 aStorageId) { + OstTraceFunctionEntry0( CMTPSTORAGEMGR_PHYSICALSTORAGENUMBER_ENTRY ); return ((aStorageId & KPhysicalIdMask) >> KPhysicalNumberShift); } @@ -103,6 +111,7 @@ */ EXPORT_C TUint CMTPStorageMgr::PhysicalStorageOwner(TUint32 aStorageId) { + OstTraceFunctionEntry0( CMTPSTORAGEMGR_PHYSICALSTORAGEOWNER_ENTRY ); return ((aStorageId & KPhysicalIdMask) >> KPhysicalOwnerShift); } @@ -115,10 +124,11 @@ */ 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)); - __FLOG(_L8("SetDefaultStorageId - Exit")); + OstTrace1(TRACE_NORMAL, CMTPSTORAGEMGR_SETDEFAULTSTORAGEID, + "Default StorageId = 0x%08X", aStorageId); + OstTraceFunctionExit0( CMTPSTORAGEMGR_SETDEFAULTSTORAGEID_EXIT ); } /** @@ -130,10 +140,11 @@ */ 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)); - __FLOG(_L8("DefineDriveNumberMapping - Exit")); + OstTraceExt2(TRACE_NORMAL, CMTPSTORAGEMGR_SETDRIVEMAPPINGL, + "Drive number %d = StorageID 0x%08X", (int)aDriveNumber, (int)aStorageId); + OstTraceFunctionExit0( CMTPSTORAGEMGR_SETDRIVEMAPPINGL_EXIT ); } /** @@ -145,24 +156,25 @@ */ 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)); - __FLOG(_L8("SetFrameworkStoragesOwner - Exit")); + OstTrace1(TRACE_NORMAL, CMTPSTORAGEMGR_SETFRAMEWORKID, + "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()); @@ -172,11 +184,13 @@ 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) @@ -184,26 +198,34 @@ // 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); @@ -220,30 +242,34 @@ 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 - __FLOG(_L8("AllocateLogicalStorageIdL - Exit")); +#endif // OST_TRACE_COMPILER_IN_USE + 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)); @@ -255,14 +281,15 @@ iStorages.InsertInOrderL(physical, StorageOrder); CleanupStack::Pop(physical); - __FLOG_VA((_L8("Allocated physical StorageID 0x%08X"), id)); - __FLOG(_L8("AllocatePhysicalStorageIdL - Exit")); + OstTrace1(TRACE_NORMAL, CMTPSTORAGEMGR_ALLOCATEPHYSICALSTORAGEIDL, + "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. @@ -283,13 +310,13 @@ } } } - __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) { @@ -305,12 +332,12 @@ 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. @@ -341,20 +368,20 @@ } } } - __FLOG(_L8("DeallocatePhysicalStorageId - Exit")); + OstTraceFunctionExit0( CMTPSTORAGEMGR_DEALLOCATEPHYSICALSTORAGEID_EXIT ); return ret; } EXPORT_C TUint32 CMTPStorageMgr::DefaultStorageId() const { - __FLOG(_L8("DefaultStorageId - Entry")); - __FLOG(_L8("DefaultStorageId - Exit")); + OstTraceFunctionEntry0( CMTPSTORAGEMGR_DEFAULTSTORAGEID_ENTRY ); + 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) { @@ -368,26 +395,26 @@ } } } - __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& aDrives) const { - __FLOG(_L8("GetAvailableDrivesL - Entry")); + OstTraceFunctionEntry0( CMTPSTORAGEMGR_GETAVAILABLEDRIVESL_ENTRY ); aDrives.Reset(); for (TUint i(0); (i < iMapDriveToStorage.Count()); i++) { @@ -396,12 +423,12 @@ aDrives.AppendL(static_cast(i)); } } - __FLOG(_L8("GetAvailableDrivesL - Exit")); + OstTraceFunctionExit0( CMTPSTORAGEMGR_GETAVAILABLEDRIVESL_EXIT ); } EXPORT_C void CMTPStorageMgr::GetLogicalStoragesL(const TMTPStorageMgrQueryParams& aParams, RPointerArray& 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); @@ -416,12 +443,12 @@ aStorages.AppendL(iStorages[i]); } } - __FLOG(_L8("GetLogicalStoragesL - Exit")); + OstTraceFunctionExit0( CMTPSTORAGEMGR_GETLOGICALSTORAGESL_EXIT ); } EXPORT_C void CMTPStorageMgr::GetPhysicalStoragesL(const TMTPStorageMgrQueryParams& aParams, RPointerArray& 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); @@ -436,19 +463,19 @@ aStorages.AppendL(iStorages[i]); } } - __FLOG(_L8("GetPhysicalStoragesL - Exit")); + OstTraceFunctionExit0( CMTPSTORAGEMGR_GETPHYSICALSTORAGESL_EXIT ); } EXPORT_C TUint32 CMTPStorageMgr::LogicalStorageId(TUint32 aStorageId) const { - __FLOG(_L8("LogicalStorageId - Entry")); - __FLOG(_L8("LogicalStorageId - Exit")); + OstTraceFunctionEntry0( CMTPSTORAGEMGR_LOGICALSTORAGEID_TUINT32_ENTRY ); + 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) @@ -459,52 +486,53 @@ 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")); - __FLOG(_L8("PhysicalStorageId - Exit")); + OstTraceFunctionEntry0( CMTPSTORAGEMGR_PHYSICALSTORAGEID_TUINT32_ENTRY ); + 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); - __FLOG(_L8("StorageL - Exit")); + LEAVEIFERROR(idx, + 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")); - __FLOG(_L8("StorageId - Exit")); + OstTraceFunctionEntry0( CMTPSTORAGEMGR_STORAGEID_ENTRY ); + 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; } @@ -530,24 +558,25 @@ 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); } @@ -566,7 +595,7 @@ CMTPTypeString* volumeId = CMTPTypeString::NewL(buffer); CleanupStack::PopAndDestroy(&buffer); - __FLOG(_L8("VolumeIdL - Exit")); + OstTraceFunctionExit0( CMTPSTORAGEMGR_VOLUMEIDL_EXIT ); return volumeId; } @@ -576,7 +605,6 @@ CMTPStorageMgr::CMTPStorageMgr() : iFrameworkId(KErrNotFound) { - } /** @@ -585,14 +613,13 @@ */ void CMTPStorageMgr::ConstructL() { - __FLOG_OPEN(KMTPSubsystem, KComponent); - __FLOG(_L8("ConstructL - Entry")); + OstTraceFunctionEntry0( CMTPSTORAGEMGR_CONSTRUCTL_ENTRY ); iSingletons.OpenL(); for (TUint i(0); (i < KMaxDrives); i++) { iMapDriveToStorage[i] = KErrNotFound; } - __FLOG(_L8("ConstructL - Exit")); + OstTraceFunctionExit0( CMTPSTORAGEMGR_CONSTRUCTL_EXIT ); } /** @@ -606,7 +633,7 @@ */ 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) { @@ -625,7 +652,7 @@ ret = KErrOverflow; } } - __FLOG_STATIC(KMTPSubsystem, KComponent, _L8("AllocateLogicalStorageId - Exit")); + OstTraceFunctionExit0( CMTPSTORAGEMGR_ALLOCATELOGICALSTORAGEID_EXIT ); return ret; } @@ -638,7 +665,7 @@ */ 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)) { @@ -656,7 +683,7 @@ ret = KErrOverflow; } } - __FLOG_STATIC(KMTPSubsystem, KComponent, _L8("AllocatePhysicalStorageId - Exit")); + OstTraceFunctionExit0( CMTPSTORAGEMGR_ALLOCATEPHYSICALSTORAGEID_EXIT ); return ret; } @@ -736,7 +763,7 @@ */ 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. @@ -751,7 +778,7 @@ // Delete the storage. delete iStorages[aIdx]; iStorages.Remove(aIdx); - __FLOG(_L8("RemoveLogicalStorageL - Entry")); + OstTraceFunctionExit0( CMTPSTORAGEMGR_REMOVELOGICALSTORAGEL_EXIT ); } /** @@ -763,10 +790,11 @@ */ CMTPStorageMetaData& CMTPStorageMgr::StorageMetaDataL(TUint32 aStorageId) { - __FLOG(_L8("StorageMetaDataL - Entry")); + OstTraceFunctionEntry0( CMTPSTORAGEMGR_STORAGEMETADATAL_ENTRY ); TInt idx(iStorages.FindInOrder(aStorageId, StorageOrder)); - User::LeaveIfError(idx); - __FLOG(_L8("StorageMetaDataL - Exit")); + LEAVEIFERROR(idx, + OstTrace1( TRACE_ERROR, CMTPSTORAGEMGR_STORAGEMETADATAL, "can't find storage with storageId %d", idx )); + OstTraceFunctionExit0( CMTPSTORAGEMGR_STORAGEMETADATAL_EXIT ); return *iStorages[idx]; }