// Copyright (c) 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/sshbuf.cpp

// Shareable Data Buffers

#include <kernel/sshbuf.h>

#include <kernel/cache.h>

#include "execs.h"

#include <kernel/smap.h>

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

 * Kernel-side executive calls

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

TInt ExecHandler::ShPoolCreate(const TShPoolInfo& aInfo, TUint aFlags)

	{

	__KTRACE_OPT(KEXEC, Kern::Printf(">Exec::ShPoolCreate"));

	const TUint acceptableFlags = EShPoolWriteable | EShPoolAllocate;

	TUint validatedFlags = aFlags & acceptableFlags;

	aFlags &= ~acceptableFlags;

	if (aFlags != 0)

		{

		Kern::Printf("Exec::ShPoolCreate: flags 0x%x after 0x%x", aFlags, validatedFlags);

		// SBZ bit set in flags passed to the exec call: panic the caller.

		K::PanicKernExec(EShBufExecBadParameter);

		}

	TShPoolCreateInfo uinfo;

	kumemget32(&uinfo.iInfo, &aInfo, sizeof(uinfo.iInfo));

	NKern::ThreadEnterCS();

	DShPool* pC = NULL;

	TInt r = K::ShPoolCreate(pC, uinfo); // should call the ShPoolCreate method on process

	if (r == KErrNone)

		{

		// The flags are passed down as attributes to RequestUserHandle, Add, and AddToProcess

		r = K::MakeHandle(EOwnerProcess, pC, validatedFlags);	// this will add the pool to the process

		if (r < KErrNone && pC)

			pC->Close(NULL);	// can't have been added so NULL

		}

	NKern::ThreadLeaveCS();

	__KTRACE_OPT(KEXEC, Kern::Printf("<Exec::ShPoolCreate returns %d", r));

	return r;

	}

TInt K::ShPoolCreate(DShPool*& aPool, TShPoolCreateInfo& aInfo)

	{

	__KTRACE_OPT(KEXEC,Kern::Printf(">K::ShPoolCreate"));

	DThread* pT=TheCurrentThread;

	DProcess* pP=pT->iOwningProcess;

	TInt r = pP->NewShPool(aPool, aInfo);

	if (r != KErrNone)

		aPool = NULL;

	__KTRACE_OPT(KEXEC, Kern::Printf("<K::ShPoolCreate returns %d %08x", r, aPool));

	return r;

	}

TInt DShPool::ModifyClientFlags(DProcess* aProcess, TUint aSetMask, TUint aClearMask)

	{

	LockPool();

	DShPoolClient* client = reinterpret_cast<DShPoolClient*>(iClientMap->Find(reinterpret_cast<TUint>(aProcess)));

	if ((client != NULL) && client->iAccessCount)

		{

		// access count must be non-zero otherwise the pool is in the process of being closed

		client->iFlags &= ~aClearMask;

		client->iFlags |= aSetMask;

		}

	UnlockPool();

	return KErrNone;

	}

TInt ExecHandler::ShPoolAlloc(TInt aHandle, TUint aFlags, SShBufBaseAndSize& aBaseAndSize)

	{

	__KTRACE_OPT(KEXEC, Kern::Printf(">Exec::ShPoolAlloc (0x%08x, 0x%x)", aHandle, aFlags));

	TUint attr = 0;

	DShBuf* pC = NULL;

	NKern::LockSystem();

	DShPool* pool = reinterpret_cast<DShPool*>(K::ObjectFromHandle(aHandle, EShPool, attr));

	/* K::ObjectFromHandle will panic on NULL */

	pool->CheckedOpen();

	NKern::ThreadEnterCS();

	NKern::UnlockSystem();

	TInt r = KErrAccessDenied;		// for the case that (attr & EShPoolAllocate) == 0

	SShBufBaseAndSize bs;

	if ((attr & EShPoolAllocate))

		{

		r = pool->Alloc(pC);

		if (r == KErrNone)

			{

			attr |= RObjectIx::EReserved;

			if (aFlags & EShPoolAllocNoMap)

				{

				attr |= EShPoolNoMapBuf;

				}

			r=K::MakeHandle(EOwnerProcess, pC, attr);	// this will add the buffer to the process

			if (r < KErrNone && pC != NULL)

				pC->Close(NULL);				// can't have been added so NULL

			else

				{

				bs.iBase = reinterpret_cast<TUint>(pC->Base(TheCurrentThread->iOwningProcess));

				bs.iSize = pool->BufSize();

				}

			}

		}

	pool->Close(NULL);

	NKern::ThreadLeaveCS();

	if (r > KErrNone)

		{

		kumemput32(&aBaseAndSize, &bs, sizeof(bs));

		}

	__KTRACE_OPT(KEXEC, Kern::Printf("<Exec::ShPoolAlloc returns %d 0x%08x", r, pC));

	return r;

	}

