VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeCapsuleLibFmp/DxeCapsuleProcessLib.c@ 81344

Last change on this file since 81344 was 80721, checked in by vboxsync, 5 years ago

Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
  • Property svn:eol-style set to native
File size: 22.3 KB
Line 
1/** @file
2 DXE capsule process.
3
4 Caution: This module requires additional review when modified.
5 This module will have external input - capsule image.
6 This external input must be validated carefully to avoid security issue like
7 buffer overflow, integer overflow.
8
9 ProcessCapsules(), ProcessTheseCapsules() will receive untrusted
10 input and do basic validation.
11
12 Copyright (c) 2016 - 2019, Intel Corporation. All rights reserved.<BR>
13 SPDX-License-Identifier: BSD-2-Clause-Patent
14
15**/
16
17#include <PiDxe.h>
18#include <Protocol/EsrtManagement.h>
19#include <Protocol/FirmwareManagementProgress.h>
20
21#include <Library/BaseLib.h>
22#include <Library/DebugLib.h>
23#include <Library/BaseMemoryLib.h>
24#include <Library/UefiBootServicesTableLib.h>
25#include <Library/UefiRuntimeServicesTableLib.h>
26#include <Library/MemoryAllocationLib.h>
27#include <Library/UefiLib.h>
28#include <Library/PcdLib.h>
29#include <Library/HobLib.h>
30#include <Library/ReportStatusCodeLib.h>
31#include <Library/CapsuleLib.h>
32#include <Library/DisplayUpdateProgressLib.h>
33
34#include <IndustryStandard/WindowsUxCapsule.h>
35
36extern EDKII_FIRMWARE_MANAGEMENT_PROGRESS_PROTOCOL *mFmpProgress;
37
38/**
39 Return if this FMP is a system FMP or a device FMP, based upon CapsuleHeader.
40
41 @param[in] CapsuleHeader A pointer to EFI_CAPSULE_HEADER
42
43 @retval TRUE It is a system FMP.
44 @retval FALSE It is a device FMP.
45**/
46BOOLEAN
47IsFmpCapsule (
48 IN EFI_CAPSULE_HEADER *CapsuleHeader
49 );
50
51/**
52 Validate Fmp capsules layout.
53
54 Caution: This function may receive untrusted input.
55
56 This function assumes the caller validated the capsule by using
57 IsValidCapsuleHeader(), so that all fields in EFI_CAPSULE_HEADER are correct.
58 The capsule buffer size is CapsuleHeader->CapsuleImageSize.
59
60 This function validates the fields in EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER
61 and EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER.
62
63 This function need support nested FMP capsule.
64
65 @param[in] CapsuleHeader Points to a capsule header.
66 @param[out] EmbeddedDriverCount The EmbeddedDriverCount in the FMP capsule.
67
68 @retval EFI_SUCESS Input capsule is a correct FMP capsule.
69 @retval EFI_INVALID_PARAMETER Input capsule is not a correct FMP capsule.
70**/
71EFI_STATUS
72ValidateFmpCapsule (
73 IN EFI_CAPSULE_HEADER *CapsuleHeader,
74 OUT UINT16 *EmbeddedDriverCount OPTIONAL
75 );
76
77/**
78 Validate if it is valid capsule header
79
80 This function assumes the caller provided correct CapsuleHeader pointer
81 and CapsuleSize.
82
83 This function validates the fields in EFI_CAPSULE_HEADER.
84
85 @param[in] CapsuleHeader Points to a capsule header.
86 @param[in] CapsuleSize Size of the whole capsule image.
87
88**/
89BOOLEAN
90IsValidCapsuleHeader (
91 IN EFI_CAPSULE_HEADER *CapsuleHeader,
92 IN UINT64 CapsuleSize
93 );
94
95/**
96 Return if this capsule is a capsule name capsule, based upon CapsuleHeader.
97
98 @param[in] CapsuleHeader A pointer to EFI_CAPSULE_HEADER
99
100 @retval TRUE It is a capsule name capsule.
101 @retval FALSE It is not a capsule name capsule.
102**/
103BOOLEAN
104IsCapsuleNameCapsule (
105 IN EFI_CAPSULE_HEADER *CapsuleHeader
106 );
107
108/**
109 Check the integrity of the capsule name capsule.
110 If the capsule is vaild, return the physical address of each capsule name string.
111
112 @param[in] CapsuleHeader Pointer to the capsule header of a capsule name capsule.
113 @param[out] CapsuleNameNum Number of capsule name.
114
115 @retval NULL Capsule name capsule is not valid.
116 @retval CapsuleNameBuf Array of capsule name physical address.
117
118**/
119EFI_PHYSICAL_ADDRESS *
120ValidateCapsuleNameCapsuleIntegrity (
121 IN EFI_CAPSULE_HEADER *CapsuleHeader,
122 OUT UINTN *CapsuleNameNum
123 );
124
125extern BOOLEAN mDxeCapsuleLibEndOfDxe;
126BOOLEAN mNeedReset = FALSE;
127
128VOID **mCapsulePtr;
129CHAR16 **mCapsuleNamePtr;
130EFI_STATUS *mCapsuleStatusArray;
131UINT32 mCapsuleTotalNumber;
132
133/**
134 The firmware implements to process the capsule image.
135
136 Caution: This function may receive untrusted input.
137
138 @param[in] CapsuleHeader Points to a capsule header.
139 @param[in] CapFileName Capsule file name.
140 @param[out] ResetRequired Indicates whether reset is required or not.
141
142 @retval EFI_SUCESS Process Capsule Image successfully.
143 @retval EFI_UNSUPPORTED Capsule image is not supported by the firmware.
144 @retval EFI_VOLUME_CORRUPTED FV volume in the capsule is corrupted.
145 @retval EFI_OUT_OF_RESOURCES Not enough memory.
146**/
147EFI_STATUS
148EFIAPI
149ProcessThisCapsuleImage (
150 IN EFI_CAPSULE_HEADER *CapsuleHeader,
151 IN CHAR16 *CapFileName, OPTIONAL
152 OUT BOOLEAN *ResetRequired OPTIONAL
153 );
154
155/**
156 Function indicate the current completion progress of the firmware
157 update. Platform may override with own specific progress function.
158
159 @param[in] Completion A value between 1 and 100 indicating the current
160 completion progress of the firmware update
161
162 @retval EFI_SUCESS The capsule update progress was updated.
163 @retval EFI_INVALID_PARAMETER Completion is greater than 100%.
164**/
165EFI_STATUS
166EFIAPI
167UpdateImageProgress (
168 IN UINTN Completion
169 )
170{
171 EFI_STATUS Status;
172 UINTN Seconds;
173 EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION *Color;
174
175 DEBUG((DEBUG_INFO, "Update Progress - %d%%\n", Completion));
176
177 if (Completion > 100) {
178 return EFI_INVALID_PARAMETER;
179 }
180
181 //
182 // Use a default timeout of 5 minutes if there is not FMP Progress Protocol.
183 //
184 Seconds = 5 * 60;
185 Color = NULL;
186 if (mFmpProgress != NULL) {
187 Seconds = mFmpProgress->WatchdogSeconds;
188 Color = &mFmpProgress->ProgressBarForegroundColor;
189 }
190
191 //
192 // Cancel the watchdog timer
193 //
194 gBS->SetWatchdogTimer (0, 0x0000, 0, NULL);
195
196 if (Completion != 100) {
197 //
198 // Arm the watchdog timer from PCD setting
199 //
200 if (Seconds != 0) {
201 DEBUG ((DEBUG_VERBOSE, "Arm watchdog timer %d seconds\n", Seconds));
202 gBS->SetWatchdogTimer (Seconds, 0x0000, 0, NULL);
203 }
204 }
205
206 Status = DisplayUpdateProgress (Completion, Color);
207
208 return Status;
209}
210
211/**
212 This function initializes the mCapsulePtr, mCapsuleStatusArray and mCapsuleTotalNumber.
213**/
214VOID
215InitCapsulePtr (
216 VOID
217 )
218{
219 EFI_PEI_HOB_POINTERS HobPointer;
220 UINTN Index;
221 UINTN Index2;
222 UINTN Index3;
223 UINTN CapsuleNameNumber;
224 UINTN CapsuleNameTotalNumber;
225 UINTN CapsuleNameCapsuleTotalNumber;
226 VOID **CapsuleNameCapsulePtr;
227 EFI_PHYSICAL_ADDRESS *CapsuleNameAddress;
228
229 CapsuleNameNumber = 0;
230 CapsuleNameTotalNumber = 0;
231 CapsuleNameCapsuleTotalNumber = 0;
232 CapsuleNameCapsulePtr = NULL;
233
234 //
235 // Find all capsule images from hob
236 //
237 HobPointer.Raw = GetHobList ();
238 while ((HobPointer.Raw = GetNextHob (EFI_HOB_TYPE_UEFI_CAPSULE, HobPointer.Raw)) != NULL) {
239 if (!IsValidCapsuleHeader((VOID *)(UINTN)HobPointer.Capsule->BaseAddress, HobPointer.Capsule->Length)) {
240 HobPointer.Header->HobType = EFI_HOB_TYPE_UNUSED; // Mark this hob as invalid
241 } else {
242 if (IsCapsuleNameCapsule((VOID *)(UINTN)HobPointer.Capsule->BaseAddress)) {
243 CapsuleNameCapsuleTotalNumber++;
244 } else {
245 mCapsuleTotalNumber++;
246 }
247 }
248 HobPointer.Raw = GET_NEXT_HOB (HobPointer);
249 }
250
251 DEBUG ((DEBUG_INFO, "mCapsuleTotalNumber - 0x%x\n", mCapsuleTotalNumber));
252
253 if (mCapsuleTotalNumber == 0) {
254 return ;
255 }
256
257 //
258 // Init temp Capsule Data table.
259 //
260 mCapsulePtr = (VOID **) AllocateZeroPool (sizeof (VOID *) * mCapsuleTotalNumber);
261 if (mCapsulePtr == NULL) {
262 DEBUG ((DEBUG_ERROR, "Allocate mCapsulePtr fail!\n"));
263 mCapsuleTotalNumber = 0;
264 return ;
265 }
266 mCapsuleStatusArray = (EFI_STATUS *) AllocateZeroPool (sizeof (EFI_STATUS) * mCapsuleTotalNumber);
267 if (mCapsuleStatusArray == NULL) {
268 DEBUG ((DEBUG_ERROR, "Allocate mCapsuleStatusArray fail!\n"));
269 FreePool (mCapsulePtr);
270 mCapsulePtr = NULL;
271 mCapsuleTotalNumber = 0;
272 return ;
273 }
274 SetMemN (mCapsuleStatusArray, sizeof (EFI_STATUS) * mCapsuleTotalNumber, EFI_NOT_READY);
275
276 CapsuleNameCapsulePtr = (VOID **) AllocateZeroPool (sizeof (VOID *) * CapsuleNameCapsuleTotalNumber);
277 if (CapsuleNameCapsulePtr == NULL) {
278 DEBUG ((DEBUG_ERROR, "Allocate CapsuleNameCapsulePtr fail!\n"));
279 FreePool (mCapsulePtr);
280 FreePool (mCapsuleStatusArray);
281 mCapsulePtr = NULL;
282 mCapsuleStatusArray = NULL;
283 mCapsuleTotalNumber = 0;
284 return ;
285 }
286
287 //
288 // Find all capsule images from hob
289 //
290 HobPointer.Raw = GetHobList ();
291 Index = 0;
292 Index2 = 0;
293 while ((HobPointer.Raw = GetNextHob (EFI_HOB_TYPE_UEFI_CAPSULE, HobPointer.Raw)) != NULL) {
294 if (IsCapsuleNameCapsule ((VOID *) (UINTN) HobPointer.Capsule->BaseAddress)) {
295 CapsuleNameCapsulePtr [Index2++] = (VOID *) (UINTN) HobPointer.Capsule->BaseAddress;
296 } else {
297 mCapsulePtr [Index++] = (VOID *) (UINTN) HobPointer.Capsule->BaseAddress;
298 }
299 HobPointer.Raw = GET_NEXT_HOB (HobPointer);
300 }
301
302 //
303 // Find Capsule On Disk Names
304 //
305 for (Index = 0; Index < CapsuleNameCapsuleTotalNumber; Index ++) {
306 CapsuleNameAddress = ValidateCapsuleNameCapsuleIntegrity (CapsuleNameCapsulePtr[Index], &CapsuleNameNumber);
307 if (CapsuleNameAddress != NULL ) {
308 CapsuleNameTotalNumber += CapsuleNameNumber;
309 }
310 }
311
312 if (CapsuleNameTotalNumber == mCapsuleTotalNumber) {
313 mCapsuleNamePtr = (CHAR16 **) AllocateZeroPool (sizeof (CHAR16 *) * mCapsuleTotalNumber);
314 if (mCapsuleNamePtr == NULL) {
315 DEBUG ((DEBUG_ERROR, "Allocate mCapsuleNamePtr fail!\n"));
316 FreePool (mCapsulePtr);
317 FreePool (mCapsuleStatusArray);
318 FreePool (CapsuleNameCapsulePtr);
319 mCapsulePtr = NULL;
320 mCapsuleStatusArray = NULL;
321 mCapsuleTotalNumber = 0;
322 return ;
323 }
324
325 for (Index = 0, Index3 = 0; Index < CapsuleNameCapsuleTotalNumber; Index ++) {
326 CapsuleNameAddress = ValidateCapsuleNameCapsuleIntegrity (CapsuleNameCapsulePtr[Index], &CapsuleNameNumber);
327 if (CapsuleNameAddress != NULL ) {
328 for (Index2 = 0; Index2 < CapsuleNameNumber; Index2 ++) {
329 mCapsuleNamePtr[Index3 ++] = (CHAR16 *)(UINTN) CapsuleNameAddress[Index2];
330 }
331 }
332 }
333 } else {
334 mCapsuleNamePtr = NULL;
335 }
336
337 FreePool (CapsuleNameCapsulePtr);
338}
339
340/**
341 This function returns if all capsule images are processed.
342
343 @retval TRUE All capsule images are processed.
344 @retval FALSE Not all capsule images are processed.
345**/
346BOOLEAN
347AreAllImagesProcessed (
348 VOID
349 )
350{
351 UINTN Index;
352
353 for (Index = 0; Index < mCapsuleTotalNumber; Index++) {
354 if (mCapsuleStatusArray[Index] == EFI_NOT_READY) {
355 return FALSE;
356 }
357 }
358
359 return TRUE;
360}
361
362/**
363 This function populates capsule in the configuration table.
364**/
365VOID
366PopulateCapsuleInConfigurationTable (
367 VOID
368 )
369{
370 VOID **CapsulePtrCache;
371 EFI_GUID *CapsuleGuidCache;
372 EFI_CAPSULE_HEADER *CapsuleHeader;
373 EFI_CAPSULE_TABLE *CapsuleTable;
374 UINT32 CacheIndex;
375 UINT32 CacheNumber;
376 UINT32 CapsuleNumber;
377 UINTN Index;
378 UINTN Size;
379 EFI_STATUS Status;
380
381 if (mCapsuleTotalNumber == 0) {
382 return ;
383 }
384
385 CapsulePtrCache = NULL;
386 CapsuleGuidCache = NULL;
387 CacheIndex = 0;
388 CacheNumber = 0;
389
390 CapsulePtrCache = (VOID **) AllocateZeroPool (sizeof (VOID *) * mCapsuleTotalNumber);
391 if (CapsulePtrCache == NULL) {
392 DEBUG ((DEBUG_ERROR, "Allocate CapsulePtrCache fail!\n"));
393 return ;
394 }
395 CapsuleGuidCache = (EFI_GUID *) AllocateZeroPool (sizeof (EFI_GUID) * mCapsuleTotalNumber);
396 if (CapsuleGuidCache == NULL) {
397 DEBUG ((DEBUG_ERROR, "Allocate CapsuleGuidCache fail!\n"));
398 FreePool (CapsulePtrCache);
399 return ;
400 }
401
402 //
403 // Capsules who have CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE always are used for operating
404 // System to have information persist across a system reset. EFI System Table must
405 // point to an array of capsules that contains the same CapsuleGuid value. And agents
406 // searching for this type capsule will look in EFI System Table and search for the
407 // capsule's Guid and associated pointer to retrieve the data. Two steps below describes
408 // how to sorting the capsules by the unique guid and install the array to EFI System Table.
409 // Firstly, Loop for all coalesced capsules, record unique CapsuleGuids and cache them in an
410 // array for later sorting capsules by CapsuleGuid.
411 //
412 for (Index = 0; Index < mCapsuleTotalNumber; Index++) {
413 CapsuleHeader = (EFI_CAPSULE_HEADER*) mCapsulePtr [Index];
414 if ((CapsuleHeader->Flags & CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE) != 0) {
415 //
416 // For each capsule, we compare it with known CapsuleGuid in the CacheArray.
417 // If already has the Guid, skip it. Whereas, record it in the CacheArray as
418 // an additional one.
419 //
420 CacheIndex = 0;
421 while (CacheIndex < CacheNumber) {
422 if (CompareGuid(&CapsuleGuidCache[CacheIndex],&CapsuleHeader->CapsuleGuid)) {
423 break;
424 }
425 CacheIndex++;
426 }
427 if (CacheIndex == CacheNumber) {
428 CopyMem(&CapsuleGuidCache[CacheNumber++],&CapsuleHeader->CapsuleGuid,sizeof(EFI_GUID));
429 }
430 }
431 }
432
433 //
434 // Secondly, for each unique CapsuleGuid in CacheArray, gather all coalesced capsules
435 // whose guid is the same as it, and malloc memory for an array which preceding
436 // with UINT32. The array fills with entry point of capsules that have the same
437 // CapsuleGuid, and UINT32 represents the size of the array of capsules. Then install
438 // this array into EFI System Table, so that agents searching for this type capsule
439 // will look in EFI System Table and search for the capsule's Guid and associated
440 // pointer to retrieve the data.
441 //
442 for (CacheIndex = 0; CacheIndex < CacheNumber; CacheIndex++) {
443 CapsuleNumber = 0;
444 for (Index = 0; Index < mCapsuleTotalNumber; Index++) {
445 CapsuleHeader = (EFI_CAPSULE_HEADER*) mCapsulePtr [Index];
446 if ((CapsuleHeader->Flags & CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE) != 0) {
447 if (CompareGuid (&CapsuleGuidCache[CacheIndex], &CapsuleHeader->CapsuleGuid)) {
448 //
449 // Cache Caspuleheader to the array, this array is uniqued with certain CapsuleGuid.
450 //
451 CapsulePtrCache[CapsuleNumber++] = (VOID*)CapsuleHeader;
452 }
453 }
454 }
455 if (CapsuleNumber != 0) {
456 Size = sizeof(EFI_CAPSULE_TABLE) + (CapsuleNumber - 1) * sizeof(VOID*);
457 CapsuleTable = AllocateRuntimePool (Size);
458 if (CapsuleTable == NULL) {
459 DEBUG ((DEBUG_ERROR, "Allocate CapsuleTable (%g) fail!\n", &CapsuleGuidCache[CacheIndex]));
460 continue;
461 }
462 CapsuleTable->CapsuleArrayNumber = CapsuleNumber;
463 CopyMem(&CapsuleTable->CapsulePtr[0], CapsulePtrCache, CapsuleNumber * sizeof(VOID*));
464 Status = gBS->InstallConfigurationTable (&CapsuleGuidCache[CacheIndex], (VOID*)CapsuleTable);
465 if (EFI_ERROR (Status)) {
466 DEBUG ((DEBUG_ERROR, "InstallConfigurationTable (%g) fail!\n", &CapsuleGuidCache[CacheIndex]));
467 }
468 }
469 }
470
471 FreePool(CapsuleGuidCache);
472 FreePool(CapsulePtrCache);
473}
474
475/**
476
477 This routine is called to process capsules.
478
479 Caution: This function may receive untrusted input.
480
481 Each individual capsule result is recorded in capsule record variable.
482
483 @param[in] FirstRound TRUE: First round. Need skip the FMP capsules with non zero EmbeddedDriverCount.
484 FALSE: Process rest FMP capsules.
485
486 @retval EFI_SUCCESS There is no error when processing capsules.
487 @retval EFI_OUT_OF_RESOURCES No enough resource to process capsules.
488
489**/
490EFI_STATUS
491ProcessTheseCapsules (
492 IN BOOLEAN FirstRound
493 )
494{
495 EFI_STATUS Status;
496 EFI_CAPSULE_HEADER *CapsuleHeader;
497 UINT32 Index;
498 ESRT_MANAGEMENT_PROTOCOL *EsrtManagement;
499 UINT16 EmbeddedDriverCount;
500 BOOLEAN ResetRequired;
501 CHAR16 *CapsuleName;
502
503 REPORT_STATUS_CODE(EFI_PROGRESS_CODE, (EFI_SOFTWARE | PcdGet32(PcdStatusCodeSubClassCapsule) | PcdGet32(PcdCapsuleStatusCodeProcessCapsulesBegin)));
504
505 if (FirstRound) {
506 InitCapsulePtr ();
507 }
508
509 if (mCapsuleTotalNumber == 0) {
510 //
511 // We didn't find a hob, so had no errors.
512 //
513 DEBUG ((DEBUG_ERROR, "We can not find capsule data in capsule update boot mode.\n"));
514 mNeedReset = TRUE;
515 return EFI_SUCCESS;
516 }
517
518 if (AreAllImagesProcessed ()) {
519 return EFI_SUCCESS;
520 }
521
522 //
523 // Check the capsule flags,if contains CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE, install
524 // capsuleTable to configure table with EFI_CAPSULE_GUID
525 //
526 if (FirstRound) {
527 PopulateCapsuleInConfigurationTable ();
528 }
529
530 REPORT_STATUS_CODE(EFI_PROGRESS_CODE, (EFI_SOFTWARE | PcdGet32(PcdStatusCodeSubClassCapsule) | PcdGet32(PcdCapsuleStatusCodeUpdatingFirmware)));
531
532 //
533 // If Windows UX capsule exist, process it first
534 //
535 for (Index = 0; Index < mCapsuleTotalNumber; Index++) {
536 CapsuleHeader = (EFI_CAPSULE_HEADER*) mCapsulePtr [Index];
537 CapsuleName = (mCapsuleNamePtr == NULL) ? NULL : mCapsuleNamePtr[Index];
538 if (CompareGuid (&CapsuleHeader->CapsuleGuid, &gWindowsUxCapsuleGuid)) {
539 DEBUG ((DEBUG_INFO, "ProcessThisCapsuleImage (Ux) - 0x%x\n", CapsuleHeader));
540 DEBUG ((DEBUG_INFO, "Display logo capsule is found.\n"));
541 Status = ProcessThisCapsuleImage (CapsuleHeader, CapsuleName, NULL);
542 mCapsuleStatusArray [Index] = EFI_SUCCESS;
543 DEBUG((DEBUG_INFO, "ProcessThisCapsuleImage (Ux) - %r\n", Status));
544 break;
545 }
546 }
547
548 DEBUG ((DEBUG_INFO, "Updating the firmware ......\n"));
549
550 //
551 // All capsules left are recognized by platform.
552 //
553 for (Index = 0; Index < mCapsuleTotalNumber; Index++) {
554 if (mCapsuleStatusArray [Index] != EFI_NOT_READY) {
555 // already processed
556 continue;
557 }
558 CapsuleHeader = (EFI_CAPSULE_HEADER*) mCapsulePtr [Index];
559 CapsuleName = (mCapsuleNamePtr == NULL) ? NULL : mCapsuleNamePtr[Index];
560 if (!CompareGuid (&CapsuleHeader->CapsuleGuid, &gWindowsUxCapsuleGuid)) {
561 //
562 // Call capsule library to process capsule image.
563 //
564 EmbeddedDriverCount = 0;
565 if (IsFmpCapsule(CapsuleHeader)) {
566 Status = ValidateFmpCapsule (CapsuleHeader, &EmbeddedDriverCount);
567 if (EFI_ERROR(Status)) {
568 DEBUG((DEBUG_ERROR, "ValidateFmpCapsule failed. Ignore!\n"));
569 mCapsuleStatusArray [Index] = EFI_ABORTED;
570 continue;
571 }
572 } else {
573 mCapsuleStatusArray [Index] = EFI_ABORTED;
574 continue;
575 }
576
577 if ((!FirstRound) || (EmbeddedDriverCount == 0)) {
578 DEBUG((DEBUG_INFO, "ProcessThisCapsuleImage - 0x%x\n", CapsuleHeader));
579 ResetRequired = FALSE;
580 Status = ProcessThisCapsuleImage (CapsuleHeader, CapsuleName, &ResetRequired);
581 mCapsuleStatusArray [Index] = Status;
582 DEBUG((DEBUG_INFO, "ProcessThisCapsuleImage - %r\n", Status));
583
584 if (Status != EFI_NOT_READY) {
585 if (EFI_ERROR(Status)) {
586 REPORT_STATUS_CODE(EFI_ERROR_CODE, (EFI_SOFTWARE | PcdGet32(PcdStatusCodeSubClassCapsule) | PcdGet32(PcdCapsuleStatusCodeUpdateFirmwareFailed)));
587 DEBUG ((DEBUG_ERROR, "Capsule process failed!\n"));
588 } else {
589 REPORT_STATUS_CODE(EFI_PROGRESS_CODE, (EFI_SOFTWARE | PcdGet32(PcdStatusCodeSubClassCapsule) | PcdGet32(PcdCapsuleStatusCodeUpdateFirmwareSuccess)));
590 }
591
592 mNeedReset |= ResetRequired;
593 if ((CapsuleHeader->Flags & PcdGet16(PcdSystemRebootAfterCapsuleProcessFlag)) != 0) {
594 mNeedReset = TRUE;
595 }
596 }
597 }
598 }
599 }
600
601 Status = gBS->LocateProtocol(&gEsrtManagementProtocolGuid, NULL, (VOID **)&EsrtManagement);
602 //
603 // Always sync ESRT Cache from FMP Instance
604 //
605 if (!EFI_ERROR(Status)) {
606 EsrtManagement->SyncEsrtFmp();
607 }
608 Status = EFI_SUCCESS;
609
610 REPORT_STATUS_CODE(EFI_PROGRESS_CODE, (EFI_SOFTWARE | PcdGet32(PcdStatusCodeSubClassCapsule) | PcdGet32(PcdCapsuleStatusCodeProcessCapsulesEnd)));
611
612 return Status;
613}
614
615/**
616 Do reset system.
617**/
618VOID
619DoResetSystem (
620 VOID
621 )
622{
623 DEBUG((DEBUG_INFO, "Capsule Request Cold Reboot."));
624
625 REPORT_STATUS_CODE(EFI_PROGRESS_CODE, (EFI_SOFTWARE | PcdGet32(PcdStatusCodeSubClassCapsule) | PcdGet32(PcdCapsuleStatusCodeResettingSystem)));
626
627 gRT->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL);
628
629 CpuDeadLoop();
630}
631
632/**
633
634 This routine is called to process capsules.
635
636 Caution: This function may receive untrusted input.
637
638 The capsules reported in EFI_HOB_UEFI_CAPSULE are processed.
639 If there is no EFI_HOB_UEFI_CAPSULE, it means error occurs, force reset to
640 normal boot path.
641
642 This routine should be called twice in BDS.
643 1) The first call must be before EndOfDxe. The system capsules is processed.
644 If device capsule FMP protocols are exposted at this time and device FMP
645 capsule has zero EmbeddedDriverCount, the device capsules are processed.
646 Each individual capsule result is recorded in capsule record variable.
647 System may reset in this function, if reset is required by capsule and
648 all capsules are processed.
649 If not all capsules are processed, reset will be defered to second call.
650
651 2) The second call must be after EndOfDxe and after ConnectAll, so that all
652 device capsule FMP protocols are exposed.
653 The system capsules are skipped. If the device capsules are NOT processed
654 in first call, they are processed here.
655 Each individual capsule result is recorded in capsule record variable.
656 System may reset in this function, if reset is required by capsule
657 processed in first call and second call.
658
659 @retval EFI_SUCCESS There is no error when processing capsules.
660 @retval EFI_OUT_OF_RESOURCES No enough resource to process capsules.
661
662**/
663EFI_STATUS
664EFIAPI
665ProcessCapsules (
666 VOID
667 )
668{
669 EFI_STATUS Status;
670
671 if (!mDxeCapsuleLibEndOfDxe) {
672 Status = ProcessTheseCapsules(TRUE);
673
674 //
675 // Reboot System if and only if all capsule processed.
676 // If not, defer reset to 2nd process.
677 //
678 if (mNeedReset && AreAllImagesProcessed()) {
679 DoResetSystem();
680 }
681 } else {
682 Status = ProcessTheseCapsules(FALSE);
683 //
684 // Reboot System if required after all capsule processed
685 //
686 if (mNeedReset) {
687 DoResetSystem();
688 }
689 }
690 return Status;
691}
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