diff -r 94f2adf59133 -r b2826f67641f userlibandfileserver/fileserver/shostmassstorage/server/transport/cbulkonlytransport.cpp
--- a/userlibandfileserver/fileserver/shostmassstorage/server/transport/cbulkonlytransport.cpp	Tue Oct 26 11:12:58 2010 +0100
+++ b/userlibandfileserver/fileserver/shostmassstorage/server/transport/cbulkonlytransport.cpp	Tue Oct 26 12:49:20 2010 +0100
@@ -34,24 +34,26 @@
 #include "mprotocol.h"
 #include "cusbifacehandler.h"
 #include "cbulkonlytransport.h"
-#include "debug.h"
-#include "msdebug.h"
+
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cbulkonlytransportTraces.h"
+#endif
+
 
 CBulkOnlyTransport::CBulkOnlyTransport()
-:	iBulkOutCbwTd(KCbwPacketSize),
-	iBulkDataTd(KResponsePacketSize),
-	iBulkInCswTd(KCswPacketSize)
-	{
-    __MSFNLOG
-	}
+:   iBulkOutCbwTd(KCbwPacketSize),
+    iBulkDataTd(KResponsePacketSize),
+    iBulkInCswTd(KCswPacketSize)
+    {
+    }
 
 CBulkOnlyTransport::~CBulkOnlyTransport()
-	{
-    __MSFNLOG
-	delete iUsbInterfaceHandler;
-	UnInitialiseTransport();
-	iInterface.Close();
-	}
+    {
+    delete iUsbInterfaceHandler;
+    UnInitialiseTransport();
+    iInterface.Close();
+    }
 
 /**
 Create CBulkOnlyTransport object.
@@ -61,170 +63,164 @@
 @return CBulkOnlyTransport* Pointer to the created object
 */
 CBulkOnlyTransport* CBulkOnlyTransport::NewL(TUint aInterfaceId)
-	{
-    __MSFNSLOG
-	CBulkOnlyTransport* transport = new (ELeave) CBulkOnlyTransport();
-	CleanupStack::PushL(transport);
+    {
+    CBulkOnlyTransport* transport = new (ELeave) CBulkOnlyTransport();
+    CleanupStack::PushL(transport);
     transport->ConstructL(aInterfaceId);
     CleanupStack::Pop(transport);
-	return transport;
-	}
+    return transport;
+    }
 
 
 void CBulkOnlyTransport::ConstructL(TUint aInterfaceId)
     {
-    __MSFNSLOG
-	User::LeaveIfError(iInterface.Open(aInterfaceId));
-	iUsbInterfaceHandler = CUsbInterfaceHandler::NewL(iInterface, iBulkPipeIn);
-	InitialiseTransport();
+    User::LeaveIfError(iInterface.Open(aInterfaceId));
+    iUsbInterfaceHandler = CUsbInterfaceHandler::NewL(iInterface, iBulkPipeIn);
+    InitialiseTransport();
     }
 
 
 void CBulkOnlyTransport::Resume()
-	{
-    __MSFNSLOG
-	__BOTPRINT(_L("BOT RESUME"));
- 
-	iInterface.CancelPermitSuspend();
-	}
+    {
+    OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_10, "BOT RESUME");
+    iInterface.CancelPermitSuspend();
+    }
 
 void CBulkOnlyTransport::Suspend(TRequestStatus& aStatus)
-	{
-    __MSFNSLOG
-	__BOTPRINT(_L("BOT SUSPEND"));
-//	iInterface.PermitRemoteWakeup(ETrue);
-	iInterface.PermitSuspendAndWaitForResume(aStatus);
-	}
+    {
+    OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_11, "BOT SUSPEND");
+//  iInterface.PermitRemoteWakeup(ETrue);
+    iInterface.PermitSuspendAndWaitForResume(aStatus);
+    }
 
 TInt CBulkOnlyTransport::InitialiseTransport()
