9ec81a6cdcb4b0741b7a77c2e2b95e9b4fde087c
[mirror_edk2.git] / MdeModulePkg / Universal / Disk / UdfDxe / FileSystemOperations.c
1 /** @file
2 Handle on-disk format and volume structures in UDF/ECMA-167 file systems.
3
4 Copyright (C) 2014-2017 Paulo Alcantara <pcacjr@zytor.com>
5
6 This program and the accompanying materials are licensed and made available
7 under the terms and conditions of the BSD License which accompanies this
8 distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
12 WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13 **/
14
15 #include "Udf.h"
16
17 EFI_STATUS
18 FindAnchorVolumeDescriptorPointer (
19 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
20 IN EFI_DISK_IO_PROTOCOL *DiskIo,
21 OUT UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER *AnchorPoint
22 )
23 {
24 EFI_STATUS Status;
25 UINT32 BlockSize;
26 EFI_LBA EndLBA;
27 EFI_LBA DescriptorLBAs[4];
28 UINTN Index;
29
30 BlockSize = BlockIo->Media->BlockSize;
31 EndLBA = BlockIo->Media->LastBlock;
32 DescriptorLBAs[0] = 256;
33 DescriptorLBAs[1] = EndLBA - 256;
34 DescriptorLBAs[2] = EndLBA;
35 DescriptorLBAs[3] = 512;
36
37 for (Index = 0; Index < ARRAY_SIZE (DescriptorLBAs); Index++) {
38 Status = DiskIo->ReadDisk (
39 DiskIo,
40 BlockIo->Media->MediaId,
41 MultU64x32 (DescriptorLBAs[Index], BlockSize),
42 sizeof (UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER),
43 (VOID *)AnchorPoint
44 );
45 if (EFI_ERROR (Status)) {
46 return Status;
47 }
48 //
49 // Check if read LBA has a valid AVDP descriptor.
50 //
51 if (IS_AVDP (AnchorPoint)) {
52 return EFI_SUCCESS;
53 }
54 }
55 //
56 // No AVDP found.
57 //
58 return EFI_VOLUME_CORRUPTED;
59 }
60
61 EFI_STATUS
62 StartMainVolumeDescriptorSequence (
63 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
64 IN EFI_DISK_IO_PROTOCOL *DiskIo,
65 IN UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER *AnchorPoint,
66 OUT UDF_VOLUME_INFO *Volume
67 )
68 {
69 EFI_STATUS Status;
70 UINT32 BlockSize;
71 UDF_EXTENT_AD *ExtentAd;
72 UINT64 StartingLsn;
73 UINT64 EndingLsn;
74 VOID *Buffer;
75 UDF_LOGICAL_VOLUME_DESCRIPTOR *LogicalVolDesc;
76 UDF_PARTITION_DESCRIPTOR *PartitionDesc;
77 UINTN Index;
78 UINT32 LogicalBlockSize;
79
80 //
81 // We've already found an ADVP on the volume. It contains the extent
82 // (MainVolumeDescriptorSequenceExtent) where the Main Volume Descriptor
83 // Sequence starts. Therefore, we'll look for Logical Volume Descriptors and
84 // Partitions Descriptors and save them in memory, accordingly.
85 //
86 // Note also that each descriptor will be aligned on a block size (BlockSize)
87 // boundary, so we need to read one block at a time.
88 //
89 BlockSize = BlockIo->Media->BlockSize;
90 ExtentAd = &AnchorPoint->MainVolumeDescriptorSequenceExtent;
91 StartingLsn = (UINT64)ExtentAd->ExtentLocation;
92 EndingLsn = StartingLsn + DivU64x32 (
93 (UINT64)ExtentAd->ExtentLength,
94 BlockSize
95 );
96
97 Volume->LogicalVolDescs =
98 (UDF_LOGICAL_VOLUME_DESCRIPTOR **)AllocateZeroPool (ExtentAd->ExtentLength);
99 if (Volume->LogicalVolDescs == NULL) {
100 return EFI_OUT_OF_RESOURCES;
101 }
102
103 Volume->PartitionDescs =
104 (UDF_PARTITION_DESCRIPTOR **)AllocateZeroPool (ExtentAd->ExtentLength);
105 if (Volume->PartitionDescs == NULL) {
106 Status = EFI_OUT_OF_RESOURCES;
107 goto Error_Alloc_Pds;
108 }
109
110 Buffer = AllocateZeroPool (BlockSize);
111 if (Buffer == NULL) {
112 Status = EFI_OUT_OF_RESOURCES;
113 goto Error_Alloc_Buf;
114 }
115
116 Volume->LogicalVolDescsNo = 0;
117 Volume->PartitionDescsNo = 0;
118
119 while (StartingLsn <= EndingLsn) {
120 Status = DiskIo->ReadDisk (
121 DiskIo,
122 BlockIo->Media->MediaId,
123 MultU64x32 (StartingLsn, BlockSize),
124 BlockSize,
125 Buffer
126 );
127 if (EFI_ERROR (Status)) {
128 goto Error_Read_Disk_Blk;
129 }
130
131 if (IS_TD (Buffer)) {
132 //
133 // Found a Terminating Descriptor. Stop the sequence then.
134 //
135 break;
136 }
137
138 if (IS_LVD (Buffer)) {
139 //
140 // Found a Logical Volume Descriptor.
141 //
142 LogicalVolDesc =
143 (UDF_LOGICAL_VOLUME_DESCRIPTOR *)
144 AllocateZeroPool (sizeof (UDF_LOGICAL_VOLUME_DESCRIPTOR));
145 if (LogicalVolDesc == NULL) {
146 Status = EFI_OUT_OF_RESOURCES;
147 goto Error_Alloc_Lvd;
148 }
149
150 CopyMem ((VOID *)LogicalVolDesc, Buffer,
151 sizeof (UDF_LOGICAL_VOLUME_DESCRIPTOR));
152 Volume->LogicalVolDescs[Volume->LogicalVolDescsNo++] = LogicalVolDesc;
153 } else if (IS_PD (Buffer)) {
154 //
155 // Found a Partition Descriptor.
156 //
157 PartitionDesc =
158 (UDF_PARTITION_DESCRIPTOR *)
159 AllocateZeroPool (sizeof (UDF_PARTITION_DESCRIPTOR));
160 if (PartitionDesc == NULL) {
161 Status = EFI_OUT_OF_RESOURCES;
162 goto Error_Alloc_Pd;
163 }
164
165 CopyMem ((VOID *)PartitionDesc, Buffer,
166 sizeof (UDF_PARTITION_DESCRIPTOR));
167 Volume->PartitionDescs[Volume->PartitionDescsNo++] = PartitionDesc;
168 }
169
170 StartingLsn++;
171 }
172
173 //
174 // When an UDF volume (revision 2.00 or higher) contains a File Entry rather
175 // than an Extended File Entry (which is not recommended as per spec), we need
176 // to make sure the size of a FE will be _at least_ 2048
177 // (UDF_LOGICAL_SECTOR_SIZE) bytes long to keep backward compatibility.
178 //
179 LogicalBlockSize = LV_BLOCK_SIZE (Volume, UDF_DEFAULT_LV_NUM);
180 if (LogicalBlockSize >= UDF_LOGICAL_SECTOR_SIZE) {
181 Volume->FileEntrySize = LogicalBlockSize;
182 } else {
183 Volume->FileEntrySize = UDF_LOGICAL_SECTOR_SIZE;
184 }
185
186 FreePool (Buffer);
187
188 return EFI_SUCCESS;
189
190 Error_Alloc_Pd:
191 Error_Alloc_Lvd:
192 for (Index = 0; Index < Volume->PartitionDescsNo; Index++) {
193 FreePool ((VOID *)Volume->PartitionDescs[Index]);
194 }
195
196 for (Index = 0; Index < Volume->LogicalVolDescsNo; Index++) {
197 FreePool ((VOID *)Volume->LogicalVolDescs[Index]);
198 }
199
200 Error_Read_Disk_Blk:
201 FreePool (Buffer);
202
203 Error_Alloc_Buf:
204 FreePool ((VOID *)Volume->PartitionDescs);
205 Volume->PartitionDescs = NULL;
206
207 Error_Alloc_Pds:
208 FreePool ((VOID *)Volume->LogicalVolDescs);
209 Volume->LogicalVolDescs = NULL;
210
211 return Status;
212 }
213
214 //
215 // Return a Partition Descriptor given a Long Allocation Descriptor. This is
216 // necessary to calculate the right extent (LongAd) offset which is added up
217 // with partition's starting location.
218 //
219 UDF_PARTITION_DESCRIPTOR *
220 GetPdFromLongAd (
221 IN UDF_VOLUME_INFO *Volume,
222 IN UDF_LONG_ALLOCATION_DESCRIPTOR *LongAd
223 )
224 {
225 UDF_LOGICAL_VOLUME_DESCRIPTOR *LogicalVolDesc;
226 UINTN Index;
227 UDF_PARTITION_DESCRIPTOR *PartitionDesc;
228 UINT16 PartitionNum;
229
230 LogicalVolDesc = Volume->LogicalVolDescs[UDF_DEFAULT_LV_NUM];
231
232 switch (LV_UDF_REVISION (LogicalVolDesc)) {
233 case 0x0102:
234 //
235 // As per UDF 1.02 specification:
236 //
237 // There shall be exactly one prevailing Logical Volume Descriptor recorded
238 // per Volume Set. The Partition Maps field shall contain only Type 1
239 // Partition Maps.
240 //
241 PartitionNum = *(UINT16 *)((UINTN)&LogicalVolDesc->PartitionMaps[4]);
242 break;
243 case 0x0150:
244 //
245 // Ensure Type 1 Partition map. Other types aren't supported in this
246 // implementation.
247 //
248 if (LogicalVolDesc->PartitionMaps[0] != 1 ||
249 LogicalVolDesc->PartitionMaps[1] != 6) {
250 return NULL;
251 }
252 PartitionNum = *(UINT16 *)((UINTN)&LogicalVolDesc->PartitionMaps[4]);
253 break;
254 case 0x0260:
255 //
256 // Fall through.
257 //
258 default:
259 PartitionNum = LongAd->ExtentLocation.PartitionReferenceNumber;
260 break;
261 }
262
263 for (Index = 0; Index < Volume->PartitionDescsNo; Index++) {
264 PartitionDesc = Volume->PartitionDescs[Index];
265 if (PartitionDesc->PartitionNumber == PartitionNum) {
266 return PartitionDesc;
267 }
268 }
269
270 return NULL;
271 }
272
273 //
274 // Return logical sector number of a given Long Allocation Descriptor.
275 //
276 UINT64
277 GetLongAdLsn (
278 IN UDF_VOLUME_INFO *Volume,
279 IN UDF_LONG_ALLOCATION_DESCRIPTOR *LongAd
280 )
281 {
282 UDF_PARTITION_DESCRIPTOR *PartitionDesc;
283
284 PartitionDesc = GetPdFromLongAd (Volume, LongAd);
285 ASSERT (PartitionDesc != NULL);
286
287 return (UINT64)PartitionDesc->PartitionStartingLocation +
288 LongAd->ExtentLocation.LogicalBlockNumber;
289 }
290
291 //
292 // Return logical sector number of a given Short Allocation Descriptor.
293 //
294 UINT64
295 GetShortAdLsn (
296 IN UDF_PARTITION_DESCRIPTOR *PartitionDesc,
297 IN UDF_SHORT_ALLOCATION_DESCRIPTOR *ShortAd
298 )
299 {
300 return (UINT64)PartitionDesc->PartitionStartingLocation +
301 ShortAd->ExtentPosition;
302 }
303
304 //
305 // Find File Set Descriptor of a given Logical Volume Descriptor.
306 //
307 // The found FSD will contain the extent (LogicalVolumeContentsUse) where our
308 // root directory is.
309 //
310 EFI_STATUS
311 FindFileSetDescriptor (
312 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
313 IN EFI_DISK_IO_PROTOCOL *DiskIo,
314 IN UDF_VOLUME_INFO *Volume,
315 IN UINTN LogicalVolDescNum,
316 OUT UDF_FILE_SET_DESCRIPTOR *FileSetDesc
317 )
318 {
319 EFI_STATUS Status;
320 UINT64 Lsn;
321 UDF_LOGICAL_VOLUME_DESCRIPTOR *LogicalVolDesc;
322
323 LogicalVolDesc = Volume->LogicalVolDescs[LogicalVolDescNum];
324 Lsn = GetLongAdLsn (Volume, &LogicalVolDesc->LogicalVolumeContentsUse);
325
326 //
327 // Read extent (Long Ad).
328 //
329 Status = DiskIo->ReadDisk (
330 DiskIo,
331 BlockIo->Media->MediaId,
332 MultU64x32 (Lsn, LogicalVolDesc->LogicalBlockSize),
333 sizeof (UDF_FILE_SET_DESCRIPTOR),
334 (VOID *)FileSetDesc
335 );
336 if (EFI_ERROR (Status)) {
337 return Status;
338 }
339
340 //
341 // Check if the read extent contains a valid FSD's tag identifier.
342 //
343 if (!IS_FSD (FileSetDesc)) {
344 return EFI_VOLUME_CORRUPTED;
345 }
346
347 return EFI_SUCCESS;
348 }
349
350 //
351 // Get all File Set Descriptors for each Logical Volume Descriptor.
352 //
353 EFI_STATUS
354 GetFileSetDescriptors (
355 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
356 IN EFI_DISK_IO_PROTOCOL *DiskIo,
357 IN OUT UDF_VOLUME_INFO *Volume
358 )
359 {
360 EFI_STATUS Status;
361 UINTN Index;
362 UDF_FILE_SET_DESCRIPTOR *FileSetDesc;
363 UINTN Count;
364
365 Volume->FileSetDescs =
366 (UDF_FILE_SET_DESCRIPTOR **)AllocateZeroPool (
367 Volume->LogicalVolDescsNo * sizeof (UDF_FILE_SET_DESCRIPTOR));
368 if (Volume->FileSetDescs == NULL) {
369 return EFI_OUT_OF_RESOURCES;
370 }
371
372 for (Index = 0; Index < Volume->LogicalVolDescsNo; Index++) {
373 FileSetDesc = AllocateZeroPool (sizeof (UDF_FILE_SET_DESCRIPTOR));
374 if (FileSetDesc == NULL) {
375 Status = EFI_OUT_OF_RESOURCES;
376 goto Error_Alloc_Fsd;
377 }
378
379 //
380 // Find a FSD for this LVD.
381 //
382 Status = FindFileSetDescriptor (
383 BlockIo,
384 DiskIo,
385 Volume,
386 Index,
387 FileSetDesc
388 );
389 if (EFI_ERROR (Status)) {
390 goto Error_Find_Fsd;
391 }
392
393 //
394 // Got one. Save it.
395 //
396 Volume->FileSetDescs[Index] = FileSetDesc;
397 }
398
399 Volume->FileSetDescsNo = Volume->LogicalVolDescsNo;
400 return EFI_SUCCESS;
401
402 Error_Find_Fsd:
403 Count = Index + 1;
404 for (Index = 0; Index < Count; Index++) {
405 FreePool ((VOID *)Volume->FileSetDescs[Index]);
406 }
407
408 FreePool ((VOID *)Volume->FileSetDescs);
409 Volume->FileSetDescs = NULL;
410
411 Error_Alloc_Fsd:
412 return Status;
413 }
414
415 //
416 // Read Volume and File Structure on an UDF file system.
417 //
418 EFI_STATUS
419 ReadVolumeFileStructure (
420 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
421 IN EFI_DISK_IO_PROTOCOL *DiskIo,
422 OUT UDF_VOLUME_INFO *Volume
423 )
424 {
425 EFI_STATUS Status;
426 UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER AnchorPoint;
427
428 //
429 // Find an AVDP.
430 //
431 Status = FindAnchorVolumeDescriptorPointer (
432 BlockIo,
433 DiskIo,
434 &AnchorPoint
435 );
436 if (EFI_ERROR (Status)) {
437 return Status;
438 }
439
440 //
441 // AVDP has been found. Start MVDS.
442 //
443 Status = StartMainVolumeDescriptorSequence (
444 BlockIo,
445 DiskIo,
446 &AnchorPoint,
447 Volume
448 );
449 if (EFI_ERROR (Status)) {
450 return Status;
451 }
452
453 return Status;
454 }
455
456 //
457 // Calculate length of a given File Identifier Descriptor.
458 //
459 UINT64
460 GetFidDescriptorLength (
461 IN UDF_FILE_IDENTIFIER_DESCRIPTOR *FileIdentifierDesc
462 )
463 {
464 return (UINT64)(
465 (INTN)((OFFSET_OF (UDF_FILE_IDENTIFIER_DESCRIPTOR, Data[0]) + 3 +
466 FileIdentifierDesc->LengthOfFileIdentifier +
467 FileIdentifierDesc->LengthOfImplementationUse) >> 2) << 2
468 );
469 }
470
471 //
472 // Duplicate a given File Identifier Descriptor.
473 //
474 VOID
475 DuplicateFid (
476 IN UDF_FILE_IDENTIFIER_DESCRIPTOR *FileIdentifierDesc,
477 OUT UDF_FILE_IDENTIFIER_DESCRIPTOR **NewFileIdentifierDesc
478 )
479 {
480 *NewFileIdentifierDesc =
481 (UDF_FILE_IDENTIFIER_DESCRIPTOR *)AllocateCopyPool (
482 (UINTN) GetFidDescriptorLength (FileIdentifierDesc), FileIdentifierDesc);
483 }
484
485 //
486 // Duplicate either a given File Entry or a given Extended File Entry.
487 //
488 VOID
489 DuplicateFe (
490 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
491 IN UDF_VOLUME_INFO *Volume,
492 IN VOID *FileEntry,
493 OUT VOID **NewFileEntry
494 )
495 {
496 *NewFileEntry = AllocateCopyPool (Volume->FileEntrySize, FileEntry);
497 }
498
499 //
500 // Get raw data + length of a given File Entry or Extended File Entry.
501 //
502 // The file's recorded data can contain either real file content (inline) or
503 // a sequence of extents (or Allocation Descriptors) which tells where file's
504 // content is stored in.
505 //
506 // NOTE: The FE/EFE can be thought it was an inode.
507 //
508 VOID
509 GetFileEntryData (
510 IN VOID *FileEntryData,
511 OUT VOID **Data,
512 OUT UINT64 *Length
513 )
514 {
515 UDF_EXTENDED_FILE_ENTRY *ExtendedFileEntry;
516 UDF_FILE_ENTRY *FileEntry;
517
518 if (IS_EFE (FileEntryData)) {
519 ExtendedFileEntry = (UDF_EXTENDED_FILE_ENTRY *)FileEntryData;
520
521 *Length = ExtendedFileEntry->InformationLength;
522 *Data = (VOID *)((UINT8 *)ExtendedFileEntry->Data +
523 ExtendedFileEntry->LengthOfExtendedAttributes);
524 } else if (IS_FE (FileEntryData)) {
525 FileEntry = (UDF_FILE_ENTRY *)FileEntryData;
526
527 *Length = FileEntry->InformationLength;
528 *Data = (VOID *)((UINT8 *)FileEntry->Data +
529 FileEntry->LengthOfExtendedAttributes);
530 }
531 }
532
533 //
534 // Get Allocation Descriptors' data information from a given FE/EFE.
535 //
536 VOID
537 GetAdsInformation (
538 IN VOID *FileEntryData,
539 OUT VOID **AdsData,
540 OUT UINT64 *Length
541 )
542 {
543 UDF_EXTENDED_FILE_ENTRY *ExtendedFileEntry;
544 UDF_FILE_ENTRY *FileEntry;
545
546 if (IS_EFE (FileEntryData)) {
547 ExtendedFileEntry = (UDF_EXTENDED_FILE_ENTRY *)FileEntryData;
548
549 *Length = ExtendedFileEntry->LengthOfAllocationDescriptors;
550 *AdsData = (VOID *)((UINT8 *)ExtendedFileEntry->Data +
551 ExtendedFileEntry->LengthOfExtendedAttributes);
552 } else if (IS_FE (FileEntryData)) {
553 FileEntry = (UDF_FILE_ENTRY *)FileEntryData;
554
555 *Length = FileEntry->LengthOfAllocationDescriptors;
556 *AdsData = (VOID *)((UINT8 *)FileEntry->Data +
557 FileEntry->LengthOfExtendedAttributes);
558 }
559 }
560
561 //
562 // Read next Long Allocation Descriptor from a given file's data.
563 //
564 EFI_STATUS
565 GetLongAdFromAds (
566 IN VOID *Data,
567 IN OUT UINT64 *Offset,
568 IN UINT64 Length,
569 OUT UDF_LONG_ALLOCATION_DESCRIPTOR **FoundLongAd
570 )
571 {
572 UDF_LONG_ALLOCATION_DESCRIPTOR *LongAd;
573 UDF_EXTENT_FLAGS ExtentFlags;
574
575 for (;;) {
576 if (*Offset >= Length) {
577 //
578 // No more Long Allocation Descriptors.
579 //
580 return EFI_DEVICE_ERROR;
581 }
582
583 LongAd =
584 (UDF_LONG_ALLOCATION_DESCRIPTOR *)((UINT8 *)Data + *Offset);
585
586 //
587 // If it's either an indirect AD (Extended Alllocation Descriptor) or an
588 // allocated AD, then return it.
589 //
590 ExtentFlags = GET_EXTENT_FLAGS (LONG_ADS_SEQUENCE, LongAd);
591 if (ExtentFlags == EXTENT_IS_NEXT_EXTENT ||
592 ExtentFlags == EXTENT_RECORDED_AND_ALLOCATED) {
593 break;
594 }
595
596 //
597 // This AD is either not recorded but allocated, or not recorded and not
598 // allocated. Skip it.
599 //
600 *Offset += AD_LENGTH (LONG_ADS_SEQUENCE);
601 }
602
603 *FoundLongAd = LongAd;
604
605 return EFI_SUCCESS;
606 }
607
608 //
609 // Read next Short Allocation Descriptor from a given file's data.
610 //
611 EFI_STATUS
612 GetShortAdFromAds (
613 IN VOID *Data,
614 IN OUT UINT64 *Offset,
615 IN UINT64 Length,
616 OUT UDF_SHORT_ALLOCATION_DESCRIPTOR **FoundShortAd
617 )
618 {
619 UDF_SHORT_ALLOCATION_DESCRIPTOR *ShortAd;
620 UDF_EXTENT_FLAGS ExtentFlags;
621
622 for (;;) {
623 if (*Offset >= Length) {
624 //
625 // No more Short Allocation Descriptors.
626 //
627 return EFI_DEVICE_ERROR;
628 }
629
630 ShortAd =
631 (UDF_SHORT_ALLOCATION_DESCRIPTOR *)((UINT8 *)Data + *Offset);
632
633 //
634 // If it's either an indirect AD (Extended Alllocation Descriptor) or an
635 // allocated AD, then return it.
636 //
637 ExtentFlags = GET_EXTENT_FLAGS (SHORT_ADS_SEQUENCE, ShortAd);
638 if (ExtentFlags == EXTENT_IS_NEXT_EXTENT ||
639 ExtentFlags == EXTENT_RECORDED_AND_ALLOCATED) {
640 break;
641 }
642
643 //
644 // This AD is either not recorded but allocated, or not recorded and not
645 // allocated. Skip it.
646 //
647 *Offset += AD_LENGTH (SHORT_ADS_SEQUENCE);
648 }
649
650 *FoundShortAd = ShortAd;
651
652 return EFI_SUCCESS;
653 }
654
655 //
656 // Get either a Short Allocation Descriptor or a Long Allocation Descriptor from
657 // file's data.
658 //
659 EFI_STATUS
660 GetAllocationDescriptor (
661 IN UDF_FE_RECORDING_FLAGS RecordingFlags,
662 IN VOID *Data,
663 IN OUT UINT64 *Offset,
664 IN UINT64 Length,
665 OUT VOID **FoundAd
666 )
667 {
668 if (RecordingFlags == LONG_ADS_SEQUENCE) {
669 return GetLongAdFromAds (
670 Data,
671 Offset,
672 Length,
673 (UDF_LONG_ALLOCATION_DESCRIPTOR **)FoundAd
674 );
675 } else if (RecordingFlags == SHORT_ADS_SEQUENCE) {
676 return GetShortAdFromAds (
677 Data,
678 Offset,
679 Length,
680 (UDF_SHORT_ALLOCATION_DESCRIPTOR **)FoundAd
681 );
682 }
683
684 return EFI_DEVICE_ERROR;
685 }
686
687 //
688 // Return logical sector number of either Short or Long Allocation Descriptor.
689 //
690 UINT64
691 GetAllocationDescriptorLsn (
692 IN UDF_FE_RECORDING_FLAGS RecordingFlags,
693 IN UDF_VOLUME_INFO *Volume,
694 IN UDF_LONG_ALLOCATION_DESCRIPTOR *ParentIcb,
695 IN VOID *Ad
696 )
697 {
698 if (RecordingFlags == LONG_ADS_SEQUENCE) {
699 return GetLongAdLsn (Volume, (UDF_LONG_ALLOCATION_DESCRIPTOR *)Ad);
700 } else if (RecordingFlags == SHORT_ADS_SEQUENCE) {
701 return GetShortAdLsn (
702 GetPdFromLongAd (Volume, ParentIcb),
703 (UDF_SHORT_ALLOCATION_DESCRIPTOR *)Ad
704 );
705 }
706
707 return 0;
708 }
709
710 //
711 // Return offset + length of a given indirect Allocation Descriptor (AED).
712 //
713 EFI_STATUS
714 GetAedAdsOffset (
715 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
716 IN EFI_DISK_IO_PROTOCOL *DiskIo,
717 IN UDF_VOLUME_INFO *Volume,
718 IN UDF_LONG_ALLOCATION_DESCRIPTOR *ParentIcb,
719 IN UDF_FE_RECORDING_FLAGS RecordingFlags,
720 IN VOID *Ad,
721 OUT UINT64 *Offset,
722 OUT UINT64 *Length
723 )
724 {
725 EFI_STATUS Status;
726 UINT32 ExtentLength;
727 UINT64 Lsn;
728 VOID *Data;
729 UINT32 LogicalBlockSize;
730 UDF_ALLOCATION_EXTENT_DESCRIPTOR *AllocExtDesc;
731
732 ExtentLength = GET_EXTENT_LENGTH (RecordingFlags, Ad);
733 Lsn = GetAllocationDescriptorLsn (RecordingFlags,
734 Volume,
735 ParentIcb,
736 Ad);
737
738 Data = AllocatePool (ExtentLength);
739 if (Data == NULL) {
740 return EFI_OUT_OF_RESOURCES;
741 }
742
743 LogicalBlockSize = LV_BLOCK_SIZE (Volume, UDF_DEFAULT_LV_NUM);
744
745 //
746 // Read extent.
747 //
748 Status = DiskIo->ReadDisk (
749 DiskIo,
750 BlockIo->Media->MediaId,
751 MultU64x32 (Lsn, LogicalBlockSize),
752 ExtentLength,
753 Data
754 );
755 if (EFI_ERROR (Status)) {
756 goto Exit;
757 }
758
759 //
760 // Check if read extent contains a valid tag identifier for AED.
761 //
762 AllocExtDesc = (UDF_ALLOCATION_EXTENT_DESCRIPTOR *)Data;
763 if (!IS_AED (AllocExtDesc)) {
764 Status = EFI_VOLUME_CORRUPTED;
765 goto Exit;
766 }
767
768 //
769 // Get AED's block offset and its length.
770 //
771 *Offset = MultU64x32 (Lsn, LogicalBlockSize) +
772 sizeof (UDF_ALLOCATION_EXTENT_DESCRIPTOR);
773 *Length = AllocExtDesc->LengthOfAllocationDescriptors;
774
775 Exit:
776 FreePool (Data);
777
778 return Status;
779 }
780
781 //
782 // Read Allocation Extent Descriptor into memory.
783 //
784 EFI_STATUS
785 GetAedAdsData (
786 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
787 IN EFI_DISK_IO_PROTOCOL *DiskIo,
788 IN UDF_VOLUME_INFO *Volume,
789 IN UDF_LONG_ALLOCATION_DESCRIPTOR *ParentIcb,
790 IN UDF_FE_RECORDING_FLAGS RecordingFlags,
791 IN VOID *Ad,
792 OUT VOID **Data,
793 OUT UINT64 *Length
794 )
795 {
796 EFI_STATUS Status;
797 UINT64 Offset;
798
799 //
800 // Get AED's offset + length.
801 //
802 Status = GetAedAdsOffset (
803 BlockIo,
804 DiskIo,
805 Volume,
806 ParentIcb,
807 RecordingFlags,
808 Ad,
809 &Offset,
810 Length
811 );
812 if (EFI_ERROR (Status)) {
813 return Status;
814 }
815
816 //
817 // Allocate buffer to read in AED's data.
818 //
819 *Data = AllocatePool ((UINTN) (*Length));
820 if (*Data == NULL) {
821 return EFI_OUT_OF_RESOURCES;
822 }
823
824 return DiskIo->ReadDisk (
825 DiskIo,
826 BlockIo->Media->MediaId,
827 Offset,
828 (UINTN) (*Length),
829 *Data
830 );
831 }
832
833 //
834 // Function used to serialise reads of Allocation Descriptors.
835 //
836 EFI_STATUS
837 GrowUpBufferToNextAd (
838 IN UDF_FE_RECORDING_FLAGS RecordingFlags,
839 IN VOID *Ad,
840 IN OUT VOID **Buffer,
841 IN UINT64 Length
842 )
843 {
844 UINT32 ExtentLength;
845
846 ExtentLength = GET_EXTENT_LENGTH (RecordingFlags, Ad);
847
848 if (*Buffer == NULL) {
849 *Buffer = AllocatePool (ExtentLength);
850 if (*Buffer == NULL) {
851 return EFI_OUT_OF_RESOURCES;
852 }
853 } else {
854 *Buffer = ReallocatePool ((UINTN) Length, (UINTN) (Length + ExtentLength), *Buffer);
855 if (*Buffer == NULL) {
856 return EFI_OUT_OF_RESOURCES;
857 }
858 }
859
860 return EFI_SUCCESS;
861 }
862
863 //
864 // Read data or size of either a File Entry or an Extended File Entry.
865 //
866 EFI_STATUS
867 ReadFile (
868 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
869 IN EFI_DISK_IO_PROTOCOL *DiskIo,
870 IN UDF_VOLUME_INFO *Volume,
871 IN UDF_LONG_ALLOCATION_DESCRIPTOR *ParentIcb,
872 IN VOID *FileEntryData,
873 IN OUT UDF_READ_FILE_INFO *ReadFileInfo
874 )
875 {
876 EFI_STATUS Status;
877 UINT32 LogicalBlockSize;
878 VOID *Data;
879 UINT64 Length;
880 VOID *Ad;
881 UINT64 AdOffset;
882 UINT64 Lsn;
883 BOOLEAN DoFreeAed;
884 UINT64 FilePosition;
885 UINT64 Offset;
886 UINT64 DataOffset;
887 UINT64 BytesLeft;
888 UINT64 DataLength;
889 BOOLEAN FinishedSeeking;
890 UINT32 ExtentLength;
891 UDF_FE_RECORDING_FLAGS RecordingFlags;
892
893 LogicalBlockSize = LV_BLOCK_SIZE (Volume, UDF_DEFAULT_LV_NUM);
894 DoFreeAed = FALSE;
895
896 //
897 // set BytesLeft to suppress incorrect compiler/analyzer warnings
898 //
899 BytesLeft = 0;
900
901 switch (ReadFileInfo->Flags) {
902 case READ_FILE_GET_FILESIZE:
903 case READ_FILE_ALLOCATE_AND_READ:
904 //
905 // Initialise ReadFileInfo structure for either getting file size, or
906 // reading file's recorded data.
907 //
908 ReadFileInfo->ReadLength = 0;
909 ReadFileInfo->FileData = NULL;
910 break;
911 case READ_FILE_SEEK_AND_READ:
912 //
913 // About to seek a file and/or read its data.
914 //
915 Length = ReadFileInfo->FileSize - ReadFileInfo->FilePosition;
916 if (ReadFileInfo->FileDataSize > Length) {
917 //
918 // About to read beyond the EOF -- truncate it.
919 //
920 ReadFileInfo->FileDataSize = Length;
921 }
922
923 //
924 // Initialise data to start seeking and/or reading a file.
925 //
926 BytesLeft = ReadFileInfo->FileDataSize;
927 DataOffset = 0;
928 FilePosition = 0;
929 FinishedSeeking = FALSE;
930
931 break;
932 }
933
934 RecordingFlags = GET_FE_RECORDING_FLAGS (FileEntryData);
935 switch (RecordingFlags) {
936 case INLINE_DATA:
937 //
938 // There are no extents for this FE/EFE. All data is inline.
939 //
940 GetFileEntryData (FileEntryData, &Data, &Length);
941
942 if (ReadFileInfo->Flags == READ_FILE_GET_FILESIZE) {
943 ReadFileInfo->ReadLength = Length;
944 } else if (ReadFileInfo->Flags == READ_FILE_ALLOCATE_AND_READ) {
945 //
946 // Allocate buffer for starting read data.
947 //
948 ReadFileInfo->FileData = AllocatePool ((UINTN) Length);
949 if (ReadFileInfo->FileData == NULL) {
950 return EFI_OUT_OF_RESOURCES;
951 }
952
953 //
954 // Read all inline data into ReadFileInfo->FileData
955 //
956 CopyMem (ReadFileInfo->FileData, Data, (UINTN) Length);
957 ReadFileInfo->ReadLength = Length;
958 } else if (ReadFileInfo->Flags == READ_FILE_SEEK_AND_READ) {
959 //
960 // If FilePosition is non-zero, seek file to FilePosition, read
961 // FileDataSize bytes and then updates FilePosition.
962 //
963 CopyMem (
964 ReadFileInfo->FileData,
965 (VOID *)((UINT8 *)Data + ReadFileInfo->FilePosition),
966 (UINTN) ReadFileInfo->FileDataSize
967 );
968
969 ReadFileInfo->FilePosition += ReadFileInfo->FileDataSize;
970 } else {
971 ASSERT (FALSE);
972 return EFI_INVALID_PARAMETER;
973 }
974
975 Status = EFI_SUCCESS;
976 break;
977
978 case LONG_ADS_SEQUENCE:
979 case SHORT_ADS_SEQUENCE:
980 //
981 // This FE/EFE contains a run of Allocation Descriptors. Get data + size
982 // for start reading them out.
983 //
984 GetAdsInformation (FileEntryData, &Data, &Length);
985 AdOffset = 0;
986
987 for (;;) {
988 //
989 // Read AD.
990 //
991 Status = GetAllocationDescriptor (
992 RecordingFlags,
993 Data,
994 &AdOffset,
995 Length,
996 &Ad
997 );
998 if (Status == EFI_DEVICE_ERROR) {
999 Status = EFI_SUCCESS;
1000 goto Done;
1001 }
1002
1003 //
1004 // Check if AD is an indirect AD. If so, read Allocation Extent
1005 // Descriptor and its extents (ADs).
1006 //
1007 if (GET_EXTENT_FLAGS (RecordingFlags, Ad) == EXTENT_IS_NEXT_EXTENT) {
1008 if (!DoFreeAed) {
1009 DoFreeAed = TRUE;
1010 } else {
1011 FreePool (Data);
1012 }
1013
1014 Status = GetAedAdsData (
1015 BlockIo,
1016 DiskIo,
1017 Volume,
1018 ParentIcb,
1019 RecordingFlags,
1020 Ad,
1021 &Data,
1022 &Length
1023 );
1024 if (EFI_ERROR (Status)) {
1025 goto Error_Get_Aed;
1026 }
1027
1028 AdOffset = 0;
1029 continue;
1030 }
1031
1032 ExtentLength = GET_EXTENT_LENGTH (RecordingFlags, Ad);
1033
1034 Lsn = GetAllocationDescriptorLsn (RecordingFlags,
1035 Volume,
1036 ParentIcb,
1037 Ad);
1038
1039 switch (ReadFileInfo->Flags) {
1040 case READ_FILE_GET_FILESIZE:
1041 ReadFileInfo->ReadLength += ExtentLength;
1042 break;
1043 case READ_FILE_ALLOCATE_AND_READ:
1044 //
1045 // Increase FileData (if necessary) to read next extent.
1046 //
1047 Status = GrowUpBufferToNextAd (
1048 RecordingFlags,
1049 Ad,
1050 &ReadFileInfo->FileData,
1051 ReadFileInfo->ReadLength
1052 );
1053 if (EFI_ERROR (Status)) {
1054 goto Error_Alloc_Buffer_To_Next_Ad;
1055 }
1056
1057 //
1058 // Read extent's data into FileData.
1059 //
1060 Status = DiskIo->ReadDisk (
1061 DiskIo,
1062 BlockIo->Media->MediaId,
1063 MultU64x32 (Lsn, LogicalBlockSize),
1064 ExtentLength,
1065 (VOID *)((UINT8 *)ReadFileInfo->FileData +
1066 ReadFileInfo->ReadLength)
1067 );
1068 if (EFI_ERROR (Status)) {
1069 goto Error_Read_Disk_Blk;
1070 }
1071
1072 ReadFileInfo->ReadLength += ExtentLength;
1073 break;
1074 case READ_FILE_SEEK_AND_READ:
1075 //
1076 // Seek file first before reading in its data.
1077 //
1078 if (FinishedSeeking) {
1079 Offset = 0;
1080 goto Skip_File_Seek;
1081 }
1082
1083 if (FilePosition + ExtentLength < ReadFileInfo->FilePosition) {
1084 FilePosition += ExtentLength;
1085 goto Skip_Ad;
1086 }
1087
1088 if (FilePosition + ExtentLength > ReadFileInfo->FilePosition) {
1089 Offset = ReadFileInfo->FilePosition - FilePosition;
1090 } else {
1091 Offset = 0;
1092 }
1093
1094 //
1095 // Done with seeking file. Start reading its data.
1096 //
1097 FinishedSeeking = TRUE;
1098
1099 Skip_File_Seek:
1100 //
1101 // Make sure we don't read more data than really wanted.
1102 //
1103 if (ExtentLength - Offset > BytesLeft) {
1104 DataLength = BytesLeft;
1105 } else {
1106 DataLength = ExtentLength - Offset;
1107 }
1108
1109 //
1110 // Read extent's data into FileData.
1111 //
1112 Status = DiskIo->ReadDisk (
1113 DiskIo,
1114 BlockIo->Media->MediaId,
1115 Offset + MultU64x32 (Lsn, LogicalBlockSize),
1116 (UINTN) DataLength,
1117 (VOID *)((UINT8 *)ReadFileInfo->FileData +
1118 DataOffset)
1119 );
1120 if (EFI_ERROR (Status)) {
1121 goto Error_Read_Disk_Blk;
1122 }
1123
1124 //
1125 // Update current file's position.
1126 //
1127 DataOffset += DataLength;
1128 ReadFileInfo->FilePosition += DataLength;
1129
1130 BytesLeft -= DataLength;
1131 if (BytesLeft == 0) {
1132 //
1133 // There is no more file data to read.
1134 //
1135 Status = EFI_SUCCESS;
1136 goto Done;
1137 }
1138
1139 break;
1140 }
1141
1142 Skip_Ad:
1143 //
1144 // Point to the next AD (extent).
1145 //
1146 AdOffset += AD_LENGTH (RecordingFlags);
1147 }
1148
1149 break;
1150 case EXTENDED_ADS_SEQUENCE:
1151 // FIXME: Not supported. Got no volume with it, yet.
1152 ASSERT (FALSE);
1153 Status = EFI_UNSUPPORTED;
1154 break;
1155
1156 default:
1157 //
1158 // A flag value reserved by the ECMA-167 standard (3rd Edition - June
1159 // 1997); 14.6 ICB Tag; 14.6.8 Flags (RBP 18); was found.
1160 //
1161 Status = EFI_UNSUPPORTED;
1162 break;
1163 }
1164
1165 Done:
1166 if (DoFreeAed) {
1167 FreePool (Data);
1168 }
1169
1170 return Status;
1171
1172 Error_Read_Disk_Blk:
1173 Error_Alloc_Buffer_To_Next_Ad:
1174 if (ReadFileInfo->Flags != READ_FILE_SEEK_AND_READ) {
1175 FreePool (ReadFileInfo->FileData);
1176 }
1177
1178 if (DoFreeAed) {
1179 FreePool (Data);
1180 }
1181
1182 Error_Get_Aed:
1183 return Status;
1184 }
1185
1186 //
1187 // Find a file by its filename from a given Parent file.
1188 //
1189 EFI_STATUS
1190 InternalFindFile (
1191 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
1192 IN EFI_DISK_IO_PROTOCOL *DiskIo,
1193 IN UDF_VOLUME_INFO *Volume,
1194 IN CHAR16 *FileName,
1195 IN UDF_FILE_INFO *Parent,
1196 IN UDF_LONG_ALLOCATION_DESCRIPTOR *Icb,
1197 OUT UDF_FILE_INFO *File
1198 )
1199 {
1200 EFI_STATUS Status;
1201 UDF_FILE_IDENTIFIER_DESCRIPTOR *FileIdentifierDesc;
1202 UDF_READ_DIRECTORY_INFO ReadDirInfo;
1203 BOOLEAN Found;
1204 CHAR16 FoundFileName[UDF_FILENAME_LENGTH];
1205 VOID *CompareFileEntry;
1206
1207 //
1208 // Check if parent file is really directory.
1209 //
1210 if (!IS_FE_DIRECTORY (Parent->FileEntry)) {
1211 return EFI_NOT_FOUND;
1212 }
1213
1214 //
1215 // If FileName is current file or working directory, just duplicate Parent's
1216 // FE/EFE and FID descriptors.
1217 //
1218 if (StrCmp (FileName, L".") == 0) {
1219 DuplicateFe (BlockIo, Volume, Parent->FileEntry, &File->FileEntry);
1220 DuplicateFid (Parent->FileIdentifierDesc, &File->FileIdentifierDesc);
1221
1222 return EFI_SUCCESS;
1223 }
1224
1225 //
1226 // Start directory listing.
1227 //
1228 ZeroMem ((VOID *)&ReadDirInfo, sizeof (UDF_READ_DIRECTORY_INFO));
1229 Found = FALSE;
1230
1231 for (;;) {
1232 Status = ReadDirectoryEntry (
1233 BlockIo,
1234 DiskIo,
1235 Volume,
1236 Parent->FileIdentifierDesc ?
1237 &Parent->FileIdentifierDesc->Icb :
1238 Icb,
1239 Parent->FileEntry,
1240 &ReadDirInfo,
1241 &FileIdentifierDesc
1242 );
1243 if (EFI_ERROR (Status)) {
1244 if (Status == EFI_DEVICE_ERROR) {
1245 Status = EFI_NOT_FOUND;
1246 }
1247
1248 break;
1249 }
1250
1251 if (IS_FID_PARENT_FILE (FileIdentifierDesc)) {
1252 //
1253 // This FID contains the location (FE/EFE) of the parent directory of this
1254 // directory (Parent), and if FileName is either ".." or "\\", then it's
1255 // the expected FID.
1256 //
1257 if (StrCmp (FileName, L"..") == 0 || StrCmp (FileName, L"\\") == 0) {
1258 Found = TRUE;
1259 break;
1260 }
1261 } else {
1262 Status = GetFileNameFromFid (FileIdentifierDesc, FoundFileName);
1263 if (EFI_ERROR (Status)) {
1264 break;
1265 }
1266
1267 if (StrCmp (FileName, FoundFileName) == 0) {
1268 //
1269 // FID has been found. Prepare to find its respective FE/EFE.
1270 //
1271 Found = TRUE;
1272 break;
1273 }
1274 }
1275
1276 FreePool ((VOID *)FileIdentifierDesc);
1277 }
1278
1279 if (ReadDirInfo.DirectoryData != NULL) {
1280 //
1281 // Free all allocated resources for the directory listing.
1282 //
1283 FreePool (ReadDirInfo.DirectoryData);
1284 }
1285
1286 if (Found) {
1287 Status = EFI_SUCCESS;
1288
1289 File->FileIdentifierDesc = FileIdentifierDesc;
1290
1291 //
1292 // If the requested file is root directory, then the FE/EFE was already
1293 // retrieved in UdfOpenVolume() function, thus no need to find it again.
1294 //
1295 // Otherwise, find FE/EFE from the respective FID.
1296 //
1297 if (StrCmp (FileName, L"\\") != 0) {
1298 Status = FindFileEntry (
1299 BlockIo,
1300 DiskIo,
1301 Volume,
1302 &FileIdentifierDesc->Icb,
1303 &CompareFileEntry
1304 );
1305 if (EFI_ERROR (Status)) {
1306 goto Error_Find_Fe;
1307 }
1308
1309 //
1310 // Make sure that both Parent's FE/EFE and found FE/EFE are not equal.
1311 //
1312 if (CompareMem ((VOID *)Parent->FileEntry, (VOID *)CompareFileEntry,
1313 Volume->FileEntrySize) != 0) {
1314 File->FileEntry = CompareFileEntry;
1315 } else {
1316 FreePool ((VOID *)FileIdentifierDesc);
1317 FreePool ((VOID *)CompareFileEntry);
1318 Status = EFI_NOT_FOUND;
1319 }
1320 }
1321 }
1322
1323 return Status;
1324
1325 Error_Find_Fe:
1326 FreePool ((VOID *)FileIdentifierDesc);
1327
1328 return Status;
1329 }
1330
1331 /**
1332 Read volume information on a medium which contains a valid UDF file system.
1333
1334 @param[in] BlockIo BlockIo interface.
1335 @param[in] DiskIo DiskIo interface.
1336 @param[out] Volume UDF volume information structure.
1337
1338 @retval EFI_SUCCESS Volume information read.
1339 @retval EFI_NO_MEDIA The device has no media.
1340 @retval EFI_DEVICE_ERROR The device reported an error.
1341 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1342 @retval EFI_OUT_OF_RESOURCES The volume was not read due to lack of resources.
1343
1344 **/
1345 EFI_STATUS
1346 ReadUdfVolumeInformation (
1347 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
1348 IN EFI_DISK_IO_PROTOCOL *DiskIo,
1349 OUT UDF_VOLUME_INFO *Volume
1350 )
1351 {
1352 EFI_STATUS Status;
1353
1354 Status = ReadVolumeFileStructure (
1355 BlockIo,
1356 DiskIo,
1357 Volume
1358 );
1359 if (EFI_ERROR (Status)) {
1360 return Status;
1361 }
1362
1363 Status = GetFileSetDescriptors (
1364 BlockIo,
1365 DiskIo,
1366 Volume
1367 );
1368 if (EFI_ERROR (Status)) {
1369 CleanupVolumeInformation (Volume);
1370 }
1371
1372 return Status;
1373 }
1374
1375 /**
1376 Find the root directory on an UDF volume.
1377
1378 @param[in] BlockIo BlockIo interface.
1379 @param[in] DiskIo DiskIo interface.
1380 @param[in] Volume UDF volume information structure.
1381 @param[out] File Root directory file.
1382
1383 @retval EFI_SUCCESS Root directory found.
1384 @retval EFI_NO_MEDIA The device has no media.
1385 @retval EFI_DEVICE_ERROR The device reported an error.
1386 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1387 @retval EFI_OUT_OF_RESOURCES The root directory was not found due to lack of
1388 resources.
1389
1390 **/
1391 EFI_STATUS
1392 FindRootDirectory (
1393 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
1394 IN EFI_DISK_IO_PROTOCOL *DiskIo,
1395 IN UDF_VOLUME_INFO *Volume,
1396 OUT UDF_FILE_INFO *File
1397 )
1398 {
1399 EFI_STATUS Status;
1400 UDF_FILE_INFO Parent;
1401
1402 Status = FindFileEntry (
1403 BlockIo,
1404 DiskIo,
1405 Volume,
1406 &Volume->FileSetDescs[0]->RootDirectoryIcb,
1407 &File->FileEntry
1408 );
1409 if (EFI_ERROR (Status)) {
1410 return Status;
1411 }
1412
1413 Parent.FileEntry = File->FileEntry;
1414 Parent.FileIdentifierDesc = NULL;
1415
1416 Status = FindFile (
1417 BlockIo,
1418 DiskIo,
1419 Volume,
1420 L"\\",
1421 NULL,
1422 &Parent,
1423 &Volume->FileSetDescs[0]->RootDirectoryIcb,
1424 File
1425 );
1426 if (EFI_ERROR (Status)) {
1427 FreePool (File->FileEntry);
1428 }
1429
1430 return Status;
1431 }
1432
1433 /**
1434 Find either a File Entry or a Extended File Entry from a given ICB.
1435
1436 @param[in] BlockIo BlockIo interface.
1437 @param[in] DiskIo DiskIo interface.
1438 @param[in] Volume UDF volume information structure.
1439 @param[in] Icb ICB of the FID.
1440 @param[out] FileEntry File Entry or Extended File Entry.
1441
1442 @retval EFI_SUCCESS File Entry or Extended File Entry found.
1443 @retval EFI_NO_MEDIA The device has no media.
1444 @retval EFI_DEVICE_ERROR The device reported an error.
1445 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1446 @retval EFI_OUT_OF_RESOURCES The FE/EFE entry was not found due to lack of
1447 resources.
1448
1449 **/
1450 EFI_STATUS
1451 FindFileEntry (
1452 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
1453 IN EFI_DISK_IO_PROTOCOL *DiskIo,
1454 IN UDF_VOLUME_INFO *Volume,
1455 IN UDF_LONG_ALLOCATION_DESCRIPTOR *Icb,
1456 OUT VOID **FileEntry
1457 )
1458 {
1459 EFI_STATUS Status;
1460 UINT64 Lsn;
1461 UINT32 LogicalBlockSize;
1462
1463 Lsn = GetLongAdLsn (Volume, Icb);
1464 LogicalBlockSize = LV_BLOCK_SIZE (Volume, UDF_DEFAULT_LV_NUM);
1465
1466 *FileEntry = AllocateZeroPool (Volume->FileEntrySize);
1467 if (*FileEntry == NULL) {
1468 return EFI_OUT_OF_RESOURCES;
1469 }
1470
1471 //
1472 // Read extent.
1473 //
1474 Status = DiskIo->ReadDisk (
1475 DiskIo,
1476 BlockIo->Media->MediaId,
1477 MultU64x32 (Lsn, LogicalBlockSize),
1478 Volume->FileEntrySize,
1479 *FileEntry
1480 );
1481 if (EFI_ERROR (Status)) {
1482 goto Error_Read_Disk_Blk;
1483 }
1484
1485 //
1486 // Check if the read extent contains a valid Tag Identifier for the expected
1487 // FE/EFE.
1488 //
1489 if (!IS_FE (*FileEntry) && !IS_EFE (*FileEntry)) {
1490 Status = EFI_VOLUME_CORRUPTED;
1491 goto Error_Invalid_Fe;
1492 }
1493
1494 return EFI_SUCCESS;
1495
1496 Error_Invalid_Fe:
1497 Error_Read_Disk_Blk:
1498 FreePool (*FileEntry);
1499
1500 return Status;
1501 }
1502
1503 /**
1504 Find a file given its absolute path on an UDF volume.
1505
1506 @param[in] BlockIo BlockIo interface.
1507 @param[in] DiskIo DiskIo interface.
1508 @param[in] Volume UDF volume information structure.
1509 @param[in] FilePath File's absolute path.
1510 @param[in] Root Root directory file.
1511 @param[in] Parent Parent directory file.
1512 @param[out] File Found file.
1513
1514 @retval EFI_SUCCESS @p FilePath was found.
1515 @retval EFI_NO_MEDIA The device has no media.
1516 @retval EFI_DEVICE_ERROR The device reported an error.
1517 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1518 @retval EFI_OUT_OF_RESOURCES The @p FilePath file was not found due to lack of
1519 resources.
1520
1521 **/
1522 EFI_STATUS
1523 FindFile (
1524 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
1525 IN EFI_DISK_IO_PROTOCOL *DiskIo,
1526 IN UDF_VOLUME_INFO *Volume,
1527 IN CHAR16 *FilePath,
1528 IN UDF_FILE_INFO *Root,
1529 IN UDF_FILE_INFO *Parent,
1530 IN UDF_LONG_ALLOCATION_DESCRIPTOR *Icb,
1531 OUT UDF_FILE_INFO *File
1532 )
1533 {
1534 EFI_STATUS Status;
1535 CHAR16 FileName[UDF_FILENAME_LENGTH];
1536 CHAR16 *FileNamePointer;
1537 UDF_FILE_INFO PreviousFile;
1538 VOID *FileEntry;
1539
1540 Status = EFI_NOT_FOUND;
1541
1542 CopyMem ((VOID *)&PreviousFile, (VOID *)Parent, sizeof (UDF_FILE_INFO));
1543 while (*FilePath != L'\0') {
1544 FileNamePointer = FileName;
1545 while (*FilePath != L'\0' && *FilePath != L'\\') {
1546 *FileNamePointer++ = *FilePath++;
1547 }
1548
1549 *FileNamePointer = L'\0';
1550 if (FileName[0] == L'\0') {
1551 //
1552 // Open root directory.
1553 //
1554 if (Root == NULL) {
1555 //
1556 // There is no file found for the root directory yet. So, find only its
1557 // FID by now.
1558 //
1559 // See UdfOpenVolume() function.
1560 //
1561 Status = InternalFindFile (BlockIo,
1562 DiskIo,
1563 Volume,
1564 L"\\",
1565 &PreviousFile,
1566 Icb,
1567 File);
1568 } else {
1569 //
1570 // We've already a file pointer (Root) for the root directory. Duplicate
1571 // its FE/EFE and FID descriptors.
1572 //
1573 DuplicateFe (BlockIo, Volume, Root->FileEntry, &File->FileEntry);
1574 DuplicateFid (Root->FileIdentifierDesc, &File->FileIdentifierDesc);
1575 Status = EFI_SUCCESS;
1576 }
1577 } else {
1578 //
1579 // No root directory. Find filename from the current directory.
1580 //
1581 Status = InternalFindFile (BlockIo,
1582 DiskIo,
1583 Volume,
1584 FileName,
1585 &PreviousFile,
1586 Icb,
1587 File);
1588 }
1589
1590 if (EFI_ERROR (Status)) {
1591 return Status;
1592 }
1593
1594 //
1595 // If the found file is a symlink, then find its respective FE/EFE and
1596 // FID descriptors.
1597 //
1598 if (IS_FE_SYMLINK (File->FileEntry)) {
1599 FreePool ((VOID *)File->FileIdentifierDesc);
1600
1601 FileEntry = File->FileEntry;
1602
1603 Status = ResolveSymlink (BlockIo,
1604 DiskIo,
1605 Volume,
1606 &PreviousFile,
1607 FileEntry,
1608 File);
1609
1610 FreePool (FileEntry);
1611
1612 if (EFI_ERROR (Status)) {
1613 return Status;
1614 }
1615 }
1616
1617 if (CompareMem ((VOID *)&PreviousFile, (VOID *)Parent,
1618 sizeof (UDF_FILE_INFO)) != 0) {
1619 CleanupFileInformation (&PreviousFile);
1620 }
1621
1622 CopyMem ((VOID *)&PreviousFile, (VOID *)File, sizeof (UDF_FILE_INFO));
1623 if (*FilePath != L'\0' && *FilePath == L'\\') {
1624 FilePath++;
1625 }
1626 }
1627
1628 return Status;
1629 }
1630
1631 /**
1632 Read a directory entry at a time on an UDF volume.
1633
1634 @param[in] BlockIo BlockIo interface.
1635 @param[in] DiskIo DiskIo interface.
1636 @param[in] Volume UDF volume information structure.
1637 @param[in] ParentIcb ICB of the parent file.
1638 @param[in] FileEntryData FE/EFE of the parent file.
1639 @param[in out] ReadDirInfo Next read directory listing structure
1640 information.
1641 @param[out] FoundFid File Identifier Descriptor pointer.
1642
1643 @retval EFI_SUCCESS Directory entry read.
1644 @retval EFI_UNSUPPORTED Extended Allocation Descriptors not supported.
1645 @retval EFI_NO_MEDIA The device has no media.
1646 @retval EFI_DEVICE_ERROR The device reported an error.
1647 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1648 @retval EFI_OUT_OF_RESOURCES The directory entry was not read due to lack of
1649 resources.
1650
1651 **/
1652 EFI_STATUS
1653 ReadDirectoryEntry (
1654 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
1655 IN EFI_DISK_IO_PROTOCOL *DiskIo,
1656 IN UDF_VOLUME_INFO *Volume,
1657 IN UDF_LONG_ALLOCATION_DESCRIPTOR *ParentIcb,
1658 IN VOID *FileEntryData,
1659 IN OUT UDF_READ_DIRECTORY_INFO *ReadDirInfo,
1660 OUT UDF_FILE_IDENTIFIER_DESCRIPTOR **FoundFid
1661 )
1662 {
1663 EFI_STATUS Status;
1664 UDF_READ_FILE_INFO ReadFileInfo;
1665 UDF_FILE_IDENTIFIER_DESCRIPTOR *FileIdentifierDesc;
1666
1667 if (ReadDirInfo->DirectoryData == NULL) {
1668 //
1669 // The directory's recorded data has not been read yet. So let's cache it
1670 // into memory and the next calls won't need to read it again.
1671 //
1672 ReadFileInfo.Flags = READ_FILE_ALLOCATE_AND_READ;
1673
1674 Status = ReadFile (
1675 BlockIo,
1676 DiskIo,
1677 Volume,
1678 ParentIcb,
1679 FileEntryData,
1680 &ReadFileInfo
1681 );
1682 if (EFI_ERROR (Status)) {
1683 return Status;
1684 }
1685
1686 //
1687 // Fill in ReadDirInfo structure with the read directory's data information.
1688 //
1689 ReadDirInfo->DirectoryData = ReadFileInfo.FileData;
1690 ReadDirInfo->DirectoryLength = ReadFileInfo.ReadLength;
1691 }
1692
1693 do {
1694 if (ReadDirInfo->FidOffset >= ReadDirInfo->DirectoryLength) {
1695 //
1696 // There are no longer FIDs for this directory. By returning
1697 // EFI_DEVICE_ERROR to the callee will indicate end of directory
1698 // listening.
1699 //
1700 return EFI_DEVICE_ERROR;
1701 }
1702
1703 //
1704 // Get FID for this entry.
1705 //
1706 FileIdentifierDesc = GET_FID_FROM_ADS (ReadDirInfo->DirectoryData,
1707 ReadDirInfo->FidOffset);
1708 //
1709 // Update FidOffset to point to next FID.
1710 //
1711 ReadDirInfo->FidOffset += GetFidDescriptorLength (FileIdentifierDesc);
1712 } while (IS_FID_DELETED_FILE (FileIdentifierDesc));
1713
1714 DuplicateFid (FileIdentifierDesc, FoundFid);
1715
1716 return EFI_SUCCESS;
1717 }
1718
1719 /**
1720 Get a filename (encoded in OSTA-compressed format) from a File Identifier
1721 Descriptor on an UDF volume.
1722
1723 @param[in] FileIdentifierDesc File Identifier Descriptor pointer.
1724 @param[out] FileName Decoded filename.
1725
1726 @retval EFI_SUCCESS Filename decoded and read.
1727 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1728 **/
1729 EFI_STATUS
1730 GetFileNameFromFid (
1731 IN UDF_FILE_IDENTIFIER_DESCRIPTOR *FileIdentifierDesc,
1732 OUT CHAR16 *FileName
1733 )
1734 {
1735 UINT8 *OstaCompressed;
1736 UINT8 CompressionId;
1737 UINT8 Length;
1738 UINTN Index;
1739
1740 OstaCompressed =
1741 (UINT8 *)(
1742 (UINT8 *)FileIdentifierDesc->Data +
1743 FileIdentifierDesc->LengthOfImplementationUse
1744 );
1745
1746 CompressionId = OstaCompressed[0];
1747 if (!IS_VALID_COMPRESSION_ID (CompressionId)) {
1748 return EFI_VOLUME_CORRUPTED;
1749 }
1750
1751 //
1752 // Decode filename.
1753 //
1754 Length = FileIdentifierDesc->LengthOfFileIdentifier;
1755 for (Index = 1; Index < Length; Index++) {
1756 if (CompressionId == 16) {
1757 *FileName = OstaCompressed[Index++] << 8;
1758 } else {
1759 *FileName = 0;
1760 }
1761
1762 if (Index < Length) {
1763 *FileName |= OstaCompressed[Index];
1764 }
1765
1766 FileName++;
1767 }
1768
1769 *FileName = L'\0';
1770
1771 return EFI_SUCCESS;
1772 }
1773
1774 /**
1775 Resolve a symlink file on an UDF volume.
1776
1777 @param[in] BlockIo BlockIo interface.
1778 @param[in] DiskIo DiskIo interface.
1779 @param[in] Volume UDF volume information structure.
1780 @param[in] Parent Parent file.
1781 @param[in] FileEntryData FE/EFE structure pointer.
1782 @param[out] File Resolved file.
1783
1784 @retval EFI_SUCCESS Symlink file resolved.
1785 @retval EFI_UNSUPPORTED Extended Allocation Descriptors not supported.
1786 @retval EFI_NO_MEDIA The device has no media.
1787 @retval EFI_DEVICE_ERROR The device reported an error.
1788 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1789 @retval EFI_OUT_OF_RESOURCES The symlink file was not resolved due to lack of
1790 resources.
1791
1792 **/
1793 EFI_STATUS
1794 ResolveSymlink (
1795 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
1796 IN EFI_DISK_IO_PROTOCOL *DiskIo,
1797 IN UDF_VOLUME_INFO *Volume,
1798 IN UDF_FILE_INFO *Parent,
1799 IN VOID *FileEntryData,
1800 OUT UDF_FILE_INFO *File
1801 )
1802 {
1803 EFI_STATUS Status;
1804 UDF_READ_FILE_INFO ReadFileInfo;
1805 UINT8 *Data;
1806 UINT64 Length;
1807 UINT8 *EndData;
1808 UDF_PATH_COMPONENT *PathComp;
1809 UINT8 PathCompLength;
1810 CHAR16 FileName[UDF_FILENAME_LENGTH];
1811 CHAR16 *C;
1812 UINTN Index;
1813 UINT8 CompressionId;
1814 UDF_FILE_INFO PreviousFile;
1815
1816 //
1817 // Symlink files on UDF volumes do not contain so much data other than
1818 // Path Components which resolves to real filenames, so it's OK to read in
1819 // all its data here -- usually the data will be inline with the FE/EFE for
1820 // lower filenames.
1821 //
1822 ReadFileInfo.Flags = READ_FILE_ALLOCATE_AND_READ;
1823
1824 Status = ReadFile (
1825 BlockIo,
1826 DiskIo,
1827 Volume,
1828 &Parent->FileIdentifierDesc->Icb,
1829 FileEntryData,
1830 &ReadFileInfo
1831 );
1832 if (EFI_ERROR (Status)) {
1833 return Status;
1834 }
1835
1836 Length = ReadFileInfo.ReadLength;
1837
1838 Data = (UINT8 *)ReadFileInfo.FileData;
1839 EndData = Data + Length;
1840
1841 CopyMem ((VOID *)&PreviousFile, (VOID *)Parent, sizeof (UDF_FILE_INFO));
1842
1843 for (;;) {
1844 PathComp = (UDF_PATH_COMPONENT *)Data;
1845
1846 PathCompLength = PathComp->LengthOfComponentIdentifier;
1847
1848 switch (PathComp->ComponentType) {
1849 case 1:
1850 //
1851 // This Path Component specifies the root directory hierarchy subject to
1852 // agreement between the originator and recipient of the medium. Skip it.
1853 //
1854 // Fall through.
1855 //
1856 case 2:
1857 //
1858 // "\\." of the current directory. Read next Path Component.
1859 //
1860 goto Next_Path_Component;
1861 case 3:
1862 //
1863 // ".." (parent directory). Go to it.
1864 //
1865 CopyMem ((VOID *)FileName, L"..", 6);
1866 break;
1867 case 4:
1868 //
1869 // "." (current file). Duplicate both FE/EFE and FID of this file.
1870 //
1871 DuplicateFe (BlockIo, Volume, PreviousFile.FileEntry, &File->FileEntry);
1872 DuplicateFid (PreviousFile.FileIdentifierDesc,
1873 &File->FileIdentifierDesc);
1874 goto Next_Path_Component;
1875 case 5:
1876 //
1877 // This Path Component identifies an object, either a file or a
1878 // directory or an alias.
1879 //
1880 // Decode it from the compressed data in ComponentIdentifier and find
1881 // respective path.
1882 //
1883 CompressionId = PathComp->ComponentIdentifier[0];
1884 if (!IS_VALID_COMPRESSION_ID (CompressionId)) {
1885 return EFI_VOLUME_CORRUPTED;
1886 }
1887
1888 C = FileName;
1889 for (Index = 1; Index < PathCompLength; Index++) {
1890 if (CompressionId == 16) {
1891 *C = *(UINT8 *)((UINT8 *)PathComp->ComponentIdentifier +
1892 Index) << 8;
1893 Index++;
1894 } else {
1895 *C = 0;
1896 }
1897
1898 if (Index < Length) {
1899 *C |= *(UINT8 *)((UINT8 *)PathComp->ComponentIdentifier + Index);
1900 }
1901
1902 C++;
1903 }
1904
1905 *C = L'\0';
1906 break;
1907 }
1908
1909 //
1910 // Find file from the read filename in symlink's file data.
1911 //
1912 Status = InternalFindFile (
1913 BlockIo,
1914 DiskIo,
1915 Volume,
1916 FileName,
1917 &PreviousFile,
1918 NULL,
1919 File
1920 );
1921 if (EFI_ERROR (Status)) {
1922 goto Error_Find_File;
1923 }
1924
1925 Next_Path_Component:
1926 Data += sizeof (UDF_PATH_COMPONENT) + PathCompLength;
1927 if (Data >= EndData) {
1928 break;
1929 }
1930
1931 if (CompareMem ((VOID *)&PreviousFile, (VOID *)Parent,
1932 sizeof (UDF_FILE_INFO)) != 0) {
1933 CleanupFileInformation (&PreviousFile);
1934 }
1935
1936 CopyMem ((VOID *)&PreviousFile, (VOID *)File, sizeof (UDF_FILE_INFO));
1937 }
1938
1939 //
1940 // Unmap the symlink file.
1941 //
1942 FreePool (ReadFileInfo.FileData);
1943
1944 return EFI_SUCCESS;
1945
1946 Error_Find_File:
1947 if (CompareMem ((VOID *)&PreviousFile, (VOID *)Parent,
1948 sizeof (UDF_FILE_INFO)) != 0) {
1949 CleanupFileInformation (&PreviousFile);
1950 }
1951
1952 FreePool (ReadFileInfo.FileData);
1953
1954 return Status;
1955 }
1956
1957 /**
1958 Clean up in-memory UDF volume information.
1959
1960 @param[in] Volume Volume information pointer.
1961
1962 **/
1963 VOID
1964 CleanupVolumeInformation (
1965 IN UDF_VOLUME_INFO *Volume
1966 )
1967 {
1968 UINTN Index;
1969
1970 if (Volume->LogicalVolDescs != NULL) {
1971 for (Index = 0; Index < Volume->LogicalVolDescsNo; Index++) {
1972 FreePool ((VOID *)Volume->LogicalVolDescs[Index]);
1973 }
1974 FreePool ((VOID *)Volume->LogicalVolDescs);
1975 }
1976
1977 if (Volume->PartitionDescs != NULL) {
1978 for (Index = 0; Index < Volume->PartitionDescsNo; Index++) {
1979 FreePool ((VOID *)Volume->PartitionDescs[Index]);
1980 }
1981 FreePool ((VOID *)Volume->PartitionDescs);
1982 }
1983
1984 if (Volume->FileSetDescs != NULL) {
1985 for (Index = 0; Index < Volume->FileSetDescsNo; Index++) {
1986 FreePool ((VOID *)Volume->FileSetDescs[Index]);
1987 }
1988 FreePool ((VOID *)Volume->FileSetDescs);
1989 }
1990
1991 ZeroMem ((VOID *)Volume, sizeof (UDF_VOLUME_INFO));
1992 }
1993
1994 /**
1995 Clean up in-memory UDF file information.
1996
1997 @param[in] File File information pointer.
1998
1999 **/
2000 VOID
2001 CleanupFileInformation (
2002 IN UDF_FILE_INFO *File
2003 )
2004 {
2005 if (File->FileEntry != NULL) {
2006 FreePool (File->FileEntry);
2007 }
2008 if (File->FileIdentifierDesc != NULL) {
2009 FreePool ((VOID *)File->FileIdentifierDesc);
2010 }
2011
2012 ZeroMem ((VOID *)File, sizeof (UDF_FILE_INFO));
2013 }
2014
2015 /**
2016 Find a file from its absolute path on an UDF volume.
2017
2018 @param[in] BlockIo BlockIo interface.
2019 @param[in] DiskIo DiskIo interface.
2020 @param[in] Volume UDF volume information structure.
2021 @param[in] File File information structure.
2022 @param[out] Size Size of the file.
2023
2024 @retval EFI_SUCCESS File size calculated and set in @p Size.
2025 @retval EFI_UNSUPPORTED Extended Allocation Descriptors not supported.
2026 @retval EFI_NO_MEDIA The device has no media.
2027 @retval EFI_DEVICE_ERROR The device reported an error.
2028 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
2029 @retval EFI_OUT_OF_RESOURCES The file size was not calculated due to lack of
2030 resources.
2031
2032 **/
2033 EFI_STATUS
2034 GetFileSize (
2035 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
2036 IN EFI_DISK_IO_PROTOCOL *DiskIo,
2037 IN UDF_VOLUME_INFO *Volume,
2038 IN UDF_FILE_INFO *File,
2039 OUT UINT64 *Size
2040 )
2041 {
2042 EFI_STATUS Status;
2043 UDF_READ_FILE_INFO ReadFileInfo;
2044
2045 ReadFileInfo.Flags = READ_FILE_GET_FILESIZE;
2046
2047 Status = ReadFile (
2048 BlockIo,
2049 DiskIo,
2050 Volume,
2051 &File->FileIdentifierDesc->Icb,
2052 File->FileEntry,
2053 &ReadFileInfo
2054 );
2055 if (EFI_ERROR (Status)) {
2056 return Status;
2057 }
2058
2059 *Size = ReadFileInfo.ReadLength;
2060
2061 return EFI_SUCCESS;
2062 }
2063
2064 /**
2065 Set information about a file on an UDF volume.
2066
2067 @param[in] File File pointer.
2068 @param[in] FileSize Size of the file.
2069 @param[in] FileName Filename of the file.
2070 @param[in out] BufferSize Size of the returned file infomation.
2071 @param[out] Buffer Data of the returned file information.
2072
2073 @retval EFI_SUCCESS File information set.
2074 @retval EFI_NO_MEDIA The device has no media.
2075 @retval EFI_DEVICE_ERROR The device reported an error.
2076 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
2077 @retval EFI_OUT_OF_RESOURCES The file information was not set due to lack of
2078 resources.
2079
2080 **/
2081 EFI_STATUS
2082 SetFileInfo (
2083 IN UDF_FILE_INFO *File,
2084 IN UINT64 FileSize,
2085 IN CHAR16 *FileName,
2086 IN OUT UINTN *BufferSize,
2087 OUT VOID *Buffer
2088 )
2089 {
2090 UINTN FileInfoLength;
2091 EFI_FILE_INFO *FileInfo;
2092 UDF_FILE_ENTRY *FileEntry;
2093 UDF_EXTENDED_FILE_ENTRY *ExtendedFileEntry;
2094
2095 //
2096 // Calculate the needed size for the EFI_FILE_INFO structure.
2097 //
2098 FileInfoLength = sizeof (EFI_FILE_INFO) + (FileName ?
2099 StrSize (FileName) :
2100 sizeof (CHAR16));
2101 if (*BufferSize < FileInfoLength) {
2102 //
2103 // The given Buffer has no size enough for EFI_FILE_INFO structure.
2104 //
2105 *BufferSize = FileInfoLength;
2106 return EFI_BUFFER_TOO_SMALL;
2107 }
2108
2109 //
2110 // Buffer now contains room enough to store EFI_FILE_INFO structure.
2111 // Now, fill it in with all necessary information about the file.
2112 //
2113 FileInfo = (EFI_FILE_INFO *)Buffer;
2114 FileInfo->Size = FileInfoLength;
2115 FileInfo->Attribute &= ~EFI_FILE_VALID_ATTR;
2116 FileInfo->Attribute |= EFI_FILE_READ_ONLY;
2117
2118 if (IS_FID_DIRECTORY_FILE (File->FileIdentifierDesc)) {
2119 FileInfo->Attribute |= EFI_FILE_DIRECTORY;
2120 } else if (IS_FID_NORMAL_FILE (File->FileIdentifierDesc)) {
2121 FileInfo->Attribute |= EFI_FILE_ARCHIVE;
2122 }
2123
2124 if (IS_FID_HIDDEN_FILE (File->FileIdentifierDesc)) {
2125 FileInfo->Attribute |= EFI_FILE_HIDDEN;
2126 }
2127
2128 if (IS_FE (File->FileEntry)) {
2129 FileEntry = (UDF_FILE_ENTRY *)File->FileEntry;
2130
2131 //
2132 // Check if FE has the system attribute set.
2133 //
2134 if (FileEntry->IcbTag.Flags & (1 << 10)) {
2135 FileInfo->Attribute |= EFI_FILE_SYSTEM;
2136 }
2137
2138 FileInfo->FileSize = FileSize;
2139 FileInfo->PhysicalSize = FileSize;
2140
2141 FileInfo->CreateTime.Year = FileEntry->AccessTime.Year;
2142 FileInfo->CreateTime.Month = FileEntry->AccessTime.Month;
2143 FileInfo->CreateTime.Day = FileEntry->AccessTime.Day;
2144 FileInfo->CreateTime.Hour = FileEntry->AccessTime.Hour;
2145 FileInfo->CreateTime.Minute = FileEntry->AccessTime.Second;
2146 FileInfo->CreateTime.Second = FileEntry->AccessTime.Second;
2147 FileInfo->CreateTime.Nanosecond =
2148 FileEntry->AccessTime.HundredsOfMicroseconds;
2149
2150 FileInfo->LastAccessTime.Year =
2151 FileEntry->AccessTime.Year;
2152 FileInfo->LastAccessTime.Month =
2153 FileEntry->AccessTime.Month;
2154 FileInfo->LastAccessTime.Day =
2155 FileEntry->AccessTime.Day;
2156 FileInfo->LastAccessTime.Hour =
2157 FileEntry->AccessTime.Hour;
2158 FileInfo->LastAccessTime.Minute =
2159 FileEntry->AccessTime.Minute;
2160 FileInfo->LastAccessTime.Second =
2161 FileEntry->AccessTime.Second;
2162 FileInfo->LastAccessTime.Nanosecond =
2163 FileEntry->AccessTime.HundredsOfMicroseconds;
2164 } else if (IS_EFE (File->FileEntry)) {
2165 ExtendedFileEntry = (UDF_EXTENDED_FILE_ENTRY *)File->FileEntry;
2166
2167 //
2168 // Check if EFE has the system attribute set.
2169 //
2170 if (ExtendedFileEntry->IcbTag.Flags & (1 << 10)) {
2171 FileInfo->Attribute |= EFI_FILE_SYSTEM;
2172 }
2173
2174 FileInfo->FileSize = FileSize;
2175 FileInfo->PhysicalSize = FileSize;
2176
2177 FileInfo->CreateTime.Year = ExtendedFileEntry->CreationTime.Year;
2178 FileInfo->CreateTime.Month = ExtendedFileEntry->CreationTime.Month;
2179 FileInfo->CreateTime.Day = ExtendedFileEntry->CreationTime.Day;
2180 FileInfo->CreateTime.Hour = ExtendedFileEntry->CreationTime.Hour;
2181 FileInfo->CreateTime.Minute = ExtendedFileEntry->CreationTime.Second;
2182 FileInfo->CreateTime.Second = ExtendedFileEntry->CreationTime.Second;
2183 FileInfo->CreateTime.Nanosecond =
2184 ExtendedFileEntry->AccessTime.HundredsOfMicroseconds;
2185
2186 FileInfo->LastAccessTime.Year =
2187 ExtendedFileEntry->AccessTime.Year;
2188 FileInfo->LastAccessTime.Month =
2189 ExtendedFileEntry->AccessTime.Month;
2190 FileInfo->LastAccessTime.Day =
2191 ExtendedFileEntry->AccessTime.Day;
2192 FileInfo->LastAccessTime.Hour =
2193 ExtendedFileEntry->AccessTime.Hour;
2194 FileInfo->LastAccessTime.Minute =
2195 ExtendedFileEntry->AccessTime.Minute;
2196 FileInfo->LastAccessTime.Second =
2197 ExtendedFileEntry->AccessTime.Second;
2198 FileInfo->LastAccessTime.Nanosecond =
2199 ExtendedFileEntry->AccessTime.HundredsOfMicroseconds;
2200 }
2201
2202 FileInfo->CreateTime.TimeZone = EFI_UNSPECIFIED_TIMEZONE;
2203 FileInfo->CreateTime.Daylight = EFI_TIME_ADJUST_DAYLIGHT;
2204 FileInfo->LastAccessTime.TimeZone = EFI_UNSPECIFIED_TIMEZONE;
2205 FileInfo->LastAccessTime.Daylight = EFI_TIME_ADJUST_DAYLIGHT;
2206
2207 CopyMem ((VOID *)&FileInfo->ModificationTime,
2208 (VOID *)&FileInfo->LastAccessTime,
2209 sizeof (EFI_TIME));
2210
2211 if (FileName != NULL) {
2212 StrCpyS (FileInfo->FileName, StrLen (FileName) + 1, FileName);
2213 } else {
2214 FileInfo->FileName[0] = '\0';
2215 }
2216
2217 *BufferSize = FileInfoLength;
2218
2219 return EFI_SUCCESS;
2220 }
2221
2222 /**
2223 Get volume and free space size information of an UDF volume.
2224
2225 @param[in] BlockIo BlockIo interface.
2226 @param[in] DiskIo DiskIo interface.
2227 @param[in] Volume UDF volume information structure.
2228 @param[out] VolumeSize Volume size.
2229 @param[out] FreeSpaceSize Free space size.
2230
2231 @retval EFI_SUCCESS Volume and free space size calculated.
2232 @retval EFI_NO_MEDIA The device has no media.
2233 @retval EFI_DEVICE_ERROR The device reported an error.
2234 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
2235 @retval EFI_OUT_OF_RESOURCES The volume and free space size were not
2236 calculated due to lack of resources.
2237
2238 **/
2239 EFI_STATUS
2240 GetVolumeSize (
2241 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
2242 IN EFI_DISK_IO_PROTOCOL *DiskIo,
2243 IN UDF_VOLUME_INFO *Volume,
2244 OUT UINT64 *VolumeSize,
2245 OUT UINT64 *FreeSpaceSize
2246 )
2247 {
2248 UDF_EXTENT_AD ExtentAd;
2249 UINT32 LogicalBlockSize;
2250 UINT64 Lsn;
2251 EFI_STATUS Status;
2252 UDF_LOGICAL_VOLUME_INTEGRITY *LogicalVolInt;
2253 UINTN Index;
2254 UINTN Length;
2255 UINT32 LsnsNo;
2256
2257 *VolumeSize = 0;
2258 *FreeSpaceSize = 0;
2259
2260 for (Index = 0; Index < Volume->LogicalVolDescsNo; Index++) {
2261 CopyMem ((VOID *)&ExtentAd,
2262 (VOID *)&Volume->LogicalVolDescs[Index]->IntegritySequenceExtent,
2263 sizeof (UDF_EXTENT_AD));
2264 if (ExtentAd.ExtentLength == 0) {
2265 continue;
2266 }
2267
2268 LogicalBlockSize = LV_BLOCK_SIZE (Volume, Index);
2269
2270 Read_Next_Sequence:
2271 LogicalVolInt = (UDF_LOGICAL_VOLUME_INTEGRITY *)
2272 AllocatePool (ExtentAd.ExtentLength);
2273 if (LogicalVolInt == NULL) {
2274 return EFI_OUT_OF_RESOURCES;
2275 }
2276
2277 Lsn = (UINT64)ExtentAd.ExtentLocation;
2278
2279 Status = DiskIo->ReadDisk (
2280 DiskIo,
2281 BlockIo->Media->MediaId,
2282 MultU64x32 (Lsn, LogicalBlockSize),
2283 ExtentAd.ExtentLength,
2284 (VOID *)LogicalVolInt
2285 );
2286 if (EFI_ERROR (Status)) {
2287 FreePool ((VOID *)LogicalVolInt);
2288 return Status;
2289 }
2290
2291 if (!IS_LVID (LogicalVolInt)) {
2292 FreePool ((VOID *)LogicalVolInt);
2293 return EFI_VOLUME_CORRUPTED;
2294 }
2295
2296 Length = LogicalVolInt->NumberOfPartitions;
2297 for (Index = 0; Index < Length; Index += sizeof (UINT32)) {
2298 LsnsNo = *(UINT32 *)((UINT8 *)LogicalVolInt->Data + Index);
2299 if (LsnsNo == 0xFFFFFFFFUL) {
2300 //
2301 // Size not specified.
2302 //
2303 continue;
2304 }
2305
2306 *FreeSpaceSize += MultU64x32 ((UINT64)LsnsNo, LogicalBlockSize);
2307 }
2308
2309 Length = (LogicalVolInt->NumberOfPartitions * sizeof (UINT32)) << 1;
2310 for (; Index < Length; Index += sizeof (UINT32)) {
2311 LsnsNo = *(UINT32 *)((UINT8 *)LogicalVolInt->Data + Index);
2312 if (LsnsNo == 0xFFFFFFFFUL) {
2313 //
2314 // Size not specified.
2315 //
2316 continue;
2317 }
2318
2319 *VolumeSize += MultU64x32 ((UINT64)LsnsNo, LogicalBlockSize);
2320 }
2321
2322 CopyMem ((VOID *)&ExtentAd,(VOID *)&LogicalVolInt->NextIntegrityExtent,
2323 sizeof (UDF_EXTENT_AD));
2324 if (ExtentAd.ExtentLength > 0) {
2325 FreePool ((VOID *)LogicalVolInt);
2326 goto Read_Next_Sequence;
2327 }
2328
2329 FreePool ((VOID *)LogicalVolInt);
2330 }
2331
2332 return EFI_SUCCESS;
2333 }
2334
2335 /**
2336 Seek a file and read its data into memory on an UDF volume.
2337
2338 @param[in] BlockIo BlockIo interface.
2339 @param[in] DiskIo DiskIo interface.
2340 @param[in] Volume UDF volume information structure.
2341 @param[in] File File information structure.
2342 @param[in] FileSize Size of the file.
2343 @param[in out] FilePosition File position.
2344 @param[in out] Buffer File data.
2345 @param[in out] BufferSize Read size.
2346
2347 @retval EFI_SUCCESS File seeked and read.
2348 @retval EFI_UNSUPPORTED Extended Allocation Descriptors not supported.
2349 @retval EFI_NO_MEDIA The device has no media.
2350 @retval EFI_DEVICE_ERROR The device reported an error.
2351 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
2352 @retval EFI_OUT_OF_RESOURCES The file's recorded data was not read due to lack
2353 of resources.
2354
2355 **/
2356 EFI_STATUS
2357 ReadFileData (
2358 IN EFI_BLOCK_IO_PROTOCOL *BlockIo,
2359 IN EFI_DISK_IO_PROTOCOL *DiskIo,
2360 IN UDF_VOLUME_INFO *Volume,
2361 IN UDF_FILE_INFO *File,
2362 IN UINT64 FileSize,
2363 IN OUT UINT64 *FilePosition,
2364 IN OUT VOID *Buffer,
2365 IN OUT UINT64 *BufferSize
2366 )
2367 {
2368 EFI_STATUS Status;
2369 UDF_READ_FILE_INFO ReadFileInfo;
2370
2371 ReadFileInfo.Flags = READ_FILE_SEEK_AND_READ;
2372 ReadFileInfo.FilePosition = *FilePosition;
2373 ReadFileInfo.FileData = Buffer;
2374 ReadFileInfo.FileDataSize = *BufferSize;
2375 ReadFileInfo.FileSize = FileSize;
2376
2377 Status = ReadFile (
2378 BlockIo,
2379 DiskIo,
2380 Volume,
2381 &File->FileIdentifierDesc->Icb,
2382 File->FileEntry,
2383 &ReadFileInfo
2384 );
2385 if (EFI_ERROR (Status)) {
2386 return Status;
2387 }
2388
2389 *BufferSize = ReadFileInfo.FileDataSize;
2390 *FilePosition = ReadFileInfo.FilePosition;
2391
2392 return EFI_SUCCESS;
2393 }
2394
2395 /**
2396 Check if ControllerHandle supports an UDF file system.
2397
2398 @param[in] This Protocol instance pointer.
2399 @param[in] ControllerHandle Handle of device to test.
2400
2401 @retval EFI_SUCCESS UDF file system found.
2402 @retval EFI_UNSUPPORTED UDF file system not found.
2403
2404 **/
2405 EFI_STATUS
2406 SupportUdfFileSystem (
2407 IN EFI_DRIVER_BINDING_PROTOCOL *This,
2408 IN EFI_HANDLE ControllerHandle
2409 )
2410 {
2411 EFI_STATUS Status;
2412 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
2413 EFI_DEVICE_PATH_PROTOCOL *DevicePathNode;
2414 EFI_DEVICE_PATH_PROTOCOL *LastDevicePathNode;
2415 EFI_GUID *VendorDefinedGuid;
2416 EFI_GUID UdfDevPathGuid = EFI_UDF_DEVICE_PATH_GUID;
2417
2418 //
2419 // Open Device Path protocol on ControllerHandle
2420 //
2421 Status = gBS->OpenProtocol (
2422 ControllerHandle,
2423 &gEfiDevicePathProtocolGuid,
2424 (VOID **)&DevicePath,
2425 This->DriverBindingHandle,
2426 ControllerHandle,
2427 EFI_OPEN_PROTOCOL_GET_PROTOCOL
2428 );
2429 if (EFI_ERROR (Status)) {
2430 return EFI_UNSUPPORTED;
2431 }
2432
2433 Status = EFI_UNSUPPORTED;
2434
2435 //
2436 // Get last Device Path node
2437 //
2438 LastDevicePathNode = NULL;
2439 DevicePathNode = DevicePath;
2440 while (!IsDevicePathEnd (DevicePathNode)) {
2441 LastDevicePathNode = DevicePathNode;
2442 DevicePathNode = NextDevicePathNode (DevicePathNode);
2443 }
2444 //
2445 // Check if last Device Path node contains a Vendor-Defined Media Device Path
2446 // of an UDF file system.
2447 //
2448 if (LastDevicePathNode != NULL &&
2449 DevicePathType (LastDevicePathNode) == MEDIA_DEVICE_PATH &&
2450 DevicePathSubType (LastDevicePathNode) == MEDIA_VENDOR_DP) {
2451 VendorDefinedGuid = (EFI_GUID *)((UINTN)LastDevicePathNode +
2452 OFFSET_OF (VENDOR_DEVICE_PATH, Guid));
2453 if (CompareGuid (VendorDefinedGuid, &UdfDevPathGuid)) {
2454 Status = EFI_SUCCESS;
2455 }
2456 }
2457
2458 //
2459 // Close Device Path protocol on ControllerHandle
2460 //
2461 gBS->CloseProtocol (
2462 ControllerHandle,
2463 &gEfiDevicePathProtocolGuid,
2464 This->DriverBindingHandle,
2465 ControllerHandle
2466 );
2467
2468 return Status;
2469 }