Обнаружение USB устройства

Привет всем!

Разрабатываю программу для лечения USB-устройств, появились некоторые вопросы:
Как из режима ядра определить что вставлено USB-устройство, аналог WM_DEVICECHANGE для ядра, и еще один вопрос, как можно получить управление первым, сразу как была вставлено USB-устройство?

Спасибо.

 

в DDK есть пример.

 

n0name Этот \DDK\src\storage\filters\diskperf\?

 

Код (Text):

1. NTSTATUS
2. DiskPerfDispatchPnp(
3.     IN PDEVICE_OBJECT DeviceObject,
4.     IN PIRP Irp
5.     )
6. /*++
7.  
8. Routine Description:
9.  
10.     Dispatch for PNP
11.  
12. Arguments:
13.  
14.     DeviceObject    - Supplies the device object.
15.  
16.     Irp             - Supplies the I/O request packet.
17.  
18. Return Value:
19.  
20.     NTSTATUS
21.  
22. --*/
23.  
24. {
25.     PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
26.     NTSTATUS            status;
27.     PDEVICE_EXTENSION   deviceExtension;
28.  
29.     PAGED_CODE();
30.  
31.     DebugPrint((2, "DiskPerfDispatchPnp: Device %X Irp %X\n",
32.         DeviceObject, Irp));
33.  
34.     switch(irpSp->MinorFunction) {
35.  
36.         case IRP_MN_START_DEVICE:
37.             //
38.             // Call the Start Routine handler to schedule a completion routine
39.             //
40.             DebugPrint((3,
41.                "DiskPerfDispatchPnp: Schedule completion for START_DEVICE"));
42.             status = DiskPerfStartDevice(DeviceObject, Irp);
43.             break;
44.  
45.         case IRP_MN_REMOVE_DEVICE:
46.         {
47.             //
48.             // Call the Remove Routine handler to schedule a completion routine
49.             //
50.             DebugPrint((3,
51.                "DiskPerfDispatchPnp: Schedule completion for REMOVE_DEVICE"));
52.             status = DiskPerfRemoveDevice(DeviceObject, Irp);
53.             break;
54.         }
55.         case IRP_MN_DEVICE_USAGE_NOTIFICATION:
56.         {
57.             PIO_STACK_LOCATION irpStack;
58.             ULONG count;
59.             BOOLEAN setPagable;
60.  
61.             DebugPrint((3,
62.                "DiskPerfDispatchPnp: Processing DEVICE_USAGE_NOTIFICATION"));
63.             irpStack = IoGetCurrentIrpStackLocation(Irp);
64.  
65.             if (irpStack->Parameters.UsageNotification.Type != DeviceUsageTypePaging) {
66.                 status = DiskPerfSendToNextDriver(DeviceObject, Irp);
67.                 break; // out of case statement
68.             }
69.  
70.             deviceExtension = DeviceObject->DeviceExtension;
71.  
72.             //
73.             // wait on the paging path event
74.             //
75.  
76.             status = KeWaitForSingleObject(&deviceExtension->PagingPathCountEvent,
77.                                            Executive, KernelMode,
78.                                            FALSE, NULL);
79.  
80.             //
81.             // if removing last paging device, need to set DO_POWER_PAGABLE
82.             // bit here, and possible re-set it below on failure.
83.             //
84.  
85.             setPagable = FALSE;
86.             if (!irpStack->Parameters.UsageNotification.InPath &&
87.                 deviceExtension->PagingPathCount == 1 ) {
88.  
89.                 //
90.                 // removing the last paging file
91.                 // must have DO_POWER_PAGABLE bits set
92.                 //
93.  
94.                 if (DeviceObject->Flags & DO_POWER_INRUSH) {
95.                     DebugPrint((3, "DiskPerfDispatchPnp: last paging file "
96.                                 "removed but DO_POWER_INRUSH set, so not "
97.                                 "setting PAGABLE bit "
98.                                 "for DO %p\n", DeviceObject));
99.                 } else {
100.                     DebugPrint((2, "DiskPerfDispatchPnp: Setting  PAGABLE "
101.                                 "bit for DO %p\n", DeviceObject));
102.                     DeviceObject->Flags |= DO_POWER_PAGABLE;
103.                     setPagable = TRUE;
104.                 }
105.  
106.             }
107.  
108.             //
109.             // send the irp synchronously
110.             //
111.  
112.             status = DiskPerfForwardIrpSynchronous(DeviceObject, Irp);
113.  
114.             //
115.             // now deal with the failure and success cases.
116.             // note that we are not allowed to fail the irp
117.             // once it is sent to the lower drivers.
118.             //
119.  
120.             if (NT_SUCCESS(status)) {
121.  
122.                 IoAdjustPagingPathCount(
123.                     &deviceExtension->PagingPathCount,
124.                     irpStack->Parameters.UsageNotification.InPath);
125.  
126.                 if (irpStack->Parameters.UsageNotification.InPath) {
127.                     if (deviceExtension->PagingPathCount == 1) {
128.  
129.                         //
130.                         // first paging file addition
131.                         //
132.  
133.                         DebugPrint((3, "DiskPerfDispatchPnp: Clearing PAGABLE bit "
134.                                     "for DO %p\n", DeviceObject));
135.                         DeviceObject->Flags &= ~DO_POWER_PAGABLE;
136.                     }
137.                 }
138.  
139.             } else {
140.  
141.                 //
142.                 // cleanup the changes done above
143.                 //
144.  
145.                 if (setPagable == TRUE) {
146.                     DeviceObject->Flags &= ~DO_POWER_PAGABLE;
147.                     setPagable = FALSE;
148.                 }
149.  
150.             }
151.  
152.             //
153.             // set the event so the next one can occur.
154.             //
155.  
156.             KeSetEvent(&deviceExtension->PagingPathCountEvent,
157.                        IO_NO_INCREMENT, FALSE);
158.  
159.             //
160.             // and complete the irp
161.             //
162.  
163.             IoCompleteRequest(Irp, IO_NO_INCREMENT);
164.             return status;
165.             break;
166.  
167.         }
168.  
169.         default:
170.             DebugPrint((3,
171.                "DiskPerfDispatchPnp: Forwarding irp"));
172.             //
173.             // Simply forward all other Irps
174.             //
175.             return DiskPerfSendToNextDriver(DeviceObject, Irp);
176.  
177.     }
178.  
179.     return status;
180.  
181. } // end DiskPerfDispatchPnp()

 

IoRegisterPlugPlayNotification или фильтр на класс