// MemoryAccess.cpp

// 

// Copyright (c) 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

//#include <m32std.h>

#include <nkern.h>

#include <kernel.h>

#include <kern_priv.h>

#include <fshell/common.mmh>

#ifdef FSHELL_DOBJECTIX_SUPPORT

#include "dobject.h" // To pick up my defn of DObjectIx/DObjectIxNinePointOneHack

#endif

#include <e32cmn.h>

#include "memoryaccess.h"

#include "PropertyAccess.h"

#include "fdebuggerkernel.h"

#include "DynamicDfcSupport.h"

//define this to get log output

/*#define DO_LOGGING

#ifdef DO_LOGGING

	#define DO_LOG(X) X

#else

	#define DO_LOG(X)

#endif */

const TInt KLocalBufferSize=4096;

const TInt KMajorVersionNumber=1;

const TInt KMinorVersionNumber=0;

const TInt KBuildVersionNumber=0;

_LIT(KMemAccessPanicCategory,"MemAccess");

enum TMemAccessPanic

	{

	EMemAccessPanicBadContainerType,

	EMemAccessMutexAlreadyHeld,

	EMemAccessMutexNotHeld

	};

class DMemoryAccess;

// DMemoryAccessFactory

//

NONSHARABLE_CLASS(DMemoryAccessFactory) : public DLogicalDevice

    {

public:

    DMemoryAccessFactory();

	~DMemoryAccessFactory();

	TInt GetEventHandler(DDebuggerEventHandler*& aResult);

	TInt GetDfcQue(TDfcQue*& aResult);

private:

    TInt Install();                     //overriding pure virtual

    void GetCaps(TDes8& aDes) const;    //overriding pure virtual

    TInt Create(DLogicalChannelBase*& aChannel);         //overriding pure virtual

	void Lock();

	void Unlock();

private:

	DDebuggerEventHandler* iSharedEventHandler;

	TDynDfcQueWrapper* iDfcQueWrapper;

	NFastMutex iLock;

    };

// DECLARE_STANDARD_LDD

//  Standard Extension Framework export

DECLARE_STANDARD_EXTENSION()

	{

	return KErrNone;

	}

DECLARE_EXTENSION_LDD()

	{

	return new DMemoryAccessFactory();

	}

class DThreadChangeHandler;

class DMsgQueue;

// DMemoryAccess

//

