FCL/sf/os/usb: comparison usbmgmt/usbmgr/usbman/server/SRC/CUsbSession.cpp

equal deleted inserted replaced

-:f1fd07aa74c9
+:59aa7d6e3e0f
 /**
 @file
 */
+#include <usbstates.h>
+#include <usberrors.h>
+#include <usb/usbshared.h>
 #include <usb/usblogger.h>
 #include "CUsbSession.h"
 #include "CUsbDevice.h"
 #include "CUsbServer.h"
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 #include "CUsbOtg.h"
 #include "cusbhost.h"
 #endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
-#include <usbstates.h>
-#include <usberrors.h>
-#include <usb/usbshared.h>
 #include "CPersonality.h"
 #include "rusb.h"
 #include "UsbSettings.h"
+#include "OstTraceDefinitions.h"
-#ifdef __FLOG_ACTIVE
+#ifdef OST_TRACE_COMPILER_IN_USE
-_LIT8(KLogComponent, "USBSVR");
+#include "CUsbSessionTraces.h"
 #endif
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 CUsbSession* CUsbSession::iCtlSession = NULL;
 #endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 *
 * @return	A new CUsbSession object
 */
 CUsbSession* CUsbSession::NewL(CUsbServer* aServer)
 	{
-	LOG_STATIC_FUNC_ENTRY
+	OstTraceFunctionEntry0( CUSBSESSION_NEWL_ENTRY );
 	//this class has moved away from standard NewL() semantics
 	//and now uses the virtual CSession2::CreateL() function
 	//[instead of ConstructL()] which is called by CServer2
 	//and finalises the construction of the session
 * @param	aServer	Service the session will be a member of
 */
 CUsbSession::CUsbSession(CUsbServer* aServer)
 	: iUsbServer(aServer)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_CUSBSESSION_CONS_ENTRY );
 	iUsbServer->IncrementSessionCount();
+	OstTraceFunctionExit0( CUSBSESSION_CUSBSESSION_CONS_EXIT );
 	}
 /**
 * Destructor.
 */
 CUsbSession::~CUsbSession()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_CUSBSESSION_DES_ENTRY );
-	LOGTEXT2(_L8("About to Device().DeRegisterObserver(%08x"),this);
+	OstTrace1( TRACE_NORMAL, CUSBSESSION_CUSBSESSION, "CUsbSession::~CUsbSession;About to Device().DeRegisterObserver(%08x)", this );
 	iUsbServer->Device().DeRegisterObserver(*this);
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 #ifndef __OVER_DUMMYUSBDI__
-	LOGTEXT2(_L8("About to Otg().DeRegisterObserver(%08x"),this);
+	OstTrace1( TRACE_NORMAL, CUSBSESSION_CUSBSESSION_DUP1, "CUsbSession::~CUsbSession;About to Otg().DeRegisterObserver(%08x)", this );
 	iUsbServer->Otg().DeRegisterObserver(*this);
 #endif
-	LOGTEXT2(_L8("About to Host().DeRegisterObserver(%08x"),this);
+	OstTrace1( TRACE_NORMAL, CUSBSESSION_CUSBSESSION_DUP2, "CUsbSession::~CUsbSession;About to Host().DeRegisterObserver(%08x)", this );
 	iUsbServer->Host().DeregisterObserver(*this);
 	if ( iCtlSession && (iCtlSession == this) )
 		{
 		iCtlSession = NULL;
 		}
 #endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
-	LOGTEXT(_L8("About to iUsbServer->DecrementSessionCount()"));
+	OstTrace0( TRACE_NORMAL, CUSBSESSION_CUSBSESSION_DUP3, "CUsbSession::~CUsbSession;About to iUsbServer->DecrementSessionCount()" );
 	iUsbServer->DecrementSessionCount();
+	OstTraceFunctionExit0( CUSBSESSION_CUSBSESSION_DES_EXIT );
 	}
 /**
 * Called when a message is received from the client.
 *
 * @param	aMessage	Message received from the client
 */
 void CUsbSession::ServiceL(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_SERVICEL_ENTRY );
 	DispatchMessageL(aMessage);
+	OstTraceFunctionExit0( CUSBSESSION_SERVICEL_EXIT );
 	}
 /**
 * Handles 2nd Phase Construction.  Implementation of the virtual method defined in CSession2 and called from
 * CServer2::DoConnectL() which executes when the client makes a connection request through CServer2::Connect().  If
 * a Leave occurs at any point the CUsbSession object is cleaned up in CServer2::DoConnect().
 */
 void CUsbSession::CreateL()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_CREATEL_ENTRY );
 	// This code originally existed in the typical non-virtual ConstructL() method.
 	// However it was moved to this method for minor optimisation reasons [three less
 	// function calls and several lines less code in the NewL() method].
 	iPersonalityCfged = iUsbServer->Device().isPersonalityCfged();
-LOGTEXT(_L8("Registering Device Observer\n"));
+OstTrace0( TRACE_NORMAL, CUSBSESSION_CREATEL, "CUsbSession::CreateL;Registering Device Observer" );
 	iUsbServer->Device().RegisterObserverL(*this);
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 #ifndef __OVER_DUMMYUSBDI__
-	LOGTEXT(_L8("Registering OTG Observer\n"));
+	OstTrace0( TRACE_NORMAL, CUSBSESSION_CREATEL_DUP1, "CUsbSession::CreateL;Registering OTG Observer" );
 	iUsbServer->Otg().RegisterObserverL(*this);
 #endif
-	LOGTEXT(_L8("Registering HOST Observer\n"));
+	OstTrace0( TRACE_NORMAL, CUSBSESSION_CREATEL_DUP2, "CUsbSession::CreateL;Registering HOST Observer" );
 	iUsbServer->Host().RegisterObserverL(*this);
 #endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
+	OstTraceFunctionExit0( CUSBSESSION_CREATEL_EXIT );
 	}
 /**
 * Called by CUsbDevice when the service state changes.
 * CUsbSession is an observer of the device.
 * @param	aNewState	The device's new and current service state
 */
 void CUsbSession::UsbServiceStateChange(TInt aLastError, TUsbServiceState aOldState,
 										TUsbServiceState aNewState)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_USBSERVICESTATECHANGE_ENTRY );
-	LOGTEXT3(_L8("    aOldState=0x%X, aNewState=0x%X"), aOldState, aNewState);
+	OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBSERVICESTATECHANGE, "CUsbSession::UsbServiceStateChange;aOldState=0x%X, aNewState=0x%X", aOldState, aNewState );
 	(void) aOldState; // a-void build warning in UREL
 	// Note that it's possible to have both a start and a stop outstanding!
 	if (iStartOutstanding)
 		TPckg<TUint32> pckg(aNewState);
 		iServiceObserverOutstanding = EFalse;
 		const TInt err = iServiceObserverMessage.Write(0, pckg);
 		iServiceObserverMessage.Complete(err);
 		}
+	OstTraceFunctionExit0( CUSBSESSION_USBSERVICESTATECHANGE_EXIT );
 	}
 /**
 * Handles a state change while a start request is currently outstanding.
 *
 * @param aNewState The state we've moved to
 */
 void CUsbSession::HandleServiceStateChangeWhileStarting(TInt aLastError,
 												 TUsbServiceState aNewState)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_ENTRY );
 	switch (aNewState)
 		{
 	case EUsbServiceStarted:
-		LOGTEXT(_L8("    Completing Start successfully"));
+		OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING, "CUsbSession::HandleServiceStateChangeWhileStarting    Completing Start successfully" );
 		// If the user has tried to cancel the start, they're too late!
 		if (iCancelOutstanding)
 			{
-			LOGTEXT(_L8("    Completing cancel request with KErrNone"));
+			OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_DUP1, "CUsbSession::HandleServiceStateChangeWhileStarting    Completing cancel request with KErrNone" );
 			iCancelOutstanding = EFalse;
 			iCancelMessage.Complete(KErrNone);
 			}
 		iStartMessage.Complete(KErrNone);
 		iStartOutstanding = EFalse;
 		break;
 	case EUsbServiceIdle:
