/*

* 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 "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:  Declaration of the class RAnalyzeTool.

*

*/

#ifndef __ANALYZETOOL_H__

#define __ANALYZETOOL_H__

// INCLUDES

#include <e32cmn.h>

//Version information for command line engine.

//Tells the version of AT core componenets.

// CONSTANTS

inline TVersion KAnalyzeToolLddVersion() { return TVersion(1, 0, 1); }

/* The name of the analyze tool device driver*/

_LIT( KAnalyzeToolLddName, "AToolKernelEventHandler" );

/* The priority of AnalyzeTool Dfc */

const TInt KAnalyzeToolThreadPriority = 27;

/* The name of the AnalyzeTool DFC */

_LIT8( KAnalyzeToolThreadName, "AnalyzeToolThreadDfc" );

/* The panic literal */

_LIT( KClientPanic, "AnalyzeTool" );

//const TInt KATMaxCallstackLength = 20;

/* The device handler panic codes */

enum TPanic

	{

	EPanicRequestPending,

	EPanicNoRequestPending,

	EPanicUnsupportedRequest

	};

// Size of following must be multiple of 4 bytes.

class TMainThreadParams

	{

	public:

		RAllocator* iAllocator;

		TBool       iAlone;

		TUint       iProcessId;

	};

typedef TPckgBuf<TMainThreadParams> TMainThreadParamsBuf;

class TLibraryInfo

	{

	public:

		TBuf8<KMaxLibraryName> iLibraryName;

		TLinAddr  iRunAddress;

		TUint32   iSize;

		TInt      iIndex;

		TUint     iProcessId;

	};

typedef TPckgBuf<TLibraryInfo> TLibraryInfoBuf;

class TCodesegInfo

	{

	public:

		TBuf8<KMaxLibraryName> iFullName;

		TLinAddr iRunAddress;

		TUint32  iSize;

		TInt  iIndex;

		TUint iProcessId;

		TInt  iCodesegIndex; 

		TLinAddr iFileEntryPoint;

		TInt     iFuntionCount;

		TLibraryFunction iFirstFunction;

		TModuleMemoryInfo iMemoryInfo;

	};

typedef TPckgBuf<TCodesegInfo> TCodesegInfoBuf;

class TThreadParams

	{		

	public:

	    TLinAddr iStackAddress;

	    TInt iStackSize;

	    TUint iThreadId;

	};

typedef TPckgBuf<TThreadParams> TThreadParamsBuf;

class TProcessIdentityParams

	{		

	public:

		TBuf8<KMaxProcessName> iProcessName;

		TInt iDynamicCount;

		TInt iCodesegCount;

		TUint iProcessId;

		TUint iThreadId;

	    TLinAddr iStackAddress;

	    TInt iStackSize;

	};

typedef TPckgBuf<TProcessIdentityParams> TProcessIdentityParamsBuf;

class TLibraryEventInfo

	{

	public:

		enum TLibraryEvent

			{ 

			ELibraryAdded = 0, 

			ELibraryRemoved,

			EKillThread 

			};

	public:

		TUint iProcessId;

		TBuf8<KMaxLibraryName> iLibraryName;

		TLinAddr iRunAddress;

		TUint32 iSize;

		TLibraryEvent iEventType;

		TUint iThreadId;

	};

typedef TPckgBuf<TLibraryEventInfo> TLibraryEventInfoBuf;

class TProcessHandleInfo

	{

	public:

		TInt     iProcessHandleCount;

		TInt     iThreadHandleCount;

		TInt     iIndex;

		TInt     iThreadCount;

		TLinAddr iUserStackRunAddress;

		TInt     iUserStackSize;

		TUint    iProcessId;

	};

typedef TPckgBuf<TProcessHandleInfo> TProcessHandleInfoBuf;

/**

*  A class for particular process's current handle count

*/

class TATProcessHandles

    {

    public:

        /** The ID of the process. */

        TUint iProcessId;

        /** The number of current handles in the library. */

        TInt iCurrentHandleCount;

    };

typedef TPckgBuf<TATProcessHandles> TATProcessHandlesBuf;

class TClientCount

    {

    public:

        /** The count of clients */

        TInt iClientCount;     

    };

typedef TPckgBuf<TClientCount> TClientCountBuf;

class TATMemoryModel

    {

    public :

        /* Memory model*/

        TUint32 iMemoryModel;

    };

typedef TPckgBuf<TATMemoryModel> TATMemoryModelBuf;

// CLASS DECLARATION

/**

*  The user-side handle to a logical channel which provides functions to 

*  open a channel and to make requests to a analyze tool device driver. 

*/

