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

// 

//

#include <kernel/kern_priv.h>

#include "execs.h"

/* Macro for checking whether function is called from Kern::DfcQue0 or Kern::DfcQue1 thread context.

   Device drivers which access user memory should not run in shared DFC threads.

   See Base_How_To_Migrate_Media_Drivers_To_Support_Demand Paging.doc

*/

#if (!defined _DEBUG || ((!defined _CHECK_DFCQ_CONTEXT_WARNING_) && (!defined _CHECK_DFCQ_CONTEXT_PANIC_)))

#define _CHECK_DFCQ01_CONTEXT(function)

#else

#ifdef _CHECK_DFCQ_CONTEXT_PANIC_

#define _CHECK_DFCQ01_CONTEXT(func ) \

	{ \

	NThread* nt=NKern::CurrentThread(); \

	__ASSERT_DEBUG( (nt!=Kern::DfcQue0()->iThread && nt!=Kern::DfcQue1()->iThread), (\

	KPrintf("Function: %s\n called from DfcQ0 or DfcQ1 thread context",func), \

	NKFault(func, 0))); \

	}

#else //WARRNING

#define _CHECK_DFCQ01_CONTEXT(func ) \

	{ \

	NThread* nt=NKern::CurrentThread(); \

	__ASSERT_DEBUG( (nt!=Kern::DfcQue0()->iThread && nt!=Kern::DfcQue1()->iThread), (\

	KPrintf("Function: %s\n called from DfcQ0 or DfcQ1 thread context",func))); \

	}

#endif //  _CHECK_DFCQ_CONTEXT_PANIC_

#endif // !defined _DEBUG || ((!defined _CHECK_DFCQ_CONTEXT_WARNING_) && (!defined _CHECK_DFCQ_CONTEXT_PANIC_)))

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

 * Generic kernel message code

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

/**	Sends a kernel message without waiting for a reply.

	If the receiving queue is ready to receive its DFC will be queued; otherwise

	the message is simply placed on the end of the queue.

	@param	aQ	Message queue to which message should be sent.

	@pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

	@post	The message contains a reference counted pointer to the current thread.

 */

EXPORT_C void TMessageBase::Send(TMessageQue* aQ)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"TMessageBase::Send");			

	__KTRACE_OPT(KSERVER,Kern::Printf("MsgB::Send %08x to %08x",this,aQ));

	DThread* pC=TheCurrentThread;

	TMessageQue::Lock();

	__NK_ASSERT_ALWAYS(iState==EFree);

	iQueue=aQ;

	iSem.iCount=0;

	iSem.iOwningThread=&pC->iNThread;

	pC->Open();

	if (aQ->iReady)

		{

		iState=EAccepted;

		aQ->iMessage=this;

		aQ->iReady=EFalse;

		aQ->UnlockAndKick();

		}

	else

		{

		aQ->iQ.Add(this);

		iState=EDelivered;

		TMessageQue::Unlock();

		}

	}

/**	Sends a kernel message and wait for a reply.

	If the receiving queue is ready to receive its DFC will be queued; otherwise

	the message is simply placed on the end of the queue.

	When received the message will contain a reference counted pointer to the

	current thread.

	@param	aQ	Message queue to which message should be sent.

	@return	The result parameter passed to TMessageBase::Complete().

	@pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

	@see	TMessageBase::Complete()

 */

EXPORT_C TInt TMessageBase::SendReceive(TMessageQue* aQ)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"TMessageBase::SendReceive");			

	__KTRACE_OPT(KSERVER,Kern::Printf(">MsgB::SendRcv %08x to %08x",this,aQ));

	Send(aQ);

	NKern::FSWait(&iSem);

	__KTRACE_OPT(KSERVER,Kern::Printf("<MsgB::SendRcv ret %d",iValue));

	return iValue;

	}

/**	Completes a kernel message and optionally receive the next one.

	@param	aResult		 Completion code to pass back to message sender.

	@param	aReceiveNext TRUE means receive the next message on the same queue (if any) immediately.

						 FALSE means don't receive any more messages on that queue yet.

	@pre    No fast mutex can be held.					 

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

	@pre	Calling thread must be in a critical section

	@post	The reference count on the sending thread is closed asynchronously.

	@see	TMessageBase::SendReceive()

 */

