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

// 

//

#include <kernel/kern_priv.h>

#include "execs.h"

#include "memmodel.h"

#define iMState		iWaitLink.iSpare1

const TInt KMaxMsgLimit=512;

extern "C" void __SendDiscMsg(DSession* aSession);

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

 * User side message formats

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

// User side message version

// This must match the layout of class RMessage2

class RMessageU2

	{

public:

	inline RMessageU2(const RMessageK& a);

public:

	// from RMessagePtr2

	TInt iHandle;

	// from RMessage2

	TInt iFunction;

	TInt iArgs[KMaxMessageArguments];

	TUint32 iSpare1;

	const TAny* iSessionPtr;

#if		0

	// not used or copied by IPC, so not required ...

	mutable TInt iFlags;

	TInt iSpare3;

#endif

	};

inline RMessageU2::RMessageU2(const RMessageK& a)

	{

	iHandle = (TInt)&a;

	iFunction = a.iFunction;

	if (iFunction == RMessage2::EDisConnect)

		{

		iArgs[0] = 0;

		iArgs[1] = 0;

		iArgs[2] = 0;

		iArgs[3] = 0;

		}

	else

		{

		iArgs[0] = a.Arg(0);

		iArgs[1] = a.Arg(1);

		iArgs[2] = a.Arg(2);

		iArgs[3] = a.Arg(3);

		}

	iSpare1 = 0;

	iSessionPtr = a.iSession->iSessionCookie;

#ifdef KIPC

	if (KDebugNum(KIPC))

		Kern::Printf("RMessageU2(%08X): %08X %08X; %08X->%08X",

			&a, iHandle, iFunction, a.iSession, iSessionPtr);

#endif //KIPC

	}

TServerMessage::TServerMessage() :

	TClientRequest(CallbackFunc)

	{

	}

#ifndef __CLIENT_REQUEST_MACHINE_CODED__

void TServerMessage::CallbackFunc(TAny* aData, TUserModeCallbackReason aReason)

	{

	TServerMessage* req = (TServerMessage*)aData;

	if (aReason == EUserModeCallbackRun && req->iResult == KErrNone)

		{

		RMessageU2 userData(*req->iMessageData);

		K::USafeWrite(req->iMessagePtr, &userData, sizeof(userData));

		}

	TClientRequest::CallbackFunc(aData, aReason);

	}

#endif

RMessageK::RMessageK() :

	TClientRequest(CallbackFunc),

   	iAccessCount(0)

	{

	}

void RMessageK::CallbackFunc(TAny* aData, TUserModeCallbackReason aReason)

	{

	RMessageK* msg = (RMessageK*)aData;

	TBool ok = ETrue;

	if (aReason == EUserModeCallbackRun)

		{

		// Write back updated descriptor lengths

		TInt flags = msg->iMsgArgs.AllDesWritten();

		for (TInt i = 0 ; flags != 0 ; ++i, flags >>= 1)

			{

			if (flags & 1)

				{

				const TDesHeader& des = msg->Descriptor(i);

				TAny* exc = K::USafeWrite(msg->Ptr(i), &des.TypeAndLength(), sizeof(TUint32));

				if (exc != NULL)

					ok = EFalse;	

				if (ok && des.Type() == EBufCPtr)

					{

					TInt len = des.Length();

					TUint8* pL = (TUint8*)(des.DataPtr() - sizeof(TDesC));

					exc = K::USafeWrite(pL, &len, sizeof(len));

					if (exc != NULL)

						ok = EFalse;	

					}

				}

			}

		}

	TClientRequest::CallbackFunc(aData, aReason);

	NKern::LockSystem();

	__NK_ASSERT_DEBUG(msg->IsCompleting());

	msg->CloseRef();

	NKern::UnlockSystem();

	if (!ok)

		{

		NKern::ThreadLeaveCS();

		K::PanicKernExec(EBadIpcDescriptor);

		}

	}

void RMessageK::OpenRef()

	{ 

	// iAccess count will probably never be more than 2?

	__NK_ASSERT_DEBUG(iAccessCount < 0xfe);

	__e32_atomic_add_ord8(&iAccessCount, 1);

	}

