FCL/sf/os/kernelhwsrv: comparison kernel/eka/drivers/locmedia/locmedia.cpp

equal deleted inserted replaced

-:0bf4040442f9
+:46fffbe7b5a7
 #include "locmedia.h"
 #include <d32locd.h>
 #include "dmasupport.h"
 #include <kernel/cache.h>
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "locmedia_ost.h"
+#ifdef __VC32__
+#pragma warning(disable: 4127) // disabling warning "conditional expression is constant"
+#endif
+#include "locmediaTraces.h"
+#endif
 #if defined(_DEBUG) && defined(__DEMAND_PAGING__)
 //#define __DEBUG_DEMAND_PAGING__
 #endif
 	};
 DPinObjectAllocator::~DPinObjectAllocator()
 	{
+	OstTraceFunctionEntry1( DPINOBJECTALLOCATOR_DPINOBJECTALLOCATOR_ENTRY, this );
 	if (iPreAllocatedDataLock)
 		{
 		iPreAllocatedDataLock->Cleanup();
 		delete iPreAllocatedDataLock;
 		}
 		if (virtualPinContainer.iObject)
 			Kern::DestroyVirtualPinObject(virtualPinContainer.iObject);
 		}
 	delete [] iVirtualPinContainers;
+	OstTraceFunctionExit1( DPINOBJECTALLOCATOR_DPINOBJECTALLOCATOR_EXIT, this );
 	}
 TInt DPinObjectAllocator::Construct(TInt aObjectCount, TUint aNumPages)
 	{
+	OstTraceFunctionEntryExt( DPINOBJECTALLOCATOR_CONSTRUCT_ENTRY, this );
 	TInt pageSize = Kern::RoundToPageSize(1);
 	iFragmentGranularity = pageSize * aNumPages;
 	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Fragmentation granularity set to 0x%x", iFragmentGranularity));
+	OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPINOBJECTALLOCATOR_CONSTRUCT, "Fragmentation granularity=0x%x", iFragmentGranularity);
 	// construct the paging lock containing pre-allocated buffers
 	iPreAllocatedDataLock = new DFragmentationPagingLock();
 	if(!iPreAllocatedDataLock)
+	    {
+		OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT1, this, KErrNoMemory );
 		return KErrNoMemory;
+	    }
 	TInt r = iPreAllocatedDataLock->Construct(aNumPages);
 	if (r != KErrNone)
+	    {
+		OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT2, this, r );
 		return r;
+	    }
 	SVirtualPinContainer* iVirtualPinContainers = new SVirtualPinContainer[aObjectCount];
 	if (iVirtualPinContainers == NULL)
+	    {
+		OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT3, this, KErrNoMemory );
 		return KErrNoMemory;
+	    }
 	memclr(iVirtualPinContainers, sizeof(SVirtualPinContainer) * aObjectCount);
 	iObjectCount = aObjectCount;
 	// construct the queue of dynamic paging locks
 	for (TInt n=0; n<aObjectCount; n++)
 		{
 		SVirtualPinContainer& pinContainer = iVirtualPinContainers[n];
 		TInt r = Kern::CreateVirtualPinObject(pinContainer.iObject);
 		if (r != KErrNone)
+		    {
+			OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT4, this, KErrNoMemory );
 			return KErrNoMemory;
+		    }
 		iFreeQ.Add(&pinContainer.iLink);
 		}
+	OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT5, this, KErrNone );
 	return KErrNone;
 	}
 /**
 returns a SVirtualPinContainer object or NULL if NULL available
 */
 DPinObjectAllocator::SVirtualPinContainer* DPinObjectAllocator::AcquirePinObject()
 	{
+	OstTraceFunctionEntry1( DPINOBJECTALLOCATOR_ACQUIREPINOBJECT_ENTRY, this );
 	SVirtualPinContainer* pinContainer = NULL;
 	NKern::FMWait(&iLock);
 	if (!iFreeQ.IsEmpty())
 		link->Deque();
 		}
 	NKern::FMSignal(&iLock);
+	OstTraceFunctionExit1( DPINOBJECTALLOCATOR_ACQUIREPINOBJECT_EXIT, this );
 	return pinContainer;
 	}
 /**
 returns a SVirtualPinContainer object to the pool
 */
 void DPinObjectAllocator::ReleasePinObject(SVirtualPinContainer* aPinContainer)
 	{
+	OstTraceFunctionEntry1( DPINOBJECTALLOCATOR_RELEASEPINOBJECT_ENTRY, this );
 	NKern::FMWait(&iLock);
 	iFreeQ.Add(&aPinContainer->iLink);
 	NKern::FMSignal(&iLock);
+	OstTraceFunctionExit1( DPINOBJECTALLOCATOR_RELEASEPINOBJECT_EXIT, this );
 	}
 #endif	// __DEMAND_PAGING__
 DLocalDriveFactory::DLocalDriveFactory()
 //
 // Constructor
 //
 	{
+	OstTraceFunctionEntry1( DLOCALDRIVEFACTORY_DLOCALDRIVEFACTORY_ENTRY, this );
 	iParseMask=KDeviceAllowUnit|KDeviceAllowInfo;
 	iUnitsMask=~(0xffffffff<<KMaxLocalDrives);
 	iVersion=TVersion(KLocalDriveMajorVersion,KLocalDriveMinorVersion,KLocalDriveBuildVersion);
+	OstTraceFunctionExit1( DLOCALDRIVEFACTORY_DLOCALDRIVEFACTORY_EXIT, this );
 	}
 TInt DLocalDriveFactory::Install()
 //
 // Install the device driver.
 TInt DLocalDriveFactory::Create(DLogicalChannelBase*& aChannel)
 //
 // Create a channel on the device.
 //
 	{
+	OstTraceFunctionEntry1( DLOCALDRIVEFACTORY_CREATE_ENTRY, this );
 	aChannel=new DLocalDrive;
 	return aChannel?KErrNone:KErrNoMemory;
 	}
 /********************************************
 //	iLink.iNext=NULL;
 	}
 DLocalDrive::~DLocalDrive()
 	{
+	OstTraceFunctionEntry1( DLOCALDRIVE_DLOCALDRIVE_ENTRY, this );
 	if (iDrive)
 		{
 		__KTRACE_OPT(KLOCDRV,Kern::Printf(">DLocalDrive::DoClose D:%d, M:%08x",iDrive->iDriveNumber,iDrive->iMedia));
 		iDrive->Disconnect(this);
 		__KTRACE_OPT(KLOCDRV,Kern::Printf("<DLocalDrive::DoClose D:%d, M:%08x",iDrive->iDriveNumber,iDrive->iMedia));
 			Kern::QueueRequestComplete(pC,iNotifyChangeRequest,KErrCancel);
 		pC->Close(NULL);	// balances Open() in DoCreate
 		}
 	if (iNotifyChangeRequest)
 		Kern::DestroyClientRequest(iNotifyChangeRequest);
+	OstTraceFunctionExit1( DLOCALDRIVE_DLOCALDRIVE_EXIT, this );
 	}
 TInt DLocalDrive::DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer)
 	{
+OstTraceFunctionEntry1( DLOCALDRIVE_DOCREATE_ENTRY, this );
 	if(!Kern::CurrentThreadHasCapability(ECapabilityTCB,__PLATSEC_DIAGNOSTIC_STRING("Checked by ELOCD.LDD (Local Media Driver)")))
+	    {
+		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT1, this, KErrPermissionDenied );
 		return KErrPermissionDenied;
+	    }
 	if (!Kern::QueryVersionSupported(TVersion(KLocalDriveMajorVersion,KLocalDriveMinorVersion,KLocalDriveBuildVersion),aVer))
+	    {
+		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT2, this, KErrNotSupported );
 		return KErrNotSupported;
+	    }
 	NKern::ThreadEnterCS();
 	TInt r = Kern::CreateClientDataRequest(iNotifyChangeRequest);
 	NKern::ThreadLeaveCS();
 	if (r != KErrNone)
+	    {
+		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT3, this, r );
 		return r;
+	    }
 	DThread& t=Kern::CurrentThread();
 	NKern::LockSystem();
 	t.AddCleanup(&iCleanup);
 	NKern::UnlockSystem();
 	t.Open();
 	iNotifyChangeRequest->SetDestPtr((TBool*) anInfo);
 	iDrive=TheDrives[aUnit];
 	if (!iDrive)
+	    {
+		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT4, this, KErrNotSupported );
 		return KErrNotSupported;
+	    }
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DLocalDrive Create - connect to drive %d, M:%08x",iDrive->iDriveNumber,iDrive->iMedia));
 	r=iDrive->Connect(this);
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("<DLocalDrive Create D:%d, M:%08x r:%d",iDrive->iDriveNumber,iDrive->iMedia,r));
 	if (r!=KErrNone)
 		iDrive=NULL;	// didn't connect so don't disconnect
+	OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT5, this, r );
 	return r;
 	}
 #if defined(_DEBUG)
 void DebugDumpDriveCaps(const TLocDrv* aDrive, const TAny* aCaps)
 * iArg[8]	= Pointer to TLocDrv
 */
 TInt DLocalDrive::Request(TInt aFunction, TAny* a1, TAny* a2)
 	{
+	OstTraceFunctionEntry1( DLOCALDRIVE_REQUEST_ENTRY, this );
 	__TRACE_TIMING(0);
 	__KTRACE_OPT(KLOCDRV,Kern::Printf(">DLocalDrive::DoControl D:%d M:%08x F:%d A1:%08x A2:%08x",
 														iDrive->iDriveNumber, iDrive->iMedia, aFunction, a1, a2));
+	OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST, "iMedia=0x%08x; iDriveNumber=%d; Request Id=%d", (TUint) iDrive->iMedia, (TInt) iDrive->iDriveNumber, (TInt) aFunction );
 	TInt r=KErrNotSupported;
 	TLocDrvRequest& m=TLocDrvRequest::Get();
 	m.Flags()=0;
 	m.Drive()=iDrive;
 	switch (aFunction)
 			r=m.ProcessMessageData(a1);
 			__TRACE_TIMING(1);
 			if (r==KErrNone)
 				{
 				__TRACE_TIMING(2);
+				OstTraceDefExt4( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_READ, "ERead iDriveNumber=%d; length=0x%x; position=0x%x; TLocDrvRequest Object=0x%x", (TInt) iDrive->iDriveNumber, (TUint) m.Length(), (TUint) m.Pos(), (TUint) &m);
 				r=iDrive->Request(m);
 				__TRACE_TIMING(3);
+				OstTraceDefExt4( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_READ_RETURN, "ERead Return iDriveNumber=%d; length=0x%x; position=0x%x; TLocDrvRequest Object=0x%x", (TInt) iDrive->iDriveNumber, (TUint) m.Length(), (TUint) m.Pos(), (TUint) &m );
 				}
 			m.CloseRemoteThread();
 			break;
 			}
 		case RLocalDrive::EControlWrite:
 			{
 			m.Id()=EWrite;
 			r=m.ProcessMessageData(a1);
 			if (r==KErrNone)
+				{
+				OstTraceDefExt4( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_WRITE, "EWrite iDriveNumber=%d; length=0x%x; position=0x%x; TLocDrvRequest Object=0x%x", (TInt) iDrive->iDriveNumber, (TUint) m.Length(), (TUint) m.Pos(), (TUint) &m );
 				r=iDrive->Request(m);
+				OstTraceDefExt4( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_WRITE_RETURN, "EWrite Return iDriveNumber=%d; length=0x%x; position=0x%x; TLocDrvRequest Object=0x%x", (TInt) iDrive->iDriveNumber, (TUint) m.Length(), (TUint) m.Pos(), (TUint) &m );
+				}
 			m.CloseRemoteThread();
 			break;
 			}
 		case RLocalDrive::EControlCaps:
 			{
 						caps.iNumberOfSectors = I64LOW(totalSizeInSectors);
 						}
 					}
 				}
+#if defined(OST_TRACE_COMPILER_IN_USE) && defined(_DEBUG)
+			const TLocalDriveCapsV5& caps=*(const TLocalDriveCapsV5*)capsBuf.Ptr();
+#endif
+			OstTraceExt5( TRACE_INTERNALS, DLOCALDRIVE_REQUEST_CAPS1, "Device caps: iDriveNumber=%d; iSize=0x%x; iType=%d; iDriveAtt=%d; TLocDrvRequest Object=0x%x", (TInt)iDrive->iDriveNumber, (TUint) caps.iSize, (TInt) caps.iType, (TInt) caps.iDriveAtt, (TUint) &m);
+			OstTraceExt5( TRACE_INTERNALS, DLOCALDRIVE_REQUEST_CAPS2, "Device caps: iBaseAddress=0x%x; iFileSystemId=%d; iPartitionType=%d; iHiddenSectors=0x%x; iEraseBlockSize=0x%x", (TUint) caps.iBaseAddress, (TInt) caps.iFileSystemId, (TUint) caps.iPartitionType, (TUint) caps.iHiddenSectors, (TUint) caps.iEraseBlockSize);
 #if defined(_DEBUG)
 			__KTRACE_OPT(KLOCDRV,DebugDumpDriveCaps(iDrive,capsBuf.Ptr()));
 #endif
 			Kern::InfoCopy(*(TDes8*)a1, capsBuf);
 			break;
 		case RLocalDrive::EControlFormat:
 			{
 			m.Id()=EFormat;
 			r=m.ProcessMessageData(a1);
 			if (r==KErrNone)
+			    {
+			    OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_FORMAT, "EFormat; TLocDrvRequest Object=0x%x", (TUint) &m);
 				r=iDrive->Request(m);
+				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_FORMAT_RETURN, "EFormat Return; TLocDrvRequest Object=0x%x", (TUint) &m);
+			    }
 			break;
 			}
 		case RLocalDrive::EControlEnlarge:
 			if ((TInt)a1<0)
 				{
 				r=KErrArgument;
 				break;
 				}
 			m.Length()=(TInt)a1;
 			m.Id()=EEnlarge;
+			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_ENLARGE, "EEnlarge; TLocDrvRequest Object=0x%x", (TUint) &m);
 			r=iDrive->Request(m);
+			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_ENLARGE_RETURN, "EEnlarge Return; TLocDrvRequest Object=0x%x", (TUint) &m);
 			break;
 		case RLocalDrive::EControlReduce:
 			{
 			if ((TInt)a1<0 || (TInt)a2<0)
 				{
 				break;
 				}
 			m.Pos()=(TInt)a1;
 			m.Length()=(TInt)a2;
 			m.Id()=EReduce;
+	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_REDUCE, "EReduce; TLocDrvRequest Object=0x%x", (TUint) &m);
 			r=iDrive->Request(m);
+	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_REDUCE_RETURN, "EReduce Return; TLocDrvRequest Object=0x%x", (TUint) &m);
 			break;
 			}
 		case RLocalDrive::EControlForceMediaChange:
 			m.Pos()=(TInt)a1;
 			m.Id()=EForceMediaChange;
+	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_FORCEMEDIACHANGE, "EForceMediaChange; TLocDrvRequest Object=0x%x", (TUint) &m);
 			r = iDrive->Request(m);
+	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_FORCEMEDIACHANGE_RETURN, "EForceMediaChange Return; TLocDrvRequest Object=0x%x", (TUint) &m);
 			break;
 		case RLocalDrive::EControlMediaDevice:
+	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLMEDIADEVICE, "EControlMediaDevice; TLocDrvRequest Object=0x%x", (TUint) &m);
 			r=iDrive->iPrimaryMedia->iDevice;
 			break;
 		case RLocalDrive::EControlIsRemovable:
 			{
+	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLISREMOVABLE, "EControlIsRemovable; TLocDrvRequest Object=0x%x", (TUint) &m);
 			TInt sockNum;
 			r=iDrive->iPrimaryMedia->IsRemovableDevice(sockNum);
 			if (r)
 				kumemput32(a1,&sockNum,sizeof(TInt));
 			break;
 			//We're highjacking fields representing
 			//length and position in a normal message, so
 			//let's not have the dispatcher function attempt
 			//to adjust for partition size.
 			m.Flags() |= TLocDrvRequest::EAdjusted;
+	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLCONTROLIO, "EControlControlIO; TLocDrvRequest Object=0x%x", (TUint) &m);
 			r=iDrive->Request(m);
+			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLCONTROLIO_RETURN, "EControlControlIO Return; TLocDrvRequest Object=0x%x", (TUint) &m);
 			break;
 			}
 		case RLocalDrive::EControlSetMountInfo:
 			{
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLSETMOUNTINFO, "EControlSetMountInfo; TLocDrvRequest Object=0x%x", (TUint) &m);
 			m.Id()=ERead;
 			r=m.ProcessMessageData(a1);
 			DPrimaryMediaBase* pM=iDrive->iPrimaryMedia;
 			if(!pM || r!=KErrNone)
 				break;
 			TMediaPassword newPasswd;
 			TLocalDrivePasswordData pswData;
 			r = ReadPasswordData(m, pswData, oldPasswd, newPasswd);
 			if (r == KErrNone)
+				{
+				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDLOCK, "EPasswordLock; TLocDrvRequest Object=0x%x", (TUint) &m);
 				r = iDrive->Request(m);
+				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDLOCK_RETURN, "EPasswordLock Return; TLocDrvRequest Object=0x%x", (TUint) &m);
+				}
 			break;
 			}
 		case RLocalDrive::EControlPasswordUnlock:
 			{
 			m.Id()=EPasswordUnlock;
 			TMediaPassword newPasswd;
 			TLocalDrivePasswordData pswData;
 			r = ReadPasswordData(m, pswData, oldPasswd, newPasswd);
 			if(r == KErrNone)
+				{
+				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDUNLOCK, "EPasswordUnLock; TLocDrvRequest Object=0x%x", (TUint) &m);
 				r=iDrive->Request(m);
+				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDUNLOCK_RETURN, "EPasswordUnLock Return; TLocDrvRequest Object=0x%x", (TUint) &m);
+				}
 			if (r == KErrNone)
 				iDrive->iPrimaryMedia->iTotalPartitionsOpened = 0;
 			break;
 			}
 		case RLocalDrive::EControlPasswordClear:
 			TMediaPassword newPasswd;
 			TLocalDrivePasswordData pswData;
 			r = ReadPasswordData(m, pswData, oldPasswd, newPasswd);
 			if (r == KErrNone)
+				{
+				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDCLEAR, "EPasswordClear; TLocDrvRequest Object=0x%x", (TUint) &m);
 				r = iDrive->Request(m);
+				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDCLEAR_RETURN, "EPasswordClear Return; TLocDrvRequest Object=0x%x", (TUint) &m);
+				}
 			break;
 			}
 		case RLocalDrive::EControlPasswordErase:
 			{
 			m.Id()=EPasswordErase;
+			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDERASE, "EPasswordErase; TLocDrvRequest Object=0x%x", (TUint) &m);
 			r=iDrive->Request(m);
