// memoryaccess.h

// 

// 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

//

#ifndef __MemoryAccess_H__

#define __MemoryAccess_H__

#ifndef __KERNEL_MODE__

#include <e32std.h>

#endif

#include <u32std.h>

_LIT(KMemoryAccessName,"memoryAccess-fshell");

typedef TBuf8<KMaxFullName> TFullName8;

typedef TBuf8<KMaxFileName> TFileName8;

//size of buffer used for returning queues

const TInt KQueBufferLength = 1024; 

//Buffer used to pass pointer arrays, of pointers to kernel side objects

class TPointerArrayBuffer

	{

public:

	TUint8* iBuffer[KQueBufferLength];  //buffer holding up to KQueBufferLength items of the array or queue

	TUint iStartFrom; //the point in the array to start from

	TUint iCount; //the total number of entries written into iBuffer.  If KMaxTInt, there are more available

	};

//

//Structures used for communication with driver

//

class RProcess;

class TObjectInfoByIndexParams

	{

public:

	TObjectType iObjectType;

	TUint iObjectIndex;

	};

typedef TPckgBuf<TObjectInfoByIndexParams> TObjectInfoByIndexParamsBuf;

class TObjectInfoByPtrParams

	{

public:

	TObjectType iObjectType;

	TUint8* iObjectPtr;	

	};

typedef TPckgBuf<TObjectInfoByPtrParams> TObjectInfoByPtrParamsBuf;

class TObjectInfoByNameParams

	{

public:

	TObjectType iObjectType;

	TBuf8<KMaxFullName> iObjectName;

	};

typedef TPckgBuf<TObjectInfoByNameParams> TObjectInfoByNameParamsBuf;

class TObjectInfoByHandleParams

	{

public:

	TObjectType iObjectType;

	TInt iThreadId;	

	TInt iObjectHandle;	

	};

typedef TPckgBuf<TObjectInfoByHandleParams> TObjectInfoByHandleParamsBuf;

class TThreadMemoryAccessParams

	{

public:

	TUint iId;

	const TUint8* iAddr;

	TInt iSize;

	};

typedef TPckgBuf<TThreadMemoryAccessParams> TThreadMemoryAccessParamsBuf;

class TObjectKillParams

	{

public:

	TObjectType iObjectType;

	TUint iObjectId;

	TUint8* iObjectPtr;	

	TExitType iType;

	TInt iReason;

	TFullName8 iCategory;

	};

typedef TPckgBuf<TObjectKillParams> TObjectKillParamsBuf;

class TGetObjectAddressesParams

	{

public:

	TObjectType iObjectType;

	TFullName8 iOwningProcess;

	};

typedef TPckgBuf<TGetObjectAddressesParams> TGetObjectAddressesParamsBuf;

class TGetChunkAddressesParams

	{

public:

	TUint iControllingProcessId;

	};

typedef TPckgBuf<TGetChunkAddressesParams> TGetChunkAddressesParamsBuf;

class TObjectKernelInfo

	{

public:

	TUint8* iAddressOfKernelObject;

	TFullName8 iName;

	TFullName8 iFullName;

	TInt iAccessCount;

	TInt iUniqueID;

	TUint iProtection;

	TUint8* iAddressOfKernelOwner;

	};

typedef TPckgBuf<TObjectKernelInfo> TObjectKernelInfoBuf;

class TThreadKernelInfo : public TObjectKernelInfo

	{

public:

	TUint iThreadId;

	TUint8* iAddressOfOwningProcess;

	TInt iThreadPriority;

	TInt iUserStackSize;

	TUint32 iFlags;

	TLinAddr iSupervisorStack;

	TInt iSupervisorStackSize;

	TLinAddr iUserStackLimit;

	TInt iNThreadSuspendCount;

	inline TLinAddr UserStackBase() const { return iUserStackLimit + iUserStackSize; }

	};

typedef TPckgBuf<TThreadKernelInfo> TThreadKernelInfoBuf;

