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

 // f32test\loader\d_ldrtst.cpp

 // LDD for testing loader

 // 

 //

 #include <kernel/kern_priv.h>

 #include "d_ldrtst.h"

 const TInt KMajorVersionNumber=0;

 const TInt KMinorVersionNumber=1;

 const TInt KBuildVersionNumber=1;

 class DLdrTest;

 class DLdrTestFactory : public DLogicalDevice

 //

 // Test LDD factory

 //

 	{

 public:

 	DLdrTestFactory();

 	virtual TInt Install();

 	virtual void GetCaps(TDes8& aDes) const;

 	virtual TInt Create(DLogicalChannelBase*& aChannel);

 	};

 class DLdrTest : public DLogicalChannelBase

 //

 // Test logical channel

 //

 	{

 public:

 	virtual ~DLdrTest();

 protected:

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

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

 public:

 	TInt GetCodeSegInfo(TAny* aHandle, TAny* aDest);

 	TAny* ModuleCodeSeg(TModuleHandle aModuleHandle);

 	TAny* ProcessCodeSeg(TInt aProcessHandle);

 	TAny* LibraryCodeSeg(TInt aLibraryHandle);

 	TInt GetCodeSegList(RLdrTest::SEntry* aList, TInt aMax);

 	TAny* CodeSegFromAddr(TLinAddr aAddr);

 	TModuleHandle ModuleHandleFromAddr(TLinAddr aAddr);

 	TInt ProcessSMPUnsafeCount(TInt aProcessHandle);

 private:

 	SDblQueLink* FindCodeSegQueueAnchor();

 	};

 DECLARE_STANDARD_LDD()

 	{

 	return new DLdrTestFactory;

 	}

 DLdrTestFactory::DLdrTestFactory()

 //

 // Constructor

 //

 	{

 	iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

 	}

 TInt DLdrTestFactory::Create(DLogicalChannelBase*& aChannel)

 //

 // Create a new DLdrTest on this logical device

 //

 	{

 	aChannel=new DLdrTest;

 	return aChannel?KErrNone:KErrNoMemory;

 	}

 TInt DLdrTestFactory::Install()

 //

 // Install the LDD - overriding pure virtual

 //

 	{

 	return SetName(&KLdrTestLddName);

 	}

 void DLdrTestFactory::GetCaps(TDes8& aDes) const

 //

 // Get capabilities - overriding pure virtual

 //

 	{

 	TCapsTestV01 b;

 	b.iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

     Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));

 	}

 TInt DLdrTest::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)

 //

 // Create channel

 //

 	{

 	if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))

 		return KErrNotSupported;

 	return KErrNone;

 	}

 DLdrTest::~DLdrTest()

 //

 // Destructor

 //

 	{

 	}

 TInt DLdrTest::GetCodeSegInfo(TAny* aHandle, TAny* aDest)

 	{

 	TCodeSegCreateInfo info;

 	DCodeSeg* pS=DCodeSeg::VerifyHandle(aHandle);

 	if (pS)

 		{

 		Kern::AccessCode();

 		pS->Info(info);

 		Kern::EndAccessCode();

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

 		return KErrNone;

 		}

 	return KErrArgument;

 	}

 TAny* DLdrTest::ModuleCodeSeg(TModuleHandle aModuleHandle)

 	{

 	DCodeSeg* pS=DCodeSeg::VerifyHandle(aModuleHandle);

 	if(!pS)

 		{

 		Kern::AccessCode();

 		DCodeSeg::CodeSegFromEntryPoint((TLinAddr)aModuleHandle);  // ignore returned DCodeSeg*

 		Kern::EndAccessCode();

 		}

 	return pS;

 	}

 TAny* DLdrTest::CodeSegFromAddr(TLinAddr aAddr)

 	{

 	Kern::AccessCode();

 	DCodeSeg* s = Kern::CodeSegFromAddress(aAddr, Kern::CurrentThread().iOwningProcess);

 	Kern::EndAccessCode();

 	return s;

 	}

 TModuleHandle DLdrTest::ModuleHandleFromAddr(TLinAddr aAddr)

 	{

 	TModuleHandle h = (TModuleHandle)CodeSegFromAddr(aAddr);

 	if(!h)

 		h = (TModuleHandle)aAddr;

 	return h;

 	}

 TAny* DLdrTest::ProcessCodeSeg(TInt aProcessHandle)

 	{

 	DCodeSeg* pS=NULL;

 	DThread& t=Kern::CurrentThread();

 	NKern::LockSystem();

 	DProcess* pP=(DProcess*)t.ObjectFromHandle(aProcessHandle, EProcess);

 	if (pP)

 		{

 		pS=pP->iCodeSeg;

 		if (!pS)

 			pS=pP->iTempCodeSeg;

 		}

 	NKern::UnlockSystem();

 	return pS;

 	}

 TAny* DLdrTest::LibraryCodeSeg(TInt aLibraryHandle)

 	{

 	DCodeSeg* pS=NULL;

 	DThread& t=Kern::CurrentThread();

 	NKern::LockSystem();

 	DLibrary* pL=(DLibrary*)t.ObjectFromHandle(aLibraryHandle, ELibrary);

 	if (pL)

 		pS=pL->iCodeSeg;

 	NKern::UnlockSystem();

 	return pS;

 	}

 SDblQueLink* DLdrTest::FindCodeSegQueueAnchor()

 	{

 	SDblQueLink* p=&iDevice->iCodeSeg->iLink;	// this device driver's code segment

 	for (;;)

 		{

 		p=p->iPrev;

 		DCodeSeg* s=_LOFF(p, DCodeSeg, iLink);

 		if (s->iExeCodeSeg==s && (s->iAttr & ECodeSegAttKernel))

 			{

 			// s is the kernel's code segment, which is the first one to be created

 			return s->iLink.iPrev;

 			}

 		}

 	}

 TInt DLdrTest::GetCodeSegList(RLdrTest::SEntry* aList, TInt aMax)

 	{

 	if (aMax<=0)

 		return KErrArgument;

 	RLdrTest::SEntry list[128];

 	Kern::AccessCode();

 	SDblQueLink* anchor=FindCodeSegQueueAnchor();

 	SDblQueLink* p=anchor->iNext;

 	if (aMax>128)

 		aMax=128;

 	TInt n=0;

 	for(; p!=anchor && n<aMax; p=p->iNext, ++n)

 		{

 		DCodeSeg* s=_LOFF(p, DCodeSeg, iLink);

 		list[n].iHandle=s;

 		list[n].iUid3=(TUint32)s->iUids.iUid[2].iUid;

 		}

 	Kern::EndAccessCode();

 	if (n>0)

 		kumemput32(aList, list, n*sizeof(RLdrTest::SEntry));

 	return n;

 	}

 TInt DLdrTest::ProcessSMPUnsafeCount(TInt aProcessHandle)

 	{

 	TInt count=KErrNotFound;

 	DThread& t=Kern::CurrentThread();

 	NKern::LockSystem();

 	DProcess* pP=(DProcess*)t.ObjectFromHandle(aProcessHandle, EProcess);

 	if (pP)

 		count=pP->iSMPUnsafeCount;

 	NKern::UnlockSystem();

 	return count;

 	}

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

 	{

 	TInt r=KErrNone;

 	switch (aFunction)

 		{

 		case RLdrTest::EControlGetCodeSegInfo:

 			r=GetCodeSegInfo(a1,a2);

  			break;

 		case RLdrTest::EControlProcessCodeSeg:

 			r=(TInt)ProcessCodeSeg((TInt)a1);

  			break;

 		case RLdrTest::EControlLibraryCodeSeg:

 			r=(TInt)LibraryCodeSeg((TInt)a1);

  			break;

 		case RLdrTest::EControlModuleCodeSeg:

 			r=(TInt)ModuleCodeSeg((TModuleHandle)a1);

  			break;

 		case RLdrTest::EControlGetCodeSegList:

 			r=GetCodeSegList( (RLdrTest::SEntry*)a1, (TInt)a2 );

 			break;

 		case RLdrTest::EControlCodeSegFromAddr:

 			r=(TInt)CodeSegFromAddr((TLinAddr)a1);

  			break;

 		case RLdrTest::EControlModuleHandleFromAddr:

 			r=(TInt)ModuleHandleFromAddr((TLinAddr)a1);

  			break;

 		case RLdrTest::EControlProcessSMPUnsafeCount:

 			r=ProcessSMPUnsafeCount((TInt)a1);

 			break;

 		default:

 			r=KErrNotSupported;

 			break;

 		}

 	return r;

 	}