NONSHARABLE_CLASS(DMemoryAccess) : public DLogicalChannel, public MDebuggerEventClient

    {

public:

    DMemoryAccess();

    ~DMemoryAccess();

private:

//Framework

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

	void HandleMsg(TMessageBase* aMsg);

    void DoCancel(TInt aReqNo);

    TInt DoRequest(TInt aReqNo,TRequestStatus aStatus,TAny* a1,TAny* a2);

    TInt DoControl(TInt aFunction,TAny *a1,TAny *a2);

//API

    TInt GetThreadMem(TAny* aParams, TAny* aBuf);

    TInt GetAllocatorAddress(TUint aId, TUint8*& aAddr, TBool aGetCurrentAllocator=EFalse); //TOMSCI If false, get the created allocator. If true, get the current one

	TInt GetContainerCount(const TObjectType aObjectType, TUint& aCount);

	TInt AcquireContainerMutex(const TObjectType aObjectType);

	TInt ReleaseContainerMutex(const TObjectType aObjectType);

	TInt GetObjectType(TUint8* aObjectPtr, TObjectType& aType);

	TInt GetObjectInfo(TObjectType aObjectType, TInt aObjectIndexInContainer, TDes8* aKernelInfoBuf);

	TInt GetObjectInfoByPtr(TObjectType aObjectType, TUint8* aObjectPtr, TDes8* aKernelInfoBuf);

	TInt GetObjectInfoByName(TObjectType aObjectType, const TDesC8& aObjectName, TDes8* aKernelInfoBuf);

	TInt GetObjectInfoByHandle(TObjectType aObjectType, TInt aThreadId, TInt aObjectHandle, TDes8* aKernelInfoBuf);

	TInt GetObjectAddresses(TObjectType aObjectType, const TDesC8& aOwningProcess, TDes8* aKernelInfoBuf);

	TInt GetChunkAddresses(TUint aControllingProcessId, TDes8* aKernelInfoBuf);

	TInt AcquireCodeSegMutex();

	TInt ReleaseCodeSegMutex();

	TInt GetNextCodeSegInfo(TDes8* aCodeSegInfoBuf);

	TInt ObjectDie(TObjectKillParamsBuf& aObjectKillParamsBuf);

	TInt FindPtrInCodeSegments(TAny* aDllNamePtr, TAny* aPtr);

	TInt GetHandleOwners(TAny* aObj, TAny* aOwnersBuf);

	TInt GetThreadHandles(TInt aThreadId, TAny* aHandlesBuf);

	TInt GetProcessHandles(TInt aProcessId, TAny* aHandlesBuf);

	TInt SetThreadPriority(TInt aThreadHandle, TInt aPriority);

	void NotifyThreadCreation(TRequestStatus* aStatus);

	void CancelNotifyThreadCreation();

	TInt SetPriorityOverride(TInt aPriority, TAny* aMatchString);

	TInt SetCriticalFlags(TInt aThreadHandle, TUint aFlags);

	TInt OpenThread(TUint aTid);

//Helpers

	void GetObjectInfo(DObject* aObject, TObjectKernelInfo& aInfo);

	TInt GetObjectPositionInContainer(TUint8* aObjectPtr, DObjectCon& aContainer, TInt& aPosInContainer);

	TInt GetThreadInfo(DThread* aThread, TDes8* aThreadInfoBuf);

	TInt GetProcessInfo(DProcess* aProcess, TDes8* aProcessInfoBuf);

	TInt GetChunkInfo(DChunk* aChunk, TDes8* aChunkInfoBuf);

	TInt GetLibraryInfo(DLibrary* aLibrary, TDes8* aLibraryInfoBuf);

	TInt GetSemaphoreInfo(DSemaphore* aSemaphore, TDes8* aLibraryInfoBuf);

	TInt GetMutexInfo(DMutex* aMutex, TDes8* aLibraryInfoBuf);

	TInt GetTimerInfo(DTimer* aTimer, TDes8* aTimerInfoBuf);

	TInt GetServerInfo(DServer* aServer, TDes8* aServerInfoBuf);

	TInt GetSessionInfo(DSession* aSession, TDes8* aSessionInfoBuf);

	TInt GetLogicalDeviceInfo(DLogicalDevice* aLogicalDevice, TDes8* aLogicalDeviceInfoBuf);

	TInt GetPhysicalDeviceInfo(DPhysicalDevice* aPhysicalDevice, TDes8* aPhysicalDeviceInfoBuf);

	TInt GetLogicalChannelInfo(DLogicalChannel* aLogicalChannel, TDes8* aLogicalChannelInfoBuf);

	TInt GetChangeNotifierInfo(DChangeNotifier* aChangeNotifier, TDes8* aChangeNotifierInfoBuf);

	TInt GetUndertakerInfo(DUndertaker* aUndertaker, TDes8* aUndertakerInfoBuf);

	TInt GetMsgQueueInfo(DMsgQueue* aMsgQueue, TDes8* aMsgQueueInfoBuf);

//	TInt GetPropertyRefInfo(DPropertyRef* aPropertyRef, TDes8* aPropertyRefInfoBuf);

	TInt GetCondVarInfo(DCondVar* aCondVar, TDes8* aCondVarInfoBuf);

	TInt InPlaceObjectRename(TAny* aParamsBuf, TAny* aNewNamePtr);

	TInt InPlaceSetProcessFileName(TAny* aParamsBuf, TAny* aNewNamePtr);

	TLinAddr DoGetAllocatorAddress(DThread* aThread, TBool aGetCurrent);

	TInt EnableHeapTracing(TUint aThreadId, TBool aEnable);

	TInt DefragRam(TInt aPriority);

	TInt EmptyRamZone(TInt aPriority, TUint aZone);

	TInt GetRamZoneInfo(TUint aZone, TAny* aInfoPkg);

	TInt SetProcessProperties(TInt aProcessHandle, TAny* aProperties);

	TInt WriteShadowMemory(TLinAddr aAddress, TAny* aNewContents);

	TInt FreeShadowMemory(TLinAddr aAddress, TInt aLength);

	TInt DebuggerFn(TInt aFn, TAny* a1, TAny* a2);

	TInt GetRegisters(TAny* a1, TAny* /*a2*/);

	DThread* ThreadFromHandle(TInt aHandle);

private: // From MDebuggerEventClient

	void BreakpointHit(TDes& aPkg);

private:

	DThread* iClient;

	TBool iLocks[ENumObjectTypes];

	TBool iCodeSegLock;

	DCodeSeg* iCurrentCodeSeg;

	DThreadChangeHandler* iEventHandler;

	DPropertyAccess* iPropertyAccess;

	TAny* iClientBreakpointNotifyPkg;

	TRequestStatus* iClientBreakpointNotifyStatus;

	};