const TInt KNumEnvironmentSlots = 16;

class TProcessKernelInfo : public TObjectKernelInfo

	{ 

public:

	TUint iProcessId;

	TInt iPriority;

	TUint8* iAddressOfOwningProcess;

	TUint iCreatorId;

	TUint iSecurityZone;

	TUidType iUids;

	TInt iAttributes;

	TUint8* iAddressOfDataBssStackChunk;

	TPointerArrayBuffer iThreadQ;

	SSecurityInfo iProcessSecurityInfo;

	SSecurityInfo iProcessCreatorSecurityInfo;

	TBuf8<256> iCommandLine;

	TUint32 iFlags;

	TInt iEnvironmentData[KNumEnvironmentSlots];

	TUint iFirstThreadId;

	};

typedef TPckgBuf<TProcessKernelInfo> TProcessKernelInfoBuf;	 

class TChunkKernelInfo : public TObjectKernelInfo

	{ 

public:

	TInt iSize;

	TInt iMaxSize;

	TUint8* iBase;

	TInt iBottom;

	TInt iTop;

	TInt iAttributes;

	TInt iStartPos;

	TUint iControllingOwnerProcessId;

	TUint iRestrictions;

	TUint iMapAttr;

	TUint iChunkType;

	TUint8* iAddressOfOwningProcess;

	};

typedef TPckgBuf<TChunkKernelInfo> TChunkKernelInfoBuf;	 

class TLibraryKernelInfo : public TObjectKernelInfo

	{

public:

	TInt iMapCount;

	TUint8 iState;

	TUint8* iAddressOfCodeSeg;

	};

typedef TPckgBuf<TLibraryKernelInfo> TLibraryKernelInfoBuf;	 

class TSemaphoreKernelInfo : public TObjectKernelInfo

	{ 

public:

	TInt iCount;

	TUint8 iResetting;

	TPointerArrayBuffer iSuspendedQ;

	};

typedef TPckgBuf<TSemaphoreKernelInfo> TSemaphoreKernelInfoBuf;	 

class TMutexKernelInfo : public TObjectKernelInfo

	{

public:

	TInt iHoldCount;

	TInt iWaitCount;

	TUint8 iResetting;

	TUint8 iOrder;

	TPointerArrayBuffer iSuspendedQ;

	TPointerArrayBuffer iPendingQ;

	};

typedef TPckgBuf<TMutexKernelInfo> TMutexKernelInfoBuf;	 

class TTimerKernelInfo : public TObjectKernelInfo

	{

public:

	TUint8 iState;

	TUint8 iType;

	TLinAddr iClientStatus;

	};

typedef TPckgBuf<TTimerKernelInfo> TTimerKernelInfoBuf;	 

class TServerKernelInfo : public TObjectKernelInfo

	{

public:

	TUint8*	iAddressOfOwningThread;

	TUint8 iSessionType;

	TPointerArrayBuffer iSessionQ;

	TUint iOwningThreadId;

	};

typedef TPckgBuf<TServerKernelInfo> TServerKernelInfoBuf;	 

class TSessionKernelInfo : public TObjectKernelInfo

	{ 

public:

	TUint8*	iServer;

	TAny* 	iSessionPtr;

	TUint16	iTotalAccessCount;

	TUint8 iSessionType;

	TUint8 iSvrSessionType;

	TInt iMsgCount;

	TInt iMsgLimit;

	};

typedef TPckgBuf<TSessionKernelInfo> TSessionKernelInfoBuf;	 

class TLogicalDeviceKernelInfo : public TObjectKernelInfo

	{

public:

	TVersion iVersion;

	TUint iParseMask;

	TUint iUnitsMask;

	TInt iOpenChannels;

	};

typedef TPckgBuf<TLogicalDeviceKernelInfo> TLogicalDeviceKernelInfoBuf;	 

class TPhysicalDeviceKernelInfo : public TObjectKernelInfo

	{ 

public:

	TVersion iVersion;

	TUint iUnitsMask;

	TUint8* iAddressOfCodeSeg;

	};

