Server session constructor

Called by a debug agent to request debug privileges for the executable with file name aExecutableName.

Purpose: Returns the properties associated with a given TBreakId. The supplied break id must previously have been allocated to the debug agent by a SetBreak() call.

Purpose: Cancel a previously issued asynchronous RSecuritySvrSession::GetEvent call. The previously issued call will immediately complete with the TRequestStatus = KErrCancel

Purpose: Clears a previously set thread-specific or process-specific breakpoint.

Close the session and thread

Called by a client to create a session with the DSS. This method starts the DSS if it is not running, or connects to it if it already exists.

Called by a debug agent to detach from the executable with file name aExecutableName.

Purpose: Method to erase entire flash partition

Purpose: Method to erase a block in the crash flash

Get debug functionality text block and place it into aBuffer.

The debug functionality block (DFBlock) is used to provide information about the functionality (i.e. features) which are supported by the rm_debug.ldd device driver.

Calling this function with a suitably sized buffer aBuffer will result in the debug functionality information being stored in aBuffer. The necessary size of aBuffer can be determined by calling DebugFunctionalityBufSize().

The format of the DFBlock is:

Sub-block 0
Sub-block 1
...
Sub-block N-1

The data which will be returned by a call to GetDebugFunctionality() is constant so is guaranteed to fit exactly into the aBuffer allocated, assuming that the size of aBuffer corresponds to the value returned from GetDebugFunctionalityBufSize().

Each sub-block is composed of a TTagHeader object followed by a C-style array of TTag objects. The sub-block contains information about a particular aspect of the debug sub-system, for example information about the manner in which memory can be accessed. The TTagHeader is comprised of an identifier which determines the type of data it contains, together with the number of TTag elements in the array following the TTagHeader. Each TTag in a sub-block has a unique ID, stored in the TTag::iTagId member variable.

The only sub-block that is guaranteed to exist has TTagHeader::iTagHdrId = ETagHeaderIdCore, all other sub-blocks are optional. The ETagHeaderIdCore sub-block is the first sub-block within the DFBlock. Other sub-blocks may appear in any order after the ETagHeaderIdCore sub-block.

The following is a diagrammatic representation of a sub-block the DFBlock:

The HHHH represents the tag header ID of a sub-block (TTagHeader::iTagHdrId)
The NNNN represents the number of TTag elements in the sub-block (TTagHeader::iNumTags)
The IIIIIIII represents the ID of the TTag (TTag::iTagId)
The TTTT represents the type of the TTag (TTag::iType)
The SSSS represents the size of the TTag's associated data (TTag::iSize)
The VVVVVVVV represents the TTag's value (TTag::iValue)

0xNNNNHHHH	TTagHeader element for first sub-block (has N1 TTag elements)
0xIIIIIIII	\
0xSSSSTTTT	-- TTag 0
0xVVVVVVVV	/
0xIIIIIIII	\
0xSSSSTTTT	-- TTag 1
0xVVVVVVVV	/
...
0xIIIIIIII	\
0xSSSSTTTT	-- TTag N1 - 1
0xVVVVVVVV	/
0xNNNNHHHH	TTagHeader element for second sub-block (has N2 TTag elements)
0xIIIIIIII	\
0xSSSSTTTT	-- TTag 0
0xVVVVVVVV	/
...
0xIIIIIIII	\
0xSSSSTTTT	-- TTag N2 - 1
0xVVVVVVVV	/
...
0xNNNNHHHH	TTagHeader element for last sub-block (has NX TTag elements)
0xIIIIIIII	\
0xSSSSTTTT	-- TTag 0
0xVVVVVVVV	/
...
0xIIIIIIII	\
0xSSSSTTTT	-- TTag NX - 1
0xVVVVVVVV	/

Binary		Meaning					Value

0x000A0000	iTagHdrId, iNumTags		ETagHeaderIdCore, ECoreLast
0x00000000	iTagId					ECoreEvents
0x00000000	iType, iSize			ETagTypeBoolean, 0
0x00000001	iValue					ETrue
0x00000001	iTagId					ECoreStartStop
0x00000000	iType, iSize			ETagTypeBoolean, 0
0x00000001	iValue					ETrue
...
0x00000008	iTagId					ECoreHardware
0x00000000	iType, iSize			ETagTypeBoolean, 0
0x00000000	iValue					EFalse
0x00000009	iTagId					ECoreApiConstants
0x00000000	iType, iSize			ETagTypeBoolean, 0
0x00000001	iValue					ETrue

0x000A0001	iTagHdrId, iNumTags		ETagHeaderIdMemory, EMemoryLast
0x00000000	iTagId					EMemoryRead
0x00000000	iType, iSize			ETagTypeBoolean, 0
0x00000001	iValue					ETrue
0x00000001	iTagId					EMemoryWrite
0x00000000	iType, iSize			ETagTypeBoolean, 0
0x00000001	iValue					ETrue
...
0x00000008	iTagId					EMemoryLE8
0x00000000	iType, iSize			ETagTypeBoolean, 0
0x00000001	iValue					ETrue
0x00000009	iTagId					EMemoryMaxBlockSize
0x00000001	iType, iSize			ETagTypeTUint32, 0
0x00004000	iValue					0x4000

