--- a/kernel/eka/include/sm_debug_api.h Wed Aug 18 11:08:29 2010 +0300
+++ b/kernel/eka/include/sm_debug_api.h Thu Sep 02 21:54:16 2010 +0300
@@ -1,4 +1,4 @@
-// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+// Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
@@ -23,11 +23,1454 @@
#ifndef D_STOP_MODE_API_H
#define D_STOP_MODE_API_H
-#include <rm_debug_api.h>
#include <plat_priv.h>
+#include <e32cmn.h>
+#include <e32def_private.h>
+
namespace Debug
- {
+ {
+
+
+/** This is the maximum size in bytes a user trace can be */
+const TInt TUserTraceSize = 256;
+
+/**
+ Information in the debug functionality block is represented as a concatenation
+ of pairs of TTagHeader structures and arrays of TTag objects.
+ @see TTagHeader
+ @see RSecuritySvrSession::GetDebugFunctionality
+ */
+struct TTag
+{
+ /** Tag ID, value identifying this tag. */
+ TUint32 iTagId;
+ /**
+ Values correspond to TTagType enumerators.
+ @see TTagType
+ */
+ TUint16 iType;
+ /** Size of external data associated with this tag. */
+ TUint16 iSize;
+ /** Data associated with this tag. */
+ TUint32 iValue;
+};
+
+/**
+ Enumeration defining the supported tag types. These enumerators are used in TTag.iTagId.
+ @see TTag
+ */
+enum TTagType
+{
+ /** Indicates that the iValue field of a TTag structure will contain either ETrue or EFalse. */
+ ETagTypeBoolean = 0,
+ /** Indicates that the iValue field of a TTag structure will contain a value in the TUint32 range. */
+ ETagTypeTUint32 = 1,
+ /** Indicates that the iValue field of a TTag structure will contain values from an enumeration. */
+ ETagTypeEnum = 2,
+ /** Indicates that the iValue field of a TTag structure should be interpreted as a bit field. */
+ ETagTypeBitField = 3,
+ /** Indicates that the type of the iValue field of a TTag structure is unknown. */
+ ETagTypeUnknown = 4,
+ /** Indicates that the iValue field of a TTag structure will contain a pointer. */
+ ETagTypePointer = 5
+};
+
+/**
+ Information in the debug functionality block is represented as a concatenation
+ of pairs of TTagHeader structures and arrays of TTag objects.
+ @see TTag
+ @see RSecuritySvrSession::GetDebugFunctionality
+ */
+struct TTagHeader
+{
+ /** Value identifying the contents of this TTagHeader, should be interpreted as an enumerator from TTagHeaderId.
+ @see TTagHeaderId
+ */
+ TUint16 iTagHdrId;
+ /** The number of TTag elements in the array associated with this TTagHeader. */
+ TUint16 iNumTags;
+};
+
+/**
+ Enumeration used to identify TTagHeader structures, TTagHeader::iTagHdrId elements take these enumerators as values.
+ @see TTagHeader
+ */
+enum TTagHeaderId
+{
+ ETagHeaderIdCore = 0, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityCore. */
+ ETagHeaderIdMemory = 1, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityMemory. */
+ /**
+ Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityRegister.
+ These values are defined as in the document Symbian Core Dump File Format Appendix C
+ (see SGL.TS0028.027 - Symbian Core Dump File Format v1.0.doc).
+ The TTag objects in the associated array have an iSize value corresponding to the size of the register's data in bytes.
+ */
+ ETagHeaderIdRegistersCore = 2,
+ /**
+ Identifies a TTagHeader with associated TTag elements with iTagId values corresponding to coprocessor register identifiers.
+ Coprocessor registers are defined as in the document Symbian Core Dump File Format Appendix C as follows
+ (see SGL.TS0028.027 - Symbian Core Dump File Format v1.0.doc):
+
+ For each 32-bit data word defining a co-pro register, the definition of the meaning of the bits follows
+ the ARM Architecture Reference manual instruction coding
+
+ Upper Halfword Lower Halfword
+ Opcode 2 CRm
+
+ For example: The Domain Access Control Register is Register 3 of co-processor 15. The encoding is therefore
+ CRm = 3
+ Opcode2 = 0
+
+ Therefore the functionality tag would be:
+ TagID: 15 // co-processor number
+ Type: ETagTypeTUint32
+ Data: 0x00000003 // Opcode2 = 0, CRm = 3
+ */
+ ETagHeaderIdCoProRegisters = 3, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityRegister. */
+ ETagHeaderIdBreakpoints = 4, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityBreakpoint. */
+ ETagHeaderIdStepping = 5, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityStep. */
+ ETagHeaderIdExecution = 6, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityExec. */
+ ETagHeaderIdEvents = 7, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TEventType. */
+ ETagHeaderIdApiConstants = 8, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityApiConstants.*/
+ ETagHeaderList = 9, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TListId. */
+ ETagHeaderIdKillObjects = 10, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityKillObject. */
+ ETagHeaderIdSecurity = 11, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalitySecurity */
+ ETagHeaderIdBuffers = 12, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TBufferType. */
+ ETagHeaderIdStopModeFunctions = 13, /**< Identifies a TTagHeader with associated TTag elements with iTagId values from TFunctionalityStopModeFunctions. */
+};
+
+/**
+ This structure is not used in the run-mode debug API.
+ @deprecated
+ */
+struct TSubBlock
+{
+ /** Header to identify the TSubBlock. */
+ TTagHeader iHeader;
+ /** Pointer to array of TTag values associated with this TSubBlock. */
+ TTag* iTagArray;
+};
+
+/**
+ These tags define what kinds of core functionality are supported by the run-mode debug subsystem.
+ TTag structures associated with the ETagHeaderIdCore sub-block will have iTagId values from this enumeration.
+ See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
+ */
+enum TFunctionalityCore
+{
+ ECoreEvents = 0, /**< Indicates whether events processing is supported. */
+ ECoreStartStop = 1, /**< Indicates whether suspending and resuming threads is supported. */
+ ECoreMemory = 2, /**< Indicates whether reading and writing memory is supported. */
+ ECoreRegister = 3, /**< Indicates whether reading and writing register values is supported. */
+ ECoreBreakpoint = 4, /**< Indicates whether breakpoints are supported. */
+ ECoreStepping = 5, /**< Indicates whether stepping is supported. */
+ ECoreLists = 6, /**< Indicates whether listings are supported. */
+ ECoreLogging = 7, /**< Indicates whether logging is supported. */
+ ECoreHardware = 8, /**< Indicates whether hardware support is supported. */
+ ECoreApiConstants = 9, /**< Indicates whether the information in the ETagHeaderIdApiConstants sub-block is relevant. */
+ ECoreKillObjects = 10, /**< Indicates whether killing objects (i.e. threads and processes) is supported. */
+ ECoreSecurity = 11, /**< Indicates whether OEM Debug token support or other security info is supported. */
+ ECoreStopModeFunctions = 12, /**< Indicates whether Stop Mode function calling is supported. */
+ ECoreStopModeBuffers = 13, /**< Indicates whether Stop Mode buffers are supported. */
+
+ /**
+ @internalTechnology
+ A debug agent should find the number of core tags from the DFBlock rather than this enumerator.
+ */
+ ECoreLast
+};
+
+/**
+ These tags define what kind of memory operations can be performed.
+ TTag structures associated with the ETagHeaderIdMemory sub-block will have iTagId values from this enumeration.
+ See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
+ */
+enum TFunctionalityMemory
+{
+ EMemoryRead = 0, /**< Indicates whether reading memory is supported. */
+ EMemoryWrite = 1, /**< Indicates whether writing memory is supported. */
+ EMemoryAccess64 = 2, /**< Indicates whether 64 bit memory access is supported. */
+ EMemoryAccess32 = 3, /**< Indicates whether 32 bit memory access is supported. */
+ EMemoryAccess16 = 4, /**< Indicates whether 16 bit memory access is supported. */
+ EMemoryAccess8 = 5, /**< Indicates whether 8 bit memory access is supported. */
+ EMemoryBE8 = 6, /**< Indicates whether reading memory as 8 bit big-endian values is supported. */
+ EMemoryBE32 = 7, /**< Indicates whether reading memory as 32 bit big-endian values is supported. */
+ EMemoryLE8 = 8, /**< Indicates whether reading memory as 8 bit little-endian values is supported. */
+ EMemoryMaxBlockSize = 9, /**< Corresponds to the maximum size of a block of memory which can be requested. */
+ /**
+ @internalTechnology
+ A debug agent should find the number of memory tags from the DFBlock rather than this enumerator.
+ */
+ EMemoryLast
+};
+
+/**
+ These tags define which objects can be killed by the device driver.
+ TTag structures associated with the ETagHeaderIdKillObjects sub-block will have iTagId values from this enumeration.
+ See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
+ */
+enum TFunctionalityKillObject
+{
+ EFunctionalityKillThread = 0, /**< Indicates whether killing threads is supported. */
+ EFunctionalityKillProcess = 1, /**< Indicates whether killing processes is supported. */
+ /**
+ @internalTechnology
+ A debug agent should find the number of kill object tags from the DFBlock rather than this enumerator.
+ */
+ EFunctionalityKillObjectLast
+};
+
+/**
+ A TTag with an id from the TFunctionalityRegister enum will have a value from this enumeration.
+ The values define how a register can be accessed, if at all.
+ */
+enum TFunctionalityAccess
+{
+ EAccessNone = 0, /**< Indicates that a register cannot be accessed. */
+ EAccessReadOnly = 1, /**< Indicates that a register can be read, but not written to. */
+ EAccessWriteOnly = 2, /**< Indicates that a register can be written to, but not read. */
+ EAccessReadWrite = 3, /**< Indicates that a register can be both read and written to. */
+ EAccessUnknown = 4, /**< Indicates that it is unspecified whether reading or writing to a register is possible. */
+};
+
+/**
+ These enumerators act as core register identifiers.
+ TTag structures associated with the ETagHeaderIdRegistersCore sub-block will have iTagId values from this enumeration.
+ The numeric value of each enumerator identifies the register according to the definitions in the Symbian Core Dump File Format Appendix B
+ (see SGL.TS0028.027 - Symbian Core Dump File Format v1.0.doc).
+ */
+enum TFunctionalityRegister
+{
+ ERegisterR0 = 0x00000000, /**< Identifier for user mode register R0. */
+ ERegisterR1 = 0x00000100, /**< Identifier for user mode register R1. */
+ ERegisterR2 = 0x00000200, /**< Identifier for user mode register R2. */
+ ERegisterR3 = 0x00000300, /**< Identifier for user mode register R3. */
+ ERegisterR4 = 0x00000400, /**< Identifier for user mode register R4. */
+ ERegisterR5 = 0x00000500, /**< Identifier for user mode register R5. */
+ ERegisterR6 = 0x00000600, /**< Identifier for user mode register R6. */
+ ERegisterR7 = 0x00000700, /**< Identifier for user mode register R7. */
+ ERegisterR8 = 0x00000800, /**< Identifier for user mode register R8. */
+ ERegisterR9 = 0x00000900, /**< Identifier for user mode register R9. */
+ ERegisterR10 = 0x00000a00, /**< Identifier for user mode register R10. */
+ ERegisterR11 = 0x00000b00, /**< Identifier for user mode register R11. */
+ ERegisterR12 = 0x00000c00, /**< Identifier for user mode register R12. */
+ ERegisterR13 = 0x00000d00, /**< Identifier for user mode register R13. */
+ ERegisterR14 = 0x00000e00, /**< Identifier for user mode register R14. */
+ ERegisterR15 = 0x00000f00, /**< Identifier for user mode register R15. */
+ ERegisterCpsr = 0x00001000, /**< Identifier for CPSR. */
+ ERegisterR13Svc = 0x00001100, /**< Identifier for R13 supervisor mode banked register. */
+ ERegisterR14Svc = 0x00001200, /**< Identifier for R14 supervisor mode banked register. */
+ ERegisterSpsrSvc = 0x00001300, /**< Identifier for SPSR supervisor mode banked register. */
+ ERegisterR13Abt = 0x00001400, /**< Identifier for R13 Abort mode banked register. */
+ ERegisterR14Abt = 0x00001500, /**< Identifier for R14 Abort mode banked register. */
+ ERegisterSpsrAbt = 0x00001600, /**< Identifier for SPSR Abort mode banked register. */
+ ERegisterR13Und = 0x00001700, /**< Identifier for R13 Undefined mode banked register. */
+ ERegisterR14Und = 0x00001800, /**< Identifier for R14 Undefined mode banked register. */
+ ERegisterSpsrUnd = 0x00001900, /**< Identifier for SPSR Undefined mode banked register. */
+ ERegisterR13Irq = 0x00001a00, /**< Identifier for R13 Interrupt mode banked register. */
+ ERegisterR14Irq = 0x00001b00, /**< Identifier for R14 Interrupt mode banked register. */
+ ERegisterSpsrIrq = 0x00001c00, /**< Identifier for SPSR Interrupt mode banked register. */
+ ERegisterR8Fiq = 0x00001d00, /**< Identifier for R8 Fast Interrupt mode banked register. */
+ ERegisterR9Fiq = 0x00001e00, /**< Identifier for R9 Fast Interrupt mode banked register. */
+ ERegisterR10Fiq = 0x00001f00, /**< Identifier for R10 Fast Interrupt mode banked register. */
+ ERegisterR11Fiq = 0x00002000, /**< Identifier for R11 Fast Interrupt mode banked register. */
+ ERegisterR12Fiq = 0x00002100, /**< Identifier for R12 Fast Interrupt mode banked register. */
+ ERegisterR13Fiq = 0x00002200, /**< Identifier for R13 Fast Interrupt mode banked register. */
+ ERegisterR14Fiq = 0x00002300, /**< Identifier for R14 Fast Interrupt mode banked register. */
+ ERegisterSpsrFiq = 0x00002400, /**< Identifier for SPSR Fast Interrupt mode banked register. */
+ /**
+ @internalTechnology
+ A debug agent should find the number of core registers from the DFBlock rather than this enumerator.
+ */
+ ERegisterLast = 37
+};
+
+
+/**
+ These tags define the kind of breakpoints that are supported.
+ TTag structures associated with the ETagHeaderIdBreakpoints sub-block will have iTagId values from this enumeration.
+ See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
+ */
+enum TFunctionalityBreakpoint
+{
+ EBreakpointThread = 0, /**< Indicates whether thread specific breakpoints are supported. */
+ EBreakpointProcess = 1, /**< Indicates whether process specific breakpoints are supported. */
+ EBreakpointSystem = 2, /**< Indicates whether system wide breakpoints are supported. */
+ EBreakpointArm = 3, /**< Indicates whether ARM mode breakpoints are supported. */
+ EBreakpointThumb = 4, /**< Indicates whether Thumb mode breakpoints are supported. */
+ EBreakpointT2EE = 5, /**< Indicates whether Thumb2 mode breakpoints are supported. */
+ EBreakpointArmInst = 6, /**< Reserved for future use. */
+ EBreakpointThumbInst = 7, /**< Reserved for future use. */
+ EBreakpointT2EEInst = 8, /**< Reserved for future use. */
+ EBreakpointSetArmInst = 9, /**< Reserved for future use. */
+ EBreakpointSetThumbInst = 10, /**< Reserved for future use. */
+ EBreakpointSetT2EEInst = 11, /**< Reserved for future use. */
+ /**
+ @internalTechnology
+ A debug agent should find the number of breakpoint tags from the DFBlock rather than this enumerator.
+ */
+ EBreakpointLast
+};
+
+/**
+ These enumerators provide information about the stepping capabilities of the debug sub-system.
+ TTag structures associated with the ETagHeaderIdStepping sub-block will have iTagId values from this enumeration.
+ See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
+ */
+enum TFunctionalityStep
+{
+ EStep = 0, /**< Indicates whether instruction stepping is supported. */
+ /**
+ @internalTechnology
+ A debug agent should find the number of stepping tags from the DFBlock rather than this enumerator.
+ */
+ EStepLast
+};
+
+/**
+ These enumerators provide information about the execution control capabilities of the debug sub-system.
+ TTag structures associated with the ETagHeaderIdExecution sub-block will have iTagId values from this enumeration.
+ See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
+ */
+enum TFunctionalityExec
+{
+ EExecThreadSuspendResume = 0, /**< Indicates whether suspending and resuming threads is supported. */
+ EExecProcessSuspendResume = 1, /**< Indicates whether suspending and resuming processes is supported. */
+ EExecSystemSuspendResume = 2, /**< Indicates whether suspending and resuming the entire system is supported. */
+ /**
+ @internalTechnology
+ A debug agent should find the number of execution control tags from the DFBlock rather than this enumerator.
+ */
+ EExecLast
+};
+
+/**
+ This enumeration defines the event types supported by the debug sub-system.
+ TTag structures associated with the ETagHeaderIdEvents sub-block will have
+ iTagId values from this enumeration, and iValue values from the TKernelEventAction enumeration.
+
+ These enumerators are also used by the RSecuritySvrSession API to identify events.
+ @see RSecuritySvrSession
+ @see TKernelEventAction
+ */
+enum TEventType
+{
+ EEventsBreakPoint = 0, /**< Identifies a breakpoint event. */
+ EEventsSwExc = 1, /**< Identifies a software exception event. */
+ EEventsHwExc = 2, /**< Identifies a hardware exception event. */
+ EEventsKillThread = 3, /**< Identifies a kill thread event. */
+ EEventsAddLibrary = 4, /**< Identifies an add library event. */
+ EEventsRemoveLibrary = 5, /**< Identifies a remove library event. */
+ /**
+ If an event is generated and there is only a single space remaining in the events queue then
+ an event of type EEventsBufferFull will be stored in the queue and the generated event will
+ be discarded. If further events occur while the buffer is full the events will be discarded.
+ As such an event of type EEventsBufferFull being returned signifies that one or more events
+ were discarded. An event of this type has no valid data associated with it.
+ */
+ EEventsBufferFull = 6,
+ EEventsUnknown = 7, /**< Identifies an event of unknown type. */
+ EEventsUserTrace = 8, /**< Identifies a user trace. */
+ EEventsProcessBreakPoint = 9, /**< Identifies a process breakpoint event. */
+ EEventsStartThread = 10, /**< Identifies a start thread event. */
+ EEventsUserTracesLost = 11, /**< Identifies user traces being lost. */
+ EEventsAddProcess = 12, /**< Identifies an AddProcess event */
+ EEventsRemoveProcess = 13, /**< Identifies a RemoveProcess event */
+ /**
+ @internalTechnology
+ A debug agent should find the number of event types from the DFBlock rather than this enumerator.
+ */
+ EEventsLast
+};
+
+/**
+ These enumerators provide information about constants which are used in the RSecuritySvrSession API.
+ TTag structures associated with the ETagHeaderIdApiConstants sub-block will have iTagId values from this enumeration.
+ See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
+ */
+enum TFunctionalityApiConstants
+ {
+ /**
+ Corresponds to the size of a buffer required to store a TEventInfo.
+ @see TEventInfo
+ */
+ EApiConstantsTEventInfoSize = 0,
+ /**
+ @internalTechnology
+ A debug agent should find the number of API constants tags from the DFBlock rather than this enumerator.
+ */
+ EApiConstantsLast,
+ };
+
+/**
+ The set of possible actions which could be taken when a kernel event occurs.
+ Not all actions are possible for all events. The debug functionality sub-block with header id ETagHeaderIdEvents
+ indicates which values are permitted for each event. The value given for that event should be
+ considered as the most intrusive action the debugger may set: with the definition that EActionSuspend is more
+ intrusive than EActionContinue, which is more intrusive than EActionIgnore.
+ @see RSecuritySvrSession
+ */
+enum TKernelEventAction
+{
+ /** If an event action is set to this value then events of that type will be
+ ignored, and not reported to the debugger. */
+ EActionIgnore = 0,
+ /** If an event action is set to this value then events of that type will be
+ reported to the debugger and the thread which generated the event will be
+ allowed to continue executing. */
+ EActionContinue = 1,
+ /** If an event action is set to this value then events of that type will be
+ reported to the debugger and the thread which generated the event will be
+ suspended. */
+ EActionSuspend = 2,
+ /**
+ @internalTechnology
+ Count of event actions.
+ */
+ EActionLast
+};
+
+/**
+ These enumerators provide information about the ability of the debug subsystem to support OEM Debug tokens.
+ TTag structures associated with the ETagHeaderIdSecurity sub-block will have iTagId values from this enumeration.
+ See each enumerator for an explanation of how a TTag with that iTagId should be interpreted.
+ */
+enum TFunctionalitySecurity
+{
+ ESecurityOEMDebugToken = 0, /**< Indicates whether the DSS supports the use of OEM Debug Tokens. */
+
+ /**
+ @internalTechnology
+ A debug agent should find the number of tags from the DFBlock rather than this enumerator.
+ */
+ ESecurityLast
+};
+
+/**
+ Used for storing the contents of a 32 bit register
+ */
+typedef TUint32 TRegisterValue32;
+
+
+/**
+ * Processor mode
+ */
+enum TArmProcessorModes
+{
+ EUserMode=0x10, //!< EUserMode
+ EFiqMode=0x11, //!< EFiqMode
+ EIrqMode=0x12, //!< EIrqMode
+ ESvcMode=0x13, //!< ESvcMode
+ EAbortMode=0x17, //!< EAbortMode
+ EUndefMode=0x1b, //!< EUndefMode
+ EMaskMode=0x1f //!< EMaskMode
+};
+
+
+
+/**
+ Structure containing information about the state of the registers when a
+ hardware exception occurred
+ */
+class TRmdArmExcInfo
+ {
+public:
+ /** Enumeration detailing the types of exception which may occur. */
+ enum TExceptionType
+ {
+ /** Enumerator signifying that a prefetch abort error has occurred. */
+ EPrefetchAbort = 0,
+ /** Enumerator signifying that a data abort error has occurred. */
+ EDataAbort = 1,
+ /** Enumerator signifying that an undefined instruction error has occurred. */
+ EUndef =2
+ };
+
+ /** Value of CPSR. */
+ TRegisterValue32 iCpsr;
+ /** Type of exception which has occurred. */
+ TExceptionType iExcCode;
+ /** Value of R13 supervisor mode banked register. */
+ TRegisterValue32 iR13Svc;
+ /** Value of user mode register R4. */
+ TRegisterValue32 iR4;
+ /** Value of user mode register R5. */
+ TRegisterValue32 iR5;
+ /** Value of user mode register R6. */
+ TRegisterValue32 iR6;
+ /** Value of user mode register R7. */
+ TRegisterValue32 iR7;
+ /** Value of user mode register R8. */
+ TRegisterValue32 iR8;
+ /** Value of user mode register R9. */
+ TRegisterValue32 iR9;
+ /** Value of user mode register R10. */
+ TRegisterValue32 iR10;
+ /** Value of user mode register R11. */
+ TRegisterValue32 iR11;
+ /** Value of R14 supervisor mode banked register. */
+ TRegisterValue32 iR14Svc;
+ /** Address which caused exception (System Control Coprocessor Fault Address Register) */
+ TRegisterValue32 iFaultAddress;
+ /** Value of System Control Coprocessor Fault Status Register. */
+ TRegisterValue32 iFaultStatus;
+ /** Value of SPSR supervisor mode banked register. */
+ TRegisterValue32 iSpsrSvc;
+ /** Value of user mode register R13. */
+ TRegisterValue32 iR13;
+ /** Value of user mode register R14. */
+ TRegisterValue32 iR14;
+ /** Value of user mode register R0. */
+ TRegisterValue32 iR0;
+ /** Value of user mode register R1. */
+ TRegisterValue32 iR1;
+ /** Value of user mode register R2. */
+ TRegisterValue32 iR2;
+ /** Value of user mode register R3. */
+ TRegisterValue32 iR3;
+ /** Value of user mode register R12. */
+ TRegisterValue32 iR12;
+ /** Value of user mode register R15, points to instruction which caused exception. */
+ TRegisterValue32 iR15;
+ };
+
+/**
+ The maximum size, in bytes, of the panic category string returned as part of a
+ TEventInfo object.
+
+ @see TEventInfo
+ @see TThreadKillInfo
+ */
+const TInt KPanicCategoryMaxName = KMaxName;
+
+/**
+ Event specific information returned as part of a TEventInfo object when
+ an agent set breakpoint is hit.
+ */
+class TThreadBreakPointInfo
+ {
+public:
+ /** Identifies the type of exception. */
+ TExcType iExceptionNumber;
+ /** Structure containing information about the ARM register values. */
+ TRmdArmExcInfo iRmdArmExcInfo;
+ };
+
+/**
+ Event specific information returned as part of a TEventInfo object when
+ a software exception occurs.
+ */
+class TThreadSwExceptionInfo
+ {
+public:
+ /** The value of the program counter. */
+ TUint32 iCurrentPC;
+ /** Identifies the type of exception. */
+ TExcType iExceptionNumber;
+ };
+
+/**
+ Event specific information returned as part of a TEventInfo object when
+ a hardware exception occurs.
+ */
+class TThreadHwExceptionInfo
+ {
+public:
+ /** Identifies the type of exception. */
+ TExcType iExceptionNumber;
+ /** Structure containing information about the ARM register values. */
+ TRmdArmExcInfo iRmdArmExcInfo;
+ };
+
+/**
+ Event specific information returned as part of a TEventInfo object when
+ a thread kill event occurs.
+ */
+class TThreadKillInfo
+ {
+public:
+ /** The value of the program counter. */
+ TUint32 iCurrentPC;
+ /** 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. */
+ TInt iExitReason;
+ /** Specifies the type of the thread kill event, values correspond to elements of TExitType. */
+ TUint8 iExitType;
+ /** The panic category of the killed thread. */
+ TUint8 iPanicCategory[KPanicCategoryMaxName];
+ /** Contains the length in bytes of the initialised data in iPanicCategory. */
+ TInt iPanicCategoryLength;
+ };
+
+/**
+ Event specific information returned as part of a TEventInfo object when
+ a library load event occurs.
+ */
+class TLibraryLoadedInfo
+ {
+public:
+ /** The name of the file that the library was loaded from. */
+ TUint8 iFileName[KMaxName];
+ /** Contains the length in bytes of the initialised data in iFileName. */
+ TInt iFileNameLength;
+ /** The code base address (.text). */
+ TUint32 iCodeAddress;
+ /** The base address of the initialised data section (.data). */
+ TUint32 iDataAddress;
+ };
+
+/**
+ Event specific information returned as part of a TEventInfo object when
+ a thread is started
+ */
+class TStartThreadInfo
+ {
+public:
+ /** The name of the file that the process owning the thread was created from. */
+ TUint8 iFileName[KMaxName];
+ /** Contains the length in bytes of the initialised data in iFileName. */
+ TInt iFileNameLength;
+ };
+
+/**
+ Event specific information returned as part of a TEventInfo object when
+ a process is added. Note that the Process may not be fully constructed,
+ e.g. no threads.
+ */
+class TAddProcessInfo
+ {
+public:
+ /** The name of the file that the process was created from. */
+ TUint8 iFileName[KMaxName];
+ /** Contains the length in bytes of the initialised data in iFileName. */
+ TInt iFileNameLength;
+ /** The UID3 of this process */
+ TUint32 iUid3;
+ /** Contains the CreatorThread ID if available: May be 0 */
+ TUint64 iCreatorThreadId;
+ };
+
+/**
+ Event specific information returned as part of a TEventInfo object when
+ a process is removed. Note that the Process may not be fully destroyed,
+ so its resources should only be accessed if you already have a handle to it.
+ */
+class TRemoveProcessInfo
+ {
+public:
+ /** The name of the file that the process was created from. */
+ TUint8 iFileName[KMaxName];
+ /** Contains the length in bytes of the initialised data in iFileName. */
+ TInt iFileNameLength;
+ TUint32 iSpare1; // Unused
+ };
+
+/**
+ Event specific information returned as part of a TEventInfo object when
+ a library unload event occurs.
+ */
+class TLibraryUnloadedInfo
+ {
+public:
+ /** The name of the file that the library was loaded from. */
+ TUint8 iFileName[KMaxName];
+ /** Contains the length in bytes of the initialised data in iFileName. */
+ TInt iFileNameLength;
+ };
+
+/**
+ * Enum to represent the context of a user trace message
+ */
+enum TUserTraceMessageContext
+{
+ ESingleMessage = 0x1, /** Indicates this message is the only one corresponding to a given user trace */
+ EMultiStart = 0x2, /** Indicates this message is the start of a user trace which consists of multiple messages */
+ EMultiMid = 0x3, /** Indicates this message is one in a series of user trace messages */
+ EMultiEnd = 0x4, /** Indicates this message is the last in a series of user trace messages */
+ /**
+ @internalTechnology
+ A debug agent should find the number of core tags from the DFBlock rather than this enumerator.
+ */
+ ELast = 0x5
+};
+
+/**
+ * Event specific information returned as part of a TEventInfo object
+ * when a user trace event occurs.
+ */
+class TUserTraceInfo
+ {
+public:
+ /** The user trace text */
+ TUint8 iUserTraceText[TUserTraceSize];
+
+ /** User trace text length */
+ TInt iUserTraceLength;
+
+ /** The context of the message */
+ TUserTraceMessageContext iMessageStatus;
+ };
+
+
+/**
+ Structure used to store information about an event. An object of this type
+ is passed as an argument to the RSecuritySvrSession::GetEvent function,
+ and is filled in by the debug driver, and returned to the agent, when a
+ relevant event occurs.
+
+ The debug functionality block contains the size in bytes of the data that
+ the driver will return when a GetEvent call is issued. A debug agent should
+ ensure that this value equals the size of this TEventInfo object to ensure
+ that a compatible debug driver is being used. The value is stored as
+ EApiConstantsTEventInfoSize in the TFunctionalityApiConstants block.
+
+ @see RSecuritySvrSession::GetDebugFunctionality
+ @see RSecuritySvrSession::GetEvent
+ */
+class TEventInfo
+ {
+public:
+
+ /** Constructor sets all elements to default values. */
+ inline TEventInfo() { Reset(); };
+
+ /** Resets all values to default values. */
+ inline void Reset()
+ {
+ iProcessId = 0;
+ iProcessIdValid = EFalse;
+ iThreadId = 0;
+ iThreadIdValid = EFalse;
+ iEventType = (TEventType)NULL;
+ };
+
+public:
+
+ /** The process ID of the process which the event occurred in. */
+ TUint64 iProcessId;
+ /** The thread ID of the thread which the event occurred in. */
+ TUint64 iThreadId;
+ /** Has value ETrue if iProcessId is valid, EFalse otherwise. */
+ TUint8 iProcessIdValid;
+ /** Has value ETrue if iThreadId is valid, EFalse otherwise. */
+ TUint8 iThreadIdValid;
+ /** Indicates the type of the event. This type should be used to determine
+ the type of the information stored in the union which is part of this class. */
+ TEventType iEventType;
+ union
+ {
+ /** Information which is specific to the break point event. */
+ TThreadBreakPointInfo iThreadBreakPointInfo;
+ /** Information which is specific to the software exception event. */
+ TThreadSwExceptionInfo iThreadSwExceptionInfo;
+ /** Information which is specific to the hardware exception event. */
+ TThreadHwExceptionInfo iThreadHwExceptionInfo;
+ /** Information which is specific to the thread kill event. */
+ TThreadKillInfo iThreadKillInfo;
+ /** Information which is specific to the library loaded event. */
+ TLibraryLoadedInfo iLibraryLoadedInfo;
+ /** Information which is specific to the library unloaded event. */
+ TLibraryUnloadedInfo iLibraryUnloadedInfo;
+ /** Information which is specific to the user trace event. */
+ TUserTraceInfo iUserTraceInfo;
+ /** Information which is specific to the start thread event. */
+ TStartThreadInfo iStartThreadInfo;
+ /** Information which is specific to the Add Process event. */
+ TAddProcessInfo iAddProcessInfo;
+ /** Information which is specific to the Remove Process event. */
+ TRemoveProcessInfo iRemoveProcessInfo;
+ };
+ };
+
+/**
+ @internalComponent
+ */
+class TProcessInfo
+ {
+ public:
+
+ inline TProcessInfo() { Reset(); }
+
+ inline TProcessInfo(TUint32 aId, TUint32 aCodeAddress, TUint32 aCodeSize, TUint32 aDataAddress)
+ : iId(aId),
+ iCodeAddress(aCodeAddress),
+ iCodeSize(aCodeSize),
+ iDataAddress(aDataAddress) { }
+
+ inline void Reset()
+ {
+ iId = 0;
+ iCodeAddress = 0;
+ iCodeSize = 0;
+ iDataAddress = 0;
+ }
+
+ public:
+
+ TUint32 iId;
+ TUint32 iCodeAddress;
+ TUint32 iCodeSize;
+ TUint32 iDataAddress;
+ };
+
+/* Other functionality may be defined here later */
+
+/**
+Represents a register id value, in the terms of the Symbian ELF format:
+ - bits 0-7 define the class
+ - bits 8-15 define the rd_id
+ - bits 16-31 define the rd_sub_id
+
+Both the core registers (TFunctionalityRegister type) and the coprocessor registers
+follow this identifier scheme.
+*/
+typedef TUint32 TRegisterInfo;
+
+/**
+Enum representing the status flags which could be returned from a register
+access call.
+*/
+enum TRegisterFlag
+ {
+ /**
+ Default value, a register access call will never return this value
+ */
+ ENotSet = 0,
+ /**
+ Would be returned if the register is supported by the debug driver but the kernel cannot access the register
+ */
+ EInValid = 1,
+ /**
+ Would be returned if the register could be accessed correctly
+ */
+ EValid = 2,
+ /**
+ Would be returned if the register is not supported by the debug driver
+ */
+ ENotSupported = 3,
+ /**
+ Would be returned if a non-4 byte register value was requested
+ */
+ EBadSize = 4
+ };
+
+/**
+Enum representing the different ARM CPU instruction set architectures.
+*/
+enum TArchitectureMode
+ {
+ /** Represents the ARM CPU architecture. */
+ EArmMode = 1,
+ /** Represents the Thumb CPU architecture. */
+ EThumbMode = 2,
+ /**
+ Represents the Thumb2 CPU architecture.
+ @prototype
+ */
+ EThumb2EEMode = 3
+ };
+
+/**
+ Used as an identifier for breakpoints set by the RSecuritySvrSession::SetBreak function.
+ @see RSecuritySvrSession
+ */
+typedef TInt32 TBreakId;
+
+/**
+ Specifies the type of a code segment.
+ @see TCodeSegListEntry
+ */
+enum TCodeSegType
+ {
+ EUnknownCodeSegType = 0, /**< Signifies an unknown code segment type. */
+ EExeCodeSegType = 1, /**< Signifies a code segment belonging to an executable. */
+ EDllCodeSegType = 2 /**< Signifies a code segment belonging to a library. */
+ };
+
+/**
+Structure used for extracting data from a descriptor returned by a call to
+RSecuritySvrSession::GetList() when GetList() is called with TListId::ECodeSegs
+as the first argument.
+
+@see RSecuritySvrSession::GetList()
+
+@code
+//buffer is a TDesC8 containing 4-byte aligned TCodeSegListEntry objects
+//create a pointer to the start of the data
+TUint8* ptr = (TUint8*)buffer.Ptr();
+//create a pointer to the end of the data
+const TUint8* ptrEnd = ptr + buffer.Length();
+while(ptr < ptrEnd)
+ {
+ //cast the pointer to be a TCodeSegListEntry object
+ TCodeSegListEntry& entry = *(TCodeSegListEntry*)ptr;
+ //use the TCodeSegListEntry pointer, i.e.
+ TUint16 nameLength = entry.iNameLength;
+ TPtr name(&(entry.iName[0]), nameLength, nameLength);
+ // move ptr on to point to the next TCodeSegListEntry object
+ ptr += Align4(entry.GetSize());
+ }
+@endcode
+*/
+class TCodeSegListEntry
+ {
+public:
+ TInt GetSize() const;
+public:
+ /**
+ Address of the start of the code segment.
+ */
+ TUint32 iCodeBase;
+ /**
+ Size of the code segment.
+ */
+ TUint32 iCodeSize;
+ /**
+ Size of the const data segment
+ */
+ TUint32 iConstDataSize;
+ /**
+ Address of the initialised data
+ */
+ TUint32 iInitialisedDataBase;
+ /**
+ Size of the initialised data
+ */
+ TUint32 iInitialisedDataSize;
+ /**
+ Size of the uninitialised data
+ */
+ TUint32 iUninitialisedDataSize;
+ /**
+ Boolean indicating whether the code segment is execute in place
+ */
+ TBool iIsXip;
+ /**
+ Indicates whether the code segment is from an executable or a dll, or neither
+ */
+ TCodeSegType iCodeSegType;
+ /** Uid3 of this segment. */
+ TUint32 iUid3;
+ /** Currently unused element. May be used in future to aid maintaining compatibility. */
+ TUint32 iSpare2;
+ /**
+ Length of the code segment's name
+ */
+ TUint16 iNameLength;
+ /**
+ First two bytes of the code segment's name, the name should be considered to
+ extend past the end of the TCodeSegListEntry structure to a length
+ corresponding to iNameLength
+ */
+ TUint16 iName[1];
+ };
+
+/**
+Returns the size of the TCodeSegListEntry, including the file name length
+
+@return the size, in bytes, of the TCodeSegListEntry and the code segment's
+file name
+*/
+inline TInt TCodeSegListEntry::GetSize() const
+ {
+ return sizeof(TCodeSegListEntry) - sizeof(iName) + (2 * iNameLength);
+ }
+
+/**
+Structure used for extracting data from a descriptor returned by a call to
+RSecuritySvrSession::GetList() when GetList() is called with TListId::EXipLibraries
+as the first argument.
+
+@see RSecuritySvrSession::GetList()
+
+@code
+//buffer is a TDesC8 containing 4-byte aligned TXipLibraryListEntry objects
+//create a pointer to the start of the data
+TUint8* ptr = (TUint8*)buffer.Ptr();
+//create a pointer to the end of the data
+const TUint8* ptrEnd = ptr + buffer.Length();
+while(ptr < ptrEnd)
+ {
+ //cast the pointer to be a TXipLibraryListEntry object
+ TXipLibraryListEntry& entry = *(TXipLibraryListEntry*)ptr;
+ //use the TXipLibraryListEntry pointer, i.e.
+ TUint16 nameLength = entry.iNameLength;
+ TPtr name(&(entry.iName[0]), nameLength, nameLength);
+ // move ptr on to point to the next TXipLibraryListEntry object
+ ptr += Align4(entry.GetSize());
+ }
+@endcode
+*/
+class TXipLibraryListEntry
+ {
+public:
+ TInt GetSize() const;
+public:
+ /**
+ Address of the start of the library's code segment.
+ */
+ TUint32 iCodeBase;
+ /**
+ Size of the code segment.
+ */
+ TUint32 iCodeSize;
+ /**
+ Size of the const data segment
+ */
+ TUint32 iConstDataSize;
+ /**
+ Address of the initialised data
+ */
+ TUint32 iInitialisedDataBase;
+ /**
+ Size of the initialised data
+ */
+ TUint32 iInitialisedDataSize;
+ /**
+ Size of the uninitialised data
+ */
+ TUint32 iUninitialisedDataSize;
+ /** Currently unused element. May be used in future to aid maintaining compatibility. */
+ TUint32 iSpare1;
+ /** Currently unused element. May be used in future to aid maintaining compatibility. */
+ TUint32 iSpare2;
+ /**
+ Length of the library's name
+ */
+ TUint16 iNameLength;
+ /**
+ First two bytes of the code segment's name, the name should be considered to
+ extend past the end of the TXipLibraryListEntry structure to a length
+ corresponding to iNameLength
+ */
+ TUint16 iName[1];
+ };
+
+/**
+Returns the size of the TXipLibraryListEntry, including the file name length
+
+@return the size, in bytes, of the TXipLibraryListEntry and the library's
+file name
+*/
+inline TInt TXipLibraryListEntry::GetSize() const
+ {
+ return sizeof(TXipLibraryListEntry) - sizeof(iName) + (2 * iNameLength);
+ }
+
+/**
+Structure used for extracting data from a descriptor returned by a call to
+RSecuritySvrSession::GetList() when GetList() is called with TListId::EExecutables
+as the first argument.
+
+@see RSecuritySvrSession::GetList()
+
+@code
+//buffer is a TDesC8 containing 4-byte aligned TExecutablesListEntry objects
+//create a pointer to the start of the data
+TUint8* ptr = (TUint8*)buffer.Ptr();
+//create a pointer to the end of the data
+const TUint8* ptrEnd = ptr + buffer.Length();
+while(ptr < ptrEnd)
+ {
+ //cast the pointer to be a TExecutablesListEntry object
+ TExecutablesListEntry& entry = *(TExecutablesListEntry*)ptr;
+ //use the TExecutablesListEntry pointer, i.e.
+ TUint16 nameLength = entry.iNameLength;
+ TPtr name(&(entry.iName[0]), nameLength, nameLength);
+ // move ptr on to point to the next TExecutablesListEntry object
+ ptr += Align4(entry.GetSize());
+ }
+@endcode
+*/
+class TExecutablesListEntry
+ {
+public:
+ TInt GetSize() const;
+public:
+ /**
+ Indicates whether an agent has registered to actively debug the executable,
+ a non-zero value indicates that an agent has attached.
+ */
+ TUint8 iIsActivelyDebugged;
+ /**
+ Indicates whether any agents have registered to passively debug the executable,
+ a non-zero value indicates that at least one agent is attached passively
+ */
+ TUint8 iIsPassivelyDebugged;
+ /** Currently unused element. May be used in future to aid maintaining compatibility. */
+ TUint32 iSpare1;
+ /** Currently unused element. May be used in future to aid maintaining compatibility. */
+ TUint32 iSpare2;
+ /**
+ Length of the executable's name
+ */
+ TUint16 iNameLength;
+ /**
+ First two bytes of the executable's name, the name should be considered to
+ extend past the end of the TExecutablesListEntry structure to a length
+ corresponding to iNameLength
+ */
+ TUint16 iName[1];
+ };
+
+/**
+Returns the size of the TExecutablesListEntry, including the file name length
+
+@return the size, in bytes, of the TExecutablesListEntry and the executable's
+file name
+*/
+inline TInt TExecutablesListEntry::GetSize() const
+ {
+ return sizeof(TExecutablesListEntry) - sizeof(iName) + (2*iNameLength);
+ }
+
+/**
+Structure used for extracting data from a descriptor returned by a call to
+RSecuritySvrSession::GetList() when GetList() is called with TListId::EProcesses
+as the first argument.
+
+@see RSecuritySvrSession::GetList()
+
+@code
+//buffer is a TDesC8 containing 4-byte aligned TProcessListEntry objects
+//create a pointer to the start of the data
+TUint8* ptr = (TUint8*)buffer.Ptr();
+//create a pointer to the end of the data
+const TUint8* ptrEnd = ptr + buffer.Length();
+while(ptr < ptrEnd)
+ {
+ //cast the pointer to be a TProcessListEntry object
+ TProcessListEntry& entry = *(TProcessListEntry*)ptr;
+ //use the TProcessListEntry pointer, i.e.
+ TUint16 fileNameLength = entry.iFileNameLength;
+ TPtr name(&(entry.iNames[0]), fileNameLength, fileNameLength);
+ // move ptr on to point to the next TProcessListEntry object
+ ptr += Align4(entry.GetSize());
+ }
+@endcode
+*/
+class TProcessListEntry
+ {
+ public:
+ TInt GetSize() const;
+
+ public:
+ /** Process ID */
+ TUint64 iProcessId;
+
+ /** The Uid3 of the process */
+ TUint32 iUid3;
+
+ /**
+ * Process Attributes
+ * @see DProcess::TProcessAttributes
+ */
+ TInt iAttributes;
+
+ /**
+ * Length of fully qualified file name of the process in bytes. Note that this
+ * entry may be 0 if the process is in the process of shutting down.
+ */
+ TUint16 iFileNameLength;
+
+ /**
+ * Length of current dynamic name of the process in bytes
+ */
+ TUint16 iDynamicNameLength;
+
+ /**
+ * First two bytes of the process' file name, the name should be considered to
+ * extend past the end of the TProcessListEntry structure to a length
+ * corresponding to iFileNameLength. Directly after the data corresponding to the
+ * file name, the dynamic name is stored with a length of iDynamicNameLength characters.
+ * Note that these names are not null terminated and are concatenated directly after each other.
+ *
+ * @code
+ * TProcessListEntry& entry; // entry is a reference to a TProcessListEntry
+ *
+ * //get the file name..
+ * TPtr fileName(&(entry.iNames[0]), iFileNameLength, iFileNameLength);
+ *
+ * //get the dynamic name length..
+ * TPtr dynamicName(&(entry.iNames[0]) + iFileNameLength, iDynamicNameLength, iDynamicNameLength);
+ * @endcode
+ */
+ TUint16 iNames[1];
+ };
+
+/**
+Returns the size of the TProcessListEntry, including the file name length and the
+dynamic name length
+
+@return the size, in bytes, of the TProcessListEntry and the executable's
+file name file name and dynamic name
+*/
+inline TInt TProcessListEntry::GetSize() const
+ {
+ return sizeof(TProcessListEntry) - sizeof(iNames) + (2 * (iFileNameLength + iDynamicNameLength));
+ }
+
+/**
+Structure used for extracting data from a descriptor returned by a call to
+RSecuritySvrSession::GetList() when GetList() is called with TListId::EThreads
+as the first argument.
+
+@see RSecuritySvrSession::GetList()
+
+@code
+//buffer is a TDesC8 containing 4-byte aligned TThreadListEntry objects
+//create a pointer to the start of the data
+TUint8* ptr = (TUint8*)buffer.Ptr();
+//create a pointer to the end of the data
+const TUint8* ptrEnd = ptr + buffer.Length();
+while(ptr < ptrEnd)
+ {
+ //cast the pointer to be a TThreadListEntry object
+ TThreadListEntry& entry = *(TThreadListEntry*)ptr;
+ //use the TThreadListEntry pointer, i.e.
+ TUint16 nameLength = entry.iNameLength;
+ TPtr name(&(entry.iName[0]), nameLength, nameLength);
+ // move ptr on to point to the next TThreadListEntry object
+ ptr += Align4(entry.GetSize());
+ }
+@endcode
+*/
+class TThreadListEntry
+ {
+public:
+ TInt GetSize() const;
+public:
+ /**
+ Thread ID
+ */
+ TUint64 iThreadId;
+ /**
+ Process ID
+ */
+ TUint64 iProcessId;
+ /**
+ Address of the base of the supervisor stack
+ */
+ TUint32 iSupervisorStackBase;
+ /**
+ Size of the supervisor stack
+ */
+ TUint32 iSupervisorStackSize;
+ /**
+ Non-zero if iSupervisorStackBase has been set correctly
+ */
+ TUint8 iSupervisorStackBaseValid;
+ /**
+ Non-zero if iSupervisorStackSize has been set correctly
+ */
+ TUint8 iSupervisorStackSizeValid;
+ /**
+ Address of the thread's supervisor stack pointer
+ */
+ TUint32 iSupervisorStackPtr;
+ /**
+ Indicator of whether the value returned as iSupervisorStackPtr is valid.
+ It is necessary, but not necessarily sufficient, that the thread be suspended
+ for a valid value to be returned. This may be removed from the final API and
+ the value would be extracted instead via the ReadRegisters type calls.
+ */
+ TRegisterFlag iSupervisorStackPtrValid;
+ /** Currently unused element. May be used in future to aid maintaining compatibility. */
+ TUint32 iSpare1;
+ /** Currently unused element. May be used in future to aid maintaining compatibility. */
+ TUint32 iSpare2;
+ /**
+ The length of the thread's name
+ */
+ TUint16 iNameLength;
+ /**
+ First two bytes of the thread's name, the name should be considered to
+ extend past the end of the TThreadListEntry structure to a length
+ corresponding to iNameLength
+ */
+ TUint16 iName[1];
+ };
+
+/**
+Returns the size of the TThreadListEntry, including the name length
+
+@return the size, in bytes, of the TExecutablesListEntry and the thread's name
+*/
+inline TInt TThreadListEntry::GetSize() const
+ {
+ return sizeof(TThreadListEntry) - sizeof(iName) + (2 * iNameLength);
+ }
+
+/**
+Denotes which list type to return from a RSecuritySvrSession::GetList() call
+
+@see RSecuritySvrSession::GetList()
+*/
+enum TListId
+ {
+ /**
+ Indicates that the GetList() call should return a list of the processes in
+ the system. The returned buffer will contain an array of 4-byte aligned
+ TProcessListEntry objects.
+
+ @see TProcessListEntry
+ */
+ EProcesses = 0,
+ /**
+ Indicates that the GetList() call should return a list of the threads in
+ the system. The returned buffer will contain an array of 4-byte aligned
+ TThreadListEntry objects.
+
+ @see TThreadListEntry
+ */
+ EThreads = 1,
+ /**
+ Indicates that the GetList() call should return a list of the code segments in
+ the system. The returned buffer will contain an array of 4-byte aligned
+ TCodeSegListEntry objects.
+
+ @see TCodeSegListEntry
+ */
+ ECodeSegs = 2,
+ /**
+ Indicates that the GetList() call should return a list of the XIP libraries in
+ the system. The returned buffer will contain an array of 4-byte aligned
+ EXipLibraries objects.
+
+ @see EXipLibraries
+ */
+ EXipLibraries = 3,
+ /**
+ Indicates that the GetList() call should return a list of the executables in
+ the system. The returned buffer will contain an array of 4-byte aligned
+ EExecutables objects.
+
+ @see EExecutables
+ */
+ EExecutables = 4,
+ /**
+ Indicates that the GetList() call should return a list of the logical devices in the system.
+ */
+ ELogicalDevices = 5,
+ /**
+ Indicates that the GetList() call should return a list of the mutexes in the system.
+ */
+ EMutexes = 6,
+ /**
+ Indicates that the GetList() call should return a list of the servers in the system.
+ */
+ EServers = 7,
+ /**
+ Indicates that the GetList() call should return a list of the sessions in the system.
+ */
+ ESessions = 8,
+ /**
+ Indicates that the GetList() call should return a list of the semaphores in the system.
+ */
+ ESemaphores = 9,
+ /**
+ Indicates that the GetList() call should return a list of the chunks in the system.
+ */
+ EChunks = 10,
+
+ /**
+ Provides a complete list of all the breakpoints in the system and their
+ current state.
+
+ @see EBreakpoints
+ */
+ EBreakpoints = 11,
+
+ /**
+ The following are for the possible use of kernel-side debug and SMP breakpoint
+ manipulation.
+ */
+ ESetBreak = 12,
+ ERemoveBreak = 13,
+ EModifyBreak = 14,
+
+ /**
+ * Provides static information of the system
+ */
+ EStaticInfo = 15,
+
+ /** Last listing enum. */
+ EListLast
+ };
+
+/**
+ Bit field values denoting the scope of a listing.
+
+ In the debug functionality block, the TTag::iValue element which is returned for a listing tag
+ should be considered as a union of the supported values from this enumeration for that listing.
+ */
+enum TListScope
+ {
+ EScopeNone = 0x0, /**< Corresponds to no scope for a listing. equivalent to not supported */
+ EScopeGlobal= 0x1, /**< Corresponds to a global scope for a listing. */
+ EScopeProcessSpecific = 0x2, /**< Corresponds to a process specific scope for a listing. */
+ EScopeThreadSpecific = 0x4 /**< Corresponds to a thread specific scope for a listing. */
+ };
+
+/**
+@internalComponent
+
+Interface constructor for passing IPC data for the GetList call.
+*/
+class TListDetails
+ {
+public:
+ TListDetails(const TListId aListId, const TListScope aListScope, TUint64 aTargetId=0)
+ : iListId(aListId),
+ iListScope(aListScope),
+ iTargetId(aTargetId) {}
+public:
+ TListId iListId;
+ TListScope iListScope;
+ TUint64 iTargetId;
+ };
+
+
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace Debug
+ {
+
/**
* The stop-mode debug interface is a stateless interface which may be called at any point
* except user mode, provided the rest of the OS is not going to run or pre-empt it.
@@ -263,6 +1706,105 @@
static TInt CopyAndExpandDes(const TDesC& aSrc, TDes& aDest);
};
+
+
+ /**
+ Provides static methods for accessing the information stored in a TRegisterInfo
+ object.
+ */
+ class Register
+ {
+ public:
+ static TBool IsCoreReg(const Debug::TRegisterInfo aRegister);
+ static TBool IsCoproReg(const Debug::TRegisterInfo aRegister);
+ static TUint32 GetCoreRegId(const Debug::TRegisterInfo aRegister);
+ static TUint32 GetCRm(const Debug::TRegisterInfo aRegister);
+ static TUint32 GetCRn(const Debug::TRegisterInfo aRegister);
+ static TUint32 GetOpcode1(const Debug::TRegisterInfo aRegister);
+ static TUint32 GetOpcode2(const Debug::TRegisterInfo aRegister);
+ static TUint32 GetCoproNum(const Debug::TRegisterInfo aRegister);
+ };
+
+ /**
+ Identify whether aRegister is a core register
+ @param aRegister register ID to analyse
+ @return ETrue if core register, EFalse otherwise
+ */
+ inline TBool Register::IsCoreReg(const Debug::TRegisterInfo aRegister)
+ {
+ return ((aRegister & 0xff) == 0x0);
+ }
+
+ /**
+ Identify whether aRegister is a coprocessor register
+ @param aRegister register ID to analyse
+ @return ETrue if coprocessor register, EFalse otherwise
+ */
+ inline TBool Register::IsCoproReg(const Debug::TRegisterInfo aRegister)
+ {
+ return ((aRegister & 0xff) == 0x1);
+ }
+
+ /**
+ Get the ID of the core register
+ @param aRegister register ID to analyse
+ @return ID of the core register
+ */
+ inline TUint32 Register::GetCoreRegId(const Debug::TRegisterInfo aRegister)
+ {
+ return ((aRegister >> 8) & 0xff);
+ }
+
+ /**
+ Get the CRm value of a coprocessor register
+ @param aRegister register ID to analyse
+ @return the CRm value of a coprocessor register
+ */
+ inline TUint32 Register::GetCRm(const Debug::TRegisterInfo aRegister)
+ {
+ return ((aRegister >> 16) & 0xf);
+ }
+
+ /**
+ Get the CRm value of a coprocessor register
+ @param aRegister register ID to analyse
+ @return the CRm value of a coprocessor register
+ */
+ inline TUint32 Register::GetCRn(const Debug::TRegisterInfo aRegister)
+ {
+ return ((aRegister >> 20) & 0xf);
+ }
+
+ /**
+ Get the Opcode1 value of a coprocessor register
+ @param aRegister register ID to analyse
+ @return the Opcode1 value of a coprocessor register
+ */
+ inline TUint32 Register::GetOpcode1(const Debug::TRegisterInfo aRegister)
+ {
+ return ((aRegister >> 24) & 0x8);
+ }
+
+ /**
+ Get the Opcode2 value of a coprocessor register
+ @param aRegister register ID to analyse
+ @return the Opcode2 value of a coprocessor register
+ */
+ inline TUint32 Register::GetOpcode2(const Debug::TRegisterInfo aRegister)
+ {
+ return ((aRegister >> 27) & 0x8);
+ }
+
+ /**
+ Get the coprocessor number of a coprocessor register
+ @param aRegister register ID to analyse
+ @return the coprocessor number of a coprocessor register
+ */
+ inline TUint32 Register::GetCoproNum(const Debug::TRegisterInfo aRegister)
+ {
+ return ((aRegister >> 8) & 0xff);
+ }
+
};
#endif // D_STOP_MODE_API_H