// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\include\kernel\kern_priv.h

// 

// WARNING: This file contains some APIs which are internal and are subject

//          to change without notice. Such APIs should therefore not be used

//          outside the Kernel and Hardware Services package.

//

/**

 @file

 @internalComponent

*/

#ifndef __K32KERN_H__

#define __K32KERN_H__

#include <kernel/kernel.h>

#include <nk_priv.h>

#include <kernel/kpower.h>

#include <platform.h>

#include <e32uid.h>

#include <kernel/kernboot.h>

#include <e32def_private.h>

#include <e32const_private.h>

#include <e32des8_private.h>

#include <e32event_private.h>

#include <kernel/heap_hybrid.h>

#ifndef __MINIMUM_MACHINE_CODE__

#ifdef __MARM__

#ifndef __BIG_ENDIAN__

#ifdef __SMP__

	#define __FASTEXEC_MACHINE_CODED__

 	#define __TBMA_MACHINE_CODED__

#else

// These macros are intended for Symbian use only.

// It may not be possible to build the kernel if particular combinations 

// of these macros are undefined

	#define __FASTEXEC_MACHINE_CODED__

	#define __MMU_MACHINE_CODED__

	#define __PROCESS_MACHINE_CODED__

 	#define __TBMA_MACHINE_CODED__

	#define __MESSAGE_MACHINE_CODED_2__

	#define	__HANDLES_MACHINE_CODED__

	#define __REQUEST_COMPLETE_MACHINE_CODED__

	#define __MESSAGE_MACHINE_CODED__

#endif

#endif

#endif

#endif

// size of each buffer used to store entropy data before it is passed to the RNG

const TUint KEntropyBufferSizeWords = 1024;// maximum size of 1024 words (32Kbit);

const TInt KKernelServerDefaultPriority=16;

const TInt KDefaultExitPriority=KKernelServerDefaultPriority;

// counter to ensure that priority inheritance has bounded execution time

const TInt KMaxPriorityInheritanceNesting=10;

const TInt KArgIndex = 16;	//number of slots in DProcess for passing info to child process on creation

const TInt KDefaultMaxMemCopyInOneGo = 512;

// Forward declare Shareable data buffer classes

class DShPool;

class TShPoolCreateInfo;

//Forward declare Debug namespace for StopMode API

namespace Debug { class StopModeDebug; }

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

 * Kernel-side trap harness for catching exceptions

 * Not nestable, one per thread only

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

class TExcTrap;

typedef void (*TExcTrapHandler)(TExcTrap*,DThread*,TAny*);

class TExcTrap

	{

public:

	IMPORT_C TInt Trap();	// use default exception handler

	IMPORT_C TInt Trap(TExcTrapHandler aHandler);

	inline void UnTrap();

	IMPORT_C void Exception(TInt aResult);

public:

	TUint32 iState[EXC_TRAP_CTX_SZ];

	TExcTrapHandler iHandler;

	DThread* iThread;

	};

class TPagingExcTrap

	{

public:

	TInt Trap();

	inline void UnTrap();

	void Exception(TInt aResult);

public:

	TUint32 iState[EXC_TRAP_CTX_SZ];

	DThread* iThread;

	};

#define XT_DEFAULT

#define XTRAP(_r,_h,_s)	{							\

						TExcTrap __t;				\

						if (((_r)=__t.Trap(_h))==0)	\

							{						\

							_s;						\

							__t.UnTrap();			\

							}						\

						}

#define XTRAPD(_r,_h,_s) TInt _r;					\

						{							\

						TExcTrap __t;				\

						if (((_r)=__t.Trap(_h))==0)	\

							{						\

							_s;						\

							__t.UnTrap();			\

							}						\

						}

#ifdef __DEMAND_PAGING__

#define CHECK_PAGING_SAFE				__NK_ASSERT_DEBUG(M::CheckPagingSafe(EFalse))

#define CHECK_PAGING_SAFE_RANGE(s, l)	__NK_ASSERT_DEBUG(M::CheckPagingSafe(EFalse, (s), (l)))

