diff -r f1fd07aa74c9 -r 59aa7d6e3e0f usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/src/CUsbMsClassController.cpp --- a/usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/src/CUsbMsClassController.cpp Wed Jul 07 14:16:40 2010 +0800 +++ b/usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/src/CUsbMsClassController.cpp Wed Jul 07 15:08:54 2010 +0800 @@ -1,5 +1,5 @@ /* -* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). +* Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies). * All rights reserved. * This component and the accompanying materials are made available * under the terms of "Eclipse Public License v1.0" @@ -28,14 +28,13 @@ #include #include #include "CUsbMsClassController.h" -#include - -#ifdef __FLOG_ACTIVE -_LIT8(KLogComponent, "MSCC"); +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "CUsbMsClassControllerTraces.h" #endif +#ifdef _DEBUG // Panic category -#ifdef _DEBUG _LIT( KMsCcPanicCategory, "UsbMsCc" ); #endif @@ -58,12 +57,12 @@ CUsbMsClassController* CUsbMsClassController::NewL( MUsbClassControllerNotify& aOwner) { - LOG_STATIC_FUNC_ENTRY - + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_NEWL_ENTRY ); CUsbMsClassController* r = new (ELeave) CUsbMsClassController(aOwner); CleanupStack::PushL(r); r->ConstructL(); CleanupStack::Pop(); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_NEWL_EXIT ); return r; } @@ -72,7 +71,9 @@ */ CUsbMsClassController::~CUsbMsClassController() { + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_CUSBMSCLASSCONTROLLER_DES_ENTRY ); Cancel(); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_CUSBMSCLASSCONTROLLER_DES_EXIT ); } /** @@ -84,7 +85,9 @@ MUsbClassControllerNotify& aOwner) : CUsbClassControllerPlugIn(aOwner, KMsStartupPriority) { + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_CUSBMSCLASSCONTROLLER_CONS_ENTRY ); // Intentionally left blank + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_CUSBMSCLASSCONTROLLER_CONS_EXIT ); } /** @@ -92,9 +95,9 @@ */ void CUsbMsClassController::ConstructL() { - LOG_FUNC - + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_CONSTRUCT_ENTRY ); ReadMassStorageConfigL(); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_CONSTRUCT_EXIT ); } /** @@ -104,11 +107,16 @@ */ void CUsbMsClassController::Start(TRequestStatus& aStatus) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_START_ENTRY ); // The service state should always be idle when this function is called // (guaranteed by CUsbSession). - __ASSERT_DEBUG( iState == EUsbServiceIdle, _USB_PANIC(KMsCcPanicCategory, EBadApiCall) ); + + if (iState != EUsbServiceIdle) + { + OstTrace1( TRACE_FATAL, CUSBMSCLASSCONTROLLER_START, "CUsbMsClassController::Star;iState=%d", (TInt)iState ); + __ASSERT_DEBUG( EFalse, User::Panic(KMsCcPanicCategory, EBadApiCall) ); + } TRequestStatus* reportStatus = &aStatus; @@ -121,7 +129,9 @@ { iState = EUsbServiceIdle; User::RequestComplete(reportStatus, err); - LOGTEXT(_L8("Failed to connect to mass storage file server")); + OstTrace0( TRACE_NORMAL, CUSBMSCLASSCONTROLLER_START_DUP1, + "CUsbMsClassController::Start;Failed to connect to mass storage file server" ); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_START_EXIT ); return; } @@ -131,19 +141,19 @@ if (err != KErrNone) { iState = EUsbServiceIdle; - // Connection was created successfully in last step // Get it closed since failed to start device. iUsbMs.Close(); - User::RequestComplete(reportStatus, err); - LOGTEXT(_L8("Failed to start mass storage device")); + OstTrace0( TRACE_NORMAL, CUSBMSCLASSCONTROLLER_START_DUP2, + "CUsbMsClassController::Start;Failed to start mass storage device" ); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_START_EXIT_DUP1 ); return; } iState = EUsbServiceStarted; - User::RequestComplete(reportStatus, KErrNone); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_START_EXIT_DUP2 ); } /** @@ -153,27 +163,32 @@ */ void CUsbMsClassController::Stop(TRequestStatus& aStatus) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_STOP_ENTRY ); // The service state should always be started when this function is called // (guaranteed by CUsbSession) - __ASSERT_DEBUG( iState == EUsbServiceStarted, _USB_PANIC(KMsCcPanicCategory, EBadApiCall) ); + if (iState != EUsbServiceStarted) + { + OstTrace1( TRACE_FATAL, CUSBMSCLASSCONTROLLER_STOP, "CUsbMsClassController::Stop;iState=%d", (TInt)iState ); + __ASSERT_DEBUG( EFalse, User::Panic(KMsCcPanicCategory, EBadApiCall) ); + } TRequestStatus* reportStatus = &aStatus; - TInt err = iUsbMs.Stop(); if (err != KErrNone) { iState = EUsbServiceStarted; User::RequestComplete(reportStatus, err); - LOGTEXT(_L8("Failed to stop mass storage device")); + OstTrace0( TRACE_NORMAL, CUSBMSCLASSCONTROLLER_STOP_DUP1, + "CUsbMsClassController::Start;Failed to stop mass storage device" ); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_STOP_EXIT ); return; } iUsbMs.Close(); - User::RequestComplete(reportStatus, KErrNone); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_START_STOP_DUP1 ); } /** @@ -184,7 +199,11 @@ */ void CUsbMsClassController::GetDescriptorInfo(TUsbDescriptor& /*aDescriptorInfo*/) const { - __ASSERT_DEBUG( EFalse, _USB_PANIC(KMsCcPanicCategory, EUnusedFunction)); + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_GETDESCRIPTORINFO_ENTRY ); + OstTrace1( TRACE_FATAL, CUSBMSCLASSCONTROLLER_GETDESCRIPTORINFO, + "CUsbMsClassController::GetDescriptorInfo;panic line=%d", (TInt)__LINE__ ); + __ASSERT_DEBUG( EFalse, User::Panic(KMsCcPanicCategory, EUnusedFunction) ); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_GETDESCRIPTORINFO_EXIT ); } /** @@ -193,7 +212,11 @@ */ void CUsbMsClassController::RunL() { - __ASSERT_DEBUG( EFalse, _USB_PANIC(KMsCcPanicCategory, EUnusedFunction) ); + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_RUNL_ENTRY ); + OstTrace1( TRACE_FATAL, CUSBMSCLASSCONTROLLER_RUNL, + "CUsbMsClassController::RunL;panic line=%d", (TInt)__LINE__ ); + __ASSERT_DEBUG( EFalse, User::Panic(KMsCcPanicCategory, EUnusedFunction) ); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_RUNL_EXIT ); } /** @@ -202,7 +225,11 @@ */ void CUsbMsClassController::DoCancel() { - __ASSERT_DEBUG( EFalse, _USB_PANIC(KMsCcPanicCategory, EUnusedFunction) ); + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_DOCANCEL_ENTRY ); + OstTrace1( TRACE_FATAL, CUSBMSCLASSCONTROLLER_DOCANCEL, + "CUsbMsClassController::DoCancel;panic line=%d", (TInt)__LINE__ ); + __ASSERT_DEBUG( EFalse, User::Panic(KMsCcPanicCategory, EUnusedFunction) ); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_DOCANCEL_EXIT ); } /** @@ -214,7 +241,11 @@ */ TInt CUsbMsClassController::RunError(TInt /*aError*/) { - __ASSERT_DEBUG( EFalse, _USB_PANIC(KMsCcPanicCategory, EUnusedFunction) ); + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_RUNERROR_ENTRY ); + OstTrace1( TRACE_FATAL, CUSBMSCLASSCONTROLLER_RUNERROR, + "CUsbMsClassController::RunError;panic line=%d", (TInt)__LINE__ ); + __ASSERT_DEBUG( EFalse, User::Panic(KMsCcPanicCategory, EUnusedFunction) ); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_RUNERROR_EXIT ); return KErrNone; } @@ -223,21 +254,31 @@ */ void CUsbMsClassController::ReadMassStorageConfigL() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_READMASSSTORAGECONFIGL_ENTRY ); // Try to connect to file server - RFs fs; - LEAVEIFERRORL(fs.Connect()); + RFs fs; + TInt fserr = fs.Connect(); + + if (fserr < 0) + { + OstTrace1( TRACE_FATAL, CUSBMSCLASSCONTROLLER_READMASSSTORAGECONFIGL, + "CUsbMsClassController::ReadMassStorageConfigL;leave err = %d", fserr ); + User::Leave(fserr); + } CleanupClosePushL(fs); RResourceFile resource; TRAPD(err, resource.OpenL(fs, KUsbMsResource)); - LOGTEXT2(_L8("Opened resource file with error %d"), err); + OstTrace1( TRACE_NORMAL, CUSBMSCLASSCONTROLLER_READMASSSTORAGECONFIGL_DUP1, + "CUsbMsClassController::ReadMassStorageConfigL;Opened resource file with error %d", err ); if (err != KErrNone) { - LOGTEXT(_L8("Unable to open resource file")); + OstTrace0( TRACE_NORMAL, CUSBMSCLASSCONTROLLER_READMASSSTORAGECONFIGL_DUP2, + "CUsbMsClassController::ReadMassStorageConfigL;Unable to open resource file" ); CleanupStack::PopAndDestroy(&fs); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_READMASSSTORAGECONFIGL_EXIT ); return; } @@ -249,8 +290,10 @@ TRAPD(ret, msConfigBuf = resource.AllocReadL(USBMS_CONFIG)); if (ret != KErrNone) { - LOGTEXT(_L8("Failed to open mass storage configuration file")); + OstTrace0( TRACE_NORMAL, CUSBMSCLASSCONTROLLER_READMASSSTORAGECONFIGL_DUP3, + "CUsbMsClassController::ReadMassStorageConfigL;Failed to open mass storage configuration file" ); CleanupStack::PopAndDestroy(2, &fs); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_READMASSSTORAGECONFIGL_EXIT_DUP1 ); return; } CleanupStack::PushL(msConfigBuf); @@ -282,11 +325,17 @@ ConfigItem(productRev, iMsConfig.iProductRev, 4); // Debugging - LOGTEXT2(_L8("vendorId = %S\n"), &vendorId); - LOGTEXT2(_L8("productId = %S\n"), &productId); - LOGTEXT2(_L8("productRev = %S\n"), &productRev); + OstTraceExt1( TRACE_NORMAL, CUSBMSCLASSCONTROLLER_READMASSSTORAGECONFIGL_DUP4, + "CUsbMsClassController::ReadMassStorageConfigL;vendorId = %S\n", vendorId ); + + OstTraceExt1( TRACE_NORMAL, CUSBMSCLASSCONTROLLER_READMASSSTORAGECONFIGL_DUP5, + "CUsbMsClassController::ReadMassStorageConfigL;productId = %S\n", productId ); + + OstTraceExt1( TRACE_NORMAL, CUSBMSCLASSCONTROLLER_READMASSSTORAGECONFIGL_DUP6, + "CUsbMsClassController::ReadMassStorageConfigL;productRev = %S\n", productRev ); CleanupStack::PopAndDestroy(3, &fs); // msConfigBuf, resource, fs + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_READMASSSTORAGECONFIGL_EXIT_DUP2 ); } /** @@ -295,11 +344,13 @@ */ void CUsbMsClassController::ConfigItem(const TPtrC& source, TDes& target, TInt maxLength) { + OstTraceFunctionEntry0( CUSBMSCLASSCONTROLLER_CONFIGITEM_ENTRY ); if (source.Length() < maxLength) { maxLength = source.Length(); } - target.Copy(source.Ptr(), maxLength); + target.Copy(source.Ptr(), maxLength); + OstTraceFunctionExit0( CUSBMSCLASSCONTROLLER_CONFIGITEM_EXIT ); }