-	{
-    __MSFNLOG
-	TInt BulkOutEpAddr;
-	TInt BulkInEpAddr;
-	const TUint8 KEpDirectionIn = 0x80;
-	const TUint8 KEpDirectionOut = 0x00;
-	const TUint8 KTransferTypeBulk = 0x02;
+    {
+    TInt BulkOutEpAddr;
+    TInt BulkInEpAddr;
+    const TUint8 KEpDirectionIn = 0x80;
+    const TUint8 KEpDirectionOut = 0x00;
+    const TUint8 KTransferTypeBulk = 0x02;
 
-	GetEndpointAddress(iInterface,0,KTransferTypeBulk,KEpDirectionOut,BulkOutEpAddr);
-	GetEndpointAddress(iInterface,0,KTransferTypeBulk,KEpDirectionIn,BulkInEpAddr);
-	iInterface.OpenPipeForEndpoint(iBulkPipeOut, BulkOutEpAddr, EFalse);
-	iInterface.OpenPipeForEndpoint(iBulkPipeIn, BulkInEpAddr, EFalse);
+    GetEndpointAddress(iInterface,0,KTransferTypeBulk,KEpDirectionOut,BulkOutEpAddr);
+    GetEndpointAddress(iInterface,0,KTransferTypeBulk,KEpDirectionIn,BulkInEpAddr);
+    iInterface.OpenPipeForEndpoint(iBulkPipeOut, BulkOutEpAddr, EFalse);
+    iInterface.OpenPipeForEndpoint(iBulkPipeIn, BulkInEpAddr, EFalse);
 
-	if (iInterface.RegisterTransferDescriptor(iBulkOutCbwTd) != KErrNone ||
-			iInterface.RegisterTransferDescriptor(iBulkDataTd) != KErrNone ||
-					iInterface.RegisterTransferDescriptor(iBulkInCswTd) != KErrNone)
+    if (iInterface.RegisterTransferDescriptor(iBulkOutCbwTd) != KErrNone ||
+            iInterface.RegisterTransferDescriptor(iBulkDataTd) != KErrNone ||
+                    iInterface.RegisterTransferDescriptor(iBulkInCswTd) != KErrNone)
         {
-		return KErrGeneral;
+        return KErrGeneral;
         }
 
-	if (iInterface.InitialiseTransferDescriptors() != KErrNone)
+    if (iInterface.InitialiseTransferDescriptors() != KErrNone)
         {
-		return KErrGeneral;
+        return KErrGeneral;
         }
-	return KErrNone;
-	}
+    return KErrNone;
+    }
 
 
 void CBulkOnlyTransport::UnInitialiseTransport()
-	{
-    __MSFNLOG
-	iBulkPipeOut.Close();
-	iBulkPipeIn.Close();
-	}
+    {
+    iBulkPipeOut.Close();
+    iBulkPipeIn.Close();
+    }
+
 
 TInt CBulkOnlyTransport::GetEndpointAddress(RUsbInterface& aUsbInterface,
                                             TInt aInterfaceSetting,
                                             TUint8 aTransferType,
                                             TUint8 aDirection,
                                             TInt& aEndpointAddress)
-	{
-    __MSFNLOG
-	TUsbInterfaceDescriptor alternateInterfaceDescriptor;
+    {
+    TUsbInterfaceDescriptor alternateInterfaceDescriptor;
 
-	if (aUsbInterface.GetAlternateInterfaceDescriptor(aInterfaceSetting, alternateInterfaceDescriptor))
-		{
-		__BOTPRINT1(_L("GetEndpointAddress : <Error> Unable to get alternate interface (%x) descriptor"),aInterfaceSetting);
-		return KErrGeneral;
-		}
+    if (aUsbInterface.GetAlternateInterfaceDescriptor(aInterfaceSetting, alternateInterfaceDescriptor))
+        {
+        OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_20,
+                  "GetEndpointAddress : <Error> Unable to get alternate interface (%x) descriptor", aInterfaceSetting);
+        return KErrGeneral;
+        }
 
-	TUsbGenericDescriptor* descriptor = alternateInterfaceDescriptor.iFirstChild;
+    TUsbGenericDescriptor* descriptor = alternateInterfaceDescriptor.iFirstChild;
 
-	while (descriptor)
-		{
-		TUsbEndpointDescriptor* endpoint = TUsbEndpointDescriptor::Cast(descriptor);
-		if (endpoint)
-			{
-			if ((endpoint->Attributes() & aTransferType) == aTransferType)
-				{
-				// Found the endpoint address
-				if ( (endpoint->EndpointAddress() & 0x80) == aDirection)
-					{
-					aEndpointAddress = endpoint->EndpointAddress();
-					__BOTPRINT(_L("GetEndpointAddress : Endpoint address found"));
-					return KErrNone;
-					}
-				}
-			}
-		descriptor = descriptor->iNextPeer;
-		}
+    while (descriptor)
+        {
+        TUsbEndpointDescriptor* endpoint = TUsbEndpointDescriptor::Cast(descriptor);
+        if (endpoint)
+            {
+            if ((endpoint->Attributes() & aTransferType) == aTransferType)
+                {
+                // Found the endpoint address
+                if ( (endpoint->EndpointAddress() & 0x80) == aDirection)
+                    {
+                    aEndpointAddress = endpoint->EndpointAddress();
+                    OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_21,
+                              "GetEndpointAddress : Endpoint address found");
+                    return KErrNone;
+                    }
+                }
+            }
+        descriptor = descriptor->iNextPeer;
+        }
 
