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

 // e32\nkern\win32\ncthrd.cpp

 // 

 //

 // NThreadBase member data

 #define __INCLUDE_NTHREADBASE_DEFINES__

 #include "nk_priv.h"

 #include <emulator.h>

 extern "C" void ExcFault(TAny*);

 // initial Win32 thread stack size

 const TInt KInitialStackSize = 0x1000;

 // maximum size of the parameter block passed to a new thread

 const TInt KMaxParameterBlock = 512;

 // data passed to new thread to enable hand-off of the parameter block

 struct SCreateThread

 	{

 	const SNThreadCreateInfo* iInfo;

 	NFastMutex iHandoff;

 	};

 /**

  * Set the Win32 thread priority based on the thread type.

  * Interrupt/Event threads must be able to preempt normal nKern threads,

  * so they get a higher priority.

  */

 static void SetPriority(HANDLE aThread, TEmulThreadType aType)

 	{

 	TInt p;

 	switch (aType)

 		{

 	default:

 		FAULT();

 	case EThreadEvent:

 		p = THREAD_PRIORITY_ABOVE_NORMAL;

 		break;

 	case EThreadNKern:

 		p = THREAD_PRIORITY_NORMAL;

 		break;

 		}

 	__NK_ASSERT_ALWAYS(SetThreadPriority(aThread, p));

 	SetThreadPriorityBoost(aThread, TRUE);		// disable priority boost (for NT)

 	}

 /**	Create a Win32 thread for use in the emulator.

 	@param	aType Type of thread (Event or NKern) - determines Win32 priority

 	@param	aThreadFunc Entry point of thread

 	@param	aPtr Argument passed to entry point

 	@param	aRun TRUE if thread should be resumed immediately

 	@return	The Win32 handle to the thread, 0 if an error occurred

 	@pre    Call either in thread context.

 	@pre	Do not call from bare Win32 threads.

 	@see TEmulThreadType

  */

 EXPORT_C HANDLE CreateWin32Thread(TEmulThreadType aType, LPTHREAD_START_ROUTINE aThreadFunc, LPVOID aPtr, TBool aRun)

 	{

 	__NK_ASSERT_DEBUG(!TheScheduler.iCurrentThread || NKern::CurrentContext() == NKern::EThread);

 	__LOCK_HOST;

 	DWORD id;

 	HANDLE handle = CreateThread(NULL , KInitialStackSize, aThreadFunc, aPtr, CREATE_SUSPENDED, &id);

 	if (handle)

 		{

 		SetPriority(handle, aType);

 		if (aRun)

 			ResumeThread(handle);

 		}

 	return handle;

 	}

 /** Set some global properties of the emulator

 	Called by the Win32 base port during boot.

 	@param	aTrace TRUE means trace Win32 thread ID for every thread created

 	@param	aSingleCpu TRUE means lock the emulator process to a single CPU

 	@internalTechnology

  */

 EXPORT_C void NThread::SetProperties(TBool aTrace, TInt aSingleCpu)

 	{

 	Win32TraceThreadId = aTrace;

 	Win32SingleCpu = aSingleCpu;

 	}

 #if defined(__CW32__) && __MWERKS__ < 0x3200

 DWORD NThread__ExceptionHandler(EXCEPTION_RECORD* aException, TAny* /*aRegistrationRecord*/, CONTEXT* aContext)

 //

 // Hook into exception handling for old version of CW

 //

 	{

 	return NThread::ExceptionHandler(aException, aContext);

 	}

 #endif // old __CW32__

 DWORD WINAPI NThread::StartThread(LPVOID aParam)

 //

 // Win32 thread function for nKern threads.

 //

 // The thread first enters this function after the nScheduler has resumed

 // it, following the context switch induced by the hand-off mutex.

 //

 // The parameter block for this thread needs to be copied into its

 // own context, before releasing the mutex and handing control back to

 // the creating thread.

 //

 	{

 	SCreateThread* init = static_cast<SCreateThread*>(aParam);

 	NThread& me=*static_cast<NThread*>(init->iHandoff.iHoldingThread);

 	me.iWinThreadId = GetCurrentThreadId();

 	SchedulerRegister(me);

 #ifdef BTRACE_FAST_MUTEX

 	BTraceContext4(BTrace::EFastMutex,BTrace::EFastMutexWait,&init->iHandoff);

 #endif

 	NKern::Unlock();

 #if defined(__CW32__) && __MWERKS__ < 0x3200

 	// intercept the win32 exception mechanism manually

     asm {

     	push	ebp

     	mov		eax, -1

     	push	eax

     	push	eax

     	push	offset NThread__ExceptionHandler

     	push	fs:[0]

     	mov		fs:[0], esp

 		// realign the stack

     	sub		esp, 0x20

     	and		esp, ~0x1f

 		}

 #else // ! old __CW32__

 	// intercept win32 exceptions in a debuggabble way

 __try {

 #endif // old __CW32__

 	// save the thread entry point and parameter block

 	const SNThreadCreateInfo& info = *init->iInfo;

 	TUint8 parameterBlock[KMaxParameterBlock];

 	TAny* parameter=(TAny*)info.iParameterBlock;

 	if (info.iParameterBlockSize)

 		{

 		__NK_ASSERT_DEBUG(TUint(info.iParameterBlockSize)<=TUint(KMaxParameterBlock));

 		parameter=parameterBlock;

 		memcpy(parameterBlock,info.iParameterBlock,info.iParameterBlockSize);

 		}

 	NThreadFunction threadFunction=info.iFunction;

 	// Calculate stack base

 	me.iUserStackBase = (((TLinAddr)&parameterBlock)+0xfff)&~0xfff; // base address of stack

 	// some useful diagnostics for debugging

 	if (Win32TraceThreadId)

 		KPrintf("Thread %T created @ 0x%x - Win32 Thread ID 0x%x",init->iHandoff.iHoldingThread,init->iHandoff.iHoldingThread,GetCurrentThreadId());

 #ifdef MONITOR_THREAD_CPU_TIME

 	me.iLastStartTime = 0;  // Don't count NThread setup in cpu time

 #endif

 	// start-up complete, release the handoff mutex, which will re-suspend us

 	NKern::FMSignal(&init->iHandoff);

 	// thread has been resumed: invoke the thread function

 	threadFunction(parameter);

 #if !defined(__CW32__) || __MWERKS__ >= 0x3200

 	// handle win32 exceptions

 } __except (ExceptionFilter(GetExceptionInformation())) {

 	// Do nothing - filter does all the work and hooks

 	// into EPOC h/w exception mechanism if necessary

 	// by thread diversion

 }

 #endif // !old __CW32__

 	NKern::Exit();

 	return 0;

 	}

 static HANDLE InitThread()

 //

 // Set up the initial thread and return the thread handle

 //

 	{

 	HANDLE p = GetCurrentProcess();

 	HANDLE me;

 	__NK_ASSERT_ALWAYS(DuplicateHandle(p, GetCurrentThread(), p, &me, 0, FALSE, DUPLICATE_SAME_ACCESS));

 	SetPriority(me, EThreadNKern);

 	return me;

 	}

 TInt NThread::Create(SNThreadCreateInfo& aInfo, TBool aInitial)

 	{

 	iWinThread = NULL;

 	iWinThreadId = 0;

 	iScheduleLock = NULL;

 	iInKernel = 1;

 	iDivert = NULL;

 	iWakeup = aInitial ? ERelease : EResumeLocked;	// mark new threads as created (=> win32 suspend)

 	TInt r=NThreadBase::Create(aInfo,aInitial);

 	if (r!=KErrNone)

 		return r;

 	// the rest has to be all or nothing, we must complete it

 	iScheduleLock = CreateEventA(NULL, FALSE, FALSE, NULL);

 	if (iScheduleLock == NULL)

 		return Emulator::LastError();

 	if (aInitial)

 		{

 		iWinThread = InitThread();

 		FastCounterInit();

 #ifdef MONITOR_THREAD_CPU_TIME

 		iLastStartTime = NKern::FastCounter();

 #endif

 		iUserStackBase = (((TLinAddr)&r)+0xfff)&~0xfff; // base address of stack

 		SchedulerInit(*this);

 		return KErrNone;

 		}

 	// create the thread proper

 	//

 	SCreateThread start;

 	start.iInfo = &aInfo;

 	iWinThread = CreateWin32Thread(EThreadNKern, &StartThread, &start, FALSE);

 	if (iWinThread == NULL)

 		{

 		r = Emulator::LastError();

 		CloseHandle(iScheduleLock);

 		return r;

 		}

 #ifdef BTRACE_THREAD_IDENTIFICATION

 	BTrace4(BTrace::EThreadIdentification,BTrace::ENanoThreadCreate,this);

 #endif

 	// switch to the new thread to hand over the parameter block

 	NKern::Lock();

 	ForceResume();	// mark the thread as ready

 	// give the thread ownership of the handoff mutex

 	start.iHandoff.iHoldingThread = this;

 	iHeldFastMutex = &start.iHandoff;

 	Suspend(1);		// will defer as holding a fast mutex (implicit critical section)

 	// do the hand-over

 	start.iHandoff.Wait();

 	start.iHandoff.Signal();

 	NKern::Unlock();

 	return KErrNone;

 	}

 void NThread__HandleException(TWin32ExcInfo aExc)

 //

 // Final stage NKern exception handler.

 //

 // Check for a fatal exception when the kernel is locked

 //

 // Note that the parameter struct is passed by value, this allows for

 // direct access to the exception context created on the call stack by

 // NThread::Exception().

 //

 	{

 	if (TheScheduler.iKernCSLocked)

 		ExcFault(&aExc);

 	// Complete the exception data. Note that the call to EnterKernel() in

 	// ExceptionFilter() will have incremented iInKernel after the exception

 	// occurred.

 	NThread* me = static_cast<NThread*>(TheScheduler.iCurrentThread);

 	__NK_ASSERT_DEBUG(me->iInKernel);

 	aExc.iFlags = me->iInKernel == 1 ? 0 : TWin32ExcInfo::EExcInKernel;

 	aExc.iHandler = NULL;

 	// run NThread exception handler in 'kernel' mode

 	me->iHandlers->iExceptionHandler(&aExc, me);

 	LeaveKernel();

 	// If a 'user' handler is set by the kernel handler, run it

 	if (aExc.iHandler)

 		aExc.iHandler(aExc.iParam[0], aExc.iParam[1]);

 	}

 void NKern__Unlock()

 //

 // CW asm ICE workaround

 //

 	{

 	NKern::Unlock();

 	}

 __NAKED__ void NThread::Exception()

 //

 // Trampoline to nKern exception handler

 // must preserve all registers in the structure defined by TWin32Exc

 //

 	{

 	// this is the TWin32Exc structure

 	__asm push Win32ExcAddress			// save return address followed by EBP first to help debugger

 	__asm push ebp

 	__asm mov ebp, esp

 	__asm push cs

 	__asm pushfd

 	__asm push gs

 	__asm push fs

 	__asm push es

 	__asm push ds

 	__asm push ss

 	__asm push edi

 	__asm push esi

 	__asm lea esi, [ebp+8]

 	__asm push esi		// original esp

 	__asm push ebx

 	__asm push edx

 	__asm push ecx

 	__asm push eax

 	__asm push Win32ExcDataAddress

 	__asm push Win32ExcCode

 	__asm sub esp, 20	// struct init completed by NThread__HandleException()

 	__asm call NKern__Unlock

 	__asm call NThread__HandleException

 	__asm add esp, 28

 	__asm pop eax

 	__asm pop ecx

 	__asm pop edx

 	__asm pop ebx

 	__asm pop esi		// original ESP - ignore

 	__asm pop esi

 	__asm pop edi

 	__asm pop ebp		// original SS - ignore

 	__asm pop ds

 	__asm pop es

 	__asm pop fs

 	__asm pop gs

 	__asm popfd

 	__asm pop ebp		// original CS - ignore

 	__asm pop ebp

 	__asm ret

 	}

 LONG WINAPI NThread::ExceptionFilter(EXCEPTION_POINTERS* aExc)

 //

 // Filter wrapper for main Win32 exception handler

 //

 	{

 	LONG ret = EXCEPTION_CONTINUE_SEARCH;

 	switch (ExceptionHandler(aExc->ExceptionRecord, aExc->ContextRecord))

 		{

 		case ExceptionContinueExecution:

 			{

 			ret = EXCEPTION_CONTINUE_EXECUTION;

 			}

 			break;

 		case ExceptionContinueSearch:

 		default:

 			{

 			}

 			break;

 		}

 	return ret;

 	}

 // From e32/commmon/win32/seh.cpp

 extern DWORD CallFinalSEHHandler(EXCEPTION_RECORD* aException, CONTEXT* aContext);

 extern void DivertHook();

 DWORD NThread::ExceptionHandler(EXCEPTION_RECORD* aException, CONTEXT* aContext)

 //

 // Win32 exception handler for EPOC threads

 //

 	{

 	if (aException->ExceptionCode == EXCEPTION_BREAKPOINT)

 		{

 		// Hardcoded breakpoint

 		//

 		// Jump directly to NT's default unhandled exception handler which will

 		// either display a dialog, directly invoke the JIT debugger or do nothing

 		// dependent upon the AeDebug and ErrorMode registry settings.

 		//

 		// Note this handler is always installed on the SEH chain and is always

 		// the last handler on this chain, as it is installed by NT in kernel32.dll

 		// before invoking the Win32 thread function.

 		return CallFinalSEHHandler(aException, aContext);

 		}

 	// deal with conflict between preemption and diversion

 	// the diversion will have been applied to the pre-exception context, not

 	// the current context, and thus will get 'lost'. Wake-up of a pre-empted

 	// thread with a diversion will not unlock the kernel, so need to deal with

 	// the possibility that the kernel may be locked if a diversion exists

 	NThread& me = *static_cast<NThread*>(TheScheduler.iCurrentThread);

 	if (me.iDiverted && me.iDivert)

 		{

 		// The thread is being forced to exit - run the diversion outside of Win32 exception handler

 		__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 1);

 		aContext->Eip = (TUint32)&DivertHook;

 		}

 	else

 		{

 		if (me.iDiverted)

 			{

 			// The thread is being prodded to pick up its callbacks.  This will happen when the

 			// exception handler calls LeaveKernel(), so we can remove the diversion

 			__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 1);

 			if (aException->ExceptionAddress == &DivertHook)

 				aException->ExceptionAddress = me.iDivertReturn;

 			me.iDiverted = EFalse;

 			me.iDivertReturn = NULL;

 			EnterKernel(FALSE);

 			}

 		else

 			{

 			EnterKernel();

 			TheScheduler.iKernCSLocked = 1;	// prevent pre-emption

 			}

 		// If the kernel was already locked, this will be detected in the next stage handler

 		// run 2nd stage handler outside of Win32 exception context

 		Win32ExcAddress = aException->ExceptionAddress;

 		Win32ExcDataAddress = (TAny*)aException->ExceptionInformation[1];

 		Win32ExcCode = aException->ExceptionCode;

 		aContext->Eip = (TUint32)&Exception;

 		}

 	return ExceptionContinueExecution;

 	}

 void NThread::Diverted()

 //

 // Forced diversion go through here, in order to 'enter' the kernel

 //

 	{

 	NThread& me = *static_cast<NThread*>(TheScheduler.iCurrentThread);

 	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 1);

 	__NK_ASSERT_ALWAYS(me.iDiverted);

 	NThread::TDivert divert = me.iDivert;

 	me.iDiverted = EFalse;

 	me.iDivert = NULL;

 	me.iDivertReturn = NULL;

 	EnterKernel(FALSE);

 	if (divert)

 		divert();	// does not return

 	NKern::Unlock();

 	LeaveKernel();

 	}

 void NThread__Diverted()

 	{

 	NThread::Diverted();

 	}

 __NAKED__ void DivertHook()

 	{

 	// The stack frame is set up like this:

 	//

 	//		| return address |

 	//		| frame pointer  |

 	//		| flags			 |

 	//		| saved eax		 |

 	//		| saved ecx		 |

 	//      | saved edx		 |

 	//		

 	__asm push eax					// reserve word for return address

 	__asm push ebp

 	__asm mov ebp, esp 

 	__asm pushfd

 	__asm push eax

 	__asm push ecx

 	__asm push edx

 	__asm mov eax, [TheScheduler.iCurrentThread]

 	__asm mov eax, [eax]NThread.iDivertReturn

 	__asm mov [esp + 20], eax		// store return address

 	__asm call NThread__Diverted

 	__asm pop edx

 	__asm pop ecx

 	__asm pop eax

 	__asm popfd

 	__asm pop ebp

 	__asm ret

 	}

 void NThread::ApplyDiversion()

 	{

 	// Called with interrupts disabled and kernel locked

 	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 1);

 	if (iDiverted)

 		return;

 	CONTEXT c;

 	c.ContextFlags=CONTEXT_FULL;

 	GetThreadContext(iWinThread, &c);

 	__NK_ASSERT_ALWAYS(iDivertReturn == NULL);

 	iDivertReturn = (TAny*)c.Eip;

 	c.Eip=(TUint32)&DivertHook;

 	SetThreadContext(iWinThread, &c);

 	iDiverted = ETrue;

 	}

 void NThread::Divert(TDivert aDivert)

 //

 // Divert the thread from its current path

 // The diversion function is called with the kernel locked and interrupts enabled

 //

 	{

 	iDivert = aDivert;

 	if (iWakeup == EResume)

 		iWakeup = EResumeDiverted;

 	else

 		__NK_ASSERT_ALWAYS(iWakeup == ERelease);

 	}

 void NThread::ExitSync()

 //

 // Diversion used to terminate 'stillborn' threads.

 // On entry, kernel is locked, interrupts are enabled and we hold an interlock mutex

 //

 	{

 	NThreadBase& me=*TheScheduler.iCurrentThread;

 	me.iHeldFastMutex->Signal();	// release the interlock

 	me.iNState=EDead;				// mark ourselves as dead which will take thread out of scheduler

 	TheScheduler.Remove(&me);

 	RescheduleNeeded();

 	TScheduler::Reschedule();	// this won't return

 	FAULT();

 	}

 void NThread::Stillborn()

 //

 // Called if the new thread creation was aborted - so it will not be killed in the usual manner

 //

 // This function needs to exit the thread synchronously as on return we will destroy the thread control block

 // Thus wee need to use an interlock that ensure that the target thread runs the exit handler before we continue

 //

 	{

 	// check if the Win32 thread was created

 	if (!iWinThread)

 		return;

 	NKern::Lock();

 	Divert(&ExitSync);

 	ForceResume();

 	// create and assign mutex to stillborn thread

 	NFastMutex interlock;

 	interlock.iHoldingThread=this;

 	iHeldFastMutex=&interlock;

 	interlock.Wait();			// interlock on thread exit handler

 	interlock.Signal();

 	NKern::Unlock();

 	}

 void NThread::ExitAsync()

 //

 // Diversion used to terminate 'killed' threads.

 // On entry, kernel is locked and interrupts are enabled

 //

 	{

 	NThreadBase& me = *TheScheduler.iCurrentThread;

 	me.iCsCount = 0;

 	__NK_ASSERT_ALWAYS(static_cast<NThread&>(me).iInKernel>0);

 	me.Exit();

 	}

 void NThreadBase::OnKill()

 	{

 	}

 void NThreadBase::OnExit()

 	{

 	}

 inline void NThread::DoForceExit()

 	{

 	__NK_ASSERT_DEBUG(TheScheduler.iKernCSLocked);

 //

 	Divert(&ExitAsync);

 	}

 void NThreadBase::ForceExit()

 //

 // Called to force the thread to exit when it resumes

 //

 	{

 	static_cast<NThread*>(this)->DoForceExit();

 	}

 //

 // We need a global lock in the emulator to avoid scheduling reentrancy problems with the host

 // in particular, some host API calls acquire host mutexes, preempting such services results

 // in suspension of those threads which can cause deadlock if another thread requires that host

 // mutex.

 //

 // Because thread dreaction and code loading also require the same underlying mutex (used

 // by NT to protect DLL entrypoint calling), this would be rather complex with a fast mutex.

 // For now, keep it simple and use the preemption lock. Note that this means that the

 // MS timer DFC may be significantly delayed when loading large DLL trees, for example.

 //

 void SchedulerLock()

 //

 // Acquire the global lock. May be called before scheduler running, so handle that case

 //

 	{

 	if (TheScheduler.iCurrentThread)

 		{

 		EnterKernel();

 		NKern::Lock();

 		}

 	}

 void SchedulerUnlock()

 //

 // Release the global lock. May be called before scheduler running, so handle that case

 //

 	{

 	if (TheScheduler.iCurrentThread)

 		{

 		NKern::Unlock();

 		LeaveKernel();

 		}

 	}