VirtualBox

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

Last change on this file since 105668 was 99404, checked in by vboxsync, 2 years ago

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

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