-	// Unable to find the endpoint address
-	__BOTPRINT(_L("GetEndpointAddress : Unable to find endpoint address matching the specified attributes"));
-	return KErrNotFound;
-	}
+    // Unable to find the endpoint address
+    OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_22,
+              "GetEndpointAddress : Unable to find endpoint address matching the specified attributes");
+    return KErrNotFound;
+    }
 
 void CBulkOnlyTransport::GetMaxLun(TLun* aMaxLun, const RMessage2& aMessage)
-	{
-    __MSFNLOG
-	iUsbInterfaceHandler->GetMaxLun(aMaxLun, aMessage);
-	}
+    {
+    iUsbInterfaceHandler->GetMaxLun(aMaxLun, aMessage);
+    }
 
 TInt CBulkOnlyTransport::Reset()
-	{
-    __MSFNLOG
-	RUsbInterface::TUsbTransferRequestDetails reqDetails;
-	_LIT8(KNullDesC8,"");
+    {
+    RUsbInterface::TUsbTransferRequestDetails reqDetails;
+    _LIT8(KNullDesC8,"");
 
-	reqDetails.iRequestType = 0x21;
-	reqDetails.iRequest = 0xFF;
-	reqDetails.iValue = 0x0000;
-	reqDetails.iIndex = 0x0000;
-	reqDetails.iFlags = 0x04;		// Short transfer OK
+    reqDetails.iRequestType = 0x21;
+    reqDetails.iRequest = 0xFF;
+    reqDetails.iValue = 0x0000;
+    reqDetails.iIndex = 0x0000;
+    reqDetails.iFlags = 0x04;       // Short transfer OK
 
-	iInterface.Ep0Transfer(reqDetails, KNullDesC8, (TDes8 &) KNullDesC8, iStatus);
-	User::WaitForRequest(iStatus);
-    __BOTPRINT1(_L("BOT RESET[%d]"), iStatus.Int());
+    iInterface.Ep0Transfer(reqDetails, KNullDesC8, (TDes8 &) KNullDesC8, iStatus);
+    User::WaitForRequest(iStatus);
+    OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_30,
+              "BOT RESET[%d]", iStatus.Int());
 
-	if (iStatus.Int() != KErrNone)
+    if (iStatus.Int() != KErrNone)
         {
-		return KErrGeneral;
+        return KErrGeneral;
         }
 
-	return KErrNone;
-	}
+    return KErrNone;
+    }
 
 void CBulkOnlyTransport::DoResetRecovery()
-	{
-    __MSFNLOG
-
-    __BOTPRINT(_L("BOT RESET RECOVERY"));
+    {
+    OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_31,
+              "BOT RESET RECOVERY");
 #ifdef MASSSTORAGE_PUBLISHER
     TMsPublisher publisher(TMsPublisher::KBotResetProperty);
 #endif
-	Reset();
-	iBulkPipeIn.ClearRemoteStall();
-	iBulkPipeOut.ClearRemoteStall();
-	}
+    Reset();
+    iBulkPipeIn.ClearRemoteStall();
+    iBulkPipeOut.ClearRemoteStall();
+    }
 
 
 void CBulkOnlyTransport::SendCbwL(const MClientCommandServiceReq* aReq,
                                   TBotCbw::TCbwDirection aDirection,
                                   TUint32 aTransferLength)
-	{
-    __MSFNLOG
-    __BOTPRINT1(_L("Cbw Tag=0x%x"), iCbwTag);
+    {
+    OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_40,
+              "Cbw Tag=0x%x", iCbwTag);
 
-	iCbw.SetTag(iCbwTag++);
+    iCbw.SetTag(iCbwTag++);
     iCbw.SetDataTransferLength(aTransferLength);
     iCbw.SetDataTransferDirection(aDirection);
     iCbw.SetLun(iLun);
@@ -236,110 +232,115 @@
     iBulkPipeOut.Transfer(iBulkOutCbwTd, iStatus);
     User::WaitForRequest(iStatus);
 
-	TInt r = iStatus.Int();
+    TInt r = iStatus.Int();
     if (r != KErrNone)
         {
-		if (r == KErrUsbStalled)
+        if (r == KErrUsbStalled)
             {
-            __BOTPRINT(_L("Cbw: BulkOut stalled"));
+            OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_41,
+                      "Cbw: BulkOut stalled");
             DoResetRecovery();
             }
-		__BOTPRINT1(_L("Usb transfer error %d"),r);
-		User::Leave(KErrGeneral);
+        OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_42,
+                  "Usb transfer error %d", r);
+        User::Leave(KErrGeneral);
         }