-		LOGTEXT2(_L8("    Completing Start with error=%d"), aLastError);
+		OstTrace1( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_DUP2, "CUsbSession::HandleServiceStateChangeWhileStarting;    Completing Start with error=%d", aLastError );
 		// If there hasn't actually been an error, but we're in an unexpected
 		// state now, that means that this client cancelled the request, or
 		// another client stopped the service.
 		if (aLastError == KErrNone)
 			{
 			// If there's a cancel outstanding, then that message succeeded, but
 			// the start message should be completed with KErrCancel.
 			if (iCancelOutstanding)
 				{
-				LOGTEXT(_L8("    Completing original message with KErrCancel"));
+				OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_DUP3, "CUsbSession::HandleServiceStateChangeWhileStarting    Completing original message with KErrCancel" );
 				iCancelOutstanding = EFalse;
 				iCancelMessage.Complete(KErrNone);
 				iStartMessage.Complete(KErrCancel);
 				}
 			else
 		break;
 	default:
 		break;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_EXIT );
 	}
 /**
 * Handles a state change while a stop request is currently outstanding.
 *
 * @param aNewState The state we've moved to
 */
 void CUsbSession::HandleServiceStateChangeWhileStopping(TInt aLastError,
 												 TUsbServiceState aNewState)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_ENTRY );
 	switch (aNewState)
 		{
 	case EUsbServiceStarted:
-		LOGTEXT2(_L8("    Completing Stop with error=%d"), aLastError);
+		OstTrace1( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING, "CUsbSession::HandleServiceStateChangeWhileStopping;    Completing Stop with error=%d", aLastError );
 		// If there hasn't actually been an error, but we're in an unexpected
 		// state now, that means that this client cancelled the request, or
 		// another client has started the service.
 		if (aLastError == KErrNone)
 			{
 			// If there's a cancel outstanding, then that message succeeded, but
 			// the stop message should be completed with KErrCancel.
 			if (iCancelOutstanding)
 				{
-				LOGTEXT(_L8("    Completing original message with KErrCancel"));
+				OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_DUP1, "CUsbSession::HandleServiceStateChangeWhileStopping;    Completing original message with KErrCancel" );
 				iCancelOutstanding = EFalse;
 				iCancelMessage.Complete(KErrNone);
 				iStopMessage.Complete(KErrCancel);
 				}
 			else
 		iStopOutstanding = EFalse;
 		break;
 	case EUsbServiceIdle:
-		LOGTEXT(_L8("    Completing Stop with KErrNone"));
+		OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_DUP2, "CUsbSession::HandleServiceStateChangeWhileStopping    Completing Stop with KErrNone" );
 		// If the user has tried to cancel the stop, they're too late!
 		if (iCancelOutstanding)
 			{
-			LOGTEXT(_L8("    Completing cancel request with KErrNone"));
+			OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_DUP3, "CUsbSession::HandleServiceStateChangeWhileStopping    Completing cancel request with KErrNone" );
 			iCancelOutstanding = EFalse;
 			iCancelMessage.Complete(KErrNone);
 			}
 		iStopMessage.Complete(KErrNone);
 		break;
 	default:
 		break;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_EXIT );
 	}
 /**
 * Called by CUsbDevice when it state change. CUsbSession is an observer of
 * the device. If the client has an Observer outstanding then complete it,
 * @param	aNewState	The device's new and current state
 */
 void CUsbSession::UsbDeviceStateChange(TInt /*aLastError*/, TUsbDeviceState /*aOldState*/,
 									   TUsbDeviceState aNewState)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_USBDEVICESTATECHANGE_ENTRY );
 	// can we bypass the queue?
 	if ((iDeviceObserverOutstanding) && (iDevStateQueueHead == iDevStateQueueTail))
 		{
 		if ((iDeviceObserverMessage.Int0() & aNewState) ||
 			while (queuePtr != iDevStateQueueHead)
 				{
 				if (aNewState == iDeviceStateQueue[queuePtr])
 					{
 					// Event is already queued; discard the duplicate and in-between events
-					LOGTEXT3(_L8("--- collapsing queue head (%d, %d)"),
+					OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBDEVICESTATECHANGE, "CUsbSession::UsbDeviceStateChange;--- collapsing queue head (%d, %d)", iDevStateQueueHead, ((queuePtr + 1) % KDeviceStatesQueueSize) );
-						iDevStateQueueHead,
-						(queuePtr + 1) % KDeviceStatesQueueSize);
 					// queue head moved to position following the match
 					iDevStateQueueHead = (queuePtr + 1) % KDeviceStatesQueueSize;
 					addToQueue = EFalse;
 					break;
 		if (addToQueue)
 			{
 			// add event to head of queue
 			iDeviceStateQueue[iDevStateQueueHead] = aNewState;
 			iDevStateQueueHead = (iDevStateQueueHead + 1) % KDeviceStatesQueueSize;
-			LOGTEXT3(_L8("+++ addqueue (%d, %d)"), iDevStateQueueHead,
+			OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBDEVICESTATECHANGE_DUP1, "CUsbSession::UsbDeviceStateChange;+++ addqueue (%d, %d)", iDevStateQueueHead, iDevStateQueueTail );
-				iDevStateQueueTail);
 			}
 		// UsbDeviceDequeueEvent() will read from queue when RegisterObserver()
 		// is next called.
 		}
+	OstTraceFunctionExit0( CUSBSESSION_USBDEVICESTATECHANGE_EXIT );
 	}
 /**
 * Dequeues an event and completes the observer's request with it.
 */
 void CUsbSession::UsbDeviceDequeueEvent()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_USBDEVICEDEQUEUEEVENT_ENTRY );
 	// Work our way through the queue, until we reach the end
 	// OR we find an event the current observer wants.
 	while ((iDeviceObserverOutstanding) && (iDevStateQueueHead != iDevStateQueueTail))
 		{
 			{
 			TPckg<TUint32> pckg(newState);
 			iNotifiedDevState = newState;
-			LOGTEXT3(_L8(">>> dequeued event #%d (0x%x)"), iDevStateQueueTail, newState);
+			OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBDEVICEDEQUEUEEVENT, "CUsbSession::UsbDeviceDequeueEvent;dequeued event #%d (0x%x)", iDevStateQueueTail, newState );
 			iDeviceObserverOutstanding = EFalse;
 			const TInt err = iDeviceObserverMessage.Write(1, pckg);
 			iDeviceObserverMessage.Complete(err);
 			break;
 			}
 		}
+	OstTraceFunctionExit0( CUSBSESSION_USBDEVICEDEQUEUEEVENT_EXIT );
 	}
 /**
 * Handles the request (in the form of a the message) received from the client
 *
 * @internalComponent
 * @param	aMessage	The received message
 */
 void CUsbSession::DispatchMessageL(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_DISPATCHMESSAGEL_ENTRY );
 	TBool complete = ETrue;
 	TInt ret = KErrNone;
