ReactOS 0.4.16-dev-1946-g52006dd
Functions
kdfuncs.h File Reference
#include <umtypes.h>
#include <kdtypes.h>
Include dependency graph for kdfuncs.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

NTSTATUS NTAPI KdSystemDebugControl (_In_ SYSDBG_COMMAND Command, _In_reads_bytes_(InputBufferLength) PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_writes_bytes_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _Out_opt_ PULONG ReturnLength, _In_ KPROCESSOR_MODE PreviousMode)
 Perform various queries to the kernel debugger.
 
BOOLEAN NTAPI KdPollBreakIn (VOID)
 
NTSYSCALLAPI NTSTATUS NTAPI NtQueryDebugFilterState (_In_ ULONG ComponentId, _In_ ULONG Level)
 
NTSYSCALLAPI NTSTATUS NTAPI NtSetDebugFilterState (_In_ ULONG ComponentId, _In_ ULONG Level, _In_ BOOLEAN State)
 
NTSYSCALLAPI NTSTATUS NTAPI NtSystemDebugControl (_In_ SYSDBG_COMMAND Command, _In_reads_bytes_(InputBufferLength) PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_writes_bytes_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _Out_opt_ PULONG ReturnLength)
 Perform various queries to the kernel debugger.
 
NTSYSAPI NTSTATUS NTAPI ZwQueryDebugFilterState (ULONG ComponentId, ULONG Level)
 
NTSYSAPI NTSTATUS NTAPI ZwSetDebugFilterState (ULONG ComponentId, ULONG Level, BOOLEAN State)
 
NTSYSAPI NTSTATUS NTAPI ZwSystemDebugControl (_In_ SYSDBG_COMMAND Command, _In_reads_bytes_(InputBufferLength) PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_writes_bytes_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _Out_opt_ PULONG ReturnLength)
 

Function Documentation

◆ KdPollBreakIn()

BOOLEAN NTAPI KdPollBreakIn ( VOID  )

Definition at line 75 of file kdlock.c.

76{
77 BOOLEAN DoBreak = FALSE, Enable;
78
79 /* First make sure that KD is enabled */
80 if (KdDebuggerEnabled)
81 {
82 /* Disable interrupts */
83 Enable = KeDisableInterrupts();
84
85 /* Check if a CTRL-C is in the queue */
86 if (KdpContext.KdpControlCPending)
87 {
88 /* Set it and prepare for break */
89 KdpControlCPressed = TRUE;
90 DoBreak = TRUE;
91 KdpContext.KdpControlCPending = FALSE;
92 }
93 else
94 {
95 KIRQL OldIrql;
96 /* Try to acquire the lock */
97 KeRaiseIrql(HIGH_LEVEL, &OldIrql);
98 if (KeTryToAcquireSpinLockAtDpcLevel(&KdpDebuggerLock))
99 {
100 /* Now get a packet */
101 if (KdReceivePacket(PACKET_TYPE_KD_POLL_BREAKIN,
102 NULL,
103 NULL,
104 NULL,
105 NULL) == KdPacketReceived)
106 {
107 /* Successful breakin */
108 DoBreak = TRUE;
109 KdpControlCPressed = TRUE;
110 }
111
112 /* Let go of the port */
113 KdpPortUnlock();
114 }
115 KeLowerIrql(OldIrql);
116 }
117
118 /* Re-enable interrupts */
119 KeRestoreInterrupts(Enable);
120 }
121
122 /* Tell the caller to do a break */
123 return DoBreak;
124}
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
KIRQL
UCHAR KIRQL
Definition: env_spec_w32.h:591
KeRaiseIrql
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
HIGH_LEVEL
#define HIGH_LEVEL
Definition: env_spec_w32.h:703
KeLowerIrql
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
KdpDebuggerLock
KSPIN_LOCK KdpDebuggerLock
Definition: kddata.c:67
KdpContext
KD_CONTEXT KdpContext
Definition: kddata.c:65
KdpControlCPressed
BOOLEAN KdpControlCPressed
Definition: kddata.c:68
KdDebuggerEnabled
BOOLEAN KdDebuggerEnabled
Definition: kddata.c:82
KdReceivePacket
KDP_STATUS NTAPI KdReceivePacket(IN ULONG PacketType, OUT PSTRING MessageHeader, OUT PSTRING MessageData, OUT PULONG DataLength, IN OUT PKD_CONTEXT KdContext)
Definition: kddll.c:80
KdpPortUnlock
VOID NTAPI KdpPortUnlock(VOID)
Definition: kdlock.c:27
Enable
_In_ ULONGLONG _In_ ULONGLONG _In_ BOOLEAN Enable
Definition: ntddpcm.h:142
KeDisableInterrupts
FORCEINLINE BOOLEAN KeDisableInterrupts(VOID)
Definition: ke.h:241
KeRestoreInterrupts
FORCEINLINE VOID KeRestoreInterrupts(BOOLEAN WereEnabled)
Definition: ke.h:256
KeTryToAcquireSpinLockAtDpcLevel
BOOLEAN FASTCALL KeTryToAcquireSpinLockAtDpcLevel(IN OUT PKSPIN_LOCK SpinLock)
Definition: spinlock.c:309
KdPacketReceived
#define KdPacketReceived
Definition: kddll.h:5
_KD_CONTEXT::KdpControlCPending
BOOLEAN KdpControlCPending
Definition: windbgkd.h:227
PACKET_TYPE_KD_POLL_BREAKIN
#define PACKET_TYPE_KD_POLL_BREAKIN
Definition: windbgkd.h:49
OldIrql
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778

Referenced by KdInitSystem(), KeUpdateSystemTime(), KiInitializeSystem(), and KiSystemStartup().

◆ KdSystemDebugControl()

NTSTATUS NTAPI KdSystemDebugControl ( _In_ SYSDBG_COMMAND  Command,
_In_reads_bytes_(InputBufferLength) PVOID  InputBuffer,
_In_ ULONG  InputBufferLength,
_Out_writes_bytes_(OutputBufferLength) PVOID  OutputBuffer,
_In_ ULONG  OutputBufferLength,
_Out_opt_ PULONG  ReturnLength,
_In_ KPROCESSOR_MODE  PreviousMode 
)

