Symaptic: os/kernelhwsrv/kernel/eka/include/rm_debug

sl@0	1	// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0	2	// All rights reserved.
sl@0	3	// This component and the accompanying materials are made available
sl@0	4	// under the terms of the License "Eclipse Public License v1.0"
sl@0	5	// which accompanies this distribution, and is available
sl@0	6	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	7	//
sl@0	8	// Initial Contributors:
sl@0	9	// Nokia Corporation - initial contribution.
sl@0	10	//
sl@0	11	// Contributors:
sl@0	12	//
sl@0	13	// Description:
sl@0	14	// Definitions for the run mode debug agent client side sessions.
sl@0	15	//
sl@0	16	// WARNING: This file contains some APIs which are internal and are subject
sl@0	17	// to change without notice. Such APIs should therefore not be used
sl@0	18	// outside the Kernel and Hardware Services package.
sl@0	19	//
sl@0	20
sl@0	21	#ifndef RM_DEBUG_API_H
sl@0	22	#define RM_DEBUG_API_H
sl@0	23
sl@0	24	/**
sl@0	25	@file
sl@0	26	@publishedPartner
sl@0	27	@released
sl@0	28	*/
sl@0	29
sl@0	30	#include <e32cmn.h>
sl@0	31	#include <e32def_private.h>
sl@0	32
sl@0	33	/**
sl@0	34	The Debug namespace contains all API definitions used for on-target debugging.
sl@0	35	*/
sl@0	36	namespace Debug {
sl@0	37
sl@0	38	/** This is the maximum size in bytes a user trace can be */
sl@0	39	const TInt TUserTraceSize = 256;
sl@0	40
sl@0	41	/**
sl@0	42	Information in the debug functionality block is represented as a concatenation
sl@0	43	of pairs of TTagHeader structures and arrays of TTag objects.
sl@0	44	@see TTagHeader
sl@0	45	@see RSecuritySvrSession::GetDebugFunctionality
sl@0	46	*/
sl@0	47	struct TTag
sl@0	48	{
sl@0	49	/** Tag ID, value identifying this tag. */
sl@0	50	TUint32 iTagId;
sl@0	51	/**
sl@0	52	Values correspond to TTagType enumerators.
sl@0	53	@see TTagType
sl@0	54	*/
sl@0	55	TUint16 iType;
sl@0	56	/** Size of external data associated with this tag. */
sl@0	57	TUint16 iSize;
sl@0	58	/** Data associated with this tag. */
sl@0	59	TUint32 iValue;
sl@0	60	};
sl@0	61
sl@0	62	/**
sl@0	63	Enumeration defining the supported tag types. These enumerators are used in TTag.iTagId.
sl@0	64	@see TTag
sl@0	65	*/
sl@0	66	enum TTagType
sl@0	67	{
sl@0	68	/** Indicates that the iValue field of a TTag structure will contain either ETrue or EFalse. */
sl@0	69	ETagTypeBoolean = 0,
sl@0	70	/** Indicates that the iValue field of a TTag structure will contain a value in the TUint32 range. */
sl@0	71	ETagTypeTUint32 = 1,
sl@0	72	/** Indicates that the iValue field of a TTag structure will contain values from an enumeration. */
sl@0	73	ETagTypeEnum = 2,
sl@0	74	/** Indicates that the iValue field of a TTag structure should be interpreted as a bit field. */
sl@0	75	ETagTypeBitField = 3,
sl@0	76	/** Indicates that the type of the iValue field of a TTag structure is unknown. */
sl@0	77	ETagTypeUnknown = 4,
sl@0	78	/** Indicates that the iValue field of a TTag structure will contain a pointer. */
sl@0	79	ETagTypePointer = 5
sl@0	80	};
sl@0	81
sl@0	82	/**
sl@0	83	Information in the debug functionality block is represented as a concatenation
sl@0	84	of pairs of TTagHeader structures and arrays of TTag objects.
sl@0	85	@see TTag
sl@0	86	@see RSecuritySvrSession::GetDebugFunctionality
sl@0	87	*/
sl@0	88	struct TTagHeader
sl@0	89	{
sl@0	90	/** Value identifying the contents of this TTagHeader, should be interpreted as an enumerator from TTagHeaderId.
sl@0	91	@see TTagHeaderId
sl@0	92	*/
sl@0	93	TUint16 iTagHdrId;
sl@0	94	/** The number of TTag elements in the array associated with this TTagHeader. */
sl@0	95	TUint16 iNumTags;
sl@0	96	};
sl@0	97
sl@0	98	/**
sl@0	99	Enumeration used to identify TTagHeader structures, TTagHeader::iTagHdrId elements take these enumerators as values.
sl@0	100	@see TTagHeader
sl@0	101	*/
sl@0	102	enum TTagHeaderId
sl@0	103	{
sl@0	104	ETagHeaderIdCore = 0, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityCore. /
sl@0	105	ETagHeaderIdMemory = 1, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityMemory. /
sl@0	106	/**
sl@0	107	Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityRegister.
sl@0	108	These values are defined as in the document Symbian Core Dump File Format Appendix C
sl@0	109	(see SGL.TS0028.027 - Symbian Core Dump File Format v1.0.doc).
sl@0	110	The TTag objects in the associated array have an iSize value corresponding to the size of the register's data in bytes.
sl@0	111	*/
sl@0	112	ETagHeaderIdRegistersCore = 2,
sl@0	113	/**
sl@0	114	Identifies a TTagHeader with associated TTag elements with iTagId values corresponding to coprocessor register identifiers.
sl@0	115	Coprocessor registers are defined as in the document Symbian Core Dump File Format Appendix C as follows
sl@0	116	(see SGL.TS0028.027 - Symbian Core Dump File Format v1.0.doc):
sl@0	117
sl@0	118	For each 32-bit data word defining a co-pro register, the definition of the meaning of the bits follows
sl@0	119	the ARM Architecture Reference manual instruction coding
sl@0	120
sl@0	121	Upper Halfword Lower Halfword
sl@0	122	Opcode 2 CRm
sl@0	123
sl@0	124	For example: The Domain Access Control Register is Register 3 of co-processor 15. The encoding is therefore
sl@0	125	CRm = 3
sl@0	126	Opcode2 = 0
sl@0	127
sl@0	128	Therefore the functionality tag would be:
sl@0	129	TagID: 15 // co-processor number
sl@0	130	Type: ETagTypeTUint32
sl@0	131	Data: 0x00000003 // Opcode2 = 0, CRm = 3
sl@0	132	*/
sl@0	133	ETagHeaderIdCoProRegisters = 3, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityRegister. /
sl@0	134	ETagHeaderIdBreakpoints = 4, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityBreakpoint. /
sl@0	135	ETagHeaderIdStepping = 5, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityStep. /
sl@0	136	ETagHeaderIdExecution = 6, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityExec. /
sl@0	137	ETagHeaderIdEvents = 7, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TEventType. /
sl@0	138	ETagHeaderIdApiConstants = 8, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityApiConstants./
sl@0	139	ETagHeaderList = 9, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TListId. /
sl@0	140	ETagHeaderIdKillObjects = 10, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityKillObject. /
sl@0	141	ETagHeaderIdSecurity = 11, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalitySecurity /
sl@0	142	ETagHeaderIdBuffers = 12, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TBufferType. /
sl@0	143	ETagHeaderIdStopModeFunctions = 13, /*< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityStopModeFunctions. /
sl@0	144	};
sl@0	145
sl@0	146	/**
sl@0	147	This structure is not used in the run-mode debug API.
sl@0	148	@deprecated
sl@0	149	*/
sl@0	150	struct TSubBlock
sl@0	151	{
sl@0	152	/** Header to identify the TSubBlock. */
sl@0	153	TTagHeader iHeader;
sl@0	154	/** Pointer to array of TTag values associated with this TSubBlock. */
sl@0	155	TTag* iTagArray;
sl@0	156	};
sl@0	157
sl@0	158	/**
sl@0	159	These tags define what kinds of core functionality are supported by the run-mode debug subsystem.
sl@0	160	TTag structures associated with the ETagHeaderIdCore sub-block will have iTagId values from this enumeration.
sl@0	161	See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
sl@0	162	*/
sl@0	163	enum TFunctionalityCore
sl@0	164	{
sl@0	165	ECoreEvents = 0, /*< Indicates whether events processing is supported. /
sl@0	166	ECoreStartStop = 1, /*< Indicates whether suspending and resuming threads is supported. /
sl@0	167	ECoreMemory = 2, /*< Indicates whether reading and writing memory is supported. /
sl@0	168	ECoreRegister = 3, /*< Indicates whether reading and writing register values is supported. /
sl@0	169	ECoreBreakpoint = 4, /*< Indicates whether breakpoints are supported. /
sl@0	170	ECoreStepping = 5, /*< Indicates whether stepping is supported. /
sl@0	171	ECoreLists = 6, /*< Indicates whether listings are supported. /
sl@0	172	ECoreLogging = 7, /*< Indicates whether logging is supported. /
sl@0	173	ECoreHardware = 8, /*< Indicates whether hardware support is supported. /
sl@0	174	ECoreApiConstants = 9, /*< Indicates whether the information in the ETagHeaderIdApiConstants sub-block is relevant. /
sl@0	175	ECoreKillObjects = 10, /*< Indicates whether killing objects (i.e. threads and processes) is supported. /
sl@0	176	ECoreSecurity = 11, /*< Indicates whether OEM Debug token support or other security info is supported. /
sl@0	177	ECoreStopModeFunctions = 12, /*< Indicates whether Stop Mode function calling is supported. /
sl@0	178	ECoreStopModeBuffers = 13, /*< Indicates whether Stop Mode buffers are supported. /
sl@0	179
sl@0	180	/**
sl@0	181	@internalTechnology
sl@0	182	A debug agent should find the number of core tags from the DFBlock rather than this enumerator.
sl@0	183	*/
sl@0	184	ECoreLast
sl@0	185	};
sl@0	186
sl@0	187	/**
sl@0	188	These tags define what kind of memory operations can be performed.
sl@0	189	TTag structures associated with the ETagHeaderIdMemory sub-block will have iTagId values from this enumeration.
sl@0	190	See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
sl@0	191	*/
sl@0	192	enum TFunctionalityMemory
sl@0	193	{
sl@0	194	EMemoryRead = 0, /*< Indicates whether reading memory is supported. /
sl@0	195	EMemoryWrite = 1, /*< Indicates whether writing memory is supported. /
sl@0	196	EMemoryAccess64 = 2, /*< Indicates whether 64 bit memory access is supported. /
sl@0	197	EMemoryAccess32 = 3, /*< Indicates whether 32 bit memory access is supported. /
sl@0	198	EMemoryAccess16 = 4, /*< Indicates whether 16 bit memory access is supported. /
sl@0	199	EMemoryAccess8 = 5, /*< Indicates whether 8 bit memory access is supported. /
sl@0	200	EMemoryBE8 = 6, /*< Indicates whether reading memory as 8 bit big-endian values is supported. /
sl@0	201	EMemoryBE32 = 7, /*< Indicates whether reading memory as 32 bit big-endian values is supported. /
sl@0	202	EMemoryLE8 = 8, /*< Indicates whether reading memory as 8 bit little-endian values is supported. /
sl@0	203	EMemoryMaxBlockSize = 9, /*< Corresponds to the maximum size of a block of memory which can be requested. /
sl@0	204	/**
sl@0	205	@internalTechnology
sl@0	206	A debug agent should find the number of memory tags from the DFBlock rather than this enumerator.
sl@0	207	*/
sl@0	208	EMemoryLast
sl@0	209	};
sl@0	210
sl@0	211	/**
sl@0	212	These tags define which objects can be killed by the device driver.
sl@0	213	TTag structures associated with the ETagHeaderIdKillObjects sub-block will have iTagId values from this enumeration.
sl@0	214	See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
sl@0	215	*/
sl@0	216	enum TFunctionalityKillObject
sl@0	217	{
sl@0	218	EFunctionalityKillThread = 0, /*< Indicates whether killing threads is supported. /
sl@0	219	EFunctionalityKillProcess = 1, /*< Indicates whether killing processes is supported. /
sl@0	220	/**
sl@0	221	@internalTechnology
sl@0	222	A debug agent should find the number of kill object tags from the DFBlock rather than this enumerator.
sl@0	223	*/
sl@0	224	EFunctionalityKillObjectLast
sl@0	225	};
sl@0	226
sl@0	227	/**
sl@0	228	A TTag with an id from the TFunctionalityRegister enum will have a value from this enumeration.
sl@0	229	The values define how a register can be accessed, if at all.
sl@0	230	*/
sl@0	231	enum TFunctionalityAccess
sl@0	232	{
sl@0	233	EAccessNone = 0, /*< Indicates that a register cannot be accessed. /
sl@0	234	EAccessReadOnly = 1, /*< Indicates that a register can be read, but not written to. /
sl@0	235	EAccessWriteOnly = 2, /*< Indicates that a register can be written to, but not read. /
sl@0	236	EAccessReadWrite = 3, /*< Indicates that a register can be both read and written to. /
sl@0	237	EAccessUnknown = 4, /*< Indicates that it is unspecified whether reading or writing to a register is possible. /
sl@0	238	};
sl@0	239
sl@0	240	/**
sl@0	241	These enumerators act as core register identifiers.
sl@0	242	TTag structures associated with the ETagHeaderIdRegistersCore sub-block will have iTagId values from this enumeration.
sl@0	243	The numeric value of each enumerator identifies the register according to the definitions in the Symbian Core Dump File Format Appendix B
sl@0	244	(see SGL.TS0028.027 - Symbian Core Dump File Format v1.0.doc).
sl@0	245	*/
sl@0	246	enum TFunctionalityRegister
sl@0	247	{
sl@0	248	ERegisterR0 = 0x00000000, /*< Identifier for user mode register R0. /
sl@0	249	ERegisterR1 = 0x00000100, /*< Identifier for user mode register R1. /
sl@0	250	ERegisterR2 = 0x00000200, /*< Identifier for user mode register R2. /
sl@0	251	ERegisterR3 = 0x00000300, /*< Identifier for user mode register R3. /
sl@0	252	ERegisterR4 = 0x00000400, /*< Identifier for user mode register R4. /
sl@0	253	ERegisterR5 = 0x00000500, /*< Identifier for user mode register R5. /
sl@0	254	ERegisterR6 = 0x00000600, /*< Identifier for user mode register R6. /
sl@0	255	ERegisterR7 = 0x00000700, /*< Identifier for user mode register R7. /
sl@0	256	ERegisterR8 = 0x00000800, /*< Identifier for user mode register R8. /
sl@0	257	ERegisterR9 = 0x00000900, /*< Identifier for user mode register R9. /
sl@0	258	ERegisterR10 = 0x00000a00, /*< Identifier for user mode register R10. /
sl@0	259	ERegisterR11 = 0x00000b00, /*< Identifier for user mode register R11. /
sl@0	260	ERegisterR12 = 0x00000c00, /*< Identifier for user mode register R12. /
sl@0	261	ERegisterR13 = 0x00000d00, /*< Identifier for user mode register R13. /
sl@0	262	ERegisterR14 = 0x00000e00, /*< Identifier for user mode register R14. /
sl@0	263	ERegisterR15 = 0x00000f00, /*< Identifier for user mode register R15. /
sl@0	264	ERegisterCpsr = 0x00001000, /*< Identifier for CPSR. /
sl@0	265	ERegisterR13Svc = 0x00001100, /*< Identifier for R13 supervisor mode banked register. /
sl@0	266	ERegisterR14Svc = 0x00001200, /*< Identifier for R14 supervisor mode banked register. /
sl@0	267	ERegisterSpsrSvc = 0x00001300, /*< Identifier for SPSR supervisor mode banked register. /
sl@0	268	ERegisterR13Abt = 0x00001400, /*< Identifier for R13 Abort mode banked register. /
sl@0	269	ERegisterR14Abt = 0x00001500, /*< Identifier for R14 Abort mode banked register. /
sl@0	270	ERegisterSpsrAbt = 0x00001600, /*< Identifier for SPSR Abort mode banked register. /
sl@0	271	ERegisterR13Und = 0x00001700, /*< Identifier for R13 Undefined mode banked register. /
sl@0	272	ERegisterR14Und = 0x00001800, /*< Identifier for R14 Undefined mode banked register. /
sl@0	273	ERegisterSpsrUnd = 0x00001900, /*< Identifier for SPSR Undefined mode banked register. /
sl@0	274	ERegisterR13Irq = 0x00001a00, /*< Identifier for R13 Interrupt mode banked register. /
sl@0	275	ERegisterR14Irq = 0x00001b00, /*< Identifier for R14 Interrupt mode banked register. /
sl@0	276	ERegisterSpsrIrq = 0x00001c00, /*< Identifier for SPSR Interrupt mode banked register. /
sl@0	277	ERegisterR8Fiq = 0x00001d00, /*< Identifier for R8 Fast Interrupt mode banked register. /
sl@0	278	ERegisterR9Fiq = 0x00001e00, /*< Identifier for R9 Fast Interrupt mode banked register. /
sl@0	279	ERegisterR10Fiq = 0x00001f00, /*< Identifier for R10 Fast Interrupt mode banked register. /
sl@0	280	ERegisterR11Fiq = 0x00002000, /*< Identifier for R11 Fast Interrupt mode banked register. /
sl@0	281	ERegisterR12Fiq = 0x00002100, /*< Identifier for R12 Fast Interrupt mode banked register. /
sl@0	282	ERegisterR13Fiq = 0x00002200, /*< Identifier for R13 Fast Interrupt mode banked register. /
sl@0	283	ERegisterR14Fiq = 0x00002300, /*< Identifier for R14 Fast Interrupt mode banked register. /
sl@0	284	ERegisterSpsrFiq = 0x00002400, /*< Identifier for SPSR Fast Interrupt mode banked register. /
sl@0	285	/**
sl@0	286	@internalTechnology
sl@0	287	A debug agent should find the number of core registers from the DFBlock rather than this enumerator.
sl@0	288	*/
sl@0	289	ERegisterLast = 37
sl@0	290	};
sl@0	291
sl@0	292
sl@0	293	/**
sl@0	294	These tags define the kind of breakpoints that are supported.
sl@0	295	TTag structures associated with the ETagHeaderIdBreakpoints sub-block will have iTagId values from this enumeration.
sl@0	296	See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
sl@0	297	*/
sl@0	298	enum TFunctionalityBreakpoint
sl@0	299	{
sl@0	300	EBreakpointThread = 0, /*< Indicates whether thread specific breakpoints are supported. /
sl@0	301	EBreakpointProcess = 1, /*< Indicates whether process specific breakpoints are supported. /
sl@0	302	EBreakpointSystem = 2, /*< Indicates whether system wide breakpoints are supported. /
sl@0	303	EBreakpointArm = 3, /*< Indicates whether ARM mode breakpoints are supported. /
sl@0	304	EBreakpointThumb = 4, /*< Indicates whether Thumb mode breakpoints are supported. /
sl@0	305	EBreakpointT2EE = 5, /*< Indicates whether Thumb2 mode breakpoints are supported. /
sl@0	306	EBreakpointArmInst = 6, /*< Reserved for future use. /
sl@0	307	EBreakpointThumbInst = 7, /*< Reserved for future use. /
sl@0	308	EBreakpointT2EEInst = 8, /*< Reserved for future use. /
sl@0	309	EBreakpointSetArmInst = 9, /*< Reserved for future use. /
sl@0	310	EBreakpointSetThumbInst = 10, /*< Reserved for future use. /
sl@0	311	EBreakpointSetT2EEInst = 11, /*< Reserved for future use. /
sl@0	312	/**
sl@0	313	@internalTechnology
sl@0	314	A debug agent should find the number of breakpoint tags from the DFBlock rather than this enumerator.
sl@0	315	*/
sl@0	316	EBreakpointLast
sl@0	317	};
sl@0	318
sl@0	319	/**
sl@0	320	These enumerators provide information about the stepping capabilities of the debug sub-system.
sl@0	321	TTag structures associated with the ETagHeaderIdStepping sub-block will have iTagId values from this enumeration.
sl@0	322	See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
sl@0	323	*/
sl@0	324	enum TFunctionalityStep
sl@0	325	{
sl@0	326	EStep = 0, /*< Indicates whether instruction stepping is supported. /
sl@0	327	/**
sl@0	328	@internalTechnology
sl@0	329	A debug agent should find the number of stepping tags from the DFBlock rather than this enumerator.
sl@0	330	*/
sl@0	331	EStepLast
sl@0	332	};
sl@0	333
sl@0	334	/**
sl@0	335	These enumerators provide information about the execution control capabilities of the debug sub-system.
sl@0	336	TTag structures associated with the ETagHeaderIdExecution sub-block will have iTagId values from this enumeration.
sl@0	337	See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
sl@0	338	*/
sl@0	339	enum TFunctionalityExec
sl@0	340	{
sl@0	341	EExecThreadSuspendResume = 0, /*< Indicates whether suspending and resuming threads is supported. /
sl@0	342	EExecProcessSuspendResume = 1, /*< Indicates whether suspending and resuming processes is supported. /
sl@0	343	EExecSystemSuspendResume = 2, /*< Indicates whether suspending and resuming the entire system is supported. /
sl@0	344	/**
sl@0	345	@internalTechnology
sl@0	346	A debug agent should find the number of execution control tags from the DFBlock rather than this enumerator.
sl@0	347	*/
sl@0	348	EExecLast
sl@0	349	};
sl@0	350
sl@0	351	/**
sl@0	352	This enumeration defines the event types supported by the debug sub-system.
sl@0	353	TTag structures associated with the ETagHeaderIdEvents sub-block will have
sl@0	354	iTagId values from this enumeration, and iValue values from the TKernelEventAction enumeration.
sl@0	355
sl@0	356	These enumerators are also used by the RSecuritySvrSession API to identify events.
sl@0	357	@see RSecuritySvrSession
sl@0	358	@see TKernelEventAction
sl@0	359	*/
sl@0	360	enum TEventType
sl@0	361	{
sl@0	362	EEventsBreakPoint = 0, /*< Identifies a breakpoint event. /
sl@0	363	EEventsSwExc = 1, /*< Identifies a software exception event. /
sl@0	364	EEventsHwExc = 2, /*< Identifies a hardware exception event. /
sl@0	365	EEventsKillThread = 3, /*< Identifies a kill thread event. /
sl@0	366	EEventsAddLibrary = 4, /*< Identifies an add library event. /
sl@0	367	EEventsRemoveLibrary = 5, /*< Identifies a remove library event. /
sl@0	368	/**
sl@0	369	If an event is generated and there is only a single space remaining in the events queue then
sl@0	370	an event of type EEventsBufferFull will be stored in the queue and the generated event will
sl@0	371	be discarded. If further events occur while the buffer is full the events will be discarded.
sl@0	372	As such an event of type EEventsBufferFull being returned signifies that one or more events
sl@0	373	were discarded. An event of this type has no valid data associated with it.
sl@0	374	*/
sl@0	375	EEventsBufferFull = 6,
sl@0	376	EEventsUnknown = 7, /*< Identifies an event of unknown type. /
sl@0	377	EEventsUserTrace = 8, /*< Identifies a user trace. /
sl@0	378	EEventsProcessBreakPoint = 9, /*< Identifies a process breakpoint event. /
sl@0	379	EEventsStartThread = 10, /*< Identifies a start thread event. /
sl@0	380	EEventsUserTracesLost = 11, /*< Identifies user traces being lost. /
sl@0	381	EEventsAddProcess = 12, /*< Identifies an AddProcess event /
sl@0	382	EEventsRemoveProcess = 13, /*< Identifies a RemoveProcess event /
sl@0	383	/**
sl@0	384	@internalTechnology
sl@0	385	A debug agent should find the number of event types from the DFBlock rather than this enumerator.
sl@0	386	*/
sl@0	387	EEventsLast
sl@0	388	};
sl@0	389
sl@0	390	/**
sl@0	391	These enumerators provide information about constants which are used in the RSecuritySvrSession API.
sl@0	392	TTag structures associated with the ETagHeaderIdApiConstants sub-block will have iTagId values from this enumeration.
sl@0	393	See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
sl@0	394	*/
sl@0	395	enum TFunctionalityApiConstants
sl@0	396	{
sl@0	397	/**
sl@0	398	Corresponds to the size of a buffer required to store a TEventInfo.
sl@0	399	@see TEventInfo
sl@0	400	*/
sl@0	401	EApiConstantsTEventInfoSize = 0,
sl@0	402	/**
sl@0	403	@internalTechnology
sl@0	404	A debug agent should find the number of API constants tags from the DFBlock rather than this enumerator.
sl@0	405	*/
sl@0	406	EApiConstantsLast,
sl@0	407	};
sl@0	408
sl@0	409	/**
sl@0	410	The set of possible actions which could be taken when a kernel event occurs.
sl@0	411	Not all actions are possible for all events. The debug functionality sub-block with header id ETagHeaderIdEvents
sl@0	412	indicates which values are permitted for each event. The value given for that event should be
sl@0	413	considered as the most intrusive action the debugger may set: with the definition that EActionSuspend is more
sl@0	414	intrusive than EActionContinue, which is more intrusive than EActionIgnore.
sl@0	415	@see RSecuritySvrSession
sl@0	416	*/
sl@0	417	enum TKernelEventAction
sl@0	418	{
sl@0	419	/** If an event action is set to this value then events of that type will be
sl@0	420	ignored, and not reported to the debugger. */
sl@0	421	EActionIgnore = 0,
sl@0	422	/** If an event action is set to this value then events of that type will be
sl@0	423	reported to the debugger and the thread which generated the event will be
sl@0	424	allowed to continue executing. */
sl@0	425	EActionContinue = 1,
sl@0	426	/** If an event action is set to this value then events of that type will be
sl@0	427	reported to the debugger and the thread which generated the event will be
sl@0	428	suspended. */
sl@0	429	EActionSuspend = 2,
sl@0	430	/**
sl@0	431	@internalTechnology
sl@0	432	Count of event actions.
sl@0	433	*/
sl@0	434	EActionLast
sl@0	435	};
sl@0	436
sl@0	437	/**
sl@0	438	These enumerators provide information about the ability of the debug subsystem to support OEM Debug tokens.
sl@0	439	TTag structures associated with the ETagHeaderIdSecurity sub-block will have iTagId values from this enumeration.
sl@0	440	See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
sl@0	441	*/
sl@0	442	enum TFunctionalitySecurity
sl@0	443	{
sl@0	444	ESecurityOEMDebugToken = 0, /*< Indicates whether the DSS supports the use of OEM Debug Tokens. /
sl@0	445
sl@0	446	/**
sl@0	447	@internalTechnology
sl@0	448	A debug agent should find the number of tags from the DFBlock rather than this enumerator.
sl@0	449	*/
sl@0	450	ESecurityLast
sl@0	451	};
sl@0	452
sl@0	453	/**
sl@0	454	Used for storing the contents of a 32 bit register
sl@0	455	*/
sl@0	456	typedef TUint32 TRegisterValue32;
sl@0	457
sl@0	458
sl@0	459	/**
sl@0	460	* Processor mode
sl@0	461	*/
sl@0	462	enum TArmProcessorModes
sl@0	463	{
sl@0	464	EUserMode=0x10, //!< EUserMode
sl@0	465	EFiqMode=0x11, //!< EFiqMode
sl@0	466	EIrqMode=0x12, //!< EIrqMode
sl@0	467	ESvcMode=0x13, //!< ESvcMode
sl@0	468	EAbortMode=0x17, //!< EAbortMode
sl@0	469	EUndefMode=0x1b, //!< EUndefMode
sl@0	470	EMaskMode=0x1f //!< EMaskMode
sl@0	471	};
sl@0	472
sl@0	473
sl@0	474
sl@0	475	/**
sl@0	476	Structure containing information about the state of the registers when a
sl@0	477	hardware exception occurred
sl@0	478	*/
sl@0	479	class TRmdArmExcInfo
sl@0	480	{
sl@0	481	public:
sl@0	482	/** Enumeration detailing the types of exception which may occur. */
sl@0	483	enum TExceptionType
sl@0	484	{
sl@0	485	/** Enumerator signifying that a prefetch abort error has occurred. */
sl@0	486	EPrefetchAbort = 0,
sl@0	487	/** Enumerator signifying that a data abort error has occurred. */
sl@0	488	EDataAbort = 1,
sl@0	489	/** Enumerator signifying that an undefined instruction error has occurred. */
sl@0	490	EUndef =2
sl@0	491	};
sl@0	492
sl@0	493	/** Value of CPSR. */
sl@0	494	TRegisterValue32 iCpsr;
sl@0	495	/** Type of exception which has occurred. */
sl@0	496	TExceptionType iExcCode;
sl@0	497	/** Value of R13 supervisor mode banked register. */
sl@0	498	TRegisterValue32 iR13Svc;
sl@0	499	/** Value of user mode register R4. */
sl@0	500	TRegisterValue32 iR4;
sl@0	501	/** Value of user mode register R5. */
sl@0	502	TRegisterValue32 iR5;
sl@0	503	/** Value of user mode register R6. */
sl@0	504	TRegisterValue32 iR6;
sl@0	505	/** Value of user mode register R7. */
sl@0	506	TRegisterValue32 iR7;
sl@0	507	/** Value of user mode register R8. */
sl@0	508	TRegisterValue32 iR8;
sl@0	509	/** Value of user mode register R9. */
sl@0	510	TRegisterValue32 iR9;
sl@0	511	/** Value of user mode register R10. */
sl@0	512	TRegisterValue32 iR10;
sl@0	513	/** Value of user mode register R11. */
sl@0	514	TRegisterValue32 iR11;
sl@0	515	/** Value of R14 supervisor mode banked register. */
sl@0	516	TRegisterValue32 iR14Svc;
sl@0	517	/** Address which caused exception (System Control Coprocessor Fault Address Register) */
sl@0	518	TRegisterValue32 iFaultAddress;
sl@0	519	/** Value of System Control Coprocessor Fault Status Register. */
sl@0	520	TRegisterValue32 iFaultStatus;
sl@0	521	/** Value of SPSR supervisor mode banked register. */
sl@0	522	TRegisterValue32 iSpsrSvc;
sl@0	523	/** Value of user mode register R13. */
sl@0	524	TRegisterValue32 iR13;
sl@0	525	/** Value of user mode register R14. */
sl@0	526	TRegisterValue32 iR14;
sl@0	527	/** Value of user mode register R0. */
sl@0	528	TRegisterValue32 iR0;
sl@0	529	/** Value of user mode register R1. */
sl@0	530	TRegisterValue32 iR1;
sl@0	531	/** Value of user mode register R2. */
sl@0	532	TRegisterValue32 iR2;
sl@0	533	/** Value of user mode register R3. */
sl@0	534	TRegisterValue32 iR3;
sl@0	535	/** Value of user mode register R12. */
sl@0	536	TRegisterValue32 iR12;
sl@0	537	/** Value of user mode register R15, points to instruction which caused exception. */
sl@0	538	TRegisterValue32 iR15;
sl@0	539	};
sl@0	540
sl@0	541	/**
sl@0	542	The maximum size, in bytes, of the panic category string returned as part of a
sl@0	543	TEventInfo object.
sl@0	544
sl@0	545	@see TEventInfo
sl@0	546	@see TThreadKillInfo
sl@0	547	*/
sl@0	548	const TInt KPanicCategoryMaxName = KMaxName;
sl@0	549
sl@0	550	/**
sl@0	551	Event specific information returned as part of a TEventInfo object when
sl@0	552	an agent set breakpoint is hit.
sl@0	553	*/
sl@0	554	class TThreadBreakPointInfo
sl@0	555	{
sl@0	556	public:
sl@0	557	/** Identifies the type of exception. */
sl@0	558	TExcType iExceptionNumber;
sl@0	559	/** Structure containing information about the ARM register values. */
sl@0	560	TRmdArmExcInfo iRmdArmExcInfo;
sl@0	561	};
sl@0	562
sl@0	563	/**
sl@0	564	Event specific information returned as part of a TEventInfo object when
sl@0	565	a software exception occurs.
sl@0	566	*/
sl@0	567	class TThreadSwExceptionInfo
sl@0	568	{
sl@0	569	public:
sl@0	570	/** The value of the program counter. */
sl@0	571	TUint32 iCurrentPC;
sl@0	572	/** Identifies the type of exception. */
sl@0	573	TExcType iExceptionNumber;
sl@0	574	};
sl@0	575
sl@0	576	/**
sl@0	577	Event specific information returned as part of a TEventInfo object when
sl@0	578	a hardware exception occurs.
sl@0	579	*/
sl@0	580	class TThreadHwExceptionInfo
sl@0	581	{
sl@0	582	public:
sl@0	583	/** Identifies the type of exception. */
sl@0	584	TExcType iExceptionNumber;
sl@0	585	/** Structure containing information about the ARM register values. */
sl@0	586	TRmdArmExcInfo iRmdArmExcInfo;
sl@0	587	};
sl@0	588
sl@0	589	/**
sl@0	590	Event specific information returned as part of a TEventInfo object when
sl@0	591	a thread kill event occurs.
sl@0	592	*/
sl@0	593	class TThreadKillInfo
sl@0	594	{
sl@0	595	public:
sl@0	596	/** The value of the program counter. */
sl@0	597	TUint32 iCurrentPC;
sl@0	598	/** Specifies the reason for the kill thread event, this value is specific to the killed thread and does not correspond to a standard Symbian enumeration. */
sl@0	599	TInt iExitReason;
sl@0	600	/** Specifies the type of the thread kill event, values correspond to elements of TExitType. */
sl@0	601	TUint8 iExitType;
sl@0	602	/** The panic category of the killed thread. */
sl@0	603	TUint8 iPanicCategory[KPanicCategoryMaxName];
sl@0	604	/** Contains the length in bytes of the initialised data in iPanicCategory. */
sl@0	605	TInt iPanicCategoryLength;
sl@0	606	};
sl@0	607
sl@0	608	/**
sl@0	609	Event specific information returned as part of a TEventInfo object when
sl@0	610	a library load event occurs.
sl@0	611	*/
sl@0	612	class TLibraryLoadedInfo
sl@0	613	{
sl@0	614	public:
sl@0	615	/** The name of the file that the library was loaded from. */
sl@0	616	TUint8 iFileName[KMaxName];
sl@0	617	/** Contains the length in bytes of the initialised data in iFileName. */
sl@0	618	TInt iFileNameLength;
sl@0	619	/** The code base address (.text). */
sl@0	620	TUint32 iCodeAddress;
sl@0	621	/** The base address of the initialised data section (.data). */
sl@0	622	TUint32 iDataAddress;
sl@0	623	};
sl@0	624
sl@0	625	/**
sl@0	626	Event specific information returned as part of a TEventInfo object when
sl@0	627	a thread is started
sl@0	628	*/
sl@0	629	class TStartThreadInfo
sl@0	630	{
sl@0	631	public:
sl@0	632	/** The name of the file that the process owning the thread was created from. */
sl@0	633	TUint8 iFileName[KMaxName];
sl@0	634	/** Contains the length in bytes of the initialised data in iFileName. */
sl@0	635	TInt iFileNameLength;
sl@0	636	};
sl@0	637
sl@0	638	/**
sl@0	639	Event specific information returned as part of a TEventInfo object when
sl@0	640	a process is added. Note that the Process may not be fully constructed,
sl@0	641	e.g. no threads.
sl@0	642	*/
sl@0	643	class TAddProcessInfo
sl@0	644	{
sl@0	645	public:
sl@0	646	/** The name of the file that the process was created from. */
sl@0	647	TUint8 iFileName[KMaxName];
sl@0	648	/** Contains the length in bytes of the initialised data in iFileName. */
sl@0	649	TInt iFileNameLength;
sl@0	650	/** The UID3 of this process */
sl@0	651	TUint32 iUid3;
sl@0	652	/** Contains the CreatorThread ID if available: May be 0 */
sl@0	653	TUint64 iCreatorThreadId;
sl@0	654	};
sl@0	655
sl@0	656	/**
sl@0	657	Event specific information returned as part of a TEventInfo object when
sl@0	658	a process is removed. Note that the Process may not be fully destroyed,
sl@0	659	so its resources should only be accessed if you already have a handle to it.
sl@0	660	*/
sl@0	661	class TRemoveProcessInfo
sl@0	662	{
sl@0	663	public:
sl@0	664	/** The name of the file that the process was created from. */
sl@0	665	TUint8 iFileName[KMaxName];
sl@0	666	/** Contains the length in bytes of the initialised data in iFileName. */
sl@0	667	TInt iFileNameLength;
sl@0	668	TUint32 iSpare1; // Unused
sl@0	669	};
sl@0	670
sl@0	671	/**
sl@0	672	Event specific information returned as part of a TEventInfo object when
sl@0	673	a library unload event occurs.
sl@0	674	*/
sl@0	675	class TLibraryUnloadedInfo
sl@0	676	{
sl@0	677	public:
sl@0	678	/** The name of the file that the library was loaded from. */
sl@0	679	TUint8 iFileName[KMaxName];
sl@0	680	/** Contains the length in bytes of the initialised data in iFileName. */
sl@0	681	TInt iFileNameLength;
sl@0	682	};
sl@0	683
sl@0	684	/**
sl@0	685	* Enum to represent the context of a user trace message
sl@0	686	*/
sl@0	687	enum TUserTraceMessageContext
sl@0	688	{
sl@0	689	ESingleMessage = 0x1, /** Indicates this message is the only one corresponding to a given user trace */
sl@0	690	EMultiStart = 0x2, /** Indicates this message is the start of a user trace which consists of multiple messages */
sl@0	691	EMultiMid = 0x3, /** Indicates this message is one in a series of user trace messages */
sl@0	692	EMultiEnd = 0x4, /** Indicates this message is the last in a series of user trace messages */
sl@0	693	/**
sl@0	694	@internalTechnology
sl@0	695	A debug agent should find the number of core tags from the DFBlock rather than this enumerator.
sl@0	696	*/
sl@0	697	ELast = 0x5
sl@0	698	};
sl@0	699
sl@0	700	/**
sl@0	701	* Event specific information returned as part of a TEventInfo object
sl@0	702	* when a user trace event occurs.
sl@0	703	*/
sl@0	704	class TUserTraceInfo
sl@0	705	{
sl@0	706	public:
sl@0	707	/** The user trace text */
sl@0	708	TUint8 iUserTraceText[TUserTraceSize];
sl@0	709
sl@0	710	/** User trace text length */
sl@0	711	TInt iUserTraceLength;
sl@0	712
sl@0	713	/** The context of the message */
sl@0	714	TUserTraceMessageContext iMessageStatus;
sl@0	715	};
sl@0	716
sl@0	717
sl@0	718	/**
sl@0	719	Structure used to store information about an event. An object of this type
sl@0	720	is passed as an argument to the RSecuritySvrSession::GetEvent function,
sl@0	721	and is filled in by the debug driver, and returned to the agent, when a
sl@0	722	relevant event occurs.
sl@0	723
sl@0	724	The debug functionality block contains the size in bytes of the data that
sl@0	725	the driver will return when a GetEvent call is issued. A debug agent should
sl@0	726	ensure that this value equals the size of this TEventInfo object to ensure
sl@0	727	that a compatible debug driver is being used. The value is stored as
sl@0	728	EApiConstantsTEventInfoSize in the TFunctionalityApiConstants block.
sl@0	729
sl@0	730	@see RSecuritySvrSession::GetDebugFunctionality
sl@0	731	@see RSecuritySvrSession::GetEvent
sl@0	732	*/
sl@0	733	class TEventInfo
sl@0	734	{
sl@0	735	public:
sl@0	736
sl@0	737	/** Constructor sets all elements to default values. */
sl@0	738	inline TEventInfo() { Reset(); };
sl@0	739
sl@0	740	/** Resets all values to default values. */
sl@0	741	inline void Reset()
sl@0	742	{
sl@0	743	iProcessId = 0;
sl@0	744	iProcessIdValid = EFalse;
sl@0	745	iThreadId = 0;
sl@0	746	iThreadIdValid = EFalse;
sl@0	747	iEventType = (TEventType)NULL;
sl@0	748	};
sl@0	749
sl@0	750	public:
sl@0	751
sl@0	752	/** The process ID of the process which the event occurred in. */
sl@0	753	TUint64 iProcessId;
sl@0	754	/** The thread ID of the thread which the event occurred in. */
sl@0	755	TUint64 iThreadId;
sl@0	756	/** Has value ETrue if iProcessId is valid, EFalse otherwise. */
sl@0	757	TUint8 iProcessIdValid;
sl@0	758	/** Has value ETrue if iThreadId is valid, EFalse otherwise. */
sl@0	759	TUint8 iThreadIdValid;
sl@0	760	/** Indicates the type of the event. This type should be used to determine
sl@0	761	the type of the information stored in the union which is part of this class. */
sl@0	762	TEventType iEventType;
sl@0	763	union
sl@0	764	{
sl@0	765	/** Information which is specific to the break point event. */
sl@0	766	TThreadBreakPointInfo iThreadBreakPointInfo;
sl@0	767	/** Information which is specific to the software exception event. */
sl@0	768	TThreadSwExceptionInfo iThreadSwExceptionInfo;
sl@0	769	/** Information which is specific to the hardware exception event. */
sl@0	770	TThreadHwExceptionInfo iThreadHwExceptionInfo;
sl@0	771	/** Information which is specific to the thread kill event. */
sl@0	772	TThreadKillInfo iThreadKillInfo;
sl@0	773	/** Information which is specific to the library loaded event. */
sl@0	774	TLibraryLoadedInfo iLibraryLoadedInfo;
sl@0	775	/** Information which is specific to the library unloaded event. */
sl@0	776	TLibraryUnloadedInfo iLibraryUnloadedInfo;
sl@0	777	/** Information which is specific to the user trace event. */
sl@0	778	TUserTraceInfo iUserTraceInfo;
sl@0	779	/** Information which is specific to the start thread event. */
sl@0	780	TStartThreadInfo iStartThreadInfo;
sl@0	781	/** Information which is specific to the Add Process event. */
sl@0	782	TAddProcessInfo iAddProcessInfo;
sl@0	783	/** Information which is specific to the Remove Process event. */
sl@0	784	TRemoveProcessInfo iRemoveProcessInfo;
sl@0	785	};
sl@0	786	};
sl@0	787
sl@0	788	/**
sl@0	789	@internalComponent
sl@0	790	*/
sl@0	791	class TProcessInfo
sl@0	792	{
sl@0	793	public:
sl@0	794
sl@0	795	inline TProcessInfo() { Reset(); }
sl@0	796
sl@0	797	inline TProcessInfo(TUint32 aId, TUint32 aCodeAddress, TUint32 aCodeSize, TUint32 aDataAddress)
sl@0	798	: iId(aId),
sl@0	799	iCodeAddress(aCodeAddress),
sl@0	800	iCodeSize(aCodeSize),
sl@0	801	iDataAddress(aDataAddress) { }
sl@0	802
sl@0	803	inline void Reset()
sl@0	804	{
sl@0	805	iId = 0;
sl@0	806	iCodeAddress = 0;
sl@0	807	iCodeSize = 0;
sl@0	808	iDataAddress = 0;
sl@0	809	}
sl@0	810
sl@0	811	public:
sl@0	812
sl@0	813	TUint32 iId;
sl@0	814	TUint32 iCodeAddress;
sl@0	815	TUint32 iCodeSize;
sl@0	816	TUint32 iDataAddress;
sl@0	817	};
sl@0	818
sl@0	819	/* Other functionality may be defined here later */
sl@0	820
sl@0	821	/**
sl@0	822	Represents a register id value, in the terms of the Symbian ELF format:
sl@0	823	- bits 0-7 define the class
sl@0	824	- bits 8-15 define the rd_id
sl@0	825	- bits 16-31 define the rd_sub_id
sl@0	826
sl@0	827	Both the core registers (TFunctionalityRegister type) and the coprocessor registers
sl@0	828	follow this identifier scheme.
sl@0	829	*/
sl@0	830	typedef TUint32 TRegisterInfo;
sl@0	831
sl@0	832	/**
sl@0	833	Enum representing the status flags which could be returned from a register
sl@0	834	access call.
sl@0	835	*/
sl@0	836	enum TRegisterFlag
sl@0	837	{
sl@0	838	/**
sl@0	839	Default value, a register access call will never return this value
sl@0	840	*/
sl@0	841	ENotSet = 0,
sl@0	842	/**
sl@0	843	Would be returned if the register is supported by the debug driver but the kernel cannot access the register
sl@0	844	*/
sl@0	845	EInValid = 1,
sl@0	846	/**
sl@0	847	Would be returned if the register could be accessed correctly
sl@0	848	*/
sl@0	849	EValid = 2,
sl@0	850	/**
sl@0	851	Would be returned if the register is not supported by the debug driver
sl@0	852	*/
sl@0	853	ENotSupported = 3,
sl@0	854	/**
sl@0	855	Would be returned if a non-4 byte register value was requested
sl@0	856	*/
sl@0	857	EBadSize = 4
sl@0	858	};
sl@0	859
sl@0	860	/**
sl@0	861	Enum representing the different ARM CPU instruction set architectures.
sl@0	862	*/
sl@0	863	enum TArchitectureMode
sl@0	864	{
sl@0	865	/** Represents the ARM CPU architecture. */
sl@0	866	EArmMode = 1,
sl@0	867	/** Represents the Thumb CPU architecture. */
sl@0	868	EThumbMode = 2,
sl@0	869	/**
sl@0	870	Represents the Thumb2 CPU architecture.
sl@0	871	@prototype
sl@0	872	*/
sl@0	873	EThumb2EEMode = 3
sl@0	874	};
sl@0	875
sl@0	876	/**
sl@0	877	Used as an identifier for breakpoints set by the RSecuritySvrSession::SetBreak function.
sl@0	878	@see RSecuritySvrSession
sl@0	879	*/
sl@0	880	typedef TInt32 TBreakId;
sl@0	881
sl@0	882	/**
sl@0	883	Specifies the type of a code segment.
sl@0	884	@see TCodeSegListEntry
sl@0	885	*/
sl@0	886	enum TCodeSegType
sl@0	887	{
sl@0	888	EUnknownCodeSegType = 0, /*< Signifies an unknown code segment type. /
sl@0	889	EExeCodeSegType = 1, /*< Signifies a code segment belonging to an executable. /
sl@0	890	EDllCodeSegType = 2 /*< Signifies a code segment belonging to a library. /
sl@0	891	};
sl@0	892
sl@0	893	/**
sl@0	894	Structure used for extracting data from a descriptor returned by a call to
sl@0	895	RSecuritySvrSession::GetList() when GetList() is called with TListId::ECodeSegs
sl@0	896	as the first argument.
sl@0	897
sl@0	898	@see RSecuritySvrSession::GetList()
sl@0	899
sl@0	900	@code
sl@0	901	//buffer is a TDesC8 containing 4-byte aligned TCodeSegListEntry objects
sl@0	902	//create a pointer to the start of the data
sl@0	903	TUint8* ptr = (TUint8*)buffer.Ptr();
sl@0	904	//create a pointer to the end of the data
sl@0	905	const TUint8* ptrEnd = ptr + buffer.Length();
sl@0	906	while(ptr < ptrEnd)
sl@0	907	{
sl@0	908	//cast the pointer to be a TCodeSegListEntry object
sl@0	909	TCodeSegListEntry& entry = (TCodeSegListEntry)ptr;
sl@0	910	//use the TCodeSegListEntry pointer, i.e.
sl@0	911	TUint16 nameLength = entry.iNameLength;
sl@0	912	TPtr name(&(entry.iName[0]), nameLength, nameLength);
sl@0	913	// move ptr on to point to the next TCodeSegListEntry object
sl@0	914	ptr += Align4(entry.GetSize());
sl@0	915	}
sl@0	916	@endcode
sl@0	917	*/
sl@0	918	class TCodeSegListEntry
sl@0	919	{
sl@0	920	public:
sl@0	921	TInt GetSize() const;
sl@0	922	public:
sl@0	923	/**
sl@0	924	Address of the start of the code segment.
sl@0	925	*/
sl@0	926	TUint32 iCodeBase;
sl@0	927	/**
sl@0	928	Size of the code segment.
sl@0	929	*/
sl@0	930	TUint32 iCodeSize;
sl@0	931	/**
sl@0	932	Size of the const data segment
sl@0	933	*/
sl@0	934	TUint32 iConstDataSize;
sl@0	935	/**
sl@0	936	Address of the initialised data
sl@0	937	*/
sl@0	938	TUint32 iInitialisedDataBase;
sl@0	939	/**
sl@0	940	Size of the initialised data
sl@0	941	*/
sl@0	942	TUint32 iInitialisedDataSize;
sl@0	943	/**
sl@0	944	Size of the uninitialised data
sl@0	945	*/
sl@0	946	TUint32 iUninitialisedDataSize;
sl@0	947	/**
sl@0	948	Boolean indicating whether the code segment is execute in place
sl@0	949	*/
sl@0	950	TBool iIsXip;
sl@0	951	/**
sl@0	952	Indicates whether the code segment is from an executable or a dll, or neither
sl@0	953	*/
sl@0	954	TCodeSegType iCodeSegType;
sl@0	955	/** Uid3 of this segment. */
sl@0	956	TUint32 iUid3;
sl@0	957	/** Currently unused element. May be used in future to aid maintaining compatibility. */
sl@0	958	TUint32 iSpare2;
sl@0	959	/**
sl@0	960	Length of the code segment's name
sl@0	961	*/
sl@0	962	TUint16 iNameLength;
sl@0	963	/**
sl@0	964	First two bytes of the code segment's name, the name should be considered to
sl@0	965	extend past the end of the TCodeSegListEntry structure to a length
sl@0	966	corresponding to iNameLength
sl@0	967	*/
sl@0	968	TUint16 iName[1];
sl@0	969	};
sl@0	970
sl@0	971	/**
sl@0	972	Returns the size of the TCodeSegListEntry, including the file name length
sl@0	973
sl@0	974	@return the size, in bytes, of the TCodeSegListEntry and the code segment's
sl@0	975	file name
sl@0	976	*/
sl@0	977	inline TInt TCodeSegListEntry::GetSize() const
sl@0	978	{
sl@0	979	return sizeof(TCodeSegListEntry) - sizeof(iName) + (2 * iNameLength);
sl@0	980	}
sl@0	981
sl@0	982	/**
sl@0	983	Structure used for extracting data from a descriptor returned by a call to
sl@0	984	RSecuritySvrSession::GetList() when GetList() is called with TListId::EXipLibraries
sl@0	985	as the first argument.
sl@0	986
sl@0	987	@see RSecuritySvrSession::GetList()
sl@0	988
sl@0	989	@code
sl@0	990	//buffer is a TDesC8 containing 4-byte aligned TXipLibraryListEntry objects
sl@0	991	//create a pointer to the start of the data
sl@0	992	TUint8* ptr = (TUint8*)buffer.Ptr();
sl@0	993	//create a pointer to the end of the data
sl@0	994	const TUint8* ptrEnd = ptr + buffer.Length();
sl@0	995	while(ptr < ptrEnd)
sl@0	996	{
sl@0	997	//cast the pointer to be a TXipLibraryListEntry object
sl@0	998	TXipLibraryListEntry& entry = (TXipLibraryListEntry)ptr;
sl@0	999	//use the TXipLibraryListEntry pointer, i.e.
sl@0	1000	TUint16 nameLength = entry.iNameLength;
sl@0	1001	TPtr name(&(entry.iName[0]), nameLength, nameLength);
sl@0	1002	// move ptr on to point to the next TXipLibraryListEntry object
sl@0	1003	ptr += Align4(entry.GetSize());
sl@0	1004	}
sl@0	1005	@endcode
sl@0	1006	*/
sl@0	1007	class TXipLibraryListEntry
sl@0	1008	{
sl@0	1009	public:
sl@0	1010	TInt GetSize() const;
sl@0	1011	public:
sl@0	1012	/**
sl@0	1013	Address of the start of the library's code segment.
sl@0	1014	*/
sl@0	1015	TUint32 iCodeBase;
sl@0	1016	/**
sl@0	1017	Size of the code segment.
sl@0	1018	*/
sl@0	1019	TUint32 iCodeSize;
sl@0	1020	/**
sl@0	1021	Size of the const data segment
sl@0	1022	*/
sl@0	1023	TUint32 iConstDataSize;
sl@0	1024	/**
sl@0	1025	Address of the initialised data
sl@0	1026	*/
sl@0	1027	TUint32 iInitialisedDataBase;
sl@0	1028	/**
sl@0	1029	Size of the initialised data
sl@0	1030	*/
sl@0	1031	TUint32 iInitialisedDataSize;
sl@0	1032	/**
sl@0	1033	Size of the uninitialised data
sl@0	1034	*/
sl@0	1035	TUint32 iUninitialisedDataSize;
sl@0	1036	/** Currently unused element. May be used in future to aid maintaining compatibility. */
sl@0	1037	TUint32 iSpare1;
sl@0	1038	/** Currently unused element. May be used in future to aid maintaining compatibility. */
sl@0	1039	TUint32 iSpare2;
sl@0	1040	/**
sl@0	1041	Length of the library's name
sl@0	1042	*/
sl@0	1043	TUint16 iNameLength;
sl@0	1044	/**
sl@0	1045	First two bytes of the code segment's name, the name should be considered to
sl@0	1046	extend past the end of the TXipLibraryListEntry structure to a length
sl@0	1047	corresponding to iNameLength
sl@0	1048	*/
sl@0	1049	TUint16 iName[1];
sl@0	1050	};
sl@0	1051
sl@0	1052	/**
sl@0	1053	Returns the size of the TXipLibraryListEntry, including the file name length
sl@0	1054
sl@0	1055	@return the size, in bytes, of the TXipLibraryListEntry and the library's
sl@0	1056	file name
sl@0	1057	*/
sl@0	1058	inline TInt TXipLibraryListEntry::GetSize() const
sl@0	1059	{
sl@0	1060	return sizeof(TXipLibraryListEntry) - sizeof(iName) + (2 * iNameLength);
sl@0	1061	}
sl@0	1062
sl@0	1063	/**
sl@0	1064	Structure used for extracting data from a descriptor returned by a call to
sl@0	1065	RSecuritySvrSession::GetList() when GetList() is called with TListId::EExecutables
sl@0	1066	as the first argument.
sl@0	1067
sl@0	1068	@see RSecuritySvrSession::GetList()
sl@0	1069
sl@0	1070	@code
sl@0	1071	//buffer is a TDesC8 containing 4-byte aligned TExecutablesListEntry objects
sl@0	1072	//create a pointer to the start of the data
sl@0	1073	TUint8* ptr = (TUint8*)buffer.Ptr();
sl@0	1074	//create a pointer to the end of the data
sl@0	1075	const TUint8* ptrEnd = ptr + buffer.Length();
sl@0	1076	while(ptr < ptrEnd)
sl@0	1077	{
sl@0	1078	//cast the pointer to be a TExecutablesListEntry object
sl@0	1079	TExecutablesListEntry& entry = (TExecutablesListEntry)ptr;
sl@0	1080	//use the TExecutablesListEntry pointer, i.e.
sl@0	1081	TUint16 nameLength = entry.iNameLength;
sl@0	1082	TPtr name(&(entry.iName[0]), nameLength, nameLength);
sl@0	1083	// move ptr on to point to the next TExecutablesListEntry object
sl@0	1084	ptr += Align4(entry.GetSize());
sl@0	1085	}
sl@0	1086	@endcode
sl@0	1087	*/
sl@0	1088	class TExecutablesListEntry
sl@0	1089	{
sl@0	1090	public:
sl@0	1091	TInt GetSize() const;
sl@0	1092	public:
sl@0	1093	/**
sl@0	1094	Indicates whether an agent has registered to actively debug the executable,
sl@0	1095	a non-zero value indicates that an agent has attached.
sl@0	1096	*/
sl@0	1097	TUint8 iIsActivelyDebugged;
sl@0	1098	/**
sl@0	1099	Indicates whether any agents have registered to passively debug the executable,
sl@0	1100	a non-zero value indicates that at least one agent is attached passively
sl@0	1101	*/
sl@0	1102	TUint8 iIsPassivelyDebugged;
sl@0	1103	/** Currently unused element. May be used in future to aid maintaining compatibility. */
sl@0	1104	TUint32 iSpare1;
sl@0	1105	/** Currently unused element. May be used in future to aid maintaining compatibility. */
sl@0	1106	TUint32 iSpare2;
sl@0	1107	/**
sl@0	1108	Length of the executable's name
sl@0	1109	*/
sl@0	1110	TUint16 iNameLength;
sl@0	1111	/**
sl@0	1112	First two bytes of the executable's name, the name should be considered to
sl@0	1113	extend past the end of the TExecutablesListEntry structure to a length
sl@0	1114	corresponding to iNameLength
sl@0	1115	*/
sl@0	1116	TUint16 iName[1];
sl@0	1117	};
sl@0	1118
sl@0	1119	/**
sl@0	1120	Returns the size of the TExecutablesListEntry, including the file name length
sl@0	1121
sl@0	1122	@return the size, in bytes, of the TExecutablesListEntry and the executable's
sl@0	1123	file name
sl@0	1124	*/
sl@0	1125	inline TInt TExecutablesListEntry::GetSize() const
sl@0	1126	{
sl@0	1127	return sizeof(TExecutablesListEntry) - sizeof(iName) + (2*iNameLength);
sl@0	1128	}
sl@0	1129
sl@0	1130	/**
sl@0	1131	Structure used for extracting data from a descriptor returned by a call to
sl@0	1132	RSecuritySvrSession::GetList() when GetList() is called with TListId::EProcesses
sl@0	1133	as the first argument.
sl@0	1134
sl@0	1135	@see RSecuritySvrSession::GetList()
sl@0	1136
sl@0	1137	@code
sl@0	1138	//buffer is a TDesC8 containing 4-byte aligned TProcessListEntry objects
sl@0	1139	//create a pointer to the start of the data
sl@0	1140	TUint8* ptr = (TUint8*)buffer.Ptr();
sl@0	1141	//create a pointer to the end of the data
sl@0	1142	const TUint8* ptrEnd = ptr + buffer.Length();
sl@0	1143	while(ptr < ptrEnd)
sl@0	1144	{
sl@0	1145	//cast the pointer to be a TProcessListEntry object
sl@0	1146	TProcessListEntry& entry = (TProcessListEntry)ptr;
sl@0	1147	//use the TProcessListEntry pointer, i.e.
sl@0	1148	TUint16 fileNameLength = entry.iFileNameLength;
sl@0	1149	TPtr name(&(entry.iNames[0]), fileNameLength, fileNameLength);
sl@0	1150	// move ptr on to point to the next TProcessListEntry object
sl@0	1151	ptr += Align4(entry.GetSize());
sl@0	1152	}
sl@0	1153	@endcode
sl@0	1154	*/
sl@0	1155	class TProcessListEntry
sl@0	1156	{
sl@0	1157	public:
sl@0	1158	TInt GetSize() const;
sl@0	1159
sl@0	1160	public:
sl@0	1161	/** Process ID */
sl@0	1162	TUint64 iProcessId;
sl@0	1163
sl@0	1164	/** The Uid3 of the process */
sl@0	1165	TUint32 iUid3;
sl@0	1166
sl@0	1167	/**
sl@0	1168	* Process Attributes
sl@0	1169	* @see DProcess::TProcessAttributes
sl@0	1170	*/
sl@0	1171	TInt iAttributes;
sl@0	1172
sl@0	1173	/**
sl@0	1174	* Length of fully qualified file name of the process in bytes. Note that this
sl@0	1175	* entry may be 0 if the process is in the process of shutting down.
sl@0	1176	*/
sl@0	1177	TUint16 iFileNameLength;
sl@0	1178
sl@0	1179	/**
sl@0	1180	* Length of current dynamic name of the process in bytes
sl@0	1181	*/
sl@0	1182	TUint16 iDynamicNameLength;
sl@0	1183
sl@0	1184	/**
sl@0	1185	* First two bytes of the process' file name, the name should be considered to
sl@0	1186	* extend past the end of the TProcessListEntry structure to a length
sl@0	1187	* corresponding to iFileNameLength. Directly after the data corresponding to the
sl@0	1188	* file name, the dynamic name is stored with a length of iDynamicNameLength characters.
sl@0	1189	* Note that these names are not null terminated and are concatenated directly after each other.
sl@0	1190	*
sl@0	1191	* @code
sl@0	1192	* TProcessListEntry& entry; // entry is a reference to a TProcessListEntry
sl@0	1193	*
sl@0	1194	* //get the file name..
sl@0	1195	* TPtr fileName(&(entry.iNames[0]), iFileNameLength, iFileNameLength);
sl@0	1196	*
sl@0	1197	* //get the dynamic name length..
sl@0	1198	* TPtr dynamicName(&(entry.iNames[0]) + iFileNameLength, iDynamicNameLength, iDynamicNameLength);
sl@0	1199	* @endcode
sl@0	1200	*/
sl@0	1201	TUint16 iNames[1];
sl@0	1202	};
sl@0	1203
sl@0	1204	/**
sl@0	1205	Returns the size of the TProcessListEntry, including the file name length and the
sl@0	1206	dynamic name length
sl@0	1207
sl@0	1208	@return the size, in bytes, of the TProcessListEntry and the executable's
sl@0	1209	file name file name and dynamic name
sl@0	1210	*/
sl@0	1211	inline TInt TProcessListEntry::GetSize() const
sl@0	1212	{
sl@0	1213	return sizeof(TProcessListEntry) - sizeof(iNames) + (2 * (iFileNameLength + iDynamicNameLength));
sl@0	1214	}
sl@0	1215
sl@0	1216	/**
sl@0	1217	Structure used for extracting data from a descriptor returned by a call to
sl@0	1218	RSecuritySvrSession::GetList() when GetList() is called with TListId::EThreads
sl@0	1219	as the first argument.
sl@0	1220
sl@0	1221	@see RSecuritySvrSession::GetList()
sl@0	1222
sl@0	1223	@code
sl@0	1224	//buffer is a TDesC8 containing 4-byte aligned TThreadListEntry objects
sl@0	1225	//create a pointer to the start of the data
sl@0	1226	TUint8* ptr = (TUint8*)buffer.Ptr();
sl@0	1227	//create a pointer to the end of the data
sl@0	1228	const TUint8* ptrEnd = ptr + buffer.Length();
sl@0	1229	while(ptr < ptrEnd)
sl@0	1230	{
sl@0	1231	//cast the pointer to be a TThreadListEntry object
sl@0	1232	TThreadListEntry& entry = (TThreadListEntry)ptr;
sl@0	1233	//use the TThreadListEntry pointer, i.e.
sl@0	1234	TUint16 nameLength = entry.iNameLength;
sl@0	1235	TPtr name(&(entry.iName[0]), nameLength, nameLength);
sl@0	1236	// move ptr on to point to the next TThreadListEntry object
sl@0	1237	ptr += Align4(entry.GetSize());
sl@0	1238	}
sl@0	1239	@endcode
sl@0	1240	*/
sl@0	1241	class TThreadListEntry
sl@0	1242	{
sl@0	1243	public:
sl@0	1244	TInt GetSize() const;
sl@0	1245	public:
sl@0	1246	/**
sl@0	1247	Thread ID
sl@0	1248	*/
sl@0	1249	TUint64 iThreadId;
sl@0	1250	/**
sl@0	1251	Process ID
sl@0	1252	*/
sl@0	1253	TUint64 iProcessId;
sl@0	1254	/**
sl@0	1255	Address of the base of the supervisor stack
sl@0	1256	*/
sl@0	1257	TUint32 iSupervisorStackBase;
sl@0	1258	/**
sl@0	1259	Size of the supervisor stack
sl@0	1260	*/
sl@0	1261	TUint32 iSupervisorStackSize;
sl@0	1262	/**
sl@0	1263	Non-zero if iSupervisorStackBase has been set correctly
sl@0	1264	*/
sl@0	1265	TUint8 iSupervisorStackBaseValid;
sl@0	1266	/**
sl@0	1267	Non-zero if iSupervisorStackSize has been set correctly
sl@0	1268	*/
sl@0	1269	TUint8 iSupervisorStackSizeValid;
sl@0	1270	/**
sl@0	1271	Address of the thread's supervisor stack pointer
sl@0	1272	*/
sl@0	1273	TUint32 iSupervisorStackPtr;
sl@0	1274	/**
sl@0	1275	Indicator of whether the value returned as iSupervisorStackPtr is valid.
sl@0	1276	It is necessary, but not necessarily sufficient, that the thread be suspended
sl@0	1277	for a valid value to be returned. This may be removed from the final API and
sl@0	1278	the value would be extracted instead via the ReadRegisters type calls.
sl@0	1279	*/
sl@0	1280	TRegisterFlag iSupervisorStackPtrValid;
sl@0	1281	/** Currently unused element. May be used in future to aid maintaining compatibility. */
sl@0	1282	TUint32 iSpare1;
sl@0	1283	/** Currently unused element. May be used in future to aid maintaining compatibility. */
sl@0	1284	TUint32 iSpare2;
sl@0	1285	/**
sl@0	1286	The length of the thread's name
sl@0	1287	*/
sl@0	1288	TUint16 iNameLength;
sl@0	1289	/**
sl@0	1290	First two bytes of the thread's name, the name should be considered to
sl@0	1291	extend past the end of the TThreadListEntry structure to a length
sl@0	1292	corresponding to iNameLength
sl@0	1293	*/
sl@0	1294	TUint16 iName[1];
sl@0	1295	};
sl@0	1296
sl@0	1297	/**
sl@0	1298	Returns the size of the TThreadListEntry, including the name length
sl@0	1299
sl@0	1300	@return the size, in bytes, of the TExecutablesListEntry and the thread's name
sl@0	1301	*/
sl@0	1302	inline TInt TThreadListEntry::GetSize() const
sl@0	1303	{
sl@0	1304	return sizeof(TThreadListEntry) - sizeof(iName) + (2 * iNameLength);
sl@0	1305	}
sl@0	1306
sl@0	1307	/**
sl@0	1308	Denotes which list type to return from a RSecuritySvrSession::GetList() call
sl@0	1309
sl@0	1310	@see RSecuritySvrSession::GetList()
sl@0	1311	*/
sl@0	1312	enum TListId
sl@0	1313	{
sl@0	1314	/**
sl@0	1315	Indicates that the GetList() call should return a list of the processes in
sl@0	1316	the system. The returned buffer will contain an array of 4-byte aligned
sl@0	1317	TProcessListEntry objects.
sl@0	1318
sl@0	1319	@see TProcessListEntry
sl@0	1320	*/
sl@0	1321	EProcesses = 0,
sl@0	1322	/**
sl@0	1323	Indicates that the GetList() call should return a list of the threads in
sl@0	1324	the system. The returned buffer will contain an array of 4-byte aligned
sl@0	1325	TThreadListEntry objects.
sl@0	1326
sl@0	1327	@see TThreadListEntry
sl@0	1328	*/
sl@0	1329	EThreads = 1,
sl@0	1330	/**
sl@0	1331	Indicates that the GetList() call should return a list of the code segments in
sl@0	1332	the system. The returned buffer will contain an array of 4-byte aligned
sl@0	1333	TCodeSegListEntry objects.
sl@0	1334
sl@0	1335	@see TCodeSegListEntry
sl@0	1336	*/
sl@0	1337	ECodeSegs = 2,
sl@0	1338	/**
sl@0	1339	Indicates that the GetList() call should return a list of the XIP libraries in
sl@0	1340	the system. The returned buffer will contain an array of 4-byte aligned
sl@0	1341	EXipLibraries objects.
sl@0	1342
sl@0	1343	@see EXipLibraries
sl@0	1344	*/
sl@0	1345	EXipLibraries = 3,
sl@0	1346	/**
sl@0	1347	Indicates that the GetList() call should return a list of the executables in
sl@0	1348	the system. The returned buffer will contain an array of 4-byte aligned
sl@0	1349	EExecutables objects.
sl@0	1350
sl@0	1351	@see EExecutables
sl@0	1352	*/
sl@0	1353	EExecutables = 4,
sl@0	1354	/**
sl@0	1355	Indicates that the GetList() call should return a list of the logical devices in the system.
sl@0	1356	*/
sl@0	1357	ELogicalDevices = 5,
sl@0	1358	/**
sl@0	1359	Indicates that the GetList() call should return a list of the mutexes in the system.
sl@0	1360	*/
sl@0	1361	EMutexes = 6,
sl@0	1362	/**
sl@0	1363	Indicates that the GetList() call should return a list of the servers in the system.
sl@0	1364	*/
sl@0	1365	EServers = 7,
sl@0	1366	/**
sl@0	1367	Indicates that the GetList() call should return a list of the sessions in the system.
sl@0	1368	*/
sl@0	1369	ESessions = 8,
sl@0	1370	/**
sl@0	1371	Indicates that the GetList() call should return a list of the semaphores in the system.
sl@0	1372	*/
sl@0	1373	ESemaphores = 9,
sl@0	1374	/**
sl@0	1375	Indicates that the GetList() call should return a list of the chunks in the system.
sl@0	1376	*/
sl@0	1377	EChunks = 10,
sl@0	1378
sl@0	1379	/**
sl@0	1380	Provides a complete list of all the breakpoints in the system and their
sl@0	1381	current state.
sl@0	1382
sl@0	1383	@see EBreakpoints
sl@0	1384	*/
sl@0	1385	EBreakpoints = 11,
sl@0	1386
sl@0	1387	/**
sl@0	1388	The following are for the possible use of kernel-side debug and SMP breakpoint
sl@0	1389	manipulation.
sl@0	1390	*/
sl@0	1391	ESetBreak = 12,
sl@0	1392	ERemoveBreak = 13,
sl@0	1393	EModifyBreak = 14,
sl@0	1394
sl@0	1395	/**
sl@0	1396	* Provides static information of the system
sl@0	1397	*/
sl@0	1398	EStaticInfo = 15,
sl@0	1399
sl@0	1400	/** Last listing enum. */
sl@0	1401	EListLast
sl@0	1402	};
sl@0	1403
sl@0	1404	/**
sl@0	1405	Bit field values denoting the scope of a listing.
sl@0	1406
sl@0	1407	In the debug functionality block, the TTag::iValue element which is returned for a listing tag
sl@0	1408	should be considered as a union of the supported values from this enumeration for that listing.
sl@0	1409	*/
sl@0	1410	enum TListScope
sl@0	1411	{
sl@0	1412	EScopeNone = 0x0, /*< Corresponds to no scope for a listing. equivalent to not supported /
sl@0	1413	EScopeGlobal= 0x1, /*< Corresponds to a global scope for a listing. /
sl@0	1414	EScopeProcessSpecific = 0x2, /*< Corresponds to a process specific scope for a listing. /
sl@0	1415	EScopeThreadSpecific = 0x4 /*< Corresponds to a thread specific scope for a listing. /
sl@0	1416	};
sl@0	1417
sl@0	1418	/**
sl@0	1419	@internalComponent
sl@0	1420
sl@0	1421	Interface constructor for passing IPC data for the GetList call.
sl@0	1422	*/
sl@0	1423	class TListDetails
sl@0	1424	{
sl@0	1425	public:
sl@0	1426	TListDetails(const TListId aListId, const TListScope aListScope, TUint64 aTargetId=0)
sl@0	1427	: iListId(aListId),
sl@0	1428	iListScope(aListScope),
sl@0	1429	iTargetId(aTargetId) {}
sl@0	1430	public:
sl@0	1431	TListId iListId;
sl@0	1432	TListScope iListScope;
sl@0	1433	TUint64 iTargetId;
sl@0	1434	};
sl@0	1435
sl@0	1436	/** Debug Security Server Secure ID */
sl@0	1437	const TUid KUidDebugSecurityServer = { 0x102834E2 };
sl@0	1438
sl@0	1439	} // end of Debug namespace declaration
sl@0	1440
sl@0	1441	// the remaining functionality in this file is intended for use on user side only
sl@0	1442	#ifndef __KERNEL_MODE__
sl@0	1443
sl@0	1444	#include <e32std.h>
sl@0	1445
sl@0	1446	// API definition for Debug namespace appears elsewhere in this file.
sl@0	1447	namespace Debug {
sl@0	1448
sl@0	1449	/** The name of the Debug Security Server. */
sl@0	1450	_LIT(KSecurityServerName,"DebugSecurityServer");
sl@0	1451
sl@0	1452	// A version must be specified when creating a session with the server
sl@0	1453	/** The Debug Security Server's major version number. */
sl@0	1454	const TUint KDebugServMajorVersionNumber=2;
sl@0	1455	/** The Debug Security Server's minor version number. */
sl@0	1456	const TUint KDebugServMinorVersionNumber=4;
sl@0	1457	/** The Debug Security Server's patch version number. */
sl@0	1458	const TUint KDebugServPatchVersionNumber=0;
sl@0	1459
sl@0	1460	/**
sl@0	1461	Denotes how memory should be accessed
sl@0	1462	*/
sl@0	1463	enum TAccess
sl@0	1464	{
sl@0	1465	EAccess8 = 1, /*< Currently unsupported, signifies 8 bit access. /
sl@0	1466	EAccess16 = 2, /*< Currently unsupported, signifies 16 bit access. /
sl@0	1467	EAccess32 = 4 /*< Signifies 32 bit access. /
sl@0	1468	};
sl@0	1469
sl@0	1470	/**
sl@0	1471	Denotes how data should be interpreted
sl@0	1472	*/
sl@0	1473	enum TEndianess
sl@0	1474	{
sl@0	1475	EEndLE8 = 0, /*< Signifies 8 bit little-endian. /
sl@0	1476	EEndBE8 = 1, /*< Currently unsupported, signifies 8 bit big-endian. /
sl@0	1477	EEndBE32 = 2 /*< Currently unsupported, signifies 32 bit big-endian. /
sl@0	1478	};
sl@0	1479
sl@0	1480	/**
sl@0	1481	Structure used to store information about a memory operation
sl@0	1482
sl@0	1483	@internalComponent
sl@0	1484	*/
sl@0	1485	class TMemoryInfo
sl@0	1486	{
sl@0	1487	public:
sl@0	1488
sl@0	1489	TMemoryInfo(TUint32 aAddress=0, TUint32 aLength=0, TAccess aAccess=EAccess32, TEndianess aEndianess=EEndLE8)
sl@0	1490	: iAddress(aAddress),
sl@0	1491	iSize(aLength),
sl@0	1492	iAccess(aAccess),
sl@0	1493	iEndianess(aEndianess)
sl@0	1494	{}
sl@0	1495
sl@0	1496	public:
sl@0	1497
sl@0	1498	/**
sl@0	1499	Address to start reading/writing memory
sl@0	1500	*/
sl@0	1501	TUint32 iAddress;
sl@0	1502	/**
sl@0	1503	Number of bytes of memory to read/write
sl@0	1504	*/
sl@0	1505	TUint32 iSize;
sl@0	1506	/**
sl@0	1507	Access size for read/write
sl@0	1508	@see TAccess
sl@0	1509	*/
sl@0	1510	TAccess iAccess;
sl@0	1511	/**
sl@0	1512	Endianess to interpret data as
sl@0	1513	@see TEndianess
sl@0	1514	*/
sl@0	1515	TEndianess iEndianess;
sl@0	1516	};
sl@0	1517
sl@0	1518	/**
sl@0	1519	@internalComponent
sl@0	1520	*/
sl@0	1521	class TBreakInfo
sl@0	1522	{
sl@0	1523	public:
sl@0	1524	TUint32 iAddress;
sl@0	1525	TArchitectureMode iArchitectureMode;
sl@0	1526	};
sl@0	1527
sl@0	1528	/**
sl@0	1529	@internalComponent
sl@0	1530
sl@0	1531	Function codes (opcodes) used in message passing between client and server
sl@0	1532	in this header file and what arguments should be passed with each of these
sl@0	1533	*/
sl@0	1534	enum TDebugServRqst
sl@0	1535	{
sl@0	1536	EDebugServOpen = 1,
sl@0	1537	EDebugServClose = 2,
sl@0	1538	EDebugServSuspendThread = 3,
sl@0	1539	EDebugServResumeThread = 4,
sl@0	1540	EDebugServReadMemory = 5,
sl@0	1541	EDebugServWriteMemory = 6,
sl@0	1542	EDebugServSetBreak = 7,
sl@0	1543	EDebugServClearBreak = 8,
sl@0	1544	EDebugServModifyBreak = 9,
sl@0	1545	EDebugServGetEvent = 10,
sl@0	1546	EDebugServCancelGetEvent = 11,
sl@0	1547	EDebugServAttachExecutable = 12,
sl@0	1548	EDebugServDetachExecutable = 13,
sl@0	1549	EDebugServGetDebugFunctionalityBufSize = 14,
sl@0	1550	EDebugServGetDebugFunctionality = 15,
sl@0	1551	EDebugServReadRegisters = 16,
sl@0	1552	EDebugServWriteRegisters = 17,
sl@0	1553	EDebugServSetEventAction = 18,
sl@0	1554	EDebugServBreakInfo = 19,
sl@0	1555	EDebugServGetList = 20,
sl@0	1556	EDebugServStep = 21,
sl@0	1557	EDebugServSetProcessBreak = 22,
sl@0	1558	EDebugServProcessBreakInfo = 23,
sl@0	1559	EDebugServKillProcess = 24,
sl@0	1560	EDebugServModifyProcessBreak = 25,
sl@0	1561	EDebugServReadCrashFlash = 26,
sl@0	1562	EDebugServWriteCrashFlash = 27,
sl@0	1563	EDebugServEraseCrashFlash = 28,
sl@0	1564	EDebugServEraseEntireCrashFlash = 29,
sl@0	1565	};
sl@0	1566
sl@0	1567	/**
sl@0	1568	Client side API to debug security server (DSS). Interaction with the DSS should
sl@0	1569	be conducted through this class only.
sl@0	1570	*/
sl@0	1571	class RSecuritySvrSession : public RSessionBase
sl@0	1572	{
sl@0	1573	public:
sl@0	1574	RSecuritySvrSession();
sl@0	1575	TVersion Version() const;
sl@0	1576
sl@0	1577	TInt Close();
sl@0	1578
sl@0	1579	TInt AttachExecutable(const TDesC& aProcessName, TBool aPassive);
sl@0	1580	TInt DetachExecutable(const TDesC& aProcessName);
sl@0	1581
sl@0	1582	TInt GetDebugFunctionalityBufSize(TUint32* aBufSize);
sl@0	1583	TInt GetDebugFunctionality(TDes8& aBuffer);
sl@0	1584
sl@0	1585	TInt SuspendThread(const TThreadId aThreadId);
sl@0	1586	TInt ResumeThread(const TThreadId aThreadId);
sl@0	1587
sl@0	1588	TInt ReadMemory(const TThreadId aThreadId, const TUint32 aAddress, const TUint32 aLength, TDes8 &aData, const TAccess aAccessSize, const TEndianess aEndianess);
sl@0	1589	TInt WriteMemory(const TThreadId aThreadId, const TUint32 aAddress, const TUint32 aLength, const TDesC8 &aData, const TAccess aAccessSize, const TEndianess aEndianess);
sl@0	1590
sl@0	1591	TInt ReadRegisters(const TThreadId aThreadId, const TDesC8& aRegisterIds, TDes8& aRegisterValues, TDes8& aRegisterFlags);
sl@0	1592	TInt WriteRegisters(const TThreadId aThreadId, const TDesC8& aRegisterIds, const TDesC8& aRegisterValues, TDes8& aRegisterFlags);
sl@0	1593
sl@0	1594	void GetEvent(const TDesC& aExecutableName, TRequestStatus &aStatus, TDes8& aEventInfo);
sl@0	1595	TInt CancelGetEvent(const TDesC& aExecutableName);
sl@0	1596
sl@0	1597	TInt SetEventAction(const TDesC& aExecutableName, TEventType aEvent, TKernelEventAction aEventAction);
sl@0	1598
sl@0	1599	TInt SetBreak( TBreakId &aId, const TThreadId aThreadId, const TUint32 aAddress, const TArchitectureMode aArchitectureMode);
sl@0	1600	TInt ClearBreak(const TBreakId aBreakId);
sl@0	1601	TInt ModifyBreak(const TBreakId aBreakId, const TThreadId aThreadId, const TUint32 aAddress, const TArchitectureMode aArchitectureMode);
sl@0	1602	TInt BreakInfo(const TBreakId aBreakId, TThreadId& aThreadId, TUint32& aAddress, TArchitectureMode& aMode);
sl@0	1603	TInt SetProcessBreak( TBreakId &aId, const TProcessId aProcessId, const TUint32 aAddress, const TArchitectureMode aArchitectureMode);
sl@0	1604	TInt ProcessBreakInfo(const TBreakId aBreakId, TProcessId& aProcessId, TUint32& aAddress, TArchitectureMode& aMode);
sl@0	1605	TInt ModifyProcessBreak(const TBreakId aBreakId, const TProcessId aProcessId, const TUint32 aAddress, const TArchitectureMode aArchitectureMode);
sl@0	1606
sl@0	1607	TInt GetList(const TListId aListId, TDes8& aListData, TUint32& aDataSize);
sl@0	1608	TInt GetList(const TThreadId aThreadId, const TListId aListId, TDes8& aListData, TUint32& aDataSize);
sl@0	1609	TInt GetList(const TProcessId aProcessId, const TListId aListId, TDes8& aListData, TUint32& aDataSize);
sl@0	1610	TInt Step(const TThreadId aThreadId, TUint32 aNumSteps);
sl@0	1611	TInt KillProcess(const TProcessId aProcessId, const TInt aReason);
sl@0	1612	TInt ReadCrashLog(const TUint32 aPos, TDes8& aData, const TUint32 aDataSize);
sl@0	1613	TInt WriteCrashConfig(const TUint32 aPos, const TDesC8& aBuffer, TUint32& aSize);
sl@0	1614	TInt EraseCrashLog(const TUint32 aPos, const TUint32 aBlockNumber);
sl@0	1615	TInt EraseCrashFlashPartition();
sl@0	1616
sl@0	1617	TInt Connect(const TVersion aVersion);
sl@0	1618	private:
sl@0	1619	TInt StartServer(void);
sl@0	1620	};
sl@0	1621	/**
sl@0	1622	Server session constructor
sl@0	1623	*/
sl@0	1624	inline RSecuritySvrSession::RSecuritySvrSession()
sl@0	1625	{
sl@0	1626
sl@0	1627	}
sl@0	1628
sl@0	1629	/**
sl@0	1630	Called by a client to create a session with the DSS. This method starts the
sl@0	1631	DSS if it is not running, or connects to it if it already exists.
sl@0	1632
sl@0	1633	@param aVersion version of the DSS to connect to
sl@0	1634
sl@0	1635	@return KErrNone if a connection was successfully created, or one of the other
sl@0	1636	system wide error codes
sl@0	1637	*/
sl@0	1638	inline TInt RSecuritySvrSession::Connect(const TVersion aVersion)
sl@0	1639	{
sl@0	1640	// default message slots for the server
sl@0	1641	const TUint KDefaultMessageSlots = 4;
sl@0	1642	TInt retry=2;
sl@0	1643	for (;;)
sl@0	1644	{
sl@0	1645	TInt r=CreateSession(KSecurityServerName, aVersion, KDefaultMessageSlots);
sl@0	1646	if (r!=KErrNotFound && r!=KErrServerTerminated)
sl@0	1647	{
sl@0	1648	return r;
sl@0	1649	}
sl@0	1650	if (--retry==0)
sl@0	1651	{
sl@0	1652	return r;
sl@0	1653	}
sl@0	1654	r=StartServer();
sl@0	1655	if (r!=KErrNone && r!=KErrAlreadyExists)
sl@0	1656	{
sl@0	1657	return r;
sl@0	1658	}
sl@0	1659	}
sl@0	1660	}
sl@0	1661
sl@0	1662	/**
sl@0	1663	Start the server
sl@0	1664
sl@0	1665	@return KErrNone on success, or one of the other system wide error codes
sl@0	1666	*/
sl@0	1667	inline TInt RSecuritySvrSession::StartServer()
sl@0	1668	{
sl@0	1669	// constants for the server
sl@0	1670	_LIT(KSecurityServerProcessName, "rm_debug_svr");
sl@0	1671	const TUidType serverUid(KNullUid, KNullUid, KUidDebugSecurityServer);
sl@0	1672
sl@0	1673	RProcess server;
sl@0	1674	TInt err = server.Create(KSecurityServerProcessName, KNullDesC, serverUid);
sl@0	1675
sl@0	1676	if(KErrNone != err)
sl@0	1677	{
sl@0	1678	return err;
sl@0	1679	}
sl@0	1680
sl@0	1681	// Synchronise with the process to make sure it hasn't died straight away
sl@0	1682	TRequestStatus stat;
sl@0	1683	server.Rendezvous(stat);
sl@0	1684	if (stat != KRequestPending)
sl@0	1685	{
sl@0	1686	// logon failed - server is not yet running, so cannot have terminated
sl@0	1687	server.Kill(0); // Abort startup
sl@0	1688	}
sl@0	1689	else
sl@0	1690	{
sl@0	1691	// logon OK - start the server
sl@0	1692	server.Resume();
sl@0	1693	}
sl@0	1694
sl@0	1695	// Wait to synchronise with server - if it dies in the meantime, it
sl@0	1696	// also gets completed
sl@0	1697	User::WaitForRequest(stat);
sl@0	1698
sl@0	1699	// We can't use the 'exit reason' if the server panicked as this
sl@0	1700	// is the panic 'reason' and may be '0' which cannot be distinguished
sl@0	1701	// from KErrNone
sl@0	1702	err = (server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();
sl@0	1703	server.Close();
sl@0	1704	return err;
sl@0	1705	}
sl@0	1706
sl@0	1707	/**
sl@0	1708	Get version of RSecuritySvrSession
sl@0	1709
sl@0	1710	@return a TVersion object specifying the version
sl@0	1711	*/
sl@0	1712	inline TVersion RSecuritySvrSession::Version(void) const
sl@0	1713	{
sl@0	1714	return (TVersion(KDebugServMajorVersionNumber, KDebugServMinorVersionNumber, KDebugServPatchVersionNumber));
sl@0	1715	}
sl@0	1716
sl@0	1717	/**
sl@0	1718	Suspends execution of the specified thread.
sl@0	1719
sl@0	1720	@param aThreadId thread ID of the thread to suspend
sl@0	1721
sl@0	1722	@return KErrNone if there were no problems, KErrPermissionDenied if security
sl@0	1723	check fails or KErrArgument if the thread does not exist
sl@0	1724	*/
sl@0	1725	inline TInt RSecuritySvrSession::SuspendThread(const TThreadId aThreadId)
sl@0	1726	{
sl@0	1727	TPckgBuf<TThreadId> threadIdPckg(aThreadId);
sl@0	1728	TIpcArgs args(&threadIdPckg);
sl@0	1729
sl@0	1730	return SendReceive(EDebugServSuspendThread, args);
sl@0	1731	}
sl@0	1732
sl@0	1733	/**
sl@0	1734	Resumes execution of the specified thread.
sl@0	1735
sl@0	1736	@param aThreadId thread ID of the thread to resume
sl@0	1737
sl@0	1738	@return KErrNone if there were no problems, KErrPermissionDenied if security
sl@0	1739	check fails or KErrArgument if the thread does not exist
sl@0	1740	*/
sl@0	1741	inline TInt RSecuritySvrSession::ResumeThread(const TThreadId aThreadId)
sl@0	1742	{
sl@0	1743	TPckgBuf<TThreadId> threadIdPckg(aThreadId);
sl@0	1744	TIpcArgs args(&threadIdPckg);
sl@0	1745
sl@0	1746	return SendReceive(EDebugServResumeThread, args);
sl@0	1747	}
sl@0	1748
sl@0	1749	/**
sl@0	1750	Purpose:
sl@0	1751	Set a thread-specific breakpoint in an attached process.
sl@0	1752
sl@0	1753	@pre Debug Agent must be connected to the debug security server
sl@0	1754	@pre Debug Agent must be attached to a process.
sl@0	1755
sl@0	1756	@param aThreadId The thread id to which the breakpoint will apply.
sl@0	1757	@param aAddress The virtual memory address at which to place the breakpoint.
sl@0	1758	@param aArchitectureMode The kind of breakpoint which is to be set (e.g. ARM/Thumb/Thumb2EE)
sl@0	1759	@param aBreakId The address to which the assigned breakpoint ID will be written by this function
sl@0	1760	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	1761	*/
sl@0	1762	inline TInt RSecuritySvrSession::SetBreak( TBreakId &aBreakId,const TThreadId aThreadId, const TUint32 aAddress, const TArchitectureMode aArchitectureMode)
sl@0	1763	{
sl@0	1764	TPtr8 breakIdPtr((TUint8*)&aBreakId, sizeof(aBreakId));
sl@0	1765
sl@0	1766	TPckgBuf<TThreadId> threadIdPckg(aThreadId);
sl@0	1767
sl@0	1768	TBreakInfo breakInfo;
sl@0	1769	breakInfo.iAddress = aAddress;
sl@0	1770	breakInfo.iArchitectureMode = aArchitectureMode;
sl@0	1771	TPckgBuf<TBreakInfo> breakInfoPckg(breakInfo);
sl@0	1772
sl@0	1773	//call driver to attempt to set break
sl@0	1774	TIpcArgs args(&threadIdPckg, &breakInfoPckg, &breakIdPtr);
sl@0	1775	return SendReceive(EDebugServSetBreak, args);
sl@0	1776	}
sl@0	1777
sl@0	1778	/**
sl@0	1779	Purpose:
sl@0	1780	Clears a previously set thread-specific or process-specific breakpoint.
sl@0	1781
sl@0	1782	@pre Debug Agent must be connected to the debug security server
sl@0	1783	@pre Debug Agent must be attached to a process.
sl@0	1784
sl@0	1785	@param aBreakId The TBreakId returned by a prior SetBreak call. Must have been set by the same Debug Agent.
sl@0	1786	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	1787	*/
sl@0	1788	inline TInt RSecuritySvrSession::ClearBreak(const TBreakId aBreakId)
sl@0	1789	{
sl@0	1790	TIpcArgs args(aBreakId);
sl@0	1791	return SendReceive(EDebugServClearBreak, args);
sl@0	1792	}
sl@0	1793
sl@0	1794	/**
sl@0	1795	Purpose:
sl@0	1796	Modifies the properties of a previously set breakpoint.
sl@0	1797
sl@0	1798	@pre Debug Agent must be connected to the debug security server
sl@0	1799	@pre Debug Agent must be attached to a process.
sl@0	1800
sl@0	1801	@param aBreakId the TBreakId returned by a prior SetBreak() call. Must have been set by the same Debug Agent.
sl@0	1802	@param aThreadId the thread id of the thread to move the breakpoint to
sl@0	1803	@param aAddress the virtual memory address at which to place the breakpoint.
sl@0	1804	@param aArchitectureMode the kind of breakpoint which is to be set (e.g. ARM/Thumb/Thumb2EE)
sl@0	1805	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	1806	*/
sl@0	1807	inline TInt RSecuritySvrSession::ModifyBreak(const TBreakId aBreakId, const TThreadId aThreadId, const TUint32 aAddress, const TArchitectureMode aArchitectureMode)
sl@0	1808
sl@0	1809	{
sl@0	1810	TPckgBuf<TThreadId> threadIdPckg(aThreadId);
sl@0	1811	TIpcArgs args(aBreakId,&threadIdPckg,aAddress,aArchitectureMode);
sl@0	1812	return SendReceive(EDebugServModifyBreak, args);
sl@0	1813	}
sl@0	1814
sl@0	1815	/**
sl@0	1816	Purpose:
sl@0	1817	Modifies the properties of a previously set process breakpoint.
sl@0	1818
sl@0	1819	@pre Debug Agent must be connected to the debug security server
sl@0	1820	@pre Debug Agent must be attached to a process.
sl@0	1821
sl@0	1822	@param aBreakId the TBreakId returned by a prior SetBreak() call. Must have been set by the same Debug Agent.
sl@0	1823	@param aProcessId the process id of the process to move the breakpoint to
sl@0	1824	@param aAddress the virtual memory address at which to place the breakpoint.
sl@0	1825	@param aArchitectureMode the kind of breakpoint which is to be set (e.g. ARM/Thumb/Thumb2EE)
sl@0	1826	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	1827	*/
sl@0	1828	inline TInt RSecuritySvrSession::ModifyProcessBreak(const TBreakId aBreakId, const TProcessId aProcessId, const TUint32 aAddress, const TArchitectureMode aArchitectureMode)
sl@0	1829
sl@0	1830	{
sl@0	1831	TPckgBuf<TProcessId> processIdPckg(aProcessId);
sl@0	1832	TIpcArgs args(aBreakId,&processIdPckg,aAddress,aArchitectureMode);
sl@0	1833	return SendReceive(EDebugServModifyProcessBreak, args);
sl@0	1834	}
sl@0	1835
sl@0	1836	/**
sl@0	1837	Purpose:
sl@0	1838	Returns the properties associated with a given TBreakId. The supplied break id must previously have been allocated
sl@0	1839	to the debug agent by a SetBreak() call.
sl@0	1840
sl@0	1841	@pre Debug Agent must be connected to the debug security server
sl@0	1842	@pre Debug Agent must be attached to a process.
sl@0	1843	@pre The aBreakId must have been previously returned by a SetBreak() call and not subsequently cleared by ClearBreak().
sl@0	1844
sl@0	1845	@param aBreakId the TBreakId returned by a prior SetBreak() call. Must have been set by the same Debug Agent.
sl@0	1846	@param aAddress on return contains the virtual memory address of the breakpoint
sl@0	1847	@param aThreadId on return contains the thread id of the thread that the breakpoint is set in
sl@0	1848	@param aMode on return contains the type of this breakpoint (e.g. ARM/Thumb/Thumb2EE)
sl@0	1849	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	1850	*/
sl@0	1851	inline TInt RSecuritySvrSession::BreakInfo(const TBreakId aBreakId, TThreadId& aThreadId, TUint32& aAddress, TArchitectureMode& aMode)
sl@0	1852	{
sl@0	1853	// temporary descriptors
sl@0	1854	TPtr8 threadId((TUint8*)&aThreadId,0,sizeof(TThreadId));
sl@0	1855	TPtr8 address((TUint8*)&aAddress,0,sizeof(TUint32));
sl@0	1856	TPtr8 mode((TUint8*)&aMode,0,sizeof(TArchitectureMode));
sl@0	1857
sl@0	1858	TIpcArgs args(aBreakId,&threadId,&address,&mode);
sl@0	1859	return SendReceive(EDebugServBreakInfo, args);
sl@0	1860	}
sl@0	1861
sl@0	1862	/**
sl@0	1863	Purpose:
sl@0	1864	Set a process-specific breakpoint in an attached process.
sl@0	1865
sl@0	1866	@pre Debug Agent must be connected to the debug security server
sl@0	1867	@pre Debug Agent must be attached to a process.
sl@0	1868
sl@0	1869	@param aProcessId The process id to which the breakpoint will apply.
sl@0	1870	@param aAddress The virtual memory address at which to place the breakpoint.
sl@0	1871	@param aArchitectureMode The kind of breakpoint which is to be set (e.g. ARM/Thumb/Thumb2EE)
sl@0	1872	@param aBreakId The address to which the assigned breakpoint ID will be written by this function
sl@0	1873	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	1874	*/
sl@0	1875	inline TInt RSecuritySvrSession::SetProcessBreak( TBreakId &aBreakId, const TProcessId aProcessId, const TUint32 aAddress, const TArchitectureMode aArchitectureMode)
sl@0	1876	{
sl@0	1877	TPtr8 breakIdPtr((TUint8*)&aBreakId, sizeof(aBreakId));
sl@0	1878
sl@0	1879	TPckgBuf<TProcessId> threadIdPckg(aProcessId);
sl@0	1880
sl@0	1881	TBreakInfo breakInfo;
sl@0	1882	breakInfo.iAddress = aAddress;
sl@0	1883	breakInfo.iArchitectureMode = aArchitectureMode;
sl@0	1884	TPckgBuf<TBreakInfo> breakInfoPckg(breakInfo);
sl@0	1885
sl@0	1886	//call driver to attempt to set break
sl@0	1887	TIpcArgs args(&threadIdPckg, &breakInfoPckg, &breakIdPtr);
sl@0	1888	return SendReceive(EDebugServSetProcessBreak, args);
sl@0	1889	}
sl@0	1890
sl@0	1891	/**
sl@0	1892	Purpose:
sl@0	1893	Returns the properties associated with a given TBreakId. The supplied break id must previously have been allocated
sl@0	1894	to the debug agent by a SetProcessBreak() call.
sl@0	1895
sl@0	1896	@pre Debug Agent must be connected to the debug security server
sl@0	1897	@pre Debug Agent must be attached to a process.
sl@0	1898	@pre The aBreakId must have been previously returned by a SetProcessBreak() call and not subsequently cleared by ClearBreak().
sl@0	1899
sl@0	1900	@param aBreakId the TBreakId returned by a prior SetBreak() call. Must have been set by the same Debug Agent.
sl@0	1901	@param aAddress on return contains the virtual memory address of the breakpoint
sl@0	1902	@param aThreadId on return contains the thread id of the thread that the breakpoint is set in
sl@0	1903	@param aMode on return contains the type of this breakpoint (e.g. ARM/Thumb/Thumb2EE)
sl@0	1904	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	1905	*/
sl@0	1906	inline TInt RSecuritySvrSession::ProcessBreakInfo(const TBreakId aBreakId, TProcessId& aProcessId, TUint32& aAddress, TArchitectureMode& aMode)
sl@0	1907	{
sl@0	1908	// temporary descriptors
sl@0	1909	TPtr8 processId((TUint8*)&aProcessId,0,sizeof(TProcessId));
sl@0	1910	TPtr8 address((TUint8*)&aAddress,0,sizeof(TUint32));
sl@0	1911	TPtr8 mode((TUint8*)&aMode,0,sizeof(TArchitectureMode));
sl@0	1912
sl@0	1913	TIpcArgs args(aBreakId,&processId,&address,&mode);
sl@0	1914	return SendReceive(EDebugServProcessBreakInfo, args);
sl@0	1915	}
sl@0	1916
sl@0	1917	/**
sl@0	1918	Purpose:
sl@0	1919	Wait for an event to occur to the target executable being debugged. When an event
sl@0	1920	occurs, the TRequestStatus is changed from KRequestPending.
sl@0	1921
sl@0	1922	@pre Debug Agent must be connected to the debug security server
sl@0	1923	@pre Debug Agent must be attached to a process.
sl@0	1924
sl@0	1925	Note 1: Events are reported on a per-executable basis, not per-thread.
sl@0	1926
sl@0	1927	Note 2: All the parameters must remain in scope until either CancelGetEvent is called, or
sl@0	1928	until TRequestStatus is changed from KRequestPending. In practice, this generally
sl@0	1929	means these parameters should not be based on the stack, as they may go out of
sl@0	1930	scope before the call completes.
sl@0	1931
sl@0	1932	Note 3: TIpcArgs args is allocated on the stack within this function, however,
sl@0	1933	all the data containing in args is transferred in the SendReceive() so it can safely
sl@0	1934	go out of scope after the call has been made.
sl@0	1935
sl@0	1936	@param aExecutableName The name of any executable to which the Debug Agent is attached.
sl@0	1937	@param aStatus Debug Agent request status variable.
sl@0	1938	@param aEventInfo Descriptor containing a buffer sufficient for Event information.
sl@0	1939	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	1940	*/
sl@0	1941	inline void RSecuritySvrSession::GetEvent(const TDesC& aExecutableName, TRequestStatus &aStatus, TDes8& aEventInfo)
sl@0	1942	{
sl@0	1943	TIpcArgs args(&aExecutableName, &aEventInfo);
sl@0	1944
sl@0	1945	SendReceive(EDebugServGetEvent, args, aStatus );
sl@0	1946
sl@0	1947	}
sl@0	1948
sl@0	1949	/**
sl@0	1950	Purpose:
sl@0	1951	Cancel a previously issued asynchronous RSecuritySvrSession::GetEvent call. The previously
sl@0	1952	issued call will immediately complete with the TRequestStatus = KErrCancel
sl@0	1953
sl@0	1954	@pre Debug Agent must be connected to the debug security server
sl@0	1955	@pre Debug Agent must be attached to the process specified by aProcessName
sl@0	1956	@pre Debug Agent must have previously issued an RSecuritySvrSession::GetEvent() call.
sl@0	1957
sl@0	1958	@param aExecutableName The name of the executable being debugged.
sl@0	1959	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	1960	*/
sl@0	1961	inline TInt RSecuritySvrSession::CancelGetEvent(const TDesC& aExecutableName)
sl@0	1962	{
sl@0	1963	TIpcArgs args(&aExecutableName);
sl@0	1964
sl@0	1965	return SendReceive(EDebugServCancelGetEvent,args);
sl@0	1966	}
sl@0	1967
sl@0	1968	/**
sl@0	1969	Called by a debug agent to request debug privileges for the executable with
sl@0	1970	file name aExecutableName.
sl@0	1971
sl@0	1972	@param aExecutableName a fully qualified file name of the executable to attach to
sl@0	1973	@param aPassive if true then the agent has reduced debug rights.
sl@0	1974
sl@0	1975	@return KErrNone if attached successfully, one of the other system wide error
sl@0	1976	codes otherwise
sl@0	1977	*/
sl@0	1978	inline TInt RSecuritySvrSession::AttachExecutable(const TDesC& aExecutableName, TBool aPassive)
sl@0	1979	{
sl@0	1980	TIpcArgs args((TInt)aPassive, &aExecutableName);
sl@0	1981	return SendReceive(EDebugServAttachExecutable, args);
sl@0	1982	}
sl@0	1983
sl@0	1984	/**
sl@0	1985	Called by a debug agent to detach from the executable with file
sl@0	1986	name aExecutableName.
sl@0	1987
sl@0	1988	@param aExecutableName the fully qualified file name of the executable to detach from
sl@0	1989
sl@0	1990	@return KErrNone if detached successfully, one of the other system wide error
sl@0	1991	codes otherwise
sl@0	1992	*/
sl@0	1993	inline TInt RSecuritySvrSession::DetachExecutable(const TDesC& aExecutableName)
sl@0	1994	{
sl@0	1995	TIpcArgs args(&aExecutableName);
sl@0	1996	return SendReceive(EDebugServDetachExecutable, args);
sl@0	1997	}
sl@0	1998
sl@0	1999	/**
sl@0	2000	Close the session and thread
sl@0	2001
sl@0	2002	@return KErrNone if the session is closed successfully, otherwise one of the system wide errors.
sl@0	2003	*/
sl@0	2004	inline TInt RSecuritySvrSession::Close()
sl@0	2005	{
sl@0	2006	RSessionBase::Close();
sl@0	2007	return KErrNone;
sl@0	2008	}
sl@0	2009
sl@0	2010	/**
sl@0	2011	Get buffer size required to contain Functionality text block.
sl@0	2012
sl@0	2013	@see in-source documentation in rm_debug_api.h
sl@0	2014
sl@0	2015	@param aBufSize function will fill this with the required buffer size
sl@0	2016
sl@0	2017	@return KErrNone if the call succeeded, or one of the other system wide error
sl@0	2018	codes if the call failed
sl@0	2019	*/
sl@0	2020	inline TInt RSecuritySvrSession::GetDebugFunctionalityBufSize(TUint32 *aBufSize)
sl@0	2021	{
sl@0	2022	TInt res = KErrNone;
sl@0	2023
sl@0	2024	TPtr8 stuff((TUint8*)aBufSize,4, 4);
sl@0	2025
sl@0	2026	TIpcArgs args(&stuff);
sl@0	2027
sl@0	2028	res = SendReceive(EDebugServGetDebugFunctionalityBufSize, args);
sl@0	2029
sl@0	2030	return res;
sl@0	2031	}
sl@0	2032
sl@0	2033	/**
sl@0	2034	Get debug functionality text block and place it into aBuffer.
sl@0	2035
sl@0	2036	The debug functionality block (DFBlock) is used to provide information about the functionality
sl@0	2037	(i.e. features) which are supported by the rm_debug.ldd device driver.
sl@0	2038
sl@0	2039	Calling this function with a suitably sized buffer aBuffer will result in the debug
sl@0	2040	functionality information being stored in aBuffer. The necessary size of aBuffer can
sl@0	2041	be determined by calling DebugFunctionalityBufSize().
sl@0	2042
sl@0	2043	The format of the DFBlock is:
sl@0	2044
sl@0	2045	@code
sl@0	2046	Sub-block 0
sl@0	2047	Sub-block 1
sl@0	2048	...
sl@0	2049	Sub-block N-1
sl@0	2050	@endcode
sl@0	2051
sl@0	2052	The data which will be returned by a call to GetDebugFunctionality() is constant so is
sl@0	2053	guaranteed to fit exactly into the aBuffer allocated, assuming that the size of aBuffer
sl@0	2054	corresponds to the value returned from GetDebugFunctionalityBufSize().
sl@0	2055
sl@0	2056	Each sub-block is composed of a TTagHeader object followed by a C-style array of TTag objects.
sl@0	2057	The sub-block contains information about a particular aspect of the debug sub-system, for example
sl@0	2058	information about the manner in which memory can be accessed.
sl@0	2059	The TTagHeader is comprised of an identifier which determines the type of data
sl@0	2060	it contains, together with the number of TTag elements in the array following the TTagHeader.
sl@0	2061	Each TTag in a sub-block has a unique ID, stored in the TTag::iTagId member variable.
sl@0	2062
sl@0	2063	The only sub-block that is guaranteed to exist has TTagHeader::iTagHdrId = ETagHeaderIdCore, all other
sl@0	2064	sub-blocks are optional. The ETagHeaderIdCore sub-block is the first sub-block within the DFBlock.
sl@0	2065	Other sub-blocks may appear in any order after the ETagHeaderIdCore sub-block.
sl@0	2066
sl@0	2067	The following is a diagrammatic representation of a sub-block the DFBlock:
sl@0	2068
sl@0	2069	@code
sl@0	2070	The HHHH represents the tag header ID of a sub-block (TTagHeader::iTagHdrId)
sl@0	2071	The NNNN represents the number of TTag elements in the sub-block (TTagHeader::iNumTags)
sl@0	2072	The IIIIIIII represents the ID of the TTag (TTag::iTagId)
sl@0	2073	The TTTT represents the type of the TTag (TTag::iType)
sl@0	2074	The SSSS represents the size of the TTag's associated data (TTag::iSize)
sl@0	2075	The VVVVVVVV represents the TTag's value (TTag::iValue)
sl@0	2076
sl@0	2077	0xNNNNHHHH TTagHeader element for first sub-block (has N1 TTag elements)
sl@0	2078	0xIIIIIIII \
sl@0	2079	0xSSSSTTTT -- TTag 0
sl@0	2080	0xVVVVVVVV /
sl@0	2081	0xIIIIIIII \
sl@0	2082	0xSSSSTTTT -- TTag 1
sl@0	2083	0xVVVVVVVV /
sl@0	2084	...
sl@0	2085	0xIIIIIIII \
sl@0	2086	0xSSSSTTTT -- TTag N1 - 1
sl@0	2087	0xVVVVVVVV /
sl@0	2088	0xNNNNHHHH TTagHeader element for second sub-block (has N2 TTag elements)
sl@0	2089	0xIIIIIIII \
sl@0	2090	0xSSSSTTTT -- TTag 0
sl@0	2091	0xVVVVVVVV /
sl@0	2092	...
sl@0	2093	0xIIIIIIII \
sl@0	2094	0xSSSSTTTT -- TTag N2 - 1
sl@0	2095	0xVVVVVVVV /
sl@0	2096	...
sl@0	2097	0xNNNNHHHH TTagHeader element for last sub-block (has NX TTag elements)
sl@0	2098	0xIIIIIIII \
sl@0	2099	0xSSSSTTTT -- TTag 0
sl@0	2100	0xVVVVVVVV /
sl@0	2101	...
sl@0	2102	0xIIIIIIII \
sl@0	2103	0xSSSSTTTT -- TTag NX - 1
sl@0	2104	0xVVVVVVVV /
sl@0	2105	@endcode
sl@0	2106
sl@0	2107	The following example DFBlock contains two sub-blocks (values taken from enums below):
sl@0	2108	- ETagHeaderIdCore
sl@0	2109	- ETagHeaderIdMemory
sl@0	2110
sl@0	2111	@code
sl@0	2112	Binary Meaning Value
sl@0	2113
sl@0	2114	0x000A0000 iTagHdrId, iNumTags ETagHeaderIdCore, ECoreLast
sl@0	2115	0x00000000 iTagId ECoreEvents
sl@0	2116	0x00000000 iType, iSize ETagTypeBoolean, 0
sl@0	2117	0x00000001 iValue ETrue
sl@0	2118	0x00000001 iTagId ECoreStartStop
sl@0	2119	0x00000000 iType, iSize ETagTypeBoolean, 0
sl@0	2120	0x00000001 iValue ETrue
sl@0	2121	...
sl@0	2122	0x00000008 iTagId ECoreHardware
sl@0	2123	0x00000000 iType, iSize ETagTypeBoolean, 0
sl@0	2124	0x00000000 iValue EFalse
sl@0	2125	0x00000009 iTagId ECoreApiConstants
sl@0	2126	0x00000000 iType, iSize ETagTypeBoolean, 0
sl@0	2127	0x00000001 iValue ETrue
sl@0	2128
sl@0	2129	0x000A0001 iTagHdrId, iNumTags ETagHeaderIdMemory, EMemoryLast
sl@0	2130	0x00000000 iTagId EMemoryRead
sl@0	2131	0x00000000 iType, iSize ETagTypeBoolean, 0
sl@0	2132	0x00000001 iValue ETrue
sl@0	2133	0x00000001 iTagId EMemoryWrite
sl@0	2134	0x00000000 iType, iSize ETagTypeBoolean, 0
sl@0	2135	0x00000001 iValue ETrue
sl@0	2136	...
sl@0	2137	0x00000008 iTagId EMemoryLE8
sl@0	2138	0x00000000 iType, iSize ETagTypeBoolean, 0
sl@0	2139	0x00000001 iValue ETrue
sl@0	2140	0x00000009 iTagId EMemoryMaxBlockSize
sl@0	2141	0x00000001 iType, iSize ETagTypeTUint32, 0
sl@0	2142	0x00004000 iValue 0x4000
sl@0	2143	@endcode
sl@0	2144
sl@0	2145	- Debug Agent DFBlock Processing:
sl@0	2146
sl@0	2147	Debug Agents MUST understand and process the ETagHeaderIdCore block. The other
sl@0	2148	blocks may be ignored if not recognised. Tags within each block may be ignored if
sl@0	2149	not recognised.
sl@0	2150
sl@0	2151	@pre aBuffer.MaxLength() >= *aBufSize where aBufSize is set by a call to:
sl@0	2152	RSecuritySvrSession::GetDebugFunctionalityBufSize(TUint32 *aBufSize)
sl@0	2153
sl@0	2154	@param aBuffer buffer to store functionality block in
sl@0	2155
sl@0	2156	@return KErrNone if call succeeded,
sl@0	2157	KErrNoMemory if temporary memory could not be allocated,
sl@0	2158	KErrGeneral if debug functionality block could not be accessed
sl@0	2159	*/
sl@0	2160	inline TInt RSecuritySvrSession::GetDebugFunctionality(TDes8& aBuffer)
sl@0	2161	{
sl@0	2162	TIpcArgs args(&aBuffer);
sl@0	2163
sl@0	2164	TInt res = KErrNone;
sl@0	2165
sl@0	2166	res = SendReceive(EDebugServGetDebugFunctionality, args);
sl@0	2167
sl@0	2168	return res;
sl@0	2169	}
sl@0	2170
sl@0	2171	/**
sl@0	2172	Read a block of memory from the target debug thread defined by aThreadId.
sl@0	2173
sl@0	2174	@pre the client should attach to the process containing the target thread
sl@0	2175	@pre aData.MaxLength() >= aLength
sl@0	2176
sl@0	2177	@param aThreadId thread ID of the thread to read memory from
sl@0	2178	@param aAddress address to start reading memory from
sl@0	2179	@param aLength number of bytes of memory to read
sl@0	2180	@param aData descriptor to read memory into
sl@0	2181	@param aAccessSize access size for memory reads, default is TAccess::EAccess32
sl@0	2182	@param aEndianess interpretation of endianess of target data, default is
sl@0	2183	TEndianess::EEndLE8
sl@0	2184
sl@0	2185	@return KErrNone if memory read successfully, or one of the other system wide error codes
sl@0	2186	*/
sl@0	2187	inline TInt RSecuritySvrSession::ReadMemory(const TThreadId aThreadId, const TUint32 aAddress, const TUint32 aLength, TDes8 &aData, const TAccess aAccessSize, const TEndianess aEndianess)
sl@0	2188	{
sl@0	2189	TPckgBuf<TThreadId> threadIdPckg(aThreadId);
sl@0	2190	//set up memory info object
sl@0	2191	TMemoryInfo memoryInfo;
sl@0	2192	memoryInfo.iAddress = aAddress;
sl@0	2193	memoryInfo.iSize = aLength;
sl@0	2194	memoryInfo.iAccess = aAccessSize;
sl@0	2195	memoryInfo.iEndianess = aEndianess;
sl@0	2196
sl@0	2197	TPckgBuf<TMemoryInfo> pckg(memoryInfo);
sl@0	2198
sl@0	2199	TIpcArgs args(&threadIdPckg, &pckg, &aData);
sl@0	2200
sl@0	2201	return SendReceive(EDebugServReadMemory, args);
sl@0	2202	}
sl@0	2203
sl@0	2204	/**
sl@0	2205	Write a block of memory to the target debug thread defined by aThreadId.
sl@0	2206
sl@0	2207	@pre the client should attach non-passively to the process containing the
sl@0	2208	target thread
sl@0	2209
sl@0	2210	@param aThreadId thread ID of the thread to write memory to
sl@0	2211	@param aAddress address to start writing memory at
sl@0	2212	@param aLength number of bytes of memory to write
sl@0	2213	@param aData descriptor to read memory from
sl@0	2214	@param aAccessSize access size for memory writes, default is TAccess::EAccess32
sl@0	2215	@param aEndianess interpretation of endianess of target data, default is
sl@0	2216	TEndianess::EEndLE8
sl@0	2217
sl@0	2218	@return KErrNone if memory written successfully, or one of the other system wide error codes
sl@0	2219	*/
sl@0	2220	inline TInt RSecuritySvrSession::WriteMemory(const TThreadId aThreadId, const TUint32 aAddress, const TUint32 aLength, const TDesC8 &aData, const TAccess aAccessSize, const TEndianess aEndianess)
sl@0	2221	{
sl@0	2222	TPckgBuf<TThreadId> threadIdPckg(aThreadId);
sl@0	2223	//create memory info object
sl@0	2224	TMemoryInfo memoryInfo;
sl@0	2225	memoryInfo.iAddress = aAddress;
sl@0	2226	memoryInfo.iSize = aLength;
sl@0	2227	memoryInfo.iAccess = aAccessSize;
sl@0	2228	memoryInfo.iEndianess = aEndianess;
sl@0	2229
sl@0	2230	TPckgBuf<TMemoryInfo> pckg(memoryInfo);
sl@0	2231
sl@0	2232	TIpcArgs args(&threadIdPckg, &pckg, &aData);
sl@0	2233
sl@0	2234	return SendReceive(EDebugServWriteMemory, args);
sl@0	2235	}
sl@0	2236
sl@0	2237	/**
sl@0	2238	Read register values from the thread with thread ID aThreadId. The IDs of the
sl@0	2239	registers to read are stored as an array of TRegisterInfo objects in
sl@0	2240	aRegisterIds. If the nth register requested could be read then the value of the
sl@0	2241	register will be appended to aRegisterValues and EValid stored at
sl@0	2242	offset n in aRegisterFlags. If the register is supported but could not be read
sl@0	2243	then EInValid will be stored at offset n in aRegisterFlags and arbitrary data
sl@0	2244	appended in aRegisterValues. If reading the specified register is not
sl@0	2245	supported by the kernel then ENotSupported will be stored at offset n in
sl@0	2246	aRegisterFlags and arbitrary data appended to aRegisterValues. If an unknown
sl@0	2247	register is specified then EUnknown will be put in aRegisterFlags and
sl@0	2248	arbitrary data placed in aRegisterValues.
sl@0	2249
sl@0	2250	@pre the client should attach to the process containing the target thread
sl@0	2251
sl@0	2252	@see the register ID format is defined in:
sl@0	2253	SGL.TS0028.027 - Symbian Core Dump File Format v1.0.doc
sl@0	2254
sl@0	2255	@param aThreadId thread ID of the thread to read register values from
sl@0	2256	@param aRegisterIds descriptor containing array of TFunctionalityRegister defined
sl@0	2257	register IDs
sl@0	2258	@param aRegisterValues descriptor to contain register values
sl@0	2259	@param aRegisterFlags descriptor containing array of TUint8 flags, with values
sl@0	2260	taken from TRegisterFlag
sl@0	2261
sl@0	2262	@return KErrNone if registers were read successfully, or one of the other system wide error codes
sl@0	2263	*/
sl@0	2264	inline TInt RSecuritySvrSession::ReadRegisters(const TThreadId aThreadId, const TDesC8& aRegisterIds, TDes8& aRegisterValues, TDes8& aRegisterFlags)
sl@0	2265	{
sl@0	2266	TPckgBuf<TThreadId> threadIdPckg(aThreadId);
sl@0	2267	TIpcArgs args(&threadIdPckg, &aRegisterIds, &aRegisterValues, &aRegisterFlags);
sl@0	2268
sl@0	2269	return SendReceive(EDebugServReadRegisters, args);
sl@0	2270	}
sl@0	2271
sl@0	2272	/**
sl@0	2273	Write register values to the thread with thread ID aThreadId. The IDs of the
sl@0	2274	registers to write are stored as an array of TRegisterInfo objects in
sl@0	2275	aRegisterIds. The values to put in the registers are stored as an array of
sl@0	2276	objects in aRegisterValues. If the nth register to write could be
sl@0	2277	written then EValid stored at offset n in aRegisterFlags. If the register is
sl@0	2278	supported but could not be written then EInValid will be stored at offset n in
sl@0	2279	aRegisterFlags. If writing to the specified register is not supported by the
sl@0	2280	kernel then ENotSupported will be stored at offset n in aRegisterFlags. If an
sl@0	2281	unknown register is specified then EUnknown will be put in aRegisterFlags.
sl@0	2282
sl@0	2283	@pre the client should attach non-passively to the process containing the
sl@0	2284	target thread
sl@0	2285
sl@0	2286	@see the register ID format is defined in:
sl@0	2287	SGL.TS0028.027 - Symbian Core Dump File Format v1.0.doc
sl@0	2288
sl@0	2289	@param aThreadId thread ID of the thread to write register values to
sl@0	2290	@param aRegisterIds descriptor containing array of TFunctionalityRegister defined
sl@0	2291	register IDs
sl@0	2292	@param aRegisterValues descriptor containing array of register values
sl@0	2293	@param aRegisterFlags descriptor containing array of TUint8 flags, with values
sl@0	2294	taken from TRegisterFlag
sl@0	2295
sl@0	2296	@return KErrNone if registers were written successfully, or one of the other system wide error codes
sl@0	2297	*/
sl@0	2298	inline TInt RSecuritySvrSession::WriteRegisters(const TThreadId aThreadId, const TDesC8& aRegisterIds, const TDesC8& aRegisterValues, TDes8& aRegisterFlags)
sl@0	2299	{
sl@0	2300	TPckgBuf<TThreadId> threadIdPckg(aThreadId);
sl@0	2301	TIpcArgs args(&threadIdPckg, &aRegisterIds, &aRegisterValues, &aRegisterFlags);
sl@0	2302
sl@0	2303	return SendReceive(EDebugServWriteRegisters, args);
sl@0	2304	}
sl@0	2305
sl@0	2306	/**
sl@0	2307	Purpose:
sl@0	2308	Set the requisite actions to be taken when a particular event occurs.
sl@0	2309	The events are defined in Debug::TEventType and the
sl@0	2310	actions are defined in Debug::TKernelEventAction.
sl@0	2311
sl@0	2312	The default action for all events is EActionIgnore.
sl@0	2313
sl@0	2314	@pre Debug Agent must be connected to the debug security server
sl@0	2315	@pre Debug Agent must be attached to the executable specified by aExecutableName.
sl@0	2316
sl@0	2317	Note: Event actions are on a per-executable basis. This is
sl@0	2318	to ensure that events such as EEventStartThread are notified to the Debug
sl@0	2319	Agent, even though the debug agent cannot be aware of the existence
sl@0	2320	of a new thread at the time the event occurs.
sl@0	2321
sl@0	2322	@param aExecutableName The name of the executable to which the Debug Agent is attached.
sl@0	2323	@param aEvent A TEventType enum defined in rm_debug_api.h:Debug::TEventType
sl@0	2324	@param aEventAction Any TKernelEventAction permitted by the DFBlock.
sl@0	2325	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	2326	*/
sl@0	2327	inline TInt RSecuritySvrSession::SetEventAction(const TDesC& aExecutableName, TEventType aEvent, TKernelEventAction aEventAction)
sl@0	2328	{
sl@0	2329	TInt res = KErrNone;
sl@0	2330
sl@0	2331	TIpcArgs args(&aExecutableName,aEvent,aEventAction);
sl@0	2332
sl@0	2333	res = SendReceive(EDebugServSetEventAction, args);
sl@0	2334
sl@0	2335	return res;
sl@0	2336	}
sl@0	2337
sl@0	2338	/**
sl@0	2339	Returns a global listing corresponding to the type specified as aListId. The structure
sl@0	2340	of the returned data depends on the value of aListId, see TListId for details.
sl@0	2341	If aListData is not large enough to contain the listings data then
sl@0	2342	the necessary buffer size is stored in aDataSize and the function returns
sl@0	2343	KErrTooBig. In this case the contents of aListData will not contain useful data.
sl@0	2344
sl@0	2345	Note that if the aListData buffer was too small to hold the data then the value
sl@0	2346	returned as aDataSize corresponds to the size of the data at that particular
sl@0	2347	instance. The size of the data will vary over time, for example the thread list
sl@0	2348	will increase and decrease in size as threads are created and destroyed, so
sl@0	2349	re-requesting data with a buffer with max length aDataSize will not necessarily
sl@0	2350	succeed if a list has increased in size between the two calls.
sl@0	2351
sl@0	2352	@see TListId
sl@0	2353
sl@0	2354	@param aListId enum from TListId signifying which type of listing to return
sl@0	2355	@param aListData buffer provided by the debug agent in which data can be returned by the debug system
sl@0	2356	@param aDataSize if aListData was not large enough to contain the requested
sl@0	2357	data then the necessary buffer size is stored in aDataSize. If aListData
sl@0	2358	was large enough then the value of aDataSize is the length of aListData
sl@0	2359
sl@0	2360	@return KErrNone if data was returned successfully,
sl@0	2361	KErrTooBig if aListData is too small to hold the data,
sl@0	2362	one of the other system-wide error codes
sl@0	2363	*/
sl@0	2364	inline TInt RSecuritySvrSession::GetList(const TListId aListId, TDes8& aListData, TUint32& aDataSize)
sl@0	2365	{
sl@0	2366	//second argument of ETrue implies a global listing
sl@0	2367	TListDetails info(aListId, EScopeGlobal);
sl@0	2368	TPtr8 infoBuf((TUint8*)&info, sizeof(TListDetails), sizeof(TListDetails));
sl@0	2369	TPtr8 dataSizeBuf((TUint8*)&aDataSize, sizeof(TUint32), sizeof(TUint32));
sl@0	2370	TIpcArgs args(&infoBuf, &aListData, &dataSizeBuf);
sl@0	2371	return SendReceive(EDebugServGetList, args);
sl@0	2372	}
sl@0	2373
sl@0	2374	/**
sl@0	2375	Returns a thread-specific listing corresponding to the type specified as aListId. The structure
sl@0	2376	of the returned data depends on the value of aListId, see TListId for details.
sl@0	2377	If aListData is not large enough to contain the listings data then
sl@0	2378	the necessary buffer size is stored in aDataSize and the function returns
sl@0	2379	KErrTooBig. In this case the contents of aListData will not contain useful data.
sl@0	2380
sl@0	2381	Note that if the aListData buffer is too small to hold the data then the value
sl@0	2382	returned as aDataSize corresponds to the size of the data at that particular
sl@0	2383	instant. The size of the data will vary over time, for example the thread list
sl@0	2384	will increase and decrease in size as threads are created and destroyed, so
sl@0	2385	re-requesting data with a buffer with max length aDataSize will not necessarily
sl@0	2386	succeed if a list has increased in size between the two calls.
sl@0	2387
sl@0	2388	@see TListId
sl@0	2389
sl@0	2390	@param aThreadId thread to return the listing for
sl@0	2391	@param aListId member of TListId signifying which type of listing to return
sl@0	2392	@param aListData buffer provided by the debug agent in which data can be returned by the debug system.
sl@0	2393	@param aDataSize if aListData was not large enough to contain the requested
sl@0	2394	data then the necessary buffer size is stored in aDataSize. If aListData
sl@0	2395	was large enough then the value of aDataSize is the length of aListData
sl@0	2396
sl@0	2397	@return KErrNone if data was returned successfully,
sl@0	2398	KErrTooBig if aListData is too small to hold the data,
sl@0	2399	one of the other system-wide error codes
sl@0	2400	*/
sl@0	2401	inline TInt RSecuritySvrSession::GetList(const TThreadId aThreadId, const TListId aListId, TDes8& aListData, TUint32& aDataSize)
sl@0	2402	{
sl@0	2403	TListDetails info(aListId, EScopeThreadSpecific, aThreadId.Id());
sl@0	2404	TPtr8 infoBuf((TUint8*)&info, sizeof(TListDetails), sizeof(TListDetails));
sl@0	2405	TPtr8 dataSizeBuf((TUint8*)&aDataSize, sizeof(TUint32), sizeof(TUint32));
sl@0	2406	TIpcArgs args(&infoBuf, &aListData, &dataSizeBuf);
sl@0	2407	return SendReceive(EDebugServGetList, args);
sl@0	2408	}
sl@0	2409
sl@0	2410	/**
sl@0	2411	Returns a process-specific listing corresponding to the type specified as aListId. The structure
sl@0	2412	of the returned data depends on the value of aListId, see TListId for details.
sl@0	2413	If aListData is not large enough to contain the listings data then
sl@0	2414	the necessary buffer size is stored in aDataSize and the function returns
sl@0	2415	KErrTooBig. In this case the contents of aListData will not contain useful data.
sl@0	2416
sl@0	2417	Note that if the aListData buffer is too small to hold the data then the value
sl@0	2418	returned as aDataSize corresponds to the size of the data at that particular
sl@0	2419	instant. The size of the data will vary over time, for example the thread list
sl@0	2420	will increase and decrease in size as threads are created and destroyed, so
sl@0	2421	re-requesting data with a buffer with max length aDataSize will not necessarily
sl@0	2422	succeed if a list has increased in size between the two calls.
sl@0	2423
sl@0	2424	@see TListId
sl@0	2425
sl@0	2426	@param aProcessId process to return the listing for
sl@0	2427	@param aListId member of TListId signifying which type of listing to return
sl@0	2428	@param aListData buffer provided by the debug agent in which data can be returned by the debug system.
sl@0	2429	@param aDataSize if aListData was not large enough to contain the requested
sl@0	2430	data then the necessary buffer size is stored in aDataSize. If aListData
sl@0	2431	was large enough then the value of aDataSize is the length of aListData
sl@0	2432
sl@0	2433	@return KErrNone if data was returned successfully,
sl@0	2434	KErrTooBig if aListData is too small to hold the data,
sl@0	2435	one of the other system-wide error codes
sl@0	2436	*/
sl@0	2437	inline TInt RSecuritySvrSession::GetList(const TProcessId aProcessId, const TListId aListId, TDes8& aListData, TUint32& aDataSize)
sl@0	2438	{
sl@0	2439	TListDetails info(aListId, EScopeProcessSpecific, aProcessId.Id());
sl@0	2440	TPtr8 infoBuf((TUint8*)&info, sizeof(TListDetails), sizeof(TListDetails));
sl@0	2441	TPtr8 dataSizeBuf((TUint8*)&aDataSize, sizeof(TUint32), sizeof(TUint32));
sl@0	2442	TIpcArgs args(&infoBuf, &aListData, &dataSizeBuf);
sl@0	2443	return SendReceive(EDebugServGetList, args);
sl@0	2444	}
sl@0	2445
sl@0	2446	/**
sl@0	2447	Purpose:
sl@0	2448	Step one or more CPU instructions in the specified thread from the current PC.
sl@0	2449
sl@0	2450	@pre Debug Agent must be connected to the debug security server
sl@0	2451	@pre Debug Agent must be attached to a process.
sl@0	2452	@pre The thread being stepped must be suspended by the Debug Agent.
sl@0	2453
sl@0	2454	@param aThreadId the id of the thread which is to be stepped
sl@0	2455	@param aNumSteps how many machine-level instructions are to be stepped.
sl@0	2456	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	2457	*/
sl@0	2458	inline TInt RSecuritySvrSession::Step(const TThreadId aThreadId, const TUint32 aNumSteps)
sl@0	2459	{
sl@0	2460	TPckgBuf<TThreadId> threadIdPckg(aThreadId);
sl@0	2461	TInt res = KErrNone;
sl@0	2462
sl@0	2463	TIpcArgs args(&threadIdPckg,aNumSteps);
sl@0	2464
sl@0	2465	res = SendReceive(EDebugServStep,args);
sl@0	2466
sl@0	2467	return res;
sl@0	2468	}
sl@0	2469
sl@0	2470	/**
sl@0	2471	Purpose:
sl@0	2472	Kill the specified process with the supplied reason. Reason codes are equivalent
sl@0	2473	to those in RProcess.Kill().
sl@0	2474
sl@0	2475	@pre Debug Agent must be connected to the debug security server
sl@0	2476	@pre Debug Agent must be attached to a process.
sl@0	2477
sl@0	2478	@param aProcessId the id of the process which is to be killed
sl@0	2479	@param aReason The reason to be associated with the ending of this process
sl@0	2480	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	2481	*/
sl@0	2482	inline TInt RSecuritySvrSession::KillProcess(const TProcessId aProcessId, const TInt aReason)
sl@0	2483	{
sl@0	2484	TPckgBuf<TProcessId> processIdPckg(aProcessId);
sl@0	2485	TInt res = KErrNone;
sl@0	2486
sl@0	2487	TIpcArgs args(&processIdPckg,aReason);
sl@0	2488
sl@0	2489	res = SendReceive(EDebugServKillProcess,args);
sl@0	2490
sl@0	2491	return res;
sl@0	2492	}
sl@0	2493
sl@0	2494	/**
sl@0	2495	Purpose
sl@0	2496	Method to read data from the crash flash
sl@0	2497
sl@0	2498	@pre aData buffer to retrieve the data from the crash flash
sl@0	2499	@pre aDataSize Size of the data
sl@0	2500
sl@0	2501	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	2502	*/
sl@0	2503	inline TInt RSecuritySvrSession::ReadCrashLog(const TUint32 aPos, TDes8& aData, const TUint32 aDataSize)
sl@0	2504	{
sl@0	2505	TIpcArgs args(aPos, &aData, aDataSize);
sl@0	2506	TInt res = SendReceive(EDebugServReadCrashFlash,args);
sl@0	2507	return res;
sl@0	2508	}
sl@0	2509
sl@0	2510	/**
sl@0	2511	* @internalTechnology
sl@0	2512	* @prototype
sl@0	2513	*
sl@0	2514	Purpose:
sl@0	2515	Method to write the crash flash config
sl@0	2516
sl@0	2517	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	2518	*/
sl@0	2519	inline TInt RSecuritySvrSession::WriteCrashConfig(const TUint32 aPos, const TDesC8& aBuffer, TUint32& aSize)
sl@0	2520	{
sl@0	2521	TPtr8 sizePtr((TUint8*)&aSize,4, 4);
sl@0	2522	TIpcArgs args(aPos, &aBuffer, &sizePtr);
sl@0	2523	TInt res = SendReceive(EDebugServWriteCrashFlash, args);
sl@0	2524	return res;
sl@0	2525	}
sl@0	2526	/**
sl@0	2527	Purpose:
sl@0	2528	Method to erase a block in the crash flash
sl@0	2529
sl@0	2530	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	2531	*/
sl@0	2532	inline TInt RSecuritySvrSession::EraseCrashLog(const TUint32 aPos, const TUint32 aBlockNumber)
sl@0	2533	{
sl@0	2534	TIpcArgs args(aPos, aBlockNumber);
sl@0	2535	TInt res = SendReceive(EDebugServEraseCrashFlash, args);
sl@0	2536	return res;
sl@0	2537	}
sl@0	2538
sl@0	2539	/**
sl@0	2540	Purpose:
sl@0	2541	Method to erase entire flash partition
sl@0	2542
sl@0	2543	@return Any error which may be returned by RSessionBase::SendReceive()
sl@0	2544	*/
sl@0	2545	inline TInt RSecuritySvrSession::EraseCrashFlashPartition()
sl@0	2546	{
sl@0	2547	TInt res = SendReceive(EDebugServEraseEntireCrashFlash);
sl@0	2548	return res;
sl@0	2549	}
sl@0	2550
sl@0	2551	} // end of Debug namespace declaration
sl@0	2552
sl@0	2553	#endif // #ifndef __KERNEL_MODE__
sl@0	2554
sl@0	2555	#endif // RM_DEBUG_API_H
sl@0	2556
sl@0	2557
sl@0	2558

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--