-	LOGTEXT2(_L8("CUsbSession::DispatchMessageL(): func# %d"), aMessage.Function());
+	OstTrace1( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL, "CUsbSession::DispatchMessageL;func#=%d", aMessage.Function() );
 	switch (aMessage.Function())
 		{
 	case EUsbStart:
 		ret = StartDeviceL(aMessage, complete);
 #ifdef _DEBUG
 	// Heap failure debug APIs.
 	case EUsbDbgMarkHeap:
-		LOGTEXT(_L8("Marking heap"));
+		OstTrace0( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP1, "CUsbSession::DispatchMessageL;Marking heap" );
 		__UHEAP_MARK;
 		break;
 	case EUsbDbgCheckHeap:
-		LOGTEXT2(_L8("Checking heap (expecting %d cells)"), aMessage.Int0());
+		OstTrace1( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP2, "CUsbSession::DispatchMessageL;Checking heap (expecting %d cells)", aMessage.Int0() );
 		__UHEAP_CHECK(aMessage.Int0());
 		break;
 	case EUsbDbgMarkEnd:
-		LOGTEXT2(_L8("End of marking heap (expecting %d cells)"), aMessage.Int0());
+		OstTrace1( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP3, "CUsbSession::DispatchMessageL;End of marking heap (expecting %d cells)", aMessage.Int0() );
 		__UHEAP_MARKENDC(aMessage.Int0());
 		break;
 	case EUsbDbgFailNext:
 		{
-		LOGTEXT2(_L8("Simulating failure after %d allocation(s)"), aMessage.Int0());
+		OstTrace1( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP4, "CUsbSession::DispatchMessageL;Simulating failure after %d allocation(s)", aMessage.Int0() );
 		if (aMessage.Int0() == 0)
 			__UHEAP_RESET;
 		else
 			__UHEAP_FAILNEXT(aMessage.Int0());
 		}
 		break;
 	case EUsbDbgAlloc:
 		{
 		ret = KErrNone;
 #ifdef _DEBUG
-		LOGTEXT(_L8("\tallocate on the heap"));
+		OstTrace0( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP5, "CUsbSession::DispatchMessageL;allocate on the heap" );
 		TInt* x = NULL;
 		TRAP(ret, x = new(ELeave) TInt);
 		delete x;
 #endif // _DEBUG
 		}
 		ret = KErrNotSupported;
 		break;
 #endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 	default:
-		LOGTEXT2(_L8("Illegal IPC argument(%d) - Panicking Client..."), aMessage.Function());
+		OstTrace1( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP6, "CUsbSession::DispatchMessageL;Illegal IPC argument(%d) - Panicking Client...", aMessage.Function() );
 		aMessage.Panic(KUsbCliPncCat, EUsbPanicIllegalIPC);
 		complete = EFalse;
 		break;
 		}
 	if (complete)
 		aMessage.Complete(ret);
+	OstTraceFunctionExit0( CUSBSESSION_DISPATCHMESSAGEL_EXIT );
 	}
 /**
 * Client request to start the device.
 * @param	aComplete	Whether the request is complete or not
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::StartDeviceL(const RMessage2& aMessage, TBool& aComplete)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_STARTDEVICEL_ENTRY );
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 	// Only 'control' session is allowed to start USB support
 	if ( !iSessionCtlMode )
 		{
+		OstTraceFunctionExit0( CUSBSESSION_STARTDEVICEL_EXIT );
 		return KErrAccessDenied;
 		}
 #endif
 	if (iStartOutstanding)
 		aComplete = EFalse;
 		iStartMessage = aMessage;
 		iStartOutstanding = ETrue;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_STARTDEVICEL_EXIT_DUP1 );
 	return KErrNone;
 #else
 	// pretend that the server is in Started state
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 	iUsbServer->Host().StartL();
 #endif
 	iStartOutstanding = EFalse;
 	aMessage.IsNull();
 	aComplete = ETrue;
+	OstTraceFunctionExit0( CUSBSESSION_STARTDEVICEL_EXIT_DUP2 );
 	return KErrNone;
 #endif
 	}
 * @param	aComplete	Whether the request is complete or not
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::StopDeviceL(const RMessage2& aMessage, TBool& aComplete)
 {
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_STOPDEVICEL_ENTRY );
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 	// Only 'control' session is allowed to stop USB support
 	if ( !iSessionCtlMode )
 		{
+		OstTraceFunctionExit0( CUSBSESSION_STOPDEVICEL_EXIT );
 		return KErrAccessDenied;
 		}
 #endif
 	if (iStopOutstanding)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_STOPDEVICEL_EXIT_DUP1 );
 		return KErrInUse;
 		}
 #ifndef __OVER_DUMMYUSBDI__
 		aComplete = EFalse;
 		iStopMessage = aMessage;
 		iStopOutstanding = ETrue;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_STOPDEVICEL_EXIT_DUP2 );
 	return KErrNone;
 #else
 	// pretend that the server is in Started state
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 	iUsbServer->Host().Stop();
 #endif
 	aComplete = ETrue;
 	aMessage.IsNull();
 	iStopOutstanding = EFalse;
+	OstTraceFunctionExit0( CUSBSESSION_STOPDEVICEL_EXIT_DUP3 );
 	return KErrNone;
 #endif
 }
 * @param aComplete Whether the message is complete or not
 * @return Always KErrNone
 */
 TInt CUsbSession::StartCancel(const RMessage2& aMessage, TBool& aComplete)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_STARTCANCEL_ENTRY );
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 	// Only 'control' session is allowed to cancel outstaning start request
 	if ( !iSessionCtlMode )
 		{
+		OstTraceFunctionExit0( CUSBSESSION_STARTCANCEL_EXIT );
 		return KErrAccessDenied;
 		}
 #endif
 	if (!iStartOutstanding)
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 		iUsbServer->Host().Stop();
 #endif
 		}
+	OstTraceFunctionExit0( CUSBSESSION_STARTCANCEL_EXIT_DUP1 );
 	return KErrNone;
 	}
 /**
 * Cancel the pending stop operation. Note that this can just be implemented as
 * @param aComplete Whether the message is complete or not
 * @return KErrNone on success, otherwise standard error codes
 */
 TInt CUsbSession::StopCancel(const RMessage2& aMessage, TBool& aComplete)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_STOPCANCEL_ENTRY );
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 	// Only 'control' session is allowed to cancel outstaning stop request
 	if ( !iSessionCtlMode )
 		{
+		OstTraceFunctionExit0( CUSBSESSION_STOPCANCEL_EXIT );
 		return KErrAccessDenied;
 		}
 #endif
 	if (!iStopOutstanding)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_STOPCANCEL_EXIT_DUP1 );
 		return KErrNone;
 		}
 	aComplete = EFalse;
 	iCancelMessage = aMessage;
 	TRAPD(errHost,iUsbServer->Host().StartL());
 	if (errHost != KErrNone)
 		return errHost;
 #endif
 	TRAPD(err, iUsbServer->Device().StartL());