Perform various queries to the kernel debugger.

Parameters
[in]CommandA SYSDBG_COMMAND value describing the kernel debugger command to perform.
[in]InputBufferPointer to a user-provided input command-specific buffer, whose length is given by InputBufferLength.
[in]InputBufferLengthThe size (in bytes) of the buffer pointed by InputBuffer.
[out]OutputBufferPointer to a user-provided command-specific output buffer, whose length is given by OutputBufferLength.
[in]OutputBufferLengthThe size (in bytes) of the buffer pointed by OutputBuffer.
[out]ReturnLengthOptional pointer to a ULONG variable that receives the actual length of data written written in the output buffer. It is always zero, except for the live dump commands where an actual non-zero length is returned.
[in]PreviousModeThe processor mode (KernelMode or UserMode) in which the command is being executed.
Returns
STATUS_SUCCESS in case of success, or a proper error code otherwise.
Remarks
  • This is a kernel-mode function, accessible only by kernel-mode drivers.
Note
See: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2004-2339
See also
NtSystemDebugControl()

Definition at line 2217 of file kdapi.c.

2225{
2226 NTSTATUS Status;
2227 ULONG Length = 0;
2228
2229 /* Handle some internal commands */
2230 switch ((ULONG)Command)
2231 {
2232#if DBG
2233 case ' soR': /* ROS-INTERNAL */
2234 {
2235 switch ((ULONG_PTR)InputBuffer)
2236 {
2237 case 0x21: // DumpAllThreads:
2238 PspDumpThreads(TRUE);
2239 break;
2240
2241 case 0x22: // DumpUserThreads:
2242 PspDumpThreads(FALSE);
2243 break;
2244
2245 case 0x24: // KdSpare3:
2246 MmDumpArmPfnDatabase(FALSE);
2247 break;
2248
2249 default:
2250 break;
2251 }
2252 return STATUS_SUCCESS;
2253 }
2254
2255#if defined(_M_IX86) && !defined(_WINKD_) // See ke/i386/traphdlr.c
2256 /* Register a debug callback */
2257 case 'CsoR':
2258 {
2259 switch (InputBufferLength)
2260 {
2261 case ID_Win32PreServiceHook:
2262 KeWin32PreServiceHook = InputBuffer;
2263 break;
2264
2265 case ID_Win32PostServiceHook:
2266 KeWin32PostServiceHook = InputBuffer;
2267 break;
2268
2269 }
2270 break;
2271 }
2272#endif
2273
2274 /* Special case for stack frame dumps */
2275 case 'DsoR':
2276 {
2277 KeRosDumpStackFrames((PULONG_PTR)InputBuffer, InputBufferLength);
2278 break;
2279 }
2280#ifdef KDBG
2281 /* Register KDBG CLI callback */
2282 case 'RbdK':
2283 {
2284 return KdbRegisterCliCallback(InputBuffer, InputBufferLength);
2285 }
2286#endif // KDBG
2287#endif
2288 default:
2289 break;
2290 }
2291
2292 switch (Command)
2293 {
2294 case SysDbgQueryVersion:
2295 if (OutputBufferLength != sizeof(DBGKD_GET_VERSION64))
2296 {
2297 Status = STATUS_INFO_LENGTH_MISMATCH;
2298 }
2299 else
2300 {
2301 KdpSysGetVersion((PDBGKD_GET_VERSION64)OutputBuffer);
2302 Status = STATUS_SUCCESS;
2303 }
2304 break;
2305
2306 case SysDbgReadVirtual:
2307 case SysDbgWriteVirtual:
2308 if (InputBufferLength != sizeof(SYSDBG_VIRTUAL))
2309 {
2310 Status = STATUS_INFO_LENGTH_MISMATCH;
2311 }
2312 else
2313 {
2314 SYSDBG_VIRTUAL Request = *(PSYSDBG_VIRTUAL)InputBuffer;
2315 PVOID LockedBuffer;
2316 PMDL LockVariable;
2317
2318 Status = ExLockUserBuffer(Request.Buffer,
2319 Request.Request,
2320 PreviousMode,
2321 Command == SysDbgReadVirtual ? IoWriteAccess : IoReadAccess,
2322 &LockedBuffer,
2323 &LockVariable);
2324 if (NT_SUCCESS(Status))
2325 {
2326 Status = KdpCopyMemoryChunks((ULONG64)(ULONG_PTR)Request.Address,
2327 Request.Buffer,
2328 Request.Request,
2329 0,
2330 Command == SysDbgReadVirtual ? 0 : MMDBG_COPY_WRITE,
2331 &Length);
2332 ExUnlockUserBuffer(LockVariable);
2333 }
2334 }
2335 break;
2336
2337 case SysDbgReadPhysical:
2338 case SysDbgWritePhysical:
2339 if (InputBufferLength != sizeof(SYSDBG_PHYSICAL))
2340 {
2341 Status = STATUS_INFO_LENGTH_MISMATCH;
2342 }
2343 else
2344 {
2345 SYSDBG_PHYSICAL Request = *(PSYSDBG_PHYSICAL)InputBuffer;
2346 PVOID LockedBuffer;
2347 PMDL LockVariable;
2348
2349 Status = ExLockUserBuffer(Request.Buffer,
2350 Request.Request,
2351 PreviousMode,
2352 Command == SysDbgReadVirtual ? IoWriteAccess : IoReadAccess,
2353 &LockedBuffer,
2354 &LockVariable);
2355 if (NT_SUCCESS(Status))
2356 {
2357 Status = KdpCopyMemoryChunks(Request.Address.QuadPart,
2358 Request.Buffer,
2359 Request.Request,
2360 0,
2361 MMDBG_COPY_PHYSICAL | (Command == SysDbgReadVirtual ? 0 : MMDBG_COPY_WRITE),
2362 &Length);
2363 ExUnlockUserBuffer(LockVariable);
2364 }
2365 }
2366 break;
2367
2368 case SysDbgReadControlSpace:
2369 if (InputBufferLength != sizeof(SYSDBG_CONTROL_SPACE))
2370 {
2371 Status = STATUS_INFO_LENGTH_MISMATCH;
2372 }
2373 else
2374 {
2375 SYSDBG_CONTROL_SPACE Request = *(PSYSDBG_CONTROL_SPACE)InputBuffer;
2376 PVOID LockedBuffer;
2377 PMDL LockVariable;
2378
2379 Status = ExLockUserBuffer(Request.Buffer,
2380 Request.Request,
2381 PreviousMode,
2382 IoWriteAccess,
2383 &LockedBuffer,
2384 &LockVariable);
2385 if (NT_SUCCESS(Status))
2386 {
2387 Status = KdpSysReadControlSpace(Request.Processor,
2388 Request.Address,
2389 LockedBuffer,
2390 Request.Request,
2391 &Length);
2392 ExUnlockUserBuffer(LockVariable);
2393 }
2394 }
2395 break;
2396
2397 case SysDbgWriteControlSpace:
2398 if (InputBufferLength != sizeof(SYSDBG_CONTROL_SPACE))
2399 {
2400 Status = STATUS_INFO_LENGTH_MISMATCH;
2401 }
2402 else
2403 {
2404 SYSDBG_CONTROL_SPACE Request = *(PSYSDBG_CONTROL_SPACE)InputBuffer;
2405 PVOID LockedBuffer;
2406 PMDL LockVariable;
2407
2408 Status = ExLockUserBuffer(Request.Buffer,
2409 Request.Request,
2410 PreviousMode,
2411 IoReadAccess,
2412 &LockedBuffer,
2413 &LockVariable);
2414 if (NT_SUCCESS(Status))
2415 {
2416 Status = KdpSysWriteControlSpace(Request.Processor,
2417 Request.Address,
2418 LockedBuffer,
2419 Request.Request,
2420 &Length);
2421 ExUnlockUserBuffer(LockVariable);
2422 }
2423 }
2424 break;
2425
2426 case SysDbgReadIoSpace:
2427 if (InputBufferLength != sizeof(SYSDBG_IO_SPACE))
2428 {
2429 Status = STATUS_INFO_LENGTH_MISMATCH;
2430 }
2431 else
2432 {
2433 SYSDBG_IO_SPACE Request = *(PSYSDBG_IO_SPACE)InputBuffer;
2434 PVOID LockedBuffer;
2435 PMDL LockVariable;
2436
2437 Status = ExLockUserBuffer(Request.Buffer,
2438 Request.Request,
2439 PreviousMode,
2440 IoWriteAccess,
2441 &LockedBuffer,
2442 &LockVariable);
2443 if (NT_SUCCESS(Status))
2444 {
2445 Status = KdpSysReadIoSpace(Request.InterfaceType,
2446 Request.BusNumber,
2447 Request.AddressSpace,
2448 Request.Address,
2449 LockedBuffer,
2450 Request.Request,
2451 &Length);
2452 ExUnlockUserBuffer(LockVariable);
2453 }
2454 }
2455 break;
2456
2457 case SysDbgWriteIoSpace:
2458 if (InputBufferLength != sizeof(SYSDBG_IO_SPACE))
2459 {
2460 Status = STATUS_INFO_LENGTH_MISMATCH;
2461 }
2462 else
2463 {
2464 SYSDBG_IO_SPACE Request = *(PSYSDBG_IO_SPACE)InputBuffer;
2465 PVOID LockedBuffer;
2466 PMDL LockVariable;
2467
2468 Status = ExLockUserBuffer(Request.Buffer,
2469 Request.Request,
2470 PreviousMode,
2471 IoReadAccess,
2472 &LockedBuffer,
2473 &LockVariable);
2474 if (NT_SUCCESS(Status))
2475 {
2476 Status = KdpSysWriteIoSpace(Request.InterfaceType,
2477 Request.BusNumber,
2478 Request.AddressSpace,
2479 Request.Address,
2480 LockedBuffer,
2481 Request.Request,
2482 &Length);
2483 ExUnlockUserBuffer(LockVariable);
2484 }
2485 }
2486 break;
2487
2488 case SysDbgReadMsr:
2489 if (InputBufferLength != sizeof(SYSDBG_MSR))
2490 {
2491 Status = STATUS_INFO_LENGTH_MISMATCH;
2492 }
2493 else
2494 {
2495 PSYSDBG_MSR Request = (PSYSDBG_MSR)InputBuffer;
2496 Status = KdpSysReadMsr(Request->Address, &Request->Data);
2497 }
2498 break;
2499
2500 case SysDbgWriteMsr:
2501 if (InputBufferLength != sizeof(SYSDBG_MSR))
2502 {
2503 Status = STATUS_INFO_LENGTH_MISMATCH;
2504 }
2505 else
2506 {
2507 PSYSDBG_MSR Request = (PSYSDBG_MSR)InputBuffer;
2508 Status = KdpSysWriteMsr(Request->Address, &Request->Data);
2509 }
2510 break;
2511
2512 case SysDbgReadBusData:
2513 if (InputBufferLength != sizeof(SYSDBG_BUS_DATA))
2514 {
2515 Status = STATUS_INFO_LENGTH_MISMATCH;
2516 }
2517 else
2518 {
2519 SYSDBG_BUS_DATA Request = *(PSYSDBG_BUS_DATA)InputBuffer;
2520 PVOID LockedBuffer;
2521 PMDL LockVariable;
2522
2523 Status = ExLockUserBuffer(Request.Buffer,
2524 Request.Request,
2525 PreviousMode,
2526 IoWriteAccess,
2527 &LockedBuffer,
2528 &LockVariable);
2529 if (NT_SUCCESS(Status))
2530 {
2531 Status = KdpSysReadBusData(Request.BusDataType,
2532 Request.BusNumber,
2533 Request.SlotNumber,
2534 Request.Address,
2535 LockedBuffer,
2536 Request.Request,
2537 &Length);
2538 ExUnlockUserBuffer(LockVariable);
2539 }
2540 }
2541 break;
2542
2543 case SysDbgWriteBusData:
2544 if (InputBufferLength != sizeof(SYSDBG_BUS_DATA))
2545 {
2546 Status = STATUS_INFO_LENGTH_MISMATCH;
2547 }
2548 else
2549 {
2550 SYSDBG_BUS_DATA Request = *(PSYSDBG_BUS_DATA)InputBuffer;
2551 PVOID LockedBuffer;
2552 PMDL LockVariable;
2553
2554 Status = ExLockUserBuffer(Request.Buffer,
2555 Request.Request,
2556 PreviousMode,
2557 IoReadAccess,
2558 &LockedBuffer,
2559 &LockVariable);
2560 if (NT_SUCCESS(Status))
2561 {
2562 Status = KdpSysWriteBusData(Request.BusDataType,
2563 Request.BusNumber,
2564 Request.SlotNumber,
2565 Request.Address,
2566 LockedBuffer,
2567 Request.Request,
2568 &Length);
2569 ExUnlockUserBuffer(LockVariable);
2570 }
2571 }
2572 break;
2573
2574 case SysDbgCheckLowMemory:
2575 Status = KdpSysCheckLowMemory(0);
2576 break;
2577
2578 default:
2579 Status = STATUS_INVALID_INFO_CLASS;
2580 break;
2581 }
2582
2583 if (ReturnLength)
2584 *ReturnLength = Length;
2585
2586 return Status;
2587}
ReturnLength
_In_ PVOID _In_ ULONG _Out_ PVOID _In_ ULONG _Inout_ PULONG ReturnLength
Definition: KdSystemDebugControl.c:34
PreviousMode
_In_ PVOID _In_ ULONG _Out_ PVOID _In_ ULONG _Inout_ PULONG _In_ KPROCESSOR_MODE PreviousMode
Definition: KdSystemDebugControl.c:35
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
KeRosDumpStackFrames
#define KeRosDumpStackFrames(Frames, Count)
Definition: gdidebug.h:11
Status
Status
Definition: gdiplustypes.h:25
KdpSysWriteBusData
NTSTATUS NTAPI KdpSysWriteBusData(_In_ BUS_DATA_TYPE BusDataType, _In_ ULONG BusNumber, _In_ ULONG SlotNumber, _In_ ULONG Offset, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _Out_ PULONG ActualLength)
Definition: kdx64.c:151
KdpSysCheckLowMemory
NTSTATUS NTAPI KdpSysCheckLowMemory(IN ULONG Flags)
Definition: kdx64.c:364
KdpSysWriteIoSpace
NTSTATUS NTAPI KdpSysWriteIoSpace(_In_ INTERFACE_TYPE InterfaceType, _In_ ULONG BusNumber, _In_ ULONG AddressSpace, _In_ ULONG64 IoAddress, _In_reads_bytes_(DataSize) PVOID DataValue, _In_ ULONG DataSize, _Out_ PULONG ActualDataSize)
Definition: kdx64.c:307
KdpSysWriteMsr
NTSTATUS NTAPI KdpSysWriteMsr(_In_ ULONG Msr, _In_ PULONGLONG MsrValue)
Definition: kdx64.c:116
KdpSysReadMsr
NTSTATUS NTAPI KdpSysReadMsr(_In_ ULONG Msr, _Out_ PULONGLONG MsrValue)
Definition: kdx64.c:96
KdpSysReadControlSpace
NTSTATUS NTAPI KdpSysReadControlSpace(_In_ ULONG Processor, _In_ ULONG64 BaseAddress, _Out_writes_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _Out_ PULONG ActualLength)
Definition: kdx64.c:166
KdpSysReadBusData
NTSTATUS NTAPI KdpSysReadBusData(_In_ BUS_DATA_TYPE BusDataType, _In_ ULONG BusNumber, _In_ ULONG SlotNumber, _In_ ULONG Offset, _Out_writes_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _Out_ PULONG ActualLength)
Definition: kdx64.c:136
KdpSysWriteControlSpace
NTSTATUS NTAPI KdpSysWriteControlSpace(_In_ ULONG Processor, _In_ ULONG64 BaseAddress, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _Out_ PULONG ActualLength)
Definition: kdx64.c:218
KdpSysReadIoSpace
NTSTATUS NTAPI KdpSysReadIoSpace(_In_ INTERFACE_TYPE InterfaceType, _In_ ULONG BusNumber, _In_ ULONG AddressSpace, _In_ ULONG64 IoAddress, _Out_writes_bytes_(DataSize) PVOID DataValue, _In_ ULONG DataSize, _Out_ PULONG ActualDataSize)
Definition: kdx64.c:250
PspDumpThreads
VOID NTAPI PspDumpThreads(BOOLEAN SystemThreads)
KdpCopyMemoryChunks
NTSTATUS NTAPI KdpCopyMemoryChunks(_In_ ULONG64 Address, _In_ PVOID Buffer, _In_ ULONG TotalSize, _In_ ULONG ChunkSize, _In_ ULONG Flags, _Out_opt_ PULONG ActualSize)
Definition: kdapi.c:55
KdpSysGetVersion
VOID NTAPI KdpSysGetVersion(_Out_ PDBGKD_GET_VERSION64 Version)
Definition: kdapi.c:433
KdbRegisterCliCallback
BOOLEAN NTAPI KdbRegisterCliCallback(PVOID Callback, BOOLEAN Deregister)
Definition: kdb_cli.c:3203
ULONG64
unsigned __int64 ULONG64
Definition: imports.h:198
PSYSDBG_MSR
struct _SYSDBG_MSR * PSYSDBG_MSR
PSYSDBG_CONTROL_SPACE
struct _SYSDBG_CONTROL_SPACE * PSYSDBG_CONTROL_SPACE
PSYSDBG_BUS_DATA
struct _SYSDBG_BUS_DATA * PSYSDBG_BUS_DATA
PSYSDBG_PHYSICAL
struct _SYSDBG_PHYSICAL * PSYSDBG_PHYSICAL
SysDbgCheckLowMemory
@ SysDbgCheckLowMemory
Definition: kdtypes.h:82
SysDbgReadPhysical
@ SysDbgReadPhysical
Definition: kdtypes.h:72
SysDbgReadMsr
@ SysDbgReadMsr
Definition: kdtypes.h:78
SysDbgWriteControlSpace
@ SysDbgWriteControlSpace
Definition: kdtypes.h:75
SysDbgWriteBusData
@ SysDbgWriteBusData
Definition: kdtypes.h:81
SysDbgWriteVirtual
@ SysDbgWriteVirtual
Definition: kdtypes.h:71
SysDbgWritePhysical
@ SysDbgWritePhysical
Definition: kdtypes.h:73
SysDbgQueryVersion
@ SysDbgQueryVersion
Definition: kdtypes.h:69
SysDbgReadControlSpace
@ SysDbgReadControlSpace
Definition: kdtypes.h:74
SysDbgReadBusData
@ SysDbgReadBusData
Definition: kdtypes.h:80
SysDbgReadIoSpace
@ SysDbgReadIoSpace
Definition: kdtypes.h:76
SysDbgWriteMsr
@ SysDbgWriteMsr
Definition: kdtypes.h:79
SysDbgReadVirtual
@ SysDbgReadVirtual
Definition: kdtypes.h:70
SysDbgWriteIoSpace
@ SysDbgWriteIoSpace
Definition: kdtypes.h:77
PSYSDBG_IO_SPACE
struct _SYSDBG_IO_SPACE * PSYSDBG_IO_SPACE
PSYSDBG_VIRTUAL
struct _SYSDBG_VIRTUAL * PSYSDBG_VIRTUAL
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
ExUnlockUserBuffer
VOID NTAPI ExUnlockUserBuffer(PMDL Mdl)
Definition: sysinfo.c:194
ExLockUserBuffer
NTSTATUS NTAPI ExLockUserBuffer(PVOID BaseAddress, ULONG Length, KPROCESSOR_MODE AccessMode, LOCK_OPERATION Operation, PVOID *MappedSystemVa, PMDL *OutMdl)
Definition: sysinfo.c:202
MMDBG_COPY_PHYSICAL
#define MMDBG_COPY_PHYSICAL
Definition: mm.h:76
MmDumpArmPfnDatabase
VOID NTAPI MmDumpArmPfnDatabase(IN BOOLEAN StatusOnly)
Definition: mminit.c:1465
MMDBG_COPY_WRITE
#define MMDBG_COPY_WRITE
Definition: mm.h:75
STATUS_INVALID_INFO_CLASS
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:333
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
Command
Definition: shell.h:41
_DBGKD_GET_VERSION64
Definition: wdbgexts.h:153
_SYSDBG_BUS_DATA
Definition: kdtypes.h:145
_SYSDBG_CONTROL_SPACE
Definition: kdtypes.h:127
_SYSDBG_IO_SPACE
Definition: kdtypes.h:135
_SYSDBG_MSR
Definition: kdtypes.h:155
_SYSDBG_PHYSICAL
Definition: kdtypes.h:113
_SYSDBG_VIRTUAL
Definition: kdtypes.h:120
PULONG_PTR
uint32_t * PULONG_PTR
Definition: typedefs.h:65
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
ULONG
uint32_t ULONG
Definition: typedefs.h:59
STATUS_INFO_LENGTH_MISMATCH
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
Request
_In_ WDFREQUEST Request
Definition: wdfdevice.h:547
OutputBufferLength
_In_ WDFREQUEST _In_ size_t OutputBufferLength
Definition: wdfio.h:320
InputBufferLength
_In_ WDFREQUEST _In_ size_t _In_ size_t InputBufferLength
Definition: wdfio.h:322
OutputBuffer
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR OutputBuffer
Definition: wdfiotarget.h:863
InputBuffer
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR InputBuffer
Definition: wdfiotarget.h:953
IoReadAccess
@ IoReadAccess
Definition: ketypes.h:915
IoWriteAccess
@ IoWriteAccess
Definition: ketypes.h:916

