]> git.proxmox.com Git - mirror_edk2.git/blame - IntelFrameworkModulePkg/Universal/FirmwareVolume/FwVolDxe/FwVol.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add core FFS3 support, DxeCore.
[mirror_edk2.git] / IntelFrameworkModulePkg / Universal / FirmwareVolume / FwVolDxe / FwVol.c
CommitLineData
c2df8e13 1/** @file\r
2\r
3 Firmware File System driver that produce full Firmware Volume2 protocol.\r
4 Layers on top of Firmware Block protocol to produce a file abstraction\r
5 of FV based files.\r
6\r
7 Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>\r
8\r
9 This program and the accompanying materials\r
10 are licensed and made available under the terms and conditions\r
11 of the BSD License which accompanies this distribution. The\r
12 full text of the license may be found at\r
13 http://opensource.org/licenses/bsd-license.php\r
14\r
15 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
16 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
17\r
18**/\r
19\r
20#include "FwVolDriver.h"\r
21\r
22#define KEYSIZE sizeof (UINTN)\r
23\r
24/**\r
25 Given the supplied FW_VOL_BLOCK_PROTOCOL, allocate a buffer for output and\r
26 copy the real length volume header into it.\r
27\r
28 @param Fvb The FW_VOL_BLOCK_PROTOCOL instance from which to\r
29 read the volume header\r
30 @param FwVolHeader Pointer to pointer to allocated buffer in which\r
31 the volume header is returned.\r
32\r
33 @retval EFI_OUT_OF_RESOURCES No enough buffer could be allocated.\r
34 @retval EFI_SUCCESS Successfully read volume header to the allocated\r
35 buffer.\r
36 @retval EFI_ACCESS_DENIED Read status of FV is not enabled.\r
37**/\r
38EFI_STATUS\r
39GetFwVolHeader (\r
40 IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb,\r
41 OUT EFI_FIRMWARE_VOLUME_HEADER **FwVolHeader\r
42 )\r
43{\r
44 EFI_STATUS Status;\r
45 EFI_FIRMWARE_VOLUME_HEADER TempFvh;\r
46 EFI_FVB_ATTRIBUTES_2 FvbAttributes;\r
47 UINTN FvhLength;\r
48 EFI_PHYSICAL_ADDRESS BaseAddress;\r
49\r
50 //\r
51 // Determine the real length of FV header\r
52 //\r
53 Status = Fvb->GetAttributes (\r
54 Fvb,\r
55 &FvbAttributes\r
56 );\r
57 if (EFI_ERROR (Status)) {\r
58 return Status;\r
59 }\r
60\r
61 if ((FvbAttributes & EFI_FVB2_READ_STATUS) == 0) {\r
62 return EFI_ACCESS_DENIED;\r
63 }\r
64\r
65 //\r
66 // Just avoid compiling warning\r
67 //\r
68 BaseAddress = 0;\r
69 FvhLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER);\r
70\r
71 //\r
72 // memory-mapped FV and non memory-mapped has different ways to read\r
73 //\r
74 if ((FvbAttributes & EFI_FVB2_MEMORY_MAPPED) != 0) {\r
75 Status = Fvb->GetPhysicalAddress (\r
76 Fvb,\r
77 &BaseAddress\r
78 );\r
79 if (EFI_ERROR (Status)) {\r
80 return Status;\r
81 }\r
82 CopyMem (&TempFvh, (VOID *) (UINTN) BaseAddress, FvhLength);\r
83 } else {\r
84 Status = Fvb->Read (\r
85 Fvb,\r
86 0,\r
87 0,\r
88 &FvhLength,\r
89 (UINT8 *) &TempFvh\r
90 );\r
91 }\r
92\r
93 *FwVolHeader = AllocatePool (TempFvh.HeaderLength);\r
94 if (*FwVolHeader == NULL) {\r
95 return EFI_OUT_OF_RESOURCES;\r
96 }\r
97 //\r
98 // Read the whole header\r
99 //\r
100 if ((FvbAttributes & EFI_FVB2_MEMORY_MAPPED) != 0) {\r
101 CopyMem (*FwVolHeader, (VOID *) (UINTN) BaseAddress, TempFvh.HeaderLength);\r
102 } else {\r
103 //\r
104 // Assumed the first block is bigger than the length of Fv headder\r
105 //\r
106 FvhLength = TempFvh.HeaderLength;\r
107 Status = Fvb->Read (\r
108 Fvb,\r
109 0,\r
110 0,\r
111 &FvhLength,\r
112 (UINT8 *) *FwVolHeader\r
113 );\r
114 //\r
115 // Check whether Read successes.\r
116 //\r
117 if (EFI_ERROR (Status)) {\r
118 FreePool (*FwVolHeader);\r
119 *FwVolHeader = NULL;\r
120 return Status;\r
121 }\r
122 }\r
123\r
124 return EFI_SUCCESS;\r
125}\r
126\r
127/**\r
128 Free FvDevice resource when error happens.\r
129\r
130 @param FvDevice Pointer to the FvDevice to be freed.\r
131**/\r
132VOID\r
133FreeFvDeviceResource (\r
134 IN FV_DEVICE *FvDevice\r
135 )\r
136{\r
137 LBA_ENTRY *LbaEntry;\r
138 FREE_SPACE_ENTRY *FreeSpaceEntry;\r
139 FFS_FILE_LIST_ENTRY *FfsFileEntry;\r
140 LIST_ENTRY *NextEntry;\r
141\r
142 //\r
143 // Free LAB Entry\r
144 //\r
145 LbaEntry = (LBA_ENTRY *) FvDevice->LbaHeader.ForwardLink;\r
146 while (&LbaEntry->Link != &FvDevice->LbaHeader) {\r
147 NextEntry = (&LbaEntry->Link)->ForwardLink;\r
148 FreePool (LbaEntry);\r
149 LbaEntry = (LBA_ENTRY *) NextEntry;\r
150 }\r
151 //\r
152 // Free File List Entry\r
153 //\r
154 FfsFileEntry = (FFS_FILE_LIST_ENTRY *) FvDevice->FfsFileListHeader.ForwardLink;\r
155 while (&FfsFileEntry->Link != &FvDevice->FfsFileListHeader) {\r
156 NextEntry = (&FfsFileEntry->Link)->ForwardLink;\r
157 FreePool (FfsFileEntry);\r
158 FfsFileEntry = (FFS_FILE_LIST_ENTRY *) NextEntry;\r
159 }\r
160 //\r
161 // Free Space Entry\r
162 //\r
163 FreeSpaceEntry = (FREE_SPACE_ENTRY *) FvDevice->FreeSpaceHeader.ForwardLink;\r
164 while (&FreeSpaceEntry->Link != &FvDevice->FreeSpaceHeader) {\r
165 NextEntry = (&FreeSpaceEntry->Link)->ForwardLink;\r
166 FreePool (FreeSpaceEntry);\r
167 FreeSpaceEntry = (FREE_SPACE_ENTRY *) NextEntry;\r
168 }\r
169 //\r
170 // Free the cache\r
171 //\r
172 FreePool ((UINT8 *) (UINTN) FvDevice->CachedFv);\r
173\r
174 return ;\r
175}\r
176\r
177/**\r
178 Check if an FV is consistent and allocate cache for it.\r
179\r
180 @param FvDevice A pointer to the FvDevice to be checked.\r
181\r
182 @retval EFI_OUT_OF_RESOURCES No enough buffer could be allocated.\r
183 @retval EFI_VOLUME_CORRUPTED File system is corrupted.\r
184 @retval EFI_SUCCESS FV is consistent and cache is allocated.\r
185\r
186**/\r
187EFI_STATUS\r
188FvCheck (\r
189 IN FV_DEVICE *FvDevice\r
190 )\r
191{\r
192 EFI_STATUS Status;\r
193 EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;\r
194 EFI_FVB_ATTRIBUTES_2 FvbAttributes;\r
195 EFI_FV_BLOCK_MAP_ENTRY *BlockMap;\r
196 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;\r
197 UINT8 *FwCache;\r
198 LBA_ENTRY *LbaEntry;\r
199 FREE_SPACE_ENTRY *FreeSpaceEntry;\r
200 FFS_FILE_LIST_ENTRY *FfsFileEntry;\r
201 UINT8 *LbaStart;\r
202 UINTN Index;\r
203 EFI_LBA LbaIndex;\r
204 UINT8 *Ptr;\r
205 UINTN Size;\r
206 UINT8 *FreeStart;\r
207 UINTN FreeSize;\r
208 UINT8 ErasePolarity;\r
209 UINTN FileLength;\r
210 EFI_FFS_FILE_STATE FileState;\r
211 UINT8 *TopFvAddress;\r
212 UINTN TestLength;\r
213 EFI_PHYSICAL_ADDRESS BaseAddress;\r
214\r
215 Fvb = FvDevice->Fvb;\r
216\r
217 Status = Fvb->GetAttributes (Fvb, &FvbAttributes);\r
218 if (EFI_ERROR (Status)) {\r
219 return Status;\r
220 }\r
221\r
222 InitializeListHead (&FvDevice->LbaHeader);\r
223 InitializeListHead (&FvDevice->FreeSpaceHeader);\r
224 InitializeListHead (&FvDevice->FfsFileListHeader);\r
225\r
226 FwVolHeader = NULL;\r
227 Status = GetFwVolHeader (Fvb, &FwVolHeader);\r
228 if (EFI_ERROR (Status)) {\r
229 return Status;\r
230 }\r
231 ASSERT (FwVolHeader != NULL);\r
232\r
233 //\r
234 // Double Check firmware volume header here\r
235 //\r
236 if (!VerifyFvHeaderChecksum (FwVolHeader)) {\r
237 FreePool (FwVolHeader);\r
238 return EFI_VOLUME_CORRUPTED;\r
239 }\r
240\r
241 BlockMap = FwVolHeader->BlockMap;\r
242\r
243 //\r
244 // FwVolHeader->FvLength is the whole FV length including FV header\r
245 //\r
246 FwCache = AllocateZeroPool ((UINTN) FwVolHeader->FvLength);\r
247 if (FwCache == NULL) {\r
248 FreePool (FwVolHeader);\r
249 return EFI_OUT_OF_RESOURCES;\r
250 }\r
251\r
252 FvDevice->CachedFv = (EFI_PHYSICAL_ADDRESS) (UINTN) FwCache;\r
253\r
254 //\r
255 // Copy to memory\r
256 //\r
257 LbaStart = FwCache;\r
258 LbaIndex = 0;\r
259 Ptr = NULL;\r
260\r
261 if ((FvbAttributes & EFI_FVB2_MEMORY_MAPPED) != 0) {\r
262 //\r
263 // Get volume base address\r
264 //\r
265 Status = Fvb->GetPhysicalAddress (Fvb, &BaseAddress);\r
266 if (EFI_ERROR (Status)) {\r
267 FreePool (FwVolHeader);\r
268 return Status;\r
269 }\r
270\r
271 Ptr = (UINT8 *) ((UINTN) BaseAddress);\r
272\r
273 DEBUG((EFI_D_INFO, "Fv Base Address is 0x%LX\n", BaseAddress));\r
274 }\r
275 //\r
276 // Copy whole FV into the memory\r
277 //\r
278 while ((BlockMap->NumBlocks != 0) || (BlockMap->Length != 0)) {\r
279\r
280 for (Index = 0; Index < BlockMap->NumBlocks; Index++) {\r
281 LbaEntry = AllocatePool (sizeof (LBA_ENTRY));\r
282 if (LbaEntry == NULL) {\r
283 FreePool (FwVolHeader);\r
284 FreeFvDeviceResource (FvDevice);\r
285 return EFI_OUT_OF_RESOURCES;\r
286 }\r
287\r
288 LbaEntry->LbaIndex = LbaIndex;\r
289 LbaEntry->StartingAddress = LbaStart;\r
290 LbaEntry->BlockLength = BlockMap->Length;\r
291\r
292 //\r
293 // Copy each LBA into memory\r
294 //\r
295 if ((FvbAttributes & EFI_FVB2_MEMORY_MAPPED) != 0) {\r
296\r
297 CopyMem (LbaStart, Ptr, BlockMap->Length);\r
298 Ptr += BlockMap->Length;\r
299\r
300 } else {\r
301\r
302 Size = BlockMap->Length;\r
303 Status = Fvb->Read (\r
304 Fvb,\r
305 LbaIndex,\r
306 0,\r
307 &Size,\r
308 LbaStart\r
309 );\r
310 //\r
311 // Not check EFI_BAD_BUFFER_SIZE, for Size = BlockMap->Length\r
312 //\r
313 if (EFI_ERROR (Status)) {\r
314 FreePool (FwVolHeader);\r
315 FreeFvDeviceResource (FvDevice);\r
316 return Status;\r
317 }\r
318\r
319 }\r
320\r
321 LbaIndex++;\r
322 LbaStart += BlockMap->Length;\r
323\r
324 InsertTailList (&FvDevice->LbaHeader, &LbaEntry->Link);\r
325 }\r
326\r
327 BlockMap++;\r
328 }\r
329\r
330 FvDevice->FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) FwCache;\r
331\r
332 //\r
333 // it is not used any more, so free FwVolHeader\r
334 //\r
335 FreePool (FwVolHeader);\r
336\r
337 //\r
338 // Scan to check the free space & File list\r
339 //\r
340 if ((FvbAttributes & EFI_FVB2_ERASE_POLARITY) != 0) {\r
341 ErasePolarity = 1;\r
342 } else {\r
343 ErasePolarity = 0;\r
344 }\r
345\r
346 FvDevice->ErasePolarity = ErasePolarity;\r
347\r
348 //\r
349 // go through the whole FV cache, check the consistence of the FV\r
350 //\r
351 Ptr = (UINT8 *) (UINTN) (FvDevice->CachedFv + FvDevice->FwVolHeader->HeaderLength);\r
352 TopFvAddress = (UINT8 *) (UINTN) (FvDevice->CachedFv + FvDevice->FwVolHeader->FvLength - 1);\r
353\r
354 //\r
355 // Build FFS list & Free Space List here\r
356 //\r
357 while (Ptr <= TopFvAddress) {\r
358 TestLength = TopFvAddress - Ptr + 1;\r
359\r
360 if (TestLength > sizeof (EFI_FFS_FILE_HEADER)) {\r
361 TestLength = sizeof (EFI_FFS_FILE_HEADER);\r
362 }\r
363\r
364 if (IsBufferErased (ErasePolarity, Ptr, TestLength)) {\r
365 //\r
366 // We found free space\r
367 //\r
368 FreeStart = Ptr;\r
369 FreeSize = 0;\r
370\r
371 do {\r
372 TestLength = TopFvAddress - Ptr + 1;\r
373\r
374 if (TestLength > sizeof (EFI_FFS_FILE_HEADER)) {\r
375 TestLength = sizeof (EFI_FFS_FILE_HEADER);\r
376 }\r
377\r
378 if (!IsBufferErased (ErasePolarity, Ptr, TestLength)) {\r
379 break;\r
380 }\r
381\r
382 FreeSize += TestLength;\r
383 Ptr += TestLength;\r
384 } while (Ptr <= TopFvAddress);\r
385\r
386 FreeSpaceEntry = AllocateZeroPool (sizeof (FREE_SPACE_ENTRY));\r
387 if (FreeSpaceEntry == NULL) {\r
388 FreeFvDeviceResource (FvDevice);\r
389 return EFI_OUT_OF_RESOURCES;\r
390 }\r
391 //\r
392 // Create a Free space entry\r
393 //\r
394 FreeSpaceEntry->StartingAddress = FreeStart;\r
395 FreeSpaceEntry->Length = FreeSize;\r
396 InsertTailList (&FvDevice->FreeSpaceHeader, &FreeSpaceEntry->Link);\r
397 continue;\r
398 }\r
399 //\r
400 // double check boundry\r
401 //\r
402 if (TestLength < sizeof (EFI_FFS_FILE_HEADER)) {\r
403 break;\r
404 }\r
405\r
406 if (!IsValidFFSHeader (\r
407 FvDevice->ErasePolarity,\r
408 (EFI_FFS_FILE_HEADER *) Ptr\r
409 )) {\r
410 FileState = GetFileState (\r
411 FvDevice->ErasePolarity,\r
412 (EFI_FFS_FILE_HEADER *) Ptr\r
413 );\r
414 if ((FileState == EFI_FILE_HEADER_INVALID) || (FileState == EFI_FILE_HEADER_CONSTRUCTION)) {\r
415 Ptr += sizeof (EFI_FFS_FILE_HEADER);\r
416\r
417 continue;\r
418\r
419 } else {\r
420 //\r
421 // File system is corrputed, return\r
422 //\r
423 FreeFvDeviceResource (FvDevice);\r
424 return EFI_VOLUME_CORRUPTED;\r
425 }\r
426 }\r
427\r
428 if (IsValidFFSFile (FvDevice, (EFI_FFS_FILE_HEADER *) Ptr)) {\r
429 FileLength = *(UINT32 *) ((EFI_FFS_FILE_HEADER *) Ptr)->Size & 0x00FFFFFF;\r
430 FileState = GetFileState (\r
431 FvDevice->ErasePolarity,\r
432 (EFI_FFS_FILE_HEADER *) Ptr\r
433 );\r
434\r
435 //\r
436 // check for non-deleted file\r
437 //\r
438 if (FileState != EFI_FILE_DELETED) {\r
439 //\r
440 // Create a FFS list entry for each non-deleted file\r
441 //\r
442 FfsFileEntry = AllocateZeroPool (sizeof (FFS_FILE_LIST_ENTRY));\r
443 if (FfsFileEntry == NULL) {\r
444 FreeFvDeviceResource (FvDevice);\r
445 return EFI_OUT_OF_RESOURCES;\r
446 }\r
447\r
448 FfsFileEntry->FfsHeader = Ptr;\r
449 InsertTailList (&FvDevice->FfsFileListHeader, &FfsFileEntry->Link);\r
450 }\r
451\r
452 Ptr += FileLength;\r
453\r
454 //\r
455 // Adjust Ptr to the next 8-byte aligned boundry.\r
456 //\r
457 while (((UINTN) Ptr & 0x07) != 0) {\r
458 Ptr++;\r
459 }\r
460 } else {\r
461 //\r
462 // File system is corrupted, return\r
463 //\r
464 FreeFvDeviceResource (FvDevice);\r
465 return EFI_VOLUME_CORRUPTED;\r
466 }\r
467 }\r
468\r
469 FvDevice->CurrentFfsFile = NULL;\r
470\r
471 return EFI_SUCCESS;\r
472}\r
473\r
474/**\r
475 Entry point function does install/reinstall FV2 protocol with full functionality.\r
476\r
477 @param ImageHandle A handle for the image that is initializing this driver\r
478 @param SystemTable A pointer to the EFI system table\r
479\r
480 @retval EFI_SUCCESS At least one Fv protocol install/reinstall successfully.\r
481 @retval EFI_NOT_FOUND No FV protocol install/reinstall successfully.\r
482**/\r
483EFI_STATUS\r
484EFIAPI\r
485FwVolDriverInit (\r
486 IN EFI_HANDLE ImageHandle,\r
487 IN EFI_SYSTEM_TABLE *SystemTable\r
488 )\r
489{\r
490 EFI_STATUS Status;\r
491 EFI_HANDLE *HandleBuffer;\r
492 UINTN HandleCount;\r
493 UINTN Index;\r
494 EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;\r
495 EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;\r
496 FV_DEVICE *FvDevice;\r
497 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;\r
498 BOOLEAN Reinstall;\r
499 BOOLEAN InstallFlag;\r
500\r
501 DEBUG ((EFI_D_INFO, "=========FwVol writable driver installed\n"));\r
502 InstallFlag = FALSE;\r
503 //\r
504 // Locate all handles of Fvb protocol\r
505 //\r
506 Status = gBS->LocateHandleBuffer (\r
507 ByProtocol,\r
508 &gEfiFirmwareVolumeBlockProtocolGuid,\r
509 NULL,\r
510 &HandleCount,\r
511 &HandleBuffer\r
512 );\r
513 if (EFI_ERROR (Status)) {\r
514 return EFI_NOT_FOUND;\r
515 }\r
516 //\r
517 // Get FV with gEfiFirmwareFileSystemGuid\r
518 //\r
519 for (Index = 0; Index < HandleCount; Index += 1) {\r
520 Status = gBS->HandleProtocol (\r
521 HandleBuffer[Index],\r
522 &gEfiFirmwareVolumeBlockProtocolGuid,\r
523 (VOID **) &Fvb\r
524 );\r
525 if (EFI_ERROR (Status)) {\r
526 continue;\r
527 }\r
528\r
529 FwVolHeader = NULL;\r
530 Status = GetFwVolHeader (Fvb, &FwVolHeader);\r
531 if (EFI_ERROR (Status)) {\r
532 continue;\r
533 }\r
534 ASSERT (FwVolHeader != NULL);\r
535 //\r
536 // Check to see that the file system is indeed formatted in a way we can\r
537 // understand it...\r
538 //\r
539 if (!CompareGuid (\r
540 &FwVolHeader->FileSystemGuid,\r
541 &gEfiFirmwareFileSystem2Guid\r
542 )) {\r
543 FreePool (FwVolHeader);\r
544 continue;\r
545 }\r
546 FreePool (FwVolHeader);\r
547\r
548 Reinstall = FALSE;\r
549 //\r
550 // Check if there is an FV protocol already installed in that handle\r
551 //\r
552 Status = gBS->HandleProtocol (\r
553 HandleBuffer[Index],\r
554 &gEfiFirmwareVolume2ProtocolGuid,\r
555 (VOID **) &Fv\r
556 );\r
557 if (!EFI_ERROR (Status)) {\r
558 Reinstall = TRUE;\r
559 }\r
560 //\r
561 // FwVol protocol on the handle so create a new one\r
562 //\r
563 FvDevice = AllocateZeroPool (sizeof (FV_DEVICE));\r
564 if (FvDevice == NULL) {\r
565 goto Done;\r
566 }\r
567\r
568 FvDevice->Signature = FV_DEVICE_SIGNATURE;\r
569 FvDevice->Fvb = Fvb;\r
570\r
571 //\r
572 // Firmware Volume Protocol interface\r
573 //\r
574 FvDevice->Fv.GetVolumeAttributes = FvGetVolumeAttributes;\r
575 FvDevice->Fv.SetVolumeAttributes = FvSetVolumeAttributes;\r
576 FvDevice->Fv.ReadFile = FvReadFile;\r
577 FvDevice->Fv.ReadSection = FvReadFileSection;\r
578 FvDevice->Fv.WriteFile = FvWriteFile;\r
579 FvDevice->Fv.GetNextFile = FvGetNextFile;\r
580 FvDevice->Fv.KeySize = KEYSIZE;\r
581 FvDevice->Fv.GetInfo = FvGetVolumeInfo;\r
582 FvDevice->Fv.SetInfo = FvSetVolumeInfo;\r
583\r
584 Status = FvCheck (FvDevice);\r
585 if (EFI_ERROR (Status)) {\r
586 //\r
587 // The file system is not consistence\r
588 //\r
589 FreePool (FvDevice);\r
590 continue;\r
591 }\r
592\r
593 if (Reinstall) {\r
594 //\r
595 // Reinstall an New FV protocol\r
596 //\r
597 // FvDevice = FV_DEVICE_FROM_THIS (Fv);\r
598 // FvDevice->Fvb = Fvb;\r
599 // FreeFvDeviceResource (FvDevice);\r
600 //\r
601 Status = gBS->ReinstallProtocolInterface (\r
602 HandleBuffer[Index],\r
603 &gEfiFirmwareVolume2ProtocolGuid,\r
604 Fv,\r
605 &FvDevice->Fv\r
606 );\r
607 if (!EFI_ERROR (Status)) {\r
608 InstallFlag = TRUE;\r
609 } else {\r
610 FreePool (FvDevice);\r
611 }\r
612 \r
613 DEBUG ((EFI_D_INFO, "Reinstall FV protocol as writable - %r\n", Status));\r
614 ASSERT_EFI_ERROR (Status);\r
615 } else {\r
616 //\r
617 // Install an New FV protocol\r
618 //\r
619 Status = gBS->InstallProtocolInterface (\r
620 &FvDevice->Handle,\r
621 &gEfiFirmwareVolume2ProtocolGuid,\r
622 EFI_NATIVE_INTERFACE,\r
623 &FvDevice->Fv\r
624 );\r
625 if (!EFI_ERROR (Status)) {\r
626 InstallFlag = TRUE;\r
627 } else {\r
628 FreePool (FvDevice);\r
629 }\r
630 \r
631 DEBUG ((EFI_D_INFO, "Install FV protocol as writable - %r\n", Status));\r
632 ASSERT_EFI_ERROR (Status);\r
633 }\r
634 }\r
635\r
636Done:\r
637 //\r
638 // As long as one Fv protocol install/reinstall successfully,\r
639 // success should return to ensure this image will be not unloaded.\r
640 // Otherwise, new Fv protocols are corrupted by other loaded driver.\r
641 //\r
642 if (InstallFlag) {\r
643 return EFI_SUCCESS;\r
644 }\r
645 \r
646 //\r
647 // No FV protocol install/reinstall successfully.\r
648 // EFI_NOT_FOUND should return to ensure this image will be unloaded.\r
649 //\r
650 return EFI_NOT_FOUND;\r
651}\r
EFI Development Kit II mirror for PVE