void RMessageK::CloseRef()

	{

	__ASSERT_SYSTEM_LOCK;

	if (__e32_atomic_add_ord8(&iAccessCount, (TUint8)-1) == 1)

	   	Free(); 

	}

#if		0

// Just to exercise the chunk-adjustment code and check that we

// manage the system lock and thread critical sections correctly.

// Enter and return with system unlocked and caller in a critical section

static void JiggleMsgChunk()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL, "RMessageK::JiggleMsgChunk");

	DChunk* msgChunk = K::MsgInfo.iChunk;

	if (msgChunk)

		{

		__ASSERT_DEBUG((TUint)msgChunk->Size() == K::MsgInfo.iCurrSize, K::Fault(K::EMsgFreeBadPool));

		msgChunk->Adjust(K::MsgInfo.iCurrSize+Kern::RoundToPageSize(1));

		msgChunk->Adjust(K::MsgInfo.iCurrSize);

		__ASSERT_DEBUG((TUint)msgChunk->Size() == K::MsgInfo.iCurrSize, K::Fault(K::EMsgFreeBadPool));

		}

	}

	// We must drop the system lock before calling JiggleMsgChunk(),

	// but as our caller may be holding resources we have to enter a

	// critical section before doing so. Note that K::ThreadEnterCS()

	// (as opposed to NKern::ThreadEnterCS()) both enters a critical

	// section AND then releases the lock; likewise K::ThreadLeaveCS()

	// reclaims the system lock before leaving the critical section,

	// so there is no window for the thread to be killed while holding

	// allocated resources ...

	K::ThreadEnterCS();

	JiggleMsgChunk();

	K::ThreadLeaveCS();

#endif

#ifdef	_DEBUG

// Check consistency of the specified list

// Enter and return with system locked

static TBool MessagePoolIntact(RMessageK* p = K::MsgInfo.iNextMessage, TInt count = K::MsgInfo.iFreeMessageCount)

{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED, "DSession::MessagePoolIntact");

	TInt k = 0;

	while (p)

		{

		k += 1;

		p = (RMessageK*)p->iSessionLink.iNext;

		}

	return (k == count);

}

// Ditto, but enter and return with system unlocked

static TBool MessagePoolIntactUnlocked()

	{

	NKern::LockSystem();

	TInt r = MessagePoolIntact();

	NKern::UnlockSystem();

	return r;

	}

#endif

#ifndef __MESSAGE_MACHINE_CODED_2__

EXPORT_C RMessageK* RMessageK::MessageK(TInt aMsgHandle)

//

// Validates a message handle and converts it into a pointer.

// Enter and leave with system locked.

//

	{

	RMessageK* m = MessageK(aMsgHandle, TheCurrentThread);

	if (m == NULL || m->iFunction == RMessage2::EDisConnect)

		K::PanicCurrentThread(EBadMessageHandle);

	return m;

	}

RMessageK* RMessageK::MessageK(TInt aMsgHandle, DThread* aThread)

//

// Validates a message handle and converts it into a pointer.

// Enter and leave with system locked.

//

	{

	RMessageK& m = *(RMessageK*)aMsgHandle;

	SDblQueLink lnk;

	// Handle must point into kernel message chunk, and be correctly aligned

	TInt offset = (TUint8*)&m - K::MsgInfo.iBase;

	if (offset < 0 || offset+sizeof(RMessageK) > (TUint)K::MsgInfo.iMaxSize)

		return NULL;

	if (offset & (KMessageSize-1))

		return NULL;

	// Message must be readable, in the correct state and owned by the right process

	if (Kern::SafeRead(&m.iServerLink, &lnk, sizeof(lnk)) != NULL

	||  TUint32(lnk.iNext) != ~TUint32(&m)

	||	TUint32(lnk.iPrev) != ~TUint32(aThread->iOwningProcess))

		return NULL;

	return &m;

	}

#endif

