28、Windows内核编程，IRP的同步(2)
3、StartIo例程
1)系统处理的StartIo
StartIo例程能够保证各个并行的IRP顺序执行，即串行化。
DDK提供一个内部队列，并将IRP用StartIo例程串行化处理。当设备由忙转入空闲状态时，从队列中抽取一个IRP进行处理，并将状态设为忙。一个新的IRP来时，如果设备为忙，则插入到队列当中，如果为空闲，则直接处理。
OS提供kdevice_queue来实现串行化，队列头保存在pDriverObject->DeviceQueue子域中。插入和删除由OS负责。使用这个队列时，需要提供一个叫做StartIo的例程。
pDriverObject->DriverStartIo = HelloDDKStartIO;
这个StartIo例程运行在DISPATCH_LEVEL，不会线程打断的，所以不可分页。派遣函数加入IoStartPacket，就可以把IRP插入到队列中了，这样把IRP实现串行化。IoStartPacket还可以指定取消例程。一般，队列操作从尾部插入，从首部删除。在StartIo例程结束前，应该调用IoStartNextPacket（从队列中抽取下一个IRP，作为参数调用StartIo例程）。
代码
1 //.cpp
2
3 #include "Driver.h"
4
5
6 #pragma LOCKEDCODE
7 VOID
8 HelloDDKStartIO(
9 IN PDEVICE_OBJECT DeviceObject,
10 IN PIRP Irp
11 )
12 {
13 KIRQL oldirql;
14 KdPrint(("Enter HelloDDKStartIO\n"));
15
16 //获取cancel自旋锁
17 IoAcquireCancelSpinLock(&oldirql);
18 if (Irp!=DeviceObject->CurrentIrp||Irp->Cancel)
19 {
20 //如果当前有正在处理的IRP，则简单的入队列，并直接返回
21 //入队列的工作由系统完成，在StartIO中不用负责
22 IoReleaseCancelSpinLock(oldirql);
23 KdPrint(("Leave HelloDDKStartIO\n"));
24 return;
25 }else
26 {
27 //由于正在处理该IRP，所以不允许调用取消例程
28 //因此将此IRP的取消例程设置为NULL
29 IoSetCancelRoutine(Irp,NULL);
30 IoReleaseCancelSpinLock(oldirql);
31 }
32
33 KEVENT event;
34 KeInitializeEvent(&event,NotificationEvent,FALSE);
35
36 //等3秒
37 LARGE_INTEGER timeout;
38 timeout.QuadPart = -3*1000*1000*10;
39
40 //定义一个3秒的延时，主要是为了模拟该IRP操作需要大概3秒左右时间
41 KeWaitForSingleObject(&event,Executive,KernelMode,FALSE,&timeout);
42
43 Irp->IoStatus.Status = STATUS_SUCCESS;
44 Irp->IoStatus.Information = 0; // no bytes xfered
45 IoCompleteRequest(Irp,IO_NO_INCREMENT);
46
47
48 //在队列中读取一个IRP，并进行StartIo
49 IoStartNextPacket(DeviceObject,TRUE);
50
51 KdPrint(("Leave HelloDDKStartIO\n"));
52 }
53
54 /************************************************************************
55 * 函数名称:DriverEntry
56 * 功能描述:初始化驱动程序，定位和申请硬件资源，创建内核对象
57 * 参数列表:
58 pDriverObject:从I/O管理器中传进来的驱动对象
59 pRegistryPath:驱动程序在注册表的中的路径
60 * 返回 值:返回初始化驱动状态
61 *************************************************************************/
62 #pragma INITCODE
63 extern "C" NTSTATUS DriverEntry (
64 IN PDRIVER_OBJECT pDriverObject,
65 IN PUNICODE_STRING pRegistryPath )
66 {
67 NTSTATUS status;
68 KdPrint(("Enter DriverEntry\n"));
69
70 //设置卸载函数
71 pDriverObject->DriverUnload = HelloDDKUnload;
72
73 //设置派遣函数
74 pDriverObject->MajorFunction[IRP_MJ_CREATE] = HelloDDKDispatchRoutin;
75 pDriverObject->MajorFunction[IRP_MJ_CLOSE] = HelloDDKDispatchRoutin;
76 pDriverObject->MajorFunction[IRP_MJ_WRITE] = HelloDDKDispatchRoutin;
77 pDriverObject->MajorFunction[IRP_MJ_READ] = HelloDDKRead;
78 pDriverObject->MajorFunction[IRP_MJ_CLEANUP] = HelloDDKDispatchRoutin;
79 pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = HelloDDKDispatchRoutin;
80 pDriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = HelloDDKDispatchRoutin;
81 pDriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = HelloDDKDispatchRoutin;
82 pDriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = HelloDDKDispatchRoutin;
83
84 //设置StartIO例程
85 pDriverObject->DriverStartIo = HelloDDKStartIO;
86
87 //创建驱动设备对象
88 status = CreateDevice(pDriverObject);
89
90 KdPrint(("Leave DriverEntry\n"));
91 return status;
92 }
93
94 /************************************************************************
95 * 函数名称:CreateDevice
96 * 功能描述:初始化设备对象
97 * 参数列表:
98 pDriverObject:从I/O管理器中传进来的驱动对象
99 * 返回 值:返回初始化状态
100 *************************************************************************/
101 #pragma INITCODE
102 NTSTATUS CreateDevice (
103 IN PDRIVER_OBJECT pDriverObject)
104 {
105 NTSTATUS status;
106 PDEVICE_OBJECT pDevObj;
107 PDEVICE_EXTENSION pDevExt;
108
109 //创建设备名称
110 UNICODE_STRING devName;
111 RtlInitUnicodeString(&devName,L"\\Device\\MyDDKDevice");
112
113 //创建设备
114 status = IoCreateDevice( pDriverObject,
115 sizeof(DEVICE_EXTENSION),
116 &(UNICODE_STRING)devName,
117 FILE_DEVICE_UNKNOWN,
118 0, TRUE,
119 &pDevObj );
120 if (!NT_SUCCESS(status))
121 return status;
122
123 pDevObj->Flags |= DO_BUFFERED_IO;
124 pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
125 pDevExt->pDevice = pDevObj;
126 pDevExt->ustrDeviceName = devName;
127
128 //创建符号链接
129 UNICODE_STRING symLinkName;
130 RtlInitUnicodeString(&symLinkName,L"\\??\\HelloDDK");
131 pDevExt->ustrSymLinkName = symLinkName;
132 status = IoCreateSymbolicLink( &symLinkName,&devName );
133 if (!NT_SUCCESS(status))
134 {
135 IoDeleteDevice( pDevObj );
136 return status;
137 }
138 return STATUS_SUCCESS;
139 }
140
141 /************************************************************************
142 * 函数名称:HelloDDKUnload
143 * 功能描述:负责驱动程序的卸载操作
144 * 参数列表:
145 pDriverObject:驱动对象
146 * 返回 值:返回状态
147 *************************************************************************/
148 #pragma PAGEDCODE
149 VOID HelloDDKUnload (IN PDRIVER_OBJECT pDriverObject)
150 {
151 PDEVICE_OBJECT pNextObj;
152 KdPrint(("Enter DriverUnload\n"));
153 pNextObj = pDriverObject->DeviceObject;
154 while (pNextObj != NULL)
155 {
156 PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
157 pNextObj->DeviceExtension;
158
159 //删除符号链接
160 UNICODE_STRING pLinkName = pDevExt->ustrSymLinkName;
161 IoDeleteSymbolicLink(&pLinkName);
162
163 pNextObj = pNextObj->NextDevice;
164 IoDeleteDevice( pDevExt->pDevice );
165 }
166 }
167
168 /************************************************************************
169 * 函数名称:HelloDDKDispatchRoutin
170 * 功能描述:对读IRP进行处理
171 * 参数列表:
172 pDevObj:功能设备对象
173 pIrp:从IO请求包
174 * 返回 值:返回状态
175 *************************************************************************/
176 #pragma PAGEDCODE
177 NTSTATUS HelloDDKDispatchRoutin(IN PDEVICE_OBJECT pDevObj,
178 IN PIRP pIrp)
179 {
180 KdPrint(("Enter HelloDDKDispatchRoutin\n"));
181
182 PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(pIrp);
183 //建立一个字符串数组与IRP类型对应起来
184 static char* irpname[] =
185 {
186 "IRP_MJ_CREATE",
187 "IRP_MJ_CREATE_NAMED_PIPE",
188 "IRP_MJ_CLOSE",
189 "IRP_MJ_READ",
190 "IRP_MJ_WRITE",
191 "IRP_MJ_QUERY_INFORMATION",
192 "IRP_MJ_SET_INFORMATION",
193 "IRP_MJ_QUERY_EA",
194 "IRP_MJ_SET_EA",
195 "IRP_MJ_FLUSH_BUFFERS",
196 "IRP_MJ_QUERY_VOLUME_INFORMATION",
197 "IRP_MJ_SET_VOLUME_INFORMATION",
198 "IRP_MJ_DIRECTORY_CONTROL",
199 "IRP_MJ_FILE_SYSTEM_CONTROL",
200 "IRP_MJ_DEVICE_CONTROL",
201 "IRP_MJ_INTERNAL_DEVICE_CONTROL",
202 "IRP_MJ_SHUTDOWN",
203 "IRP_MJ_LOCK_CONTROL",
204 "IRP_MJ_CLEANUP",
205 "IRP_MJ_CREATE_MAILSLOT",
206 "IRP_MJ_QUERY_SECURITY",
207 "IRP_MJ_SET_SECURITY",
208 "IRP_MJ_POWER",
209 "IRP_MJ_SYSTEM_CONTROL",
210 "IRP_MJ_DEVICE_CHANGE",
211 "IRP_MJ_QUERY_QUOTA",
212 "IRP_MJ_SET_QUOTA",
213 "IRP_MJ_PNP",
214 };
215
216 UCHAR type = stack->MajorFunction;
217 if (type >= arraysize(irpname))
218 KdPrint((" - Unknown IRP, major type %X\n", type));
219 else
220 KdPrint(("\t%s\n", irpname[type]));
221
222
223 //对一般IRP的简单操作，后面会介绍对IRP更复杂的操作
224 NTSTATUS status = STATUS_SUCCESS;
225 // 完成IRP
226 pIrp->IoStatus.Status = status;
227 pIrp->IoStatus.Information = 0; // bytes xfered
228 IoCompleteRequest( pIrp, IO_NO_INCREMENT );
229
230 KdPrint(("Leave HelloDDKDispatchRoutin\n"));
231
232 return status;
233 }
234
235 VOID
236 OnCancelIRP(
237 IN PDEVICE_OBJECT DeviceObject,
238 IN PIRP Irp
239 )
240 {
241 KdPrint(("Enter CancelReadIRP\n"));
242
243 if (Irp==DeviceObject->CurrentIrp)
244 {
245 //表明当前正在改由StartIo处理
246 //但StartIo并没有获取cancel自旋锁之前
247 //这时候需要
248 KIRQL oldirql = Irp->CancelIrql;
249
250 //释放Cancel自旋锁
251 IoReleaseCancelSpinLock(Irp->CancelIrql);
252
253 IoStartNextPacket(DeviceObject,TRUE);
254
255 KeLowerIrql(oldirql);
256 }else
257 {
258 //从设备队列中将该IRP抽取出来
259 KeRemoveEntryDeviceQueue(&DeviceObject->DeviceQueue,&Irp->Tail.Overlay.DeviceQueueEntry);
260 //释放Cancel自旋锁
261 IoReleaseCancelSpinLock(Irp->CancelIrql);
262 }
263
264
265 //设置完成状态为STATUS_CANCELLED
266 Irp->IoStatus.Status = STATUS_CANCELLED;
267 Irp->IoStatus.Information = 0; // bytes xfered
268 IoCompleteRequest( Irp, IO_NO_INCREMENT );
269
270 KdPrint(("Leave CancelReadIRP\n"));
271 }
272
273
274 NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj,
275 IN PIRP pIrp)
276 {
277 KdPrint(("Enter HelloDDKRead\n"));
278
279 PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
280 pDevObj->DeviceExtension;
281
282 //将IRP设置为挂起
283 IoMarkIrpPending(pIrp);
284
285 //将IRP插入系统的队列
286 IoStartPacket(pDevObj,pIrp,0,OnCancelIRP);
287
288 KdPrint(("Leave HelloDDKRead\n"));
289
290 //返回pending状态
291 return STATUS_PENDING;
292 }
293
294 //应用程序
295 #include <windows.h>
296 #include <stdio.h>
297 #include <process.h>
298
299 UINT WINAPI Thread(LPVOID context)
300 {
301 printf("Enter Thread\n");
302 //等待5秒
303 OVERLAPPED overlap={0};
304 overlap.hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
305 UCHAR buffer[10];
306 ULONG ulRead;
307
308 BOOL bRead = ReadFile(*(PHANDLE)context,buffer,10,&ulRead,&overlap);
309
310 //可以试验取消例程
311 //CancelIo(*(PHANDLE)context);
312 WaitForSingleObject(overlap.hEvent,INFINITE);
313 return 0;
314 }
315
316 int main()
317 {
318 HANDLE hDevice =
319 CreateFile("\\\\.\\HelloDDK",
320 GENERIC_READ | GENERIC_WRITE,
321 FILE_SHARE_READ,
322 NULL,
323 OPEN_EXISTING,
324 FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,//此处设置FILE_FLAG_OVERLAPPED
325 NULL );
326
327 if (hDevice == INVALID_HANDLE_VALUE)
328 {
329 printf("Open Device failed!");
330 return 1;
331 }
332
333 HANDLE hThread[2];
334 hThread[0] = (HANDLE) _beginthreadex (NULL,0,Thread,&hDevice,0,NULL);
335 hThread[1] = (HANDLE) _beginthreadex (NULL,0,Thread,&hDevice,0,NULL);
336
337 //主线程等待两个子线程结束
338 WaitForMultipleObjects(2,hThread,TRUE,INFINITE);
339
340 //创建IRP_MJ_CLEANUP IRP
341 CloseHandle(hDevice);
342
343 return 0;
344 }
示例代码 P267
使用StartIo时，需要IRP的派遣函数返回挂起状态。
2)自定义StartIo
系统提供的StartIo只能使用一个队列，如果想把读，写等操作分开进行串行化，那就要多（2）个队列。需要自定义。我们用DDK提供的 PKDEVICE_QUEUE存储队列，队列中每个元素用PKDEVICE_QUEUE_ENTRY表示。自定义StartIo里，需要我们自已维护“入队”“出队”操作。
初始化队列：KeInitializeDeviceQueue
插入：KeInsertDeviceQueue
删除：KeRemoveDeviceQueue
代码
1 //.h
2 #pragma once
3
4 #ifdef __cplusplus
5 extern "C"
6 {
7 #endif
8 #include <NTDDK.h>
9 #ifdef __cplusplus
10 }
11 #endif
12
13 #define PAGEDCODE code_seg("PAGE")
14 #define LOCKEDCODE code_seg()
15 #define INITCODE code_seg("INIT")
16
17 #define PAGEDDATA data_seg("PAGE")
18 #define LOCKEDDATA data_seg()
19 #define INITDATA data_seg("INIT")
20
21 #define arraysize(p) (sizeof(p)/sizeof((p)[0]))
22
23 typedef struct _DEVICE_EXTENSION {
24 PDEVICE_OBJECT pDevice;
25 UNICODE_STRING ustrDeviceName; //设备名称
26 UNICODE_STRING ustrSymLinkName; //符号链接名
27 KDEVICE_QUEUE device_queue; //设备队列
28 } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
29
30 // 函数声明
31
32 NTSTATUS CreateDevice (IN PDRIVER_OBJECT pDriverObject);
33 VOID HelloDDKUnload (IN PDRIVER_OBJECT pDriverObject);
34 NTSTATUS HelloDDKDispatchRoutin(IN PDEVICE_OBJECT pDevObj,
35 IN PIRP pIrp);
36 NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj,
37 IN PIRP pIrp);
38 NTSTATUS HelloDDKCleanUp(IN PDEVICE_OBJECT pDevObj,
39 IN PIRP pIrp);
40 //.cpp
41 #include "Driver.h"
42
43
44 #pragma LOCKEDCODE
45 VOID
46 MyStartIo(
47 IN PDEVICE_OBJECT DeviceObject,
48 IN PIRP pFistIrp
49 )
50 {
51 KdPrint(("Enter MyStartIo\n"));
52
53 PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
54 DeviceObject->DeviceExtension;
55
56 PKDEVICE_QUEUE_ENTRY device_entry;
57
58 PIRP Irp = pFistIrp;
59 do
60 {
61 KEVENT event;
62 KeInitializeEvent(&event,NotificationEvent,FALSE);
63
64 //等3秒
65 LARGE_INTEGER timeout;
66 timeout.QuadPart = -3*1000*1000*10;
67
68 //定义一个3秒的延时，主要是为了模拟该IRP操作需要大概3秒左右时间
69 KeWaitForSingleObject(&event,Executive,KernelMode,FALSE,&timeout);
70
71 KdPrint(("Complete a irp:%x\n",Irp));
72 Irp->IoStatus.Status = STATUS_SUCCESS;
73 Irp->IoStatus.Information = 0; // no bytes xfered
74 IoCompleteRequest(Irp,IO_NO_INCREMENT);
75
76 device_entry=KeRemoveDeviceQueue(&pDevExt->device_queue);
77 KdPrint(("device_entry:%x\n",device_entry));
78 if (device_entry==NULL)
79 {
80 break;
81 }
82
83 Irp = CONTAINING_RECORD(device_entry, IRP, Tail.Overlay.DeviceQueueEntry);
84 }while(1);
85
86 KdPrint(("Leave MyStartIo\n"));
87 }
88
89 /************************************************************************
90 * 函数名称:DriverEntry
91 * 功能描述:初始化驱动程序，定位和申请硬件资源，创建内核对象
92 * 参数列表:
93 pDriverObject:从I/O管理器中传进来的驱动对象
94 pRegistryPath:驱动程序在注册表的中的路径
95 * 返回 值:返回初始化驱动状态
96 *************************************************************************/
97 #pragma INITCODE
98 extern "C" NTSTATUS DriverEntry (
99 IN PDRIVER_OBJECT pDriverObject,
100 IN PUNICODE_STRING pRegistryPath )
101 {
102 NTSTATUS status;
103 KdPrint(("Enter DriverEntry\n"));
104
105 //设置卸载函数
106 pDriverObject->DriverUnload = HelloDDKUnload;
107
108 //设置派遣函数
109 pDriverObject->MajorFunction[IRP_MJ_CREATE] = HelloDDKDispatchRoutin;
110 pDriverObject->MajorFunction[IRP_MJ_CLOSE] = HelloDDKDispatchRoutin;
111 pDriverObject->MajorFunction[IRP_MJ_WRITE] = HelloDDKDispatchRoutin;
112 pDriverObject->MajorFunction[IRP_MJ_READ] = HelloDDKRead;
113 pDriverObject->MajorFunction[IRP_MJ_CLEANUP] = HelloDDKDispatchRoutin;
114 pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = HelloDDKDispatchRoutin;
115 pDriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = HelloDDKDispatchRoutin;
116 pDriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = HelloDDKDispatchRoutin;
117 pDriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = HelloDDKDispatchRoutin;
118
119 //创建驱动设备对象
120 status = CreateDevice(pDriverObject);
121
122 KdPrint(("Leave DriverEntry\n"));
123 return status;
124 }
125
126 /************************************************************************
127 * 函数名称:CreateDevice
128 * 功能描述:初始化设备对象
129 * 参数列表:
130 pDriverObject:从I/O管理器中传进来的驱动对象
131 * 返回 值:返回初始化状态
132 *************************************************************************/
133 #pragma INITCODE
134 NTSTATUS CreateDevice (
135 IN PDRIVER_OBJECT pDriverObject)
136 {
137 NTSTATUS status;
138 PDEVICE_OBJECT pDevObj;
139 PDEVICE_EXTENSION pDevExt;
140
141 //创建设备名称
142 UNICODE_STRING devName;
143 RtlInitUnicodeString(&devName,L"\\Device\\MyDDKDevice");
144
145 //创建设备
146 status = IoCreateDevice( pDriverObject,
147 sizeof(DEVICE_EXTENSION),
148 &(UNICODE_STRING)devName,
149 FILE_DEVICE_UNKNOWN,
150 0, TRUE,
151 &pDevObj );
152 if (!NT_SUCCESS(status))
153 return status;
154
155 pDevObj->Flags |= DO_BUFFERED_IO;
156 pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
157 pDevExt->pDevice = pDevObj;
158 pDevExt->ustrDeviceName = devName;
159
160 RtlZeroBytes(&pDevExt->device_queue,sizeof(pDevExt->device_queue));
161 KeInitializeDeviceQueue(&pDevExt->device_queue);
162
163 //创建符号链接
164 UNICODE_STRING symLinkName;
165 RtlInitUnicodeString(&symLinkName,L"\\??\\HelloDDK");
166 pDevExt->ustrSymLinkName = symLinkName;
167 status = IoCreateSymbolicLink( &symLinkName,&devName );
168 if (!NT_SUCCESS(status))
169 {
170 IoDeleteDevice( pDevObj );
171 return status;
172 }
173 return STATUS_SUCCESS;
174 }
175
176 /************************************************************************
177 * 函数名称:HelloDDKUnload
178 * 功能描述:负责驱动程序的卸载操作
179 * 参数列表:
180 pDriverObject:驱动对象
181 * 返回 值:返回状态
182 *************************************************************************/
183 #pragma PAGEDCODE
184 VOID HelloDDKUnload (IN PDRIVER_OBJECT pDriverObject)
185 {
186 PDEVICE_OBJECT pNextObj;
187 KdPrint(("Enter DriverUnload\n"));
188 pNextObj = pDriverObject->DeviceObject;
189 while (pNextObj != NULL)
190 {
191 PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
192 pNextObj->DeviceExtension;
193
194 //删除符号链接
195 UNICODE_STRING pLinkName = pDevExt->ustrSymLinkName;
196 IoDeleteSymbolicLink(&pLinkName);
197
198 pNextObj = pNextObj->NextDevice;
199 IoDeleteDevice( pDevExt->pDevice );
200 }
201 }
202
203 /************************************************************************
204 * 函数名称:HelloDDKDispatchRoutin
205 * 功能描述:对读IRP进行处理
206 * 参数列表:
207 pDevObj:功能设备对象
208 pIrp:从IO请求包
209 * 返回 值:返回状态
210 *************************************************************************/
211 #pragma PAGEDCODE
212 NTSTATUS HelloDDKDispatchRoutin(IN PDEVICE_OBJECT pDevObj,
213 IN PIRP pIrp)
214 {
215 KdPrint(("Enter HelloDDKDispatchRoutin\n"));
216
217 PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(pIrp);
218 //建立一个字符串数组与IRP类型对应起来
219 static char* irpname[] =
220 {
221 "IRP_MJ_CREATE",
222 "IRP_MJ_CREATE_NAMED_PIPE",
223 "IRP_MJ_CLOSE",
224 "IRP_MJ_READ",
225 "IRP_MJ_WRITE",
226 "IRP_MJ_QUERY_INFORMATION",
227 "IRP_MJ_SET_INFORMATION",
228 "IRP_MJ_QUERY_EA",
229 "IRP_MJ_SET_EA",
230 "IRP_MJ_FLUSH_BUFFERS",
231 "IRP_MJ_QUERY_VOLUME_INFORMATION",
232 "IRP_MJ_SET_VOLUME_INFORMATION",
233 "IRP_MJ_DIRECTORY_CONTROL",
234 "IRP_MJ_FILE_SYSTEM_CONTROL",
235 "IRP_MJ_DEVICE_CONTROL",
236 "IRP_MJ_INTERNAL_DEVICE_CONTROL",
237 "IRP_MJ_SHUTDOWN",
238 "IRP_MJ_LOCK_CONTROL",
239 "IRP_MJ_CLEANUP",
240 "IRP_MJ_CREATE_MAILSLOT",
241 "IRP_MJ_QUERY_SECURITY",
242 "IRP_MJ_SET_SECURITY",
243 "IRP_MJ_POWER",
244 "IRP_MJ_SYSTEM_CONTROL",
245 "IRP_MJ_DEVICE_CHANGE",
246 "IRP_MJ_QUERY_QUOTA",
247 "IRP_MJ_SET_QUOTA",
248 "IRP_MJ_PNP",
249 };
250
251 UCHAR type = stack->MajorFunction;
252 if (type >= arraysize(irpname))
253 KdPrint((" - Unknown IRP, major type %X\n", type));
254 else
255 KdPrint(("\t%s\n", irpname[type]));
256
257 //对一般IRP的简单操作，后面会介绍对IRP更复杂的操作
258 NTSTATUS status = STATUS_SUCCESS;
259 // 完成IRP
260 pIrp->IoStatus.Status = status;
261 pIrp->IoStatus.Information = 0; // bytes xfered
262 IoCompleteRequest( pIrp, IO_NO_INCREMENT );
263
264 KdPrint(("Leave HelloDDKDispatchRoutin\n"));
265
266 return status;
267 }
268
269 VOID
270 OnCancelIRP(
271 IN PDEVICE_OBJECT DeviceObject,
272 IN PIRP Irp
273 )
274 {
275 KdPrint(("Enter CancelReadIRP\n"));
276
277 //释放Cancel自旋锁
278 IoReleaseCancelSpinLock(Irp->CancelIrql);
279
280 //设置完成状态为STATUS_CANCELLED
281 Irp->IoStatus.Status = STATUS_CANCELLED;
282 Irp->IoStatus.Information = 0; // bytes xfered
283 IoCompleteRequest( Irp, IO_NO_INCREMENT );
284
285 KdPrint(("Leave CancelReadIRP\n"));
286 }
287
288 NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj,
289 IN PIRP pIrp)
290 {
291 KdPrint(("Enter HelloDDKRead\n"));
292
293 PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
294 pDevObj->DeviceExtension;
295
296 //将IRP设置为挂起
297 IoMarkIrpPending(pIrp);
298
299 IoSetCancelRoutine(pIrp,OnCancelIRP);
300
301 KIRQL oldirql;
302 //提升IRP至DISPATCH_LEVEL
303 KeRaiseIrql(DISPATCH_LEVEL, &oldirql);
304
305 KdPrint(("HelloDDKRead irp :%x\n",pIrp));
306
307 KdPrint(("DeviceQueueEntry:%x\n",&pIrp->Tail.Overlay.DeviceQueueEntry));
308 if (!KeInsertDeviceQueue(&pDevExt->device_queue, &pIrp->Tail.Overlay.DeviceQueueEntry))
309 MyStartIo(pDevObj,pIrp);
310
311 //将IRP降至原来IRQL
312 KeLowerIrql(oldirql);
313
314 KdPrint(("Leave HelloDDKRead\n"));
315
316 //返回pending状态
317 return STATUS_PENDING;
318 }
319
320 //应用程序
321 #include <windows.h>
322 #include <stdio.h>
323 #include <process.h>
324
325 UINT WINAPI Thread(LPVOID context)
326 {
327 printf("Enter Thread\n");
328 OVERLAPPED overlap={0};
329 overlap.hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
330 UCHAR buffer[10];
331 ULONG ulRead;
332
333 BOOL bRead = ReadFile(*(PHANDLE)context,buffer,10,&ulRead,&overlap);
334
335 WaitForSingleObject(overlap.hEvent,INFINITE);
336 return 0;
337 }
338
339 int main()
340 {
341 HANDLE hDevice =
342 CreateFile("\\\\.\\HelloDDK",
343 GENERIC_READ | GENERIC_WRITE,
344 FILE_SHARE_READ,
345 NULL,
346 OPEN_EXISTING,
347 FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,//此处设置FILE_FLAG_OVERLAPPED
348 NULL );
349
350 if (hDevice == INVALID_HANDLE_VALUE)
351 {
352 printf("Open Device failed!");
353 return 1;
354 }
355
356 HANDLE hThread[2];
357 hThread[0] = (HANDLE) _beginthreadex (NULL,0,Thread,&hDevice,0,NULL);
358 hThread[1] = (HANDLE) _beginthreadex (NULL,0,Thread,&hDevice,0,NULL);
359
360 //主线程等待两个子线程结束
361 WaitForMultipleObjects(2,hThread,TRUE,INFINITE);
362
363 //创建IRP_MJ_CLEANUP IRP
364 CloseHandle(hDevice);
365
366 return 0;
367 }
示例代码 P272
4、中断服务例程(ISR)和DPC例程
DDK 提供内核函数IoConnectInterrupt把中断对象与ISR联系起来。ISR运行在DIRQL级别，高于普通线程的优先级。派遣函数，StartIo例程随时会被中断服务程序所打断，为了不让ISR打断，可以将IRQL升到相应的DIRQL。DDK提供了与ISR函数同步的内核函数
KeSynchronizeExecution。当运行到KeSynchronizeExecution时，ISR不会打断KeSynchronizeExecution提供的同步函数，我们可将同步代码放到KeSynchronizeExecution提供的同步函数中。
DPC(deferred procedure call )例程
ISR处于较高的IRQL，会打断正常运行的线程。DPC处于DISPATCH_LEVEL。所以，一般，ISR中的代码应该尽量少，不太重要的代码放入DPC中。
KeInitializeDpc
