ReactOS  0.4.14-dev-583-g2a1ba2c
fastio.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/fsrtl/fastio.c
5  * PURPOSE: Provides Fast I/O entrypoints to the Cache Manager
6  * PROGRAMMERS: Dominique Cote (buzdelabuz2@gmail.com)
7  * Alex Ionescu (alex.ionescu@reactos.org)
8  * Aleksey Bragin (aleksey@reactos.org)
9  */
10 
11 /* INCLUDES ******************************************************************/
12 
13 #include <ntoskrnl.h>
14 #define NDEBUG
15 #include <debug.h>
16 
17 /* PUBLIC FUNCTIONS **********************************************************/
18 
19 /*
20  * @implemented
21  */
22 VOID
23 NTAPI
25 {
27 }
28 
29 /*
30  * @implemented
31  */
32 VOID
33 NTAPI
35 {
37 }
38 
39 /*
40  * @implemented
41  */
42 VOID
43 NTAPI
45 {
47 }
48 
49 /*
50  * @implemented
51  */
52 VOID
53 NTAPI
55 {
57 }
58 
59 /*
60  * @implemented
61  */
62 BOOLEAN
63 NTAPI
66  IN ULONG Length,
67  IN BOOLEAN Wait,
72 {
73 
74  PFSRTL_COMMON_FCB_HEADER FcbHeader;
80 
81  PAGED_CODE();
83  ASSERT(FileObject->FsContext);
84 
85  /* No actual read */
86  if (!Length)
87  {
88  /* Return success */
89  IoStatus->Status = STATUS_SUCCESS;
90  IoStatus->Information = 0;
91  return TRUE;
92  }
93 
94  if (Length > MAXLONGLONG - FileOffset->QuadPart)
95  {
97  IoStatus->Information = 0;
98  return FALSE;
99  }
100 
101  /* Get the offset and FCB header */
102  Offset.QuadPart = FileOffset->QuadPart + Length;
103  FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
104 
105  if (Wait)
106  {
107  /* Use a Resource Acquire */
109  CcFastReadWait++;
111  }
112  else
113  {
114  /* Acquire the resource without blocking. Return false and the I/O manager
115  * will retry using the standard IRP method. Use a Resource Acquire.
116  */
118  if (!ExAcquireResourceSharedLite(FcbHeader->Resource, FALSE))
119  {
122  return FALSE;
123  }
124  }
125 
126  /* Check if this is a fast I/O cached file */
127  if (!(FileObject->PrivateCacheMap) ||
128  (FcbHeader->IsFastIoPossible == FastIoIsNotPossible))
129  {
130  /* It's not, so fail */
131  Result = FALSE;
132  goto Cleanup;
133  }
134 
135  /* Check if we need to find out if fast I/O is available */
136  if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
137  {
138  /* Sanity check */
140 
141  /* Get the Fast I/O table */
143  FastIoDispatch = Device->DriverObject->FastIoDispatch;
144 
145  /* Sanity check */
148 
149  /* Ask the driver if we can do it */
151  FileOffset,
152  Length,
153  TRUE,
154  LockKey,
155  TRUE,
156  IoStatus,
157  Device))
158  {
159  /* It's not, fail */
160  Result = FALSE;
161  goto Cleanup;
162  }
163  }
164 
165  /* Check if we read too much */
166  if (Offset.QuadPart > FcbHeader->FileSize.QuadPart)
167  {
168  /* We did, check if the file offset is past the end */
169  if (FileOffset->QuadPart >= FcbHeader->FileSize.QuadPart)
170  {
171  /* Set end of file */
172  IoStatus->Status = STATUS_END_OF_FILE;
173  IoStatus->Information = 0;
174  goto Cleanup;
175  }
176 
177  /* Otherwise, just normalize the length */
178  Length = (ULONG)(FcbHeader->FileSize.QuadPart - FileOffset->QuadPart);
179  }
180 
181  /* Set this as top-level IRP */
183 
184  _SEH2_TRY
185  {
186  /* Make sure the IO and file size is below 4GB */
187  if (Wait && !(Offset.HighPart | FcbHeader->FileSize.HighPart))
188  {
189 
190  /* Call the cache controller */
192  FileOffset->LowPart,
193  Length,
194  PageCount,
195  Buffer,
196  IoStatus);
197 
198  /* File was accessed */
200 
201  if (IoStatus->Status != STATUS_END_OF_FILE)
202  {
203  ASSERT((ULONGLONG)FcbHeader->FileSize.QuadPart >=
204  ((ULONGLONG)FileOffset->QuadPart + IoStatus->Information));
205  }
206  }
207  else
208  {
209 
210  /* Call the cache controller */
212  FileOffset,
213  Length,
214  Wait,
215  Buffer,
216  IoStatus);
217 
218  /* File was accessed */
220 
221  if (Result != FALSE)
222  {
223  ASSERT((IoStatus->Status == STATUS_END_OF_FILE) ||
224  (((ULONGLONG)FileOffset->QuadPart + IoStatus->Information) <=
225  (ULONGLONG)FcbHeader->FileSize.QuadPart));
226  }
227  }
228 
229  /* Update the current file offset */
230  if (Result != FALSE)
231  {
232  FileObject->CurrentByteOffset.QuadPart = FileOffset->QuadPart + IoStatus->Information;
233  }
234  }
237  {
238  Result = FALSE;
239  }
240  _SEH2_END;
241 
242  PsGetCurrentThread()->TopLevelIrp = 0;
243 
244  /* Return to caller */
245 Cleanup:
246 
247  ExReleaseResourceLite(FcbHeader->Resource);
249 
250  if (Result == FALSE)
251  {
253  }
254 
255  return Result;
256 }
257 
258 
259 /*
260  * @implemented
261  */
262 BOOLEAN
263 NTAPI
266  IN ULONG Length,
267  IN BOOLEAN Wait,
268  IN ULONG LockKey,
269  OUT PVOID Buffer,
272 {
273  BOOLEAN Result = TRUE;
276  PFSRTL_COMMON_FCB_HEADER FcbHeader;
277  PSHARED_CACHE_MAP SharedCacheMap;
278 
279  /* WDK doc.
280  * Offset == 0xffffffffffffffff indicates append to the end of file.
281  */
282  BOOLEAN FileOffsetAppend = (FileOffset->HighPart == (LONG)0xffffffff) &&
283  (FileOffset->LowPart == 0xffffffff);
284 
285  BOOLEAN ResourceAcquiredShared = FALSE;
286  BOOLEAN b_4GB = FALSE;
287  BOOLEAN FileSizeModified = FALSE;
288  LARGE_INTEGER OldFileSize;
289  LARGE_INTEGER OldValidDataLength;
292 
293  PAGED_CODE();
294 
296  ASSERT(FileObject->FsContext);
297 
298  /* Initialize some of the vars and pointers */
299  NewSize.QuadPart = 0;
300  Offset.QuadPart = FileOffset->QuadPart + Length;
301  FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
302 
303  /* Nagar p.544.
304  * Check with Cc if we can write and check if the IO > 64kB (WDK macro).
305  */
308  ((FileObject->Flags & FO_WRITE_THROUGH)))
309  {
310  return FALSE;
311  }
312 
313  /* Already init IO_STATUS_BLOCK */
314  IoStatus->Status = STATUS_SUCCESS;
315  IoStatus->Information = Length;
316 
317  /* No actual read */
318  if (!Length)
319  {
320  return TRUE;
321  }
322 
324 
325  /* Nagar p.544/545.
326  * The CcFastCopyWrite doesn't deal with filesize beyond 4GB.
327  */
328  if (Wait && (FcbHeader->AllocationSize.HighPart == 0))
329  {
330  /* If the file offset is not past the file size,
331  * then we can acquire the lock shared.
332  */
333  if ((FileOffsetAppend == FALSE) &&
334  (Offset.LowPart <= FcbHeader->ValidDataLength.LowPart))
335  {
337  ResourceAcquiredShared = TRUE;
338  }
339  else
340  {
342  }
343 
344  /* Nagar p.544/545.
345  * If we append, use the file size as offset.
346  * Also, check that we aren't crossing the 4GB boundary.
347  */
348  if (FileOffsetAppend != FALSE)
349  {
350  Offset.LowPart = FcbHeader->FileSize.LowPart;
351  NewSize.LowPart = FcbHeader->FileSize.LowPart + Length;
352  b_4GB = (NewSize.LowPart < FcbHeader->FileSize.LowPart);
353 
354  }
355  else
356  {
357  Offset.LowPart = FileOffset->LowPart;
358  NewSize.LowPart = FileOffset->LowPart + Length;
359  b_4GB = (NewSize.LowPart < FileOffset->LowPart) ||
360  (FileOffset->HighPart != 0);
361  }
362 
363  /* Nagar p.544/545.
364  * Make sure that caching is initated.
365  * That fast are allowed for this file stream.
366  * That we are not extending past the allocated size.
367  * That we are not creating a hole bigger than 8k.
368  * That we are not crossing the 4GB boundary.
369  */
370  if ((FileObject->PrivateCacheMap != NULL) &&
371  (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
372  (FcbHeader->AllocationSize.LowPart >= NewSize.LowPart) &&
373  (Offset.LowPart < FcbHeader->ValidDataLength.LowPart + 0x2000) &&
374  !b_4GB)
375  {
376  /* If we are extending past the file size, we need to
377  * release the lock and acquire it exclusively, because
378  * we are going to need to update the FcbHeader.
379  */
380  if (ResourceAcquiredShared &&
381  (NewSize.LowPart > FcbHeader->ValidDataLength.LowPart + 0x2000))
382  {
383  /* Then we need to acquire the resource exclusive */
384  ExReleaseResourceLite(FcbHeader->Resource);
386  if (FileOffsetAppend != FALSE)
387  {
388  Offset.LowPart = FcbHeader->FileSize.LowPart; // ??
389  NewSize.LowPart = FcbHeader->FileSize.LowPart + Length;
390 
391  /* Make sure we don't cross the 4GB boundary */
392  b_4GB = (NewSize.LowPart < Offset.LowPart);
393  }
394 
395  /* Recheck some of the conditions since we let the lock go */
396  if ((FileObject->PrivateCacheMap != NULL) &&
397  (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
398  (FcbHeader->AllocationSize.LowPart >= NewSize.LowPart) &&
399  (FcbHeader->AllocationSize.HighPart == 0) &&
400  !b_4GB)
401  {
402  /* Do nothing? */
403  }
404  else
405  {
406  goto FailAndCleanup;
407  }
408  }
409 
410  }
411  else
412  {
413  goto FailAndCleanup;
414  }
415 
416  /* Check if we need to find out if fast I/O is available */
417  if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
418  {
419  IO_STATUS_BLOCK FastIoCheckIfPossibleStatus;
420 
421  /* Sanity check */
423 
424  /* Get the Fast I/O table */
426  FastIoDispatch = Device->DriverObject->FastIoDispatch;
427 
428  /* Sanity check */
431 
432  /* Ask the driver if we can do it */
434  FileOffsetAppend ?
435  &FcbHeader->FileSize :
436  FileOffset,
437  Length,
438  TRUE,
439  LockKey,
440  FALSE,
441  &FastIoCheckIfPossibleStatus,
442  Device))
443  {
444  /* It's not, fail */
445  goto FailAndCleanup;
446  }
447  }
448 
449  /* If we are going to extend the file then save
450  * the old file size in case the operation fails.
451  */
452  if (NewSize.LowPart > FcbHeader->FileSize.LowPart)
453  {
454  FileSizeModified = TRUE;
455  OldFileSize.LowPart = FcbHeader->FileSize.LowPart;
456  OldValidDataLength.LowPart = FcbHeader->ValidDataLength.LowPart;
457  FcbHeader->FileSize.LowPart = NewSize.LowPart;
458  }
459 
460  /* Set this as top-level IRP */
462 
463  _SEH2_TRY
464  {
465  if (Offset.LowPart > FcbHeader->ValidDataLength.LowPart)
466  {
467  LARGE_INTEGER OffsetVar;
468  OffsetVar.LowPart = Offset.LowPart;
469  OffsetVar.HighPart = 0;
470  CcZeroData(FileObject, &FcbHeader->ValidDataLength, &OffsetVar, TRUE);
471  }
472 
473  /* Call the cache manager */
475  }
479  {
480  Result = FALSE;
481  }
482  _SEH2_END;
483 
484  /* Remove ourselves at the top level component after the IO is done */
485  PsGetCurrentThread()->TopLevelIrp = 0;
486 
487  /* Did the operation succeed? */
488  if (Result != FALSE)
489  {
490  /* Update the valid file size if necessary */
491  if (NewSize.LowPart > FcbHeader->ValidDataLength.LowPart)
492  {
493  FcbHeader->ValidDataLength.LowPart = NewSize.LowPart;
494  }
495 
496  /* Flag the file as modified */
497  FileObject->Flags |= FO_FILE_MODIFIED;
498 
499  /* Update the strucutres if the file size changed */
500  if (FileSizeModified)
501  {
502  SharedCacheMap =
503  (PSHARED_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
504  SharedCacheMap->FileSize.LowPart = NewSize.LowPart;
506  }
507 
508  /* Update the file object current file offset */
509  FileObject->CurrentByteOffset.QuadPart = NewSize.LowPart;
510 
511  }
512  else
513  {
514  /* Result == FALSE if we get here */
515  if (FileSizeModified)
516  {
517  /* If the file size was modified then restore the old file size */
518  if (FcbHeader->PagingIoResource != NULL)
519  {
520  /* Nagar P.544.
521  * Restore the old file size if operation didn't succeed.
522  */
524  FcbHeader->FileSize.LowPart = OldFileSize.LowPart;
525  FcbHeader->ValidDataLength.LowPart = OldValidDataLength.LowPart;
527  }
528  else
529  {
530  /* If there is no lock and do it without */
531  FcbHeader->FileSize.LowPart = OldFileSize.LowPart;
532  FcbHeader->ValidDataLength.LowPart = OldValidDataLength.LowPart;
533  }
534  }
535  else
536  {
537  /* Do nothing? */
538  }
539  }
540 
541  goto Cleanup;
542  }
543  else
544  {
545  LARGE_INTEGER OldFileSize;
546 
547  /* Sanity check */
549 
550  /* Nagar P.544.
551  * Check if we need to acquire the resource exclusive.
552  */
553  if ((FileOffsetAppend == FALSE) &&
554  (FileOffset->QuadPart + Length <= FcbHeader->ValidDataLength.QuadPart))
555  {
556  /* Acquire the resource shared */
557  if (!ExAcquireResourceSharedLite(FcbHeader->Resource, Wait))
558  {
559  goto LeaveCriticalAndFail;
560  }
561  ResourceAcquiredShared = TRUE;
562  }
563  else
564  {
565  /* Acquire the resource exclusive */
566  if (!ExAcquireResourceExclusiveLite(FcbHeader->Resource, Wait))
567  {
568  goto LeaveCriticalAndFail;
569  }
570  }
571 
572  /* Check if we are appending */
573  if (FileOffsetAppend != FALSE)
574  {
575  Offset.QuadPart = FcbHeader->FileSize.QuadPart;
576  NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
577  }
578  else
579  {
580  Offset.QuadPart = FileOffset->QuadPart;
581  NewSize.QuadPart += FileOffset->QuadPart + Length;
582  }
583 
584  /* Nagar p.544/545.
585  * Make sure that caching is initated.
586  * That fast are allowed for this file stream.
587  * That we are not extending past the allocated size.
588  * That we are not creating a hole bigger than 8k.
589  */
590  if ((FileObject->PrivateCacheMap != NULL) &&
591  (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
592  (FcbHeader->ValidDataLength.QuadPart + 0x2000 > Offset.QuadPart) &&
593  (Length <= MAXLONGLONG - Offset.QuadPart) &&
594  (FcbHeader->AllocationSize.QuadPart >= NewSize.QuadPart))
595  {
596  /* Check if we can keep the lock shared */
597  if (ResourceAcquiredShared &&
598  (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart))
599  {
600  ExReleaseResourceLite(FcbHeader->Resource);
601  if (!ExAcquireResourceExclusiveLite(FcbHeader->Resource, Wait))
602  {
603  goto LeaveCriticalAndFail;
604  }
605 
606  /* Compute the offset and the new filesize */
607  if (FileOffsetAppend)
608  {
609  Offset.QuadPart = FcbHeader->FileSize.QuadPart;
610  NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
611  }
612 
613  /* Recheck the above points since we released and reacquire the lock */
614  if ((FileObject->PrivateCacheMap != NULL) &&
615  (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
616  (FcbHeader->AllocationSize.QuadPart > NewSize.QuadPart))
617  {
618  /* Do nothing */
619  }
620  else
621  {
622  goto FailAndCleanup;
623  }
624  }
625 
626  /* Check if we need to find out if fast I/O is available */
627  if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
628  {
629  IO_STATUS_BLOCK FastIoCheckIfPossibleStatus;
630 
631  /* Sanity check */
633 
634  /* Get the Fast I/O table */
636  FastIoDispatch = Device->DriverObject->FastIoDispatch;
637 
638  /* Sanity check */
641 
642  /* Ask the driver if we can do it */
644  FileOffsetAppend ?
645  &FcbHeader->FileSize :
646  FileOffset,
647  Length,
648  Wait,
649  LockKey,
650  FALSE,
651  &FastIoCheckIfPossibleStatus,
652  Device))
653  {
654  /* It's not, fail */
655  goto FailAndCleanup;
656  }
657  }
658 
659  /* If we are going to modify the filesize,
660  * save the old fs in case the operation fails.
661  */
662  if (NewSize.QuadPart > FcbHeader->FileSize.QuadPart)
663  {
664  FileSizeModified = TRUE;
665  OldFileSize.QuadPart = FcbHeader->FileSize.QuadPart;
666  OldValidDataLength.QuadPart = FcbHeader->ValidDataLength.QuadPart;
667 
668  /* If the high part of the filesize is going
669  * to change, grab the Paging IoResouce.
670  */
671  if (NewSize.HighPart != FcbHeader->FileSize.HighPart &&
672  FcbHeader->PagingIoResource)
673  {
675  FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
677  }
678  else
679  {
680  FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
681  }
682  }
683 
684  /* Nagar p.544.
685  * Set ourselves as top component.
686  */
688 
689  _SEH2_TRY
690  {
691  BOOLEAN CallCc = TRUE;
692 
693  /* Check if there is a gap between the end of the file
694  * and the offset. If yes, then we have to zero the data.
695  */
696  if (Offset.QuadPart > FcbHeader->ValidDataLength.QuadPart)
697  {
698  if (!(Result = CcZeroData(FileObject,
699  &FcbHeader->ValidDataLength,
700  &Offset,
701  Wait)))
702  {
703  /* If this operation fails, then we have to exit. We can't jump
704  * outside the SEH, so I am using a variable to exit normally.
705  */
706  CallCc = FALSE;
707  }
708  }
709 
710  /* Unless the CcZeroData failed, call the cache manager */
711  if (CallCc)
712  {
714  }
715  }
719  {
720  Result = FALSE;
721  }
722  _SEH2_END;
723 
724  /* Reset the top component */
726 
727  /* Did the operation suceeded */
728  if (Result)
729  {
730  /* Check if we need to update the filesize */
731  if (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart)
732  {
733  if (NewSize.HighPart != FcbHeader->ValidDataLength.HighPart &&
734  FcbHeader->PagingIoResource)
735  {
737  FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
739  }
740  else
741  {
742  FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
743  }
744  }
745 
746  /* Flag the file as modified */
747  FileObject->Flags |= FO_FILE_MODIFIED;
748 
749  /* Check if the filesize has changed */
750  if (FileSizeModified)
751  {
752  /* Update the file sizes */
753  SharedCacheMap =
754  (PSHARED_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
755  SharedCacheMap->FileSize.QuadPart = NewSize.QuadPart;
757  }
758 
759  /* Update the current FO byte offset */
760  FileObject->CurrentByteOffset.QuadPart = NewSize.QuadPart;
761  }
762  else
763  {
764  /* The operation did not succeed.
765  * Reset the file size to what it should be.
766  */
767  if (FileSizeModified)
768  {
769  if (FcbHeader->PagingIoResource)
770  {
772  FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
773  FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
775  }
776  else
777  {
778  FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
779  FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
780  }
781  }
782  }
783 
784  goto Cleanup;
785  }
786  else
787  {
788  goto FailAndCleanup;
789  }
790  }
791 
792 LeaveCriticalAndFail:
793 
795  return FALSE;
796 
797 FailAndCleanup:
798 
799  ExReleaseResourceLite(FcbHeader->Resource);
801  return FALSE;
802 
803 Cleanup:
804 
805  ExReleaseResourceLite(FcbHeader->Resource);
807  return Result;
808 }
809 
810 /*
811  * @implemented
812  */
813 NTSTATUS
814 NTAPI
817 {
822  PFAST_IO_DISPATCH FastDispatch;
823  KEVENT Event;
824  PIO_STACK_LOCATION IoStackLocation;
825  PIRP Irp;
826  BOOLEAN OldHardError;
827 
828  PAGED_CODE();
829 
830  /* Get Device Object and Fast Calls */
832  FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
833 
834  /* Check if we support Fast Calls, and check FastIoQueryStandardInfo.
835  * Call the function and see if it succeeds.
836  */
837  if (!FastDispatch ||
838  !FastDispatch->FastIoQueryStandardInfo ||
839  !FastDispatch->FastIoQueryStandardInfo(FileObject,
840  TRUE,
841  &Info,
842  &IoStatus,
843  DeviceObject))
844  {
845  /* If any of the above failed, then we are going to send an
846  * IRP to the device object. Initialize the event for the IO.
847  */
849 
850  /* Allocate the IRP */
852 
853  if (Irp == NULL)
854  {
856  }
857 
858  /* Don't process hard error */
859  OldHardError = IoSetThreadHardErrorMode(FALSE);
860 
861  /* Setup the IRP */
862  Irp->UserIosb = &IoStatus;
863  Irp->UserEvent = &Event;
864  Irp->Tail.Overlay.Thread = PsGetCurrentThread();
866  Irp->RequestorMode = KernelMode;
867  Irp->Tail.Overlay.OriginalFileObject = FileObject;
868  Irp->AssociatedIrp.SystemBuffer = &Info;
869 
870  /* Setup out stack location */
871  IoStackLocation = Irp->Tail.Overlay.CurrentStackLocation;
872  IoStackLocation--;
873  IoStackLocation->MajorFunction = IRP_MJ_QUERY_INFORMATION;
874  IoStackLocation->FileObject = FileObject;
875  IoStackLocation->DeviceObject = DeviceObject;
876  IoStackLocation->Parameters.QueryFile.Length =
878  IoStackLocation->Parameters.QueryFile.FileInformationClass =
880 
881  /* Send the IRP to the related device object */
883 
884  /* Standard DDK IRP result processing */
885  if (Status == STATUS_PENDING)
886  {
888  }
889 
890  /* If there was a synchronous error, signal it */
891  if (!NT_SUCCESS(Status))
892  {
893  IoStatus.Status = Status;
894  }
895 
896  IoSetThreadHardErrorMode(OldHardError);
897  }
898 
899  /* Check the sync/async IO result */
900  if (NT_SUCCESS(IoStatus.Status))
901  {
902  /* Was the request for a directory? */
903  if (Info.Directory)
904  {
906  }
907  else
908  {
909  FileSize->QuadPart = Info.EndOfFile.QuadPart;
910  }
911  }
912 
913  return IoStatus.Status;
914 }
915 
916 /*
917  * @implemented
918  */
919 BOOLEAN
920 NTAPI
923  IN ULONG Length,
924  IN ULONG LockKey,
925  OUT PMDL *MdlChain,
927 {
928  PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
929  PFAST_IO_DISPATCH FastDispatch;
930 
931  /* Get Device Object and Fast Calls */
933  FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
934 
935  /* Check if we support Fast Calls, and check this one */
936  if (FastDispatch && FastDispatch->MdlRead)
937  {
938  /* Use the fast path */
939  return FastDispatch->MdlRead(FileObject,
940  FileOffset,
941  Length,
942  LockKey,
943  MdlChain,
944  IoStatus,
945  DeviceObject);
946  }
947 
948  /* Get the Base File System (Volume) and Fast Calls */
949  BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
950  FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
951 
952  /* If the Base Device Object has its own FastDispatch Routine, fail */
953  if (FastDispatch && FastDispatch->MdlRead && BaseDeviceObject != DeviceObject)
954  {
955  return FALSE;
956  }
957 
958  /* No fast path, use slow path */
960  FileOffset,
961  Length,
962  LockKey,
963  MdlChain,
964  IoStatus,
965  DeviceObject);
966 }
967 
968 /*
969  * @implemented
970  */
971 BOOLEAN
972 NTAPI
975 {
976  PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
977  PFAST_IO_DISPATCH FastDispatch;
978 
979  /* Get Device Object and Fast Calls */
981  FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
982 
983  /* Check if we support Fast Calls, and check this one */
984  if (FastDispatch && FastDispatch->MdlReadComplete)
985  {
986  /* Use the fast path */
987  return FastDispatch->MdlReadComplete(FileObject, MdlChain, DeviceObject);
988  }
989 
990  /* Get the Base File System (Volume) and Fast Calls */
991  BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
992  FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
993 
994  /* If the Base Device Object has its own FastDispatch Routine, fail */
995  if ((BaseDeviceObject != DeviceObject) &&
996  FastDispatch &&
997  FastDispatch->MdlReadComplete)
998  {
999  return FALSE;
1000  }
1001 
1002  /* No fast path, use slow path */
1004 }
1005 
1006 /*
1007  * @implemented
1008  */
1009 BOOLEAN
1010 NTAPI
1014 {
1015  /* Call the Cache Manager */
1017  return TRUE;
1018 }
1019 
1020 /*
1021  * @implemented
1022  */
1023 BOOLEAN
1024 NTAPI
1027  IN ULONG Length,
1028  IN ULONG LockKey,
1029  OUT PMDL *MdlChain,
1032 {
1033  PFSRTL_COMMON_FCB_HEADER FcbHeader;
1034  BOOLEAN Result = TRUE;
1038  PAGED_CODE();
1039 
1040  /* No actual read */
1041  if (!Length)
1042  {
1043  /* Return success */
1044  IoStatus->Status = STATUS_SUCCESS;
1045  IoStatus->Information = 0;
1046  return TRUE;
1047  }
1048 
1049  /* Sanity check */
1050  ASSERT(MAXLONGLONG - FileOffset->QuadPart >= (LONGLONG)Length);
1051 
1052  /* Get the offset and FCB header */
1053  Offset.QuadPart = FileOffset->QuadPart + Length;
1054  FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1055 
1056  /* Enter the FS */
1059 
1060  /* Lock the FCB */
1061  ExAcquireResourceShared(FcbHeader->Resource, TRUE);
1062 
1063  /* Check if this is a fast I/O cached file */
1064  if (!(FileObject->PrivateCacheMap) ||
1065  (FcbHeader->IsFastIoPossible == FastIoIsNotPossible))
1066  {
1067  /* It's not, so fail */
1069  Result = FALSE;
1070  goto Cleanup;
1071  }
1072 
1073  /* Check if we need to find out if fast I/O is available */
1074  if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
1075  {
1076  /* Get the Fast I/O table */
1078  FastIoDispatch = Device->DriverObject->FastIoDispatch;
1079 
1080  /* Sanity check */
1084 
1085  /* Ask the driver if we can do it */
1087  FileOffset,
1088  Length,
1089  TRUE,
1090  LockKey,
1091  TRUE,
1092  IoStatus,
1093  Device))
1094  {
1095  /* It's not, fail */
1097  Result = FALSE;
1098  goto Cleanup;
1099  }
1100  }
1101 
1102  /* Check if we read too much */
1103  if (Offset.QuadPart > FcbHeader->FileSize.QuadPart)
1104  {
1105  /* We did, check if the file offset is past the end */
1106  if (FileOffset->QuadPart >= FcbHeader->FileSize.QuadPart)
1107  {
1108  /* Set end of file */
1109  IoStatus->Status = STATUS_END_OF_FILE;
1110  IoStatus->Information = 0;
1111  goto Cleanup;
1112  }
1113 
1114  /* Otherwise, just normalize the length */
1115  Length = (ULONG)(FcbHeader->FileSize.QuadPart - FileOffset->QuadPart);
1116  }
1117 
1118  /* Set this as top-level IRP */
1120 
1121  _SEH2_TRY
1122  {
1123  /* Attempt a read */
1125  FileObject->Flags |= FO_FILE_FAST_IO_READ;
1126  }
1130  {
1131  Result = FALSE;
1132  }
1133  _SEH2_END;
1134 
1135 
1136  /* Remove the top-level IRP flag */
1137  PsGetCurrentThread()->TopLevelIrp = 0;
1138 
1139  /* Return to caller */
1140 Cleanup:
1141 
1142  ExReleaseResourceLite(FcbHeader->Resource);
1144 
1145  return Result;
1146 }
1147 
1148 /*
1149  * @implemented
1150  */
1151 BOOLEAN
1152 NTAPI
1155  IN PMDL MdlChain)
1156 {
1157  PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1158  PFAST_IO_DISPATCH FastDispatch;
1159 
1160  /* Get Device Object and Fast Calls */
1162  FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1163 
1164  /* Check if we support Fast Calls, and check this one */
1165  if (FastDispatch && FastDispatch->MdlWriteComplete)
1166  {
1167  /* Use the fast path */
1168  return FastDispatch->MdlWriteComplete(FileObject,
1169  FileOffset,
1170  MdlChain,
1171  DeviceObject);
1172  }
1173 
1174  /* Get the Base File System (Volume) and Fast Calls */
1175  BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1176  FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
1177 
1178  /* If the Base Device Object has its own FastDispatch Routine, fail */
1179  if (FastDispatch &&
1180  FastDispatch->MdlWriteComplete &&
1181  BaseDeviceObject != DeviceObject)
1182  {
1183  return FALSE;
1184  }
1185 
1186  /* No fast path, use slow path */
1188  FileOffset,
1189  MdlChain,
1190  DeviceObject);
1191 }
1192 
1193 /*
1194  * @implemented
1195  */
1196 BOOLEAN
1197 NTAPI
1200  IN PMDL MdlChain,
1202 {
1203  if (FileObject->Flags & FO_WRITE_THROUGH)
1204  {
1205  return FALSE;
1206  }
1207 
1208  /* Call the Cache Manager */
1210  return TRUE;
1211 }
1212 
1213 /*
1214  * @implemented
1215  */
1216 BOOLEAN
1217 NTAPI
1220  IN ULONG Length,
1221  IN ULONG LockKey,
1222  OUT PMDL *MdlChain,
1224 {
1225  PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1226  PFAST_IO_DISPATCH FastDispatch;
1227 
1228  /* Get Device Object and Fast Calls */
1230  FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1231 
1232  /* Check if we support Fast Calls, and check this one */
1233  if (FastDispatch && FastDispatch->PrepareMdlWrite)
1234  {
1235  /* Use the fast path */
1236  return FastDispatch->PrepareMdlWrite(FileObject,
1237  FileOffset,
1238  Length,
1239  LockKey,
1240  MdlChain,
1241  IoStatus,
1242  DeviceObject);
1243  }
1244 
1245  /* Get the Base File System (Volume) and Fast Calls */
1246  BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1247  FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
1248 
1249  /* If the Base Device Object has its own FastDispatch Routine, fail */
1250  if (FastDispatch &&
1251  FastDispatch->PrepareMdlWrite &&
1252  BaseDeviceObject != DeviceObject)
1253  {
1254  return FALSE;
1255  }
1256 
1257  /* No fast path, use slow path */
1259  FileOffset,
1260  Length,
1261  LockKey,
1262  MdlChain,
1263  IoStatus,
1264  DeviceObject);
1265 }
1266 
1267 /*
1268  * @implemented
1269  */
1270 BOOLEAN
1271 NTAPI
1274  IN ULONG Length,
1275  IN ULONG LockKey,
1276  OUT PMDL *MdlChain,
1279 {
1280  BOOLEAN Result = TRUE;
1283  PFSRTL_COMMON_FCB_HEADER FcbHeader;
1284  PSHARED_CACHE_MAP SharedCacheMap;
1285 
1286  LARGE_INTEGER OldFileSize;
1287  LARGE_INTEGER OldValidDataLength;
1290 
1291  /* WDK doc.
1292  * Offset == 0xffffffffffffffff indicates append to the end of file.
1293  */
1294  BOOLEAN FileOffsetAppend = (FileOffset->HighPart == (LONG)0xffffffff) &&
1295  (FileOffset->LowPart == 0xffffffff);
1296 
1297  BOOLEAN FileSizeModified = FALSE;
1298  BOOLEAN ResourceAcquiredShared = FALSE;
1299 
1300  /* Initialize some of the vars and pointers */
1301  OldFileSize.QuadPart = 0;
1302  OldValidDataLength.QuadPart = 0;
1303 
1304  PAGED_CODE();
1305 
1306  Offset.QuadPart = FileOffset->QuadPart + Length;
1307 
1308  /* Nagar p.544.
1309  * Check with Cc if we can write.
1310  */
1311  if (!CcCanIWrite(FileObject, Length, TRUE, FALSE) ||
1312  (FileObject->Flags & FO_WRITE_THROUGH))
1313  {
1314  return FALSE;
1315  }
1316 
1317  IoStatus->Status = STATUS_SUCCESS;
1318 
1319  /* No actual read */
1320  if (!Length)
1321  {
1322  return TRUE;
1323  }
1324 
1325  FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1327 
1328  /* Check we are going to extend the file */
1329  if ((FileOffsetAppend == FALSE) &&
1330  (FileOffset->QuadPart + Length <= FcbHeader->ValidDataLength.QuadPart))
1331  {
1332  /* Acquire the resource shared */
1334  ResourceAcquiredShared = TRUE;
1335  }
1336  else
1337  {
1338  /* Acquire the resource exclusive */
1340  }
1341 
1342  /* Check if we are appending */
1343  if (FileOffsetAppend != FALSE)
1344  {
1345  Offset.QuadPart = FcbHeader->FileSize.QuadPart;
1346  NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
1347  }
1348  else
1349  {
1350  Offset.QuadPart = FileOffset->QuadPart;
1351  NewSize.QuadPart = FileOffset->QuadPart + Length;
1352  }
1353 
1354  if ((FileObject->PrivateCacheMap) &&
1355  (FcbHeader->IsFastIoPossible) &&
1357  (NewSize.QuadPart <= FcbHeader->AllocationSize.QuadPart))
1358  {
1359  /* Check if we can keep the lock shared */
1360  if (ResourceAcquiredShared &&
1361  (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart))
1362  {
1363  ExReleaseResourceLite(FcbHeader->Resource);
1365 
1366  /* Compute the offset and the new filesize */
1367  if (FileOffsetAppend)
1368  {
1369  Offset.QuadPart = FcbHeader->FileSize.QuadPart;
1370  NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
1371  }
1372 
1373  /* Recheck the above points since we released and reacquire the lock */
1374  if ((FileObject->PrivateCacheMap != NULL) &&
1375  (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
1376  (FcbHeader->AllocationSize.QuadPart > NewSize.QuadPart))
1377  {
1378  /* Do nothing */
1379  }
1380  else
1381  {
1382  goto FailAndCleanup;
1383  }
1384  }
1385 
1386  /* Check if we need to find out if fast I/O is available */
1387  if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
1388  {
1389  /* Sanity check */
1390  /* ASSERT(!KeIsExecutingDpc()); */
1391 
1392  /* Get the Fast I/O table */
1394  FastIoDispatch = Device->DriverObject->FastIoDispatch;
1395 
1396  /* Sanity check */
1399 
1400  /* Ask the driver if we can do it */
1402  FileOffset,
1403  Length,
1404  TRUE,
1405  LockKey,
1406  FALSE,
1407  IoStatus,
1408  Device))
1409  {
1410  /* It's not, fail */
1411  goto FailAndCleanup;
1412  }
1413  }
1414 
1415  /* If we are going to modify the filesize,
1416  * save the old fs in case the operation fails.
1417  */
1418  if (NewSize.QuadPart > FcbHeader->FileSize.QuadPart)
1419  {
1420  FileSizeModified = TRUE;
1421  OldFileSize.QuadPart = FcbHeader->FileSize.QuadPart;
1422  OldValidDataLength.QuadPart = FcbHeader->ValidDataLength.QuadPart;
1423 
1424  /* If the high part of the filesize is going
1425  * to change, grab the Paging IoResouce.
1426  */
1427  if (NewSize.HighPart != FcbHeader->FileSize.HighPart &&
1428  FcbHeader->PagingIoResource)
1429  {
1431  FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
1433  }
1434  else
1435  {
1436  FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
1437  }
1438  }
1439 
1440 
1441  /* Nagar p.544.
1442  * Set ourselves as top component.
1443  */
1445  _SEH2_TRY
1446  {
1447  /* Check if there is a gap between the end of the file and the offset.
1448  * If yes, then we have to zero the data.
1449  */
1450  if (Offset.QuadPart > FcbHeader->ValidDataLength.QuadPart)
1451  {
1453  &FcbHeader->ValidDataLength,
1454  &Offset,
1455  TRUE);
1456  if (Result)
1457  {
1459  &Offset,
1460  Length,
1461  MdlChain,
1462  IoStatus);
1463  }
1464  }
1465  else
1466  {
1468  }
1469 
1470  }
1474  {
1475  Result = FALSE;
1476  }
1477  _SEH2_END;
1478 
1479  /* Reset the top component */
1480  PsGetCurrentThread()->TopLevelIrp = 0;
1481 
1482  /* Did the operation suceeded */
1483  if (Result)
1484  {
1485  /* Check if we need to update the filesize */
1486  if (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart)
1487  {
1488  if (NewSize.HighPart != FcbHeader->ValidDataLength.HighPart &&
1489  FcbHeader->PagingIoResource)
1490  {
1492  FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
1494  }
1495  else
1496  {
1497  FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
1498  }
1499  }
1500 
1501  /* Flag the file as modified */
1502  FileObject->Flags |= FO_FILE_MODIFIED;
1503 
1504  /* Check if the filesize has changed */
1505  if (FileSizeModified)
1506  {
1507  SharedCacheMap =
1508  (PSHARED_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
1509  SharedCacheMap->FileSize.QuadPart = NewSize.QuadPart;
1510  FileObject->Flags |= FO_FILE_SIZE_CHANGED;
1511  }
1512  }
1513  else
1514  {
1515  /* The operation did not succeed.
1516  * Reset the file size to what it should be.
1517  */
1518  if (FileSizeModified)
1519  {
1520  if (FcbHeader->PagingIoResource)
1521  {
1523  FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
1524  FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
1526  }
1527  else
1528  {
1529  FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
1530  FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
1531  }
1532  }
1533  }
1534 
1535  goto Cleanup;
1536  }
1537  else
1538  {
1539  goto FailAndCleanup;
1540  }
1541 
1542 FailAndCleanup:
1543 
1544  ExReleaseResourceLite(FcbHeader->Resource);
1546  return FALSE;
1547 
1548 Cleanup:
1549 
1550  ExReleaseResourceLite(FcbHeader->Resource);
1552  return Result;
1553 }
1554 
1555 NTSTATUS
1556 NTAPI
1559  IN ULONG Reserved)
1560 {
1561  PFSRTL_COMMON_FCB_HEADER FcbHeader;
1563  PFAST_IO_DISPATCH FastDispatch;
1564 
1565  /* Get Device Object and Fast Calls */
1566  FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1568  FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1569 
1570  /* Get master FsRtl lock */
1572 
1573  /* Check if Fast Calls are supported, and check AcquireFileForNtCreateSection */
1574  if (FastDispatch &&
1575  FastDispatch->AcquireFileForNtCreateSection)
1576  {
1577  /* Call the AcquireFileForNtCreateSection FastIo handler */
1579  }
1580  else
1581  {
1582  /* No FastIo handler, acquire file's resource exclusively */
1583  if (FcbHeader && FcbHeader->Resource) ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
1584  }
1585 
1586  return STATUS_SUCCESS;
1587 }
1588 
1589 /*
1590 * @implemented
1591 */
1592 VOID
1593 NTAPI
1595 {
1596  PAGED_CODE();
1597 
1598  /* Call the common routine. Don't care about the result */
1600 }
1601 
1602 /*
1603 * @implemented
1604 */
1605 VOID
1606 NTAPI
1608 {
1609  PFSRTL_COMMON_FCB_HEADER FcbHeader;
1611  PFAST_IO_DISPATCH FastDispatch;
1612 
1613  /* Get Device Object and Fast Calls */
1614  FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1616  FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1617 
1618  /* Check if Fast Calls are supported and check ReleaseFileForNtCreateSection */
1619  if (FastDispatch &&
1620  FastDispatch->ReleaseFileForNtCreateSection)
1621  {
1622  /* Call the ReleaseFileForNtCreateSection FastIo handler */
1624  }
1625  else
1626  {
1627  /* No FastIo handler, release file's resource */
1628  if (FcbHeader && FcbHeader->Resource) ExReleaseResourceLite(FcbHeader->Resource);
1629  }
1630 
1631  /* Release master FsRtl lock */
1633 }
1634 
1635 /*
1636 * @implemented
1637 */
1638 NTSTATUS
1639 NTAPI
1641 {
1642  PFSRTL_COMMON_FCB_HEADER FcbHeader;
1643  PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1644  PFAST_IO_DISPATCH FastDispatch;
1645  NTSTATUS Status;
1646 
1647  /* Get the Base File System (Volume) and Fast Calls */
1648  FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1650  BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1651  FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1652 
1653  /* Get master FsRtl lock */
1655 
1656  /* Check if Fast Calls are supported, and check AcquireForCcFlush */
1657  if (FastDispatch &&
1658  FastDispatch->AcquireForCcFlush)
1659  {
1660  /* Call the AcquireForCcFlush FastIo handler */
1661  Status = FastDispatch->AcquireForCcFlush(FileObject, BaseDeviceObject);
1662 
1663  /* Return either success or inability to wait.
1664  In case of other failure - fall through */
1665  if (Status == STATUS_SUCCESS ||
1667  {
1668  return Status;
1669  }
1670  }
1671 
1672  /* No FastIo handler (or it failed). Acquire Main resource */
1673  if (FcbHeader->Resource)
1674  {
1675  /* Acquire it - either shared if it's already acquired
1676  or exclusively if we are the first */
1677  if (ExIsResourceAcquiredSharedLite(FcbHeader->Resource))
1679  else
1681  }
1682 
1683  /* Also acquire its PagingIO resource */
1684  if (FcbHeader->PagingIoResource)
1686 
1687  return STATUS_SUCCESS;
1688 }
1689 
1690 /*
1691 * @implemented
1692 */
1693 VOID
1694 NTAPI
1696 {
1697  PAGED_CODE();
1698 
1699  /* Call the common routine. Don't care about the result */
1701 }
1702 
1703 
1704 /*
1705 * @implemented
1706 */
1707 VOID
1708 NTAPI
1710 {
1711  PFSRTL_COMMON_FCB_HEADER FcbHeader;
1712  PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1713  PFAST_IO_DISPATCH FastDispatch;
1715 
1716  /* Get Device Object and Fast Calls */
1717  FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1719  BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1720  FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1721 
1722  /* Check if Fast Calls are supported, and check ReleaseForCcFlush */
1723  if (FastDispatch &&
1724  FastDispatch->ReleaseForCcFlush)
1725  {
1726  /* Call the ReleaseForCcFlush FastIo handler */
1727  Status = FastDispatch->ReleaseForCcFlush(FileObject, BaseDeviceObject);
1728  }
1729 
1730  if (!NT_SUCCESS(Status))
1731  {
1732  /* No FastIo handler (or it failed). Release PagingIO resource and
1733  then Main resource */
1734  if (FcbHeader->PagingIoResource) ExReleaseResourceLite(FcbHeader->PagingIoResource);
1735  if (FcbHeader->Resource) ExReleaseResourceLite(FcbHeader->Resource);
1736  }
1737 
1738  /* Release master FsRtl lock */
1740 }
1741 
1742 /*
1743 * @implemented
1744 */
1745 NTSTATUS
1746 NTAPI
1750 {
1751  PFSRTL_COMMON_FCB_HEADER FcbHeader;
1752  PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1753  PFAST_IO_DISPATCH FastDispatch;
1754  PERESOURCE ResourceToAcquire = NULL;
1755  BOOLEAN Exclusive = FALSE;
1756  BOOLEAN Result;
1758 
1759  /* Get Device Object and Fast Calls */
1760  FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1762  BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1763  FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1764 
1765  /* Check if Fast Calls are supported, and check AcquireForModWrite */
1766  if (FastDispatch &&
1767  FastDispatch->AcquireForModWrite)
1768  {
1769  /* Call the AcquireForModWrite FastIo handler */
1770  Status = FastDispatch->AcquireForModWrite(FileObject,
1771  EndingOffset,
1773  BaseDeviceObject);
1774 
1775  /* Return either success or inability to wait.
1776  In case of other failure - fall through */
1777  if (Status == STATUS_SUCCESS ||
1779  {
1780  return Status;
1781  }
1782  }
1783 
1785 
1786  /* No FastIo handler, use algorithm from Nagar p.550. */
1787  if (!FcbHeader->Resource)
1788  {
1790  return STATUS_SUCCESS;
1791  }
1792 
1793  /* Default condition - shared acquiring of Paging IO Resource */
1794  ResourceToAcquire = FcbHeader->PagingIoResource;
1795 
1796  /* Decide on type of locking and type of resource based on historical magic
1797  well explain by Nagar in p. 550-551 */
1798  if ((EndingOffset->QuadPart > FcbHeader->ValidDataLength.QuadPart &&
1799  FcbHeader->FileSize.QuadPart != FcbHeader->ValidDataLength.QuadPart) ||
1800  (FcbHeader->Flags & FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX))
1801  {
1802  /* Either exclusive flag is set or write operation is extending
1803  the valid data length. Prefer exclusive acquire then */
1804  Exclusive = TRUE;
1805  ResourceToAcquire = FcbHeader->Resource;
1806  }
1807  else if (!FcbHeader->PagingIoResource ||
1808  (FcbHeader->Flags & FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH))
1809  {
1810  /* Acquire main resource shared if flag is specified or
1811  if PagingIo resource is missing */
1812  Exclusive = FALSE;
1813  ResourceToAcquire = FcbHeader->Resource;
1814  }
1815 
1816  /* Acquire the resource in the loop, since the above code is unsafe */
1817  while (TRUE)
1818  {
1819  Result = FALSE;
1820 
1821  if (Exclusive)
1822  Result = ExAcquireResourceExclusiveLite(ResourceToAcquire, FALSE);
1823  else
1824  Result = ExAcquireSharedWaitForExclusive(ResourceToAcquire, FALSE);
1825 
1826  if (!Result) {
1828  break;
1829  }
1830 
1831  /* Do the magic ifs again */
1832  if ((EndingOffset->QuadPart > FcbHeader->ValidDataLength.QuadPart) ||
1833  (FcbHeader->Flags & FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX))
1834  {
1835  /* Check what we have */
1836  if (Exclusive)
1837  {
1838  /* Asked for exclusive, got exclusive! */
1839  break;
1840  }
1841  else
1842  {
1843  /* Asked for exclusive, got shared. Release it and retry. */
1844  ExReleaseResourceLite(ResourceToAcquire);
1845  Exclusive = TRUE;
1846  ResourceToAcquire = FcbHeader->Resource;
1847  }
1848  }
1849  else if (FcbHeader->Flags & FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH)
1850  {
1851  if (Exclusive)
1852  {
1853  /* Asked for shared, got exclusive - convert */
1854  ExConvertExclusiveToSharedLite(ResourceToAcquire);
1855  break;
1856  }
1857  else if (ResourceToAcquire != FcbHeader->Resource)
1858  {
1859  /* Asked for main resource, got something else */
1860  ExReleaseResourceLite(ResourceToAcquire);
1861  ResourceToAcquire = FcbHeader->Resource;
1862  Exclusive = TRUE;
1863  }
1864  }
1865  else if (FcbHeader->PagingIoResource &&
1866  ResourceToAcquire != FcbHeader->PagingIoResource)
1867  {
1868  /* There is PagingIo resource, but other resource was acquired */
1869  ResourceToAcquire = FcbHeader->PagingIoResource;
1870  if (!ExAcquireSharedWaitForExclusive(ResourceToAcquire, FALSE))
1871  {
1873  ExReleaseResourceLite(FcbHeader->Resource);
1874  }
1875 
1876  break;
1877  }
1878  else if (Exclusive)
1879  {
1880  /* Asked for shared got exclusive - convert */
1881  ExConvertExclusiveToSharedLite(ResourceToAcquire);
1882  break;
1883  }
1884  }
1885 
1886  /* If the resource was acquired successfully - pass it to the caller */
1887  if (NT_SUCCESS(Status))
1888  *ResourceToRelease = ResourceToAcquire;
1889 
1890  return Status;
1891 }
1892 
1893 /*
1894 * @implemented
1895 */
1896 VOID
1897 NTAPI
1900 {
1901  PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1902  PFAST_IO_DISPATCH FastDispatch;
1904 
1905  /* Get Device Object and Fast Calls */
1907  BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1908  FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1909 
1910  /* Check if Fast Calls are supported and check ReleaseFileForNtCreateSection */
1911  if (FastDispatch &&
1912  FastDispatch->ReleaseForModWrite)
1913  {
1914  /* Call the ReleaseForModWrite FastIo handler */
1915  Status = FastDispatch->ReleaseForModWrite(FileObject,
1917  BaseDeviceObject);
1918  }
1919 
1920  /* Just release the resource if previous op failed */
1921  if (!NT_SUCCESS(Status))
1922  {
1924  }
1925 }
1926 
1927 
1928 /*++
1929  * @name FsRtlRegisterFileSystemFilterCallbacks
1930  * @unimplemented
1931  *
1932  * FILLME
1933  *
1934  * @param FilterDriverObject
1935  * FILLME
1936  *
1937  * @param Callbacks
1938  * FILLME
1939  *
1940  * @return None
1941  *
1942  * @remarks None
1943  *
1944  *--*/
1945 NTSTATUS
1946 NTAPI
1948  PDRIVER_OBJECT FilterDriverObject,
1950 {
1951  PFS_FILTER_CALLBACKS NewCallbacks;
1953  PAGED_CODE();
1954 
1955  /* Verify parameters */
1956  if ((FilterDriverObject == NULL) || (Callbacks == NULL))
1957  {
1958  return STATUS_INVALID_PARAMETER;
1959  }
1960 
1961  /* Allocate a buffer for a copy of the callbacks */
1962  NewCallbacks = ExAllocatePoolWithTag(NonPagedPool,
1963  Callbacks->SizeOfFsFilterCallbacks,
1964  'gmSF');
1965  if (NewCallbacks == NULL)
1966  {
1968  }
1969 
1970  /* Copy the callbacks */
1971  RtlCopyMemory(NewCallbacks, Callbacks, Callbacks->SizeOfFsFilterCallbacks);
1972 
1973  /* Set the callbacks in the driver extension */
1975  DriverExtension->FsFilterCallbacks = NewCallbacks;
1976 
1977  return STATUS_SUCCESS;
1978 }
BOOLEAN NTAPI ExAcquireSharedWaitForExclusive(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:1217
_In_ PLARGE_INTEGER EndingOffset
Definition: iotypes.h:1554
VOID NTAPI CcMdlRead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
Definition: mdlsup.c:64
#define IN
Definition: typedefs.h:38
BOOLEAN NTAPI FsRtlIsNtstatusExpected(IN NTSTATUS NtStatus)
Definition: filter.c:61
ULONG CcFastReadNoWait
Definition: copysup.c:23
ULONG CcFastMdlReadWait
Definition: copysup.c:19
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define STATUS_FILE_IS_A_DIRECTORY
Definition: udferr_usr.h:164
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define FsRtlEnterFileSystem
_In_ PIRP _In_ PDEVICE_OBJECT Device
Definition: fatprocs.h:2020
ULONG CcFastReadNotPossible
Definition: copysup.c:21
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
#define FsRtlExitFileSystem
BOOLEAN NTAPI FsRtlMdlReadCompleteDev(IN PFILE_OBJECT FileObject, IN PMDL MemoryDescriptorList, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:1011
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN OUT PIO_STATUS_BLOCK IoStatus
Definition: fatprocs.h:2650
_In_ PIRP Irp
Definition: csq.h:116
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
_In_ PLARGE_INTEGER _Out_ struct _ERESOURCE ** ResourceToRelease
Definition: iotypes.h:1555
BOOLEAN NTAPI FsRtlMdlWriteCompleteDev(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:1198
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ ULONG _In_ ULONG _Outptr_ PMDL * MdlChain
Definition: fsrtlfuncs.h:46
#define FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX
Definition: fsrtltypes.h:48
VOID NTAPI ExConvertExclusiveToSharedLite(IN PERESOURCE Resource)
Definition: resource.c:1402
VOID NTAPI FsRtlIncrementCcFastReadWait(VOID)
Definition: fastio.c:44
LONG NTSTATUS
Definition: precomp.h:26
PFAST_IO_MDL_READ MdlRead
Definition: iotypes.h:1706
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
PFAST_IO_PREPARE_MDL_WRITE PrepareMdlWrite
Definition: iotypes.h:1708
PFAST_IO_RELEASE_FILE ReleaseFileForNtCreateSection
Definition: iotypes.h:1702
PDEVICE_OBJECT NTAPI IoGetRelatedDeviceObject(IN PFILE_OBJECT FileObject)
Definition: device.c:1539
BOOLEAN NTAPI FsRtlMdlReadComplete(IN PFILE_OBJECT FileObject, IN OUT PMDL MdlChain)
Definition: fastio.c:973
#define MAXLONGLONG
NTSTATUS NTAPI FsRtlGetFileSize(IN PFILE_OBJECT FileObject, IN OUT PLARGE_INTEGER FileSize)
Definition: fastio.c:815
VOID NTAPI FsRtlAcquireFileExclusive(IN PFILE_OBJECT FileObject)
Definition: fastio.c:1594
BOOLEAN NTAPI FsRtlPrepareMdlWriteDev(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:1272
PFAST_IO_RELEASE_FOR_MOD_WRITE ReleaseForModWrite
Definition: iotypes.h:1715
VOID NTAPI FsRtlReleaseFile(IN PFILE_OBJECT FileObject)
Definition: fastio.c:1607
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
BOOLEAN NTAPI FsRtlPrepareMdlWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
Definition: fastio.c:1218
PFAST_IO_MDL_READ_COMPLETE MdlReadComplete
Definition: iotypes.h:1707
BOOLEAN NTAPI KeIsExecutingDpc(VOID)
Definition: dpc.c:946
struct TraceInfo Info
#define PAGED_CODE()
Definition: video.h:57
_SEH2_TRY
Definition: create.c:4250
VOID NTAPI CcMdlReadComplete2(IN PFILE_OBJECT FileObject, IN PMDL MdlChain)
Definition: mdlsup.c:83
#define STATUS_END_OF_FILE
Definition: shellext.h:67
ULONG CcFastReadWait
Definition: copysup.c:22
BOOLEAN NTAPI ExAcquireResourceExclusiveLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:770
#define FO_FILE_SIZE_CHANGED
Definition: iotypes.h:1746
#define FO_FILE_MODIFIED
Definition: iotypes.h:1745
#define EXCEPTION_CONTINUE_SEARCH
Definition: excpt.h:86
ERESOURCE * PERESOURCE
Definition: env_spec_w32.h:595
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
VOID NTAPI CcPrepareMdlWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
Definition: mdlsup.c:91
NTSTATUS NTAPI FsRtlAcquireFileExclusiveCommon(IN PFILE_OBJECT FileObject, IN FS_FILTER_SECTION_SYNC_TYPE SyncType, IN ULONG Reserved)
Definition: fastio.c:1557
BOOLEAN NTAPI CcZeroData(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER StartOffset, IN PLARGE_INTEGER EndOffset, IN BOOLEAN Wait)
Definition: fssup.c:412
#define FO_FILE_FAST_IO_READ
Definition: iotypes.h:1752
_Inout_ PMDL MemoryDescriptorList
Definition: mmfuncs.h:406
long LONG
Definition: pedump.c:60
PDRIVER_EXTENSION DriverExtension
Definition: iotypes.h:2174
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:435
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
unsigned char BOOLEAN
NTSTATUS NTAPI FsRtlAcquireFileForModWriteEx(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER EndingOffset, IN PERESOURCE *ResourceToRelease)
Definition: fastio.c:1747
smooth NULL
Definition: ftsmooth.c:416
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
_Reserved_ PVOID Reserved
Definition: winddi.h:3974
Definition: bufpool.h:45
VOID NTAPI FsRtlIncrementCcFastReadNoWait(VOID)
Definition: fastio.c:54
#define FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH
Definition: fsrtltypes.h:49
VOID NTAPI FsRtlIncrementCcFastReadNotPossible(VOID)
Definition: fastio.c:34
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
#define ADDRESS_AND_SIZE_TO_SPAN_PAGES(_Va, _Size)
BOOLEAN NTAPI FsRtlMdlReadDev(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:1025
VOID NTAPI FsRtlReleaseFileForModWrite(IN PFILE_OBJECT FileObject, IN PERESOURCE ResourceToRelease)
Definition: fastio.c:1898
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG LockKey
Definition: fatprocs.h:2650
int64_t LONGLONG
Definition: typedefs.h:66
const struct winhelp_callbacks Callbacks
Definition: callback.c:161
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
BOOLEAN NTAPI CcCanIWrite(IN PFILE_OBJECT FileObject, IN ULONG BytesToWrite, IN BOOLEAN Wait, IN UCHAR Retrying)
Definition: copysup.c:214
VOID NTAPI FsRtlAcquireFileForCcFlush(IN PFILE_OBJECT FileObject)
Definition: fastio.c:1695
uint64_t ULONGLONG
Definition: typedefs.h:65
PDEVICE_OBJECT DeviceObject
Definition: iotypes.h:2867
VOID NTAPI CcFastCopyRead(IN PFILE_OBJECT FileObject, IN ULONG FileOffset, IN ULONG Length, IN ULONG PageCount, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus)
Definition: copysup.c:117
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
* PFILE_OBJECT
Definition: iotypes.h:1955
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
struct _EXTENDED_DRIVER_EXTENSION * PEXTENDED_DRIVER_EXTENSION
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
NTSTATUS NTAPI FsRtlRegisterFileSystemFilterCallbacks(PDRIVER_OBJECT FilterDriverObject, PFS_FILTER_CALLBACKS Callbacks)
Definition: fastio.c:1947
PFAST_IO_ACQUIRE_FOR_CCFLUSH AcquireForCcFlush
Definition: iotypes.h:1716
BOOLEAN NTAPI CcCopyRead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus)
Definition: copysup.c:43
#define FILE_STANDARD_INFORMATION
Definition: disk.h:54
#define VOID
Definition: acefi.h:82
BOOLEAN NTAPI IoSetThreadHardErrorMode(IN BOOLEAN HardErrorEnabled)
Definition: error.c:707
NTKERNELAPI BOOLEAN NTAPI CcCopyWriteWontFlush(_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length)
ULONG LowPart
Definition: typedefs.h:104
ULONG CcFastReadResourceMiss
Definition: copysup.c:24
_Must_inspect_result_ _Out_ PLARGE_INTEGER FileSize
Definition: fsrtlfuncs.h:108
_Must_inspect_result_ _In_ USHORT NewSize
Definition: fltkernel.h:975
LARGE_INTEGER AllocationSize
Definition: env_spec_w32.h:755
static const WCHAR Cleanup[]
Definition: register.c:80
PPCI_DRIVER_EXTENSION DriverExtension
Definition: pci.c:41
PFAST_IO_ACQUIRE_FOR_MOD_WRITE AcquireForModWrite
Definition: iotypes.h:1705
Status
Definition: gdiplustypes.h:24
#define FSRTL_FAST_IO_TOP_LEVEL_IRP
Definition: fsrtltypes.h:62
BOOLEAN NTAPI CcCopyWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN PVOID Buffer)
Definition: copysup.c:129
FAST_IO_DISPATCH FastIoDispatch
Definition: fastio.c:20
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
VOID NTAPI CcMdlWriteComplete2(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain)
Definition: mdlsup.c:111
PFILE_OBJECT FileObject
Definition: iotypes.h:2813
_SEH2_END
Definition: create.c:4424
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:151
PDEVICE_OBJECT NTAPI IoGetBaseFileSystemDeviceObject(IN PFILE_OBJECT FileObject)
Definition: device.c:1627
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PFAST_IO_QUERY_STANDARD_INFO FastIoQueryStandardInfo
Definition: iotypes.h:1695
#define ExAcquireResourceShared
Definition: exfuncs.h:343
#define IRP_PAGING_IO
BOOLEAN NTAPI ExAcquireResourceSharedLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:885
#define FileStandardInformation
Definition: propsheet.cpp:61
BOOLEAN NTAPI FsRtlCopyRead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:64
enum _FS_FILTER_SECTION_SYNC_TYPE FS_FILTER_SECTION_SYNC_TYPE
BOOLEAN NTAPI FsRtlCopyWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:264
PFAST_IO_MDL_WRITE_COMPLETE MdlWriteComplete
Definition: iotypes.h:1709
#define OUT
Definition: typedefs.h:39
ULONG CcFastMdlReadNotPossible
Definition: copysup.c:20
NTSTATUS NTAPI FsRtlAcquireFileForCcFlushEx(IN PFILE_OBJECT FileObject)
Definition: fastio.c:1640
VOID NTAPI FsRtlReleaseFileForCcFlush(IN PFILE_OBJECT FileObject)
Definition: fastio.c:1709
BOOLEAN NTAPI FsRtlMdlWriteComplete(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain)
Definition: fastio.c:1153
ret QuadPart
Definition: rtlfuncs.h:3091
unsigned int ULONG
Definition: retypes.h:1
PFAST_IO_CHECK_IF_POSSIBLE FastIoCheckIfPossible
Definition: iotypes.h:1691
ULONG NTAPI ExIsResourceAcquiredSharedLite(IN PERESOURCE Resource)
Definition: resource.c:1658
PIRP NTAPI IoAllocateIrp(IN CCHAR StackSize, IN BOOLEAN ChargeQuota)
Definition: irp.c:615
#define IRP_MJ_QUERY_INFORMATION
Definition: rdpdr.c:48
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
LARGE_INTEGER ValidDataLength
Definition: env_spec_w32.h:757
PFAST_IO_ACQUIRE_FILE AcquireFileForNtCreateSection
Definition: iotypes.h:1701
return STATUS_SUCCESS
Definition: btrfs.c:2938
PFAST_IO_RELEASE_FOR_CCFLUSH ReleaseForCcFlush
Definition: iotypes.h:1717
BOOLEAN NTAPI FsRtlMdlRead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
Definition: fastio.c:921
VOID NTAPI FsRtlIncrementCcFastReadResourceMiss(VOID)
Definition: fastio.c:24
VOID NTAPI CcFastCopyWrite(IN PFILE_OBJECT FileObject, IN ULONG FileOffset, IN ULONG Length, IN PVOID Buffer)
Definition: copysup.c:204
struct _FSRTL_COMMON_FCB_HEADER * PFSRTL_COMMON_FCB_HEADER
#define IRP_SYNCHRONOUS_PAGING_IO
LONGLONG QuadPart
Definition: typedefs.h:112
#define FO_WRITE_THROUGH
Definition: iotypes.h:1736
#define STATUS_CANT_WAIT
Definition: ntstatus.h:438
IN BOOLEAN Wait
Definition: fatprocs.h:1529