Referenced by DriverEntry(), i8042KbdInterruptService(), KdbpCmdRegs(), KdRosDumpStackFrames(), KdRosSetDebugCallback(), and NtSystemDebugControl().

◆ NtQueryDebugFilterState()

NTSYSCALLAPI NTSTATUS NTAPI NtQueryDebugFilterState ( _In_ ULONG  ComponentId,
_In_ ULONG  Level 
)

Definition at line 2712 of file kdapi.c.

2715{
2716 PULONG Mask;
2717
2718 /* Check if the ID fits in the component table */
2719 if (ComponentId < KdComponentTableSize)
2720 {
2721 /* It does, so get the mask from there */
2722 Mask = KdComponentTable[ComponentId];
2723 }
2724 else if (ComponentId == MAXULONG)
2725 {
2726 /*
2727 * This is the internal ID used for DbgPrint messages without ID
2728 * and Level. Use the system-wide mask for those.
2729 */
2730 Mask = &Kd_WIN2000_Mask;
2731 }
2732 else
2733 {
2734#if (NTDDI_VERSION >= NTDDI_VISTA)
2735 /* Use the default component ID */
2736 Mask = &Kd_DEFAULT_Mask;
2737 // Level = DPFLTR_INFO_LEVEL; // Override the Level.
2738#else
2739 /* Invalid ID, fail */
2740 return STATUS_INVALID_PARAMETER_1;
2741#endif
2742 }
2743
2744 /* Convert Level to bit field if required */
2745 if (Level < 32) Level = 1 << Level;
2746 Level &= ~DPFLTR_MASK;
2747
2748 /* Determine if this Level is filtered out */
2749 if ((Kd_WIN2000_Mask & Level) || (*Mask & Level))
2750 {
2751 /* This mask will get through to the debugger */
2752 return (NTSTATUS)TRUE;
2753 }
2754 else
2755 {
2756 /* This mask is filtered out */
2757 return (NTSTATUS)FALSE;
2758 }
2759}
ComponentId
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 ACPI_STATUS const char UINT32 ACPI_STATUS const char UINT32 const char const char UINT32 ComponentId
Definition: acpixf.h:1281
Mask
unsigned int Mask
Definition: fpcontrol.c:82
Kd_WIN2000_Mask
ULONG Kd_WIN2000_Mask
Definition: kddata.c:143
KdComponentTableSize
ULONG KdComponentTableSize
Definition: kddata.c:484
Kd_DEFAULT_Mask
ULONG Kd_DEFAULT_Mask
Definition: kddata.c:245
KdComponentTable
PULONG KdComponentTable[MAX_KD_COMPONENT_TABLE_ENTRIES]
Definition: kddata.c:314
STATUS_INVALID_PARAMETER_1
#define STATUS_INVALID_PARAMETER_1
Definition: ntstatus.h:569
MAXULONG
#define MAXULONG
Definition: typedefs.h:251
PULONG
uint32_t * PULONG
Definition: typedefs.h:59
Level
_IRQL_requires_same_ typedef _In_ ULONG _In_ UCHAR Level
Definition: wmitypes.h:56