+	OstTraceFunctionExit0( CUSBSESSION_STOPCANCEL_EXIT_DUP2 );
 	return err;
 	}
 /**
 * Client request to observe the device (for state changes).
 *
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::RegisterDeviceObserver(const RMessage2& aMessage, TBool& aComplete)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_REGISTERDEVICEOBSERVER_ENTRY );
 	if (iDeviceObserverOutstanding)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_REGISTERDEVICEOBSERVER_EXIT );
 		return KErrInUse;
 		}
 	iDeviceObserverMessage = aMessage;
 	iDeviceObserverOutstanding = ETrue;
 	if (iObserverQueueEvents == EFalse)
 	 	{
 		// This is the first observer after c'tor or DeregisterObserver(),
 		// so zap the device event queue.
-		LOGTEXT(_L8("    Reset Device Event Queue"));
+		OstTrace0( TRACE_NORMAL, CUSBSESSION_REGISTERDEVICEOBSERVER, "CUsbSession::RegisterDeviceObserver    Reset Device Event Queue" );
 		iDevStateQueueHead = 0;
 		iDevStateQueueTail = 0;
 		iObserverQueueEvents = ETrue;
 	 	}
 	else if (iDevStateQueueHead != iDevStateQueueTail)
 	 	{
 		// event(s) queued, we can de-queue one now
 		UsbDeviceDequeueEvent();
 	 	}
+	OstTraceFunctionExit0( CUSBSESSION_REGISTERDEVICEOBSERVER_EXIT_DUP1 );
 	return KErrNone;
 	}
 /**
 * Client request to observe the service (for state changes)
 *
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::RegisterServiceObserver(const RMessage2& aMessage, TBool& aComplete)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_REGISTERSERVICEOBSERVER_ENTRY );
 	if (iServiceObserverOutstanding)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_REGISTERSERVICEOBSERVER_EXIT );
 		return KErrInUse;
 		}
 	iServiceObserverMessage = aMessage;
 	iServiceObserverOutstanding = ETrue;
 	aComplete = EFalse;
+	OstTraceFunctionExit0( CUSBSESSION_REGISTERSERVICEOBSERVER_EXIT_DUP1 );
 	return KErrNone;
 	}
 /**
 *
 * @return	Any errors that occurred or KErrNone
 */
 TInt CUsbSession::GetCurrentServiceState(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_GETCURRENTSERVICESTATE_ENTRY );
 	TUsbServiceState state = iUsbServer->Device().ServiceState();
-	LOGTEXT2(_L8("\tstate = %d"), state);
+	OstTrace1( TRACE_NORMAL, CUSBSESSION_GETCURRENTSERVICESTATE, "CUsbSession::GetCurrentServiceState;state=%d", state );
 	TPckg<TUint32> pckg(state);
 	return aMessage.Write(0, pckg);
 	}
 /**
 *
 * @return	Any errors that occurred or KErrNone
 */
 TInt CUsbSession::GetCurrentDeviceState(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_GETCURRENTDEVICESTATE_ENTRY );
 	TUsbDeviceState state = iUsbServer->Device().DeviceState();
-	LOGTEXT2(_L8("\tstate = %d"), state);
+	OstTrace1( TRACE_NORMAL, CUSBSESSION_GETCURRENTDEVICESTATE, "CUsbSession::GetCurrentDeviceState;state=%d", state );
 	TPckg<TUint32> pckg(state);
 	return aMessage.Write(0, pckg);
 	}
 *
 * @return Always KErrNone
 */
 TInt CUsbSession::DeRegisterDeviceObserver()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_DEREGISTERDEVICEOBSERVER_ENTRY );
 	if (!iDeviceObserverOutstanding)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_DEREGISTERDEVICEOBSERVER_EXIT );
 		return KErrNone;
 		}
 	iDeviceObserverOutstanding = EFalse;
 	iDeviceObserverMessage.Complete(KErrCancel);
 	// client doesn't need events queuing any more
 	iObserverQueueEvents = EFalse;
+	OstTraceFunctionExit0( CUSBSESSION_DEREGISTERDEVICEOBSERVER_EXIT_DUP1 );
 	return KErrNone;
 	}
 /**
 * Deregister the client as an observer of service state changes. Note that we don't
 *
 * @return Always KErrNone
 */
 TInt CUsbSession::DeRegisterServiceObserver()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_DEREGISTERSERVICEOBSERVER_ENTRY );
 	if (!iServiceObserverOutstanding)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_DEREGISTERSERVICEOBSERVER_EXIT );
 		return KErrNone;
 		}
 	iServiceObserverOutstanding = EFalse;
 	iServiceObserverMessage.Complete(KErrCancel);
+	OstTraceFunctionExit0( CUSBSESSION_DEREGISTERSERVICEOBSERVER_EXIT_DUP1 );
 	return KErrNone;
 	}
 /**
 * Try starting the USB device.
 * @param	aComplete	set to true to complete the request
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::TryStartDeviceL(const RMessage2& aMessage, TBool& aComplete)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_TRYSTARTDEVICEL_ENTRY );
 #ifndef __OVER_DUMMYUSBDI__
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 	// Only 'control' session is allowed to start USB support
 	if ( !iSessionCtlMode )
 		{
+		OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT );
 		return KErrAccessDenied;
 		}
 #endif
 	if (!iPersonalityCfged)
 	{
+	OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP1 );
 	return KErrNotSupported;
 	}
 	if (iStartOutstanding || iStopOutstanding)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP2 );
 		return KErrServerBusy;
 		}
 	// Obtains the curent service state
 	TUsbServiceState state = iUsbServer->Device().ServiceState();
 		}
 	else if (state == EUsbServiceStarting || state == EUsbServiceStarted)
 		{
 		if (aMessage.Int0() != iUsbServer->Device().CurrentPersonalityId())
 			{
+			OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP3 );
 			return KErrAbort;
 			}
 		if (state == EUsbServiceStarting)
 			{
 			iStartOutstanding = ETrue;
 			}
 		}
 	else if (state == EUsbServiceStopping)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP4 );
 		return KErrServerBusy;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP5 );
 	return KErrNone;
 #else
 	// pretend that the server is in Started state
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 	iUsbServer->Host().StartL();
 #endif
 	iStartOutstanding = EFalse;
 	aMessage.IsNull();
 	aComplete = ETrue;
+	OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP6 );
 	return KErrNone;
 #endif
 	}
 /**
 * @param	aComplete	Whether the request is complete or not
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::TryStopDeviceL(const RMessage2& aMessage, TBool& aComplete)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_TRYSTOPDEVICEL_ENTRY );
 #ifndef __OVER_DUMMYUSBDI__
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 	// Only 'control' session is allowed to stop USB support
 	if ( !iSessionCtlMode )
 		{
+		OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT );
 		return KErrAccessDenied;
 		}
 #endif
 	if (!iPersonalityCfged)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT_DUP1 );
 		return KErrNotSupported;
 		}
 	if (iStartOutstanding || iStopOutstanding)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT_DUP2 );
 		return KErrServerBusy;
 		}
 	// Obtains the curent service state
 	TUsbServiceState state = iUsbServer->Device().ServiceState();
 		iStopMessage = aMessage;
 		iStopOutstanding = ETrue;
 		}
 	else if (state == EUsbServiceStarting)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT_DUP3 );
 		return KErrServerBusy;
 		}
 	else if (state == EUsbServiceStopping)
 		{
 		aComplete = EFalse;
 		iStopMessage = aMessage;
 		iStopOutstanding = ETrue;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT_DUP4 );
 	return KErrNone;
 #else
 	// pretend that the server is in Started state
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 	iUsbServer->Host().Stop();
 #endif
 	aMessage.IsNull();
 	aComplete = ETrue;
 	iStopOutstanding = EFalse;
+	OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT_DUP5 );
 	return KErrNone;
 #endif
 	}
 /**
 * @param	aMessage	Message received from the client
 * @return	KErrCancel
 */
 TInt CUsbSession::CancelInterest(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_CANCELINTEREST_ENTRY );
 	if (!iPersonalityCfged)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_CANCELINTEREST_EXIT );
 		return KErrNotSupported;
 		}
 	TUsbMessages toBeCancelledMsg = static_cast<TUsbMessages>(aMessage.Int0());
 	if (toBeCancelledMsg == EUsbStart || toBeCancelledMsg == EUsbTryStart)
 			iStopMessage.Complete(KErrNone);
 			iStopOutstanding = EFalse;
 			}
 		}
