ReactOS 0.4.15-dev-8408-g466a198
Interface.c
Go to the documentation of this file.
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
34
36
38{
42
44
45/* LOCAL FUNCTIONS ****************************************/
46
47static
48VOID
50{
51 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
52
53 DeviceExtension = DeviceObject->DeviceExtension;
54 if (DeviceExtension)
55 {
56 // cleanup device extension
57 }
58}
59
60CODE_SEG("PAGE")
61static
65 _Out_ PDEVICE_OBJECT *AttachedToDeviceObject)
66{
68
69 PAGED_CODE();
70
71 /* Before attaching, copy the flags from the device we're going to attach to */
73 {
75 }
77 {
79 }
81 {
83 }
84
85 /* Attach this device to the top of the driver stack */
88 AttachedToDeviceObject);
89
90 return Status;
91}
92
93CODE_SEG("PAGE")
94static
98{
99 PDEVICE_OBJECT CurrentDeviceObject;
101
102 PAGED_CODE();
103
104 /* Initialize the return pointer */
106
107 /* Start by getting the top level device in the chain */
108 CurrentDeviceObject = IoGetAttachedDeviceReference(DeviceObject);
109
110 /* Loop while there are attached devices */
111 while (CurrentDeviceObject)
112 {
113 /* Check if this device driver matches ours */
114 if (CurrentDeviceObject->DriverObject == DriverData.DriverObject)
115 {
116 FLT_ASSERT(CurrentDeviceObject->DeviceExtension != NULL);
117
118 /* We're attached, return the device object if the caller asked for it */
120 {
121 *AttachedDeviceObject = CurrentDeviceObject;
122 }
123 else
124 {
125 /* We aren't returning the reference, so decrement the count */
126 ObDereferenceObject(CurrentDeviceObject);
127 }
128
129 return TRUE;
130 }
131
132 /* Get the next device in the chain */
133 NextDeviceObject = IoGetLowerDeviceObject(CurrentDeviceObject);
134
135 /* Decrement the count on the last device before we update the pointer */
136 ObDereferenceObject(CurrentDeviceObject);
137 CurrentDeviceObject = NextDeviceObject;
138 }
139
140 return FALSE;
141}
142
143CODE_SEG("PAGE")
144static
147{
148 PFLTMGR_DEVICE_EXTENSION NewDeviceExtension;
149 PDEVICE_OBJECT BaseDeviceObject;
150 PDEVICE_OBJECT NewDeviceObject;
152 PDEVICE_OBJECT StorageStackDeviceObject;
154 ULONG NumDevices;
155 ULONG i;
157
158 PAGED_CODE();
159
160 /* Get the base device */
161 BaseDeviceObject = IoGetDeviceAttachmentBaseRef(DeviceObject);
162
163 /* get the number of device object linked to the base file system */
164 Status = IoEnumerateDeviceObjectList(BaseDeviceObject->DriverObject,
165 NULL,
166 0,
167 &NumDevices);
169
170 /* Add a few more slots in case the size changed between calls and allocate some memory to hold the pointers */
171 NumDevices += 4;
173 (NumDevices * sizeof(PDEVICE_OBJECT)),
176
177 /* Now get all the device objects that this base driver has created */
178 Status = IoEnumerateDeviceObjectList(BaseDeviceObject->DriverObject,
180 (NumDevices * sizeof(PDEVICE_OBJECT)),
181 &NumDevices);
182 if (!NT_SUCCESS(Status))
183 {
185 return Status;
186 }
187
188 /* Loop through all the devices looking for ones to attach to */
189 for (i = 0; i < NumDevices; i++)
190 {
192 StorageStackDeviceObject = NULL;
193 NewDeviceObject = NULL;
194
195 /* Ignore the device we passed in, and devices of the wrong type */
196 if ((DeviceList[i] == BaseDeviceObject) ||
197 (DeviceList[i]->DeviceType != BaseDeviceObject->DeviceType))
198 {
199 goto CleanupAndNext;
200 }
201
202 /* Ignore this device if we're already attached to it */
204 {
205 goto CleanupAndNext;
206 }
207
208
209 /*
210 * If the device has a name, it must be a control device.
211 * This handles drivers with more then one control device (like FastFat)
212 */
214 if (NT_SUCCESS(Status) && DeviceName.Length > 0)
215 {
216 goto CleanupAndNext;
217 }
218
219 /*
220 * Try to get the storage stack (disk) device object associated with
221 * this file system device object. Ignore the device if we don't have one
222 */
224 &StorageStackDeviceObject);
225 if (!NT_SUCCESS(Status))
226 {
227 goto CleanupAndNext;
228 }
229
230
231 /*
232 * TODO: Don't attach to shadow copy volumes,
233 * ros doesn't have any so it's not an issues yet
234 */
235
236 /*
237 * We're far enough to be ready to attach, create a device
238 * object which we'll use to do so
239 */
242 NULL,
244 0,
245 FALSE,
246 &NewDeviceObject);
247 if (!NT_SUCCESS(Status))
248 {
249 goto CleanupAndNext;
250 }
251
252 /* Get the device extension for this new object and store our disk object there */
253 NewDeviceExtension = NewDeviceObject->DeviceExtension;
254 NewDeviceExtension->StorageStackDeviceObject = StorageStackDeviceObject;
255
256 /* Lookup and store the device name for the storage stack */
257 RtlInitEmptyUnicodeString(&NewDeviceExtension->DeviceName,
258 NewDeviceExtension->DeviceNameBuffer,
259 sizeof(NewDeviceExtension->DeviceNameBuffer));
260 FltpGetObjectName(StorageStackDeviceObject,
261 &NewDeviceExtension->DeviceName);
262
263
264 /* Grab the attach lock before we attempt to attach */
266
267 /* Check again that we aren't already attached. It may have changed since our last check */
269 {
270 FLT_ASSERT(NewDeviceObject->DriverObject == DriverData.DriverObject);
271
272 /* Finally, attach to the volume */
274 NewDeviceObject,
275 &NewDeviceExtension->AttachedToDeviceObject);
276 if (NT_SUCCESS(Status))
277 {
278 /* Clean the initializing flag so other filters can attach to our device object */
279 ClearFlag(NewDeviceObject->Flags, DO_DEVICE_INITIALIZING);
280 }
281 }
282 else
283 {
284 /* We're already attached. Just cleanup */
286 }
287
289
290CleanupAndNext:
291
292 if (!NT_SUCCESS(Status))
293 {
294 if (NewDeviceObject)
295 {
296 FltpCleanupDeviceObject(NewDeviceObject);
297 IoDeleteDevice(NewDeviceObject);
298 }
299 }
300
301 if (StorageStackDeviceObject)
302 {
303 /* A ref was added for us when we attached, so we can deref ours now */
304 ObDereferenceObject(StorageStackDeviceObject);
305 }
306
307 /* Remove the ref which was added by IoEnumerateDeviceObjectList */
309
310 /* Free the buffer that FltpGetBaseDeviceObjectName added */
312
313 }
314
315 /* Free the memory we allocated for the list */
317
318 return STATUS_SUCCESS;
319}
320
321CODE_SEG("PAGE")
322static
326{
327 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
328 PDEVICE_OBJECT NewDeviceObject;
330 UNICODE_STRING FileSystemDeviceName;
331 UNICODE_STRING FsRecDeviceName;
333
334 PAGED_CODE();
335
336 /* Only handle device types we're interested in */
337 if (DeviceObject->DeviceType != FILE_DEVICE_DISK_FILE_SYSTEM &&
340 {
341 return STATUS_SUCCESS;
342 }
343
344 /* Setup the buffer to hold the device name */
345 RtlInitEmptyUnicodeString(&FileSystemDeviceName,
346 Buffer,
347 MAX_DEVNAME_LENGTH * sizeof(WCHAR));
348
349 /* Get the the name of the file system device */
350 Status = FltpGetObjectName(DeviceObject->DriverObject, &FileSystemDeviceName);
351 if (!NT_SUCCESS(Status)) return Status;
352
353 DPRINT("Found device %wZ, checking if we need to attach...\n", &FileSystemDeviceName);
354
355 /* Build up the name of the file system recognizer device */
356 RtlInitUnicodeString(&FsRecDeviceName, L"\\FileSystem\\Fs_Rec");
357
358 /* We don't attach to recognizer devices, so bail if this is one */
359 if (RtlCompareUnicodeString(&FileSystemDeviceName, &FsRecDeviceName, TRUE) == 0)
360 {
361 return STATUS_SUCCESS;
362 }
363
364 /* Create a device object which we can attach to this file system */
367 NULL,
368 DeviceObject->DeviceType,
369 0,
370 FALSE,
371 &NewDeviceObject);
372 if (!NT_SUCCESS(Status))
373 {
374 DPRINT1("Failed to create a DO for attaching to a FS : 0x%X\n", Status);
375 return Status;
376 }
377
378 /* Cast the device extension to something we understand */
379 DeviceExtension = NewDeviceObject->DeviceExtension;
380
381 /* Attach this device to the top of the driver stack and store the DO we attached to in the DE */
382 Status = FltpAttachDeviceObject(NewDeviceObject,
384 &DeviceExtension->AttachedToDeviceObject);
385 if (NT_SUCCESS(Status))
386 {
387 DPRINT("Attached to %wZ\n", &FileSystemDeviceName);
388 }
389 else
390 {
391 DPRINT1("Failed to attach to the driver stack : 0x%X\n", Status);
392 goto Cleanup;
393 }
394
395 /* Setup the unicode string buffer and copy the device name to the device extension */
396 RtlInitEmptyUnicodeString(&DeviceExtension->DeviceName,
397 DeviceExtension->DeviceNameBuffer,
398 MAX_DEVNAME_LENGTH * sizeof(WCHAR));
399 RtlCopyUnicodeString(&DeviceExtension->DeviceName, DeviceName);
400
401 /* We're done, remove the initializing flag */
402 ClearFlag(NewDeviceObject->Flags, DO_DEVICE_INITIALIZING);
403
404 /* Look for existing mounted devices for this file system */
406 if (!NT_SUCCESS(Status))
407 {
408 DPRINT1("Failed to enumerate file system volumes for this file system : 0x%X\n", Status);
409 IoDetachDevice(DeviceExtension->AttachedToDeviceObject);
410 }
411
412Cleanup:
413
414 if (!NT_SUCCESS(Status))
415 {
416 IoDeleteDevice(NewDeviceObject);
417 }
418
419 return Status;
420}
421
422CODE_SEG("PAGE")
423static
426{
427 PDEVICE_OBJECT AttachedDevice, NextDevice;
428 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
430
431 PAGED_CODE();
432
433 /* Get the top device in the chain and increment the ref count on it */
435
436 /* Loop all attached devices looking for our file system driver */
437 while (AttachedDevice->DriverObject != DriverData.DriverObject)
438 {
439 FLT_ASSERT(AttachedDevice != NULL);
440
441 /* Get the next lower device object. This adds a ref on NextDevice */
442 NextDevice = IoGetLowerDeviceObject(AttachedDevice);
443
444 /* Remove the reference we added */
445 Count = ObDereferenceObject(AttachedDevice);
446
447 /* Bail if this is the last one */
448 if (NextDevice == NULL) return Count;
449
450 /* Try the next one */
451 AttachedDevice = NextDevice;
452 }
453
454
455 DeviceExtension = AttachedDevice->DeviceExtension;
456 if (DeviceExtension)
457 {
458 //
459 // FIXME: Put any device extension cleanup code here
460 //
461 }
462
463 /* Detach the device from the chain and delete the object */
465 IoDeleteDevice(AttachedDevice);
466
467 /* Remove the reference we added so the delete can complete */
468 return ObDereferenceObject(AttachedDevice);
469}
470
471
472/* DISPATCH ROUTINES **********************************************/
473
475NTAPI
478{
481 __debugbreak();
482 return STATUS_SUCCESS;
483}
484
485VOID
486NTAPI
490{
494 __debugbreak();
495}
496
498NTAPI
501{
502 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
503 PIO_STACK_LOCATION StackPtr;
505
506 DeviceExtension = DeviceObject->DeviceExtension;
507
508 /* Check if this is a request for us */
510 {
512 FLT_ASSERT(DeviceExtension == NULL);
513
514 /* Hand it off to our internal handler */
516 if (Status != STATUS_REPARSE)
517 {
518 Irp->IoStatus.Status = Status;
519 Irp->IoStatus.Information = 0;
521 }
522 return Status;
523 }
524
525 /* Check if this is a request for a the messaging device */
527 {
528 /* Hand off to our internal routine */
530 }
531
532 FLT_ASSERT(DeviceExtension &&
533 DeviceExtension->AttachedToDeviceObject);
534
536 if (StackPtr->MajorFunction == IRP_MJ_SHUTDOWN)
537 {
538 // handle shutdown request
539 }
540
541 DPRINT1("Received %X from %wZ\n", StackPtr->MajorFunction, &DeviceExtension->DeviceName);
542
543 /* Just pass the IRP down the stack */
545 return IoCallDriver(DeviceExtension->AttachedToDeviceObject, Irp);
546}
547
548CODE_SEG("PAGE")
550NTAPI
553{
554 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
555
556 PAGED_CODE();
557
558 DeviceExtension = DeviceObject->DeviceExtension;
559
560 /* Check if this is a request for us */
562 {
564 FLT_ASSERT(DeviceExtension == NULL);
565
566 /* Someone wants a handle to the fltmgr, allow it */
567 Irp->IoStatus.Status = STATUS_SUCCESS;
568 Irp->IoStatus.Information = 0;
570 return STATUS_SUCCESS;
571 }
572
573 /* Check if this is a request for a the new comms connection */
575 {
576 /* Hand off to our internal routine */
578 }
579
580 FLT_ASSERT(DeviceExtension &&
581 DeviceExtension->AttachedToDeviceObject);
582
583 DPRINT1("Received create from %wZ (%lu)\n", &DeviceExtension->DeviceName, PsGetCurrentProcessId());
584
585 /* Just pass the IRP down the stack */
587 return IoCallDriver(DeviceExtension->AttachedToDeviceObject, Irp);
588}
589
590CODE_SEG("PAGE")
592NTAPI
595{
596 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
597
598 PAGED_CODE();
599
600 /* Check if this is a request for us */
602 {
603 /* We don't handle this request */
604 Irp->IoStatus.Information = 0;
605 Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
608 }
609
610 DeviceExtension = DeviceObject->DeviceExtension;
611
612 FLT_ASSERT(DeviceExtension &&
613 DeviceExtension->AttachedToDeviceObject);
614
615 /* Just pass the IRP down the stack */
617 return IoCallDriver(DeviceExtension->AttachedToDeviceObject, Irp);
618}
619
621NTAPI
624{
625 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
627
628 /* Check if the request was meant for us */
630 {
632 if (Status != STATUS_REPARSE)
633 {
634 Irp->IoStatus.Status = Status;
635 Irp->IoStatus.Information = 0;
637 }
638
639 return Status;
640 }
641
642 DeviceExtension = DeviceObject->DeviceExtension;
643
644 FLT_ASSERT(DeviceExtension &&
645 DeviceExtension->AttachedToDeviceObject);
646
647 /* Just pass the IRP down the stack */
649 return IoCallDriver(DeviceExtension->AttachedToDeviceObject, Irp);
650}
651
652
653
654/* FASTIO ROUTINES ************************************************/
655
656CODE_SEG("PAGE")
658NTAPI
667
668{
669 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
672
673 PAGED_CODE();
674
675 /* If it doesn't have a device extension, then it's not our device object */
676 if (DeviceObject->DeviceExtension == NULL)
677 {
678 /* Fail the call */
680 IoStatus->Information = 0;
681 return TRUE;
682 }
683
684 DeviceExtension = DeviceObject->DeviceExtension;
685 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
686
687 /* Get the device that we attached to */
689 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
690
691 /* Make sure our FastIo table is valid */
693 {
694 /* Forward the call onto the device we attached to */
697 Length,
698 Wait,
699 LockKey,
701 IoStatus,
703 }
704
705 /* We failed to handle the request, send it down the slow path */
707 return FALSE;
708}
709
710CODE_SEG("PAGE")
712NTAPI
721{
722 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
725
726 PAGED_CODE();
727
728 /* If it doesn't have a device extension, then it's not our device object */
729 if (DeviceObject->DeviceExtension == NULL)
730 {
731 /* Fail the call */
733 IoStatus->Information = 0;
734 return TRUE;
735 }
736
737 DeviceExtension = DeviceObject->DeviceExtension;
738 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
739
740 /* Get the device that we attached to */
742 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
743
744 /* Make sure our FastIo table is valid */
746 {
747 /* Forward the call onto the device we attached to */
750 Length,
751 Wait,
752 LockKey,
753 Buffer,
754 IoStatus,
756 }
757
758 /* We failed to handle the request, send it down the slow path */
760 return FALSE;
761}
762
763CODE_SEG("PAGE")
765NTAPI
774{
775 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
778
779 PAGED_CODE();
780
781 /* If it doesn't have a device extension, then it's not our device object */
782 if (DeviceObject->DeviceExtension == NULL)
783 {
784 /* Fail the call */
786 IoStatus->Information = 0;
787 return TRUE;
788 }
789
790 DeviceExtension = DeviceObject->DeviceExtension;
791 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
792
793 /* Get the device that we attached to */
795 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
796
797 /* Make sure our FastIo table is valid */
799 {
800 /* Forward the call onto the device we attached to */
803 Length,
804 Wait,
805 LockKey,
806 Buffer,
807 IoStatus,
809 }
810
811 /* We failed to handle the request, send it down the slow path */
813 return FALSE;
814}
815
816CODE_SEG("PAGE")
818NTAPI
824{
825 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
828
829 PAGED_CODE();
830
831 /* If it doesn't have a device extension, then it's not our device object */
832 if (DeviceObject->DeviceExtension == NULL)
833 {
834 /* Fail the call */
836 IoStatus->Information = 0;
837 return TRUE;
838 }
839
840 DeviceExtension = DeviceObject->DeviceExtension;
841 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
842
843 /* Get the device that we attached to */
845 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
846
847 /* Make sure our FastIo table is valid */
849 {
850 /* Forward the call onto the device we attached to */
852 Wait,
853 Buffer,
854 IoStatus,
856 }
857
858 /* We failed to handle the request, send it down the slow path */
860 return FALSE;
861}
862
863CODE_SEG("PAGE")
865NTAPI
871{
872 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
875
876 PAGED_CODE();
877
878 /* If it doesn't have a device extension, then it's not our device object */
879 if (DeviceObject->DeviceExtension == NULL)
880 {
881 /* Fail the call */
883 IoStatus->Information = 0;
884 return TRUE;
885 }
886
887 DeviceExtension = DeviceObject->DeviceExtension;
888 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
889
890 /* Get the device that we attached to */
892 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
893
894 /* Make sure our FastIo table is valid */
896 {
897 /* Forward the call onto the device we attached to */
899 Wait,
900 Buffer,
901 IoStatus,
903 }
904
905 /* We failed to handle the request, send it down the slow path */
907 return FALSE;
908}
909
910CODE_SEG("PAGE")
912NTAPI
917 _In_ ULONG Key,
922{
923 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
926
927 PAGED_CODE();
928
929 /* If it doesn't have a device extension, then it's not our device object */
930 if (DeviceObject->DeviceExtension == NULL)
931 {
932 /* Fail the call */
934 IoStatus->Information = 0;
935 return TRUE;
936 }
937
938 DeviceExtension = DeviceObject->DeviceExtension;
939 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
940
941 /* Get the device that we attached to */
943 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
944
945 /* Make sure our FastIo table is valid */
947 {
948 /* Forward the call onto the device we attached to */
951 Length,
952 ProcessId,
953 Key,
956 IoStatus,
958 }
959
960 /* We failed to handle the request, send it down the slow path */
962 return FALSE;
963}
964
965CODE_SEG("PAGE")
967NTAPI
972 _In_ ULONG Key,
975{
976 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
979
980 PAGED_CODE();
981
982 /* If it doesn't have a device extension, then it's not our device object */
983 if (DeviceObject->DeviceExtension == NULL)
984 {
985 /* Fail the call */
987 IoStatus->Information = 0;
988 return TRUE;
989 }
990
991 DeviceExtension = DeviceObject->DeviceExtension;
992 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
993
994 /* Get the device that we attached to */
996 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
997
998 /* Make sure our FastIo table is valid */
1000 {
1001 /* Forward the call onto the device we attached to */
1003 FileOffset,
1004 Length,
1005 ProcessId,
1006 Key,
1007 IoStatus,
1009 }
1010
1011 /* We failed to handle the request, send it down the slow path */
1013 return FALSE;
1014}
1015
1016CODE_SEG("PAGE")
1017BOOLEAN
1018NTAPI
1023
1024{
1025 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1028
1029 PAGED_CODE();
1030
1031 /* If it doesn't have a device extension, then it's not our device object */
1032 if (DeviceObject->DeviceExtension == NULL)
1033 {
1034 /* Fail the call */
1036 IoStatus->Information = 0;
1037 return TRUE;
1038 }
1039
1040 DeviceExtension = DeviceObject->DeviceExtension;
1041 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1042
1043 /* Get the device that we attached to */
1045 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1046
1047 /* Make sure our FastIo table is valid */
1049 {
1050 /* Forward the call onto the device we attached to */
1052 ProcessId,
1053 IoStatus,
1055 }
1056
1057 /* We failed to handle the request, send it down the slow path */
1059 return FALSE;
1060}
1061
1062CODE_SEG("PAGE")
1063BOOLEAN
1064NTAPI
1067 _In_ ULONG Key,
1070{
1071 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1074
1075 PAGED_CODE();
1076
1077 /* If it doesn't have a device extension, then it's not our device object */
1078 if (DeviceObject->DeviceExtension == NULL)
1079 {
1080 /* Fail the call */
1082 IoStatus->Information = 0;
1083 return TRUE;
1084 }
1085
1086 DeviceExtension = DeviceObject->DeviceExtension;
1087 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1088
1089 /* Get the device that we attached to */
1091 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1092
1093 /* Make sure our FastIo table is valid */
1095 {
1096 /* Forward the call onto the device we attached to */
1098 ProcessId,
1099 Key,
1100 IoStatus,
1102 }
1103
1104 /* We failed to handle the request, send it down the slow path */
1106 return FALSE;
1107}
1108
1109CODE_SEG("PAGE")
1110BOOLEAN
1111NTAPI
1121{
1122 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1125
1126 PAGED_CODE();
1127
1128 /* If it doesn't have a device extension, then it's not our device object */
1129 if (DeviceObject->DeviceExtension == NULL)
1130 {
1131 /* Fail the request, send it down the slow path */
1132 return FALSE;
1133 }
1134
1135 DeviceExtension = DeviceObject->DeviceExtension;
1136 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1137
1138 /* Get the device that we attached to */
1140 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1141
1142 /* Make sure our FastIo table is valid */
1144 {
1145 /* Forward the call onto the device we attached to */
1147 Wait,
1153 IoStatus,
1155 }
1156
1157 /* We failed to handle the request, send it down the slow path */
1159 return FALSE;
1160}
1161
1162VOID
1163NTAPI
1165{
1166 PDETACH_DEVICE_WORK_ITEM DetachDeviceWorkItem = Parameter;
1167
1168 /* Run any cleanup routines */
1169 FltpCleanupDeviceObject(DetachDeviceWorkItem->SourceDevice);
1170
1171 /* Detach from the target device */
1172 IoDetachDevice(DetachDeviceWorkItem->TargetDevice);
1173
1174 /* Delete the source */
1175 IoDeleteDevice(DetachDeviceWorkItem->SourceDevice);
1176
1177 /* Free the pool we allocated in FltpFastIoDetachDevice */
1178 ExFreePoolWithTag(DetachDeviceWorkItem, 0x1234);
1179}
1180
1181CODE_SEG("PAGE")
1182VOID
1183NTAPI
1186{
1187 PDETACH_DEVICE_WORK_ITEM DetachDeviceWorkItem;
1188
1189 PAGED_CODE();
1190
1191 /*
1192 * Detaching and deleting devices is a lot of work and takes too long
1193 * to be a worthwhile FastIo candidate, so we defer this call to speed
1194 * it up. There's no return value so we're okay to do this.
1195 */
1196
1197 /* Allocate the work item and it's corresponding data */
1198 DetachDeviceWorkItem = ExAllocatePoolWithTag(NonPagedPool,
1200 0x1234);
1201 if (DetachDeviceWorkItem)
1202 {
1203 /* Initialize the work item */
1204 ExInitializeWorkItem(&DetachDeviceWorkItem->WorkItem,
1206 DetachDeviceWorkItem);
1207
1208 /* Queue the work item and return the call */
1209 ExQueueWorkItem(&DetachDeviceWorkItem->WorkItem,
1211 }
1212 else
1213 {
1214 /* We failed to defer, just cleanup here */
1218 }
1219
1220}
1221
1222CODE_SEG("PAGE")
1223BOOLEAN
1224NTAPI
1230{
1231 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1234
1235 PAGED_CODE();
1236
1237 /* If it doesn't have a device extension, then it's not our device object */
1238 if (DeviceObject->DeviceExtension == NULL)
1239 {
1240 /* Fail the call */
1242 IoStatus->Information = 0;
1243 return TRUE;
1244 }
1245
1246 DeviceExtension = DeviceObject->DeviceExtension;
1247 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1248
1249 /* Get the device that we attached to */
1251 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1252
1253 /* Make sure our FastIo table is valid */
1255 {
1256 /* Forward the call onto the device we attached to */
1258 Wait,
1259 Buffer,
1260 IoStatus,
1262 }
1263
1264 /* We failed to handle the request, send it down the slow path */
1266 return FALSE;
1267}
1268
1269CODE_SEG("PAGE")
1270BOOLEAN
1271NTAPI
1279{
1280 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1283
1284 PAGED_CODE();
1285
1286 /* If it doesn't have a device extension, then it's not our device object */
1287 if (DeviceObject->DeviceExtension == NULL)
1288 {
1289 /* Fail the call */
1291 IoStatus->Information = 0;
1292 return TRUE;
1293 }
1294
1295 DeviceExtension = DeviceObject->DeviceExtension;
1296 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1297
1298 /* Get the device that we attached to */
1300 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1301
1302 /* Make sure our FastIo table is valid */
1304 {
1305 /* Forward the call onto the device we attached to */
1307 FileOffset,
1308 Length,
1309 LockKey,
1310 MdlChain,
1311 IoStatus,
1313 }
1314
1315 /* We failed to handle the request, send it down the slow path */
1317 return FALSE;
1318}
1319
1320CODE_SEG("PAGE")
1321BOOLEAN
1322NTAPI
1326
1327{
1328 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1331
1332 PAGED_CODE();
1333
1334 /* If it doesn't have a device extension, then it's not our device object */
1335 if (DeviceObject->DeviceExtension == NULL)
1336 {
1337 /* Fail the request, send it down the slow path */
1338 return FALSE;
1339 }
1340
1341 DeviceExtension = DeviceObject->DeviceExtension;
1342 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1343
1344 /* Get the device that we attached to */
1346 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1347
1348 /* Make sure our FastIo table is valid */
1350 {
1351 /* Forward the call onto the device we attached to */
1353 MdlChain,
1355 }
1356
1357 /* We failed to handle the request, send it down the slow path */
1359 return FALSE;
1360}
1361
1362CODE_SEG("PAGE")
1363BOOLEAN
1364NTAPI
1372{
1373 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1376
1377 PAGED_CODE();
1378
1379 /* If it doesn't have a device extension, then it's not our device object */
1380 if (DeviceObject->DeviceExtension == NULL)
1381 {
1382 /* Fail the call */
1384 IoStatus->Information = 0;
1385 return TRUE;
1386 }
1387
1388 DeviceExtension = DeviceObject->DeviceExtension;
1389 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1390
1391 /* Get the device that we attached to */
1393 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1394
1395 /* Make sure our FastIo table is valid */
1397 {
1398 /* Forward the call onto the device we attached to */
1400 FileOffset,
1401 Length,
1402 LockKey,
1403 MdlChain,
1404 IoStatus,
1406 }
1407
1408 /* We failed to handle the request, send it down the slow path */
1410 return FALSE;
1411}
1412
1413CODE_SEG("PAGE")
1414BOOLEAN
1415NTAPI
1420{
1421 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1424
1425 PAGED_CODE();
1426
1427 /* If it doesn't have a device extension, then it's not our device object */
1428 if (DeviceObject->DeviceExtension == NULL)
1429 {
1430 /* Fail the request, send it down the slow path */
1431 return FALSE;
1432 }
1433
1434 DeviceExtension = DeviceObject->DeviceExtension;
1435 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1436
1437 /* Get the device that we attached to */
1439 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1440
1441 /* Make sure our FastIo table is valid */
1443 {
1444 /* Forward the call onto the device we attached to */
1446 FileOffset,
1447 MdlChain,
1449 }
1450
1451 /* We failed to handle the request, send it down the slow path */
1453 return FALSE;
1454}
1455
1456CODE_SEG("PAGE")
1457BOOLEAN
1458NTAPI
1469{
1470 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1473
1474 PAGED_CODE();
1475
1476 /* If it doesn't have a device extension, then it's not our device object */
1477 if (DeviceObject->DeviceExtension == NULL)
1478 {
1479 /* Fail the request, send it down the slow path */
1480 return FALSE;
1481 }
1482
1483 DeviceExtension = DeviceObject->DeviceExtension;
1484 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1485
1486 /* Get the device that we attached to */
1488 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1489
1490 /* Make sure our FastIo table is valid */
1492 {
1493 /* Forward the call onto the device we attached to */
1495 FileOffset,
1496 Length,
1497 LockKey,
1498 Buffer,
1499 MdlChain,
1500 IoStatus,
1504 }
1505
1506 /* We failed to handle the request, send it down the slow path */
1508 return FALSE;
1509}
1510
1511CODE_SEG("PAGE")
1512BOOLEAN
1513NTAPI
1524{
1525 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1528
1529 PAGED_CODE();
1530
1531 /* If it doesn't have a device extension, then it's not our device object */
1532 if (DeviceObject->DeviceExtension == NULL)
1533 {
1534 /* Fail the request, send it down the slow path */
1535 return FALSE;
1536 }
1537
1538 DeviceExtension = DeviceObject->DeviceExtension;
1539 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1540
1541 /* Get the device that we attached to */
1543 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1544
1545 /* Make sure our FastIo table is valid */
1547 {
1548 /* Forward the call onto the device we attached to */
1550 FileOffset,
1551 Length,
1552 LockKey,
1553 Buffer,
1554 MdlChain,
1555 IoStatus,
1559 }
1560
1561 /* We failed to handle the request, send it down the slow path */
1563 return FALSE;
1564}
1565
1566CODE_SEG("PAGE")
1567BOOLEAN
1568NTAPI
1572{
1573 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1576
1577 PAGED_CODE();
1578
1579 /* If it doesn't have a device extension, then it's not our device object */
1580 if (DeviceObject->DeviceExtension == NULL)
1581 {
1582 return FALSE;
1583 }
1584
1585 DeviceExtension = DeviceObject->DeviceExtension;
1586 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1587
1588 /* Get the device that we attached to */
1590 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1591
1592 /* Make sure our FastIo table is valid */
1594 {
1595 /* Forward the call onto the device we attached to */
1597 MdlChain,
1599 }
1600
1601 /* We failed to handle the request, send it down the slow path */
1603 return FALSE;
1604}
1605
1606CODE_SEG("PAGE")
1607BOOLEAN
1608NTAPI
1613{
1614 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1617
1618 PAGED_CODE();
1619
1620 /* If it doesn't have a device extension, then it's not our device object */
1621 if (DeviceObject->DeviceExtension == NULL)
1622 {
1623 return FALSE;
1624 }
1625
1626 DeviceExtension = DeviceObject->DeviceExtension;
1627 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1628
1629 /* Get the device that we attached to */
1631 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1632
1633 /* Make sure our FastIo table is valid */
1635 {
1636 /* Forward the call onto the device we attached to */
1638 FileOffset,
1639 MdlChain,
1641 }
1642
1643 /* We failed to handle the request, send it down the slow path */
1645 return FALSE;
1646}
1647
1648CODE_SEG("PAGE")
1649BOOLEAN
1650NTAPI
1654{
1655 PFLTMGR_DEVICE_EXTENSION DeviceExtension;
1659
1660 PAGED_CODE();
1661
1662 /* If it doesn't have a device extension, then it's not our device object */
1663 if (DeviceObject->DeviceExtension == NULL)
1664 {
1665 return FALSE;
1666 }
1667
1668 DeviceExtension = DeviceObject->DeviceExtension;
1669 FLT_ASSERT(DeviceExtension->AttachedToDeviceObject);
1670
1671 /* Get the device that we attached to */
1673 FastIoDispatch = AttachedDeviceObject->DriverObject->FastIoDispatch;
1674
1675 /* Make sure our FastIo table is valid */
1677 {
1679
1680 /* Update the stack to contain the correct device for the next filter */
1682
1683 /* Now forward the call */
1687
1688 /* Restore the DeviceObject as we found it */
1689 StackPtr->DeviceObject = DeviceObject;
1690 return Success;
1691 }
1692
1693 /* We failed to handle the request, send it down the slow path */
1695 return FALSE;
1696}
1697
1698CODE_SEG("PAGE")
1699DRIVER_FS_NOTIFICATION FltpFsNotification;
1700
1701CODE_SEG("PAGE")
1702VOID
1703NTAPI
1706{
1709
1710 PAGED_CODE();
1711
1712 /* Set an empty string */
1714
1715 /* Get the name of the lowest device object on the stack */
1717 if (NT_SUCCESS(Status))
1718 {
1719 /* Check if it's attaching or detaching */
1720 if (FsActive)
1721 {
1722 /* Run the attach routine */
1724 }
1725 else
1726 {
1727 /* Run the detach routine */
1729 }
1730
1731 /* Free the buffer which FltpGetBaseDeviceObjectName allocated */
1733 }
1734}
1735
1736static
1737CODE_SEG("INIT")
1740{
1743 ULONG i;
1744
1745 /* Plug all the IRPs */
1746 for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
1747 {
1748 DriverObject->MajorFunction[i] = FltpDispatch;
1749 }
1750
1751 /* Override the ones we're interested in */
1752 DriverObject->MajorFunction[IRP_MJ_CREATE] = FltpCreate;
1757
1758 /* The FastIo dispatch table is stored in the pool along with a tag */
1761
1762 /* Fill out the FastIo table */
1786
1787 /* Store the FastIo table for internal and our access */
1788 DriverObject->FastIoDispatch = FastIoDispatch;
1790
1791 /* Initialize the callback table */
1792 Callbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS);
1793 Callbacks.PreAcquireForSectionSynchronization = FltpPreFsFilterOperation;
1794 Callbacks.PostAcquireForSectionSynchronization = FltpPostFsFilterOperation;
1795 Callbacks.PreReleaseForSectionSynchronization = FltpPreFsFilterOperation;
1796 Callbacks.PostReleaseForSectionSynchronization = FltpPostFsFilterOperation;
1797 Callbacks.PreAcquireForCcFlush = FltpPreFsFilterOperation;
1798 Callbacks.PostAcquireForCcFlush = FltpPostFsFilterOperation;
1799 Callbacks.PreReleaseForCcFlush = FltpPreFsFilterOperation;
1800 Callbacks.PostReleaseForCcFlush = FltpPostFsFilterOperation;
1801 Callbacks.PreAcquireForModifiedPageWriter = FltpPreFsFilterOperation;
1802 Callbacks.PostAcquireForModifiedPageWriter = FltpPostFsFilterOperation;
1803 Callbacks.PreReleaseForModifiedPageWriter = FltpPreFsFilterOperation;
1804 Callbacks.PostReleaseForModifiedPageWriter = FltpPostFsFilterOperation;
1805
1806 /* Register our callbacks */
1808}
1809
1810CODE_SEG("INIT") DRIVER_INITIALIZE DriverEntry;
1811
1812CODE_SEG("INIT")
1814NTAPI
1817{
1818 UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\FileSystem\\Filters\\"DRIVER_NAME);
1819 PDEVICE_OBJECT RawDeviceObject;
1821 PFILE_OBJECT RawFileObject;
1823 UNICODE_STRING SymLink;
1824
1826
1829
1830 /* Save the registry key for this driver */
1834 RegistryPath->MaximumLength,
1838
1839 /* Do some initialization */
1841
1842 /* Create the main filter manager device object */
1844 0,
1845 &DeviceName,
1848 FALSE,
1849 &DeviceObject);
1850 if (!NT_SUCCESS(Status))
1851 {
1852 DPRINT1("fltmgr IoCreateDevice failed. Status = %X\n", Status);
1853 goto Cleanup;
1854 }
1855
1856 /* Store a global reference so we can access from callbacks */
1858
1859 /* Generate the symbolic link name */
1860 RtlInitUnicodeString(&SymLink, L"\\??\\"DRIVER_NAME);
1862 if (!NT_SUCCESS(Status)) goto Cleanup;
1863
1864 /* Create the callbacks for the dispatch table, FastIo and FS callbacks */
1866 if (!NT_SUCCESS(Status)) goto Cleanup;
1867
1868 /* Initialize the comms objects */
1870 if (!NT_SUCCESS(Status)) goto Cleanup;
1871
1872 /* Register for notifications when a new file system is loaded. This also enumerates any existing file systems */
1874 FLT_ASSERT(Status != STATUS_DEVICE_ALREADY_ATTACHED); // Windows checks for this, I'm not sure how it can happen. Needs investigation??
1875 if (!NT_SUCCESS(Status)) goto Cleanup;
1876
1879
1880 /* IoRegisterFsRegistrationChange isn't notified about the raw file systems, so we attach to them manually */
1881 RtlInitUnicodeString(&ObjectName, L"\\Device\\RawDisk");
1884 &RawFileObject,
1885 &RawDeviceObject);
1886 if (NT_SUCCESS(Status))
1887 {
1888 FltpFsNotification(RawDeviceObject, TRUE);
1889 ObDereferenceObject(RawFileObject);
1890 }
1891
1892 RtlInitUnicodeString(&ObjectName, L"\\Device\\RawCdRom");
1895 &RawFileObject,
1896 &RawDeviceObject);
1897 if (NT_SUCCESS(Status))
1898 {
1899 FltpFsNotification(RawDeviceObject, TRUE);
1900 ObDereferenceObject(RawFileObject);
1901 }
1902
1903 /* We're done, clear the initializing flag */
1906
1907Cleanup:
1908
1909 if (!NT_SUCCESS(Status))
1910 {
1912 {
1913 DriverObject->FastIoDispatch = NULL;
1915 }
1916
1917 IoDeleteSymbolicLink(&SymLink);
1918
1919 if (DeviceObject)
1921
1924 }
1925
1926 return Status;
1927}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
#define PAGED_CODE()
#define CODE_SEG(...)
NTSTATUS FltpDispatchHandler(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
Definition: Dispatch.c:103
NTSTATUS FltpDeviceControlHandler(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
Definition: Dispatch.c:37
BOOLEAN NTAPI FltpFastIoQueryStandardInfo(_In_ PFILE_OBJECT FileObject, _In_ BOOLEAN Wait, _Out_ PFILE_STANDARD_INFORMATION Buffer, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:866
NTSTATUS NTAPI FltpPreFsFilterOperation(_In_ PFS_FILTER_CALLBACK_DATA Data, _Out_ PVOID *CompletionContext)
Definition: Interface.c:476
BOOLEAN NTAPI FltpFastIoRead(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ BOOLEAN Wait, _In_ ULONG LockKey, _Out_ PVOID Buffer, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:713
VOID NTAPI FltpPostFsFilterOperation(_In_ PFS_FILTER_CALLBACK_DATA Data, _In_ NTSTATUS OperationStatus, _In_ PVOID CompletionContext)
Definition: Interface.c:487
struct _DETACH_DEVICE_WORK_ITEM * PDETACH_DEVICE_WORK_ITEM
LIST_ENTRY FilterList
Definition: Filter.c:24
static NTSTATUS FltpAttachDeviceObject(_In_ PDEVICE_OBJECT SourceDevice, _In_ PDEVICE_OBJECT TargetDevice, _Out_ PDEVICE_OBJECT *AttachedToDeviceObject)
Definition: Interface.c:63
BOOLEAN NTAPI FltpFastIoUnlockSingle(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ PLARGE_INTEGER Length, _In_ PEPROCESS ProcessId, _In_ ULONG Key, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:968
BOOLEAN NTAPI FltpFastIoQueryOpen(_Inout_ PIRP Irp, _Out_ PFILE_NETWORK_OPEN_INFORMATION NetworkInformation, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1651
BOOLEAN NTAPI FltpFastIoWriteCompressed(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ ULONG LockKey, _In_ PVOID Buffer, _Out_ PMDL *MdlChain, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PCOMPRESSED_DATA_INFO CompressedDataInfo, _In_ ULONG CompressedDataInfoLength, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1514
VOID NTAPI FltpFastIoDetachDeviceWorker(_In_ PVOID Parameter)
Definition: Interface.c:1164
NTSTATUS NTAPI FltpDispatch(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
Definition: Interface.c:499
static LONG_PTR FltpDetachFromFileSystemDevice(_In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:425
struct _DETACH_DEVICE_WORK_ITEM DETACH_DEVICE_WORK_ITEM
static NTSTATUS FltpEnumerateFileSystemVolumes(_In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:146
BOOLEAN NTAPI FltpFastIoQueryNetworkOpenInfo(_In_ PFILE_OBJECT FileObject, _In_ BOOLEAN Wait, _Out_ PFILE_NETWORK_OPEN_INFORMATION Buffer, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1225
PDEVICE_OBJECT CommsDeviceObject
Definition: Messaging.c:22
DRIVER_FS_NOTIFICATION FltpFsNotification
Definition: Interface.c:1699
BOOLEAN NTAPI FltpFastIoMdlReadCompleteCompressed(_In_ PFILE_OBJECT FileObject, _In_ PMDL MdlChain, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1569
NTSTATUS NTAPI FltpCreate(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
Definition: Interface.c:551
BOOLEAN NTAPI FltpFastIoUnlockAll(_In_ PFILE_OBJECT FileObject, _In_ PEPROCESS ProcessId, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1019
BOOLEAN NTAPI FltpFastIoQueryBasicInfo(_In_ PFILE_OBJECT FileObject, _In_ BOOLEAN Wait, _Out_ PFILE_BASIC_INFORMATION Buffer, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:819
BOOLEAN NTAPI FltpFastIoCheckIfPossible(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ BOOLEAN Wait, _In_ ULONG LockKey, _In_ BOOLEAN CheckForReadOperation, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:659
ERESOURCE FilterListLock
Definition: Filter.c:25
BOOLEAN NTAPI FltpFastIoPrepareMdlWrite(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ ULONG LockKey, _Out_ PMDL *MdlChain, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1365
NTSTATUS NTAPI FltpDeviceControl(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
Definition: Interface.c:622
BOOLEAN NTAPI FltpFastIoMdlWriteCompleteCompressed(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ PMDL MdlChain, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1609
BOOLEAN NTAPI FltpFastIoMdlWriteComplete(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ PMDL MdlChain, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1416
static NTSTATUS FltpAttachToFileSystemDevice(_In_ PDEVICE_OBJECT DeviceObject, _In_ PUNICODE_STRING DeviceName)
Definition: Interface.c:324
BOOLEAN NTAPI FltpFastIoMdlRead(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ ULONG LockKey, _Out_ PMDL *MdlChain, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1272
static NTSTATUS SetupDispatchAndCallbacksTables(_In_ PDRIVER_OBJECT DriverObject)
Definition: Interface.c:1739
static VOID FltpCleanupDeviceObject(_In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:49
static BOOLEAN FltpIsAttachedToDevice(_In_ PDEVICE_OBJECT DeviceObject, _In_opt_ PDEVICE_OBJECT *AttachedDeviceObject)
Definition: Interface.c:96
BOOLEAN NTAPI FltpFastIoDeviceControl(_In_ PFILE_OBJECT FileObject, _In_ BOOLEAN Wait, _In_opt_ PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_opt_ PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _In_ ULONG IoControlCode, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1112
BOOLEAN NTAPI FltpFastIoWrite(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ BOOLEAN Wait, _In_ ULONG LockKey, _In_ PVOID Buffer, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:766
BOOLEAN NTAPI FltpFastIoReadCompressed(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ ULONG LockKey, _Out_ PVOID Buffer, _Out_ PMDL *MdlChain, _Out_ PIO_STATUS_BLOCK IoStatus, _Out_ PCOMPRESSED_DATA_INFO CompressedDataInfo, _In_ ULONG CompressedDataInfoLength, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1459
DRIVER_DATA DriverData
Definition: Interface.c:35
BOOLEAN NTAPI FltpFastIoUnlockAllByKey(_In_ PFILE_OBJECT FileObject, _In_ PVOID ProcessId, _In_ ULONG Key, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1065
BOOLEAN NTAPI FltpFastIoMdlReadComplete(_In_ PFILE_OBJECT FileObject, _In_ PMDL MdlChain, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:1323
VOID NTAPI FltpFastIoDetachDevice(_In_ PDEVICE_OBJECT SourceDevice, _In_ PDEVICE_OBJECT TargetDevice)
Definition: Interface.c:1184
BOOLEAN NTAPI FltpFastIoLock(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ PLARGE_INTEGER Length, _In_ PEPROCESS ProcessId, _In_ ULONG Key, _In_ BOOLEAN FailImmediately, _In_ BOOLEAN ExclusiveLock, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
Definition: Interface.c:913
NTSTATUS NTAPI FltpFsControl(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
Definition: Interface.c:593
unsigned char BOOLEAN
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
const struct winhelp_callbacks Callbacks
Definition: callback.c:161
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:160
#define FILE_DEVICE_SECURE_OPEN
Definition: cdrw_usr.h:46
Definition: bufpool.h:45
_In_ PIRP Irp
Definition: csq.h:116
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
PDEVICE_LIST DeviceList
Definition: utils.c:27
static const WCHAR Cleanup[]
Definition: register.c:80
DRIVER_INITIALIZE DriverEntry
Definition: condrv.c:21
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define DO_BUFFERED_IO
Definition: env_spec_w32.h:394
ULONG RtlCompareUnicodeString(PUNICODE_STRING s1, PUNICODE_STRING s2, BOOLEAN UpCase)
Definition: string_lib.cpp:31
NTSTATUS ExInitializeResourceLite(PULONG res)
Definition: env_spec_w32.h:641
#define DO_DIRECT_IO
Definition: env_spec_w32.h:396
#define DO_DEVICE_INITIALIZING
Definition: env_spec_w32.h:399
#define DO_SYSTEM_BOOT_PARTITION
Definition: env_spec_w32.h:400
#define NonPagedPool
Definition: env_spec_w32.h:307
ULONG ERESOURCE
Definition: env_spec_w32.h:594
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
@ Success
Definition: eventcreate.c:712
#define ClearFlag(_F, _SF)
Definition: ext2fs.h:191
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
#define DRIVER_NAME
Definition: ext2fs.h:136
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG LockKey
Definition: fatprocs.h:2665
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN BOOLEAN ExclusiveLock
Definition: fatprocs.h:2714
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN CheckForReadOperation
Definition: fatprocs.h:2666
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN FailImmediately
Definition: fatprocs.h:2713
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ProcessId
Definition: fatprocs.h:2711
#define FLT_ASSERT(_e)
Definition: fltkernel.h:49
#define FM_TAG_REGISTRY_DATA
Definition: fltmgr.h:18
NTSTATUS FltpGetObjectName(_In_ PVOID Object, _Inout_ PUNICODE_STRING ObjectName)
Definition: Object.c:263
#define FM_TAG_DISPATCH_TABLE
Definition: fltmgr.h:17
#define MAX_DEVNAME_LENGTH
Definition: fltmgr.h:26
#define FM_TAG_DEV_OBJ_PTRS
Definition: fltmgr.h:19
VOID FltpFreeUnicodeString(_In_ PUNICODE_STRING String)
Definition: Lib.c:24
NTSTATUS FltpGetBaseDeviceObjectName(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PUNICODE_STRING ObjectName)
Definition: Object.c:245
NTSTATUS FltpSetupCommunicationObjects(_In_ PDRIVER_OBJECT DriverObject)
Definition: Messaging.c:377
NTSTATUS FltpMsgCreate(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
Definition: Messaging.c:223
NTSTATUS FltpMsgDispatch(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
Definition: Messaging.c:256
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ ULONG _In_ ULONG _Outptr_ PMDL * MdlChain
Definition: fsrtlfuncs.h:49
Status
Definition: gdiplustypes.h:25
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
VOID FASTCALL ExAcquireFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:23
VOID FASTCALL ExReleaseFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:31
void __cdecl __debugbreak(void)
Definition: intrin_ppc.h:698
DeviceType
Definition: mmdrv.h:42
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
#define _Out_opt_
Definition: ms_sal.h:346
#define _Inout_
Definition: ms_sal.h:378
#define _Out_
Definition: ms_sal.h:345
#define _In_
Definition: ms_sal.h:308
#define _In_opt_
Definition: ms_sal.h:309
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
__in UCHAR __in POWER_STATE __in_opt PVOID __in PIO_STATUS_BLOCK IoStatus
Definition: mxum.h:159
_Inout_opt_ PDEVICE_OBJECT _Inout_opt_ PDEVICE_OBJECT _Inout_opt_ PDEVICE_OBJECT * NextDeviceObject
Definition: ndis.h:4642
int Count
Definition: noreturn.cpp:7
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
NTSTATUS NTAPI FsRtlRegisterFileSystemFilterCallbacks(PDRIVER_OBJECT FilterDriverObject, PFS_FILTER_CALLBACKS Callbacks)
Definition: fastio.c:2008
NTSTATUS NTAPI IoEnumerateDeviceObjectList(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT *DeviceObjectList, IN ULONG DeviceObjectListSize, OUT PULONG ActualNumberDeviceObjects)
Definition: device.c:1322
PDEVICE_OBJECT NTAPI IoGetLowerDeviceObject(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1507
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1031
NTSTATUS NTAPI IoAttachDeviceToDeviceStackSafe(IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice, IN OUT PDEVICE_OBJECT *AttachedToDeviceObject)
Definition: device.c:980
NTSTATUS NTAPI IoGetDiskDeviceObject(IN PDEVICE_OBJECT FileSystemDeviceObject, OUT PDEVICE_OBJECT *DiskDeviceObject)
Definition: device.c:1453
PDEVICE_OBJECT NTAPI IoGetDeviceAttachmentBaseRef(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1419
VOID NTAPI IoDetachDevice(IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:1296
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251
NTSTATUS NTAPI IoGetDeviceObjectPointer(IN PUNICODE_STRING ObjectName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1435
PDEVICE_OBJECT NTAPI IoGetAttachedDeviceReference(PDEVICE_OBJECT DeviceObject)
Definition: device.c:1406
VOID FASTCALL IofCompleteRequest(IN PIRP Irp, IN CCHAR PriorityBoost)
Definition: irp.c:1308
#define IoCompleteRequest
Definition: irp.c:1240
#define IoCallDriver
Definition: irp.c:1225
NTSTATUS NTAPI IoRegisterFsRegistrationChange(IN PDRIVER_OBJECT DriverObject, IN PDRIVER_FS_NOTIFICATION DriverNotificationRoutine)
Definition: volume.c:1089
HANDLE NTAPI PsGetCurrentProcessId(VOID)
Definition: process.c:1123
#define STATUS_REPARSE
Definition: ntstatus.h:83
#define STATUS_DEVICE_ALREADY_ATTACHED
Definition: ntstatus.h:292
#define L(x)
Definition: ntvdm.h:50
FAST_IO_DISPATCH FastIoDispatch
Definition: null.c:15
#define FILE_DEVICE_DISK_FILE_SYSTEM
Definition: winioctl.h:53
#define FILE_DEVICE_CD_ROM_FILE_SYSTEM
Definition: winioctl.h:48
#define FILE_DEVICE_NETWORK_FILE_SYSTEM
Definition: winioctl.h:65
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define DPRINT
Definition: sndvol32.h:73
PDEVICE_OBJECT SourceDevice
Definition: Interface.c:40
PDEVICE_OBJECT TargetDevice
Definition: Interface.c:41
WORK_QUEUE_ITEM WorkItem
Definition: Interface.c:39
DWORD DeviceType
Definition: utils.c:20
PVOID DeviceExtension
Definition: env_spec_w32.h:418
PDRIVER_OBJECT DriverObject
Definition: fltmgr.h:31
UNICODE_STRING ServiceKey
Definition: fltmgr.h:33
PFAST_IO_DISPATCH FastIoDispatch
Definition: fltmgr.h:37
FAST_MUTEX FilterAttachLock
Definition: fltmgr.h:39
PDEVICE_OBJECT DeviceObject
Definition: fltmgr.h:32
PFAST_IO_QUERY_STANDARD_INFO FastIoQueryStandardInfo
Definition: iotypes.h:1738
PFAST_IO_UNLOCK_ALL_BY_KEY FastIoUnlockAllByKey
Definition: iotypes.h:1742
PFAST_IO_MDL_READ_COMPLETE MdlReadComplete
Definition: iotypes.h:1750
PFAST_IO_MDL_WRITE_COMPLETE_COMPRESSED MdlWriteCompleteCompressed
Definition: iotypes.h:1756
PFAST_IO_MDL_READ MdlRead
Definition: iotypes.h:1749
PFAST_IO_WRITE FastIoWrite
Definition: iotypes.h:1736
PFAST_IO_UNLOCK_ALL FastIoUnlockAll
Definition: iotypes.h:1741
PFAST_IO_QUERY_NETWORK_OPEN_INFO FastIoQueryNetworkOpenInfo
Definition: iotypes.h:1747
PFAST_IO_MDL_WRITE_COMPLETE MdlWriteComplete
Definition: iotypes.h:1752
ULONG SizeOfFastIoDispatch
Definition: iotypes.h:1733
PFAST_IO_DEVICE_CONTROL FastIoDeviceControl
Definition: iotypes.h:1743
PFAST_IO_READ FastIoRead
Definition: iotypes.h:1735
PFAST_IO_QUERY_BASIC_INFO FastIoQueryBasicInfo
Definition: iotypes.h:1737
PFAST_IO_LOCK FastIoLock
Definition: iotypes.h:1739
PFAST_IO_WRITE_COMPRESSED FastIoWriteCompressed
Definition: iotypes.h:1754
PFAST_IO_MDL_READ_COMPLETE_COMPRESSED MdlReadCompleteCompressed
Definition: iotypes.h:1755
PFAST_IO_UNLOCK_SINGLE FastIoUnlockSingle
Definition: iotypes.h:1740
PFAST_IO_READ_COMPRESSED FastIoReadCompressed
Definition: iotypes.h:1753
PFAST_IO_PREPARE_MDL_WRITE PrepareMdlWrite
Definition: iotypes.h:1751
PFAST_IO_CHECK_IF_POSSIBLE FastIoCheckIfPossible
Definition: iotypes.h:1734
PFAST_IO_QUERY_OPEN FastIoQueryOpen
Definition: iotypes.h:1757
PFAST_IO_DETACH_DEVICE FastIoDetachDevice
Definition: iotypes.h:1746
PDEVICE_OBJECT AttachedToDeviceObject
Definition: fltmgr.h:46
WCHAR DeviceNameBuffer[MAX_DEVNAME_LENGTH]
Definition: fltmgr.h:54
UNICODE_STRING DeviceName
Definition: fltmgr.h:53
PDEVICE_OBJECT StorageStackDeviceObject
Definition: fltmgr.h:49
PDEVICE_OBJECT DeviceObject
Definition: iotypes.h:3223
Definition: typedefs.h:120
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
#define NTAPI
Definition: typedefs.h:36
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint16_t * PWCHAR
Definition: typedefs.h:56
uint32_t ULONG
Definition: typedefs.h:59
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3275
_In_ WDFDPC _In_ BOOLEAN Wait
Definition: wdfdpc.h:170
_Must_inspect_result_ _In_ PDRIVER_OBJECT _In_ PCUNICODE_STRING RegistryPath
Definition: wdfdriver.h:215
_Must_inspect_result_ _In_ PDRIVER_OBJECT DriverObject
Definition: wdfdriver.h:213
_In_ WDFREQUEST _In_ size_t _In_ size_t _In_ ULONG IoControlCode
Definition: wdfio.h:325
_In_ WDFREQUEST _In_ size_t OutputBufferLength
Definition: wdfio.h:320
_In_ WDFREQUEST _In_ size_t _In_ size_t InputBufferLength
Definition: wdfio.h:322
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR OutputBuffer
Definition: wdfiotarget.h:863
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR InputBuffer
Definition: wdfiotarget.h:953
WDF_EXTERN_C_START typedef _Must_inspect_result_ _In_ WDFDRIVER _In_opt_ PWDF_OBJECT_ATTRIBUTES _In_ PDEVICE_OBJECT _In_opt_ PDEVICE_OBJECT AttachedDeviceObject
Definition: wdfminiport.h:70
_In_ WDFREQUEST _In_opt_ PFN_WDF_REQUEST_COMPLETION_ROUTINE _In_opt_ __drv_aliasesMem WDFCONTEXT CompletionContext
Definition: wdfrequest.h:898
VOID NTAPI ExQueueWorkItem(IN PWORK_QUEUE_ITEM WorkItem, IN WORK_QUEUE_TYPE QueueType)
Definition: work.c:723
_In_ PVOID _Out_opt_ PULONG_PTR _Outptr_opt_ PCUNICODE_STRING * ObjectName
Definition: cmfuncs.h:64
#define ExInitializeWorkItem(Item, Routine, Context)
Definition: exfuncs.h:265
FORCEINLINE VOID ExInitializeFastMutex(_Out_ PFAST_MUTEX FastMutex)
Definition: exfuncs.h:274
@ DelayedWorkQueue
Definition: extypes.h:190
_Must_inspect_result_ __drv_aliasesMem PDEVICE_OBJECT SourceDevice
Definition: iofuncs.h:690
_Must_inspect_result_ __drv_aliasesMem PDEVICE_OBJECT _In_ PDEVICE_OBJECT TargetDevice
Definition: iofuncs.h:691
_In_ BOOLEAN FsActive
Definition: iotypes.h:7360
#define IRP_MJ_CREATE_NAMED_PIPE
#define IRP_MJ_CREATE_MAILSLOT
#define IRP_MJ_FILE_SYSTEM_CONTROL
_Out_ PFILE_NETWORK_OPEN_INFORMATION NetworkInformation
Definition: iotypes.h:1703
_In_ PLARGE_INTEGER _In_ ULONG _In_ ULONG _Out_ PVOID _Out_ PMDL _Out_ PIO_STATUS_BLOCK _Out_ struct _COMPRESSED_DATA_INFO * CompressedDataInfo
Definition: iotypes.h:1658
_In_ PLARGE_INTEGER _In_ ULONG _In_ ULONG _Out_ PVOID _Out_ PMDL _Out_ PIO_STATUS_BLOCK _Out_ struct _COMPRESSED_DATA_INFO _In_ ULONG CompressedDataInfoLength
Definition: iotypes.h:1659
struct _FS_FILTER_CALLBACKS FS_FILTER_CALLBACKS
* PFILE_OBJECT
Definition: iotypes.h:1998
struct _FAST_IO_DISPATCH FAST_IO_DISPATCH
#define IRP_MJ_SHUTDOWN
#define IRP_MJ_MAXIMUM_FUNCTION
_IRQL_requires_same_ _In_ PKE_PROCESSOR_CHANGE_NOTIFY_CONTEXT _Inout_ PNTSTATUS OperationStatus
Definition: ketypes.h:373
#define ObDereferenceObject
Definition: obfuncs.h:203
_Inout_opt_ PVOID Parameter
Definition: rtltypes.h:336
__wchar_t WCHAR
Definition: xmlstorage.h:180