#define CHECK_DATA_PAGING_SAFE				__NK_ASSERT_DEBUG(M::CheckPagingSafe(ETrue))

#define CHECK_DATA_PAGING_SAFE_RANGE(s, l)	__NK_ASSERT_DEBUG(M::CheckPagingSafe(ETrue, (s), (l)))

//

// Important - Do not use XTRAP inside an XTRAP_PAGING

// I.e.

//		XTRAP(XTRAP_PAGING(foo))

// is OK, but

//		XTRAP_PAGING(XTRAP(foo))

// will put the system into a bad state when a paging exception happens

// because TExcTrap::UnTrap won't get called.

//

#define XTRAP_PAGING(_r,_s)	{								\

							TPagingExcTrap __t;				\

							if (((_r)=__t.Trap())==0)		\

								{							\

								_s;							\

								__t.UnTrap();				\

								}							\

							}

#define XTRAP_PAGING_START(_r)	{								\

								TPagingExcTrap __t;				\

								if (((_r)=__t.Trap())==0)		\

									{

#define XTRAP_PAGING_END			__t.UnTrap();				\

									}							\

								}

#define XTRAP_PAGING_RETRY(_s)	{											\

								_retry:										\

									TInt _exc;								\

									XTRAP_PAGING_START(_exc);				\

									_s;										\

									XTRAP_PAGING_END;						\

									if(_exc) goto _retry;					\

								}

#else

#define XTRAP_PAGING(_r,_s)		{ _s }

#define XTRAP_PAGING_START(_r)	{_r=0;{ 

#define XTRAP_PAGING_END			  }} 

#define CHECK_PAGING_SAFE

#define CHECK_PAGING_SAFE_RANGE(s, l)

#define CHECK_DATA_PAGING_SAFE

#define CHECK_DATA_PAGING_SAFE_RANGE(s, l)

#define XTRAP_PAGING_RETRY(_s)  { _s }

#endif

class TIpcExcTrap : public TExcTrap

	{

public:

	TInt Trap(DThread* aClientThread); 	// use default ipc exception handler

	inline void UnTrap();

	enum TExcLocation { EExcUnknown, EExcLocal, EExcRemote };

	TExcLocation ExcLocation(DThread* aThread, TAny* aContext);

	TBool IsTIpcExcTrap();

public:

	TLinAddr iLocalBase;

	TLinAddr iRemoteBase;

	TUint32 iSize;

	TInt iDir;		// 0=read, 1=write

	};

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

 * Structure used for miscellaneous notifications

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

class TMiscNotifier : public TClientRequest

	{

public:

	SDblQueLink		iThreadLink;

	SDblQueLink		iObjLink;

	DThread*		iThread;		// doesn't need to be reference counted since all notifiers are removed when thread terminates

private:

	~TMiscNotifier();				// call Close(), don't delete

	};

struct SMiscNotifierQ : public SDblQue

	{

	};

class TMiscNotifierMgr

	{

public:

	TMiscNotifierMgr();

	void Init2();

	void CompleteNotifications(SDblQue& aQ);

	static void CompletionDfcFn(TAny* aMgr);

	static void IdleDfcFn(TAny* aMgr);

	inline void Lock()

		{NKern::FMWait(&iLock);}

	inline void Unlock()

		{NKern::FMSignal(&iLock);}

	TInt NewMiscNotifier(TRequestStatus* aStatus, TBool aObj, TAny* aPtr, TMiscNotifier*& aN, SMiscNotifierQ*& aQ);

public:

	SDblQue			iCompleted;

	TDfc			iCompletionDfc;

	SMiscNotifierQ*	iIdleNotifierQ;

	TDfc			iIdleDfc;

	NFastMutex		iLock;

	};

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

 * Kernel object index (handles array)

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

class DMutex;

/** Handle analysis and synthesis

@internalComponent

*/

inline TBool HandleIsSpecial(TInt aHandle)

	{ return aHandle<0; }

