Remove unnecessary executable bits
[reactos.git] / drivers / filesystems / cdfs_new / allocsup.c
1 /*++
2
3 Copyright (c) 1990-2000 Microsoft Corporation
4
5 Module Name:
6
7 AllocSup.c
8
9 Abstract:
10
11 This module implements the Allocation support routines for Cdfs.
12
13 The data structure used here is the CD_MCB. There is an entry in
14 the Mcb for each dirent for a file. The entry will map the offset
15 within some file to a starting disk offset and number of bytes.
16 The Mcb also contains the interleave information for an extent.
17 An interleave consists of a number of blocks with data and a
18 (possibly different) number of blocks to skip. Any number of
19 data/skip pairs may exist in an extent but the data and skip sizes
20 are the same throughout the extent.
21
22 We store the following information into an Mcb entry for an extent.
23
24 FileOffset Offset in file for start of extent
25 DiskOffset Offset on disk for start of extent
26 ByteCount Number of file bytes in extent, no skip bytes
27 DataBlockByteCount Number of bytes in each data block
28 TotalBlockByteCount Number of bytes is data block and skip block
29
30 The disk offset in the Mcb has already been biased by the size of
31 the Xar block if present. All of the byte count fields are aligned
32 on logical block boundaries. If this is a directory or path table
33 then the file offset has been biased to round the initial disk
34 offset down to a sector boundary. The biasing is done when loading
35 the values into an Mcb entry.
36
37 An XA file has a header prepended to the file and each sector is 2352
38 bytes. The allocation information ignores the header and only deals
39 with 2048 byte sectors. Callers into the allocation package have
40 adjusted the starting offset value to reflect 2048 sectors. On return
41 from this package the caller will have to convert from 2048 sector values
42 into raw XA sector values.
43
44
45 --*/
46
47 #include "cdprocs.h"
48
49 //
50 // The Bug check file id for this module
51 //
52
53 #define BugCheckFileId (CDFS_BUG_CHECK_ALLOCSUP)
54
55 //
56 // Local support routines
57 //
58
59 ULONG
60 CdFindMcbEntry (
61 _In_ PIRP_CONTEXT IrpContext,
62 _In_ PFCB Fcb,
63 _In_ LONGLONG FileOffset
64 );
65
66 VOID
67 CdDiskOffsetFromMcbEntry (
68 _In_ PIRP_CONTEXT IrpContext,
69 _In_ PCD_MCB_ENTRY McbEntry,
70 _In_ LONGLONG FileOffset,
71 _Out_ PLONGLONG DiskOffset,
72 _Out_ PULONG ByteCount
73 );
74
75 #ifdef ALLOC_PRAGMA
76 #pragma alloc_text(PAGE, CdAddInitialAllocation)
77 #pragma alloc_text(PAGE, CdAddAllocationFromDirent)
78 #pragma alloc_text(PAGE, CdDiskOffsetFromMcbEntry)
79 #pragma alloc_text(PAGE, CdFindMcbEntry)
80 #pragma alloc_text(PAGE, CdInitializeMcb)
81 #pragma alloc_text(PAGE, CdLookupAllocation)
82 #pragma alloc_text(PAGE, CdTruncateAllocation)
83 #pragma alloc_text(PAGE, CdUninitializeMcb)
84 #endif
85
86 \f
87 _Requires_lock_held_(_Global_critical_region_)
88 VOID
89 #ifdef _MSC_VER
90 // PREFast currently has no way to express the Fcb==Fcb->Vcb->VolumeDasdFcb early return
91 #pragma warning(suppress: 6001 6101)
92 #endif
93 CdLookupAllocation (
94 _In_ PIRP_CONTEXT IrpContext,
95 _In_ PFCB Fcb,
96 _In_ LONGLONG FileOffset,
97 _Out_ PLONGLONG DiskOffset,
98 _Out_ PULONG ByteCount
99 )
100
101 /*++
102
103 Routine Description:
104
105 This routine looks through the mapping information for the file
106 to find the logical diskoffset and number of bytes at that offset.
107 We only deal with logical 2048 byte sectors here.
108
109 If the mapping isn't present we will look it up on disk now.
110 This routine assumes we are looking up a valid range in the file. This
111 routine raises if it can't find mapping for the file offset.
112
113 The Fcb may not be locked prior to calling this routine. We will always
114 acquire it here.
115
116 Arguments:
117
118 Fcb - Fcb representing this stream.
119
120 FileOffset - Lookup the allocation beginning at this point.
121
122 DiskOffset - Address to store the logical disk offset.
123
124 ByteCount - Address to store the number of contiguous bytes beginning
125 at DiskOffset above.
126
127 Return Value:
128
129 None.
130
131 --*/
132
133 {
134 BOOLEAN FirstPass = TRUE;
135 ULONG McbEntryOffset;
136 PFCB ParentFcb = NULL;
137 BOOLEAN CleanupParent = FALSE;
138
139 BOOLEAN UnlockFcb = FALSE;
140
141 LONGLONG CurrentFileOffset;
142 ULONG CurrentMcbOffset;
143 PCD_MCB_ENTRY CurrentMcbEntry;
144
145 DIRENT_ENUM_CONTEXT DirContext = {0};
146 DIRENT Dirent = {0};
147
148 PAGED_CODE();
149
150 ASSERT_IRP_CONTEXT( IrpContext );
151 ASSERT_FCB( Fcb );
152
153 //
154 // For DASD IO we already have clamped the read to the volume limits.
155 // We'll allow reading beyond those limits for extended DASD IO, so
156 // no MCB lookup here.
157 //
158
159 if (Fcb == Fcb->Vcb->VolumeDasdFcb) {
160
161 *DiskOffset = FileOffset;
162 return;
163 }
164
165 //
166 // Use a try finally to facilitate cleanup.
167 //
168
169 _SEH2_TRY {
170
171 //
172 // We use a loop to perform the lookup. If we don't find the mapping in the
173 // first pass then we look up all of the allocation and then look again.
174
175 while (TRUE) {
176
177 //
178 //
179 // Lookup the entry containing this file offset.
180 //
181
182 CdLockFcb( IrpContext, Fcb );
183 UnlockFcb = TRUE;
184
185 McbEntryOffset = CdFindMcbEntry( IrpContext, Fcb, FileOffset );
186
187 //
188 // If within the Mcb then we use the data out of this entry and are
189 // done.
190 //
191
192 if (McbEntryOffset < Fcb->Mcb.CurrentEntryCount) {
193
194 CdDiskOffsetFromMcbEntry( IrpContext,
195 Fcb->Mcb.McbArray + McbEntryOffset,
196 FileOffset,
197 DiskOffset,
198 ByteCount );
199
200 break;
201
202 //
203 // If this is not the first pass then the disk is corrupt.
204 //
205
206 } else if (!FirstPass) {
207
208 CdRaiseStatus( IrpContext, STATUS_DISK_CORRUPT_ERROR );
209 }
210
211 CdUnlockFcb( IrpContext, Fcb );
212 UnlockFcb = FALSE;
213
214 //
215 // Initialize the search dirent structures.
216 //
217
218 CdInitializeDirContext( IrpContext, &DirContext );
219 CdInitializeDirent( IrpContext, &Dirent );
220
221 //
222 // Otherwise we need to walk the dirents for this file until we find
223 // the one containing this entry. The parent Fcb should always be
224 // present.
225 //
226
227 ParentFcb = Fcb->ParentFcb;
228 CdAcquireFileShared( IrpContext, ParentFcb );
229 CleanupParent = TRUE;
230
231 //
232 // Do an unsafe test to see if we need to create a file object.
233 //
234
235 CdVerifyOrCreateDirStreamFile( IrpContext, ParentFcb);
236
237 //
238 // Initialize the local variables to indicate the first dirent
239 // and lookup the first dirent.
240 //
241
242 CurrentFileOffset = 0;
243 CurrentMcbOffset = 0;
244
245 CdLookupDirent( IrpContext,
246 ParentFcb,
247 CdQueryFidDirentOffset( Fcb->FileId ),
248 &DirContext );
249
250 //
251 // If we are adding allocation to the Mcb then add all of it.
252 //
253
254 while (TRUE ) {
255
256 //
257 // Update the dirent from the on-disk dirent.
258 //
259
260 CdUpdateDirentFromRawDirent( IrpContext, ParentFcb, &DirContext, &Dirent );
261
262 //
263 // Add this dirent to the Mcb if not already present.
264 //
265
266 CdLockFcb( IrpContext, Fcb );
267 UnlockFcb = TRUE;
268
269 if (CurrentMcbOffset >= Fcb->Mcb.CurrentEntryCount) {
270
271 CdAddAllocationFromDirent( IrpContext, Fcb, CurrentMcbOffset, CurrentFileOffset, &Dirent );
272 }
273
274 CdUnlockFcb( IrpContext, Fcb );
275 UnlockFcb = FALSE;
276
277 //
278 // If this is the last dirent for the file then exit.
279 //
280
281 if (!FlagOn( Dirent.DirentFlags, CD_ATTRIBUTE_MULTI )) {
282
283 break;
284 }
285
286 //
287 // If we couldn't find another entry then the directory is corrupt because
288 // the last dirent for a file doesn't exist.
289 //
290
291 if (!CdLookupNextDirent( IrpContext, ParentFcb, &DirContext, &DirContext )) {
292
293 CdRaiseStatus( IrpContext, STATUS_DISK_CORRUPT_ERROR );
294 }
295
296 //
297 // Update our loop variables.
298 //
299
300 CurrentMcbEntry = Fcb->Mcb.McbArray + CurrentMcbOffset;
301 CurrentFileOffset += CurrentMcbEntry->ByteCount;
302 CurrentMcbOffset += 1;
303 }
304
305 //
306 // All of the allocation is loaded. Go back and look up the mapping again.
307 // It better be there this time.
308 //
309
310 FirstPass = FALSE;
311 }
312
313 } _SEH2_FINALLY {
314
315 if (CleanupParent) {
316
317 //
318 // Release the parent and cleanup the dirent structures.
319 //
320
321 CdReleaseFile( IrpContext, ParentFcb );
322
323 CdCleanupDirContext( IrpContext, &DirContext );
324 CdCleanupDirent( IrpContext, &Dirent );
325 }
326
327 if (UnlockFcb) { CdUnlockFcb( IrpContext, Fcb ); }
328 } _SEH2_END;
329
330 return;
331 }
332
333 \f
334 VOID
335 CdAddAllocationFromDirent (
336 _In_ PIRP_CONTEXT IrpContext,
337 _Inout_ PFCB Fcb,
338 _In_ ULONG McbEntryOffset,
339 _In_ LONGLONG StartingFileOffset,
340 _In_ PDIRENT Dirent
341 )
342
343 /*++
344
345 Routine Description:
346
347 This routine is called to add an entry into the Cd Mcb. We grow the Mcb
348 as necessary and update the new entry.
349
350 NOTE - The Fcb has already been locked prior to makeing this call.
351
352 Arguments:
353
354 Fcb - Fcb containing the Mcb to update.
355
356 McbEntryOffset - Offset into the Mcb array to add this data.
357
358 StartingFileOffset - Offset in bytes from the start of the file.
359
360 Dirent - Dirent containing the on-disk data for this entry.
361
362 Return Value:
363
364 None
365
366 --*/
367
368 {
369 ULONG NewArraySize;
370 PVOID NewMcbArray;
371 PCD_MCB_ENTRY McbEntry;
372
373 PAGED_CODE();
374
375 UNREFERENCED_PARAMETER( IrpContext );
376
377 ASSERT_IRP_CONTEXT( IrpContext );
378 ASSERT_FCB( Fcb );
379 ASSERT_LOCKED_FCB( Fcb );
380
381 //
382 // If we need to grow the Mcb then do it now.
383 //
384
385 if (McbEntryOffset >= Fcb->Mcb.MaximumEntryCount) {
386
387 //
388 // Allocate a new buffer and copy the old data over.
389 //
390
391 NewArraySize = Fcb->Mcb.MaximumEntryCount * 2 * sizeof( CD_MCB_ENTRY );
392
393 NewMcbArray = FsRtlAllocatePoolWithTag( CdPagedPool,
394 NewArraySize,
395 TAG_MCB_ARRAY );
396
397 RtlZeroMemory( NewMcbArray, NewArraySize );
398 RtlCopyMemory( NewMcbArray,
399 Fcb->Mcb.McbArray,
400 Fcb->Mcb.MaximumEntryCount * sizeof( CD_MCB_ENTRY ));
401
402 //
403 // Deallocate the current array unless it is embedded in the Fcb.
404 //
405
406 if (Fcb->Mcb.MaximumEntryCount != 1) {
407
408 CdFreePool( &Fcb->Mcb.McbArray );
409 }
410
411 //
412 // Now update the Mcb with the new array.
413 //
414
415 Fcb->Mcb.MaximumEntryCount *= 2;
416 Fcb->Mcb.McbArray = NewMcbArray;
417 }
418
419 //
420 // Update the new entry with the input data.
421 //
422
423 McbEntry = Fcb->Mcb.McbArray + McbEntryOffset;
424
425 //
426 // Start with the location and length on disk.
427 //
428
429 McbEntry->DiskOffset = LlBytesFromBlocks( Fcb->Vcb, Dirent->StartingOffset );
430 McbEntry->ByteCount = Dirent->DataLength;
431
432 //
433 // Round the byte count up to a logical block boundary if this is
434 // the last extent.
435 //
436
437 if (!FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_MULTI )) {
438
439 McbEntry->ByteCount = BlockAlign( Fcb->Vcb, McbEntry->ByteCount );
440 }
441
442 //
443 // The file offset is the logical position within this file.
444 // We know this is correct regardless of whether we bias the
445 // file size or disk offset.
446 //
447
448 McbEntry->FileOffset = StartingFileOffset;
449
450 //
451 // Convert the interleave information from logical blocks to
452 // bytes.
453 //
454
455 if (Dirent->FileUnitSize != 0) {
456
457 McbEntry->DataBlockByteCount = LlBytesFromBlocks( Fcb->Vcb, Dirent->FileUnitSize );
458 McbEntry->TotalBlockByteCount = McbEntry->DataBlockByteCount +
459 LlBytesFromBlocks( Fcb->Vcb, Dirent->InterleaveGapSize );
460
461 //
462 // If the file is not interleaved then the size of the data block
463 // and total block are the same as the byte count.
464 //
465
466 } else {
467
468 McbEntry->DataBlockByteCount =
469 McbEntry->TotalBlockByteCount = McbEntry->ByteCount;
470 }
471
472 //
473 // Update the number of entries in the Mcb. The Mcb is never sparse
474 // so whenever we add an entry it becomes the last entry in the Mcb.
475 //
476
477 Fcb->Mcb.CurrentEntryCount = McbEntryOffset + 1;
478
479 return;
480 }
481
482 \f
483 VOID
484 CdAddInitialAllocation (
485 _In_ PIRP_CONTEXT IrpContext,
486 _Inout_ PFCB Fcb,
487 _In_ ULONG StartingBlock,
488 _In_ LONGLONG DataLength
489 )
490
491 /*++
492
493 Routine Description:
494
495 This routine is called to set up the initial entry in an Mcb.
496
497 This routine handles the single initial entry for a directory file. We will
498 round the start block down to a sector boundary. Our caller has already
499 biased the DataLength with any adjustments. This is used for the case
500 where there is a single entry and we want to align the data on a sector
501 boundary.
502
503 Arguments:
504
505 Fcb - Fcb containing the Mcb to update.
506
507 StartingBlock - Starting logical block for this directory. This is
508 the start of the actual data. We will bias this by the sector
509 offset of the data.
510
511 DataLength - Length of the data.
512
513 Return Value:
514
515 None
516
517 --*/
518
519 {
520 PCD_MCB_ENTRY McbEntry;
521
522 PAGED_CODE();
523
524 UNREFERENCED_PARAMETER( IrpContext );
525
526 ASSERT_IRP_CONTEXT( IrpContext );
527 ASSERT_FCB( Fcb );
528 ASSERT_LOCKED_FCB( Fcb );
529 NT_ASSERT( 0 == Fcb->Mcb.CurrentEntryCount);
530 NT_ASSERT( CDFS_NTC_FCB_DATA != Fcb->NodeTypeCode);
531
532 //
533 // Update the new entry with the input data.
534 //
535
536 McbEntry = Fcb->Mcb.McbArray;
537
538 //
539 // Start with the location and length on disk.
540 //
541
542 McbEntry->DiskOffset = LlBytesFromBlocks( Fcb->Vcb, StartingBlock );
543 McbEntry->DiskOffset -= Fcb->StreamOffset;
544
545 McbEntry->ByteCount = DataLength;
546
547 //
548 // The file offset is the logical position within this file.
549 // We know this is correct regardless of whether we bias the
550 // file size or disk offset.
551 //
552
553 McbEntry->FileOffset = 0;
554
555 //
556 // If the file is not interleaved then the size of the data block
557 // and total block are the same as the byte count.
558 //
559
560 McbEntry->DataBlockByteCount =
561 McbEntry->TotalBlockByteCount = McbEntry->ByteCount;
562
563 //
564 // Update the number of entries in the Mcb. The Mcb is never sparse
565 // so whenever we add an entry it becomes the last entry in the Mcb.
566 //
567
568 Fcb->Mcb.CurrentEntryCount = 1;
569
570 return;
571 }
572
573 \f
574 VOID
575 CdTruncateAllocation (
576 _In_ PIRP_CONTEXT IrpContext,
577 _Inout_ PFCB Fcb,
578 _In_ LONGLONG StartingFileOffset
579 )
580
581 /*++
582
583 Routine Description:
584
585 This routine truncates the Mcb for a file by eliminating all of the Mcb
586 entries from the entry which contains the given offset.
587
588 The Fcb should be locked when this routine is called.
589
590 Arguments:
591
592 Fcb - Fcb containing the Mcb to truncate.
593
594 StartingFileOffset - Offset in the file to truncate the Mcb from.
595
596 Return Value:
597
598 None
599
600 --*/
601
602 {
603 ULONG McbEntryOffset;
604
605 PAGED_CODE();
606
607 ASSERT_IRP_CONTEXT( IrpContext );
608 ASSERT_FCB( Fcb );
609 ASSERT_LOCKED_FCB( Fcb );
610
611 //
612 // Find the entry containg this starting offset.
613 //
614
615 McbEntryOffset = CdFindMcbEntry( IrpContext, Fcb, StartingFileOffset );
616
617 //
618 // Now set the current size of the mcb to this point.
619 //
620
621 Fcb->Mcb.CurrentEntryCount = McbEntryOffset;
622
623 return;
624 }
625
626 \f
627 _At_(Fcb->NodeByteSize, _In_range_(>=, FIELD_OFFSET( FCB, FcbType )))
628 VOID
629 CdInitializeMcb (
630 _In_ PIRP_CONTEXT IrpContext,
631 _Inout_updates_bytes_(Fcb->NodeByteSize) PFCB Fcb
632 )
633
634 /*++
635
636 Routine Description:
637
638 This routine is called to initialize the Mcb in an Fcb. We initialize
639 this with an entry count of one and point to the entry in the Fcb
640 itself.
641
642 Fcb should be acquired exclusively when this is called.
643
644 Arguments:
645
646 Fcb - Fcb containing the Mcb to initialize.
647
648 Return Value:
649
650 None
651
652 --*/
653
654 {
655 PAGED_CODE();
656
657 UNREFERENCED_PARAMETER( IrpContext );
658
659 ASSERT_IRP_CONTEXT( IrpContext );
660 ASSERT_FCB( Fcb );
661
662 //
663 // Set the entry counts to show there is one entry in the array and
664 // it is unused.
665 //
666
667 Fcb->Mcb.MaximumEntryCount = 1;
668 Fcb->Mcb.CurrentEntryCount = 0;
669
670 Fcb->Mcb.McbArray = &Fcb->McbEntry;
671
672 return;
673 }
674
675 \f
676 _At_(Fcb->NodeByteSize, _In_range_(>=, FIELD_OFFSET( FCB, FcbType )))
677 _When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_PATH_TABLE, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_INDEX)))
678 _When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_INDEX, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_INDEX)))
679 _When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_DATA, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_DATA)))
680 VOID
681 CdUninitializeMcb (
682 _In_ PIRP_CONTEXT IrpContext,
683 _Inout_updates_bytes_(Fcb->NodeByteSize) PFCB Fcb
684 )
685
686 /*++
687
688 Routine Description:
689
690 This routine is called to cleanup an Mcb in an Fcb. We look at the
691 maximum run count in the Fcb and if greater than one we will deallocate
692 the buffer.
693
694 Fcb should be acquired exclusively when this is called.
695
696 Arguments:
697
698 Fcb - Fcb containing the Mcb to uninitialize.
699
700 Return Value:
701
702 None
703
704 --*/
705
706 {
707 PAGED_CODE();
708
709 UNREFERENCED_PARAMETER( IrpContext );
710
711 ASSERT_IRP_CONTEXT( IrpContext );
712 ASSERT_FCB( Fcb );
713
714 //
715 // If the count is greater than one then this is an allocated buffer.
716 //
717
718 if (Fcb->Mcb.MaximumEntryCount > 1) {
719
720 CdFreePool( &Fcb->Mcb.McbArray );
721 }
722
723 return;
724 }
725
726 \f
727 //
728 // Local suupport routine
729 //
730
731 ULONG
732 CdFindMcbEntry (
733 _In_ PIRP_CONTEXT IrpContext,
734 _In_ PFCB Fcb,
735 _In_ LONGLONG FileOffset
736 )
737
738 /*++
739
740 Routine Description:
741
742 This routine is called to find the Mcb entry which contains the file
743 offset at the given point. If the file offset is not currently in the
744 Mcb then we return the offset of the entry to add.
745
746 Fcb should be locked when this is called.
747
748 Arguments:
749
750 Fcb - Fcb containing the Mcb to uninitialize.
751
752 FileOffset - Return the Mcb entry which contains this file offset.
753
754 Return Value:
755
756 ULONG - Offset in the Mcb of the entry for this offset.
757
758 --*/
759
760 {
761 ULONG CurrentMcbOffset;
762 PCD_MCB_ENTRY CurrentMcbEntry;
763
764 PAGED_CODE();
765
766 UNREFERENCED_PARAMETER( IrpContext );
767
768 ASSERT_IRP_CONTEXT( IrpContext );
769 ASSERT_FCB( Fcb );
770 ASSERT_LOCKED_FCB( Fcb );
771
772 //
773 // We expect a linear search will be sufficient here.
774 //
775
776 CurrentMcbOffset = 0;
777 CurrentMcbEntry = Fcb->Mcb.McbArray;
778
779 while (CurrentMcbOffset < Fcb->Mcb.CurrentEntryCount) {
780
781 //
782 // Check if the offset lies within the current Mcb position.
783 //
784
785 if (FileOffset < CurrentMcbEntry->FileOffset + CurrentMcbEntry->ByteCount) {
786
787 break;
788 }
789
790 //
791 // Move to the next entry.
792 //
793
794 CurrentMcbOffset += 1;
795 CurrentMcbEntry += 1;
796 }
797
798 //
799 // This is the offset containing this file offset (or the point
800 // where an entry should be added).
801 //
802
803 return CurrentMcbOffset;
804 }
805
806 \f
807 //
808 // Local support routine
809 //
810
811 VOID
812 CdDiskOffsetFromMcbEntry (
813 _In_ PIRP_CONTEXT IrpContext,
814 _In_ PCD_MCB_ENTRY McbEntry,
815 _In_ LONGLONG FileOffset,
816 _Out_ PLONGLONG DiskOffset,
817 _Out_ PULONG ByteCount
818 )
819
820 /*++
821
822 Routine Description:
823
824 This routine is called to return the diskoffset and length of the file
825 data which begins at offset 'FileOffset'. We have the Mcb entry which
826 contains the mapping and interleave information.
827
828 NOTE - This routine deals with data in 2048 byte logical sectors. If
829 this is an XA file then our caller has already converted from
830 'raw' file bytes to 'cooked' file bytes.
831
832 Arguments:
833
834 McbEntry - Entry in the Mcb containing the allocation information.
835
836 FileOffset - Starting Offset in the file to find the matching disk
837 offsets.
838
839 DiskOffset - Address to store the starting disk offset for this operation.
840
841 ByteCount - Address to store number of contiguous bytes starting at this
842 disk offset.
843
844 Return Value:
845
846 None
847
848 --*/
849
850 {
851 LONGLONG ExtentOffset;
852
853 LONGLONG CurrentDiskOffset;
854 LONGLONG CurrentExtentOffset;
855
856 LONGLONG LocalByteCount;
857
858 PAGED_CODE();
859
860 UNREFERENCED_PARAMETER( IrpContext );
861
862 ASSERT_IRP_CONTEXT( IrpContext );
863
864 //
865 // Extent offset is the difference between the file offset and the start
866 // of the extent.
867 //
868
869 ExtentOffset = FileOffset - McbEntry->FileOffset;
870
871 //
872 // Optimize the non-interleave case.
873 //
874
875 if (McbEntry->ByteCount == McbEntry->DataBlockByteCount) {
876
877 *DiskOffset = McbEntry->DiskOffset + ExtentOffset;
878
879 LocalByteCount = McbEntry->ByteCount - ExtentOffset;
880
881 } else {
882
883 //
884 // Walk though any interleave until we reach the current offset in
885 // this extent.
886 //
887
888 CurrentExtentOffset = McbEntry->DataBlockByteCount;
889 CurrentDiskOffset = McbEntry->DiskOffset;
890
891 while (CurrentExtentOffset <= ExtentOffset) {
892
893 CurrentDiskOffset += McbEntry->TotalBlockByteCount;
894 CurrentExtentOffset += McbEntry->DataBlockByteCount;
895 }
896
897 //
898 // We are now positioned at the data block containing the starting
899 // file offset we were given. The disk offset is the offset of
900 // the start of this block plus the extent offset into this block.
901 // The byte count is the data block byte count minus our offset into
902 // this block.
903 //
904
905 *DiskOffset = CurrentDiskOffset + (ExtentOffset + McbEntry->DataBlockByteCount - CurrentExtentOffset);
906
907 //
908 // Make sure we aren't past the end of the data length. This is possible
909 // if we only use part of the last data block on an interleaved file.
910 //
911
912 if (CurrentExtentOffset > McbEntry->ByteCount) {
913
914 CurrentExtentOffset = McbEntry->ByteCount;
915 }
916
917 LocalByteCount = CurrentExtentOffset - ExtentOffset;
918 }
919
920 //
921 // If the byte count exceeds our limit then cut it to fit in 32 bits.
922 //
923
924 if (LocalByteCount > MAXULONG) {
925
926 *ByteCount = MAXULONG;
927
928 } else {
929
930 *ByteCount = (ULONG) LocalByteCount;
931 }
932
933 return;
934 }
935