Referenced by DbgQueryDebugFilterState(), KdpPrint(), and vDbgPrintExWithPrefixInternal().

◆ NtSetDebugFilterState()

NTSYSCALLAPI NTSTATUS NTAPI NtSetDebugFilterState ( _In_ ULONG  ComponentId,
_In_ ULONG  Level,
_In_ BOOLEAN  State 
)

Definition at line 2766 of file kdapi.c.

2770{
2771 PULONG Mask;
2772
2773 /* Modifying debug filters requires the debug privilege */
2774 if (!SeSinglePrivilegeCheck(SeDebugPrivilege, ExGetPreviousMode()))
2775 {
2776 /* Fail */
2777 return STATUS_ACCESS_DENIED;
2778 }
2779
2780 /* Check if the ID fits in the component table */
2781 if (ComponentId < KdComponentTableSize)
2782 {
2783 /* It does, so get the mask from there */
2784 Mask = KdComponentTable[ComponentId];
2785 }
2786 else if (ComponentId == MAXULONG)
2787 {
2788 /*
2789 * This is the internal ID used for DbgPrint messages without ID
2790 * and Level. Use the system-wide mask for those.
2791 */
2792 Mask = &Kd_WIN2000_Mask;
2793 }
2794 else
2795 {
2796#if (NTDDI_VERSION >= NTDDI_VISTA)
2797 /* Use the default component ID */
2798 Mask = &Kd_DEFAULT_Mask;
2799#else
2800 /* Invalid ID, fail */
2801 return STATUS_INVALID_PARAMETER_1;
2802#endif
2803 }
2804
2805 /* Convert Level to bit field if required */
2806 if (Level < 32) Level = 1 << Level;
2807 Level &= ~DPFLTR_MASK;
2808
2809 /* Set or remove the Level */
2810 if (State)
2811 *Mask |= Level;
2812 else
2813 *Mask &= ~Level;
2814
2815 return STATUS_SUCCESS;
2816}
ExGetPreviousMode
#define ExGetPreviousMode
Definition: ex.h:143
SeDebugPrivilege
const LUID SeDebugPrivilege
Definition: priv.c:39
SeSinglePrivilegeCheck
BOOLEAN NTAPI SeSinglePrivilegeCheck(_In_ LUID PrivilegeValue, _In_ KPROCESSOR_MODE PreviousMode)
Checks if a single privilege is present in the context of the calling thread.
Definition: priv.c:744
STATUS_ACCESS_DENIED
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145

