VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteApi.c@ 99454

Last change on this file since 99454 was 99404, checked in by vboxsync, 22 months ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 21.6 KB
Line 
1/** @file
2 FAT recovery PEIM entry point, Ppi Functions and FAT Api functions.
3
4Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>
5
6SPDX-License-Identifier: BSD-2-Clause-Patent
7
8**/
9
10#include "FatLitePeim.h"
11
12PEI_FAT_PRIVATE_DATA *mPrivateData = NULL;
13
14/**
15 BlockIo installation notification function. Find out all the current BlockIO
16 PPIs in the system and add them into private data. Assume there is
17
18 @param PeiServices General purpose services available to every
19 PEIM.
20 @param NotifyDescriptor The typedef structure of the notification
21 descriptor. Not used in this function.
22 @param Ppi The typedef structure of the PPI descriptor.
23 Not used in this function.
24
25 @retval EFI_SUCCESS The function completed successfully.
26
27**/
28EFI_STATUS
29EFIAPI
30BlockIoNotifyEntry (
31 IN EFI_PEI_SERVICES **PeiServices,
32 IN EFI_PEI_NOTIFY_DESCRIPTOR *NotifyDescriptor,
33 IN VOID *Ppi
34 );
35
36/**
37 Discover all the block I/O devices to find the FAT volume.
38
39 @param PrivateData Global memory map for accessing global
40 variables.
41 @param BlockIo2 Boolean to show whether using BlockIo2 or BlockIo
42
43 @retval EFI_SUCCESS The function completed successfully.
44
45**/
46EFI_STATUS
47UpdateBlocksAndVolumes (
48 IN OUT PEI_FAT_PRIVATE_DATA *PrivateData,
49 IN BOOLEAN BlockIo2
50 )
51{
52 EFI_STATUS Status;
53 EFI_PEI_PPI_DESCRIPTOR *TempPpiDescriptor;
54 UINTN BlockIoPpiInstance;
55 EFI_PEI_RECOVERY_BLOCK_IO_PPI *BlockIoPpi;
56 EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2Ppi;
57 UINTN NumberBlockDevices;
58 UINTN Index;
59 EFI_PEI_BLOCK_IO_MEDIA Media;
60 EFI_PEI_BLOCK_IO2_MEDIA Media2;
61 PEI_FAT_VOLUME Volume;
62 EFI_PEI_SERVICES **PeiServices;
63
64 PeiServices = (EFI_PEI_SERVICES **)GetPeiServicesTablePointer ();
65 BlockIo2Ppi = NULL;
66 BlockIoPpi = NULL;
67 //
68 // Clean up caches
69 //
70 for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {
71 PrivateData->CacheBuffer[Index].Valid = FALSE;
72 }
73
74 PrivateData->BlockDeviceCount = 0;
75
76 //
77 // Find out all Block Io Ppi instances within the system
78 // Assuming all device Block Io Peims are dispatched already
79 //
80 for (BlockIoPpiInstance = 0; BlockIoPpiInstance < PEI_FAT_MAX_BLOCK_IO_PPI; BlockIoPpiInstance++) {
81 if (BlockIo2) {
82 Status = PeiServicesLocatePpi (
83 &gEfiPeiVirtualBlockIo2PpiGuid,
84 BlockIoPpiInstance,
85 &TempPpiDescriptor,
86 (VOID **)&BlockIo2Ppi
87 );
88 } else {
89 Status = PeiServicesLocatePpi (
90 &gEfiPeiVirtualBlockIoPpiGuid,
91 BlockIoPpiInstance,
92 &TempPpiDescriptor,
93 (VOID **)&BlockIoPpi
94 );
95 }
96
97 if (EFI_ERROR (Status)) {
98 //
99 // Done with all Block Io Ppis
100 //
101 break;
102 }
103
104 if (BlockIo2) {
105 Status = BlockIo2Ppi->GetNumberOfBlockDevices (
106 PeiServices,
107 BlockIo2Ppi,
108 &NumberBlockDevices
109 );
110 } else {
111 Status = BlockIoPpi->GetNumberOfBlockDevices (
112 PeiServices,
113 BlockIoPpi,
114 &NumberBlockDevices
115 );
116 }
117
118 if (EFI_ERROR (Status)) {
119 continue;
120 }
121
122 for (Index = 1; Index <= NumberBlockDevices && PrivateData->BlockDeviceCount < PEI_FAT_MAX_BLOCK_DEVICE; Index++) {
123 if (BlockIo2) {
124 Status = BlockIo2Ppi->GetBlockDeviceMediaInfo (
125 PeiServices,
126 BlockIo2Ppi,
127 Index,
128 &Media2
129 );
130 if (EFI_ERROR (Status) || !Media2.MediaPresent) {
131 continue;
132 }
133
134 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockIo2 = BlockIo2Ppi;
135 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].InterfaceType = Media2.InterfaceType;
136 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].LastBlock = Media2.LastBlock;
137 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockSize = Media2.BlockSize;
138 } else {
139 Status = BlockIoPpi->GetBlockDeviceMediaInfo (
140 PeiServices,
141 BlockIoPpi,
142 Index,
143 &Media
144 );
145 if (EFI_ERROR (Status) || !Media.MediaPresent) {
146 continue;
147 }
148
149 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockIo = BlockIoPpi;
150 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].DevType = Media.DeviceType;
151 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].LastBlock = Media.LastBlock;
152 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockSize = (UINT32)Media.BlockSize;
153 }
154
155 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].IoAlign = 0;
156 //
157 // Not used here
158 //
159 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].Logical = FALSE;
160 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].PartitionChecked = FALSE;
161
162 PrivateData->BlockDevice[PrivateData->BlockDeviceCount].PhysicalDevNo = (UINT8)Index;
163 PrivateData->BlockDeviceCount++;
164 }
165 }
166
167 //
168 // Find out all logical devices
169 //
170 FatFindPartitions (PrivateData);
171
172 //
173 // Build up file system volume array
174 //
175 PrivateData->VolumeCount = 0;
176 for (Index = 0; Index < PrivateData->BlockDeviceCount; Index++) {
177 Volume.BlockDeviceNo = Index;
178 Status = FatGetBpbInfo (PrivateData, &Volume);
179 if (Status == EFI_SUCCESS) {
180 //
181 // Add the detected volume to the volume array
182 //
183 CopyMem (
184 (UINT8 *)&(PrivateData->Volume[PrivateData->VolumeCount]),
185 (UINT8 *)&Volume,
186 sizeof (PEI_FAT_VOLUME)
187 );
188 PrivateData->VolumeCount += 1;
189 if (PrivateData->VolumeCount >= PEI_FAT_MAX_VOLUME) {
190 break;
191 }
192 }
193 }
194
195 return EFI_SUCCESS;
196}
197
198/**
199 BlockIo installation notification function. Find out all the current BlockIO
200 PPIs in the system and add them into private data. Assume there is
201
202 @param PeiServices General purpose services available to every
203 PEIM.
204 @param NotifyDescriptor The typedef structure of the notification
205 descriptor. Not used in this function.
206 @param Ppi The typedef structure of the PPI descriptor.
207 Not used in this function.
208
209 @retval EFI_SUCCESS The function completed successfully.
210
211**/
212EFI_STATUS
213EFIAPI
214BlockIoNotifyEntry (
215 IN EFI_PEI_SERVICES **PeiServices,
216 IN EFI_PEI_NOTIFY_DESCRIPTOR *NotifyDescriptor,
217 IN VOID *Ppi
218 )
219{
220 if (CompareGuid (NotifyDescriptor->Guid, &gEfiPeiVirtualBlockIo2PpiGuid)) {
221 UpdateBlocksAndVolumes (mPrivateData, TRUE);
222 } else {
223 UpdateBlocksAndVolumes (mPrivateData, FALSE);
224 }
225
226 return EFI_SUCCESS;
227}
228
229/**
230 Installs the Device Recovery Module PPI, Initialize BlockIo Ppi
231 installation notification
232
233 @param FileHandle Handle of the file being invoked. Type
234 EFI_PEI_FILE_HANDLE is defined in
235 FfsFindNextFile().
236 @param PeiServices Describes the list of possible PEI Services.
237
238 @retval EFI_SUCCESS The entry point was executed successfully.
239 @retval EFI_OUT_OF_RESOURCES There is no enough memory to complete the
240 operations.
241
242**/
243EFI_STATUS
244EFIAPI
245FatPeimEntry (
246 IN EFI_PEI_FILE_HANDLE FileHandle,
247 IN CONST EFI_PEI_SERVICES **PeiServices
248 )
249{
250 EFI_STATUS Status;
251 EFI_PHYSICAL_ADDRESS Address;
252 PEI_FAT_PRIVATE_DATA *PrivateData;
253
254 Status = PeiServicesRegisterForShadow (FileHandle);
255 if (!EFI_ERROR (Status)) {
256 return Status;
257 }
258
259 Status = PeiServicesAllocatePages (
260 EfiBootServicesCode,
261 (sizeof (PEI_FAT_PRIVATE_DATA) - 1) / PEI_FAT_MEMORY_PAGE_SIZE + 1,
262 &Address
263 );
264 if (EFI_ERROR (Status)) {
265 return EFI_OUT_OF_RESOURCES;
266 }
267
268 PrivateData = (PEI_FAT_PRIVATE_DATA *)(UINTN)Address;
269
270 //
271 // Initialize Private Data (to zero, as is required by subsequent operations)
272 //
273 ZeroMem ((UINT8 *)PrivateData, sizeof (PEI_FAT_PRIVATE_DATA));
274
275 PrivateData->Signature = PEI_FAT_PRIVATE_DATA_SIGNATURE;
276
277 //
278 // Installs Ppi
279 //
280 PrivateData->DeviceRecoveryPpi.GetNumberRecoveryCapsules = GetNumberRecoveryCapsules;
281 PrivateData->DeviceRecoveryPpi.GetRecoveryCapsuleInfo = GetRecoveryCapsuleInfo;
282 PrivateData->DeviceRecoveryPpi.LoadRecoveryCapsule = LoadRecoveryCapsule;
283
284 PrivateData->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST);
285 PrivateData->PpiDescriptor.Guid = &gEfiPeiDeviceRecoveryModulePpiGuid;
286 PrivateData->PpiDescriptor.Ppi = &PrivateData->DeviceRecoveryPpi;
287
288 Status = PeiServicesInstallPpi (&PrivateData->PpiDescriptor);
289 if (EFI_ERROR (Status)) {
290 return EFI_OUT_OF_RESOURCES;
291 }
292
293 //
294 // Other initializations
295 //
296 PrivateData->BlockDeviceCount = 0;
297
298 UpdateBlocksAndVolumes (PrivateData, TRUE);
299 UpdateBlocksAndVolumes (PrivateData, FALSE);
300
301 //
302 // PrivateData is allocated now, set it to the module variable
303 //
304 mPrivateData = PrivateData;
305
306 //
307 // Installs Block Io Ppi notification function
308 //
309 PrivateData->NotifyDescriptor[0].Flags =
310 (
311 EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK
312 );
313 PrivateData->NotifyDescriptor[0].Guid = &gEfiPeiVirtualBlockIoPpiGuid;
314 PrivateData->NotifyDescriptor[0].Notify = BlockIoNotifyEntry;
315 PrivateData->NotifyDescriptor[1].Flags =
316 (
317 EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK |
318 EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
319 );
320 PrivateData->NotifyDescriptor[1].Guid = &gEfiPeiVirtualBlockIo2PpiGuid;
321 PrivateData->NotifyDescriptor[1].Notify = BlockIoNotifyEntry;
322 return PeiServicesNotifyPpi (&PrivateData->NotifyDescriptor[0]);
323}
324
325/**
326 Returns the number of DXE capsules residing on the device.
327
328 This function searches for DXE capsules from the associated device and returns
329 the number and maximum size in bytes of the capsules discovered. Entry 1 is
330 assumed to be the highest load priority and entry N is assumed to be the lowest
331 priority.
332
333 @param[in] PeiServices General-purpose services that are available
334 to every PEIM
335 @param[in] This Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI
336 instance.
337 @param[out] NumberRecoveryCapsules Pointer to a caller-allocated UINTN. On
338 output, *NumberRecoveryCapsules contains
339 the number of recovery capsule images
340 available for retrieval from this PEIM
341 instance.
342
343 @retval EFI_SUCCESS One or more capsules were discovered.
344 @retval EFI_DEVICE_ERROR A device error occurred.
345 @retval EFI_NOT_FOUND A recovery DXE capsule cannot be found.
346
347**/
348EFI_STATUS
349EFIAPI
350GetNumberRecoveryCapsules (
351 IN EFI_PEI_SERVICES **PeiServices,
352 IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,
353 OUT UINTN *NumberRecoveryCapsules
354 )
355{
356 EFI_STATUS Status;
357 PEI_FAT_PRIVATE_DATA *PrivateData;
358 UINTN Index;
359 UINTN RecoveryCapsuleCount;
360 PEI_FILE_HANDLE Handle;
361
362 PrivateData = PEI_FAT_PRIVATE_DATA_FROM_THIS (This);
363
364 //
365 // Search each volume in the root directory for the Recovery capsule
366 //
367 RecoveryCapsuleCount = 0;
368 for (Index = 0; Index < PrivateData->VolumeCount; Index++) {
369 Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr (PcdRecoveryFileName), &Handle);
370 if (EFI_ERROR (Status)) {
371 continue;
372 }
373
374 RecoveryCapsuleCount++;
375 }
376
377 *NumberRecoveryCapsules = RecoveryCapsuleCount;
378
379 if (*NumberRecoveryCapsules == 0) {
380 return EFI_NOT_FOUND;
381 }
382
383 return EFI_SUCCESS;
384}
385
386/**
387 Returns the size and type of the requested recovery capsule.
388
389 This function gets the size and type of the capsule specified by CapsuleInstance.
390
391 @param[in] PeiServices General-purpose services that are available to every PEIM
392 @param[in] This Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI
393 instance.
394 @param[in] CapsuleInstance Specifies for which capsule instance to retrieve
395 the information. This parameter must be between
396 one and the value returned by GetNumberRecoveryCapsules()
397 in NumberRecoveryCapsules.
398 @param[out] Size A pointer to a caller-allocated UINTN in which
399 the size of the requested recovery module is
400 returned.
401 @param[out] CapsuleType A pointer to a caller-allocated EFI_GUID in which
402 the type of the requested recovery capsule is
403 returned. The semantic meaning of the value
404 returned is defined by the implementation.
405
406 @retval EFI_SUCCESS One or more capsules were discovered.
407 @retval EFI_DEVICE_ERROR A device error occurred.
408 @retval EFI_NOT_FOUND A recovery DXE capsule cannot be found.
409
410**/
411EFI_STATUS
412EFIAPI
413GetRecoveryCapsuleInfo (
414 IN EFI_PEI_SERVICES **PeiServices,
415 IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,
416 IN UINTN CapsuleInstance,
417 OUT UINTN *Size,
418 OUT EFI_GUID *CapsuleType
419 )
420{
421 EFI_STATUS Status;
422 PEI_FAT_PRIVATE_DATA *PrivateData;
423 UINTN Index;
424 UINTN BlockDeviceNo;
425 UINTN RecoveryCapsuleCount;
426 PEI_FILE_HANDLE Handle;
427 UINTN NumberRecoveryCapsules;
428
429 Status = GetNumberRecoveryCapsules (PeiServices, This, &NumberRecoveryCapsules);
430
431 if (EFI_ERROR (Status)) {
432 return Status;
433 }
434
435 if ((CapsuleInstance == 0) || (CapsuleInstance > NumberRecoveryCapsules)) {
436 return EFI_NOT_FOUND;
437 }
438
439 PrivateData = PEI_FAT_PRIVATE_DATA_FROM_THIS (This);
440
441 //
442 // Search each volume in the root directory for the Recovery capsule
443 //
444 RecoveryCapsuleCount = 0;
445 for (Index = 0; Index < PrivateData->VolumeCount; Index++) {
446 Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr (PcdRecoveryFileName), &Handle);
447
448 if (EFI_ERROR (Status)) {
449 continue;
450 }
451
452 if (CapsuleInstance - 1 == RecoveryCapsuleCount) {
453 //
454 // Get file size
455 //
456 *Size = (UINTN)(((PEI_FAT_FILE *)Handle)->FileSize);
457
458 //
459 // Find corresponding physical block device
460 //
461 BlockDeviceNo = PrivateData->Volume[Index].BlockDeviceNo;
462 while (PrivateData->BlockDevice[BlockDeviceNo].Logical && BlockDeviceNo < PrivateData->BlockDeviceCount) {
463 BlockDeviceNo = PrivateData->BlockDevice[BlockDeviceNo].ParentDevNo;
464 }
465
466 //
467 // Fill in the Capsule Type GUID according to the block device type
468 //
469 if (BlockDeviceNo < PrivateData->BlockDeviceCount) {
470 if (PrivateData->BlockDevice[BlockDeviceNo].BlockIo2 != NULL) {
471 switch (PrivateData->BlockDevice[BlockDeviceNo].InterfaceType) {
472 case MSG_ATAPI_DP:
473 CopyGuid (CapsuleType, &gRecoveryOnFatIdeDiskGuid);
474 break;
475
476 case MSG_USB_DP:
477 CopyGuid (CapsuleType, &gRecoveryOnFatUsbDiskGuid);
478 break;
479
480 case MSG_NVME_NAMESPACE_DP:
481 CopyGuid (CapsuleType, &gRecoveryOnFatNvmeDiskGuid);
482 break;
483
484 default:
485 break;
486 }
487 }
488
489 if (PrivateData->BlockDevice[BlockDeviceNo].BlockIo != NULL) {
490 switch (PrivateData->BlockDevice[BlockDeviceNo].DevType) {
491 case LegacyFloppy:
492 CopyGuid (CapsuleType, &gRecoveryOnFatFloppyDiskGuid);
493 break;
494
495 case IdeCDROM:
496 case IdeLS120:
497 CopyGuid (CapsuleType, &gRecoveryOnFatIdeDiskGuid);
498 break;
499
500 case UsbMassStorage:
501 CopyGuid (CapsuleType, &gRecoveryOnFatUsbDiskGuid);
502 break;
503
504 default:
505 break;
506 }
507 }
508 }
509
510 return EFI_SUCCESS;
511 }
512
513 RecoveryCapsuleCount++;
514 }
515
516 return EFI_NOT_FOUND;
517}
518
519/**
520 Loads a DXE capsule from some media into memory.
521
522 This function, by whatever mechanism, retrieves a DXE capsule from some device
523 and loads it into memory. Note that the published interface is device neutral.
524
525 @param[in] PeiServices General-purpose services that are available
526 to every PEIM
527 @param[in] This Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI
528 instance.
529 @param[in] CapsuleInstance Specifies which capsule instance to retrieve.
530 @param[out] Buffer Specifies a caller-allocated buffer in which
531 the requested recovery capsule will be returned.
532
533 @retval EFI_SUCCESS The capsule was loaded correctly.
534 @retval EFI_DEVICE_ERROR A device error occurred.
535 @retval EFI_NOT_FOUND A requested recovery DXE capsule cannot be found.
536
537**/
538EFI_STATUS
539EFIAPI
540LoadRecoveryCapsule (
541 IN EFI_PEI_SERVICES **PeiServices,
542 IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,
543 IN UINTN CapsuleInstance,
544 OUT VOID *Buffer
545 )
546{
547 EFI_STATUS Status;
548 PEI_FAT_PRIVATE_DATA *PrivateData;
549 UINTN Index;
550 UINTN RecoveryCapsuleCount;
551 PEI_FILE_HANDLE Handle;
552 UINTN NumberRecoveryCapsules;
553
554 Status = GetNumberRecoveryCapsules (PeiServices, This, &NumberRecoveryCapsules);
555
556 if (EFI_ERROR (Status)) {
557 return Status;
558 }
559
560 if ((CapsuleInstance == 0) || (CapsuleInstance > NumberRecoveryCapsules)) {
561 return EFI_NOT_FOUND;
562 }
563
564 PrivateData = PEI_FAT_PRIVATE_DATA_FROM_THIS (This);
565
566 //
567 // Search each volume in the root directory for the Recovery capsule
568 //
569 RecoveryCapsuleCount = 0;
570 for (Index = 0; Index < PrivateData->VolumeCount; Index++) {
571 Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr (PcdRecoveryFileName), &Handle);
572 if (EFI_ERROR (Status)) {
573 continue;
574 }
575
576 if (CapsuleInstance - 1 == RecoveryCapsuleCount) {
577 Status = FatReadFile (
578 PrivateData,
579 Handle,
580 (UINTN)(((PEI_FAT_FILE *)Handle)->FileSize),
581 Buffer
582 );
583 return Status;
584 }
585
586 RecoveryCapsuleCount++;
587 }
588
589 return EFI_NOT_FOUND;
590}
591
592/**
593 Finds the recovery file on a FAT volume.
594 This function finds the recovery file named FileName on a specified FAT volume and returns
595 its FileHandle pointer.
596
597 @param PrivateData Global memory map for accessing global
598 variables.
599 @param VolumeIndex The index of the volume.
600 @param FileName The recovery file name to find.
601 @param Handle The output file handle.
602
603 @retval EFI_DEVICE_ERROR Some error occurred when operating the FAT
604 volume.
605 @retval EFI_NOT_FOUND The recovery file was not found.
606 @retval EFI_SUCCESS The recovery file was successfully found on the
607 FAT volume.
608
609**/
610EFI_STATUS
611FindRecoveryFile (
612 IN PEI_FAT_PRIVATE_DATA *PrivateData,
613 IN UINTN VolumeIndex,
614 IN CHAR16 *FileName,
615 OUT PEI_FILE_HANDLE *Handle
616 )
617{
618 EFI_STATUS Status;
619 PEI_FAT_FILE Parent;
620 PEI_FAT_FILE *File;
621
622 File = &PrivateData->File;
623
624 //
625 // VolumeIndex must be less than PEI_FAT_MAX_VOLUME because PrivateData->VolumeCount
626 // cannot be larger than PEI_FAT_MAX_VOLUME when detecting recovery volume.
627 //
628 ASSERT (VolumeIndex < PEI_FAT_MAX_VOLUME);
629
630 //
631 // Construct root directory file
632 //
633 ZeroMem (&Parent, sizeof (PEI_FAT_FILE));
634 Parent.IsFixedRootDir = (BOOLEAN)((PrivateData->Volume[VolumeIndex].FatType == Fat32) ? FALSE : TRUE);
635 Parent.Attributes = FAT_ATTR_DIRECTORY;
636 Parent.CurrentPos = 0;
637 Parent.CurrentCluster = Parent.IsFixedRootDir ? 0 : PrivateData->Volume[VolumeIndex].RootDirCluster;
638 Parent.StartingCluster = Parent.CurrentCluster;
639 Parent.Volume = &PrivateData->Volume[VolumeIndex];
640
641 Status = FatSetFilePos (PrivateData, &Parent, 0);
642 if (EFI_ERROR (Status)) {
643 return EFI_DEVICE_ERROR;
644 }
645
646 //
647 // Search for recovery capsule in root directory
648 //
649 Status = FatReadNextDirectoryEntry (PrivateData, &Parent, File);
650 while (Status == EFI_SUCCESS) {
651 //
652 // Compare whether the file name is recovery file name.
653 //
654 if (EngStriColl (PrivateData, FileName, File->FileName)) {
655 break;
656 }
657
658 Status = FatReadNextDirectoryEntry (PrivateData, &Parent, File);
659 }
660
661 if (EFI_ERROR (Status)) {
662 return EFI_NOT_FOUND;
663 }
664
665 //
666 // Get the recovery file, set its file position to 0.
667 //
668 if (File->StartingCluster != 0) {
669 Status = FatSetFilePos (PrivateData, File, 0);
670 }
671
672 *Handle = File;
673
674 return EFI_SUCCESS;
675}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette