// 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