ReactOS 0.4.15-dev-7788-g1ad9096
iofunc.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/io/iomgr/iofunc.c
5 * PURPOSE: Generic I/O Functions that build IRPs for various operations
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 * Gunnar Dalsnes
8 * Filip Navara (navaraf@reactos.org)
9 * Pierre Schweitzer (pierre@reactos.org)
10 */
11
12/* INCLUDES *****************************************************************/
13
14#include <ntoskrnl.h>
15#include <ioevent.h>
16#define NDEBUG
17#include <debug.h>
18#include "internal/io_i.h"
19
22
23/* PRIVATE FUNCTIONS *********************************************************/
24
25VOID
30 IN PKEVENT LocalEvent OPTIONAL)
31{
32 PAGED_CODE();
33 IOTRACE(IO_API_DEBUG, "IRP: %p. FO: %p\n", Irp, FileObject);
34
35 if (Irp)
36 {
37 /* Check if we had a buffer */
38 if (Irp->AssociatedIrp.SystemBuffer)
39 {
40 /* Free it */
41 ExFreePool(Irp->AssociatedIrp.SystemBuffer);
42 }
43
44 /* Free the mdl */
45 if (Irp->MdlAddress) IoFreeMdl(Irp->MdlAddress);
46
47 /* Free the IRP */
49 }
50
51 /* Check if we had a file lock */
52 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
53 {
54 /* Release it */
56 }
57
58 /* Check if we had an event */
60
61 /* Check if we had a local event */
62 if (LocalEvent) ExFreePool(LocalEvent);
63
64 /* Derefenrce the FO */
66}
67
72 IN PIRP Irp,
74 IN PIO_STATUS_BLOCK KernelIosb,
76{
77 NTSTATUS FinalStatus = SynchStatus;
78 PAGED_CODE();
79 IOTRACE(IO_API_DEBUG, "IRP: %p. Status: %lx\n", Irp, SynchStatus);
80
81 /* Make sure the IRP was completed, but returned pending */
82 if (FinalStatus == STATUS_PENDING)
83 {
84 /* Wait for the IRP */
85 FinalStatus = KeWaitForSingleObject(Event,
88 FALSE,
89 NULL);
90 if (FinalStatus == STATUS_USER_APC)
91 {
92 /* Abort the request */
94 }
95
96 /* Set the final status */
97 FinalStatus = KernelIosb->Status;
98 }
99
100 /* Wrap potential user-mode write in SEH */
102 {
103 *IoStatusBlock = *KernelIosb;
104 }
106 {
107 /* Get the exception code */
108 FinalStatus = _SEH2_GetExceptionCode();
109 }
110 _SEH2_END;
111
112 /* Free the event and return status */
114 return FinalStatus;
115}
116
118NTAPI
120 IN PIRP Irp,
122 IN BOOLEAN Deferred,
124 IN BOOLEAN SynchIo,
125 IN IOP_TRANSFER_TYPE TransferType)
126{
128 PKNORMAL_ROUTINE NormalRoutine;
129 PVOID NormalContext = NULL;
131 PAGED_CODE();
132 IOTRACE(IO_API_DEBUG, "IRP: %p. DO: %p. FO: %p\n",
134
135 /* Queue the IRP */
137
138 /* Update operation counts */
139 IopUpdateOperationCount(TransferType);
140
141 /* Call the driver */
143
144 /* Check if we're optimizing this case */
145 if (Deferred)
146 {
147 /* We are! Check if the IRP wasn't completed */
148 if (Status != STATUS_PENDING)
149 {
150 /* Complete it ourselves */
151 NormalRoutine = NULL;
152 NormalContext = NULL;
153 ASSERT(!Irp->PendingReturned);
155 IopCompleteRequest(&Irp->Tail.Apc,
156 &NormalRoutine,
157 &NormalContext,
158 (PVOID*)&FileObject,
159 &NormalContext);
161 }
162 }
163
164 /* Check if this was synch I/O */
165 if (SynchIo)
166 {
167 /* Make sure the IRP was completed, but returned pending */
168 if (Status == STATUS_PENDING)
169 {
170 /* Wait for the IRP */
172 Executive,
174 (FileObject->Flags &
175 FO_ALERTABLE_IO) != 0,
176 NULL);
178 {
179 /* Abort the request */
181 }
182
183 /* Set the final status */
184 Status = FileObject->FinalStatus;
185 }
186
187 /* Release the file lock */
189 }
190
191 /* Return status */
192 return Status;
193}
194
196NTAPI
199 IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
200 IN PVOID UserApcContext OPTIONAL,
207 IN BOOLEAN IsDevIoCtl)
208{
212 PIRP Irp;
213 PIO_STACK_LOCATION StackPtr;
214 PKEVENT EventObject = NULL;
215 BOOLEAN LockedForSynch = FALSE;
216 ULONG AccessType;
222
223 PAGED_CODE();
224
225 IOTRACE(IO_CTL_DEBUG, "Handle: %p. CTL: %lx. Type: %lx\n",
226 DeviceHandle, IoControlCode, IsDevIoCtl);
227
228 /* Get the access type */
230
231 /* Check if we came from user mode */
233 {
235 {
236 /* Probe the status block */
238
239 /* Check if this is buffered I/O */
240 if (AccessType == METHOD_BUFFERED)
241 {
242 /* Check if we have an output buffer */
243 if (OutputBuffer)
244 {
245 /* Probe the output buffer */
248 sizeof(CHAR));
249 }
250 else
251 {
252 /* Make sure the caller can't fake this as we depend on this */
254 }
255 }
256
257 /* Check if we we have an input buffer I/O */
258 if (AccessType != METHOD_NEITHER)
259 {
260 /* Check if we have an input buffer */
261 if (InputBuffer)
262 {
263 /* Probe the input buffer */
265 }
266 else
267 {
268 /* Make sure the caller can't fake this as we depend on this */
270 }
271 }
272 }
274 {
275 /* Return the exception code */
277 }
278 _SEH2_END;
279 }
280
281 /* Don't check for access rights right now, KernelMode can do anything */
283 0,
286 (PVOID*)&FileObject,
288 if (!NT_SUCCESS(Status)) return Status;
289
290 /* Can't use an I/O completion port and an APC at the same time */
291 if ((FileObject->CompletionContext) && (UserApcRoutine))
292 {
293 /* Fail */
296 }
297
298 /* Check if we from user mode */
300 {
301 /* Get the access mask */
302 DesiredAccess = (ACCESS_MASK)((IoControlCode >> 14) & 3);
303
304 /* Check if we can open it */
306 (HandleInformation.GrantedAccess & DesiredAccess) != DesiredAccess)
307 {
308 /* Dereference the file object and fail */
311 }
312 }
313
314 /* Check for an event */
315 if (Event)
316 {
317 /* Reference it */
322 (PVOID*)&EventObject,
323 NULL);
324 if (!NT_SUCCESS(Status))
325 {
326 /* Dereference the file object and fail */
328 return Status;
329 }
330
331 /* Clear it */
332 KeClearEvent(EventObject);
333 }
334
335 /* Check if this is a file that was opened for Synch I/O */
336 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
337 {
338 /* Lock it */
340 if (Status != STATUS_SUCCESS)
341 {
342 if (EventObject) ObDereferenceObject(EventObject);
344 return Status;
345 }
346
347 /* Remember to unlock later */
348 LockedForSynch = TRUE;
349 }
350
351 /* Check if this is a direct open or not */
353 {
354 /* It's a direct open, get the attached device */
356 }
357 else
358 {
359 /* Otherwise get the related device */
361 }
362
363 /* If this is a device I/O, try to do it with FastIO path */
364 if (IsDevIoCtl)
365 {
366 PFAST_IO_DISPATCH FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch;
367
368 /* Check whether FSD is FastIO aware and provide an appropriate routine */
370 {
371 IO_STATUS_BLOCK KernelIosb;
372
373 /* If we have an output buffer coming from usermode */
375 {
376 /* Probe it according to its usage */
378 {
379 if (AccessType == METHOD_IN_DIRECT)
380 {
382 }
383 else if (AccessType == METHOD_OUT_DIRECT)
384 {
386 }
387 }
389 {
390 /* Cleanup after exception and return */
392
393 /* Return the exception code */
395 }
396 _SEH2_END;
397 }
398
399 /* If we are dismounting a volume, increase the dismount count */
401 {
402 InterlockedIncrement((PLONG)&SharedUserData->DismountCount);
403 }
404
405 /* Call the FSD */
407 TRUE,
413 &KernelIosb,
415 {
416 IO_COMPLETION_CONTEXT CompletionInfo = { NULL, NULL };
417
418 /* Write the IOSB back */
420 {
421 *IoStatusBlock = KernelIosb;
422
423 }
425 {
426 KernelIosb.Status = _SEH2_GetExceptionCode();
427 }
428 _SEH2_END;
429
430 /* Backup our complete context in case it exists */
431 if (FileObject->CompletionContext)
432 {
433 CompletionInfo = *(FileObject->CompletionContext);
434 }
435
436 /* If we had an event, signal it */
437 if (Event)
438 {
439 KeSetEvent(EventObject, IO_NO_INCREMENT, FALSE);
440 ObDereferenceObject(EventObject);
441 }
442
443 /* If FO was locked, unlock it */
444 if (LockedForSynch)
445 {
447 }
448
449 /* Set completion if required */
450 if (CompletionInfo.Port != NULL && UserApcContext != NULL)
451 {
452 if (!NT_SUCCESS(IoSetIoCompletion(CompletionInfo.Port,
453 CompletionInfo.Key,
454 UserApcContext,
455 KernelIosb.Status,
456 KernelIosb.Information,
457 TRUE)))
458 {
460 }
461 }
462
463 /* We're done with FastIO! */
465 return KernelIosb.Status;
466 }
467 }
468 }
469
470 /* Clear the event */
471 KeClearEvent(&FileObject->Event);
472
473 /* Allocate IRP */
474 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
475 if (!Irp) return IopCleanupFailedIrp(FileObject, EventObject, NULL);
476
477 /* Setup the IRP */
478 Irp->UserIosb = IoStatusBlock;
479 Irp->UserEvent = EventObject;
480 Irp->Overlay.AsynchronousParameters.UserApcRoutine = UserApcRoutine;
481 Irp->Overlay.AsynchronousParameters.UserApcContext = UserApcContext;
482 Irp->Cancel = FALSE;
483 Irp->CancelRoutine = NULL;
484 Irp->PendingReturned = FALSE;
485 Irp->RequestorMode = PreviousMode;
486 Irp->MdlAddress = NULL;
487 Irp->AssociatedIrp.SystemBuffer = NULL;
488 Irp->Flags = 0;
489 Irp->Tail.Overlay.AuxiliaryBuffer = NULL;
490 Irp->Tail.Overlay.OriginalFileObject = FileObject;
491 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
492
493 /* Set stack location settings */
494 StackPtr = IoGetNextIrpStackLocation(Irp);
495 StackPtr->FileObject = FileObject;
496 StackPtr->MajorFunction = IsDevIoCtl ?
499 StackPtr->MinorFunction = 0; /* Minor function 0 is IRP_MN_USER_FS_REQUEST */
500 StackPtr->Control = 0;
501 StackPtr->Flags = 0;
502 StackPtr->Parameters.DeviceIoControl.Type3InputBuffer = NULL;
503
504 /* Set the IOCTL Data */
505 StackPtr->Parameters.DeviceIoControl.IoControlCode = IoControlCode;
506 StackPtr->Parameters.DeviceIoControl.InputBufferLength = InputBufferLength;
507 StackPtr->Parameters.DeviceIoControl.OutputBufferLength =
509
511
512 /* Handle the Methods */
513 switch (AccessType)
514 {
515 /* Buffered I/O */
516 case METHOD_BUFFERED:
517
518 /* Enter SEH for allocations */
520 {
521 /* Select the right Buffer Length */
524
525 /* Make sure there is one */
526 if (BufferLength)
527 {
528 /* Allocate the System Buffer */
529 Irp->AssociatedIrp.SystemBuffer =
533
534 /* Check if we got a buffer */
535 if (InputBuffer)
536 {
537 /* Copy into the System Buffer */
538 RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
541 }
542
543 /* Write the flags */
545 if (OutputBuffer) Irp->Flags |= IRP_INPUT_OPERATION;
546
547 /* Save the Buffer */
548 Irp->UserBuffer = OutputBuffer;
549 }
550 else
551 {
552 /* Clear the Flags and Buffer */
553 Irp->UserBuffer = NULL;
554 }
555 }
557 {
558 /* Cleanup after exception and return */
561 }
562 _SEH2_END;
563 break;
564
565 /* Direct I/O */
566 case METHOD_IN_DIRECT:
568
569 /* Enter SEH */
571 {
572 /* Check if we got an input buffer */
574 {
575 /* Allocate the System Buffer */
576 Irp->AssociatedIrp.SystemBuffer =
580
581 /* Copy into the System Buffer */
582 RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
585
586 /* Write the flags */
588 }
589
590 /* Check if we got an output buffer */
592 {
593 /* Allocate the System Buffer */
594 Irp->MdlAddress = IoAllocateMdl(OutputBuffer,
596 FALSE,
597 FALSE,
598 Irp);
599 if (!Irp->MdlAddress)
600 {
601 /* Raise exception we'll catch */
603 }
604
605 /* Do the probe */
606 MmProbeAndLockPages(Irp->MdlAddress,
608 (AccessType == METHOD_IN_DIRECT) ?
610 }
611 }
613 {
614 /* Cleanup after exception and return */
617 }
618 _SEH2_END;
619 break;
620
621 case METHOD_NEITHER:
622
623 /* Just save the Buffer */
624 Irp->UserBuffer = OutputBuffer;
625 StackPtr->Parameters.DeviceIoControl.Type3InputBuffer = InputBuffer;
626 }
627
628 /* Use deferred completion for FS I/O */
629 if (!IsDevIoCtl)
630 {
632 }
633
634 /* If we are dismounting a volume, increaase the dismount count */
636 {
637 InterlockedIncrement((PLONG)&SharedUserData->DismountCount);
638 }
639
640 /* Perform the call */
642 Irp,
644 !IsDevIoCtl,
646 LockedForSynch,
648}
649
651NTAPI
658{
660 PIRP Irp;
662 PIO_STACK_LOCATION StackPtr;
663 BOOLEAN LocalEvent = FALSE;
666 PAGED_CODE();
667 IOTRACE(IO_API_DEBUG, "Handle: %p. CTL: %lx. Type: %lx\n",
669
670 /* Reference the object */
672
673 /* Check if this is a file that was opened for Synch I/O */
674 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
675 {
676 /* Lock it */
678
679 /* Use File Object event */
680 KeClearEvent(&FileObject->Event);
681 }
682 else
683 {
684 /* Use local event */
686 LocalEvent = TRUE;
687 }
688
689 /* Get the Device Object */
691
692 /* Allocate the IRP */
693 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
695
696 /* Set the IRP */
697 Irp->Tail.Overlay.OriginalFileObject = FileObject;
698 Irp->RequestorMode = KernelMode;
699 Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
700 Irp->UserIosb = &IoStatusBlock;
701 Irp->UserEvent = (LocalEvent) ? &Event : NULL;
702 Irp->Flags = (LocalEvent) ? IRP_SYNCHRONOUS_API : 0;
703 Irp->Flags |= IRP_BUFFERED_IO;
704 Irp->AssociatedIrp.SystemBuffer = Information;
705 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
706
707 /* Set the Stack Data */
708 StackPtr = IoGetNextIrpStackLocation(Irp);
711 StackPtr->FileObject = FileObject;
712
713 /* Check which type this is */
714 if (File)
715 {
716 /* Set Parameters */
717 StackPtr->Parameters.QueryFile.FileInformationClass = InformationClass;
718 StackPtr->Parameters.QueryFile.Length = Length;
719 }
720 else
721 {
722 /* Set Parameters */
723 StackPtr->Parameters.QueryVolume.FsInformationClass = InformationClass;
724 StackPtr->Parameters.QueryVolume.Length = Length;
725 }
726
727 /* Queue the IRP */
729
730 /* Call the Driver */
732
733 /* Check if this was synch I/O */
734 if (!LocalEvent)
735 {
736 /* Check if the request is pending */
737 if (Status == STATUS_PENDING)
738 {
739 /* Wait on the file object */
741 Executive,
743 (FileObject->Flags &
744 FO_ALERTABLE_IO) != 0,
745 NULL);
746 if (Status == STATUS_ALERTED)
747 {
748 /* Abort the operation */
750 }
751
752 /* Get the final status */
753 Status = FileObject->FinalStatus;
754 }
755
756 /* Release the file lock */
758 }
759 else if (Status == STATUS_PENDING)
760 {
761 /* Wait on the local event and get the final status */
763 Executive,
765 FALSE,
766 NULL);
768 }
769
770 /* Return the Length and Status. ReturnedLength is NOT optional */
772 return Status;
773}
774
776NTAPI
779 IN FILE_INFORMATION_CLASS FileInfoClass,
782{
783 PIRP Irp;
789
790 PAGED_CODE();
791
792 /* Allocate an IRP */
795 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
796 if (Irp == NULL)
797 {
800 }
801
802 /* Init event */
804
805 /* Setup the IRP */
806 Irp->UserIosb = &IoStatusBlock;
807 Irp->UserEvent = &Event;
808 Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
809 Irp->RequestorMode = KernelMode;
810 Irp->AssociatedIrp.SystemBuffer = Buffer;
812 Irp->Tail.Overlay.OriginalFileObject = FileObject;
813 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
814
816 Stack->MajorFunction = IRP_MJ_QUERY_INFORMATION;
817 Stack->FileObject = FileObject;
818 Stack->Parameters.QueryFile.FileInformationClass = FileInfoClass;
819 Stack->Parameters.QueryFile.Length = Length;
820
821
822 /* Queue the IRP */
824
825 /* Call the driver */
827 if (Status == STATUS_PENDING)
828 {
831 }
832
834 return Status;
835}
836
838NTAPI
841{
845
846 PAGED_CODE();
847
848 /* Try to do it the fast way if possible */
850 if (DeviceObject->DriverObject->FastIoDispatch != NULL &&
851 DeviceObject->DriverObject->FastIoDispatch->FastIoQueryBasicInfo != NULL &&
852 DeviceObject->DriverObject->FastIoDispatch->FastIoQueryBasicInfo(FileObject,
853 ((FileObject->Flags & FO_SYNCHRONOUS_IO) != 0),
854 BasicInfo,
857 {
858 return IoStatusBlock.Status;
859 }
860
861 /* In case it failed, fall back to IRP-based method */
863}
864
866NTAPI
868 IN PIRP Irp,
869 IN PFILE_RENAME_INFORMATION RenameInfo,
871{
876 PFILE_OBJECT TargetFileObject;
878 FILE_BASIC_INFORMATION BasicInfo;
882
883 PAGED_CODE();
884
885 /* First, establish whether our target is a directory */
886 if (!(FileObject->Flags & FO_DIRECT_DEVICE_OPEN))
887 {
889 if (!NT_SUCCESS(Status))
890 {
891 return Status;
892 }
893
896 }
897 }
898
899 /* Setup the string to the target */
900 FileName.Buffer = RenameInfo->FileName;
901 FileName.Length = RenameInfo->FileNameLength;
902 FileName.MaximumLength = RenameInfo->FileNameLength;
903
905 &FileName,
907 RenameInfo->RootDirectory,
908 NULL);
909
910 /* And open its parent directory
911 * Use hint if specified
912 */
914 {
915 PFILE_OBJECT_EXTENSION FileObjectExtension;
916
918
919 FileObjectExtension = FileObject->FileObjectExtension;
924 NULL,
925 0,
927 FILE_OPEN,
929 NULL,
930 0,
932 NULL,
934 FileObjectExtension->TopDeviceObjectHint);
935 }
936 else
937 {
942 NULL,
943 0,
945 FILE_OPEN,
947 NULL,
948 0,
950 NULL,
952 }
953
954 if (!NT_SUCCESS(Status))
955 {
956 return Status;
957 }
958
959 /* Once open, continue only if:
960 * Target exists and we're allowed to overwrite it
961 */
963 if (Stack->Parameters.SetFile.FileInformationClass == FileLinkInformation &&
964 !RenameInfo->ReplaceIfExists &&
966 {
969 }
970
971 /* Now, we'll get the associated device of the target, to check for same device location
972 * So, get the FO first
973 */
978 (PVOID *)&TargetFileObject,
980 if (!NT_SUCCESS(Status))
981 {
983 return Status;
984 }
985
986 /* We can dereference, we have the handle */
987 ObDereferenceObject(TargetFileObject);
988 /* If we're not on the same device, error out **/
990 {
993 }
994
995 /* Return parent directory file object and handle */
996 Stack->Parameters.SetFile.FileObject = TargetFileObject;
998
999 return STATUS_SUCCESS;
1000}
1001
1002static
1003ULONG
1005{
1006 ULONG Mode = 0;
1007
1008 if (FileObject->Flags & FO_WRITE_THROUGH)
1010
1011 if (FileObject->Flags & FO_SEQUENTIAL_ONLY)
1013
1016
1017 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
1018 {
1019 if (FileObject->Flags & FO_ALERTABLE_IO)
1021 else
1023 }
1024
1025 if (FileObject->Flags & FO_DELETE_ON_CLOSE)
1027
1028 return Mode;
1029}
1030
1031static
1032BOOLEAN
1034{
1035 KIRQL OldIrql;
1036 PVPB Vpb;
1037 BOOLEAN Mounted;
1038
1039 /* Assume not mounted */
1040 Mounted = FALSE;
1041
1042 /* Check whether we have the mount flag */
1044
1045 Vpb = DeviceObject->Vpb;
1046 if (Vpb != NULL &&
1047 BooleanFlagOn(Vpb->Flags, VPB_MOUNTED))
1048 {
1049 Mounted = TRUE;
1050 }
1051
1053
1054 return Mounted;
1055}
1056
1057static
1058BOOLEAN
1061{
1062 PDEVICE_OBJECT StackDO;
1063
1064 /* Browse our whole device stack, trying to find the appropriate driver */
1066 while (StackDO != NULL)
1067 {
1068 /* We've found the driver, return success */
1069 if (StackDO->DriverObject == DriverObject)
1070 {
1071 return TRUE;
1072 }
1073
1074 /* Move to the next */
1075 StackDO = StackDO->AttachedDevice;
1076 }
1077
1078 /* We only reach there if driver was not found */
1079 return FALSE;
1080}
1081
1082static
1085 IN PFILE_FS_DRIVER_PATH_INFORMATION DriverPathInfo,
1086 IN ULONG Length)
1087{
1088 KIRQL OldIrql;
1090 UNICODE_STRING DriverName;
1092
1093 /* Make sure the structure is consistent (ie, driver name fits into the buffer) */
1094 if (Length - FIELD_OFFSET(FILE_FS_DRIVER_PATH_INFORMATION, DriverName) < DriverPathInfo->DriverNameLength)
1095 {
1097 }
1098
1099 /* Setup the whole driver name */
1100 DriverName.Length = DriverPathInfo->DriverNameLength;
1101 DriverName.MaximumLength = DriverPathInfo->DriverNameLength;
1102 DriverName.Buffer = &DriverPathInfo->DriverName[0];
1103
1104 /* Ask Ob for such driver */
1105 Status = ObReferenceObjectByName(&DriverName,
1107 NULL,
1108 0,
1110 KernelMode,
1111 NULL,
1112 (PVOID*)&DriverObject);
1113 /* No such driver, bail out */
1114 if (!NT_SUCCESS(Status))
1115 {
1116 return Status;
1117 }
1118
1119 /* Lock the devices database, we'll browse it */
1121 /* If we have a VPB, browse the stack from the volume */
1122 if (FileObject->Vpb != NULL && FileObject->Vpb->DeviceObject != NULL)
1123 {
1124 DriverPathInfo->DriverInPath = IopVerifyDriverObjectOnStack(FileObject->Vpb->DeviceObject, DriverObject);
1125 }
1126 /* Otherwise, do it from the normal device */
1127 else
1128 {
1129 DriverPathInfo->DriverInPath = IopVerifyDriverObjectOnStack(FileObject->DeviceObject, DriverObject);
1130 }
1132
1133 /* No longer needed */
1135
1136 return STATUS_SUCCESS;
1137}
1138
1139/* PUBLIC FUNCTIONS **********************************************************/
1140
1141/*
1142 * @implemented
1143 */
1145NTAPI
1147 IN PMDL Mdl,
1150 IN PIO_STATUS_BLOCK StatusBlock)
1151{
1152 PIRP Irp;
1153 PIO_STACK_LOCATION StackPtr;
1155 IOTRACE(IO_API_DEBUG, "FileObject: %p. Mdl: %p. Offset: %p\n",
1157
1158 /* Is the write originating from Cc? */
1159 if (FileObject->SectionObjectPointer != NULL &&
1160 FileObject->SectionObjectPointer->SharedCacheMap != NULL)
1161 {
1162 ++CcDataFlushes;
1164 }
1165
1166 /* Get the Device Object */
1168
1169 /* Allocate IRP */
1170 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
1172
1173 /* Get the Stack */
1174 StackPtr = IoGetNextIrpStackLocation(Irp);
1175
1176 /* Create the IRP Settings */
1177 Irp->MdlAddress = Mdl;
1178 Irp->UserBuffer = MmGetMdlVirtualAddress(Mdl);
1179 Irp->UserIosb = StatusBlock;
1180 Irp->UserEvent = Event;
1181 Irp->RequestorMode = KernelMode;
1183 Irp->Tail.Overlay.OriginalFileObject = FileObject;
1184 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
1185
1186 /* Set the Stack Settings */
1187 StackPtr->Parameters.Write.Length = MmGetMdlByteCount(Mdl);
1188 StackPtr->Parameters.Write.ByteOffset = *Offset;
1189 StackPtr->MajorFunction = IRP_MJ_WRITE;
1190 StackPtr->FileObject = FileObject;
1191
1192 /* Call the Driver */
1193 return IoCallDriver(DeviceObject, Irp);
1194}
1195
1196/*
1197 * @implemented
1198 */
1200NTAPI
1202 IN PMDL Mdl,
1205 IN PIO_STATUS_BLOCK StatusBlock)
1206{
1207 PIRP Irp;
1208 PIO_STACK_LOCATION StackPtr;
1210 IOTRACE(IO_API_DEBUG, "FileObject: %p. Mdl: %p. Offset: %p\n",
1212
1213 /* Get the Device Object */
1215
1216 /* Allocate IRP */
1217 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
1218 /* If allocation failed, try to see whether we can use
1219 * the reserve IRP
1220 */
1221 if (Irp == NULL)
1222 {
1223 /* We will use it only for paging file */
1225 {
1228 }
1229 else
1230 {
1232 }
1233
1234 /* If allocation failed (not a paging file or too big stack size)
1235 * Fail for real
1236 */
1237 if (Irp == NULL)
1238 {
1240 }
1241 }
1242
1243 /* Get the Stack */
1244 StackPtr = IoGetNextIrpStackLocation(Irp);
1245
1246 /* Create the IRP Settings */
1247 Irp->MdlAddress = Mdl;
1248 Irp->UserBuffer = MmGetMdlVirtualAddress(Mdl);
1249 Irp->UserIosb = StatusBlock;
1250 Irp->UserEvent = Event;
1251 Irp->RequestorMode = KernelMode;
1252 Irp->Flags = IRP_PAGING_IO |
1253 IRP_NOCACHE |
1256 Irp->Tail.Overlay.OriginalFileObject = FileObject;
1257 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
1258
1259 /* Set the Stack Settings */
1260 StackPtr->Parameters.Read.Length = MmGetMdlByteCount(Mdl);
1261 StackPtr->Parameters.Read.ByteOffset = *Offset;
1262 StackPtr->MajorFunction = IRP_MJ_READ;
1263 StackPtr->FileObject = FileObject;
1264
1265 /* Call the Driver */
1266 return IoCallDriver(DeviceObject, Irp);
1267}
1268
1269/*
1270 * @implemented
1271 */
1273NTAPI
1276 IN ULONG Length,
1279{
1280 /* Call the shared routine */
1283 Length,
1286 TRUE);
1287}
1288
1289/*
1290 * @implemented
1291 */
1293NTAPI
1296 IN ULONG Length,
1297 OUT PVOID FsInformation,
1299{
1300 /* Call the shared routine */
1303 Length,
1304 FsInformation,
1306 FALSE);
1307}
1308
1309/*
1310 * @implemented
1311 */
1313NTAPI
1316 IN ULONG Length,
1318{
1320 PIRP Irp;
1322 PIO_STACK_LOCATION StackPtr;
1323 BOOLEAN LocalEvent = FALSE;
1324 KEVENT Event;
1326 PAGED_CODE();
1327 IOTRACE(IO_API_DEBUG, "FileObject: %p. Class: %lx. Length: %lx\n",
1329
1330 /* Reference the object */
1332
1333 /* Check if this is a file that was opened for Synch I/O */
1334 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
1335 {
1336 /* Lock it */
1338
1339 /* Use File Object event */
1340 KeClearEvent(&FileObject->Event);
1341 }
1342 else
1343 {
1344 /* Use local event */
1346 LocalEvent = TRUE;
1347 }
1348
1349 /* Get the Device Object */
1351
1352 /* Allocate the IRP */
1353 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
1354 if (!Irp) return IopCleanupFailedIrp(FileObject, NULL, NULL);
1355
1356 /* Set the IRP */
1357 Irp->Tail.Overlay.OriginalFileObject = FileObject;
1358 Irp->RequestorMode = KernelMode;
1359 Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
1360 Irp->UserIosb = &IoStatusBlock;
1361 Irp->UserEvent = (LocalEvent) ? &Event : NULL;
1362 Irp->Flags = (LocalEvent) ? IRP_SYNCHRONOUS_API : 0;
1363 Irp->Flags |= IRP_BUFFERED_IO;
1364 Irp->AssociatedIrp.SystemBuffer = FileInformation;
1365 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
1366
1367 /* Set the Stack Data */
1368 StackPtr = IoGetNextIrpStackLocation(Irp);
1370 StackPtr->FileObject = FileObject;
1371
1372 /* Set Parameters */
1373 StackPtr->Parameters.SetFile.FileInformationClass = FileInformationClass;
1374 StackPtr->Parameters.SetFile.Length = Length;
1375
1376 /* Queue the IRP */
1378
1379 /* Call the Driver */
1381
1382 /* Check if this was synch I/O */
1383 if (!LocalEvent)
1384 {
1385 /* Check if the request is pending */
1386 if (Status == STATUS_PENDING)
1387 {
1388 /* Wait on the file object */
1390 Executive,
1391 KernelMode,
1392 (FileObject->Flags &
1393 FO_ALERTABLE_IO) != 0,
1394 NULL);
1395 if (Status == STATUS_ALERTED)
1396 {
1397 /* Abort the operation */
1399 }
1400
1401 /* Get the final status */
1402 Status = FileObject->FinalStatus;
1403 }
1404
1405 /* Release the file lock */
1407 }
1408 else if (Status == STATUS_PENDING)
1409 {
1410 /* Wait on the local event and get the final status */
1412 Executive,
1413 KernelMode,
1414 FALSE,
1415 NULL);
1417 }
1418
1419 /* Return the status */
1420 return Status;
1421}
1422
1423/* NATIVE SERVICES ***********************************************************/
1424
1425/*
1426 * @implemented
1427 */
1429NTAPI
1432 IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
1433 IN PVOID UserApcContext OPTIONAL,
1440{
1441 /* Call the Generic Function */
1443 Event,
1444 UserApcRoutine,
1445 UserApcContext,
1452 TRUE);
1453}
1454
1455/*
1456 * @implemented
1457 */
1459NTAPI
1462 IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
1463 IN PVOID UserApcContext OPTIONAL,
1470{
1471 /* Call the Generic Function */
1473 Event,
1474 UserApcRoutine,
1475 UserApcContext,
1482 FALSE);
1483}
1484
1486NTAPI
1489{
1491 PIRP Irp;
1492 PIO_STACK_LOCATION StackPtr;
1495 PKEVENT Event = NULL;
1496 BOOLEAN LocalEvent = FALSE;
1497 OBJECT_HANDLE_INFORMATION ObjectHandleInfo;
1499 IO_STATUS_BLOCK KernelIosb;
1500 PAGED_CODE();
1501 IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
1502
1503 if (PreviousMode != KernelMode)
1504 {
1505 /* Protect probes */
1506 _SEH2_TRY
1507 {
1508 /* Probe the I/O Status block */
1510 }
1512 {
1513 /* Return the exception code */
1515 }
1516 _SEH2_END;
1517 }
1518
1519 /* Get the File Object */
1521 0,
1524 (PVOID*)&FileObject,
1525 &ObjectHandleInfo);
1526 if (!NT_SUCCESS(Status)) return Status;
1527
1528 /*
1529 * Check if the handle has either FILE_WRITE_DATA or FILE_APPEND_DATA was
1530 * granted. However, if this is a named pipe, make sure we don't ask for
1531 * FILE_APPEND_DATA as it interferes with the FILE_CREATE_PIPE_INSTANCE
1532 * access right!
1533 */
1534 if (!(ObjectHandleInfo.GrantedAccess &
1535 ((!(FileObject->Flags & FO_NAMED_PIPE) ? FILE_APPEND_DATA : 0) |
1537 {
1538 /* We failed */
1540 return STATUS_ACCESS_DENIED;
1541 }
1542
1543 /* Check if we should use Sync IO or not */
1544 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
1545 {
1546 /* Lock it */
1548 if (Status != STATUS_SUCCESS)
1549 {
1551 return Status;
1552 }
1553 }
1554 else
1555 {
1556 /* Use local event */
1558 if (!Event)
1559 {
1560 /* We failed */
1563 }
1565 LocalEvent = TRUE;
1566 }
1567
1568 /* Get the Device Object */
1570
1571 /* Clear the event */
1572 KeClearEvent(&FileObject->Event);
1573
1574 /* Allocate the IRP */
1575 Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);
1577
1578 /* Set up the IRP */
1579 Irp->Flags = (LocalEvent) ? IRP_SYNCHRONOUS_API : 0;
1580 Irp->UserIosb = (LocalEvent) ? &KernelIosb : IoStatusBlock;
1581 Irp->UserEvent = (LocalEvent) ? Event : NULL;
1582 Irp->RequestorMode = PreviousMode;
1583 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
1584 Irp->Tail.Overlay.OriginalFileObject = FileObject;
1585 Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
1586
1587 /* Set up Stack Data */
1588 StackPtr = IoGetNextIrpStackLocation(Irp);
1590 StackPtr->FileObject = FileObject;
1591
1592 /* Call the Driver */
1594 Irp,
1595 FileObject,
1596 FALSE,
1598 !LocalEvent,
1600
1601 /* Check if this was async I/O */
1602 if (LocalEvent)
1603 {
1604 /* It was, finalize this request */
1606 Event,
1607 Irp,
1609 &KernelIosb,
1611 }
1612
1613 /* Return the Status */
1614 return Status;
1615}
1616
1617/*
1618 * @implemented
1619 */
1621NTAPI
1631{
1632 PIRP Irp;
1633 PKEVENT Event = NULL;
1636 PIO_STACK_LOCATION IoStack;
1639 BOOLEAN LockedForSync = FALSE;
1640 PAGED_CODE();
1641 IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
1642
1643 /* Check if we're called from user mode */
1644 if (PreviousMode != KernelMode)
1645 {
1646 /* Enter SEH for probing */
1647 _SEH2_TRY
1648 {
1649 /* Probe the I/O STatus block */
1651
1652 /* Probe the buffer */
1654 }
1656 {
1657 /* Return the exception code */
1659 }
1660 _SEH2_END;
1661
1662 /* Check if CompletionFilter is valid */
1664 {
1666 }
1667 }
1668
1669 /* Get File Object */
1674 (PVOID*)&FileObject,
1675 NULL);
1676 if (!NT_SUCCESS(Status)) return Status;
1677
1678 /* Can't use an I/O completion port and an APC at the same time */
1679 if ((FileObject->CompletionContext) && (ApcRoutine))
1680 {
1681 /* Fail */
1684 }
1685
1686 /* Check if we have an event handle */
1687 if (EventHandle)
1688 {
1689 /* Reference it */
1694 (PVOID *)&Event,
1695 NULL);
1696 if (Status != STATUS_SUCCESS)
1697 {
1699 return Status;
1700 }
1702 }
1703
1704 /* Check if we should use Sync IO or not */
1705 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
1706 {
1707 /* Lock it */
1709 if (Status != STATUS_SUCCESS)
1710 {
1713 return Status;
1714 }
1715 LockedForSync = TRUE;
1716 }
1717
1718 /* Clear File Object event */
1719 KeClearEvent(&FileObject->Event);
1720
1721 /* Get the device object */
1723
1724 /* Allocate the IRP */
1725 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
1727
1728 /* Set up the IRP */
1729 Irp->RequestorMode = PreviousMode;
1730 Irp->UserIosb = IoStatusBlock;
1731 Irp->UserEvent = Event;
1732 Irp->UserBuffer = Buffer;
1733 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
1734 Irp->Tail.Overlay.OriginalFileObject = FileObject;
1735 Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
1736 Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
1737
1738 /* Set up Stack Data */
1739 IoStack = IoGetNextIrpStackLocation(Irp);
1742 IoStack->FileObject = FileObject;
1743
1744 /* Set parameters */
1745 IoStack->Parameters.NotifyDirectory.CompletionFilter = CompletionFilter;
1746 IoStack->Parameters.NotifyDirectory.Length = BufferSize;
1747 if (WatchTree) IoStack->Flags = SL_WATCH_TREE;
1748
1749 /* Perform the call */
1751 Irp,
1752 FileObject,
1753 FALSE,
1755 LockedForSync,
1757}
1758
1759/*
1760 * @implemented
1761 */
1763NTAPI
1771 IN ULONG Key,
1774{
1776 PLARGE_INTEGER LocalLength = NULL;
1777 PIRP Irp;
1778 PIO_STACK_LOCATION StackPtr;
1780 PKEVENT Event = NULL;
1781 BOOLEAN LockedForSync = FALSE;
1783 LARGE_INTEGER CapturedByteOffset, CapturedLength;
1787 PAGED_CODE();
1788 CapturedByteOffset.QuadPart = 0;
1789 CapturedLength.QuadPart = 0;
1790 IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
1791
1792 /* Get File Object */
1794 0,
1797 (PVOID*)&FileObject,
1799 if (!NT_SUCCESS(Status)) return Status;
1800
1801 /* Check if we're called from user mode */
1802 if (PreviousMode != KernelMode)
1803 {
1804 /* Can't use an I/O completion port and an APC at the same time */
1805 if ((FileObject->CompletionContext) && (ApcRoutine))
1806 {
1807 /* Fail */
1810 }
1811
1812 /* Must have either FILE_READ_DATA or FILE_WRITE_DATA access */
1813 if (!(HandleInformation.GrantedAccess &
1815 {
1817 return STATUS_ACCESS_DENIED;
1818 }
1819
1820 /* Enter SEH for probing */
1821 _SEH2_TRY
1822 {
1823 /* Probe the I/O STatus block */
1825
1826 /* Probe and capture the large integers */
1827 CapturedByteOffset = ProbeForReadLargeInteger(ByteOffset);
1828 CapturedLength = ProbeForReadLargeInteger(Length);
1829 }
1831 {
1832 /* Dereference the object and return exception code */
1835 }
1836 _SEH2_END;
1837 }
1838 else
1839 {
1840 /* Otherwise, capture them directly */
1841 CapturedByteOffset = *ByteOffset;
1842 CapturedLength = *Length;
1843 }
1844
1845 /* Check if we have an event handle */
1846 if (EventHandle)
1847 {
1848 /* Reference it */
1853 (PVOID *)&Event,
1854 NULL);
1855 if (Status != STATUS_SUCCESS) return Status;
1857 }
1858
1859 /* Get the device object */
1861
1862 /* Try to do it the FastIO way if possible */
1863 FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch;
1865 {
1866 IO_STATUS_BLOCK KernelIosb;
1867
1869 &CapturedByteOffset,
1870 &CapturedLength,
1872 Key,
1875 &KernelIosb,
1876 DeviceObject))
1877 {
1878 /* Write the IOSB back */
1879 _SEH2_TRY
1880 {
1881 *IoStatusBlock = KernelIosb;
1882 }
1884 {
1885 KernelIosb.Status = _SEH2_GetExceptionCode();
1886 }
1887 _SEH2_END;
1888
1889 /* If we had an event, signal it */
1890 if (EventHandle)
1891 {
1894 }
1895
1896 /* Set completion if required */
1897 if (FileObject->CompletionContext != NULL && ApcContext != NULL)
1898 {
1899 if (!NT_SUCCESS(IoSetIoCompletion(FileObject->CompletionContext->Port,
1900 FileObject->CompletionContext->Key,
1901 ApcContext,
1902 KernelIosb.Status,
1903 KernelIosb.Information,
1904 TRUE)))
1905 {
1907 }
1908 }
1909
1910 FileObject->LockOperation = TRUE;
1911
1912 /* We're done with FastIO! */
1914 return KernelIosb.Status;
1915 }
1916 }
1917
1918 /* Check if we should use Sync IO or not */
1919 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
1920 {
1921 /* Lock it */
1923 if (Status != STATUS_SUCCESS)
1924 {
1927 return Status;
1928 }
1929 LockedForSync = TRUE;
1930 }
1931
1932 /* Clear File Object event */
1933 KeClearEvent(&FileObject->Event);
1934 FileObject->LockOperation = TRUE;
1935
1936 /* Allocate the IRP */
1937 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
1939
1940 /* Set up the IRP */
1941 Irp->RequestorMode = PreviousMode;
1942 Irp->UserIosb = IoStatusBlock;
1943 Irp->UserEvent = Event;
1944 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
1945 Irp->Tail.Overlay.OriginalFileObject = FileObject;
1946 Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
1947 Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
1948
1949 /* Set up Stack Data */
1950 StackPtr = IoGetNextIrpStackLocation(Irp);
1952 StackPtr->MinorFunction = IRP_MN_LOCK;
1953 StackPtr->FileObject = FileObject;
1954
1955 /* Allocate local buffer */
1956 LocalLength = ExAllocatePoolWithTag(NonPagedPool,
1957 sizeof(LARGE_INTEGER),
1958 TAG_LOCK);
1959 if (!LocalLength)
1960 {
1961 /* Allocating failed, clean up and return failure */
1964 }
1965
1966 /* Set the length */
1967 *LocalLength = CapturedLength;
1968 Irp->Tail.Overlay.AuxiliaryBuffer = (PVOID)LocalLength;
1969 StackPtr->Parameters.LockControl.Length = LocalLength;
1970
1971 /* Set Parameters */
1972 StackPtr->Parameters.LockControl.ByteOffset = CapturedByteOffset;
1973 StackPtr->Parameters.LockControl.Key = Key;
1974
1975 /* Set Flags */
1976 if (FailImmediately) StackPtr->Flags = SL_FAIL_IMMEDIATELY;
1977 if (ExclusiveLock) StackPtr->Flags |= SL_EXCLUSIVE_LOCK;
1978
1979 /* Perform the call */
1981 Irp,
1982 FileObject,
1983 FALSE,
1985 LockedForSync,
1987}
1988
1989/*
1990 * @implemented
1991 */
1993NTAPI
2000 IN ULONG Length,
2005{
2006 PIRP Irp;
2009 PIO_STACK_LOCATION StackPtr;
2012 BOOLEAN LockedForSynch = FALSE;
2013 PKEVENT Event = NULL;
2014 volatile PVOID AuxBuffer = NULL;
2015 PMDL Mdl;
2016 UNICODE_STRING CapturedFileName;
2017 PUNICODE_STRING SearchPattern;
2018 PAGED_CODE();
2019 IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
2020
2021 /* Check if we came from user mode */
2022 if (PreviousMode != KernelMode)
2023 {
2024 /* Enter SEH for probing */
2025 _SEH2_TRY
2026 {
2027 /* Probe the I/O Status Block */
2029
2030 /* Probe the file information */
2032
2033 /* Check if we have a file name */
2034 if (FileName)
2035 {
2036 /* Capture it */
2037 CapturedFileName = ProbeForReadUnicodeString(FileName);
2038 if (CapturedFileName.Length)
2039 {
2040 /* Probe its buffer */
2041 ProbeForRead(CapturedFileName.Buffer,
2042 CapturedFileName.Length,
2043 1);
2044 }
2045
2046 /* Allocate the auxiliary buffer */
2048 CapturedFileName.Length +
2049 sizeof(UNICODE_STRING),
2050 TAG_SYSB);
2051 RtlCopyMemory((PVOID)((ULONG_PTR)AuxBuffer +
2052 sizeof(UNICODE_STRING)),
2053 CapturedFileName.Buffer,
2054 CapturedFileName.Length);
2055
2056 /* Setup the search pattern */
2057 SearchPattern = (PUNICODE_STRING)AuxBuffer;
2058 SearchPattern->Buffer = (PWCHAR)((ULONG_PTR)AuxBuffer +
2059 sizeof(UNICODE_STRING));
2060 SearchPattern->Length = CapturedFileName.Length;
2061 SearchPattern->MaximumLength = CapturedFileName.Length;
2062 }
2063 }
2065 {
2066 /* Free buffer and return the exception code */
2067 if (AuxBuffer) ExFreePoolWithTag(AuxBuffer, TAG_SYSB);
2069 }
2070 _SEH2_END;
2071 }
2072
2073 /* Check input parameters */
2074
2075 switch (FileInformationClass)
2076 {
2077#define CHECK_LENGTH(class, struct) \
2078 case class: \
2079 if (Length < sizeof(struct)) \
2080 return STATUS_INFO_LENGTH_MISMATCH; \
2081 break
2088 default:
2089 break;
2090#undef CHECK_LENGTH
2091 }
2092
2093 /* Get File Object */
2098 (PVOID *)&FileObject,
2099 NULL);
2100 if (!NT_SUCCESS(Status))
2101 {
2102 /* Fail */
2103 if (AuxBuffer) ExFreePoolWithTag(AuxBuffer, TAG_SYSB);
2104 return Status;
2105 }
2106
2107 /* Are there two associated completion routines? */
2108 if (FileObject->CompletionContext != NULL && ApcRoutine != NULL)
2109 {
2111 if (AuxBuffer) ExFreePoolWithTag(AuxBuffer, TAG_SYSB);
2113 }
2114
2115 /* Check if we have an even handle */
2116 if (EventHandle)
2117 {
2118 /* Get its pointer */
2123 (PVOID *)&Event,
2124 NULL);
2125 if (!NT_SUCCESS(Status))
2126 {
2127 /* Fail */
2128 if (AuxBuffer) ExFreePoolWithTag(AuxBuffer, TAG_SYSB);
2130 return Status;
2131 }
2132
2133 /* Clear it */
2135 }
2136
2137 /* Check if this is a file that was opened for Synch I/O */
2138 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
2139 {
2140 /* Lock it */
2142 if (Status != STATUS_SUCCESS)
2143 {
2146 if (AuxBuffer) ExFreePoolWithTag(AuxBuffer, TAG_SYSB);
2147 return Status;
2148 }
2149
2150 /* Remember to unlock later */
2151 LockedForSynch = TRUE;
2152 }
2153
2154 /* Get the device object */
2156
2157 /* Clear the File Object's event */
2158 KeClearEvent(&FileObject->Event);
2159
2160 /* Allocate the IRP */
2161 Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);
2162 if (!Irp) return IopCleanupFailedIrp(FileObject, EventHandle, AuxBuffer);
2163
2164 /* Set up the IRP */
2165 Irp->RequestorMode = PreviousMode;
2166 Irp->UserIosb = IoStatusBlock;
2167 Irp->UserEvent = Event;
2168 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
2169 Irp->Tail.Overlay.OriginalFileObject = FileObject;
2170 Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
2171 Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
2172 Irp->MdlAddress = NULL;
2173 Irp->Tail.Overlay.AuxiliaryBuffer = AuxBuffer;
2174 Irp->AssociatedIrp.SystemBuffer = NULL;
2175
2176 /* Check if this is buffered I/O */
2177 if (DeviceObject->Flags & DO_BUFFERED_IO)
2178 {
2179 /* Allocate a buffer */
2180 Irp->AssociatedIrp.SystemBuffer = ExAllocatePoolWithTag(NonPagedPool,
2181 Length,
2182 TAG_SYSB);
2183 if (!Irp->AssociatedIrp.SystemBuffer)
2184 {
2185 /* Allocating failed, clean up and return the exception code */
2187 if (AuxBuffer) ExFreePoolWithTag(AuxBuffer, TAG_SYSB);
2188
2189 /* Return the exception code */
2191 }
2192
2193 /* Set the buffer and flags */
2194 Irp->UserBuffer = FileInformation;
2195 Irp->Flags = (IRP_BUFFERED_IO |
2198 }
2199 else if (DeviceObject->Flags & DO_DIRECT_IO)
2200 {
2201 _SEH2_TRY
2202 {
2203 /* Allocate an MDL */
2207 }
2209 {
2210 /* Allocating failed, clean up and return the exception code */
2213 }
2214 _SEH2_END;
2215 }
2216 else
2217 {
2218 /* No allocation flags, and use the buffer directly */
2219 Irp->UserBuffer = FileInformation;
2220 }
2221
2222 /* Set up Stack Data */
2223 StackPtr = IoGetNextIrpStackLocation(Irp);
2224 StackPtr->FileObject = FileObject;
2227
2228 /* Set Parameters */
2229 StackPtr->Parameters.QueryDirectory.FileInformationClass =
2231 StackPtr->Parameters.QueryDirectory.FileName = AuxBuffer;
2232 StackPtr->Parameters.QueryDirectory.FileIndex = 0;
2233 StackPtr->Parameters.QueryDirectory.Length = Length;
2234 StackPtr->Flags = 0;
2235 if (RestartScan) StackPtr->Flags = SL_RESTART_SCAN;
2237
2238 /* Set deferred I/O */
2239 Irp->Flags |= IRP_DEFER_IO_COMPLETION;
2240
2241 /* Perform the call */
2243 Irp,
2244 FileObject,
2245 TRUE,
2247 LockedForSynch,
2249}
2250
2251/*
2252 * @unimplemented
2253 */
2255NTAPI
2259 IN ULONG Length,
2261 IN PVOID EaList OPTIONAL,
2265{
2268}
2269
2270/*
2271 * @implemented
2272 */
2274NTAPI
2278 IN ULONG Length,
2280{
2284 PIRP Irp;
2286 PIO_STACK_LOCATION StackPtr;
2288 PKEVENT Event = NULL;
2289 BOOLEAN LocalEvent = FALSE;
2290 PKNORMAL_ROUTINE NormalRoutine;
2291 PVOID NormalContext;
2292 KIRQL OldIrql;
2293 IO_STATUS_BLOCK KernelIosb;
2294 BOOLEAN CallDriver = TRUE;
2295 PFILE_ACCESS_INFORMATION AccessBuffer;
2296 PFILE_MODE_INFORMATION ModeBuffer;
2297 PFILE_ALIGNMENT_INFORMATION AlignmentBuffer;
2298 PFILE_ALL_INFORMATION AllBuffer;
2300 PAGED_CODE();
2301 IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
2302
2303 /* Check if we're called from user mode */
2304 if (PreviousMode != KernelMode)
2305 {
2306 /* Validate the information class */
2307 if ((FileInformationClass < 0) ||
2310 {
2311 /* Invalid class */
2313 }
2314
2315 /* Validate the length */
2317 {
2318 /* Invalid length */
2320 }
2321
2322 /* Enter SEH for probing */
2323 _SEH2_TRY
2324 {
2325 /* Probe the I/O Status block */
2327
2328 /* Probe the information */
2330 }
2332 {
2333 /* Return the exception code */
2335 }
2336 _SEH2_END;
2337 }
2338#if DBG
2339 else
2340 {
2341 /* Validate the information class */
2342 if ((FileInformationClass < 0) ||
2345 {
2346 /* Invalid class */
2348 }
2349
2350 /* Validate the length */
2352 {
2353 /* Invalid length */
2355 }
2356 }
2357#endif
2358
2359 /* Reference the Handle */
2365 (PVOID *)&FileObject,
2367 if (!NT_SUCCESS(Status)) return Status;
2368
2369 /* Check if this is a direct open or not */
2370 if (FileObject->Flags & FO_DIRECT_DEVICE_OPEN)
2371 {
2372 /* Get the device object */
2374 }
2375 else
2376 {
2377 /* Get the device object */
2379 }
2380
2381 /* Check if this is a file that was opened for Synch I/O */
2382 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
2383 {
2384 /* Lock it */
2386 if (Status != STATUS_SUCCESS)
2387 {
2389 return Status;
2390 }
2391
2392 /* Check if the caller just wants the position */
2394 {
2395 /* Protect write in SEH */
2396 _SEH2_TRY
2397 {
2398 /* Write the offset */
2400 CurrentByteOffset = FileObject->CurrentByteOffset;
2401
2402 /* Fill out the I/O Status Block */
2405 }
2407 {
2408 /* Get the exception code */
2410 }
2411 _SEH2_END;
2412
2413 /* Release the file lock, dereference the file and return */
2416 return Status;
2417 }
2418 }
2419 else
2420 {
2421 /* Use local event */
2423 if (!Event)
2424 {
2427 }
2429 LocalEvent = TRUE;
2430 }
2431
2432 /* Check if FastIO is possible for the two available information classes */
2433 FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch;
2434 if (FastIoDispatch != NULL &&
2437 {
2439
2441 {
2444 &KernelIosb,
2445 DeviceObject);
2446 }
2447 else
2448 {
2451 &KernelIosb,
2452 DeviceObject);
2453 }
2454
2455 /* If call succeed */
2456 if (Success)
2457 {
2458 /* Write the IOSB back */
2459 _SEH2_TRY
2460 {
2461 *IoStatusBlock = KernelIosb;
2462 }
2464 {
2465 KernelIosb.Status = _SEH2_GetExceptionCode();
2466 }
2467 _SEH2_END;
2468
2469 /* Free the event if we had one */
2470 if (LocalEvent)
2471 {
2473 }
2474
2475 /* If FO was locked, unlock it */
2476 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
2477 {
2479 }
2480
2481 /* We're done with FastIO! */
2483 return KernelIosb.Status;
2484 }
2485 }
2486
2487 /* Clear the File Object event */
2488 KeClearEvent(&FileObject->Event);
2489
2490 /* Allocate the IRP */
2491 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
2493
2494 /* Set the IRP */
2495 Irp->Tail.Overlay.OriginalFileObject = FileObject;
2496 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
2497 Irp->RequestorMode = PreviousMode;
2498 Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
2499 Irp->Flags = (LocalEvent) ? IRP_SYNCHRONOUS_API : 0;
2500 Irp->UserIosb = (LocalEvent) ? &KernelIosb : IoStatusBlock;
2501 Irp->UserEvent = (LocalEvent) ? Event : NULL;
2502 Irp->AssociatedIrp.SystemBuffer = NULL;
2503 Irp->MdlAddress = NULL;
2504 Irp->UserBuffer = FileInformation;
2505
2506 /* Set the Stack Data */
2507 StackPtr = IoGetNextIrpStackLocation(Irp);
2509 StackPtr->FileObject = FileObject;
2510
2511 /* Enter SEH */
2512 _SEH2_TRY
2513 {
2514 /* Allocate a buffer */
2515 Irp->AssociatedIrp.SystemBuffer =
2517 Length,
2518 TAG_SYSB);
2519 }
2521 {
2522 /* Allocating failed, clean up and return the exception code */
2525 }
2526 _SEH2_END;
2527
2528 /* Set the flags */
2529 Irp->Flags |= (IRP_BUFFERED_IO |
2533
2534 /* Set the Parameters */
2535 StackPtr->Parameters.QueryFile.FileInformationClass = FileInformationClass;
2536 StackPtr->Parameters.QueryFile.Length = Length;
2537
2538 /* Queue the IRP */
2540
2541 /* Update operation counts */
2543
2544 /* Fill in file information before calling the driver.
2545 See 'File System Internals' page 485.*/
2547 {
2548 AccessBuffer = Irp->AssociatedIrp.SystemBuffer;
2549 AccessBuffer->AccessFlags = HandleInformation.GrantedAccess;
2550 Irp->IoStatus.Information = sizeof(FILE_ACCESS_INFORMATION);
2551 CallDriver = FALSE;
2552 }
2554 {
2555 ModeBuffer = Irp->AssociatedIrp.SystemBuffer;
2556 ModeBuffer->Mode = IopGetFileMode(FileObject);
2557 Irp->IoStatus.Information = sizeof(FILE_MODE_INFORMATION);
2558 CallDriver = FALSE;
2559 }
2561 {
2562 AlignmentBuffer = Irp->AssociatedIrp.SystemBuffer;
2563 AlignmentBuffer->AlignmentRequirement = DeviceObject->AlignmentRequirement;
2564 Irp->IoStatus.Information = sizeof(FILE_ALIGNMENT_INFORMATION);
2565 CallDriver = FALSE;
2566 }
2568 {
2569 AllBuffer = Irp->AssociatedIrp.SystemBuffer;
2570 AllBuffer->AccessInformation.AccessFlags = HandleInformation.GrantedAccess;
2572 AllBuffer->AlignmentInformation.AlignmentRequirement = DeviceObject->AlignmentRequirement;
2573 Irp->IoStatus.Information = sizeof(FILE_ACCESS_INFORMATION) +
2574 sizeof(FILE_MODE_INFORMATION) +
2576 }
2577
2578 /* Call the Driver */
2579 if (CallDriver)
2580 {
2582 }
2583 else
2584 {
2586 Irp->IoStatus.Status = STATUS_SUCCESS;
2587 }
2588
2589 if (Status == STATUS_PENDING)
2590 {
2591 /* Check if this was async I/O */
2592 if (LocalEvent)
2593 {
2594 /* Then to a non-alertable wait */
2596 Executive,
2598 FALSE,
2599 NULL);
2600 if (Status == STATUS_USER_APC)
2601 {
2602 /* Abort the request */
2604 }
2605
2606 /* Set the final status */
2607 Status = KernelIosb.Status;
2608
2609 /* Enter SEH to write the IOSB back */
2610 _SEH2_TRY
2611 {
2612 /* Write it back to the caller */
2613 *IoStatusBlock = KernelIosb;
2614 }
2616 {
2617 /* Get the exception code */
2619 }
2620 _SEH2_END;
2621
2622 /* Free the event */
2624 }
2625 else
2626 {
2627 /* Wait for the IRP */
2629 Executive,
2631 (FileObject->Flags &
2632 FO_ALERTABLE_IO) != 0,
2633 NULL);
2635 {
2636 /* Abort the request */
2638 }
2639
2640 /* Set the final status */
2641 Status = FileObject->FinalStatus;
2642
2643 /* Release the file lock */
2645 }
2646 }
2647 else
2648 {
2649 /* Free the event if we had one */
2650 if (LocalEvent)
2651 {
2652 /* Clear it in the IRP for completion */
2653 Irp->UserEvent = NULL;
2655 }
2656
2657 /* Set the caller IOSB */
2658 Irp->UserIosb = IoStatusBlock;
2659
2660 /* The IRP wasn't completed, complete it ourselves */
2661 NormalRoutine = NULL;
2662 NormalContext = NULL;
2664 IopCompleteRequest(&Irp->Tail.Apc,
2665 &NormalRoutine,
2666 &NormalContext,
2667 (PVOID*)&FileObject,
2668 &NormalContext);
2670
2671 /* Release the file object if we had locked it*/
2672 if (!LocalEvent) IopUnlockFileObject(FileObject);
2673 }
2674
2675 /* Return the Status */
2676 return Status;
2677}
2678
2679/*
2680 * @unimplemented
2681 */
2683NTAPI
2687 IN ULONG Length,
2689 IN PVOID SidList OPTIONAL,
2693{
2696}
2697
2698/*
2699 * @implemented
2700 */
2702NTAPI
2709 IN ULONG Length,
2712{
2715 PIRP Irp;
2717 PIO_STACK_LOCATION StackPtr;
2719 PKEVENT EventObject = NULL;
2720 LARGE_INTEGER CapturedByteOffset;
2721 ULONG CapturedKey = 0;
2722 BOOLEAN Synchronous = FALSE;
2723 PMDL Mdl;
2725 IO_STATUS_BLOCK KernelIosb;
2727
2728 PAGED_CODE();
2729 CapturedByteOffset.QuadPart = 0;
2730 IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
2731
2732 /* Get File Object */
2737 (PVOID*)&FileObject,
2738 NULL);
2739 if (!NT_SUCCESS(Status)) return Status;
2740
2741 /* Get the device object */
2743
2744 /* Validate User-Mode Buffers */
2745 if (PreviousMode != KernelMode)
2746 {
2747 _SEH2_TRY
2748 {
2749 /* Probe the status block */
2751
2752 /* Probe the read buffer */
2754
2755 /* Check if we got a byte offset */
2756 if (ByteOffset)
2757 {
2758 /* Capture and probe it */
2759 CapturedByteOffset = ProbeForReadLargeInteger(ByteOffset);
2760 }
2761
2762 /* Can't use an I/O completion port and an APC at the same time */
2763 if ((FileObject->CompletionContext) && (ApcRoutine))
2764 {
2765 /* Fail */
2768 }
2769
2770 /* Perform additional checks for non-cached file access */
2772 {
2773 /* Fail if Length is not sector size aligned
2774 * Perform a quick check for 2^ sector sizes
2775 * If it fails, try a more standard way
2776 */
2777 if ((DeviceObject->SectorSize != 0) &&
2778 ((DeviceObject->SectorSize - 1) & Length) != 0)
2779 {
2780 if (Length % DeviceObject->SectorSize != 0)
2781 {
2782 /* Release the file object and and fail */
2785 }
2786 }
2787
2788 /* Fail if buffer doesn't match alignment requirements */
2789 if (((ULONG_PTR)Buffer & DeviceObject->AlignmentRequirement) != 0)
2790 {
2791 /* Release the file object and and fail */
2794 }
2795
2796 if (ByteOffset)
2797 {
2798 /* Fail if ByteOffset is not sector size aligned */
2799 if ((DeviceObject->SectorSize != 0) &&
2800 (CapturedByteOffset.QuadPart % DeviceObject->SectorSize != 0))
2801 {
2802 /* Release the file object and and fail */
2805 }
2806 }
2807 }
2808
2809 /* Capture and probe the key */
2810 if (Key) CapturedKey = ProbeForReadUlong(Key);
2811 }
2813 {
2814 /* Release the file object and return the exception code */
2817 }
2818 _SEH2_END;
2819 }
2820 else
2821 {
2822 /* Kernel mode: capture directly */
2823 if (ByteOffset) CapturedByteOffset = *ByteOffset;
2824 if (Key) CapturedKey = *Key;
2825 }
2826
2827 /* Check for invalid offset */
2828 if ((CapturedByteOffset.QuadPart < 0) && (CapturedByteOffset.QuadPart != -2))
2829 {
2830 /* -2 is FILE_USE_FILE_POINTER_POSITION */
2833 }
2834
2835 /* Check for event */
2836 if (Event)
2837 {
2838 /* Reference it */
2843 (PVOID*)&EventObject,
2844 NULL);
2845 if (!NT_SUCCESS(Status))
2846 {
2847 /* Fail */
2849 return Status;
2850 }
2851
2852 /* Otherwise reset the event */
2853 KeClearEvent(EventObject);
2854 }
2855
2856 /* Check if we should use Sync IO or not */
2857 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
2858 {
2859 /* Lock the file object */
2861 if (Status != STATUS_SUCCESS)
2862 {
2863 if (EventObject) ObDereferenceObject(EventObject);
2865 return Status;
2866 }
2867
2868 /* Check if we don't have a byte offset available */
2869 if (!(ByteOffset) ||
2870 ((CapturedByteOffset.u.LowPart == FILE_USE_FILE_POINTER_POSITION) &&
2871 (CapturedByteOffset.u.HighPart == -1)))
2872 {
2873 /* Use the Current Byte Offset instead */
2874 CapturedByteOffset = FileObject->CurrentByteOffset;
2875 }
2876
2877 /* If the file is cached, try fast I/O */
2878 if (FileObject->PrivateCacheMap)
2879 {
2880 /* Perform fast read */
2881 FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch;
2883
2885 &CapturedByteOffset,
2886 Length,
2887 TRUE,
2888 CapturedKey,
2889 Buffer,
2890 &KernelIosb,
2891 DeviceObject);
2892
2893 /* Only accept the result if we got a straightforward status */
2894 if (Success &&
2895 (KernelIosb.Status == STATUS_SUCCESS ||
2896 KernelIosb.Status == STATUS_BUFFER_OVERFLOW ||
2897 KernelIosb.Status == STATUS_END_OF_FILE))
2898 {
2899 /* Fast path -- update transfer & operation counts */
2902 (ULONG)KernelIosb.Information);
2903
2904 /* Enter SEH to write the IOSB back */
2905 _SEH2_TRY
2906 {
2907 /* Write it back to the caller */
2908 *IoStatusBlock = KernelIosb;
2909 }
2911 {
2912 /* The caller's IOSB was invalid, so fail */
2913 if (EventObject) ObDereferenceObject(EventObject);
2917 }
2918 _SEH2_END;
2919
2920 /* Signal the completion event */
2921 if (EventObject)
2922 {
2923 KeSetEvent(EventObject, 0, FALSE);
2924 ObDereferenceObject(EventObject);
2925 }
2926
2927 /* Clean up */
2930 return KernelIosb.Status;
2931 }
2932 }
2933
2934 /* Remember we are sync */
2935 Synchronous = TRUE;
2936 }
2937 else if (!(ByteOffset) &&
2938 !(FileObject->Flags & (FO_NAMED_PIPE | FO_MAILSLOT)))
2939 {
2940 /* Otherwise, this was async I/O without a byte offset, so fail */
2941 if (EventObject) ObDereferenceObject(EventObject);
2944 }
2945
2946 /* Clear the File Object's event */
2947 KeClearEvent(&FileObject->Event);
2948
2949 /* Allocate the IRP */
2950 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
2951 if (!Irp) return IopCleanupFailedIrp(FileObject, EventObject, NULL);
2952
2953 /* Set the IRP */
2954 Irp->Tail.Overlay.OriginalFileObject = FileObject;
2955 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
2956 Irp->RequestorMode = PreviousMode;
2957 Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
2958 Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
2959 Irp->UserIosb = IoStatusBlock;
2960 Irp->UserEvent = EventObject;
2961 Irp->PendingReturned = FALSE;
2962 Irp->Cancel = FALSE;
2963 Irp->CancelRoutine = NULL;
2964 Irp->AssociatedIrp.SystemBuffer = NULL;
2965 Irp->MdlAddress = NULL;
2966
2967 /* Set the Stack Data */
2968 StackPtr = IoGetNextIrpStackLocation(Irp);
2969 StackPtr->MajorFunction = IRP_MJ_READ;
2970 StackPtr->FileObject = FileObject;
2971 StackPtr->Parameters.Read.Key = CapturedKey;
2972 StackPtr->Parameters.Read.Length = Length;
2973 StackPtr->Parameters.Read.ByteOffset = CapturedByteOffset;
2974
2975 /* Check if this is buffered I/O */
2976 if (DeviceObject->Flags & DO_BUFFERED_IO)
2977 {
2978 /* Check if we have a buffer length */
2979 if (Length)
2980 {
2981 /* Enter SEH */
2982 _SEH2_TRY
2983 {
2984 /* Allocate a buffer */
2985 Irp->AssociatedIrp.SystemBuffer =
2987 Length,
2988 TAG_SYSB);
2989 }
2991 {
2992 /* Allocating failed, clean up and return the exception code */
2995 }
2996 _SEH2_END;
2997
2998 /* Set the buffer and flags */
2999 Irp->UserBuffer = Buffer;
3000 Irp->Flags = (IRP_BUFFERED_IO |
3003 }
3004 else
3005 {
3006 /* Not reading anything */
3008 }
3009 }
3010 else if (DeviceObject->Flags & DO_DIRECT_IO)
3011 {
3012 /* Check if we have a buffer length */
3013 if (Length)
3014 {
3015 _SEH2_TRY
3016 {
3017 /* Allocate an MDL */
3019 if (!Mdl)
3022 }
3024 {
3025 /* Allocating failed, clean up and return the exception code */
3028 }
3029 _SEH2_END;
3030
3031 }
3032
3033 /* No allocation flags */
3034 Irp->Flags = 0;
3035 }
3036 else
3037 {
3038 /* No allocation flags, and use the buffer directly */
3039 Irp->Flags = 0;
3040 Irp->UserBuffer = Buffer;
3041 }
3042
3043 /* Now set the deferred read flags */
3045
3047
3048 /* Perform the call */
3050 Irp,
3051 FileObject,
3052 TRUE,
3054 Synchronous,
3056}
3057
3058/*
3059 * @unimplemented
3060 */
3062NTAPI
3065 IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
3066 IN PVOID UserApcContext OPTIONAL,
3067 OUT PIO_STATUS_BLOCK UserIoStatusBlock,
3068 IN FILE_SEGMENT_ELEMENT BufferDescription [],
3072{
3075}
3076
3077/*
3078 * @unimplemented
3079 */
3081NTAPI
3085 IN ULONG EaBufferSize)
3086{
3089}
3090
3091/*
3092 * @implemented
3093 */
3095NTAPI
3099 IN ULONG Length,
3101{
3104 PIRP Irp;
3106 PIO_STACK_LOCATION StackPtr;
3108 PKEVENT Event = NULL;
3109 BOOLEAN LocalEvent = FALSE;
3110 PKNORMAL_ROUTINE NormalRoutine;
3111 PVOID NormalContext;
3112 KIRQL OldIrql;
3113 IO_STATUS_BLOCK KernelIosb;
3114 PVOID Queue;
3117 PFILE_RENAME_INFORMATION RenameInfo;
3119 PAGED_CODE();
3120 IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
3121
3122 /* Check if we're called from user mode */
3123 if (PreviousMode != KernelMode)
3124 {
3125 /* Validate the information class */
3126 if ((FileInformationClass < 0) ||
3129 {
3130 /* Invalid class */
3132 }
3133
3134 /* Validate the length */
3136 {
3137 /* Invalid length */
3139 }
3140
3141 /* Enter SEH for probing */
3142 _SEH2_TRY
3143 {
3144 /* Probe the I/O Status block */
3146
3147 /* Probe the information */
3149 Length,
3150 (Length == sizeof(BOOLEAN)) ?
3151 sizeof(BOOLEAN) : sizeof(ULONG));
3152 }
3154 {
3155 /* Return the exception code */
3157 }
3158 _SEH2_END;
3159 }
3160 else
3161 {
3162 /* Validate the information class */
3163 if ((FileInformationClass < 0) ||
3166 {
3167 /* Invalid class */
3169 }
3170
3171 /* Validate the length */
3173 {
3174 /* Invalid length */
3176 }
3177 }
3178
3179 /* Reference the Handle */
3185 (PVOID *)&FileObject,
3186 NULL);
3187 if (!NT_SUCCESS(Status)) return Status;
3188
3189 /* Check if this is a direct open or not */
3190 if (FileObject->Flags & FO_DIRECT_DEVICE_OPEN)
3191 {
3192 /* Get the device object */
3194 }
3195 else
3196 {
3197 /* Get the device object */
3199 }
3200
3201 DPRINT("Will call: %p\n", DeviceObject);
3202 DPRINT("Associated driver: %p (%wZ)\n", DeviceObject->DriverObject, &DeviceObject->DriverObject->DriverName);
3203
3204 /* Check if this is a file that was opened for Synch I/O */
3205 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
3206 {
3207 /* Lock it */
3209 if (Status != STATUS_SUCCESS)
3210 {
3212 return Status;
3213 }
3214
3215 /* Check if the caller just wants the position */
3217 {
3218 /* Protect write in SEH */
3219 _SEH2_TRY
3220 {
3221 /* Write the offset */
3222 FileObject->CurrentByteOffset =
3224 CurrentByteOffset;
3225
3226 /* Fill out the I/O Status Block */
3229 }
3231 {
3232 /* Get the exception code */
3234 }
3235 _SEH2_END;
3236
3237 /* Update transfer count */
3239
3240 /* Release the file lock, dereference the file and return */
3243 return Status;
3244 }
3245 }
3246 else
3247 {
3248 /* Use local event */
3250 if (!Event)
3251 {
3254 }
3255
3257 LocalEvent = TRUE;
3258 }
3259
3260 /* Clear the File Object event */
3261 KeClearEvent(&FileObject->Event);
3262
3263 /* Allocate the IRP */
3264 Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);
3266
3267 /* Set the IRP */
3268 Irp->Tail.Overlay.OriginalFileObject = FileObject;
3269 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
3270 Irp->RequestorMode = PreviousMode;
3271 Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
3272 Irp->Flags = (LocalEvent) ? IRP_SYNCHRONOUS_API : 0;
3273 Irp->UserIosb = (LocalEvent) ? &KernelIosb : IoStatusBlock;
3274 Irp->UserEvent = (LocalEvent) ? Event : NULL;
3275 Irp->AssociatedIrp.SystemBuffer = NULL;
3276 Irp->MdlAddress = NULL;
3277 Irp->UserBuffer = FileInformation;
3278
3279 /* Set the Stack Data */
3280 StackPtr = IoGetNextIrpStackLocation(Irp);
3282 StackPtr->FileObject = FileObject;
3283
3284 /* Enter SEH */
3285 _SEH2_TRY
3286 {
3287 /* Allocate a buffer */
3288 Irp->AssociatedIrp.SystemBuffer =
3290 Length,
3291 TAG_SYSB);
3292
3293 /* Copy the data into it */
3294 RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
3296 Length);
3297 }
3299 {
3300 /* Allocating failed, clean up and return the exception code */
3303 }
3304 _SEH2_END;
3305
3306 /* Set the flags */
3307 Irp->Flags |= (IRP_BUFFERED_IO |
3310
3311 /* Set the Parameters */
3312 StackPtr->Parameters.SetFile.FileInformationClass = FileInformationClass;
3313 StackPtr->Parameters.SetFile.Length = Length;
3314
3315 /* Queue the IRP */
3317
3318 /* Update operation counts */
3320
3321 /* FIXME: Later, we can implement a lot of stuff here and avoid a driver call */
3322 /* Handle IO Completion Port quickly */
3324 {
3325 /* Check if the file object already has a completion port */
3326 if ((FileObject->Flags & FO_SYNCHRONOUS_IO) ||
3327 (FileObject->CompletionContext))
3328 {
3329 /* Fail */
3331 }
3332 else
3333 {
3334 /* Reference the Port */
3335 CompletionInfo = Irp->AssociatedIrp.SystemBuffer;
3336 Status = ObReferenceObjectByHandle(CompletionInfo->Port,
3340 (PVOID*)&Queue,
3341 NULL);
3342 if (NT_SUCCESS(Status))
3343 {
3344 /* Allocate the Context */
3346 sizeof(IO_COMPLETION_CONTEXT),
3347 IOC_TAG);
3348 if (Context)
3349 {
3350 /* Set the Data */
3351 Context->Key = CompletionInfo->Key;
3352 Context->Port = Queue;
3355 Context,
3356 NULL))
3357 {
3358 /*
3359 * Someone else set the completion port in the
3360 * meanwhile, so dereference the port and fail.
3361 */
3365 }
3366 }
3367 else
3368 {
3369 /* Dereference the Port now */
3372 }
3373 }
3374 }
3375
3376 /* Set the IRP Status */
3377 Irp->IoStatus.Status = Status;
3378 Irp->IoStatus.Information = 0;
3379 }
3383 {
3384 /* Get associated information */
3385 RenameInfo = Irp->AssociatedIrp.SystemBuffer;
3386
3387 /* Only rename if:
3388 * -> We have a name
3389 * -> In unicode
3390 * -> sizes are valid
3391 */
3392 if (RenameInfo->FileNameLength != 0 &&
3393 !(RenameInfo->FileNameLength & 1) &&
3395 {
3396 /* Properly set information received */
3398 {
3399 StackPtr->Parameters.SetFile.ClusterCount = ((PFILE_MOVE_CLUSTER_INFORMATION)RenameInfo)->ClusterCount;
3400 }
3401 else
3402 {
3403 StackPtr->Parameters.SetFile.ReplaceIfExists = RenameInfo->ReplaceIfExists;
3404 }
3405
3406 /* If we got fully path OR relative target, attempt a parent directory open */
3407 if (RenameInfo->FileName[0] == OBJ_NAME_PATH_SEPARATOR || RenameInfo->RootDirectory)
3408 {
3410 if (!NT_SUCCESS(Status))
3411 {
3412 Irp->IoStatus.Status = Status;
3413 }
3414 else
3415 {
3416 /* Call the Driver */
3418 }
3419 }
3420 else
3421 {
3422 /* Call the Driver */
3424 }
3425 }
3426 else
3427 {
3429 Irp->IoStatus.Status = Status;
3430 }
3431 }
3432 else
3433 {
3434 /* Call the Driver */
3436 }
3437
3438 /* Check if we're waiting for the IRP to complete */
3439 if (Status == STATUS_PENDING)
3440 {
3441 /* Check if this was async I/O */
3442 if (LocalEvent)
3443 {
3444 /* Then to a non-alertable wait */
3446 Executive,
3448 FALSE,
3449 NULL);
3450 if (Status == STATUS_USER_APC)
3451 {
3452 /* Abort the request */
3454 }
3455
3456 /* Set the final status */
3457 Status = KernelIosb.Status;
3458
3459 /* Enter SEH to write the IOSB back */
3460 _SEH2_TRY
3461 {
3462 /* Write it back to the caller */
3463 *IoStatusBlock = KernelIosb;
3464 }
3466 {
3467 /* Get the exception code */
3469 }
3470 _SEH2_END;
3471
3472 /* Free the event */
3474 }
3475 else
3476 {
3477 /* Wait for the IRP */
3479 Executive,
3481 (FileObject->Flags &
3482 FO_ALERTABLE_IO) != 0,
3483 NULL);
3485 {
3486 /* Abort the request */
3488 }
3489
3490 /* Set the final status */
3491 Status = FileObject->FinalStatus;
3492
3493 /* Release the file lock */
3495 }
3496 }
3497 else
3498 {
3499 /* Free the event if we had one */
3500 if (LocalEvent)
3501 {
3502 /* Clear it in the IRP for completion */
3503 Irp->UserEvent = NULL;
3505 }
3506
3507 /* Set the caller IOSB */
3508 Irp->UserIosb = IoStatusBlock;
3509
3510 /* The IRP wasn't completed, complete it ourselves */
3511 NormalRoutine = NULL;
3512 NormalContext = NULL;
3514 IopCompleteRequest(&Irp->Tail.Apc,
3515 &NormalRoutine,
3516 &NormalContext,
3517 (PVOID*)&FileObject,
3518 &NormalContext);
3520
3521 /* Release the file object if we had locked it*/
3522 if (!LocalEvent) IopUnlockFileObject(FileObject);
3523 }
3524
3525 if (TargetHandle != NULL)
3526 {
3528 }
3529
3530 /* Return the Status */
3531 return Status;
3532}
3533
3534/*
3535 * @unimplemented
3536 */
3538NTAPI
3541 IN PVOID Buffer,
3543{
3546}
3547
3548/*
3549 * @implemented
3550 */
3552NTAPI
3558{
3560 PLARGE_INTEGER LocalLength = NULL;
3561 PIRP Irp;
3562 PIO_STACK_LOCATION StackPtr;
3564 PKEVENT Event = NULL;
3565 BOOLEAN LocalEvent = FALSE;
3567 LARGE_INTEGER CapturedByteOffset, CapturedLength;
3570 IO_STATUS_BLOCK KernelIosb;
3572 PAGED_CODE();
3573 CapturedByteOffset.QuadPart = 0;
3574 CapturedLength.QuadPart = 0;
3575 IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
3576
3577 /* Get File Object */
3579 0,
3582 (PVOID*)&FileObject,
3584 if (!NT_SUCCESS(Status)) return Status;
3585
3586 /* Check if we're called from user mode */
3587 if (PreviousMode != KernelMode)
3588 {
3589 /* Must have either FILE_READ_DATA or FILE_WRITE_DATA access */
3590 if (!(HandleInformation.GrantedAccess &
3592 {
3594 return STATUS_ACCESS_DENIED;
3595 }
3596
3597 /* Enter SEH for probing */
3598 _SEH2_TRY
3599 {
3600 /* Probe the I/O Status block */
3602
3603 /* Probe and capture the large integers */
3604 CapturedByteOffset = ProbeForReadLargeInteger(ByteOffset);
3605 CapturedLength = ProbeForReadLargeInteger(Length);
3606 }
3608 {
3609 /* Dereference the object and return exception code */
3612 }
3613 _SEH2_END;
3614 }
3615 else
3616 {
3617 /* Otherwise, capture them directly */
3618 CapturedByteOffset = *ByteOffset;
3619 CapturedLength = *Length;
3620 }
3621
3622 /* Check if this is a direct open or not */
3623 if (FileObject->Flags & FO_DIRECT_DEVICE_OPEN)
3624 {
3626 }
3627 else
3628 {
3630 }
3631
3632 /* Try to do it the FastIO way if possible */
3633 FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch;
3635 {
3637 &CapturedByteOffset,
3638 &CapturedLength,
3640 Key,
3641 &KernelIosb,
3642 DeviceObject))
3643 {
3644 /* Write the IOSB back */
3645 _SEH2_TRY
3646 {
3647 *IoStatusBlock = KernelIosb;
3648 }
3650 {
3651 KernelIosb.Status = _SEH2_GetExceptionCode();
3652 }
3653 _SEH2_END;
3654
3655 /* We're done with FastIO! */
3657 return KernelIosb.Status;
3658 }
3659 }
3660
3661 /* Check if we should use Sync IO or not */
3662 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
3663 {
3664 /* Lock it */
3666 if (Status != STATUS_SUCCESS)
3667 {
3669 return Status;
3670 }
3671 }
3672 else
3673 {
3674 /* Use local event */
3676 if (!Event)
3677 {
3680 }
3682 LocalEvent = TRUE;
3683 }
3684
3685 /* Clear File Object event */
3686 KeClearEvent(&FileObject->Event);
3687
3688 /* Allocate the IRP */
3689 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
3691
3692 /* Set up the IRP */
3693 Irp->RequestorMode = PreviousMode;
3694 Irp->Flags = (LocalEvent) ? IRP_SYNCHRONOUS_API : 0;
3695 Irp->UserIosb = (LocalEvent) ? &KernelIosb : IoStatusBlock;
3696 Irp->UserEvent = (LocalEvent) ? Event : NULL;
3697 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
3698 Irp->Tail.Overlay.OriginalFileObject = FileObject;
3699 Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
3700
3701 /* Set up Stack Data */
3702 StackPtr = IoGetNextIrpStackLocation(Irp);
3705 StackPtr->FileObject = FileObject;
3706
3707 /* Enter SEH */
3708 _SEH2_TRY
3709 {
3710 /* Allocate a buffer */
3711 LocalLength = ExAllocatePoolWithTag(NonPagedPool,
3712 sizeof(LARGE_INTEGER),
3713 TAG_LOCK);
3714
3715 /* Set the length */
3716 *LocalLength = CapturedLength;
3717 Irp->Tail.Overlay.AuxiliaryBuffer = (PVOID)LocalLength;
3718 StackPtr->Parameters.LockControl.Length = LocalLength;
3719 }
3721 {
3722 /* Allocating failed, clean up and return the exception code */
3724 if (LocalLength) ExFreePoolWithTag(LocalLength, TAG_LOCK);
3725
3726 /* Return the exception code */
3728 }
3729 _SEH2_END;
3730
3731 /* Set Parameters */
3732 StackPtr->Parameters.LockControl.ByteOffset = CapturedByteOffset;
3733 StackPtr->Parameters.LockControl.Key = Key;
3734
3735 /* Call the Driver */
3737 Irp,
3738 FileObject,
3739 FALSE,
3741 !LocalEvent,
3743
3744 /* Check if this was async I/O */
3745 if (LocalEvent)
3746 {
3747 /* It was, finalize this request */
3749 Event,
3750 Irp,
3752 &KernelIosb,
3754 }
3755
3756 /* Return status */
3757 return Status;
3758}
3759
3760/*
3761 * @implemented
3762 */
3764NTAPI
3770 IN PVOID Buffer,
3771 IN ULONG Length,
3774{
3777 PIRP Irp;
3779 PIO_STACK_LOCATION StackPtr;
3781 PKEVENT EventObject = NULL;
3782 LARGE_INTEGER CapturedByteOffset;
3783 ULONG CapturedKey = 0;
3784 BOOLEAN Synchronous = FALSE;
3785 PMDL Mdl;
3786 OBJECT_HANDLE_INFORMATION ObjectHandleInfo;
3788 IO_STATUS_BLOCK KernelIosb;
3790
3791 PAGED_CODE();
3792 CapturedByteOffset.QuadPart = 0;
3793 IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
3794
3795 /* Get File Object for write */
3798 &FileObject,
3799 &ObjectHandleInfo);
3800 if (!NT_SUCCESS(Status)) return Status;
3801
3802 /* Get the device object */
3804
3805 /* Validate User-Mode Buffers */
3806 if (PreviousMode != KernelMode)
3807 {
3808 _SEH2_TRY
3809 {
3810 /* Probe the status block */
3812
3813 /* Probe the read buffer */
3815
3816 /* Check if we got a byte offset */
3817 if (ByteOffset)
3818 {
3819 /* Capture and probe it */
3820 CapturedByteOffset = ProbeForReadLargeInteger(ByteOffset);
3821 }
3822
3823 /* Can't use an I/O completion port and an APC at the same time */
3824 if ((FileObject->CompletionContext) && (ApcRoutine))
3825 {
3826 /* Fail */
3829 }
3830
3831 /* Perform additional checks for non-cached file access */
3833 {
3834 /* Fail if Length is not sector size aligned
3835 * Perform a quick check for 2^ sector sizes
3836 * If it fails, try a more standard way
3837 */
3838 if ((DeviceObject->SectorSize != 0) &&
3839 ((DeviceObject->SectorSize - 1) & Length) != 0)
3840 {
3841 if (Length % DeviceObject->SectorSize != 0)
3842 {
3843 /* Release the file object and and fail */
3846 }
3847 }
3848
3849 /* Fail if buffer doesn't match alignment requirements */
3850 if (((ULONG_PTR)Buffer & DeviceObject->AlignmentRequirement) != 0)
3851 {
3852 /* Release the file object and and fail */
3855 }
3856
3857 if (ByteOffset)
3858 {
3859 /* Fail if ByteOffset is not sector size aligned */
3860 if ((DeviceObject->SectorSize != 0) &&
3861 (CapturedByteOffset.QuadPart % DeviceObject->SectorSize != 0))
3862 {
3863 /* Only if that's not specific values for synchronous IO */
3864 if ((CapturedByteOffset.QuadPart != FILE_WRITE_TO_END_OF_FILE) &&
3865 (CapturedByteOffset.QuadPart != FILE_USE_FILE_POINTER_POSITION ||
3867 {
3868 /* Release the file object and and fail */
3871 }
3872 }
3873 }
3874 }
3875
3876 /* Capture and probe the key */
3877 if (Key) CapturedKey = ProbeForReadUlong(Key);
3878 }
3880 {
3881 /* Release the file object and return the exception code */
3884 }
3885 _SEH2_END;
3886 }
3887 else
3888 {
3889 /* Kernel mode: capture directly */
3890 if (ByteOffset) CapturedByteOffset = *ByteOffset;
3891 if (Key) CapturedKey = *Key;
3892 }
3893
3894 /* Check for invalid offset */
3895 if (CapturedByteOffset.QuadPart < -2)
3896 {
3897 /* -1 is FILE_WRITE_TO_END_OF_FILE */
3898 /* -2 is FILE_USE_FILE_POINTER_POSITION */
3901 }
3902
3903 /* Check if this is an append operation */
3904 if ((ObjectHandleInfo.GrantedAccess &
3906 {
3907 /* Give the drivers something to understand */
3908 CapturedByteOffset.u.LowPart = FILE_WRITE_TO_END_OF_FILE;
3909 CapturedByteOffset.u.HighPart = -1;
3910 }
3911
3912 /* Check for event */
3913 if (Event)
3914 {
3915 /* Reference it */
3920 (PVOID*)&EventObject,
3921 NULL);
3922 if (!NT_SUCCESS(Status))
3923 {
3924 /* Fail */
3926 return Status;
3927 }
3928
3929 /* Otherwise reset the event */
3930 KeClearEvent(EventObject);
3931 }
3932
3933 /* Check if we should use Sync IO or not */
3934 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
3935 {
3936 /* Lock the file object */
3938 if (Status != STATUS_SUCCESS)
3939 {
3940 if (EventObject) ObDereferenceObject(EventObject);
3942 return Status;
3943 }
3944
3945 /* Check if we don't have a byte offset available */
3946 if (!(ByteOffset) ||
3947 ((CapturedByteOffset.u.LowPart == FILE_USE_FILE_POINTER_POSITION) &&
3948 (CapturedByteOffset.u.HighPart == -1)))
3949 {
3950 /* Use the Current Byte Offset instead */
3951 CapturedByteOffset = FileObject->CurrentByteOffset;
3952 }
3953
3954 /* If the file is cached, try fast I/O */
3955 if (FileObject->PrivateCacheMap)
3956 {
3957 /* Perform fast write */
3958 FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch;
3960
3962 &CapturedByteOffset,
3963 Length,
3964 TRUE,
3965 CapturedKey,
3966 Buffer,
3967 &KernelIosb,
3968 DeviceObject);
3969
3970 /* Only accept the result if it was successful */
3971 if (Success &&
3972 KernelIosb.Status == STATUS_SUCCESS)
3973 {
3974 /* Fast path -- update transfer & operation counts */
3977 (ULONG)KernelIosb.Information);
3978
3979 /* Enter SEH to write the IOSB back */
3980 _SEH2_TRY
3981 {
3982 /* Write it back to the caller */
3983 *IoStatusBlock = KernelIosb;
3984 }
3986 {
3987 /* The caller's IOSB was invalid, so fail */
3988 if (EventObject) ObDereferenceObject(EventObject);
3992 }
3993 _SEH2_END;
3994
3995 /* Signal the completion event */
3996 if (EventObject)
3997 {
3998 KeSetEvent(EventObject, 0, FALSE);
3999 ObDereferenceObject(EventObject);
4000 }
4001
4002 /* Clean up */
4005 return KernelIosb.Status;
4006 }
4007 }
4008
4009 /* Remember we are sync */
4010 Synchronous = TRUE;
4011 }
4012 else if (!(ByteOffset) &&
4013 !(FileObject->Flags & (FO_NAMED_PIPE | FO_MAILSLOT)))
4014 {
4015 /* Otherwise, this was async I/O without a byte offset, so fail */
4016 if (EventObject) ObDereferenceObject(EventObject);
4019 }
4020
4021 /* Clear the File Object's event */
4022 KeClearEvent(&FileObject->Event);
4023
4024 /* Allocate the IRP */
4025 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
4026 if (!Irp) return IopCleanupFailedIrp(FileObject, EventObject, NULL);
4027
4028 /* Set the IRP */
4029 Irp->Tail.Overlay.OriginalFileObject = FileObject;
4030 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
4031 Irp->RequestorMode = PreviousMode;
4032 Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
4033 Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
4034 Irp->UserIosb = IoStatusBlock;
4035 Irp->UserEvent = EventObject;
4036 Irp->PendingReturned = FALSE;
4037 Irp->Cancel = FALSE;
4038 Irp->CancelRoutine = NULL;
4039 Irp->AssociatedIrp.SystemBuffer = NULL;
4040 Irp->MdlAddress = NULL;
4041
4042 /* Set the Stack Data */
4043 StackPtr = IoGetNextIrpStackLocation(Irp);
4044 StackPtr->MajorFunction = IRP_MJ_WRITE;
4045 StackPtr->FileObject = FileObject;
4046 StackPtr->Flags = FileObject->Flags & FO_WRITE_THROUGH ?
4047 SL_WRITE_THROUGH : 0;
4048 StackPtr->Parameters.Write.Key = CapturedKey;
4049 StackPtr->Parameters.Write.Length = Length;
4050 StackPtr->Parameters.Write.ByteOffset = CapturedByteOffset;
4051
4052 /* Check if this is buffered I/O */
4053 if (DeviceObject->Flags & DO_BUFFERED_IO)
4054 {
4055 /* Check if we have a buffer length */
4056 if (Length)
4057 {
4058 /* Enter SEH */
4059 _SEH2_TRY
4060 {
4061 /* Allocate a buffer */
4062 Irp->AssociatedIrp.SystemBuffer =
4064 Length,
4065 TAG_SYSB);
4066
4067 /* Copy the data into it */
4068 RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, Buffer, Length);
4069 }
4071 {
4072 /* Allocating failed, clean up and return the exception code */
4075 }
4076 _SEH2_END;
4077
4078 /* Set the flags */
4080 }
4081 else
4082 {
4083 /* Not writing anything */
4084 Irp->Flags = IRP_BUFFERED_IO;
4085 }
4086 }
4087 else if (DeviceObject->Flags & DO_DIRECT_IO)
4088 {
4089 /* Check if we have a buffer length */
4090 if (Length)
4091 {
4092 _SEH2_TRY
4093 {
4094 /* Allocate an MDL */
4096 if (!Mdl)
4099 }
4101 {
4102 /* Allocating failed, clean up and return the exception code */
4105 }
4106 _SEH2_END;
4107 }
4108
4109 /* No allocation flags */
4110 Irp->Flags = 0;
4111 }
4112 else
4113 {
4114 /* No allocation flags, and use the buffer directly */
4115 Irp->Flags = 0;
4116 Irp->UserBuffer = Buffer;
4117 }
4118
4119 /* Now set the deferred read flags */
4121
4123
4124 /* Perform the call */
4126 Irp,
4127 FileObject,
4128 TRUE,
4130 Synchronous,
4132}
4133
4135NTAPI
4138 IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
4139 IN PVOID UserApcContext OPTIONAL,
4140 OUT PIO_STATUS_BLOCK UserIoStatusBlock,
4141 IN FILE_SEGMENT_ELEMENT BufferDescription [],
4145{
4148}
4149
4150/*
4151 * @implemented
4152 */
4154NTAPI
4157 OUT PVOID FsInformation,
4158 IN ULONG Length,
4160{
4162 PIRP Irp;
4163 PIO_STACK_LOCATION StackPtr;
4165 PKEVENT Event = NULL;
4166 BOOLEAN LocalEvent = FALSE;
4169 IO_STATUS_BLOCK KernelIosb;
4170 PAGED_CODE();
4171 IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
4172
4173 /* Check if we're called from user mode */
4174 if (PreviousMode != KernelMode)
4175 {
4176 /* Validate the information class */
4177 if ((FsInformationClass < 0) ||
4180 {
4181 /* Invalid class */
4183 }
4184
4185 /* Validate the length */
4187 {
4188 /* Invalid length */
4190 }
4191
4192 /* Enter SEH for probing */
4193 _SEH2_TRY
4194 {
4195 /* Probe the I/O Status block */
4197
4198 /* Probe the information */
4199 ProbeForWrite(FsInformation, Length, sizeof(ULONG));
4200 }
4202 {
4203 /* Return the exception code */
4205 }
4206 _SEH2_END;
4207 }
4208
4209 /* Get File Object */
4215 (PVOID*)&FileObject,
4216 NULL);
4217 if (!NT_SUCCESS(Status)) return Status;
4218
4219 /* Only allow direct device open for FileFsDeviceInformation */
4222 {
4225 }
4226
4227 /* Check if we should use Sync IO or not */
4228 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
4229 {
4230 /* Lock it */
4232 if (Status != STATUS_SUCCESS)
4233 {
4235 return Status;
4236 }
4237 }
4238
4239 /*
4240 * Quick path for FileFsDeviceInformation - the kernel has enough
4241 * info to reply instead of the driver, excepted for network file systems
4242 */
4245 {
4246 PFILE_FS_DEVICE_INFORMATION FsDeviceInfo = FsInformation;
4247 DeviceObject = FileObject->DeviceObject;
4248
4249 _SEH2_TRY
4250 {
4251 FsDeviceInfo->DeviceType = DeviceObject->DeviceType;
4252
4253 /* Complete characteristcs with mount status if relevant */
4254 FsDeviceInfo->Characteristics = DeviceObject->Characteristics;
4256 {
4258 }
4259
4262 }
4264 {
4265 /* Check if we had a file lock */
4267 {
4268 /* Release it */
4270 }
4271
4272 /* Dereference the FO */
4274
4276 }
4277 _SEH2_END;
4278
4279 /* Check if we had a file lock */
4281 {
4282 /* Release it */
4284 }
4285
4286 /* Dereference the FO */
4288
4289 return STATUS_SUCCESS;
4290 }
4291 /* This is to be handled by the kernel, not by FSD */
4293 {
4295
4296 _SEH2_TRY
4297 {
4298 /* Allocate our local structure */
4300
4301 /* And copy back caller data */
4302 RtlCopyMemory(DriverPathInfo, FsInformation, Length);
4303
4304 /* Is the driver in the IO path? */
4306 (PFILE_FS_DRIVER_PATH_INFORMATION)DriverPathInfo,
4307 Length);
4308 /* We failed, don't continue execution */
4309 if (!NT_SUCCESS(Status))
4310 {
4312 }
4313
4314 /* We succeed, copy back info */
4315 ((PFILE_FS_DRIVER_PATH_INFORMATION)FsInformation)->DriverInPath = DriverPathInfo->DriverInPath;
4316
4317 /* We're done */
4320 }
4322 {
4324 }
4325 _SEH2_END;
4326
4327 /* Don't leak */
4328 if (DriverPathInfo != NULL)
4329 {
4330 ExFreePoolWithTag(DriverPathInfo, TAG_IO);
4331 }
4332
4333 /* Check if we had a file lock */
4335 {
4336 /* Release it */
4338 }
4339
4340 /* Dereference the FO */
4342
4343 return Status;
4344 }
4345
4347 {
4348 /* Use local event */
4350 if (!Event)
4351 {
4354 }
4356 LocalEvent = TRUE;
4357 }
4358
4359 /* Get the device object */
4361
4362 /* Clear File Object event */
4363 KeClearEvent(&FileObject->Event);
4364
4365 /* Allocate the IRP */
4366 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
4368
4369 /* Set up the IRP */
4370 Irp->RequestorMode = PreviousMode;
4371 Irp->Flags = (LocalEvent) ? IRP_SYNCHRONOUS_API : 0;
4372 Irp->UserIosb = (LocalEvent) ? &KernelIosb : IoStatusBlock;
4373 Irp->UserEvent = (LocalEvent) ? Event : NULL;
4374 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
4375 Irp->Tail.Overlay.OriginalFileObject = FileObject;
4376 Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
4377 Irp->UserBuffer = FsInformation;
4378 Irp->AssociatedIrp.SystemBuffer = NULL;
4379 Irp->MdlAddress = NULL;
4380
4381 /* Set up Stack Data */
4382 StackPtr = IoGetNextIrpStackLocation(Irp);
4384 StackPtr->FileObject = FileObject;
4385
4386 /* Enter SEH */
4387 _SEH2_TRY
4388 {
4389 /* Allocate a buffer */
4390 Irp->AssociatedIrp.SystemBuffer =
4392 Length,
4393 TAG_SYSB);
4394 }
4396 {
4397 /* Allocating failed, clean up and return the exception code */
4400 }
4401 _SEH2_END;
4402
4403 /* Set the flags for this buffered + deferred I/O */
4404 Irp->Flags |= (IRP_BUFFERED_IO |
4408
4409 /* Set Parameters */
4410 StackPtr->Parameters.QueryVolume.Length = Length;
4411 StackPtr->Parameters.QueryVolume.FsInformationClass = FsInformationClass;
4412
4413 /* Call the Driver */
4415 Irp,
4416 FileObject,
4417 TRUE,
4419 !LocalEvent,
4421
4422 /* Check if this was async I/O */
4423 if (LocalEvent)
4424 {
4425 /* It was, finalize this request */
4427 Event,
4428 Irp,
4430 &KernelIosb,
4432 }
4433
4434 /* Return status */
4435 return Status;
4436}
4437
4438/*
4439 * @implemented
4440 */
4442NTAPI
4445 IN PVOID FsInformation,
4446 IN ULONG Length,
4448{
4450 PIRP Irp;
4451 PIO_STACK_LOCATION StackPtr;
4453 PKEVENT Event = NULL;
4454 BOOLEAN LocalEvent = FALSE;
4457 IO_STATUS_BLOCK KernelIosb;
4459 PAGED_CODE();
4460 IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
4461
4462 /* Check if we're called from user mode */
4463 if (PreviousMode != KernelMode)
4464 {
4465 /* Validate the information class */
4466 if ((FsInformationClass < 0) ||
4469 {
4470 /* Invalid class */
4472 }
4473
4474 /* Validate the length */
4476 {
4477 /* Invalid length */
4479 }
4480
4481 /* Enter SEH for probing */
4482 _SEH2_TRY
4483 {
4484 /* Probe the I/O Status block */
4486
4487 /* Probe the information */
4488 ProbeForRead(FsInformation, Length, sizeof(ULONG));
4489 }
4491 {
4492 /* Return the exception code */
4494 }
4495 _SEH2_END;
4496 }
4497
4498 /* Get File Object */
4504 (PVOID*)&FileObject,
4505 NULL);
4506 if (!NT_SUCCESS(Status)) return Status;
4507
4508 /* Get target device for notification */
4511
4512 /* Check if we should use Sync IO or not */
4513 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
4514 {
4515 /* Lock it */
4517 if (Status != STATUS_SUCCESS)
4518 {
4521 return Status;
4522 }
4523 }
4524 else
4525 {
4526 /* Use local event */
4528 if (!Event)
4529 {
4533 }
4535 LocalEvent = TRUE;
4536 }
4537
4538 /* Get the device object */
4540
4541 /* Clear File Object event */
4542 KeClearEvent(&FileObject->Event);
4543
4544 /* Allocate the IRP */
4545 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
4546 if (!Irp)
4547 {
4550 }
4551
4552 /* Set up the IRP */
4553 Irp->RequestorMode = PreviousMode;
4554 Irp->Flags = (LocalEvent) ? IRP_SYNCHRONOUS_API : 0;
4555 Irp->UserIosb = (LocalEvent) ? &KernelIosb : IoStatusBlock;
4556 Irp->UserEvent = (LocalEvent) ? Event : NULL;
4557 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
4558 Irp->Tail.Overlay.OriginalFileObject = FileObject;
4559 Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
4560 Irp->UserBuffer = FsInformation;
4561 Irp->AssociatedIrp.SystemBuffer = NULL;
4562 Irp->MdlAddress = NULL;
4563
4564 /* Set up Stack Data */
4565 StackPtr = IoGetNextIrpStackLocation(Irp);
4567 StackPtr->FileObject = FileObject;
4568
4569 /* Enter SEH */
4570 _SEH2_TRY
4571 {
4572 /* Allocate a buffer */
4573 Irp->AssociatedIrp.SystemBuffer =
4575 Length,
4576 TAG_SYSB);
4577
4578 /* Copy the data into it */
4579 RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, FsInformation, Length);
4580 }
4582 {
4583 /* Allocating failed, clean up and return the exception code */
4587 }
4588 _SEH2_END;
4589
4590 /* Set the flags for this buffered + deferred I/O */
4592
4593 /* Set Parameters */
4594 StackPtr->Parameters.SetVolume.Length = Length;
4595 StackPtr->Parameters.SetVolume.FsInformationClass = FsInformationClass;
4596
4597 /* Call the Driver */
4599 Irp,
4600 FileObject,
4601 FALSE,
4603 !LocalEvent,
4605
4606 /* Check if this was async I/O */
4607 if (LocalEvent)
4608 {
4609 /* It was, finalize this request */
4611 Event,
4612 Irp,
4614 &KernelIosb,
4616 }
4617
4619 {
4620 /* Time to report change */
4621 NotificationStructure.Version = 1;
4623 NotificationStructure.Event = GUID_IO_VOLUME_NAME_CHANGE;
4624 NotificationStructure.FileObject = NULL;
4625 NotificationStructure.NameBufferOffset = - 1;
4627 }
4628
4629 /* Return status */
4630 return Status;
4631}
4632
4633/*
4634 * @unimplemented
4635 */
4637NTAPI
4639{
4642}
4643
4644/*
4645 * @unimplemented
4646 */
4648NTAPI
4650{
4653}
#define PAGED_CODE()
unsigned char BOOLEAN
#define OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
#define InterlockedIncrement
Definition: armddk.h:53
LONG NTSTATUS
Definition: precomp.h:26
#define FILE_DELETE_ON_CLOSE
Definition: constants.h:494
_In_ ULONG _In_ BATTERY_QUERY_INFORMATION_LEVEL _In_ LONG _In_ ULONG _Out_ PULONG ReturnedLength
Definition: batclass.h:188
#define UNIMPLEMENTED
Definition: debug.h:115
Definition: bufpool.h:45
Definition: File.h:16
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
_In_ PIRP Irp
Definition: csq.h:116
#define BufferSize
Definition: mmc.h:75
#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:32
#define FILE_SHARE_READ
Definition: compat.h:136
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define DO_BUFFERED_IO
Definition: env_spec_w32.h:394
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define APC_LEVEL
Definition: env_spec_w32.h:695
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
#define DO_DIRECT_IO
Definition: env_spec_w32.h:396
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define NonPagedPoolCacheAligned
Definition: env_spec_w32.h:310
struct _UNICODE_STRING UNICODE_STRING
#define NonPagedPool
Definition: env_spec_w32.h:307
#define PagedPool
Definition: env_spec_w32.h:308
@ Success
Definition: eventcreate.c:712
VOID NTAPI KeClearEvent(IN PKEVENT Event)
Definition: eventobj.c:22
#define ExGetPreviousMode
Definition: ex.h:140
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
#define FILE_WRITE_TO_END_OF_FILE
Definition: ext2fs.h:278
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
IN OUT PVCB IN PDEVICE_OBJECT TargetDeviceObject
Definition: fatprocs.h:1674
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN BOOLEAN ExclusiveLock
Definition: fatprocs.h:2714
IN OUT PVCB IN PDEVICE_OBJECT IN PVPB Vpb
Definition: fatprocs.h:1675
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN FailImmediately
Definition: fatprocs.h:2713
IN PDCB IN PCCB IN VBO IN OUT PULONG OUT PDIRENT OUT PBCB OUT PVBO ByteOffset
Definition: fatprocs.h:731
struct _FileName FileName
Definition: fatprocs.h:896
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ BOOLEAN _In_ ULONG _In_opt_ PULONG _In_ BOOLEAN RestartScan
Definition: fltkernel.h:2299
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ BOOLEAN _In_ ULONG EaListLength
Definition: fltkernel.h:2297
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ FS_INFORMATION_CLASS FsInformationClass
Definition: fltkernel.h:1330
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1231
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ BOOLEAN ReturnSingleEntry
Definition: fltkernel.h:2295
_Inout_ PLIST_ENTRY _In_ PVOID _In_ PSTRING _In_ BOOLEAN _In_ BOOLEAN _In_ ULONG CompletionFilter
Definition: fltkernel.h:2243
_Inout_ PLIST_ENTRY _In_ PVOID _In_ PSTRING _In_ BOOLEAN WatchTree
Definition: fltkernel.h:2241
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ BOOLEAN _In_ ULONG _In_opt_ PULONG EaIndex
Definition: fltkernel.h:2298
_In_ FILTER_INFORMATION_CLASS InformationClass
Definition: fltkernel.h:1713
@ FilePositionInformation
Definition: from_kernel.h:75
@ FileMoveClusterInformation
Definition: from_kernel.h:92
@ FileMaximumInformation
Definition: from_kernel.h:112
@ FileRenameInformation
Definition: from_kernel.h:71
@ FileAllInformation
Definition: from_kernel.h:79
@ FileLinkInformation
Definition: from_kernel.h:72
@ FileDirectoryInformation
Definition: from_kernel.h:62
@ FileAlignmentInformation
Definition: from_kernel.h:78
@ FileIdBothDirectoryInformation
Definition: from_kernel.h:98
@ FileNamesInformation
Definition: from_kernel.h:73
@ FileCompletionInformation
Definition: from_kernel.h:91
@ FileFullDirectoryInformation
Definition: from_kernel.h:63
@ FileModeInformation
Definition: from_kernel.h:77
@ FileBasicInformation
Definition: from_kernel.h:65
@ FileBothDirectoryInformation
Definition: from_kernel.h:64
@ FileIdFullDirectoryInformation
Definition: from_kernel.h:99
#define FILE_OPEN
Definition: from_kernel.h:54
enum _FILE_INFORMATION_CLASS FILE_INFORMATION_CLASS
Definition: directory.c:44
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
@ FileFsDeviceInformation
Definition: from_kernel.h:222
@ FileFsMaximumInformation
Definition: from_kernel.h:229
#define FILE_NO_INTERMEDIATE_BUFFERING
Definition: from_kernel.h:28
#define FILE_WRITE_THROUGH
Definition: from_kernel.h:26
#define FILE_SEQUENTIAL_ONLY
Definition: from_kernel.h:27
#define FILE_SYNCHRONOUS_IO_ALERT
Definition: from_kernel.h:30
enum _FSINFOCLASS FS_INFORMATION_CLASS
#define FILE_OPEN_FOR_BACKUP_INTENT
Definition: from_kernel.h:42
#define IoFreeMdl
Definition: fxmdl.h:89
#define IoAllocateMdl
Definition: fxmdl.h:88
ULONG Handle
Definition: gdb_input.c:15
Status
Definition: gdiplustypes.h:25
VOID FASTCALL KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, IN KIRQL OldIrql)
Definition: spinlock.c:154
KIRQL FASTCALL KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
Definition: spinlock.c:108
_Inout_ PUSB_DEVICE_HANDLE DeviceHandle
Definition: hubbusif.h:121
_In_ ULONG Mode
Definition: hubbusif.h:303
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
struct _FILE_MODE_INFORMATION FILE_MODE_INFORMATION
#define InterlockedExchangeAdd
Definition: interlocked.h:181
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
UCHAR IopSetFsOperationLength[]
Definition: io_i.h:228
UCHAR IopQueryOperationLength[]
Definition: io_i.h:12
UCHAR IopSetOperationLength[]
Definition: io_i.h:69
ULONG IopQueryFsOperationAccess[]
Definition: io_i.h:246
UCHAR IopQueryFsOperationLength[]
Definition: io_i.h:210
ULONG IopSetFsOperationAccess[]
Definition: io_i.h:264
ACCESS_MASK IopQueryOperationAccess[]
Definition: io_i.h:115
ACCESS_MASK IopSetOperationAccess[]
Definition: io_i.h:161
static __inline NTSTATUS IopLockFileObject(_In_ PFILE_OBJECT FileObject, _In_ KPROCESSOR_MODE WaitMode)
Definition: io_x.h:12
FORCEINLINE VOID IopQueueIrpToThread(IN PIRP Irp)
Definition: io_x.h:49
static __inline VOID IopUpdateTransferCount(IN IOP_TRANSFER_TYPE Type, IN ULONG TransferCount)
Definition: io_x.h:116
static __inline VOID IopUpdateOperationCount(IN IOP_TRANSFER_TYPE Type)
Definition: io_x.h:82
static __inline VOID IopUnlockFileObject(IN PFILE_OBJECT FileObject)
Definition: io_x.h:36
NTSTATUS NTAPI NtFsControlFile(IN HANDLE DeviceHandle, IN HANDLE Event OPTIONAL, IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL, IN PVOID UserApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, IN ULONG IoControlCode, IN PVOID InputBuffer, IN ULONG InputBufferLength OPTIONAL, OUT PVOID OutputBuffer, IN ULONG OutputBufferLength OPTIONAL)
Definition: iofunc.c:1460
NTSTATUS NTAPI NtReadFileScatter(IN HANDLE FileHandle, IN HANDLE Event OPTIONAL, IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL, IN PVOID UserApcContext OPTIONAL, OUT PIO_STATUS_BLOCK UserIoStatusBlock, IN FILE_SEGMENT_ELEMENT BufferDescription[], IN ULONG BufferLength, IN PLARGE_INTEGER ByteOffset, IN PULONG Key OPTIONAL)
Definition: iofunc.c:3063
NTSTATUS NTAPI NtFlushBuffersFile(IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock)
Definition: iofunc.c:1487
NTSTATUS NTAPI IopQueryDeviceInformation(IN PFILE_OBJECT FileObject, IN ULONG InformationClass, IN ULONG Length, OUT PVOID Information, OUT PULONG ReturnedLength, IN BOOLEAN File)
Definition: iofunc.c:652
NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE DeviceHandle, IN HANDLE Event OPTIONAL, IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL, IN PVOID UserApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, IN ULONG IoControlCode, IN PVOID InputBuffer, IN ULONG InputBufferLength OPTIONAL, OUT PVOID OutputBuffer, IN ULONG OutputBufferLength OPTIONAL)
Definition: iofunc.c:1430
NTSTATUS NTAPI NtQueryInformationFile(IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PVOID FileInformation, IN ULONG Length, IN FILE_INFORMATION_CLASS FileInformationClass)
Definition: iofunc.c:2275
NTSTATUS NTAPI NtSetQuotaInformationFile(IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PVOID Buffer, IN ULONG BufferLength)
Definition: iofunc.c:3539
NTSTATUS NTAPI NtSetVolumeInformationFile(IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PVOID FsInformation, IN ULONG Length, IN FS_INFORMATION_CLASS FsInformationClass)
Definition: iofunc.c:4443
NTSTATUS NTAPI NtSetEaFile(IN HANDLE FileHandle, IN PIO_STATUS_BLOCK IoStatusBlock, IN PVOID EaBuffer, IN ULONG EaBufferSize)
Definition: iofunc.c:3082
NTSTATUS NTAPI NtWriteFile(IN HANDLE FileHandle, IN HANDLE Event OPTIONAL, IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER ByteOffset OPTIONAL, IN PULONG Key OPTIONAL)
Definition: iofunc.c:3765
NTSTATUS NTAPI NtSetInformationFile(IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PVOID FileInformation, IN ULONG Length, IN FILE_INFORMATION_CLASS FileInformationClass)
Definition: iofunc.c:3096
volatile LONG IoPageReadIrpAllocationFailure
Definition: iofunc.c:20
NTSTATUS NTAPI IopOpenLinkOrRenameTarget(OUT PHANDLE Handle, IN PIRP Irp, IN PFILE_RENAME_INFORMATION RenameInfo, IN PFILE_OBJECT FileObject)
Definition: iofunc.c:867
NTSTATUS NTAPI NtRequestDeviceWakeup(IN HANDLE DeviceHandle)
Definition: iofunc.c:4649
NTSTATUS NTAPI NtLockFile(IN HANDLE FileHandle, IN HANDLE EventHandle OPTIONAL, IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER ByteOffset, IN PLARGE_INTEGER Length, IN ULONG Key, IN BOOLEAN FailImmediately, IN BOOLEAN ExclusiveLock)
Definition: iofunc.c:1764
NTSTATUS NTAPI NtNotifyChangeDirectoryFile(IN HANDLE FileHandle, IN HANDLE EventHandle OPTIONAL, IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, OUT PVOID Buffer, IN ULONG BufferSize, IN ULONG CompletionFilter, IN BOOLEAN WatchTree)
Definition: iofunc.c:1622
static BOOLEAN IopVerifyDriverObjectOnStack(IN PDEVICE_OBJECT DeviceObject, IN PDRIVER_OBJECT DriverObject)
Definition: iofunc.c:1059
NTSTATUS NTAPI NtReadFile(IN HANDLE FileHandle, IN HANDLE Event OPTIONAL, IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, OUT PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER ByteOffset OPTIONAL, IN PULONG Key OPTIONAL)
Definition: iofunc.c:2703
NTSTATUS NTAPI IopGetBasicInformationFile(IN PFILE_OBJECT FileObject, OUT PFILE_BASIC_INFORMATION BasicInfo)
Definition: iofunc.c:839
volatile LONG IoPageReadNonPagefileIrpAllocationFailure
Definition: iofunc.c:21
NTSTATUS NTAPI IopDeviceFsIoControl(IN HANDLE DeviceHandle, IN HANDLE Event OPTIONAL, IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL, IN PVOID UserApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, IN ULONG IoControlCode, IN PVOID InputBuffer, IN ULONG InputBufferLength OPTIONAL, OUT PVOID OutputBuffer, IN ULONG OutputBufferLength OPTIONAL, IN BOOLEAN IsDevIoCtl)
Definition: iofunc.c:197
NTSTATUS NTAPI NtQueryVolumeInformationFile(IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock, OUT PVOID FsInformation, IN ULONG Length, IN FS_INFORMATION_CLASS FsInformationClass)
Definition: iofunc.c:4155
NTSTATUS NTAPI IopPerformSynchronousRequest(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PFILE_OBJECT FileObject, IN BOOLEAN Deferred, IN KPROCESSOR_MODE PreviousMode, IN BOOLEAN SynchIo, IN IOP_TRANSFER_TYPE TransferType)
Definition: iofunc.c:119
static BOOLEAN IopGetMountFlag(IN PDEVICE_OBJECT DeviceObject)
Definition: iofunc.c:1033
NTSTATUS NTAPI NtCancelDeviceWakeupRequest(IN HANDLE DeviceHandle)
Definition: iofunc.c:4638
NTSTATUS NTAPI IoQueryFileInformation(IN PFILE_OBJECT FileObject, IN FILE_INFORMATION_CLASS FileInformationClass, IN ULONG Length, OUT PVOID FileInformation, OUT PULONG ReturnedLength)
Definition: iofunc.c:1274
NTSTATUS NTAPI IoPageRead(IN PFILE_OBJECT FileObject, IN PMDL Mdl, IN PLARGE_INTEGER Offset, IN PKEVENT Event, IN PIO_STATUS_BLOCK StatusBlock)
Definition: iofunc.c:1201
NTSTATUS NTAPI NtQueryDirectoryFile(IN HANDLE FileHandle, IN HANDLE EventHandle OPTIONAL, IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, OUT PVOID FileInformation, IN ULONG Length, IN FILE_INFORMATION_CLASS FileInformationClass, IN BOOLEAN ReturnSingleEntry, IN PUNICODE_STRING FileName OPTIONAL, IN BOOLEAN RestartScan)
Definition: iofunc.c:1994
NTSTATUS NTAPI NtQueryEaFile(IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock, OUT PVOID Buffer, IN ULONG Length, IN BOOLEAN ReturnSingleEntry, IN PVOID EaList OPTIONAL, IN ULONG EaListLength, IN PULONG EaIndex OPTIONAL, IN BOOLEAN RestartScan)
Definition: iofunc.c:2256
NTSTATUS NTAPI IoQueryVolumeInformation(IN PFILE_OBJECT FileObject, IN FS_INFORMATION_CLASS FsInformationClass, IN ULONG Length, OUT PVOID FsInformation, OUT PULONG ReturnedLength)
Definition: iofunc.c:1294
static ULONG IopGetFileMode(IN PFILE_OBJECT FileObject)
Definition: iofunc.c:1004
NTSTATUS NTAPI IoSetInformation(IN PFILE_OBJECT FileObject, IN FILE_INFORMATION_CLASS FileInformationClass, IN ULONG Length, IN PVOID FileInformation)
Definition: iofunc.c:1314
VOID NTAPI IopCleanupAfterException(IN PFILE_OBJECT FileObject, IN PIRP Irp OPTIONAL, IN PKEVENT Event OPTIONAL, IN PKEVENT LocalEvent OPTIONAL)
Definition: iofunc.c:27
NTSTATUS NTAPI IopGetFileInformation(IN PFILE_OBJECT FileObject, IN ULONG Length, IN FILE_INFORMATION_CLASS FileInfoClass, OUT PVOID Buffer, OUT PULONG ReturnedLength)
Definition: iofunc.c:777
NTSTATUS NTAPI IoSynchronousPageWrite(IN PFILE_OBJECT FileObject, IN PMDL Mdl, IN PLARGE_INTEGER Offset, IN PKEVENT Event, IN PIO_STATUS_BLOCK StatusBlock)
Definition: iofunc.c:1146
static NTSTATUS IopGetDriverPathInformation(IN PFILE_OBJECT FileObject, IN PFILE_FS_DRIVER_PATH_INFORMATION DriverPathInfo, IN ULONG Length)
Definition: iofunc.c:1084
NTSTATUS NTAPI IopFinalizeAsynchronousIo(IN NTSTATUS SynchStatus, IN PKEVENT Event, IN PIRP Irp, IN KPROCESSOR_MODE PreviousMode, IN PIO_STATUS_BLOCK KernelIosb, OUT PIO_STATUS_BLOCK IoStatusBlock)
Definition: iofunc.c:70
#define CHECK_LENGTH(class, struct)
NTSTATUS NTAPI NtQueryQuotaInformationFile(IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock, OUT PVOID Buffer, IN ULONG Length, IN BOOLEAN ReturnSingleEntry, IN PVOID SidList OPTIONAL, IN ULONG SidListLength, IN PSID StartSid OPTIONAL, IN BOOLEAN RestartScan)
Definition: iofunc.c:2684
NTSTATUS NTAPI NtWriteFileGather(IN HANDLE FileHandle, IN HANDLE Event OPTIONAL, IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL, IN PVOID UserApcContext OPTIONAL, OUT PIO_STATUS_BLOCK UserIoStatusBlock, IN FILE_SEGMENT_ELEMENT BufferDescription[], IN ULONG BufferLength, IN PLARGE_INTEGER ByteOffset, IN PULONG Key OPTIONAL)
Definition: iofunc.c:4136
NTSTATUS NTAPI NtUnlockFile(IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER ByteOffset, IN PLARGE_INTEGER Length, IN ULONG Key OPTIONAL)
Definition: iofunc.c:3553
POBJECT_TYPE IoFileObjectType
Definition: iomgr.c:36
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:931
#define ASSERT(a)
Definition: mode.c:44
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
static OUT PIO_STATUS_BLOCK OUT PVOID FileInformation
Definition: pipe.c:75
static OUT PIO_STATUS_BLOCK OUT PVOID IN ULONG IN FILE_INFORMATION_CLASS FileInformationClass
Definition: pipe.c:75
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define IO_METHOD_FROM_CTL_CODE(C)
Definition: mup.h:11
#define KernelMode
Definition: asm.h:34
#define KeGetPreviousMode()
Definition: ketypes.h:1115
_In_opt_ HANDLE _In_opt_ PIO_APC_ROUTINE _In_opt_ PVOID ApcContext
Definition: iofuncs.h:727
_In_opt_ HANDLE _In_opt_ PIO_APC_ROUTINE ApcRoutine
Definition: iofuncs.h:726
#define IO_COMPLETION_MODIFY_STATE
Definition: iotypes.h:33
#define FO_FILE_OBJECT_HAS_EXTENSION
Definition: iotypes.h:144
VOID(NTAPI * PKNORMAL_ROUTINE)(IN PVOID NormalContext OPTIONAL, IN PVOID SystemArgument1 OPTIONAL, IN PVOID SystemArgument2 OPTIONAL)
Definition: ketypes.h:744
_In_ HANDLE _In_opt_ HANDLE _Out_opt_ PHANDLE TargetHandle
Definition: obfuncs.h:431
DECLSPEC_NORETURN NTSYSAPI VOID NTAPI RtlRaiseStatus(_In_ NTSTATUS Status)
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define SYNCHRONIZE
Definition: nt_native.h:61
#define METHOD_NEITHER
Definition: nt_native.h:597
#define FILE_WRITE_DATA
Definition: nt_native.h:631
#define FILE_READ_DATA
Definition: nt_native.h:628
#define FILE_USE_FILE_POINTER_POSITION
Definition: nt_native.h:780
ULONG ACCESS_MASK
Definition: nt_native.h:40
#define FILE_LIST_DIRECTORY
Definition: nt_native.h:629
struct _FILE_FS_DEVICE_INFORMATION FILE_FS_DEVICE_INFORMATION
struct _FILE_POSITION_INFORMATION FILE_POSITION_INFORMATION
struct _FILE_ALIGNMENT_INFORMATION FILE_ALIGNMENT_INFORMATION
#define FILE_EXISTS
Definition: nt_native.h:772
#define FILE_APPEND_DATA
Definition: nt_native.h:634
#define FILE_DEVICE_IS_MOUNTED
Definition: nt_native.h:812
#define METHOD_OUT_DIRECT
Definition: nt_native.h:596
#define FILE_ANY_ACCESS
Definition: nt_native.h:609
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
#define METHOD_BUFFERED
Definition: nt_native.h:594
struct _FILE_POSITION_INFORMATION * PFILE_POSITION_INFORMATION
#define FILE_ADD_SUBDIRECTORY
Definition: nt_native.h:635
#define FSCTL_DISMOUNT_VOLUME
Definition: nt_native.h:834
VOID(* PIO_APC_ROUTINE)(IN PVOID ApcContext, IN PIO_STATUS_BLOCK IoStatusBlock, IN ULONG Reserved)
Definition: nt_native.h:877
#define METHOD_IN_DIRECT
Definition: nt_native.h:595
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
@ SynchronizationEvent
#define FileFsDriverPathInformation
Definition: ntifs_ex.h:391
ULONG CcDataPages
Definition: copy.c:43
ULONG CcDataFlushes
Definition: copy.c:44
POBJECT_TYPE ExEventObjectType
Definition: event.c:18
enum _IOP_TRANSFER_TYPE IOP_TRANSFER_TYPE
VOID NTAPI IopCompleteRequest(IN PKAPC Apc, IN PKNORMAL_ROUTINE *NormalRoutine, IN PVOID *NormalContext, IN PVOID *SystemArgument1, IN PVOID *SystemArgument2)
Definition: irp.c:238
POBJECT_TYPE IoCompletionType
Definition: iocomp.c:16
PIRP NTAPI IopAllocateReserveIrp(IN CCHAR StackSize)
Definition: irp.c:573
NTSTATUS NTAPI IopCleanupFailedIrp(IN PFILE_OBJECT FileObject, IN PKEVENT EventObject, IN PVOID Buffer OPTIONAL)
Definition: irp.c:45
@ IopWriteTransfer
Definition: io.h:262
@ IopReadTransfer
Definition: io.h:261
@ IopOtherTransfer
Definition: io.h:263
NTSTATUS NTAPI IoGetRelatedTargetDevice(IN PFILE_OBJECT FileObject, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1607
VOID NTAPI IopAbortInterruptedIrp(IN PKEVENT EventObject, IN PIRP Irp)
Definition: irp.c:67
#define IO_API_DEBUG
Definition: io.h:21
#define IOTRACE(x, fmt,...)
Definition: io.h:47
NTSTATUS NTAPI IoSetIoCompletion(IN PVOID IoCompletion, IN PVOID KeyContext, IN PVOID ApcContext, IN NTSTATUS IoStatus, IN ULONG_PTR IoStatusInformation, IN BOOLEAN Quota)
Definition: iocomp.c:147
PDEVICE_OBJECT NTAPI IopGetDeviceAttachmentBase(IN PDEVICE_OBJECT DeviceObject)
Definition: file.c:1486
#define IO_CTL_DEBUG
Definition: io.h:22
BOOLEAN NTAPI MmIsFileObjectAPagingFile(PFILE_OBJECT FileObject)
Definition: pagefile.c:119
#define ExRaiseStatus
Definition: ntoskrnl.h:114
PDEVICE_OBJECT NTAPI IoGetRelatedDeviceObject(IN PFILE_OBJECT FileObject)
Definition: device.c:1539
PDEVICE_OBJECT NTAPI IoGetAttachedDevice(PDEVICE_OBJECT DeviceObject)
Definition: device.c:1385
POBJECT_TYPE IoDriverObjectType
Definition: driver.c:34
NTSTATUS NTAPI IoCreateFile(OUT PHANDLE FileHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER AllocationSize OPTIONAL, IN ULONG FileAttributes, IN ULONG ShareAccess, IN ULONG Disposition, IN ULONG CreateOptions, IN PVOID EaBuffer OPTIONAL, IN ULONG EaLength, IN CREATE_FILE_TYPE CreateFileType, IN PVOID ExtraCreateParameters OPTIONAL, IN ULONG Options)
Definition: file.c:3010
NTSTATUS NTAPI IoCreateFileSpecifyDeviceObjectHint(OUT PHANDLE FileHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER AllocationSize OPTIONAL, IN ULONG FileAttributes, IN ULONG ShareAccess, IN ULONG Disposition, IN ULONG CreateOptions, IN PVOID EaBuffer OPTIONAL, IN ULONG EaLength, IN CREATE_FILE_TYPE CreateFileType, IN PVOID ExtraCreateParameters OPTIONAL, IN ULONG Options, IN PVOID DeviceObject)
Definition: file.c:3050
PIRP NTAPI IoAllocateIrp(IN CCHAR StackSize, IN BOOLEAN ChargeQuota)
Definition: irp.c:615
#define IoCallDriver
Definition: irp.c:1225
VOID NTAPI IoFreeIrp(IN PIRP Irp)
Definition: irp.c:1666
VOID NTAPI IoReleaseVpbSpinLock(IN KIRQL Irql)
Definition: volume.c:1215
VOID NTAPI IoAcquireVpbSpinLock(OUT PKIRQL Irql)
Definition: volume.c:1204
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:455
#define STATUS_ALERTED
Definition: ntstatus.h:80
#define STATUS_USER_APC
Definition: ntstatus.h:78
#define STATUS_PENDING
Definition: ntstatus.h:82
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
#define STATUS_NOT_SAME_DEVICE
Definition: ntstatus.h:448
FAST_IO_DISPATCH FastIoDispatch
Definition: null.c:15
NTSTATUS NTAPI ObReferenceFileObjectForWrite(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode, OUT PFILE_OBJECT *FileObject, OUT POBJECT_HANDLE_INFORMATION HandleInformation)
Definition: obref.c:200
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379
NTSTATUS NTAPI ObReferenceObjectByName(IN PUNICODE_STRING ObjectPath, IN ULONG Attributes, IN PACCESS_STATE PassedAccessState, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, IN OUT PVOID ParseContext, OUT PVOID *ObjectPtr)
Definition: obref.c:409
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
long LONG
Definition: pedump.c:60
NTSTATUS NTAPI IoReportTargetDeviceChange(IN PDEVICE_OBJECT PhysicalDeviceObject, IN PVOID NotificationStructure)
Definition: pnpreport.c:448
struct _FILE_ACCESS_INFORMATION FILE_ACCESS_INFORMATION
#define FileAccessInformation
Definition: propsheet.cpp:51
#define FileStandardInformation
Definition: propsheet.cpp:61
#define FILE_DEVICE_NETWORK_FILE_SYSTEM
Definition: winioctl.h:126
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define _SEH2_VOLATILE
Definition: pseh2_64.h:163
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
#define IRP_MJ_DIRECTORY_CONTROL
Definition: rdpdr.c:51
#define IRP_MN_QUERY_DIRECTORY
Definition: rdpdr.c:55
#define IRP_MN_NOTIFY_CHANGE_DIRECTORY
Definition: rdpdr.c:56
#define IRP_MJ_READ
Definition: rdpdr.c:46
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
#define IRP_MJ_QUERY_VOLUME_INFORMATION
Definition: rdpdr.c:50
#define IRP_MJ_LOCK_CONTROL
Definition: rdpdr.c:53
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
#define IRP_MJ_SET_INFORMATION
Definition: rdpdr.c:49
#define IRP_MJ_QUERY_INFORMATION
Definition: rdpdr.c:48
#define ProbeForReadUnicodeString(Ptr)
Definition: probe.h:77
#define ProbeForWriteIoStatusBlock(Ptr)
Definition: probe.h:52
#define ProbeForReadUlong(Ptr)
Definition: probe.h:65
#define ProbeForReadLargeInteger(Ptr)
Definition: probe.h:75
#define SharedUserData
#define STATUS_END_OF_FILE
Definition: shellext.h:67
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
#define DPRINT
Definition: sndvol32.h:71
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
PFAST_IO_QUERY_STANDARD_INFO FastIoQueryStandardInfo
Definition: iotypes.h:1738
PFAST_IO_WRITE FastIoWrite
Definition: iotypes.h:1736
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_UNLOCK_SINGLE FastIoUnlockSingle
Definition: iotypes.h:1740
FILE_MODE_INFORMATION ModeInformation
Definition: winternl.h:802
FILE_ALIGNMENT_INFORMATION AlignmentInformation
Definition: winternl.h:803
FILE_ACCESS_INFORMATION AccessInformation
Definition: winternl.h:800
PDEVICE_OBJECT TopDeviceObjectHint
Definition: io.h:102
PFILE_OBJECT FileObject
Definition: iotypes.h:3169
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
ACCESS_MASK GrantedAccess
Definition: iotypes.h:181
USHORT MaximumLength
Definition: env_spec_w32.h:370
PVPB Vpb
Definition: cdstruc.h:511
Definition: iotypes.h:189
#define IOC_TAG
Definition: tag.h:69
#define TAG_LOCK
Definition: tag.h:63
#define TAG_IO
Definition: tag.h:80
#define TAG_SYSB
Definition: tag.h:96
#define TAG_SYS_BUF
Definition: tag.h:87
uint32_t * PULONG
Definition: typedefs.h:59
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
INT POOL_TYPE
Definition: typedefs.h:78
#define NTAPI
Definition: typedefs.h:36
void * PVOID
Definition: typedefs.h:50
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
int32_t * PLONG
Definition: typedefs.h:58
uint16_t * PWCHAR
Definition: typedefs.h:56
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define STATUS_OBJECT_NAME_COLLISION
Definition: udferr_usr.h:150
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
LONGLONG QuadPart
Definition: typedefs.h:114
struct _LARGE_INTEGER::@2290 u
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_Must_inspect_result_ _In_ WDFDEVICE _In_ ULONG _In_ ACCESS_MASK DesiredAccess
Definition: wdfdevice.h:2658
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ _Strict_type_match_ POOL_TYPE PoolType
Definition: wdfdevice.h:3815
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550
_Must_inspect_result_ _In_ WDFDEVICE _In_ PIRP _In_ WDFQUEUE Queue
Definition: wdfdevice.h:2225
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3771
_In_ WDFDEVICE _In_ PVOID _In_opt_ PMDL Mdl
_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
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:254
_In_ WDFREQUEST _In_opt_ PFN_WDF_REQUEST_COMPLETION_ROUTINE _In_opt_ __drv_aliasesMem WDFCONTEXT CompletionContext
Definition: wdfrequest.h:898
_In_ WDFREQUEST _In_ PIO_STACK_LOCATION Stack
Definition: wdfrequest.h:639
_In_ WDFREQUEST _In_ NTSTATUS _In_ ULONG_PTR Information
Definition: wdfrequest.h:1049
#define EVENT_MODIFY_STATE
Definition: winbase.h:163
#define ExAllocatePoolWithQuotaTag(a, b, c)
Definition: exfuncs.h:530
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Out_ PIO_STATUS_BLOCK _In_opt_ PLARGE_INTEGER _In_ ULONG _In_ ULONG _In_ ULONG _In_ ULONG _In_opt_ PVOID EaBuffer
Definition: iofuncs.h:845
_Out_ PHANDLE EventHandle
Definition: iofuncs.h:857
_In_ PVOID NotificationStructure
Definition: iofuncs.h:1206
#define IRP_DEALLOCATE_BUFFER
#define FO_SEQUENTIAL_ONLY
Definition: iotypes.h:1780
#define FO_NAMED_PIPE
Definition: iotypes.h:1782
#define FO_ALERTABLE_IO
Definition: iotypes.h:1777
#define IRP_SYNCHRONOUS_API
#define SL_WATCH_TREE
Definition: iotypes.h:1839
#define IO_FORCE_ACCESS_CHECK
Definition: iotypes.h:540
#define IO_OPEN_TARGET_DIRECTORY
Definition: iotypes.h:7352
#define IRP_INPUT_OPERATION
#define VPB_MOUNTED
Definition: iotypes.h:1807
#define IO_NO_PARAMETER_CHECKING
Definition: iotypes.h:541
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define IRP_MJ_FILE_SYSTEM_CONTROL
#define IRP_PAGING_IO
struct _FILE_MOVE_CLUSTER_INFORMATION * PFILE_MOVE_CLUSTER_INFORMATION
#define IRP_OB_QUERY_NAME
#define IRP_MJ_SET_VOLUME_INFORMATION
#define FO_OPENED_CASE_SENSITIVE
Definition: iotypes.h:1793
#define IRP_WRITE_OPERATION
#define FO_WRITE_THROUGH
Definition: iotypes.h:1779
#define IRP_MN_LOCK
Definition: iotypes.h:4410
#define SL_RETURN_SINGLE_ENTRY
Definition: iotypes.h:1836
#define IRP_DEFER_IO_COMPLETION
#define FO_DIRECT_DEVICE_OPEN
Definition: iotypes.h:1787
* PFILE_OBJECT
Definition: iotypes.h:1998
#define IRP_MJ_FLUSH_BUFFERS
#define IRP_READ_OPERATION
#define FO_NO_INTERMEDIATE_BUFFERING
Definition: iotypes.h:1778
@ CreateFileTypeNone
Definition: iotypes.h:535
#define FO_DELETE_ON_CLOSE
Definition: iotypes.h:1792
struct _TARGET_DEVICE_CUSTOM_NOTIFICATION TARGET_DEVICE_CUSTOM_NOTIFICATION
#define FILE_NOTIFY_VALID_MASK
#define SL_FAIL_IMMEDIATELY
Definition: iotypes.h:1832
#define FO_SYNCHRONOUS_IO
Definition: iotypes.h:1776
#define IRP_MN_UNLOCK_SINGLE
Definition: iotypes.h:4411
struct _FILE_FS_DRIVER_PATH_INFORMATION FILE_FS_DRIVER_PATH_INFORMATION
#define SL_WRITE_THROUGH
Definition: iotypes.h:1824
#define IRP_BUFFERED_IO
#define IRP_SYNCHRONOUS_PAGING_IO
#define SL_RESTART_SCAN
Definition: iotypes.h:1835
#define SL_EXCLUSIVE_LOCK
Definition: iotypes.h:1833
#define IRP_NOCACHE
struct _FILE_FS_DRIVER_PATH_INFORMATION * PFILE_FS_DRIVER_PATH_INFORMATION
#define FO_MAILSLOT
Definition: iotypes.h:1784
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
@ Executive
Definition: ketypes.h:415
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
@ IoReadAccess
Definition: ketypes.h:863
@ IoWriteAccess
Definition: ketypes.h:864
@ LockQueueIoDatabaseLock
Definition: ketypes.h:668
#define MmGetMdlByteCount(_Mdl)
#define MmGetMdlVirtualAddress(_Mdl)
#define BYTES_TO_PAGES(Size)
_In_ ACCESS_MASK _In_opt_ POBJECT_TYPE _In_ KPROCESSOR_MODE _Out_ PVOID _Out_opt_ POBJECT_HANDLE_INFORMATION HandleInformation
Definition: obfuncs.h:44
#define ObDereferenceObject
Definition: obfuncs.h:203
#define ObReferenceObject
Definition: obfuncs.h:204
#define PsGetCurrentProcess
Definition: psfuncs.h:17
_In_ KPROCESSOR_MODE PreviousMode
Definition: sefuncs.h:103
char CHAR
Definition: xmlstorage.h:175
_Out_ PIO_STATUS_BLOCK _In_ ULONG _In_ BOOLEAN _In_ ULONG _In_opt_ PSID StartSid
Definition: zwfuncs.h:1121
_Out_ PIO_STATUS_BLOCK _In_ ULONG _In_ BOOLEAN _In_ ULONG SidListLength
Definition: zwfuncs.h:1120