Как правильно обрабатывать IRP_MJ_PNP и IRP_MJ_POWER в фильтре клавиатуры?

Пишу драйвер фильтр для клавиатуры на С под Windows 10 x64, в написании драйверов я не бельмеса, но неплохо знаю C++.
Я устанавливаю фильтрацию для всех KeyboardClasses.
Устанавливаю фильтр с помощью sc create, sc start
Драйвер фильтрует и работает нормально но есть проблема, BSOD.
Если к ноутбуку подключить дополнительную клавиатуру, установить мой драйвер, зайти в диспетчер задач, удалить подключенную клавиатуру, отказаться от перезагрузки, все работает, но если потом отключить клавиатуру из USB порта я ловлю BSOD. Или BSOD наступает в момент удаления устройства из диспетчера.
Как я понимаю у меня проблемы с обработкой IRP_MJ_POWER , IRP_MJ_PNP что я только не пробывал ничего не получается, ловлю BSOD но по дампу он не в моем файле а в HIDCLASS.SYS.

filter.c

Код (Text):

1.  
2. wchar_t* SrcNameF = L"\\??\\MY.KbFilter%lu\0";
3. wchar_t* DevNameF = L"\\Device\\MY.KbFilter%lu\0";
4.  
5. static
6. VOID
7. _Function_class_(DRIVER_UNLOAD)
8. DriverUnload(PDRIVER_OBJECT DriverObject)
9. {
10.     DbgPrint("DriverUnload");
11.     UNREFERENCED_PARAMETER(DriverObject);
12.     DECLARE_UNICODE_STRING_SIZE(srcName, 255);
13.     LONG SuccessfulDetachments = 0;
14.     LARGE_INTEGER WaitInterval;
15.     WaitInterval.QuadPart = -10 * 1000 * 1000;
16.  
17.     PDEVICE_OBJECT KeyboardClassFilterDevice = DriverObject->DeviceObject;
18.  
19.     while (KeyboardClassFilterDevice != NULL)
20.     {
21.         const PDEVICE_OBJECT KeyboardClassFilterDeviceNext = KeyboardClassFilterDevice->NextDevice;
22.         const PDEVICE_EXTENSION DeviceExtension = KeyboardClassFilterDevice->DeviceExtension;
23.         MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, NULL);
24.         if (DeviceExtension->Deleted == FALSE)
25.         {
26.             IoDetachDevice(DeviceExtension->AttachedDevice);
27.  
28.             do
29.             {
30.                 KeDelayExecutionThread(KernelMode, FALSE, &WaitInterval);
31.             }         while (InterlockedCompareExchange(&DeviceExtension->PendingIrp, 0, 0) > 0);
32.            
33.  
34.             IoDeleteDevice(DeviceExtension->ThisDevice);
35.         }
36.  
37.         DbgPrint("[*] Keyboard filter device #%lu has been detached\n", SuccessfulDetachments++);
38.         RtlUnicodeStringPrintf(&srcName, SrcNameF, DeviceExtension->DeviceIndex);
39.         IoDeleteSymbolicLink(&srcName);
40.  
41.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, NULL);
42.         KeyboardClassFilterDevice = KeyboardClassFilterDeviceNext;
43.     }
44. }
45.  
46. static
47. NTSTATUS
48. _Function_class_(DRIVER_DISPATCH)
49. DispatchPassThrough(PDEVICE_OBJECT DeviceObject, PIRP Irp)
50. {
51.     PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
52.     NTSTATUS status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
53.     if (!NT_SUCCESS(status))
54.     {
55.         status = CompleteRequest(Irp, status, 0);
56.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
57.         return status;
58.     }
59.     PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
60.     if (irpStack->MajorFunction == IRP_MJ_CLOSE)
61.     {
62.         Irp->IoStatus.Status = STATUS_SUCCESS;
63.         Irp->IoStatus.Information = 0;
64.         IoCompleteRequest(Irp, IO_NO_INCREMENT);
65.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
66.         return STATUS_SUCCESS;
67.     }
68.     IoSkipCurrentIrpStackLocation(Irp);
69.  
70.      status = IoCallDriver(((PDEVICE_EXTENSION)DeviceObject->DeviceExtension)->AttachedDevice, Irp);
71.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
72.     return status;
73. }
74.  
75. static
76. NTSTATUS
77. _Function_class_(IO_COMPLETION_ROUTINE)
78. CompletionRoutine(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
79. {
80.     UNREFERENCED_PARAMETER(Context);
81.  
82.     const PDEVICE_EXTENSION DeviceExtenstion = DeviceObject->DeviceExtension;
83.  
84.     if (Irp->PendingReturned)
85.     {
86.         IoMarkIrpPending(Irp);
87.     }
88.  
89.     if (Irp->IoStatus.Status == STATUS_SUCCESS)
90.     {
91.         const ULONG ScanCodesCount = (ULONG)(Irp->IoStatus.Information / sizeof(KEYBOARD_INPUT_DATA));
92.         const PKEYBOARD_INPUT_DATA KeyboardInputData = Irp->AssociatedIrp.SystemBuffer;
93.  
94.         for (ULONG I = 0; I < ScanCodesCount; ++I)
95.         {
96.             const PKEYBOARD_INPUT_DATA ScanCodeInformation = &KeyboardInputData[I];
97.  
98.             if (ScanCodeInformation->Flags == PUSH_BUTTON1 || ScanCodeInformation->Flags == PUSH_BUTTON2)
99.             {
100.                 PushButton(ScanCodeInformation->MakeCode);
101.             }
102.             else if (ScanCodeInformation->Flags == RELEASE_BUTTON1 || ScanCodeInformation->Flags == RELEASE_BUTTON2)
103.             {
104.                 ReleaseButton(ScanCodeInformation->MakeCode);
105.             }
106.  
107.             if (IsCancelCombination() && KeysDisabled == TRUE)
108.             {
109.                 ScanCodeInformation->MakeCode = 0;
110.                 DbgPrint(("COMBINATION CANCELED\n"));
111.             }
112.         }
113.     }
114.  
115.     InterlockedDecrement(&DeviceExtenstion->PendingIrp);
116.  
117.     return STATUS_SUCCESS;
118. }
119.  
120. NTSTATUS DispatchPower(IN PDEVICE_OBJECT deviceObject, IN PIRP Irp)
121. {
122.     PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION)deviceObject->DeviceExtension;
123.     PoStartNextPowerIrp(Irp);
124.     NTSTATUS status;
125.     status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
126.     if (!NT_SUCCESS(status))
127.     {
128.         status = CompleteRequest(Irp, status, 0);
129.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
130.         return status;
131.     }
132.     IoSkipCurrentIrpStackLocation(Irp);
133.     status = PoCallDriver(DeviceExtension->AttachedDevice, Irp);
134.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
135.     return status;
136. }
137.  
138. NTSTATUS DispatchPNP(IN PDEVICE_OBJECT deviceObject, IN PIRP Irp)
139. {
140.     NTSTATUS ntStatus;
141.     PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION)deviceObject->DeviceExtension;
142.     NTSTATUS                status = STATUS_SUCCESS;
143.     status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
144.     if (!NT_SUCCESS(status))
145.     {
146.         status = CompleteRequest(Irp, status, 0);
147.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
148.         return status;
149.     }
150.  
151.     PIO_STACK_LOCATION stackLOCATE = IoGetCurrentIrpStackLocation(Irp);
152.     ULONG function = stackLOCATE->MinorFunction;
153.  
154.     DbgPrint("DispatchPNP1functio :%lu\n", (LONG)function);
155.     if (DeviceExtension == NULL)
156.     {
157.         DbgPrint("DispatchPNP2");
158.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
159.         return STATUS_DEVICE_REMOVED;
160.     }
161.  
162.     if (DeviceExtension->Deleted == FALSE &&
163.         (function == IRP_MN_REMOVE_DEVICE ||
164.          function == IRP_MN_SURPRISE_REMOVAL ||
165.          function == IRP_MN_CANCEL_REMOVE_DEVICE ||
166.         function == IRP_MN_QUERY_REMOVE_DEVICE))
167.     {
168.         DbgPrint("DispatchPNP3");
169.         IoDetachDevice(DeviceExtension->AttachedDevice);
170.         IoDeleteDevice(DeviceExtension->ThisDevice);
171.         DECLARE_UNICODE_STRING_SIZE(srcName, 255);
172.         RtlUnicodeStringPrintf(&srcName, SrcNameF, DeviceExtension->DeviceIndex);
173.         IoDeleteSymbolicLink(&srcName);
174.         DeviceExtension->Deleted = TRUE;
175.         KeysDisabled = FALSE;
176.  
177.         Irp->IoStatus.Status = STATUS_SUCCESS;
178.         Irp->IoStatus.Information = 0;
179.         IoCompleteRequest(Irp, IO_NO_INCREMENT);
180.  
181.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
182.         return STATUS_SUCCESS;
183.     }
184.     if (DeviceExtension->Deleted == TRUE)
185.     {
186.         DbgPrint("DispatchPNP4");
187.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
188.         return STATUS_DEVICE_REMOVED;
189.     }
190.     DbgPrint("DispatchPNP5");
191.     IoSkipCurrentIrpStackLocation(Irp);
192.     ntStatus = IoCallDriver(DeviceExtension->AttachedDevice, Irp);
193.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
194.     return ntStatus;
195. }
196.  
197. static
198. NTSTATUS
199. _Function_class_(DRIVER_DISPATCH)
200. DispatchRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
201. {
202.     DbgPrint("DispatchRead");
203.     const PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
204.     NTSTATUS                status = STATUS_SUCCESS;
205.     status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
206.     if (!NT_SUCCESS(status))
207.     {
208.         status = CompleteRequest(Irp, status, 0);
209.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
210.         return status;
211.     }
212.     InterlockedIncrement(&DeviceExtension->PendingIrp);
213.     IoCopyCurrentIrpStackLocationToNext(Irp);
214.  
215.     status = IoSetCompletionRoutineEx(DeviceObject, Irp, CompletionRoutine, NULL, TRUE, TRUE, TRUE);
216.     if (!NT_SUCCESS(status))
217.     {
218.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
219.         return status;
220.     }
221.  
222.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
223.  
224.     return IoCallDriver(DeviceExtension->AttachedDevice, Irp);
225. }
226.  
227. NTSTATUS
228. NTAPI
229. DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
230. {
231.     DbgPrint("DriverEntry");
232.     UNREFERENCED_PARAMETER(RegistryPath);
233.  
234.     DriverObject->DriverUnload = DriverUnload;
235.  
236.     for (ULONG I = 0; I < IRP_MJ_MAXIMUM_FUNCTION; ++I)
237.     {
238.         DriverObject->MajorFunction[I] = DispatchPassThrough;
239.     }
240.  
241.     DriverObject->MajorFunction[IRP_MJ_READ] = DispatchRead;
242.     DriverObject->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;
243.     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchDeviceControl;
244.     DriverObject->MajorFunction[IRP_MJ_POWER] = DispatchPower;
245.     DriverObject->MajorFunction[IRP_MJ_PNP] = DispatchPNP;
246.  
247.     DECLARE_UNICODE_STRING_SIZE(devName, 255);
248.     DECLARE_UNICODE_STRING_SIZE(srcName, 255);
249.     NTSTATUS Status;
250.     LONG SuccessfulAttachments = 0;
251.     UNICODE_STRING Unicode;
252.     ULONG totalDevices = 0;
253.  
254.     RtlInitUnicodeString(&Unicode, L"IoDriverObjectType");
255.     const POBJECT_TYPE* IoDriverObjectType = MmGetSystemRoutineAddress(&Unicode);
256.  
257.     RtlInitUnicodeString(&Unicode, L"IoDeviceObjectType");
258.     const POBJECT_TYPE* IoDeviceObjectType = MmGetSystemRoutineAddress(&Unicode);
259.  
260.     DbgPrint("DispatchDeviceControl u");
261.     if (IoDriverObjectType != NULL && IoDeviceObjectType != NULL)
262.     {
263.         RtlInitUnicodeString(&Unicode, L"ObReferenceObjectByName");
264.         const FPN_OB_REFERENCE_OBJECT_BY_NAME ObReferenceObjectByName = (FPN_OB_REFERENCE_OBJECT_BY_NAME)MmGetSystemRoutineAddress(&Unicode);
265.  
266.         if (ObReferenceObjectByName != NULL)
267.         {
268.             RtlInitUnicodeString(&Unicode, L"\\Driver\\KbdClass");
269.             PDRIVER_OBJECT KbdClassDriver;
270.             Status = ObReferenceObjectByName(&Unicode,
271.                 OBJ_CASE_INSENSITIVE,
272.                 0,
273.                 0,
274.                 *IoDriverObjectType,
275.                 KernelMode,
276.                 NULL,
277.                 (PVOID)&KbdClassDriver);
278.             if (NT_SUCCESS(Status))
279.             {
280.                 PDEVICE_OBJECT KeyboardClassDevice = KbdClassDriver->DeviceObject;
281.                 while (KeyboardClassDevice != NULL)
282.                 {
283.                     Status = ObReferenceObjectByPointer(KeyboardClassDevice,
284.                         0,
285.                         *IoDeviceObjectType,
286.                         KernelMode);
287.                     if (NT_SUCCESS(Status))
288.                     {
289.                         RtlUnicodeStringPrintf(&devName, DevNameF, totalDevices);
290.                         RtlUnicodeStringPrintf(&srcName, SrcNameF, totalDevices);
291.                         Status = IoCreateSymbolicLink(&srcName, &devName);
292.                         PDEVICE_OBJECT KeyboardClassFilterDevice;
293.                         Status = IoCreateDevice(DriverObject,
294.                             sizeof(DEVICE_EXTENSTION),
295.                             &devName,
296.                             FILE_DEVICE_KEYBOARD,
297.                             0,
298.                             TRUE,
299.                             &KeyboardClassFilterDevice);
300.  
301.                         if (NT_SUCCESS(Status))
302.                         {
303.                             const PDEVICE_EXTENSION DeviceExtenstion = KeyboardClassFilterDevice->DeviceExtension;
304.                             DeviceExtenstion->PendingIrp = 0;
305.                             DeviceExtenstion->Deleted = FALSE;
306.                             DeviceExtenstion->DeviceIndex = totalDevices;
307.                             DeviceExtenstion->AttachedDevice = IoAttachDeviceToDeviceStack(KeyboardClassFilterDevice, KeyboardClassDevice);
308.                             MyIoInitializeRemoveLock(&DeviceExtenstion->RemoveLock, 0, 0, 255);
309.                             if (DeviceExtenstion->AttachedDevice == NULL)
310.                             {
311.                                 IoDeleteDevice(KeyboardClassFilterDevice);
312.                             }
313.                             else
314.                             {
315.                                 DeviceExtenstion->ThisDevice = KeyboardClassFilterDevice;
316.                                 KeyboardClassFilterDevice->Flags |= DO_BUFFERED_IO;
317.                                 KeyboardClassFilterDevice->Flags &= ~DO_DEVICE_INITIALIZING;
318.                                 ++SuccessfulAttachments;
319.                                 totalDevices++;
320.                             }
321.                         }
322.                         ObDereferenceObject(KeyboardClassDevice);
323.                     }
324.                     KeyboardClassDevice = KeyboardClassDevice->NextDevice;
325.                 }
326.                 ObDereferenceObject(KbdClassDriver);
327.             }
328.         }
329.     }
330.     return SuccessfulAttachments != 0 ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
331. }
332. NTSTATUS DispatchCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
333. {
334.     DbgPrint("DispatchCreate");
335.     DEVICE_EXTENSTION* DeviceExtension = (DEVICE_EXTENSTION*)DeviceObject->DeviceExtension;
336.     NTSTATUS                status = STATUS_SUCCESS;
337.     status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
338.     if (!NT_SUCCESS(status))
339.     {
340.         status = CompleteRequest(Irp, status, 0);
341.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
342.         return status;
343.     }
344.     PIO_STACK_LOCATION      ioStackLocation;
345.  
346.     ioStackLocation = IoGetCurrentIrpStackLocation(Irp);
347.     DbgPrint("DispatchCreate :%lu\n", (LONG)ioStackLocation->MinorFunction);
348.     Irp->IoStatus.Status = status;
349.     Irp->IoStatus.Information = 0;
350.  
351.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
352.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
353.     return(STATUS_SUCCESS);
354. }
355. NTSTATUS DispatchDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
356. {
357.     DbgPrint("DispatchDeviceControl");
358.     ULONG                   operation;
359.     PIO_STACK_LOCATION      ioStack;
360.     NTSTATUS                status = STATUS_SUCCESS;
361.     DEVICE_EXTENSTION* DeviceExtension = (DEVICE_EXTENSTION*)DeviceObject->DeviceExtension;
362.     status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
363.     if (!NT_SUCCESS(status))
364.     {
365.         status = CompleteRequest(Irp, status, 0);
366.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
367.         return status;
368.     }
369.  
370.     ioStack = IoGetCurrentIrpStackLocation(Irp);
371.  
372.     operation = ioStack->Parameters.DeviceIoControl.IoControlCode;
373.     DbgPrint("DispatchDeviceControl :%lu\n", (LONG)operation);
374.     switch (operation)
375.     {
376.         case IOCTL_NEXT_KBFILTER_ON:
377.         {
378.             KeysDisabled = TRUE;
379.         }
380.         break;
381.         case IOCTL_NEXT_KBFILTER_OFF:
382.         {
383.             KeysDisabled = FALSE;
384.         }
385.         break;
386.         default:
387.             status = STATUS_INVALID_PARAMETER;
388.             break;
389.     }
390.  
391.     Irp->IoStatus.Status = status;
392.  
393.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
394.  
395.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
396.  
397.     return(status);
398. }
399.  