typedef TPckgBuf<TPhysicalDeviceKernelInfo> TPhysicalDeviceKernelInfoBuf;	 

class TLogicalChannelKernelInfo : public TObjectKernelInfo

	{

public:

	};

typedef TPckgBuf<TLogicalChannelKernelInfo> TLogicalChannelKernelInfoBuf;	 

class TChangeNotifierKernelInfo : public TObjectKernelInfo

	{

public:

	TUint iChanges;

	TUint8* iAddressOfThread;

	};

typedef TPckgBuf<TChangeNotifierKernelInfo> TChangeNotifierKernelInfoBuf;	 

class TUndertakerKernelInfo : public TObjectKernelInfo

	{

public:

	TUint8* iOwningThread;

	};

typedef TPckgBuf<TUndertakerKernelInfo> TUndertakerKernelInfoBuf;	 

class TMsgQueueKernelInfo : public TObjectKernelInfo

	{

public:

	TUint iMaxMsgLength;

	};

typedef TPckgBuf<TMsgQueueKernelInfo> TMsgQueueKernelInfoBuf;	 

class TPropertyRefKernelInfo : public TObjectKernelInfo

	{

public:

	};

typedef TPckgBuf<TPropertyRefKernelInfo> TPropertyRefKernelInfoBuf;	 

class TCondVarKernelInfo : public TObjectKernelInfo

	{

public:

	TUint8 iResetting;

	TUint8* iAddressOfMutex;

	TInt iWaitCount;

	TPointerArrayBuffer iSuspendedQ;

	};

typedef TPckgBuf<TCondVarKernelInfo> TCondVarKernelInfoBuf;	 

class TCodeSegKernelInfoBase

	{

public:

	TUint32 iRunAddress;

	TInt iSize;

	TFileName8 iFileName;

	};

// We don't really need a base class, it's just for BC reasons 

class TCodeSegKernelInfo : public TCodeSegKernelInfoBase

	{

public:

	TUint8* iAddressOfKernelObject;

	TFullName8 iName;

	TInt iAccessCount;

	TInt iDepCount;

	TBool iXip;

	};

typedef TPckgBuf<TCodeSegKernelInfo> TCodeSegKernelInfoBuf;	 

class TProp

	{

public:

	TUid iCategory;

	TUint iKey;

	TInt iActualSize; // Return value, only used when getting a descriptor property

	TBool iDefine;

	};

class TPropNotifyResult

	{

public:

	TUint iCategory;

	TUint iKey;

	TInt iMissedChanges;

	TInt iError;

	};

class TRamZoneInfo

	{

public:

	TUint iFreePages;

	TUint iUnknownPages;

	TUint iFixedPages;

	TUint iMovablePages;

	TUint iDiscardablePages;

	};

class TProcessProperties

	{

public:

	TProcessProperties() : iSid(0xFFFFFFFFu), iVid(0xFFFFFFFFu), /*iHeapMin(0), iHeapMax(0), iStackSize(0),*/ iProcessPriority(0)

		{

		iCapsToAdd.SetEmpty();

		iCapsToRemove.SetEmpty();

		}

	TCapabilitySet iCapsToAdd;

	TCapabilitySet iCapsToRemove;

	TUint iSid;

	TUint iVid;

	//TUint iHeapMin;

	//TUint iHeapMax;

	//TUint iStackSize;

	TInt iProcessPriority;

	};

// class RMemoryAccess

//  User side communication interface to Memory Access driver.

//  Provides access to arbitrary kernel objects, memory, and some basic object manipulation.

//  For use in debugging tools only!  Do not include in a release ROM.

