// Copyright (c) 2002-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:

// e32test\debug\d_schedhook.cpp

// 

//

#include <kernel/kernel.h>

#include <kernel/kern_priv.h>

#include "platform.h"

#include <kernel/cache.h>

#include <arm.h>

#include "d_schedhook.h"

_LIT(KLddName,"D_SCHEDHOOK");

NThread* TestThread;

TInt TestCount;

const TInt KMajorVersionNumber = 0;

const TInt KMinorVersionNumber = 1;

const TInt KBuildVersionNumber = 1;

class DSchedhookTest;

class DSchedhookTestFactory : public DLogicalDevice

	{

public:

	DSchedhookTestFactory();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	};

class DHwExcHandler : public DKernelEventHandler

	{

public:

	DHwExcHandler() : DKernelEventHandler(HandleEvent, this) {}

private:

	static TUint HandleEvent(TKernelEvent aEvent, TAny* a1, TAny* a2, TAny* aThis);

	};

class DSchedhookTest : public DLogicalChannelBase

	{

public:

	virtual ~DSchedhookTest();

protected:

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

	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

public:

	DHwExcHandler* iHwExcHandler;

	};

DECLARE_STANDARD_LDD()

	{

	return new DSchedhookTestFactory;

	}

//

// DSchedhookTestFactory

//

DSchedhookTestFactory::DSchedhookTestFactory()

	{

	iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

	}

TInt DSchedhookTestFactory::Create(DLogicalChannelBase*& aChannel)

/**

 Create a new DSchedhookTest on this logical device

*/

	{

	aChannel=new DSchedhookTest;

	return aChannel ? KErrNone : KErrNoMemory;

	}

TInt DSchedhookTestFactory::Install()

/**

 Install the LDD - overriding pure virtual

*/

	{

	return SetName(&KLddName);

	}

void DSchedhookTestFactory::GetCaps(TDes8& aDes) const

/**

 Get capabilities - overriding pure virtual

*/

	{

	TCapsTestV01 b;

	b.iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));

	}

//

// DHwExcHandler

//

/**

 Handle exceptions on our test thread by suspending it

*/

TUint DHwExcHandler::HandleEvent(TKernelEvent aEvent, TAny* a1, TAny* /*a2*/, TAny* /*aThis*/)

	{

	if (aEvent == EEventHwExc)

		{

		if(&Kern::CurrentThread().iNThread!=TestThread)

			return ERunNext;

		TArmExcInfo *pR=(TArmExcInfo*)a1;

		pR->iR15+=4;

		Kern::ThreadSuspend(Kern::CurrentThread(),1);

		return (TUint)EExcHandled;

		}

	return (TUint)ERunNext;

	}

//

// DSchedhookTest

//

TInt DSchedhookTest::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)

/**

 Create channel

*/

	{

	if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))

		return KErrNotSupported;

	iHwExcHandler = new DHwExcHandler;

	if (! iHwExcHandler)

		return KErrNoMemory;

	return iHwExcHandler->Add();

	}

DSchedhookTest::~DSchedhookTest()

	{

	if (iHwExcHandler)

		iHwExcHandler->Close();

	}

//

// Scheduler Hook functions

//

NThread* CurrentThread=NULL;

void DisableRescheduleCallback()

/**

 Stops the Scheduler calling us on every context switch

*/

	{

	// Prevent rescheduling whilst we disable the callback

	NKern::Lock();

	// Disable Callback

	NKern::SetRescheduleCallback(NULL);

	// Invalidate CurrentThread

	CurrentThread = NULL;

	// Callback now disabled...

	NKern::Unlock();

	}

void RemoveSchedulerHooks()

/**

 Removes the patches added to the Scheduler code.

*/

	{

	// Make sure callback is disabled (required before removing hooks)

	DisableRescheduleCallback();

	// Get range of memory used by hooks

	TLinAddr start,end;

	NKern::Lock();

	NKern::SchedulerHooks(start,end);

	NKern::Unlock();

	// Free shadow pages which cover hooks

	TUint32 pageSize=Kern::RoundToPageSize(1);

	NKern::ThreadEnterCS();

	for(TLinAddr a=start; a<end; a+=pageSize)

		Epoc::FreeShadowPage(a);   // Ignore errors because we're trying to clean up anyway

	NKern::ThreadLeaveCS();

	}

TInt InsertSchedulerHooks()