-	}
+    }
 
 
 void CBulkOnlyTransport::ReceiveCswL()
-	{
-    __MSFNLOG
-	iBulkInCswTd.SaveData(KCswPacketSize);
-	iBulkPipeIn.Transfer(iBulkInCswTd, iStatus);
-	User::WaitForRequest(iStatus);
+    {
+    iBulkInCswTd.SaveData(KCswPacketSize);
+    iBulkPipeIn.Transfer(iBulkInCswTd, iStatus);
+    User::WaitForRequest(iStatus);
 
-	TInt r = iStatus.Int();
-	if (r != KErrNone)
+    TInt r = iStatus.Int();
+    if (r != KErrNone)
         {
-		if (r == KErrUsbStalled)
-			{
-            __BOTPRINT(_L("Csw: Clearing BulkIn stall"));
-			iBulkPipeIn.ClearRemoteStall();
-			iBulkInCswTd.SaveData(KCswPacketSize);
-			iBulkPipeIn.Transfer(iBulkInCswTd, iStatus);
-			User::WaitForRequest(iStatus);
+        if (r == KErrUsbStalled)
+            {
+            OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_50,
+                      "Csw: Clearing BulkIn stall");
+            iBulkPipeIn.ClearRemoteStall();
+            iBulkInCswTd.SaveData(KCswPacketSize);
+            iBulkPipeIn.Transfer(iBulkInCswTd, iStatus);
+            User::WaitForRequest(iStatus);
 #ifdef MASSSTORAGE_PUBLISHER
             TMsPublisher publisher(TMsPublisher::KStallProperty);
 #endif
-			r = iStatus.Int();
-			if (r == KErrUsbStalled)
+            r = iStatus.Int();
+            if (r == KErrUsbStalled)
                 {
-				__BOTPRINT(_L("Csw: BulkIn stalled"));
-				DoResetRecovery();
+                OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_51,
+                          "Csw: BulkIn stalled");
+                DoResetRecovery();
                 }
-			}
-		// Handle other usb error and retry failures
-		if (r != KErrNone)
-			{
-			__BOTPRINT1(_L("Usb transfer error %d"), r);
-			User::Leave(KErrGeneral);
-			}
+            }
+        // Handle other usb error and retry failures
+        if (r != KErrNone)
+            {
+            OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_52,
+                      "Usb transfer error %d", r);
+            User::Leave(KErrGeneral);
+            }
         }
 
-	TPtrC8 data = iBulkInCswTd.Buffer();
-	r = iCsw.Decode(data);
+    TPtrC8 data = iBulkInCswTd.Buffer();
+    r = iCsw.Decode(data);
     if (r != KErrNone)
         {
-        __BOTPRINT(_L("Csw: Invalid"));
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_53,
+                  "Csw: Invalid");
         DoResetRecovery();
         User::Leave(KErrGeneral);
         }
-	}
+    }
 
 
 TInt CBulkOnlyTransport::SendControlCmdL(const MClientCommandServiceReq* aCommand)
-	{
-    __MSFNLOG
+    {
     SendCbwL(aCommand, TBotCbw::EDataOut, 0);
     ReceiveCswL();
     return ProcessZeroTransferL();
-	}
+    }
 
 
 TInt CBulkOnlyTransport::SendControlCmdL(const MClientCommandServiceReq* aCommand,
                                          MClientCommandServiceResp* aResp)
-	{
-    __MSFNLOG
-
-	SendCbwL(aCommand, TBotCbw::EDataIn, aResp->DataLength());
+    {
+    SendCbwL(aCommand, TBotCbw::EDataIn, aResp->DataLength());
 
-	if (aResp->DataLength() > KResponsePacketSize)
+    if (aResp->DataLength() > KResponsePacketSize)
         {
-		__BOTPRINT(_L("Control command response length not supported"));
-		User::Leave(KErrGeneral);
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_60,
+                  "Control command response length not supported");
+        User::Leave(KErrGeneral);
         }
 
-	iBulkDataTd.SaveData(KResponsePacketSize);
-	iBulkPipeIn.Transfer(iBulkDataTd, iStatus);
-	User::WaitForRequest(iStatus);
-	TInt r = iStatus.Int();
-	if (r != KErrNone)
+    iBulkDataTd.SaveData(KResponsePacketSize);
+    iBulkPipeIn.Transfer(iBulkDataTd, iStatus);
+    User::WaitForRequest(iStatus);
+    TInt r = iStatus.Int();
+    if (r != KErrNone)
         {
-		if (r != KErrUsbStalled)
-			{
-			__BOTPRINT1(_L("Usb transfer error %d"),r);
-			User::Leave(KErrGeneral);
-			}
-		__BOTPRINT(_L("SendControlCmdL ClearRemoteStall"));
-		iBulkPipeIn.ClearRemoteStall();
+        if (r != KErrUsbStalled)
+            {
+            OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_61,
+                      "Usb transfer error %d",r);
+            User::Leave(KErrGeneral);
+            }
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_62,
+                  "SendControlCmdL ClearRemoteStall");
+        iBulkPipeIn.ClearRemoteStall();
         ReceiveCswL();