inline TBool HandleIsThreadLocal(TInt aHandle)

	{ return aHandle&0x40000000; }

inline TBool HandleNoClose(TInt aHandle)

	{ return aHandle&0x00008000; }

inline TInt HandleIndex(TInt aHandle)

	{ return aHandle&0x00007FFF; }

inline TInt HandleInstance(TInt aHandle)

	{ return (aHandle&0x3FFF0000)>>16; }

inline TInt MakeHandle(TInt aIndex, TInt aInstance)

	{ return ((aInstance&0x3FFF)<<16)|(aIndex&0x7FFF); }

/**

@internalComponent

*/

class RObjectIx

	{

public:

	enum {ENoClose=KHandleNoClose,ELocalHandle=0x40000000};

	enum {EReserved=0x80000000u, EAttributeMask=0xfffu};

	enum {EMinSlots=8, EMaxSlots=32768};

public:

	enum {ENumFreeQ=6, EModCount=4, EBitMapSize=128, EMaxLockedIter=8};

private:

	// queue numbers

	enum {EQFree=-6, EQAltFree=-5, EQTempFree=-4, EQRsvd=-3, EQAltRsvd=-2, EQTempRsvd=-1};

	// iObjR, iRsvd fields

	enum {EObjROccupied=4u, EObjRObjMask=0xfffffffcu, EObjRRsvd=1u};

	// states

	enum {ENormal=0u, ETidying=1u, EFindingLast=2u, ECounting=3u, ESearching=4u, ETerminated=5u};

	struct	SSlotQLink

		{

		TInt16		iNext;	// pointer to next free slot, -n if no next

		TInt16		iPrev;	// pointer to previous free slot, -n if no previous

		};

	struct	SFreeSlot : public SSlotQLink

		{

		TUint32		iRsvd;	// 0 for normal, 1 for reserved slot

		};

	struct	SUsedSlot

		{

		TUint32		iAttr;	// bits 0-13 = instance (nonzero), bits 14-19 = object type, bits 20-31 = handle attributes

		TUint32		iObjR;	// pointer to object (nonzero), bit 0=1 if reserved slot

		};

	union SSlot

		{

		SFreeSlot	iFree;

		SUsedSlot	iUsed;

		};

	struct SMonitorObj

		{

		DObject*	iObj;

		TInt		iBoundary;

		TInt		iResult;

		};

	union SModList

		{

		TInt16		iIndex[EModCount];

		TUint32		iBitMap[EBitMapSize/32];

		SMonitorObj	iMonitor;

		};

private:

#ifdef __HANDLES_USE_RW_SPIN_LOCK__

// Beginning of support for spinlock-only protection (i.e. not requiring the system lock)

// for access to handles.  Requires changes everywhere objects returned from handles are

// used, and some additional work in the handle lookup code in cutils.cia.

#error "spinlocks for handle lookup not supported"

	inline void AcquireReadLock()

		{ __SPIN_LOCK_IRQ_R(iRWL); }

	inline void ReleaseReadLock()

		{ __SPIN_UNLOCK_IRQ_R(iRWL); }

	inline void AcquireWriteLock()

		{ __SPIN_LOCK_IRQ_W(iRWL); }

	inline void ReleaseWriteLock()

		{ __SPIN_UNLOCK_IRQ_W(iRWL); }

#else

	/* Places which use a read lock would already have the system lock held */

	inline void AcquireReadLock()

		{ __ASSERT_SYSTEM_LOCK; }

	inline void ReleaseReadLock()

		{  }

	inline void AcquireWriteLock()

		{ NKern::LockSystem(); }

	inline void ReleaseWriteLock()

		{ NKern::UnlockSystem(); }

#endif

private:

	static inline DObject* Occupant(SSlot* aS)

		{ return (DObject*)(aS->iUsed.iObjR & EObjRObjMask); }

	static inline TBool IsReserved(SSlot* aS)

		{ return aS->iUsed.iObjR & EObjRRsvd; }

	static inline TBool IsFreeReserved(SSlot* aS)

		{ return (aS->iUsed.iObjR & EObjRRsvd) && (aS->iUsed.iObjR<EObjROccupied); }

	void Empty(TInt aQueue);

	SSlot* Dequeue(TInt aSlotIndex);

	inline void AddHead(TInt aQueue, TInt aSlotIndex);

	inline void AddTail(TInt aQueue, TInt aSlotIndex);

	void AddBefore(TInt aBase, TInt aSlotIndex);

	void AddAfter(TInt aBase, TInt aSlotIndex);

	void AppendList(TInt aSrcQ, TInt aDestQ);

	void PrependList(TInt aSrcQ, TInt aDestQ);

	TInt DoAdd(DObject* aObj, TUint32 aAttr, SSlot* aSlot);	// add aObj using an existing slot (don't grow)

	TInt DoRemove(TInt aHandle, DObject*& aObject, TUint32& aAttr);	// remove a handle (don't shrink)

	void MarkModified(TInt aSlotIndex);

	static TUint32 GetNextInstanceValue();

	TInt UnReserveSlots(TInt aCount, TBool aAmortize);

	TInt ReserveSlots(TInt aCount);

	TInt Grow(TInt aReserve, SSlot* aSlotData);

	void TidyAndCompact();

	inline SSlotQLink* Link(TInt aIndex)

		{ return (aIndex<0) ? (iFreeQ+ENumFreeQ+aIndex) : &(iSlots+aIndex)->iFree; }

public:

	// common operations

	RObjectIx();

	TInt Close(TAny* aPtr);

	TInt Add(DObject* aObj, TUint32 aAttr);

	TInt Remove(TInt aHandle, DObject*& aObject, TUint32& aAttr);

	TInt Reserve(TInt aCount);

	DObject* At(TInt aHandle, TInt aUniqueID, TUint32 aRequiredAttr);

	DObject* At(TInt aHandle, TInt aUniqueID, TUint32* aAttr);

	DObject* At(TInt aHandle, TInt aUniqueID);

	DObject* At(TInt aHandle);

	static void Wait();

	static void Signal();

	inline TInt Count()

		{ return iCount; }

	inline TInt ActiveCount()

		{ return iActiveCount; }

public:

	// uncommon operations

	DObject* operator[](TInt aIndex);

	TInt At(DObject* aObject);

	TInt Count(DObject* aObject);

	TInt LastHandle();

#ifdef DOBJECT_TEST_CODE

	typedef void (*TValidateEntry)(TInt, TInt, TInt, TInt, TUint, DObject*);

	void Check(TValidateEntry aV);

#endif

private:

	TRWSpinLock		iRWL;

	TInt			iAllocated;			// Max entries before realloc needed

	volatile TInt	iCount;				// Points to at least 1 above the highest occupied slot or unoccupied reserved slot

	volatile TInt	iActiveCount;		// Number of occupied entries in the index (reserved or normal)

	volatile TInt	iReservedFree;		// Number of unoccupied reserved slots

	volatile TInt	iReservedTotal;		// Number of reserved slots (occupied or unoccupied)

	volatile TInt	iReservedFreeHWM;	// Points to at least 1 above the last unoccupied reserved slot

	SSlotQLink		iFreeQ[ENumFreeQ];	// queues of free slots

	SSlot*			iSlots;				// array of handle slots

	TInt			iAmortize;			// Number of handle removals before we see if we can shrink

	TUint8			iState;

	TUint8			iModCount;			// 255=not in use, 0...EModCount->use iModList.iIndex[], EModCount+1->use iModList.iBitMap

	TUint8			iModListShift;

	TUint8			iSpare1;

	SModList		iModList;			// Entries modified while array moving

public:

	static volatile TUint32 NextInstance;

	static DMutex* HandleMutex;

public:

	friend void PreprocessHandler();

	friend class DThread;

	friend class K;

	friend class Monitor;

	};