NONSHARABLE_CLASS(DThreadChangeHandler) : public DKernelEventHandler

	{

public:

	DThreadChangeHandler(DThread* aClientThread);

	~DThreadChangeHandler();

	static TUint Event(TKernelEvent aEvent, TAny* a1, TAny* a2, TAny* aPrivateData);

	TUint DoEvent(TKernelEvent aEvent, TAny* a1, TAny* a2);

	void SetStatus(TRequestStatus* aStatus);

private:

	DThread* iThread;

	TRequestStatus* iStatus;

public:

	TBuf8<256> iMatch;

	TInt iPriorityToSet;

	};

// class DMemoryAccessFactory Implementation

//

//

DMemoryAccessFactory::DMemoryAccessFactory()

	{

    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

	}

// DMemoryAccessFactory::Create

//

TInt DMemoryAccessFactory::Create(DLogicalChannelBase*& aChannel)

    {

    aChannel=new DMemoryAccess();

	if (aChannel==NULL)

		return KErrNoMemory;

	else

		return KErrNone;

    }

// DMemoryAccessFactory::Install

//

TInt DMemoryAccessFactory::Install()

    {

    TInt err = SetName(&KMemoryAccessName);

	if (err == KErrNone)

		{

		DDebuggerEventHandler* dontCare;

		err = GetEventHandler(dontCare); // We call this to make sure the event handler is always running, so we can track creator info asap

		}

	return err;

    }

// DMemoryAccessFactory::GetCaps

//

void DMemoryAccessFactory::GetCaps(TDes8& /*aDes*/) const

    {

/*    TCapsMemoryAccessV01 b;

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

    aDes.FillZ(aDes.MaxLength());

    aDes.Copy((TUint8*)&b,Min(aDes.MaxLength(),sizeof(b)));

*/    } 

// class DMemoryAccess Implementation

// Ctor

//

DMemoryAccess::DMemoryAccess()

    : DLogicalChannel()

    {

    //SetBehaviour(-1); //JR

    }

const TInt KMemAccessDfcThreadPriority = 27;

// DMemoryAccess::DoCreate

//  Check capabilities & version & start listening for events

TInt DMemoryAccess::DoCreate(TInt /*aUnit*/,const TDesC* /*anInfo*/,const TVersion& aVer)

    {

	TInt ret=KErrNone;

	//Require Power Management to use this driver

	//Not ideal, but better than nothing

	//if(!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt,__PLATSEC_DIAGNOSTIC_STRING("Checked by MEMORYACCESS.LDD (Memory Access for Task Managers)")))

	//    return KErrPermissionDenied;

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

    	{

    	return KErrNotSupported;

    	}

    iClient=&Kern::CurrentThread();

	iClient->Open();

	TDfcQue* q = NULL;

	ret = ((DMemoryAccessFactory*)iDevice)->GetDfcQue(q);

	if (ret == KErrNone)

		{

    	SetDfcQ(q);

    	iMsgQ.Receive();		

		}

    return ret;

    }

TInt DMemoryAccessFactory::GetDfcQue(TDfcQue*& aQue)

	{

	Lock();

	if (iDfcQueWrapper)

		{

		aQue = iDfcQueWrapper->Que();

		Unlock();

		return KErrNone;

		}

	Unlock(); // Can't hold a fast mutex around DFC q creation

	TDynDfcQueWrapper* wrapper = NULL;

	_LIT(KDfcThreadName, "MemoryAccess-fshell");

	TInt ret = TDynDfcQueWrapper::Create(wrapper, KMemAccessDfcThreadPriority, KDfcThreadName);

	if (ret == KErrNone)

		{

		Lock();

		if (iDfcQueWrapper)

			{

			// Someone beat us to it while we weren't holding the lock

			aQue = iDfcQueWrapper->Que();

			Unlock();

			wrapper->Destroy();

			}

		else

			{

			iDfcQueWrapper = wrapper;

			aQue = iDfcQueWrapper->Que();

			Unlock();

			}

		}

	return ret;

	}