+	OstTraceFunctionExit0( CUSBSESSION_CANCELINTEREST_EXIT_DUP1 );
 	return KErrCancel;
 	}
 /**
 * Gets the current personality id.
 * @param	aMessage	Message received from the client
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::GetCurrentPersonalityId(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_GETCURRENTPERSONALITYID_ENTRY );
 	if (!iPersonalityCfged)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_GETCURRENTPERSONALITYID_EXIT );
 		return KErrNotSupported;
 		}
 	TInt currentPersonalityId = iUsbServer->Device().CurrentPersonalityId();
-	LOGTEXT2(_L8("\tcurrentPersonalityId = %d"), currentPersonalityId);
+	OstTrace1( TRACE_NORMAL, CUSBSESSION_GETCURRENTPERSONALITYID, "CUsbSession::GetCurrentPersonalityId;currentPersonalityId=%d", currentPersonalityId );
 	TPckgC<TInt> pckg(currentPersonalityId);
 	return aMessage.Write(0, pckg);
 	}
 /**
 *          KErrNotSupported if personality is not configured
 * 			return code from RMessage2.Write()
 */
 TInt CUsbSession::GetSupportedClasses(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_GETSUPPORTEDCLASSES_ENTRY );
 	if (!iPersonalityCfged)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDCLASSES_EXIT );
 		return KErrNotSupported;
 		}
 	// +1 for the size of actual class uid count
 	TInt32 classUids[KUsbMaxSupportedClasses + 1];
 	// Gets all class uids for the given personality
 	const RPointerArray<CPersonality>&  personalities = iUsbServer->Device().Personalities();
 	TInt personalityCount = personalities.Count();
 	for (TInt i = 0; i < personalityCount; i++)
 		{
-		__ASSERT_ALWAYS(personalities[i] != NULL, _USB_PANIC(KUsbSvrPncCat, ENullPersonalityPointer));
+		if(personalities[i] == NULL)
+		    {
+OstTrace1( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDCLASSES, "CUsbSession::GetSupportedClasses;ENullPersonalityPointer=%d", ENullPersonalityPointer );
+User::Panic(KUsbSvrPncCat, ENullPersonalityPointer);
+		    }
 		if (aMessage.Int0() == personalities[i]->PersonalityId())
 			{
 			classUids[0] = personalities[i]->SupportedClasses().Count();
 			for (TInt j = 1; j <= classUids[0]; j++)
 				{
 				if (j < KUsbMaxSupportedClasses + 1)
 					{
 					classUids[j] = personalities[i]->SupportedClasses()[j - 1].iClassUid.iUid;
-					LOGTEXT3(_L8("\tclassUids[%d] = %d"), j, classUids[j]);
+					OstTrace1( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDCLASSES_DUP1, "CUsbSession::GetSupportedClasses;classUids[%d] = ", j );
+					OstTrace1( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDCLASSES_DUP2, "%d", classUids[j] );
 					}
 				else
 					{
+					OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDCLASSES_EXIT_DUP1 );
 					return KErrTooBig;
 					}
 				}
 			break;
 			}
 		}
 	if (classUids[0] == 0)
 		{
 		// No supported classes are found
+		OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDCLASSES_EXIT_DUP2 );
 		return KErrNotSupported;
 		}
 	TInt ret;
 	HBufC8* buf = NULL;
 		ptr8.Copy(reinterpret_cast<TUint8*>(classUids), (classUids[0] + 1)*sizeof(TInt32));
 		ret = aMessage.Write(1, ptr8);
 		}
 	delete buf;