-        return KErrCommandStalled;        
+        return KErrCommandStalled;
         }
-	TPtrC8 data = iBulkDataTd.Buffer();
+    TPtrC8 data = iBulkDataTd.Buffer();
 
-	ReceiveCswL();
+    ReceiveCswL();
 
     TUint32 dataReceived = 0;
-	r = ProcessInTransferL(dataReceived);
+    r = ProcessInTransferL(dataReceived);
     if (!r)
         {
         TRAP(r, aResp->DecodeL(data));
@@ -356,169 +357,174 @@
             // 1 Transcend JetFlashV30 VendorID=JetFlash ProductID=TS#GJFV30
             // (# is device size in G)
 
-            __BOTPRINT1(_L("Warning: No data received"), dataReceived);
+            OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_63,
+                      "Warning: No data received");
             }
         }
-	return r;
-	}
+    return r;
+    }
 
 
 TInt CBulkOnlyTransport::SendDataRxCmdL(const MClientCommandServiceReq* aCommand,
                                         TDes8& aCopyBuf,
                                         TInt& aLen)
-	{
-    __MSFNLOG
-
-	TInt r = KErrNone;
-	SendCbwL(aCommand, TBotCbw::EDataIn, aLen);
+    {
+    TInt r = KErrNone;
+    SendCbwL(aCommand, TBotCbw::EDataIn, aLen);
 
     // store initial length as data is appended to the buffer
     TInt startPos = aCopyBuf.Length();
 
-	TInt len = aLen;
+    TInt len = aLen;
 
-	while (len)
+    while (len)
         {
-		if(len > KResponsePacketSize)
-			iBulkDataTd.SaveData(KResponsePacketSize);
-		else
-			iBulkDataTd.SaveData(len);
-		iBulkPipeIn.Transfer(iBulkDataTd, iStatus);
-		User::WaitForRequest(iStatus);
+        if(len > KResponsePacketSize)
+            iBulkDataTd.SaveData(KResponsePacketSize);
+        else
+            iBulkDataTd.SaveData(len);
+        iBulkPipeIn.Transfer(iBulkDataTd, iStatus);
+        User::WaitForRequest(iStatus);
 
-		r = iStatus.Int();
-		if (r != KErrNone)
-			{
-			if (r == KErrUsbStalled)
-				{
-				__BOTPRINT(_L("SendDataRxCmdL ClearRemoteStall"));
-				iBulkPipeIn.ClearRemoteStall();
+        r = iStatus.Int();
+        if (r != KErrNone)
+            {
+            if (r == KErrUsbStalled)
+                {
+                OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_70,
+                          "SendDataRxCmdL ClearRemoteStall");
+                iBulkPipeIn.ClearRemoteStall();
 #ifdef MASSSTORAGE_PUBLISHER
                 TMsPublisher publisher(TMsPublisher::KStallProperty);
 #endif
-				break;
-				}
-			DoResetRecovery();
-			__BOTPRINT1(_L("Usb transfer error %d"),r);
-			User::Leave(KErrGeneral);
-			}
+                break;
+                }
+            DoResetRecovery();
+            OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_71,
+                      "Usb transfer error %d", r);
+            User::Leave(KErrGeneral);
+            }
 
-		TPtrC8 data = iBulkDataTd.Buffer();
-		aCopyBuf.Append(data.Ptr(), data.Length());
-		if(len > KResponsePacketSize)
-			len -= KResponsePacketSize;
-		else
-			len = 0;
+        TPtrC8 data = iBulkDataTd.Buffer();
+        aCopyBuf.Append(data.Ptr(), data.Length());
+        if(len > KResponsePacketSize)
+            len -= KResponsePacketSize;
+        else
+            len = 0;
         }
 