// Claim one page of memory, carve it up into message blocks,

// and add them to the global pool

// Enter and return with system lock, may be temporarily released though

TInt RMessageK::ExpandMessagePool()

	{

	// KMessageSize must have been defined as a power of two at least as big as an RMessageK

	__ASSERT_COMPILE((KMessageSize & (KMessageSize-1)) == 0);

	__ASSERT_COMPILE(KMessageSize >= sizeof(RMessageK));

	// This function can be called during the creation of the very first thread, which is

	// before the msg chunk has been created (the first thread will own the chunk, so must

	// be created first). In this situation we cannot expand the pool, and so just return.

	// This first thread is thus unique in not having a preallocated message for synchronous

	// use; but it's destined to become the idle thread and as such never makes use of IPC.

	// So that's alright then :)

	DChunk* msgChunk = K::MsgInfo.iChunk;

	if (!msgChunk)

		return KErrNotReady;

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED, "DSession::ExpandMessagePool");

	__ASSERT_DEBUG(MessagePoolIntact(), K::Fault(K::EMsgFreeBadPool));

	RMessageK* first = NULL;

	RMessageK* m = NULL;

	TInt r = KErrNone;

	TInt k = 0;

	// We must drop the system lock before calling DChunk::Adjust().

	// This DMutex ensures single-threading while adjusting the pool.

	// Note that the system lock may be dropped and reacquired here ...

	TUint oldSize = K::MsgInfo.iCurrSize;

	NKern::ThreadEnterCS();

	K::MsgInfo.iMsgChunkLock->Wait();

	NKern::UnlockSystem();

	// Someone may have got in first while we were waiting for the DMutex.

	// So we only expand the chunk if its size is unchanged from above;

	// otherwise we just do nothing and let the caller retry if necessary

	if (K::MsgInfo.iCurrSize == oldSize)

		{

		__ASSERT_DEBUG((TUint)msgChunk->Size() == K::MsgInfo.iCurrSize, K::Fault(K::EMsgFreeBadPool));

		__KTRACE_OPT(KSERVER,Kern::Printf("ExpandMessagePool(): MsgChunk %08X, base %08X, size %08X, max %08X",

			msgChunk, K::MsgInfo.iBase, K::MsgInfo.iCurrSize, K::MsgInfo.iMaxSize));

		r = msgChunk->Adjust(K::MsgInfo.iCurrSize+Kern::RoundToPageSize(KMessageSize));

		__KTRACE_OPT(KSERVER,Kern::Printf("ExpandMessagePool(): Adjust returns %d, size now %08X", r, msgChunk->Size()));

		if (r == KErrNone)

			{

			// Turn the allocated memory info a list of messages

			// This can (and should) be done without the system lock

			TUint8* p = K::MsgInfo.iBase + K::MsgInfo.iCurrSize;

			K::MsgInfo.iCurrSize = (TUint)msgChunk->Size();

			TUint8* top = K::MsgInfo.iBase + K::MsgInfo.iCurrSize;

			__ASSERT_DEBUG(p < top, K::Fault(K::EMsgFreeBadPool));

			memclr(p, top-p);

			for (first = (RMessageK*)p, k = 0; p < top; ++k)

				{

				m = (RMessageK*)p;

				p += KMessageSize;

				new (m) RMessageK;

				m->iMsgType = EGlobal;

				m->iSessionLink.iNext = (SDblQueLink*)p;

				}

			__ASSERT_DEBUG(p == top, K::Fault(K::EMsgFreeBadPool));

			__ASSERT_DEBUG((TAny*)(m+1) <= top, K::Fault(K::EMsgFreeBadPool));

			}

		}

	// Reacquire system lock before adding the new messages to the pool

	// Note that K::MsgInfo.iNextMessage may no longer be NULL

	NKern::LockSystem();

	if (first)

		{

		// We expanded the pool; m is the last allocated message

		m->iSessionLink.iNext = (SDblQueLink*)K::MsgInfo.iNextMessage;

		K::MsgInfo.iNextMessage = first;

		K::MsgInfo.iFreeMessageCount += k;

		}

	// Now we can release the pool mutex; unfortunately this also releases

	// the system lock, so we have to acquire it again before returning.

	// This makes it possible -- though very unlikely -- that after adding

	// messages to the pool, they *all* get claimed by other threads in the

	// window between dropping the system lock and reacquiring it, so that

	// our caller finds the pool still empty.  In such cases, it's up to

	// the caller to retry ...

	K::MsgInfo.iMsgChunkLock->Signal();

	NKern::LockSystem();

	NKern::ThreadLeaveCS();

	return r;

	}

