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

 //

 #include <memmodel.h>

 #include "mmu/mm.h"

 #include "mmboot.h"

 /********************************************

  * Thread

  ********************************************/

 TInt DThread::AllocateSupervisorStack()

 	{

 	__KTRACE_OPT(KTHREAD,Kern::Printf("DThread::AllocateSupervisorStack %O %x",this,iSupervisorStackSize));

 	iSupervisorStackSize = MM::RoundToPageSize(iSupervisorStackSize);

 	if(iThreadType==EThreadInitial)

 		return KErrNone;

 	TUint guardSize = PP::SupervisorThreadStackGuard;

 	TUint virtualSize = guardSize+iSupervisorStackSize;

 	DMemoryObject* memory;

 	TInt r = MM::MemoryNew(memory,EMemoryObjectUnpaged,MM::BytesToPages(virtualSize));

 	if(r==KErrNone)

 		{

 		r = MM::MemoryAlloc(memory,MM::BytesToPages(guardSize),MM::BytesToPages(iSupervisorStackSize));

 		if(r==KErrNone)

 			{

 			DMemoryMapping* mapping;

 			r = MM::MappingNew(mapping,memory,ESupervisorReadWrite,KKernelOsAsid);

 			if(r==KErrNone)

 				{

 				__NK_ASSERT_DEBUG(!((DMemModelThread*)this)->iKernelStackMapping);

 				((DMemModelThread*)this)->iKernelStackMapping = mapping;

 				iSupervisorStack = (TAny*)(MM::MappingBase(mapping)+guardSize);

 				__KTRACE_OPT(KTHREAD,Kern::Printf("Supervisor stack at %x, size %x",iSupervisorStack,iSupervisorStackSize));

 				}

 			}

 		if(r!=KErrNone)

 			MM::MemoryDestroy(memory);

 		else

 			{

 #ifdef BTRACE_FLEXIBLE_MEM_MODEL

 			BTrace8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectIsSupervisorStack,memory,&iNThread);

 #endif

 			}

 		}

 	return r;

 	}

 void DThread::FreeSupervisorStack()

 	{

 	__KTRACE_OPT(KTHREAD,Kern::Printf("DThread::FreeSupervisorStack %O",this));

 	if(iThreadType==EThreadInitial) // !!!???

 		return;

 	MM::MappingAndMemoryDestroy(((DMemModelThread*)this)->iKernelStackMapping);

 	}

 TInt DThread::AllocateUserStack(TInt aSize, TBool aPaged)

 	{

 	__KTRACE_OPT(KTHREAD,Kern::Printf("DThread::AllocateUserStack %O %x",this,aSize));

 	aSize = MM::RoundToPageSize(aSize);

 	if(aSize>PP::MaxUserThreadStack)

 		return KErrTooBig;

 	TMemoryObjectType memoryType = (aPaged)? EMemoryObjectPaged : EMemoryObjectMovable;

 	TUint guardSize = PP::UserThreadStackGuard;

 	TUint virtualSize = guardSize+aSize;

 	// wipe user thread stack with 0x29292929

 	TMemoryCreateFlags flags = (TMemoryCreateFlags)(EMemoryCreateDefault | EMemoryCreateUseCustomWipeByte | (0x29 << EMemoryCreateWipeByteShift));

 	DMemoryObject* memory;

 	TInt r = MM::MemoryNew(memory, memoryType, MM::BytesToPages(virtualSize),flags);

 	if(r==KErrNone)

 		{

 		r = MM::MemoryAlloc(memory,MM::BytesToPages(guardSize),MM::BytesToPages(aSize));

 		if(r==KErrNone)

 			{

 			DMemoryMapping* mapping;

 			// Get os asid, no need to open a reference as this only invoked where 

 			// the current thread is owned by iOwningProcess, iOwningProcess is 

 			// the kernel process or this is the first thread of a process that 

 			// isn't fully created yet.

 			TUint osAsid = ((DMemModelProcess*)iOwningProcess)->OsAsid();

 			r = MM::MappingNew(mapping,memory,EUserReadWrite,osAsid);

 			if(r==KErrNone)

 				{

 				__NK_ASSERT_DEBUG(!((DMemModelThread*)this)->iUserStackMapping);

 				((DMemModelThread*)this)->iUserStackMapping = mapping;

 				iUserStackSize = aSize;

 				iUserStackRunAddress = MM::MappingBase(mapping)+guardSize;

 				__KTRACE_OPT(KTHREAD,Kern::Printf("User stack at %x, size %x",iUserStackRunAddress,iUserStackSize));

 				}

 			}

 		if(r!=KErrNone)

 			MM::MemoryDestroy(memory);

 		else

 			{

 #ifdef BTRACE_FLEXIBLE_MEM_MODEL

 			BTrace8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectIsUserStack,memory,&iNThread);

 #endif

 			}

 		}

 	return r;

 	}

 void DThread::FreeUserStack()

 	{

 	__KTRACE_OPT(KTHREAD,Kern::Printf("DThread::FreeUserStack %O",this));

 	MM::MappingAndMemoryDestroy(((DMemModelThread*)this)->iUserStackMapping);

 	}

 void DMemModelThread::SetPaging(TUint& aCreateFlags)

 	{

 	TUint pagingAtt = aCreateFlags & EThreadCreateFlagPagingMask;

 	TUint dataPolicy = TheSuperPage().KernelConfigFlags() & EKernelConfigDataPagingPolicyMask;

 	if (dataPolicy == EKernelConfigDataPagingPolicyNoPaging ||

 		!(K::MemModelAttributes & EMemModelAttrDataPaging))

 		{// No paging policy set or no data paging device installed.

 		pagingAtt = EThreadCreateFlagUnpaged;

 		}

 	else if (dataPolicy == EKernelConfigDataPagingPolicyAlwaysPage)

 		{

 		pagingAtt = EThreadCreateFlagPaged;

 		}

 	else if (pagingAtt == EThreadCreateFlagPagingUnspec)

 		{// No data paging attribute specified for this chunk so use the process's.

 		if (iOwningProcess->iAttributes & DProcess::EDataPaged)

 			pagingAtt = EThreadCreateFlagPaged;

 		else

 			pagingAtt = EThreadCreateFlagUnpaged;

 		}

 #ifdef _DEBUG

 	else

 		{

 		__NK_ASSERT_DEBUG(	pagingAtt == EThreadCreateFlagPaged || 

 							pagingAtt == EThreadCreateFlagUnpaged);

 		}

 #endif

 	// Save the paging attributes for when the stack and heap are created later.

 	aCreateFlags &= ~EThreadCreateFlagPagingMask;

 	aCreateFlags |= pagingAtt;

 	}

 void DMemModelThread::DoExit1()

 	{

 	// Regularize the thread state before main exit processing.

 	// We must remove any existing alias before we do any operation 

 	// which requires aliasing (e.g. logon completion).

 	__KTRACE_OPT(KTHREAD,Kern::Printf("DMemModelThread %O DoExit1",this));

 	RemoveAlias();

 	}

 void DThread::IpcExcHandler(TExcTrap* aTrap, DThread* aThread, TAny* aContext)

 	{

 	aThread->iIpcClient = 0;

 	TIpcExcTrap& xt=*(TIpcExcTrap*)aTrap;

 	switch (xt.ExcLocation(aThread, aContext))

 		{

 		case TIpcExcTrap::EExcRemote:

 			// problem accessing remote address - 'leave' so an error code will be returned

 			((DMemModelThread*)aThread)->RemoveAlias();

 			xt.Exception(KErrBadDescriptor);  // does not return

 		case TIpcExcTrap::EExcLocal:

 			// problem accessing local address - return and panic current thread as usual

 			((DMemModelThread*)aThread)->RemoveAlias();

 			return;

 		default:

 			// otherwise return and fault kernel

 			NKern::LockSystem();

 			return;

 		}

 	}

 void DMemModelThread::BTracePrime(TInt aCategory)

 	{

 	DThread::BTracePrime(aCategory);

 #ifdef BTRACE_FLEXIBLE_MEM_MODEL

 	if(aCategory==BTrace::EFlexibleMemModel || aCategory==-1)

 		{

 		if (iKernelStackMapping)

 			{

 			DMemoryObject* memory = MM::MappingGetAndOpenMemory(iKernelStackMapping);

 			if (memory)

 				{

 				MM::MemoryBTracePrime(memory);

 				BTrace8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectIsSupervisorStack,memory,&iNThread);

 				MM::MemoryClose(memory);

 				}

 			}

 		if (iUserStackMapping)

 			{

 			DMemoryObject* memory = MM::MappingGetAndOpenMemory(iUserStackMapping);

 			if (memory)

 				{

 				MM::MemoryBTracePrime(memory);

 				BTrace8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectIsUserStack,memory,&iNThread);

 				MM::MemoryClose(memory);

 				}

 			}

 		}

 #endif

 	}