-	ReceiveCswL();
-	TUint32 lenReceived = 0;
+    ReceiveCswL();
+    TUint32 lenReceived = 0;
 
-	r = ProcessInTransferL(lenReceived);
+    r = ProcessInTransferL(lenReceived);
     aLen = lenReceived;
     aCopyBuf.SetLength(startPos + lenReceived);
 
-	return r;
-	}
+    return r;
+    }
 
 TInt CBulkOnlyTransport::SendDataTxCmdL(const MClientCommandServiceReq* aCommand,
                                         TDesC8& aData,
                                         TUint aPos,
                                         TInt& aLen)
-	{
-    __MSFNLOG
-   	TInt r = KErrNone;
+    {
+    TInt r = KErrNone;
+
+    SendCbwL(aCommand, TBotCbw::EDataOut, aLen);
 
-   	SendCbwL(aCommand, TBotCbw::EDataOut, aLen);
-
-   	TInt len = aLen;
-   	TInt length = 0;
-   	iBulkDataTd.SetZlpStatus(RUsbTransferDescriptor::ESuppressZlp);
-   	while (len)
+    TInt len = aLen;
+    TInt length = 0;
+    iBulkDataTd.SetZlpStatus(RUsbTransferDescriptor::ESuppressZlp);
+    while (len)
         {
-   		TPtr8 senddata = iBulkDataTd.WritableBuffer();
-		senddata.Append(aData.Ptr() + length + aPos, len > KResponsePacketSize? KResponsePacketSize : len);
+        TPtr8 senddata = iBulkDataTd.WritableBuffer();
+        senddata.Append(aData.Ptr() + length + aPos, len > KResponsePacketSize? KResponsePacketSize : len);
 
-   		iBulkDataTd.SaveData(senddata.Length());
-   		iBulkPipeOut.Transfer(iBulkDataTd, iStatus);
-   		User::WaitForRequest(iStatus);
+        iBulkDataTd.SaveData(senddata.Length());
+        iBulkPipeOut.Transfer(iBulkDataTd, iStatus);
+        User::WaitForRequest(iStatus);
 
-		if (iStatus.Int() != KErrNone)
-   			{
-   			if (iStatus.Int() == KErrUsbStalled)
-   				{
-				__BOTPRINT(_L("SendDataTxCmdL ClearRemoteStall"));
-   				iBulkPipeOut.ClearRemoteStall();
+        if (iStatus.Int() != KErrNone)
+            {
+            if (iStatus.Int() == KErrUsbStalled)
+                {
+                OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_80,
+                          "SendDataTxCmdL ClearRemoteStall");
+                iBulkPipeOut.ClearRemoteStall();
 #ifdef MASSSTORAGE_PUBLISHER
                 TMsPublisher publisher(TMsPublisher::KStallProperty);
 #endif
-   				break;
-   				}
-   			DoResetRecovery();
-			__BOTPRINT1(_L("Usb transfer error %d"), r);
-   			User::Leave(KErrGeneral);
-   			}
+                break;
+                }
+            DoResetRecovery();
+            OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_81,
+                      "Usb transfer error %d", r);
+            User::Leave(KErrGeneral);
+            }
 
-		if(len > KResponsePacketSize)
-			{
-   			len -= KResponsePacketSize;
-   			length += KResponsePacketSize;
-			}
-		else
-			{
-   			length += len;
-   			len = 0;
-			}
+        if(len > KResponsePacketSize)
+            {
+            len -= KResponsePacketSize;
+            length += KResponsePacketSize;
+            }
+        else
+            {
+            length += len;
+            len = 0;
+            }
         }
 
-   	ReceiveCswL();
+    ReceiveCswL();
 
-   	TUint32 lenSent = 0;
-   	r = ProcessOutTransferL(lenSent);
-   	aLen = lenSent;
+    TUint32 lenSent = 0;
+    r = ProcessOutTransferL(lenSent);
+    aLen = lenSent;
 
-   	return r;
-	}
+    return r;
+    }
 
 
 TInt CBulkOnlyTransport::ProcessZeroTransferL()
     {
-    __MSFNLOG
     // process 13 cases
 
-	__ASSERT_DEBUG(iCbw.iDirection == TBotCbw::EDataOut, User::Invariant());
-	__ASSERT_DEBUG(iCbw.iDataTransferLength == 0, User::Invariant());
+    __ASSERT_DEBUG(iCbw.iDirection == TBotCbw::EDataOut, User::Invariant());
+    __ASSERT_DEBUG(iCbw.iDataTransferLength == 0, User::Invariant());
 
     // Hn - Host expects no data transfers
     if (!iCsw.IsValidCsw(iCbw.iTag))
         {
-        __BOTPRINT(_L("BOT CSW Invalid"));
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_90,
+                  "BOT CSW Invalid");
         DoResetRecovery();
-		User::Leave(KErrGeneral);
+        User::Leave(KErrGeneral);
         }
     if (!iCsw.IsMeaningfulCsw(iCbw.iDataTransferLength))
         {
-        __BOTPRINT(_L("BOT CSW not meaningful"));
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_91,
+                  "BOT CSW not meaningful");
         DoResetRecovery();
