* Sync up to trunk HEAD (r62975).
[reactos.git] / ntoskrnl / fsrtl / fastio.c
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
24 FsRtlIncrementCcFastReadResourceMiss(VOID)
25 {
26 CcFastReadResourceMiss++;
27 }
28
29 /*
30 * @implemented
31 */
32 VOID
33 NTAPI
34 FsRtlIncrementCcFastReadNotPossible(VOID)
35 {
36 CcFastReadNotPossible++;
37 }
38
39 /*
40 * @implemented
41 */
42 VOID
43 NTAPI
44 FsRtlIncrementCcFastReadWait(VOID)
45 {
46 CcFastReadWait++;
47 }
48
49 /*
50 * @implemented
51 */
52 VOID
53 NTAPI
54 FsRtlIncrementCcFastReadNoWait(VOID)
55 {
56 CcFastReadNoWait++;
57 }
58
59 /*
60 * @implemented
61 */
62 BOOLEAN
63 NTAPI
64 FsRtlCopyRead(IN PFILE_OBJECT FileObject,
65 IN PLARGE_INTEGER FileOffset,
66 IN ULONG Length,
67 IN BOOLEAN Wait,
68 IN ULONG LockKey,
69 OUT PVOID Buffer,
70 OUT PIO_STATUS_BLOCK IoStatus,
71 IN PDEVICE_OBJECT DeviceObject)
72 {
73
74 PFSRTL_COMMON_FCB_HEADER FcbHeader;
75 LARGE_INTEGER Offset;
76 PFAST_IO_DISPATCH FastIoDispatch;
77 PDEVICE_OBJECT Device;
78 BOOLEAN Result = TRUE;
79 ULONG PageCount = ADDRESS_AND_SIZE_TO_SPAN_PAGES(FileOffset, Length);
80
81 PAGED_CODE();
82 ASSERT(FileObject);
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 {
96 IoStatus->Status = STATUS_INVALID_PARAMETER;
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 */
108 FsRtlEnterFileSystem();
109 CcFastReadWait++;
110 ExAcquireResourceSharedLite(FcbHeader->Resource, TRUE);
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 */
117 FsRtlEnterFileSystem();
118 if (!ExAcquireResourceSharedLite(FcbHeader->Resource, FALSE))
119 {
120 FsRtlExitFileSystem();
121 FsRtlIncrementCcFastReadResourceMiss();
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 */
139 ASSERT(!KeIsExecutingDpc());
140
141 /* Get the Fast I/O table */
142 Device = IoGetRelatedDeviceObject(FileObject);
143 FastIoDispatch = Device->DriverObject->FastIoDispatch;
144
145 /* Sanity check */
146 ASSERT(FastIoDispatch != NULL);
147 ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL);
148
149 /* Ask the driver if we can do it */
150 if (!FastIoDispatch->FastIoCheckIfPossible(FileObject,
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 */
182 PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_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 */
191 CcFastCopyRead(FileObject,
192 FileOffset->LowPart,
193 Length,
194 PageCount,
195 Buffer,
196 IoStatus);
197
198 /* File was accessed */
199 FileObject->Flags |= FO_FILE_FAST_IO_READ;
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 */
211 Result = CcCopyRead(FileObject,
212 FileOffset,
213 Length,
214 Wait,
215 Buffer,
216 IoStatus);
217
218 /* File was accessed */
219 FileObject->Flags |= FO_FILE_FAST_IO_READ;
220
221 if (Result == TRUE)
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 == TRUE)
231 {
232 FileObject->CurrentByteOffset.QuadPart = FileOffset->QuadPart + IoStatus->Information;
233 }
234 }
235 _SEH2_EXCEPT(FsRtlIsNtstatusExpected(_SEH2_GetExceptionCode()) ?
236 EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
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);
248 FsRtlExitFileSystem();
249
250 if (Result == FALSE)
251 {
252 CcFastReadNotPossible += 1;
253 }
254
255 return Result;
256 }
257
258
259 /*
260 * @implemented
261 */
262 BOOLEAN
263 NTAPI
264 FsRtlCopyWrite(IN PFILE_OBJECT FileObject,
265 IN PLARGE_INTEGER FileOffset,
266 IN ULONG Length,
267 IN BOOLEAN Wait,
268 IN ULONG LockKey,
269 OUT PVOID Buffer,
270 OUT PIO_STATUS_BLOCK IoStatus,
271 IN PDEVICE_OBJECT DeviceObject)
272 {
273 BOOLEAN Result = TRUE;
274 PFAST_IO_DISPATCH FastIoDispatch;
275 PDEVICE_OBJECT Device;
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;
290 LARGE_INTEGER NewSize;
291 LARGE_INTEGER Offset;
292
293 PAGED_CODE();
294
295 ASSERT(FileObject);
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 */
306 if ((CcCanIWrite(FileObject, Length, Wait, FALSE) == FALSE) ||
307 (CcCopyWriteWontFlush(FileObject, FileOffset, Length) == FALSE) ||
308 ((FileObject->Flags & FO_WRITE_THROUGH)))
309 {
310 return FALSE;
311 }
312
313 /* No actual read */
314 if (!Length)
315 {
316 IoStatus->Status = STATUS_SUCCESS;
317 IoStatus->Information = Length;
318 return TRUE;
319 }
320
321 FsRtlEnterFileSystem();
322
323 /* Nagar p.544/545.
324 * The CcFastCopyWrite doesn't deal with filesize beyond 4GB.
325 */
326 if (Wait && (FcbHeader->AllocationSize.HighPart == 0))
327 {
328 /* If the file offset is not past the file size,
329 * then we can acquire the lock shared.
330 */
331 if ((FileOffsetAppend == FALSE) &&
332 (Offset.LowPart <= FcbHeader->ValidDataLength.LowPart))
333 {
334 ExAcquireResourceSharedLite(FcbHeader->Resource, TRUE);
335 ResourceAcquiredShared = TRUE;
336 }
337 else
338 {
339 ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
340 }
341
342 /* Nagar p.544/545.
343 * If we append, use the file size as offset.
344 * Also, check that we aren't crossing the 4GB boundary.
345 */
346 if (FileOffsetAppend == TRUE)
347 {
348 Offset.LowPart = FcbHeader->FileSize.LowPart;
349 NewSize.LowPart = FcbHeader->FileSize.LowPart + Length;
350 b_4GB = (NewSize.LowPart < FcbHeader->FileSize.LowPart);
351
352 }
353 else
354 {
355 Offset.LowPart = FileOffset->LowPart;
356 NewSize.LowPart = FileOffset->LowPart + Length;
357 b_4GB = (NewSize.LowPart < FileOffset->LowPart) ||
358 (FileOffset->HighPart != 0);
359 }
360
361 /* Nagar p.544/545.
362 * Make sure that caching is initated.
363 * That fast are allowed for this file stream.
364 * That we are not extending past the allocated size.
365 * That we are not creating a hole bigger than 8k.
366 * That we are not crossing the 4GB boundary.
367 */
368 if ((FileObject->PrivateCacheMap != NULL) &&
369 (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
370 (FcbHeader->AllocationSize.LowPart >= NewSize.LowPart) &&
371 (Offset.LowPart < FcbHeader->ValidDataLength.LowPart + 0x2000) &&
372 !b_4GB)
373 {
374 /* If we are extending past the file size, we need to
375 * release the lock and acquire it exclusively, because
376 * we are going to need to update the FcbHeader.
377 */
378 if (ResourceAcquiredShared &&
379 (NewSize.LowPart > FcbHeader->ValidDataLength.LowPart + 0x2000))
380 {
381 /* Then we need to acquire the resource exclusive */
382 ExReleaseResourceLite(FcbHeader->Resource);
383 ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
384 if (FileOffsetAppend == TRUE)
385 {
386 Offset.LowPart = FcbHeader->FileSize.LowPart; // ??
387 NewSize.LowPart = FcbHeader->FileSize.LowPart + Length;
388
389 /* Make sure we don't cross the 4GB boundary */
390 b_4GB = (NewSize.LowPart < Offset.LowPart);
391 }
392
393 /* Recheck some of the conditions since we let the lock go */
394 if ((FileObject->PrivateCacheMap != NULL) &&
395 (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
396 (FcbHeader->AllocationSize.LowPart >= NewSize.LowPart) &&
397 (FcbHeader->AllocationSize.HighPart == 0) &&
398 !b_4GB)
399 {
400 /* Do nothing? */
401 }
402 else
403 {
404 goto FailAndCleanup;
405 }
406 }
407
408 }
409 else
410 {
411 goto FailAndCleanup;
412 }
413
414 /* Check if we need to find out if fast I/O is available */
415 if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
416 {
417 IO_STATUS_BLOCK FastIoCheckIfPossibleStatus;
418
419 /* Sanity check */
420 ASSERT(!KeIsExecutingDpc());
421
422 /* Get the Fast I/O table */
423 Device = IoGetRelatedDeviceObject(FileObject);
424 FastIoDispatch = Device->DriverObject->FastIoDispatch;
425
426 /* Sanity check */
427 ASSERT(FastIoDispatch != NULL);
428 ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL);
429
430 /* Ask the driver if we can do it */
431 if (!FastIoDispatch->FastIoCheckIfPossible(FileObject,
432 FileOffsetAppend ?
433 &FcbHeader->FileSize :
434 FileOffset,
435 Length,
436 TRUE,
437 LockKey,
438 FALSE,
439 &FastIoCheckIfPossibleStatus,
440 Device))
441 {
442 /* It's not, fail */
443 goto FailAndCleanup;
444 }
445 }
446
447 /* If we are going to extend the file then save
448 * the old file size in case the operation fails.
449 */
450 if (NewSize.LowPart > FcbHeader->FileSize.LowPart)
451 {
452 FileSizeModified = TRUE;
453 OldFileSize.LowPart = FcbHeader->FileSize.LowPart;
454 OldValidDataLength.LowPart = FcbHeader->ValidDataLength.LowPart;
455 FcbHeader->FileSize.LowPart = NewSize.LowPart;
456 }
457
458 /* Set this as top-level IRP */
459 PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP;
460
461 _SEH2_TRY
462 {
463 if (Offset.LowPart > FcbHeader->ValidDataLength.LowPart)
464 {
465 LARGE_INTEGER OffsetVar;
466 OffsetVar.LowPart = Offset.LowPart;
467 OffsetVar.HighPart = 0;
468 CcZeroData(FileObject, &FcbHeader->ValidDataLength, &OffsetVar, TRUE);
469 }
470
471 /* Call the cache manager */
472 CcFastCopyWrite(FileObject, Offset.LowPart, Length, Buffer);
473 }
474 _SEH2_EXCEPT(FsRtlIsNtstatusExpected(_SEH2_GetExceptionCode()) ?
475 EXCEPTION_EXECUTE_HANDLER :
476 EXCEPTION_CONTINUE_SEARCH)
477 {
478 Result = FALSE;
479 }
480 _SEH2_END;
481
482 /* Remove ourselves at the top level component after the IO is done */
483 PsGetCurrentThread()->TopLevelIrp = 0;
484
485 /* Did the operation succeed? */
486 if (Result == TRUE)
487 {
488 /* Update the valid file size if necessary */
489 if (NewSize.LowPart > FcbHeader->ValidDataLength.LowPart)
490 {
491 FcbHeader->ValidDataLength.LowPart = NewSize.LowPart;
492 }
493
494 /* Flag the file as modified */
495 FileObject->Flags |= FO_FILE_MODIFIED;
496
497 /* Update the strucutres if the file size changed */
498 if (FileSizeModified)
499 {
500 SharedCacheMap =
501 (PSHARED_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
502 SharedCacheMap->FileSize.LowPart = NewSize.LowPart;
503 FileObject->Flags |= FO_FILE_SIZE_CHANGED;
504 }
505
506 /* Update the file object current file offset */
507 FileObject->CurrentByteOffset.QuadPart = NewSize.LowPart;
508
509 }
510 else
511 {
512 /* Result == FALSE if we get here */
513 if (FileSizeModified)
514 {
515 /* If the file size was modified then restore the old file size */
516 if (FcbHeader->PagingIoResource != NULL)
517 {
518 /* Nagar P.544.
519 * Restore the old file size if operation didn't succeed.
520 */
521 ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
522 FcbHeader->FileSize.LowPart = OldFileSize.LowPart;
523 FcbHeader->ValidDataLength.LowPart = OldValidDataLength.LowPart;
524 ExReleaseResourceLite(FcbHeader->PagingIoResource);
525 }
526 else
527 {
528 /* If there is no lock and do it without */
529 FcbHeader->FileSize.LowPart = OldFileSize.LowPart;
530 FcbHeader->ValidDataLength.LowPart = OldValidDataLength.LowPart;
531 }
532 }
533 else
534 {
535 /* Do nothing? */
536 }
537 }
538
539 goto Cleanup;
540 }
541 else
542 {
543 LARGE_INTEGER OldFileSize;
544
545 /* Sanity check */
546 ASSERT(!KeIsExecutingDpc());
547
548 /* Nagar P.544.
549 * Check if we need to acquire the resource exclusive.
550 */
551 if ((FileOffsetAppend == FALSE) &&
552 (FileOffset->QuadPart + Length <= FcbHeader->ValidDataLength.QuadPart))
553 {
554 /* Acquire the resource shared */
555 if (!ExAcquireResourceSharedLite(FcbHeader->Resource, Wait))
556 {
557 goto LeaveCriticalAndFail;
558 }
559 ResourceAcquiredShared = TRUE;
560 }
561 else
562 {
563 /* Acquire the resource exclusive */
564 if (!ExAcquireResourceExclusiveLite(FcbHeader->Resource, Wait))
565 {
566 goto LeaveCriticalAndFail;
567 }
568 }
569
570 /* Check if we are appending */
571 if (FileOffsetAppend == TRUE)
572 {
573 Offset.QuadPart = FcbHeader->FileSize.QuadPart;
574 NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
575 }
576 else
577 {
578 Offset.QuadPart = FileOffset->QuadPart;
579 NewSize.QuadPart += FileOffset->QuadPart + Length;
580 }
581
582 /* Nagar p.544/545.
583 * Make sure that caching is initated.
584 * That fast are allowed for this file stream.
585 * That we are not extending past the allocated size.
586 * That we are not creating a hole bigger than 8k.
587 */
588 if ((FileObject->PrivateCacheMap != NULL) &&
589 (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
590 (FcbHeader->ValidDataLength.QuadPart + 0x2000 > Offset.QuadPart) &&
591 (Length <= MAXLONGLONG - Offset.QuadPart) &&
592 (FcbHeader->AllocationSize.QuadPart >= NewSize.QuadPart))
593 {
594 /* Check if we can keep the lock shared */
595 if (ResourceAcquiredShared &&
596 (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart))
597 {
598 ExReleaseResourceLite(FcbHeader->Resource);
599 if (!ExAcquireResourceExclusiveLite(FcbHeader->Resource, Wait))
600 {
601 goto LeaveCriticalAndFail;
602 }
603
604 /* Compute the offset and the new filesize */
605 if (FileOffsetAppend)
606 {
607 Offset.QuadPart = FcbHeader->FileSize.QuadPart;
608 NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
609 }
610
611 /* Recheck the above points since we released and reacquire the lock */
612 if ((FileObject->PrivateCacheMap != NULL) &&
613 (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
614 (FcbHeader->AllocationSize.QuadPart > NewSize.QuadPart))
615 {
616 /* Do nothing */
617 }
618 else
619 {
620 goto FailAndCleanup;
621 }
622 }
623
624 /* Check if we need to find out if fast I/O is available */
625 if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
626 {
627 IO_STATUS_BLOCK FastIoCheckIfPossibleStatus;
628
629 /* Sanity check */
630 ASSERT(!KeIsExecutingDpc());
631
632 /* Get the Fast I/O table */
633 Device = IoGetRelatedDeviceObject(FileObject);
634 FastIoDispatch = Device->DriverObject->FastIoDispatch;
635
636 /* Sanity check */
637 ASSERT(FastIoDispatch != NULL);
638 ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL);
639
640 /* Ask the driver if we can do it */
641 if (!FastIoDispatch->FastIoCheckIfPossible(FileObject,
642 FileOffsetAppend ?
643 &FcbHeader->FileSize :
644 FileOffset,
645 Length,
646 Wait,
647 LockKey,
648 FALSE,
649 &FastIoCheckIfPossibleStatus,
650 Device))
651 {
652 /* It's not, fail */
653 goto FailAndCleanup;
654 }
655 }
656
657 /* If we are going to modify the filesize,
658 * save the old fs in case the operation fails.
659 */
660 if (NewSize.QuadPart > FcbHeader->FileSize.QuadPart)
661 {
662 FileSizeModified = TRUE;
663 OldFileSize.QuadPart = FcbHeader->FileSize.QuadPart;
664 OldValidDataLength.QuadPart = FcbHeader->ValidDataLength.QuadPart;
665
666 /* If the high part of the filesize is going
667 * to change, grab the Paging IoResouce.
668 */
669 if (NewSize.HighPart != FcbHeader->FileSize.HighPart &&
670 FcbHeader->PagingIoResource)
671 {
672 ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
673 FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
674 ExReleaseResourceLite(FcbHeader->PagingIoResource);
675 }
676 else
677 {
678 FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
679 }
680 }
681
682 /* Nagar p.544.
683 * Set ourselves as top component.
684 */
685 PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP;
686
687 _SEH2_TRY
688 {
689 BOOLEAN CallCc = TRUE;
690
691 /* Check if there is a gap between the end of the file
692 * and the offset. If yes, then we have to zero the data.
693 */
694 if (Offset.QuadPart > FcbHeader->ValidDataLength.QuadPart)
695 {
696 if (!(Result = CcZeroData(FileObject,
697 &FcbHeader->ValidDataLength,
698 &Offset,
699 Wait)))
700 {
701 /* If this operation fails, then we have to exit. We can't jump
702 * outside the SEH, so I am using a variable to exit normally.
703 */
704 CallCc = FALSE;
705 }
706 }
707
708 /* Unless the CcZeroData failed, call the cache manager */
709 if (CallCc)
710 {
711 Result = CcCopyWrite(FileObject, &Offset, Length, Wait, Buffer);
712 }
713 }
714 _SEH2_EXCEPT(FsRtlIsNtstatusExpected(_SEH2_GetExceptionCode()) ?
715 EXCEPTION_EXECUTE_HANDLER :
716 EXCEPTION_CONTINUE_SEARCH)
717 {
718 Result = FALSE;
719 }
720 _SEH2_END;
721
722 /* Reset the top component */
723 PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP;
724
725 /* Did the operation suceeded */
726 if (Result)
727 {
728 /* Check if we need to update the filesize */
729 if (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart)
730 {
731 if (NewSize.HighPart != FcbHeader->ValidDataLength.HighPart &&
732 FcbHeader->PagingIoResource)
733 {
734 ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
735 FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
736 ExReleaseResourceLite(FcbHeader->PagingIoResource);
737 }
738 else
739 {
740 FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
741 }
742 }
743
744 /* Flag the file as modified */
745 FileObject->Flags |= FO_FILE_MODIFIED;
746
747 /* Check if the filesize has changed */
748 if (FileSizeModified)
749 {
750 /* Update the file sizes */
751 SharedCacheMap =
752 (PSHARED_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
753 SharedCacheMap->FileSize.QuadPart = NewSize.QuadPart;
754 FileObject->Flags |= FO_FILE_SIZE_CHANGED;
755 }
756
757 /* Update the current FO byte offset */
758 FileObject->CurrentByteOffset.QuadPart = NewSize.QuadPart;
759 }
760 else
761 {
762 /* The operation did not succeed.
763 * Reset the file size to what it should be.
764 */
765 if (FileSizeModified)
766 {
767 if (FcbHeader->PagingIoResource)
768 {
769 ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
770 FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
771 FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
772 ExReleaseResourceLite(FcbHeader->PagingIoResource);
773 }
774 else
775 {
776 FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
777 FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
778 }
779 }
780 }
781
782 goto Cleanup;
783 }
784 else
785 {
786 goto FailAndCleanup;
787 }
788 }
789
790 LeaveCriticalAndFail:
791
792 FsRtlExitFileSystem();
793 return FALSE;
794
795 FailAndCleanup:
796
797 ExReleaseResourceLite(FcbHeader->Resource);
798 FsRtlExitFileSystem();
799 return FALSE;
800
801 Cleanup:
802
803 ExReleaseResourceLite(FcbHeader->Resource);
804 FsRtlExitFileSystem();
805 return Result;
806 }
807
808 /*
809 * @implemented
810 */
811 NTSTATUS
812 NTAPI
813 FsRtlGetFileSize(IN PFILE_OBJECT FileObject,
814 IN OUT PLARGE_INTEGER FileSize)
815 {
816 FILE_STANDARD_INFORMATION Info;
817 NTSTATUS Status;
818 IO_STATUS_BLOCK IoStatus;
819 PDEVICE_OBJECT DeviceObject;
820 PFAST_IO_DISPATCH FastDispatch;
821 KEVENT Event;
822 PIO_STACK_LOCATION IoStackLocation;
823 PIRP Irp;
824 BOOLEAN OldHardError;
825
826 PAGED_CODE();
827
828 /* Get Device Object and Fast Calls */
829 DeviceObject = IoGetRelatedDeviceObject(FileObject);
830 FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
831
832 /* Check if we support Fast Calls, and check FastIoQueryStandardInfo.
833 * Call the function and see if it succeeds.
834 */
835 if (!FastDispatch ||
836 !FastDispatch->FastIoQueryStandardInfo ||
837 !FastDispatch->FastIoQueryStandardInfo(FileObject,
838 TRUE,
839 &Info,
840 &IoStatus,
841 DeviceObject))
842 {
843 /* If any of the above failed, then we are going to send an
844 * IRP to the device object. Initialize the event for the IO.
845 */
846 KeInitializeEvent(&Event, NotificationEvent, FALSE);
847
848 /* Allocate the IRP */
849 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
850
851 if (Irp == NULL)
852 {
853 return STATUS_INSUFFICIENT_RESOURCES;
854 }
855
856 /* Don't process hard error */
857 OldHardError = IoSetThreadHardErrorMode(FALSE);
858
859 /* Setup the IRP */
860 Irp->UserIosb = &IoStatus;
861 Irp->UserEvent = &Event;
862 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
863 Irp->Flags = IRP_SYNCHRONOUS_PAGING_IO | IRP_PAGING_IO;
864 Irp->RequestorMode = KernelMode;
865 Irp->Tail.Overlay.OriginalFileObject = FileObject;
866 Irp->AssociatedIrp.SystemBuffer = &Info;
867
868 /* Setup out stack location */
869 IoStackLocation = Irp->Tail.Overlay.CurrentStackLocation;
870 IoStackLocation--;
871 IoStackLocation->MajorFunction = IRP_MJ_QUERY_INFORMATION;
872 IoStackLocation->FileObject = FileObject;
873 IoStackLocation->DeviceObject = DeviceObject;
874 IoStackLocation->Parameters.QueryFile.Length =
875 sizeof(FILE_STANDARD_INFORMATION);
876 IoStackLocation->Parameters.QueryFile.FileInformationClass =
877 FileStandardInformation;
878
879 /* Send the IRP to the related device object */
880 Status = IoCallDriver(DeviceObject, Irp);
881
882 /* Standard DDK IRP result processing */
883 if (Status == STATUS_PENDING)
884 {
885 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
886 }
887
888 /* If there was a synchronous error, signal it */
889 if (!NT_SUCCESS(Status))
890 {
891 IoStatus.Status = Status;
892 }
893
894 IoSetThreadHardErrorMode(OldHardError);
895 }
896
897 /* Check the sync/async IO result */
898 if (NT_SUCCESS(IoStatus.Status))
899 {
900 /* Was the request for a directory? */
901 if (Info.Directory)
902 {
903 IoStatus.Status = STATUS_FILE_IS_A_DIRECTORY;
904 }
905 else
906 {
907 FileSize->QuadPart = Info.EndOfFile.QuadPart;
908 }
909 }
910
911 return IoStatus.Status;
912 }
913
914 /*
915 * @implemented
916 */
917 BOOLEAN
918 NTAPI
919 FsRtlMdlRead(IN PFILE_OBJECT FileObject,
920 IN PLARGE_INTEGER FileOffset,
921 IN ULONG Length,
922 IN ULONG LockKey,
923 OUT PMDL *MdlChain,
924 OUT PIO_STATUS_BLOCK IoStatus)
925 {
926 PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
927 PFAST_IO_DISPATCH FastDispatch;
928
929 /* Get Device Object and Fast Calls */
930 DeviceObject = IoGetRelatedDeviceObject(FileObject);
931 FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
932
933 /* Check if we support Fast Calls, and check this one */
934 if (FastDispatch && FastDispatch->MdlRead)
935 {
936 /* Use the fast path */
937 return FastDispatch->MdlRead(FileObject,
938 FileOffset,
939 Length,
940 LockKey,
941 MdlChain,
942 IoStatus,
943 DeviceObject);
944 }
945
946 /* Get the Base File System (Volume) and Fast Calls */
947 BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
948 FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
949
950 /* If the Base Device Object has its own FastDispatch Routine, fail */
951 if (FastDispatch && FastDispatch->MdlRead && BaseDeviceObject != DeviceObject)
952 {
953 return FALSE;
954 }
955
956 /* No fast path, use slow path */
957 return FsRtlMdlReadDev(FileObject,
958 FileOffset,
959 Length,
960 LockKey,
961 MdlChain,
962 IoStatus,
963 DeviceObject);
964 }
965
966 /*
967 * @implemented
968 */
969 BOOLEAN
970 NTAPI
971 FsRtlMdlReadComplete(IN PFILE_OBJECT FileObject,
972 IN OUT PMDL MdlChain)
973 {
974 PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
975 PFAST_IO_DISPATCH FastDispatch;
976
977 /* Get Device Object and Fast Calls */
978 DeviceObject = IoGetRelatedDeviceObject(FileObject);
979 FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
980
981 /* Check if we support Fast Calls, and check this one */
982 if (FastDispatch && FastDispatch->MdlReadComplete)
983 {
984 /* Use the fast path */
985 return FastDispatch->MdlReadComplete(FileObject, MdlChain, DeviceObject);
986 }
987
988 /* Get the Base File System (Volume) and Fast Calls */
989 BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
990 FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
991
992 /* If the Base Device Object has its own FastDispatch Routine, fail */
993 if ((BaseDeviceObject != DeviceObject) &&
994 FastDispatch &&
995 FastDispatch->MdlReadComplete)
996 {
997 return FALSE;
998 }
999
1000 /* No fast path, use slow path */
1001 return FsRtlMdlReadCompleteDev(FileObject, MdlChain, DeviceObject);
1002 }
1003
1004 /*
1005 * @implemented
1006 */
1007 BOOLEAN
1008 NTAPI
1009 FsRtlMdlReadCompleteDev(IN PFILE_OBJECT FileObject,
1010 IN PMDL MemoryDescriptorList,
1011 IN PDEVICE_OBJECT DeviceObject)
1012 {
1013 /* Call the Cache Manager */
1014 CcMdlReadComplete2(FileObject, MemoryDescriptorList);
1015 return TRUE;
1016 }
1017
1018 /*
1019 * @implemented
1020 */
1021 BOOLEAN
1022 NTAPI
1023 FsRtlMdlReadDev(IN PFILE_OBJECT FileObject,
1024 IN PLARGE_INTEGER FileOffset,
1025 IN ULONG Length,
1026 IN ULONG LockKey,
1027 OUT PMDL *MdlChain,
1028 OUT PIO_STATUS_BLOCK IoStatus,
1029 IN PDEVICE_OBJECT DeviceObject)
1030 {
1031 PFSRTL_COMMON_FCB_HEADER FcbHeader;
1032 BOOLEAN Result = TRUE;
1033 LARGE_INTEGER Offset;
1034 PFAST_IO_DISPATCH FastIoDispatch;
1035 PDEVICE_OBJECT Device;
1036 PAGED_CODE();
1037
1038 /* No actual read */
1039 if (!Length)
1040 {
1041 /* Return success */
1042 IoStatus->Status = STATUS_SUCCESS;
1043 IoStatus->Information = 0;
1044 return TRUE;
1045 }
1046
1047 /* Sanity check */
1048 ASSERT(MAXLONGLONG - FileOffset->QuadPart >= (LONGLONG)Length);
1049
1050 /* Get the offset and FCB header */
1051 Offset.QuadPart = FileOffset->QuadPart + Length;
1052 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1053
1054 /* Enter the FS */
1055 FsRtlEnterFileSystem();
1056 CcFastMdlReadWait++;
1057
1058 /* Lock the FCB */
1059 ExAcquireResourceShared(FcbHeader->Resource, TRUE);
1060
1061 /* Check if this is a fast I/O cached file */
1062 if (!(FileObject->PrivateCacheMap) ||
1063 (FcbHeader->IsFastIoPossible == FastIoIsNotPossible))
1064 {
1065 /* It's not, so fail */
1066 CcFastMdlReadNotPossible += 1;
1067 Result = FALSE;
1068 goto Cleanup;
1069 }
1070
1071 /* Check if we need to find out if fast I/O is available */
1072 if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
1073 {
1074 /* Get the Fast I/O table */
1075 Device = IoGetRelatedDeviceObject(FileObject);
1076 FastIoDispatch = Device->DriverObject->FastIoDispatch;
1077
1078 /* Sanity check */
1079 ASSERT(!KeIsExecutingDpc());
1080 ASSERT(FastIoDispatch != NULL);
1081 ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL);
1082
1083 /* Ask the driver if we can do it */
1084 if (!FastIoDispatch->FastIoCheckIfPossible(FileObject,
1085 FileOffset,
1086 Length,
1087 TRUE,
1088 LockKey,
1089 TRUE,
1090 IoStatus,
1091 Device))
1092 {
1093 /* It's not, fail */
1094 CcFastMdlReadNotPossible += 1;
1095 Result = FALSE;
1096 goto Cleanup;
1097 }
1098 }
1099
1100 /* Check if we read too much */
1101 if (Offset.QuadPart > FcbHeader->FileSize.QuadPart)
1102 {
1103 /* We did, check if the file offset is past the end */
1104 if (FileOffset->QuadPart >= FcbHeader->FileSize.QuadPart)
1105 {
1106 /* Set end of file */
1107 IoStatus->Status = STATUS_END_OF_FILE;
1108 IoStatus->Information = 0;
1109 goto Cleanup;
1110 }
1111
1112 /* Otherwise, just normalize the length */
1113 Length = (ULONG)(FcbHeader->FileSize.QuadPart - FileOffset->QuadPart);
1114 }
1115
1116 /* Set this as top-level IRP */
1117 PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP;
1118
1119 _SEH2_TRY
1120 {
1121 /* Attempt a read */
1122 CcMdlRead(FileObject, FileOffset, Length, MdlChain, IoStatus);
1123 FileObject->Flags |= FO_FILE_FAST_IO_READ;
1124 }
1125 _SEH2_EXCEPT(FsRtlIsNtstatusExpected(_SEH2_GetExceptionCode()) ?
1126 EXCEPTION_EXECUTE_HANDLER :
1127 EXCEPTION_CONTINUE_SEARCH)
1128 {
1129 Result = FALSE;
1130 }
1131 _SEH2_END;
1132
1133
1134 /* Remove the top-level IRP flag */
1135 PsGetCurrentThread()->TopLevelIrp = 0;
1136
1137 /* Return to caller */
1138 Cleanup:
1139
1140 ExReleaseResourceLite(FcbHeader->Resource);
1141 FsRtlExitFileSystem();
1142
1143 return Result;
1144 }
1145
1146 /*
1147 * @implemented
1148 */
1149 BOOLEAN
1150 NTAPI
1151 FsRtlMdlWriteComplete(IN PFILE_OBJECT FileObject,
1152 IN PLARGE_INTEGER FileOffset,
1153 IN PMDL MdlChain)
1154 {
1155 PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1156 PFAST_IO_DISPATCH FastDispatch;
1157
1158 /* Get Device Object and Fast Calls */
1159 DeviceObject = IoGetRelatedDeviceObject(FileObject);
1160 FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1161
1162 /* Check if we support Fast Calls, and check this one */
1163 if (FastDispatch && FastDispatch->MdlWriteComplete)
1164 {
1165 /* Use the fast path */
1166 return FastDispatch->MdlWriteComplete(FileObject,
1167 FileOffset,
1168 MdlChain,
1169 DeviceObject);
1170 }
1171
1172 /* Get the Base File System (Volume) and Fast Calls */
1173 BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1174 FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
1175
1176 /* If the Base Device Object has its own FastDispatch Routine, fail */
1177 if (FastDispatch &&
1178 FastDispatch->MdlWriteComplete &&
1179 BaseDeviceObject != DeviceObject)
1180 {
1181 return FALSE;
1182 }
1183
1184 /* No fast path, use slow path */
1185 return FsRtlMdlWriteCompleteDev(FileObject,
1186 FileOffset,
1187 MdlChain,
1188 DeviceObject);
1189 }
1190
1191 /*
1192 * @implemented
1193 */
1194 BOOLEAN
1195 NTAPI
1196 FsRtlMdlWriteCompleteDev(IN PFILE_OBJECT FileObject,
1197 IN PLARGE_INTEGER FileOffset,
1198 IN PMDL MdlChain,
1199 IN PDEVICE_OBJECT DeviceObject)
1200 {
1201 if (FileObject->Flags & FO_WRITE_THROUGH)
1202 {
1203 return FALSE;
1204 }
1205
1206 /* Call the Cache Manager */
1207 CcMdlWriteComplete2(FileObject, FileOffset, MdlChain);
1208 return TRUE;
1209 }
1210
1211 /*
1212 * @implemented
1213 */
1214 BOOLEAN
1215 NTAPI
1216 FsRtlPrepareMdlWrite(IN PFILE_OBJECT FileObject,
1217 IN PLARGE_INTEGER FileOffset,
1218 IN ULONG Length,
1219 IN ULONG LockKey,
1220 OUT PMDL *MdlChain,
1221 OUT PIO_STATUS_BLOCK IoStatus)
1222 {
1223 PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1224 PFAST_IO_DISPATCH FastDispatch;
1225
1226 /* Get Device Object and Fast Calls */
1227 DeviceObject = IoGetRelatedDeviceObject(FileObject);
1228 FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1229
1230 /* Check if we support Fast Calls, and check this one */
1231 if (FastDispatch && FastDispatch->PrepareMdlWrite)
1232 {
1233 /* Use the fast path */
1234 return FastDispatch->PrepareMdlWrite(FileObject,
1235 FileOffset,
1236 Length,
1237 LockKey,
1238 MdlChain,
1239 IoStatus,
1240 DeviceObject);
1241 }
1242
1243 /* Get the Base File System (Volume) and Fast Calls */
1244 BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1245 FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
1246
1247 /* If the Base Device Object has its own FastDispatch Routine, fail */
1248 if (FastDispatch &&
1249 FastDispatch->PrepareMdlWrite &&
1250 BaseDeviceObject != DeviceObject)
1251 {
1252 return FALSE;
1253 }
1254
1255 /* No fast path, use slow path */
1256 return FsRtlPrepareMdlWriteDev(FileObject,
1257 FileOffset,
1258 Length,
1259 LockKey,
1260 MdlChain,
1261 IoStatus,
1262 DeviceObject);
1263 }
1264
1265 /*
1266 * @implemented
1267 */
1268 BOOLEAN
1269 NTAPI
1270 FsRtlPrepareMdlWriteDev(IN PFILE_OBJECT FileObject,
1271 IN PLARGE_INTEGER FileOffset,
1272 IN ULONG Length,
1273 IN ULONG LockKey,
1274 OUT PMDL *MdlChain,
1275 OUT PIO_STATUS_BLOCK IoStatus,
1276 IN PDEVICE_OBJECT DeviceObject)
1277 {
1278 BOOLEAN Result = TRUE;
1279 PFAST_IO_DISPATCH FastIoDispatch;
1280 PDEVICE_OBJECT Device;
1281 PFSRTL_COMMON_FCB_HEADER FcbHeader;
1282 PSHARED_CACHE_MAP SharedCacheMap;
1283
1284 LARGE_INTEGER OldFileSize;
1285 LARGE_INTEGER OldValidDataLength;
1286 LARGE_INTEGER NewSize;
1287 LARGE_INTEGER Offset;
1288
1289 /* WDK doc.
1290 * Offset == 0xffffffffffffffff indicates append to the end of file.
1291 */
1292 BOOLEAN FileOffsetAppend = (FileOffset->HighPart == (LONG)0xffffffff) &&
1293 (FileOffset->LowPart == 0xffffffff);
1294
1295 BOOLEAN FileSizeModified = FALSE;
1296 BOOLEAN ResourceAcquiredShared = FALSE;
1297
1298 /* Initialize some of the vars and pointers */
1299 OldFileSize.QuadPart = 0;
1300 OldValidDataLength.QuadPart = 0;
1301
1302 PAGED_CODE();
1303
1304 Offset.QuadPart = FileOffset->QuadPart + Length;
1305
1306 /* Nagar p.544.
1307 * Check with Cc if we can write.
1308 */
1309 if (!CcCanIWrite(FileObject, Length, TRUE, FALSE) ||
1310 (FileObject->Flags & FO_WRITE_THROUGH))
1311 {
1312 return FALSE;
1313 }
1314
1315 IoStatus->Status = STATUS_SUCCESS;
1316
1317 /* No actual read */
1318 if (!Length)
1319 {
1320 return TRUE;
1321 }
1322
1323 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1324 FsRtlEnterFileSystem();
1325
1326 /* Check we are going to extend the file */
1327 if ((FileOffsetAppend == FALSE) &&
1328 (FileOffset->QuadPart + Length <= FcbHeader->ValidDataLength.QuadPart))
1329 {
1330 /* Acquire the resource shared */
1331 ExAcquireResourceSharedLite(FcbHeader->Resource, TRUE);
1332 ResourceAcquiredShared = TRUE;
1333 }
1334 else
1335 {
1336 /* Acquire the resource exclusive */
1337 ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
1338 }
1339
1340 /* Check if we are appending */
1341 if (FileOffsetAppend == TRUE)
1342 {
1343 Offset.QuadPart = FcbHeader->FileSize.QuadPart;
1344 NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
1345 }
1346 else
1347 {
1348 Offset.QuadPart = FileOffset->QuadPart;
1349 NewSize.QuadPart = FileOffset->QuadPart + Length;
1350 }
1351
1352 if ((FileObject->PrivateCacheMap) &&
1353 (FcbHeader->IsFastIoPossible) &&
1354 (Length <= MAXLONGLONG - FileOffset->QuadPart) &&
1355 (NewSize.QuadPart <= FcbHeader->AllocationSize.QuadPart))
1356 {
1357 /* Check if we can keep the lock shared */
1358 if (ResourceAcquiredShared &&
1359 (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart))
1360 {
1361 ExReleaseResourceLite(FcbHeader->Resource);
1362 ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
1363
1364 /* Compute the offset and the new filesize */
1365 if (FileOffsetAppend)
1366 {
1367 Offset.QuadPart = FcbHeader->FileSize.QuadPart;
1368 NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
1369 }
1370
1371 /* Recheck the above points since we released and reacquire the lock */
1372 if ((FileObject->PrivateCacheMap != NULL) &&
1373 (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
1374 (FcbHeader->AllocationSize.QuadPart > NewSize.QuadPart))
1375 {
1376 /* Do nothing */
1377 }
1378 else
1379 {
1380 goto FailAndCleanup;
1381 }
1382 }
1383
1384 /* Check if we need to find out if fast I/O is available */
1385 if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
1386 {
1387 /* Sanity check */
1388 /* ASSERT(!KeIsExecutingDpc()); */
1389
1390 /* Get the Fast I/O table */
1391 Device = IoGetRelatedDeviceObject(FileObject);
1392 FastIoDispatch = Device->DriverObject->FastIoDispatch;
1393
1394 /* Sanity check */
1395 ASSERT(FastIoDispatch != NULL);
1396 ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL);
1397
1398 /* Ask the driver if we can do it */
1399 if (!FastIoDispatch->FastIoCheckIfPossible(FileObject,
1400 FileOffset,
1401 Length,
1402 TRUE,
1403 LockKey,
1404 FALSE,
1405 IoStatus,
1406 Device))
1407 {
1408 /* It's not, fail */
1409 goto FailAndCleanup;
1410 }
1411 }
1412
1413 /* If we are going to modify the filesize,
1414 * save the old fs in case the operation fails.
1415 */
1416 if (NewSize.QuadPart > FcbHeader->FileSize.QuadPart)
1417 {
1418 FileSizeModified = TRUE;
1419 OldFileSize.QuadPart = FcbHeader->FileSize.QuadPart;
1420 OldValidDataLength.QuadPart = FcbHeader->ValidDataLength.QuadPart;
1421
1422 /* If the high part of the filesize is going
1423 * to change, grab the Paging IoResouce.
1424 */
1425 if (NewSize.HighPart != FcbHeader->FileSize.HighPart &&
1426 FcbHeader->PagingIoResource)
1427 {
1428 ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
1429 FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
1430 ExReleaseResourceLite(FcbHeader->PagingIoResource);
1431 }
1432 else
1433 {
1434 FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
1435 }
1436 }
1437
1438
1439 /* Nagar p.544.
1440 * Set ourselves as top component.
1441 */
1442 PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP;
1443 _SEH2_TRY
1444 {
1445 /* Check if there is a gap between the end of the file and the offset.
1446 * If yes, then we have to zero the data.
1447 */
1448 if (Offset.QuadPart > FcbHeader->ValidDataLength.QuadPart)
1449 {
1450 Result = CcZeroData(FileObject,
1451 &FcbHeader->ValidDataLength,
1452 &Offset,
1453 TRUE);
1454 if (Result)
1455 {
1456 CcPrepareMdlWrite(FileObject,
1457 &Offset,
1458 Length,
1459 MdlChain,
1460 IoStatus);
1461 }
1462 }
1463 else
1464 {
1465 CcPrepareMdlWrite(FileObject, &Offset, Length, MdlChain, IoStatus);
1466 }
1467
1468 }
1469 _SEH2_EXCEPT(FsRtlIsNtstatusExpected(_SEH2_GetExceptionCode()) ?
1470 EXCEPTION_EXECUTE_HANDLER :
1471 EXCEPTION_CONTINUE_SEARCH)
1472 {
1473 Result = FALSE;
1474 }
1475 _SEH2_END;
1476
1477 /* Reset the top component */
1478 PsGetCurrentThread()->TopLevelIrp = 0;
1479
1480 /* Did the operation suceeded */
1481 if (Result)
1482 {
1483 /* Check if we need to update the filesize */
1484 if (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart)
1485 {
1486 if (NewSize.HighPart != FcbHeader->ValidDataLength.HighPart &&
1487 FcbHeader->PagingIoResource)
1488 {
1489 ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
1490 FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
1491 ExReleaseResourceLite(FcbHeader->PagingIoResource);
1492 }
1493 else
1494 {
1495 FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
1496 }
1497 }
1498
1499 /* Flag the file as modified */
1500 FileObject->Flags |= FO_FILE_MODIFIED;
1501
1502 /* Check if the filesize has changed */
1503 if (FileSizeModified)
1504 {
1505 SharedCacheMap =
1506 (PSHARED_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
1507 SharedCacheMap->FileSize.QuadPart = NewSize.QuadPart;
1508 FileObject->Flags |= FO_FILE_SIZE_CHANGED;
1509 }
1510 }
1511 else
1512 {
1513 /* The operation did not succeed.
1514 * Reset the file size to what it should be.
1515 */
1516 if (FileSizeModified)
1517 {
1518 if (FcbHeader->PagingIoResource)
1519 {
1520 ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
1521 FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
1522 FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
1523 ExReleaseResourceLite(FcbHeader->PagingIoResource);
1524 }
1525 else
1526 {
1527 FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
1528 FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
1529 }
1530 }
1531 }
1532
1533 goto Cleanup;
1534 }
1535 else
1536 {
1537 goto FailAndCleanup;
1538 }
1539
1540 FailAndCleanup:
1541
1542 ExReleaseResourceLite(FcbHeader->Resource);
1543 FsRtlExitFileSystem();
1544 return FALSE;
1545
1546 Cleanup:
1547
1548 ExReleaseResourceLite(FcbHeader->Resource);
1549 FsRtlExitFileSystem();
1550 return Result;
1551 }
1552
1553 NTSTATUS
1554 NTAPI
1555 FsRtlAcquireFileExclusiveCommon(IN PFILE_OBJECT FileObject,
1556 IN FS_FILTER_SECTION_SYNC_TYPE SyncType,
1557 IN ULONG Reserved)
1558 {
1559 PFSRTL_COMMON_FCB_HEADER FcbHeader;
1560 PDEVICE_OBJECT DeviceObject;
1561 PFAST_IO_DISPATCH FastDispatch;
1562
1563 /* Get Device Object and Fast Calls */
1564 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1565 DeviceObject = IoGetRelatedDeviceObject(FileObject);
1566 FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1567
1568 /* Get master FsRtl lock */
1569 FsRtlEnterFileSystem();
1570
1571 /* Check if Fast Calls are supported, and check AcquireFileForNtCreateSection */
1572 if (FastDispatch &&
1573 FastDispatch->AcquireFileForNtCreateSection)
1574 {
1575 /* Call the AcquireFileForNtCreateSection FastIo handler */
1576 FastDispatch->AcquireFileForNtCreateSection(FileObject);
1577 }
1578 else
1579 {
1580 /* No FastIo handler, acquire file's resource exclusively */
1581 if (FcbHeader && FcbHeader->Resource) ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
1582 }
1583
1584 return STATUS_SUCCESS;
1585 }
1586
1587 /*
1588 * @implemented
1589 */
1590 VOID
1591 NTAPI
1592 FsRtlAcquireFileExclusive(IN PFILE_OBJECT FileObject)
1593 {
1594 PAGED_CODE();
1595
1596 /* Call the common routine. Don't care about the result */
1597 (VOID)FsRtlAcquireFileExclusiveCommon(FileObject, SyncTypeOther, 0);
1598 }
1599
1600 /*
1601 * @implemented
1602 */
1603 VOID
1604 NTAPI
1605 FsRtlReleaseFile(IN PFILE_OBJECT FileObject)
1606 {
1607 PFSRTL_COMMON_FCB_HEADER FcbHeader;
1608 PDEVICE_OBJECT DeviceObject;
1609 PFAST_IO_DISPATCH FastDispatch;
1610
1611 /* Get Device Object and Fast Calls */
1612 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1613 DeviceObject = IoGetRelatedDeviceObject(FileObject);
1614 FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1615
1616 /* Check if Fast Calls are supported and check ReleaseFileForNtCreateSection */
1617 if (FastDispatch &&
1618 FastDispatch->ReleaseFileForNtCreateSection)
1619 {
1620 /* Call the ReleaseFileForNtCreateSection FastIo handler */
1621 FastDispatch->ReleaseFileForNtCreateSection(FileObject);
1622 }
1623 else
1624 {
1625 /* No FastIo handler, release file's resource */
1626 if (FcbHeader && FcbHeader->Resource) ExReleaseResourceLite(FcbHeader->Resource);
1627 }
1628
1629 /* Release master FsRtl lock */
1630 FsRtlExitFileSystem();
1631 }
1632
1633 /*
1634 * @implemented
1635 */
1636 NTSTATUS
1637 NTAPI
1638 FsRtlAcquireFileForCcFlushEx(IN PFILE_OBJECT FileObject)
1639 {
1640 PFSRTL_COMMON_FCB_HEADER FcbHeader;
1641 PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1642 PFAST_IO_DISPATCH FastDispatch;
1643 NTSTATUS Status;
1644
1645 /* Get the Base File System (Volume) and Fast Calls */
1646 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1647 DeviceObject = IoGetRelatedDeviceObject(FileObject);
1648 BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1649 FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1650
1651 /* Get master FsRtl lock */
1652 FsRtlEnterFileSystem();
1653
1654 /* Check if Fast Calls are supported, and check AcquireForCcFlush */
1655 if (FastDispatch &&
1656 FastDispatch->AcquireForCcFlush)
1657 {
1658 /* Call the AcquireForCcFlush FastIo handler */
1659 Status = FastDispatch->AcquireForCcFlush(FileObject, BaseDeviceObject);
1660
1661 /* Return either success or inability to wait.
1662 In case of other failure - fall through */
1663 if (Status == STATUS_SUCCESS ||
1664 Status == STATUS_CANT_WAIT)
1665 {
1666 return Status;
1667 }
1668 }
1669
1670 /* No FastIo handler (or it failed). Acquire Main resource */
1671 if (FcbHeader->Resource)
1672 {
1673 /* Acquire it - either shared if it's already acquired
1674 or exclusively if we are the first */
1675 if (ExIsResourceAcquiredSharedLite(FcbHeader->Resource))
1676 ExAcquireResourceSharedLite(FcbHeader->Resource, TRUE);
1677 else
1678 ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
1679 }
1680
1681 /* Also acquire its PagingIO resource */
1682 if (FcbHeader->PagingIoResource)
1683 ExAcquireResourceSharedLite(FcbHeader->PagingIoResource, TRUE);
1684
1685 return STATUS_SUCCESS;
1686 }
1687
1688 /*
1689 * @implemented
1690 */
1691 VOID
1692 NTAPI
1693 FsRtlAcquireFileForCcFlush(IN PFILE_OBJECT FileObject)
1694 {
1695 PAGED_CODE();
1696
1697 /* Call the common routine. Don't care about the result */
1698 (VOID)FsRtlAcquireFileForCcFlushEx(FileObject);
1699 }
1700
1701
1702 /*
1703 * @implemented
1704 */
1705 VOID
1706 NTAPI
1707 FsRtlReleaseFileForCcFlush(IN PFILE_OBJECT FileObject)
1708 {
1709 PFSRTL_COMMON_FCB_HEADER FcbHeader;
1710 PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1711 PFAST_IO_DISPATCH FastDispatch;
1712 NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST;
1713
1714 /* Get Device Object and Fast Calls */
1715 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1716 DeviceObject = IoGetRelatedDeviceObject(FileObject);
1717 BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1718 FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1719
1720 /* Check if Fast Calls are supported, and check ReleaseForCcFlush */
1721 if (FastDispatch &&
1722 FastDispatch->ReleaseForCcFlush)
1723 {
1724 /* Call the ReleaseForCcFlush FastIo handler */
1725 Status = FastDispatch->ReleaseForCcFlush(FileObject, BaseDeviceObject);
1726 }
1727
1728 if (!NT_SUCCESS(Status))
1729 {
1730 /* No FastIo handler (or it failed). Release PagingIO resource and
1731 then Main resource */
1732 if (FcbHeader->PagingIoResource) ExReleaseResourceLite(FcbHeader->PagingIoResource);
1733 if (FcbHeader->Resource) ExReleaseResourceLite(FcbHeader->Resource);
1734 }
1735
1736 /* Release master FsRtl lock */
1737 FsRtlExitFileSystem();
1738 }
1739
1740 /*
1741 * @implemented
1742 */
1743 NTSTATUS
1744 NTAPI
1745 FsRtlAcquireFileForModWriteEx(IN PFILE_OBJECT FileObject,
1746 IN PLARGE_INTEGER EndingOffset,
1747 IN PERESOURCE *ResourceToRelease)
1748 {
1749 PFSRTL_COMMON_FCB_HEADER FcbHeader;
1750 PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1751 PFAST_IO_DISPATCH FastDispatch;
1752 PERESOURCE ResourceToAcquire = NULL;
1753 BOOLEAN Exclusive = FALSE;
1754 BOOLEAN Result;
1755 NTSTATUS Status = STATUS_SUCCESS;
1756
1757 /* Get Device Object and Fast Calls */
1758 FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
1759 DeviceObject = IoGetRelatedDeviceObject(FileObject);
1760 BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1761 FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1762
1763 /* Check if Fast Calls are supported, and check AcquireForModWrite */
1764 if (FastDispatch &&
1765 FastDispatch->AcquireForModWrite)
1766 {
1767 /* Call the AcquireForModWrite FastIo handler */
1768 Status = FastDispatch->AcquireForModWrite(FileObject,
1769 EndingOffset,
1770 ResourceToRelease,
1771 BaseDeviceObject);
1772
1773 /* Return either success or inability to wait.
1774 In case of other failure - fall through */
1775 if (Status == STATUS_SUCCESS ||
1776 Status == STATUS_CANT_WAIT)
1777 {
1778 return Status;
1779 }
1780 }
1781
1782 Status = STATUS_SUCCESS;
1783
1784 /* No FastIo handler, use algorithm from Nagar p.550. */
1785 if (!FcbHeader->Resource)
1786 {
1787 *ResourceToRelease = NULL;
1788 return STATUS_SUCCESS;
1789 }
1790
1791 /* Default condition - shared acquiring of Paging IO Resource */
1792 ResourceToAcquire = FcbHeader->PagingIoResource;
1793
1794 /* Decide on type of locking and type of resource based on historical magic
1795 well explain by Nagar in p. 550-551 */
1796 if ((EndingOffset->QuadPart > FcbHeader->ValidDataLength.QuadPart &&
1797 FcbHeader->FileSize.QuadPart != FcbHeader->ValidDataLength.QuadPart) ||
1798 (FcbHeader->Flags & FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX))
1799 {
1800 /* Either exclusive flag is set or write operation is extending
1801 the valid data length. Prefer exclusive acquire then */
1802 Exclusive = TRUE;
1803 ResourceToAcquire = FcbHeader->Resource;
1804 }
1805 else if (!FcbHeader->PagingIoResource ||
1806 (FcbHeader->Flags & FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH))
1807 {
1808 /* Acquire main resource shared if flag is specified or
1809 if PagingIo resource is missing */
1810 Exclusive = FALSE;
1811 ResourceToAcquire = FcbHeader->Resource;
1812 }
1813
1814 /* Acquire the resource in the loop, since the above code is unsafe */
1815 while (TRUE)
1816 {
1817 Result = FALSE;
1818
1819 if (Exclusive)
1820 Result = ExAcquireResourceExclusiveLite(ResourceToAcquire, FALSE);
1821 else
1822 Result = ExAcquireSharedWaitForExclusive(ResourceToAcquire, FALSE);
1823
1824 if (!Result) {
1825 Status = STATUS_CANT_WAIT;
1826 break;
1827 }
1828
1829 /* Do the magic ifs again */
1830 if ((EndingOffset->QuadPart > FcbHeader->ValidDataLength.QuadPart) ||
1831 (FcbHeader->Flags & FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX))
1832 {
1833 /* Check what we have */
1834 if (Exclusive)
1835 {
1836 /* Asked for exclusive, got exclusive! */
1837 break;
1838 }
1839 else
1840 {
1841 /* Asked for exclusive, got shared. Release it and retry. */
1842 ExReleaseResourceLite(ResourceToAcquire);
1843 Exclusive = TRUE;
1844 ResourceToAcquire = FcbHeader->Resource;
1845 }
1846 }
1847 else if (FcbHeader->Flags & FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH)
1848 {
1849 if (Exclusive)
1850 {
1851 /* Asked for shared, got exclusive - convert */
1852 ExConvertExclusiveToSharedLite(ResourceToAcquire);
1853 break;
1854 }
1855 else if (ResourceToAcquire != FcbHeader->Resource)
1856 {
1857 /* Asked for main resource, got something else */
1858 ExReleaseResourceLite(ResourceToAcquire);
1859 ResourceToAcquire = FcbHeader->Resource;
1860 Exclusive = TRUE;
1861 }
1862 }
1863 else if (FcbHeader->PagingIoResource &&
1864 ResourceToAcquire != FcbHeader->PagingIoResource)
1865 {
1866 /* There is PagingIo resource, but other resource was acquired */
1867 ResourceToAcquire = FcbHeader->PagingIoResource;
1868 if (!ExAcquireSharedWaitForExclusive(ResourceToAcquire, FALSE))
1869 {
1870 Status = STATUS_CANT_WAIT;
1871 ExReleaseResourceLite(FcbHeader->Resource);
1872 }
1873
1874 break;
1875 }
1876 else if (Exclusive)
1877 {
1878 /* Asked for shared got exclusive - convert */
1879 ExConvertExclusiveToSharedLite(ResourceToAcquire);
1880 break;
1881 }
1882 }
1883
1884 /* If the resource was acquired successfully - pass it to the caller */
1885 if (NT_SUCCESS(Status))
1886 *ResourceToRelease = ResourceToAcquire;
1887
1888 return Status;
1889 }
1890
1891 /*
1892 * @implemented
1893 */
1894 VOID
1895 NTAPI
1896 FsRtlReleaseFileForModWrite(IN PFILE_OBJECT FileObject,
1897 IN PERESOURCE ResourceToRelease)
1898 {
1899 PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
1900 PFAST_IO_DISPATCH FastDispatch;
1901 NTSTATUS Status = STATUS_SUCCESS;
1902
1903 /* Get Device Object and Fast Calls */
1904 DeviceObject = IoGetRelatedDeviceObject(FileObject);
1905 BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
1906 FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
1907
1908 /* Check if Fast Calls are supported and check ReleaseFileForNtCreateSection */
1909 if (FastDispatch &&
1910 FastDispatch->ReleaseForModWrite)
1911 {
1912 /* Call the ReleaseForModWrite FastIo handler */
1913 Status = FastDispatch->ReleaseForModWrite(FileObject,
1914 ResourceToRelease,
1915 BaseDeviceObject);
1916 }
1917
1918 /* Just release the resource if previous op failed */
1919 if (!NT_SUCCESS(Status))
1920 {
1921 ExReleaseResourceLite(ResourceToRelease);
1922 }
1923 }
1924
1925
1926 /*++
1927 * @name FsRtlRegisterFileSystemFilterCallbacks
1928 * @unimplemented
1929 *
1930 * FILLME
1931 *
1932 * @param FilterDriverObject
1933 * FILLME
1934 *
1935 * @param Callbacks
1936 * FILLME
1937 *
1938 * @return None
1939 *
1940 * @remarks None
1941 *
1942 *--*/
1943 NTSTATUS
1944 NTAPI
1945 FsRtlRegisterFileSystemFilterCallbacks(
1946 PDRIVER_OBJECT FilterDriverObject,
1947 PFS_FILTER_CALLBACKS Callbacks)
1948 {
1949 PFS_FILTER_CALLBACKS NewCallbacks;
1950 PEXTENDED_DRIVER_EXTENSION DriverExtension;
1951 PAGED_CODE();
1952
1953 /* Verify parameters */
1954 if ((FilterDriverObject == NULL) || (Callbacks == NULL))
1955 {
1956 return STATUS_INVALID_PARAMETER;
1957 }
1958
1959 /* Allocate a buffer for a copy of the callbacks */
1960 NewCallbacks = ExAllocatePoolWithTag(NonPagedPool,
1961 Callbacks->SizeOfFsFilterCallbacks,
1962 'gmSF');
1963 if (NewCallbacks == NULL)
1964 {
1965 return STATUS_INSUFFICIENT_RESOURCES;
1966 }
1967
1968 /* Copy the callbacks */
1969 RtlCopyMemory(NewCallbacks, Callbacks, Callbacks->SizeOfFsFilterCallbacks);
1970
1971 /* Set the callbacks in the driver extension */
1972 DriverExtension = (PEXTENDED_DRIVER_EXTENSION)FilterDriverObject->DriverExtension;
1973 DriverExtension->FsFilterCallbacks = NewCallbacks;
1974
1975 return STATUS_SUCCESS;
1976 }