+			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDERASE_RETURN, "EPasswordErase Return; TLocDrvRequest Object=0x%x", (TUint) &m);
 			if(r == KErrNone)
 				iDrive->iPrimaryMedia->iTotalPartitionsOpened = 0;
 			break;
 			}
 		case RLocalDrive::EControlNotifyChange:
 			if (iCleanup.iThread != &Kern::CurrentThread())
 				Kern::PanicCurrentThread(KLitLocMedia,KErrAccessDenied);
 			r=KErrNone;
 			if (!iNotifyChangeRequest->StatusPtr())
 				r = iNotifyChangeRequest->SetStatus((TRequestStatus*) a1);
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLNOTIFYCHANGE, "EControlNotifyChange; TLocDrvRequest Object=0x%x", (TUint) &m);
 			break;
 		case RLocalDrive::EControlNotifyChangeCancel:
 			if (iCleanup.iThread != &Kern::CurrentThread())
 				Kern::PanicCurrentThread(KLitLocMedia,KErrAccessDenied);
 			Kern::QueueRequestComplete(iCleanup.iThread,iNotifyChangeRequest,KErrCancel);
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLNOTIFYCHANGECANCEL, "EControlNotifyChangeCancel; TLocDrvRequest Object=0x%x", (TUint) &m);
 			break;
 		case RLocalDrive::EControlReadPasswordStore:
 			{
 			TUint8  passData[TPasswordStore::EMaxPasswordLength];
 			m.RemoteDes() = (TAny*) passData;
 			m.Length() = sizeof(passData);
 			m.Id()=EReadPasswordStore;
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_READPASSWORDSTORE, "EReadPasswordStore; TLocDrvRequest Object=0x%x", (TUint) &m);
 			r=iDrive->Request(m);
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_READPASSWORDSTORE_RETURN, "EReadPasswordStore Return; TLocDrvRequest Object=0x%x", (TUint) &m);
 			if (r==KErrNone)
 				{
 				TPtr8 pData(passData, (TInt) m.Length(), TPasswordStore::EMaxPasswordLength);
 				m.RemoteDes()=(TDes8*)a1;
 				r = m.WriteRemote(&pData,0);
 			m.RemoteDes() = (TAny*) pData.Ptr();
 			m.Length() = pData.Length();
 			m.Id()=EWritePasswordStore;
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_WRITEPASSWORDSTORE, "EWritePasswordStore; TLocDrvRequest Object=0x%x", (TUint) &m);
 			r=iDrive->Request(m);
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_WRITEPASSWORDSTORE_RETURN, "EReadPasswordStore Return; TLocDrvRequest Object=0x%x", (TUint) &m);
 			if(r == KErrNone)
 				iDrive->iPrimaryMedia->iTotalPartitionsOpened = 0;
 			break;
 			}
 		case RLocalDrive::EControlPasswordStoreLengthInBytes:
 			{
 			m.Id()=EPasswordStoreLengthInBytes;
 			TInt length;
 			m.RemoteDes() = (TAny*) &length;
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDSTORELENGTH, "EPasswordStoreLengthInBytes; TLocDrvRequest Object=0x%x", (TUint) &m);
 			r=iDrive->Request(m);
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDSTORELENGTH_RETURN, "EPasswordStoreLengthInBytes Return; TLocDrvRequest Object=0x%x", (TUint) &m);
 			if (r == KErrNone)
 				{
 				m.RemoteDes()=a1;
 				r = m.WriteRemoteRaw(&length,sizeof(TInt));
 			TErrorInfoBuf errorInfoBuf;
 			errorInfoBuf.SetMax();
 			errorInfoBuf.FillZ();
 			m.RemoteDes()=(TAny*) errorInfoBuf.Ptr();	// overload this
 			m.Length() = errorInfoBuf.MaxLength();
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_GETLASTERRORINFO, "EGetLastErrorInfo; TLocDrvRequest Object=0x%x", (TUint) &m);
 			r=iDrive->Request(m);
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLGETLASTERRORINFO_RETURN, "EControlGetLastErrorInfo Return; TLocDrvRequest Object=0x%x", (TUint) &m);
 			Kern::InfoCopy(*(TDes8*)a1, errorInfoBuf);
 			break;
 			}
 		case RLocalDrive::EControlDeleteNotify:
 			{
 			m.Id()=EDeleteNotify;
 			r=m.ProcessMessageData(a1);
 			if (r==KErrNone)
+			    {
+			    OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_DELETENOTIFY, "EDeleteNotify; TLocDrvRequest Object=0x%x", (TUint) &m);
 				r=iDrive->Request(m);
+				OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_DELETENOTIFY_RETURN, "EDeleteNotify Return; TLocDrvRequest Object=0x%x", (TUint) &m);
+			    }
 			break;
 			}
 		case RLocalDrive::EControlQueryDevice:
 			{
 			TBuf8<KMaxQueryDeviceLength> queryBuf;
 			queryBuf.SetMax();
 			queryBuf.FillZ();
 			m.Id() = EQueryDevice;
 			m.iArg[0] = a1;		// RLocalDrive::TQueryDevice
 			m.RemoteDes() = (TAny*)queryBuf.Ptr();	// overload this
 			m.Length() = KMaxLocalDriveCapsLength;	// for pinning
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_QUERYDEVICE, "EQueryDevice; TLocDrvRequest Object=0x%x", (TUint) &m);
 			r=iDrive->Request(m);
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_QUERYDEVICE_RETURN, "EQueryDevice Return; TLocDrvRequest Object=0x%x", (TUint) &m);
 			Kern::InfoCopy(*(TDes8*)a2, queryBuf);
 			break;
 			}
 		}
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("<DLocalDrive::DoControl D:%d M:%08x ret %d",iDrive->iDriveNumber, iDrive->iMedia, r));
 	__TRACE_TIMING(4);
+	OstTraceFunctionExitExt( DLOCALDRIVE_REQUEST_EXIT, this, r );
 	return r;
 	}
 TInt DLocalDrive::ReadPasswordData(TLocDrvRequest& aReq, TLocalDrivePasswordData& aPswData, TMediaPassword& aOldPasswd, TMediaPassword& aNewPasswd)
 	{
 #ifdef __DEMAND_PAGING__
 TInt DLocalDrive::LockMountInfo(DPrimaryMediaBase& aPrimaryMedia, TLocDrvRequest& aReq)
 	{
+	OstTraceExt2(TRACE_FLOW, DLOCALDRIVE_LOCKMOUNTINFO_ENTRY, "> aPrimaryMedia=%x;aReq=%x", (TUint) &aPrimaryMedia, (TUint) &aReq );
 	DMediaPagingDevice* pagingDevice = aPrimaryMedia.iBody->iPagingDevice;
 	if (pagingDevice == NULL)
+	    {
+		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT1, this, KErrNone );
 		return KErrNone;
+	    }
 	__ASSERT_DEBUG(pagingDevice->iMountInfoDataLock == NULL, LOCM_FAULT());
 	__ASSERT_DEBUG(pagingDevice->iMountInfoDescHdrLock == NULL, LOCM_FAULT());
 	__ASSERT_DEBUG(pagingDevice->iMountInfoDescLenLock == NULL, LOCM_FAULT());
 	TInt length = 0;
 	TInt maxLength = 0;
 	TUint8* desAddress = NULL;
 	TInt r = Kern::ThreadGetDesInfo(pT,aReq.RemoteDes(),length,maxLength,desAddress,EFalse);	// get descriptor length, maxlength and desAddress
 	if (r != KErrNone)
+	    {
+		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT2, this, r );
 		return r;
+	    }
 	if (length == 0)
+	    {
+		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT3, this, KErrNone );
 		return KErrNone;
+	    }
 	static const TUint8 LengthLookup[16]={4,8,12,8,12,0,0,0,0,0,0,0,0,0,0,0};
 	TUint32 desHdr;
 	r = Kern::ThreadRawRead(pT, aReq.RemoteDes(), &desHdr, sizeof(desHdr));
 	if(r!=KErrNone)
+	    {
+		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT4, this, r );
 		return r;
+	    }
 	TInt desType = desHdr >>KShiftDesType8;
 	TInt desHdrLen = LengthLookup[desType];
 	if(!desHdrLen)
+	    {
+		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT5, this, KErrBadDescriptor );
 		return KErrBadDescriptor;
+	    }
 	pagingDevice->iMountInfoDataLock = ThePinObjectAllocator->AcquirePinObject();
 	pagingDevice->iMountInfoDescHdrLock = ThePinObjectAllocator->AcquirePinObject();
 	pagingDevice->iMountInfoDescLenLock = ThePinObjectAllocator->AcquirePinObject();
 	if (pagingDevice->iMountInfoDataLock == NULL ||
 		pagingDevice->iMountInfoDescHdrLock == NULL ||
 		pagingDevice->iMountInfoDescLenLock == NULL)
 		{
 		UnlockMountInfo(aPrimaryMedia);	// tidy up
+		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT6, this, KErrNoMemory );
 		return KErrNoMemory;
 		}
 	// First pin the descriptor header
 	lock = (DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDescHdrLock;
 	r = Kern::PinVirtualMemory(lock->iObject, (TLinAddr) (TUint8*) aReq.RemoteDes(), desHdrLen, pT);
 	if (r != KErrNone)
 		{
 		UnlockMountInfo(aPrimaryMedia);	// tidy up
+		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT7, this, KErrNoMemory );
 		return KErrNoMemory;
 		}
 		TLinAddr extraLenAddr = TLinAddr(desAddress) - aReq.RemoteDesOffset() - sizeof(TUint32);
 		r = Kern::PinVirtualMemory(lock->iObject, (TLinAddr) (TUint8*) extraLenAddr, sizeof(TUint32), pT);
 		if (r != KErrNone)
 			{
 			UnlockMountInfo(aPrimaryMedia);	// tidy up
+			OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT8, this, KErrNoMemory );
 			return KErrNoMemory;
 			}
 		}
 	lock = (DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDataLock;
 	r = Kern::PinVirtualMemory(lock->iObject, (TLinAddr) desAddress, length, pT);
 	if (r != KErrNone)
 		{
 		UnlockMountInfo(aPrimaryMedia);	// tidy up
+		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT9, this, KErrNoMemory );
 		return KErrNoMemory;
 		}
+	OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT10, this, KErrNone );
 	return KErrNone;
 	}
 void DLocalDrive::UnlockMountInfo(DPrimaryMediaBase& aPrimaryMedia)
 	{
+	OstTrace1(TRACE_FLOW, DLOCALDRIVE_UNLOCKMOUNTINFO_ENTRY, "> DLocalDrive::UnlockMountInfo;aPrimaryMedia=%x", (TUint) &aPrimaryMedia);
 	DMediaPagingDevice* pagingDevice = aPrimaryMedia.iBody->iPagingDevice;
 	if (pagingDevice == NULL || pagingDevice->iMountInfoDataLock == NULL)
+	    {
+		OstTraceFunctionExit1( DLOCALDRIVE_UNLOCKMOUNTINFO_EXIT1, this );
 		return;
+	    }
 	if (pagingDevice->iMountInfoDataLock)
 		{
 		Kern::UnpinVirtualMemory(((DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDataLock)->iObject);
 		Kern::UnpinVirtualMemory(((DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDescLenLock)->iObject);
 		ThePinObjectAllocator->ReleasePinObject((DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDescLenLock);
 		pagingDevice->iMountInfoDescLenLock = NULL;
 		}
+	OstTraceFunctionExit1( DLOCALDRIVE_UNLOCKMOUNTINFO_EXIT2, this );
 	}
 #endif	// __DEMAND_PAGING__
 void DLocalDrive::NotifyChange(DPrimaryMediaBase& aPrimaryMedia, TBool aMediaChange)
 	{
+OstTraceExt2( TRACE_FLOW, DLOCALDRIVE_NOTIFYCHANGE_ENTRY, "> DLocalDrive::NotifyChange;aPrimaryMedia=%x;aMediaChange=%d", (TUint) &aPrimaryMedia, aMediaChange );
 #ifndef __DEMAND_PAGING__
 	aPrimaryMedia;
 #endif
 	// Complete any notification request on media change or power down
 				Kern::ThreadRawWrite(pC, iNotifyChangeRequest->DestPtr(), &b, sizeof(b), NULL);
 				}
 			pC->AsyncClose();
 			}
 		}
+	OstTraceFunctionExit1( DLOCALDRIVE_NOTIFYCHANGE_EXIT, this );
 	}
 TLocalDriveCleanup::TLocalDriveCleanup()
 	{
 	}
 @see Kern::ThreadDesRead()
 */
 EXPORT_C TInt TLocDrvRequest::ReadRemote(TDes8* aDes, TInt anOffset)
 	{
+	OstTraceFunctionEntry1( TLOCDRVREQUEST_READREMOTE_ENTRY, this );
+	TInt r;
 	DThread* pT=RemoteThread();
 	if (!pT)
 		pT=Client();
 #ifdef __DEMAND_PAGING__	// only if driver has its own thread, we don't support paging in MD which run in the context of their clients
 	if (Flags() & ETClientBuffer)
-		return Kern::ThreadBufRead(pT, (TClientBuffer*) RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0);
+	    {
+r = Kern::ThreadBufRead(pT, (TClientBuffer*) RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0);
+		OstTraceFunctionExitExt( TLOCDRVREQUEST_READREMOTE_EXIT1, this, r );
+		return r;
+	    }
 	__ASSERT_ALWAYS((Flags() & ETClientBuffer) == 0, LOCM_FAULT());
 #endif
+	r = Kern::ThreadDesRead(pT,RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0);
-	return Kern::ThreadDesRead(pT,RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0);
+	OstTraceFunctionExitExt( TLOCDRVREQUEST_READREMOTE_EXIT2, this, r );
+	return r;
 	}
 @see Kern::ThreadDesRead()
 */
 EXPORT_C TInt TLocDrvRequest::ReadRemote(const TAny* aSrc, TDes8* aDes)
 	{
+	OstTraceFunctionEntry1( TLOCDRVREQUEST_READ_REMOTE_ENTRY, this );
 	if (Flags() & TLocDrvRequest::EKernelBuffer)
 		{
 		aDes->Copy(* (TDesC8*) aSrc);
 		return KErrNone;
 		}
+	TInt r;
 	DThread* pT=RemoteThread();
 	if (!pT)
 		pT=Client();
 #ifdef __DEMAND_PAGING__
 	__ASSERT_DEBUG(!DataPagingDfcQ(Drive()->iPrimaryMedia), LOCM_FAULT());
 	if (DataPagingDfcQ(Drive()->iPrimaryMedia))
+		{
+		OstTraceFunctionExitExt( TLOCDRVREQUEST_READ_REMOTE_EXIT1, this, KErrNotSupported );
 		return KErrNotSupported;
-#endif
+	    }
+#endif
-	return Kern::ThreadDesRead(pT,aSrc,*aDes,0,KChunkShiftBy0);
+	r = Kern::ThreadDesRead(pT,aSrc,*aDes,0,KChunkShiftBy0);
+	OstTraceFunctionExitExt( TLOCDRVREQUEST_READ_REMOTE_EXIT2, this, r );
+	return r;
 	}
 @see Kern::ThreadRawRead()
 */
 EXPORT_C TInt TLocDrvRequest::ReadRemoteRaw(TAny* aDest, TInt aSize)
 	{
+	OstTraceFunctionEntry1( TLOCDRVREQUEST_READREMOTERAW_ENTRY, this );
 	if (Flags() & TLocDrvRequest::EKernelBuffer)
 		{
 		(void)memcpy(aDest, (TAny*) RemoteDes(), aSize);
 		return KErrNone;
 		}
+	TInt r;
 	DThread* pT=RemoteThread();
 	if (!pT)
 		pT=Client();
 #ifdef __DEMAND_PAGING__
 	__ASSERT_ALWAYS((Flags() & ETClientBuffer) == 0, LOCM_FAULT());
 #endif
-	return Kern::ThreadRawRead(pT,RemoteDes(),aDest,aSize);
+	r = Kern::ThreadRawRead(pT,RemoteDes(),aDest,aSize);
+	OstTraceFunctionExitExt( TLOCDRVREQUEST_READREMOTERAW_EXIT, this, r );
+	return r;
 	}
 /**
 Writes data to a descriptor in the requesting thread's process.
 @see Kern::ThreadDesWrite()
 */
 EXPORT_C TInt TLocDrvRequest::WriteRemote(const TDesC8* aDes, TInt anOffset)
 	{
+OstTraceFunctionEntry1( TLOCDRVREQUEST_WRITEREMOTE_ENTRY, this );
+TInt r;
 	DThread* pC=Client();
 	DThread* pT=RemoteThread();
 	if (!pT)
 		pT=pC;
 #ifdef __DEMAND_PAGING__
 	if (Flags() & ETClientBuffer)
-		return Kern::ThreadBufWrite(pT, (TClientBuffer*) RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0,pC);
+	    {
-#endif
+r = Kern::ThreadBufWrite(pT, (TClientBuffer*) RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0,pC);
+		OstTraceFunctionExitExt( TLOCDRVREQUEST_WRITEREMOTE_EXIT1, this, r );
-	return Kern::ThreadDesWrite(pT,RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0,pC);
+		return r;
+	    }
+#endif
+	r = Kern::ThreadDesWrite(pT,RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0,pC);
+	OstTraceFunctionExitExt( TLOCDRVREQUEST_WRITEREMOTE_EXIT2, this, r );
+	return r;
 	}
 /**
 Writes raw data to the requesting thread's process.
 @see Kern::ThreadRawWrite()
 */
 EXPORT_C TInt TLocDrvRequest::WriteRemoteRaw(const TAny* aSrc, TInt aSize)
 	{
+OstTraceFunctionEntry1( TLOCDRVREQUEST_WRITEREMOTERAW_ENTRY, this );
+TInt r;
 	DThread* pC=Client();
 	DThread* pT=RemoteThread();
 	if (!pT)
 		pT=pC;
 #ifdef __DEMAND_PAGING__
 	__ASSERT_ALWAYS((Flags() & ETClientBuffer) == 0, LOCM_FAULT());
 #endif
+	r = Kern::ThreadRawWrite(pT,RemoteDes(),aSrc,aSize,pC);
-	return Kern::ThreadRawWrite(pT,RemoteDes(),aSrc,aSize,pC);
+	OstTraceFunctionExitExt( TLOCDRVREQUEST_WRITEREMOTERAW_EXIT, this, r );
+	return r;
 	}
 TInt TLocDrvRequest::ProcessMessageData(TAny* aPtr)
 //
 // Get read/write parameters from client and open remote thread
 //
 	{
+	OstTraceFunctionEntry1( TLOCDRVREQUEST_PROCESSMESSAGEDATA_ENTRY, this );
 	RemoteThread()=NULL;
 	DThread& t=Kern::CurrentThread();
 	TLocalDriveMessageData d;
 	kumemget32(&d,aPtr,sizeof(d));
+	OstTrace1( TRACE_INTERNALS, TLOCDRVREQUEST_PROCESSMESSAGEDATA, "Message handle=%d", d.iHandle );
 	if (d.iHandle!=KLocalMessageHandle && Id()!=DLocalDrive::EFormat)
 		{
 		NKern::LockSystem();
 		DThread* pT = RMessageK::MessageK(d.iHandle)->iClient;
 		if (!pT || pT->Open()!=KErrNone)
 			{
 			NKern::UnlockSystem();
+			OstTraceFunctionExitExt( TLOCDRVREQUEST_PROCESSMESSAGEDATA_EXIT1, this, KErrBadHandle );
 			return KErrBadHandle;
 			}
 		t.iExtTempObj=pT;
 		RemoteThread()=pT;
 		NKern::UnlockSystem();
 	Length()=d.iLength;
 	RemoteDes()=(TAny*)d.iPtr;
 	RemoteDesOffset()=d.iOffset;
 	DriverFlags()=d.iFlags;
 	if (Pos()<0 || Length()<0)
+	    {
+		OstTraceFunctionExitExt( TLOCDRVREQUEST_PROCESSMESSAGEDATA_EXIT2, this, KErrArgument );
 		return KErrArgument;
+	    }
+	OstTraceFunctionExitExt( TLOCDRVREQUEST_PROCESSMESSAGEDATA_EXIT3, this, KErrNone );
 	return KErrNone;
 	}
 void TLocDrvRequest::CloseRemoteThread()
 	{
+OstTraceFunctionEntry1( TLOCDRVREQUEST_CLOSEREMOTETHREAD_ENTRY, this );
 	if (!RemoteThread())
+	    {
+		OstTraceFunctionExit1( TLOCDRVREQUEST_CLOSEREMOTETHREAD_EXIT1, this );
 		return;
+	    }
 	NKern::ThreadEnterCS();
 	DThread& t=Kern::CurrentThread();
 	RemoteThread()=NULL;
 	Kern::SafeClose((DObject*&)t.iExtTempObj,NULL);
 	NKern::ThreadLeaveCS();
+	OstTraceFunctionExit1( TLOCDRVREQUEST_CLOSEREMOTETHREAD_EXIT2, this );
 	}
 EXPORT_C TInt TLocDrvRequest::CheckAndAdjustForPartition()
 	{
+	OstTraceFunctionEntry1( TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION_ENTRY, this );
 	TLocDrv& d=*Drive();
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("CheckAndAdjustForPartition drive %d partition len %lx",d.iDriveNumber,d.iPartitionLen));
+	OstTraceExt2( TRACE_INTERNALS, TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION1, "iDriveNumber=%d; partition length=0x%lx", d.iDriveNumber, (TInt) d.iPartitionLen );
 	Flags() |= EAdjusted;
+	TInt r;
 	switch (Id())
 		{
 		case DLocalDrive::ECaps:
 		case DLocalDrive::EForceMediaChange:
 		case DLocalDrive::EPasswordLock:
 		case DLocalDrive::EPasswordErase:
 		case DLocalDrive::EReadPasswordStore:
 		case DLocalDrive::EWritePasswordStore:
 		case DLocalDrive::EPasswordStoreLengthInBytes:
 		case DLocalDrive::EQueryDevice:
-			return KErrNone;
+		    {
+			r = KErrNone;
+			break;
+		    }
 		case DLocalDrive::EEnlarge:
 			__KTRACE_OPT(KLOCDRV,Kern::Printf("Enlarge request %lx",Length()));
+			OstTrace1( TRACE_INTERNALS, TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION2, "Enlarge request=0x%lx", Length() );
 			if (Length()>KMaxTInt)
-				return KErrArgument;
+				r = KErrArgument;
-			return KErrNone;
+			else
+			    r = KErrNone;
+			break;
 		case DLocalDrive::EReduce:
 			__KTRACE_OPT(KLOCDRV,Kern::Printf("Reduce request %lx@%lx",Length(),Pos()));
+			OstTraceExt2( TRACE_INTERNALS, TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION3, "Reduce request length=0x%lx; position=0x%lx", (TUint) Length(), (TUint) Pos() );
 			if (Pos()+Length()>d.iPartitionLen)
-				return KErrArgument;
+				r = KErrArgument;
-			return KErrNone;
+			else
+r = KErrNone;
+			break;
 		case DLocalDrive::EFormat:
 			__KTRACE_OPT(KLOCDRV,Kern::Printf("Format request %lx@%lx",Length(),Pos()));
+			OstTraceExt2( TRACE_INTERNALS, TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION4, "Format request length=0x%lx; position=0x%lx", (TUint) Length(), (TUint) Pos() );
 			if (!(DriverFlags() & RLocalDrive::ELocDrvWholeMedia))
 				{
 				if (Pos()>d.iPartitionLen)
 					{
 					Length()=0;
-					return KErrEof;
+					r = KErrEof;
+					break;
 					}
 				Int64 left=d.iPartitionLen-Pos();
 				if (left<Length())
 					Length()=left;
 				Pos()+=d.iPartitionBaseAddr;
 				if (Length()==0)
-					return KErrEof;
+				    {
+					r = KErrEof;
+					break;
+				    }
 				}
-			return KErrNone;
+			r = KErrNone;
+			break;
 #ifdef __DEMAND_PAGING__
 		case DMediaPagingDevice::ERomPageInRequest:
 //          if the ROM was reported to LOCM then it will also need to be adjusted....
 //		    Otherwise the media driver adjust it internally
 		case DMediaPagingDevice::ECodePageInRequest:
 			__KTRACE_OPT(KLOCDPAGING,Kern::Printf("Adjusted Paging read request %lx@%lx",Length(),Pos()));
+			OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, TLOCDRVREQUESTCHECKANDADJUSTFORPARTITION5, "Adjusted Paging read request length=0x%lx; position=0x%lx", (TUint) Length(),  (TUint) Pos());
 			if (Pos()+Length()>d.iPartitionLen)
-				return KErrArgument;
+			    {
+				r = KErrArgument;
+				break;
+			    }
 			Pos()+=d.iPartitionBaseAddr;
-			return KErrNone;
+			r = KErrNone;
+			break;
 #endif
 		default:	// read or write or fragment
 			__KTRACE_OPT(KLOCDRV,Kern::Printf("R/W request %lx@%lx",Length(),Pos()));
+			OstTraceExt2( TRACE_INTERNALS, TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION6, "Read/Write request length=0x%x; position=0x%x", (TUint) Length(), (TUint) Pos() );
 			if (DriverFlags() & RLocalDrive::ELocDrvWholeMedia)
 				{
 				if (d.iMedia && d.iMedia->iDriver && Pos()+Length() > d.iMedia->iDriver->iTotalSizeInBytes)
-					return KErrArgument;
+				    {
+					r = KErrArgument;
+					break;
+				    }
 				}
 			else
 				{
 				if (Pos()+Length() > d.iPartitionLen)
-					return KErrArgument;
+				    {
+					r = KErrArgument;
+					break;
+				    }
 				Pos()+=d.iPartitionBaseAddr;
 				}
-			return KErrNone;
+		r = KErrNone;
 		}