void ExecHandler::ShPoolGetInfo(DShPool* aShPool, TShPoolInfo& aInfo)

	{

	__KTRACE_OPT(KEXEC,Kern::Printf(">Exec::ShPoolGetInfo"));

	TShPoolInfo info;

	aShPool->GetInfo(info);

	NKern::UnlockSystem();

	kumemput32(&aInfo,&info,sizeof(info));

	}

TUint ExecHandler::ShPoolFreeCount(DShPool* aShPool)

	{

	__KTRACE_OPT(KEXEC,Kern::Printf(">Exec::ShPoolFreeCount (0x%08x)", aShPool));

	return aShPool->FreeCount();

	}

TInt ExecHandler::ShPoolNotification(DShPool* aShPool, TShPoolNotifyType aType, TUint aThreshold, TRequestStatus& aStatus)

	{

	__KTRACE_OPT(KEXEC, Kern::Printf(">Exec::ShPoolNotification (0x%08x, %d, 0x%x)", aShPool, aType, &aStatus));

	aShPool->CheckedOpen();

	NKern::ThreadEnterCS();

	NKern::UnlockSystem();

	TInt r = aShPool->AddNotification(aType, aThreshold, aStatus);

	aShPool->Close(NULL);

	NKern::ThreadLeaveCS();

	if (r == KErrArgument)

		K::PanicKernExec(EShBufExecBadNotification);

	return r;

	}

TInt ExecHandler::ShPoolNotificationCancel(DShPool* aShPool, TShPoolNotifyType aType, TRequestStatus& aStatus)

	{

	__KTRACE_OPT(KEXEC, Kern::Printf(">Exec::ShPoolNotificationCancel (0x%08x)", aShPool));

	aShPool->CheckedOpen();

	NKern::ThreadEnterCS();

	NKern::UnlockSystem();

	TInt r = aShPool->RemoveNotification(aType, aStatus);

	aShPool->Close(NULL);

	NKern::ThreadLeaveCS();

	if (r == KErrArgument)

		K::PanicKernExec(EShBufExecBadNotification);

	return r;

	}

TInt ExecHandler::ShPoolBufferWindow(DShPool* aShPool, TInt aWindowSize, TBool aAutoMap)

	{

	__KTRACE_OPT(KEXEC,Kern::Printf(">Exec::ShPoolBufferWindow (0x%08x)", aShPool));

	DProcess* pP = TheCurrentThread->iOwningProcess;

	aShPool->CheckedOpen();

	NKern::ThreadEnterCS();

	NKern::UnlockSystem();

	TInt r = aShPool->SetBufferWindow(pP, aWindowSize);

	if (r == KErrNone)

		{

		r = aShPool->ModifyClientFlags(pP, aAutoMap ? EShPoolAutoMapBuf : 0, aAutoMap ? 0 : EShPoolAutoMapBuf);

		}

	aShPool->Close(NULL);

	NKern::ThreadLeaveCS();

	return r;

	}

