// 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\object.cpp

// 

//

#include <kernel/kern_priv.h>

#include "dobject.h"

#ifdef _DEBUG

#define __DEBUG_SAVE(p)				TInt dbgNestLevel = ((RHeap::SDebugCell*)p)[-1].nestingLevel

#define __DEBUG_RESTORE(p)			((RHeap::SDebugCell*)p)[-1].nestingLevel = dbgNestLevel

#else

#define __DEBUG_SAVE(p)

#define __DEBUG_RESTORE(p)

#endif

_LIT(KLitLocal,"Local-");

_LIT8(KLitLocal8,"Local-");

_LIT(KColonColon,"::");

_LIT8(KColonColon8,"::");

_LIT(KLitDObjectCon,"DObjectCon");

_LIT(KLitHandleMutex,"HandleMutex");

#ifdef __SMP__

// SMP_FIXME: Investigate what the purpose of this is

TSpinLock TraceSpinLock(TSpinLock::EOrderNone);

#endif

inline TUint64 DObject::ObjectId() const

	{

	return iObjectId >> 18;

	}

/** Default constructor for DObject

	Sets access count to 1, no name, no container, no owner.

	@internalComponent

 */

EXPORT_C DObject::DObject()

	{

//	iContainer=NULL;

//	iOwner=NULL;

//	iName=NULL;

	iAccessCount=1;

	iObjectId = __e32_atomic_add_ord64(&NextObjectId, TUint64(1<<18));

	}

/** Base class destructor for DObject

	Removes the name, removes object from its container if any, and removes owner.

    @pre Calling thread must be in a critical section.

    @pre No fast mutex can be held.

	@pre Call in a thread context.

	@pre Kernel must be unlocked

	@pre interrupts enabled

	@internalComponent

 */

EXPORT_C DObject::~DObject()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DObject::~DObject");		

	__ASSERT_ALWAYS(AccessCount()==0,Panic(EObjObjectStillReferenced));

	__KTRACE_OPT(KOBJECT,Kern::Printf("DObject::~DObject %O owner %O",this,iOwner));

	NKern::FMWait(&Lock);

	HBuf* pN=iName;

	iName=NULL;

	DObjectCon* pC;

	if(iContainerID)

		{

		pC=K::Containers[iContainerID-1];

		iContainerID=0;

		}

	else

		pC=NULL;

	DObject* pO=iOwner;

	iOwner=NULL;

	NKern::FMSignal(&Lock);

	if (pC)

		pC->Remove(this);

	if (HasNotifierQ())	// this can't go from zero to nonzero now since no-one has a reference on this object

		{

		SDblQue dq;

		TMiscNotifierMgr& m = K::TheMiscNotifierMgr;

		m.Lock();

		SMiscNotifierQ* q = NotifierQ();

		SetNotifierQ(0);

		dq.MoveFrom(q);

		m.Unlock();

		if (q)

			{

			Kern::Free(q);

			m.CompleteNotifications(dq);

			}

		}

	if (pN)

		Kern::Free(pN);

	if (pO)

		pO->Close(NULL);

	}

void K::ObjDelete(DObject* aObj)

	{

	SDblQue dq;

	SMiscNotifierQ* q = 0;

	TMiscNotifierMgr& m = K::TheMiscNotifierMgr;

	if (aObj->HasNotifierQ())	// this can't go from zero to nonzero now since no-one has a reference on this object

		{

		m.Lock();

		q = aObj->NotifierQ();

		aObj->SetNotifierQ(0);

		dq.MoveFrom(q);

		m.Unlock();

		}

	TBool deferCodesegCleanup = aObj->iObjectFlags&DObject::EObjectDeferKernelCodesegCleanup;

	if(deferCodesegCleanup)

		DCodeSeg::DeferKernelCleanup();

	DBase::Delete(aObj);

	if (q)

		{

		Kern::Free(q);

		m.CompleteNotifications(dq);

		}

	if(deferCodesegCleanup)

		DCodeSeg::EndDeferKernelCleanup();

	}

/**	Closes a reference on a DObject-derived class.

	This is the default implementation of the virtual function.

	Decrements reference count and, if it becomes zero, deletes the object.

	Uses an atomic safe decrement so that a zero access count is unchanged.

	@param	aPtr	Points to relevant DProcess if a user handle is being closed

					NULL if any other reference is being closed

	@return	Bit mask of values from enum DObject::TCloseReturn

			EObjectDeleted	Set if object has been deleted

			EObjectUnmapped	Set if the last reference from a user process has been removed

							Only used for DLibrary

    @pre Calling thread must be in a critical section.

    @pre No fast mutex can be held.

	@pre Call in a thread context.

	@pre Kernel must be unlocked

	@pre interrupts enabled

 */