+	OstTraceFunctionExitExt( TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION_EXIT, this, r );
+	return r;
 	}
 /********************************************
 * Local drive class
 ********************************************/
 TLocDrv::TLocDrv(TInt aDriveNumber)
 	{
+	OstTraceFunctionEntryExt( TLOCDRV_TLOCDRV_ENTRY, this );
 	memclr(this, sizeof(TLocDrv));
 	iDriveNumber=aDriveNumber;
 	iPartitionNumber=-1;
+	OstTraceFunctionExit1( TLOCDRV_TLOCDRV_EXIT, this );
 	}
 /**
 Initialises the DMedia entity with the media device number and ID.
 @see	TMediaDevice
 */
 EXPORT_C TInt DMedia::Create(TMediaDevice aDevice, TInt aMediaId, TInt)
 	{
+	OstTraceFunctionEntry1( DMEDIA_CREATE_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DMedia::Create media %d device %d",aMediaId,aDevice));
+	OstTraceExt2(TRACE_INTERNALS, DMEDIA_CREATE, "media=%d; device=%d", aMediaId, (TUint) aDevice);
 	iMediaId=aMediaId;
 	iDevice=aDevice;
+	OstTraceFunctionExitExt( DMEDIA_CREATE_EXIT, this, KErrNone );
 	return KErrNone;
 	}
 /********************************************
 * Primary Media Class
 ********************************************/
 void asyncDfc(TAny* aPtr)
 	{
+	OstTraceFunctionEntry0( _ASYNCDFC_ENTRY );
 	DPrimaryMediaBase* pM=(DPrimaryMediaBase*)aPtr;
 	if (pM->iState==DMedia::EOpening)
 		pM->DoOpenMediaDriverComplete(pM->iAsyncErrorCode);
 	else if (pM->iState==DMedia::EReadPartitionInfo)
 		pM->DoPartitionInfoComplete(pM->iAsyncErrorCode);
+	OstTraceFunctionExit0( _ASYNCDFC_EXIT );
 	}
 void handleMsg(TAny* aPtr)
 	{
+	OstTraceFunctionEntry0( _HANDLEMSG_ENTRY );
 	DPrimaryMediaBase* primaryMedia=(DPrimaryMediaBase*)aPtr;
 	for(TLocDrvRequest* m = (TLocDrvRequest*) primaryMedia->iMsgQ.iMessage;
 		m != NULL;
 		m = (TLocDrvRequest*) primaryMedia->iMsgQ.Poll())
 #endif
 		}
 	primaryMedia->iMsgQ.Receive();	// allow reception of more messages
+	OstTraceFunctionExit0( _HANDLEMSG_EXIT );
 	}
 EXPORT_C DPrimaryMediaBase::DPrimaryMediaBase()
 	:	iMsgQ(handleMsg, this, NULL, 1),
 		iDeferred(NULL, NULL, NULL, 0),			// callback never used
 /**
 Constructor of DPrimaryMediaBase class.
 Initialises the media state as closed.
 */
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_DPRIMARYMEDIABASE_ENTRY, this );
 	iState = EClosed;
 	}
 @return KErrNone
 @see TMediaDevice
 */
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_CREATE_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase::Create media %d-%d device %d",aMediaId,aLastMediaId,aDevice));
+	OstTraceExt3( TRACE_INTERNALS, DPRIMARYMEDIABASE_CREATE, "aMediaId=%d; aLastMediaId=%d; aDevice=%d ", aMediaId, aLastMediaId, (TUint) aDevice );
 	TInt r=DMedia::Create(aDevice,aMediaId,0);
 	if (r != KErrNone)
+	    {
+		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_CREATE_EXIT1, this, r );
 		return r;
+	    }
 	iBody = new DBody;
 	if (iBody == NULL)
+	    {
+		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_CREATE_EXIT2, this, KErrNoMemory );
 		return KErrNoMemory;
+	    }
 #ifdef __DEMAND_PAGING__
 	TInt pageSize = Kern::RoundToPageSize(1);
 	iBody->iPageSizeMsk = pageSize-1;
 #endif
 		iMsgQ.SetDfcQ(iDfcQ);
 		iDeferred.SetDfcQ(iDfcQ);
 		iWaitMedChg.SetDfcQ(iDfcQ);
 		iAsyncDfc.SetDfcQ(iDfcQ);
 		}
+	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_CREATE_EXIT3, this, KErrNone );
 	return KErrNone;
 	}
 EXPORT_C TInt DPrimaryMediaBase::Connect(DLocalDrive* aLocalDrive)
 		otherwise, one of the other system wide error codes.
 @see DLocalDrive
 */
 	{
+	OstTraceFunctionEntryExt( DPRIMARYMEDIABASE_CONNECT_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::Connect %O",iMediaId,aLocalDrive));
+	OstTraceExt2( TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_CONNECT, "iMediaId=%d; iDriveNumber=%d", iMediaId, aLocalDrive->iDrive->iDriveNumber );
+	TInt r=KErrNone;
 	if (iDfcQ)
 		{
 		TThreadMessage& m=Kern::Message();
 		m.iValue=EConnect;
 		m.iArg[0]=aLocalDrive;
-		return m.SendReceive(&iMsgQ);
+		r=m.SendReceive(&iMsgQ);
+		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_CONNECT_EXIT1, this, r );
+		return r;
 		}
 	// If no DFC queue, must be a fixed media device
 	// If this is the first connection, open media driver now
 	// Assume no non-primary media exist on this device
-	TInt r=KErrNone;
 	NKern::LockSystem();
 	TBool first=iConnectionQ.IsEmpty();
 	iConnectionQ.Add(&aLocalDrive->iLink);
 	NKern::UnlockSystem();
 	if (first)
 			NKern::LockSystem();
 			aLocalDrive->Deque();
 			NKern::UnlockSystem();
 			}
 		}
 	if (r==KErrNone)
 		aLocalDrive->iDrive->iMedia=this;
+	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_CONNECT_EXIT2, this, r );
 	return r;
 	}
 @post Kernel must be unlocked
 @see DLocalDrive
 */
 	{
+	OstTraceFunctionEntryExt( DPRIMARYMEDIABASE_DISCONNECT_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::Disconnect %O",iMediaId,aLocalDrive));
+	OstTraceExt2( TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_DISCONNECT, "iMediaId=%d; iDriveNumber=%d", iMediaId, aLocalDrive->iDrive->iDriveNumber );
 	if (iDfcQ)
 		{
 		TThreadMessage& m=Kern::Message();
 		m.iValue=EDisconnect;
 		m.iArg[0]=aLocalDrive;
 		m.SendReceive(&iMsgQ);
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_DISCONNECT_EXIT1, this );
 		return;
 		}
 	// If no DFC queue, must be a fixed media device
 	// If this is the last connection, close media driver now
 		iDriver=NULL;
 		}
 	NKern::UnlockSystem();
 	if (pD)
 		pD->Close();
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_DISCONNECT_EXIT2, this );
 	}
 EXPORT_C TInt DPrimaryMediaBase::Request(TLocDrvRequest& aReq)
 /**
 Issues a local drive request. It is called from TLocDrv::Request() function .
 	Otherwise, one of the other system wide error codes.
 @see TLocDrvRequest
 */
 	{
+OstTraceFunctionEntry1( DPRIMARYMEDIABASE_REQUEST_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::Request(%08x)",iMediaId,&aReq));
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("this=%x, ReqId=%d, Pos=%lx, Len=%lx, remote thread %O",this,aReq.Id(),aReq.Pos(),aReq.Length(),aReq.RemoteThread()));
+	OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DPRIMARYMEDIABASE_REQUEST, "reqId=%d; length=0x%lx; position=0x%lx; remote thread=0x%x", (TInt) aReq.Id(), (TUint) aReq.Length(),  (TUint) aReq.Pos(), (TUint) aReq.RemoteThread());
 	TInt reqId = aReq.Id();
 	if (reqId == DLocalDrive::ECaps)
 		DefaultDriveCaps(*(TLocalDriveCapsV2*)aReq.RemoteDes());	// fill in stuff we know even if no media present
 	if (r != KErrNone && aReq.Id()!=DLocalDrive::EForceMediaChange &&			// EForceMediaChange, and
 			 			 aReq.Id()!=DLocalDrive::EReadPasswordStore &&			// Password store operations
 						 aReq.Id()!=DLocalDrive::EWritePasswordStore &&			// do not require the media
 						 aReq.Id()!=DLocalDrive::EPasswordStoreLengthInBytes)	// to be ready.)
 	 	{
+		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_REQUEST_EXIT, this, r );
 		return r;
 	  	}
 	// for ERead & EWrite requests, get the linear address for pinning & DMA
 			if (reqId == DLocalDrive::ERead)
 				{
 				TPtrC8 ptr(NULL, 0);
 				r = Kern::ThreadDesWrite(pT, aReq.RemoteDes(), ptr, aReq.RemoteDesOffset(), KChunkShiftBy0,pC);
 				}
+			OstTraceFunctionExitExt( DPRIMARYMEDIABASE_REQUEST_EXIT2, this, r );
 			return r;
 			}
 		clientBuffer.SetFromDescriptor(aReq.RemoteDes(), pT);
 		TInt length = 0;
 		TInt maxLength = 0;
 		TInt r = Kern::ThreadGetDesInfo(pT,aReq.RemoteDes(),length,maxLength,linAddress,EFalse);	// get descriptor length, maxlength and linAddress
 		if (r != KErrNone)
+		    {
+			OstTraceFunctionExitExt( DPRIMARYMEDIABASE_REQUEST_EXIT3, this, r );
 			return r;
+		    }
 		linAddress+= aReq.RemoteDesOffset();
 #ifdef __DEMAND_PAGING__
 		// NB change in behavior IF DATA PAGING IS ENABLED: TLocDrvRequest::RemoteDes() points
 		// to a TClientBuffer rather than the client's remote descriptor
 #ifdef __DEMAND_PAGING__
 		// If this is a ROM/Code paging media, pin writes
 		// If there is a Data paging media registered, pin all requests with descriptors
 		if ( (DataPagingDeviceRegistered) || (reqId == DLocalDrive::EWrite && RomPagingDfcQ(this)) )
+		    {
 			r = PinSendReceive(aReq, (TLinAddr) linAddress);
+		    }
 		else
 #endif	// __DEMAND_PAGING__
 			r = SendReceive(aReq, (TLinAddr) linAddress);
 		}
 	else
 		{
 		// If no DFC queue, must be a fixed media device
 		// Media driver must already have been opened
 		// Assume no non-primary media exist on this device
 		// Just pass request straight through to media driver
 		r = aReq.CheckAndAdjustForPartition();
 		if (r == KErrNone)
 			r = iDriver->Request(aReq);
 		}
 #ifdef __DEMAND_PAGING__
 		// NB change in behavior IF DATA PAGING IS ENABLED: TLocDrvRequest::RemoteDes() points
 		// to a TClientBuffer rather than the client's remote descriptor
 	if (reqId == DLocalDrive::ERead && DataPagingDeviceRegistered && r == KErrNone)
 		{
 		r = clientBuffer.UpdateDescriptorLength(pT);
 		}
 #endif
+	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_REQUEST_EXIT4, this, r );
 	return r;
 	}
 #ifdef __DEMAND_PAGING__
 TInt DPrimaryMediaBase::PinSendReceive(TLocDrvRequest& aReq, TLinAddr aLinAddress)
 	{
+OstTraceExt2(TRACE_FLOW, DPRIMARYMEDIABASE_PINSENDRECEIVE_ENTRY, "> DPrimaryMediaBase::PinSendReceive;aReq=%x;aLinAddress=%x;", (TUint) &aReq, (TUint) &aLinAddress );
 	__ASSERT_DEBUG(ThePinObjectAllocator, LOCM_FAULT());
 	TInt msgId = aReq.Id();
+	TInt r;
 	switch(msgId)
 		{
 		case DLocalDrive::EControlIO:
 			{
 					// ControlIo is not supported if either of the two bare (TAny*) pointers are non-NULL
 					// as it's not possible to determine what the pointers are pointing at...
 					if (aReq.Int1() || aReq.Int2())
 						{
 						__KTRACE_OPT(KDATAPAGEWARN, Kern::Printf("Data paging: Naked EControlIO not supported on paging device: fn=%x", aReq.Int0()));
-						return KErrNotSupported;
+						r = KErrNotSupported;
+						break;
 						}
 					// fall into...
 				case 0:
-					return SendReceive(aReq);
+					r = SendReceive(aReq);
+					break;
 				default:
 					// if Int3() is > 0, Int1() is a data pointer, and Int3() is a length
 					if (controlIoType > (TInt) ThePinObjectAllocator->iFragmentGranularity)
-						return KErrTooBig;
+					    {
+						r = KErrTooBig;
+						break;
+					    }
 					if (controlIoType < 0)
-						return KErrArgument;
+					    {
-					return PinFragmentSendReceive(aReq, (TLinAddr) aReq.Ptr1(), controlIoType);
+						r = KErrArgument;
+						break;
+					    }
+					r = PinFragmentSendReceive(aReq, (TLinAddr) aReq.Ptr1(), controlIoType);
+					break;
 				}
+			break;
 			}
 		case DLocalDrive::ERead:
 		case DLocalDrive::EWrite:
 			{
-			return PinFragmentSendReceive(aReq, aLinAddress, aReq.Length());
+			r = PinFragmentSendReceive(aReq, aLinAddress, aReq.Length());
+			break;
 			}
 		// For all these requests, aReq.RemoteDes() points to a buffer on the stack in DLocalDrive::Request()
 		// This is a kernel stack & so should be unpaged & not require pinning...
 		case DLocalDrive::ECaps:
 		case DLocalDrive::EWritePasswordStore:
 		case DLocalDrive::EPasswordStoreLengthInBytes:
 		case DLocalDrive::EPasswordErase:
 		default:
-			return SendReceive(aReq);
+			r = SendReceive(aReq);
 		}