/**

 Enables use of the Scheduler callback by using shadow pages to patch the Scheduler code.

*/

	{

	// Get range of memory used by hooks	

	TLinAddr start=0,end=0;

	NKern::Lock();

	NKern::SchedulerHooks(start,end);

	NKern::Unlock();

	if (start==0 && end==0) return KErrNotSupported;

	// Create shadow pages for hooks

	TUint32 pageSize=Kern::RoundToPageSize(1);

	for(TLinAddr a=start; a<end; a+=pageSize)

		{

		NKern::ThreadEnterCS();

		TInt r=Epoc::AllocShadowPage(a);

		NKern::ThreadLeaveCS();

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

			{

			RemoveSchedulerHooks();

			return r;

			}

		}

	// Put hooks in

	NKern::Lock();

	NKern::InsertSchedulerHooks();

	NKern::Unlock();

	// Make I and D caches consistant for hook region

	Cache::IMB_Range(start,end-start);

	return KErrNone;

	}

void RescheduleTestFunction()

/**

 Test function to be called on each thread reschedule

*/

	{

	// Count rechedules to the test thread

	if(CurrentThread==TestThread)

		++TestCount;

	}

void RescheduleCallback(NThread* aNThread)

/**

 Main scheduler callback.

 Called with the Kernel Lock (Preemption Lock) held.

*/

	{

#ifndef __SMP__

	// The 'CurrentThread' is now unscheduled and has become the 'previous thread'

	// Set this thread 'UserContextType'...

	CurrentThread->SetUserContextType();

#endif

	// Make the newly scheduled thread the CurrentThread

	CurrentThread = aNThread;

	// Test function

	RescheduleTestFunction();

	}

void RescheduleCallbackFirst(NThread* aNThread)

/**

 Scheduler callback used once for initialisation.

 Called with the Kernel Lock (Preemption Lock) held.

*/

	{

	// Initialise CurrentThread

	CurrentThread = aNThread;

	// Switch future callbacks to the main RescheduleCallback

	NKern::SetRescheduleCallback(RescheduleCallback);

	// Test function

	RescheduleTestFunction();

	}

void EnableRescheduleCallback()

/**

 Sets the Scheduler to call us back on every thread reschedule

*/

	{

	// Reset the User Context Type for all threads, because these values

	// will be out-of-date. (It is our Rescheduler callback which set's them.

	// and we're just about enable that.)

	NKern::ThreadEnterCS();  // Prevent us from dying or suspending whilst holding a DMutex

	DObjectCon& threads=*Kern::Containers()[EThread];  // Get containing holding threads

	threads.Wait();  // Obtain the container mutex so the list does get changed under us

#ifndef __SMP__

	// For each thread...

	TInt c=threads.Count();

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

		((DThread*)threads[i])->iNThread.ResetUserContextType();

#endif

	threads.Signal();  // Release the container mutex

	NKern::ThreadLeaveCS();  // End of critical section

	// Ask for callback

	NKern::SetRescheduleCallback(RescheduleCallbackFirst);

	}

TInt GetThreadUserContext(NThread* aThread,TArmRegSet& aContext)

/**

 Test function to get a threads User Context

*/

	{

	// Get the User Context Type which our Reschedule hook set

	TInt type = aThread->iSpare3; /*iUserContextType*/

	// Get the table corresponding to the User Context Type

	const TArmContextElement* c = NThread::UserContextTables()[type];

	// Set the User Context by using the table we got

	TUint32* sp  = (TUint32*)aThread->iSavedSP;

	TUint32* st  = (TUint32*)((TUint32)aThread->iStackBase+(TUint32)aThread->iStackSize);

	TArmReg* out = (TArmReg*)(&aContext);

	TArmReg* end = (TArmReg*)(&aContext+1);

	do

		{

		TInt v = c->iValue;

		TInt t = c->iType;

		++c;

		if(t==TArmContextElement::EOffsetFromSp)

			v = sp[v];

		else if(t==TArmContextElement::EOffsetFromStackTop)

			v = st[-v];

		*out++ = v;

		}

	while(out<end);

	return type;

	}