Referenced by DbgSetDebugFilterState(), and KdbpCmdFilter().

◆ NtSystemDebugControl()

NTSYSCALLAPI NTSTATUS NTAPI NtSystemDebugControl ( _In_ SYSDBG_COMMAND  Command,
_In_reads_bytes_(InputBufferLength) PVOID  InputBuffer,
_In_ ULONG  InputBufferLength,
_Out_writes_bytes_(OutputBufferLength) PVOID  OutputBuffer,
_In_ ULONG  OutputBufferLength,
_Out_opt_ PULONG  ReturnLength 
)

Perform various queries to the kernel debugger.

Parameters
[in]CommandA SYSDBG_COMMAND value describing the kernel debugger command to perform.
[in]InputBufferPointer to a user-provided input command-specific buffer, whose length is given by InputBufferLength.
[in]InputBufferLengthThe size (in bytes) of the buffer pointed by InputBuffer.
[out]OutputBufferPointer to a user-provided command-specific output buffer, whose length is given by OutputBufferLength.
[in]OutputBufferLengthThe size (in bytes) of the buffer pointed by OutputBuffer.
[out]ReturnLengthOptional pointer to a ULONG variable that receives the actual length of data written written in the output buffer. It is always zero, except for the live dump commands where an actual non-zero length is returned.
Returns
STATUS_SUCCESS in case of success, or a proper error code otherwise.
Remarks
  • The caller must have SeDebugPrivilege, otherwise the function fails with STATUS_ACCESS_DENIED.
  • Only the live dump commands: SysDbgGetTriageDump, and SysDbgGetLiveKernelDump (Win8.1+) are available even if the debugger is disabled or absent.

  • The following system-critical commands are not accessible anymore for user-mode usage with this API on NT 5.2+ (Windows 2003 SP1 and later) systems:

    SysDbgQueryVersion, SysDbgReadVirtual and SysDbgWriteVirtual, SysDbgReadPhysical and SysDbgWritePhysical, SysDbgReadControlSpace and SysDbgWriteControlSpace, SysDbgReadIoSpace and SysDbgWriteIoSpace, SysDbgReadMsr and SysDbgWriteMsr, SysDbgReadBusData and SysDbgWriteBusData, SysDbgCheckLowMemory.

    For these, NtSystemDebugControl() will return STATUS_NOT_IMPLEMENTED. They are now available from kernel-mode only with KdSystemDebugControl().