EXPORT_C TInt DObject::Close(TAny* /*aPtr*/)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DObject::Close");		

	__KTRACE_OPT(KOBJECT,Kern::Printf("DObject::Close %d %O",AccessCount(),this));

	if (Dec()==1)

		{

		NKern::LockSystem();		// just in case someone is still using this object

		NKern::UnlockSystem();

		K::ObjDelete(this);

		return EObjectDeleted;

		}

	return 0;

	}

/**	Opens a reference on a DObject-derived class, checking that its reference

	count was not initially zero.

	@panic	Current thread KERN-EXEC 0 if initial reference count was 0

	@pre    Call in a thread context.

	@pre	System lock must be held.

	@internalComponent

 */

EXPORT_C void DObject::CheckedOpen()

	{

	CHECK_PRECONDITIONS(MASK_NOT_ISR|MASK_NOT_IDFC|MASK_SYSTEM_LOCKED,"DObject::CheckedOpen");		

	if (Open())

		K::PanicCurrentThread(EBadHandle);

	}

/** Appends the object's short name to a descriptor.

	This is the default implementation of the virtual function.

	This is overridden by some

	DObject-derived classes to add extra information to the name.

	@param	aName	Writeable descriptor to which name should be appended.

	@pre    Call in a thread context.

	@pre	DObject::Lock fast mutex held.

 */

EXPORT_C void DObject::DoAppendName(TDes& aName)

	{

	CHECK_PRECONDITIONS(MASK_NOT_ISR|MASK_NOT_IDFC,"DObject::DoAppendName");		

	__ASSERT_WITH_MESSAGE_DEBUG(NKern::HeldFastMutex()==&DObject::Lock,"DObject::Lock fast mutex must be held","DObject::DoAppendName"); 	

  	if (iName)

		aName.Append(*iName);

	else

		{

		aName.Append(KLitLocal);

		aName.AppendNumFixedWidth((TInt)this,EHex,8);

		}

	}

/** Appends the object's full name to a descriptor.

	@param	aFullName	Writeable descriptor to which name should be appended.

	@pre    Call in a thread context.

	@pre	DObject::Lock fast mutex held.

 */

EXPORT_C void DObject::DoAppendFullName(TDes& aFullName)

	{

	CHECK_PRECONDITIONS(MASK_NOT_ISR|MASK_NOT_IDFC,"DObject::DoAppendFullName");		

	__ASSERT_WITH_MESSAGE_DEBUG(NKern::HeldFastMutex()==&DObject::Lock,"DObject::Lock fast mutex must be held","DObject::DoAppendFullName");

  	if (iOwner)

		{

		iOwner->DoAppendFullName(aFullName);

		aFullName.Append(KColonColon);

		}

	DoAppendName(aFullName);

	}

/** Gets the object's short name into a descriptor.

	@param	aName	Writeable descriptor to which name should be copied.

    @pre	No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

 */

EXPORT_C void DObject::Name(TDes& aName)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"DObject::Name");		

	aName.Zero();

	AppendName(aName);

	}

/** Appends the object's short name to a descriptor.

	@param	aName	Writeable descriptor to which name should be appended.

	@pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

 */

EXPORT_C void DObject::AppendName(TDes& aName)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"DObject::AppendName");		

	NKern::FMWait(&Lock);

	DoAppendName(aName);

	NKern::FMSignal(&Lock);

	}

/** Gets the object's full name into a descriptor.

	@param	aFullName	Writeable descriptor to which name should be copied.

	@pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

 */

EXPORT_C void DObject::FullName(TDes& aFullName)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"DObject::FullName");		

	aFullName.Zero();

	AppendFullName(aFullName);

	}

/** Appends the object's full name to a descriptor.

	@param	aFullName	Writeable descriptor to which name should be appended.

	@pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

 */

EXPORT_C void DObject::AppendFullName(TDes& aFullName)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"DObject::AppendFullName");		

	NKern::FMWait(&Lock);

	DoAppendFullName(aFullName);

	NKern::FMSignal(&Lock);

	}

/** Appends the object's short name to a descriptor without waiting on any fast

	mutexes.

	Used in kernel tracing.

	@param	aName	Writeable descriptor to which name should be appended.

	@param	aLock	TRUE if kernel should be locked while copying out name

	@pre    Call either in a thread or an IDFC context, if aLock=TRUE.

	@pre    Call in any context, if aLock=FALSE.

*/

EXPORT_C void DObject::TraceAppendName(TDes8& aName, TBool aLock)

	{

	TInt c = NKern::CurrentContext();

#ifdef __SMP__

	TInt irq = 0;

	if (aLock)

		{

		if (c==NKern::EInterrupt)

			irq = TraceSpinLock.LockIrqSave();

		else

			{

			NKern::Lock();

			TraceSpinLock.LockOnly();

			}

		}

#else

	if (aLock && c!=NKern::EInterrupt)

		NKern::Lock();

#endif

	if (iName)

		aName.Append(*iName);

	else

		{

		aName.Append(KLitLocal8);

		aName.AppendNumFixedWidth((TUint)this,EHex,8);

		}

#ifdef __SMP__

	if (aLock)

		{

		if (c==NKern::EInterrupt)

			TraceSpinLock.UnlockIrqRestore(irq);

		else

			{

			TraceSpinLock.UnlockOnly();

			NKern::Unlock();

			}

		}

#else

	if (aLock && c!=NKern::EInterrupt)

		NKern::Unlock();

#endif

	}

