diff -r 000000000000 -r 96e5fb8b040d kernel/eka/kernel/sexec.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/kernel/sexec.cpp	Thu Dec 17 09:24:54 2009 +0200
@@ -0,0 +1,2785 @@
+// Copyright (c) 1994-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\kernel\sexec.cpp
+// 
+//
+
+#include <kernel/kern_priv.h>
+#include <e32uid.h>
+#include <e32ver.h>
+//#include <unicode.h>
+#include "execs.h"
+
+TInt ExecHandler::ObjectNext(TObjectType aType, TBuf8<KMaxFullName>& aName, TFindHandle& aFindHandle)
+//
+// Do the next find.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ObjectNext type %d",aType));
+	if (aType<0 || aType>=ENumObjectTypes)
+		K::PanicKernExec(EBadObjectType);
+	DObjectCon* pC=K::Containers[aType];
+	TFullName fn;
+	TFullName match;
+	TFindHandle h;
+	Kern::KUDesGet(match,aName);
+	kumemget32(&h,&aFindHandle,sizeof(h));
+	__KTRACE_OPT(KEXEC,Kern::Printf("ObjN: %lS %08x", &match, h.Handle()));
+	NKern::ThreadEnterCS();
+	TInt r=pC->FindByFullName(h, match, fn);
+	NKern::ThreadLeaveCS();
+	Kern::KUDesPut(aName,fn);
+	kumemput32(&aFindHandle,&h,sizeof(h));
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ObjectNext ret %d",r));
+	return r;
+	}
+
+TUint8 *ExecHandler::ChunkBase(DChunk* aChunk)
+//
+// Return the address of the base of the Chunk.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkBase"));
+	return (TUint8*)aChunk->Base(&Kern::CurrentProcess());
+	}
+
+TInt ExecHandler::ChunkSize(DChunk* aChunk)
+//
+// Return the current size of the Chunk.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkSize"));
+	return aChunk->Size();
+	}
+
+TInt ExecHandler::ChunkMaxSize(DChunk* aChunk)
+//
+// Return the maximum size of the Chunk.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkMaxSize")); 	
+	return aChunk->MaxSize();
+	}
+
+TInt ExecHandler::ChunkBottom(DChunk* aChunk)
+//
+// Return the position of the bottom of the chunk
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkBottom"));
+	return aChunk->Bottom();
+	}
+
+TInt ExecHandler::ChunkTop(DChunk* aChunk)
+//
+// Return the position of the top of the chunk
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkTop"));
+	return aChunk->Top();
+	}
+
+void ExecHandler::MutexWait(DMutex* aMutex)
+//
+// Wait for the mutex.
+//
+	{
+
+//	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::MutexWait"));
+	aMutex->Wait();
+	}
+
+void ExecHandler::MutexSignal(DMutex* aMutex)
+//
+// Signal the mutex.
+//
+	{
+
+//	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::MutexSignal"));
+	if (TheCurrentThread==aMutex->iCleanup.iThread)
+		{
+		aMutex->Signal();
+		return;
+		}
+	K::PanicCurrentThread(EAccessDenied);
+	}
+
+/**
+Test if mutex is held by the current thread.
+@return True if the current thread has waited on the mutex, false otherwise.
+*/
+TBool ExecHandler::MutexIsHeld(DMutex* aMutex)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::MutexIsHeld"));
+	return TheCurrentThread==aMutex->iCleanup.iThread;
+	}
+
+void ExecHandler::ProcessType(DProcess* aProcess, TUidType& aUids)
+//
+// Get process' UIDs.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessType"));
+	TUidType uids(aProcess->iUids);
+	NKern::UnlockSystem();
+	kumemput32(&aUids,&uids,sizeof(TUidType));
+	}
+
+TInt ExecHandler::ProcessId(DProcess* aProcess)
+//
+// Get process ID.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessId")); 	
+	return (TInt)aProcess->iId;
+	}
+
+void ExecHandler::ProcessSecurityInfo(DProcess* aProcess,SSecurityInfo& aInfo)
+//
+// Get process security info.
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessSecurityInfo"));
+	SSecurityInfo info(aProcess->iS);
+	NKern::UnlockSystem();
+	kumemput32(&aInfo,&info,sizeof(info));
+	}
+
+void ExecHandler::ThreadSecurityInfo(DThread* aThread,SSecurityInfo& aInfo)
+//
+// Get threads security info.
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadSecurityInfo"));
+	SSecurityInfo info(aThread->iOwningProcess->iS);
+	NKern::UnlockSystem();
+	kumemput32(&aInfo,&info,sizeof(info));
+	}
+
+void ExecHandler::MessageSecurityInfo(DThread* aClient,SSecurityInfo& aInfo)
+//
+// Get clients security info.
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::MessageSecurityInfo"));
+	SSecurityInfo info(aClient->iOwningProcess->iS);
+	NKern::UnlockSystem();
+	kumemput32(&aInfo,&info,sizeof(info));
+	}
+
+TInt ExecHandler::SessionSecurityInfo(TInt aSession,SSecurityInfo& aInfo)
+//
+// Get session security info.
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::SessionSecurityInfo"));
+	TInt r = KErrBadHandle;
+	SSecurityInfo info;
+	NKern::LockSystem();
+	DSession* s = (DSession*)TheCurrentThread->ObjectFromHandle(aSession,ESession);
+	if (s)
+		{
+		if (s->iServer && s->iServer->iOwningThread)
+			{
+			// session is connected, and server is alive
+			info = s->iServer->iOwningThread->iOwningProcess->iS;
+			r = KErrNone;
+			}
+		else
+			{
+			r = KErrServerTerminated;
+			}
+		}
+	NKern::UnlockSystem();
+	if (r==KErrNone)
+		kumemput32(&aInfo,&info,sizeof(info));
+	return r;
+	}
+
+void ExecHandler::CreatorSecurityInfo(SSecurityInfo& aInfo)
+//
+// Get creator's security info.
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::CreatorSecurityInfo"));
+	kumemput32(&aInfo,&TheCurrentThread->iOwningProcess->iCreatorInfo,sizeof(aInfo));
+	}
+
+void ExecHandler::DisabledCapabilities(SCapabilitySet& aCaps)
+//
+// Get the set of capabilities which are not to be checked (implemented by effectively
+// setting them for all executables).
+//
+	{
+	__KTRACE_OPT(KEXEC, Kern::Printf("Exec::DisabledCapabilities"));
+#ifdef __PLATSEC_UNLOCKED__
+	kumemput32(&aCaps, &TheSuperPage().iDisabledCapabilities, sizeof(aCaps));
+#else
+	kumemset(&aCaps, 0, sizeof(aCaps));
+#endif	// __PLATSEC_UNLOCKED__
+	}
+
+void ExecHandler::ProcessResume(DProcess* aProcess)
+//
+// Resume the first thread in the process.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessResume"));
+	if (aProcess->iCreatorId!=TheCurrentThread->iOwningProcess->iId) // Not creator...
+		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RProcess::Resume"));
+	aProcess->Resume();
+	}
+
+void ExecHandler::ProcessFileName(DProcess* aProcess, TDes8& aName)
+//
+// Return the process file name.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessFileName"));
+	TFileName fn;
+	DCodeSeg* pS=aProcess->iCodeSeg;
+	if (pS)
+		pS->AppendFullFileName(fn);
+	NKern::UnlockSystem();
+	if (pS)
+		P::NormalizeExecutableFileName(fn);
+	Kern::KUDesPut(aName, fn);
+	}
+
+TInt ExecHandler::ProcessCommandLineLength(DProcess* aProcess)
+//
+// Return the process command line length.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessCommandLineLength"));
+
+	if (aProcess->iSecurityZone!=TheCurrentThread->iOwningProcess->iSecurityZone)
+		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RProcess::CommandLineLength"));
+	const TDesC* pC=aProcess->iCommandLine;
+#ifdef _UNICODE
+	return pC?(pC->Length()>>1):0;
+#else
+	return pC?(pC->Length()):0;
+#endif
+	}
+
+void ExecHandler::ProcessCommandLine(DProcess* aProcess, TDes8& aCommandLine)
+//
+// Return the process command line.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessCommandLine"));
+	if (aProcess->iSecurityZone!=TheCurrentThread->iOwningProcess->iSecurityZone)
+		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RProcess::CommandLine"));
+	aProcess->CheckedOpen();
+	DThread& t=*TheCurrentThread;
+	t.iTempObj=aProcess;
+	NKern::UnlockSystem();
+	const TDesC* pC=aProcess->iCommandLine;
+	if (!pC)
+		pC=&KNullDesC;
+	Kern::KUDesPut(aCommandLine,*pC);
+	NKern::ThreadEnterCS();
+	t.iTempObj=NULL;
+	aProcess->Close(NULL);
+	NKern::ThreadLeaveCS();
+	}
+
+TExitType ExecHandler::ProcessExitType(DProcess* aProcess)
+//
+// Return the exit type.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessExitType")); 	
+	return (TExitType)aProcess->iExitType;
+	}
+
+TInt ExecHandler::ProcessExitReason(DProcess* aProcess)
+//
+// Return the exit reason.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessExitReason"));
+	return aProcess->iExitReason;
+	}
+
+void ExecHandler::ProcessExitCategory(DProcess* aProcess, TDes8& aName)
+//
+// Return the category of the exit type.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessExitCategory"));
+	TBufC<KMaxExitCategoryName> exitCat(aProcess->iExitCategory);
+	NKern::UnlockSystem();
+	Kern::KUDesPut(aName,exitCat);
+	}
+
+LOCAL_D const TProcessPriority procPriorityConvertTable[8]=
+	{
+	EPriorityLow,			EPriorityBackground,	EPriorityForeground,	EPriorityHigh,
+	EPriorityWindowServer,	EPriorityFileServer,	EPrioritySupervisor,	EPriorityRealTimeServer
+	};
+
+LOCAL_D const TThreadPriority thrdPriorityConvertTable[8]=
+	{
+	EPriorityMuchLess,	EPriorityMuchLess,	EPriorityLess,		EPriorityNormal,
+	EPriorityMore,		EPriorityMuchMore,	EPriorityRealTime,	EPriorityRealTime
+	};
+
+LOCAL_C TThreadPriority ConvertThreadPriority(TInt p)
+	{
+	switch(p)
+		{
+		case EThrdPriorityAbsoluteVeryLow:
+			return EPriorityAbsoluteVeryLow;
+		case EThrdPriorityAbsoluteLowNormal:
+			return EPriorityAbsoluteLowNormal;
+		case EThrdPriorityAbsoluteLow:
+			return EPriorityAbsoluteLow;
+		case EThrdPriorityAbsoluteBackgroundNormal:
+			return EPriorityAbsoluteBackgroundNormal;
+		case EThrdPriorityAbsoluteBackground:
+			return EPriorityAbsoluteBackground;
+		case EThrdPriorityAbsoluteForegroundNormal:
+			return EPriorityAbsoluteForegroundNormal;
+		case EThrdPriorityAbsoluteForeground:
+			return EPriorityAbsoluteForeground;
+		case EThrdPriorityAbsoluteHighNormal:
+			return EPriorityAbsoluteHighNormal;
+		case EThrdPriorityAbsoluteHigh:
+			return EPriorityAbsoluteHigh;
+		case EThrdPriorityAbsoluteRealTime1:
+			return EPriorityAbsoluteRealTime1;
+		case EThrdPriorityAbsoluteRealTime2:
+			return EPriorityAbsoluteRealTime2;
+		case EThrdPriorityAbsoluteRealTime3:
+			return EPriorityAbsoluteRealTime3;
+		case EThrdPriorityAbsoluteRealTime4:
+			return EPriorityAbsoluteRealTime4;
+		case EThrdPriorityAbsoluteRealTime5:
+			return EPriorityAbsoluteRealTime5;
+		case EThrdPriorityAbsoluteRealTime6:
+			return EPriorityAbsoluteRealTime6;
+		case EThrdPriorityAbsoluteRealTime7:
+			return EPriorityAbsoluteRealTime7;
+		case EThrdPriorityAbsoluteRealTime8:
+			return EPriorityAbsoluteRealTime8;
+		default:
+			if (p>=-8 && p<0)
+				return thrdPriorityConvertTable[p+8];
+		}
+	return EPriorityNormal;
+	}
+
+LOCAL_C TBool ProcessPriorityValid(TProcessPriority p)
+	{
+	switch(p)
+		{
+		case EPriorityLow:
+		case EPriorityBackground:
+		case EPriorityForeground:
+		case EPriorityHigh:
+			return ETrue;
+		default:
+			return EFalse;
+		}
+	}
+
+TProcessPriority ExecHandler::ProcessPriority(DProcess* aProcess)
+//
+// Get the process base priority.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessPriority"));
+	return procPriorityConvertTable[aProcess->iPriority];
+	}
+
+TInt ExecHandler::ProcessSetPriority(DProcess* aProcess, TProcessPriority aPriority)
+//
+// Set the process base priority.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessSetPriority"));
+	aProcess->CheckedOpen();
+	DThread& t=*TheCurrentThread;
+	t.iTempObj=aProcess;
+	NKern::UnlockSystem();
+	if (!ProcessPriorityValid(aPriority))
+		K::PanicKernExec(EBadPriority);
+
+	TBool allowed=ETrue;
+	DProcess* currentProcess=TheCurrentThread->iOwningProcess;
+	if (aProcess->iSecurityZone!=currentProcess->iSecurityZone)  // Not self...
+		if (aProcess->iCreatorId!=currentProcess->iId)  // Not creator
+			{
+			TInt processPriority=aProcess->iPriority;
+			if (!(aProcess->iFlags&KProcessFlagPriorityControl)  // No remote control...
+ 				|| (processPriority!=EProcPriorityBackground && processPriority!=EProcPriorityForeground && processPriority!=EProcPriorityHigh)
+				|| (aPriority!=EPriorityBackground && aPriority!=EPriorityForeground && aPriority!=EPriorityHigh) )  // Or not foreground/background/high
+					allowed=!(TheSuperPage().KernelConfigFlags() & EKernelConfigPlatSecProcessIsolation);
+			}
+
+	NKern::ThreadEnterCS();
+	t.iTempObj=NULL;
+	if(allowed)
+		aProcess->SetPriority(aPriority);
+	aProcess->Close(NULL);
+	NKern::ThreadLeaveCS();
+	if (allowed)
+		{
+		return KErrNone;
+		}
+	else
+		{
+		return KErrPermissionDenied;
+		}
+
+	}
+
+
+
+const TUint32 KDefinedProcessFlags=
+	KProcessFlagSystemCritical|
+	KProcessFlagSystemPermanent|
+	KProcessFlagJustInTime|
+	KProcessFlagPriorityControl|
+	KThreadFlagProcessCritical;
+
+const TUint32 KRestrictedProcessFlags =
+		~(KProcessFlagJustInTime|KProcessFlagPriorityControl|KThreadFlagProcessCritical); // All but these are restricted
+
+const TUint32 KSelfOnlyProcessFlags =
+		~0u; // (KProcessFlagJustInTime|KProcessFlagPriorityControl); // Only self can change these
+
+const TUint32 KDefinedThreadFlags=
+	KThreadFlagProcessCritical|
+	KThreadFlagProcessPermanent|
+	KThreadFlagSystemCritical|
+	KThreadFlagSystemPermanent|
+	KThreadFlagLastChance|
+	KThreadFlagRealtime|
+	KThreadFlagRealtimeTest;
+
+const TUint32 KRestrictedThreadFlags =
+		~(KThreadFlagProcessCritical|KThreadFlagProcessPermanent|KThreadFlagLastChance|
+			KThreadFlagRealtime|KThreadFlagRealtimeTest); // All but these are restricted
+
+const TUint32 KSelfOnlyThreadFlags =
+		~0u; // (KThreadFlagProcessCritical|KThreadFlagProcessPermanent|KThreadFlagLastChance); // Only owning process can change these
+
+
+TUint ExecHandler::ProcessFlags(DProcess* aProcess)
+//
+// Get the process flags
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessFlags"));
+	return aProcess->iFlags;
+	}
+
+TUint ExecHandler::ThreadProcessFlags(DThread* aThread)
+//
+// Get the process flags
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadProcessFlags"));
+	return aThread->iOwningProcess->iFlags;
+	}
+
+void ExecHandler::ProcessSetFlags(DProcess* aProcess, TUint aClearMask, TUint aSetMask)
+//
+// Set the process flags
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessSetFlags"));
+
+	TUint flags = aProcess->iFlags;
+	TUint modified = ((flags&~aClearMask)|aSetMask);
+	modified = (modified^flags)&KDefinedProcessFlags;
+
+	DProcess* currentProcess=TheCurrentThread->iOwningProcess;
+
+	if (modified&KSelfOnlyProcessFlags)
+		if(aProcess->iSecurityZone!=currentProcess->iSecurityZone)
+			if(aProcess->iCreatorId!=currentProcess->iId)
+				K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Attempt to modify the attributes of another Process. Possibly RProcess::SetSystem."));
+
+	if (modified&KRestrictedProcessFlags)
+		if(!currentProcess->HasCapability(ECapabilityProtServ,__PLATSEC_DIAGNOSTIC_STRING("Checked by User::SetProcessCritical (or RProcess::SetSystem)")))
+			K::LockedPlatformSecurityPanic();
+
+	aProcess->iFlags=flags^modified;
+
+	// if flags altered before resume, original thread inherits system critical and
+	// process critical from process.
+	if (!(aProcess->iAttributes & DProcess::EResumed))
+		{
+		TUint32& tf = aProcess->FirstThread()->iFlags;
+		tf = (tf &~ (KThreadFlagSystemCritical|KThreadFlagProcessCritical)) |
+			(aProcess->iFlags & (KThreadFlagSystemCritical|KThreadFlagProcessCritical));
+		}
+	}
+
+TInt ExecHandler::SemaphoreWait(DSemaphore* aSemaphore, TInt aTimeout)
+//
+// Wait for a signal.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::SemaphoreWait"));
+	if (aTimeout)
+		{
+		if (aTimeout<0)
+			{
+			NKern::UnlockSystem();
+			return KErrArgument;
+			}
+
+		// Convert microseconds to NTimer ticks, rounding up
+		TInt ntp = NKern::TickPeriod();
+		aTimeout += ntp-1;
+		aTimeout /= ntp;
+		}
+	return aSemaphore->Wait(aTimeout);
+	}
+
+void ExecHandler::SemaphoreSignal1(DSemaphore* aSemaphore)
+//
+// Signal the semaphore once.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::SemaphoreSignal1"));
+	aSemaphore->Signal();
+	}
+
+void ExecHandler::SemaphoreSignalN(DSemaphore* aSem, TInt aCount)
+//
+// Signal the semaphore aCount times.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::SemaphoreSignalN"));
+	aSem->CheckedOpen();
+	NKern::ThreadEnterCS();
+	aSem->SignalN(aCount);
+	NKern::UnlockSystem();
+	aSem->Close(NULL);
+	NKern::ThreadLeaveCS();
+	}
+
+TInt ExecHandler::ThreadId(DThread* aThread)
+//
+// Get thread ID.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadId"));
+	return (TInt)aThread->iId;
+	}
+	
+LOCAL_C TBool IsThreadPriorityAbsoluteRealTime(TThreadPriority p)
+//
+// Returns true if priority is an absolute "real time" thread priority.
+//
+	{
+	switch(p)
+		{
+		case EPriorityAbsoluteRealTime1:
+		case EPriorityAbsoluteRealTime2:
+		case EPriorityAbsoluteRealTime3:
+		case EPriorityAbsoluteRealTime4:
+		case EPriorityAbsoluteRealTime5:
+		case EPriorityAbsoluteRealTime6:
+		case EPriorityAbsoluteRealTime7:
+		case EPriorityAbsoluteRealTime8:
+			return ETrue;
+		default:
+			return EFalse;
+		}
+	}
+
+void ExecHandler::ThreadResume(DThread* aThread)
+//
+// Resume a thread.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadResume"));
+	if (aThread->iOwningProcess->iSecurityZone!=TheCurrentThread->iOwningProcess->iSecurityZone)
+		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Use of RThread::Resume on a thread in another process"));
+	aThread->Resume();
+	}
+
+TThreadPriority ExecHandler::ThreadPriority(DThread* aThread)
+//
+// Get the threads priority.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadPriority"));
+	return ConvertThreadPriority(aThread->iThreadPriority);
+	}
+
+void ExecHandler::ThreadSetPriority(DThread* aThread,TThreadPriority aPriority)
+//
+// Set the threads priority.
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadSetPriority"));
+	if (aThread->iOwningProcess->iSecurityZone!=TheCurrentThread->iOwningProcess->iSecurityZone)
+		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Use of RThread::SetPriority on a thread in a different process"));
+	if(IsThreadPriorityAbsoluteRealTime(aPriority) && 
+	   !(TheCurrentThread->HasCapability(ECapabilityProtServ,__PLATSEC_DIAGNOSTIC_STRING("Checked by RThread::SetPriority"))))
+		K::LockedPlatformSecurityPanic();
+	else
+		aThread->SetPriority(aPriority);
+	}
+
+TProcessPriority ExecHandler::ThreadProcessPriority(DThread* aThread)
+//
+// Get the owning process's priority.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadProcessPriority"));
+	return procPriorityConvertTable[aThread->iOwningProcess->iPriority];
+	}
+
+void ExecHandler::ThreadSetProcessPriority(DThread* aThread, TProcessPriority aPriority)
+//
+// Set the owning process's priority.
+//
+	{
+	ExecHandler::ProcessSetPriority(aThread->iOwningProcess,aPriority);
+	}
+
+TUint ExecHandler::ThreadFlags(DThread* aThread)
+//
+// Get the threads flag state.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadFlags"));
+	return(aThread->iFlags);
+	}
+
+void ExecHandler::ThreadSetFlags(DThread* aThread,TUint aClearMask,TUint aSetMask)
+//
+// Set the thread flags
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadSetFlags"));
+	TUint flags = aThread->iFlags;
+	TUint modified = ((flags&~aClearMask)|aSetMask);
+	modified = (modified^flags)&KDefinedThreadFlags;
+
+	DProcess* currentProcess=TheCurrentThread->iOwningProcess;
+
+	if (modified&KSelfOnlyThreadFlags)
+		if(aThread->iOwningProcess->iSecurityZone!=currentProcess->iSecurityZone)
+			K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Attempt to modify attributes of a thread in another process. Possibly RThread::SetSystem"));
+
+	if (modified&KRestrictedThreadFlags)
+		if(!currentProcess->HasCapability(ECapabilityProtServ,__PLATSEC_DIAGNOSTIC_STRING("Checked by User::SetCritical (or RThread::SetSystem)")))
+			K::LockedPlatformSecurityPanic();
+
+	aThread->iFlags=flags^modified;
+	}
+
+TExitType ExecHandler::ThreadExitType(DThread* aThread)
+//
+// Return the exit type.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadExitType"));
+	return (TExitType)aThread->iExitType;
+	}
+
+TInt ExecHandler::ThreadExitReason(DThread* aThread)
+//
+// Return the exit reason.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadExitReason"));
+	return aThread->iExitReason;
+	}
+
+void ExecHandler::ThreadExitCategory(DThread* aThread, TDes8& aName)
+//
+// Return the category of the exit type.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadExitCategory"));
+	TBufC<KMaxExitCategoryName> exitCat(aThread->iExitCategory);
+	NKern::UnlockSystem();
+	Kern::KUDesPut(aName,exitCat);
+	}
+
+void ExecHandler::ThreadRequestSignal(DThread* aThread)
+//
+// Signal a request completion.
+// Enter with system locked, return with system unlocked.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadRequestSignal"));
+	if(aThread->iOwningProcess!=TheCurrentThread->iOwningProcess)
+		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Attempt to use RThread::RequestComplete on a thread in another process"));
+	NKern::ThreadRequestSignal(&aThread->iNThread, SYSTEM_LOCK);
+	}
+
+TInt ExecHandler::FindHandleOpen(TOwnerType aType, const TFindHandle& aFindHandle)
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::FindHandleOpen"));
+	TFindHandle fh;
+	kumemget32(&fh,&aFindHandle,sizeof(fh));
+	NKern::ThreadEnterCS();
+	TInt h;
+	TInt r=TheCurrentThread->OpenFindHandle(aType,fh,h);
+	if(r==KErrNone)
+		r = h;
+	NKern::ThreadLeaveCS();
+	if (r==KErrBadHandle)
+		K::PanicKernExec(EBadHandle);
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::FindHandleOpen returns %d",r));
+	return r;
+	}
+
+TInt ExecHandler::HandleClose(TInt aHandle)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::HandleClose %08x",aHandle));
+	NKern::ThreadEnterCS();
+	TInt r=K::HandleClose(aHandle);
+	NKern::ThreadLeaveCS();
+	if (r==KErrBadHandle)
+		K::PanicKernExec(EBadHandle);
+	else if (r==DObject::EObjectUnmapped)
+		TheCurrentThread->iOwningProcess->WaitDllLock();
+	return r;
+	}
+
+TInt ExecHandler::LastThreadHandle()
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::LastThreadHandle"));
+	DThread& t=*TheCurrentThread;
+	NKern::ThreadEnterCS();
+	RObjectIx::Wait();
+	TInt r=t.iHandles.LastHandle();
+	RObjectIx::Signal();
+	NKern::ThreadLeaveCS();
+	if (r)
+		r|=KHandleFlagLocal;
+	return r;
+	}
+
+TInt ExecHandler::ChunkCreate(TOwnerType aType, const TDesC8* aName, TChunkCreate& anInfo)
+	{
+	TKName n;
+	if (aName)
+		Kern::KUDesGet(n,*aName);
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkCreate %lS",&n));
+	TChunkCreate uinfo;
+	SChunkCreateInfo info;
+	kumemget32(&uinfo,&anInfo,sizeof(uinfo));
+	info.iGlobal=uinfo.iAtt & TChunkCreate::EGlobal;
+	info.iAtt = uinfo.iAtt&TChunkCreate::EChunkCreateAttMask;
+	info.iForceFixed=uinfo.iForceFixed;
+	info.iOperations=SChunkCreateInfo::EAdjust;	// adjust but don't add to process
+	info.iRunAddress=0;
+	info.iType=(uinfo.iAtt & TChunkCreate::ECode) ? EUserSelfModCode : EUserData;
+	info.iMaxSize=uinfo.iMaxSize;
+	info.iInitialBottom=uinfo.iInitialBottom;
+	info.iInitialTop=uinfo.iInitialTop;
+	info.iPreallocated=0;
+	info.iClearByte = uinfo.iClearByte;
+	DThread* pT=TheCurrentThread;
+	DProcess* pP=pT->iOwningProcess;
+	if (aName)
+		info.iName.Set(n);
+	else
+		info.iName.Set(NULL,0);
+	if (!info.iGlobal)
+		info.iOwner=(aType==EOwnerThread)?(DObject*)pT:(DObject*)pP;
+	else
+		info.iOwner=NULL;
+	NKern::ThreadEnterCS();
+	DChunk* pC=NULL;
+	TLinAddr addr;
+	TInt r=pP->NewChunk(pC,info,addr);
+	if (r==KErrNone)
+		r=K::MakeHandle(aType,pC);	// this will add the chunk to the process
+	if (r<KErrNone && pC)
+		pC->Close(NULL);				// can't have been added so NULL
+	NKern::ThreadLeaveCS();
+	__KTRACE_OPT(KTHREAD,Kern::Printf("Exec::ChunkCreate returns %d",r));
+	return r;
+	}
+
+TInt ExecHandler::ChunkSetRestrictions(DChunk* aChunk, TUint aRestrictions)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkSetRestrictions %O flags=%x",aChunk,aRestrictions));
+	if(aChunk->iControllingOwner!=TheCurrentThread->iOwningProcess->iId)
+		return KErrAccessDenied;
+	aChunk->iRestrictions = aRestrictions;
+	return KErrNone;
+	}
+
+TInt ExecHandler::ChunkAdjust(DChunk* aChunk, TInt aType, TInt a1, TInt a2)
+	{
+	__KTRACE_OPT(KPROC,Kern::Printf("Exec::ChunkAdjust %O type %d a1=%x a2=%x",aChunk,aType,a1,a2));
+	aChunk->CheckedOpen();
+	NKern::ThreadEnterCS();
+	NKern::UnlockSystem();
+	TInt r=KErrNone;
+	TInt s=aChunk->CheckAccess();
+	if (s!=KErrNone)
+		goto done;
+	if((aChunk->iRestrictions&EChunkPreventAdjust) && (aChunk->iControllingOwner!=TheCurrentThread->iOwningProcess->iId))
+		{
+		r=KErrAccessDenied;
+		goto done;
+		}
+	switch (aType)
+		{
+		case EChunkAdjust:
+			r=aChunk->Adjust(a1);
+			break;
+		case EChunkAdjustDoubleEnded:
+			r=aChunk->AdjustDoubleEnded(a1,a2);
+			break;
+		case EChunkCommit:
+			r=aChunk->Commit(a1,a2);
+			break;
+		case EChunkDecommit:
+			r=aChunk->Decommit(a1,a2);
+			break;
+		case EChunkAllocate:
+			r=aChunk->Allocate(a1);
+			break;
+		case EChunkLock:
+			if(&Kern::CurrentProcess()!=aChunk->iOwningProcess)
+				r = KErrAccessDenied;	
+			else
+				r=aChunk->Lock(a1,a2);
+			break;
+		case EChunkUnlock:
+			if(&Kern::CurrentProcess()!=aChunk->iOwningProcess)
+				r = KErrAccessDenied;	
+			else
+				r=aChunk->Unlock(a1,a2);
+			break;
+		default:
+			r=KErrArgument;
+			break;
+		}
+done:
+	aChunk->Close(NULL);		// NULL because we didn't up the process access count
+	NKern::ThreadLeaveCS();
+	if (s!=KErrNone)
+		K::PanicKernExec(EAccessDenied);
+	__KTRACE_OPT(KPROC,Kern::Printf("Exec::ChunkAdjust returns %d",r));
+	return r;
+	}
+
+
+/**
+@return ETrue if the chunk is data paged, EFalse otherwise.
+*/
+TBool ExecHandler::ChunkIsPaged(DChunk* aChunk)
+	{
+	return (aChunk->iAttributes & DChunk::EDataPaged) != 0;
+	}
+
+
+/**
+@return ETrue if the process is data paged, EFalse otherwise.
+*/
+TBool ExecHandler::ProcessDefaultDataPaged(DProcess* aProcess)
+	{
+	return (aProcess->iAttributes & DProcess::EDataPaged) != 0;
+	}
+
+
+
+TInt ExecHandler::OpenObject(TObjectType aObjType, const TDesC8& aName, TOwnerType aType)
+	{
+	__KTRACE_OPT(KTHREAD,Kern::Printf("Exec::OpenObject %lS",&aName));
+	TFullName n;
+	Kern::KUDesGet(n,aName);
+	if (Kern::ValidateFullName(n)!=KErrNone)
+		K::PanicKernExec(EBadName);
+	if ((TUint)aObjType>=(TUint)ENumObjectTypes)
+		K::PanicKernExec(EBadObjectType);
+	TInt h=0;
+	DObject* pO=NULL;
+	NKern::ThreadEnterCS();
+	TInt r=TheCurrentThread->OpenObject(aType,n,h,pO,aObjType);
+	NKern::ThreadLeaveCS();
+	if(r==KErrNone)
+		r = h;
+	__KTRACE_OPT(KTHREAD,Kern::Printf("Exec::OpenObject returns %d",r));
+	return r;
+	}
+
+
+TInt ExecHandler::HandleDuplicate(TInt aThreadHandle, TOwnerType aType, TInt& aHandle)
+	{
+	TInt h;
+	kumemget32(&h, &aHandle, sizeof(h));
+	__KTRACE_OPT(KTHREAD,Kern::Printf("Exec::HandleDuplicate %08x", h));
+	DThread* pC=TheCurrentThread;
+	NKern::LockSystem();
+	DThread* pT=(DThread*)K::ThreadEnterCS(aThreadHandle,EThread);
+	__KTRACE_OPT(KTHREAD,Kern::Printf("Exec::HandleDuplicate source thread %O",pT));
+	TInt r=KErrBadHandle;
+	NKern::LockSystem();
+	DObject* pO=pT->ObjectFromHandle(h);
+	h = 0;	// now holds value to be returned
+	if (pO)
+		r=pO->Open();
+	NKern::UnlockSystem();
+	if (r==KErrNone)
+		{
+		if (pO->Protection()!=DObject::EGlobal
+			&& pT->iOwningProcess->iSecurityZone!=pC->iOwningProcess->iSecurityZone)
+			{
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+			r = PlatSec::ProcessIsolationFail(__PLATSEC_DIAGNOSTIC_STRING("Checked by RHandleBase::Duplicate"));
+#else //__REMOVE_PLATSEC_DIAGNOSTICS__
+			r = PlatSec::EmitDiagnostic();
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+			}
+		if (r==KErrNone)
+			r = pC->MakeHandle(aType, pO, h);	// this will add to process if necessary
+		if (r<KErrNone)
+			pO->Close(NULL);	// can't have been added to process so NULL
+		}
+	pT->Close(NULL);
+	TInt s = KErrNone;
+	XTRAP(s, XT_DEFAULT, kumemput32(&aHandle, &h, sizeof(h)));
+	if (s!=KErrNone && r==KErrNone)
+		pC->HandleClose(h);
+	NKern::ThreadLeaveCS();
+	if (r == KErrBadHandle)
+		K::PanicKernExec(EBadHandle);
+	if (s != KErrNone)
+		K::PanicKernExec(ECausedException);
+	__KTRACE_OPT(KTHREAD,Kern::Printf("Exec::HandleDuplicate returns %d",r));
+	return r;
+	}
+
+TInt ExecHandler::MutexCreate(const TDesC8* aName, TOwnerType aType)
+	{
+	TKName n;
+	DObject* pO=NULL;
+	const TDesC* pN=NULL;
+	if (aName)
+		{
+		Kern::KUDesGet(n,*aName);
+		pN=&n;
+		}
+	else if (aType==EOwnerThread)
+		pO=TheCurrentThread;
+	else
+		pO=TheCurrentThread->iOwningProcess;
+	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Exec::MutexCreate %lS",aName));
+	NKern::ThreadEnterCS();
+	DMutex* pM;
+	TInt r=K::MutexCreate(pM, *pN, pO, ETrue, KMutexOrdUser);
+	if (r==KErrNone)
+		{
+		if(aName)
+			pM->SetProtection(n.Length()? DObject::EGlobal : DObject::EProtected);
+		r=K::MakeHandle(aType,pM);
+		if (r<KErrNone)
+			pM->Close(NULL);
+		}
+	NKern::ThreadLeaveCS();
+	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Exec::MutexCreate returns %d",r));
+	return r;
+	}
+
+TInt ExecHandler::SemaphoreCreate(const TDesC8* aName, TInt aCount, TOwnerType aType)
+	{
+	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Exec::SemaphoreCreate %lS",aName));
+	TKName n;
+	DObject* pO=NULL;
+	const TDesC* pN=NULL;
+	if (aName)
+		{
+		Kern::KUDesGet(n,*aName);
+		pN=&n;
+		}
+	else if (aType==EOwnerThread)
+		pO=TheCurrentThread;
+	else
+		pO=TheCurrentThread->iOwningProcess;
+	NKern::ThreadEnterCS();
+	TInt r=KErrNoMemory;
+	DSemaphore* pS=new DSemaphore;
+	if (pS)
+		r=pS->Create(pO,pN,aCount);
+	if (r==KErrNone)
+		{
+		if(aName)
+			pS->SetProtection(n.Length()? DObject::EGlobal : DObject::EProtected);
+		r=K::MakeHandle(aType,pS);
+		}
+	if (r<KErrNone && pS)
+		pS->Close(NULL);
+	NKern::ThreadLeaveCS();
+	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Exec::SemaphoreCreate returns %d",r));
+	return r;
+	}
+
+LOCAL_C TInt OpenById(TUint anId, TOwnerType aType, TBool aProcess)
+	{
+	NKern::ThreadEnterCS();
+	TInt type=aProcess?EProcess:EThread;
+	DObjectCon* pC=K::Containers[type];
+	pC->Wait();
+	DObject* pO=aProcess?(DObject*)Kern::ProcessFromId(anId):(DObject*)Kern::ThreadFromId(anId);
+	TInt r=KErrNotFound;
+	if (pO && (r=pO->Open())==KErrNone)
+		{
+		pC->Signal();	// must release this before opening handle
+		DProcess* pP;
+		if(aProcess)
+			pP=(DProcess*)pO;
+		else
+			pP=((DThread*)pO)->iOwningProcess;
+
+		if( pO->Protection()!=DObject::EGlobal
+			&& pP->iSecurityZone!=TheCurrentThread->iOwningProcess->iSecurityZone)
+			{
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+			r = PlatSec::ProcessIsolationFail(__PLATSEC_DIAGNOSTIC_STRING("Checked by RThread::Open(TThreadId)"));
+#else //__REMOVE_PLATSEC_DIAGNOSTICS__
+			r = PlatSec::EmitDiagnostic();
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+			}
+		if (r==KErrNone)
+			r=K::MakeHandle(aType,pO);
+		if (r<KErrNone)
+			pO->Close(NULL);
+		}
+	else
+		pC->Signal();
+	NKern::ThreadLeaveCS();
+	return r;
+	}
+
+TInt ExecHandler::ThreadOpenById(TUint anId, TOwnerType aType)
+	{
+	__KTRACE_OPT(KTHREAD,Kern::Printf("Exec::ThreadOpenById %d",anId));
+	TInt r=OpenById(anId,aType,EFalse);
+	__KTRACE_OPT(KTHREAD,Kern::Printf("Exec::ThreadOpenById returns %d",r));
+	return r;
+	}
+
+TInt ExecHandler::ProcessOpenById(TUint anId, TOwnerType aType)
+	{
+	__KTRACE_OPT(KPROC,Kern::Printf("Exec::ProcessOpenById %d",anId));
+	TInt r=OpenById(anId,aType,ETrue);
+	__KTRACE_OPT(KPROC,Kern::Printf("Exec::ProcessOpenById returns %d",r));
+	return r;
+	}
+
+// Enter with system locked, return with system unlocked
+void ExecHandler::ThreadLogon(DThread* aThread, TRequestStatus* aStatus, TBool aRendezvous)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadLogon"));
+	aThread->CheckedOpen();
+	NKern::ThreadEnterCS();
+	NKern::UnlockSystem();
+	TInt r=aThread->Logon(aStatus,aRendezvous);
+	if (r!=KErrNone)
+		{
+		if (r==KErrDied)
+			r=aThread->iExitReason;
+		Kern::RequestComplete(aStatus,r);
+		}
+	aThread->Close(NULL);
+	NKern::ThreadLeaveCS();
+	}
+
+// Enter with system locked, return with system unlocked
+TInt ExecHandler::ThreadLogonCancel(DThread* aThread, TRequestStatus* aStatus, TBool aRendezvous)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadLogonCancel"));
+	aThread->CheckedOpen();
+	NKern::ThreadEnterCS();
+	NKern::UnlockSystem();
+	DThread& t = *TheCurrentThread;
+	TUint32 type = TLogon::ETargetThread;
+	if (aRendezvous)
+		type |= TLogon::ERendezvous;
+	TInt r = TLogon::Cancel(t.iOwnedLogons, aThread, aStatus, type);
+	aThread->Close(NULL);
+	NKern::ThreadLeaveCS();
+	return r;
+	}
+
+// Enter with system locked, return with system unlocked
+void ExecHandler::ProcessLogon(DProcess* aProcess, TRequestStatus* aStatus, TBool aRendezvous)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessLogon"));
+	aProcess->CheckedOpen();
+	NKern::ThreadEnterCS();
+	NKern::UnlockSystem();
+	TInt r=aProcess->Logon(aStatus,aRendezvous);
+	if (r!=KErrNone)
+		{
+		if (r==KErrDied)
+			r=aProcess->iExitReason;
+		Kern::RequestComplete(aStatus,r);
+		}
+	aProcess->Close(NULL);
+	NKern::ThreadLeaveCS();
+	}
+
+// Enter with system locked, return with system unlocked
+TInt ExecHandler::ProcessLogonCancel(DProcess* aProcess, TRequestStatus* aStatus, TBool aRendezvous)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessLogonCancel"));
+	aProcess->CheckedOpen();
+	NKern::ThreadEnterCS();
+	NKern::UnlockSystem();
+	DThread& t = *TheCurrentThread;
+	TUint32 type = TLogon::ETargetProcess;
+	if (aRendezvous)
+		type |= TLogon::ERendezvous;
+	TInt r = TLogon::Cancel(t.iOwnedLogons, aProcess, aStatus, type);
+	aProcess->Close(NULL);
+	NKern::ThreadLeaveCS();
+	return r;
+	}
+
+TAny* ExecHandler::DllTls(TInt aHandle, TInt aDllUid)
+	{
+	// no protection needed since only this thread can access the TLS array
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::DllTls"));
+#ifndef __EPOC32__
+	extern TInt LookupDllUid(TInt);
+
+	if (aDllUid == KDllUid_Special)
+		aDllUid = LookupDllUid(aHandle);
+#endif
+	return TheCurrentThread->Tls(aHandle,aDllUid);
+	}
+
+TInt ExecHandler::DllSetTls(TInt aHandle, TInt aDllUid, TAny* aPtr)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::DllSetTls %08x->%08x", aHandle, aPtr));
+#ifndef __EPOC32__
+	extern TInt LookupDllUid(TInt);
+
+	if (aDllUid == KDllUid_Special)
+		aDllUid = LookupDllUid(aHandle);
+#endif
+	NKern::ThreadEnterCS();
+	TInt r=TheCurrentThread->SetTls(aHandle,aDllUid,aPtr);
+	NKern::ThreadLeaveCS();
+	return r;
+	}
+
+void ExecHandler::DllFreeTls(TInt aHandle)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::DllFreeTls"));
+	NKern::ThreadEnterCS();
+	TheCurrentThread->FreeTls(aHandle);
+	NKern::ThreadLeaveCS();
+	}
+
+TInt ExecHandler::ThreadRename(TInt aHandle, const TDesC8& aName)
+	{
+	TKName n;
+	Kern::KUDesGet(n,aName);
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadRename %lS",&n));
+	NKern::LockSystem();
+	DThread* pT=(DThread*)K::ThreadEnterCS(aHandle,EThread);
+	if (pT!=TheCurrentThread &&
+		pT->iOwningProcess->iSecurityZone!=TheCurrentThread->iOwningProcess->iSecurityZone)
+		{
+		if(TheSuperPage().KernelConfigFlags() & EKernelConfigPlatSecEnforcement)
+			{
+			pT->Close(NULL);
+			K::ThreadLeaveCS();
+			}
+		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RThread::Rename"));
+		if(TheSuperPage().KernelConfigFlags() & EKernelConfigPlatSecEnforcement)
+			Kern::Fault("ThreadRename",0);
+		}
+	TInt r=pT->Rename(n);
+	pT->Close(NULL);
+	NKern::ThreadLeaveCS();
+	return r;
+	}
+
+TInt ExecHandler::ProcessRename(TInt aHandle, const TDesC8& aName)
+	{
+	TKName n;
+	Kern::KUDesGet(n,aName);
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessRename %lS",&n));
+	NKern::LockSystem();
+	DProcess* pP=(DProcess*)K::ThreadEnterCS(aHandle,EProcess);
+	if (pP->iSecurityZone!=TheCurrentThread->iOwningProcess->iSecurityZone)
+		{
+		if(TheSuperPage().KernelConfigFlags() & EKernelConfigPlatSecEnforcement)
+			{
+			pP->Close(NULL);
+			K::ThreadLeaveCS();
+			}
+		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RProcess::Rename"));
+		if(TheSuperPage().KernelConfigFlags() & EKernelConfigPlatSecEnforcement)
+			Kern::Fault("ProcessRename",0);
+		}
+	TInt r=pP->Rename(n);
+	pP->Close(NULL);
+	NKern::ThreadLeaveCS();
+	return r;
+	}
+
+TInt ExecHandler::ThreadProcess(DThread* aThread)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadProcess"));
+	DProcess* pP=aThread->iOwningProcess;
+	pP->Open();	// can't get an error here
+	NKern::ThreadEnterCS();
+	NKern::UnlockSystem();
+	TInt r=K::MakeHandle(EOwnerThread,pP);
+	if (r<KErrNone)
+		pP->Close(NULL);
+	NKern::ThreadLeaveCS();
+	return r;
+	}
+
+RAllocator* ExecHandler::ThreadGetHeap(DThread* aThread)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadGetHeap %O",aThread));
+	if (aThread->iOwningProcess->iSecurityZone!=TheCurrentThread->iOwningProcess->iSecurityZone)
+		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RThread::Heap"));
+	return aThread->iAllocator;
+	}
+
+void ExecHandler::HandleName(TInt aHandle, TDes8& aName)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::HandleName"));
+	DObject* pO=NULL;
+	TInt r=K::OpenObjectFromHandle(aHandle,pO);
+	if (r!=KErrNone)
+		K::PanicKernExec(EBadHandle);
+	TKName n;
+	pO->Name(n);
+	pO->Close(NULL);
+	NKern::ThreadLeaveCS();
+	Kern::KUDesPut(aName,n);
+	}
+
+void ExecHandler::HandleFullName(TInt aHandle, TDes8& aFullName)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::HandleFullName"));
+	DObject* pO=NULL;
+	TInt r=K::OpenObjectFromHandle(aHandle,pO);
+	if (r!=KErrNone)
+		K::PanicKernExec(EBadHandle);
+	TFullName n;
+	pO->FullName(n);
+	pO->Close(NULL);
+	NKern::ThreadLeaveCS();
+	Kern::KUDesPut(aFullName,n);
+	}
+
+void ExecHandler::HandleCount(DThread* aThread, TInt& aProcessHandleCount, TInt& aThreadHandleCount)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::HandleCount"));
+	TInt tCount=aThread->iHandles.ActiveCount();
+	TInt pCount=aThread->iOwningProcess->iHandles.ActiveCount();
+	NKern::UnlockSystem();
+	kumemput32(&aProcessHandleCount,&pCount,sizeof(pCount));
+	kumemput32(&aThreadHandleCount,&tCount,sizeof(tCount));
+	}
+
+TInt ExecHandler::GetBTraceId(DObject* aObj)
+//
+// Get the BTraceID of any given RHandleBase-derived object. In practice
+// this ID is simply a pointer to the associated DObject.
+//
+	{
+	return (TInt)aObj;
+	}
+
+void ExecHandler::HandleInfo(TInt aHandle, THandleInfo* anInfo)
+//
+// Find out how many threads and processes have an open handle on the object given by 
+// a handle, and whether it's open in this process and thread.
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::HandleInfo"));
+	THandleInfo hinfo;
+	memclr(&hinfo, sizeof(hinfo));
+	DObject* pO=NULL;
+	TInt r=K::OpenObjectFromHandle(aHandle,pO);
+	if (r==KErrNone)
+		{
+		RObjectIx::Wait();
+		DProcess* pCurrentProcess=TheCurrentThread->iOwningProcess;
+		hinfo.iNumOpenInThread=TheCurrentThread->iHandles.Count(pO);
+		hinfo.iNumOpenInProcess=pCurrentProcess->iHandles.Count(pO);
+
+		DObjectCon& threads=*K::Containers[EThread];
+		threads.Wait();
+		TInt c=threads.Count();
+		TInt i=0;
+		for (;i<c;i++)
+			{
+			DThread *pT=(DThread *)threads[i];
+			TInt r=pT->iHandles.At(pO);
+			if (r!=KErrNotFound)
+				{
+				++hinfo.iNumThreads;
+				if (pT->iOwningProcess==pCurrentProcess)
+					++hinfo.iNumOpenInProcess;
+				}
+			}
+		threads.Signal();
+		DObjectCon& processes=*K::Containers[EProcess];
+		processes.Wait();
+		c=processes.Count();
+		for (i=0;i<c;i++)
+			{
+			DProcess *pP=(DProcess *)processes[i];
+			TInt r=pP->iHandles.At(pO);
+			if (r!=KErrNotFound)
+				++hinfo.iNumProcesses;
+			}
+		processes.Signal();
+		RObjectIx::Signal();
+		pO->Close(NULL);
+		NKern::ThreadLeaveCS();
+		}
+	kumemput32(anInfo,&hinfo,sizeof(hinfo));
+	}
+
+TUint ExecHandler::HandleAttributes(TInt aHandle)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::HandleAttributes"));
+	TUint attributes = RHandleBase::EReadAccess | RHandleBase::EDirectReadAccess;
+	NKern::LockSystem();
+	DObject* pO = K::ObjectFromHandle(aHandle);
+	if (pO->UniqueID() - 1 == EChunk)
+		{
+		DChunk* pChunk = (DChunk*) pO;
+		if (!(pChunk->iAttributes & DChunk::EReadOnly) ||
+			(TheCurrentThread->iOwningProcess->iId == pChunk->iControllingOwner))
+			{
+			attributes |= (RHandleBase::EWriteAccess | RHandleBase::EDirectWriteAccess);
+			}
+		}
+	else
+		{
+		attributes |= (RHandleBase::EWriteAccess | RHandleBase::EDirectWriteAccess);
+		}
+	NKern::UnlockSystem();
+	return attributes;
+	}
+
+TLibraryFunction ExecHandler::LibraryLookup(TInt aLibraryHandle, TInt aOrdinal)
+	{
+	TLibraryFunction f = NULL;
+	NKern::LockSystem();
+
+XTRAP_PAGING_RETRY(
+	DLibrary* library = (DLibrary*)K::ObjectFromHandle(aLibraryHandle,ELibrary);
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::LibraryLookup %O %d",library,aOrdinal));
+	DCodeSeg* pS = library->iCodeSeg;
+	if(pS)
+		f = pS->Lookup(aOrdinal);
+)
+	NKern::UnlockSystem();
+	return f;
+	}
+
+/**
+Retrieves pointer to the named symbol export data, if present.
+	
+@param aProcessHandle Handle to the process whose code seg to search
+@return	Pointer to named symbol export data if its present, NULL otherwise
+@internalComponent
+*/
+TAny* ExecHandler::ProcessExeExportData(void)
+	{
+	DProcess* pP = &Kern::CurrentProcess();
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessExeExportData %O",pP));
+	DCodeSeg* pS = pP->CodeSeg();	// can't be null if process is running
+	
+	// Lookup() returns NULL if this is not a stdexe/stddll
+	return (TAny*)pS->Lookup(0);
+	}
+
+void ExecHandler::LibraryType(DLibrary* aLibrary, TUidType& aUids)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::LibraryType"));
+	TUidType uids;
+	memclr(&uids, sizeof(uids));
+	DCodeSeg* pS=aLibrary->iCodeSeg;
+	if (pS)
+		uids=pS->iUids;
+	__KTRACE_OPT(KEXEC,Kern::Printf("UIDS: %08x,%08x,%08x",uids.iUid[0],uids.iUid[1],uids.iUid[2]));
+	NKern::UnlockSystem();
+	kumemput32(&aUids,&uids,sizeof(TUidType));
+	}
+
+void ExecHandler::LibraryFileName(DLibrary* aLibrary, TDes8& aFileName)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::LibraryFileName"));
+	TFileName fn;
+	DCodeSeg* pS=aLibrary->iCodeSeg;
+	if (pS)
+		pS->AppendFullFileName(fn);
+	NKern::UnlockSystem();
+	P::NormalizeExecutableFileName(fn);
+	Kern::KUDesPut(aFileName, fn);
+	}
+
+TInt ExecHandler::HalFunction(TInt aGroup, TInt aFunction, TAny* a1, TAny* a2)
+	{
+	TInt aDeviceNumber = TUint(aGroup)>>16;
+	aGroup=aGroup&0xffff;
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::HalFunction(%d,%d,%08x,%08x,%d)",aGroup,aFunction,a1,a2,aDeviceNumber));
+	TInt r=KErrNotSupported;
+	if(TUint(aDeviceNumber)>=TUint(KMaxHalEntries))
+		return r;
+	if (aGroup>=0 && aGroup<KMaxHalGroups)
+		{
+		SHalEntry2* pE=&K::HalEntryArray[aGroup];
+		SHalEntry* pBase=(SHalEntry*)pE;
+		THalFunc f=NULL;
+		TAny* p=NULL;
+		if(aDeviceNumber>0)
+			{
+			if(!pE->iExtendedEntries)
+				return r;
+			pBase=pE->iExtendedEntries + (aDeviceNumber-1);
+			}
+		NKern::LockSystem();
+		f=pBase->iFunction;
+		p=pBase->iPtr;
+		NKern::UnlockSystem();
+		if (f)
+			r=(*f)(p,aFunction,a1,a2);
+		}
+	return r;
+	}
+
+TUint32 ExecHandler::DebugMask()
+	{
+	return TheSuperPage().iDebugMask[0];
+	}
+
+TUint32 ExecHandler::DebugMaskIndex(TUint aIndex)
+ 	{
+	if (aIndex >= (TUint)KNumTraceMaskWords) 
+		return 0;	
+	else
+		return TheSuperPage().iDebugMask[aIndex];
+	}
+
+void ExecHandler::SetDebugMask(TUint32 aVal)
+	{
+	TheSuperPage().iDebugMask[0]=(TInt)aVal;
+	}
+
+void ExecHandler::SetDebugMaskIndex(TUint32 aVal, TUint aIndex)
+	{
+	if (aIndex >= (TUint)KNumTraceMaskWords) return;
+	
+	// check that we have permission to set KALLTHREADSSYSTEM bit
+	if (aIndex == DEBUGMASKWORD2 && (aVal & (1 << (KALLTHREADSSYSTEM%32))))
+		{
+		DProcess* currentProcess=TheCurrentThread->iOwningProcess;
+		if(!currentProcess->HasCapability(ECapabilityProtServ,__PLATSEC_DIAGNOSTIC_STRING("Checked by User::SetDebugMask(TUint32, TUint)")))
+			K::UnlockedPlatformSecurityPanic();
+		}
+
+	TheSuperPage().iDebugMask[aIndex]=(TInt)aVal;
+	}
+
+RAllocator* ExecHandler::HeapSwitch(RAllocator* aA)
+	{
+	DThread* pT = TheCurrentThread;
+	RAllocator* pA = pT->iAllocator;
+	pT->iAllocator = aA;
+	if (!pT->iCreatedAllocator)
+		pT->iCreatedAllocator = aA;
+	return pA;
+	}
+
+void ExecHandler::KernelHeapDebug(TInt aFunction, TInt a1, TAny* a2)
+	{
+	(void)aFunction;
+	(void)a1;
+	(void)a2;
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::KernelHeapDebug %d,%08x,%08x",aFunction,a1,a2));
+#ifdef _DEBUG
+	TInt panic=KMinTInt;
+	switch (aFunction)
+		{
+		case EDbgMarkStart:
+			NKern::ThreadEnterCS();
+			K::Allocator->__DbgMarkStart();
+			NKern::ThreadLeaveCS();
+			break;
+
+		case EDbgMarkCheck:
+			{
+			TBuf8<KMaxFileName> name;
+			TKernelHeapMarkCheckInfo info;
+			kumemget32(&info,a2,sizeof(info));
+			Kern::KUDesGet(name,*info.iFileName);
+			NKern::ThreadEnterCS();
+			TInt r = K::Allocator->__DbgMarkCheck(info.iCountAll, a1, name, info.iLineNum);
+			if (r!=KErrNone)
+				panic=EFailedKernelHeapCheck;
+			NKern::ThreadLeaveCS();
+			break;
+			}
+
+		case EDbgMarkEnd:
+			{
+			NKern::ThreadEnterCS();
+			TInt r = K::Allocator->__DbgMarkEnd(a1);
+			if (r!=KErrNone)
+				panic=EFailedKernelHeapCheck;
+			NKern::ThreadLeaveCS();
+			break;
+			}
+
+		case EDbgSetAllocFail:
+			NKern::ThreadEnterCS();
+			K::Allocator->__DbgSetAllocFail((RAllocator::TAllocFail)a1,(TInt)a2);
+			NKern::ThreadLeaveCS();
+			break;
+
+		case EDbgSetBurstAllocFail:
+			{
+			SRAllocatorBurstFail burstFail;
+			kumemget32(&burstFail, a2, sizeof(SRAllocatorBurstFail));
+			NKern::ThreadEnterCS();
+			K::Allocator->__DbgSetBurstAllocFail((RAllocator::TAllocFail)a1, burstFail.iRate, burstFail.iBurst);
+			NKern::ThreadLeaveCS();
+			break;
+			}
+
+		case EDbgCheckFailure:
+			{
+			NKern::ThreadEnterCS();
+			TUint failures = K::Allocator->__DbgCheckFailure();
+			NKern::ThreadLeaveCS();
+			kumemput32(a2, (TAny*)&failures, sizeof(TUint));
+			break;
+			}
+
+		default:
+			panic=EBadKernelHeapDebugFunction;
+			break;
+		}
+	if (panic>KMinTInt)
+		K::PanicKernExec(panic);
+#endif
+	}
+
+TExceptionHandler ExecHandler::ExceptionHandler(DThread* aThread)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ExceptionHandler"));
+	if(aThread!=TheCurrentThread)
+		if(TheCurrentThread->iOwningProcess->iSecurityZone!=KSecurityZoneLegacyCode
+			|| aThread->iOwningProcess->iSecurityZone!=KSecurityZoneLegacyCode
+			)
+			K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RThread::ExceptionHandler"));
+	return aThread->iExceptionHandler;
+	}
+
+TInt ExecHandler::SetExceptionHandler(DThread* aThread, TExceptionHandler aHandler, TUint32 aMask)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::SetExceptionHandler"));
+	if(aThread!=TheCurrentThread)
+		if(TheCurrentThread->iOwningProcess->iSecurityZone!=KSecurityZoneLegacyCode
+			|| aThread->iOwningProcess->iSecurityZone!=KSecurityZoneLegacyCode
+			)
+			K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RThread::SetExceptionHandler"));
+	aThread->iExceptionHandler=aHandler;
+	aThread->iExceptionMask=aMask;
+	return KErrNone;
+	}
+
+void ExecHandler::ModifyExceptionMask(DThread* aThread, TUint32 aClearMask, TUint32 aSetMask)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ModifyExceptionMask"));
+	if(aThread!=TheCurrentThread)
+		if(TheCurrentThread->iOwningProcess->iSecurityZone!=KSecurityZoneLegacyCode
+			|| aThread->iOwningProcess->iSecurityZone!=KSecurityZoneLegacyCode
+			)
+			K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RThread::ModifyExceptionMask"));
+	TUint& m=aThread->iExceptionMask;
+	m=(m&~aClearMask)|aSetMask;
+	}
+
+TInt ExecHandler::RaiseException(DThread* aThread, TExcType aType)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::RaiseException %d on %O",aType,aThread));
+	if(aThread!=TheCurrentThread)
+		if(TheCurrentThread->iOwningProcess->iSecurityZone!=KSecurityZoneLegacyCode
+			|| aThread->iOwningProcess->iSecurityZone!=KSecurityZoneLegacyCode
+			)
+			K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RThread::RaiseException"));
+	return aThread->RaiseException(aType);
+	}
+
+TBool ExecHandler::IsExceptionHandled(DThread* aThread,TExcType aType, TBool aSwExcInProgress)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::IsExceptionHandled %d %d",aType,aSwExcInProgress));
+	if(aThread!=TheCurrentThread)
+		if(TheCurrentThread->iOwningProcess->iSecurityZone!=KSecurityZoneLegacyCode
+			|| aThread->iOwningProcess->iSecurityZone!=KSecurityZoneLegacyCode
+			)
+			K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RThread::IsExceptionHandled"));
+	TBool isHandled=aThread->IsExceptionHandled(aType);
+	NKern::UnlockSystem();
+	if (aSwExcInProgress)
+		DKernelEventHandler::Dispatch(EEventSwExc, (TAny*)aType, NULL);
+	return isHandled;
+	}
+
+void ExecHandler::ThreadContext(DThread* aThread, TDes8& aDes)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadContext %O",aThread));
+	TBuf8<KMaxThreadContext> c;
+	aThread->Context(c);
+	NKern::UnlockSystem();
+	Kern::InfoCopy(aDes,c);
+	}
+
+TInt ExecHandler::ThreadStackInfo(DThread* aThread, TThreadStackInfo& aInfo)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadStackInfo %O",aThread));
+	TThreadStackInfo info;
+	memclr(&info, sizeof(info));
+	TInt r=KErrGeneral;
+	if(aThread->iUserStackRunAddress)
+		{
+		info.iBase = aThread->iUserStackRunAddress+aThread->iUserStackSize;
+		info.iLimit = aThread->iUserStackRunAddress;
+		info.iExpandLimit = aThread->iUserStackRunAddress;
+		r = KErrNone;
+		}
+	NKern::UnlockSystem();
+	kumemput32(&aInfo,&info,sizeof(info));
+	return r;
+	}
+
+TInt ExecHandler::ProcessGetMemoryInfo(TInt aProcessHandle, TModuleMemoryInfo& aInfo)
+	{
+	TModuleMemoryInfo info;
+	memclr(&info, sizeof(info));
+	TInt r = KErrGeneral;
+	NKern::LockSystem();
+
+XTRAP_PAGING_RETRY(
+	DProcess* process = (DProcess*)K::ObjectFromHandle(aProcessHandle,EProcess);
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessGetMemoryInfo %O",process));
+	DCodeSeg* seg=process->iCodeSeg;
+	if(seg)
+		r = seg->GetMemoryInfo(info,TheCurrentThread->iOwningProcess);
+)
+	NKern::UnlockSystem();
+	kumemput32(&aInfo, &info, sizeof(info));
+	return r;
+	}
+
+TInt ExecHandler::LibraryGetMemoryInfo(TInt aLibraryHandle, TModuleMemoryInfo& aInfo)
+	{
+	TModuleMemoryInfo info;
+	memclr(&info, sizeof(info));
+	TInt r = KErrGeneral;
+	NKern::LockSystem();
+
+XTRAP_PAGING_RETRY(
+	DLibrary* library = (DLibrary*)K::ObjectFromHandle(aLibraryHandle,ELibrary);
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::LibraryGetMemoryInfo %O",library));
+	DCodeSeg* seg=library->iCodeSeg;
+	if(seg)
+		r = seg->GetMemoryInfo(info,TheCurrentThread->iOwningProcess);
+)
+	NKern::UnlockSystem();
+	kumemput32(&aInfo, &info, sizeof(info));
+	return r;
+	}
+
+void AccessMachineConfig()
+	{
+	NKern::ThreadEnterCS();
+	Kern::MutexWait(*K::MachineConfigMutex);
+	}
+
+void EndAccessMachineConfig()
+	{
+	Kern::MutexSignal(*K::MachineConfigMutex);
+	NKern::ThreadLeaveCS();
+	}
+
+TInt ExecHandler::MachineConfiguration(TDes8& aConfig, TInt& aSize)
+//
+// Get the machine configuration
+// Enter and leave with system unlocked
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::MachineConfiguration"));
+	if(!Kern::CurrentThreadHasCapability(ECapabilityReadDeviceData,__PLATSEC_DIAGNOSTIC_STRING("Checked by User::MachineConfiguration")))
+		K::UnlockedPlatformSecurityPanic();
+    const TPtrC8 platConfig(A::MachineConfiguration());
+    TInt platSize=platConfig.Length();
+	TInt usize=sizeof(TUid)+sizeof(TVersion)+sizeof(platSize)+platSize;
+
+	TInt ulen, umax;
+	Kern::KUDesInfo(aConfig,ulen,umax);
+	TInt r = KErrArgument;
+	if(umax<usize)
+		goto done; // user buffer not big enough
+
+	// create tempory  buffer for config data
+	{
+	DThread& t=*TheCurrentThread;
+	NKern::ThreadEnterCS();
+	TUint8* buf=(TUint8*)Kern::Alloc(usize);
+	t.iTempAlloc=buf;			// if we are killed, buf will be deleted
+	NKern::ThreadLeaveCS();
+	r = KErrNoMemory;
+	if (!buf)
+		goto done; // no memory
+
+	// get config data
+	{
+	TUint8* p=buf;
+	*((TUid*&)p)++ = KMachineConfigurationUid;
+	*((TVersion*&)p)++ = TVersion(KMachineConfigurationMajorVersionNumber,KMachineConfigurationMinorVersionNumber,KMachineConfigurationBuildVersionNumber);
+	*((TInt*&)p)++ = platSize;
+	AccessMachineConfig();
+	NKern::LockSystem();
+	memcpy(p,platConfig.Ptr(),platSize);
+	NKern::UnlockSystem();
+	EndAccessMachineConfig();
+
+	Kern::KUDesPut(aConfig,TPtrC8(buf,usize));
+
+	NKern::ThreadEnterCS();
+	t.iTempAlloc=NULL;
+	delete buf;
+	NKern::ThreadLeaveCS();
+
+	r = KErrNone;
+	}
+	}
+done:
+	kumemput32(&aSize,&usize,sizeof(usize));
+	return r;
+	}
+
+TInt ExecHandler::SetMachineConfiguration(const TDesC8& aConfig)
+//
+// Set the machine configuration
+// Enter and leave with system unlocked
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::SetMachineConfiguration"));
+	if(!Kern::CurrentThreadHasCapability(ECapabilityWriteDeviceData,__PLATSEC_DIAGNOSTIC_STRING("Checked by User::SetMachineConfiguration")))
+		K::UnlockedPlatformSecurityPanic();
+	TInt len;
+	TInt maxLen;
+	const TUint8* pC=Kern::KUDesInfo(aConfig,len,maxLen);
+	TInt r=KErrNoMemory;
+	TUint8* pB=NULL;
+    TPckgBuf<TUid> uid;
+    TPckgBuf<TVersion> version;
+    TPckgBuf<TInt> platSizeBuf;
+	TInt platSize;
+	TInt i=0;
+	TPtrC8 platConfig;
+	DThread& t=*TheCurrentThread;
+
+	// first allocate a kernel-side buffer big enough to hold the new configuration
+	NKern::ThreadEnterCS();
+	pB=(TUint8*)Kern::Alloc(len);
+	if (!pB)
+		goto endSetMachineConfig2;
+	t.iTempAlloc=pB;			// if we are killed, pB will be deleted
+	NKern::ThreadLeaveCS();
+
+	// copy the configuration
+	kumemget(pB,pC,len);
+	r=KErrArgument;
+	if (len<(TInt)(sizeof(TUid)+sizeof(TVersion)+sizeof(TInt)))
+		goto endSetMachineConfig;
+
+	// extract and check the UID
+	uid.Copy(pB+i,(TInt)sizeof(TUid));
+    if (uid().iUid!=KMachineConfigurationUidValue)
+		goto endSetMachineConfig;
+	i+=(TInt)sizeof(TUid);
+
+	// extract and check the version
+	version.Copy(pB+i,(TInt)sizeof(TVersion));
+	r=KErrNotSupported;
+    if(!Kern::QueryVersionSupported(TVersion(KMachineConfigurationMajorVersionNumber,KMachineConfigurationMinorVersionNumber,KMachineConfigurationBuildVersionNumber),version()))
+		goto endSetMachineConfig;
+	i+=(TInt)sizeof(TVersion);
+
+	// extract and check the super page size
+	platSizeBuf.Copy(pB+i,(TInt)sizeof(TInt));
+	i+=(TInt)sizeof(TInt);
+	platSize=platSizeBuf();
+	r=KErrArgument;
+    if (platSize>(len-i))
+		goto endSetMachineConfig;
+
+	platConfig.Set(pB+i,platSize);
+
+	// restore the super page config
+	AccessMachineConfig();
+	K::SetMachineConfiguration(platConfig);
+	r=KErrNone;
+	EndAccessMachineConfig();
+
+endSetMachineConfig:
+	NKern::ThreadEnterCS();
+	t.iTempAlloc=NULL;
+	delete pB;
+endSetMachineConfig2:
+	NKern::ThreadLeaveCS();
+	return r;
+	}
+
+TInt ExecHandler::ThreadCreate(const TDesC8& aName, TOwnerType aType, SThreadCreateInfo& aInfo)
+	{
+	TKName n;
+	Kern::KUDesGet(n,aName);
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadCreate %lS",&n));
+	TUint32 infoBuf[KMaxThreadCreateInfo/sizeof(TUint32)];
+	SThreadCreateInfo& info = *(SThreadCreateInfo*)infoBuf;
+	kumemget32(&info, &aInfo, sizeof(SThreadCreateInfo));
+	TInt r = ( (info.iTotalSize < (TInt)sizeof(SThreadCreateInfo)) || (info.iTotalSize > KMaxThreadCreateInfo) || (info.iTotalSize & 7) )
+		? KErrArgument : KErrNone;
+	if (info.iUserStackSize < KMaxThreadCreateInfo*2)
+		r=KErrArgument;
+	if (r==KErrNone)
+		{
+		if (info.iTotalSize > (TInt)sizeof(SThreadCreateInfo))
+			kumemget32( (&info)+1, (&aInfo)+1, info.iTotalSize-(TInt)sizeof(SThreadCreateInfo) );
+		info.iType=EThreadUser;
+		info.iSupervisorStackSize=0;	// zero means use default value
+		info.iSupervisorStack=NULL;
+		info.iInitialThreadPriority=EThrdPriorityNormal;
+		info.iName.Set(n);
+		NKern::ThreadEnterCS();
+		DThread* pT=NULL;
+		TInt h;
+		r=TheCurrentThread->iOwningProcess->NewThread(pT, info, &h, aType);
+		if(r==KErrNone)
+			r = h;
+		NKern::ThreadLeaveCS();
+		}
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadCreate returns %d",r));
+	return r;
+	}
+
+/********************************************
+ * Kernel-side executive calls
+ ********************************************/
+
+TInt K::MutexCreate(DMutex*& aMutex, const TDesC& aName, DObject* anOwner, TBool aVisible, TUint aOrder)
+	{
+	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("K::MutexCreate %lS owner %O visible=%d order=%02x",&aName,anOwner,aVisible,aOrder));
+	DMutex* pM=new DMutex;
+	TInt r=KErrNoMemory;
+	if (pM)
+		{
+		r=pM->Create(anOwner, &aName, aVisible, aOrder);
+		if (r==KErrNone)
+			aMutex=pM;
+		else
+			pM->Close(NULL);
+		}
+	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("K::MutexCreate returns %d %08x",r,pM));
+	return r;
+	}
+
+/**	Creates a new thread.
+
+	It receives a parameter of type SThreadCreateInfo. The members of this structure have the following meaning for this function:
+
+	iHandle	[out]	Heap allocated DThread pointer to the new created thread.
+					This member is valid only if the return code is KErrNone.
+					Do not assume it's NULL if the operation failed.
+	iType	[in]	Specifies if the thread will run in User mode or in Kernel mode.
+					It can be one of:
+						EThreadInitial - this is the initial thread
+						EThreadSupervisor - this runs in supervisor mode
+						EThreadMinimalSupervisor - this runs in supervisor mode and has no handles array
+						EThreadUser - this runs in User Mode
+						EThreadAPInitial - this is the initial thread on a non-boot processor (SMP only)
+	iFunction [in]	This is the function that will be run in the new thread.
+	iPtr	[in]	Extra custom parameters passed to iFunction when it starts running.
+	iSupervisorStack	Ignored.
+	iSupervisorStackSize [in]	If the thread is a Kernel thread, this parameter will specify the desired supervisor stack size.
+								If the size is 0, the size will be specified by K::SupervisorThreadStackSize, which is 4K.
+								The size will be rounded up to Page or Block size.
+	iUserStack			Ignored.
+	iUserStackSize [in]	If the thread is a User Mode thread, this parameter will specify the desired user stack size.
+						The size will be rounded up to Page or Block size.
+						It will fail with KErrTooBig if the size is greater than PP::MaxUserThreadStack which is usually set to 0x14000 (80K).
+	iInitialThreadPriority [in] Initial priority for this thread. Must be in [0,63] interval.
+	iName	[in]	Name of the thread. In case you do not specify a name for this thread, it will be created EProtected
+					and any attempts to open it will fail with KErrPermissionDenied. Otherwise, the object will be EGlobal.
+	iTotalSize [in]	Total size in bytes of the SThreadCreateInfo, including the extras. Fails with KErrArgument if it's less than sizeof(SThreadCreateInfo) or greater than KMaxThreadCreateInfo.
+
+	It can fail with KErrArgument if aInfo.iTotalSize is not set correctly or aInfo.iPriority is not in [0,63] interval
+	In x86 port it can fail with KErrArgument if anInfo.iStackBase is NULL or anInfo.iStackSize is less than 0x100
+	It can fail with KErrTooBig if aInfo.iUserStackSize is bigger than maximum user stack size
+	It can fail in Emulator with a Win32 error code returned by GetLastError if the Win32 thread or the scheduler Win32 event cannot be created
+	It can fail with KErrDied if the thread dies during the creation process
+	It can fail with KErrNoMemory in OOM scenarios.
+	It can fail with KErrGeneral indicating a general malfunction or data corruption.
+	
+	If it succeeds it will return the heap allocated DThread pointer to the new created thread in iHandle member of aInfo
+	  
+	@param aInfo Information passed by the caller to specify how to create the thread.
+	
+	@pre Calling thread must be in a critical section.
+	@pre Call in a thread context.
+	@pre Kernel must be unlocked.
+	@pre interrupts enabled
+	@pre No fast mutex can be held
+	
+	@post Calling thread is in a critical section.
+*/
+EXPORT_C TInt Kern::ThreadCreate(SThreadCreateInfo& aInfo)
+	{
+	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Kern::ThreadCreate");		
+	__KTRACE_OPT(KEXEC,Kern::Printf("Kern::ThreadCreate %lS",&aInfo.iName));
+	aInfo.iHandle=NULL;
+	DThread* pT=NULL;
+	TBool svc = aInfo.iType!=EThreadUser;
+	DProcess* pP = svc ? K::TheKernelProcess : TheCurrentThread->iOwningProcess;
+	aInfo.iSupervisorStack = NULL;
+	aInfo.iUserStack = NULL;
+	TInt r = pP->NewThread(pT, aInfo, NULL, EOwnerProcess);
+	if (r==KErrNone)
+		aInfo.iHandle = pT;
+	__KTRACE_OPT(KEXEC,Kern::Printf("Kern::ThreadCreate returns %d",r));
+	return r;
+	}
+
+#ifdef _UNICODE
+void ccopy (TUint16* aDest, const TAny* aSrc)
+{
+	TUint16* pSrc = (TUint16*)aSrc;
+	if(aSrc) {
+		TUint16* p = aDest + 1;
+		for (;*pSrc;)
+			*p++ = *pSrc++;
+		*aDest = (TUint16)(p-aDest-1);
+	}
+	else
+		*aDest = 0;	
+}
+#else
+void ccopy (TUint8* aDest, const TAny* aSrc)
+{
+	TUint8* pSrc = (TUint8*)aSrc;
+	if(aSrc) {
+		TUint8* p = aDest + 1;
+		for (;*pSrc;)
+			*p++ = *pSrc++;
+		*aDest = (TUint8)(p-aDest-1);
+	}
+	else
+		*aDest = 0;	
+}
+#endif
+
+TInt ExecHandler::GetModuleNameFromAddress(TAny* aPtr, TDes8& aModuleName)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::GetModuleNameFromAddress 0x%X", aPtr));
+	TFileName fn;
+	Kern::AccessCode();
+	DCodeSeg* pSeg = Kern::CodeSegFromAddress( (TLinAddr)aPtr, TheCurrentThread->iOwningProcess );
+	if (pSeg)
+		pSeg->AppendFullFileName(fn);
+	Kern::EndAccessCode();
+	if (!pSeg)
+		{
+ 		return KErrNotFound;
+		}
+	Kern::KUDesPut(aModuleName, fn);
+	return KErrNone;
+	}
+
+TInt ExecHandler::LocaleExports(TAny* aHandle, TLibraryFunction* aExportList)
+//
+// Change Locale setups
+//
+// NOTES
+//
+// 1. A mutex is NOT used to protect this, so if it is called by more than one thread
+//    simultaneousely, the locale info may be garbled.
+// 2. Locale libraries are never closed once they have been used. This prevents them from
+//    being unloaded whilst other threads are referencing the data contained in them.
+// 3. This function doesn't duplicate the EKA1 behaviour of saving the default data for
+//    restoring later.
+//
+// The current use case for this function is that it is called once by WSERV after boot,
+// so the above points should never be a problem. ( A generic 'change locale' will cause
+// all sorts of problems throught the OS, so current practice won't change before a
+// comprehensive rearchitecture occurs anyway.)
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::LocaleExports"));
+
+	DCodeSeg& cs=*DCodeSeg::VerifyCallerAndHandle(aHandle);
+
+  	if(cs.iUids.iUid[1].iUid !=	KLocaleDllUid.iUid)
+  		return KErrNotSupported;
+
+	// Increment the code segment's access count
+	// This will increment every time the same locale is reloaded, but
+	// this doesn't matter since we don't unload locale DLLs.
+	NKern::ThreadEnterCS();
+	DCodeSeg::Wait();
+	cs.CheckedOpen();
+	DCodeSeg::Signal();
+	NKern::ThreadLeaveCS();
+	
+	TLibraryFunction data[KNumLocaleExports];
+	TInt n;
+	for(n=0; n<KNumLocaleExports; n++)
+		data[n] = (TLibraryFunction)cs.Lookup(n);
+  
+	kumemput32(aExportList, &data[0], KNumLocaleExports * sizeof(TLibraryFunction));
+
+	return KErrNone;
+	}
+
+TInt ExecHandler::ResetMachine(TMachineStartupType /*aType*/)
+	{
+	// Don't implement without considering Platform Security!
+	return KErrNotSupported;
+	}
+
+TInt ExecHandler::ExecuteInSupervisorMode(TSupervisorFunction aFunction, TAny* aParameter)
+//
+// Execute a function in supervisor mode. Only available to F32 - panic anyone else
+//
+	{
+#ifndef __MEMMODEL_FLEXIBLE__
+	if (TheCurrentThread->iOwningProcess == K::TheFileServerProcess)
+		{
+		UNLOCK_USER_MEMORY();
+		TInt r = A::CallSupervisorFunction(aFunction,aParameter);
+		LOCK_USER_MEMORY();
+		return r;
+		}
+#endif
+	K::PanicKernExec(EAccessDenied);
+	return 0;
+	}
+
+_LIT(KDriveZed, "Z:");
+void ExecHandler::DllFileName(TInt aHandle, TDes8& aFileName)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::DllFileName %08x",aHandle));
+	TFileName n;
+	Kern::AccessCode();
+	DCodeSeg* pS=DCodeSeg::CodeSegFromEntryPoint(aHandle);
+	if (pS)
+		pS->AppendFullFileName(n);
+	else
+		n=KDriveZed;
+	Kern::EndAccessCode();
+	if (pS)
+		P::NormalizeExecutableFileName(n);
+	Kern::KUDesPut(aFileName,n);
+	}
+
+#ifdef MONITOR_THREAD_CPU_TIME
+TInt ExecHandler::ThreadGetCpuTime(DThread* aThread, Int64& aTime)
+	{
+#ifndef __SMP__
+	TInt64 time = (1000000 * aThread->iNThread.iTotalCpuTime) / NKern::FastCounterFrequency();
+	NKern::UnlockSystem();
+	kumemput32(&aTime, &time, sizeof(TInt64));
+#else
+	TUint64 t = NKern::ThreadCpuTime(&aThread->iNThread);
+	NKern::UnlockSystem();
+	TUint32 f = NKern::CpuTimeMeasFreq();
+	TUint64 t2 = t>>32;
+	t = ((t<<32)>>32)*1000000;
+	t2 *= 1000000;
+	t2 += (t>>32);
+	t &= TUint64(KMaxTUint32);
+	TUint64 q2 = t2/f;
+	t2 -= q2*f;
+	t += (t2<<32);
+	TUint64 q = t/f;
+	q += (q2<<32);
+	kumemput32(&aTime, &q, sizeof(TInt64));
+#endif
+	return KErrNone;
+	}
+#else		
+TInt ExecHandler::ThreadGetCpuTime(DThread* /*aThread*/, Int64& /*aTime*/)
+	{
+	NKern::UnlockSystem();
+	return KErrNotSupported;
+	}
+#endif
+
+TInt ExecHandler::SetMemoryThresholds(TInt aLowThreshold, TInt aGoodThreshold)
+	{
+	if(!Kern::CurrentThreadHasCapability(ECapabilityWriteDeviceData,__PLATSEC_DIAGNOSTIC_STRING("Checked by UserSvr::SetMemoryThresholds")))
+		K::LockedPlatformSecurityPanic();
+	if (aLowThreshold<0 || aGoodThreshold<aLowThreshold)
+		return KErrArgument;
+	K::MemoryLowThreshold=aLowThreshold;
+	K::MemoryGoodThreshold=aGoodThreshold;
+	return KErrNone;
+	}
+
+void ExecHandler::FsRegisterThread()
+//
+// Register the file server thread
+//
+	{
+
+	__KTRACE_OPT(KBOOT,Kern::Printf("File server thread registered"));
+	DThread* pT = TheCurrentThread;
+	DProcess* pP = pT->iOwningProcess;
+	pP->iFlags |= (KThreadFlagProcessCritical | KProcessFlagSystemPermanent);
+	pT->iFlags |= KThreadFlagSystemPermanent;
+	if (K::TheFileServerProcess && K::TheFileServerProcess!=pP)
+		K::PanicCurrentThread(EAccessDenied);
+	K::TheFileServerProcess=pP;
+	K::ThreadEnterCS();
+	pP->SetPriority(EPriorityFileServer);
+	M::FsRegisterThread();
+	K::ThreadLeaveCS();
+	}
+
+
+void ExecHandler::RegisterTrustedChunk(DChunk* aChunk)
+//
+// Register file server's chunk intended for DMA transfer
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::RegisterTrustedChunk %x",aChunk));
+
+	DProcess* pP=TheCurrentThread->iOwningProcess;
+	if (K::TheFileServerProcess && K::TheFileServerProcess!=pP)
+		{
+		K::PanicCurrentThread(EAccessDenied);
+		}
+	aChunk->iAttributes |= DChunk::ETrustedChunk;
+	}
+	
+void ExecHandler::WsRegisterThread()
+//
+// Register the window server thread
+//
+	{
+
+	__KTRACE_OPT(KBOOT,Kern::Printf("Window server thread registered"));
+	DProcess* pP=TheCurrentThread->iOwningProcess;
+	if (K::TheWindowServerProcess && K::TheWindowServerProcess!=pP)
+		K::PanicCurrentThread(EAccessDenied);
+	K::TheWindowServerProcess=pP;
+	K::ThreadEnterCS();
+	pP->SetPriority(EPriorityWindowServer);
+	K::ThreadLeaveCS();
+	}
+
+void ExecHandler::RequestSignal(TInt aCount)
+//
+// Signal the request semaphore.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::RequestSignal %d",aCount));
+	NKern::ThreadRequestSignal(NULL,aCount);
+	}
+
+TInt ExecHandler::ThreadRequestCount(DThread* aThread)
+//
+// Get the request semaphores count.
+//
+	{
+
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadRequestCount"));
+	return aThread->iNThread.iRequestSemaphore.iCount;
+	}
+
+void CompleteUserAfter(TAny* aPtr)
+	{
+	DThread* pT=DThread::FromTimer(aPtr);
+	if (pT->iTimer.iState==TTimer::EWaiting)
+		{
+		Kern::QueueRequestComplete(pT,pT->iTimer.iRequest,KErrNone);
+		pT->iTimer.iState=TTimer::EIdle;
+		}
+	}
+
+void CompleteUserAt(TAny* aPtr)
+	{
+	DThread* pT=DThread::FromTimer(aPtr);
+	if (pT->iTimer.iState==TTimer::EWaiting)
+		{
+		Kern::QueueRequestComplete(pT,pT->iTimer.iRequest,KErrNone);
+		pT->iTimer.iState=TTimer::EIdle;
+		}
+	}
+
+void CompleteUserAfterHighRes(TAny* aPtr)
+	{
+	DThread* pT=DThread::FromTimer(aPtr);
+	NKern::LockSystem();
+	pT->iTimer.iState=TTimer::EIdle;
+	Kern::QueueRequestComplete(pT,pT->iTimer.iRequest,KErrNone);
+	NKern::UnlockSystem();
+	}
+
+void ExecHandler::After(TInt anInterval, TRequestStatus& aStatus)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::After %d",anInterval));
+	TInt iv=anInterval;
+	if (iv<=0)
+		{
+		// just rotate the ready queue for this thread
+		NKern::RotateReadyList(-1);
+		TRequestStatus* s=&aStatus;
+		Kern::RequestComplete(s,KErrNone);
+		return;
+		}
+	NKern::ThreadEnterCS();
+	TInt r=TheCurrentThread->iTimer.After(iv,CompleteUserAfter,aStatus);
+	NKern::ThreadLeaveCS();
+	if (r==KErrInUse)
+		K::PanicKernExec(ETimerAlreadyPending);
+	else if (r!=KErrNone)
+		{
+		TRequestStatus* s=&aStatus;
+		Kern::RequestComplete(s,r);
+		}
+	}
+
+void ExecHandler::AfterHighRes(TInt anInterval, TRequestStatus& aStatus)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::AfterHighRes %d",anInterval));
+	TInt r=TheCurrentThread->iTimer.AfterHighRes(anInterval,CompleteUserAfterHighRes,aStatus);
+	if (r==KErrInUse)
+		K::PanicCurrentThread(ETimerAlreadyPending);
+	}
+
+void ExecHandler::At(const TTimeK& aTime, TRequestStatus& aStatus)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::At"));
+	TTimeK time;
+	kumemget32(&time,&aTime,sizeof(time));
+	NKern::ThreadEnterCS();
+	TInt r=TheCurrentThread->iTimer.At(time,CompleteUserAt,aStatus);
+	NKern::ThreadLeaveCS();
+	if (r==KErrInUse)
+		K::PanicKernExec(ETimerAlreadyPending);
+	else if (r!=KErrNone)
+		{
+		TRequestStatus* s=&aStatus;
+		Kern::RequestComplete(s,r);
+		}
+	}
+
+#ifndef __FASTEXEC_MACHINE_CODED__
+RAllocator* ExecHandler::Heap()
+	{
+	return TheCurrentThread->iAllocator;
+	}
+
+extern void InvalidFastExec();
+
+TTrapHandler* ExecHandler::PushTrapFrame(TTrap* aFrame)
+//
+// Push a new trap frame.
+//
+	{
+#ifdef __LEAVE_EQUALS_THROW__
+#ifdef __WINS__
+	// On WINS overload this function to remember when a TWin32SEHTrap is installed
+	// over another one
+	DThread& t=*TheCurrentThread;
+	t.iFrame=aFrame;
+	return 0;
+#else
+	InvalidFastExec();
+	return (TTrapHandler*)aFrame; // Prevents compiler warnings
+#endif
+#else
+	DThread& t=*TheCurrentThread;
+	aFrame->iHandler=t.iTrapHandler;
+	aFrame->iNext=t.iFrame;
+	t.iFrame=aFrame;
+	return t.iTrapHandler;
+#endif
+	}
+
+TTrap* ExecHandler::PopTrapFrame()
+//
+// Pop the current frame.
+//
+	{
+#ifdef __LEAVE_EQUALS_THROW__
+#ifdef __WINS__
+	// On WINS overload this function to recall when a TWin32SEHTrap is installed
+	// over another one
+	DThread& t=*TheCurrentThread;
+	return t.iFrame;
+#else
+	InvalidFastExec();
+	return 0;
+#endif
+#else
+	DThread& t=*TheCurrentThread;
+	TTrap* pF=t.iFrame;
+	if (pF)
+		t.iFrame=pF->iNext;
+	return pF;
+#endif
+	}
+
+CActiveScheduler* ExecHandler::ActiveScheduler()
+//
+// Return the address of the current active scheduler
+//
+	{
+	DThread& t=*TheCurrentThread;
+	return t.iScheduler;
+	}
+
+void ExecHandler::SetActiveScheduler(CActiveScheduler* aScheduler)
+//
+// Set the address of the current active scheduler
+//
+	{
+	DThread& t=*TheCurrentThread;
+	t.iScheduler=aScheduler;
+	}
+
+TTrapHandler* ExecHandler::TrapHandler()
+//
+// Return the current trap handler.
+//
+	{
+	DThread& t=*TheCurrentThread;
+	return t.iTrapHandler;
+	}
+
+TTrapHandler* ExecHandler::SetTrapHandler(TTrapHandler* aHandler)
+//
+// Set the current trap handler.
+//
+	{
+	DThread& t=*TheCurrentThread;
+	TTrapHandler* pH=t.iTrapHandler;
+	t.iTrapHandler=aHandler;
+	return pH;
+	}
+
+void ExecHandler::SetReentryPoint(TLinAddr a)
+	{
+	DThread& t = *TheCurrentThread;
+	t.iOwningProcess->iReentryPoint = a;
+	}
+#endif
+
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+void K::DoProcessIsolationFailure(const char* aContextText)
+	{
+	// enter with system locked
+	if(TheSuperPage().KernelConfigFlags() & EKernelConfigPlatSecProcessIsolation)
+		{
+		if(PlatSec::ProcessIsolationFail(aContextText)==KErrNone)
+			return;
+		LockedPlatformSecurityPanic();
+		}
+	}
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+void K::DoProcessIsolationFailure()
+	{
+	// enter with system locked
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+	DoProcessIsolationFailure(NULL);
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+	if (TheSuperPage().KernelConfigFlags() & EKernelConfigPlatSecProcessIsolation)
+		{
+		if (PlatSec::EmitDiagnostic() == KErrNone)
+			return;
+		LockedPlatformSecurityPanic();
+		}
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+	}
+
+
+void K::UnlockedPlatformSecurityPanic()
+	{
+	// enter with system unlocked
+	NKern::LockSystem();
+	K::LockedPlatformSecurityPanic();
+	}
+
+void K::LockedPlatformSecurityPanic()
+	{
+	// enter with system locked
+	K::PanicCurrentThread(EPlatformSecurityTrap);
+	}
+
+void ExecHandler::ThreadRendezvous(TInt aReason)
+	{
+	NKern::ThreadEnterCS();
+	TheCurrentThread->Rendezvous(aReason);
+	NKern::ThreadLeaveCS();
+	}
+
+void ExecHandler::ProcessRendezvous(TInt aReason)
+	{
+	NKern::ThreadEnterCS();
+	TheCurrentThread->iOwningProcess->Rendezvous(aReason);
+	NKern::ThreadLeaveCS();
+	}
+
+void ExecHandler::DebugPrint(TAny* aDes, TInt aMode)
+	{
+	TInt l, m;
+	const TText* p = Kern::KUDesInfo(*(const TDesC*)aDes, l, m);
+
+#ifdef __DEBUGGER_SUPPORT__
+	TUint r = DKernelEventHandler::Dispatch(EEventUserTrace, (TAny*)p, (TAny*)l);
+	if (r & DKernelEventHandler::ETraceHandled)
+		l = 0;
+#endif
+
+	TBuf8<256> buffer;
+	l = Min(l,256);
+	buffer.SetLength(l);
+	kumemget((TUint8*)buffer.Ptr(), p, l); //Copy user-side data into kernel memory
+	K::TextTrace(buffer,EUserTrace,!aMode);
+	}
+
+
+TInt ExecHandler::ProcessSetHandleParameter(DProcess* aProcess, TInt aSlot, TInt aHandle)
+	{
+	if (aProcess->iCreatorId != TheCurrentThread->iOwningProcess->iId) //check called by creator
+		K::LockedPlatformSecurityPanic();
+
+	if ((aSlot < 0) || (aSlot >= KArgIndex))
+		K::PanicCurrentThread(EParameterSlotRange);
+
+	if (aProcess->iEnvironmentData[aSlot] != 0)
+		K::PanicCurrentThread(EParameterSlotInUse);
+
+	DObject* pObject = K::ObjectFromHandle(aHandle);
+
+	if (pObject->Protection() == DObject::ELocal) 
+		K::LockedPlatformSecurityPanic();
+	pObject->CheckedOpen();
+
+	aProcess->iEnvironmentData[aSlot] = (TInt)pObject | EHandle;
+	return KErrNone;
+	}
+
+//no locks held on entry
+TInt ExecHandler::ProcessSetDataParameter(TInt aProcess, TInt aSlot, const TUint8* aData, TInt aLen)
+	{
+
+	if ((aSlot < 0) || (aSlot >= KArgIndex))
+		K::PanicKernExec(EParameterSlotRange);
+
+	if (aLen < 0)
+		K::PanicKernExec(EParameterSlotDataLength);
+
+	NKern::ThreadEnterCS();
+	HBuf8* pBuf = NULL;
+	if (aLen)
+		pBuf = HBuf8::New(aLen);
+
+	DThread* currentThread = TheCurrentThread;
+	currentThread->iTempAlloc = pBuf;
+	NKern::ThreadLeaveCS();				
+
+	if (aLen)
+		{
+		if (!pBuf)
+			return KErrNoMemory;
+		kumemget((void*)pBuf->Ptr(), aData, aLen);
+		pBuf->SetLength(aLen);
+		}
+
+
+	NKern::LockSystem();
+	DProcess* pProc = (DProcess*)K::ObjectFromHandle(aProcess, EProcess); 
+
+	if (pProc->iCreatorId != currentThread->iOwningProcess->iId) //check called by creator
+		K::LockedPlatformSecurityPanic();
+
+	if (pProc->iEnvironmentData[aSlot] != 0)
+		K::PanicCurrentThread(EParameterSlotInUse);
+
+	pProc->iEnvironmentData[aSlot] = (TInt)pBuf | EBinaryData;
+	currentThread->iTempAlloc = NULL;
+	NKern::UnlockSystem();
+
+	return KErrNone;
+	}
+
+
+
+//need to have sys locked on way in
+TInt ExecHandler::ProcessGetHandleParameter(TInt aSlot, TObjectType aObjectType, TOwnerType aOwnerType)
+	{
+
+	DThread * currentThread = TheCurrentThread;
+	DProcess * currentProcess = currentThread->iOwningProcess;
+
+	if ((aSlot < 0) || (aSlot >= KArgIndex))
+		K::PanicCurrentThread(EParameterSlotRange);
+
+	TInt data = currentProcess->iEnvironmentData[aSlot];
+
+	if (!data)
+		return KErrNotFound;
+
+	TProcessParameterType type = (TProcessParameterType)(data&3);
+
+	if (type != EHandle)
+		return KErrArgument;
+
+	DObject* pObject = (DObject*)(data&~3);
+
+	if ((TInt)aObjectType+1 != pObject->UniqueID())	//check it's the correct type
+		return KErrArgument;
+
+	// zero parameter to prevent race conditions while retrieving the object
+	currentProcess->iEnvironmentData[aSlot]=0;
+	
+	NKern::ThreadEnterCS();
+	NKern::UnlockSystem();
+	TInt handle = 0;
+
+	TInt ret = currentThread->MakeHandle(aOwnerType, pObject, handle);
+
+	NKern::LockSystem();
+	NKern::ThreadLeaveCS();
+
+	if (ret != KErrNone)
+		{
+		// restore parameter data as 'nothing happened'
+		currentProcess->iEnvironmentData[aSlot]=data;
+		return ret;
+		}
+	return handle;
+	}
+
+
+//enter with the system lock held, auto release on exit
+TInt ExecHandler::ProcessGetDataParameter(TInt aSlot,  TUint8* aData, TInt aLen)
+	{
+
+	DThread * currentThread = TheCurrentThread;
+	DProcess * currentProcess = currentThread->iOwningProcess;
+
+	if ((aSlot < 0) || (aSlot >= KArgIndex))
+		K::PanicCurrentThread(EParameterSlotRange);
+
+	TInt data = currentProcess->iEnvironmentData[aSlot];
+	if (!data)
+		return KErrNotFound;
+
+	TProcessParameterType type = (TProcessParameterType)(data&3);
+	if (type != EBinaryData)
+		return KErrArgument;
+
+	HBuf8* p = (HBuf8*)(data&~3);
+	if (!p)	//we've passed zero length binary data so nothing to copy
+		return 0;
+
+	if (aLen < p->Length())
+		return KErrArgument;
+
+	currentThread->iTempAlloc = p;
+	currentProcess->iEnvironmentData[aSlot] = 0;
+	NKern::UnlockSystem();
+
+	TInt len = p->Length();
+	kumemput((void*)aData, (void*)p->Ptr(), len);
+
+	NKern::ThreadEnterCS();
+	currentThread->iTempAlloc = NULL;
+	delete p;
+	NKern::ThreadLeaveCS();
+
+	NKern::LockSystem();
+	return len;
+	}
+
+TInt ExecHandler::ProcessDataParameterLength(TInt aSlot)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessDesParameterLength"));
+
+	DProcess * currentProcess = TheCurrentThread->iOwningProcess;
+
+	if ((aSlot < 0) || (aSlot >= KArgIndex))
+		K::PanicCurrentThread(EParameterSlotRange);
+
+	TInt data = currentProcess->iEnvironmentData[aSlot];
+
+	if (!data)
+		return KErrNotFound;
+
+	TProcessParameterType type = (TProcessParameterType)(data&3);
+
+	if (type != EBinaryData)
+		return KErrArgument;
+
+	const HBuf8* p = (const HBuf8*)(data&~3);
+
+	return p ? p->Length() : 0;
+	}
+
+
+
+void ExecHandler::NotifyChanges(TUint aChanges)
+//
+// Check that the caller has permission to notify the requested changes,
+// and pass it on to Kern::NotifyChanges if it's ok
+//
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::NotifyChanges"));
+	
+	if (aChanges & ~EChangesLocale)
+		K::UnlockedPlatformSecurityPanic();
+	
+	NKern::ThreadEnterCS();
+	Kern::NotifyChanges(aChanges);
+	NKern::ThreadLeaveCS();
+	}
+
+
+
+static TInt GlobalUserData[EMaxGlobalUserData] = {0};
+
+TInt ExecHandler::GetGlobalUserData(TInt aIndex)
+	{
+	if(TUint(aIndex)<TUint(EMaxGlobalUserData))
+		return GlobalUserData[aIndex];
+	return 0;
+	}
+
+TInt ExecHandler::SetGlobalUserData(TInt aIndex,TInt aValue)
+	{
+	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::SetGlobalUserData %d 0x%8x",aIndex,aValue));
+	if(TUint(aIndex)<TUint(EMaxGlobalUserData))
+		{
+		if(!Kern::CurrentThreadHasCapability(ECapabilityWriteDeviceData,__PLATSEC_DIAGNOSTIC_STRING("Checked by SetGlobalUserData")))
+			return KErrPermissionDenied;
+		else
+			{
+			GlobalUserData[aIndex] = aValue;
+			return KErrNone;
+			}
+		}
+	return KErrArgument;
+	}
+
+TBool ExecHandler::UserThreadExiting(TInt aReason)
+	{
+	// Mark this thread as exiting and check whether there are any other threads in the process that
+	// are not already exiting
+	
+	DThread* thread = TheCurrentThread;
+	DProcess* process = thread->iOwningProcess;
+	
+	NKern::ThreadEnterCS();
+
+	// If the thread is process permanent then all other threads in the process will be killed -
+	// make sure this happens now, so that this thread has a chance to run global object destructors.
+	if (thread->iFlags & KThreadFlagProcessPermanent)
+		{
+		__NK_ASSERT_ALWAYS(process->WaitProcessLock() == KErrNone);
+		NKern::LockSystem();
+		process->KillAllThreads(EExitKill, aReason, KNullDesC);
+		NKern::UnlockSystem();
+		process->SignalProcessLock();
+		}
+
+	TBool lastThread = EFalse;
+	__NK_ASSERT_DEBUG(thread->iUserThreadState >= DThread::EUserThreadRunning);
+	if (thread->iUserThreadState == DThread::EUserThreadRunning)
+		{
+		thread->iUserThreadState = DThread::EUserThreadExiting;
+		lastThread = (__e32_atomic_tas_ord32(&process->iUserThreadsRunning, 1, -1, 0) == 1);
+		}
+	
+	NKern::ThreadLeaveCS();
+	
+	return lastThread;
+	}
+
+
+#include <kernel/cache.h>
+
+void ExecHandler::IMBRange(TAny* aStart, TUint aSize)
+	{
+	UNLOCK_USER_MEMORY();
+	Cache::IMB_Range((TLinAddr)aStart,aSize);
+	LOCK_USER_MEMORY();
+	}