filter.h

Код (Text):

1.  
2. #pragma once
3. #include <ntddk.h>
4.  
5.  
6. #define PUSH_BUTTON1     0
7. #define RELEASE_BUTTON1     1
8. #define PUSH_BUTTON2     2
9. #define RELEASE_BUTTON2     3
10.  
11.  
12. //
13. // The following value is arbitrarily chosen from the space defined by Microsoft
14. // as being "for non-Microsoft use"
15. //
16. #define FILE_DEVICE_KBFILTER 0xCF52
17. //
18. // Device control codes - values between 2048 and 4095 arbitrarily chosen
19. //
20. #define IOCTL_NEXT_KBFILTER_ON    CTL_CODE(FILE_DEVICE_KBFILTER, 2049, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
21. #define IOCTL_NEXT_KBFILTER_OFF  CTL_CODE(FILE_DEVICE_KBFILTER, 2050, METHOD_BUFFERED, FILE_ANY_ACCESS)
22.  
23.  
24. volatile LONG KeysDisabled = 0;
25. NTSTATUS DispatchCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp);
26. NTSTATUS DispatchDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp);
27.  
28.  
29. typedef struct _MY_IO_REMOVE_LOCK {
30.    LONG usage;  // reference count
31.    BOOLEAN removing;  // true if removal is pending
32.    KEVENT evRemove;  // event to wait on
33. } MY_IO_REMOVE_LOCK, * PMY_IO_REMOVE_LOCK;
34.  
35. typedef struct
36. {
37.    LONG       PendingIrp;
38.    PDEVICE_OBJECT   AttachedDevice;
39.    PDEVICE_OBJECT   ThisDevice;
40.    LONG       DeviceIndex;
41.    BOOLEAN       Deleted;
42.    MY_IO_REMOVE_LOCK RemoveLock;
43. } DEVICE_EXTENSTION, * PDEVICE_EXTENSION;
44.  
45.  
46. typedef NTSTATUS(NTAPI* FPN_OB_REFERENCE_OBJECT_BY_NAME)(PUNICODE_STRING ObjectName,
47.    ULONG Attributes,
48.    PACCESS_STATE AccessState,
49.    ACCESS_MASK DesiredAccess,
50.    POBJECT_TYPE ObjectType,
51.    KPROCESSOR_MODE AccessMode,
52.    PVOID ParseContext,
53.    PVOID* Object);
54.  
55. typedef struct _KEYBOARD_INPUT_DATA {
56.    USHORT UnitId;
57.    USHORT MakeCode;
58.    USHORT Flags;
59.    USHORT Reserved;
60.    ULONG  ExtraInformation;
61. } KEYBOARD_INPUT_DATA, * PKEYBOARD_INPUT_DATA;
62.  
63.  
64. VOID MyIoInitializeRemoveLock(PMY_IO_REMOVE_LOCK lock, ULONG tag, ULONG minutes, ULONG maxcount)
65. {
66.    KeInitializeEvent(&lock->evRemove, NotificationEvent, FALSE);
67.    lock->usage = 1;
68.    lock->removing = FALSE;
69. }
70.  
71. NTSTATUS MyIoAcquireRemoveLock(PMY_IO_REMOVE_LOCK lock, PVOID tag)
72. {
73.    LONG usage = InterlockedIncrement(&lock->usage);
74.    if (lock->removing)
75.    {  // removal in progress
76.      if (InterlockedDecrement(&lock->usage) == 0)
77.        KeSetEvent(&lock->evRemove, 0, FALSE);
78.      return STATUS_DELETE_PENDING;
79.    }  // removal in progress
80.    return STATUS_SUCCESS;
81. }
82. //-------------------------------------------------------------------------------
83. VOID MyIoReleaseRemoveLock(PMY_IO_REMOVE_LOCK lock, PVOID tag)
84. {
85.    if (InterlockedDecrement(&lock->usage) == 0)
86.      KeSetEvent(&lock->evRemove, 0, FALSE);
87. }
88.  
89. VOID MyIoReleaseRemoveLockAndWait(PMY_IO_REMOVE_LOCK lock, PVOID tag)
90. {
91.    lock->removing = TRUE;
92.    MyIoReleaseRemoveLock(lock, tag);
93.    MyIoReleaseRemoveLock(lock, NULL);
94.    KeWaitForSingleObject(&lock->evRemove, Executive, KernelMode, FALSE, NULL);
95. }
96.  
97. NTSTATUS CompleteRequest(IN PIRP Irp, IN NTSTATUS status, IN ULONG_PTR info)
98. {
99.    Irp->IoStatus.Status = status;
100.    Irp->IoStatus.Information = info;
101.    IoCompleteRequest(Irp, IO_NO_INCREMENT);
102.    return status;
103. }
104.  