//

// These are the same as their e32base.h versions

/*inline TBool IsLocalHandle(TInt aHandle)

	{return(aHandle&RObjectIx::ELocalHandle);}

inline void SetLocalHandle(TInt &aHandle)

	{aHandle|=RObjectIx::ELocalHandle;}

inline void UnSetLocalHandle(TInt &aHandle)

	{aHandle&=(~RObjectIx::ELocalHandle);}

*/

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

 * Kernel object container

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

class DObjectCon : public DBase

	{

protected:

	enum {ENotOwnerID};

public:

	~DObjectCon();

	static DObjectCon* New(TInt aUniqueID);

	IMPORT_C void Remove(DObject* aObj);

	IMPORT_C TInt Add(DObject* aObj);

	IMPORT_C DObject* operator[](TInt aIndex);

	IMPORT_C DObject* At(const TFindHandle& aFindHandle);

	IMPORT_C TInt CheckUniqueFullName(DObject* aOwner, const TDesC& aName);

	IMPORT_C TInt CheckUniqueFullName(DObject* aObject);

	IMPORT_C TInt FindByName(TFindHandle& aFindHandle, const TDesC& aMatch, TKName& aName);

	IMPORT_C TInt FindByFullName(TFindHandle& aFindHandle, const TDesC& aMatch, TFullName& aFullName);

	IMPORT_C TInt OpenByFullName(DObject*& aObject, const TDesC& aMatch);

	inline TInt UniqueID() {return iUniqueID;}

	inline TInt Count() {return iCount;}

	inline void Wait() {Kern::MutexWait(*iMutex);}

	inline void Signal() {Kern::MutexSignal(*iMutex);}

	inline DMutex* Lock() {return iMutex;}

protected:

	DObjectCon(TInt aUniqueID);

	TBool NamesMatch(DObject* aObject, const TDesC& aObjectName, DObject* aCurrentObject);

public:

	TInt iUniqueID;

private:

	TInt iAllocated;

	TInt iCount;

	DObject** iObjects;

	DMutex* iMutex;

public:

	friend class Monitor;

	friend class Debugger;

	friend class SCMonitor;

	friend class Debug::StopModeDebug;

	};

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

 * Process and process-relative thread priorities

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