+	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_PINSENDRECEIVE_EXIT, this, r );
+	return r;
 	}
 TInt DPrimaryMediaBase::PinFragmentSendReceive(TLocDrvRequest& aReq, TLinAddr aLinAddress, TInt aLength)
 	{
+	OstTraceExt3(TRACE_FLOW, DPRIMARYMEDIABASE_PINFRAGMENTSENDRECEIVE_ENTRY, "> DPrimaryMediaBase::PinFragmentSendReceive;aReq=%x;aLinAddress=%x;aLength=%d;", (TUint) &aReq, (TUint) &aLinAddress, aLength );
 	TLocDrvRequest fragment = aReq;		// create a request on the stack for use during fragmentation, pre-fill with the original req args, leave original Kernel message as repository (thread will block, message contents won't change)
 	TInt r = KErrNone;
 //	Kern::Printf(">PFSR %02X aReq %08X aLinAddress %08X aLen %08X offset %08X", aReq.Id(), &aReq, aLinAddress, aLength, aReq.RemoteDesOffset());
 	if (!pT)
 		pT=&Kern::CurrentThread();	// e.g. when using TBusLocalDrive directly
 	__KTRACE_OPT2(KLOCDPAGING,KLOCDRV,Kern::Printf("Fragmenting Read/Write Request(0x%08x) on drive(%d), remote des(0x%x), offset into des(0x%x), original req Length(0x%x)",&aReq,aReq.Drive()->iDriveNumber,(TInt)(aReq.RemoteDes()),aReq.RemoteDesOffset(),aLength));
 	__KTRACE_OPT(KLOCDPAGING,Kern::Printf("Remote thread(0x%08x), current thread(0x%08x), start of data to write(0x%08x)",aReq.RemoteThread(),&Kern::CurrentThread(),(TInt)aLinAddress));
+	OstTraceDefExt5(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_PINFRAGMENTSENDRECEIVE1, "Fragmenting Read/Write Request=0x%08x; drive=%d; remote des=0x%x; offset into des=0x%x; original length=0x%x", (TUint) &aReq, (TUint) aReq.Drive()->iDriveNumber, (TInt) (aReq.RemoteDes()), (TInt) aReq.RemoteDesOffset(), (TInt) aLength );
+	OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_PINFRAGMENTSENDRECEIVE2, "Remote Thread=0x%08x; current Thread=0x%x; start of data to write=0x%08x", (TUint) aReq.RemoteThread(), (TUint) &Kern::CurrentThread(),(TUint)aLinAddress );
 	// don't want this thread to be terminated until last fragment is sent to MD and mem can be free'd up
 	NKern::ThreadEnterCS();
 	__ASSERT_DEBUG(ThePinObjectAllocator, LOCM_FAULT());
 			// otherwise (dataLockResult > 0) release it after calling SendReceive()
 			if (dataLockResult <= 0)
 				ThePinObjectAllocator->PreAllocatedDataLock().UnlockFragmentation();
 #ifdef __DEBUG_DEMAND_PAGING__
 				if (dataLockResult < 0)
 					Kern::Printf("DFragmentationPagingLock::Lock() %d", dataLockResult);
 #endif
 			if (dataLockResult < 0)	// if lock returned an error then give up
 				{
 				r = dataLockResult;
 		fragment.RemoteDesOffset() = aReq.RemoteDesOffset() + pos;
 		fragment.Pos() = aReq.Pos() + pos;
 		fragment.Flags() = aReq.Flags();
 		__KTRACE_OPT2(KLOCDPAGING,KLOCDRV,Kern::Printf("Send fragment (0x%08x) type(%d), length(0x%x), offset within original req(0x%x), pos in media(0x%lx)",&fragment,fragment.Id(), pinnedLen, pos, fragment.Pos()));
+		OstTraceDefExt5(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_PINFRAGMENTSENDRECEIVE3, "Send fragment 0x%08x; type=%d; length=0x%x; offset within original req=0x%x; position in media=0x%lx", (TUint) &fragment, (TInt) fragment.Id(), (TUint) pinnedLen, (TUint) pos, (TUint) fragment.Pos());
 #ifdef BTRACE_PAGING_MEDIA
 		TInt buf[4];
 		buf[0] = pinnedLen;	// fragment length
 		buf[1] = pos;		// offset within original request
 		buf[2] = fragment.Pos(); // offset in media
 		buf[3] = (TInt)&pT->iNThread;	// thread that issued the original write req
 		BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedFragmentBegin,&fragment,fragment.Id(),buf,sizeof(buf));
 #endif
 		r = SendReceive(fragment, aLinAddress);	// only come back here when message (fragment) has been completed
 		// unpin memory
 		if (pinDataObject)
 			{
 			Kern::UnpinVirtualMemory(pinDataObject->iObject);
 			ThePinObjectAllocator->ReleasePinObject(pinDataObject);
 	NKern::ThreadLeaveCS();
 //	Kern::Printf("<PFSR %02X aReq %08X aLinAddress %08X aLen %08X offset %08X", aReq.Id(), &aReq, aLinAddress, aLength, aReq.RemoteDesOffset());
+	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_PINFRAGMENTSENDRECEIVE_EXIT, this, r );
 	return r;
 	}
 #endif	// __DEMAND_PAGING__
 *
 * @see TLocDrvRequest::SendReceive()
 * @see DDmaHelper::SendReceive()
 */
 	{
+	OstTraceExt2( TRACE_FLOW, DPRIMARYMEDIABASE_SENDRECEIVE_ENTRY, "> DPrimaryMediaBase::SendReceive;aReq=%x;aLinAddress=%x", (TUint) &aReq, (TUint) &aLinAddress );
 	DDmaHelper* dmaHelper = aReq.Drive()->iDmaHelper;
 #ifdef __DEMAND_PAGING__
 	RequestCountInc();
 #endif
 	TInt r;
 	if (dmaHelper)
 		r = dmaHelper->SendReceive(aReq, aLinAddress);
 	else
+	    {
 		r = aReq.SendReceive(&iMsgQ);
+	    }
 #ifdef __DEMAND_PAGING__
 	RequestCountDec();
 #endif
+	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_SENDRECEIVE_EXIT, this, r );
 	return r;
 	}
 @param aRequest Encapsulates the request information received from the client
 @see TLocDrvRequest
 */
 	{
+	OstTrace1( TRACE_FLOW, DPRIMARYMEDIABASE_HANDLEMSG_ENTRY, "> DPrimaryMediaBase::HandleMsg;m=%x;", (TUint) &m);
 	switch (m.iValue)
 		{
 		case EConnect:
 			{
 			DLocalDrive* pD=(DLocalDrive*)m.Ptr0();
 			iConnectionQ.Add(&pD->iLink);
 			m.Complete(KErrNone, EFalse);
+			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT1, this );
 			return;
 			}
 		case EDisconnect:
 			{
 			DLocalDrive* pD=(DLocalDrive*)m.Ptr0();
 			else
 				{
 				pD->Deque();
 				m.Complete(KErrNone, EFalse);
 				}
+			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT2, this );
 			return;
 			}
 		case DLocalDrive::EForceMediaChange:
 			{
 			TUint flags = (TUint) m.Pos();
 				{
 				TInt sock;
 				if (!IsRemovableDevice(sock))
 					{
 					CompleteRequest(m, KErrNotSupported);
+					OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT3, this );
 					return;
 					}
 				// wait for power up and then call DPrimaryMediaBase::DoRequest()
 				break;
 				}
 				{
 				if (r==KErrNotSupported || r==KErrCompletion)
 					r=KErrNone;
 				CompleteRequest(m, r);
 				}
+			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT4, this );
 			return;
 			}
 		case DLocalDrive::ECaps:
 			if (iState==EPoweredDown)
 				{
 				// The media is powered down, but the media driver still exists.
 				//  - Issue the ECaps request without powering the media back up.
 				DoRequest(m);
 				__TRACE_TIMING(0x101);
+				OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT5, this );
 				return;
 				}
 			break;
 		case DLocalDrive::ERead:
 			{
 			DLocalDrive* pD=(DLocalDrive*)m.Ptr0();
 			TLocDrv* pL=pD->iDrive;
 			*((TErrorInfo*) m.RemoteDes()) = pL->iLastErrorInfo;
 			CompleteRequest(m, KErrNone);
+			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT6, this );
 			return;
 			}
 		case DLocalDrive::EReadPasswordStore:
 			{
 			TPtr8 pswData ((TUint8*) m.RemoteDes(), (TInt) m.Length());
 			TInt r = ThePasswordStore->ReadPasswordData(pswData);
 			m.Length() = pswData.Length();
 			CompleteRequest(m, r);
+			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT7, this );
 			return;
 			}
 		case DLocalDrive::EWritePasswordStore:
 			{
 			TPtrC8 pData((TUint8*) m.RemoteDes(), (TInt) m.Length());
 			TInt r = ThePasswordStore->WritePasswordData(pData);
 			if(r != KErrNone)
 				{
 				CompleteRequest(m, r);
+				OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT8, this );
 				return;
 				}
 			r = QuickCheckStatus();
 			if(r != KErrNone)
 				{
 				// Don't try to power up the device if it's not ready.
 				// - Note that this isn't an error that needs to be returned to the client.
 				CompleteRequest(m, KErrNone);
+				OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT9, this );
 				return;
 				}
 			break;
 			}
 		case DLocalDrive::EPasswordStoreLengthInBytes:
 			{
 			TInt length = ThePasswordStore->PasswordStoreLengthInBytes();
 			*(TInt*) m.RemoteDes() = length;
 			CompleteRequest(m, KErrNone);
+			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT10, this );
 			return;
 			}
 		default:
 			CHECK_RET(KErrNotSupported);
 			CompleteRequest(m, KErrNotSupported);
+			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT11, this );
 			return;
 		}
 	__KTRACE_OPT(KFAIL,Kern::Printf("mdrq %d",m.Id()));
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::HandleMsg state %d req %d",iMediaId,iState,m.Id()));
+	OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DPRIMARYMEDIABASE_HANDLEMSG2, "iMediaId=%d; iState=%d; req Id=%d", iMediaId, iState, m.Id());
 	// if media driver already open, pass request through
 	if (iState==EReady)
 		{
 		DoRequest(m);
 		__TRACE_TIMING(0x101);
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT12, this );
 		return;
 		}
 	// if open or close in progress, defer this message
 	if (iState!=EClosed && iState!=EPoweredDown)
 			__ASSERT_ALWAYS(iPagingMedia,LOCM_FAULT());
 			__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
 			__ASSERT_ALWAYS( ((m.Flags() & TLocDrvRequest::ECodePaging) == 0) || (m.Drive()->iPagingDrv), LOCM_FAULT());
 			__KTRACE_OPT2(KLOCDPAGING,KLOCDRV,Kern::Printf("Deferring PageIn request 0x%08x because opening or closing",&m));
+			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_HANDLEMSG3, "Deferring PageIn request 0x%08x because opening or closing", &m);
 			iBody->iPagingDevice->SendToDeferredQ(&m);
 			}
 		else
 #endif
 		m.Forward(&iDeferred,EFalse);
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT13, this );
 		return;
 		}
 	// nothing is open, so try to open something
 	__ASSERT_ALWAYS(!iCurrentReq,LOCM_FAULT());
 	if (DMediaPagingDevice::PagingRequest(m))
 		{
 		__ASSERT_DEBUG(iPagingMedia,LOCM_FAULT());
 		__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
 		__KTRACE_OPT(KLOCDPAGING,Kern::Printf("Page request 0x%08x received -> opening MD",&m));
+		OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_HANDLEMSG4, "Page request 0x%08x received; opening MD", &m);
 		}
 #endif	// _DEBUG
 #endif	// __DEMAND_PAGING__
 	TInt r=InitiatePowerUp();
 	if (r==KErrNone || r==KErrServerBusy)
 		{
 		// wait for completion of power up request
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT14, this );
 		return;
 		}
 	if (r==KErrCompletion)
 		r=KErrNone;		// device already powered up
 	PowerUpComplete(r);
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT15, this );
 	}
 EXPORT_C TInt DPrimaryMediaBase::DoRequest(TLocDrvRequest& m)
 /**
 If the media exists, it tries to get the partition information if not there.
 	KErrBadDescriptor, if request encapsulates a bad descriptor
 	Otherwise, one of the other system wide error codes.
 */
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_DOREQUEST_ENTRY, this );
 	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("DPrimaryMediaBase::DoRequest %d",m.Id()));
 	TLocDrv* pL=m.Drive();
 	DMedia* media=pL->iMedia;
 	TInt r=KErrNone;
+	OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DPRIMARYMEDIABASE_DOREQUEST, "req Id=%d; length=0x%x; position=0x%x", (TInt) m.Id(), (TInt) m.Length(), (TInt) m.Pos());
 	// re-open this drive's media driver ?
 	if (m.iValue == DLocalDrive::EForceMediaChange)
 		{
 		__ASSERT_DEBUG(((TUint) m.Pos()) == (TUint) KForceMediaChangeReOpenMediaDriver, LOCM_FAULT());
 		iState=EOpening;
 		StartOpenMediaDrivers();
 		NotifyClients(ETrue,pL);
 		CompleteRequest(m, r);
+		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_DOREQUEST_EXIT, this, r );
 		return r;
 		}
 	if (!media || !media->iDriver || iState == EClosed)
 		{
 	if (r==KErrNone)
 		{
 		if(iTotalPartitionsOpened == 0)
 			{
 			UpdatePartitionInfo();
+			OstTraceFunctionExitExt( DPRIMARYMEDIABASE_DOREQUEST_EXIT2, this, KErrNone );
 			return KErrNone;
 			}
 		if (!(m.Flags() & TLocDrvRequest::EAdjusted))
 			{
 			// If this isn't the only partition, don't allow access to the whole media
 				m.DriverFlags() &= ~RLocalDrive::ELocDrvWholeMedia;
 			r=m.CheckAndAdjustForPartition();
 			}
 		if (r==KErrNone)
 			{
+			OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_INTERNALS, DPRIMARYMEDIABASE_DOREQUEST_START, "req Id=%d; Remote Thread=0x%x", (TInt) m.Id(), (TUint) m.RemoteThread());
 			r=media->iDriver->Request(m);
 			if (r>0)
 				{
 				// defer request
 #ifdef __DEMAND_PAGING__
 					{
 					__ASSERT_ALWAYS(iPagingMedia,LOCM_FAULT());
 					__ASSERT_ALWAYS( ((m.Flags() & TLocDrvRequest::ECodePaging) == 0) || (m.Drive()->iPagingDrv), LOCM_FAULT());
 					__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
 					__KTRACE_OPT2(KLOCDPAGING,KLOCDRV,Kern::Printf("Defer PageIn request 0x%08x",&m));
+					OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_DOREQUEST2, "Defer PageIn request 0x%08x", &m);
 					DMediaPagingDevice* pagingdevice=iBody->iPagingDevice;
 #ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
 					TInt id=m.iValue;
 					if (id==DMediaPagingDevice::ERomPageInRequest)
 					m.Forward(&iDeferred,EFalse);
 				r=KErrNone;
 				}
 #if defined(__DEMAND_PAGING__) && defined(_DEBUG)
 			else if (r == KErrNone && DMediaPagingDevice::PagingRequest(m))
+			    {
 				__KTRACE_OPT(KLOCDPAGING,Kern::Printf("PageIn req 0x%08x completing asynchronously",&m));
+OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_DOREQUEST3, "PageIn req 0x%08x completing asynchronously", &m);
+			    }
 #endif
 			}
 		}
 	if (r!=KErrNone && iCurrentReq)
 			{
 			__ASSERT_ALWAYS(iPagingMedia,LOCM_FAULT());
 			__ASSERT_ALWAYS( ((m.Flags() & TLocDrvRequest::ECodePaging) == 0) || (m.Drive()->iPagingDrv), LOCM_FAULT());
 			__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
 			__KTRACE_OPT(KLOCDPAGING,Kern::Printf("media driver cannot service or defer PageIn request 0x%08x or serviced it synchronously (%d)",&m, s));
+			OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_DOREQUEST4, "Media driver cannot service or defer PageIn request 0x%08x or serviced it synchronously; retval=%d",(TUint) &m, s);
 			iBody->iPagingDevice->CompleteRequest(&m, s);
 			}
 		else
 #endif
 		CompleteRequest(m, s);
+		OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_INTERNALS, DPRIMARYMEDIABASE_DOREQUEST_RETURN, "Return req Id=%d; Remote Thread=0x%x; retval=%d", (TInt) m.Id(), (TUint) m.RemoteThread(), (TInt) s);
 		}
 	iCurrentReq=NULL;
+	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_DOREQUEST_EXIT3, this, r );
 	return r;
 	}
 EXPORT_C void DPrimaryMediaBase::PowerUpComplete(TInt anError)
 /**
 and if they are already open then it handles the current/pending requests.
 @param anError Error code to be passed on while completing outstanding requests.
 */
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_POWERUPCOMPLETE_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf(">DPrimaryMediaBase(%d)::PowerUpComplete err %d iState %d",iMediaId,anError,iState));
+	OstTraceExt3( TRACE_INTERNALS, DPRIMARYMEDIABASE_POWERUPCOMPLETE, "iMediaId=%d; anError=%d; iState=%d", iMediaId, anError, iState );
 	if (anError!=KErrNone)
 		{
 		// error powering up device
 		if (iState==EPoweringUp1 || iState==EPoweringUp2)
 			SetClosed(anError);
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_POWERUPCOMPLETE_EXIT, this );
 		return;
 		}
 	// Powered up OK - now open media drivers
 	if (iState==EPoweringUp1)
 	else if (iState==EPoweringUp2)
 		{
 		// media is powered up and ready, so handle the current/pending requests
 		MediaReadyHandleRequest();
 		}
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_POWERUPCOMPLETE_EXIT2, this );
 	}
 void DPrimaryMediaBase::CloseMediaDrivers(DMedia* aMedia)
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf(">DPrimaryMediaBase(%d)::CloseMediaDrivers",iMediaId));
+	OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS1, "DPrimaryMediaBase iMediaId=%d", iMediaId );
 	// we mustn't ever close the media driver if it's responsible for data paging as re-opening the drive
 	// would involve memory allocation which might cause deadlock if the kernel heap were to grow
 #ifdef __DEMAND_PAGING__
 	if (DataPagingDfcQ(this))
 		{
 		__KTRACE_OPT(KLOCDRV,Kern::Printf("CloseMediaDrivers aborting for data paging media %08X", this));
+		OstTrace1(TRACE_FLOW, DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS_EXIT1, "CloseMediaDrivers aborting for data paging media 0x%08x", this);
 		return;
 		}
 #endif
 	TInt i;
 		{
 		TLocDrv* pL=TheDrives[i];
 		if (pL && pL->iPrimaryMedia==this)
 			{
 			__KTRACE_OPT(KLOCDRV,Kern::Printf("Drive %d",i));
+			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS2, "Drive=%d", i );
 			if (aMedia == NULL || pL->iMedia == aMedia)
 				{
 				pL->iMedia=NULL;
 				}
 			}
 		if (aMedia == NULL || pM == aMedia)
 			{
 			DMediaDriver* pD=pM->iDriver;
 			pM->iDriver=NULL;
 			__KTRACE_OPT(KLOCDRV,Kern::Printf("DMedia[%d] @ %08x Driver @ %08x",i,pM,pD));
+			OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS3, "MediaId=%d; DMedia=0x%08x; MediaDriver=0x%08x", (TInt) i, (TUint) pM, (TUint) pD );
 			if (pD)
 				pD->Close();
 			}
 		}
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("<DPrimaryMediaBase(%d)::CloseMediaDrivers",iMediaId));
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS_EXIT2, this );
 	}
 void DPrimaryMediaBase::StartOpenMediaDrivers()
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_STARTOPENMEDIADRIVERS_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::StartOpenMediaDrivers",iMediaId));
+	OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_STARTOPENMEDIADRIVERS, "DPrimaryMediaBase iMediaId=%d ",iMediaId);
 	TVersion ver(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);
 	// Get a list of all currently loaded media drivers
 	// Most media drivers do not make use of the pointer iMountInfo.iInfo when
 	// their Validate() procedures are called from RPhysicalDeviceArray::GetDriverList().
 	TInt r=iPhysDevArray.GetDriverList(KLitMediaDriverName,iDevice,iMountInfo.iInfo,ver);
 	if (r!=KErrNone)
 		{
 		// out of memory or no driver exists
 		SetClosed(r);
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_STARTOPENMEDIADRIVERS_EXIT1, this );
 		return;
 		}
 	// Go through them starting with highest priority
 	iNextMediaId=iMediaId;
 	iBody->iPhysDevIndex=iPhysDevArray.Count()-1;
 	iTotalPartitionsOpened=0;
 	iMediaDriversOpened=0;
 	iNextMediaDriver=NULL;
 	OpenNextMediaDriver();
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_STARTOPENMEDIADRIVERS_EXIT2, this );
 	}
 void DPrimaryMediaBase::OpenNextMediaDriver()
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_OPENNEXTMEDIADRIVER_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::OpenNextMediaDriver, this %x mediaId %d iBody->iPhysDevIndex %d",iNextMediaId, this, iMediaId, iBody->iPhysDevIndex));
+	OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_OPENNEXTMEDIADRIVER, "DPrimaryMediaBase iNextMediaId=%d; this=%x; imediaId=%d; iBody->iPhysDevIndex=%d",iNextMediaId, (TUint) this, iMediaId, iBody->iPhysDevIndex);
 	TVersion ver(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);
 	SPhysicalDeviceEntry& e=iPhysDevArray[iBody->iPhysDevIndex];
 	DPhysicalDevice* pD=e.iPhysicalDevice;
 	iState = EOpening;
 	DMedia* pM=TheMedia[iNextMediaId];
 	if (pM && pM->iDriver != NULL)
 		{
 		iNextMediaDriver = pM->iDriver;
 		DoOpenMediaDriverComplete(KErrNone);
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_OPENNEXTMEDIADRIVER_EXIT1, this );
 		return;
 		}
 	// this may be asynchronous
 	TInt s=pD->Create( (DBase*&)iNextMediaDriver, iMediaId,  (TDesC8*) &iMountInfo, ver);
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("Media:Open-Opening %o(PRI:%d)-%d",pD,e.iPriority,s));
 	if (s!=KErrNone)
 		{
 		iAsyncErrorCode=s;
 		iAsyncDfc.Enque();
 		}
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_OPENNEXTMEDIADRIVER_EXIT2, this );
 	}
 // Called when a media driver has responded to the Open request
 void DPrimaryMediaBase::DoOpenMediaDriverComplete(TInt anError)
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_DOOPENMEDIADRIVERCOMPLETE_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::DoOpenMediaDriverComplete error %d iNextMediaDriver %x",iNextMediaId,anError,iNextMediaDriver));
+OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_DOOPENMEDIADRIVERCOMPLETE, "iMediaId=%d; anError=%d; iNextMediaDriver=0x%x", (TInt) iNextMediaId, (TInt) anError, (TUint) iNextMediaDriver);
 	if (anError!=KErrNone)
 		{
 		DMediaDriver* md = iNextMediaDriver;
 		iNextMediaDriver = NULL;
 		if (md)
 	if (anError==KErrNotReady || anError==KErrNoMemory)
 		{
 		// if it's not ready or we're out of memory, abort
 		CloseMediaDrivers();
 		SetClosed(anError);
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOOPENMEDIADRIVERCOMPLETE_EXIT1, this );
 		return;
 		}
 	if (anError==KErrNone)
 		{
 		DMedia* pM=TheMedia[iNextMediaId];
 		iNextMediaDriver->iPhysicalDevice=pD;
 		pD=NULL;	// so it won't be closed when we tidy up
 		++iMediaDriversOpened;
 		}
 	// if no error, read partition info on media
 	iState = EReadPartitionInfo;
 	if (anError == KErrNone)
 		{
 		}
 	else
 		{
 		DoPartitionInfoComplete(anError);
 		}
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOOPENMEDIADRIVERCOMPLETE_EXIT2, this );
 	}
 void DPrimaryMediaBase::DoPartitionInfoComplete(TInt anError)
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::DoPartitionInfoComplete error %d",iNextMediaId,anError));
+	OstTraceExt2( TRACE_INTERNALS, DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE1, "iNextMediaId=%d; anError=%d", iNextMediaId, anError );
 	DMedia* pM=TheMedia[iNextMediaId];
 	if (anError==KErrNone || anError == KErrLocked)
 		{
 		// successfully read partition info
 		iTotalPartitionsOpened+=pM->PartitionCount();
 			{
 #ifdef __DEMAND_PAGING__
 			if (DataPagingDfcQ(this))
 				{
 				__KTRACE_OPT(KLOCDRV,Kern::Printf("DoPartitionInfoComplete(%d) Close Media Driver aborted for data paging media %08X", this));
+				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE2, "Close Media Driver for data paging media 0x%08x", this);
 				}
 			else
 #endif
 				{
 				pM->iDriver->Close();
 		if (anError==KErrNotReady || anError==KErrNoMemory)
 			{
 			// if it's not ready or we're out of memory, or the drive is locked, abort
 			CloseMediaDrivers();
 			SetClosed(anError);
+			OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_EXIT, this );
 			return;
 			}
 		}
 	// Open next media driver, if there is one
 	else
 		iBody->iPhysDevIndex--;
 	if (!complete)
 		{
 		OpenNextMediaDriver();
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_EXIT2, this );
 		return;
 		}
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase %d All media drivers open & partitions read",iMediaId));
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("%d media drivers opened",iMediaDriversOpened));
+	OstTrace1( TRACE_INTERNALS, DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE3, "iMediaDriversOpened=%d", iMediaDriversOpened );
 	if (iMediaDriversOpened==0)
 		{
 		SetClosed(KErrNotSupported);
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_EXIT3, this );
 		return;
 		}
 	// we are now finished with media driver list
 	iPhysDevArray.Close();
 	// Finished reading partition info
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase %d Read partition info complete",iMediaId));
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("%d total partitions",iTotalPartitionsOpened));
+	OstTraceExt2( TRACE_INTERNALS, DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE4, "Read partition info complete iMediaId=%d; iPartitionsOpened=%d", iMediaId, iTotalPartitionsOpened );
 	if (iTotalPartitionsOpened==0)
 		{
 		SetClosed(KErrNotSupported);
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_EXIT4, this );
 		return;
 		}
 	// work out mapping of drives to partitions/media
 	TInt totalPartitions=iTotalPartitionsOpened;
 	TInt id=iMediaId;	// start with primary media
 	TInt partitionsOnThisMedia=PartitionCount();
 	TInt partition=0;
 				id++;
 				partition=0;
 				partitionsOnThisMedia=TheMedia[id]->PartitionCount();
 				}
 			__KTRACE_OPT(KLOCDRV,Kern::Printf("Drive %d = Media %d Partition %d",j,id,partition));
+			OstTraceExt3( TRACE_INTERNALS, DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE5, "Local Drive=%d; iMediaId=%d; partition=%d", j, id, partition );
 			pD->iMedia=TheMedia[id];
 			pD->iPartitionNumber=partition;
 			memcpy(pD, pD->iMedia->iPartitionInfo.iEntry+partition, sizeof(TPartitionEntry));
 			partition++;
 			totalPartitions--;
 			}
 		}
 	// media is now ready - handle current or deferred requests
 	MediaReadyHandleRequest();
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_EXIT5, this );
 	}
 void DPrimaryMediaBase::MediaReadyHandleRequest()
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_MEDIAREADYHANDLEREQUEST_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase::MediaReadyHandleRequest() this %x", this));
 	iState = EReady;
 	// now we can process the current request
 	// careful - thread may have exited while we were powering up
 		DoRequest(*iCurrentReq);	// this sets iCurrentReq=NULL
 		}
 	// see if we can process any other requests concurrently
 	RunDeferred();
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_MEDIAREADYHANDLEREQUEST_EXIT, this );
 	}
 void DPrimaryMediaBase::UpdatePartitionInfo()
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_UPDATEPARTITIONINFO_ENTRY, this );
 	iState=EReadPartitionInfo;
 	iNextMediaId=iMediaId;
 	DMedia* pM=TheMedia[iNextMediaId];
 	TInt r=pM->iDriver->PartitionInfo(pM->iPartitionInfo);
 	if (r!=KErrNone)
 		{
 		if (r==KErrCompletion)
 			r=KErrNone;
 		DoPartitionInfoComplete(r);
 		}
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_UPDATEPARTITIONINFO_EXIT, this );
 	}
 void DPrimaryMediaBase::CompleteCurrent(TInt anError)
 	{
+	OstTraceFunctionEntryExt( DPRIMARYMEDIABASE_COMPLETECURRENT_ENTRY, this );
 	if (iCurrentReq)
 		{
 		CHECK_RET(anError);
 #ifdef __DEMAND_PAGING__
 		// got here because it was powered down when powering up, or failed powering up or failed opening MD or got media change
 			__ASSERT_ALWAYS(iPagingMedia,LOCM_FAULT());
 			__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
 			__ASSERT_ALWAYS( ((iCurrentReq->Flags() & TLocDrvRequest::ECodePaging) == 0) || (iCurrentReq->Drive()->iPagingDrv), LOCM_FAULT());
 			__KTRACE_OPT2(KLOCDPAGING,KFAIL,Kern::Printf("Got here because it was powered down when powering up, or failed powering up or failed opening MD or got media change"));
+			OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_COMPLETECURRENT, "Completed request due to powered down when powering up, or failed powering up or failed opening MD or got media change");
 			iBody->iPagingDevice->CompleteRequest(iCurrentReq, anError);
 			}
 		else
 #endif
 		CompleteRequest(*iCurrentReq, anError);
 		iCurrentReq=NULL;
 		}
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_COMPLETECURRENT_EXIT, this );
 	}
 void DPrimaryMediaBase::CompleteRequest(TLocDrvRequest& aMsg, TInt aResult)
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_COMPLETEREQUEST_ENTRY, this );
+	OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DPRIMARYMEDIABASE_COMPLETEREQUEST1, "TLocDrvRequest Object=0x%x; aResult=%d", (TUint) &aMsg, aResult);
 	aMsg.Complete(aResult,EFalse);
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_COMPLETEREQUEST_EXIT, this );
 	}
 EXPORT_C void DPrimaryMediaBase::RunDeferred()
 /**
 Runs deferred Requests. Initiated from DPrimaryMediaBase::PowerUpComplete() function
 to see if any other requests can be processed concurrently.
 Can also be called from DPrimaryMediaBase::NotifyPowerDown
 or DPrimaryMediaBase::NotifyEmergencyPowerDown() function or DMediaDriver::Complete()
 */
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_RUNDEFERRED_ENTRY, this );
 	// Do nothing if an open or close is in progress - this might be the case, for example,
 	// if a EForceMediaChange request (with the  KForceMediaChangeReOpenMediaDriver flag)
 	// has recently been processed
 	if (iState!=EReady && iState!=EClosed && iState!=EPoweredDown)
+	    {
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_RUNDEFERRED_EXIT1, this );
 		return;
+	    }
 	// rerun deferred requests;
 #ifdef __DEMAND_PAGING__
 #ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
 	TInt countROM=0;
 	TInt countCode=0;
 		{
 		__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
 		if(iBody->iPagingDevice->iEmptyingQ & DMediaPagingDevice::EDeferredQ)		// if already emptying deferred page in queue, don't reenter
 			{
 			__KTRACE_OPT(KLOCDPAGING,Kern::Printf("Already emptying deferred queue"));
+			OstTrace0(TRACE_FLOW, DPRIMARYMEDIABASE_RUNDEFERRED_EXIT2, "< Already emptying deferred queue");
 			return;
 			}
 		DMediaPagingDevice* pagingdevice=iBody->iPagingDevice;
 		TLocDrvRequest* pL = (TLocDrvRequest*) pagingdevice->iDeferredQ.Last();
 							pagingdevice->iDataStats.iMaxReqsInDeferred=countCode;
 					NKern::FMSignal(&pagingdevice->iInstrumentationLock);
 					}
 #endif
 				__KTRACE_OPT(KLOCDPAGING,Kern::Printf("RunDeferred: process req 0x%08x, last in deferred queue 0x%08x",pM,pL));
+				OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_RUNDEFERRED2, "process req=0x%08x; last in deferred queue=0x%08x",(TUint) pM, (TUint) pL);
 #ifdef BTRACE_PAGING_MEDIA
 				BTraceContext8(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageInDeferredReposted,pM,pM->iValue);
 #endif
 				// if Page In requests are synchronous this services them all in sequence,
 				// if they're asynch it re-defers them
 		// all requests synchronously, but runs background tasks that cannot be interrupted. In this last case the
 		// normal deferred queue may have some very long latency requests.
 		if(pagingdevice->iEmptyingQ & DMediaPagingDevice::EMainQ)	// already emptying main Page In queue, skip (any Page In requests will be deferred)
 			{
 			__KTRACE_OPT(KLOCDPAGING,Kern::Printf("Already emptying main queue"));
+			OstTrace0(TRACE_FLOW, DPRIMARYMEDIABASE_RUNDEFERRED_EXIT3, "< Already emptying main queue");
 			return;
 			}
 		TLocDrvRequest* pM=NULL;
 		if (!pagingdevice->iMainQ.iReady)	// if it's ready, then queue is empty
 #ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
 				(pM->iValue==DMediaPagingDevice::ERomPageInRequest)?(countROM++):(countCode++);
 #endif
 				__KTRACE_OPT(KLOCDPAGING,Kern::Printf("RunDeferred: process req 0x%08x",pM));
+				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_RUNDEFERRED4, "process req=0x%08x", pM);
 				DoRequest(*(TLocDrvRequest*)pM);	// if Page In requests are synchronous this services them all in sequence, if they're asynch it defers them
 				}
 			pagingdevice->iEmptyingQ&= ~DMediaPagingDevice::EMainQ;
 #endif
 			}	// if (pM)
 		}	// 	if(iPagingMedia)
 #endif
 	if (iRunningDeferred)
+	    {
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_RUNDEFERRED_EXIT4, this );
 		return;
+	    }
 	TMessageBase* pL = iDeferred.Last();
 	if (!pL)