EXPORT_C void TMessageBase::Complete(TInt aResult, TBool aReceiveNext)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TMessageBase::Complete");			

	__KTRACE_OPT(KSERVER,Kern::Printf("MsgB::Complete %08x, %d",this,aResult));

	TMessageQue::Lock();

	__NK_ASSERT_ALWAYS(iState==EAccepted);

	iValue=aResult;

	iState=EFree;

	DThread* pT=_LOFF(iSem.iOwningThread,DThread,iNThread);

	if (aReceiveNext)

		{

		__NK_ASSERT_ALWAYS(!iQueue->iReady);

		if (!iQueue->iQ.IsEmpty())

			{

			TMessageBase* pM=(TMessageBase*)iQueue->iQ.First()->Deque();

			__KTRACE_OPT(KSERVER,Kern::Printf("rxnext: got %08x",pM));

			pM->iState=EAccepted;

			iQueue->iMessage=pM;

			iQueue->Enque();

			}

		else

			{

			__KTRACE_OPT(KSERVER,Kern::Printf("rxnext"));

			iQueue->iReady=ETrue;

			iQueue->iMessage=NULL;

			}

		}

	iQueue=NULL;

	NKern::FSSignal(&iSem,&TMessageQue::MsgLock);

	pT->AsyncClose();

	}

/**	Forwards a kernel message to another queue, and optionally receives the next

	message on the original queue.

	@param	aQ			 The queue to which the message should be forwarded.

	@param	aReceiveNext TRUE means receive the next message on the original queue (if any) immediately

						 FALSE means don't receive any more messages on that queue yet.

	@pre    No fast mutex can be held.					 

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

 */

EXPORT_C void TMessageBase::Forward(TMessageQue* aQ, TBool aReceiveNext)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"TMessageBase::Forward");			

	__KTRACE_OPT(KSERVER,Kern::Printf("MsgB::Forward %08x->%08x",this,aQ));

	TMessageQue::Lock();

	__NK_ASSERT_ALWAYS(iState==EAccepted);

	if (aReceiveNext)

		{

		__NK_ASSERT_ALWAYS(!iQueue->iReady);

		if (!iQueue->iQ.IsEmpty())

			{

			TMessageBase* pM=(TMessageBase*)iQueue->iQ.First()->Deque();

			__KTRACE_OPT(KSERVER,Kern::Printf("rxnext: got %08x",pM));

			pM->iState=EAccepted;

			iQueue->iMessage=pM;

			iQueue->Enque();

			}

		else

			{

			__KTRACE_OPT(KSERVER,Kern::Printf("rxnext"));

			iQueue->iReady=ETrue;

			iQueue->iMessage=NULL;

			}

		}

	iQueue=aQ;

	if (aQ->iReady)

		{

		iState=EAccepted;

		aQ->iMessage=this;

		aQ->iReady=EFalse;

		aQ->UnlockAndKick();

		}

	else

		{

		aQ->iQ.Add(this);

		iState=EDelivered;

		TMessageQue::Unlock();

		}

	}

/** Called by kernel server if client thread exits with a message outstanding.

	Only cancels the message if its state is DELIVERED - that is it is on a

	queue and not currently being processed.

	Other measures must be taken to avoid problems if threads exit while their

	synchronous kernel messages are ACCEPTED.

    @pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

	@pre	Calling thread must be in a critical section

	@post	If the original message state was DELIVERED the reference count on

			the sending thread is closed asynchronously.

	@internalTechnology

 */

EXPORT_C void TMessageBase::Cancel()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TMessageBase::Cancel");			

	__KTRACE_OPT(KSERVER,Kern::Printf("MsgB::Cancel %08x",this));

	DThread* pT=NULL;

	TMessageQue::Lock();

	switch(iState)

		{

		case EDelivered:

			Deque();

			pT=_LOFF(iSem.iOwningThread,DThread,iNThread);

			iState=EFree;

			iQueue=NULL;

		case EAccepted:

		case EFree:

			break;

		}

	TMessageQue::Unlock();

	if (pT)

		pT->AsyncClose();

	}

