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

 	}