class RAnalyzeTool : public RBusLogicalChannel

	{

	public:

	/** Enumeration of supported functions */

	enum TBasicAnalyzerControl

		{

		EGetProcessInfo = 0, /* The process information */

		EGetCodesegInfo,	 /* The codesegment information */

		EGetLibraryInfo,     /* The library information */

		EGetDynamicInfo,	 /* The count of dynamic code in the process */

		ELibraryEvent,       /* Subscribe events from library events */

		ECancelLibraryEvent, /* Cancel subscribetion of library events */

		ECurrentClientCount,  /* The count of clients in device driver */

		EMainThreadAlloctor,

		EThreadStack,

		EGetProcessHandle,	/* Gets process global handles info*/

		EGetCurrentHandles, /* Get a process's current handle count */

		EGetMemoryModel

		};

#ifndef __KERNEL_MODE__

        /**

        * Opens a handle to a logical channel.

        * @return TInt Returns KErrNone, if successful or otherwise 

        		  one of the other system-wide error codes

        */

		inline TInt Open();

        /**

        * Acquires process information.

        * @param aProcessIdentityParams The process information which 

        								is filled by the device driver

        * @return TInt Returns KErrNone, if successful

        			   otherwise one of the other system-wide error codes

        */

		inline TInt GetProcessInfo( 

				TProcessIdentityParamsBuf& aProcessIdentityParams );

        /**

        * Acquires codeseg information.

        * @param aCodesegInfo The codeseg information which 

        					  is filled by the device driver

        * @return TInt Returns KErrNone, if successful

        			   otherwise one of the other system-wide error codes

        */

		inline TInt GetCodesegInfo( TCodesegInfoBuf& aCodesegInfo );

        /**

        * Acquires library information.

        * @param aLibraryInfo The library information which 

        					  is filled by the device driver

        * @return TInt Returns KErrNone, if successful

        			   otherwise one of the other system-wide error codes

        */

		inline TInt GetLibraryInfo( TLibraryInfoBuf& aLibraryInfo );

        /**

        * Subscribes library event.

        * @param aStatus The request status object for this request. 

        * @param aLibraryInfo The library information which 

        					  is filled by the device driver

        * @return TInt Returns KErrNone, if successful

        			   otherwise one of the other system-wide error codes

        */

		inline void LibraryEvent( TRequestStatus& aStatus, 

		                          TLibraryEventInfo& aLibraryInfo );

        /**

        * Cancels subscribetion of the library event.

        */

		inline void CancelLibraryEvent();

        /**

        * Acquires device driver current client count.

        * @param aClientCount A reference to TInt which is 

        				      updated by the device driver.

        * @return TInt Returns KErrNone, if successful

        			   otherwise one of the other system-wide error codes

        */

		inline TInt ClientCount( TClientCountBuf& aClientCount );

        /**

        * Acquires process main thread RAllocator

        * @param aMainThreadParams The main thread information which 

        					        is filled by the device driver

        * @return TInt Returns KErrNone, if successful

        			   otherwise one of the other system-wide error codes

        */	

		inline TInt MainThreadAlloctor( TMainThreadParamsBuf& aMainThreadParams );

		/**

		* Acquires main thread stack address.

		* @param aThreadStack Pointer to the TThreadParams object.

		* @return TInt Returns KErrNone, if successful

					   otherwise one of the other system-wide error codes

		*/

		inline TInt ThreadStack( TThreadParamsBuf& aThreadStack );

        /**

        * Acquires information about process global handles.

        * @param aProcessHandleInfo Pointer to the TProcessHandleInfo object.

        * @return TInt Returns KErrNone, if successful

        			   otherwise one of the other system-wide error codes

        */

		inline TInt GetProcessHandleInfo( TProcessHandleInfoBuf& aProcessHandleInfo );

        /**

        * Acquires a process's current handle count.

        * @param aProcessHandles Pointer to the TATProcessHandles object.

        * @return TInt Returns KErrNone, if successful

                       otherwise one of the other system-wide error codes

        */

        inline TInt GetCurrentHandleCount( TATProcessHandlesBuf& aProcessHandles );

        /**

         * Acquires memory model system uses.

         * @param aMemoryModel pointer to the TATMemoryModelBuf object.

         */

        inline TInt GetMemoryModel( TATMemoryModelBuf& aMemoryModel );

#endif // #ifndef __KERNEL_MODE__

	};

// INLINES

#include <analyzetool/analyzetool.inl>

#endif // #ifndef __ANALYZETOOL_H__

// End of File