/** Panics the sender of a kernel message.

	Also completes the message with reason code KErrDied. This is done so that

	the open reference on the client can be closed.

	@param	aCategory	Category string for panic.

	@param	aReason		Reason code for panic.

	@pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

 */

EXPORT_C void TMessageBase::PanicClient(const TDesC& aCategory, TInt aReason)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"TMessageBase::PanicClient");			

	NKern::LockSystem();

	DThread* pT=_LOFF(iSem.iOwningThread,DThread,iNThread);

	pT->Die(EExitPanic,aReason,aCategory);

	Complete(KErrDied,ETrue);	// so reference on client is closed

	}

/** Gets a pointer to the sending thread.

	@return	Pointer to the thread which sent this message.

			This pointer is reference counted provided that the message has not

			yet been completed.

	@pre	Call in any context.

	@pre	Message must be in ACCEPTED state.

 */

EXPORT_C DThread* TMessageBase::Client()

	{

	return _LOFF(iSem.iOwningThread,DThread,iNThread);

	}

/** Gets the current thread's kernel message.

	@return Current thread's kernel message.

	@pre No fast mutex can be held.

	@pre Call in a thread context.

	@pre Kernel must be unlocked

	@pre interrupts enabled

*/

EXPORT_C TThreadMessage& Kern::Message()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"Kern::Message");

	return TheCurrentThread->iKernMsg;

	}

/** Constructs a kernel side message queue.

	A message queue contains a DFC which runs whenever a message is available

	and has been requested.

	@param	aFunction	Function to be called on reception of a message.

	@param	aPtr		Arbitrary parameter to be passed to above function.

	@param	aDfcQ		Pointer to DFC queue to be used for processing messages.

	@param	aPriority	Priority of this message queue within the DFC queue (0-7).

 */

EXPORT_C TMessageQue::TMessageQue(TDfcFn aFunction, TAny* aPtr, TDfcQue* aDfcQ, TInt aPriority)

	:	TDfc(aFunction,aPtr,aDfcQ,aPriority),

		iReady(EFalse),

		iMessage(NULL)

	{

	}

/** Requests the next message on this queue.

	If the queue is nonempty the next message is removed from the queue, marked

	as ACCEPTED and a pointer to it is placed in the iMessage member; the DFC is

	then activated.

	If the queue is empty it is marked as ready so that the next message to be

	sent will be accepted immediately.

    @pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

 */

EXPORT_C void TMessageQue::Receive()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"TMessageQue::Receive");			

	Lock();

	__NK_ASSERT_ALWAYS(!iReady);

	if (!iQ.IsEmpty())

		{

		iMessage=(TMessageBase*)iQ.First()->Deque();

		__KTRACE_OPT(KSERVER,Kern::Printf("MsgQ:Rx got %08x",iMessage));

		iMessage->iState=TMessageBase::EAccepted;

		UnlockAndKick();

		}

	else

		{

		__KTRACE_OPT(KSERVER,Kern::Printf("MsgQ:Rx"));

		iReady=ETrue;

		iMessage=NULL;

		Unlock();

		}

	}

/** Gets the next message synchronously if there is one.

	If the queue is nonempty the next message is removed from the queue, marked

	as ACCEPTED and a pointer to it returned.

	If the queue is empty NULL is returned.

	No asynchronous receive operation may be pending on the queue.

	@return	Pointer to next message or NULL if there is none.

	@pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Queue must not be in asynchronous receive mode.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

 */

EXPORT_C TMessageBase* TMessageQue::Poll()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"TMessageQue::Poll");			

	TMessageBase* pM=NULL;

	Lock();

	__NK_ASSERT_ALWAYS(!iReady);

	if (!iQ.IsEmpty())

		{

		pM=(TMessageBase*)iQ.First()->Deque();

		__KTRACE_OPT(KSERVER,Kern::Printf("MsgQ:Poll got %08x",pM));

		pM->iState=TMessageBase::EAccepted;

		}

	Unlock();

	return pM;

	}