TInt ExecHandler::ShBufMap(DShBuf* aBuf, TBool aReadOnly, SShBufBaseAndSize& aBaseAndSize)

	{

	__KTRACE_OPT(KEXEC, Kern::Printf(">Exec::ShBufMap (0x%08x)", aBuf));

	DProcess* pP = TheCurrentThread->iOwningProcess;

	DShPool* pool = aBuf->iPool;

	SShBufBaseAndSize bs;

	TInt r = KErrAccessDenied;

	aBuf->CheckedOpen();

	NKern::ThreadEnterCS();

	NKern::UnlockSystem();

	pool->LockPool();

	DShPoolClient* client = reinterpret_cast<DShPoolClient*>(pool->iClientMap->Find(reinterpret_cast<TUint>(pP)));

	TUint attr = client->iFlags;

	pool->UnlockPool();

	// if the buffer is being mapped as writeable check that the pool has the corresponding

	// capabilities

	if (aReadOnly)

		attr &= ~EShPoolWriteable;

	r = aBuf->Map(attr, pP, bs.iBase);

	bs.iSize = aBuf->Size();

	aBuf->Close(NULL);

	NKern::ThreadLeaveCS();

	if (r == KErrNone)

		{

		kumemput32(&aBaseAndSize, &bs, sizeof(bs));

		}

	__KTRACE_OPT(KEXEC, Kern::Printf("<Exec::ShBufMap returns %d 0x%08x",r, bs.iBase));

	return r;

	}

TInt ExecHandler::ShBufUnMap(DShBuf* aShBuf)

	{

	__KTRACE_OPT(KEXEC, Kern::Printf(">Exec::ShBufUnMap (0x%08x)", aShBuf));

	aShBuf->CheckedOpen();

	NKern::ThreadEnterCS();

	DProcess* pP = TheCurrentThread->iOwningProcess;

	NKern::UnlockSystem();

	TInt r = aShBuf->UnMap(pP);

	aShBuf->Close(NULL);

	NKern::ThreadLeaveCS();

	return r;

	}

TInt ExecHandler::ShBufBaseAndSize(DShBuf* aShBuf, SShBufBaseAndSize& aBaseAndSize)

	{

	__KTRACE_OPT(KEXEC, Kern::Printf(">Exec::ShBufBaseAndSize (0x%08x)", aShBuf));

	aShBuf->CheckedOpen();

	NKern::ThreadEnterCS();

	NKern::UnlockSystem();

	SShBufBaseAndSize bs;

	bs.iBase = reinterpret_cast<TUint>(aShBuf->Base(TheCurrentThread->iOwningProcess));

	bs.iSize = aShBuf->Size();

	aShBuf->Close(NULL);

	NKern::ThreadLeaveCS();

	kumemput32(&aBaseAndSize, &bs, sizeof(bs));

	__KTRACE_OPT(KEXEC, Kern::Printf("<Exec::ShBufBaseAndSize (0x%08x, 0x%08x, 0x%08x)", aShBuf, bs.iBase, bs.iSize));

	return KErrNone;

	}

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

 * DShPool and DShBuf

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

EXPORT_C TShPoolInfo::TShPoolInfo()

	{

	memclr(this, sizeof(TShPoolInfo));

	}

EXPORT_C TShPoolCreateInfo::TShPoolCreateInfo(TShPoolPageAlignedBuffers aFlag, TUint aBufSize, TUint aInitialBufs)

	{

	iInfo.iBufSize = aBufSize;

	iInfo.iInitialBufs = aInitialBufs;

	iInfo.iFlags = aFlag;

	SetSizingAttributes(aInitialBufs,0,0,0);

	iPhysAddr.iPhysAddrList = 0;

	iPages = 0;

	}

EXPORT_C TShPoolCreateInfo::TShPoolCreateInfo(TShPoolNonPageAlignedBuffers aFlag, TUint aBufSize, TUint aInitialBufs, TUint aAlignment)

	{

	iInfo.iBufSize = aBufSize;

	iInfo.iInitialBufs = aInitialBufs;

	iInfo.iAlignment = aAlignment;

	iInfo.iFlags = aFlag;

	SetSizingAttributes(aInitialBufs,0,0,0);

	iPhysAddr.iPhysAddrList = 0;

	iPages = 0;

	}