+	OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDCLASSES_EXIT_DUP3 );
 	return ret;
 	}
 /**
 * Gets all personality ids.
 * @param	aMessage	Message received from the client
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::GetPersonalityIds(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_GETPERSONALITYIDS_ENTRY );
 	if (!iPersonalityCfged)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_GETPERSONALITYIDS_EXIT );
 		return KErrNotSupported;
 		}
 	// +1 for the size of actual personality id count
 	TInt personalityIds[KUsbMaxSupportedPersonalities + 1];
 	const RPointerArray<CPersonality>&  personalities = iUsbServer->Device().Personalities();
 	TInt personalityCount = personalities.Count();
 	for (TInt i = 0; i < personalityCount; ++i)
 		{
-		__ASSERT_ALWAYS(personalities[i] != NULL, _USB_PANIC(KUsbSvrPncCat, ENullPersonalityPointer));
+if(personalities[i] == NULL)
+{
+OstTrace1( TRACE_NORMAL, CUSBSESSION_GETPERSONALITYIDS, "CUsbSession::GetPersonalityIds;Panic reason=%d", ENullPersonalityPointer );
+User::Panic(KUsbSvrPncCat, ENullPersonalityPointer);
+}
 		personalityIds[i + 1] = personalities[i]->PersonalityId();
 		}
 	personalityIds[0] = personalityCount;
 	TInt ret;
 		ptr8.Copy(reinterpret_cast<TUint8*>(personalityIds), (personalityCount + 1)*sizeof(TInt));
 		ret = aMessage.Write(0, ptr8);
 		}
 	delete buf;
+	OstTraceFunctionExit0( CUSBSESSION_GETPERSONALITYIDS_EXIT_DUP1 );
 	return ret;
 	}
 /**
 * Gets personality description
 * @param	aMessage	Message received from the client
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::GetDescription(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_GETDESCRIPTION_ENTRY );
 	if (!iPersonalityCfged)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_GETDESCRIPTION_EXIT );
 		return KErrNotSupported;
 		}
 	TInt personalityId = aMessage.Int0();
 	const CPersonality* personality = iUsbServer->Device().GetPersonality(personalityId);
 		{
 		return aMessage.Write(1, *(personality->Description()));
 		}
 	// We should never reach here
+	OstTraceFunctionExit0( CUSBSESSION_GETDESCRIPTION_EXIT_DUP1 );
 	return KErrNotSupported;
 	}
 /**
 * @param   aMessage    Message received from the client
 * @return  Any error that occurred or KErrNone
 */
 TInt CUsbSession::GetPersonalityProperty(const RMessage2& aMessage)
 	{
-		LOG_FUNC
+		OstTraceFunctionEntry0( CUSBSESSION_GETPERSONALITYPROPERTY_ENTRY );
 		if (!iPersonalityCfged)
 			{
+			OstTraceFunctionExit0( CUSBSESSION_GETPERSONALITYPROPERTY_EXIT );
 			return KErrNotSupported;
 			}
 		TInt personalityId = aMessage.Int0();
 		const CPersonality* personality = iUsbServer->Device().GetPersonality(personalityId);
 			{
 			TPckg<TUint32> pckg(personality->Property());
 			return aMessage.Write(1, pckg);
 			}
+		OstTraceFunctionExit0( CUSBSESSION_GETPERSONALITYPROPERTY_EXIT_DUP2 );
 		return KErrNotSupported;
 	}
 /**
 * Checks if a given class is supported by a personality.
 * @param	aMessage	Message received from the client
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::ClassSupported(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_CLASSSUPPORTED_ENTRY );
 	if (!iPersonalityCfged)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_CLASSSUPPORTED_EXIT );
 		return KErrNotSupported;
 		}
 	TBool isSupported = EFalse;
 	TInt personalityId = aMessage.Int0();
 		TPckg<TBool> pkg2(isSupported);
 		return aMessage.Write(2, pkg2);
 		}
 	// We should never reach here
+	OstTraceFunctionExit0( CUSBSESSION_CLASSSUPPORTED_EXIT_DUP1 );
 	return KErrNotSupported;
 	}
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 /**
 * @param	aMessage	Message received from the client
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::SetCtlSessionMode(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_SETCTLSESSIONMODE_ENTRY );
 	TInt ret = KErrNone;
 	TBool value = (TBool)aMessage.Int0();
-	LOGTEXT2(_L8("\tSetting = %d"), static_cast<TInt>(value));
+	OstTrace1( TRACE_NORMAL, CUSBSESSION_SETCTLSESSIONMODE, "CUsbSession::SetCtlSessionMode;Setting = %d", static_cast<TInt>(value) );
 	// Verify if this is the same session which set the value before
 	if ( iCtlSession && (iCtlSession != this) )
 		{
 		ret = KErrAccessDenied;
 			{
 			iCtlSession = NULL;
 			}
 		}
+	OstTraceFunctionExit0( CUSBSESSION_SETCTLSESSIONMODE_EXIT );
 	return ret;
 	}
 /**
 * Asserts a request to drive VBus.
 * @return	If control mode flag is not set returns KErrAccessDenied
 * 			An error code for all other cases
 */
 TInt CUsbSession::BusRequest()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_BUSREQUEST_ENTRY );
 	TInt ret = KErrNone;
 	if ( iSessionCtlMode )
 		{
 		ret = iUsbServer->Otg().BusRequest();
 	else
 		{
 		ret = KErrAccessDenied;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_BUSREQUEST_EXIT );
 	return ret;
 	}
 /**
 * Asserts a request to raise VBUS but assumes this is after B-Device
 * @return	If control mode flag is not set returns KErrAccessDenied
 * 			Any error that occurred or KErrNone for all other cases
 */
 TInt CUsbSession::BusRespondSrp()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_BUSRESPONDSRP_ENTRY );
 	TInt ret = KErrNone;
 	if ( iSessionCtlMode )
 		{
 		ret = iUsbServer->Otg().BusRespondSrp();
 	else
 		{
 		ret = KErrAccessDenied;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_BUSRESPONDSRP_EXIT );
 	return ret;
 	}
 /**
 * Clears a possible VBUS error condition (VBUS inexplicably low after
 * @return	If control mode flag is not set returns KErrAccessDenied
 * 			Any error that occurred or KErrNone for all other cases
 */
 TInt CUsbSession::BusClearError()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_BUSCLEARERROR_ENTRY );
 	TInt ret = KErrNone;
 	if ( iSessionCtlMode )
 		{
 		ret = iUsbServer->Otg().BusClearError();
 	else
 		{
 		ret = KErrAccessDenied;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_BUSCLEARERROR_EXIT );
 	return ret;
 	}
 /**
 * Drops VBus.
 * @return	If control mode flag is not set returns KErrAccessDenied
 * 			Any error that occurred or KErrNone for all other cases
 */
 TInt CUsbSession::BusDrop()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_BUSDROP_ENTRY );
 	TInt ret = KErrNone;
 	if ( iSessionCtlMode )
 		{
 		ret = iUsbServer->Otg().BusDrop();
 	else
 		{
 		ret = KErrAccessDenied;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_BUSDROP_EXIT );
 	return ret;
 	}
 /**
 * Enables loading of Function Drivers.
 * @return	If control mode flag is not set returns KErrAccessDenied
 * 			Any error that occurred or KErrNone for all other cases
 */
 TInt CUsbSession::EnableFunctionDriverLoading()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_ENABLEFUNCTIONDRIVERLOADING_ENTRY );
 	TInt ret = KErrNone;
 	if ( iSessionCtlMode )
 		{
 		ret = iUsbServer->Host().EnableDriverLoading();
 	else
 		{
 		ret = KErrAccessDenied;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_ENABLEFUNCTIONDRIVERLOADING_EXIT );
 	return ret;
 	}
 /**
 * Disables loading of Function Drivers.
 * @return	If control mode flag is not set returns KErrAccessDenied
 * 			KErrNone for all other cases
 */
 TInt CUsbSession::DisableFunctionDriverLoading()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_DISABLEFUNCTIONDRIVERLOADING_ENTRY );
 	TInt ret = KErrNone;
 	if ( iSessionCtlMode )
 		{
 		iUsbServer->Host().DisableDriverLoading();
 	else
 		{
 		ret = KErrAccessDenied;
 		}
+	OstTraceFunctionExit0( CUSBSESSION_DISABLEFUNCTIONDRIVERLOADING_EXIT );
 	return ret;
 	}
 /**
 * Requests an array of language identifiers supported by connected device.
 * @param	aMessage	Message received from the client
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::GetSupportedLanguages(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_GETSUPPORTEDLANGUAGES_ENTRY );
 	TRAPD(err, GetSupportedLanguagesL(aMessage));
+	OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDLANGUAGES_EXIT );
 	return err;
 	}
 /**
 * Requests an array of language identifiers supported by connected device.
 * @param	aMessage	Message received from the client
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::GetSupportedLanguagesL(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_GETSUPPORTEDLANGUAGESL_ENTRY );
 	const TUint deviceId = aMessage.Int0();
-	LOGTEXT2(_L8("\tdeviceId = %d"), deviceId);
+	OstTrace1( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDLANGUAGESL, "CUsbSession::GetSupportedLanguagesL;deviceId=%d", deviceId );
 	RArray<TUint> langIds;
 	CleanupClosePushL(langIds);
 	TInt ret = iUsbServer->Host().GetSupportedLanguages(deviceId,langIds);
 	if (ret == KErrNone)
 		{
 		const TUint count = langIds.Count();
-		LOGTEXT2(_L8("\tcount = %d"), count);
+		OstTrace1( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDLANGUAGESL_DUP1, "CUsbSession::GetSupportedLanguagesL;count=%d", count );
 		// Set error code if there is no languages or there are too many
 		if ( count == 0 )
 			{
 			ret = KErrNotSupported;
 			// Save all received language Ids
 			for ( TUint ii = 0 ; ii < count; ++ii )
 				{
 				buf.Append((TUint8*)&(langIds[ii]), sizeof(TUint));
-				LOGTEXT3(_L8("Append langID[%d] = %d"),ii,langIds[ii]);
+				OstTraceExt2( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDLANGUAGESL_DUP2, "CUsbSession::GetSupportedLanguagesL;Append langID[%d] = %d", ii, langIds[ii] );
 				}
 			// Write back to the client.
 			ret = aMessage.Write(1, buf);
 			CleanupStack::PopAndDestroy(&buf);
 			}
 		}
 	CleanupStack::PopAndDestroy();
+	OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDLANGUAGESL_EXIT );
 	return ret;
 	}
 /**
 * Requests a manufacturer string descriptor of connected device.
 * @param	aMessage	Message received from the client
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::GetManufacturerStringDescriptor(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_GETMANUFACTURERSTRINGDESCRIPTOR_ENTRY );
 	const TUint deviceId = aMessage.Int0();
 	const TUint langId = aMessage.Int1();
-	LOGTEXT3(_L8("\tdeviceId = %d, langId = %d"), deviceId, langId);
+	OstTraceExt2( TRACE_NORMAL, CUSBSESSION_GETMANUFACTURERSTRINGDESCRIPTOR, "CUsbSession::GetManufacturerStringDescriptor;langId=%d;deviceId=%d", langId, deviceId );
 	TName string;
 	TInt ret = iUsbServer->Host().GetManufacturerStringDescriptor(deviceId,langId,string);
 	if (ret == KErrNone)
 		{
-		LOGTEXT2(_L("\tstring = \"%S\""), &string);
+		OstTraceExt1( TRACE_NORMAL, CUSBSESSION_GETMANUFACTURERSTRINGDESCRIPTOR_DUP1, "CUsbSession::GetManufacturerStringDescriptor;string = \"%S\"", string );
 		ret = aMessage.Write(2, string);
 		}
+	OstTraceFunctionExit0( CUSBSESSION_GETMANUFACTURERSTRINGDESCRIPTOR_EXIT );
 	return ret;
 	}
 /**
 * Requests a product string descriptor of connected device.
 * @param	aMessage	Message received from the client
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::GetProductStringDescriptor(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_GETPRODUCTSTRINGDESCRIPTOR_ENTRY );
 	const TUint deviceId = aMessage.Int0();
 	const TUint langId = aMessage.Int1();
-	LOGTEXT3(_L8("\tdeviceId = %d, langId = %d"), deviceId, langId);
+	OstTraceExt2( TRACE_NORMAL, CUSBSESSION_GETPRODUCTSTRINGDESCRIPTOR, "CUsbSession::GetProductStringDescriptor;deviceId=%d;langId=%d", deviceId, langId );
 	TName string;
 	TInt ret = iUsbServer->Host().GetProductStringDescriptor(deviceId,langId,string);
 	if (ret == KErrNone)
 		{
-		LOGTEXT2(_L("\tstring = \"%S\""), &string);
+		OstTraceExt1( TRACE_NORMAL, CUSBSESSION_GETPRODUCTSTRINGDESCRIPTOR_DUP1, "CUsbSession::GetProductStringDescriptor;string = \"%S\"", string );
 		ret = aMessage.Write(2, string);
 		}
+	OstTraceFunctionExit0( CUSBSESSION_GETPRODUCTSTRINGDESCRIPTOR_EXIT );
 	return ret;
 	}
 /**
 * Requests a OTG descriptor of connected device.
 * @param	aMessage	Message received from the client
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::GetOtgDescriptor(const RMessage2& aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_GETOTGDESCRIPTOR_ENTRY );
 	const TUint deviceId = aMessage.Int0();
-	LOGTEXT2(_L8("\tdeviceId = %d"), deviceId);
+	OstTrace1( TRACE_NORMAL, CUSBSESSION_GETOTGDESCRIPTOR, "CUsbSession::GetOtgDescriptor;deviceId=%d", deviceId );
 TOtgDescriptor otgDescriptor;
 	TInt ret = iUsbServer->Host().GetOtgDescriptor(deviceId, otgDescriptor);
 	if (ret == KErrNone)
 		{
 		TPckg<TOtgDescriptor> buf(otgDescriptor);
 		ret = aMessage.Write(1, buf);
 		}
+	OstTraceFunctionExit0( CUSBSESSION_GETOTGDESCRIPTOR_EXIT );
 	return ret;
 	}
 /**
 * Client request to observe the host (for state changes).
 *
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::RegisterHostObserver(const RMessage2& aMessage, TBool& aComplete)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_REGISTERHOSTOBSERVER_ENTRY );
 	if (iHostEventObserverOutstanding)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_REGISTERHOSTOBSERVER_EXIT );
 		return KErrInUse;
 		}
 	iHostEventObserverMessage = aMessage;
 	iHostEventObserverOutstanding = ETrue;
 	if (iHostEventObserverQueueEvents == EFalse)
 	 	{
 		// This is the first observer after c'tor or DeregisterObserver(),
 		// so zap the device event queue.
-		LOGTEXT(_L8("    Reset OTG Host State Queue"));
+		OstTrace0( TRACE_NORMAL, CUSBSESSION_REGISTERHOSTOBSERVER, "CUsbSession::RegisterHostObserver;    Reset OTG Host State Queue" );
 		iHostEventQueueHead = 0;
 		iHostEventQueueTail = 0;
 		iHostEventObserverQueueEvents = ETrue;
 	 	}
 	else if (iHostEventQueueHead != iHostEventQueueTail)
 	 	{
 		// event(s) queued, we can de-queue one now
 		UsbHostEventDequeue();
 	 	}
+	OstTraceFunctionExit0( CUSBSESSION_REGISTERHOSTOBSERVER_EXIT_DUP1 );
 	return KErrNone;
 	}
 /**
 * Deregister the client as an observer of host state changes.
 * @internalComponent
 * @return Always KErrNone
 */
 TInt CUsbSession::DeRegisterHostObserver()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_DEREGISTERHOSTOBSERVER_ENTRY );
 	if (!iHostEventObserverQueueEvents)
 		{
 		//Never register
-		LOGTEXT(_L8("iHostEventObserverQueueEvents is FALSE!"));
+		OstTrace0( TRACE_NORMAL, CUSBSESSION_DEREGISTERHOSTOBSERVER, "CUsbSession::DeRegisterHostObserver;iHostEventObserverQueueEvents is FALSE!" );
+		OstTraceFunctionExit0( CUSBSESSION_DEREGISTERHOSTOBSERVER_EXIT );
 		return KErrNone;
 		}
 	if (iHostEventObserverOutstanding)
 		{
 		iHostEventObserverOutstanding = EFalse;
 		iHostEventObserverMessage.Complete(KErrCancel);
-		LOGTEXT(_L8("iHostEventObserverMessage.Complete(KErrCancel);"));
+		OstTrace0( TRACE_NORMAL, CUSBSESSION_DEREGISTERHOSTOBSERVER_DUP1, "CUsbSession::DeRegisterHostObserver;iHostEventObserverMessage.Complete(KErrCancel);" );
 		}
 	// client doesn't need events queuing any more
 	iHostEventObserverQueueEvents = EFalse;
 	//Reset OTG Host State Queue
 	iHostEventQueueHead = 0;
 	iHostEventQueueTail = 0;
