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