[NTOSKRNL] Add a raw implementation of !irpfind in kdbg
[reactos.git] / ntoskrnl / tests / fsrtl.c
1 #include <ntifs.h>
2 #include "ntndk.h"
3 #include "fsrtl_glue.h"
4
5 #include "fastio.h"
6 #include "fsrtl.h"
7
8 /*
9 This is the main test function. It is called from DriverEntry.
10
11 There is a DbgBreakPoint() call at the beginning of DriverEntry.
12 In order to run the test again, simply type
13 net stop fsrtl
14 net start fsrtl
15
16 Author: Dom Cote
17 */
18
19 BOOLEAN FsRtlTest_StartTest() {
20 HANDLE Fh = NULL;
21 PFILE_OBJECT Pfo = NULL;
22
23 HANDLE DirFh = NULL;
24 PFILE_OBJECT DirPfo = NULL;
25
26
27 IO_STATUS_BLOCK IoStatus;
28 BOOLEAN Return;
29 NTSTATUS Status = STATUS_SUCCESS;
30 LONGLONG i = 0;
31
32 PCHAR Buffer;
33 PMDL MdlChain = 0;
34
35 LARGE_INTEGER Offset;
36 ULONG Length = 0;
37 LARGE_INTEGER OldSize;
38
39 /* Parameters we are going to use in the test from the FCB */
40 PFSRTL_COMMON_FCB_HEADER FcbHeader;
41 PLARGE_INTEGER AllocationSize;
42 PLARGE_INTEGER ValidDataLength;
43 PLARGE_INTEGER FileSize;
44
45 PDEVICE_OBJECT pRelatedDo = NULL;
46
47 /* Allocate a 100KB buffer to do IOs */
48 Buffer = ExAllocatePool(PagedPool,100*_1KB);
49
50 /* ------------------------------------------------------------------------
51 TESTING:
52 BOOLEAN
53 NTAPI
54 FsRtlCopyWrite(IN PFILE_OBJECT FileObject,
55 IN PLARGE_INTEGER FileOffset,
56 IN ULONG Length,
57 IN BOOLEAN Wait,
58 IN ULONG LockKey,
59 OUT PVOID Buffer,
60 OUT PIO_STATUS_BLOCK IoStatus,
61 IN PDEVICE_OBJECT DeviceObject)
62
63 with Wait = TRUE
64
65 ------------------------------------------------------------------------ */
66 FsRtlTest_OpenTestFile(&Fh, &Pfo);
67 FSRTL_TEST("Opening Test File.",((Pfo != NULL) && (Fh != NULL)));
68
69 /* Extract the test variable from the FCB struct */
70 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)Pfo->FsContext;
71 AllocationSize = &FcbHeader->AllocationSize;
72 ValidDataLength = &FcbHeader->ValidDataLength;
73 FileSize = &FcbHeader->FileSize;
74
75 /* Try to cache without caching having been initialized. This should fail.*/
76 Length = 10*_1KB;
77 FSRTL_TEST("FsRtlCopyWrite() - No cache map test.",!FsRtlCopyWrite(Pfo,AllocationSize,Length,TRUE,0,Buffer,&IoStatus,NULL));
78
79 /* We are going to build a 100k file */
80 /* This will inititate caching and build some size */
81 Offset.QuadPart = 0;
82 Length = 100*_1KB;
83 Return = FsRltTest_WritefileZw(Fh,&Offset,Length, Buffer, &IoStatus);
84 FSRTL_TEST("FsRtlCopyWrite() - Building 100k filesize.",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
85 Return = TRUE;
86
87 /* Extending the file by 1/2 sector, 256 bytes. */
88 Offset.QuadPart = 0x7fffffffffff;
89 Length = 0x100;
90 Return = FsRltTest_WritefileZw(Fh,NULL,Length, Buffer, &IoStatus);
91 FSRTL_TEST("FsRtlCopyWrite() - Extending by 1/2 sector.",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
92 Return = TRUE;
93
94 /* Append to the file past the allocation size*/
95 Offset.LowPart = 0xFFFFFFFF;
96 Offset.HighPart = 0xFFFFFFFF;
97 OldSize.QuadPart = FileSize->QuadPart;
98 Length = (ULONG) (AllocationSize->QuadPart -ValidDataLength->QuadPart);
99 FSRTL_TEST("FsRtlCopyWrite() - Testing extending past allocation size",!FsRtlCopyWrite(Pfo,&Offset,Length+1,TRUE,0,Buffer,&IoStatus,NULL));
100 FSRTL_TEST("FsRtlCopyWrite() - Testing extending not past allocation size",FsRtlCopyWrite(Pfo,&Offset,Length,TRUE,0,Buffer,&IoStatus,NULL));
101 FSRTL_TEST("FsRtlCopyWrite() - Check filesize",(FileSize->QuadPart = (OldSize.QuadPart+Length)));
102
103 /* Try do write a 65kb IO and check that if fails. Maximum IO size for thus function is 64KB */
104 Offset.QuadPart = 0;
105 Length = 65*_1KB;
106 FSRTL_TEST("FsRtlCopyWrite() - 65KB IO Test",!FsRtlCopyWrite(Pfo,&Offset,Length,TRUE,0,Buffer,&IoStatus,NULL));
107
108 /* Try do write a 64kb IO. Maximum IO size for thus function is 64KB */
109 Length = 64*_1KB;
110 FSRTL_TEST("FsRtlCopyWrite() - 64KB IO Test",FsRtlCopyWrite(Pfo,&Offset,Length,TRUE,0,Buffer,&IoStatus,NULL))
111
112 /* Test the fast Io questionable flag
113 This test fails and should succeed. I am not sure why. When FsRtlCopyWrite() queries the FastIoTable of the related
114 device object, it comes back with no.
115 FcbHeader->IsFastIoPossible = FastIoIsQuestionable;
116 FSRTL_TEST("FastIo is questionable flag",FsRtlCopyWrite(Pfo,&Offset,Length,TRUE,0,Buffer,&IoStatus,NULL))
117 */
118
119 /* Test the fast Io not possible flag */
120 FcbHeader->IsFastIoPossible = FastIoIsNotPossible;
121 FSRTL_TEST("FsRtlCopyWrite() - FastIo is not possible flag",!FsRtlCopyWrite(Pfo,&Offset,Length,TRUE,0,Buffer,&IoStatus,NULL))
122 /* Set the flag back to what it was */
123 FcbHeader->IsFastIoPossible = FastIoIsPossible;
124 FSRTL_TEST("FsRtlCopyWrite() - FastIo is possbile flag",FsRtlCopyWrite(Pfo,&Offset,Length,TRUE,0,Buffer,&IoStatus,NULL))
125
126 if (Pfo)
127 {
128 ObDereferenceObject(Pfo);
129 Pfo = NULL;
130 }
131
132 if (Fh)
133 {
134 ZwClose(Fh);
135 Fh = NULL;
136 }
137
138 /* ------------------------------------------------------------------------
139 TESTING:
140 BOOLEAN
141 NTAPI
142 FsRtlCopyWrite(IN PFILE_OBJECT FileObject,
143 IN PLARGE_INTEGER FileOffset,
144 IN ULONG Length,
145 IN BOOLEAN Wait,
146 IN ULONG LockKey,
147 OUT PVOID Buffer,
148 OUT PIO_STATUS_BLOCK IoStatus,
149 IN PDEVICE_OBJECT DeviceObject)
150
151 with Wait = FALSE
152
153 ------------------------------------------------------------------------ */
154
155 /* We are going to repeat the same bunch of tests but with Wait = FALSE. So we exercise the second part of the function. */
156 FsRtlTest_OpenTestFile(&Fh, &Pfo);
157
158 /* Extract the test variable from the FCB struct */
159 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)Pfo->FsContext;
160 AllocationSize = &FcbHeader->AllocationSize;
161 ValidDataLength = &FcbHeader->ValidDataLength;
162 FileSize = &FcbHeader->FileSize;
163
164 /* Try to cache without caching having been initialized. This should fail.*/
165 Length = 10*_1KB;
166 FSRTL_TEST("FsRtlCopyWrite() - No cache map test. Wait = FALSE",!FsRtlCopyWrite(Pfo,AllocationSize,Length,FALSE,0,Buffer,&IoStatus,NULL));
167
168 /* We are going to build a 100k file */
169 /* This will inititate caching and build some size */
170 Offset.QuadPart = 0;
171 Length = 100*_1KB;
172 Return = FsRltTest_WritefileZw(Fh,&Offset,Length, Buffer, &IoStatus);
173 FSRTL_TEST("FsRtlCopyWrite() - Building 100k filesize. Wait = FALSE",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
174 Return = TRUE;
175
176 /* Extending the file by 1/2 sector, 256 bytes. */
177 Offset.QuadPart = 0x7fffffffffff;
178 Length = 0x100;
179 Return = FsRltTest_WritefileZw(Fh,NULL,Length, Buffer, &IoStatus);
180 FSRTL_TEST("FsRtlCopyWrite() - Extending by 1/2 sector. Wait = FALSE",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
181 Return = TRUE;
182
183 /* Append to the file past the allocation size*/
184 Offset.LowPart = 0xFFFFFFFF;
185 Offset.HighPart = 0xFFFFFFFF;
186 OldSize.QuadPart = FileSize->QuadPart;
187 Length = (ULONG) (AllocationSize->QuadPart -ValidDataLength->QuadPart);
188 FSRTL_TEST("FsRtlCopyWrite() - Testing extending past allocation size Wait = FALSE",!FsRtlCopyWrite(Pfo,&Offset,Length+1,FALSE,0,Buffer,&IoStatus,NULL));
189 FSRTL_TEST("FsRtlCopyWrite() - Testing extending not past allocation size. Wait = FALSE",FsRtlCopyWrite(Pfo,&Offset,Length,FALSE,0,Buffer,&IoStatus,NULL));
190 FSRTL_TEST("FsRtlCopyWrite() - Check filesize",(FileSize->QuadPart = (OldSize.QuadPart+Length)));
191
192 /* Try do write a 65kb IO and check that if fails. Maximum IO size for thus function is 64KB */
193 Offset.QuadPart = 0;
194 Length = 65*_1KB;
195 FSRTL_TEST("FsRtlCopyWrite() - 65KB IO Test. Wait = FALSE",!FsRtlCopyWrite(Pfo,&Offset,Length,FALSE,0,Buffer,&IoStatus,NULL));
196
197 /* Try do write a 64kb IO. Maximum IO size for thus function is 64KB */
198 Length = 64*_1KB;
199 FSRTL_TEST("FsRtlCopyWrite() - 64KB IO Test. Wait = FALSE",FsRtlCopyWrite(Pfo,&Offset,Length,FALSE,0,Buffer,&IoStatus,NULL))
200
201 /* Test the fast Io questionable flag
202 This test fails and should succeed. I am not sure why. When FsRtlCopyWrite() queries the FastIoTable of the related
203 device object, it comes back with no.
204 FcbHeader->IsFastIoPossible = FastIoIsQuestionable;
205 FSRTL_TEST("FastIo is questionable flag",FsRtlCopyWrite(Pfo,&Offset,Length,TRUE,0,Buffer,&IoStatus,NULL))
206 */
207
208 /* Test the fast Io not possible flag */
209 FcbHeader->IsFastIoPossible = FastIoIsNotPossible;
210 FSRTL_TEST("FsRtlCopyWrite() - FastIo is not possible flag. Wait = FALSE",!FsRtlCopyWrite(Pfo,&Offset,Length,FALSE,0,Buffer,&IoStatus,NULL))
211 /* Set the flag back to what it was */
212 FcbHeader->IsFastIoPossible = FastIoIsPossible;
213 FSRTL_TEST("FsRtlCopyWrite() - FastIo is possbile flag. Wait = FALSE",FsRtlCopyWrite(Pfo,&Offset,Length,FALSE,0,Buffer,&IoStatus,NULL))
214
215
216 /* ------------------------------------------------------------------------------------------
217 TESTING:
218
219 BOOLEAN
220 NTAPI
221 FsRtlCopyRead(IN PFILE_OBJECT FileObject,
222 IN PLARGE_INTEGER FileOffset,
223 IN ULONG Length,
224 IN BOOLEAN Wait,
225 IN ULONG LockKey,
226 OUT PVOID Buffer,
227 OUT PIO_STATUS_BLOCK IoStatus,
228 IN PDEVICE_OBJECT DeviceObject)
229
230 ------------------------------------------------------------------------------------------ */
231
232 Offset.LowPart = 0x0;
233 Offset.HighPart = 0x0;
234 Length = 0x10000;
235
236 /* Testing a 64KB read with Wait = TRUE */
237 Return = FsRtlCopyRead(Pfo,&Offset,Length,TRUE,0,Buffer,&IoStatus,NULL);
238 FSRTL_TEST("FsRtlCopyRead() - Testing 64k IO Wait=TRUE",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
239 Return = TRUE;
240
241 /* Testing a 64KB read with Wait = FALSE */
242 Return = FsRtlCopyRead(Pfo,&Offset,Length,FALSE,0,Buffer,&IoStatus,NULL);
243 FSRTL_TEST("FsRtlCopyRead() - Testing 64k IO Wait=FALSE",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
244 Return = TRUE;
245
246 /* Testing read past the end of the file */
247 Offset.QuadPart = FileSize->QuadPart - (5 * _1KB);
248 Length = 10 * _1KB;
249 Return = FsRtlCopyRead(Pfo,&Offset,Length,TRUE,0,Buffer,&IoStatus,NULL);
250 FSRTL_TEST("FsRtlCopyRead() - Testing reading past end of file but starting before EOF",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status) && IoStatus.Information == (FileSize->QuadPart-Offset.QuadPart)));
251
252 Offset.QuadPart = FileSize->QuadPart + 1;
253 Length = 10 * _1KB;
254 Return = FsRtlCopyRead(Pfo,&Offset,Length,TRUE,0,Buffer,&IoStatus,NULL);
255 FSRTL_TEST("FsRtlCopyRead() - Testing reading past end of file but starting after EOF",(NT_SUCCESS(Return) && (IoStatus.Status == STATUS_END_OF_FILE) && IoStatus.Information == 0));
256
257
258 /* Testing a 64KB read with Wait = TRUE */
259 Offset.LowPart = 0x0;
260 Offset.HighPart = 0x0;
261 Length = 0x10000;
262 FcbHeader->IsFastIoPossible = FastIoIsNotPossible;
263 FSRTL_TEST("FsRtlCopyRead() - FastIo is not possible flag. Wait = FALSE",!FsRtlCopyRead(Pfo,&Offset,Length,FALSE,0,Buffer,&IoStatus,NULL));
264 FSRTL_TEST("FsRtlCopyRead() - FastIo is not possible flag. Wait = TRUE",!FsRtlCopyRead(Pfo,&Offset,Length,TRUE,0,Buffer,&IoStatus,NULL));
265 FcbHeader->IsFastIoPossible = FastIoIsPossible;
266 Return = TRUE;
267
268 if (Pfo)
269 {
270 ObDereferenceObject(Pfo);
271 Pfo = NULL;
272 }
273
274 if (Fh)
275 {
276 ZwClose(Fh);
277 Fh = NULL;
278 }
279
280 /* ------------------------------------------------------------------------
281 TESTING:
282 BOOLEAN
283 NTAPI
284 FsRtlPrepareMdlWriteDev(IN PFILE_OBJECT FileObject,
285 IN PLARGE_INTEGER FileOffset,
286 IN ULONG Length,
287 IN ULONG LockKey,
288 OUT PMDL *MdlChain,
289 OUT PIO_STATUS_BLOCK IoStatus,
290 IN PDEVICE_OBJECT DeviceObject)
291
292 ------------------------------------------------------------------------ */
293
294 /* We are going to repeat the same bunch of tests but with Wait = FALSE. So we exercise the second part of the function. */
295 FsRtlTest_OpenTestFile(&Fh, &Pfo);
296
297 /* Extract the test variable from the FCB struct */
298 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)Pfo->FsContext;
299 AllocationSize = &FcbHeader->AllocationSize;
300 ValidDataLength = &FcbHeader->ValidDataLength;
301 FileSize = &FcbHeader->FileSize;
302
303 /* Try to cache without caching having been initialized. This should fail.*/
304 Length = 10*_1KB;
305 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - No cache map test. Wait = FALSE",
306 !FsRtlPrepareMdlWriteDev(Pfo,AllocationSize,Length,0,MdlChain,&IoStatus,NULL));
307
308 /* We are going to build a 100k file */
309 /* This will inititate caching and build some size */
310 Offset.QuadPart = 0;
311 Length = 100*_1KB;
312 Return = FsRltTest_WritefileZw(Fh,&Offset,Length, Buffer, &IoStatus);
313 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - Building 100k filesize. Wait = FALSE",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
314 Return = TRUE;
315
316 /* Extending the file by 1/2 sector, 256 bytes. */
317 Offset.QuadPart = 0x7fffffffffff;
318 Length = 0x100;
319 Return = FsRltTest_WritefileZw(Fh,NULL,Length, Buffer, &IoStatus);
320 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - Extending by 1/2 sector. Wait = FALSE",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
321 Return = TRUE;
322
323
324 pRelatedDo = IoGetRelatedDeviceObject(Pfo);
325 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - Did we get related DO ?",pRelatedDo);
326
327
328 /* Append to the file past the allocation size*/
329 Offset.QuadPart = FileSize->QuadPart;
330 OldSize.QuadPart = FileSize->QuadPart;
331 Length = (ULONG) (AllocationSize->QuadPart -ValidDataLength->QuadPart);
332 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - Testing extending past allocation size.",
333 !FsRtlPrepareMdlWriteDev(Pfo,&Offset,Length+1,0,&MdlChain,&IoStatus,pRelatedDo));
334
335 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - Testing extending not past allocation size.",
336 FsRtlPrepareMdlWriteDev(Pfo,&Offset,Length,0,&MdlChain,&IoStatus,pRelatedDo));
337 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - Check filesize",(FileSize->QuadPart = (OldSize.QuadPart+Length)));
338 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - Release the MDL.",FsRtlMdlWriteCompleteDev(Pfo,&Offset,MdlChain,pRelatedDo));
339
340
341 /* Try do write a 65kb IO and check that if fails. Maximum IO size for thus function is 64KB */
342 Offset.QuadPart = 0;
343 MdlChain = NULL;
344 Length = 65*_1KB;
345 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - 65KB IO Test.",
346 FsRtlPrepareMdlWriteDev(Pfo,&Offset,Length,0,&MdlChain,&IoStatus,pRelatedDo));
347 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - Release the MDL.",FsRtlMdlWriteCompleteDev(Pfo,&Offset,MdlChain,pRelatedDo));
348
349 /* Try do write a 64kb IO. Maximum IO size for thus function is 64KB */
350 Length = 64*_1KB;
351 MdlChain = NULL;
352 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - 64KB IO Test.",
353 FsRtlPrepareMdlWriteDev(Pfo,&Offset,Length,0,&MdlChain,&IoStatus,NULL))
354 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - Release the MDL.",FsRtlMdlWriteCompleteDev(Pfo,&Offset,MdlChain,NULL));
355
356 /* Test the fast Io not possible flag */
357 FcbHeader->IsFastIoPossible = FastIoIsNotPossible;
358 FSRTL_TEST("FsRtlPrepareMdlWriteDev() - FastIo is not possible flag.",
359 !FsRtlPrepareMdlWriteDev(Pfo,&Offset,Length,0,&MdlChain,&IoStatus,NULL))
360
361 if (Pfo)
362 {
363 ObDereferenceObject(Pfo);
364 Pfo = NULL;
365 }
366
367 if (Fh)
368 {
369 ZwClose(Fh);
370 Fh = NULL;
371 }
372
373 /* ------------------------------------------------------------------------
374 TESTING:
375 BOOLEAN
376 NTAPI
377 FsRtlPrepareMdlWrite( IN PFILE_OBJECT FileObject,
378 IN PLARGE_INTEGER FileOffset,
379 IN ULONG Length,
380 IN ULONG LockKey,
381 OUT PMDL *MdlChain,
382 OUT PIO_STATUS_BLOCK IoStatus,
383 IN PDEVICE_OBJECT DeviceObject)
384
385 ------------------------------------------------------------------------ */
386
387 /* We are going to repeat the same bunch of tests but with Wait = FALSE. So we exercise the second part of the function. */
388 FsRtlTest_OpenTestFile(&Fh, &Pfo);
389
390 /* Extract the test variable from the FCB struct */
391 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)Pfo->FsContext;
392 AllocationSize = &FcbHeader->AllocationSize;
393 ValidDataLength = &FcbHeader->ValidDataLength;
394 FileSize = &FcbHeader->FileSize;
395
396 /* Try to cache without caching having been initialized. This should fail.*/
397 Length = 10*_1KB;
398 FSRTL_TEST("FsRtlPrepareMdlWrite() - No cache map test. Wait = FALSE",
399 !FsRtlPrepareMdlWrite(Pfo,AllocationSize,Length,0,MdlChain,&IoStatus));
400
401 /* We are going to build a 100k file */
402 /* This will inititate caching and build some size */
403 Offset.QuadPart = 0;
404 Length = 100*_1KB;
405 Return = FsRltTest_WritefileZw(Fh,&Offset,Length, Buffer, &IoStatus);
406 FSRTL_TEST("FsRtlPrepareMdlWrite() - Building 100k filesize. Wait = FALSE",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
407 Return = TRUE;
408
409 /* Extending the file by 1/2 sector, 256 bytes. */
410 Offset.QuadPart = 0x7fffffffffff;
411 Length = 0x100;
412 Return = FsRltTest_WritefileZw(Fh,NULL,Length, Buffer, &IoStatus);
413 FSRTL_TEST("FsRtlPrepareMdlWrite() - Extending by 1/2 sector. Wait = FALSE",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
414 Return = TRUE;
415
416
417 /* Append to the file past the allocation size*/
418 MdlChain = NULL;
419 Offset.QuadPart = FileSize->QuadPart;
420 OldSize.QuadPart = FileSize->QuadPart;
421 Length = (ULONG) (AllocationSize->QuadPart -ValidDataLength->QuadPart);
422 FSRTL_TEST("FsRtlPrepareMdlWrite() - Testing extending past allocation size.",
423 !FsRtlPrepareMdlWrite(Pfo,&Offset,Length+1,0,&MdlChain,&IoStatus));
424
425 FSRTL_TEST("FsRtlPrepareMdlWrite() - Testing extending not past allocation size.",
426 FsRtlPrepareMdlWrite(Pfo,&Offset,Length,0,&MdlChain,&IoStatus));
427 FSRTL_TEST("FsRtlPrepareMdlWrite() - Check filesize",(FileSize->QuadPart = (OldSize.QuadPart+Length)));
428 FSRTL_TEST("FsRtlPrepareMdlWrite() - Release the MDL.",FsRtlMdlWriteComplete(Pfo,&Offset,MdlChain));
429
430
431 /* Try do write a 65kb IO and check that if fails. Maximum IO size for thus function is 64KB */
432 Offset.QuadPart = 0;
433 MdlChain = NULL;
434 Length = 65*_1KB;
435 FSRTL_TEST("FsRtlPrepareMdlWrite() - 65KB IO Test.",
436 !FsRtlPrepareMdlWrite(Pfo,&Offset,Length,0,&MdlChain,&IoStatus));
437 //FSRTL_TEST("FsRtlPrepareMdlWrite() - Release the MDL.",FsRtlMdlWriteComplete(Pfo,&Offset,MdlChain));
438
439 /* Try do write a 64kb IO. Maximum IO size for thus function is 64KB */
440 Length = 64*_1KB;
441 MdlChain = NULL;
442 FSRTL_TEST("FsRtlPrepareMdlWrite() - 64KB IO Test.",
443 FsRtlPrepareMdlWrite(Pfo,&Offset,Length,0,&MdlChain,&IoStatus))
444 FSRTL_TEST("FsRtlPrepareMdlWrite() - Release the MDL.",FsRtlMdlWriteComplete(Pfo,&Offset,MdlChain));
445
446 /* Test the fast Io not possible flag */
447 FcbHeader->IsFastIoPossible = FastIoIsNotPossible;
448 FSRTL_TEST("FsRtlPrepareMdlWrite() - FastIo is not possible flag.",
449 !FsRtlPrepareMdlWrite(Pfo,&Offset,Length,0,&MdlChain,&IoStatus))
450
451 if (Pfo)
452 {
453 ObDereferenceObject(Pfo);
454 Pfo = NULL;
455 }
456
457 if (Fh)
458 {
459 ZwClose(Fh);
460 Fh = NULL;
461 }
462
463 /* ------------------------------------------------------------------------------------------
464 TESTING:
465
466 FsRtlMdlReadDev(IN PFILE_OBJECT FileObject,
467 IN PLARGE_INTEGER FileOffset,
468 IN ULONG Length,
469 IN ULONG LockKey,
470 OUT PMDL *MdlChain,
471 OUT PIO_STATUS_BLOCK IoStatus,
472 IN PDEVICE_OBJECT DeviceObject)
473
474 FsRtlMdlReadCompleteDev(IN PFILE_OBJECT FileObject,
475 IN PMDL MemoryDescriptorList,
476 IN PDEVICE_OBJECT DeviceObject)
477
478 ------------------------------------------------------------------------------------------
479 */
480
481 FsRtlTest_OpenTestFile(&Fh, &Pfo);
482
483 /* Extract the test variable from the FCB struct */
484 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)Pfo->FsContext;
485 AllocationSize = &FcbHeader->AllocationSize;
486 ValidDataLength = &FcbHeader->ValidDataLength;
487 FileSize = &FcbHeader->FileSize;
488
489
490 /* We are going to build a 100k file */
491 /* This will inititate caching and build some size */
492 Offset.QuadPart = 0;
493 Length = 100*_1KB;
494 Return = FsRltTest_WritefileZw(Fh,&Offset,Length, Buffer, &IoStatus);
495 FSRTL_TEST("FsRtlMdlReadDev() - Building 100k filesize.",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
496 Return = TRUE;
497
498
499 Offset.LowPart = 0x0;
500 Offset.HighPart = 0x0;
501 Length = 0x10000;
502
503 /* Testing a 64KB read */
504 MdlChain = NULL;
505 Return = FsRtlMdlReadDev(Pfo,&Offset,Length,0,&MdlChain,&IoStatus,NULL);
506 FSRTL_TEST("FsRtlMdlReadDev() - Testing 64k IO",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
507 FSRTL_TEST("FsRtlMdlReadDev() - Releasing the MDL",FsRtlMdlReadCompleteDev(Pfo,MdlChain,NULL));
508
509
510 /* Testing read past the end of the file */
511 Offset.QuadPart = FileSize->QuadPart - (5 * _1KB);
512 Length = 10 * _1KB;
513 MdlChain = NULL;
514 Return = FsRtlMdlReadDev(Pfo,&Offset,Length,0,&MdlChain,&IoStatus,NULL);
515 FSRTL_TEST("FsRtlMdlReadDev() - Testing reading past end of file but starting before EOF",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status) && IoStatus.Information == (FileSize->QuadPart-Offset.QuadPart)));
516 FSRTL_TEST("FsRtlMdlReadDev() - Releasing the MDL",FsRtlMdlReadCompleteDev(Pfo,MdlChain,NULL));
517
518 Offset.QuadPart = FileSize->QuadPart + 1;
519 Length = 10 * _1KB;
520 MdlChain = NULL;
521 Return = FsRtlMdlReadDev(Pfo,&Offset,Length,0,&MdlChain,&IoStatus,NULL);
522 FSRTL_TEST("FsRtlMdlReadDev() - Testing reading past end of file but starting after EOF",(NT_SUCCESS(Return) && (IoStatus.Status == STATUS_END_OF_FILE) && IoStatus.Information == 0));
523
524 /* Testing FastIoIsNotPossible */
525 Offset.LowPart = 0x0;
526 Offset.HighPart = 0x0;
527 MdlChain = NULL;
528 Length = 0x10000;
529 FcbHeader->IsFastIoPossible = FastIoIsNotPossible;
530 FSRTL_TEST("FsRtlMdlReadDev() - FastIo is not possible flag. Wait = TRUE",!FsRtlMdlReadDev(Pfo,&Offset,Length,0,&MdlChain,&IoStatus,NULL));
531
532 Return = TRUE;
533
534 if (Pfo)
535 {
536 ObDereferenceObject(Pfo);
537 Pfo = NULL;
538 }
539
540 if (Fh)
541 {
542 ZwClose(Fh);
543 Fh = NULL;
544 }
545
546 /* ------------------------------------------------------------------------------------------
547 TESTING:
548
549 FsRtlMdlRead(IN PFILE_OBJECT FileObject,
550 IN PLARGE_INTEGER FileOffset,
551 IN ULONG Length,
552 IN ULONG LockKey,
553 OUT PMDL *MdlChain,
554 OUT PIO_STATUS_BLOCK IoStatus)
555
556 FsRtlMdlReadComplete(IN PFILE_OBJECT FileObject,
557 IN PMDL MemoryDescriptorList)
558
559 ------------------------------------------------------------------------------------------
560 */
561
562 FsRtlTest_OpenTestFile(&Fh, &Pfo);
563
564 /* Extract the test variable from the FCB struct */
565 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)Pfo->FsContext;
566 AllocationSize = &FcbHeader->AllocationSize;
567 ValidDataLength = &FcbHeader->ValidDataLength;
568 FileSize = &FcbHeader->FileSize;
569
570
571 /* We are going to build a 100k file */
572 /* This will inititate caching and build some size */
573 Offset.QuadPart = 0;
574 Length = 100*_1KB;
575 Return = FsRltTest_WritefileZw(Fh,&Offset,Length, Buffer, &IoStatus);
576 FSRTL_TEST("FsRtlMdlRead() - Building 100k filesize.",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
577 Return = TRUE;
578
579
580 Offset.LowPart = 0x0;
581 Offset.HighPart = 0x0;
582 Length = 0x10000;
583
584 /* Testing a 64KB read */
585 MdlChain = NULL;
586 Return = FsRtlMdlRead(Pfo,&Offset,Length,0,&MdlChain,&IoStatus);
587 FSRTL_TEST("FsRtlMdlRead() - Testing 64k IO",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status ) && IoStatus.Information == Length));
588 FSRTL_TEST("FsRtlMdlRead() - Releasing the MDL",FsRtlMdlReadComplete(Pfo,MdlChain));
589
590
591 /* Testing read past the end of the file */
592 Offset.QuadPart = FileSize->QuadPart - (5 * _1KB);
593 Length = 10 * _1KB;
594 MdlChain = NULL;
595 Return = FsRtlMdlRead(Pfo,&Offset,Length,0,&MdlChain,&IoStatus);
596 FSRTL_TEST("FsRtlMdlRead() - Testing reading past end of file but starting before EOF",(NT_SUCCESS(Return) && NT_SUCCESS(IoStatus.Status) && IoStatus.Information == (FileSize->QuadPart-Offset.QuadPart)));
597 FSRTL_TEST("FsRtlMdlRead() - Releasing the MDL",FsRtlMdlReadComplete(Pfo,MdlChain));
598
599 Offset.QuadPart = FileSize->QuadPart + 1;
600 Length = 10 * _1KB;
601 MdlChain = NULL;
602 Return = FsRtlMdlRead(Pfo,&Offset,Length,0,&MdlChain,&IoStatus);
603 FSRTL_TEST("FsRtlMdlRead() - Testing reading past end of file but starting after EOF",(NT_SUCCESS(Return) && (IoStatus.Status == STATUS_END_OF_FILE) && IoStatus.Information == 0));
604
605 /* Testing FastIoIsNotPossible */
606 Offset.LowPart = 0x0;
607 Offset.HighPart = 0x0;
608 MdlChain = NULL;
609 Length = 0x10000;
610 FcbHeader->IsFastIoPossible = FastIoIsNotPossible;
611 FSRTL_TEST("FsRtlMdlRead() - FastIo is not possible flag. Wait = TRUE",!FsRtlMdlRead(Pfo,&Offset,Length,0,&MdlChain,&IoStatus));
612
613 Return = TRUE;
614
615 if (Pfo)
616 {
617 ObDereferenceObject(Pfo);
618 Pfo = NULL;
619 }
620
621 if (Fh)
622 {
623 ZwClose(Fh);
624 Fh = NULL;
625 }
626
627
628
629 /* ------------------------------------------------------------------------------------------
630 TESTING:
631
632 FsRtlGetFileSize(IN PFILE_OBJECT FileObject,
633 IN OUT PLARGE_INTEGER FileSize)
634
635 ------------------------------------------------------------------------------------------
636 */
637 FsRtlTest_OpenTestFile(&Fh, &Pfo);
638 FSRTL_TEST("FsRtlGetFileSize() - Opening Test File.",((Pfo != NULL) && (Fh != NULL)));
639
640 FsRtlTest_OpenTestDirectory(&DirFh, &DirPfo);
641 FSRTL_TEST("FsRtlGetFileSize() - Opening Test Directory.",((DirPfo != NULL) && (DirFh != NULL)));
642
643 Status = FsRtlGetFileSize(Pfo,&OldSize);
644 FSRTL_TEST("FsRtlGetFileSize() - Get the size of a real file",NT_SUCCESS(Status));
645
646 Status = FsRtlGetFileSize(DirPfo,&OldSize);
647 FSRTL_TEST("FsRtlGetFileSize() - Get the size of a directory file",(Status == STATUS_FILE_IS_A_DIRECTORY));
648
649
650 /* The test if over. Do clean up */
651
652 Cleanup:
653
654 if (DirPfo)
655 {
656 ObDereferenceObject(DirPfo);
657 DirPfo = NULL;
658 }
659
660 if (DirFh)
661 {
662 ZwClose(DirFh);
663 DirFh = NULL;
664 }
665 if (Pfo)
666 {
667 ObDereferenceObject(Pfo);
668 Pfo = NULL;
669 }
670
671 if (Fh)
672 {
673 ZwClose(Fh);
674 Fh = NULL;
675 }
676
677 if (Buffer != NULL) {
678 ExFreePool(Buffer);
679 Buffer = NULL;
680 }
681
682 return Return;
683
684 }
685
686 /* This function is just a wrapper around ZwWriteFile */
687 NTSTATUS FsRltTest_WritefileZw(HANDLE fh, PLARGE_INTEGER Offset, ULONG Length, PVOID Buffer, PIO_STATUS_BLOCK pIoStatus){
688 NTSTATUS Return;
689
690 Return = ZwWriteFile(
691 fh,
692 NULL,
693 NULL,
694 NULL,
695 pIoStatus,
696 Buffer,
697 Length,
698 Offset,
699 NULL
700 );
701
702 return Return;
703 }
704
705 /* This function fills the buffer with a test pattern */
706 void FsRtlTest_FillBuffer(LARGE_INTEGER Start, ULONG Length, PVOID Buffer) {
707 ULONG i = 0;
708 PULONGLONG Index = (PULONGLONG) Buffer;
709
710 for (i=0; i<Length/sizeof(ULONGLONG); i++) {
711 Index[i] = Start.QuadPart + i;
712 }
713
714 return;
715 }
716
717 /* This function opens a test file with the FILE_DELETE_ON_CLOSE flag
718 and reference the file object
719 */
720 NTSTATUS FsRtlTest_OpenTestFile(PHANDLE Pfh, PFILE_OBJECT *Ppfo) {
721 UNICODE_STRING FileName;
722 OBJECT_ATTRIBUTES oa;
723 IO_STATUS_BLOCK IoStatus;
724 NTSTATUS Return;
725
726 RtlInitUnicodeString(&FileName,L"\\??\\C:\\fsrtl.bin");
727
728 InitializeObjectAttributes(
729 &oa,
730 &FileName,
731 OBJ_KERNEL_HANDLE,
732 NULL,
733 NULL;
734 );
735
736 Return = IoCreateFile(Pfh,
737 GENERIC_WRITE,
738 &oa,
739 &IoStatus,
740 0,
741 FILE_ATTRIBUTE_NORMAL,
742 0,
743 FILE_OVERWRITE_IF ,
744 FILE_SYNCHRONOUS_IO_ALERT | FILE_DELETE_ON_CLOSE,
745 NULL,
746 0,
747 CreateFileTypeNone,
748 NULL,
749 0);
750
751 Return = ObReferenceObjectByHandle(
752 *Pfh,
753 GENERIC_WRITE,
754 NULL,
755 KernelMode,
756 Ppfo,
757 NULL
758 );
759 }
760
761 NTSTATUS FsRtlTest_OpenTestDirectory(PHANDLE Pfh, PFILE_OBJECT *Ppfo) {
762 UNICODE_STRING FileName;
763 OBJECT_ATTRIBUTES oa;
764 IO_STATUS_BLOCK IoStatus;
765 NTSTATUS Return;
766
767 RtlInitUnicodeString(&FileName,L"\\??\\C:\\testdir01");
768
769 InitializeObjectAttributes(
770 &oa,
771 &FileName,
772 OBJ_KERNEL_HANDLE,
773 NULL,
774 NULL;
775 );
776
777 Return = IoCreateFile(Pfh,
778 GENERIC_WRITE,
779 &oa,
780 &IoStatus,
781 0,
782 FILE_ATTRIBUTE_NORMAL,
783 0,
784 FILE_OPEN_IF,
785 FILE_DIRECTORY_FILE,FILE_SYNCHRONOUS_IO_ALERT | FILE_DELETE_ON_CLOSE,
786 NULL,
787 0,
788 CreateFileTypeNone,
789 NULL,
790 0);
791
792 Return = ObReferenceObjectByHandle(
793 *Pfh,
794 GENERIC_WRITE,
795 NULL,
796 KernelMode,
797 Ppfo,
798 NULL
799 );
800 }
801
802 /* All the testing is done from driver entry */
803 NTSTATUS DriverEntry( IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath )
804 {
805 PDEVICE_OBJECT DeviceObject;
806 NTSTATUS mStatus;
807 UNICODE_STRING uniName, uniDOSName;
808 PDEVOBJ_EXTENSION x;
809
810 DbgPrint("Loading the FSRTL test driver.\n");
811 DbgBreakPoint();
812
813 /* register device functions */
814 DriverObject->MajorFunction[IRP_MJ_CREATE] = FsRtlTest_DispatchCreateClose;
815 DriverObject->MajorFunction[IRP_MJ_CLOSE] = FsRtlTest_DispatchCreateClose;
816 DriverObject->DriverUnload = FsRtlTest_Unload;
817
818 if (!FsRtlTest_StartTest()) {
819 DbgPrint("FsRtl test failed.\n");
820 } else {
821 DbgPrint("FsRtl test OK.\n");
822 }
823
824 return STATUS_SUCCESS;
825 }
826
827
828
829
830
831
832 NTSTATUS FsRtlTest_DispatchCreateClose( IN PDEVICE_OBJECT devObj, IN PIRP Irp )
833 {
834 DbgPrint(("FsRtl: Open / Close\n"));
835
836 Irp->IoStatus.Information = 0;
837 Irp->IoStatus.Status = STATUS_SUCCESS;
838 IoCompleteRequest( Irp, IO_NO_INCREMENT );
839
840 return STATUS_SUCCESS;
841 }
842
843 VOID FsRtlTest_Unload( IN PDRIVER_OBJECT DriverObject )
844 {
845 DbgPrint(("FsRtl: Unloading.\n"));
846 }
847
848