+	    {
+		OstTraceFunctionExit1( DPRIMARYMEDIABASE_RUNDEFERRED_EXIT5, this );
 		return;	// no deferred requests
+	    }
 	iRunningDeferred=1;
 	TMessageBase* pM=NULL;
 	while( pM != pL && (pM=iDeferred.Poll()) != NULL)	// stop after processing last one (requests may be re-deferred)
 		DoRequest(*(TLocDrvRequest*)pM);
 	iRunningDeferred=0;
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_RUNDEFERRED_EXIT6, this );
 	}
 void DPrimaryMediaBase::SetClosed(TInt anError)
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_SETCLOSED_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::SetClosed error %d",iMediaId,anError));
+	OstTraceExt2( TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_SETCLOSED, "iMediaId=%d; anError=%d", iMediaId, anError );
 	CHECK_RET(anError);
 	// cancel DMediaDriver::OpenMediaDriverComplete() / DMediaDriver::PartitionInfoComplete() DFC
 	iAsyncDfc.Cancel();
 		iPhysDevArray.Close();
 	iState = EClosed;
 	iWaitMedChg.CompleteAll(KErrNone);
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_SETCLOSED_EXIT, this );
 	}
 void DPrimaryMediaBase::NotifyClients(TBool aMediaChange,TLocDrv* aLocDrv)
 //
 // Notify all clients of a media change or power-down event
 //
 	{
+	OstTraceFunctionEntryExt( DPRIMARYMEDIABASE_NOTIFYCLIENTS_ENTRY, this );
 	SDblQueLink* pL=iConnectionQ.iA.iNext;
 	while (pL!=&iConnectionQ.iA)
 		{
 		DLocalDrive* pD=_LOFF(pL,DLocalDrive,iLink);
 		// Issue the notification if the caller wants to notify all drives (aLocDrv == NULL) or
 		// the specified drive matches this one
 		if (aLocDrv == NULL || aLocDrv == pD->iDrive)
 			pD->NotifyChange(*this, aMediaChange);
 		pL=pL->iNext;
 		}
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYCLIENTS_EXIT, this );
 	}
 EXPORT_C void DPrimaryMediaBase::NotifyMediaChange()
 /**
 Closes all media drivers on this device and notifies all connections that media change has occurred
 and completes any outstanding requests with KErrNotReady.
 This also completes any force media change requests with KErrNone.
 */
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_NOTIFYMEDIACHANGE_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::NotifyMediaChange state %d",iMediaId,iState));
+	OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_NOTIFYMEDIACHANGE, "iMediaId=%d; iState=%d", iMediaId, iState );
 	TInt state=iState;
 	__ASSERT_DEBUG(iBody, LOCM_FAULT());
 #ifdef __DEMAND_PAGING__
 	// notify all connections that media change has occurred
 	NotifyClients(ETrue);
 	// complete any force media change requests
 	iWaitMedChg.CompleteAll(KErrNone);
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYMEDIACHANGE_EXIT, this );
 	}
 EXPORT_C void DPrimaryMediaBase::NotifyPowerDown()
 /**
 If device is not ready then it completes current requests but leaves other outstanding requests
 If ready, media driver should complete current request.
 */
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_NOTIFYPOWERDOWN_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::NotifyPowerDown state %d",iMediaId,iState));
+	OstTraceExt2( TRACE_INTERNALS, DPRIMARYMEDIABASE_NOTIFYPOWERDOWN, "iMediaId=%d; iState=%d", iMediaId, iState );
 	TInt id;
 	TBool allPersistent = ETrue;
 	TBool allOpen = ETrue;
 	 // notify all media drivers on this device
 			allPersistent = EFalse;
 			}
 		}
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("allPersistent(%d)::allOpen %d",allPersistent, allOpen));
+	OstTraceExt2( TRACE_INTERNALS, DPRIMARYMEDIABASE_NOTIFYPOWERDOWN2, "allPersistent=%d; allOpen=%d", allPersistent, allOpen );
 	if (allPersistent && allOpen && iState == EReady)
 		{
 		//
 		// The EPoweredDown state indicates that the media is powered down, but the media driver still exists.
 		CloseMediaDrivers();
 		SetClosed(KErrNotReady);
 		}
 	NotifyClients(EFalse);
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYPOWERDOWN_EXIT, this );
 	}
 EXPORT_C void DPrimaryMediaBase::NotifyPsuFault(TInt anError)
 /**
 Closes all media drivers on this device and completes any outstanding requests with error code.
 @param anError Error code to be passed on while closing media drivers and completing outstanding requests.
 */
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_NOTIFYPSUFAULT_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::NotifyPsuFault state %d, err %d",iMediaId,iState,anError));
+	OstTraceExt3( TRACE_INTERNALS, DPRIMARYMEDIABASE_NOTIFYPSUFAULT, "iMediaId=%d; iState=%d; anError=%d", iMediaId, iState, anError );
 	if (iState>=EOpening)
 		{
 		CloseMediaDrivers();
 		}
 	// complete any outstanding requests with error
 	SetClosed(anError);
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYPSUFAULT_EXIT, this );
 	}
 EXPORT_C void DPrimaryMediaBase::NotifyEmergencyPowerDown()
 /**
 Called on emergency power down. Notifies all media drivers on this device.
 If it is not in a ready state then it completes the current request but leaves other outstanding requests.
 If it is ready then the media driver should complete the current request.
 It closes all media drivers and notifies all clients of a power down event.
 */
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_NOTIFYEMERGENCYPOWERDOWN_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::NotifyEmergencyPowerDown state %d",iMediaId,iState));
+	OstTraceExt2( TRACE_INTERNALS, DPRIMARYMEDIABASE_NOTIFYEMERGENCYPOWERDOWN, "iMediaId=%d; iState=%d", iMediaId, iState );
 	TBool recover=EFalse;
 	if (iState==EReady && iCritical!=0)
 		{
 		// check if emergency power recovery supported
 		;
 		CompleteCurrent(KErrNotReady);
 		}
 	CloseMediaDrivers();
 	SetClosed(KErrNotReady);
 	NotifyClients(EFalse);
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYEMERGENCYPOWERDOWN_EXIT, this );
 	}
 EXPORT_C void DPrimaryMediaBase::NotifyMediaPresent()
 /**
 Notifies clients of a media change by calling NotifyClients ( ) function to indicate that media is present.
 */
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_NOTIFYMEDIAPRESENT_ENTRY, this );
 	NotifyClients(ETrue);
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYMEDIAPRESENT_EXIT, this );
 	}
 EXPORT_C TInt DPrimaryMediaBase::DoInCritical()
 /**
 Flags the media driver as entering a critical part of its processing.
 	{
 	}
 TInt DPrimaryMediaBase::InCritical()
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_INCRITICAL_ENTRY, this );
 	if (iCritical==0)
 		{
 		TInt r=DoInCritical();
 		if (r!=KErrNone)
+		    {
+			OstTraceFunctionExitExt( DPRIMARYMEDIABASE_INCRITICAL_EXIT1, this, r );
 			return r;
+		    }
 		}
 	++iCritical;
+	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_INCRITICAL_EXIT2, this, KErrNone );
 	return KErrNone;
 	}
 void DPrimaryMediaBase::EndInCritical()
 	{
+	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_ENDINCRITICAL_ENTRY, this );
 	if (--iCritical==0)
 		DoEndInCritical();
+	OstTraceFunctionExit1( DPRIMARYMEDIABASE_ENDINCRITICAL_EXIT, this );
 	}
 EXPORT_C void DPrimaryMediaBase::DeltaCurrentConsumption(TInt /*aCurrent*/)
 /**
 Sets the incremental value of current consumption to aCurrent.
 TInt DPrimaryMediaBase::OpenMediaDriver()
 //
 // Synchronous open for devices with no DFC queue (e.g. IRAM)
 //
 	{
+OstTraceFunctionEntry1( DPRIMARYMEDIABASE_OPENMEDIADRIVER_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf(">DPrimaryMediaBase:OpenMediaDriver-%d",iMediaId));
+	OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_OPENMEDIADRIVER1, "iMediaId=%d", iMediaId);
 	TVersion ver(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);
 	// Get a list of all currently loaded media drivers
 	// Most media drivers do not make use of the pointer iMountInfo.iInfo when
 	// their Validate() procedures are called from RPhysicalDeviceArray::GetDriverList().
 	// the additional information pointed to by iMountInfo.iInfo to distinguish
 	// group members. This information is passed when the media driver is registered
 	// using LocDrv::RegisterMediaDevice().
 	TInt r=iPhysDevArray.GetDriverList(KLitMediaDriverName,iDevice,iMountInfo.iInfo,ver);
 	if (r!=KErrNone)
+	    {
+		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_OPENMEDIADRIVER_EXIT1, this, r );
 		return r;
+	    }
 	// Go through them starting with highest priority
 	TInt totalPartitions=0;
 	TInt c=iPhysDevArray.Count();	// can't be zero
 	TInt i=c-1;
 	r=KErrNotSupported;
 		// try to open media driver
 		TInt s=pD->Create( (DBase*&)pM, iMediaId, NULL, ver);
 		__KTRACE_OPT(KLOCDRV,Kern::Printf("Media:Open-Opening %o(PRI:%d)-%d",pD,iPhysDevArray[i].iPriority,s));
+		OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_OPENMEDIADRIVER2, "Media:Open-Opening 0x%x iPriority=%d; retval=%d", (TUint) pD, (TUint) iPhysDevArray[i].iPriority, (TUint) s);
 		if (s!=KErrNone && pM)
 			{
 			pM->Close();
 			pM=NULL;
 			}
 				}
 			}
 		}
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("<DPrimaryMediaBase:OpenMediaDriver-%d",r));
+	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_OPENMEDIADRIVER_EXIT2, this, r );
 	return r;
 	}
 #ifdef __DEMAND_PAGING__
 // RequestCountInc()
 void DPrimaryMediaBase::RequestCountInc()
 	{
 	__ASSERT_DEBUG(iBody, LOCM_FAULT());
 	TInt oldVal = (TInt) __e32_atomic_add_ord32(&iBody->iRequestCount, (TUint) 1);
 //Kern::Printf("RCINC: this %x cnt %d, old %d", this, iBody->iRequestCount, oldVal);
+	OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_REQUESTCOUNTINC, "new count=%d; old count=%d", iBody->iRequestCount, oldVal );
 	if (oldVal == 0 && iBody->iPagingDevice)
 		{
 //Kern::Printf("RCINC: NotifyBusy()");
 		iBody->iPagingDevice->NotifyBusy();
 		}
 void DPrimaryMediaBase::RequestCountDec()
 	{
 	__ASSERT_DEBUG(iBody, LOCM_FAULT());
 	TInt oldVal = (TInt) __e32_atomic_add_ord32(&iBody->iRequestCount, (TUint) -1);
 //Kern::Printf("RCDEC: this %x cnt %d, old %d", this, iBody->iRequestCount, oldVal);
+	OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_REQUESTCOUNTDEC, "new count=%d; old count=%d", iBody->iRequestCount, oldVal );
 	if (oldVal == 1 && iBody->iPagingDevice)
 		{
 //Kern::Printf("RCDEC: NotifyIdle()");
 		iBody->iPagingDevice->NotifyIdle();
 		}
 	__ASSERT_DEBUG(iBody->iRequestCount >= 0, LOCM_FAULT());
 	}
 #endif	// __DEMAND_PAGING__
 TPartitionInfo::TPartitionInfo()
 //
 // Constructor
 //
 #ifdef __DEMAND_PAGING__
 void pageInDfc(TAny* aPtr)
 	{
+	OstTraceFunctionEntry0( _PAGEINDFC_ENTRY );
 	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("pageInDfc"));
 	DPrimaryMediaBase* primaryMedia=(DPrimaryMediaBase*)aPtr;
 	__ASSERT_ALWAYS(primaryMedia && primaryMedia->iPagingMedia && primaryMedia->iBody->iPagingDevice,LOCM_FAULT());
 	DMediaPagingDevice* pagingdevice=primaryMedia->iBody->iPagingDevice;
 #ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
 		(m->iValue == DMediaPagingDevice::ERomPageInRequest)?(countROM++):(countCode++);
 #endif
 		__KTRACE_OPT(KLOCDPAGING, Kern::Printf("pageInDfc: process request 0x%08x, last in queue 0x%08x",m, pagingdevice->iMainQ.Last()) );
+		OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, PAGEINDFC2, "process request=0x%08x; last in queue=0x%08x",(TUint) m, (TUint) pagingdevice->iMainQ.Last());
 		primaryMedia->HandleMsg(*m);
 		}
 #ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
 		pagingdevice->iCodeStats.iMaxReqsInPending=countCode;
 	NKern::FMSignal(&pagingdevice->iInstrumentationLock);
 #endif
 	pagingdevice->iMainQ.Receive();	// allow reception of more messages
+	OstTraceFunctionExit0( _PAGEINDFC_EXIT );
 	}
 DMediaPagingDevice::DMediaPagingDevice(DPrimaryMediaBase* aPtr)
 	:	iMainQ(pageInDfc, aPtr, NULL, KMaxDfcPriority),
 		iDeferredQ(NULL, NULL, NULL, 0),			// callback never used
 		iInstrumentationLock()
 #ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
 		,iServicingROM(NULL), iServicingCode(NULL)
 #endif
 	{
+	OstTraceFunctionEntry1( DMEDIAPAGINGDEVICE_DMEDIAPAGINGDEVICE_CONSTRUCTOR_ENTRY, this );
 	iPrimaryMedia = aPtr;
 	if (iPrimaryMedia->iDfcQ)	// media driver has its own thread
 		{
 		iMainQ.SetDfcQ(iPrimaryMedia->iDfcQ);
 		}
 	iDataOutBenchmarkData.iCount=iDataOutBenchmarkData.iTotalTime=iDataOutBenchmarkData.iMaxTime=0;
 	iDataOutBenchmarkData.iMinTime = KMaxTInt;
 #endif
 	iMainQ.Receive();
+	OstTraceFunctionExit1( DMEDIAPAGINGDEVICE_DMEDIAPAGINGDEVICE_CONSTRUCTOR_EXIT, this );
 	}
 DMediaPagingDevice::~DMediaPagingDevice()
 	{
+OstTraceFunctionEntry1( DMEDIAPAGINGDEVICE_DMEDIAPAGINGDEVICE_DESTRUCTOR_ENTRY, this );
 	if (iMountInfoDataLock)
 		ThePinObjectAllocator->ReleasePinObject((DPinObjectAllocator::SVirtualPinContainer*) iMountInfoDataLock);
 	if (iMountInfoDescHdrLock)
 		ThePinObjectAllocator->ReleasePinObject((DPinObjectAllocator::SVirtualPinContainer*) iMountInfoDescHdrLock);
 	if (iMountInfoDescLenLock)
 		ThePinObjectAllocator->ReleasePinObject((DPinObjectAllocator::SVirtualPinContainer*) iMountInfoDescLenLock);
+	OstTraceFunctionExit1( DMEDIAPAGINGDEVICE_DMEDIAPAGINGDEVICE_DESTRUCTOR_EXIT, this );
 	}
 void DMediaPagingDevice::SendToMainQueueDfcAndBlock(TThreadMessage* aMsg)
 	{
+	OstTraceFunctionEntryExt( DMEDIAPAGINGDEVICE_SENDTOMAINQUEUEDFCANDBLOCK_ENTRY, this );
 	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("Send request 0x%08x to main queue",aMsg));
 	__ASSERT_ALWAYS(aMsg->iState==TMessageBase::EFree,LOCM_FAULT());	// check that message was previously completed or never queued
 	// if drive supports DMA, turn on Physical memory flag & sync memory
 	TLocDrvRequest& m=*(TLocDrvRequest*)(aMsg);
 	// Count the number of outstanding requests if this is the data-paging media, so that
 	// we can call DPagingDevice::NotifyBusy() / DPagingDevice::NotifyIdle()
 	if ((m.Flags() & TLocDrvRequest::EBackgroundPaging) == 0)
 		iPrimaryMedia->RequestCountInc();
 	aMsg->SendReceive(&iMainQ);
 #ifdef __DEMAND_PAGING__
 	if ((m.Flags() & TLocDrvRequest::EBackgroundPaging) == 0)
 		iPrimaryMedia->RequestCountDec();
 		}
 	// come back here when request is completed
 	__ASSERT_DEBUG(aMsg->iState==TMessageBase::EFree,LOCM_FAULT());		// check message has been completed
+	OstTraceFunctionExit1( DMEDIAPAGINGDEVICE_SENDTOMAINQUEUEDFCANDBLOCK_EXIT, this );
 	}
 void DMediaPagingDevice::SendToDeferredQ(TThreadMessage* aMsg)
 	{
+	OstTraceFunctionEntryExt( DMEDIAPAGINGDEVICE_SENDTODEFERREDQ_ENTRY, this );
 	// This queue is only accessed from MD thread
 	__ASSERT_ALWAYS(aMsg->iState==TMessageBase::EAccepted,LOCM_FAULT());	// check that message was previously dequeued
 #ifdef BTRACE_PAGING_MEDIA
 	if(iEmptyingQ&DMediaPagingDevice::EDeferredQ)		// already deferring
 		BTraceContext8(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageInReDeferred,aMsg,aMsg->iValue);
 	else
 		BTraceContext8(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageInDeferred,aMsg,aMsg->iValue);
 #endif
 	aMsg->Forward(&iDeferredQ, EFalse);
+	OstTraceFunctionExit1( DMEDIAPAGINGDEVICE_SENDTODEFERREDQ_EXIT, this );
 	}
 void DMediaPagingDevice::CompleteRequest(TThreadMessage* aMsg, TInt aResult)
 	{
+	OstTraceFunctionEntryExt( DMEDIAPAGINGDEVICE_COMPLETEREQUEST_ENTRY, this );
 	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("DMediaPagingDevice::CompleteRequest, request 0x%08x result %d", aMsg, aResult));
 	__ASSERT_DEBUG(aMsg->iState==TMessageBase::EAccepted,LOCM_FAULT());
 #ifdef BTRACE_PAGING_MEDIA
 	BTraceContext12(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageInPagedIn,aMsg,aResult,aMsg->iValue);
 #endif
 	iPrimaryMedia->CompleteRequest(*((TLocDrvRequest*) aMsg), aResult);
+	OstTraceFunctionExit1( DMEDIAPAGINGDEVICE_COMPLETEREQUEST_EXIT, this );
 	}
 TInt DMediaPagingDevice::Read(TThreadMessage* aReq,TLinAddr aBuffer,TUint aOffset,TUint aSize,TInt aDrvNumber)
 	{
+	OstTraceFunctionEntry1( DMEDIAPAGINGDEVICE_READ_ENTRY, this );
 	__ASSERT_ALWAYS(NKern::CurrentThread()!=iPrimaryMedia->iDfcQ->iThread,LOCM_FAULT());	// that would lock up the system, thus better die now
 	__ASSERT_ALWAYS(aReq,LOCM_FAULT());
 	__ASSERT_CRITICAL
 #ifdef __DEMAND_PAGING_BENCHMARKS__
 	buf[2]=(TInt)aReq;	// address of request object
 	BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageInBegin,aBuffer,offset,buf,sizeof(buf));
 #endif
 	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("DMediaPagingDevice::Read, Req(0x%08x), Buff(0x%x),Offset(%d),Size(%d),DrvNo(%d)",aReq,aBuffer,offset,size,aDrvNumber));
+	OstTraceDefExt5(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_READ1, "req=0x%08x; aBuffer=0x%x; offset=%d; size=%d; aDrvNumber=%d", (TUint) aReq, (TInt) aBuffer, (TInt) offset, (TUint) size, (TUint) aDrvNumber);
 	// no DFCQ, media driver executes in the context of calling thread
 	if (!iPrimaryMedia->iDfcQ)
 		{
 		LOCM_FAULT();		// don't allow paging
+		OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_READ_EXIT, this, KErrNone );
 		return KErrNone;	// keep compiler happy
 		}
 	TLocDrvRequest& m=*(TLocDrvRequest*)(aReq);
 #ifdef __DEMAND_PAGING_BENCHMARKS__
 	SPagingBenchmarkInfo* info = NULL;
 #endif
 		m.Length()=Int64(size);
 		m.RemoteDes()=(TAny*)aBuffer;
 		m.RemoteDesOffset()=0;		// pre-aligned
 		m.DriverFlags()=0;
 		__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("ReqId=%d, Pos=0x%lx, Len=0x%lx, remote Des 0x%x",m.Id(),m.Pos(),m.Length(),m.RemoteDes()));
+		OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_READ2, "reqId=%d; position=0x%lx; length=0x%x; remote Des=0x%x", (TInt) m.Id(), (TUint) m.Pos(), (TUint) m.Length(), (TUint) m.RemoteDes());
 		__ASSERT_DEBUG(iPrimaryMedia->iBody, LOCM_FAULT());
 		TInt mediaChanges = iPrimaryMedia->iBody->iMediaChanges;
 		SendToMainQueueDfcAndBlock(&m);		// queues request, sets and opens client thread, queues dfc and blocks thread until request is completed
 		retVal = m.iValue;
 #ifdef __DEBUG_DEMAND_PAGING__
 		if (retVal != KErrNone)
+		    {
 			Kern::Printf("Pagin Failure %d, retry %d", retVal, i);
+		    }
 #endif
 		// reset retry count if there's ben a media change
 		if (retVal != KErrNone && mediaChanges != iPrimaryMedia->iBody->iMediaChanges)
 			i = 0;
 	if (elapsed > info->iMaxTime)
 		info->iMaxTime = elapsed;
 	if (elapsed < info->iMinTime)
 		info->iMinTime = elapsed;
 #endif // __DEMAND_PAGING_BENCHMARKS__
+	OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_READ_EXIT2, this, retVal );
 	return retVal;
 	}
 TInt DMediaPagingDevice::Write(TThreadMessage* aReq,TLinAddr aBuffer,TUint aOffset,TUint aSize,TBool aBackground)
 	{
+	OstTraceFunctionEntry1( DMEDIAPAGINGDEVICE_WRITE_ENTRY, this );
 	__ASSERT_ALWAYS(NKern::CurrentThread()!=iPrimaryMedia->iDfcQ->iThread,LOCM_FAULT());	// that would lock up the system, thus better die now
 	__ASSERT_ALWAYS(aReq,LOCM_FAULT());
 	__ASSERT_CRITICAL
 #ifdef __DEMAND_PAGING_BENCHMARKS__
 	buf[1] = (TInt)aReq;		// address of request object
 	BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageOutBegin,aBuffer,offset,buf,sizeof(buf));
 #endif
 	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("DMediaPagingDevice::Write, Req(0x%08x), Buff(0x%x),Offset(%d),Size(%d)",aReq,aBuffer,offset,size));
+	OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_WRITE1, "req=0x%08x; aBuffer=0x%x; offset=%d; size=%d", (TUint) aReq, (TUint) aBuffer, offset, size);
 	// no DFCQ, media driver executes in the context of calling thread
 	if (!iPrimaryMedia->iDfcQ)
 		{
 		LOCM_FAULT();		// don't allow paging
+		OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_WRITE_EXIT, this, KErrNone );
 		return KErrNone;	// keep compiler happy
 		}
 	TLocDrvRequest& m=*(TLocDrvRequest*)(aReq);
 #ifdef __DEMAND_PAGING_BENCHMARKS__
 	__e32_atomic_add_ord32(&iMediaPagingInfo.iDataPageOutCount, (TUint) 1);
 	if (aBackground)
 		__e32_atomic_add_ord32(&iMediaPagingInfo.iDataPageOutBackgroundCount, (TUint) 1);
 #endif
 		m.Length()=Int64(size);
 		m.RemoteDes()=(TAny*)aBuffer;
 		m.RemoteDesOffset()=0;		// pre-aligned
 		m.DriverFlags()=0;
 		__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("ReqId=%d, Pos=0x%lx, Len=0x%lx, remote Des 0x%x",m.Id(),m.Pos(),m.Length(),m.RemoteDes()));
+		OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_WRITE2, "reqId=%d; position=0x%lx; length=0x%lx; remote Des=0x%x", (TInt) m.Id(), (TUint) m.Pos(), (TUint) m.Length(), (TUint) m.RemoteDes());
 		__ASSERT_DEBUG(iPrimaryMedia->iBody, LOCM_FAULT());
 		TInt mediaChanges = iPrimaryMedia->iBody->iMediaChanges;
 		SendToMainQueueDfcAndBlock(&m);		// queues request, sets and opens client thread, queues dfc and blocks thread until request is completed
 		retVal = m.iValue;
 #ifdef __DEBUG_DEMAND_PAGING__
 		if (retVal != KErrNone)
 			Kern::Printf("Pagout Failure %d, retry %d", retVal, i);
 	if (elapsed > info.iMaxTime)
 		info.iMaxTime = elapsed;
 	if (elapsed < info.iMinTime)
 		info.iMinTime = elapsed;
 #endif // __DEMAND_PAGING_BENCHMARKS__
+	OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_WRITE_EXIT2, this, retVal );
 	return retVal;
 	}
 TInt DMediaPagingDevice::DeleteNotify(TThreadMessage* aReq,TUint aOffset,TUint aSize)
 	{
+	OstTraceFunctionEntry1( DMEDIAPAGINGDEVICE_DELETENOTIFY_ENTRY, this );
 	if (iDeleteNotifyNotSupported)
+	    {
+		OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_DELETENOTIFY_EXIT1, this, KErrNotSupported );
 		return KErrNotSupported;
+	    }
 	__ASSERT_ALWAYS(NKern::CurrentThread()!=iPrimaryMedia->iDfcQ->iThread,LOCM_FAULT());	// that would lock up the system, thus better die now
 	__ASSERT_ALWAYS(aReq,LOCM_FAULT());
 	__ASSERT_ALWAYS(DataPagingDfcQ(iPrimaryMedia),LOCM_FAULT());
 	__ASSERT_CRITICAL
 	buf[1] = (TInt)aReq;	// address of request object
 	BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedDeleteNotifyBegin,NULL,offset,buf,sizeof(buf));
 #endif
 	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("DMediaPagingDevice::Write, Req(0x%08x), Offset(%d),Size(%d)",aReq,offset,size));
+	OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_DELETENOTIFY1 , "req=0x%08x; offset=%d; size=%d", (TUint) aReq, offset, size);
 	// no DFCQ, media driver executes in the context of calling thread
 	if (!iPrimaryMedia->iDfcQ)
 		{
 		LOCM_FAULT();		// don't allow paging
+		OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_DELETENOTIFY_EXIT2, this, KErrNone );
 		return KErrNone;	// keep compiler happy
 		}
 	TLocDrvRequest& m=*(TLocDrvRequest*)(aReq);
 	m.Length() = Int64(size);
 	m.RemoteDes() = NULL;
 	m.RemoteDesOffset() = 0;		// pre-aligned
 	m.DriverFlags()=0;
 	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("ReqId=%d, Pos=0x%lx, Len=0x%lx, remote Des 0x%x",m.Id(),m.Pos(),m.Length(),m.RemoteDes()));
+	OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_DELETENOTIFY2 , "reqId=%d; position=0x%lx; length=0x%lx; remote Des=0x%x", m.Id(), m.Pos(), m.Length(), (TUint) m.RemoteDes());
 	// send request aynchronously as we don't particularly care about the result
 	// and waiting would slow down the thread taking the page fault
 	iPrimaryMedia->RequestCountInc();
 	TInt retVal = m.iValue;
 	if (retVal == KErrNotSupported)
 		iDeleteNotifyNotSupported = ETrue;
+	OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_DELETENOTIFY_EXIT3, this, retVal );
 	return retVal;
 	}
 EXPORT_C TInt TLocDrvRequest::WriteToPageHandler(const TAny* aSrc, TInt aSize, TInt anOffset)
 	{
+	OstTraceFunctionEntry1( TLOCDRVREQUEST_WRITETOPAGEHANDLER_ENTRY, this );
 #ifdef BTRACE_PAGING_MEDIA
 	TMediaDevice medDev=Drive()->iMedia->iDevice;
 	TInt buf[3];
 	buf[0]=(TUint32)RemoteDes();
 	buf[1]=anOffset;
 	buf[2]=aSize;
 	BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaMedDrvWriteBack,medDev,this,buf,sizeof(buf));
 #endif
 	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("TLocDrvRequest::WriteToPageHandler, memcpy((aTrg)%08x, (aSrc)%08x, (aLength)%08x)",(TUint32)RemoteDes()+anOffset,aSrc,aSize));
 	(void)memcpy((TAny*)((TUint32)RemoteDes()+anOffset), aSrc, aSize);	// maybe in later versions this could be something else
+	OstTraceFunctionExitExt( TLOCDRVREQUEST_WRITETOPAGEHANDLER_EXIT, this, KErrNone );
 	return KErrNone;
 	}
 EXPORT_C TInt TLocDrvRequest::ReadFromPageHandler(TAny* aDst, TInt aSize, TInt anOffset)
 	{
+	OstTraceFunctionEntry1( TLOCDRVREQUEST_READFROMPAGEHANDLER_ENTRY, this );
 #ifdef BTRACE_PAGING_MEDIA
 	TMediaDevice medDev=Drive()->iMedia->iDevice;
 	TInt buf[3];
 	buf[0]=(TUint32)RemoteDes();
 	buf[1]=anOffset;
 	buf[2]=aSize;
 	BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaMedDrvRead,medDev,this,buf,sizeof(buf));
 #endif
 	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("TLocDrvRequest::ReadFromPageHandler, memcpy((aDst)%08x, (aTrg)%08x, (aLength)%08x)",aDst,(TUint32)RemoteDes()+anOffset,aSize));
 	(void)memcpy(aDst, (TAny*)((TUint32)RemoteDes()+anOffset), aSize);	// maybe in later versions this could be something else
+	OstTraceFunctionExitExt( TLOCDRVREQUEST_READFROMPAGEHANDLER_EXIT, this, KErrNone );
 	return KErrNone;
 	}
 _LIT(KLitFragmentationMutexName, "FRAGMENTATION_MUTEX");
 TInt DFragmentationPagingLock::Construct(TUint aNumPages)
 	{
+	OstTraceFunctionEntryExt( DFRAGMENTATIONPAGINGLOCK_CONSTRUCT_ENTRY, this );
 	TInt r=KErrNone;
 	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Fragmentation Lock: creating Mutex"));
 	r=Kern::MutexCreate(this->iFragmentationMutex, KLitFragmentationMutexName, KMutexOrdNone);
 	if (r!=KErrNone)
+	    {
+		OstTraceFunctionExitExt( DFRAGMENTATIONPAGINGLOCK_CONSTRUCT_EXIT1, this, r );
 		return r;
+	    }
 	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Fragmentation Lock: Mutex created OK"));
+	OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DFRAGMENTATIONPAGINGLOCK_CONSTRUCT1 , "Fragmentation Lock: Mutex created OK");
 	iFragmentGranularity = 0;
 	if (aNumPages == 0)
+	    {
+		OstTraceFunctionExitExt( DFRAGMENTATIONPAGINGLOCK_CONSTRUCT_EXIT2, this, KErrNone );
 		return KErrNone;
+	    }
 	// in CS
 	TInt pageSize=Kern::RoundToPageSize(1);
 	LockFragmentation();
 	r=Alloc(pageSize*aNumPages);	// alloc pages
 	UnlockFragmentation();
 	if(r==KErrNone)
 		{
 		iFragmentGranularity = pageSize * aNumPages;
 		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Fragmentation granularity set to 0x%x", iFragmentGranularity));
-		}
+		OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DFRAGMENTATIONPAGINGLOCK_CONSTRUCT2, "Fragmentation granularity=0x%x", iFragmentGranularity);
+		}
+	OstTraceFunctionExitExt( DFRAGMENTATIONPAGINGLOCK_CONSTRUCT_EXIT3, this, r );
 	return r;
 	}
 void DFragmentationPagingLock::Cleanup()
 	{
+	OstTraceFunctionEntry1( DFRAGMENTATIONPAGINGLOCK_CLEANUP_ENTRY, this );
 	// in CS
 	if (iFragmentationMutex)
 		{
 		LockFragmentation();
 		Free();					// at last!
 		UnlockFragmentation();
 		Kern::SafeClose((DObject*&)iFragmentationMutex,NULL);
 		}
+	OstTraceFunctionExit1( DFRAGMENTATIONPAGINGLOCK_CLEANUP_EXIT, this );
 	}
 #else
 #if !defined(__WINS__)
 EXPORT_C TInt TLocDrvRequest::WriteToPageHandler(const TAny* , TInt , TInt)
 @see LocDrv::RegisterMediaDevice()
 */
 EXPORT_C DMediaDriver::DMediaDriver(TInt aMediaId)
 	{
+	OstTraceFunctionEntryExt( DMEDIADRIVER_DMEDIADRIVER_ENTRY, this );
 //	iPhysicalDevice=NULL;
 //	iTotalSizeInBytes=0;
 //	iCurrentConsumption=0;
 //	iPrimaryMedia=NULL;
 //	iCritical=EFalse;
 	iPrimaryMedia=(DPrimaryMediaBase*)TheMedia[aMediaId];
+	OstTraceFunctionExit1( DMEDIADRIVER_DMEDIADRIVER_EXIT, this );
 	}
 @see DObject::Close()
 */
 EXPORT_C DMediaDriver::~DMediaDriver()
 	{
+	OstTraceFunctionEntry1( DMEDIADRIVER_DMEDIADRIVER_DESTRUCTOR_ENTRY, this );
 	SetCurrentConsumption(0);
 	Kern::SafeClose((DObject*&)iPhysicalDevice,NULL);
+	OstTraceFunctionExit1( DMEDIADRIVER_DMEDIADRIVER_DESTRUCTOR_EXIT, this );
 	}
 @see DMediaDriver::PartitionInfo()
 */
 EXPORT_C void DMediaDriver::SetTotalSizeInBytes(Int64 aTotalSizeInBytes, TLocDrv* aLocDrv)
 	{
+	OstTraceFunctionEntry1( DMEDIADRIVER_SETTOTALSIZEINBYTES_ENTRY, this );
 	iTotalSizeInBytes=aTotalSizeInBytes;
 	if (aLocDrv)
 		aLocDrv->iPartitionLen=aTotalSizeInBytes;
+	OstTraceFunctionExit1( DMEDIADRIVER_SETTOTALSIZEINBYTES_EXIT, this );
 	}
 @see DMediaDriver::EndInCritical()
 */
 EXPORT_C TInt DMediaDriver::InCritical()
 	{
+	OstTraceFunctionEntry1( DMEDIADRIVER_INCRITICAL_ENTRY, this );
 	if (!iCritical)
 		{
 		TInt r=iPrimaryMedia->InCritical();
 		if (r!=KErrNone)
+		    {
+			OstTraceFunctionExitExt( DMEDIADRIVER_INCRITICAL_EXIT, this, r );
 			return r;
+		    }
 		iCritical=ETrue;
 		}
+	OstTraceFunctionExitExt( DMEDIADRIVER_INCRITICAL_EXIT2, this, KErrNone );
 	return KErrNone;
 	}
 @see DMediaDriver::InCritical()
 */
 EXPORT_C void DMediaDriver::EndInCritical()
 	{
+	OstTraceFunctionEntry1( DMEDIADRIVER_ENDINCRITICAL_ENTRY, this );
 	if (iCritical)
 		{
 		iCritical=EFalse;
 		iPrimaryMedia->EndInCritical();
 		}
+	OstTraceFunctionExit1( DMEDIADRIVER_ENDINCRITICAL_EXIT, this );
 	}
 /**
 @internalComponent
 */
 EXPORT_C void DMediaDriver::SetCurrentConsumption(TInt aValue)
 	{
+	OstTraceFunctionEntryExt( DMEDIADRIVER_SETCURRENTCONSUMPTION_ENTRY, this );
 	TInt old = (TInt)__e32_atomic_swp_ord32(&iCurrentConsumption, aValue);
 	TInt delta = aValue - old;
 	iPrimaryMedia->DeltaCurrentConsumption(delta);
+	OstTraceFunctionExit1( DMEDIADRIVER_SETCURRENTCONSUMPTION_EXIT, this );
 	}
 is KErrNone to report success, or one of the other system-wide
 error codes to report failure or other problems.
 */
 EXPORT_C void DMediaDriver::Complete(TLocDrvRequest& m, TInt aResult)
 	{
+	OstTraceExt2( TRACE_FLOW, DMEDIADRIVER_COMPLETE_ENTRY, "m=%x;aResult=%d", (TUint) &m, aResult );
 	CHECK_RET(aResult);
 #ifdef __DEMAND_PAGING__
 	if (DMediaPagingDevice::PagingRequest(m))
 		{
 		__ASSERT_ALWAYS(iPrimaryMedia && iPrimaryMedia->iPagingMedia && iPrimaryMedia->iBody->iPagingDevice,LOCM_FAULT());
 	if (&m == iPrimaryMedia->iCurrentReq)	// Complete() called on request serviced synchronously
 		iPrimaryMedia->iCurrentReq = NULL;
 	iPrimaryMedia->RunDeferred();
+	OstTraceFunctionExit1( DMEDIADRIVER_COMPLETE_EXIT, this );
 	}
 @param anError KErrNone if successful, otherwise one of the other system wide
 error codes.
 */
 EXPORT_C void DMediaDriver::OpenMediaDriverComplete(TInt anError)
 	{
+	OstTraceFunctionEntry1( DMEDIADRIVER_OPENMEDIADRIVERCOMPLETE_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DMediaDriver::OpenMediaDriverComplete(%d) this %x iPrimaryMedia %x", anError, this, iPrimaryMedia));
+	OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DMEDIADRIVER_OPENMEDIADRIVERCOMPLETE, "anError %d this 0x%x iPrimaryMedia 0x%x", anError, (TUint) this, (TUint) iPrimaryMedia);
 	DPrimaryMediaBase* pM=iPrimaryMedia;
 	pM->iAsyncErrorCode=anError;
 	pM->iAsyncDfc.Enque();
+	OstTraceFunctionExit1( DMEDIADRIVER_OPENMEDIADRIVERCOMPLETE_EXIT, this );
 	}
 @see DMediaDriver::PartitionInfo()
 */
 EXPORT_C void DMediaDriver::PartitionInfoComplete(TInt anError)
 	{
+	OstTraceFunctionEntry1( DMEDIADRIVER_PARTITIONINFOCOMPLETE_ENTRY, this );
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("DMediaDriver::PartitionInfoComplete(%d) anError %d this %x iPrimaryMedia %x", anError, this, iPrimaryMedia));
+	OstTraceExt3( TRACE_INTERNALS, DMDEDIADRIVER_PARTITIONINFOCOMPLETE, "anError=%d; this=%x; iPrimaryMedia=%x", anError, (TUint) this, (TUint) iPrimaryMedia );
 	DPrimaryMediaBase* pM=iPrimaryMedia;
 	pM->iAsyncErrorCode=anError;
 	pM->iAsyncDfc.Enque();
+	OstTraceFunctionExit1( DMEDIADRIVER_PARTITIONINFOCOMPLETE_EXIT, this );
 	}
 @internalComponent
 */
 // Default implementation
 EXPORT_C void DMediaDriver::Disconnect(DLocalDrive* aLocalDrive, TThreadMessage* aMsg)
 	{
+	OstTraceFunctionEntryExt( DMEDIADRIVER_DISCONNECT_ENTRY, this );
 	// don't need to worry about DLocalDrive going away
 	aLocalDrive->Deque();
 	aMsg->Complete(KErrNone, EFalse);
+	OstTraceFunctionExit1( DMEDIADRIVER_DISCONNECT_EXIT, this );
 	}
 KErrNoMemory, if there is insufficient memory;
 or one of the other system-wide error codes.
 */
 EXPORT_C TInt LocDrv::RegisterMediaDevice(TMediaDevice aDevice, TInt aDriveCount, const TInt* aDriveList, DPrimaryMediaBase* aPrimaryMedia, TInt aNumMedia, const TDesC& aName)
 	{
+	OstTraceFunctionEntry0( LOCDRV_REGISTERMEDIADEVICE_ENTRY );
 	// Create TLocDrv / DMedia objects to handle a media device
 	__KTRACE_OPT(KBOOT,Kern::Printf("RegisterMediaDevice %lS dev=%1d #drives=%d 1st=%d PM=%08x #media=%d",&aName,aDevice,aDriveCount,*aDriveList,aPrimaryMedia,aNumMedia));
+	OstTraceExt5( TRACE_INTERNALS, LOCDRV_REGISTERMEDIADEVICE1, "aDevice=%d; aDriveCount=%d; aDriveList=%d; aPrimaryMedia=0x%08x; aNumMedia=%d", (TInt) aDevice, (TInt) aDriveCount, (TInt) *aDriveList, (TUint) aPrimaryMedia, (TInt) aNumMedia );
 	const TInt* p=aDriveList;
 	TInt i;
 	TInt r=0;
 	if (UsedMedia+aNumMedia>KMaxLocalDrives)
+	    {
+		OstTrace0(TRACE_FLOW, LOCDRV_REGISTERMEDIADEVICE_EXIT1, "< KErrInUse");
 		return KErrInUse;
+	    }
 	for (i=0; i<aDriveCount; ++i)
 		{
 		TInt drv = *p++;
 		// -1 means not used; this is to enable Dual-slot MMC support
 		if (drv == -1)
 			continue;
 		__KTRACE_OPT(KBOOT,Kern::Printf("Registering drive %d", drv));
+		OstTrace1( TRACE_INTERNALS, LOCDRV_REGISTERMEDIADEVICE2, "Registering drive=%d", drv );
 		if (TheDrives[drv])
 			{
 			__KTRACE_OPT(KBOOT,Kern::Printf("Drive %d already in use", drv));
+			OstTrace1( TRACE_FLOW, LOCDRV_REGISTERMEDIADEVICE_EXIT2, "< Drive %d already in use; KErrInUse", drv);
 			return KErrInUse;
 			}
 		}
 	HBuf* pN=HBuf::New(aName);
 	if (!pN)
+	    {
+OstTrace0(TRACE_FLOW, LOCDRV_REGISTERMEDIADEVICE_EXIT3, "< KErrNoMemory");
 		return KErrNoMemory;
+	    }
 	TInt lastMedia=UsedMedia+aNumMedia-1;
 	for (i=UsedMedia; i<=lastMedia; ++i)
 		{
 		if (i==UsedMedia)
 			TheMedia[i]=aPrimaryMedia;
 		else
 			TheMedia[i]=new DMedia;
 		if (!TheMedia[i])
+		    {
+OstTrace0(TRACE_FLOW, LOCDRV_REGISTERMEDIADEVICE_EXIT4, "< KErrNoMemory");
 			return KErrNoMemory;
+		    }
 		r=TheMedia[i]->Create(aDevice,i,lastMedia);
 		__KTRACE_OPT(KBOOT,Kern::Printf("Media %d Create() returns %d",i,r));
+		OstTraceExt2( TRACE_INTERNALS, LOCDRV_REGISTERMEDIADEVICE3, "Media=%d Create(); retval=%d", i, r );
 		if (r!=KErrNone)
+		    {
+OstTrace1(TRACE_FLOW, LOCDRV_REGISTERMEDIADEVICE_EXIT5, "< retval=%d", r);
 			return r;
+		    }
 		}
 	__KTRACE_OPT(KBOOT,Kern::Printf("FirstMedia %d LastMedia %d",UsedMedia,lastMedia));
+	OstTraceExt2( TRACE_INTERNALS, LOCDRV_REGISTERMEDIADEVICE4, "FirstMedia=%d; LastMedia=%d", UsedMedia, lastMedia );
 	UsedMedia+=aNumMedia;
 	p=aDriveList;
 	for (i=0; i<aDriveCount; ++i)
 		{
 		TInt drv=*p++;
 		if (drv == -1)
 			continue;
 		TLocDrv* pL=new TLocDrv(drv);
 		if (!pL)
+		    {
+OstTrace0(TRACE_FLOW, LOCDRV_REGISTERMEDIADEVICE_EXIT6, "< KErrNoMemory");
 			return KErrNoMemory;
+		    }
 		TheDrives[drv]=pL;
 		DriveNames[drv]=pN;
 		pL->iPrimaryMedia=aPrimaryMedia;
 		__KTRACE_OPT(KBOOT,Kern::Printf("Drive %d: TLocDrv @ %08x",drv,pL));
-		}
+		OstTraceExt2( TRACE_INTERNALS, LOCDRV_REGISTERMEDIADEVICE5, "Drive=%d; TLocDrv 0x%08x;", (TInt) drv, (TUint) pL );
+		}
+	OstTraceFunctionExit0( LOCDRV_REGISTERMEDIADEVICE_EXIT7 );
 	return KErrNone;
 	}
 @return KErrNone, if successful;
 KErrAlreadyExists, if a password store has already been registered.
 */
 EXPORT_C TInt LocDrv::RegisterPasswordStore(TPasswordStore* aStore)
 	{
+	OstTraceFunctionEntry0( LOCDRV_REGISTERPASSWORDSTORE_ENTRY );
 	// Create TLocDrv / DMedia objects to handle a media device
 	__KTRACE_OPT(KBOOT,Kern::Printf("RegisterPasswordStore"));
 	TInt r = KErrNone;
 	if(ThePasswordStore == NULL)
 		ThePasswordStore = aStore;
 	else
 		r = KErrAlreadyExists;
+	OstTrace1(TRACE_INTERNALS, LOCDRV_REGISTERPASSWORDSTORE, "retval=%d", r);
+	OstTraceFunctionExit0( LOCDRV_REGISTERPASSWORDSTORE_EXIT );
 	return r;
 	}
 /**
 Returns a pointer to the registered password store.
 */
 EXPORT_C TPasswordStore* LocDrv::PasswordStore()
 	{
 	return ThePasswordStore;
 	}
 #ifdef __DEMAND_PAGING__
 /**
 Registers a paging device with the Local Media Subsystem, and provides
 information about drive numbers used in Code Paging.
 KErrNoMemory, if there is insufficient memory;
 or one of the other system-wide error codes.
 */
 EXPORT_C TInt LocDrv::RegisterPagingDevice(DPrimaryMediaBase* aPrimaryMedia, const TInt* aPagingDriveList, TInt aDriveCount, TUint aPagingType, TInt aReadShift, TUint aNumPages)
 	{
+	OstTraceFunctionEntry0( LOCDRV_REGISTERPAGINGDEVICE_ENTRY );
 	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf(">RegisterPagingDevice: paging type=%d PM=0x%x read shift=%d",aPagingType,aPrimaryMedia,aReadShift));
