[NTOSKRNL]
[reactos.git] / ntoskrnl / kd64 / kdtrap.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/kd64/kdtrap.c
5 * PURPOSE: KD64 Trap Handlers
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 * Stefan Ginsberg (stefan.ginsberg@reactos.org)
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15
16 //
17 // Retrieves the ComponentId and Level for BREAKPOINT_PRINT
18 // and OutputString and OutputStringLength for BREAKPOINT_PROMPT.
19 //
20 #if defined(_X86_)
21
22 //
23 // EBX/EDI on x86
24 //
25 #define KdpGetParameterThree(Context) ((Context)->Ebx)
26 #define KdpGetParameterFour(Context) ((Context)->Edi)
27
28 #elif defined(_AMD64_)
29
30 //
31 // R8/R9 on AMD64
32 //
33 #define KdpGetParameterThree(Context) ((Context)->R8)
34 #define KdpGetParameterFour(Context) ((Context)->R9)
35
36 #elif defined(_ARM_)
37
38 //
39 // R3/R4 on ARM
40 //
41 #define KdpGetParameterThree(Context) ((Context)->R3)
42 #define KdpGetParameterFour(Context) ((Context)->R4)
43
44 #else
45 #error Unsupported Architecture
46 #endif
47
48 /* FUNCTIONS *****************************************************************/
49
50 BOOLEAN
51 NTAPI
52 KdpReport(IN PKTRAP_FRAME TrapFrame,
53 IN PKEXCEPTION_FRAME ExceptionFrame,
54 IN PEXCEPTION_RECORD ExceptionRecord,
55 IN PCONTEXT ContextRecord,
56 IN KPROCESSOR_MODE PreviousMode,
57 IN BOOLEAN SecondChanceException)
58 {
59 BOOLEAN Enable, Handled;
60 PKPRCB Prcb;
61 NTSTATUS ExceptionCode = ExceptionRecord->ExceptionCode;
62
63 /*
64 * Determine whether to pass the exception to the debugger.
65 * First, check if this is a "debug exception", meaning breakpoint
66 * (including debug service), single step and assertion failure exceptions.
67 */
68 if ((ExceptionCode == STATUS_BREAKPOINT) ||
69 (ExceptionCode == STATUS_SINGLE_STEP) ||
70 (ExceptionCode == STATUS_ASSERTION_FAILURE))
71 {
72 /* This is a debug exception; we always pass them to the debugger */
73 }
74 else if (NtGlobalFlag & FLG_STOP_ON_EXCEPTION)
75 {
76 /*
77 * Not a debug exception, but the stop-on-exception flag is set,
78 * meaning the debugger requests that we pass it first chance
79 * exceptions. However, some exceptions are always passed to the
80 * exception handler first, namely exceptions with a code that isn't
81 * an error or warning code, and also exceptions with the special
82 * STATUS_PORT_DISCONNECTED code (an error code).
83 */
84 if ((SecondChanceException == FALSE) &&
85 ((ExceptionCode == STATUS_PORT_DISCONNECTED) ||
86 (NT_SUCCESS(ExceptionCode))))
87 {
88 /* Let the exception handler, if any, try to handle it */
89 return FALSE;
90 }
91 }
92 else if (SecondChanceException == FALSE)
93 {
94 /*
95 * This isn't a debug exception and the stop-on-exception flag isn't
96 * set, so don't bother
97 */
98 return FALSE;
99 }
100
101 /* Enter the debugger */
102 Enable = KdEnterDebugger(TrapFrame, ExceptionFrame);
103
104 /*
105 * Get the KPRCB and save the CPU Control State manually instead of
106 * using KiSaveProcessorState, since we already have a valid CONTEXT.
107 */
108 Prcb = KeGetCurrentPrcb();
109 KiSaveProcessorControlState(&Prcb->ProcessorState);
110 RtlCopyMemory(&Prcb->ProcessorState.ContextFrame,
111 ContextRecord,
112 sizeof(CONTEXT));
113
114 /* Report the new state */
115 Handled = KdpReportExceptionStateChange(ExceptionRecord,
116 &Prcb->ProcessorState.
117 ContextFrame,
118 SecondChanceException);
119
120 /* Now restore the processor state, manually again. */
121 RtlCopyMemory(ContextRecord,
122 &Prcb->ProcessorState.ContextFrame,
123 sizeof(CONTEXT));
124 KiRestoreProcessorControlState(&Prcb->ProcessorState);
125
126 /* Exit the debugger and clear the CTRL-C state */
127 KdExitDebugger(Enable);
128 KdpControlCPressed = FALSE;
129 return Handled;
130 }
131
132 BOOLEAN
133 NTAPI
134 KdpTrap(IN PKTRAP_FRAME TrapFrame,
135 IN PKEXCEPTION_FRAME ExceptionFrame,
136 IN PEXCEPTION_RECORD ExceptionRecord,
137 IN PCONTEXT ContextRecord,
138 IN KPROCESSOR_MODE PreviousMode,
139 IN BOOLEAN SecondChanceException)
140 {
141 BOOLEAN Unload = FALSE;
142 ULONG_PTR ProgramCounter;
143 BOOLEAN Handled;
144 NTSTATUS ReturnStatus;
145 USHORT ReturnLength;
146
147 /*
148 * Check if we got a STATUS_BREAKPOINT with a SubID for Print, Prompt or
149 * Load/Unload symbols. Make sure it isn't a software breakpoints as those
150 * are handled by KdpReport.
151 */
152 if ((ExceptionRecord->ExceptionCode == STATUS_BREAKPOINT) &&
153 (ExceptionRecord->ExceptionInformation[0] != BREAKPOINT_BREAK))
154 {
155 /* Save Program Counter */
156 ProgramCounter = KeGetContextPc(ContextRecord);
157
158 /* Check what kind of operation was requested from us */
159 switch (ExceptionRecord->ExceptionInformation[0])
160 {
161 /* DbgPrint */
162 case BREAKPOINT_PRINT:
163
164 /* Call the worker routine */
165 ReturnStatus = KdpPrint((ULONG)KdpGetParameterThree(ContextRecord),
166 (ULONG)KdpGetParameterFour(ContextRecord),
167 (LPSTR)ExceptionRecord->
168 ExceptionInformation[1],
169 (USHORT)ExceptionRecord->
170 ExceptionInformation[2],
171 PreviousMode,
172 TrapFrame,
173 ExceptionFrame,
174 &Handled);
175
176 /* Update the return value for the caller */
177 KeSetContextReturnRegister(ContextRecord, ReturnStatus);
178 break;
179
180 /* DbgPrompt */
181 case BREAKPOINT_PROMPT:
182
183 /* Call the worker routine */
184 ReturnLength = KdpPrompt((LPSTR)ExceptionRecord->
185 ExceptionInformation[1],
186 (USHORT)ExceptionRecord->
187 ExceptionInformation[2],
188 (LPSTR)KdpGetParameterThree(ContextRecord),
189 (USHORT)KdpGetParameterFour(ContextRecord),
190 PreviousMode,
191 TrapFrame,
192 ExceptionFrame);
193 Handled = TRUE;
194
195 /* Update the return value for the caller */
196 KeSetContextReturnRegister(ContextRecord, ReturnLength);
197 break;
198
199 /* DbgUnLoadImageSymbols */
200 case BREAKPOINT_UNLOAD_SYMBOLS:
201
202 /* Drop into the load case below, with the unload parameter */
203 Unload = TRUE;
204
205 /* DbgLoadImageSymbols */
206 case BREAKPOINT_LOAD_SYMBOLS:
207
208 /* Call the worker routine */
209 KdpSymbol((PSTRING)ExceptionRecord->
210 ExceptionInformation[1],
211 (PKD_SYMBOLS_INFO)ExceptionRecord->
212 ExceptionInformation[2],
213 Unload,
214 PreviousMode,
215 ContextRecord,
216 TrapFrame,
217 ExceptionFrame);
218 Handled = TRUE;
219 break;
220
221 /* DbgCommandString */
222 case BREAKPOINT_COMMAND_STRING:
223
224 /* Call the worker routine */
225 KdpCommandString((PSTRING)ExceptionRecord->
226 ExceptionInformation[1],
227 (PSTRING)ExceptionRecord->
228 ExceptionInformation[2],
229 PreviousMode,
230 ContextRecord,
231 TrapFrame,
232 ExceptionFrame);
233 Handled = TRUE;
234
235 /* Anything else, do nothing */
236 default:
237
238 /* Invalid debug service! Don't handle this! */
239 Handled = FALSE;
240 break;
241 }
242
243 /*
244 * If the PC was not updated, we'll increment it ourselves so execution
245 * continues past the breakpoint.
246 */
247 if (ProgramCounter == KeGetContextPc(ContextRecord))
248 {
249 /* Update it */
250 KeSetContextPc(ContextRecord,
251 ProgramCounter + KD_BREAKPOINT_SIZE);
252 }
253 }
254 else
255 {
256 /* Call the worker routine */
257 Handled = KdpReport(TrapFrame,
258 ExceptionFrame,
259 ExceptionRecord,
260 ContextRecord,
261 PreviousMode,
262 SecondChanceException);
263 }
264
265 /* Return TRUE or FALSE to caller */
266 return Handled;
267 }
268
269 BOOLEAN
270 NTAPI
271 KdpStub(IN PKTRAP_FRAME TrapFrame,
272 IN PKEXCEPTION_FRAME ExceptionFrame,
273 IN PEXCEPTION_RECORD ExceptionRecord,
274 IN PCONTEXT ContextRecord,
275 IN KPROCESSOR_MODE PreviousMode,
276 IN BOOLEAN SecondChanceException)
277 {
278 ULONG_PTR ExceptionCommand = ExceptionRecord->ExceptionInformation[0];
279
280 /* Check if this was a breakpoint due to DbgPrint or Load/UnloadSymbols */
281 if ((ExceptionRecord->ExceptionCode == STATUS_BREAKPOINT) &&
282 (ExceptionRecord->NumberParameters > 0) &&
283 ((ExceptionCommand == BREAKPOINT_LOAD_SYMBOLS) ||
284 (ExceptionCommand == BREAKPOINT_UNLOAD_SYMBOLS) ||
285 (ExceptionCommand == BREAKPOINT_COMMAND_STRING) ||
286 (ExceptionCommand == BREAKPOINT_PRINT)))
287 {
288 /* This we can handle: simply bump the Program Counter */
289 KeSetContextPc(ContextRecord,
290 KeGetContextPc(ContextRecord) + KD_BREAKPOINT_SIZE);
291 return TRUE;
292 }
293 else if (KdPitchDebugger)
294 {
295 /* There's no debugger, fail. */
296 return FALSE;
297 }
298 else if ((KdAutoEnableOnEvent) &&
299 (KdPreviouslyEnabled) &&
300 !(KdDebuggerEnabled) &&
301 (NT_SUCCESS(KdEnableDebugger())) &&
302 (KdDebuggerEnabled))
303 {
304 /* Debugging was Auto-Enabled. We can now send this to KD. */
305 return KdpTrap(TrapFrame,
306 ExceptionFrame,
307 ExceptionRecord,
308 ContextRecord,
309 PreviousMode,
310 SecondChanceException);
311 }
312 else
313 {
314 /* FIXME: All we can do in this case is trace this exception */
315 return FALSE;
316 }
317 }
318
319 BOOLEAN
320 NTAPI
321 KdIsThisAKdTrap(IN PEXCEPTION_RECORD ExceptionRecord,
322 IN PCONTEXT Context,
323 IN KPROCESSOR_MODE PreviousMode)
324 {
325 /*
326 * Determine if this is a valid debug service call and make sure that
327 * it isn't a software breakpoint
328 */
329 if ((ExceptionRecord->ExceptionCode == STATUS_BREAKPOINT) &&
330 (ExceptionRecord->NumberParameters > 0) &&
331 (ExceptionRecord->ExceptionInformation[0] != BREAKPOINT_BREAK))
332 {
333 /* Then we have to handle it */
334 return TRUE;
335 }
336 else
337 {
338 /* We don't have to handle it */
339 return FALSE;
340 }
341 }