enum TThrdPriority

	{

	EThrdPriorityIdle=-8,

	EThrdPriorityMuchLess=-7,

	EThrdPriorityLess=-6,

	EThrdPriorityNormal=-5,

	EThrdPriorityMore=-4,

	EThrdPriorityMuchMore=-3,

	EThrdPriorityRealTime=-2,

	EThrdPriorityNull=0,

	EThrdPriorityAbsoluteVeryLow=1,

	EThrdPriorityAbsoluteLowNormal=3,

	EThrdPriorityAbsoluteLow=5,

	EThrdPriorityAbsoluteBackgroundNormal=7,

	EThrdPriorityAbsoluteBackground=10,

	EThrdPriorityAbsoluteForegroundNormal=12,

	EThrdPriorityAbsoluteForeground=15,

	EThrdPriorityAbsoluteHighNormal=19,

	EThrdPriorityAbsoluteHigh=23,

	EThrdPriorityAbsoluteRealTime1=24,

	EThrdPriorityAbsoluteRealTime2=25,

	EThrdPriorityAbsoluteRealTime3=26,

	EThrdPriorityAbsoluteRealTime4=27,

	EThrdPriorityAbsoluteRealTime5=28,

	EThrdPriorityAbsoluteRealTime6=29,

	EThrdPriorityAbsoluteRealTime7=30,

	EThrdPriorityAbsoluteRealTime8=31

	};

enum TProcPriority

	{

	EProcPriorityLow=0,

	EProcPriorityBackground=1,

	EProcPriorityForeground=2,

	EProcPriorityHigh=3,

	EProcPrioritySystemServer1=4,

	EProcPrioritySystemServer2=5,

	EProcPrioritySystemServer3=6,

	EProcPriorityRealTimeServer=7,

	};

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

 * Multipurpose timer

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

#ifndef MAX