// Claim a chain of aCount RMessageK objects from the global pool,

// and set their type to aType (e.g. ESession or ESync)

// Enter and return with system unlocked and caller in a critical section

RMessageK* RMessageK::ClaimMessagePool(enum TMsgType aType, TInt aCount, DSession *aSession)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL, "RMessageK::ClaimMessagePool");

	RMessageK* chain = NULL;

	TInt wanted = aCount;

	// In order not to hold the system lock for too long at one time,

	// we release it between iterations of this loop.

#define	KMaxMessagesInOneGo		16

	for (NKern::LockSystem(); ; NKern::FlashSystem())

		{

		TInt n = Min(wanted, KMaxMessagesInOneGo);

		while (K::MsgInfo.iFreeMessageCount < n)

			if (ExpandMessagePool() != KErrNone)

				goto fail;

		__ASSERT_DEBUG(MessagePoolIntact(), K::Fault(K::EMsgFreeBadPool));

		RMessageK* first = K::MsgInfo.iNextMessage;

		RMessageK* last = first;

		RMessageK* p = first;

		// Count out n message blocks

		__ASSERT_DEBUG(K::MsgInfo.iFreeMessageCount >= n, K::Fault(K::EMsgFreeBadPool));

		for (TInt k = 0; k < n; ++k)

			{

			last = p;

			p->iSession = aSession;

			p->iMsgType = (TUint8)aType;

			p = (RMessageK*)p->iSessionLink.iNext;

			}

		// Add them to the chain we're building

		if (chain)

			last->iSessionLink.iNext = (SDblQueLink*)chain;

		else

			last->iSessionLink.iNext = NULL;

		chain = first;

		// Synchronise the global pool

		K::MsgInfo.iNextMessage = p;

		K::MsgInfo.iFreeMessageCount -= n;

		__ASSERT_DEBUG(MessagePoolIntact(), K::Fault(K::EMsgFreeBadPool));

		if ((wanted -= n) == 0)

			break;

		}

	__ASSERT_DEBUG(MessagePoolIntact(chain, aCount), K::Fault(K::EMsgFreeBadPool));

	NKern::UnlockSystem();

	// Return this chain of message blocks

	return chain;

fail:

	__ASSERT_DEBUG(MessagePoolIntact(), K::Fault(K::EMsgFreeBadPool));

	NKern::UnlockSystem();

	if (chain)

		chain->ReleaseMessagePool(aType, KMaxTInt);

	return NULL;

	}

// Release a chain of at most aMax RMessageK objects back to the

// global pool, resetting their type to EGlobal in the process

// Enter and return with system unlocked and caller in a critical section

void RMessageK::ReleaseMessagePool(enum TMsgType aType, TInt aMax)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL, "RMessageK::ReleaseMessagePool");

	__ASSERT_DEBUG(MessagePoolIntactUnlocked(), K::Fault(K::EMsgFreeBadPool));

	RMessageK* next = this;

	RMessageK* p;

	TInt k = 0;

	do

		{

		p = next;

		next = (RMessageK*)p->iSessionLink.iNext;

		__ASSERT_DEBUG(p->iMsgType == aType, K::Fault(K::EMsgFreeBadPool));

		p->iMsgType = EGlobal;

		}

	while (++k < aMax && next != NULL);

	// The linked list may not be NULL-terminated -- in DEBUG builds, the link

	// may be deliberately set to an invalid value.  Here, we assert that if

	// exit was reached because the count reached zero, rather than because we

	// reached a NULL link, then the next link was in fact just such a value.