-		User::Leave(KErrGeneral);
+        User::Leave(KErrGeneral);
         }
 
     if (iCsw.iStatus == TBotCsw::EPhaseError)
         {
         // Case (2) or (3)
-        __BOTPRINT(_L("BOT Phase Error"));
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_92,
+                  "BOT Phase Error");
         // Reset Recovery
         DoResetRecovery();
-		User::Leave(KErrGeneral);
+        User::Leave(KErrGeneral);
         }
 
     if (iCsw.iDataResidue != 0)
         {
         // should not happen
-        __BOTPRINT(_L("BOT Residue is invalid!"));
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_93,
+                  "BOT Residue is invalid!");
         // Reset Recovery
         DoResetRecovery();
-		User::Leave(KErrGeneral);
+        User::Leave(KErrGeneral);
         }
 
     // all ok if here
@@ -528,22 +534,23 @@
 
 TInt CBulkOnlyTransport::ProcessInTransferL(TUint32& aDataReceived)
     {
-    __MSFNLOG
     aDataReceived = 0;
     // process 13 cases
 
-	__ASSERT_DEBUG(iCbw.iDirection == TBotCbw::EDataIn, User::Invariant());
+    __ASSERT_DEBUG(iCbw.iDirection == TBotCbw::EDataIn, User::Invariant());
 
     // Hi - Host expects to receive data from the device
     if (!iCsw.IsValidCsw(iCbw.iTag))
         {
-        __BOTPRINT(_L("BOT CSW Invalid"));
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_100,
+                  "BOT CSW Invalid");
         DoResetRecovery();
         User::Leave(KErrGeneral);
         }
     if (!iCsw.IsMeaningfulCsw(iCbw.iDataTransferLength))
         {
-        __BOTPRINT(_L("BOT CSW not meaningful"));
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_101,
+                  "BOT CSW not meaningful");
         DoResetRecovery();
         User::Leave(KErrGeneral);
         }
@@ -551,11 +558,12 @@
 
     if (iCsw.iStatus == TBotCsw::EPhaseError)
         {
-        __BOTPRINT(_L("BOT Phase Error"));
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_102,
+                  "BOT Phase Error");
         // Case (7) or (8)
         // Reset Recovery
         DoResetRecovery();
-		User::Leave(KErrGeneral);
+        User::Leave(KErrGeneral);
         }
 
     // all ok if here
@@ -567,33 +575,35 @@
 
 TInt CBulkOnlyTransport::ProcessOutTransferL(TUint32& aDataReceived)
     {
-    __MSFNLOG
     aDataReceived = 0;
     // process 13 cases
 
-	__ASSERT_DEBUG(iCbw.iDirection == TBotCbw::EDataOut, User::Invariant());
+    __ASSERT_DEBUG(iCbw.iDirection == TBotCbw::EDataOut, User::Invariant());
 
     // Ho - Host expects to send data to the device
     if (!iCsw.IsValidCsw(iCbw.iTag))
         {
-        __BOTPRINT(_L("BOT CSW Invalid"));
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_110,
+                  "BOT CSW Invalid");
         DoResetRecovery();
         User::Leave(KErrGeneral);
         }
     if (!iCsw.IsMeaningfulCsw(iCbw.iDataTransferLength))
         {
-        __BOTPRINT(_L("BOT CSW not meaningful"));
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_111,
+                  "BOT CSW not meaningful");
         DoResetRecovery();
         User::Leave(KErrGeneral);
         }
 
     if (iCsw.iStatus == TBotCsw::EPhaseError)
         {
-        __BOTPRINT(_L("BOT Phase Error"));
+        OstTrace0(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_112,
+                  "BOT Phase Error");
         // Case (10) or (13)
         // Reset Recovery
         DoResetRecovery();
-		User::Leave(KErrGeneral);
+        User::Leave(KErrGeneral);
         }
 
     // all ok if here