/** Finds the last outstanding message on this queue.

	If the queue is nonempty a pointer to the last currently outstanding message

	is returned. The message is NOT marked as ACCEPTED or removed from the queue.

	If the queue is empty NULL is returned.

	@return	Pointer to last outstanding message or NULL if there is none.

	@pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

 */

EXPORT_C TMessageBase* TMessageQue::Last()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"TMessageQue::Last");			

	TMessageBase* pM=NULL;

	Lock();

	if (!iQ.IsEmpty())

		{

		pM=(TMessageBase*)iQ.Last();

		__KTRACE_OPT(KSERVER,Kern::Printf("MsgQ(%08x):Last=%08x",this,pM));

		}

	Unlock();

	return pM;

	}

/**	Completes all outstanding messages on this queue.

	No request is made to receive further messages.

	@param	aResult		 Completion code to pass back to message sender(s).

	@pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

	@pre	Calling thread must be in a critical section

	@post	The reference counts on all sending threads are closed asynchronously.

	@post	The queue is not ready to receive further messages.

 */

EXPORT_C void TMessageQue::CompleteAll(TInt aResult)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TMessageQue::CompleteAll");			

	TMessageBase* pM;

	while ((pM=Poll())!=NULL)

		pM->Complete(aResult,EFalse);

	}

/** Reads a descriptor from a thread's process.

	It reads a descriptor from a thread's address space, enforcing checks on validity of source and destination if necessary.

	It is used especially by device drivers to transfer data from a user thread.

	aDest might be accessed with user permission validation.

	@param aThread  Thread from which address space to read.

	@param aSrc     Pointer to a descriptor to read from. It will fail with KErrBadDescriptor if it's NULL.

	@param aDest    Descriptor to write into.

	@param aOffset	Offset in aPtr from where to start reading.

	@param aMode    Flags specifying how to read. KChunkShiftBy1 treats descriptors as 16bit while KChunkShiftBy0 treats descriptors as 8bit variants.

	@return KErrNone, if succesful;

	        KErrBadDescriptor, if aSrc or aDest is an invalid decriptor;

            KErrArgument, if aOffset is negative;

            KErrDied, if aThread is dead.

	@pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

*/

EXPORT_C TInt Kern::ThreadDesRead(DThread* aThread, const TAny* aSrc, TDes8& aDest, TInt aOffset, TInt aMode)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"Kern::ThreadDesRead");

	_CHECK_DFCQ01_CONTEXT("Kern::ThreadDesRead");

#ifndef __MEMMODEL_FLEXIBLE__

	NKern::LockSystem();

#endif

	TInt r=aThread->DesRead(aSrc,(TUint8*)aDest.Ptr(),aDest.MaxLength(),aOffset,aMode);

#ifndef __MEMMODEL_FLEXIBLE__

	NKern::UnlockSystem();

#endif

	if (r<0)

		return r;

	aDest.SetLength(r);

	return KErrNone;

	}

/** Reads a raw buffer from a thread's process.

	It reads a raw buffer from a thread's address space, enforcing checks on validity of source and destination if necessary.

	It is used especially by device drivers to transfer data from a user thread.

	aDest might be accessed with user permission validation.

	@param aThread Thread from which address space to read.

	@param aSrc    Pointer to a buffer to read from. The buffer is in aThread's address space.

	@param aDest   Pointer to a buffer to write into. The buffer is in the current process's address space.

	@param aSize   Length in bytes to be read.

	@return KErrNone, if successful;

	        KErrDied, if aThread is dead.

	        KErrBadDescriptor, if the attempt to read aSrc buffer causes exception.

	@pre    No fast mutex can be held.

	@pre	Call in a thread context.

	@pre	Kernel must be unlocked

	@pre	interrupts enabled

*/

EXPORT_C TInt Kern::ThreadRawRead(DThread* aThread, const TAny* aSrc, TAny* aDest, TInt aSize)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"Kern::ThreadRawRead");

	_CHECK_DFCQ01_CONTEXT("Kern::ThreadRawRead");

#ifndef __MEMMODEL_FLEXIBLE__

	NKern::LockSystem();

#endif

	TIpcExcTrap xt;

	xt.iLocalBase=0;

	xt.iRemoteBase=(TLinAddr)aSrc;

	xt.iSize=aSize;