[NTOSKRNL] Add a raw implementation of !irpfind in kdbg
[reactos.git] / ntoskrnl / kd64 / i386 / kdx86.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/kd64/i386/kdx86.c
5 * PURPOSE: KD support routines for x86
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 /* FUNCTIONS *****************************************************************/
17
18 VOID
19 NTAPI
20 KdpGetStateChange(IN PDBGKD_MANIPULATE_STATE64 State,
21 IN PCONTEXT Context)
22 {
23 PKPRCB Prcb;
24 ULONG i;
25
26 /* Check for success */
27 if (NT_SUCCESS(State->u.Continue2.ContinueStatus))
28 {
29 /* Check if we're tracing */
30 if (State->u.Continue2.ControlSet.TraceFlag)
31 {
32 /* Enable TF */
33 Context->EFlags |= EFLAGS_TF;
34 }
35 else
36 {
37 /* Remove it */
38 Context->EFlags &= ~EFLAGS_TF;
39 }
40
41 /* Loop all processors */
42 for (i = 0; i < KeNumberProcessors; i++)
43 {
44 /* Get the PRCB and update DR7 and DR6 */
45 Prcb = KiProcessorBlock[i];
46 Prcb->ProcessorState.SpecialRegisters.KernelDr7 =
47 State->u.Continue2.ControlSet.Dr7;
48 Prcb->ProcessorState.SpecialRegisters.KernelDr6 = 0;
49 }
50
51 /* Check if we have new symbol information */
52 if (State->u.Continue2.ControlSet.CurrentSymbolStart != 1)
53 {
54 /* Update it */
55 KdpCurrentSymbolStart =
56 State->u.Continue2.ControlSet.CurrentSymbolStart;
57 KdpCurrentSymbolEnd= State->u.Continue2.ControlSet.CurrentSymbolEnd;
58 }
59 }
60 }
61
62 VOID
63 NTAPI
64 KdpSetContextState(IN PDBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange,
65 IN PCONTEXT Context)
66 {
67 PKPRCB Prcb = KeGetCurrentPrcb();
68
69 /* Copy i386 specific debug registers */
70 WaitStateChange->ControlReport.Dr6 = Prcb->ProcessorState.SpecialRegisters.
71 KernelDr6;
72 WaitStateChange->ControlReport.Dr7 = Prcb->ProcessorState.SpecialRegisters.
73 KernelDr7;
74
75 /* Copy i386 specific segments */
76 WaitStateChange->ControlReport.SegCs = (USHORT)Context->SegCs;
77 WaitStateChange->ControlReport.SegDs = (USHORT)Context->SegDs;
78 WaitStateChange->ControlReport.SegEs = (USHORT)Context->SegEs;
79 WaitStateChange->ControlReport.SegFs = (USHORT)Context->SegFs;
80
81 /* Copy EFlags */
82 WaitStateChange->ControlReport.EFlags = Context->EFlags;
83
84 /* Set Report Flags */
85 WaitStateChange->ControlReport.ReportFlags = REPORT_INCLUDES_SEGS;
86 if (WaitStateChange->ControlReport.SegCs == KGDT_R0_CODE)
87 {
88 WaitStateChange->ControlReport.ReportFlags |= REPORT_STANDARD_CS;
89 }
90 }
91
92 NTSTATUS
93 NTAPI
94 KdpSysReadMsr(IN ULONG Msr,
95 OUT PLARGE_INTEGER MsrValue)
96 {
97 /* Wrap this in SEH in case the MSR doesn't exist */
98 _SEH2_TRY
99 {
100 /* Read from the MSR */
101 MsrValue->QuadPart = __readmsr(Msr);
102 }
103 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
104 {
105 /* Invalid MSR */
106 _SEH2_YIELD(return STATUS_NO_SUCH_DEVICE);
107 }
108 _SEH2_END;
109
110 /* Success */
111 return STATUS_SUCCESS;
112 }
113
114 NTSTATUS
115 NTAPI
116 KdpSysWriteMsr(IN ULONG Msr,
117 IN PLARGE_INTEGER MsrValue)
118 {
119 /* Wrap this in SEH in case the MSR doesn't exist */
120 _SEH2_TRY
121 {
122 /* Write to the MSR */
123 __writemsr(Msr, MsrValue->QuadPart);
124 }
125 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
126 {
127 /* Invalid MSR */
128 _SEH2_YIELD(return STATUS_NO_SUCH_DEVICE);
129 }
130 _SEH2_END;
131
132 /* Success */
133 return STATUS_SUCCESS;
134 }
135
136 NTSTATUS
137 NTAPI
138 KdpSysReadBusData(IN ULONG BusDataType,
139 IN ULONG BusNumber,
140 IN ULONG SlotNumber,
141 IN ULONG Offset,
142 IN PVOID Buffer,
143 IN ULONG Length,
144 OUT PULONG ActualLength)
145 {
146 /* Just forward to HAL */
147 *ActualLength = HalGetBusDataByOffset(BusDataType,
148 BusNumber,
149 SlotNumber,
150 Buffer,
151 Offset,
152 Length);
153
154 /* Return status */
155 return *ActualLength != 0 ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
156 }
157
158 NTSTATUS
159 NTAPI
160 KdpSysWriteBusData(IN ULONG BusDataType,
161 IN ULONG BusNumber,
162 IN ULONG SlotNumber,
163 IN ULONG Offset,
164 IN PVOID Buffer,
165 IN ULONG Length,
166 OUT PULONG ActualLength)
167 {
168 /* Just forward to HAL */
169 *ActualLength = HalSetBusDataByOffset(BusDataType,
170 BusNumber,
171 SlotNumber,
172 Buffer,
173 Offset,
174 Length);
175
176 /* Return status */
177 return *ActualLength != 0 ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
178 }
179
180 NTSTATUS
181 NTAPI
182 KdpSysReadControlSpace(IN ULONG Processor,
183 IN ULONG64 BaseAddress,
184 IN PVOID Buffer,
185 IN ULONG Length,
186 OUT PULONG ActualLength)
187 {
188 PVOID ControlStart;
189 ULONG RealLength;
190
191 /* Make sure that this is a valid request */
192 if ((BaseAddress < sizeof(KPROCESSOR_STATE)) &&
193 (Processor < KeNumberProcessors))
194 {
195 /* Get the actual length */
196 RealLength = sizeof(KPROCESSOR_STATE) - (ULONG_PTR)BaseAddress;
197 if (RealLength < Length) Length = RealLength;
198
199 /* Set the proper address */
200 ControlStart = (PVOID)((ULONG_PTR)BaseAddress +
201 (ULONG_PTR)&KiProcessorBlock[Processor]->
202 ProcessorState);
203
204 /* Read the control state safely */
205 return KdpCopyMemoryChunks((ULONG_PTR)Buffer,
206 ControlStart,
207 Length,
208 0,
209 MMDBG_COPY_UNSAFE | MMDBG_COPY_WRITE,
210 ActualLength);
211 }
212 else
213 {
214 /* Invalid request */
215 *ActualLength = 0;
216 return STATUS_UNSUCCESSFUL;
217 }
218 }
219
220 NTSTATUS
221 NTAPI
222 KdpSysWriteControlSpace(IN ULONG Processor,
223 IN ULONG64 BaseAddress,
224 IN PVOID Buffer,
225 IN ULONG Length,
226 OUT PULONG ActualLength)
227 {
228 PVOID ControlStart;
229
230 /* Make sure that this is a valid request */
231 if (((BaseAddress + Length) <= sizeof(KPROCESSOR_STATE)) &&
232 (Processor < KeNumberProcessors))
233 {
234 /* Set the proper address */
235 ControlStart = (PVOID)((ULONG_PTR)BaseAddress +
236 (ULONG_PTR)&KiProcessorBlock[Processor]->
237 ProcessorState);
238
239 /* Write the control state safely */
240 return KdpCopyMemoryChunks((ULONG_PTR)Buffer,
241 ControlStart,
242 Length,
243 0,
244 MMDBG_COPY_UNSAFE,
245 ActualLength);
246 }
247 else
248 {
249 /* Invalid request */
250 *ActualLength = 0;
251 return STATUS_UNSUCCESSFUL;
252 }
253 }
254
255 NTSTATUS
256 NTAPI
257 KdpSysReadIoSpace(IN ULONG InterfaceType,
258 IN ULONG BusNumber,
259 IN ULONG AddressSpace,
260 IN ULONG64 IoAddress,
261 IN PVOID DataValue,
262 IN ULONG DataSize,
263 OUT PULONG ActualDataSize)
264 {
265 NTSTATUS Status;
266
267 /* Verify parameters */
268 if ((InterfaceType != Isa) ||
269 (BusNumber != 0) ||
270 (AddressSpace != 1))
271 {
272 /* Fail, we don't support this */
273 *ActualDataSize = 0;
274 return STATUS_UNSUCCESSFUL;
275 }
276
277 /* Check the size */
278 switch (DataSize)
279 {
280 case sizeof(UCHAR):
281
282 /* Read 1 byte */
283 *(PUCHAR)DataValue =
284 READ_PORT_UCHAR((PUCHAR)(ULONG_PTR)IoAddress);
285 *ActualDataSize = sizeof(UCHAR);
286 Status = STATUS_SUCCESS;
287 break;
288
289 case sizeof(USHORT):
290
291 /* Make sure the address is aligned */
292 if ((IoAddress & (sizeof(USHORT) - 1)) != 0)
293 {
294 /* It isn't, bail out */
295 *ActualDataSize = 0;
296 Status = STATUS_DATATYPE_MISALIGNMENT;
297 break;
298 }
299
300 /* Read 2 bytes */
301 *(PUSHORT)DataValue =
302 READ_PORT_USHORT((PUSHORT)(ULONG_PTR)IoAddress);
303 *ActualDataSize = sizeof(USHORT);
304 Status = STATUS_SUCCESS;
305 break;
306
307 case sizeof(ULONG):
308
309 /* Make sure the address is aligned */
310 if ((IoAddress & (sizeof(ULONG) - 1)) != 0)
311 {
312 /* It isn't, bail out */
313 *ActualDataSize = 0;
314 Status = STATUS_DATATYPE_MISALIGNMENT;
315 break;
316 }
317
318 /* Read 4 bytes */
319 *(PULONG)DataValue =
320 READ_PORT_ULONG((PULONG)(ULONG_PTR)IoAddress);
321 *ActualDataSize = sizeof(ULONG);
322 Status = STATUS_SUCCESS;
323 break;
324
325 default:
326
327 /* Invalid size, fail */
328 *ActualDataSize = 0;
329 Status = STATUS_INVALID_PARAMETER;
330 }
331
332 /* Return status */
333 return Status;
334 }
335
336 NTSTATUS
337 NTAPI
338 KdpSysWriteIoSpace(IN ULONG InterfaceType,
339 IN ULONG BusNumber,
340 IN ULONG AddressSpace,
341 IN ULONG64 IoAddress,
342 IN PVOID DataValue,
343 IN ULONG DataSize,
344 OUT PULONG ActualDataSize)
345 {
346 NTSTATUS Status;
347
348 /* Verify parameters */
349 if ((InterfaceType != Isa) ||
350 (BusNumber != 0) ||
351 (AddressSpace != 1))
352 {
353 /* Fail, we don't support this */
354 *ActualDataSize = 0;
355 return STATUS_UNSUCCESSFUL;
356 }
357
358 /* Check the size */
359 switch (DataSize)
360 {
361 case sizeof(UCHAR):
362
363 /* Write 1 byte */
364 WRITE_PORT_UCHAR((PUCHAR)(ULONG_PTR)IoAddress,
365 *(PUCHAR)DataValue);
366 *ActualDataSize = sizeof(UCHAR);
367 Status = STATUS_SUCCESS;
368 break;
369
370 case sizeof(USHORT):
371
372 /* Make sure the address is aligned */
373 if ((IoAddress & (sizeof(USHORT) - 1)) != 0)
374 {
375 /* It isn't, bail out */
376 *ActualDataSize = 0;
377 Status = STATUS_DATATYPE_MISALIGNMENT;
378 break;
379 }
380
381 /* Write 2 bytes */
382 WRITE_PORT_USHORT((PUSHORT)(ULONG_PTR)IoAddress,
383 *(PUSHORT)DataValue);
384 *ActualDataSize = sizeof(USHORT);
385 Status = STATUS_SUCCESS;
386 break;
387
388 case sizeof(ULONG):
389
390 /* Make sure the address is aligned */
391 if ((IoAddress & (sizeof(ULONG) - 1)) != 0)
392 {
393 /* It isn't, bail out */
394 *ActualDataSize = 0;
395 Status = STATUS_DATATYPE_MISALIGNMENT;
396 break;
397 }
398
399 /* Write 4 bytes */
400 WRITE_PORT_ULONG((PULONG)(ULONG_PTR)IoAddress,
401 *(PULONG)DataValue);
402 *ActualDataSize = sizeof(ULONG);
403 Status = STATUS_SUCCESS;
404 break;
405
406 default:
407
408 /* Invalid size, fail */
409 *ActualDataSize = 0;
410 Status = STATUS_INVALID_PARAMETER;
411 }
412
413 /* Return status */
414 return Status;
415 }
416
417 NTSTATUS
418 NTAPI
419 KdpSysCheckLowMemory(IN ULONG Flags)
420 {
421 /* Stubbed as we don't support PAE */
422 return STATUS_UNSUCCESSFUL;
423 }
424
425 NTSTATUS
426 NTAPI
427 KdpAllowDisable(VOID)
428 {
429 LONG i;
430 ULONG Dr7;
431
432 /* Loop every processor */
433 for (i = 0; i < KeNumberProcessors; i++)
434 {
435 /* Get its DR7 */
436 Dr7 = KiProcessorBlock[i]->ProcessorState.SpecialRegisters.KernelDr7;
437
438 /* Check if any processor breakpoints are active */
439 if (Dr7 != 0)
440 {
441 /* We can't allow running without a debugger then */
442 return STATUS_ACCESS_DENIED;
443 }
444 }
445
446 /* No processor breakpoints; allow disabling the debugger */
447 return STATUS_SUCCESS;
448 }