// dtor

//

DMemoryAccess::~DMemoryAccess()

    {

    //Clean up any mutexes that have been left open

	DObjectCon* const * cons = Kern::Containers();

    for (TInt ii=0;ii<ENumObjectTypes;++ii)

    	{

    	if (iLocks[ii])

    		{

			DObjectCon* container = cons[ii];

			container->Signal();

    		}

    	}

	DMutex* const codeSegLock = Kern::CodeSegLock();

    if (iCodeSegLock && codeSegLock)

		{

		Kern::MutexSignal(*codeSegLock);

		}

	if (iClientBreakpointNotifyStatus)

		{

		// Hmm I'm sure there are some threading subtleties here that I'm missing

		DDebuggerEventHandler* handler = NULL;

		TInt err = ((DMemoryAccessFactory*)iDevice)->GetEventHandler(handler);

		if (!err) handler->UnregisterForBreakpointNotification(this);

		Kern::RequestComplete(iClient, iClientBreakpointNotifyStatus, KErrCancel);

		}

	if (iEventHandler)

		{

		NKern::ThreadEnterCS();

		iEventHandler->Close();

		NKern::ThreadLeaveCS();

		}

	delete iPropertyAccess;

	if (iClient)

		{

		iClient->Close(NULL);

		}

	}

// DMemoryAccess::HandleMsg

//  Called when user side sends us something

void DMemoryAccess::HandleMsg(TMessageBase* aMsg)

	{

    TThreadMessage& m=*(TThreadMessage*)aMsg;

    // Get message type

    TInt id=m.iValue;

    // Decode the message type and dispatch it to the relevent handler function...

    // A logical channel can be closed either explicitly by its user-side client,

    // or implicitly if the client thread dies. In the latter case, the channel

    // is closed in the context of the kernel supervisor thread. 

    if (id==(TInt)ECloseMsg)

        {

        // Channel Close

		// We don't actually have any async requests

        //DoCancel(RMemoryAccess::EAllRequests); //JR

        m.Complete(KErrNone, EFalse);

        return;

        }

    // For all other message types, we check that the message is from the thread

    // that created us.

    if(m.Client()!=iClient)

        {

        Kern::ThreadKill(m.Client(),EExitPanic,ERequestFromWrongThread,KMemAccessPanicCategory);

        m.Complete(KErrNone,ETrue);

        return;

        }

    if (id==KMaxTInt)

        {

        // DoCancel

        DoCancel(m.Int0());

        m.Complete(KErrNone,ETrue);

        return;

        }

    if (id<0)

        {

        // DoRequest

        TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

        TInt r=DoRequest(~id, *pS, m.Ptr1(), m.Ptr2());

        if (r!=KErrNone)

            Kern::RequestComplete(iClient,pS,r);

        m.Complete(KErrNone,ETrue);

        }

    else

        {

        // DoControl

        TInt r=DoControl(id,m.Ptr0(),m.Ptr1());

        m.Complete(r,ETrue);

        }	

	}

// DMemoryAccess::DoRequest

//  Handles async messages, called from HandleMsg

TInt DMemoryAccess::DoRequest(TInt /*aReqNo*/, TRequestStatus /*aStatus*/, TAny* /*a1*/, TAny* /*a2*/)

    {

    return KErrNone;

    }

// DMemoryAccess::DoCancel

//  Cancels async messages, called from HandleMsg

void DMemoryAccess::DoCancel(TInt /*aReqNo*/)

    {

    }

// DMemoryAccess::DoControl

//  Handles sync messages, called from HandleMsg