/**

Sets the pool to be created in a specific physical address range

@param aFlag		Indicates pool to be created within a specific physical address range

@param aBufSize		Size of a single buffer within the pool

@param aInitialBufs Initial number of buffers allocated to the pool

@param aAlignment	Alignment of the start of each buffer in the pool

@param aPages		Number of pages to commit. Must be a multiple of the MMU

@param aPhysicalAddressList A pointer to a list of physical addresses, one address for

						each page of memory committed. Each physical address must be

						a multiple of the MMU page size.

@see DShPool::Create()

*/

EXPORT_C TShPoolCreateInfo::TShPoolCreateInfo(TShPoolMemoryDevice aFlag, TUint aBufSize, TUint aInitialBufs, TUint aAlignment, TUint aPages, TPhysAddr* aPhysicalAddressList)

	{

	iInfo.iBufSize = aBufSize;

	iInfo.iInitialBufs = aInitialBufs;

	iInfo.iAlignment = aAlignment;

	iPhysAddr.iPhysAddrList = aPhysicalAddressList;

	iPages = aPages;

	iInfo.iFlags = aFlag;

	SetSizingAttributes(aInitialBufs,0,0,0);

	}

/**

Sets the pool to be created in a specific physical address range

@param aFlag		Indicates pool to be created within a specific physical address range

@param aBufSize		Size of a single buffer within the pool

@param aInitialBufs Initial number of buffers allocated to the pool

@param aAlignment	Alignment of the start of each buffer in the pool

@param aPages		Number of pages to commit. Must be a multiple of the MMU

@param aPhysicalAddress A physical address, Each physical address must be

						a multiple of the MMU page size.

@see DShPool::Create()

*/

EXPORT_C TShPoolCreateInfo::TShPoolCreateInfo(TShPoolMemoryDevice aFlag, TUint aBufSize, TUint aInitialBufs, TUint aAlignment, TUint aPages, TPhysAddr aPhysicalAddress)

	{

	iInfo.iBufSize = aBufSize;

	iInfo.iInitialBufs = aInitialBufs;

	iInfo.iAlignment = aAlignment;

	iPhysAddr.iPhysAddr = aPhysicalAddress;

	iPages = aPages;

	iInfo.iFlags = aFlag;

	SetContiguous();

	SetSizingAttributes(aInitialBufs,0,0,0);

	}

EXPORT_C TInt TShPoolCreateInfo::SetSizingAttributes(TUint aMaxBufs, TUint aGrowTriggerRatio,

					TUint aGrowByRatio, TUint aShrinkHysteresisRatio)

	{

	if (aGrowTriggerRatio == 0 || aGrowByRatio == 0)	// No automatic growing/shrinking

		{

		aGrowTriggerRatio = aGrowByRatio = 0;

		if (aMaxBufs != iInfo.iInitialBufs)

			return KErrArgument;

		}

	else

		{

		// aGrowTriggerRatio must be < 1.0 (i.e. 256)

		// aShrinkHysteresisRatio must be > 1.0

		if (aGrowTriggerRatio >= 256 || aShrinkHysteresisRatio <= 256)

			return KErrArgument;

		if ((iInfo.iFlags & EShPoolContiguous) && (iInfo.iFlags & EShPoolNonPageAlignedBuffer))

			return KErrNotSupported;

		}

	iInfo.iMaxBufs			= aMaxBufs;

	iInfo.iGrowTriggerRatio	= aGrowTriggerRatio;

	iInfo.iGrowByRatio		= aGrowByRatio;

	iInfo.iShrinkHysteresisRatio = aShrinkHysteresisRatio;

	return KErrNone;

	}

EXPORT_C TInt TShPoolCreateInfo::SetExclusive()

	{

	iInfo.iFlags |= EShPoolExclusiveAccess;

	return KErrNone;

	}

EXPORT_C TInt TShPoolCreateInfo::SetGuardPages()

	{

	iInfo.iFlags |= EShPoolGuardPages;

	return KErrNone;

	}