/** Appends the object's full name to a descriptor without waiting on any fast

	mutexes.

	Used in kernel tracing.

	@param	aFullName Writeable descriptor to which name should be appended.

	@param	aLock	TRUE if kernel should be locked while copying out name.

	@pre    Call either in a thread or an IDFC context, if aLock=TRUE.

	@pre    Call in any context, if aLock=FALSE.

 */

EXPORT_C void DObject::TraceAppendFullName(TDes8& aFullName, TBool aLock)

	{

	TInt c = NKern::CurrentContext();

#ifdef __SMP__

	TInt irq = 0;

	if (aLock)

		{

		if (c==NKern::EInterrupt)

			irq = TraceSpinLock.LockIrqSave();

		else

			{

			NKern::Lock();

			TraceSpinLock.LockOnly();

			}

		}

#else

	if (aLock && c!=NKern::EInterrupt)

		NKern::Lock();

#endif

	if (iOwner)

		{

		iOwner->TraceAppendFullName(aFullName,EFalse);

		aFullName.Append(KColonColon8);

		}

	TraceAppendName(aFullName,EFalse);

#ifdef __SMP__

	if (aLock)

		{

		if (c==NKern::EInterrupt)

			TraceSpinLock.UnlockIrqRestore(irq);

		else

			{

			TraceSpinLock.UnlockOnly();

			NKern::Unlock();

			}

		}

#else

	if (aLock && c!=NKern::EInterrupt)

		NKern::Unlock();

#endif

	}

/** Sets the object's name, clearing any previous name.

	If the object's name had already been set the old name is replaced. If aName

	is NULL the object ends up with no name.

	@param	aName	Pointer to descriptor containing new name;

					NULL if there is no new name.

	@return	KErrNone, if name set successfully;

	        KErrNoMemory, if a heap buffer could not be allocated for the new name;

	        KErrBadName, if new name contained invalid characters.

    @pre    Calling thread must be in a critical section.

    @pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

	@internalComponent

 */

EXPORT_C TInt DObject::SetName(const TDesC* aName)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DObject::SetName");		

	__KTRACE_OPT(KOBJECT,Kern::Printf("SetName %O (%S)",this,aName));

	TAny* pN=NULL;

	if (aName)

		{

		TInt r = Kern::ValidateName(*aName);

		if(r!=KErrNone)

			return r;

		pN=HBuf::New(*aName);

		if (!pN)

			return(KErrNoMemory);

		}

	NKern::FMWait(&Lock);

	pN = __e32_atomic_swp_ord_ptr(&iName, pN);

	if (iName)

		{

		__KTRACE_OPT(KOBJECT,Kern::Printf("Name is now %S",iName));

		}

	else

		{

		__KTRACE_OPT(KOBJECT,Kern::Printf("No name"));

		}

#ifdef _DEBUG

	if (pN && iName)

		{

		__DEBUG_SAVE(pN);

		__DEBUG_RESTORE(iName);

		}

#endif

	NKern::FMSignal(&Lock);

	if (pN)

		Kern::Free(pN);

	return KErrNone;

	}

/** Sets the object's owner, clearing any previous owner.

	If the object's owner had already been set the old owner is replaced. If aOwner

	is NULL the object ends up with no owner.

	An extra reference is opened on the new owner. The old owner, if any, has a

	reference closed to compensate.

	@param	aOwner	Pointer to DObject-derived class which is the new owner

					NULL if there is no new owner

	@return	KErrNone, if name set successfully;

	        KErrGeneral, if new owner had zero access count.

    @pre    Calling thread must be in a critical section.

    @pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

	@internalComponent

 */

EXPORT_C TInt DObject::SetOwner(DObject* aOwner)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DObject::SetOwner");		

	__KTRACE_OPT(KOBJECT,Kern::Printf("SetOwner %O (%O)",this,aOwner));

	NKern::FMWait(&Lock);

	DObject* pO=iOwner;

	iOwner=NULL;

	TInt r=KErrNone;

	if (aOwner)

		{

		r=aOwner->Open();

		if (r==KErrNone)

			{

			iOwner=aOwner;

			}

		}

	NKern::FMSignal(&Lock);

	if (pO)

		pO->Close(NULL);

	return r;

	}

/** Notifies an object that a handle to it has been requested by a user thread.

	This is the default implementation of the virtual function.

	This function allows a DObject-derived class to control access to itself

	from user threads. For example it might wish to restrict its use to a single