class RMemoryAccess : public RBusLogicalChannel

	{

public:

	enum TControl

		{

		EControlGetThreadMem,

		EControlGetAllocatorAddress,

		EControlResetTimer,

		EControlGetContainerCount,

		EControlAcquireContainerMutex,

		EControlReleaseContainerMutex,

		EControlGetObjectType,

		EControlGetObjectInfo,

		EControlGetObjectInfoByPtr,

		EControlGetObjectInfoByHandle,

		EControlAcquireCodeSegMutex,

		EControlReleaseCodeSegMutex,

		EControlGetNextCodeSegInfo,

		EControlObjectDie,

		EControlGetObjectInfoByName,

		EControlGetObjectAddresses,

		EControlGetChunkAddresses,

		EControlGetCurrentAllocatorAddress,

		EControlFindPtrInCodeSegments,

		EControlGetHandleOwners,

		EControlForceCrash,

		EControlGetPropertyInt,

		EControlGetPropertyDesc,

		EControlSetPropertyInt,

		EControlSetPropertyDesc,

		EControlDeleteProperty,

		EControlSetThreadPriority,

		EControlNotifyThreadCreation,

		EControlCancelNotifyThreadCreation,

		EControlSetPriorityOverride,

		EControlSetCriticalFlags,

		EControlOpenThread,

		EControlGetThreadHandles,

		EControlGetProcessHandles,

		EControlInPlaceThreadRename,

		ERemoved1, //EControlGetBinaryPropertyKernelLocation

		EControlInPlaceObjectRename,

		EControlInPlaceSetProcessFileName,

		ERemoved2, //EControlGetAllProperties,

		ERemoved3, //EControlSetupMassPropertyNotify,

		ERemoved4, //EControlMassPropertyNotifyStart,

		ERemoved5, //EControlMassPropertyNotifyStop,

		EControlEnableHeapTracing,

		EControlDefragRam,

		EControlEmptyRamZone,

		EControlGetRamZoneInfo,

		EControlSetProcessProperties,

		EControlWriteShadowMemory,

		EControlFreeShadowMemory,

		EControlSetZombieDebugMode,

		EControlWriteMem,

		EControlSetTextTraceMode,

		EControlGetRegisters,

		EControlGetZombies,

		EControlGetZombieDebugMode,

		EControlReleaseZombie,

		EControlSuspendThread,

		EControlNotifyBreakpoint,

		EControlSetBreakpoint,

		EControlSetBreakpointEnabled,

		EControlClearBreakpoint,

		EControlContinueFromBreakpoint,

		EControlGetBreakpoints,

		EControlCancelNotifyBreakpoint,

		EControlRegisterPersistantBreakpoint,

		EControlSetSymbolicBreakpoint,

		EControlSetDebugPort,

		EControlReboot,

		EControlGetCreatorThread,

		EControlPropertyNotify,

		EControlPropertyNotifyCancel,

		EControlSubscribeToProperty,

		EControlAcquireCodeSegMutexAndFilterCodesegsForProcess,

		ENumRequests,  // Add new commands above this line

        };

public:

	static TInt LoadDriver();

	static void CloseDriver();

public:

	//Open the driver

	TInt Open();

	//Deprecated.

	TInt ResetTimer();

	//Read memory from the context of a thread

	TInt GetThreadMem(const TThreadMemoryAccessParamsBuf& aParams, TDes8& aBuf);

	//Get the address of the allocator of a thread

	TInt GetAllocatorAddress(TUint aThreadId, TUint8*& aAddressOfKernelObject);

	TInt GetCurrentAllocatorAddress(TUint aThreadId, TUint8*& aAddressOfKernelObject);

	TInt FindAddressInCodeSegments(TFullName8& aDllName, TAny* aPtr);

	TInt GetHandleOwners(TAny* aKernelObjectPtr, TDes8& aOwnersBuf);

	TInt GetThreadHandles(TUint aThreadId, TDes8& aHandlesBuf);

	TInt GetProcessHandles(TUint aProcessId, TDes8& aHandlesBuf);

	void ForceCrash();

	void Reboot(TInt aReason);

	//Get the number of objects in a specified kernel container

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

	//Wait on the mutex of a specified kernel container

	TInt AcquireContainerMutex (const TObjectType aObjectType);

	//Signal the mutex of a specified kernel container

	TInt ReleaseContainerMutex (const TObjectType aObjectType);

	//Get the type of a DObject* object in the kernel

	TInt GetObjectType (TUint8* aKernelObjectAddr, TObjectType& aObjectType);

	//Get info about a kernel object, referenced by position in its container.  Call AcquireContainerMutex before calling.

	TInt GetObjectInfo (TObjectType aObjectType, TUint aIndexInKernelContainer, TDes8& aObjectInfoBuf);

	//Get info about a kernel object specified as a DObject*

	TInt GetObjectInfo (TObjectType aObjectType, TUint8* aAddressOfKernelObject, TDes8& aObjectInfoBuf);

	//Get info about a kernel object specified by name.

	TInt GetObjectInfo (TObjectType aObjectType, const TDesC& aObjectName, TDes8& aObjectInfoBuf);

	//Get info about a kernel object specified as a user side handle	

	TInt GetObjectInfoByHandle (TObjectType aObjectType, TInt aThreadId, TInt aObjectHandle, TDes8& aObjectInfoBuf);

	//Wait on the kernel's code seg mutex

	TInt AcquireCodeSegMutex();

	TInt AcquireCodeSegMutexAndFilterCodesegsForProcess(TUint aProcessId);

	//Signal the kernel's code seg mutex

	TInt ReleaseCodeSegMutex();

	//Get info about the next code seg.  Call repeatedly to iterate all code segs.  Call AcquireCodeSegMutex before calling.

	TInt GetNextCodeSegInfo(TDes8& aCodeSegInfoBuf);

	//Kill an object.  aObyType should be a thread or process.  Either an objectId (user side handle) _OR_ objectPtr (kernel side DObject*) should be provided.

	TInt ObjectDie(TObjectType aObjType, TUint aObjectId, TUint8* aObjectPtr, TExitType aType, TInt aReason, const TDesC& aCategory);

	//Pack the addresses of all the kernel objects of the specified type belonging to the specified process into the supplied buffer.

	//Returns KErrOverflow if the buffer isn't big enough to hold all the addresses. aOwningProcess may contain '?' and '*' wild characters.

	TInt GetObjectAddresses(TObjectType aObjType, const TDesC& aOwningProcess, TDes8& aAddressBuffer);

	//Pack the addresses of all the chunks with a the specified controlling process id into the supplied buffer.

	//Returns KErrOverflow if the buffer isn't big enough to hold all the addresses. Note, this interface allows global chunks (which have

	//a NULL owner pointers, hence can't be found using RMemoryAccess::GetObjectAddresses) that were created by a particular process to be found.

	TInt GetChunkAddresses(TUint aControllingProcessId, TDes8& aAddressBuffer);

	TInt GetProperty(TUid aCategory, TUint aKey, TInt& aValue);

	TInt GetProperty(TUid aCategory, TUint aKey, TDes8& aValue, TInt& aActualSize);

	TInt SetProperty(TUid aCategory, TUint aKey, TInt aValue, TBool aDefineIfNotSet=EFalse);

	TInt SetProperty(TUid aCategory, TUint aKey, const TDesC8& aValue, TBool aDefineIfNotSet=EFalse);

	TInt DeleteProperty(TUid aCategory, TUint aKey);

	TInt SubscribeToProperty(TUid aCategory, TUint aKey, TBool aOutputToBtrace); // If aOutputToBtrace is false, use NotifyPropertyChange to get details

	void NotifyPropertyChange(TPropNotifyResult& aResult, TRequestStatus& aStatus);

	void CancelPropertyChange();

	TInt RThreadForceOpen(RThread& aThread, TUint aId);

	TInt SetThreadPriority(RThread& aThread, TInt aPriority);

	void NotifyThreadCreation(TRequestStatus& aStatus);

	void CancelNotifyThreadCreation();