Dump

Код (Text):

1.  
2.  KEY_VALUES_STRING: 1
3.  
4.   Key  : Analysis.CPU.Sec
5.   Value: 0
6.  
7.   Key  : Analysis.DebugAnalysisProvider.CPP
8.   Value: Create: 8007007e on DESKTOP
9.  
10.   Key  : Analysis.DebugData
11.   Value: CreateObject
12.  
13.   Key  : Analysis.DebugModel
14.   Value: CreateObject
15.  
16.   Key  : Analysis.Elapsed.Sec
17.   Value: 0
18.  
19.   Key  : Analysis.Memory.CommitPeak.Mb
20.   Value: 59
21.  
22.   Key  : Analysis.System
23.   Value: CreateObject
24.  
25.  
26. ADDITIONAL_DEBUG_TEXT:  
27. You can run '.symfix; .reload' to try to fix the symbol path and load symbols.
28.  
29. WRONG_SYMBOLS_TIMESTAMP: b5a82e62
30.  
31. WRONG_SYMBOLS_SIZE: ab5000
32.  
33. FAULTING_MODULE: fffff80239400000 nt
34.  
35. BUGCHECK_CODE:  a
36.  
37. BUGCHECK_P1: 48
38.  
39. BUGCHECK_P2: 2
40.  
41. BUGCHECK_P3: 1
42.  
43. BUGCHECK_P4: fffff80239417bf3
44.  
45. Unable to get size of nt!_MMPTE - probably bad symbols
46.  0000000000000048
47.  
48. STACK_TEXT:  
49. ffffa18e`4ca6f148 fffff802`395d5929 : 00000000`0000000a 00000000`00000048 00000000`00000002 00000000`00000001 : nt!KeBugCheckEx
50. ffffa18e`4ca6f150 fffff802`395d1c69 : 00000000`00000000 00000000`00000000 00000000`00000000 fffff802`39452785 : nt!setjmpex+0x81f9
51. ffffa18e`4ca6f290 fffff802`39417bf3 : 00000000`40420088 00000000`00000000 00000000`00000000 fffff802`394be1c5 : nt!setjmpex+0x4539
52. ffffa18e`4ca6f420 fffff802`42a353f9 : ffffce0d`36af1650 00000000`00000000 00000000`00000002 00000003`05080e42 : nt!KeAcquireSpinLockRaiseToDpc+0x53
53. ffffa18e`4ca6f450 fffff802`3951c541 : ffffce0d`35d26010 ffffce0d`3980aab0 fffff802`40628000 fffff802`42a35350 : HIDCLASS+0x53f9
54. ffffa18e`4ca6f4c0 fffff802`4062c3b8 : ffffce0d`36d664b0 fffff802`40628040 ffffa18e`4ca6f500 ffffce0d`00000000 : nt!IoCancelIrp+0x71
55. ffffa18e`4ca6f500 fffff802`394467f9 : ffffffff`ffb3b4c0 ffffce0d`36d664b0 ffffce0d`36d66ad8 ffffce0d`35c4ada0 : kbdhid+0xc3b8
56. ffffa18e`4ca6f570 fffff802`46fc43db : ffffce0d`36d664b0 ffffce0d`35c4ada0 ffffce0d`35c4ada0 00000000`00000670 : nt!IofCallDriver+0x59
57. ffffa18e`4ca6f5b0 fffff802`394467f9 : 00000000`00000000 00000000`c00000bb ffffce0d`35c4ac50 00000000`69706e00 : kbdclass+0x43db
58. ffffa18e`4ca6f620 fffff802`39a56e0c : ffffa18e`4ca6f6c0 ffffce0d`35c4ac50 ffffa18e`4ca6f720 ffffce0d`36d664b0 : nt!IofCallDriver+0x59
59. ffffa18e`4ca6f660 fffff802`39b311ca : 00000000`00000002 ffffce0d`38ee2c90 ffffce0d`36af1500 ffffce0d`36af1500 : nt!FsRtlNotifyVolumeEventEx+0x78c
60. ffffa18e`4ca6f6e0 fffff802`39572c70 : ffffa307`4a2103c0 ffffce0d`38ee2c90 00000000`0000000a 00000000`00000000 : nt!IoSetDevicePropertyData+0x2ada
61. ffffa18e`4ca6f7a0 fffff802`39b30b7f : ffffce0d`38ee2c90 ffffa307`00000015 00000000`00000000 cb3a4008`00200001 : nt!RtlCrc64+0x13d0
62. ffffa18e`4ca6f800 fffff802`39b3081a : ffffce0d`38ee2c90 ffffa18e`4ca6f880 00000000`00000015 ffffce0d`38ee2c90 : nt!IoSetDevicePropertyData+0x248f
63. ffffa18e`4ca6f840 fffff802`39c01b52 : ffffce0d`36af1500 00000000`00000002 ffffce0d`36af1500 00000000`00000001 : nt!IoSetDevicePropertyData+0x212a
64. ffffa18e`4ca6f8c0 fffff802`39aff04e : ffffa18e`4ca6fa10 ffffce0d`38ee2c00 ffffa18e`4ca6fa00 ffffa307`00000001 : nt!FsRtlRegisterFltMgrCalls+0x76722
65. ffffa18e`4ca6f9b0 fffff802`39a5f9b8 : ffffa307`4a2103c0 ffffa307`49fa2a20 ffffa307`49fa2a20 00000000`00000000 : nt!RtlGetGroupSecurityDescriptor+0x12be
66. ffffa18e`4ca6f9e0 fffff802`394693d5 : ffffce0d`28660cf0 ffffce0d`305e6040 ffffce0d`28660cf0 ffffce0d`00000800 : nt!FsRtlAllocateExtraCreateParameterFromLookasideList+0x10b8
67. ffffa18e`4ca6fa70 fffff802`39527c35 : ffffce0d`305e6040 00000000`00000080 ffffce0d`2867e040 0000256f`b19bbfff : nt!PsReturnProcessNonPagedPoolQuota+0xcd5
68. ffffa18e`4ca6fb10 fffff802`395cb0b8 : ffffba81`27c20180 ffffce0d`305e6040 fffff802`39527be0 00000000`00000000 : nt!RtlIsNonEmptyDirectoryReparsePointAllowed+0x415
69. ffffa18e`4ca6fb60 00000000`00000000 : ffffa18e`4ca70000 ffffa18e`4ca69000 00000000`00000000 00000000`00000000 : nt!KeSynchronizeExecution+0x6408
70.  
71.  
72. STACK_COMMAND:  .thread ; .cxr ; kb
73.  
74. EXCEPTION_CODE_STR:  B5A82E62
75.  
76. EXCEPTION_STR:  WRONG_SYMBOLS
77.  
78. PROCESS_NAME:  ntoskrnl.wrong.symbols.exe
79.  
80. IMAGE_NAME:  ntoskrnl.wrong.symbols.exe
81.  
82. MODULE_NAME: nt_wrong_symbols
83.  
84. SYMBOL_NAME:  nt_wrong_symbols!B5A82E62AB5000
85.  
86. FAILURE_BUCKET_ID:  WRONG_SYMBOLS_X64_18362.1.amd64fre.19h1_release.190318-1202_TIMESTAMP_660730-064658_B5A82E62_nt_wrong_symbols!B5A82E62AB5000
87.  
88. OS_VERSION:  10.0.18362.1
89.  
90. BUILDLAB_STR:  19h1_release
91.  
92. OSPLATFORM_TYPE:  x64
93.  
94. OSNAME:  Windows 10
95.  
96. FAILURE_ID_HASH:  {bd622a0a-c89a-73d9-3319-bcef0893192c}
97.  
98. Followup:  MachineOwner
99. ---------
100.  
101.  
102.  

 

Как не бился ответа не нашел, взял пример из WDK Keyboard_Input_WDF_Filter_Driver__Kbfiltr_
Чуток подправил ini там в устройствах нужно указать
HID_DEVICE_SYSTEM_KEYBOARD
и легко установил через devcon

Код (Text):

1. devcon update KbFilter.inf HID_DEVICE_SYSTEM_KEYBOARD