TInt DMemoryAccess::DoControl(TInt aFunction, TAny* a1, TAny* a2)

    {

	// Kern::Printf("[DMemoryAccess] ::DoControl; Function: %d", aFunction);

    switch (aFunction)

        {

    case RMemoryAccess::EControlGetThreadMem:

        return GetThreadMem(a1, a2);

    case RMemoryAccess::EControlGetAllocatorAddress:

        return GetAllocatorAddress((TUint)a1, *(TUint8**)a2);

    case RMemoryAccess::EControlGetCurrentAllocatorAddress:

        return GetAllocatorAddress((TUint)a1, *(TUint8**)a2, ETrue);

    case RMemoryAccess::EControlFindPtrInCodeSegments:

		return FindPtrInCodeSegments(a1, a2);

    case RMemoryAccess::EControlGetHandleOwners:

		return GetHandleOwners(a1, a2);

    case RMemoryAccess::EControlGetThreadHandles:

		return GetThreadHandles((TUint)a1, a2);

    case RMemoryAccess::EControlGetProcessHandles:

		return GetProcessHandles((TUint)a1, a2);

	case RMemoryAccess::EControlForceCrash:

		Kern::Fault("ForceCrash-QR3", 0);

		return KErrNone;

	case RMemoryAccess::EControlReboot:

		Kern::Restart((TInt)a1);

		return KErrNone;

	case RMemoryAccess::EControlGetPropertyInt:

	case RMemoryAccess::EControlGetPropertyDesc:

	case RMemoryAccess::EControlSetPropertyInt:

	case RMemoryAccess::EControlSetPropertyDesc:

	case RMemoryAccess::EControlDeleteProperty:

	case RMemoryAccess::EControlPropertyNotify:

	case RMemoryAccess::EControlPropertyNotifyCancel:

	case RMemoryAccess::EControlSubscribeToProperty:

		if (!iPropertyAccess)

			{

			iPropertyAccess = new DPropertyAccess(iClient);

			}

		if (!iPropertyAccess) return KErrNoMemory;

		return iPropertyAccess->HandleProperty(aFunction, a1, a2);

	case RMemoryAccess::EControlSetThreadPriority:

		return SetThreadPriority((TInt)a1, (TInt)a2);

	case RMemoryAccess::EControlNotifyThreadCreation:

		NotifyThreadCreation((TRequestStatus*)a1);

		return KErrNone;

	case RMemoryAccess::EControlCancelNotifyThreadCreation:

		CancelNotifyThreadCreation();

		return KErrNone;

	case RMemoryAccess::EControlSetPriorityOverride:

		return SetPriorityOverride((TInt)a1, a2);

	case RMemoryAccess::EControlSetCriticalFlags:

		return SetCriticalFlags((TInt)a1, (TUint)a2);

	case RMemoryAccess::EControlInPlaceThreadRename:

		{

		DThread* thread = ThreadFromHandle((TInt)a1);

		if (!thread) return 0;

		TBuf<64> buf;

		TInt err = Kern::ThreadDesRead(iClient, a2, buf, 0);

		if (err)

			{

			thread->Close(NULL);

			return err;

			}

		thread->iName->Copy(buf);

		TLinAddr addr = (TLinAddr)thread->iName;

		thread->Close(NULL);

		return addr;

		}

	case RMemoryAccess::EControlInPlaceObjectRename:

		return InPlaceObjectRename(a1, a2);

	case RMemoryAccess::EControlInPlaceSetProcessFileName:

		return InPlaceSetProcessFileName(a1, a2);

	case RMemoryAccess::EControlOpenThread:

		return OpenThread((TUint)a1);

    case RMemoryAccess::EControlResetTimer:

        return KErrNone;

	case RMemoryAccess::EControlGetContainerCount:

		return GetContainerCount(*(TObjectType*)&a1, *(TUint*)a2);

	case RMemoryAccess::EControlAcquireContainerMutex:

		return AcquireContainerMutex(*(TObjectType*)&a1);

	case RMemoryAccess::EControlReleaseContainerMutex:

		return ReleaseContainerMutex(*(TObjectType*)&a1);

    case RMemoryAccess::EControlGetObjectType:

    	return GetObjectType((TUint8*)a1, *(TObjectType*)a2);

    case RMemoryAccess::EControlGetObjectInfo:

		{

		TObjectInfoByIndexParamsBuf params;

		TInt err = Kern::ThreadDesRead(iClient,a1,params,0);

		if (err == KErrNone)