// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32utils\profiler\sampler.cpp

 // 

 //

 #include "platform.h"

 #include "sampler.h"

 #include <kernel/kern_priv.h>		//temporary

 #include <memmodel/epoc/plat_priv.h> // needed for DEpocCodeSeg

 _LIT(KLddName,"Sampler");

 TKName KiDFCThread = _L("Running from iDFC");

 TKName KiDFCProcess = _L("N/A");

 TUint  KiDFCId = (TUint)-1; //both process and thread assigned to iDFC will have 'fake' id=-1

 const TInt KMajorVersionNumber=2;

 const TInt KMinorVersionNumber=0;

 const TInt KBuildVersionNumber=0;

 const TInt KMinRate=10;

 const TInt KMaxRate=1000;

 const TInt KRawBufSize=256;

 const TInt KCookedBufSize=0x2000;

 const TInt KCodeBufSize=0x2000;

 const TInt KMaxCreateCodeSegRecordSize = 300; //Max size of the encoded CodeSegCreate record.

 const TInt KMaxErrorReportRecordSize = 18;    //Max size of the encoded ErrorReport record. (3 zeros and 3 integers)

 const TInt KRequiredFreeSpace=512;

 //Bit mask in report

 const TInt KNonXIPModeActive=1; 

 const TInt KNoDebugSupport=2;

 #define PUT(p,x,e,s)	{*(p)++=(x); if ((p)==(e)) (p)-=(s);}

 #define GET_A_BYTE(p,x,e,s)	{*(x)++=*(p)++; if ((p)==(e)) (p)-=(s);}

 #define	TAG(obj)		(*(TUint32*)&(obj->iAsyncDeleteNext))

 #define CODESEGBUFEND (iCodeSegBuffer+KCodeBufSize)

 #define COOKEDBUFEND (iCookedBuf+KCookedBufSize)

 extern TUint IntStackPtr();

 extern TUint32 SPSR();

 extern TUint IDFCRunning();

 // global Dfc Que

 TDynamicDfcQue* gDfcQ;

 class DDeviceSampler : public DLogicalDevice

 	{

 public:

 	DDeviceSampler();

 	~DDeviceSampler();

 	virtual TInt Install();

 	virtual void GetCaps(TDes8& aDes) const;

 	virtual TInt Create(DLogicalChannelBase*& aChannel);

 	};

 struct SRawSample

 	{

 	TLinAddr iPC;

 	TUint32 iSampleCounter;

 	TUint32 iThreadId;

 	};

 class DProfile : public DLogicalChannel

 	{

 public:

 	DProfile();

 	~DProfile();

 protected:

 	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

 	virtual void HandleMsg(TMessageBase* aMsg);

 private:

 	TInt GetSegments(TDes8* aDes);

 	TInt StartSampling(TInt aRate);

 	TInt StopSampling();

 	TInt Reset(TBool aXIPOnly);

 	TInt ResetSegments();

 	TInt Drain(TDes8* aDes);

 	TInt GetErrors(TDes8* aDes);

 	TInt ProcessReadRequest();

 	TInt DoDrainCooked();

 	TInt Cook();

 	void Complete(TInt aResult);

 	inline TBool Running()

 		{return iTimer.iState!=NTimer::EIdle;}

 private:

 	static void Sample(TAny*);

 	static void Dfc(TAny*);

 	static TUint KernelEventHandler(TKernelEvent aEvent, TAny* a1, TAny* a2, TAny* aPrivateData);

 	void LogCodeSegEvent(TKernelEvent aEvent, DEpocCodeSeg *pCodeSeg);

 private:

 	static TUint8* EncodeTag(TUint8* p, TUint8* e);

 	static TUint8* EncodeInt(TUint8* p, TUint8* e, TInt aValue);

 	static TUint8* EncodeUint(TUint8* p, TUint8* e, TUint aValue);

 	static TUint8* EncodeText(TUint8* p, TUint8* e, const TDesC& aDes);

 	static TUint8* EncodeRepeat(TUint8* p, TUint8* e, DProfile* aProfile);

 	TUint8* EncodeThread(TUint8* p, TUint8* e, DThread* aThread);

 	TUint8* EncodeIDFC(TUint8* p, TUint8* e);

 	TUint8* PutStream(TUint8* p, TUint8* e, const TUint8* aSource, TInt aSize);

 	TUint8* GetStream(TUint8* p, TUint8* e, TInt8* aDest, TInt aSize);	

 	TBool CookCodeSeg(TBool aPutAll, TInt aSampleCounter);

 private:

 	TUint32 iStartTime;

 	TInt iRepeat;

 	SRawSample iLast;

 	TInt iPeriod;

 	NTimer iTimer;

 	TDfc iDfc;

 	TUint* iIntStackTop;

 	DThread* iClient;

 	TRequestStatus* iReqStatus;

 	TInt iPos;			// client des pos

 	TInt iRemain;		// space left in client des

 	TDes8* iDes;		// client des pointer

 	TUint8 iRPut;		// raw buffer put index

 	TUint8 iRGet;		// raw buffer get index

 	TUint8* iCPut;		// cooked buffer put

 	TUint8* iCGet;		// cooked buffer get

 	SRawSample iRawBuf[KRawBufSize];

 	TUint8 iCookedBuf[KCookedBufSize];

 	DKernelEventHandler* iKernelEvHandler;

 	TInt iNextSampleCounter;

 	TBool iXIPOnly;

 	TBool iMarkedOnlySegments;	// True during GettingSegments phase in which event handler...

 								// ... collects only the events from marked segments.

 	TUint8 iCodeSegBuffer[KCodeBufSize];

 	TUint8* iCSPut;		// CodeSeg buffer put

 	TUint8* iCSGet;		// CodeSeg buffer get

 	TUint iIDFCSeenBefore;

 	struct TReport

 		{

 		TUint iRowBufferErrCounter;

 		TUint iCodeSegErrCounter;

 		TInt  iReportMask; 

 		} iReport;

 	};

 DECLARE_STANDARD_LDD()

 	{

 	return new DDeviceSampler;

 	}

 DDeviceSampler::DDeviceSampler()

 //

 // Constructor

 //

 	{

 	//iParseMask=0;

 	//iUnitsMask=0;

 	iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

 	}

 const TInt KDSamplerThreadPriority = 27;

 _LIT(KDSamplerThread,"DSamplerThread");

 TInt DDeviceSampler::Install()

 //

 // Install the device driver.

 //

 	{

 	// Allocate a kernel thread to run the DFC 

 	TInt r = Kern::DynamicDfcQCreate(gDfcQ, KDSamplerThreadPriority, KDSamplerThread);

 	if (r != KErrNone)

 		return r; 	

 	r=SetName(&KLddName);

 	return r;

 	}

 void DDeviceSampler::GetCaps(TDes8& aDes) const

 //

 // Return the capabilities.

 //

 	{

 	}

 /**

   Destructor

 */

 DDeviceSampler::~DDeviceSampler()

 	{

 	if (gDfcQ)

 		gDfcQ->Destroy();

 	}

 TInt DDeviceSampler::Create(DLogicalChannelBase*& aChannel)

 //

 // Create a channel on the device.

 //

 	{

 	aChannel=new DProfile;

 	return aChannel?KErrNone:KErrNoMemory;

 	}

 DProfile::DProfile()

 	:	iTimer(Sample,this),

 		iDfc(Dfc,this,NULL,7)

 //

 // Constructor

 //

 	{

 	}

 DProfile::~DProfile()

 //

 // Destructor

 //

 	{

 	Kern::SafeClose((DObject*&)iClient, NULL);

 	}

 TInt DProfile::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)

 //

 // Create the channel from the passed info.

 //

 	{

 	if (!Kern::QueryVersionSupported(TVersion(1,0,1),aVer))

 		return KErrNotSupported;

 	iClient=&Kern::CurrentThread();

 	iClient->Open();

 	Kern::SetThreadPriority(24);

 	iIntStackTop=(TUint*)IntStackPtr();

 	SetDfcQ(gDfcQ);

 	iDfc.SetDfcQ(iDfcQ);

 	iMsgQ.Receive();

 	return KErrNone;

 	}

 void DProfile::Complete(TInt aResult)

 //Completes user request

 	{

 	DEBUG_PROFILER(Kern::Printf("C");)

 	Kern::RequestComplete(iClient,iReqStatus,aResult);

 	}

 TInt DProfile::StartSampling(TInt aRate)

 	{

 	DEBUG_PROFILER(Kern::Printf("START");)

 	//Activate timer

 	aRate=Min(KMaxRate, Max(KMinRate, aRate));

 	iPeriod=1000/aRate;

 	if (!Running())

 		iTimer.OneShot(iPeriod);

 	DEBUG_PROFILER(Kern::Printf("START end");)

 	return KErrNone;

 	}

 TInt DProfile::GetSegments(TDes8* aDes)

 //

 // Collects and marks all non-XIP segments.

 //

 	{

 	DEBUG_PROFILER(Kern::Printf("GS");)

 	TInt max=Kern::ThreadGetDesMaxLength(iClient,aDes);

 	Kern::ThreadDesWrite(iClient,aDes,KNullDesC8,0,0,iClient);//Set length to zero

 	TInt current = 0;

 	Kern::AccessCode();

 	// Take all records that are collected by event handler first. They may be only Delete CodeSeg 

 	// events of tagged(marked) segments. On the first GetSegments call, cooked buffer also contains Profile Tag.

 	CookCodeSeg(ETrue, 0); // Transfer/encode from CodeSeg buffer into cooked buffer

 	current = iCPut-iCGet;

 	if (current)

 		{

 		if (current < max)

 			{//Copy data into user side descriptor

 			TPtrC8 aPtr(iCGet, current);

 			Kern::ThreadDesWrite(iClient,aDes,aPtr,0,KChunkShiftBy0,iClient);

 			}

 		else

 			{	

 			//This is very unlikely as in this stage we collect only CodeSeg Delete events of the marked segments.

 			//It cannot happen on the first call, as there are no marked segments - which means that Profiler Tag is OK.

 			iReport.iCodeSegErrCounter++;

 			}

 		}

 	iCGet = iCPut = iCookedBuf; //Reset the cooked buffer

 	//Collect all non-XIP segments that are not already marked.

 	SDblQue* p = Kern::CodeSegList();

 	SDblQueLink* anchor=&p->iA;

 	SDblQueLink* a=anchor->iNext;

 	for (; a!=anchor; a=a->iNext) 

 		{

 		DEpocCodeSeg* pSeg = (DEpocCodeSeg*) _LOFF(a, DCodeSeg, iLink);

 		if (pSeg->iXIP || pSeg->iMark&DCodeSeg::EMarkProfilerTAG)

 			continue;

 		if (current > (max-KMaxCreateCodeSegRecordSize))

 			break;//No more space. Finish now and wait for another GetSegments request.

 		pSeg->iMark |= DCodeSeg::EMarkProfilerTAG;	//Mark this segment

 		LogCodeSegEvent(EEventAddCodeSeg, pSeg); 	//Place this record into CodeSeg buffer ...

 		CookCodeSeg(ETrue, 0);						//...and encode it into cooked buffer

 		TPtrC8 aPtr(iCGet, iCPut-iCGet);

 		Kern::ThreadDesWrite(iClient,aDes,aPtr,current,KChunkShiftBy0,iClient);//Copy record into user desc.

 		current += iCPut-iCGet;

 		iCPut = iCGet = iCookedBuf; //Reset cooked buffer

 		}

 	if (!current)//This will be the last GetSegments call. From now on, all events have to be recorded.

 		iMarkedOnlySegments = EFalse;

 	Kern::EndAccessCode();

 	DEBUG_PROFILER(Kern::Printf("GS end %d",current);)

 	return KErrNone;

 	}

 TInt DProfile::ResetSegments()

 //

 // Unmarks all non-XIP segments 

 // Sets device into GettingSegments mode in which only the events of the marked Code Segments will be recorder

 // 

 	{

 	DEBUG_PROFILER(Kern::Printf("RS");)

 	if (iXIPOnly)

 		return KErrGeneral;

 	Kern::AccessCode();

 	SDblQue* p = Kern::CodeSegList();

 	SDblQueLink* anchor=&p->iA;

 	SDblQueLink* a=anchor->iNext;

 	for (; a!=anchor; a=a->iNext) 

 		{

 		DEpocCodeSeg* pSeg = (DEpocCodeSeg*) _LOFF(a, DCodeSeg, iLink);

 		if (!pSeg->iXIP)

 			pSeg->iMark &= ~DCodeSeg::EMarkProfilerTAG;

 		}

 	if (DKernelEventHandler::DebugSupportEnabled())

 		{

 		DEBUG_PROFILER(Kern::Printf("RS add handler");)

 		iKernelEvHandler->Add();

 		iReport.iReportMask|= KNonXIPModeActive;

 		}

 	else

 		iReport.iReportMask|= KNoDebugSupport;	

 	iMarkedOnlySegments = ETrue;	

 	Kern::EndAccessCode();

 	DEBUG_PROFILER(Kern::Printf("RS end");)

 	return KErrNone;

 	}

 TInt DProfile::Reset(TBool aXIPOnly)

 	{

 //

 // Resets the device. It is the first message sent by profiler application.

 //	

 	if (Running())

 		return KErrGeneral;

 	DEBUG_PROFILER(Kern::Printf("RST %d", aXIPOnly);)

 	iXIPOnly = aXIPOnly;

 	iTimer.Cancel();

 	iDfc.Cancel();

 	iLast.iPC=0;

 	iLast.iSampleCounter=0;

 	iLast.iThreadId=0;

 	iRepeat=0;

 	iPeriod=1;

 	iReqStatus=NULL;

 	iRPut=0;				// raw buffer put index

 	iRGet=0;				// raw buffer get index

 	iCPut=EncodeTag(iCookedBuf,COOKEDBUFEND); //cooked buffer put

 	iCGet=iCookedBuf;		// cooked buffer get

 	iPos=0;					// client des pos

 	iDes=NULL;				// client des pointer

 	iStartTime=NKern::TickCount();

 	iReport.iRowBufferErrCounter = 0;

 	iReport.iCodeSegErrCounter = 0;

 	iReport.iReportMask = 0;

 	iNextSampleCounter = 0;

 	iCSPut=iCodeSegBuffer;	// CodeSeg buffer put

 	iCSGet=iCodeSegBuffer;	// CodeSeg buffer get

 	iMarkedOnlySegments = EFalse;

 	iIDFCSeenBefore = EFalse;

 	if (!iXIPOnly)

 		iKernelEvHandler = new DKernelEventHandler(KernelEventHandler, this);

 	DEBUG_PROFILER(Kern::Printf("RST end");)

 	return KErrNone;

 	}

 TInt DProfile::StopSampling()

 //

 // Stops sampling

 //

 	{

 	DEBUG_PROFILER(Kern::Printf("STOP");)

 	if (Running())

 		{

 		iTimer.Cancel();

 		Dfc(this);

 		}

 	if (iReqStatus)

 		Complete(KErrNone);

 	DEBUG_PROFILER(Kern::Printf("STOP end");)

 	return KErrNone;

 	}

 TInt DProfile::GetErrors(TDes8* aDes)

 //

 // Returns error report and closes event handler

 //

 	{

 	TInt r = KErrNone;

 	TBuf8<KMaxErrorReportRecordSize> localBuf; //Enough space to encode 3 zeros and 3 integers

 	DEBUG_PROFILER(Kern::Printf("GE");)

 	TInt max=Kern::ThreadGetDesMaxLength(iClient,aDes);

 	if (max<KMaxErrorReportRecordSize)

 		return KErrArgument;

 	Kern::ThreadDesWrite(iClient,aDes,KNullDesC8,0,0,iClient);//set zero length

 	TUint8* p = (TUint8*)localBuf.Ptr();

 	TUint8* e = p+KMaxErrorReportRecordSize;

 	p = EncodeInt (p, e, 0);

 	p = EncodeUint(p, e, 0);

 	p = EncodeUint(p, e, 0);

 	p = EncodeUint(p, e, iReport.iRowBufferErrCounter);

 	p = EncodeUint(p, e, iReport.iCodeSegErrCounter);

 	p = EncodeUint(p, e, iReport.iReportMask);

 	localBuf.SetLength(p-localBuf.Ptr());

 	r=Kern::ThreadDesWrite(iClient,aDes,localBuf,0,KChunkShiftBy0,iClient);

 	if(iKernelEvHandler && iKernelEvHandler->IsQueued())

 		iKernelEvHandler->Close();

 	DEBUG_PROFILER(Kern::Printf("GE end %d %d %d", iReport.iRowBufferErrCounter, iReport.iCodeSegErrCounter, iReport.iReportMask);)

 	return r;

 	}

 TInt DProfile::Drain(TDes8* aDes)

 //

 // Collects any remaining data

 //

 	{

 	DEBUG_PROFILER(Kern::Printf("D");)		

 	if (Running())

 		return KErrGeneral;

 	// we can assume read request is not pending

 	TInt max=Kern::ThreadGetDesMaxLength(iClient,aDes);

 	if (max<0)

 		return max;

 	if (max==0)

 		return KErrArgument;

 	TInt r=Kern::ThreadDesWrite(iClient,aDes,KNullDesC8,0,0,iClient);		// set client descriptor length to zero

 	if (r!=KErrNone)

 		return r;

 	iDes=aDes;

 	iRemain=max;

 	iPos=0;

 	iReqStatus=NULL;

 	TInt n=-1;

 	while (n)

 		{

 		r=DoDrainCooked();				// drain any cooked data if possible

 		if (r<0 && r!=KErrUnderflow)

 			return r;					// error writing client buffer

 		n=Cook();						// cook the samples, return number cooked

 		}

 	// there might still be data left over

 	DEBUG_PROFILER(Kern::Printf("D end");)

 	return KErrNone;

 	}

 TInt DProfile::ProcessReadRequest()

 	{

 // If the profiler is stopped and there is available data, return it immediately and complete the request

 // If the profiler is stopped and there is no data, wait.

 // If the profiler is running, retrieve any data available now, if more is req'd set the trigger

 	DEBUG_PROFILER(Kern::Printf("READ");)

 	TInt max=Kern::ThreadGetDesMaxLength(iClient,iDes);

 	if (max<0)

 		return max;

 	if (max==0)

 		return KErrArgument;

 	TInt r=Kern::ThreadDesWrite(iClient,iDes,KNullDesC8,0,0,iClient);		// set client descriptor length to zero

 	if (r!=KErrNone)

 		return r;

 	iRemain=max;

 	iPos=0;

 	TInt n=-1;

 	TBool read=EFalse;

 	while (n)

 		{

 		r=DoDrainCooked();				// drain any cooked data if possible

 		if (r!=KErrUnderflow)

 			read=ETrue;					// we've got something

 		if (r>0)

 			return KErrNone;			// request completed, so finish

 		if (r!=KErrNone && r!=KErrUnderflow)

 			return r;					// error writing client buffer

 		n=Cook();						// cook the samples, return number cooked

 		}

 	if (!Running() && read)

 		return KErrCompletion;			// if stopped and data read, return it

 	return KErrNone;					// wait

 	}

 TInt DProfile::DoDrainCooked()

 //

 // Copies encoded data from Cook buffer into user side descriptor (iDes).

 // Returns:

 // KErrUnderflow if all the data was already transfered or the desciptor was already full before the call.

 // KErrNone if there is still remaining space available in the descriptor.

 // 1  - descriptor is full and user request is completed.

 // Error code other then KErrNone if writing to the user memory fails

 //

 	{

 	TInt avail=iCPut-iCGet;

 	if (avail<0)

 		avail+=KCookedBufSize;

 	TInt len=Min(avail,iRemain);

 	if (len)

 		{

 		TUint8* pE=iCookedBuf+KCookedBufSize;

 		TInt len1=Min(len,pE-iCGet);

 		TPtrC8 local(iCGet,len1);

 		TInt r=Kern::ThreadDesWrite(iClient, iDes, local, iPos, KChunkShiftBy0, iClient);

 		if (r!=KErrNone)

 			return r;

 		len-=len1;

 		TUint8* pG=iCGet+len1;

 		if (pG==pE)

 			pG=iCookedBuf;

 		iCGet=pG;

 		iRemain-=len1;

 		iPos+=len1;

 		if (len) // will be > 0 if there are remaining data at the beginning of Cooked buffer to be copied.

 			{

 			TPtrC8 local(iCGet,len);

 			r=Kern::ThreadDesWrite(iClient, iDes, local, iPos, KChunkShiftBy0, iClient);

 			if (r!=KErrNone)

 				return r;

 			iCGet+=len;

 			iRemain-=len;

 			iPos+=len;

 			}

 		if (iRemain==0 && iReqStatus)

 			{

 			Complete(KErrNone);

 			return 1;

 			}

 		return KErrNone;

 		}

 	return KErrUnderflow;

 	}

 void DProfile::HandleMsg(TMessageBase* aMsg)

 //

 // Client requests

 //

 	{

 	TInt r=KErrNone;

 	TThreadMessage& m=*(TThreadMessage*)aMsg;

 	TInt id=m.iValue;

 	// Allow the client thread to send a message or system critical thread

 	// to send a close message as this is probably the supervisor thread doing clean up

 	if (m.Client()!=iClient && 

 		!((m.Client()->iFlags&KThreadFlagSystemCritical) && id==(TInt)ECloseMsg))

 		{

 		m.PanicClient(_L("SAMPLER"),EAccessDenied);

 		return;

 		}

 	if (id==(TInt)ECloseMsg)

 		{

 		DEBUG_PROFILER(Kern::Printf("CLOSE");)

 		iTimer.Cancel();

 		iDfc.Cancel();

 		m.Complete(KErrNone,EFalse);

 		iMsgQ.CompleteAll(KErrServerTerminated);

 		DEBUG_PROFILER(Kern::Printf("CLOSE end");)

 		return;

 		}

 	else if (id<0)

 		{

 		if (id!=~RSampler::ERequestRead)

 			{

 			TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

 			Kern::RequestComplete(iClient,pS,KErrNotSupported);

 			}

 		if (iReqStatus)

 			{

 			m.PanicClient(_L("SAMPLER"),ERequestAlreadyPending);

 			return;

 			}

 		iReqStatus=(TRequestStatus*)m.Ptr0();

 		iDes=(TDes8*)m.Ptr1();

 		r=ProcessReadRequest();

 		if (r!=KErrNone)

 			{

 			if (r==KErrCompletion)

 				r=KErrNone;

 			Complete(r);

 			}

 		r=KErrNone;

 		}

 	else if (id==KMaxTInt)

 		{

 		TInt mask=m.Int0();

 		if (mask & (1<<RSampler::ERequestRead))

 			{

 			Complete(KErrCancel);

 			}

 		}

 	else

 		{

 		switch(id)

 			{

 			case RSampler::EControlGetSegments:

 				r=GetSegments((TDes8*)m.Ptr0());

 				break;

 			case RSampler::EControlStartProfile:

 				r=StartSampling(m.Int0());

 				break;

 			case RSampler::EControlStopProfile:

 				r=StopSampling();

 				break;

 			case RSampler::EControlResetProfile:

 				r=Reset((TBool)m.Ptr0());

 				break;

 			case RSampler::EControlResetSegments:

 				r=ResetSegments();

 				break;

 			case RSampler::EControlDrain:

 				r=Drain((TDes8*)m.Ptr0());

 				break;

 			case RSampler::EControlGetErrors:

 				r=GetErrors((TDes8*)m.Ptr0());

 				break;

 			default:

 				r=KErrNotSupported;

 				break;

 			}

 		}

 	m.Complete(r,ETrue);

 	}

 TUint8* DProfile::EncodeTag(TUint8* p, TUint8* e)

 //

 // Encode a tag and version to the trace data. This allows the offline analyser to 

 // identify the sample data.

 //

 	{

 	_LIT(KTraceTag,"profile");

 	p=EncodeText(p,e,KTraceTag);

 	p=EncodeUint(p,e,KMajorVersionNumber);

 	return p;

 	}

 TUint8* DProfile::EncodeInt(TUint8* p, TUint8* e, TInt aValue)

 //

 // Encode a 32 bit signed integer into the data stream

 // This has to deal with wrap around at the end of the buffer

 //

 	{

 	TUint byte;

 	for (;;)

 		{

 		byte = aValue & 0x7f;

 		if ((aValue >> 6) == (aValue >> 7))

 			break;

 		aValue >>= 7;

 		PUT(p,(TUint8)byte,e,KCookedBufSize);

 		}

 	PUT(p,(TUint8)(byte|0x80),e,KCookedBufSize);

 	return p;

 	}

 TUint8* DProfile::EncodeUint(TUint8* p, TUint8* e, TUint aValue)

 //

 // Encode a 32 bit unsigned integer into the data stream

 // This has to deal with wrap around at the end of the buffer

 //

 	{

 	TUint byte;

 	for (;;)

 		{

 		byte = aValue & 0x7f;

 		aValue >>= 7;

 		if (aValue == 0)

 			break;

 		PUT(p,(TUint8)byte,e,KCookedBufSize);

 		}

 	PUT(p,(TUint8)(byte|0x80),e,KCookedBufSize);

 	return p;

 	}

 TUint8* DProfile::EncodeText(TUint8* p, TUint8* e, const TDesC& aDes)

 //

 // Encode a descriptor into the data stream

 // This is currently limited to a descriptor that is up to 255 characters in length,

 // and Unicode characters are truncated to 8 bits

 //

 	{

 	TInt len=aDes.Length();

 	PUT(p,(TUint8)len,e,KCookedBufSize);

 	const TText* s = aDes.Ptr();

 	while (--len >= 0)

 		PUT(p,*s++,e,KCookedBufSize);

 	return p;

 	}

 TUint8* DProfile::EncodeIDFC(TUint8* p, TUint8* e)

 //

 // iDFC samples do not really belong to any thread.

 // However, the profiler protocol requires each sample to be associated to a particular thread.

 // This method will encode 'fake' process ID & name and thread name for iDFC sample in the data stream.

 // It will be embedded only for the very first sample from iDFCs.

 // (For the rest of iDFCs samples, threadID is sufficient - as for the real threads.)

 //

 	{

 	p=EncodeUint(p,e,KiDFCId);     //processID for iDFC

 	p=EncodeText(p,e,KiDFCProcess);//process name for iDFC

 	p=EncodeText(p,e,KiDFCThread); //thread name for iDFC

 	return p;

 	}

 TUint8* DProfile::EncodeThread(TUint8* p, TUint8* e, DThread* aThread)

 //

 // Encode a thread name in the data stream.

 // The thread is identified by its name, and the identity of its owning process.

 // If the process has not been identified in the data stream already, it's name is

 // also encoded.

 //

 	{

 	DProcess* pP=aThread->iOwningProcess;

 	TKName n;

 	p=EncodeUint(p,e,pP->iId);

 	if (TAG(pP)!=iStartTime)	// not seen this before

 		{

 		TAG(pP)=iStartTime;

 		// Provide the name matching this process ID

 		pP->Name(n);

 		p=EncodeText(p,e,n);

 		}

 	aThread->Name(n);

 	p=EncodeText(p,e,n);

 	return p;

 	}

 TUint8* DProfile::EncodeRepeat(TUint8* p, TUint8* e, DProfile* aP)

 //

 // Encode a repeated sequence of samples

 //

 	{

 	p=EncodeInt(p,e,0);

 	p=EncodeUint(p,e,aP->iRepeat);

 	aP->iRepeat = 0;

 	return p;

 	}

 TInt DProfile::CookCodeSeg(TBool aPutAll, TInt aSampleCounter)

 //

 // Transfers and encodes CodeSeg Create/Delete records from CodeSeg buffer into Cooked buffer.

 // If aPutAll = Etrue, all records will be transferred.

 // If aPutAll = EFalse, only records at the beginning of the queue that matches aSampleCounter will be transferred.

 // It stopps if there is less then KRequiredFreeSpace bytes available in cooked buffer.

 // Returns the number of the transferred records.

 //

 	{

 	if (iXIPOnly)

 		return 0;

 	TInt n = 0;

 	TInt codeSampleCounter;//Will hold the sample counter of the record

 	TInt runAddress;

 	TInt codeSize;

 	TInt8 textLen;

 	TBuf<255> text;

 	TUint8* localCSGet = iCSGet;

 	FOREVER

 		{

 		//Check if there is any Code Seg record left.

 		if (iCSGet==iCSPut)

 			return n;//No records left

 		//Check if the next record is due to be encoded. Both Create & Delete CodeSeg records start with sample counter.

 		localCSGet = iCSGet;

 		localCSGet = GetStream(localCSGet, CODESEGBUFEND, (TInt8*)(&codeSampleCounter), sizeof(TInt));

 		if (!aPutAll && codeSampleCounter!=aSampleCounter)

 			return n; //Still too early to insert the record into Cook Buffer

 		//Check for the space in cook buffer

 		TInt cookAvailable = (TInt)iCGet - (TInt)iCPut;

 		if (cookAvailable <= 0)	

 			cookAvailable+=KCookedBufSize;

 		if (cookAvailable < KRequiredFreeSpace)

 			return n;//No space in Cook Buffer.

 		//At this point it is for sure that we have to transfer some record to cook buffer

 		n++;

 		iCSGet = localCSGet;

 		//The next field for both Create & Delete CodeSeg records is run address:

 		iCSGet = GetStream(iCSGet, CODESEGBUFEND, (TInt8*)(&runAddress), sizeof(TInt));

 		if (runAddress & 1)//LSB in run address idenifies the type of the record

 			{//CodeSegment Delete record. To be encoded as Int(0), UInt(0), UInt(RunAddress | 1)

 			iCPut = EncodeInt (iCPut, COOKEDBUFEND, 0);

 			iCPut = EncodeUint(iCPut, COOKEDBUFEND, 0);

 			iCPut = EncodeUint(iCPut, COOKEDBUFEND, runAddress);

 			}

 		else

 			{//CodeSegment Create record.

 			iCSGet = GetStream(iCSGet, CODESEGBUFEND, (TInt8*)(&codeSize), sizeof(TInt));

 			iCSGet = GetStream(iCSGet, CODESEGBUFEND, (TInt8*)(&textLen), sizeof(TInt8));

 			iCSGet = GetStream(iCSGet, CODESEGBUFEND, (TInt8*)(text.Ptr()), textLen);

 			text.SetLength(textLen);

 			//To be encoded as Int(0), UInt(0), UInt(RunAddress), UInt(SegmentSize), Text(FileNeme)

 			iCPut = EncodeInt(iCPut, COOKEDBUFEND, 0);

 			iCPut = EncodeUint(iCPut, COOKEDBUFEND, 0);

 			iCPut = EncodeUint(iCPut, COOKEDBUFEND, runAddress);

 			iCPut = EncodeUint(iCPut, COOKEDBUFEND, codeSize);

 			iCPut = EncodeText(iCPut, COOKEDBUFEND, text);

 			}

 		}

 	}

 TInt DProfile::Cook()

 //

 // Transfers/encodes row data and code segments record into cooked buffer.

 // Returns the number of records (incl. both samples and codeSeg records) cooked.

 //

 	{

 	TUint8* p=iCPut;

 	TUint8* e=iCookedBuf+KCookedBufSize;

 	TInt n=0;

 	FOREVER

 		{

 		iCPut=p; //update iCPut before calling CookCodeSeg

 		if ((iRGet==iRPut))

 			{//No more samples.

 			n+=CookCodeSeg(ETrue, 0); //Cook the remaining content of CodeSeg buffer.

 			break;

 			}

 		SRawSample* s=iRawBuf+iRGet;	// pointer to the next sample to be cooked

 		n+=CookCodeSeg(EFalse, s->iSampleCounter);//cook all codeSeg records than matches this sample counter

 		p=iCPut; //CookCodeSeg might have changed iCPut

 		TInt space=iCGet-p;

 		if (space<=0)

 			space+=KCookedBufSize;		// space remaining in cooked buffer

 		if (space<KRequiredFreeSpace)

 			break;						// if insufficient, finish

 		//Cook the next sample record from Row buffer		

 		++iRGet;

 		++n;

 		TBool newthread=s->iPC & 1;		// bit 0 of PC means so far unknown thread

 		TLinAddr pc=s->iPC &~ 1;

 		TUint rp = iRepeat;

 		TInt diff=TInt(pc-iLast.iPC);

 		if (!newthread)

 			{

 			if (s->iThreadId!=iLast.iThreadId)

 				diff|=1;

 			if (diff == 0)

 				{

 				iRepeat = rp + 1;	// Identical sample, bump up the repeat count

 				continue;

 				}

 			if (rp)

 				{

 				// Encode the repeat data

 				p = EncodeRepeat(p,e,this);

 				}

 			// Encode the PC difference

 			p = EncodeInt(p, e, diff);

 			if (diff & 1)

 				{

 				// Encode the new thread ID

 				iLast.iThreadId = s->iThreadId;

 				p = EncodeUint(p, e, s->iThreadId);

 				}

 			}

 		else

 			{

 			if (rp)

 				{

 				// Encode the repeat data

 				p = EncodeRepeat(p,e,this);

 				}

 			// Encode the PC difference

 			p = EncodeInt(p, e, diff|1);

 			if (s->iThreadId == KiDFCId)

 				{

 				// This is the first sample from iDFC. Encode 'threadID'

 				iLast.iThreadId = KiDFCId;

 				p = EncodeUint(p, e, KiDFCId);

 				// and encode processID, processName & threadName for this sample

 				p = EncodeIDFC(p, e);

 				}

 			else

 				{

 				// Encode the new thread ID

 				DThread* pT=(DThread*)s->iThreadId;

 				iLast.iThreadId = pT->iId;

 				p = EncodeUint(p, e, pT->iId);

 				// The thread is 'unknown' to this sample, so encode the thread name

 				p = EncodeThread(p, e, pT);

 				}

 			}

 		iLast.iPC=pc;

 		}

 	return n;

 	}

 void DProfile::Dfc(TAny* aPtr)

 //

 // Tranfers/encodes Row & CodeSeg buffers' content into Cook buffer (by Cook()), 

 // and copies encoded data into user side descriptor (by DoDrainCooked())

 //

 	{

 	DProfile& d=*(DProfile*)aPtr;

 	TInt n=-1;

 	while (n)

 		{

 		TInt r=d.DoDrainCooked();		// drain any cooked data if possible

 		if (r<0 && r!=KErrUnderflow)

 			{

 			d.Complete(r);				// error writing client buffer

 			break;

 			}

 		n=d.Cook();						// cook the samples, return number cooked

 		}

 	}

 TUint8* DProfile::PutStream(TUint8* p, TUint8* e, const TUint8* aSource, TInt aSize)

 //

 // Put data into CodeSeg stream 

 // This has to deal with wrap around at the end of the buffer

 //

 	{

 	for (TInt i = 0 ; i< aSize ; i++)

 		{

 		PUT(p,(TUint8)(*aSource),e,KCodeBufSize);

 		aSource++;

 		}

 	return p;

 	}

 TUint8* DProfile::GetStream(TUint8* p, TUint8* e, TInt8* aDest, TInt aSize)

 //

 // Get 32 bits from CodeSeg stream.

 // This has to deal with wrap around at the end of the buffer

 //

 	{

 	for (TInt i = 0 ; i< aSize ; i++)

 		GET_A_BYTE(p,aDest,e,KCodeBufSize);

 	return p;

 	}

 void DProfile::LogCodeSegEvent(TKernelEvent aEvent, DEpocCodeSeg *pCodeSeg)

 //

 // Records the event in CodeSeg buffer.

 //

 	{

 ///

 ///	

 	TUint8* localCSPut = iCSPut;

 	TInt available = KCodeBufSize + (TInt)iCSGet - (TInt)iCSPut;

 	if (available > KCodeBufSize)

 		available -= KCodeBufSize;

 	switch (aEvent)

 		{

 	case EEventAddCodeSeg:

 		{

 		TInt textOffset = 0;

 		TInt textSize= pCodeSeg->iFileName->Length();

 		//Restrict file name to max 255 sharacters. If bigger, record the last 255 bytes only

 		if (textSize > 255)

 			{

 			textOffset = textSize-255;

 			textSize = 255;

 			}

 		if ((available -= 13+textSize) < 0) //13 bytes needed for sample counter, run address, size and text size) 

 			{

 			iReport.iCodeSegErrCounter++;

 			return;

 			}

 		localCSPut = PutStream(localCSPut, CODESEGBUFEND, (TUint8*)(&iNextSampleCounter), sizeof(TInt));

 		localCSPut = PutStream(localCSPut, CODESEGBUFEND, (TUint8*)(&pCodeSeg->iRunAddress), sizeof(TInt));

 		localCSPut = PutStream(localCSPut, CODESEGBUFEND, (TUint8*)(&pCodeSeg->iSize), sizeof(TInt));

 		localCSPut = PutStream(localCSPut, CODESEGBUFEND, (TUint8*)(&textSize), sizeof(TInt8));

 		localCSPut = PutStream(	localCSPut, CODESEGBUFEND, pCodeSeg->iFileName->Ptr()+textOffset, textSize);

 		iCSPut = localCSPut;

 		DEBUG_PROFILER

 			(

 			TBuf<256> buf(textSize+1);

 			buf.Copy(pCodeSeg->iFileName->Ptr()+textOffset,textSize); buf.SetLength(textSize+1); buf[textSize]=0;

 			Kern::Printf("CREATE CS:%s, %x, %x,", buf.Ptr(), pCodeSeg->iRunAddress, pCodeSeg->iSize);

 			)

 		break;

 		}

 	case EEventRemoveCodeSeg:

 		{

 		if ((available-=8) < 0) //8 bytes needed for sample counter and run address

 			{

 			iReport.iCodeSegErrCounter++;

 			return;

 			}

 		TInt runAddress = pCodeSeg->iRunAddress | 1; 

 		localCSPut = PutStream(localCSPut, CODESEGBUFEND, (TUint8*)(&iNextSampleCounter), sizeof(TInt));

 		localCSPut = PutStream(localCSPut, CODESEGBUFEND, (TUint8*)(&runAddress), sizeof(TInt));

 		iCSPut = localCSPut;

 		DEBUG_PROFILER(Kern::Printf("DELETE CS:%x", pCodeSeg->iRunAddress);)

 		break;

 		}

 	default:

 		return;

 	}

 	if (available < KCodeBufSize/2) //Start emptying CodeSeg (and Raw Buffer, as well) Buffer if more then a half full.

 		iDfc.Enque();

 }

 TUint DProfile::KernelEventHandler(TKernelEvent aEvent, TAny* a1, TAny* a2, TAny* aPrivateData)

 //

 // Logs non-XIP CodeSeg Create/Delete events.

 // In GettingSegments mode, it logs only deletion of the marked segments.

 // Runs in the content of the Kernel scheduler

 //

 {

 	if (aEvent==EEventAddCodeSeg || aEvent==EEventRemoveCodeSeg) 

 	{

 		DProfile *p = (DProfile*)aPrivateData;

 		DEpocCodeSeg* pCodeSeg = (DEpocCodeSeg*)(DCodeSeg*)a1;

 		Kern::AccessCode();

 		if ((!pCodeSeg->iXIP) && (!p->iMarkedOnlySegments || pCodeSeg->iMark&DCodeSeg::EMarkProfilerTAG))

 			p->LogCodeSegEvent(aEvent, pCodeSeg);

 		Kern::EndAccessCode();

 	}

 	return DKernelEventHandler::ERunNext;

 }

 void DProfile::Sample(TAny* aPtr)

 	{

 	DProfile& d=*(DProfile*)aPtr;

 	d.iTimer.Again(d.iPeriod);

 	TUint8 next_put=(TUint8)(d.iRPut+1);

 	if (next_put!=d.iRGet)		// space in raw buffer

 		{

 		DThread* pT=Kern::NThreadToDThread(NKern::CurrentThread());

 		if (pT!=NULL)

 			{

 			SRawSample* p=d.iRawBuf+d.iRPut;

 			d.iRPut=next_put;

 			p->iPC=((d.iIntStackTop)[-1]) & ~1; //clear LSB bit (in case of Jazelle code)

 			p->iSampleCounter=d.iNextSampleCounter++;

 			if (IDFCRunning())

 				{

 				p->iThreadId=KiDFCId; //indicates iDFC running

 				if (!d.iIDFCSeenBefore)

 					{

 					d.iIDFCSeenBefore = ETrue;

 					p->iPC|=1;				// set bit 0 of PC to indicate new thread

 					}

 				else

 					{

 					TUint8 used=(TUint8)(d.iRPut-d.iRGet);

 					if (used<=KRawBufSize/2)

 						return;

 					}

 				}

 			else

 				{

 				if (TAG(pT)!=d.iStartTime)	// not seen this before

 					{

 					TAG(pT)=d.iStartTime;

 					p->iThreadId=(TUint)pT;

 					p->iPC|=1;				// set bit 0 of PC to indicate new thread

 					}

 				else

 					{

 					p->iThreadId=pT->iId;

 					TUint8 used=(TUint8)(d.iRPut-d.iRGet);

 					if (used<=KRawBufSize/2)

 						return;

 					}

 				}

 			d.iDfc.Add();	// queue DFC if new thread seen or buffer more than half full

 			}

 		}

 	else

 		d.iReport.iRowBufferErrCounter++;

 	}