+	OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE1, "aPagingType=%d; aPrimaryMedia=0x%x; aReadShift=%d", (TInt) aPagingType, (TUint) aPrimaryMedia, (TInt) aReadShift);
 	TInt i;
 	if(!aPagingType || (aPagingType&~(DPagingDevice::ERom | DPagingDevice::ECode | DPagingDevice::EData)))
 		{
 		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Unsupported paging type, exiting"));
+		OstTrace0(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT1, "< Unsupported paging type; KErrArgument");
 		return KErrArgument;
 		}
 	if (aPagingType == 0)
 		{
 		// there's already a ROM or Data paging device & this doesn't support code paging so quietly exit without further addo
 		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Nothing left to register on locdrv no %d, exiting",i));
+		OstTrace1(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT2, "< Nothing left to register on locdrv no %d; KErrNone",i);
 		return KErrNone;
 		}
 	const TInt* p=aPagingDriveList;
 	if(aPagingType&DPagingDevice::ECode)	// supports code paging, do argument check
 		{
 		if(!aDriveCount || (aDriveCount>=KMaxLocalDrives))
 			{
 			__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Invalid code paging drive count: %d", aDriveCount));
+			OstTrace1(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT3, "< Invalid code paging drive count=%d; KErrArgument", aDriveCount);
 			return KErrArgument;
 			}
 		TInt drvCount=0;
 		for(i=0; i<KMaxLocalDrives; i++)
 			if(TheDrives[i] && TheDrives[i]->iPrimaryMedia==aPrimaryMedia)
 				drvCount++;
 		if(aDriveCount>drvCount)	// can't exceed number of drives registered by this device
 			{
-			__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Invalid code paging drive count: %d total %d", aDriveCount, drvCount));
+			__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Invalid code paging drive count=%d; total=%d", aDriveCount, drvCount));
+			OstTraceExt2(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT4, "< Invalid code paging drive count=%d; total=%d; KErrArgument", aDriveCount, drvCount);
 			return KErrArgument;
 			}
 		for (i=0; i<aDriveCount; ++i)
 			{
 			__KTRACE_OPT(KBOOT,Kern::Printf("RegisterPagingDevice: registering drive=%d ",*p));
+			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE2, "Registering Drive=%d", *p );
 			TInt drv=*p++;
 			if(drv>=KMaxLocalDrives)
 				{
 				__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Invalid code paging drive number: %d", drv));
+				OstTrace1(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT5, "< Invalid code paging drive number=%d; KErrArgument", drv);
 				return KErrArgument;
 				}
 			TLocDrv* pD=TheDrives[drv];
 			if (!pD)
+			    {
+OstTrace0(TRACE_FLOW, LOCRV_REGISTERPAGINGDEVICE_EXIT6, "< KErrNotFound");
 				return KErrNotFound;
+			    }
 			if (pD->iPrimaryMedia!=aPrimaryMedia)
+			    {
+OstTrace0(TRACE_FLOW, LOCRV_REGISTERPAGINGDEVICE_EXIT7, "< KErrNotSupported");
 				return KErrNotSupported;
+			    }
 			}
 		}
 	TInt firstLocalDriveNumber = KErrNotFound;
 			firstLocalDriveNumber = i;
 			break;
 			}
 		}
 	__ASSERT_ALWAYS(i < KMaxLocalDrives, LOCM_FAULT());
 	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("DMediaPagingDevice(), firstLocalDriveNumber %d", firstLocalDriveNumber));