EXPORT_C TInt TShPoolCreateInfo::SetContiguous()

	{

	iInfo.iFlags |= EShPoolContiguous;

	return KErrNone;

	}

/**

   Creates a pool of buffers with the specified attributes

   @param aPool[out]      Returns a pointer to the pool.

   @param aInfo           Reference to pool create information.

   @param aMap   		  ETrue specifies that an allocated or received buffer

	                      will be automatically mapped into the process's address space.

   @param aFlags		  Flags to modify the behaviour of the handle.  This should be a bit-wise

						  OR of values from TShPoolHandleFlags.

   @pre Calling thread must be in a critical section.

   @return the KErrNone if successful, otherwise one of the system-wide error codes.

*/

EXPORT_C TInt Kern::ShPoolCreate(TShPool*& aPool, TShPoolCreateInfo& aInfo, TBool aMap, TUint aFlags)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">Kern::ShPoolCreate, (aInfo 0x%08x)", &aInfo));

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL, "Kern::ShPoolCreate");

	aPool = NULL;

	const TUint acceptableFlags = EShPoolWriteable | EShPoolAllocate;

	TUint validatedFlags = aFlags & acceptableFlags;

	aFlags &= ~acceptableFlags;

	if (aFlags != 0)

		{

		Kern::Printf("Kern::ShPoolCreate: flags 0x%x after 0x%x", aFlags, validatedFlags);

		return KErrArgument;

		}

	DShPool* pool;

	TInt r = K::TheKernelProcess->NewShPool(pool, aInfo);

	if (r == KErrNone)

		{

		if (aMap) validatedFlags |= EShPoolAutoMapBuf;

		r = pool->AddToProcess(K::TheKernelProcess, validatedFlags);

		if (r == KErrNone)

			{

			aPool = reinterpret_cast<TShPool*>(pool);

			}

		else

			{

			pool->Close(NULL);	// can't have been added so NULL

			}

		}

	__KTRACE_OPT(KMMU, Kern::Printf("<Kern::ShPoolCreate, pool(%x)", aPool));

	return r;

	}

/**

   Opens a pool of buffers in the kernel address space using a user process

   handle

   @param aPool[out]      Returns pointer to the pool.

   @param aThread         Pointer to user process thread, if null

                          current thread is used.

   @param aHandle         User process handle to open pool from

   @param aMap   		  ETrue specifies that an allocated or received buffer

	                      will be automatically mapped into the process's address space.

   @param aFlags		  Flags to modify the behaviour of the handle.  This should be a bit-wise

						  OR of values from TShPoolHandleFlags.

   @pre Calling thread must be in a critical section.

   @return the KErrNone if successful, otherwise one of the system-wide error codes.

*/

EXPORT_C TInt Kern::ShPoolOpen(TShPool*& aPool, DThread* aThread, TInt aHandle, TBool aMap, TUint aFlags)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">Kern::ShPoolOpen, 0x%08x %d", aThread, aHandle));

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL, "Kern::ShPoolOpen");

	const TUint acceptableFlags = EShPoolWriteable | EShPoolAllocate;

	TUint validatedFlags = aFlags & acceptableFlags;

	aFlags &= ~acceptableFlags;

	if (aFlags != 0)

		{

		Kern::Printf("Kern::ShPoolOpen: flags 0x%x after 0x%x", aFlags, validatedFlags);

		return KErrArgument;

		}

	TInt r = KErrNotFound;

	aPool = NULL;

	TUint attr;

	NKern::LockSystem();

	DShPool* pool = reinterpret_cast<DShPool*>(aThread->ObjectFromHandle(aHandle, EShPool, attr));

	if (pool != NULL)

		{

		r = pool->Open();

		}

	NKern::UnlockSystem();

	attr |= validatedFlags;

	if (r == KErrNone)

		{

		if (aMap) attr |= EShPoolAutoMapBuf;

		r = pool->AddToProcess(K::TheKernelProcess, attr);

		if (r == KErrNone)

			{