Note
See: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2004-2339
See also
KdSystemDebugControl()

Definition at line 209 of file dbgctrl.c.

216{
217 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
218 ULONG Length = 0;
219 NTSTATUS Status;
220
221 /* Debugger controlling requires the debug privilege */
222 if (!SeSinglePrivilegeCheck(SeDebugPrivilege, PreviousMode))
223 return STATUS_ACCESS_DENIED;
224
225 _SEH2_TRY
226 {
227 if (PreviousMode != KernelMode)
228 {
229 if (InputBufferLength)
230 ProbeForRead(InputBuffer, InputBufferLength, sizeof(ULONG));
231 if (OutputBufferLength)
232 ProbeForWrite(OutputBuffer, OutputBufferLength, sizeof(ULONG));
233 if (ReturnLength)
234 ProbeForWriteUlong(ReturnLength);
235 }
236
237 switch (Command)
238 {
239 case SysDbgQueryModuleInformation:
240 /* Removed in WinNT4 */
241 Status = STATUS_INVALID_INFO_CLASS;
242 break;
243
244#ifdef _M_IX86
245 case SysDbgQueryTraceInformation:
246 case SysDbgSetTracepoint:
247 case SysDbgSetSpecialCall:
248 case SysDbgClearSpecialCalls:
249 case SysDbgQuerySpecialCalls:
250 UNIMPLEMENTED;
251 Status = STATUS_NOT_IMPLEMENTED;
252 break;
253#endif
254
255 case SysDbgQueryVersion:
256 case SysDbgReadVirtual:
257 case SysDbgWriteVirtual:
258 case SysDbgReadPhysical:
259 case SysDbgWritePhysical:
260 case SysDbgReadControlSpace:
261 case SysDbgWriteControlSpace:
262 case SysDbgReadIoSpace:
263 case SysDbgWriteIoSpace:
264 case SysDbgReadMsr:
265 case SysDbgWriteMsr:
266 case SysDbgReadBusData:
267 case SysDbgWriteBusData:
268 case SysDbgCheckLowMemory:
269 /* Those are implemented in KdSystemDebugControl */
270 if (InitIsWinPEMode)
271 {
272 Status = KdSystemDebugControl(Command,
273 InputBuffer, InputBufferLength,
274 OutputBuffer, OutputBufferLength,
275 &Length, PreviousMode);
276 }
277 else
278 {
279 Status = STATUS_NOT_IMPLEMENTED;
280 }
281 break;
282
283 case SysDbgBreakPoint:
284 if (KdDebuggerEnabled)
285 {
286 DbgBreakPointWithStatus(DBG_STATUS_DEBUG_CONTROL);
287 Status = STATUS_SUCCESS;
288 }
289 else
290 {
291 Status = STATUS_UNSUCCESSFUL;
292 }
293 break;
294
295 case SysDbgEnableKernelDebugger:
296 Status = KdEnableDebugger();
297 break;
298
299 case SysDbgDisableKernelDebugger:
300 Status = KdDisableDebugger();
301 break;
302
303 case SysDbgGetAutoKdEnable:
304 if (OutputBufferLength != sizeof(BOOLEAN))
305 {
306 Status = STATUS_INFO_LENGTH_MISMATCH;
307 }
308 else
309 {
310 *(PBOOLEAN)OutputBuffer = KdAutoEnableOnEvent;
311 Status = STATUS_SUCCESS;
312 }
313 break;
314
315 case SysDbgSetAutoKdEnable:
316 if (InputBufferLength != sizeof(BOOLEAN))
317 {
318 Status = STATUS_INFO_LENGTH_MISMATCH;
319 }
320 else if (KdPitchDebugger)
321 {
322 Status = STATUS_ACCESS_DENIED;
323 }
324 else
325 {
326 KdAutoEnableOnEvent = *(PBOOLEAN)InputBuffer;
327 Status = STATUS_SUCCESS;
328 }
329 break;
330
331 case SysDbgGetPrintBufferSize:
332 if (OutputBufferLength != sizeof(ULONG))
333 {
334 Status = STATUS_INFO_LENGTH_MISMATCH;
335 }
336 else
337 {
338 /* Return buffer size only if KD is enabled */
339 *(PULONG)OutputBuffer = KdPitchDebugger ? 0 : KdPrintBufferSize;
340 Status = STATUS_SUCCESS;
341 }
342 break;
343
344 case SysDbgSetPrintBufferSize:
345 UNIMPLEMENTED;
346 Status = STATUS_NOT_IMPLEMENTED;
347 break;
348
349 case SysDbgGetKdUmExceptionEnable:
350 if (OutputBufferLength != sizeof(BOOLEAN))
351 {
352 Status = STATUS_INFO_LENGTH_MISMATCH;
353 }
354 else
355 {
356 /* Unfortunately, the internal flag says if UM exceptions are disabled */
357 *(PBOOLEAN)OutputBuffer = !KdIgnoreUmExceptions;
358 Status = STATUS_SUCCESS;
359 }
360 break;
361
362 case SysDbgSetKdUmExceptionEnable:
363 if (InputBufferLength != sizeof(BOOLEAN))
364 {
365 Status = STATUS_INFO_LENGTH_MISMATCH;
366 }
367 else if (KdPitchDebugger)
368 {
369 Status = STATUS_ACCESS_DENIED;
370 }
371 else
372 {
373 /* Unfortunately, the internal flag says if UM exceptions are disabled */
374 KdIgnoreUmExceptions = !*(PBOOLEAN)InputBuffer;
375 Status = STATUS_SUCCESS;
376 }
377 break;
378
379 case SysDbgGetTriageDump:
380 UNIMPLEMENTED;
381 Status = STATUS_NOT_IMPLEMENTED;
382 break;
383
384 case SysDbgGetKdBlockEnable:
385 if (OutputBufferLength != sizeof(BOOLEAN))
386 {
387 Status = STATUS_INFO_LENGTH_MISMATCH;
388 }
389 else
390 {
391 *(PBOOLEAN)OutputBuffer = KdBlockEnable;
392 Status = STATUS_SUCCESS;
393 }
394 break;
395
396 case SysDbgSetKdBlockEnable:
397 Status = KdChangeOption(KD_OPTION_SET_BLOCK_ENABLE,
398 InputBufferLength,
399 InputBuffer,
400 OutputBufferLength,
401 OutputBuffer,
402 &Length);
403 break;
404
405 default:
406 Status = STATUS_INVALID_INFO_CLASS;
407 break;
408 }
409
410 if (ReturnLength)
411 *ReturnLength = Length;
412
413 _SEH2_YIELD(return Status);
414 }
415 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
416 {
417 _SEH2_YIELD(return _SEH2_GetExceptionCode());
418 }
419 _SEH2_END;
420}
UNIMPLEMENTED
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15
STATUS_NOT_IMPLEMENTED
#define STATUS_NOT_IMPLEMENTED
Definition: d3dkmdt.h:42
ProbeForRead
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
ProbeForWrite
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
EXCEPTION_EXECUTE_HANDLER
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
KdPitchDebugger
BOOLEAN KdPitchDebugger
Definition: kddata.c:80
KdPrintBufferSize
ULONG KdPrintBufferSize
Definition: kddata.c:136
KdBlockEnable
BOOLEAN KdBlockEnable
Definition: kddata.c:84
KdIgnoreUmExceptions
BOOLEAN KdIgnoreUmExceptions
Definition: kddata.c:85
KdAutoEnableOnEvent
BOOLEAN KdAutoEnableOnEvent
Definition: kddata.c:83
KdChangeOption
NTSTATUS NTAPI KdChangeOption(IN KD_OPTION Option, IN ULONG InBufferBytes OPTIONAL, IN PVOID InBuffer, IN ULONG OutBufferBytes OPTIONAL, OUT PVOID OutBuffer, OUT PULONG OutBufferNeeded OPTIONAL)
Definition: kdapi.c:2594
KdSystemDebugControl
NTSTATUS NTAPI KdSystemDebugControl(_In_ SYSDBG_COMMAND Command, _In_reads_bytes_(InputBufferLength) PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_writes_bytes_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _Out_opt_ PULONG ReturnLength, _In_ KPROCESSOR_MODE PreviousMode)
Perform various queries to the kernel debugger.
Definition: kdapi.c:2217
KdDisableDebugger
NTSTATUS NTAPI KdDisableDebugger(VOID)
Definition: kdapi.c:2169
KdEnableDebugger
NTSTATUS NTAPI KdEnableDebugger(VOID)
Definition: kdapi.c:2158
KeGetPreviousMode
#define KeGetPreviousMode()
Definition: ketypes.h:1115
KernelMode
#define KernelMode
Definition: asm.h:38
SysDbgQuerySpecialCalls
@ SysDbgQuerySpecialCalls
Definition: kdtypes.h:67
SysDbgSetTracepoint
@ SysDbgSetTracepoint
Definition: kdtypes.h:64
SysDbgGetPrintBufferSize
@ SysDbgGetPrintBufferSize
Definition: kdtypes.h:87
SysDbgQueryTraceInformation
@ SysDbgQueryTraceInformation
Definition: kdtypes.h:63
SysDbgClearSpecialCalls
@ SysDbgClearSpecialCalls
Definition: kdtypes.h:66
SysDbgGetKdBlockEnable
@ SysDbgGetKdBlockEnable
Definition: kdtypes.h:92
SysDbgEnableKernelDebugger
@ SysDbgEnableKernelDebugger
Definition: kdtypes.h:83
SysDbgGetKdUmExceptionEnable
@ SysDbgGetKdUmExceptionEnable
Definition: kdtypes.h:89
SysDbgBreakPoint
@ SysDbgBreakPoint
Definition: kdtypes.h:68
SysDbgSetKdUmExceptionEnable
@ SysDbgSetKdUmExceptionEnable
Definition: kdtypes.h:90
SysDbgGetAutoKdEnable
@ SysDbgGetAutoKdEnable
Definition: kdtypes.h:85
SysDbgSetPrintBufferSize
@ SysDbgSetPrintBufferSize
Definition: kdtypes.h:88
SysDbgQueryModuleInformation
@ SysDbgQueryModuleInformation
Definition: kdtypes.h:62
SysDbgSetAutoKdEnable
@ SysDbgSetAutoKdEnable
Definition: kdtypes.h:86
SysDbgGetTriageDump
@ SysDbgGetTriageDump
Definition: kdtypes.h:91
SysDbgDisableKernelDebugger
@ SysDbgDisableKernelDebugger
Definition: kdtypes.h:84
SysDbgSetSpecialCall
@ SysDbgSetSpecialCall
Definition: kdtypes.h:65
SysDbgSetKdBlockEnable
@ SysDbgSetKdBlockEnable
Definition: kdtypes.h:93
DBG_STATUS_DEBUG_CONTROL
#define DBG_STATUS_DEBUG_CONTROL
Definition: kdtypes.h:44
InitIsWinPEMode
BOOLEAN InitIsWinPEMode
Definition: init.c:72
_SEH2_GetExceptionCode
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:181
_SEH2_EXCEPT
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
_SEH2_END
#define _SEH2_END
Definition: pseh2_64.h:171
_SEH2_TRY
#define _SEH2_TRY
Definition: pseh2_64.h:71
_SEH2_YIELD
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:184
ProbeForWriteUlong
#define ProbeForWriteUlong(Ptr)
Definition: probe.h:36
PBOOLEAN
unsigned char * PBOOLEAN
Definition: typedefs.h:53
STATUS_UNSUCCESSFUL
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
DbgBreakPointWithStatus
__analysis_noreturn NTSYSAPI VOID NTAPI DbgBreakPointWithStatus(_In_ ULONG Status)
KPROCESSOR_MODE
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
KD_OPTION_SET_BLOCK_ENABLE
@ KD_OPTION_SET_BLOCK_ENABLE
Definition: ketypes.h:576

Referenced by TestSystemDebugControl().

◆ ZwQueryDebugFilterState()

NTSYSAPI NTSTATUS NTAPI ZwQueryDebugFilterState ( ULONG  ComponentId,
ULONG  Level 
)

◆ ZwSetDebugFilterState()

NTSYSAPI NTSTATUS NTAPI ZwSetDebugFilterState ( ULONG  ComponentId,
ULONG  Level,
BOOLEAN  State 
)

◆ ZwSystemDebugControl()

NTSYSAPI NTSTATUS NTAPI ZwSystemDebugControl ( _In_ SYSDBG_COMMAND  Command,
_In_reads_bytes_(InputBufferLength) PVOID  InputBuffer,
_In_ ULONG  InputBufferLength,
_Out_writes_bytes_(OutputBufferLength) PVOID  OutputBuffer,
_In_ ULONG  OutputBufferLength,
_Out_opt_ PULONG  ReturnLength 
)