VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/DxeCapsuleLibFmp/DxeCapsuleLib.c@ 85716

最後變更 在這個檔案從85716是 80721,由 vboxsync 提交於 6 年 前

Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
  • 屬性 svn:eol-style 設為 native
檔案大小: 53.7 KB
行 
1/** @file
2 DXE capsule library.
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 SupportCapsuleImage(), ProcessCapsuleImage(), IsValidCapsuleHeader(),
10 ValidateFmpCapsule(), and DisplayCapsuleImage() receives untrusted input and
11 performs basic validation.
12
13 Copyright (c) 2016 - 2019, Intel Corporation. All rights reserved.<BR>
14 SPDX-License-Identifier: BSD-2-Clause-Patent
15
16**/
17
18#include <PiDxe.h>
19
20#include <IndustryStandard/WindowsUxCapsule.h>
21
22#include <Guid/FmpCapsule.h>
23#include <Guid/SystemResourceTable.h>
24#include <Guid/EventGroup.h>
25
26#include <Library/BaseLib.h>
27#include <Library/DebugLib.h>
28#include <Library/BaseMemoryLib.h>
29#include <Library/DxeServicesTableLib.h>
30#include <Library/UefiBootServicesTableLib.h>
31#include <Library/UefiRuntimeServicesTableLib.h>
32#include <Library/MemoryAllocationLib.h>
33#include <Library/CapsuleLib.h>
34#include <Library/DevicePathLib.h>
35#include <Library/UefiLib.h>
36#include <Library/BmpSupportLib.h>
37
38#include <Protocol/GraphicsOutput.h>
39#include <Protocol/EsrtManagement.h>
40#include <Protocol/FirmwareManagement.h>
41#include <Protocol/FirmwareManagementProgress.h>
42#include <Protocol/DevicePath.h>
43
44EFI_SYSTEM_RESOURCE_TABLE *mEsrtTable = NULL;
45BOOLEAN mIsVirtualAddrConverted = FALSE;
46
47BOOLEAN mDxeCapsuleLibEndOfDxe = FALSE;
48EFI_EVENT mDxeCapsuleLibEndOfDxeEvent = NULL;
49
50EDKII_FIRMWARE_MANAGEMENT_PROGRESS_PROTOCOL *mFmpProgress = NULL;
51
52/**
53 Initialize capsule related variables.
54**/
55VOID
56InitCapsuleVariable (
57 VOID
58 );
59
60/**
61 Record capsule status variable.
62
63 @param[in] CapsuleHeader The capsule image header
64 @param[in] CapsuleStatus The capsule process stauts
65
66 @retval EFI_SUCCESS The capsule status variable is recorded.
67 @retval EFI_OUT_OF_RESOURCES No resource to record the capsule status variable.
68**/
69EFI_STATUS
70RecordCapsuleStatusVariable (
71 IN EFI_CAPSULE_HEADER *CapsuleHeader,
72 IN EFI_STATUS CapsuleStatus
73 );
74
75/**
76 Record FMP capsule status variable.
77
78 @param[in] CapsuleHeader The capsule image header
79 @param[in] CapsuleStatus The capsule process stauts
80 @param[in] PayloadIndex FMP payload index
81 @param[in] ImageHeader FMP image header
82 @param[in] FmpDevicePath DevicePath associated with the FMP producer
83 @param[in] CapFileName Capsule file name
84
85 @retval EFI_SUCCESS The capsule status variable is recorded.
86 @retval EFI_OUT_OF_RESOURCES No resource to record the capsule status variable.
87**/
88EFI_STATUS
89RecordFmpCapsuleStatusVariable (
90 IN EFI_CAPSULE_HEADER *CapsuleHeader,
91 IN EFI_STATUS CapsuleStatus,
92 IN UINTN PayloadIndex,
93 IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader,
94 IN EFI_DEVICE_PATH_PROTOCOL *FmpDevicePath, OPTIONAL
95 IN CHAR16 *CapFileName OPTIONAL
96 );
97
98/**
99 Function indicate the current completion progress of the firmware
100 update. Platform may override with own specific progress function.
101
102 @param[in] Completion A value between 1 and 100 indicating the current
103 completion progress of the firmware update
104
105 @retval EFI_SUCESS The capsule update progress was updated.
106 @retval EFI_INVALID_PARAMETER Completion is greater than 100%.
107**/
108EFI_STATUS
109EFIAPI
110UpdateImageProgress (
111 IN UINTN Completion
112 );
113
114/**
115 Return if this capsule is a capsule name capsule, based upon CapsuleHeader.
116
117 @param[in] CapsuleHeader A pointer to EFI_CAPSULE_HEADER
118
119 @retval TRUE It is a capsule name capsule.
120 @retval FALSE It is not a capsule name capsule.
121**/
122BOOLEAN
123IsCapsuleNameCapsule (
124 IN EFI_CAPSULE_HEADER *CapsuleHeader
125 )
126{
127 return CompareGuid (&CapsuleHeader->CapsuleGuid, &gEdkiiCapsuleOnDiskNameGuid);
128}
129
130/**
131 Return if this CapsuleGuid is a FMP capsule GUID or not.
132
133 @param[in] CapsuleGuid A pointer to EFI_GUID
134
135 @retval TRUE It is a FMP capsule GUID.
136 @retval FALSE It is not a FMP capsule GUID.
137**/
138BOOLEAN
139IsFmpCapsuleGuid (
140 IN EFI_GUID *CapsuleGuid
141 )
142{
143 if (CompareGuid(&gEfiFmpCapsuleGuid, CapsuleGuid)) {
144 return TRUE;
145 }
146
147 return FALSE;
148}
149
150/**
151 Validate if it is valid capsule header
152
153 Caution: This function may receive untrusted input.
154
155 This function assumes the caller provided correct CapsuleHeader pointer
156 and CapsuleSize.
157
158 This function validates the fields in EFI_CAPSULE_HEADER.
159
160 @param[in] CapsuleHeader Points to a capsule header.
161 @param[in] CapsuleSize Size of the whole capsule image.
162
163**/
164BOOLEAN
165IsValidCapsuleHeader (
166 IN EFI_CAPSULE_HEADER *CapsuleHeader,
167 IN UINT64 CapsuleSize
168 )
169{
170 if (CapsuleHeader->CapsuleImageSize != CapsuleSize) {
171 return FALSE;
172 }
173 if (CapsuleHeader->HeaderSize >= CapsuleHeader->CapsuleImageSize) {
174 return FALSE;
175 }
176 return TRUE;
177}
178
179/**
180 Validate Fmp capsules layout.
181
182 Caution: This function may receive untrusted input.
183
184 This function assumes the caller validated the capsule by using
185 IsValidCapsuleHeader(), so that all fields in EFI_CAPSULE_HEADER are correct.
186 The capsule buffer size is CapsuleHeader->CapsuleImageSize.
187
188 This function validates the fields in EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER
189 and EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER.
190
191 This function need support nested FMP capsule.
192
193 @param[in] CapsuleHeader Points to a capsule header.
194 @param[out] EmbeddedDriverCount The EmbeddedDriverCount in the FMP capsule.
195
196 @retval EFI_SUCESS Input capsule is a correct FMP capsule.
197 @retval EFI_INVALID_PARAMETER Input capsule is not a correct FMP capsule.
198**/
199EFI_STATUS
200ValidateFmpCapsule (
201 IN EFI_CAPSULE_HEADER *CapsuleHeader,
202 OUT UINT16 *EmbeddedDriverCount OPTIONAL
203 )
204{
205 EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *FmpCapsuleHeader;
206 UINT8 *EndOfCapsule;
207 EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader;
208 UINT8 *EndOfPayload;
209 UINT64 *ItemOffsetList;
210 UINT32 ItemNum;
211 UINTN Index;
212 UINTN FmpCapsuleSize;
213 UINTN FmpCapsuleHeaderSize;
214 UINT64 FmpImageSize;
215 UINTN FmpImageHeaderSize;
216
217 if (!IsFmpCapsuleGuid(&CapsuleHeader->CapsuleGuid)) {
218 return ValidateFmpCapsule ((EFI_CAPSULE_HEADER *)((UINTN)CapsuleHeader + CapsuleHeader->HeaderSize), EmbeddedDriverCount);
219 }
220
221 if (CapsuleHeader->HeaderSize >= CapsuleHeader->CapsuleImageSize) {
222 DEBUG((DEBUG_ERROR, "HeaderSize(0x%x) >= CapsuleImageSize(0x%x)\n", CapsuleHeader->HeaderSize, CapsuleHeader->CapsuleImageSize));
223 return EFI_INVALID_PARAMETER;
224 }
225
226 FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *) ((UINT8 *) CapsuleHeader + CapsuleHeader->HeaderSize);
227 EndOfCapsule = (UINT8 *) CapsuleHeader + CapsuleHeader->CapsuleImageSize;
228 FmpCapsuleSize = (UINTN)EndOfCapsule - (UINTN)FmpCapsuleHeader;
229
230 if (FmpCapsuleSize < sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER)) {
231 DEBUG((DEBUG_ERROR, "FmpCapsuleSize(0x%x) < EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER\n", FmpCapsuleSize));
232 return EFI_INVALID_PARAMETER;
233 }
234
235 // Check EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER
236 if (FmpCapsuleHeader->Version != EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION) {
237 DEBUG((DEBUG_ERROR, "FmpCapsuleHeader->Version(0x%x) != EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION\n", FmpCapsuleHeader->Version));
238 return EFI_INVALID_PARAMETER;
239 }
240 ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
241
242 // No overflow
243 ItemNum = FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount;
244
245 if ((FmpCapsuleSize - sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER))/sizeof(UINT64) < ItemNum) {
246 DEBUG((DEBUG_ERROR, "ItemNum(0x%x) too big\n", ItemNum));
247 return EFI_INVALID_PARAMETER;
248 }
249 FmpCapsuleHeaderSize = sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER) + sizeof(UINT64)*ItemNum;
250
251 // Check ItemOffsetList
252 for (Index = 0; Index < ItemNum; Index++) {
253 if (ItemOffsetList[Index] >= FmpCapsuleSize) {
254 DEBUG((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) >= FmpCapsuleSize(0x%x)\n", Index, ItemOffsetList[Index], FmpCapsuleSize));
255 return EFI_INVALID_PARAMETER;
256 }
257 if (ItemOffsetList[Index] < FmpCapsuleHeaderSize) {
258 DEBUG((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) < FmpCapsuleHeaderSize(0x%x)\n", Index, ItemOffsetList[Index], FmpCapsuleHeaderSize));
259 return EFI_INVALID_PARAMETER;
260 }
261 //
262 // All the address in ItemOffsetList must be stored in ascending order
263 //
264 if (Index > 0) {
265 if (ItemOffsetList[Index] <= ItemOffsetList[Index - 1]) {
266 DEBUG((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) < ItemOffsetList[%d](0x%x)\n", Index, ItemOffsetList[Index], Index - 1, ItemOffsetList[Index - 1]));
267 return EFI_INVALID_PARAMETER;
268 }
269 }
270 }
271
272 // Check EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER
273 for (Index = FmpCapsuleHeader->EmbeddedDriverCount; Index < ItemNum; Index++) {
274 ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]);
275 if (Index == ItemNum - 1) {
276 EndOfPayload = (UINT8 *)((UINTN)EndOfCapsule - (UINTN)FmpCapsuleHeader);
277 } else {
278 EndOfPayload = (UINT8 *)(UINTN)ItemOffsetList[Index+1];
279 }
280 FmpImageSize = (UINTN)EndOfPayload - ItemOffsetList[Index];
281
282 FmpImageHeaderSize = sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER);
283 if ((ImageHeader->Version > EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) ||
284 (ImageHeader->Version < 1)) {
285 DEBUG((DEBUG_ERROR, "ImageHeader->Version(0x%x) Unknown\n", ImageHeader->Version));
286 return EFI_INVALID_PARAMETER;
287 }
288 if (ImageHeader->Version < EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) {
289 FmpImageHeaderSize = OFFSET_OF(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, UpdateHardwareInstance);
290 }
291 if (FmpImageSize < FmpImageHeaderSize) {
292 DEBUG((DEBUG_ERROR, "FmpImageSize(0x%lx) < FmpImageHeaderSize(0x%x)\n", FmpImageSize, FmpImageHeaderSize));
293 return EFI_INVALID_PARAMETER;
294 }
295
296 // No overflow
297 if (FmpImageSize != (UINT64)FmpImageHeaderSize + (UINT64)ImageHeader->UpdateImageSize + (UINT64)ImageHeader->UpdateVendorCodeSize) {
298 DEBUG((DEBUG_ERROR, "FmpImageSize(0x%lx) mismatch, UpdateImageSize(0x%x) UpdateVendorCodeSize(0x%x)\n", FmpImageSize, ImageHeader->UpdateImageSize, ImageHeader->UpdateVendorCodeSize));
299 return EFI_INVALID_PARAMETER;
300 }
301 }
302
303 if (ItemNum == 0) {
304 //
305 // No driver & payload element in FMP
306 //
307 EndOfPayload = (UINT8 *)(FmpCapsuleHeader + 1);
308 if (EndOfPayload != EndOfCapsule) {
309 DEBUG((DEBUG_ERROR, "EndOfPayload(0x%x) mismatch, EndOfCapsule(0x%x)\n", EndOfPayload, EndOfCapsule));
310 return EFI_INVALID_PARAMETER;
311 }
312 return EFI_UNSUPPORTED;
313 }
314
315 if (EmbeddedDriverCount != NULL) {
316 *EmbeddedDriverCount = FmpCapsuleHeader->EmbeddedDriverCount;
317 }
318
319 return EFI_SUCCESS;
320}
321
322/**
323 Those capsules supported by the firmwares.
324
325 Caution: This function may receive untrusted input.
326
327 @param[in] CapsuleHeader Points to a capsule header.
328
329 @retval EFI_SUCESS Input capsule is supported by firmware.
330 @retval EFI_UNSUPPORTED Input capsule is not supported by the firmware.
331**/
332EFI_STATUS
333DisplayCapsuleImage (
334 IN EFI_CAPSULE_HEADER *CapsuleHeader
335 )
336{
337 DISPLAY_DISPLAY_PAYLOAD *ImagePayload;
338 UINTN PayloadSize;
339 EFI_STATUS Status;
340 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
341 UINTN BltSize;
342 UINTN Height;
343 UINTN Width;
344 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
345
346 //
347 // UX capsule doesn't have extended header entries.
348 //
349 if (CapsuleHeader->HeaderSize != sizeof (EFI_CAPSULE_HEADER)) {
350 return EFI_UNSUPPORTED;
351 }
352 ImagePayload = (DISPLAY_DISPLAY_PAYLOAD *)((UINTN) CapsuleHeader + CapsuleHeader->HeaderSize);
353 //
354 // (CapsuleImageSize > HeaderSize) is guaranteed by IsValidCapsuleHeader().
355 //
356 PayloadSize = CapsuleHeader->CapsuleImageSize - CapsuleHeader->HeaderSize;
357
358 //
359 // Make sure the image payload at least contain the DISPLAY_DISPLAY_PAYLOAD header.
360 // Further size check is performed by the logic translating BMP to GOP BLT.
361 //
362 if (PayloadSize <= sizeof (DISPLAY_DISPLAY_PAYLOAD)) {
363 return EFI_INVALID_PARAMETER;
364 }
365
366 if (ImagePayload->Version != 1) {
367 return EFI_UNSUPPORTED;
368 }
369 if (CalculateCheckSum8((UINT8 *)CapsuleHeader, CapsuleHeader->CapsuleImageSize) != 0) {
370 return EFI_UNSUPPORTED;
371 }
372 //
373 // Only Support Bitmap by now
374 //
375 if (ImagePayload->ImageType != 0) {
376 return EFI_UNSUPPORTED;
377 }
378
379 //
380 // Try to open GOP
381 //
382 Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiGraphicsOutputProtocolGuid, (VOID **)&GraphicsOutput);
383 if (EFI_ERROR (Status)) {
384 Status = gBS->LocateProtocol(&gEfiGraphicsOutputProtocolGuid, NULL, (VOID **)&GraphicsOutput);
385 if (EFI_ERROR(Status)) {
386 return EFI_UNSUPPORTED;
387 }
388 }
389
390 if (GraphicsOutput->Mode->Mode != ImagePayload->Mode) {
391 return EFI_UNSUPPORTED;
392 }
393
394 Blt = NULL;
395 Width = 0;
396 Height = 0;
397 Status = TranslateBmpToGopBlt (
398 ImagePayload + 1,
399 PayloadSize - sizeof(DISPLAY_DISPLAY_PAYLOAD),
400 &Blt,
401 &BltSize,
402 &Height,
403 &Width
404 );
405
406 if (EFI_ERROR (Status)) {
407 return Status;
408 }
409
410 Status = GraphicsOutput->Blt (
411 GraphicsOutput,
412 Blt,
413 EfiBltBufferToVideo,
414 0,
415 0,
416 (UINTN) ImagePayload->OffsetX,
417 (UINTN) ImagePayload->OffsetY,
418 Width,
419 Height,
420 Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
421 );
422
423 FreePool(Blt);
424
425 return Status;
426}
427
428/**
429 Dump FMP information.
430
431 @param[in] ImageInfoSize The size of ImageInfo, in bytes.
432 @param[in] ImageInfo A pointer to EFI_FIRMWARE_IMAGE_DESCRIPTOR.
433 @param[in] DescriptorVersion The version of EFI_FIRMWARE_IMAGE_DESCRIPTOR.
434 @param[in] DescriptorCount The count of EFI_FIRMWARE_IMAGE_DESCRIPTOR.
435 @param[in] DescriptorSize The size of an individual EFI_FIRMWARE_IMAGE_DESCRIPTOR, in bytes.
436 @param[in] PackageVersion The version of package.
437 @param[in] PackageVersionName The version name of package.
438**/
439VOID
440DumpFmpImageInfo (
441 IN UINTN ImageInfoSize,
442 IN EFI_FIRMWARE_IMAGE_DESCRIPTOR *ImageInfo,
443 IN UINT32 DescriptorVersion,
444 IN UINT8 DescriptorCount,
445 IN UINTN DescriptorSize,
446 IN UINT32 PackageVersion,
447 IN CHAR16 *PackageVersionName
448 )
449{
450 EFI_FIRMWARE_IMAGE_DESCRIPTOR *CurrentImageInfo;
451 UINTN Index;
452
453 DEBUG((DEBUG_VERBOSE, " DescriptorVersion - 0x%x\n", DescriptorVersion));
454 DEBUG((DEBUG_VERBOSE, " DescriptorCount - 0x%x\n", DescriptorCount));
455 DEBUG((DEBUG_VERBOSE, " DescriptorSize - 0x%x\n", DescriptorSize));
456 DEBUG((DEBUG_VERBOSE, " PackageVersion - 0x%x\n", PackageVersion));
457 DEBUG((DEBUG_VERBOSE, " PackageVersionName - %s\n\n", PackageVersionName));
458 CurrentImageInfo = ImageInfo;
459 for (Index = 0; Index < DescriptorCount; Index++) {
460 DEBUG((DEBUG_VERBOSE, " ImageDescriptor (%d)\n", Index));
461 DEBUG((DEBUG_VERBOSE, " ImageIndex - 0x%x\n", CurrentImageInfo->ImageIndex));
462 DEBUG((DEBUG_VERBOSE, " ImageTypeId - %g\n", &CurrentImageInfo->ImageTypeId));
463 DEBUG((DEBUG_VERBOSE, " ImageId - 0x%lx\n", CurrentImageInfo->ImageId));
464 DEBUG((DEBUG_VERBOSE, " ImageIdName - %s\n", CurrentImageInfo->ImageIdName));
465 DEBUG((DEBUG_VERBOSE, " Version - 0x%x\n", CurrentImageInfo->Version));
466 DEBUG((DEBUG_VERBOSE, " VersionName - %s\n", CurrentImageInfo->VersionName));
467 DEBUG((DEBUG_VERBOSE, " Size - 0x%x\n", CurrentImageInfo->Size));
468 DEBUG((DEBUG_VERBOSE, " AttributesSupported - 0x%lx\n", CurrentImageInfo->AttributesSupported));
469 DEBUG((DEBUG_VERBOSE, " AttributesSetting - 0x%lx\n", CurrentImageInfo->AttributesSetting));
470 DEBUG((DEBUG_VERBOSE, " Compatibilities - 0x%lx\n", CurrentImageInfo->Compatibilities));
471 if (DescriptorVersion > 1) {
472 DEBUG((DEBUG_VERBOSE, " LowestSupportedImageVersion - 0x%x\n", CurrentImageInfo->LowestSupportedImageVersion));
473 if (DescriptorVersion > 2) {
474 DEBUG((DEBUG_VERBOSE, " LastAttemptVersion - 0x%x\n", CurrentImageInfo->LastAttemptVersion));
475 DEBUG((DEBUG_VERBOSE, " LastAttemptStatus - 0x%x\n", CurrentImageInfo->LastAttemptStatus));
476 DEBUG((DEBUG_VERBOSE, " HardwareInstance - 0x%lx\n", CurrentImageInfo->HardwareInstance));
477 }
478 }
479 //
480 // Use DescriptorSize to move ImageInfo Pointer to stay compatible with different ImageInfo version
481 //
482 CurrentImageInfo = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)((UINT8 *)CurrentImageInfo + DescriptorSize);
483 }
484}
485
486/**
487 Dump a non-nested FMP capsule.
488
489 @param[in] CapsuleHeader A pointer to CapsuleHeader
490**/
491VOID
492DumpFmpCapsule (
493 IN EFI_CAPSULE_HEADER *CapsuleHeader
494 )
495{
496 EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *FmpCapsuleHeader;
497 EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader;
498 UINTN Index;
499 UINT64 *ItemOffsetList;
500
501 FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *)((UINT8 *)CapsuleHeader + CapsuleHeader->HeaderSize);
502
503 DEBUG((DEBUG_VERBOSE, "FmpCapsule:\n"));
504 DEBUG((DEBUG_VERBOSE, " Version - 0x%x\n", FmpCapsuleHeader->Version));
505 DEBUG((DEBUG_VERBOSE, " EmbeddedDriverCount - 0x%x\n", FmpCapsuleHeader->EmbeddedDriverCount));
506 DEBUG((DEBUG_VERBOSE, " PayloadItemCount - 0x%x\n", FmpCapsuleHeader->PayloadItemCount));
507
508 ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
509 for (Index = 0; Index < FmpCapsuleHeader->EmbeddedDriverCount; Index++) {
510 DEBUG((DEBUG_VERBOSE, " ItemOffsetList[%d] - 0x%lx\n", Index, ItemOffsetList[Index]));
511 }
512 for (; Index < (UINT32)FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount; Index++) {
513 DEBUG((DEBUG_VERBOSE, " ItemOffsetList[%d] - 0x%lx\n", Index, ItemOffsetList[Index]));
514 ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]);
515
516 DEBUG((DEBUG_VERBOSE, " ImageHeader:\n"));
517 DEBUG((DEBUG_VERBOSE, " Version - 0x%x\n", ImageHeader->Version));
518 DEBUG((DEBUG_VERBOSE, " UpdateImageTypeId - %g\n", &ImageHeader->UpdateImageTypeId));
519 DEBUG((DEBUG_VERBOSE, " UpdateImageIndex - 0x%x\n", ImageHeader->UpdateImageIndex));
520 DEBUG((DEBUG_VERBOSE, " UpdateImageSize - 0x%x\n", ImageHeader->UpdateImageSize));
521 DEBUG((DEBUG_VERBOSE, " UpdateVendorCodeSize - 0x%x\n", ImageHeader->UpdateVendorCodeSize));
522 if (ImageHeader->Version >= EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) {
523 DEBUG((DEBUG_VERBOSE, " UpdateHardwareInstance - 0x%lx\n", ImageHeader->UpdateHardwareInstance));
524 }
525 }
526}
527
528/**
529 Dump all FMP information.
530**/
531VOID
532DumpAllFmpInfo (
533 VOID
534 )
535{
536 EFI_STATUS Status;
537 EFI_HANDLE *HandleBuffer;
538 UINTN NumberOfHandles;
539 EFI_FIRMWARE_MANAGEMENT_PROTOCOL *Fmp;
540 UINTN Index;
541 UINTN ImageInfoSize;
542 EFI_FIRMWARE_IMAGE_DESCRIPTOR *FmpImageInfoBuf;
543 UINT32 FmpImageInfoDescriptorVer;
544 UINT8 FmpImageInfoCount;
545 UINTN DescriptorSize;
546 UINT32 PackageVersion;
547 CHAR16 *PackageVersionName;
548
549 Status = gBS->LocateHandleBuffer (
550 ByProtocol,
551 &gEfiFirmwareManagementProtocolGuid,
552 NULL,
553 &NumberOfHandles,
554 &HandleBuffer
555 );
556 if (EFI_ERROR(Status)) {
557 return ;
558 }
559
560 for (Index = 0; Index < NumberOfHandles; Index++) {
561 Status = gBS->HandleProtocol(
562 HandleBuffer[Index],
563 &gEfiFirmwareManagementProtocolGuid,
564 (VOID **)&Fmp
565 );
566 if (EFI_ERROR(Status)) {
567 continue;
568 }
569
570 ImageInfoSize = 0;
571 Status = Fmp->GetImageInfo (
572 Fmp,
573 &ImageInfoSize,
574 NULL,
575 NULL,
576 NULL,
577 NULL,
578 NULL,
579 NULL
580 );
581 if (Status != EFI_BUFFER_TOO_SMALL) {
582 continue;
583 }
584
585 FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);
586 if (FmpImageInfoBuf == NULL) {
587 continue;
588 }
589
590 PackageVersionName = NULL;
591 Status = Fmp->GetImageInfo (
592 Fmp,
593 &ImageInfoSize, // ImageInfoSize
594 FmpImageInfoBuf, // ImageInfo
595 &FmpImageInfoDescriptorVer, // DescriptorVersion
596 &FmpImageInfoCount, // DescriptorCount
597 &DescriptorSize, // DescriptorSize
598 &PackageVersion, // PackageVersion
599 &PackageVersionName // PackageVersionName
600 );
601 if (EFI_ERROR(Status)) {
602 FreePool(FmpImageInfoBuf);
603 continue;
604 }
605
606 DEBUG((DEBUG_INFO, "FMP (%d) ImageInfo:\n", Index));
607 DumpFmpImageInfo(
608 ImageInfoSize, // ImageInfoSize
609 FmpImageInfoBuf, // ImageInfo
610 FmpImageInfoDescriptorVer, // DescriptorVersion
611 FmpImageInfoCount, // DescriptorCount
612 DescriptorSize, // DescriptorSize
613 PackageVersion, // PackageVersion
614 PackageVersionName // PackageVersionName
615 );
616
617 if (PackageVersionName != NULL) {
618 FreePool(PackageVersionName);
619 }
620
621 FreePool(FmpImageInfoBuf);
622 }
623
624 FreePool (HandleBuffer);
625
626 return ;
627}
628
629/**
630 Get FMP handle by ImageTypeId and HardwareInstance.
631
632 @param[in] UpdateImageTypeId Used to identify device firmware targeted by this update.
633 @param[in] UpdateHardwareInstance The HardwareInstance to target with this update.
634 @param[out] NoHandles The number of handles returned in HandleBuf.
635 @param[out] HandleBuf A pointer to the buffer to return the requested array of handles.
636 @param[out] ResetRequiredBuf A pointer to the buffer to return reset required flag for
637 the requested array of handles.
638
639 @retval EFI_SUCCESS The array of handles and their reset required flag were returned in
640 HandleBuf and ResetRequiredBuf, and the number of handles in HandleBuf
641 was returned in NoHandles.
642 @retval EFI_NOT_FOUND No handles match the search.
643 @retval EFI_OUT_OF_RESOURCES There is not enough pool memory to store the matching results.
644**/
645EFI_STATUS
646GetFmpHandleBufferByType (
647 IN EFI_GUID *UpdateImageTypeId,
648 IN UINT64 UpdateHardwareInstance,
649 OUT UINTN *NoHandles, OPTIONAL
650 OUT EFI_HANDLE **HandleBuf, OPTIONAL
651 OUT BOOLEAN **ResetRequiredBuf OPTIONAL
652 )
653{
654 EFI_STATUS Status;
655 EFI_HANDLE *HandleBuffer;
656 UINTN NumberOfHandles;
657 EFI_HANDLE *MatchedHandleBuffer;
658 BOOLEAN *MatchedResetRequiredBuffer;
659 UINTN MatchedNumberOfHandles;
660 EFI_FIRMWARE_MANAGEMENT_PROTOCOL *Fmp;
661 UINTN Index;
662 UINTN ImageInfoSize;
663 EFI_FIRMWARE_IMAGE_DESCRIPTOR *FmpImageInfoBuf;
664 UINT32 FmpImageInfoDescriptorVer;
665 UINT8 FmpImageInfoCount;
666 UINTN DescriptorSize;
667 UINT32 PackageVersion;
668 CHAR16 *PackageVersionName;
669 UINTN Index2;
670 EFI_FIRMWARE_IMAGE_DESCRIPTOR *TempFmpImageInfo;
671
672 if (NoHandles != NULL) {
673 *NoHandles = 0;
674 }
675 if (HandleBuf != NULL) {
676 *HandleBuf = NULL;
677 }
678 if (ResetRequiredBuf != NULL) {
679 *ResetRequiredBuf = NULL;
680 }
681
682 Status = gBS->LocateHandleBuffer (
683 ByProtocol,
684 &gEfiFirmwareManagementProtocolGuid,
685 NULL,
686 &NumberOfHandles,
687 &HandleBuffer
688 );
689 if (EFI_ERROR(Status)) {
690 return Status;
691 }
692
693 MatchedNumberOfHandles = 0;
694
695 MatchedHandleBuffer = NULL;
696 if (HandleBuf != NULL) {
697 MatchedHandleBuffer = AllocateZeroPool (sizeof(EFI_HANDLE) * NumberOfHandles);
698 if (MatchedHandleBuffer == NULL) {
699 FreePool (HandleBuffer);
700 return EFI_OUT_OF_RESOURCES;
701 }
702 }
703
704 MatchedResetRequiredBuffer = NULL;
705 if (ResetRequiredBuf != NULL) {
706 MatchedResetRequiredBuffer = AllocateZeroPool (sizeof(BOOLEAN) * NumberOfHandles);
707 if (MatchedResetRequiredBuffer == NULL) {
708 if (MatchedHandleBuffer != NULL) {
709 FreePool (MatchedHandleBuffer);
710 }
711 FreePool (HandleBuffer);
712 return EFI_OUT_OF_RESOURCES;
713 }
714 }
715
716 for (Index = 0; Index < NumberOfHandles; Index++) {
717 Status = gBS->HandleProtocol(
718 HandleBuffer[Index],
719 &gEfiFirmwareManagementProtocolGuid,
720 (VOID **)&Fmp
721 );
722 if (EFI_ERROR(Status)) {
723 continue;
724 }
725
726 ImageInfoSize = 0;
727 Status = Fmp->GetImageInfo (
728 Fmp,
729 &ImageInfoSize,
730 NULL,
731 NULL,
732 NULL,
733 NULL,
734 NULL,
735 NULL
736 );
737 if (Status != EFI_BUFFER_TOO_SMALL) {
738 continue;
739 }
740
741 FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);
742 if (FmpImageInfoBuf == NULL) {
743 continue;
744 }
745
746 PackageVersionName = NULL;
747 Status = Fmp->GetImageInfo (
748 Fmp,
749 &ImageInfoSize, // ImageInfoSize
750 FmpImageInfoBuf, // ImageInfo
751 &FmpImageInfoDescriptorVer, // DescriptorVersion
752 &FmpImageInfoCount, // DescriptorCount
753 &DescriptorSize, // DescriptorSize
754 &PackageVersion, // PackageVersion
755 &PackageVersionName // PackageVersionName
756 );
757 if (EFI_ERROR(Status)) {
758 FreePool(FmpImageInfoBuf);
759 continue;
760 }
761
762 if (PackageVersionName != NULL) {
763 FreePool(PackageVersionName);
764 }
765
766 TempFmpImageInfo = FmpImageInfoBuf;
767 for (Index2 = 0; Index2 < FmpImageInfoCount; Index2++) {
768 //
769 // Check if this FMP instance matches
770 //
771 if (CompareGuid(UpdateImageTypeId, &TempFmpImageInfo->ImageTypeId)) {
772 if ((UpdateHardwareInstance == 0) ||
773 ((FmpImageInfoDescriptorVer >= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION) &&
774 (UpdateHardwareInstance == TempFmpImageInfo->HardwareInstance))) {
775 if (MatchedHandleBuffer != NULL) {
776 MatchedHandleBuffer[MatchedNumberOfHandles] = HandleBuffer[Index];
777 }
778 if (MatchedResetRequiredBuffer != NULL) {
779 MatchedResetRequiredBuffer[MatchedNumberOfHandles] = (((TempFmpImageInfo->AttributesSupported &
780 IMAGE_ATTRIBUTE_RESET_REQUIRED) != 0) &&
781 ((TempFmpImageInfo->AttributesSetting &
782 IMAGE_ATTRIBUTE_RESET_REQUIRED) != 0));
783 }
784 MatchedNumberOfHandles++;
785 break;
786 }
787 }
788 TempFmpImageInfo = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)((UINT8 *)TempFmpImageInfo + DescriptorSize);
789 }
790 FreePool(FmpImageInfoBuf);
791 }
792
793 FreePool (HandleBuffer);
794
795 if (MatchedNumberOfHandles == 0) {
796 return EFI_NOT_FOUND;
797 }
798
799 if (NoHandles != NULL) {
800 *NoHandles = MatchedNumberOfHandles;
801 }
802 if (HandleBuf != NULL) {
803 *HandleBuf = MatchedHandleBuffer;
804 }
805 if (ResetRequiredBuf != NULL) {
806 *ResetRequiredBuf = MatchedResetRequiredBuffer;
807 }
808
809 return EFI_SUCCESS;
810}
811
812/**
813 Return FmpImageInfoDescriptorVer by an FMP handle.
814
815 @param[in] Handle A FMP handle.
816
817 @return FmpImageInfoDescriptorVer associated with the FMP.
818**/
819UINT32
820GetFmpImageInfoDescriptorVer (
821 IN EFI_HANDLE Handle
822 )
823{
824 EFI_STATUS Status;
825 EFI_FIRMWARE_MANAGEMENT_PROTOCOL *Fmp;
826 UINTN ImageInfoSize;
827 EFI_FIRMWARE_IMAGE_DESCRIPTOR *FmpImageInfoBuf;
828 UINT32 FmpImageInfoDescriptorVer;
829 UINT8 FmpImageInfoCount;
830 UINTN DescriptorSize;
831 UINT32 PackageVersion;
832 CHAR16 *PackageVersionName;
833
834 Status = gBS->HandleProtocol(
835 Handle,
836 &gEfiFirmwareManagementProtocolGuid,
837 (VOID **)&Fmp
838 );
839 if (EFI_ERROR(Status)) {
840 return 0;
841 }
842
843 ImageInfoSize = 0;
844 Status = Fmp->GetImageInfo (
845 Fmp,
846 &ImageInfoSize,
847 NULL,
848 NULL,
849 NULL,
850 NULL,
851 NULL,
852 NULL
853 );
854 if (Status != EFI_BUFFER_TOO_SMALL) {
855 return 0;
856 }
857
858 FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);
859 if (FmpImageInfoBuf == NULL) {
860 return 0;
861 }
862
863 PackageVersionName = NULL;
864 Status = Fmp->GetImageInfo (
865 Fmp,
866 &ImageInfoSize, // ImageInfoSize
867 FmpImageInfoBuf, // ImageInfo
868 &FmpImageInfoDescriptorVer, // DescriptorVersion
869 &FmpImageInfoCount, // DescriptorCount
870 &DescriptorSize, // DescriptorSize
871 &PackageVersion, // PackageVersion
872 &PackageVersionName // PackageVersionName
873 );
874 if (EFI_ERROR(Status)) {
875 FreePool(FmpImageInfoBuf);
876 return 0;
877 }
878 return FmpImageInfoDescriptorVer;
879}
880
881/**
882 Set FMP image data.
883
884 @param[in] Handle A FMP handle.
885 @param[in] ImageHeader The payload image header.
886 @param[in] PayloadIndex The index of the payload.
887
888 @return The status of FMP->SetImage.
889**/
890EFI_STATUS
891SetFmpImageData (
892 IN EFI_HANDLE Handle,
893 IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader,
894 IN UINTN PayloadIndex
895 )
896{
897 EFI_STATUS Status;
898 EFI_FIRMWARE_MANAGEMENT_PROTOCOL *Fmp;
899 UINT8 *Image;
900 VOID *VendorCode;
901 CHAR16 *AbortReason;
902 EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS ProgressCallback;
903
904 Status = gBS->HandleProtocol(
905 Handle,
906 &gEfiFirmwareManagementProtocolGuid,
907 (VOID **)&Fmp
908 );
909 if (EFI_ERROR(Status)) {
910 return Status;
911 }
912
913 //
914 // Lookup Firmware Management Progress Protocol before SetImage() is called
915 // This is an optional protocol that may not be present on Handle.
916 //
917 Status = gBS->HandleProtocol (
918 Handle,
919 &gEdkiiFirmwareManagementProgressProtocolGuid,
920 (VOID **)&mFmpProgress
921 );
922 if (EFI_ERROR (Status)) {
923 mFmpProgress = NULL;
924 }
925
926 if (ImageHeader->Version >= EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) {
927 Image = (UINT8 *)(ImageHeader + 1);
928 } else {
929 //
930 // If the EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER is version 1,
931 // Header should exclude UpdateHardwareInstance field
932 //
933 Image = (UINT8 *)ImageHeader + OFFSET_OF(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, UpdateHardwareInstance);
934 }
935
936 if (ImageHeader->UpdateVendorCodeSize == 0) {
937 VendorCode = NULL;
938 } else {
939 VendorCode = Image + ImageHeader->UpdateImageSize;
940 }
941 AbortReason = NULL;
942 DEBUG((DEBUG_INFO, "Fmp->SetImage ...\n"));
943 DEBUG((DEBUG_INFO, "ImageTypeId - %g, ", &ImageHeader->UpdateImageTypeId));
944 DEBUG((DEBUG_INFO, "PayloadIndex - 0x%x, ", PayloadIndex));
945 DEBUG((DEBUG_INFO, "ImageIndex - 0x%x ", ImageHeader->UpdateImageIndex));
946 if (ImageHeader->Version >= EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) {
947 DEBUG((DEBUG_INFO, "(UpdateHardwareInstance - 0x%x)", ImageHeader->UpdateHardwareInstance));
948 }
949 DEBUG((DEBUG_INFO, "\n"));
950
951 //
952 // Before calling SetImage(), reset the progress bar to 0%
953 //
954 ProgressCallback = UpdateImageProgress;
955 Status = UpdateImageProgress (0);
956 if (EFI_ERROR (Status)) {
957 ProgressCallback = NULL;
958 }
959
960 Status = Fmp->SetImage(
961 Fmp,
962 ImageHeader->UpdateImageIndex, // ImageIndex
963 Image, // Image
964 ImageHeader->UpdateImageSize, // ImageSize
965 VendorCode, // VendorCode
966 ProgressCallback, // Progress
967 &AbortReason // AbortReason
968 );
969 //
970 // Set the progress bar to 100% after returning from SetImage()
971 //
972 if (ProgressCallback != NULL) {
973 UpdateImageProgress (100);
974 }
975
976 DEBUG((DEBUG_INFO, "Fmp->SetImage - %r\n", Status));
977 if (AbortReason != NULL) {
978 DEBUG ((DEBUG_ERROR, "%s\n", AbortReason));
979 FreePool(AbortReason);
980 }
981
982 //
983 // Clear mFmpProgress after SetImage() returns
984 //
985 mFmpProgress = NULL;
986
987 return Status;
988}
989
990/**
991 Start a UEFI image in the FMP payload.
992
993 @param[in] ImageBuffer A pointer to the memory location containing a copy of the image to be loaded..
994 @param[in] ImageSize The size in bytes of ImageBuffer.
995
996 @return The status of gBS->LoadImage and gBS->StartImage.
997**/
998EFI_STATUS
999StartFmpImage (
1000 IN VOID *ImageBuffer,
1001 IN UINTN ImageSize
1002 )
1003{
1004 MEMMAP_DEVICE_PATH MemMapNode;
1005 EFI_STATUS Status;
1006 EFI_HANDLE ImageHandle;
1007 EFI_DEVICE_PATH_PROTOCOL *DriverDevicePath;
1008 UINTN ExitDataSize;
1009
1010 SetDevicePathNodeLength (&MemMapNode.Header, sizeof (MemMapNode));
1011 MemMapNode.Header.Type = HARDWARE_DEVICE_PATH;
1012 MemMapNode.Header.SubType = HW_MEMMAP_DP;
1013 MemMapNode.MemoryType = EfiBootServicesCode;
1014 MemMapNode.StartingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)ImageBuffer;
1015 MemMapNode.EndingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)((UINT8 *)ImageBuffer + ImageSize - 1);
1016
1017 DriverDevicePath = AppendDevicePathNode (NULL, &MemMapNode.Header);
1018 if (DriverDevicePath == NULL) {
1019 return EFI_OUT_OF_RESOURCES;
1020 }
1021
1022 DEBUG((DEBUG_INFO, "FmpCapsule: LoadImage ...\n"));
1023 Status = gBS->LoadImage(
1024 FALSE,
1025 gImageHandle,
1026 DriverDevicePath,
1027 ImageBuffer,
1028 ImageSize,
1029 &ImageHandle
1030 );
1031 DEBUG((DEBUG_INFO, "FmpCapsule: LoadImage - %r\n", Status));
1032 if (EFI_ERROR(Status)) {
1033 FreePool(DriverDevicePath);
1034 return Status;
1035 }
1036
1037 DEBUG((DEBUG_INFO, "FmpCapsule: StartImage ...\n"));
1038 Status = gBS->StartImage(
1039 ImageHandle,
1040 &ExitDataSize,
1041 NULL
1042 );
1043 DEBUG((DEBUG_INFO, "FmpCapsule: StartImage - %r\n", Status));
1044 if (EFI_ERROR(Status)) {
1045 DEBUG ((DEBUG_ERROR, "Driver Return Status = %r\n", Status));
1046 }
1047
1048 FreePool(DriverDevicePath);
1049 return Status;
1050}
1051
1052/**
1053 Record FMP capsule status.
1054
1055 @param[in] Handle A FMP handle.
1056 @param[in] CapsuleHeader The capsule image header
1057 @param[in] CapsuleStatus The capsule process stauts
1058 @param[in] PayloadIndex FMP payload index
1059 @param[in] ImageHeader FMP image header
1060 @param[in] CapFileName Capsule file name
1061**/
1062VOID
1063RecordFmpCapsuleStatus (
1064 IN EFI_HANDLE Handle, OPTIONAL
1065 IN EFI_CAPSULE_HEADER *CapsuleHeader,
1066 IN EFI_STATUS CapsuleStatus,
1067 IN UINTN PayloadIndex,
1068 IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader,
1069 IN CHAR16 *CapFileName OPTIONAL
1070 )
1071{
1072 EFI_STATUS Status;
1073 EFI_DEVICE_PATH_PROTOCOL *FmpDevicePath;
1074 UINT32 FmpImageInfoDescriptorVer;
1075 EFI_STATUS StatusEsrt;
1076 ESRT_MANAGEMENT_PROTOCOL *EsrtProtocol;
1077 EFI_SYSTEM_RESOURCE_ENTRY EsrtEntry;
1078
1079 FmpDevicePath = NULL;
1080 if (Handle != NULL) {
1081 gBS->HandleProtocol(
1082 Handle,
1083 &gEfiDevicePathProtocolGuid,
1084 (VOID **)&FmpDevicePath
1085 );
1086 }
1087
1088 RecordFmpCapsuleStatusVariable (
1089 CapsuleHeader,
1090 CapsuleStatus,
1091 PayloadIndex,
1092 ImageHeader,
1093 FmpDevicePath,
1094 CapFileName
1095 );
1096
1097 //
1098 // Update corresponding ESRT entry LastAttemp Status
1099 //
1100 Status = gBS->LocateProtocol(&gEsrtManagementProtocolGuid, NULL, (VOID **)&EsrtProtocol);
1101 if (EFI_ERROR (Status)) {
1102 return ;
1103 }
1104
1105 if (Handle == NULL) {
1106 return ;
1107 }
1108
1109 //
1110 // Update EsrtEntry For V1, V2 FMP instance.
1111 // V3 FMP ESRT cache will be synced up through SyncEsrtFmp interface
1112 //
1113 FmpImageInfoDescriptorVer = GetFmpImageInfoDescriptorVer (Handle);
1114 if (FmpImageInfoDescriptorVer < EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION) {
1115 StatusEsrt = EsrtProtocol->GetEsrtEntry(&ImageHeader->UpdateImageTypeId, &EsrtEntry);
1116 if (!EFI_ERROR(StatusEsrt)){
1117 if (!EFI_ERROR(CapsuleStatus)) {
1118 EsrtEntry.LastAttemptStatus = LAST_ATTEMPT_STATUS_SUCCESS;
1119 } else {
1120 EsrtEntry.LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL;
1121 }
1122 EsrtEntry.LastAttemptVersion = 0;
1123 EsrtProtocol->UpdateEsrtEntry(&EsrtEntry);
1124 }
1125 }
1126}
1127
1128/**
1129 Process Firmware management protocol data capsule.
1130
1131 This function assumes the caller validated the capsule by using
1132 ValidateFmpCapsule(), so that all fields in EFI_CAPSULE_HEADER,
1133 EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER and
1134 EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER are correct.
1135
1136 This function need support nested FMP capsule.
1137
1138 @param[in] CapsuleHeader Points to a capsule header.
1139 @param[in] CapFileName Capsule file name.
1140 @param[out] ResetRequired Indicates whether reset is required or not.
1141
1142 @retval EFI_SUCESS Process Capsule Image successfully.
1143 @retval EFI_UNSUPPORTED Capsule image is not supported by the firmware.
1144 @retval EFI_VOLUME_CORRUPTED FV volume in the capsule is corrupted.
1145 @retval EFI_OUT_OF_RESOURCES Not enough memory.
1146 @retval EFI_NOT_READY No FMP protocol to handle this FMP capsule.
1147**/
1148EFI_STATUS
1149ProcessFmpCapsuleImage (
1150 IN EFI_CAPSULE_HEADER *CapsuleHeader,
1151 IN CHAR16 *CapFileName, OPTIONAL
1152 OUT BOOLEAN *ResetRequired OPTIONAL
1153 )
1154{
1155 EFI_STATUS Status;
1156 EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *FmpCapsuleHeader;
1157 EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader;
1158 UINT64 *ItemOffsetList;
1159 UINT32 ItemNum;
1160 UINTN Index;
1161 EFI_HANDLE *HandleBuffer;
1162 BOOLEAN *ResetRequiredBuffer;
1163 UINTN NumberOfHandles;
1164 UINTN DriverLen;
1165 UINT64 UpdateHardwareInstance;
1166 UINTN Index2;
1167 BOOLEAN NotReady;
1168 BOOLEAN Abort;
1169
1170 if (!IsFmpCapsuleGuid(&CapsuleHeader->CapsuleGuid)) {
1171 return ProcessFmpCapsuleImage ((EFI_CAPSULE_HEADER *)((UINTN)CapsuleHeader + CapsuleHeader->HeaderSize), CapFileName, ResetRequired);
1172 }
1173
1174 NotReady = FALSE;
1175 Abort = FALSE;
1176
1177 DumpFmpCapsule(CapsuleHeader);
1178
1179 FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *) ((UINT8 *) CapsuleHeader + CapsuleHeader->HeaderSize);
1180
1181 if (FmpCapsuleHeader->Version > EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION) {
1182 return EFI_INVALID_PARAMETER;
1183 }
1184 ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
1185
1186 ItemNum = FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount;
1187
1188 //
1189 // capsule in which driver count and payload count are both zero is not processed.
1190 //
1191 if (ItemNum == 0) {
1192 return EFI_SUCCESS;
1193 }
1194
1195 //
1196 // 1. Try to load & start all the drivers within capsule
1197 //
1198 for (Index = 0; Index < FmpCapsuleHeader->EmbeddedDriverCount; Index++) {
1199 if ((FmpCapsuleHeader->PayloadItemCount == 0) &&
1200 (Index == (UINTN)FmpCapsuleHeader->EmbeddedDriverCount - 1)) {
1201 //
1202 // When driver is last element in the ItemOffsetList array, the driver size is calculated by reference CapsuleImageSize in EFI_CAPSULE_HEADER
1203 //
1204 DriverLen = CapsuleHeader->CapsuleImageSize - CapsuleHeader->HeaderSize - (UINTN)ItemOffsetList[Index];
1205 } else {
1206 DriverLen = (UINTN)ItemOffsetList[Index + 1] - (UINTN)ItemOffsetList[Index];
1207 }
1208
1209 Status = StartFmpImage (
1210 (UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index],
1211 DriverLen
1212 );
1213 if (EFI_ERROR(Status)) {
1214 DEBUG ((DEBUG_ERROR, "Driver Return Status = %r\n", Status));
1215 return Status;
1216 }
1217 }
1218
1219 //
1220 // 2. Route payload to right FMP instance
1221 //
1222 DEBUG((DEBUG_INFO, "FmpCapsule: route payload to right FMP instance ...\n"));
1223
1224 DumpAllFmpInfo ();
1225
1226 //
1227 // Check all the payload entry in capsule payload list
1228 //
1229 for (Index = FmpCapsuleHeader->EmbeddedDriverCount; Index < ItemNum; Index++) {
1230 ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]);
1231
1232 UpdateHardwareInstance = 0;
1233 if (ImageHeader->Version >= EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) {
1234 UpdateHardwareInstance = ImageHeader->UpdateHardwareInstance;
1235 }
1236
1237 Status = GetFmpHandleBufferByType (
1238 &ImageHeader->UpdateImageTypeId,
1239 UpdateHardwareInstance,
1240 &NumberOfHandles,
1241 &HandleBuffer,
1242 &ResetRequiredBuffer
1243 );
1244 if (EFI_ERROR(Status) ||
1245 (HandleBuffer == NULL) ||
1246 (ResetRequiredBuffer == NULL)) {
1247 NotReady = TRUE;
1248 RecordFmpCapsuleStatus (
1249 NULL,
1250 CapsuleHeader,
1251 EFI_NOT_READY,
1252 Index - FmpCapsuleHeader->EmbeddedDriverCount,
1253 ImageHeader,
1254 CapFileName
1255 );
1256 continue;
1257 }
1258
1259 for (Index2 = 0; Index2 < NumberOfHandles; Index2++) {
1260 if (Abort) {
1261 RecordFmpCapsuleStatus (
1262 HandleBuffer[Index2],
1263 CapsuleHeader,
1264 EFI_ABORTED,
1265 Index - FmpCapsuleHeader->EmbeddedDriverCount,
1266 ImageHeader,
1267 CapFileName
1268 );
1269 continue;
1270 }
1271
1272 Status = SetFmpImageData (
1273 HandleBuffer[Index2],
1274 ImageHeader,
1275 Index - FmpCapsuleHeader->EmbeddedDriverCount
1276 );
1277 if (Status != EFI_SUCCESS) {
1278 Abort = TRUE;
1279 } else {
1280 if (ResetRequired != NULL) {
1281 *ResetRequired |= ResetRequiredBuffer[Index2];
1282 }
1283 }
1284
1285 RecordFmpCapsuleStatus (
1286 HandleBuffer[Index2],
1287 CapsuleHeader,
1288 Status,
1289 Index - FmpCapsuleHeader->EmbeddedDriverCount,
1290 ImageHeader,
1291 CapFileName
1292 );
1293 }
1294 if (HandleBuffer != NULL) {
1295 FreePool(HandleBuffer);
1296 }
1297 if (ResetRequiredBuffer != NULL) {
1298 FreePool(ResetRequiredBuffer);
1299 }
1300 }
1301
1302 if (NotReady) {
1303 return EFI_NOT_READY;
1304 }
1305
1306 //
1307 // always return SUCCESS to indicate this capsule is processed.
1308 // The status of SetImage is recorded in capsule result variable.
1309 //
1310 return EFI_SUCCESS;
1311}
1312
1313/**
1314 Return if there is a FMP header below capsule header.
1315
1316 @param[in] CapsuleHeader A pointer to EFI_CAPSULE_HEADER
1317
1318 @retval TRUE There is a FMP header below capsule header.
1319 @retval FALSE There is not a FMP header below capsule header
1320**/
1321BOOLEAN
1322IsNestedFmpCapsule (
1323 IN EFI_CAPSULE_HEADER *CapsuleHeader
1324 )
1325{
1326 EFI_STATUS Status;
1327 EFI_SYSTEM_RESOURCE_ENTRY *EsrtEntry;
1328 UINTN Index;
1329 BOOLEAN EsrtGuidFound;
1330 EFI_CAPSULE_HEADER *NestedCapsuleHeader;
1331 UINTN NestedCapsuleSize;
1332 ESRT_MANAGEMENT_PROTOCOL *EsrtProtocol;
1333 EFI_SYSTEM_RESOURCE_ENTRY Entry;
1334
1335 EsrtGuidFound = FALSE;
1336 if (mIsVirtualAddrConverted) {
1337 if(mEsrtTable != NULL) {
1338 EsrtEntry = (EFI_SYSTEM_RESOURCE_ENTRY *)(mEsrtTable + 1);
1339 for (Index = 0; Index < mEsrtTable->FwResourceCount ; Index++, EsrtEntry++) {
1340 if (CompareGuid(&EsrtEntry->FwClass, &CapsuleHeader->CapsuleGuid)) {
1341 EsrtGuidFound = TRUE;
1342 break;
1343 }
1344 }
1345 }
1346 } else {
1347 //
1348 // Check ESRT protocol
1349 //
1350 Status = gBS->LocateProtocol(&gEsrtManagementProtocolGuid, NULL, (VOID **)&EsrtProtocol);
1351 if (!EFI_ERROR(Status)) {
1352 Status = EsrtProtocol->GetEsrtEntry(&CapsuleHeader->CapsuleGuid, &Entry);
1353 if (!EFI_ERROR(Status)) {
1354 EsrtGuidFound = TRUE;
1355 }
1356 }
1357
1358 //
1359 // Check Firmware Management Protocols
1360 //
1361 if (!EsrtGuidFound) {
1362 Status = GetFmpHandleBufferByType (
1363 &CapsuleHeader->CapsuleGuid,
1364 0,
1365 NULL,
1366 NULL,
1367 NULL
1368 );
1369 if (!EFI_ERROR(Status)) {
1370 EsrtGuidFound = TRUE;
1371 }
1372 }
1373 }
1374 if (!EsrtGuidFound) {
1375 return FALSE;
1376 }
1377
1378 //
1379 // Check nested capsule header
1380 // FMP GUID after ESRT one
1381 //
1382 NestedCapsuleHeader = (EFI_CAPSULE_HEADER *)((UINT8 *)CapsuleHeader + CapsuleHeader->HeaderSize);
1383 NestedCapsuleSize = (UINTN)CapsuleHeader + CapsuleHeader->CapsuleImageSize - (UINTN)NestedCapsuleHeader;
1384 if (NestedCapsuleSize < sizeof(EFI_CAPSULE_HEADER)) {
1385 return FALSE;
1386 }
1387 if (!IsValidCapsuleHeader(NestedCapsuleHeader, NestedCapsuleSize)) {
1388 return FALSE;
1389 }
1390 if (!IsFmpCapsuleGuid(&NestedCapsuleHeader->CapsuleGuid)) {
1391 return FALSE;
1392 }
1393 DEBUG ((DEBUG_INFO, "IsNestedFmpCapsule\n"));
1394 return TRUE;
1395}
1396
1397/**
1398 Return if this FMP is a system FMP or a device FMP, based upon CapsuleHeader.
1399
1400 @param[in] CapsuleHeader A pointer to EFI_CAPSULE_HEADER
1401
1402 @retval TRUE It is a system FMP.
1403 @retval FALSE It is a device FMP.
1404**/
1405BOOLEAN
1406IsFmpCapsule (
1407 IN EFI_CAPSULE_HEADER *CapsuleHeader
1408 )
1409{
1410 if (IsFmpCapsuleGuid(&CapsuleHeader->CapsuleGuid)) {
1411 return TRUE;
1412 }
1413 if (IsNestedFmpCapsule(CapsuleHeader)) {
1414 return TRUE;
1415 }
1416 return FALSE;
1417}
1418
1419/**
1420 Those capsules supported by the firmwares.
1421
1422 Caution: This function may receive untrusted input.
1423
1424 @param[in] CapsuleHeader Points to a capsule header.
1425
1426 @retval EFI_SUCESS Input capsule is supported by firmware.
1427 @retval EFI_UNSUPPORTED Input capsule is not supported by the firmware.
1428 @retval EFI_INVALID_PARAMETER Input capsule layout is not correct
1429**/
1430EFI_STATUS
1431EFIAPI
1432SupportCapsuleImage (
1433 IN EFI_CAPSULE_HEADER *CapsuleHeader
1434 )
1435{
1436 //
1437 // check Display Capsule Guid
1438 //
1439 if (CompareGuid (&gWindowsUxCapsuleGuid, &CapsuleHeader->CapsuleGuid)) {
1440 return EFI_SUCCESS;
1441 }
1442
1443 //
1444 // Check capsule file name capsule
1445 //
1446 if (IsCapsuleNameCapsule(CapsuleHeader)) {
1447 return EFI_SUCCESS;
1448 }
1449
1450 if (IsFmpCapsule(CapsuleHeader)) {
1451 //
1452 // Fake capsule header is valid case in QueryCapsuleCpapbilities().
1453 //
1454 if (CapsuleHeader->HeaderSize == CapsuleHeader->CapsuleImageSize) {
1455 return EFI_SUCCESS;
1456 }
1457 //
1458 // Check layout of FMP capsule
1459 //
1460 return ValidateFmpCapsule(CapsuleHeader, NULL);
1461 }
1462 DEBUG((DEBUG_ERROR, "Unknown Capsule Guid - %g\n", &CapsuleHeader->CapsuleGuid));
1463 return EFI_UNSUPPORTED;
1464}
1465
1466/**
1467 The firmware implements to process the capsule image.
1468
1469 Caution: This function may receive untrusted input.
1470
1471 @param[in] CapsuleHeader Points to a capsule header.
1472 @param[in] CapFileName Capsule file name.
1473 @param[out] ResetRequired Indicates whether reset is required or not.
1474
1475 @retval EFI_SUCESS Process Capsule Image successfully.
1476 @retval EFI_UNSUPPORTED Capsule image is not supported by the firmware.
1477 @retval EFI_VOLUME_CORRUPTED FV volume in the capsule is corrupted.
1478 @retval EFI_OUT_OF_RESOURCES Not enough memory.
1479**/
1480EFI_STATUS
1481EFIAPI
1482ProcessThisCapsuleImage (
1483 IN EFI_CAPSULE_HEADER *CapsuleHeader,
1484 IN CHAR16 *CapFileName, OPTIONAL
1485 OUT BOOLEAN *ResetRequired OPTIONAL
1486 )
1487{
1488 EFI_STATUS Status;
1489
1490 if (SupportCapsuleImage (CapsuleHeader) != EFI_SUCCESS) {
1491 RecordCapsuleStatusVariable(CapsuleHeader, EFI_UNSUPPORTED);
1492 return EFI_UNSUPPORTED;
1493 }
1494
1495 //
1496 // Display image in firmware update display capsule
1497 //
1498 if (CompareGuid (&gWindowsUxCapsuleGuid, &CapsuleHeader->CapsuleGuid)) {
1499 DEBUG((DEBUG_INFO, "ProcessCapsuleImage for WindowsUxCapsule ...\n"));
1500 Status = DisplayCapsuleImage(CapsuleHeader);
1501 RecordCapsuleStatusVariable(CapsuleHeader, Status);
1502 return Status;
1503 }
1504
1505 //
1506 // Check FMP capsule layout
1507 //
1508 if (IsFmpCapsule (CapsuleHeader)) {
1509 DEBUG((DEBUG_INFO, "ProcessCapsuleImage for FmpCapsule ...\n"));
1510 DEBUG((DEBUG_INFO, "ValidateFmpCapsule ...\n"));
1511 Status = ValidateFmpCapsule(CapsuleHeader, NULL);
1512 DEBUG((DEBUG_INFO, "ValidateFmpCapsule - %r\n", Status));
1513 if (EFI_ERROR(Status)) {
1514 RecordCapsuleStatusVariable(CapsuleHeader, Status);
1515 return Status;
1516 }
1517
1518 //
1519 // Process EFI FMP Capsule
1520 //
1521 DEBUG((DEBUG_INFO, "ProcessFmpCapsuleImage ...\n"));
1522 Status = ProcessFmpCapsuleImage(CapsuleHeader, CapFileName, ResetRequired);
1523 DEBUG((DEBUG_INFO, "ProcessFmpCapsuleImage - %r\n", Status));
1524
1525 return Status;
1526 }
1527
1528 return EFI_UNSUPPORTED;
1529}
1530
1531/**
1532 The firmware implements to process the capsule image.
1533
1534 Caution: This function may receive untrusted input.
1535
1536 @param[in] CapsuleHeader Points to a capsule header.
1537
1538 @retval EFI_SUCESS Process Capsule Image successfully.
1539 @retval EFI_UNSUPPORTED Capsule image is not supported by the firmware.
1540 @retval EFI_VOLUME_CORRUPTED FV volume in the capsule is corrupted.
1541 @retval EFI_OUT_OF_RESOURCES Not enough memory.
1542**/
1543EFI_STATUS
1544EFIAPI
1545ProcessCapsuleImage (
1546 IN EFI_CAPSULE_HEADER *CapsuleHeader
1547 )
1548{
1549 return ProcessThisCapsuleImage (CapsuleHeader, NULL, NULL);
1550}
1551
1552/**
1553 Callback function executed when the EndOfDxe event group is signaled.
1554
1555 @param[in] Event Event whose notification function is being invoked.
1556 @param[in] Context The pointer to the notification function's context, which
1557 is implementation-dependent.
1558**/
1559VOID
1560EFIAPI
1561DxeCapsuleLibEndOfDxe (
1562 IN EFI_EVENT Event,
1563 IN VOID *Context
1564 )
1565{
1566 mDxeCapsuleLibEndOfDxe = TRUE;
1567}
1568
1569/**
1570 The constructor function.
1571
1572 @param[in] ImageHandle The firmware allocated handle for the EFI image.
1573 @param[in] SystemTable A pointer to the EFI System Table.
1574
1575 @retval EFI_SUCCESS The constructor successfully .
1576**/
1577EFI_STATUS
1578EFIAPI
1579DxeCapsuleLibConstructor (
1580 IN EFI_HANDLE ImageHandle,
1581 IN EFI_SYSTEM_TABLE *SystemTable
1582 )
1583{
1584 EFI_STATUS Status;
1585
1586 Status = gBS->CreateEventEx (
1587 EVT_NOTIFY_SIGNAL,
1588 TPL_CALLBACK,
1589 DxeCapsuleLibEndOfDxe,
1590 NULL,
1591 &gEfiEndOfDxeEventGroupGuid,
1592 &mDxeCapsuleLibEndOfDxeEvent
1593 );
1594 ASSERT_EFI_ERROR (Status);
1595
1596 InitCapsuleVariable();
1597
1598 return EFI_SUCCESS;
1599}
1600
1601/**
1602 The destructor function closes the End of DXE event.
1603
1604 @param ImageHandle The firmware allocated handle for the EFI image.
1605 @param SystemTable A pointer to the EFI System Table.
1606
1607 @retval EFI_SUCCESS The destructor completed successfully.
1608**/
1609EFI_STATUS
1610EFIAPI
1611DxeCapsuleLibDestructor (
1612 IN EFI_HANDLE ImageHandle,
1613 IN EFI_SYSTEM_TABLE *SystemTable
1614 )
1615{
1616 EFI_STATUS Status;
1617
1618 //
1619 // Close the End of DXE event.
1620 //
1621 Status = gBS->CloseEvent (mDxeCapsuleLibEndOfDxeEvent);
1622 ASSERT_EFI_ERROR (Status);
1623
1624 return EFI_SUCCESS;
1625}
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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