void DumpContext(TArmRegSet& aContext,TInt aType)

	{

	Kern::Printf("  Context type %d",aType);

	Kern::Printf("  r0 =%08x r1 =%08x r2 =%08x r3 =%08x",aContext.iR0,aContext.iR1,aContext.iR2,aContext.iR3);

	Kern::Printf("  r4 =%08x r5 =%08x r6 =%08x r7 =%08x",aContext.iR4,aContext.iR5,aContext.iR6,aContext.iR7);

	Kern::Printf("  r8 =%08x r9 =%08x r10=%08x r11=%08x",aContext.iR8,aContext.iR9,aContext.iR10,aContext.iR11);

	Kern::Printf("  r12=%08x r13=%08x r14=%08x r15=%08x",aContext.iR12,aContext.iR13,aContext.iR14,aContext.iR15);

	Kern::Printf("  cpsr=%08x dacr=%08x",aContext.iFlags, aContext.iDacr);

	}

TInt TestGetThreadContext(DThread* aThread,TDes8* aContext)

	{

	TArmRegSet context1;

	TArmRegSet context2;

	memclr(&context1,sizeof(context1));

	memclr(&context2,sizeof(context2));

	NKern::Lock();

	TUint32 unused;

	NKern::ThreadGetUserContext(&aThread->iNThread,&context1,unused);

	TInt r=GetThreadUserContext(&aThread->iNThread,context2);

	NKern::Unlock();

	DumpContext(context1,-1);

	DumpContext(context2,r);

	TInt len,maxLen;

	Kern::KUDesInfo(*aContext,len,maxLen);

	if(maxLen>KMaxThreadContext)

		maxLen = KMaxThreadContext;

	TPtr8 ptr((TUint8*)&context1,maxLen,maxLen);

	Kern::KUDesPut(*aContext,ptr);

	for(TUint i=0; i<sizeof(context1); i++)

		if(((TUint8*)&context1)[i]!=((TUint8*)&context2)[i])

			return KErrGeneral;

	return r;

	}

DThread* ThreadFromId(TUint aId)

	{

	// This is risky because the thread could die on us an the DThread* become invalid.

	// We are relying on this never happening in our test code.

	NKern::ThreadEnterCS();  // Prevent us from dying or suspending whilst holding a DMutex

	DObjectCon& threads=*Kern::Containers()[EThread];  // Get containing holding threads

	threads.Wait();  // Obtain the container mutex so the list does get changed under us

	DThread* thread = Kern::ThreadFromId(aId);

	threads.Signal();  // Release the container mutex

	NKern::ThreadLeaveCS();  // End of critical section

	return thread;

	}

TInt DSchedhookTest::Request(TInt aFunction, TAny* a1, TAny* a2)

/**

 Handle requests from the test program

*/

	{

	TInt r=KErrNone;

	switch (aFunction)

		{

		case RSchedhookTest::EInstall:

			r=InsertSchedulerHooks();

			break;

		case RSchedhookTest::EUninstall:

			RemoveSchedulerHooks();

			return KErrNone;

		case RSchedhookTest::EInsertHooks:

			{

			NKern::Lock();

			NKern::InsertSchedulerHooks();

			TLinAddr start,end;

			NKern::SchedulerHooks(start,end);

			NKern::Unlock();

			Cache::IMB_Range(start,end-start);

			}

			return KErrNone;

		case RSchedhookTest::ERemoveHooks:

			{

			NKern::Lock();

			NKern::SetRescheduleCallback(NULL);

			NKern::RemoveSchedulerHooks();

			TLinAddr start,end;

			NKern::SchedulerHooks(start,end);

			NKern::Unlock();

			Cache::IMB_Range(start,end-start);

			}

			return KErrNone;

		case RSchedhookTest::EEnableCallback:

			NKern::Lock();

			NKern::SetRescheduleCallback(RescheduleCallbackFirst);

			NKern::Unlock();

			return KErrNone;

		case RSchedhookTest::EDisableCallback:

			DisableRescheduleCallback();

			return KErrNone;

		case RSchedhookTest::ESetTestThread:

			{

			NKern::ThreadEnterCS();  // Prevent us from dying or suspending whilst holding a DMutex

			DObjectCon& threads=*Kern::Containers()[EThread];  // Get containing holding threads

			threads.Wait();  // Obtain the container mutex so the list does get changed under us

			TestThread = &ThreadFromId((TUint)a1)->iNThread;

			threads.Signal();  // Release the container mutex

			NKern::ThreadLeaveCS();  // End of critical section

			TestCount = 0;

			}

			break;

		case RSchedhookTest::EGetThreadContext:

			return TestGetThreadContext(ThreadFromId((TUint)a1),(TDes8*)a2);

		case RSchedhookTest::EGetTestCount:

			return TestCount;

		default:

			r=KErrNotSupported;

			break;

		}

	return r;

	}