Debug Agents MUST understand and process the ETagHeaderIdCore block. The other blocks may be ignored if not recognised. Tags within each block may be ignored if not recognised.

Get buffer size required to contain Functionality text block.

in-source documentation in rm_debug_api.h

Purpose: Wait for an event to occur to the target executable being debugged. When an event occurs, the TRequestStatus is changed from KRequestPending.

Note 2: All the parameters must remain in scope until either CancelGetEvent is called, or until TRequestStatus is changed from KRequestPending. In practice, this generally means these parameters should not be based on the stack, as they may go out of scope before the call completes.

Note 3: TIpcArgs args is allocated on the stack within this function, however, all the data containing in args is transferred in the SendReceive() so it can safely go out of scope after the call has been made.

Returns a global listing corresponding to the type specified as aListId. The structure of the returned data depends on the value of aListId, see TListId for details. If aListData is not large enough to contain the listings data then the necessary buffer size is stored in aDataSize and the function returns KErrTooBig. In this case the contents of aListData will not contain useful data.

Note that if the aListData buffer was too small to hold the data then the value returned as aDataSize corresponds to the size of the data at that particular instance. The size of the data will vary over time, for example the thread list will increase and decrease in size as threads are created and destroyed, so re-requesting data with a buffer with max length aDataSize will not necessarily succeed if a list has increased in size between the two calls.

TListId

Returns a thread-specific listing corresponding to the type specified as aListId. The structure of the returned data depends on the value of aListId, see TListId for details. If aListData is not large enough to contain the listings data then the necessary buffer size is stored in aDataSize and the function returns KErrTooBig. In this case the contents of aListData will not contain useful data.

Note that if the aListData buffer is too small to hold the data then the value returned as aDataSize corresponds to the size of the data at that particular instant. The size of the data will vary over time, for example the thread list will increase and decrease in size as threads are created and destroyed, so re-requesting data with a buffer with max length aDataSize will not necessarily succeed if a list has increased in size between the two calls.

TListId

Returns a process-specific listing corresponding to the type specified as aListId. The structure of the returned data depends on the value of aListId, see TListId for details. If aListData is not large enough to contain the listings data then the necessary buffer size is stored in aDataSize and the function returns KErrTooBig. In this case the contents of aListData will not contain useful data.

Note that if the aListData buffer is too small to hold the data then the value returned as aDataSize corresponds to the size of the data at that particular instant. The size of the data will vary over time, for example the thread list will increase and decrease in size as threads are created and destroyed, so re-requesting data with a buffer with max length aDataSize will not necessarily succeed if a list has increased in size between the two calls.

TListId

Purpose: Kill the specified process with the supplied reason. Reason codes are equivalent to those in RProcess.Kill().

Purpose: Modifies the properties of a previously set breakpoint.

Purpose: Modifies the properties of a previously set process breakpoint.

Purpose: Returns the properties associated with a given TBreakId. The supplied break id must previously have been allocated to the debug agent by a SetProcessBreak() call.

Purpose Method to read data from the crash flash

Read a block of memory from the target debug thread defined by aThreadId.

Read register values from the thread with thread ID aThreadId. The IDs of the registers to read are stored as an array of TRegisterInfo objects in aRegisterIds. If the nth register requested could be read then the value of the register will be appended to aRegisterValues and EValid stored at offset n in aRegisterFlags. If the register is supported but could not be read then EInValid will be stored at offset n in aRegisterFlags and arbitrary data appended in aRegisterValues. If reading the specified register is not supported by the kernel then ENotSupported will be stored at offset n in aRegisterFlags and arbitrary data appended to aRegisterValues. If an unknown register is specified then EUnknown will be put in aRegisterFlags and arbitrary data placed in aRegisterValues.

Resumes execution of the specified thread.

Purpose: Set a thread-specific breakpoint in an attached process.

Purpose: Set the requisite actions to be taken when a particular event occurs. The events are defined in Debug::TEventType and the actions are defined in Debug::TKernelEventAction.

The default action for all events is EActionIgnore.

Purpose: Set a process-specific breakpoint in an attached process.

Start the server

Purpose: Step one or more CPU instructions in the specified thread from the current PC.

Suspends execution of the specified thread.

Get version of RSecuritySvrSession

Purpose: Method to write the crash flash config

Write a block of memory to the target debug thread defined by aThreadId.

Write register values to the thread with thread ID aThreadId. The IDs of the registers to write are stored as an array of TRegisterInfo objects in aRegisterIds. The values to put in the registers are stored as an array of objects in aRegisterValues. If the nth register to write could be written then EValid stored at offset n in aRegisterFlags. If the register is supported but could not be written then EInValid will be stored at offset n in aRegisterFlags. If writing to the specified register is not supported by the kernel then ENotSupported will be stored at offset n in aRegisterFlags. If an unknown register is specified then EUnknown will be put in aRegisterFlags.