// Copyright (c) 2008-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:

// e32test\system\d_atomic.cpp

// LDD for testing atomic operations

// 

//

#include <kernel/kern_priv.h>

#include "t_atomic.h"

class DAtomicTest;

struct TPerThreadK : public TPerThread

	{

	TAny* iOldExtraContext;

	const SSlowExecEntry* iOldSlowExecTable;

	DAtomicTest* iCh;

	TInt iId;

	};

class DAtomicTestFactory : public DLogicalDevice

	{

public:

	DAtomicTestFactory();

	~DAtomicTestFactory();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

public:

	};

class DAtomicTest : public DLogicalChannelBase

	{

public:

	virtual ~DAtomicTest();

protected:

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

private:

	void SetupExecTable();

	static TInt XGetThreadInfo(TAny* aDest);

	static TInt XSetThreadInfo(const TAny* aSrc);

	static TInt XAtomicAction(TAny* aPtr);

	static TInt XRestore();

private:

	TUint64A	iReg;

	TPerThreadK	iPerThread[KMaxThreads];

	TUint32		iXT[19];

	};

DAtomicTestFactory::DAtomicTestFactory()

	{

	}

DAtomicTestFactory::~DAtomicTestFactory()

	{

	}

TInt DAtomicTestFactory::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel = new DAtomicTest;

	return KErrNone;

	}

TInt DAtomicTestFactory::Install()

	{

	return SetName(&KAtomicTestLddName);

	}

void DAtomicTestFactory::GetCaps(TDes8& aDes) const

	{

	// Not used but required as DLogicalDevice::GetCaps is pure virtual

	}

DECLARE_STANDARD_LDD()

	{

	return new DAtomicTestFactory;

	}

TInt DAtomicTest::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

	{

	SetupExecTable();

	return KErrNone;

	}

DAtomicTest::~DAtomicTest()

	{

	}

void DAtomicTest::SetupExecTable()

	{

	NThread* t = NKern::CurrentThread();

	SSlowExecTable& sxt = *(SSlowExecTable*)iXT;

	const SSlowExecTable& orig_sxt = *_LOFF(t->iSlowExecTable, SSlowExecTable, iEntries);

	sxt.iSlowExecCount = 4;		// get thread info, set thread info, atomic action, restore exec table

	sxt.iInvalidExecHandler = orig_sxt.iInvalidExecHandler;

	sxt.iPreprocessHandler = 0;	// not used

	sxt.iEntries[0].iFlags = 0;		// don't do anything special on entry or exit

	sxt.iEntries[0].iFunction = (TLinAddr)&XGetThreadInfo;

	sxt.iEntries[1].iFlags = 0;		// don't do anything special on entry or exit

	sxt.iEntries[1].iFunction = (TLinAddr)&XSetThreadInfo;

	sxt.iEntries[2].iFlags = 0;		// don't do anything special on entry or exit

	sxt.iEntries[2].iFunction = (TLinAddr)&XAtomicAction;

	sxt.iEntries[3].iFlags = 0;		// don't do anything special on entry or exit

	sxt.iEntries[3].iFunction = (TLinAddr)&XRestore;

	}

TInt DAtomicTest::Request(TInt aFunction, TAny* a1, TAny* a2)

	{

	TInt r = KErrNotSupported;

	switch (aFunction)

		{

		case RTestAtomic::ETDGExecuteK:

			{

			TDGBase tdg;

			kumemget32(&tdg, a1, sizeof(tdg));

			r = tdg.Execute();

			kumemput32(a1, &tdg, sizeof(tdg));

			break;

			}

		case RTestAtomic::EInitialise:

			{

			kumemget32(&iReg, a1, sizeof(TUint64));

			break;

			}

		case RTestAtomic::ERetrieve:

			{

			kumemput32(a1, &iReg, sizeof(TUint64));

			break;

			}

		case RTestAtomic::ESetCurrentThreadTimeslice:

			{

			NKern::ThreadSetTimeslice(NKern::CurrentThread(), NKern::TimesliceTicks((TInt)a1));

			r = KErrNone;

			break;

			}

		case RTestAtomic::ESwitchExecTables:

			{

			TUint tid = (TUint)a1;

			NThread* nt = NKern::CurrentThread();

			DThread& t = Kern::CurrentThread();

			if (Kern::NThreadToDThread(nt)==&t && tid<TUint(KMaxThreads))

				{

				TPerThreadK* p = iPerThread + tid;

				p->iOldExtraContext = nt->iExtraContext;

				p->iOldSlowExecTable = nt->iSlowExecTable;

				p->iId = tid;

				p->iCh = this;

				nt->iExtraContext = p;

				SSlowExecTable& sxt = *(SSlowExecTable*)iXT;

				nt->iSlowExecTable = sxt.iEntries;

				r = KErrNone;

				}

			break;

			}

		case RTestAtomic::EGetKernelMemoryAddress:

			{

			r = (TInt)NKern::CurrentThread();	// if we trash this the test should go bang

			break;

			}

		default:

			break;

		}

	return r;

	}

TInt DAtomicTest::XGetThreadInfo(TAny* aDest)

	{

	NThread* t = NKern::CurrentThread();

	TPerThreadK* p = (TPerThreadK*)t->iExtraContext;

	kumemput32(aDest, p, sizeof(TPerThread));

	return KErrNone;

	}

TInt DAtomicTest::XSetThreadInfo(const TAny* aSrc)

	{

	NThread* t = NKern::CurrentThread();

	TPerThreadK* p = (TPerThreadK*)t->iExtraContext;

	kumemget32(p, aSrc, sizeof(TPerThread));

	return KErrNone;

	}

TInt DAtomicTest::XAtomicAction(TAny* aPtr)

	{

	NThread* t = NKern::CurrentThread();

	TPerThreadK* p = (TPerThreadK*)t->iExtraContext;

	TAtomicAction action;

	kumemget32(&action, aPtr, sizeof(TAtomicAction));

	if (action.iThread!=p->iId || TUint(action.iIndex)>=TUint(TOTAL_INDEXES))

		return KErrNotSupported;

	return DoAtomicAction(&p->iCh->iReg, p, action);

	}

TInt DAtomicTest::XRestore()

	{

	NThread* t = NKern::CurrentThread();

	TPerThreadK* p = (TPerThreadK*)t->iExtraContext;

	t->iExtraContext = p->iOldExtraContext;

	t->iSlowExecTable = p->iOldSlowExecTable;

	return KErrNone;

	}