+	OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE3, "firstLocalDriveNumber=%d", firstLocalDriveNumber );
 	// Send an ECaps message to wake up the media driver & ensure all partitions are
 	// reported, then search for paged-data or paged-ROM partitions
 	if ((aPagingType & DPagingDevice::EData) ||
 		(aPagingType & DPagingDevice::ERom && aPrimaryMedia->iDfcQ && aPrimaryMedia->iMsgQ.iReady))
 		{
 		// the message queue must have been started already (by the media driver calling iMsgQ.Receive())
 		// otherwise we can't send the DLocalDrive::EQueryDevice request
 		if (aPrimaryMedia->iDfcQ && !aPrimaryMedia->iMsgQ.iReady)
 			{
 			__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: Message queue not started"));
+			OstTrace0(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT8, "< RegisterPagingDevice: Message queue not started; KErrNotReady");
 			return KErrNotReady;
 			}
 		TLocDrvRequest m;
 			m.Length() = KMaxLocalDriveCapsLength;	// for pinning
 			r = aPrimaryMedia->Request(m);
 //Kern::Printf("EQueryPageDeviceInfo: i %d: r %d ", i, r);
 			__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("Paging device ECaps: i %d: r %d ", i, r));
+			OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE4, "Paging device ECaps: i %d retval=%d", i, r);
 			}
 		if (r != KErrNone)
+		    {
+OstTrace1(TRACE_FLOW, LOCRV_REGISTERPAGINGDEVICE_EXIT9, "< retval=%d",r);
 			return r;
+		    }
 		TLocDrv* drive;
 		for (i=0; i<KMaxLocalDrives; ++i)
 			{
 			drive = TheDrives[i];
 				__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("RegisterPagingDevice: local drive %d, partition type %x size %x", i, drive->iPartitionType, I64LOW(drive->iPartitionLen)));
 				// ROM partition ?
 				if ((romPagingDriveNumber == KErrNotFound) && (drive->iPartitionType == KPartitionTypeROM))
 					{
 					__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("Found ROM partition on local drive %d, size %x", i, I64LOW(drive->iPartitionLen)));
+					OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE5, "Found ROM partition on local drive=%d; size=0x%x", (TInt) i, (TUint) I64LOW(drive->iPartitionLen));
 					romPagingDriveNumber = i;
 					}
 			    // swap partition ?
 				else if ((dataPagingDriveNumber == KErrNotFound) && (drive->iPartitionType == KPartitionTypePagedData))
 					{
 					__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("Found swap partition on local drive %d, size %x", i, I64LOW(drive->iPartitionLen)));
+					OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE6, "Found SWAP partition on local drive=%d; size=0x%x", (TInt) i, (TUint) I64LOW(drive->iPartitionLen) );
 					dataPagingDriveNumber = i;
 					swapSize = drive->iPartitionLen >> aReadShift;
 					}
 				}
 			}
 		if (swapSize == 0)
 			{
 			__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("Disabling data paging"));
+			OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE7, "Disabling data paging");
 			aPagingType &= ~DPagingDevice::EData;
 			}
 		}
 	// create and set up a DPagingDevice to allow PageIn request servicing
 	DMediaPagingDevice* pagingDevice = new DMediaPagingDevice(aPrimaryMedia);
 	if(!pagingDevice)
 		{
 		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: could not create paging device"));
+		OstTrace0(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT_EXIT10, "< RegisterPagingDevice: could not create paging device; KErrNoMemory");
 		return KErrNoMemory;
 		}
 	pagingDevice->iType = aPagingType;
 	pagingDevice->iReadUnitShift = aReadShift;
 	Kern::Printf("iReadUnitShift 0x%x\n", pagingDevice->iReadUnitShift);
 	Kern::Printf("iFirstLocalDriveNumber 0x%x\n", pagingDevice->iFirstLocalDriveNumber);
 	Kern::Printf("iRomPagingDriveNumber 0x%x\n", pagingDevice->iRomPagingDriveNumber);
 	Kern::Printf("iDataPagingDriveNumber 0x%x\n", pagingDevice->iDataPagingDriveNumber);
 	Kern::Printf("iSwapSize 0x%x\n", pagingDevice->iSwapSize);
-#endif
+	#endif
 	// This table is indexed by DPagingDevice::TType
 	const char* DeviceName[] =
 		{
 	if (ThePinObjectAllocator == NULL)
 		ThePinObjectAllocator = new DPinObjectAllocator();
 	if(!ThePinObjectAllocator)
 		{
 		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: could not create ThePinObjectAllocator"));
+		OstTrace0(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT11, "RegisterPagingDevice: could not create ThePinObjectAllocator; KErrNoMemory");
 		return KErrNoMemory;
 		}
 	TInt r = ThePinObjectAllocator->Construct(KDynamicPagingLockCount, aNumPages);
 	if (r != KErrNone)
 		{
 		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: could not construct ThePinObjectAllocator"));
+		OstTrace1(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT12, "< RegisterPagingDevice: could not construct ThePinObjectAllocator; retval=%d",r);
 		return r;
 		}
 	// Register our DPagingDevice with the Kernel
 #endif
 	if (r!=KErrNone)
 		{
 		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: could not install paging device"));
+		OstTrace1(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT13, "< RegisterPagingDevice: could not install paging device; retval=%d", r);
 		delete pagingDevice;
 		return r;
 		}
 	// all hunky dory, save paging device and mark our media as pageable
 #endif
 	if (!dataPagingSupported)
 		{
 #ifdef __DEBUG_DEMAND_PAGING__
 		if (aPagingType & DPagingDevice::EData)
+		    {
 			Kern::Printf("Disabling data paging, not supported in this ROM");
+		    }
 #endif
 		aPagingType&= ~DPagingDevice::EData;
 		}
 		DataPagingDeviceRegistered = ETrue;
 		aPrimaryMedia->iDataPagingMedia = 1;
 		TheDataPagingMedia = aPrimaryMedia;
 		}
-	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("<RegisterPagingDevice"));
+	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("< RegisterPagingDevice"));
+	OstTraceFunctionExit0( LOCDRV_REGISTERPAGINGDEVICE_EXIT14 );
 	return KErrNone;
 	}
 #else //__DEMAND_PAGING__
 EXPORT_C TInt LocDrv::RegisterDmaDevice(DPrimaryMediaBase* aPrimaryMedia,
 										TInt aMediaBlockSize,				// Minimum transfer size (bytes) for the media
 										TInt aDmaMaxAddressable,			// Max Addressing Range for DMA controller, 0 if None.
 										TInt aDmaAlignment)					// DMA Alignment e.g. word alignment required = 2
 	{
+	OstTraceFunctionEntry0( LOCDRV_REGISTERDMADEVICE_ENTRY );
 	__KTRACE_OPT(KBOOT ,Kern::Printf("RegisterPhysicalAddrDevice: PM=0x%x BS=%d MaxAddr=%d DMA=%d",
 									aPrimaryMedia, aMediaBlockSize, aDmaMaxAddressable, aDmaAlignment));
+	OstTraceExt4( TRACE_INTERNALS, LOCDRV_REGISTERDMADEVICE, "aPrimaryMedia=0x%x; aMediaBlockSize=%d; aDmaMaxAddressable=%d; aDmaAlignment=%d", (TUint) aPrimaryMedia, (TInt) aMediaBlockSize, (TInt) aDmaMaxAddressable, (TInt) aDmaAlignment );
 	for (TInt i=0; i<KMaxLocalDrives; ++i)
 		{
 		TLocDrv* pL=TheDrives[i];
 		if (pL && pL->iPrimaryMedia == aPrimaryMedia && pL->iDmaHelper == NULL)
 			{
 			TInt r = pL->iDmaHelper->Construct(MaxAddress, aMediaBlockSize, aDmaAlignment);
 			__ASSERT_ALWAYS(r == KErrNone, LOCM_FAULT());
 			}
 		}
+	OstTraceFunctionExit0( LOCDRV_REGISTERDMADEVICE_EXIT );
 	return KErrNone;
 	}
 void GetDriveInfo(TDriveInfoV1& info)
 	{
+	OstTraceFunctionEntry1( GETDRIVEINFO_ENTRY, ( TUint )&( info ) );
 	TInt i;
 	TInt drives=0;
 	TUint32 sock_mask=0;
 	TInt sockets=0;
 				{
 				if (!(sock_mask & (1<<sockNum)))
 					{
 					info.iSocketName[sockNum]=*DriveNames[i];
 					__KTRACE_OPT(KLOCDRV,Kern::Printf("Socket %d device %d name %lS", sockNum, pM->iDevice, DriveNames[i]));
+					OstTraceExt2( TRACE_INTERNALS, GETDRIVEINFO1, "Socket=%d; device=%d", sockNum, (TUint) pM->iDevice );
 					if ( (sockNum + 1) > sockets )
 						sockets = sockNum + 1;
 					}
 				sock_mask |= (1<<sockNum);
 				}
 			info.iDriveName[i]=*DriveNames[i];
 			__KTRACE_OPT(KLOCDRV,Kern::Printf("Drive %d device %d name %lS",i,pM->iDevice,DriveNames[i]));
+			OstTraceExt2( TRACE_INTERNALS, GETDRIVEINFO2, "Drive=%d; device=%d", i, (TUint) pM->iDevice );
 			info.iRegisteredDriveBitmask |= (0x01 << i);
 			}
 		}
 	info.iTotalSupportedDrives=drives;
 	info.iTotalSockets=sockets;
 	info.iRuggedFileSystem=ETrue;
 	__KTRACE_OPT(KLOCDRV,Kern::Printf("Total drives=%d, sockets=%d",drives,sockets));
+	OstTraceExt2( TRACE_INTERNALS, GETDRIVEINFO3, "Total drives=%d; sockets=%d", drives, sockets );
+	OstTraceFunctionExit0( GETDRIVEINFO_EXIT );
 	}
 #if defined(__DEMAND_PAGING__) && defined(__CONCURRENT_PAGING_INSTRUMENTATION__)
 void ResetConcurrencyStats(DMediaPagingDevice* aDevice, TMediaPagingStats aStats)
 	{
 EXPORT_C void TPartitionTableScanner::Set(TUint8* aSectorBuffer, TPartitionEntry* aEntry, TInt aMaxPartitions, TInt64 aMediaSize)
 	{
 	__KTRACE_OPT(KLOCDRV, Kern::Printf("TPartitionTableScanner @ %08x : buf %08x entry %08x max %d sz %08x %08x",
 								this, aSectorBuffer, aEntry, aMaxPartitions, I64HIGH(aMediaSize), I64LOW(aMediaSize)));
+	OstTraceExt4( TRACE_INTERNALS, TPARTITIONTABLESCANNER_SET, "TPartitionTableScanner at 0x%08x; aSectorBuffer=0x%08x; aEntry=0x%08x; aMaxPartitions=%d", (TUint) this, (TUint) aSectorBuffer, (TUint) aEntry, aMaxPartitions );
 	__ASSERT_ALWAYS(aMaxPartitions>0, LOCM_FAULT());
 	memclr(this, sizeof(TPartitionTableScanner));
 	iLBA = -1;
 	iSectorBuffer = aSectorBuffer;
 	iFirstEntry = aEntry;
 EXPORT_C TInt TPartitionTableScanner::NumberOfPartitionsFound() const
 	{
 	TInt n = iNextEntry - iFirstEntry;
 	__KTRACE_OPT(KLOCDRV, Kern::Printf("TPartitionTableScanner N=%d", n));
+	OstTrace1( TRACE_INTERNALS, TPARTITIONTABLESCANNER_NUMBERPARTITIONS, "Number of partitions=%d", n );
 	return n;
 	}
 TPartitionTableScanner::SPart::SPart(const TUint8* a)
 	{
 	iBootInd = a[0];
 	iType = a[4];
 	iRSS = a[8]|(a[9]<<8)|(a[10]<<16)|(a[11]<<24);
 	iSectors = a[12]|(a[13]<<8)|(a[14]<<16)|(a[15]<<24);
 	__KTRACE_OPT(KLOCDRV, Kern::Printf("SPart: BI=%02x TYPE=%02x RSS=%08x SIZE=%08x", iBootInd, iType, iRSS, iSectors));
+	OstTraceExt4(TRACE_INTERNALS, TPARTITIONTABLESCANNER_SPART_SPART, "SPart: iBootInd=%02x; iType=%02x; iRSS=%08x; iSectors=%08x", (TUint) iBootInd, (TUint) iType, (TUint) iRSS, (TUint) iSectors);
 	}
 TInt TPartitionTableScanner::MakeEntry(const SPart& a)
 	{
+	OstTraceFunctionEntry1( TPARTITIONTABLESCANNER_MAKEENTRY_ENTRY, this );
 	if (iNextEntry == iLimit)
+	    {
+		OstTraceFunctionExitExt( TPARTITIONTABLESCANNER_MAKEENTRY_EXIT1, this, KErrOverflow );
 		return KErrOverflow;
+	    }
 	if (a.iRSS<=0 || a.iSectors<=0 || a.iRSS>=iMediaSize)
+	    {
+		OstTraceFunctionExitExt( TPARTITIONTABLESCANNER_MAKEENTRY_EXIT2, this, KErrCorrupt );
 		return KErrCorrupt;
+	    }
 	if (TUint64(a.iRSS) + TUint64(a.iSectors) > TUint64(iMediaSize))
+	    {
+		OstTraceFunctionExitExt( TPARTITIONTABLESCANNER_MAKEENTRY_EXIT3, this, KErrCorrupt );
 		return KErrCorrupt;
+	    }
 	iNextEntry->iBootIndicator = a.iBootInd;
 	iNextEntry->iPartitionType = a.iType;
 	iNextEntry->iPartitionBaseAddr = TInt64(a.iRSS)<<ESectorShift;
 	iNextEntry->iPartitionLen = TInt64(a.iSectors)<<ESectorShift;
 	++iNextEntry;
+	OstTraceFunctionExitExt( TPARTITIONTABLESCANNER_MAKEENTRY_EXIT4, this, KErrNone );
 	return KErrNone;
 	}
 EXPORT_C TInt64 TPartitionTableScanner::NextLBA()
 	{
+	OstTraceFunctionEntry0( TPARTITIONTABLESCANNER_NEXTLBA_ENTRY );
 	__KTRACE_OPT(KLOCDRV, Kern::Printf(">TPartitionTableScanner iLBA=%08x %08x", I64HIGH(iLBA), I64LOW(iLBA)));
+	OstTraceExt2( TRACE_INTERNALS, TPARTITIONTABLESCANNER_NEXTLBA1, "TPartitionTableScanner iLBA=%08x %08x", I64HIGH(iLBA), I64LOW(iLBA) );
 	TInt r;
 	TUint8* b = iSectorBuffer;
 	TUint8* pS = b + 0x1be;
 	TUint8* pE = pS + 64;
 	TUint8* p = pS;
 		}
 	__KTRACE_OPT(KLOCDRV,DMEMDUMP(b, ESectorSize));
 	if (b[ESectorSize-2]!=0x55 || b[ESectorSize-1]!=0xaa)
 		{
 		__KTRACE_OPT(KLOCDRV, Kern::Printf("Bad signature"));
+		OstTrace0( TRACE_INTERNALS, TPARTITIONTABLESCANNER_NEXTLBA2, "Bad signature" );
 		iLBA = KErrCorrupt;
 		goto end;
 		}
 	if (iLBA==0 && iNextEntry==iFirstEntry)
 		{
 				{
 				const TInt64& rss = iStack[sp].iRSS;
 				const TInt64& size = iStack[sp].iSectors;
 				__KTRACE_OPT(KLOCDRV, Kern::Printf("Stack[%d] RSS %08x %08x SIZE %08x %08x", sp,
 					I64HIGH(rss), I64LOW(rss), I64HIGH(size), I64LOW(size) ));
+				OstTraceExt5(TRACE_INTERNALS, PARTITIONTABLESCANNER_NEXTLBA3, "Stack[%d] RSS 0x%x 0x%x SIZE 0x%08x 0x%08x", (TInt) sp, (TUint) I64HIGH(rss), (TUint) I64LOW(rss), (TUint) I64HIGH(size), (TUint) I64LOW(size));
 				}
 #endif
 			}
 		}
 	// Look for other data partitions
 	else
 		iLBA = KErrEof;	// finished
 end:
 	__KTRACE_OPT(KLOCDRV, Kern::Printf("<TPartitionTableScanner iLBA=%08x %08x", I64HIGH(iLBA), I64LOW(iLBA)));
+	OstTraceExt2( TRACE_INTERNALS, TPARTITIONTABLESCANNER_NEXTLBA3, "TPartitionTableScanner iLBA=0x%08x 0x%08x", I64HIGH(iLBA), I64LOW(iLBA) );
+	OstTraceFunctionExit0( TPARTITIONTABLESCANNER_NEXTLBA_EXIT );
 	return iLBA;
 	}
 /**
 * Returns Address and Length of next contiguous Physical memory fragment
 * 		   KErrNoMemory, if no more memory fragments left.
 * 		   KErrNotSupported, if Physical Memory addressing is not supported by this Media.
 */
 EXPORT_C TInt TLocDrvRequest::GetNextPhysicalAddress(TPhysAddr& aAddr, TInt& aLen)
 	{
+	OstTraceExt2(TRACE_FLOW, TLOCDRVREQUEST_GETNEXTPHYSICALADDRESS_ENTRY, "> TLocDrvRequest::GetNextPhysicalAddress;aAddr=%x;aLen=%d;", (TUint) &aAddr, aLen );
 	if (Flags() & EPhysAddr)
 		{
 #ifdef __DEMAND_PAGING__
 		if (DMediaPagingDevice::PagingRequest(*this))
 			{
 			return DDmaHelper::GetPhysicalAddress(*this, aAddr, aLen);
 			}
 #endif
 		return Drive()->iDmaHelper->GetPhysicalAddress(aAddr, aLen);
 		}
 	else
 		{
+		OstTraceFunctionExitExt( TLOCDRVREQUEST_GETNEXTPHYSICALADDRESS_EXIT, this, KErrNotSupported );
 		return KErrNotSupported;
 		}
 	}

changeset 47	46fffbe7b5a7
parent 44	36bfc973b146
child 62	4a8fed1c0ef6
child 90	947f0dc9f7a8