[FASTFAT][FLTMGR][NTOS] Do not explicitly call ObfDereferenceObject() (#1636)
[reactos.git] / drivers / filters / fltmgr / Interface.c
1 /*
2 * PROJECT: Filesystem Filter Manager
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: drivers/filters/fltmgr/interface.c
5 * PURPOSE: Implements the driver interface
6 * PROGRAMMERS: Ged Murphy (gedmurphy@reactos.org)
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include "fltmgr.h"
12 #include "fltmgrint.h"
13
14 //#define NDEBUG
15 #include <debug.h>
16
17
18 /* DATA *********************************************************************/
19
20 #define VALID_FAST_IO_DISPATCH_HANDLER(_FastIoDispatchPtr, _FieldName) \
21 (((_FastIoDispatchPtr) != NULL) && \
22 (((_FastIoDispatchPtr)->SizeOfFastIoDispatch) >= \
23 (FIELD_OFFSET(FAST_IO_DISPATCH, _FieldName) + sizeof(void *))) && \
24 ((_FastIoDispatchPtr)->_FieldName != NULL))
25
26 #define IS_MY_DEVICE_OBJECT(_devObj) \
27 (((_devObj) != NULL) && \
28 ((_devObj)->DriverObject == Dispatcher::DriverObject) && \
29 ((_devObj)->DeviceExtension != NULL))
30
31 extern PDEVICE_OBJECT CommsDeviceObject;
32 extern LIST_ENTRY FilterList;
33 extern ERESOURCE FilterListLock;
34
35
36 DRIVER_INITIALIZE DriverEntry;
37 NTSTATUS
38 NTAPI
39 DriverEntry(
40 _In_ PDRIVER_OBJECT DriverObject,
41 _In_ PUNICODE_STRING RegistryPath
42 );
43
44 static
45 NTSTATUS
46 SetupDispatchAndCallbacksTables(
47 _In_ PDRIVER_OBJECT DriverObject
48 );
49
50 static
51 NTSTATUS
52 FltpAttachDeviceObject(
53 _In_ PDEVICE_OBJECT SourceDevice,
54 _In_ PDEVICE_OBJECT TargetDevice,
55 _Out_ PDEVICE_OBJECT *AttachedToDeviceObject
56 );
57
58 static
59 VOID
60 FltpCleanupDeviceObject(
61 _In_ PDEVICE_OBJECT DeviceObject
62 );
63
64 static
65 BOOLEAN
66 FltpIsAttachedToDevice(
67 _In_ PDEVICE_OBJECT DeviceObject,
68 _In_opt_ PDEVICE_OBJECT *AttachedDeviceObject
69 );
70
71 static
72 NTSTATUS
73 FltpEnumerateFileSystemVolumes(
74 _In_ PDEVICE_OBJECT DeviceObject
75 );
76
77 static
78 NTSTATUS
79 FltpAttachToFileSystemDevice(
80 _In_ PDEVICE_OBJECT DeviceObject,
81 _In_ PUNICODE_STRING DeviceName
82 );
83
84 static
85 LONG_PTR
86 FltpDetachFromFileSystemDevice(
87 _In_ PDEVICE_OBJECT DeviceObject
88 );
89
90 DRIVER_FS_NOTIFICATION FltpFsNotification;
91 VOID
92 NTAPI
93 FltpFsNotification(
94 _In_ PDEVICE_OBJECT DeviceObject,
95 _In_ BOOLEAN FsActive
96 );
97
98 NTSTATUS
99 NTAPI
100 FltpDispatch(
101 _In_ PDEVICE_OBJECT DeviceObject,
102 _Inout_ PIRP Irp
103 );
104
105 NTSTATUS
106 NTAPI
107 FltpCreate(
108 _In_ PDEVICE_OBJECT DeviceObject,
109 _Inout_ PIRP Irp
110 );
111
112 NTSTATUS
113 NTAPI
114 FltpFsControl(
115 _In_ PDEVICE_OBJECT DeviceObject,
116 _Inout_ PIRP Irp
117 );
118
119 NTSTATUS
120 NTAPI
121 FltpDeviceControl(
122 _In_ PDEVICE_OBJECT DeviceObject,
123 _Inout_ PIRP Irp
124 );
125
126 BOOLEAN
127 NTAPI
128 FltpFastIoCheckIfPossible(
129 _In_ PFILE_OBJECT FileObject,
130 _In_ PLARGE_INTEGER FileOffset,
131 _In_ ULONG Length,
132 _In_ BOOLEAN Wait,
133 _In_ ULONG LockKey,
134 _In_ BOOLEAN CheckForReadOperation,
135 _Out_ PIO_STATUS_BLOCK IoStatus,
136 _In_ PDEVICE_OBJECT DeviceObject
137 );
138
139
140 BOOLEAN
141 NTAPI
142 FltpFastIoRead(
143 _In_ PFILE_OBJECT FileObject,
144 _In_ PLARGE_INTEGER FileOffset,
145 _In_ ULONG Length,
146 _In_ BOOLEAN Wait,
147 _In_ ULONG LockKey,
148 _Out_ PVOID Buffer,
149 _Out_ PIO_STATUS_BLOCK IoStatus,
150 _In_ PDEVICE_OBJECT DeviceObject
151 );
152
153 BOOLEAN
154 NTAPI
155 FltpFastIoWrite(
156 _In_ PFILE_OBJECT FileObject,
157 _In_ PLARGE_INTEGER FileOffset,
158 _In_ ULONG Length,
159 _In_ BOOLEAN Wait,
160 _In_ ULONG LockKey,
161 _In_ PVOID Buffer,
162 _Out_ PIO_STATUS_BLOCK IoStatus,
163 _In_ PDEVICE_OBJECT DeviceObject
164 );
165
166 BOOLEAN
167 NTAPI
168 FltpFastIoQueryBasicInfo(
169 _In_ PFILE_OBJECT FileObject,
170 _In_ BOOLEAN Wait,
171 _Out_ PFILE_BASIC_INFORMATION Buffer,
172 _Out_ PIO_STATUS_BLOCK IoStatus,
173 _In_ PDEVICE_OBJECT DeviceObject
174 );
175
176 BOOLEAN
177 NTAPI
178 FltpFastIoQueryStandardInfo(
179 _In_ PFILE_OBJECT FileObject,
180 _In_ BOOLEAN Wait,
181 _Out_ PFILE_STANDARD_INFORMATION Buffer,
182 _Out_ PIO_STATUS_BLOCK IoStatus,
183 _In_ PDEVICE_OBJECT DeviceObject
184 );
185
186 BOOLEAN
187 NTAPI
188 FltpFastIoLock(
189 _In_ PFILE_OBJECT FileObject,
190 _In_ PLARGE_INTEGER FileOffset,
191 _In_ PLARGE_INTEGER Length,
192 _In_ PEPROCESS ProcessId,
193 _In_ ULONG Key,
194 _In_ BOOLEAN FailImmediately,
195 _In_ BOOLEAN ExclusiveLock,
196 _Out_ PIO_STATUS_BLOCK IoStatus,
197 _In_ PDEVICE_OBJECT DeviceObject
198 );
199
200 BOOLEAN
201 NTAPI
202 FltpFastIoUnlockSingle(
203 _In_ PFILE_OBJECT FileObject,
204 _In_ PLARGE_INTEGER FileOffset,
205 _In_ PLARGE_INTEGER Length,
206 _In_ PEPROCESS ProcessId,
207 _In_ ULONG Key,
208 _Out_ PIO_STATUS_BLOCK IoStatus,
209 _In_ PDEVICE_OBJECT DeviceObject
210 );
211
212 BOOLEAN
213 NTAPI
214 FltpFastIoUnlockAll(
215 _In_ PFILE_OBJECT FileObject,
216 _In_ PEPROCESS ProcessId,
217 _Out_ PIO_STATUS_BLOCK IoStatus,
218 _In_ PDEVICE_OBJECT DeviceObject
219 );
220
221 BOOLEAN
222 NTAPI
223 FltpFastIoUnlockAllByKey(
224 _In_ PFILE_OBJECT FileObject,
225 _In_ PVOID ProcessId,
226 _In_ ULONG Key,
227 _Out_ PIO_STATUS_BLOCK IoStatus,
228 _In_ PDEVICE_OBJECT DeviceObject
229 );
230
231 BOOLEAN
232 NTAPI
233 FltpFastIoDeviceControl(
234 _In_ PFILE_OBJECT FileObject,
235 _In_ BOOLEAN Wait,
236 _In_opt_ PVOID InputBuffer,
237 _In_ ULONG InputBufferLength,
238 _Out_opt_ PVOID OutputBuffer,
239 _In_ ULONG OutputBufferLength,
240 _In_ ULONG IoControlCode,
241 _Out_ PIO_STATUS_BLOCK IoStatus,
242 _In_ PDEVICE_OBJECT DeviceObject
243 );
244
245 VOID
246 NTAPI
247 FltpFastIoDetachDevice(
248 _In_ PDEVICE_OBJECT SourceDevice,
249 _In_ PDEVICE_OBJECT TargetDevice
250 );
251
252 BOOLEAN
253 NTAPI
254 FltpFastIoQueryNetworkOpenInfo(
255 _In_ PFILE_OBJECT FileObject,
256 _In_ BOOLEAN Wait,
257 _Out_ PFILE_NETWORK_OPEN_INFORMATION Buffer,
258 _Out_ PIO_STATUS_BLOCK IoStatus,
259 _In_ PDEVICE_OBJECT DeviceObject
260 );
261
262 BOOLEAN
263 NTAPI
264 FltpFastIoMdlRead(
265 _In_ PFILE_OBJECT FileObject,
266 _In_ PLARGE_INTEGER FileOffset,
267 _In_ ULONG Length,
268 _In_ ULONG LockKey,
269 _Out_ PMDL *MdlChain,
270 _Out_ PIO_STATUS_BLOCK IoStatus,
271 _In_ PDEVICE_OBJECT DeviceObject
272 );
273
274 BOOLEAN
275 NTAPI
276 FltpFastIoMdlReadComplete(
277 _In_ PFILE_OBJECT FileObject,
278 _In_ PMDL MdlChain,
279 _In_ PDEVICE_OBJECT DeviceObject
280 );
281
282 BOOLEAN
283 NTAPI
284 FltpFastIoPrepareMdlWrite(
285 _In_ PFILE_OBJECT FileObject,
286 _In_ PLARGE_INTEGER FileOffset,
287 _In_ ULONG Length,
288 _In_ ULONG LockKey,
289 _Out_ PMDL *MdlChain,
290 _Out_ PIO_STATUS_BLOCK IoStatus,
291 _In_ PDEVICE_OBJECT DeviceObject
292 );
293
294 BOOLEAN
295 NTAPI
296 FltpFastIoMdlWriteComplete(
297 _In_ PFILE_OBJECT FileObject,
298 _In_ PLARGE_INTEGER FileOffset,
299 _In_ PMDL MdlChain,
300 _In_ PDEVICE_OBJECT DeviceObject
301 );
302
303 BOOLEAN
304 NTAPI
305 FltpFastIoReadCompressed(
306 _In_ PFILE_OBJECT FileObject,
307 _In_ PLARGE_INTEGER FileOffset,
308 _In_ ULONG Length,
309 _In_ ULONG LockKey,
310 _Out_ PVOID Buffer,
311 _Out_ PMDL *MdlChain,
312 _Out_ PIO_STATUS_BLOCK IoStatus,
313 _Out_ PCOMPRESSED_DATA_INFO CompressedDataInfo,
314 _In_ ULONG CompressedDataInfoLength,
315 _In_ PDEVICE_OBJECT DeviceObject
316 );
317
318 BOOLEAN
319 NTAPI
320 FltpFastIoWriteCompressed(
321 _In_ PFILE_OBJECT FileObject,
322 _In_ PLARGE_INTEGER FileOffset,
323 _In_ ULONG Length,
324 _In_ ULONG LockKey,
325 _In_ PVOID Buffer,
326 _Out_ PMDL *MdlChain,
327 _Out_ PIO_STATUS_BLOCK IoStatus,
328 _In_ PCOMPRESSED_DATA_INFO CompressedDataInfo,
329 _In_ ULONG CompressedDataInfoLength,
330 _In_ PDEVICE_OBJECT DeviceObject
331 );
332
333 BOOLEAN
334 NTAPI
335 FltpFastIoMdlReadCompleteCompressed(
336 _In_ PFILE_OBJECT FileObject,
337 _In_ PMDL MdlChain,
338 _In_ PDEVICE_OBJECT DeviceObject
339 );
340
341 BOOLEAN
342 NTAPI
343 FltpFastIoMdlWriteCompleteCompressed(
344 _In_ PFILE_OBJECT FileObject,
345 _In_ PLARGE_INTEGER FileOffset,
346 _In_ PMDL MdlChain,
347 _In_ PDEVICE_OBJECT DeviceObject
348 );
349
350 BOOLEAN
351 NTAPI
352 FltpFastIoQueryOpen(
353 _Inout_ PIRP Irp,
354 _Out_ PFILE_NETWORK_OPEN_INFORMATION NetworkInformation,
355 _In_ PDEVICE_OBJECT DeviceObject
356 );
357
358
359
360 #ifdef ALLOC_PRAGMA
361 #pragma alloc_text(INIT, DriverEntry)
362 #pragma alloc_text(INIT, SetupDispatchAndCallbacksTables)
363 #pragma alloc_text(PAGE, FltpAttachDeviceObject)
364 #pragma alloc_text(PAGE, FltpIsAttachedToDevice)
365 #pragma alloc_text(PAGE, FltpEnumerateFileSystemVolumes)
366 #pragma alloc_text(PAGE, FltpAttachToFileSystemDevice)
367 #pragma alloc_text(PAGE, FltpDetachFromFileSystemDevice)
368 #pragma alloc_text(PAGE, FltpFsNotification)
369 #pragma alloc_text(PAGE, FltpCreate)
370 #pragma alloc_text(PAGE, FltpFsControl)
371 #pragma alloc_text(PAGE, FltpDeviceControl)
372 #pragma alloc_text(PAGE, FltpFastIoRead)
373 #pragma alloc_text(PAGE, FltpFastIoWrite)
374 #pragma alloc_text(PAGE, FltpFastIoQueryBasicInfo)
375 #pragma alloc_text(PAGE, FltpFastIoQueryStandardInfo)
376 #pragma alloc_text(PAGE, FltpFastIoLock)
377 #pragma alloc_text(PAGE, FltpFastIoUnlockSingle)
378 #pragma alloc_text(PAGE, FltpFastIoUnlockAll)
379 #pragma alloc_text(PAGE, FltpFastIoUnlockAllByKey)
380 #pragma alloc_text(PAGE, FltpFastIoDeviceControl)
381 #pragma alloc_text(PAGE, FltpFastIoDetachDevice)
382 #pragma alloc_text(PAGE, FltpFastIoQueryNetworkOpenInfo)
383 #pragma alloc_text(PAGE, FltpFastIoMdlRead)
384 #pragma alloc_text(PAGE, FltpFastIoMdlReadComplete)
385 #pragma alloc_text(PAGE, FltpFastIoPrepareMdlWrite)
386 #pragma alloc_text(PAGE, FltpFastIoMdlWriteComplete)
387 #pragma alloc_text(PAGE, FltpFastIoReadCompressed)
388 #pragma alloc_text(PAGE, FltpFastIoWriteCompressed)
389 #pragma alloc_text(PAGE, FltpFastIoMdlReadCompleteCompressed)
390 #pragma alloc_text(PAGE, FltpFastIoMdlWriteCompleteCompressed)
391 #pragma alloc_text(PAGE, FltpFastIoQueryOpen)
392 #endif
393
394
395
396 DRIVER_DATA DriverData;
397
398
399 typedef struct _DETACH_DEVICE_WORK_ITEM
400 {
401 WORK_QUEUE_ITEM WorkItem;
402 PDEVICE_OBJECT SourceDevice;
403 PDEVICE_OBJECT TargetDevice;
404
405 } DETACH_DEVICE_WORK_ITEM, *PDETACH_DEVICE_WORK_ITEM;
406
407
408 /* DISPATCH ROUTINES **********************************************/
409
410 NTSTATUS
411 NTAPI
412 FltpPreFsFilterOperation(_In_ PFS_FILTER_CALLBACK_DATA Data,
413 _Out_ PVOID *CompletionContext)
414 {
415 UNREFERENCED_PARAMETER(Data);
416 UNREFERENCED_PARAMETER(CompletionContext);
417 __debugbreak();
418 return STATUS_SUCCESS;
419 }
420
421 VOID
422 NTAPI
423 FltpPostFsFilterOperation(_In_ PFS_FILTER_CALLBACK_DATA Data,
424 _In_ NTSTATUS OperationStatus,
425 _In_ PVOID CompletionContext)
426 {
427 UNREFERENCED_PARAMETER(Data);
428 UNREFERENCED_PARAMETER(OperationStatus);
429 UNREFERENCED_PARAMETER(CompletionContext);
430 __debugbreak();
431 }
432
433 NTSTATUS
434 NTAPI
435 FltpDispatch(_In_ PDEVICE_OBJECT DeviceObject,
436 _Inout_ PIRP Irp)
437 {
438 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
439 PIO_STACK_LOCATION StackPtr;
440 NTSTATUS Status;
441
442 DeviceExtension = DeviceObject->DeviceExtension;
443
444 /* Check if this is a request for us */
445 if (DeviceObject == DriverData.DeviceObject)
446 {
447 FLT_ASSERT(DeviceObject->DriverObject == DriverData.DriverObject);
448 FLT_ASSERT(DeviceExtension == NULL);
449
450 /* Hand it off to our internal handler */
451 Status = FltpDispatchHandler(DeviceObject, Irp);
452 if (Status != STATUS_REPARSE)
453 {
454 Irp->IoStatus.Status = Status;
455 Irp->IoStatus.Information = 0;
456 IoCompleteRequest(Irp, 0);
457 }
458 return Status;
459 }
460
461 /* Check if this is a request for a the messaging device */
462 if (DeviceObject == CommsDeviceObject)
463 {
464 /* Hand off to our internal routine */
465 return FltpMsgDispatch(DeviceObject, Irp);
466 }
467
468 FLT_ASSERT(DeviceExtension &&
469 DeviceExtension->AttachedToDeviceObject);
470
471 StackPtr = IoGetCurrentIrpStackLocation(Irp);
472 if (StackPtr->MajorFunction == IRP_MJ_SHUTDOWN)
473 {
474 // handle shutdown request
475 }
476
477 DPRINT1("Received %X from %wZ\n", StackPtr->MajorFunction, &DeviceExtension->DeviceName);
478
479 /* Just pass the IRP down the stack */
480 IoSkipCurrentIrpStackLocation(Irp);
481 return IoCallDriver(DeviceExtension->AttachedToDeviceObject, Irp);
482 }
483
484 NTSTATUS
485 NTAPI
486 FltpCreate(_In_ PDEVICE_OBJECT DeviceObject,
487 _Inout_ PIRP Irp)
488 {
489 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
490
491 PAGED_CODE();
492
493 DeviceExtension = DeviceObject->DeviceExtension;
494
495 /* Check if this is a request for us */
496 if (DeviceObject == DriverData.DeviceObject)
497 {
498 FLT_ASSERT(DeviceObject->DriverObject == DriverData.DriverObject);
499 FLT_ASSERT(DeviceExtension == NULL);
500
501 /* Someone wants a handle to the fltmgr, allow it */
502 Irp->IoStatus.Status = STATUS_SUCCESS;
503 Irp->IoStatus.Information = 0;
504 IofCompleteRequest(Irp, 0);
505 return STATUS_SUCCESS;
506 }
507
508 /* Check if this is a request for a the new comms connection */
509 if (DeviceObject == CommsDeviceObject)
510 {
511 /* Hand off to our internal routine */
512 return FltpMsgCreate(DeviceObject, Irp);
513 }
514
515 FLT_ASSERT(DeviceExtension &&
516 DeviceExtension->AttachedToDeviceObject);
517
518 DPRINT1("Received create from %wZ (%lu)\n", &DeviceExtension->DeviceName, PsGetCurrentProcessId());
519
520 /* Just pass the IRP down the stack */
521 IoSkipCurrentIrpStackLocation(Irp);
522 return IoCallDriver(DeviceExtension->AttachedToDeviceObject, Irp);
523 }
524
525 NTSTATUS
526 NTAPI
527 FltpFsControl(_In_ PDEVICE_OBJECT DeviceObject,
528 _Inout_ PIRP Irp)
529 {
530 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
531
532 PAGED_CODE();
533
534 /* Check if this is a request for us */
535 if (DeviceObject == DriverData.DeviceObject)
536 {
537 /* We don't handle this request */
538 Irp->IoStatus.Information = 0;
539 Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
540 IofCompleteRequest(Irp, 0);
541 return STATUS_INVALID_DEVICE_REQUEST;
542 }
543
544 DeviceExtension = DeviceObject->DeviceExtension;
545
546 FLT_ASSERT(DeviceExtension &&
547 DeviceExtension->AttachedToDeviceObject);
548
549 /* Just pass the IRP down the stack */
550 IoSkipCurrentIrpStackLocation(Irp);
551 return IoCallDriver(DeviceExtension->AttachedToDeviceObject, Irp);
552 }
553
554 NTSTATUS
555 NTAPI
556 FltpDeviceControl(_In_ PDEVICE_OBJECT DeviceObject,
557 _Inout_ PIRP Irp)
558 {
559 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
560 NTSTATUS Status;
561
562 /* Check if the request was meant for us */
563 if (DeviceObject == DriverData.DeviceObject)
564 {
565 Status = FltpDeviceControlHandler(DeviceObject, Irp);
566 if (Status != STATUS_REPARSE)
567 {
568 Irp->IoStatus.Status = Status;
569 Irp->IoStatus.Information = 0;
570 IoCompleteRequest(Irp, 0);
571 }
572
573 return Status;
574 }
575
576 DeviceExtension = DeviceObject->DeviceExtension;
577
578 FLT_ASSERT(DeviceExtension &&
579 DeviceExtension->AttachedToDeviceObject);
580
581 /* Just pass the IRP down the stack */
582 IoSkipCurrentIrpStackLocation(Irp);
583 return IoCallDriver(DeviceExtension->AttachedToDeviceObject, Irp);
584 }
585
586
587
588 /* FASTIO ROUTINES ************************************************/
589
590 BOOLEAN
591 NTAPI
592 FltpFastIoCheckIfPossible(_In_ PFILE_OBJECT FileObject,
593 _In_ PLARGE_INTEGER FileOffset,
594 _In_ ULONG Length,
595 _In_ BOOLEAN Wait,
596 _In_ ULONG LockKey,
597 _In_ BOOLEAN CheckForReadOperation,
598 _Out_ PIO_STATUS_BLOCK IoStatus,
599 _In_ PDEVICE_OBJECT DeviceObject)
600
601 {
602 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
603 PDEVICE_OBJECT AttachedDeviceObject;
604 PFAST_IO_DISPATCH FastIoDispatch;
605
606 PAGED_CODE();
607
608 /* If it doesn't have a device extension, then it's not our device object */
609 if (DeviceObject->DeviceExtension == NULL)
610 {
611 /* Fail the call */
612 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
613 IoStatus->Information = 0;
614 return TRUE;
615 }
616
617 DeviceExtension = DeviceObject->DeviceExtension;
618 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
619
620 /* Get the device that we attached to */
621 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
622 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
623
624 /* Make sure our FastIo table is valid */
625 if (FastIoDispatch && FastIoDispatch->FastIoCheckIfPossible)
626 {
627 /* Forward the call onto the device we attached to */
628 return FastIoDispatch->FastIoCheckIfPossible(FileObject,
629 FileOffset,
630 Length,
631 Wait,
632 LockKey,
633 CheckForReadOperation,
634 IoStatus,
635 AttachedDeviceObject);
636 }
637
638 /* We failed to handle the request, send it down the slow path */
639 FLT_ASSERT(FALSE);
640 return FALSE;
641 }
642
643 BOOLEAN
644 NTAPI
645 FltpFastIoRead(_In_ PFILE_OBJECT FileObject,
646 _In_ PLARGE_INTEGER FileOffset,
647 _In_ ULONG Length,
648 _In_ BOOLEAN Wait,
649 _In_ ULONG LockKey,
650 _Out_ PVOID Buffer,
651 _Out_ PIO_STATUS_BLOCK IoStatus,
652 _In_ PDEVICE_OBJECT DeviceObject)
653 {
654 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
655 PDEVICE_OBJECT AttachedDeviceObject;
656 PFAST_IO_DISPATCH FastIoDispatch;
657
658 PAGED_CODE();
659
660 /* If it doesn't have a device extension, then it's not our device object */
661 if (DeviceObject->DeviceExtension == NULL)
662 {
663 /* Fail the call */
664 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
665 IoStatus->Information = 0;
666 return TRUE;
667 }
668
669 DeviceExtension = DeviceObject->DeviceExtension;
670 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
671
672 /* Get the device that we attached to */
673 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
674 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
675
676 /* Make sure our FastIo table is valid */
677 if (FastIoDispatch && FastIoDispatch->FastIoRead)
678 {
679 /* Forward the call onto the device we attached to */
680 return FastIoDispatch->FastIoRead(FileObject,
681 FileOffset,
682 Length,
683 Wait,
684 LockKey,
685 Buffer,
686 IoStatus,
687 AttachedDeviceObject);
688 }
689
690 /* We failed to handle the request, send it down the slow path */
691 FLT_ASSERT(FALSE);
692 return FALSE;
693 }
694
695 BOOLEAN
696 NTAPI
697 FltpFastIoWrite(_In_ PFILE_OBJECT FileObject,
698 _In_ PLARGE_INTEGER FileOffset,
699 _In_ ULONG Length,
700 _In_ BOOLEAN Wait,
701 _In_ ULONG LockKey,
702 _In_ PVOID Buffer,
703 _Out_ PIO_STATUS_BLOCK IoStatus,
704 _In_ PDEVICE_OBJECT DeviceObject)
705 {
706 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
707 PDEVICE_OBJECT AttachedDeviceObject;
708 PFAST_IO_DISPATCH FastIoDispatch;
709
710 PAGED_CODE();
711
712 /* If it doesn't have a device extension, then it's not our device object */
713 if (DeviceObject->DeviceExtension == NULL)
714 {
715 /* Fail the call */
716 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
717 IoStatus->Information = 0;
718 return TRUE;
719 }
720
721 DeviceExtension = DeviceObject->DeviceExtension;
722 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
723
724 /* Get the device that we attached to */
725 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
726 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
727
728 /* Make sure our FastIo table is valid */
729 if (FastIoDispatch && FastIoDispatch->FastIoWrite)
730 {
731 /* Forward the call onto the device we attached to */
732 return FastIoDispatch->FastIoWrite(FileObject,
733 FileOffset,
734 Length,
735 Wait,
736 LockKey,
737 Buffer,
738 IoStatus,
739 AttachedDeviceObject);
740 }
741
742 /* We failed to handle the request, send it down the slow path */
743 FLT_ASSERT(FALSE);
744 return FALSE;
745 }
746
747 BOOLEAN
748 NTAPI
749 FltpFastIoQueryBasicInfo(_In_ PFILE_OBJECT FileObject,
750 _In_ BOOLEAN Wait,
751 _Out_ PFILE_BASIC_INFORMATION Buffer,
752 _Out_ PIO_STATUS_BLOCK IoStatus,
753 _In_ PDEVICE_OBJECT DeviceObject)
754 {
755 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
756 PDEVICE_OBJECT AttachedDeviceObject;
757 PFAST_IO_DISPATCH FastIoDispatch;
758
759 PAGED_CODE();
760
761 /* If it doesn't have a device extension, then it's not our device object */
762 if (DeviceObject->DeviceExtension == NULL)
763 {
764 /* Fail the call */
765 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
766 IoStatus->Information = 0;
767 return TRUE;
768 }
769
770 DeviceExtension = DeviceObject->DeviceExtension;
771 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
772
773 /* Get the device that we attached to */
774 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
775 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
776
777 /* Make sure our FastIo table is valid */
778 if (FastIoDispatch && FastIoDispatch->FastIoQueryBasicInfo)
779 {
780 /* Forward the call onto the device we attached to */
781 return FastIoDispatch->FastIoQueryBasicInfo(FileObject,
782 Wait,
783 Buffer,
784 IoStatus,
785 AttachedDeviceObject);
786 }
787
788 /* We failed to handle the request, send it down the slow path */
789 FLT_ASSERT(FALSE);
790 return FALSE;
791 }
792
793 BOOLEAN
794 NTAPI
795 FltpFastIoQueryStandardInfo(_In_ PFILE_OBJECT FileObject,
796 _In_ BOOLEAN Wait,
797 _Out_ PFILE_STANDARD_INFORMATION Buffer,
798 _Out_ PIO_STATUS_BLOCK IoStatus,
799 _In_ PDEVICE_OBJECT DeviceObject)
800 {
801 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
802 PDEVICE_OBJECT AttachedDeviceObject;
803 PFAST_IO_DISPATCH FastIoDispatch;
804
805 PAGED_CODE();
806
807 /* If it doesn't have a device extension, then it's not our device object */
808 if (DeviceObject->DeviceExtension == NULL)
809 {
810 /* Fail the call */
811 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
812 IoStatus->Information = 0;
813 return TRUE;
814 }
815
816 DeviceExtension = DeviceObject->DeviceExtension;
817 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
818
819 /* Get the device that we attached to */
820 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
821 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
822
823 /* Make sure our FastIo table is valid */
824 if (FastIoDispatch && FastIoDispatch->FastIoQueryStandardInfo)
825 {
826 /* Forward the call onto the device we attached to */
827 return FastIoDispatch->FastIoQueryStandardInfo(FileObject,
828 Wait,
829 Buffer,
830 IoStatus,
831 AttachedDeviceObject);
832 }
833
834 /* We failed to handle the request, send it down the slow path */
835 FLT_ASSERT(FALSE);
836 return FALSE;
837 }
838
839 BOOLEAN
840 NTAPI
841 FltpFastIoLock(_In_ PFILE_OBJECT FileObject,
842 _In_ PLARGE_INTEGER FileOffset,
843 _In_ PLARGE_INTEGER Length,
844 _In_ PEPROCESS ProcessId,
845 _In_ ULONG Key,
846 _In_ BOOLEAN FailImmediately,
847 _In_ BOOLEAN ExclusiveLock,
848 _Out_ PIO_STATUS_BLOCK IoStatus,
849 _In_ PDEVICE_OBJECT DeviceObject)
850 {
851 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
852 PDEVICE_OBJECT AttachedDeviceObject;
853 PFAST_IO_DISPATCH FastIoDispatch;
854
855 PAGED_CODE();
856
857 /* If it doesn't have a device extension, then it's not our device object */
858 if (DeviceObject->DeviceExtension == NULL)
859 {
860 /* Fail the call */
861 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
862 IoStatus->Information = 0;
863 return TRUE;
864 }
865
866 DeviceExtension = DeviceObject->DeviceExtension;
867 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
868
869 /* Get the device that we attached to */
870 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
871 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
872
873 /* Make sure our FastIo table is valid */
874 if (FastIoDispatch && FastIoDispatch->FastIoLock)
875 {
876 /* Forward the call onto the device we attached to */
877 return FastIoDispatch->FastIoLock(FileObject,
878 FileOffset,
879 Length,
880 ProcessId,
881 Key,
882 FailImmediately,
883 ExclusiveLock,
884 IoStatus,
885 AttachedDeviceObject);
886 }
887
888 /* We failed to handle the request, send it down the slow path */
889 FLT_ASSERT(FALSE);
890 return FALSE;
891 }
892
893 BOOLEAN
894 NTAPI
895 FltpFastIoUnlockSingle(_In_ PFILE_OBJECT FileObject,
896 _In_ PLARGE_INTEGER FileOffset,
897 _In_ PLARGE_INTEGER Length,
898 _In_ PEPROCESS ProcessId,
899 _In_ ULONG Key,
900 _Out_ PIO_STATUS_BLOCK IoStatus,
901 _In_ PDEVICE_OBJECT DeviceObject)
902 {
903 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
904 PDEVICE_OBJECT AttachedDeviceObject;
905 PFAST_IO_DISPATCH FastIoDispatch;
906
907 PAGED_CODE();
908
909 /* If it doesn't have a device extension, then it's not our device object */
910 if (DeviceObject->DeviceExtension == NULL)
911 {
912 /* Fail the call */
913 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
914 IoStatus->Information = 0;
915 return TRUE;
916 }
917
918 DeviceExtension = DeviceObject->DeviceExtension;
919 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
920
921 /* Get the device that we attached to */
922 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
923 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
924
925 /* Make sure our FastIo table is valid */
926 if (FastIoDispatch && FastIoDispatch->FastIoUnlockSingle)
927 {
928 /* Forward the call onto the device we attached to */
929 return FastIoDispatch->FastIoUnlockSingle(FileObject,
930 FileOffset,
931 Length,
932 ProcessId,
933 Key,
934 IoStatus,
935 AttachedDeviceObject);
936 }
937
938 /* We failed to handle the request, send it down the slow path */
939 FLT_ASSERT(FALSE);
940 return FALSE;
941 }
942
943 BOOLEAN
944 NTAPI
945 FltpFastIoUnlockAll(_In_ PFILE_OBJECT FileObject,
946 _In_ PEPROCESS ProcessId,
947 _Out_ PIO_STATUS_BLOCK IoStatus,
948 _In_ PDEVICE_OBJECT DeviceObject)
949
950 {
951 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
952 PDEVICE_OBJECT AttachedDeviceObject;
953 PFAST_IO_DISPATCH FastIoDispatch;
954
955 PAGED_CODE();
956
957 /* If it doesn't have a device extension, then it's not our device object */
958 if (DeviceObject->DeviceExtension == NULL)
959 {
960 /* Fail the call */
961 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
962 IoStatus->Information = 0;
963 return TRUE;
964 }
965
966 DeviceExtension = DeviceObject->DeviceExtension;
967 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
968
969 /* Get the device that we attached to */
970 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
971 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
972
973 /* Make sure our FastIo table is valid */
974 if (FastIoDispatch && FastIoDispatch->FastIoUnlockAll)
975 {
976 /* Forward the call onto the device we attached to */
977 return FastIoDispatch->FastIoUnlockAll(FileObject,
978 ProcessId,
979 IoStatus,
980 AttachedDeviceObject);
981 }
982
983 /* We failed to handle the request, send it down the slow path */
984 FLT_ASSERT(FALSE);
985 return FALSE;
986 }
987
988 BOOLEAN
989 NTAPI
990 FltpFastIoUnlockAllByKey(_In_ PFILE_OBJECT FileObject,
991 _In_ PVOID ProcessId,
992 _In_ ULONG Key,
993 _Out_ PIO_STATUS_BLOCK IoStatus,
994 _In_ PDEVICE_OBJECT DeviceObject)
995 {
996 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
997 PDEVICE_OBJECT AttachedDeviceObject;
998 PFAST_IO_DISPATCH FastIoDispatch;
999
1000 PAGED_CODE();
1001
1002 /* If it doesn't have a device extension, then it's not our device object */
1003 if (DeviceObject->DeviceExtension == NULL)
1004 {
1005 /* Fail the call */
1006 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
1007 IoStatus->Information = 0;
1008 return TRUE;
1009 }
1010
1011 DeviceExtension = DeviceObject->DeviceExtension;
1012 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1013
1014 /* Get the device that we attached to */
1015 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1016 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1017
1018 /* Make sure our FastIo table is valid */
1019 if (FastIoDispatch && FastIoDispatch->FastIoUnlockAllByKey)
1020 {
1021 /* Forward the call onto the device we attached to */
1022 return FastIoDispatch->FastIoUnlockAllByKey(FileObject,
1023 ProcessId,
1024 Key,
1025 IoStatus,
1026 AttachedDeviceObject);
1027 }
1028
1029 /* We failed to handle the request, send it down the slow path */
1030 FLT_ASSERT(FALSE);
1031 return FALSE;
1032 }
1033
1034 BOOLEAN
1035 NTAPI
1036 FltpFastIoDeviceControl(_In_ PFILE_OBJECT FileObject,
1037 _In_ BOOLEAN Wait,
1038 _In_opt_ PVOID InputBuffer,
1039 _In_ ULONG InputBufferLength,
1040 _Out_opt_ PVOID OutputBuffer,
1041 _In_ ULONG OutputBufferLength,
1042 _In_ ULONG IoControlCode,
1043 _Out_ PIO_STATUS_BLOCK IoStatus,
1044 _In_ PDEVICE_OBJECT DeviceObject)
1045 {
1046 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1047 PDEVICE_OBJECT AttachedDeviceObject;
1048 PFAST_IO_DISPATCH FastIoDispatch;
1049
1050 PAGED_CODE();
1051
1052 /* If it doesn't have a device extension, then it's not our device object */
1053 if (DeviceObject->DeviceExtension == NULL)
1054 {
1055 /* Fail the request, send it down the slow path */
1056 return FALSE;
1057 }
1058
1059 DeviceExtension = DeviceObject->DeviceExtension;
1060 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1061
1062 /* Get the device that we attached to */
1063 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1064 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1065
1066 /* Make sure our FastIo table is valid */
1067 if (FastIoDispatch && FastIoDispatch->FastIoDeviceControl)
1068 {
1069 /* Forward the call onto the device we attached to */
1070 return FastIoDispatch->FastIoDeviceControl(FileObject,
1071 Wait,
1072 InputBuffer,
1073 InputBufferLength,
1074 OutputBuffer,
1075 OutputBufferLength,
1076 IoControlCode,
1077 IoStatus,
1078 AttachedDeviceObject);
1079 }
1080
1081 /* We failed to handle the request, send it down the slow path */
1082 FLT_ASSERT(FALSE);
1083 return FALSE;
1084 }
1085
1086 VOID
1087 NTAPI
1088 FltpFastIoDetachDeviceWorker(_In_ PVOID Parameter)
1089 {
1090 PDETACH_DEVICE_WORK_ITEM DetachDeviceWorkItem = Parameter;
1091
1092 /* Run any cleanup routines */
1093 FltpCleanupDeviceObject(DetachDeviceWorkItem->SourceDevice);
1094
1095 /* Detach from the target device */
1096 IoDetachDevice(DetachDeviceWorkItem->TargetDevice);
1097
1098 /* Delete the source */
1099 IoDeleteDevice(DetachDeviceWorkItem->SourceDevice);
1100
1101 /* Free the pool we allocated in FltpFastIoDetachDevice */
1102 ExFreePoolWithTag(DetachDeviceWorkItem, 0x1234);
1103 }
1104
1105 VOID
1106 NTAPI
1107 FltpFastIoDetachDevice(_In_ PDEVICE_OBJECT SourceDevice,
1108 _In_ PDEVICE_OBJECT TargetDevice)
1109 {
1110 PDETACH_DEVICE_WORK_ITEM DetachDeviceWorkItem;
1111
1112 PAGED_CODE();
1113
1114 /*
1115 * Detaching and deleting devices is a lot of work and takes too long
1116 * to be a worthwhile FastIo candidate, so we defer this call to speed
1117 * it up. There's no return value so we're okay to do this.
1118 */
1119
1120 /* Allocate the work item and it's corresponding data */
1121 DetachDeviceWorkItem = ExAllocatePoolWithTag(NonPagedPool,
1122 sizeof(DETACH_DEVICE_WORK_ITEM),
1123 0x1234);
1124 if (DetachDeviceWorkItem)
1125 {
1126 /* Initialize the work item */
1127 ExInitializeWorkItem(&DetachDeviceWorkItem->WorkItem,
1128 FltpFastIoDetachDeviceWorker,
1129 DetachDeviceWorkItem);
1130
1131 /* Queue the work item and return the call */
1132 ExQueueWorkItem(&DetachDeviceWorkItem->WorkItem,
1133 DelayedWorkQueue);
1134 }
1135 else
1136 {
1137 /* We failed to defer, just cleanup here */
1138 FltpCleanupDeviceObject(SourceDevice);
1139 IoDetachDevice(TargetDevice);
1140 IoDeleteDevice(SourceDevice);
1141 }
1142
1143 }
1144
1145 BOOLEAN
1146 NTAPI
1147 FltpFastIoQueryNetworkOpenInfo(_In_ PFILE_OBJECT FileObject,
1148 _In_ BOOLEAN Wait,
1149 _Out_ PFILE_NETWORK_OPEN_INFORMATION Buffer,
1150 _Out_ PIO_STATUS_BLOCK IoStatus,
1151 _In_ PDEVICE_OBJECT DeviceObject)
1152 {
1153 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1154 PDEVICE_OBJECT AttachedDeviceObject;
1155 PFAST_IO_DISPATCH FastIoDispatch;
1156
1157 PAGED_CODE();
1158
1159 /* If it doesn't have a device extension, then it's not our device object */
1160 if (DeviceObject->DeviceExtension == NULL)
1161 {
1162 /* Fail the call */
1163 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
1164 IoStatus->Information = 0;
1165 return TRUE;
1166 }
1167
1168 DeviceExtension = DeviceObject->DeviceExtension;
1169 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1170
1171 /* Get the device that we attached to */
1172 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1173 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1174
1175 /* Make sure our FastIo table is valid */
1176 if (FastIoDispatch && FastIoDispatch->FastIoQueryNetworkOpenInfo)
1177 {
1178 /* Forward the call onto the device we attached to */
1179 return FastIoDispatch->FastIoQueryNetworkOpenInfo(FileObject,
1180 Wait,
1181 Buffer,
1182 IoStatus,
1183 AttachedDeviceObject);
1184 }
1185
1186 /* We failed to handle the request, send it down the slow path */
1187 FLT_ASSERT(FALSE);
1188 return FALSE;
1189 }
1190
1191 BOOLEAN
1192 NTAPI
1193 FltpFastIoMdlRead(_In_ PFILE_OBJECT FileObject,
1194 _In_ PLARGE_INTEGER FileOffset,
1195 _In_ ULONG Length,
1196 _In_ ULONG LockKey,
1197 _Out_ PMDL *MdlChain,
1198 _Out_ PIO_STATUS_BLOCK IoStatus,
1199 _In_ PDEVICE_OBJECT DeviceObject)
1200 {
1201 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1202 PDEVICE_OBJECT AttachedDeviceObject;
1203 PFAST_IO_DISPATCH FastIoDispatch;
1204
1205 PAGED_CODE();
1206
1207 /* If it doesn't have a device extension, then it's not our device object */
1208 if (DeviceObject->DeviceExtension == NULL)
1209 {
1210 /* Fail the call */
1211 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
1212 IoStatus->Information = 0;
1213 return TRUE;
1214 }
1215
1216 DeviceExtension = DeviceObject->DeviceExtension;
1217 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1218
1219 /* Get the device that we attached to */
1220 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1221 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1222
1223 /* Make sure our FastIo table is valid */
1224 if (FastIoDispatch && FastIoDispatch->MdlRead)
1225 {
1226 /* Forward the call onto the device we attached to */
1227 return FastIoDispatch->MdlRead(FileObject,
1228 FileOffset,
1229 Length,
1230 LockKey,
1231 MdlChain,
1232 IoStatus,
1233 AttachedDeviceObject);
1234 }
1235
1236 /* We failed to handle the request, send it down the slow path */
1237 FLT_ASSERT(FALSE);
1238 return FALSE;
1239 }
1240
1241 BOOLEAN
1242 NTAPI
1243 FltpFastIoMdlReadComplete(_In_ PFILE_OBJECT FileObject,
1244 _In_ PMDL MdlChain,
1245 _In_ PDEVICE_OBJECT DeviceObject)
1246
1247 {
1248 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1249 PDEVICE_OBJECT AttachedDeviceObject;
1250 PFAST_IO_DISPATCH FastIoDispatch;
1251
1252 PAGED_CODE();
1253
1254 /* If it doesn't have a device extension, then it's not our device object */
1255 if (DeviceObject->DeviceExtension == NULL)
1256 {
1257 /* Fail the request, send it down the slow path */
1258 return FALSE;
1259 }
1260
1261 DeviceExtension = DeviceObject->DeviceExtension;
1262 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1263
1264 /* Get the device that we attached to */
1265 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1266 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1267
1268 /* Make sure our FastIo table is valid */
1269 if (FastIoDispatch && FastIoDispatch->MdlReadComplete)
1270 {
1271 /* Forward the call onto the device we attached to */
1272 return FastIoDispatch->MdlReadComplete(FileObject,
1273 MdlChain,
1274 AttachedDeviceObject);
1275 }
1276
1277 /* We failed to handle the request, send it down the slow path */
1278 FLT_ASSERT(FALSE);
1279 return FALSE;
1280 }
1281
1282 BOOLEAN
1283 NTAPI
1284 FltpFastIoPrepareMdlWrite(_In_ PFILE_OBJECT FileObject,
1285 _In_ PLARGE_INTEGER FileOffset,
1286 _In_ ULONG Length,
1287 _In_ ULONG LockKey,
1288 _Out_ PMDL *MdlChain,
1289 _Out_ PIO_STATUS_BLOCK IoStatus,
1290 _In_ PDEVICE_OBJECT DeviceObject)
1291 {
1292 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1293 PDEVICE_OBJECT AttachedDeviceObject;
1294 PFAST_IO_DISPATCH FastIoDispatch;
1295
1296 PAGED_CODE();
1297
1298 /* If it doesn't have a device extension, then it's not our device object */
1299 if (DeviceObject->DeviceExtension == NULL)
1300 {
1301 /* Fail the call */
1302 IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
1303 IoStatus->Information = 0;
1304 return TRUE;
1305 }
1306
1307 DeviceExtension = DeviceObject->DeviceExtension;
1308 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1309
1310 /* Get the device that we attached to */
1311 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1312 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1313
1314 /* Make sure our FastIo table is valid */
1315 if (FastIoDispatch && FastIoDispatch->PrepareMdlWrite)
1316 {
1317 /* Forward the call onto the device we attached to */
1318 return FastIoDispatch->PrepareMdlWrite(FileObject,
1319 FileOffset,
1320 Length,
1321 LockKey,
1322 MdlChain,
1323 IoStatus,
1324 AttachedDeviceObject);
1325 }
1326
1327 /* We failed to handle the request, send it down the slow path */
1328 FLT_ASSERT(FALSE);
1329 return FALSE;
1330 }
1331
1332 BOOLEAN
1333 NTAPI
1334 FltpFastIoMdlWriteComplete(_In_ PFILE_OBJECT FileObject,
1335 _In_ PLARGE_INTEGER FileOffset,
1336 _In_ PMDL MdlChain,
1337 _In_ PDEVICE_OBJECT DeviceObject)
1338 {
1339 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1340 PDEVICE_OBJECT AttachedDeviceObject;
1341 PFAST_IO_DISPATCH FastIoDispatch;
1342
1343 PAGED_CODE();
1344
1345 /* If it doesn't have a device extension, then it's not our device object */
1346 if (DeviceObject->DeviceExtension == NULL)
1347 {
1348 /* Fail the request, send it down the slow path */
1349 return FALSE;
1350 }
1351
1352 DeviceExtension = DeviceObject->DeviceExtension;
1353 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1354
1355 /* Get the device that we attached to */
1356 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1357 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1358
1359 /* Make sure our FastIo table is valid */
1360 if (FastIoDispatch && FastIoDispatch->MdlWriteComplete)
1361 {
1362 /* Forward the call onto the device we attached to */
1363 return FastIoDispatch->MdlWriteComplete(FileObject,
1364 FileOffset,
1365 MdlChain,
1366 AttachedDeviceObject);
1367 }
1368
1369 /* We failed to handle the request, send it down the slow path */
1370 FLT_ASSERT(FALSE);
1371 return FALSE;
1372 }
1373
1374 BOOLEAN
1375 NTAPI
1376 FltpFastIoReadCompressed(_In_ PFILE_OBJECT FileObject,
1377 _In_ PLARGE_INTEGER FileOffset,
1378 _In_ ULONG Length,
1379 _In_ ULONG LockKey,
1380 _Out_ PVOID Buffer,
1381 _Out_ PMDL *MdlChain,
1382 _Out_ PIO_STATUS_BLOCK IoStatus,
1383 _Out_ PCOMPRESSED_DATA_INFO CompressedDataInfo,
1384 _In_ ULONG CompressedDataInfoLength,
1385 _In_ PDEVICE_OBJECT DeviceObject)
1386 {
1387 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1388 PDEVICE_OBJECT AttachedDeviceObject;
1389 PFAST_IO_DISPATCH FastIoDispatch;
1390
1391 PAGED_CODE();
1392
1393 /* If it doesn't have a device extension, then it's not our device object */
1394 if (DeviceObject->DeviceExtension == NULL)
1395 {
1396 /* Fail the request, send it down the slow path */
1397 return FALSE;
1398 }
1399
1400 DeviceExtension = DeviceObject->DeviceExtension;
1401 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1402
1403 /* Get the device that we attached to */
1404 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1405 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1406
1407 /* Make sure our FastIo table is valid */
1408 if (FastIoDispatch && FastIoDispatch->FastIoReadCompressed)
1409 {
1410 /* Forward the call onto the device we attached to */
1411 return FastIoDispatch->FastIoReadCompressed(FileObject,
1412 FileOffset,
1413 Length,
1414 LockKey,
1415 Buffer,
1416 MdlChain,
1417 IoStatus,
1418 CompressedDataInfo,
1419 CompressedDataInfoLength,
1420 AttachedDeviceObject);
1421 }
1422
1423 /* We failed to handle the request, send it down the slow path */
1424 FLT_ASSERT(FALSE);
1425 return FALSE;
1426 }
1427
1428 BOOLEAN
1429 NTAPI
1430 FltpFastIoWriteCompressed(_In_ PFILE_OBJECT FileObject,
1431 _In_ PLARGE_INTEGER FileOffset,
1432 _In_ ULONG Length,
1433 _In_ ULONG LockKey,
1434 _In_ PVOID Buffer,
1435 _Out_ PMDL *MdlChain,
1436 _Out_ PIO_STATUS_BLOCK IoStatus,
1437 _In_ PCOMPRESSED_DATA_INFO CompressedDataInfo,
1438 _In_ ULONG CompressedDataInfoLength,
1439 _In_ PDEVICE_OBJECT DeviceObject)
1440 {
1441 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1442 PDEVICE_OBJECT AttachedDeviceObject;
1443 PFAST_IO_DISPATCH FastIoDispatch;
1444
1445 PAGED_CODE();
1446
1447 /* If it doesn't have a device extension, then it's not our device object */
1448 if (DeviceObject->DeviceExtension == NULL)
1449 {
1450 /* Fail the request, send it down the slow path */
1451 return FALSE;
1452 }
1453
1454 DeviceExtension = DeviceObject->DeviceExtension;
1455 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1456
1457 /* Get the device that we attached to */
1458 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1459 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1460
1461 /* Make sure our FastIo table is valid */
1462 if (FastIoDispatch && FastIoDispatch->FastIoWriteCompressed)
1463 {
1464 /* Forward the call onto the device we attached to */
1465 return FastIoDispatch->FastIoWriteCompressed(FileObject,
1466 FileOffset,
1467 Length,
1468 LockKey,
1469 Buffer,
1470 MdlChain,
1471 IoStatus,
1472 CompressedDataInfo,
1473 CompressedDataInfoLength,
1474 AttachedDeviceObject);
1475 }
1476
1477 /* We failed to handle the request, send it down the slow path */
1478 FLT_ASSERT(FALSE);
1479 return FALSE;
1480 }
1481
1482 BOOLEAN
1483 NTAPI
1484 FltpFastIoMdlReadCompleteCompressed(_In_ PFILE_OBJECT FileObject,
1485 _In_ PMDL MdlChain,
1486 _In_ PDEVICE_OBJECT DeviceObject)
1487 {
1488 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1489 PDEVICE_OBJECT AttachedDeviceObject;
1490 PFAST_IO_DISPATCH FastIoDispatch;
1491
1492 PAGED_CODE();
1493
1494 /* If it doesn't have a device extension, then it's not our device object */
1495 if (DeviceObject->DeviceExtension == NULL)
1496 {
1497 return FALSE;
1498 }
1499
1500 DeviceExtension = DeviceObject->DeviceExtension;
1501 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1502
1503 /* Get the device that we attached to */
1504 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1505 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1506
1507 /* Make sure our FastIo table is valid */
1508 if (FastIoDispatch && FastIoDispatch->MdlReadCompleteCompressed)
1509 {
1510 /* Forward the call onto the device we attached to */
1511 return FastIoDispatch->MdlReadCompleteCompressed(FileObject,
1512 MdlChain,
1513 AttachedDeviceObject);
1514 }
1515
1516 /* We failed to handle the request, send it down the slow path */
1517 FLT_ASSERT(FALSE);
1518 return FALSE;
1519 }
1520
1521 BOOLEAN
1522 NTAPI
1523 FltpFastIoMdlWriteCompleteCompressed(_In_ PFILE_OBJECT FileObject,
1524 _In_ PLARGE_INTEGER FileOffset,
1525 _In_ PMDL MdlChain,
1526 _In_ PDEVICE_OBJECT DeviceObject)
1527 {
1528 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1529 PDEVICE_OBJECT AttachedDeviceObject;
1530 PFAST_IO_DISPATCH FastIoDispatch;
1531
1532 PAGED_CODE();
1533
1534 /* If it doesn't have a device extension, then it's not our device object */
1535 if (DeviceObject->DeviceExtension == NULL)
1536 {
1537 return FALSE;
1538 }
1539
1540 DeviceExtension = DeviceObject->DeviceExtension;
1541 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1542
1543 /* Get the device that we attached to */
1544 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1545 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1546
1547 /* Make sure our FastIo table is valid */
1548 if (FastIoDispatch && FastIoDispatch->MdlWriteCompleteCompressed)
1549 {
1550 /* Forward the call onto the device we attached to */
1551 return FastIoDispatch->MdlWriteCompleteCompressed(FileObject,
1552 FileOffset,
1553 MdlChain,
1554 AttachedDeviceObject);
1555 }
1556
1557 /* We failed to handle the request, send it down the slow path */
1558 FLT_ASSERT(FALSE);
1559 return FALSE;
1560 }
1561
1562 BOOLEAN
1563 NTAPI
1564 FltpFastIoQueryOpen(_Inout_ PIRP Irp,
1565 _Out_ PFILE_NETWORK_OPEN_INFORMATION NetworkInformation,
1566 _In_ PDEVICE_OBJECT DeviceObject)
1567 {
1568 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1569 PDEVICE_OBJECT AttachedDeviceObject;
1570 PFAST_IO_DISPATCH FastIoDispatch;
1571 BOOLEAN Success;
1572
1573 PAGED_CODE();
1574
1575 /* If it doesn't have a device extension, then it's not our device object */
1576 if (DeviceObject->DeviceExtension == NULL)
1577 {
1578 return FALSE;
1579 }
1580
1581 DeviceExtension = DeviceObject->DeviceExtension;
1582 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1583
1584 /* Get the device that we attached to */
1585 AttachedDeviceObject = DeviceExtension->AttachedToDeviceObject;
1586 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1587
1588 /* Make sure our FastIo table is valid */
1589 if (FastIoDispatch && FastIoDispatch->FastIoQueryOpen)
1590 {
1591 PIO_STACK_LOCATION StackPtr = IoGetCurrentIrpStackLocation(Irp);
1592
1593 /* Update the stack to contain the correct device for the next filter */
1594 StackPtr->DeviceObject = AttachedDeviceObject;
1595
1596 /* Now forward the call */
1597 Success = FastIoDispatch->FastIoQueryOpen(Irp,
1598 NetworkInformation,
1599 AttachedDeviceObject);
1600
1601 /* Restore the DeviceObject as we found it */
1602 StackPtr->DeviceObject = DeviceObject;
1603 return Success;
1604 }
1605
1606 /* We failed to handle the request, send it down the slow path */
1607 FLT_ASSERT(FALSE);
1608 return FALSE;
1609 }
1610
1611
1612
1613 /* FUNCTIONS **********************************************/
1614
1615 static
1616 VOID
1617 FltpCleanupDeviceObject(_In_ PDEVICE_OBJECT DeviceObject)
1618 {
1619 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1620
1621 DeviceExtension = DeviceObject->DeviceExtension;
1622 if (DeviceExtension)
1623 {
1624 // cleanup device extension
1625 }
1626 }
1627
1628 static
1629 NTSTATUS
1630 FltpAttachDeviceObject(_In_ PDEVICE_OBJECT SourceDevice,
1631 _In_ PDEVICE_OBJECT TargetDevice,
1632 _Out_ PDEVICE_OBJECT *AttachedToDeviceObject)
1633 {
1634 NTSTATUS Status;
1635
1636 PAGED_CODE();
1637
1638 /* Before attaching, copy the flags from the device we're going to attach to */
1639 if (FlagOn(SourceDevice->Flags, DO_BUFFERED_IO))
1640 {
1641 SetFlag(TargetDevice->Flags, DO_BUFFERED_IO);
1642 }
1643 if (FlagOn(SourceDevice->Flags, DO_DIRECT_IO))
1644 {
1645 SetFlag(TargetDevice->Flags, DO_DIRECT_IO);
1646 }
1647 if (FlagOn(SourceDevice->Flags, DO_SYSTEM_BOOT_PARTITION))
1648 {
1649 SetFlag(TargetDevice->Characteristics, FILE_DEVICE_SECURE_OPEN);
1650 }
1651
1652 /* Attach this device to the top of the driver stack */
1653 Status = IoAttachDeviceToDeviceStackSafe(SourceDevice,
1654 TargetDevice,
1655 AttachedToDeviceObject);
1656
1657 return Status;
1658 }
1659
1660 static
1661 BOOLEAN
1662 FltpIsAttachedToDevice(_In_ PDEVICE_OBJECT DeviceObject,
1663 _In_opt_ PDEVICE_OBJECT *AttachedDeviceObject)
1664 {
1665 PDEVICE_OBJECT CurrentDeviceObject;
1666 PDEVICE_OBJECT NextDeviceObject;
1667
1668 PAGED_CODE();
1669
1670 /* Initialize the return pointer */
1671 if (AttachedDeviceObject) *AttachedDeviceObject = NULL;
1672
1673 /* Start by getting the top level device in the chain */
1674 CurrentDeviceObject = IoGetAttachedDeviceReference(DeviceObject);
1675
1676 /* Loop while there are attached devices */
1677 while (CurrentDeviceObject)
1678 {
1679 /* Check if this device driver matches ours */
1680 if (CurrentDeviceObject->DriverObject == DriverData.DriverObject)
1681 {
1682 FLT_ASSERT(CurrentDeviceObject->DeviceExtension != NULL);
1683
1684 /* We're attached, return the device object if the caller asked for it */
1685 if (AttachedDeviceObject)
1686 {
1687 *AttachedDeviceObject = CurrentDeviceObject;
1688 }
1689 else
1690 {
1691 /* We aren't returning the reference, so decrement the count */
1692 ObDereferenceObject(CurrentDeviceObject);
1693 }
1694
1695 return TRUE;
1696 }
1697
1698 /* Get the next device in the chain */
1699 NextDeviceObject = IoGetLowerDeviceObject(CurrentDeviceObject);
1700
1701 /* Decrement the count on the last device before we update the pointer */
1702 ObDereferenceObject(CurrentDeviceObject);
1703 CurrentDeviceObject = NextDeviceObject;
1704 }
1705
1706 return FALSE;
1707 }
1708
1709 static
1710 NTSTATUS
1711 FltpEnumerateFileSystemVolumes(_In_ PDEVICE_OBJECT DeviceObject)
1712 {
1713 PFLTMGR_DEVICE_EXTENSION NewDeviceExtension;
1714 PDEVICE_OBJECT BaseDeviceObject;
1715 PDEVICE_OBJECT NewDeviceObject;
1716 PDEVICE_OBJECT *DeviceList;
1717 PDEVICE_OBJECT StorageStackDeviceObject;
1718 UNICODE_STRING DeviceName;
1719 ULONG NumDevices;
1720 ULONG i;
1721 NTSTATUS Status;
1722
1723 PAGED_CODE();
1724
1725 /* Get the base device */
1726 BaseDeviceObject = IoGetDeviceAttachmentBaseRef(DeviceObject);
1727
1728 /* get the number of device object linked to the base file system */
1729 Status = IoEnumerateDeviceObjectList(BaseDeviceObject->DriverObject,
1730 NULL,
1731 0,
1732 &NumDevices);
1733 if (Status != STATUS_BUFFER_TOO_SMALL) return Status;
1734
1735 /* Add a few more slots in case the size changed between calls and allocate some memory to hold the pointers */
1736 NumDevices += 4;
1737 DeviceList = ExAllocatePoolWithTag(NonPagedPool,
1738 (NumDevices * sizeof(PDEVICE_OBJECT)),
1739 FM_TAG_DEV_OBJ_PTRS);
1740 if (DeviceList == NULL) return STATUS_INSUFFICIENT_RESOURCES;
1741
1742 /* Now get all the device objects that this base driver has created */
1743 Status = IoEnumerateDeviceObjectList(BaseDeviceObject->DriverObject,
1744 DeviceList,
1745 (NumDevices * sizeof(PDEVICE_OBJECT)),
1746 &NumDevices);
1747 if (!NT_SUCCESS(Status))
1748 {
1749 ExFreePoolWithTag(DeviceList, FM_TAG_DEV_OBJ_PTRS);
1750 return Status;
1751 }
1752
1753 /* Loop through all the devices looking for ones to attach to */
1754 for (i = 0; i < NumDevices; i++)
1755 {
1756 RtlInitUnicodeString(&DeviceName, NULL);
1757 StorageStackDeviceObject = NULL;
1758 NewDeviceObject = NULL;
1759
1760 /* Ignore the device we passed in, and devices of the wrong type */
1761 if ((DeviceList[i] == BaseDeviceObject) ||
1762 (DeviceList[i]->DeviceType != BaseDeviceObject->DeviceType))
1763 {
1764 goto CleanupAndNext;
1765 }
1766
1767 /* Ignore this device if we're already attached to it */
1768 if (FltpIsAttachedToDevice(DeviceList[i], NULL) == FALSE)
1769 {
1770 goto CleanupAndNext;
1771 }
1772
1773
1774 /*
1775 * If the device has a name, it must be a control device.
1776 * This handles drivers with more then one control device (like FastFat)
1777 */
1778 FltpGetBaseDeviceObjectName(DeviceList[i], &DeviceName);
1779 if (NT_SUCCESS(Status) && DeviceName.Length > 0)
1780 {
1781 goto CleanupAndNext;
1782 }
1783
1784 /*
1785 * Try to get the storage stack (disk) device object associated with
1786 * this file system device object. Ignore the device if we don't have one
1787 */
1788 Status = IoGetDiskDeviceObject(DeviceList[i],
1789 &StorageStackDeviceObject);
1790 if (!NT_SUCCESS(Status))
1791 {
1792 goto CleanupAndNext;
1793 }
1794
1795
1796 /*
1797 * TODO: Don't attach to shadow copy volumes,
1798 * ros doesn't have any so it's not an issues yet
1799 */
1800
1801 /*
1802 * We're far enough to be ready to attach, create a device
1803 * object which we'll use to do so
1804 */
1805 Status = IoCreateDevice(DriverData.DriverObject,
1806 sizeof(FLTMGR_DEVICE_EXTENSION),
1807 NULL,
1808 DeviceList[i]->DeviceType,
1809 0,
1810 FALSE,
1811 &NewDeviceObject);
1812 if (!NT_SUCCESS(Status))
1813 {
1814 goto CleanupAndNext;
1815 }
1816
1817 /* Get the device extension for this new object and store our disk object there */
1818 NewDeviceExtension = NewDeviceObject->DeviceExtension;
1819 NewDeviceExtension->StorageStackDeviceObject = StorageStackDeviceObject;
1820
1821 /* Lookup and store the device name for the storage stack */
1822 RtlInitEmptyUnicodeString(&NewDeviceExtension->DeviceName,
1823 NewDeviceExtension->DeviceNameBuffer,
1824 sizeof(NewDeviceExtension->DeviceNameBuffer));
1825 FltpGetObjectName(StorageStackDeviceObject,
1826 &NewDeviceExtension->DeviceName);
1827
1828
1829 /* Grab the attach lock before we attempt to attach */
1830 ExAcquireFastMutex(&DriverData.FilterAttachLock);
1831
1832 /* Check again that we aren't already attached. It may have changed since our last check */
1833 if (FltpIsAttachedToDevice(DeviceList[i], NULL) == FALSE)
1834 {
1835 FLT_ASSERT(NewDeviceObject->DriverObject == DriverData.DriverObject);
1836
1837 /* Finally, attach to the volume */
1838 Status = FltpAttachDeviceObject(DeviceList[i],
1839 NewDeviceObject,
1840 &NewDeviceExtension->AttachedToDeviceObject);
1841 if (NT_SUCCESS(Status))
1842 {
1843 /* Clean the initializing flag so other filters can attach to our device object */
1844 ClearFlag(NewDeviceObject->Flags, DO_DEVICE_INITIALIZING);
1845 }
1846 }
1847 else
1848 {
1849 /* We're already attached. Just cleanup */
1850 Status = STATUS_DEVICE_ALREADY_ATTACHED;
1851 }
1852
1853 ExReleaseFastMutex(&DriverData.FilterAttachLock);
1854
1855 CleanupAndNext:
1856
1857 if (!NT_SUCCESS(Status))
1858 {
1859 if (NewDeviceObject)
1860 {
1861 FltpCleanupDeviceObject(NewDeviceObject);
1862 IoDeleteDevice(NewDeviceObject);
1863 }
1864 }
1865
1866 if (StorageStackDeviceObject)
1867 {
1868 /* A ref was added for us when we attached, so we can deref ours now */
1869 ObDereferenceObject(StorageStackDeviceObject);
1870 }
1871
1872 /* Remove the ref which was added by IoEnumerateDeviceObjectList */
1873 ObDereferenceObject(DeviceList[i]);
1874
1875 /* Free the buffer that FltpGetBaseDeviceObjectName added */
1876 FltpFreeUnicodeString(&DeviceName);
1877
1878 }
1879
1880 /* Free the memory we allocated for the list */
1881 ExFreePoolWithTag(DeviceList, FM_TAG_DEV_OBJ_PTRS);
1882
1883 return STATUS_SUCCESS;
1884 }
1885
1886 static
1887 NTSTATUS
1888 FltpAttachToFileSystemDevice(_In_ PDEVICE_OBJECT DeviceObject,
1889 _In_ PUNICODE_STRING DeviceName)
1890 {
1891 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1892 PDEVICE_OBJECT NewDeviceObject;
1893 WCHAR Buffer[MAX_DEVNAME_LENGTH];
1894 UNICODE_STRING FileSystemDeviceName;
1895 UNICODE_STRING FsRecDeviceName;
1896 NTSTATUS Status;
1897
1898 PAGED_CODE();
1899
1900 /* Only handle device types we're interested in */
1901 if (DeviceObject->DeviceType != FILE_DEVICE_DISK_FILE_SYSTEM &&
1902 DeviceObject->DeviceType != FILE_DEVICE_CD_ROM_FILE_SYSTEM &&
1903 DeviceObject->DeviceType != FILE_DEVICE_NETWORK_FILE_SYSTEM)
1904 {
1905 return STATUS_SUCCESS;
1906 }
1907
1908 /* Setup the buffer to hold the device name */
1909 RtlInitEmptyUnicodeString(&FileSystemDeviceName,
1910 Buffer,
1911 MAX_DEVNAME_LENGTH * sizeof(WCHAR));
1912
1913 /* Get the the name of the file system device */
1914 Status = FltpGetObjectName(DeviceObject->DriverObject, &FileSystemDeviceName);
1915 if (!NT_SUCCESS(Status)) return Status;
1916
1917 DPRINT("Found device %wZ, checking if we need to attach...\n", &FileSystemDeviceName);
1918
1919 /* Build up the name of the file system recognizer device */
1920 RtlInitUnicodeString(&FsRecDeviceName, L"\\FileSystem\\Fs_Rec");
1921
1922 /* We don't attach to recognizer devices, so bail if this is one */
1923 if (RtlCompareUnicodeString(&FileSystemDeviceName, &FsRecDeviceName, TRUE) == 0)
1924 {
1925 return STATUS_SUCCESS;
1926 }
1927
1928 /* Create a device object which we can attach to this file system */
1929 Status = IoCreateDevice(DriverData.DriverObject,
1930 sizeof(FLTMGR_DEVICE_EXTENSION),
1931 NULL,
1932 DeviceObject->DeviceType,
1933 0,
1934 FALSE,
1935 &NewDeviceObject);
1936 if (!NT_SUCCESS(Status))
1937 {
1938 DPRINT1("Failed to create a DO for attaching to a FS : 0x%X\n", Status);
1939 return Status;
1940 }
1941
1942 /* Cast the device extension to something we understand */
1943 DeviceExtension = NewDeviceObject->DeviceExtension;
1944
1945 /* Attach this device to the top of the driver stack and store the DO we attached to in the DE */
1946 Status = FltpAttachDeviceObject(NewDeviceObject,
1947 DeviceObject,
1948 &DeviceExtension->AttachedToDeviceObject);
1949 if (NT_SUCCESS(Status))
1950 {
1951 DPRINT("Attached to %wZ\n", &FileSystemDeviceName);
1952 }
1953 else
1954 {
1955 DPRINT1("Failed to attach to the driver stack : 0x%X\n", Status);
1956 goto Cleanup;
1957 }
1958
1959 /* Setup the unicode string buffer and copy the device name to the device extension */
1960 RtlInitEmptyUnicodeString(&DeviceExtension->DeviceName,
1961 DeviceExtension->DeviceNameBuffer,
1962 MAX_DEVNAME_LENGTH * sizeof(WCHAR));
1963 RtlCopyUnicodeString(&DeviceExtension->DeviceName, DeviceName);
1964
1965 /* We're done, remove the initializing flag */
1966 ClearFlag(NewDeviceObject->Flags, DO_DEVICE_INITIALIZING);
1967
1968 /* Look for existing mounted devices for this file system */
1969 Status = FltpEnumerateFileSystemVolumes(DeviceObject);
1970 if (!NT_SUCCESS(Status))
1971 {
1972 DPRINT1("Failed to enumerate file system volumes for this file system : 0x%X\n", Status);
1973 IoDetachDevice(DeviceExtension->AttachedToDeviceObject);
1974 }
1975
1976 Cleanup:
1977
1978 if (!NT_SUCCESS(Status))
1979 {
1980 IoDeleteDevice(NewDeviceObject);
1981 }
1982
1983 return Status;
1984 }
1985
1986 static
1987 LONG_PTR
1988 FltpDetachFromFileSystemDevice(_In_ PDEVICE_OBJECT DeviceObject)
1989 {
1990 PDEVICE_OBJECT AttachedDevice, NextDevice;
1991 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1992 LONG_PTR Count;
1993
1994 PAGED_CODE();
1995
1996 /* Get the top device in the chain and increment the ref count on it */
1997 AttachedDevice = IoGetAttachedDeviceReference(DeviceObject);
1998
1999 /* Loop all attached devices looking for our file system driver */
2000 while (AttachedDevice->DriverObject != DriverData.DriverObject)
2001 {
2002 FLT_ASSERT(AttachedDevice != NULL);
2003
2004 /* Get the next lower device object. This adds a ref on NextDevice */
2005 NextDevice = IoGetLowerDeviceObject(AttachedDevice);
2006
2007 /* Remove the reference we added */
2008 Count = ObDereferenceObject(AttachedDevice);
2009
2010 /* Bail if this is the last one */
2011 if (NextDevice == NULL) return Count;
2012
2013 /* Try the next one */
2014 AttachedDevice = NextDevice;
2015 }
2016
2017
2018 DeviceExtension = AttachedDevice->DeviceExtension;
2019 if (DeviceExtension)
2020 {
2021 //
2022 // FIXME: Put any device extension cleanup code here
2023 //
2024 }
2025
2026 /* Detach the device from the chain and delete the object */
2027 IoDetachDevice(DeviceObject);
2028 IoDeleteDevice(AttachedDevice);
2029
2030 /* Remove the reference we added so the delete can complete */
2031 return ObDereferenceObject(AttachedDevice);
2032 }
2033
2034 DRIVER_FS_NOTIFICATION FltpFsNotification;
2035 VOID
2036 NTAPI
2037 FltpFsNotification(_In_ PDEVICE_OBJECT DeviceObject,
2038 _In_ BOOLEAN FsActive)
2039 {
2040 UNICODE_STRING DeviceName;
2041 NTSTATUS Status;
2042
2043 PAGED_CODE();
2044
2045 /* Set an empty string */
2046 RtlInitUnicodeString(&DeviceName, NULL);
2047
2048 /* Get the name of the lowest device object on the stack */
2049 Status = FltpGetBaseDeviceObjectName(DeviceObject, &DeviceName);
2050 if (NT_SUCCESS(Status))
2051 {
2052 /* Check if it's attaching or detaching */
2053 if (FsActive)
2054 {
2055 /* Run the attach routine */
2056 FltpAttachToFileSystemDevice(DeviceObject, &DeviceName);
2057 }
2058 else
2059 {
2060 /* Run the detach routine */
2061 FltpDetachFromFileSystemDevice(DeviceObject);
2062 }
2063
2064 /* Free the buffer which FltpGetBaseDeviceObjectName allocated */
2065 FltpFreeUnicodeString(&DeviceName);
2066 }
2067 }
2068
2069 DRIVER_INITIALIZE DriverEntry;
2070 NTSTATUS
2071 NTAPI
2072 DriverEntry(_In_ PDRIVER_OBJECT DriverObject,
2073 _In_ PUNICODE_STRING RegistryPath)
2074 {
2075 UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\FileSystem\\Filters\\"DRIVER_NAME);
2076 PDEVICE_OBJECT RawDeviceObject;
2077 PDEVICE_OBJECT DeviceObject;
2078 PFILE_OBJECT RawFileObject;
2079 UNICODE_STRING ObjectName;
2080 UNICODE_STRING SymLink;
2081
2082 NTSTATUS Status;
2083
2084 RtlZeroMemory(&DriverData, sizeof(DRIVER_DATA));
2085 DriverData.DriverObject = DriverObject;
2086
2087 /* Save the registry key for this driver */
2088 DriverData.ServiceKey.Length = RegistryPath->Length;
2089 DriverData.ServiceKey.MaximumLength = RegistryPath->MaximumLength;
2090 DriverData.ServiceKey.Buffer = (PWCHAR)ExAllocatePoolWithTag(NonPagedPool,
2091 RegistryPath->MaximumLength,
2092 FM_TAG_REGISTRY_DATA);
2093 if (!DriverData.ServiceKey.Buffer) return STATUS_INSUFFICIENT_RESOURCES;
2094 RtlCopyUnicodeString(&DriverData.ServiceKey, RegistryPath);
2095
2096 /* Do some initialization */
2097 ExInitializeFastMutex(&DriverData.FilterAttachLock);
2098
2099 /* Create the main filter manager device object */
2100 Status = IoCreateDevice(DriverObject,
2101 0,
2102 &DeviceName,
2103 FILE_DEVICE_DISK_FILE_SYSTEM,
2104 FILE_DEVICE_SECURE_OPEN,
2105 FALSE,
2106 &DeviceObject);
2107 if (!NT_SUCCESS(Status))
2108 {
2109 DPRINT1("fltmgr IoCreateDevice failed. Status = %X\n", Status);
2110 goto Cleanup;
2111 }
2112
2113 /* Store a global reference so we can access from callbacks */
2114 DriverData.DeviceObject = DeviceObject;
2115
2116 /* Generate the symbolic link name */
2117 RtlInitUnicodeString(&SymLink, L"\\??\\"DRIVER_NAME);
2118 Status = IoCreateSymbolicLink(&SymLink, &DeviceName);
2119 if (!NT_SUCCESS(Status)) goto Cleanup;
2120
2121 /* Create the callbacks for the dispatch table, FastIo and FS callbacks */
2122 Status = SetupDispatchAndCallbacksTables(DriverObject);
2123 if (!NT_SUCCESS(Status)) goto Cleanup;
2124
2125 /* Initialize the comms objects */
2126 Status = FltpSetupCommunicationObjects(DriverObject);
2127 if (!NT_SUCCESS(Status)) goto Cleanup;
2128
2129 /* Register for notifications when a new file system is loaded. This also enumerates any existing file systems */
2130 Status = IoRegisterFsRegistrationChange(DriverObject, FltpFsNotification);
2131 FLT_ASSERT(Status != STATUS_DEVICE_ALREADY_ATTACHED); // Windows checks for this, I'm not sure how it can happen. Needs investigation??
2132 if (!NT_SUCCESS(Status)) goto Cleanup;
2133
2134 InitializeListHead(&FilterList);
2135 ExInitializeResourceLite(&FilterListLock);
2136
2137 /* IoRegisterFsRegistrationChange isn't notified about the raw file systems, so we attach to them manually */
2138 RtlInitUnicodeString(&ObjectName, L"\\Device\\RawDisk");
2139 Status = IoGetDeviceObjectPointer(&ObjectName,
2140 FILE_READ_ATTRIBUTES,
2141 &RawFileObject,
2142 &RawDeviceObject);
2143 if (NT_SUCCESS(Status))
2144 {
2145 FltpFsNotification(RawDeviceObject, TRUE);
2146 ObDereferenceObject(RawFileObject);
2147 }
2148
2149 RtlInitUnicodeString(&ObjectName, L"\\Device\\RawCdRom");
2150 Status = IoGetDeviceObjectPointer(&ObjectName,
2151 FILE_READ_ATTRIBUTES,
2152 &RawFileObject,
2153 &RawDeviceObject);
2154 if (NT_SUCCESS(Status))
2155 {
2156 FltpFsNotification(RawDeviceObject, TRUE);
2157 ObDereferenceObject(RawFileObject);
2158 }
2159
2160 /* We're done, clear the initializing flag */
2161 ClearFlag(DeviceObject->Flags, DO_DEVICE_INITIALIZING);
2162 Status = STATUS_SUCCESS;
2163
2164 Cleanup:
2165
2166 if (!NT_SUCCESS(Status))
2167 {
2168 if (DriverData.FastIoDispatch)
2169 {
2170 DriverObject->FastIoDispatch = NULL;
2171 ExFreePoolWithTag(DriverData.FastIoDispatch, FM_TAG_DISPATCH_TABLE);
2172 }
2173
2174 IoDeleteSymbolicLink(&SymLink);
2175
2176 if (DeviceObject)
2177 IoDeleteDevice(DeviceObject);
2178
2179 if (DriverData.ServiceKey.Buffer)
2180 ExFreePoolWithTag(DriverData.ServiceKey.Buffer, FM_TAG_REGISTRY_DATA);
2181 }
2182
2183 return Status;
2184 }
2185
2186
2187 static
2188 NTSTATUS
2189 SetupDispatchAndCallbacksTables(_In_ PDRIVER_OBJECT DriverObject)
2190 {
2191 PFAST_IO_DISPATCH FastIoDispatch;
2192 FS_FILTER_CALLBACKS Callbacks;
2193 ULONG i;
2194
2195 /* Plug all the IRPs */
2196 for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
2197 {
2198 DriverObject->MajorFunction[i] = FltpDispatch;
2199 }
2200
2201 /* Override the ones we're interested in */
2202 DriverObject->MajorFunction[IRP_MJ_CREATE] = FltpCreate;
2203 DriverObject->MajorFunction[IRP_MJ_CREATE_NAMED_PIPE] = FltpCreate;
2204 DriverObject->MajorFunction[IRP_MJ_CREATE_MAILSLOT] = FltpCreate;
2205 DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = FltpFsControl;
2206 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = FltpDeviceControl;
2207
2208 /* The FastIo dispatch table is stored in the pool along with a tag */
2209 FastIoDispatch = ExAllocatePoolWithTag(NonPagedPool, sizeof(FAST_IO_DISPATCH), FM_TAG_DISPATCH_TABLE);
2210 if (FastIoDispatch == NULL) return STATUS_INSUFFICIENT_RESOURCES;
2211
2212 /* Fill out the FastIo table */
2213 RtlZeroMemory(FastIoDispatch, sizeof(FAST_IO_DISPATCH));
2214 FastIoDispatch->SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
2215 FastIoDispatch->FastIoCheckIfPossible = FltpFastIoCheckIfPossible;
2216 FastIoDispatch->FastIoRead = FltpFastIoRead;
2217 FastIoDispatch->FastIoWrite = FltpFastIoWrite;
2218 FastIoDispatch->FastIoQueryBasicInfo = FltpFastIoQueryBasicInfo;
2219 FastIoDispatch->FastIoQueryStandardInfo = FltpFastIoQueryStandardInfo;
2220 FastIoDispatch->FastIoLock = FltpFastIoLock;
2221 FastIoDispatch->FastIoUnlockSingle = FltpFastIoUnlockSingle;
2222 FastIoDispatch->FastIoUnlockAll = FltpFastIoUnlockAll;
2223 FastIoDispatch->FastIoUnlockAllByKey = FltpFastIoUnlockAllByKey;
2224 FastIoDispatch->FastIoDeviceControl = FltpFastIoDeviceControl;
2225 FastIoDispatch->FastIoDetachDevice = FltpFastIoDetachDevice;
2226 FastIoDispatch->FastIoQueryNetworkOpenInfo = FltpFastIoQueryNetworkOpenInfo;
2227 FastIoDispatch->MdlRead = FltpFastIoMdlRead;
2228 FastIoDispatch->MdlReadComplete = FltpFastIoMdlReadComplete;
2229 FastIoDispatch->PrepareMdlWrite = FltpFastIoPrepareMdlWrite;
2230 FastIoDispatch->MdlWriteComplete = FltpFastIoMdlWriteComplete;
2231 FastIoDispatch->FastIoReadCompressed = FltpFastIoReadCompressed;
2232 FastIoDispatch->FastIoWriteCompressed = FltpFastIoWriteCompressed;
2233 FastIoDispatch->MdlReadCompleteCompressed = FltpFastIoMdlReadCompleteCompressed;
2234 FastIoDispatch->MdlWriteCompleteCompressed = FltpFastIoMdlWriteCompleteCompressed;
2235 FastIoDispatch->FastIoQueryOpen = FltpFastIoQueryOpen;
2236
2237 /* Store the FastIo table for internal and our access */
2238 DriverObject->FastIoDispatch = FastIoDispatch;
2239 DriverData.FastIoDispatch = FastIoDispatch;
2240
2241 /* Initialize the callback table */
2242 Callbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS);
2243 Callbacks.PreAcquireForSectionSynchronization = FltpPreFsFilterOperation;
2244 Callbacks.PostAcquireForSectionSynchronization = FltpPostFsFilterOperation;
2245 Callbacks.PreReleaseForSectionSynchronization = FltpPreFsFilterOperation;
2246 Callbacks.PostReleaseForSectionSynchronization = FltpPostFsFilterOperation;
2247 Callbacks.PreAcquireForCcFlush = FltpPreFsFilterOperation;
2248 Callbacks.PostAcquireForCcFlush = FltpPostFsFilterOperation;
2249 Callbacks.PreReleaseForCcFlush = FltpPreFsFilterOperation;
2250 Callbacks.PostReleaseForCcFlush = FltpPostFsFilterOperation;
2251 Callbacks.PreAcquireForModifiedPageWriter = FltpPreFsFilterOperation;
2252 Callbacks.PostAcquireForModifiedPageWriter = FltpPostFsFilterOperation;
2253 Callbacks.PreReleaseForModifiedPageWriter = FltpPreFsFilterOperation;
2254 Callbacks.PostReleaseForModifiedPageWriter = FltpPostFsFilterOperation;
2255
2256 /* Register our callbacks */
2257 return FsRtlRegisterFileSystemFilterCallbacks(DriverObject, &Callbacks);
2258 }