@@ -605,9 +615,9 @@
 
 void CBulkOnlyTransport::SetLun(TLun aLun)
     {
-    __MSFNLOG
     iLun = aLun;
-    __BOTPRINT1(_L("CBulkOnlyTransport::SetLun(%d)"), aLun)
+    OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_120,
+              "CBulkOnlyTransport::SetLun(%d)", aLun);
     }
 
 
@@ -620,23 +630,23 @@
 */
 void TBotCbw::EncodeL(TPtr8 &aBuffer, const MClientCommandServiceReq* aCommand) const
     {
-    __MSFNSLOG
-	aBuffer.SetLength(KCbwLength);
+    aBuffer.SetLength(KCbwLength);
 
-	TPtr8 commandBlock = aBuffer.MidTPtr(TBotCbw::KCbwCbOffset);
+    TPtr8 commandBlock = aBuffer.MidTPtr(TBotCbw::KCbwCbOffset);
 
-	aBuffer.FillZ();
+    aBuffer.FillZ();
 
     TInt cbLength = aCommand->EncodeRequestL(commandBlock);
 
-	TUint8* ptr = (TUint8 *) aBuffer.Ptr();
+    TUint8* ptr = (TUint8 *) aBuffer.Ptr();
     LittleEndian::Put32(&ptr[KCbwSignatureOffset], 0x43425355);
     LittleEndian::Put32(&ptr[KCbwTagOffset], iTag);
     LittleEndian::Put32(&ptr[KCbwDataTransferLengthOffset], iDataTransferLength);
     aBuffer[KCbwFlagOffset] = (iDirection == EDataOut) ? 0x00 : 0x80;
     aBuffer[KCbwLunOffset] = iLun;
     aBuffer[KCbwCbLengthOffset] = cbLength;
-	__BOTPRINT1(_L("BOT TBotCbw::Encode Lun=%d"), iLun);
+    OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_121,
+              "BOT TBotCbw::Encode Lun=%d", iLun);
     }
 
 
@@ -647,10 +657,10 @@
 */
 TInt TBotCsw::Decode(const TDesC8& aPtr)
     {
-    __MSFNLOG
     if (aPtr.Length() != KCswLength)
         {
-		__BOTPRINT1(_L("Invalid CSW length %d"), aPtr.Length());
+        OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_130,
+                  "Invalid CSW length %d", aPtr.Length());
         return KErrGeneral;
         }
 
@@ -660,7 +670,8 @@
 
     TInt status = aPtr[KCswStatusOffset];
     iStatus = static_cast<TCswStatus>(status);
-    __BOTPRINT1(_L("BOT CSW Status = %d"), iStatus);
+    OstTrace1(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_131,
+              "BOT CSW Status = %d", iStatus);
     return KErrNone;
     }
 
@@ -675,7 +686,6 @@
 */
 TBool TBotCsw::IsValidCsw(TUint32 aTag) const
     {
-    __MSFNSLOG
     if (iSignature != 0x53425355)
         {
         return EFalse;
@@ -698,7 +708,6 @@
 */
 TBool TBotCsw::IsMeaningfulCsw(TUint32 aTransferLength) const
     {
-    __MSFNSLOG
     if (iStatus != EPhaseError)
         {
         if (iDataResidue > aTransferLength)
@@ -712,13 +721,14 @@
 #ifdef MASSSTORAGE_PUBLISHER
 TMsPublisher::TMsPublisher(TPropertyKeys aKey)
     {
-	RProperty prop;
+    RProperty prop;
 
     const TUid KUidHostMassStorageCategory = {KMyUid};
 
-	TInt ret = prop.Attach(KUidHostMassStorageCategory, aKey);
-    __BOTPRINT2(_L("Property Key[%d] attach ret=%d"), aKey, ret);
-	if (ret == KErrNone)
+    TInt ret = prop.Attach(KUidHostMassStorageCategory, aKey);
+    OstTraceExt2(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_140,
+                 "Property Key[%d] attach ret=%d", aKey, ret);
+    if (ret == KErrNone)
         {
         TInt flag;
         ret = prop.Get(KUidHostMassStorageCategory, aKey, flag);
@@ -727,8 +737,10 @@
             flag++;
             ret = prop.Set(KUidHostMassStorageCategory, aKey, flag);
             }
-	    __BOTPRINT3(_L("Property Set[%d] ret=%d Counter=%d"), aKey, ret, flag);
-		prop.Close();
+        OstTraceExt3(TRACE_SHOSTMASSSTORAGE_BOT, CBULKONLYTRANSPORT_141,
+                     "Property Set[%d] ret=%d Counter=%d",
+                     aKey, ret, flag);
+        prop.Close();
         }
     }