#ifndef	KILL_LINK_VALUE

#define KILL_LINK_VALUE ((SDblQueLink*)0xdfdfdfdf)

#endif

	__ASSERT_DEBUG((next == NULL || (k == aMax && next == (TAny*)KILL_LINK_VALUE)), K::Fault(K::EMsgFreeBadPool));

	__ASSERT_DEBUG((k == aMax || aMax == KMaxTInt), K::Fault(K::EMsgFreeBadPool));

	// At the end of the chain

	NKern::LockSystem();

	p->iSessionLink.iNext = (SDblQueLink*)K::MsgInfo.iNextMessage;

	K::MsgInfo.iNextMessage = this;

	K::MsgInfo.iFreeMessageCount += k;

	__ASSERT_DEBUG(MessagePoolIntact(), K::Fault(K::EMsgFreeBadPool));

	NKern::UnlockSystem();

	(void)aType;				// Suppress compiler whinge in non-DEBUG build

	}

// Get a free message from the global pool. Expand the global pool if

// it's empty; but return NULL if that fails to add more messages.

// 

// Enter and return with system lock, may be temporarily released though

RMessageK* RMessageK::GetNextFreeMessage(DSession* aSession)

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED, "RMessageK::GetNextFreeMessage");

	__ASSERT_DEBUG(MessagePoolIntact(), K::Fault(K::EMsgFreeBadPool));

	RMessageK* volatile* p = &K::MsgInfo.iNextMessage;

	RMessageK* m;

	// If there are no free messages, expand the global pool. Keep trying

	// until we successfully get a message or fail with an error.

	while ((m = *p) == NULL)

		if (ExpandMessagePool() != KErrNone)

			return NULL;

	*p = (RMessageK*)m->iSessionLink.iNext;

	m->iSessionLink.iNext = NULL;

	m->iSession = aSession;

	K::MsgInfo.iFreeMessageCount -= 1;

	__ASSERT_DEBUG(MessagePoolIntact(), K::Fault(K::EMsgFreeBadPool));

	__KTRACE_OPT(KSERVER,Kern::Printf("RMessageK::GetNextFreeMessage returns %08x", m));

	return m;

	}

// Enter and return with system unlocked.

void RMessageK::TMsgArgs::ReadDesHeaders(const TInt aArgsPtr[KMaxMessageArguments+1])

	{

	// Copy the args into the structure; the extra word contains the IPC flags

	TInt i;

	for (i = 0; i < KMaxMessageArguments; ++i)

		iArgs[i] = *aArgsPtr++;

	iArgFlags = *aArgsPtr & KAllIpcFlagsMask;

	TInt descFlags = AllDescriptorFlags();

	for (i = 0; descFlags != 0; ++i, descFlags >>= TIpcArgs::KBitsPerType)

		if (descFlags & TIpcArgs::EFlagDes)

			{

			// Read descriptor header in current process.  May take page fault

			TInt r = K::USafeReadAndParseDesHeader((TAny*)iArgs[i], iDesInfo[i]);

			if (r != KErrNone)

				{

				// If the descriptor is bad (unreadable or unknown type), clear

				// the parameter type and mark the descriptor header as invalid

				SetArgUndefined(i);

				iDesInfo[i].Unset();

				}

			}

	}

// Enter and return with system unlocked and caller in a critical section

void UnpinMessageArguments(RMessageK::TPinArray *aPinArray)

	{

	for (TInt i = 0; i < KMaxMessageArguments; ++i)

		{

		if (aPinArray->iPinPtrs[i])

			{

			// This will unpin the pinned memory and set iPinPtrs[i] to NULL.

			M::DestroyVirtualPinObject(aPinArray->iPinPtrs[i]);

			}

		__NK_ASSERT_DEBUG(!aPinArray->iPinPtrs[i]);

		}

	}

// Enter and return with system lock, may be temporarily released though

TInt RMessageK::PinDescriptors(DSession* aSession, TBool aPinningServer)

	{