+	OstTraceFunctionExit0( CUSBSESSION_DEREGISTERHOSTOBSERVER_EXIT_DUP1 );
 	return KErrNone;
 	}
 /**
 * Client request to observe both OTG and HOST (for events and errors).
 *
 * @return	Any error that occurred or KErrNone
 */
 TInt CUsbSession::RegisterMsgObserver(const RMessage2& aMessage, TBool& aComplete)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_REGISTERMSGOBSERVER_ENTRY );
 	if (iMsgObserverOutstanding)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_REGISTERMSGOBSERVER_EXIT );
 		return KErrInUse;
 		}
 	iMsgObserverMessage = aMessage;
 	iMsgObserverOutstanding = ETrue;
 	if (iMsgObserverQueueEvents == EFalse)
 	 	{
 		// This is the first observer after c'tor or DeregisterObserver(),
 		// so zap the device event queue.
-		LOGTEXT(_L8("    Reset OTG Message Queue"));
+		OstTrace0( TRACE_NORMAL, CUSBSESSION_REGISTERMSGOBSERVER, "CUsbSession::RegisterMsgObserver;    Reset OTG Message Queue" );
 		iMsgQueueHead = 0;
 		iMsgQueueTail = 0;
 		iMsgObserverQueueEvents = ETrue;
 	 	}
 	else if (iMsgQueueHead != iMsgQueueTail)
 	 	{
 		// event(s) queued, we can de-queue one now
 		UsbMsgDequeue();
 	 	}
+	OstTraceFunctionExit0( CUSBSESSION_REGISTERMSGOBSERVER_EXIT_DUP1 );
 	return KErrNone;
 	}
 /**
 * Deregister the client as an observer of OTG/HOST events and errors.
 * @internalComponent
 * @return Always KErrNone
 */
 TInt CUsbSession::DeRegisterMsgObserver()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_DEREGISTERMSGOBSERVER_ENTRY );
 	if (!iMsgObserverOutstanding)
 		{
+		OstTraceFunctionExit0( CUSBSESSION_DEREGISTERMSGOBSERVER_EXIT );
 		return KErrNone;
 		}
 	iMsgObserverOutstanding = EFalse;
 	iMsgObserverMessage.Complete(KErrCancel);
 	// client doesn't need events queuing any more
 	iMsgObserverQueueEvents = EFalse;
+	OstTraceFunctionExit0( CUSBSESSION_DEREGISTERMSGOBSERVER_EXIT_DUP1 );
 	return KErrNone;
 	}
 * @internalComponent
 * @param aMessage The new OTG Message
 */
 void CUsbSession::UsbOtgHostMessage(TInt aMessage)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_USBOTGHOSTMESSAGE_ENTRY );
 	// can we bypass the queue?
 	if ((iMsgObserverOutstanding) && (iMsgQueueHead == iMsgQueueTail))
 		{
 		TPckg<TInt> pckg(aMessage);
 	else if (iMsgObserverQueueEvents)
 		{
 		// add event to head of queue
 		iMsgQueue[iMsgQueueHead] = aMessage;
 		iMsgQueueHead = (iMsgQueueHead + 1) % KOtgHostMessageQueueSize;
-		LOGTEXT3(_L8("+++ CUsbSession::UsbOtgMessage() addqueue (%d, %d)"), iMsgQueueHead,
+		OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBOTGHOSTMESSAGE, "CUsbSession::UsbOtgHostMessage; addqueue (%d, %d)", iMsgQueueHead, iMsgQueueTail );
-			iMsgQueueTail);
 		// UsbMsgDequeueEvent() will read from queue when RegisterMsgObserver()
 		// is next called.
 		}
+	OstTraceFunctionExit0( CUSBSESSION_USBOTGHOSTMESSAGE_EXIT );
 	}
 /**
 * Called by CUsbHost when it state change. CUsbSession is an observer of
 * the device. If the client has an Observer outstanding then complete it,
 * @param	aDevInfo	The information about the device being attached or detached
 * 						along with the status of Function Driver loading
 */
 void CUsbSession::UsbHostEvent(TDeviceEventInformation& aDevInfo)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_USBHOSTEVENT_ENTRY );
 	// can we bypass the queue?
 	if ((iHostEventObserverOutstanding) && (iHostEventQueueHead == iHostEventQueueTail))
 		{
 		iNotifiedHostState = aDevInfo;
 		iHostEventObserverOutstanding = EFalse;
-		LOGTEXT(_L8("CUsbSession::UsbHostEvent() detected outstanding request"));
+		OstTrace0( TRACE_NORMAL, CUSBSESSION_USBHOSTEVENT, "CUsbSession::UsbHostEvent detected outstanding request" );
 		TPckg<TDeviceEventInformation> info(aDevInfo);
 		const TInt err = iHostEventObserverMessage.Write(0, info);
 		iHostEventObserverMessage.Complete(err);
-		LOGTEXT2(_L8("CUsbSession::UsbHostEvent() detects outstanding request: request is compeleted with %d"), err);
+		OstTrace1( TRACE_NORMAL, CUSBSESSION_USBHOSTEVENT_DUP1, "CUsbSession::UsbHostEvent; detects outstanding request: request is compeleted with %d", err );
 		}
 	else if (iHostEventObserverQueueEvents)
 		{
 		// add dev info to head of queue
 		iHostStateQueue[iHostEventQueueHead] = aDevInfo;
 		iHostEventQueueHead = (iHostEventQueueHead + 1) % KDeviceStatesQueueSize;
-		LOGTEXT3(_L8("+++ CUsbSession::UsbHostEvent() addqueue (%d, %d)"), iHostEventQueueHead,
+		OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBHOSTEVENT_DUP2, "CUsbSession::UsbHostEvent; addqueue (%d, %d)", iHostEventQueueHead, iHostEventQueueTail );
-			iHostEventQueueTail);
 		// UsbHostStateDequeueEvent() will read from queue when RegisterHostObserver()
 		// is next called.
 		}
+	OstTraceFunctionExit0( CUSBSESSION_USBHOSTEVENT_EXIT );
 	}
 /**
 * Dequeues an event and completes the observer's request with it.
 */
 void CUsbSession::UsbMsgDequeue()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_USBMSGDEQUEUE_ENTRY );
 	// Work our way through the queue, until we reach the end
 	// OR we find an event the current observer wants.
 	if ((iMsgObserverOutstanding) && (iMsgQueueHead != iMsgQueueTail))
 		{
 		iMsgQueueTail = (iMsgQueueTail + 1) % KOtgHostMessageQueueSize;
 		TPckg<TUint32> pckg(newMsg);
 		iNotifiedMsg = newMsg;
-		LOGTEXT3(_L8(">>> dequeued event #%d (0x%x)"), iMsgQueueTail, newMsg);
+		OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBMSGDEQUEUE, "CUsbSession::UsbMsgDequeue;dequeued event #%d (0x%x)", iMsgQueueTail, newMsg );
 		iMsgObserverOutstanding = EFalse;
 		const TInt err = iMsgObserverMessage.Write(0, pckg);
 		iMsgObserverMessage.Complete(err);
 		}
+	OstTraceFunctionExit0( CUSBSESSION_USBMSGDEQUEUE_EXIT );
 	}
 /**
 * Dequeues an event and completes the observer's request with it.
 */
 void CUsbSession::UsbHostEventDequeue()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSESSION_USBHOSTEVENTDEQUEUE_ENTRY );
 	// Work our way through the queue, until we reach the end
 	// OR we find an event the current observer wants.
 	if ((iHostEventObserverOutstanding) && (iHostEventQueueHead != iHostEventQueueTail))
 		{
 		iNotifiedHostState = newDevInfo;
 		// advance tail towards the head
 		iHostEventQueueTail = (iHostEventQueueTail + 1) % KDeviceStatesQueueSize;
-		LOGTEXT3(_L8(">>> CUsbSession::UsbHostStateDequeueEvent() dequeued event #%d (0x%x)"), iHostEventQueueTail, newDevInfo.iEventType);
+		OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBHOSTEVENTDEQUEUE, "CUsbSession::UsbHostEventDequeue; dequeued event #%d (0x%x)", iHostEventQueueTail, newDevInfo.iEventType );
 		TPckg<TDeviceEventInformation> info(newDevInfo);
 		iHostEventObserverOutstanding = EFalse;
 		const TInt err = iHostEventObserverMessage.Write(0, info);
 		iHostEventObserverMessage.Complete(err);
-		LOGTEXT2(_L8("CUsbSession::UsbHostStateDequeueEvent() detects outstanding request: request is compeleted with %d"), err);
+		OstTrace1( TRACE_NORMAL, CUSBSESSION_USBHOSTEVENTDEQUEUE_DUP1, "CUsbSession::UsbHostStateDequeueEvent() detects outstanding request: request is compeleted with %d", err );
 		}
+	OstTraceFunctionExit0( CUSBSESSION_USBHOSTEVENTDEQUEUE_EXIT );
 	}
 TInt CUsbSession::RequestSession()
 	{
 	return DoRequestSession();

changeset 29	59aa7d6e3e0f
parent 26	f3a1ae528dee
child 48	21625e5de155